Extract GrDrawTarget::DrState into independent GrDrawState struct.
This is intended to be a first step towards making the stack of states
maintained by GrDrawTarget cheaper to maintain.
git-svn-id: http://skia.googlecode.com/svn/trunk@2544 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/gpu/GrDrawTarget.cpp b/src/gpu/GrDrawTarget.cpp
index 986dbd6..97ec3ba 100644
--- a/src/gpu/GrDrawTarget.cpp
+++ b/src/gpu/GrDrawTarget.cpp
@@ -24,7 +24,7 @@
stage_mask_recur<N+1>(stage);
}
template<>
-int stage_mask_recur<GrDrawTarget::kNumStages>(int) { return 0; }
+int stage_mask_recur<GrDrawState::kNumStages>(int) { return 0; }
// mask of all tex coord indices for one stage
int stage_tex_coord_mask(int stage) {
@@ -45,7 +45,7 @@
tex_coord_mask_recur<N+1>(texCoordIdx);
}
template<>
-int tex_coord_mask_recur<GrDrawTarget::kMaxTexCoords>(int) { return 0; }
+int tex_coord_mask_recur<GrDrawState::kMaxTexCoords>(int) { return 0; }
// mask of all bits relevant to one texture coordinate index
int tex_coord_idx_mask(int texCoordIdx) {
@@ -54,7 +54,7 @@
bool check_layout(GrVertexLayout layout) {
// can only have 1 or 0 bits set for each stage.
- for (int s = 0; s < GrDrawTarget::kNumStages; ++s) {
+ for (int s = 0; s < GrDrawState::kNumStages; ++s) {
int stageBits = layout & stage_mask(s);
if (stageBits && !GrIsPow2(stageBits)) {
return false;
@@ -66,7 +66,7 @@
int num_tex_coords(GrVertexLayout layout) {
int cnt = 0;
// figure out how many tex coordinates are present
- for (int t = 0; t < GrDrawTarget::kMaxTexCoords; ++t) {
+ for (int t = 0; t < GrDrawState::kMaxTexCoords; ++t) {
if (tex_coord_idx_mask(t) & layout) {
++cnt;
}
@@ -107,7 +107,7 @@
* Position
* Tex Coord 0
* ...
- * Tex Coord kMaxTexCoords-1
+ * Tex Coord GrDrawState::kMaxTexCoords-1
* Color
* Coverage
*/
@@ -185,11 +185,12 @@
return -1;
}
-int GrDrawTarget::VertexSizeAndOffsetsByIdx(GrVertexLayout vertexLayout,
- int texCoordOffsetsByIdx[kMaxTexCoords],
- int* colorOffset,
- int* coverageOffset,
- int* edgeOffset) {
+int GrDrawTarget::VertexSizeAndOffsetsByIdx(
+ GrVertexLayout vertexLayout,
+ int texCoordOffsetsByIdx[GrDrawState::kMaxTexCoords],
+ int* colorOffset,
+ int* coverageOffset,
+ int* edgeOffset) {
GrAssert(check_layout(vertexLayout));
int vecSize = (vertexLayout & kTextFormat_VertexLayoutBit) ?
@@ -197,7 +198,7 @@
sizeof(GrPoint);
int size = vecSize; // position
- for (int t = 0; t < kMaxTexCoords; ++t) {
+ for (int t = 0; t < GrDrawState::kMaxTexCoords; ++t) {
if (tex_coord_idx_mask(t) & vertexLayout) {
if (NULL != texCoordOffsetsByIdx) {
texCoordOffsetsByIdx[t] = size;
@@ -242,14 +243,15 @@
return size;
}
-int GrDrawTarget::VertexSizeAndOffsetsByStage(GrVertexLayout vertexLayout,
- int texCoordOffsetsByStage[kNumStages],
- int* colorOffset,
- int* coverageOffset,
- int* edgeOffset) {
+int GrDrawTarget::VertexSizeAndOffsetsByStage(
+ GrVertexLayout vertexLayout,
+ int texCoordOffsetsByStage[GrDrawState::kNumStages],
+ int* colorOffset,
+ int* coverageOffset,
+ int* edgeOffset) {
GrAssert(check_layout(vertexLayout));
- int texCoordOffsetsByIdx[kMaxTexCoords];
+ int texCoordOffsetsByIdx[GrDrawState::kMaxTexCoords];
int size = VertexSizeAndOffsetsByIdx(vertexLayout,
(NULL == texCoordOffsetsByStage) ?
NULL :
@@ -258,7 +260,7 @@
coverageOffset,
edgeOffset);
if (NULL != texCoordOffsetsByStage) {
- for (int s = 0; s < kNumStages; ++s) {
+ for (int s = 0; s < GrDrawState::kNumStages; ++s) {
int tcIdx;
if (StagePosAsTexCoordVertexLayoutBit(s) & vertexLayout) {
texCoordOffsetsByStage[s] = 0;
@@ -275,20 +277,21 @@
////////////////////////////////////////////////////////////////////////////////
bool GrDrawTarget::VertexUsesStage(int stage, GrVertexLayout vertexLayout) {
- GrAssert(stage < kNumStages);
+ GrAssert(stage < GrDrawState::kNumStages);
GrAssert(check_layout(vertexLayout));
return !!(stage_mask(stage) & vertexLayout);
}
bool GrDrawTarget::VertexUsesTexCoordIdx(int coordIndex,
GrVertexLayout vertexLayout) {
- GrAssert(coordIndex < kMaxTexCoords);
+ GrAssert(coordIndex < GrDrawState::kMaxTexCoords);
GrAssert(check_layout(vertexLayout));
return !!(tex_coord_idx_mask(coordIndex) & vertexLayout);
}
-int GrDrawTarget::VertexTexCoordsForStage(int stage, GrVertexLayout vertexLayout) {
- GrAssert(stage < kNumStages);
+int GrDrawTarget::VertexTexCoordsForStage(int stage,
+ GrVertexLayout vertexLayout) {
+ GrAssert(stage < GrDrawState::kNumStages);
GrAssert(check_layout(vertexLayout));
int bit = vertexLayout & stage_tex_coord_mask(stage);
if (bit) {
@@ -296,7 +299,7 @@
// bits are ordered T0S0, T0S1, T0S2, ..., T1S0, T1S1, ...
// and start at bit 0.
GR_STATIC_ASSERT(sizeof(GrVertexLayout) <= sizeof(uint32_t));
- return (32 - Gr_clz(bit) - 1) / kNumStages;
+ return (32 - Gr_clz(bit) - 1) / GrDrawState::kNumStages;
}
return -1;
}
@@ -308,31 +311,32 @@
static bool run;
if (!run) {
run = true;
- for (int s = 0; s < kNumStages; ++s) {
+ for (int s = 0; s < GrDrawState::kNumStages; ++s) {
GrAssert(!VertexUsesStage(s, 0));
GrAssert(-1 == VertexStageCoordOffset(s, 0));
GrVertexLayout stageMask = 0;
- for (int t = 0; t < kMaxTexCoords; ++t) {
+ for (int t = 0; t < GrDrawState::kMaxTexCoords; ++t) {
stageMask |= StageTexCoordVertexLayoutBit(s,t);
}
- GrAssert(1 == kMaxTexCoords || !check_layout(stageMask));
+ GrAssert(1 == GrDrawState::kMaxTexCoords ||
+ !check_layout(stageMask));
GrAssert(stage_tex_coord_mask(s) == stageMask);
stageMask |= StagePosAsTexCoordVertexLayoutBit(s);
GrAssert(stage_mask(s) == stageMask);
GrAssert(!check_layout(stageMask));
}
- for (int t = 0; t < kMaxTexCoords; ++t) {
+ for (int t = 0; t < GrDrawState::kMaxTexCoords; ++t) {
GrVertexLayout tcMask = 0;
GrAssert(!VertexUsesTexCoordIdx(t, 0));
- for (int s = 0; s < kNumStages; ++s) {
+ for (int s = 0; s < GrDrawState::kNumStages; ++s) {
tcMask |= StageTexCoordVertexLayoutBit(s,t);
GrAssert(VertexUsesStage(s, tcMask));
GrAssert(sizeof(GrPoint) == VertexStageCoordOffset(s, tcMask));
GrAssert(VertexUsesTexCoordIdx(t, tcMask));
GrAssert(2*sizeof(GrPoint) == VertexSize(tcMask));
GrAssert(t == VertexTexCoordsForStage(s, tcMask));
- for (int s2 = s + 1; s2 < kNumStages; ++s2) {
+ for (int s2 = s + 1; s2 < GrDrawState::kNumStages; ++s2) {
GrAssert(-1 == VertexStageCoordOffset(s2, tcMask));
GrAssert(!VertexUsesStage(s2, tcMask));
GrAssert(-1 == VertexTexCoordsForStage(s2, tcMask));
@@ -384,18 +388,19 @@
GrAssert(tex_coord_idx_mask(t) == tcMask);
GrAssert(check_layout(tcMask));
- int stageOffsets[kNumStages];
+ int stageOffsets[GrDrawState::kNumStages];
int colorOffset;
int edgeOffset;
int coverageOffset;
int size;
- size = VertexSizeAndOffsetsByStage(tcMask, stageOffsets, &colorOffset,
+ size = VertexSizeAndOffsetsByStage(tcMask,
+ stageOffsets, &colorOffset,
&coverageOffset, &edgeOffset);
GrAssert(2*sizeof(GrPoint) == size);
GrAssert(-1 == colorOffset);
GrAssert(-1 == coverageOffset);
GrAssert(-1 == edgeOffset);
- for (int s = 0; s < kNumStages; ++s) {
+ for (int s = 0; s < GrDrawState::kNumStages; ++s) {
GrAssert(VertexUsesStage(s, tcMask));
GrAssert(sizeof(GrPoint) == stageOffsets[s]);
GrAssert(sizeof(GrPoint) == VertexStageCoordOffset(s, tcMask));
@@ -444,17 +449,17 @@
}
void GrDrawTarget::setTexture(int stage, GrTexture* tex) {
- GrAssert(stage >= 0 && stage < kNumStages);
+ GrAssert(stage >= 0 && stage < GrDrawState::kNumStages);
fCurrDrawState.fTextures[stage] = tex;
}
const GrTexture* GrDrawTarget::getTexture(int stage) const {
- GrAssert(stage >= 0 && stage < kNumStages);
+ GrAssert(stage >= 0 && stage < GrDrawState::kNumStages);
return fCurrDrawState.fTextures[stage];
}
GrTexture* GrDrawTarget::getTexture(int stage) {
- GrAssert(stage >= 0 && stage < kNumStages);
+ GrAssert(stage >= 0 && stage < GrDrawState::kNumStages);
return fCurrDrawState.fTextures[stage];
}
@@ -501,7 +506,7 @@
}
void GrDrawTarget::setSamplerState(int stage, const GrSamplerState& state) {
- GrAssert(stage >= 0 && stage < kNumStages);
+ GrAssert(stage >= 0 && stage < GrDrawState::kNumStages);
fCurrDrawState.fSamplerStates[stage] = state;
}
@@ -933,7 +938,7 @@
(layout & kCoverage_VertexLayoutBit) ||
(layout & kEdge_VertexLayoutBit);
for (int s = fCurrDrawState.fFirstCoverageStage;
- !hasCoverage && s < kNumStages;
+ !hasCoverage && s < GrDrawState::kNumStages;
++s) {
if (StageWillBeUsed(s, layout, fCurrDrawState)) {
hasCoverage = true;
@@ -1021,9 +1026,10 @@
///////////////////////////////////////////////////////////////////////////////
-void GrDrawTarget::setEdgeAAData(const Edge* edges, int numEdges) {
- GrAssert(numEdges <= kMaxEdges);
- memcpy(fCurrDrawState.fEdgeAAEdges, edges, numEdges * sizeof(Edge));
+void GrDrawTarget::setEdgeAAData(const GrDrawState::Edge* edges, int numEdges) {
+ GrAssert(numEdges <= GrDrawState::kMaxEdges);
+ memcpy(fCurrDrawState.fEdgeAAEdges, edges,
+ numEdges * sizeof(GrDrawState::Edge));
fCurrDrawState.fEdgeAANumEdges = numEdges;
}
@@ -1053,7 +1059,7 @@
const GrRect* srcRects[]) {
GrVertexLayout layout = 0;
- for (int i = 0; i < kNumStages; ++i) {
+ for (int i = 0; i < GrDrawState::kNumStages; ++i) {
int numTC = 0;
if (stageEnableBitfield & (1 << i)) {
if (NULL != srcRects && NULL != srcRects[i]) {
@@ -1078,7 +1084,7 @@
void* vertices) {
#if GR_DEBUG
// check that the layout and srcRects agree
- for (int i = 0; i < kNumStages; ++i) {
+ for (int i = 0; i < GrDrawState::kNumStages; ++i) {
if (VertexTexCoordsForStage(i, layout) >= 0) {
GR_DEBUGASSERT(NULL != srcRects && NULL != srcRects[i]);
} else {
@@ -1087,7 +1093,7 @@
}
#endif
- int stageOffsets[kNumStages];
+ int stageOffsets[GrDrawState::kNumStages];
int vsize = VertexSizeAndOffsetsByStage(layout, stageOffsets,
NULL, NULL, NULL);
@@ -1098,7 +1104,7 @@
matrix->mapPointsWithStride(GrTCast<GrPoint*>(vertices), vsize, 4);
}
- for (int i = 0; i < kNumStages; ++i) {
+ for (int i = 0; i < GrDrawState::kNumStages; ++i) {
if (stageOffsets[i] > 0) {
GrPoint* coords = GrTCast<GrPoint*>(GrTCast<intptr_t>(vertices) +
stageOffsets[i]);
@@ -1155,7 +1161,7 @@
if (fStageMask) {
GrMatrix invVM;
if (fViewMatrix.invert(&invVM)) {
- for (int s = 0; s < kNumStages; ++s) {
+ for (int s = 0; s < GrDrawState::kNumStages; ++s) {
if (fStageMask & (1 << s)) {
fSamplerMatrices[s] = target->getSamplerMatrix(s);
}
@@ -1171,7 +1177,7 @@
GrDrawTarget::AutoDeviceCoordDraw::~AutoDeviceCoordDraw() {
fDrawTarget->setViewMatrix(fViewMatrix);
- for (int s = 0; s < kNumStages; ++s) {
+ for (int s = 0; s < GrDrawState::kNumStages; ++s) {
if (fStageMask & (1 << s)) {
fDrawTarget->setSamplerMatrix(s, fSamplerMatrices[s]);
}