Add transfer buffer support.

src/gpu/gl/SkNullGLContext.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/SkNullGLContext.h"
 #include "gl/GrGLInterface.h"
@@ skipping 104 matching lines @@
 /**
  * The state object for the null interface.
  */
 class SkNullGLContext::ContextState : public SkRefCnt {
 public:
     
 
     BufferManager   fBufferManager;
     GrGLuint        fCurrArrayBuffer;
     GrGLuint        fCurrElementArrayBuffer;
+    GrGLuint        fCurrPixelPackBuffer;
+    GrGLuint        fCurrPixelUnpackBuffer;
     GrGLuint        fCurrProgramID;
     GrGLuint        fCurrShaderID;
 
 
     ContextState()
         : fCurrArrayBuffer(0)
         , fCurrElementArrayBuffer(0)
+        , fCurrPixelPackBuffer(0)
+        , fCurrPixelUnpackBuffer(0)
         , fCurrProgramID(0)
         , fCurrShaderID(0) {}
 
     static ContextState* Get() { return current_context(); }
 };
 
 typedef SkNullGLContext::ContextState State;
 
 // Functions not declared in GrGLBogusInterface.h (not common with the Debug GL interface).
 
@@ skipping 23 matching lines @@
     State* state = State::Get();
     GrGLuint id = 0;
 
     switch (target) {
     case GR_GL_ARRAY_BUFFER:
         id = state->fCurrArrayBuffer;
         break;
     case GR_GL_ELEMENT_ARRAY_BUFFER:
         id = state->fCurrElementArrayBuffer;
         break;
+    case GR_GL_PIXEL_PACK_BUFFER:
+        id = state->fCurrPixelPackBuffer;
+        break;
+    case GR_GL_PIXEL_UNPACK_BUFFER:
+        id = state->fCurrPixelUnpackBuffer;
+        break;
     default:
         SkFAIL("Unexpected target to nullGLBufferData");
         break;
     }
 
     if (id > 0) {
         BufferObj* buffer = state->fBufferManager.lookUp(id);
         buffer->allocate(size, (const GrGLchar*) data);
     }
 }
@@ skipping 23 matching lines @@
 
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLBindBuffer(GrGLenum target, GrGLuint buffer) {
     State* state = State::Get();
     switch (target) {
     case GR_GL_ARRAY_BUFFER:
         state->fCurrArrayBuffer = buffer;
         break;
     case GR_GL_ELEMENT_ARRAY_BUFFER:
         state->fCurrElementArrayBuffer = buffer;
         break;
+    case GR_GL_PIXEL_PACK_BUFFER:
+        state->fCurrPixelPackBuffer = buffer;
+        break;
+    case GR_GL_PIXEL_UNPACK_BUFFER:
+        state->fCurrPixelUnpackBuffer = buffer;
+        break;
     }
 }
 
 // deleting a bound buffer has the side effect of binding 0
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLDeleteBuffers(GrGLsizei n, const GrGLuint* ids) {
     State* state = State::Get();
     for (int i = 0; i < n; ++i) {
         if (ids[i] == state->fCurrArrayBuffer) {
             state->fCurrArrayBuffer = 0;
         }
         if (ids[i] == state->fCurrElementArrayBuffer) {
             state->fCurrElementArrayBuffer = 0;
         }
+        if (ids[i] == state->fCurrPixelPackBuffer) {
+            state->fCurrPixelPackBuffer = 0;
+        }
+        if (ids[i] == state->fCurrPixelUnpackBuffer) {
+            state->fCurrPixelUnpackBuffer = 0;
+        }
 
         BufferObj* buffer = state->fBufferManager.lookUp(ids[i]);
         state->fBufferManager.free(buffer);
     }
 }
 
 GrGLvoid* GR_GL_FUNCTION_TYPE nullGLMapBufferRange(GrGLenum target, GrGLintptr offset,
                                                    GrGLsizeiptr length, GrGLbitfield access) {
     State* state = State::Get();
     GrGLuint id = 0;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             id = state->fCurrArrayBuffer;
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             id = state->fCurrElementArrayBuffer;
             break;
+        case GR_GL_PIXEL_PACK_BUFFER:
+            id = state->fCurrPixelPackBuffer;
+            break;
+        case GR_GL_PIXEL_UNPACK_BUFFER:
+            id = state->fCurrPixelUnpackBuffer;
+            break;
     }
 
     if (id > 0) {
         // We just ignore the offset and length here.
         BufferObj* buffer = state->fBufferManager.lookUp(id);
         SkASSERT(!buffer->mapped());
         buffer->setMapped(true);
         return buffer->dataPtr();
     }
     return nullptr;
 }
 
 GrGLvoid* GR_GL_FUNCTION_TYPE nullGLMapBuffer(GrGLenum target, GrGLenum access) {
     State* state = State::Get();
     GrGLuint id = 0;
     switch (target) {
         case GR_GL_ARRAY_BUFFER:
             id = state->fCurrArrayBuffer;
             break;
         case GR_GL_ELEMENT_ARRAY_BUFFER:
             id = state->fCurrElementArrayBuffer;
             break;
+        case GR_GL_PIXEL_PACK_BUFFER:
+            id = state->fCurrPixelPackBuffer;
+            break;
+        case GR_GL_PIXEL_UNPACK_BUFFER:
+            id = state->fCurrPixelUnpackBuffer;
+            break;
     }
 
     if (id > 0) {
         BufferObj* buffer = state->fBufferManager.lookUp(id);
         SkASSERT(!buffer->mapped());
         buffer->setMapped(true);
         return buffer->dataPtr();
     }
 
     SkASSERT(false);
     return nullptr;            // no buffer bound to target
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLFlushMappedBufferRange(GrGLenum target,
                                                           GrGLintptr offset,
                                                           GrGLsizeiptr length) {}
 
 
 GrGLboolean GR_GL_FUNCTION_TYPE nullGLUnmapBuffer(GrGLenum target) {
     State* state = State::Get();
     GrGLuint id = 0;
     switch (target) {
     case GR_GL_ARRAY_BUFFER:
         id = state->fCurrArrayBuffer;
         break;
     case GR_GL_ELEMENT_ARRAY_BUFFER:
         id = state->fCurrElementArrayBuffer;
         break;
+    case GR_GL_PIXEL_PACK_BUFFER:
+        id = state->fCurrPixelPackBuffer;
+        break;
+    case GR_GL_PIXEL_UNPACK_BUFFER:
+        id = state->fCurrPixelUnpackBuffer;
+        break;
     }
     if (id > 0) {
         BufferObj* buffer = state->fBufferManager.lookUp(id);
         SkASSERT(buffer->mapped());
         buffer->setMapped(false);
         return GR_GL_TRUE;
     }
 
     GrAlwaysAssert(false);
     return GR_GL_FALSE; // GR_GL_INVALID_OPERATION;
 }
 
 GrGLvoid GR_GL_FUNCTION_TYPE nullGLGetBufferParameteriv(GrGLenum target, GrGLenum pname, GrGLint* params) {
     State* state = State::Get();
     switch (pname) {
         case GR_GL_BUFFER_MAPPED: {
             *params = GR_GL_FALSE;
             GrGLuint id = 0;
             switch (target) {
                 case GR_GL_ARRAY_BUFFER:
                     id = state->fCurrArrayBuffer;
                     break;
                 case GR_GL_ELEMENT_ARRAY_BUFFER:
                     id = state->fCurrElementArrayBuffer;
                     break;
+                case GR_GL_PIXEL_PACK_BUFFER:
+                    id = state->fCurrPixelPackBuffer;
+                    break;
+                case GR_GL_PIXEL_UNPACK_BUFFER:
+                    id = state->fCurrPixelUnpackBuffer;
+                    break;
             }
             if (id > 0) {
                 BufferObj* buffer = state->fBufferManager.lookUp(id);
                 if (buffer->mapped()) {
                     *params = GR_GL_TRUE;
                 }
             }
             break; }
         default:
             SkFAIL("Unexpected pname to GetBufferParamateriv");
@@ skipping 220 matching lines @@
     interface->fCallbackData = reinterpret_cast<GrGLInterfaceCallbackData>(fState);
 #endif
 }
 
 SkNullGLContext::~SkNullGLContext() {
     this->teardown();
     fState->unref();
 }
 
 void SkNullGLContext::onPlatformMakeCurrent() const { set_current_context(fState); }