Search and replace change. Some Gr enum value names didn't have a "Gr" in their suffix.
Verbal LGTM from TomH
git-svn-id: http://skia.googlecode.com/svn/trunk@4198 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/gm/texdata.cpp b/gm/texdata.cpp
index 1fdae69..b62aad0 100644
--- a/gm/texdata.cpp
+++ b/gm/texdata.cpp
@@ -96,8 +96,8 @@
GrPaint paint;
paint.reset();
paint.fColor = 0xffffffff;
- paint.fSrcBlendCoeff = kOne_BlendCoeff;
- paint.fDstBlendCoeff = kISA_BlendCoeff;
+ paint.fSrcBlendCoeff = kOne_GrBlendCoeff;
+ paint.fDstBlendCoeff = kISA_GrBlendCoeff;
GrMatrix vm;
if (i) {
vm.setRotate(90 * SK_Scalar1,
diff --git a/include/gpu/GrPaint.h b/include/gpu/GrPaint.h
index 62ab164..729f6f0 100644
--- a/include/gpu/GrPaint.h
+++ b/include/gpu/GrPaint.h
@@ -237,8 +237,8 @@
GrTexture* fMaskTextures[kMaxMasks];
void resetBlend() {
- fSrcBlendCoeff = kOne_BlendCoeff;
- fDstBlendCoeff = kZero_BlendCoeff;
+ fSrcBlendCoeff = kOne_GrBlendCoeff;
+ fDstBlendCoeff = kZero_GrBlendCoeff;
}
void resetOptions() {
diff --git a/include/gpu/GrTypes.h b/include/gpu/GrTypes.h
index 4b17f94..c3f659c 100644
--- a/include/gpu/GrTypes.h
+++ b/include/gpu/GrTypes.h
@@ -203,46 +203,46 @@
* Geometric primitives used for drawing.
*/
enum GrPrimitiveType {
- kTriangles_PrimitiveType,
- kTriangleStrip_PrimitiveType,
- kTriangleFan_PrimitiveType,
- kPoints_PrimitiveType,
- kLines_PrimitiveType, // 1 pix wide only
- kLineStrip_PrimitiveType // 1 pix wide only
+ kTriangles_GrPrimitiveType,
+ kTriangleStrip_GrPrimitiveType,
+ kTriangleFan_GrPrimitiveType,
+ kPoints_GrPrimitiveType,
+ kLines_GrPrimitiveType, // 1 pix wide only
+ kLineStrip_GrPrimitiveType // 1 pix wide only
};
static inline bool GrIsPrimTypeLines(GrPrimitiveType type) {
- return kLines_PrimitiveType == type || kLineStrip_PrimitiveType == type;
+ return kLines_GrPrimitiveType == type || kLineStrip_GrPrimitiveType == type;
}
static inline bool GrIsPrimTypeTris(GrPrimitiveType type) {
- return kTriangles_PrimitiveType == type ||
- kTriangleStrip_PrimitiveType == type ||
- kTriangleFan_PrimitiveType == type;
+ return kTriangles_GrPrimitiveType == type ||
+ kTriangleStrip_GrPrimitiveType == type ||
+ kTriangleFan_GrPrimitiveType == type;
}
/**
* Coeffecients for alpha-blending.
*/
enum GrBlendCoeff {
- kInvalid_BlendCoeff = -1,
+ kInvalid_GrBlendCoeff = -1,
- kZero_BlendCoeff, //<! 0
- kOne_BlendCoeff, //<! 1
- kSC_BlendCoeff, //<! src color
- kISC_BlendCoeff, //<! one minus src color
- kDC_BlendCoeff, //<! dst color
- kIDC_BlendCoeff, //<! one minus dst color
- kSA_BlendCoeff, //<! src alpha
- kISA_BlendCoeff, //<! one minus src alpha
- kDA_BlendCoeff, //<! dst alpha
- kIDA_BlendCoeff, //<! one minus dst alpha
- kConstC_BlendCoeff, //<! constant color
- kIConstC_BlendCoeff, //<! one minus constant color
- kConstA_BlendCoeff, //<! constant color alpha
- kIConstA_BlendCoeff, //<! one minus constant color alpha
+ kZero_GrBlendCoeff, //<! 0
+ kOne_GrBlendCoeff, //<! 1
+ kSC_GrBlendCoeff, //<! src color
+ kISC_GrBlendCoeff, //<! one minus src color
+ kDC_GrBlendCoeff, //<! dst color
+ kIDC_GrBlendCoeff, //<! one minus dst color
+ kSA_GrBlendCoeff, //<! src alpha
+ kISA_GrBlendCoeff, //<! one minus src alpha
+ kDA_GrBlendCoeff, //<! dst alpha
+ kIDA_GrBlendCoeff, //<! one minus dst alpha
+ kConstC_GrBlendCoeff, //<! constant color
+ kIConstC_GrBlendCoeff, //<! one minus constant color
+ kConstA_GrBlendCoeff, //<! constant color alpha
+ kIConstA_GrBlendCoeff, //<! one minus constant color alpha
- kPublicBlendCoeffCount
+ kPublicGrBlendCoeffCount
};
/**
@@ -528,46 +528,46 @@
* Path filling rules
*/
enum GrPathFill {
- kWinding_PathFill,
- kEvenOdd_PathFill,
- kInverseWinding_PathFill,
- kInverseEvenOdd_PathFill,
- kHairLine_PathFill,
+ kWinding_GrPathFill,
+ kEvenOdd_GrPathFill,
+ kInverseWinding_GrPathFill,
+ kInverseEvenOdd_GrPathFill,
+ kHairLine_GrPathFill,
- kPathFillCount
+ kGrPathFillCount
};
static inline GrPathFill GrNonInvertedFill(GrPathFill fill) {
static const GrPathFill gNonInvertedFills[] = {
- kWinding_PathFill, // kWinding_PathFill
- kEvenOdd_PathFill, // kEvenOdd_PathFill
- kWinding_PathFill, // kInverseWinding_PathFill
- kEvenOdd_PathFill, // kInverseEvenOdd_PathFill
- kHairLine_PathFill,// kHairLine_PathFill
+ kWinding_GrPathFill, // kWinding_GrPathFill
+ kEvenOdd_GrPathFill, // kEvenOdd_GrPathFill
+ kWinding_GrPathFill, // kInverseWinding_GrPathFill
+ kEvenOdd_GrPathFill, // kInverseEvenOdd_GrPathFill
+ kHairLine_GrPathFill,// kHairLine_GrPathFill
};
- GR_STATIC_ASSERT(0 == kWinding_PathFill);
- GR_STATIC_ASSERT(1 == kEvenOdd_PathFill);
- GR_STATIC_ASSERT(2 == kInverseWinding_PathFill);
- GR_STATIC_ASSERT(3 == kInverseEvenOdd_PathFill);
- GR_STATIC_ASSERT(4 == kHairLine_PathFill);
- GR_STATIC_ASSERT(5 == kPathFillCount);
+ GR_STATIC_ASSERT(0 == kWinding_GrPathFill);
+ GR_STATIC_ASSERT(1 == kEvenOdd_GrPathFill);
+ GR_STATIC_ASSERT(2 == kInverseWinding_GrPathFill);
+ GR_STATIC_ASSERT(3 == kInverseEvenOdd_GrPathFill);
+ GR_STATIC_ASSERT(4 == kHairLine_GrPathFill);
+ GR_STATIC_ASSERT(5 == kGrPathFillCount);
return gNonInvertedFills[fill];
}
static inline bool GrIsFillInverted(GrPathFill fill) {
static const bool gIsFillInverted[] = {
- false, // kWinding_PathFill
- false, // kEvenOdd_PathFill
- true, // kInverseWinding_PathFill
- true, // kInverseEvenOdd_PathFill
- false, // kHairLine_PathFill
+ false, // kWinding_GrPathFill
+ false, // kEvenOdd_GrPathFill
+ true, // kInverseWinding_GrPathFill
+ true, // kInverseEvenOdd_GrPathFill
+ false, // kHairLine_GrPathFill
};
- GR_STATIC_ASSERT(0 == kWinding_PathFill);
- GR_STATIC_ASSERT(1 == kEvenOdd_PathFill);
- GR_STATIC_ASSERT(2 == kInverseWinding_PathFill);
- GR_STATIC_ASSERT(3 == kInverseEvenOdd_PathFill);
- GR_STATIC_ASSERT(4 == kHairLine_PathFill);
- GR_STATIC_ASSERT(5 == kPathFillCount);
+ GR_STATIC_ASSERT(0 == kWinding_GrPathFill);
+ GR_STATIC_ASSERT(1 == kEvenOdd_GrPathFill);
+ GR_STATIC_ASSERT(2 == kInverseWinding_GrPathFill);
+ GR_STATIC_ASSERT(3 == kInverseEvenOdd_GrPathFill);
+ GR_STATIC_ASSERT(4 == kHairLine_GrPathFill);
+ GR_STATIC_ASSERT(5 == kGrPathFillCount);
return gIsFillInverted[fill];
}
diff --git a/include/gpu/SkGr.h b/include/gpu/SkGr.h
index 8780104..1a5cc93 100644
--- a/include/gpu/SkGr.h
+++ b/include/gpu/SkGr.h
@@ -42,16 +42,16 @@
#define sk_tile_mode_to_grwrap(X) ((GrSamplerState::WrapMode)(X))
-GR_STATIC_ASSERT((int)kZero_BlendCoeff == (int)SkXfermode::kZero_Coeff);
-GR_STATIC_ASSERT((int)kOne_BlendCoeff == (int)SkXfermode::kOne_Coeff);
-GR_STATIC_ASSERT((int)kSC_BlendCoeff == (int)SkXfermode::kSC_Coeff);
-GR_STATIC_ASSERT((int)kISC_BlendCoeff == (int)SkXfermode::kISC_Coeff);
-GR_STATIC_ASSERT((int)kDC_BlendCoeff == (int)SkXfermode::kDC_Coeff);
-GR_STATIC_ASSERT((int)kIDC_BlendCoeff == (int)SkXfermode::kIDC_Coeff);
-GR_STATIC_ASSERT((int)kSA_BlendCoeff == (int)SkXfermode::kSA_Coeff);
-GR_STATIC_ASSERT((int)kISA_BlendCoeff == (int)SkXfermode::kISA_Coeff);
-GR_STATIC_ASSERT((int)kDA_BlendCoeff == (int)SkXfermode::kDA_Coeff);
-GR_STATIC_ASSERT((int)kIDA_BlendCoeff == (int)SkXfermode::kIDA_Coeff);
+GR_STATIC_ASSERT((int)kZero_GrBlendCoeff == (int)SkXfermode::kZero_Coeff);
+GR_STATIC_ASSERT((int)kOne_GrBlendCoeff == (int)SkXfermode::kOne_Coeff);
+GR_STATIC_ASSERT((int)kSC_GrBlendCoeff == (int)SkXfermode::kSC_Coeff);
+GR_STATIC_ASSERT((int)kISC_GrBlendCoeff == (int)SkXfermode::kISC_Coeff);
+GR_STATIC_ASSERT((int)kDC_GrBlendCoeff == (int)SkXfermode::kDC_Coeff);
+GR_STATIC_ASSERT((int)kIDC_GrBlendCoeff == (int)SkXfermode::kIDC_Coeff);
+GR_STATIC_ASSERT((int)kSA_GrBlendCoeff == (int)SkXfermode::kSA_Coeff);
+GR_STATIC_ASSERT((int)kISA_GrBlendCoeff == (int)SkXfermode::kISA_Coeff);
+GR_STATIC_ASSERT((int)kDA_GrBlendCoeff == (int)SkXfermode::kDA_Coeff);
+GR_STATIC_ASSERT((int)kIDA_GrBlendCoeff == (int)SkXfermode::kIDA_Coeff);
#define sk_blend_to_grblend(X) ((GrBlendCoeff)(X))
diff --git a/src/gpu/GrAAConvexPathRenderer.cpp b/src/gpu/GrAAConvexPathRenderer.cpp
index ca7ecdc..74b2608 100644
--- a/src/gpu/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/GrAAConvexPathRenderer.cpp
@@ -435,7 +435,7 @@
const GrDrawTarget* target,
bool antiAlias) const {
if (!target->getCaps().fShaderDerivativeSupport || !antiAlias ||
- kHairLine_PathFill == fill || GrIsFillInverted(fill) ||
+ kHairLine_GrPathFill == fill || GrIsFillInverted(fill) ||
!path.isConvex()) {
return false;
} else {
@@ -511,7 +511,7 @@
create_vertices(segments, fanPt, verts, idxs);
drawState->setVertexEdgeType(GrDrawState::kQuad_EdgeType);
- target->drawIndexed(kTriangles_PrimitiveType,
+ target->drawIndexed(kTriangles_GrPrimitiveType,
0, // start vertex
0, // start index
vCount,
diff --git a/src/gpu/GrAAHairLinePathRenderer.cpp b/src/gpu/GrAAHairLinePathRenderer.cpp
index 701bf3a..3893b9d 100644
--- a/src/gpu/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/GrAAHairLinePathRenderer.cpp
@@ -578,7 +578,7 @@
GrPathFill fill,
const GrDrawTarget* target,
bool antiAlias) const {
- if (fill != kHairLine_PathFill || !antiAlias) {
+ if (fill != kHairLine_GrPathFill || !antiAlias) {
return false;
}
@@ -635,7 +635,7 @@
while (lines < lineCnt) {
int n = GrMin(lineCnt - lines, nBufLines);
drawState->setVertexEdgeType(GrDrawState::kHairLine_EdgeType);
- target->drawIndexed(kTriangles_PrimitiveType,
+ target->drawIndexed(kTriangles_GrPrimitiveType,
kVertsPerLineSeg*lines, // startV
0, // startI
kVertsPerLineSeg*n, // vCount
@@ -648,7 +648,7 @@
while (quads < quadCnt) {
int n = GrMin(quadCnt - quads, kNumQuadsInIdxBuffer);
drawState->setVertexEdgeType(GrDrawState::kHairQuad_EdgeType);
- target->drawIndexed(kTriangles_PrimitiveType,
+ target->drawIndexed(kTriangles_GrPrimitiveType,
4 * lineCnt + kVertsPerQuad*quads, // startV
0, // startI
kVertsPerQuad*n, // vCount
diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp
index e31b5f3..c0272bb 100644
--- a/src/gpu/GrClipMaskManager.cpp
+++ b/src/gpu/GrClipMaskManager.cpp
@@ -102,7 +102,7 @@
// that need to be checked here
if (clipIn.getDoAA(i)) {
// Antialiased rects are converted to paths and then drawn with
- // kEvenOdd_PathFill.
+ // kEvenOdd_GrPathFill.
// TODO: wrap GrContext::fillAARect in a helper class and
// draw AA rects directly rather than converting to paths
@@ -110,7 +110,7 @@
temp.addRect(clipIn.getRect(i));
if (path_needs_SW_renderer(this->getContext(), gpu, temp,
- kEvenOdd_PathFill, true)) {
+ kEvenOdd_GrPathFill, true)) {
useSW = true;
}
}
@@ -361,22 +361,22 @@
switch (op) {
case SkRegion::kReplace_Op:
- drawState->setBlendFunc(kOne_BlendCoeff, kZero_BlendCoeff);
+ drawState->setBlendFunc(kOne_GrBlendCoeff, kZero_GrBlendCoeff);
break;
case SkRegion::kIntersect_Op:
- drawState->setBlendFunc(kDC_BlendCoeff, kZero_BlendCoeff);
+ drawState->setBlendFunc(kDC_GrBlendCoeff, kZero_GrBlendCoeff);
break;
case SkRegion::kUnion_Op:
- drawState->setBlendFunc(kOne_BlendCoeff, kISC_BlendCoeff);
+ drawState->setBlendFunc(kOne_GrBlendCoeff, kISC_GrBlendCoeff);
break;
case SkRegion::kXOR_Op:
- drawState->setBlendFunc(kIDC_BlendCoeff, kISC_BlendCoeff);
+ drawState->setBlendFunc(kIDC_GrBlendCoeff, kISC_GrBlendCoeff);
break;
case SkRegion::kDifference_Op:
- drawState->setBlendFunc(kZero_BlendCoeff, kISC_BlendCoeff);
+ drawState->setBlendFunc(kZero_GrBlendCoeff, kISC_GrBlendCoeff);
break;
case SkRegion::kReverseDifference_Op:
- drawState->setBlendFunc(kIDC_BlendCoeff, kZero_BlendCoeff);
+ drawState->setBlendFunc(kIDC_GrBlendCoeff, kZero_GrBlendCoeff);
break;
default:
GrAssert(false);
@@ -419,7 +419,7 @@
temp.addRect(clipIn.getRect(index));
return draw_path(this->getContext(), gpu, temp,
- kEvenOdd_PathFill, clipIn.getDoAA(index));
+ kEvenOdd_GrPathFill, clipIn.getDoAA(index));
} else {
gpu->drawSimpleRect(clipIn.getRect(index), NULL, 0);
}
@@ -771,7 +771,7 @@
const SkPath* clipPath = NULL;
if (kRect_ClipType == clipCopy.getElementType(c)) {
canRenderDirectToStencil = true;
- fill = kEvenOdd_PathFill;
+ fill = kEvenOdd_GrPathFill;
fillInverted = false;
// there is no point in intersecting a screen filling
// rectangle.
@@ -960,18 +960,18 @@
GrPathFill invert_fill(GrPathFill fill) {
static const GrPathFill gInvertedFillTable[] = {
- kInverseWinding_PathFill, // kWinding_PathFill
- kInverseEvenOdd_PathFill, // kEvenOdd_PathFill
- kWinding_PathFill, // kInverseWinding_PathFill
- kEvenOdd_PathFill, // kInverseEvenOdd_PathFill
- kHairLine_PathFill, // kHairLine_PathFill
+ kInverseWinding_GrPathFill, // kWinding_GrPathFill
+ kInverseEvenOdd_GrPathFill, // kEvenOdd_GrPathFill
+ kWinding_GrPathFill, // kInverseWinding_GrPathFill
+ kEvenOdd_GrPathFill, // kInverseEvenOdd_GrPathFill
+ kHairLine_GrPathFill, // kHairLine_GrPathFill
};
- GR_STATIC_ASSERT(0 == kWinding_PathFill);
- GR_STATIC_ASSERT(1 == kEvenOdd_PathFill);
- GR_STATIC_ASSERT(2 == kInverseWinding_PathFill);
- GR_STATIC_ASSERT(3 == kInverseEvenOdd_PathFill);
- GR_STATIC_ASSERT(4 == kHairLine_PathFill);
- GR_STATIC_ASSERT(5 == kPathFillCount);
+ GR_STATIC_ASSERT(0 == kWinding_GrPathFill);
+ GR_STATIC_ASSERT(1 == kEvenOdd_GrPathFill);
+ GR_STATIC_ASSERT(2 == kInverseWinding_GrPathFill);
+ GR_STATIC_ASSERT(3 == kInverseEvenOdd_GrPathFill);
+ GR_STATIC_ASSERT(4 == kHairLine_GrPathFill);
+ GR_STATIC_ASSERT(5 == kGrPathFillCount);
return gInvertedFillTable[fill];
}
@@ -1038,7 +1038,7 @@
temp.addRect(clipIn.getRect(i));
helper.draw(temp, SkRegion::kReplace_Op,
- kInverseEvenOdd_PathFill, clipIn.getDoAA(i),
+ kInverseEvenOdd_GrPathFill, clipIn.getDoAA(i),
0x00000000);
} else {
GrAssert(kPath_ClipType == clipIn.getElementType(i));
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index bbca09a..1c55ecf 100644
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -394,7 +394,7 @@
texture->height(),
2*sizeof(GrPoint));
verts[1].setIRectFan(0, 0, 1, 1, 2*sizeof(GrPoint));
- fGpu->drawNonIndexed(kTriangleFan_PrimitiveType,
+ fGpu->drawNonIndexed(kTriangleFan_GrPrimitiveType,
0, 4);
entry.set(fTextureCache->createAndLock(resourceKey, texture));
}
@@ -800,7 +800,7 @@
target->setIndexSourceToBuffer(indexBuffer);
- target->drawIndexed(kTriangles_PrimitiveType, 0,
+ target->drawIndexed(kTriangles_GrPrimitiveType, 0,
0, 8, this->aaFillRectIndexCount());
}
@@ -874,7 +874,7 @@
}
target->setIndexSourceToBuffer(indexBuffer);
- target->drawIndexed(kTriangles_PrimitiveType,
+ target->drawIndexed(kTriangles_GrPrimitiveType,
0, 0, 16, aaStrokeRectIndexCount());
}
@@ -1002,12 +1002,12 @@
if (width > 0) {
vertCount = 10;
- primType = kTriangleStrip_PrimitiveType;
+ primType = kTriangleStrip_GrPrimitiveType;
setStrokeRectStrip(vertex, rect, width);
} else {
// hairline
vertCount = 5;
- primType = kLineStrip_PrimitiveType;
+ primType = kLineStrip_GrPrimitiveType;
vertex[0].set(rect.fLeft, rect.fTop);
vertex[1].set(rect.fRight, rect.fTop);
vertex[2].set(rect.fRight, rect.fBottom);
@@ -1046,7 +1046,7 @@
drawState->preConcatViewMatrix(m);
drawState->preConcatSamplerMatrices(stageMask, m);
- target->drawNonIndexed(kTriangleFan_PrimitiveType, 0, 4);
+ target->drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4);
#else
target->drawSimpleRect(rect, matrix, stageMask);
#endif
@@ -1105,7 +1105,7 @@
return;
}
target->setVertexSourceToBuffer(layout, sqVB);
- target->drawNonIndexed(kTriangleFan_PrimitiveType, 0, 4);
+ target->drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4);
#else
GrDrawTarget* target;
@@ -1250,7 +1250,7 @@
SkPath path;
path.addOval(rect);
GrPathFill fill = (strokeWidth == 0) ?
- kHairLine_PathFill : kWinding_PathFill;
+ kHairLine_GrPathFill : kWinding_GrPathFill;
this->internalDrawPath(paint, path, fill, NULL);
return;
}
@@ -1309,7 +1309,7 @@
}
drawState->setVertexEdgeType(GrDrawState::kCircle_EdgeType);
- target->drawNonIndexed(kTriangleStrip_PrimitiveType, 0, 4);
+ target->drawNonIndexed(kTriangleStrip_GrPrimitiveType, 0, 4);
}
void GrContext::drawPath(const GrPaint& paint, const SkPath& path,
@@ -1327,7 +1327,7 @@
if (translate) {
ovalRect.offset(*translate);
}
- SkScalar width = (fill == kHairLine_PathFill) ? 0 : -SK_Scalar1;
+ SkScalar width = (fill == kHairLine_GrPathFill) ? 0 : -SK_Scalar1;
this->drawOval(paint, ovalRect, width);
return;
}
@@ -1740,7 +1740,7 @@
return;
}
((GrPoint*)geo.vertices())->setIRectFan(0, 0, width, height);
- fGpu->drawNonIndexed(kTriangleFan_PrimitiveType, 0, VCOUNT);
+ fGpu->drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, VCOUNT);
}
////////////////////////////////////////////////////////////////////////////////
diff --git a/src/gpu/GrDefaultPathRenderer.cpp b/src/gpu/GrDefaultPathRenderer.cpp
index e0f36a3..feb6a99 100644
--- a/src/gpu/GrDefaultPathRenderer.cpp
+++ b/src/gpu/GrDefaultPathRenderer.cpp
@@ -154,7 +154,7 @@
#if STENCIL_OFF
return true;
#else
- if (kEvenOdd_PathFill == fill || kWinding_PathFill == fill) {
+ if (kEvenOdd_GrPathFill == fill || kWinding_GrPathFill == fill) {
return path.isConvex();
}
return false;
@@ -174,7 +174,7 @@
// when drawing lines we're appending line segments along
// the contour. When applying the other fill rules we're
// drawing triangle fans around fanCenterIdx.
- if (kHairLine_PathFill != fillType) {
+ if (kHairLine_GrPathFill != fillType) {
*((*indices)++) = fanCenterIdx;
}
*((*indices)++) = edgeV0Idx;
@@ -217,19 +217,19 @@
bool indexed = contourCnt > 1;
int maxIdxs = 0;
- if (kHairLine_PathFill == fill) {
+ if (kHairLine_GrPathFill == fill) {
if (indexed) {
maxIdxs = 2 * maxPts;
- *primType = kLines_PrimitiveType;
+ *primType = kLines_GrPrimitiveType;
} else {
- *primType = kLineStrip_PrimitiveType;
+ *primType = kLineStrip_GrPrimitiveType;
}
} else {
if (indexed) {
maxIdxs = 3 * maxPts;
- *primType = kTriangles_PrimitiveType;
+ *primType = kTriangles_GrPrimitiveType;
} else {
- *primType = kTriangleFan_PrimitiveType;
+ *primType = kTriangleFan_GrPrimitiveType;
}
}
@@ -371,7 +371,7 @@
bool reverse = false;
bool lastPassIsBounds;
- if (kHairLine_PathFill == fill) {
+ if (kHairLine_GrPathFill == fill) {
passCount = 1;
if (stencilOnly) {
passes[0] = &gDirectToStencil;
@@ -392,10 +392,10 @@
lastPassIsBounds = false;
} else {
switch (fill) {
- case kInverseEvenOdd_PathFill:
+ case kInverseEvenOdd_GrPathFill:
reverse = true;
// fallthrough
- case kEvenOdd_PathFill:
+ case kEvenOdd_GrPathFill:
passes[0] = &gEOStencilPass;
if (stencilOnly) {
passCount = 1;
@@ -412,10 +412,10 @@
drawFace[0] = drawFace[1] = GrDrawState::kBoth_DrawFace;
break;
- case kInverseWinding_PathFill:
+ case kInverseWinding_GrPathFill:
reverse = true;
// fallthrough
- case kWinding_PathFill:
+ case kWinding_GrPathFill:
if (fSeparateStencil) {
if (fStencilWrapOps) {
passes[0] = &gWindStencilSeparateWithWrap;
@@ -540,7 +540,7 @@
void GrDefaultPathRenderer::drawPathToStencil(const SkPath& path,
GrPathFill fill,
GrDrawTarget* target) {
- GrAssert(kInverseEvenOdd_PathFill != fill);
- GrAssert(kInverseWinding_PathFill != fill);
+ GrAssert(kInverseEvenOdd_GrPathFill != fill);
+ GrAssert(kInverseWinding_GrPathFill != fill);
this->internalDrawPath(path, fill, NULL, target, 0, true);
}
diff --git a/src/gpu/GrDefaultTextContext.cpp b/src/gpu/GrDefaultTextContext.cpp
index 8bc4c68..d3d4e52 100644
--- a/src/gpu/GrDefaultTextContext.cpp
+++ b/src/gpu/GrDefaultTextContext.cpp
@@ -37,14 +37,14 @@
drawState->setTexture(kGlyphMaskStage, fCurrTexture);
if (!GrPixelConfigIsAlphaOnly(fCurrTexture->config())) {
- if (kOne_BlendCoeff != fGrPaint.fSrcBlendCoeff ||
- kISA_BlendCoeff != fGrPaint.fDstBlendCoeff ||
+ if (kOne_GrBlendCoeff != fGrPaint.fSrcBlendCoeff ||
+ kISA_GrBlendCoeff != fGrPaint.fDstBlendCoeff ||
fGrPaint.hasTexture()) {
GrPrintf("LCD Text will not draw correctly.\n");
}
// setup blend so that we get mask * paintColor + (1-mask)*dstColor
drawState->setBlendConstant(fGrPaint.fColor);
- drawState->setBlendFunc(kConstC_BlendCoeff, kISC_BlendCoeff);
+ drawState->setBlendFunc(kConstC_GrBlendCoeff, kISC_GrBlendCoeff);
// don't modulate by the paint's color in the frag since we're
// already doing it via the blend const.
drawState->setColor(0xffffffff);
@@ -56,7 +56,7 @@
fDrawTarget->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
int nGlyphs = fCurrVertex / 4;
- fDrawTarget->drawIndexedInstances(kTriangles_PrimitiveType,
+ fDrawTarget->drawIndexedInstances(kTriangles_GrPrimitiveType,
nGlyphs,
4, 6);
fVertices = NULL;
@@ -232,7 +232,7 @@
GrPoint translate;
translate.set(GrFixedToScalar(vx - GrIntToFixed(glyph->fBounds.fLeft)),
GrFixedToScalar(vy - GrIntToFixed(glyph->fBounds.fTop)));
- fContext->drawPath(fGrPaint, *glyph->fPath, kWinding_PathFill,
+ fContext->drawPath(fGrPaint, *glyph->fPath, kWinding_GrPathFill,
&translate);
return;
}
diff --git a/src/gpu/GrDrawState.h b/src/gpu/GrDrawState.h
index 23d05bc..e56b98f 100644
--- a/src/gpu/GrDrawState.h
+++ b/src/gpu/GrDrawState.h
@@ -82,8 +82,8 @@
fCoverage = 0xffffffff;
fFirstCoverageStage = kNumStages;
fColorFilterMode = SkXfermode::kDst_Mode;
- fSrcBlend = kOne_BlendCoeff;
- fDstBlend = kZero_BlendCoeff;
+ fSrcBlend = kOne_GrBlendCoeff;
+ fDstBlend = kZero_GrBlendCoeff;
fViewMatrix.reset();
fBehaviorBits = 0;
@@ -289,10 +289,10 @@
fDstBlend = dstCoeff;
#if GR_DEBUG
switch (dstCoeff) {
- case kDC_BlendCoeff:
- case kIDC_BlendCoeff:
- case kDA_BlendCoeff:
- case kIDA_BlendCoeff:
+ case kDC_GrBlendCoeff:
+ case kIDC_GrBlendCoeff:
+ case kDA_GrBlendCoeff:
+ case kIDA_GrBlendCoeff:
GrPrintf("Unexpected dst blend coeff. Won't work correctly with"
"coverage stages.\n");
break;
@@ -300,10 +300,10 @@
break;
}
switch (srcCoeff) {
- case kSC_BlendCoeff:
- case kISC_BlendCoeff:
- case kSA_BlendCoeff:
- case kISA_BlendCoeff:
+ case kSC_GrBlendCoeff:
+ case kISC_GrBlendCoeff:
+ case kSA_GrBlendCoeff:
+ case kISA_GrBlendCoeff:
GrPrintf("Unexpected src blend coeff. Won't work correctly with"
"coverage stages.\n");
break;
@@ -325,10 +325,10 @@
/**
* Sets the blending function constant referenced by the following blending
* coeffecients:
- * kConstC_BlendCoeff
- * kIConstC_BlendCoeff
- * kConstA_BlendCoeff
- * kIConstA_BlendCoeff
+ * kConstC_GrBlendCoeff
+ * kIConstC_GrBlendCoeff
+ * kConstA_GrBlendCoeff
+ * kIConstA_GrBlendCoeff
*
* @param constant the constant to set
*/
diff --git a/src/gpu/GrDrawTarget.cpp b/src/gpu/GrDrawTarget.cpp
index 2f7bf84..bc373ba 100644
--- a/src/gpu/GrDrawTarget.cpp
+++ b/src/gpu/GrDrawTarget.cpp
@@ -788,8 +788,8 @@
return false;
}
if (GrPixelConfigIsUnpremultiplied(drawState.getRenderTarget()->config())) {
- if (kOne_BlendCoeff != drawState.getSrcBlendCoeff() ||
- kZero_BlendCoeff != drawState.getDstBlendCoeff()) {
+ if (kOne_GrBlendCoeff != drawState.getSrcBlendCoeff() ||
+ kZero_GrBlendCoeff != drawState.getDstBlendCoeff()) {
return false;
}
}
@@ -847,9 +847,9 @@
* coeffecient in terms of S' and D.
*/
GrBlendCoeff dstCoeff = this->getDrawState().getDstBlendCoeff();
- return kOne_BlendCoeff == dstCoeff ||
- kISA_BlendCoeff == dstCoeff ||
- kISC_BlendCoeff == dstCoeff;
+ return kOne_GrBlendCoeff == dstCoeff ||
+ kISA_GrBlendCoeff == dstCoeff ||
+ kISC_GrBlendCoeff == dstCoeff;
}
bool GrDrawTarget::srcAlphaWillBeOne(GrVertexLayout layout) const {
@@ -915,32 +915,32 @@
*dstCoeff = drawState.getDstBlendCoeff();
// We don't ever expect source coeffecients to reference the source
- GrAssert(kSA_BlendCoeff != *srcCoeff &&
- kISA_BlendCoeff != *srcCoeff &&
- kSC_BlendCoeff != *srcCoeff &&
- kISC_BlendCoeff != *srcCoeff);
+ GrAssert(kSA_GrBlendCoeff != *srcCoeff &&
+ kISA_GrBlendCoeff != *srcCoeff &&
+ kSC_GrBlendCoeff != *srcCoeff &&
+ kISC_GrBlendCoeff != *srcCoeff);
// same for dst
- GrAssert(kDA_BlendCoeff != *dstCoeff &&
- kIDA_BlendCoeff != *dstCoeff &&
- kDC_BlendCoeff != *dstCoeff &&
- kIDC_BlendCoeff != *dstCoeff);
+ GrAssert(kDA_GrBlendCoeff != *dstCoeff &&
+ kIDA_GrBlendCoeff != *dstCoeff &&
+ kDC_GrBlendCoeff != *dstCoeff &&
+ kIDC_GrBlendCoeff != *dstCoeff);
if (drawState.isColorWriteDisabled()) {
- *srcCoeff = kZero_BlendCoeff;
- *dstCoeff = kOne_BlendCoeff;
+ *srcCoeff = kZero_GrBlendCoeff;
+ *dstCoeff = kOne_GrBlendCoeff;
}
bool srcAIsOne = this->srcAlphaWillBeOne(layout);
- bool dstCoeffIsOne = kOne_BlendCoeff == *dstCoeff ||
- (kSA_BlendCoeff == *dstCoeff && srcAIsOne);
- bool dstCoeffIsZero = kZero_BlendCoeff == *dstCoeff ||
- (kISA_BlendCoeff == *dstCoeff && srcAIsOne);
+ bool dstCoeffIsOne = kOne_GrBlendCoeff == *dstCoeff ||
+ (kSA_GrBlendCoeff == *dstCoeff && srcAIsOne);
+ bool dstCoeffIsZero = kZero_GrBlendCoeff == *dstCoeff ||
+ (kISA_GrBlendCoeff == *dstCoeff && srcAIsOne);
// When coeffs are (0,1) there is no reason to draw at all, unless
// stenciling is enabled. Having color writes disabled is effectively
// (0,1). The same applies when coverage is known to be 0.
- if ((kZero_BlendCoeff == *srcCoeff && dstCoeffIsOne) ||
+ if ((kZero_GrBlendCoeff == *srcCoeff && dstCoeffIsOne) ||
(!(layout & kCoverage_VertexLayoutBit) &&
0 == drawState.getCoverage())) {
if (drawState.getStencil().doesWrite()) {
@@ -969,15 +969,15 @@
// has to read at all. If not, we'll disable blending.
if (!hasCoverage) {
if (dstCoeffIsZero) {
- if (kOne_BlendCoeff == *srcCoeff) {
+ if (kOne_GrBlendCoeff == *srcCoeff) {
// if there is no coverage and coeffs are (1,0) then we
// won't need to read the dst at all, it gets replaced by src
return kDisableBlend_BlendOptFlag;
- } else if (kZero_BlendCoeff == *srcCoeff) {
+ } else if (kZero_GrBlendCoeff == *srcCoeff) {
// if the op is "clear" then we don't need to emit a color
// or blend, just write transparent black into the dst.
- *srcCoeff = kOne_BlendCoeff;
- *dstCoeff = kZero_BlendCoeff;
+ *srcCoeff = kOne_GrBlendCoeff;
+ *dstCoeff = kZero_GrBlendCoeff;
return kDisableBlend_BlendOptFlag |
kEmitTransBlack_BlendOptFlag;
}
@@ -989,24 +989,24 @@
return kCoverageAsAlpha_BlendOptFlag;
}
if (dstCoeffIsZero) {
- if (kZero_BlendCoeff == *srcCoeff) {
+ if (kZero_GrBlendCoeff == *srcCoeff) {
// the source color is not included in the blend
// the dst coeff is effectively zero so blend works out to:
// (c)(0)D + (1-c)D = (1-c)D.
- *dstCoeff = kISA_BlendCoeff;
+ *dstCoeff = kISA_GrBlendCoeff;
return kEmitCoverage_BlendOptFlag;
} else if (srcAIsOne) {
// the dst coeff is effectively zero so blend works out to:
// cS + (c)(0)D + (1-c)D = cS + (1-c)D.
// If Sa is 1 then we can replace Sa with c
// and set dst coeff to 1-Sa.
- *dstCoeff = kISA_BlendCoeff;
+ *dstCoeff = kISA_GrBlendCoeff;
return kCoverageAsAlpha_BlendOptFlag;
}
} else if (dstCoeffIsOne) {
// the dst coeff is effectively one so blend works out to:
// cS + (c)(1)D + (1-c)D = cS + D.
- *dstCoeff = kOne_BlendCoeff;
+ *dstCoeff = kOne_GrBlendCoeff;
return kCoverageAsAlpha_BlendOptFlag;
}
}
@@ -1081,7 +1081,7 @@
SetRectVertices(rect, matrix, srcRects,
srcMatrices, layout, geo.vertices());
- drawNonIndexed(kTriangleFan_PrimitiveType, 0, 4);
+ drawNonIndexed(kTriangleFan_GrPrimitiveType, 0, 4);
}
GrVertexLayout GrDrawTarget::GetRectVertexLayout(StageMask stageMask,
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index baca824..d39ace0 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -35,12 +35,12 @@
enum ExtendedBlendCoeffs {
// source 2 refers to second output color when
// using dual source blending.
- kS2C_BlendCoeff = kPublicBlendCoeffCount,
- kIS2C_BlendCoeff,
- kS2A_BlendCoeff,
- kIS2A_BlendCoeff,
+ kS2C_GrBlendCoeff = kPublicGrBlendCoeffCount,
+ kIS2C_GrBlendCoeff,
+ kS2A_GrBlendCoeff,
+ kIS2A_GrBlendCoeff,
- kTotalBlendCoeffCount
+ kTotalGrBlendCoeffCount
};
/**
@@ -133,7 +133,7 @@
* Returns an index buffer that can be used to render quads.
* Six indices per quad: 0, 1, 2, 0, 2, 3, etc.
* The max number of quads can be queried using GrIndexBuffer::maxQuads().
- * Draw with kTriangles_PrimitiveType
+ * Draw with kTriangles_GrPrimitiveType
* @ return the quad index buffer
*/
const GrIndexBuffer* getQuadIndexBuffer() const;
diff --git a/src/gpu/GrInOrderDrawBuffer.cpp b/src/gpu/GrInOrderDrawBuffer.cpp
index 7b3b04f..7abe941 100644
--- a/src/gpu/GrInOrderDrawBuffer.cpp
+++ b/src/gpu/GrInOrderDrawBuffer.cpp
@@ -156,7 +156,7 @@
Draw& lastDraw = fDraws.back();
GrAssert(lastDraw.fIndexBuffer == fQuadIndexBuffer);
- GrAssert(kTriangles_PrimitiveType == lastDraw.fPrimitiveType);
+ GrAssert(kTriangles_GrPrimitiveType == lastDraw.fPrimitiveType);
GrAssert(0 == lastDraw.fVertexCount % 4);
GrAssert(0 == lastDraw.fIndexCount % 6);
GrAssert(0 == lastDraw.fStartIndex);
@@ -183,7 +183,7 @@
}
if (!appendToPreviousDraw) {
this->setIndexSourceToBuffer(fQuadIndexBuffer);
- this->drawIndexed(kTriangles_PrimitiveType, 0, 0, 4, 6);
+ this->drawIndexed(kTriangles_GrPrimitiveType, 0, 0, 4, 6);
fCurrQuad = 1;
fLastRectVertexLayout = layout;
}
diff --git a/src/gpu/GrIndexBuffer.h b/src/gpu/GrIndexBuffer.h
index faa5018..a7e7a57 100644
--- a/src/gpu/GrIndexBuffer.h
+++ b/src/gpu/GrIndexBuffer.h
@@ -17,7 +17,7 @@
public:
/**
* Retrieves the maximum number of quads that could be rendered
- * from the index buffer (using kTriangles_PrimitiveType).
+ * from the index buffer (using kTriangles_GrPrimitiveType).
* @return the maximum number of quads using full size of index buffer.
*/
int maxQuads() const {
diff --git a/src/gpu/GrPathRenderer.h b/src/gpu/GrPathRenderer.h
index ff9fdbb..4439f6c 100644
--- a/src/gpu/GrPathRenderer.h
+++ b/src/gpu/GrPathRenderer.h
@@ -120,7 +120,7 @@
/**
* Draws the path to the stencil buffer. Assume the writable stencil bits
* are already initialized to zero. Fill will always be either
- * kWinding_PathFill or kEvenOdd_PathFill.
+ * kWinding_GrPathFill or kEvenOdd_GrPathFill.
*
* Only called if requiresStencilPass returns true for the same combo of
* target, path, and fill. Never called with an inverse fill.
diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
index 817f55a..99209c6 100644
--- a/src/gpu/GrSoftwarePathRenderer.cpp
+++ b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -37,13 +37,13 @@
////////////////////////////////////////////////////////////////////////////////
SkPath::FillType gr_fill_to_sk_fill(GrPathFill fill) {
switch (fill) {
- case kWinding_PathFill:
+ case kWinding_GrPathFill:
return SkPath::kWinding_FillType;
- case kEvenOdd_PathFill:
+ case kEvenOdd_GrPathFill:
return SkPath::kEvenOdd_FillType;
- case kInverseWinding_PathFill:
+ case kInverseWinding_GrPathFill:
return SkPath::kInverseWinding_FillType;
- case kInverseEvenOdd_PathFill:
+ case kInverseEvenOdd_GrPathFill:
return SkPath::kInverseEvenOdd_FillType;
default:
GrCrash("Unexpected fill.");
@@ -141,7 +141,7 @@
SkPaint paint;
SkPath tmpPath;
const SkPath* pathToDraw = &clientPath;
- if (kHairLine_PathFill == fill) {
+ if (kHairLine_GrPathFill == fill) {
paint.setStyle(SkPaint::kStroke_Style);
paint.setStrokeWidth(SK_Scalar1);
} else {
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 7d9b4d9..b0ff43a 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -618,9 +618,9 @@
// must be in SkCanvas::PointMode order
static const GrPrimitiveType gPointMode2PrimtiveType[] = {
- kPoints_PrimitiveType,
- kLines_PrimitiveType,
- kLineStrip_PrimitiveType
+ kPoints_GrPrimitiveType,
+ kLines_GrPrimitiveType,
+ kLineStrip_GrPrimitiveType
};
void SkGpuDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode,
@@ -722,16 +722,16 @@
GrPathFill skToGrFillType(SkPath::FillType fillType) {
switch (fillType) {
case SkPath::kWinding_FillType:
- return kWinding_PathFill;
+ return kWinding_GrPathFill;
case SkPath::kEvenOdd_FillType:
- return kEvenOdd_PathFill;
+ return kEvenOdd_GrPathFill;
case SkPath::kInverseWinding_FillType:
- return kInverseWinding_PathFill;
+ return kInverseWinding_GrPathFill;
case SkPath::kInverseEvenOdd_FillType:
- return kInverseEvenOdd_PathFill;
+ return kInverseEvenOdd_GrPathFill;
default:
SkDebugf("Unsupported path fill type\n");
- return kHairLine_PathFill;
+ return kHairLine_GrPathFill;
}
}
@@ -830,8 +830,8 @@
// code path may not be taken. So we use a dst blend coeff of ISA. We
// could special case AA draws to a dst surface with known alpha=0 to
// use a zero dst coeff when dual source blending isn't available.
- tempPaint.fSrcBlendCoeff = kOne_BlendCoeff;
- tempPaint.fDstBlendCoeff = kISC_BlendCoeff;
+ tempPaint.fSrcBlendCoeff = kOne_GrBlendCoeff;
+ tempPaint.fDstBlendCoeff = kISC_GrBlendCoeff;
}
// Draw hard shadow to pathTexture with path topleft at origin 0,0.
context->drawPath(tempPaint, path, pathFillType, &offset);
@@ -856,18 +856,18 @@
paint.setTexture(0, pathTexture);
if (SkMaskFilter::kInner_BlurType == blurType) {
// inner: dst = dst * src
- paint.fSrcBlendCoeff = kDC_BlendCoeff;
- paint.fDstBlendCoeff = kZero_BlendCoeff;
+ paint.fSrcBlendCoeff = kDC_GrBlendCoeff;
+ paint.fDstBlendCoeff = kZero_GrBlendCoeff;
} else if (SkMaskFilter::kSolid_BlurType == blurType) {
// solid: dst = src + dst - src * dst
// = (1 - dst) * src + 1 * dst
- paint.fSrcBlendCoeff = kIDC_BlendCoeff;
- paint.fDstBlendCoeff = kOne_BlendCoeff;
+ paint.fSrcBlendCoeff = kIDC_GrBlendCoeff;
+ paint.fDstBlendCoeff = kOne_GrBlendCoeff;
} else if (SkMaskFilter::kOuter_BlurType == blurType) {
// outer: dst = dst * (1 - src)
// = 0 * src + (1 - src) * dst
- paint.fSrcBlendCoeff = kZero_BlendCoeff;
- paint.fDstBlendCoeff = kISC_BlendCoeff;
+ paint.fSrcBlendCoeff = kZero_GrBlendCoeff;
+ paint.fDstBlendCoeff = kISC_GrBlendCoeff;
}
context->drawRect(paint, srcRect);
}
@@ -1038,7 +1038,7 @@
// transform the path into device space
pathPtr->transform(*draw.fMatrix, devPathPtr);
GrPathFill pathFillType = doFill ?
- skToGrFillType(devPathPtr->getFillType()) : kHairLine_PathFill;
+ skToGrFillType(devPathPtr->getFillType()) : kHairLine_GrPathFill;
if (!drawWithGPUMaskFilter(fContext, *devPathPtr, paint.getMaskFilter(),
*draw.fMatrix, *draw.fClip, draw.fBounder,
&grPaint, pathFillType)) {
@@ -1051,21 +1051,21 @@
return;
}
- GrPathFill fill = kHairLine_PathFill;
+ GrPathFill fill = kHairLine_GrPathFill;
if (doFill) {
switch (pathPtr->getFillType()) {
case SkPath::kWinding_FillType:
- fill = kWinding_PathFill;
+ fill = kWinding_GrPathFill;
break;
case SkPath::kEvenOdd_FillType:
- fill = kEvenOdd_PathFill;
+ fill = kEvenOdd_GrPathFill;
break;
case SkPath::kInverseWinding_FillType:
- fill = kInverseWinding_PathFill;
+ fill = kInverseWinding_GrPathFill;
break;
case SkPath::kInverseEvenOdd_FillType:
- fill = kInverseEvenOdd_PathFill;
+ fill = kInverseEvenOdd_GrPathFill;
break;
default:
SkDebugf("Unsupported path fill type\n");
@@ -1613,9 +1613,9 @@
// must be in SkCanvas::VertexMode order
static const GrPrimitiveType gVertexMode2PrimitiveType[] = {
- kTriangles_PrimitiveType,
- kTriangleStrip_PrimitiveType,
- kTriangleFan_PrimitiveType,
+ kTriangles_GrPrimitiveType,
+ kTriangleStrip_GrPrimitiveType,
+ kTriangleFan_GrPrimitiveType,
};
void SkGpuDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 92a3aff..00a0282 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -179,16 +179,16 @@
GrPathFill SkGrClipIterator::getPathFill() const {
switch (fCurr->fPath->getFillType()) {
case SkPath::kWinding_FillType:
- return kWinding_PathFill;
+ return kWinding_GrPathFill;
case SkPath::kEvenOdd_FillType:
- return kEvenOdd_PathFill;
+ return kEvenOdd_GrPathFill;
case SkPath::kInverseWinding_FillType:
- return kInverseWinding_PathFill;
+ return kInverseWinding_GrPathFill;
case SkPath::kInverseEvenOdd_FillType:
- return kInverseEvenOdd_PathFill;
+ return kInverseEvenOdd_GrPathFill;
default:
GrCrash("Unsupported path fill in clip.");
- return kWinding_PathFill; // suppress warning
+ return kWinding_GrPathFill; // suppress warning
}
}
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index b1d6d4f..3202d39 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -112,7 +112,7 @@
case ProgramDesc::kCoverage_DualSrcOutput:
case ProgramDesc::kCoverageISA_DualSrcOutput:
case ProgramDesc::kCoverageISC_DualSrcOutput:
- *dstCoeff = (GrBlendCoeff)GrGpu::kIS2C_BlendCoeff;
+ *dstCoeff = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
break;
default:
GrCrash("Unexpected dual source blend output");
diff --git a/src/gpu/gl/GrGpuGL.cpp b/src/gpu/gl/GrGpuGL.cpp
index 82a65fd..d5c0bd2 100644
--- a/src/gpu/gl/GrGpuGL.cpp
+++ b/src/gpu/gl/GrGpuGL.cpp
@@ -83,30 +83,32 @@
false,
};
return gCoeffReferencesBlendConst[coeff];
- GR_STATIC_ASSERT(kTotalBlendCoeffCount == GR_ARRAY_COUNT(gCoeffReferencesBlendConst));
+ GR_STATIC_ASSERT(kTotalGrBlendCoeffCount ==
+ GR_ARRAY_COUNT(gCoeffReferencesBlendConst));
- GR_STATIC_ASSERT(0 == kZero_BlendCoeff);
- GR_STATIC_ASSERT(1 == kOne_BlendCoeff);
- GR_STATIC_ASSERT(2 == kSC_BlendCoeff);
- GR_STATIC_ASSERT(3 == kISC_BlendCoeff);
- GR_STATIC_ASSERT(4 == kDC_BlendCoeff);
- GR_STATIC_ASSERT(5 == kIDC_BlendCoeff);
- GR_STATIC_ASSERT(6 == kSA_BlendCoeff);
- GR_STATIC_ASSERT(7 == kISA_BlendCoeff);
- GR_STATIC_ASSERT(8 == kDA_BlendCoeff);
- GR_STATIC_ASSERT(9 == kIDA_BlendCoeff);
- GR_STATIC_ASSERT(10 == kConstC_BlendCoeff);
- GR_STATIC_ASSERT(11 == kIConstC_BlendCoeff);
- GR_STATIC_ASSERT(12 == kConstA_BlendCoeff);
- GR_STATIC_ASSERT(13 == kIConstA_BlendCoeff);
+ GR_STATIC_ASSERT(0 == kZero_GrBlendCoeff);
+ GR_STATIC_ASSERT(1 == kOne_GrBlendCoeff);
+ GR_STATIC_ASSERT(2 == kSC_GrBlendCoeff);
+ GR_STATIC_ASSERT(3 == kISC_GrBlendCoeff);
+ GR_STATIC_ASSERT(4 == kDC_GrBlendCoeff);
+ GR_STATIC_ASSERT(5 == kIDC_GrBlendCoeff);
+ GR_STATIC_ASSERT(6 == kSA_GrBlendCoeff);
+ GR_STATIC_ASSERT(7 == kISA_GrBlendCoeff);
+ GR_STATIC_ASSERT(8 == kDA_GrBlendCoeff);
+ GR_STATIC_ASSERT(9 == kIDA_GrBlendCoeff);
+ GR_STATIC_ASSERT(10 == kConstC_GrBlendCoeff);
+ GR_STATIC_ASSERT(11 == kIConstC_GrBlendCoeff);
+ GR_STATIC_ASSERT(12 == kConstA_GrBlendCoeff);
+ GR_STATIC_ASSERT(13 == kIConstA_GrBlendCoeff);
- GR_STATIC_ASSERT(14 == kS2C_BlendCoeff);
- GR_STATIC_ASSERT(15 == kIS2C_BlendCoeff);
- GR_STATIC_ASSERT(16 == kS2A_BlendCoeff);
- GR_STATIC_ASSERT(17 == kIS2A_BlendCoeff);
+ GR_STATIC_ASSERT(14 == kS2C_GrBlendCoeff);
+ GR_STATIC_ASSERT(15 == kIS2C_GrBlendCoeff);
+ GR_STATIC_ASSERT(16 == kS2A_GrBlendCoeff);
+ GR_STATIC_ASSERT(17 == kIS2A_GrBlendCoeff);
// assertion for gXfermodeCoeff2Blend have to be in GrGpu scope
- GR_STATIC_ASSERT(kTotalBlendCoeffCount == GR_ARRAY_COUNT(gXfermodeCoeff2Blend));
+ GR_STATIC_ASSERT(kTotalGrBlendCoeffCount ==
+ GR_ARRAY_COUNT(gXfermodeCoeff2Blend));
}
///////////////////////////////////////////////////////////////////////////////
@@ -2005,19 +2007,19 @@
GL_CALL(Enable(GR_GL_BLEND));
fHWBlendState.fEnabled = kYes_TriState;
}
- if (kSA_BlendCoeff != fHWBlendState.fSrcCoeff ||
- kISA_BlendCoeff != fHWBlendState.fDstCoeff) {
- GL_CALL(BlendFunc(gXfermodeCoeff2Blend[kSA_BlendCoeff],
- gXfermodeCoeff2Blend[kISA_BlendCoeff]));
- fHWBlendState.fSrcCoeff = kSA_BlendCoeff;
- fHWBlendState.fDstCoeff = kISA_BlendCoeff;
+ if (kSA_GrBlendCoeff != fHWBlendState.fSrcCoeff ||
+ kISA_GrBlendCoeff != fHWBlendState.fDstCoeff) {
+ GL_CALL(BlendFunc(gXfermodeCoeff2Blend[kSA_GrBlendCoeff],
+ gXfermodeCoeff2Blend[kISA_GrBlendCoeff]));
+ fHWBlendState.fSrcCoeff = kSA_GrBlendCoeff;
+ fHWBlendState.fDstCoeff = kISA_GrBlendCoeff;
}
} else {
// any optimization to disable blending should
// have already been applied and tweaked the coeffs
// to (1, 0).
- bool blendOff = kOne_BlendCoeff == srcCoeff &&
- kZero_BlendCoeff == dstCoeff;
+ bool blendOff = kOne_GrBlendCoeff == srcCoeff &&
+ kZero_GrBlendCoeff == dstCoeff;
if (blendOff) {
if (kNo_TriState != fHWBlendState.fEnabled) {
GL_CALL(Disable(GR_GL_BLEND));
diff --git a/src/gpu/gl/GrGpuGL.h b/src/gpu/gl/GrGpuGL.h
index df729a7..2906170 100644
--- a/src/gpu/gl/GrGpuGL.h
+++ b/src/gpu/gl/GrGpuGL.h
@@ -331,8 +331,8 @@
TriState fEnabled;
void invalidate() {
- fSrcCoeff = kInvalid_BlendCoeff;
- fDstCoeff = kInvalid_BlendCoeff;
+ fSrcCoeff = kInvalid_GrBlendCoeff;
+ fDstCoeff = kInvalid_GrBlendCoeff;
fConstColorValid = false;
fEnabled = kUnknown_TriState;
}
diff --git a/src/gpu/gl/GrGpuGL_program.cpp b/src/gpu/gl/GrGpuGL_program.cpp
index 581a22a..d8299ff 100644
--- a/src/gpu/gl/GrGpuGL_program.cpp
+++ b/src/gpu/gl/GrGpuGL_program.cpp
@@ -657,7 +657,7 @@
// Must initialize all fields or cache will have false negatives!
desc.fVertexLayout = this->getVertexLayout();
- desc.fEmitsPointSize = kPoints_PrimitiveType == type;
+ desc.fEmitsPointSize = kPoints_GrPrimitiveType == type;
bool requiresAttributeColors =
!skipColor && SkToBool(desc.fVertexLayout & kColor_VertexLayoutBit);
@@ -847,16 +847,16 @@
if (this->getCaps().fDualSourceBlendingSupport &&
!(blendOpts & (kEmitCoverage_BlendOptFlag |
kCoverageAsAlpha_BlendOptFlag))) {
- if (kZero_BlendCoeff == dstCoeff) {
+ if (kZero_GrBlendCoeff == dstCoeff) {
// write the coverage value to second color
desc.fDualSrcOutput = ProgramDesc::kCoverage_DualSrcOutput;
desc.fFirstCoverageStage = firstCoverageStage;
- } else if (kSA_BlendCoeff == dstCoeff) {
+ } else if (kSA_GrBlendCoeff == dstCoeff) {
// SA dst coeff becomes 1-(1-SA)*coverage when dst is partially
// cover
desc.fDualSrcOutput = ProgramDesc::kCoverageISA_DualSrcOutput;
desc.fFirstCoverageStage = firstCoverageStage;
- } else if (kSC_BlendCoeff == dstCoeff) {
+ } else if (kSC_GrBlendCoeff == dstCoeff) {
// SA dst coeff becomes 1-(1-SA)*coverage when dst is partially
// cover
desc.fDualSrcOutput = ProgramDesc::kCoverageISC_DualSrcOutput;