Remove Renderer11::markAllStateDirty.

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

@@ -1098,9 +1098,6 @@ gl::Error Blit11::swizzleTexture(const gl::Context *context,
     stateManager->setDrawShaders(support.vertexShader, support.geometryShader,
                                  &shader->pixelShader);
 
-    // Unset the currently bound shader resource to avoid conflicts
-    stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
-
     // Apply render target
     stateManager->setRenderTarget(dest.get(), nullptr);
 
@@ -1113,9 +1110,6 @@ gl::Error Blit11::swizzleTexture(const gl::Context *context,
     // Draw the quad
     deviceContext->Draw(drawCount, 0);
 
-    // Dirty state.
-    mRenderer->markAllStateDirty(context);
-
     return gl::NoError();
 }
 
@@ -1213,9 +1207,6 @@ gl::Error Blit11::copyTexture(const gl::Context *context,
     stateManager->setDrawShaders(support.vertexShader, support.geometryShader,
                                  &shader->pixelShader);
 
-    // Unset the currently bound shader resource to avoid conflicts
-    stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
-
     // Apply render target
     stateManager->setRenderTarget(dest.get(), nullptr);
 
@@ -1240,9 +1231,6 @@ gl::Error Blit11::copyTexture(const gl::Context *context,
     // Draw the quad
     deviceContext->Draw(drawCount, 0);
 
-    // Invalidate state.
-    mRenderer->markAllStateDirty(context);
-
     return gl::NoError();
 }
 
@@ -1323,9 +1311,6 @@ gl::Error Blit11::copyDepth(const gl::Context *context,
 
     stateManager->setDrawShaders(&mQuad2DVS.getObj(), nullptr, &mDepthPS.getObj());
 
-    // Unset the currently bound shader resource to avoid conflicts
-    stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
-
     // Apply render target
     stateManager->setRenderTarget(nullptr, dest.get());
 
@@ -1338,9 +1323,6 @@ gl::Error Blit11::copyDepth(const gl::Context *context,
     // Draw the quad
     deviceContext->Draw(drawCount, 0);
 
-    // Invalidate all state.
-    mRenderer->markAllStateDirty(context);
-
     return gl::NoError();
 }
 
@@ -1955,9 +1937,6 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveDepth(const gl::Context *conte
 
     ANGLE_TRY(initResolveDepthOnly(depth->getFormatSet(), extents));
 
-    // Notify the Renderer that all state should be invalidated.
-    mRenderer->markAllStateDirty(context);
-
     ANGLE_TRY(mResolveDepthStencilVS.resolve(mRenderer));
     ANGLE_TRY(mResolveDepthPS.resolve(mRenderer));
 
@@ -2103,8 +2082,6 @@ gl::ErrorOrResult<TextureHelper11> Blit11::resolveStencil(const gl::Context *con
     }
 
     // Notify the Renderer that all state should be invalidated.
-    mRenderer->markAllStateDirty(context);
-
     ANGLE_TRY(mResolveDepthStencilVS.resolve(mRenderer));
 
     // Resolving the depth buffer works by sampling the depth in the shader using a SRV, then

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

@@ -836,9 +836,6 @@ gl::Error Clear11::clearFramebuffer(const gl::Context *context,
         }
     }
 
-    // Clean up
-    mRenderer->markAllStateDirty(context);
-
     return gl::NoError();
 }
 }  // namespace rx

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

@@ -215,12 +215,6 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::Context *context,
     UINT numPixels = (destArea.width * destArea.height * destArea.depth);
     deviceContext->Draw(numPixels, 0);
 
-    // Unbind shader resources and invalidate state.
-    stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, nullptr);
-    stateManager->setVertexConstantBuffer(0, nullptr);
-
-    mRenderer->markAllStateDirty(context);
-
     return gl::NoError();
 }
 

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

@@ -868,9 +868,6 @@ egl::Error Renderer11::initializeDevice()
         return egl::EglBadAlloc() << "Error initializing state manager.";
     }
 
-    // No context is available here, use the proxy context in the display.
-    markAllStateDirty(mDisplay->getProxyContext());
-
     // Gather stats on DXGI and D3D feature level
     ANGLE_HISTOGRAM_BOOLEAN("GPU.ANGLE.SupportsDXGI1_2", mRenderer11DeviceCaps.supportsDXGI1_2);
 
@@ -1951,13 +1948,6 @@ gl::Error Renderer11::drawTriangleFan(const gl::State &glState,
     return gl::NoError();
 }
 
-void Renderer11::markAllStateDirty(const gl::Context *context)
-{
-    TRACE_EVENT0("gpu.angle", "Renderer11::markAllStateDirty");
-
-    mStateManager.invalidateEverything(context);
-}
-
 void Renderer11::releaseDeviceResources()
 {
     mStateManager.deinitialize();

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

@@ -332,7 +332,6 @@ class Renderer11 : public RendererD3D
                                       GLenum sourcePixelsType,
                                       const gl::Box &destArea) override;
 
-    void markAllStateDirty(const gl::Context *context);
     gl::Error packPixels(const TextureHelper11 &textureHelper,
                          const PackPixelsParams &params,
                          uint8_t *pixelsOut);

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

@@ -1337,48 +1337,6 @@ void StateManager11::invalidateBoundViews(const gl::Context *context)
     invalidateRenderTarget(context);
 }
 
-void StateManager11::invalidateEverything(const gl::Context *context)
-{
-    mInternalDirtyBits.set();
-
-    // We reset the current SRV data because it might not be in sync with D3D's state
-    // anymore. For example when a currently used SRV is used as an RTV, D3D silently
-    // remove it from its state.
-    invalidateBoundViews(context);
-
-    // All calls to IASetInputLayout go through the state manager, so it shouldn't be
-    // necessary to invalidate the state.
-
-    // Invalidate the vertex buffer state.
-    invalidateVertexBuffer();
-
-    mCurrentPrimitiveTopology = D3D_PRIMITIVE_TOPOLOGY_UNDEFINED;
-
-    mAppliedVertexShader.dirty();
-    mAppliedGeometryShader.dirty();
-    mAppliedPixelShader.dirty();
-    mAppliedComputeShader.dirty();
-
-    std::fill(mForceSetVertexSamplerStates.begin(), mForceSetVertexSamplerStates.end(), true);
-    std::fill(mForceSetPixelSamplerStates.begin(), mForceSetPixelSamplerStates.end(), true);
-    std::fill(mForceSetComputeSamplerStates.begin(), mForceSetComputeSamplerStates.end(), true);
-
-    mAppliedIB       = nullptr;
-    mAppliedIBFormat = DXGI_FORMAT_UNKNOWN;
-    mAppliedIBOffset = 0;
-
-    mLastFirstVertex.reset();
-
-    invalidateTexturesAndSamplers();
-
-    invalidateDriverUniforms();
-
-    // As long as all calls to *SSetConstantBuffes go through the StateManager11, it should not be
-    // necessary to invalidate constant buffer state.
-
-    mAppliedTFSerial = Serial();
-}
-
 void StateManager11::invalidateVertexBuffer()
 {
     unsigned int limit = std::min<unsigned int>(mRenderer->getNativeCaps().maxVertexAttributes,
@@ -1442,15 +1400,32 @@ void StateManager11::invalidateConstantBuffer(unsigned int slot)
 
 void StateManager11::setRenderTarget(ID3D11RenderTargetView *rtv, ID3D11DepthStencilView *dsv)
 {
+    if ((rtv && unsetConflictingView(rtv)) || (dsv && unsetConflictingView(dsv)))
+    {
+        mInternalDirtyBits.set(DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE);
+    }
+
     mRenderer->getDeviceContext()->OMSetRenderTargets(1, &rtv, dsv);
     mInternalDirtyBits.set(DIRTY_BIT_RENDER_TARGET);
 }
 
 void StateManager11::setRenderTargets(ID3D11RenderTargetView **rtvs,
-                                      UINT numRtvs,
+                                      UINT numRTVs,
                                       ID3D11DepthStencilView *dsv)
 {
-    mRenderer->getDeviceContext()->OMSetRenderTargets(numRtvs, (numRtvs > 0) ? rtvs : nullptr, dsv);
+    bool anyDirty = false;
+
+    for (UINT rtvIndex = 0; rtvIndex < numRTVs; ++rtvIndex)
+    {
+        anyDirty = anyDirty || unsetConflictingView(rtvs[rtvIndex]);
+    }
+
+    if (anyDirty)
+    {
+        mInternalDirtyBits.set(DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE);
+    }
+
+    mRenderer->getDeviceContext()->OMSetRenderTargets(numRTVs, (numRTVs > 0) ? rtvs : nullptr, dsv);
     mInternalDirtyBits.set(DIRTY_BIT_RENDER_TARGET);
 }
 
@@ -1527,23 +1502,35 @@ gl::Error StateManager11::clearTextures(gl::SamplerType samplerType,
     return gl::NoError();
 }
 
-void StateManager11::unsetConflictingSRVs(gl::SamplerType samplerType,
+bool StateManager11::unsetConflictingView(ID3D11View *view)
+{
+    uintptr_t resource = reinterpret_cast<uintptr_t>(GetViewResource(view));
+    return unsetConflictingSRVs(gl::SAMPLER_VERTEX, resource, nullptr) ||
+           unsetConflictingSRVs(gl::SAMPLER_PIXEL, resource, nullptr);
+}
+
+bool StateManager11::unsetConflictingSRVs(gl::SamplerType samplerType,
                                           uintptr_t resource,
-                                          const gl::ImageIndex &index)
+                                          const gl::ImageIndex *index)
 {
     auto &currentSRVs = (samplerType == gl::SAMPLER_VERTEX ? mCurVertexSRVs : mCurPixelSRVs);
 
+    bool foundOne = false;
+
     for (size_t resourceIndex = 0; resourceIndex < currentSRVs.size(); ++resourceIndex)
     {
         auto &record = currentSRVs[resourceIndex];
 
         if (record.srv && record.resource == resource &&
-            ImageIndexConflictsWithSRV(index, record.desc))
+            (!index || ImageIndexConflictsWithSRV(*index, record.desc)))
         {
             setShaderResourceInternal<d3d11::ShaderResourceView>(
                 samplerType, static_cast<UINT>(resourceIndex), nullptr);
+            foundOne = true;
         }
     }
+
+    return foundOne;
 }
 
 void StateManager11::unsetConflictingAttachmentResources(
@@ -1557,14 +1544,14 @@ void StateManager11::unsetConflictingAttachmentResources(
         const gl::ImageIndex &index = attachment->getTextureImageIndex();
         // The index doesn't need to be corrected for the small compressed texture workaround
         // because a rendertarget is never compressed.
-        unsetConflictingSRVs(gl::SAMPLER_VERTEX, resourcePtr, index);
-        unsetConflictingSRVs(gl::SAMPLER_PIXEL, resourcePtr, index);
+        unsetConflictingSRVs(gl::SAMPLER_VERTEX, resourcePtr, &index);
+        unsetConflictingSRVs(gl::SAMPLER_PIXEL, resourcePtr, &index);
     }
     else if (attachment->type() == GL_FRAMEBUFFER_DEFAULT)
     {
         uintptr_t resourcePtr = reinterpret_cast<uintptr_t>(resource);
-        unsetConflictingSRVs(gl::SAMPLER_VERTEX, resourcePtr, gl::ImageIndex::Make2D(0));
-        unsetConflictingSRVs(gl::SAMPLER_PIXEL, resourcePtr, gl::ImageIndex::Make2D(0));
+        unsetConflictingSRVs(gl::SAMPLER_VERTEX, resourcePtr, nullptr);
+        unsetConflictingSRVs(gl::SAMPLER_PIXEL, resourcePtr, nullptr);
     }
 }
 
@@ -1578,9 +1565,9 @@ gl::Error StateManager11::initialize(const gl::Caps &caps, const gl::Extensions
 
     mCurrentValueAttribs.resize(caps.maxVertexAttributes);
 
-    mForceSetVertexSamplerStates.resize(caps.maxVertexTextureImageUnits);
-    mForceSetPixelSamplerStates.resize(caps.maxTextureImageUnits);
-    mForceSetComputeSamplerStates.resize(caps.maxComputeTextureImageUnits);
+    mForceSetVertexSamplerStates.resize(caps.maxVertexTextureImageUnits, true);
+    mForceSetPixelSamplerStates.resize(caps.maxTextureImageUnits, true);
+    mForceSetComputeSamplerStates.resize(caps.maxComputeTextureImageUnits, true);
 
     mCurVertexSamplerStates.resize(caps.maxVertexTextureImageUnits);
     mCurPixelSamplerStates.resize(caps.maxTextureImageUnits);
@@ -2140,8 +2127,8 @@ void StateManager11::setSimplePixelTextureAndSampler(const d3d11::SharedSRV &srv
     setShaderResourceInternal(gl::SAMPLER_PIXEL, 0, &srv);
     deviceContext->PSSetSamplers(0, 1, samplerState.getPointer());
 
-    // TODO(jmadill): Narrower dirty region.
     mInternalDirtyBits.set(DIRTY_BIT_TEXTURE_AND_SAMPLER_STATE);
+    mForceSetPixelSamplerStates[0] = true;
 }
 
 void StateManager11::setSimpleScissorRect(const gl::Rectangle &glRect)

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

@@ -158,22 +158,26 @@ class StateManager11 final : angle::NonCopyable
 
     void updateStencilSizeIfChanged(bool depthStencilInitialized, unsigned int stencilSize);
 
+    // These invalidations methods are called externally.
+
+    // Called from TextureStorage11.
+    void invalidateBoundViews(const gl::Context *context);
+
+    // Called from VertexArray11::updateVertexAttribStorage.
+    void invalidateCurrentValueAttrib(size_t attribIndex);
+
     // Checks are done on a framebuffer state change to trigger other state changes.
     // The Context is allowed to be nullptr for these methods, when called in EGL init code.
     void invalidateRenderTarget(const gl::Context *context);
-    void invalidateBoundViews(const gl::Context *context);
+
+    // Called by instanced point sprite emulation.
     void invalidateVertexBuffer();
-    void invalidateEverything(const gl::Context *context);
+
+    // Called by Framebuffer11::syncState for the default sized viewport.
     void invalidateViewport(const gl::Context *context);
-    void invalidateTexturesAndSamplers();
-    void invalidateSwizzles();
-    void invalidateDriverUniforms();
-    void invalidateProgramUniforms();
-    void invalidateProgramUniformBuffers();
-    void invalidateConstantBuffer(unsigned int slot);
 
-    // Called from VertexArray11::updateVertexAttribStorage.
-    void invalidateCurrentValueAttrib(size_t attribIndex);
+    // Called by TextureStorage11::markLevelDirty.
+    void invalidateSwizzles();
 
     void setRenderTarget(ID3D11RenderTargetView *rtv, ID3D11DepthStencilView *dsv);
     void setRenderTargets(ID3D11RenderTargetView **rtvs, UINT numRtvs, ID3D11DepthStencilView *dsv);
@@ -257,9 +261,10 @@ class StateManager11 final : angle::NonCopyable
                                    UINT resourceSlot,
                                    const SRVType *srv);
 
-    void unsetConflictingSRVs(gl::SamplerType shaderType,
+    bool unsetConflictingView(ID3D11View *view);
+    bool unsetConflictingSRVs(gl::SamplerType shaderType,
                               uintptr_t resource,
-                              const gl::ImageIndex &index);
+                              const gl::ImageIndex *index);
     void unsetConflictingAttachmentResources(const gl::FramebufferAttachment *attachment,
                                              ID3D11Resource *resource);
 
@@ -314,6 +319,13 @@ class StateManager11 final : angle::NonCopyable
     gl::Error syncUniformBuffers(const gl::Context *context, ProgramD3D *programD3D);
     gl::Error syncTransformFeedbackBuffers(const gl::Context *context);
 
+    // These are currently only called internally.
+    void invalidateTexturesAndSamplers();
+    void invalidateDriverUniforms();
+    void invalidateProgramUniforms();
+    void invalidateProgramUniformBuffers();
+    void invalidateConstantBuffer(unsigned int slot);
+
     enum DirtyBitType
     {
         DIRTY_BIT_RENDER_TARGET,

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

@@ -848,9 +848,6 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(const gl::Context *context,
     // Draw
     deviceContext->Draw(4, 0);
 
-    // Rendering to the swapchain is now complete. Now we can call Present().
-    mRenderer->markAllStateDirty(context);
-
     return EGL_SUCCESS;
 }