X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Foutput.cpp;h=07da64e3ba565cdca64a8bb9f58b5d34f11c11eb;hp=718b1a8bcde406ec124f7959f314b606361c1d2a;hb=HEAD;hpb=3e24a1bfd5a259b185ff0f37046dd0489e1908a3 diff --git a/source/glsl/output.cpp b/source/glsl/output.cpp index 718b1a8b..d28de156 100644 --- a/source/glsl/output.cpp +++ b/source/glsl/output.cpp @@ -8,16 +8,7 @@ namespace Msp { namespace GL { namespace SL { -Formatter::Formatter(): - stage(0), - source_index(0), - source_line(1), - indent(0), - parameter_list(false), - omit_builtin(false) -{ } - -const string &Formatter::apply(Stage &s) +string Formatter::apply(Stage &s) { stage = &s; omit_builtin = true; @@ -27,21 +18,27 @@ const string &Formatter::apply(Stage &s) if(ver) { append(format("#version %d%02d", ver.major, ver.minor)); - if(s.required_features.gl_api==OPENGL_ES2 && ver>=Version(3, 0)) + if(s.required_features.target_api==OPENGL_ES && ver>=Version(3, 0)) append(" es"); formatted += '\n'; } + if(s.required_features.arb_enhanced_layouts) + append("#extension GL_ARB_enhanced_layouts: require\n"); if(s.required_features.arb_explicit_attrib_location) - append("#extension arb_explicit_attrib_location: require\n"); + append("#extension GL_ARB_explicit_attrib_location: require\n"); + if(s.required_features.arb_explicit_uniform_location) + append("#extension GL_ARB_explicit_uniform_location: require\n"); if(s.required_features.arb_gpu_shader5) - append("#extension arb_gpu_shader5: require\n"); + append("#extension GL_ARB_gpu_shader5: require\n"); + if(s.required_features.arb_separate_shader_objects) + append("#extension GL_ARB_separate_shader_objects: require\n"); if(s.required_features.arb_uniform_buffer_object) - append("#extension arb_uniform_buffer_object: require\n"); + append("#extension GL_ARB_uniform_buffer_object: require\n"); if(s.required_features.ext_gpu_shader4) - append("#extension ext_gpu_shader4: require\n"); + append("#extension GL_EXT_gpu_shader4: require\n"); if(s.required_features.ext_texture_array) - append("#extension ext_texture_array: require\n"); + append("#extension GL_EXT_texture_array: require\n"); formatted += '\n'; s.content.visit(*this); @@ -52,8 +49,8 @@ const string &Formatter::apply(Stage &s) void Formatter::append(const string &text) { formatted += text; - for(string::const_iterator i=text.begin(); i!=text.end(); ++i) - if(*i=='\n') + for(char c: text) + if(c=='\n') ++source_line; } @@ -92,53 +89,78 @@ void Formatter::visit(Block &block) SetForScope set(indent, indent+(indent>0 || use_braces)); string spaces(indent*2, ' '); bool first = true; - for(NodeList::iterator i=block.body.begin(); i!=block.body.end(); ++i) + for(const RefPtr &s: block.body) { - if(omit_builtin && (*i)->source<=BUILTIN_SOURCE) + if(omit_builtin && s->source<=BUILTIN_SOURCE) continue; if(!first) append('\n'); first = false; - set_source((*i)->source, (*i)->line); + set_source(s->source, s->line); append(spaces); - (*i)->visit(*this); + s->visit(*this); } if(use_braces) append(format("\n%s}", string(brace_indent*2, ' '))); } -void Formatter::visit(Literal &literal) +void Formatter::visit_expression(Expression &expr, const Operator *outer_oper, bool on_rhs) { - append(literal.token); -} + unsigned outer_precedence = (outer_oper ? outer_oper->precedence : 20); + unsigned inner_precedence = (expr.oper ? expr.oper->precedence : 0); -void Formatter::visit(ParenthesizedExpression &parexpr) -{ - append('('); - parexpr.expression->visit(*this); - append(')'); + bool needs_parentheses = (inner_precedence>=outer_precedence); + + // Omit parentheses if the outer operator encloses this operand. + if(outer_oper && outer_oper->type==Operator::BINARY && outer_oper->token2[0] && on_rhs) + needs_parentheses = false; + + if(expr.oper) + { + /* Omit parentheses if the inner expression's operator sits between the + expression and the outer operator. */ + bool oper_on_left = expr.oper->type==Operator::PREFIX; + bool oper_on_right = expr.oper->type==Operator::POSTFIX || (expr.oper->type==Operator::BINARY && expr.oper->token2[0]); + if(expr.oper && ((oper_on_left && on_rhs) || (oper_on_right && !on_rhs))) + needs_parentheses = false; + + // Omit parentheses if the operator's natural grouping works out. + if(expr.oper==outer_oper) + needs_parentheses = (expr.oper->assoc!=Operator::ASSOCIATIVE && on_rhs!=(expr.oper->assoc==Operator::RIGHT_TO_LEFT)); + } + + if(needs_parentheses) + append('('); + expr.visit(*this); + if(needs_parentheses) + append(')'); } -void Formatter::visit(VariableReference &var) +void Formatter::visit(Literal &literal) { - append(var.name); + append(literal.token); } -void Formatter::visit(InterfaceBlockReference &iface) +void Formatter::visit(VariableReference &var) { - append(iface.name); + r_empty_name = var.name.find(' ')!=string::npos; + if(!r_empty_name) + append(var.name); } void Formatter::visit(MemberAccess &memacc) { - memacc.left->visit(*this); - append(format(".%s", memacc.member)); + visit_expression(*memacc.left, memacc.oper, false); + if(!r_empty_name) + append('.'); + append(memacc.member); + r_empty_name = false; } void Formatter::visit(Swizzle &swizzle) { - swizzle.left->visit(*this); + visit_expression(*swizzle.left, swizzle.oper, false); append(format(".%s", swizzle.component_group)); } @@ -146,31 +168,41 @@ void Formatter::visit(UnaryExpression &unary) { if(unary.oper->type==Operator::PREFIX) append(unary.oper->token); - unary.expression->visit(*this); + visit_expression(*unary.expression, unary.oper, unary.oper->type==Operator::PREFIX); if(unary.oper->type==Operator::POSTFIX) append(unary.oper->token); } void Formatter::visit(BinaryExpression &binary) { - binary.left->visit(*this); + visit_expression(*binary.left, binary.oper, false); append(binary.oper->token); - binary.right->visit(*this); - if(binary.oper->token[0]=='[') - append(']'); + visit_expression(*binary.right, binary.oper, true); + if(binary.oper->token2[0]) + append(binary.oper->token2); } void Formatter::visit(Assignment &assign) { - assign.left->visit(*this); + visit_expression(*assign.left, assign.oper, false); append(format(" %s ", assign.oper->token)); - assign.right->visit(*this); + visit_expression(*assign.right, assign.oper, true); +} + +void Formatter::visit(TernaryExpression &ternary) +{ + visit_expression(*ternary.condition, ternary.oper, false); + append(ternary.oper->token); + visit_expression(*ternary.true_expr, ternary.oper, false); + if(ternary.oper->token2[0]) + append(ternary.oper->token2); + visit_expression(*ternary.false_expr, ternary.oper, true); } void Formatter::visit(FunctionCall &call) { append(format("%s(", call.name)); - for(NodeArray::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i) + for(auto i=call.arguments.begin(); i!=call.arguments.end(); ++i) { if(i!=call.arguments.begin()) append(", "); @@ -198,7 +230,7 @@ void Formatter::visit(Precision &prec) void Formatter::visit(Layout &layout) { append("layout("); - for(vector::const_iterator i=layout.qualifiers.begin(); i!=layout.qualifiers.end(); ++i) + for(auto i=layout.qualifiers.begin(); i!=layout.qualifiers.end(); ++i) { if(i!=layout.qualifiers.begin()) append(", "); @@ -217,6 +249,9 @@ void Formatter::visit(InterfaceLayout &layout) void Formatter::visit(StructDeclaration &strct) { + if(!strct.block_name.empty()) + return; + append(format("struct %s\n", strct.name)); strct.members.visit(*this); append(';'); @@ -249,10 +284,25 @@ void Formatter::visit(VariableDeclaration &var) } if(!var.precision.empty()) append(format("%s ", var.precision)); - string type_name = var.type_declaration->name; - if(var.array) - type_name = type_name.substr(0, type_name.find('[')); - append(format("%s %s", type_name, var.name)); + + if(var.block_declaration) + { + append(format("%s\n", var.block_declaration->block_name)); + var.block_declaration->members.visit(*this); + if(var.name.find(' ')==string::npos) + append(format(" %s", var.name)); + } + else + { + string type_name = var.type_declaration->name; + if(const ImageTypeDeclaration *image = dynamic_cast(var.type_declaration)) + if(image->base_image) + type_name = image->base_image->name; + if(var.array) + type_name = type_name.substr(0, type_name.find('[')); + append(format("%s %s", type_name, var.name)); + } + if(var.array) { append('['); @@ -269,25 +319,10 @@ void Formatter::visit(VariableDeclaration &var) append(';'); } -void Formatter::visit(InterfaceBlock &iface) -{ - append(format("%s %s\n", iface.interface, iface.name)); - if(iface.struct_declaration) - iface.struct_declaration->members.visit(*this); - if(!iface.instance_name.empty()) - { - append(' '); - append(iface.instance_name); - if(iface.array) - append("[]"); - } - append(';'); -} - void Formatter::visit(FunctionDeclaration &func) { append(format("%s %s(", func.return_type_declaration->name, func.name)); - for(NodeArray::iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i) + for(auto i=func.parameters.begin(); i!=func.parameters.end(); ++i) { if(i!=func.parameters.begin()) append(", ");