diff options
author | egdaniel <egdaniel@google.com> | 2014-09-26 06:15:04 -0700 |
---|---|---|
committer | Commit bot <commit-bot@chromium.org> | 2014-09-26 06:15:04 -0700 |
commit | 89af44a0f1323dc136b238c00ccf143e15abb243 (patch) | |
tree | 24993a0a51b35b8b1d55ebf7e2375de56d11261f /src/gpu/GrOptDrawState.h | |
parent | fbe8d890ce45035daabc54574f94354db89d99ae (diff) |
Split GrDrawState and GrOptDrawState into separate classes and remove base class.
Besides splitting the two classes, there are no logical changes here and mostly moving code around.
BUG=skia:
R=bsalomon@google.com
Author: egdaniel@google.com
Review URL: https://codereview.chromium.org/597323002
Diffstat (limited to 'src/gpu/GrOptDrawState.h')
-rw-r--r-- | src/gpu/GrOptDrawState.h | 326 |
1 files changed, 320 insertions, 6 deletions
diff --git a/src/gpu/GrOptDrawState.h b/src/gpu/GrOptDrawState.h index b4f59d3a7b..f0a726e954 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 + |