GrGpu.h revision 47c1ccbcd8e17efdc89a325e314c414a7c75846c
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 "GrTraceMarker.h" 15#include "GrXferProcessor.h" 16#include "SkPath.h" 17 18class GrBatchTracker; 19class GrContext; 20struct GrGLInterface; 21class GrIndexBuffer; 22class GrNonInstancedVertices; 23class GrPath; 24class GrPathRange; 25class GrPathRenderer; 26class GrPathRendererChain; 27class GrPathRendering; 28class GrPipeline; 29class GrPrimitiveProcessor; 30class GrRenderTarget; 31class GrStencilAttachment; 32class GrSurface; 33class GrTexture; 34class GrVertexBuffer; 35class GrVertices; 36 37class GrGpu : public SkRefCnt { 38public: 39 /** 40 * Create an instance of GrGpu that matches the specified backend. If the requested backend is 41 * not supported (at compile-time or run-time) this returns NULL. The context will not be 42 * fully constructed and should not be used by GrGpu until after this function returns. 43 */ 44 static GrGpu* Create(GrBackend, GrBackendContext, const GrContextOptions&, GrContext* context); 45 46 //////////////////////////////////////////////////////////////////////////// 47 48 GrGpu(GrContext* context); 49 ~GrGpu() override; 50 51 GrContext* getContext() { return fContext; } 52 const GrContext* getContext() const { return fContext; } 53 54 /** 55 * Gets the capabilities of the draw target. 56 */ 57 const GrCaps* caps() const { return fCaps.get(); } 58 59 GrPathRendering* pathRendering() { return fPathRendering.get(); } 60 61 // Called by GrContext when the underlying backend context has been destroyed. 62 // GrGpu should use this to ensure that no backend API calls will be made from 63 // here onward, including in its destructor. Subclasses should call 64 // INHERITED::contextAbandoned() if they override this. 65 virtual void contextAbandoned(); 66 67 /** 68 * The GrGpu object normally assumes that no outsider is setting state 69 * within the underlying 3D API's context/device/whatever. This call informs 70 * the GrGpu that the state was modified and it shouldn't make assumptions 71 * about the state. 72 */ 73 void markContextDirty(uint32_t state = kAll_GrBackendState) { fResetBits |= state; } 74 75 /** 76 * Creates a texture object. If kRenderTarget_GrSurfaceFlag the texture can 77 * be used as a render target by calling GrTexture::asRenderTarget(). Not all 78 * pixel configs can be used as render targets. Support for configs as textures 79 * or render targets can be checked using GrCaps. 80 * 81 * @param desc describes the texture to be created. 82 * @param budgeted does this texture count against the resource cache budget? 83 * @param srcData texel data to load texture. Begins with full-size 84 * palette data for paletted textures. For compressed 85 * formats it contains the compressed pixel data. Otherwise, 86 * it contains width*height texels. If NULL texture data 87 * is uninitialized. 88 * @param rowBytes the number of bytes between consecutive rows. Zero 89 * means rows are tightly packed. This field is ignored 90 * for compressed formats. 91 * 92 * @return The texture object if successful, otherwise NULL. 93 */ 94 GrTexture* createTexture(const GrSurfaceDesc& desc, bool budgeted, 95 const void* srcData, size_t rowBytes); 96 97 /** 98 * Implements GrContext::wrapBackendTexture 99 */ 100 GrTexture* wrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership); 101 102 /** 103 * Implements GrContext::wrapBackendTexture 104 */ 105 GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc&, GrWrapOwnership); 106 107 /** 108 * Creates a vertex buffer. 109 * 110 * @param size size in bytes of the vertex buffer 111 * @param dynamic hints whether the data will be frequently changed 112 * by either GrVertexBuffer::map() or 113 * GrVertexBuffer::updateData(). 114 * 115 * @return The vertex buffer if successful, otherwise NULL. 116 */ 117 GrVertexBuffer* createVertexBuffer(size_t size, bool dynamic); 118 119 /** 120 * Creates an index buffer. 121 * 122 * @param size size in bytes of the index buffer 123 * @param dynamic hints whether the data will be frequently changed 124 * by either GrIndexBuffer::map() or 125 * GrIndexBuffer::updateData(). 126 * 127 * @return The index buffer if successful, otherwise NULL. 128 */ 129 GrIndexBuffer* createIndexBuffer(size_t size, bool dynamic); 130 131 /** 132 * Resolves MSAA. 133 */ 134 void resolveRenderTarget(GrRenderTarget* target); 135 136 /** 137 * Gets a preferred 8888 config to use for writing/reading pixel data to/from a surface with 138 * config surfaceConfig. The returned config must have at least as many bits per channel as the 139 * readConfig or writeConfig param. 140 */ 141 virtual GrPixelConfig preferredReadPixelsConfig(GrPixelConfig readConfig, 142 GrPixelConfig surfaceConfig) const { 143 return readConfig; 144 } 145 virtual GrPixelConfig preferredWritePixelsConfig(GrPixelConfig writeConfig, 146 GrPixelConfig surfaceConfig) const { 147 return writeConfig; 148 } 149 150 /** 151 * Called before uploading writing pixels to a GrTexture when the src pixel config doesn't 152 * match the texture's config. 153 */ 154 virtual bool canWriteTexturePixels(const GrTexture*, GrPixelConfig srcConfig) const = 0; 155 156 /** 157 * OpenGL's readPixels returns the result bottom-to-top while the skia 158 * API is top-to-bottom. Thus we have to do a y-axis flip. The obvious 159 * solution is to have the subclass do the flip using either the CPU or GPU. 160 * However, the caller (GrContext) may have transformations to apply and can 161 * simply fold in the y-flip for free. On the other hand, the subclass may 162 * be able to do it for free itself. For example, the subclass may have to 163 * do memcpys to handle rowBytes that aren't tight. It could do the y-flip 164 * concurrently. 165 * 166 * This function returns true if a y-flip is required to put the pixels in 167 * top-to-bottom order and the subclass cannot do it for free. 168 * 169 * See read pixels for the params 170 * @return true if calling readPixels with the same set of params will 171 * produce bottom-to-top data 172 */ 173 virtual bool readPixelsWillPayForYFlip(GrRenderTarget* renderTarget, 174 int left, int top, 175 int width, int height, 176 GrPixelConfig config, 177 size_t rowBytes) const = 0; 178 /** 179 * This should return true if reading a NxM rectangle of pixels from a 180 * render target is faster if the target has dimensons N and M and the read 181 * rectangle has its top-left at 0,0. 182 */ 183 virtual bool fullReadPixelsIsFasterThanPartial() const { return false; }; 184 185 /** 186 * Reads a rectangle of pixels from a render target. 187 * 188 * @param renderTarget the render target to read from. NULL means the 189 * current render target. 190 * @param left left edge of the rectangle to read (inclusive) 191 * @param top top edge of the rectangle to read (inclusive) 192 * @param width width of rectangle to read in pixels. 193 * @param height height of rectangle to read in pixels. 194 * @param config the pixel config of the destination buffer 195 * @param buffer memory to read the rectangle into. 196 * @param rowBytes the number of bytes between consecutive rows. Zero 197 * means rows are tightly packed. 198 * @param invertY buffer should be populated bottom-to-top as opposed 199 * to top-to-bottom (skia's usual order) 200 * 201 * @return true if the read succeeded, false if not. The read can fail 202 * because of a unsupported pixel config or because no render 203 * target is currently set. 204 */ 205 bool readPixels(GrRenderTarget* renderTarget, 206 int left, int top, int width, int height, 207 GrPixelConfig config, void* buffer, size_t rowBytes); 208 209 /** 210 * Updates the pixels in a rectangle of a texture. 211 * 212 * @param left left edge of the rectangle to write (inclusive) 213 * @param top top edge of the rectangle to write (inclusive) 214 * @param width width of rectangle to write in pixels. 215 * @param height height of rectangle to write in pixels. 216 * @param config the pixel config of the source buffer 217 * @param buffer memory to read pixels from 218 * @param rowBytes number of bytes between consecutive rows. Zero 219 * means rows are tightly packed. 220 */ 221 bool writeTexturePixels(GrTexture* texture, 222 int left, int top, int width, int height, 223 GrPixelConfig config, const void* buffer, 224 size_t rowBytes); 225 226 /** 227 * Clear the passed in render target. Ignores the draw state and clip. Clears the whole thing if 228 * rect is NULL, otherwise just the rect. If canIgnoreRect is set then the entire render target 229 * can be optionally cleared. 230 */ 231 void clear(const SkIRect* rect, GrColor color, bool canIgnoreRect,GrRenderTarget* renderTarget); 232 233 234 void clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* renderTarget); 235 236 /** 237 * Discards the contents render target. NULL indicates that the current render target should 238 * be discarded. 239 **/ 240 virtual void discard(GrRenderTarget* = NULL) = 0; 241 242 /** 243 * This is can be called before allocating a texture to be a dst for copySurface. It will 244 * populate the origin, config, and flags fields of the desc such that copySurface can 245 * efficiently succeed. It should only succeed if it can allow copySurface to perform a copy 246 * that would be more effecient than drawing the src to a dst render target. 247 */ 248 virtual bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) = 0; 249 250 // After the client interacts directly with the 3D context state the GrGpu 251 // must resync its internal state and assumptions about 3D context state. 252 // Each time this occurs the GrGpu bumps a timestamp. 253 // state of the 3D context 254 // At 10 resets / frame and 60fps a 64bit timestamp will overflow in about 255 // a billion years. 256 typedef uint64_t ResetTimestamp; 257 258 // This timestamp is always older than the current timestamp 259 static const ResetTimestamp kExpiredTimestamp = 0; 260 // Returns a timestamp based on the number of times the context was reset. 261 // This timestamp can be used to lazily detect when cached 3D context state 262 // is dirty. 263 ResetTimestamp getResetTimestamp() const { return fResetTimestamp; } 264 265 virtual void buildProgramDesc(GrProgramDesc*, 266 const GrPrimitiveProcessor&, 267 const GrPipeline&, 268 const GrBatchTracker&) const = 0; 269 270 // Called to perform a surface to surface copy. Fallbacks to issuing a draw from the src to dst 271 // take place at the GrDrawTarget level and this function implement faster copy paths. The rect 272 // and point are pre-clipped. The src rect and implied dst rect are guaranteed to be within the 273 // src/dst bounds and non-empty. 274 virtual bool copySurface(GrSurface* dst, 275 GrSurface* src, 276 const SkIRect& srcRect, 277 const SkIPoint& dstPoint) = 0; 278 279 // Called before certain draws in order to guarantee coherent results from dst reads. 280 virtual void xferBarrier(GrRenderTarget*, GrXferBarrierType) = 0; 281 282 struct DrawArgs { 283 DrawArgs(const GrPrimitiveProcessor* primProc, 284 const GrPipeline* pipeline, 285 const GrProgramDesc* desc, 286 const GrBatchTracker* batchTracker) 287 : fPrimitiveProcessor(primProc) 288 , fPipeline(pipeline) 289 , fDesc(desc) 290 , fBatchTracker(batchTracker) { 291 SkASSERT(primProc && pipeline && desc && batchTracker); 292 } 293 const GrPrimitiveProcessor* fPrimitiveProcessor; 294 const GrPipeline* fPipeline; 295 const GrProgramDesc* fDesc; 296 const GrBatchTracker* fBatchTracker; 297 }; 298 299 void draw(const DrawArgs&, const GrVertices&); 300 301 /////////////////////////////////////////////////////////////////////////// 302 // Debugging and Stats 303 304 class Stats { 305 public: 306#if GR_GPU_STATS 307 Stats() { this->reset(); } 308 309 void reset() { 310 fRenderTargetBinds = 0; 311 fShaderCompilations = 0; 312 fTextureCreates = 0; 313 fTextureUploads = 0; 314 fStencilAttachmentCreates = 0; 315 } 316 317 int renderTargetBinds() const { return fRenderTargetBinds; } 318 void incRenderTargetBinds() { fRenderTargetBinds++; } 319 int shaderCompilations() const { return fShaderCompilations; } 320 void incShaderCompilations() { fShaderCompilations++; } 321 int textureCreates() const { return fTextureCreates; } 322 void incTextureCreates() { fTextureCreates++; } 323 int textureUploads() const { return fTextureUploads; } 324 void incTextureUploads() { fTextureUploads++; } 325 void incStencilAttachmentCreates() { fStencilAttachmentCreates++; } 326 void dump(SkString*); 327 328 private: 329 int fRenderTargetBinds; 330 int fShaderCompilations; 331 int fTextureCreates; 332 int fTextureUploads; 333 int fStencilAttachmentCreates; 334#else 335 void dump(SkString*) {}; 336 void incRenderTargetBinds() {} 337 void incShaderCompilations() {} 338 void incTextureCreates() {} 339 void incTextureUploads() {} 340 void incStencilAttachmentCreates() {} 341#endif 342 }; 343 344 Stats* stats() { return &fStats; } 345 346 /** 347 * Called at start and end of gpu trace marking 348 * GR_CREATE_GPU_TRACE_MARKER(marker_str, target) will automatically call these at the start 349 * and end of a code block respectively 350 */ 351 void addGpuTraceMarker(const GrGpuTraceMarker* marker); 352 void removeGpuTraceMarker(const GrGpuTraceMarker* marker); 353 354 /** 355 * Takes the current active set of markers and stores them for later use. Any current marker 356 * in the active set is removed from the active set and the targets remove function is called. 357 * These functions do not work as a stack so you cannot call save a second time before calling 358 * restore. Also, it is assumed that when restore is called the current active set of markers 359 * is empty. When the stored markers are added back into the active set, the targets add marker 360 * is called. 361 */ 362 void saveActiveTraceMarkers(); 363 void restoreActiveTraceMarkers(); 364 365 // Given a rt, find or create a stencil buffer and attach it 366 bool attachStencilAttachmentToRenderTarget(GrRenderTarget* target); 367 368 // This is only to be used in tests. 369 virtual const GrGLInterface* glInterfaceForTesting() const { return NULL; } 370 371protected: 372 // Functions used to map clip-respecting stencil tests into normal 373 // stencil funcs supported by GPUs. 374 static GrStencilFunc ConvertStencilFunc(bool stencilInClip, 375 GrStencilFunc func); 376 static void ConvertStencilFuncAndMask(GrStencilFunc func, 377 bool clipInStencil, 378 unsigned int clipBit, 379 unsigned int userBits, 380 unsigned int* ref, 381 unsigned int* mask); 382 383 const GrTraceMarkerSet& getActiveTraceMarkers() const { return fActiveTraceMarkers; } 384 385 Stats fStats; 386 SkAutoTDelete<GrPathRendering> fPathRendering; 387 // Subclass must initialize this in its constructor. 388 SkAutoTUnref<const GrCaps> fCaps; 389 390private: 391 // called when the 3D context state is unknown. Subclass should emit any 392 // assumed 3D context state and dirty any state cache. 393 virtual void onResetContext(uint32_t resetBits) = 0; 394 395 // overridden by backend-specific derived class to create objects. 396 // Texture size and sample size will have already been validated in base class before 397 // onCreateTexture/CompressedTexture are called. 398 virtual GrTexture* onCreateTexture(const GrSurfaceDesc& desc, 399 GrGpuResource::LifeCycle lifeCycle, 400 const void* srcData, size_t rowBytes) = 0; 401 virtual GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, 402 GrGpuResource::LifeCycle lifeCycle, 403 const void* srcData) = 0; 404 virtual GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) = 0; 405 virtual GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&, 406 GrWrapOwnership) = 0; 407 virtual GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) = 0; 408 virtual GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) = 0; 409 410 // overridden by backend-specific derived class to perform the clear. 411 virtual void onClear(GrRenderTarget*, const SkIRect* rect, GrColor color, 412 bool canIgnoreRect) = 0; 413 414 415 // Overridden by backend specific classes to perform a clear of the stencil clip bits. This is 416 // ONLY used by the the clip target 417 virtual void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) = 0; 418 419 // overridden by backend-specific derived class to perform the draw call. 420 virtual void onDraw(const DrawArgs&, const GrNonInstancedVertices&) = 0; 421 422 virtual bool onReadPixels(GrRenderTarget* target, 423 int left, int top, int width, int height, 424 GrPixelConfig, 425 void* buffer, 426 size_t rowBytes) = 0; 427 428 // overridden by backend-specific derived class to perform the texture update 429 virtual bool onWriteTexturePixels(GrTexture* texture, 430 int left, int top, int width, int height, 431 GrPixelConfig config, const void* buffer, 432 size_t rowBytes) = 0; 433 434 // overridden by backend-specific derived class to perform the resolve 435 virtual void onResolveRenderTarget(GrRenderTarget* target) = 0; 436 437 // width and height may be larger than rt (if underlying API allows it). 438 // Should attach the SB to the RT. Returns false if compatible sb could 439 // not be created. 440 virtual bool createStencilAttachmentForRenderTarget(GrRenderTarget*, int width, int height) = 0; 441 442 // attaches an existing SB to an existing RT. 443 virtual bool attachStencilAttachmentToRenderTarget(GrStencilAttachment*, GrRenderTarget*) = 0; 444 445 // clears target's entire stencil buffer to 0 446 virtual void clearStencil(GrRenderTarget* target) = 0; 447 448 virtual void didAddGpuTraceMarker() = 0; 449 virtual void didRemoveGpuTraceMarker() = 0; 450 451 void resetContext() { 452 this->onResetContext(fResetBits); 453 fResetBits = 0; 454 ++fResetTimestamp; 455 } 456 457 void handleDirtyContext() { 458 if (fResetBits) { 459 this->resetContext(); 460 } 461 } 462 463 ResetTimestamp fResetTimestamp; 464 uint32_t fResetBits; 465 // To keep track that we always have at least as many debug marker adds as removes 466 int fGpuTraceMarkerCount; 467 GrTraceMarkerSet fActiveTraceMarkers; 468 GrTraceMarkerSet fStoredTraceMarkers; 469 // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu. 470 GrContext* fContext; 471 472 friend class GrPathRendering; 473 typedef SkRefCnt INHERITED; 474}; 475 476#endif 477