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<Node>::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);
}
}
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 += ';';
}
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)
{
+ SetForScope<unsigned> set(scope_level, scope_level+1);
+ if(scope_level>1)
+ return Visitor::visit(block);
+
list<RefPtr<Node> >::iterator struct_insert_point = block.body.end();
list<RefPtr<Node> >::iterator variable_insert_point = block.body.end();
+ list<RefPtr<Node> >::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(); )
{
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)
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);
}
var.init_expression = 0;
}
+void ProgramCompiler::NodeRemover::visit(Iteration &iter)
+{
+ if(to_remove.count(iter.init_statement.get()))
+ iter.init_statement = 0;
+}
+
void ProgramCompiler::PrecisionRemover::visit(Precision &)
{
return check_version(Version(3, 30));
}
+bool ProgramCompiler::LegacyConverter::supports_centroid_sampling() const
+{
+ if(target_api==OPENGL_ES2)
+ return check_version(Version(3, 0));
+ else
+ return check_version(Version(1, 20));
+}
+
+bool ProgramCompiler::LegacyConverter::supports_sample_sampling() const
+{
+ if(target_api==OPENGL_ES2)
+ return check_version(Version(3, 20));
+ else
+ return check_version(Version(4, 0));
+}
+
void ProgramCompiler::LegacyConverter::visit(VariableDeclaration &var)
{
if(var.layout && !supports_interface_layouts())
}
}
+ 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")
projects / libs / gl.git / blobdiff