GrGpu.h revision 5d1d79a1f9d351e6f2390d844e6a7361d7d607ca
1 2/* 3 * Copyright 2011 Google Inc. 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9 10#ifndef GrGpu_DEFINED 11#define GrGpu_DEFINED 12 13#include "GrDrawTarget.h" 14#include "GrRect.h" 15#include "GrRefCnt.h" 16#include "GrClipMaskManager.h" 17 18#include "SkPath.h" 19 20class GrContext; 21class GrIndexBufferAllocPool; 22class GrPath; 23class GrPathRenderer; 24class GrPathRendererChain; 25class GrResource; 26class GrStencilBuffer; 27class GrVertexBufferAllocPool; 28 29class GrGpu : public GrDrawTarget { 30 31public: 32 33 /** 34 * Additional blend coefficients for dual source blending, not exposed 35 * through GrPaint/GrContext. 36 */ 37 enum ExtendedBlendCoeffs { 38 // source 2 refers to second output color when 39 // using dual source blending. 40 kS2C_GrBlendCoeff = kPublicGrBlendCoeffCount, 41 kIS2C_GrBlendCoeff, 42 kS2A_GrBlendCoeff, 43 kIS2A_GrBlendCoeff, 44 45 kTotalGrBlendCoeffCount 46 }; 47 48 /** 49 * Create an instance of GrGpu that matches the specified backend. If the requested backend is 50 * not supported (at compile-time or run-time) this returns NULL. The context will not be 51 * fully constructed and should not be used by GrGpu until after this function returns. 52 */ 53 static GrGpu* Create(GrBackend, GrBackendContext, GrContext* context); 54 55 //////////////////////////////////////////////////////////////////////////// 56 57 GrGpu(GrContext* context); 58 virtual ~GrGpu(); 59 60 GrContext* getContext() { return this->INHERITED::getContext(); } 61 const GrContext* getContext() const { return this->INHERITED::getContext(); } 62 63 /** 64 * The GrGpu object normally assumes that no outsider is setting state 65 * within the underlying 3D API's context/device/whatever. This call informs 66 * the GrGpu that the state was modified and it shouldn't make assumptions 67 * about the state. 68 */ 69 void markContextDirty() { fContextIsDirty = true; } 70 71 void unimpl(const char[]); 72 73 /** 74 * Creates a texture object. If desc width or height is not a power of 75 * two but underlying API requires a power of two texture then srcData 76 * will be embedded in a power of two texture. The extra width and height 77 * is filled as though srcData were rendered clamped into the texture. 78 * 79 * If kRenderTarget_TextureFlag is specified the GrRenderTarget is 80 * accessible via GrTexture::asRenderTarget(). The texture will hold a ref 81 * on the render target until the texture is destroyed. 82 * 83 * @param desc describes the texture to be created. 84 * @param srcData texel data to load texture. Begins with full-size 85 * palette data for paletted textures. Contains width* 86 * height texels. If NULL texture data is uninitialized. 87 * 88 * @return The texture object if successful, otherwise NULL. 89 */ 90 GrTexture* createTexture(const GrTextureDesc& desc, 91 const void* srcData, size_t rowBytes); 92 93 /** 94 * Implements GrContext::wrapBackendTexture 95 */ 96 GrTexture* wrapBackendTexture(const GrBackendTextureDesc&); 97 98 /** 99 * Implements GrContext::wrapBackendTexture 100 */ 101 GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc&); 102 103 /** 104 * Creates a vertex buffer. 105 * 106 * @param size size in bytes of the vertex buffer 107 * @param dynamic hints whether the data will be frequently changed 108 * by either GrVertexBuffer::lock or 109 * GrVertexBuffer::updateData. 110 * 111 * @return The vertex buffer if successful, otherwise NULL. 112 */ 113 GrVertexBuffer* createVertexBuffer(uint32_t size, bool dynamic); 114 115 /** 116 * Creates an index buffer. 117 * 118 * @param size size in bytes of the index buffer 119 * @param dynamic hints whether the data will be frequently changed 120 * by either GrIndexBuffer::lock or 121 * GrIndexBuffer::updateData. 122 * 123 * @return The index buffer if successful, otherwise NULL. 124 */ 125 GrIndexBuffer* createIndexBuffer(uint32_t size, bool dynamic); 126 127 /** 128 * Creates a path object that can be stenciled using stencilPath(). It is 129 * only legal to call this if the caps report support for path stenciling. 130 */ 131 GrPath* createPath(const SkPath& path); 132 133 /** 134 * Returns an index buffer that can be used to render quads. 135 * Six indices per quad: 0, 1, 2, 0, 2, 3, etc. 136 * The max number of quads can be queried using GrIndexBuffer::maxQuads(). 137 * Draw with kTriangles_GrPrimitiveType 138 * @ return the quad index buffer 139 */ 140 const GrIndexBuffer* getQuadIndexBuffer() const; 141 142 /** 143 * Resolves MSAA. 144 */ 145 void resolveRenderTarget(GrRenderTarget* target); 146 147 /** 148 * Ensures that the current render target is actually set in the 149 * underlying 3D API. Used when client wants to use 3D API to directly 150 * render to the RT. 151 */ 152 void forceRenderTargetFlush(); 153 154 /** 155 * Gets a preferred 8888 config to use for writing/reading pixel data to/from a surface with 156 * config surfaceConfig. The returned config must have at least as many bits per channel as the 157 * readConfig or writeConfig param. 158 */ 159 virtual GrPixelConfig preferredReadPixelsConfig(GrPixelConfig readConfig, 160 GrPixelConfig surfaceConfig) const { 161 return readConfig; 162 } 163 virtual GrPixelConfig preferredWritePixelsConfig(GrPixelConfig writeConfig, 164 GrPixelConfig surfaceConfig) const { 165 return writeConfig; 166 } 167 168 /** 169 * Called before uploading writing pixels to a GrTexture when the src pixel config doesn't 170 * match the texture's config. 171 */ 172 virtual bool canWriteTexturePixels(const GrTexture*, GrPixelConfig srcConfig) const = 0; 173 174 /** 175 * OpenGL's readPixels returns the result bottom-to-top while the skia 176 * API is top-to-bottom. Thus we have to do a y-axis flip. The obvious 177 * solution is to have the subclass do the flip using either the CPU or GPU. 178 * However, the caller (GrContext) may have transformations to apply and can 179 * simply fold in the y-flip for free. On the other hand, the subclass may 180 * be able to do it for free itself. For example, the subclass may have to 181 * do memcpys to handle rowBytes that aren't tight. It could do the y-flip 182 * concurrently. 183 * 184 * This function returns true if a y-flip is required to put the pixels in 185 * top-to-bottom order and the subclass cannot do it for free. 186 * 187 * See read pixels for the params 188 * @return true if calling readPixels with the same set of params will 189 * produce bottom-to-top data 190 */ 191 virtual bool readPixelsWillPayForYFlip(GrRenderTarget* renderTarget, 192 int left, int top, 193 int width, int height, 194 GrPixelConfig config, 195 size_t rowBytes) const = 0; 196 /** 197 * This should return true if reading a NxM rectangle of pixels from a 198 * render target is faster if the target has dimensons N and M and the read 199 * rectangle has its top-left at 0,0. 200 */ 201 virtual bool fullReadPixelsIsFasterThanPartial() const { return false; }; 202 203 /** 204 * Reads a rectangle of pixels from a render target. 205 * 206 * @param renderTarget the render target to read from. NULL means the 207 * current render target. 208 * @param left left edge of the rectangle to read (inclusive) 209 * @param top top edge of the rectangle to read (inclusive) 210 * @param width width of rectangle to read in pixels. 211 * @param height height of rectangle to read in pixels. 212 * @param config the pixel config of the destination buffer 213 * @param buffer memory to read the rectangle into. 214 * @param rowBytes the number of bytes between consecutive rows. Zero 215 * means rows are tightly packed. 216 * @param invertY buffer should be populated bottom-to-top as opposed 217 * to top-to-bottom (skia's usual order) 218 * 219 * @return true if the read succeeded, false if not. The read can fail 220 * because of a unsupported pixel config or because no render 221 * target is currently set. 222 */ 223 bool readPixels(GrRenderTarget* renderTarget, 224 int left, int top, int width, int height, 225 GrPixelConfig config, void* buffer, size_t rowBytes); 226 227 /** 228 * Updates the pixels in a rectangle of a texture. 229 * 230 * @param left left edge of the rectangle to write (inclusive) 231 * @param top top edge of the rectangle to write (inclusive) 232 * @param width width of rectangle to write in pixels. 233 * @param height height of rectangle to write in pixels. 234 * @param config the pixel config of the source buffer 235 * @param buffer memory to read pixels from 236 * @param rowBytes number of bytes between consecutive rows. Zero 237 * means rows are tightly packed. 238 */ 239 bool writeTexturePixels(GrTexture* texture, 240 int left, int top, int width, int height, 241 GrPixelConfig config, const void* buffer, 242 size_t rowBytes); 243 244 /** 245 * Called to tell Gpu object that all GrResources have been lost and should 246 * be abandoned. Overrides must call INHERITED::abandonResources(). 247 */ 248 virtual void abandonResources(); 249 250 /** 251 * Called to tell Gpu object to release all GrResources. Overrides must call 252 * INHERITED::releaseResources(). 253 */ 254 void releaseResources(); 255 256 /** 257 * Add resource to list of resources. Should only be called by GrResource. 258 * @param resource the resource to add. 259 */ 260 void insertResource(GrResource* resource); 261 262 /** 263 * Remove resource from list of resources. Should only be called by 264 * GrResource. 265 * @param resource the resource to remove. 266 */ 267 void removeResource(GrResource* resource); 268 269 // GrDrawTarget overrides 270 virtual void clear(const GrIRect* rect, 271 GrColor color, 272 GrRenderTarget* renderTarget = NULL) SK_OVERRIDE; 273 274 virtual void purgeResources() SK_OVERRIDE { 275 // The clip mask manager can rebuild all its clip masks so just 276 // get rid of them all. 277 fClipMaskManager.releaseResources(); 278 } 279 280 // After the client interacts directly with the 3D context state the GrGpu 281 // must resync its internal state and assumptions about 3D context state. 282 // Each time this occurs the GrGpu bumps a timestamp. 283 // state of the 3D context 284 // At 10 resets / frame and 60fps a 64bit timestamp will overflow in about 285 // a billion years. 286 typedef uint64_t ResetTimestamp; 287 288 // This timestamp is always older than the current timestamp 289 static const ResetTimestamp kExpiredTimestamp = 0; 290 // Returns a timestamp based on the number of times the context was reset. 291 // This timestamp can be used to lazily detect when cached 3D context state 292 // is dirty. 293 ResetTimestamp getResetTimestamp() const { 294 return fResetTimestamp; 295 } 296 297 /** 298 * Can the provided configuration act as a color render target? 299 */ 300 bool isConfigRenderable(GrPixelConfig config) const { 301 GrAssert(kGrPixelConfigCnt > config); 302 return fConfigRenderSupport[config]; 303 } 304 305 /** 306 * These methods are called by the clip manager's setupClipping function 307 * which (called as part of GrGpu's implementation of onDraw and 308 * onStencilPath member functions.) The GrGpu subclass should flush the 309 * stencil state to the 3D API in its implementation of flushGraphicsState. 310 */ 311 void enableScissor(const GrIRect& rect) { 312 fScissorState.fEnabled = true; 313 fScissorState.fRect = rect; 314 } 315 void disableScissor() { fScissorState.fEnabled = false; } 316 317 /** 318 * Like the scissor methods above this is called by setupClipping and 319 * should be flushed by the GrGpu subclass in flushGraphicsState. These 320 * stencil settings should be used in place of those on the GrDrawState. 321 * They have been adjusted to account for any interactions between the 322 * GrDrawState's stencil settings and stencil clipping. 323 */ 324 void setStencilSettings(const GrStencilSettings& settings) { 325 fStencilSettings = settings; 326 } 327 void disableStencil() { fStencilSettings.setDisabled(); } 328 329 // GrGpu subclass sets clip bit in the stencil buffer. The subclass is 330 // free to clear the remaining bits to zero if masked clears are more 331 // expensive than clearing all bits. 332 virtual void clearStencilClip(const GrIRect& rect, bool insideClip) = 0; 333 334 enum PrivateDrawStateStateBits { 335 kFirstBit = (GrDrawState::kLastPublicStateBit << 1), 336 337 kModifyStencilClip_StateBit = kFirstBit, // allows draws to modify 338 // stencil bits used for 339 // clipping. 340 }; 341 342protected: 343 enum DrawType { 344 kDrawPoints_DrawType, 345 kDrawLines_DrawType, 346 kDrawTriangles_DrawType, 347 kStencilPath_DrawType, 348 }; 349 350 DrawType PrimTypeToDrawType(GrPrimitiveType type) { 351 switch (type) { 352 case kTriangles_GrPrimitiveType: 353 case kTriangleStrip_GrPrimitiveType: 354 case kTriangleFan_GrPrimitiveType: 355 return kDrawTriangles_DrawType; 356 case kPoints_GrPrimitiveType: 357 return kDrawPoints_DrawType; 358 case kLines_GrPrimitiveType: 359 case kLineStrip_GrPrimitiveType: 360 return kDrawLines_DrawType; 361 default: 362 GrCrash("Unexpected primitive type"); 363 return kDrawTriangles_DrawType; 364 } 365 } 366 367 // prepares clip flushes gpu state before a draw 368 bool setupClipAndFlushState(DrawType, const GrDeviceCoordTexture* dstCopy); 369 370 // Functions used to map clip-respecting stencil tests into normal 371 // stencil funcs supported by GPUs. 372 static GrStencilFunc ConvertStencilFunc(bool stencilInClip, 373 GrStencilFunc func); 374 static void ConvertStencilFuncAndMask(GrStencilFunc func, 375 bool clipInStencil, 376 unsigned int clipBit, 377 unsigned int userBits, 378 unsigned int* ref, 379 unsigned int* mask); 380 381 GrClipMaskManager fClipMaskManager; 382 383 struct GeometryPoolState { 384 const GrVertexBuffer* fPoolVertexBuffer; 385 int fPoolStartVertex; 386 387 const GrIndexBuffer* fPoolIndexBuffer; 388 int fPoolStartIndex; 389 }; 390 const GeometryPoolState& getGeomPoolState() { 391 return fGeomPoolStateStack.back(); 392 } 393 394 // The state of the scissor is controlled by the clip manager 395 struct ScissorState { 396 bool fEnabled; 397 GrIRect fRect; 398 } fScissorState; 399 400 // The final stencil settings to use as determined by the clip manager. 401 GrStencilSettings fStencilSettings; 402 403 // Derived classes need access to this so they can fill it out in their 404 // constructors 405 bool fConfigRenderSupport[kGrPixelConfigCnt]; 406 407 // Helpers for setting up geometry state 408 void finalizeReservedVertices(); 409 void finalizeReservedIndices(); 410 411private: 412 // GrDrawTarget overrides 413 virtual bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) SK_OVERRIDE; 414 virtual bool onReserveIndexSpace(int indexCount, void** indices) SK_OVERRIDE; 415 virtual void releaseReservedVertexSpace() SK_OVERRIDE; 416 virtual void releaseReservedIndexSpace() SK_OVERRIDE; 417 virtual void onSetVertexSourceToArray(const void* vertexArray, int vertexCount) SK_OVERRIDE; 418 virtual void onSetIndexSourceToArray(const void* indexArray, int indexCount) SK_OVERRIDE; 419 virtual void releaseVertexArray() SK_OVERRIDE; 420 virtual void releaseIndexArray() SK_OVERRIDE; 421 virtual void geometrySourceWillPush() SK_OVERRIDE; 422 virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) SK_OVERRIDE; 423 424 425 // called when the 3D context state is unknown. Subclass should emit any 426 // assumed 3D context state and dirty any state cache. 427 virtual void onResetContext() = 0; 428 429 // overridden by backend-specific derived class to create objects. 430 virtual GrTexture* onCreateTexture(const GrTextureDesc& desc, 431 const void* srcData, 432 size_t rowBytes) = 0; 433 virtual GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) = 0; 434 virtual GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) = 0; 435 virtual GrVertexBuffer* onCreateVertexBuffer(uint32_t size, bool dynamic) = 0; 436 virtual GrIndexBuffer* onCreateIndexBuffer(uint32_t size, bool dynamic) = 0; 437 virtual GrPath* onCreatePath(const SkPath& path) = 0; 438 439 // overridden by backend-specific derived class to perform the clear and 440 // clearRect. NULL rect means clear whole target. 441 virtual void onClear(const GrIRect* rect, GrColor color) = 0; 442 443 // overridden by backend-specific derived class to perform the draw call. 444 virtual void onGpuDraw(const DrawInfo&) = 0; 445 // when GrDrawTarget::stencilPath is called the draw state's current stencil 446 // settings are ignored. Instead the GrGpu decides the stencil rules 447 // necessary to stencil the path. These are still subject to filtering by 448 // the clip mask manager. 449 virtual void setStencilPathSettings(const GrPath&, 450 SkPath::FillType, 451 GrStencilSettings* settings) = 0; 452 // overridden by backend-specific derived class to perform the path stenciling. 453 virtual void onGpuStencilPath(const GrPath*, SkPath::FillType) = 0; 454 455 // overridden by backend-specific derived class to perform flush 456 virtual void onForceRenderTargetFlush() = 0; 457 458 // overridden by backend-specific derived class to perform the read pixels. 459 virtual bool onReadPixels(GrRenderTarget* target, 460 int left, int top, int width, int height, 461 GrPixelConfig, 462 void* buffer, 463 size_t rowBytes) = 0; 464 465 // overridden by backend-specific derived class to perform the texture update 466 virtual bool onWriteTexturePixels(GrTexture* texture, 467 int left, int top, int width, int height, 468 GrPixelConfig config, const void* buffer, 469 size_t rowBytes) = 0; 470 471 // overridden by backend-specific derived class to perform the resolve 472 virtual void onResolveRenderTarget(GrRenderTarget* target) = 0; 473 474 // width and height may be larger than rt (if underlying API allows it). 475 // Should attach the SB to the RT. Returns false if compatible sb could 476 // not be created. 477 virtual bool createStencilBufferForRenderTarget(GrRenderTarget*, int width, int height) = 0; 478 479 // attaches an existing SB to an existing RT. 480 virtual bool attachStencilBufferToRenderTarget(GrStencilBuffer*, GrRenderTarget*) = 0; 481 482 // The GrGpu typically records the clients requested state and then flushes 483 // deltas from previous state at draw time. This function does the 484 // backend-specific flush of the state. 485 // returns false if current state is unsupported. 486 virtual bool flushGraphicsState(DrawType, const GrDeviceCoordTexture* dstCopy) = 0; 487 488 // clears the entire stencil buffer to 0 489 virtual void clearStencil() = 0; 490 491 // Given a rt, find or create a stencil buffer and attach it 492 bool attachStencilBufferToRenderTarget(GrRenderTarget* target); 493 494 // GrDrawTarget overrides 495 virtual void onDraw(const DrawInfo&) SK_OVERRIDE; 496 virtual void onStencilPath(const GrPath* path, const SkStrokeRec& stroke, 497 SkPath::FillType) SK_OVERRIDE; 498 499 // readies the pools to provide vertex/index data. 500 void prepareVertexPool(); 501 void prepareIndexPool(); 502 503 void resetContext() { 504 // We call this because the client may have messed with the 505 // stencil buffer. Perhaps we should detect whether it is a 506 // internally created stencil buffer and if so skip the invalidate. 507 fClipMaskManager.invalidateStencilMask(); 508 this->onResetContext(); 509 ++fResetTimestamp; 510 } 511 512 void handleDirtyContext() { 513 if (fContextIsDirty) { 514 this->resetContext(); 515 fContextIsDirty = false; 516 } 517 } 518 519 enum { 520 kPreallocGeomPoolStateStackCnt = 4, 521 }; 522 typedef SkTInternalLList<GrResource> ResourceList; 523 SkSTArray<kPreallocGeomPoolStateStackCnt, GeometryPoolState, true> fGeomPoolStateStack; 524 ResetTimestamp fResetTimestamp; 525 GrVertexBufferAllocPool* fVertexPool; 526 GrIndexBufferAllocPool* fIndexPool; 527 // counts number of uses of vertex/index pool in the geometry stack 528 int fVertexPoolUseCnt; 529 int fIndexPoolUseCnt; 530 // these are mutable so they can be created on-demand 531 mutable GrIndexBuffer* fQuadIndexBuffer; 532 bool fContextIsDirty; 533 // Used to abandon/release all resources created by this GrGpu. TODO: Move this 534 // functionality to GrResourceCache. 535 ResourceList fResourceList; 536 537 typedef GrDrawTarget INHERITED; 538}; 539 540#endif 541