| /* |
| * 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 GrDrawState_DEFINED |
| #define GrDrawState_DEFINED |
| |
| #include "GrBackendEffectFactory.h" |
| #include "GrColor.h" |
| #include "GrEffectStage.h" |
| #include "GrPaint.h" |
| #include "GrPoint.h" |
| #include "GrRefCnt.h" |
| #include "GrRenderTarget.h" |
| #include "GrStencil.h" |
| #include "GrTemplates.h" |
| #include "GrTexture.h" |
| #include "GrTypesPriv.h" |
| #include "effects/GrSimpleTextureEffect.h" |
| |
| #include "SkMatrix.h" |
| #include "SkXfermode.h" |
| |
| class GrDrawState : public GrRefCnt { |
| public: |
| SK_DECLARE_INST_COUNT(GrDrawState) |
| |
| GrDrawState() { |
| GR_DEBUGCODE(fBlockEffectRemovalCnt = 0;) |
| this->reset(); |
| } |
| |
| GrDrawState(const SkMatrix& initialViewMatrix) { |
| GR_DEBUGCODE(fBlockEffectRemovalCnt = 0;) |
| this->reset(initialViewMatrix); |
| } |
| |
| /** |
| * Copies another draw state. |
| **/ |
| GrDrawState(const GrDrawState& state) : INHERITED() { |
| GR_DEBUGCODE(fBlockEffectRemovalCnt = 0;) |
| *this = state; |
| } |
| |
| /** |
| * Copies another draw state with a preconcat to the view matrix. |
| **/ |
| GrDrawState(const GrDrawState& state, const SkMatrix& preConcatMatrix) { |
| GR_DEBUGCODE(fBlockEffectRemovalCnt = 0;) |
| *this = state; |
| if (!preConcatMatrix.isIdentity()) { |
| for (int i = 0; i < fColorStages.count(); ++i) { |
| fColorStages[i].localCoordChange(preConcatMatrix); |
| } |
| for (int i = 0; i < fCoverageStages.count(); ++i) { |
| fCoverageStages[i].localCoordChange(preConcatMatrix); |
| } |
| } |
| } |
| |
| virtual ~GrDrawState() { GrAssert(0 == fBlockEffectRemovalCnt); } |
| |
| /** |
| * Resets to the default state. GrEffects will be removed from all stages. |
| */ |
| void reset() { this->onReset(NULL); } |
| |
| void reset(const SkMatrix& initialViewMatrix) { this->onReset(&initialViewMatrix); } |
| |
| /** |
| * Initializes the GrDrawState based on a GrPaint, view matrix and render target. Note that |
| * GrDrawState encompasses more than GrPaint. Aspects of GrDrawState that have no GrPaint |
| * equivalents are set to default values. Clipping will be enabled. |
| */ |
| void setFromPaint(const GrPaint& , const SkMatrix& viewMatrix, GrRenderTarget*); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| /// @name Vertex Attributes |
| //// |
| |
| enum { |
| kMaxVertexAttribCnt = kLast_GrVertexAttribBinding + 4, |
| }; |
| |
| /** |
| * The format of vertices is represented as an array of GrVertexAttribs, with each representing |
| * the type of the attribute, its offset, and semantic binding (see GrVertexAttrib in |
| * GrTypesPriv.h). |
| * |
| * The mapping of attributes with kEffect bindings to GrEffect inputs is specified when |
| * setEffect is called. |
| */ |
| |
| /** |
| * Sets vertex attributes for next draw. The object driving the templatization |
| * should be a global GrVertexAttrib array that is never changed. |
| */ |
| template <const GrVertexAttrib A[]> void setVertexAttribs(int count) { |
| this->setVertexAttribs(A, count); |
| } |
| |
| const GrVertexAttrib* getVertexAttribs() const { return fCommon.fVAPtr; } |
| int getVertexAttribCount() const { return fCommon.fVACount; } |
| |
| size_t getVertexSize() const; |
| |
| /** |
| * Sets default vertex attributes for next draw. The default is a single attribute: |
| * {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribType} |
| */ |
| void setDefaultVertexAttribs(); |
| |
| /** |
| * Getters for index into getVertexAttribs() for particular bindings. -1 is returned if the |
| * binding does not appear in the current attribs. These bindings should appear only once in |
| * the attrib array. |
| */ |
| |
| int positionAttributeIndex() const { |
| return fCommon.fFixedFunctionVertexAttribIndices[kPosition_GrVertexAttribBinding]; |
| } |
| int localCoordAttributeIndex() const { |
| return fCommon.fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttribBinding]; |
| } |
| int colorVertexAttributeIndex() const { |
| return fCommon.fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBinding]; |
| } |
| int coverageVertexAttributeIndex() const { |
| return fCommon.fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribBinding]; |
| } |
| |
| bool hasLocalCoordAttribute() const { |
| return -1 != fCommon.fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttribBinding]; |
| } |
| bool hasColorVertexAttribute() const { |
| return -1 != fCommon.fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBinding]; |
| } |
| bool hasCoverageVertexAttribute() const { |
| return -1 != fCommon.fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribBinding]; |
| } |
| |
| bool validateVertexAttribs() const; |
| |
| /** |
| * Helper to save/restore vertex attribs |
| */ |
| class AutoVertexAttribRestore { |
| public: |
| AutoVertexAttribRestore(GrDrawState* drawState) { |
| GrAssert(NULL != drawState); |
| fDrawState = drawState; |
| fVAPtr = drawState->fCommon.fVAPtr; |
| fVACount = drawState->fCommon.fVACount; |
| fDrawState->setDefaultVertexAttribs(); |
| } |
| |
| ~AutoVertexAttribRestore(){ |
| fDrawState->fCommon.fVAPtr = fVAPtr; |
| fDrawState->fCommon.fVACount = fVACount; |
| } |
| |
| private: |
| GrDrawState* fDrawState; |
| const GrVertexAttrib* fVAPtr; |
| int fVACount; |
| }; |
| |
| /** |
| * Accessing positions, local 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 vertex 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); |
| } |
| |
| /// @} |
| |
| /** |
| * Determines whether src alpha is guaranteed to be one for all src pixels |
| */ |
| bool srcAlphaWillBeOne() const; |
| |
| /** |
| * Determines whether the output coverage is guaranteed to be one for all pixels hit by a draw. |
| */ |
| bool hasSolidCoverage() const; |
| |
| /// @} |
| |
| /////////////////////////////////////////////////////////////////////////// |
| /// @name Color |
| //// |
| |
| /** |
| * Sets color for next draw to a premultiplied-alpha color. |
| * |
| * @param color the color to set. |
| */ |
| void setColor(GrColor color) { fCommon.fColor = color; } |
| |
| GrColor getColor() const { return fCommon.fColor; } |
| |
| /** |
| * 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 a) { |
| this->setColor((a << 24) | (a << 16) | (a << 8) | a); |
| } |
| |
| /** |
| * Add a color filter that can be represented by a color and a mode. Applied |
| * after color-computing effect stages. |
| */ |
| void setColorFilter(GrColor c, SkXfermode::Mode mode) { |
| fCommon.fColorFilterColor = c; |
| fCommon.fColorFilterMode = mode; |
| } |
| |
| GrColor getColorFilterColor() const { return fCommon.fColorFilterColor; } |
| SkXfermode::Mode getColorFilterMode() const { return fCommon.fColorFilterMode; } |
| |
| /** |
| * Constructor sets the color to be 'color' which is undone by the destructor. |
| */ |
| class AutoColorRestore : public ::GrNoncopyable { |
| public: |
| AutoColorRestore() : fDrawState(NULL), fOldColor(0) {} |
| |
| AutoColorRestore(GrDrawState* drawState, GrColor color) { |
| fDrawState = NULL; |
| this->set(drawState, color); |
| } |
| |
| void reset() { |
| if (NULL != fDrawState) { |
| fDrawState->setColor(fOldColor); |
| fDrawState = NULL; |
| } |
| } |
| |
| void set(GrDrawState* drawState, GrColor color) { |
| this->reset(); |
| fDrawState = drawState; |
| fOldColor = fDrawState->getColor(); |
| fDrawState->setColor(color); |
| } |
| |
| ~AutoColorRestore() { this->reset(); } |
| private: |
| GrDrawState* fDrawState; |
| GrColor fOldColor; |
| }; |
| |
| /// @} |
| |
| /////////////////////////////////////////////////////////////////////////// |
| /// @name Coverage |
| //// |
| |
| /** |
| * Sets a constant fractional coverage to be applied to the draw. The |
| * initial value (after construction or reset()) is 0xff. The constant |
| * coverage is ignored when per-vertex coverage is provided. |
| */ |
| void setCoverage(uint8_t coverage) { |
| fCommon.fCoverage = GrColorPackRGBA(coverage, coverage, coverage, coverage); |
| } |
| |
| /** |
| * Version of above that specifies 4 channel per-vertex color. The value |
| * should be premultiplied. |
| */ |
| void setCoverage4(GrColor coverage) { |
| fCommon.fCoverage = coverage; |
| } |
| |
| GrColor getCoverage() const { |
| return fCommon.fCoverage; |
| } |
| |
| /// @} |
| |
| /////////////////////////////////////////////////////////////////////////// |
| /// @name Effect Stages |
| /// Each stage hosts a GrEffect. The effect produces an output color or coverage in the fragment |
| /// shader. Its inputs are the output from the previous stage as well as some variables |
| /// available to it in the fragment and vertex shader (e.g. the vertex position, the dst color, |
| /// the fragment position, local coordinates). |
| /// |
| /// The stages are divided into two sets, color-computing and coverage-computing. The final |
| /// color stage produces the final pixel color. The coverage-computing stages function exactly |
| /// as the color-computing but the output of the final coverage stage is treated as a fractional |
| /// pixel coverage rather than as input to the src/dst color blend step. |
| /// |
| /// The input color to the first color-stage is either the constant color or interpolated |
| /// per-vertex colors. The input to the first coverage stage is either a constant coverage |
| /// (usually full-coverage) or interpolated per-vertex coverage. |
| /// |
| /// See the documentation of kCoverageDrawing_StateBit for information about disabling the |
| /// the color / coverage distinction. |
| //// |
| |
| const GrEffectRef* addColorEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) { |
| GrAssert(NULL != effect); |
| SkNEW_APPEND_TO_TARRAY(&fColorStages, GrEffectStage, (effect, attr0, attr1)); |
| return effect; |
| } |
| |
| const GrEffectRef* addCoverageEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) { |
| GrAssert(NULL != effect); |
| SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrEffectStage, (effect, attr0, attr1)); |
| return effect; |
| } |
| |
| /** |
| * Creates a GrSimpleTextureEffect that uses local coords as texture coordinates. |
| */ |
| void addColorTextureEffect(GrTexture* texture, const SkMatrix& matrix) { |
| GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix); |
| this->addColorEffect(effect)->unref(); |
| } |
| |
| void addCoverageTextureEffect(GrTexture* texture, const SkMatrix& matrix) { |
| GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix); |
| this->addCoverageEffect(effect)->unref(); |
| } |
| |
| void addColorTextureEffect(GrTexture* texture, |
| const SkMatrix& matrix, |
| const GrTextureParams& params) { |
| GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params); |
| this->addColorEffect(effect)->unref(); |
| } |
| |
| void addCoverageTextureEffect(GrTexture* texture, |
| const SkMatrix& matrix, |
| const GrTextureParams& params) { |
| GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params); |
| this->addCoverageEffect(effect)->unref(); |
| } |
| |
| /** |
| * When this object is destroyed it will remove any effects from the draw state that were added |
| * after its constructor. |
| */ |
| class AutoRestoreEffects : public ::GrNoncopyable { |
| public: |
| AutoRestoreEffects() : fDrawState(NULL), fColorEffectCnt(0), fCoverageEffectCnt(0) {} |
| |
| AutoRestoreEffects(GrDrawState* ds) : fDrawState(NULL), fColorEffectCnt(0), fCoverageEffectCnt(0) { |
| this->set(ds); |
| } |
| |
| ~AutoRestoreEffects() { this->set(NULL); } |
| |
| void set(GrDrawState* ds) { |
| if (NULL != fDrawState) { |
| int n = fDrawState->fColorStages.count() - fColorEffectCnt; |
| GrAssert(n >= 0); |
| fDrawState->fColorStages.pop_back_n(n); |
| n = fDrawState->fCoverageStages.count() - fCoverageEffectCnt; |
| GrAssert(n >= 0); |
| fDrawState->fCoverageStages.pop_back_n(n); |
| GR_DEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;) |
| } |
| fDrawState = ds; |
| if (NULL != ds) { |
| fColorEffectCnt = ds->fColorStages.count(); |
| fCoverageEffectCnt = ds->fCoverageStages.count(); |
| GR_DEBUGCODE(++ds->fBlockEffectRemovalCnt;) |
| } |
| } |
| |
| private: |
| GrDrawState* fDrawState; |
| int fColorEffectCnt; |
| int fCoverageEffectCnt; |
| }; |
| |
| int numColorStages() const { return fColorStages.count(); } |
| int numCoverageStages() const { return fCoverageStages.count(); } |
| int numTotalStages() const { return this->numColorStages() + this->numCoverageStages(); } |
| |
| const GrEffectStage& getColorStage(int stageIdx) const { return fColorStages[stageIdx]; } |
| const GrEffectStage& getCoverageStage(int stageIdx) const { return fCoverageStages[stageIdx]; } |
| |
| /** |
| * Checks whether any of the effects will read the dst pixel color. |
| */ |
| bool willEffectReadDstColor() const; |
| |
| /// @} |
| |
| /////////////////////////////////////////////////////////////////////////// |
| /// @name Blending |
| //// |
| |
| /** |
| * Sets the blending function coefficients. |
| * |
| * 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 coefficient applied to the src color. |
| * @param dstCoef coefficient applied to the dst color. |
| */ |
| void setBlendFunc(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff) { |
| fCommon.fSrcBlend = srcCoeff; |
| fCommon.fDstBlend = dstCoeff; |
| #if GR_DEBUG |
| switch (dstCoeff) { |
| case kDC_GrBlendCoeff: |
| case kIDC_GrBlendCoeff: |
| case kDA_GrBlendCoeff: |
| case kIDA_GrBlendCoeff: |
| GrPrintf("Unexpected dst blend coeff. Won't work correctly with" |
| "coverage stages.\n"); |
| break; |
| default: |
| break; |
| } |
| switch (srcCoeff) { |
| case kSC_GrBlendCoeff: |
| case kISC_GrBlendCoeff: |
| case kSA_GrBlendCoeff: |
| case kISA_GrBlendCoeff: |
| GrPrintf("Unexpected src blend coeff. Won't work correctly with" |
| "coverage stages.\n"); |
| break; |
| default: |
| break; |
| } |
| #endif |
| } |
| |
| GrBlendCoeff getSrcBlendCoeff() const { return fCommon.fSrcBlend; } |
| GrBlendCoeff getDstBlendCoeff() const { return fCommon.fDstBlend; } |
| |
| void getDstBlendCoeff(GrBlendCoeff* srcBlendCoeff, |
| GrBlendCoeff* dstBlendCoeff) const { |
| *srcBlendCoeff = fCommon.fSrcBlend; |
| *dstBlendCoeff = fCommon.fDstBlend; |
| } |
| |
| /** |
| * Sets the blending function constant referenced by the following blending |
| * coefficients: |
| * kConstC_GrBlendCoeff |
| * kIConstC_GrBlendCoeff |
| * kConstA_GrBlendCoeff |
| * kIConstA_GrBlendCoeff |
| * |
| * @param constant the constant to set |
| */ |
| void setBlendConstant(GrColor constant) { fCommon.fBlendConstant = constant; } |
| |
| /** |
| * Retrieves the last value set by setBlendConstant() |
| * @return the blending constant value |
| */ |
| GrColor getBlendConstant() const { return fCommon.fBlendConstant; } |
| |
| /** |
| * Determines whether multiplying the computed per-pixel color by the pixel's fractional |
| * coverage before the blend will give the correct final destination color. In general it |
| * will not as coverage is applied after blending. |
| */ |
| bool canTweakAlphaForCoverage() const; |
| |
| /** |
| * Optimizations for blending / coverage to that can be applied based on the current state. |
| */ |
| enum BlendOptFlags { |
| /** |
| * No optimization |
| */ |
| kNone_BlendOpt = 0, |
| /** |
| * Don't draw at all |
| */ |
| kSkipDraw_BlendOptFlag = 0x1, |
| /** |
| * Emit the src color, disable HW blending (replace dst with src) |
| */ |
| kDisableBlend_BlendOptFlag = 0x2, |
| /** |
| * The coverage value does not have to be computed separately from alpha, the the output |
| * color can be the modulation of the two. |
| */ |
| kCoverageAsAlpha_BlendOptFlag = 0x4, |
| /** |
| * Instead of emitting a src color, emit coverage in the alpha channel and r,g,b are |
| * "don't cares". |
| */ |
| kEmitCoverage_BlendOptFlag = 0x8, |
| /** |
| * Emit transparent black instead of the src color, no need to compute coverage. |
| */ |
| kEmitTransBlack_BlendOptFlag = 0x10, |
| }; |
| GR_DECL_BITFIELD_OPS_FRIENDS(BlendOptFlags); |
| |
| /** |
| * Determines what optimizations can be applied based on the blend. The coefficients may have |
| * to be tweaked in order for the optimization to work. srcCoeff and dstCoeff are optional |
| * params that receive the tweaked coefficients. Normally the function looks at the current |
| * state to see if coverage is enabled. By setting forceCoverage the caller can speculatively |
| * determine the blend optimizations that would be used if there was partial pixel coverage. |
| * |
| * Subclasses of GrDrawTarget that actually draw (as opposed to those that just buffer for |
| * playback) must call this function and respect the flags that replace the output color. |
| */ |
| BlendOptFlags getBlendOpts(bool forceCoverage = false, |
| GrBlendCoeff* srcCoeff = NULL, |
| GrBlendCoeff* dstCoeff = NULL) const; |
| |
| /// @} |
| |
| /////////////////////////////////////////////////////////////////////////// |
| /// @name View Matrix |
| //// |
| |
| /** |
| * Sets the view matrix to identity and updates any installed effects to compensate for the |
| * coord system change. |
| */ |
| bool setIdentityViewMatrix(); |
| |
| /** |
| * Retrieves the current view matrix |
| * @return the current view matrix. |
| */ |
| const SkMatrix& getViewMatrix() const { return fCommon.fViewMatrix; } |
| |
| /** |
| * 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(SkMatrix* matrix) const { |
| // TODO: determine whether we really need to leave matrix unmodified |
| // at call sites when inversion fails. |
| SkMatrix inverse; |
| if (fCommon.fViewMatrix.invert(&inverse)) { |
| if (matrix) { |
| *matrix = inverse; |
| } |
| return true; |
| } |
| return false; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| |
| /** |
| * Preconcats the current view matrix and restores the previous view matrix in the destructor. |
| * Effect matrices are automatically adjusted to compensate and adjusted back in the destructor. |
| */ |
| class AutoViewMatrixRestore : public ::GrNoncopyable { |
| public: |
| AutoViewMatrixRestore() : fDrawState(NULL) {} |
| |
| AutoViewMatrixRestore(GrDrawState* ds, const SkMatrix& preconcatMatrix) { |
| fDrawState = NULL; |
| this->set(ds, preconcatMatrix); |
| } |
| |
| ~AutoViewMatrixRestore() { this->restore(); } |
| |
| /** |
| * Can be called prior to destructor to restore the original matrix. |
| */ |
| void restore(); |
| |
| void set(GrDrawState* drawState, const SkMatrix& preconcatMatrix); |
| |
| /** Sets the draw state's matrix to identity. This can fail because the current view matrix |
| is not invertible. */ |
| bool setIdentity(GrDrawState* drawState); |
| |
| private: |
| void doEffectCoordChanges(const SkMatrix& coordChangeMatrix); |
| |
| GrDrawState* fDrawState; |
| SkMatrix fViewMatrix; |
| int fNumColorStages; |
| SkAutoSTArray<8, GrEffectStage::SavedCoordChange> fSavedCoordChanges; |
| }; |
| |
| /// @} |
| |
| /////////////////////////////////////////////////////////////////////////// |
| /// @name Render Target |
| //// |
| |
| /** |
| * Sets the render-target used at the next drawing call |
| * |
| * @param target The render target to set. |
| */ |
| void setRenderTarget(GrRenderTarget* target) { |
| fRenderTarget.reset(SkSafeRef(target)); |
| } |
| |
| /** |
| * Retrieves the currently set render-target. |
| * |
| * @return The currently set render target. |
| */ |
| const GrRenderTarget* getRenderTarget() const { return fRenderTarget.get(); } |
| GrRenderTarget* getRenderTarget() { return fRenderTarget.get(); } |
| |
| class AutoRenderTargetRestore : public ::GrNoncopyable { |
| public: |
| AutoRenderTargetRestore() : fDrawState(NULL), fSavedTarget(NULL) {} |
| AutoRenderTargetRestore(GrDrawState* ds, GrRenderTarget* newTarget) { |
| fDrawState = NULL; |
| fSavedTarget = NULL; |
| this->set(ds, newTarget); |
| } |
| ~AutoRenderTargetRestore() { this->restore(); } |
| |
| void restore() { |
| if (NULL != fDrawState) { |
| fDrawState->setRenderTarget(fSavedTarget); |
| fDrawState = NULL; |
| } |
| GrSafeSetNull(fSavedTarget); |
| } |
| |
| void set(GrDrawState* ds, GrRenderTarget* newTarget) { |
| this->restore(); |
| |
| if (NULL != ds) { |
| GrAssert(NULL == fSavedTarget); |
| fSavedTarget = ds->getRenderTarget(); |
| SkSafeRef(fSavedTarget); |
| ds->setRenderTarget(newTarget); |
| fDrawState = ds; |
| } |
| } |
| private: |
| GrDrawState* fDrawState; |
| GrRenderTarget* fSavedTarget; |
| }; |
| |
| /// @} |
| |
| /////////////////////////////////////////////////////////////////////////// |
| /// @name Stencil |
| //// |
| |
| /** |
| * 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) { |
| fCommon.fStencilSettings = settings; |
| } |
| |
| /** |
| * Shortcut to disable stencil testing and ops. |
| */ |
| void disableStencil() { |
| fCommon.fStencilSettings.setDisabled(); |
| } |
| |
| const GrStencilSettings& getStencil() const { return fCommon.fStencilSettings; } |
| |
| GrStencilSettings* stencil() { return &fCommon.fStencilSettings; } |
| |
| /// @} |
| |
| /////////////////////////////////////////////////////////////////////////// |
| /// @name State Flags |
| //// |
| |
| /** |
| * Flags that affect rendering. Controlled using enable/disableState(). All |
| * default to disabled. |
| */ |
| enum StateBits { |
| /** |
| * Perform dithering. TODO: Re-evaluate whether we need this bit |
| */ |
| kDither_StateBit = 0x01, |
| /** |
| * Perform HW anti-aliasing. This means either HW FSAA, if supported by the render target, |
| * or smooth-line rendering if a line primitive is drawn and line smoothing is supported by |
| * the 3D API. |
| */ |
| kHWAntialias_StateBit = 0x02, |
| /** |
| * Draws will respect the clip, otherwise the clip is ignored. |
| */ |
| kClip_StateBit = 0x04, |
| /** |
| * Disables writing to the color buffer. Useful when performing stencil |
| * operations. |
| */ |
| kNoColorWrites_StateBit = 0x08, |
| |
| /** |
| * Usually coverage is applied after color blending. The color is blended using the coeffs |
| * specified by setBlendFunc(). The blended color is then combined with dst using coeffs |
| * of src_coverage, 1-src_coverage. Sometimes we are explicitly drawing a coverage mask. In |
| * this case there is no distinction between coverage and color and the caller needs direct |
| * control over the blend coeffs. When set, there will be a single blend step controlled by |
| * setBlendFunc() which will use coverage*color as the src color. |
| */ |
| kCoverageDrawing_StateBit = 0x10, |
| |
| // Users of the class may add additional bits to the vector |
| kDummyStateBit, |
| kLastPublicStateBit = kDummyStateBit-1, |
| }; |
| |
| void resetStateFlags() { |
| fCommon.fFlagBits = 0; |
| } |
| |
| /** |
| * Enable render state settings. |
| * |
| * @param stateBits bitfield of StateBits specifying the states to enable |
| */ |
| void enableState(uint32_t stateBits) { |
| fCommon.fFlagBits |= stateBits; |
| } |
| |
| /** |
| * Disable render state settings. |
| * |
| * @param stateBits bitfield of StateBits specifying the states to disable |
| */ |
| void disableState(uint32_t stateBits) { |
| fCommon.fFlagBits &= ~(stateBits); |
| } |
| |
| /** |
| * Enable or disable stateBits based on a boolean. |
| * |
| * @param stateBits bitfield of StateBits to enable or disable |
| * @param enable if true enable stateBits, otherwise disable |
| */ |
| void setState(uint32_t stateBits, bool enable) { |
| if (enable) { |
| this->enableState(stateBits); |
| } else { |
| this->disableState(stateBits); |
| } |
| } |
| |
| bool isDitherState() const { |
| return 0 != (fCommon.fFlagBits & kDither_StateBit); |
| } |
| |
| bool isHWAntialiasState() const { |
| return 0 != (fCommon.fFlagBits & kHWAntialias_StateBit); |
| } |
| |
| bool isClipState() const { |
| return 0 != (fCommon.fFlagBits & kClip_StateBit); |
| } |
| |
| bool isColorWriteDisabled() const { |
| return 0 != (fCommon.fFlagBits & kNoColorWrites_StateBit); |
| } |
| |
| bool isCoverageDrawing() const { |
| return 0 != (fCommon.fFlagBits & kCoverageDrawing_StateBit); |
| } |
| |
| bool isStateFlagEnabled(uint32_t stateBit) const { |
| return 0 != (stateBit & fCommon.fFlagBits); |
| } |
| |
| /// @} |
| |
| /////////////////////////////////////////////////////////////////////////// |
| /// @name Face Culling |
| //// |
| |
| enum DrawFace { |
| kInvalid_DrawFace = -1, |
| |
| kBoth_DrawFace, |
| kCCW_DrawFace, |
| kCW_DrawFace, |
| }; |
| |
| /** |
| * Controls whether clockwise, counterclockwise, or both faces are drawn. |
| * @param face the face(s) to draw. |
| */ |
| void setDrawFace(DrawFace face) { |
| GrAssert(kInvalid_DrawFace != face); |
| fCommon.fDrawFace = face; |
| } |
| |
| /** |
| * Gets whether the target is drawing clockwise, counterclockwise, |
| * or both faces. |
| * @return the current draw face(s). |
| */ |
| DrawFace getDrawFace() const { return fCommon.fDrawFace; } |
| |
| /// @} |
| |
| /////////////////////////////////////////////////////////////////////////// |
| |
| bool operator ==(const GrDrawState& s) const { |
| if (fRenderTarget.get() != s.fRenderTarget.get() || |
| fColorStages.count() != s.fColorStages.count() || |
| fCoverageStages.count() != s.fCoverageStages.count() || |
| fCommon != s.fCommon) { |
| return false; |
| } |
| for (int i = 0; i < fColorStages.count(); i++) { |
| if (fColorStages[i] != s.fColorStages[i]) { |
| return false; |
| } |
| } |
| for (int i = 0; i < fCoverageStages.count(); i++) { |
| if (fCoverageStages[i] != s.fCoverageStages[i]) { |
| return false; |
| } |
| } |
| return true; |
| } |
| bool operator !=(const GrDrawState& s) const { return !(*this == s); } |
| |
| GrDrawState& operator= (const GrDrawState& s) { |
| GrAssert(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages()); |
| this->setRenderTarget(s.fRenderTarget.get()); |
| fCommon = s.fCommon; |
| fColorStages = s.fColorStages; |
| fCoverageStages = s.fCoverageStages; |
| return *this; |
| } |
| |
| private: |
| |
| void onReset(const SkMatrix* initialViewMatrix) { |
| GrAssert(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages()); |
| fColorStages.reset(); |
| fCoverageStages.reset(); |
| |
| fRenderTarget.reset(NULL); |
| |
| this->setDefaultVertexAttribs(); |
| |
| fCommon.fColor = 0xffffffff; |
| if (NULL == initialViewMatrix) { |
| fCommon.fViewMatrix.reset(); |
| } else { |
| fCommon.fViewMatrix = *initialViewMatrix; |
| } |
| fCommon.fSrcBlend = kOne_GrBlendCoeff; |
| fCommon.fDstBlend = kZero_GrBlendCoeff; |
| fCommon.fBlendConstant = 0x0; |
| fCommon.fFlagBits = 0x0; |
| fCommon.fStencilSettings.setDisabled(); |
| fCommon.fCoverage = 0xffffffff; |
| fCommon.fColorFilterMode = SkXfermode::kDst_Mode; |
| fCommon.fColorFilterColor = 0x0; |
| fCommon.fDrawFace = kBoth_DrawFace; |
| } |
| |
| /** Fields that are identical in GrDrawState and GrDrawState::DeferredState. */ |
| struct CommonState { |
| // These fields are roughly sorted by decreasing likelihood of being different in op== |
| GrColor fColor; |
| SkMatrix fViewMatrix; |
| GrBlendCoeff fSrcBlend; |
| GrBlendCoeff fDstBlend; |
| GrColor fBlendConstant; |
| uint32_t fFlagBits; |
| const GrVertexAttrib* fVAPtr; |
| int fVACount; |
| GrStencilSettings fStencilSettings; |
| GrColor fCoverage; |
| SkXfermode::Mode fColorFilterMode; |
| GrColor fColorFilterColor; |
| DrawFace fDrawFace; |
| |
| // This is simply a different representation of info in fVertexAttribs and thus does |
| // not need to be compared in op==. |
| int fFixedFunctionVertexAttribIndices[kGrFixedFunctionVertexAttribBindingCnt]; |
| |
| bool operator== (const CommonState& other) const { |
| bool result = fColor == other.fColor && |
| fViewMatrix.cheapEqualTo(other.fViewMatrix) && |
| fSrcBlend == other.fSrcBlend && |
| fDstBlend == other.fDstBlend && |
| fBlendConstant == other.fBlendConstant && |
| fFlagBits == other.fFlagBits && |
| fVACount == other.fVACount && |
| !memcmp(fVAPtr, other.fVAPtr, fVACount * sizeof(GrVertexAttrib)) && |
| fStencilSettings == other.fStencilSettings && |
| fCoverage == other.fCoverage && |
| fColorFilterMode == other.fColorFilterMode && |
| fColorFilterColor == other.fColorFilterColor && |
| fDrawFace == other.fDrawFace; |
| GrAssert(!result || 0 == memcmp(fFixedFunctionVertexAttribIndices, |
| other.fFixedFunctionVertexAttribIndices, |
| sizeof(fFixedFunctionVertexAttribIndices))); |
| return result; |
| } |
| bool operator!= (const CommonState& other) const { return !(*this == other); } |
| }; |
| |
| /** GrDrawState uses GrEffectStages to hold stage state which holds a ref on GrEffectRef. |
| DeferredState must directly reference GrEffects, however. */ |
| struct SavedEffectStage { |
| SavedEffectStage() : fEffect(NULL) {} |
| const GrEffect* fEffect; |
| GrEffectStage::SavedCoordChange fCoordChange; |
| }; |
| |
| public: |
| /** |
| * DeferredState contains all of the data of a GrDrawState but does not hold refs on GrResource |
| * objects. Resources are allowed to hit zero ref count while in DeferredStates. Their internal |
| * dispose mechanism returns them to the cache. This allows recycling resources through the |
| * the cache while they are in a deferred draw queue. |
| */ |
| class DeferredState { |
| public: |
| DeferredState() : fRenderTarget(NULL) { |
| GR_DEBUGCODE(fInitialized = false;) |
| } |
| // TODO: Remove this when DeferredState no longer holds a ref to the RT |
| ~DeferredState() { SkSafeUnref(fRenderTarget); } |
| |
| void saveFrom(const GrDrawState& drawState) { |
| fCommon = drawState.fCommon; |
| // TODO: Here we will copy the GrRenderTarget pointer without taking a ref. |
| fRenderTarget = drawState.fRenderTarget.get(); |
| SkSafeRef(fRenderTarget); |
| // Here we ref the effects directly rather than the effect-refs. TODO: When the effect- |
| // ref gets fully unref'ed it will cause the underlying effect to unref its resources |
| // and recycle them to the cache (if no one else is holding a ref to the resources). |
| fStages.reset(drawState.fColorStages.count() + drawState.fCoverageStages.count()); |
| fColorStageCnt = drawState.fColorStages.count(); |
| for (int i = 0; i < fColorStageCnt; ++i) { |
| fStages[i].saveFrom(drawState.fColorStages[i]); |
| } |
| for (int i = 0; i < drawState.fCoverageStages.count(); ++i) { |
| fStages[i + fColorStageCnt].saveFrom(drawState.fCoverageStages[i]); |
| } |
| GR_DEBUGCODE(fInitialized = true;) |
| } |
| |
| void restoreTo(GrDrawState* drawState) { |
| GrAssert(fInitialized); |
| drawState->fCommon = fCommon; |
| drawState->setRenderTarget(fRenderTarget); |
| // reinflate color/cov stage arrays. |
| drawState->fColorStages.reset(); |
| for (int i = 0; i < fColorStageCnt; ++i) { |
| SkNEW_APPEND_TO_TARRAY(&drawState->fColorStages, GrEffectStage, (fStages[i])); |
| } |
| int coverageStageCnt = fStages.count() - fColorStageCnt; |
| drawState->fCoverageStages.reset(); |
| for (int i = 0; i < coverageStageCnt; ++i) { |
| SkNEW_APPEND_TO_TARRAY(&drawState->fCoverageStages, |
| GrEffectStage, (fStages[i + fColorStageCnt])); |
| } |
| } |
| |
| bool isEqual(const GrDrawState& state) const { |
| int numCoverageStages = fStages.count() - fColorStageCnt; |
| if (fRenderTarget != state.fRenderTarget.get() || |
| fColorStageCnt != state.fColorStages.count() || |
| numCoverageStages != state.fCoverageStages.count() || |
| fCommon != state.fCommon) { |
| return false; |
| } |
| bool explicitLocalCoords = state.hasLocalCoordAttribute(); |
| for (int i = 0; i < fColorStageCnt; ++i) { |
| if (!fStages[i].isEqual(state.fColorStages[i], explicitLocalCoords)) { |
| return false; |
| } |
| } |
| for (int i = 0; i < numCoverageStages; ++i) { |
| int s = fColorStageCnt + i; |
| if (!fStages[s].isEqual(state.fCoverageStages[i], explicitLocalCoords)) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| private: |
| typedef SkAutoSTArray<8, GrEffectStage::DeferredStage> DeferredStageArray; |
| |
| GrRenderTarget* fRenderTarget; |
| CommonState fCommon; |
| int fColorStageCnt; |
| DeferredStageArray fStages; |
| |
| GR_DEBUGCODE(bool fInitialized;) |
| }; |
| |
| private: |
| |
| SkAutoTUnref<GrRenderTarget> fRenderTarget; |
| CommonState fCommon; |
| |
| typedef SkSTArray<4, GrEffectStage> EffectStageArray; |
| EffectStageArray fColorStages; |
| EffectStageArray fCoverageStages; |
| |
| // Some of the auto restore objects assume that no effects are removed during their lifetime. |
| // This is used to assert that this condition holds. |
| GR_DEBUGCODE(int fBlockEffectRemovalCnt;) |
| |
| /** |
| * Sets vertex attributes for next draw. |
| * |
| * @param attribs the array of vertex attributes to set. |
| * @param count the number of attributes being set, limited to kMaxVertexAttribCnt. |
| */ |
| void setVertexAttribs(const GrVertexAttrib attribs[], int count); |
| |
| typedef GrRefCnt INHERITED; |
| }; |
| |
| GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags); |
| |
| #endif |