D3D11: Futher optimize input layout cache.

src/libANGLE/Program.h

@@ -195,6 +195,7 @@ class Program : angle::NonCopyable
     void getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
     GLint getActiveAttributeCount();
     GLint getActiveAttributeMaxLength();
+    const sh::Attribute *getLinkedAttributes() const { return mLinkedAttribute; }
 
     GLint getSamplerMapping(SamplerType type, unsigned int samplerIndex, const Caps &caps);
     GLenum getSamplerTextureType(SamplerType type, unsigned int samplerIndex);

src/libANGLE/formatutils.cpp

@@ -647,6 +647,58 @@ const FormatSet &GetAllSizedInternalFormats()
     return formatSet;
 }
 
+AttributeType GetAttributeType(GLenum enumValue)
+{
+    switch (enumValue)
+    {
+        case GL_FLOAT:
+            return ATTRIBUTE_FLOAT;
+        case GL_FLOAT_VEC2:
+            return ATTRIBUTE_VEC2;
+        case GL_FLOAT_VEC3:
+            return ATTRIBUTE_VEC3;
+        case GL_FLOAT_VEC4:
+            return ATTRIBUTE_VEC4;
+        case GL_INT:
+            return ATTRIBUTE_INT;
+        case GL_INT_VEC2:
+            return ATTRIBUTE_IVEC2;
+        case GL_INT_VEC3:
+            return ATTRIBUTE_IVEC3;
+        case GL_INT_VEC4:
+            return ATTRIBUTE_IVEC4;
+        case GL_UNSIGNED_INT:
+            return ATTRIBUTE_UINT;
+        case GL_UNSIGNED_INT_VEC2:
+            return ATTRIBUTE_UVEC2;
+        case GL_UNSIGNED_INT_VEC3:
+            return ATTRIBUTE_UVEC3;
+        case GL_UNSIGNED_INT_VEC4:
+            return ATTRIBUTE_UVEC4;
+        case GL_FLOAT_MAT2:
+            return ATTRIBUTE_MAT2;
+        case GL_FLOAT_MAT3:
+            return ATTRIBUTE_MAT3;
+        case GL_FLOAT_MAT4:
+            return ATTRIBUTE_MAT4;
+        case GL_FLOAT_MAT2x3:
+            return ATTRIBUTE_MAT2x3;
+        case GL_FLOAT_MAT2x4:
+            return ATTRIBUTE_MAT2x4;
+        case GL_FLOAT_MAT3x2:
+            return ATTRIBUTE_MAT3x2;
+        case GL_FLOAT_MAT3x4:
+            return ATTRIBUTE_MAT3x4;
+        case GL_FLOAT_MAT4x2:
+            return ATTRIBUTE_MAT4x2;
+        case GL_FLOAT_MAT4x3:
+            return ATTRIBUTE_MAT4x3;
+        default:
+            UNREACHABLE();
+            return ATTRIBUTE_FLOAT;
+    }
+}
+
 VertexFormatType GetVertexFormatType(GLenum type, GLboolean normalized, GLuint components, bool pureInteger)
 {
     switch (type)

src/libANGLE/formatutils.h

@@ -76,6 +76,37 @@ GLenum GetSizedInternalFormat(GLenum internalFormat, GLenum type);
 typedef std::set<GLenum> FormatSet;
 const FormatSet &GetAllSizedInternalFormats();
 
+// From the ESSL 3.00.4 spec:
+// Vertex shader inputs can only be float, floating-point vectors, matrices, signed and unsigned
+// integers and integer vectors. Vertex shader inputs cannot be arrays or structures.
+
+enum AttributeType
+{
+    ATTRIBUTE_FLOAT,
+    ATTRIBUTE_VEC2,
+    ATTRIBUTE_VEC3,
+    ATTRIBUTE_VEC4,
+    ATTRIBUTE_INT,
+    ATTRIBUTE_IVEC2,
+    ATTRIBUTE_IVEC3,
+    ATTRIBUTE_IVEC4,
+    ATTRIBUTE_UINT,
+    ATTRIBUTE_UVEC2,
+    ATTRIBUTE_UVEC3,
+    ATTRIBUTE_UVEC4,
+    ATTRIBUTE_MAT2,
+    ATTRIBUTE_MAT3,
+    ATTRIBUTE_MAT4,
+    ATTRIBUTE_MAT2x3,
+    ATTRIBUTE_MAT2x4,
+    ATTRIBUTE_MAT3x2,
+    ATTRIBUTE_MAT3x4,
+    ATTRIBUTE_MAT4x2,
+    ATTRIBUTE_MAT4x3,
+};
+
+AttributeType GetAttributeType(GLenum enumValue);
+
 enum VertexFormatType
 {
     VERTEX_FORMAT_INVALID,

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

@@ -10,16 +10,17 @@
 #ifndef LIBANGLE_RENDERER_D3D_D3D11_INPUTLAYOUTCACHE_H_
 #define LIBANGLE_RENDERER_D3D_D3D11_INPUTLAYOUTCACHE_H_
 
-#include "libANGLE/Constants.h"
-#include "libANGLE/Error.h"
-#include "common/angleutils.h"
-
 #include <GLES2/gl2.h>
 
 #include <cstddef>
 #include <map>
 #include <unordered_map>
 
+#include "common/angleutils.h"
+#include "libANGLE/Constants.h"
+#include "libANGLE/Error.h"
+#include "libANGLE/formatutils.h"
+
 namespace gl
 {
 class Program;
@@ -48,28 +49,6 @@ class InputLayoutCache : angle::NonCopyable
     void setCacheSize(unsigned int cacheSize) { mCacheSize = cacheSize; }
 
   private:
-    struct InputLayoutElement
-    {
-        D3D11_INPUT_ELEMENT_DESC desc;
-        GLenum glslElementType;
-    };
-
-    struct InputLayoutKey
-    {
-        unsigned int elementCount;
-        InputLayoutElement elements[gl::MAX_VERTEX_ATTRIBS];
-
-        const char *begin() const
-        {
-            return reinterpret_cast<const char*>(&elementCount);
-        }
-
-        const char *end() const
-        {
-            return reinterpret_cast<const char*>(&elements[elementCount]);
-        }
-    };
-
     struct PackedAttributeLayout
     {
         PackedAttributeLayout()
@@ -80,23 +59,10 @@ class InputLayoutCache : angle::NonCopyable
 
         void addAttributeData(GLenum glType,
                               UINT semanticIndex,
-                              DXGI_FORMAT dxgiFormat,
-                              unsigned int divisor)
-        {
-            attributeData[numAttributes].glType = glType;
-            attributeData[numAttributes].semanticIndex = semanticIndex;
-            attributeData[numAttributes].dxgiFormat = dxgiFormat;
-            attributeData[numAttributes].divisor = divisor;
-            ++numAttributes;
-        }
+                              gl::VertexFormatType vertexFormatType,
+                              unsigned int divisor);
 
-        struct PackedAttribute
-        {
-            GLenum glType;
-            UINT semanticIndex;
-            DXGI_FORMAT dxgiFormat;
-            unsigned int divisor;
-        };
+        bool operator<(const PackedAttributeLayout &other) const;
 
         enum Flags
         {
@@ -107,15 +73,10 @@ class InputLayoutCache : angle::NonCopyable
 
         size_t numAttributes;
         unsigned int flags;
-        PackedAttribute attributeData[gl::MAX_VERTEX_ATTRIBS];
-    };
-
-    struct PackedAttributeComparator
-    {
-        bool operator()(const PackedAttributeLayout &a, const PackedAttributeLayout &b) const;
+        uint32_t attributeData[gl::MAX_VERTEX_ATTRIBS];
     };
 
-    std::map<PackedAttributeLayout, ID3D11InputLayout *, PackedAttributeComparator> mLayoutMap;
+    std::map<PackedAttributeLayout, ID3D11InputLayout *> mLayoutMap;
 
     ID3D11InputLayout *mCurrentIL;
     ID3D11Buffer *mCurrentBuffers[gl::MAX_VERTEX_ATTRIBS];

src/tests/gl_tests/VertexAttributeTest.cpp

@@ -333,6 +333,22 @@ TEST_P(VertexAttributeTest, MaxAttribsPlusOne)
     ASSERT_EQ(0u, program);
 }
 
+// Simple test for when we use glBindAttribLocation
+TEST_P(VertexAttributeTest, SimpleBindAttribLocation)
+{
+    // Re-use the multi-attrib program, binding attribute 0
+    GLuint program = compileMultiAttribProgram(1);
+    glBindAttribLocation(program, 2, "position");
+    glBindAttribLocation(program, 3, "a0");
+    glLinkProgram(program);
+
+    // Setup and draw the quad
+    setupMultiAttribs(program, 1, 0.5f);
+    drawQuad(program, "position", 0.5f);
+    EXPECT_GL_NO_ERROR();
+    EXPECT_PIXEL_NEAR(0, 0, 128, 0, 0, 255, 1);
+}
+
 // Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
 // D3D11 Feature Level 9_3 uses different D3D formats for vertex attribs compared to Feature Levels 10_0+, so we should test them separately.
 ANGLE_INSTANTIATE_TEST(VertexAttributeTest, ES2_D3D9(), ES2_D3D11(), ES2_D3D11_FL9_3(), ES2_OPENGL(), ES3_OPENGL());