Add direct bezier cubic support for GPU shaders

src/gpu/GrAAHairLinePathRenderer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAHairLinePathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 11 matching lines @@
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLSL.h"
 
 namespace {
 // quadratics are rendered as 5-sided polys in order to bound the
 // AA stroke around the center-curve. See comments in push_quad_index_buffer and
 // bloat_quad. Quadratics and conics share an index buffer
 static const int kVertsPerQuad = 5;
 static const int kIdxsPerQuad = 9;
 
+static const int kVertsPerCubic = 4;
+static const int kIdxsPerCubic = 6;
+
 static const int kVertsPerLineSeg = 4;
 static const int kIdxsPerLineSeg = 6;
 
 static const int kNumQuadsInIdxBuffer = 256;
 static const size_t kQuadIdxSBufize = kIdxsPerQuad *
                                       sizeof(uint16_t) *
                                       kNumQuadsInIdxBuffer;
 
+static const int kNumCubicsInIdxBuffer = 256;
+static const size_t kCubicIdxSBufize = kIdxsPerCubic *
+                                      sizeof(uint16_t) *
+                                      kNumCubicsInIdxBuffer;
+
+bool push_cubic_index_data(GrIndexBuffer* cIdxBuffer) {
+    uint16_t* data = (uint16_t*) cIdxBuffer->lock();
+    bool tempData = NULL == data;
+    if (tempData) {
+        data = SkNEW_ARRAY(uint16_t, kNumCubicsInIdxBuffer * kIdxsPerCubic);
+    }
+    for (int i = 0; i < kNumCubicsInIdxBuffer; ++i) {
+
+        int baseIdx = i * kIdxsPerCubic;
+        uint16_t baseVert = (uint16_t)(i * kVertsPerCubic);
+        
+        data[0 + baseIdx] = baseVert + 0;
+        data[1 + baseIdx] = baseVert + 1;
+        data[2 + baseIdx] = baseVert + 2;
+        data[3 + baseIdx] = baseVert + 2;
+        data[4 + baseIdx] = baseVert + 3;
+        data[5 + baseIdx] = baseVert + 0;
+    }
+    if (tempData) {
+        bool ret = cIdxBuffer->updateData(data, kCubicIdxSBufize);
+        delete[] data;
+        return ret;
+    } else {
+        cIdxBuffer->unlock();
+        return true;
+    }
+}
+
 bool push_quad_index_data(GrIndexBuffer* qIdxBuffer) {
     uint16_t* data = (uint16_t*) qIdxBuffer->lock();
     bool tempData = NULL == data;
     if (tempData) {
         data = SkNEW_ARRAY(uint16_t, kNumQuadsInIdxBuffer * kIdxsPerQuad);
     }
     for (int i = 0; i < kNumQuadsInIdxBuffer; ++i) {
 
         // Each quadratic is rendered as a five sided polygon. This poly bounds
         // the quadratic's bounding triangle but has been expanded so that the
@@ skipping 35 matching lines @@
     if (NULL == lIdxBuffer) {
         return NULL;
     }
     GrGpu* gpu = context->getGpu();
     GrIndexBuffer* qIdxBuf = gpu->createIndexBuffer(kQuadIdxSBufize, false);
     SkAutoTUnref<GrIndexBuffer> qIdxBuffer(qIdxBuf);
     if (NULL == qIdxBuf ||
         !push_quad_index_data(qIdxBuf)) {
         return NULL;
     }
+    GrIndexBuffer* cIdxBuf = gpu->createIndexBuffer(kCubicIdxSBufize, false);
+    SkAutoTUnref<GrIndexBuffer> cIdxBuffer(cIdxBuf);
+    if (NULL == cIdxBuf ||
+        !push_cubic_index_data(cIdxBuf)) {
+        return NULL;
+    }
     return SkNEW_ARGS(GrAAHairLinePathRenderer,
-                      (context, lIdxBuffer, qIdxBuf));
+                      (context, lIdxBuffer, qIdxBuf, cIdxBuf));
 }
 
 GrAAHairLinePathRenderer::GrAAHairLinePathRenderer(
                                         const GrContext* context,
                                         const GrIndexBuffer* linesIndexBuffer,
-                                        const GrIndexBuffer* quadsIndexBuffer) {
+                                        const GrIndexBuffer* quadsIndexBuffer,
+                                        const GrIndexBuffer* cubicsIndexBuffer) {
     fLinesIndexBuffer = linesIndexBuffer;
     linesIndexBuffer->ref();
     fQuadsIndexBuffer = quadsIndexBuffer;
     quadsIndexBuffer->ref();
+    fCubicsIndexBuffer = cubicsIndexBuffer;
+    cubicsIndexBuffer->ref();
 }
 
 GrAAHairLinePathRenderer::~GrAAHairLinePathRenderer() {
     fLinesIndexBuffer->unref();
     fQuadsIndexBuffer->unref();
+    fCubicsIndexBuffer->unref();
 }
 
 namespace {
 
 typedef SkTArray<SkPoint, true> PtArray;
 #define PREALLOC_PTARRAY(N) SkSTArray<(N),SkPoint, true>
 typedef SkTArray<int, true> IntArray;
 typedef SkTArray<float, true> FloatArray;
 
 // Takes 178th time of logf on Z600 / VC2010
@@ skipping 13 matching lines @@
         GrAssert(get_float_exp(100.f) == 6);
         GrAssert(get_float_exp(1000.f) == 9);
         GrAssert(get_float_exp(1024.f) == 10);
         GrAssert(get_float_exp(3000000.f) == 21);
     }
 #endif
     const int* iptr = (const int*)&x;
     return (((*iptr) & 0x7f800000) >> 23) - 127;
 }
 
+//int chop_cubic_at_loop_intersection(const SkPoint src[4], SkPoint dst[10], SkScalar k[3] = NULL,
+//                                    SkScalar l[3] = NULL, SkScalar m[3] = NULL);
+
 // Uses the max curvature function for quads to estimate
 // where to chop the conic. If the max curvature is not
 // found along the curve segment it will return 1 and
 // dst[0] is the original conic. If it returns 2 the dst[0]
 // and dst[1] are the two new conics.
 int split_conic(const SkPoint src[3], SkConic dst[2], const SkScalar weight) {
     SkScalar t = SkFindQuadMaxCurvature(src);
     if (t == 0) {
         if (dst) {
             dst[0].set(src, weight);
@@ skipping 17 matching lines @@
     int conicCnt = split_conic(src, dstTemp, weight);
     if (2 == conicCnt) {
         int conicCnt2 = split_conic(dstTemp[0].fPts, dst, dstTemp[0].fW);
         conicCnt = conicCnt2 + split_conic(dstTemp[1].fPts, &dst[conicCnt2], dstTemp[1].fW);
     } else {
         dst[0] = dstTemp[0];
     }
     return conicCnt;
 }
 
+int is_degen_cubic(const SkPoint p[4]) {
+    static const SkScalar gDegenerateToLineTol = SK_Scalar1;
+    static const SkScalar gDegenerateToLineTolSqd =
+        SkScalarMul(gDegenerateToLineTol, gDegenerateToLineTol);
+
+    if (p[0].distanceToSqd(p[3]) < gDegenerateToLineTolSqd &&
+        p[1].distanceToSqd(p[2]) < gDegenerateToLineTolSqd) {
+        return 1;
+    }
+
+    // if the points are all close to being colinear
+    SkScalar dsqd1= p[1].distanceToLineBetweenSqd(p[0], p[3]);
+    SkScalar dsqd2= p[2].distanceToLineBetweenSqd(p[0], p[3]);
+    if (dsqd1 < gDegenerateToLineTolSqd && dsqd2 < gDegenerateToLineTolSqd) {
+        return 1;
+    }
+
+    return 0;
+    
+}
+
 // returns 0 if quad/conic is degen or close to it
 // in this case approx the path with lines
 // otherwise returns 1
 int is_degen_quad_or_conic(const SkPoint p[3]) {
     static const SkScalar gDegenerateToLineTol = SK_Scalar1;
     static const SkScalar gDegenerateToLineTolSqd =
         SkScalarMul(gDegenerateToLineTol, gDegenerateToLineTol);
 
     if (p[0].distanceToSqd(p[1]) < gDegenerateToLineTolSqd ||
         p[1].distanceToSqd(p[2]) < gDegenerateToLineTolSqd) {
@@ skipping 70 matching lines @@
  * perspective, then in they are in src space. We do this because we will
  * subdivide large quads to reduce over-fill. This subdivision has to be
  * performed before applying the perspective matrix.
  */
 int generate_lines_and_quads(const SkPath& path,
                              const SkMatrix& m,
                              const SkIRect& devClipBounds,
                              PtArray* lines,
                              PtArray* quads,
                              PtArray* conics,
+                             PtArray* cubics,
                              IntArray* quadSubdivCnts,
-                             FloatArray* conicWeights) {
+                             FloatArray* conicWeights,
+                             FloatArray* cubicKLM) {
     SkPath::Iter iter(path, false);
 
     int totalQuadCount = 0;
     SkRect bounds;
     SkIRect ibounds;
 
     bool persp = m.hasPerspective();
 
     for (;;) {
         GrPoint pathPts[4];
@@ skipping 76 matching lines @@
                             pts[0] = qPts[0];
                             pts[1] = qPts[1];
                             pts[2] = qPts[2];
                             quadSubdivCnts->push_back() = subdiv;
                             totalQuadCount += 1 << subdiv;
                         }
                     }
                 }
                 break;
             }
-            case SkPath::kCubic_Verb:
+            case SkPath::kCubic_Verb: {
+                SkPoint dst[10];
+                SkScalar klm[9];
+                SkScalar klm_rev[3];
                 m.mapPoints(devPts, pathPts, 4);
-                bounds.setBounds(devPts, 4);
-                bounds.outset(SK_Scalar1, SK_Scalar1);
-                bounds.roundOut(&ibounds);
-                if (SkIRect::Intersects(devClipBounds, ibounds)) {
-                    PREALLOC_PTARRAY(32) q;
-                    // we don't need a direction if we aren't constraining the subdivision
-                    static const SkPath::Direction kDummyDir = SkPath::kCCW_Direction;
-                    // We convert cubics to quadratics (for now).
-                    // In perspective have to do conversion in src space.
-                    if (persp) {
-                        SkScalar tolScale =
-                            GrPathUtils::scaleToleranceToSrc(SK_Scalar1, m,
-                                                             path.getBounds());
-                        GrPathUtils::convertCubicToQuads(pathPts, tolScale, false, kDummyDir, &q);
-                    } else {
-                        GrPathUtils::convertCubicToQuads(devPts, SK_Scalar1, false, kDummyDir, &q);
-                    }
-                    for (int i = 0; i < q.count(); i += 3) {
-                        SkPoint* qInDevSpace;
-                        // bounds has to be calculated in device space, but q is
-                        // in src space when there is perspective.
-                        if (persp) {
-                            m.mapPoints(devPts, &q[i], 3);
-                            bounds.setBounds(devPts, 3);
-                            qInDevSpace = devPts;
+                int cubicCnt = GrPathUtils::chopCubicAtLoopIntersection(pathPts, dst, klm,
+                                                                        klm_rev, devPts);
+                for (int i = 0; i < cubicCnt; ++i) {
+                    SkPoint* chopPnts = &dst[i*3];
+                    m.mapPoints(devPts, chopPnts, 4);
+                    bounds.setBounds(devPts, 4);
+                    bounds.outset(SK_Scalar1, SK_Scalar1);
+                    bounds.roundOut(&ibounds);
+                    if (SkIRect::Intersects(devClipBounds, ibounds)) {
+                        if (is_degen_cubic(devPts)) {
+                            SkPoint* pts = lines->push_back_n(6);
+                            pts[0] = devPts[0];
+                            pts[1] = devPts[1];
+                            pts[2] = devPts[1];
+                            pts[3] = devPts[2];
+                            pts[4] = devPts[2];
+                            pts[5] = devPts[3];
                         } else {
-                            bounds.setBounds(&q[i], 3);
-                            qInDevSpace = &q[i];
-                        }
-                        bounds.outset(SK_Scalar1, SK_Scalar1);
-                        bounds.roundOut(&ibounds);
-                        if (SkIRect::Intersects(devClipBounds, ibounds)) {
-                            int subdiv = num_quad_subdivs(qInDevSpace);
-                            GrAssert(subdiv >= -1);
-                            if (-1 == subdiv) {
-                                SkPoint* pts = lines->push_back_n(4);
-                                // lines should always be in device coords
-                                pts[0] = qInDevSpace[0];
-                                pts[1] = qInDevSpace[1];
-                                pts[2] = qInDevSpace[1];
-                                pts[3] = qInDevSpace[2];
-                            } else {
-                                SkPoint* pts = quads->push_back_n(3);
-                                // q is already in src space when there is no
-                                // perspective and dev coords otherwise.
-                                pts[0] = q[0 + i];
-                                pts[1] = q[1 + i];
-                                pts[2] = q[2 + i];
-                                quadSubdivCnts->push_back() = subdiv;
-                                totalQuadCount += 1 << subdiv;
+                            // when in perspective keep conics in src space
+                            SkPoint* cPts = persp ? chopPnts : devPts;
+                            SkPoint* pts = cubics->push_back_n(4);
+                            pts[0] = cPts[0];
+                            pts[1] = cPts[1];
+                            pts[2] = cPts[2];
+                            pts[3] = cPts[3];
+                            SkScalar* klms = cubicKLM->push_back_n(9);
+                            // set sub sections klm to equal klm of whole curve and 
+                            // flip the signs of k, l if needed
+                            memcpy(klms, klm, 9 * sizeof(SkScalar));
+                            for (int j = 0; j < 6; ++j) {
+                                klms[j] *= klm_rev[i];
                             }
                         }
                     }
                 }
                 break;
+            }
             case SkPath::kClose_Verb:
                 break;
             case SkPath::kDone_Verb:
                 return totalQuadCount;
         }
     }
 }
 
 struct Vertex {
     GrPoint fPos;
     union {
         struct {
             SkScalar fA;
             SkScalar fB;
             SkScalar fC;
         } fLine;
         struct {
             SkScalar fK;
             SkScalar fL;
             SkScalar fM;
-        } fConic;
+        } fBezier;
         GrVec   fQuadCoord;
         struct {
             SkScalar fBogus[4];
         };
     };
 };
 
 GR_STATIC_ASSERT(sizeof(Vertex) == 3 * sizeof(GrPoint));
 
 void intersect_lines(const SkPoint& ptA, const SkVector& normA,
@@ skipping 13 matching lines @@
     result->fY = SkScalarMul(lineAW, normB.fX) - SkScalarMul(normA.fX, lineBW);
     result->fY = SkScalarMul(result->fY, wInv);
 }
 
 void set_uv_quad(const SkPoint qpts[3], Vertex verts[kVertsPerQuad]) {
     // this should be in the src space, not dev coords, when we have perspective
     GrPathUtils::QuadUVMatrix DevToUV(qpts);
     DevToUV.apply<kVertsPerQuad, sizeof(Vertex), sizeof(GrPoint)>(verts);
 }
 
+// Set verts to be bounding box around the control points cpts bloated
+// out by 1 in each direcition
+void bloat_cubic(const SkPoint cpts[4], const SkMatrix* toDevice,
+                const SkMatrix* toSrc, Vertex verts[kVertsPerCubic],
+                SkRect* devBounds) {
+    GrAssert(!toDevice == !toSrc);
+    // original cubic is specified by quad a,b,c,d
+    SkPoint a = cpts[0];
+    SkPoint b = cpts[1];
+    SkPoint c = cpts[2];
+    SkPoint d = cpts[3];
+
+    if (toDevice) {
+        toDevice->mapPoints(&a, 1);
+        toDevice->mapPoints(&b, 1);
+        toDevice->mapPoints(&c, 1);
+        toDevice->mapPoints(&d, 1);
+    }
+   
+    SkScalar minX = cpts[0].fX;
+    SkScalar maxX = cpts[0].fX;
+    SkScalar minY = cpts[0].fY;
+    SkScalar maxY = cpts[0].fY;
+
+    for (int i = 1; i < 4; ++i) {
+        minX = SkMinScalar(minX, cpts[i].fX);
+        maxX = SkMaxScalar(maxX, cpts[i].fX);
+        minY = SkMinScalar(minY, cpts[i].fY);
+        maxY = SkMaxScalar(maxY, cpts[i].fY);
+    }
+
+    minX -= 1.0f;
+    maxX += 1.0f;
+    minY -= 1.0f;
+    maxY += 1.0f;
+
+    Vertex& a1 = verts[0];
+    Vertex& b1 = verts[1];
+    Vertex& c1 = verts[2];
+    Vertex& d1 = verts[3];
+
+    a1.fPos.fX = minX;
+    a1.fPos.fY = minY;
+    b1.fPos.fX = maxX;
+    b1.fPos.fY = minY;
+    c1.fPos.fX = maxX;
+    c1.fPos.fY = maxY;
+    d1.fPos.fX = minX;
+    d1.fPos.fY = maxY;
+
+    devBounds->growToInclude(a1.fPos.fX, a1.fPos.fY);
+    devBounds->growToInclude(b1.fPos.fX, b1.fPos.fY);
+    devBounds->growToInclude(c1.fPos.fX, c1.fPos.fY);
+    devBounds->growToInclude(d1.fPos.fX, d1.fPos.fY);
+
+    if (toSrc) {
+        toSrc->mapPointsWithStride(&verts[0].fPos, sizeof(Vertex), kVertsPerCubic);
+    }
+}
+
 void bloat_quad(const SkPoint qpts[3], const SkMatrix* toDevice,
                 const SkMatrix* toSrc, Vertex verts[kVertsPerQuad],
                 SkRect* devBounds) {
     GrAssert(!toDevice == !toSrc);
     // original quad is specified by tri a,b,c
     SkPoint a = qpts[0];
     SkPoint b = qpts[1];
     SkPoint c = qpts[2];
 
     if (toDevice) {
@@ skipping 86 matching lines @@
     k[2] = (p[2].fX - p[0].fX) * p[0].fY - (p[2].fY - p[0].fY) * p[0].fX;
 
     // scale the max absolute value of coeffs to 10
     SkScalar scale = 0.0f;
     for (int i = 0; i < 3; ++i) {
        scale = SkMaxScalar(scale, SkScalarAbs(k[i]));
        scale = SkMaxScalar(scale, SkScalarAbs(l[i]));
        scale = SkMaxScalar(scale, SkScalarAbs(m[i]));
     }
     GrAssert(scale > 0);
-    scale /= 10.0f;
-    k[0] /= scale;
-    k[1] /= scale;
-    k[2] /= scale;
-    l[0] /= scale;
-    l[1] /= scale;
-    l[2] /= scale;
-    m[0] /= scale;
-    m[1] /= scale;
-    m[2] /= scale;
+    scale = 10.0f / scale;
+    k[0] *= scale;
+    k[1] *= scale;
+    k[2] *= scale;
+    l[0] *= scale;
+    l[1] *= scale;
+    l[2] *= scale;
+    m[0] *= scale;
+    m[1] *= scale;
+    m[2] *= scale;
 }
 
 // Equations based off of Loop-Blinn Quadratic GPU Rendering
 // Input Parametric:
 // P(t) = (P0*(1-t)^2 + 2*w*P1*t*(1-t) + P2*t^2) / (1-t)^2 + 2*w*t*(1-t) + t^2)
 // Output Implicit:
 // f(x, y, w) = f(P) = K^2 - LM
 // K = dot(k, P), L = dot(l, P), M = dot(m, P)
 // k, l, m are calculated in function calc_conic_klm
-void set_conic_coeffs(const SkPoint p[3], Vertex verts[kVertsPerQuad], const float weight) {
+void set_conic_klm(const SkPoint p[3], Vertex verts[kVertsPerQuad], const float weight) {
     SkScalar k[3];
     SkScalar l[3];
     SkScalar m[3];
 
     calc_conic_klm(p, weight, k, l, m);
 
     for (int i = 0; i < kVertsPerQuad; ++i) {
         const SkPoint pnt = verts[i].fPos;
-        verts[i].fConic.fK = pnt.fX * k[0] + pnt.fY * k[1] + k[2];
-        verts[i].fConic.fL = pnt.fX * l[0] + pnt.fY * l[1] + l[2];
-        verts[i].fConic.fM = pnt.fX * m[0] + pnt.fY * m[1] + m[2];
+        verts[i].fBezier.fK = pnt.fX * k[0] + pnt.fY * k[1] + k[2];
+        verts[i].fBezier.fL = pnt.fX * l[0] + pnt.fY * l[1] + l[2];
+        verts[i].fBezier.fM = pnt.fX * m[0] + pnt.fY * m[1] + m[2];
     }
 }
 
+void set_cubic_klm(const SkPoint p[4], Vertex verts[kVertsPerCubic], const SkScalar klm[9]) {
+    for (int i = 0; i < kVertsPerCubic; ++i) {
+        const SkPoint pnt = verts[i].fPos;
+        verts[i].fBezier.fK = pnt.fX * klm[0] + pnt.fY * klm[1] + klm[2];
+        verts[i].fBezier.fL = pnt.fX * klm[3] + pnt.fY * klm[4] + klm[5];
+        verts[i].fBezier.fM = pnt.fX * klm[6] + pnt.fY * klm[7] + klm[8];
+    }
+}
+
+void add_cubics(const SkPoint p[3],
+                const SkScalar klm[9],
+                const SkMatrix* toDevice,
+                const SkMatrix* toSrc,
+                Vertex** vert,
+                SkRect* devBounds) {
+    bloat_cubic(p, toDevice, toSrc, *vert, devBounds);
+    set_cubic_klm(p, *vert, klm);
+    *vert += kVertsPerCubic;
+}
+
 void add_conics(const SkPoint p[3],
                 float weight,
                 const SkMatrix* toDevice,
                 const SkMatrix* toSrc,
                 Vertex** vert,
                 SkRect* devBounds) {
     bloat_quad(p, toDevice, toSrc, *vert, devBounds);
-    set_conic_coeffs(p, *vert, weight);
+    set_conic_klm(p, *vert, weight);
     *vert += kVertsPerQuad;
 }
 
 void add_quads(const SkPoint p[3],
                int subdiv,
                const SkMatrix* toDevice,
                const SkMatrix* toSrc,
                Vertex** vert,
                SkRect* devBounds) {
     GrAssert(subdiv >= 0);
@@ skipping 46 matching lines @@
         (*vert)[2].fPos.set(SK_ScalarMax, SK_ScalarMax);
         (*vert)[3].fPos.set(SK_ScalarMax, SK_ScalarMax);
     }
 
     *vert += kVertsPerLineSeg;
 }
 
 }
 
 /**
+ * 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).
  */
 
 /**
@@ skipping 328 matching lines @@
     {kVec4f_GrVertexAttribType, sizeof(GrPoint),    kEffect_GrVertexAttribBinding}
 };
 };
 
 bool GrAAHairLinePathRenderer::createGeom(
             const SkPath& path,
             GrDrawTarget* target,
             int* lineCnt,
             int* quadCnt,
             int* conicCnt,
+            int* cubicCnt,
             GrDrawTarget::AutoReleaseGeometry* arg,
             SkRect* devBounds) {
     GrDrawState* drawState = target->drawState();
     int rtHeight = drawState->getRenderTarget()->height();
 
     SkIRect devClipBounds;
     target->getClip()->getConservativeBounds(drawState->getRenderTarget(), &devClipBounds);
 
     SkMatrix viewM = drawState->getViewMatrix();
 
     // All the vertices that we compute are within 1 of path control points with the exception of
     // one of the bounding vertices for each quad. The add_quads() function will update the bounds
     // for each quad added.
     *devBounds = path.getBounds();
     viewM.mapRect(devBounds);
     devBounds->outset(SK_Scalar1, SK_Scalar1);
 
     PREALLOC_PTARRAY(128) lines;
     PREALLOC_PTARRAY(128) quads;
     PREALLOC_PTARRAY(128) conics;
+    PREALLOC_PTARRAY(128) cubics;
     IntArray qSubdivs;
     FloatArray cWeights;
+    FloatArray cubicKLM;
     *quadCnt = generate_lines_and_quads(path, viewM, devClipBounds,
-                                        &lines, &quads, &conics, &qSubdivs, &cWeights);
+                                        &lines, &quads, &conics, &cubics,
+                                        &qSubdivs, &cWeights, &cubicKLM);
 
     *lineCnt = lines.count() / 2;
     *conicCnt = conics.count() / 3;
+    *cubicCnt = cubics.count() / 4;
     int vertCnt = kVertsPerLineSeg * *lineCnt + kVertsPerQuad * *quadCnt +
-        kVertsPerQuad * *conicCnt;
+        kVertsPerQuad * *conicCnt + kVertsPerCubic * *cubicCnt;
 
     target->drawState()->setVertexAttribs<gHairlineAttribs>(SK_ARRAY_COUNT(gHairlineAttribs));
     GrAssert(sizeof(Vertex) == target->getDrawState().getVertexSize());
 
     if (!arg->set(target, vertCnt, 0)) {
         return false;
     }
 
     Vertex* verts = reinterpret_cast<Vertex*>(arg->vertices());
 
@@ skipping 11 matching lines @@
     for (int i = 0; i < *lineCnt; ++i) {
         add_line(&lines[2*i], rtHeight, toSrc, &verts);
     }
 
     int unsubdivQuadCnt = quads.count() / 3;
     for (int i = 0; i < unsubdivQuadCnt; ++i) {
         GrAssert(qSubdivs[i] >= 0);
         add_quads(&quads[3*i], qSubdivs[i], toDevice, toSrc, &verts, devBounds);
     }
 
-    // Start Conics
     for (int i = 0; i < *conicCnt; ++i) {
         add_conics(&conics[3*i], cWeights[i], toDevice, toSrc, &verts, devBounds);
     }
+    
+    for (int i = 0; i < *cubicCnt; ++i) {
+        add_cubics(&cubics[4*i], &cubicKLM[9*i], toDevice, toSrc, &verts, devBounds);
+    }
     return true;
 }
 
 bool GrAAHairLinePathRenderer::canDrawPath(const SkPath& path,
                                            const SkStrokeRec& stroke,
                                            const GrDrawTarget* target,
                                            bool antiAlias) const {
     if (!stroke.isHairlineStyle() || !antiAlias) {
         return false;
     }
 
     if (SkPath::kLine_SegmentMask == path.getSegmentMasks() ||
         target->caps()->shaderDerivativeSupport()) {
         return true;
     }
     return false;
 }
 
 bool GrAAHairLinePathRenderer::onDrawPath(const SkPath& path,
                                           const SkStrokeRec&,
                                           GrDrawTarget* target,
                                           bool antiAlias) {
 
     int lineCnt;
     int quadCnt;
     int conicCnt;
+    int cubicCnt;
     GrDrawTarget::AutoReleaseGeometry arg;
     SkRect devBounds;
 
     if (!this->createGeom(path,
                           target,
                           &lineCnt,
                           &quadCnt,
                           &conicCnt,
+                          &cubicCnt,
                           &arg,
                           &devBounds)) {
         return false;
     }
 
     GrDrawTarget::AutoStateRestore asr;
 
     // createGeom transforms the geometry to device space when the matrix does not have
     // perspective.
     if (target->getDrawState().getViewMatrix().hasPerspective()) {
         asr.set(target, GrDrawTarget::kPreserve_ASRInit);
     } else if (!asr.setIdentity(target, GrDrawTarget::kPreserve_ASRInit)) {
         return false;
     }
     GrDrawState* drawState = target->drawState();
 
     // TODO: See whether rendering lines as degenerate quads improves perf
     // when we have a mix
 
     static const int kEdgeAttrIndex = 1;
 
     GrEffectRef* hairLineEffect = HairLineEdgeEffect::Create();
     GrEffectRef* hairQuadEffect = HairQuadEdgeEffect::Create();
     GrEffectRef* hairConicEffect = HairConicEdgeEffect::Create();
+    GrEffectRef* hairCubicEffect = HairCubicEdgeEffect::Create();
 
     // Check devBounds
 #if GR_DEBUG
     SkRect tolDevBounds = devBounds;
     tolDevBounds.outset(SK_Scalar1 / 10000, SK_Scalar1 / 10000);
     SkRect actualBounds;
     Vertex* verts = reinterpret_cast<Vertex*>(arg.vertices());
     int vCount = kVertsPerLineSeg * lineCnt + kVertsPerQuad * quadCnt + kVertsPerQuad * conicCnt;
     bool first = true;
     for (int i = 0; i < vCount; ++i) {
@@ skipping 46 matching lines @@
                                 kVertsPerQuad*n,                                   // vCount
                                 kIdxsPerQuad*n,                                    // iCount
                                 &devBounds);
             quads += n;
         }
     }
 
     {
         GrDrawState::AutoRestoreEffects are(drawState);
         int conics = 0;
-        drawState->addCoverageEffect(hairConicEffect, 1, 2)->unref();
+        drawState->addCoverageEffect(hairConicEffect, kEdgeAttrIndex)->unref();
         while (conics < conicCnt) {
             int n = GrMin(conicCnt - conics, kNumQuadsInIdxBuffer);
             target->drawIndexed(kTriangles_GrPrimitiveType,
                                 kVertsPerLineSeg*lineCnt +
                                 kVertsPerQuad*(quadCnt + conics),  // startV
                                 0,                                 // startI
                                 kVertsPerQuad*n,                   // vCount
                                 kIdxsPerQuad*n,                    // iCount
                                 &devBounds);
             conics += n;
         }
     }
+    
+    {
+        GrDrawState::AutoRestoreEffects are(drawState);
+        target->setIndexSourceToBuffer(fCubicsIndexBuffer);
+        int cubics = 0;
+        drawState->addCoverageEffect(hairCubicEffect, kEdgeAttrIndex)->unref();
+        while (cubics < cubicCnt) {
+            int n = GrMin(cubicCnt - cubics, kNumCubicsInIdxBuffer);
+            target->drawIndexed(kTriangles_GrPrimitiveType,
+                                kVertsPerLineSeg * lineCnt +
+                                kVertsPerQuad * (quadCnt + conicCnt) +
+                                kVertsPerCubic * cubics,                            // startV
+                                0,                                                  // startI
+                                kVertsPerCubic*n,                                   // vCount
+                                kIdxsPerCubic*n,                                    // iCount
+                                &devBounds);
+            cubics += n;
+        }
+    }
     target->resetIndexSource();
 
     return true;
 }