Fixed r2125. Identical change but also moves GrTesselatedPathRenderer.h to src dir.
Verbal SGTM from Tom who reviewed the original version at: http://codereview.appspot.com/4894050/
git-svn-id: http://skia.googlecode.com/svn/trunk@2129 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/gpu/include/GrContext.h b/gpu/include/GrContext.h
index 0671701..44e0c04 100644
--- a/gpu/include/GrContext.h
+++ b/gpu/include/GrContext.h
@@ -12,16 +12,20 @@
#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;
@@ -551,7 +555,7 @@
GrFontCache* fFontCache;
GrPathRenderer* fCustomPathRenderer;
- GrDefaultPathRenderer fDefaultPathRenderer;
+ GrDefaultPathRenderer* fDefaultPathRenderer;
GrVertexBufferAllocPool* fDrawBufferVBAllocPool;
GrIndexBufferAllocPool* fDrawBufferIBAllocPool;
diff --git a/gpu/include/GrDrawTarget.h b/gpu/include/GrDrawTarget.h
deleted file mode 100644
index 8196beb..0000000
--- a/gpu/include/GrDrawTarget.h
+++ /dev/null
@@ -1,1260 +0,0 @@
-
-/*
- * 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
diff --git a/gpu/include/GrPathRenderer.h b/gpu/include/GrPathRenderer.h
deleted file mode 100644
index 67c3a93..0000000
--- a/gpu/include/GrPathRenderer.h
+++ /dev/null
@@ -1,256 +0,0 @@
-
-/*
- * 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
-
diff --git a/gpu/include/GrTesselatedPathRenderer.h b/gpu/include/GrTesselatedPathRenderer.h
deleted file mode 100644
index 5791be6..0000000
--- a/gpu/include/GrTesselatedPathRenderer.h
+++ /dev/null
@@ -1,32 +0,0 @@
-
-/*
- * 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 GrTesselatedPathRenderer_DEFINED
-#define GrTesselatedPathRenderer_DEFINED
-
-#include "GrPathRenderer.h"
-
-class GrTesselatedPathRenderer : public GrPathRenderer {
-public:
- GrTesselatedPathRenderer();
-
- virtual void drawPath(GrDrawTarget::StageBitfield stages);
- virtual bool canDrawPath(const GrPath& path,
- GrPathFill fill) const;
-
- virtual bool requiresStencilPass(const GrDrawTarget* target,
- const GrPath& path,
- GrPathFill fill) const { return false; }
- virtual void drawPathToStencil();
- virtual bool supportsAA(GrDrawTarget* target,
- const GrPath& path,
- GrPathFill fill);
-};
-
-#endif