Revert "Using dirty bits notification for blend state"

src/libANGLE/Context.cpp

@@ -1781,7 +1781,7 @@ void Context::syncRendererState()
     const State::DirtyBits &dirtyBits = mState.getDirtyBits();
     if (dirtyBits.any())
     {
-        mRenderer->syncState(getData(), dirtyBits);
+        mRenderer->syncState(mState, dirtyBits);
         mState.clearDirtyBits();
     }
 }
@@ -1791,7 +1791,7 @@ void Context::syncRendererState(const State::DirtyBits &bitMask)
     const State::DirtyBits &dirtyBits = (mState.getDirtyBits() & bitMask);
     if (dirtyBits.any())
     {
-        mRenderer->syncState(getData(), dirtyBits);
+        mRenderer->syncState(mState, dirtyBits);
         mState.clearDirtyBits(dirtyBits);
     }
 }

src/libANGLE/renderer/Renderer.h

@@ -90,7 +90,7 @@ class Renderer : public ImplFactory
     virtual void pushGroupMarker(GLsizei length, const char *marker) = 0;
     virtual void popGroupMarker() = 0;
 
-    virtual gl::Error syncState(const gl::Data &data, const gl::State::DirtyBits &dirtyBits) = 0;
+    virtual void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits) = 0;
 
     // Renderer capabilities
     const gl::Caps &getRendererCaps() const;

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -8,22 +8,22 @@
 
 #include "libANGLE/renderer/d3d/RendererD3D.h"
 
-#include "common/debug.h"
 #include "common/MemoryBuffer.h"
+#include "common/debug.h"
 #include "common/utilities.h"
 #include "libANGLE/Display.h"
-#include "libANGLE/formatutils.h"
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/FramebufferAttachment.h"
+#include "libANGLE/ResourceManager.h"
+#include "libANGLE/State.h"
+#include "libANGLE/VertexArray.h"
+#include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/BufferD3D.h"
 #include "libANGLE/renderer/d3d/CompilerD3D.h"
 #include "libANGLE/renderer/d3d/DisplayD3D.h"
 #include "libANGLE/renderer/d3d/IndexDataManager.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
 #include "libANGLE/renderer/d3d/SamplerD3D.h"
-#include "libANGLE/ResourceManager.h"
-#include "libANGLE/State.h"
-#include "libANGLE/VertexArray.h"
 
 namespace rx
 {
@@ -305,16 +305,6 @@ gl::Error RendererD3D::genericDrawArrays(const gl::Data &data,
     return gl::Error(GL_NO_ERROR);
 }
 
-gl::Error RendererD3D::syncState(const gl::Data &data, const gl::State::DirtyBits &dirtyBits)
-{
-    // TODO(dianx) mStateManager->syncState when all the states have been moved to manager
-    // We don't clear the dirty bits here because applyState uses the dirty bits.
-    // This is a bit of a workaround
-    mStateManager->syncExternalDirtyBits(dirtyBits);
-
-    return gl::Error(GL_NO_ERROR);
-}
-
 gl::Error RendererD3D::generateSwizzles(const gl::Data &data, gl::SamplerType type)
 {
     ProgramD3D *programD3D = GetImplAs<ProgramD3D>(data.state->getProgram());
@@ -389,22 +379,60 @@ gl::Error RendererD3D::applyState(const gl::Data &data, GLenum drawMode)
     const gl::Framebuffer *framebufferObject = data.state->getDrawFramebuffer();
     int samples = framebufferObject->getSamples(data);
 
-    // TODO(dianx) drawMode shouldn't be a part of rasterizer state. We should remove it
-    // from RasterizerState and set a local state only when drawing point sprites in the draw call
     gl::RasterizerState rasterizer = data.state->getRasterizerState();
     rasterizer.pointDrawMode = (drawMode == GL_POINTS);
     rasterizer.multiSample = (samples != 0);
 
-    gl::Error error = setRasterizerState(rasterizer, data.state->getDirtyBits());
+    gl::Error error = setRasterizerState(rasterizer);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    unsigned int mask = 0;
+    if (data.state->isSampleCoverageEnabled())
+    {
+        GLclampf coverageValue = data.state->getSampleCoverageValue();
+        if (coverageValue != 0)
+        {
+            float threshold = 0.5f;
+
+            for (int i = 0; i < samples; ++i)
+            {
+                mask <<= 1;
+
+                if ((i + 1) * coverageValue >= threshold)
+                {
+                    threshold += 1.0f;
+                    mask |= 1;
+                }
+            }
+        }
 
+        bool coverageInvert = data.state->getSampleCoverageInvert();
+        if (coverageInvert)
+        {
+            mask = ~mask;
+        }
+    }
+    else
+    {
+        mask = 0xFFFFFFFF;
+    }
+    error = setBlendState(framebufferObject, data.state->getBlendState(), data.state->getBlendColor(), mask);
     if (error.isError())
     {
         return error;
     }
 
-    error = mStateManager->syncState(data, data.state->getDirtyBits());
+    error = setDepthStencilState(data.state->getDepthStencilState(), data.state->getStencilRef(),
+                                 data.state->getStencilBackRef(), rasterizer.frontFace == GL_CCW);
+    if (error.isError())
+    {
+        return error;
+    }
 
-    return error;
+    return gl::Error(GL_NO_ERROR);
 }
 
 // Applies the shaders and shader constants to the Direct3D device
@@ -713,4 +741,4 @@ gl::DebugAnnotator *RendererD3D::getAnnotator()
     return mAnnotator;
 }
 
-}  // namespace rx
+}

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -12,13 +12,12 @@
 #include "common/debug.h"
 #include "common/MemoryBuffer.h"
 #include "libANGLE/Data.h"
-#include "libANGLe/formatutils.h"
-#include "libANGLE/renderer/d3d/d3d11/NativeWindow.h"
-#include "libANGLE/renderer/d3d/formatutilsD3D.h"
-#include "libANGLE/renderer/d3d/StateManagerD3D.h"
+#include "libANGLE/formatutils.h"
+#include "libANGLE/renderer/Renderer.h"
 #include "libANGLE/renderer/d3d/VertexDataManager.h"
+#include "libANGLE/renderer/d3d/formatutilsD3D.h"
 #include "libANGLE/renderer/d3d/WorkaroundsD3D.h"
-#include "libANGLE/renderer/Renderer.h"
+#include "libANGLE/renderer/d3d/d3d11/NativeWindow.h"
 
 //FIXME(jmadill): std::array is currently prohibited by Chromium style guide
 #include <array>
@@ -150,12 +149,13 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
                                         const std::vector<GLint> &vertexUniformBuffers,
                                         const std::vector<GLint> &fragmentUniformBuffers) = 0;
 
-    // Calls state manager to sync state using dirty bits
-    virtual gl::Error setRasterizerState(const gl::RasterizerState &rasterState,
-                                         const gl::State::DirtyBits &dirtyBits) = 0;
+    virtual gl::Error setRasterizerState(const gl::RasterizerState &rasterState) = 0;
+    virtual gl::Error setBlendState(const gl::Framebuffer *framebuffer, const gl::BlendState &blendState, const gl::ColorF &blendColor,
+                                    unsigned int sampleMask) = 0;
+    virtual gl::Error setDepthStencilState(const gl::DepthStencilState &depthStencilState, int stencilRef,
+                                           int stencilBackRef, bool frontFaceCCW) = 0;
 
     virtual void setScissorRectangle(const gl::Rectangle &scissor, bool enabled) = 0;
-
     virtual void setViewport(const gl::Rectangle &viewport, float zNear, float zFar, GLenum drawMode, GLenum frontFace,
                              bool ignoreViewport) = 0;
 
@@ -220,7 +220,10 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
     virtual gl::Error fastCopyBufferToTexture(const gl::PixelUnpackState &unpack, unsigned int offset, RenderTargetD3D *destRenderTarget,
                                               GLenum destinationFormat, GLenum sourcePixelsType, const gl::Box &destArea) = 0;
 
-    gl::Error syncState(const gl::Data &data, const gl::State::DirtyBits &dirtyBits) override;
+    void syncState(const gl::State & /*state*/, const gl::State::DirtyBits &bitmask) override
+    {
+        // TODO(jmadill): implement state sync for D3D renderers;
+    }
 
     // Device lost
     void notifyDeviceLost() override;
@@ -246,8 +249,6 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
 
     virtual void createAnnotator() = 0;
 
-    StateManagerD3D *mStateManager;
-
     // dirtyPointer is a special value that will make the comparison with any valid pointer fail and force the renderer to re-apply the state.
     static const uintptr_t DirtyPointer;
 
@@ -259,10 +260,6 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
 
     std::vector<TranslatedAttribute> mTranslatedAttribCache;
 
-    gl::Rectangle mCurScissor;
-    bool mScissorEnabled;
-    bool mForceSetScissor;
-
   private:
     gl::Error genericDrawArrays(const gl::Data &data,
                                 GLenum mode,
@@ -336,6 +333,6 @@ struct dx_PixelConstants
     float depthFront[4];
 };
 
-}  // namespace rx
+}
 
 #endif // LIBANGLE_RENDERER_D3D_RENDERERD3D_H_

src/libANGLE/renderer/d3d/StateManagerD3D.cpp

-//
-// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-// StateManagerD3D.cpp: Defines a class for caching D3D state
-
-#include "libANGLE/renderer/d3d/StateManagerD3D.h"
-
-#include "common/BitSetIterator.h"
-#include "libANGLE/Framebuffer.h"
-
-namespace rx
-{
-
-namespace
-{
-
-void SetGivenBitsDirty(gl::State::DirtyBits &dirtyBits,
-                       const gl::State::DirtyBitType *givenBits,
-                       size_t count)
-{
-    for (size_t i = 0; i < count; ++i)
-    {
-        dirtyBits.set(givenBits[i]);
-    }
-}
-
-const gl::State::DirtyBitType kRasterizerDirtyBits[] = {
-    gl::State::DIRTY_BIT_CULL_FACE_ENABLED, gl::State::DIRTY_BIT_CULL_FACE,
-    gl::State::DIRTY_BIT_FRONT_FACE,        gl::State::DIRTY_BIT_POLYGON_OFFSET_FILL_ENABLED,
-    gl::State::DIRTY_BIT_POLYGON_OFFSET,    gl::State::DIRTY_BIT_RASTERIZER_DISCARD_ENABLED};
-
-const gl::State::DirtyBitType kDepthStencilDirtyBits[] = {
-    gl::State::DIRTY_BIT_DEPTH_MASK,
-    gl::State::DIRTY_BIT_DEPTH_TEST_ENABLED,
-    gl::State::DIRTY_BIT_DEPTH_FUNC,
-    gl::State::DIRTY_BIT_STENCIL_TEST_ENABLED,
-    gl::State::DIRTY_BIT_STENCIL_FUNCS_FRONT,
-    gl::State::DIRTY_BIT_STENCIL_FUNCS_BACK,
-    gl::State::DIRTY_BIT_STENCIL_WRITEMASK_FRONT,
-    gl::State::DIRTY_BIT_STENCIL_WRITEMASK_BACK,
-    gl::State::DIRTY_BIT_STENCIL_OPS_FRONT,
-    gl::State::DIRTY_BIT_STENCIL_OPS_BACK,
-};
-
-const gl::State::DirtyBitType kBlendStateDirtyBits[] = {
-    gl::State::DIRTY_BIT_BLEND_EQUATIONS, gl::State::DIRTY_BIT_BLEND_FUNCS,
-    gl::State::DIRTY_BIT_BLEND_ENABLED,   gl::State::DIRTY_BIT_SAMPLE_ALPHA_TO_COVERAGE_ENABLED,
-    gl::State::DIRTY_BIT_DITHER_ENABLED,  gl::State::DIRTY_BIT_COLOR_MASK,
-    gl::State::DIRTY_BIT_BLEND_COLOR};
-
-}  // anonymous namespace
-
-StateManagerD3D::StateManagerD3D()
-    : mCurBlendColor(0, 0, 0, 0),
-      mCurSampleMask(0),
-      mCurStencilRef(0),
-      mCurStencilBackRef(0),
-      mCurStencilSize(0),
-      mCurScissorTestEnabled(false),
-      mLocalDirtyBits(),
-      mExternalDirtyBits()
-{
-    mCurBlendState.blend                 = false;
-    mCurBlendState.sourceBlendRGB        = GL_ONE;
-    mCurBlendState.destBlendRGB          = GL_ZERO;
-    mCurBlendState.sourceBlendAlpha      = GL_ONE;
-    mCurBlendState.destBlendAlpha        = GL_ZERO;
-    mCurBlendState.blendEquationRGB      = GL_FUNC_ADD;
-    mCurBlendState.blendEquationAlpha    = GL_FUNC_ADD;
-    mCurBlendState.colorMaskRed          = true;
-    mCurBlendState.colorMaskBlue         = true;
-    mCurBlendState.colorMaskGreen        = true;
-    mCurBlendState.colorMaskAlpha        = true;
-    mCurBlendState.sampleAlphaToCoverage = false;
-    mCurBlendState.dither                = false;
-
-    mCurDepthStencilState.depthTest                = false;
-    mCurDepthStencilState.depthFunc                = GL_LESS;
-    mCurDepthStencilState.depthMask                = true;
-    mCurDepthStencilState.stencilTest              = false;
-    mCurDepthStencilState.stencilMask              = true;
-    mCurDepthStencilState.stencilFail              = GL_KEEP;
-    mCurDepthStencilState.stencilPassDepthFail     = GL_KEEP;
-    mCurDepthStencilState.stencilPassDepthPass     = GL_KEEP;
-    mCurDepthStencilState.stencilWritemask         = static_cast<GLuint>(-1);
-    mCurDepthStencilState.stencilBackFunc          = GL_ALWAYS;
-    mCurDepthStencilState.stencilBackMask          = static_cast<GLuint>(-1);
-    mCurDepthStencilState.stencilBackFail          = GL_KEEP;
-    mCurDepthStencilState.stencilBackPassDepthFail = GL_KEEP;
-    mCurDepthStencilState.stencilBackPassDepthPass = GL_KEEP;
-    mCurDepthStencilState.stencilBackWritemask     = static_cast<GLuint>(-1);
-
-    mCurRasterizerState.rasterizerDiscard   = false;
-    mCurRasterizerState.cullFace            = false;
-    mCurRasterizerState.cullMode            = GL_BACK;
-    mCurRasterizerState.frontFace           = GL_CCW;
-    mCurRasterizerState.polygonOffsetFill   = false;
-    mCurRasterizerState.polygonOffsetFactor = 0.0f;
-    mCurRasterizerState.polygonOffsetUnits  = 0.0f;
-    mCurRasterizerState.pointDrawMode       = false;
-    mCurRasterizerState.multiSample         = false;
-}
-
-StateManagerD3D::~StateManagerD3D()
-{
-}
-
-const gl::State::DirtyBits StateManagerD3D::mRasterizerDirtyBits = []()
-{
-    gl::State::DirtyBits rasterizerDirtyBits;
-    SetGivenBitsDirty(rasterizerDirtyBits, kRasterizerDirtyBits, ArraySize(kRasterizerDirtyBits));
-    return rasterizerDirtyBits;
-}();
-
-const gl::State::DirtyBits StateManagerD3D::mDepthStencilDirtyBits = []()
-{
-    gl::State::DirtyBits depthStencilDirtyBits;
-    SetGivenBitsDirty(depthStencilDirtyBits, kDepthStencilDirtyBits,
-                      ArraySize(kDepthStencilDirtyBits));
-    return depthStencilDirtyBits;
-}();
-
-const gl::State::DirtyBits StateManagerD3D::mBlendDirtyBits = []()
-{
-    gl::State::DirtyBits blendDirtyBits;
-    SetGivenBitsDirty(blendDirtyBits, kBlendStateDirtyBits, ArraySize(kBlendStateDirtyBits));
-    return blendDirtyBits;
-}();
-
-bool StateManagerD3D::IsBlendStateDirty(const gl::State::DirtyBits &dirtyBits)
-{
-    return (dirtyBits & mBlendDirtyBits).any();
-}
-
-bool StateManagerD3D::IsDepthStencilStateDirty(const gl::State::DirtyBits &dirtyBits)
-{
-    return (dirtyBits & mDepthStencilDirtyBits).any();
-}
-
-bool StateManagerD3D::IsRasterizerStateDirty(const gl::State::DirtyBits &dirtyBits)
-{
-    return (dirtyBits & mRasterizerDirtyBits).any();
-}
-
-void StateManagerD3D::resetRasterizerForceBits()
-{
-    // If a bit is inside of mRasterizerDirtyBits, we want to reset it, otherwise, leave it alone
-    mLocalDirtyBits &= (~mRasterizerDirtyBits);
-}
-
-void StateManagerD3D::resetBlendForceBits()
-{
-    mLocalDirtyBits &= (~mBlendDirtyBits);
-}
-
-void StateManagerD3D::resetDepthStencilForceBits()
-{
-    mLocalDirtyBits &= (~mDepthStencilDirtyBits);
-}
-
-bool StateManagerD3D::isForceSetRasterizerState() const
-{
-    return (mLocalDirtyBits & mRasterizerDirtyBits).any();
-}
-
-bool StateManagerD3D::isForceSetDepthStencilState() const
-{
-    return (mLocalDirtyBits & mDepthStencilDirtyBits).any();
-}
-
-bool StateManagerD3D::isForceSetBlendState() const
-{
-    return (mLocalDirtyBits & mBlendDirtyBits).any();
-}
-
-void StateManagerD3D::setCurStencilSize(unsigned int size)
-{
-    mCurStencilSize = size;
-}
-
-unsigned int StateManagerD3D::getCurStencilSize() const
-{
-    return mCurStencilSize;
-}
-
-void StateManagerD3D::setRasterizerScissorEnabled(bool enabled)
-{
-    mCurScissorTestEnabled = enabled;
-}
-
-unsigned int StateManagerD3D::getBlendStateMask(const gl::Framebuffer *framebufferObject,
-                                                int samples,
-                                                const gl::State &state) const
-{
-    unsigned int mask = 0;
-    if (state.isSampleCoverageEnabled())
-    {
-        GLclampf coverageValue = state.getSampleCoverageValue();
-        if (coverageValue != 0)
-        {
-            float threshold = 0.5f;
-
-            for (int i = 0; i < samples; ++i)
-            {
-                mask <<= 1;
-
-                if ((i + 1) * coverageValue >= threshold)
-                {
-                    threshold += 1.0f;
-                    mask |= 1;
-                }
-            }
-        }
-
-        bool coverageInvert = state.getSampleCoverageInvert();
-        if (coverageInvert)
-        {
-            mask = ~mask;
-        }
-    }
-    else
-    {
-        mask = 0xFFFFFFFF;
-    }
-
-    return mask;
-}
-
-void StateManagerD3D::forceSetBlendState()
-{
-    mLocalDirtyBits |= mBlendDirtyBits;
-}
-
-void StateManagerD3D::forceSetDepthStencilState()
-{
-    mLocalDirtyBits |= mDepthStencilDirtyBits;
-}
-
-void StateManagerD3D::forceSetRasterizerState()
-{
-    mLocalDirtyBits |= mRasterizerDirtyBits;
-}
-
-void StateManagerD3D::syncExternalDirtyBits(const gl::State::DirtyBits &dirtyBits)
-{
-    mExternalDirtyBits = dirtyBits;
-}
-
-gl::Error StateManagerD3D::syncState(const gl::Data &data, const gl::State::DirtyBits &dirtyBits)
-{
-    const gl::Framebuffer *framebufferObject = data.state->getDrawFramebuffer();
-    int samples                              = framebufferObject->getSamples(data);
-
-    gl::State::DirtyBits allDirtyBits = mExternalDirtyBits | mLocalDirtyBits;
-
-    unsigned int sampleMask = getBlendStateMask(framebufferObject, samples, *(data.state));
-    gl::Error error = setBlendState(framebufferObject, data.state->getBlendState(),
-                                    data.state->getBlendColor(), sampleMask, allDirtyBits);
-
-    if (error.isError())
-    {
-        return error;
-    }
-
-    resetBlendForceBits();
-
-    error = setDepthStencilState(data.state->getDepthStencilState(), data.state->getStencilRef(),
-                                 data.state->getStencilBackRef(),
-                                 data.state->getRasterizerState().frontFace == GL_CCW,
-                                 data.state->getDirtyBits());
-
-    if (error.isError())
-    {
-        return error;
-    }
-
-    resetDepthStencilForceBits();
-
-    mExternalDirtyBits.reset();
-
-    return gl::Error(GL_NO_ERROR);
-}
-}  // namespace rx
\ No newline at end of file

src/libANGLE/renderer/d3d/StateManagerD3D.h

-//
-// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-// StateManagerD3D.h: Defines a class for caching D3D state
-
-#ifndef LIBANGLE_RENDERER_D3D_STATEMANAGERD3D_H_
-#define LIBANGLE_RENDERER_D3D_STATEMANAGERD3D_H_
-
-#include "libANGLE/angletypes.h"
-#include "libANGLE/Data.h"
-#include "libANGLE/State.h"
-
-namespace rx
-{
-
-class StateManagerD3D : angle::NonCopyable
-{
-  public:
-    explicit StateManagerD3D();
-
-    virtual ~StateManagerD3D();
-
-    void syncExternalDirtyBits(const gl::State::DirtyBits &dirtyBits);
-
-    gl::Error syncState(const gl::Data &data, const gl::State::DirtyBits &dirtyBits);
-
-    virtual gl::Error setBlendState(const gl::Framebuffer *framebuffer,
-                                    const gl::BlendState &blendState,
-                                    const gl::ColorF &blendColor,
-                                    unsigned int sampleMask,
-                                    const gl::State::DirtyBits &dirtyBits) = 0;
-
-    virtual gl::Error setDepthStencilState(const gl::DepthStencilState &depthStencilState,
-                                           int stencilRef,
-                                           int stencilBackRef,
-                                           bool frontFaceCCW,
-                                           const gl::State::DirtyBits &dirtyBits) = 0;
-
-    virtual gl::Error setRasterizerState(const gl::RasterizerState &rasterizerState,
-                                         const gl::State::DirtyBits &dirtyBits) = 0;
-
-    void setRasterizerScissorEnabled(bool enabled);
-    void setCurStencilSize(unsigned int size);
-    unsigned int getCurStencilSize() const;
-
-    void forceSetBlendState();
-    void forceSetDepthStencilState();
-    void forceSetRasterizerState();
-
-    bool isForceSetRasterizerState() const;
-    bool isForceSetDepthStencilState() const;
-    bool isForceSetBlendState() const;
-
-  protected:
-    static bool IsBlendStateDirty(const gl::State::DirtyBits &dirtyBits);
-    static bool IsDepthStencilStateDirty(const gl::State::DirtyBits &dirtyBits);
-    static bool IsRasterizerStateDirty(const gl::State::DirtyBits &dirtyBits);
-
-    void resetRasterizerForceBits();
-    void resetBlendForceBits();
-    void resetDepthStencilForceBits();
-
-    bool mForceSetDepthStencilState;
-    bool mForceSetBlendState;
-
-    // Blend State
-    gl::BlendState mCurBlendState;
-    gl::ColorF mCurBlendColor;
-    unsigned int mCurSampleMask;
-
-    // Depth Stencil State
-    gl::DepthStencilState mCurDepthStencilState;
-    int mCurStencilRef;
-    int mCurStencilBackRef;
-    unsigned int mCurStencilSize;
-
-    // Rasterizer State
-    gl::RasterizerState mCurRasterizerState;
-
-    // Scissor State
-    bool mCurScissorTestEnabled;
-
-    // Local force dirty bits
-    gl::State::DirtyBits mLocalDirtyBits;
-    // Copy of dirty bits in state. Synced on syncState. Should be removed after all states are
-    // moved in
-    gl::State::DirtyBits mExternalDirtyBits;
-    static const gl::State::DirtyBits mBlendDirtyBits;
-    static const gl::State::DirtyBits mDepthStencilDirtyBits;
-    static const gl::State::DirtyBits mRasterizerDirtyBits;
-
-  private:
-    unsigned int getBlendStateMask(const gl::Framebuffer *framebufferObject,
-                                   int samples,
-                                   const gl::State &state) const;
-};
-}  // namespace rx
-#endif
\ No newline at end of file

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

@@ -35,7 +35,6 @@
 #include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
 #include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h"
 #include "libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h"
-#include "libANGLE/renderer/d3d/d3d11/StateManager11.h"
 #include "libANGLE/renderer/d3d/d3d11/SwapChain11.h"
 #include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
 #include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h"
@@ -195,7 +194,7 @@ ANGLEFeatureLevel GetANGLEFeatureLevel(D3D_FEATURE_LEVEL d3dFeatureLevel)
     }
 }
 
-}  // namespace
+}
 
 void Renderer11::SRVCache::update(size_t resourceIndex, ID3D11ShaderResourceView *srv)
 {
@@ -239,6 +238,7 @@ void Renderer11::SRVCache::clear()
 Renderer11::Renderer11(egl::Display *display)
     : RendererD3D(display),
       mStateCache(this),
+      mCurStencilSize(0),
       mLastHistogramUpdateTime(ANGLEPlatformCurrent()->monotonicallyIncreasingTime()),
       mDebug(nullptr)
 {
@@ -283,8 +283,6 @@ Renderer11::Renderer11(egl::Display *display)
 
     mAppliedNumXFBBindings = static_cast<size_t>(-1);
 
-    mStateManager = nullptr;
-
     ZeroMemory(&mAdapterDescription, sizeof(mAdapterDescription));
 
     const auto &attributes = mDisplay->getAttributeMap();
@@ -603,9 +601,6 @@ void Renderer11::initializeDevice()
     ASSERT(!mPixelTransfer);
     mPixelTransfer = new PixelTransfer11(this);
 
-    ASSERT(!mStateManager);
-    mStateManager = new StateManager11(mDeviceContext, &mStateCache);
-
     const gl::Caps &rendererCaps = getRendererCaps();
 
     mForceSetVertexSamplerStates.resize(rendererCaps.maxVertexTextureImageUnits);
@@ -1130,11 +1125,117 @@ gl::Error Renderer11::setUniformBuffers(const gl::Data &data,
     return gl::Error(GL_NO_ERROR);
 }
 
-gl::Error Renderer11::setRasterizerState(const gl::RasterizerState &rasterState,
-                                         const gl::State::DirtyBits &dirtyBits)
+gl::Error Renderer11::setRasterizerState(const gl::RasterizerState &rasterState)
 {
-    mStateManager->setRasterizerScissorEnabled(mScissorEnabled);
-    return mStateManager->setRasterizerState(rasterState, dirtyBits);
+    if (mForceSetRasterState || memcmp(&rasterState, &mCurRasterState, sizeof(gl::RasterizerState)) != 0)
+    {
+        ID3D11RasterizerState *dxRasterState = NULL;
+        gl::Error error = mStateCache.getRasterizerState(rasterState, mScissorEnabled, &dxRasterState);
+        if (error.isError())
+        {
+            return error;
+        }
+
+        mDeviceContext->RSSetState(dxRasterState);
+
+        mCurRasterState = rasterState;
+    }
+
+    mForceSetRasterState = false;
+
+    return gl::Error(GL_NO_ERROR);
+}
+
+gl::Error Renderer11::setBlendState(const gl::Framebuffer *framebuffer, const gl::BlendState &blendState, const gl::ColorF &blendColor,
+                                    unsigned int sampleMask)
+{
+    if (mForceSetBlendState ||
+        memcmp(&blendState, &mCurBlendState, sizeof(gl::BlendState)) != 0 ||
+        memcmp(&blendColor, &mCurBlendColor, sizeof(gl::ColorF)) != 0 ||
+        sampleMask != mCurSampleMask)
+    {
+        ID3D11BlendState *dxBlendState = NULL;
+        gl::Error error = mStateCache.getBlendState(framebuffer, blendState, &dxBlendState);
+        if (error.isError())
+        {
+            return error;
+        }
+
+        ASSERT(dxBlendState != NULL);
+
+        float blendColors[4] = {0.0f};
+        if (blendState.sourceBlendRGB != GL_CONSTANT_ALPHA && blendState.sourceBlendRGB != GL_ONE_MINUS_CONSTANT_ALPHA &&
+            blendState.destBlendRGB != GL_CONSTANT_ALPHA && blendState.destBlendRGB != GL_ONE_MINUS_CONSTANT_ALPHA)
+        {
+            blendColors[0] = blendColor.red;
+            blendColors[1] = blendColor.green;
+            blendColors[2] = blendColor.blue;
+            blendColors[3] = blendColor.alpha;
+        }
+        else
+        {
+            blendColors[0] = blendColor.alpha;
+            blendColors[1] = blendColor.alpha;
+            blendColors[2] = blendColor.alpha;
+            blendColors[3] = blendColor.alpha;
+        }
+
+        mDeviceContext->OMSetBlendState(dxBlendState, blendColors, sampleMask);
+
+        mCurBlendState = blendState;
+        mCurBlendColor = blendColor;
+        mCurSampleMask = sampleMask;
+    }
+
+    mForceSetBlendState = false;
+
+    return gl::Error(GL_NO_ERROR);
+}
+
+gl::Error Renderer11::setDepthStencilState(const gl::DepthStencilState &depthStencilState, int stencilRef,
+                                           int stencilBackRef, bool frontFaceCCW)
+{
+    if (mForceSetDepthStencilState ||
+        memcmp(&depthStencilState, &mCurDepthStencilState, sizeof(gl::DepthStencilState)) != 0 ||
+        stencilRef != mCurStencilRef || stencilBackRef != mCurStencilBackRef)
+    {
+        // get the maximum size of the stencil ref
+        unsigned int maxStencil = 0;
+        if (depthStencilState.stencilTest && mCurStencilSize > 0)
+        {
+            maxStencil = (1 << mCurStencilSize) - 1;
+        }
+        ASSERT((depthStencilState.stencilWritemask & maxStencil) ==
+               (depthStencilState.stencilBackWritemask & maxStencil));
+        ASSERT(stencilRef == stencilBackRef);
+        ASSERT((depthStencilState.stencilMask & maxStencil) ==
+               (depthStencilState.stencilBackMask & maxStencil));
+
+        ID3D11DepthStencilState *dxDepthStencilState = NULL;
+        gl::Error error = mStateCache.getDepthStencilState(depthStencilState, &dxDepthStencilState);
+        if (error.isError())
+        {
+            return error;
+        }
+
+        ASSERT(dxDepthStencilState);
+
+        // Max D3D11 stencil reference value is 0xFF, corresponding to the max 8 bits in a stencil buffer
+        // GL specifies we should clamp the ref value to the nearest bit depth when doing stencil ops
+        static_assert(D3D11_DEFAULT_STENCIL_READ_MASK == 0xFF, "Unexpected value of D3D11_DEFAULT_STENCIL_READ_MASK");
+        static_assert(D3D11_DEFAULT_STENCIL_WRITE_MASK == 0xFF, "Unexpected value of D3D11_DEFAULT_STENCIL_WRITE_MASK");
+        UINT dxStencilRef = std::min<UINT>(stencilRef, 0xFFu);
+
+        mDeviceContext->OMSetDepthStencilState(dxDepthStencilState, dxStencilRef);
+
+        mCurDepthStencilState = depthStencilState;
+        mCurStencilRef = stencilRef;
+        mCurStencilBackRef = stencilBackRef;
+    }
+
+    mForceSetDepthStencilState = false;
+
+    return gl::Error(GL_NO_ERROR);
 }
 
 void Renderer11::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
@@ -1155,7 +1256,7 @@ void Renderer11::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
 
         if (enabled != mScissorEnabled)
         {
-            mStateManager->forceSetRasterizerState();
+            mForceSetRasterState = true;
         }
 
         mCurScissor = scissor;
@@ -1410,10 +1511,10 @@ gl::Error Renderer11::applyRenderTarget(const gl::Framebuffer *framebuffer)
         }
 
         unsigned int stencilSize = depthStencil->getStencilSize();
-        if (!mDepthStencilInitialized || stencilSize != mStateManager->getCurStencilSize())
+        if (!mDepthStencilInitialized || stencilSize != mCurStencilSize)
         {
-            mStateManager->setCurStencilSize(stencilSize);
-            mStateManager->forceSetDepthStencilState();
+            mCurStencilSize            = stencilSize;
+            mForceSetDepthStencilState = true;
         }
     }
 
@@ -1429,12 +1530,11 @@ gl::Error Renderer11::applyRenderTarget(const gl::Framebuffer *framebuffer)
         mRenderTargetDesc.format = renderTargetFormat;
         mForceSetViewport = true;
         mForceSetScissor = true;
-
-        mStateManager->forceSetBlendState();
+        mForceSetBlendState = true;
 
         if (!mDepthStencilInitialized)
         {
-            mStateManager->forceSetRasterizerState();
+            mForceSetRasterState = true;
         }
 
         for (size_t rtIndex = 0; rtIndex < ArraySize(framebufferRTVs); rtIndex++)
@@ -1994,9 +2094,7 @@ gl::Error Renderer11::applyShadersImpl(const gl::Data &data, GLenum drawMode)
     }
 
     ID3D11GeometryShader *geometryShader = NULL;
-
     bool transformFeedbackActive = data.state->isTransformFeedbackActiveUnpaused();
-
     if (transformFeedbackActive)
     {
         geometryShader = (vertexExe ? GetAs<ShaderExecutable11>(vertexExe)->getStreamOutShader() : NULL);
@@ -2245,10 +2343,9 @@ void Renderer11::markAllStateDirty()
         mForceSetPixelSamplerStates[fsamplerId] = true;
     }
 
-    mStateManager->forceSetBlendState();
-    mStateManager->forceSetDepthStencilState();
-    mStateManager->forceSetRasterizerState();
-
+    mForceSetBlendState = true;
+    mForceSetRasterState = true;
+    mForceSetDepthStencilState = true;
     mForceSetScissor = true;
     mForceSetViewport = true;
 
@@ -2303,7 +2400,6 @@ void Renderer11::releaseDeviceResources()
     SafeDelete(mClear);
     SafeDelete(mTrim);
     SafeDelete(mPixelTransfer);
-    SafeDelete(mStateManager);
 
     SafeRelease(mDriverConstantBufferVS);
     SafeRelease(mDriverConstantBufferPS);
@@ -3865,4 +3961,4 @@ gl::Error Renderer11::clearTextures(gl::SamplerType samplerType, size_t rangeSta
     return gl::Error(GL_NO_ERROR);
 }
 
-}  // namespace rx
+}

src/libANGLE/renderer/d3d/d3d11/Renderer11.h

@@ -11,14 +11,14 @@
 
 #include "common/angleutils.h"
 #include "common/mathutil.h"
-#include "libANGLE/angletypes.h"
 #include "libANGLE/AttributeMap.h"
-#include "libANGLE/renderer/d3d/d3d11/DebugAnnotator11.h"
-#include "libANGLE/renderer/d3d/d3d11/InputLayoutCache.h"
-#include "libANGLE/renderer/d3d/d3d11/RenderStateCache.h"
+#include "libANGLE/angletypes.h"
 #include "libANGLE/renderer/d3d/HLSLCompiler.h"
 #include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/RenderTargetD3D.h"
+#include "libANGLE/renderer/d3d/d3d11/DebugAnnotator11.h"
+#include "libANGLE/renderer/d3d/d3d11/InputLayoutCache.h"
+#include "libANGLE/renderer/d3d/d3d11/RenderStateCache.h"
 
 namespace gl
 {
@@ -120,11 +120,13 @@ class Renderer11 : public RendererD3D
                                 const std::vector<GLint> &vertexUniformBuffers,
                                 const std::vector<GLint> &fragmentUniformBuffers) override;
 
-    gl::Error setRasterizerState(const gl::RasterizerState &rasterState,
-                                 const gl::State::DirtyBits &dirtyBits) override;
-
-    void setScissorRectangle(const gl::Rectangle &scissor, bool enabled) override;
+    virtual gl::Error setRasterizerState(const gl::RasterizerState &rasterState);
+    gl::Error setBlendState(const gl::Framebuffer *framebuffer, const gl::BlendState &blendState, const gl::ColorF &blendColor,
+                            unsigned int sampleMask) override;
+    virtual gl::Error setDepthStencilState(const gl::DepthStencilState &depthStencilState, int stencilRef,
+                                           int stencilBackRef, bool frontFaceCCW);
 
+    virtual void setScissorRectangle(const gl::Rectangle &scissor, bool enabled);
     virtual void setViewport(const gl::Rectangle &viewport, float zNear, float zFar, GLenum drawMode, GLenum frontFace,
                              bool ignoreViewport);
 
@@ -317,6 +319,7 @@ class Renderer11 : public RendererD3D
     uintptr_t mAppliedDSV;
     bool mDepthStencilInitialized;
     bool mRenderTargetDescInitialized;
+    unsigned int mCurStencilSize;
 
     struct RenderTargetDesc
     {
@@ -376,6 +379,27 @@ class Renderer11 : public RendererD3D
     // A block of NULL pointers, cached so we don't re-allocate every draw call
     std::vector<ID3D11ShaderResourceView*> mNullSRVs;
 
+    // Currently applied blend state
+    bool mForceSetBlendState;
+    gl::BlendState mCurBlendState;
+    gl::ColorF mCurBlendColor;
+    unsigned int mCurSampleMask;
+
+    // Currently applied rasterizer state
+    bool mForceSetRasterState;
+    gl::RasterizerState mCurRasterState;
+
+    // Currently applied depth stencil state
+    bool mForceSetDepthStencilState;
+    gl::DepthStencilState mCurDepthStencilState;
+    int mCurStencilRef;
+    int mCurStencilBackRef;
+
+    // Currently applied scissor rectangle
+    bool mForceSetScissor;
+    bool mScissorEnabled;
+    gl::Rectangle mCurScissor;
+
     // Currently applied viewport
     bool mForceSetViewport;
     gl::Rectangle mCurViewport;
@@ -462,5 +486,5 @@ class Renderer11 : public RendererD3D
     ID3D11Debug *mDebug;
 };
 
-}  // namespace rx
+}
 #endif // LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_H_

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

-//
-// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-// StateManager11.cpp: Defines a class for caching D3D11 state
-
-#include "libANGLE/renderer/d3d/d3d11/StateManager11.h"
-
-namespace rx
-{
-
-StateManager11::StateManager11(ID3D11DeviceContext *deviceContext, RenderStateCache *stateCache)
-    : mDeviceContext(deviceContext), mStateCache(stateCache)
-{
-}
-
-StateManager11::~StateManager11()
-{
-}
-
-const gl::RasterizerState &StateManager11::getCurRasterizerState()
-{
-    return mCurRasterizerState;
-}
-
-// TODO(dianx) Separate out the blend and stencil states so that each dirty bit
-// changes only one thing rather than all for D3D11
-gl::Error StateManager11::setBlendState(const gl::Framebuffer *framebuffer,
-                                        const gl::BlendState &blendState,
-                                        const gl::ColorF &blendColor,
-                                        unsigned int sampleMask,
-                                        const gl::State::DirtyBits &dirtyBits)
-{
-    if (isForceSetBlendState() ||
-        (IsBlendStateDirty(dirtyBits) &&
-         (memcmp(&blendState, &mCurBlendState, sizeof(gl::BlendState)) != 0 ||
-          memcmp(&blendColor, &mCurBlendColor, sizeof(gl::ColorF)) != 0 ||
-          sampleMask != mCurSampleMask)))
-    {
-        ID3D11BlendState *dxBlendState = NULL;
-        gl::Error error = mStateCache->getBlendState(framebuffer, blendState, &dxBlendState);
-        if (error.isError())
-        {
-            return error;
-        }
-
-        ASSERT(dxBlendState != NULL);
-
-        float blendColors[4] = {0.0f};
-
-        if (blendState.sourceBlendRGB != GL_CONSTANT_ALPHA &&
-            blendState.sourceBlendRGB != GL_ONE_MINUS_CONSTANT_ALPHA &&
-            blendState.destBlendRGB != GL_CONSTANT_ALPHA &&
-            blendState.destBlendRGB != GL_ONE_MINUS_CONSTANT_ALPHA)
-        {
-            blendColors[0] = blendColor.red;
-            blendColors[1] = blendColor.green;
-            blendColors[2] = blendColor.blue;
-            blendColors[3] = blendColor.alpha;
-        }
-        else
-        {
-            blendColors[0] = blendColor.alpha;
-            blendColors[1] = blendColor.alpha;
-            blendColors[2] = blendColor.alpha;
-            blendColors[3] = blendColor.alpha;
-        }
-
-        mDeviceContext->OMSetBlendState(dxBlendState, blendColors, sampleMask);
-
-        mCurBlendState = blendState;
-        mCurBlendColor = blendColor;
-        mCurSampleMask = sampleMask;
-    }
-
-    return gl::Error(GL_NO_ERROR);
-}
-
-gl::Error StateManager11::setDepthStencilState(const gl::DepthStencilState &depthStencilState,
-                                               int stencilRef,
-                                               int stencilBackRef,
-                                               bool frontFaceCCW,
-                                               const gl::State::DirtyBits &dirtyBits)
-{
-    // TODO(dianx) We are currently not using dirty bits for this, but should in a future patch.
-    if (isForceSetDepthStencilState() ||
-        memcmp(&depthStencilState, &mCurDepthStencilState, sizeof(gl::DepthStencilState)) != 0 ||
-        stencilRef != mCurStencilRef || stencilBackRef != mCurStencilBackRef)
-    {
-        // get the maximum size of the stencil ref
-        unsigned int maxStencil = 0;
-        if (depthStencilState.stencilTest && mCurStencilSize > 0)
-        {
-            maxStencil = (1 << mCurStencilSize) - 1;
-        }
-        ASSERT((depthStencilState.stencilWritemask & maxStencil) ==
-               (depthStencilState.stencilBackWritemask & maxStencil));
-        ASSERT(stencilRef == stencilBackRef);
-        ASSERT((depthStencilState.stencilMask & maxStencil) ==
-               (depthStencilState.stencilBackMask & maxStencil));
-
-        ID3D11DepthStencilState *dxDepthStencilState = NULL;
-        gl::Error error =
-            mStateCache->getDepthStencilState(depthStencilState, &dxDepthStencilState);
-        if (error.isError())
-        {
-            return error;
-        }
-
-        ASSERT(dxDepthStencilState);
-
-        // Max D3D11 stencil reference value is 0xFF, the max 8 bits in a stencil buffer
-        // GL specifies we should clamp the ref value to nearest bit depth when doing stencil ops
-        static_assert(D3D11_DEFAULT_STENCIL_READ_MASK == 0xFF,
-                      "Unexpected value of D3D11_DEFAULT_STENCIL_READ_MASK");
-        static_assert(D3D11_DEFAULT_STENCIL_WRITE_MASK == 0xFF,
-                      "Unexpected value of D3D11_DEFAULT_STENCIL_WRITE_MASK");
-        UINT dxStencilRef = std::min<UINT>(stencilRef, 0xFFu);
-
-        mDeviceContext->OMSetDepthStencilState(dxDepthStencilState, dxStencilRef);
-
-        mCurDepthStencilState = depthStencilState;
-        mCurStencilRef        = stencilRef;
-        mCurStencilBackRef    = stencilBackRef;
-    }
-
-    return gl::Error(GL_NO_ERROR);
-}
-
-gl::Error StateManager11::setRasterizerState(const gl::RasterizerState &rasterizerState,
-                                             const gl::State::DirtyBits &dirtyBits)
-{
-    // TODO(dianx) setRasterizerState is being called after syncRendererState in Context.cpp
-    // which means the force bits are being cleared before this call is reached.
-    // We should move the dirtybits back when this is moved to syncState
-
-    if (isForceSetRasterizerState() ||
-        (memcmp(&rasterizerState, &mCurRasterizerState, sizeof(gl::RasterizerState)) != 0))
-    {
-        ID3D11RasterizerState *dxRasterState = NULL;
-        gl::Error error = mStateCache->getRasterizerState(rasterizerState, mCurScissorTestEnabled,
-                                                          &dxRasterState);
-        if (error.isError())
-        {
-            return error;
-        }
-
-        mDeviceContext->RSSetState(dxRasterState);
-
-        mCurRasterizerState = rasterizerState;
-
-        resetRasterizerForceBits();
-    }
-
-    return gl::Error(GL_NO_ERROR);
-}
-
-}  // namespace rx
\ No newline at end of file

src/libANGLE/renderer/d3d/d3d11/StateManager11.h

-//
-// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-// StateManager11.h: Defines a class for caching D3D11 state
-
-#ifndef LIBANGLE_RENDERER_D3D11_STATEMANAGER11_H_
-#define LIBANGLE_RENDERER_D3D11_STATEMANAGER11_H_
-
-#include "libANGLE/renderer/d3d/StateManagerD3D.h"
-
-#include "libANGLE/renderer/d3d/d3d11/RenderStateCache.h"
-
-namespace rx
-{
-
-class StateManager11 final : public StateManagerD3D
-{
-  public:
-    StateManager11(ID3D11DeviceContext *deviceContext, RenderStateCache *stateCache);
-
-    ~StateManager11() override;
-
-    gl::Error setBlendState(const gl::Framebuffer *framebuffer,
-                            const gl::BlendState &blendState,
-                            const gl::ColorF &blendColor,
-                            unsigned int sampleMask,
-                            const gl::State::DirtyBits &dirtyBits) override;
-
-    gl::Error setDepthStencilState(const gl::DepthStencilState &depthStencilState,
-                                   int stencilRef,
-                                   int stencilBackRef,
-                                   bool frontFaceCCW,
-                                   const gl::State::DirtyBits &dirtyBits) override;
-
-    gl::Error setRasterizerState(const gl::RasterizerState &rasterizerState,
-                                 const gl::State::DirtyBits &dirtyBits) override;
-
-    const gl::RasterizerState &getCurRasterizerState();
-
-  private:
-    // TODO(dianx) d3d11 and cached states are not in sync, hence we need to force set things
-    // but this should not be necessary.
-
-    ID3D11DeviceContext *mDeviceContext;
-    RenderStateCache *mStateCache;
-};
-}  // namespace rx
-#endif
\ No newline at end of file

src/libANGLE/renderer/d3d/d3d9/Renderer9.h

@@ -11,12 +11,12 @@
 
 #include "common/angleutils.h"
 #include "common/mathutil.h"
-#include "libANGLE/renderer/d3d/d3d9/DebugAnnotator9.h"
-#include "libANGLE/renderer/d3d/d3d9/ShaderCache.h"
-#include "libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.h"
 #include "libANGLE/renderer/d3d/HLSLCompiler.h"
 #include "libANGLE/renderer/d3d/RendererD3D.h"
 #include "libANGLE/renderer/d3d/RenderTargetD3D.h"
+#include "libANGLE/renderer/d3d/d3d9/DebugAnnotator9.h"
+#include "libANGLE/renderer/d3d/d3d9/ShaderCache.h"
+#include "libANGLE/renderer/d3d/d3d9/VertexDeclarationCache.h"
 
 namespace gl
 {
@@ -96,11 +96,13 @@ class Renderer9 : public RendererD3D
                                 const std::vector<GLint> &vertexUniformBuffers,
                                 const std::vector<GLint> &fragmentUniformBuffers) override;
 
-    gl::Error setRasterizerState(const gl::RasterizerState &rasterState,
-                                 const gl::State::DirtyBits &dirtyBits) override;
+    virtual gl::Error setRasterizerState(const gl::RasterizerState &rasterState);
+    gl::Error setBlendState(const gl::Framebuffer *framebuffer, const gl::BlendState &blendState, const gl::ColorF &blendColor,
+                            unsigned int sampleMask) override;
+    virtual gl::Error setDepthStencilState(const gl::DepthStencilState &depthStencilState, int stencilRef,
+                                           int stencilBackRef, bool frontFaceCCW);
 
     virtual void setScissorRectangle(const gl::Rectangle &scissor, bool enabled);
-
     virtual void setViewport(const gl::Rectangle &viewport, float zNear, float zFar, GLenum drawMode, GLenum frontFace,
                              bool ignoreViewport);
 
@@ -310,6 +312,8 @@ class Renderer9 : public RendererD3D
     unsigned int mAppliedDepthStencilSerial;
     bool mDepthStencilInitialized;
     bool mRenderTargetDescInitialized;
+    unsigned int mCurStencilSize;
+    unsigned int mCurDepthSize;
 
     struct RenderTargetDesc
     {
@@ -321,12 +325,31 @@ class Renderer9 : public RendererD3D
 
     IDirect3DStateBlock9 *mMaskedClearSavedState;
 
+    // previously set render states
+    bool mForceSetDepthStencilState;
+    gl::DepthStencilState mCurDepthStencilState;
+    int mCurStencilRef;
+    int mCurStencilBackRef;
+    bool mCurFrontFaceCCW;
+
+    bool mForceSetRasterState;
+    gl::RasterizerState mCurRasterState;
+
+    bool mForceSetScissor;
+    gl::Rectangle mCurScissor;
+    bool mScissorEnabled;
+
     bool mForceSetViewport;
     gl::Rectangle mCurViewport;
     float mCurNear;
     float mCurFar;
     float mCurDepthFront;
 
+    bool mForceSetBlendState;
+    gl::BlendState mCurBlendState;
+    gl::ColorF mCurBlendColor;
+    GLuint mCurSampleMask;
+
     // Currently applied sampler states
     struct CurSamplerState
     {
@@ -375,5 +398,5 @@ class Renderer9 : public RendererD3D
     UINT mMaxNullColorbufferLRU;
 };
 
-}  // namespace rx
+}
 #endif // LIBANGLE_RENDERER_D3D_D3D9_RENDERER9_H_

src/libANGLE/renderer/d3d/d3d9/StateManager9.h

-//
-// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-
-// StateManager9.h: Defines a class for caching D3D9 state
-
-#ifndef LIBANGLE_RENDERER_D3D9_STATEMANAGER9_H_
-#define LIBANGLE_RENDERER_D3D9_STATEMANAGER9_H_
-
-#include "libANGLE/renderer/d3d/StateManagerD3D.h"
-
-namespace rx
-{
-
-class StateManager9 final : public StateManagerD3D
-{
-  public:
-    StateManager9(IDirect3DDevice9 *device, D3DADAPTER_IDENTIFIER9 &adapterIdentifier);
-
-    ~StateManager9() override;
-
-    gl::Error setBlendState(const gl::Framebuffer *framebuffer,
-                            const gl::BlendState &blendState,
-                            const gl::ColorF &blendColor,
-                            unsigned int sampleMask,
-                            const gl::State::DirtyBits &dirtyBits) override;
-
-    gl::Error setDepthStencilState(const gl::DepthStencilState &depthStencilState,
-                                   int stencilRef,
-                                   int stencilBackRef,
-                                   bool frontFaceCCW,
-                                   const gl::State::DirtyBits &dirtyBits) override;
-
-    gl::Error setRasterizerState(const gl::RasterizerState &rasterizerState,
-                                 const gl::State::DirtyBits &dirtyBits) override;
-
-    void setCurDepthSize(unsigned int size);
-    unsigned int getCurDepthSize() const;
-
-  private:
-    static const D3DRENDERSTATETYPE D3DRS_CCW_STENCILREF       = D3DRS_STENCILREF;
-    static const D3DRENDERSTATETYPE D3DRS_CCW_STENCILMASK      = D3DRS_STENCILMASK;
-    static const D3DRENDERSTATETYPE D3DRS_CCW_STENCILWRITEMASK = D3DRS_STENCILWRITEMASK;
-
-    VendorID getVendorId() const;
-
-    // Blend state setting functions
-    void setDepthMask(bool depthMask);
-    void setDepthTestAndFunc(bool depthTest, GLenum depthFunc);
-    void setStencilTestEnabled(bool stencilTest);
-    void setStencilFuncsFront(GLenum stencilFunc,
-                              GLuint stencilMask,
-                              int stencilRef,
-                              unsigned int maxStencil,
-                              bool frontFaceCCW);
-    void setStencilFuncsBack(GLenum stencilBackFunc,
-                             GLuint stencilBackMask,
-                             int stencilBackRef,
-                             unsigned int maxStencil,
-                             bool frontFaceCCW);
-
-    void setStencilWriteMaskFront(GLuint stencilWritemask, bool frontFaceCCW);
-    void setStencilWriteMaskBack(GLuint stencilBackWritemask, bool frontFaceCCW);
-    void setStencilOpsFront(GLenum stencilFail,
-                            GLenum stencilPassDepthFail,
-                            GLenum stencilPassDepthPass,
-                            bool frontFaceCCW);
-    void setStencilOpsBack(GLenum stencilBackFail,
-                           GLenum stencilBackPassDepthFail,
-                           GLenum stencilBackPassDepthPass,
-                           bool frontFaceCCW);
-
-    // Depth stencil state setting functions
-    void setBlendEnableFuncsEquations(const gl::BlendState &blendState,
-                                      const gl::ColorF &blendColor);
-    void setBlendColor(const gl::ColorF &blendColor, const gl::BlendState &blendState);
-    void setBlendEnabled(bool blendEnabled);
-    void setSampleAlphaToCoverageEnabled(bool sampleAlphaToCoverage);
-    void setDitherEnabled(bool ditherEnabled);
-    void setBlendColorMask(const gl::BlendState &blendState, const gl::Framebuffer *framebuffer);
-    void setSampleMask(unsigned int sampleMask);
-
-    // Rasterizer state setting functions
-    void setRasterizerMode(bool cullFace, GLenum cullMode, GLenum frontFace);
-    void setRasterizerPolygonOffset(bool polygonOffsetFill,
-                                    GLfloat polygonOffsetFactor,
-                                    GLfloat polygonOffsetUnits);
-
-    IDirect3DDevice9 *mDevice;
-    const D3DADAPTER_IDENTIFIER9 &mAdapterIdentifier;
-
-    unsigned int mCurDepthSize;
-    bool mCurFrontFaceCCW;
-};
-
-}  // namespace rx
-#endif
\ No newline at end of file

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -418,8 +418,8 @@ void RendererGL::generateCaps(gl::Caps *outCaps, gl::TextureCapsMap* outTextureC
     nativegl_gl::GenerateCaps(mFunctions, outCaps, outTextureCaps, outExtensions, &mMaxSupportedESVersion);
 }
 
-gl::Error RendererGL::syncState(const gl::Data &data, const gl::State::DirtyBits &dirtyBits)
+void RendererGL::syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits)
 {
-    return mStateManager->syncState(*data.state, dirtyBits);
+    mStateManager->syncState(state, dirtyBits);
 }
 }

src/libANGLE/renderer/gl/RendererGL.h

@@ -103,7 +103,7 @@ class RendererGL : public Renderer
     std::string getVendorString() const override;
     std::string getRendererDescription() const override;
 
-    gl::Error syncState(const gl::Data &data, const gl::State::DirtyBits &dirtyBits) override;
+    void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits) override;
 
     const gl::Version &getMaxSupportedESVersion() const;
     const FunctionsGL *getFunctions() const { return mFunctions; }

src/libANGLE/renderer/gl/StateManagerGL.cpp

@@ -1274,7 +1274,7 @@ void StateManagerGL::setClearStencil(GLint clearStencil)
     }
 }
 
-gl::Error StateManagerGL::syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits)
+void StateManagerGL::syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits)
 {
     // TODO(jmadill): Investigate only syncing vertex state for active attributes
     for (unsigned int dirtyBit : angle::IterateBitSet(dirtyBits | mLocalDirtyBits))
@@ -1507,8 +1507,6 @@ gl::Error StateManagerGL::syncState(const gl::State &state, const gl::State::Dir
 
         mLocalDirtyBits.reset();
     }
-
-    return gl::Error(GL_NO_ERROR);
 }
 
 void StateManagerGL::setFramebufferSRGBEnabled(bool enabled)

src/libANGLE/renderer/gl/StateManagerGL.h

@@ -135,7 +135,7 @@ class StateManagerGL final : angle::NonCopyable
                                    GLsizei instanceCount,
                                    const GLvoid **outIndices);
 
-    gl::Error syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits);
+    void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits);
 
   private:
     gl::Error setGenericDrawState(const gl::Data &data);

src/libGLESv2.gypi

@@ -215,8 +215,6 @@
             'libANGLE/renderer/d3d/ShaderD3D.h',
             'libANGLE/renderer/d3d/ShaderExecutableD3D.cpp',
             'libANGLE/renderer/d3d/ShaderExecutableD3D.h',
-            'libANGLe/renderer/d3d/StateManagerD3D.h',
-            'libANGLE/renderer/d3d/StateManagerD3D.cpp',
             'libANGLE/renderer/d3d/SurfaceD3D.cpp',
             'libANGLE/renderer/d3d/SurfaceD3D.h',
             'libANGLE/renderer/d3d/SwapChainD3D.h',
@@ -265,8 +263,6 @@
             'libANGLE/renderer/d3d/d3d9/shaders/compiled/luminanceps.h',
             'libANGLE/renderer/d3d/d3d9/shaders/compiled/passthroughps.h',
             'libANGLE/renderer/d3d/d3d9/shaders/compiled/standardvs.h',
-            'libANGLE/renderer/d3d/d3d9/StateManager9.h',
-            'libANGLE/renderer/d3d/d3d9/StateManager9.cpp',
             'libANGLE/renderer/d3d/d3d9/SwapChain9.cpp',
             'libANGLE/renderer/d3d/d3d9/SwapChain9.h',
             'libANGLE/renderer/d3d/d3d9/TextureStorage9.cpp',
@@ -375,8 +371,6 @@
             'libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui2darrayps.h',
             'libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui2dps.h',
             'libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui3dps.h',
-            'libANGLE/renderer/d3d/d3d11/StateManager11.h',
-            'libANGLE/renderer/d3d/d3d11/StateManager11.cpp',
             'libANGLE/renderer/d3d/d3d11/SwapChain11.cpp',
             'libANGLE/renderer/d3d/d3d11/SwapChain11.h',
             'libANGLE/renderer/d3d/d3d11/swizzle_format_info.h',