X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fprogramcompiler.cpp;h=c35fa275c2b1bbadbcfbfb8f113cf68d165d4a8a;hp=14c9d3d3ced42958e539e7ef27a6623f297e41cb;hb=6dc2da27f0831d4172fcfeba4900616fd6c844b8;hpb=94c4f0983dcaeae21b911b3a79a9e0eb656fb84a diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp index 14c9d3d3..c35fa275 100644 --- a/source/programcompiler.cpp +++ b/source/programcompiler.cpp @@ -122,6 +122,8 @@ void ProgramCompiler::process() else ++i; } + for(list::iterator i=module->stages.begin(); i!=module->stages.end(); ++i) + finalize(*i); } void ProgramCompiler::import(const string &name) @@ -185,6 +187,14 @@ bool ProgramCompiler::optimize(Stage &stage) return !unused.empty(); } +void ProgramCompiler::finalize(Stage &stage) +{ + if(get_gl_api()==OPENGL_ES2) + apply(stage); + else + apply(stage); +} + void ProgramCompiler::inject_block(Block &target, const Block &source) { list >::iterator insert_point = target.body.begin(); @@ -220,6 +230,38 @@ void ProgramCompiler::Visitor::apply(Stage &s) } +ProgramCompiler::BlockModifier::BlockModifier(): + remove_node(false) +{ } + +void ProgramCompiler::BlockModifier::flatten_block(Block &block) +{ + 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) +{ + block.body.insert(i, insert_nodes.begin(), insert_nodes.end()); + insert_nodes.clear(); + + if(remove_node) + block.body.erase(i++); + else + ++i; + remove_node = false; +} + +void ProgramCompiler::BlockModifier::visit(Block &block) +{ + for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) + { + (*i)->visit(*this); + apply_and_increment(block, i); + } +} + + ProgramCompiler::Formatter::Formatter(): indent(0), parameter_list(false), @@ -228,9 +270,17 @@ ProgramCompiler::Formatter::Formatter(): void ProgramCompiler::Formatter::apply(ProgramSyntax::Stage &s) { + GLApi api = get_gl_api(); const Version &ver = s.required_version; - if(ver.major) - formatted += format("#version %d%d\n", ver.major, ver.minor); + + if(ver) + { + formatted += format("#version %d%02d", ver.major, ver.minor); + if(api==OPENGL_ES2 && ver>=Version(3, 0)) + formatted += " es"; + formatted += '\n'; + } + Visitor::apply(s); } @@ -329,6 +379,11 @@ void ProgramCompiler::Formatter::visit(Import &import) formatted += format("import %s;", import.module); } +void ProgramCompiler::Formatter::visit(Precision &prec) +{ + formatted += format("precision %s %s;", prec.precision, prec.type); +} + void ProgramCompiler::Formatter::visit(Layout &layout) { formatted += "layout("; @@ -368,7 +423,19 @@ void ProgramCompiler::Formatter::visit(VariableDeclaration &var) if(!var.sampling.empty()) formatted += format("%s ", var.sampling); if(!var.interface.empty() && var.interface!=block_interface) - formatted += format("%s ", var.interface); + { + string interface = var.interface; + if(stage->required_versiontype==VERTEX && var.interface=="in") + interface = "attribute"; + else if((stage->type==VERTEX && var.interface=="out") || (stage->type==FRAGMENT && var.interface=="in")) + interface = "varying"; + } + formatted += format("%s ", interface); + } + if(!var.precision.empty()) + formatted += format("%s ", var.precision); formatted += format("%s %s", var.type, var.name); if(var.array) { @@ -461,8 +528,7 @@ void ProgramCompiler::Formatter::visit(Jump &jump) ProgramCompiler::DeclarationCombiner::DeclarationCombiner(): - toplevel(true), - remove_node(false) + toplevel(true) { } void ProgramCompiler::DeclarationCombiner::visit(Block &block) @@ -471,15 +537,7 @@ void ProgramCompiler::DeclarationCombiner::visit(Block &block) return; SetForScope set(toplevel, false); - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) - { - remove_node = false; - (*i)->visit(*this); - if(remove_node) - block.body.erase(i++); - else - ++i; - } + BlockModifier::visit(block); } void ProgramCompiler::DeclarationCombiner::visit(FunctionDeclaration &func) @@ -679,38 +737,6 @@ void ProgramCompiler::FunctionResolver::visit(FunctionDeclaration &func) } -ProgramCompiler::BlockModifier::BlockModifier(): - remove_node(false) -{ } - -void ProgramCompiler::BlockModifier::flatten_block(Block &block) -{ - 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) -{ - block.body.insert(i, insert_nodes.begin(), insert_nodes.end()); - insert_nodes.clear(); - - if(remove_node) - block.body.erase(i++); - else - ++i; - remove_node = false; -} - -void ProgramCompiler::BlockModifier::visit(Block &block) -{ - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) - { - (*i)->visit(*this); - apply_and_increment(block, i); - } -} - - ProgramCompiler::InterfaceGenerator::InterfaceGenerator(): scope_level(0) { } @@ -1229,8 +1255,7 @@ void ProgramCompiler::UnusedVariableLocator::apply(Stage &s) if(!i->second.referenced) { unused_nodes.insert(i->first); - for(vector::iterator j=i->second.assignments.begin(); j!=i->second.assignments.end(); ++j) - unused_nodes.insert(*j); + clear_assignments(i->second, true); } } variables.pop_back(); @@ -1282,11 +1307,21 @@ void ProgramCompiler::UnusedVariableLocator::record_assignment(VariableDeclarati { VariableInfo &var_info = variables.back()[&var]; if(!self_ref) - var_info.assignments.clear(); + clear_assignments(var_info, true); var_info.assignments.push_back(&node); var_info.conditionally_assigned = false; } +void ProgramCompiler::UnusedVariableLocator::clear_assignments(VariableInfo &var_info, bool mark_unused) +{ + if(mark_unused) + { + for(vector::iterator i=var_info.assignments.begin(); i!=var_info.assignments.end(); ++i) + unused_nodes.insert(*i); + } + var_info.assignments.clear(); +} + void ProgramCompiler::UnusedVariableLocator::visit(ExpressionStatement &expr) { assignment = 0; @@ -1337,6 +1372,8 @@ void ProgramCompiler::UnusedVariableLocator::visit(FunctionDeclaration &func) BlockVariableMap &block_variables = variables.back(); for(BlockVariableMap::iterator i=block_variables.begin(); i!=block_variables.end(); ++i) i->second.conditionally_assigned = true; + for(vector >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) + block_variables[i->get()].referenced = true; merge_down_variables(); } @@ -1350,8 +1387,7 @@ void ProgramCompiler::UnusedVariableLocator::merge_down_variables() { if(!i->second.referenced) unused_nodes.insert(i->first); - for(vector::iterator j=i->second.assignments.begin(); j!=i->second.assignments.end(); ++j) - unused_nodes.insert(*j); + clear_assignments(i->second, true); continue; } @@ -1360,11 +1396,9 @@ void ProgramCompiler::UnusedVariableLocator::merge_down_variables() parent_variables.insert(*i); else { - if(!i->second.conditionally_assigned) - { - j->second.assignments.clear(); - j->second.conditionally_assigned = true; - } + if(i->second.referenced || !i->second.conditionally_assigned) + clear_assignments(j->second, !i->second.referenced); + j->second.conditionally_assigned = i->second.conditionally_assigned; j->second.referenced |= i->second.referenced; j->second.assignments.insert(j->second.assignments.end(), i->second.assignments.begin(), i->second.assignments.end()); } @@ -1439,7 +1473,7 @@ void ProgramCompiler::UnusedFunctionLocator::visit(FunctionDeclaration &func) { TraversingVisitor::visit(func); - if(func.name!="main" && !used_definitions.count(&func)) + if((func.name!="main" || func.body.body.empty()) && !used_definitions.count(&func)) unused_nodes.insert(&func); } @@ -1475,15 +1509,78 @@ void ProgramCompiler::NodeRemover::visit(VariableDeclaration &var) } +void ProgramCompiler::PrecisionRemover::visit(Precision &) +{ + remove_node = true; +} + +void ProgramCompiler::PrecisionRemover::visit(VariableDeclaration &var) +{ + var.precision.clear(); +} + + +ProgramCompiler::DefaultPrecisionGenerator::DefaultPrecisionGenerator(): + toplevel(true) +{ } + +void ProgramCompiler::DefaultPrecisionGenerator::visit(Block &block) +{ + if(toplevel) + { + SetForScope set(toplevel, false); + BlockModifier::visit(block); + } + else + Visitor::visit(block); +} + +void ProgramCompiler::DefaultPrecisionGenerator::visit(Precision &prec) +{ + have_default.insert(prec.type); +} + +void ProgramCompiler::DefaultPrecisionGenerator::visit(VariableDeclaration &var) +{ + if(var.type_declaration) + return; + + string type = var.type; + if(!type.compare(0, 3, "vec") || !type.compare(0, 3, "mat")) + type = "float"; + else if(!type.compare(0, 3, "ivec") || type=="uint") + type = "int"; + + if(!have_default.count(type)) + { + Precision *prec = new Precision; + if(!type.compare(0, 7, "sampler")) + prec->precision = "lowp"; + else if(stage->type==FRAGMENT) + prec->precision = "mediump"; + else + prec->precision = "highp"; + prec->type = type; + insert_nodes.push_back(prec); + + have_default.insert(type); + } +} + + ProgramCompiler::LegacyConverter::LegacyConverter(): - target_version(get_glsl_version()) + target_api(get_gl_api()), + target_version(get_glsl_version()), + frag_out(0) { } ProgramCompiler::LegacyConverter::LegacyConverter(const Version &v): - target_version(v) + target_api(get_gl_api()), + target_version(v), + frag_out(0) { } -bool ProgramCompiler::LegacyConverter::check_version(const Version &feature_version) +bool ProgramCompiler::LegacyConverter::check_version(const Version &feature_version) const { if(target_version >::iterator i = call.arguments.begin(); if(i!=call.arguments.end()) @@ -1534,9 +1654,17 @@ void ProgramCompiler::LegacyConverter::visit(FunctionCall &call) TraversingVisitor::visit(call); } +bool ProgramCompiler::LegacyConverter::supports_interface_layouts() const +{ + if(target_api==OPENGL_ES2) + return check_version(Version(3, 0)); + else + return check_version(Version(3, 30)); +} + void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var) { - if(var.layout && !check_version(Version(3, 30))) + if(var.layout && !supports_interface_layouts()) { vector::iterator i; for(i=var.layout->qualifiers.begin(); (i!=var.layout->qualifiers.end() && i->identifier!="location"); ++i) ; @@ -1559,15 +1687,11 @@ void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var) } } - if((var.interface=="in" || var.interface=="out") && !check_version(Version(1, 30))) + if((var.interface=="in" || var.interface=="out") && !supports_unified_interface_syntax()) { - 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") + if(stage->type==FRAGMENT && var.interface=="out") { - frag_out_name = var.name; + frag_out = &var; remove_node = true; } } @@ -1575,9 +1699,22 @@ void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var) TraversingVisitor::visit(var); } +bool ProgramCompiler::LegacyConverter::supports_interface_blocks(const string &iface) const +{ + if(target_api==OPENGL_ES2) + { + if(iface=="uniform") + return check_version(Version(3, 0)); + else + return check_version(Version(3, 20)); + } + else + return check_version(Version(1, 50)); +} + void ProgramCompiler::LegacyConverter::visit(InterfaceBlock &iface) { - if(!check_version(Version(1, 50))) + if(!supports_interface_blocks(iface.interface)) flatten_block(iface.members); }