1 /* 2 * Copyright 2011 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 GrGpu_DEFINED 9 #define GrGpu_DEFINED 10 11 #include "GrPipelineBuilder.h" 12 #include "GrProgramDesc.h" 13 #include "GrStencil.h" 14 #include "GrSwizzle.h" 15 #include "GrTextureParamsAdjuster.h" 16 #include "GrXferProcessor.h" 17 #include "SkPath.h" 18 19 class GrBatchTracker; 20 class GrContext; 21 class GrGLContext; 22 class GrIndexBuffer; 23 class GrNonInstancedVertices; 24 class GrPath; 25 class GrPathRange; 26 class GrPathRenderer; 27 class GrPathRendererChain; 28 class GrPathRendering; 29 class GrPipeline; 30 class GrPrimitiveProcessor; 31 class GrRenderTarget; 32 class GrStencilAttachment; 33 class GrSurface; 34 class GrTexture; 35 class GrTransferBuffer; 36 class GrVertexBuffer; 37 class GrVertices; 38 39 class GrGpu : public SkRefCnt { 40 public: 41 /** 42 * Create an instance of GrGpu that matches the specified backend. If the requested backend is 43 * not supported (at compile-time or run-time) this returns nullptr. The context will not be 44 * fully constructed and should not be used by GrGpu until after this function returns. 45 */ 46 static GrGpu* Create(GrBackend, GrBackendContext, const GrContextOptions&, GrContext* context); 47 48 //////////////////////////////////////////////////////////////////////////// 49 50 GrGpu(GrContext* context); 51 ~GrGpu() override; 52 53 GrContext* getContext() { return fContext; } 54 const GrContext* getContext() const { return fContext; } 55 56 /** 57 * Gets the capabilities of the draw target. 58 */ 59 const GrCaps* caps() const { return fCaps.get(); } 60 61 GrPathRendering* pathRendering() { return fPathRendering.get(); } 62 63 // Called by GrContext when the underlying backend context has been destroyed. 64 // GrGpu should use this to ensure that no backend API calls will be made from 65 // here onward, including in its destructor. Subclasses should call 66 // INHERITED::contextAbandoned() if they override this. 67 virtual void contextAbandoned(); 68 69 /** 70 * The GrGpu object normally assumes that no outsider is setting state 71 * within the underlying 3D API's context/device/whatever. This call informs 72 * the GrGpu that the state was modified and it shouldn't make assumptions 73 * about the state. 74 */ 75 void markContextDirty(uint32_t state = kAll_GrBackendState) { fResetBits |= state; } 76 77 /** 78 * Creates a texture object. If kRenderTarget_GrSurfaceFlag the texture can 79 * be used as a render target by calling GrTexture::asRenderTarget(). Not all 80 * pixel configs can be used as render targets. Support for configs as textures 81 * or render targets can be checked using GrCaps. 82 * 83 * @param desc describes the texture to be created. 84 * @param budgeted does this texture count against the resource cache budget? 85 * @param srcData texel data to load texture. Begins with full-size 86 * palette data for paletted textures. For compressed 87 * formats it contains the compressed pixel data. Otherwise, 88 * it contains width*height texels. If nullptr texture data 89 * is uninitialized. 90 * @param rowBytes the number of bytes between consecutive rows. Zero 91 * means rows are tightly packed. This field is ignored 92 * for compressed formats. 93 * 94 * @return The texture object if successful, otherwise nullptr. 95 */ 96 GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, 97 const void* srcData, size_t rowBytes); 98 99 /** 100 * Implements GrTextureProvider::wrapBackendTexture 101 */ 102 GrTexture* wrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership); 103 104 /** 105 * Implements GrTextureProvider::wrapBackendRenderTarget 106 */ 107 GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc&, GrWrapOwnership); 108 109 /** 110 * Implements GrTextureProvider::wrapBackendTextureAsRenderTarget 111 */ 112 GrRenderTarget* wrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&, GrWrapOwnership); 113 114 /** 115 * Creates a vertex buffer. 116 * 117 * @param size size in bytes of the vertex buffer 118 * @param dynamic hints whether the data will be frequently changed 119 * by either GrVertexBuffer::map() or 120 * GrVertexBuffer::updateData(). 121 * 122 * @return The vertex buffer if successful, otherwise nullptr. 123 */ 124 GrVertexBuffer* createVertexBuffer(size_t size, bool dynamic); 125 126 /** 127 * Creates an index buffer. 128 * 129 * @param size size in bytes of the index buffer 130 * @param dynamic hints whether the data will be frequently changed 131 * by either GrIndexBuffer::map() or 132 * GrIndexBuffer::updateData(). 133 * 134 * @return The index buffer if successful, otherwise nullptr. 135 */ 136 GrIndexBuffer* createIndexBuffer(size_t size, bool dynamic); 137 138 /** 139 * Creates a transfer buffer. 140 * 141 * @param size size in bytes of the index buffer 142 * @param toGpu true if used to transfer from the cpu to the gpu 143 * otherwise to be used to transfer from the gpu to the cpu 144 * 145 * @return The transfer buffer if successful, otherwise nullptr. 146 */ 147 GrTransferBuffer* createTransferBuffer(size_t size, TransferType type); 148 149 /** 150 * Resolves MSAA. 151 */ 152 void resolveRenderTarget(GrRenderTarget* target); 153 154 /** Info struct returned by getReadPixelsInfo about performing intermediate draws before 155 reading pixels for performance or correctness. */ 156 struct ReadPixelTempDrawInfo { 157 /** If the GrGpu is requesting that the caller do a draw to an intermediate surface then 158 this is descriptor for the temp surface. The draw should always be a rect with 159 dst 0,0,w,h. */ 160 GrSurfaceDesc fTempSurfaceDesc; 161 /** Indicates whether there is a performance advantage to using an exact match texture 162 (in terms of width and height) for the intermediate texture instead of approximate. */ 163 bool fUseExactScratch; 164 /** Swizzle to apply during the draw. This is used to compensate for either feature or 165 performance limitations in the underlying 3D API. */ 166 GrSwizzle fSwizzle; 167 /** The config that should be used to read from the temp surface after the draw. This may be 168 different than the original read config in order to compensate for swizzling. The 169 read data will effectively be in the original read config. */ 170 GrPixelConfig fReadConfig; 171 }; 172 173 /** Describes why an intermediate draw must/should be performed before readPixels. */ 174 enum DrawPreference { 175 /** On input means that the caller would proceed without draw if the GrGpu doesn't request 176 one. 177 On output means that the GrGpu is not requesting a draw. */ 178 kNoDraw_DrawPreference, 179 /** Means that the client would prefer a draw for performance of the readback but 180 can satisfy a straight readPixels call on the inputs without an intermediate draw. 181 getReadPixelsInfo will never set the draw preference to this value but may leave 182 it set. */ 183 kCallerPrefersDraw_DrawPreference, 184 /** On output means that GrGpu would prefer a draw for performance of the readback but 185 can satisfy a straight readPixels call on the inputs without an intermediate draw. The 186 caller of getReadPixelsInfo should never specify this on intput. */ 187 kGpuPrefersDraw_DrawPreference, 188 /** On input means that the caller requires a draw to do a transformation and there is no 189 CPU fallback. 190 On output means that GrGpu can only satisfy the readPixels request if the intermediate 191 draw is performed. 192 */ 193 kRequireDraw_DrawPreference 194 }; 195 196 /** 197 * Used to negotiate whether and how an intermediate draw should or must be performed before 198 * a readPixels call. If this returns false then GrGpu could not deduce an intermediate draw 199 * that would allow a successful readPixels call. The passed width, height, and rowBytes, 200 * must be non-zero and already reflect clipping to the src bounds. 201 */ 202 bool getReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes, 203 GrPixelConfig readConfig, DrawPreference*, ReadPixelTempDrawInfo*); 204 205 /** Info struct returned by getWritePixelsInfo about performing an intermediate draw in order 206 to write pixels to a GrSurface for either performance or correctness reasons. */ 207 struct WritePixelTempDrawInfo { 208 /** If the GrGpu is requesting that the caller upload to an intermediate surface and draw 209 that to the dst then this is the descriptor for the intermediate surface. The caller 210 should upload the pixels such that the upper left pixel of the upload rect is at 0,0 in 211 the intermediate surface.*/ 212 GrSurfaceDesc fTempSurfaceDesc; 213 /** Swizzle to apply during the draw. This is used to compensate for either feature or 214 performance limitations in the underlying 3D API. */ 215 GrSwizzle fSwizzle; 216 /** The config that should be specified when uploading the *original* data to the temp 217 surface before the draw. This may be different than the original src data config in 218 order to compensate for swizzling that will occur when drawing. */ 219 GrPixelConfig fWriteConfig; 220 }; 221 222 /** 223 * Used to negotiate whether and how an intermediate surface should be used to write pixels to 224 * a GrSurface. If this returns false then GrGpu could not deduce an intermediate draw 225 * that would allow a successful transfer of the src pixels to the dst. The passed width, 226 * height, and rowBytes, must be non-zero and already reflect clipping to the dst bounds. 227 */ 228 bool getWritePixelsInfo(GrSurface* dstSurface, int width, int height, 229 GrPixelConfig srcConfig, DrawPreference*, WritePixelTempDrawInfo*); 230 231 /** 232 * Reads a rectangle of pixels from a render target. 233 * 234 * @param surface The surface to read from 235 * @param left left edge of the rectangle to read (inclusive) 236 * @param top top edge of the rectangle to read (inclusive) 237 * @param width width of rectangle to read in pixels. 238 * @param height height of rectangle to read in pixels. 239 * @param config the pixel config of the destination buffer 240 * @param buffer memory to read the rectangle into. 241 * @param rowBytes the number of bytes between consecutive rows. Zero 242 * means rows are tightly packed. 243 * @param invertY buffer should be populated bottom-to-top as opposed 244 * to top-to-bottom (skia's usual order) 245 * 246 * @return true if the read succeeded, false if not. The read can fail 247 * because of a unsupported pixel config or because no render 248 * target is currently set. 249 */ 250 bool readPixels(GrSurface* surface, 251 int left, int top, int width, int height, 252 GrPixelConfig config, void* buffer, size_t rowBytes); 253 254 /** 255 * Updates the pixels in a rectangle of a surface. 256 * 257 * @param surface The surface to write to. 258 * @param left left edge of the rectangle to write (inclusive) 259 * @param top top edge of the rectangle to write (inclusive) 260 * @param width width of rectangle to write in pixels. 261 * @param height height of rectangle to write in pixels. 262 * @param config the pixel config of the source buffer 263 * @param buffer memory to read pixels from 264 * @param rowBytes number of bytes between consecutive rows. Zero 265 * means rows are tightly packed. 266 */ 267 bool writePixels(GrSurface* surface, 268 int left, int top, int width, int height, 269 GrPixelConfig config, const void* buffer, 270 size_t rowBytes); 271 272 /** 273 * Updates the pixels in a rectangle of a surface using a GrTransferBuffer 274 * 275 * @param surface The surface to write to. 276 * @param left left edge of the rectangle to write (inclusive) 277 * @param top top edge of the rectangle to write (inclusive) 278 * @param width width of rectangle to write in pixels. 279 * @param height height of rectangle to write in pixels. 280 * @param config the pixel config of the source buffer 281 * @param buffer GrTransferBuffer to read pixels from 282 * @param offset offset from the start of the buffer 283 * @param rowBytes number of bytes between consecutive rows. Zero 284 * means rows are tightly packed. 285 */ 286 bool transferPixels(GrSurface* surface, 287 int left, int top, int width, int height, 288 GrPixelConfig config, GrTransferBuffer* buffer, 289 size_t offset, size_t rowBytes); 290 291 /** 292 * Clear the passed in render target. Ignores the draw state and clip. 293 */ 294 void clear(const SkIRect& rect, GrColor color, GrRenderTarget* renderTarget); 295 296 297 void clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* renderTarget); 298 299 /** 300 * Discards the contents render target. nullptr indicates that the current render target should 301 * be discarded. 302 **/ 303 virtual void discard(GrRenderTarget* = nullptr) = 0; 304 305 /** 306 * This is can be called before allocating a texture to be a dst for copySurface. It will 307 * populate the origin, config, and flags fields of the desc such that copySurface can 308 * efficiently succeed. It should only succeed if it can allow copySurface to perform a copy 309 * that would be more effecient than drawing the src to a dst render target. 310 */ 311 virtual bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) const = 0; 312 313 // After the client interacts directly with the 3D context state the GrGpu 314 // must resync its internal state and assumptions about 3D context state. 315 // Each time this occurs the GrGpu bumps a timestamp. 316 // state of the 3D context 317 // At 10 resets / frame and 60fps a 64bit timestamp will overflow in about 318 // a billion years. 319 typedef uint64_t ResetTimestamp; 320 321 // This timestamp is always older than the current timestamp 322 static const ResetTimestamp kExpiredTimestamp = 0; 323 // Returns a timestamp based on the number of times the context was reset. 324 // This timestamp can be used to lazily detect when cached 3D context state 325 // is dirty. 326 ResetTimestamp getResetTimestamp() const { return fResetTimestamp; } 327 328 virtual void buildProgramDesc(GrProgramDesc*, 329 const GrPrimitiveProcessor&, 330 const GrPipeline&) const = 0; 331 332 // Called to perform a surface to surface copy. Fallbacks to issuing a draw from the src to dst 333 // take place at the GrDrawTarget level and this function implement faster copy paths. The rect 334 // and point are pre-clipped. The src rect and implied dst rect are guaranteed to be within the 335 // src/dst bounds and non-empty. 336 bool copySurface(GrSurface* dst, 337 GrSurface* src, 338 const SkIRect& srcRect, 339 const SkIPoint& dstPoint); 340 341 struct DrawArgs { 342 DrawArgs(const GrPrimitiveProcessor* primProc, 343 const GrPipeline* pipeline, 344 const GrProgramDesc* desc) 345 : fPrimitiveProcessor(primProc) 346 , fPipeline(pipeline) 347 , fDesc(desc) { 348 SkASSERT(primProc && pipeline && desc); 349 } 350 const GrPrimitiveProcessor* fPrimitiveProcessor; 351 const GrPipeline* fPipeline; 352 const GrProgramDesc* fDesc; 353 }; 354 355 void draw(const DrawArgs&, const GrVertices&); 356 357 // Called by drawtarget when flushing. 358 // Provides a hook for post-flush actions (e.g. PLS reset and Vulkan command buffer submits). 359 virtual void finishDrawTarget() {} 360 361 /////////////////////////////////////////////////////////////////////////// 362 // Debugging and Stats 363 364 class Stats { 365 public: 366 #if GR_GPU_STATS 367 Stats() { this->reset(); } 368 369 void reset() { 370 fRenderTargetBinds = 0; 371 fShaderCompilations = 0; 372 fTextureCreates = 0; 373 fTextureUploads = 0; 374 fTransfersToTexture = 0; 375 fStencilAttachmentCreates = 0; 376 fNumDraws = 0; 377 } 378 379 int renderTargetBinds() const { return fRenderTargetBinds; } 380 void incRenderTargetBinds() { fRenderTargetBinds++; } 381 int shaderCompilations() const { return fShaderCompilations; } 382 void incShaderCompilations() { fShaderCompilations++; } 383 int textureCreates() const { return fTextureCreates; } 384 void incTextureCreates() { fTextureCreates++; } 385 int textureUploads() const { return fTextureUploads; } 386 void incTextureUploads() { fTextureUploads++; } 387 int transfersToTexture() const { return fTransfersToTexture; } 388 void incTransfersToTexture() { fTransfersToTexture++; } 389 void incStencilAttachmentCreates() { fStencilAttachmentCreates++; } 390 void incNumDraws() { fNumDraws++; } 391 void dump(SkString*); 392 void dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values); 393 394 private: 395 int fRenderTargetBinds; 396 int fShaderCompilations; 397 int fTextureCreates; 398 int fTextureUploads; 399 int fTransfersToTexture; 400 int fStencilAttachmentCreates; 401 int fNumDraws; 402 #else 403 void dump(SkString*) {} 404 void dumpKeyValuePairs(SkTArray<SkString>*, SkTArray<double>*) {} 405 void incRenderTargetBinds() {} 406 void incShaderCompilations() {} 407 void incTextureCreates() {} 408 void incTextureUploads() {} 409 void incTransfersToTexture() {} 410 void incStencilAttachmentCreates() {} 411 void incNumDraws() {} 412 #endif 413 }; 414 415 Stats* stats() { return &fStats; } 416 417 /** Creates a texture directly in the backend API without wrapping it in a GrTexture. This is 418 only to be used for testing (particularly for testing the methods that import an externally 419 created texture into Skia. Must be matched with a call to deleteTestingOnlyTexture(). */ 420 virtual GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h, 421 GrPixelConfig config) = 0; 422 /** Check a handle represents an actual texture in the backend API that has not been freed. */ 423 virtual bool isTestingOnlyBackendTexture(GrBackendObject) const = 0; 424 /** If ownership of the backend texture has been transferred pass true for abandonTexture. This 425 will do any necessary cleanup of the handle without freeing the texture in the backend 426 API. */ 427 virtual void deleteTestingOnlyBackendTexture(GrBackendObject, 428 bool abandonTexture = false) = 0; 429 430 // width and height may be larger than rt (if underlying API allows it). 431 // Returns nullptr if compatible sb could not be created, otherwise the caller owns the ref on 432 // the GrStencilAttachment. 433 virtual GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*, 434 int width, 435 int height) = 0; 436 // clears target's entire stencil buffer to 0 437 virtual void clearStencil(GrRenderTarget* target) = 0; 438 439 // draws an outline rectangle for debugging/visualization purposes. 440 virtual void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) = 0; 441 442 // Determines whether a texture will need to be rescaled in order to be used with the 443 // GrTextureParams. This variation is called when the caller will create a new texture using the 444 // texture provider from a non-texture src (cpu-backed image, ...). 445 bool makeCopyForTextureParams(int width, int height, const GrTextureParams&, 446 GrTextureProducer::CopyParams*) const; 447 448 // Like the above but this variation should be called when the caller is not creating the 449 // original texture but rather was handed the original texture. It adds additional checks 450 // relevant to original textures that were created external to Skia via 451 // GrTextureProvider::wrap methods. 452 bool makeCopyForTextureParams(GrTexture* texture, const GrTextureParams& params, 453 GrTextureProducer::CopyParams* copyParams) const { 454 if (this->makeCopyForTextureParams(texture->width(), texture->height(), params, 455 copyParams)) { 456 return true; 457 } 458 return this->onMakeCopyForTextureParams(texture, params, copyParams); 459 } 460 461 // This is only to be used in GL-specific tests. 462 virtual const GrGLContext* glContextForTesting() const { return nullptr; } 463 464 // This is only to be used by testing code 465 virtual void resetShaderCacheForTesting() const {} 466 467 protected: 468 // Functions used to map clip-respecting stencil tests into normal 469 // stencil funcs supported by GPUs. 470 static GrStencilFunc ConvertStencilFunc(bool stencilInClip, 471 GrStencilFunc func); 472 static void ConvertStencilFuncAndMask(GrStencilFunc func, 473 bool clipInStencil, 474 unsigned int clipBit, 475 unsigned int userBits, 476 unsigned int* ref, 477 unsigned int* mask); 478 479 static void ElevateDrawPreference(GrGpu::DrawPreference* preference, 480 GrGpu::DrawPreference elevation) { 481 GR_STATIC_ASSERT(GrGpu::kCallerPrefersDraw_DrawPreference > GrGpu::kNoDraw_DrawPreference); 482 GR_STATIC_ASSERT(GrGpu::kGpuPrefersDraw_DrawPreference > 483 GrGpu::kCallerPrefersDraw_DrawPreference); 484 GR_STATIC_ASSERT(GrGpu::kRequireDraw_DrawPreference > 485 GrGpu::kGpuPrefersDraw_DrawPreference); 486 *preference = SkTMax(*preference, elevation); 487 } 488 489 void handleDirtyContext() { 490 if (fResetBits) { 491 this->resetContext(); 492 } 493 } 494 495 Stats fStats; 496 SkAutoTDelete<GrPathRendering> fPathRendering; 497 // Subclass must initialize this in its constructor. 498 SkAutoTUnref<const GrCaps> fCaps; 499 500 private: 501 // called when the 3D context state is unknown. Subclass should emit any 502 // assumed 3D context state and dirty any state cache. 503 virtual void onResetContext(uint32_t resetBits) = 0; 504 505 // Called before certain draws in order to guarantee coherent results from dst reads. 506 virtual void xferBarrier(GrRenderTarget*, GrXferBarrierType) = 0; 507 508 // overridden by backend-specific derived class to create objects. 509 // Texture size and sample size will have already been validated in base class before 510 // onCreateTexture/CompressedTexture are called. 511 virtual GrTexture* onCreateTexture(const GrSurfaceDesc& desc, 512 GrGpuResource::LifeCycle lifeCycle, 513 const void* srcData, size_t rowBytes) = 0; 514 virtual GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, 515 GrGpuResource::LifeCycle lifeCycle, 516 const void* srcData) = 0; 517 virtual GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) = 0; 518 virtual GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&, 519 GrWrapOwnership) = 0; 520 virtual GrRenderTarget* onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&, 521 GrWrapOwnership) = 0; 522 virtual GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) = 0; 523 virtual GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) = 0; 524 virtual GrTransferBuffer* onCreateTransferBuffer(size_t size, TransferType type) = 0; 525 526 // overridden by backend-specific derived class to perform the clear. 527 virtual void onClear(GrRenderTarget*, const SkIRect& rect, GrColor color) = 0; 528 529 530 // Overridden by backend specific classes to perform a clear of the stencil clip bits. This is 531 // ONLY used by the the clip target 532 virtual void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) = 0; 533 534 // overridden by backend-specific derived class to perform the draw call. 535 virtual void onDraw(const DrawArgs&, const GrNonInstancedVertices&) = 0; 536 537 virtual bool onMakeCopyForTextureParams(GrTexture* texture, const GrTextureParams&, 538 GrTextureProducer::CopyParams*) const { return false; } 539 540 virtual bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, 541 size_t rowBytes, GrPixelConfig readConfig, DrawPreference*, 542 ReadPixelTempDrawInfo*) = 0; 543 virtual bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height, 544 GrPixelConfig srcConfig, DrawPreference*, 545 WritePixelTempDrawInfo*) = 0; 546 547 // overridden by backend-specific derived class to perform the surface read 548 virtual bool onReadPixels(GrSurface*, 549 int left, int top, 550 int width, int height, 551 GrPixelConfig, 552 void* buffer, 553 size_t rowBytes) = 0; 554 555 // overridden by backend-specific derived class to perform the surface write 556 virtual bool onWritePixels(GrSurface*, 557 int left, int top, int width, int height, 558 GrPixelConfig config, const void* buffer, 559 size_t rowBytes) = 0; 560 561 // overridden by backend-specific derived class to perform the surface write 562 virtual bool onTransferPixels(GrSurface*, 563 int left, int top, int width, int height, 564 GrPixelConfig config, GrTransferBuffer* buffer, 565 size_t offset, size_t rowBytes) = 0; 566 567 // overridden by backend-specific derived class to perform the resolve 568 virtual void onResolveRenderTarget(GrRenderTarget* target) = 0; 569 570 // overridden by backend specific derived class to perform the copy surface 571 virtual bool onCopySurface(GrSurface* dst, 572 GrSurface* src, 573 const SkIRect& srcRect, 574 const SkIPoint& dstPoint) = 0; 575 576 void resetContext() { 577 this->onResetContext(fResetBits); 578 fResetBits = 0; 579 ++fResetTimestamp; 580 } 581 582 ResetTimestamp fResetTimestamp; 583 uint32_t fResetBits; 584 // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu. 585 GrContext* fContext; 586 587 friend class GrPathRendering; 588 typedef SkRefCnt INHERITED; 589 }; 590 591 #endif 592
