Revert "D3D11: Fix draw perf regression with input layouts."

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -59,9 +59,12 @@ GLenum GetTextureType(GLenum samplerType)
 
 gl::InputLayout GetDefaultInputLayoutFromShader(const gl::Shader *vertexShader)
 {
-    gl::InputLayout defaultLayout;
-    for (const sh::Attribute &shaderAttr : vertexShader->getActiveAttributes())
+    gl::InputLayout defaultLayout(gl::MAX_VERTEX_ATTRIBS, gl::VERTEX_FORMAT_INVALID);
+    const auto &shaderAttributes = vertexShader->getActiveAttributes();
+    size_t layoutIndex = 0;
+    for (size_t attribIndex = 0; attribIndex < shaderAttributes.size(); ++attribIndex)
     {
+        const sh::Attribute &shaderAttr = shaderAttributes[attribIndex];
         if (shaderAttr.type != GL_NONE)
         {
             GLenum transposedType = gl::TransposeMatrixType(shaderAttr.type);
@@ -76,7 +79,7 @@ gl::InputLayout GetDefaultInputLayoutFromShader(const gl::Shader *vertexShader)
                 gl::VertexFormatType defaultType = gl::GetVertexFormatType(
                     componentType, GL_FALSE, components, pureInt);
 
-                defaultLayout.push_back(defaultType);
+                defaultLayout[layoutIndex++] = defaultType;
             }
         }
     }
@@ -147,36 +150,23 @@ void ProgramD3D::VertexExecutable::getSignature(RendererD3D *renderer,
                                                 const gl::InputLayout &inputLayout,
                                                 Signature *signatureOut)
 {
-    signatureOut->resize(inputLayout.size());
+    signatureOut->assign(inputLayout.size(), false);
 
     for (size_t index = 0; index < inputLayout.size(); ++index)
     {
         gl::VertexFormatType vertexFormatType = inputLayout[index];
-        bool converted = false;
         if (vertexFormatType != gl::VERTEX_FORMAT_INVALID)
         {
             VertexConversionType conversionType =
                 renderer->getVertexConversionType(vertexFormatType);
-            converted = ((conversionType & VERTEX_CONVERT_GPU) != 0);
+            (*signatureOut)[index] = ((conversionType & VERTEX_CONVERT_GPU) != 0);
         }
-
-        (*signatureOut)[index] = converted;
     }
 }
 
 bool ProgramD3D::VertexExecutable::matchesSignature(const Signature &signature) const
 {
-    size_t limit = std::max(mSignature.size(), signature.size());
-    for (size_t index = 0; index < limit; ++index)
-    {
-        // treat undefined indexes as 'not converted'
-        bool a = index < signature.size() ? signature[index] : false;
-        bool b = index < mSignature.size() ? mSignature[index] : false;
-        if (a != b)
-            return false;
-    }
-
-    return true;
+    return mSignature == signature;
 }
 
 ProgramD3D::PixelExecutable::PixelExecutable(const std::vector<GLenum> &outputSignature,
@@ -2070,7 +2060,7 @@ void ProgramD3D::sortAttributesByLayout(const std::vector<TranslatedAttribute> &
 
 void ProgramD3D::updateCachedInputLayout(const gl::Program *program, const gl::State &state)
 {
-    mCachedInputLayout.clear();
+    mCachedInputLayout.assign(gl::MAX_VERTEX_ATTRIBS, gl::VERTEX_FORMAT_INVALID);
     const int *semanticIndexes = program->getSemanticIndexes();
 
     const auto &vertexAttributes = state.getVertexArray()->getVertexAttributes();
@@ -2081,10 +2071,6 @@ void ProgramD3D::updateCachedInputLayout(const gl::Program *program, const gl::S
 
         if (semanticIndex != -1)
         {
-            if (mCachedInputLayout.size() < semanticIndex + 1)
-            {
-                mCachedInputLayout.resize(semanticIndex + 1, gl::VERTEX_FORMAT_INVALID);
-            }
             mCachedInputLayout[semanticIndex] =
                 GetVertexFormatType(vertexAttributes[attributeIndex],
                                     state.getVertexAttribCurrentValue(attributeIndex).Type);

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

@@ -31,16 +31,17 @@ gl::InputLayout GetInputLayout(
     const TranslatedAttribute *translatedAttributes[gl::MAX_VERTEX_ATTRIBS],
     size_t attributeCount)
 {
-    gl::InputLayout inputLayout(attributeCount, gl::VERTEX_FORMAT_INVALID);
-
+    gl::InputLayout inputLayout(gl::MAX_VERTEX_ATTRIBS, gl::VERTEX_FORMAT_INVALID);
     for (size_t attributeIndex = 0; attributeIndex < attributeCount; ++attributeIndex)
     {
         const TranslatedAttribute *translatedAttribute = translatedAttributes[attributeIndex];
 
         if (translatedAttribute->active)
         {
-            inputLayout[attributeIndex] = gl::GetVertexFormatType(
-                *translatedAttribute->attribute, translatedAttribute->currentValueType);
+            gl::VertexFormatType vertexFormatType =
+                gl::GetVertexFormatType(*translatedAttribute->attribute,
+                translatedAttribute->currentValueType);
+            inputLayout[attributeIndex] = vertexFormatType;
         }
     }
     return inputLayout;