Store the applied element array buffer as a binding pointer.

src/libANGLE/VertexArray.cpp

@@ -54,14 +54,12 @@ void VertexArray::detachBuffer(GLuint bufferName)
         if (mData.mVertexAttributes[attribute].buffer.id() == bufferName)
         {
             mData.mVertexAttributes[attribute].buffer.set(nullptr);
-            mVertexArray->setAttribute(attribute, mData.mVertexAttributes[attribute]);
         }
     }
 
     if (mData.mElementArrayBuffer.id() == bufferName)
     {
         mData.mElementArrayBuffer.set(nullptr);
-        mVertexArray->setElementArrayBuffer(nullptr);
     }
 }
 
@@ -75,14 +73,12 @@ void VertexArray::setVertexAttribDivisor(size_t index, GLuint divisor)
 {
     ASSERT(index < getMaxAttribs());
     mData.mVertexAttributes[index].divisor = divisor;
-    mVertexArray->setAttributeDivisor(index, divisor);
 }
 
 void VertexArray::enableAttribute(size_t attributeIndex, bool enabledState)
 {
     ASSERT(attributeIndex < getMaxAttribs());
     mData.mVertexAttributes[attributeIndex].enabled = enabledState;
-    mVertexArray->enableAttribute(attributeIndex, enabledState);
 
     // Update state cache
     if (enabledState)
@@ -113,14 +109,11 @@ void VertexArray::setAttributeState(size_t attributeIndex, gl::Buffer *boundBuff
     attrib->pureInteger = pureInteger;
     attrib->stride = stride;
     attrib->pointer = pointer;
-
-    mVertexArray->setAttribute(attributeIndex, *attrib);
 }
 
 void VertexArray::setElementArrayBuffer(Buffer *buffer)
 {
     mData.mElementArrayBuffer.set(buffer);
-    mVertexArray->setElementArrayBuffer(buffer);
 }
 
 }

src/libANGLE/renderer/VertexArrayImpl.h

@@ -22,11 +22,6 @@ class VertexArrayImpl : angle::NonCopyable
     VertexArrayImpl(const gl::VertexArray::Data &data) : mData(data) { }
     virtual ~VertexArrayImpl() { }
 
-    virtual void setElementArrayBuffer(const gl::Buffer *buffer) = 0;
-    virtual void setAttribute(size_t idx, const gl::VertexAttribute &attr) = 0;
-    virtual void setAttributeDivisor(size_t idx, GLuint divisor) = 0;
-    virtual void enableAttribute(size_t idx, bool enabledState) = 0;
-
   protected:
     const gl::VertexArray::Data &mData;
 };

src/libANGLE/renderer/d3d/d3d11/VertexArray11.h

@@ -23,12 +23,7 @@ class VertexArray11 : public VertexArrayImpl
         : VertexArrayImpl(data)
     {
     }
-    virtual ~VertexArray11() { }
-
-    virtual void setElementArrayBuffer(const gl::Buffer *buffer) { }
-    virtual void setAttribute(size_t idx, const gl::VertexAttribute &attr) { }
-    virtual void setAttributeDivisor(size_t idx, GLuint divisor) { }
-    virtual void enableAttribute(size_t idx, bool enabledState) { }
+    virtual ~VertexArray11() {}
 };
 
 }

src/libANGLE/renderer/d3d/d3d9/VertexArray9.h

@@ -25,11 +25,6 @@ class VertexArray9 : public VertexArrayImpl
     }
 
     virtual ~VertexArray9() { }
-
-    virtual void setElementArrayBuffer(const gl::Buffer *buffer) { }
-    virtual void setAttribute(size_t idx, const gl::VertexAttribute &attr) { }
-    virtual void setAttributeDivisor(size_t idx, GLuint divisor) { }
-    virtual void enableAttribute(size_t idx, bool enabledState) { }
 };
 
 }

src/libANGLE/renderer/gl/VertexArrayGL.cpp

@@ -26,7 +26,7 @@ VertexArrayGL::VertexArrayGL(const gl::VertexArray::Data &data, const FunctionsG
       mFunctions(functions),
       mStateManager(stateManager),
       mVertexArrayID(0),
-      mAppliedElementArrayBuffer(0),
+      mAppliedElementArrayBuffer(),
       mStreamingElementArrayBufferSize(0),
       mStreamingElementArrayBuffer(0),
       mStreamingArrayBufferSize(0),
@@ -55,34 +55,13 @@ VertexArrayGL::~VertexArrayGL()
     mStreamingArrayBufferSize = 0;
     mStreamingArrayBuffer = 0;
 
+    mAppliedElementArrayBuffer.set(nullptr);
     for (size_t idx = 0; idx < mAppliedAttributes.size(); idx++)
     {
         mAppliedAttributes[idx].buffer.set(nullptr);
     }
 }
 
-void VertexArrayGL::setElementArrayBuffer(const gl::Buffer *buffer)
-{
-    // If the buffer is being unbound/deleted, reset the currently applied buffer ID
-    // so that even if a new buffer is generated with the same ID, it will be re-bound.
-    if (buffer == nullptr && mAppliedElementArrayBuffer != mStreamingElementArrayBuffer)
-    {
-        mAppliedElementArrayBuffer = 0;
-    }
-}
-
-void VertexArrayGL::setAttribute(size_t idx, const gl::VertexAttribute &attr)
-{
-}
-
-void VertexArrayGL::setAttributeDivisor(size_t idx, GLuint divisor)
-{
-}
-
-void VertexArrayGL::enableAttribute(size_t idx, bool enabledState)
-{
-}
-
 gl::Error VertexArrayGL::syncDrawArraysState(const std::vector<GLuint> &activeAttribLocations, GLint first, GLsizei count) const
 {
     return syncDrawState(activeAttribLocations, first, count, GL_NONE, nullptr, nullptr);
@@ -96,7 +75,7 @@ gl::Error VertexArrayGL::syncDrawElementsState(const std::vector<GLuint> &active
 
 gl::Error VertexArrayGL::syncDrawState(const std::vector<GLuint> &activeAttribLocations, GLint first, GLsizei count, GLenum type, const GLvoid *indices, const GLvoid **outIndices) const
 {
-    mStateManager->bindVertexArray(mVertexArrayID, mAppliedElementArrayBuffer);
+    mStateManager->bindVertexArray(mVertexArrayID, getAppliedElementArrayBufferID());
 
     // Check if any attributes need to be streamed, determines if the index range needs to be computed
     bool attributesNeedStreaming = doAttributesNeedStreaming(activeAttribLocations);
@@ -250,12 +229,11 @@ gl::Error VertexArrayGL::syncIndexData(GLsizei count, GLenum type, const GLvoid
     // Need to check the range of indices if attributes need to be streamed
     if (elementArrayBuffer != nullptr)
     {
-        const BufferGL *bufferGL = GetImplAs<BufferGL>(elementArrayBuffer);
-        GLuint elementArrayBufferID = bufferGL->getBufferID();
-        if (elementArrayBufferID != mAppliedElementArrayBuffer)
+        if (elementArrayBuffer != mAppliedElementArrayBuffer.get())
         {
-            mStateManager->bindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementArrayBufferID);
-            mAppliedElementArrayBuffer = elementArrayBufferID;
+            const BufferGL *bufferGL = GetImplAs<BufferGL>(elementArrayBuffer);
+            mStateManager->bindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufferGL->getBufferID());
+            mAppliedElementArrayBuffer.set(elementArrayBuffer);
         }
 
         // Only compute the index range if the attributes also need to be streamed
@@ -291,7 +269,7 @@ gl::Error VertexArrayGL::syncIndexData(GLsizei count, GLenum type, const GLvoid
         }
 
         mStateManager->bindBuffer(GL_ELEMENT_ARRAY_BUFFER, mStreamingElementArrayBuffer);
-        mAppliedElementArrayBuffer = mStreamingElementArrayBuffer;
+        mAppliedElementArrayBuffer.set(nullptr);
 
         // Make sure the element array buffer is large enough
         const gl::Type &indexTypeInfo = gl::GetTypeInfo(type);
@@ -414,7 +392,8 @@ GLuint VertexArrayGL::getVertexArrayID() const
 
 GLuint VertexArrayGL::getAppliedElementArrayBufferID() const
 {
-    return mAppliedElementArrayBuffer;
+    return mAppliedElementArrayBuffer.get() == nullptr ? mStreamingElementArrayBuffer
+                                                       : mAppliedElementArrayBuffer.id();
 }
 
 }

src/libANGLE/renderer/gl/VertexArrayGL.h

@@ -23,11 +23,6 @@ class VertexArrayGL : public VertexArrayImpl
     VertexArrayGL(const gl::VertexArray::Data &data, const FunctionsGL *functions, StateManagerGL *stateManager);
     ~VertexArrayGL() override;
 
-    void setElementArrayBuffer(const gl::Buffer *buffer) override;
-    void setAttribute(size_t idx, const gl::VertexAttribute &attr) override;
-    void setAttributeDivisor(size_t idx, GLuint divisor) override;
-    void enableAttribute(size_t idx, bool enabledState) override;
-
     gl::Error syncDrawArraysState(const std::vector<GLuint> &activeAttribLoations, GLint first, GLsizei count) const;
     gl::Error syncDrawElementsState(const std::vector<GLuint> &activeAttribLoations, GLsizei count, GLenum type,
                                     const GLvoid *indices, const GLvoid **outIndices) const;
@@ -61,7 +56,7 @@ class VertexArrayGL : public VertexArrayImpl
 
     GLuint mVertexArrayID;
 
-    mutable GLuint mAppliedElementArrayBuffer;
+    mutable BindingPointer<gl::Buffer> mAppliedElementArrayBuffer;
     mutable std::vector<gl::VertexAttribute> mAppliedAttributes;
 
     mutable size_t mStreamingElementArrayBufferSize;