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