D3D11: Cache element array buffer updates.

src/libANGLE/renderer/d3d/IndexDataManager.cpp

@@ -110,8 +110,30 @@ gl::Error StreamInIndexBuffer(IndexBufferInterface *buffer,
     return gl::NoError();
 }
 
+unsigned int ElementTypeSize(GLenum elementType)
+{
+    switch (elementType)
+    {
+        case GL_UNSIGNED_BYTE:
+            return sizeof(GLubyte);
+        case GL_UNSIGNED_SHORT:
+            return sizeof(GLushort);
+        case GL_UNSIGNED_INT:
+            return sizeof(GLuint);
+        default:
+            UNREACHABLE();
+            return 0;
+    }
+}
+
 }  // anonymous namespace
 
+bool IsOffsetAligned(GLenum elementType, unsigned int offset)
+{
+    return (offset % ElementTypeSize(elementType) == 0);
+}
+
+// IndexDataManager implementation.
 IndexDataManager::IndexDataManager(BufferFactoryD3D *factory)
     : mFactory(factory), mStreamingBufferShort(), mStreamingBufferInt()
 {
@@ -170,7 +192,7 @@ gl::Error IndexDataManager::prepareIndexData(const gl::Context *context,
     unsigned int offset = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(indices));
     ASSERT(srcTypeInfo.bytes * static_cast<unsigned int>(count) + offset <= buffer->getSize());
 
-    bool offsetAligned = (offset % gl::ElementTypeSize(srcType) == 0);
+    bool offsetAligned = IsOffsetAligned(srcType, offset);
 
     // Case 2a: the buffer can be used directly
     if (offsetAligned && buffer->supportsDirectBinding() && dstType == srcType)
@@ -182,10 +204,8 @@ gl::Error IndexDataManager::prepareIndexData(const gl::Context *context,
         translated->startOffset = offset;
         return gl::NoError();
     }
-    else
-    {
-        translated->storage = nullptr;
-    }
+
+    translated->storage = nullptr;
 
     // Case 2b: use a static translated copy or fall back to streaming
     StaticIndexBufferInterface *staticBuffer = buffer->getStaticIndexBuffer();

src/libANGLE/renderer/d3d/IndexDataManager.h

@@ -98,6 +98,8 @@ GLenum GetIndexTranslationDestType(GLenum srcType,
                                    const gl::HasIndexRange &lazyIndexRange,
                                    bool usePrimitiveRestartWorkaround);
 
+bool IsOffsetAligned(GLenum elementType, unsigned int offset);
+
 }  // namespace rx
 
 #endif  // LIBANGLE_INDEXDATAMANAGER_H_

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

@@ -473,6 +473,9 @@ gl::Error Buffer11::copySubData(const gl::Context *context,
     mSize = std::max<size_t>(mSize, destOffset + size);
     invalidateStaticData(context);
 
+    // Also notify that direct buffers are dirty.
+    mDirectBroadcastChannel.signal(context);
+
     return gl::NoError();
 }
 
@@ -755,6 +758,7 @@ Buffer11::BufferStorage *Buffer11::allocateStorage(BufferUsage usage)
             return new SystemMemoryStorage(mRenderer);
         case BUFFER_USAGE_EMULATED_INDEXED_VERTEX:
             return new EmulatedIndexedStorage(mRenderer);
+        case BUFFER_USAGE_INDEX:
         case BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK:
             return new NativeStorage(mRenderer, usage, &mDirectBroadcastChannel);
         default:

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

@@ -22,6 +22,7 @@
 #include "libANGLE/renderer/d3d/d3d11/Context11.h"
 #include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
 #include "libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h"
+#include "libANGLE/renderer/d3d/d3d11/VertexArray11.h"
 #include "libANGLE/renderer/d3d/d3d11/VertexBuffer11.h"
 #include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
 
@@ -126,7 +127,7 @@ gl::Error InputLayoutCache::applyVertexBuffers(
     const std::vector<const TranslatedAttribute *> &currentAttributes,
     GLenum mode,
     GLint start,
-    TranslatedIndexData *indexInfo)
+    bool isIndexedRendering)
 {
     Renderer11 *renderer   = GetImplAs<Context11>(context)->getRenderer();
     const gl::State &state = context->getGLState();
@@ -161,8 +162,11 @@ gl::Error InputLayoutCache::applyVertexBuffers(
                 ASSERT(attrib.vertexBuffer.get());
                 buffer = GetAs<VertexBuffer11>(attrib.vertexBuffer.get())->getBuffer().get();
             }
-            else if (instancedPointSpritesActive && (indexInfo != nullptr))
+            else if (instancedPointSpritesActive && isIndexedRendering)
             {
+                VertexArray11 *vao11 = GetImplAs<VertexArray11>(state.getVertexArray());
+                ASSERT(vao11->isCachedIndexInfoValid());
+                TranslatedIndexData *indexInfo = vao11->getCachedIndexInfo();
                 if (indexInfo->srcIndexData.srcBuffer != nullptr)
                 {
                     const uint8_t *bufferData = nullptr;

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

@@ -90,7 +90,7 @@ class InputLayoutCache : angle::NonCopyable
                                  const std::vector<const TranslatedAttribute *> &currentAttributes,
                                  GLenum mode,
                                  GLint start,
-                                 TranslatedIndexData *indexInfo);
+                                 bool isIndexedRendering);
 
     gl::Error updateVertexOffsetsForPointSpritesEmulation(
         Renderer11 *renderer,

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

@@ -1514,7 +1514,7 @@ gl::Error Renderer11::drawArrays(const gl::Context *context,
     }
 
     DrawCallVertexParams vertexParams(startVertex, count, instances);
-    ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, nullptr));
+    ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, false));
 
     if (glState.isTransformFeedbackActiveUnpaused())
     {
@@ -1651,10 +1651,9 @@ gl::Error Renderer11::drawElements(const gl::Context *context,
         UsePrimitiveRestartWorkaround(glState.isPrimitiveRestartEnabled(), type);
     DrawCallVertexParams vertexParams(!usePrimitiveRestartWorkaround, lazyIndexRange, 0, instances);
 
-    TranslatedIndexData indexInfo;
     ANGLE_TRY(mStateManager.applyIndexBuffer(context, indices, count, type, lazyIndexRange,
-                                             usePrimitiveRestartWorkaround, &indexInfo));
-    ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, &indexInfo));
+                                             usePrimitiveRestartWorkaround));
+    ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, true));
 
     int startVertex = static_cast<int>(vertexParams.firstVertex());
     int baseVertex  = -startVertex;
@@ -1742,7 +1741,7 @@ gl::Error Renderer11::drawArraysIndirect(const gl::Context *context,
     if (!DrawCallNeedsTranslation(context, mode))
     {
         DrawCallVertexParams vertexParams(0, 0, 0);
-        ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, nullptr));
+        ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, false));
         ID3D11Buffer *buffer = nullptr;
         ANGLE_TRY_RESULT(storage->getBuffer(context, BUFFER_USAGE_INDIRECT), buffer);
         mDeviceContext->DrawInstancedIndirect(buffer, static_cast<unsigned int>(offset));
@@ -1759,7 +1758,7 @@ gl::Error Renderer11::drawArraysIndirect(const gl::Context *context,
     GLuint first     = args->first;
 
     DrawCallVertexParams vertexParams(first, count, instances);
-    ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, nullptr));
+    ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, false));
 
     if (mode == GL_LINE_LOOP)
     {
@@ -1796,13 +1795,12 @@ gl::Error Renderer11::drawElementsIndirect(const gl::Context *context,
     bool usePrimitiveRestartWorkaround =
         UsePrimitiveRestartWorkaround(glState.isPrimitiveRestartEnabled(), type);
 
-    TranslatedIndexData indexInfo;
     if (!DrawCallNeedsTranslation(context, mode) && !IsStreamingIndexData(context, type))
     {
         ANGLE_TRY(mStateManager.applyIndexBuffer(context, nullptr, 0, type, gl::HasIndexRange(),
-                                                 usePrimitiveRestartWorkaround, &indexInfo));
+                                                 usePrimitiveRestartWorkaround));
         DrawCallVertexParams vertexParams(0, 0, 0);
-        ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, &indexInfo));
+        ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, true));
         ID3D11Buffer *buffer = nullptr;
         ANGLE_TRY_RESULT(storage->getBuffer(context, BUFFER_USAGE_INDIRECT), buffer);
         mDeviceContext->DrawIndexedInstancedIndirect(buffer, static_cast<unsigned int>(offset));
@@ -1827,11 +1825,11 @@ gl::Error Renderer11::drawElementsIndirect(const gl::Context *context,
     gl::HasIndexRange lazyIndexRange(const_cast<gl::Context *>(context), count, type, indices);
 
     ANGLE_TRY(mStateManager.applyIndexBuffer(context, indices, count, type, lazyIndexRange,
-                                             usePrimitiveRestartWorkaround, &indexInfo));
+                                             usePrimitiveRestartWorkaround));
 
     DrawCallVertexParams vertexParams(false, lazyIndexRange, baseVertex, instances);
 
-    ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, &indexInfo));
+    ANGLE_TRY(mStateManager.applyVertexBuffer(context, mode, vertexParams, true));
 
     int baseVertexLocation = -static_cast<int>(lazyIndexRange.getIndexRange().value().start);
 

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

@@ -562,6 +562,7 @@ StateManager11::StateManager11(Renderer11 *renderer)
       mAppliedIB(nullptr),
       mAppliedIBFormat(DXGI_FORMAT_UNKNOWN),
       mAppliedIBOffset(0),
+      mIndexBufferIsDirty(false),
       mVertexDataManager(renderer),
       mIndexDataManager(renderer),
       mIsMultiviewEnabled(false),
@@ -952,6 +953,8 @@ void StateManager11::syncState(const gl::Context *context, const gl::State::Dirt
                 // internal cache of TranslatedAttributes, and they CurrentValue attributes are
                 // owned by the StateManager11/Context.
                 mDirtyCurrentValueAttribs.set();
+                // Invalidate the cached index buffer.
+                mIndexBufferIsDirty = true;
                 break;
             case gl::State::DIRTY_BIT_TEXTURE_BINDINGS:
                 invalidateTexturesAndSamplers();
@@ -2486,7 +2489,7 @@ gl::Error StateManager11::syncProgram(const gl::Context *context, GLenum drawMod
 gl::Error StateManager11::applyVertexBuffer(const gl::Context *context,
                                             GLenum mode,
                                             const DrawCallVertexParams &vertexParams,
-                                            TranslatedIndexData *indexInfo)
+                                            bool isIndexedRendering)
 {
     const auto &state       = context->getGLState();
     const gl::VertexArray *vertexArray = state.getVertexArray();
@@ -2544,7 +2547,7 @@ gl::Error StateManager11::applyVertexBuffer(const gl::Context *context,
 
     // Update the applied vertex buffers.
     ANGLE_TRY(mInputLayoutCache.applyVertexBuffers(context, mCurrentAttributes, mode,
-                                                   vertexParams.firstVertex(), indexInfo));
+                                                   vertexParams.firstVertex(), isIndexedRendering));
 
     // InputLayoutCache::applyVertexBuffers calls through to the Bufer11 to get the native vertex
     // buffer (ID3D11Buffer *). Because we allocate these buffers lazily, this will trigger
@@ -2564,18 +2567,27 @@ gl::Error StateManager11::applyIndexBuffer(const gl::Context *context,
                                            GLsizei count,
                                            GLenum type,
                                            const gl::HasIndexRange &lazyIndexRange,
-                                           bool usePrimitiveRestartWorkaround,
-                                           TranslatedIndexData *indexInfo)
+                                           bool usePrimitiveRestartWorkaround)
 {
-    const auto &glState            = context->getGLState();
-    gl::VertexArray *vao           = glState.getVertexArray();
-    gl::Buffer *elementArrayBuffer = vao->getElementArrayBuffer().get();
+    const auto &glState  = context->getGLState();
+    gl::VertexArray *vao = glState.getVertexArray();
+    VertexArray11 *vao11 = GetImplAs<VertexArray11>(vao);
 
-    GLenum dstType =
+    GLenum destElementType =
         GetIndexTranslationDestType(type, lazyIndexRange, usePrimitiveRestartWorkaround);
 
-    ANGLE_TRY(mIndexDataManager.prepareIndexData(context, type, dstType, count, elementArrayBuffer,
-                                                 indices, indexInfo));
+    if (!vao11->updateElementArrayStorage(context, type, destElementType, indices) &&
+        !mIndexBufferIsDirty)
+    {
+        // No streaming or index buffer application necessary.
+        return gl::NoError();
+    }
+
+    gl::Buffer *elementArrayBuffer = vao->getElementArrayBuffer().get();
+
+    TranslatedIndexData *indexInfo = vao11->getCachedIndexInfo();
+    ANGLE_TRY(mIndexDataManager.prepareIndexData(context, type, destElementType, count,
+                                                 elementArrayBuffer, indices, indexInfo));
 
     ID3D11Buffer *buffer = nullptr;
     DXGI_FORMAT bufferFormat =
@@ -2594,15 +2606,28 @@ gl::Error StateManager11::applyIndexBuffer(const gl::Context *context,
 
     // Track dirty indices in the index range cache.
     indexInfo->srcIndexData.srcIndicesChanged =
-        setIndexBuffer(buffer, bufferFormat, indexInfo->startOffset);
+        syncIndexBuffer(buffer, bufferFormat, indexInfo->startOffset);
+
+    mIndexBufferIsDirty = false;
 
+    vao11->setCachedIndexInfoValid();
     return gl::NoError();
 }
 
-bool StateManager11::setIndexBuffer(ID3D11Buffer *buffer,
+void StateManager11::setIndexBuffer(ID3D11Buffer *buffer,
                                     DXGI_FORMAT indexFormat,
                                     unsigned int offset)
 {
+    if (syncIndexBuffer(buffer, indexFormat, offset))
+    {
+        mIndexBufferIsDirty = true;
+    }
+}
+
+bool StateManager11::syncIndexBuffer(ID3D11Buffer *buffer,
+                                     DXGI_FORMAT indexFormat,
+                                     unsigned int offset)
+{
     if (buffer != mAppliedIB || indexFormat != mAppliedIBFormat || offset != mAppliedIBOffset)
     {
         mRenderer->getDeviceContext()->IASetIndexBuffer(buffer, indexFormat, offset);

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

@@ -267,17 +267,16 @@ class StateManager11 final : angle::NonCopyable
     gl::Error applyVertexBuffer(const gl::Context *context,
                                 GLenum mode,
                                 const DrawCallVertexParams &vertexParams,
-                                TranslatedIndexData *indexInfo);
+                                bool isIndexedRendering);
 
     gl::Error applyIndexBuffer(const gl::Context *context,
                                const void *indices,
                                GLsizei count,
                                GLenum type,
                                const gl::HasIndexRange &lazyIndexRange,
-                               bool usePrimitiveRestartWorkaround,
-                               TranslatedIndexData *indexInfo);
+                               bool usePrimitiveRestartWorkaround);
 
-    bool setIndexBuffer(ID3D11Buffer *buffer, DXGI_FORMAT indexFormat, unsigned int offset);
+    void setIndexBuffer(ID3D11Buffer *buffer, DXGI_FORMAT indexFormat, unsigned int offset);
 
     gl::Error updateVertexOffsetsForPointSpritesEmulation(GLint startVertex,
                                                           GLsizei emulatedInstanceId);
@@ -359,6 +358,8 @@ class StateManager11 final : angle::NonCopyable
     // Called by the Framebuffer11 directly.
     void processFramebufferInvalidation(const gl::Context *context);
 
+    bool syncIndexBuffer(ID3D11Buffer *buffer, DXGI_FORMAT indexFormat, unsigned int offset);
+
     enum DirtyBitType
     {
         DIRTY_BIT_RENDER_TARGET,
@@ -508,6 +509,7 @@ class StateManager11 final : angle::NonCopyable
     ID3D11Buffer *mAppliedIB;
     DXGI_FORMAT mAppliedIBFormat;
     unsigned int mAppliedIBOffset;
+    bool mIndexBufferIsDirty;
 
     // Vertex, index and input layouts
     VertexDataManager mVertexDataManager;

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

@@ -19,16 +19,43 @@ using namespace angle;
 namespace rx
 {
 
+namespace
+{
+OnBufferDataDirtyChannel *GetBufferBroadcastChannel(Buffer11 *buffer11,
+                                                    IndexStorageType storageType)
+{
+    switch (storageType)
+    {
+        case IndexStorageType::Direct:
+            return buffer11->getDirectBroadcastChannel();
+        case IndexStorageType::Static:
+            return buffer11->getStaticBroadcastChannel();
+        case IndexStorageType::Dynamic:
+            return buffer11 ? buffer11->getStaticBroadcastChannel() : nullptr;
+        default:
+            UNREACHABLE();
+            return nullptr;
+    }
+}
+}  // anonymous namespace
+
 VertexArray11::VertexArray11(const gl::VertexArrayState &data)
     : VertexArrayImpl(data),
       mAttributeStorageTypes(data.getMaxAttribs(), VertexStorageType::CURRENT_VALUE),
       mTranslatedAttribs(data.getMaxAttribs()),
-      mCurrentBuffers(data.getMaxAttribs()),
-      mAppliedNumViewsToDivisor(1)
+      mCurrentArrayBuffers(data.getMaxAttribs()),
+      mCurrentElementArrayBuffer(),
+      mOnArrayBufferDataDirty(),
+      mOnElementArrayBufferDataDirty(this, mCurrentArrayBuffers.size()),
+      mAppliedNumViewsToDivisor(1),
+      mLastElementType(GL_NONE),
+      mLastDrawElementsOffset(0),
+      mCurrentElementArrayStorage(IndexStorageType::Invalid),
+      mCachedIndexInfoValid(false)
 {
-    for (size_t attribIndex = 0; attribIndex < mCurrentBuffers.size(); ++attribIndex)
+    for (size_t attribIndex = 0; attribIndex < mCurrentArrayBuffers.size(); ++attribIndex)
     {
-        mOnBufferDataDirty.emplace_back(this, attribIndex);
+        mOnArrayBufferDataDirty.emplace_back(this, attribIndex);
     }
 }
 
@@ -38,13 +65,15 @@ VertexArray11::~VertexArray11()
 
 void VertexArray11::destroy(const gl::Context *context)
 {
-    for (auto &buffer : mCurrentBuffers)
+    for (auto &buffer : mCurrentArrayBuffers)
     {
         if (buffer.get())
         {
             buffer.set(context, nullptr);
         }
     }
+
+    mCurrentElementArrayBuffer.set(context, nullptr);
 }
 
 void VertexArray11::syncState(const gl::Context *context,
@@ -63,12 +92,17 @@ void VertexArray11::syncState(const gl::Context *context,
     for (auto dirtyBit : dirtyBits)
     {
         if (dirtyBit == gl::VertexArray::DIRTY_BIT_ELEMENT_ARRAY_BUFFER)
-            continue;
-
-        size_t index = gl::VertexArray::GetVertexIndexFromDirtyBit(dirtyBit);
-        // TODO(jiawei.shao@intel.com): Vertex Attrib Bindings
-        ASSERT(index == mState.getBindingIndexFromAttribIndex(index));
-        mAttribsToUpdate.set(index);
+        {
+            mCachedIndexInfoValid = false;
+            mLastElementType      = GL_NONE;
+        }
+        else
+        {
+            size_t index = gl::VertexArray::GetVertexIndexFromDirtyBit(dirtyBit);
+            // TODO(jiawei.shao@intel.com): Vertex Attrib Bindings
+            ASSERT(index == mState.getBindingIndexFromAttribIndex(index));
+            mAttribsToUpdate.set(index);
+        }
     }
 }
 
@@ -94,6 +128,59 @@ bool VertexArray11::flushAttribUpdates(const gl::Context *context)
     return false;
 }
 
+bool VertexArray11::updateElementArrayStorage(const gl::Context *context,
+                                              GLenum elementType,
+                                              GLenum destElementType,
+                                              const void *indices)
+{
+    unsigned int offset = static_cast<unsigned int>(reinterpret_cast<uintptr_t>(indices));
+
+    if (mCachedIndexInfoValid && mLastElementType == elementType &&
+        offset == mLastDrawElementsOffset)
+    {
+        // Dynamic index buffers must be re-streamed every draw.
+        return (mCurrentElementArrayStorage == IndexStorageType::Dynamic);
+    }
+
+    gl::Buffer *newBuffer           = mState.getElementArrayBuffer().get();
+    gl::Buffer *oldBuffer           = mCurrentElementArrayBuffer.get();
+    bool needsTranslation           = false;
+    IndexStorageType newStorageType = ClassifyIndexStorage(
+        context->getGLState(), newBuffer, elementType, destElementType, offset, &needsTranslation);
+
+    if (newBuffer != oldBuffer)
+    {
+        mCurrentElementArrayBuffer.set(context, newBuffer);
+    }
+
+    if (newStorageType != mCurrentElementArrayStorage || newBuffer != oldBuffer)
+    {
+        Buffer11 *newBuffer11 = SafeGetImplAs<Buffer11>(newBuffer);
+
+        auto *newChannel = GetBufferBroadcastChannel(newBuffer11, newStorageType);
+
+        mCurrentElementArrayStorage = newStorageType;
+        mOnElementArrayBufferDataDirty.bind(newChannel);
+        needsTranslation = true;
+    }
+
+    if (mLastDrawElementsOffset != offset)
+    {
+        needsTranslation        = true;
+        mLastDrawElementsOffset = offset;
+    }
+
+    if (mLastElementType != elementType)
+    {
+        needsTranslation = true;
+        mLastElementType = elementType;
+    }
+
+    // TODO(jmadill): We should probably promote static usage immediately, because this can change
+    // the storage type for dynamic buffers.
+    return needsTranslation || !mCachedIndexInfoValid;
+}
+
 void VertexArray11::updateVertexAttribStorage(const gl::Context *context, size_t attribIndex)
 {
     const auto &attrib  = mState.getVertexAttribute(attribIndex);
@@ -128,7 +215,7 @@ void VertexArray11::updateVertexAttribStorage(const gl::Context *context, size_t
         }
     }
 
-    gl::Buffer *oldBufferGL = mCurrentBuffers[attribIndex].get();
+    gl::Buffer *oldBufferGL = mCurrentArrayBuffers[attribIndex].get();
     gl::Buffer *newBufferGL = binding.getBuffer().get();
     Buffer11 *oldBuffer11   = oldBufferGL ? GetImplAs<Buffer11>(oldBufferGL) : nullptr;
     Buffer11 *newBuffer11   = newBufferGL ? GetImplAs<Buffer11>(newBufferGL) : nullptr;
@@ -160,8 +247,8 @@ void VertexArray11::updateVertexAttribStorage(const gl::Context *context, size_t
             }
         }
 
-        mOnBufferDataDirty[attribIndex].bind(newChannel);
-        mCurrentBuffers[attribIndex].set(context, binding.getBuffer().get());
+        mOnArrayBufferDataDirty[attribIndex].bind(newChannel);
+        mCurrentArrayBuffers[attribIndex].set(context, binding.getBuffer().get());
     }
 }
 
@@ -263,14 +350,23 @@ const std::vector<TranslatedAttribute> &VertexArray11::getTranslatedAttribs() co
 
 void VertexArray11::signal(size_t channelID, const gl::Context *context)
 {
-    ASSERT(mAttributeStorageTypes[channelID] != VertexStorageType::CURRENT_VALUE);
+    if (channelID == mAttributeStorageTypes.size())
+    {
+        mCachedIndexInfoValid   = false;
+        mLastElementType        = GL_NONE;
+        mLastDrawElementsOffset = 0;
+    }
+    else
+    {
+        ASSERT(mAttributeStorageTypes[channelID] != VertexStorageType::CURRENT_VALUE);
 
-    // This can change a buffer's storage, we'll need to re-check.
-    mAttribsToUpdate.set(channelID);
+        // This can change a buffer's storage, we'll need to re-check.
+        mAttribsToUpdate.set(channelID);
 
-    // Changing the vertex attribute state can affect the vertex shader.
-    Renderer11 *renderer = GetImplAs<Context11>(context)->getRenderer();
-    renderer->getStateManager()->invalidateShaders();
+        // Changing the vertex attribute state can affect the vertex shader.
+        Renderer11 *renderer = GetImplAs<Context11>(context)->getRenderer();
+        renderer->getStateManager()->invalidateShaders();
+    }
 }
 
 void VertexArray11::clearDirtyAndPromoteDynamicAttribs(const gl::Context *context,
@@ -299,4 +395,19 @@ void VertexArray11::markAllAttributeDivisorsForAdjustment(int numViews)
     }
 }
 
+TranslatedIndexData *VertexArray11::getCachedIndexInfo()
+{
+    return &mCachedIndexInfo;
+}
+
+void VertexArray11::setCachedIndexInfoValid()
+{
+    mCachedIndexInfoValid = true;
+}
+
+bool VertexArray11::isCachedIndexInfoValid() const
+{
+    return mCachedIndexInfoValid;
+}
+
 }  // namespace rx

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

@@ -12,6 +12,7 @@
 #include "libANGLE/Framebuffer.h"
 #include "libANGLE/renderer/VertexArrayImpl.h"
 #include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
+#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
 #include "libANGLE/signal_utils.h"
 
 namespace rx
@@ -48,6 +49,16 @@ class VertexArray11 : public VertexArrayImpl, public OnBufferDataDirtyReceiver
 
     bool flushAttribUpdates(const gl::Context *context);
 
+    // Returns true if the element array buffer needs to be translated.
+    bool updateElementArrayStorage(const gl::Context *context,
+                                   GLenum elementType,
+                                   GLenum destElementType,
+                                   const void *indices);
+
+    TranslatedIndexData *getCachedIndexInfo();
+    void setCachedIndexInfoValid();
+    bool isCachedIndexInfoValid() const;
+
   private:
     void updateVertexAttribStorage(const gl::Context *context, size_t attribIndex);
 
@@ -64,14 +75,23 @@ class VertexArray11 : public VertexArrayImpl, public OnBufferDataDirtyReceiver
     gl::AttributesMask mAttribsToTranslate;
 
     // We need to keep a safe pointer to the Buffer so we can attach the correct dirty callbacks.
-    std::vector<gl::BindingPointer<gl::Buffer>> mCurrentBuffers;
+    std::vector<gl::BindingPointer<gl::Buffer>> mCurrentArrayBuffers;
+    gl::BindingPointer<gl::Buffer> mCurrentElementArrayBuffer;
 
-    std::vector<OnBufferDataDirtyBinding> mOnBufferDataDirty;
+    std::vector<OnBufferDataDirtyBinding> mOnArrayBufferDataDirty;
+    OnBufferDataDirtyBinding mOnElementArrayBufferDataDirty;
 
     Serial mCurrentStateSerial;
 
     // The numViews value used to adjust the divisor.
     int mAppliedNumViewsToDivisor;
+
+    // If the index buffer needs re-streaming.
+    GLenum mLastElementType;
+    unsigned int mLastDrawElementsOffset;
+    IndexStorageType mCurrentElementArrayStorage;
+    TranslatedIndexData mCachedIndexInfo;
+    bool mCachedIndexInfoValid;
 };
 
 }  // namespace rx

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

@@ -2381,4 +2381,41 @@ bool IsStreamingIndexData(const gl::Context *context, GLenum srcType)
     return false;
 }
 
+IndexStorageType ClassifyIndexStorage(const gl::State &glState,
+                                      const gl::Buffer *elementArrayBuffer,
+                                      GLenum elementType,
+                                      GLenum destElementType,
+                                      unsigned int offset,
+                                      bool *needsTranslation)
+{
+    // No buffer bound means we are streaming from a client pointer.
+    if (!elementArrayBuffer || !IsOffsetAligned(elementType, offset))
+    {
+        *needsTranslation = true;
+        return IndexStorageType::Dynamic;
+    }
+
+    // The buffer can be used directly if the storage supports it and no translation needed.
+    BufferD3D *bufferD3D = GetImplAs<BufferD3D>(elementArrayBuffer);
+    if (bufferD3D->supportsDirectBinding() && destElementType == elementType)
+    {
+        *needsTranslation = false;
+        return IndexStorageType::Direct;
+    }
+
+    // Use a static copy when available.
+    StaticIndexBufferInterface *staticBuffer = bufferD3D->getStaticIndexBuffer();
+    if (staticBuffer != nullptr)
+    {
+        // Need to re-translate the static data if has never been used, or changed type.
+        *needsTranslation =
+            (staticBuffer->getBufferSize() == 0 || staticBuffer->getIndexType() != destElementType);
+        return IndexStorageType::Static;
+    }
+
+    // Static buffer not available, fall back to streaming.
+    *needsTranslation = true;
+    return IndexStorageType::Dynamic;
+}
+
 }  // namespace rx

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

@@ -392,6 +392,30 @@ bool UsePresentPathFast(const Renderer11 *renderer, const gl::FramebufferAttachm
 bool UsePrimitiveRestartWorkaround(bool primitiveRestartFixedIndexEnabled, GLenum type);
 bool IsStreamingIndexData(const gl::Context *context, GLenum srcType);
 
+enum class IndexStorageType
+{
+    // Dynamic indexes are re-streamed every frame. They come from a client data pointer or
+    // from buffers that are updated frequently.
+    Dynamic,
+
+    // Static indexes are translated from the original storage once, and re-used multiple times.
+    Static,
+
+    // Direct indexes are never transated and are used directly from the source buffer. They are
+    // the fastest available path.
+    Direct,
+
+    // Not a real storage type.
+    Invalid,
+};
+
+IndexStorageType ClassifyIndexStorage(const gl::State &glState,
+                                      const gl::Buffer *elementArrayBuffer,
+                                      GLenum elementType,
+                                      GLenum destElementType,
+                                      unsigned int offset,
+                                      bool *needsTranslation);
+
 // Used for state change notifications between buffers and vertex arrays.
 using OnBufferDataDirtyBinding  = angle::ChannelBinding<size_t, const gl::Context *>;
 using OnBufferDataDirtyChannel  = angle::BroadcastChannel<size_t, const gl::Context *>;