Emit separate declarations for struct types

I'm going to add uniform block support shortly and structs can't be
declared inside blocks.

diff --git a/source/programbuilder.cpp b/source/programbuilder.cpp
index 91575d0dfe436b9e1aa794496303db8fa8d71f75..d73cfff48bc2146750b96f5f3d0ab7c6ef59b445 100644 (file)
--- a/source/programbuilder.cpp
+++ b/source/programbuilder.cpp
@@ -1,5 +1,6 @@
 #include <algorithm>
 #include <cstring>
+#include <set>
 #include <msp/strings/format.h>
 #include <msp/strings/utils.h>
 #include "extension.h"
@@ -137,18 +138,21 @@ const ProgramBuilder::VariableDefinition ProgramBuilder::standard_variables[] =
        { UNIFORM, "eye_obj_normal_matrix", "mat3", "gl_NormalMatrix", 0 },
        { UNIFORM, "projection_matrix", "mat4", "gl_ProjectionMatrix", 0 },
        { UNIFORM, "shd_eye_matrix", "mat4", 0, 0 },
-       { UNIFORM, "light_sources", "struct { vec4 position; vec4 diffuse; vec4 specular; }[MAX_LIGHTS]", "gl_LightSource[i]", 0 },
+       { UNIFORM, "light_sources", "LightSourceParameters[MAX_LIGHTS]", "gl_LightSource[i]", 0 },
        { UNIFORM, "ambient_color", "vec4", 0, 0 },
        { UNIFORM, "sky_color", "vec4", 0, 0 },
        { UNIFORM, "eye_sky_dir", "vec3", 0, 0 },
        { UNIFORM, "horizon_limit", "float", 0, 0 },
-       { UNIFORM, "material", "struct { vec4 ambient; vec4 diffuse; vec4 specular; float shininess; }", "gl_FrontMaterial", 0 },
+       { UNIFORM, "material", "MaterialParameters", "gl_FrontMaterial", 0 },
+
+       { TYPE, "LightSourceParameters", "struct { vec4 position; vec4 diffuse; vec4 specular; }", "gl_LightSourceParameters", 0 },
+       { TYPE, "MaterialParameters", "struct { vec4 ambient; vec4 diffuse; vec4 specular; float shininess; }", "gl_MaterialParameters", 0 },
 
        // Terminator entry
        { NO_SCOPE, 0, 0, 0, 0 }
 };
 
-const char ProgramBuilder::interfaces[] = { 0, 0, 0, 'v', 0 };
+const char ProgramBuilder::interfaces[] = { 0, 0, 0, 0, 'v', 0 };
 
 ProgramBuilder::ProgramBuilder(const StandardFeatures &f):
        features(f),
@@ -272,6 +276,15 @@ void ProgramBuilder::add_shaders(Program &prog) const
                                continue;
                }
 
+               if(def->scope==TYPE)
+               {
+                       for(list<ShaderVariable *>::iterator j=resolved_vars.begin(); j!=resolved_vars.end(); ++j)
+                               if(!(*j)->type && name_match(def->name, (*j)->variable->type))
+                                       (*j)->resolve_type(*def);
+
+                       continue;
+               }
+
                // See if this variable can satisfy any unresolved variables
                ShaderVariable *last_resolved = 0;
                for(list<ShaderVariable>::iterator j=variables.begin(); j!=variables.end(); ++j)
@@ -353,9 +366,18 @@ string ProgramBuilder::create_source(const list<ShaderVariable *> &variables, Va
        if(!features.legacy)
                source += "#version 130\n";
 
+       set<const VariableDefinition *> declared_types;
        for(list<ShaderVariable *>::const_iterator i=variables.begin(); i!=variables.end(); ++i)
                if((*i)->variable->scope==UNIFORM && (*i)->is_referenced_from(scope) && !(*i)->inlined)
+               {
+                       if((*i)->type && !declared_types.count((*i)->type))
+                       {
+                               source += format("%s;\n", (*i)->create_type_declaration());
+                               declared_types.insert((*i)->type);
+                       }
+
                        source += format("uniform %s;\n", (*i)->create_declaration());
+               }
 
        /* Interface variables need to have global declarations. */
        for(list<ShaderVariable *>::const_iterator i=variables.begin(); i!=variables.end(); ++i)
@@ -646,6 +668,7 @@ string ProgramBuilder::StandardFeatures::create_flags() const
 ProgramBuilder::ShaderVariable::ShaderVariable(const std::string &n):
        name(n),
        variable(0),
+       type(0),
        resolved_name(n),
        fuzzy_space(name.find("zzz")!=string::npos),
        array_sum(false),
@@ -687,6 +710,11 @@ void ProgramBuilder::ShaderVariable::resolve(ShaderVariable &var)
        var.referenced_by.insert(var.referenced_by.end(), referenced_by.begin(), referenced_by.end());
 }
 
+void ProgramBuilder::ShaderVariable::resolve_type(const VariableDefinition &var)
+{
+       type = &var;
+}
+
 void ProgramBuilder::ShaderVariable::resolve_space(const string &space)
 {
        if(fuzzy_space)
@@ -867,6 +895,21 @@ ProgramBuilder::InterfaceFlags ProgramBuilder::ShaderVariable::get_interface_fla
        return static_cast<InterfaceFlags>(flags);
 }
 
+string ProgramBuilder::ShaderVariable::create_type_declaration() const
+{
+       if(!type)
+               throw logic_error("no type");
+
+       if(!strncmp(type->type, "struct", 6))
+       {
+               const char *brace = strchr(type->type, '{');
+               if(brace)
+                       return format("struct %s %s", type->name, brace);
+       }
+
+       throw invalid_variable_definition("invalid typedef");
+}
+
 string ProgramBuilder::ShaderVariable::create_declaration(char interface, bool loop) const
 {
        if(variable->scope==UNIFORM && !array_subscript.empty())

diff --git a/source/programbuilder.h b/source/programbuilder.h
index 0883f6a74fd07a6479dc1b01fa62424882455042..1f9bb846aa0b5729a0ffb3583d5d3e939861b2c1 100644 (file)
--- a/source/programbuilder.h
+++ b/source/programbuilder.h
@@ -56,6 +56,7 @@ private:
        enum VariableScope
        {
                NO_SCOPE,
+               TYPE,
                UNIFORM,
                ATTRIBUTE,
                VERTEX,
@@ -84,6 +85,7 @@ private:
        {
                std::string name;
                const VariableDefinition *variable;
+               const VariableDefinition *type;
                std::string resolved_name;
                bool fuzzy_space;
                std::string resolved_space;
@@ -100,6 +102,7 @@ private:
 
                void resolve(const VariableDefinition &);
                void resolve(ShaderVariable &);
+               void resolve_type(const VariableDefinition &);
                void resolve_space(const std::string &);
                void resolve_array(const StandardFeatures &, unsigned = 0);
                void add_reference(ShaderVariable &);
@@ -107,6 +110,7 @@ private:
                void check_inline(bool, bool);
                bool is_referenced_from(VariableScope) const;
                InterfaceFlags get_interface_flags(VariableScope) const;
+               std::string create_type_declaration() const;
                std::string create_declaration(char = 0, bool = false) const;
                std::string create_replacement(VariableScope, const char * = 0) const;
                std::string create_expression(const char * = 0) const;