Removing vertex attrib indices

src/gpu/gl/GrGLProgramEffects.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 "GrGLProgramEffects.h"
 #include "GrDrawEffect.h"
 #include "gl/GrGLEffect.h"
 #include "gl/GrGLPathRendering.h"
 #include "gl/builders/GrGLProgramBuilder.h"
-#include "gl/GrGLVertexEffect.h"
+#include "gl/GrGLGeometryProcessor.h"
 #include "gl/GrGpuGL.h"
 
 typedef GrGLProgramEffects::TransformedCoords TransformedCoords;
 typedef GrGLProgramEffects::TransformedCoordsArray TransformedCoordsArray;
 typedef GrGLProgramEffects::TextureSampler TextureSampler;
 typedef GrGLProgramEffects::TextureSamplerArray TextureSamplerArray;
 
 /**
  * We specialize the vertex code for each of these matrix types.
  */
@@ skipping 91 matching lines @@
 
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrGLProgramEffects::GenEffectMetaKey(const GrDrawEffect& drawEffect, const GrGLCaps& caps,
                                           GrEffectKeyBuilder* b) {
 
     uint32_t textureKey = GrGLProgramEffects::GenTextureKey(drawEffect, caps);
     uint32_t transformKey = GrGLProgramEffects::GenTransformKey(drawEffect);
-    uint32_t attribKey = GrGLProgramEffects::GenAttribKey(drawEffect);
+    uint32_t attribKey = GrGLProgramEffects::GenAttribKey(drawEffect.castEffect<GrEffect>());
     uint32_t classID = drawEffect.effect()->getFactory().effectClassID();
 
     // Currently we allow 16 bits for each of the above portions of the meta-key. Fail if they
     // don't fit.
     static const uint32_t kMetaKeyInvalidMask = ~((uint32_t) SK_MaxU16);
     if ((textureKey | transformKey | attribKey | classID) & kMetaKeyInvalidMask) {
         return false;
     }
 
     uint32_t* key = b->add32n(2);
     key[0] = (textureKey << 16 | transformKey);
     key[1] = (classID << 16 | attribKey);
     return true;
 }
 
-uint32_t GrGLProgramEffects::GenAttribKey(const GrDrawEffect& drawEffect) {
+uint32_t GrGLProgramEffects::GenAttribKey(const GrEffect& effect) {
     uint32_t key = 0;
-    int numAttributes = drawEffect.getVertexAttribIndexCount();
+
+    const GrEffect::VertexAttribArray& vars = effect.getVertexAttribs();
+    int numAttributes = vars.count();
     SkASSERT(numAttributes <= 2);
-    const int* attributeIndices = drawEffect.getVertexAttribIndices();
     for (int a = 0; a < numAttributes; ++a) {
-        uint32_t value = attributeIndices[a] << 3 * a;
-        SkASSERT(0 == (value & key)); // keys for each attribute ought not to overlap
+        uint32_t value = 1 << a;
         key |= value;
     }
     return key;
 }
 
 uint32_t GrGLProgramEffects::GenTransformKey(const GrDrawEffect& drawEffect) {
     uint32_t totalKey = 0;
     int numTransforms = drawEffect.effect()->numTransforms();
     for (int t = 0; t < numTransforms; ++t) {
         uint32_t key = 0;
@@ skipping 112 matching lines @@
     GrGLEffect* glEffect = effect->getFactory().createGLInstance(drawEffect);
     fGLEffects.push_back(glEffect);
 
     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("\t{ // Stage %d: %s\n", stageIndex, glEffect->name());
     fsBuilder->codeAppend(openBrace.c_str());
     vsBuilder->codeAppend(openBrace.c_str());
 
     if (glEffect->isVertexEffect()) {
-        GrGLVertexEffect* vertexEffect = static_cast<GrGLVertexEffect*>(glEffect);
+        GrGLGeometryProcessor* vertexEffect = static_cast<GrGLGeometryProcessor*>(glEffect);
         vertexEffect->emitCode(builder, drawEffect, key, outColor, inColor, coords, samplers);
     } else {
         glEffect->emitCode(builder, drawEffect, key, outColor, inColor, coords, samplers);
     }
 
     vsBuilder->codeAppend("\t}\n");
     fsBuilder->codeAppend("\t}\n");
 }
 
 void GrGLVertexProgramEffects::emitTransforms(GrGLFullProgramBuilder* builder,
@@ skipping 178 matching lines @@
                                           const GrEffectStage& stage,
                                           const GrEffectKey& key,
                                           const char* outColor,
                                           const char* inColor,
                                           int stageIndex) {
     GrDrawEffect drawEffect(stage, false);
     const GrEffect* effect = stage.getEffect();
     SkSTArray<2, TransformedCoords> coords(effect->numTransforms());
     SkSTArray<4, TextureSampler> samplers(effect->numTextures());
 
-    SkASSERT(0 == stage.getVertexAttribIndexCount());
+    SkASSERT(0 == effect->getVertexAttribs().count());
     this->setupPathTexGen(builder, drawEffect, &coords);
     this->emitSamplers(builder, effect, &samplers);
 
     GrGLEffect* glEffect = effect->getFactory().createGLInstance(drawEffect);
     fGLEffects.push_back(glEffect);
 
     GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     // Enclose custom code in a block to avoid namespace conflicts
     SkString openBrace;
     openBrace.printf("\t{ // Stage %d: %s\n", stageIndex, glEffect->name());
@@ skipping 75 matching lines @@
 }
 void GrGLPathTexGenProgramEffectsBuilder::emitEffect(const GrEffectStage& stage,
                                                      const GrEffectKey& key,
                                                      const char* outColor,
                                                      const char* inColor,
                                                      int stageIndex) {
     SkASSERT(fProgramEffects.get());
     fProgramEffects->emitEffect(fBuilder, stage, key, outColor, inColor, stageIndex);
 }