Revert "Revert "Change how vertex/instance attributes are handled in geometry processors.""

This reverts commit 5045e501d2aec23e5f1e4b46346033ac3202c6b0.

TBR=csmartdalton@google.com

Change-Id: Ifbf5f1d8f8ef340fdc69653e931b6d68d4bf0854
Reviewed-on: https://skia-review.googlesource.com/135862
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>

6 files changed, 73 insertions, 48 deletions

diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 88f5abecb4..be53222ee8 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -1775,35 +1775,29 @@ void GrGLGpu::setupGeometry(const GrBuffer* indexBuffer,
         attribState = fHWVertexArrayState.bindInternalVertexArray(this);
     }
 
-    struct {
-        const GrBuffer*   fBuffer;
-        int               fStride;
-        size_t            fBufferOffset;
-    } bindings[2];
+    int numAttribs = fHWProgram->numVertexAttributes() + fHWProgram->numInstanceAttributes();
+    attribState->enableVertexArrays(this, numAttribs, enablePrimitiveRestart);
 
     if (int vertexStride = fHWProgram->vertexStride()) {
         SkASSERT(vertexBuffer && !vertexBuffer->isMapped());
-        bindings[0].fBuffer = vertexBuffer;
-        bindings[0].fStride = vertexStride;
-        bindings[0].fBufferOffset = vertexBuffer->baseOffset() + baseVertex * vertexStride;
+        size_t bufferOffset = vertexBuffer->baseOffset() + baseVertex * vertexStride;
+        for (int i = 0; i < fHWProgram->numVertexAttributes(); ++i) {
+            const auto& attrib = fHWProgram->vertexAttribute(i);
+            static constexpr int kDivisor = 0;
+            attribState->set(this, attrib.fLocation, vertexBuffer, attrib.fType, vertexStride,
+                             bufferOffset + attrib.fOffset, kDivisor);
+        }
     }
     if (int instanceStride = fHWProgram->instanceStride()) {
         SkASSERT(instanceBuffer && !instanceBuffer->isMapped());
-        bindings[1].fBuffer = instanceBuffer;
-        bindings[1].fStride = instanceStride;
-        bindings[1].fBufferOffset = instanceBuffer->baseOffset() + baseInstance * instanceStride;
-    }
-
-    auto numAttributes = fHWProgram->numAttributes();
-    attribState->enableVertexArrays(this, numAttributes, enablePrimitiveRestart);
-
-    for (int i = 0; i < numAttributes; ++i) {
-        using InputRate = GrPrimitiveProcessor::Attribute::InputRate;
-        const GrGLProgram::Attribute& attribute = fHWProgram->attribute(i);
-        const int divisor = InputRate::kPerInstance == attribute.fInputRate ? 1 : 0;
-        const auto& binding = bindings[divisor];
-        attribState->set(this, attribute.fLocation, binding.fBuffer, attribute.fType,
-                         binding.fStride, binding.fBufferOffset + attribute.fOffset, divisor);
+        size_t bufferOffset = instanceBuffer->baseOffset() + baseInstance * instanceStride;
+        int attribIdx = fHWProgram->numVertexAttributes();
+        for (int i = 0; i < fHWProgram->numInstanceAttributes(); ++i, ++attribIdx) {
+            const auto& attrib = fHWProgram->instanceAttribute(i);
+            static constexpr int kDivisor = 1;
+            attribState->set(this, attrib.fLocation, instanceBuffer, attrib.fType, instanceStride,
+                             bufferOffset + attrib.fOffset, kDivisor);
+        }
     }
 }
 
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index 262f0b21c4..3d4bd380fa 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -38,7 +38,8 @@ GrGLProgram::GrGLProgram(
         std::unique_ptr<std::unique_ptr<GrGLSLFragmentProcessor>[]> fragmentProcessors,
         int fragmentProcessorCnt,
         std::unique_ptr<Attribute[]> attributes,
-        int attributeCnt,
+        int vertexAttributeCnt,
+        int instanceAttributeCnt,
         int vertexStride,
         int instanceStride)
         : fBuiltinUniformHandles(builtinUniforms)
@@ -48,7 +49,8 @@ GrGLProgram::GrGLProgram(
         , fFragmentProcessors(std::move(fragmentProcessors))
         , fFragmentProcessorCnt(fragmentProcessorCnt)
         , fAttributes(std::move(attributes))
-        , fAttributeCnt(attributeCnt)
+        , fVertexAttributeCnt(vertexAttributeCnt)
+        , fInstanceAttributeCnt(instanceAttributeCnt)
         , fVertexStride(vertexStride)
         , fInstanceStride(instanceStride)
         , fGpu(gpu)
diff --git a/src/gpu/gl/GrGLProgram.h b/src/gpu/gl/GrGLProgram.h
index 6ea1f2cbf9..ca4eddce4b 100644
--- a/src/gpu/gl/GrGLProgram.h
+++ b/src/gpu/gl/GrGLProgram.h
@@ -10,7 +10,6 @@
 #define GrGLProgram_DEFINED
 
 #include "GrGLProgramDataManager.h"
-#include "GrPrimitiveProcessor.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLUniformHandler.h"
 
@@ -35,15 +34,18 @@ public:
      */
     struct Attribute {
         GrVertexAttribType fType;
-        int fOffset;
+        size_t fOffset;
         GrGLint fLocation;
-        GrPrimitiveProcessor::Attribute::InputRate fInputRate;
     };
 
     using UniformHandle = GrGLSLProgramDataManager::UniformHandle;
     using UniformInfoArray = GrGLProgramDataManager::UniformInfoArray;
     using VaryingInfoArray = GrGLProgramDataManager::VaryingInfoArray;
 
+    /**
+     * The attribute array consists of vertexAttributeCnt + instanceAttributeCnt elements with
+     * the vertex attributes preceding the instance attributes.
+     */
     GrGLProgram(GrGLGpu*,
                 const GrGLSLBuiltinUniformHandles&,
                 GrGLuint programID,
@@ -56,7 +58,8 @@ public:
                 std::unique_ptr<std::unique_ptr<GrGLSLFragmentProcessor>[]> fragmentProcessors,
                 int fragmentProcessorCnt,
                 std::unique_ptr<Attribute[]>,
-                int attributeCnt,
+                int vertexAttributeCnt,
+                int instanceAttributeCnt,
                 int vertexStride,
                 int instanceStride);
 
@@ -124,8 +127,17 @@ public:
     int vertexStride() const { return fVertexStride; }
     int instanceStride() const { return fInstanceStride; }
 
-    int numAttributes() const { return fAttributeCnt; }
-    const Attribute& attribute(int i) const { return fAttributes[i]; }
+    int numVertexAttributes() const { return fVertexAttributeCnt; }
+    const Attribute& vertexAttribute(int i) const {
+        SkASSERT(i >= 0 && i < fVertexAttributeCnt);
+        return fAttributes[i];
+    }
+
+    int numInstanceAttributes() const { return fInstanceAttributeCnt; }
+    const Attribute& instanceAttribute(int i) const {
+        SkASSERT(i >= 0 && i < fInstanceAttributeCnt);
+        return fAttributes[i + fVertexAttributeCnt];
+    }
 
 private:
     // A helper to loop over effects, set the transforms (via subclass) and bind textures
@@ -153,7 +165,8 @@ private:
     int fFragmentProcessorCnt;
 
     std::unique_ptr<Attribute[]> fAttributes;
-    int fAttributeCnt;
+    int fVertexAttributeCnt;
+    int fInstanceAttributeCnt;
     int fVertexStride;
     int fInstanceStride;
 
diff --git a/src/gpu/gl/GrGLVaryingHandler.cpp b/src/gpu/gl/GrGLVaryingHandler.cpp
index eecc63e617..e426d46e14 100644
--- a/src/gpu/gl/GrGLVaryingHandler.cpp
+++ b/src/gpu/gl/GrGLVaryingHandler.cpp
@@ -20,7 +20,8 @@ GrGLSLVaryingHandler::VaryingHandle GrGLVaryingHandler::addPathProcessingVarying
     SkASSERT(glPB->gpu()->glCaps().shaderCaps()->pathRenderingSupport() &&
              glPB->fPrimProc.isPathRendering() &&
              !glPB->fPrimProc.willUseGeoShader() &&
-             glPB->fPrimProc.numAttribs() == 0);
+             !glPB->fPrimProc.numVertexAttributes() &&
+             !glPB->fPrimProc.numInstanceAttributes());
 #endif
     this->addVarying(name, v);
     auto varyingInfo = fPathProcVaryingInfos.push_back();
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
index 0cdc3b5b21..79e13d3555 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
@@ -70,7 +70,8 @@ GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu,
         , fGpu(gpu)
         , fVaryingHandler(this)
         , fUniformHandler(this)
-        , fAttributeCnt(0)
+        , fVertexAttributeCnt(0)
+        , fInstanceAttributeCnt(0)
         , fVertexStride(0)
         , fInstanceStride(0) {}
 
@@ -227,18 +228,30 @@ GrGLProgram* GrGLProgramBuilder::finalize() {
         // NVPR actually requires a vertex shader to compile
         bool useNvpr = primProc.isPathRendering();
         if (!useNvpr) {
-            fAttributeCnt = primProc.numAttribs();
-            fAttributes.reset(new GrGLProgram::Attribute[fAttributeCnt]);
-            fVertexStride = primProc.getVertexStride();
-            fInstanceStride = primProc.getInstanceStride();
-            for (int i = 0; i < fAttributeCnt; i++) {
-                const auto& attr = primProc.getAttrib(i);
-                fAttributes[i].fInputRate = attr.inputRate();
-                fAttributes[i].fType = attr.type();
-                fAttributes[i].fOffset = attr.offsetInRecord();
+            fVertexAttributeCnt = primProc.numVertexAttributes();
+            fInstanceAttributeCnt = primProc.numInstanceAttributes();
+            fAttributes.reset(
+                    new GrGLProgram::Attribute[fVertexAttributeCnt + fInstanceAttributeCnt]);
+            auto addAttr = [&](int i, const auto& a, size_t* stride) {
+                fAttributes[i].fType = a.type();
+                fAttributes[i].fOffset = *stride;
+                *stride += a.sizeAlign4();
                 fAttributes[i].fLocation = i;
-                GL_CALL(BindAttribLocation(programID, i, attr.name()));
+                GL_CALL(BindAttribLocation(programID, i, a.name()));
+            };
+            fVertexStride = 0;
+            int i = 0;
+            for (; i < fVertexAttributeCnt; i++) {
+                addAttr(i, primProc.vertexAttribute(i), &fVertexStride);
+                SkASSERT(fAttributes[i].fOffset == primProc.debugOnly_vertexAttributeOffset(i));
             }
+            SkASSERT(fVertexStride == primProc.debugOnly_vertexStride());
+            fInstanceStride = 0;
+            for (int j = 0; j < fInstanceAttributeCnt; j++, ++i) {
+                addAttr(i, primProc.instanceAttribute(j), &fInstanceStride);
+                SkASSERT(fAttributes[i].fOffset == primProc.debugOnly_instanceAttributeOffset(j));
+            }
+            SkASSERT(fInstanceStride == primProc.debugOnly_instanceStride());
         }
 
         if (primProc.willUseGeoShader()) {
@@ -406,7 +419,8 @@ GrGLProgram* GrGLProgramBuilder::createProgram(GrGLuint programID) {
                            std::move(fFragmentProcessors),
                            fFragmentProcessorCnt,
                            std::move(fAttributes),
-                           fAttributeCnt,
+                           fVertexAttributeCnt,
+                           fInstanceAttributeCnt,
                            fVertexStride,
                            fInstanceStride);
 }
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.h b/src/gpu/gl/builders/GrGLProgramBuilder.h
index ea3432bd04..30d5179325 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.h
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.h
@@ -81,9 +81,10 @@ private:
     GrGLUniformHandler    fUniformHandler;
 
     std::unique_ptr<GrGLProgram::Attribute[]> fAttributes;
-    int fAttributeCnt;
-    int fVertexStride;
-    int fInstanceStride;
+    int fVertexAttributeCnt;
+    int fInstanceAttributeCnt;
+    size_t fVertexStride;
+    size_t fInstanceStride;
 
     // shader pulled from cache. Data is organized as:
     // SkSL::Program::Inputs inputs