Index: src/gpu/GrOptDrawState.h |
diff --git a/src/gpu/GrOptDrawState.h b/src/gpu/GrOptDrawState.h |
index b4f59d3a7b09f0dd1ff51f20ed6721318518f191..f0a726e9547d5d7bddffaf145a690ffcd0244432 100644 |
--- a/src/gpu/GrOptDrawState.h |
+++ b/src/gpu/GrOptDrawState.h |
@@ -9,17 +9,272 @@ |
#define GrOptDrawState_DEFINED |
#include "GrDrawState.h" |
-#include "GrRODrawState.h" |
/** |
- * Subclass of GrRODrawState that holds an optimized version of a GrDrawState. Like it's parent |
- * it is meant to be an immutable class, and simply adds a few helpful data members not in the |
- * base class. |
+ * Class that holds an optimized version of a GrDrawState. It is meant to be an immutable class, |
+ * and contains all data needed to set the state for a gpu draw. |
*/ |
-class GrOptDrawState : public GrRODrawState { |
+class GrOptDrawState : public SkRefCnt { |
public: |
bool operator== (const GrOptDrawState& that) const; |
+ /////////////////////////////////////////////////////////////////////////// |
+ /// @name Vertex Attributes |
+ //// |
+ |
+ enum { |
+ kMaxVertexAttribCnt = kLast_GrVertexAttribBinding + 4, |
+ }; |
+ |
+ const GrVertexAttrib* getVertexAttribs() const { return fVAPtr; } |
+ int getVertexAttribCount() const { return fVACount; } |
+ |
+ size_t getVertexStride() const { return fVAStride; } |
+ |
+ /** |
+ * 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 fFixedFunctionVertexAttribIndices[kPosition_GrVertexAttribBinding]; |
+ } |
+ int localCoordAttributeIndex() const { |
+ return fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttribBinding]; |
+ } |
+ int colorVertexAttributeIndex() const { |
+ return fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBinding]; |
+ } |
+ int coverageVertexAttributeIndex() const { |
+ return fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribBinding]; |
+ } |
+ |
+ bool hasLocalCoordAttribute() const { |
+ return -1 != fFixedFunctionVertexAttribIndices[kLocalCoord_GrVertexAttribBinding]; |
+ } |
+ bool hasColorVertexAttribute() const { |
+ return -1 != fFixedFunctionVertexAttribIndices[kColor_GrVertexAttribBinding]; |
+ } |
+ bool hasCoverageVertexAttribute() const { |
+ return -1 != fFixedFunctionVertexAttribIndices[kCoverage_GrVertexAttribBinding]; |
+ } |
+ |
+ /// @} |
+ |
+ /////////////////////////////////////////////////////////////////////////// |
+ /// @name Color |
+ //// |
+ |
+ GrColor getColor() const { return fColor; } |
+ |
+ /// @} |
+ |
+ /////////////////////////////////////////////////////////////////////////// |
+ /// @name Coverage |
+ //// |
+ |
+ uint8_t getCoverage() const { return fCoverage; } |
+ |
+ GrColor getCoverageColor() const { |
+ return GrColorPackRGBA(fCoverage, fCoverage, fCoverage, fCoverage); |
+ } |
+ |
+ /// @} |
+ |
+ /////////////////////////////////////////////////////////////////////////// |
+ /// @name Effect Stages |
+ /// Each stage hosts a GrProcessor. 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. |
+ //// |
+ |
+ int numColorStages() const { return fColorStages.count(); } |
+ int numCoverageStages() const { return fCoverageStages.count(); } |
+ int numTotalStages() const { |
+ return this->numColorStages() + this->numCoverageStages() + |
+ (this->hasGeometryProcessor() ? 1 : 0); |
+ } |
+ |
+ bool hasGeometryProcessor() const { return SkToBool(fGeometryProcessor.get()); } |
+ const GrGeometryStage* getGeometryProcessor() const { return fGeometryProcessor.get(); } |
+ const GrFragmentStage& getColorStage(int idx) const { return fColorStages[idx]; } |
+ const GrFragmentStage& getCoverageStage(int idx) const { return fCoverageStages[idx]; } |
+ |
+ /// @} |
+ |
+ /////////////////////////////////////////////////////////////////////////// |
+ /// @name Blending |
+ //// |
+ |
+ GrBlendCoeff getSrcBlendCoeff() const { return fSrcBlend; } |
+ GrBlendCoeff getDstBlendCoeff() const { return fDstBlend; } |
+ |
+ /** |
+ * Retrieves the last value set by setBlendConstant() |
+ * @return the blending constant value |
+ */ |
+ GrColor getBlendConstant() const { return fBlendConstant; } |
+ |
+ /// @} |
+ |
+ /////////////////////////////////////////////////////////////////////////// |
+ /// @name View Matrix |
+ //// |
+ |
+ /** |
+ * Retrieves the current view matrix |
+ * @return the current view matrix. |
+ */ |
+ const SkMatrix& getViewMatrix() const { return 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 { |
+ SkMatrix inverse; |
+ if (fViewMatrix.invert(&inverse)) { |
+ if (matrix) { |
+ *matrix = inverse; |
+ } |
+ return true; |
+ } |
+ return false; |
+ } |
+ |
+ /// @} |
+ |
+ /////////////////////////////////////////////////////////////////////////// |
+ /// @name Render Target |
+ //// |
+ |
+ /** |
+ * Retrieves the currently set render-target. |
+ * |
+ * @return The currently set render target. |
+ */ |
+ GrRenderTarget* getRenderTarget() const { |
+ return static_cast<GrRenderTarget*>(fRenderTarget.getResource()); |
+ } |
+ |
+ /// @} |
+ |
+ /////////////////////////////////////////////////////////////////////////// |
+ /// @name Stencil |
+ //// |
+ |
+ const GrStencilSettings& getStencil() const { return 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, |
+ }; |
+ |
+ bool isStateFlagEnabled(uint32_t stateBit) const { return 0 != (stateBit & fFlagBits); } |
+ |
+ bool isDitherState() const { return 0 != (fFlagBits & kDither_StateBit); } |
+ bool isHWAntialiasState() const { return 0 != (fFlagBits & kHWAntialias_StateBit); } |
+ bool isClipState() const { return 0 != (fFlagBits & kClip_StateBit); } |
+ bool isColorWriteDisabled() const { return 0 != (fFlagBits & kNoColorWrites_StateBit); } |
+ bool isCoverageDrawing() const { return 0 != (fFlagBits & kCoverageDrawing_StateBit); } |
+ |
+ /// @} |
+ |
+ /////////////////////////////////////////////////////////////////////////// |
+ /// @name Face Culling |
+ //// |
+ |
+ enum DrawFace { |
+ kInvalid_DrawFace = -1, |
+ |
+ kBoth_DrawFace, |
+ kCCW_DrawFace, |
+ kCW_DrawFace, |
+ }; |
+ |
+ /** |
+ * Gets whether the target is drawing clockwise, counterclockwise, |
+ * or both faces. |
+ * @return the current draw face(s). |
+ */ |
+ DrawFace getDrawFace() const { return fDrawFace; } |
+ |
+ /// @} |
+ |
+ /////////////////////////////////////////////////////////////////////////// |
+ |
+ /** Return type for CombineIfPossible. */ |
+ enum CombinedState { |
+ /** The GrDrawStates cannot be combined. */ |
+ kIncompatible_CombinedState, |
+ /** Either draw state can be used in place of the other. */ |
+ kAOrB_CombinedState, |
+ /** Use the first draw state. */ |
+ kA_CombinedState, |
+ /** Use the second draw state. */ |
+ kB_CombinedState, |
+ }; |
+ |
bool inputColorIsUsed() const { return fInputColorIsUsed; } |
bool inputCoverageIsUsed() const { return fInputCoverageIsUsed; } |
@@ -64,6 +319,35 @@ public: |
private: |
/** |
+ * 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, |
+ /** |
+ * 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 = 0x2, |
+ /** |
+ * Instead of emitting a src color, emit coverage in the alpha channel and r,g,b are |
+ * "don't cares". |
+ */ |
+ kEmitCoverage_BlendOptFlag = 0x4, |
+ /** |
+ * Emit transparent black instead of the src color, no need to compute coverage. |
+ */ |
+ kEmitTransBlack_BlendOptFlag = 0x8, |
+ }; |
+ GR_DECL_BITFIELD_OPS_FRIENDS(BlendOptFlags); |
+ |
+ /** |
* Constructs and optimized drawState out of a GrRODrawState. |
*/ |
GrOptDrawState(const GrDrawState& drawState, BlendOptFlags blendOptFlags, |
@@ -114,6 +398,33 @@ private: |
*/ |
void setOutputStateInfo(const GrDrawTargetCaps&); |
+ bool isEqual(const GrOptDrawState& that) const; |
+ |
+ // These fields are roughly sorted by decreasing likelihood of being different in op== |
+ typedef GrTGpuResourceRef<GrRenderTarget> ProgramRenderTarget; |
+ ProgramRenderTarget fRenderTarget; |
+ GrColor fColor; |
+ SkMatrix fViewMatrix; |
+ GrColor fBlendConstant; |
+ uint32_t fFlagBits; |
+ const GrVertexAttrib* fVAPtr; |
+ int fVACount; |
+ size_t fVAStride; |
+ GrStencilSettings fStencilSettings; |
+ uint8_t fCoverage; |
+ DrawFace fDrawFace; |
+ GrBlendCoeff fSrcBlend; |
+ GrBlendCoeff fDstBlend; |
+ |
+ typedef SkSTArray<4, GrFragmentStage> FragmentStageArray; |
+ SkAutoTDelete<GrGeometryStage> fGeometryProcessor; |
+ FragmentStageArray fColorStages; |
+ FragmentStageArray fCoverageStages; |
+ |
+ // This is simply a different representation of info in fVertexAttribs and thus does |
+ // not need to be compared in op==. |
+ int fFixedFunctionVertexAttribIndices[kGrFixedFunctionVertexAttribBindingCnt]; |
+ |
// These flags are needed to protect the code from creating an unused uniform color/coverage |
// which will cause shader compiler errors. |
bool fInputColorIsUsed; |
@@ -133,7 +444,10 @@ private: |
SecondaryOutputType fSecondaryOutputType : 8; |
friend GrOptDrawState* GrDrawState::createOptState(const GrDrawTargetCaps&) const; |
- typedef GrRODrawState INHERITED; |
+ typedef SkRefCnt INHERITED; |
}; |
+GR_MAKE_BITFIELD_OPS(GrOptDrawState::BlendOptFlags); |
+ |
#endif |
+ |