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/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