using namespace ProgramSyntax;
+// XXX For some reason global declarations are emitted for otherwise undeclared local variables
+
ProgramCompiler::ProgramCompiler():
resources(0),
module(0)
void ProgramCompiler::append_module(ProgramSyntax::Module &mod)
{
- list<Import *> imports = apply<NodeGatherer<Import> >(mod.shared);
- for(list<Import *>::iterator i=imports.begin(); i!=imports.end(); ++i)
+ 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()));
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)
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)
ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator():
variable_values(0),
+ const_only(false),
result(0.0f),
result_valid(false)
{ }
-ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator(const ValueMap &v):
- variable_values(&v),
+ProgramCompiler::ExpressionEvaluator::ExpressionEvaluator(const ValueMap *v, bool c):
+ variable_values(v),
+ const_only(c),
result(0.0f),
result_valid(false)
{ }
{
if(!var.declaration)
return;
+ if(const_only && !var.declaration->constant)
+ return;
if(variable_values)
{
ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
- scope_level(0)
+ scope_level(0),
+ in_loop(false)
{ }
void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
{
- ExpressionEvaluator eval(variable_values);
+ ExpressionEvaluator eval(&variable_values, in_loop);
cond.condition->visit(eval);
if(eval.result_valid)
flatten_block(eval.result ? cond.body : cond.else_body);
void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter)
{
+ // XXX Should this not visit init_statement first?
if(iter.condition)
{
- ExpressionEvaluator eval;
+ ExpressionEvaluator eval(0, in_loop);
iter.condition->visit(eval);
if(eval.result_valid && !eval.result)
{
}
}
+ SetFlag set_loop(in_loop);
TraversingVisitor::visit(iter);
}
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")