X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fprogramcompiler.cpp;h=1a3cd34fae5067201f81dabf8ffcdf76121b0d59;hp=cafedc8f03180d9be4285d7e189d7a9a1e4de975;hb=4691b76467eadabfb0a7e810b12fe858a36ad519;hpb=53953f28255e782ed640a9e8d2d42c9b218943ad

diff --git a/source/programcompiler.cpp b/source/programcompiler.cpp
index cafedc8f..1a3cd34f 100644
--- a/source/programcompiler.cpp
+++ b/source/programcompiler.cpp
@@ -132,8 +132,8 @@ Stage *ProgramCompiler::get_builtins(StageType type)
 
 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()));
 
@@ -208,6 +208,7 @@ void ProgramCompiler::generate(Stage &stage)
 	apply<InterfaceGenerator>(stage);
 	apply<VariableResolver>(stage);
 	apply<DeclarationReorderer>(stage);
+	apply<FunctionResolver>(stage);
 	apply<LegacyConverter>(stage);
 }
 
@@ -459,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)
@@ -987,13 +990,30 @@ void ProgramCompiler::InterfaceGenerator::visit(Passthrough &pass)
 
 
 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(); )
 	{
@@ -1017,13 +1037,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)
@@ -1129,12 +1200,14 @@ void ProgramCompiler::FunctionInliner::visit(Return &ret)
 
 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)
 { }
@@ -1159,6 +1232,8 @@ void ProgramCompiler::ExpressionEvaluator::visit(VariableReference &var)
 {
 	if(!var.declaration)
 		return;
+	if(const_only && !var.declaration->constant)
+		return;
 
 	if(variable_values)
 	{
@@ -1218,7 +1293,8 @@ void ProgramCompiler::ExpressionEvaluator::visit(BinaryExpression &binary)
 
 
 ProgramCompiler::ConstantConditionEliminator::ConstantConditionEliminator():
-	scope_level(0)
+	scope_level(0),
+	in_loop(false)
 { }
 
 void ProgramCompiler::ConstantConditionEliminator::visit(Block &block)
@@ -1243,7 +1319,7 @@ void ProgramCompiler::ConstantConditionEliminator::visit(VariableDeclaration &va
 
 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);
@@ -1253,9 +1329,10 @@ void ProgramCompiler::ConstantConditionEliminator::visit(Conditional &cond)
 
 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)
 		{
@@ -1264,6 +1341,7 @@ void ProgramCompiler::ConstantConditionEliminator::visit(Iteration &iter)
 		}
 	}
 
+	SetFlag set_loop(in_loop);
 	TraversingVisitor::visit(iter);
 }
 
@@ -1694,6 +1772,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())
@@ -1721,6 +1815,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")