Merge pull request #288 from thp/attribute-reflection

Reflection: Add support for querying vertex attributes in reflection API

Test/baseResults/reflection.vert.out

@@ -95,3 +95,10 @@ abl2[1]: offset -1, type ffffffff, size 4, index -1
 abl2[2]: offset -1, type ffffffff, size 4, index -1
 abl2[3]: offset -1, type ffffffff, size 4, index -1
 
+Vertex attribute reflection:
+attributeFloat: offset 0, type 1406, size 0, index 0
+attributeFloat2: offset 0, type 8b50, size 0, index 0
+attributeFloat3: offset 0, type 8b51, size 0, index 0
+attributeFloat4: offset 0, type 8b52, size 0, index 0
+attributeMat4: offset 0, type 8b5c, size 0, index 0
+

Test/reflection.vert

@@ -94,6 +94,12 @@ struct deep3 {
     ivec3 v3;
 };
 
+in float attributeFloat;
+layout(location = 2) in vec2 attributeFloat2;
+in vec3 attributeFloat3;
+in vec4 attributeFloat4;
+in mat4 attributeMat4;
+
 uniform deep3 deepA[2], deepB[2], deepC[3], deepD[2];
 
 const bool control = true;
@@ -167,4 +173,10 @@ void main()
 
     f += arrBl[2].foo + arrBl[0].foo;
     f += arrBl2[i].foo;
+
+    f += attributeFloat;
+    f += attributeFloat2.x;
+    f += attributeFloat3.x;
+    f += attributeFloat4.x;
+    f += attributeMat4[0][1];
 }

glslang/MachineIndependent/ShaderLang.cpp

@@ -1572,6 +1572,9 @@ int TProgram::getUniformBlockIndex(int index)        { return reflection->getUni
 int TProgram::getUniformType(int index)              { return reflection->getUniform(index).glDefineType; }
 int TProgram::getUniformBufferOffset(int index)      { return reflection->getUniform(index).offset; }
 int TProgram::getUniformArraySize(int index)         { return reflection->getUniform(index).size; }
+int TProgram::getNumLiveAttributes()                 { return reflection->getNumAttributes(); }
+const char* TProgram::getAttributeName(int index)    { return reflection->getAttribute(index).name.c_str(); }
+int TProgram::getAttributeType(int index)            { return reflection->getAttribute(index).glDefineType; }
 
 void TProgram::dumpReflection()                      { reflection->dump(); }
 

glslang/MachineIndependent/reflection.cpp

@@ -108,6 +108,22 @@ public:
         }
     }
 
+    void addAttribute(const TIntermSymbol& base)
+    {
+        if (processedDerefs.find(&base) == processedDerefs.end()) {
+            processedDerefs.insert(&base);
+
+            const TString &name = base.getName();
+            const TType &type = base.getType();
+
+            TReflection::TNameToIndex::const_iterator it = reflection.nameToIndex.find(name);
+            if (it == reflection.nameToIndex.end()) {
+                reflection.nameToIndex[name] = (int)reflection.indexToAttribute.size();
+                reflection.indexToAttribute.push_back(TObjectReflection(name, 0, mapToGlType(type), 0, 0));
+            }
+        }
+    }
+
     // Lookup or calculate the offset of a block member, using the recursively
     // defined block offset rules.
     int getOffset(const TType& type, int index)
@@ -671,6 +687,9 @@ void TLiveTraverser::visitSymbol(TIntermSymbol* base)
 {
     if (base->getQualifier().storage == EvqUniform)
         addUniform(*base);
+
+    if (intermediate.getStage() == EShLangVertex && base->getQualifier().isPipeInput())
+        addAttribute(*base);
 }
 
 // To prune semantically dead paths.
@@ -728,6 +747,11 @@ void TReflection::dump()
         indexToUniformBlock[i].dump();
     printf("\n");
 
+    printf("Vertex attribute reflection:\n");
+    for (size_t i = 0; i < indexToAttribute.size(); ++i)
+        indexToAttribute[i].dump();
+    printf("\n");
+
     //printf("Live names\n");
     //for (TNameToIndex::const_iterator it = nameToIndex.begin(); it != nameToIndex.end(); ++it)
     //    printf("%s: %d\n", it->first.c_str(), it->second);

glslang/MachineIndependent/reflection.h

@@ -93,7 +93,17 @@ public:
             return badReflection;
     }
 
-    // for mapping any name to its index (both block names and uniforms names)
+    // for mapping an attribute index to the attribute's description
+    int getNumAttributes() { return (int)indexToAttribute.size(); }
+    const TObjectReflection& getAttribute(int i) const
+    {
+        if (i >= 0 && i < (int)indexToAttribute.size())
+            return indexToAttribute[i];
+        else
+            return badReflection;
+    }
+
+    // for mapping any name to its index (block names, uniform names and attribute names)
     int getIndex(const char* name) const 
     {
         TNameToIndex::const_iterator it = nameToIndex.find(name);
@@ -116,6 +126,7 @@ protected:
     TNameToIndex nameToIndex;        // maps names to indexes; can hold all types of data: uniform/buffer and which function names have been processed
     TMapIndexToReflection indexToUniform;
     TMapIndexToReflection indexToUniformBlock;
+    TMapIndexToReflection indexToAttribute;
 };
 
 } // end namespace glslang

glslang/Public/ShaderLang.h

@@ -461,6 +461,9 @@ public:
     int getUniformType(int index);                   // can be used for glGetActiveUniformsiv(GL_UNIFORM_TYPE)
     int getUniformBufferOffset(int index);           // can be used for glGetActiveUniformsiv(GL_UNIFORM_OFFSET)
     int getUniformArraySize(int index);              // can be used for glGetActiveUniformsiv(GL_UNIFORM_SIZE)
+    int getNumLiveAttributes();                      // can be used for glGetProgramiv(GL_ACTIVE_ATTRIBUTES)
+    const char *getAttributeName(int index);         // can be used for glGetActiveAttrib()
+    int getAttributeType(int index);                 // can be used for glGetActiveAttrib()
     void dumpReflection();
 
 protected: