GL: Support VAOs without native VAOs.

include/platform/FeaturesGL.h

@@ -529,6 +529,12 @@ struct FeaturesGL : FeatureSetBase
         "shift_instanced_array_data_with_offset", FeatureCategory::OpenGLWorkarounds,
         "glDrawArraysInstanced is buggy on certain new Mac Intel GPUs", &members,
         "http://crbug.com/1144207"};
+
+    // ANGLE needs to support devices that have no native VAOs. Sync everything to the default VAO.
+    Feature syncVertexArraysToDefault = {
+        "sync_vertex_arrays_to_default", FeatureCategory::OpenGLWorkarounds,
+        "Only use the default VAO because of missing support or driver bugs", &members,
+        "http://anglebug.com/5577"};
 };
 
 inline FeaturesGL::FeaturesGL()  = default;

src/libANGLE/renderer/gl/BlitGL.cpp

@@ -256,9 +256,10 @@ BlitGL::~BlitGL()
         mScratchFBO = 0;
     }
 
-    if (mVAO != 0)
+    if (mOwnsVAOState)
     {
         mStateManager->deleteVertexArray(mVAO);
+        SafeDelete(mVAOState);
         mVAO = 0;
     }
 }
@@ -365,7 +366,7 @@ angle::Result BlitGL::copySubImageToLUMAWorkaroundTexture(const gl::Context *con
     ANGLE_GL_TRY(context, mFunctions->uniform1i(blitProgram->multiplyAlphaLocation, 0));
     ANGLE_GL_TRY(context, mFunctions->uniform1i(blitProgram->unMultiplyAlphaLocation, 0));
 
-    mStateManager->bindVertexArray(mVAO, 0);
+    ANGLE_TRY(setVAOState(context));
     ANGLE_GL_TRY(context, mFunctions->drawArrays(GL_TRIANGLES, 0, 3));
 
     // Copy the swizzled texture to the destination texture
@@ -548,7 +549,7 @@ angle::Result BlitGL::blitColorBufferWithShader(const gl::Context *context,
 
     mStateManager->bindFramebuffer(GL_DRAW_FRAMEBUFFER, destFramebuffer);
 
-    mStateManager->bindVertexArray(mVAO, 0);
+    ANGLE_TRY(setVAOState(context));
     ANGLE_GL_TRY(context, mFunctions->drawArrays(GL_TRIANGLES, 0, 3));
 
     ANGLE_TRY(scopedState.exit(context));
@@ -663,7 +664,7 @@ angle::Result BlitGL::copySubTexture(const gl::Context *context,
                                                     unpackUnmultiplyAlpha));
     }
 
-    mStateManager->bindVertexArray(mVAO, 0);
+    ANGLE_TRY(setVAOState(context));
     ANGLE_GL_TRY(context, mFunctions->drawArrays(GL_TRIANGLES, 0, 3));
 
     *copySucceededOut = true;
@@ -1075,7 +1076,7 @@ angle::Result BlitGL::generateSRGBMipmap(const gl::Context *context,
     mStateManager->bindTexture(sourceType, source->getTextureID());
     ANGLE_TRY(source->setMinFilter(context, GL_NEAREST));
 
-    mStateManager->bindVertexArray(mVAO, 0);
+    ANGLE_TRY(setVAOState(context));
     ANGLE_GL_TRY(context, mFunctions->drawArrays(GL_TRIANGLES, 0, 3));
 
     // Generate mipmaps on the linear texture
@@ -1133,21 +1134,21 @@ angle::Result BlitGL::initializeResources(const gl::Context *context)
     ANGLE_GL_TRY(context, mFunctions->bufferData(GL_ARRAY_BUFFER, sizeof(float) * 6, vertexData,
                                                  GL_STATIC_DRAW));
 
-    ANGLE_GL_TRY(context, mFunctions->genVertexArrays(1, &mVAO));
-
-    mStateManager->bindVertexArray(mVAO, 0);
-    mStateManager->bindBuffer(gl::BufferBinding::Array, mVertexBuffer);
-
-    // Enable all attributes with the same buffer so that it doesn't matter what location the
-    // texcoord attribute is assigned
-    GLint maxAttributes = 0;
-    ANGLE_GL_TRY(context, mFunctions->getIntegerv(GL_MAX_VERTEX_ATTRIBS, &maxAttributes));
-
-    for (GLint i = 0; i < maxAttributes; i++)
+    VertexArrayStateGL *defaultVAOState = mStateManager->getDefaultVAOState();
+    if (!mFeatures.syncVertexArraysToDefault.enabled)
     {
-        ANGLE_GL_TRY(context, mFunctions->enableVertexAttribArray(i));
-        ANGLE_GL_TRY(context,
-                     mFunctions->vertexAttribPointer(i, 2, GL_FLOAT, GL_FALSE, 0, nullptr));
+        ANGLE_GL_TRY(context, mFunctions->genVertexArrays(1, &mVAO));
+        mVAOState     = new VertexArrayStateGL(defaultVAOState->attributes.size(),
+                                           defaultVAOState->bindings.size());
+        mOwnsVAOState = true;
+        ANGLE_TRY(setVAOState(context));
+        ANGLE_TRY(initializeVAOState(context));
+    }
+    else
+    {
+        mVAO          = mStateManager->getDefaultVAO();
+        mVAOState     = defaultVAOState;
+        mOwnsVAOState = false;
     }
 
     constexpr GLenum potentialSRGBMipmapGenerationFormats[] = {
@@ -1227,6 +1228,43 @@ angle::Result BlitGL::setScratchTextureParameter(const gl::Context *context,
     return angle::Result::Continue;
 }
 
+angle::Result BlitGL::setVAOState(const gl::Context *context)
+{
+    mStateManager->bindVertexArray(mVAO, mVAOState);
+    if (mFeatures.syncVertexArraysToDefault.enabled)
+    {
+        ANGLE_TRY(initializeVAOState(context));
+    }
+
+    return angle::Result::Continue;
+}
+
+angle::Result BlitGL::initializeVAOState(const gl::Context *context)
+{
+    mStateManager->bindBuffer(gl::BufferBinding::Array, mVertexBuffer);
+
+    ANGLE_GL_TRY(context, mFunctions->enableVertexAttribArray(mTexcoordAttribLocation));
+    ANGLE_GL_TRY(context, mFunctions->vertexAttribPointer(mTexcoordAttribLocation, 2, GL_FLOAT,
+                                                          GL_FALSE, 0, nullptr));
+
+    VertexAttributeGL &attribute = mVAOState->attributes[mTexcoordAttribLocation];
+    attribute.enabled            = true;
+    attribute.format             = &angle::Format::Get(angle::FormatID::R32G32_FLOAT);
+    attribute.pointer            = nullptr;
+
+    VertexBindingGL &binding = mVAOState->bindings[mTexcoordAttribLocation];
+    binding.stride           = 8;
+    binding.offset           = 0;
+    binding.buffer           = mVertexBuffer;
+
+    if (mFeatures.syncVertexArraysToDefault.enabled)
+    {
+        mStateManager->setDefaultVAOStateDirty();
+    }
+
+    return angle::Result::Continue;
+}
+
 angle::Result BlitGL::getBlitProgram(const gl::Context *context,
                                      gl::TextureType sourceTextureType,
                                      GLenum sourceComponentType,
@@ -1242,6 +1280,7 @@ angle::Result BlitGL::getBlitProgram(const gl::Context *context,
 
         // Depending on what types need to be output by the shaders, different versions need to be
         // used.
+        constexpr const char *texcoordAttribName = "a_texcoord";
         std::string version;
         std::string vsInputVariableQualifier;
         std::string vsOutputVariableQualifier;
@@ -1282,15 +1321,17 @@ angle::Result BlitGL::getBlitProgram(const gl::Context *context,
             // Compile the vertex shader
             std::ostringstream vsSourceStream;
             vsSourceStream << "#version " << version << "\n";
-            vsSourceStream << vsInputVariableQualifier << " vec2 a_texcoord;\n";
+            vsSourceStream << vsInputVariableQualifier << " vec2 " << texcoordAttribName << ";\n";
             vsSourceStream << "uniform vec2 u_scale;\n";
             vsSourceStream << "uniform vec2 u_offset;\n";
             vsSourceStream << vsOutputVariableQualifier << " vec2 v_texcoord;\n";
             vsSourceStream << "\n";
             vsSourceStream << "void main()\n";
             vsSourceStream << "{\n";
-            vsSourceStream << "    gl_Position = vec4((a_texcoord * 2.0) - 1.0, 0.0, 1.0);\n";
-            vsSourceStream << "    v_texcoord = a_texcoord * u_scale + u_offset;\n";
+            vsSourceStream << "    gl_Position = vec4((" << texcoordAttribName
+                           << " * 2.0) - 1.0, 0.0, 1.0);\n";
+            vsSourceStream << "    v_texcoord = " << texcoordAttribName
+                           << " * u_scale + u_offset;\n";
             vsSourceStream << "}\n";
 
             std::string vsSourceStr  = vsSourceStream.str();
@@ -1477,6 +1518,8 @@ angle::Result BlitGL::getBlitProgram(const gl::Context *context,
             ANGLE_GL_TRY(context, mFunctions->deleteShader(fs));
         }
 
+        ANGLE_GL_TRY(context, mFunctions->bindAttribLocation(
+                                  result.program, mTexcoordAttribLocation, texcoordAttribName));
         ANGLE_GL_TRY(context, mFunctions->linkProgram(result.program));
         ANGLE_TRY(CheckLinkStatus(context, mFunctions, result.program));
 

src/libANGLE/renderer/gl/BlitGL.h

@@ -36,6 +36,7 @@ class FunctionsGL;
 class RenderbufferGL;
 class StateManagerGL;
 class TextureGL;
+struct VertexArrayStateGL;
 
 class BlitGL : angle::NonCopyable
 {
@@ -168,6 +169,8 @@ class BlitGL : angle::NonCopyable
     angle::Result setScratchTextureParameter(const gl::Context *context,
                                              GLenum param,
                                              GLenum value);
+    angle::Result setVAOState(const gl::Context *context);
+    angle::Result initializeVAOState(const gl::Context *context);
 
     const FunctionsGL *mFunctions;
     const angle::FeaturesGL &mFeatures;
@@ -195,11 +198,15 @@ class BlitGL : angle::NonCopyable
     using BlitProgramType = std::tuple<gl::TextureType, GLenum, GLenum>;
     std::map<BlitProgramType, BlitProgram> mBlitPrograms;
 
-    GLuint mScratchTextures[2];
-    GLuint mScratchFBO;
+    GLuint mScratchTextures[2] = {0};
+    GLuint mScratchFBO         = 0;
 
-    GLuint mVAO;
-    GLuint mVertexBuffer;
+    GLuint mVAO                   = 0;
+    VertexArrayStateGL *mVAOState = nullptr;
+    bool mOwnsVAOState            = false;
+
+    const GLuint mTexcoordAttribLocation = 0;
+    GLuint mVertexBuffer                 = 0;
 
     nativegl::TexImageFormat mSRGBMipmapGenerationFormat;
 };

src/libANGLE/renderer/gl/ContextGL.cpp

@@ -115,12 +115,23 @@ BufferImpl *ContextGL::createBuffer(const gl::BufferState &state)
 
 VertexArrayImpl *ContextGL::createVertexArray(const gl::VertexArrayState &data)
 {
-    const FunctionsGL *functions = getFunctions();
+    const angle::FeaturesGL &features = getFeaturesGL();
+
+    if (features.syncVertexArraysToDefault.enabled)
+    {
+        StateManagerGL *stateManager = getStateManager();
 
-    GLuint vao = 0;
-    functions->genVertexArrays(1, &vao);
+        return new VertexArrayGL(data, stateManager->getDefaultVAO(),
+                                 stateManager->getDefaultVAOState());
+    }
+    else
+    {
+        const FunctionsGL *functions = getFunctions();
 
-    return new VertexArrayGL(data, vao);
+        GLuint vao = 0;
+        functions->genVertexArrays(1, &vao);
+        return new VertexArrayGL(data, vao);
+    }
 }
 
 QueryImpl *ContextGL::createQuery(gl::QueryType type)

src/libANGLE/renderer/gl/StateManagerGL.cpp

@@ -56,6 +56,17 @@ static void ValidateStateHelper(const FunctionsGL *functions,
 
 }  // anonymous namespace
 
+VertexArrayStateGL::VertexArrayStateGL(size_t maxAttribs, size_t maxBindings)
+    : attributes(std::min<size_t>(maxAttribs, gl::MAX_VERTEX_ATTRIBS)),
+      bindings(std::min<size_t>(maxBindings, gl::MAX_VERTEX_ATTRIBS))
+{
+    // Set the cached vertex attribute array and vertex attribute binding array size
+    for (GLuint i = 0; i < attributes.size(); i++)
+    {
+        attributes[i].bindingIndex = i;
+    }
+}
+
 StateManagerGL::IndexedBufferBinding::IndexedBufferBinding() : offset(0), size(0), buffer(0) {}
 
 StateManagerGL::StateManagerGL(const FunctionsGL *functions,
@@ -67,6 +78,8 @@ StateManagerGL::StateManagerGL(const FunctionsGL *functions,
       mProgram(0),
       mVAO(0),
       mVertexAttribCurrentValues(rendererCaps.maxVertexAttributes),
+      mDefaultVAOState(rendererCaps.maxVertexAttributes, rendererCaps.maxVertexAttribBindings),
+      mVAOState(&mDefaultVAOState),
       mBuffers(),
       mIndexedBuffers(),
       mTextureUnitIndex(0),
@@ -182,9 +195,26 @@ StateManagerGL::StateManagerGL(const FunctionsGL *functions,
         mFunctions->primitiveRestartIndex(primitiveRestartIndex);
         mPrimitiveRestartIndex = primitiveRestartIndex;
     }
+
+    // It's possible we've enabled the emulated VAO feature for testing but we're on a core profile.
+    // Use a generated VAO as the default VAO so we can still test.
+    if (features.syncVertexArraysToDefault.enabled &&
+        !nativegl::CanUseDefaultVertexArrayObject(mFunctions))
+    {
+        ASSERT(nativegl::SupportsVertexArrayObjects(mFunctions));
+        mFunctions->genVertexArrays(1, &mDefaultVAO);
+        mFunctions->bindVertexArray(mDefaultVAO);
+        mVAO = mDefaultVAO;
+    }
 }
 
-StateManagerGL::~StateManagerGL() {}
+StateManagerGL::~StateManagerGL()
+{
+    if (mDefaultVAO != 0)
+    {
+        mFunctions->deleteVertexArrays(1, &mDefaultVAO);
+    }
+}
 
 void StateManagerGL::deleteProgram(GLuint program)
 {
@@ -205,7 +235,7 @@ void StateManagerGL::deleteVertexArray(GLuint vao)
     {
         if (mVAO == vao)
         {
-            bindVertexArray(0, 0);
+            bindVertexArray(0, &mDefaultVAOState);
         }
         mFunctions->deleteVertexArrays(1, &vao);
     }
@@ -281,6 +311,22 @@ void StateManagerGL::deleteBuffer(GLuint buffer)
         }
     }
 
+    if (mVAOState)
+    {
+        if (mVAOState->elementArrayBuffer == buffer)
+        {
+            mVAOState->elementArrayBuffer = 0;
+        }
+
+        for (VertexBindingGL &binding : mVAOState->bindings)
+        {
+            if (binding.buffer == buffer)
+            {
+                binding.buffer = 0;
+            }
+        }
+    }
+
     mFunctions->deleteBuffers(1, &buffer);
 }
 
@@ -360,12 +406,17 @@ void StateManagerGL::forceUseProgram(GLuint program)
     mLocalDirtyBits.set(gl::State::DIRTY_BIT_PROGRAM_BINDING);
 }
 
-void StateManagerGL::bindVertexArray(GLuint vao, GLuint elementArrayBuffer)
+void StateManagerGL::bindVertexArray(GLuint vao, VertexArrayStateGL *vaoState)
 {
+    ASSERT(vaoState);
     if (mVAO != vao)
     {
+        ASSERT(!mFeatures.syncVertexArraysToDefault.enabled);
+
         mVAO                                      = vao;
-        mBuffers[gl::BufferBinding::ElementArray] = elementArrayBuffer;
+        mVAOState                                 = vaoState;
+        mBuffers[gl::BufferBinding::ElementArray] = vaoState ? vaoState->elementArrayBuffer : 0;
+
         mFunctions->bindVertexArray(vao);
 
         mLocalDirtyBits.set(gl::State::DIRTY_BIT_VERTEX_ARRAY_BINDING);
@@ -1957,11 +2008,37 @@ angle::Result StateManagerGL::syncState(const gl::Context *context,
                 break;
             case gl::State::DIRTY_BIT_VERTEX_ARRAY_BINDING:
             {
-                const VertexArrayGL *vaoGL = GetImplAs<VertexArrayGL>(state.getVertexArray());
-                bindVertexArray(vaoGL->getVertexArrayID(), vaoGL->getAppliedElementArrayBufferID());
+                VertexArrayGL *vaoGL = GetImplAs<VertexArrayGL>(state.getVertexArray());
+                bindVertexArray(vaoGL->getVertexArrayID(), vaoGL->getNativeState());
 
                 propagateProgramToVAO(context, state.getProgram(),
                                       GetImplAs<VertexArrayGL>(state.getVertexArray()));
+
+                if (mFeatures.syncVertexArraysToDefault.enabled)
+                {
+                    // Re-sync the vertex array because all frontend VAOs share the same backend
+                    // state. Only sync bits that can be set in ES2.0 or 3.0
+                    gl::VertexArray::DirtyBits dirtyBits;
+                    gl::VertexArray::DirtyAttribBitsArray dirtyAttribBits;
+                    gl::VertexArray::DirtyBindingBitsArray dirtBindingBits;
+
+                    dirtyBits.set(gl::VertexArray::DIRTY_BIT_ELEMENT_ARRAY_BUFFER);
+                    for (size_t attrib = 0; attrib < mDefaultVAOState.attributes.size(); attrib++)
+                    {
+                        dirtyBits.set(gl::VertexArray::DIRTY_BIT_ATTRIB_0 + attrib);
+                        dirtyAttribBits[attrib].set(gl::VertexArray::DIRTY_ATTRIB_ENABLED);
+                        dirtyAttribBits[attrib].set(gl::VertexArray::DIRTY_ATTRIB_POINTER);
+                        dirtyAttribBits[attrib].set(gl::VertexArray::DIRTY_ATTRIB_POINTER_BUFFER);
+                    }
+                    for (size_t binding = 0; binding < mDefaultVAOState.bindings.size(); binding++)
+                    {
+                        dirtyBits.set(gl::VertexArray::DIRTY_BIT_BINDING_0 + binding);
+                        dirtBindingBits[binding].set(gl::VertexArray::DIRTY_BINDING_DIVISOR);
+                    }
+
+                    ANGLE_TRY(
+                        vaoGL->syncState(context, dirtyBits, &dirtyAttribBits, &dirtBindingBits));
+                }
                 break;
             }
             case gl::State::DIRTY_BIT_DRAW_INDIRECT_BUFFER_BINDING:
@@ -2422,6 +2499,16 @@ void StateManagerGL::syncTransformFeedbackState(const gl::Context *context)
     }
 }
 
+GLuint StateManagerGL::getDefaultVAO() const
+{
+    return mDefaultVAO;
+}
+
+VertexArrayStateGL *StateManagerGL::getDefaultVAOState()
+{
+    return &mDefaultVAOState;
+}
+
 void StateManagerGL::validateState() const
 {
     // Current program
@@ -3070,4 +3157,9 @@ void StateManagerGL::restoreVertexArraysNativeContext(const gl::Extensions &exte
     bindVertexArray(state->vertexArrayBinding, 0);
 }
 
+void StateManagerGL::setDefaultVAOStateDirty()
+{
+    mLocalDirtyBits.set(gl::State::DIRTY_BIT_VERTEX_ARRAY_BINDING);
+}
+
 }  // namespace rx

src/libANGLE/renderer/gl/StateManagerGL.h

@@ -115,6 +115,36 @@ struct ExternalContextState
     GLenum vertexArrayBinding;
 };
 
+struct VertexAttributeGL
+{
+    bool enabled                = false;
+    const angle::Format *format = &angle::Format::Get(angle::FormatID::R32G32B32A32_FLOAT);
+
+    const void *pointer   = nullptr;
+    GLuint relativeOffset = 0;
+
+    GLuint bindingIndex = 0;
+};
+
+struct VertexBindingGL
+{
+    GLuint stride   = 16;
+    GLuint divisor  = 0;
+    GLintptr offset = 0;
+
+    GLuint buffer = 0;
+};
+
+struct VertexArrayStateGL
+{
+    VertexArrayStateGL(size_t maxAttribs, size_t maxBindings);
+
+    GLuint elementArrayBuffer = 0;
+
+    angle::FixedVector<VertexAttributeGL, gl::MAX_VERTEX_ATTRIBS> attributes;
+    angle::FixedVector<VertexBindingGL, gl::MAX_VERTEX_ATTRIBS> bindings;
+};
+
 class StateManagerGL final : angle::NonCopyable
 {
   public:
@@ -135,7 +165,7 @@ class StateManagerGL final : angle::NonCopyable
 
     void useProgram(GLuint program);
     void forceUseProgram(GLuint program);
-    void bindVertexArray(GLuint vao, GLuint elementArrayBuffer);
+    void bindVertexArray(GLuint vao, VertexArrayStateGL *vaoState);
     void bindBuffer(gl::BufferBinding target, GLuint buffer);
     void bindBufferBase(gl::BufferBinding target, size_t index, GLuint buffer);
     void bindBufferRange(gl::BufferBinding target,
@@ -262,6 +292,10 @@ class StateManagerGL final : angle::NonCopyable
 
     bool getHasSeparateFramebufferBindings() const { return mHasSeparateFramebufferBindings; }
 
+    GLuint getDefaultVAO() const;
+    VertexArrayStateGL *getDefaultVAOState();
+    void setDefaultVAOStateDirty();
+
     void validateState() const;
 
     void syncFromNativeContext(const gl::Extensions &extensions, ExternalContextState *state);
@@ -338,6 +372,17 @@ class StateManagerGL final : angle::NonCopyable
     GLuint mVAO;
     std::vector<gl::VertexAttribCurrentValueData> mVertexAttribCurrentValues;
 
+    GLuint mDefaultVAO = 0;
+    // The current state of the default VAO is owned by StateManagerGL. It may be shared between
+    // multiple VertexArrayGL objects if the native driver does not support vertex array objects.
+    // When this object is shared, StateManagerGL forces VertexArrayGL to resynchronize itself every
+    // time a new vertex array is bound.
+    VertexArrayStateGL mDefaultVAOState;
+
+    // The state of the currently bound vertex array object so StateManagerGL can know about the
+    // current element array buffer.
+    VertexArrayStateGL *mVAOState = nullptr;
+
     angle::PackedEnumMap<gl::BufferBinding, GLuint> mBuffers;
 
     struct IndexedBufferBinding

src/libANGLE/renderer/gl/VertexArrayGL.h

@@ -20,11 +20,13 @@ namespace rx
 
 class FunctionsGL;
 class StateManagerGL;
+struct VertexArrayStateGL;
 
 class VertexArrayGL : public VertexArrayImpl
 {
   public:
     VertexArrayGL(const gl::VertexArrayState &data, GLuint id);
+    VertexArrayGL(const gl::VertexArrayState &data, GLuint id, VertexArrayStateGL *sharedState);
     ~VertexArrayGL() override;
 
     void destroy(const gl::Context *context) override;
@@ -44,7 +46,7 @@ class VertexArrayGL : public VertexArrayImpl
                                         const void **outIndices) const;
 
     GLuint getVertexArrayID() const;
-    GLuint getAppliedElementArrayBufferID() const;
+    VertexArrayStateGL *getNativeState() const;
 
     angle::Result syncState(const gl::Context *context,
                             const gl::VertexArray::DirtyBits &dirtyBits,
@@ -123,23 +125,24 @@ class VertexArrayGL : public VertexArrayImpl
         const gl::Context *context,
         gl::AttributesMask *attributeMask) const;
 
-    GLuint mVertexArrayID;
-    int mAppliedNumViews;
+    GLuint mVertexArrayID = 0;
+    int mAppliedNumViews  = 1;
 
     // Remember the program's active attrib location mask so that attributes can be enabled/disabled
     // based on whether they are active in the program
     gl::AttributesMask mProgramActiveAttribLocationsMask;
 
-    mutable gl::BindingPointer<gl::Buffer> mAppliedElementArrayBuffer;
+    bool mOwnsNativeState            = false;
+    VertexArrayStateGL *mNativeState = nullptr;
 
-    mutable std::vector<gl::VertexAttribute> mAppliedAttributes;
-    mutable std::vector<gl::VertexBinding> mAppliedBindings;
+    mutable gl::BindingPointer<gl::Buffer> mElementArrayBuffer;
+    mutable std::array<gl::BindingPointer<gl::Buffer>, gl::MAX_VERTEX_ATTRIBS> mArrayBuffers;
 
-    mutable size_t mStreamingElementArrayBufferSize;
-    mutable GLuint mStreamingElementArrayBuffer;
+    mutable size_t mStreamingElementArrayBufferSize = 0;
+    mutable GLuint mStreamingElementArrayBuffer     = 0;
 
-    mutable size_t mStreamingArrayBufferSize;
-    mutable GLuint mStreamingArrayBuffer;
+    mutable size_t mStreamingArrayBufferSize = 0;
+    mutable GLuint mStreamingArrayBuffer     = 0;
 
     // Used for Mac Intel instanced draw workaround
     mutable gl::AttributesMask mForcedStreamingAttributesForDrawArraysInstancedMask;

src/libANGLE/renderer/gl/renderergl_utils.cpp

@@ -1309,6 +1309,13 @@ void GenerateCaps(const FunctionsGL *functions,
         LimitVersion(maxSupportedESVersion, gl::Version(3, 1));
     }
 
+    if (!nativegl::SupportsVertexArrayObjects(functions) ||
+        features.syncVertexArraysToDefault.enabled)
+    {
+        // ES 3.1 vertex bindings are not emulated on the default vertex array
+        LimitVersion(maxSupportedESVersion, gl::Version(3, 0));
+    }
+
     // Extension support
     extensions->setTextureExtensionSupport(*textureCapsMap);
     extensions->textureCompressionASTCHDRKHR =
@@ -2080,6 +2087,8 @@ void InitializeFeatures(const FunctionsGL *functions, angle::FeaturesGL *feature
     // now.
     ANGLE_FEATURE_CONDITION(features, shiftInstancedArrayDataWithExtraOffset,
                             IsApple() && IsIntel(vendor) && !IsHaswell(device));
+    ANGLE_FEATURE_CONDITION(features, syncVertexArraysToDefault,
+                            !nativegl::SupportsVertexArrayObjects(functions));
 }
 
 void InitializeFrontendFeatures(const FunctionsGL *functions, angle::FrontendFeatures *features)
@@ -2112,6 +2121,20 @@ void ReInitializeFeaturesAtGPUSwitch(const FunctionsGL *functions, angle::Featur
 
 namespace nativegl
 {
+
+bool SupportsVertexArrayObjects(const FunctionsGL *functions)
+{
+    return functions->isAtLeastGLES(gl::Version(3, 0)) ||
+           functions->hasGLESExtension("GL_OES_vertex_array_object") ||
+           functions->isAtLeastGL(gl::Version(3, 0)) ||
+           functions->hasGLExtension("GL_ARB_vertex_array_object");
+}
+
+bool CanUseDefaultVertexArrayObject(const FunctionsGL *functions)
+{
+    return (functions->profile & GL_CONTEXT_CORE_PROFILE_BIT) == 0;
+}
+
 bool SupportsCompute(const FunctionsGL *functions)
 {
     // OpenGL 4.2 is required for GL_ARB_compute_shader, some platform drivers have the extension,

src/libANGLE/renderer/gl/renderergl_utils.h

@@ -113,6 +113,8 @@ void ReInitializeFeaturesAtGPUSwitch(const FunctionsGL *functions, angle::Featur
 
 namespace nativegl
 {
+bool SupportsVertexArrayObjects(const FunctionsGL *functions);
+bool CanUseDefaultVertexArrayObject(const FunctionsGL *functions);
 bool SupportsCompute(const FunctionsGL *functions);
 bool SupportsFenceSync(const FunctionsGL *functions);
 bool SupportsOcclusionQueries(const FunctionsGL *functions);

src/tests/gl_tests/VertexAttributeTest.cpp

@@ -3631,6 +3631,15 @@ void main()
     }
 }
 
+// VAO emulation fails on Mac but is not used on Mac in the wild. http://anglebug.com/5577
+#if !defined(__APPLE__)
+#    define EMULATED_VAO_CONFIGS                                          \
+        WithEmulatedVAOs(ES2_OPENGL()), WithEmulatedVAOs(ES2_OPENGLES()), \
+            WithEmulatedVAOs(ES3_OPENGL()), WithEmulatedVAOs(ES3_OPENGLES()),
+#else
+#    define EMULATED_VAO_CONFIGS
+#endif
+
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these
 // tests should be run against.
 // D3D11 Feature Level 9_3 uses different D3D formats for vertex attribs compared to Feature Levels
@@ -3642,7 +3651,8 @@ ANGLE_INSTANTIATE_TEST_ES2_AND_ES3_AND(
                                              /* cheapRenderPass */ true),
     WithMetalMemoryBarrierAndCheapRenderPass(ES3_METAL(),
                                              /* hasBarrier */ false,
-                                             /* cheapRenderPass */ false));
+                                             /* cheapRenderPass */ false),
+    EMULATED_VAO_CONFIGS);
 
 ANGLE_INSTANTIATE_TEST_ES2_AND_ES3_AND(
     VertexAttributeOORTest,

src/tests/test_utils/angle_test_configs.cpp

@@ -268,6 +268,11 @@ std::ostream &operator<<(std::ostream &stream, const PlatformParameters &pp)
         stream << "_NoVulkanViewportFlip";
     }
 
+    if (pp.eglParameters.emulatedVAOs == EGL_TRUE)
+    {
+        stream << "_EmulatedVAOs";
+    }
+
     return stream;
 }
 

src/tests/test_utils/angle_test_configs.h

@@ -289,6 +289,14 @@ inline PlatformParameters WithNoVulkanViewportFlip(const PlatformParameters &par
     withoutVulkanViewportFlip.eglParameters.supportsVulkanViewportFlip = EGL_FALSE;
     return withoutVulkanViewportFlip;
 }
+
+inline PlatformParameters WithEmulatedVAOs(const PlatformParameters &params)
+{
+    PlatformParameters emualtedVAOParams         = params;
+    emualtedVAOParams.eglParameters.emulatedVAOs = EGL_TRUE;
+    return emualtedVAOParams;
+}
+
 }  // namespace angle
 
 #endif  // ANGLE_TEST_CONFIGS_H_

util/EGLPlatformParameters.h

@@ -64,7 +64,7 @@ struct EGLPlatformParameters
                         shaderStencilOutputFeature, genMultipleMipsPerPassFeature, platformMethods,
                         robustness, emulatedPrerotation, asyncCommandQueueFeatureVulkan,
                         hasExplicitMemBarrierFeatureMtl, hasCheapRenderPassFeatureMtl,
-                        forceBufferGPUStorageFeatureMtl, supportsVulkanViewportFlip);
+                        forceBufferGPUStorageFeatureMtl, supportsVulkanViewportFlip, emulatedVAOs);
     }
 
     EGLint renderer                               = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
@@ -86,6 +86,7 @@ struct EGLPlatformParameters
     EGLint hasCheapRenderPassFeatureMtl           = EGL_DONT_CARE;
     EGLint forceBufferGPUStorageFeatureMtl        = EGL_DONT_CARE;
     EGLint supportsVulkanViewportFlip             = EGL_DONT_CARE;
+    EGLint emulatedVAOs                           = EGL_DONT_CARE;
     angle::PlatformMethods *platformMethods       = nullptr;
 };
 

util/EGLWindow.cpp

@@ -263,6 +263,11 @@ bool EGLWindow::initializeDisplay(OSWindow *osWindow,
         enabledFeatureOverrides.push_back("force_buffer_gpu_storage_mtl");
     }
 
+    if (params.emulatedVAOs == EGL_TRUE)
+    {
+        enabledFeatureOverrides.push_back("sync_vertex_arrays_to_default");
+    }
+
     const bool hasFeatureControlANGLE =
         strstr(extensionString, "EGL_ANGLE_feature_control") != nullptr;