/* * Copyright 2014 Google Inc. * * Use of this source code is governed by a BSD-style license that can be * found in the LICENSE file. */ #ifndef GrOptDrawState_DEFINED #define GrOptDrawState_DEFINED #include "GrDrawState.h" /** * 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 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(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; } bool readsDst() const { return fReadsDst; } bool readsFragPosition() const { return fReadsFragPosition; } bool requiresLocalCoordAttrib() const { return fRequiresLocalCoordAttrib; } /////////////////////////////////////////////////////////////////////////// /// @name Stage Output Types //// enum PrimaryOutputType { // Modulate color and coverage, write result as the color output. kModulate_PrimaryOutputType, // Combines the coverage, dst, and color as coverage * color + (1 - coverage) * dst. This // can only be set if fDstReadKey is non-zero. kCombineWithDst_PrimaryOutputType, kPrimaryOutputTypeCnt, }; enum SecondaryOutputType { // There is no secondary output kNone_SecondaryOutputType, // Writes coverage as the secondary output. Only set if dual source blending is supported // and primary output is kModulate. kCoverage_SecondaryOutputType, // Writes coverage * (1 - colorA) as the secondary output. Only set if dual source blending // is supported and primary output is kModulate. kCoverageISA_SecondaryOutputType, // Writes coverage * (1 - colorRGBA) as the secondary output. Only set if dual source // blending is supported and primary output is kModulate. kCoverageISC_SecondaryOutputType, kSecondaryOutputTypeCnt, }; PrimaryOutputType getPrimaryOutputType() const { return fPrimaryOutputType; } SecondaryOutputType getSecondaryOutputType() const { return fSecondaryOutputType; } /// @} 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, GrBlendCoeff optSrcCoeff, GrBlendCoeff optDstCoeff, const GrDrawTargetCaps& caps); /** * Loops through all the color stage effects to check if the stage will ignore color input or * always output a constant color. In the ignore color input case we can ignore all previous * stages. In the constant color case, we can ignore all previous stages and * the current one and set the state color to the constant color. Once we determine the so * called first effective stage, we copy all the effective stages into our optimized * state. */ void copyEffectiveColorStages(const GrDrawState& ds); /** * Loops through all the coverage stage effects to check if the stage will ignore color input. * If a coverage stage will ignore input, then we can ignore all coverage stages before it. We * loop to determine the first effective coverage stage, and then copy all of our effective * coverage stages into our optimized state. */ void copyEffectiveCoverageStages(const GrDrawState& ds); /** * This function takes in a flag and removes the corresponding fixed function vertex attributes. * The flags are in the same order as GrVertexAttribBinding array. If bit i of removeVAFlags is * set, then vertex attributes with binding (GrVertexAttribute)i will be removed. */ void removeFixedFunctionVertexAttribs(uint8_t removeVAFlags); /** * Alter the OptDrawState (adjusting stages, vertex attribs, flags, etc.) based on the * BlendOptFlags. */ void adjustFromBlendOpts(); /** * Loop over the effect stages to determine various info like what data they will read and what * shaders they require. */ void getStageStats(); /** * Calculates the primary and secondary output types of the shader. For certain output types * the function may adjust the blend coefficients. After this function is called the src and dst * blend coeffs will represent those used by backend API. */ 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 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 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; bool fInputCoverageIsUsed; // These flags give aggregated info on the effect stages that are used when building programs. bool fReadsDst; bool fReadsFragPosition; bool fRequiresLocalCoordAttrib; SkAutoSTArray<4, GrVertexAttrib> fOptVA; BlendOptFlags fBlendOptFlags; // Fragment shader color outputs PrimaryOutputType fPrimaryOutputType : 8; SecondaryOutputType fSecondaryOutputType : 8; friend GrOptDrawState* GrDrawState::createOptState(const GrDrawTargetCaps&) const; typedef SkRefCnt INHERITED; }; GR_MAKE_BITFIELD_OPS(GrOptDrawState::BlendOptFlags); #endif