+#include <msp/core/algorithm.h>
#include <msp/core/raii.h>
+#include <msp/gl/extensions/arb_explicit_attrib_location.h>
+#include <msp/gl/extensions/arb_gpu_shader5.h>
+#include <msp/gl/extensions/arb_uniform_buffer_object.h>
#include <msp/gl/extensions/ext_gpu_shader4.h>
#include <msp/strings/format.h>
#include <msp/strings/utils.h>
#include "resources.h"
#include "shader.h"
+#undef interface
+
using namespace std;
namespace {
const char builtins_src[] =
- "////// vertex\n"
+ "#pragma MSP stage(vertex)\n"
"out gl_PerVertex {\n"
" vec4 gl_Position;\n"
" float gl_ClipDistance[];\n"
- "};"
- "////// geometry\n"
+ "};\n"
+ "#pragma MSP stage(geometry)\n"
"in gl_PerVertex {\n"
" vec4 gl_Position;\n"
" float gl_ClipDistance[];\n"
module(0)
{ }
+ProgramCompiler::~ProgramCompiler()
+{
+ delete module;
+}
+
void ProgramCompiler::compile(const string &source, const string &src_name)
{
resources = 0;
- module = &parser.parse(source, src_name);
+ delete module;
+ module = new Module();
+ ProgramParser parser;
+ imported_names.insert(src_name);
+ append_module(parser.parse(source, src_name));
process();
}
void ProgramCompiler::compile(IO::Base &io, Resources *res, const string &src_name)
{
resources = res;
- module = &parser.parse(io, src_name);
+ delete module;
+ module = new Module();
+ ProgramParser parser;
+ imported_names.insert(src_name);
+ append_module(parser.parse(io, src_name));
process();
}
return 0;
}
-void ProgramCompiler::process()
+void ProgramCompiler::append_module(ProgramSyntax::Module &mod)
{
- list<Import *> imports = apply<NodeGatherer<Import> >(module->shared);
- for(list<Import *>::iterator i=imports.end(); i!=imports.begin(); )
- import((*--i)->module);
- apply<NodeRemover>(module->shared, set<Node *>(imports.begin(), imports.end()));
+ vector<Import *> imports = apply<NodeGatherer<Import> >(mod.shared);
+ for(vector<Import *>::iterator i=imports.begin(); i!=imports.end(); ++i)
+ import((*i)->module);
+ apply<NodeRemover>(mod.shared, set<Node *>(imports.begin(), imports.end()));
+
+ append_stage(mod.shared);
+ for(list<Stage>::iterator i=mod.stages.begin(); i!=mod.stages.end(); ++i)
+ append_stage(*i);
+}
+
+void ProgramCompiler::append_stage(Stage &stage)
+{
+ Stage *target = 0;
+ if(stage.type==SHARED)
+ target = &module->shared;
+ else
+ {
+ list<Stage>::iterator i;
+ for(i=module->stages.begin(); (i!=module->stages.end() && i->type<stage.type); ++i) ;
+ if(i==module->stages.end() || i->type>stage.type)
+ {
+ list<Stage>::iterator j = module->stages.insert(i, stage.type);
+ if(i!=module->stages.end())
+ i->previous = &*j;
+ i = j;
+ if(i!=module->stages.begin())
+ i->previous = &*--j;
+ }
+
+ target = &*i;
+ }
+
+ for(NodeList<Statement>::iterator i=stage.content.body.begin(); i!=stage.content.body.end(); ++i)
+ target->content.body.push_back(*i);
+ apply<DeclarationCombiner>(*target);
+}
+void ProgramCompiler::process()
+{
for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); ++i)
generate(*i);
for(list<Stage>::iterator i=module->stages.begin(); i!=module->stages.end(); )
void ProgramCompiler::import(const string &name)
{
string fn = name+".glsl";
+ if(imported_names.count(fn))
+ return;
+ imported_names.insert(fn);
+
RefPtr<IO::Seekable> 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;
- Module &imported_module = import_parser.parse(*io, fn);
-
- inject_block(module->shared.content, imported_module.shared.content);
- apply<DeclarationCombiner>(module->shared);
- for(list<Stage>::iterator i=imported_module.stages.begin(); i!=imported_module.stages.end(); ++i)
- {
- list<Stage>::iterator j;
- for(j=module->stages.begin(); (j!=module->stages.end() && j->type<i->type); ++j) ;
- if(j==module->stages.end() || j->type>i->type)
- {
- j = module->stages.insert(j, *i);
- list<Stage>::iterator k = j;
- if(++k!=module->stages.end())
- k->previous = &*j;
- if(j!=module->stages.begin())
- j->previous = &*--(k=j);
- }
- else
- {
- inject_block(j->content, i->content);
- apply<DeclarationCombiner>(*j);
- }
- }
+ append_module(import_parser.parse(*io, fn));
}
void ProgramCompiler::generate(Stage &stage)
apply<VariableResolver>(stage);
apply<InterfaceGenerator>(stage);
apply<VariableResolver>(stage);
- apply<VariableRenamer>(stage);
apply<DeclarationReorderer>(stage);
+ apply<FunctionResolver>(stage);
apply<LegacyConverter>(stage);
}
void ProgramCompiler::inject_block(Block &target, const Block &source)
{
- list<RefPtr<Node> >::iterator insert_point = target.body.begin();
- for(list<RefPtr<Node> >::const_iterator i=source.body.begin(); i!=source.body.end(); ++i)
+ list<RefPtr<Statement> >::iterator insert_point = target.body.begin();
+ for(list<RefPtr<Statement> >::const_iterator i=source.body.begin(); i!=source.body.end(); ++i)
target.body.insert(insert_point, (*i)->clone());
}
remove_node = true;
}
-void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list<RefPtr<Node> >::iterator &i)
+void ProgramCompiler::BlockModifier::apply_and_increment(Block &block, list<RefPtr<Statement> >::iterator &i)
{
block.body.insert(i, insert_nodes.begin(), insert_nodes.end());
insert_nodes.clear();
void ProgramCompiler::BlockModifier::visit(Block &block)
{
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+ for(list<RefPtr<Statement> >::iterator i=block.body.begin(); i!=block.body.end(); )
{
(*i)->visit(*this);
apply_and_increment(block, i);
formatted += '\n';
}
+ for(vector<const Extension *>::const_iterator i=s.required_extensions.begin(); i!=s.required_extensions.end(); ++i)
+ formatted += format("#extension %s: require\n", (*i)->get_name());
+ if(!s.required_extensions.empty())
+ formatted += '\n';
+
Visitor::apply(s);
}
SetForScope<unsigned> set(indent, indent+(indent>0 || use_braces));
string spaces(indent*2, ' ');
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
+ for(list<RefPtr<Statement> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
{
if(i!=block.body.begin())
formatted += '\n';
}
if(var.constant)
formatted += "const ";
+ if(!var.interpolation.empty())
+ formatted += format("%s ", var.interpolation);
if(!var.sampling.empty())
formatted += format("%s ", var.sampling);
if(!var.interface.empty() && var.interface!=block_interface)
void ProgramCompiler::Formatter::visit(Iteration &iter)
{
- formatted += "for(";
- iter.init_statement->visit(*this);
- formatted += ' ';
- iter.condition->visit(*this);
- formatted += "; ";
- iter.loop_expression->visit(*this);
- formatted += ")\n";
- iter.body.visit(*this);
+ if(!iter.init_statement && iter.condition && !iter.loop_expression)
+ {
+ formatted += "while(";
+ iter.condition->visit(*this);
+ formatted += ')';
+ }
+ else
+ {
+ formatted += "for(";
+ if(iter.init_statement)
+ iter.init_statement->visit(*this);
+ else
+ formatted += ';';
+ if(iter.condition)
+ {
+ formatted += ' ';
+ iter.condition->visit(*this);
+ }
+ formatted += ';';
+ if(iter.loop_expression)
+ {
+ formatted += ' ';
+ iter.loop_expression->visit(*this);
+ }
+ formatted += ')';
+ }
+
+ if(iter.body.body.empty())
+ formatted += " { }";
+ else
+ {
+ formatted += '\n';
+ iter.body.visit(*this);
+ }
}
void ProgramCompiler::Formatter::visit(Return &ret)
{
- formatted += "return ";
- ret.expression->visit(*this);
+ formatted += "return";
+ if(ret.expression)
+ {
+ formatted += ' ';
+ ret.expression->visit(*this);
+ }
formatted += ';';
}
ptr->type = var.type;
if(var.init_expression)
ptr->init_expression = var.init_expression;
+ if(var.layout)
+ {
+ if(ptr->layout)
+ {
+ for(vector<Layout::Qualifier>::iterator i=var.layout->qualifiers.begin(); i!=var.layout->qualifiers.end(); ++i)
+ {
+ bool found = false;
+ for(vector<Layout::Qualifier>::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
void ProgramCompiler::InterfaceGenerator::visit(Block &block)
{
SetForScope<unsigned> set(scope_level, scope_level+1);
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+ for(list<RefPtr<Statement> >::iterator i=block.body.begin(); i!=block.body.end(); )
{
(*i)->visit(*this);
{
for(map<string, RefPtr<VariableDeclaration> >::iterator j=iface_declarations.begin(); j!=iface_declarations.end(); ++j)
{
- list<RefPtr<Node> >::iterator k = block.body.insert(i, j->second);
+ list<RefPtr<Statement> >::iterator k = block.body.insert(i, j->second);
(*k)->visit(*this);
}
iface_declarations.clear();
ExpressionStatement *stmt = new ExpressionStatement;
stmt->expression = assign;
+ stmt->visit(*this);
insert_nodes.push_back(stmt);
}
if(i==prev_out.end())
i = prev_out.find(in_prefix+var.name);
if(i!=prev_out.end())
- generate_interface(*i->second, "in", var.name);
+ {
+ generate_interface(*i->second, "in", i->second->name);
+ var.name = i->second->name;
+ }
}
void ProgramCompiler::InterfaceGenerator::visit(VariableDeclaration &var)
{
remove_node = true;
if(var.init_expression)
+ {
insert_assignment(var.name, var.init_expression->clone());
+ return;
+ }
}
}
else if(var.interface=="in")
}
-void ProgramCompiler::VariableRenamer::visit(VariableReference &var)
-{
- if(var.declaration)
- var.name = var.declaration->name;
-}
-
-void ProgramCompiler::VariableRenamer::visit(VariableDeclaration &var)
-{
- if(var.linked_declaration)
- var.name = var.linked_declaration->name;
- TraversingVisitor::visit(var);
-}
-
-
ProgramCompiler::DeclarationReorderer::DeclarationReorderer():
+ scope_level(0),
kind(NO_DECLARATION)
{ }
+void ProgramCompiler::DeclarationReorderer::visit(FunctionCall &call)
+{
+ FunctionDeclaration *def = call.declaration;
+ if(def)
+ def = def->definition;
+ if(def && !ordered_funcs.count(def))
+ needed_funcs.insert(def);
+}
+
void ProgramCompiler::DeclarationReorderer::visit(Block &block)
{
- list<RefPtr<Node> >::iterator struct_insert_point = block.body.end();
- list<RefPtr<Node> >::iterator variable_insert_point = block.body.end();
+ SetForScope<unsigned> set(scope_level, scope_level+1);
+ if(scope_level>1)
+ return Visitor::visit(block);
+
+ list<RefPtr<Statement> >::iterator struct_insert_point = block.body.end();
+ list<RefPtr<Statement> >::iterator variable_insert_point = block.body.end();
+ list<RefPtr<Statement> >::iterator function_insert_point = block.body.end();
+ unsigned unordered_func_count = 0;
+ bool ordered_any_funcs = false;
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+ for(list<RefPtr<Statement> >::iterator i=block.body.begin(); i!=block.body.end(); )
{
kind = NO_DECLARATION;
(*i)->visit(*this);
else if(kind>VARIABLE && variable_insert_point==block.body.end())
variable_insert_point = i;
+ if(kind==FUNCTION)
+ {
+ if(function_insert_point==block.body.end())
+ function_insert_point = i;
+
+ if(needed_funcs.empty())
+ {
+ ordered_funcs.insert(i->get());
+ if(i!=function_insert_point)
+ {
+ block.body.insert(function_insert_point, *i);
+ moved = true;
+ }
+ else
+ ++function_insert_point;
+ ordered_any_funcs = true;
+ }
+ else
+ ++unordered_func_count;
+ }
+
if(moved)
+ {
+ if(function_insert_point==i)
+ ++function_insert_point;
block.body.erase(i++);
+ }
else
++i;
+
+ if(i==block.body.end() && unordered_func_count)
+ {
+ if(!ordered_any_funcs)
+ // A subset of the remaining functions forms a recursive loop
+ /* TODO pick a function and move it up, adding any necessary
+ declarations */
+ break;
+
+ i = function_insert_point;
+ unordered_func_count = 0;
+ }
}
}
+void ProgramCompiler::DeclarationReorderer::visit(ProgramSyntax::VariableDeclaration &var)
+{
+ Visitor::visit(var);
+ kind = VARIABLE;
+}
+
+void ProgramCompiler::DeclarationReorderer::visit(FunctionDeclaration &func)
+{
+ needed_funcs.clear();
+ func.body.visit(*this);
+ needed_funcs.erase(&func);
+ kind = FUNCTION;
+}
+
ProgramCompiler::InlineableFunctionLocator::InlineableFunctionLocator():
in_function(0)
if(extract_result)
--extract_result;
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
+ for(list<RefPtr<Statement> >::iterator i=block.body.begin(); i!=block.body.end(); ++i)
{
(*i)->visit(*this);
if(extract_result)
inline_result = 0;
}
+void ProgramCompiler::FunctionInliner::visit(MemberAccess &memacc)
+{
+ visit_and_inline(memacc.left);
+ inline_result = 0;
+}
+
void ProgramCompiler::FunctionInliner::visit(FunctionCall &call)
{
for(vector<RefPtr<Expression> >::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
inline_result = 0;
}
+void ProgramCompiler::FunctionInliner::visit(VariableDeclaration &var)
+{
+ if(var.init_expression)
+ visit_and_inline(var.init_expression);
+ inline_result = 0;
+}
+
void ProgramCompiler::FunctionInliner::visit(Return &ret)
{
TraversingVisitor::visit(ret);
ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
- scope_level(0)
+ scope_level(0),
+ record_only(false)
{ }
void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
variable_values.erase(i->second);
}
+void ProgramCompiler::ConstantConditionEliminator::visit(UnaryExpression &unary)
+{
+ if(VariableReference *var = dynamic_cast<VariableReference *>(unary.expression.get()))
+ if(unary.oper=="++" || unary.oper=="--")
+ variable_values.erase(var->declaration);
+}
+
void ProgramCompiler::ConstantConditionEliminator::visit(Assignment &assign)
{
variable_values.erase(assign.target_declaration);
void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
{
- ExpressionEvaluator eval(variable_values);
- cond.condition->visit(eval);
- if(eval.result_valid)
- flatten_block(eval.result ? cond.body : cond.else_body);
- else
- TraversingVisitor::visit(cond);
+ if(!record_only)
+ {
+ ExpressionEvaluator eval(variable_values);
+ cond.condition->visit(eval);
+ if(eval.result_valid)
+ {
+ flatten_block(eval.result ? cond.body : cond.else_body);
+ return;
+ }
+ }
+
+ TraversingVisitor::visit(cond);
}
void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter)
{
- if(iter.condition)
+ if(!record_only)
{
- ExpressionEvaluator eval;
- iter.condition->visit(eval);
- if(eval.result_valid && !eval.result)
+ if(iter.condition)
{
- remove_node = true;
- return;
+ /* If the loop condition is always false on the first iteration, the
+ entire loop can be removed */
+ if(iter.init_statement)
+ iter.init_statement->visit(*this);
+ ExpressionEvaluator eval(variable_values);
+ iter.condition->visit(eval);
+ if(eval.result_valid && !eval.result)
+ {
+ remove_node = true;
+ return;
+ }
}
+
+ /* Record all assignments that occur inside the loop body so those
+ variables won't be considered as constant */
+ SetFlag set_record(record_only);
+ TraversingVisitor::visit(iter);
}
TraversingVisitor::visit(iter);
+
+ if(VariableDeclaration *init_decl = dynamic_cast<VariableDeclaration *>(iter.init_statement.get()))
+ variable_values.erase(init_decl);
}
aggregate(0),
assignment(0),
assignment_target(false),
+ assign_to_subscript(false),
global_scope(true)
{ }
{
if(binary.oper=="[")
{
+ if(assignment_target)
+ assign_to_subscript = true;
binary.left->visit(*this);
SetForScope<bool> set(assignment_target, false);
binary.right->visit(*this);
void ProgramCompiler::UnusedVariableLocator::visit(Assignment &assign)
{
{
+ assign_to_subscript = false;
SetForScope<bool> set(assignment_target, !assign.self_referencing);
assign.left->visit(*this);
}
assignment = &assign;
}
-void ProgramCompiler::UnusedVariableLocator::record_assignment(VariableDeclaration &var, Node &node, bool self_ref)
+void ProgramCompiler::UnusedVariableLocator::record_assignment(VariableDeclaration &var, Node &node, bool chained)
{
VariableInfo &var_info = variables.back()[&var];
- if(!self_ref)
+ if(!chained)
clear_assignments(var_info, true);
var_info.assignments.push_back(&node);
var_info.conditionally_assigned = false;
assignment = 0;
TraversingVisitor::visit(expr);
if(assignment && assignment->target_declaration)
- record_assignment(*assignment->target_declaration, expr, assignment->self_referencing);
+ record_assignment(*assignment->target_declaration, expr, (assignment->self_referencing || assign_to_subscript));
}
void ProgramCompiler::UnusedVariableLocator::visit(StructDeclaration &strct)
void ProgramCompiler::NodeRemover::visit(Block &block)
{
- for(list<RefPtr<Node> >::iterator i=block.body.begin(); i!=block.body.end(); )
+ for(list<RefPtr<Statement> >::iterator i=block.body.begin(); i!=block.body.end(); )
{
(*i)->visit(*this);
if(to_remove.count(i->get()))
var.init_expression = 0;
}
+void ProgramCompiler::NodeRemover::visit(Iteration &iter)
+{
+ if(to_remove.count(iter.init_statement.get()))
+ iter.init_statement = 0;
+ TraversingVisitor::visit(iter);
+}
+
void ProgramCompiler::PrecisionRemover::visit(Precision &)
{
return true;
}
+bool ProgramCompiler::LegacyConverter::check_extension(const Extension &extension) const
+{
+ if(!extension)
+ return false;
+
+ vector<const Extension *>::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)
{
if(target_api==OPENGL_ES2)
return check_version(Version(3, 0));
+ else if(check_version(Version(3, 30)))
+ return true;
+ else
+ 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_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(3, 30));
+ return check_extension(ARB_gpu_shader5);
}
void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
}
}
+ if(var.sampling=="centroid")
+ {
+ if(!supports_centroid_sampling())
+ var.sampling = string();
+ }
+ else if(var.sampling=="sample")
+ {
+ if(!supports_sample_sampling())
+ var.sampling = string();
+ }
+
if((var.interface=="in" || var.interface=="out") && !supports_unified_interface_syntax())
{
if(stage->type==FRAGMENT && var.interface=="out")
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)