#include "GrClip.h"
#include "GrPaint.h"
+#include "GrPathRenderer.h"
-class GrDefaultPathRenderer;
-class GrDrawTarget;
class GrFontCache;
class GrGpu;
struct GrGpuStats;
-class GrIndexBuffer;
class GrIndexBufferAllocPool;
class GrInOrderDrawBuffer;
-class GrPathRenderer;
class GrResourceEntry;
class GrResourceCache;
class GrStencilBuffer;
-class GrVertexBuffer;
class GrVertexBufferAllocPool;
GrFontCache* fFontCache;
GrPathRenderer* fCustomPathRenderer;
- GrDefaultPathRenderer* fDefaultPathRenderer;
+ GrDefaultPathRenderer fDefaultPathRenderer;
GrVertexBufferAllocPool* fDrawBufferVBAllocPool;
GrIndexBufferAllocPool* fDrawBufferIBAllocPool;
--- /dev/null
+
+/*
+ * 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 GrDrawTarget_DEFINED
+#define GrDrawTarget_DEFINED
+
+#include "GrClip.h"
+#include "GrColor.h"
+#include "GrMatrix.h"
+#include "GrRefCnt.h"
+#include "GrRenderTarget.h"
+#include "GrSamplerState.h"
+#include "GrStencil.h"
+#include "GrTexture.h"
+
+#include "SkXfermode.h"
+
+class GrTexture;
+class GrClipIterator;
+class GrVertexBuffer;
+class GrIndexBuffer;
+
+class GrDrawTarget : public GrRefCnt {
+public:
+ /**
+ * Number of texture stages. Each stage takes as input a color and
+ * 2D texture coordinates. The color input to the first enabled stage is the
+ * per-vertex color or the constant color (setColor/setAlpha) if there are
+ * no per-vertex colors. For subsequent stages the input color is the output
+ * color from the previous enabled stage. The output color of each stage is
+ * the input color modulated with the result of a texture lookup. Texture
+ * lookups are specified by a texture a sampler (setSamplerState). Texture
+ * coordinates for each stage come from the vertices based on a
+ * GrVertexLayout bitfield. The output fragment color is the output color of
+ * the last enabled stage. The presence or absence of texture coordinates
+ * for each stage in the vertex layout indicates whether a stage is enabled
+ * or not.
+ */
+ enum {
+ kNumStages = 3,
+ kMaxTexCoords = kNumStages
+ };
+
+
+ /**
+ * The absolute maximum number of edges that may be specified for
+ * a single draw call when performing edge antialiasing. This is used for
+ * the size of several static buffers, so implementations of getMaxEdges()
+ * (below) should clamp to this value.
+ */
+ enum {
+ kMaxEdges = 32
+ };
+
+ /**
+ * Bitfield used to indicate which stages are in use.
+ */
+ typedef int StageBitfield;
+ GR_STATIC_ASSERT(sizeof(StageBitfield)*8 >= kNumStages);
+
+ /**
+ * Flags that affect rendering. Controlled using enable/disableState(). All
+ * default to disabled.
+ */
+ enum StateBits {
+ kDither_StateBit = 0x01, //<! Perform color dithering
+ kAntialias_StateBit = 0x02, //<! Perform anti-aliasing. The render-
+ // target must support some form of AA
+ // (msaa, coverage sampling, etc). For
+ // GrGpu-created rendertarget/textures
+ // this is controlled by parameters
+ // passed to createTexture.
+ kClip_StateBit = 0x04, //<! Controls whether drawing is clipped
+ // against the region specified by
+ // setClip.
+ kNoColorWrites_StateBit = 0x08, //<! If set it disables writing colors.
+ // Useful while performing stencil
+ // ops.
+ kEdgeAAConcave_StateBit = 0x10,//<! If set, edge AA will test edge
+ // pairs for convexity while
+ // rasterizing. Set this if the
+ // source polygon is non-convex.
+
+ // subclass may use additional bits internally
+ kDummyStateBit,
+ kLastPublicStateBit = kDummyStateBit-1
+ };
+
+ enum DrawFace {
+ kBoth_DrawFace,
+ kCCW_DrawFace,
+ kCW_DrawFace,
+ };
+
+ /**
+ * Sets the stencil settings to use for the next draw.
+ * Changing the clip has the side-effect of possibly zeroing
+ * out the client settable stencil bits. So multipass algorithms
+ * using stencil should not change the clip between passes.
+ * @param settings the stencil settings to use.
+ */
+ void setStencil(const GrStencilSettings& settings) {
+ fCurrDrawState.fStencilSettings = settings;
+ }
+
+ /**
+ * Shortcut to disable stencil testing and ops.
+ */
+ void disableStencil() {
+ fCurrDrawState.fStencilSettings.setDisabled();
+ }
+
+ class Edge {
+ public:
+ Edge() {}
+ Edge(float x, float y, float z) : fX(x), fY(y), fZ(z) {}
+ GrPoint intersect(const Edge& other) {
+ return GrPoint::Make(
+ (fY * other.fZ - other.fY * fZ) /
+ (fX * other.fY - other.fX * fY),
+ (fX * other.fZ - other.fX * fZ) /
+ (other.fX * fY - fX * other.fY));
+ }
+ float fX, fY, fZ;
+ };
+
+protected:
+
+ struct DrState {
+ DrState() {
+ // make sure any pad is zero for memcmp
+ // all DrState members should default to something
+ // valid by the memset
+ memset(this, 0, sizeof(DrState));
+
+ // memset exceptions
+ fColorFilterXfermode = SkXfermode::kDstIn_Mode;
+ fFirstCoverageStage = kNumStages;
+
+ // pedantic assertion that our ptrs will
+ // be NULL (0 ptr is mem addr 0)
+ GrAssert((intptr_t)(void*)NULL == 0LL);
+
+ // default stencil setting should be disabled
+ GrAssert(fStencilSettings.isDisabled());
+ fFirstCoverageStage = kNumStages;
+ }
+ uint32_t fFlagBits;
+ GrBlendCoeff fSrcBlend;
+ GrBlendCoeff fDstBlend;
+ GrColor fBlendConstant;
+ GrTexture* fTextures[kNumStages];
+ GrSamplerState fSamplerStates[kNumStages];
+ int fFirstCoverageStage;
+ GrRenderTarget* fRenderTarget;
+ GrColor fColor;
+ DrawFace fDrawFace;
+ GrColor fColorFilterColor;
+ SkXfermode::Mode fColorFilterXfermode;
+
+ GrStencilSettings fStencilSettings;
+ GrMatrix fViewMatrix;
+ Edge fEdgeAAEdges[kMaxEdges];
+ int fEdgeAANumEdges;
+ bool operator ==(const DrState& s) const {
+ return 0 == memcmp(this, &s, sizeof(DrState));
+ }
+ bool operator !=(const DrState& s) const { return !(*this == s); }
+ };
+
+public:
+ ///////////////////////////////////////////////////////////////////////////
+
+ GrDrawTarget();
+ virtual ~GrDrawTarget();
+
+ /**
+ * Sets the current clip to the region specified by clip. All draws will be
+ * clipped against this clip if kClip_StateBit is enabled.
+ *
+ * Setting the clip may (or may not) zero out the client's stencil bits.
+ *
+ * @param description of the clipping region
+ */
+ void setClip(const GrClip& clip);
+
+ /**
+ * Gets the current clip.
+ *
+ * @return the clip.
+ */
+ const GrClip& getClip() const;
+
+ /**
+ * Sets the texture used at the next drawing call
+ *
+ * @param stage The texture stage for which the texture will be set
+ *
+ * @param texture The texture to set. Can be NULL though there is no advantage
+ * to settings a NULL texture if doing non-textured drawing
+ */
+ void setTexture(int stage, GrTexture* texture);
+
+ /**
+ * Retrieves the currently set texture.
+ *
+ * @return The currently set texture. The return value will be NULL if no
+ * texture has been set, NULL was most recently passed to
+ * setTexture, or the last setTexture was destroyed.
+ */
+ const GrTexture* getTexture(int stage) const;
+ GrTexture* getTexture(int stage);
+
+ /**
+ * Sets the rendertarget used at the next drawing call
+ *
+ * @param target The render target to set.
+ */
+ void setRenderTarget(GrRenderTarget* target);
+
+ /**
+ * Retrieves the currently set rendertarget.
+ *
+ * @return The currently set render target.
+ */
+ const GrRenderTarget* getRenderTarget() const;
+ GrRenderTarget* getRenderTarget();
+
+ /**
+ * Sets the sampler state for a stage used in subsequent draws.
+ *
+ * The sampler state determines how texture coordinates are
+ * intepretted and used to sample the texture.
+ *
+ * @param stage the stage of the sampler to set
+ * @param samplerState Specifies the sampler state.
+ */
+ void setSamplerState(int stage, const GrSamplerState& samplerState);
+
+ /**
+ * Concats the matrix of a stage's sampler.
+ *
+ * @param stage the stage of the sampler to set
+ * @param matrix the matrix to concat
+ */
+ void preConcatSamplerMatrix(int stage, const GrMatrix& matrix) {
+ GrAssert(stage >= 0 && stage < kNumStages);
+ fCurrDrawState.fSamplerStates[stage].preConcatMatrix(matrix);
+ }
+
+ /**
+ * Shortcut for preConcatSamplerMatrix on all stages in mask with same
+ * matrix
+ */
+ void preConcatSamplerMatrices(int stageMask, const GrMatrix& matrix) {
+ for (int i = 0; i < kNumStages; ++i) {
+ if ((1 << i) & stageMask) {
+ this->preConcatSamplerMatrix(i, matrix);
+ }
+ }
+ }
+
+ /**
+ * Gets the matrix of a stage's sampler
+ *
+ * @param stage the stage to of sampler to get
+ * @return the sampler state's matrix
+ */
+ const GrMatrix& getSamplerMatrix(int stage) const {
+ return fCurrDrawState.fSamplerStates[stage].getMatrix();
+ }
+
+ /**
+ * Sets the matrix of a stage's sampler
+ *
+ * @param stage the stage of sampler set
+ * @param matrix the matrix to set
+ */
+ void setSamplerMatrix(int stage, const GrMatrix& matrix) {
+ fCurrDrawState.fSamplerStates[stage].setMatrix(matrix);
+ }
+
+ /**
+ * Sets the matrix applied to veretx positions.
+ *
+ * In the post-view-matrix space the rectangle [0,w]x[0,h]
+ * fully covers the render target. (w and h are the width and height of the
+ * the rendertarget.)
+ *
+ * @param m the matrix used to transform the vertex positions.
+ */
+ void setViewMatrix(const GrMatrix& m);
+
+ /**
+ * Multiplies the current view matrix by a matrix
+ *
+ * After this call V' = V*m where V is the old view matrix,
+ * m is the parameter to this function, and V' is the new view matrix.
+ * (We consider positions to be column vectors so position vector p is
+ * transformed by matrix X as p' = X*p.)
+ *
+ * @param m the matrix used to modify the view matrix.
+ */
+ void preConcatViewMatrix(const GrMatrix& m);
+
+ /**
+ * Multiplies the current view matrix by a matrix
+ *
+ * After this call V' = m*V where V is the old view matrix,
+ * m is the parameter to this function, and V' is the new view matrix.
+ * (We consider positions to be column vectors so position vector p is
+ * transformed by matrix X as p' = X*p.)
+ *
+ * @param m the matrix used to modify the view matrix.
+ */
+ void postConcatViewMatrix(const GrMatrix& m);
+
+ /**
+ * Retrieves the current view matrix
+ * @return the current view matrix.
+ */
+ const GrMatrix& getViewMatrix() const;
+
+ /**
+ * Retrieves the inverse of the current view matrix.
+ *
+ * If the current view matrix is invertible, return true, and if matrix
+ * is non-null, copy the inverse into it. If the current view matrix is
+ * non-invertible, return false and ignore the matrix parameter.
+ *
+ * @param matrix if not null, will receive a copy of the current inverse.
+ */
+ bool getViewInverse(GrMatrix* matrix) const;
+
+ /**
+ * Sets color for next draw to a premultiplied-alpha color.
+ *
+ * @param the color to set.
+ */
+ void setColor(GrColor);
+
+ /**
+ * Add a color filter that can be represented by a color and a mode.
+ */
+ void setColorFilter(GrColor, SkXfermode::Mode);
+
+ /**
+ * Sets the color to be used for the next draw to be
+ * (r,g,b,a) = (alpha, alpha, alpha, alpha).
+ *
+ * @param alpha The alpha value to set as the color.
+ */
+ void setAlpha(uint8_t alpha);
+
+ /**
+ * Controls whether clockwise, counterclockwise, or both faces are drawn.
+ * @param face the face(s) to draw.
+ */
+ void setDrawFace(DrawFace face) { fCurrDrawState.fDrawFace = face; }
+
+ /**
+ * A common pattern is to compute a color with the initial stages and then
+ * modulate that color by a coverage value in later stage(s) (AA, mask-
+ * filters, glyph mask, etc). Color-filters, xfermodes, etc should be
+ * computed based on the pre-coverage-modulated color. The division of
+ * stages between color-computing and coverage-computing is specified by
+ * this method. Initially this is kNumStages (all stages are color-
+ * computing).
+ */
+ void setFirstCoverageStage(int firstCoverageStage) {
+ fCurrDrawState.fFirstCoverageStage = firstCoverageStage;
+ }
+
+ /**
+ * Gets the index of the first coverage-computing stage.
+ */
+ int getFirstCoverageStage() const {
+ return fCurrDrawState.fFirstCoverageStage;
+ }
+
+ /**
+ * Gets whether the target is drawing clockwise, counterclockwise,
+ * or both faces.
+ * @return the current draw face(s).
+ */
+ DrawFace getDrawFace() const { return fCurrDrawState.fDrawFace; }
+
+ /**
+ * Enable render state settings.
+ *
+ * @param flags bitfield of StateBits specifing the states to enable
+ */
+ void enableState(uint32_t stateBits);
+
+ /**
+ * Disable render state settings.
+ *
+ * @param flags bitfield of StateBits specifing the states to disable
+ */
+ void disableState(uint32_t stateBits);
+
+ bool isDitherState() const {
+ return 0 != (fCurrDrawState.fFlagBits & kDither_StateBit);
+ }
+
+ bool isAntialiasState() const {
+ return 0 != (fCurrDrawState.fFlagBits & kAntialias_StateBit);
+ }
+
+ bool isClipState() const {
+ return 0 != (fCurrDrawState.fFlagBits & kClip_StateBit);
+ }
+
+ bool isColorWriteDisabled() const {
+ return 0 != (fCurrDrawState.fFlagBits & kNoColorWrites_StateBit);
+ }
+
+ /**
+ * Sets the blending function coeffecients.
+ *
+ * The blend function will be:
+ * D' = sat(S*srcCoef + D*dstCoef)
+ *
+ * where D is the existing destination color, S is the incoming source
+ * color, and D' is the new destination color that will be written. sat()
+ * is the saturation function.
+ *
+ * @param srcCoef coeffecient applied to the src color.
+ * @param dstCoef coeffecient applied to the dst color.
+ */
+ void setBlendFunc(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff);
+
+ /**
+ * Sets the blending function constant referenced by the following blending
+ * coeffecients:
+ * kConstC_BlendCoeff
+ * kIConstC_BlendCoeff
+ * kConstA_BlendCoeff
+ * kIConstA_BlendCoeff
+ *
+ * @param constant the constant to set
+ */
+ void setBlendConstant(GrColor constant) { fCurrDrawState.fBlendConstant = constant; }
+
+ /**
+ * Retrieves the last value set by setBlendConstant()
+ * @return the blending constant value
+ */
+ GrColor getBlendConstant() const { return fCurrDrawState.fBlendConstant; }
+
+ /**
+ * Used to save and restore the GrGpu's drawing state
+ */
+ struct SavedDrawState {
+ private:
+ DrState fState;
+ friend class GrDrawTarget;
+ };
+
+ /**
+ * Saves the current draw state. The state can be restored at a later time
+ * with restoreDrawState.
+ *
+ * See also AutoStateRestore class.
+ *
+ * @param state will hold the state after the function returns.
+ */
+ void saveCurrentDrawState(SavedDrawState* state) const;
+
+ /**
+ * Restores previously saved draw state. The client guarantees that state
+ * was previously passed to saveCurrentDrawState and that the rendertarget
+ * and texture set at save are still valid.
+ *
+ * See also AutoStateRestore class.
+ *
+ * @param state the previously saved state to restore.
+ */
+ void restoreDrawState(const SavedDrawState& state);
+
+ /**
+ * Copies the draw state from another target to this target.
+ *
+ * @param srcTarget draw target used as src of the draw state.
+ */
+ void copyDrawState(const GrDrawTarget& srcTarget);
+
+ /**
+ * The format of vertices is represented as a bitfield of flags.
+ * Flags that indicate the layout of vertex data. Vertices always contain
+ * positions and may also contain up to kMaxTexCoords sets of 2D texture
+ * coordinates and per-vertex colors. Each stage can use any of the texture
+ * coordinates as its input texture coordinates or it may use the positions.
+ *
+ * If no texture coordinates are specified for a stage then the stage is
+ * disabled.
+ *
+ * Only one type of texture coord can be specified per stage. For
+ * example StageTexCoordVertexLayoutBit(0, 2) and
+ * StagePosAsTexCoordVertexLayoutBit(0) cannot both be specified.
+ *
+ * The order in memory is always (position, texture coord 0, ..., color)
+ * with any unused fields omitted. Note that this means that if only texture
+ * coordinates 1 is referenced then there is no texture coordinates 0 and
+ * the order would be (position, texture coordinate 1[, color]).
+ */
+
+ /**
+ * Generates a bit indicating that a texture stage uses texture coordinates
+ *
+ * @param stage the stage that will use texture coordinates.
+ * @param texCoordIdx the index of the texture coordinates to use
+ *
+ * @return the bit to add to a GrVertexLayout bitfield.
+ */
+ static int StageTexCoordVertexLayoutBit(int stage, int texCoordIdx) {
+ GrAssert(stage < kNumStages);
+ GrAssert(texCoordIdx < kMaxTexCoords);
+ return 1 << (stage + (texCoordIdx * kNumStages));
+ }
+
+ /**
+ * Determines if blend is effectively disabled.
+ *
+ * @return true if blend can be disabled without changing the rendering
+ * result given the current state including the vertex layout specified
+ * with the vertex source.
+ */
+ bool canDisableBlend() const;
+
+ /**
+ * Sets the edge data required for edge antialiasing.
+ *
+ * @param edges 3 * 6 float values, representing the edge
+ * equations in Ax + By + C form
+ */
+ void setEdgeAAData(const Edge* edges, int numEdges);
+
+private:
+ static const int TEX_COORD_BIT_CNT = kNumStages*kMaxTexCoords;
+public:
+ /**
+ * Generates a bit indicating that a texture stage uses the position
+ * as its texture coordinate.
+ *
+ * @param stage the stage that will use position as texture
+ * coordinates.
+ *
+ * @return the bit to add to a GrVertexLayout bitfield.
+ */
+ static int StagePosAsTexCoordVertexLayoutBit(int stage) {
+ GrAssert(stage < kNumStages);
+ return (1 << (TEX_COORD_BIT_CNT + stage));
+ }
+private:
+ static const int STAGE_BIT_CNT = TEX_COORD_BIT_CNT + kNumStages;
+
+public:
+
+ /**
+ * Additional Bits that can be specified in GrVertexLayout.
+ */
+ enum VertexLayoutBits {
+
+ kColor_VertexLayoutBit = 1 << (STAGE_BIT_CNT + 0),
+ //<! vertices have colors
+ kTextFormat_VertexLayoutBit = 1 << (STAGE_BIT_CNT + 1),
+ //<! use text vertices. (Pos
+ // and tex coords may be
+ // a different type for
+ // text [GrGpuTextVertex vs
+ // GrPoint].)
+ // for below assert
+ kDummyVertexLayoutBit,
+ kHighVertexLayoutBit = kDummyVertexLayoutBit - 1
+ };
+ // make sure we haven't exceeded the number of bits in GrVertexLayout.
+ GR_STATIC_ASSERT(kHighVertexLayoutBit < ((uint64_t)1 << 8*sizeof(GrVertexLayout)));
+
+ /**
+ * There are three methods for specifying geometry (vertices and optionally
+ * indices) to the draw target. When indexed drawing the indices and vertices
+ * can use a different method. Once geometry is specified it can be used for
+ * multiple drawIndexed and drawNonIndexed calls.
+ *
+ * Sometimes it is necessary to perform a draw while upstack code has
+ * already specified geometry that it isn't finished with. There are push
+ * pop methods
+ *
+ * 1. Provide a cpu array (set*SourceToArray). This is useful when the
+ * caller's client has already provided vertex data in a format
+ * the time compatible with a GrVertexLayout. The array must contain the
+ * data at set*SourceToArray is called. The source stays in effect for
+ * drawIndexed & drawNonIndexed calls until set*SourceToArray is called
+ * again or one of the other two paths is chosen.
+ *
+ * 2. Reserve. This is most useful when the caller has data it must
+ * transform before drawing and is not long-lived. The caller requests
+ * that the draw target make room for some amount of vertex and/or index
+ * data. The target provides ptrs to hold the vertex and/or index data.
+ *
+ * The data is writable up until the next drawIndexed, drawNonIndexed,
+ * or pushGeometrySource At this point the data is frozen and the ptrs
+ * are no longer valid.
+ *
+ * 3. Vertex and Index Buffers. This is most useful for geometry that will
+ * is long-lived. SetVertexSourceToBuffer and SetIndexSourceToBuffer are
+ * used to set the buffer and subsequent drawIndexed and drawNonIndexed
+ * calls use this source until another source is set.
+ */
+
+ /**
+ * Reserves space for vertices. Draw target will use reserved vertices at
+ * at the next draw.
+ *
+ * If succeeds:
+ * if vertexCount > 0, *vertices will be the array
+ * of vertices to be filled by caller. The next draw will read
+ * these vertices.
+ *
+ * If a client does not already have a vertex buffer then this is the
+ * preferred way to allocate vertex data. It allows the subclass of
+ * GrDrawTarget to decide whether to put data in buffers, to group vertex
+ * data that uses the same state (e.g. for deferred rendering), etc.
+ *
+ * After the next draw or pushGeometrySource the vertices ptr is no longer
+ * valid and the geometry data cannot be further modified. The contents
+ * that were put in the reserved space can be drawn by multiple draws,
+ * however.
+ *
+ * @param vertexLayout the format of vertices (ignored if vertexCount == 0).
+ * @param vertexCount the number of vertices to reserve space for. Can be 0.
+ * @param vertices will point to reserved vertex space if vertexCount is
+ * non-zero. Illegal to pass NULL if vertexCount > 0.
+ *
+ * @return true if succeeded in allocating space for the vertices and false
+ * if not.
+ */
+ bool reserveVertexSpace(GrVertexLayout vertexLayout,
+ int vertexCount,
+ void** vertices);
+ /**
+ * Reserves space for indices. Draw target will use the reserved indices at
+ * the next indexed draw.
+ *
+ * If succeeds:
+ * if indexCount > 0, *indices will be the array
+ * of indices to be filled by caller. The next draw will read
+ * these indices.
+ *
+ * If a client does not already have a index buffer then this is the
+ * preferred way to allocate index data. It allows the subclass of
+ * GrDrawTarget to decide whether to put data in buffers, to group index
+ * data that uses the same state (e.g. for deferred rendering), etc.
+ *
+ * After the next indexed draw or pushGeometrySource the indices ptr is no
+ * longer valid and the geometry data cannot be further modified. The
+ * contents that were put in the reserved space can be drawn by multiple
+ * draws, however.
+ *
+ * @param indexCount the number of indices to reserve space for. Can be 0.
+ * @param indices will point to reserved index space if indexCount is
+ * non-zero. Illegal to pass NULL if indexCount > 0.
+ */
+
+ bool reserveIndexSpace(int indexCount, void** indices);
+ /**
+ * Provides hints to caller about the number of vertices and indices
+ * that can be allocated cheaply. This can be useful if caller is reserving
+ * space but doesn't know exactly how much geometry is needed.
+ *
+ * Also may hint whether the draw target should be flushed first. This is
+ * useful for deferred targets.
+ *
+ * @param vertexLayout layout of vertices caller would like to reserve
+ * @param vertexCount in: hint about how many vertices the caller would
+ * like to allocate.
+ * out: a hint about the number of vertices that can be
+ * allocated cheaply. Negative means no hint.
+ * Ignored if NULL.
+ * @param indexCount in: hint about how many indices the caller would
+ * like to allocate.
+ * out: a hint about the number of indices that can be
+ * allocated cheaply. Negative means no hint.
+ * Ignored if NULL.
+ *
+ * @return true if target should be flushed based on the input values.
+ */
+ virtual bool geometryHints(GrVertexLayout vertexLayout,
+ int* vertexCount,
+ int* indexCount) const;
+
+ /**
+ * Sets source of vertex data for the next draw. Array must contain
+ * the vertex data when this is called.
+ *
+ * @param array cpu array containing vertex data.
+ * @param size size of the vertex data.
+ * @param vertexCount the number of vertices in the array.
+ */
+ void setVertexSourceToArray(GrVertexLayout vertexLayout,
+ const void* vertexArray,
+ int vertexCount);
+
+ /**
+ * Sets source of index data for the next indexed draw. Array must contain
+ * the indices when this is called.
+ *
+ * @param array cpu array containing index data.
+ * @param indexCount the number of indices in the array.
+ */
+ void setIndexSourceToArray(const void* indexArray, int indexCount);
+
+ /**
+ * Sets source of vertex data for the next draw. Data does not have to be
+ * in the buffer until drawIndexed or drawNonIndexed.
+ *
+ * @param buffer vertex buffer containing vertex data. Must be
+ * unlocked before draw call.
+ * @param vertexLayout layout of the vertex data in the buffer.
+ */
+ void setVertexSourceToBuffer(GrVertexLayout vertexLayout,
+ const GrVertexBuffer* buffer);
+
+ /**
+ * Sets source of index data for the next indexed draw. Data does not have
+ * to be in the buffer until drawIndexed or drawNonIndexed.
+ *
+ * @param buffer index buffer containing indices. Must be unlocked
+ * before indexed draw call.
+ */
+ void setIndexSourceToBuffer(const GrIndexBuffer* buffer);
+
+ /**
+ * Resets vertex source. Drawing from reset vertices is illegal. Set vertex
+ * source to reserved, array, or buffer before next draw. May be able to free
+ * up temporary storage allocated by setVertexSourceToArray or
+ * reserveVertexSpace.
+ */
+ void resetVertexSource();
+
+ /**
+ * Resets index source. Indexed Drawing from reset indices is illegal. Set
+ * index source to reserved, array, or buffer before next indexed draw. May
+ * be able to free up temporary storage allocated by setIndexSourceToArray
+ * or reserveIndexSpace.
+ */
+ void resetIndexSource();
+
+ /**
+ * Pushes and resets the vertex/index sources. Any reserved vertex / index
+ * data is finalized (i.e. cannot be updated after the matching pop but can
+ * be drawn from). Must be balanced by a pop.
+ */
+ void pushGeometrySource();
+
+ /**
+ * Pops the vertex / index sources from the matching push.
+ */
+ void popGeometrySource();
+
+ /**
+ * Draws indexed geometry using the current state and current vertex / index
+ * sources.
+ *
+ * @param type The type of primitives to draw.
+ * @param startVertex the vertex in the vertex array/buffer corresponding
+ * to index 0
+ * @param startIndex first index to read from index src.
+ * @param vertexCount one greater than the max index.
+ * @param indexCount the number of index elements to read. The index count
+ * is effectively trimmed to the last completely
+ * specified primitive.
+ */
+ void drawIndexed(GrPrimitiveType type,
+ int startVertex,
+ int startIndex,
+ int vertexCount,
+ int indexCount);
+
+ /**
+ * Draws non-indexed geometry using the current state and current vertex
+ * sources.
+ *
+ * @param type The type of primitives to draw.
+ * @param startVertex the vertex in the vertex array/buffer corresponding
+ * to index 0
+ * @param vertexCount one greater than the max index.
+ */
+ void drawNonIndexed(GrPrimitiveType type,
+ int startVertex,
+ int vertexCount);
+
+ /**
+ * Helper function for drawing rects. This does not use the current index
+ * and vertex sources. After returning, the vertex and index sources may
+ * have changed. They should be reestablished before the next drawIndexed
+ * or drawNonIndexed. This cannot be called between reserving and releasing
+ * geometry. The GrDrawTarget subclass may be able to perform additional
+ * optimizations if drawRect is used rather than drawIndexed or
+ * drawNonIndexed.
+ * @param rect the rect to draw
+ * @param matrix optional matrix applied to rect (before viewMatrix)
+ * @param stageEnableBitfield bitmask indicating which stages are enabled.
+ * Bit i indicates whether stage i is enabled.
+ * @param srcRects specifies rects for stages enabled by stageEnableMask.
+ * if stageEnableMask bit i is 1, srcRects is not NULL,
+ * and srcRects[i] is not NULL, then srcRects[i] will be
+ * used as coordinates for stage i. Otherwise, if stage i
+ * is enabled then rect is used as the coordinates.
+ * @param srcMatrices optional matrices applied to srcRects. If
+ * srcRect[i] is non-NULL and srcMatrices[i] is
+ * non-NULL then srcRect[i] will be transformed by
+ * srcMatrix[i]. srcMatrices can be NULL when no
+ * srcMatrices are desired.
+ */
+ virtual void drawRect(const GrRect& rect,
+ const GrMatrix* matrix,
+ StageBitfield stageEnableBitfield,
+ const GrRect* srcRects[],
+ const GrMatrix* srcMatrices[]);
+
+ /**
+ * Helper for drawRect when the caller doesn't need separate src rects or
+ * matrices.
+ */
+ void drawSimpleRect(const GrRect& rect,
+ const GrMatrix* matrix,
+ StageBitfield stageEnableBitfield) {
+ drawRect(rect, matrix, stageEnableBitfield, NULL, NULL);
+ }
+
+ /**
+ * Clear the render target. Ignores the clip and all other draw state
+ * (blend mode, stages, etc). Clears the whole thing if rect is NULL,
+ * otherwise just the rect.
+ */
+ virtual void clear(const GrIRect* rect, GrColor color) = 0;
+
+ /**
+ * Returns the maximum number of edges that may be specified in a single
+ * draw call when performing edge antialiasing. This is usually limited
+ * by the number of fragment uniforms which may be uploaded. Must be a
+ * minimum of six, since a triangle's vertices each belong to two boundary
+ * edges which may be distinct.
+ */
+ virtual int getMaxEdges() const { return 6; }
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ class AutoStateRestore : ::GrNoncopyable {
+ public:
+ AutoStateRestore();
+ AutoStateRestore(GrDrawTarget* target);
+ ~AutoStateRestore();
+
+ /**
+ * if this object is already saving state for param target then
+ * this does nothing. Otherise, it restores previously saved state on
+ * previous target (if any) and saves current state on param target.
+ */
+ void set(GrDrawTarget* target);
+
+ private:
+ GrDrawTarget* fDrawTarget;
+ SavedDrawState fDrawState;
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ class AutoViewMatrixRestore : ::GrNoncopyable {
+ public:
+ AutoViewMatrixRestore() {
+ fDrawTarget = NULL;
+ }
+
+ AutoViewMatrixRestore(GrDrawTarget* target)
+ : fDrawTarget(target), fMatrix(fDrawTarget->getViewMatrix()) {
+ GrAssert(NULL != target);
+ }
+
+ void set(GrDrawTarget* target) {
+ GrAssert(NULL != target);
+ if (NULL != fDrawTarget) {
+ fDrawTarget->setViewMatrix(fMatrix);
+ }
+ fDrawTarget = target;
+ fMatrix = target->getViewMatrix();
+ }
+
+ ~AutoViewMatrixRestore() {
+ if (NULL != fDrawTarget) {
+ fDrawTarget->setViewMatrix(fMatrix);
+ }
+ }
+
+ private:
+ GrDrawTarget* fDrawTarget;
+ GrMatrix fMatrix;
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * Sets the view matrix to I and preconcats all stage matrices enabled in
+ * mask by the view inverse. Destructor undoes these changes.
+ */
+ class AutoDeviceCoordDraw : ::GrNoncopyable {
+ public:
+ AutoDeviceCoordDraw(GrDrawTarget* target, int stageMask);
+ ~AutoDeviceCoordDraw();
+ private:
+ GrDrawTarget* fDrawTarget;
+ GrMatrix fViewMatrix;
+ GrMatrix fSamplerMatrices[kNumStages];
+ int fStageMask;
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ class AutoReleaseGeometry : ::GrNoncopyable {
+ public:
+ AutoReleaseGeometry(GrDrawTarget* target,
+ GrVertexLayout vertexLayout,
+ int vertexCount,
+ int indexCount);
+ AutoReleaseGeometry();
+ ~AutoReleaseGeometry();
+ bool set(GrDrawTarget* target,
+ GrVertexLayout vertexLayout,
+ int vertexCount,
+ int indexCount);
+ bool succeeded() const { return NULL != fTarget; }
+ void* vertices() const { GrAssert(this->succeeded()); return fVertices; }
+ void* indices() const { GrAssert(this->succeeded()); return fIndices; }
+ GrPoint* positions() const {
+ return static_cast<GrPoint*>(this->vertices());
+ }
+
+ private:
+ void reset();
+
+ GrDrawTarget* fTarget;
+ void* fVertices;
+ void* fIndices;
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ class AutoClipRestore : ::GrNoncopyable {
+ public:
+ AutoClipRestore(GrDrawTarget* target) {
+ fTarget = target;
+ fClip = fTarget->getClip();
+ }
+
+ ~AutoClipRestore() {
+ fTarget->setClip(fClip);
+ }
+ private:
+ GrDrawTarget* fTarget;
+ GrClip fClip;
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ class AutoGeometryPush : ::GrNoncopyable {
+ public:
+ AutoGeometryPush(GrDrawTarget* target) {
+ GrAssert(NULL != target);
+ fTarget = target;
+ target->pushGeometrySource();
+ }
+ ~AutoGeometryPush() {
+ fTarget->popGeometrySource();
+ }
+ private:
+ GrDrawTarget* fTarget;
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+ // Helpers for picking apart vertex layouts
+
+ /**
+ * Helper function to compute the size of a vertex from a vertex layout
+ * @return size of a single vertex.
+ */
+ static size_t VertexSize(GrVertexLayout vertexLayout);
+
+ /**
+ * Helper function for determining the index of texture coordinates that
+ * is input for a texture stage. Note that a stage may instead use positions
+ * as texture coordinates, in which case the result of the function is
+ * indistinguishable from the case when the stage is disabled.
+ *
+ * @param stage the stage to query
+ * @param vertexLayout layout to query
+ *
+ * @return the texture coordinate index or -1 if the stage doesn't use
+ * separate (non-position) texture coordinates.
+ */
+ static int VertexTexCoordsForStage(int stage, GrVertexLayout vertexLayout);
+
+ /**
+ * Helper function to compute the offset of texture coordinates in a vertex
+ * @return offset of texture coordinates in vertex layout or -1 if the
+ * layout has no texture coordinates. Will be 0 if positions are
+ * used as texture coordinates for the stage.
+ */
+ static int VertexStageCoordOffset(int stage, GrVertexLayout vertexLayout);
+
+ /**
+ * Helper function to compute the offset of the color in a vertex
+ * @return offset of color in vertex layout or -1 if the
+ * layout has no color.
+ */
+ static int VertexColorOffset(GrVertexLayout vertexLayout);
+
+ /**
+ * Helper function to determine if vertex layout contains explicit texture
+ * coordinates of some index.
+ *
+ * @param coordIndex the tex coord index to query
+ * @param vertexLayout layout to query
+ *
+ * @return true if vertex specifies texture coordinates for the index,
+ * false otherwise.
+ */
+ static bool VertexUsesTexCoordIdx(int coordIndex,
+ GrVertexLayout vertexLayout);
+
+ /**
+ * Helper function to determine if vertex layout contains either explicit or
+ * implicit texture coordinates for a stage.
+ *
+ * @param stage the stage to query
+ * @param vertexLayout layout to query
+ *
+ * @return true if vertex specifies texture coordinates for the stage,
+ * false otherwise.
+ */
+ static bool VertexUsesStage(int stage, GrVertexLayout vertexLayout);
+
+ /**
+ * Helper function to compute the size of each vertex and the offsets of
+ * texture coordinates and color. Determines tex coord offsets by tex coord
+ * index rather than by stage. (Each stage can be mapped to any t.c. index
+ * by StageTexCoordVertexLayoutBit.)
+ *
+ * @param vertexLayout the layout to query
+ * @param texCoordOffsetsByIdx after return it is the offset of each
+ * tex coord index in the vertex or -1 if
+ * index isn't used.
+ * @return size of a single vertex
+ */
+ static int VertexSizeAndOffsetsByIdx(GrVertexLayout vertexLayout,
+ int texCoordOffsetsByIdx[kMaxTexCoords],
+ int *colorOffset);
+
+ /**
+ * Helper function to compute the size of each vertex and the offsets of
+ * texture coordinates and color. Determines tex coord offsets by stage
+ * rather than by index. (Each stage can be mapped to any t.c. index
+ * by StageTexCoordVertexLayoutBit.) If a stage uses positions for
+ * tex coords then that stage's offset will be 0 (positions are always at 0).
+ *
+ * @param vertexLayout the layout to query
+ * @param texCoordOffsetsByStage after return it is the offset of each
+ * tex coord index in the vertex or -1 if
+ * index isn't used.
+ * @return size of a single vertex
+ */
+ static int VertexSizeAndOffsetsByStage(GrVertexLayout vertexLayout,
+ int texCoordOffsetsByStage[kNumStages],
+ int *colorOffset);
+
+ /**
+ * Accessing positions, texture coords, or colors, of a vertex within an
+ * array is a hassle involving casts and simple math. These helpers exist
+ * to keep GrDrawTarget clients' code a bit nicer looking.
+ */
+
+ /**
+ * Gets a pointer to a GrPoint of a vertex's position or texture
+ * coordinate.
+ * @param vertices the vetex array
+ * @param vertexIndex the index of the vertex in the array
+ * @param vertexSize the size of each vertex in the array
+ * @param offset the offset in bytes of the vertex component.
+ * Defaults to zero (corresponding to vertex position)
+ * @return pointer to the vertex component as a GrPoint
+ */
+ static GrPoint* GetVertexPoint(void* vertices,
+ int vertexIndex,
+ int vertexSize,
+ int offset = 0) {
+ intptr_t start = GrTCast<intptr_t>(vertices);
+ return GrTCast<GrPoint*>(start + offset +
+ vertexIndex * vertexSize);
+ }
+ static const GrPoint* GetVertexPoint(const void* vertices,
+ int vertexIndex,
+ int vertexSize,
+ int offset = 0) {
+ intptr_t start = GrTCast<intptr_t>(vertices);
+ return GrTCast<const GrPoint*>(start + offset +
+ vertexIndex * vertexSize);
+ }
+
+ /**
+ * Gets a pointer to a GrColor inside a vertex within a vertex array.
+ * @param vertices the vetex array
+ * @param vertexIndex the index of the vertex in the array
+ * @param vertexSize the size of each vertex in the array
+ * @param offset the offset in bytes of the vertex color
+ * @return pointer to the vertex component as a GrColor
+ */
+ static GrColor* GetVertexColor(void* vertices,
+ int vertexIndex,
+ int vertexSize,
+ int offset) {
+ intptr_t start = GrTCast<intptr_t>(vertices);
+ return GrTCast<GrColor*>(start + offset +
+ vertexIndex * vertexSize);
+ }
+ static const GrColor* GetVertexColor(const void* vertices,
+ int vertexIndex,
+ int vertexSize,
+ int offset) {
+ const intptr_t start = GrTCast<intptr_t>(vertices);
+ return GrTCast<const GrColor*>(start + offset +
+ vertexIndex * vertexSize);
+ }
+
+ static void VertexLayoutUnitTest();
+
+protected:
+
+ enum GeometrySrcType {
+ kNone_GeometrySrcType, //<! src has not been specified
+ kReserved_GeometrySrcType, //<! src was set using reserve*Space
+ kArray_GeometrySrcType, //<! src was set using set*SourceToArray
+ kBuffer_GeometrySrcType //<! src was set using set*SourceToBuffer
+ };
+
+ struct GeometrySrcState {
+ GeometrySrcType fVertexSrc;
+ union {
+ // valid if src type is buffer
+ const GrVertexBuffer* fVertexBuffer;
+ // valid if src type is reserved or array
+ int fVertexCount;
+ };
+
+ GeometrySrcType fIndexSrc;
+ union {
+ // valid if src type is buffer
+ const GrIndexBuffer* fIndexBuffer;
+ // valid if src type is reserved or array
+ int fIndexCount;
+ };
+
+ GrVertexLayout fVertexLayout;
+ };
+
+ // given a vertex layout and a draw state, will a stage be used?
+ static bool StageWillBeUsed(int stage, GrVertexLayout layout,
+ const DrState& state) {
+ return NULL != state.fTextures[stage] && VertexUsesStage(stage, layout);
+ }
+
+ bool isStageEnabled(int stage) const {
+ return StageWillBeUsed(stage, this->getGeomSrc().fVertexLayout,
+ fCurrDrawState);
+ }
+
+ // Helpers for GrDrawTarget subclasses that won't have private access to
+ // SavedDrawState but need to peek at the state values.
+ static DrState& accessSavedDrawState(SavedDrawState& sds)
+ { return sds.fState; }
+ static const DrState& accessSavedDrawState(const SavedDrawState& sds)
+ { return sds.fState; }
+
+ // implemented by subclass to allocate space for reserved geom
+ virtual bool onReserveVertexSpace(GrVertexLayout vertexLayout,
+ int vertexCount,
+ void** vertices) = 0;
+ virtual bool onReserveIndexSpace(int indexCount, void** indices) = 0;
+ // implemented by subclass to handle release of reserved geom space
+ virtual void releaseReservedVertexSpace() = 0;
+ virtual void releaseReservedIndexSpace() = 0;
+ // subclass must consume array contents when set
+ virtual void onSetVertexSourceToArray(const void* vertexArray,
+ int vertexCount) = 0;
+ virtual void onSetIndexSourceToArray(const void* indexArray,
+ int indexCount) = 0;
+ // subclass is notified that geom source will be set away from an array
+ virtual void releaseVertexArray() = 0;
+ virtual void releaseIndexArray() = 0;
+ // subclass overrides to be notified just before geo src state
+ // is pushed/popped.
+ virtual void geometrySourceWillPush() = 0;
+ virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) = 0;
+ // subclass called to perform drawing
+ virtual void onDrawIndexed(GrPrimitiveType type,
+ int startVertex,
+ int startIndex,
+ int vertexCount,
+ int indexCount) = 0;
+ virtual void onDrawNonIndexed(GrPrimitiveType type,
+ int startVertex,
+ int vertexCount) = 0;
+ // subclass overrides to be notified when clip is set. Must call
+ // INHERITED::clipwillBeSet
+ virtual void clipWillBeSet(const GrClip& clip);
+
+ // Helpers for drawRect, protected so subclasses that override drawRect
+ // can use them.
+ static GrVertexLayout GetRectVertexLayout(StageBitfield stageEnableBitfield,
+ const GrRect* srcRects[]);
+
+ static void SetRectVertices(const GrRect& rect,
+ const GrMatrix* matrix,
+ const GrRect* srcRects[],
+ const GrMatrix* srcMatrices[],
+ GrVertexLayout layout,
+ void* vertices);
+
+ // accessor for derived classes
+ const GeometrySrcState& getGeomSrc() const {
+ return fGeoSrcStateStack.back();
+ }
+
+ GrClip fClip;
+
+ DrState fCurrDrawState;
+
+private:
+ // called when setting a new vert/idx source to unref prev vb/ib
+ void releasePreviousVertexSource();
+ void releasePreviousIndexSource();
+
+ enum {
+ kPreallocGeoSrcStateStackCnt = 4,
+ };
+ GrAlignedSTStorage<kPreallocGeoSrcStateStackCnt,
+ GeometrySrcState>
+ fGeoSrcStateStackStorage;
+ GrTArray<GeometrySrcState, true> fGeoSrcStateStack;
+
+};
+
+#endif
--- /dev/null
+
+/*
+ * 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 GrPathRenderer_DEFINED
+#define GrPathRenderer_DEFINED
+
+#include "GrDrawTarget.h"
+#include "SkTemplates.h"
+
+class SkPath;
+struct GrPoint;
+
+/**
+ * Base class for drawing paths into a GrDrawTarget.
+ * Paths may be drawn multiple times as when tiling for supersampling. The
+ * calls on GrPathRenderer to draw a path will look like this:
+ *
+ * pr->setPath(target, path, fill, translate); // sets the path to draw
+ * pr->drawPath(...); // draw the path
+ * pr->drawPath(...);
+ * ...
+ * pr->clearPath(); // finished with the path
+ */
+class GR_API GrPathRenderer : public GrRefCnt {
+public:
+ GrPathRenderer(void);
+ /**
+ * Returns true if this path renderer is able to render the path.
+ * Returning false allows the caller to fallback to another path renderer.
+ *
+ * @param path The path to draw
+ * @param fill The fill rule to use
+ *
+ * @return true if the path can be drawn by this object, false otherwise.
+ */
+ virtual bool canDrawPath(const SkPath& path, GrPathFill fill) const = 0;
+
+ /**
+ * For complex clips Gr uses the stencil buffer. The path renderer must be
+ * able to render paths into the stencil buffer. However, the path renderer
+ * itself may require the stencil buffer to resolve the path fill rule.
+ * This function queries whether the path render needs its own stencil
+ * pass. If this returns false then drawPath() should not modify the
+ * the target's stencil settings but use those already set on target. The
+ * target is passed as a param in case the answer depends upon draw state.
+ * The view matrix and render target set on the draw target may change
+ * before setPath/drawPath is called and so shouldn't be considered.
+ *
+ * @param target target that the path will be rendered to
+ * @param path the path that will be drawn
+ * @param fill the fill rule that will be used, will never be an inverse
+ * rule.
+ *
+ * @return false if this path renderer can generate interior-only fragments
+ * without changing the stencil settings on the target. If it
+ * returns true the drawPathToStencil will be used when rendering
+ * clips.
+ */
+ virtual bool requiresStencilPass(const GrDrawTarget* target,
+ const SkPath& path,
+ GrPathFill fill) const { return false; }
+
+ /**
+ * @return true if the path renderer can perform anti-aliasing (aside from
+ * having FSAA enabled for a render target). Target is provided to
+ * communicate the draw state (blend mode, stage settings, etc).
+ */
+ virtual bool supportsAA(GrDrawTarget* target,
+ const SkPath& path,
+ GrPathFill fill) { return false; }
+
+ /**
+ * Sets the path to render and target to render into. All calls to drawPath
+ * and drawPathToStencil must occur between setPath and clearPath. The
+ * path cannot be modified externally between setPath and clearPath. The
+ * path may be drawn several times (e.g. tiled supersampler). The target's
+ * state may change between setPath and drawPath* calls. However, if the
+ * path renderer specified vertices/indices during setPath or drawPath*
+ * they will still be set at subsequent drawPath* calls until the next
+ * clearPath. The target's draw state may change between drawPath* calls
+ * so if the subclass does any caching of tesselation, etc. then it must
+ * validate that target parameters that guided the decisions still hold.
+ *
+ * @param target the target to draw into.
+ * @param path the path to draw.
+ * @param fill the fill rule to apply.
+ * @param translate optional additional translation to apply to
+ * the path. NULL means (0,0).
+ */
+ void setPath(GrDrawTarget* target,
+ const SkPath* path,
+ GrPathFill fill,
+ const GrPoint* translate);
+
+ /**
+ * Notifies path renderer that path set in setPath is no longer in use.
+ */
+ void clearPath();
+
+ /**
+ * Draws the path into the draw target. If requiresStencilBuffer returned
+ * false then the target may be setup for stencil rendering (since the
+ * path renderer didn't claim that it needs to use the stencil internally).
+ *
+ * Only called between setPath / clearPath.
+ *
+ * @param stages bitfield that indicates which stages are
+ * in use. All enabled stages expect positions
+ * as texture coordinates. The path renderer
+ * use the remaining stages for its path
+ * filling algorithm.
+ */
+ virtual void drawPath(GrDrawTarget::StageBitfield stages) = 0;
+
+ /**
+ * Draws the path to the stencil buffer. Assume the writable stencil bits
+ * are already initialized to zero. Fill will always be either
+ * kWinding_PathFill or kEvenOdd_PathFill.
+ *
+ * Only called if requiresStencilPass returns true for the same combo of
+ * target, path, and fill. Never called with an inverse fill.
+ *
+ * The default implementation assumes the path filling algorithm doesn't
+ * require a separate stencil pass and so crashes.
+ *
+ * Only called between setPath / clearPath.
+ */
+ virtual void drawPathToStencil() {
+ GrCrash("Unexpected call to drawPathToStencil.");
+ }
+
+ /**
+ * This is called to install a custom path renderer in every GrContext at
+ * create time. The default implementation in GrCreatePathRenderer_none.cpp
+ * returns NULL. Link against another implementation to install your own.
+ */
+ static GrPathRenderer* CreatePathRenderer();
+
+ /**
+ * Multiply curve tolerance by the given value, increasing or decreasing
+ * the maximum error permitted in tesselating curves with short straight
+ * line segments.
+ */
+ void scaleCurveTolerance(GrScalar multiplier) {
+ GrAssert(multiplier > 0);
+ fCurveTolerance = SkScalarMul(fCurveTolerance, multiplier);
+ }
+
+ /**
+ * Helper that sets a path and automatically remove it in destructor.
+ */
+ class AutoClearPath {
+ public:
+ AutoClearPath() {
+ fPathRenderer = NULL;
+ }
+ AutoClearPath(GrPathRenderer* pr,
+ GrDrawTarget* target,
+ const SkPath* path,
+ GrPathFill fill,
+ const GrPoint* translate) {
+ GrAssert(NULL != pr);
+ pr->setPath(target, path, fill, translate);
+ fPathRenderer = pr;
+ }
+ void set(GrPathRenderer* pr,
+ GrDrawTarget* target,
+ const SkPath* path,
+ GrPathFill fill,
+ const GrPoint* translate) {
+ if (NULL != fPathRenderer) {
+ fPathRenderer->clearPath();
+ }
+ GrAssert(NULL != pr);
+ pr->setPath(target, path, fill, translate);
+ fPathRenderer = pr;
+ }
+ ~AutoClearPath() {
+ if (NULL != fPathRenderer) {
+ fPathRenderer->clearPath();
+ }
+ }
+ private:
+ GrPathRenderer* fPathRenderer;
+ };
+
+protected:
+
+ // subclass can override these to be notified just after a path is set
+ // and just before the path is cleared.
+ virtual void pathWasSet() {}
+ virtual void pathWillClear() {}
+
+ GrScalar fCurveTolerance;
+ const SkPath* fPath;
+ GrDrawTarget* fTarget;
+ GrPathFill fFill;
+ GrPoint fTranslate;
+
+private:
+
+ typedef GrRefCnt INHERITED;
+};
+
+/**
+ * Subclass that renders the path using the stencil buffer to resolve fill
+ * rules (e.g. winding, even-odd)
+ */
+class GR_API GrDefaultPathRenderer : public GrPathRenderer {
+public:
+ GrDefaultPathRenderer(bool separateStencilSupport,
+ bool stencilWrapOpsSupport);
+
+ virtual bool canDrawPath(const SkPath& path,
+ GrPathFill fill) const { return true; }
+
+ virtual bool requiresStencilPass(const GrDrawTarget* target,
+ const SkPath& path,
+ GrPathFill fill) const;
+
+ virtual void drawPath(GrDrawTarget::StageBitfield stages);
+ virtual void drawPathToStencil();
+
+protected:
+ virtual void pathWillClear();
+
+private:
+
+ void onDrawPath(GrDrawTarget::StageBitfield stages, bool stencilOnly);
+
+ bool createGeom(GrScalar srcSpaceTol,
+ GrDrawTarget::StageBitfield stages);
+
+ bool fSeparateStencil;
+ bool fStencilWrapOps;
+
+ int fSubpathCount;
+ SkAutoSTMalloc<8, uint16_t> fSubpathVertCount;
+ int fIndexCnt;
+ int fVertexCnt;
+ GrScalar fPreviousSrcTol;
+ GrDrawTarget::StageBitfield fPreviousStages;
+ GrPrimitiveType fPrimitiveType;
+ bool fUseIndexedDraw;
+
+ typedef GrPathRenderer INHERITED;
+};
+
+#endif
+
delete fDrawBuffer;
delete fDrawBufferVBAllocPool;
delete fDrawBufferIBAllocPool;
- GrSafeUnref(fDefaultPathRenderer);
GrSafeUnref(fCustomPathRenderer);
GrSafeUnref(fAAFillRectIndexBuffer);
GrSafeUnref(fAAStrokeRectIndexBuffer);
fGpu->printStats();
}
-GrContext::GrContext(GrGpu* gpu) {
+GrContext::GrContext(GrGpu* gpu) :
+ fDefaultPathRenderer(gpu->supportsTwoSidedStencil(),
+ gpu->supportsStencilWrapOps()) {
+
fGpu = gpu;
fGpu->ref();
fGpu->setContext(this);
- fDefaultPathRenderer =
- new GrDefaultPathRenderer(gpu->supportsTwoSidedStencil(),
- gpu->supportsStencilWrapOps());
fCustomPathRenderer = GrPathRenderer::CreatePathRenderer();
fGpu->setClipPathRenderer(fCustomPathRenderer);
fCustomPathRenderer->canDrawPath(path, fill)) {
return fCustomPathRenderer;
} else {
- GrAssert(fDefaultPathRenderer->canDrawPath(path, fill));
- return fDefaultPathRenderer;
+ GrAssert(fDefaultPathRenderer.canDrawPath(path, fill));
+ return &fDefaultPathRenderer;
}
}
+++ /dev/null
-
-/*
- * 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 GrDrawTarget_DEFINED
-#define GrDrawTarget_DEFINED
-
-#include "GrClip.h"
-#include "GrColor.h"
-#include "GrMatrix.h"
-#include "GrRefCnt.h"
-#include "GrRenderTarget.h"
-#include "GrSamplerState.h"
-#include "GrStencil.h"
-#include "GrTexture.h"
-
-#include "SkXfermode.h"
-
-class GrTexture;
-class GrClipIterator;
-class GrVertexBuffer;
-class GrIndexBuffer;
-
-class GrDrawTarget : public GrRefCnt {
-public:
- /**
- * Number of texture stages. Each stage takes as input a color and
- * 2D texture coordinates. The color input to the first enabled stage is the
- * per-vertex color or the constant color (setColor/setAlpha) if there are
- * no per-vertex colors. For subsequent stages the input color is the output
- * color from the previous enabled stage. The output color of each stage is
- * the input color modulated with the result of a texture lookup. Texture
- * lookups are specified by a texture a sampler (setSamplerState). Texture
- * coordinates for each stage come from the vertices based on a
- * GrVertexLayout bitfield. The output fragment color is the output color of
- * the last enabled stage. The presence or absence of texture coordinates
- * for each stage in the vertex layout indicates whether a stage is enabled
- * or not.
- */
- enum {
- kNumStages = 3,
- kMaxTexCoords = kNumStages
- };
-
-
- /**
- * The absolute maximum number of edges that may be specified for
- * a single draw call when performing edge antialiasing. This is used for
- * the size of several static buffers, so implementations of getMaxEdges()
- * (below) should clamp to this value.
- */
- enum {
- kMaxEdges = 32
- };
-
- /**
- * Bitfield used to indicate which stages are in use.
- */
- typedef int StageBitfield;
- GR_STATIC_ASSERT(sizeof(StageBitfield)*8 >= kNumStages);
-
- /**
- * Flags that affect rendering. Controlled using enable/disableState(). All
- * default to disabled.
- */
- enum StateBits {
- kDither_StateBit = 0x01, //<! Perform color dithering
- kAntialias_StateBit = 0x02, //<! Perform anti-aliasing. The render-
- // target must support some form of AA
- // (msaa, coverage sampling, etc). For
- // GrGpu-created rendertarget/textures
- // this is controlled by parameters
- // passed to createTexture.
- kClip_StateBit = 0x04, //<! Controls whether drawing is clipped
- // against the region specified by
- // setClip.
- kNoColorWrites_StateBit = 0x08, //<! If set it disables writing colors.
- // Useful while performing stencil
- // ops.
- kEdgeAAConcave_StateBit = 0x10,//<! If set, edge AA will test edge
- // pairs for convexity while
- // rasterizing. Set this if the
- // source polygon is non-convex.
-
- // subclass may use additional bits internally
- kDummyStateBit,
- kLastPublicStateBit = kDummyStateBit-1
- };
-
- enum DrawFace {
- kBoth_DrawFace,
- kCCW_DrawFace,
- kCW_DrawFace,
- };
-
- /**
- * Sets the stencil settings to use for the next draw.
- * Changing the clip has the side-effect of possibly zeroing
- * out the client settable stencil bits. So multipass algorithms
- * using stencil should not change the clip between passes.
- * @param settings the stencil settings to use.
- */
- void setStencil(const GrStencilSettings& settings) {
- fCurrDrawState.fStencilSettings = settings;
- }
-
- /**
- * Shortcut to disable stencil testing and ops.
- */
- void disableStencil() {
- fCurrDrawState.fStencilSettings.setDisabled();
- }
-
- class Edge {
- public:
- Edge() {}
- Edge(float x, float y, float z) : fX(x), fY(y), fZ(z) {}
- GrPoint intersect(const Edge& other) {
- return GrPoint::Make(
- (fY * other.fZ - other.fY * fZ) /
- (fX * other.fY - other.fX * fY),
- (fX * other.fZ - other.fX * fZ) /
- (other.fX * fY - fX * other.fY));
- }
- float fX, fY, fZ;
- };
-
-protected:
-
- struct DrState {
- DrState() {
- // make sure any pad is zero for memcmp
- // all DrState members should default to something
- // valid by the memset
- memset(this, 0, sizeof(DrState));
-
- // memset exceptions
- fColorFilterXfermode = SkXfermode::kDstIn_Mode;
- fFirstCoverageStage = kNumStages;
-
- // pedantic assertion that our ptrs will
- // be NULL (0 ptr is mem addr 0)
- GrAssert((intptr_t)(void*)NULL == 0LL);
-
- // default stencil setting should be disabled
- GrAssert(fStencilSettings.isDisabled());
- fFirstCoverageStage = kNumStages;
- }
- uint32_t fFlagBits;
- GrBlendCoeff fSrcBlend;
- GrBlendCoeff fDstBlend;
- GrColor fBlendConstant;
- GrTexture* fTextures[kNumStages];
- GrSamplerState fSamplerStates[kNumStages];
- int fFirstCoverageStage;
- GrRenderTarget* fRenderTarget;
- GrColor fColor;
- DrawFace fDrawFace;
- GrColor fColorFilterColor;
- SkXfermode::Mode fColorFilterXfermode;
-
- GrStencilSettings fStencilSettings;
- GrMatrix fViewMatrix;
- Edge fEdgeAAEdges[kMaxEdges];
- int fEdgeAANumEdges;
- bool operator ==(const DrState& s) const {
- return 0 == memcmp(this, &s, sizeof(DrState));
- }
- bool operator !=(const DrState& s) const { return !(*this == s); }
- };
-
-public:
- ///////////////////////////////////////////////////////////////////////////
-
- GrDrawTarget();
- virtual ~GrDrawTarget();
-
- /**
- * Sets the current clip to the region specified by clip. All draws will be
- * clipped against this clip if kClip_StateBit is enabled.
- *
- * Setting the clip may (or may not) zero out the client's stencil bits.
- *
- * @param description of the clipping region
- */
- void setClip(const GrClip& clip);
-
- /**
- * Gets the current clip.
- *
- * @return the clip.
- */
- const GrClip& getClip() const;
-
- /**
- * Sets the texture used at the next drawing call
- *
- * @param stage The texture stage for which the texture will be set
- *
- * @param texture The texture to set. Can be NULL though there is no advantage
- * to settings a NULL texture if doing non-textured drawing
- */
- void setTexture(int stage, GrTexture* texture);
-
- /**
- * Retrieves the currently set texture.
- *
- * @return The currently set texture. The return value will be NULL if no
- * texture has been set, NULL was most recently passed to
- * setTexture, or the last setTexture was destroyed.
- */
- const GrTexture* getTexture(int stage) const;
- GrTexture* getTexture(int stage);
-
- /**
- * Sets the rendertarget used at the next drawing call
- *
- * @param target The render target to set.
- */
- void setRenderTarget(GrRenderTarget* target);
-
- /**
- * Retrieves the currently set rendertarget.
- *
- * @return The currently set render target.
- */
- const GrRenderTarget* getRenderTarget() const;
- GrRenderTarget* getRenderTarget();
-
- /**
- * Sets the sampler state for a stage used in subsequent draws.
- *
- * The sampler state determines how texture coordinates are
- * intepretted and used to sample the texture.
- *
- * @param stage the stage of the sampler to set
- * @param samplerState Specifies the sampler state.
- */
- void setSamplerState(int stage, const GrSamplerState& samplerState);
-
- /**
- * Concats the matrix of a stage's sampler.
- *
- * @param stage the stage of the sampler to set
- * @param matrix the matrix to concat
- */
- void preConcatSamplerMatrix(int stage, const GrMatrix& matrix) {
- GrAssert(stage >= 0 && stage < kNumStages);
- fCurrDrawState.fSamplerStates[stage].preConcatMatrix(matrix);
- }
-
- /**
- * Shortcut for preConcatSamplerMatrix on all stages in mask with same
- * matrix
- */
- void preConcatSamplerMatrices(int stageMask, const GrMatrix& matrix) {
- for (int i = 0; i < kNumStages; ++i) {
- if ((1 << i) & stageMask) {
- this->preConcatSamplerMatrix(i, matrix);
- }
- }
- }
-
- /**
- * Gets the matrix of a stage's sampler
- *
- * @param stage the stage to of sampler to get
- * @return the sampler state's matrix
- */
- const GrMatrix& getSamplerMatrix(int stage) const {
- return fCurrDrawState.fSamplerStates[stage].getMatrix();
- }
-
- /**
- * Sets the matrix of a stage's sampler
- *
- * @param stage the stage of sampler set
- * @param matrix the matrix to set
- */
- void setSamplerMatrix(int stage, const GrMatrix& matrix) {
- fCurrDrawState.fSamplerStates[stage].setMatrix(matrix);
- }
-
- /**
- * Sets the matrix applied to veretx positions.
- *
- * In the post-view-matrix space the rectangle [0,w]x[0,h]
- * fully covers the render target. (w and h are the width and height of the
- * the rendertarget.)
- *
- * @param m the matrix used to transform the vertex positions.
- */
- void setViewMatrix(const GrMatrix& m);
-
- /**
- * Multiplies the current view matrix by a matrix
- *
- * After this call V' = V*m where V is the old view matrix,
- * m is the parameter to this function, and V' is the new view matrix.
- * (We consider positions to be column vectors so position vector p is
- * transformed by matrix X as p' = X*p.)
- *
- * @param m the matrix used to modify the view matrix.
- */
- void preConcatViewMatrix(const GrMatrix& m);
-
- /**
- * Multiplies the current view matrix by a matrix
- *
- * After this call V' = m*V where V is the old view matrix,
- * m is the parameter to this function, and V' is the new view matrix.
- * (We consider positions to be column vectors so position vector p is
- * transformed by matrix X as p' = X*p.)
- *
- * @param m the matrix used to modify the view matrix.
- */
- void postConcatViewMatrix(const GrMatrix& m);
-
- /**
- * Retrieves the current view matrix
- * @return the current view matrix.
- */
- const GrMatrix& getViewMatrix() const;
-
- /**
- * Retrieves the inverse of the current view matrix.
- *
- * If the current view matrix is invertible, return true, and if matrix
- * is non-null, copy the inverse into it. If the current view matrix is
- * non-invertible, return false and ignore the matrix parameter.
- *
- * @param matrix if not null, will receive a copy of the current inverse.
- */
- bool getViewInverse(GrMatrix* matrix) const;
-
- /**
- * Sets color for next draw to a premultiplied-alpha color.
- *
- * @param the color to set.
- */
- void setColor(GrColor);
-
- /**
- * Add a color filter that can be represented by a color and a mode.
- */
- void setColorFilter(GrColor, SkXfermode::Mode);
-
- /**
- * Sets the color to be used for the next draw to be
- * (r,g,b,a) = (alpha, alpha, alpha, alpha).
- *
- * @param alpha The alpha value to set as the color.
- */
- void setAlpha(uint8_t alpha);
-
- /**
- * Controls whether clockwise, counterclockwise, or both faces are drawn.
- * @param face the face(s) to draw.
- */
- void setDrawFace(DrawFace face) { fCurrDrawState.fDrawFace = face; }
-
- /**
- * A common pattern is to compute a color with the initial stages and then
- * modulate that color by a coverage value in later stage(s) (AA, mask-
- * filters, glyph mask, etc). Color-filters, xfermodes, etc should be
- * computed based on the pre-coverage-modulated color. The division of
- * stages between color-computing and coverage-computing is specified by
- * this method. Initially this is kNumStages (all stages are color-
- * computing).
- */
- void setFirstCoverageStage(int firstCoverageStage) {
- fCurrDrawState.fFirstCoverageStage = firstCoverageStage;
- }
-
- /**
- * Gets the index of the first coverage-computing stage.
- */
- int getFirstCoverageStage() const {
- return fCurrDrawState.fFirstCoverageStage;
- }
-
- /**
- * Gets whether the target is drawing clockwise, counterclockwise,
- * or both faces.
- * @return the current draw face(s).
- */
- DrawFace getDrawFace() const { return fCurrDrawState.fDrawFace; }
-
- /**
- * Enable render state settings.
- *
- * @param flags bitfield of StateBits specifing the states to enable
- */
- void enableState(uint32_t stateBits);
-
- /**
- * Disable render state settings.
- *
- * @param flags bitfield of StateBits specifing the states to disable
- */
- void disableState(uint32_t stateBits);
-
- bool isDitherState() const {
- return 0 != (fCurrDrawState.fFlagBits & kDither_StateBit);
- }
-
- bool isAntialiasState() const {
- return 0 != (fCurrDrawState.fFlagBits & kAntialias_StateBit);
- }
-
- bool isClipState() const {
- return 0 != (fCurrDrawState.fFlagBits & kClip_StateBit);
- }
-
- bool isColorWriteDisabled() const {
- return 0 != (fCurrDrawState.fFlagBits & kNoColorWrites_StateBit);
- }
-
- /**
- * Sets the blending function coeffecients.
- *
- * The blend function will be:
- * D' = sat(S*srcCoef + D*dstCoef)
- *
- * where D is the existing destination color, S is the incoming source
- * color, and D' is the new destination color that will be written. sat()
- * is the saturation function.
- *
- * @param srcCoef coeffecient applied to the src color.
- * @param dstCoef coeffecient applied to the dst color.
- */
- void setBlendFunc(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff);
-
- /**
- * Sets the blending function constant referenced by the following blending
- * coeffecients:
- * kConstC_BlendCoeff
- * kIConstC_BlendCoeff
- * kConstA_BlendCoeff
- * kIConstA_BlendCoeff
- *
- * @param constant the constant to set
- */
- void setBlendConstant(GrColor constant) { fCurrDrawState.fBlendConstant = constant; }
-
- /**
- * Retrieves the last value set by setBlendConstant()
- * @return the blending constant value
- */
- GrColor getBlendConstant() const { return fCurrDrawState.fBlendConstant; }
-
- /**
- * Used to save and restore the GrGpu's drawing state
- */
- struct SavedDrawState {
- private:
- DrState fState;
- friend class GrDrawTarget;
- };
-
- /**
- * Saves the current draw state. The state can be restored at a later time
- * with restoreDrawState.
- *
- * See also AutoStateRestore class.
- *
- * @param state will hold the state after the function returns.
- */
- void saveCurrentDrawState(SavedDrawState* state) const;
-
- /**
- * Restores previously saved draw state. The client guarantees that state
- * was previously passed to saveCurrentDrawState and that the rendertarget
- * and texture set at save are still valid.
- *
- * See also AutoStateRestore class.
- *
- * @param state the previously saved state to restore.
- */
- void restoreDrawState(const SavedDrawState& state);
-
- /**
- * Copies the draw state from another target to this target.
- *
- * @param srcTarget draw target used as src of the draw state.
- */
- void copyDrawState(const GrDrawTarget& srcTarget);
-
- /**
- * The format of vertices is represented as a bitfield of flags.
- * Flags that indicate the layout of vertex data. Vertices always contain
- * positions and may also contain up to kMaxTexCoords sets of 2D texture
- * coordinates and per-vertex colors. Each stage can use any of the texture
- * coordinates as its input texture coordinates or it may use the positions.
- *
- * If no texture coordinates are specified for a stage then the stage is
- * disabled.
- *
- * Only one type of texture coord can be specified per stage. For
- * example StageTexCoordVertexLayoutBit(0, 2) and
- * StagePosAsTexCoordVertexLayoutBit(0) cannot both be specified.
- *
- * The order in memory is always (position, texture coord 0, ..., color)
- * with any unused fields omitted. Note that this means that if only texture
- * coordinates 1 is referenced then there is no texture coordinates 0 and
- * the order would be (position, texture coordinate 1[, color]).
- */
-
- /**
- * Generates a bit indicating that a texture stage uses texture coordinates
- *
- * @param stage the stage that will use texture coordinates.
- * @param texCoordIdx the index of the texture coordinates to use
- *
- * @return the bit to add to a GrVertexLayout bitfield.
- */
- static int StageTexCoordVertexLayoutBit(int stage, int texCoordIdx) {
- GrAssert(stage < kNumStages);
- GrAssert(texCoordIdx < kMaxTexCoords);
- return 1 << (stage + (texCoordIdx * kNumStages));
- }
-
- /**
- * Determines if blend is effectively disabled.
- *
- * @return true if blend can be disabled without changing the rendering
- * result given the current state including the vertex layout specified
- * with the vertex source.
- */
- bool canDisableBlend() const;
-
- /**
- * Sets the edge data required for edge antialiasing.
- *
- * @param edges 3 * 6 float values, representing the edge
- * equations in Ax + By + C form
- */
- void setEdgeAAData(const Edge* edges, int numEdges);
-
-private:
- static const int TEX_COORD_BIT_CNT = kNumStages*kMaxTexCoords;
-public:
- /**
- * Generates a bit indicating that a texture stage uses the position
- * as its texture coordinate.
- *
- * @param stage the stage that will use position as texture
- * coordinates.
- *
- * @return the bit to add to a GrVertexLayout bitfield.
- */
- static int StagePosAsTexCoordVertexLayoutBit(int stage) {
- GrAssert(stage < kNumStages);
- return (1 << (TEX_COORD_BIT_CNT + stage));
- }
-private:
- static const int STAGE_BIT_CNT = TEX_COORD_BIT_CNT + kNumStages;
-
-public:
-
- /**
- * Additional Bits that can be specified in GrVertexLayout.
- */
- enum VertexLayoutBits {
-
- kColor_VertexLayoutBit = 1 << (STAGE_BIT_CNT + 0),
- //<! vertices have colors
- kTextFormat_VertexLayoutBit = 1 << (STAGE_BIT_CNT + 1),
- //<! use text vertices. (Pos
- // and tex coords may be
- // a different type for
- // text [GrGpuTextVertex vs
- // GrPoint].)
- // for below assert
- kDummyVertexLayoutBit,
- kHighVertexLayoutBit = kDummyVertexLayoutBit - 1
- };
- // make sure we haven't exceeded the number of bits in GrVertexLayout.
- GR_STATIC_ASSERT(kHighVertexLayoutBit < ((uint64_t)1 << 8*sizeof(GrVertexLayout)));
-
- /**
- * There are three methods for specifying geometry (vertices and optionally
- * indices) to the draw target. When indexed drawing the indices and vertices
- * can use a different method. Once geometry is specified it can be used for
- * multiple drawIndexed and drawNonIndexed calls.
- *
- * Sometimes it is necessary to perform a draw while upstack code has
- * already specified geometry that it isn't finished with. There are push
- * pop methods
- *
- * 1. Provide a cpu array (set*SourceToArray). This is useful when the
- * caller's client has already provided vertex data in a format
- * the time compatible with a GrVertexLayout. The array must contain the
- * data at set*SourceToArray is called. The source stays in effect for
- * drawIndexed & drawNonIndexed calls until set*SourceToArray is called
- * again or one of the other two paths is chosen.
- *
- * 2. Reserve. This is most useful when the caller has data it must
- * transform before drawing and is not long-lived. The caller requests
- * that the draw target make room for some amount of vertex and/or index
- * data. The target provides ptrs to hold the vertex and/or index data.
- *
- * The data is writable up until the next drawIndexed, drawNonIndexed,
- * or pushGeometrySource At this point the data is frozen and the ptrs
- * are no longer valid.
- *
- * 3. Vertex and Index Buffers. This is most useful for geometry that will
- * is long-lived. SetVertexSourceToBuffer and SetIndexSourceToBuffer are
- * used to set the buffer and subsequent drawIndexed and drawNonIndexed
- * calls use this source until another source is set.
- */
-
- /**
- * Reserves space for vertices. Draw target will use reserved vertices at
- * at the next draw.
- *
- * If succeeds:
- * if vertexCount > 0, *vertices will be the array
- * of vertices to be filled by caller. The next draw will read
- * these vertices.
- *
- * If a client does not already have a vertex buffer then this is the
- * preferred way to allocate vertex data. It allows the subclass of
- * GrDrawTarget to decide whether to put data in buffers, to group vertex
- * data that uses the same state (e.g. for deferred rendering), etc.
- *
- * After the next draw or pushGeometrySource the vertices ptr is no longer
- * valid and the geometry data cannot be further modified. The contents
- * that were put in the reserved space can be drawn by multiple draws,
- * however.
- *
- * @param vertexLayout the format of vertices (ignored if vertexCount == 0).
- * @param vertexCount the number of vertices to reserve space for. Can be 0.
- * @param vertices will point to reserved vertex space if vertexCount is
- * non-zero. Illegal to pass NULL if vertexCount > 0.
- *
- * @return true if succeeded in allocating space for the vertices and false
- * if not.
- */
- bool reserveVertexSpace(GrVertexLayout vertexLayout,
- int vertexCount,
- void** vertices);
- /**
- * Reserves space for indices. Draw target will use the reserved indices at
- * the next indexed draw.
- *
- * If succeeds:
- * if indexCount > 0, *indices will be the array
- * of indices to be filled by caller. The next draw will read
- * these indices.
- *
- * If a client does not already have a index buffer then this is the
- * preferred way to allocate index data. It allows the subclass of
- * GrDrawTarget to decide whether to put data in buffers, to group index
- * data that uses the same state (e.g. for deferred rendering), etc.
- *
- * After the next indexed draw or pushGeometrySource the indices ptr is no
- * longer valid and the geometry data cannot be further modified. The
- * contents that were put in the reserved space can be drawn by multiple
- * draws, however.
- *
- * @param indexCount the number of indices to reserve space for. Can be 0.
- * @param indices will point to reserved index space if indexCount is
- * non-zero. Illegal to pass NULL if indexCount > 0.
- */
-
- bool reserveIndexSpace(int indexCount, void** indices);
- /**
- * Provides hints to caller about the number of vertices and indices
- * that can be allocated cheaply. This can be useful if caller is reserving
- * space but doesn't know exactly how much geometry is needed.
- *
- * Also may hint whether the draw target should be flushed first. This is
- * useful for deferred targets.
- *
- * @param vertexLayout layout of vertices caller would like to reserve
- * @param vertexCount in: hint about how many vertices the caller would
- * like to allocate.
- * out: a hint about the number of vertices that can be
- * allocated cheaply. Negative means no hint.
- * Ignored if NULL.
- * @param indexCount in: hint about how many indices the caller would
- * like to allocate.
- * out: a hint about the number of indices that can be
- * allocated cheaply. Negative means no hint.
- * Ignored if NULL.
- *
- * @return true if target should be flushed based on the input values.
- */
- virtual bool geometryHints(GrVertexLayout vertexLayout,
- int* vertexCount,
- int* indexCount) const;
-
- /**
- * Sets source of vertex data for the next draw. Array must contain
- * the vertex data when this is called.
- *
- * @param array cpu array containing vertex data.
- * @param size size of the vertex data.
- * @param vertexCount the number of vertices in the array.
- */
- void setVertexSourceToArray(GrVertexLayout vertexLayout,
- const void* vertexArray,
- int vertexCount);
-
- /**
- * Sets source of index data for the next indexed draw. Array must contain
- * the indices when this is called.
- *
- * @param array cpu array containing index data.
- * @param indexCount the number of indices in the array.
- */
- void setIndexSourceToArray(const void* indexArray, int indexCount);
-
- /**
- * Sets source of vertex data for the next draw. Data does not have to be
- * in the buffer until drawIndexed or drawNonIndexed.
- *
- * @param buffer vertex buffer containing vertex data. Must be
- * unlocked before draw call.
- * @param vertexLayout layout of the vertex data in the buffer.
- */
- void setVertexSourceToBuffer(GrVertexLayout vertexLayout,
- const GrVertexBuffer* buffer);
-
- /**
- * Sets source of index data for the next indexed draw. Data does not have
- * to be in the buffer until drawIndexed or drawNonIndexed.
- *
- * @param buffer index buffer containing indices. Must be unlocked
- * before indexed draw call.
- */
- void setIndexSourceToBuffer(const GrIndexBuffer* buffer);
-
- /**
- * Resets vertex source. Drawing from reset vertices is illegal. Set vertex
- * source to reserved, array, or buffer before next draw. May be able to free
- * up temporary storage allocated by setVertexSourceToArray or
- * reserveVertexSpace.
- */
- void resetVertexSource();
-
- /**
- * Resets index source. Indexed Drawing from reset indices is illegal. Set
- * index source to reserved, array, or buffer before next indexed draw. May
- * be able to free up temporary storage allocated by setIndexSourceToArray
- * or reserveIndexSpace.
- */
- void resetIndexSource();
-
- /**
- * Pushes and resets the vertex/index sources. Any reserved vertex / index
- * data is finalized (i.e. cannot be updated after the matching pop but can
- * be drawn from). Must be balanced by a pop.
- */
- void pushGeometrySource();
-
- /**
- * Pops the vertex / index sources from the matching push.
- */
- void popGeometrySource();
-
- /**
- * Draws indexed geometry using the current state and current vertex / index
- * sources.
- *
- * @param type The type of primitives to draw.
- * @param startVertex the vertex in the vertex array/buffer corresponding
- * to index 0
- * @param startIndex first index to read from index src.
- * @param vertexCount one greater than the max index.
- * @param indexCount the number of index elements to read. The index count
- * is effectively trimmed to the last completely
- * specified primitive.
- */
- void drawIndexed(GrPrimitiveType type,
- int startVertex,
- int startIndex,
- int vertexCount,
- int indexCount);
-
- /**
- * Draws non-indexed geometry using the current state and current vertex
- * sources.
- *
- * @param type The type of primitives to draw.
- * @param startVertex the vertex in the vertex array/buffer corresponding
- * to index 0
- * @param vertexCount one greater than the max index.
- */
- void drawNonIndexed(GrPrimitiveType type,
- int startVertex,
- int vertexCount);
-
- /**
- * Helper function for drawing rects. This does not use the current index
- * and vertex sources. After returning, the vertex and index sources may
- * have changed. They should be reestablished before the next drawIndexed
- * or drawNonIndexed. This cannot be called between reserving and releasing
- * geometry. The GrDrawTarget subclass may be able to perform additional
- * optimizations if drawRect is used rather than drawIndexed or
- * drawNonIndexed.
- * @param rect the rect to draw
- * @param matrix optional matrix applied to rect (before viewMatrix)
- * @param stageEnableBitfield bitmask indicating which stages are enabled.
- * Bit i indicates whether stage i is enabled.
- * @param srcRects specifies rects for stages enabled by stageEnableMask.
- * if stageEnableMask bit i is 1, srcRects is not NULL,
- * and srcRects[i] is not NULL, then srcRects[i] will be
- * used as coordinates for stage i. Otherwise, if stage i
- * is enabled then rect is used as the coordinates.
- * @param srcMatrices optional matrices applied to srcRects. If
- * srcRect[i] is non-NULL and srcMatrices[i] is
- * non-NULL then srcRect[i] will be transformed by
- * srcMatrix[i]. srcMatrices can be NULL when no
- * srcMatrices are desired.
- */
- virtual void drawRect(const GrRect& rect,
- const GrMatrix* matrix,
- StageBitfield stageEnableBitfield,
- const GrRect* srcRects[],
- const GrMatrix* srcMatrices[]);
-
- /**
- * Helper for drawRect when the caller doesn't need separate src rects or
- * matrices.
- */
- void drawSimpleRect(const GrRect& rect,
- const GrMatrix* matrix,
- StageBitfield stageEnableBitfield) {
- drawRect(rect, matrix, stageEnableBitfield, NULL, NULL);
- }
-
- /**
- * Clear the render target. Ignores the clip and all other draw state
- * (blend mode, stages, etc). Clears the whole thing if rect is NULL,
- * otherwise just the rect.
- */
- virtual void clear(const GrIRect* rect, GrColor color) = 0;
-
- /**
- * Returns the maximum number of edges that may be specified in a single
- * draw call when performing edge antialiasing. This is usually limited
- * by the number of fragment uniforms which may be uploaded. Must be a
- * minimum of six, since a triangle's vertices each belong to two boundary
- * edges which may be distinct.
- */
- virtual int getMaxEdges() const { return 6; }
-
- ////////////////////////////////////////////////////////////////////////////
-
- class AutoStateRestore : ::GrNoncopyable {
- public:
- AutoStateRestore();
- AutoStateRestore(GrDrawTarget* target);
- ~AutoStateRestore();
-
- /**
- * if this object is already saving state for param target then
- * this does nothing. Otherise, it restores previously saved state on
- * previous target (if any) and saves current state on param target.
- */
- void set(GrDrawTarget* target);
-
- private:
- GrDrawTarget* fDrawTarget;
- SavedDrawState fDrawState;
- };
-
- ////////////////////////////////////////////////////////////////////////////
-
- class AutoViewMatrixRestore : ::GrNoncopyable {
- public:
- AutoViewMatrixRestore() {
- fDrawTarget = NULL;
- }
-
- AutoViewMatrixRestore(GrDrawTarget* target)
- : fDrawTarget(target), fMatrix(fDrawTarget->getViewMatrix()) {
- GrAssert(NULL != target);
- }
-
- void set(GrDrawTarget* target) {
- GrAssert(NULL != target);
- if (NULL != fDrawTarget) {
- fDrawTarget->setViewMatrix(fMatrix);
- }
- fDrawTarget = target;
- fMatrix = target->getViewMatrix();
- }
-
- ~AutoViewMatrixRestore() {
- if (NULL != fDrawTarget) {
- fDrawTarget->setViewMatrix(fMatrix);
- }
- }
-
- private:
- GrDrawTarget* fDrawTarget;
- GrMatrix fMatrix;
- };
-
- ////////////////////////////////////////////////////////////////////////////
-
- /**
- * Sets the view matrix to I and preconcats all stage matrices enabled in
- * mask by the view inverse. Destructor undoes these changes.
- */
- class AutoDeviceCoordDraw : ::GrNoncopyable {
- public:
- AutoDeviceCoordDraw(GrDrawTarget* target, int stageMask);
- ~AutoDeviceCoordDraw();
- private:
- GrDrawTarget* fDrawTarget;
- GrMatrix fViewMatrix;
- GrMatrix fSamplerMatrices[kNumStages];
- int fStageMask;
- };
-
- ////////////////////////////////////////////////////////////////////////////
-
- class AutoReleaseGeometry : ::GrNoncopyable {
- public:
- AutoReleaseGeometry(GrDrawTarget* target,
- GrVertexLayout vertexLayout,
- int vertexCount,
- int indexCount);
- AutoReleaseGeometry();
- ~AutoReleaseGeometry();
- bool set(GrDrawTarget* target,
- GrVertexLayout vertexLayout,
- int vertexCount,
- int indexCount);
- bool succeeded() const { return NULL != fTarget; }
- void* vertices() const { GrAssert(this->succeeded()); return fVertices; }
- void* indices() const { GrAssert(this->succeeded()); return fIndices; }
- GrPoint* positions() const {
- return static_cast<GrPoint*>(this->vertices());
- }
-
- private:
- void reset();
-
- GrDrawTarget* fTarget;
- void* fVertices;
- void* fIndices;
- };
-
- ////////////////////////////////////////////////////////////////////////////
-
- class AutoClipRestore : ::GrNoncopyable {
- public:
- AutoClipRestore(GrDrawTarget* target) {
- fTarget = target;
- fClip = fTarget->getClip();
- }
-
- ~AutoClipRestore() {
- fTarget->setClip(fClip);
- }
- private:
- GrDrawTarget* fTarget;
- GrClip fClip;
- };
-
- ////////////////////////////////////////////////////////////////////////////
-
- class AutoGeometryPush : ::GrNoncopyable {
- public:
- AutoGeometryPush(GrDrawTarget* target) {
- GrAssert(NULL != target);
- fTarget = target;
- target->pushGeometrySource();
- }
- ~AutoGeometryPush() {
- fTarget->popGeometrySource();
- }
- private:
- GrDrawTarget* fTarget;
- };
-
- ////////////////////////////////////////////////////////////////////////////
- // Helpers for picking apart vertex layouts
-
- /**
- * Helper function to compute the size of a vertex from a vertex layout
- * @return size of a single vertex.
- */
- static size_t VertexSize(GrVertexLayout vertexLayout);
-
- /**
- * Helper function for determining the index of texture coordinates that
- * is input for a texture stage. Note that a stage may instead use positions
- * as texture coordinates, in which case the result of the function is
- * indistinguishable from the case when the stage is disabled.
- *
- * @param stage the stage to query
- * @param vertexLayout layout to query
- *
- * @return the texture coordinate index or -1 if the stage doesn't use
- * separate (non-position) texture coordinates.
- */
- static int VertexTexCoordsForStage(int stage, GrVertexLayout vertexLayout);
-
- /**
- * Helper function to compute the offset of texture coordinates in a vertex
- * @return offset of texture coordinates in vertex layout or -1 if the
- * layout has no texture coordinates. Will be 0 if positions are
- * used as texture coordinates for the stage.
- */
- static int VertexStageCoordOffset(int stage, GrVertexLayout vertexLayout);
-
- /**
- * Helper function to compute the offset of the color in a vertex
- * @return offset of color in vertex layout or -1 if the
- * layout has no color.
- */
- static int VertexColorOffset(GrVertexLayout vertexLayout);
-
- /**
- * Helper function to determine if vertex layout contains explicit texture
- * coordinates of some index.
- *
- * @param coordIndex the tex coord index to query
- * @param vertexLayout layout to query
- *
- * @return true if vertex specifies texture coordinates for the index,
- * false otherwise.
- */
- static bool VertexUsesTexCoordIdx(int coordIndex,
- GrVertexLayout vertexLayout);
-
- /**
- * Helper function to determine if vertex layout contains either explicit or
- * implicit texture coordinates for a stage.
- *
- * @param stage the stage to query
- * @param vertexLayout layout to query
- *
- * @return true if vertex specifies texture coordinates for the stage,
- * false otherwise.
- */
- static bool VertexUsesStage(int stage, GrVertexLayout vertexLayout);
-
- /**
- * Helper function to compute the size of each vertex and the offsets of
- * texture coordinates and color. Determines tex coord offsets by tex coord
- * index rather than by stage. (Each stage can be mapped to any t.c. index
- * by StageTexCoordVertexLayoutBit.)
- *
- * @param vertexLayout the layout to query
- * @param texCoordOffsetsByIdx after return it is the offset of each
- * tex coord index in the vertex or -1 if
- * index isn't used.
- * @return size of a single vertex
- */
- static int VertexSizeAndOffsetsByIdx(GrVertexLayout vertexLayout,
- int texCoordOffsetsByIdx[kMaxTexCoords],
- int *colorOffset);
-
- /**
- * Helper function to compute the size of each vertex and the offsets of
- * texture coordinates and color. Determines tex coord offsets by stage
- * rather than by index. (Each stage can be mapped to any t.c. index
- * by StageTexCoordVertexLayoutBit.) If a stage uses positions for
- * tex coords then that stage's offset will be 0 (positions are always at 0).
- *
- * @param vertexLayout the layout to query
- * @param texCoordOffsetsByStage after return it is the offset of each
- * tex coord index in the vertex or -1 if
- * index isn't used.
- * @return size of a single vertex
- */
- static int VertexSizeAndOffsetsByStage(GrVertexLayout vertexLayout,
- int texCoordOffsetsByStage[kNumStages],
- int *colorOffset);
-
- /**
- * Accessing positions, texture coords, or colors, of a vertex within an
- * array is a hassle involving casts and simple math. These helpers exist
- * to keep GrDrawTarget clients' code a bit nicer looking.
- */
-
- /**
- * Gets a pointer to a GrPoint of a vertex's position or texture
- * coordinate.
- * @param vertices the vetex array
- * @param vertexIndex the index of the vertex in the array
- * @param vertexSize the size of each vertex in the array
- * @param offset the offset in bytes of the vertex component.
- * Defaults to zero (corresponding to vertex position)
- * @return pointer to the vertex component as a GrPoint
- */
- static GrPoint* GetVertexPoint(void* vertices,
- int vertexIndex,
- int vertexSize,
- int offset = 0) {
- intptr_t start = GrTCast<intptr_t>(vertices);
- return GrTCast<GrPoint*>(start + offset +
- vertexIndex * vertexSize);
- }
- static const GrPoint* GetVertexPoint(const void* vertices,
- int vertexIndex,
- int vertexSize,
- int offset = 0) {
- intptr_t start = GrTCast<intptr_t>(vertices);
- return GrTCast<const GrPoint*>(start + offset +
- vertexIndex * vertexSize);
- }
-
- /**
- * Gets a pointer to a GrColor inside a vertex within a vertex array.
- * @param vertices the vetex array
- * @param vertexIndex the index of the vertex in the array
- * @param vertexSize the size of each vertex in the array
- * @param offset the offset in bytes of the vertex color
- * @return pointer to the vertex component as a GrColor
- */
- static GrColor* GetVertexColor(void* vertices,
- int vertexIndex,
- int vertexSize,
- int offset) {
- intptr_t start = GrTCast<intptr_t>(vertices);
- return GrTCast<GrColor*>(start + offset +
- vertexIndex * vertexSize);
- }
- static const GrColor* GetVertexColor(const void* vertices,
- int vertexIndex,
- int vertexSize,
- int offset) {
- const intptr_t start = GrTCast<intptr_t>(vertices);
- return GrTCast<const GrColor*>(start + offset +
- vertexIndex * vertexSize);
- }
-
- static void VertexLayoutUnitTest();
-
-protected:
-
- enum GeometrySrcType {
- kNone_GeometrySrcType, //<! src has not been specified
- kReserved_GeometrySrcType, //<! src was set using reserve*Space
- kArray_GeometrySrcType, //<! src was set using set*SourceToArray
- kBuffer_GeometrySrcType //<! src was set using set*SourceToBuffer
- };
-
- struct GeometrySrcState {
- GeometrySrcType fVertexSrc;
- union {
- // valid if src type is buffer
- const GrVertexBuffer* fVertexBuffer;
- // valid if src type is reserved or array
- int fVertexCount;
- };
-
- GeometrySrcType fIndexSrc;
- union {
- // valid if src type is buffer
- const GrIndexBuffer* fIndexBuffer;
- // valid if src type is reserved or array
- int fIndexCount;
- };
-
- GrVertexLayout fVertexLayout;
- };
-
- // given a vertex layout and a draw state, will a stage be used?
- static bool StageWillBeUsed(int stage, GrVertexLayout layout,
- const DrState& state) {
- return NULL != state.fTextures[stage] && VertexUsesStage(stage, layout);
- }
-
- bool isStageEnabled(int stage) const {
- return StageWillBeUsed(stage, this->getGeomSrc().fVertexLayout,
- fCurrDrawState);
- }
-
- // Helpers for GrDrawTarget subclasses that won't have private access to
- // SavedDrawState but need to peek at the state values.
- static DrState& accessSavedDrawState(SavedDrawState& sds)
- { return sds.fState; }
- static const DrState& accessSavedDrawState(const SavedDrawState& sds)
- { return sds.fState; }
-
- // implemented by subclass to allocate space for reserved geom
- virtual bool onReserveVertexSpace(GrVertexLayout vertexLayout,
- int vertexCount,
- void** vertices) = 0;
- virtual bool onReserveIndexSpace(int indexCount, void** indices) = 0;
- // implemented by subclass to handle release of reserved geom space
- virtual void releaseReservedVertexSpace() = 0;
- virtual void releaseReservedIndexSpace() = 0;
- // subclass must consume array contents when set
- virtual void onSetVertexSourceToArray(const void* vertexArray,
- int vertexCount) = 0;
- virtual void onSetIndexSourceToArray(const void* indexArray,
- int indexCount) = 0;
- // subclass is notified that geom source will be set away from an array
- virtual void releaseVertexArray() = 0;
- virtual void releaseIndexArray() = 0;
- // subclass overrides to be notified just before geo src state
- // is pushed/popped.
- virtual void geometrySourceWillPush() = 0;
- virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) = 0;
- // subclass called to perform drawing
- virtual void onDrawIndexed(GrPrimitiveType type,
- int startVertex,
- int startIndex,
- int vertexCount,
- int indexCount) = 0;
- virtual void onDrawNonIndexed(GrPrimitiveType type,
- int startVertex,
- int vertexCount) = 0;
- // subclass overrides to be notified when clip is set. Must call
- // INHERITED::clipwillBeSet
- virtual void clipWillBeSet(const GrClip& clip);
-
- // Helpers for drawRect, protected so subclasses that override drawRect
- // can use them.
- static GrVertexLayout GetRectVertexLayout(StageBitfield stageEnableBitfield,
- const GrRect* srcRects[]);
-
- static void SetRectVertices(const GrRect& rect,
- const GrMatrix* matrix,
- const GrRect* srcRects[],
- const GrMatrix* srcMatrices[],
- GrVertexLayout layout,
- void* vertices);
-
- // accessor for derived classes
- const GeometrySrcState& getGeomSrc() const {
- return fGeoSrcStateStack.back();
- }
-
- GrClip fClip;
-
- DrState fCurrDrawState;
-
-private:
- // called when setting a new vert/idx source to unref prev vb/ib
- void releasePreviousVertexSource();
- void releasePreviousIndexSource();
-
- enum {
- kPreallocGeoSrcStateStackCnt = 4,
- };
- GrAlignedSTStorage<kPreallocGeoSrcStateStackCnt,
- GeometrySrcState>
- fGeoSrcStateStackStorage;
- GrTArray<GeometrySrcState, true> fGeoSrcStateStack;
-
-};
-
-#endif
GrGpu::~GrGpu() {
this->releaseResources();
- GrSafeUnref(fDefaultPathRenderer);
- GrSafeUnref(fClientPathRenderer);
}
void GrGpu::abandonResources() {
+++ /dev/null
-
-/*
- * 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 GrPathRenderer_DEFINED
-#define GrPathRenderer_DEFINED
-
-#include "GrDrawTarget.h"
-#include "SkTemplates.h"
-
-class SkPath;
-struct GrPoint;
-
-/**
- * Base class for drawing paths into a GrDrawTarget.
- * Paths may be drawn multiple times as when tiling for supersampling. The
- * calls on GrPathRenderer to draw a path will look like this:
- *
- * pr->setPath(target, path, fill, translate); // sets the path to draw
- * pr->drawPath(...); // draw the path
- * pr->drawPath(...);
- * ...
- * pr->clearPath(); // finished with the path
- */
-class GR_API GrPathRenderer : public GrRefCnt {
-public:
- GrPathRenderer(void);
- /**
- * Returns true if this path renderer is able to render the path.
- * Returning false allows the caller to fallback to another path renderer.
- *
- * @param path The path to draw
- * @param fill The fill rule to use
- *
- * @return true if the path can be drawn by this object, false otherwise.
- */
- virtual bool canDrawPath(const SkPath& path, GrPathFill fill) const = 0;
-
- /**
- * For complex clips Gr uses the stencil buffer. The path renderer must be
- * able to render paths into the stencil buffer. However, the path renderer
- * itself may require the stencil buffer to resolve the path fill rule.
- * This function queries whether the path render needs its own stencil
- * pass. If this returns false then drawPath() should not modify the
- * the target's stencil settings but use those already set on target. The
- * target is passed as a param in case the answer depends upon draw state.
- * The view matrix and render target set on the draw target may change
- * before setPath/drawPath is called and so shouldn't be considered.
- *
- * @param target target that the path will be rendered to
- * @param path the path that will be drawn
- * @param fill the fill rule that will be used, will never be an inverse
- * rule.
- *
- * @return false if this path renderer can generate interior-only fragments
- * without changing the stencil settings on the target. If it
- * returns true the drawPathToStencil will be used when rendering
- * clips.
- */
- virtual bool requiresStencilPass(const GrDrawTarget* target,
- const SkPath& path,
- GrPathFill fill) const { return false; }
-
- /**
- * @return true if the path renderer can perform anti-aliasing (aside from
- * having FSAA enabled for a render target). Target is provided to
- * communicate the draw state (blend mode, stage settings, etc).
- */
- virtual bool supportsAA(GrDrawTarget* target,
- const SkPath& path,
- GrPathFill fill) { return false; }
-
- /**
- * Sets the path to render and target to render into. All calls to drawPath
- * and drawPathToStencil must occur between setPath and clearPath. The
- * path cannot be modified externally between setPath and clearPath. The
- * path may be drawn several times (e.g. tiled supersampler). The target's
- * state may change between setPath and drawPath* calls. However, if the
- * path renderer specified vertices/indices during setPath or drawPath*
- * they will still be set at subsequent drawPath* calls until the next
- * clearPath. The target's draw state may change between drawPath* calls
- * so if the subclass does any caching of tesselation, etc. then it must
- * validate that target parameters that guided the decisions still hold.
- *
- * @param target the target to draw into.
- * @param path the path to draw.
- * @param fill the fill rule to apply.
- * @param translate optional additional translation to apply to
- * the path. NULL means (0,0).
- */
- void setPath(GrDrawTarget* target,
- const SkPath* path,
- GrPathFill fill,
- const GrPoint* translate);
-
- /**
- * Notifies path renderer that path set in setPath is no longer in use.
- */
- void clearPath();
-
- /**
- * Draws the path into the draw target. If requiresStencilBuffer returned
- * false then the target may be setup for stencil rendering (since the
- * path renderer didn't claim that it needs to use the stencil internally).
- *
- * Only called between setPath / clearPath.
- *
- * @param stages bitfield that indicates which stages are
- * in use. All enabled stages expect positions
- * as texture coordinates. The path renderer
- * use the remaining stages for its path
- * filling algorithm.
- */
- virtual void drawPath(GrDrawTarget::StageBitfield stages) = 0;
-
- /**
- * Draws the path to the stencil buffer. Assume the writable stencil bits
- * are already initialized to zero. Fill will always be either
- * kWinding_PathFill or kEvenOdd_PathFill.
- *
- * Only called if requiresStencilPass returns true for the same combo of
- * target, path, and fill. Never called with an inverse fill.
- *
- * The default implementation assumes the path filling algorithm doesn't
- * require a separate stencil pass and so crashes.
- *
- * Only called between setPath / clearPath.
- */
- virtual void drawPathToStencil() {
- GrCrash("Unexpected call to drawPathToStencil.");
- }
-
- /**
- * This is called to install a custom path renderer in every GrContext at
- * create time. The default implementation in GrCreatePathRenderer_none.cpp
- * returns NULL. Link against another implementation to install your own.
- */
- static GrPathRenderer* CreatePathRenderer();
-
- /**
- * Multiply curve tolerance by the given value, increasing or decreasing
- * the maximum error permitted in tesselating curves with short straight
- * line segments.
- */
- void scaleCurveTolerance(GrScalar multiplier) {
- GrAssert(multiplier > 0);
- fCurveTolerance = SkScalarMul(fCurveTolerance, multiplier);
- }
-
- /**
- * Helper that sets a path and automatically remove it in destructor.
- */
- class AutoClearPath {
- public:
- AutoClearPath() {
- fPathRenderer = NULL;
- }
- AutoClearPath(GrPathRenderer* pr,
- GrDrawTarget* target,
- const SkPath* path,
- GrPathFill fill,
- const GrPoint* translate) {
- GrAssert(NULL != pr);
- pr->setPath(target, path, fill, translate);
- fPathRenderer = pr;
- }
- void set(GrPathRenderer* pr,
- GrDrawTarget* target,
- const SkPath* path,
- GrPathFill fill,
- const GrPoint* translate) {
- if (NULL != fPathRenderer) {
- fPathRenderer->clearPath();
- }
- GrAssert(NULL != pr);
- pr->setPath(target, path, fill, translate);
- fPathRenderer = pr;
- }
- ~AutoClearPath() {
- if (NULL != fPathRenderer) {
- fPathRenderer->clearPath();
- }
- }
- private:
- GrPathRenderer* fPathRenderer;
- };
-
-protected:
-
- // subclass can override these to be notified just after a path is set
- // and just before the path is cleared.
- virtual void pathWasSet() {}
- virtual void pathWillClear() {}
-
- GrScalar fCurveTolerance;
- const SkPath* fPath;
- GrDrawTarget* fTarget;
- GrPathFill fFill;
- GrPoint fTranslate;
-
-private:
-
- typedef GrRefCnt INHERITED;
-};
-
-/**
- * Subclass that renders the path using the stencil buffer to resolve fill
- * rules (e.g. winding, even-odd)
- */
-class GR_API GrDefaultPathRenderer : public GrPathRenderer {
-public:
- GrDefaultPathRenderer(bool separateStencilSupport,
- bool stencilWrapOpsSupport);
-
- virtual bool canDrawPath(const SkPath& path,
- GrPathFill fill) const { return true; }
-
- virtual bool requiresStencilPass(const GrDrawTarget* target,
- const SkPath& path,
- GrPathFill fill) const;
-
- virtual void drawPath(GrDrawTarget::StageBitfield stages);
- virtual void drawPathToStencil();
-
-protected:
- virtual void pathWillClear();
-
-private:
-
- void onDrawPath(GrDrawTarget::StageBitfield stages, bool stencilOnly);
-
- bool createGeom(GrScalar srcSpaceTol,
- GrDrawTarget::StageBitfield stages);
-
- bool fSeparateStencil;
- bool fStencilWrapOps;
-
- int fSubpathCount;
- SkAutoSTMalloc<8, uint16_t> fSubpathVertCount;
- int fIndexCnt;
- int fVertexCnt;
- GrScalar fPreviousSrcTol;
- GrDrawTarget::StageBitfield fPreviousStages;
- GrPrimitiveType fPrimitiveType;
- bool fUseIndexedDraw;
-
- typedef GrPathRenderer INHERITED;
-};
-
-#endif
-
'../gpu/include/GrColor.h',
'../gpu/include/GrConfig.h',
'../gpu/include/GrContext.h',
+ '../gpu/include/GrDrawTarget.h',
'../gpu/include/GrFontScaler.h',
'../gpu/include/GrGLConfig.h',
'../gpu/include/GrGLConfig_chrome.h',
'../gpu/include/GrNoncopyable.h',
'../gpu/include/GrPaint.h',
'../gpu/include/GrPath.h',
+ '../gpu/include/GrPathRenderer.h',
'../gpu/include/GrPathSink.h',
'../gpu/include/GrPlotMgr.h',
'../gpu/include/GrPoint.h',
'../gpu/src/GrContext.cpp',
'../gpu/src/GrCreatePathRenderer_none.cpp',
'../gpu/src/GrDrawTarget.cpp',
- '../gpu/src/GrDrawTarget.h',
'../gpu/src/GrGeometryBuffer.h',
'../gpu/src/GrGLDefaultInterface_none.cpp',
'../gpu/src/GrGLIndexBuffer.cpp',
'../gpu/src/GrMatrix.cpp',
'../gpu/src/GrMemory.cpp',
'../gpu/src/GrPathRenderer.cpp',
- '../gpu/src/GrPathRenderer.h',
'../gpu/src/GrPathUtils.cpp',
'../gpu/src/GrPathUtils.h',
'../gpu/src/GrRectanizer.cpp',
#include "SkTypeface.h"
#include "GrGLInterface.h"
-#include "GrRenderTarget.h"
#include "SkPDFDevice.h"
#include "SkPDFDocument.h"
projects / platform / upstream / libSkiaSharp.git / commitdiff