First step to moving vertex attributes to the geometryProcessor

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 47 matching lines @@
     SkPaint::Cap cap = strokeInfo.getStrokeRec().getCap();
     // Current we do don't handle Round or Square cap dashes
     if (SkPaint::kRound_Cap == cap && info.fIntervals[0] != 0.f) {
         return false;
     }
 
     return true;
 }
 
 namespace {
-
 struct DashLineVertex {
     SkPoint fPos;
     SkPoint fDashPos;
 };
-
-extern const GrVertexAttrib gDashLineVertexAttribs[] = {
-    { kVec2f_GrVertexAttribType, 0,                 kPosition_GrVertexAttribBinding },
-    { kVec2f_GrVertexAttribType, sizeof(SkPoint),   kGeometryProcessor_GrVertexAttribBinding },
 };
 
-};
 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);
 
     SkVector vecSrcPerp;
     vecSrc.rotateCW(&vecSrcPerp);
     viewMatrix.mapVectors(&vecSrc, 1);
@@ skipping 244 matching lines @@
         lineDone = true;
 
         SkPoint devicePts[2];
         vm.mapPoints(devicePts, ptsRot, 2);
         SkScalar lineLength = SkPoint::Distance(devicePts[0], devicePts[1]);
         if (hasCap) {
             lineLength += 2.f * halfDevStroke;
         }
         devIntervals[0] = lineLength;
     }
+
+    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 :
             kFillBW_GrProcessorEdgeType;
         bool isRoundCap = SkPaint::kRound_Cap == cap;
         GrDashingEffect::DashCap capType = isRoundCap ? GrDashingEffect::kRound_DashCap :
                                                         GrDashingEffect::kNonRound_DashCap;
-        drawState->setGeometryProcessor(
-                GrDashingEffect::Create(edgeType, devInfo, strokeWidth, capType))->unref();
-
-        // Set up the vertex data for the line and start/end dashes
-        drawState->setVertexAttribs<gDashLineVertexAttribs>(SK_ARRAY_COUNT(gDashLineVertexAttribs),
-                                                            sizeof(DashLineVertex));
+        gp = GrDashingEffect::Create(edgeType, devInfo, strokeWidth, capType);
     } else {
         // Set up the vertex data for the line and start/end dashes
-        drawState->setGeometryProcessor(
-                GrDefaultGeoProcFactory::CreateAndSetAttribs(
-                        drawState,
-                        GrDefaultGeoProcFactory::kPosition_GPType))->unref();
+        gp = GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType);
     }
 
+    drawState->setGeometryProcessor(gp)->unref();
+
     int totalRectCnt = 0;
 
     totalRectCnt += !lineDone ? 1 : 0;
     totalRectCnt += hasStartRect ? 1 : 0;
     totalRectCnt += hasEndRect ? 1 : 0;
 
     GrDrawTarget::AutoReleaseGeometry geo(target,
                                           totalRectCnt * 4,
-                                          drawState->getVertexStride(), 0);
+                                          gp->getVertexStride(), 0);
     if (!geo.succeeded()) {
         SkDebugf("Failed to get space for vertices!\n");
         return false;
     }
 
     int curVIdx = 0;
 
     if (SkPaint::kRound_Cap == cap && 0 != srcStrokeWidth) {
         // need to adjust this for round caps to correctly set the dashPos attrib on vertices
         startOffset -= halfDevStroke;
     }
 
     // Draw interior part of dashed line
     if (!lineDone) {
         SkPoint devicePts[2];
         vm.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);
         } 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);
         } 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);
         } 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(drawState, kTriangles_GrPrimitiveType, totalRectCnt, 4, 6);
     target->resetIndexSource();
     return true;
 }
@@ skipping 15 matching lines @@
     typedef SkPathEffect::DashInfo DashInfo;
 
     static GrGeometryProcessor* Create(GrPrimitiveEdgeType edgeType,
                                        const DashInfo& info,
                                        SkScalar radius);
 
     virtual ~DashingCircleEffect();
 
     static const char* Name() { return "DashingCircleEffect"; }
 
-    const GrShaderVar& inCoord() const { return fInCoord; }
+    const GrAttribute* inPosition() const { return fInPosition; }
+
+    const GrAttribute* inCoord() const { return fInCoord; }
 
     GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
 
     SkScalar getRadius() const { return fRadius; }
 
     SkScalar getCenterX() const { return fCenterX; }
 
     SkScalar getIntervalLength() const { return fIntervalLength; }
 
     typedef GLDashingCircleEffect GLProcessor;
 
     virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE;
 
 private:
     DashingCircleEffect(GrPrimitiveEdgeType edgeType, const DashInfo& info, SkScalar radius);
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
 
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
 
-    GrPrimitiveEdgeType    fEdgeType;
-    const GrShaderVar&  fInCoord;
+    GrPrimitiveEdgeType fEdgeType;
+    const GrAttribute*  fInPosition;
+    const GrAttribute*  fInCoord;
     SkScalar            fIntervalLength;
     SkScalar            fRadius;
     SkScalar            fCenterX;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
@@ skipping 27 matching lines @@
 void GLDashingCircleEffect::emitCode(const EmitArgs& args) {
     const DashingCircleEffect& dce = args.fGP.cast<DashingCircleEffect>();
     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,
                                          "params",
                                          &paramName);
 
+    GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
+
     GrGLVertToFrag v(kVec2f_GrSLType);
     args.fPB->addVarying("Coord", &v);
+    vsBuilder->codeAppendf("%s = %s;", v.vsOut(), dce.inCoord()->fName);
 
-    GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
-    vsBuilder->codeAppendf("\t%s = %s;\n", v.vsOut(), dce.inCoord().c_str());
+    // setup coord outputs
+    vsBuilder->codeAppendf("%s = %s;", vsBuilder->positionCoords(), dce.inPosition()->fName);
+    vsBuilder->codeAppendf("%s = %s;", vsBuilder->localCoords(), dce.inPosition()->fName);
 
     // setup position varying
     vsBuilder->codeAppendf("%s = %s * vec3(%s, 1);", vsBuilder->glPosition(), vsBuilder->uViewM(),
-                           vsBuilder->inPosition());
+                           dce.inPosition()->fName);
 
     // 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");
     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");
     } 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("\t\t%s = %s;\n", args.fOutput,
-                           (GrGLSLExpr4(args.fInput) * GrGLSLExpr1("alpha")).c_str());
+    fsBuilder->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
 }
 
 void GLDashingCircleEffect::setData(const GrGLProgramDataManager& pdman
                                     , const GrProcessor& processor) {
     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);
@@ skipping 25 matching lines @@
 void DashingCircleEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->mulByUnknownAlpha();
 }
 
 const GrBackendGeometryProcessorFactory& DashingCircleEffect::getFactory() const {
     return GrTBackendGeometryProcessorFactory<DashingCircleEffect>::getInstance();
 }
 
 DashingCircleEffect::DashingCircleEffect(GrPrimitiveEdgeType edgeType, const DashInfo& info,
                                          SkScalar radius)
-    : fEdgeType(edgeType)
-    , fInCoord(this->addVertexAttrib(GrShaderVar("inCoord",
-                                                 kVec2f_GrSLType,
-                                                 GrShaderVar::kAttribute_TypeModifier))) {
+    : fEdgeType(edgeType) {
+    fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
+    fInCoord = &this->addVertexAttrib(GrAttribute("inCoord", kVec2f_GrVertexAttribType));
     SkScalar onLen = info.fIntervals[0];
     SkScalar offLen = info.fIntervals[1];
     fIntervalLength = onLen + offLen;
     fRadius = radius;
     fCenterX = SkScalarHalf(offLen);
 }
 
 bool DashingCircleEffect::onIsEqual(const GrGeometryProcessor& other) const {
     const DashingCircleEffect& dce = other.cast<DashingCircleEffect>();
     return (fEdgeType == dce.fEdgeType &&
@@ skipping 40 matching lines @@
     typedef SkPathEffect::DashInfo DashInfo;
 
     static GrGeometryProcessor* Create(GrPrimitiveEdgeType edgeType,
                                        const DashInfo& info,
                                        SkScalar strokeWidth);
 
     virtual ~DashingLineEffect();
 
     static const char* Name() { return "DashingEffect"; }
 
-    const GrShaderVar& inCoord() const { return fInCoord; }
+    const GrAttribute* inPosition() const { return fInPosition; }
+
+    const GrAttribute* inCoord() const { return fInCoord; }
 
     GrPrimitiveEdgeType getEdgeType() const { return fEdgeType; }
 
     const SkRect& getRect() const { return fRect; }
 
     SkScalar getIntervalLength() const { return fIntervalLength; }
 
     typedef GLDashingLineEffect GLProcessor;
 
     virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE;
 
 private:
     DashingLineEffect(GrPrimitiveEdgeType edgeType, const DashInfo& info, SkScalar strokeWidth);
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
 
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
 
-    GrPrimitiveEdgeType    fEdgeType;
-    const GrShaderVar&  fInCoord;
+    GrPrimitiveEdgeType fEdgeType;
+    const GrAttribute*  fInPosition;
+    const GrAttribute*  fInCoord;
     SkRect              fRect;
     SkScalar            fIntervalLength;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ skipping 31 matching lines @@
                                        kVec4f_GrSLType,
                                        "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,
                                             "interval",
                                             &intervalName);
 
+
+    GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
+
     GrGLVertToFrag v(kVec2f_GrSLType);
     args.fPB->addVarying("Coord", &v);
-    GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
-    vsBuilder->codeAppendf("\t%s = %s;\n", v.vsOut(), de.inCoord().c_str());
+    vsBuilder->codeAppendf("%s = %s;", v.vsOut(), de.inCoord()->fName);
+
+    // setup coord outputs
+    vsBuilder->codeAppendf("%s = %s;", vsBuilder->positionCoords(), de.inPosition()->fName);
+    vsBuilder->codeAppendf("%s = %s;", vsBuilder->localCoords(), de.inPosition()->fName);
 
     // setup position varying
     vsBuilder->codeAppendf("%s = %s * vec3(%s, 1);", vsBuilder->glPosition(), vsBuilder->uViewM(),
-                           vsBuilder->inPosition());
+                           de.inPosition()->fName);
 
     // 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());
     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);
         // 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");
     } 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("\t\t%s = %s;\n", args.fOutput,
-                           (GrGLSLExpr4(args.fInput) * GrGLSLExpr1("alpha")).c_str());
+    fsBuilder->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
 }
 
 void GLDashingLineEffect::setData(const GrGLProgramDataManager& pdman,
                                   const GrProcessor& processor) {
     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);
@@ skipping 26 matching lines @@
 void DashingLineEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->mulByUnknownAlpha();
 }
 
 const GrBackendGeometryProcessorFactory& DashingLineEffect::getFactory() const {
     return GrTBackendGeometryProcessorFactory<DashingLineEffect>::getInstance();
 }
 
 DashingLineEffect::DashingLineEffect(GrPrimitiveEdgeType edgeType, const DashInfo& info,
                                      SkScalar strokeWidth)
-    : fEdgeType(edgeType)
-    , fInCoord(this->addVertexAttrib(GrShaderVar("inCoord",
-                                                 kVec2f_GrSLType,
-                                                 GrShaderVar::kAttribute_TypeModifier))) {
+    : fEdgeType(edgeType) {
+    fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
+    fInCoord = &this->addVertexAttrib(GrAttribute("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);
 }
 
 bool DashingLineEffect::onIsEqual(const GrGeometryProcessor& other) const {
     const DashingLineEffect& de = other.cast<DashingLineEffect>();
@@ skipping 31 matching lines @@
     switch (cap) {
         case GrDashingEffect::kRound_DashCap:
             return DashingCircleEffect::Create(edgeType, info, SkScalarHalf(strokeWidth));
         case GrDashingEffect::kNonRound_DashCap:
             return DashingLineEffect::Create(edgeType, info, strokeWidth);
         default:
             SkFAIL("Unexpected dashed cap.");
     }
     return NULL;
 }