X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fprogramcompiler.cpp;h=0e749c9736588ddaa5192d74a70fb9719dc16f05;hp=3cb8611c0192be3d08d67798aa9c1c0d6407f09a;hb=6a045019fbd68738b77849629e6dfd3dfd9a4d93;hpb=acec85413f86c58ff262fbc26c2c1aa8726b5c58 diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp index 3cb8611c..0e749c97 100644 --- a/source/programcompiler.cpp +++ b/source/programcompiler.cpp @@ -58,21 +58,23 @@ void ProgramCompiler::add_shaders(Program &program) if(!module) throw invalid_operation("ProgramCompiler::add_shaders"); - string head = "#version 150\n"; for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++i) { if(i->type==VERTEX) - program.attach_shader_owned(new VertexShader(head+apply(*i))); + { + program.attach_shader_owned(new VertexShader(apply(*i))); + for(map::iterator j=i->locations.begin(); j!=i->locations.end(); ++j) + program.bind_attribute(j->second, j->first); + } else if(i->type==GEOMETRY) - program.attach_shader_owned(new GeometryShader(head+apply(*i))); + program.attach_shader_owned(new GeometryShader(apply(*i))); else if(i->type==FRAGMENT) - program.attach_shader_owned(new FragmentShader(head+apply(*i))); + { + program.attach_shader_owned(new FragmentShader(apply(*i))); + for(map::iterator j=i->locations.begin(); j!=i->locations.end(); ++j) + program.bind_fragment_data(j->second, j->first); + } } - - program.bind_attribute(VERTEX4, "vertex"); - program.bind_attribute(NORMAL3, "normal"); - program.bind_attribute(COLOR4_FLOAT, "color"); - program.bind_attribute(TEXCOORD4, "texcoord"); } Module *ProgramCompiler::create_builtins_module() @@ -124,9 +126,8 @@ void ProgramCompiler::process() void ProgramCompiler::import(const string &name) { - if(!resources) - throw runtime_error("no resources"); - RefPtr io = resources->open_raw(name+".glsl"); + string fn = name+".glsl"; + RefPtr io = (resources ? resources->open_raw(fn) : Resources::get_builtins().open(fn)); if(!io) throw runtime_error(format("module %s not found", name)); ProgramParser import_parser; @@ -164,12 +165,16 @@ void ProgramCompiler::generate(Stage &stage) apply(stage); apply(stage); apply(stage); + apply(stage); + apply(stage); } bool ProgramCompiler::optimize(Stage &stage) { apply(stage); - apply(stage); + + set inlineable = apply(stage); + apply(stage, inlineable); set unused = apply(stage); set unused2 = apply(stage); @@ -181,8 +186,8 @@ bool ProgramCompiler::optimize(Stage &stage) void ProgramCompiler::inject_block(Block &target, const Block &source) { - list >::iterator insert_point = target.body.begin(); - for(list >::const_iterator i=source.body.begin(); i!=source.body.end(); ++i) + list >::iterator insert_point = target.body.begin(); + for(list >::const_iterator i=source.body.begin(); i!=source.body.end(); ++i) target.body.insert(insert_point, (*i)->clone()); } @@ -220,6 +225,14 @@ ProgramCompiler::Formatter::Formatter(): else_if(0) { } +void ProgramCompiler::Formatter::apply(ProgramSyntax::Stage &s) +{ + const Version &ver = s.required_version; + if(ver.major) + formatted += format("#version %d%d\n", ver.major, ver.minor); + Visitor::apply(s); +} + void ProgramCompiler::Formatter::visit(Literal &literal) { formatted += literal.token; @@ -270,7 +283,7 @@ void ProgramCompiler::Formatter::visit(Assignment &assign) void ProgramCompiler::Formatter::visit(FunctionCall &call) { formatted += format("%s(", call.name); - for(vector >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) + for(vector >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) { if(i!=call.arguments.begin()) formatted += ", "; @@ -295,9 +308,9 @@ void ProgramCompiler::Formatter::visit(Block &block) if(use_braces) formatted += format("%s{\n", string(brace_indent*2, ' ')); - SetForScope set(indent, indent+!formatted.empty()); + SetForScope set(indent, indent+(indent>0 || use_braces)); string spaces(indent*2, ' '); - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ++i) + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ++i) { if(i!=block.body.begin()) formatted += '\n'; @@ -326,7 +339,13 @@ void ProgramCompiler::Formatter::visit(Layout &layout) if(!i->value.empty()) formatted += format("=%s", i->value); } - formatted += format(") %s;", layout.interface); + formatted += ')'; +} + +void ProgramCompiler::Formatter::visit(InterfaceLayout &layout) +{ + layout.layout.visit(*this); + formatted += format(" %s;", layout.interface); } void ProgramCompiler::Formatter::visit(StructDeclaration &strct) @@ -338,6 +357,11 @@ void ProgramCompiler::Formatter::visit(StructDeclaration &strct) void ProgramCompiler::Formatter::visit(VariableDeclaration &var) { + if(var.layout) + { + var.layout->visit(*this); + formatted += ' '; + } if(var.constant) formatted += "const "; if(!var.sampling.empty()) @@ -372,7 +396,7 @@ void ProgramCompiler::Formatter::visit(InterfaceBlock &iface) void ProgramCompiler::Formatter::visit(FunctionDeclaration &func) { formatted += format("%s %s(", func.return_type, func.name); - for(vector >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) + for(vector >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) { if(i!=func.parameters.begin()) formatted += ", "; @@ -440,7 +464,7 @@ void ProgramCompiler::DeclarationCombiner::visit(Block &block) return; SetForScope set(toplevel, false); - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) { remove_node = false; (*i)->visit(*this); @@ -470,6 +494,7 @@ void ProgramCompiler::DeclarationCombiner::visit(VariableDeclaration &var) VariableDeclaration *&ptr = variables[var.name]; if(ptr) { + ptr->type = var.type; if(var.init_expression) ptr->init_expression = var.init_expression; remove_node = true; @@ -653,15 +678,13 @@ ProgramCompiler::BlockModifier::BlockModifier(): void ProgramCompiler::BlockModifier::flatten_block(Block &block) { - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ++i) - insert_nodes.push_back((*i)->clone()); + insert_nodes.insert(insert_nodes.end(), block.body.begin(), block.body.end()); remove_node = true; } -void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list >::iterator &i) +void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list >::iterator &i) { - for(list::iterator j=insert_nodes.begin(); j!=insert_nodes.end(); ++j) - block.body.insert(i, *j); + block.body.insert(i, insert_nodes.begin(), insert_nodes.end()); insert_nodes.clear(); if(remove_node) @@ -673,7 +696,7 @@ void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list >::iterator i=block.body.begin(); i!=block.body.end(); ) + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) { (*i)->visit(*this); apply_and_increment(block, i); @@ -707,15 +730,15 @@ void ProgramCompiler::InterfaceGenerator::apply(Stage &s) void ProgramCompiler::InterfaceGenerator::visit(Block &block) { SetForScope set(scope_level, scope_level+1); - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) { (*i)->visit(*this); if(scope_level==1) { - for(map::iterator j=iface_declarations.begin(); j!=iface_declarations.end(); ++j) + for(map >::iterator j=iface_declarations.begin(); j!=iface_declarations.end(); ++j) { - list >::iterator k = block.body.insert(i, j->second); + list >::iterator k = block.body.insert(i, j->second); (*k)->visit(*this); } iface_declarations.clear(); @@ -824,9 +847,9 @@ void ProgramCompiler::InterfaceGenerator::visit(Passthrough &pass) for(map::const_iterator i=stage->in_variables.begin(); i!=stage->in_variables.end(); ++i) pass_vars.push_back(i->second); - for(map::const_iterator i=iface_declarations.begin(); i!=iface_declarations.end(); ++i) + for(map >::const_iterator i=iface_declarations.begin(); i!=iface_declarations.end(); ++i) if(i->second->interface=="in") - pass_vars.push_back(i->second); + pass_vars.push_back(i->second.get()); if(stage->previous) { @@ -898,6 +921,147 @@ void ProgramCompiler::VariableRenamer::visit(VariableDeclaration &var) } +ProgramCompiler::DeclarationReorderer::DeclarationReorderer(): + kind(NO_DECLARATION) +{ } + +void ProgramCompiler::DeclarationReorderer::visit(Block &block) +{ + list >::iterator struct_insert_point = block.body.end(); + list >::iterator variable_insert_point = block.body.end(); + + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) + { + kind = NO_DECLARATION; + (*i)->visit(*this); + + bool moved = false; + if(kind==STRUCT && struct_insert_point!=block.body.end()) + { + block.body.insert(struct_insert_point, *i); + moved = true; + } + else if(kind>STRUCT && struct_insert_point==block.body.end()) + struct_insert_point = i; + + if(kind==VARIABLE && variable_insert_point!=block.body.end()) + { + block.body.insert(variable_insert_point, *i); + moved = true; + } + else if(kind>VARIABLE && variable_insert_point==block.body.end()) + variable_insert_point = i; + + if(moved) + block.body.erase(i++); + else + ++i; + } +} + + +ProgramCompiler::InlineableFunctionLocator::InlineableFunctionLocator(): + in_function(0) +{ } + +void ProgramCompiler::InlineableFunctionLocator::visit(FunctionCall &call) +{ + FunctionDeclaration *def = call.declaration; + if(def && def->definition!=def) + def = def->definition; + + if(def) + { + unsigned &count = refcounts[def]; + ++count; + if(count>1 || def==in_function) + inlineable.erase(def); + } + + TraversingVisitor::visit(call); +} + +void ProgramCompiler::InlineableFunctionLocator::visit(FunctionDeclaration &func) +{ + unsigned &count = refcounts[func.definition]; + if(!count && func.parameters.empty()) + inlineable.insert(func.definition); + + SetForScope set(in_function, &func); + TraversingVisitor::visit(func); +} + + +ProgramCompiler::FunctionInliner::FunctionInliner(): + extract_result(0) +{ } + +ProgramCompiler::FunctionInliner::FunctionInliner(const set &in): + inlineable(in), + extract_result(0) +{ } + +void ProgramCompiler::FunctionInliner::visit_and_inline(RefPtr &ptr) +{ + inline_result = 0; + ptr->visit(*this); + if(inline_result) + ptr = inline_result; +} + +void ProgramCompiler::FunctionInliner::visit(Block &block) +{ + if(extract_result) + --extract_result; + + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ++i) + { + (*i)->visit(*this); + if(extract_result) + --extract_result; + } +} + +void ProgramCompiler::FunctionInliner::visit(UnaryExpression &unary) +{ + visit_and_inline(unary.expression); + inline_result = 0; +} + +void ProgramCompiler::FunctionInliner::visit(BinaryExpression &binary) +{ + visit_and_inline(binary.left); + visit_and_inline(binary.right); + inline_result = 0; +} + +void ProgramCompiler::FunctionInliner::visit(FunctionCall &call) +{ + for(vector >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) + visit_and_inline(*i); + + FunctionDeclaration *def = call.declaration; + if(def && def->definition!=def) + def = def->definition; + + if(def && inlineable.count(def)) + { + extract_result = 2; + def->visit(*this); + } + else + inline_result = 0; +} + +void ProgramCompiler::FunctionInliner::visit(Return &ret) +{ + TraversingVisitor::visit(ret); + + if(extract_result) + inline_result = ret.expression->clone(); +} + + ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator(): variable_values(0), result(0.0f), @@ -921,6 +1085,11 @@ void ProgramCompiler::ExpressionEvaluator::visit(Literal &literal) result_valid = true; } +void ProgramCompiler::ExpressionEvaluator::visit(ParenthesizedExpression &parexp) +{ + parexp.expression->visit(*this); +} + void ProgramCompiler::ExpressionEvaluator::visit(VariableReference &var) { if(!var.declaration) @@ -1004,7 +1173,7 @@ void ProgramCompiler::ConstantConditionEliminator::visit(Assignment &assign) void ProgramCompiler::ConstantConditionEliminator::visit(VariableDeclaration &var) { if(var.constant || scope_level>1) - variable_values[&var] = &*var.init_expression; + variable_values[&var] = var.init_expression.get(); } void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond) @@ -1152,7 +1321,7 @@ void ProgramCompiler::UnusedVariableLocator::visit(FunctionDeclaration &func) { assignments.push_back(BlockAssignmentMap()); - for(vector >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) + for(vector >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) (*i)->visit(*this); func.body.visit(*this); @@ -1258,10 +1427,10 @@ ProgramCompiler::NodeRemover::NodeRemover(const set &r): void ProgramCompiler::NodeRemover::visit(Block &block) { - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) { (*i)->visit(*this); - if(to_remove.count(&**i)) + if(to_remove.count(i->get())) block.body.erase(i++); else ++i; @@ -1274,12 +1443,120 @@ void ProgramCompiler::NodeRemover::visit(VariableDeclaration &var) { stage->in_variables.erase(var.name); stage->out_variables.erase(var.name); + stage->locations.erase(var.name); if(var.linked_declaration) var.linked_declaration->linked_declaration = 0; } - else if(var.init_expression && to_remove.count(&*var.init_expression)) + else if(var.init_expression && to_remove.count(var.init_expression.get())) var.init_expression = 0; } + +ProgramCompiler::LegacyConverter::LegacyConverter(): + target_version(get_glsl_version()) +{ } + +ProgramCompiler::LegacyConverter::LegacyConverter(const Version &v): + target_version(v) +{ } + +bool ProgramCompiler::LegacyConverter::check_version(const Version &feature_version) +{ + if(target_versionrequired_versionrequired_version = feature_version; + + return true; +} + +void ProgramCompiler::LegacyConverter::visit(VariableReference &var) +{ + if(var.name==frag_out_name && !check_version(Version(1, 30))) + { + var.name = "gl_FragColor"; + var.declaration = 0; + type = "vec4"; + } + else if(var.declaration) + type = var.declaration->type; + else + type = string(); +} + +void ProgramCompiler::LegacyConverter::visit(FunctionCall &call) +{ + if(call.name=="texture" && !call.declaration && !check_version(Version(1, 30))) + { + vector >::iterator i = call.arguments.begin(); + if(i!=call.arguments.end()) + { + (*i)->visit(*this); + if(type=="sampler1D") + call.name = "texture1D"; + else if(type=="sampler2D") + call.name = "texture2D"; + else if(type=="sampler3D") + call.name = "texture3D"; + else if(type=="sampler1DShadow") + call.name = "shadow1D"; + else if(type=="sampler2DShadow") + call.name = "shadow2D"; + + for(; i!=call.arguments.end(); ++i) + (*i)->visit(*this); + } + } + else + TraversingVisitor::visit(call); +} + +void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var) +{ + if(var.layout && !check_version(Version(3, 30))) + { + vector::iterator i; + for(i=var.layout->qualifiers.begin(); (i!=var.layout->qualifiers.end() && i->identifier!="location"); ++i) ; + if(i!=var.layout->qualifiers.end()) + { + unsigned location = lexical_cast(i->value); + if(stage->type==VERTEX && var.interface=="in") + { + stage->locations[var.name] = location; + var.layout->qualifiers.erase(i); + } + else if(stage->type==FRAGMENT && var.interface=="out") + { + stage->locations[var.name] = location; + var.layout->qualifiers.erase(i); + } + + if(var.layout->qualifiers.empty()) + var.layout = 0; + } + } + + if((var.interface=="in" || var.interface=="out") && !check_version(Version(1, 30))) + { + if(stage->type==VERTEX && var.interface=="in") + var.interface = "attribute"; + else if((stage->type==VERTEX && var.interface=="out") || (stage->type==FRAGMENT && var.interface=="in")) + var.interface = "varying"; + else if(stage->type==FRAGMENT && var.interface=="out") + { + frag_out_name = var.name; + remove_node = true; + } + } + + TraversingVisitor::visit(var); +} + +void ProgramCompiler::LegacyConverter::visit(InterfaceBlock &iface) +{ + if(!check_version(Version(1, 50))) + flatten_block(iface.members); +} + } // namespace GL } // namespace Msp