diff -r 000000000000 -r 6474c204b198 gfx/skia/trunk/src/gpu/GrGpu.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gfx/skia/trunk/src/gpu/GrGpu.h Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,528 @@ +/* + * Copyright 2011 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef GrGpu_DEFINED +#define GrGpu_DEFINED + +#include "GrDrawTarget.h" +#include "GrClipMaskManager.h" +#include "SkPath.h" + +class GrContext; +class GrIndexBufferAllocPool; +class GrPath; +class GrPathRenderer; +class GrPathRendererChain; +class GrResource; +class GrStencilBuffer; +class GrVertexBufferAllocPool; + +class GrGpu : public GrDrawTarget { +public: + + /** + * Additional blend coefficients for dual source blending, not exposed + * through GrPaint/GrContext. + */ + enum ExtendedBlendCoeffs { + // source 2 refers to second output color when + // using dual source blending. + kS2C_GrBlendCoeff = kPublicGrBlendCoeffCount, + kIS2C_GrBlendCoeff, + kS2A_GrBlendCoeff, + kIS2A_GrBlendCoeff, + + kTotalGrBlendCoeffCount + }; + + /** + * Create an instance of GrGpu that matches the specified backend. If the requested backend is + * not supported (at compile-time or run-time) this returns NULL. The context will not be + * fully constructed and should not be used by GrGpu until after this function returns. + */ + static GrGpu* Create(GrBackend, GrBackendContext, GrContext* context); + + //////////////////////////////////////////////////////////////////////////// + + GrGpu(GrContext* context); + virtual ~GrGpu(); + + GrContext* getContext() { return this->INHERITED::getContext(); } + const GrContext* getContext() const { return this->INHERITED::getContext(); } + + /** + * The GrGpu object normally assumes that no outsider is setting state + * within the underlying 3D API's context/device/whatever. This call informs + * the GrGpu that the state was modified and it shouldn't make assumptions + * about the state. + */ + void markContextDirty(uint32_t state = kAll_GrBackendState) { + fResetBits |= state; + } + + void unimpl(const char[]); + + /** + * Creates a texture object. If desc width or height is not a power of + * two but underlying API requires a power of two texture then srcData + * will be embedded in a power of two texture. The extra width and height + * is filled as though srcData were rendered clamped into the texture. + * + * If kRenderTarget_TextureFlag is specified the GrRenderTarget is + * accessible via GrTexture::asRenderTarget(). The texture will hold a ref + * on the render target until the texture is destroyed. + * + * @param desc describes the texture to be created. + * @param srcData texel data to load texture. Begins with full-size + * palette data for paletted textures. Contains width* + * height texels. If NULL texture data is uninitialized. + * + * @return The texture object if successful, otherwise NULL. + */ + GrTexture* createTexture(const GrTextureDesc& desc, + const void* srcData, size_t rowBytes); + + /** + * Implements GrContext::wrapBackendTexture + */ + GrTexture* wrapBackendTexture(const GrBackendTextureDesc&); + + /** + * Implements GrContext::wrapBackendTexture + */ + GrRenderTarget* wrapBackendRenderTarget(const GrBackendRenderTargetDesc&); + + /** + * Creates a vertex buffer. + * + * @param size size in bytes of the vertex buffer + * @param dynamic hints whether the data will be frequently changed + * by either GrVertexBuffer::lock or + * GrVertexBuffer::updateData. + * + * @return The vertex buffer if successful, otherwise NULL. + */ + GrVertexBuffer* createVertexBuffer(size_t size, bool dynamic); + + /** + * Creates an index buffer. + * + * @param size size in bytes of the index buffer + * @param dynamic hints whether the data will be frequently changed + * by either GrIndexBuffer::lock or + * GrIndexBuffer::updateData. + * + * @return The index buffer if successful, otherwise NULL. + */ + GrIndexBuffer* createIndexBuffer(size_t size, bool dynamic); + + /** + * Creates a path object that can be stenciled using stencilPath(). It is + * only legal to call this if the caps report support for path stenciling. + */ + GrPath* createPath(const SkPath& path, const SkStrokeRec& stroke); + + /** + * Returns an index buffer that can be used to render quads. + * Six indices per quad: 0, 1, 2, 0, 2, 3, etc. + * The max number of quads can be queried using GrIndexBuffer::maxQuads(). + * Draw with kTriangles_GrPrimitiveType + * @ return the quad index buffer + */ + const GrIndexBuffer* getQuadIndexBuffer() const; + + /** + * Resolves MSAA. + */ + void resolveRenderTarget(GrRenderTarget* target); + + /** + * Ensures that the current render target is actually set in the + * underlying 3D API. Used when client wants to use 3D API to directly + * render to the RT. + */ + void forceRenderTargetFlush(); + + /** + * Gets a preferred 8888 config to use for writing/reading pixel data to/from a surface with + * config surfaceConfig. The returned config must have at least as many bits per channel as the + * readConfig or writeConfig param. + */ + virtual GrPixelConfig preferredReadPixelsConfig(GrPixelConfig readConfig, + GrPixelConfig surfaceConfig) const { + return readConfig; + } + virtual GrPixelConfig preferredWritePixelsConfig(GrPixelConfig writeConfig, + GrPixelConfig surfaceConfig) const { + return writeConfig; + } + + /** + * Called before uploading writing pixels to a GrTexture when the src pixel config doesn't + * match the texture's config. + */ + virtual bool canWriteTexturePixels(const GrTexture*, GrPixelConfig srcConfig) const = 0; + + /** + * OpenGL's readPixels returns the result bottom-to-top while the skia + * API is top-to-bottom. Thus we have to do a y-axis flip. The obvious + * solution is to have the subclass do the flip using either the CPU or GPU. + * However, the caller (GrContext) may have transformations to apply and can + * simply fold in the y-flip for free. On the other hand, the subclass may + * be able to do it for free itself. For example, the subclass may have to + * do memcpys to handle rowBytes that aren't tight. It could do the y-flip + * concurrently. + * + * This function returns true if a y-flip is required to put the pixels in + * top-to-bottom order and the subclass cannot do it for free. + * + * See read pixels for the params + * @return true if calling readPixels with the same set of params will + * produce bottom-to-top data + */ + virtual bool readPixelsWillPayForYFlip(GrRenderTarget* renderTarget, + int left, int top, + int width, int height, + GrPixelConfig config, + size_t rowBytes) const = 0; + /** + * This should return true if reading a NxM rectangle of pixels from a + * render target is faster if the target has dimensons N and M and the read + * rectangle has its top-left at 0,0. + */ + virtual bool fullReadPixelsIsFasterThanPartial() const { return false; }; + + /** + * Reads a rectangle of pixels from a render target. + * + * @param renderTarget the render target to read from. NULL means the + * current render target. + * @param left left edge of the rectangle to read (inclusive) + * @param top top edge of the rectangle to read (inclusive) + * @param width width of rectangle to read in pixels. + * @param height height of rectangle to read in pixels. + * @param config the pixel config of the destination buffer + * @param buffer memory to read the rectangle into. + * @param rowBytes the number of bytes between consecutive rows. Zero + * means rows are tightly packed. + * @param invertY buffer should be populated bottom-to-top as opposed + * to top-to-bottom (skia's usual order) + * + * @return true if the read succeeded, false if not. The read can fail + * because of a unsupported pixel config or because no render + * target is currently set. + */ + bool readPixels(GrRenderTarget* renderTarget, + int left, int top, int width, int height, + GrPixelConfig config, void* buffer, size_t rowBytes); + + /** + * Updates the pixels in a rectangle of a texture. + * + * @param left left edge of the rectangle to write (inclusive) + * @param top top edge of the rectangle to write (inclusive) + * @param width width of rectangle to write in pixels. + * @param height height of rectangle to write in pixels. + * @param config the pixel config of the source buffer + * @param buffer memory to read pixels from + * @param rowBytes number of bytes between consecutive rows. Zero + * means rows are tightly packed. + */ + bool writeTexturePixels(GrTexture* texture, + int left, int top, int width, int height, + GrPixelConfig config, const void* buffer, + size_t rowBytes); + + /** + * Called to tell Gpu object that all GrResources have been lost and should + * be abandoned. Overrides must call INHERITED::abandonResources(). + */ + virtual void abandonResources(); + + /** + * Called to tell Gpu object to release all GrResources. Overrides must call + * INHERITED::releaseResources(). + */ + void releaseResources(); + + /** + * Add resource to list of resources. Should only be called by GrResource. + * @param resource the resource to add. + */ + void insertResource(GrResource* resource); + + /** + * Remove resource from list of resources. Should only be called by + * GrResource. + * @param resource the resource to remove. + */ + void removeResource(GrResource* resource); + + // GrDrawTarget overrides + virtual void clear(const SkIRect* rect, + GrColor color, + bool canIgnoreRect, + GrRenderTarget* renderTarget = NULL) SK_OVERRIDE; + + virtual void purgeResources() SK_OVERRIDE { + // The clip mask manager can rebuild all its clip masks so just + // get rid of them all. + fClipMaskManager.releaseResources(); + } + + // After the client interacts directly with the 3D context state the GrGpu + // must resync its internal state and assumptions about 3D context state. + // Each time this occurs the GrGpu bumps a timestamp. + // state of the 3D context + // At 10 resets / frame and 60fps a 64bit timestamp will overflow in about + // a billion years. + typedef uint64_t ResetTimestamp; + + // This timestamp is always older than the current timestamp + static const ResetTimestamp kExpiredTimestamp = 0; + // Returns a timestamp based on the number of times the context was reset. + // This timestamp can be used to lazily detect when cached 3D context state + // is dirty. + ResetTimestamp getResetTimestamp() const { + return fResetTimestamp; + } + + /** + * These methods are called by the clip manager's setupClipping function + * which (called as part of GrGpu's implementation of onDraw and + * onStencilPath member functions.) The GrGpu subclass should flush the + * stencil state to the 3D API in its implementation of flushGraphicsState. + */ + void enableScissor(const SkIRect& rect) { + fScissorState.fEnabled = true; + fScissorState.fRect = rect; + } + void disableScissor() { fScissorState.fEnabled = false; } + + /** + * Like the scissor methods above this is called by setupClipping and + * should be flushed by the GrGpu subclass in flushGraphicsState. These + * stencil settings should be used in place of those on the GrDrawState. + * They have been adjusted to account for any interactions between the + * GrDrawState's stencil settings and stencil clipping. + */ + void setStencilSettings(const GrStencilSettings& settings) { + fStencilSettings = settings; + } + void disableStencil() { fStencilSettings.setDisabled(); } + + // GrGpu subclass sets clip bit in the stencil buffer. The subclass is + // free to clear the remaining bits to zero if masked clears are more + // expensive than clearing all bits. + virtual void clearStencilClip(const SkIRect& rect, bool insideClip) = 0; + + enum PrivateDrawStateStateBits { + kFirstBit = (GrDrawState::kLastPublicStateBit << 1), + + kModifyStencilClip_StateBit = kFirstBit, // allows draws to modify + // stencil bits used for + // clipping. + }; + + void getPathStencilSettingsForFillType(SkPath::FillType fill, GrStencilSettings* outStencilSettings); + +protected: + enum DrawType { + kDrawPoints_DrawType, + kDrawLines_DrawType, + kDrawTriangles_DrawType, + kStencilPath_DrawType, + kDrawPath_DrawType, + }; + + DrawType PrimTypeToDrawType(GrPrimitiveType type) { + switch (type) { + case kTriangles_GrPrimitiveType: + case kTriangleStrip_GrPrimitiveType: + case kTriangleFan_GrPrimitiveType: + return kDrawTriangles_DrawType; + case kPoints_GrPrimitiveType: + return kDrawPoints_DrawType; + case kLines_GrPrimitiveType: + case kLineStrip_GrPrimitiveType: + return kDrawLines_DrawType; + default: + GrCrash("Unexpected primitive type"); + return kDrawTriangles_DrawType; + } + } + + // prepares clip flushes gpu state before a draw + bool setupClipAndFlushState(DrawType, + const GrDeviceCoordTexture* dstCopy, + GrDrawState::AutoRestoreEffects* are, + const SkRect* devBounds); + + // Functions used to map clip-respecting stencil tests into normal + // stencil funcs supported by GPUs. + static GrStencilFunc ConvertStencilFunc(bool stencilInClip, + GrStencilFunc func); + static void ConvertStencilFuncAndMask(GrStencilFunc func, + bool clipInStencil, + unsigned int clipBit, + unsigned int userBits, + unsigned int* ref, + unsigned int* mask); + + GrClipMaskManager fClipMaskManager; + + struct GeometryPoolState { + const GrVertexBuffer* fPoolVertexBuffer; + int fPoolStartVertex; + + const GrIndexBuffer* fPoolIndexBuffer; + int fPoolStartIndex; + }; + const GeometryPoolState& getGeomPoolState() { + return fGeomPoolStateStack.back(); + } + + // The state of the scissor is controlled by the clip manager + struct ScissorState { + bool fEnabled; + SkIRect fRect; + } fScissorState; + + // The final stencil settings to use as determined by the clip manager. + GrStencilSettings fStencilSettings; + + // Helpers for setting up geometry state + void finalizeReservedVertices(); + void finalizeReservedIndices(); + +private: + // GrDrawTarget overrides + virtual bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) SK_OVERRIDE; + virtual bool onReserveIndexSpace(int indexCount, void** indices) SK_OVERRIDE; + virtual void releaseReservedVertexSpace() SK_OVERRIDE; + virtual void releaseReservedIndexSpace() SK_OVERRIDE; + virtual void onSetVertexSourceToArray(const void* vertexArray, int vertexCount) SK_OVERRIDE; + virtual void onSetIndexSourceToArray(const void* indexArray, int indexCount) SK_OVERRIDE; + virtual void releaseVertexArray() SK_OVERRIDE; + virtual void releaseIndexArray() SK_OVERRIDE; + virtual void geometrySourceWillPush() SK_OVERRIDE; + virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) SK_OVERRIDE; + + + // called when the 3D context state is unknown. Subclass should emit any + // assumed 3D context state and dirty any state cache. + virtual void onResetContext(uint32_t resetBits) = 0; + + // overridden by backend-specific derived class to create objects. + virtual GrTexture* onCreateTexture(const GrTextureDesc& desc, + const void* srcData, + size_t rowBytes) = 0; + virtual GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) = 0; + virtual GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) = 0; + virtual GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) = 0; + virtual GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) = 0; + virtual GrPath* onCreatePath(const SkPath& path, const SkStrokeRec&) = 0; + + // overridden by backend-specific derived class to perform the clear and + // clearRect. NULL rect means clear whole target. If canIgnoreRect is + // true, it is okay to perform a full clear instead of a partial clear + virtual void onClear(const SkIRect* rect, GrColor color, bool canIgnoreRect) = 0; + + // overridden by backend-specific derived class to perform the draw call. + virtual void onGpuDraw(const DrawInfo&) = 0; + + // overridden by backend-specific derived class to perform the path stenciling. + virtual void onGpuStencilPath(const GrPath*, SkPath::FillType) = 0; + virtual void onGpuDrawPath(const GrPath*, SkPath::FillType) = 0; + + // overridden by backend-specific derived class to perform flush + virtual void onForceRenderTargetFlush() = 0; + + // overridden by backend-specific derived class to perform the read pixels. + virtual bool onReadPixels(GrRenderTarget* target, + int left, int top, int width, int height, + GrPixelConfig, + void* buffer, + size_t rowBytes) = 0; + + // overridden by backend-specific derived class to perform the texture update + virtual bool onWriteTexturePixels(GrTexture* texture, + int left, int top, int width, int height, + GrPixelConfig config, const void* buffer, + size_t rowBytes) = 0; + + // overridden by backend-specific derived class to perform the resolve + virtual void onResolveRenderTarget(GrRenderTarget* target) = 0; + + // width and height may be larger than rt (if underlying API allows it). + // Should attach the SB to the RT. Returns false if compatible sb could + // not be created. + virtual bool createStencilBufferForRenderTarget(GrRenderTarget*, int width, int height) = 0; + + // attaches an existing SB to an existing RT. + virtual bool attachStencilBufferToRenderTarget(GrStencilBuffer*, GrRenderTarget*) = 0; + + // The GrGpu typically records the clients requested state and then flushes + // deltas from previous state at draw time. This function does the + // backend-specific flush of the state. + // returns false if current state is unsupported. + virtual bool flushGraphicsState(DrawType, const GrDeviceCoordTexture* dstCopy) = 0; + + // clears the entire stencil buffer to 0 + virtual void clearStencil() = 0; + + // Given a rt, find or create a stencil buffer and attach it + bool attachStencilBufferToRenderTarget(GrRenderTarget* target); + + // GrDrawTarget overrides + virtual void onDraw(const DrawInfo&) SK_OVERRIDE; + virtual void onStencilPath(const GrPath*, SkPath::FillType) SK_OVERRIDE; + virtual void onDrawPath(const GrPath*, SkPath::FillType, + const GrDeviceCoordTexture* dstCopy) SK_OVERRIDE; + + // readies the pools to provide vertex/index data. + void prepareVertexPool(); + void prepareIndexPool(); + + void resetContext() { + // We call this because the client may have messed with the + // stencil buffer. Perhaps we should detect whether it is a + // internally created stencil buffer and if so skip the invalidate. + fClipMaskManager.invalidateStencilMask(); + this->onResetContext(fResetBits); + fResetBits = 0; + ++fResetTimestamp; + } + + void handleDirtyContext() { + if (fResetBits) { + this->resetContext(); + } + } + + enum { + kPreallocGeomPoolStateStackCnt = 4, + }; + typedef SkTInternalLList ResourceList; + SkSTArray fGeomPoolStateStack; + ResetTimestamp fResetTimestamp; + uint32_t fResetBits; + GrVertexBufferAllocPool* fVertexPool; + GrIndexBufferAllocPool* fIndexPool; + // counts number of uses of vertex/index pool in the geometry stack + int fVertexPoolUseCnt; + int fIndexPoolUseCnt; + // these are mutable so they can be created on-demand + mutable GrIndexBuffer* fQuadIndexBuffer; + // Used to abandon/release all resources created by this GrGpu. TODO: Move this + // functionality to GrResourceCache. + ResourceList fResourceList; + + typedef GrDrawTarget INHERITED; +}; + +#endif