Using dirty bit notification for D3D9 rasterizer state

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

@@ -919,16 +919,9 @@ gl::Error Renderer9::updateState(const gl::Data &data, GLenum drawMode)
     rasterizer.pointDrawMode       = (drawMode == GL_POINTS);
     rasterizer.multiSample         = (samples != 0);
 
-    error = setRasterizerState(rasterizer);
-    if (error.isError())
-    {
-        return error;
-    }
-
-    // Setting blend state
     unsigned int mask = GetBlendSampleMask(data, samples);
-    error = setBlendState(framebufferObject, data.state->getBlendState(),
-                          data.state->getBlendColor(), mask);
+    error             = setBlendAndRasterizerState(data, mask);
+
     if (error.isError())
     {
         return error;
@@ -942,52 +935,15 @@ gl::Error Renderer9::updateState(const gl::Data &data, GLenum drawMode)
     return error;
 }
 
-gl::Error Renderer9::setRasterizerState(const gl::RasterizerState &rasterState)
+gl::Error Renderer9::setBlendAndRasterizerState(const gl::Data &glData, GLenum drawMode)
 {
-    bool rasterStateChanged = mForceSetRasterState || memcmp(&rasterState, &mCurRasterState, sizeof(gl::RasterizerState)) != 0;
-
-    if (rasterStateChanged)
-    {
-        // Set the cull mode
-        if (rasterState.cullFace)
-        {
-            mDevice->SetRenderState(D3DRS_CULLMODE, gl_d3d9::ConvertCullMode(rasterState.cullMode, rasterState.frontFace));
-        }
-        else
-        {
-            mDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
-        }
-
-        if (rasterState.polygonOffsetFill)
-        {
-            if (mCurDepthSize > 0)
-            {
-                mDevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, *(DWORD*)&rasterState.polygonOffsetFactor);
-
-                float depthBias = ldexp(rasterState.polygonOffsetUnits, -static_cast<int>(mCurDepthSize));
-                mDevice->SetRenderState(D3DRS_DEPTHBIAS, *(DWORD*)&depthBias);
-            }
-        }
-        else
-        {
-            mDevice->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, 0);
-            mDevice->SetRenderState(D3DRS_DEPTHBIAS, 0);
-        }
-
-        mCurRasterState = rasterState;
-    }
-
-    mForceSetRasterState = false;
-
-    return gl::Error(GL_NO_ERROR);
-}
+    int samples                    = glData.state->getDrawFramebuffer()->getSamples(glData);
+    gl::RasterizerState rasterizer = glData.state->getRasterizerState();
+    rasterizer.pointDrawMode       = (drawMode == GL_POINTS);
+    rasterizer.multiSample         = (samples != 0);
 
-gl::Error Renderer9::setBlendState(const gl::Framebuffer *framebuffer,
-                                   const gl::BlendState &blendState,
-                                   const gl::ColorF &blendColor,
-                                   unsigned int sampleMask)
-{
-    return mStateManager.setBlendState(framebuffer, blendState, blendColor, sampleMask);
+    unsigned int mask = GetBlendSampleMask(glData, samples);
+    return mStateManager.setBlendAndRasterizerState(*glData.state, mask);
 }
 
 gl::Error Renderer9::setDepthStencilState(const gl::State &glState)
@@ -1376,11 +1332,7 @@ gl::Error Renderer9::applyRenderTarget(const gl::FramebufferAttachment *colorAtt
             mDevice->SetDepthStencilSurface(NULL);
         }
 
-        if (!mDepthStencilInitialized || depthSize != mCurDepthSize)
-        {
-            mCurDepthSize = depthSize;
-            mForceSetRasterState = true;
-        }
+        mStateManager.updateDepthSizeIfChanged(mDepthStencilInitialized, depthSize);
 
         if (!mDepthStencilInitialized || stencilSize != mCurStencilSize)
         {
@@ -2241,9 +2193,9 @@ void Renderer9::markAllStateDirty()
     mRenderTargetDescInitialized = false;
 
     mForceSetDepthStencilState = true;
-    mForceSetRasterState = true;
     mForceSetScissor = true;
     mForceSetViewport = true;
+    mStateManager.forceSetRasterState();
     mStateManager.forceSetBlendState();
 
     ASSERT(mCurVertexSamplerStates.size() == mCurVertexTextures.size());

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

@@ -275,11 +275,7 @@ class Renderer9 : public RendererD3D
 
     WorkaroundsD3D generateWorkarounds() const override;
 
-    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);
+    gl::Error setBlendAndRasterizerState(const gl::Data &glData, GLenum drawMode);
     gl::Error setDepthStencilState(const gl::State &glState);
 
     void release();
@@ -337,7 +333,6 @@ class Renderer9 : public RendererD3D
     bool mDepthStencilInitialized;
     bool mRenderTargetDescInitialized;
     unsigned int mCurStencilSize;
-    unsigned int mCurDepthSize;
 
     struct RenderTargetDesc
     {
@@ -358,9 +353,6 @@ class Renderer9 : public RendererD3D
     int mCurStencilBackRef;
     bool mCurFrontFaceCCW;
 
-    bool mForceSetRasterState;
-    gl::RasterizerState mCurRasterState;
-
     bool mForceSetScissor;
     gl::Rectangle mCurScissor;
     bool mScissorEnabled;

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

@@ -20,6 +20,8 @@ StateManager9::StateManager9(Renderer9 *renderer9)
     : mCurBlendState(),
       mCurBlendColor(0, 0, 0, 0),
       mCurSampleMask(0),
+      mCurRasterState(),
+      mCurDepthSize(0),
       mRenderer9(renderer9),
       mDirtyBits()
 {
@@ -30,6 +32,9 @@ StateManager9::StateManager9(Renderer9 *renderer9)
     mBlendStateDirtyBits.set(DIRTY_BIT_COLOR_MASK);
     mBlendStateDirtyBits.set(DIRTY_BIT_DITHER);
     mBlendStateDirtyBits.set(DIRTY_BIT_SAMPLE_MASK);
+
+    mRasterizerStateDirtyBits.set(DIRTY_BIT_CULL_MODE);
+    mRasterizerStateDirtyBits.set(DIRTY_BIT_DEPTH_BIAS);
 }
 
 StateManager9::~StateManager9()
@@ -41,6 +46,11 @@ void StateManager9::forceSetBlendState()
     mDirtyBits |= mBlendStateDirtyBits;
 }
 
+void StateManager9::forceSetRasterState()
+{
+    mDirtyBits |= mRasterizerStateDirtyBits;
+}
+
 void StateManager9::syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits)
 {
     for (unsigned int dirtyBit : angle::IterateBitSet(dirtyBits))
@@ -111,18 +121,56 @@ void StateManager9::syncState(const gl::State &state, const gl::State::DirtyBits
                     mDirtyBits.set(DIRTY_BIT_BLEND_COLOR);
                 }
                 break;
+            case gl::State::DIRTY_BIT_CULL_FACE_ENABLED:
+                if (state.getRasterizerState().cullFace != mCurRasterState.cullFace)
+                {
+                    mDirtyBits.set(DIRTY_BIT_CULL_MODE);
+                }
+                break;
+            case gl::State::DIRTY_BIT_CULL_FACE:
+                if (state.getRasterizerState().cullMode != mCurRasterState.cullMode)
+                {
+                    mDirtyBits.set(DIRTY_BIT_CULL_MODE);
+                }
+                break;
+            case gl::State::DIRTY_BIT_FRONT_FACE:
+                if (state.getRasterizerState().frontFace != mCurRasterState.frontFace)
+                {
+                    mDirtyBits.set(DIRTY_BIT_CULL_MODE);
+                }
+                break;
+            case gl::State::DIRTY_BIT_POLYGON_OFFSET_FILL_ENABLED:
+                if (state.getRasterizerState().polygonOffsetFill !=
+                    mCurRasterState.polygonOffsetFill)
+                {
+                    mDirtyBits.set(DIRTY_BIT_DEPTH_BIAS);
+                }
+                break;
+            case gl::State::DIRTY_BIT_POLYGON_OFFSET:
+            {
+                const gl::RasterizerState &rasterizerState = state.getRasterizerState();
+                if (rasterizerState.polygonOffsetFactor != mCurRasterState.polygonOffsetFactor ||
+                    rasterizerState.polygonOffsetUnits != mCurRasterState.polygonOffsetUnits)
+                {
+                    mDirtyBits.set(DIRTY_BIT_DEPTH_BIAS);
+                }
+                break;
+            }
             default:
                 break;
         }
     }
 }
 
-gl::Error StateManager9::setBlendState(const gl::Framebuffer *framebuffer,
-                                       const gl::BlendState &blendState,
-                                       const gl::ColorF &blendColor,
-                                       unsigned int sampleMask)
+gl::Error StateManager9::setBlendAndRasterizerState(const gl::State &glState,
+                                                    unsigned int sampleMask)
 {
-    for (unsigned int dirtyBit : angle::IterateBitSet(mDirtyBits))
+    const gl::Framebuffer *framebuffer     = glState.getDrawFramebuffer();
+    const gl::BlendState &blendState       = glState.getBlendState();
+    const gl::ColorF &blendColor           = glState.getBlendColor();
+    const gl::RasterizerState &rasterState = glState.getRasterizerState();
+
+    for (auto dirtyBit : angle::IterateBitSet(mDirtyBits))
     {
         switch (dirtyBit)
         {
@@ -145,6 +193,12 @@ gl::Error StateManager9::setBlendState(const gl::Framebuffer *framebuffer,
             case DIRTY_BIT_DITHER:
                 setDither(blendState.dither);
                 break;
+            case DIRTY_BIT_CULL_MODE:
+                setCullMode(rasterState.cullFace, rasterState.cullMode, rasterState.frontFace);
+                break;
+            case DIRTY_BIT_DEPTH_BIAS:
+                setDepthBias(rasterState.polygonOffsetFill, rasterState.polygonOffsetFactor,
+                             rasterState.polygonOffsetUnits);
             default:
                 break;
         }
@@ -293,4 +347,56 @@ void StateManager9::setSampleMask(unsigned int sampleMask)
     mCurSampleMask = sampleMask;
 }
 
+void StateManager9::setCullMode(bool cullFace, GLenum cullMode, GLenum frontFace)
+{
+    if (cullFace)
+    {
+        mRenderer9->getDevice()->SetRenderState(D3DRS_CULLMODE,
+                                                gl_d3d9::ConvertCullMode(cullMode, frontFace));
+    }
+    else
+    {
+        mRenderer9->getDevice()->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
+    }
+
+    mCurRasterState.cullFace  = cullFace;
+    mCurRasterState.cullMode  = cullMode;
+    mCurRasterState.frontFace = frontFace;
+}
+
+void StateManager9::setDepthBias(bool polygonOffsetFill,
+                                 GLfloat polygonOffsetFactor,
+                                 GLfloat polygonOffsetUnits)
+{
+    if (polygonOffsetFill)
+    {
+        if (mCurDepthSize > 0)
+        {
+            IDirect3DDevice9 *device = mRenderer9->getDevice();
+            device->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, *(DWORD *)&polygonOffsetFactor);
+
+            float depthBias = ldexp(polygonOffsetUnits, -static_cast<int>(mCurDepthSize));
+            device->SetRenderState(D3DRS_DEPTHBIAS, *(DWORD *)&depthBias);
+        }
+    }
+    else
+    {
+        IDirect3DDevice9 *device = mRenderer9->getDevice();
+        device->SetRenderState(D3DRS_SLOPESCALEDEPTHBIAS, 0);
+        device->SetRenderState(D3DRS_DEPTHBIAS, 0);
+    }
+
+    mCurRasterState.polygonOffsetFill   = polygonOffsetFill;
+    mCurRasterState.polygonOffsetFactor = polygonOffsetFactor;
+    mCurRasterState.polygonOffsetUnits  = polygonOffsetUnits;
+}
+
+void StateManager9::updateDepthSizeIfChanged(bool depthStencilInitialized, unsigned int depthSize)
+{
+    if (!depthStencilInitialized || depthSize != mCurDepthSize)
+    {
+        mCurDepthSize = depthSize;
+        forceSetRasterState();
+    }
+}
 }  // namespace rx

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

@@ -26,14 +26,12 @@ class StateManager9 final : angle::NonCopyable
 
     void syncState(const gl::State &state, const gl::State::DirtyBits &dirtyBits);
 
-    gl::Error setBlendState(const gl::Framebuffer *framebuffer,
-                            const gl::BlendState &blendState,
-                            const gl::ColorF &blendColor,
-                            unsigned int sampleMask);
-
+    gl::Error setBlendAndRasterizerState(const gl::State &glState, unsigned int sampleMask);
     void forceSetBlendState();
+    void forceSetRasterState();
+
+    void updateDepthSizeIfChanged(bool depthStencilInitialized, unsigned int depthSize);
     void resetDirtyBits() { mDirtyBits.reset(); }
-    VendorID getVendorId() const;
 
   private:
     void setBlendEnabled(bool enabled);
@@ -53,6 +51,12 @@ class StateManager9 final : angle::NonCopyable
 
     void setSampleMask(unsigned int sampleMask);
 
+    // Current raster state functions
+    void setCullMode(bool cullFace, GLenum cullMode, GLenum frontFace);
+    void setDepthBias(bool polygonOffsetFill,
+                      GLfloat polygonOffsetFactor,
+                      GLfloat polygonOffsetUnits);
+
     enum DirtyBitType
     {
         DIRTY_BIT_BLEND_ENABLED,
@@ -63,6 +67,9 @@ class StateManager9 final : angle::NonCopyable
         DIRTY_BIT_DITHER,
         DIRTY_BIT_SAMPLE_MASK,
 
+        DIRTY_BIT_CULL_MODE,
+        DIRTY_BIT_DEPTH_BIAS,
+
         DIRTY_BIT_MAX
     };
 
@@ -74,6 +81,11 @@ class StateManager9 final : angle::NonCopyable
     unsigned int mCurSampleMask;
     DirtyBits mBlendStateDirtyBits;
 
+    // Currently applied raster state
+    gl::RasterizerState mCurRasterState;
+    unsigned int mCurDepthSize;
+    DirtyBits mRasterizerStateDirtyBits;
+
     Renderer9 *mRenderer9;
     DirtyBits mDirtyBits;
 };