Reland "Remove redundant BlendStateArray tracking"

src/libANGLE/Context.cpp

@@ -264,10 +264,10 @@ bool IsClearBufferEnabled(const FramebufferState &mState, GLenum buffer, GLint d
     return buffer != GL_COLOR || mState.getEnabledDrawBuffers()[drawbuffer];
 }
 
-bool IsColorMaskedOut(const BlendState &blend)
+bool IsColorMaskedOut(const BlendStateExt &blendStateExt, const GLint drawbuffer)
 {
-    return (!blend.colorMaskRed && !blend.colorMaskGreen && !blend.colorMaskBlue &&
-            !blend.colorMaskAlpha);
+    ASSERT(static_cast<size_t>(drawbuffer) < blendStateExt.mMaxDrawBuffers);
+    return blendStateExt.getColorMaskIndexed(static_cast<size_t>(drawbuffer)) == 0;
 }
 }  // anonymous namespace
 
@@ -3816,8 +3816,7 @@ bool Context::isClearBufferMaskedOut(GLenum buffer, GLint drawbuffer) const
     switch (buffer)
     {
         case GL_COLOR:
-            ASSERT(static_cast<size_t>(drawbuffer) < mState.getBlendStateArray().size());
-            return IsColorMaskedOut(mState.getBlendStateArray()[drawbuffer]);
+            return IsColorMaskedOut(mState.getBlendStateExt(), drawbuffer);
         case GL_DEPTH:
             return mState.getDepthStencilState().isDepthMaskedOut();
         case GL_STENCIL:

src/libANGLE/State.cpp

@@ -698,13 +698,10 @@ void State::setStencilClearValue(int stencil)
 
 void State::setColorMask(bool red, bool green, bool blue, bool alpha)
 {
-    for (BlendState &blendState : mBlendStateArray)
-    {
-        blendState.colorMaskRed   = red;
-        blendState.colorMaskGreen = green;
-        blendState.colorMaskBlue  = blue;
-        blendState.colorMaskAlpha = alpha;
-    }
+    mBlendState.colorMaskRed   = red;
+    mBlendState.colorMaskGreen = green;
+    mBlendState.colorMaskBlue  = blue;
+    mBlendState.colorMaskAlpha = alpha;
 
     mBlendStateExt.setColorMask(red, green, blue, alpha);
     mDirtyBits.set(DIRTY_BIT_COLOR_MASK);
@@ -712,42 +709,24 @@ void State::setColorMask(bool red, bool green, bool blue, bool alpha)
 
 void State::setColorMaskIndexed(bool red, bool green, bool blue, bool alpha, GLuint index)
 {
-    ASSERT(index < mBlendStateArray.size());
-    mBlendStateArray[index].colorMaskRed   = red;
-    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);
 }
 
 bool State::allActiveDrawBufferChannelsMasked() const
 {
-    for (size_t drawBufferIndex : mDrawFramebuffer->getDrawBufferMask())
-    {
-        const BlendState &blendState = mBlendStateArray[drawBufferIndex];
-        if (blendState.colorMaskRed || blendState.colorMaskGreen || blendState.colorMaskBlue ||
-            blendState.colorMaskAlpha)
-        {
-            return false;
-        }
-    }
-    return true;
+    // Compare current color mask with all-disabled color mask, while ignoring disabled draw
+    // buffers.
+    return (mBlendStateExt.compareColorMask(0) & mDrawFramebuffer->getDrawBufferMask()).none();
 }
 
 bool State::anyActiveDrawBufferChannelMasked() const
 {
-    for (size_t drawBufferIndex : mDrawFramebuffer->getDrawBufferMask())
-    {
-        const BlendState &blendState = mBlendStateArray[drawBufferIndex];
-        if (!(blendState.colorMaskRed && blendState.colorMaskGreen && blendState.colorMaskBlue &&
-              blendState.colorMaskAlpha))
-        {
-            return true;
-        }
-    }
-    return false;
+    // Compare current color mask with all-enabled color mask, while ignoring disabled draw
+    // buffers.
+    return (mBlendStateExt.compareColorMask(mBlendStateExt.mMaxColorMask) &
+            mDrawFramebuffer->getDrawBufferMask())
+        .any();
 }
 
 void State::setDepthMask(bool mask)
@@ -813,31 +792,25 @@ void State::setDepthRange(float zNear, float zFar)
 
 void State::setBlend(bool enabled)
 {
-    for (BlendState &blendState : mBlendStateArray)
-    {
-        blendState.blend = enabled;
-    }
+    mBlendState.blend = enabled;
+
     mBlendStateExt.setEnabled(enabled);
     mDirtyBits.set(DIRTY_BIT_BLEND_ENABLED);
 }
 
 void State::setBlendIndexed(bool enabled, GLuint index)
 {
-    ASSERT(index < mBlendStateArray.size());
-    mBlendStateArray[index].blend = enabled;
     mBlendStateExt.setEnabledIndexed(index, enabled);
     mDirtyBits.set(DIRTY_BIT_BLEND_ENABLED);
 }
 
 void State::setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha)
 {
-    for (BlendState &blendState : mBlendStateArray)
-    {
-        blendState.sourceBlendRGB   = sourceRGB;
-        blendState.destBlendRGB     = destRGB;
-        blendState.sourceBlendAlpha = sourceAlpha;
-        blendState.destBlendAlpha   = destAlpha;
-    }
+
+    mBlendState.sourceBlendRGB   = sourceRGB;
+    mBlendState.destBlendRGB     = destRGB;
+    mBlendState.sourceBlendAlpha = sourceAlpha;
+    mBlendState.destBlendAlpha   = destAlpha;
 
     if (mNoSimultaneousConstantColorAndAlphaBlendFunc)
     {
@@ -870,12 +843,6 @@ void State::setBlendFactorsIndexed(GLenum sourceRGB,
                                    GLenum destAlpha,
                                    GLuint index)
 {
-    ASSERT(index < mBlendStateArray.size());
-    mBlendStateArray[index].sourceBlendRGB   = sourceRGB;
-    mBlendStateArray[index].destBlendRGB     = destRGB;
-    mBlendStateArray[index].sourceBlendAlpha = sourceAlpha;
-    mBlendStateArray[index].destBlendAlpha   = destAlpha;
-
     if (mNoSimultaneousConstantColorAndAlphaBlendFunc)
     {
         mBlendFuncConstantColorDrawBuffers.set(index, hasConstantColor(sourceRGB, destRGB));
@@ -911,11 +878,8 @@ void State::setBlendColor(float red, float green, float blue, float alpha)
 
 void State::setBlendEquation(GLenum rgbEquation, GLenum alphaEquation)
 {
-    for (BlendState &blendState : mBlendStateArray)
-    {
-        blendState.blendEquationRGB   = rgbEquation;
-        blendState.blendEquationAlpha = alphaEquation;
-    }
+    mBlendState.blendEquationRGB   = rgbEquation;
+    mBlendState.blendEquationAlpha = alphaEquation;
 
     mBlendStateExt.setEquations(rgbEquation, alphaEquation);
     mDirtyBits.set(DIRTY_BIT_BLEND_EQUATIONS);
@@ -923,10 +887,6 @@ void State::setBlendEquation(GLenum rgbEquation, GLenum alphaEquation)
 
 void State::setBlendEquationIndexed(GLenum rgbEquation, GLenum alphaEquation, GLuint index)
 {
-    ASSERT(index < mBlendStateArray.size());
-    mBlendStateArray[index].blendEquationRGB   = rgbEquation;
-    mBlendStateArray[index].blendEquationAlpha = alphaEquation;
-
     mBlendStateExt.setEquationsIndexed(index, rgbEquation, alphaEquation);
     mDirtyBits.set(DIRTY_BIT_BLEND_EQUATIONS);
 }
@@ -2232,12 +2192,16 @@ void State::getBooleanv(GLenum pname, GLboolean *params) const
             *params = mDepthStencil.depthMask;
             break;
         case GL_COLOR_WRITEMASK:
+        {
             // non-indexed get returns the state of draw buffer zero
-            params[0] = mBlendStateArray[0].colorMaskRed;
-            params[1] = mBlendStateArray[0].colorMaskGreen;
-            params[2] = mBlendStateArray[0].colorMaskBlue;
-            params[3] = mBlendStateArray[0].colorMaskAlpha;
+            bool r, g, b, a;
+            mBlendStateExt.getColorMaskIndexed(0, &r, &g, &b, &a);
+            params[0] = r;
+            params[1] = g;
+            params[2] = b;
+            params[3] = a;
             break;
+        }
         case GL_CULL_FACE:
             *params = mRasterizer.cullFace;
             break;
@@ -2264,7 +2228,7 @@ void State::getBooleanv(GLenum pname, GLboolean *params) const
             break;
         case GL_BLEND:
             // non-indexed get returns the state of draw buffer zero
-            *params = mBlendStateArray[0].blend;
+            *params = mBlendStateExt.mEnabledMask.test(0);
             break;
         case GL_DITHER:
             *params = mRasterizer.dither;
@@ -2579,22 +2543,22 @@ angle::Result State::getIntegerv(const Context *context, GLenum pname, GLint *pa
             break;
         case GL_BLEND_SRC_RGB:
             // non-indexed get returns the state of draw buffer zero
-            *params = mBlendStateArray[0].sourceBlendRGB;
+            *params = mBlendStateExt.getSrcColorIndexed(0);
             break;
         case GL_BLEND_SRC_ALPHA:
-            *params = mBlendStateArray[0].sourceBlendAlpha;
+            *params = mBlendStateExt.getSrcAlphaIndexed(0);
             break;
         case GL_BLEND_DST_RGB:
-            *params = mBlendStateArray[0].destBlendRGB;
+            *params = mBlendStateExt.getDstColorIndexed(0);
             break;
         case GL_BLEND_DST_ALPHA:
-            *params = mBlendStateArray[0].destBlendAlpha;
+            *params = mBlendStateExt.getDstAlphaIndexed(0);
             break;
         case GL_BLEND_EQUATION_RGB:
-            *params = mBlendStateArray[0].blendEquationRGB;
+            *params = mBlendStateExt.getEquationColorIndexed(0);
             break;
         case GL_BLEND_EQUATION_ALPHA:
-            *params = mBlendStateArray[0].blendEquationAlpha;
+            *params = mBlendStateExt.getEquationAlphaIndexed(0);
             break;
         case GL_STENCIL_WRITEMASK:
             *params = CastMaskValue(mDepthStencil.stencilWritemask);
@@ -2852,10 +2816,10 @@ angle::Result State::getIntegerv(const Context *context, GLenum pname, GLint *pa
             break;
         case GL_BLEND_SRC:
             // non-indexed get returns the state of draw buffer zero
-            *params = mBlendStateArray[0].sourceBlendRGB;
+            *params = mBlendStateExt.getSrcColorIndexed(0);
             break;
         case GL_BLEND_DST:
-            *params = mBlendStateArray[0].destBlendRGB;
+            *params = mBlendStateExt.getDstColorIndexed(0);
             break;
         case GL_PERSPECTIVE_CORRECTION_HINT:
         case GL_POINT_SMOOTH_HINT:
@@ -2921,28 +2885,28 @@ void State::getIntegeri_v(GLenum target, GLuint index, GLint *data) const
     switch (target)
     {
         case GL_BLEND_SRC_RGB:
-            ASSERT(static_cast<size_t>(index) < mBlendStateArray.size());
-            *data = mBlendStateArray[index].sourceBlendRGB;
+            ASSERT(static_cast<size_t>(index) < mBlendStateExt.mMaxDrawBuffers);
+            *data = mBlendStateExt.getSrcColorIndexed(index);
             break;
         case GL_BLEND_SRC_ALPHA:
-            ASSERT(static_cast<size_t>(index) < mBlendStateArray.size());
-            *data = mBlendStateArray[index].sourceBlendAlpha;
+            ASSERT(static_cast<size_t>(index) < mBlendStateExt.mMaxDrawBuffers);
+            *data = mBlendStateExt.getSrcAlphaIndexed(index);
             break;
         case GL_BLEND_DST_RGB:
-            ASSERT(static_cast<size_t>(index) < mBlendStateArray.size());
-            *data = mBlendStateArray[index].destBlendRGB;
+            ASSERT(static_cast<size_t>(index) < mBlendStateExt.mMaxDrawBuffers);
+            *data = mBlendStateExt.getDstColorIndexed(index);
             break;
         case GL_BLEND_DST_ALPHA:
-            ASSERT(static_cast<size_t>(index) < mBlendStateArray.size());
-            *data = mBlendStateArray[index].destBlendAlpha;
+            ASSERT(static_cast<size_t>(index) < mBlendStateExt.mMaxDrawBuffers);
+            *data = mBlendStateExt.getDstAlphaIndexed(index);
             break;
         case GL_BLEND_EQUATION_RGB:
-            ASSERT(static_cast<size_t>(index) < mBlendStateArray.size());
-            *data = mBlendStateArray[index].blendEquationRGB;
+            ASSERT(static_cast<size_t>(index) < mBlendStateExt.mMaxDrawBuffers);
+            *data = mBlendStateExt.getEquationColorIndexed(index);
             break;
         case GL_BLEND_EQUATION_ALPHA:
-            ASSERT(static_cast<size_t>(index) < mBlendStateArray.size());
-            *data = mBlendStateArray[index].blendEquationAlpha;
+            ASSERT(static_cast<size_t>(index) < mBlendStateExt.mMaxDrawBuffers);
+            *data = mBlendStateExt.getEquationAlphaIndexed(index);
             break;
         case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
             ASSERT(static_cast<size_t>(index) < mTransformFeedback->getIndexedBufferCount());
@@ -3053,12 +3017,16 @@ void State::getBooleani_v(GLenum target, GLuint index, GLboolean *data) const
     switch (target)
     {
         case GL_COLOR_WRITEMASK:
-            ASSERT(static_cast<size_t>(index) < mBlendStateArray.size());
-            data[0] = mBlendStateArray[index].colorMaskRed;
-            data[1] = mBlendStateArray[index].colorMaskGreen;
-            data[2] = mBlendStateArray[index].colorMaskBlue;
-            data[3] = mBlendStateArray[index].colorMaskAlpha;
+        {
+            ASSERT(static_cast<size_t>(index) < mBlendStateExt.mMaxDrawBuffers);
+            bool r, g, b, a;
+            mBlendStateExt.getColorMaskIndexed(index, &r, &g, &b, &a);
+            data[0] = r;
+            data[1] = g;
+            data[2] = b;
+            data[3] = a;
             break;
+        }
         case GL_IMAGE_BINDING_LAYERED:
             ASSERT(static_cast<size_t>(index) < mImageUnits.size());
             *data = mImageUnits[index].layered;

src/libANGLE/State.h

@@ -134,8 +134,8 @@ class State : angle::NonCopyable
     bool allActiveDrawBufferChannelsMasked() const;
     bool anyActiveDrawBufferChannelMasked() const;
     const RasterizerState &getRasterizerState() const;
-    const BlendState &getBlendState() const { return mBlendStateArray[0]; }
-    const BlendStateArray &getBlendStateArray() const { return mBlendStateArray; }
+    const BlendState &getBlendState() const { return mBlendState; }
+    const BlendStateExt &getBlendStateExt() const { return mBlendStateExt; }
     const DepthStencilState &getDepthStencilState() const;
 
     // Clear behavior setters & state parameter block generation function
@@ -176,11 +176,11 @@ class State : angle::NonCopyable
     float getFarPlane() const { return mFarZ; }
 
     // Blend state manipulation
-    bool isBlendEnabled() const { return mBlendStateArray[0].blend; }
+    bool isBlendEnabled() const { return mBlendStateExt.mEnabledMask.test(0); }
     bool isBlendEnabledIndexed(GLuint index) const
     {
-        ASSERT(index < mBlendStateArray.size());
-        return mBlendStateArray[index].blend;
+        ASSERT(static_cast<size_t>(index) < mBlendStateExt.mMaxDrawBuffers);
+        return mBlendStateExt.mEnabledMask.test(index);
     }
     DrawBufferMask getBlendEnabledDrawBufferMask() const { return mBlendStateExt.mEnabledMask; }
     void setBlend(bool enabled);
@@ -858,8 +858,6 @@ class State : angle::NonCopyable
 
     const std::vector<ImageUnit> getImageUnits() const { return mImageUnits; }
 
-    const BlendStateExt &getBlendStateExt() const { return mBlendStateExt; }
-
   private:
     friend class Context;
 
@@ -957,7 +955,7 @@ class State : angle::NonCopyable
     bool mScissorTest;
     Rectangle mScissor;
 
-    BlendStateArray mBlendStateArray;
+    BlendState mBlendState;  // Buffer zero blend state legacy struct
     BlendStateExt mBlendStateExt;
     ColorF mBlendColor;
     bool mSampleAlphaToCoverage;

src/libANGLE/angletypes.h

@@ -189,8 +189,6 @@ struct BlendState final
 bool operator==(const BlendState &a, const BlendState &b);
 bool operator!=(const BlendState &a, const BlendState &b);
 
-using BlendStateArray = std::array<BlendState, IMPLEMENTATION_MAX_DRAW_BUFFERS>;
-
 struct DepthStencilState final
 {
     // This will zero-initialize the struct, including padding.

src/libANGLE/frame_capture_utils.cpp

@@ -235,19 +235,16 @@ void SerializeRectangle(gl::BinaryOutputStream *bos, const gl::Rectangle &rectan
     bos->writeInt(rectangle.height);
 }
 
-void SerializeBlendState(gl::BinaryOutputStream *bos, const gl::BlendState &blendState)
+void SerializeBlendStateExt(gl::BinaryOutputStream *bos, const gl::BlendStateExt &blendStateExt)
 {
-    bos->writeInt(blendState.blend);
-    bos->writeInt(blendState.sourceBlendRGB);
-    bos->writeInt(blendState.destBlendRGB);
-    bos->writeInt(blendState.sourceBlendAlpha);
-    bos->writeInt(blendState.destBlendAlpha);
-    bos->writeInt(blendState.blendEquationRGB);
-    bos->writeInt(blendState.blendEquationAlpha);
-    bos->writeInt(blendState.colorMaskRed);
-    bos->writeInt(blendState.colorMaskGreen);
-    bos->writeInt(blendState.colorMaskBlue);
-    bos->writeInt(blendState.colorMaskAlpha);
+    bos->writeInt(blendStateExt.mEnabledMask.bits());
+    bos->writeInt(blendStateExt.mDstColor);
+    bos->writeInt(blendStateExt.mDstAlpha);
+    bos->writeInt(blendStateExt.mSrcColor);
+    bos->writeInt(blendStateExt.mSrcAlpha);
+    bos->writeInt(blendStateExt.mEquationColor);
+    bos->writeInt(blendStateExt.mEquationAlpha);
+    bos->writeInt(blendStateExt.mColorMask);
 }
 
 void SerializeDepthStencilState(gl::BinaryOutputStream *bos,
@@ -346,11 +343,7 @@ void SerializeGLContextStates(gl::BinaryOutputStream *bos, const gl::State &stat
     SerializeRasterizerState(bos, state.getRasterizerState());
     bos->writeInt(state.isScissorTestEnabled());
     SerializeRectangle(bos, state.getScissor());
-    const gl::BlendStateArray &blendStateArray = state.getBlendStateArray();
-    for (size_t i = 0; i < blendStateArray.size(); i++)
-    {
-        SerializeBlendState(bos, blendStateArray[i]);
-    }
+    SerializeBlendStateExt(bos, state.getBlendStateExt());
     SerializeColor(bos, state.getBlendColor());
     bos->writeInt(state.isSampleAlphaToCoverageEnabled());
     bos->writeInt(state.isSampleCoverageEnabled());