GrContext.h revision 2354f8432a7205571f04f9638a0018fb0b1fb282
1/* 2 * Copyright 2010 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8#ifndef GrContext_DEFINED 9#define GrContext_DEFINED 10 11#include "GrClipData.h" 12#include "GrColor.h" 13#include "GrPaint.h" 14#include "GrPathRendererChain.h" 15#include "GrRenderTarget.h" 16#include "GrTexture.h" 17#include "SkMatrix.h" 18#include "SkPathEffect.h" 19#include "SkTypes.h" 20 21class GrAARectRenderer; 22class GrAutoScratchTexture; 23class GrDrawState; 24class GrDrawTarget; 25class GrEffect; 26class GrFontCache; 27class GrGpu; 28class GrGpuTraceMarker; 29class GrIndexBuffer; 30class GrIndexBufferAllocPool; 31class GrInOrderDrawBuffer; 32class GrLayerCache; 33class GrOvalRenderer; 34class GrPath; 35class GrPathRenderer; 36class GrResourceEntry; 37class GrResourceCache; 38class GrStencilBuffer; 39class GrTestTarget; 40class GrTextContext; 41class GrTextureParams; 42class GrVertexBuffer; 43class GrVertexBufferAllocPool; 44class GrStrokeInfo; 45class GrSoftwarePathRenderer; 46class SkStrokeRec; 47 48class SK_API GrContext : public SkRefCnt { 49public: 50 SK_DECLARE_INST_COUNT(GrContext) 51 52 /** 53 * Creates a GrContext for a backend context. 54 */ 55 static GrContext* Create(GrBackend, GrBackendContext); 56 57 virtual ~GrContext(); 58 59 /** 60 * The GrContext normally assumes that no outsider is setting state 61 * within the underlying 3D API's context/device/whatever. This call informs 62 * the context that the state was modified and it should resend. Shouldn't 63 * be called frequently for good performance. 64 * The flag bits, state, is dpendent on which backend is used by the 65 * context, either GL or D3D (possible in future). 66 */ 67 void resetContext(uint32_t state = kAll_GrBackendState); 68 69 /** 70 * Callback function to allow classes to cleanup on GrContext destruction. 71 * The 'info' field is filled in with the 'info' passed to addCleanUp. 72 */ 73 typedef void (*PFCleanUpFunc)(const GrContext* context, void* info); 74 75 /** 76 * Add a function to be called from within GrContext's destructor. 77 * This gives classes a chance to free resources held on a per context basis. 78 * The 'info' parameter will be stored and passed to the callback function. 79 */ 80 void addCleanUp(PFCleanUpFunc cleanUp, void* info) { 81 CleanUpData* entry = fCleanUpData.push(); 82 83 entry->fFunc = cleanUp; 84 entry->fInfo = info; 85 } 86 87 /** 88 * Abandons all GPU resources and assumes the underlying backend 3D API 89 * context is not longer usable. Call this if you have lost the associated 90 * GPU context, and thus internal texture, buffer, etc. references/IDs are 91 * now invalid. Should be called even when GrContext is no longer going to 92 * be used for two reasons: 93 * 1) ~GrContext will not try to free the objects in the 3D API. 94 * 2) Any GrGpuResources created by this GrContext that outlive 95 * will be marked as invalid (GrGpuResource::wasDestroyed()) and 96 * when they're destroyed no 3D API calls will be made. 97 * Content drawn since the last GrContext::flush() may be lost. After this 98 * function is called the only valid action on the GrContext or 99 * GrGpuResources it created is to destroy them. 100 */ 101 void abandonContext(); 102 void contextDestroyed() { this->abandonContext(); } // legacy alias 103 104 /////////////////////////////////////////////////////////////////////////// 105 // Resource Cache 106 107 /** 108 * Return the current GPU resource cache limits. 109 * 110 * @param maxResources If non-null, returns maximum number of resources that 111 * can be held in the cache. 112 * @param maxResourceBytes If non-null, returns maximum number of bytes of 113 * video memory that can be held in the cache. 114 */ 115 void getResourceCacheLimits(int* maxResources, size_t* maxResourceBytes) const; 116 SK_ATTR_DEPRECATED("This function has been renamed to getResourceCacheLimits().") 117 void getTextureCacheLimits(int* maxTextures, size_t* maxTextureBytes) const { 118 this->getResourceCacheLimits(maxTextures, maxTextureBytes); 119 } 120 121 /** 122 * Gets the current GPU resource cache usage. 123 * 124 * @param resourceCount If non-null, returns the number of resources that are held in the 125 * cache. 126 * @param maxResourceBytes If non-null, returns the total number of bytes of video memory held 127 * in the cache. 128 */ 129 void getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const; 130 131 SK_ATTR_DEPRECATED("Use getResourceCacheUsage().") 132 size_t getGpuTextureCacheBytes() const { 133 size_t bytes; 134 this->getResourceCacheUsage(NULL, &bytes); 135 return bytes; 136 } 137 138 SK_ATTR_DEPRECATED("Use getResourceCacheUsage().") 139 int getGpuTextureCacheResourceCount() const { 140 int count; 141 this->getResourceCacheUsage(&count, NULL); 142 return count; 143 } 144 145 /** 146 * Specify the GPU resource cache limits. If the current cache exceeds either 147 * of these, it will be purged (LRU) to keep the cache within these limits. 148 * 149 * @param maxResources The maximum number of resources that can be held in 150 * the cache. 151 * @param maxResourceBytes The maximum number of bytes of video memory 152 * that can be held in the cache. 153 */ 154 void setResourceCacheLimits(int maxResources, size_t maxResourceBytes); 155 SK_ATTR_DEPRECATED("This function has been renamed to setResourceCacheLimits().") 156 void setTextureCacheLimits(int maxTextures, size_t maxTextureBytes) { 157 this->setResourceCacheLimits(maxTextures, maxTextureBytes); 158 } 159 160 /** 161 * Frees GPU created by the context. Can be called to reduce GPU memory 162 * pressure. 163 */ 164 void freeGpuResources(); 165 166 /** 167 * This method should be called whenever a GrResource is unreffed or 168 * switched from exclusive to non-exclusive. This 169 * gives the resource cache a chance to discard unneeded resources. 170 * Note: this entry point will be removed once totally ref-driven 171 * cache maintenance is implemented. 172 */ 173 void purgeCache(); 174 175 /** 176 * Purge all the unlocked resources from the cache. 177 * This entry point is mainly meant for timing texture uploads 178 * and is not defined in normal builds of Skia. 179 */ 180 void purgeAllUnlockedResources(); 181 182 /** 183 * Stores a custom resource in the cache, based on the specified key. 184 */ 185 void addResourceToCache(const GrResourceKey&, GrGpuResource*); 186 187 /** 188 * Finds a resource in the cache, based on the specified key. This is intended for use in 189 * conjunction with addResourceToCache(). The return value will be NULL if not found. The 190 * caller must balance with a call to unref(). 191 */ 192 GrGpuResource* findAndRefCachedResource(const GrResourceKey&); 193 194 /** 195 * Creates a new text rendering context that is optimal for the 196 * render target and the context. Caller assumes the ownership 197 * of the returned object. The returned object must be deleted 198 * before the context is destroyed. 199 */ 200 GrTextContext* createTextContext(GrRenderTarget*, 201 const SkDeviceProperties&, 202 bool enableDistanceFieldFonts); 203 204 /////////////////////////////////////////////////////////////////////////// 205 // Textures 206 207 /** 208 * Creates a new entry, based on the specified key and texture and returns it. The caller owns a 209 * ref on the returned texture which must be balanced by a call to unref. 210 * 211 * @param params The texture params used to draw a texture may help determine 212 * the cache entry used. (e.g. different versions may exist 213 * for different wrap modes on GPUs with limited NPOT 214 * texture support). NULL implies clamp wrap modes. 215 * @param desc Description of the texture properties. 216 * @param cacheID Cache-specific properties (e.g., texture gen ID) 217 * @param srcData Pointer to the pixel values. 218 * @param rowBytes The number of bytes between rows of the texture. Zero 219 * implies tightly packed rows. For compressed pixel configs, this 220 * field is ignored. 221 * @param cacheKey (optional) If non-NULL, we'll write the cache key we used to cacheKey. 222 */ 223 GrTexture* createTexture(const GrTextureParams* params, 224 const GrTextureDesc& desc, 225 const GrCacheID& cacheID, 226 const void* srcData, 227 size_t rowBytes, 228 GrResourceKey* cacheKey = NULL); 229 /** 230 * Search for an entry based on key and dimensions. If found, ref it and return it. The return 231 * value will be NULL if not found. The caller must balance with a call to unref. 232 * 233 * @param desc Description of the texture properties. 234 * @param cacheID Cache-specific properties (e.g., texture gen ID) 235 * @param params The texture params used to draw a texture may help determine 236 * the cache entry used. (e.g. different versions may exist 237 * for different wrap modes on GPUs with limited NPOT 238 * texture support). NULL implies clamp wrap modes. 239 */ 240 GrTexture* findAndRefTexture(const GrTextureDesc& desc, 241 const GrCacheID& cacheID, 242 const GrTextureParams* params); 243 /** 244 * Determines whether a texture is in the cache. If the texture is found it 245 * will not be locked or returned. This call does not affect the priority of 246 * the texture for deletion. 247 */ 248 bool isTextureInCache(const GrTextureDesc& desc, 249 const GrCacheID& cacheID, 250 const GrTextureParams* params) const; 251 252 /** 253 * Enum that determines how closely a returned scratch texture must match 254 * a provided GrTextureDesc. 255 */ 256 enum ScratchTexMatch { 257 /** 258 * Finds a texture that exactly matches the descriptor. 259 */ 260 kExact_ScratchTexMatch, 261 /** 262 * Finds a texture that approximately matches the descriptor. Will be 263 * at least as large in width and height as desc specifies. If desc 264 * specifies that texture is a render target then result will be a 265 * render target. If desc specifies a render target and doesn't set the 266 * no stencil flag then result will have a stencil. Format and aa level 267 * will always match. 268 */ 269 kApprox_ScratchTexMatch 270 }; 271 272 /** 273 * Returns a texture matching the desc. It's contents are unknown. Subsequent 274 * requests with the same descriptor are not guaranteed to return the same 275 * texture. The same texture is guaranteed not be returned again until it is 276 * unlocked. Call must be balanced with an unlockTexture() call. The caller 277 * owns a ref on the returned texture and must balance with a call to unref. 278 * 279 * Textures created by createAndLockTexture() hide the complications of 280 * tiling non-power-of-two textures on APIs that don't support this (e.g. 281 * unextended GLES2). Tiling a NPOT texture created by lockScratchTexture on 282 * such an API will create gaps in the tiling pattern. This includes clamp 283 * mode. (This may be addressed in a future update.) 284 */ 285 GrTexture* lockAndRefScratchTexture(const GrTextureDesc&, ScratchTexMatch match); 286 287 /** 288 * When done with an entry, call unlockScratchTexture(entry) on it, which returns 289 * it to the cache, where it may be purged. This does not unref the texture. 290 */ 291 void unlockScratchTexture(GrTexture* texture); 292 293 /** 294 * Creates a texture that is outside the cache. Does not count against 295 * cache's budget. 296 */ 297 GrTexture* createUncachedTexture(const GrTextureDesc& desc, 298 void* srcData, 299 size_t rowBytes); 300 301 /** 302 * Returns true if the specified use of an indexed texture is supported. 303 * Support may depend upon whether the texture params indicate that the 304 * texture will be tiled. Passing NULL for the texture params indicates 305 * clamp mode. 306 */ 307 bool supportsIndex8PixelConfig(const GrTextureParams*, 308 int width, 309 int height) const; 310 311 /** 312 * Return the max width or height of a texture supported by the current GPU. 313 */ 314 int getMaxTextureSize() const; 315 316 /** 317 * Temporarily override the true max texture size. Note: an override 318 * larger then the true max texture size will have no effect. 319 * This entry point is mainly meant for testing texture size dependent 320 * features and is only available if defined outside of Skia (see 321 * bleed GM. 322 */ 323 void setMaxTextureSizeOverride(int maxTextureSizeOverride); 324 325 /////////////////////////////////////////////////////////////////////////// 326 // Render targets 327 328 /** 329 * Sets the render target. 330 * @param target the render target to set. 331 */ 332 void setRenderTarget(GrRenderTarget* target) { 333 fRenderTarget.reset(SkSafeRef(target)); 334 } 335 336 /** 337 * Gets the current render target. 338 * @return the currently bound render target. 339 */ 340 const GrRenderTarget* getRenderTarget() const { return fRenderTarget.get(); } 341 GrRenderTarget* getRenderTarget() { return fRenderTarget.get(); } 342 343 /** 344 * Can the provided configuration act as a color render target? 345 */ 346 bool isConfigRenderable(GrPixelConfig config, bool withMSAA) const; 347 348 /** 349 * Return the max width or height of a render target supported by the 350 * current GPU. 351 */ 352 int getMaxRenderTargetSize() const; 353 354 /** 355 * Returns the max sample count for a render target. It will be 0 if MSAA 356 * is not supported. 357 */ 358 int getMaxSampleCount() const; 359 360 /** 361 * Returns the recommended sample count for a render target when using this 362 * context. 363 * 364 * @param config the configuration of the render target. 365 * @param dpi the display density in dots per inch. 366 * 367 * @return sample count that should be perform well and have good enough 368 * rendering quality for the display. Alternatively returns 0 if 369 * MSAA is not supported or recommended to be used by default. 370 */ 371 int getRecommendedSampleCount(GrPixelConfig config, SkScalar dpi) const; 372 373 /////////////////////////////////////////////////////////////////////////// 374 // Backend Surfaces 375 376 /** 377 * Wraps an existing texture with a GrTexture object. 378 * 379 * OpenGL: if the object is a texture Gr may change its GL texture params 380 * when it is drawn. 381 * 382 * @param desc description of the object to create. 383 * 384 * @return GrTexture object or NULL on failure. 385 */ 386 GrTexture* wrapBackendTexture(const GrBackendTextureDesc& desc); 387 388 /** 389 * Wraps an existing render target with a GrRenderTarget object. It is 390 * similar to wrapBackendTexture but can be used to draw into surfaces 391 * that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that 392 * the client will resolve to a texture). 393 * 394 * @param desc description of the object to create. 395 * 396 * @return GrTexture object or NULL on failure. 397 */ 398 GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc& desc); 399 400 /////////////////////////////////////////////////////////////////////////// 401 // Matrix state 402 403 /** 404 * Gets the current transformation matrix. 405 * @return the current matrix. 406 */ 407 const SkMatrix& getMatrix() const { return fViewMatrix; } 408 409 /** 410 * Sets the transformation matrix. 411 * @param m the matrix to set. 412 */ 413 void setMatrix(const SkMatrix& m) { fViewMatrix = m; } 414 415 /** 416 * Sets the current transformation matrix to identity. 417 */ 418 void setIdentityMatrix() { fViewMatrix.reset(); } 419 420 /** 421 * Concats the current matrix. The passed matrix is applied before the 422 * current matrix. 423 * @param m the matrix to concat. 424 */ 425 void concatMatrix(const SkMatrix& m) { fViewMatrix.preConcat(m); } 426 427 428 /////////////////////////////////////////////////////////////////////////// 429 // Clip state 430 /** 431 * Gets the current clip. 432 * @return the current clip. 433 */ 434 const GrClipData* getClip() const { return fClip; } 435 436 /** 437 * Sets the clip. 438 * @param clipData the clip to set. 439 */ 440 void setClip(const GrClipData* clipData) { fClip = clipData; } 441 442 /////////////////////////////////////////////////////////////////////////// 443 // Draws 444 445 /** 446 * Clear the entire or rect of the render target, ignoring any clips. 447 * @param rect the rect to clear or the whole thing if rect is NULL. 448 * @param color the color to clear to. 449 * @param canIgnoreRect allows partial clears to be converted to whole 450 * clears on platforms for which that is cheap 451 * @param target if non-NULL, the render target to clear otherwise clear 452 * the current render target 453 */ 454 void clear(const SkIRect* rect, GrColor color, bool canIgnoreRect, 455 GrRenderTarget* target = NULL); 456 457 /** 458 * Draw everywhere (respecting the clip) with the paint. 459 */ 460 void drawPaint(const GrPaint& paint); 461 462 /** 463 * Draw the rect using a paint. 464 * @param paint describes how to color pixels. 465 * @param strokeInfo the stroke information (width, join, cap), and. 466 * the dash information (intervals, count, phase). 467 * If strokeInfo == NULL, then the rect is filled. 468 * Otherwise, if stroke width == 0, then the stroke 469 * is always a single pixel thick, else the rect is 470 * mitered/beveled stroked based on stroke width. 471 * If the stroke is dashed the rect is sent to drawPath. 472 * @param matrix Optional matrix applied to the rect. Applied before 473 * context's matrix or the paint's matrix. 474 * The rects coords are used to access the paint (through texture matrix) 475 */ 476 void drawRect(const GrPaint& paint, 477 const SkRect&, 478 const GrStrokeInfo* strokeInfo = NULL, 479 const SkMatrix* matrix = NULL); 480 481 /** 482 * Maps a rect of local coordinates onto the a rect of destination 483 * coordinates. Each rect can optionally be transformed. The localRect 484 * is stretched over the dstRect. The dstRect is transformed by the 485 * context's matrix. Additional optional matrices for both rects can be 486 * provided by parameters. 487 * 488 * @param paint describes how to color pixels. 489 * @param dstRect the destination rect to draw. 490 * @param localRect rect of local coordinates to be mapped onto dstRect 491 * @param dstMatrix Optional matrix to transform dstRect. Applied before context's matrix. 492 * @param localMatrix Optional matrix to transform localRect. 493 */ 494 void drawRectToRect(const GrPaint& paint, 495 const SkRect& dstRect, 496 const SkRect& localRect, 497 const SkMatrix* dstMatrix = NULL, 498 const SkMatrix* localMatrix = NULL); 499 500 /** 501 * Draw a roundrect using a paint. 502 * 503 * @param paint describes how to color pixels. 504 * @param rrect the roundrect to draw 505 * @param strokeInfo the stroke information (width, join, cap) and 506 * the dash information (intervals, count, phase). 507 */ 508 void drawRRect(const GrPaint& paint, const SkRRect& rrect, const GrStrokeInfo& strokeInfo); 509 510 /** 511 * Shortcut for drawing an SkPath consisting of nested rrects using a paint. 512 * Does not support stroking. The result is undefined if outer does not contain 513 * inner. 514 * 515 * @param paint describes how to color pixels. 516 * @param outer the outer roundrect 517 * @param inner the inner roundrect 518 */ 519 void drawDRRect(const GrPaint& paint, const SkRRect& outer, const SkRRect& inner); 520 521 522 /** 523 * Draws a path. 524 * 525 * @param paint describes how to color pixels. 526 * @param path the path to draw 527 * @param strokeInfo the stroke information (width, join, cap) and 528 * the dash information (intervals, count, phase). 529 */ 530 void drawPath(const GrPaint& paint, const SkPath& path, const GrStrokeInfo& strokeInfo); 531 532 /** 533 * Draws vertices with a paint. 534 * 535 * @param paint describes how to color pixels. 536 * @param primitiveType primitives type to draw. 537 * @param vertexCount number of vertices. 538 * @param positions array of vertex positions, required. 539 * @param texCoords optional array of texture coordinates used 540 * to access the paint. 541 * @param colors optional array of per-vertex colors, supercedes 542 * the paint's color field. 543 * @param indices optional array of indices. If NULL vertices 544 * are drawn non-indexed. 545 * @param indexCount if indices is non-null then this is the 546 * number of indices. 547 */ 548 void drawVertices(const GrPaint& paint, 549 GrPrimitiveType primitiveType, 550 int vertexCount, 551 const SkPoint positions[], 552 const SkPoint texs[], 553 const GrColor colors[], 554 const uint16_t indices[], 555 int indexCount); 556 557 /** 558 * Draws an oval. 559 * 560 * @param paint describes how to color pixels. 561 * @param oval the bounding rect of the oval. 562 * @param strokeInfo the stroke information (width, join, cap) and 563 * the dash information (intervals, count, phase). 564 */ 565 void drawOval(const GrPaint& paint, 566 const SkRect& oval, 567 const GrStrokeInfo& strokeInfo); 568 569 /////////////////////////////////////////////////////////////////////////// 570 // Misc. 571 572 /** 573 * Flags that affect flush() behavior. 574 */ 575 enum FlushBits { 576 /** 577 * A client may reach a point where it has partially rendered a frame 578 * through a GrContext that it knows the user will never see. This flag 579 * causes the flush to skip submission of deferred content to the 3D API 580 * during the flush. 581 */ 582 kDiscard_FlushBit = 0x2, 583 }; 584 585 /** 586 * Call to ensure all drawing to the context has been issued to the 587 * underlying 3D API. 588 * @param flagsBitfield flags that control the flushing behavior. See 589 * FlushBits. 590 */ 591 void flush(int flagsBitfield = 0); 592 593 /** 594 * These flags can be used with the read/write pixels functions below. 595 */ 596 enum PixelOpsFlags { 597 /** The GrContext will not be flushed. This means that the read or write may occur before 598 previous draws have executed. */ 599 kDontFlush_PixelOpsFlag = 0x1, 600 /** The src for write or dst read is unpremultiplied. This is only respected if both the 601 config src and dst configs are an RGBA/BGRA 8888 format. */ 602 kUnpremul_PixelOpsFlag = 0x2, 603 }; 604 605 /** 606 * Reads a rectangle of pixels from a render target. 607 * @param target the render target to read from. NULL means the current render target. 608 * @param left left edge of the rectangle to read (inclusive) 609 * @param top top edge of the rectangle to read (inclusive) 610 * @param width width of rectangle to read in pixels. 611 * @param height height of rectangle to read in pixels. 612 * @param config the pixel config of the destination buffer 613 * @param buffer memory to read the rectangle into. 614 * @param rowBytes number of bytes bewtween consecutive rows. Zero means rows are tightly 615 * packed. 616 * @param pixelOpsFlags see PixelOpsFlags enum above. 617 * 618 * @return true if the read succeeded, false if not. The read can fail because of an unsupported 619 * pixel config or because no render target is currently set and NULL was passed for 620 * target. 621 */ 622 bool readRenderTargetPixels(GrRenderTarget* target, 623 int left, int top, int width, int height, 624 GrPixelConfig config, void* buffer, 625 size_t rowBytes = 0, 626 uint32_t pixelOpsFlags = 0); 627 628 /** 629 * Copy the src pixels [buffer, row bytes, pixel config] into a render target at the specified 630 * rectangle. 631 * @param target the render target to write into. NULL means the current render target. 632 * @param left left edge of the rectangle to write (inclusive) 633 * @param top top edge of the rectangle to write (inclusive) 634 * @param width width of rectangle to write in pixels. 635 * @param height height of rectangle to write in pixels. 636 * @param config the pixel config of the source buffer 637 * @param buffer memory to read the rectangle from. 638 * @param rowBytes number of bytes between consecutive rows. Zero means rows are tightly 639 * packed. 640 * @param pixelOpsFlags see PixelOpsFlags enum above. 641 * 642 * @return true if the write succeeded, false if not. The write can fail because of an 643 * unsupported combination of target and pixel configs. 644 */ 645 bool writeRenderTargetPixels(GrRenderTarget* target, 646 int left, int top, int width, int height, 647 GrPixelConfig config, const void* buffer, 648 size_t rowBytes = 0, 649 uint32_t pixelOpsFlags = 0); 650 651 /** 652 * Reads a rectangle of pixels from a texture. 653 * @param texture the texture to read from. 654 * @param left left edge of the rectangle to read (inclusive) 655 * @param top top edge of the rectangle to read (inclusive) 656 * @param width width of rectangle to read in pixels. 657 * @param height height of rectangle to read in pixels. 658 * @param config the pixel config of the destination buffer 659 * @param buffer memory to read the rectangle into. 660 * @param rowBytes number of bytes between consecutive rows. Zero means rows are tightly 661 * packed. 662 * @param pixelOpsFlags see PixelOpsFlags enum above. 663 * 664 * @return true if the read succeeded, false if not. The read can fail because of an unsupported 665 * pixel config. 666 */ 667 bool readTexturePixels(GrTexture* texture, 668 int left, int top, int width, int height, 669 GrPixelConfig config, void* buffer, 670 size_t rowBytes = 0, 671 uint32_t pixelOpsFlags = 0); 672 673 /** 674 * Writes a rectangle of pixels to a texture. 675 * @param texture the render target to read from. 676 * @param left left edge of the rectangle to write (inclusive) 677 * @param top top edge of the rectangle to write (inclusive) 678 * @param width width of rectangle to write in pixels. 679 * @param height height of rectangle to write in pixels. 680 * @param config the pixel config of the source buffer 681 * @param buffer memory to read pixels from 682 * @param rowBytes number of bytes between consecutive rows. Zero 683 * means rows are tightly packed. 684 * @param pixelOpsFlags see PixelOpsFlags enum above. 685 * @return true if the write succeeded, false if not. The write can fail because of an 686 * unsupported combination of texture and pixel configs. 687 */ 688 bool writeTexturePixels(GrTexture* texture, 689 int left, int top, int width, int height, 690 GrPixelConfig config, const void* buffer, 691 size_t rowBytes, 692 uint32_t pixelOpsFlags = 0); 693 694 /** 695 * Copies a rectangle of texels from src to dst. The size of dst is the size of the rectangle 696 * copied and topLeft is the position of the rect in src. The rectangle is clipped to src's 697 * bounds. 698 * @param src the texture to copy from. 699 * @param dst the render target to copy to. 700 * @param topLeft the point in src that will be copied to the top-left of dst. If NULL, 701 * (0, 0) will be used. 702 */ 703 void copyTexture(GrTexture* src, GrRenderTarget* dst, const SkIPoint* topLeft = NULL); 704 705 /** 706 * Resolves a render target that has MSAA. The intermediate MSAA buffer is 707 * down-sampled to the associated GrTexture (accessible via 708 * GrRenderTarget::asTexture()). Any pending draws to the render target will 709 * be executed before the resolve. 710 * 711 * This is only necessary when a client wants to access the object directly 712 * using the backend API directly. GrContext will detect when it must 713 * perform a resolve to a GrTexture used as the source of a draw or before 714 * reading pixels back from a GrTexture or GrRenderTarget. 715 */ 716 void resolveRenderTarget(GrRenderTarget*); 717 718 /** 719 * Provides a perfomance hint that the render target's contents are allowed 720 * to become undefined. 721 */ 722 void discardRenderTarget(GrRenderTarget*); 723 724#ifdef SK_DEVELOPER 725 void dumpFontCache() const; 726#endif 727 728 /////////////////////////////////////////////////////////////////////////// 729 // Helpers 730 731 class AutoRenderTarget : public ::SkNoncopyable { 732 public: 733 AutoRenderTarget(GrContext* context, GrRenderTarget* target) { 734 fPrevTarget = context->getRenderTarget(); 735 SkSafeRef(fPrevTarget); 736 context->setRenderTarget(target); 737 fContext = context; 738 } 739 AutoRenderTarget(GrContext* context) { 740 fPrevTarget = context->getRenderTarget(); 741 SkSafeRef(fPrevTarget); 742 fContext = context; 743 } 744 ~AutoRenderTarget() { 745 if (NULL != fContext) { 746 fContext->setRenderTarget(fPrevTarget); 747 } 748 SkSafeUnref(fPrevTarget); 749 } 750 private: 751 GrContext* fContext; 752 GrRenderTarget* fPrevTarget; 753 }; 754 755 /** 756 * Save/restore the view-matrix in the context. It can optionally adjust a paint to account 757 * for a coordinate system change. Here is an example of how the paint param can be used: 758 * 759 * A GrPaint is setup with GrEffects. The stages will have access to the pre-matrix source 760 * geometry positions when the draw is executed. Later on a decision is made to transform the 761 * geometry to device space on the CPU. The effects now need to know that the space in which 762 * the geometry will be specified has changed. 763 * 764 * Note that when restore is called (or in the destructor) the context's matrix will be 765 * restored. However, the paint will not be restored. The caller must make a copy of the 766 * paint if necessary. Hint: use SkTCopyOnFirstWrite if the AutoMatrix is conditionally 767 * initialized. 768 */ 769 class AutoMatrix : public ::SkNoncopyable { 770 public: 771 AutoMatrix() : fContext(NULL) {} 772 773 ~AutoMatrix() { this->restore(); } 774 775 /** 776 * Initializes by pre-concat'ing the context's current matrix with the preConcat param. 777 */ 778 void setPreConcat(GrContext* context, const SkMatrix& preConcat, GrPaint* paint = NULL) { 779 SkASSERT(NULL != context); 780 781 this->restore(); 782 783 fContext = context; 784 fMatrix = context->getMatrix(); 785 this->preConcat(preConcat, paint); 786 } 787 788 /** 789 * Sets the context's matrix to identity. Returns false if the inverse matrix is required to 790 * update a paint but the matrix cannot be inverted. 791 */ 792 bool setIdentity(GrContext* context, GrPaint* paint = NULL) { 793 SkASSERT(NULL != context); 794 795 this->restore(); 796 797 if (NULL != paint) { 798 if (!paint->localCoordChangeInverse(context->getMatrix())) { 799 return false; 800 } 801 } 802 fMatrix = context->getMatrix(); 803 fContext = context; 804 context->setIdentityMatrix(); 805 return true; 806 } 807 808 /** 809 * Replaces the context's matrix with a new matrix. Returns false if the inverse matrix is 810 * required to update a paint but the matrix cannot be inverted. 811 */ 812 bool set(GrContext* context, const SkMatrix& newMatrix, GrPaint* paint = NULL) { 813 if (NULL != paint) { 814 if (!this->setIdentity(context, paint)) { 815 return false; 816 } 817 this->preConcat(newMatrix, paint); 818 } else { 819 this->restore(); 820 fContext = context; 821 fMatrix = context->getMatrix(); 822 context->setMatrix(newMatrix); 823 } 824 return true; 825 } 826 827 /** 828 * If this has been initialized then the context's matrix will be further updated by 829 * pre-concat'ing the preConcat param. The matrix that will be restored remains unchanged. 830 * The paint is assumed to be relative to the context's matrix at the time this call is 831 * made, not the matrix at the time AutoMatrix was first initialized. In other words, this 832 * performs an incremental update of the paint. 833 */ 834 void preConcat(const SkMatrix& preConcat, GrPaint* paint = NULL) { 835 if (NULL != paint) { 836 paint->localCoordChange(preConcat); 837 } 838 fContext->concatMatrix(preConcat); 839 } 840 841 /** 842 * Returns false if never initialized or the inverse matrix was required to update a paint 843 * but the matrix could not be inverted. 844 */ 845 bool succeeded() const { return NULL != fContext; } 846 847 /** 848 * If this has been initialized then the context's original matrix is restored. 849 */ 850 void restore() { 851 if (NULL != fContext) { 852 fContext->setMatrix(fMatrix); 853 fContext = NULL; 854 } 855 } 856 857 private: 858 GrContext* fContext; 859 SkMatrix fMatrix; 860 }; 861 862 class AutoClip : public ::SkNoncopyable { 863 public: 864 // This enum exists to require a caller of the constructor to acknowledge that the clip will 865 // initially be wide open. It also could be extended if there are other desirable initial 866 // clip states. 867 enum InitialClip { 868 kWideOpen_InitialClip, 869 }; 870 871 AutoClip(GrContext* context, InitialClip initialState) 872 : fContext(context) { 873 SkASSERT(kWideOpen_InitialClip == initialState); 874 fNewClipData.fClipStack = &fNewClipStack; 875 876 fOldClip = context->getClip(); 877 context->setClip(&fNewClipData); 878 } 879 880 AutoClip(GrContext* context, const SkRect& newClipRect) 881 : fContext(context) 882 , fNewClipStack(newClipRect) { 883 fNewClipData.fClipStack = &fNewClipStack; 884 885 fOldClip = fContext->getClip(); 886 fContext->setClip(&fNewClipData); 887 } 888 889 ~AutoClip() { 890 if (NULL != fContext) { 891 fContext->setClip(fOldClip); 892 } 893 } 894 private: 895 GrContext* fContext; 896 const GrClipData* fOldClip; 897 898 SkClipStack fNewClipStack; 899 GrClipData fNewClipData; 900 }; 901 902 class AutoWideOpenIdentityDraw { 903 public: 904 AutoWideOpenIdentityDraw(GrContext* ctx, GrRenderTarget* rt) 905 : fAutoClip(ctx, AutoClip::kWideOpen_InitialClip) 906 , fAutoRT(ctx, rt) { 907 fAutoMatrix.setIdentity(ctx); 908 // should never fail with no paint param. 909 SkASSERT(fAutoMatrix.succeeded()); 910 } 911 912 private: 913 AutoClip fAutoClip; 914 AutoRenderTarget fAutoRT; 915 AutoMatrix fAutoMatrix; 916 }; 917 918 /////////////////////////////////////////////////////////////////////////// 919 // Functions intended for internal use only. 920 GrGpu* getGpu() { return fGpu; } 921 const GrGpu* getGpu() const { return fGpu; } 922 GrFontCache* getFontCache() { return fFontCache; } 923 GrLayerCache* getLayerCache() { return fLayerCache.get(); } 924 GrDrawTarget* getTextTarget(); 925 const GrIndexBuffer* getQuadIndexBuffer() const; 926 GrAARectRenderer* getAARectRenderer() { return fAARectRenderer; } 927 928 // Called by tests that draw directly to the context via GrDrawTarget 929 void getTestTarget(GrTestTarget*); 930 931 // Functions for managing gpu trace markers 932 bool isGpuTracingEnabled() const { return fGpuTracingEnabled; } 933 void enableGpuTracing() { fGpuTracingEnabled = true; } 934 void disableGpuTracing() { fGpuTracingEnabled = false; } 935 936 void addGpuTraceMarker(const GrGpuTraceMarker* marker); 937 void removeGpuTraceMarker(const GrGpuTraceMarker* marker); 938 939 /** 940 * Stencil buffers add themselves to the cache using addStencilBuffer. findStencilBuffer is 941 * called to check the cache for a SB that matches an RT's criteria. 942 */ 943 void addStencilBuffer(GrStencilBuffer* sb); 944 GrStencilBuffer* findStencilBuffer(int width, int height, int sampleCnt); 945 946 GrPathRenderer* getPathRenderer( 947 const SkPath& path, 948 const SkStrokeRec& stroke, 949 const GrDrawTarget* target, 950 bool allowSW, 951 GrPathRendererChain::DrawType drawType = GrPathRendererChain::kColor_DrawType, 952 GrPathRendererChain::StencilSupport* stencilSupport = NULL); 953 954#if GR_CACHE_STATS 955 void printCacheStats() const; 956#endif 957 958private: 959 // Used to indicate whether a draw should be performed immediately or queued in fDrawBuffer. 960 enum BufferedDraw { 961 kYes_BufferedDraw, 962 kNo_BufferedDraw, 963 }; 964 BufferedDraw fLastDrawWasBuffered; 965 966 GrGpu* fGpu; 967 SkMatrix fViewMatrix; 968 SkAutoTUnref<GrRenderTarget> fRenderTarget; 969 const GrClipData* fClip; // TODO: make this ref counted 970 GrDrawState* fDrawState; 971 972 GrResourceCache* fResourceCache; 973 GrFontCache* fFontCache; 974 SkAutoTDelete<GrLayerCache> fLayerCache; 975 976 GrPathRendererChain* fPathRendererChain; 977 GrSoftwarePathRenderer* fSoftwarePathRenderer; 978 979 GrVertexBufferAllocPool* fDrawBufferVBAllocPool; 980 GrIndexBufferAllocPool* fDrawBufferIBAllocPool; 981 GrInOrderDrawBuffer* fDrawBuffer; 982 983 // Set by OverbudgetCB() to request that GrContext flush before exiting a draw. 984 bool fFlushToReduceCacheSize; 985 986 GrAARectRenderer* fAARectRenderer; 987 GrOvalRenderer* fOvalRenderer; 988 989 bool fDidTestPMConversions; 990 int fPMToUPMConversion; 991 int fUPMToPMConversion; 992 993 struct CleanUpData { 994 PFCleanUpFunc fFunc; 995 void* fInfo; 996 }; 997 998 SkTDArray<CleanUpData> fCleanUpData; 999 1000 int fMaxTextureSizeOverride; 1001 1002 bool fGpuTracingEnabled; 1003 1004 GrContext(); // init must be called after the constructor. 1005 bool init(GrBackend, GrBackendContext); 1006 1007 void setupDrawBuffer(); 1008 1009 class AutoRestoreEffects; 1010 class AutoCheckFlush; 1011 /// Sets the paint and returns the target to draw into. The paint can be NULL in which case the 1012 /// draw state is left unmodified. 1013 GrDrawTarget* prepareToDraw(const GrPaint*, BufferedDraw, AutoRestoreEffects*, AutoCheckFlush*); 1014 1015 void internalDrawPath(GrDrawTarget* target, bool useAA, const SkPath& path, 1016 const GrStrokeInfo& stroke); 1017 1018 GrTexture* createResizedTexture(const GrTextureDesc& desc, 1019 const GrCacheID& cacheID, 1020 const void* srcData, 1021 size_t rowBytes, 1022 bool filter); 1023 1024 // Needed so GrTexture's returnToCache helper function can call 1025 // addExistingTextureToCache 1026 friend class GrTexture; 1027 friend class GrStencilAndCoverPathRenderer; 1028 friend class GrStencilAndCoverTextContext; 1029 1030 // Add an existing texture to the texture cache. This is intended solely 1031 // for use with textures released from an GrAutoScratchTexture. 1032 void addExistingTextureToCache(GrTexture* texture); 1033 1034 /** 1035 * These functions create premul <-> unpremul effects if it is possible to generate a pair 1036 * of effects that make a readToUPM->writeToPM->readToUPM cycle invariant. Otherwise, they 1037 * return NULL. 1038 */ 1039 const GrEffect* createPMToUPMEffect(GrTexture* texture, 1040 bool swapRAndB, 1041 const SkMatrix& matrix); 1042 const GrEffect* createUPMToPMEffect(GrTexture* texture, 1043 bool swapRAndB, 1044 const SkMatrix& matrix); 1045 1046 /** 1047 * This callback allows the resource cache to callback into the GrContext 1048 * when the cache is still overbudget after a purge. 1049 */ 1050 static bool OverbudgetCB(void* data); 1051 1052 /** Creates a new gpu path, based on the specified path and stroke and returns it. 1053 * The caller owns a ref on the returned path which must be balanced by a call to unref. 1054 * 1055 * @param skPath the path geometry. 1056 * @param stroke the path stroke. 1057 * @return a new path or NULL if the operation is not supported by the backend. 1058 */ 1059 GrPath* createPath(const SkPath& skPath, const SkStrokeRec& stroke); 1060 1061 typedef SkRefCnt INHERITED; 1062}; 1063 1064/** 1065 * Gets and locks a scratch texture from a descriptor using either exact or approximate criteria. 1066 * Unlocks texture in the destructor. 1067 */ 1068class GrAutoScratchTexture : public ::SkNoncopyable { 1069public: 1070 GrAutoScratchTexture() 1071 : fContext(NULL) 1072 , fTexture(NULL) { 1073 } 1074 1075 GrAutoScratchTexture(GrContext* context, 1076 const GrTextureDesc& desc, 1077 GrContext::ScratchTexMatch match = GrContext::kApprox_ScratchTexMatch) 1078 : fContext(NULL) 1079 , fTexture(NULL) { 1080 this->set(context, desc, match); 1081 } 1082 1083 ~GrAutoScratchTexture() { 1084 this->reset(); 1085 } 1086 1087 void reset() { 1088 if (NULL != fContext && NULL != fTexture) { 1089 fContext->unlockScratchTexture(fTexture); 1090 fTexture->unref(); 1091 fTexture = NULL; 1092 } 1093 } 1094 1095 /* 1096 * When detaching a texture we do not unlock it in the texture cache but 1097 * we do set the returnToCache flag. In this way the texture remains 1098 * "locked" in the texture cache until it is freed and recycled in 1099 * GrTexture::internal_dispose. In reality, the texture has been removed 1100 * from the cache (because this is in AutoScratchTexture) and by not 1101 * calling unlockScratchTexture we simply don't re-add it. It will be 1102 * reattached in GrTexture::internal_dispose. 1103 * 1104 * Note that the caller is assumed to accept and manage the ref to the 1105 * returned texture. 1106 */ 1107 GrTexture* detach() { 1108 if (NULL == fTexture) { 1109 return NULL; 1110 } 1111 GrTexture* texture = fTexture; 1112 fTexture = NULL; 1113 1114 // This GrAutoScratchTexture has a ref from lockAndRefScratchTexture, which we give up now. 1115 // The cache also has a ref which we are lending to the caller of detach(). When the caller 1116 // lets go of the ref and the ref count goes to 0 internal_dispose will see this flag is 1117 // set and re-ref the texture, thereby restoring the cache's ref. 1118 SkASSERT(!texture->unique()); 1119 texture->impl()->setFlag((GrTextureFlags) GrTextureImpl::kReturnToCache_FlagBit); 1120 texture->unref(); 1121 SkASSERT(NULL != texture->getCacheEntry()); 1122 1123 return texture; 1124 } 1125 1126 GrTexture* set(GrContext* context, 1127 const GrTextureDesc& desc, 1128 GrContext::ScratchTexMatch match = GrContext::kApprox_ScratchTexMatch) { 1129 this->reset(); 1130 1131 fContext = context; 1132 if (NULL != fContext) { 1133 fTexture = fContext->lockAndRefScratchTexture(desc, match); 1134 if (NULL == fTexture) { 1135 fContext = NULL; 1136 } 1137 return fTexture; 1138 } else { 1139 return NULL; 1140 } 1141 } 1142 1143 GrTexture* texture() { return fTexture; } 1144 1145private: 1146 GrContext* fContext; 1147 GrTexture* fTexture; 1148}; 1149 1150#endif 1151