#ifndef GrDrawState_DEFINED
#define GrDrawState_DEFINED
-#include "GrBackendEffectFactory.h"
#include "GrBlend.h"
-#include "GrColor.h"
-#include "GrEffectStage.h"
-#include "GrPaint.h"
-#include "GrRenderTarget.h"
-#include "GrStencil.h"
-#include "GrTemplates.h"
-#include "GrTexture.h"
-#include "GrTypesPriv.h"
+#include "GrDrawTargetCaps.h"
+#include "GrGpuResourceRef.h"
+#include "GrRODrawState.h"
#include "effects/GrSimpleTextureEffect.h"
-#include "SkMatrix.h"
-#include "SkTypes.h"
-#include "SkXfermode.h"
+class GrOptDrawState;
-class GrDrawState : public SkRefCnt {
+/**
+ * Modifiable subclass derived from GrRODrawState. The majority of the data that represents a draw
+ * state is stored in the parent class. GrDrawState contains methods for setting, adding to, etc.
+ * various data members of the draw state. This class is used to configure the state used when
+ * issuing draws via GrDrawTarget.
+ */
+class GrDrawState : public GrRODrawState {
public:
SK_DECLARE_INST_COUNT(GrDrawState)
- GrDrawState() {
+ GrDrawState() : fCachedOptState(NULL) {
SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
this->reset();
}
- GrDrawState(const SkMatrix& initialViewMatrix) {
+ GrDrawState(const SkMatrix& initialViewMatrix) : fCachedOptState(NULL) {
SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
this->reset(initialViewMatrix);
}
/**
* Copies another draw state.
**/
- GrDrawState(const GrDrawState& state) : INHERITED() {
+ GrDrawState(const GrDrawState& state) : INHERITED(), fCachedOptState(NULL) {
SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
*this = state;
}
/**
* Copies another draw state with a preconcat to the view matrix.
**/
- GrDrawState(const GrDrawState& state, const SkMatrix& preConcatMatrix) {
- SkDEBUGCODE(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);
- }
- }
- }
+ GrDrawState(const GrDrawState& state, const SkMatrix& preConcatMatrix);
- virtual ~GrDrawState() { SkASSERT(0 == fBlockEffectRemovalCnt); }
+ virtual ~GrDrawState();
/**
- * Resets to the default state. GrEffects will be removed from all stages.
+ * Resets to the default state. GrProcessors will be removed from all stages.
*/
void reset() { this->onReset(NULL); }
/**
* 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.
+ * equivalents are set to default values with the exception of vertex attribute state which
+ * is unmodified by this function and clipping which 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
+ * The mapping of attributes with kEffect bindings to GrProcessor 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.
+ *
+ * @param count the number of attributes being set, limited to kMaxVertexAttribCnt.
+ * @param stride the number of bytes between successive vertex data.
*/
- template <const GrVertexAttrib A[]> void setVertexAttribs(int count) {
- this->setVertexAttribs(A, count);
+ template <const GrVertexAttrib A[]> void setVertexAttribs(int count, size_t stride) {
+ this->internalSetVertexAttribs(A, count, stride);
}
- 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) {
- SkASSERT(NULL != drawState);
- fDrawState = drawState;
- fVAPtr = drawState->fCommon.fVAPtr;
- fVACount = drawState->fCommon.fVACount;
- fDrawState->setDefaultVertexAttribs();
- }
-
- ~AutoVertexAttribRestore(){
- fDrawState->setVertexAttribs(fVAPtr, fVACount);
- }
+ AutoVertexAttribRestore(GrDrawState* drawState);
+
+ ~AutoVertexAttribRestore() { fDrawState->internalSetVertexAttribs(fVAPtr, fVACount,
+ fVAStride); }
private:
GrDrawState* fDrawState;
const GrVertexAttrib* fVAPtr;
int fVACount;
+ size_t fVAStride;
};
- /**
- * 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 SkPoint* GetVertexPoint(void* vertices,
- int vertexIndex,
- int vertexSize,
- int offset = 0) {
- intptr_t start = GrTCast<intptr_t>(vertices);
- return GrTCast<SkPoint*>(start + offset +
- vertexIndex * vertexSize);
- }
- static const SkPoint* GetVertexPoint(const void* vertices,
- int vertexIndex,
- int vertexSize,
- int offset = 0) {
- intptr_t start = GrTCast<intptr_t>(vertices);
- return GrTCast<const SkPoint*>(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.
+ * Depending on features available in the underlying 3D API and the color blend mode requested
+ * it may or may not be possible to correctly blend with fractional pixel coverage generated by
+ * the fragment shader.
+ *
+ * This function considers the current draw state and the draw target's capabilities to
+ * determine whether coverage can be handled correctly. This function assumes that the caller
+ * intends to specify fractional pixel coverage (via setCoverage(), through a coverage vertex
+ * attribute, or a coverage effect) but may not have specified it yet.
*/
- bool hasSolidCoverage() const;
+ bool couldApplyCoverage(const GrDrawTargetCaps& caps) const;
/// @}
*
* @param color the color to set.
*/
- void setColor(GrColor color) { fCommon.fColor = color; }
-
- GrColor getColor() const { return fCommon.fColor; }
+ void setColor(GrColor color) {
+ if (color != fColor) {
+ fColor = color;
+ this->invalidateOptState();
+ }
+ }
/**
* Sets the color to be used for the next draw to be
*
* @param alpha The alpha value to set as the color.
*/
- void setAlpha(uint8_t a) {
- this->setColor((a << 24) | (a << 16) | (a << 8) | a);
- }
-
- /**
- * Constructor sets the color to be 'color' which is undone by the destructor.
- */
- class AutoColorRestore : public ::SkNoncopyable {
- 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;
- };
+ void setAlpha(uint8_t a) { this->setColor((a << 24) | (a << 16) | (a << 8) | a); }
/// @}
* coverage is ignored when per-vertex coverage is provided.
*/
void setCoverage(uint8_t coverage) {
- fCommon.fCoverage = GrColorPackRGBA(coverage, coverage, coverage, coverage);
+ if (coverage != fCoverage) {
+ fCoverage = coverage;
+ this->invalidateOptState();
+ }
}
- uint8_t getCoverage() const {
- return GrColorUnpackR(fCommon.fCoverage);
- }
+ /// @}
- GrColor getCoverageColor() const {
- return fCommon.fCoverage;
- }
+ /**
+ * The geometry processor is the sole element of the skia pipeline which can use the vertex,
+ * geometry, and tesselation shaders. The GP may also compute a coverage in its fragment shader
+ * but is never put in the color processing pipeline.
+ */
- /// @}
+ const GrGeometryProcessor* setGeometryProcessor(const GrGeometryProcessor* geometryProcessor) {
+ SkASSERT(geometryProcessor);
+ SkASSERT(!this->hasGeometryProcessor());
+ fGeometryProcessor.reset(new GrGeometryStage(geometryProcessor));
+ this->invalidateOptState();
+ return geometryProcessor;
+ }
///////////////////////////////////////////////////////////////////////////
/// @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
+ /// 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 color / coverage distinction.
////
- const GrEffectRef* addColorEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
- SkASSERT(NULL != effect);
- SkNEW_APPEND_TO_TARRAY(&fColorStages, GrEffectStage, (effect, attr0, attr1));
+ const GrFragmentProcessor* addColorProcessor(const GrFragmentProcessor* effect) {
+ SkASSERT(effect);
+ SkNEW_APPEND_TO_TARRAY(&fColorStages, GrFragmentStage, (effect));
+ this->invalidateOptState();
return effect;
}
- const GrEffectRef* addCoverageEffect(const GrEffectRef* effect, int attr0 = -1, int attr1 = -1) {
- SkASSERT(NULL != effect);
- SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrEffectStage, (effect, attr0, attr1));
+ const GrFragmentProcessor* addCoverageProcessor(const GrFragmentProcessor* effect) {
+ SkASSERT(effect);
+ SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrFragmentStage, (effect));
+ this->invalidateOptState();
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 addColorTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
+ this->addColorProcessor(GrSimpleTextureEffect::Create(texture, matrix))->unref();
}
- void addCoverageTextureEffect(GrTexture* texture, const SkMatrix& matrix) {
- GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix);
- this->addCoverageEffect(effect)->unref();
+ void addCoverageTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
+ this->addCoverageProcessor(GrSimpleTextureEffect::Create(texture, matrix))->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,
+ void addColorTextureProcessor(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
- GrEffectRef* effect = GrSimpleTextureEffect::Create(texture, matrix, params);
- this->addCoverageEffect(effect)->unref();
+ this->addColorProcessor(GrSimpleTextureEffect::Create(texture, matrix, params))->unref();
+ }
+
+ void addCoverageTextureProcessor(GrTexture* texture,
+ const SkMatrix& matrix,
+ const GrTextureParams& params) {
+ this->addCoverageProcessor(GrSimpleTextureEffect::Create(texture, matrix, params))->unref();
}
/**
- * When this object is destroyed it will remove any effects from the draw state that were added
- * after its constructor.
+ * When this object is destroyed it will remove any color/coverage effects from the draw state
+ * that were added after its constructor.
+ *
+ * This class has strange behavior around geometry processor. If there is a GP on the draw state
+ * it will assert that the GP is not modified until after the destructor of the ARE. If the
+ * draw state has a NULL GP when the ARE is constructed then it will reset it to null in the
+ * destructor.
+ *
+ * TODO: We'd prefer for the ARE to just save and restore the GP. However, this would add
+ * significant complexity to the multi-ref architecture for deferred drawing. Once GrDrawState
+ * and GrOptDrawState are fully separated then GrDrawState will never be in the deferred
+ * execution state and GrOptDrawState always will be (and will be immutable and therefore
+ * unable to have an ARE). At this point we can restore sanity and have the ARE save and restore
+ * the GP.
*/
class AutoRestoreEffects : public ::SkNoncopyable {
public:
- AutoRestoreEffects() : fDrawState(NULL), fColorEffectCnt(0), fCoverageEffectCnt(0) {}
-
- AutoRestoreEffects(GrDrawState* ds) : fDrawState(NULL), fColorEffectCnt(0), fCoverageEffectCnt(0) {
+ AutoRestoreEffects()
+ : fDrawState(NULL)
+ , fOriginalGPID(SK_InvalidUniqueID)
+ , fColorEffectCnt(0)
+ , fCoverageEffectCnt(0) {}
+
+ AutoRestoreEffects(GrDrawState* ds)
+ : fDrawState(NULL)
+ , fOriginalGPID(SK_InvalidUniqueID)
+ , fColorEffectCnt(0)
+ , fCoverageEffectCnt(0) {
this->set(ds);
}
~AutoRestoreEffects() { this->set(NULL); }
- void set(GrDrawState* ds) {
- if (NULL != fDrawState) {
- int n = fDrawState->fColorStages.count() - fColorEffectCnt;
- SkASSERT(n >= 0);
- fDrawState->fColorStages.pop_back_n(n);
- n = fDrawState->fCoverageStages.count() - fCoverageEffectCnt;
- SkASSERT(n >= 0);
- fDrawState->fCoverageStages.pop_back_n(n);
- SkDEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
- }
- fDrawState = ds;
- if (NULL != ds) {
- fColorEffectCnt = ds->fColorStages.count();
- fCoverageEffectCnt = ds->fCoverageStages.count();
- SkDEBUGCODE(++ds->fBlockEffectRemovalCnt;)
- }
- }
+ void set(GrDrawState* ds);
- bool isSet() const { return NULL != fDrawState; }
+ bool isSet() const { return SkToBool(fDrawState); }
private:
- GrDrawState* fDrawState;
- int fColorEffectCnt;
- int fCoverageEffectCnt;
+ GrDrawState* fDrawState;
+ uint32_t fOriginalGPID;
+ 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;
-
/// @}
///////////////////////////////////////////////////////////////////////////
* @param dstCoef coefficient applied to the dst color.
*/
void setBlendFunc(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff) {
- fCommon.fSrcBlend = srcCoeff;
- fCommon.fDstBlend = dstCoeff;
+ if (srcCoeff != fSrcBlend || dstCoeff != fDstBlend) {
+ fSrcBlend = srcCoeff;
+ fDstBlend = dstCoeff;
+ this->invalidateOptState();
+ }
#ifdef SK_DEBUG
if (GrBlendCoeffRefsDst(dstCoeff)) {
GrPrintf("Unexpected dst blend coeff. Won't work correctly with coverage stages.\n");
#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:
*
* @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;
+ void setBlendConstant(GrColor constant) {
+ if (constant != fBlendConstant) {
+ fBlendConstant = constant;
+ this->invalidateOptState();
+ }
+ }
/// @}
*/
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;
- }
-
////////////////////////////////////////////////////////////////////////////
/**
private:
void doEffectCoordChanges(const SkMatrix& coordChangeMatrix);
- GrDrawState* fDrawState;
- SkMatrix fViewMatrix;
- int fNumColorStages;
- SkAutoSTArray<8, GrEffectStage::SavedCoordChange> fSavedCoordChanges;
+ GrDrawState* fDrawState;
+ SkMatrix fViewMatrix;
+ int fNumColorStages;
+ bool fHasGeometryProcessor;
+ SkAutoSTArray<8, GrProcessorStage::SavedCoordChange> fSavedCoordChanges;
};
/// @}
* @param target The render target to set.
*/
void setRenderTarget(GrRenderTarget* target) {
- fRenderTarget.reset(SkSafeRef(target));
+ fRenderTarget.set(SkSafeRef(target), GrIORef::kWrite_IOType);
+ this->invalidateOptState();
}
- /**
- * 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 ::SkNoncopyable {
- 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;
- }
- SkSafeSetNull(fSavedTarget);
- }
-
- void set(GrDrawState* ds, GrRenderTarget* newTarget) {
- this->restore();
-
- if (NULL != ds) {
- SkASSERT(NULL == fSavedTarget);
- fSavedTarget = ds->getRenderTarget();
- SkSafeRef(fSavedTarget);
- ds->setRenderTarget(newTarget);
- fDrawState = ds;
- }
- }
- private:
- GrDrawState* fDrawState;
- GrRenderTarget* fSavedTarget;
- };
-
/// @}
///////////////////////////////////////////////////////////////////////////
* @param settings the stencil settings to use.
*/
void setStencil(const GrStencilSettings& settings) {
- fCommon.fStencilSettings = settings;
+ if (settings != fStencilSettings) {
+ fStencilSettings = settings;
+ this->invalidateOptState();
+ }
}
/**
* Shortcut to disable stencil testing and ops.
*/
void disableStencil() {
- fCommon.fStencilSettings.setDisabled();
+ if (!fStencilSettings.isDisabled()) {
+ fStencilSettings.setDisabled();
+ this->invalidateOptState();
+ }
}
- const GrStencilSettings& getStencil() const { return fCommon.fStencilSettings; }
-
- GrStencilSettings* stencil() { return &fCommon.fStencilSettings; }
+ GrStencilSettings* stencil() { 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,
- };
-
void resetStateFlags() {
- fCommon.fFlagBits = 0;
+ if (0 != fFlagBits) {
+ fFlagBits = 0;
+ this->invalidateOptState();
+ }
}
/**
* @param stateBits bitfield of StateBits specifying the states to enable
*/
void enableState(uint32_t stateBits) {
- fCommon.fFlagBits |= stateBits;
+ if (stateBits & ~fFlagBits) {
+ fFlagBits |= stateBits;
+ this->invalidateOptState();
+ }
}
/**
* @param stateBits bitfield of StateBits specifying the states to disable
*/
void disableState(uint32_t stateBits) {
- fCommon.fFlagBits &= ~(stateBits);
+ if (stateBits & fFlagBits) {
+ fFlagBits &= ~(stateBits);
+ this->invalidateOptState();
+ }
}
/**
}
}
- 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) {
SkASSERT(kInvalid_DrawFace != face);
- fCommon.fDrawFace = face;
+ 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; }
-
/// @}
///////////////////////////////////////////////////////////////////////////
+ /// @name Hints
+ /// Hints that when provided can enable optimizations.
+ ////
- 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) {
- SkASSERT(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) {
- SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
- fColorStages.reset();
- fCoverageStages.reset();
-
- fRenderTarget.reset(NULL);
+ void setHint(Hints hint, bool value) { fHints = value ? (fHints | hint) : (fHints & ~hint); }
- 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.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;
- 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 &&
- fDrawFace == other.fDrawFace;
- SkASSERT(!result || 0 == memcmp(fFixedFunctionVertexAttribIndices,
- other.fFixedFunctionVertexAttribIndices,
- sizeof(fFixedFunctionVertexAttribIndices)));
- return result;
- }
- bool operator!= (const CommonState& other) const { return !(*this == other); }
+ /** 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,
};
- /** 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;
- };
+ /** This function determines whether the GrDrawStates used for two draws can be combined into
+ a single GrDrawState. This is used to avoid storing redundant GrDrawStates and to determine
+ if draws can be batched. The return value indicates whether combining is possible and, if
+ so, which of the two inputs should be used. */
+ static CombinedState CombineIfPossible(const GrDrawState& a, const GrDrawState& b,
+ const GrDrawTargetCaps& caps);
+
+ GrDrawState& operator= (const GrDrawState& that);
-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.
+ * Returns a snapshot of the current optimized state. If the current drawState has a valid
+ * cached optimiezed state it will simply return a pointer to it otherwise it will create a new
+ * GrOptDrawState. In all cases the GrOptDrawState is reffed and ownership is given to the
+ * caller.
*/
- class DeferredState {
- public:
- DeferredState() : fRenderTarget(NULL) {
- SkDEBUGCODE(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]);
- }
- SkDEBUGCODE(fInitialized = true;)
- }
-
- void restoreTo(GrDrawState* drawState) {
- SkASSERT(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;
-
- SkDEBUGCODE(bool fInitialized;)
- };
+ GrOptDrawState* createOptState(const GrDrawTargetCaps&) const;
private:
+ void invalidateOptState() const;
- SkAutoTUnref<GrRenderTarget> fRenderTarget;
- CommonState fCommon;
-
- typedef SkSTArray<4, GrEffectStage> EffectStageArray;
- EffectStageArray fColorStages;
- EffectStageArray fCoverageStages;
+ void onReset(const SkMatrix* initialViewMatrix);
// Some of the auto restore objects assume that no effects are removed during their lifetime.
// This is used to assert that this condition holds.
SkDEBUGCODE(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);
+ void internalSetVertexAttribs(const GrVertexAttrib attribs[], int count, size_t stride);
- typedef SkRefCnt INHERITED;
-};
+ mutable GrOptDrawState* fCachedOptState;
+ mutable uint32_t fCachedCapsID;
-GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
+ typedef GrRODrawState INHERITED;
+};
#endif
projects / platform / framework / web / crosswalk.git / blobdiff