Removing vertex attrib indices

src/gpu/GrRODrawState.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 "GrRODrawState.h"
 
 #include "GrDrawTargetCaps.h"
@@ skipping 75 matching lines @@
         slTypes[i] = static_cast<GrSLType>(-1);
     }
 
     if (this->hasGeometryProcessor()) {
         const GrEffectStage& stage = *this->getGeometryProcessor();
         const GrEffect* effect = stage.getEffect();
         SkASSERT(effect);
         // make sure that any attribute indices have the correct binding type, that the attrib
         // type and effect's shader lang type are compatible, and that attributes shared by
         // multiple effects use the same shader lang type.
-        const int* attributeIndices = stage.getVertexAttribIndices();
-        int numAttributes = stage.getVertexAttribIndexCount();
-        for (int i = 0; i < numAttributes; ++i) {
-            int attribIndex = attributeIndices[i];
-            if (attribIndex >= fVACount ||
-                kEffect_GrVertexAttribBinding != fVAPtr[attribIndex].fBinding) {
-                return false;
+        const GrEffect::VertexAttribArray& s = effect->getVertexAttribs();
+
+        const int effectAttribCount = s.count();
+        int effectIndex = 0;
+        for (int index = 0; index < fVACount; index++) {
+            if (kEffect_GrVertexAttribBinding != fVAPtr[index].fBinding) {
+                // we only care about effect bindings
+                continue;
             }
-
-            GrSLType effectSLType = effect->vertexAttribType(i);
-            GrVertexAttribType attribType = fVAPtr[attribIndex].fType;
+            SkASSERT(effectIndex < effectAttribCount);
+            GrSLType effectSLType = s[effectIndex].getType();
+            GrVertexAttribType attribType = fVAPtr[index].fType;
             int slVecCount = GrSLTypeVectorCount(effectSLType);
             int attribVecCount = GrVertexAttribTypeVectorCount(attribType);
             if (slVecCount != attribVecCount ||
-                (static_cast<GrSLType>(-1) != slTypes[attribIndex] &&
-                    slTypes[attribIndex] != effectSLType)) {
+                (static_cast<GrSLType>(-1) != slTypes[index] && slTypes[index] != effectSLType)) {
                 return false;
             }
-            slTypes[attribIndex] = effectSLType;
+            slTypes[index] = effectSLType;
+            effectIndex++;
         }
+        // Make sure all attributes are consumed and we were able to find everything
+        SkASSERT(effectAttribCount == effectIndex);
     }
 
     return true;
 }
 
 bool GrRODrawState::hasSolidCoverage() const {
     // If we're drawing coverage directly then coverage is effectively treated as color.
     if (this->isCoverageDrawing()) {
         return true;
     }
@@ skipping 247 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrRODrawState::canIgnoreColorAttribute() const {
     if (fBlendOptFlags & kInvalid_BlendOptFlag) {
         this->getBlendOpts();
     }
     return SkToBool(fBlendOptFlags & (GrRODrawState::kEmitTransBlack_BlendOptFlag |
                                       GrRODrawState::kEmitCoverage_BlendOptFlag));
 }