Add support to GrGLInterface for vertex array objects

src/gpu/gl/debug/GrGLCreateDebugInterface.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 "gl/GrGLInterface.h"
 #include "GrDebugGL.h"
 #include "GrShaderObj.h"
 #include "GrProgramObj.h"
 #include "GrBufferObj.h"
 #include "GrTextureUnitObj.h"
 #include "GrTextureObj.h"
 #include "GrFrameBufferObj.h"
 #include "GrRenderBufferObj.h"
+#include "GrVertexArrayObj.h"
 #include "SkFloatingPoint.h"
 #include "../GrGLNoOpInterface.h"
 
 namespace { // suppress no previous prototype warning
 
 ////////////////////////////////////////////////////////////////////////////////
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLActiveTexture(GrGLenum texture) {
 
     // Ganesh offsets the texture unit indices
     texture -= GR_GL_TEXTURE0;
@@ skipping 176 matching lines @@
 
      // a frameBufferID of 0 is acceptable - it binds to the default
      // frame buffer
      GrFrameBufferObj *frameBuffer = GR_FIND(frameBufferID,
                                              GrFrameBufferObj,
                                              GrDebugGL::kFrameBuffer_ObjTypes);
 
      GrDebugGL::getInstance()->setFrameBuffer(frameBuffer);
  }
 
- GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindRenderbuffer(GrGLenum target,
-                                                      GrGLuint renderBufferID) {
+ GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindRenderbuffer(GrGLenum target, GrGLuint renderBufferID) {
 
      GrAlwaysAssert(GR_GL_RENDERBUFFER == target);
 
      // a renderBufferID of 0 is acceptable - it unbinds the bound render buffer
      GrRenderBufferObj *renderBuffer = GR_FIND(renderBufferID,
                                                GrRenderBufferObj,
                                                GrDebugGL::kRenderBuffer_ObjTypes);
 
      GrDebugGL::getInstance()->setRenderBuffer(renderBuffer);
  }
 
- GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteTextures(GrGLsizei n,
-                                                    const GrGLuint* textures) {
+ GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteTextures(GrGLsizei n, const GrGLuint* textures) {
 
      // first potentially unbind the texture
      // TODO: move this into GrDebugGL as unBindTexture?
      for (unsigned int i = 0;
           i < GrDebugGL::getInstance()->getMaxTextureUnits();
           ++i) {
          GrTextureUnitObj *pTU = GrDebugGL::getInstance()->getTextureUnit(i);
 
          if (pTU->getTexture()) {
              for (int j = 0; j < n; ++j) {
@@ skipping 40 matching lines @@
          // OpenGL gives no guarantees if a texture is deleted while attached to
          // something other than the currently bound frame buffer
          GrAlwaysAssert(!buffer->getBound());
 
          GrAlwaysAssert(!buffer->getDeleted());
          buffer->deleteAction();
      }
 
  }
 
-
  GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteFramebuffers(GrGLsizei n,
                                                         const GrGLuint *frameBuffers) {
 
      // first potentially unbind the buffers
      if (GrDebugGL::getInstance()->getFrameBuffer()) {
          for (int i = 0; i < n; ++i) {
 
              if (frameBuffers[i] ==
                  GrDebugGL::getInstance()->getFrameBuffer()->getID()) {
                  // this ID is the current frame buffer - rebind to the default
@@ skipping 210 matching lines @@
                       GrGLuint* ids) {
 
    for (int i = 0; i < n; ++i) {
         GrFakeRefObj *obj = GrDebugGL::getInstance()->createObj(type);
         GrAlwaysAssert(obj);
         ids[i] = obj->getID();
     }
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenBuffers(GrGLsizei n, GrGLuint* ids) {
-
     debugGenObjs(GrDebugGL::kBuffer_ObjTypes, n, ids);
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenFramebuffers(GrGLsizei n,
                                                     GrGLuint* ids) {
-
     debugGenObjs(GrDebugGL::kFrameBuffer_ObjTypes, n, ids);
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenRenderbuffers(GrGLsizei n,
                                                      GrGLuint* ids) {
-
     debugGenObjs(GrDebugGL::kRenderBuffer_ObjTypes, n, ids);
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenTextures(GrGLsizei n, GrGLuint* ids) {
-
     debugGenObjs(GrDebugGL::kTexture_ObjTypes, n, ids);
 }
 
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindBuffer(GrGLenum target,
-                                               GrGLuint bufferID) {
+GrGLvoid GR_GL_FUNCTION_TYPE debugGLGenVertexArrays(GrGLsizei n, GrGLuint* ids) {
+    debugGenObjs(GrDebugGL::kVertexArray_ObjTypes, n, ids);
+}
 
-    GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
-                   GR_GL_ELEMENT_ARRAY_BUFFER == target);
+GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteVertexArrays(GrGLsizei n, const GrGLuint* ids) {
+    for (GrGLsizei i = 0; i < n; ++i) {
+        GrVertexArrayObj* array =
+            GR_FIND(ids[i], GrVertexArrayObj, GrDebugGL::kVertexArray_ObjTypes);
+        GrAlwaysAssert(array);
+
+        // Deleting the current vertex array binds object 0
+        if (GrDebugGL::getInstance()->getVertexArray() == array) {
+            GrDebugGL::getInstance()->setVertexArray(NULL);
+        }
+
+        if (array->getRefCount()) {
+            // someone is still using this vertex array so we can't delete it here
+            array->setMarkedForDeletion();
+        } else {
+            array->deleteAction();
+        }
+    }
+}
+
+GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindVertexArray(GrGLuint id) {
+    GrVertexArrayObj* array = GR_FIND(id, GrVertexArrayObj, GrDebugGL::kVertexArray_ObjTypes);
+    GrAlwaysAssert(array);
+    GrDebugGL::getInstance()->setVertexArray(array);
+}
+
+GrGLvoid GR_GL_FUNCTION_TYPE debugGLBindBuffer(GrGLenum target, GrGLuint bufferID) {
+    GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target || GR_GL_ELEMENT_ARRAY_BUFFER == target);
 
     GrBufferObj *buffer = GR_FIND(bufferID,
                                   GrBufferObj,
                                   GrDebugGL::kBuffer_ObjTypes);
     // 0 is a permissible bufferID - it unbinds the current buffer
 
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             GrDebugGL::getInstance()->setArrayBuffer(buffer);
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             GrDebugGL::getInstance()->setElementArrayBuffer(buffer);
             break;
         default:
             GrCrash("Unexpected target to glBindBuffer");
             break;
     }
 }
 
 // deleting a bound buffer has the side effect of binding 0
-GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteBuffers(GrGLsizei n,
-                                                  const GrGLuint* ids) {
+GrGLvoid GR_GL_FUNCTION_TYPE debugGLDeleteBuffers(GrGLsizei n, const GrGLuint* ids) {
     // first potentially unbind the buffers
     for (int i = 0; i < n; ++i) {
 
         if (GrDebugGL::getInstance()->getArrayBuffer() &&
             ids[i] == GrDebugGL::getInstance()->getArrayBuffer()->getID()) {
             // this ID is the current array buffer
             GrDebugGL::getInstance()->setArrayBuffer(NULL);
         }
         if (GrDebugGL::getInstance()->getElementArrayBuffer() &&
             ids[i] ==
                 GrDebugGL::getInstance()->getElementArrayBuffer()->getID()) {
             // this ID is the current element array buffer
             GrDebugGL::getInstance()->setElementArrayBuffer(NULL);
         }
     }
 
     // then actually "delete" the buffers
     for (int i = 0; i < n; ++i) {
         GrBufferObj *buffer = GR_FIND(ids[i],
                                       GrBufferObj,
                                       GrDebugGL::kBuffer_ObjTypes);
         GrAlwaysAssert(buffer);
 
         GrAlwaysAssert(!buffer->getDeleted());
         buffer->deleteAction();
     }
 }
 
 // map a buffer to the caller's address space
-GrGLvoid* GR_GL_FUNCTION_TYPE debugGLMapBuffer(GrGLenum target,
-                                               GrGLenum access) {
+GrGLvoid* GR_GL_FUNCTION_TYPE debugGLMapBuffer(GrGLenum target, GrGLenum access) {
 
     GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
                    GR_GL_ELEMENT_ARRAY_BUFFER == target);
     // GR_GL_READ_ONLY == access ||  || GR_GL_READ_WRIT == access);
     GrAlwaysAssert(GR_GL_WRITE_ONLY == access);
 
     GrBufferObj *buffer = NULL;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getArrayBuffer();
@@ skipping 150 matching lines @@
     GrGLInterface* interface = SkNEW(GrDebugGLInterface);
 
     interface->fBindingsExported = kDesktop_GrGLBinding;
     interface->fActiveTexture = debugGLActiveTexture;
     interface->fAttachShader = debugGLAttachShader;
     interface->fBeginQuery = debugGLBeginQuery;
     interface->fBindAttribLocation = debugGLBindAttribLocation;
     interface->fBindBuffer = debugGLBindBuffer;
     interface->fBindFragDataLocation = noOpGLBindFragDataLocation;
     interface->fBindTexture = debugGLBindTexture;
+    interface->fBindVertexArray = debugGLBindVertexArray;
     interface->fBlendColor = noOpGLBlendColor;
     interface->fBlendFunc = noOpGLBlendFunc;
     interface->fBufferData = debugGLBufferData;
     interface->fBufferSubData = noOpGLBufferSubData;
     interface->fClear = noOpGLClear;
     interface->fClearColor = noOpGLClearColor;
     interface->fClearStencil = noOpGLClearStencil;
     interface->fColorMask = noOpGLColorMask;
     interface->fCompileShader = noOpGLCompileShader;
     interface->fCompressedTexImage2D = noOpGLCompressedTexImage2D;
     interface->fCreateProgram = debugGLCreateProgram;
     interface->fCreateShader = debugGLCreateShader;
     interface->fCullFace = noOpGLCullFace;
     interface->fDeleteBuffers = debugGLDeleteBuffers;
     interface->fDeleteProgram = debugGLDeleteProgram;
     interface->fDeleteQueries = noOpGLDeleteIds;
     interface->fDeleteShader = debugGLDeleteShader;
     interface->fDeleteTextures = debugGLDeleteTextures;
+    interface->fDeleteVertexArrays = debugGLDeleteVertexArrays;
     interface->fDepthMask = noOpGLDepthMask;
     interface->fDisable = noOpGLDisable;
     interface->fDisableVertexAttribArray = noOpGLDisableVertexAttribArray;
     interface->fDrawArrays = noOpGLDrawArrays;
     interface->fDrawBuffer = noOpGLDrawBuffer;
     interface->fDrawBuffers = noOpGLDrawBuffers;
     interface->fDrawElements = noOpGLDrawElements;
     interface->fEnable = noOpGLEnable;
     interface->fEnableVertexAttribArray = noOpGLEnableVertexAttribArray;
     interface->fEndQuery = noOpGLEndQuery;
@@ skipping 12 matching lines @@
     interface->fGetQueryObjectuiv = noOpGLGetQueryObjectuiv;
     interface->fGetQueryiv = noOpGLGetQueryiv;
     interface->fGetProgramInfoLog = noOpGLGetInfoLog;
     interface->fGetProgramiv = noOpGLGetShaderOrProgramiv;
     interface->fGetShaderInfoLog = noOpGLGetInfoLog;
     interface->fGetShaderiv = noOpGLGetShaderOrProgramiv;
     interface->fGetString = noOpGLGetString;
     interface->fGetStringi = noOpGLGetStringi;
     interface->fGetTexLevelParameteriv = noOpGLGetTexLevelParameteriv;
     interface->fGetUniformLocation = noOpGLGetUniformLocation;
+    interface->fGenVertexArrays = debugGLGenVertexArrays;
     interface->fLineWidth = noOpGLLineWidth;
     interface->fLinkProgram = noOpGLLinkProgram;
     interface->fPixelStorei = debugGLPixelStorei;
     interface->fQueryCounter = noOpGLQueryCounter;
     interface->fReadBuffer = noOpGLReadBuffer;
     interface->fReadPixels = debugGLReadPixels;
     interface->fScissor = noOpGLScissor;
     interface->fShaderSource = noOpGLShaderSource;
     interface->fStencilFunc = noOpGLStencilFunc;
     interface->fStencilFuncSeparate = noOpGLStencilFuncSeparate;
@@ skipping 47 matching lines @@
     interface->fBlitFramebuffer = noOpGLBlitFramebuffer;
     interface->fResolveMultisampleFramebuffer =
                                     noOpGLResolveMultisampleFramebuffer;
     interface->fMapBuffer = debugGLMapBuffer;
     interface->fUnmapBuffer = debugGLUnmapBuffer;
     interface->fBindFragDataLocationIndexed =
                                     noOpGLBindFragDataLocationIndexed;
 
     return interface;
 }