| |
| /* |
| * Copyright 2010 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| |
| #ifndef GrContext_DEFINED |
| #define GrContext_DEFINED |
| |
| #include "GrClip.h" |
| #include "GrPaint.h" |
| #include "GrAARectRenderer.h" |
| // not strictly needed but requires WK change in LayerTextureUpdaterCanvas to |
| // remove. |
| #include "GrRenderTarget.h" |
| |
| class GrAutoScratchTexture; |
| class GrDrawState; |
| class GrDrawTarget; |
| class GrFontCache; |
| class GrGpu; |
| class GrIndexBuffer; |
| class GrIndexBufferAllocPool; |
| class GrInOrderDrawBuffer; |
| class GrPathRenderer; |
| class GrPathRendererChain; |
| class GrResourceEntry; |
| class GrResourceCache; |
| class GrStencilBuffer; |
| class GrVertexBuffer; |
| class GrVertexBufferAllocPool; |
| class GrSoftwarePathRenderer; |
| |
| class GR_API GrContext : public GrRefCnt { |
| public: |
| /** |
| * Creates a GrContext from within a 3D context. |
| */ |
| static GrContext* Create(GrEngine engine, |
| GrPlatform3DContext context3D); |
| |
| /** |
| * Returns the number of GrContext instances for the current thread. |
| */ |
| static int GetThreadInstanceCount(); |
| |
| virtual ~GrContext(); |
| |
| /** |
| * The GrContext normally assumes that no outsider is setting state |
| * within the underlying 3D API's context/device/whatever. This call informs |
| * the context that the state was modified and it should resend. Shouldn't |
| * be called frequently for good performance. |
| */ |
| void resetContext(); |
| |
| /** |
| * Abandons all gpu resources, assumes 3D API state is unknown. Call this |
| * if you have lost the associated GPU context, and thus internal texture, |
| * buffer, etc. references/IDs are now invalid. Should be called even when |
| * GrContext is no longer going to be used for two reasons: |
| * 1) ~GrContext will not try to free the objects in the 3D API. |
| * 2) If you've created GrResources that outlive the GrContext they will |
| * be marked as invalid (GrResource::isValid()) and won't attempt to |
| * free their underlying resource in the 3D API. |
| * Content drawn since the last GrContext::flush() may be lost. |
| */ |
| void contextLost(); |
| |
| /** |
| * Similar to contextLost, but makes no attempt to reset state. |
| * Use this method when GrContext destruction is pending, but |
| * the graphics context is destroyed first. |
| */ |
| void contextDestroyed(); |
| |
| /** |
| * Frees gpu created by the context. Can be called to reduce GPU memory |
| * pressure. |
| */ |
| void freeGpuResources(); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Textures |
| |
| /** |
| * Token that refers to an entry in the texture cache. Returned by |
| * functions that lock textures. Passed to unlockTexture. |
| */ |
| class SK_API TextureCacheEntry { |
| public: |
| TextureCacheEntry() : fEntry(NULL) {} |
| TextureCacheEntry(const TextureCacheEntry& e) : fEntry(e.fEntry) {} |
| TextureCacheEntry& operator= (const TextureCacheEntry& e) { |
| fEntry = e.fEntry; |
| return *this; |
| } |
| GrTexture* texture() const; |
| void reset() { fEntry = NULL; } |
| private: |
| explicit TextureCacheEntry(GrResourceEntry* entry) { fEntry = entry; } |
| void set(GrResourceEntry* entry) { fEntry = entry; } |
| GrResourceEntry* cacheEntry() { return fEntry; } |
| GrResourceEntry* fEntry; |
| friend class GrContext; |
| }; |
| |
| /** |
| * Create a new entry, based on the specified key and texture, and return |
| * its "locked" entry. Must call be balanced with an unlockTexture() call. |
| * |
| * @param sampler The sampler state used to draw a texture may be used |
| * to determine how to store the pixel data in the texture |
| * cache. (e.g. different versions may exist for different |
| * wrap modes on GPUs with limited or no NPOT texture |
| * support). Only the wrap and filter fields are used. NULL |
| * implies clamp wrap modes and nearest filtering. |
| * @param desc Description of the texture properties. |
| * @param srcData Pointer to the pixel values. |
| * @param rowBytes The number of bytes between rows of the texture. Zero |
| * implies tightly packed rows. |
| */ |
| TextureCacheEntry createAndLockTexture(const GrSamplerState* sampler, |
| const GrTextureDesc& desc, |
| void* srcData, size_t rowBytes); |
| |
| /** |
| * Search for an entry based on key and dimensions. If found, "lock" it and |
| * return it. The entry's texture() function will return NULL if not found. |
| * Must be balanced with an unlockTexture() call. |
| * |
| * @param desc Description of the texture properties. |
| * @param sampler The sampler state used to draw a texture may be used |
| * to determine the cache entry used. (e.g. different |
| * versions may exist for different wrap modes on GPUs with |
| * limited or no NPOT texture support). Only the wrap and |
| * filter fields are used. NULL implies clamp wrap modes |
| * and nearest filtering. |
| */ |
| TextureCacheEntry findAndLockTexture(const GrTextureDesc& desc, |
| const GrSamplerState* sampler); |
| /** |
| * Determines whether a texture is in the cache. If the texture is found it |
| * will not be locked or returned. This call does not affect the priority of |
| * the texture for deletion. |
| */ |
| bool isTextureInCache(const GrTextureDesc& desc, |
| const GrSamplerState* sampler) const; |
| |
| /** |
| * Enum that determines how closely a returned scratch texture must match |
| * a provided GrTextureDesc. |
| */ |
| enum ScratchTexMatch { |
| /** |
| * Finds a texture that exactly matches the descriptor. |
| */ |
| kExact_ScratchTexMatch, |
| /** |
| * Finds a texture that approximately matches the descriptor. Will be |
| * at least as large in width and height as desc specifies. If desc |
| * specifies that texture is a render target then result will be a |
| * render target. If desc specifies a render target and doesn't set the |
| * no stencil flag then result will have a stencil. Format and aa level |
| * will always match. |
| */ |
| kApprox_ScratchTexMatch |
| }; |
| |
| /** |
| * Returns a texture matching the desc. It's contents are unknown. Subsequent |
| * requests with the same descriptor are not guaranteed to return the same |
| * texture. The same texture is guaranteed not be returned again until it is |
| * unlocked. Must call be balanced with an unlockTexture() call. |
| * |
| * Textures created by createAndLockTexture() hide the complications of |
| * tiling non-power-of-two textures on APIs that don't support this (e.g. |
| * unextended GLES2). Tiling a npot texture created by lockScratchTexture on |
| * such an API will create gaps in the tiling pattern. This includes clamp |
| * mode. (This may be addressed in a future update.) |
| */ |
| TextureCacheEntry lockScratchTexture(const GrTextureDesc& desc, |
| ScratchTexMatch match); |
| |
| /** |
| * When done with an entry, call unlockTexture(entry) on it, which returns |
| * it to the cache, where it may be purged. |
| */ |
| void unlockTexture(TextureCacheEntry entry); |
| |
| /** |
| * Creates a texture that is outside the cache. Does not count against |
| * cache's budget. |
| */ |
| GrTexture* createUncachedTexture(const GrTextureDesc& desc, |
| void* srcData, |
| size_t rowBytes); |
| |
| /** |
| * Returns true if the specified use of an indexed texture is supported. |
| */ |
| bool supportsIndex8PixelConfig(const GrSamplerState* sampler, |
| int width, |
| int height) const; |
| |
| /** |
| * Return the current texture cache budget in bytes. |
| */ |
| size_t getTextureCacheBudget() const; |
| |
| /** |
| * Specify the texture cache budget. If the current cache size exceeds the |
| * budget it will immediately be purged to be within the budget. |
| * |
| * @param maxTextureBytes The maximum number of bytes of texture memory |
| * that can be held in the cache. |
| */ |
| void setTextureCacheBudget(size_t maxTextureBytes); |
| // DEPRECATED, this will be deleted soon. |
| void setTextureCacheLimits(int ignored, size_t maxTextureBytes) { |
| this->setTextureCacheBudget(maxTextureBytes); |
| } |
| |
| /** |
| * Returns the current number of bytes of GPU memory hosted by the texture |
| * cache. |
| */ |
| size_t getGpuTextureCacheBytes() const; |
| |
| /** |
| * Return the max width or height of a texture supported by the current gpu |
| */ |
| int getMaxTextureSize() const; |
| |
| /** |
| * Return the max width or height of a render target supported by the |
| * current gpu |
| */ |
| int getMaxRenderTargetSize() const; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Render targets |
| |
| /** |
| * Sets the render target. |
| * @param target the render target to set. (should not be NULL.) |
| */ |
| void setRenderTarget(GrRenderTarget* target); |
| |
| /** |
| * Gets the current render target. |
| * @return the currently bound render target. Should never be NULL. |
| */ |
| const GrRenderTarget* getRenderTarget() const; |
| GrRenderTarget* getRenderTarget(); |
| |
| GrAARectRenderer* getAARectRenderer() { return fAARectRenderer; } |
| |
| /** |
| * Can the provided configuration act as a color render target? |
| */ |
| bool isConfigRenderable(GrPixelConfig config) const; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Platform Surfaces |
| |
| /** |
| * Wraps an existing texture with a GrTexture object. |
| * |
| * OpenGL: if the object is a texture Gr may change its GL texture params |
| * when it is drawn. |
| * |
| * @param desc description of the object to create. |
| * |
| * @return GrTexture object or NULL on failure. |
| */ |
| GrTexture* createPlatformTexture(const GrPlatformTextureDesc& desc); |
| |
| /** |
| * Wraps an existing render target with a GrRenderTarget object. It is |
| * similar to createPlatformTexture but can be used to draw into surfaces |
| * that are not also textures (e.g. FBO 0 in OpenGL, or an MSAA buffer that |
| * the client will resolve to a texture). |
| * |
| * @param desc description of the object to create. |
| * |
| * @return GrTexture object or NULL on failure. |
| */ |
| GrRenderTarget* createPlatformRenderTarget( |
| const GrPlatformRenderTargetDesc& desc); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Matrix state |
| |
| /** |
| * Gets the current transformation matrix. |
| * @return the current matrix. |
| */ |
| const GrMatrix& getMatrix() const; |
| |
| /** |
| * Sets the transformation matrix. |
| * @param m the matrix to set. |
| */ |
| void setMatrix(const GrMatrix& m); |
| |
| /** |
| * Concats the current matrix. The passed matrix is applied before the |
| * current matrix. |
| * @param m the matrix to concat. |
| */ |
| void concatMatrix(const GrMatrix& m) const; |
| |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Clip state |
| /** |
| * Gets the current clip. |
| * @return the current clip. |
| */ |
| const GrClip& getClip() const; |
| |
| /** |
| * Sets the clip. |
| * @param clip the clip to set. |
| */ |
| void setClip(const GrClip& clip); |
| |
| /** |
| * Convenience method for setting the clip to a rect. |
| * @param rect the rect to set as the new clip. |
| */ |
| void setClip(const GrIRect& rect); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Draws |
| |
| /** |
| * Clear the entire or rect of the render target, ignoring any clips. |
| * @param rect the rect to clear or the whole thing if rect is NULL. |
| * @param color the color to clear to. |
| * @param target if non-NULL, the render target to clear otherwise clear |
| * the current render target |
| */ |
| void clear(const GrIRect* rect, GrColor color, |
| GrRenderTarget* target = NULL); |
| |
| /** |
| * Draw everywhere (respecting the clip) with the paint. |
| */ |
| void drawPaint(const GrPaint& paint); |
| |
| /** |
| * Draw the rect using a paint. |
| * @param paint describes how to color pixels. |
| * @param strokeWidth If strokeWidth < 0, then the rect is filled, else |
| * the rect is mitered stroked based on strokeWidth. If |
| * strokeWidth == 0, then the stroke is always a single |
| * pixel thick. |
| * @param matrix Optional matrix applied to the rect. Applied before |
| * context's matrix or the paint's matrix. |
| * The rects coords are used to access the paint (through texture matrix) |
| */ |
| void drawRect(const GrPaint& paint, |
| const GrRect&, |
| GrScalar strokeWidth = -1, |
| const GrMatrix* matrix = NULL); |
| |
| /** |
| * Maps a rect of paint coordinates onto the a rect of destination |
| * coordinates. Each rect can optionally be transformed. The srcRect |
| * is stretched over the dstRect. The dstRect is transformed by the |
| * context's matrix and the srcRect is transformed by the paint's matrix. |
| * Additional optional matrices can be provided by parameters. |
| * |
| * @param paint describes how to color pixels. |
| * @param dstRect the destination rect to draw. |
| * @param srcRect rect of paint coordinates to be mapped onto dstRect |
| * @param dstMatrix Optional matrix to transform dstRect. Applied before |
| * context's matrix. |
| * @param srcMatrix Optional matrix to transform srcRect Applied before |
| * paint's matrix. |
| */ |
| void drawRectToRect(const GrPaint& paint, |
| const GrRect& dstRect, |
| const GrRect& srcRect, |
| const GrMatrix* dstMatrix = NULL, |
| const GrMatrix* srcMatrix = NULL); |
| |
| /** |
| * Draws a path. |
| * |
| * @param paint describes how to color pixels. |
| * @param path the path to draw |
| * @param fill the path filling rule to use. |
| * @param translate optional additional translation applied to the |
| * path. |
| */ |
| void drawPath(const GrPaint& paint, const SkPath& path, GrPathFill fill, |
| const GrPoint* translate = NULL); |
| |
| /** |
| * Draws vertices with a paint. |
| * |
| * @param paint describes how to color pixels. |
| * @param primitiveType primitives type to draw. |
| * @param vertexCount number of vertices. |
| * @param positions array of vertex positions, required. |
| * @param texCoords optional array of texture coordinates used |
| * to access the paint. |
| * @param colors optional array of per-vertex colors, supercedes |
| * the paint's color field. |
| * @param indices optional array of indices. If NULL vertices |
| * are drawn non-indexed. |
| * @param indexCount if indices is non-null then this is the |
| * number of indices. |
| */ |
| void drawVertices(const GrPaint& paint, |
| GrPrimitiveType primitiveType, |
| int vertexCount, |
| const GrPoint positions[], |
| const GrPoint texs[], |
| const GrColor colors[], |
| const uint16_t indices[], |
| int indexCount); |
| |
| /** |
| * Draws an oval. |
| * |
| * @param paint describes how to color pixels. |
| * @param rect the bounding rect of the oval. |
| * @param strokeWidth if strokeWidth < 0, then the oval is filled, else |
| * the rect is stroked based on strokeWidth. If |
| * strokeWidth == 0, then the stroke is always a single |
| * pixel thick. |
| */ |
| void drawOval(const GrPaint& paint, |
| const GrRect& rect, |
| SkScalar strokeWidth); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Misc. |
| |
| /** |
| * Flags that affect flush() behavior. |
| */ |
| enum FlushBits { |
| /** |
| * A client may want Gr to bind a GrRenderTarget in the 3D API so that |
| * it can be rendered to directly. However, Gr lazily sets state. Simply |
| * calling setRenderTarget() followed by flush() without flags may not |
| * bind the render target. This flag forces the context to bind the last |
| * set render target in the 3D API. |
| */ |
| kForceCurrentRenderTarget_FlushBit = 0x1, |
| /** |
| * A client may reach a point where it has partially rendered a frame |
| * through a GrContext that it knows the user will never see. This flag |
| * causes the flush to skip submission of deferred content to the 3D API |
| * during the flush. |
| */ |
| kDiscard_FlushBit = 0x2, |
| }; |
| |
| /** |
| * Call to ensure all drawing to the context has been issued to the |
| * underlying 3D API. |
| * @param flagsBitfield flags that control the flushing behavior. See |
| * FlushBits. |
| */ |
| void flush(int flagsBitfield = 0); |
| |
| /** |
| * Reads a rectangle of pixels from a render target. |
| * @param target 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 number of bytes bewtween consecutive rows. Zero |
| * means rows are tightly packed. |
| * |
| * @return true if the read succeeded, false if not. The read can fail |
| * because of an unsupported pixel config or because no render |
| * target is currently set. |
| */ |
| bool readRenderTargetPixels(GrRenderTarget* target, |
| int left, int top, int width, int height, |
| GrPixelConfig config, void* buffer, |
| size_t rowBytes) { |
| return this->internalReadRenderTargetPixels(target, left, top, |
| width, height, |
| config, buffer, |
| rowBytes, 0); |
| } |
| |
| /** |
| * Copy the src pixels [buffer, rowbytes, pixelconfig] into a render target |
| * at the specified rectangle. |
| * @param target the render target to write into. NULL means the |
| * current render target. |
| * @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 the rectangle from. |
| * @param rowBytes number of bytes bewtween consecutive rows. Zero |
| * means rows are tightly packed. |
| */ |
| void writeRenderTargetPixels(GrRenderTarget* target, |
| int left, int top, int width, int height, |
| GrPixelConfig config, const void* buffer, |
| size_t rowBytes) { |
| this->internalWriteRenderTargetPixels(target, left, top, width, height, |
| config, buffer, rowBytes, 0); |
| } |
| |
| /** |
| * Reads a rectangle of pixels from a texture. |
| * @param texture the texture to read from. |
| * @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 number of bytes bewtween consecutive rows. Zero |
| * means rows are tightly packed. |
| * |
| * @return true if the read succeeded, false if not. The read can fail |
| * because of an unsupported pixel config. |
| */ |
| bool readTexturePixels(GrTexture* texture, |
| int left, int top, int width, int height, |
| GrPixelConfig config, void* buffer, |
| size_t rowBytes) { |
| return this->internalReadTexturePixels(texture, left, top, |
| width, height, |
| config, buffer, rowBytes, 0); |
| } |
| |
| /** |
| * Writes a rectangle of pixels to a texture. |
| * @param texture the render target to read from. |
| * @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 bewtween consecutive rows. Zero |
| * means rows are tightly packed. |
| */ |
| void writeTexturePixels(GrTexture* texture, |
| int left, int top, int width, int height, |
| GrPixelConfig config, const void* buffer, |
| size_t rowBytes) { |
| this->internalWriteTexturePixels(texture, left, top, width, height, |
| config, buffer, rowBytes, 0); |
| } |
| /** |
| * Copies all texels from one texture to another. |
| * @param src the texture to copy from. |
| * @param dst the render target to copy to. |
| */ |
| void copyTexture(GrTexture* src, GrRenderTarget* dst); |
| |
| /** |
| * Resolves a render target that has MSAA. The intermediate MSAA buffer is |
| * downsampled to the associated GrTexture (accessible via |
| * GrRenderTarget::asTexture()). Any pending draws to the render target will |
| * be executed before the resolve. |
| * |
| * This is only necessary when a client wants to access the object directly |
| * using the underlying graphics API. GrContext will detect when it must |
| * perform a resolve to a GrTexture used as the source of a draw or before |
| * reading pixels back from a GrTexture or GrRenderTarget. |
| */ |
| void resolveRenderTarget(GrRenderTarget* target); |
| |
| /** |
| * Applies a 2D Gaussian blur to a given texture. |
| * @param srcTexture The source texture to be blurred. |
| * @param temp1 A scratch texture. Must not be NULL. |
| * @param temp2 A scratch texture. May be NULL, in which case |
| * srcTexture is overwritten with intermediate |
| * results. |
| * @param rect The destination rectangle. |
| * @param sigmaX The blur's standard deviation in X. |
| * @param sigmaY The blur's standard deviation in Y. |
| * @return the blurred texture, which may be temp1, temp2 or srcTexture. |
| */ |
| GrTexture* gaussianBlur(GrTexture* srcTexture, |
| GrAutoScratchTexture* temp1, |
| GrAutoScratchTexture* temp2, |
| const SkRect& rect, |
| float sigmaX, float sigmaY); |
| |
| /** |
| * This enum is used with the function below, applyMorphology. |
| */ |
| enum MorphologyType { |
| kErode_MorphologyType, |
| kDilate_MorphologyType, |
| }; |
| |
| /** |
| * Applies a 2D morphology to a given texture. |
| * @param srcTexture The source texture to be blurred. |
| * @param rect The destination rectangle. |
| * @param temp1 A scratch texture. Must not be NULL. |
| * @param temp2 A scratch texture. Must not be NULL. |
| * @param filter The morphology filter. Must be kDilate_Filter or |
| * kErode_Filter. |
| * @param radius The morphology radius in X and Y. The filter is |
| * applied to a fWidth by fHeight rectangle of |
| * pixels. |
| * @return the morphed texture, which may be temp1, temp2 or srcTexture. |
| */ |
| GrTexture* applyMorphology(GrTexture* srcTexture, |
| const GrRect& rect, |
| GrTexture* temp1, GrTexture* temp2, |
| MorphologyType type, |
| SkISize radius); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Helpers |
| |
| class AutoRenderTarget : ::GrNoncopyable { |
| public: |
| AutoRenderTarget(GrContext* context, GrRenderTarget* target) { |
| fContext = NULL; |
| fPrevTarget = context->getRenderTarget(); |
| if (fPrevTarget != target) { |
| context->setRenderTarget(target); |
| fContext = context; |
| } |
| } |
| ~AutoRenderTarget() { |
| if (fContext) { |
| fContext->setRenderTarget(fPrevTarget); |
| } |
| } |
| private: |
| GrContext* fContext; |
| GrRenderTarget* fPrevTarget; |
| }; |
| |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Functions intended for internal use only. |
| GrGpu* getGpu() { return fGpu; } |
| const GrGpu* getGpu() const { return fGpu; } |
| GrFontCache* getFontCache() { return fFontCache; } |
| GrDrawTarget* getTextTarget(const GrPaint& paint); |
| const GrIndexBuffer* getQuadIndexBuffer() const; |
| |
| /** |
| * Stencil buffers add themselves to the cache using |
| * addAndLockStencilBuffer. When a SB's RT-attachment count |
| * reaches zero the SB unlocks itself using unlockStencilBuffer and is |
| * eligible for purging. findStencilBuffer is called to check the cache for |
| * a SB that matching an RT's criteria. If a match is found that has been |
| * unlocked (its attachment count has reached 0) then it will be relocked. |
| */ |
| GrResourceEntry* addAndLockStencilBuffer(GrStencilBuffer* sb); |
| void unlockStencilBuffer(GrResourceEntry* sbEntry); |
| GrStencilBuffer* findStencilBuffer(int width, int height, int sampleCnt); |
| |
| /* |
| * postClipPush acts as a hint to this and lower-level classes (e.g., |
| * GrGpu) that the clip stack has changed. |
| */ |
| virtual void postClipPush(); |
| |
| /* |
| * preClipPop acts as a hint that the clip stack has been restored to an |
| * earlier state. |
| */ |
| virtual void preClipPop(); |
| |
| GrPathRenderer* getPathRenderer(const SkPath& path, |
| GrPathFill fill, |
| const GrDrawTarget* target, |
| bool antiAlias, |
| bool allowSW); |
| |
| private: |
| // used to keep track of when we need to flush the draw buffer |
| enum DrawCategory { |
| kBuffered_DrawCategory, // last draw was inserted in draw buffer |
| kUnbuffered_DrawCategory, // last draw was not inserted in the draw buffer |
| }; |
| DrawCategory fLastDrawCategory; |
| |
| GrGpu* fGpu; |
| GrDrawState* fDrawState; |
| |
| GrResourceCache* fTextureCache; |
| GrFontCache* fFontCache; |
| |
| GrPathRendererChain* fPathRendererChain; |
| GrSoftwarePathRenderer* fSoftwarePathRenderer; |
| |
| GrVertexBufferAllocPool* fDrawBufferVBAllocPool; |
| GrIndexBufferAllocPool* fDrawBufferIBAllocPool; |
| GrInOrderDrawBuffer* fDrawBuffer; |
| |
| GrAARectRenderer* fAARectRenderer; |
| |
| GrContext(GrGpu* gpu); |
| |
| void setupDrawBuffer(); |
| |
| void flushDrawBuffer(); |
| |
| void setPaint(const GrPaint& paint); |
| |
| GrDrawTarget* prepareToDraw(const GrPaint& paint, DrawCategory drawType); |
| |
| void internalDrawPath(const GrPaint& paint, const SkPath& path, |
| GrPathFill fill, const GrPoint* translate); |
| |
| /** |
| * Flags to the internal read/write pixels funcs |
| */ |
| enum PixelOpsFlags { |
| kDontFlush_PixelOpsFlag = 0x1, |
| }; |
| |
| bool internalReadRenderTargetPixels(GrRenderTarget* target, |
| int left, int top, |
| int width, int height, |
| GrPixelConfig config, void* buffer, |
| size_t rowBytes, uint32_t flags); |
| |
| void internalWriteRenderTargetPixels(GrRenderTarget* target, |
| int left, int top, |
| int width, int height, |
| GrPixelConfig, const void* buffer, |
| size_t rowBytes, uint32_t flags); |
| |
| bool internalReadTexturePixels(GrTexture* texture, |
| int left, int top, |
| int width, int height, |
| GrPixelConfig config, void* buffer, |
| size_t rowBytes, uint32_t flags); |
| |
| void internalWriteTexturePixels(GrTexture* texture, |
| int left, int top, |
| int width, int height, |
| GrPixelConfig config, const void* buffer, |
| size_t rowBytes, uint32_t flags); |
| // needed for access to internalWriteTexturePixels. TODO: make GrContext |
| // be a facade for an internal class. Then functions that are public on the |
| // internal class would have only be callable in src/gpu. The facade would |
| // only have to functions necessary for clients. |
| friend class GrAtlas; |
| |
| // computes vertex layout bits based on the paint. If paint expresses |
| // a texture for a stage, the stage coords will be bound to postitions |
| // unless hasTexCoords[s]==true in which case stage s's input coords |
| // are bound to tex coord index s. hasTexCoords == NULL is a shortcut |
| // for an array where all the values are false. |
| static int PaintStageVertexLayoutBits( |
| const GrPaint& paint, |
| const bool hasTexCoords[GrPaint::kTotalStages]); |
| }; |
| |
| /** |
| * Save/restore the view-matrix in the context. |
| */ |
| class GrAutoMatrix : GrNoncopyable { |
| public: |
| GrAutoMatrix() : fContext(NULL) {} |
| GrAutoMatrix(GrContext* ctx) : fContext(ctx) { |
| fMatrix = ctx->getMatrix(); |
| } |
| GrAutoMatrix(GrContext* ctx, const GrMatrix& matrix) : fContext(ctx) { |
| fMatrix = ctx->getMatrix(); |
| ctx->setMatrix(matrix); |
| } |
| void set(GrContext* ctx) { |
| if (NULL != fContext) { |
| fContext->setMatrix(fMatrix); |
| } |
| fMatrix = ctx->getMatrix(); |
| fContext = ctx; |
| } |
| void set(GrContext* ctx, const GrMatrix& matrix) { |
| if (NULL != fContext) { |
| fContext->setMatrix(fMatrix); |
| } |
| fMatrix = ctx->getMatrix(); |
| ctx->setMatrix(matrix); |
| fContext = ctx; |
| } |
| ~GrAutoMatrix() { |
| if (NULL != fContext) { |
| fContext->setMatrix(fMatrix); |
| } |
| } |
| |
| private: |
| GrContext* fContext; |
| GrMatrix fMatrix; |
| }; |
| |
| /** |
| * Gets and locks a scratch texture from a descriptor using |
| * either exact or approximate criteria. Unlocks texture in |
| * the destructor. |
| */ |
| class GrAutoScratchTexture : ::GrNoncopyable { |
| public: |
| GrAutoScratchTexture() |
| : fContext(NULL) { |
| } |
| |
| GrAutoScratchTexture(GrContext* context, |
| const GrTextureDesc& desc, |
| GrContext::ScratchTexMatch match = |
| GrContext::kApprox_ScratchTexMatch) |
| : fContext(NULL) { |
| this->set(context, desc, match); |
| } |
| |
| ~GrAutoScratchTexture() { |
| this->reset(); |
| } |
| |
| void reset() { |
| if (NULL != fContext) { |
| fContext->unlockTexture(fEntry); |
| fEntry.reset(); |
| } |
| } |
| |
| GrTexture* set(GrContext* context, |
| const GrTextureDesc& desc, |
| GrContext::ScratchTexMatch match = |
| GrContext::kApprox_ScratchTexMatch) { |
| this->reset(); |
| |
| fContext = context; |
| if (NULL != fContext) { |
| fEntry = fContext->lockScratchTexture(desc, match); |
| GrTexture* ret = fEntry.texture(); |
| if (NULL == ret) { |
| fContext = NULL; |
| } |
| return ret; |
| } else { |
| return NULL; |
| } |
| } |
| |
| GrTexture* texture() { return fEntry.texture(); } |
| private: |
| GrContext* fContext; |
| GrContext::TextureCacheEntry fEntry; |
| }; |
| |
| #endif |