Add ES 3.0 fallback for instanced rendering

src/gpu/instanced/GLInstancedRendering.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GLInstancedRendering.h"
 
 #include "GrResourceProvider.h"
@@ skipping 16 matching lines @@
     int fGLDrawCmdsIdx;
 
     friend class GLInstancedRendering;
 
     typedef Batch INHERITED;
 };
 
 GrCaps::InstancedSupport GLInstancedRendering::CheckSupport(const GrGLCaps& glCaps) {
     // This method is only intended to be used for initializing fInstancedSupport in the caps.
     SkASSERT(GrCaps::InstancedSupport::kNone == glCaps.instancedSupport());
-    if (!glCaps.vertexArrayObjectSupport() || !glCaps.drawIndirectSupport()) {
+    if (!glCaps.vertexArrayObjectSupport() ||
+        (!glCaps.drawIndirectSupport() && !glCaps.drawInstancedSupport())) {
         return GrCaps::InstancedSupport::kNone;
     }
     return InstanceProcessor::CheckSupport(*glCaps.glslCaps(), glCaps);
 }
 
 GLInstancedRendering::GLInstancedRendering(GrGLGpu* gpu)
     : INHERITED(gpu),
       fVertexArrayID(0),
       fGLDrawCmdsInfo(0),
       fInstanceAttribsBufferUniqueId(SK_InvalidUniqueID) {
@@ skipping 63 matching lines @@
     fInstanceBuffer.reset(
         rp->createBuffer(sizeof(Instance) * numGLInstances, kVertex_GrBufferType,
                          kDynamic_GrAccessPattern,
                          GrResourceProvider::kNoPendingIO_Flag |
                          GrResourceProvider::kRequireGpuMemory_Flag));
     if (!fInstanceBuffer) {
         return;
     }
 
     SkASSERT(!fDrawIndirectBuffer);
-    fDrawIndirectBuffer.reset(
-        rp->createBuffer(sizeof(GrGLDrawElementsIndirectCommand) * numGLDrawCmds,
-                         kDrawIndirect_GrBufferType, kDynamic_GrAccessPattern,
-                         GrResourceProvider::kNoPendingIO_Flag |
-                         GrResourceProvider::kRequireGpuMemory_Flag));
-    if (!fDrawIndirectBuffer) {
-        return;
+    if (this->glGpu()->glCaps().drawIndirectSupport()) {
+        fDrawIndirectBuffer.reset(
+            rp->createBuffer(sizeof(GrGLDrawElementsIndirectCommand) * numGLDrawCmds,
+                             kDrawIndirect_GrBufferType, kDynamic_GrAccessPattern,
+                             GrResourceProvider::kNoPendingIO_Flag |
+                             GrResourceProvider::kRequireGpuMemory_Flag));
+        if (!fDrawIndirectBuffer) {
+            return;
+        }
     }
 
     Instance* glMappedInstances = static_cast<Instance*>(fInstanceBuffer->map());
+    SkASSERT(glMappedInstances);
     int glInstancesIdx = 0;
 
-    auto* glMappedCmds = static_cast<GrGLDrawElementsIndirectCommand*>(fDrawIndirectBuffer->map());
+    GrGLDrawElementsIndirectCommand* glMappedCmds = nullptr;
     int glDrawCmdsIdx = 0;
+    if (fDrawIndirectBuffer) {
+        glMappedCmds = static_cast<GrGLDrawElementsIndirectCommand*>(fDrawIndirectBuffer->map());
+        SkASSERT(glMappedCmds);
+    }
 
     bool baseInstanceSupport = this->glGpu()->glCaps().baseInstanceSupport();
+    SkASSERT(!baseInstanceSupport || fDrawIndirectBuffer);
 
+    SkASSERT(!fGLDrawCmdsInfo);
     if (GR_GL_LOG_INSTANCED_BATCHES || !baseInstanceSupport) {
         fGLDrawCmdsInfo.reset(numGLDrawCmds);
     }
 
     // Generate the instance and draw-indirect buffer contents based on the tracked batches.
     iter.init(this->trackedBatches(), BatchList::Iter::kHead_IterStart);
     while (Batch* b = iter.get()) {
         GLBatch* batch = static_cast<GLBatch*>(b);
         iter.next();
 
         batch->fEmulatedBaseInstance = baseInstanceSupport ? 0 : glInstancesIdx;
         batch->fGLDrawCmdsIdx = glDrawCmdsIdx;
 
         const Batch::Draw* draw = batch->fHeadDraw;
         SkASSERT(draw);
         do {
             int instanceCount = 0;
             IndexRange geometry = draw->fGeometry;
             SkASSERT(!geometry.isEmpty());
 
             do {
                 glMappedInstances[glInstancesIdx + instanceCount++] = draw->fInstance;
                 draw = draw->fNext;
             } while (draw && draw->fGeometry == geometry);
 
-            GrGLDrawElementsIndirectCommand& glCmd = glMappedCmds[glDrawCmdsIdx];
-            glCmd.fCount = geometry.fCount;
-            glCmd.fInstanceCount = instanceCount;
-            glCmd.fFirstIndex = geometry.fStart;
-            glCmd.fBaseVertex = 0;
-            glCmd.fBaseInstance = baseInstanceSupport ? glInstancesIdx : 0;
+            if (fDrawIndirectBuffer) {
+                GrGLDrawElementsIndirectCommand& glCmd = glMappedCmds[glDrawCmdsIdx];
+                glCmd.fCount = geometry.fCount;
+                glCmd.fInstanceCount = instanceCount;
+                glCmd.fFirstIndex = geometry.fStart;
+                glCmd.fBaseVertex = 0;
+                glCmd.fBaseInstance = baseInstanceSupport ? glInstancesIdx : 0;
+            }
 
             if (GR_GL_LOG_INSTANCED_BATCHES || !baseInstanceSupport) {
-                fGLDrawCmdsInfo[glDrawCmdsIdx].fInstanceCount = instanceCount;
-#if GR_GL_LOG_INSTANCED_BATCHES
-                fGLDrawCmdsInfo[glDrawCmdsIdx].fGeometry = geometry;
-#endif
+                GLDrawCmdInfo& cmdInfo = fGLDrawCmdsInfo[glDrawCmdsIdx];
+                cmdInfo.fGeometry = geometry;
+                cmdInfo.fInstanceCount = instanceCount;
             }
 
             glInstancesIdx += instanceCount;
             ++glDrawCmdsIdx;
         } while (draw);
     }
 
     SkASSERT(glDrawCmdsIdx == numGLDrawCmds);
-    fDrawIndirectBuffer->unmap();
+    if (fDrawIndirectBuffer) {
+        fDrawIndirectBuffer->unmap();
+    }
 
     SkASSERT(glInstancesIdx == numGLInstances);
     fInstanceBuffer->unmap();
 }
 
 void GLInstancedRendering::onDraw(const GrPipeline& pipeline, const InstanceProcessor& instProc,
                                   const Batch* baseBatch) {
-    if (!fDrawIndirectBuffer) {
+    if (!fDrawIndirectBuffer && !fGLDrawCmdsInfo) {
         return; // beginFlush was not successful.
     }
     if (!this->glGpu()->flushGLState(pipeline, instProc)) {
         return;
     }
 
-    this->glGpu()->bindBuffer(kDrawIndirect_GrBufferType, fDrawIndirectBuffer.get());
+    if (fDrawIndirectBuffer) {
+        this->glGpu()->bindBuffer(kDrawIndirect_GrBufferType, fDrawIndirectBuffer.get());
+    }
 
     const GrGLCaps& glCaps = this->glGpu()->glCaps();
     const GLBatch* batch = static_cast<const GLBatch*>(baseBatch);
     int numCommands = batch->numGLCommands();
 
 #if GR_GL_LOG_INSTANCED_BATCHES
     SkASSERT(fGLDrawCmdsInfo);
     SkDebugf("Instanced batch: [");
     for (int i = 0; i < numCommands; ++i) {
         int glCmdIdx = batch->fGLDrawCmdsIdx + i;
         SkDebugf("%s%i * %s", (i ? ",  " : ""), fGLDrawCmdsInfo[glCmdIdx].fInstanceCount,
                  InstanceProcessor::GetNameOfIndexRange(fGLDrawCmdsInfo[glCmdIdx].fGeometry));
     }
     SkDebugf("]\n");
 #else
     SkASSERT(SkToBool(fGLDrawCmdsInfo) == !glCaps.baseInstanceSupport());
 #endif
 
-    if (1 == numCommands || !glCaps.baseInstanceSupport() || !glCaps.multiDrawIndirectSupport()) {
-        int emulatedBaseInstance = batch->fEmulatedBaseInstance;
-        for (int i = 0; i < numCommands; ++i) {
-            int glCmdIdx = batch->fGLDrawCmdsIdx + i;
-            this->flushInstanceAttribs(emulatedBaseInstance);
-            GL_CALL(DrawElementsIndirect(GR_GL_TRIANGLES, GR_GL_UNSIGNED_BYTE,
-                                         (GrGLDrawElementsIndirectCommand*) nullptr + glCmdIdx));
-            if (!glCaps.baseInstanceSupport()) {
-                emulatedBaseInstance += fGLDrawCmdsInfo[glCmdIdx].fInstanceCount;
-            }
-        }
-    } else {
+    if (numCommands > 1 && glCaps.multiDrawIndirectSupport() && glCaps.baseInstanceSupport()) {
+        SkASSERT(fDrawIndirectBuffer);
         int glCmdsIdx = batch->fGLDrawCmdsIdx;
         this->flushInstanceAttribs(batch->fEmulatedBaseInstance);
         GL_CALL(MultiDrawElementsIndirect(GR_GL_TRIANGLES, GR_GL_UNSIGNED_BYTE,
                                           (GrGLDrawElementsIndirectCommand*) nullptr + glCmdsIdx,
                                           numCommands, 0));
+        return;
+    }
+
+    int emulatedBaseInstance = batch->fEmulatedBaseInstance;
+    for (int i = 0; i < numCommands; ++i) {
+        int glCmdIdx = batch->fGLDrawCmdsIdx + i;
+        const GLDrawCmdInfo& cmdInfo = fGLDrawCmdsInfo[glCmdIdx];
+        this->flushInstanceAttribs(emulatedBaseInstance);
+        if (fDrawIndirectBuffer) {
+            GL_CALL(DrawElementsIndirect(GR_GL_TRIANGLES, GR_GL_UNSIGNED_BYTE,
+                                         (GrGLDrawElementsIndirectCommand*) nullptr + glCmdIdx));
+        } else {
+            GL_CALL(DrawElementsInstanced(GR_GL_TRIANGLES, cmdInfo.fGeometry.fCount,
+                                          GR_GL_UNSIGNED_BYTE,
+                                          (GrGLubyte*) nullptr + cmdInfo.fGeometry.fStart,
+                                          cmdInfo.fInstanceCount));
+        }
+        if (!glCaps.baseInstanceSupport()) {
+            emulatedBaseInstance += cmdInfo.fInstanceCount;
+        }
     }
 }
 
 void GLInstancedRendering::flushInstanceAttribs(int baseInstance) {
     SkASSERT(fVertexArrayID);
     this->glGpu()->bindVertexArray(fVertexArrayID);
 
     SkASSERT(fInstanceBuffer);
     if (fInstanceAttribsBufferUniqueId != fInstanceBuffer->getUniqueID() ||
         fInstanceAttribsBaseInstance != baseInstance) {
@@ skipping 45 matching lines @@
         GL_CALL(DeleteVertexArrays(1, &fVertexArrayID));
         this->glGpu()->notifyVertexArrayDelete(fVertexArrayID);
     }
     fVertexArrayID = 0;
     fInstanceBuffer.reset();
     fDrawIndirectBuffer.reset();
     fInstanceAttribsBufferUniqueId = SK_InvalidUniqueID;
 }
 
 }