Removing vertex attrib indices

src/gpu/GrAARectRenderer.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 "gl/builders/GrGLProgramBuilder.h"
 #include "GrAARectRenderer.h"
 #include "GrGpu.h"
 #include "gl/GrGLEffect.h"
-#include "gl/GrGLVertexEffect.h"
+#include "gl/GrGLGeometryProcessor.h"
 #include "GrTBackendEffectFactory.h"
 #include "SkColorPriv.h"
-#include "effects/GrVertexEffect.h"
+#include "effects/GrGeometryProcessor.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 class GrGLAlignedRectEffect;
 
 // Axis Aligned special case
-class GrAlignedRectEffect : public GrVertexEffect {
+class GrAlignedRectEffect : public GrGeometryProcessor {
 public:
     static GrEffect* Create() {
         GR_CREATE_STATIC_EFFECT(gAlignedRectEffect, GrAlignedRectEffect, ());
         gAlignedRectEffect->ref();
         return gAlignedRectEffect;
     }
 
     virtual ~GrAlignedRectEffect() {}
 
     static const char* Name() { return "AlignedRectEdge"; }
 
     virtual void getConstantColorComponents(GrColor* color,
                                             uint32_t* validFlags) const SK_OVERRIDE {
         *validFlags = 0;
     }
 
+    const GrShaderVar& aRect() const { return fAttrRect; }
+
     virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
         return GrTBackendEffectFactory<GrAlignedRectEffect>::getInstance();
     }
 
-    class GLEffect : public GrGLVertexEffect {
+    class GLEffect : public GrGLGeometryProcessor {
     public:
         GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
         : INHERITED (factory) {}
 
         virtual void emitCode(GrGLFullProgramBuilder* builder,
                               const GrDrawEffect& drawEffect,
                               const GrEffectKey& key,
                               const char* outputColor,
                               const char* inputColor,
                               const TransformedCoordsArray&,
                               const TextureSamplerArray& samplers) SK_OVERRIDE {
             // setup the varying for the Axis aligned rect effect
             //      xy -> interpolated offset
             //      zw -> w/2+0.5, h/2+0.5
             const char *vsRectName, *fsRectName;
             builder->addVarying(kVec4f_GrSLType, "Rect", &vsRectName, &fsRectName);
 
+            const GrShaderVar& aRect = drawEffect.castEffect<GrAlignedRectEffect>().aRect();
             GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
-            const SkString* attr0Name =
-                vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
-            vsBuilder->codeAppendf("\t%s = %s;\n", vsRectName, attr0Name->c_str());
+            vsBuilder->codeAppendf("\t%s = %s;\n", vsRectName, aRect.c_str());
 
             GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
             // TODO: compute all these offsets, spans, and scales in the VS
             fsBuilder->codeAppendf("\tfloat insetW = min(1.0, %s.z) - 0.5;\n", fsRectName);
             fsBuilder->codeAppendf("\tfloat insetH = min(1.0, %s.w) - 0.5;\n", fsRectName);
             fsBuilder->codeAppend("\tfloat outset = 0.5;\n");
             // For rects > 1 pixel wide and tall the span's are noops (i.e., 1.0). For rects
             // < 1 pixel wide or tall they serve to normalize the < 1 ramp to a 0 .. 1 range.
             fsBuilder->codeAppend("\tfloat spanW = insetW + outset;\n");
             fsBuilder->codeAppend("\tfloat spanH = insetH + outset;\n");
@@ skipping 15 matching lines @@
 
             fsBuilder->codeAppendf("\t%s = %s;\n", outputColor,
                                    (GrGLSLExpr4(inputColor) * GrGLSLExpr1("coverage")).c_str());
         }
 
         static void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
 
         virtual void setData(const GrGLProgramDataManager& pdman, const GrDrawEffect&) SK_OVERRIDE {}
 
     private:
-        typedef GrGLVertexEffect INHERITED;
+        typedef GrGLGeometryProcessor INHERITED;
     };
 
 
 private:
-    GrAlignedRectEffect() : GrVertexEffect() {
-        this->addVertexAttrib(kVec4f_GrSLType);
+    GrAlignedRectEffect()
+        : GrGeometryProcessor()
+        , fAttrRect(this->addVertexAttrib(GrShaderVar("aRect",
+                                                      kVec4f_GrSLType,
+                                                      GrShaderVar::kAttribute_TypeModifier))) {
     }
 
+    const GrShaderVar& fAttrRect;
+
     virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE { return true; }
 
     GR_DECLARE_EFFECT_TEST;
 
-    typedef GrVertexEffect INHERITED;
+    typedef GrGeometryProcessor INHERITED;
 };
 
 
 GR_DEFINE_EFFECT_TEST(GrAlignedRectEffect);
 
 GrEffect* GrAlignedRectEffect::TestCreate(SkRandom* random,
                                           GrContext* context,
                                           const GrDrawTargetCaps&,
                                           GrTexture* textures[]) {
     return GrAlignedRectEffect::Create();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 class GrGLRectEffect;
 
 /**
  * The output of this effect is a modulation of the input color and coverage
  * for an arbitrarily oriented rect. The rect is specified as:
  *      Center of the rect
  *      Unit vector point down the height of the rect
  *      Half width + 0.5
  *      Half height + 0.5
  * The center and vector are stored in a vec4 varying ("RectEdge") with the
  * center in the xy components and the vector in the zw components.
  * The munged width and height are stored in a vec2 varying ("WidthHeight")
  * with the width in x and the height in y.
  */
-class GrRectEffect : public GrVertexEffect {
+
+class GrRectEffect : public GrGeometryProcessor {
 public:
     static GrEffect* Create() {
         GR_CREATE_STATIC_EFFECT(gRectEffect, GrRectEffect, ());
         gRectEffect->ref();
         return gRectEffect;
     }
 
     virtual ~GrRectEffect() {}
 
     static const char* Name() { return "RectEdge"; }
 
     virtual void getConstantColorComponents(GrColor* color,
                                             uint32_t* validFlags) const SK_OVERRIDE {
         *validFlags = 0;
     }
 
+    const GrShaderVar& aRectEdge() const { return fAttrRectEdge; }
+    const GrShaderVar& aWidthHeight() const { return fAttrWidthHeight; }
+
     virtual const GrBackendEffectFactory& getFactory() const SK_OVERRIDE {
         return GrTBackendEffectFactory<GrRectEffect>::getInstance();
     }
 
-    class GLEffect : public GrGLVertexEffect {
+    class GLEffect : public GrGLGeometryProcessor {
     public:
         GLEffect(const GrBackendEffectFactory& factory, const GrDrawEffect&)
         : INHERITED (factory) {}
 
         virtual void emitCode(GrGLFullProgramBuilder* builder,
                               const GrDrawEffect& drawEffect,
                               const GrEffectKey& key,
                               const char* outputColor,
                               const char* inputColor,
                               const TransformedCoordsArray&,
                               const TextureSamplerArray& samplers) SK_OVERRIDE {
             // setup the varying for the center point and the unit vector
             // that points down the height of the rect
             const char *vsRectEdgeName, *fsRectEdgeName;
             builder->addVarying(kVec4f_GrSLType, "RectEdge",
                                 &vsRectEdgeName, &fsRectEdgeName);
 
+            const GrRectEffect& rectEffect = drawEffect.castEffect<GrRectEffect>();
             GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
-            const SkString* attr0Name =
-                vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
-            vsBuilder->codeAppendf("\t%s = %s;\n", vsRectEdgeName, attr0Name->c_str());
+            vsBuilder->codeAppendf("%s = %s;", vsRectEdgeName, rectEffect.aRectEdge().c_str());
 
             // setup the varying for width/2+.5 and height/2+.5
             const char *vsWidthHeightName, *fsWidthHeightName;
             builder->addVarying(kVec2f_GrSLType, "WidthHeight",
                                 &vsWidthHeightName, &fsWidthHeightName);
-            const SkString* attr1Name =
-                vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[1]);
-            vsBuilder->codeAppendf("\t%s = %s;\n", vsWidthHeightName, attr1Name->c_str());
+            vsBuilder->codeAppendf("%s = %s;",
+                                   vsWidthHeightName,
+                                   rectEffect.aWidthHeight().c_str());
 
             GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
             // TODO: compute all these offsets, spans, and scales in the VS
             fsBuilder->codeAppendf("\tfloat insetW = min(1.0, %s.x) - 0.5;\n", fsWidthHeightName);
             fsBuilder->codeAppendf("\tfloat insetH = min(1.0, %s.y) - 0.5;\n", fsWidthHeightName);
             fsBuilder->codeAppend("\tfloat outset = 0.5;\n");
             // For rects > 1 pixel wide and tall the span's are noops (i.e., 1.0). For rects
             // < 1 pixel wide or tall they serve to normalize the < 1 ramp to a 0 .. 1 range.
             fsBuilder->codeAppend("\tfloat spanW = insetW + outset;\n");
             fsBuilder->codeAppend("\tfloat spanH = insetH + outset;\n");
@@ skipping 22 matching lines @@
 
             fsBuilder->codeAppendf("\t%s = %s;\n", outputColor,
                                    (GrGLSLExpr4(inputColor) * GrGLSLExpr1("coverage")).c_str());
         }
 
         static void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*) {}
 
         virtual void setData(const GrGLProgramDataManager& pdman, const GrDrawEffect&) SK_OVERRIDE {}
 
     private:
-        typedef GrGLVertexEffect INHERITED;
+        typedef GrGLGeometryProcessor INHERITED;
     };
 
 
+
 private:
-    GrRectEffect() : GrVertexEffect() {
-        this->addVertexAttrib(kVec4f_GrSLType);
-        this->addVertexAttrib(kVec2f_GrSLType);
+    GrRectEffect()
+        : GrGeometryProcessor()
+        , fAttrRectEdge(this->addVertexAttrib(GrShaderVar("aRectEdge",
+                                                          kVec4f_GrSLType,
+                                                          GrShaderVar::kAttribute_TypeModifier)))
+        , fAttrWidthHeight(this->addVertexAttrib(
+                GrShaderVar("aWidthHeight",
+                            kVec2f_GrSLType,
+                            GrShaderVar::kAttribute_TypeModifier))) {
         this->setWillReadFragmentPosition();
     }
 
     virtual bool onIsEqual(const GrEffect&) const SK_OVERRIDE { return true; }
 
+    const GrShaderVar& fAttrRectEdge;
+    const GrShaderVar& fAttrWidthHeight;
+
     GR_DECLARE_EFFECT_TEST;
 
-    typedef GrVertexEffect INHERITED;
+    typedef GrGeometryProcessor INHERITED;
 };
 
 
 GR_DEFINE_EFFECT_TEST(GrRectEffect);
 
 GrEffect* GrRectEffect::TestCreate(SkRandom* random,
                                    GrContext* context,
                                    const GrDrawTargetCaps&,
                                    GrTexture* textures[]) {
     return GrRectEffect::Create();
@@ skipping 380 matching lines @@
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 4, 0);
     if (!geo.succeeded()) {
         GrPrintf("Failed to get space for vertices!\n");
         return;
     }
 
     RectVertex* verts = reinterpret_cast<RectVertex*>(geo.vertices());
 
     GrEffect* effect = GrRectEffect::Create();
-    static const int kRectAttrIndex = 1;
-    static const int kWidthIndex = 2;
-    drawState->setGeometryProcessor(effect, kRectAttrIndex, kWidthIndex)->unref();
+    drawState->setGeometryProcessor(effect)->unref();
 
     for (int i = 0; i < 4; ++i) {
         verts[i].fCenter = center;
         verts[i].fDir = dir;
         verts[i].fWidthHeight.fX = newWidth;
         verts[i].fWidthHeight.fY = newHeight;
     }
 
     SkRect devRect;
     combinedMatrix.mapRect(&devRect, rect);
@@ skipping 27 matching lines @@
 
     GrDrawTarget::AutoReleaseGeometry geo(target, 4, 0);
     if (!geo.succeeded()) {
         GrPrintf("Failed to get space for vertices!\n");
         return;
     }
 
     AARectVertex* verts = reinterpret_cast<AARectVertex*>(geo.vertices());
 
     GrEffect* effect = GrAlignedRectEffect::Create();
-    static const int kOffsetIndex = 1;
-    drawState->setGeometryProcessor(effect, kOffsetIndex)->unref();
+    drawState->setGeometryProcessor(effect)->unref();
 
     SkRect devRect;
     combinedMatrix.mapRect(&devRect, rect);
 
     SkRect devBounds = {
         devRect.fLeft   - SK_ScalarHalf,
         devRect.fTop    - SK_ScalarHalf,
         devRect.fRight  + SK_ScalarHalf,
         devRect.fBottom + SK_ScalarHalf
     };
@@ skipping 238 matching lines @@
     // can't call mapRect for devInside since it calls sort
     combinedMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2);
 
     if (devInside.isEmpty()) {
         this->fillAARect(gpu, target, devOutside, SkMatrix::I(), devOutside);
         return;
     }
 
     this->geometryStrokeAARect(gpu, target, devOutside, devOutsideAssist, devInside, true);
 }