First step to moving vertex attributes to the geometryProcessor

src/gpu/GrAAConvexPathRenderer.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAConvexPathRenderer.h"
 
@@ skipping 500 matching lines @@
     static GrGeometryProcessor* Create() {
         GR_CREATE_STATIC_PROCESSOR(gQuadEdgeEffect, QuadEdgeEffect, ());
         gQuadEdgeEffect->ref();
         return gQuadEdgeEffect;
     }
 
     virtual ~QuadEdgeEffect() {}
 
     static const char* Name() { return "QuadEdge"; }
 
-    const GrShaderVar& inQuadEdge() const { return fInQuadEdge; }
+    const GrAttribute* inPosition() const { return fInPosition; }
+    const GrAttribute* inQuadEdge() const { return fInQuadEdge; }
 
     virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERRIDE {
         return GrTBackendGeometryProcessorFactory<QuadEdgeEffect>::getInstance();
     }
 
     class GLProcessor : public GrGLGeometryProcessor {
     public:
         GLProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&)
             : INHERITED (factory) {}
 
         virtual void emitCode(const EmitArgs& args) SK_OVERRIDE {
+            const QuadEdgeEffect& qe = args.fGP.cast<QuadEdgeEffect>();
+            GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
+
             GrGLVertToFrag v(kVec4f_GrSLType);
             args.fPB->addVarying("QuadEdge", &v);
+            vsBuilder->codeAppendf("%s = %s;", v.vsOut(), qe.inQuadEdge()->fName);
+
+            // setup coord outputs
+            vsBuilder->codeAppendf("%s = %s;", vsBuilder->positionCoords(), qe.inPosition()->fName);
+            vsBuilder->codeAppendf("%s = %s;", vsBuilder->localCoords(), qe.inPosition()->fName);
+
+            // setup position varying
+            vsBuilder->codeAppendf("%s = %s * vec3(%s, 1);", vsBuilder->glPosition(),
+                                   vsBuilder->uViewM(), qe.inPosition()->fName);
 
             GrGLGPFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
 
             SkAssertResult(fsBuilder->enableFeature(
                     GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
             fsBuilder->codeAppendf("float edgeAlpha;");
 
             // keep the derivative instructions outside the conditional
             fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", v.fsIn());
             fsBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", v.fsIn());
             fsBuilder->codeAppendf("if (%s.z > 0.0 && %s.w > 0.0) {", v.fsIn(), v.fsIn());
             // today we know z and w are in device space. We could use derivatives
             fsBuilder->codeAppendf("edgeAlpha = min(min(%s.z, %s.w) + 0.5, 1.0);", v.fsIn(),
                                     v.fsIn());
             fsBuilder->codeAppendf ("} else {");
             fsBuilder->codeAppendf("vec2 gF = vec2(2.0*%s.x*duvdx.x - duvdx.y,"
                                    "               2.0*%s.x*duvdy.x - duvdy.y);",
                                    v.fsIn(), v.fsIn());
             fsBuilder->codeAppendf("edgeAlpha = (%s.x*%s.x - %s.y);", v.fsIn(), v.fsIn(),
                                     v.fsIn());
             fsBuilder->codeAppendf("edgeAlpha = "
                                    "clamp(0.5 - edgeAlpha / length(gF), 0.0, 1.0);}");
 
-
-            fsBuilder->codeAppendf("%s = %s;", args.fOutput,
-                                   (GrGLSLExpr4(args.fInput) * GrGLSLExpr1("edgeAlpha")).c_str());
-
-            const GrShaderVar& inQuadEdge = args.fGP.cast<QuadEdgeEffect>().inQuadEdge();
-            GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
-            vsBuilder->codeAppendf("\t%s = %s;\n", v.vsOut(), inQuadEdge.c_str());
-
-            // setup position varying
-            vsBuilder->codeAppendf("%s = %s * vec3(%s, 1);", vsBuilder->glPosition(),
-                                   vsBuilder->uViewM(), vsBuilder->inPosition());
+            fsBuilder->codeAppendf("%s = vec4(edgeAlpha);", args.fOutputCoverage);
         }
 
         static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder*) {}
 
         virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE {}
 
     private:
         typedef GrGLGeometryProcessor INHERITED;
     };
 
 private:
-    QuadEdgeEffect()
-        : fInQuadEdge(this->addVertexAttrib(GrShaderVar("inQuadEdge",
-                                                        kVec4f_GrSLType,
-                                                        GrShaderVar::kAttribute_TypeModifier))) {
+    QuadEdgeEffect() {
+        fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
+        fInQuadEdge = &this->addVertexAttrib(GrAttribute("inQuadEdge", kVec4f_GrVertexAttribType));
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
         return true;
     }
 
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
         inout->mulByUnknownAlpha();
     }
 
-    const GrShaderVar& fInQuadEdge;
+    const GrAttribute* fInPosition;
+    const GrAttribute* fInQuadEdge;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(QuadEdgeEffect);
 
 GrGeometryProcessor* QuadEdgeEffect::TestCreate(SkRandom* random,
                                                 GrContext*,
                                                 const GrDrawTargetCaps& caps,
                                                 GrTexture*[]) {
     // Doesn't work without derivative instructions.
     return caps.shaderDerivativeSupport() ? QuadEdgeEffect::Create() : NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrAAConvexPathRenderer::canDrawPath(const GrDrawTarget* target,
                                          const GrDrawState*,
                                          const SkPath& path,
                                          const SkStrokeRec& stroke,
                                          bool antiAlias) const {
     return (target->caps()->shaderDerivativeSupport() && antiAlias &&
             stroke.isFillStyle() && !path.isInverseFillType() && path.isConvex());
 }
 
-namespace {
-
-// position + edge
-extern const GrVertexAttrib gPathAttribs[] = {
-    {kVec2f_GrVertexAttribType, 0,               kPosition_GrVertexAttribBinding},
-    {kVec4f_GrVertexAttribType, sizeof(SkPoint), kGeometryProcessor_GrVertexAttribBinding}
-};
-
-};
-
 bool GrAAConvexPathRenderer::onDrawPath(GrDrawTarget* target,
                                         GrDrawState* drawState,
                                         const SkPath& origPath,
                                         const SkStrokeRec&,
                                         bool antiAlias) {
 
     const SkPath* path = &origPath;
     if (path->isEmpty()) {
         return true;
     }
@@ skipping 29 matching lines @@
     // We can't simply use the path bounds because we may degenerate cubics to quads which produces
     // new control points outside the original convex hull.
     SkRect devBounds;
     if (!get_segments(*path, viewMatrix, &segments, &fanPt, &vCount, &iCount, &devBounds)) {
         return false;
     }
 
     // Our computed verts should all be within one pixel of the segment control points.
     devBounds.outset(SK_Scalar1, SK_Scalar1);
 
-    drawState->setVertexAttribs<gPathAttribs>(SK_ARRAY_COUNT(gPathAttribs), sizeof(QuadVertex));
-
     GrGeometryProcessor* quadProcessor = QuadEdgeEffect::Create();
     drawState->setGeometryProcessor(quadProcessor)->unref();
 
-    GrDrawTarget::AutoReleaseGeometry arg(target, vCount, drawState->getVertexStride(), iCount);
+    GrDrawTarget::AutoReleaseGeometry arg(target, vCount, quadProcessor->getVertexStride(), iCount);
+    SkASSERT(quadProcessor->getVertexStride() == sizeof(QuadVertex));
     if (!arg.succeeded()) {
         return false;
     }
     verts = reinterpret_cast<QuadVertex*>(arg.vertices());
     idxs = reinterpret_cast<uint16_t*>(arg.indices());
 
     SkSTArray<kPreallocDrawCnt, Draw, true> draws;
     create_vertices(segments, fanPt, &draws, verts, idxs);
 
     // Check devBounds
@@ skipping 16 matching lines @@
                             vOffset,  // start vertex
                             0,        // start index
                             draw.fVertexCnt,
                             draw.fIndexCnt,
                             &devBounds);
         vOffset += draw.fVertexCnt;
     }
 
     return true;
 }