Support generating modern, GLSL 1.30+ shaders with ProgramBuilder

diff --git a/source/programbuilder.cpp b/source/programbuilder.cpp
index 30457838e89bae1270ff3648a79250624a82d69e..88183bccf9b6094880b9532f7aa36c6af8d84301 100644 (file)
--- a/source/programbuilder.cpp
+++ b/source/programbuilder.cpp
@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <cstring>
 #include <msp/strings/format.h>
 #include "program.h"
 #include "programbuilder.h"
@@ -39,25 +40,32 @@ Naming conventions:
 anything that might need them. */
 const ProgramBuilder::StandardVariable ProgramBuilder::standard_variables[] =
 {
-       { FRAGMENT, "gl_FragColor", 0, "color_base", "!t" },
-       { FRAGMENT, "gl_FragColor", 0, "tex_sample", "!l!s!mt" },
-       { FRAGMENT, "gl_FragColor", 0, "tex_sample*color_base", "l|s|mt" },
+       { FRAGMENT, "gl_FragColor", 0, "frag_color", "g" },
+       { FRAGMENT, "frag_color", 0, "color_base", "!t" },
+       { FRAGMENT, "frag_color", 0, "tex_sample", "!l!s!mt" },
+       { FRAGMENT, "frag_color", 0, "tex_sample*color_base", "l|s|mt" },
        { FRAGMENT, "color_base", "vec4", "vec4(1.0)", "!l!s!m" },
        { FRAGMENT, "color_base", "vec4", "color", "!l!sm" },
        { FRAGMENT, "color_base", "vec4", "vec4(vec3(l_shadow), 1.0)", "!ls!m" },
        { FRAGMENT, "color_base", "vec4", "color*vec4(vec3(l_shadow), 1.0)", "!lsm" },
        { FRAGMENT, "color_base", "vec4", "vec4(rgb_light_env, 1.0)", "l!m" },
-       { FRAGMENT, "color_base", "vec4", "vec4(rgb_light_env, gl_FrontMaterial.diffuse.a)", "lm" },
+       { FRAGMENT, "color_base", "vec4", "vec4(rgb_light_env, material.diffuse.a)", "lm" },
        { FRAGMENT, "rgb_light_env", "vec3", "rgb_light_full+reflect_sample.rgb*reflectivity", "e" },
        { FRAGMENT, "rgb_light_env", "vec3", "rgb_light_full", "!e" },
-       { FRAGMENT, "rgb_light_full", "vec3", "rgb_light_shadow+gl_FrontLightModelProduct.sceneColor.rgb", "m" },
+       { FRAGMENT, "rgb_light_full", "vec3", "rgb_light_shadow+ambient_product_diffuse.rgb", "m" },
+       { FRAGMENT, "ambient_product_diffuse", "vec4", "gl_FrontLightModelProduct.sceneColor", "g" },
+       { FRAGMENT, "ambient_product_diffuse", "vec4", "ambient_color*material.diffuse", "!g" },
        { FRAGMENT, "rgb_light_full", "vec3", "rgb_light_shadow", "!m" },
        { FRAGMENT, "rgb_light_shadow", "vec3", "rgb_light*l_shadow", "s" },
        { FRAGMENT, "rgb_light_shadow", "vec3", "rgb_light", "!s" },
        { FRAGMENT, "rgb_light", "vec3", "vec3(l_diffuse)", "!m!p" },
        { FRAGMENT, "rgb_light", "vec3", "vec3(l_diffuse+l_specular)", "!mp" },
-       { FRAGMENT, "rgb_light", "vec3", "l_diffuse*gl_FrontLightProduct[0].diffuse.rgb", "m!p" },
-       { FRAGMENT, "rgb_light", "vec3", "l_diffuse*gl_FrontLightProduct[0].diffuse.rgb+l_specular*gl_FrontLightProduct[0].specular.rgb", "mp" },
+       { FRAGMENT, "rgb_light", "vec3", "l_diffuse*light_product_diffuse.rgb", "m!p" },
+       { FRAGMENT, "rgb_light", "vec3", "l_diffuse*light_product_diffuse.rgb+l_specular*light_product_specular.rgb", "mp" },
+       { FRAGMENT, "light_product_diffuse", "vec4", "gl_FrontLightProduct[0].diffuse", "g" },
+       { FRAGMENT, "light_product_diffuse", "vec4", "light_sources[0].diffuse*material.diffuse", "!g" },
+       { FRAGMENT, "light_product_specular", "vec4", "gl_FrontLightProduct[0].specular", "g" },
+       { FRAGMENT, "light_product_specular", "vec4", "light_sources[0].specular*material.specular", "!g" },
        { FRAGMENT, "reflect_sample", "vec4", "textureCube(environment, env_reflect_dir)", 0 },
        { FRAGMENT, "env_reflect_dir", "vec3", "env_eye_matrix*eye_reflect_dir", 0 },
        { FRAGMENT, "eye_reflect_dir", "vec3", "eye_tbn_matrix*tbn_reflect_dir", "n" },
@@ -65,7 +73,7 @@ const ProgramBuilder::StandardVariable ProgramBuilder::standard_variables[] =
        { FRAGMENT, "l_shadow", "float", "mix(1.0, shadow_sample, shadow_darkness)", 0 },
        { FRAGMENT, "shadow_sample", "float", "shadow2D(shadow, shd_vertex).r", 0 },
        { FRAGMENT, "l_diffuse", "float", "max(dot(n_zzz_normal, n_zzz_light_dir), 0.0)", 0 },
-       { FRAGMENT, "l_specular", "float", "pow(max(dot(n_zzz_half_vec, n_zzz_normal), 0.0), gl_FrontMaterial.shininess)", 0 },
+       { FRAGMENT, "l_specular", "float", "pow(max(dot(n_zzz_half_vec, n_zzz_normal), 0.0), material.shininess)", 0 },
        { FRAGMENT, "n_zzz_half_vec", "vec3", "normalize(zzz_light_dir-zzz_incident_dir)", 0 },
        { FRAGMENT, "n_zzz_light_dir", "vec3", "normalize(zzz_light_dir)", 0 },
        { FRAGMENT, "n_tbn_normal", "vec3", "normal_sample*2.0-1.0", "n" },
@@ -75,25 +83,29 @@ const ProgramBuilder::StandardVariable ProgramBuilder::standard_variables[] =
        { FRAGMENT, "tex_sample", "vec4", "texture2D(texture, texture_coord)", "!c" },
        { FRAGMENT, "tex_sample", "vec4", "sample_texture(texture_coord)", "c" },
 
-       { VERTEX, "gl_Position", 0, "gl_ProjectionMatrix*eye_vertex", 0 },
-       { VERTEX, "shd_vertex", "vec3", "(eye_vertex*eye_shd_rmatrix).xyz", 0 },
-       { VERTEX, "eye_shd_rmatrix", "mat4", "mat4(gl_EyePlaneS[shadow_unit], gl_EyePlaneT[shadow_unit], gl_EyePlaneR[shadow_unit], vec4(0.0, 0.0, 0.0, 1.0))", 0 },
+       { VERTEX, "gl_Position", 0, "projection_matrix*eye_vertex", 0 },
+       { VERTEX, "shd_vertex", "vec3", "vec3(dot(eye_vertex, gl_EyePlaneS[shadow_unit]), dot(eye_vertex, gl_EyePlaneT[shadow_unit]), dot(eye_vertex, gl_EyePlaneR[shadow_unit]))", "g" },
+       { VERTEX, "shd_vertex", "vec3", "(shd_eye_matrix*eye_vertex).xyz", "!g" },
        { VERTEX, "tbn_light_dir", "vec3", "eye_light_dir*eye_tbn_matrix", 0 },
-       { VERTEX, "eye_light_dir", "vec3", "normalize(gl_LightSource[0].position.xyz-eye_vertex.xyz*gl_LightSource[0].position.w)", 0 },
+       { VERTEX, "eye_light_dir", "vec3", "normalize(eye_light_position.xyz-eye_vertex.xyz*eye_light_position.w)", 0 },
+       { VERTEX, "eye_light_position", "vec4", "light_sources[0].position", 0 },
        { VERTEX, "tbn_incident_dir", "vec3", "eye_incident_dir*eye_tbn_matrix", 0 },
        { VERTEX, "eye_incident_dir", "vec3", "normalize(eye_vertex.xyz)", 0 },
        { VERTEX, "eye_tbn_matrix", "mat3", "mat3(eye_tangent, eye_binormal, eye_normal)", 0 },
-       { VERTEX, "eye_vertex", "vec4", "gl_ModelViewMatrix*gl_Vertex", "!r" },
-       { VERTEX, "eye_vertex", "vec4", "transform_vertex(gl_Vertex)", "r" },
-       { VERTEX, "eye_normal", "vec3", "gl_NormalMatrix*gl_Normal", "!r" },
-       { VERTEX, "eye_normal", "vec3", "transform_normal(gl_Normal)", "r" },
-       { VERTEX, "eye_tangent", "vec3", "gl_NormalMatrix*tangent", "!r" },
+       { VERTEX, "eye_vertex", "vec4", "eye_obj_matrix*vertex", "!r" },
+       { VERTEX, "eye_vertex", "vec4", "transform_vertex(vertex)", "r" },
+       { VERTEX, "eye_normal", "vec3", "eye_obj_normal_matrix*normal", "!r" },
+       { VERTEX, "eye_normal", "vec3", "transform_normal(normal)", "r" },
+       { VERTEX, "eye_tangent", "vec3", "eye_obj_normal_matrix*tangent", "!r" },
        { VERTEX, "eye_tangent", "vec3", "transform_normal(tangent)", "r" },
-       { VERTEX, "eye_binormal", "vec3", "gl_NormalMatrix*binormal", "!r" },
+       { VERTEX, "eye_binormal", "vec3", "eye_obj_normal_matrix*binormal", "!r" },
        { VERTEX, "eye_binormal", "vec3", "transform_normal(binormal)", "r" },
-       { VERTEX, "color", "vec4", "gl_Color", 0 },
-       { VERTEX, "texture_coord", "vec2", "gl_MultiTexCoord0.xy", 0 },
+       { VERTEX, "texture_coord", "vec2", "texcoord.xy", 0 },
 
+       { ATTRIBUTE, "vertex", "vec4", "gl_Vertex", 0 },
+       { ATTRIBUTE, "texcoord", "vec4", "gl_MultiTexCoord0", 0 },
+       { ATTRIBUTE, "color", "vec4", "gl_Color", 0 },
+       { ATTRIBUTE, "normal", "vec3", "gl_Normal", 0 },
        { ATTRIBUTE, "tangent", "vec3", 0, 0 },
        { ATTRIBUTE, "binormal", "vec3", 0, 0 },
 
@@ -105,6 +117,13 @@ const ProgramBuilder::StandardVariable ProgramBuilder::standard_variables[] =
        { UNIFORM, "environment", "samplerCube", 0, 0 },
        { UNIFORM, "env_eye_matrix", "mat3", 0, 0 },
        { UNIFORM, "reflectivity", "float", 0, 0 },
+       { UNIFORM, "eye_obj_matrix", "mat4", "gl_ModelViewMatrix", 0 },
+       { UNIFORM, "eye_obj_normal_matrix", "mat3", "gl_NormalMatrix", 0 },
+       { UNIFORM, "projection_matrix", "mat4", "gl_ProjectionMatrix", 0 },
+       { UNIFORM, "shd_eye_matrix", "mat4", 0, "!g" },
+       { UNIFORM, "light_sources", "struct { vec4 position; vec4 diffuse; vec4 specular; } %s[2]", "gl_LightSource", 0 },
+       { UNIFORM, "ambient_color", "vec4", 0, 0 },
+       { UNIFORM, "material", "struct { vec4 ambient; vec4 diffuse; vec4 specular; float shininess; }", "gl_FrontMaterial", 0 },
 
        // Terminator entry
        { NO_SCOPE,  0, 0, 0, 0 }
@@ -134,7 +153,7 @@ void ProgramBuilder::add_shaders(Program &prog) const
        list<ShaderVariable *> resolved_vars;
 
        variables.push_front(ShaderVariable("gl_Position"));
-       variables.push_front(ShaderVariable("gl_FragColor"));
+       variables.push_front(ShaderVariable(features.legacy ? "gl_FragColor" : "frag_color"));
 
        for(const StandardVariable *i=standard_variables; i->name; ++i)
        {
@@ -191,12 +210,23 @@ void ProgramBuilder::add_shaders(Program &prog) const
        if(optimize)
        {
                for(list<ShaderVariable *>::const_iterator i=resolved_vars.begin(); i!=resolved_vars.end(); ++i)
-                       (*i)->check_inline();
+                       (*i)->check_inline(features.legacy);
        }
 
        prog.attach_shader_owned(new VertexShader(create_source(resolved_vars, VERTEX)));
        prog.attach_shader_owned(new FragmentShader(create_source(resolved_vars, FRAGMENT)));
 
+       if(!features.legacy)
+       {
+               prog.bind_fragment_data(0, "frag_color");
+               prog.bind_attribute(get_component_type(VERTEX4), "vertex");
+               if(features.lighting)
+                       prog.bind_attribute(get_component_type(NORMAL3), "normal");
+               else if(features.material)
+                       prog.bind_attribute(get_component_type(COLOR4_FLOAT), "color");
+               if(features.texture || features.normalmap)
+                       prog.bind_attribute(get_component_type(TEXCOORD4), "texcoord");
+       }
        if(features.normalmap)
        {
                prog.bind_attribute(get_component_type(TANGENT3), "tangent");
@@ -208,27 +238,44 @@ string ProgramBuilder::create_source(const list<ShaderVariable *> &variables, Va
 {
        string source;
 
+       if(!features.legacy)
+               source += "#version 130\n";
+
        for(list<ShaderVariable *>::const_iterator i=variables.begin(); i!=variables.end(); ++i)
-               if((*i)->variable->scope==UNIFORM && (*i)->is_referenced_from(scope))
-                       source += format("uniform %s %s;\n", (*i)->variable->type, (*i)->resolved_name);
+               if((*i)->variable->scope==UNIFORM && (*i)->is_referenced_from(scope) && !(*i)->inlined)
+               {
+                       if(strchr((*i)->variable->type, '%'))
+                               source += format("uniform %s;\n", format((*i)->variable->type, (*i)->resolved_name));
+                       else
+                               source += format("uniform %s %s;\n", (*i)->variable->type, (*i)->resolved_name);
+               }
 
        if(scope==VERTEX)
        {
+               const char *qualifier = (features.legacy ? "attribute" : "in");
                for(list<ShaderVariable *>::const_iterator i=variables.begin(); i!=variables.end(); ++i)
-                       if((*i)->variable->scope==ATTRIBUTE)
-                               source += format("attribute %s %s;\n", (*i)->variable->type, (*i)->resolved_name);
+                       if((*i)->variable->scope==ATTRIBUTE && !(*i)->inlined)
+                               source += format("%s %s %s;\n", qualifier, (*i)->variable->type, (*i)->resolved_name);
        }
 
        /* Any variables defined in vertex scope but referenced from fragment scope
        should be exported as varyings over the interface. */
        list<ShaderVariable *> varyings;
        for(list<ShaderVariable *>::const_iterator i=variables.begin(); i!=variables.end(); ++i)
-               if((*i)->variable->scope==VERTEX && (*i)->is_referenced_from(FRAGMENT))
+               if(((*i)->variable->scope==VERTEX || (*i)->variable->scope==ATTRIBUTE) && (*i)->is_referenced_from(FRAGMENT))
                {
                        varyings.push_back(*i);
-                       source += format("varying %s v_%s;\n", (*i)->variable->type, (*i)->resolved_name);
+                       const char *qualifier;
+                       if(!features.legacy)
+                               qualifier = (scope==VERTEX ? "out" : "in");
+                       else
+                               qualifier = "varying";
+                       source += format("%s %s v_%s;\n", qualifier, (*i)->variable->type, (*i)->resolved_name);
                }
 
+       if(scope==FRAGMENT && !features.legacy)
+               source += "out vec4 frag_color;\n";
+
        if(scope==VERTEX && features.transform)
        {
                // Add the prototypes here, until I come up with something better
@@ -416,7 +463,8 @@ ProgramBuilder::StandardFeatures::StandardFeatures():
        shadow(false),
        reflection(false),
        transform(false),
-       colorify(false)
+       colorify(false),
+       legacy(!(get_glsl_version()>=Version(1, 30)))
 { }
 
 string ProgramBuilder::StandardFeatures::create_flags() const
@@ -442,6 +490,8 @@ string ProgramBuilder::StandardFeatures::create_flags() const
                flags += 'r';
        if(colorify)
                flags += 'c';
+       if(legacy)
+               flags += 'g';
 
        return flags;
 }
@@ -507,10 +557,13 @@ void ProgramBuilder::ShaderVariable::update_reference(ShaderVariable &from, Shad
                resolve_space(to.resolved_space);
 }
 
-void ProgramBuilder::ShaderVariable::check_inline()
+void ProgramBuilder::ShaderVariable::check_inline(bool allow_legacy)
 {
        if(variable->expression)
        {
+               if(!allow_legacy && !strncmp(variable->expression, "gl_", 3))
+                       return;
+
                unsigned total_refs = referenced_by.size();
                unsigned in_scope_refs = 0;
                for(list<ShaderVariable *>::const_iterator i=referenced_by.begin(); i!=referenced_by.end(); ++i)
@@ -548,7 +601,7 @@ string ProgramBuilder::ShaderVariable::get_expression() const
                if((*i)->variable)
                {
                        string replacement = (*i)->resolved_name;
-                       if(variable->scope==FRAGMENT && (*i)->variable->scope==VERTEX)
+                       if(variable->scope==FRAGMENT && ((*i)->variable->scope==VERTEX || (*i)->variable->scope==ATTRIBUTE))
                                replacement = "v_"+replacement;
                        else if((*i)->inlined)
                        {

diff --git a/source/programbuilder.h b/source/programbuilder.h
index a6eb3fde8522dc097b19032c972cab399c078685..6845f4a9450590b7ab5c01e37b3ab99fbd886086 100644 (file)
--- a/source/programbuilder.h
+++ b/source/programbuilder.h
@@ -31,6 +31,7 @@ public:
                bool reflection;
                bool transform;
                bool colorify;
+               bool legacy;
 
                StandardFeatures();
 
@@ -75,7 +76,7 @@ private:
                void resolve_space(const std::string &);
                void add_reference(ShaderVariable &);
                void update_reference(ShaderVariable &, ShaderVariable &);
-               void check_inline();
+               void check_inline(bool);
                bool is_referenced_from(VariableScope) const;
                std::string get_expression() const;
        };