blob: f0a726e9547d5d7bddffaf145a690ffcd0244432 [file] [log] [blame]
/*
* 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<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; }
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<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;
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