X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fprogramcompiler.cpp;h=50e4f5851df3cb11aecb1277763f622bb3a8d6f1;hp=3dc07d80fa4dd2566c069d0cae5bdb4451f7ac5d;hb=be55468e10915d377634aa850a95dcfb9093216d;hpb=a126d48791f0ee697c11e44efaa17fe9dc6e07cf diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp index 3dc07d80..50e4f585 100644 --- a/source/programcompiler.cpp +++ b/source/programcompiler.cpp @@ -1,4 +1,8 @@ +#include #include +#include +#include +#include #include #include #include @@ -164,7 +168,7 @@ void ProgramCompiler::append_stage(Stage &stage) target = &*i; } - for(NodeList::iterator i=stage.content.body.begin(); i!=stage.content.body.end(); ++i) + for(NodeList::iterator i=stage.content.body.begin(); i!=stage.content.body.end(); ++i) target->content.body.push_back(*i); apply(*target); } @@ -237,8 +241,8 @@ void ProgramCompiler::finalize(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) + NodeList::iterator insert_point = target.body.begin(); + for(NodeList::const_iterator i=source.body.begin(); i!=source.body.end(); ++i) target.body.insert(insert_point, (*i)->clone()); } @@ -280,7 +284,7 @@ void ProgramCompiler::BlockModifier::flatten_block(Block &block) remove_node = true; } -void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list >::iterator &i) +void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, NodeList::iterator &i) { block.body.insert(i, insert_nodes.begin(), insert_nodes.end()); insert_nodes.clear(); @@ -294,7 +298,7 @@ void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list >::iterator i=block.body.begin(); i!=block.body.end(); ) + for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ) { (*i)->visit(*this); apply_and_increment(block, i); @@ -304,8 +308,7 @@ void ProgramCompiler::BlockModifier::visit(Block &block) ProgramCompiler::Formatter::Formatter(): indent(0), - parameter_list(false), - else_if(0) + parameter_list(false) { } void ProgramCompiler::Formatter::apply(ProgramSyntax::Stage &s) @@ -315,140 +318,151 @@ void ProgramCompiler::Formatter::apply(ProgramSyntax::Stage &s) if(ver) { - formatted += format("#version %d%02d", ver.major, ver.minor); + append(format("#version %d%02d", ver.major, ver.minor)); if(api==OPENGL_ES2 && ver>=Version(3, 0)) - formatted += " es"; + append(" es"); formatted += '\n'; } + for(vector::const_iterator i=s.required_extensions.begin(); i!=s.required_extensions.end(); ++i) + append(format("#extension %s: require\n", (*i)->get_name())); + if(!s.required_extensions.empty()) + formatted += '\n'; + Visitor::apply(s); } +void ProgramCompiler::Formatter::append(const string &text) +{ + formatted += text; +} + +void ProgramCompiler::Formatter::append(char c) +{ + formatted += c; +} + void ProgramCompiler::Formatter::visit(Literal &literal) { - formatted += literal.token; + append(literal.token); } void ProgramCompiler::Formatter::visit(ParenthesizedExpression &parexpr) { - formatted += '('; + append('('); parexpr.expression->visit(*this); - formatted += ')'; + append(')'); } void ProgramCompiler::Formatter::visit(VariableReference &var) { - formatted += var.name; + append(var.name); } void ProgramCompiler::Formatter::visit(MemberAccess &memacc) { memacc.left->visit(*this); - formatted += format(".%s", memacc.member); + append(format(".%s", memacc.member)); } void ProgramCompiler::Formatter::visit(UnaryExpression &unary) { if(unary.prefix) - formatted += unary.oper; + append(unary.oper); unary.expression->visit(*this); if(!unary.prefix) - formatted += unary.oper; + append(unary.oper); } void ProgramCompiler::Formatter::visit(BinaryExpression &binary) { binary.left->visit(*this); - formatted += binary.oper; + append(binary.oper); binary.right->visit(*this); - formatted += binary.after; + append(binary.after); } void ProgramCompiler::Formatter::visit(Assignment &assign) { assign.left->visit(*this); - formatted += format(" %s ", assign.oper); + append(format(" %s ", assign.oper)); assign.right->visit(*this); } void ProgramCompiler::Formatter::visit(FunctionCall &call) { - formatted += format("%s(", call.name); - for(vector >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) + append(format("%s(", call.name)); + for(NodeArray::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) { if(i!=call.arguments.begin()) - formatted += ", "; + append(", "); (*i)->visit(*this); } - formatted += ')'; + append(')'); } void ProgramCompiler::Formatter::visit(ExpressionStatement &expr) { expr.expression->visit(*this); - formatted += ';'; + append(';'); } void ProgramCompiler::Formatter::visit(Block &block) { - if(else_if) - --else_if; - unsigned brace_indent = indent; bool use_braces = (block.use_braces || (indent && block.body.size()!=1)); if(use_braces) - formatted += format("%s{\n", string(brace_indent*2, ' ')); + append(format("%s{\n", string(brace_indent*2, ' '))); 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(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ++i) { if(i!=block.body.begin()) - formatted += '\n'; - formatted += spaces; + append('\n'); + append(spaces); (*i)->visit(*this); - else_if = 0; } if(use_braces) - formatted += format("\n%s}", string(brace_indent*2, ' ')); + append(format("\n%s}", string(brace_indent*2, ' '))); } void ProgramCompiler::Formatter::visit(Import &import) { - formatted += format("import %s;", import.module); + append(format("import %s;", import.module)); } void ProgramCompiler::Formatter::visit(Precision &prec) { - formatted += format("precision %s %s;", prec.precision, prec.type); + append(format("precision %s %s;", prec.precision, prec.type)); } void ProgramCompiler::Formatter::visit(Layout &layout) { - formatted += "layout("; + append("layout("); for(vector::const_iterator i=layout.qualifiers.begin(); i!=layout.qualifiers.end(); ++i) { if(i!=layout.qualifiers.begin()) - formatted += ", "; - formatted += i->identifier; + append(", "); + append(i->identifier); if(!i->value.empty()) - formatted += format("=%s", i->value); + append(format("=%s", i->value)); } - formatted += ')'; + append(')'); } void ProgramCompiler::Formatter::visit(InterfaceLayout &layout) { layout.layout.visit(*this); - formatted += format(" %s;", layout.interface); + append(format(" %s;", layout.interface)); } void ProgramCompiler::Formatter::visit(StructDeclaration &strct) { - formatted += format("struct %s\n", strct.name); + append(format("struct %s\n", strct.name)); strct.members.visit(*this); - formatted += ';'; + append(';'); } void ProgramCompiler::Formatter::visit(VariableDeclaration &var) @@ -456,14 +470,14 @@ void ProgramCompiler::Formatter::visit(VariableDeclaration &var) if(var.layout) { var.layout->visit(*this); - formatted += ' '; + append(' '); } if(var.constant) - formatted += "const "; + append("const "); if(!var.interpolation.empty()) - formatted += format("%s ", var.interpolation); + append(format("%s ", var.interpolation)); if(!var.sampling.empty()) - formatted += format("%s ", var.sampling); + append(format("%s ", var.sampling)); if(!var.interface.empty() && var.interface!=block_interface) { string interface = var.interface; @@ -474,72 +488,75 @@ void ProgramCompiler::Formatter::visit(VariableDeclaration &var) else if((stage->type==VERTEX && var.interface=="out") || (stage->type==FRAGMENT && var.interface=="in")) interface = "varying"; } - formatted += format("%s ", interface); + append(format("%s ", interface)); } if(!var.precision.empty()) - formatted += format("%s ", var.precision); - formatted += format("%s %s", var.type, var.name); + append(format("%s ", var.precision)); + append(format("%s %s", var.type, var.name)); if(var.array) { - formatted += '['; + append('['); if(var.array_size) var.array_size->visit(*this); - formatted += ']'; + append(']'); } if(var.init_expression) { - formatted += " = "; + append(" = "); var.init_expression->visit(*this); } if(!parameter_list) - formatted += ';'; + append(';'); } void ProgramCompiler::Formatter::visit(InterfaceBlock &iface) { SetForScope set(block_interface, iface.interface); - formatted += format("%s %s\n", iface.interface, iface.name); + append(format("%s %s\n", iface.interface, iface.name)); iface.members.visit(*this); - formatted += ';'; + append(';'); } 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) + append(format("%s %s(", func.return_type, func.name)); + for(NodeArray::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) { if(i!=func.parameters.begin()) - formatted += ", "; + append(", "); SetFlag set(parameter_list); (*i)->visit(*this); } - formatted += ')'; + append(')'); if(func.definition==&func) { - formatted += '\n'; + append('\n'); func.body.visit(*this); } else - formatted += ';'; + append(';'); } void ProgramCompiler::Formatter::visit(Conditional &cond) { - if(else_if) - formatted.replace(formatted.rfind('\n'), string::npos, 1, ' '); - - indent -= else_if; - - formatted += "if("; + append("if("); cond.condition->visit(*this); - formatted += ")\n"; + append(")\n"); cond.body.visit(*this); if(!cond.else_body.body.empty()) { - formatted += format("\n%selse\n", string(indent*2, ' ')); - SetForScope set(else_if, 2); - cond.else_body.visit(*this); + Conditional *else_cond = dynamic_cast(cond.else_body.body.front().get()); + if(cond.else_body.body.size()==1 && else_cond) + { + append(format("\n%selse ", string(indent*2, ' '))); + else_cond->visit(*this); + } + else + { + append(format("\n%selse\n", string(indent*2, ' '))); + cond.else_body.visit(*this); + } } } @@ -547,55 +564,55 @@ void ProgramCompiler::Formatter::visit(Iteration &iter) { if(!iter.init_statement && iter.condition && !iter.loop_expression) { - formatted += "while("; + append("while("); iter.condition->visit(*this); - formatted += ')'; + append(')'); } else { - formatted += "for("; + append("for("); if(iter.init_statement) iter.init_statement->visit(*this); else - formatted += ';'; + append(';'); if(iter.condition) { - formatted += ' '; + append(' '); iter.condition->visit(*this); } - formatted += ';'; + append(';'); if(iter.loop_expression) { - formatted += ' '; + append(' '); iter.loop_expression->visit(*this); } - formatted += ')'; + append(')'); } if(iter.body.body.empty()) - formatted += " { }"; + append(" { }"); else { - formatted += '\n'; + append('\n'); iter.body.visit(*this); } } void ProgramCompiler::Formatter::visit(Return &ret) { - formatted += "return"; + append("return"); if(ret.expression) { - formatted += ' '; + append(' '); ret.expression->visit(*this); } - formatted += ';'; + append(';'); } void ProgramCompiler::Formatter::visit(Jump &jump) { - formatted += jump.keyword; - formatted += ';'; + append(jump.keyword); + append(';'); } @@ -634,6 +651,27 @@ void ProgramCompiler::DeclarationCombiner::visit(VariableDeclaration &var) ptr->type = var.type; if(var.init_expression) ptr->init_expression = var.init_expression; + if(var.layout) + { + if(ptr->layout) + { + for(vector::iterator i=var.layout->qualifiers.begin(); i!=var.layout->qualifiers.end(); ++i) + { + bool found = false; + for(vector::iterator j=ptr->layout->qualifiers.begin(); (!found && j!=ptr->layout->qualifiers.end()); ++j) + if(j->identifier==i->identifier) + { + j->value = i->value; + found = true; + } + + if(!found) + ptr->layout->qualifiers.push_back(*i); + } + } + else + ptr->layout = var.layout; + } remove_node = true; } else @@ -835,7 +873,7 @@ 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(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ) { (*i)->visit(*this); @@ -843,7 +881,7 @@ void ProgramCompiler::InterfaceGenerator::visit(Block &block) { for(map >::iterator j=iface_declarations.begin(); j!=iface_declarations.end(); ++j) { - list >::iterator k = block.body.insert(i, j->second); + NodeList::iterator k = block.body.insert(i, j->second); (*k)->visit(*this); } iface_declarations.clear(); @@ -1039,13 +1077,13 @@ void ProgramCompiler::DeclarationReorderer::visit(Block &block) if(scope_level>1) return Visitor::visit(block); - list >::iterator struct_insert_point = block.body.end(); - list >::iterator variable_insert_point = block.body.end(); - list >::iterator function_insert_point = block.body.end(); + NodeList::iterator struct_insert_point = block.body.end(); + NodeList::iterator variable_insert_point = block.body.end(); + NodeList::iterator function_insert_point = block.body.end(); unsigned unordered_func_count = 0; bool ordered_any_funcs = false; - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) + for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ) { kind = NO_DECLARATION; (*i)->visit(*this); @@ -1180,7 +1218,7 @@ void ProgramCompiler::FunctionInliner::visit(Block &block) if(extract_result) --extract_result; - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ++i) + for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ++i) { (*i)->visit(*this); if(extract_result) @@ -1209,7 +1247,7 @@ void ProgramCompiler::FunctionInliner::visit(MemberAccess &memacc) void ProgramCompiler::FunctionInliner::visit(FunctionCall &call) { - for(vector >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) + for(NodeArray::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) visit_and_inline(*i); FunctionDeclaration *def = call.declaration; @@ -1543,7 +1581,7 @@ void ProgramCompiler::UnusedVariableLocator::visit(FunctionDeclaration &func) { SetForScope set(global_scope, false); - for(vector >::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) + for(NodeArray::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) (*i)->visit(*this); func.body.visit(*this); } @@ -1551,7 +1589,7 @@ 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) + for(NodeArray::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) block_variables[i->get()].referenced = true; merge_down_variables(); } @@ -1663,7 +1701,7 @@ ProgramCompiler::NodeRemover::NodeRemover(const set &r): void ProgramCompiler::NodeRemover::visit(Block &block) { - for(list >::iterator i=block.body.begin(); i!=block.body.end(); ) + for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ) { (*i)->visit(*this); if(to_remove.count(i->get())) @@ -1776,6 +1814,18 @@ bool ProgramCompiler::LegacyConverter::check_version(const Version &feature_vers return true; } +bool ProgramCompiler::LegacyConverter::check_extension(const Extension &extension) const +{ + if(!extension) + return false; + + vector::iterator i = find(stage->required_extensions, &extension); + if(i==stage->required_extensions.end()) + stage->required_extensions.push_back(&extension); + + return true; +} + bool ProgramCompiler::LegacyConverter::supports_unified_interface_syntax() const { if(target_api==OPENGL_ES2) @@ -1817,7 +1867,7 @@ void ProgramCompiler::LegacyConverter::visit(FunctionCall &call) { if(call.name=="texture" && !call.declaration && !supports_unified_sampling_functions()) { - vector >::iterator i = call.arguments.begin(); + NodeArray::iterator i = call.arguments.begin(); if(i!=call.arguments.end()) { (*i)->visit(*this); @@ -1844,24 +1894,30 @@ bool ProgramCompiler::LegacyConverter::supports_interface_layouts() const { if(target_api==OPENGL_ES2) return check_version(Version(3, 0)); + else if(check_version(Version(3, 30))) + return true; else - return check_version(Version(3, 30)); + return check_extension(ARB_explicit_attrib_location); } bool ProgramCompiler::LegacyConverter::supports_centroid_sampling() const { if(target_api==OPENGL_ES2) return check_version(Version(3, 0)); + else if(check_version(Version(1, 20))) + return true; else - return check_version(Version(1, 20)); + return check_extension(EXT_gpu_shader4); } bool ProgramCompiler::LegacyConverter::supports_sample_sampling() const { if(target_api==OPENGL_ES2) return check_version(Version(3, 20)); + else if(check_version(Version(4, 0))) + return true; else - return check_version(Version(4, 0)); + return check_extension(ARB_gpu_shader5); } void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var) @@ -1923,8 +1979,12 @@ bool ProgramCompiler::LegacyConverter::supports_interface_blocks(const string &i else return check_version(Version(3, 20)); } + else if(check_version(Version(1, 50))) + return true; + else if(iface=="uniform") + return check_extension(ARB_uniform_buffer_object); else - return check_version(Version(1, 50)); + return false; } void ProgramCompiler::LegacyConverter::visit(InterfaceBlock &iface)