GrGpu.h revision 9cb6340a62a5d748e4189d50e51fa527c8c80c03
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 "GrGpuCommandBuffer.h" 12#include "GrPipelineBuilder.h" 13#include "GrProgramDesc.h" 14#include "GrSwizzle.h" 15#include "GrAllocator.h" 16#include "GrTextureParamsAdjuster.h" 17#include "GrTypes.h" 18#include "GrXferProcessor.h" 19#include "SkPath.h" 20#include "SkTArray.h" 21 22class GrBatchTracker; 23class GrBuffer; 24class GrContext; 25class GrGLContext; 26class GrMesh; 27class GrNonInstancedVertices; 28class GrPath; 29class GrPathRange; 30class GrPathRenderer; 31class GrPathRendererChain; 32class GrPathRendering; 33class GrPipeline; 34class GrPrimitiveProcessor; 35class GrRenderTarget; 36class GrStencilAttachment; 37class GrStencilSettings; 38class GrSurface; 39class GrTexture; 40 41class GrGpu : public SkRefCnt { 42public: 43 /** 44 * Create an instance of GrGpu that matches the specified backend. If the requested backend is 45 * not supported (at compile-time or run-time) this returns nullptr. The context will not be 46 * fully constructed and should not be used by GrGpu until after this function returns. 47 */ 48 static GrGpu* Create(GrBackend, GrBackendContext, const GrContextOptions&, GrContext* context); 49 50 //////////////////////////////////////////////////////////////////////////// 51 52 GrGpu(GrContext* context); 53 ~GrGpu() override; 54 55 GrContext* getContext() { return fContext; } 56 const GrContext* getContext() const { return fContext; } 57 58 /** 59 * Gets the capabilities of the draw target. 60 */ 61 const GrCaps* caps() const { return fCaps.get(); } 62 63 GrPathRendering* pathRendering() { return fPathRendering.get(); } 64 65 enum class DisconnectType { 66 // No cleanup should be attempted, immediately cease making backend API calls 67 kAbandon, 68 // Free allocated resources (not known by GrResourceCache) before returning and 69 // ensure no backend backend 3D API calls will be made after disconnect() returns. 70 kCleanup, 71 }; 72 73 // Called by GrContext when the underlying backend context is already or will be destroyed 74 // before GrContext. 75 virtual void disconnect(DisconnectType); 76 77 /** 78 * The GrGpu object normally assumes that no outsider is setting state 79 * within the underlying 3D API's context/device/whatever. This call informs 80 * the GrGpu that the state was modified and it shouldn't make assumptions 81 * about the state. 82 */ 83 void markContextDirty(uint32_t state = kAll_GrBackendState) { fResetBits |= state; } 84 85 /** 86 * Creates a texture object. If kRenderTarget_GrSurfaceFlag the texture can 87 * be used as a render target by calling GrTexture::asRenderTarget(). Not all 88 * pixel configs can be used as render targets. Support for configs as textures 89 * or render targets can be checked using GrCaps. 90 * 91 * @param desc describes the texture to be created. 92 * @param budgeted does this texture count against the resource cache budget? 93 * @param texels array of mipmap levels containing texel data to load. 94 * Each level begins with full-size palette data for paletted textures. 95 * For compressed formats the level contains the compressed pixel data. 96 * Otherwise, it contains width*height texels. If there is only one 97 * element and it contains nullptr fPixels, texture data is 98 * uninitialized. 99 * @return The texture object if successful, otherwise nullptr. 100 */ 101 GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, 102 const SkTArray<GrMipLevel>& texels); 103 104 /** 105 * Simplified createTexture() interface for when there is no initial texel data to upload. 106 */ 107 GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted) { 108 return this->createTexture(desc, budgeted, SkTArray<GrMipLevel>()); 109 } 110 111 /** Simplified createTexture() interface for when there is only a base level */ 112 GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, const void* level0Data, 113 size_t rowBytes) { 114 SkASSERT(level0Data); 115 GrMipLevel level = { level0Data, rowBytes }; 116 SkSTArray<1, GrMipLevel> array; 117 array.push_back() = level; 118 return this->createTexture(desc, budgeted, array); 119 } 120 121 /** 122 * Implements GrTextureProvider::wrapBackendTexture 123 */ 124 GrTexture* wrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership); 125 126 /** 127 * Implements GrTextureProvider::wrapBackendRenderTarget 128 */ 129 GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc&, GrWrapOwnership); 130 131 /** 132 * Implements GrTextureProvider::wrapBackendTextureAsRenderTarget 133 */ 134 GrRenderTarget* wrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&); 135 136 /** 137 * Creates a buffer. 138 * 139 * @param size size of buffer to create. 140 * @param intendedType hint to the graphics subsystem about what the buffer will be used for. 141 * @param accessPattern hint to the graphics subsystem about how the data will be accessed. 142 * @param data optional data with which to initialize the buffer. 143 * 144 * @return the buffer if successful, otherwise nullptr. 145 */ 146 GrBuffer* createBuffer(size_t size, GrBufferType intendedType, GrAccessPattern accessPattern, 147 const void* data = nullptr); 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 texels array of mipmap levels containing texture data 264 */ 265 bool writePixels(GrSurface* surface, 266 int left, int top, int width, int height, 267 GrPixelConfig config, 268 const SkTArray<GrMipLevel>& texels); 269 270 /** 271 * This function is a shim which creates a SkTArray<GrMipLevel> of size 1. 272 * It then calls writePixels with that SkTArray. 273 * 274 * @param buffer memory to read pixels from. 275 * @param rowBytes number of bytes between consecutive rows. Zero 276 * means rows are tightly packed. 277 */ 278 bool writePixels(GrSurface* surface, 279 int left, int top, int width, int height, 280 GrPixelConfig config, const void* buffer, 281 size_t rowBytes); 282 283 /** 284 * Updates the pixels in a rectangle of a surface using a buffer 285 * 286 * @param surface The surface to write to. 287 * @param left left edge of the rectangle to write (inclusive) 288 * @param top top edge of the rectangle to write (inclusive) 289 * @param width width of rectangle to write in pixels. 290 * @param height height of rectangle to write in pixels. 291 * @param config the pixel config of the source buffer 292 * @param transferBuffer GrBuffer to read pixels from (type must be "kCpuToGpu") 293 * @param offset offset from the start of the buffer 294 * @param rowBytes number of bytes between consecutive rows. Zero 295 * means rows are tightly packed. 296 */ 297 bool transferPixels(GrSurface* surface, 298 int left, int top, int width, int height, 299 GrPixelConfig config, GrBuffer* transferBuffer, 300 size_t offset, size_t rowBytes); 301 302 /** 303 * This is can be called before allocating a texture to be a dst for copySurface. It will 304 * populate the origin, config, and flags fields of the desc such that copySurface can 305 * efficiently succeed. It should only succeed if it can allow copySurface to perform a copy 306 * that would be more effecient than drawing the src to a dst render target. 307 */ 308 virtual bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) const = 0; 309 310 // After the client interacts directly with the 3D context state the GrGpu 311 // must resync its internal state and assumptions about 3D context state. 312 // Each time this occurs the GrGpu bumps a timestamp. 313 // state of the 3D context 314 // At 10 resets / frame and 60fps a 64bit timestamp will overflow in about 315 // a billion years. 316 typedef uint64_t ResetTimestamp; 317 318 // This timestamp is always older than the current timestamp 319 static const ResetTimestamp kExpiredTimestamp = 0; 320 // Returns a timestamp based on the number of times the context was reset. 321 // This timestamp can be used to lazily detect when cached 3D context state 322 // is dirty. 323 ResetTimestamp getResetTimestamp() const { return fResetTimestamp; } 324 325 // Called to perform a surface to surface copy. Fallbacks to issuing a draw from the src to dst 326 // take place at the GrDrawTarget level and this function implement faster copy paths. The rect 327 // and point are pre-clipped. The src rect and implied dst rect are guaranteed to be within the 328 // src/dst bounds and non-empty. 329 bool copySurface(GrSurface* dst, 330 GrSurface* src, 331 const SkIRect& srcRect, 332 const SkIPoint& dstPoint); 333 334 struct MultisampleSpecs { 335 // Nonzero ID that uniquely identifies these multisample specs. 336 uint8_t fUniqueID; 337 // The actual number of samples the GPU will run. NOTE: this value can be greater than the 338 // the render target's sample count. 339 int fEffectiveSampleCnt; 340 // If sample locations are supported, contains the subpixel locations at which the GPU will 341 // sample. Pixel center is at (.5, .5) and (0, 0) indicates the top left corner. 342 SkAutoTDeleteArray<const SkPoint> fSampleLocations; 343 }; 344 345 // Finds a render target's multisample specs. The stencil settings are only needed to flush the 346 // draw state prior to querying multisample information; they should not have any effect on the 347 // multisample information itself. 348 const MultisampleSpecs& getMultisampleSpecs(GrRenderTarget*, const GrStencilSettings&); 349 350 // Creates a GrGpuCommandBuffer in which the GrDrawTarget can send draw commands to instead of 351 // directly to the Gpu object. 352 virtual GrGpuCommandBuffer* createCommandBuffer( 353 GrRenderTarget* target, 354 const GrGpuCommandBuffer::LoadAndStoreInfo& colorInfo, 355 const GrGpuCommandBuffer::LoadAndStoreInfo& stencilInfo) = 0; 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 fNumFailedDraws = 0; 378 } 379 380 int renderTargetBinds() const { return fRenderTargetBinds; } 381 void incRenderTargetBinds() { fRenderTargetBinds++; } 382 int shaderCompilations() const { return fShaderCompilations; } 383 void incShaderCompilations() { fShaderCompilations++; } 384 int textureCreates() const { return fTextureCreates; } 385 void incTextureCreates() { fTextureCreates++; } 386 int textureUploads() const { return fTextureUploads; } 387 void incTextureUploads() { fTextureUploads++; } 388 int transfersToTexture() const { return fTransfersToTexture; } 389 void incTransfersToTexture() { fTransfersToTexture++; } 390 void incStencilAttachmentCreates() { fStencilAttachmentCreates++; } 391 void incNumDraws() { fNumDraws++; } 392 void incNumFailedDraws() { ++fNumFailedDraws; } 393 void dump(SkString*); 394 void dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values); 395 int numDraws() const { return fNumDraws; } 396 int numFailedDraws() const { return fNumFailedDraws; } 397 private: 398 int fRenderTargetBinds; 399 int fShaderCompilations; 400 int fTextureCreates; 401 int fTextureUploads; 402 int fTransfersToTexture; 403 int fStencilAttachmentCreates; 404 int fNumDraws; 405 int fNumFailedDraws; 406#else 407 void dump(SkString*) {} 408 void dumpKeyValuePairs(SkTArray<SkString>*, SkTArray<double>*) {} 409 void incRenderTargetBinds() {} 410 void incShaderCompilations() {} 411 void incTextureCreates() {} 412 void incTextureUploads() {} 413 void incTransfersToTexture() {} 414 void incStencilAttachmentCreates() {} 415 void incNumDraws() {} 416 void incNumFailedDraws() {} 417#endif 418 }; 419 420 Stats* stats() { return &fStats; } 421 422 /** Creates a texture directly in the backend API without wrapping it in a GrTexture. This is 423 only to be used for testing (particularly for testing the methods that import an externally 424 created texture into Skia. Must be matched with a call to deleteTestingOnlyTexture(). */ 425 virtual GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h, 426 GrPixelConfig config) = 0; 427 /** Check a handle represents an actual texture in the backend API that has not been freed. */ 428 virtual bool isTestingOnlyBackendTexture(GrBackendObject) const = 0; 429 /** If ownership of the backend texture has been transferred pass true for abandonTexture. This 430 will do any necessary cleanup of the handle without freeing the texture in the backend 431 API. */ 432 virtual void deleteTestingOnlyBackendTexture(GrBackendObject, 433 bool abandonTexture = false) = 0; 434 435 // width and height may be larger than rt (if underlying API allows it). 436 // Returns nullptr if compatible sb could not be created, otherwise the caller owns the ref on 437 // the GrStencilAttachment. 438 virtual GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*, 439 int width, 440 int height) = 0; 441 // clears target's entire stencil buffer to 0 442 virtual void clearStencil(GrRenderTarget* target) = 0; 443 444 // draws an outline rectangle for debugging/visualization purposes. 445 virtual void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) = 0; 446 447 // Determines whether a texture will need to be rescaled in order to be used with the 448 // GrTextureParams. This variation is called when the caller will create a new texture using the 449 // texture provider from a non-texture src (cpu-backed image, ...). 450 bool makeCopyForTextureParams(int width, int height, const GrTextureParams&, 451 GrTextureProducer::CopyParams*) const; 452 453 // Like the above but this variation should be called when the caller is not creating the 454 // original texture but rather was handed the original texture. It adds additional checks 455 // relevant to original textures that were created external to Skia via 456 // GrTextureProvider::wrap methods. 457 bool makeCopyForTextureParams(GrTexture* texture, const GrTextureParams& params, 458 GrTextureProducer::CopyParams* copyParams) const { 459 if (this->makeCopyForTextureParams(texture->width(), texture->height(), params, 460 copyParams)) { 461 return true; 462 } 463 return this->onMakeCopyForTextureParams(texture, params, copyParams); 464 } 465 466 // This is only to be used in GL-specific tests. 467 virtual const GrGLContext* glContextForTesting() const { return nullptr; } 468 469 // This is only to be used by testing code 470 virtual void resetShaderCacheForTesting() const {} 471 472 void handleDirtyContext() { 473 if (fResetBits) { 474 this->resetContext(); 475 } 476 } 477 478protected: 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 // Handles cases where a surface will be updated without a call to flushRenderTarget 490 void didWriteToSurface(GrSurface* surface, const SkIRect* bounds, uint32_t mipLevels = 1) const; 491 492 Stats fStats; 493 SkAutoTDelete<GrPathRendering> fPathRendering; 494 // Subclass must initialize this in its constructor. 495 SkAutoTUnref<const GrCaps> fCaps; 496 497private: 498 // called when the 3D context state is unknown. Subclass should emit any 499 // assumed 3D context state and dirty any state cache. 500 virtual void onResetContext(uint32_t resetBits) = 0; 501 502 // Called before certain draws in order to guarantee coherent results from dst reads. 503 virtual void xferBarrier(GrRenderTarget*, GrXferBarrierType) = 0; 504 505 // overridden by backend-specific derived class to create objects. 506 // Texture size and sample size will have already been validated in base class before 507 // onCreateTexture/CompressedTexture are called. 508 virtual GrTexture* onCreateTexture(const GrSurfaceDesc& desc, 509 SkBudgeted budgeted, 510 const SkTArray<GrMipLevel>& texels) = 0; 511 virtual GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, 512 SkBudgeted budgeted, 513 const SkTArray<GrMipLevel>& texels) = 0; 514 515 virtual GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) = 0; 516 virtual GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&, 517 GrWrapOwnership) = 0; 518 virtual GrRenderTarget* onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&) = 0; 519 virtual GrBuffer* onCreateBuffer(size_t size, GrBufferType intendedType, GrAccessPattern, 520 const void* data) = 0; 521 522 virtual bool onMakeCopyForTextureParams(GrTexture* texture, const GrTextureParams&, 523 GrTextureProducer::CopyParams*) const { return false; } 524 525 virtual bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, 526 size_t rowBytes, GrPixelConfig readConfig, DrawPreference*, 527 ReadPixelTempDrawInfo*) = 0; 528 virtual bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height, 529 GrPixelConfig srcConfig, DrawPreference*, 530 WritePixelTempDrawInfo*) = 0; 531 532 // overridden by backend-specific derived class to perform the surface read 533 virtual bool onReadPixels(GrSurface*, 534 int left, int top, 535 int width, int height, 536 GrPixelConfig, 537 void* buffer, 538 size_t rowBytes) = 0; 539 540 // overridden by backend-specific derived class to perform the surface write 541 virtual bool onWritePixels(GrSurface*, 542 int left, int top, int width, int height, 543 GrPixelConfig config, 544 const SkTArray<GrMipLevel>& texels) = 0; 545 546 // overridden by backend-specific derived class to perform the surface write 547 virtual bool onTransferPixels(GrSurface*, 548 int left, int top, int width, int height, 549 GrPixelConfig config, GrBuffer* transferBuffer, 550 size_t offset, size_t rowBytes) = 0; 551 552 // overridden by backend-specific derived class to perform the resolve 553 virtual void onResolveRenderTarget(GrRenderTarget* target) = 0; 554 555 // overridden by backend specific derived class to perform the copy surface 556 virtual bool onCopySurface(GrSurface* dst, 557 GrSurface* src, 558 const SkIRect& srcRect, 559 const SkIPoint& dstPoint) = 0; 560 561 // overridden by backend specific derived class to perform the multisample queries 562 virtual void onGetMultisampleSpecs(GrRenderTarget*, 563 const GrStencilSettings&, 564 int* effectiveSampleCnt, 565 SkAutoTDeleteArray<SkPoint>* sampleLocations) = 0; 566 567 void resetContext() { 568 this->onResetContext(fResetBits); 569 fResetBits = 0; 570 ++fResetTimestamp; 571 } 572 573 ResetTimestamp fResetTimestamp; 574 uint32_t fResetBits; 575 SkTArray<const MultisampleSpecs*, true> fMultisampleSpecsMap; 576 GrTAllocator<MultisampleSpecs> fMultisampleSpecsAllocator; 577 // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu. 578 GrContext* fContext; 579 580 friend class GrPathRendering; 581 typedef SkRefCnt INHERITED; 582}; 583 584#endif 585