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