First step to moving vertex attributes to the geometryProcessor

src/gpu/gl/GrGpuGL_program.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGpuGL.h"
 
 #include "builders/GrGLProgramBuilder.h"
@@ skipping 232 matching lines @@
     // This must come after textures are flushed because a texture may need
     // to be msaa-resolved (which will modify bound FBO state).
     this->flushRenderTarget(glRT, NULL);
 
     return true;
 }
 
 void GrGpuGL::setupGeometry(const GrOptDrawState& optState,
                             const GrDrawTarget::DrawInfo& info,
                             size_t* indexOffsetInBytes) {
-    GrGLsizei stride = static_cast<GrGLsizei>(optState.getVertexStride());
-
-    size_t vertexOffsetInBytes = stride * info.startVertex();
-
     GrGLVertexBuffer* vbuf;
     vbuf = (GrGLVertexBuffer*) info.vertexBuffer();
 
     SkASSERT(vbuf);
     SkASSERT(!vbuf->isMapped());
-    vertexOffsetInBytes += vbuf->baseOffset();
 
     GrGLIndexBuffer* ibuf = NULL;
     if (info.isIndexed()) {
         SkASSERT(indexOffsetInBytes);
 
         *indexOffsetInBytes = 0;
         ibuf = (GrGLIndexBuffer*)info.indexBuffer();
 
         SkASSERT(ibuf);
         SkASSERT(!ibuf->isMapped());
         *indexOffsetInBytes += ibuf->baseOffset();
     }
     GrGLAttribArrayState* attribState =
         fHWGeometryState.bindArrayAndBuffersToDraw(this, vbuf, ibuf);
 
     if (fCurrentProgram->hasVertexShader()) {
-        int vertexAttribCount = optState.getVertexAttribCount();
+        const GrGeometryProcessor* gp = optState.getGeometryProcessor();
+
+        GrGLsizei stride = static_cast<GrGLsizei>(gp->getVertexStride());
+
+        size_t vertexOffsetInBytes = stride * info.startVertex();
+
+        vertexOffsetInBytes += vbuf->baseOffset();
+
+        const SkTArray<GrGeometryProcessor::GrAttribute, true>& attribs = gp->getAttribs();
+        int vaCount = attribs.count();
         uint32_t usedAttribArraysMask = 0;
-        const GrVertexAttrib* vertexAttrib = optState.getVertexAttribs();
+        size_t offset = 0;
 
-        for (int vertexAttribIndex = 0; vertexAttribIndex < vertexAttribCount;
-             ++vertexAttribIndex, ++vertexAttrib) {
-            usedAttribArraysMask |= (1 << vertexAttribIndex);
-            GrVertexAttribType attribType = vertexAttrib->fType;
+        for (int attribIndex = 0; attribIndex < vaCount; attribIndex++) {
+            usedAttribArraysMask |= (1 << attribIndex);
+            GrVertexAttribType attribType = attribs[attribIndex].fType;
             attribState->set(this,
-                             vertexAttribIndex,
+                             attribIndex,
                              vbuf,
                              GrGLAttribTypeToLayout(attribType).fCount,
                              GrGLAttribTypeToLayout(attribType).fType,
                              GrGLAttribTypeToLayout(attribType).fNormalized,
                              stride,
-                             reinterpret_cast<GrGLvoid*>(
-                                 vertexOffsetInBytes + vertexAttrib->fOffset));
+                             reinterpret_cast<GrGLvoid*>(vertexOffsetInBytes + offset));
+            offset += attribs[attribIndex].fOffset;
         }
         attribState->disableUnusedArrays(this, usedAttribArraysMask);
     }
 }
 
 void GrGpuGL::buildProgramDesc(const GrOptDrawState& optState,
                                const GrProgramDesc::DescInfo& descInfo,
                                GrGpu::DrawType drawType,
                                GrProgramDesc* desc) {
     if (!GrGLProgramDescBuilder::Build(optState, descInfo, drawType, this, desc)) {
         SkDEBUGFAIL("Failed to generate GL program descriptor");
     }
 }