Add a bindBuffers() call to GrOpsRenderPass

Adds a bindBuffers() call and removes the GrBuffer arguments from the
draw calls.

Change-Id: I43c2dd8afe80c41e48c1d9d5210affcfe6f095fc
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/273840
Commit-Queue: Chris Dalton <csmartdalton@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>

Author: csmartdalton86

src/gpu/GrMesh.h

@@ -200,30 +200,33 @@ inline void GrMesh::setVertexData(sk_sp<const GrBuffer> vertexBuffer, int baseVe
 inline void GrMesh::draw(GrOpsRenderPass* opsRenderPass) const {
     if (this->isInstanced()) {
         if (!this->isIndexed()) {
-            opsRenderPass->drawInstanced(fInstanceBuffer.get(), fInstanceData.fInstanceCount,
-                                         fInstanceData.fBaseInstance, fVertexBuffer.get(),
+            opsRenderPass->bindBuffers(nullptr, fInstanceBuffer.get(),  fVertexBuffer.get());
+            opsRenderPass->drawInstanced(fInstanceData.fInstanceCount, fInstanceData.fBaseInstance,
                                          fInstanceNonIndexData.fVertexCount, fBaseVertex);
         } else {
+            opsRenderPass->bindBuffers(fIndexBuffer.get(), fInstanceBuffer.get(),
+                                       fVertexBuffer.get(), this->primitiveRestart());
             opsRenderPass->drawIndexedInstanced(
-                    fIndexBuffer.get(), fInstanceIndexData.fIndexCount, 0, this->primitiveRestart(),
-                    fInstanceBuffer.get(), fInstanceData.fInstanceCount,
-                    fInstanceData.fBaseInstance, fVertexBuffer.get(), fBaseVertex);
+                    fInstanceIndexData.fIndexCount, 0, fInstanceData.fInstanceCount,
+                    fInstanceData.fBaseInstance, fBaseVertex);
         }
         return;
     }
 
     if (!this->isIndexed()) {
         SkASSERT(fNonIndexNonInstanceData.fVertexCount > 0);
-        opsRenderPass->draw(fVertexBuffer.get(), fNonIndexNonInstanceData.fVertexCount,
-                            fBaseVertex);
+        opsRenderPass->bindBuffers(nullptr, nullptr, fVertexBuffer.get());
+        opsRenderPass->draw(fNonIndexNonInstanceData.fVertexCount, fBaseVertex);
         return;
     }
 
+    opsRenderPass->bindBuffers(fIndexBuffer.get(), nullptr, fVertexBuffer.get(),
+                               this->primitiveRestart());
+
     if (0 == fIndexData.fPatternRepeatCount) {
-        opsRenderPass->drawIndexed(
-                fIndexBuffer.get(), fIndexData.fIndexCount, fNonPatternIndexData.fBaseIndex,
-                this->primitiveRestart(), fNonPatternIndexData.fMinIndexValue,
-                fNonPatternIndexData.fMaxIndexValue, fVertexBuffer.get(), fBaseVertex);
+        opsRenderPass->drawIndexed(fIndexData.fIndexCount, fNonPatternIndexData.fBaseIndex,
+                                   fNonPatternIndexData.fMinIndexValue,
+                                   fNonPatternIndexData.fMaxIndexValue, fBaseVertex);
         return;
     }
 
@@ -237,8 +240,7 @@ inline void GrMesh::draw(GrOpsRenderPass* opsRenderPass) const {
         int minIndexValue = 0;
         int maxIndexValue = fPatternData.fVertexCount * repeatCount - 1;
         SkASSERT(!(fFlags & Flags::kUsePrimitiveRestart));
-        opsRenderPass->drawIndexed(fIndexBuffer.get(), indexCount, 0, this->primitiveRestart(),
-                                   minIndexValue, maxIndexValue, fVertexBuffer.get(),
+        opsRenderPass->drawIndexed(indexCount, 0, minIndexValue, maxIndexValue,
                                    fBaseVertex + fPatternData.fVertexCount * baseRepetition);
         baseRepetition += repeatCount;
     } while (baseRepetition < fIndexData.fPatternRepeatCount);

src/gpu/GrOpsRenderPass.cpp

@@ -91,8 +91,11 @@ void GrOpsRenderPass::bindPipeline(const GrProgramInfo& programInfo, const SkRec
     }
     fTextureBindingStatus = (hasTextures) ?
             DynamicStateStatus::kUninitialized : DynamicStateStatus::kDisabled;
-    fHasVertexAttributes = programInfo.primProc().hasVertexAttributes();
-    fHasInstanceAttributes = programInfo.primProc().hasInstanceAttributes();
+    fHasIndexBuffer = false;
+    fInstanceBufferStatus = (programInfo.primProc().hasInstanceAttributes()) ?
+            DynamicStateStatus::kUninitialized : DynamicStateStatus::kDisabled;
+    fVertexBufferStatus = (programInfo.primProc().hasVertexAttributes()) ?
+            DynamicStateStatus::kUninitialized : DynamicStateStatus::kDisabled;
 #endif
 
     fDrawPipelineStatus = DrawPipelineStatus::kOk;
@@ -149,6 +152,36 @@ void GrOpsRenderPass::drawMeshes(const GrProgramInfo& programInfo, const GrMesh
     }
 }
 
+void GrOpsRenderPass::bindBuffers(const GrBuffer* indexBuffer, const GrBuffer* instanceBuffer,
+                                  const GrBuffer* vertexBuffer, GrPrimitiveRestart primRestart) {
+    if (DrawPipelineStatus::kOk != fDrawPipelineStatus) {
+        SkASSERT(DrawPipelineStatus::kNotConfigured != fDrawPipelineStatus);
+        return;
+    }
+
+#ifdef SK_DEBUG
+    if (indexBuffer) {
+        fHasIndexBuffer = true;
+    }
+
+    SkASSERT((DynamicStateStatus::kDisabled == fInstanceBufferStatus) != SkToBool(instanceBuffer));
+    if (instanceBuffer) {
+        fInstanceBufferStatus = DynamicStateStatus::kConfigured;
+    }
+
+    SkASSERT((DynamicStateStatus::kDisabled == fVertexBufferStatus) != SkToBool(vertexBuffer));
+    if (vertexBuffer) {
+        fVertexBufferStatus = DynamicStateStatus::kConfigured;
+    }
+
+    if (GrPrimitiveRestart::kYes == primRestart) {
+        SkASSERT(this->gpu()->caps()->usePrimitiveRestart());
+    }
+#endif
+
+    this->onBindBuffers(indexBuffer, instanceBuffer, vertexBuffer, primRestart);
+}
+
 bool GrOpsRenderPass::prepareToDraw() {
     if (DrawPipelineStatus::kOk != fDrawPipelineStatus) {
         SkASSERT(DrawPipelineStatus::kNotConfigured != fDrawPipelineStatus);
@@ -164,52 +197,45 @@ bool GrOpsRenderPass::prepareToDraw() {
     return true;
 }
 
-void GrOpsRenderPass::draw(const GrBuffer* vertexBuffer, int vertexCount, int baseVertex) {
+void GrOpsRenderPass::draw(int vertexCount, int baseVertex) {
     if (!this->prepareToDraw()) {
         return;
     }
-    SkASSERT(SkToBool(vertexBuffer) == fHasVertexAttributes);
-    this->onDraw(vertexBuffer, vertexCount, baseVertex);
+    SkASSERT(!fHasIndexBuffer);
+    SkASSERT(DynamicStateStatus::kConfigured != fInstanceBufferStatus);
+    SkASSERT(DynamicStateStatus::kUninitialized != fVertexBufferStatus);
+    this->onDraw(vertexCount, baseVertex);
 }
 
-void GrOpsRenderPass::drawIndexed(const GrBuffer* indexBuffer, int indexCount,
-                                  int baseIndex, GrPrimitiveRestart primitiveRestart,
-                                  uint16_t minIndexValue, uint16_t maxIndexValue,
-                                  const GrBuffer* vertexBuffer, int baseVertex) {
+void GrOpsRenderPass::drawIndexed(int indexCount, int baseIndex, uint16_t minIndexValue,
+                                  uint16_t maxIndexValue, int baseVertex) {
     if (!this->prepareToDraw()) {
         return;
     }
-    SkASSERT(GrPrimitiveRestart::kNo == primitiveRestart ||
-             this->gpu()->caps()->usePrimitiveRestart());
-    SkASSERT(SkToBool(vertexBuffer) == fHasVertexAttributes);
-    this->onDrawIndexed(indexBuffer, indexCount, baseIndex, primitiveRestart, minIndexValue,
-                        maxIndexValue, vertexBuffer, baseVertex);
+    SkASSERT(fHasIndexBuffer);
+    SkASSERT(DynamicStateStatus::kConfigured != fInstanceBufferStatus);
+    SkASSERT(DynamicStateStatus::kUninitialized != fVertexBufferStatus);
+    this->onDrawIndexed(indexCount, baseIndex, minIndexValue, maxIndexValue, baseVertex);
 }
 
-void GrOpsRenderPass::drawInstanced(const GrBuffer* instanceBuffer, int instanceCount, int
-                                    baseInstance, const GrBuffer* vertexBuffer, int vertexCount,
+void GrOpsRenderPass::drawInstanced(int instanceCount, int baseInstance, int vertexCount,
                                     int baseVertex) {
     if (!this->prepareToDraw()) {
         return;
     }
-    SkASSERT(SkToBool(vertexBuffer) == fHasVertexAttributes);
-    SkASSERT(SkToBool(instanceBuffer) == fHasInstanceAttributes);
-    this->onDrawInstanced(instanceBuffer, instanceCount, baseInstance, vertexBuffer, vertexCount,
-                          baseVertex);
+    SkASSERT(!fHasIndexBuffer);
+    SkASSERT(DynamicStateStatus::kUninitialized != fInstanceBufferStatus);
+    SkASSERT(DynamicStateStatus::kUninitialized != fVertexBufferStatus);
+    this->onDrawInstanced(instanceCount, baseInstance, vertexCount, baseVertex);
 }
 
-void GrOpsRenderPass::drawIndexedInstanced(
-        const GrBuffer* indexBuffer, int indexCount, int baseIndex,
-        GrPrimitiveRestart primitiveRestart, const GrBuffer* instanceBuffer, int instanceCount,
-        int baseInstance, const GrBuffer* vertexBuffer, int baseVertex) {
+void GrOpsRenderPass::drawIndexedInstanced(int indexCount, int baseIndex, int instanceCount,
+                                           int baseInstance, int baseVertex) {
     if (!this->prepareToDraw()) {
         return;
     }
-    SkASSERT(GrPrimitiveRestart::kNo == primitiveRestart ||
-             this->gpu()->caps()->usePrimitiveRestart());
-    SkASSERT(SkToBool(vertexBuffer) == fHasVertexAttributes);
-    SkASSERT(SkToBool(instanceBuffer) == fHasInstanceAttributes);
-    this->onDrawIndexedInstanced(indexBuffer, indexCount, baseIndex, primitiveRestart,
-                                 instanceBuffer, instanceCount, baseInstance, vertexBuffer,
-                                 baseVertex);
+    SkASSERT(fHasIndexBuffer);
+    SkASSERT(DynamicStateStatus::kUninitialized != fInstanceBufferStatus);
+    SkASSERT(DynamicStateStatus::kUninitialized != fVertexBufferStatus);
+    this->onDrawIndexedInstanced(indexCount, baseIndex, instanceCount, baseInstance, baseVertex);
 }

src/gpu/GrOpsRenderPass.h

@@ -66,28 +66,34 @@ class GrOpsRenderPass {
     // again with a different array for primProcTextures. (On subsequent calls, if the backend is
     // capable of updating the primitive processor textures independently, then it will
     // automatically skip binding textures from GrPipeline.)
+    //
+    // If the current program does not use textures, this is a no-op.
     void bindTextures(const GrPrimitiveProcessor&, const GrPipeline&,
                       const GrSurfaceProxy* const primProcTextures[]);
 
+    void bindBuffers(const GrBuffer* indexBuffer, const GrBuffer* instanceBuffer,
+                     const GrBuffer* vertexBuffer, GrPrimitiveRestart = GrPrimitiveRestart::kNo);
+
     // Draws the given array of meshes using the current pipeline state. The client must call
     // bindPipeline() before using this method.
     //
     // NOTE: This method will soon be deleted. While it continues to exist, it takes care of calling
     // setScissor() and bindTextures() on the client's behalf.
     void drawMeshes(const GrProgramInfo&, const GrMesh[], int meshCount);
 
-    // These methods issue draws using the current pipeline state. The client must call
-    // bindPipeline(), followed by setScissor() and/or bindTextures() if applicable, before using
-    // these methods.
-    void draw(const GrBuffer* vertexBuffer, int vertexCount, int baseVertex);
-    void drawIndexed(const GrBuffer* indexBuffer, int indexCount, int baseIndex, GrPrimitiveRestart,
-                     uint16_t minIndexValue, uint16_t maxIndexValue, const GrBuffer* vertexBuffer,
+    // These methods issue draws using the current pipeline state. Before drawing, the caller must
+    // configure the pipeline and dynamic state:
+    //
+    //   - Call bindPipeline()
+    //   - If the scissor test is enabled, call setScissorRect()
+    //   - If the current program uses textures, call bindTextures()
+    //   - Call bindBuffers() (even if all buffers are null)
+    void draw(int vertexCount, int baseVertex);
+    void drawIndexed(int indexCount, int baseIndex, uint16_t minIndexValue, uint16_t maxIndexValue,
                      int baseVertex);
-    void drawInstanced(const GrBuffer* instanceBuffer, int instanceCount, int baseInstance,
-                       const GrBuffer* vertexBuffer, int vertexCount, int baseVertex);
-    void drawIndexedInstanced(const GrBuffer* indexBuffer, int indexCount, int baseIndex,
-                              GrPrimitiveRestart, const GrBuffer* instanceBuffer, int instanceCount,
-                              int baseInstance, const GrBuffer* vertexBuffer, int baseVertex);
+    void drawInstanced(int instanceCount, int baseInstance, int vertexCount, int baseVertex);
+    void drawIndexedInstanced(int indexCount, int baseIndex, int instanceCount, int baseInstance,
+                              int baseVertex);
 
     // Performs an upload of vertex data in the middle of a set of a set of draws
     virtual void inlineUpload(GrOpFlushState*, GrDeferredTextureUploadFn&) = 0;
@@ -132,17 +138,15 @@ class GrOpsRenderPass {
     virtual void onSetScissorRect(const SkIRect&) = 0;
     virtual bool onBindTextures(const GrPrimitiveProcessor&, const GrPipeline&,
                                 const GrSurfaceProxy* const primProcTextures[]) = 0;
-    virtual void onDraw(const GrBuffer* vertexBuffer, int vertexCount, int baseVertex) = 0;
-    virtual void onDrawIndexed(const GrBuffer* indexBuffer, int indexCount, int baseIndex,
-                               GrPrimitiveRestart, uint16_t minIndexValue, uint16_t maxIndexValue,
-                               const GrBuffer* vertexBuffer, int baseVertex) = 0;
-    virtual void onDrawInstanced(const GrBuffer* instanceBuffer, int instanceCount,
-                                 int baseInstance, const GrBuffer* vertexBuffer, int vertexCount,
+    virtual void onBindBuffers(const GrBuffer* indexBuffer, const GrBuffer* instanceBuffer,
+                               const GrBuffer* vertexBuffer, GrPrimitiveRestart) = 0;
+    virtual void onDraw(int vertexCount, int baseVertex) = 0;
+    virtual void onDrawIndexed(int indexCount, int baseIndex, uint16_t minIndexValue,
+                               uint16_t maxIndexValue, int baseVertex) = 0;
+    virtual void onDrawInstanced(int instanceCount, int baseInstance, int vertexCount,
                                  int baseVertex) = 0;
-    virtual void onDrawIndexedInstanced(const GrBuffer* indexBuffer, int indexCount, int baseIndex,
-                                        GrPrimitiveRestart, const GrBuffer* instanceBuffer,
-                                        int instanceCount, int baseInstance,
-                                        const GrBuffer* vertexBuffer, int baseVertex) = 0;
+    virtual void onDrawIndexedInstanced(int indexCount, int baseIndex, int instanceCount,
+                                        int baseInstance, int baseVertex) = 0;
     virtual void onClear(const GrFixedClip&, const SkPMColor4f&) = 0;
     virtual void onClearStencilClip(const GrFixedClip&, bool insideStencilMask) = 0;
     virtual void onExecuteDrawable(std::unique_ptr<SkDrawable::GpuDrawHandler>) {}
@@ -165,8 +169,9 @@ class GrOpsRenderPass {
 
     DynamicStateStatus fScissorStatus = DynamicStateStatus::kDisabled;
     DynamicStateStatus fTextureBindingStatus = DynamicStateStatus::kDisabled;
-    bool fHasVertexAttributes = false;
-    bool fHasInstanceAttributes = false;
+    bool fHasIndexBuffer = false;
+    DynamicStateStatus fInstanceBufferStatus = DynamicStateStatus::kDisabled;
+    DynamicStateStatus fVertexBufferStatus = DynamicStateStatus::kDisabled;
 #endif
 
     typedef GrOpsRenderPass INHERITED;