Revert "Move shader attributes into Program shared data."

src/libANGLE/Program.h

@@ -180,7 +180,6 @@ class Program : angle::NonCopyable
             ASSERT(uniformBlockIndex < IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS);
             return mUniformBlockBindings[uniformBlockIndex];
         }
-        const std::vector<sh::Attribute> &getAttributes() const { return mAttributes; }
 
       private:
         friend class Program;
@@ -194,8 +193,6 @@ class Program : angle::NonCopyable
 
         GLuint mUniformBlockBindings[IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS];
 
-        std::vector<sh::Attribute> mAttributes;
-
         // TODO(jmadill): move more state into Data.
     };
 
@@ -231,7 +228,7 @@ class Program : angle::NonCopyable
     void getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
     GLint getActiveAttributeCount();
     GLint getActiveAttributeMaxLength();
-    const std::vector<sh::Attribute> &getAttributes() const { return mData.mAttributes; }
+    const std::vector<sh::Attribute> &getLinkedAttributes() const { return mLinkedAttributes; }
 
     GLint getFragDataLocation(const std::string &name) const;
 
@@ -338,6 +335,8 @@ class Program : angle::NonCopyable
     Data mData;
     rx::ProgramImpl *mProgram;
 
+    std::vector<sh::Attribute> mLinkedAttributes;
+
     std::map<int, VariableLocation> mOutputVariables;
 
     bool mValidated;

src/libANGLE/renderer/ProgramImpl.cpp

@@ -135,4 +135,26 @@ void ProgramImpl::reset()
     SafeDeleteContainer(mUniformBlocks);
 }
 
+void ProgramImpl::setShaderAttribute(size_t index, const sh::Attribute &attrib)
+{
+    if (mShaderAttributes.size() <= index)
+    {
+        mShaderAttributes.resize(index + 1);
+    }
+    mShaderAttributes[index] = attrib;
+}
+
+void ProgramImpl::setShaderAttribute(size_t index, GLenum type, GLenum precision, const std::string &name, GLint size, int location)
+{
+    if (mShaderAttributes.size() <= index)
+    {
+        mShaderAttributes.resize(index + 1);
+    }
+    mShaderAttributes[index].type = type;
+    mShaderAttributes[index].precision = precision;
+    mShaderAttributes[index].name = name;
+    mShaderAttributes[index].arraySize = size;
+    mShaderAttributes[index].location = location;
+}
+
 }

src/libANGLE/renderer/ProgramImpl.h

@@ -85,6 +85,7 @@ class ProgramImpl : angle::NonCopyable
     const std::vector<gl::LinkedUniform*> &getUniforms() const { return mUniforms; }
     const std::map<GLuint, gl::VariableLocation> &getUniformIndices() const { return mUniformIndex; }
     const std::vector<gl::UniformBlock*> &getUniformBlocks() const { return mUniformBlocks; }
+    const std::vector<sh::Attribute> getShaderAttributes() { return mShaderAttributes; }
     const SemanticIndexArray &getSemanticIndexes() const { return mSemanticIndex; }
 
     std::vector<gl::LinkedUniform*> &getUniforms() { return mUniforms; }
@@ -100,6 +101,9 @@ class ProgramImpl : angle::NonCopyable
     GLuint getUniformIndex(const std::string &name) const;
     GLuint getUniformBlockIndex(const std::string &name) const;
 
+    void setShaderAttribute(size_t index, const sh::Attribute &attrib);
+    void setShaderAttribute(size_t index, GLenum type, GLenum precision, const std::string &name, GLint size, int location);
+
     virtual void reset();
 
   protected:
@@ -113,6 +117,9 @@ class ProgramImpl : angle::NonCopyable
     std::vector<gl::UniformBlock*> mUniformBlocks;
 
     SemanticIndexArray mSemanticIndex;
+
+  private:
+    std::vector<sh::Attribute> mShaderAttributes;
 };
 
 }

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -1003,8 +1003,7 @@ gl::Error ProgramD3D::getVertexExecutableForInputLayout(const gl::InputLayout &i
     }
 
     // Generate new dynamic layout with attribute conversions
-    std::string finalVertexHLSL = mDynamicHLSL->generateVertexShaderForInputLayout(
-        mVertexHLSL, inputLayout, mData.getAttributes());
+    std::string finalVertexHLSL = mDynamicHLSL->generateVertexShaderForInputLayout(mVertexHLSL, inputLayout, getShaderAttributes());
 
     // Generate new vertex executable
     ShaderExecutableD3D *vertexExecutable = NULL;

src/libANGLE/renderer/d3d/ProgramD3D.h

@@ -124,7 +124,6 @@ class ProgramD3D : public ProgramImpl
     void sortAttributesByLayout(const std::vector<TranslatedAttribute> &unsortedAttributes,
                                 int sortedSemanticIndicesOut[gl::MAX_VERTEX_ATTRIBS],
                                 const rx::TranslatedAttribute *sortedAttributesOut[gl::MAX_VERTEX_ATTRIBS]) const;
-    const SemanticIndexArray &getAttributesByLayout() const { return mAttributesByLayout; }
 
     void updateCachedInputLayout(const gl::Program *program, const gl::State &state);
     const gl::InputLayout &getCachedInputLayout() const { return mCachedInputLayout; }
@@ -246,7 +245,7 @@ class ProgramD3D : public ProgramImpl
 
     int mShaderVersion;
 
-    SemanticIndexArray mAttributesByLayout;
+    int mAttributesByLayout[gl::MAX_VERTEX_ATTRIBS];
 
     unsigned int mSerial;
 

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

@@ -46,20 +46,20 @@ gl::InputLayout GetInputLayout(
     return inputLayout;
 }
 
-GLenum GetGLSLAttributeType(const std::vector<sh::Attribute> &shaderAttributes, int index)
+GLenum GetNextGLSLAttributeType(const std::vector<sh::Attribute> &linkedAttributes, int index)
 {
     // Count matrices differently
-    for (const sh::Attribute &attrib : shaderAttributes)
+    int subIndex = 0;
+    for (const sh::Attribute &attrib : linkedAttributes)
     {
-        if (attrib.location == -1)
+        if (attrib.type == GL_NONE)
         {
             continue;
         }
 
         GLenum transposedType = gl::TransposeMatrixType(attrib.type);
-        int rows              = gl::VariableRowCount(transposedType);
-
-        if (index >= attrib.location && index < attrib.location + rows)
+        subIndex += gl::VariableRowCount(transposedType);
+        if (subIndex > index)
         {
             return transposedType;
         }
@@ -185,8 +185,6 @@ gl::Error InputLayoutCache::applyVertexBuffers(const std::vector<TranslatedAttri
     bool instancedPointSpritesActive = programUsesInstancedPointSprites && (mode == GL_POINTS);
     bool indexedPointSpriteEmulationActive = instancedPointSpritesActive && (sourceInfo != nullptr);
 
-    const auto &semanticToLocation = programD3D->getAttributesByLayout();
-
     if (!mDevice || !mDeviceContext)
     {
         return gl::Error(GL_OUT_OF_MEMORY, "Internal input layout cache is not initialized.");
@@ -202,7 +200,7 @@ gl::Error InputLayoutCache::applyVertexBuffers(const std::vector<TranslatedAttri
     unsigned int firstInstancedElement = gl::MAX_VERTEX_ATTRIBS;
     unsigned int nextAvailableInputSlot = 0;
 
-    const std::vector<sh::Attribute> &shaderAttributes = program->getAttributes();
+    const std::vector<sh::Attribute> &linkedAttributes = program->getLinkedAttributes();
 
     for (unsigned int i = 0; i < unsortedAttributes.size(); i++)
     {
@@ -234,8 +232,7 @@ gl::Error InputLayoutCache::applyVertexBuffers(const std::vector<TranslatedAttri
 
             // Record the type of the associated vertex shader vector in our key
             // This will prevent mismatched vertex shaders from using the same input layout
-            GLenum glslElementType = GetGLSLAttributeType(
-                shaderAttributes, semanticToLocation[sortedSemanticIndices[i]]);
+            GLenum glslElementType = GetNextGLSLAttributeType(linkedAttributes, inputElementCount);
 
             layout.addAttributeData(glslElementType,
                                     sortedSemanticIndices[i],

src/libANGLE/renderer/gl/ProgramGL.cpp

@@ -169,33 +169,34 @@ LinkResult ProgramGL::link(const gl::Data &data,
         }
     }
 
-    for (const sh::Attribute &attribute : mData.getAttributes())
-    {
-        if (!attribute.staticUse)
-            continue;
+    // Query the attribute information
+    GLint activeAttributeMaxLength = 0;
+    mFunctions->getProgramiv(mProgramID, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &activeAttributeMaxLength);
 
-        GLint realLocation = mFunctions->getAttribLocation(mProgramID, attribute.name.c_str());
+    std::vector<GLchar> attributeNameBuffer(activeAttributeMaxLength);
 
-        // Some drivers optimize attributes more aggressively.
-        if (realLocation == -1)
-        {
-            continue;
-        }
+    GLint attributeCount = 0;
+    mFunctions->getProgramiv(mProgramID, GL_ACTIVE_ATTRIBUTES, &attributeCount);
+    for (GLint i = 0; i < attributeCount; i++)
+    {
+        GLsizei attributeNameLength = 0;
+        GLint attributeSize = 0;
+        GLenum attributeType = GL_NONE;
+        mFunctions->getActiveAttrib(mProgramID, i, static_cast<GLsizei>(attributeNameBuffer.size()),
+                                    &attributeNameLength, &attributeSize, &attributeType,
+                                    &attributeNameBuffer[0]);
 
-        // TODO(jmadill): Fix this
-        ASSERT(attribute.location == realLocation);
+        std::string attributeName(&attributeNameBuffer[0], attributeNameLength);
 
-        int registerCount = gl::VariableRegisterCount(attribute.type);
+        GLint location = mFunctions->getAttribLocation(mProgramID, attributeName.c_str());
 
-        if (mAttributeRealLocations.size() < attribute.location + registerCount + 1)
-        {
-            mAttributeRealLocations.resize(attribute.location + registerCount + 1, -1);
-        }
+        // TODO: determine attribute precision
+        setShaderAttribute(static_cast<size_t>(i), attributeType, GL_NONE, attributeName, attributeSize, location);
 
-        for (int offset = 0; offset < registerCount; ++offset)
+        int attributeRegisterCount = gl::VariableRegisterCount(attributeType);
+        for (int offset = 0; offset < attributeRegisterCount; offset++)
         {
-            mActiveAttributesMask.set(attribute.location + offset);
-            mAttributeRealLocations[attribute.location + offset] = realLocation + offset;
+            mActiveAttributesMask.set(location + offset);
         }
     }
 
@@ -377,7 +378,6 @@ void ProgramGL::reset()
     mSamplerUniformMap.clear();
     mSamplerBindings.clear();
     mActiveAttributesMask.reset();
-    mAttributeRealLocations.clear();
 }
 
 GLuint ProgramGL::getProgramID() const

src/libANGLE/renderer/gl/ProgramGL.h

@@ -101,9 +101,6 @@ class ProgramGL : public ProgramImpl
     // An array of the samplers that are used by the program
     std::vector<SamplerBindingGL> mSamplerBindings;
 
-    // Map from GL-layer attribute location to native location.
-    std::vector<GLint> mAttributeRealLocations;
-
     // Array of attribute locations used by this program
     gl::AttributesMask mActiveAttributesMask;