Unify edge type enums across GrEffect subclasses that clip rendering to a geometry.
BUG=skia:
R=egdaniel@google.com, robertphillips@google.com
Author: bsalomon@google.com
Review URL: https://codereview.chromium.org/183893023
git-svn-id: http://skia.googlecode.com/svn/trunk@13674 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/expectations/gm/ignored-tests.txt b/expectations/gm/ignored-tests.txt
index d2de911..dec7f8d 100644
--- a/expectations/gm/ignored-tests.txt
+++ b/expectations/gm/ignored-tests.txt
@@ -36,3 +36,9 @@
# This GM has probably always drawn incorrectly. We need to clarify the API
# http://skbug.com/2222 : Inverse filled paths get inverse stroked
inverse_paths
+
+# bsalomon: the order in which the edge types draw has changed.
+# https://codereview.chromium.org/183893023
+bezier_quad_effects
+bezier_conic_effects
+bezier_cubic_effects
diff --git a/gm/beziereffects.cpp b/gm/beziereffects.cpp
index 87e2d0a..aebf6fb 100644
--- a/gm/beziereffects.cpp
+++ b/gm/beziereffects.cpp
@@ -93,7 +93,21 @@
{rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
{rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)}
};
- for(int edgeType = kFillAA_GrBezierEdgeType; edgeType < 3; ++edgeType) {
+ for(int edgeType = 0; edgeType < kGrEffectEdgeTypeCnt; ++edgeType) {
+ SkAutoTUnref<GrEffectRef> effect;
+ { // scope to contain GrTestTarget
+ GrTestTarget tt;
+ context->getTestTarget(&tt);
+ if (NULL == tt.target()) {
+ continue;
+ }
+ GrEffectEdgeType et = (GrEffectEdgeType)edgeType;
+ effect.reset(GrCubicEffect::Create(et, *tt.target()->caps()));
+ if (!effect) {
+ continue;
+ }
+ }
+
SkScalar x = SkScalarMul(col, w);
SkScalar y = SkScalarMul(row, h);
SkPoint controlPts[] = {
@@ -153,17 +167,10 @@
GrTestTarget tt;
context->getTestTarget(&tt);
- if (NULL == tt.target()) {
- continue;
- }
+ SkASSERT(NULL != tt.target());
GrDrawState* drawState = tt.target()->drawState();
drawState->setVertexAttribs<kAttribs>(2);
- SkAutoTUnref<GrEffectRef> effect(GrCubicEffect::Create(
- GrBezierEdgeType(edgeType), *tt.target()->caps()));
- if (!effect) {
- continue;
- }
drawState->addCoverageEffect(effect, 1);
drawState->setRenderTarget(rt);
drawState->setColor(0xff000000);
@@ -245,7 +252,21 @@
{rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)}
};
SkScalar weight = rand.nextRangeF(0.f, 2.f);
- for(int edgeType = kFillAA_GrBezierEdgeType; edgeType < 3; ++edgeType) {
+ for(int edgeType = 0; edgeType < kGrEffectEdgeTypeCnt; ++edgeType) {
+ SkAutoTUnref<GrEffectRef> effect;
+ { // scope to contain GrTestTarget
+ GrTestTarget tt;
+ context->getTestTarget(&tt);
+ if (NULL == tt.target()) {
+ continue;
+ }
+ GrEffectEdgeType et = (GrEffectEdgeType)edgeType;
+ effect.reset(GrConicEffect::Create(et, *tt.target()->caps()));
+ if (!effect) {
+ continue;
+ }
+ }
+
SkScalar x = SkScalarMul(col, w);
SkScalar y = SkScalarMul(row, h);
SkPoint controlPts[] = {
@@ -302,17 +323,10 @@
GrTestTarget tt;
context->getTestTarget(&tt);
- if (NULL == tt.target()) {
- continue;
- }
+ SkASSERT(NULL != tt.target());
GrDrawState* drawState = tt.target()->drawState();
drawState->setVertexAttribs<kAttribs>(2);
- SkAutoTUnref<GrEffectRef> effect(GrConicEffect::Create(
- GrBezierEdgeType(edgeType), *tt.target()->caps()));
- if (!effect) {
- continue;
- }
drawState->addCoverageEffect(effect, 1);
drawState->setRenderTarget(rt);
drawState->setColor(0xff000000);
@@ -428,7 +442,21 @@
{rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)},
{rand.nextRangeF(0.f, w), rand.nextRangeF(0.f, h)}
};
- for(int edgeType = kFillAA_GrBezierEdgeType; edgeType < 3; ++edgeType) {
+ for(int edgeType = 0; edgeType < kGrEffectEdgeTypeCnt; ++edgeType) {
+ SkAutoTUnref<GrEffectRef> effect;
+ { // scope to contain GrTestTarget
+ GrTestTarget tt;
+ context->getTestTarget(&tt);
+ if (NULL == tt.target()) {
+ continue;
+ }
+ GrEffectEdgeType et = (GrEffectEdgeType)edgeType;
+ effect.reset(GrQuadEffect::Create(et, *tt.target()->caps()));
+ if (!effect) {
+ continue;
+ }
+ }
+
SkScalar x = SkScalarMul(col, w);
SkScalar y = SkScalarMul(row, h);
SkPoint controlPts[] = {
@@ -480,16 +508,10 @@
GrTestTarget tt;
context->getTestTarget(&tt);
- if (NULL == tt.target()) {
- continue;
- }
+ SkASSERT(NULL != tt.target());
GrDrawState* drawState = tt.target()->drawState();
drawState->setVertexAttribs<kAttribs>(2);
- SkAutoTUnref<GrEffectRef> effect(GrQuadEffect::Create(
- GrBezierEdgeType(edgeType), *tt.target()->caps()));
- if (!effect) {
- continue;
- }
+
drawState->addCoverageEffect(effect, 1);
drawState->setRenderTarget(rt);
drawState->setColor(0xff000000);
diff --git a/gm/convexpolyeffect.cpp b/gm/convexpolyeffect.cpp
index 9142ca9..ac8ec72 100644
--- a/gm/convexpolyeffect.cpp
+++ b/gm/convexpolyeffect.cpp
@@ -120,7 +120,7 @@
const SkPath* path = iter.get();
SkScalar x = 0;
- for (int et = 0; et < GrConvexPolyEffect::kEdgeTypeCnt; ++et) {
+ for (int et = 0; et < kGrEffectEdgeTypeCnt; ++et) {
GrTestTarget tt;
context->getTestTarget(&tt);
if (NULL == tt.target()) {
@@ -135,11 +135,10 @@
m.setTranslate(x, y);
path->transform(m, &p);
- GrConvexPolyEffect::EdgeType edgeType = (GrConvexPolyEffect::EdgeType) et;
+ GrEffectEdgeType edgeType = (GrEffectEdgeType) et;
SkAutoTUnref<GrEffectRef> effect(GrConvexPolyEffect::Create(edgeType, p));
if (!effect) {
- SkDEBUGFAIL("Couldn't create convex poly effect.");
- return;
+ continue;
}
drawState->addCoverageEffect(effect, 1);
drawState->setIdentityViewMatrix();
@@ -179,7 +178,7 @@
SkScalar x = 0;
- for (int et = 0; et < GrConvexPolyEffect::kEdgeTypeCnt; ++et) {
+ for (int et = 0; et < kGrEffectEdgeTypeCnt; ++et) {
GrTestTarget tt;
context->getTestTarget(&tt);
if (NULL == tt.target()) {
@@ -188,11 +187,10 @@
}
SkRect rect = *iter.get();
rect.offset(x, y);
- GrConvexPolyEffect::EdgeType edgeType = (GrConvexPolyEffect::EdgeType) et;
+ GrEffectEdgeType edgeType = (GrEffectEdgeType) et;
SkAutoTUnref<GrEffectRef> effect(GrConvexPolyEffect::Create(edgeType, rect));
if (!effect) {
- SkDEBUGFAIL("Couldn't create convex poly effect.");
- return;
+ continue;
}
GrDrawState* drawState = tt.target()->drawState();
diff --git a/gm/rrects.cpp b/gm/rrects.cpp
index d92fb5a..7bc7c19 100644
--- a/gm/rrects.cpp
+++ b/gm/rrects.cpp
@@ -77,7 +77,7 @@
return;
}
if (kEffect_Type == fType) {
- numRRects *= GrRRectEffect::kEdgeTypeCnt;
+ numRRects *= kGrEffectEdgeTypeCnt;
}
#endif
@@ -111,8 +111,7 @@
SkRRect rrect = fRRects[rrectIdx];
rrect.offset(SkIntToScalar(x), SkIntToScalar(y));
- GrRRectEffect::EdgeType edgeType = (GrRRectEffect::EdgeType)
- (curRRect / kNumRRects);
+ GrEffectEdgeType edgeType = (GrEffectEdgeType) (curRRect / kNumRRects);
SkAutoTUnref<GrEffectRef> effect(GrRRectEffect::Create(edgeType, rrect));
if (effect) {
drawState->addCoverageEffect(effect);
diff --git a/include/gpu/GrTypesPriv.h b/include/gpu/GrTypesPriv.h
index 8888066..1fc6c8d 100644
--- a/include/gpu/GrTypesPriv.h
+++ b/include/gpu/GrTypesPriv.h
@@ -60,6 +60,8 @@
GR_STATIC_ASSERT(kVec4f_GrSLType == 4);
}
+//////////////////////////////////////////////////////////////////////////////
+
/**
* Types used to describe format of vertices in arrays.
*/
@@ -166,4 +168,53 @@
template <int N> class GrVertexAttribArray : public SkSTArray<N, GrVertexAttrib, true> {};
+//////////////////////////////////////////////////////////////////////////////
+
+/**
+* We have coverage effects that clip rendering to the edge of some geometric primitive.
+* This enum specifies how that clipping is performed. Not all factories that take a
+* GrEffectEdgeType will succeed with all values and it is up to the caller to check for
+* a NULL return.
+*/
+enum GrEffectEdgeType {
+ kFillBW_GrEffectEdgeType,
+ kFillAA_GrEffectEdgeType,
+ kInverseFillBW_GrEffectEdgeType,
+ kInverseFillAA_GrEffectEdgeType,
+ kHairlineAA_GrEffectEdgeType,
+
+ kLast_GrEffectEdgeType = kHairlineAA_GrEffectEdgeType
+};
+
+static const int kGrEffectEdgeTypeCnt = kLast_GrEffectEdgeType + 1;
+
+static inline bool GrEffectEdgeTypeIsFill(const GrEffectEdgeType edgeType) {
+ return (kFillAA_GrEffectEdgeType == edgeType || kFillBW_GrEffectEdgeType == edgeType);
+}
+
+static inline bool GrEffectEdgeTypeIsInverseFill(const GrEffectEdgeType edgeType) {
+ return (kInverseFillAA_GrEffectEdgeType == edgeType ||
+ kInverseFillBW_GrEffectEdgeType == edgeType);
+}
+
+static inline bool GrEffectEdgeTypeIsAA(const GrEffectEdgeType edgeType) {
+ return (kFillBW_GrEffectEdgeType != edgeType && kInverseFillBW_GrEffectEdgeType != edgeType);
+}
+
+static inline GrEffectEdgeType GrInvertEffectEdgeType(const GrEffectEdgeType edgeType) {
+ switch (edgeType) {
+ case kFillBW_GrEffectEdgeType:
+ return kInverseFillBW_GrEffectEdgeType;
+ case kFillAA_GrEffectEdgeType:
+ return kInverseFillAA_GrEffectEdgeType;
+ case kInverseFillBW_GrEffectEdgeType:
+ return kFillBW_GrEffectEdgeType;
+ case kInverseFillAA_GrEffectEdgeType:
+ return kFillAA_GrEffectEdgeType;
+ case kHairlineAA_GrEffectEdgeType:
+ GrCrash("Hairline fill isn't invertible.");
+ }
+ return kFillAA_GrEffectEdgeType; // suppress warning.
+}
+
#endif
diff --git a/src/gpu/GrAAHairLinePathRenderer.cpp b/src/gpu/GrAAHairLinePathRenderer.cpp
index 830f513..60be5be 100644
--- a/src/gpu/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/GrAAHairLinePathRenderer.cpp
@@ -997,7 +997,7 @@
kVertsPerQuad * quadCnt + kVertsPerQuad * conicCnt));
if (quadCnt > 0) {
- GrEffectRef* hairQuadEffect = GrQuadEffect::Create(kHairAA_GrBezierEdgeType,
+ GrEffectRef* hairQuadEffect = GrQuadEffect::Create(kHairlineAA_GrEffectEdgeType,
*target->caps());
SkASSERT(NULL != hairQuadEffect);
GrDrawState::AutoRestoreEffects are(drawState);
@@ -1018,7 +1018,7 @@
if (conicCnt > 0) {
GrDrawState::AutoRestoreEffects are(drawState);
- GrEffectRef* hairConicEffect = GrConicEffect::Create(kHairAA_GrBezierEdgeType,
+ GrEffectRef* hairConicEffect = GrConicEffect::Create(kHairlineAA_GrEffectEdgeType,
*target->caps());
SkASSERT(NULL != hairConicEffect);
drawState->addCoverageEffect(hairConicEffect, 1, 2)->unref();
diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp
index 9b95d33..e24c759 100644
--- a/src/gpu/GrClipMaskManager.cpp
+++ b/src/gpu/GrClipMaskManager.cpp
@@ -180,19 +180,18 @@
if (!isAA) {
SkVector offset = { SkIntToScalar(-clipDataIn->fOrigin.fX),
SkIntToScalar(-clipDataIn->fOrigin.fY) };
- effect.reset(GrConvexPolyEffect::Create(GrConvexPolyEffect::kFillNoAA_EdgeType,
+ effect.reset(GrConvexPolyEffect::Create(kFillBW_GrEffectEdgeType,
path, &offset));
}
} else {
SkVector offset = { SkIntToScalar(-clipDataIn->fOrigin.fX),
SkIntToScalar(-clipDataIn->fOrigin.fY) };
- GrConvexPolyEffect::EdgeType type = isAA ? GrConvexPolyEffect::kFillAA_EdgeType :
- GrConvexPolyEffect::kFillNoAA_EdgeType;
+ GrEffectEdgeType type = isAA ? kFillAA_GrEffectEdgeType : kFillBW_GrEffectEdgeType;
effect.reset(GrConvexPolyEffect::Create(type, path, &offset));
}
} else if (isAA && SkClipStack::Element::kRRect_Type == type && !rt->isMultisampled()) {
const SkRRect& rrect = elements.tail()->getRRect();
- effect.reset(GrRRectEffect::Create(GrRRectEffect::kFillAA_EdgeType, rrect));
+ effect.reset(GrRRectEffect::Create(kFillAA_GrEffectEdgeType, rrect));
} else if (isAA && SkClipStack::Element::kRect_Type == type && !rt->isMultisampled()) {
// We only handle AA/non-MSAA rects here. Coverage effect AA isn't MSAA friendly and
// non-AA rect clips are handled by the scissor.
@@ -200,7 +199,7 @@
SkVector offset = { SkIntToScalar(-clipDataIn->fOrigin.fX),
SkIntToScalar(-clipDataIn->fOrigin.fY) };
rect.offset(offset);
- effect.reset(GrConvexPolyEffect::Create(GrConvexPolyEffect::kFillAA_EdgeType, rect));
+ effect.reset(GrConvexPolyEffect::Create(kFillAA_GrEffectEdgeType, rect));
// This should never fail.
SkASSERT(effect);
}
diff --git a/src/gpu/effects/GrBezierEffect.cpp b/src/gpu/effects/GrBezierEffect.cpp
index c9a2bea..78633e5 100644
--- a/src/gpu/effects/GrBezierEffect.cpp
+++ b/src/gpu/effects/GrBezierEffect.cpp
@@ -29,7 +29,7 @@
virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {}
private:
- GrBezierEdgeType fEdgeType;
+ GrEffectEdgeType fEdgeType;
typedef GrGLVertexEffect INHERITED;
};
@@ -59,7 +59,7 @@
builder->fsCodeAppend("\t\tfloat edgeAlpha;\n");
switch (fEdgeType) {
- case kHairAA_GrBezierEdgeType: {
+ case kHairlineAA_GrEffectEdgeType: {
SkAssertResult(builder->enableFeature(
GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
builder->fsCodeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName);
@@ -81,7 +81,7 @@
// builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
break;
}
- case kFillAA_GrBezierEdgeType: {
+ case kFillAA_GrEffectEdgeType: {
SkAssertResult(builder->enableFeature(
GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
builder->fsCodeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName);
@@ -102,12 +102,14 @@
// builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
break;
}
- case kFillNoAA_GrBezierEdgeType: {
+ case kFillBW_GrEffectEdgeType: {
builder->fsCodeAppendf("\t\tedgeAlpha = %s.x*%s.x - %s.y*%s.z;\n", fsName, fsName,
fsName, fsName);
builder->fsCodeAppend("\t\tedgeAlpha = float(edgeAlpha < 0.0);\n");
break;
}
+ default:
+ GrCrash("Shouldn't get here");
}
builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
@@ -127,7 +129,7 @@
return GrTBackendEffectFactory<GrConicEffect>::getInstance();
}
-GrConicEffect::GrConicEffect(GrBezierEdgeType edgeType) : GrVertexEffect() {
+GrConicEffect::GrConicEffect(GrEffectEdgeType edgeType) : GrVertexEffect() {
this->addVertexAttrib(kVec4f_GrSLType);
fEdgeType = edgeType;
}
@@ -145,8 +147,13 @@
GrContext*,
const GrDrawTargetCaps& caps,
GrTexture*[]) {
- const GrBezierEdgeType edgeType = static_cast<GrBezierEdgeType>(random->nextULessThan(3));
- return GrConicEffect::Create(edgeType, caps);
+ GrEffectRef* effect;
+ do {
+ GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(
+ random->nextULessThan(kGrEffectEdgeTypeCnt));
+ effect = GrConicEffect::Create(edgeType, caps);
+ } while (NULL == effect);
+ return effect;
}
//////////////////////////////////////////////////////////////////////////////
@@ -170,7 +177,7 @@
virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {}
private:
- GrBezierEdgeType fEdgeType;
+ GrEffectEdgeType fEdgeType;
typedef GrGLVertexEffect INHERITED;
};
@@ -198,7 +205,7 @@
builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName);
switch (fEdgeType) {
- case kHairAA_GrBezierEdgeType: {
+ case kHairlineAA_GrEffectEdgeType: {
SkAssertResult(builder->enableFeature(
GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
builder->fsCodeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
@@ -214,7 +221,7 @@
// builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
break;
}
- case kFillAA_GrBezierEdgeType: {
+ case kFillAA_GrEffectEdgeType: {
SkAssertResult(builder->enableFeature(
GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
builder->fsCodeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
@@ -230,12 +237,14 @@
// builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
break;
}
- case kFillNoAA_GrBezierEdgeType: {
+ case kFillBW_GrEffectEdgeType: {
builder->fsCodeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName,
fsName);
builder->fsCodeAppend("\t\tedgeAlpha = float(edgeAlpha < 0.0);\n");
break;
}
+ default:
+ GrCrash("Shouldn't get here");
}
builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
@@ -258,7 +267,7 @@
return GrTBackendEffectFactory<GrQuadEffect>::getInstance();
}
-GrQuadEffect::GrQuadEffect(GrBezierEdgeType edgeType) : GrVertexEffect() {
+GrQuadEffect::GrQuadEffect(GrEffectEdgeType edgeType) : GrVertexEffect() {
this->addVertexAttrib(kVec4f_GrSLType);
fEdgeType = edgeType;
}
@@ -276,8 +285,13 @@
GrContext*,
const GrDrawTargetCaps& caps,
GrTexture*[]) {
- const GrBezierEdgeType edgeType = static_cast<GrBezierEdgeType>(random->nextULessThan(3));
- return GrQuadEffect::Create(edgeType, caps);
+ GrEffectRef* effect;
+ do {
+ GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(
+ random->nextULessThan(kGrEffectEdgeTypeCnt));
+ effect = GrQuadEffect::Create(edgeType, caps);
+ } while (NULL == effect);
+ return effect;
}
//////////////////////////////////////////////////////////////////////////////
@@ -301,7 +315,7 @@
virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {}
private:
- GrBezierEdgeType fEdgeType;
+ GrEffectEdgeType fEdgeType;
typedef GrGLVertexEffect INHERITED;
};
@@ -331,7 +345,7 @@
builder->fsCodeAppend("\t\tfloat edgeAlpha;\n");
switch (fEdgeType) {
- case kHairAA_GrBezierEdgeType: {
+ case kHairlineAA_GrEffectEdgeType: {
SkAssertResult(builder->enableFeature(
GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
builder->fsCodeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName);
@@ -353,7 +367,7 @@
// builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
break;
}
- case kFillAA_GrBezierEdgeType: {
+ case kFillAA_GrEffectEdgeType: {
SkAssertResult(builder->enableFeature(
GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
builder->fsCodeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName);
@@ -374,12 +388,14 @@
// builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
break;
}
- case kFillNoAA_GrBezierEdgeType: {
+ case kFillBW_GrEffectEdgeType: {
builder->fsCodeAppendf("\t\tedgeAlpha = %s.x*%s.x*%s.x - %s.y*%s.z;\n",
fsName, fsName, fsName, fsName, fsName);
builder->fsCodeAppend("\t\tedgeAlpha = float(edgeAlpha < 0.0);\n");
break;
}
+ default:
+ GrCrash("Shouldn't get here");
}
builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
@@ -399,7 +415,7 @@
return GrTBackendEffectFactory<GrCubicEffect>::getInstance();
}
-GrCubicEffect::GrCubicEffect(GrBezierEdgeType edgeType) : GrVertexEffect() {
+GrCubicEffect::GrCubicEffect(GrEffectEdgeType edgeType) : GrVertexEffect() {
this->addVertexAttrib(kVec4f_GrSLType);
fEdgeType = edgeType;
}
@@ -417,6 +433,11 @@
GrContext*,
const GrDrawTargetCaps& caps,
GrTexture*[]) {
- const GrBezierEdgeType edgeType = static_cast<GrBezierEdgeType>(random->nextULessThan(3));
- return GrCubicEffect::Create(edgeType, caps);
+ GrEffectRef* effect;
+ do {
+ GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(
+ random->nextULessThan(kGrEffectEdgeTypeCnt));
+ effect = GrCubicEffect::Create(edgeType, caps);
+ } while (NULL == effect);
+ return effect;
}
diff --git a/src/gpu/effects/GrBezierEffect.h b/src/gpu/effects/GrBezierEffect.h
index 5de7b80..e2fc592 100644
--- a/src/gpu/effects/GrBezierEffect.h
+++ b/src/gpu/effects/GrBezierEffect.h
@@ -11,20 +11,7 @@
#include "GrDrawTargetCaps.h"
#include "GrEffect.h"
#include "GrVertexEffect.h"
-
-enum GrBezierEdgeType {
- kFillAA_GrBezierEdgeType,
- kHairAA_GrBezierEdgeType,
- kFillNoAA_GrBezierEdgeType,
-};
-
-static inline bool GrBezierEdgeTypeIsFill(const GrBezierEdgeType edgeType) {
- return (kHairAA_GrBezierEdgeType != edgeType);
-}
-
-static inline bool GrBezierEdgeTypeIsAA(const GrBezierEdgeType edgeType) {
- return (kFillNoAA_GrBezierEdgeType != edgeType);
-}
+#include "GrTypesPriv.h"
/**
* Shader is based off of Loop-Blinn Quadratic GPU Rendering
@@ -70,25 +57,28 @@
class GrConicEffect : public GrVertexEffect {
public:
- static GrEffectRef* Create(const GrBezierEdgeType edgeType, const GrDrawTargetCaps& caps) {
- GR_CREATE_STATIC_EFFECT(gConicFillAA, GrConicEffect, (kFillAA_GrBezierEdgeType));
- GR_CREATE_STATIC_EFFECT(gConicHairAA, GrConicEffect, (kHairAA_GrBezierEdgeType));
- GR_CREATE_STATIC_EFFECT(gConicFillNoAA, GrConicEffect, (kFillNoAA_GrBezierEdgeType));
- if (kFillAA_GrBezierEdgeType == edgeType) {
- if (!caps.shaderDerivativeSupport()) {
+ static GrEffectRef* Create(const GrEffectEdgeType edgeType, const GrDrawTargetCaps& caps) {
+ GR_CREATE_STATIC_EFFECT(gConicFillAA, GrConicEffect, (kFillAA_GrEffectEdgeType));
+ GR_CREATE_STATIC_EFFECT(gConicHairAA, GrConicEffect, (kHairlineAA_GrEffectEdgeType));
+ GR_CREATE_STATIC_EFFECT(gConicFillBW, GrConicEffect, (kFillBW_GrEffectEdgeType));
+ switch (edgeType) {
+ case kFillAA_GrEffectEdgeType:
+ if (!caps.shaderDerivativeSupport()) {
+ return NULL;
+ }
+ gConicFillAA->ref();
+ return gConicFillAA;
+ case kHairlineAA_GrEffectEdgeType:
+ if (!caps.shaderDerivativeSupport()) {
+ return NULL;
+ }
+ gConicHairAA->ref();
+ return gConicHairAA;
+ case kFillBW_GrEffectEdgeType:
+ gConicFillBW->ref();
+ return gConicFillBW;
+ default:
return NULL;
- }
- gConicFillAA->ref();
- return gConicFillAA;
- } else if (kHairAA_GrBezierEdgeType == edgeType) {
- if (!caps.shaderDerivativeSupport()) {
- return NULL;
- }
- gConicHairAA->ref();
- return gConicHairAA;
- } else {
- gConicFillNoAA->ref();
- return gConicFillNoAA;
}
}
@@ -96,9 +86,9 @@
static const char* Name() { return "Conic"; }
- inline bool isAntiAliased() const { return GrBezierEdgeTypeIsAA(fEdgeType); }
- inline bool isFilled() const { return GrBezierEdgeTypeIsFill(fEdgeType); }
- inline GrBezierEdgeType getEdgeType() const { return fEdgeType; }
+ inline bool isAntiAliased() const { return GrEffectEdgeTypeIsAA(fEdgeType); }
+ inline bool isFilled() const { return GrEffectEdgeTypeIsFill(fEdgeType); }
+ inline GrEffectEdgeType getEdgeType() const { return fEdgeType; }
typedef GrGLConicEffect GLEffect;
@@ -110,11 +100,11 @@
virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
private:
- GrConicEffect(GrBezierEdgeType);
+ GrConicEffect(GrEffectEdgeType);
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE;
- GrBezierEdgeType fEdgeType;
+ GrEffectEdgeType fEdgeType;
GR_DECLARE_EFFECT_TEST;
@@ -134,25 +124,28 @@
class GrQuadEffect : public GrVertexEffect {
public:
- static GrEffectRef* Create(const GrBezierEdgeType edgeType, const GrDrawTargetCaps& caps) {
- GR_CREATE_STATIC_EFFECT(gQuadFillAA, GrQuadEffect, (kFillAA_GrBezierEdgeType));
- GR_CREATE_STATIC_EFFECT(gQuadHairAA, GrQuadEffect, (kHairAA_GrBezierEdgeType));
- GR_CREATE_STATIC_EFFECT(gQuadFillNoAA, GrQuadEffect, (kFillNoAA_GrBezierEdgeType));
- if (kFillAA_GrBezierEdgeType == edgeType) {
- if (!caps.shaderDerivativeSupport()) {
+ static GrEffectRef* Create(const GrEffectEdgeType edgeType, const GrDrawTargetCaps& caps) {
+ GR_CREATE_STATIC_EFFECT(gQuadFillAA, GrQuadEffect, (kFillAA_GrEffectEdgeType));
+ GR_CREATE_STATIC_EFFECT(gQuadHairAA, GrQuadEffect, (kHairlineAA_GrEffectEdgeType));
+ GR_CREATE_STATIC_EFFECT(gQuadFillBW, GrQuadEffect, (kFillBW_GrEffectEdgeType));
+ switch (edgeType) {
+ case kFillAA_GrEffectEdgeType:
+ if (!caps.shaderDerivativeSupport()) {
+ return NULL;
+ }
+ gQuadFillAA->ref();
+ return gQuadFillAA;
+ case kHairlineAA_GrEffectEdgeType:
+ if (!caps.shaderDerivativeSupport()) {
+ return NULL;
+ }
+ gQuadHairAA->ref();
+ return gQuadHairAA;
+ case kFillBW_GrEffectEdgeType:
+ gQuadFillBW->ref();
+ return gQuadFillBW;
+ default:
return NULL;
- }
- gQuadFillAA->ref();
- return gQuadFillAA;
- } else if (kHairAA_GrBezierEdgeType == edgeType) {
- if (!caps.shaderDerivativeSupport()) {
- return NULL;
- }
- gQuadHairAA->ref();
- return gQuadHairAA;
- } else {
- gQuadFillNoAA->ref();
- return gQuadFillNoAA;
}
}
@@ -160,9 +153,9 @@
static const char* Name() { return "Quad"; }
- inline bool isAntiAliased() const { return GrBezierEdgeTypeIsAA(fEdgeType); }
- inline bool isFilled() const { return GrBezierEdgeTypeIsFill(fEdgeType); }
- inline GrBezierEdgeType getEdgeType() const { return fEdgeType; }
+ inline bool isAntiAliased() const { return GrEffectEdgeTypeIsAA(fEdgeType); }
+ inline bool isFilled() const { return GrEffectEdgeTypeIsFill(fEdgeType); }
+ inline GrEffectEdgeType getEdgeType() const { return fEdgeType; }
typedef GrGLQuadEffect GLEffect;
@@ -174,11 +167,11 @@
virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
private:
- GrQuadEffect(GrBezierEdgeType);
+ GrQuadEffect(GrEffectEdgeType);
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE;
- GrBezierEdgeType fEdgeType;
+ GrEffectEdgeType fEdgeType;
GR_DECLARE_EFFECT_TEST;
@@ -200,25 +193,28 @@
class GrCubicEffect : public GrVertexEffect {
public:
- static GrEffectRef* Create(const GrBezierEdgeType edgeType, const GrDrawTargetCaps& caps) {
- GR_CREATE_STATIC_EFFECT(gCubicFillAA, GrCubicEffect, (kFillAA_GrBezierEdgeType));
- GR_CREATE_STATIC_EFFECT(gCubicHairAA, GrCubicEffect, (kHairAA_GrBezierEdgeType));
- GR_CREATE_STATIC_EFFECT(gCubicFillNoAA, GrCubicEffect, (kFillNoAA_GrBezierEdgeType));
- if (kFillAA_GrBezierEdgeType == edgeType) {
- if (!caps.shaderDerivativeSupport()) {
+ static GrEffectRef* Create(const GrEffectEdgeType edgeType, const GrDrawTargetCaps& caps) {
+ GR_CREATE_STATIC_EFFECT(gCubicFillAA, GrCubicEffect, (kFillAA_GrEffectEdgeType));
+ GR_CREATE_STATIC_EFFECT(gCubicHairAA, GrCubicEffect, (kHairlineAA_GrEffectEdgeType));
+ GR_CREATE_STATIC_EFFECT(gCubicFillBW, GrCubicEffect, (kFillBW_GrEffectEdgeType));
+ switch (edgeType) {
+ case kFillAA_GrEffectEdgeType:
+ if (!caps.shaderDerivativeSupport()) {
+ return NULL;
+ }
+ gCubicFillAA->ref();
+ return gCubicFillAA;
+ case kHairlineAA_GrEffectEdgeType:
+ if (!caps.shaderDerivativeSupport()) {
+ return NULL;
+ }
+ gCubicHairAA->ref();
+ return gCubicHairAA;
+ case kFillBW_GrEffectEdgeType:
+ gCubicFillBW->ref();
+ return gCubicFillBW;
+ default:
return NULL;
- }
- gCubicFillAA->ref();
- return gCubicFillAA;
- } else if (kHairAA_GrBezierEdgeType == edgeType) {
- if (!caps.shaderDerivativeSupport()) {
- return NULL;
- }
- gCubicHairAA->ref();
- return gCubicHairAA;
- } else {
- gCubicFillNoAA->ref();
- return gCubicFillNoAA;
}
}
@@ -226,9 +222,9 @@
static const char* Name() { return "Cubic"; }
- inline bool isAntiAliased() const { return GrBezierEdgeTypeIsAA(fEdgeType); }
- inline bool isFilled() const { return GrBezierEdgeTypeIsFill(fEdgeType); }
- inline GrBezierEdgeType getEdgeType() const { return fEdgeType; }
+ inline bool isAntiAliased() const { return GrEffectEdgeTypeIsAA(fEdgeType); }
+ inline bool isFilled() const { return GrEffectEdgeTypeIsFill(fEdgeType); }
+ inline GrEffectEdgeType getEdgeType() const { return fEdgeType; }
typedef GrGLCubicEffect GLEffect;
@@ -240,11 +236,11 @@
virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
private:
- GrCubicEffect(GrBezierEdgeType);
+ GrCubicEffect(GrEffectEdgeType);
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE;
- GrBezierEdgeType fEdgeType;
+ GrEffectEdgeType fEdgeType;
GR_DECLARE_EFFECT_TEST;
diff --git a/src/gpu/effects/GrConvexPolyEffect.cpp b/src/gpu/effects/GrConvexPolyEffect.cpp
index baad928..0793bef 100644
--- a/src/gpu/effects/GrConvexPolyEffect.cpp
+++ b/src/gpu/effects/GrConvexPolyEffect.cpp
@@ -19,13 +19,12 @@
class AARectEffect : public GrEffect {
public:
typedef GLAARectEffect GLEffect;
- typedef GrConvexPolyEffect::EdgeType EdgeType;
const SkRect& getRect() const { return fRect; }
static const char* Name() { return "AARect"; }
- static GrEffectRef* Create(EdgeType edgeType, const SkRect& rect) {
+ static GrEffectRef* Create(GrEffectEdgeType edgeType, const SkRect& rect) {
return CreateEffectRef(AutoEffectUnref(SkNEW_ARGS(AARectEffect, (edgeType, rect))));
}
@@ -40,12 +39,12 @@
}
}
- GrConvexPolyEffect::EdgeType getEdgeType() const { return fEdgeType; }
+ GrEffectEdgeType getEdgeType() const { return fEdgeType; }
virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
private:
- AARectEffect(EdgeType edgeType, const SkRect& rect) : fRect(rect), fEdgeType(edgeType) {
+ AARectEffect(GrEffectEdgeType edgeType, const SkRect& rect) : fRect(rect), fEdgeType(edgeType) {
this->setWillReadFragmentPosition();
}
@@ -55,7 +54,7 @@
}
SkRect fRect;
- EdgeType fEdgeType;
+ GrEffectEdgeType fEdgeType;
typedef GrEffect INHERITED;
@@ -69,14 +68,18 @@
GrContext*,
const GrDrawTargetCaps& caps,
GrTexture*[]) {
- EdgeType edgeType = static_cast<EdgeType>(
- random->nextULessThan(GrConvexPolyEffect::kEdgeTypeCnt));
-
SkRect rect = SkRect::MakeLTRB(random->nextSScalar1(),
random->nextSScalar1(),
random->nextSScalar1(),
random->nextSScalar1());
- return AARectEffect::Create(edgeType, rect);
+ GrEffectRef* effect;
+ do {
+ GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(random->nextULessThan(
+ kGrEffectEdgeTypeCnt));
+
+ effect = AARectEffect::Create(edgeType, rect);
+ } while (NULL == effect);
+ return effect;
}
//////////////////////////////////////////////////////////////////////////////
@@ -125,8 +128,7 @@
"rect",
&rectName);
const char* fragmentPos = builder->fragmentPosition();
- if (GrConvexPolyEffect::kFillAA_EdgeType == aare.getEdgeType() ||
- GrConvexPolyEffect::kInverseFillAA_EdgeType == aare.getEdgeType()) {
+ if (GrEffectEdgeTypeIsAA(aare.getEdgeType())) {
// The amount of coverage removed in x and y by the edges is computed as a pair of negative
// numbers, xSub and ySub.
builder->fsCodeAppend("\t\tfloat xSub, ySub;\n");
@@ -145,8 +147,7 @@
builder->fsCodeAppendf("\t\talpha *= (%s.w - %s.y) > 0.5 ? 1.0 : 0.0;\n", rectName, fragmentPos);
}
- if (GrConvexPolyEffect::kInverseFillAA_EdgeType == aare.getEdgeType() ||
- GrConvexPolyEffect::kInverseFillNoAA_EdgeType == aare.getEdgeType()) {
+ if (GrEffectEdgeTypeIsInverseFill(aare.getEdgeType())) {
builder->fsCodeAppend("\t\talpha = 1.0 - alpha;\n");
}
builder->fsCodeAppendf("\t\t%s = %s;\n", outputColor,
@@ -223,15 +224,10 @@
for (int i = 0; i < cpe.getEdgeCount(); ++i) {
builder->fsCodeAppendf("\t\tedge = dot(%s[%d], vec3(%s.x, %s.y, 1));\n",
edgeArrayName, i, fragmentPos, fragmentPos);
- switch (cpe.getEdgeType()) {
- case GrConvexPolyEffect::kFillAA_EdgeType:
- case GrConvexPolyEffect::kInverseFillAA_EdgeType: // inverse handled at the end
- builder->fsCodeAppend("\t\tedge = clamp(edge, 0.0, 1.0);\n");
- break;
- case GrConvexPolyEffect::kFillNoAA_EdgeType:
- case GrConvexPolyEffect::kInverseFillNoAA_EdgeType: // inverse handled at the end
- builder->fsCodeAppend("\t\tedge = edge >= 0.5 ? 1.0 : 0.0;\n");
- break;
+ if (GrEffectEdgeTypeIsAA(cpe.getEdgeType())) {
+ builder->fsCodeAppend("\t\tedge = clamp(edge, 0.0, 1.0);\n");
+ } else {
+ builder->fsCodeAppend("\t\tedge = edge >= 0.5 ? 1.0 : 0.0;\n");
}
builder->fsCodeAppend("\t\talpha *= edge;\n");
}
@@ -241,8 +237,7 @@
builder->fsCodeAppend("\t\tif (-1.0 == alpha) {\n\t\t\tdiscard;\n\t\t}\n");
}
- if (GrConvexPolyEffect::kInverseFillAA_EdgeType == cpe.getEdgeType() ||
- GrConvexPolyEffect::kInverseFillNoAA_EdgeType == cpe.getEdgeType() ) {
+ if (GrEffectEdgeTypeIsInverseFill(cpe.getEdgeType())) {
builder->fsCodeAppend("\talpha = 1.0 - alpha;\n");
}
builder->fsCodeAppendf("\t%s = %s;\n", outputColor,
@@ -261,16 +256,18 @@
GrGLEffect::EffectKey GrGLConvexPolyEffect::GenKey(const GrDrawEffect& drawEffect,
const GrGLCaps&) {
const GrConvexPolyEffect& cpe = drawEffect.castEffect<GrConvexPolyEffect>();
- GR_STATIC_ASSERT(GrConvexPolyEffect::kEdgeTypeCnt <= 4);
- return (cpe.getEdgeCount() << 2) | cpe.getEdgeType();
+ GR_STATIC_ASSERT(kGrEffectEdgeTypeCnt <= 8);
+ return (cpe.getEdgeCount() << 3) | cpe.getEdgeType();
}
//////////////////////////////////////////////////////////////////////////////
-GrEffectRef* GrConvexPolyEffect::Create(EdgeType type, const SkPath& path, const SkVector* offset) {
+GrEffectRef* GrConvexPolyEffect::Create(GrEffectEdgeType type, const SkPath& path, const SkVector* offset) {
+ if (kHairlineAA_GrEffectEdgeType == type) {
+ return NULL;
+ }
if (path.getSegmentMasks() != SkPath::kLine_SegmentMask ||
- !path.isConvex() ||
- path.isInverseFillType()) {
+ !path.isConvex()) {
return NULL;
}
@@ -309,10 +306,16 @@
++n;
}
}
+ if (path.isInverseFillType()) {
+ type = GrInvertEffectEdgeType(type);
+ }
return Create(type, n, edges);
}
-GrEffectRef* GrConvexPolyEffect::Create(EdgeType edgeType, const SkRect& rect) {
+GrEffectRef* GrConvexPolyEffect::Create(GrEffectEdgeType edgeType, const SkRect& rect) {
+ if (kHairlineAA_GrEffectEdgeType == edgeType){
+ return NULL;
+ }
return AARectEffect::Create(edgeType, rect);
}
@@ -326,7 +329,7 @@
return GrTBackendEffectFactory<GrConvexPolyEffect>::getInstance();
}
-GrConvexPolyEffect::GrConvexPolyEffect(EdgeType edgeType, int n, const SkScalar edges[])
+GrConvexPolyEffect::GrConvexPolyEffect(GrEffectEdgeType edgeType, int n, const SkScalar edges[])
: fEdgeType(edgeType)
, fEdgeCount(n) {
// Factory function should have already ensured this.
@@ -355,12 +358,17 @@
GrContext*,
const GrDrawTargetCaps& caps,
GrTexture*[]) {
- EdgeType edgeType = static_cast<EdgeType>(random->nextULessThan(kEdgeTypeCnt));
int count = random->nextULessThan(kMaxEdges) + 1;
SkScalar edges[kMaxEdges * 3];
for (int i = 0; i < 3 * count; ++i) {
edges[i] = random->nextSScalar1();
}
- return GrConvexPolyEffect::Create(edgeType, count, edges);
+ GrEffectRef* effect;
+ do {
+ GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(
+ random->nextULessThan(kGrEffectEdgeTypeCnt));
+ effect = GrConvexPolyEffect::Create(edgeType, count, edges);
+ } while (NULL == effect);
+ return effect;
}
diff --git a/src/gpu/effects/GrConvexPolyEffect.h b/src/gpu/effects/GrConvexPolyEffect.h
index ab9d313..0e508c7 100644
--- a/src/gpu/effects/GrConvexPolyEffect.h
+++ b/src/gpu/effects/GrConvexPolyEffect.h
@@ -10,6 +10,7 @@
#include "GrDrawTargetCaps.h"
#include "GrEffect.h"
+#include "GrTypesPriv.h"
class GrGLConvexPolyEffect;
class SkPath;
@@ -21,17 +22,7 @@
*/
class GrConvexPolyEffect : public GrEffect {
public:
- enum EdgeType {
- kFillNoAA_EdgeType,
- kFillAA_EdgeType,
- kInverseFillNoAA_EdgeType,
- kInverseFillAA_EdgeType,
-
- kLastEdgeType = kInverseFillAA_EdgeType,
- };
-
enum {
- kEdgeTypeCnt = kLastEdgeType + 1,
kMaxEdges = 8,
};
@@ -46,8 +37,8 @@
* have to modify the effect/shaderbuilder interface to make it possible (e.g. give access
* to the view matrix or untransformed positions in the fragment shader).
*/
- static GrEffectRef* Create(EdgeType edgeType, int n, const SkScalar edges[]) {
- if (n <= 0 || n > kMaxEdges) {
+ static GrEffectRef* Create(GrEffectEdgeType edgeType, int n, const SkScalar edges[]) {
+ if (n <= 0 || n > kMaxEdges || kHairlineAA_GrEffectEdgeType == edgeType) {
return NULL;
}
return CreateEffectRef(AutoEffectUnref(SkNEW_ARGS(GrConvexPolyEffect,
@@ -59,18 +50,18 @@
* inverse filled, or has too many edges, this will return NULL. If offset is non-NULL, then
* the path is translated by the vector.
*/
- static GrEffectRef* Create(EdgeType, const SkPath&, const SkVector* offset= NULL);
+ static GrEffectRef* Create(GrEffectEdgeType, const SkPath&, const SkVector* offset = NULL);
/**
* Creates an effect that fills inside the rect with AA edges..
*/
- static GrEffectRef* Create(EdgeType, const SkRect&);
+ static GrEffectRef* Create(GrEffectEdgeType, const SkRect&);
virtual ~GrConvexPolyEffect();
static const char* Name() { return "ConvexPoly"; }
- EdgeType getEdgeType() const { return fEdgeType; }
+ GrEffectEdgeType getEdgeType() const { return fEdgeType; }
int getEdgeCount() const { return fEdgeCount; }
@@ -83,13 +74,13 @@
virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
private:
- GrConvexPolyEffect(EdgeType edgeType, int n, const SkScalar edges[]);
+ GrConvexPolyEffect(GrEffectEdgeType edgeType, int n, const SkScalar edges[]);
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE;
- EdgeType fEdgeType;
- int fEdgeCount;
- SkScalar fEdges[3 * kMaxEdges];
+ GrEffectEdgeType fEdgeType;
+ int fEdgeCount;
+ SkScalar fEdges[3 * kMaxEdges];
GR_DECLARE_EFFECT_TEST;
diff --git a/src/gpu/effects/GrRRectEffect.cpp b/src/gpu/effects/GrRRectEffect.cpp
index a590186..3e6473b 100644
--- a/src/gpu/effects/GrRRectEffect.cpp
+++ b/src/gpu/effects/GrRRectEffect.cpp
@@ -31,7 +31,7 @@
kBottomCircleTab_RRectType,
};
- static GrEffectRef* Create(EdgeType, const SkRRect&, RRectType);
+ static GrEffectRef* Create(GrEffectEdgeType, RRectType, const SkRRect&);
virtual ~RRectEffect() {};
static const char* Name() { return "RRect"; }
@@ -39,8 +39,8 @@
const SkRRect& getRRect() const { return fRRect; }
RRectType getType() const { return fRRectType; }
-
- EdgeType getEdgeType() const { return fEdgeType; }
+
+ GrEffectEdgeType getEdgeType() const { return fEdgeType; }
typedef GLRRectEffect GLEffect;
@@ -49,13 +49,13 @@
virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE;
private:
- RRectEffect(EdgeType, const SkRRect&, RRectType);
+ RRectEffect(GrEffectEdgeType, RRectType, const SkRRect&);
virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE;
- SkRRect fRRect;
- EdgeType fEdgeType;
- RRectType fRRectType;
+ SkRRect fRRect;
+ GrEffectEdgeType fEdgeType;
+ RRectType fRRectType;
GR_DECLARE_EFFECT_TEST;
@@ -64,8 +64,11 @@
const SkScalar RRectEffect::kRadiusMin = 0.5f;
-GrEffectRef* RRectEffect::Create(EdgeType edgeType, const SkRRect& rrect, RRectType rrtype) {
- return CreateEffectRef(AutoEffectUnref(SkNEW_ARGS(RRectEffect, (edgeType, rrect, rrtype))));
+GrEffectRef* RRectEffect::Create(GrEffectEdgeType edgeType,
+ RRectType rrType,
+ const SkRRect& rrect) {
+ SkASSERT(kFillAA_GrEffectEdgeType == edgeType || kInverseFillBW_GrEffectEdgeType == edgeType);
+ return CreateEffectRef(AutoEffectUnref(SkNEW_ARGS(RRectEffect, (edgeType, rrType, rrect))));
}
void RRectEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
@@ -76,10 +79,10 @@
return GrTBackendEffectFactory<RRectEffect>::getInstance();
}
-RRectEffect::RRectEffect(EdgeType edgeType, const SkRRect& rrect, RRectType rrtype)
+RRectEffect::RRectEffect(GrEffectEdgeType edgeType, RRectType rrType, const SkRRect& rrect)
: fRRect(rrect)
, fEdgeType(edgeType)
- , fRRectType(rrtype) {
+ , fRRectType(rrType) {
this->setWillReadFragmentPosition();
}
@@ -100,11 +103,14 @@
SkScalar w = random->nextRangeScalar(20.f, 1000.f);
SkScalar h = random->nextRangeScalar(20.f, 1000.f);
SkScalar r = random->nextRangeF(kRadiusMin, 9.f);
- EdgeType et = (EdgeType) random->nextULessThan(kEdgeTypeCnt);
SkRRect rrect;
rrect.setRectXY(SkRect::MakeWH(w, h), r, r);
-
- return GrRRectEffect::Create(et, rrect);
+ GrEffectRef* effect;
+ do {
+ GrEffectEdgeType et = (GrEffectEdgeType)random->nextULessThan(kGrEffectEdgeTypeCnt);
+ effect = GrRRectEffect::Create(et, rrect);
+ } while (NULL == effect);
+ return effect;
}
//////////////////////////////////////////////////////////////////////////////
@@ -221,8 +227,8 @@
radiusPlusHalfName);
break;
}
-
- if (kInverseFillAA_EdgeType == rre.getEdgeType()) {
+
+ if (kInverseFillBW_GrEffectEdgeType == rre.getEdgeType()) {
builder->fsCodeAppend("\t\talpha = 1.0 - alpha;\n");
}
@@ -232,8 +238,8 @@
GrGLEffect::EffectKey GLRRectEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
const RRectEffect& rre = drawEffect.castEffect<RRectEffect>();
- GR_STATIC_ASSERT(kEdgeTypeCnt <= 4);
- return (rre.getType() << 2) | rre.getEdgeType();
+ GR_STATIC_ASSERT(kGrEffectEdgeTypeCnt <= 8);
+ return (rre.getType() << 3) | rre.getEdgeType();
}
void GLRRectEffect::setData(const GrGLUniformManager& uman, const GrDrawEffect& drawEffect) {
@@ -286,7 +292,10 @@
//////////////////////////////////////////////////////////////////////////////
-GrEffectRef* GrRRectEffect::Create(EdgeType edgeType, const SkRRect& rrect) {
+GrEffectRef* GrRRectEffect::Create(GrEffectEdgeType edgeType, const SkRRect& rrect) {
+ if (kFillAA_GrEffectEdgeType != edgeType && kInverseFillBW_GrEffectEdgeType != edgeType) {
+ return NULL;
+ }
RRectEffect::RRectType rrtype;
if (rrect.isSimpleCircular()) {
if (rrect.getSimpleRadii().fX < RRectEffect::kRadiusMin) {
@@ -343,5 +352,5 @@
} else {
return NULL;
}
- return RRectEffect::Create(edgeType, rrect, rrtype);
+ return RRectEffect::Create(edgeType, rrtype, rrect);
}
diff --git a/src/gpu/effects/GrRRectEffect.h b/src/gpu/effects/GrRRectEffect.h
index aadd8c2..45ac5f4 100644
--- a/src/gpu/effects/GrRRectEffect.h
+++ b/src/gpu/effects/GrRRectEffect.h
@@ -9,25 +9,17 @@
#define GrRRectEffect_DEFINED
#include "GrTypes.h"
+#include "GrTypesPriv.h"
class GrEffectRef;
class SkRRect;
namespace GrRRectEffect {
- enum EdgeType {
- kFillAA_EdgeType,
- kInverseFillAA_EdgeType,
-
- kLastEdgeType = kInverseFillAA_EdgeType,
- };
-
- static const int kEdgeTypeCnt = kLastEdgeType + 1;
-
/**
* Creates an effect that performs anti-aliased clipping against a SkRRect. It doesn't support
* all varieties of SkRRect so the caller must check for a NULL return.
*/
- GrEffectRef* Create(EdgeType, const SkRRect&);
+ GrEffectRef* Create(GrEffectEdgeType, const SkRRect&);
};
#endif