Dash using vertex attributes for interval and stroke width

src/gpu/effects/GrDashingEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDashingEffect.h"
 
 #include "../GrAARectRenderer.h"
@@ skipping 49 matching lines @@
         return false;
     }
 
     return true;
 }
 
 namespace {
 struct DashLineVertex {
     SkPoint fPos;
     SkPoint fDashPos;
+    SkScalar fIntervalLength;
+    SkRect fRect;
+};
+struct DashCircleVertex {
+    SkPoint fPos;
+    SkPoint fDashPos;
+    SkScalar fRadius;
+    SkScalar fCenterX;
+    SkScalar fIntervalLength;

[egdaniel, 2015/02/03 14:45:59]

move fIntervalLength before radius and center to match the LineVertex structure

 };
 };
 
 static void calc_dash_scaling(SkScalar* parallelScale, SkScalar* perpScale,
                             const SkMatrix& viewMatrix, const SkPoint pts[2]) {
     SkVector vecSrc = pts[1] - pts[0];
     SkScalar magSrc = vecSrc.length();
     SkScalar invSrc = magSrc ? SkScalarInvert(magSrc) : 0;
     vecSrc.scale(invSrc);
 
@@ skipping 51 matching lines @@
     }
     if (*endingInt > info.fIntervals[0]) {
         if (0 == info.fIntervals[0]) {
             *endingInt -= 0.01f; // make sure we capture the last zero size pnt (used if has caps)
         }
         return *endingInt - info.fIntervals[0];
     }
     return 0;
 }
 
-static void setup_dashed_rect(const SkRect& rect, DashLineVertex* verts, int idx, const SkMatrix& matrix,
-                       SkScalar offset, SkScalar bloat, SkScalar len, SkScalar stroke) {
-        SkScalar startDashX = offset - bloat;
-        SkScalar endDashX = offset + len + bloat;
-        SkScalar startDashY = -stroke - bloat;
-        SkScalar endDashY = stroke + bloat;
-        verts[idx].fDashPos = SkPoint::Make(startDashX , startDashY);
-        verts[idx + 1].fDashPos = SkPoint::Make(startDashX, endDashY);
-        verts[idx + 2].fDashPos = SkPoint::Make(endDashX, endDashY);
-        verts[idx + 3].fDashPos = SkPoint::Make(endDashX, startDashY);
-        verts[idx].fPos = SkPoint::Make(rect.fLeft, rect.fTop);
-        verts[idx + 1].fPos = SkPoint::Make(rect.fLeft, rect.fBottom);
-        verts[idx + 2].fPos = SkPoint::Make(rect.fRight, rect.fBottom);
-        verts[idx + 3].fPos = SkPoint::Make(rect.fRight, rect.fTop);
-        matrix.mapPointsWithStride(&verts[idx].fPos, sizeof(DashLineVertex), 4);
+enum DashCap {
+    kRound_DashCap,
+    kNonRound_DashCap,
+};
+
+template <typename T>
+void setup_dashed_rect_common(const SkRect& rect, const SkMatrix& matrix, T* vertices, int idx,
+                              SkScalar offset, SkScalar bloat, SkScalar len, SkScalar stroke) {
+    SkScalar startDashX = offset - bloat;
+    SkScalar endDashX = offset + len + bloat;
+    SkScalar startDashY = -stroke - bloat;
+    SkScalar endDashY = stroke + bloat;
+    vertices[idx].fDashPos = SkPoint::Make(startDashX , startDashY);
+    vertices[idx + 1].fDashPos = SkPoint::Make(startDashX, endDashY);
+    vertices[idx + 2].fDashPos = SkPoint::Make(endDashX, endDashY);
+    vertices[idx + 3].fDashPos = SkPoint::Make(endDashX, startDashY);
+
+    vertices[idx].fPos = SkPoint::Make(rect.fLeft, rect.fTop);
+    vertices[idx + 1].fPos = SkPoint::Make(rect.fLeft, rect.fBottom);
+    vertices[idx + 2].fPos = SkPoint::Make(rect.fRight, rect.fBottom);
+    vertices[idx + 3].fPos = SkPoint::Make(rect.fRight, rect.fTop);
+
+    matrix.mapPointsWithStride(&vertices[idx].fPos, sizeof(T), 4);
+}
+
+static void setup_dashed_rect(const SkRect& rect, void* vertices, int idx,
+                              const SkMatrix& matrix, SkScalar offset, SkScalar bloat,
+                              SkScalar len, SkScalar stroke, SkScalar startInterval,
+                              SkScalar endInterval, SkScalar strokeWidth, DashCap cap,
+                              const size_t vertexStride) {
+    SkScalar intervalLength = startInterval + endInterval;
+
+    if (kRound_DashCap == cap) {
+        SkASSERT(vertexStride == sizeof(DashCircleVertex));
+        DashCircleVertex* verts = reinterpret_cast<DashCircleVertex*>(vertices);
+
+        setup_dashed_rect_common<DashCircleVertex>(rect, matrix, verts, idx, offset, bloat, len,
+                                                   stroke);
+
+        SkScalar radius = SkScalarHalf(strokeWidth) - 0.5f;
+        SkScalar centerX = SkScalarHalf(endInterval);
+        verts[idx].fIntervalLength = intervalLength;
+        verts[idx].fRadius = radius;
+        verts[idx].fCenterX = centerX;
+        verts[idx + 1].fRadius = radius;

[bsalomon, 2015/02/03 01:02:01]

nit, optional.. prolly fewer lines to write this as a loop

+        verts[idx + 1].fCenterX = centerX;
+        verts[idx + 1].fIntervalLength = intervalLength;
+        verts[idx + 2].fRadius = radius;
+        verts[idx + 2].fCenterX = centerX;
+        verts[idx + 2].fIntervalLength = intervalLength;
+        verts[idx + 3].fRadius = radius;
+        verts[idx + 3].fCenterX = centerX;
+        verts[idx + 3].fIntervalLength = intervalLength;
+
+    } else {
+        SkASSERT(kNonRound_DashCap == cap && vertexStride == sizeof(DashLineVertex));

[egdaniel, 2015/02/03 14:45:59]

is the NonRound assert really needed since we already are checking this with the
if

+        DashLineVertex* verts = reinterpret_cast<DashLineVertex*>(vertices);
+
+        setup_dashed_rect_common<DashLineVertex>(rect, matrix, verts, idx, offset, bloat, len,
+                                                 stroke);
+
+        SkScalar halfOffLen = SkScalarHalf(endInterval);
+        SkScalar halfStroke = SkScalarHalf(strokeWidth);
+        verts[idx].fIntervalLength = intervalLength;
+        verts[idx].fRect.set(halfOffLen + 0.5f, -halfStroke + 0.5f,

[egdaniel, 2015/02/03 14:45:59]

as with Brians comment, probably can loop this. Also maybe just make the rect
locally once and I think you can use join(SkRect) to reduce the code here.

+                             halfOffLen + startInterval - 0.5f, halfStroke - 0.5f);
+        verts[idx + 1].fIntervalLength = intervalLength;
+        verts[idx + 1].fRect.set(halfOffLen + 0.5f, -halfStroke + 0.5f,
+                                 halfOffLen + startInterval - 0.5f, halfStroke - 0.5f);
+        verts[idx + 2].fIntervalLength = intervalLength;
+        verts[idx + 2].fRect.set(halfOffLen + 0.5f, -halfStroke + 0.5f,
+                                 halfOffLen + startInterval - 0.5f, halfStroke - 0.5f);
+        verts[idx + 3].fIntervalLength = intervalLength;
+        verts[idx + 3].fRect.set(halfOffLen + 0.5f, -halfStroke + 0.5f,
+                                 halfOffLen + startInterval - 0.5f, halfStroke - 0.5f);
+    }
 }
 
 static void setup_dashed_rect_pos(const SkRect& rect, int idx, const SkMatrix& matrix,
                                   SkPoint* verts) {
     verts[idx] = SkPoint::Make(rect.fLeft, rect.fTop);
     verts[idx + 1] = SkPoint::Make(rect.fLeft, rect.fBottom);
     verts[idx + 2] = SkPoint::Make(rect.fRight, rect.fBottom);
     verts[idx + 3] = SkPoint::Make(rect.fRight, rect.fTop);
     matrix.mapPoints(&verts[idx], 4);
 }
 
+
+/**
+ * An GrGeometryProcessor that renders a dashed line.
+ * This GrGeometryProcessor is meant for dashed lines that only have a single on/off interval pair.
+ * Bounding geometry is rendered and the effect computes coverage based on the fragment's
+ * position relative to the dashed line.
+ */
+static GrGeometryProcessor* create_dash_gp(GrColor,
+                                           GrPrimitiveEdgeType edgeType,
+                                           DashCap cap,
+                                           const SkMatrix& localMatrix);
+
 bool GrDashingEffect::DrawDashLine(GrGpu* gpu, GrDrawTarget* target,
                                    GrPipelineBuilder* pipelineBuilder, GrColor color,
                                    const SkMatrix& viewMatrix, const SkPoint pts[2],
                                    const GrPaint& paint, const GrStrokeInfo& strokeInfo) {
     if (!can_fast_path_dash(pts, strokeInfo, *target, *pipelineBuilder, viewMatrix)) {
         return false;
     }
 
     const SkPathEffect::DashInfo& info = strokeInfo.getDashInfo();
 
@@ skipping 158 matching lines @@
         devIntervals[0] = lineLength;
     }
 
     // reset to device coordinates
     SkMatrix invert;
     if (!viewMatrix.invert(&invert)) {
         SkDebugf("Failed to invert\n");
         return false;
     }
 
+    bool isRoundCap = SkPaint::kRound_Cap == cap;
+    DashCap capType = isRoundCap ? kRound_DashCap : kNonRound_DashCap;
+
     SkAutoTUnref<const GrGeometryProcessor> gp;
     bool fullDash = devIntervals[1] > 0.f || useAA;
     if (fullDash) {
         SkPathEffect::DashInfo devInfo;
         devInfo.fPhase = devPhase;
         devInfo.fCount = 2;
         devInfo.fIntervals = devIntervals;
-        GrPrimitiveEdgeType edgeType= useAA ? kFillAA_GrProcessorEdgeType :
+        GrPrimitiveEdgeType edgeType = useAA ? kFillAA_GrProcessorEdgeType :
             kFillBW_GrProcessorEdgeType;
-        bool isRoundCap = SkPaint::kRound_Cap == cap;
-        GrDashingEffect::DashCap capType = isRoundCap ? GrDashingEffect::kRound_DashCap :
-                                                        GrDashingEffect::kNonRound_DashCap;
-        gp.reset(GrDashingEffect::Create(color, edgeType, devInfo, strokeWidth, capType, invert));
+        gp.reset(create_dash_gp(color, edgeType, capType, invert));
     } else {
         // Set up the vertex data for the line and start/end dashes
         gp.reset(GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType,
                                                  color,
                                                  SkMatrix::I(),
                                                  invert));
     }
 
     int totalRectCnt = 0;
 
@@ skipping 22 matching lines @@
         viewMatrix.mapPoints(devicePts, ptsRot, 2);
         SkScalar lineLength = SkPoint::Distance(devicePts[0], devicePts[1]);
         if (hasCap) {
             lineLength += 2.f * halfDevStroke;
         }
 
         SkRect bounds;
         bounds.set(ptsRot[0].fX, ptsRot[0].fY, ptsRot[1].fX, ptsRot[1].fY);
         bounds.outset(bloatX + strokeAdj, bloatY + halfSrcStroke);
         if (fullDash) {
-            DashLineVertex* verts = reinterpret_cast<DashLineVertex*>(geo.vertices());
-            SkASSERT(gp->getVertexStride() == sizeof(DashLineVertex));
-            setup_dashed_rect(bounds, verts, curVIdx, combinedMatrix, startOffset, devBloat,
-                                      lineLength, halfDevStroke);
+            setup_dashed_rect(bounds, geo.vertices(), curVIdx, combinedMatrix, startOffset,
+                              devBloat, lineLength, halfDevStroke, devIntervals[0], devIntervals[1],
+                              strokeWidth, capType, gp->getVertexStride());
         } else {
             SkPoint* verts = reinterpret_cast<SkPoint*>(geo.vertices());
             SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
             setup_dashed_rect_pos(bounds, curVIdx, combinedMatrix, verts);
         }
         curVIdx += 4;
     }
 
     if (hasStartRect) {
         SkASSERT(useAA);  // so that we know bloatX and bloatY have been set
         startRect.outset(bloatX, bloatY);
         if (fullDash) {
-            DashLineVertex* verts = reinterpret_cast<DashLineVertex*>(geo.vertices());
-            SkASSERT(gp->getVertexStride() == sizeof(DashLineVertex));
-            setup_dashed_rect(startRect, verts, curVIdx, combinedMatrix, startOffset, devBloat,
-                              devIntervals[0], halfDevStroke);
+            setup_dashed_rect(startRect, geo.vertices(), curVIdx, combinedMatrix, startOffset,
+                              devBloat, devIntervals[0], halfDevStroke, devIntervals[0],
+                              devIntervals[1], strokeWidth, capType, gp->getVertexStride());
         } else {
             SkPoint* verts = reinterpret_cast<SkPoint*>(geo.vertices());
             SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
             setup_dashed_rect_pos(startRect, curVIdx, combinedMatrix, verts);
         }
 
         curVIdx += 4;
     }
 
     if (hasEndRect) {
         SkASSERT(useAA);  // so that we know bloatX and bloatY have been set
         endRect.outset(bloatX, bloatY);
         if (fullDash) {
-            DashLineVertex* verts = reinterpret_cast<DashLineVertex*>(geo.vertices());
-            SkASSERT(gp->getVertexStride() == sizeof(DashLineVertex));
-            setup_dashed_rect(endRect, verts, curVIdx, combinedMatrix, startOffset, devBloat,
-                              devIntervals[0], halfDevStroke);
+            setup_dashed_rect(endRect, geo.vertices(), curVIdx, combinedMatrix, startOffset,
+                              devBloat, devIntervals[0], halfDevStroke, devIntervals[0],
+                              devIntervals[1], strokeWidth, capType, gp->getVertexStride());
         } else {
             SkPoint* verts = reinterpret_cast<SkPoint*>(geo.vertices());
             SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
             setup_dashed_rect_pos(endRect, curVIdx, combinedMatrix, verts);
         }
 
     }
 
     target->setIndexSourceToBuffer(gpu->getContext()->getQuadIndexBuffer());
     target->drawIndexedInstances(pipelineBuilder, gp, kTriangles_GrPrimitiveType,
@@ skipping 20 matching lines @@
  * "dash position" of each vertex. In other words it is the vertex coords (in device space) if we
  * transform the line to be horizontal, with the start of line at the origin then shifted to the
  * right by half the off interval. The line then goes in the positive x direction.
  */
 class DashingCircleEffect : public GrGeometryProcessor {
 public:
     typedef SkPathEffect::DashInfo DashInfo;
 
     static GrGeometryProcessor* Create(GrColor,
                                        GrPrimitiveEdgeType edgeType,
-                                       const DashInfo& info,
-                                       SkScalar radius,
                                        const SkMatrix& localMatrix);
 
     virtual ~DashingCircleEffect();
 
     const char* name() const SK_OVERRIDE { return "DashingCircleEffect"; }
 
     const Attribute* inPosition() const { return fInPosition; }
 
     const Attribute* inCoord() const { return fInCoord; }
 
+    const Attribute* inParams() const { return fInParams; }
+
     GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
 
-    SkScalar getRadius() const { return fRadius; }
-
-    SkScalar getCenterX() const { return fCenterX; }
-
-    SkScalar getIntervalLength() const { return fIntervalLength; }
-
     virtual void getGLProcessorKey(const GrBatchTracker&,
                                    const GrGLCaps&,
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE;
 
     virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker&,
                                                      const GrGLCaps&) const SK_OVERRIDE;
 
     void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const SK_OVERRIDE;
 
     bool onCanMakeEqual(const GrBatchTracker&,
                         const GrGeometryProcessor&,
                         const GrBatchTracker&) const SK_OVERRIDE;
 
 private:
-    DashingCircleEffect(GrColor, GrPrimitiveEdgeType edgeType, const DashInfo& info,
-                        SkScalar radius, const SkMatrix& localMatrix);
+    DashingCircleEffect(GrColor, GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix);
 
     bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
 
     void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const SK_OVERRIDE;
 
     GrPrimitiveEdgeType fEdgeType;
-    const Attribute*  fInPosition;
-    const Attribute*  fInCoord;
-    SkScalar            fIntervalLength;
-    SkScalar            fRadius;
-    SkScalar            fCenterX;
+    const Attribute*    fInPosition;
+    const Attribute*    fInCoord;
+    const Attribute*    fInParams;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingCircleEffect : public GrGLGeometryProcessor {
 public:
@@ skipping 25 matching lines @@
     fColor = GrColor_ILLEGAL;
     fPrevRadius = SK_ScalarMin;
     fPrevCenterX = SK_ScalarMin;
     fPrevIntervalLength = SK_ScalarMax;
 }
 
 void GLDashingCircleEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
     const DashingCircleEffect& dce = args.fGP.cast<DashingCircleEffect>();
     const DashingCircleBatchTracker local = args.fBT.cast<DashingCircleBatchTracker>();
     GrGLGPBuilder* pb = args.fPB;
-    const char *paramName;
-    // The param uniforms, xyz, refer to circle radius - 0.5, cicles center x coord, and
-    // the total interval length of the dash.
-    fParamUniform = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                         kVec3f_GrSLType, kDefault_GrSLPrecision,
-                                         "params", &paramName);
-
     GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
 
     // emit attributes
     vsBuilder->emitAttributes(dce);
 
-    GrGLVertToFrag v(kVec2f_GrSLType);
-    args.fPB->addVarying("Coord", &v);
-    vsBuilder->codeAppendf("%s = %s;", v.vsOut(), dce.inCoord()->fName);
+    GrGLVertToFrag coord(kVec2f_GrSLType);
+    args.fPB->addVarying("Coord", &coord);
+    vsBuilder->codeAppendf("%s = %s;", coord.vsOut(), dce.inCoord()->fName);
+
+    // The param attribute, xyz, refer to circle radius - 0.5, cicles center x coord, and

[egdaniel, 2015/02/03 14:45:59]

Lets move the interval length to the second parameter so we can be consistent
for circle and line dashes. So the second parameter holds info on the
transformed dash position and the dashing interval. The third param will hold
info on how to draw an individual dash. So DashParams and Circle/RectParams. 

+    // the total interval length of the dash.
+    GrGLVertToFrag params(kVec3f_GrSLType);
+    args.fPB->addVarying("Params", &params);
+    vsBuilder->codeAppendf("%s = %s;", params.vsOut(), dce.inParams()->fName);
 
     // Setup pass through color
     this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL, &fColorUniform);
 
     // setup uniform viewMatrix
     this->addUniformViewMatrix(pb);
 
     // Setup position
     SetupPosition(vsBuilder, gpArgs, dce.inPosition()->fName, dce.viewMatrix(), this->uViewM());
 
     // emit transforms
     this->emitTransforms(args.fPB, gpArgs->fPositionVar, dce.inPosition()->fName, dce.localMatrix(),
                          args.fTransformsIn, args.fTransformsOut);
 
     // transforms all points so that we can compare them to our test circle
     GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
-    fsBuilder->codeAppendf("\t\tfloat xShifted = %s.x - floor(%s.x / %s.z) * %s.z;\n",
-                           v.fsIn(), v.fsIn(), paramName, paramName);
-    fsBuilder->codeAppendf("\t\tvec2 fragPosShifted = vec2(xShifted, %s.y);\n", v.fsIn());
-    fsBuilder->codeAppendf("\t\tvec2 center = vec2(%s.y, 0.0);\n", paramName);
-    fsBuilder->codeAppend("\t\tfloat dist = length(center - fragPosShifted);\n");
+    fsBuilder->codeAppendf("float xShifted = %s.x - floor(%s.x / %s.z) * %s.z;",
+                           coord.fsIn(), coord.fsIn(), params.fsIn(), params.fsIn());
+    fsBuilder->codeAppendf("vec2 fragPosShifted = vec2(xShifted, %s.y);", coord.fsIn());
+    fsBuilder->codeAppendf("vec2 center = vec2(%s.y, 0.0);", params.fsIn());
+    fsBuilder->codeAppend("float dist = length(center - fragPosShifted);");
     if (GrProcessorEdgeTypeIsAA(dce.getEdgeType())) {
-        fsBuilder->codeAppendf("\t\tfloat diff = dist - %s.x;\n", paramName);
-        fsBuilder->codeAppend("\t\tdiff = 1.0 - diff;\n");
-        fsBuilder->codeAppend("\t\tfloat alpha = clamp(diff, 0.0, 1.0);\n");
+        fsBuilder->codeAppendf("float diff = dist - %s.x;", params.fsIn());
+        fsBuilder->codeAppend("diff = 1.0 - diff;");
+        fsBuilder->codeAppend("float alpha = clamp(diff, 0.0, 1.0);");
     } else {
-        fsBuilder->codeAppendf("\t\tfloat alpha = 1.0;\n");
-        fsBuilder->codeAppendf("\t\talpha *=  dist < %s.x + 0.5 ? 1.0 : 0.0;\n", paramName);
+        fsBuilder->codeAppendf("float alpha = 1.0;");
+        fsBuilder->codeAppendf("alpha *=  dist < %s.x + 0.5 ? 1.0 : 0.0;", params.fsIn());
     }
     fsBuilder->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
 }
 
 void GLDashingCircleEffect::setData(const GrGLProgramDataManager& pdman,
                                     const GrPrimitiveProcessor& processor,
                                     const GrBatchTracker& bt) {
     this->setUniformViewMatrix(pdman, processor.viewMatrix());
 
-    const DashingCircleEffect& dce = processor.cast<DashingCircleEffect>();
-    SkScalar radius = dce.getRadius();
-    SkScalar centerX = dce.getCenterX();
-    SkScalar intervalLength = dce.getIntervalLength();
-    if (radius != fPrevRadius || centerX != fPrevCenterX || intervalLength != fPrevIntervalLength) {
-        pdman.set3f(fParamUniform, radius - 0.5f, centerX, intervalLength);
-        fPrevRadius = radius;
-        fPrevCenterX = centerX;
-        fPrevIntervalLength = intervalLength;
-    }
-
     const DashingCircleBatchTracker& local = bt.cast<DashingCircleBatchTracker>();
     if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
         GrGLfloat c[4];
         GrColorToRGBAFloat(local.fColor, c);
         pdman.set4fv(fColorUniform, 1, c);
         fColor = local.fColor;
     }
 }
 
 void GLDashingCircleEffect::GenKey(const GrGeometryProcessor& gp,
                                    const GrBatchTracker& bt,
                                    const GrGLCaps&,
                                    GrProcessorKeyBuilder* b) {
     const DashingCircleBatchTracker& local = bt.cast<DashingCircleBatchTracker>();
     const DashingCircleEffect& dce = gp.cast<DashingCircleEffect>();
     uint32_t key = 0;
     key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1 : 0x0;
     key |= ComputePosKey(gp.viewMatrix()) << 1;
     key |= dce.getEdgeType() << 8;
     b->add32(key << 16 | local.fInputColorType);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGeometryProcessor* DashingCircleEffect::Create(GrColor color,
                                                  GrPrimitiveEdgeType edgeType,
-                                                 const DashInfo& info,
-                                                 SkScalar radius,
                                                  const SkMatrix& localMatrix) {
-    if (info.fCount != 2 || info.fIntervals[0] != 0) {
-        return NULL;
-    }
-
-    return SkNEW_ARGS(DashingCircleEffect, (color, edgeType, info, radius, localMatrix));
+    return SkNEW_ARGS(DashingCircleEffect, (color, edgeType, localMatrix));
 }
 
 DashingCircleEffect::~DashingCircleEffect() {}
 
 void DashingCircleEffect::onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const {
     out->setUnknownSingleComponent();
 }
 
 void DashingCircleEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                             const GrGLCaps& caps,
                                             GrProcessorKeyBuilder* b) const {
     GLDashingCircleEffect::GenKey(*this, bt, caps, b);
 }
 
 GrGLPrimitiveProcessor* DashingCircleEffect::createGLInstance(const GrBatchTracker& bt,
                                                               const GrGLCaps&) const {
     return SkNEW_ARGS(GLDashingCircleEffect, (*this, bt));
 }
 
 DashingCircleEffect::DashingCircleEffect(GrColor color,
                                          GrPrimitiveEdgeType edgeType,
-                                         const DashInfo& info,
-                                         SkScalar radius,
                                          const SkMatrix& localMatrix)
     : INHERITED(color, SkMatrix::I(), localMatrix), fEdgeType(edgeType) {
     this->initClassID<DashingCircleEffect>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
     fInCoord = &this->addVertexAttrib(Attribute("inCoord", kVec2f_GrVertexAttribType));
-    SkScalar onLen = info.fIntervals[0];
-    SkScalar offLen = info.fIntervals[1];
-    fIntervalLength = onLen + offLen;
-    fRadius = radius;
-    fCenterX = SkScalarHalf(offLen);
+    fInParams = &this->addVertexAttrib(Attribute("inParams", kVec3f_GrVertexAttribType));
 }
 
 bool DashingCircleEffect::onIsEqual(const GrGeometryProcessor& other) const {
     const DashingCircleEffect& dce = other.cast<DashingCircleEffect>();
-    return (fEdgeType == dce.fEdgeType &&
-            fIntervalLength == dce.fIntervalLength &&
-            fRadius == dce.fRadius &&
-            fCenterX == dce.fCenterX);
+    return fEdgeType == dce.fEdgeType;
 }
 
 void DashingCircleEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const {
     DashingCircleBatchTracker* local = bt->cast<DashingCircleBatchTracker>();
     local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
     local->fUsesLocalCoords = init.fUsesLocalCoords;
 }
 
 bool DashingCircleEffect::onCanMakeEqual(const GrBatchTracker& m,
                                          const GrGeometryProcessor& that,
                                          const GrBatchTracker& t) const {
     const DashingCircleBatchTracker& mine = m.cast<DashingCircleBatchTracker>();
     const DashingCircleBatchTracker& theirs = t.cast<DashingCircleBatchTracker>();
     return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
                                    that, theirs.fUsesLocalCoords) &&
            CanCombineOutput(mine.fInputColorType, mine.fColor,
                             theirs.fInputColorType, theirs.fColor);
 }
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingCircleEffect);
 
 GrGeometryProcessor* DashingCircleEffect::TestCreate(SkRandom* random,
                                                      GrContext*,
                                                      const GrDrawTargetCaps& caps,
                                                      GrTexture*[]) {
     GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(random->nextULessThan(
             kGrProcessorEdgeTypeCnt));
-    SkScalar strokeWidth = random->nextRangeScalar(0, 100.f);
-    DashInfo info;
-    info.fCount = 2;
-    SkAutoTArray<SkScalar> intervals(info.fCount);
-    info.fIntervals = intervals.get();
-    info.fIntervals[0] = 0; 
-    info.fIntervals[1] = random->nextRangeScalar(0, 10.f);
-    info.fPhase = random->nextRangeScalar(0, info.fIntervals[1]);
-
     return DashingCircleEffect::Create(GrRandomColor(random),
-                                       edgeType, info, strokeWidth,
-                                       GrProcessorUnitTest::TestMatrix(random));
+                                       edgeType, GrProcessorUnitTest::TestMatrix(random));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingLineEffect;
 
 struct DashingLineBatchTracker {
     GrGPInput fInputColorType;
     GrColor  fColor;
     bool fUsesLocalCoords;
 };
 
 /*
  * This effect will draw a dashed line. The width of the dash is given by the strokeWidth and the
  * length and spacing by the DashInfo. Both of the previous two parameters are in device space.
  * This effect also requires the setting of a vec2 vertex attribute for the the four corners of the
  * bounding rect. This attribute is the "dash position" of each vertex. In other words it is the
  * vertex coords (in device space) if we transform the line to be horizontal, with the start of
  * line at the origin then shifted to the right by half the off interval. The line then goes in the
  * positive x direction.
  */
 class DashingLineEffect : public GrGeometryProcessor {
 public:
     typedef SkPathEffect::DashInfo DashInfo;
 
     static GrGeometryProcessor* Create(GrColor,
                                        GrPrimitiveEdgeType edgeType,
-                                       const DashInfo& info,
-                                       SkScalar strokeWidth,
                                        const SkMatrix& localMatrix);
 
     virtual ~DashingLineEffect();
 
     const char* name() const SK_OVERRIDE { return "DashingEffect"; }
 
     const Attribute* inPosition() const { return fInPosition; }
 
     const Attribute* inCoord() const { return fInCoord; }
 
+    const Attribute* inRect() const { return fInRect; }
+
     GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
 
-    const SkRect& getRect() const { return fRect; }
-
-    SkScalar getIntervalLength() const { return fIntervalLength; }
-
     virtual void getGLProcessorKey(const GrBatchTracker& bt,
                                    const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE;
 
     virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
                                                      const GrGLCaps&) const SK_OVERRIDE;
 
     void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const SK_OVERRIDE;
 
     bool onCanMakeEqual(const GrBatchTracker&,
                         const GrGeometryProcessor&,
                         const GrBatchTracker&) const SK_OVERRIDE;
 
 private:
-    DashingLineEffect(GrColor, GrPrimitiveEdgeType edgeType, const DashInfo& info,
-                      SkScalar strokeWidth, const SkMatrix& localMatrix);
+    DashingLineEffect(GrColor, GrPrimitiveEdgeType edgeType, const SkMatrix& localMatrix);
 
     bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
 
     void onGetInvariantOutputCoverage(GrInitInvariantOutput*) const SK_OVERRIDE;
 
     GrPrimitiveEdgeType fEdgeType;
-    const Attribute*  fInPosition;
-    const Attribute*  fInCoord;
-    SkRect              fRect;
-    SkScalar            fIntervalLength;
+    const Attribute*    fInPosition;
+    const Attribute*    fInCoord;
+    const Attribute*    fInRect;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingLineEffect : public GrGLGeometryProcessor {
 public:
     GLDashingLineEffect(const GrGeometryProcessor&, const GrBatchTracker&);
 
     void onEmitCode(EmitArgs&, GrGPArgs*) SK_OVERRIDE;
 
     static inline void GenKey(const GrGeometryProcessor&,
                               const GrBatchTracker&,
                               const GrGLCaps&,
                               GrProcessorKeyBuilder*);
 
     virtual void setData(const GrGLProgramDataManager&,
                          const GrPrimitiveProcessor&,
                          const GrBatchTracker&) SK_OVERRIDE;
 
 private:
     GrColor       fColor;
-    UniformHandle fRectUniform;
-    UniformHandle fIntervalUniform;
     UniformHandle fColorUniform;
-    SkRect        fPrevRect;
-    SkScalar      fPrevIntervalLength;
     typedef GrGLGeometryProcessor INHERITED;
 };
 
 GLDashingLineEffect::GLDashingLineEffect(const GrGeometryProcessor&,
                                          const GrBatchTracker&) {
     fColor = GrColor_ILLEGAL;
-    fPrevRect.fLeft = SK_ScalarNaN;
-    fPrevIntervalLength = SK_ScalarMax;
 }
 
 void GLDashingLineEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
     const DashingLineEffect& de = args.fGP.cast<DashingLineEffect>();
     const DashingLineBatchTracker& local = args.fBT.cast<DashingLineBatchTracker>();
     GrGLGPBuilder* pb = args.fPB;
-    const char *rectName;
-    // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5),
-    // respectively.
-    fRectUniform = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                       kVec4f_GrSLType, kDefault_GrSLPrecision,
-                                       "rect",
-                                       &rectName);
-    const char *intervalName;
-    // The interval uniform's refers to the total length of the interval (on + off)
-    fIntervalUniform = args.fPB->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                            kFloat_GrSLType, kDefault_GrSLPrecision,
-                                            "interval",
-                                            &intervalName);
-
 
     GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
 
     // emit attributes
     vsBuilder->emitAttributes(de);
 
-    GrGLVertToFrag v(kVec2f_GrSLType);
-    args.fPB->addVarying("Coord", &v);
-    vsBuilder->codeAppendf("%s = %s;", v.vsOut(), de.inCoord()->fName);
+    // XY, and Z is interval length

[egdaniel, 2015/02/03 14:45:59]

"XY refer to the transformed dash position, and Z..."

+    GrGLVertToFrag inCoord(kVec3f_GrSLType);
+    args.fPB->addVarying("Coord", &inCoord);
+    vsBuilder->codeAppendf("%s = %s;", inCoord.vsOut(), de.inCoord()->fName);
+
+    // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5),
+    // respectively.
+    GrGLVertToFrag inRect(kVec4f_GrSLType);
+    args.fPB->addVarying("Rect", &inRect);
+    vsBuilder->codeAppendf("%s = %s;", inRect.vsOut(), de.inRect()->fName);
 
     // Setup pass through color
     this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL, &fColorUniform);
 
     // setup uniform viewMatrix
     this->addUniformViewMatrix(pb);
 
     // Setup position
     SetupPosition(vsBuilder, gpArgs, de.inPosition()->fName, de.viewMatrix(), this->uViewM());
 
     // emit transforms
     this->emitTransforms(args.fPB, gpArgs->fPositionVar, de.inPosition()->fName, de.localMatrix(),
                          args.fTransformsIn, args.fTransformsOut);
 
     // transforms all points so that we can compare them to our test rect
     GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
-    fsBuilder->codeAppendf("\t\tfloat xShifted = %s.x - floor(%s.x / %s) * %s;\n",
-                           v.fsIn(), v.fsIn(), intervalName, intervalName);
-    fsBuilder->codeAppendf("\t\tvec2 fragPosShifted = vec2(xShifted, %s.y);\n", v.fsIn());
+    fsBuilder->codeAppendf("float xShifted = %s.x - floor(%s.x / %s.z) * %s.z;",
+                           inCoord.fsIn(), inCoord.fsIn(), inCoord.fsIn(), inCoord.fsIn());
+    fsBuilder->codeAppendf("vec2 fragPosShifted = vec2(xShifted, %s.y);", inCoord.fsIn());
     if (GrProcessorEdgeTypeIsAA(de.getEdgeType())) {
         // The amount of coverage removed in x and y by the edges is computed as a pair of negative
         // numbers, xSub and ySub.
-        fsBuilder->codeAppend("\t\tfloat xSub, ySub;\n");
-        fsBuilder->codeAppendf("\t\txSub = min(fragPosShifted.x - %s.x, 0.0);\n", rectName);
-        fsBuilder->codeAppendf("\t\txSub += min(%s.z - fragPosShifted.x, 0.0);\n", rectName);
-        fsBuilder->codeAppendf("\t\tySub = min(fragPosShifted.y - %s.y, 0.0);\n", rectName);
-        fsBuilder->codeAppendf("\t\tySub += min(%s.w - fragPosShifted.y, 0.0);\n", rectName);
+        fsBuilder->codeAppend("float xSub, ySub;");
+        fsBuilder->codeAppendf("xSub = min(fragPosShifted.x - %s.x, 0.0);", inRect.fsIn());
+        fsBuilder->codeAppendf("xSub += min(%s.z - fragPosShifted.x, 0.0);", inRect.fsIn());
+        fsBuilder->codeAppendf("ySub = min(fragPosShifted.y - %s.y, 0.0);", inRect.fsIn());
+        fsBuilder->codeAppendf("ySub += min(%s.w - fragPosShifted.y, 0.0);", inRect.fsIn());
         // Now compute coverage in x and y and multiply them to get the fraction of the pixel
         // covered.
-        fsBuilder->codeAppendf("\t\tfloat alpha = (1.0 + max(xSub, -1.0)) * (1.0 + max(ySub, -1.0));\n");
+        fsBuilder->codeAppendf("float alpha = (1.0 + max(xSub, -1.0)) * (1.0 + max(ySub, -1.0));");
     } else {
         // Assuming the bounding geometry is tight so no need to check y values
-        fsBuilder->codeAppendf("\t\tfloat alpha = 1.0;\n");
-        fsBuilder->codeAppendf("\t\talpha *= (fragPosShifted.x - %s.x) > -0.5 ? 1.0 : 0.0;\n", rectName);
-        fsBuilder->codeAppendf("\t\talpha *= (%s.z - fragPosShifted.x) >= -0.5 ? 1.0 : 0.0;\n", rectName);
+        fsBuilder->codeAppendf("float alpha = 1.0;");
+        fsBuilder->codeAppendf("alpha *= (fragPosShifted.x - %s.x) > -0.5 ? 1.0 : 0.0;",
+                               inRect.fsIn());
+        fsBuilder->codeAppendf("alpha *= (%s.z - fragPosShifted.x) >= -0.5 ? 1.0 : 0.0;",
+                               inRect.fsIn());
     }
     fsBuilder->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
 }
 
 void GLDashingLineEffect::setData(const GrGLProgramDataManager& pdman,
                                   const GrPrimitiveProcessor& processor,
                                   const GrBatchTracker& bt) {
     this->setUniformViewMatrix(pdman, processor.viewMatrix());
 
-    const DashingLineEffect& de = processor.cast<DashingLineEffect>();
-    const SkRect& rect = de.getRect();
-    SkScalar intervalLength = de.getIntervalLength();
-    if (rect != fPrevRect || intervalLength != fPrevIntervalLength) {
-        pdman.set4f(fRectUniform, rect.fLeft + 0.5f, rect.fTop + 0.5f,
-                    rect.fRight - 0.5f, rect.fBottom - 0.5f);
-        pdman.set1f(fIntervalUniform, intervalLength);
-        fPrevRect = rect;
-        fPrevIntervalLength = intervalLength;
-    }
-
     const DashingLineBatchTracker& local = bt.cast<DashingLineBatchTracker>();
     if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
         GrGLfloat c[4];
         GrColorToRGBAFloat(local.fColor, c);
         pdman.set4fv(fColorUniform, 1, c);
         fColor = local.fColor;
     }
 }
 
 void GLDashingLineEffect::GenKey(const GrGeometryProcessor& gp,
                                  const GrBatchTracker& bt,
                                  const GrGLCaps&,
                                  GrProcessorKeyBuilder* b) {
     const DashingLineBatchTracker& local = bt.cast<DashingLineBatchTracker>();
     const DashingLineEffect& de = gp.cast<DashingLineEffect>();
     uint32_t key = 0;
     key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1 : 0x0;
     key |= ComputePosKey(gp.viewMatrix()) << 1;
     key |= de.getEdgeType() << 8;
     b->add32(key << 16 | local.fInputColorType);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGeometryProcessor* DashingLineEffect::Create(GrColor color,
                                                GrPrimitiveEdgeType edgeType,
-                                               const DashInfo& info,
-                                               SkScalar strokeWidth,
                                                const SkMatrix& localMatrix) {
-    if (info.fCount != 2) {
-        return NULL;
-    }
-
-    return SkNEW_ARGS(DashingLineEffect, (color, edgeType, info, strokeWidth, localMatrix));
+    return SkNEW_ARGS(DashingLineEffect, (color, edgeType, localMatrix));
 }
 
 DashingLineEffect::~DashingLineEffect() {}
 
 void DashingLineEffect::onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const {
     out->setUnknownSingleComponent();
 }
 
 void DashingLineEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                           const GrGLCaps& caps,
                                           GrProcessorKeyBuilder* b) const {
     GLDashingLineEffect::GenKey(*this, bt, caps, b);
 }
 
 GrGLPrimitiveProcessor* DashingLineEffect::createGLInstance(const GrBatchTracker& bt,
                                                             const GrGLCaps&) const {
     return SkNEW_ARGS(GLDashingLineEffect, (*this, bt));
 }
 
 DashingLineEffect::DashingLineEffect(GrColor color,
                                      GrPrimitiveEdgeType edgeType,
-                                     const DashInfo& info,
-                                     SkScalar strokeWidth,
                                      const SkMatrix& localMatrix)
     : INHERITED(color, SkMatrix::I(), localMatrix), fEdgeType(edgeType) {
     this->initClassID<DashingLineEffect>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
-    fInCoord = &this->addVertexAttrib(Attribute("inCoord", kVec2f_GrVertexAttribType));
-    SkScalar onLen = info.fIntervals[0];
-    SkScalar offLen = info.fIntervals[1];
-    SkScalar halfOffLen = SkScalarHalf(offLen);
-    SkScalar halfStroke = SkScalarHalf(strokeWidth);
-    fIntervalLength = onLen + offLen;
-    fRect.set(halfOffLen, -halfStroke, halfOffLen + onLen, halfStroke);
+    fInCoord = &this->addVertexAttrib(Attribute("inCoord", kVec3f_GrVertexAttribType));
+    fInRect = &this->addVertexAttrib(Attribute("inRect", kVec4f_GrVertexAttribType));
 }
 
 bool DashingLineEffect::onIsEqual(const GrGeometryProcessor& other) const {
     const DashingLineEffect& de = other.cast<DashingLineEffect>();
-    return (fEdgeType == de.fEdgeType &&
+    return (fEdgeType == de.fEdgeType/* &&
             fRect == de.fRect &&
-            fIntervalLength == de.fIntervalLength);
+            fIntervalLength == de.fIntervalLength*/);
 }
 
 void DashingLineEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const {
     DashingLineBatchTracker* local = bt->cast<DashingLineBatchTracker>();
     local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
     local->fUsesLocalCoords = init.fUsesLocalCoords;
 }
 
 bool DashingLineEffect::onCanMakeEqual(const GrBatchTracker& m,
                                        const GrGeometryProcessor& that,
                                        const GrBatchTracker& t) const {
     const DashingLineBatchTracker& mine = m.cast<DashingLineBatchTracker>();
     const DashingLineBatchTracker& theirs = t.cast<DashingLineBatchTracker>();
     return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
                                   that, theirs.fUsesLocalCoords) &&
            CanCombineOutput(mine.fInputColorType, mine.fColor,
                             theirs.fInputColorType, theirs.fColor);
 }
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingLineEffect);
 
 GrGeometryProcessor* DashingLineEffect::TestCreate(SkRandom* random,
                                                    GrContext*,
                                                    const GrDrawTargetCaps& caps,
                                                    GrTexture*[]) {
     GrPrimitiveEdgeType edgeType = static_cast<GrPrimitiveEdgeType>(random->nextULessThan(
             kGrProcessorEdgeTypeCnt));
-    SkScalar strokeWidth = random->nextRangeScalar(0, 100.f);
-    DashInfo info;
-    info.fCount = 2;
-    SkAutoTArray<SkScalar> intervals(info.fCount);
-    info.fIntervals = intervals.get();
-    info.fIntervals[0] = random->nextRangeScalar(0, 10.f);
-    info.fIntervals[1] = random->nextRangeScalar(0, 10.f);
-    info.fPhase = random->nextRangeScalar(0, info.fIntervals[0] + info.fIntervals[1]);
 
     return DashingLineEffect::Create(GrRandomColor(random),
-                                     edgeType, info, strokeWidth,
-                                     GrProcessorUnitTest::TestMatrix(random));
+                                     edgeType, GrProcessorUnitTest::TestMatrix(random));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-GrGeometryProcessor* GrDashingEffect::Create(GrColor color,
-                                             GrPrimitiveEdgeType edgeType,
-                                             const SkPathEffect::DashInfo& info,
-                                             SkScalar strokeWidth,
-                                             GrDashingEffect::DashCap cap,
-                                             const SkMatrix& localMatrix) {
+static GrGeometryProcessor* create_dash_gp(GrColor color,
+                                           GrPrimitiveEdgeType edgeType,
+                                           DashCap cap,
+                                           const SkMatrix& localMatrix) {
     switch (cap) {
-        case GrDashingEffect::kRound_DashCap:
-            return DashingCircleEffect::Create(color, edgeType, info,
-                                               SkScalarHalf(strokeWidth),
-                                               localMatrix);
-        case GrDashingEffect::kNonRound_DashCap:
-            return DashingLineEffect::Create(color, edgeType, info, strokeWidth, localMatrix);
+        case kRound_DashCap:
+            return DashingCircleEffect::Create(color, edgeType, localMatrix);
+        case kNonRound_DashCap:
+            return DashingLineEffect::Create(color, edgeType, localMatrix);
         default:
             SkFAIL("Unexpected dashed cap.");
     }
     return NULL;
 }