Pull out Effect Shaders in GPU Path Renderer

Move the effects in HairLinePathRender (and eventually others into their
own class called GrBezierEffects. This will allow for more sharing of
code between different path renderers on GPU.

BUG=
R=bsalomon@google.com, jvanverth@google.com, robertphillips@google.com

Author: egdaniel@google.com

Review URL: https://chromiumcodereview.appspot.com/23004010

git-svn-id: http://skia.googlecode.com/svn/trunk@10877 2bbb7eff-a529-9590-31e7-b0007b416f81

4 files changed, 649 insertions, 345 deletions

diff --git a/src/gpu/GrAAHairLinePathRenderer.cpp b/src/gpu/GrAAHairLinePathRenderer.cpp
index f8c47d829e..526bd3ebe5 100644
--- a/src/gpu/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/GrAAHairLinePathRenderer.cpp
@@ -19,8 +19,7 @@
 #include "SkStroke.h"
 #include "SkTemplates.h"
 
-#include "gl/GrGLEffect.h"
-#include "gl/GrGLSL.h"
+#include "effects/GrBezierEffect.h"
 
 namespace {
 // quadratics are rendered as 5-sided polys in order to bound the
@@ -694,346 +693,6 @@ void add_line(const SkPoint p[2],
 
 }
 
-/**
- * Shader is based off of "Resolution Independent Curve Rendering using
- * Programmable Graphics Hardware" by Loop and Blinn.
- * The output of this effect is a hairline edge for non rational cubics.
- * Cubics are specified by implicit equation K^3 - LM.
- * K, L, and M, are the first three values of the vertex attribute,
- * the fourth value is not used. Distance is calculated using a
- * first order approximation from the taylor series.
- * Coverage is max(0, 1-distance).
- */
-class HairCubicEdgeEffect : public GrEffect {
-public:
-    static GrEffectRef* Create() {
-        GR_CREATE_STATIC_EFFECT(gHairCubicEdgeEffect, HairCubicEdgeEffect, ());
-        gHairCubicEdgeEffect->ref();
-        return gHairCubicEdgeEffect;
-    }
-
-    virtual ~HairCubicEdgeEffect() {}
-
-    static const char* Name() { return "HairCubicEdge"; }
-
-    virtual void getConstantColorComponents(GrColor* color,
-                                            uint32_t* validFlags) const SK_OVERRIDE {
-        *validFlags = 0;
-    }
-
-    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
-        return GrTBackendEffectFactory<HairCubicEdgeEffect>::getInstance();
-    }
-
-    class GLEffect : public GrGLEffect {
-    public:
-        GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
-            : INHERITED (factory) {}
-
-        virtual void emitCode(GrGLShaderBuilder* builder,
-                              const GrDrawEffect& drawEffect,
-                              EffectKey key,
-                              const char* outputColor,
-                              const char* inputColor,
-                              const TextureSamplerArray& samplers) SK_OVERRIDE {
-            const char *vsName, *fsName;
-
-            SkAssertResult(builder->enableFeature(
-                    GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
-            builder->addVarying(kVec4f_GrSLType, "CubicCoeffs",
-                                &vsName, &fsName);
-            const SkString* attr0Name =
-                builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
-            builder->vsCodeAppendf("\t%s = %s;\n", vsName, attr0Name->c_str());
-
-            builder->fsCodeAppend("\t\tfloat edgeAlpha;\n");
-
-            builder->fsCodeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName);
-            builder->fsCodeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName);
-            builder->fsCodeAppendf("\t\tfloat dfdx =\n"
-                                   "\t\t3.0*%s.x*%s.x*dklmdx.x - %s.y*dklmdx.z - %s.z*dklmdx.y;\n",
-                                   fsName, fsName, fsName, fsName);
-            builder->fsCodeAppendf("\t\tfloat dfdy =\n"
-                                   "\t\t3.0*%s.x*%s.x*dklmdy.x - %s.y*dklmdy.z - %s.z*dklmdy.y;\n",
-                                   fsName, fsName, fsName, fsName);
-            builder->fsCodeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n");
-            builder->fsCodeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n");
-            builder->fsCodeAppendf("\t\tfloat func = abs(%s.x*%s.x*%s.x - %s.y*%s.z);\n",
-                                   fsName, fsName, fsName, fsName, fsName);
-            builder->fsCodeAppend("\t\tedgeAlpha = func / gFM;\n");
-            builder->fsCodeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
-            // Add line below for smooth cubic ramp
-            // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
-
-            SkString modulate;
-            GrGLSLModulatef<4>(&modulate, inputColor, "edgeAlpha");
-            builder->fsCodeAppendf("\t%s = %s;\n", outputColor, modulate.c_str());
-        }
-
-        static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
-            return 0x0;
-        }
-
-        virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {}
-
-    private:
-        typedef GrGLEffect INHERITED;
-    };
-private:
-    HairCubicEdgeEffect() {
-        this->addVertexAttrib(kVec4f_GrSLType);
-    }
-
-    virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
-        return true;
-    }
-
-    GR_DECLARE_EFFECT_TEST;
-
-    typedef GrEffect INHERITED;
-};
-
-/**
- * Shader is based off of Loop-Blinn Quadratic GPU Rendering
- * The output of this effect is a hairline edge for conics.
- * Conics specified by implicit equation K^2 - LM.
- * K, L, and M, are the first three values of the vertex attribute,
- * the fourth value is not used. Distance is calculated using a
- * first order approximation from the taylor series.
- * Coverage is max(0, 1-distance).
- */
-
-/**
- * Test were also run using a second order distance approximation.
- * There were two versions of the second order approx. The first version
- * is of roughly the form:
- * f(q) = |f(p)| - ||f'(p)||*||q-p|| - ||f''(p)||*||q-p||^2.
- * The second is similar:
- * f(q) = |f(p)| + ||f'(p)||*||q-p|| + ||f''(p)||*||q-p||^2.
- * The exact version of the equations can be found in the paper
- * "Distance Approximations for Rasterizing Implicit Curves" by Gabriel Taubin
- *
- * In both versions we solve the quadratic for ||q-p||.
- * Version 1:
- * gFM is magnitude of first partials and gFM2 is magnitude of 2nd partials (as derived from paper)
- * builder->fsCodeAppend("\t\tedgeAlpha = (sqrt(gFM*gFM+4.0*func*gF2M) - gFM)/(2.0*gF2M);\n");
- * Version 2:
- * builder->fsCodeAppend("\t\tedgeAlpha = (gFM - sqrt(gFM*gFM-4.0*func*gF2M))/(2.0*gF2M);\n");
- *
- * Also note that 2nd partials of k,l,m are zero
- *
- * When comparing the two second order approximations to the first order approximations,
- * the following results were found. Version 1 tends to underestimate the distances, thus it
- * basically increases all the error that we were already seeing in the first order
- * approx. So this version is not the one to use. Version 2 has the opposite effect
- * and tends to overestimate the distances. This is much closer to what we are
- * looking for. It is able to render ellipses (even thin ones) without the need to chop.
- * However, it can not handle thin hyperbolas well and thus would still rely on
- * chopping to tighten the clipping. Another side effect of the overestimating is
- * that the curves become much thinner and "ropey". If all that was ever rendered
- * were "not too thin" curves and ellipses then 2nd order may have an advantage since
- * only one geometry would need to be rendered. However no benches were run comparing
- * chopped first order and non chopped 2nd order.
- */
-class HairConicEdgeEffect : public GrEffect {
-public:
-    static GrEffectRef* Create() {
-        GR_CREATE_STATIC_EFFECT(gHairConicEdgeEffect, HairConicEdgeEffect, ());
-        gHairConicEdgeEffect->ref();
-        return gHairConicEdgeEffect;
-    }
-
-    virtual ~HairConicEdgeEffect() {}
-
-    static const char* Name() { return "HairConicEdge"; }
-
-    virtual void getConstantColorComponents(GrColor* color,
-                                            uint32_t* validFlags) const SK_OVERRIDE {
-        *validFlags = 0;
-    }
-
-    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
-        return GrTBackendEffectFactory<HairConicEdgeEffect>::getInstance();
-    }
-
-    class GLEffect : public GrGLEffect {
-    public:
-        GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
-            : INHERITED (factory) {}
-
-        virtual void emitCode(GrGLShaderBuilder* builder,
-                              const GrDrawEffect& drawEffect,
-                              EffectKey key,
-                              const char* outputColor,
-                              const char* inputColor,
-                              const TextureSamplerArray& samplers) SK_OVERRIDE {
-            const char *vsName, *fsName;
-
-            SkAssertResult(builder->enableFeature(
-                    GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
-            builder->addVarying(kVec4f_GrSLType, "ConicCoeffs",
-                                &vsName, &fsName);
-            const SkString* attr0Name =
-                builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
-            builder->vsCodeAppendf("\t%s = %s;\n", vsName, attr0Name->c_str());
-
-            builder->fsCodeAppend("\t\tfloat edgeAlpha;\n");
-
-            builder->fsCodeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName);
-            builder->fsCodeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName);
-            builder->fsCodeAppendf("\t\tfloat dfdx =\n"
-                                   "\t\t\t2.0*%s.x*dklmdx.x - %s.y*dklmdx.z - %s.z*dklmdx.y;\n",
-                                   fsName, fsName, fsName);
-            builder->fsCodeAppendf("\t\tfloat dfdy =\n"
-                                   "\t\t\t2.0*%s.x*dklmdy.x - %s.y*dklmdy.z - %s.z*dklmdy.y;\n",
-                                   fsName, fsName, fsName);
-            builder->fsCodeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n");
-            builder->fsCodeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n");
-            builder->fsCodeAppendf("\t\tfloat func = abs(%s.x*%s.x - %s.y*%s.z);\n", fsName, fsName,
-                                   fsName, fsName);
-            builder->fsCodeAppend("\t\tedgeAlpha = func / gFM;\n");
-            builder->fsCodeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
-            // Add line below for smooth cubic ramp
-            // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
-
-            SkString modulate;
-            GrGLSLModulatef<4>(&modulate, inputColor, "edgeAlpha");
-            builder->fsCodeAppendf("\t%s = %s;\n", outputColor, modulate.c_str());
-        }
-
-        static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
-            return 0x0;
-        }
-
-        virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {}
-
-    private:
-        typedef GrGLEffect INHERITED;
-    };
-
-private:
-    HairConicEdgeEffect() {
-        this->addVertexAttrib(kVec4f_GrSLType);
-    }
-
-    virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
-        return true;
-    }
-
-    GR_DECLARE_EFFECT_TEST;
-
-    typedef GrEffect INHERITED;
-};
-
-GR_DEFINE_EFFECT_TEST(HairConicEdgeEffect);
-
-GrEffectRef* HairConicEdgeEffect::TestCreate(SkMWCRandom* random,
-                                             GrContext*,
-                                             const GrDrawTargetCaps& caps,
-                                             GrTexture*[]) {
-    return caps.shaderDerivativeSupport() ? HairConicEdgeEffect::Create() : NULL;
-}
-
-/**
- * The output of this effect is a hairline edge for quadratics.
- * Quadratic specified by 0=u^2-v canonical coords. u and v are the first
- * two components of the vertex attribute. Uses unsigned distance.
- * Coverage is min(0, 1-distance). 3rd & 4th component unused.
- * Requires shader derivative instruction support.
- */
-class HairQuadEdgeEffect : public GrEffect {
-public:
-
-    static GrEffectRef* Create() {
-        GR_CREATE_STATIC_EFFECT(gHairQuadEdgeEffect, HairQuadEdgeEffect, ());
-        gHairQuadEdgeEffect->ref();
-        return gHairQuadEdgeEffect;
-    }
-
-    virtual ~HairQuadEdgeEffect() {}
-
-    static const char* Name() { return "HairQuadEdge"; }
-
-    virtual void getConstantColorComponents(GrColor* color,
-                                            uint32_t* validFlags) const SK_OVERRIDE {
-        *validFlags = 0;
-    }
-
-    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
-        return GrTBackendEffectFactory<HairQuadEdgeEffect>::getInstance();
-    }
-
-    class GLEffect : public GrGLEffect {
-    public:
-        GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
-            : INHERITED (factory) {}
-
-        virtual void emitCode(GrGLShaderBuilder* builder,
-                              const GrDrawEffect& drawEffect,
-                              EffectKey key,
-                              const char* outputColor,
-                              const char* inputColor,
-                              const TextureSamplerArray& samplers) SK_OVERRIDE {
-            const char *vsName, *fsName;
-            const SkString* attrName =
-                builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
-            builder->fsCodeAppendf("\t\tfloat edgeAlpha;\n");
-
-            SkAssertResult(builder->enableFeature(
-                    GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
-            builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName);
-
-            builder->fsCodeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
-            builder->fsCodeAppendf("\t\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
-            builder->fsCodeAppendf("\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,\n"
-                                   "\t\t               2.0*%s.x*duvdy.x - duvdy.y);\n",
-                                   fsName, fsName);
-            builder->fsCodeAppendf("\t\tedgeAlpha = (%s.x*%s.x - %s.y);\n", fsName, fsName,
-                                   fsName);
-            builder->fsCodeAppend("\t\tedgeAlpha = sqrt(edgeAlpha*edgeAlpha / dot(gF, gF));\n");
-            builder->fsCodeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
-
-            SkString modulate;
-            GrGLSLModulatef<4>(&modulate, inputColor, "edgeAlpha");
-            builder->fsCodeAppendf("\t%s = %s;\n", outputColor, modulate.c_str());
-
-            builder->vsCodeAppendf("\t%s = %s;\n", vsName, attrName->c_str());
-        }
-
-        static inline EffectKey GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
-            return 0x0;
-        }
-
-        virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {}
-
-    private:
-        typedef GrGLEffect INHERITED;
-    };
-
-private:
-    HairQuadEdgeEffect() {
-        this->addVertexAttrib(kVec4f_GrSLType);
-    }
-
-    virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE {
-        return true;
-    }
-
-    GR_DECLARE_EFFECT_TEST;
-
-    typedef GrEffect INHERITED;
-};
-
-GR_DEFINE_EFFECT_TEST(HairQuadEdgeEffect);
-
-GrEffectRef* HairQuadEdgeEffect::TestCreate(SkMWCRandom* random,
-                                            GrContext*,
-                                            const GrDrawTargetCaps& caps,
-                                            GrTexture*[]) {
-    // Doesn't work without derivative instructions.
-    return caps.shaderDerivativeSupport() ? HairQuadEdgeEffect::Create() : NULL;
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 namespace {
@@ -1297,8 +956,10 @@ bool GrAAHairLinePathRenderer::onDrawPath(const SkPath& path,
 
         static const int kEdgeAttrIndex = 1;
 
-        GrEffectRef* hairQuadEffect = HairQuadEdgeEffect::Create();
-        GrEffectRef* hairConicEffect = HairConicEdgeEffect::Create();
+        GrEffectRef* hairQuadEffect = GrQuadEffect::Create(kHairAA_GrBezierEdgeType,
+                                                           *target->caps());
+        GrEffectRef* hairConicEffect = GrConicEffect::Create(kHairAA_GrBezierEdgeType,
+                                                             *target->caps());
 
         // Check devBounds
         SkASSERT(check_bounds<BezierVertex>(drawState, devBounds, arg.vertices(),
diff --git a/src/gpu/GrPathUtils.cpp b/src/gpu/GrPathUtils.cpp
index e354e413f1..d412b8cd9d 100644
--- a/src/gpu/GrPathUtils.cpp
+++ b/src/gpu/GrPathUtils.cpp
@@ -639,7 +639,7 @@ static void set_loop_klm(const SkScalar d[3], SkScalar k[4], SkScalar l[4], SkSc
     // If (d0 < 0 && sign(k1) > 0) || (d0 > 0 && sign(k1) < 0),
     // we need to flip the orientation of our curve.
     // This is done by negating the k and l values
-    if ( (d[0] < 0 && k[1] < 0) || (d[0] > 0 && k[1] > 0)) {
+    if ( (d[0] < 0 && k[1] > 0) || (d[0] > 0 && k[1] < 0)) {
         for (int i = 0; i < 4; ++i) {
             k[i] = -k[i];
             l[i] = -l[i];
diff --git a/src/gpu/effects/GrBezierEffect.cpp b/src/gpu/effects/GrBezierEffect.cpp
new file mode 100644
index 0000000000..f4cebd4063
--- /dev/null
+++ b/src/gpu/effects/GrBezierEffect.cpp
@@ -0,0 +1,390 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "GrBezierEffect.h"
+
+#include "gl/GrGLEffect.h"
+#include "gl/GrGLSL.h"
+#include "GrTBackendEffectFactory.h"
+
+class GrGLConicEffect : public GrGLEffect {
+public:
+    GrGLConicEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
+
+    virtual void emitCode(GrGLShaderBuilder* builder,
+                          const GrDrawEffect& drawEffect,
+                          EffectKey key,
+                          const char* outputColor,
+                          const char* inputColor,
+                          const TextureSamplerArray&) SK_OVERRIDE;
+
+    static inline EffectKey GenKey(const GrDrawEffect&, const GrGLCaps&);
+
+    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {}
+
+private:
+    GrBezierEdgeType fEdgeType;
+
+    typedef GrGLEffect INHERITED;
+};
+    
+GrGLConicEffect::GrGLConicEffect(const GrBackendEffectFactory& factory,
+                                 const GrDrawEffect& drawEffect)
+    : INHERITED (factory) {
+    const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>();
+    fEdgeType = ce.getEdgeType();
+}
+
+void GrGLConicEffect::emitCode(GrGLShaderBuilder* builder,
+                               const GrDrawEffect& drawEffect,
+                               EffectKey key,
+                               const char* outputColor,
+                               const char* inputColor,
+                               const TextureSamplerArray& samplers) {
+    const char *vsName, *fsName;
+
+    const bool antiAlias = GrBezierEdgeTypeIsAA(fEdgeType);
+    const bool fill = GrBezierEdgeTypeIsFill(fEdgeType);
+
+    if (antiAlias) {
+        SkAssertResult(builder->enableFeature(
+                GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
+    }
+    builder->addVarying(kVec4f_GrSLType, "ConicCoeffs",
+                        &vsName, &fsName);
+    const SkString* attr0Name =
+        builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
+    builder->vsCodeAppendf("\t%s = %s;\n", vsName, attr0Name->c_str());
+
+    builder->fsCodeAppend("\t\tfloat edgeAlpha;\n");
+
+    if (antiAlias) {
+        builder->fsCodeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName);
+        builder->fsCodeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName);
+        builder->fsCodeAppendf("\t\tfloat dfdx =\n"
+                               "\t\t\t2.0*%s.x*dklmdx.x - %s.y*dklmdx.z - %s.z*dklmdx.y;\n",
+                               fsName, fsName, fsName);
+        builder->fsCodeAppendf("\t\tfloat dfdy =\n"
+                               "\t\t\t2.0*%s.x*dklmdy.x - %s.y*dklmdy.z - %s.z*dklmdy.y;\n",
+                               fsName, fsName, fsName);
+        builder->fsCodeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n");
+        builder->fsCodeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n");
+    }
+    builder->fsCodeAppendf("\t\tfloat func = %s.x*%s.x - %s.y*%s.z;\n", fsName, fsName,
+                           fsName, fsName);
+    if (!fill) {
+        builder->fsCodeAppend("\t\tfunc = abs(func);\n");
+    }
+    if (antiAlias) {
+        builder->fsCodeAppend("\t\tedgeAlpha = func / gFM;\n");
+    }
+    if (fill) {
+        if (antiAlias) {
+            builder->fsCodeAppend("\t\tedgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1.0);\n");
+            // Add line below for smooth cubic ramp
+            // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
+        } else {
+            builder->fsCodeAppend("\t\tedgeAlpha = float(func < 0.0);\n");
+        }
+    } else {
+        builder->fsCodeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
+        // Add line below for smooth cubic ramp
+        // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
+    }
+
+    SkString modulate;
+    GrGLSLModulatef<4>(&modulate, inputColor, "edgeAlpha");
+    builder->fsCodeAppendf("\t%s = %s;\n", outputColor, modulate.c_str());
+}
+
+GrGLEffect::EffectKey GrGLConicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
+    const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>();
+    return ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+GrConicEffect::~GrConicEffect() {}
+
+const GrBackendEffectFactory& GrConicEffect::getFactory() const {
+    return GrTBackendEffectFactory<GrConicEffect>::getInstance();
+}
+
+GrConicEffect::GrConicEffect(GrBezierEdgeType edgeType) : GrEffect() {
+    this->addVertexAttrib(kVec4f_GrSLType);
+    fEdgeType = edgeType;
+}
+
+bool GrConicEffect::onIsEqual(const GrEffect& other) const {
+    const GrConicEffect& ce = CastEffect<GrConicEffect>(other);
+    return (ce.fEdgeType == fEdgeType);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+GR_DEFINE_EFFECT_TEST(GrConicEffect);
+
+GrEffectRef* GrConicEffect::TestCreate(SkMWCRandom* random,
+                                             GrContext*,
+                                             const GrDrawTargetCaps& caps,
+                                             GrTexture*[]) {
+    const GrBezierEdgeType edgeType = static_cast<GrBezierEdgeType>(random->nextULessThan(3));
+    return GrConicEffect::Create(edgeType, caps);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Quad
+//////////////////////////////////////////////////////////////////////////////
+
+class GrGLQuadEffect : public GrGLEffect {
+public:
+    GrGLQuadEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
+
+    virtual void emitCode(GrGLShaderBuilder* builder,
+                          const GrDrawEffect& drawEffect,
+                          EffectKey key,
+                          const char* outputColor,
+                          const char* inputColor,
+                          const TextureSamplerArray&) SK_OVERRIDE;
+
+    static inline EffectKey GenKey(const GrDrawEffect&, const GrGLCaps&);
+
+    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {}
+
+private:
+    GrBezierEdgeType fEdgeType;
+
+    typedef GrGLEffect INHERITED;
+};
+    
+GrGLQuadEffect::GrGLQuadEffect(const GrBackendEffectFactory& factory,
+                                 const GrDrawEffect& drawEffect)
+    : INHERITED (factory) {
+    const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>();
+    fEdgeType = ce.getEdgeType();
+}
+
+void GrGLQuadEffect::emitCode(GrGLShaderBuilder* builder,
+                              const GrDrawEffect& drawEffect,
+                              EffectKey key,
+                              const char* outputColor,
+                              const char* inputColor,
+                              const TextureSamplerArray& samplers) {
+    const char *vsName, *fsName;
+
+    bool antiAlias = GrBezierEdgeTypeIsAA(fEdgeType);
+    bool fill = GrBezierEdgeTypeIsFill(fEdgeType);
+
+    const SkString* attrName =
+        builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
+    builder->fsCodeAppendf("\t\tfloat edgeAlpha;\n");
+
+    if (antiAlias) {
+        SkAssertResult(builder->enableFeature(
+                GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
+    }
+    builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName);
+
+    if (antiAlias) {
+        builder->fsCodeAppendf("\t\tvec2 duvdx = dFdx(%s.xy);\n", fsName);
+        builder->fsCodeAppendf("\t\tvec2 duvdy = dFdy(%s.xy);\n", fsName);
+        builder->fsCodeAppendf("\t\tvec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,\n"
+                               "\t\t               2.0*%s.x*duvdy.x - duvdy.y);\n",
+                               fsName, fsName);
+    }
+    builder->fsCodeAppendf("\t\tfloat func = (%s.x*%s.x - %s.y);\n", fsName, fsName,
+                           fsName);
+    if (!fill) {
+        builder->fsCodeAppend("\t\tfunc = abs(func);\n");
+    }
+    if (antiAlias) {
+        builder->fsCodeAppend("\t\tedgeAlpha = func / sqrt(dot(gF, gF));\n");
+    }
+    if (fill) {
+        if (antiAlias) {
+            builder->fsCodeAppend("\t\tedgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1.0);\n");
+            // Add line below for smooth cubic ramp
+            // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
+        } else {
+            builder->fsCodeAppend("\t\tedgeAlpha = float(func < 0.0);\n");
+        }
+    } else {
+        builder->fsCodeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
+        // Add line below for smooth cubic ramp
+        // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
+    }
+
+    SkString modulate;
+    GrGLSLModulatef<4>(&modulate, inputColor, "edgeAlpha");
+    builder->fsCodeAppendf("\t%s = %s;\n", outputColor, modulate.c_str());
+
+    builder->vsCodeAppendf("\t%s = %s;\n", vsName, attrName->c_str());
+}
+
+GrGLEffect::EffectKey GrGLQuadEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
+    const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>();
+    return ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+GrQuadEffect::~GrQuadEffect() {}
+
+const GrBackendEffectFactory& GrQuadEffect::getFactory() const {
+    return GrTBackendEffectFactory<GrQuadEffect>::getInstance();
+}
+
+GrQuadEffect::GrQuadEffect(GrBezierEdgeType edgeType) : GrEffect() {
+    this->addVertexAttrib(kVec4f_GrSLType);
+    fEdgeType = edgeType;
+}
+
+bool GrQuadEffect::onIsEqual(const GrEffect& other) const {
+    const GrQuadEffect& ce = CastEffect<GrQuadEffect>(other);
+    return (ce.fEdgeType == fEdgeType);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+GR_DEFINE_EFFECT_TEST(GrQuadEffect);
+
+GrEffectRef* GrQuadEffect::TestCreate(SkMWCRandom* random,
+                                             GrContext*,
+                                             const GrDrawTargetCaps& caps,
+                                             GrTexture*[]) {
+    const GrBezierEdgeType edgeType = static_cast<GrBezierEdgeType>(random->nextULessThan(3));
+    return GrQuadEffect::Create(edgeType, caps);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+// Cubic
+//////////////////////////////////////////////////////////////////////////////
+
+class GrGLCubicEffect : public GrGLEffect {
+public:
+    GrGLCubicEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
+
+    virtual void emitCode(GrGLShaderBuilder* builder,
+                          const GrDrawEffect& drawEffect,
+                          EffectKey key,
+                          const char* outputColor,
+                          const char* inputColor,
+                          const TextureSamplerArray&) SK_OVERRIDE;
+
+    static inline EffectKey GenKey(const GrDrawEffect&, const GrGLCaps&);
+
+    virtual void setData(const GrGLUniformManager&, const GrDrawEffect&) SK_OVERRIDE {}
+
+private:
+    GrBezierEdgeType fEdgeType;
+
+    typedef GrGLEffect INHERITED;
+};
+    
+GrGLCubicEffect::GrGLCubicEffect(const GrBackendEffectFactory& factory,
+                                 const GrDrawEffect& drawEffect)
+    : INHERITED (factory) {
+    const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>();
+    fEdgeType = ce.getEdgeType();
+}
+
+void GrGLCubicEffect::emitCode(GrGLShaderBuilder* builder,
+                               const GrDrawEffect& drawEffect,
+                               EffectKey key,
+                               const char* outputColor,
+                               const char* inputColor,
+                               const TextureSamplerArray& samplers) {
+    const char *vsName, *fsName;
+
+    bool antiAlias = GrBezierEdgeTypeIsAA(fEdgeType);
+    bool fill = GrBezierEdgeTypeIsFill(fEdgeType);
+
+    if (antiAlias) {
+        SkAssertResult(builder->enableFeature(
+                GrGLShaderBuilder::kStandardDerivatives_GLSLFeature));
+    }
+    builder->addVarying(kVec4f_GrSLType, "CubicCoeffs",
+                        &vsName, &fsName);
+    const SkString* attr0Name =
+        builder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
+    builder->vsCodeAppendf("\t%s = %s;\n", vsName, attr0Name->c_str());
+
+    builder->fsCodeAppend("\t\tfloat edgeAlpha;\n");
+
+    if (antiAlias) {
+    builder->fsCodeAppendf("\t\tvec3 dklmdx = dFdx(%s.xyz);\n", fsName);
+    builder->fsCodeAppendf("\t\tvec3 dklmdy = dFdy(%s.xyz);\n", fsName);
+    builder->fsCodeAppendf("\t\tfloat dfdx =\n"
+                           "\t\t3.0*%s.x*%s.x*dklmdx.x - %s.y*dklmdx.z - %s.z*dklmdx.y;\n",
+                           fsName, fsName, fsName, fsName);
+    builder->fsCodeAppendf("\t\tfloat dfdy =\n"
+                           "\t\t3.0*%s.x*%s.x*dklmdy.x - %s.y*dklmdy.z - %s.z*dklmdy.y;\n",
+                           fsName, fsName, fsName, fsName);
+    builder->fsCodeAppend("\t\tvec2 gF = vec2(dfdx, dfdy);\n");
+    builder->fsCodeAppend("\t\tfloat gFM = sqrt(dot(gF, gF));\n");
+    }
+    builder->fsCodeAppendf("\t\tfloat func = %s.x*%s.x*%s.x - %s.y*%s.z;\n",
+                           fsName, fsName, fsName, fsName, fsName);
+    if (!fill) {
+        builder->fsCodeAppend("\t\tfunc = abs(func);\n");
+    }
+    if (antiAlias) {
+        builder->fsCodeAppend("\t\tedgeAlpha = func / gFM;\n");
+    }
+    if (fill) {
+        if (antiAlias) {
+            builder->fsCodeAppend("\t\tedgeAlpha = clamp(1.0 - edgeAlpha, 0.0, 1.0);\n");
+            // Add line below for smooth cubic ramp
+            // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
+        } else {
+            builder->fsCodeAppend("\t\tedgeAlpha = float(func < 0.0);\n");
+        }
+    } else {
+        builder->fsCodeAppend("\t\tedgeAlpha = max(1.0 - edgeAlpha, 0.0);\n");
+        // Add line below for smooth cubic ramp
+        // builder->fsCodeAppend("\t\tedgeAlpha = edgeAlpha*edgeAlpha*(3.0-2.0*edgeAlpha);\n");
+    }
+
+    SkString modulate;
+    GrGLSLModulatef<4>(&modulate, inputColor, "edgeAlpha");
+    builder->fsCodeAppendf("\t%s = %s;\n", outputColor, modulate.c_str());
+}
+
+GrGLEffect::EffectKey GrGLCubicEffect::GenKey(const GrDrawEffect& drawEffect, const GrGLCaps&) {
+    const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>();
+    return ce.isAntiAliased() ? (ce.isFilled() ? 0x0 : 0x1) : 0x2;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+GrCubicEffect::~GrCubicEffect() {}
+
+const GrBackendEffectFactory& GrCubicEffect::getFactory() const {
+    return GrTBackendEffectFactory<GrCubicEffect>::getInstance();
+}
+
+GrCubicEffect::GrCubicEffect(GrBezierEdgeType edgeType) : GrEffect() {
+    this->addVertexAttrib(kVec4f_GrSLType);
+    fEdgeType = edgeType;
+}
+
+bool GrCubicEffect::onIsEqual(const GrEffect& other) const {
+    const GrCubicEffect& ce = CastEffect<GrCubicEffect>(other);
+    return (ce.fEdgeType == fEdgeType);
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+GR_DEFINE_EFFECT_TEST(GrCubicEffect);
+
+GrEffectRef* GrCubicEffect::TestCreate(SkMWCRandom* random,
+                                             GrContext*,
+                                             const GrDrawTargetCaps& caps,
+                                             GrTexture*[]) {
+    const GrBezierEdgeType edgeType = static_cast<GrBezierEdgeType>(random->nextULessThan(3));
+    return GrCubicEffect::Create(edgeType, caps);
+}
diff --git a/src/gpu/effects/GrBezierEffect.h b/src/gpu/effects/GrBezierEffect.h
new file mode 100644
index 0000000000..72f12517f8
--- /dev/null
+++ b/src/gpu/effects/GrBezierEffect.h
@@ -0,0 +1,253 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrBezierEffect_DEFINED
+#define GrBezierEffect_DEFINED 
+
+#include "GrEffect.h"
+#include "GrDrawTargetCaps.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);
+}
+
+/**
+ * Shader is based off of Loop-Blinn Quadratic GPU Rendering
+ * The output of this effect is a hairline edge for conics.
+ * Conics specified by implicit equation K^2 - LM.
+ * K, L, and M, are the first three values of the vertex attribute,
+ * the fourth value is not used. Distance is calculated using a
+ * first order approximation from the taylor series.
+ * Coverage for AA is max(0, 1-distance).
+ *
+ * Test were also run using a second order distance approximation.
+ * There were two versions of the second order approx. The first version
+ * is of roughly the form:
+ * f(q) = |f(p)| - ||f'(p)||*||q-p|| - ||f''(p)||*||q-p||^2.
+ * The second is similar:
+ * f(q) = |f(p)| + ||f'(p)||*||q-p|| + ||f''(p)||*||q-p||^2.
+ * The exact version of the equations can be found in the paper
+ * "Distance Approximations for Rasterizing Implicit Curves" by Gabriel Taubin
+ *
+ * In both versions we solve the quadratic for ||q-p||.
+ * Version 1:
+ * gFM is magnitude of first partials and gFM2 is magnitude of 2nd partials (as derived from paper)
+ * builder->fsCodeAppend("\t\tedgeAlpha = (sqrt(gFM*gFM+4.0*func*gF2M) - gFM)/(2.0*gF2M);\n");
+ * Version 2:
+ * builder->fsCodeAppend("\t\tedgeAlpha = (gFM - sqrt(gFM*gFM-4.0*func*gF2M))/(2.0*gF2M);\n");
+ *
+ * Also note that 2nd partials of k,l,m are zero
+ *
+ * When comparing the two second order approximations to the first order approximations,
+ * the following results were found. Version 1 tends to underestimate the distances, thus it
+ * basically increases all the error that we were already seeing in the first order
+ * approx. So this version is not the one to use. Version 2 has the opposite effect
+ * and tends to overestimate the distances. This is much closer to what we are
+ * looking for. It is able to render ellipses (even thin ones) without the need to chop.
+ * However, it can not handle thin hyperbolas well and thus would still rely on
+ * chopping to tighten the clipping. Another side effect of the overestimating is
+ * that the curves become much thinner and "ropey". If all that was ever rendered
+ * were "not too thin" curves and ellipses then 2nd order may have an advantage since
+ * only one geometry would need to be rendered. However no benches were run comparing
+ * chopped first order and non chopped 2nd order.
+ */
+class GrGLConicEffect;
+
+class GrConicEffect : public GrEffect {
+public:
+    static GrEffectRef* Create(const GrBezierEdgeType edgeType, const GrDrawTargetCaps& caps) {
+        GR_CREATE_STATIC_EFFECT(gConicFillAA, GrConicEffect, (edgeType));
+        GR_CREATE_STATIC_EFFECT(gConicHairAA, GrConicEffect, (edgeType));
+        GR_CREATE_STATIC_EFFECT(gConicFillNoAA, GrConicEffect, (edgeType));
+        if (kFillAA_GrBezierEdgeType == edgeType) {
+            if (!caps.shaderDerivativeSupport()) {
+                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;
+        }
+    }
+
+    virtual ~GrConicEffect();
+
+    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; }
+
+    typedef GrGLConicEffect GLEffect;
+
+    virtual void getConstantColorComponents(GrColor* color,
+                                            uint32_t* validFlags) const SK_OVERRIDE {
+        *validFlags = 0;
+    }
+
+    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; 
+
+private:
+    GrConicEffect(GrBezierEdgeType);
+
+    virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE; 
+
+    GrBezierEdgeType fEdgeType;
+
+    GR_DECLARE_EFFECT_TEST;
+
+    typedef GrEffect INHERITED;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * The output of this effect is a hairline edge for quadratics.
+ * Quadratic specified by 0=u^2-v canonical coords. u and v are the first
+ * two components of the vertex attribute. At the three control points that define
+ * the Quadratic, u, v have the values {0,0}, {1/2, 0}, and {1, 1} respectively.
+ * Coverage for AA is min(0, 1-distance). 3rd & 4th cimponent unused.
+ * Requires shader derivative instruction support.
+ */
+class GrGLQuadEffect;
+
+class GrQuadEffect : public GrEffect {
+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()) {
+                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;
+        }
+    }
+
+    virtual ~GrQuadEffect();
+
+    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; }
+
+    typedef GrGLQuadEffect GLEffect;
+
+    virtual void getConstantColorComponents(GrColor* color,
+                                            uint32_t* validFlags) const SK_OVERRIDE {
+        *validFlags = 0;
+    }
+
+    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; 
+
+private:
+    GrQuadEffect(GrBezierEdgeType);
+
+    virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE; 
+
+    GrBezierEdgeType fEdgeType;
+
+    GR_DECLARE_EFFECT_TEST;
+
+    typedef GrEffect INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+/**
+ * Shader is based off of "Resolution Independent Curve Rendering using
+ * Programmable Graphics Hardware" by Loop and Blinn.
+ * The output of this effect is a hairline edge for non rational cubics.
+ * Cubics are specified by implicit equation K^3 - LM.
+ * K, L, and M, are the first three values of the vertex attribute,
+ * the fourth value is not used. Distance is calculated using a
+ * first order approximation from the taylor series.
+ * Coverage for AA is max(0, 1-distance).
+ */
+class GrGLCubicEffect;
+
+class GrCubicEffect : public GrEffect {
+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()) {
+                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;
+        }
+    }
+
+    virtual ~GrCubicEffect();
+
+    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; }
+
+    typedef GrGLCubicEffect GLEffect;
+
+    virtual void getConstantColorComponents(GrColor* color,
+                                            uint32_t* validFlags) const SK_OVERRIDE {
+        *validFlags = 0;
+    }
+
+    virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE; 
+
+private:
+    GrCubicEffect(GrBezierEdgeType);
+
+    virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE; 
+
+    GrBezierEdgeType fEdgeType;
+
+    GR_DECLARE_EFFECT_TEST;
+
+    typedef GrEffect INHERITED;
+};
+
+#endif