D3D11: Minor cleanup to DrawCallVertexParams.

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

@@ -1644,10 +1644,10 @@ gl::Error Renderer11::drawElements(const gl::Context *context,
 
     const auto &lazyIndexRange = context->getParams<gl::HasIndexRange>();
 
+    DrawCallVertexParams vertexParams(lazyIndexRange, 0, instances);
+
     bool usePrimitiveRestartWorkaround =
         UsePrimitiveRestartWorkaround(glState.isPrimitiveRestartEnabled(), type);
-    DrawCallVertexParams vertexParams(!usePrimitiveRestartWorkaround, lazyIndexRange, 0, instances);
-
     ANGLE_TRY(mStateManager.applyIndexBuffer(context, indices, count, type, lazyIndexRange,
                                              usePrimitiveRestartWorkaround));
     ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, true));
@@ -1821,11 +1821,16 @@ gl::Error Renderer11::drawElementsIndirect(const gl::Context *context,
         reinterpret_cast<const void *>(static_cast<uintptr_t>(firstIndex * typeInfo.bytes));
     gl::HasIndexRange lazyIndexRange(const_cast<gl::Context *>(context), count, type, indices);
 
+    DrawCallVertexParams vertexParams(lazyIndexRange, baseVertex, instances);
+
+    // We must explicitly resolve the index range for the slow-path indirect drawElements to make
+    // sure we are using the correct 'baseVertex'. This parameter does not exist for the direct
+    // drawElements.
+    vertexParams.ensureIndexRangeResolved();
+
     ANGLE_TRY(mStateManager.applyIndexBuffer(context, indices, count, type, lazyIndexRange,
                                              usePrimitiveRestartWorkaround));
 
-    DrawCallVertexParams vertexParams(false, lazyIndexRange, baseVertex, instances);
-
     ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, true));
 
     int baseVertexLocation = -static_cast<int>(lazyIndexRange.getIndexRange().value().start);

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

@@ -3194,35 +3194,29 @@ DrawCallVertexParams::DrawCallVertexParams(GLint firstVertex,
 }
 
 // Use when in a drawElements call.
-DrawCallVertexParams::DrawCallVertexParams(bool firstVertexDefinitelyZero,
-                                           const gl::HasIndexRange &hasIndexRange,
+DrawCallVertexParams::DrawCallVertexParams(const gl::HasIndexRange &hasIndexRange,
                                            GLint baseVertex,
                                            GLsizei instances)
     : mHasIndexRange(&hasIndexRange),
-      mFirstVertex(),
+      mFirstVertex(baseVertex),
       mVertexCount(0),
       mInstances(instances),
       mBaseVertex(baseVertex)
 {
-    if (firstVertexDefinitelyZero)
-    {
-        mFirstVertex = baseVertex;
-    }
 }
 
 GLint DrawCallVertexParams::firstVertex() const
 {
-    if (!mFirstVertex.valid())
-    {
-        ensureResolved();
-        ASSERT(mFirstVertex.valid());
-    }
-    return mFirstVertex.value();
+    // In some cases we can know the first vertex will be fixed at zero, if we're on the "fast
+    // path". In these cases the index range is not resolved. If the first vertex is not zero,
+    // however, then it must be because the index range is resolved.
+    ASSERT(mFirstVertex == 0 || mHasIndexRange == nullptr);
+    return mFirstVertex;
 }
 
 GLsizei DrawCallVertexParams::vertexCount() const
 {
-    ensureResolved();
+    ASSERT(mHasIndexRange == nullptr);
     return mVertexCount;
 }
 
@@ -3231,18 +3225,19 @@ GLsizei DrawCallVertexParams::instances() const
     return mInstances;
 }
 
-void DrawCallVertexParams::ensureResolved() const
+void DrawCallVertexParams::ensureIndexRangeResolved() const
 {
-    if (mHasIndexRange)
+    if (mHasIndexRange == nullptr)
     {
-        ASSERT(!mFirstVertex.valid() || mFirstVertex == mBaseVertex);
-
-        // Resolve the index range now if we need to.
-        const auto &indexRange = mHasIndexRange->getIndexRange().value();
-        mFirstVertex           = mBaseVertex + static_cast<GLint>(indexRange.start);
-        mVertexCount           = static_cast<GLsizei>(indexRange.vertexCount());
-        mHasIndexRange         = nullptr;
+        return;
     }
+
+    // This call will resolve the index range.
+    const gl::IndexRange &indexRange = mHasIndexRange->getIndexRange().value();
+
+    mFirstVertex   = mBaseVertex + static_cast<GLint>(indexRange.start);
+    mVertexCount   = static_cast<GLsizei>(indexRange.vertexCount());
+    mHasIndexRange = nullptr;
 }
 
 // OnConstantBufferDirtyReceiver implementation.

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

@@ -148,8 +148,7 @@ class DrawCallVertexParams final : angle::NonCopyable
     DrawCallVertexParams(GLint firstVertex, GLsizei vertexCount, GLsizei instances);
 
     // Use when in a drawElements call.
-    DrawCallVertexParams(bool firstVertexDefinitelyZero,
-                         const gl::HasIndexRange &hasIndexRange,
+    DrawCallVertexParams(const gl::HasIndexRange &hasIndexRange,
                          GLint baseVertex,
                          GLsizei instances);
 
@@ -160,11 +159,11 @@ class DrawCallVertexParams final : angle::NonCopyable
     GLsizei vertexCount() const;
     GLsizei instances() const;
 
-  private:
-    void ensureResolved() const;
+    void ensureIndexRangeResolved() const;
 
+  private:
     mutable const gl::HasIndexRange *mHasIndexRange;
-    mutable Optional<GLint> mFirstVertex;
+    mutable GLint mFirstVertex;
     mutable GLsizei mVertexCount;
     GLsizei mInstances;
     GLint mBaseVertex;

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

@@ -315,6 +315,8 @@ gl::Error VertexArray11::updateDirtyAndDynamicAttribs(const gl::Context *context
 
     if (mDynamicAttribsMask.any())
     {
+        vertexParams.ensureIndexRangeResolved();
+
         auto activeDynamicAttribs = (mDynamicAttribsMask & activeLocations);
         if (activeDynamicAttribs.none())
         {