X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fgenerate.cpp;h=29d52364c1506f1dc151aad780c584dc13b0eab6;hb=a1ba04add302e7712d127b46d8d11386987a0aea;hp=8547152e45df9edb714f06ae8c2c83cccae40350;hpb=cc3f4aaaf8d2b34347f69b026c10f82797059aa4;p=libs%2Fgl.git

diff --git a/source/glsl/generate.cpp b/source/glsl/generate.cpp
index 8547152e..29d52364 100644
--- a/source/glsl/generate.cpp
+++ b/source/glsl/generate.cpp
@@ -2,6 +2,7 @@
 #include <msp/core/hash.h>
 #include <msp/core/raii.h>
 #include <msp/strings/lexicalcast.h>
+#include <msp/strings/utils.h>
 #include "builtin.h"
 #include "generate.h"
 
@@ -274,7 +275,7 @@ void VariableResolver::enter(Block &block)
 	block.variables.clear();
 }
 
-void VariableResolver::visit_and_replace(RefPtr<Expression> &expr)
+void VariableResolver::visit(RefPtr<Expression> &expr)
 {
 	r_replacement_expr = 0;
 	expr->visit(*this);
@@ -376,7 +377,7 @@ void VariableResolver::add_to_chain(Assignment::Target::ChainType type, unsigned
 
 void VariableResolver::visit(MemberAccess &memacc)
 {
-	visit_and_replace(memacc.left);
+	TraversingVisitor::visit(memacc);
 
 	VariableDeclaration *declaration = 0;
 	if(StructDeclaration *strct = dynamic_cast<StructDeclaration *>(memacc.left->type))
@@ -430,7 +431,7 @@ void VariableResolver::visit(MemberAccess &memacc)
 
 void VariableResolver::visit(Swizzle &swizzle)
 {
-	visit_and_replace(swizzle.left);
+	TraversingVisitor::visit(swizzle);
 
 	if(record_target)
 	{
@@ -441,11 +442,6 @@ void VariableResolver::visit(Swizzle &swizzle)
 	}
 }
 
-void VariableResolver::visit(UnaryExpression &unary)
-{
-	visit_and_replace(unary.expression);
-}
-
 void VariableResolver::visit(BinaryExpression &binary)
 {
 	if(binary.oper->token[0]=='[')
@@ -454,9 +450,9 @@ void VariableResolver::visit(BinaryExpression &binary)
 			/* The subscript expression is not a part of the primary assignment
 			target. */
 			SetFlag set(record_target, false);
-			visit_and_replace(binary.right);
+			visit(binary.right);
 		}
-		visit_and_replace(binary.left);
+		visit(binary.left);
 
 		if(record_target)
 		{
@@ -468,10 +464,7 @@ void VariableResolver::visit(BinaryExpression &binary)
 		}
 	}
 	else
-	{
-		visit_and_replace(binary.left);
-		visit_and_replace(binary.right);
-	}
+		TraversingVisitor::visit(binary);
 }
 
 void VariableResolver::visit(Assignment &assign)
@@ -479,30 +472,19 @@ void VariableResolver::visit(Assignment &assign)
 	{
 		SetFlag set(record_target);
 		r_assignment_target = Assignment::Target();
-		visit_and_replace(assign.left);
+		visit(assign.left);
 		r_any_resolved |= (r_assignment_target<assign.target || assign.target<r_assignment_target);
 		assign.target = r_assignment_target;
 	}
 
 	r_self_referencing = false;
-	visit_and_replace(assign.right);
+	visit(assign.right);
 	assign.self_referencing = (r_self_referencing || assign.oper->token[0]!='=');
 }
 
-void VariableResolver::visit(FunctionCall &call)
-{
-	for(NodeArray<Expression>::iterator i=call.arguments.begin(); i!=call.arguments.end(); ++i)
-		visit_and_replace(*i);
-}
-
 void VariableResolver::visit(VariableDeclaration &var)
 {
-	if(var.layout)
-		var.layout->visit(*this);
-	if(var.array_size)
-		visit_and_replace(var.array_size);
-	if(var.init_expression)
-		visit_and_replace(var.init_expression);
+	TraversingVisitor::visit(var);
 	current_block->variables.insert(make_pair(var.name, &var));
 }
 
@@ -935,17 +917,47 @@ bool FunctionResolver::apply(Stage &s)
 
 void FunctionResolver::visit(FunctionCall &call)
 {
-	map<string, FunctionDeclaration *>::iterator i = stage->functions.find(call.name);
-	if(i!=stage->functions.end())
-		call.declaration = i->second;
+	string arg_types;
+	bool has_signature = true;
+	for(NodeArray<Expression>::const_iterator i=call.arguments.begin(); (has_signature && i!=call.arguments.end()); ++i)
+	{
+		if((*i)->type)
+			append(arg_types, ",", (*i)->type->name);
+		else
+			has_signature = false;
+	}
+
+	FunctionDeclaration *declaration = 0;
+	if(has_signature)
+	{
+		map<string, FunctionDeclaration *>::iterator i = stage->functions.find(format("%s(%s)", call.name, arg_types));
+		declaration = (i!=stage->functions.end() ? i->second : 0);
+	}
+	r_any_resolved |= (declaration!=call.declaration);
+	call.declaration = declaration;
 
 	TraversingVisitor::visit(call);
 }
 
 void FunctionResolver::visit(FunctionDeclaration &func)
 {
-	FunctionDeclaration *&stage_decl = stage->functions[func.name];
-	vector<FunctionDeclaration *> &decls = declarations[func.name];
+	if(func.signature.empty())
+	{
+		string param_types;
+		for(NodeArray<VariableDeclaration>::const_iterator i=func.parameters.begin(); i!=func.parameters.end(); ++i)
+		{
+			if((*i)->type_declaration)
+				append(param_types, ",", (*i)->type_declaration->name);
+			else
+				return;
+		}
+		func.signature = format("(%s)", param_types);
+		r_any_resolved = true;
+	}
+
+	string key = func.name+func.signature;
+	FunctionDeclaration *&stage_decl = stage->functions[key];
+	vector<FunctionDeclaration *> &decls = declarations[key];
 	if(func.definition==&func)
 	{
 		stage_decl = &func;
@@ -953,17 +965,19 @@ void FunctionResolver::visit(FunctionDeclaration &func)
 		// Set all previous declarations to use this definition.
 		for(vector<FunctionDeclaration *>::iterator i=decls.begin(); i!=decls.end(); ++i)
 		{
+			r_any_resolved |= (func.definition!=(*i)->definition);
 			(*i)->definition = func.definition;
 			(*i)->body.body.clear();
 		}
 	}
 	else
 	{
-		func.definition = 0;
+		FunctionDeclaration *definition = (stage_decl ? stage_decl->definition : 0);
+		r_any_resolved |= (definition!=func.definition);
+		func.definition = definition;
+
 		if(!stage_decl)
 			stage_decl = &func;
-		else
-			func.definition = stage_decl->definition;
 	}
 	decls.push_back(&func);