#include <algorithm>
#include <cstring>
#include <msp/strings/format.h>
+#include <msp/strings/utils.h>
#include "extension.h"
#include "program.h"
#include "programbuilder.h"
color_* Color with rgba components
*/
-/* The array are stored in reverse order, so that variables always come after
+/* The array is stored in reverse order, so that variables always come after
anything that might need them. */
const ProgramBuilder::VariableDefinition ProgramBuilder::standard_variables[] =
{
{ FRAGMENT, "gl_FragColor", "vec4", "frag_color", "g" },
- { FRAGMENT, "frag_color", "vec4", "color_base", "!t" },
- { FRAGMENT, "frag_color", "vec4", "tex_sample", "!l!s!mt" },
- { FRAGMENT, "frag_color", "vec4", "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, 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+ambient_product_diffuse.rgb", "m" },
- { FRAGMENT, "rgb_light_full", "vec3", "rgb_light_shadow", "!m" },
- { FRAGMENT, "ambient_product_diffuse", "vec4", "gl_FrontLightModelProduct.sceneColor", "g" },
- { FRAGMENT, "ambient_product_diffuse", "vec4", "ambient_color*material.diffuse", "!g" },
- { 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*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, "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, "rgb_reflection", "vec3", "reflect_sample.rgb*reflectivity", 0 },
{ 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" },
- { FRAGMENT, "zzz_reflect_dir", "vec3", "reflect(zzz_incident_dir, n_zzz_normal)", 0 },
+
+ { FRAGMENT, "rgb_surface", "vec3", "rgb_unlit_surface", "!l" },
+ { FRAGMENT, "rgb_surface", "vec3", "rgb_lit_surface", "l" },
+ { FRAGMENT, "rgb_unlit_surface", "vec3", "basic_color.rgb", "!s" },
+ { FRAGMENT, "rgb_unlit_surface", "vec3", "basic_color.rgb*l_shadow", "s" },
+ { FRAGMENT, "rgb_lit_surface", "vec3", "rgb_illumination_diffuse", "!m" },
+ { FRAGMENT, "rgb_lit_surface", "vec3", "rgb_surface_ambient+rgb_surface_diffuse", "m!p" },
+ { FRAGMENT, "rgb_lit_surface", "vec3", "rgb_surface_ambient+rgb_surface_diffuse+rgb_surface_specular", "mp" },
+
+ { FRAGMENT, "surface_alpha", "float", "basic_color.a", "!m" },
+ { FRAGMENT, "surface_alpha", "float", "basic_color.a", "m!l" },
+ { FRAGMENT, "surface_alpha", "float", "material.diffuse.a", "ml!t" },
+ { FRAGMENT, "surface_alpha", "float", "material.diffuse.a*tex_sample.a", "mlt" },
+ { FRAGMENT, "basic_color", "vec4", "vec4(1.0)", "!m!t" },
+ { FRAGMENT, "basic_color", "vec4", "tex_sample", "!mt" },
+ { FRAGMENT, "basic_color", "vec4", "color", "m!t" },
+ { FRAGMENT, "basic_color", "vec4", "color*tex_sample", "mt" },
+
+ { FRAGMENT, "rgb_surface_ambient", "vec3", "rgb_illumination_ambient*material.ambient.rgb", "!t" },
+ { FRAGMENT, "rgb_surface_ambient", "vec3", "rgb_illumination_ambient*material.ambient.rgb*tex_sample.rgb", "t" },
+ { FRAGMENT, "rgb_illumination_ambient", "vec3", "ambient_color.rgb", 0 },
+
+ { FRAGMENT, "rgb_surface_specular", "vec3", "rgb_illumination_specular*material.specular.rgb", 0 },
+ { FRAGMENT, "rgb_illumination_specular", "vec3", "rgb_light_specular", "!s" },
+ { FRAGMENT, "rgb_illumination_specular", "vec3", "rgb_light_specular*l_shadow", "s" },
+ { FRAGMENT, "rgb_light_specular[i]", "vec3", "l_specular[i]*light_sources[i].specular.rgb", 0 },
+ { FRAGMENT, "l_specular[i]", "float", "pow(max(dot(n_zzz_half_vec[i], n_zzz_normal), 0.0), material.shininess)", 0 },
+
+ { FRAGMENT, "rgb_surface_diffuse", "vec3", "rgb_illumination_diffuse*material.diffuse.rgb", "!t" },
+ { FRAGMENT, "rgb_surface_diffuse", "vec3", "rgb_illumination_diffuse*material.diffuse.rgb*tex_sample.rgb", "t" },
+ { FRAGMENT, "rgb_illumination_diffuse", "vec3", "rgb_light_diffuse", "!s" },
+ { FRAGMENT, "rgb_illumination_diffuse", "vec3", "rgb_light_diffuse*l_shadow", "s" },
+ { FRAGMENT, "rgb_light_diffuse[i]", "vec3", "l_diffuse[i]*light_sources[i].diffuse.rgb", 0 },
+ { FRAGMENT, "l_diffuse[i]", "float", "max(dot(n_zzz_normal, n_zzz_light_dir[i]), 0.0)", 0 },
+
{ 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), 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, "zzz_reflect_dir", "vec3", "reflect(zzz_incident_dir, n_zzz_normal)", 0 },
+ { FRAGMENT, "n_zzz_half_vec[i]", "vec3", "normalize(zzz_light_dir[i]-zzz_incident_dir)", 0 },
+ { 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 },
{ VERTEX, "gl_Position", "vec4", "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(eye_light_position.xyz-eye_vertex.xyz*eye_light_position.w)", 0 },
- { VERTEX, "eye_light_position", "vec4", "light_sources[0].position", 0 },
+ { VERTEX, "tbn_light_dir[i]", "vec3", "eye_light_dir[i]*eye_tbn_matrix", 0 },
+ { VERTEX, "eye_light_dir[i]", "vec3", "normalize(eye_light_position[i].xyz-eye_vertex.xyz*eye_light_position[i].w)", 0 },
+ { VERTEX, "eye_light_position[i]", "vec4", "light_sources[i].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 },
{ 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; }[2]", "gl_LightSource", 0 },
+ { UNIFORM, "light_sources", "struct { vec4 position; vec4 diffuse; vec4 specular; }[MAX_LIGHTS]", "gl_LightSource[i]", 0 },
{ UNIFORM, "ambient_color", "vec4", 0, 0 },
{ UNIFORM, "material", "struct { vec4 ambient; vec4 diffuse; vec4 specular; float shininess; }", "gl_FrontMaterial", 0 },
{ NO_SCOPE, 0, 0, 0, 0 }
};
+const char ProgramBuilder::interfaces[] = { 0, 0, 0, 'v', 0 };
+
ProgramBuilder::ProgramBuilder(const StandardFeatures &f):
features(f),
feature_flags(features.create_flags()),
}
}
+ // Array sizes need to be resolved for inline processing
+ for(list<ShaderVariable>::iterator i=variables.end(); i!=variables.begin(); )
+ (--i)->resolve_array(features);
+
for(list<ShaderVariable *>::const_iterator i=resolved_vars.begin(); i!=resolved_vars.end(); ++i)
(*i)->check_inline(features.legacy, !optimize);
if((*i)->variable->scope==UNIFORM && (*i)->is_referenced_from(scope) && !(*i)->inlined)
source += format("uniform %s;\n", (*i)->create_declaration());
- if(scope==VERTEX)
+ /* Interface variables need to have global declarations. */
+ for(list<ShaderVariable *>::const_iterator i=variables.begin(); i!=variables.end(); ++i)
{
- const char *qualifier = (features.legacy ? "attribute" : "in");
- for(list<ShaderVariable *>::const_iterator i=variables.begin(); i!=variables.end(); ++i)
- if((*i)->variable->scope==ATTRIBUTE && !(*i)->inlined)
- source += format("%s %s;\n", qualifier, (*i)->create_declaration());
- }
+ if(!(*i)->resolved_name.compare(0, 3, "gl_"))
+ continue;
- /* 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)->variable->scope==ATTRIBUTE) && (*i)->is_referenced_from(FRAGMENT))
+ InterfaceFlags interface = (*i)->get_interface_flags(scope);
+
+ if(interface&INPUT)
{
- varyings.push_back(*i);
- const char *qualifier;
- if(!features.legacy)
- qualifier = (scope==VERTEX ? "out" : "in");
- else
- qualifier = "varying";
- source += format("%s %s;\n", qualifier, (*i)->create_declaration('v'));
+ const char *qualifier = (features.legacy ? scope==VERTEX ? "attribute" : "varying" : "in");
+ source += format("%s %s;\n", qualifier, (*i)->create_declaration(interfaces[scope-1]));
}
- for(list<ShaderVariable *>::const_iterator i=variables.begin(); i!=variables.end(); ++i)
- if((*i)->referenced_by.empty() && (*i)->resolved_name.compare(0, 3, "gl_"))
- source += format("out %s;\n", (*i)->create_declaration());
+ if(interface&OUTPUT)
+ {
+ const char *qualifier = (features.legacy ? "varying" : "out");
+ source += format("%s %s;\n", qualifier, (*i)->create_declaration(interfaces[scope]));
+ }
+ }
source += "void main()\n{\n";
+ list<ShaderVariable *> loop_vars;
+ unsigned loop_size = 0;
for(list<ShaderVariable *>::const_iterator i=variables.begin(); i!=variables.end(); ++i)
+ {
+ if(!loop_vars.empty() && !loop_vars.back()->in_loop && (*i)->array_size!=loop_size)
+ {
+ /* Declare all variables that need to be visible outside the loop.
+ Output variables are already declared. */
+ for(list<ShaderVariable *>::const_iterator j=loop_vars.begin(); j!=loop_vars.end(); ++j)
+ {
+ InterfaceFlags interface = (*j)->get_interface_flags(scope);
+ if(!(*j)->in_loop && !(interface&OUTPUT))
+ source += format("\t%s;\n", (*j)->create_declaration());
+ }
+
+ source += format("\tfor(int i=0; i<%d; ++i)\n\t{\n", loop_size);
+ for(list<ShaderVariable *>::const_iterator j=loop_vars.begin(); j!=loop_vars.end(); ++j)
+ {
+ if((*j)->variable->scope==scope && !(*j)->inlined)
+ {
+ string decl;
+ if((*j)->in_loop)
+ decl = (*j)->create_declaration(0, true);
+ else
+ {
+ decl = (*j)->resolved_name;
+ if(!(*j)->array_sum)
+ decl += "[i]";
+ }
+ const char *oper = ((*j)->array_sum ? "+=" : "=");
+ source += format("\t\t%s %s %s;\n", decl, oper, (*j)->create_expression("i"));
+ }
+
+ InterfaceFlags interface = (*j)->get_interface_flags(scope);
+ if(interface&OUTPUT)
+ {
+ string expr = ((*j)->inlined ? (*j)->create_expression("i") : (*j)->resolved_name+"[i]");
+ source += format("\t\t%c_%s[i] = %s;\n", interfaces[scope], (*j)->resolved_name, expr);
+ }
+ }
+ source += "\t}\n";
+
+ loop_vars.clear();
+ }
+
+ InterfaceFlags interface = (*i)->get_interface_flags(scope);
+
+ if((*i)->array_size>1)
+ {
+ if((*i)->variable->scope==scope || (interface&OUTPUT))
+ {
+ loop_size = (*i)->array_size;
+ loop_vars.push_back(*i);
+ }
+ continue;
+ }
+
if((*i)->variable->scope==scope && !(*i)->inlined)
{
- source += '\t';
- if((*i)->referenced_by.empty())
- source += (*i)->resolved_name;
- else
- source += (*i)->create_declaration();
- source += format(" = %s;\n", (*i)->create_expression());
+ string decl = ((interface&GOAL) ? (*i)->resolved_name : (*i)->create_declaration());
+ source += format("\t%s = %s;\n", decl, (*i)->create_expression());
}
- if(scope==VERTEX)
- {
- for(list<ShaderVariable *>::const_iterator i=varyings.begin(); i!=varyings.end(); ++i)
+ if((interface&(OUTPUT|GOAL))==OUTPUT)
{
- if((*i)->inlined)
- source += format("\tv_%s = %s;\n", (*i)->resolved_name, (*i)->create_expression());
- else
- source += format("\tv_%s = %s;\n", (*i)->resolved_name, (*i)->resolved_name);
+ string expr = ((*i)->inlined ? (*i)->create_expression() : (*i)->resolved_name);
+ source += format("\t%c_%s = %s;\n", interfaces[scope], (*i)->resolved_name, expr);
}
}
return cond;
}
-ProgramBuilder::MatchLevel ProgramBuilder::name_match(const char *n1, const char *n2, const char **space)
+ProgramBuilder::MatchType ProgramBuilder::name_match(const char *n1, const char *n2, const char **space)
{
int i = 0;
int zzz = -1;
++n2;
++i;
}
- return (!*n1 && !*n2) ? zzz>=0 ? FUZZY : EXACT : NO_MATCH;
+ return (!*n1 && !*n2) ? (zzz>=0 ? FUZZY : EXACT) : ((*n1=='[' || *n2=='[') ? ARRAY : NO_MATCH);
}
bool ProgramBuilder::parse_identifier(const char *ptr, unsigned &start, unsigned &length)
{
bool found = false;
bool member = false;
+ bool subscript = false;
for(const char *i=ptr;; ++i)
{
if(!found)
}
else
{
- if(!isalnum(*i) && *i!='_')
+ if(subscript)
+ {
+ if(*i==']')
+ {
+ length = i+1-(ptr+start);
+ return true;
+ }
+ else if(!isalpha(*i) || i>ptr+start+length+1)
+ return true;
+ }
+ else if(!isalnum(*i) && *i!='_')
{
length = i-(ptr+start);
- return true;
+ if(*i=='[')
+ subscript = true;
+ else
+ return true;
}
}
}
texture(false),
material(false),
lighting(false),
+ max_lights(1),
specular(false),
normalmap(false),
shadow(false),
variable(0),
resolved_name(n),
fuzzy_space(name.find("zzz")!=string::npos),
+ array_sum(false),
+ array_size(0),
inlined(false),
- inline_parens(false)
-{ }
+ inline_parens(false),
+ in_loop(false)
+{
+ string::size_type bracket = name.find('[');
+ if(bracket!=string::npos)
+ array_subscript = name.substr(bracket+1, name.size()-bracket-2);
+}
void ProgramBuilder::ShaderVariable::resolve(const VariableDefinition &var)
{
variable = &var;
const char *space = 0;
- if(name_match(var.name, resolved_name.c_str(), &space)==FUZZY)
- resolve_space(string(space, 3));
+ MatchType match = name_match(var.name, resolved_name.c_str(), &space);
+ if(match==FUZZY)
+ resolve_space(string(space, 3));
+ else if(match==ARRAY)
+ {
+ if(array_subscript.empty())
+ array_sum = true;
+ else if(var.scope==UNIFORM)
+ {
+ const char *bracket = strrchr(variable->type, '[');
+ if(bracket)
+ array_subscript = string(bracket+1, strlen(bracket)-2);
+ }
+ }
}
void ProgramBuilder::ShaderVariable::resolve(ShaderVariable &var)
(*i)->resolve_space(space);
}
+void ProgramBuilder::ShaderVariable::resolve_array(const StandardFeatures &features, unsigned size_hint)
+{
+ if(array_size)
+ return;
+ if(!array_sum && array_subscript.empty())
+ return;
+
+ if(!array_subscript.empty())
+ {
+ string::size_type bracket = resolved_name.find('[');
+ if(bracket!=string::npos)
+ resolved_name = resolved_name.substr(0, bracket);
+ }
+
+ if(variable && variable->scope==UNIFORM)
+ {
+ if(array_subscript=="MAX_LIGHTS")
+ array_size = features.max_lights;
+ else if(isnumrc(array_subscript))
+ array_size = lexical_cast<unsigned>(array_subscript);
+ else
+ throw invalid_variable_definition("invalid array size");
+ }
+
+ if(!array_size)
+ {
+ for(list<ShaderVariable *>::const_iterator i=referenced_vars.begin(); i!=referenced_vars.end(); ++i)
+ if((*i)->array_size)
+ {
+ array_size = (*i)->array_size;
+ break;
+ }
+ }
+
+ if(!array_size && size_hint)
+ array_size = size_hint;
+
+ if(array_size)
+ {
+ for(list<ShaderVariable *>::const_iterator i=referenced_vars.begin(); i!=referenced_vars.end(); ++i)
+ if(!(*i)->array_subscript.empty() && !(*i)->array_size)
+ (*i)->resolve_array(features, array_size);
+ }
+}
+
void ProgramBuilder::ShaderVariable::add_reference(ShaderVariable &var)
{
referenced_vars.push_back(&var);
{
if(variable->expression)
{
+ if(array_sum && array_size>1)
+ return;
if(!allow_legacy && !strncmp(variable->expression, "gl_", 3))
return;
// Never inline goal variables
- unsigned total_refs = referenced_by.size();
- if(!total_refs)
+ if(referenced_by.empty())
return;
// Inline an expression consisting of a single identifier
if(trivial_only)
return;
+ /* If all references to the variable come from arrays in the same scope
+ and of the same size, the variable can be embedded in the loop. */
+ in_loop = (array_size>1 && !array_sum);
+ for(list<ShaderVariable *>::const_iterator i=referenced_by.begin(); i!=referenced_by.end(); ++i)
+ if((*i)->variable->scope!=variable->scope || (*i)->array_size!=array_size)
+ in_loop = false;
+
+ /* Count all refs to this variable. Refs from array variables count once
+ per loop iteration. */
+ unsigned total_refs = 0;
unsigned in_scope_refs = 0;
for(list<ShaderVariable *>::const_iterator i=referenced_by.begin(); i!=referenced_by.end(); ++i)
+ {
+ unsigned count = max((*i)->array_size*!in_loop, 1U);
+ total_refs += count;
if((*i)->variable->scope==variable->scope)
- ++in_scope_refs;
+ in_scope_refs += count;
+ }
/* Inline if there's only one ref, or if all refs are in other scopes.
In the latter case, the actual inlining will happen in the interface
return false;
}
-string ProgramBuilder::ShaderVariable::create_declaration(char interface) const
+ProgramBuilder::InterfaceFlags ProgramBuilder::ShaderVariable::get_interface_flags(VariableScope scope) const
{
+ /* Uniforms are available to all stages and are not passed through
+ interfaces */
if(variable->scope==UNIFORM)
+ return NO_INTERFACE;
+
+ int flags = NO_INTERFACE;
+
+ for(list<ShaderVariable *>::const_iterator i=referenced_by.begin(); i!=referenced_by.end(); ++i)
+ {
+ /* Variables used in a later scope than they are declared in need to go
+ through the interface */
+ if((*i)->variable->scope>scope && variable->scope<=scope)
+ flags |= OUTPUT;
+ if((*i)->variable->scope>=scope && variable->scope<scope)
+ if(!inlined || variable->scope!=ATTRIBUTE || scope!=VERTEX)
+ flags |= INPUT;
+ }
+
+ // Variables without any references are goals and also outputs.
+ if(referenced_by.empty() && variable->scope==scope)
+ flags |= OUTPUT|GOAL;
+
+ return static_cast<InterfaceFlags>(flags);
+}
+
+string ProgramBuilder::ShaderVariable::create_declaration(char interface, bool loop) const
+{
+ if(variable->scope==UNIFORM && !array_subscript.empty())
{
const char *bracket = strrchr(variable->type, '[');
if(bracket)
- return format("%s %s%s", string(variable->type, bracket), resolved_name, bracket);
+ return format("%s %s[%d]", string(variable->type, bracket), resolved_name, array_size);
}
+ string array;
+ if(!array_sum && array_size>1 && !loop)
+ array = format("[%d]", array_size);
+
if(interface)
- return format("%s %c_%s", variable->type, interface, resolved_name);
+ return format("%s %c_%s%s", variable->type, interface, resolved_name, array);
else
- return format("%s %s", variable->type, resolved_name);
+ return format("%s %s%s", variable->type, resolved_name, array);
}
-string ProgramBuilder::ShaderVariable::create_replacement(VariableScope from_scope) const
+string ProgramBuilder::ShaderVariable::create_replacement(VariableScope from_scope, const char *loop) const
{
string replacement = resolved_name;
+ InterfaceFlags interface = NO_INTERFACE;
if(variable)
{
- if(from_scope==FRAGMENT && (variable->scope==VERTEX || variable->scope==ATTRIBUTE))
- replacement = "v_"+replacement;
+ interface = get_interface_flags(from_scope);
+ if((interface&INPUT) && interfaces[from_scope-1])
+ replacement = format("%c_%s", interfaces[from_scope-1], replacement);
else if(inlined)
{
- replacement = create_expression();
+ replacement = create_expression(loop);
if(inline_parens)
replacement = "("+replacement+")";
+ return replacement;
}
}
+ // Add an array subscript, unless the variable is embedded in a loop
+ if(!array_subscript.empty() && !in_loop)
+ {
+ if(loop)
+ return format("%s[%s]", replacement, loop);
+ else if(!variable || variable->scope==UNIFORM)
+ return replacement+"[0]";
+ }
+
return replacement;
}
-string ProgramBuilder::ShaderVariable::create_expression() const
+string ProgramBuilder::ShaderVariable::create_expression(const char *loop) const
{
map<string, string> replace_map;
for(list<ShaderVariable *>::const_iterator i=referenced_vars.begin(); i!=referenced_vars.end(); ++i)
{
- string replacement = (*i)->create_replacement(variable->scope);
+ string replacement = (*i)->create_replacement(variable->scope, loop);
if(replacement!=(*i)->name)
replace_map[(*i)->name] = replacement;
}
add("custom", &StandardFeatures::custom);
add("lighting", &StandardFeatures::lighting);
add("material", &StandardFeatures::material);
+ add("max_lights", &StandardFeatures::max_lights);
add("normalmap", &StandardFeatures::normalmap);
add("reflection", &StandardFeatures::reflection);
add("shadow", &StandardFeatures::shadow);