Consistently use the same spelling for diffuse_map and normal_map

[libs/gl.git] / source / programbuilder.cpp

diff --git a/source/programbuilder.cpp b/source/programbuilder.cpp
index f8c3973f8b8feba30da190196a588d7a62b711ca..829691b61c8fbd8929262fe8a5da6e6404e167ef 100644 (file)
--- a/source/programbuilder.cpp
+++ b/source/programbuilder.cpp
@@ -106,8 +106,8 @@ const ProgramBuilder::VariableDefinition ProgramBuilder::standard_variables[] =
        { FRAGMENT, "n_zzz_light_dir[i]", "vec3", "normalize(zzz_light_dir[i])", 0 },
        { FRAGMENT, "n_tbn_normal", "vec3", "normal_sample*2.0-1.0", "n" },
        { FRAGMENT, "n_eye_normal", "vec3", "normalize(eye_normal)", "!n" },
-       { FRAGMENT, "normal_sample", "vec3", "texture2D(normalmap, texture_coord).xyz", 0 },
-       { FRAGMENT, "diffuse_sample", "vec4", "texture2D(diffusemap, texture_coord)", 0 },
+       { FRAGMENT, "normal_sample", "vec3", "texture2D(normal_map, texture_coord).xyz", 0 },
+       { FRAGMENT, "diffuse_sample", "vec4", "texture2D(diffuse_map, texture_coord)", 0 },
 
        { VERTEX, "gl_Position", "vec4", "projection_matrix*eye_vertex", 0 },
        { VERTEX, "gl_ClipDistance[i]", "float", "dot(eye_vertex, clip_planes[i].equation)", "c" },
@@ -133,10 +133,10 @@ const ProgramBuilder::VariableDefinition ProgramBuilder::standard_variables[] =
        { ATTRIBUTE, "tangent", "vec3", 0, 0 },
        { ATTRIBUTE, "binormal", "vec3", 0, 0 },
 
-       { UNIFORM, "diffusemap", "sampler2D", 0, 0 },
+       { UNIFORM, "diffuse_map", "sampler2D", 0, 0 },
        { UNIFORM, "shadow", "sampler2DShadow", 0, 0 },
        { UNIFORM, "ShadowMap::shadow_darkness", "float", 0, 0 },
-       { UNIFORM, "normalmap", "sampler2D", 0, 0 },
+       { UNIFORM, "normal_map", "sampler2D", 0, 0 },
        { UNIFORM, "environment", "samplerCube", 0, 0 },
        { UNIFORM, "EnvMap::env_eye_matrix", "mat3", 0, 0 },
        { UNIFORM, "Material::reflectivity", "float", 0, 0 },
@@ -162,7 +162,7 @@ const ProgramBuilder::VariableDefinition ProgramBuilder::standard_variables[] =
        { NO_SCOPE, 0, 0, 0, 0 }
 };
 
-const char ProgramBuilder::interfaces[] = { 0, 0, 0, 0, 'v', 0 };
+const char ProgramBuilder::interfaces[] = { 0, 0, 0, 0, 0, 'v', 0 };
 
 ProgramBuilder::ProgramBuilder(const StandardFeatures &f):
        features(f),
@@ -211,6 +211,8 @@ ProgramBuilder::ProgramBuilder(const StandardFeatures &f):
                                                var.scope = VERTEX;
                                        else if(!strcmp(word, "fragment"))
                                                var.scope = FRAGMENT;
+                                       else if(!strcmp(word, "function"))
+                                               var.scope = FUNCTION;
                                        else
                                                throw invalid_variable_definition(word);
                                }
@@ -220,18 +222,29 @@ ProgramBuilder::ProgramBuilder(const StandardFeatures &f):
                                        var.name = word;
 
                                start = features.custom.find_first_not_of(whitespace, word_end+1);
-                               if(start>=decl_end)
+                               if(start>=decl_end || (var.scope==FUNCTION && features.custom[start]=='('))
                                        break;
                        }
 
                        if(equals!=string::npos)
                        {
+                               if(var.scope==FUNCTION)
+                                       throw invalid_variable_definition("function with expression");
                                start = features.custom.find_first_not_of(whitespace, equals+1);
                                if(start>=semicolon)
                                        throw invalid_variable_definition("no expression");
                                features.custom[semicolon] = 0;
                                var.expression = &features.custom[start];
                        }
+                       else if(var.scope==FUNCTION)
+                       {
+                               string::size_type left_paren = features.custom.find('(', start);
+                               string::size_type right_paren = features.custom.find(')', start);
+                               if(left_paren>semicolon || right_paren>semicolon)
+                                       throw invalid_variable_definition("no argument list");
+                               features.custom[right_paren] = 0;
+                               var.expression = &features.custom[left_paren+1];
+                       }
                        else
                                var.expression = 0;
 
@@ -378,10 +391,10 @@ void ProgramBuilder::add_shaders(Program &prog) const
                        prog.bind_attribute(NORMAL3, "normal");
                else if(features.material)
                        prog.bind_attribute(COLOR4_FLOAT, "color");
-               if(features.texture || features.normalmap)
+               if(features.texture || features.normal_map)
                        prog.bind_attribute(TEXCOORD4, "texcoord");
        }
-       if(features.normalmap)
+       if(features.normal_map)
        {
                prog.bind_attribute(get_component_type(TANGENT3), "tangent");
                prog.bind_attribute(get_component_type(BINORMAL3), "binormal");
@@ -415,7 +428,13 @@ string ProgramBuilder::create_source(const list<ShaderVariable *> &variables, Va
        set<const VariableDefinition *> declared_types;
        set<string> uniform_blocks;
        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)->is_referenced_from(scope))
+                       continue;
+
+               if((*i)->variable->scope==FUNCTION)
+                       source += format("%s;\n", (*i)->create_declaration());
+               else if((*i)->variable->scope==UNIFORM && !(*i)->inlined)
                {
                        if((*i)->type && !declared_types.count((*i)->type))
                        {
@@ -428,6 +447,7 @@ string ProgramBuilder::create_source(const list<ShaderVariable *> &variables, Va
                        else
                                source += format("uniform %s;\n", (*i)->create_declaration());
                }
+       }
 
        for(set<string>::const_iterator i=uniform_blocks.begin(); i!=uniform_blocks.end(); ++i)
        {
@@ -738,7 +758,7 @@ ProgramBuilder::StandardFeatures::StandardFeatures():
        skylight(false),
        fog(false),
        specular(false),
-       normalmap(false),
+       normal_map(false),
        shadow(false),
        reflection(false),
        clipping(false),
@@ -764,7 +784,7 @@ string ProgramBuilder::StandardFeatures::create_flags() const
                        flags += 'y';
                if(specular)
                        flags += 'p';
-               if(normalmap)
+               if(normal_map)
                        flags += 'n';
        }
        if(fog)
@@ -921,7 +941,7 @@ void ProgramBuilder::ShaderVariable::update_reference(ShaderVariable &from, Shad
 
 void ProgramBuilder::ShaderVariable::check_inline(bool allow_legacy, bool trivial_only)
 {
-       if(variable->expression)
+       if(variable->expression && variable->scope>=UNIFORM)
        {
                if(array_sum && array_size>1)
                        return;
@@ -995,7 +1015,7 @@ ProgramBuilder::InterfaceFlags ProgramBuilder::ShaderVariable::get_interface_fla
 {
        /* Uniforms are available to all stages and are not passed through
        interfaces */
-       if(variable->scope==UNIFORM)
+       if(variable->scope<=UNIFORM)
                return NO_INTERFACE;
 
        int flags = NO_INTERFACE;
@@ -1035,6 +1055,9 @@ string ProgramBuilder::ShaderVariable::create_type_declaration() const
 
 string ProgramBuilder::ShaderVariable::create_declaration(char iface, bool loop) const
 {
+       if(variable->scope==FUNCTION)
+               return format("%s %s(%s)", variable->type, resolved_name, variable->expression);
+
        if(variable->scope==UNIFORM && !array_subscript.empty())
        {
                const char *bracket = strrchr(variable->type, '[');
@@ -1102,17 +1125,22 @@ string ProgramBuilder::ShaderVariable::create_expression(const char *loop) const
 ProgramBuilder::StandardFeatures::Loader::Loader(StandardFeatures &f):
        DataFile::ObjectLoader<StandardFeatures>(f)
 {
+       add("clipping",  &StandardFeatures::clipping);
        add("custom",    &StandardFeatures::custom);
        add("fog",       &StandardFeatures::fog);
        add("lighting",  &StandardFeatures::lighting);
        add("material",  &StandardFeatures::material);
+       add("max_clip_planes", &StandardFeatures::max_clip_planes);
        add("max_lights", &StandardFeatures::max_lights);
-       add("normalmap", &StandardFeatures::normalmap);
+       add("normal_map", &StandardFeatures::normal_map);
        add("reflection", &StandardFeatures::reflection);
        add("shadow",    &StandardFeatures::shadow);
        add("skylight",  &StandardFeatures::skylight);
        add("specular",  &StandardFeatures::specular);
        add("texture",   &StandardFeatures::texture);
+
+       // Deprecated
+       add("normalmap", &StandardFeatures::normal_map);
 }
 
 } // namespace GL