Add support for glMapBufferRange. Use glMapBufferRange and glMapBufferSubData.

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"
@@ skipping 604 matching lines @@
                                       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 debugGLMapBufferRange(GrGLenum target, GrGLintptr offset,
+                                                    GrGLsizeiptr length, GrGLbitfield 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);
+
+    // 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 = NULL;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getArrayBuffer();
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
             break;
         default:
+            SkFAIL("Unexpected target to glMapBufferRange");
+            break;
+    }
+
+    if (NULL != buffer) {
+        GrAlwaysAssert(offset >= 0 && offset + length <= buffer->getSize());
+        GrAlwaysAssert(!buffer->getMapped());
+        buffer->setMapped(offset, length);
+        return buffer->getDataPtr() + offset;
+    }
+
+    GrAlwaysAssert(false);
+    return NULL;        // no buffer bound to the target
+}
+
+GrGLvoid* GR_GL_FUNCTION_TYPE debugGLMapBuffer(GrGLenum target, GrGLenum access) {
+    GrAlwaysAssert(GR_GL_WRITE_ONLY == access);
+
+    GrBufferObj *buffer = NULL;
+    switch (target) {
+        case GR_GL_ARRAY_BUFFER:
+            buffer = GrDebugGL::getInstance()->getArrayBuffer();
+            break;
+        case GR_GL_ELEMENT_ARRAY_BUFFER:
+            buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
+            break;
+        default:
             SkFAIL("Unexpected target to glMapBuffer");
             break;
     }
 
-    if (buffer) {
-        GrAlwaysAssert(!buffer->getMapped());
-        buffer->setMapped();
-        return buffer->getDataPtr();
-    }
-
-    GrAlwaysAssert(false);
-    return NULL;        // no buffer bound to the target
+    return debugGLMapBufferRange(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 GR_GL_FUNCTION_TYPE debugGLUnmapBuffer(GrGLenum target) {
 
     GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
                    GR_GL_ELEMENT_ARRAY_BUFFER == target);
 
     GrBufferObj *buffer = NULL;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getArrayBuffer();
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
             break;
         default:
             SkFAIL("Unexpected target to glUnmapBuffer");
             break;
     }
 
-    if (buffer) {
+    if (NULL != buffer) {
         GrAlwaysAssert(buffer->getMapped());
         buffer->resetMapped();
         return GR_GL_TRUE;
     }
 
     GrAlwaysAssert(false);
     return GR_GL_FALSE; // GR_GL_INVALID_OPERATION;
 }
 
+GrGLvoid GR_GL_FUNCTION_TYPE debugGLFlushMappedBufferRange(GrGLenum target,
+                                                           GrGLintptr offset,
+                                                           GrGLsizeiptr length) {
+    GrAlwaysAssert(GR_GL_ARRAY_BUFFER == target ||
+                   GR_GL_ELEMENT_ARRAY_BUFFER == target);
+
+    GrBufferObj *buffer = NULL;
+    switch (target) {
+        case GR_GL_ARRAY_BUFFER:
+            buffer = GrDebugGL::getInstance()->getArrayBuffer();
+            break;
+        case GR_GL_ELEMENT_ARRAY_BUFFER:
+            buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
+            break;
+        default:
+            SkFAIL("Unexpected target to glUnmapBuffer");
+            break;
+    }
+
+    if (NULL != buffer) {
+        GrAlwaysAssert(buffer->getMapped());
+        GrAlwaysAssert(offset >= 0 && (offset + length) <= buffer->getMappedLength());
+    } else {
+        GrAlwaysAssert(false);
+    }
+}
+
+
 GrGLvoid GR_GL_FUNCTION_TYPE debugGLGetBufferParameteriv(GrGLenum target,
                                                          GrGLenum value,
                                                          GrGLint* params) {
 
     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 = NULL;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getArrayBuffer();
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             buffer = GrDebugGL::getInstance()->getElementArrayBuffer();
             break;
     }
 
     GrAlwaysAssert(buffer);
 
     switch (value) {
         case GR_GL_BUFFER_MAPPED:
             *params = GR_GL_FALSE;
-            if (buffer)
+            if (NULL != buffer)
                 *params = buffer->getMapped() ? GR_GL_TRUE : GR_GL_FALSE;
             break;
         case GR_GL_BUFFER_SIZE:
             *params = 0;
-            if (buffer)
+            if (NULL != buffer)
                 *params = SkToInt(buffer->getSize());
             break;
         case GR_GL_BUFFER_USAGE:
             *params = GR_GL_STATIC_DRAW;
-            if (buffer)
+            if (NULL != buffer)
                 *params = buffer->getUsage();
             break;
         default:
             SkFAIL("Unexpected value to glGetBufferParamateriv");
             break;
     }
 };
 } // end of namespace
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 89 matching lines @@
     functions->fDisableVertexAttribArray = noOpGLDisableVertexAttribArray;
     functions->fDrawArrays = noOpGLDrawArrays;
     functions->fDrawBuffer = noOpGLDrawBuffer;
     functions->fDrawBuffers = noOpGLDrawBuffers;
     functions->fDrawElements = noOpGLDrawElements;
     functions->fEnable = noOpGLEnable;
     functions->fEnableVertexAttribArray = noOpGLEnableVertexAttribArray;
     functions->fEndQuery = noOpGLEndQuery;
     functions->fFinish = noOpGLFinish;
     functions->fFlush = noOpGLFlush;
+    functions->fFlushMappedBufferRange = debugGLFlushMappedBufferRange;
     functions->fFrontFace = noOpGLFrontFace;
     functions->fGenerateMipmap = debugGLGenerateMipmap;
     functions->fGenBuffers = debugGLGenBuffers;
     functions->fGenQueries = noOpGLGenIds;
     functions->fGenTextures = debugGLGenTextures;
     functions->fGetBufferParameteriv = debugGLGetBufferParameteriv;
     functions->fGetError = noOpGLGetError;
     functions->fGetIntegerv = noOpGLGetIntegerv;
     functions->fGetQueryObjecti64v = noOpGLGetQueryObjecti64v;
     functions->fGetQueryObjectiv = noOpGLGetQueryObjectiv;
     functions->fGetQueryObjectui64v = noOpGLGetQueryObjectui64v;
     functions->fGetQueryObjectuiv = noOpGLGetQueryObjectuiv;
     functions->fGetQueryiv = noOpGLGetQueryiv;
     functions->fGetProgramInfoLog = noOpGLGetInfoLog;
     functions->fGetProgramiv = noOpGLGetShaderOrProgramiv;
     functions->fGetShaderInfoLog = noOpGLGetInfoLog;
     functions->fGetShaderiv = noOpGLGetShaderOrProgramiv;
     functions->fGetString = noOpGLGetString;
     functions->fGetStringi = noOpGLGetStringi;
     functions->fGetTexLevelParameteriv = noOpGLGetTexLevelParameteriv;
     functions->fGetUniformLocation = noOpGLGetUniformLocation;
     functions->fGenVertexArrays = debugGLGenVertexArrays;
     functions->fLineWidth = noOpGLLineWidth;
     functions->fLinkProgram = noOpGLLinkProgram;
+    functions->fMapBuffer = debugGLMapBuffer;
+    functions->fMapBufferRange = debugGLMapBufferRange;
     functions->fPixelStorei = debugGLPixelStorei;
     functions->fQueryCounter = noOpGLQueryCounter;
     functions->fReadBuffer = noOpGLReadBuffer;
     functions->fReadPixels = debugGLReadPixels;
     functions->fScissor = noOpGLScissor;
     functions->fShaderSource = noOpGLShaderSource;
     functions->fStencilFunc = noOpGLStencilFunc;
     functions->fStencilFuncSeparate = noOpGLStencilFuncSeparate;
     functions->fStencilMask = noOpGLStencilMask;
     functions->fStencilMaskSeparate = noOpGLStencilMaskSeparate;
@@ skipping 17 matching lines @@
     functions->fUniform3i = noOpGLUniform3i;
     functions->fUniform3fv = noOpGLUniform3fv;
     functions->fUniform3iv = noOpGLUniform3iv;
     functions->fUniform4f = noOpGLUniform4f;
     functions->fUniform4i = noOpGLUniform4i;
     functions->fUniform4fv = noOpGLUniform4fv;
     functions->fUniform4iv = noOpGLUniform4iv;
     functions->fUniformMatrix2fv = noOpGLUniformMatrix2fv;
     functions->fUniformMatrix3fv = noOpGLUniformMatrix3fv;
     functions->fUniformMatrix4fv = noOpGLUniformMatrix4fv;
+    functions->fUnmapBuffer = debugGLUnmapBuffer;
     functions->fUseProgram = debugGLUseProgram;
     functions->fVertexAttrib4fv = noOpGLVertexAttrib4fv;
     functions->fVertexAttribPointer = noOpGLVertexAttribPointer;
     functions->fViewport = noOpGLViewport;
     functions->fBindFramebuffer = debugGLBindFramebuffer;
     functions->fBindRenderbuffer = debugGLBindRenderbuffer;
     functions->fCheckFramebufferStatus = noOpGLCheckFramebufferStatus;
     functions->fDeleteFramebuffers = debugGLDeleteFramebuffers;
     functions->fDeleteRenderbuffers = debugGLDeleteRenderbuffers;
     functions->fFramebufferRenderbuffer = debugGLFramebufferRenderbuffer;
     functions->fFramebufferTexture2D = debugGLFramebufferTexture2D;
     functions->fGenFramebuffers = debugGLGenFramebuffers;
     functions->fGenRenderbuffers = debugGLGenRenderbuffers;
     functions->fGetFramebufferAttachmentParameteriv =
                                     noOpGLGetFramebufferAttachmentParameteriv;
     functions->fGetRenderbufferParameteriv = noOpGLGetRenderbufferParameteriv;
     functions->fRenderbufferStorage = noOpGLRenderbufferStorage;
     functions->fRenderbufferStorageMultisample =
                                     noOpGLRenderbufferStorageMultisample;
     functions->fBlitFramebuffer = noOpGLBlitFramebuffer;
     functions->fResolveMultisampleFramebuffer =
                                     noOpGLResolveMultisampleFramebuffer;
-    functions->fMapBuffer = debugGLMapBuffer;
     functions->fMatrixLoadf = noOpGLMatrixLoadf;
     functions->fMatrixLoadIdentity = noOpGLMatrixLoadIdentity;
-    functions->fUnmapBuffer = debugGLUnmapBuffer;
+
     functions->fBindFragDataLocationIndexed =
                                     noOpGLBindFragDataLocationIndexed;
 
     interface->fExtensions.init(kGL_GrGLStandard, functions->fGetString, functions->fGetStringi,
                                 functions->fGetIntegerv);
 
     return interface;
 }