Implement basic functionality in VertexArrayGL.

src/libANGLE/VertexArray.h

@@ -49,6 +49,9 @@ class VertexArray
     GLuint getElementArrayBufferId() const { return mElementArrayBuffer.id(); }
     size_t getMaxAttribs() const { return mVertexAttributes.size(); }
 
+    rx::VertexArrayImpl *getImplementation() { return mVertexArray; }
+    const rx::VertexArrayImpl *getImplementation() const { return mVertexArray; }
+
   private:
     GLuint mId;
 

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -112,7 +112,7 @@ BufferImpl *RendererGL::createBuffer()
 
 VertexArrayImpl *RendererGL::createVertexArray()
 {
-    return new VertexArrayGL();
+    return new VertexArrayGL(mFunctions, mStateManager);
 }
 
 QueryImpl *RendererGL::createQuery(GLenum type)

src/libANGLE/renderer/gl/StateManagerGL.cpp

@@ -16,6 +16,7 @@ namespace rx
 StateManagerGL::StateManagerGL(const FunctionsGL *functions)
     : mFunctions(functions),
       mProgram(0),
+      mVAO(0),
       mBuffers()
 {
     ASSERT(mFunctions);
@@ -30,6 +31,15 @@ void StateManagerGL::useProgram(GLuint program)
     }
 }
 
+void StateManagerGL::bindVertexArray(GLuint vao)
+{
+    if (mVAO != vao)
+    {
+        mVAO = vao;
+        mFunctions->bindVertexArray(vao);
+    }
+}
+
 void StateManagerGL::bindBuffer(GLenum type, GLuint buffer)
 {
     if (mBuffers[type] == 0)

src/libANGLE/renderer/gl/StateManagerGL.h

@@ -25,6 +25,7 @@ class StateManagerGL
     StateManagerGL(const FunctionsGL *functions);
 
     void useProgram(GLuint program);
+    void bindVertexArray(GLuint vao);
     void bindBuffer(GLenum type, GLuint buffer);
 
   private:
@@ -33,6 +34,7 @@ class StateManagerGL
     const FunctionsGL *mFunctions;
 
     GLuint mProgram;
+    GLuint mVAO;
     std::map<GLenum, GLuint> mBuffers;
 };
 

src/libANGLE/renderer/gl/VertexArrayGL.cpp

@@ -9,35 +9,146 @@
 #include "libANGLE/renderer/gl/VertexArrayGL.h"
 
 #include "common/debug.h"
+#include "libANGLE/angletypes.h"
+#include "libANGLE/renderer/gl/BufferGL.h"
+#include "libANGLE/renderer/gl/FunctionsGL.h"
+#include "libANGLE/renderer/gl/StateManagerGL.h"
 
 namespace rx
 {
 
-VertexArrayGL::VertexArrayGL()
-    : VertexArrayImpl()
-{}
+VertexArrayGL::VertexArrayGL(const FunctionsGL *functions, StateManagerGL *stateManager)
+    : VertexArrayImpl(),
+      mFunctions(functions),
+      mStateManager(stateManager),
+      mVertexArrayID(0),
+      mAppliedElementArrayBuffer(0),
+      mAppliedAttributes()
+{
+    ASSERT(mFunctions);
+    ASSERT(mStateManager);
+    mFunctions->genVertexArrays(1, &mVertexArrayID);
+
+    // Set the cached vertex attribute array size
+    GLint maxVertexAttribs;
+    mFunctions->getIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxVertexAttribs);
+    mAppliedAttributes.resize(maxVertexAttribs);
+}
 
 VertexArrayGL::~VertexArrayGL()
-{}
+{
+    if (mVertexArrayID != 0)
+    {
+        mFunctions->deleteVertexArrays(1, &mVertexArrayID);
+        mVertexArrayID = 0;
+    }
+
+    for (size_t idx = 0; idx < mAppliedAttributes.size(); idx++)
+    {
+        mAppliedAttributes[idx].buffer.set(NULL);
+    }
+}
 
 void VertexArrayGL::setElementArrayBuffer(const gl::Buffer *buffer)
 {
-    //UNIMPLEMENTED();
+    GLuint elementArrayBufferID = 0;
+    if (buffer != nullptr)
+    {
+        const BufferGL *bufferGL = GetImplAs<BufferGL>(buffer);
+        elementArrayBufferID = bufferGL->getBufferID();
+    }
+
+    if (elementArrayBufferID != mAppliedElementArrayBuffer)
+    {
+        mStateManager->bindVertexArray(mVertexArrayID);
+        mStateManager->bindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementArrayBufferID);
+        mStateManager->bindVertexArray(0);
+
+        mAppliedElementArrayBuffer = elementArrayBufferID;
+    }
 }
 
 void VertexArrayGL::setAttribute(size_t idx, const gl::VertexAttribute &attr)
 {
-    UNIMPLEMENTED();
+    if (mAppliedAttributes[idx].type != attr.type ||
+        mAppliedAttributes[idx].size != attr.size ||
+        mAppliedAttributes[idx].normalized != attr.normalized ||
+        mAppliedAttributes[idx].pureInteger != attr.pureInteger ||
+        mAppliedAttributes[idx].stride != attr.stride ||
+        mAppliedAttributes[idx].pointer != attr.pointer ||
+        mAppliedAttributes[idx].buffer.get() != attr.buffer.get())
+    {
+        mStateManager->bindVertexArray(mVertexArrayID);
+
+        const gl::Buffer *arrayBuffer = attr.buffer.get();
+        if (arrayBuffer != nullptr)
+        {
+            const BufferGL *arrayBufferGL = GetImplAs<BufferGL>(arrayBuffer);
+            mStateManager->bindBuffer(GL_ARRAY_BUFFER, arrayBufferGL->getBufferID());
+        }
+        else
+        {
+            // This will take some extra work, core OpenGL doesn't support binding raw data pointers
+            // to VAOs
+            UNIMPLEMENTED();
+        }
+
+        if (attr.pureInteger)
+        {
+            mFunctions->vertexAttribIPointer(idx, attr.size, attr.type, attr.stride, attr.pointer);
+        }
+        else
+        {
+            mFunctions->vertexAttribPointer(idx, attr.size, attr.type, attr.normalized, attr.stride, attr.pointer);
+        }
+        mAppliedAttributes[idx].type = attr.type;
+        mAppliedAttributes[idx].size = attr.size;
+        mAppliedAttributes[idx].normalized = attr.normalized;
+        mAppliedAttributes[idx].pureInteger = attr.pureInteger;
+        mAppliedAttributes[idx].stride = attr.stride;
+        mAppliedAttributes[idx].pointer = attr.pointer;
+        mAppliedAttributes[idx].buffer.set(attr.buffer.get());
+
+        mStateManager->bindVertexArray(0);
+    }
 }
 
 void VertexArrayGL::setAttributeDivisor(size_t idx, GLuint divisor)
 {
-    UNIMPLEMENTED();
+    if (mAppliedAttributes[idx].divisor != divisor)
+    {
+        mStateManager->bindVertexArray(mVertexArrayID);
+
+        mFunctions->vertexAttribDivisor(idx, divisor);
+        mAppliedAttributes[idx].divisor = divisor;
+
+        mStateManager->bindVertexArray(0);
+    }
 }
 
 void VertexArrayGL::enableAttribute(size_t idx, bool enabledState)
 {
-    UNIMPLEMENTED();
+    if (mAppliedAttributes[idx].enabled != enabledState)
+    {
+        mStateManager->bindVertexArray(mVertexArrayID);
+
+        if (enabledState)
+        {
+            mFunctions->enableVertexAttribArray(idx);
+        }
+        else
+        {
+            mFunctions->disableVertexAttribArray(idx);
+        }
+        mAppliedAttributes[idx].enabled = enabledState;
+
+        mStateManager->bindVertexArray(0);
+    }
+}
+
+GLuint VertexArrayGL::getVertexArrayID() const
+{
+    return mVertexArrayID;
 }
 
 }

src/libANGLE/renderer/gl/VertexArrayGL.h

@@ -14,10 +14,13 @@
 namespace rx
 {
 
+class FunctionsGL;
+class StateManagerGL;
+
 class VertexArrayGL : public VertexArrayImpl
 {
   public:
-    VertexArrayGL();
+    VertexArrayGL(const FunctionsGL *functions, StateManagerGL *stateManager);
     ~VertexArrayGL() override;
 
     void setElementArrayBuffer(const gl::Buffer *buffer) override;
@@ -25,8 +28,18 @@ class VertexArrayGL : public VertexArrayImpl
     void setAttributeDivisor(size_t idx, GLuint divisor) override;
     void enableAttribute(size_t idx, bool enabledState) override;
 
+    GLuint getVertexArrayID() const;
+
   private:
     DISALLOW_COPY_AND_ASSIGN(VertexArrayGL);
+
+    const FunctionsGL *mFunctions;
+    StateManagerGL *mStateManager;
+
+    GLuint mVertexArrayID;
+
+    GLuint mAppliedElementArrayBuffer;
+    std::vector<gl::VertexAttribute> mAppliedAttributes;
 };
 
 }