VertexArray: Store bound attributes mask in binding.

src/libANGLE/RefCountObject.h

@@ -105,7 +105,10 @@ class BindingPointer
 
     BindingPointer(const BindingPointer<ObjectType> &other) : mObject(other.mObject)
     {
-        mObject->addRef();
+        if (mObject)
+        {
+            mObject->addRef();
+        }
     }
 
     BindingPointer &operator=(BindingPointer<ObjectType> &&other)

src/libANGLE/VertexArray.cpp

@@ -17,14 +17,14 @@ namespace gl
 {
 // VertexArrayState implementation.
 VertexArrayState::VertexArrayState(size_t maxAttribs, size_t maxAttribBindings)
-    : mLabel(), mVertexBindings(maxAttribBindings)
+    : mLabel(), mVertexBindings()
 {
     ASSERT(maxAttribs <= maxAttribBindings);
 
     for (size_t i = 0; i < maxAttribs; i++)
     {
         mVertexAttributes.emplace_back(static_cast<GLuint>(i));
-        mBindingToAttributeMasks[i].set(i);
+        mVertexBindings.emplace_back(static_cast<GLuint>(i));
     }
 
     // Initially all attributes start as "client" with no buffer bound.
@@ -40,10 +40,10 @@ bool VertexArrayState::hasEnabledNullPointerClientArray() const
     return (mNullPointerClientMemoryAttribsMask & mEnabledAttributesMask).any();
 }
 
-AttributesMask VertexArrayState::getBindingToAttributeMasks(GLuint bindingIndex) const
+AttributesMask VertexArrayState::getBindingToAttributesMask(GLuint bindingIndex) const
 {
     ASSERT(bindingIndex < MAX_VERTEX_ATTRIB_BINDINGS);
-    return mBindingToAttributeMasks[bindingIndex];
+    return mVertexBindings[bindingIndex].getBoundAttributesMask();
 }
 
 // Set an attribute using a new binding.
@@ -55,11 +55,11 @@ void VertexArrayState::setAttribBinding(size_t attribIndex, GLuint newBindingInd
     const GLuint oldBindingIndex = mVertexAttributes[attribIndex].bindingIndex;
     ASSERT(oldBindingIndex != newBindingIndex);
 
-    ASSERT(mBindingToAttributeMasks[oldBindingIndex].test(attribIndex) &&
-           !mBindingToAttributeMasks[newBindingIndex].test(attribIndex));
+    ASSERT(mVertexBindings[oldBindingIndex].getBoundAttributesMask().test(attribIndex) &&
+           !mVertexBindings[newBindingIndex].getBoundAttributesMask().test(attribIndex));
 
-    mBindingToAttributeMasks[oldBindingIndex].reset(attribIndex);
-    mBindingToAttributeMasks[newBindingIndex].set(attribIndex);
+    mVertexBindings[oldBindingIndex].resetBoundAttribute(attribIndex);
+    mVertexBindings[newBindingIndex].setBoundAttribute(attribIndex);
 
     // Set the attribute using the new binding.
     mVertexAttributes[attribIndex].bindingIndex = newBindingIndex;
@@ -191,11 +191,11 @@ void VertexArray::bindVertexBufferImpl(const Context *context,
     // Update client memory attribute pointers. Affects all bound attributes.
     if (boundBuffer)
     {
-        mState.mClientMemoryAttribsMask &= ~mState.mBindingToAttributeMasks[bindingIndex];
+        mState.mClientMemoryAttribsMask &= ~binding->getBoundAttributesMask();
     }
     else
     {
-        mState.mClientMemoryAttribsMask |= mState.mBindingToAttributeMasks[bindingIndex];
+        mState.mClientMemoryAttribsMask |= binding->getBoundAttributesMask();
     }
 }
 

src/libANGLE/VertexArray.h

@@ -69,7 +69,7 @@ class VertexArrayState final : angle::NonCopyable
     bool hasEnabledNullPointerClientArray() const;
 
     // Get all the attributes in an AttributesMask that are using the given binding.
-    AttributesMask getBindingToAttributeMasks(GLuint bindingIndex) const;
+    AttributesMask getBindingToAttributesMask(GLuint bindingIndex) const;
 
   private:
     friend class VertexArray;
@@ -86,11 +86,6 @@ class VertexArrayState final : angle::NonCopyable
     // attribs.
     gl::AttributesMask mClientMemoryAttribsMask;
     gl::AttributesMask mNullPointerClientMemoryAttribsMask;
-
-    // Records the mappings from each binding to all of the attributes that are using that binding.
-    // It is used to label all the relevant attributes dirty when we are updating a dirty binding in
-    // VertexArray11::syncStates().
-    std::array<AttributesMask, MAX_VERTEX_ATTRIB_BINDINGS> mBindingToAttributeMasks;
 };
 
 class VertexArray final : public angle::ObserverInterface, public LabeledObject

src/libANGLE/VertexAttribute.cpp

@@ -13,9 +13,14 @@ namespace gl
 
 // [OpenGL ES 3.1] (November 3, 2016) Section 20 Page 361
 // Table 20.2: Vertex Array Object State
-VertexBinding::VertexBinding()
+VertexBinding::VertexBinding() : VertexBinding(0)
+{
+}
+
+VertexBinding::VertexBinding(GLuint boundAttribute)
     : mStride(16u), mDivisor(0), mOffset(0), mCachedBufferSizeMinusOffset(0)
 {
+    mBoundAttributesMask.set(boundAttribute);
 }
 
 VertexBinding::VertexBinding(VertexBinding &&binding)
@@ -34,6 +39,7 @@ VertexBinding &VertexBinding::operator=(VertexBinding &&binding)
         mStride  = binding.mStride;
         mDivisor = binding.mDivisor;
         mOffset  = binding.mOffset;
+        mBoundAttributesMask = binding.mBoundAttributesMask;
         std::swap(binding.mBuffer, mBuffer);
         mCachedBufferSizeMinusOffset = binding.mCachedBufferSizeMinusOffset;
     }

src/libANGLE/VertexAttribute.h

@@ -10,6 +10,7 @@
 #define LIBANGLE_VERTEXATTRIBUTE_H_
 
 #include "libANGLE/Buffer.h"
+#include "libANGLE/angletypes.h"
 
 namespace gl
 {
@@ -23,6 +24,7 @@ class VertexBinding final : angle::NonCopyable
 {
   public:
     VertexBinding();
+    explicit VertexBinding(GLuint boundAttribute);
     VertexBinding(VertexBinding &&binding);
     ~VertexBinding();
     VertexBinding &operator=(VertexBinding &&binding);
@@ -46,9 +48,15 @@ class VertexBinding final : angle::NonCopyable
         return mCachedBufferSizeMinusOffset;
     }
 
+    const AttributesMask &getBoundAttributesMask() const { return mBoundAttributesMask; }
+
     // Called from VertexArray.
     void updateCachedBufferSizeMinusOffset();
 
+    void setBoundAttribute(size_t index) { mBoundAttributesMask.set(index); }
+
+    void resetBoundAttribute(size_t index) { mBoundAttributesMask.reset(index); }
+
   private:
     GLuint mStride;
     GLuint mDivisor;
@@ -56,6 +64,9 @@ class VertexBinding final : angle::NonCopyable
 
     BindingPointer<Buffer> mBuffer;
 
+    // Mapping from this binding to all of the attributes that are using this binding.
+    AttributesMask mBoundAttributesMask;
+
     // This is kept in sync by the VertexArray. It is used to optimize draw call validation.
     GLuint64 mCachedBufferSizeMinusOffset;
 };

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

@@ -43,7 +43,7 @@ void VertexArray11::destroy(const gl::Context *context)
     case gl::VertexArray::DIRTY_BIT_ATTRIB_0 + INDEX:                                     \
         if (attribBits[INDEX][gl::VertexArray::DirtyAttribBitType::DIRTY_ATTRIB_POINTER]) \
         {                                                                                 \
-            attributesToUpdate |= mState.getBindingToAttributeMasks(INDEX);               \
+            attributesToUpdate |= mState.getBindingToAttributesMask(INDEX);               \
         }                                                                                 \
         else                                                                              \
         {                                                                                 \
@@ -54,7 +54,7 @@ void VertexArray11::destroy(const gl::Context *context)
 
 #define ANGLE_VERTEX_DIRTY_BINDING_FUNC(INDEX)                          \
     case gl::VertexArray::DIRTY_BIT_BINDING_0 + INDEX:                  \
-        attributesToUpdate |= mState.getBindingToAttributeMasks(INDEX); \
+        attributesToUpdate |= mState.getBindingToAttributesMask(INDEX); \
         invalidateVertexBuffer = true;                                  \
         break;