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