D3D: Refactor driver uniform application.

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -1765,22 +1765,6 @@ void ProgramD3D::initializeUniformStorage()
     }
 }
 
-gl::Error ProgramD3D::applyUniforms()
-{
-    ASSERT(!mDirtySamplerMapping);
-    ANGLE_TRY(mRenderer->applyUniforms(*this, mD3DUniforms));
-    mUniformsDirty = false;
-    return gl::NoError();
-}
-
-gl::Error ProgramD3D::applyComputeUniforms()
-{
-    ASSERT(!mDirtySamplerMapping);
-    ANGLE_TRY(mRenderer->applyComputeUniforms(*this, mD3DUniforms));
-    mUniformsDirty = false;
-    return gl::NoError();
-}
-
 gl::Error ProgramD3D::applyUniformBuffers(const gl::ContextState &data)
 {
     if (mState.getUniformBlocks().empty())

src/libANGLE/renderer/d3d/ProgramD3D.h

@@ -208,8 +208,6 @@ class ProgramD3D : public ProgramImpl
                                  const GLfloat *coeffs) override;
 
     void initializeUniformStorage();
-    gl::Error applyUniforms();
-    gl::Error applyComputeUniforms();
     gl::Error applyUniformBuffers(const gl::ContextState &data);
     void dirtyAllUniforms();
 
@@ -290,6 +288,8 @@ class ProgramD3D : public ProgramImpl
     bool hasPixelExecutableForCachedOutputLayout();
 
     bool areUniformsDirty() const { return mUniformsDirty; }
+    const std::vector<D3DUniform *> &getD3DUniforms() const { return mD3DUniforms; }
+    void markUniformsClean() { mUniformsDirty = false; }
 
   private:
     // These forward-declared tasks are used for multi-thread shader compiles.

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -154,9 +154,6 @@ class RendererD3D : public BufferFactoryD3D
                                         const std::vector<GLint> &vertexUniformBuffers,
                                         const std::vector<GLint> &fragmentUniformBuffers) = 0;
 
-    virtual gl::Error applyUniforms(const ProgramD3D &programD3D,
-                                    const std::vector<D3DUniform *> &uniformArray) = 0;
-
     virtual unsigned int getReservedVertexUniformBuffers() const = 0;
     virtual unsigned int getReservedFragmentUniformBuffers() const = 0;
 
@@ -319,9 +316,6 @@ class RendererD3D : public BufferFactoryD3D
 
     angle::WorkerThreadPool *getWorkerThreadPool();
 
-    virtual gl::Error applyComputeUniforms(const ProgramD3D &programD3D,
-                                           const std::vector<D3DUniform *> &uniformArray) = 0;
-
     bool isRobustResourceInitEnabled() const;
 
     size_t getBoundFramebufferTextures(const gl::ContextState &data,

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

@@ -151,11 +151,6 @@ class Renderer11 : public RendererD3D
                                 const std::vector<GLint> &fragmentUniformBuffers) override;
 
     bool applyPrimitiveType(GLenum mode, GLsizei count, bool usesPointSize);
-
-    gl::Error applyUniforms(const ProgramD3D &programD3D,
-                            const std::vector<D3DUniform *> &uniformArray) override;
-
-    gl::Error applyDriverUniforms(const ProgramD3D &programD3D, GLenum drawMode);
     gl::Error applyTransformFeedbackBuffers(const gl::ContextState &data);
 
     // lost device
@@ -419,8 +414,6 @@ class Renderer11 : public RendererD3D
                               GLuint numGroupsX,
                               GLuint numGroupsY,
                               GLuint numGroupsZ);
-    gl::Error applyComputeUniforms(const ProgramD3D &programD3D,
-                                   const std::vector<D3DUniform *> &uniformArray) override;
     gl::Error applyComputeShader(const gl::Context *context);
 
     gl::ErrorOrResult<TextureHelper11> createStagingTexture(ResourceType textureType,
@@ -518,13 +511,6 @@ class Renderer11 : public RendererD3D
 
     void updateHistograms();
 
-    template <class TShaderConstants>
-    void applyDriverConstantsIfNeeded(TShaderConstants *appliedConstants,
-                                      const TShaderConstants &constants,
-                                      SamplerMetadata11 *samplerMetadata,
-                                      size_t samplerMetadataReferencedBytes,
-                                      const d3d11::Buffer &driverConstantBuffer);
-
     gl::Error copyImageInternal(const gl::Context *context,
                                 const gl::Framebuffer *framebuffer,
                                 const gl::Rectangle &sourceRect,
@@ -561,26 +547,13 @@ class Renderer11 : public RendererD3D
     // Currently applied transform feedback buffers
     uintptr_t mAppliedTFObject;
 
-    dx_VertexConstants11 mAppliedVertexConstants;
-    d3d11::Buffer mDriverConstantBufferVS;
-    uintptr_t mCurrentVertexConstantBuffer;
     unsigned int mCurrentConstantBufferVS[gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS];
     GLintptr mCurrentConstantBufferVSOffset[gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS];
     GLsizeiptr mCurrentConstantBufferVSSize[gl::IMPLEMENTATION_MAX_VERTEX_SHADER_UNIFORM_BUFFERS];
-
-    dx_PixelConstants11 mAppliedPixelConstants;
-    d3d11::Buffer mDriverConstantBufferPS;
-    uintptr_t mCurrentPixelConstantBuffer;
     unsigned int mCurrentConstantBufferPS[gl::IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS];
     GLintptr mCurrentConstantBufferPSOffset[gl::IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS];
     GLsizeiptr mCurrentConstantBufferPSSize[gl::IMPLEMENTATION_MAX_FRAGMENT_SHADER_UNIFORM_BUFFERS];
 
-    dx_ComputeConstants11 mAppliedComputeConstants;
-    d3d11::Buffer mDriverConstantBufferCS;
-    uintptr_t mCurrentComputeConstantBuffer;
-
-    uintptr_t mCurrentGeometryConstantBuffer;
-
     StreamingIndexBufferInterface *mLineLoopIB;
     StreamingIndexBufferInterface *mTriangleFanIB;
 

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

@@ -27,89 +27,117 @@ namespace rx
 struct RenderTargetDesc;
 struct Renderer11DeviceCaps;
 
-struct dx_VertexConstants11
+class ShaderConstants11 : angle::NonCopyable
 {
-    dx_VertexConstants11()
-        : depthRange{.0f},
-          viewAdjust{.0f},
-          viewCoords{.0f},
-          viewScale{.0f},
-          multiviewWriteToViewportIndex{.0f},
-          padding{.0f}
-    {
-    }
-    float depthRange[4];
-    float viewAdjust[4];
-    float viewCoords[4];
-    float viewScale[2];
-    // multiviewWriteToViewportIndex is used to select either the side-by-side or layered code-path
-    // in the GS. It's value, if set, is either 0.0f or 1.0f. The value is updated whenever a
-    // multi-view draw framebuffer is made active.
-    float multiviewWriteToViewportIndex;
-
-    // Added here to manually pad the struct.
-    float padding;
-};
+  public:
+    ShaderConstants11();
+
+    void init(const gl::Caps &caps);
+    size_t getRequiredBufferSize(gl::SamplerType samplerType) const;
+    void markDirty();
+
+    void setComputeWorkGroups(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ);
+    void setMultiviewWriteToViewportIndex(GLfloat index);
+    void onViewportChange(const gl::Rectangle &glViewport,
+                          const D3D11_VIEWPORT &dxViewport,
+                          bool is9_3,
+                          bool presentPathFast);
+    void onSamplerChange(gl::SamplerType samplerType,
+                         unsigned int samplerIndex,
+                         const gl::Texture &texture);
+
+    gl::Error updateBuffer(ID3D11DeviceContext *deviceContext,
+                           gl::SamplerType samplerType,
+                           const ProgramD3D &programD3D,
+                           const d3d11::Buffer &driverConstantBuffer);
 
-struct dx_PixelConstants11
-{
-    dx_PixelConstants11()
-        : depthRange{.0f},
-          viewCoords{.0f},
-          depthFront{.0f},
-          viewScale{.0f},
-          multiviewWriteToViewportIndex{.0f},
-          padding{.0f}
+  private:
+    struct Vertex
     {
-    }
-
-    float depthRange[4];
-    float viewCoords[4];
-    float depthFront[4];
-    float viewScale[2];
-    // multiviewWriteToViewportIndex is used to select either the side-by-side or layered code-path
-    // in the GS. It's value, if set, is either 0.0f or 1.0f. The value is updated whenever a
-    // multi-view draw framebuffer is made active.
-    float multiviewWriteToViewportIndex;
-
-    // Added here to manually pad the struct.
-    float padding;
-};
+        Vertex()
+            : depthRange{.0f},
+              viewAdjust{.0f},
+              viewCoords{.0f},
+              viewScale{.0f},
+              multiviewWriteToViewportIndex{.0f},
+              padding{.0f}
+        {
+        }
+
+        float depthRange[4];
+        float viewAdjust[4];
+        float viewCoords[4];
+        float viewScale[2];
+        // multiviewWriteToViewportIndex is used to select either the side-by-side or layered
+        // code-path in the GS. It's value, if set, is either 0.0f or 1.0f. The value is updated
+        // whenever a multi-view draw framebuffer is made active.
+        float multiviewWriteToViewportIndex;
+
+        // Added here to manually pad the struct.
+        float padding;
+    };
 
-struct dx_ComputeConstants11
-{
-    dx_ComputeConstants11() : numWorkGroups{0u}, padding{0u} {}
-    unsigned int numWorkGroups[3];
-    unsigned int padding;  // This just pads the struct to 16 bytes
-};
+    struct Pixel
+    {
+        Pixel()
+            : depthRange{.0f},
+              viewCoords{.0f},
+              depthFront{.0f},
+              viewScale{.0f},
+              multiviewWriteToViewportIndex(0),
+              padding(0)
+        {
+        }
+
+        float depthRange[4];
+        float viewCoords[4];
+        float depthFront[4];
+        float viewScale[2];
+        // multiviewWriteToViewportIndex is used to select either the side-by-side or layered
+        // code-path in the GS. It's value, if set, is either 0.0f or 1.0f. The value is updated
+        // whenever a multi-view draw framebuffer is made active.
+        float multiviewWriteToViewportIndex;
+
+        // Added here to manually pad the struct.
+        float padding;
+    };
 
-class SamplerMetadata11 final : angle::NonCopyable
-{
-  public:
-    SamplerMetadata11();
-    ~SamplerMetadata11();
+    struct Compute
+    {
+        Compute() : numWorkGroups{0u}, padding(0u) {}
+        unsigned int numWorkGroups[3];
+        unsigned int padding;  // This just pads the struct to 16 bytes
+    };
 
-    struct dx_SamplerMetadata
+    struct SamplerMetadata
     {
+        SamplerMetadata() : baseLevel(0), internalFormatBits(0), wrapModes(0), padding(0) {}
+
         int baseLevel;
         int internalFormatBits;
         int wrapModes;
         int padding;  // This just pads the struct to 16 bytes
     };
-    static_assert(sizeof(dx_SamplerMetadata) == 16u,
-                  "Sampler metadata struct must be one 4-vec / 16 bytes.");
-
-    void initData(unsigned int samplerCount);
-    void update(unsigned int samplerIndex, const gl::Texture &texture);
 
-    const dx_SamplerMetadata *getData() const;
-    size_t sizeBytes() const;
-    bool isDirty() const { return mDirty; }
-    void markClean() { mDirty = false; }
+    static_assert(sizeof(SamplerMetadata) == 16u,
+                  "Sampler metadata struct must be one 4-vec / 16 bytes.");
 
-  private:
-    std::vector<dx_SamplerMetadata> mSamplerMetadata;
-    bool mDirty;
+    // Return true if dirty.
+    bool updateSamplerMetadata(SamplerMetadata *data, const gl::Texture &texture);
+
+    Vertex mVertex;
+    bool mVertexDirty;
+    Pixel mPixel;
+    bool mPixelDirty;
+    Compute mCompute;
+    bool mComputeDirty;
+
+    std::vector<SamplerMetadata> mSamplerMetadataVS;
+    bool mSamplerMetadataVSDirty;
+    std::vector<SamplerMetadata> mSamplerMetadataPS;
+    bool mSamplerMetadataPSDirty;
+    std::vector<SamplerMetadata> mSamplerMetadataCS;
+    bool mSamplerMetadataCSDirty;
 };
 
 class StateManager11 final : angle::NonCopyable
@@ -123,15 +151,6 @@ class StateManager11 final : angle::NonCopyable
 
     void syncState(const gl::Context *context, const gl::State::DirtyBits &dirtyBits);
 
-    // TODO(jmadill): Don't expose these.
-    const dx_VertexConstants11 &getVertexConstants() const { return mVertexConstants; }
-    const dx_PixelConstants11 &getPixelConstants() const { return mPixelConstants; }
-    const dx_ComputeConstants11 &getComputeConstants() const { return mComputeConstants; }
-
-    SamplerMetadata11 *getVertexSamplerMetadata() { return &mSamplerMetadataVS; }
-    SamplerMetadata11 *getPixelSamplerMetadata() { return &mSamplerMetadataPS; }
-    SamplerMetadata11 *getComputeSamplerMetadata() { return &mSamplerMetadataCS; }
-
     gl::Error updateStateForCompute(const gl::Context *context,
                                     GLuint numGroupsX,
                                     GLuint numGroupsY,
@@ -152,6 +171,7 @@ class StateManager11 final : angle::NonCopyable
     void invalidateViewport(const gl::Context *context);
     void invalidateTexturesAndSamplers();
     void invalidateSwizzles();
+    void invalidateDriverUniforms();
 
     // Called from VertexArray11::updateVertexAttribStorage.
     void invalidateCurrentValueAttrib(size_t attribIndex);
@@ -214,6 +234,9 @@ class StateManager11 final : angle::NonCopyable
     gl::Error updateVertexOffsetsForPointSpritesEmulation(GLint startVertex,
                                                           GLsizei emulatedInstanceId);
 
+    // TODO(jmadill): Should be private.
+    gl::Error applyComputeUniforms(ProgramD3D *programD3D);
+
     // Only used in testing.
     InputLayoutCache *getInputLayoutCache() { return &mInputLayoutCache; }
 
@@ -269,6 +292,9 @@ class StateManager11 final : angle::NonCopyable
     gl::Error generateSwizzlesForShader(const gl::Context *context, gl::SamplerType type);
     gl::Error generateSwizzles(const gl::Context *context);
 
+    gl::Error applyDriverUniforms(const ProgramD3D &programD3D, GLenum drawMode);
+    gl::Error applyUniforms(ProgramD3D *programD3D);
+
     enum DirtyBitType
     {
         DIRTY_BIT_RENDER_TARGET,
@@ -320,10 +346,7 @@ class StateManager11 final : angle::NonCopyable
     std::vector<gl::Offset> mViewportOffsets;
 
     // Things needed in viewport state
-    dx_VertexConstants11 mVertexConstants;
-    dx_PixelConstants11 mPixelConstants;
-
-    dx_ComputeConstants11 mComputeConstants;
+    ShaderConstants11 mShaderConstants;
 
     // Render target variables
     gl::Extents mViewportBounds;
@@ -406,10 +429,6 @@ class StateManager11 final : angle::NonCopyable
     std::vector<bool> mForceSetComputeSamplerStates;
     std::vector<gl::SamplerState> mCurComputeSamplerStates;
 
-    SamplerMetadata11 mSamplerMetadataVS;
-    SamplerMetadata11 mSamplerMetadataPS;
-    SamplerMetadata11 mSamplerMetadataCS;
-
     // Special dirty bit for swizzles. Since they use internal shaders, must be done in a pre-pass.
     bool mDirtySwizzles;
 
@@ -428,6 +447,16 @@ class StateManager11 final : angle::NonCopyable
 
     // ANGLE_multiview.
     bool mIsMultiviewEnabled;
+
+    // Driver Constants.
+    d3d11::Buffer mDriverConstantBufferVS;
+    d3d11::Buffer mDriverConstantBufferPS;
+    d3d11::Buffer mDriverConstantBufferCS;
+
+    ResourceSerial mCurrentVertexConstantBuffer;
+    ResourceSerial mCurrentPixelConstantBuffer;
+    ResourceSerial mCurrentComputeConstantBuffer;
+    ResourceSerial mCurrentGeometryConstantBuffer;
 };
 
 }  // namespace rx

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

@@ -1842,7 +1842,7 @@ gl::Error Renderer9::applyShaders(const gl::Context *context, GLenum drawMode)
         mAppliedProgramSerial = programSerial;
     }
 
-    ANGLE_TRY(programD3D->applyUniforms());
+    ANGLE_TRY(applyUniforms(programD3D));
 
     // Driver uniforms
     mStateManager.setShaderConstants();
@@ -1850,16 +1850,18 @@ gl::Error Renderer9::applyShaders(const gl::Context *context, GLenum drawMode)
     return gl::NoError();
 }
 
-gl::Error Renderer9::applyUniforms(const ProgramD3D &programD3D,
-                                   const std::vector<D3DUniform *> &uniformArray)
+gl::Error Renderer9::applyUniforms(ProgramD3D *programD3D)
 {
-    for (const D3DUniform *targetUniform : uniformArray)
+    // Skip updates if we're not dirty.
+    if (!programD3D->areUniformsDirty())
     {
-        // Built-in uniforms must be skipped.
-        if (!targetUniform->isReferencedByFragmentShader() &&
-            !targetUniform->isReferencedByVertexShader())
-            continue;
+        return gl::NoError();
+    }
 
+    const auto &uniformArray = programD3D->getD3DUniforms();
+
+    for (const D3DUniform *targetUniform : uniformArray)
+    {
         // Built-in uniforms must be skipped.
         if (!targetUniform->isReferencedByFragmentShader() &&
             !targetUniform->isReferencedByVertexShader())
@@ -1900,6 +1902,7 @@ gl::Error Renderer9::applyUniforms(const ProgramD3D &programD3D,
         }
     }
 
+    programD3D->markUniformsClean();
     return gl::NoError();
 }
 
@@ -3225,13 +3228,6 @@ gl::Version Renderer9::getMaxSupportedESVersion() const
     return gl::Version(2, 0);
 }
 
-gl::Error Renderer9::applyComputeUniforms(const ProgramD3D &programD3D,
-                                          const std::vector<D3DUniform *> &uniformArray)
-{
-    UNIMPLEMENTED();
-    return gl::InternalError() << "Compute shader is not implemented on D3D9";
-}
-
 gl::Error Renderer9::clearRenderTarget(RenderTargetD3D *renderTarget,
                                        const gl::ColorF &clearColorValue,
                                        const float clearDepthValue,

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

@@ -147,8 +147,7 @@ class Renderer9 : public RendererD3D
     gl::Error applyRenderTarget(const gl::Context *context,
                                 const gl::FramebufferAttachment *colorAttachment,
                                 const gl::FramebufferAttachment *depthStencilAttachment);
-    gl::Error applyUniforms(const ProgramD3D &programD3D,
-                            const std::vector<D3DUniform *> &uniformArray) override;
+    gl::Error applyUniforms(ProgramD3D *programD3D);
     bool applyPrimitiveType(GLenum primitiveType, GLsizei elementCount, bool usesPointSize);
     gl::Error applyVertexBuffer(const gl::State &state,
                                 GLenum mode,
@@ -390,9 +389,6 @@ class Renderer9 : public RendererD3D
 
     gl::Version getMaxSupportedESVersion() const override;
 
-    gl::Error applyComputeUniforms(const ProgramD3D &programD3D,
-                                   const std::vector<D3DUniform *> &uniformArray) override;
-
     gl::Error clearRenderTarget(RenderTargetD3D *renderTarget,
                                 const gl::ColorF &clearColorValue,
                                 const float clearDepthValue,