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