GL: Re-enable emulatePrimitiveRestartFixedIndex

include/platform/FeaturesGL.h

@@ -364,6 +364,12 @@ struct FeaturesGL : FeatureSetBase
         "GL_PRIMITIVE_RESTART and glPrimitiveRestartIndex.",
         &members, "http://anglebug.com/3997"};
 
+    Feature setPrimitiveRestartFixedIndexForDrawArrays = {
+        "set_primitive_restart_fixed_index_for_draw_arrays", FeatureCategory::OpenGLWorkarounds,
+        "Some drivers discard vertex data in DrawArrays calls when the fixed primitive restart "
+        "index is within the number of primitives being drawn.",
+        &members, "http://anglebug.com/3997"};
+
     // Dynamic indexing of swizzled l-values doesn't work correctly on various platforms.
     Feature removeDynamicIndexingOfSwizzledVector = {
         "remove_dynamic_indexing_of_swizzled_vector", FeatureCategory::OpenGLWorkarounds,

src/libANGLE/renderer/gl/ContextGL.cpp

@@ -211,6 +211,14 @@ ANGLE_INLINE angle::Result ContextGL::setDrawArraysState(const gl::Context *cont
 #endif  // ANGLE_STATE_VALIDATION_ENABLED
     }
 
+    const angle::FeaturesGL &features = getFeaturesGL();
+    if (features.setPrimitiveRestartFixedIndexForDrawArrays.enabled)
+    {
+        StateManagerGL *stateManager           = getStateManager();
+        constexpr GLuint primitiveRestartIndex = gl::GetPrimitiveRestartIndexFromType<GLuint>();
+        ANGLE_TRY(stateManager->setPrimitiveRestartIndex(context, primitiveRestartIndex));
+    }
+
     return angle::Result::Continue;
 }
 
@@ -244,7 +252,7 @@ ANGLE_INLINE angle::Result ContextGL::setDrawElementsState(const gl::Context *co
         StateManagerGL *stateManager = getStateManager();
 
         GLuint primitiveRestartIndex = gl::GetPrimitiveRestartIndex(type);
-        stateManager->setPrimitiveRestartIndex(primitiveRestartIndex);
+        ANGLE_TRY(stateManager->setPrimitiveRestartIndex(context, primitiveRestartIndex));
     }
 
 #if defined(ANGLE_STATE_VALIDATION_ENABLED)
@@ -694,8 +702,7 @@ angle::Result ContextGL::syncState(const gl::Context *context,
                                    const gl::State::DirtyBits &dirtyBits,
                                    const gl::State::DirtyBits &bitMask)
 {
-    mRenderer->getStateManager()->syncState(context, dirtyBits, bitMask);
-    return angle::Result::Continue;
+    return mRenderer->getStateManager()->syncState(context, dirtyBits, bitMask);
 }
 
 GLint ContextGL::getGPUDisjoint()

src/libANGLE/renderer/gl/StateManagerGL.cpp

@@ -179,6 +179,14 @@ StateManagerGL::StateManagerGL(const FunctionsGL *functions,
             mFunctions->enable(GL_POINT_SPRITE);
         }
     }
+
+    if (features.emulatePrimitiveRestartFixedIndex.enabled)
+    {
+        // There is no consistent default value for primitive restart index. Set it to UINT -1.
+        constexpr GLuint primitiveRestartIndex = gl::GetPrimitiveRestartIndexFromType<GLuint>();
+        mFunctions->primitiveRestartIndex(primitiveRestartIndex);
+        mPrimitiveRestartIndex = primitiveRestartIndex;
+    }
 }
 
 StateManagerGL::~StateManagerGL() {}
@@ -1417,39 +1425,41 @@ void StateManagerGL::setLineWidth(float width)
     }
 }
 
-void StateManagerGL::setPrimitiveRestartEnabled(bool enabled)
+angle::Result StateManagerGL::setPrimitiveRestartEnabled(const gl::Context *context, bool enabled)
 {
     if (mPrimitiveRestartEnabled != enabled)
     {
-        mPrimitiveRestartEnabled = enabled;
-
         GLenum cap = mFeatures.emulatePrimitiveRestartFixedIndex.enabled
                          ? GL_PRIMITIVE_RESTART
                          : GL_PRIMITIVE_RESTART_FIXED_INDEX;
 
-        if (mPrimitiveRestartEnabled)
+        if (enabled)
         {
-            mFunctions->enable(cap);
+            ANGLE_GL_TRY(context, mFunctions->enable(cap));
         }
         else
         {
-            mFunctions->disable(cap);
+            ANGLE_GL_TRY(context, mFunctions->disable(cap));
         }
+        mPrimitiveRestartEnabled = enabled;
 
         mLocalDirtyBits.set(gl::State::DIRTY_BIT_PRIMITIVE_RESTART_ENABLED);
     }
+
+    return angle::Result::Continue;
 }
 
-void StateManagerGL::setPrimitiveRestartIndex(GLuint index)
+angle::Result StateManagerGL::setPrimitiveRestartIndex(const gl::Context *context, GLuint index)
 {
     if (mPrimitiveRestartIndex != index)
     {
+        ANGLE_GL_TRY(context, mFunctions->primitiveRestartIndex(index));
         mPrimitiveRestartIndex = index;
 
-        mFunctions->primitiveRestartIndex(index);
-
         // No dirty bit for this state, it is not exposed to the frontend.
     }
+
+    return angle::Result::Continue;
 }
 
 void StateManagerGL::setClearDepth(float clearDepth)
@@ -1514,16 +1524,16 @@ void StateManagerGL::setClearStencil(GLint clearStencil)
     }
 }
 
-void StateManagerGL::syncState(const gl::Context *context,
-                               const gl::State::DirtyBits &glDirtyBits,
-                               const gl::State::DirtyBits &bitMask)
+angle::Result StateManagerGL::syncState(const gl::Context *context,
+                                        const gl::State::DirtyBits &glDirtyBits,
+                                        const gl::State::DirtyBits &bitMask)
 {
     const gl::State &state = context->getState();
 
     const gl::State::DirtyBits glAndLocalDirtyBits = (glDirtyBits | mLocalDirtyBits) & bitMask;
     if (!glAndLocalDirtyBits.any())
     {
-        return;
+        return angle::Result::Continue;
     }
 
     // TODO(jmadill): Investigate only syncing vertex state for active attributes
@@ -1663,7 +1673,7 @@ void StateManagerGL::syncState(const gl::Context *context,
                 setLineWidth(state.getLineWidth());
                 break;
             case gl::State::DIRTY_BIT_PRIMITIVE_RESTART_ENABLED:
-                setPrimitiveRestartEnabled(state.isPrimitiveRestartEnabled());
+                ANGLE_TRY(setPrimitiveRestartEnabled(context, state.isPrimitiveRestartEnabled()));
                 break;
             case gl::State::DIRTY_BIT_CLEAR_COLOR:
                 setClearColor(state.getColorClearValue());
@@ -1876,6 +1886,8 @@ void StateManagerGL::syncState(const gl::Context *context,
     }
 
     mLocalDirtyBits &= ~(bitMask);
+
+    return angle::Result::Continue;
 }
 
 void StateManagerGL::setFramebufferSRGBEnabled(const gl::Context *context, bool enabled)

src/libANGLE/renderer/gl/StateManagerGL.h

@@ -121,8 +121,8 @@ class StateManagerGL final : angle::NonCopyable
     void setRasterizerDiscardEnabled(bool enabled);
     void setLineWidth(float width);
 
-    void setPrimitiveRestartEnabled(bool enabled);
-    void setPrimitiveRestartIndex(GLuint index);
+    angle::Result setPrimitiveRestartEnabled(const gl::Context *context, bool enabled);
+    angle::Result setPrimitiveRestartIndex(const gl::Context *context, GLuint index);
 
     void setClearColor(const gl::ColorF &clearColor);
     void setClearDepth(float clearDepth);
@@ -159,9 +159,9 @@ class StateManagerGL final : angle::NonCopyable
     angle::Result resumeQuery(const gl::Context *context, gl::QueryType type);
     angle::Result onMakeCurrent(const gl::Context *context);
 
-    void syncState(const gl::Context *context,
-                   const gl::State::DirtyBits &glDirtyBits,
-                   const gl::State::DirtyBits &bitMask);
+    angle::Result syncState(const gl::Context *context,
+                            const gl::State::DirtyBits &glDirtyBits,
+                            const gl::State::DirtyBits &bitMask);
 
     ANGLE_INLINE void updateMultiviewBaseViewLayerIndexUniform(
         const gl::Program *program,

src/libANGLE/renderer/gl/renderergl_utils.cpp

@@ -1657,6 +1657,12 @@ void InitializeFeatures(const FunctionsGL *functions, angle::FeaturesGL *feature
 
     ANGLE_FEATURE_CONDITION(features, unfoldShortCircuits, IsApple());
 
+    ANGLE_FEATURE_CONDITION(
+        features, emulatePrimitiveRestartFixedIndex,
+        functions->standard == STANDARD_GL_DESKTOP && !functions->isAtLeastGL(gl::Version(4, 3)));
+    ANGLE_FEATURE_CONDITION(features, setPrimitiveRestartFixedIndexForDrawArrays,
+                            IsApple() && isIntel);
+
     ANGLE_FEATURE_CONDITION(features, removeDynamicIndexingOfSwizzledVector,
                             IsApple() || IsAndroid() || IsWindows());