Revert of Begin instanced rendering for simple shapes

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"
-#include "gl/GrGLGpu.h"
-#include "instanced/InstanceProcessor.h"
-
-#define GL_CALL(X) GR_GL_CALL(this->glGpu()->glInterface(), X)
-
-namespace gr_instanced {
-
-class GLInstancedRendering::GLBatch : public InstancedRendering::Batch {
-public:
-    DEFINE_BATCH_CLASS_ID
-
-    GLBatch(GLInstancedRendering* instRendering) : INHERITED(ClassID(), instRendering) {}
-    int numGLCommands() const { return 1 + fNumChangesInGeometry; }
-
-private:
-    int fEmulatedBaseInstance;
-    int fGLDrawCmdsIdx;
-
-    friend class GLInstancedRendering;
-
-    typedef Batch INHERITED;
-};
-
-GLInstancedRendering* GLInstancedRendering::CreateIfSupported(GrGLGpu* gpu) {
-#ifndef SK_BUILD_FOR_MAC
-    // Only whitelisting on Mac for now. Once we've been able to work through the various issues on
-    // other platforms we can enable more generally.
-    return nullptr;
-#endif
-    const GrGLCaps& glCaps = gpu->glCaps();
-    AntialiasMode lastSupportedAAMode;
-    if (!glCaps.vertexArrayObjectSupport() ||
-        !glCaps.drawIndirectSupport() ||
-        !InstanceProcessor::IsSupported(*glCaps.glslCaps(), glCaps, &lastSupportedAAMode)) {
-        return nullptr;
-    }
-    return new GLInstancedRendering(gpu, lastSupportedAAMode);
-}
-
-GLInstancedRendering::GLInstancedRendering(GrGLGpu* gpu, AntialiasMode lastSupportedAAMode)
-    : INHERITED(gpu, lastSupportedAAMode, gpu->glCaps().canDrawIndirectToFloat()),
-      fVertexArrayID(0),
-      fGLDrawCmdsInfo(0),
-      fInstanceAttribsBufferUniqueId(SK_InvalidUniqueID) {
-}
-
-GLInstancedRendering::~GLInstancedRendering() {
-    if (fVertexArrayID) {
-        GL_CALL(DeleteVertexArrays(1, &fVertexArrayID));
-        this->glGpu()->notifyVertexArrayDelete(fVertexArrayID);
-    }
-}
-
-inline GrGLGpu* GLInstancedRendering::glGpu() const {
-    return static_cast<GrGLGpu*>(this->gpu());
-}
-
-InstancedRendering::Batch* GLInstancedRendering::createBatch() {
-    return new GLBatch(this);
-}
-
-void GLInstancedRendering::onBeginFlush(GrResourceProvider* rp) {
-    // Count what there is to draw.
-    BatchList::Iter iter;
-    iter.init(this->trackedBatches(), BatchList::Iter::kHead_IterStart);
-    int numGLInstances = 0;
-    int numGLDrawCmds = 0;
-    while (Batch* b = iter.get()) {
-        GLBatch* batch = static_cast<GLBatch*>(b);
-        iter.next();
-
-        numGLInstances += batch->fNumDraws;
-        numGLDrawCmds += batch->numGLCommands();
-    }
-    if (!numGLDrawCmds) {
-        return;
-    }
-    SkASSERT(numGLInstances);
-
-    // Lazily create a vertex array object.
-    if (!fVertexArrayID) {
-        GL_CALL(GenVertexArrays(1, &fVertexArrayID));
-        if (!fVertexArrayID) {
-            return;
-        }
-        this->glGpu()->bindVertexArray(fVertexArrayID);
-
-        // Attach our index buffer to the vertex array.
-        GL_CALL(BindBuffer(GR_GL_ELEMENT_ARRAY_BUFFER,
-                           static_cast<const GrGLBuffer*>(this->indexBuffer())->bufferID()));
-
-        // Set up the non-instanced attribs.
-        this->glGpu()->bindBuffer(kVertex_GrBufferType,
-                                  static_cast<const GrGLBuffer*>(this->vertexBuffer()));
-        GL_CALL(EnableVertexAttribArray((int)Attrib::kShapeCoords));
-        GL_CALL(VertexAttribPointer((int)Attrib::kShapeCoords, 2, GR_GL_FLOAT, GR_GL_FALSE,
-                                    sizeof(ShapeVertex), (void*) offsetof(ShapeVertex, fX)));
-        GL_CALL(EnableVertexAttribArray((int)Attrib::kVertexAttrs));
-        GL_CALL(VertexAttribIPointer((int)Attrib::kVertexAttrs, 1, GR_GL_INT, sizeof(ShapeVertex),
-                                     (void*) offsetof(ShapeVertex, fAttrs)));
-
-        SkASSERT(SK_InvalidUniqueID == fInstanceAttribsBufferUniqueId);
-    }
-
-    // Create and map instance and draw-indirect buffers.
-    SkASSERT(!fInstanceBuffer);
-    fInstanceBuffer.reset(static_cast<GrGLBuffer*>(
-        rp->createBuffer(sizeof(Instance) * numGLInstances, kVertex_GrBufferType,
-                         kDynamic_GrAccessPattern, GrResourceProvider::kNoPendingIO_Flag)));
-    if (!fInstanceBuffer) {
-        return;
-    }
-
-    SkASSERT(!fDrawIndirectBuffer);
-    fDrawIndirectBuffer.reset(static_cast<GrGLBuffer*>(
-        rp->createBuffer(sizeof(GrGLDrawElementsIndirectCommand) * numGLDrawCmds,
-                         kDrawIndirect_GrBufferType, kDynamic_GrAccessPattern,
-                         GrResourceProvider::kNoPendingIO_Flag)));
-    if (!fDrawIndirectBuffer) {
-        return;
-    }
-
-    Instance* glMappedInstances = static_cast<Instance*>(fInstanceBuffer->map());
-    int glInstancesIdx = 0;
-
-    auto* glMappedCmds = static_cast<GrGLDrawElementsIndirectCommand*>(fDrawIndirectBuffer->map());
-    int glDrawCmdsIdx = 0;
-
-    bool baseInstanceSupport = this->glGpu()->glCaps().baseInstanceSupport();
-
-    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 (GR_GL_LOG_INSTANCED_BATCHES || !baseInstanceSupport) {
-                fGLDrawCmdsInfo[glDrawCmdsIdx].fInstanceCount = instanceCount;
-#if GR_GL_LOG_INSTANCED_BATCHES
-                fGLDrawCmdsInfo[glDrawCmdsIdx].fGeometry = geometry;
-#endif
-            }
-
-            glInstancesIdx += instanceCount;
-            ++glDrawCmdsIdx;
-        } while (draw);
-    }
-
-    SkASSERT(glDrawCmdsIdx == numGLDrawCmds);
-    fDrawIndirectBuffer->unmap();
-
-    SkASSERT(glInstancesIdx == numGLInstances);
-    fInstanceBuffer->unmap();
-}
-
-void GLInstancedRendering::onDraw(const GrPipeline& pipeline, const InstanceProcessor& instProc,
-                                  const Batch* baseBatch) {
-    if (!fDrawIndirectBuffer) {
-        return; // beginFlush was not successful.
-    }
-    if (!this->glGpu()->flushGLState(pipeline, instProc)) {
-        return;
-    }
-
-    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 {
-        int glCmdsIdx = batch->fGLDrawCmdsIdx;
-        this->flushInstanceAttribs(batch->fEmulatedBaseInstance);
-        GL_CALL(MultiDrawElementsIndirect(GR_GL_TRIANGLES, GR_GL_UNSIGNED_BYTE,
-                                          (GrGLDrawElementsIndirectCommand*) nullptr + glCmdsIdx,
-                                          numCommands, 0));
-    }
-}
-
-void GLInstancedRendering::flushInstanceAttribs(int baseInstance) {
-    SkASSERT(fVertexArrayID);
-    this->glGpu()->bindVertexArray(fVertexArrayID);
-
-    SkASSERT(fInstanceBuffer);
-    if (fInstanceAttribsBufferUniqueId != fInstanceBuffer->getUniqueID() ||
-        fInstanceAttribsBaseInstance != baseInstance) {
-        Instance* offsetInBuffer = (Instance*) nullptr + baseInstance;
-
-        this->glGpu()->bindBuffer(kVertex_GrBufferType, fInstanceBuffer.get());
-
-        // Info attrib.
-        GL_CALL(EnableVertexAttribArray((int)Attrib::kInstanceInfo));
-        GL_CALL(VertexAttribIPointer((int)Attrib::kInstanceInfo, 1, GR_GL_UNSIGNED_INT,
-                                     sizeof(Instance), &offsetInBuffer->fInfo));
-        GL_CALL(VertexAttribDivisor((int)Attrib::kInstanceInfo, 1));
-
-        // Shape matrix attrib.
-        GL_CALL(EnableVertexAttribArray((int)Attrib::kShapeMatrixX));
-        GL_CALL(EnableVertexAttribArray((int)Attrib::kShapeMatrixY));
-        GL_CALL(VertexAttribPointer((int)Attrib::kShapeMatrixX, 3, GR_GL_FLOAT, GR_GL_FALSE,
-                                    sizeof(Instance), &offsetInBuffer->fShapeMatrix2x3[0]));
-        GL_CALL(VertexAttribPointer((int)Attrib::kShapeMatrixY, 3, GR_GL_FLOAT, GR_GL_FALSE,
-                                    sizeof(Instance), &offsetInBuffer->fShapeMatrix2x3[3]));
-        GL_CALL(VertexAttribDivisor((int)Attrib::kShapeMatrixX, 1));
-        GL_CALL(VertexAttribDivisor((int)Attrib::kShapeMatrixY, 1));
-
-        // Color attrib.
-        GL_CALL(EnableVertexAttribArray((int)Attrib::kColor));
-        GL_CALL(VertexAttribPointer((int)Attrib::kColor, 4, GR_GL_UNSIGNED_BYTE, GR_GL_TRUE,
-                                    sizeof(Instance), &offsetInBuffer->fColor));
-        GL_CALL(VertexAttribDivisor((int)Attrib::kColor, 1));
-
-        // Local rect attrib.
-        GL_CALL(EnableVertexAttribArray((int)Attrib::kLocalRect));
-        GL_CALL(VertexAttribPointer((int)Attrib::kLocalRect, 4, GR_GL_FLOAT, GR_GL_FALSE,
-                                    sizeof(Instance), &offsetInBuffer->fLocalRect));
-        GL_CALL(VertexAttribDivisor((int)Attrib::kLocalRect, 1));
-
-        fInstanceAttribsBufferUniqueId = fInstanceBuffer->getUniqueID();
-        fInstanceAttribsBaseInstance = baseInstance;
-    }
-}
-
-void GLInstancedRendering::onEndFlush() {
-    fInstanceBuffer.reset();
-    fDrawIndirectBuffer.reset();
-    fGLDrawCmdsInfo.reset(0);
-}
-
-void GLInstancedRendering::onResetGpuResources(ResetType resetType) {
-    if (fVertexArrayID && ResetType::kDestroy == resetType) {
-        GL_CALL(DeleteVertexArrays(1, &fVertexArrayID));
-        this->glGpu()->notifyVertexArrayDelete(fVertexArrayID);
-    }
-    fVertexArrayID = 0;
-    fInstanceBuffer.reset();
-    fDrawIndirectBuffer.reset();
-    fInstanceAttribsBufferUniqueId = SK_InvalidUniqueID;
-}
-
-}