D3D11: Move applyShaders to StateManager11.

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -288,9 +288,8 @@ bool RendererD3D::isRobustResourceInitEnabled() const
     return mDisplay->isRobustResourceInitEnabled();
 }
 
-unsigned int GetBlendSampleMask(const gl::ContextState &data, int samples)
+unsigned int GetBlendSampleMask(const gl::State &glState, int samples)
 {
-    const auto &glState = data.getState();
     unsigned int mask   = 0;
     if (glState.isSampleCoverageEnabled())
     {

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -367,7 +367,7 @@ class RendererD3D : public BufferFactoryD3D
     angle::WorkerThreadPool mWorkerThreadPool;
 };
 
-unsigned int GetBlendSampleMask(const gl::ContextState &data, int samples);
+unsigned int GetBlendSampleMask(const gl::State &glState, int samples);
 
 }  // namespace rx
 

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

@@ -2190,56 +2190,6 @@ gl::Error Renderer11::drawTriangleFan(const gl::ContextState &data,
     return gl::NoError();
 }
 
-gl::Error Renderer11::applyShaders(const gl::Context *context, GLenum drawMode)
-{
-    // This method is called single-threaded.
-    ANGLE_TRY(ensureHLSLCompilerInitialized());
-
-    const auto &data       = context->getContextState();
-    const auto &glState    = data.getState();
-    ProgramD3D *programD3D = GetImplAs<ProgramD3D>(glState.getProgram());
-    programD3D->updateCachedInputLayout(glState);
-
-    const auto &inputLayout = programD3D->getCachedInputLayout();
-
-    ShaderExecutableD3D *vertexExe = nullptr;
-    ANGLE_TRY(programD3D->getVertexExecutableForInputLayout(inputLayout, &vertexExe, nullptr));
-
-    const gl::Framebuffer *drawFramebuffer = glState.getDrawFramebuffer();
-    ShaderExecutableD3D *pixelExe          = nullptr;
-    ANGLE_TRY(programD3D->getPixelExecutableForFramebuffer(context, drawFramebuffer, &pixelExe));
-
-    ShaderExecutableD3D *geometryExe = nullptr;
-    ANGLE_TRY(
-        programD3D->getGeometryExecutableForPrimitiveType(data, drawMode, &geometryExe, nullptr));
-
-    const d3d11::VertexShader *vertexShader =
-        (vertexExe ? &GetAs<ShaderExecutable11>(vertexExe)->getVertexShader() : nullptr);
-
-    // Skip pixel shader if we're doing rasterizer discard.
-    const d3d11::PixelShader *pixelShader = nullptr;
-    if (!glState.getRasterizerState().rasterizerDiscard)
-    {
-        pixelShader = (pixelExe ? &GetAs<ShaderExecutable11>(pixelExe)->getPixelShader() : nullptr);
-    }
-
-    const d3d11::GeometryShader *geometryShader = nullptr;
-    if (glState.isTransformFeedbackActiveUnpaused())
-    {
-        geometryShader =
-            (vertexExe ? &GetAs<ShaderExecutable11>(vertexExe)->getStreamOutShader() : nullptr);
-    }
-    else
-    {
-        geometryShader =
-            (geometryExe ? &GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : nullptr);
-    }
-
-    mStateManager.setDrawShaders(vertexShader, geometryShader, pixelShader);
-
-    return programD3D->applyUniforms(drawMode);
-}
-
 // TODO(jmadill): Move to StateManager11.
 gl::Error Renderer11::applyUniforms(const ProgramD3D &programD3D,
                                     GLenum drawMode,
@@ -4313,7 +4263,6 @@ gl::Error Renderer11::genericDrawElements(const gl::Context *context,
     size_t vertexCount = indexInfo.indexRange.vertexCount();
     ANGLE_TRY(applyVertexBuffer(context, mode, static_cast<GLsizei>(indexInfo.indexRange.start),
                                 static_cast<GLsizei>(vertexCount), instances, &indexInfo));
-    ANGLE_TRY(applyShaders(context, mode));
     ANGLE_TRY(programD3D->applyUniformBuffers(data));
 
     if (!skipDraw(data, mode))
@@ -4348,7 +4297,6 @@ gl::Error Renderer11::genericDrawArrays(const gl::Context *context,
     ANGLE_TRY(mStateManager.updateState(context, mode));
     ANGLE_TRY(applyTransformFeedbackBuffers(data));
     ANGLE_TRY(applyVertexBuffer(context, mode, first, count, instances, nullptr));
-    ANGLE_TRY(applyShaders(context, mode));
     ANGLE_TRY(programD3D->applyUniformBuffers(data));
 
     if (!skipDraw(data, mode))
@@ -4382,7 +4330,6 @@ gl::Error Renderer11::genericDrawIndirect(const gl::Context *context,
     ANGLE_TRY(mStateManager.updateState(context, mode));
     ANGLE_TRY(applyTransformFeedbackBuffers(contextState));
     ASSERT(!glState.isTransformFeedbackActiveUnpaused());
-    ANGLE_TRY(applyShaders(context, mode));
     ANGLE_TRY(programD3D->applyUniformBuffers(contextState));
 
     if (type == GL_NONE)

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

@@ -513,7 +513,6 @@ class Renderer11 : public RendererD3D
                               int baseVertex,
                               int instances);
 
-    gl::Error applyShaders(const gl::Context *context, GLenum drawMode);
     gl::Error generateSwizzle(const gl::Context *context, gl::Texture *texture);
     gl::Error generateSwizzles(const gl::Context *context, gl::SamplerType type);
     gl::Error generateSwizzles(const gl::Context *context);

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

@@ -17,6 +17,7 @@
 #include "libANGLE/renderer/d3d/d3d11/Framebuffer11.h"
 #include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h"
 #include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
+#include "libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h"
 #include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h"
 
 namespace rx
@@ -1371,8 +1372,10 @@ void StateManager11::setSingleVertexBuffer(const d3d11::Buffer *buffer, UINT str
 
 gl::Error StateManager11::updateState(const gl::Context *context, GLenum drawMode)
 {
-    const auto &data    = context->getContextState();
-    const auto &glState = data.getState();
+    const auto &glState = context->getGLState();
+
+    // TODO(jmadill): Use dirty bits.
+    ANGLE_TRY(syncProgram(context, drawMode));
 
     gl::Framebuffer *framebuffer = glState.getDrawFramebuffer();
     Framebuffer11 *framebuffer11 = GetImplAs<Framebuffer11>(framebuffer);
@@ -1393,7 +1396,7 @@ gl::Error StateManager11::updateState(const gl::Context *context, GLenum drawMod
     // TODO(jmadill): This can be recomputed only on framebuffer changes.
     RenderTarget11 *firstRT = framebuffer11->getFirstRenderTarget();
     int samples             = (firstRT ? firstRT->getSamples() : 0);
-    unsigned int sampleMask = GetBlendSampleMask(data, samples);
+    unsigned int sampleMask = GetBlendSampleMask(glState, samples);
     if (sampleMask != mCurSampleMask)
     {
         mInternalDirtyBits.set(DIRTY_BIT_BLEND_STATE);
@@ -1410,7 +1413,7 @@ gl::Error StateManager11::updateState(const gl::Context *context, GLenum drawMod
                 ANGLE_TRY(syncFramebuffer(context, framebuffer));
                 break;
             case DIRTY_BIT_VIEWPORT_STATE:
-                syncViewport(&data.getCaps(), glState.getViewport(), glState.getNearPlane(),
+                syncViewport(&context->getCaps(), glState.getViewport(), glState.getNearPlane(),
                              glState.getFarPlane());
                 break;
             case DIRTY_BIT_SCISSOR_STATE:
@@ -1435,6 +1438,11 @@ gl::Error StateManager11::updateState(const gl::Context *context, GLenum drawMod
     // TODO(jmadill): Use dirty bits.
     ANGLE_TRY(syncTextures(context));
 
+    // This must happen after viewport sync, because the viewport affects builtin uniforms.
+    // TODO(jmadill): Use dirty bits.
+    auto *programD3D = GetImplAs<ProgramD3D>(glState.getProgram());
+    ANGLE_TRY(programD3D->applyUniforms(drawMode));
+
     // Check that we haven't set any dirty bits in the flushing of the dirty bits loop.
     ASSERT(mInternalDirtyBits.none());
 
@@ -1717,7 +1725,54 @@ gl::Error StateManager11::setTexture(const gl::Context *context,
          static_cast<unsigned int>(index) < mRenderer->getNativeCaps().maxVertexTextureImageUnits));
 
     setShaderResource(type, index, textureSRV->get());
+    return gl::NoError();
+}
+
+gl::Error StateManager11::syncProgram(const gl::Context *context, GLenum drawMode)
+{
+    // This method is called single-threaded.
+    ANGLE_TRY(mRenderer->ensureHLSLCompilerInitialized());
+
+    const auto &glState    = context->getGLState();
+    ProgramD3D *programD3D = GetImplAs<ProgramD3D>(glState.getProgram());
+    programD3D->updateCachedInputLayout(glState);
+
+    const auto &inputLayout = programD3D->getCachedInputLayout();
+
+    ShaderExecutableD3D *vertexExe = nullptr;
+    ANGLE_TRY(programD3D->getVertexExecutableForInputLayout(inputLayout, &vertexExe, nullptr));
+
+    const gl::Framebuffer *drawFramebuffer = glState.getDrawFramebuffer();
+    ShaderExecutableD3D *pixelExe          = nullptr;
+    ANGLE_TRY(programD3D->getPixelExecutableForFramebuffer(context, drawFramebuffer, &pixelExe));
+
+    ShaderExecutableD3D *geometryExe = nullptr;
+    ANGLE_TRY(programD3D->getGeometryExecutableForPrimitiveType(context->getContextState(),
+                                                                drawMode, &geometryExe, nullptr));
+
+    const d3d11::VertexShader *vertexShader =
+        (vertexExe ? &GetAs<ShaderExecutable11>(vertexExe)->getVertexShader() : nullptr);
+
+    // Skip pixel shader if we're doing rasterizer discard.
+    const d3d11::PixelShader *pixelShader = nullptr;
+    if (!glState.getRasterizerState().rasterizerDiscard)
+    {
+        pixelShader = (pixelExe ? &GetAs<ShaderExecutable11>(pixelExe)->getPixelShader() : nullptr);
+    }
+
+    const d3d11::GeometryShader *geometryShader = nullptr;
+    if (glState.isTransformFeedbackActiveUnpaused())
+    {
+        geometryShader =
+            (vertexExe ? &GetAs<ShaderExecutable11>(vertexExe)->getStreamOutShader() : nullptr);
+    }
+    else
+    {
+        geometryShader =
+            (geometryExe ? &GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : nullptr);
+    }
 
+    setDrawShaders(vertexShader, geometryShader, pixelShader);
     return gl::NoError();
 }
 

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

@@ -179,6 +179,7 @@ class StateManager11 final : angle::NonCopyable
     void checkPresentPath(const gl::Context *context);
 
     gl::Error syncFramebuffer(const gl::Context *context, gl::Framebuffer *framebuffer);
+    gl::Error syncProgram(const gl::Context *context, GLenum drawMode);
 
     gl::Error syncTextures(const gl::Context *context);
     gl::Error applyTextures(const gl::Context *context,

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

@@ -1037,8 +1037,7 @@ gl::Error Renderer9::setUniformBuffers(const gl::ContextState & /*data*/,
 
 gl::Error Renderer9::updateState(const gl::Context *context, GLenum drawMode)
 {
-    const auto &data    = context->getContextState();
-    const auto &glState = data.getState();
+    const auto &glState = context->getGLState();
 
     // Applies the render target surface, depth stencil surface, viewport rectangle and
     // scissor rectangle to the renderer
@@ -1071,7 +1070,7 @@ gl::Error Renderer9::updateState(const gl::Context *context, GLenum drawMode)
     rasterizer.pointDrawMode       = (drawMode == GL_POINTS);
     rasterizer.multiSample         = (samples != 0);
 
-    unsigned int mask = GetBlendSampleMask(data, samples);
+    unsigned int mask = GetBlendSampleMask(glState, samples);
     ANGLE_TRY(setBlendDepthRasterStates(context, mask));
 
     mStateManager.resetDirtyBits();
@@ -1105,7 +1104,7 @@ gl::Error Renderer9::setBlendDepthRasterStates(const gl::Context *context, GLenu
     rasterizer.pointDrawMode       = (drawMode == GL_POINTS);
     rasterizer.multiSample         = (samples != 0);
 
-    unsigned int mask = GetBlendSampleMask(context->getContextState(), samples);
+    unsigned int mask = GetBlendSampleMask(glState, samples);
     return mStateManager.setBlendDepthRasterStates(glState, mask);
 }