X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fprogramcompiler.cpp;h=3dc07d80fa4dd2566c069d0cae5bdb4451f7ac5d;hp=425941baff567e454f8d9ce1390e0b93731cfea4;hb=6a832fe1771f8c7bca0faa0d383fbbab062a1c56;hpb=4bee7581168e0803dd24568b61e590d2a4830f96

diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp
index 425941ba..3dc07d80 100644
--- a/source/programcompiler.cpp
+++ b/source/programcompiler.cpp
@@ -8,6 +8,8 @@
 #include "resources.h"
 #include "shader.h"
 
+#undef interface
+
 using namespace std;
 
 namespace {
@@ -40,17 +42,30 @@ ProgramCompiler::ProgramCompiler():
 	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();
 }
 
@@ -115,13 +130,47 @@ Stage *ProgramCompiler::get_builtins(StageType type)
 	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(); )
@@ -138,33 +187,15 @@ void ProgramCompiler::process()
 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)
@@ -176,8 +207,8 @@ 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);
 }
 
@@ -429,6 +460,8 @@ void ProgramCompiler::Formatter::visit(VariableDeclaration &var)
 	}
 	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)
@@ -512,20 +545,50 @@ void ProgramCompiler::Formatter::visit(Conditional &cond)
 
 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 += ';';
 }
 
@@ -832,6 +895,7 @@ void ProgramCompiler::InterfaceGenerator::insert_assignment(const string &left,
 
 	ExpressionStatement *stmt = new ExpressionStatement;
 	stmt->expression = assign;
+	stmt->visit(*this);
 	insert_nodes.push_back(stmt);
 }
 
@@ -847,7 +911,10 @@ void ProgramCompiler::InterfaceGenerator::visit(VariableReference &var)
 	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)
@@ -860,7 +927,10 @@ 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")
@@ -949,28 +1019,31 @@ void ProgramCompiler::InterfaceGenerator::visit(Passthrough &pass)
 }
 
 
-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(); )
 	{
@@ -994,13 +1067,64 @@ void ProgramCompiler::DeclarationReorderer::visit(Block &block)
 		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)
@@ -1077,6 +1201,12 @@ void ProgramCompiler::FunctionInliner::visit(BinaryExpression &binary)
 	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)
@@ -1095,6 +1225,13 @@ void ProgramCompiler::FunctionInliner::visit(FunctionCall &call)
 		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);
@@ -1195,7 +1332,8 @@ void ProgramCompiler::ExpressionEvaluator::visit(BinaryExpression &binary)
 
 
 ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
-	scope_level(0)
+	scope_level(0),
+	record_only(false)
 { }
 
 void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
@@ -1207,6 +1345,13 @@ 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);
@@ -1220,28 +1365,49 @@ void ProgramCompiler::ConstantConditionEliminator::visit(VariableDeclaration &va
 
 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);
 }
 
 
@@ -1249,6 +1415,7 @@ ProgramCompiler::UnusedVariableLocator::UnusedVariableLocator():
 	aggregate(0),
 	assignment(0),
 	assignment_target(false),
+	assign_to_subscript(false),
 	global_scope(true)
 { }
 
@@ -1294,6 +1461,8 @@ void ProgramCompiler::UnusedVariableLocator::visit(BinaryExpression &binary)
 {
 	if(binary.oper=="[")
 	{
+		if(assignment_target)
+			assign_to_subscript = true;
 		binary.left->visit(*this);
 		SetForScope<bool> set(assignment_target, false);
 		binary.right->visit(*this);
@@ -1305,6 +1474,7 @@ void ProgramCompiler::UnusedVariableLocator::visit(BinaryExpression &binary)
 void ProgramCompiler::UnusedVariableLocator::visit(Assignment &assign)
 {
 	{
+		assign_to_subscript = false;
 		SetForScope<bool> set(assignment_target, !assign.self_referencing);
 		assign.left->visit(*this);
 	}
@@ -1312,10 +1482,10 @@ void ProgramCompiler::UnusedVariableLocator::visit(Assignment &assign)
 	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;
@@ -1336,7 +1506,7 @@ void ProgramCompiler::UnusedVariableLocator::visit(ExpressionStatement &expr)
 	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)
@@ -1517,6 +1687,13 @@ void ProgramCompiler::NodeRemover::visit(VariableDeclaration &var)
 		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 &)
 {
@@ -1671,6 +1848,22 @@ bool ProgramCompiler::LegacyConverter::supports_interface_layouts() const
 		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())
@@ -1698,6 +1891,17 @@ 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")