GrGpu.h revision 066df7ca911b65d416783f3bec6f4f1662948ad5
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 * Clear the passed in render target. Ignores the draw state and clip. 304 */ 305 void clear(const SkIRect& rect, GrColor color, GrRenderTarget* renderTarget); 306 307 308 void clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* renderTarget); 309 310 /** 311 * Discards the contents render target. nullptr indicates that the current render target should 312 * be discarded. 313 **/ 314 virtual void discard(GrRenderTarget* = nullptr) = 0; 315 316 /** 317 * This is can be called before allocating a texture to be a dst for copySurface. It will 318 * populate the origin, config, and flags fields of the desc such that copySurface can 319 * efficiently succeed. It should only succeed if it can allow copySurface to perform a copy 320 * that would be more effecient than drawing the src to a dst render target. 321 */ 322 virtual bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) const = 0; 323 324 // After the client interacts directly with the 3D context state the GrGpu 325 // must resync its internal state and assumptions about 3D context state. 326 // Each time this occurs the GrGpu bumps a timestamp. 327 // state of the 3D context 328 // At 10 resets / frame and 60fps a 64bit timestamp will overflow in about 329 // a billion years. 330 typedef uint64_t ResetTimestamp; 331 332 // This timestamp is always older than the current timestamp 333 static const ResetTimestamp kExpiredTimestamp = 0; 334 // Returns a timestamp based on the number of times the context was reset. 335 // This timestamp can be used to lazily detect when cached 3D context state 336 // is dirty. 337 ResetTimestamp getResetTimestamp() const { return fResetTimestamp; } 338 339 // Called to perform a surface to surface copy. Fallbacks to issuing a draw from the src to dst 340 // take place at the GrDrawTarget level and this function implement faster copy paths. The rect 341 // and point are pre-clipped. The src rect and implied dst rect are guaranteed to be within the 342 // src/dst bounds and non-empty. 343 bool copySurface(GrSurface* dst, 344 GrSurface* src, 345 const SkIRect& srcRect, 346 const SkIPoint& dstPoint); 347 348 struct MultisampleSpecs { 349 // Nonzero ID that uniquely identifies these multisample specs. 350 uint8_t fUniqueID; 351 // The actual number of samples the GPU will run. NOTE: this value can be greater than the 352 // the render target's sample count. 353 int fEffectiveSampleCnt; 354 // If sample locations are supported, contains the subpixel locations at which the GPU will 355 // sample. Pixel center is at (.5, .5) and (0, 0) indicates the top left corner. 356 SkAutoTDeleteArray<const SkPoint> fSampleLocations; 357 }; 358 359 // Finds a render target's multisample specs. The stencil settings are only needed to flush the 360 // draw state prior to querying multisample information; they should not have any effect on the 361 // multisample information itself. 362 const MultisampleSpecs& getMultisampleSpecs(GrRenderTarget*, const GrStencilSettings&); 363 364 // Creates a GrGpuCommandBuffer in which the GrDrawTarget can send draw commands to instead of 365 // directly to the Gpu object. 366 virtual GrGpuCommandBuffer* createCommandBuffer(const GrRenderTarget& target, 367 GrGpuCommandBuffer::LoadAndStoreOp colorOp, 368 GrColor colorClear, 369 GrGpuCommandBuffer::LoadAndStoreOp stencilOp, 370 GrColor stencilClear) = 0; 371 372 // We pass in an array of meshCount GrMesh to the draw. The backend should loop over each 373 // GrMesh object and emit a draw for it. Each draw will use the same GrPipeline and 374 // GrPrimitiveProcessor. This may fail if the draw would exceed any resource limits (e.g. 375 // number of vertex attributes is too large). 376 bool draw(const GrPipeline&, 377 const GrPrimitiveProcessor&, 378 const GrMesh*, 379 int meshCount); 380 381 // Called by drawtarget when flushing. 382 // Provides a hook for post-flush actions (e.g. PLS reset and Vulkan command buffer submits). 383 virtual void finishDrawTarget() {} 384 385 /////////////////////////////////////////////////////////////////////////// 386 // Debugging and Stats 387 388 class Stats { 389 public: 390#if GR_GPU_STATS 391 Stats() { this->reset(); } 392 393 void reset() { 394 fRenderTargetBinds = 0; 395 fShaderCompilations = 0; 396 fTextureCreates = 0; 397 fTextureUploads = 0; 398 fTransfersToTexture = 0; 399 fStencilAttachmentCreates = 0; 400 fNumDraws = 0; 401 fNumFailedDraws = 0; 402 } 403 404 int renderTargetBinds() const { return fRenderTargetBinds; } 405 void incRenderTargetBinds() { fRenderTargetBinds++; } 406 int shaderCompilations() const { return fShaderCompilations; } 407 void incShaderCompilations() { fShaderCompilations++; } 408 int textureCreates() const { return fTextureCreates; } 409 void incTextureCreates() { fTextureCreates++; } 410 int textureUploads() const { return fTextureUploads; } 411 void incTextureUploads() { fTextureUploads++; } 412 int transfersToTexture() const { return fTransfersToTexture; } 413 void incTransfersToTexture() { fTransfersToTexture++; } 414 void incStencilAttachmentCreates() { fStencilAttachmentCreates++; } 415 void incNumDraws() { fNumDraws++; } 416 void incNumFailedDraws() { ++fNumFailedDraws; } 417 void dump(SkString*); 418 void dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values); 419 int numDraws() const { return fNumDraws; } 420 int numFailedDraws() const { return fNumFailedDraws; } 421 private: 422 int fRenderTargetBinds; 423 int fShaderCompilations; 424 int fTextureCreates; 425 int fTextureUploads; 426 int fTransfersToTexture; 427 int fStencilAttachmentCreates; 428 int fNumDraws; 429 int fNumFailedDraws; 430#else 431 void dump(SkString*) {} 432 void dumpKeyValuePairs(SkTArray<SkString>*, SkTArray<double>*) {} 433 void incRenderTargetBinds() {} 434 void incShaderCompilations() {} 435 void incTextureCreates() {} 436 void incTextureUploads() {} 437 void incTransfersToTexture() {} 438 void incStencilAttachmentCreates() {} 439 void incNumDraws() {} 440 void incNumFailedDraws() {} 441#endif 442 }; 443 444 Stats* stats() { return &fStats; } 445 446 /** Creates a texture directly in the backend API without wrapping it in a GrTexture. This is 447 only to be used for testing (particularly for testing the methods that import an externally 448 created texture into Skia. Must be matched with a call to deleteTestingOnlyTexture(). */ 449 virtual GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h, 450 GrPixelConfig config) = 0; 451 /** Check a handle represents an actual texture in the backend API that has not been freed. */ 452 virtual bool isTestingOnlyBackendTexture(GrBackendObject) const = 0; 453 /** If ownership of the backend texture has been transferred pass true for abandonTexture. This 454 will do any necessary cleanup of the handle without freeing the texture in the backend 455 API. */ 456 virtual void deleteTestingOnlyBackendTexture(GrBackendObject, 457 bool abandonTexture = false) = 0; 458 459 // width and height may be larger than rt (if underlying API allows it). 460 // Returns nullptr if compatible sb could not be created, otherwise the caller owns the ref on 461 // the GrStencilAttachment. 462 virtual GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*, 463 int width, 464 int height) = 0; 465 // clears target's entire stencil buffer to 0 466 virtual void clearStencil(GrRenderTarget* target) = 0; 467 468 // draws an outline rectangle for debugging/visualization purposes. 469 virtual void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) = 0; 470 471 // Determines whether a texture will need to be rescaled in order to be used with the 472 // GrTextureParams. This variation is called when the caller will create a new texture using the 473 // texture provider from a non-texture src (cpu-backed image, ...). 474 bool makeCopyForTextureParams(int width, int height, const GrTextureParams&, 475 GrTextureProducer::CopyParams*) const; 476 477 // Like the above but this variation should be called when the caller is not creating the 478 // original texture but rather was handed the original texture. It adds additional checks 479 // relevant to original textures that were created external to Skia via 480 // GrTextureProvider::wrap methods. 481 bool makeCopyForTextureParams(GrTexture* texture, const GrTextureParams& params, 482 GrTextureProducer::CopyParams* copyParams) const { 483 if (this->makeCopyForTextureParams(texture->width(), texture->height(), params, 484 copyParams)) { 485 return true; 486 } 487 return this->onMakeCopyForTextureParams(texture, params, copyParams); 488 } 489 490 // This is only to be used in GL-specific tests. 491 virtual const GrGLContext* glContextForTesting() const { return nullptr; } 492 493 // This is only to be used by testing code 494 virtual void resetShaderCacheForTesting() const {} 495 496protected: 497 static void ElevateDrawPreference(GrGpu::DrawPreference* preference, 498 GrGpu::DrawPreference elevation) { 499 GR_STATIC_ASSERT(GrGpu::kCallerPrefersDraw_DrawPreference > GrGpu::kNoDraw_DrawPreference); 500 GR_STATIC_ASSERT(GrGpu::kGpuPrefersDraw_DrawPreference > 501 GrGpu::kCallerPrefersDraw_DrawPreference); 502 GR_STATIC_ASSERT(GrGpu::kRequireDraw_DrawPreference > 503 GrGpu::kGpuPrefersDraw_DrawPreference); 504 *preference = SkTMax(*preference, elevation); 505 } 506 507 void handleDirtyContext() { 508 if (fResetBits) { 509 this->resetContext(); 510 } 511 } 512 513 // Handles cases where a surface will be updated without a call to flushRenderTarget 514 void didWriteToSurface(GrSurface* surface, const SkIRect* bounds, uint32_t mipLevels = 1) const; 515 516 Stats fStats; 517 SkAutoTDelete<GrPathRendering> fPathRendering; 518 // Subclass must initialize this in its constructor. 519 SkAutoTUnref<const GrCaps> fCaps; 520 521private: 522 // called when the 3D context state is unknown. Subclass should emit any 523 // assumed 3D context state and dirty any state cache. 524 virtual void onResetContext(uint32_t resetBits) = 0; 525 526 // Called before certain draws in order to guarantee coherent results from dst reads. 527 virtual void xferBarrier(GrRenderTarget*, GrXferBarrierType) = 0; 528 529 // overridden by backend-specific derived class to create objects. 530 // Texture size and sample size will have already been validated in base class before 531 // onCreateTexture/CompressedTexture are called. 532 virtual GrTexture* onCreateTexture(const GrSurfaceDesc& desc, 533 SkBudgeted budgeted, 534 const SkTArray<GrMipLevel>& texels) = 0; 535 virtual GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, 536 SkBudgeted budgeted, 537 const SkTArray<GrMipLevel>& texels) = 0; 538 539 virtual GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) = 0; 540 virtual GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&, 541 GrWrapOwnership) = 0; 542 virtual GrRenderTarget* onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&) = 0; 543 virtual GrBuffer* onCreateBuffer(size_t size, GrBufferType intendedType, GrAccessPattern, 544 const void* data) = 0; 545 546 // overridden by backend-specific derived class to perform the clear. 547 virtual void onClear(GrRenderTarget*, const SkIRect& rect, GrColor color) = 0; 548 549 // Overridden by backend specific classes to perform a clear of the stencil clip bits. This is 550 // ONLY used by the the clip target 551 virtual void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) = 0; 552 553 // overridden by backend-specific derived class to perform the draw call. 554 virtual void onDraw(const GrPipeline&, 555 const GrPrimitiveProcessor&, 556 const GrMesh*, 557 int meshCount) = 0; 558 559 virtual bool onMakeCopyForTextureParams(GrTexture* texture, const GrTextureParams&, 560 GrTextureProducer::CopyParams*) const { return false; } 561 562 virtual bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, 563 size_t rowBytes, GrPixelConfig readConfig, DrawPreference*, 564 ReadPixelTempDrawInfo*) = 0; 565 virtual bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height, 566 GrPixelConfig srcConfig, DrawPreference*, 567 WritePixelTempDrawInfo*) = 0; 568 569 // overridden by backend-specific derived class to perform the surface read 570 virtual bool onReadPixels(GrSurface*, 571 int left, int top, 572 int width, int height, 573 GrPixelConfig, 574 void* buffer, 575 size_t rowBytes) = 0; 576 577 // overridden by backend-specific derived class to perform the surface write 578 virtual bool onWritePixels(GrSurface*, 579 int left, int top, int width, int height, 580 GrPixelConfig config, 581 const SkTArray<GrMipLevel>& texels) = 0; 582 583 // overridden by backend-specific derived class to perform the surface write 584 virtual bool onTransferPixels(GrSurface*, 585 int left, int top, int width, int height, 586 GrPixelConfig config, GrBuffer* transferBuffer, 587 size_t offset, size_t rowBytes) = 0; 588 589 // overridden by backend-specific derived class to perform the resolve 590 virtual void onResolveRenderTarget(GrRenderTarget* target) = 0; 591 592 // overridden by backend specific derived class to perform the copy surface 593 virtual bool onCopySurface(GrSurface* dst, 594 GrSurface* src, 595 const SkIRect& srcRect, 596 const SkIPoint& dstPoint) = 0; 597 598 // overridden by backend specific derived class to perform the multisample queries 599 virtual void onGetMultisampleSpecs(GrRenderTarget*, 600 const GrStencilSettings&, 601 int* effectiveSampleCnt, 602 SkAutoTDeleteArray<SkPoint>* sampleLocations) = 0; 603 604 void resetContext() { 605 this->onResetContext(fResetBits); 606 fResetBits = 0; 607 ++fResetTimestamp; 608 } 609 610 ResetTimestamp fResetTimestamp; 611 uint32_t fResetBits; 612 SkTArray<const MultisampleSpecs*, true> fMultisampleSpecsMap; 613 GrTAllocator<MultisampleSpecs> fMultisampleSpecsAllocator; 614 // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu. 615 GrContext* fContext; 616 617 friend class GrPathRendering; 618 typedef SkRefCnt INHERITED; 619}; 620 621#endif 622