Support texel and draw-indirect buffers in null GL contexts

src/gpu/gl/GrGLCreateNullInterface.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "gl/GrGLInterface.h"
 #include "GrGLTestInterface.h"
@@ skipping 95 matching lines @@
     // Index of the first entry of fBuffers in the free list. Free slots in fBuffers are indices to
     // the next free slot. The last free slot has a value of kFreeListEnd.
     intptr_t                fFreeListHead;
     SkTDArray<BufferObj*>   fBuffers;
 };
 
 /** Null interface implementation */
 class NullInterface : public GrGLTestInterface {
 public:
     NullInterface(bool enableNVPR)
-        : fCurrArrayBuffer(0)
-        , fCurrElementArrayBuffer(0)
-        , fCurrPixelPackBuffer(0)
-        , fCurrPixelUnpackBuffer(0)
-        , fCurrProgramID(0)
+        : fCurrProgramID(0)
         , fCurrShaderID(0)
         , fCurrGenericID(0)
         , fCurrUniformLocation(0)
         , fCurrPathID(0) {
+        memset(fBoundBuffers, 0, sizeof(fBoundBuffers));
         fExtensions.push_back("GL_ARB_framebuffer_object");
         fExtensions.push_back("GL_ARB_blend_func_extended");
         fExtensions.push_back("GL_ARB_timer_query");
         fExtensions.push_back("GL_ARB_draw_buffers");
         fExtensions.push_back("GL_ARB_occlusion_query");
         fExtensions.push_back("GL_EXT_stencil_wrap");
         if (enableNVPR) {
             fExtensions.push_back("GL_NV_path_rendering");
             fExtensions.push_back("GL_ARB_program_interface_query");
         }
         fExtensions.push_back(nullptr);
 
         this->init(kGL_GrGLStandard);
     }
 
     GrGLenum checkFramebufferStatus(GrGLenum target) override {
         return GR_GL_FRAMEBUFFER_COMPLETE;
     }
 
     GrGLvoid genBuffers(GrGLsizei n, GrGLuint* ids) override {
         for (int i = 0; i < n; ++i) {
             BufferObj* buffer = fBufferManager.create();
             ids[i] = buffer->id();
         }
     }
 
     GrGLvoid bufferData(GrGLenum target, GrGLsizeiptr size, const GrGLvoid* data,
                         GrGLenum usage) override {
-        GrGLuint id = 0;
-
-        switch (target) {
-            case GR_GL_ARRAY_BUFFER:
-                id = fCurrArrayBuffer;
-                break;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:
-                id = fCurrElementArrayBuffer;
-                break;
-            case GR_GL_PIXEL_PACK_BUFFER:
-                id = fCurrPixelPackBuffer;
-                break;
-            case GR_GL_PIXEL_UNPACK_BUFFER:
-                id = fCurrPixelUnpackBuffer;
-                break;
-            default:
-                SkFAIL("Unexpected target to nullGLBufferData");
-                break;
-        }
-
+        GrGLuint id = fBoundBuffers[GetBufferIndex(target)];
         if (id > 0) {
             BufferObj* buffer = fBufferManager.lookUp(id);
             buffer->allocate(size, (const GrGLchar*) data);
         }
     }
 
     GrGLuint createProgram() override {
         return ++fCurrProgramID;
     }
 
     GrGLuint createShader(GrGLenum type) override {
         return ++fCurrShaderID;
     }
 
     GrGLvoid bindBuffer(GrGLenum target, GrGLuint buffer) override {
-        switch (target) {
-            case GR_GL_ARRAY_BUFFER:
-                fCurrArrayBuffer = buffer;
-                break;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:
-                fCurrElementArrayBuffer = buffer;
-                break;
-            case GR_GL_PIXEL_PACK_BUFFER:
-                fCurrPixelPackBuffer = buffer;
-                break;
-            case GR_GL_PIXEL_UNPACK_BUFFER:
-                fCurrPixelUnpackBuffer = buffer;
-                break;
-        }
+        fBoundBuffers[GetBufferIndex(target)] = buffer;
     }
 
    // deleting a bound buffer has the side effect of binding 0
-    GrGLvoid deleteBuffers(GrGLsizei n, const GrGLuint* ids) override {
+   GrGLvoid deleteBuffers(GrGLsizei n, const GrGLuint* ids) override {
+        // First potentially unbind the buffers.
+        for (int buffIdx = 0; buffIdx < kNumBufferTargets; ++buffIdx) {
+            if (!fBoundBuffers[buffIdx]) {
+                continue;
+            }
+            for (int i = 0; i < n; ++i) {
+                if (ids[i] == fBoundBuffers[buffIdx]) {
+                    fBoundBuffers[buffIdx] = 0;
+                    break;
+                }
+            }
+        }
+
+        // Then actually "delete" the buffers.
         for (int i = 0; i < n; ++i) {
-            if (ids[i] == fCurrArrayBuffer) {
-                fCurrArrayBuffer = 0;
-            }
-            if (ids[i] == fCurrElementArrayBuffer) {
-                fCurrElementArrayBuffer = 0;
-            }
-            if (ids[i] == fCurrPixelPackBuffer) {
-                fCurrPixelPackBuffer = 0;
-            }
-            if (ids[i] == fCurrPixelUnpackBuffer) {
-                fCurrPixelUnpackBuffer = 0;
-            }
-
             if (ids[i] > 0) {
                 BufferObj* buffer = fBufferManager.lookUp(ids[i]);
                 fBufferManager.free(buffer);
             }
         }
     }
 
     GrGLvoid genFramebuffers(GrGLsizei n, GrGLuint *framebuffers) override {
         this->genGenericIds(n, framebuffers);
     }
@@ skipping 170 matching lines @@
                 return nullptr;
         }
     }
 
     GrGLint getUniformLocation(GrGLuint program, const char* name) override {
         return ++fCurrUniformLocation;
     }
 
     GrGLvoid* mapBufferRange(GrGLenum target, GrGLintptr offset, GrGLsizeiptr length,
                              GrGLbitfield access) override {
-        GrGLuint id = 0;
-        switch (target) {
-            case GR_GL_ARRAY_BUFFER:
-                id = fCurrArrayBuffer;
-                break;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:
-                id = fCurrElementArrayBuffer;
-                break;
-            case GR_GL_PIXEL_PACK_BUFFER:
-                id = fCurrPixelPackBuffer;
-                break;
-            case GR_GL_PIXEL_UNPACK_BUFFER:
-                id = fCurrPixelUnpackBuffer;
-                break;
-        }
-
+        GrGLuint id = fBoundBuffers[GetBufferIndex(target)];
         if (id > 0) {
             // We just ignore the offset and length here.
             BufferObj* buffer = fBufferManager.lookUp(id);
             SkASSERT(!buffer->mapped());
             buffer->setMapped(true);
             return buffer->dataPtr();
         }
         return nullptr;
     }
 
     GrGLvoid* mapBuffer(GrGLenum target, GrGLenum access) override {
-        GrGLuint id = 0;
-        switch (target) {
-            case GR_GL_ARRAY_BUFFER:
-                id = fCurrArrayBuffer;
-                break;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:
-                id = fCurrElementArrayBuffer;
-                break;
-            case GR_GL_PIXEL_PACK_BUFFER:
-                id = fCurrPixelPackBuffer;
-                break;
-            case GR_GL_PIXEL_UNPACK_BUFFER:
-                id = fCurrPixelUnpackBuffer;
-                break;
-        }
-
+        GrGLuint id = fBoundBuffers[GetBufferIndex(target)];
         if (id > 0) {
             BufferObj* buffer = fBufferManager.lookUp(id);
             SkASSERT(!buffer->mapped());
             buffer->setMapped(true);
             return buffer->dataPtr();
         }
 
         SkASSERT(false);
         return nullptr;            // no buffer bound to target
     }
 
     GrGLboolean unmapBuffer(GrGLenum target) override {
-        GrGLuint id = 0;
-        switch (target) {
-            case GR_GL_ARRAY_BUFFER:
-                id = fCurrArrayBuffer;
-                break;
-            case GR_GL_ELEMENT_ARRAY_BUFFER:
-                id = fCurrElementArrayBuffer;
-                break;
-            case GR_GL_PIXEL_PACK_BUFFER:
-                id = fCurrPixelPackBuffer;
-                break;
-            case GR_GL_PIXEL_UNPACK_BUFFER:
-                id = fCurrPixelUnpackBuffer;
-                break;
-        }
+        GrGLuint id = fBoundBuffers[GetBufferIndex(target)];
         if (id > 0) {
             BufferObj* buffer = fBufferManager.lookUp(id);
             SkASSERT(buffer->mapped());
             buffer->setMapped(false);
             return GR_GL_TRUE;
         }
 
         GrAlwaysAssert(false);
         return GR_GL_FALSE; // GR_GL_INVALID_OPERATION;
     }
 
     GrGLvoid getBufferParameteriv(GrGLenum target, GrGLenum pname, GrGLint* params) override {
         switch (pname) {
             case GR_GL_BUFFER_MAPPED: {
                 *params = GR_GL_FALSE;
-                GrGLuint id = 0;
-                switch (target) {
-                    case GR_GL_ARRAY_BUFFER:
-                        id = fCurrArrayBuffer;
-                        break;
-                    case GR_GL_ELEMENT_ARRAY_BUFFER:
-                        id = fCurrElementArrayBuffer;
-                        break;
-                    case GR_GL_PIXEL_PACK_BUFFER:
-                        id = fCurrPixelPackBuffer;
-                        break;
-                    case GR_GL_PIXEL_UNPACK_BUFFER:
-                        id = fCurrPixelUnpackBuffer;
-                        break;
-                }
+                GrGLuint id = fBoundBuffers[GetBufferIndex(target)];
                 if (id > 0) {
                     BufferObj* buffer = fBufferManager.lookUp(id);
                     if (buffer->mapped()) {
                         *params = GR_GL_TRUE;
                     }
                 }
                 break; }
             default:
                 SkFAIL("Unexpected pname to GetBufferParamateriv");
                 break;
         }
     };
 
     // NV_path_rendering
     GrGLuint genPaths(GrGLsizei range) override {
         return ++fCurrPathID;
     }
 
 
 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;
+            case GR_GL_PIXEL_PACK_BUFFER:      return 4;
+            case GR_GL_PIXEL_UNPACK_BUFFER:    return 5;
+        }
+    }
+    constexpr int static kNumBufferTargets = 6;
+
     BufferManager          fBufferManager;
-    GrGLuint               fCurrArrayBuffer;
-    GrGLuint               fCurrElementArrayBuffer;
-    GrGLuint               fCurrPixelPackBuffer;
-    GrGLuint               fCurrPixelUnpackBuffer;
+    GrGLuint               fBoundBuffers[kNumBufferTargets];
     GrGLuint               fCurrProgramID;
     GrGLuint               fCurrShaderID;
     GrGLuint               fCurrGenericID;
     GrGLuint               fCurrUniformLocation;
     GrGLuint               fCurrPathID;
     SkTArray<const char*>  fExtensions;
 
     // the OpenGLES 2.0 spec says this must be >= 128
     static const GrGLint kDefaultMaxVertexUniformVectors = 128;
 
@@ skipping 70 matching lines @@
                 break;
         }
     }
 
     typedef GrGLTestInterface INHERITED;
 };
 
 }  // anonymous namespace
 
 const GrGLInterface* GrGLCreateNullInterface(bool enableNVPR) { return new NullInterface(enableNVPR); }