Pull out Effect Shaders in GPU Path Renderer

src/gpu/effects/GrBezierEffect.h

+/*
+ * 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"
+
+enum BezierEffectType {

[bsalomon, 2013/08/21 20:04:39]

I'm wondering if there is something more specific we could call this.
BezierEdgeType?
BezierEdgeFill?
BezierEdgeStyle?


Also should be GrFoo {
kA_GrFoo,
kB_GrFoo,...
}
if it's not scoped by a Gr class or namespace

[egdaniel, 2013/08/21 20:18:06]

I say either GrBezierEdgeType or Style...wish there was a shorter and more
descriptive way since we end up with things like, kFillAA_GrBezierEdgeType which
seems so wordy 

On 2013/08/21 20:04:39, bsalomon wrote:

+    kFillAA_BezierEffectType,
+    kHairAA_BezierEffectType,
+    kFillNoAA_BezierEffectType,
+};
+
+/**
+ * Shader is based off of Loop-Blinn Quadratic GPU Rendering

[bsalomon, 2013/08/21 20:04:39]

Should we merge this comment block with the next one?

[egdaniel, 2013/08/21 20:18:06]

Yeah, I just left them separate at first since the top part was more explaining
the implemented function where as the bottom was all about additional non
implemented test we tried.
On 2013/08/21 20:04:39, bsalomon wrote:

+ * 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 GrGLConicEffect;
+
+class GrConicEffect : public GrEffect {
+public:
+    static GrEffectRef* Create(BezierEffectType effectType) {

[bsalomon, 2013/08/21 20:11:29]

Do we need to check or assert that we have derivative support in these
factories?

[egdaniel, 2013/08/21 20:18:06]

I suppose we should. Before we relied on the PathRenderer to do that check for
us, but since these are stand alone we should. Also the non-AA doesn't need it

On 2013/08/21 20:11:29, bsalomon wrote:

+        GR_CREATE_STATIC_EFFECT(gConicFillNoAA, GrConicEffect, (false, true));

[bsalomon, 2013/08/21 20:04:39]

It seems like we should just plumb the enum value all the way down rather than
converting it to two bools here (and repeating this for the other curve types).

could have helpers:
static inline bool GrBezierEdgeTypeIsFill(BezierEdgeType);
static inline bool GrBezierEdgeTypeIsAA(BezierEdgeType);

if it helps.

[egdaniel, 2013/08/21 20:18:06]

Will do
On 2013/08/21 20:04:39, bsalomon wrote:

+        GR_CREATE_STATIC_EFFECT(gConicFillAA, GrConicEffect, (true, true));
+        GR_CREATE_STATIC_EFFECT(gConicHairAA, GrConicEffect, (true, false));
+        if (kFillAA_BezierEffectType == effectType) {
+            gConicFillAA->ref();
+            return gConicFillAA;
+        } else if (kHairAA_BezierEffectType == effectType) {
+            gConicHairAA->ref();
+            return gConicHairAA;
+        } else { 
+            gConicFillNoAA->ref();
+            return gConicFillNoAA;
+        }
+    }
+
+    virtual ~GrConicEffect();
+
+    static const char* Name() { return "Conic"; }
+
+    inline bool isAntiAliased() const { return fAntiAlias; }
+    inline bool isFilled() const { return fFill; }
+
+    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(bool antiAlias, bool fill); 
+
+    virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE; 
+
+    bool fAntiAlias;
+    bool fFill;
+
+    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. Uses unsigned distance.
+ * Coverage is min(0, 1-distance). 3rd & 4th component unused.

[bsalomon, 2013/08/21 20:04:39]

maybe we should say somewhere in here that uv is {0,0}, {1/2, 0} and {1, 1} at
the control pts.

[egdaniel, 2013/08/21 20:18:06]

Adding it.

On 2013/08/21 20:04:39, bsalomon wrote:

+ * Requires shader derivative instruction support.
+ */
+class GrGLQuadEffect;
+
+class GrQuadEffect : public GrEffect {
+public:
+    static GrEffectRef* Create(BezierEffectType effectType) {
+        GR_CREATE_STATIC_EFFECT(gQuadFillNoAA, GrQuadEffect, (false, true));
+        GR_CREATE_STATIC_EFFECT(gQuadFillAA, GrQuadEffect, (true, true));
+        GR_CREATE_STATIC_EFFECT(gQuadHairAA, GrQuadEffect, (true, false));
+        if (kFillAA_BezierEffectType == effectType) {
+            gQuadFillAA->ref();
+            return gQuadFillAA;
+        } else if (kHairAA_BezierEffectType == effectType) {
+            gQuadHairAA->ref();
+            return gQuadHairAA;
+        } else { 
+            gQuadFillNoAA->ref();
+            return gQuadFillNoAA;
+        }
+    }
+
+    virtual ~GrQuadEffect();
+
+    static const char* Name() { return "Quad"; }
+
+    inline bool isAntiAliased() const { return fAntiAlias; }
+    inline bool isFilled() const { return fFill; }
+
+    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(bool antiAlias, bool fill); 
+
+    virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE; 
+
+    bool fAntiAlias;
+    bool fFill;
+
+    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 is max(0, 1-distance).
+ */
+class GrGLCubicEffect;
+
+class GrCubicEffect : public GrEffect {
+public:
+    static GrEffectRef* Create(BezierEffectType effectType) {
+        GR_CREATE_STATIC_EFFECT(gCubicFillNoAA, GrCubicEffect, (false, true));
+        GR_CREATE_STATIC_EFFECT(gCubicFillAA, GrCubicEffect, (true, true));
+        GR_CREATE_STATIC_EFFECT(gCubicHairAA, GrCubicEffect, (true, false));
+        if (kFillAA_BezierEffectType == effectType) {
+            gCubicFillAA->ref();
+            return gCubicFillAA;
+        } else if (kHairAA_BezierEffectType == effectType) {
+            gCubicHairAA->ref();
+            return gCubicHairAA;
+        } else { 
+            gCubicFillNoAA->ref();
+            return gCubicFillNoAA;
+        }
+    }
+
+    virtual ~GrCubicEffect();
+
+    static const char* Name() { return "Cubic"; }
+
+    inline bool isAntiAliased() const { return fAntiAlias; }
+    inline bool isFilled() const { return fFill; }
+
+    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(bool antiAlias, bool fill); 
+
+    virtual bool onIsEqual(const GrEffect& other) const SK_OVERRIDE; 
+
+    bool fAntiAlias;
+    bool fFill;
+
+    GR_DECLARE_EFFECT_TEST;
+
+    typedef GrEffect INHERITED;
+};
+
+#endif