Add loader support for clipping in standard shaders

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

diff --git a/source/programbuilder.cpp b/source/programbuilder.cpp
index 002e3a275f7ef7e1c7eaa05e08e277d9106da734..5379abf2cc289162fb843341c7315759d039431f 100644 (file)
--- a/source/programbuilder.cpp
+++ b/source/programbuilder.cpp
@@ -45,9 +45,13 @@ anything that might need them. */
 const ProgramBuilder::VariableDefinition ProgramBuilder::standard_variables[] =
 {
        { FRAGMENT, "gl_FragColor", "vec4", "frag_color", 0 },
-       { FRAGMENT, "frag_color", "vec4", "basic_color", "!e!l" },
-       { FRAGMENT, "frag_color", "vec4", "vec4(rgb_surface, surface_alpha)", "!el" },
-       { FRAGMENT, "frag_color", "vec4", "vec4(rgb_surface+rgb_reflection, surface_alpha)", "e" },
+       { FRAGMENT, "frag_color", "vec4", "incoming_color", "!f" },
+       { FRAGMENT, "frag_color", "vec4", "vec4(mix(fog_color.rgb, incoming_color.rgb, fog_value), incoming_color.a)", "f" },
+       { FRAGMENT, "fog_value", "float", "exp(-fog_coord*fog_density)", 0 },
+
+       { FRAGMENT, "incoming_color", "vec4", "basic_color", "!e!l" },
+       { FRAGMENT, "incoming_color", "vec4", "vec4(rgb_surface, surface_alpha)", "!el" },
+       { FRAGMENT, "incoming_color", "vec4", "vec4(rgb_surface+rgb_reflection, surface_alpha)", "e" },
 
        { FRAGMENT, "rgb_reflection", "vec3", "reflect_sample.rgb*reflectivity", 0 },
        { FRAGMENT, "reflect_sample", "vec4", "textureCube(environment, env_reflect_dir)", 0 },
@@ -106,6 +110,8 @@ const ProgramBuilder::VariableDefinition ProgramBuilder::standard_variables[] =
        { FRAGMENT, "diffuse_sample", "vec4", "texture2D(diffusemap, 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" },
+       { VERTEX, "fog_coord", "float", "-eye_vertex.z", 0 },
        { VERTEX, "shd_vertex", "vec3", "(shd_eye_matrix*eye_vertex).xyz", 0 },
        { VERTEX, "tbn_sky_dir", "vec3", "eye_sky_dir*eye_tbn_matrix", "n" },
        { VERTEX, "tbn_light_dir[i]", "vec3", "eye_light_dir[i]*eye_tbn_matrix", 0 },
@@ -143,10 +149,14 @@ const ProgramBuilder::VariableDefinition ProgramBuilder::standard_variables[] =
        { UNIFORM, "Lighting::sky_color", "vec4", 0, 0 },
        { UNIFORM, "Lighting::eye_sky_dir", "vec3", 0, 0 },
        { UNIFORM, "Lighting::horizon_limit", "float", 0, 0 },
+       { UNIFORM, "Lighting::fog_color", "vec4", "gl_Fog.color", 0 },
+       { UNIFORM, "Lighting::fog_density", "float", "gl_Fog.density", 0 },
        { UNIFORM, "Material::material", "MaterialParameters", "gl_FrontMaterial", 0 },
+       { UNIFORM, "Clipping::clip_planes", "ClipPlane[MAX_CLIP_PLANES]", 0, 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 },
+       { TYPE, "ClipPlane", "struct { vec4 equation; }", 0, 0 },
 
        // Terminator entry
        { NO_SCOPE, 0, 0, 0, 0 }
@@ -238,7 +248,10 @@ ProgramBuilder::ProgramBuilder(const StandardFeatures &f):
 
        if(!features.legacy)
        {
+               aliases["texture1D"] = "texture";
                aliases["texture2D"] = "texture";
+               aliases["texture3D"] = "texture";
+               aliases["textureCube"] = "texture";
                aliases["shadow2D"] = "texture";
        }
        else
@@ -262,6 +275,8 @@ void ProgramBuilder::add_shaders(Program &prog) const
        list<ShaderVariable> variables;
        list<ShaderVariable *> resolved_vars;
 
+       if(features.clipping)
+               variables.push_back(ShaderVariable("gl_ClipDistance[i]"));
        variables.push_front(ShaderVariable("gl_Position"));
        variables.push_front(ShaderVariable(features.legacy ? "gl_FragColor" : "frag_color"));
 
@@ -444,6 +459,10 @@ string ProgramBuilder::create_source(const list<ShaderVariable *> &variables, Va
                }
        }
 
+       // The clip distance array must be declared manually to give it a size
+       if(scope==VERTEX && features.clipping)
+               source += format("out float gl_ClipDistance[%d];\n", features.max_clip_planes);
+
        source += "void main()\n{\n";
 
        list<ShaderVariable *> loop_vars;
@@ -480,7 +499,7 @@ string ProgramBuilder::create_source(const list<ShaderVariable *> &variables, Va
                                }
 
                                InterfaceFlags iface = (*j)->get_interface_flags(scope);
-                               if(iface&OUTPUT)
+                               if((iface&(OUTPUT|GOAL))==OUTPUT)
                                {
                                        string expr = ((*j)->inlined ? create_expression(**j, "i") : (*j)->resolved_name+"[i]");
                                        source += format("\t\t%c_%s[i] = %s;\n", interfaces[scope], (*j)->resolved_name, expr);
@@ -493,7 +512,7 @@ string ProgramBuilder::create_source(const list<ShaderVariable *> &variables, Va
 
                InterfaceFlags iface = (*i)->get_interface_flags(scope);
 
-               if((*i)->array_size>1)
+               if((*i)->array_size>1 || ((*i)->array_size==1 && (iface&GOAL)))
                {
                        if((*i)->variable->scope==scope || (iface&OUTPUT))
                        {
@@ -717,10 +736,13 @@ ProgramBuilder::StandardFeatures::StandardFeatures():
        lighting(false),
        max_lights(1),
        skylight(false),
+       fog(false),
        specular(false),
        normalmap(false),
        shadow(false),
-       reflection(false)
+       reflection(false),
+       clipping(false),
+       max_clip_planes(1)
 {
        if(get_gl_api()==OPENGL_ES2)
                legacy = !(get_glsl_version()>=Version(3, 0));
@@ -745,10 +767,14 @@ string ProgramBuilder::StandardFeatures::create_flags() const
                if(normalmap)
                        flags += 'n';
        }
+       if(fog)
+               flags += 'f';
        if(shadow)
                flags += 's';
        if(reflection)
                flags += 'e';
+       if(clipping)
+               flags += 'c';
        if(legacy && get_gl_api()==OPENGL)
                flags += 'g';
 
@@ -848,6 +874,8 @@ void ProgramBuilder::ShaderVariable::resolve_array(const StandardFeatures &featu
        {
                if(array_subscript=="MAX_LIGHTS")
                        array_size = features.max_lights;
+               else if(array_subscript=="MAX_CLIP_PLANES")
+                       array_size = features.max_clip_planes;
                else if(isnumrc(array_subscript))
                        array_size = lexical_cast<unsigned>(array_subscript);
                else
@@ -1074,9 +1102,12 @@ 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("reflection", &StandardFeatures::reflection);