Update driver constants on program change. Comes with a new SamplerMetadataUpdateOnSetProgram test.

CONTRIBUTORS

@@ -78,6 +78,7 @@ Klarälvdalens Datakonsult AB
  Milian Wolff
 
 Mozilla Corp.
+ Dzmitry Malyshau
  Ehsan Akhgari
  Edwin Flores
  Jeff Gilbert

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

@@ -252,9 +252,9 @@ ShaderConstants11::ShaderConstants11()
     : mVertexDirty(true),
       mPixelDirty(true),
       mComputeDirty(true),
-      mSamplerMetadataVSDirty(true),
-      mSamplerMetadataPSDirty(true),
-      mSamplerMetadataCSDirty(true)
+      mNumActiveVSSamplers(0),
+      mNumActivePSSamplers(0),
+      mNumActiveCSSamplers(0)
 {
 }
 
@@ -287,12 +287,12 @@ size_t ShaderConstants11::getRequiredBufferSize(gl::ShaderType shaderType) const
 
 void ShaderConstants11::markDirty()
 {
-    mVertexDirty            = true;
-    mPixelDirty             = true;
-    mComputeDirty           = true;
-    mSamplerMetadataVSDirty = true;
-    mSamplerMetadataPSDirty = true;
-    mSamplerMetadataCSDirty = true;
+    mVertexDirty         = true;
+    mPixelDirty          = true;
+    mComputeDirty        = true;
+    mNumActiveVSSamplers = 0;
+    mNumActivePSSamplers = 0;
+    mNumActiveCSSamplers = 0;
 }
 
 bool ShaderConstants11::updateSamplerMetadata(SamplerMetadata *data, const gl::Texture &texture)
@@ -463,19 +463,19 @@ void ShaderConstants11::onSamplerChange(gl::ShaderType shaderType,
         case gl::SHADER_VERTEX:
             if (updateSamplerMetadata(&mSamplerMetadataVS[samplerIndex], texture))
             {
-                mSamplerMetadataVSDirty = true;
+                mNumActiveVSSamplers = 0;
             }
             break;
         case gl::SHADER_FRAGMENT:
             if (updateSamplerMetadata(&mSamplerMetadataPS[samplerIndex], texture))
             {
-                mSamplerMetadataPSDirty = true;
+                mNumActivePSSamplers = 0;
             }
             break;
         case gl::SHADER_COMPUTE:
             if (updateSamplerMetadata(&mSamplerMetadataCS[samplerIndex], texture))
             {
-                mSamplerMetadataCSDirty = true;
+                mNumActiveCSSamplers = 0;
             }
             break;
         default:
@@ -494,31 +494,35 @@ gl::Error ShaderConstants11::updateBuffer(Renderer11 *renderer,
     const uint8_t *data        = nullptr;
     const uint8_t *samplerData = nullptr;
 
+    // Re-upload the sampler meta-data if the current program uses more samplers
+    // than we previously uploaded.
+    int numSamplers = programD3D.getUsedSamplerRange(shaderType);
+
     switch (shaderType)
     {
         case gl::SHADER_VERTEX:
-            dirty                   = mVertexDirty || mSamplerMetadataVSDirty;
+            dirty                   = mVertexDirty || (mNumActiveVSSamplers < numSamplers);
             dataSize                = sizeof(Vertex);
             data                    = reinterpret_cast<const uint8_t *>(&mVertex);
             samplerData             = reinterpret_cast<const uint8_t *>(mSamplerMetadataVS.data());
             mVertexDirty            = false;
-            mSamplerMetadataVSDirty = false;
+            mNumActiveVSSamplers    = numSamplers;
             break;
         case gl::SHADER_FRAGMENT:
-            dirty                   = mPixelDirty || mSamplerMetadataPSDirty;
+            dirty                   = mPixelDirty || (mNumActivePSSamplers < numSamplers);
             dataSize                = sizeof(Pixel);
             data                    = reinterpret_cast<const uint8_t *>(&mPixel);
             samplerData             = reinterpret_cast<const uint8_t *>(mSamplerMetadataPS.data());
             mPixelDirty             = false;
-            mSamplerMetadataPSDirty = false;
+            mNumActivePSSamplers    = numSamplers;
             break;
         case gl::SHADER_COMPUTE:
-            dirty                   = mComputeDirty || mSamplerMetadataCSDirty;
+            dirty                   = mComputeDirty || (mNumActiveCSSamplers < numSamplers);
             dataSize                = sizeof(Compute);
             data                    = reinterpret_cast<const uint8_t *>(&mCompute);
             samplerData             = reinterpret_cast<const uint8_t *>(mSamplerMetadataCS.data());
             mComputeDirty           = false;
-            mSamplerMetadataCSDirty = false;
+            mNumActiveCSSamplers    = numSamplers;
             break;
         default:
             UNREACHABLE();
@@ -537,10 +541,10 @@ gl::Error ShaderConstants11::updateBuffer(Renderer11 *renderer,
     ANGLE_TRY(
         renderer->mapResource(driverConstantBuffer.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mapping));
 
-    size_t samplerDataBytes = sizeof(SamplerMetadata) * programD3D.getUsedSamplerRange(shaderType);
-
     memcpy(mapping.pData, data, dataSize);
-    memcpy(reinterpret_cast<uint8_t *>(mapping.pData) + dataSize, samplerData, samplerDataBytes);
+    memcpy(reinterpret_cast<uint8_t *>(mapping.pData) + dataSize,
+           samplerData,
+           sizeof(SamplerMetadata) * numSamplers);
 
     renderer->getDeviceContext()->Unmap(driverConstantBuffer.get(), 0);
 
@@ -1014,6 +1018,7 @@ void StateManager11::syncState(const gl::Context *context, const gl::State::Dirt
                 invalidateTexturesAndSamplers();
                 invalidateProgramUniforms();
                 invalidateProgramUniformBuffers();
+                invalidateDriverUniforms();
                 gl::VertexArray *vao = state.getVertexArray();
                 if (mIsMultiviewEnabled && vao != nullptr)
                 {

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

@@ -134,11 +134,11 @@ class ShaderConstants11 : angle::NonCopyable
     bool mComputeDirty;
 
     std::vector<SamplerMetadata> mSamplerMetadataVS;
-    bool mSamplerMetadataVSDirty;
+    int mNumActiveVSSamplers;
     std::vector<SamplerMetadata> mSamplerMetadataPS;
-    bool mSamplerMetadataPSDirty;
+    int mNumActivePSSamplers;
     std::vector<SamplerMetadata> mSamplerMetadataCS;
-    bool mSamplerMetadataCSDirty;
+    int mNumActiveCSSamplers;
 };
 
 class DrawCallVertexParams final : angle::NonCopyable

src/tests/gl_tests/StateChangeTest.cpp

@@ -716,6 +716,91 @@ TEST_P(StateChangeTestES3, VertexArrayObjectAndDisabledAttributes)
     EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::black);
 }
 
+const char kSamplerMetadataVertexShader0[] = R"(#version 300 es
+precision mediump float;
+out vec4 color;
+uniform sampler2D texture;
+void main()
+{
+    vec2 size = vec2(textureSize(texture, 0));
+    color = size.x != 0.0 ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 0.0);
+    vec2 pos = vec2(0.0);
+    switch (gl_VertexID) {
+        case 0: pos = vec2(-1.0, -1.0); break;
+        case 1: pos = vec2(3.0, -1.0); break;
+        case 2: pos = vec2(-1.0, 3.0); break;
+    };
+    gl_Position = vec4(pos, 0.0, 1.0);
+})";
+
+const char kSamplerMetadataVertexShader1[] = R"(#version 300 es
+precision mediump float;
+out vec4 color;
+uniform sampler2D texture1;
+uniform sampler2D texture2;
+void main()
+{
+    vec2 size1 = vec2(textureSize(texture1, 0));
+    vec2 size2 = vec2(textureSize(texture2, 0));
+    color = size1.x * size2.x != 0.0 ? vec4(0.0, 1.0, 0.0, 1.0) : vec4(1.0, 0.0, 0.0, 0.0);
+    vec2 pos = vec2(0.0);
+    switch (gl_VertexID) {
+        case 0: pos = vec2(-1.0, -1.0); break;
+        case 1: pos = vec2(3.0, -1.0); break;
+        case 2: pos = vec2(-1.0, 3.0); break;
+    };
+    gl_Position = vec4(pos, 0.0, 1.0);
+})";
+
+const char kSamplerMetadataFragmentShader[] = R"(#version 300 es
+precision mediump float;
+in vec4 color;
+out vec4 result;
+void main()
+{
+    result = color;
+})";
+
+// Tests that changing an active program invalidates the sampler metadata properly.
+TEST_P(StateChangeTestES3, SamplerMetadataUpdateOnSetProgram)
+{
+    GLVertexArray vertexArray;
+    glBindVertexArray(vertexArray);
+
+    // Create a simple framebuffer.
+    GLTexture texture1, texture2;
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, texture1);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+    glActiveTexture(GL_TEXTURE1);
+    glBindTexture(GL_TEXTURE_2D, texture2);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 3, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+    // Create 2 shader programs differing only in the number of active samplers.
+    ANGLE_GL_PROGRAM(program1, kSamplerMetadataVertexShader0, kSamplerMetadataFragmentShader);
+    glUseProgram(program1);
+    glUniform1i(glGetUniformLocation(program1, "texture"), 0);
+    ANGLE_GL_PROGRAM(program2, kSamplerMetadataVertexShader1, kSamplerMetadataFragmentShader);
+    glUseProgram(program2);
+    glUniform1i(glGetUniformLocation(program2, "texture1"), 0);
+    glUniform1i(glGetUniformLocation(program2, "texture2"), 0);
+
+    // Draw a solid green color to the framebuffer.
+    glUseProgram(program1);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+    // Test that our first program is good.
+    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
+
+    // Bind a different program that uses more samplers.
+    // Draw another quad that depends on the sampler metadata.
+    glUseProgram(program2);
+    glDrawArrays(GL_TRIANGLES, 0, 3);
+    // Flush via ReadPixels and check that it's still green.
+    EXPECT_PIXEL_COLOR_EQ(0, 0, GLColor::green);
+
+    ASSERT_GL_NO_ERROR();
+}
+
 // Simple state change tests, primarily focused on basic object lifetime and dependency management
 // with back-ends that don't support that automatically (i.e. Vulkan).
 class SimpleStateChangeTest : public ANGLETest