D3D11: Consolidate shader state application.

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

@@ -966,7 +966,7 @@ gl::Error Blit11::getShaderSupport(const Shader &shader, Blit11::ShaderSupport *
         ANGLE_TRY(mQuad2DIL.resolve(mRenderer));
         ANGLE_TRY(mQuad2DVS.resolve(mRenderer));
         supportOut->inputLayout         = &mQuad2DIL.getObj();
-        supportOut->vertexShader        = mQuad2DVS.get();
+        supportOut->vertexShader        = &mQuad2DVS.getObj();
         supportOut->geometryShader      = nullptr;
         supportOut->vertexWriteFunction = Write2DVertices;
     }
@@ -977,8 +977,8 @@ gl::Error Blit11::getShaderSupport(const Shader &shader, Blit11::ShaderSupport *
         ANGLE_TRY(mQuad3DVS.resolve(mRenderer));
         ANGLE_TRY(mQuad3DGS.resolve(mRenderer));
         supportOut->inputLayout         = &mQuad2DIL.getObj();
-        supportOut->vertexShader        = mQuad3DVS.get();
-        supportOut->geometryShader      = mQuad3DGS.get();
+        supportOut->vertexShader        = &mQuad3DVS.getObj();
+        supportOut->geometryShader      = &mQuad3DGS.getObj();
         supportOut->vertexWriteFunction = Write3DVertices;
     }
 
@@ -1095,10 +1095,9 @@ gl::Error Blit11::swizzleTexture(const gl::Context *context,
     // Apply shaders
     stateManager->setInputLayout(support.inputLayout);
     stateManager->setPrimitiveTopology(topology);
-    deviceContext->VSSetShader(support.vertexShader, nullptr, 0);
 
-    deviceContext->PSSetShader(shader->pixelShader.get(), nullptr, 0);
-    deviceContext->GSSetShader(support.geometryShader, nullptr, 0);
+    stateManager->setDrawShaders(support.vertexShader, support.geometryShader,
+                                 &shader->pixelShader);
 
     // Unset the currently bound shader resource to avoid conflicts
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
@@ -1230,10 +1229,9 @@ gl::Error Blit11::copyTexture(const gl::Context *context,
     // Apply shaders
     stateManager->setInputLayout(support.inputLayout);
     stateManager->setPrimitiveTopology(topology);
-    deviceContext->VSSetShader(support.vertexShader, nullptr, 0);
 
-    deviceContext->PSSetShader(shader->pixelShader.get(), nullptr, 0);
-    deviceContext->GSSetShader(support.geometryShader, nullptr, 0);
+    stateManager->setDrawShaders(support.vertexShader, support.geometryShader,
+                                 &shader->pixelShader);
 
     // Unset the currently bound shader resource to avoid conflicts
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
@@ -1362,10 +1360,8 @@ gl::Error Blit11::copyDepth(const gl::Context *context,
     // Apply shaders
     stateManager->setInputLayout(&mQuad2DIL.getObj());
     stateManager->setPrimitiveTopology(topology);
-    deviceContext->VSSetShader(mQuad2DVS.get(), nullptr, 0);
 
-    deviceContext->PSSetShader(mDepthPS.get(), nullptr, 0);
-    deviceContext->GSSetShader(nullptr, nullptr, 0);
+    stateManager->setDrawShaders(&mQuad2DVS.getObj(), nullptr, &mDepthPS.getObj());
 
     // Unset the currently bound shader resource to avoid conflicts
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
@@ -2021,8 +2017,8 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveDepth(const gl::Context *conte
     // Apply the necessary state changes to the D3D11 immediate device context.
     stateManager->setInputLayout(nullptr);
     stateManager->setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
-    deviceContext->VSSetShader(mResolveDepthStencilVS.get(), nullptr, 0);
-    deviceContext->GSSetShader(nullptr, nullptr, 0);
+    stateManager->setDrawShaders(&mResolveDepthStencilVS.getObj(), nullptr,
+                                 &mResolveDepthPS.getObj());
     deviceContext->RSSetState(nullptr);
     deviceContext->OMSetDepthStencilState(mDepthStencilState.get(), 0xFFFFFFFF);
     deviceContext->OMSetRenderTargets(0, nullptr, mResolvedDepthDSView.get());
@@ -2042,8 +2038,6 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveDepth(const gl::Context *conte
 
     deviceContext->PSSetShaderResources(0, 1, pixelViews);
 
-    deviceContext->PSSetShader(mResolveDepthPS.get(), nullptr, 0);
-
     // Trigger the blit on the GPU.
     deviceContext->Draw(6, 0);
 
@@ -2178,11 +2172,25 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveStencil(const gl::Context *con
 
     ANGLE_TRY(mResolveDepthStencilVS.resolve(mRenderer));
 
+    // Resolving the depth buffer works by sampling the depth in the shader using a SRV, then
+    // writing to the resolved depth buffer using SV_Depth. We can't use this method for stencil
+    // because SV_StencilRef isn't supported until HLSL 5.1/D3D11.3.
+    const d3d11::PixelShader *pixelShader = nullptr;
+    if (alsoDepth)
+    {
+        ANGLE_TRY(mResolveDepthStencilPS.resolve(mRenderer));
+        pixelShader = &mResolveDepthStencilPS.getObj();
+    }
+    else
+    {
+        ANGLE_TRY(mResolveStencilPS.resolve(mRenderer));
+        pixelShader = &mResolveStencilPS.getObj();
+    }
+
     // Apply the necessary state changes to the D3D11 immediate device context.
     stateManager->setInputLayout(nullptr);
     stateManager->setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
-    deviceContext->VSSetShader(mResolveDepthStencilVS.get(), nullptr, 0);
-    deviceContext->GSSetShader(nullptr, nullptr, 0);
+    stateManager->setDrawShaders(&mResolveDepthStencilVS.getObj(), nullptr, pixelShader);
     deviceContext->RSSetState(nullptr);
     deviceContext->OMSetDepthStencilState(nullptr, 0xFFFFFFFF);
     deviceContext->OMSetRenderTargets(1, rtvs, nullptr);
@@ -2204,20 +2212,6 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveStencil(const gl::Context *con
 
     deviceContext->PSSetShaderResources(0, 2, pixelViews);
 
-    // Resolving the depth buffer works by sampling the depth in the shader using a SRV, then
-    // writing to the resolved depth buffer using SV_Depth. We can't use this method for stencil
-    // because SV_StencilRef isn't supported until HLSL 5.1/D3D11.3.
-    if (alsoDepth)
-    {
-        ANGLE_TRY(mResolveDepthStencilPS.resolve(mRenderer));
-        deviceContext->PSSetShader(mResolveDepthStencilPS.get(), nullptr, 0);
-    }
-    else
-    {
-        ANGLE_TRY(mResolveStencilPS.resolve(mRenderer));
-        deviceContext->PSSetShader(mResolveStencilPS.get(), nullptr, 0);
-    }
-
     // Trigger the blit on the GPU.
     deviceContext->Draw(6, 0);
 

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

@@ -201,8 +201,8 @@ class Blit11 : angle::NonCopyable
     struct ShaderSupport
     {
         const d3d11::InputLayout *inputLayout;
-        ID3D11VertexShader *vertexShader;
-        ID3D11GeometryShader *geometryShader;
+        const d3d11::VertexShader *vertexShader;
+        const d3d11::GeometryShader *geometryShader;
         WriteVertexFunction vertexWriteFunction;
     };
 

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

@@ -99,8 +99,8 @@ Clear11::ShaderManager::~ShaderManager()
 gl::Error Clear11::ShaderManager::getShadersAndLayout(Renderer11 *renderer,
                                                       const INT clearType,
                                                       const d3d11::InputLayout **il,
-                                                      ID3D11VertexShader **vs,
-                                                      ID3D11PixelShader **ps)
+                                                      const d3d11::VertexShader **vs,
+                                                      const d3d11::PixelShader **ps)
 {
     if (renderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3)
     {
@@ -120,29 +120,29 @@ gl::Error Clear11::ShaderManager::getShadersAndLayout(Renderer11 *renderer,
             ANGLE_TRY(renderer->allocateResource(ilDescArray, &vertexShader, &mIl9));
         }
 
-        *vs = mVs9.get();
+        *vs = &mVs9.getObj();
         *il = &mIl9;
-        *ps = mPsFloat9.get();
+        *ps = &mPsFloat9.getObj();
         return gl::NoError();
     }
 
     ANGLE_TRY(mVs.resolve(renderer));
-    *vs = mVs.get();
+    *vs = &mVs.getObj();
     *il = nullptr;
 
     switch (clearType)
     {
         case GL_FLOAT:
             ANGLE_TRY(mPsFloat.resolve(renderer));
-            *ps = mPsFloat.get();
+            *ps = &mPsFloat.getObj();
             break;
         case GL_UNSIGNED_INT:
             ANGLE_TRY(mPsUInt.resolve(renderer));
-            *ps = mPsUInt.get();
+            *ps = &mPsUInt.getObj();
             break;
         case GL_INT:
             ANGLE_TRY(mPsSInt.resolve(renderer));
-            *ps = mPsSInt.get();
+            *ps = &mPsSInt.getObj();
             break;
         default:
             UNREACHABLE();
@@ -680,16 +680,14 @@ gl::Error Clear11::clearFramebuffer(const gl::Context *context,
     auto *stateManager = mRenderer->getStateManager();
 
     // Get Shaders
-    ID3D11VertexShader *vs       = nullptr;
-    const d3d11::InputLayout *il = nullptr;
-    ID3D11PixelShader *ps        = nullptr;
+    const d3d11::VertexShader *vs = nullptr;
+    const d3d11::InputLayout *il  = nullptr;
+    const d3d11::PixelShader *ps  = nullptr;
 
     ANGLE_TRY(mShaderManager.getShadersAndLayout(mRenderer, clearParams.colorType, &il, &vs, &ps));
 
     // Apply Shaders
-    deviceContext->VSSetShader(vs, nullptr, 0);
-    deviceContext->GSSetShader(nullptr, nullptr, 0);
-    deviceContext->PSSetShader(ps, nullptr, 0);
+    stateManager->setDrawShaders(vs, nullptr, ps);
     ID3D11Buffer *constantBuffer = mConstantBuffer.get();
     deviceContext->PSSetConstantBuffers(0, 1, &constantBuffer);
 

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

@@ -51,8 +51,8 @@ class Clear11 : angle::NonCopyable
         gl::Error getShadersAndLayout(Renderer11 *renderer,
                                       const INT clearType,
                                       const d3d11::InputLayout **il,
-                                      ID3D11VertexShader **vs,
-                                      ID3D11PixelShader **ps);
+                                      const d3d11::VertexShader **vs,
+                                      const d3d11::PixelShader **ps);
 
       private:
         d3d11::InputLayout mIl9;

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

@@ -157,7 +157,7 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::Context *context,
 
     ASSERT(mRenderer->supportsFastCopyBufferToTexture(destinationFormat));
 
-    ID3D11PixelShader *pixelShader = findBufferToTexturePS(destinationFormat);
+    const d3d11::PixelShader *pixelShader = findBufferToTexturePS(destinationFormat);
     ASSERT(pixelShader);
 
     // The SRV must be in the proper read format, which may be different from the destination format
@@ -186,13 +186,10 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::Context *context,
     ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
 
     // Are we doing a 2D or 3D copy?
-    ID3D11GeometryShader *geometryShader =
-        ((destSize.depth > 1) ? mBufferToTextureGS.get() : nullptr);
-    auto stateManager                    = mRenderer->getStateManager();
+    const auto *geometryShader = ((destSize.depth > 1) ? &mBufferToTextureGS : nullptr);
+    auto stateManager          = mRenderer->getStateManager();
 
-    deviceContext->VSSetShader(mBufferToTextureVS.get(), nullptr, 0);
-    deviceContext->GSSetShader(geometryShader, nullptr, 0);
-    deviceContext->PSSetShader(pixelShader, nullptr, 0);
+    stateManager->setDrawShaders(&mBufferToTextureVS, geometryShader, pixelShader);
     stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, bufferSRV);
     stateManager->setInputLayout(nullptr);
     stateManager->setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
@@ -261,7 +258,7 @@ gl::Error PixelTransfer11::buildShaderMap()
     return gl::NoError();
 }
 
-ID3D11PixelShader *PixelTransfer11::findBufferToTexturePS(GLenum internalFormat) const
+const d3d11::PixelShader *PixelTransfer11::findBufferToTexturePS(GLenum internalFormat) const
 {
     GLenum componentType = gl::GetSizedInternalFormatInfo(internalFormat).componentType;
     if (componentType == GL_SIGNED_NORMALIZED || componentType == GL_UNSIGNED_NORMALIZED)
@@ -270,7 +267,7 @@ ID3D11PixelShader *PixelTransfer11::findBufferToTexturePS(GLenum internalFormat)
     }
 
     auto shaderMapIt = mBufferToTexturePSMap.find(componentType);
-    return (shaderMapIt == mBufferToTexturePSMap.end() ? nullptr : shaderMapIt->second.get());
+    return (shaderMapIt == mBufferToTexturePSMap.end() ? nullptr : &shaderMapIt->second);
 }
 
 }  // namespace rx

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

@@ -73,7 +73,7 @@ class PixelTransfer11
 
     gl::Error loadResources();
     gl::Error buildShaderMap();
-    ID3D11PixelShader *findBufferToTexturePS(GLenum internalFormat) const;
+    const d3d11::PixelShader *findBufferToTexturePS(GLenum internalFormat) const;
 
     Renderer11 *mRenderer;
 

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

@@ -423,11 +423,6 @@ Renderer11::Renderer11(egl::Display *display)
     mDxgiAdapter    = nullptr;
     mDxgiFactory    = nullptr;
 
-    mAppliedVertexShader   = angle::DirtyPointer;
-    mAppliedGeometryShader = angle::DirtyPointer;
-    mAppliedPixelShader    = angle::DirtyPointer;
-    mAppliedComputeShader  = angle::DirtyPointer;
-
     mAppliedTFObject = angle::DirtyPointer;
 
     ZeroMemory(&mAdapterDescription, sizeof(mAdapterDescription));
@@ -1858,7 +1853,7 @@ gl::Error Renderer11::drawArraysImpl(const gl::Context *context,
         // won't get the correct output. To work around this, draw with *only* the stream out
         // first (no pixel shader) to feed the stream out buffers and then draw again with the
         // geometry shader + pixel shader to rasterize the primitives.
-        mDeviceContext->PSSetShader(nullptr, nullptr, 0);
+        mStateManager.setPixelShader(nullptr);
 
         if (instances > 0)
         {
@@ -1879,20 +1874,15 @@ gl::Error Renderer11::drawArraysImpl(const gl::Context *context,
             return gl::NoError();
         }
 
-        ID3D11PixelShader *pixelShader = GetAs<ShaderExecutable11>(pixelExe)->getPixelShader();
-        ASSERT(reinterpret_cast<uintptr_t>(pixelShader) == mAppliedPixelShader);
-        mDeviceContext->PSSetShader(pixelShader, nullptr, 0);
+        mStateManager.setPixelShader(&GetAs<ShaderExecutable11>(pixelExe)->getPixelShader());
 
         // Retrieve the geometry shader.
         rx::ShaderExecutableD3D *geometryExe = nullptr;
         ANGLE_TRY(
             programD3D->getGeometryExecutableForPrimitiveType(data, mode, &geometryExe, nullptr));
 
-        ID3D11GeometryShader *geometryShader =
-            (geometryExe ? GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : nullptr);
-        mAppliedGeometryShader = reinterpret_cast<uintptr_t>(geometryShader);
-        ASSERT(geometryShader);
-        mDeviceContext->GSSetShader(geometryShader, nullptr, 0);
+        mStateManager.setGeometryShader(
+            &GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader());
 
         if (instances > 0)
         {
@@ -2379,45 +2369,29 @@ gl::Error Renderer11::applyShaders(const gl::Context *context, GLenum drawMode)
     ANGLE_TRY(
         programD3D->getGeometryExecutableForPrimitiveType(data, drawMode, &geometryExe, nullptr));
 
-    ID3D11VertexShader *vertexShader =
-        (vertexExe ? GetAs<ShaderExecutable11>(vertexExe)->getVertexShader() : nullptr);
+    const d3d11::VertexShader *vertexShader =
+        (vertexExe ? &GetAs<ShaderExecutable11>(vertexExe)->getVertexShader() : nullptr);
 
     // Skip pixel shader if we're doing rasterizer discard.
-    ID3D11PixelShader *pixelShader = nullptr;
+    const d3d11::PixelShader *pixelShader = nullptr;
     if (!glState.getRasterizerState().rasterizerDiscard)
     {
-        pixelShader = (pixelExe ? GetAs<ShaderExecutable11>(pixelExe)->getPixelShader() : nullptr);
+        pixelShader = (pixelExe ? &GetAs<ShaderExecutable11>(pixelExe)->getPixelShader() : nullptr);
     }
 
-    ID3D11GeometryShader *geometryShader = nullptr;
+    const d3d11::GeometryShader *geometryShader = nullptr;
     if (glState.isTransformFeedbackActiveUnpaused())
     {
         geometryShader =
-            (vertexExe ? GetAs<ShaderExecutable11>(vertexExe)->getStreamOutShader() : nullptr);
+            (vertexExe ? &GetAs<ShaderExecutable11>(vertexExe)->getStreamOutShader() : nullptr);
     }
     else
     {
         geometryShader =
-            (geometryExe ? GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : nullptr);
+            (geometryExe ? &GetAs<ShaderExecutable11>(geometryExe)->getGeometryShader() : nullptr);
     }
 
-    if (reinterpret_cast<uintptr_t>(vertexShader) != mAppliedVertexShader)
-    {
-        mDeviceContext->VSSetShader(vertexShader, nullptr, 0);
-        mAppliedVertexShader = reinterpret_cast<uintptr_t>(vertexShader);
-    }
-
-    if (reinterpret_cast<uintptr_t>(geometryShader) != mAppliedGeometryShader)
-    {
-        mDeviceContext->GSSetShader(geometryShader, nullptr, 0);
-        mAppliedGeometryShader = reinterpret_cast<uintptr_t>(geometryShader);
-    }
-
-    if (reinterpret_cast<uintptr_t>(pixelShader) != mAppliedPixelShader)
-    {
-        mDeviceContext->PSSetShader(pixelShader, nullptr, 0);
-        mAppliedPixelShader = reinterpret_cast<uintptr_t>(pixelShader);
-    }
+    mStateManager.setDrawShaders(vertexShader, geometryShader, pixelShader);
 
     return programD3D->applyUniforms(drawMode);
 }
@@ -2761,11 +2735,6 @@ void Renderer11::markAllStateDirty(const gl::Context *context)
     mAppliedIBFormat = DXGI_FORMAT_UNKNOWN;
     mAppliedIBOffset = 0;
 
-    mAppliedVertexShader   = angle::DirtyPointer;
-    mAppliedGeometryShader = angle::DirtyPointer;
-    mAppliedPixelShader    = angle::DirtyPointer;
-    mAppliedComputeShader  = angle::DirtyPointer;
-
     mAppliedTFObject = angle::DirtyPointer;
 
     memset(&mAppliedVertexConstants, 0, sizeof(dx_VertexConstants11));
@@ -4748,15 +4717,9 @@ gl::Error Renderer11::applyComputeShader(const gl::ContextState &data)
 
     ShaderExecutableD3D *computeExe = nullptr;
     ANGLE_TRY(programD3D->getComputeExecutable(&computeExe));
-
     ASSERT(computeExe != nullptr);
-    ID3D11ComputeShader *computeShader = GetAs<ShaderExecutable11>(computeExe)->getComputeShader();
 
-    if (reinterpret_cast<uintptr_t>(computeShader) != mAppliedComputeShader)
-    {
-        mDeviceContext->CSSetShader(computeShader, nullptr, 0);
-        mAppliedComputeShader = reinterpret_cast<uintptr_t>(computeShader);
-    }
+    mStateManager.setComputeShader(&GetAs<ShaderExecutable11>(computeExe)->getComputeShader());
 
     return programD3D->applyComputeUniforms();
 }

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

@@ -630,12 +630,6 @@ class Renderer11 : public RendererD3D
     // Currently applied transform feedback buffers
     uintptr_t mAppliedTFObject;
 
-    // Currently applied shaders
-    uintptr_t mAppliedVertexShader;
-    uintptr_t mAppliedGeometryShader;
-    uintptr_t mAppliedPixelShader;
-    uintptr_t mAppliedComputeShader;
-
     dx_VertexConstants11 mAppliedVertexConstants;
     d3d11::Buffer mDriverConstantBufferVS;
     SamplerMetadataD3D11 mSamplerMetadataVS;

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

@@ -66,29 +66,29 @@ ShaderExecutable11::~ShaderExecutable11()
 {
 }
 
-ID3D11VertexShader *ShaderExecutable11::getVertexShader() const
+const d3d11::VertexShader &ShaderExecutable11::getVertexShader() const
 {
-    return mVertexExecutable.get();
+    return mVertexExecutable;
 }
 
-ID3D11PixelShader *ShaderExecutable11::getPixelShader() const
+const d3d11::PixelShader &ShaderExecutable11::getPixelShader() const
 {
-    return mPixelExecutable.get();
+    return mPixelExecutable;
 }
 
-ID3D11GeometryShader *ShaderExecutable11::getGeometryShader() const
+const d3d11::GeometryShader &ShaderExecutable11::getGeometryShader() const
 {
-    return mGeometryExecutable.get();
+    return mGeometryExecutable;
 }
 
-ID3D11GeometryShader *ShaderExecutable11::getStreamOutShader() const
+const d3d11::GeometryShader &ShaderExecutable11::getStreamOutShader() const
 {
-    return mStreamOutExecutable.get();
+    return mStreamOutExecutable;
 }
 
-ID3D11ComputeShader *ShaderExecutable11::getComputeShader() const
+const d3d11::ComputeShader &ShaderExecutable11::getComputeShader() const
 {
-    return mComputeExecutable.get();
+    return mComputeExecutable;
 }
 
 UniformStorage11::UniformStorage11(size_t initialSize)

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

@@ -31,11 +31,11 @@ class ShaderExecutable11 : public ShaderExecutableD3D
 
     virtual ~ShaderExecutable11();
 
-    ID3D11PixelShader *getPixelShader() const;
-    ID3D11VertexShader *getVertexShader() const;
-    ID3D11GeometryShader *getGeometryShader() const;
-    ID3D11GeometryShader *getStreamOutShader() const;
-    ID3D11ComputeShader *getComputeShader() const;
+    const d3d11::PixelShader &getPixelShader() const;
+    const d3d11::VertexShader &getVertexShader() const;
+    const d3d11::GeometryShader &getGeometryShader() const;
+    const d3d11::GeometryShader &getStreamOutShader() const;
+    const d3d11::ComputeShader &getComputeShader() const;
 
   private:
     d3d11::PixelShader mPixelExecutable;

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

@@ -848,6 +848,11 @@ void StateManager11::invalidateEverything(const gl::Context *context)
     invalidateVertexBuffer();
 
     mCurrentPrimitiveTopology = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
+
+    mAppliedVertexShader.dirty();
+    mAppliedGeometryShader.dirty();
+    mAppliedPixelShader.dirty();
+    mAppliedComputeShader.dirty();
 }
 
 void StateManager11::invalidateVertexBuffer()
@@ -1294,4 +1299,61 @@ void StateManager11::setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY primitiveTopo
     }
 }
 
+void StateManager11::setDrawShaders(const d3d11::VertexShader *vertexShader,
+                                    const d3d11::GeometryShader *geometryShader,
+                                    const d3d11::PixelShader *pixelShader)
+{
+    setVertexShader(vertexShader);
+    setGeometryShader(geometryShader);
+    setPixelShader(pixelShader);
+}
+
+void StateManager11::setVertexShader(const d3d11::VertexShader *shader)
+{
+    ResourceSerial serial = shader ? shader->getSerial() : 0;
+
+    if (serial != mAppliedVertexShader)
+    {
+        ID3D11VertexShader *appliedShader = shader ? shader->get() : nullptr;
+        mRenderer->getDeviceContext()->VSSetShader(appliedShader, nullptr, 0);
+        mAppliedVertexShader = serial;
+    }
+}
+
+void StateManager11::setGeometryShader(const d3d11::GeometryShader *shader)
+{
+    ResourceSerial serial = shader ? shader->getSerial() : 0;
+
+    if (serial != mAppliedGeometryShader)
+    {
+        ID3D11GeometryShader *appliedShader = shader ? shader->get() : nullptr;
+        mRenderer->getDeviceContext()->GSSetShader(appliedShader, nullptr, 0);
+        mAppliedGeometryShader = serial;
+    }
+}
+
+void StateManager11::setPixelShader(const d3d11::PixelShader *shader)
+{
+    ResourceSerial serial = shader ? shader->getSerial() : 0;
+
+    if (serial != mAppliedPixelShader)
+    {
+        ID3D11PixelShader *appliedShader = shader ? shader->get() : nullptr;
+        mRenderer->getDeviceContext()->PSSetShader(appliedShader, nullptr, 0);
+        mAppliedPixelShader = serial;
+    }
+}
+
+void StateManager11::setComputeShader(const d3d11::ComputeShader *shader)
+{
+    ResourceSerial serial = shader ? shader->getSerial() : 0;
+
+    if (serial != mAppliedComputeShader)
+    {
+        ID3D11ComputeShader *appliedShader = shader ? shader->get() : nullptr;
+        mRenderer->getDeviceContext()->CSSetShader(appliedShader, nullptr, 0);
+        mAppliedComputeShader = serial;
+    }
+}
+
 }  // namespace rx

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

@@ -111,6 +111,14 @@ class StateManager11 final : angle::NonCopyable
 
     void setPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY primitiveTopology);
 
+    void setDrawShaders(const d3d11::VertexShader *vertexShader,
+                        const d3d11::GeometryShader *geometryShader,
+                        const d3d11::PixelShader *pixelShader);
+    void setVertexShader(const d3d11::VertexShader *shader);
+    void setGeometryShader(const d3d11::GeometryShader *shader);
+    void setPixelShader(const d3d11::PixelShader *shader);
+    void setComputeShader(const d3d11::ComputeShader *shader);
+
   private:
     void unsetConflictingSRVs(gl::SamplerType shaderType,
                               uintptr_t resource,
@@ -249,6 +257,12 @@ class StateManager11 final : angle::NonCopyable
 
     // Currently applied primitive topology
     D3D11_PRIMITIVE_TOPOLOGY mCurrentPrimitiveTopology;
+
+    // Currently applied shaders
+    ResourceSerial mAppliedVertexShader;
+    ResourceSerial mAppliedGeometryShader;
+    ResourceSerial mAppliedPixelShader;
+    ResourceSerial mAppliedComputeShader;
 };
 
 }  // namespace rx

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

@@ -814,9 +814,7 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(const gl::Context *context,
     // Apply shaders
     stateManager->setInputLayout(&mPassThroughIL);
     stateManager->setPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
-    deviceContext->VSSetShader(mPassThroughVS.get(), nullptr, 0);
-    deviceContext->PSSetShader(mPassThroughPS.get(), nullptr, 0);
-    deviceContext->GSSetShader(nullptr, nullptr, 0);
+    stateManager->setDrawShaders(&mPassThroughVS, nullptr, &mPassThroughPS);
 
     // Apply render targets. Use the proxy context in display.
     stateManager->setOneTimeRenderTarget(context, mBackBufferRTView.get(), nullptr);