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(mState, dirtyBits);
+        mRenderer->syncState(getData(), 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(mState, dirtyBits);
+        mRenderer->syncState(getData(), 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 void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits) = 0;
+    virtual gl::Error syncState(const gl::Data &data, 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/MemoryBuffer.h"
 #include "common/debug.h"
+#include "common/MemoryBuffer.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,6 +305,16 @@ 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());
@@ -379,60 +389,22 @@ 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);
-    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;
-                }
-            }
-        }
+    gl::Error error = setRasterizerState(rasterizer, data.state->getDirtyBits());
 
-        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 = setDepthStencilState(data.state->getDepthStencilState(), data.state->getStencilRef(),
-                                 data.state->getStencilBackRef(), rasterizer.frontFace == GL_CCW);
-    if (error.isError())
-    {
-        return error;
-    }
+    error = mStateManager->syncState(data, data.state->getDirtyBits());
 
-    return gl::Error(GL_NO_ERROR);
+    return error;
 }
 
 // Applies the shaders and shader constants to the Direct3D device
@@ -741,4 +713,4 @@ gl::DebugAnnotator *RendererD3D::getAnnotator()
     return mAnnotator;
 }
 
-}
+}  // namespace rx

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -12,12 +12,13 @@
 #include "common/debug.h"
 #include "common/MemoryBuffer.h"
 #include "libANGLE/Data.h"
-#include "libANGLE/formatutils.h"
-#include "libANGLE/renderer/Renderer.h"
-#include "libANGLE/renderer/d3d/VertexDataManager.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/renderer/d3d/VertexDataManager.h"
 #include "libANGLE/renderer/d3d/WorkaroundsD3D.h"
-#include "libANGLE/renderer/d3d/d3d11/NativeWindow.h"
+#include "libANGLE/renderer/Renderer.h"
 
 //FIXME(jmadill): std::array is currently prohibited by Chromium style guide
 #include <array>
@@ -149,13 +150,12 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
                                         const std::vector<GLint> &vertexUniformBuffers,
                                         const std::vector<GLint> &fragmentUniformBuffers) = 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;
+    // Calls state manager to sync state using dirty bits
+    virtual gl::Error setRasterizerState(const gl::RasterizerState &rasterState,
+                                         const gl::State::DirtyBits &dirtyBits) = 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,10 +220,7 @@ 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;
 
-    void syncState(const gl::State & /*state*/, const gl::State::DirtyBits &bitmask) override
-    {
-        // TODO(jmadill): implement state sync for D3D renderers;
-    }
+    gl::Error syncState(const gl::Data &data, const gl::State::DirtyBits &dirtyBits) override;
 
     // Device lost
     void notifyDeviceLost() override;
@@ -249,6 +246,8 @@ 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;
 
@@ -260,6 +259,10 @@ 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,
@@ -333,6 +336,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,6 +35,7 @@
 #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"
@@ -194,7 +195,7 @@ ANGLEFeatureLevel GetANGLEFeatureLevel(D3D_FEATURE_LEVEL d3dFeatureLevel)
     }
 }
 
-}
+}  // namespace
 
 void Renderer11::SRVCache::update(size_t resourceIndex, ID3D11ShaderResourceView *srv)
 {
@@ -238,7 +239,6 @@ void Renderer11::SRVCache::clear()
 Renderer11::Renderer11(egl::Display *display)
     : RendererD3D(display),
       mStateCache(this),
-      mCurStencilSize(0),
       mLastHistogramUpdateTime(ANGLEPlatformCurrent()->monotonicallyIncreasingTime()),
       mDebug(nullptr)
 {
@@ -283,6 +283,8 @@ Renderer11::Renderer11(egl::Display *display)
 
     mAppliedNumXFBBindings = static_cast<size_t>(-1);
 
+    mStateManager = nullptr;
+
     ZeroMemory(&mAdapterDescription, sizeof(mAdapterDescription));
 
     const auto &attributes = mDisplay->getAttributeMap();
@@ -601,6 +603,9 @@ 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);
@@ -1125,117 +1130,11 @@ gl::Error Renderer11::setUniformBuffers(const gl::Data &data,
     return gl::Error(GL_NO_ERROR);
 }
 
-gl::Error Renderer11::setRasterizerState(const gl::RasterizerState &rasterState)
+gl::Error Renderer11::setRasterizerState(const gl::RasterizerState &rasterState,
+                                         const gl::State::DirtyBits &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);
+    mStateManager->setRasterizerScissorEnabled(mScissorEnabled);
+    return mStateManager->setRasterizerState(rasterState, dirtyBits);
 }
 
 void Renderer11::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
@@ -1256,7 +1155,7 @@ void Renderer11::setScissorRectangle(const gl::Rectangle &scissor, bool enabled)
 
         if (enabled != mScissorEnabled)
         {
-            mForceSetRasterState = true;
+            mStateManager->forceSetRasterizerState();
         }
 
         mCurScissor = scissor;
@@ -1511,10 +1410,10 @@ gl::Error Renderer11::applyRenderTarget(const gl::Framebuffer *framebuffer)
         }
 
         unsigned int stencilSize = depthStencil->getStencilSize();
-        if (!mDepthStencilInitialized || stencilSize != mCurStencilSize)
+        if (!mDepthStencilInitialized || stencilSize != mStateManager->getCurStencilSize())
         {
-            mCurStencilSize            = stencilSize;
-            mForceSetDepthStencilState = true;
+            mStateManager->setCurStencilSize(stencilSize);
+            mStateManager->forceSetDepthStencilState();
         }
     }
 
@@ -1530,11 +1429,12 @@ gl::Error Renderer11::applyRenderTarget(const gl::Framebuffer *framebuffer)
         mRenderTargetDesc.format = renderTargetFormat;
         mForceSetViewport = true;
         mForceSetScissor = true;
-        mForceSetBlendState = true;
+
+        mStateManager->forceSetBlendState();
 
         if (!mDepthStencilInitialized)
         {
-            mForceSetRasterState = true;
+            mStateManager->forceSetRasterizerState();
         }
 
         for (size_t rtIndex = 0; rtIndex < ArraySize(framebufferRTVs); rtIndex++)
@@ -2094,7 +1994,9 @@ 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);
@@ -2343,9 +2245,10 @@ void Renderer11::markAllStateDirty()
         mForceSetPixelSamplerStates[fsamplerId] = true;
     }
 
-    mForceSetBlendState = true;
-    mForceSetRasterState = true;
-    mForceSetDepthStencilState = true;
+    mStateManager->forceSetBlendState();
+    mStateManager->forceSetDepthStencilState();
+    mStateManager->forceSetRasterizerState();
+
     mForceSetScissor = true;
     mForceSetViewport = true;
 
@@ -2400,6 +2303,7 @@ void Renderer11::releaseDeviceResources()
     SafeDelete(mClear);
     SafeDelete(mTrim);
     SafeDelete(mPixelTransfer);
+    SafeDelete(mStateManager);
 
     SafeRelease(mDriverConstantBufferVS);
     SafeRelease(mDriverConstantBufferPS);
@@ -3961,4 +3865,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/AttributeMap.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/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/renderer/d3d/HLSLCompiler.h"
+#include "libANGLE/renderer/d3d/RendererD3D.h"
+#include "libANGLE/renderer/d3d/RenderTargetD3D.h"
 
 namespace gl
 {
@@ -120,13 +120,11 @@ class Renderer11 : public RendererD3D
                                 const std::vector<GLint> &vertexUniformBuffers,
                                 const std::vector<GLint> &fragmentUniformBuffers) 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);
+    gl::Error setRasterizerState(const gl::RasterizerState &rasterState,
+                                 const gl::State::DirtyBits &dirtyBits) override;
+
+    void setScissorRectangle(const gl::Rectangle &scissor, bool enabled) override;
 
-    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);
 
@@ -319,7 +317,6 @@ class Renderer11 : public RendererD3D
     uintptr_t mAppliedDSV;
     bool mDepthStencilInitialized;
     bool mRenderTargetDescInitialized;
-    unsigned int mCurStencilSize;
 
     struct RenderTargetDesc
     {
@@ -379,27 +376,6 @@ 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;
@@ -486,5 +462,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/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"
+#include "libANGLE/renderer/d3d/HLSLCompiler.h"
+#include "libANGLE/renderer/d3d/RendererD3D.h"
+#include "libANGLE/renderer/d3d/RenderTargetD3D.h"
 
 namespace gl
 {
@@ -96,13 +96,11 @@ class Renderer9 : public RendererD3D
                                 const std::vector<GLint> &vertexUniformBuffers,
                                 const std::vector<GLint> &fragmentUniformBuffers) 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);
+    gl::Error setRasterizerState(const gl::RasterizerState &rasterState,
+                                 const gl::State::DirtyBits &dirtyBits) override;
 
     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);
 
@@ -312,8 +310,6 @@ class Renderer9 : public RendererD3D
     unsigned int mAppliedDepthStencilSerial;
     bool mDepthStencilInitialized;
     bool mRenderTargetDescInitialized;
-    unsigned int mCurStencilSize;
-    unsigned int mCurDepthSize;
 
     struct RenderTargetDesc
     {
@@ -325,31 +321,12 @@ 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
     {
@@ -398,5 +375,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);
 }
 
-void RendererGL::syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits)
+gl::Error RendererGL::syncState(const gl::Data &data, const gl::State::DirtyBits &dirtyBits)
 {
-    mStateManager->syncState(state, dirtyBits);
+    return mStateManager->syncState(*data.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;
 
-    void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits) override;
+    gl::Error syncState(const gl::Data &data, 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)
     }
 }
 
-void StateManagerGL::syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits)
+gl::Error 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,6 +1507,8 @@ void StateManagerGL::syncState(const gl::State &state, const gl::State::DirtyBit
 
         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);
 
-    void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits);
+    gl::Error syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits);
 
   private:
     gl::Error setGenericDrawState(const gl::Data &data);

src/libGLESv2.gypi

@@ -215,6 +215,8 @@
             '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',
@@ -263,6 +265,8 @@
             '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',
@@ -371,6 +375,8 @@
             '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',