Removing vertex attrib indices

src/gpu/effects/GrBezierEffect.cpp

 /*
  * Copyright 2013 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 "GrBezierEffect.h"
 
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLSL.h"
-#include "gl/GrGLVertexEffect.h"
+#include "gl/GrGLGeometryProcessor.h"
 #include "GrTBackendEffectFactory.h"
 
-class GrGLConicEffect : public GrGLVertexEffect {
+class GrGLConicEffect : public GrGLGeometryProcessor {
 public:
     GrGLConicEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
 
     virtual void emitCode(GrGLFullProgramBuilder* builder,
                           const GrDrawEffect& drawEffect,
                           const GrEffectKey& key,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
 
     static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
 
     virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {}
 
 private:
     GrEffectEdgeType fEdgeType;
 
-    typedef GrGLVertexEffect INHERITED;
+    typedef GrGLGeometryProcessor INHERITED;
 };
 
 GrGLConicEffect::GrGLConicEffect(const GrBackendEffectFactory& factory,
                                  const GrDrawEffect& drawEffect)
     : INHERITED (factory) {
     const GrConicEffect& ce = drawEffect.castEffect<GrConicEffect>();
     fEdgeType = ce.getEdgeType();
 }
 
 void GrGLConicEffect::emitCode(GrGLFullProgramBuilder* builder,
                                const GrDrawEffect& drawEffect,
                                const GrEffectKey& key,
                                const char* outputColor,
                                const char* inputColor,
                                const TransformedCoordsArray&,
                                const TextureSamplerArray& samplers) {
     const char *vsName, *fsName;
 
     builder->addVarying(kVec4f_GrSLType, "ConicCoeffs",
                               &vsName, &fsName);
 
+    const GrShaderVar& aConicCoeffs = drawEffect.castEffect<GrConicEffect>().aConicCoeffs();
     GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
-    const SkString* attr0Name =
-        vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
-    vsBuilder->codeAppendf("%s = %s;", vsName, attr0Name->c_str());
+    vsBuilder->codeAppendf("%s = %s;", vsName, aConicCoeffs.c_str());
 
     GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     fsBuilder->codeAppend("float edgeAlpha;");
 
     switch (fEdgeType) {
         case kHairlineAA_GrEffectEdgeType: {
             SkAssertResult(fsBuilder->enableFeature(
                     GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
             fsBuilder->codeAppendf("vec3 dklmdx = dFdx(%s.xyz);", fsName);
             fsBuilder->codeAppendf("vec3 dklmdy = dFdy(%s.xyz);", fsName);
@@ skipping 57 matching lines @@
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrConicEffect::~GrConicEffect() {}
 
 const GrBackendEffectFactory& GrConicEffect::getFactory() const {
     return GrTBackendEffectFactory<GrConicEffect>::getInstance();
 }
 
-GrConicEffect::GrConicEffect(GrEffectEdgeType edgeType) : GrVertexEffect() {
-    this->addVertexAttrib(kVec4f_GrSLType);
-    fEdgeType = edgeType;
+GrConicEffect::GrConicEffect(GrEffectEdgeType edgeType)
+    : GrGeometryProcessor()

[bsalomon, 2014/09/12 00:34:17]

We usually use the INHERITED typedef for the base class. Also, does it work to
omit the explicit base class default cons?

[joshua.litt, 2014/09/12 00:46:07]

Acknowledged.

+    , fEdgeType(edgeType)
+    , fAttrConicCoeffs(this->addVertexAttrib(GrShaderVar("aConicCoeffs",
+                                                         kVec4f_GrSLType,
+                                                         GrShaderVar::kAttribute_TypeModifier))) {
 }
 
 bool GrConicEffect::onIsEqual(const GrEffect& other) const {
     const GrConicEffect& ce = CastEffect<GrConicEffect>(other);
     return (ce.fEdgeType == fEdgeType);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_EFFECT_TEST(GrConicEffect);
 
 GrEffect* GrConicEffect::TestCreate(SkRandom* random,
                                     GrContext*,
                                     const GrDrawTargetCaps& caps,
                                     GrTexture*[]) {
     GrEffect* effect;
     do {
         GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(
                                                     random->nextULessThan(kGrEffectEdgeTypeCnt));
         effect = GrConicEffect::Create(edgeType, caps);
     } while (NULL == effect);
     return effect;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Quad
 //////////////////////////////////////////////////////////////////////////////
 
-class GrGLQuadEffect : public GrGLVertexEffect {
+class GrGLQuadEffect : public GrGLGeometryProcessor {
 public:
     GrGLQuadEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
 
     virtual void emitCode(GrGLFullProgramBuilder* builder,
                           const GrDrawEffect& drawEffect,
                           const GrEffectKey& key,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
 
     static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
 
     virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {}
 
 private:
     GrEffectEdgeType fEdgeType;
 
-    typedef GrGLVertexEffect INHERITED;
+    typedef GrGLGeometryProcessor INHERITED;
 };
 
 GrGLQuadEffect::GrGLQuadEffect(const GrBackendEffectFactory& factory,
                                  const GrDrawEffect& drawEffect)
     : INHERITED (factory) {
     const GrQuadEffect& ce = drawEffect.castEffect<GrQuadEffect>();
     fEdgeType = ce.getEdgeType();
 }
 
 void GrGLQuadEffect::emitCode(GrGLFullProgramBuilder* builder,
                               const GrDrawEffect& drawEffect,
                               const GrEffectKey& key,
                               const char* outputColor,
                               const char* inputColor,
                               const TransformedCoordsArray&,
                               const TextureSamplerArray& samplers) {
     const char *vsName, *fsName;
     builder->addVarying(kVec4f_GrSLType, "HairQuadEdge", &vsName, &fsName);
 
     GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
-    const SkString* attrName =
-        vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
-    vsBuilder->codeAppendf("%s = %s;", vsName, attrName->c_str());
+    const GrShaderVar& aHairQuadEdge = drawEffect.castEffect<GrQuadEffect>().aHairQuadEdge();

[bsalomon, 2014/09/12 00:34:17]

similar for the local vars, hairQuadAttr? I don't think we use 'u' for
GrGLShaderVars that are uniforms, 'v' for varyings, etc. Ok to adopt a new
pattern but would rather be consistent.

[joshua.litt, 2014/09/12 00:46:06]

Yea, I probably should have discussed this with you guys.  I like the convention
of using the same variable names for shader vars in both GL code and C++.  I
think this makes it very easy to track when moving between shader code and C++. 
I am happy to change this if the team disagrees.

+    vsBuilder->codeAppendf("%s = %s;", vsName, aHairQuadEdge.c_str());
 
     GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     fsBuilder->codeAppendf("float edgeAlpha;");
 
     switch (fEdgeType) {
         case kHairlineAA_GrEffectEdgeType: {
             SkAssertResult(fsBuilder->enableFeature(
                     GrGLFragmentShaderBuilder::kStandardDerivatives_GLSLFeature));
             fsBuilder->codeAppendf("vec2 duvdx = dFdx(%s.xy);", fsName);
             fsBuilder->codeAppendf("vec2 duvdy = dFdy(%s.xy);", fsName);
@@ skipping 43 matching lines @@
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrQuadEffect::~GrQuadEffect() {}
 
 const GrBackendEffectFactory& GrQuadEffect::getFactory() const {
     return GrTBackendEffectFactory<GrQuadEffect>::getInstance();
 }
 
-GrQuadEffect::GrQuadEffect(GrEffectEdgeType edgeType) : GrVertexEffect() {
-    this->addVertexAttrib(kVec4f_GrSLType);
-    fEdgeType = edgeType;
+GrQuadEffect::GrQuadEffect(GrEffectEdgeType edgeType)
+    : GrGeometryProcessor()
+    , fEdgeType(edgeType)
+    , fAttrHairQuadEdge(this->addVertexAttrib(GrShaderVar("aCubicCoeffs",
+                                                          kVec4f_GrSLType,
+                                                          GrShaderVar::kAttribute_TypeModifier))) {
 }
 
 bool GrQuadEffect::onIsEqual(const GrEffect& other) const {
     const GrQuadEffect& ce = CastEffect<GrQuadEffect>(other);
     return (ce.fEdgeType == fEdgeType);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_EFFECT_TEST(GrQuadEffect);
 
 GrEffect* GrQuadEffect::TestCreate(SkRandom* random,
                                    GrContext*,
                                    const GrDrawTargetCaps& caps,
                                    GrTexture*[]) {
     GrEffect* effect;
     do {
         GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(
                                                     random->nextULessThan(kGrEffectEdgeTypeCnt));
         effect = GrQuadEffect::Create(edgeType, caps);
     } while (NULL == effect);
     return effect;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // Cubic
 //////////////////////////////////////////////////////////////////////////////
 
-class GrGLCubicEffect : public GrGLVertexEffect {
+class GrGLCubicEffect : public GrGLGeometryProcessor {
 public:
     GrGLCubicEffect(const GrBackendEffectFactory&, const GrDrawEffect&);
 
     virtual void emitCode(GrGLFullProgramBuilder* builder,
                           const GrDrawEffect& drawEffect,
                           const GrEffectKey& key,
                           const char* outputColor,
                           const char* inputColor,
                           const TransformedCoordsArray&,
                           const TextureSamplerArray&) SK_OVERRIDE;
 
     static inline void GenKey(const GrDrawEffect&, const GrGLCaps&, GrEffectKeyBuilder*);
 
     virtual void setData(const GrGLProgramDataManager&, const GrDrawEffect&) SK_OVERRIDE {}
 
 private:
     GrEffectEdgeType fEdgeType;
 
-    typedef GrGLVertexEffect INHERITED;
+    typedef GrGLGeometryProcessor INHERITED;
 };
 
 GrGLCubicEffect::GrGLCubicEffect(const GrBackendEffectFactory& factory,
                                  const GrDrawEffect& drawEffect)
     : INHERITED (factory) {
     const GrCubicEffect& ce = drawEffect.castEffect<GrCubicEffect>();
     fEdgeType = ce.getEdgeType();
 }
 
 void GrGLCubicEffect::emitCode(GrGLFullProgramBuilder* builder,
                                const GrDrawEffect& drawEffect,
                                const GrEffectKey& key,
                                const char* outputColor,
                                const char* inputColor,
                                const TransformedCoordsArray&,
                                const TextureSamplerArray& samplers) {
     const char *vsName, *fsName;
 
     builder->addVarying(kVec4f_GrSLType, "CubicCoeffs",
                               &vsName, &fsName, GrGLShaderVar::kHigh_Precision);
 
     GrGLVertexShaderBuilder* vsBuilder = builder->getVertexShaderBuilder();
-    const SkString* attr0Name =
-        vsBuilder->getEffectAttributeName(drawEffect.getVertexAttribIndices()[0]);
-    vsBuilder->codeAppendf("%s = %s;", vsName, attr0Name->c_str());
+    const GrShaderVar& aCubicCoeffs = drawEffect.castEffect<GrCubicEffect>().aCubicCoeffs();
+    vsBuilder->codeAppendf("%s = %s;", vsName, aCubicCoeffs.c_str());
 
     GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
 
     GrGLShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precision);
     GrGLShaderVar dklmdx("dklmdx", kVec3f_GrSLType, 0, GrGLShaderVar::kHigh_Precision);
     GrGLShaderVar dklmdy("dklmdy", kVec3f_GrSLType, 0, GrGLShaderVar::kHigh_Precision);
     GrGLShaderVar dfdx("dfdx", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precision);
     GrGLShaderVar dfdy("dfdy", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precision);
     GrGLShaderVar gF("gF", kVec2f_GrSLType, 0, GrGLShaderVar::kHigh_Precision);
     GrGLShaderVar gFM("gFM", kFloat_GrSLType, 0, GrGLShaderVar::kHigh_Precision);
@@ skipping 83 matching lines @@
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrCubicEffect::~GrCubicEffect() {}
 
 const GrBackendEffectFactory& GrCubicEffect::getFactory() const {
     return GrTBackendEffectFactory<GrCubicEffect>::getInstance();
 }
 
-GrCubicEffect::GrCubicEffect(GrEffectEdgeType edgeType) : GrVertexEffect() {
-    this->addVertexAttrib(kVec4f_GrSLType);
-    fEdgeType = edgeType;
+GrCubicEffect::GrCubicEffect(GrEffectEdgeType edgeType)
+    : GrGeometryProcessor()
+    , fEdgeType(edgeType)
+    , fAttrCubicCoeffs(this->addVertexAttrib(GrShaderVar("aCubicCoeffs",
+                                                         kVec4f_GrSLType,
+                                                         GrShaderVar::kAttribute_TypeModifier))) {
 }
 
 bool GrCubicEffect::onIsEqual(const GrEffect& other) const {
     const GrCubicEffect& ce = CastEffect<GrCubicEffect>(other);
     return (ce.fEdgeType == fEdgeType);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GR_DEFINE_EFFECT_TEST(GrCubicEffect);
 
 GrEffect* GrCubicEffect::TestCreate(SkRandom* random,
                                     GrContext*,
                                     const GrDrawTargetCaps& caps,
                                     GrTexture*[]) {
     GrEffect* effect;
     do {
         GrEffectEdgeType edgeType = static_cast<GrEffectEdgeType>(
                                                     random->nextULessThan(kGrEffectEdgeTypeCnt));
         effect = GrCubicEffect::Create(edgeType, caps);
     } while (NULL == effect);
     return effect;
 }