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