OpenGL: Implement OES_draw_buffers_indexed

include/platform/FeaturesGL.h

@@ -426,6 +426,12 @@ struct FeaturesGL : FeatureSetBase
         "avoid_dxt1_srgb_texture_format", FeatureCategory::OpenGLWorkarounds,
         "Replaces DXT1 sRGB with DXT1 sRGB Alpha as a driver bug workaround.", &members};
 
+    // Bugs exist in OpenGL AMD drivers on Windows that produce incorrect pipeline state for
+    // colorMaski calls.
+    Feature disableDrawBuffersIndexed = {"disable_draw_buffers_indexed",
+                                         FeatureCategory::OpenGLWorkarounds,
+                                         "Disable OES_draw_buffers_indexed extension.", &members};
+
     // GL_EXT_semaphore_fd doesn't work properly with Mesa 19.3.4 and earlier versions.
     Feature disableSemaphoreFd = {"disable_semaphore_fd", FeatureCategory::OpenGLWorkarounds,
                                   "Disable GL_EXT_semaphore_fd extension", &members,

src/libANGLE/State.cpp

@@ -388,6 +388,7 @@ void State::initialize(Context *context)
     const Version &clientVersion       = context->getClientVersion();
 
     mMaxDrawBuffers               = static_cast<GLuint>(caps.maxDrawBuffers);
+    mBlendStateExt                = BlendStateExt(mMaxDrawBuffers);
     mMaxCombinedTextureImageUnits = static_cast<GLuint>(caps.maxCombinedTextureImageUnits);
 
     setColorClearValue(0.0f, 0.0f, 0.0f, 0.0f);
@@ -706,6 +707,8 @@ void State::setColorMask(bool red, bool green, bool blue, bool alpha)
         blendState.colorMaskBlue  = blue;
         blendState.colorMaskAlpha = alpha;
     }
+
+    mBlendStateExt.setColorMask(red, green, blue, alpha);
     mDirtyBits.set(DIRTY_BIT_COLOR_MASK);
 }
 
@@ -716,6 +719,8 @@ void State::setColorMaskIndexed(bool red, bool green, bool blue, bool alpha, GLu
     mBlendStateArray[index].colorMaskGreen = green;
     mBlendStateArray[index].colorMaskBlue  = blue;
     mBlendStateArray[index].colorMaskAlpha = alpha;
+
+    mBlendStateExt.setColorMaskIndexed(index, red, green, blue, alpha);
     mDirtyBits.set(DIRTY_BIT_COLOR_MASK);
 }
 
@@ -814,7 +819,7 @@ void State::setBlend(bool enabled)
     {
         blendState.blend = enabled;
     }
-    enabled ? mBlendEnabledDrawBuffers.set() : mBlendEnabledDrawBuffers.reset();
+    mBlendStateExt.setEnabled(enabled);
     mDirtyBits.set(DIRTY_BIT_BLEND_ENABLED);
 }
 
@@ -822,7 +827,7 @@ void State::setBlendIndexed(bool enabled, GLuint index)
 {
     ASSERT(index < mBlendStateArray.size());
     mBlendStateArray[index].blend = enabled;
-    mBlendEnabledDrawBuffers.set(index, enabled);
+    mBlendStateExt.setEnabledIndexed(index, enabled);
     mDirtyBits.set(DIRTY_BIT_BLEND_ENABLED);
 }
 
@@ -856,6 +861,8 @@ void State::setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha
             mBlendFuncConstantAlphaDrawBuffers.reset();
         }
     }
+
+    mBlendStateExt.setFactors(sourceRGB, destRGB, sourceAlpha, destAlpha);
     mDirtyBits.set(DIRTY_BIT_BLEND_FUNCS);
 }
 
@@ -876,6 +883,8 @@ void State::setBlendFactorsIndexed(GLenum sourceRGB,
         mBlendFuncConstantColorDrawBuffers.set(index, hasConstantColor(sourceRGB, destRGB));
         mBlendFuncConstantAlphaDrawBuffers.set(index, hasConstantAlpha(sourceRGB, destRGB));
     }
+
+    mBlendStateExt.setFactorsIndexed(index, sourceRGB, destRGB, sourceAlpha, destAlpha);
     mDirtyBits.set(DIRTY_BIT_BLEND_FUNCS);
 }
 
@@ -909,6 +918,8 @@ void State::setBlendEquation(GLenum rgbEquation, GLenum alphaEquation)
         blendState.blendEquationRGB   = rgbEquation;
         blendState.blendEquationAlpha = alphaEquation;
     }
+
+    mBlendStateExt.setEquations(rgbEquation, alphaEquation);
     mDirtyBits.set(DIRTY_BIT_BLEND_EQUATIONS);
 }
 
@@ -917,6 +928,8 @@ void State::setBlendEquationIndexed(GLenum rgbEquation, GLenum alphaEquation, GL
     ASSERT(index < mBlendStateArray.size());
     mBlendStateArray[index].blendEquationRGB   = rgbEquation;
     mBlendStateArray[index].blendEquationAlpha = alphaEquation;
+
+    mBlendStateExt.setEquationsIndexed(index, rgbEquation, alphaEquation);
     mDirtyBits.set(DIRTY_BIT_BLEND_EQUATIONS);
 }
 

src/libANGLE/State.h

@@ -172,7 +172,7 @@ class State : angle::NonCopyable
         ASSERT(index < mBlendStateArray.size());
         return mBlendStateArray[index].blend;
     }
-    DrawBufferMask getBlendEnabledDrawBufferMask() const { return mBlendEnabledDrawBuffers; }
+    DrawBufferMask getBlendEnabledDrawBufferMask() const { return mBlendStateExt.mEnabledMask; }
     void setBlend(bool enabled);
     void setBlendIndexed(bool enabled, GLuint index);
     void setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha);
@@ -764,12 +764,12 @@ class State : angle::NonCopyable
 
     bool hasConstantAlphaBlendFunc() const
     {
-        return (mBlendFuncConstantAlphaDrawBuffers & mBlendEnabledDrawBuffers).any();
+        return (mBlendFuncConstantAlphaDrawBuffers & mBlendStateExt.mEnabledMask).any();
     }
 
     bool hasSimultaneousConstantColorAndAlphaBlendFunc() const
     {
-        return (mBlendFuncConstantColorDrawBuffers & mBlendEnabledDrawBuffers).any() &&
+        return (mBlendFuncConstantColorDrawBuffers & mBlendStateExt.mEnabledMask).any() &&
                hasConstantAlphaBlendFunc();
     }
 
@@ -780,6 +780,8 @@ class State : angle::NonCopyable
 
     bool isEarlyFragmentTestsOptimizationAllowed() const { return isSampleCoverageEnabled(); }
 
+    const BlendStateExt &getBlendStateExt() const { return mBlendStateExt; }
+
   private:
     friend class Context;
 
@@ -875,6 +877,7 @@ class State : angle::NonCopyable
     Rectangle mScissor;
 
     BlendStateArray mBlendStateArray;
+    BlendStateExt mBlendStateExt;
     ColorF mBlendColor;
     bool mSampleAlphaToCoverage;
     bool mSampleCoverage;
@@ -1002,7 +1005,6 @@ class State : angle::NonCopyable
     const OverlayType *mOverlay;
 
     // OES_draw_buffers_indexed
-    DrawBufferMask mBlendEnabledDrawBuffers;
     DrawBufferMask mBlendFuncConstantAlphaDrawBuffers;
     DrawBufferMask mBlendFuncConstantColorDrawBuffers;
     bool mNoSimultaneousConstantColorAndAlphaBlendFunc;

src/libANGLE/renderer/gl/StateManagerGL.h

@@ -89,12 +89,10 @@ class StateManagerGL final : angle::NonCopyable
     void setDepthRange(float near, float far);
 
     void setBlendEnabled(bool enabled);
+    void setBlendEnabledIndexed(const gl::DrawBufferMask blendEnabledMask);
     void setBlendColor(const gl::ColorF &blendColor);
-    void setBlendFuncs(GLenum sourceBlendRGB,
-                       GLenum destBlendRGB,
-                       GLenum sourceBlendAlpha,
-                       GLenum destBlendAlpha);
-    void setBlendEquations(GLenum blendEquationRGB, GLenum blendEquationAlpha);
+    void setBlendFuncs(const gl::BlendStateExt &blendStateExt);
+    void setBlendEquations(const gl::BlendStateExt &blendStateExt);
     void setColorMask(bool red, bool green, bool blue, bool alpha);
     void setSampleAlphaToCoverageEnabled(bool enabled);
     void setSampleCoverageEnabled(bool enabled);
@@ -137,11 +135,8 @@ class StateManagerGL final : angle::NonCopyable
     void setFramebufferSRGBEnabledForFramebuffer(const gl::Context *context,
                                                  bool enabled,
                                                  const FramebufferGL *framebuffer);
-    void setColorMaskForFramebuffer(bool red,
-                                    bool green,
-                                    bool blue,
-                                    bool alpha,
-                                    const FramebufferGL *framebuffer);
+    void setColorMaskForFramebuffer(const gl::BlendStateExt &blendStateExt,
+                                    const bool disableAlpha);
 
     void setDitherEnabled(bool enabled);
 
@@ -279,18 +274,10 @@ class StateManagerGL final : angle::NonCopyable
     float mNear;
     float mFar;
 
-    bool mBlendEnabled;
     gl::ColorF mBlendColor;
-    GLenum mSourceBlendRGB;
-    GLenum mDestBlendRGB;
-    GLenum mSourceBlendAlpha;
-    GLenum mDestBlendAlpha;
-    GLenum mBlendEquationRGB;
-    GLenum mBlendEquationAlpha;
-    bool mColorMaskRed;
-    bool mColorMaskGreen;
-    bool mColorMaskBlue;
-    bool mColorMaskAlpha;
+    gl::BlendStateExt mBlendStateExt;
+    const bool mIndependentBlendStates;
+
     bool mSampleAlphaToCoverageEnabled;
     bool mSampleCoverageEnabled;
     float mSampleCoverageValue;

src/libANGLE/renderer/gl/renderergl_utils.cpp

@@ -1162,7 +1162,16 @@ void GenerateCaps(const FunctionsGL *functions,
     extensions->drawBuffers = functions->isAtLeastGL(gl::Version(2, 0)) ||
                               functions->hasGLExtension("ARB_draw_buffers") ||
                               functions->hasGLESExtension("GL_EXT_draw_buffers");
-    extensions->textureStorage = functions->standard == STANDARD_GL_DESKTOP ||
+    extensions->drawBuffersIndexedEXT =
+        !features.disableDrawBuffersIndexed.enabled &&
+        (functions->isAtLeastGL(gl::Version(4, 0)) ||
+         (functions->hasGLExtension("GL_EXT_draw_buffers2") &&
+          functions->hasGLExtension("GL_ARB_draw_buffers_blend")) ||
+         functions->isAtLeastGLES(gl::Version(3, 2)) ||
+         functions->hasGLESExtension("GL_OES_draw_buffers_indexed") ||
+         functions->hasGLESExtension("GL_EXT_draw_buffers_indexed"));
+    extensions->drawBuffersIndexedOES = extensions->drawBuffersIndexedEXT;
+    extensions->textureStorage        = functions->standard == STANDARD_GL_DESKTOP ||
                                  functions->hasGLESExtension("GL_EXT_texture_storage");
     extensions->textureFilterAnisotropic =
         functions->hasGLExtension("GL_EXT_texture_filter_anisotropic") ||
@@ -1705,6 +1714,8 @@ void InitializeFeatures(const FunctionsGL *functions, angle::FeaturesGL *feature
     // Workaround for incorrect sampling from DXT1 sRGB textures in Intel OpenGL on Windows.
     ANGLE_FEATURE_CONDITION(features, avoidDXT1sRGBTextureFormat, IsWindows() && isIntel);
 
+    ANGLE_FEATURE_CONDITION(features, disableDrawBuffersIndexed, IsWindows() && isAMD);
+
     ANGLE_FEATURE_CONDITION(
         features, disableSemaphoreFd,
         IsLinux() && isAMD && isMesa && mesaVersion < (std::array<int, 3>{19, 3, 5}));

src/tests/gl_tests/ClearTest.cpp

@@ -852,7 +852,7 @@ TEST_P(ClearTestES3, MaskedIndexedClearMultipleAttachments)
     ANGLE_SKIP_TEST_IF(!IsGLExtensionEnabled("GL_OES_draw_buffers_indexed"));
 
     constexpr uint32_t kSize            = 16;
-    constexpr uint32_t kAttachmentCount = 2;
+    constexpr uint32_t kAttachmentCount = 4;
     std::vector<unsigned char> pixelData(kSize * kSize * 4, 255);
 
     glBindFramebuffer(GL_FRAMEBUFFER, mFBOs[0]);
@@ -882,7 +882,8 @@ TEST_P(ClearTestES3, MaskedIndexedClearMultipleAttachments)
     // Block blue channel for all attachements
     glColorMask(GL_TRUE, GL_TRUE, GL_FALSE, GL_TRUE);
 
-    // Unblock blue channel for attachement 1
+    // Unblock blue channel for attachments 0 and 1
+    glColorMaskiOES(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
     glColorMaskiOES(1, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
 
     glClearColor(clearColor[0], clearColor[1], clearColor[2], clearColor[3]);
@@ -895,12 +896,12 @@ TEST_P(ClearTestES3, MaskedIndexedClearMultipleAttachments)
         glReadBuffer(GL_COLOR_ATTACHMENT0 + i);
         ASSERT_GL_NO_ERROR();
 
-        const GLColor attachementColor = (i == 1) ? clearColor : clearColorMasked;
-        EXPECT_PIXEL_COLOR_EQ(0, 0, attachementColor);
-        EXPECT_PIXEL_COLOR_EQ(0, kSize - 1, attachementColor);
-        EXPECT_PIXEL_COLOR_EQ(kSize - 1, 0, attachementColor);
-        EXPECT_PIXEL_COLOR_EQ(kSize - 1, kSize - 1, attachementColor);
-        EXPECT_PIXEL_COLOR_EQ(kSize / 2, kSize / 2, attachementColor);
+        const GLColor attachmentColor = (i > 1) ? clearColorMasked : clearColor;
+        EXPECT_PIXEL_COLOR_EQ(0, 0, attachmentColor);
+        EXPECT_PIXEL_COLOR_EQ(0, kSize - 1, attachmentColor);
+        EXPECT_PIXEL_COLOR_EQ(kSize - 1, 0, attachmentColor);
+        EXPECT_PIXEL_COLOR_EQ(kSize - 1, kSize - 1, attachmentColor);
+        EXPECT_PIXEL_COLOR_EQ(kSize / 2, kSize / 2, attachmentColor);
     }
 }