Support texel and draw-indirect buffers in null GL contexts

tools/gpu/gl/debug/DebugGLTestContext.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "DebugGLTestContext.h"
 
@@ skipping 17 matching lines @@
 
 // Helper macro to make creating an object (where you need to get back a derived type) easier
 #define FIND(id, className, classEnum)                   \
     reinterpret_cast<className *>(this->findObject(id, classEnum))
 
 class DebugInterface : public GrGLTestInterface {
 public:
     DebugInterface()
         : fCurrGenericID(0)
         , fCurrTextureUnit(0)
-        , fArrayBuffer(nullptr)
-        , fElementArrayBuffer(nullptr)
         , fVertexArray(nullptr)
         , fPackRowLength(0)
         , fUnpackRowLength(0)
         , fPackAlignment(4)
         , fFrameBuffer(nullptr)
         , fRenderBuffer(nullptr)
         , fProgram(nullptr)
         , fAbandoned(false) {
         for (int i = 0; i < kDefaultMaxTextureUnits; ++i) {
             fTextureUnits[i] =
                 reinterpret_cast<GrTextureUnitObj*>(this->createObj(kTextureUnit_ObjTypes));
             fTextureUnits[i]->ref();
             fTextureUnits[i]->setNumber(i);
         }
+        memset(fBoundBuffers, 0, sizeof(fBoundBuffers));
         this->init(kGL_GrGLStandard);
     }
 
     ~DebugInterface() override {
         // unref & delete the texture units first so they don't show up on the leak report
         for (int i = 0; i < kDefaultMaxTextureUnits; ++i) {
             fTextureUnits[i]->unref();
             fTextureUnits[i]->deleteAction();
         }
         for (int i = 0; i < fObjects.count(); ++i) {
             delete fObjects[i];
         }
         fObjects.reset();
 
-        fArrayBuffer = nullptr;
-        fElementArrayBuffer = nullptr;
+        memset(fBoundBuffers, 0, sizeof(fBoundBuffers));
         fVertexArray = nullptr;
 
         this->report();
     }
 
     void abandon() const override { fAbandoned = true; }
 
     GrGLvoid activeTexture(GrGLenum texture) override {
         // Ganesh offsets the texture unit indices
         texture -= GR_GL_TEXTURE0;
@@ skipping 20 matching lines @@
 
         // a textureID of 0 is acceptable - it binds to the default texture target
         GrTextureObj *texture = FIND(textureID, GrTextureObj, kTexture_ObjTypes);
 
         this->setTexture(texture);
     }
 
     ////////////////////////////////////////////////////////////////////////////////
     GrGLvoid bufferData(GrGLenum target, GrGLsizeiptr size, const GrGLvoid* data,
                         GrGLenum usage) override {
-        GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
-                       GR_GL_ELEMENT_ARRAY_BUFFER == target);
         GrAlwaysAssert(size >= 0);
         GrAlwaysAssert(GR_GL_STREAM_DRAW == usage ||
                        GR_GL_STATIC_DRAW == usage ||
                        GR_GL_DYNAMIC_DRAW == usage);
 
-        GrBufferObj *buffer = nullptr;
-        switch (target) {
-            case GR_GL_ARRAY_BUFFER:
-                buffer = this->getArrayBuffer();
-                break;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:
-                buffer = this->getElementArrayBuffer();
-                break;
-            default:
-                SkFAIL("Unexpected target to glBufferData");
-                break;
-        }
-
+        GrBufferObj *buffer = fBoundBuffers[GetBufferIndex(target)];
         GrAlwaysAssert(buffer);
         GrAlwaysAssert(buffer->getBound());
 
         buffer->allocate(size, reinterpret_cast<const GrGLchar *>(data));
         buffer->setUsage(usage);
     }
 
 
     GrGLvoid pixelStorei(GrGLenum pname, GrGLint param) override {
 
@@ skipping 579 matching lines @@
         }
     }
 
     GrGLvoid bindVertexArray(GrGLuint id) override {
         GrVertexArrayObj* array = FIND(id, GrVertexArrayObj, kVertexArray_ObjTypes);
         GrAlwaysAssert((0 == id) || array);
         this->setVertexArray(array);
     }
 
     GrGLvoid bindBuffer(GrGLenum target, GrGLuint bufferID) override {
-        GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target || GR_GL_ELEMENT_ARRAY_BUFFER == target);
-
         GrBufferObj *buffer = FIND(bufferID, GrBufferObj, kBuffer_ObjTypes);
         // 0 is a permissible bufferID - it unbinds the current buffer
 
-        switch (target) {
-            case GR_GL_ARRAY_BUFFER:
-                this->setArrayBuffer(buffer);
-                break;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:
-                this->setElementArrayBuffer(buffer);
-                break;
-            default:
-                SkFAIL("Unexpected target to glBindBuffer");
-                break;
-        }
+        this->setBuffer(GetBufferIndex(target), buffer);
     }
 
     // deleting a bound buffer has the side effect of binding 0
     GrGLvoid deleteBuffers(GrGLsizei n, const GrGLuint* ids) override {
         // first potentially unbind the buffers
-        for (int i = 0; i < n; ++i) {
-
-            if (this->getArrayBuffer() &&
-                ids[i] == this->getArrayBuffer()->getID()) {
-                // this ID is the current array buffer
-                this->setArrayBuffer(nullptr);
+        for (int buffIdx = 0; buffIdx < kNumBufferTargets; ++buffIdx) {
+            GrBufferObj* buffer = fBoundBuffers[buffIdx];
+            if (!buffer) {
+                continue;
             }
-            if (this->getElementArrayBuffer() &&
-                ids[i] == this->getElementArrayBuffer()->getID()) {
-                // this ID is the current element array buffer
-                this->setElementArrayBuffer(nullptr);
+            for (int i = 0; i < n; ++i) {
+                if (ids[i] == buffer->getID()) {
+                    this->setBuffer(buffIdx, nullptr);
+                    break;
+                }
             }
         }
 
         // then actually "delete" the buffers
         for (int i = 0; i < n; ++i) {
             GrBufferObj *buffer = FIND(ids[i], GrBufferObj, kBuffer_ObjTypes);
             GrAlwaysAssert(buffer);
 
             GrAlwaysAssert(!buffer->getDeleted());
             buffer->deleteAction();
         }
     }
 
     // map a buffer to the caller's address space
     GrGLvoid* mapBufferRange(GrGLenum target, GrGLintptr offset, GrGLsizeiptr length,
                              GrGLbitfield access) override {
-        GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
-                       GR_GL_ELEMENT_ARRAY_BUFFER == target);
-
         // We only expect read access and we expect that the buffer or range is always invalidated.
         GrAlwaysAssert(!SkToBool(GR_GL_MAP_READ_BIT & access));
         GrAlwaysAssert((GR_GL_MAP_INVALIDATE_BUFFER_BIT | GR_GL_MAP_INVALIDATE_RANGE_BIT) & access);
 
-        GrBufferObj *buffer = nullptr;
-        switch (target) {
-            case GR_GL_ARRAY_BUFFER:
-                buffer = this->getArrayBuffer();
-                break;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:
-                buffer = this->getElementArrayBuffer();
-                break;
-            default:
-                SkFAIL("Unexpected target to glMapBufferRange");
-                break;
-        }
-
+        GrBufferObj *buffer = fBoundBuffers[GetBufferIndex(target)];
         if (buffer) {
             GrAlwaysAssert(offset >= 0 && offset + length <= buffer->getSize());
             GrAlwaysAssert(!buffer->getMapped());
             buffer->setMapped(offset, length);
             return buffer->getDataPtr() + offset;
         }
 
         GrAlwaysAssert(false);
         return nullptr;        // no buffer bound to the target
     }
 
     GrGLvoid* mapBuffer(GrGLenum target, GrGLenum access) override {
         GrAlwaysAssert(GR_GL_WRITE_ONLY == access);
-
-        GrBufferObj *buffer = nullptr;
-        switch (target) {
-            case GR_GL_ARRAY_BUFFER:
-                buffer = this->getArrayBuffer();
-                break;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:
-                buffer = this->getElementArrayBuffer();
-                break;
-            default:
-                SkFAIL("Unexpected target to glMapBuffer");
-                break;
-        }
-
+        GrBufferObj *buffer = fBoundBuffers[GetBufferIndex(target)];
         return this->mapBufferRange(target, 0, buffer->getSize(),
                                     GR_GL_MAP_WRITE_BIT | GR_GL_MAP_INVALIDATE_BUFFER_BIT);
     }
 
     // remove a buffer from the caller's address space
     // TODO: check if the "access" method from "glMapBuffer" was honored
     GrGLboolean unmapBuffer(GrGLenum target) override {
-        GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
-                       GR_GL_ELEMENT_ARRAY_BUFFER == target);
-
-        GrBufferObj *buffer = nullptr;
-        switch (target) {
-            case GR_GL_ARRAY_BUFFER:
-                buffer = this->getArrayBuffer();
-                break;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:
-                buffer = this->getElementArrayBuffer();
-                break;
-            default:
-                SkFAIL("Unexpected target to glUnmapBuffer");
-                break;
-        }
-
+        GrBufferObj *buffer = fBoundBuffers[GetBufferIndex(target)];
         if (buffer) {
             GrAlwaysAssert(buffer->getMapped());
             buffer->resetMapped();
             return GR_GL_TRUE;
         }
 
         GrAlwaysAssert(false);
         return GR_GL_FALSE; // GR_GL_INVALID_OPERATION;
     }
 
     GrGLvoid flushMappedBufferRange(GrGLenum target, GrGLintptr offset,
                                     GrGLsizeiptr length) override {
-        GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
-                       GR_GL_ELEMENT_ARRAY_BUFFER == target);
-
-        GrBufferObj *buffer = nullptr;
-        switch (target) {
-            case GR_GL_ARRAY_BUFFER:
-                buffer = this->getArrayBuffer();
-                break;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:
-                buffer = this->getElementArrayBuffer();
-                break;
-            default:
-                SkFAIL("Unexpected target to glUnmapBuffer");
-                break;
-        }
-
+        GrBufferObj *buffer = fBoundBuffers[GetBufferIndex(target)];
         if (buffer) {
             GrAlwaysAssert(buffer->getMapped());
             GrAlwaysAssert(offset >= 0 && (offset + length) <= buffer->getMappedLength());
         } else {
             GrAlwaysAssert(false);
         }
     }
 
     GrGLvoid getBufferParameteriv(GrGLenum target, GrGLenum value, GrGLint* params) override {
 
-        GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
-                       GR_GL_ELEMENT_ARRAY_BUFFER == target);
         GrAlwaysAssert(GR_GL_BUFFER_SIZE == value ||
                        GR_GL_BUFFER_USAGE == value);
 
-        GrBufferObj *buffer = nullptr;
-        switch (target) {
-            case GR_GL_ARRAY_BUFFER:
-                buffer = this->getArrayBuffer();
-                break;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:
-                buffer = this->getElementArrayBuffer();
-                break;
-        }
-
+        GrBufferObj *buffer = fBoundBuffers[GetBufferIndex(target)];
         GrAlwaysAssert(buffer);
 
         switch (value) {
             case GR_GL_BUFFER_MAPPED:
                 *params = GR_GL_FALSE;
                 if (buffer)
                     *params = buffer->getMapped() ? GR_GL_TRUE : GR_GL_FALSE;
                 break;
             case GR_GL_BUFFER_SIZE:
                 *params = 0;
                 if (buffer)
                     *params = SkToInt(buffer->getSize());
                 break;
             case GR_GL_BUFFER_USAGE:
                 *params = GR_GL_STATIC_DRAW;
                 if (buffer)
                     *params = buffer->getUsage();
                 break;
             default:
                 SkFAIL("Unexpected value to glGetBufferParamateriv");
                 break;
         }
     }
 
 private:
+    inline int static GetBufferIndex(GrGLenum glTarget) {
+        switch (glTarget) {
+            default:                           SkFAIL("Unexpected GL target to GetBufferIndex");
+            case GR_GL_ARRAY_BUFFER:           return 0;
+            case GR_GL_ELEMENT_ARRAY_BUFFER:   return 1;
+            case GR_GL_TEXTURE_BUFFER:         return 2;
+            case GR_GL_DRAW_INDIRECT_BUFFER:   return 3;
+        }
+    }
+    constexpr int static kNumBufferTargets = 4;
+
     // the OpenGLES 2.0 spec says this must be >= 128
     static const GrGLint kDefaultMaxVertexUniformVectors = 128;
 
     // the OpenGLES 2.0 spec says this must be >=16
     static const GrGLint kDefaultMaxFragmentUniformVectors = 16;
 
     // the OpenGLES 2.0 spec says this must be >= 8
     static const GrGLint kDefaultMaxVertexAttribs = 8;
 
     // the OpenGLES 2.0 spec says this must be >= 8
     static const GrGLint kDefaultMaxVaryingVectors = 8;
 
     // the OpenGLES 2.0 spec says this must be >= 2
     static const GrGLint kDefaultMaxTextureUnits = 8;
 
     static const char* kExtensions[];
 
     GrGLuint                    fCurrGenericID;
     GrGLuint                    fCurrTextureUnit;
     GrTextureUnitObj*           fTextureUnits[kDefaultMaxTextureUnits];
-    GrBufferObj*                fArrayBuffer;
-    GrBufferObj*                fElementArrayBuffer;
+    GrBufferObj*                fBoundBuffers[kNumBufferTargets];
     GrVertexArrayObj*           fVertexArray;
     GrGLint                     fPackRowLength;
     GrGLint                     fUnpackRowLength;
     GrGLint                     fPackAlignment;
     GrFrameBufferObj*           fFrameBuffer;
     GrRenderBufferObj*          fRenderBuffer;
     GrProgramObj*               fProgram;
     mutable bool                fAbandoned;
     // global store of all objects
     SkTArray<GrFakeRefObj *>    fObjects;
@@ skipping 108 matching lines @@
         }
         return nullptr;
     }
 
     GrTextureUnitObj* getTextureUnit(int unit) {
         GrAlwaysAssert(0 <= unit && kDefaultMaxTextureUnits > unit);
 
         return fTextureUnits[unit];
     }
 
-    void setArrayBuffer(GrBufferObj *arrayBuffer) {
-        if (fArrayBuffer) {
+    GrGLvoid setBuffer(int buffIdx, GrBufferObj* buffer) {
+        if (fBoundBuffers[buffIdx]) {
             // automatically break the binding of the old buffer
-            GrAlwaysAssert(fArrayBuffer->getBound());
-            fArrayBuffer->resetBound();
+            GrAlwaysAssert(fBoundBuffers[buffIdx]->getBound());
+            fBoundBuffers[buffIdx]->resetBound();
 
-            GrAlwaysAssert(!fArrayBuffer->getDeleted());
-            fArrayBuffer->unref();
+            GrAlwaysAssert(!fBoundBuffers[buffIdx]->getDeleted());
+            fBoundBuffers[buffIdx]->unref();
         }
 
-        fArrayBuffer = arrayBuffer;
+        if (buffer) {
+            GrAlwaysAssert(!buffer->getDeleted());
+            buffer->ref();
 
-        if (fArrayBuffer) {
-            GrAlwaysAssert(!fArrayBuffer->getDeleted());
-            fArrayBuffer->ref();
-
-            GrAlwaysAssert(!fArrayBuffer->getBound());
-            fArrayBuffer->setBound();
-        }
-    }
-
-    GrBufferObj* getArrayBuffer() { return fArrayBuffer; }
-    void setElementArrayBuffer(GrBufferObj *elementArrayBuffer) {
-        if (fElementArrayBuffer) {
-            // automatically break the binding of the old buffer
-            GrAlwaysAssert(fElementArrayBuffer->getBound());
-            fElementArrayBuffer->resetBound();
-
-            GrAlwaysAssert(!fElementArrayBuffer->getDeleted());
-            fElementArrayBuffer->unref();
+            GrAlwaysAssert(!buffer->getBound());
+            buffer->setBound();
         }
 
-        fElementArrayBuffer = elementArrayBuffer;
-
-        if (fElementArrayBuffer) {
-            GrAlwaysAssert(!fElementArrayBuffer->getDeleted());
-            fElementArrayBuffer->ref();
-
-            GrAlwaysAssert(!fElementArrayBuffer->getBound());
-            fElementArrayBuffer->setBound();
-        }
+        fBoundBuffers[buffIdx] = buffer;
     }
 
-    GrBufferObj *getElementArrayBuffer() { return fElementArrayBuffer; }
-
     void setVertexArray(GrVertexArrayObj* vertexArray) {
         if (vertexArray) {
             SkASSERT(!vertexArray->getDeleted());
         }
         SkRefCnt_SafeAssign(fVertexArray, vertexArray);
     }
 
     GrVertexArrayObj* getVertexArray() { return fVertexArray; }
 
     void setTexture(GrTextureObj *texture) {
@@ skipping 117 matching lines @@
 namespace sk_gpu_test {
 GLTestContext* CreateDebugGLTestContext() {
     GLTestContext* ctx = new DebugGLContext();
     if (ctx->isValid()) {
         return ctx;
     }
     delete ctx;
     return nullptr;
 }
 }