Implement basic functionality in BufferGL.

src/libANGLE/renderer/gl/BufferGL.cpp

@@ -9,45 +9,78 @@
 #include "libANGLE/renderer/gl/BufferGL.h"
 
 #include "common/debug.h"
+#include "libANGLE/angletypes.h"
+#include "libANGLE/renderer/gl/FunctionsGL.h"
+#include "libANGLE/renderer/gl/StateManagerGL.h"
 
 namespace rx
 {
 
-BufferGL::BufferGL()
-    : BufferImpl()
-{}
+static const GLenum SourceBufferOperationTarget = GL_ELEMENT_ARRAY_BUFFER;
+static const GLenum DestBufferOperationTarget = GL_ARRAY_BUFFER;
+
+BufferGL::BufferGL(const FunctionsGL *functions, StateManagerGL *stateManager)
+    : BufferImpl(),
+      mFunctions(functions),
+      mStateManager(stateManager),
+      mBufferID(0)
+{
+    ASSERT(mFunctions);
+    ASSERT(mStateManager);
+
+    mFunctions->genBuffers(1, &mBufferID);
+}
 
 BufferGL::~BufferGL()
-{}
+{
+    if (mBufferID)
+    {
+        mFunctions->deleteBuffers(1, &mBufferID);
+        mBufferID = 0;
+    }
+}
 
 gl::Error BufferGL::setData(const void* data, size_t size, GLenum usage)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    mStateManager->bindBuffer(DestBufferOperationTarget, mBufferID);
+    mFunctions->bufferData(DestBufferOperationTarget, size, data, usage);
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error BufferGL::setSubData(const void* data, size_t size, size_t offset)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    mStateManager->bindBuffer(DestBufferOperationTarget, mBufferID);
+    mFunctions->bufferSubData(DestBufferOperationTarget, offset, size, data);
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error BufferGL::copySubData(BufferImpl* source, GLintptr sourceOffset, GLintptr destOffset, GLsizeiptr size)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    BufferGL *sourceGL = GetAs<BufferGL>(source);
+
+    mStateManager->bindBuffer(DestBufferOperationTarget, mBufferID);
+    mStateManager->bindBuffer(SourceBufferOperationTarget, sourceGL->getBufferID());
+
+    mFunctions->copyBufferSubData(SourceBufferOperationTarget, GL_ARRAY_BUFFER, sourceOffset, destOffset, size);
+
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error BufferGL::map(size_t offset, size_t length, GLbitfield access, GLvoid **mapPtr)
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    // TODO: look into splitting this into two functions, glMapBuffer is available in 1.5, but
+    // glMapBufferRange requires 3.0
+
+    mStateManager->bindBuffer(DestBufferOperationTarget, mBufferID);
+    *mapPtr = mFunctions->mapBufferRange(DestBufferOperationTarget, offset, length, access);
+    return gl::Error(GL_NO_ERROR);
 }
 
 gl::Error BufferGL::unmap()
 {
-    UNIMPLEMENTED();
-    return gl::Error(GL_INVALID_OPERATION);
+    mStateManager->bindBuffer(DestBufferOperationTarget, mBufferID);
+    mFunctions->unmapBuffer(DestBufferOperationTarget);
+    return gl::Error(GL_NO_ERROR);
 }
 
 void BufferGL::markTransformFeedbackUsage()
@@ -61,4 +94,9 @@ gl::Error BufferGL::getData(const uint8_t **outData)
     return gl::Error(GL_INVALID_OPERATION);
 }
 
+GLuint BufferGL::getBufferID() const
+{
+    return mBufferID;
+}
+
 }

src/libANGLE/renderer/gl/BufferGL.h

@@ -14,10 +14,13 @@
 namespace rx
 {
 
+class FunctionsGL;
+class StateManagerGL;
+
 class BufferGL : public BufferImpl
 {
   public:
-    BufferGL();
+    BufferGL(const FunctionsGL *functions, StateManagerGL *stateManager);
     ~BufferGL() override;
 
     gl::Error setData(const void* data, size_t size, GLenum usage) override;
@@ -31,8 +34,15 @@ class BufferGL : public BufferImpl
     // for validation, for certain indexed draw calls.
     gl::Error getData(const uint8_t **outData) override;
 
+    GLuint getBufferID() const;
+
   private:
     DISALLOW_COPY_AND_ASSIGN(BufferGL);
+
+    const FunctionsGL *mFunctions;
+    StateManagerGL *mStateManager;
+
+    GLuint mBufferID;
 };
 
 }

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -107,7 +107,7 @@ RenderbufferImpl *RendererGL::createRenderbuffer()
 
 BufferImpl *RendererGL::createBuffer()
 {
-    return new BufferGL();
+    return new BufferGL(mFunctions, mStateManager);
 }
 
 VertexArrayImpl *RendererGL::createVertexArray()

src/libANGLE/renderer/gl/StateManagerGL.cpp

@@ -15,7 +15,8 @@ namespace rx
 
 StateManagerGL::StateManagerGL(const FunctionsGL *functions)
     : mFunctions(functions),
-      mProgram(0)
+      mProgram(0),
+      mBuffers()
 {
     ASSERT(mFunctions);
 }
@@ -29,4 +30,13 @@ void StateManagerGL::useProgram(GLuint program)
     }
 }
 
+void StateManagerGL::bindBuffer(GLenum type, GLuint buffer)
+{
+    if (mBuffers[type] == 0)
+    {
+        mBuffers[type] = buffer;
+        mFunctions->bindBuffer(type, buffer);
+    }
+}
+
 }

src/libANGLE/renderer/gl/StateManagerGL.h

@@ -12,6 +12,8 @@
 #include "common/debug.h"
 #include "libANGLE/renderer/gl/functionsgl_typedefs.h"
 
+#include <map>
+
 namespace rx
 {
 
@@ -23,6 +25,7 @@ class StateManagerGL
     StateManagerGL(const FunctionsGL *functions);
 
     void useProgram(GLuint program);
+    void bindBuffer(GLenum type, GLuint buffer);
 
   private:
     DISALLOW_COPY_AND_ASSIGN(StateManagerGL);
@@ -30,6 +33,7 @@ class StateManagerGL
     const FunctionsGL *mFunctions;
 
     GLuint mProgram;
+    std::map<GLenum, GLuint> mBuffers;
 };
 
 }

tests/angle_tests/SimpleOperationTest.cpp

@@ -142,3 +142,49 @@ TYPED_TEST(SimpleOperationTest, LinkProgramWithAttributes)
 
     EXPECT_GL_NO_ERROR();
 }
+
+TYPED_TEST(SimpleOperationTest, BufferDataWithData)
+{
+    GLuint buffer;
+    glGenBuffers(1, &buffer);
+    glBindBuffer(GL_ARRAY_BUFFER, buffer);
+
+    std::vector<uint8_t> data(1024);
+    glBufferData(GL_ARRAY_BUFFER, data.size(), &data[0], GL_STATIC_DRAW);
+
+    glDeleteBuffers(1, &buffer);
+
+    EXPECT_GL_NO_ERROR();
+}
+
+TYPED_TEST(SimpleOperationTest, BufferDataWithNoData)
+{
+    GLuint buffer;
+    glGenBuffers(1, &buffer);
+    glBindBuffer(GL_ARRAY_BUFFER, buffer);
+    glBufferData(GL_ARRAY_BUFFER, 1024, nullptr, GL_STATIC_DRAW);
+    glDeleteBuffers(1, &buffer);
+
+    EXPECT_GL_NO_ERROR();
+}
+
+TYPED_TEST(SimpleOperationTest, BufferSubData)
+{
+    GLuint buffer;
+    glGenBuffers(1, &buffer);
+    glBindBuffer(GL_ARRAY_BUFFER, buffer);
+
+    const size_t bufferSize = 1024;
+    glBufferData(GL_ARRAY_BUFFER, bufferSize, nullptr, GL_STATIC_DRAW);
+
+    const size_t subDataCount = 16;
+    std::vector<uint8_t> data(bufferSize / subDataCount);
+    for (size_t i = 0; i < subDataCount; i++)
+    {
+        glBufferSubData(GL_ARRAY_BUFFER, data.size() * i, data.size(), &data[0]);
+    }
+
+    glDeleteBuffers(1, &buffer);
+
+    EXPECT_GL_NO_ERROR();
+}