Use a special flag to mark D3D11 shaders as dirty instead of NULL.

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -204,7 +204,7 @@ gl::Error RendererD3D::drawArrays(const gl::Data &data,
 
     if (!skipDraw(data, mode))
     {
-        error = drawArrays(mode, count, instances, transformFeedbackActive, program->usesPointSize());
+        error = drawArrays(data, mode, count, instances, transformFeedbackActive, program->usesPointSize());
         if (error.isError())
         {
             return error;

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -157,7 +157,7 @@ class RendererD3D : public Renderer
     gl::Error getScratchMemoryBuffer(size_t requestedSize, MemoryBuffer **bufferOut);
 
   protected:
-    virtual gl::Error drawArrays(GLenum mode, GLsizei count, GLsizei instances, bool transformFeedbackActive, bool usesPointSize) = 0;
+    virtual gl::Error drawArrays(const gl::Data &data, GLenum mode, GLsizei count, GLsizei instances, bool transformFeedbackActive, bool usesPointSize) = 0;
     virtual gl::Error drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices,
                                    gl::Buffer *elementArrayBuffer, const TranslatedIndexData &indexInfo, GLsizei instances) = 0;
 

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

@@ -188,7 +188,6 @@ Renderer11::Renderer11(egl::Display *display, EGLNativeDisplayType hDc, const eg
 
     mAppliedVertexShader = NULL;
     mAppliedGeometryShader = NULL;
-    mCurPointGeometryShader = NULL;
     mAppliedPixelShader = NULL;
 
     EGLint requestedMajorVersion = attributes.get(EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE, EGL_DONT_CARE);
@@ -1242,7 +1241,7 @@ void Renderer11::applyTransformFeedbackBuffers(const gl::State& state)
     }
 }
 
-gl::Error Renderer11::drawArrays(GLenum mode, GLsizei count, GLsizei instances, bool transformFeedbackActive, bool usesPointSize)
+gl::Error Renderer11::drawArrays(const gl::Data &data, GLenum mode, GLsizei count, GLsizei instances, bool transformFeedbackActive, bool usesPointSize)
 {
     bool useInstancedPointSpriteEmulation = usesPointSize && getWorkarounds().useInstancedPointSpriteEmulation;
     if (mode == GL_POINTS && transformFeedbackActive)
@@ -1263,19 +1262,38 @@ gl::Error Renderer11::drawArrays(GLenum mode, GLsizei count, GLsizei instances,
             mDeviceContext->Draw(count, 0);
         }
 
-        mDeviceContext->GSSetShader(mCurPointGeometryShader, NULL, 0);
-        mDeviceContext->PSSetShader(mAppliedPixelShader, NULL, 0);
+        ProgramD3D *programD3D = ProgramD3D::makeProgramD3D(data.state->getProgram()->getImplementation());
 
-        if (instances > 0)
+        rx::ShaderExecutableD3D *pixelExe = NULL;
+        gl::Error error = programD3D->getPixelExecutableForFramebuffer(data.state->getDrawFramebuffer(), &pixelExe);
+        if (error.isError())
         {
-            mDeviceContext->DrawInstanced(count, instances, 0, 0);
+            return error;
         }
-        else
+
+        // Skip this step if we're doing rasterizer discard.
+        if (pixelExe && !data.state->getRasterizerState().rasterizerDiscard)
         {
-            mDeviceContext->Draw(count, 0);
-        }
+            ID3D11PixelShader *pixelShader = ShaderExecutable11::makeShaderExecutable11(pixelExe)->getPixelShader();
+            ASSERT(reinterpret_cast<uintptr_t>(pixelShader) == mAppliedPixelShader);
+            mDeviceContext->PSSetShader(pixelShader, NULL, 0);
+
+            // Retrieve the point sprite geometry shader
+            rx::ShaderExecutableD3D *geometryExe = programD3D->getGeometryExecutable();
+            ID3D11GeometryShader *geometryShader = (geometryExe ? ShaderExecutable11::makeShaderExecutable11(geometryExe)->getGeometryShader() : NULL);
+            mAppliedGeometryShader = reinterpret_cast<uintptr_t>(geometryShader);
+            ASSERT(geometryShader);
+            mDeviceContext->GSSetShader(geometryShader, NULL, 0);
 
-        mDeviceContext->GSSetShader(mAppliedGeometryShader, NULL, 0);
+            if (instances > 0)
+            {
+                mDeviceContext->DrawInstanced(count, instances, 0, 0);
+            }
+            else
+            {
+                mDeviceContext->Draw(count, 0);
+            }
+        }
 
         return gl::Error(GL_NO_ERROR);
     }
@@ -1611,33 +1629,24 @@ gl::Error Renderer11::applyShaders(gl::Program *program, const gl::VertexFormat
 
     bool dirtyUniforms = false;
 
-    if (vertexShader != mAppliedVertexShader)
+    if (reinterpret_cast<uintptr_t>(vertexShader) != mAppliedVertexShader)
     {
         mDeviceContext->VSSetShader(vertexShader, NULL, 0);
-        mAppliedVertexShader = vertexShader;
+        mAppliedVertexShader = reinterpret_cast<uintptr_t>(vertexShader);
         dirtyUniforms = true;
     }
 
-    if (geometryShader != mAppliedGeometryShader)
+    if (reinterpret_cast<uintptr_t>(geometryShader) != mAppliedGeometryShader)
     {
         mDeviceContext->GSSetShader(geometryShader, NULL, 0);
-        mAppliedGeometryShader = geometryShader;
+        mAppliedGeometryShader = reinterpret_cast<uintptr_t>(geometryShader);
         dirtyUniforms = true;
     }
 
-    if (geometryExe && mCurRasterState.pointDrawMode)
-    {
-        mCurPointGeometryShader = ShaderExecutable11::makeShaderExecutable11(geometryExe)->getGeometryShader();
-    }
-    else
-    {
-        mCurPointGeometryShader = NULL;
-    }
-
-    if (pixelShader != mAppliedPixelShader)
+    if (reinterpret_cast<uintptr_t>(pixelShader) != mAppliedPixelShader)
     {
         mDeviceContext->PSSetShader(pixelShader, NULL, 0);
-        mAppliedPixelShader = pixelShader;
+        mAppliedPixelShader = reinterpret_cast<uintptr_t>(pixelShader);
         dirtyUniforms = true;
     }
 
@@ -1849,10 +1858,13 @@ void Renderer11::markAllStateDirty()
     mAppliedIBFormat = DXGI_FORMAT_UNKNOWN;
     mAppliedIBOffset = 0;
 
-    mAppliedVertexShader = NULL;
-    mAppliedGeometryShader = NULL;
-    mCurPointGeometryShader = NULL;
-    mAppliedPixelShader = NULL;
+
+    // dirtyPointer is a special value that will make the comparison with any valid pointer fail and force the renderer to re-apply the state.
+    const uintptr_t dirtyPointer = -1;
+
+    mAppliedVertexShader = dirtyPointer;
+    mAppliedGeometryShader = dirtyPointer;
+    mAppliedPixelShader = dirtyPointer;
 
     for (size_t i = 0; i < gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++)
     {

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

@@ -91,7 +91,7 @@ class Renderer11 : public RendererD3D
     virtual gl::Error applyIndexBuffer(const GLvoid *indices, gl::Buffer *elementArrayBuffer, GLsizei count, GLenum mode, GLenum type, TranslatedIndexData *indexInfo);
     virtual void applyTransformFeedbackBuffers(const gl::State &state);
 
-    virtual gl::Error drawArrays(GLenum mode, GLsizei count, GLsizei instances, bool transformFeedbackActive, bool usesPointSize);
+    virtual gl::Error drawArrays(const gl::Data &data, GLenum mode, GLsizei count, GLsizei instances, bool transformFeedbackActive, bool usesPointSize);
     virtual gl::Error drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices,
                                    gl::Buffer *elementArrayBuffer, const TranslatedIndexData &indexInfo, GLsizei instances);
 
@@ -322,10 +322,9 @@ class Renderer11 : public RendererD3D
                                                                                  // to different append behavior
 
     // Currently applied shaders
-    ID3D11VertexShader *mAppliedVertexShader;
-    ID3D11GeometryShader *mAppliedGeometryShader;
-    ID3D11GeometryShader *mCurPointGeometryShader;
-    ID3D11PixelShader *mAppliedPixelShader;
+    uintptr_t mAppliedVertexShader;
+    uintptr_t mAppliedGeometryShader;
+    uintptr_t mAppliedPixelShader;
 
     dx_VertexConstants mVertexConstants;
     dx_VertexConstants mAppliedVertexConstants;

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

@@ -1390,7 +1390,7 @@ void Renderer9::applyTransformFeedbackBuffers(const gl::State& state)
     UNREACHABLE();
 }
 
-gl::Error Renderer9::drawArrays(GLenum mode, GLsizei count, GLsizei instances, bool transformFeedbackActive, bool usesPointSize)
+gl::Error Renderer9::drawArrays(const gl::Data &data, GLenum mode, GLsizei count, GLsizei instances, bool transformFeedbackActive, bool usesPointSize)
 {
     ASSERT(!transformFeedbackActive);
 

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

@@ -93,7 +93,7 @@ class Renderer9 : public RendererD3D
 
     virtual void applyTransformFeedbackBuffers(const gl::State& state);
 
-    virtual gl::Error drawArrays(GLenum mode, GLsizei count, GLsizei instances, bool transformFeedbackActive, bool usesPointSize);
+    virtual gl::Error drawArrays(const gl::Data &data, GLenum mode, GLsizei count, GLsizei instances, bool transformFeedbackActive, bool usesPointSize);
     virtual gl::Error drawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices,
                                    gl::Buffer *elementArrayBuffer, const TranslatedIndexData &indexInfo, GLsizei instances);