X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fresolve.cpp;h=eb99bec2ab57d9c801724b8803a3397e270ae363;hb=2e9d0beaafa8220d8a917749c8a12beaf4718729;hp=c03ecae08c80d5bbe9be4c942a8379482b2bbe14;hpb=6306d2f7018fe9aab3600b49332397d70306ef11;p=libs%2Fgl.git

diff --git a/source/glsl/resolve.cpp b/source/glsl/resolve.cpp
index c03ecae0..eb99bec2 100644
--- a/source/glsl/resolve.cpp
+++ b/source/glsl/resolve.cpp
@@ -151,8 +151,8 @@ bool VariableResolver::apply(Stage &s)
 	s.interface_blocks.clear();
 	r_any_resolved = false;
 	s.content.visit(*this);
-	for(VariableDeclaration *v: redeclared_builtins)
-		v->source = GENERATED_SOURCE;
+	for(Statement *b: redeclared_builtins)
+		b->source = GENERATED_SOURCE;
 	NodeRemover().apply(s, nodes_to_remove);
 	return r_any_resolved;
 }
@@ -390,34 +390,68 @@ void VariableResolver::merge_layouts(Layout &to_layout, const Layout &from_layou
 	}
 }
 
+void VariableResolver::redeclare_builtin(VariableDeclaration &existing, VariableDeclaration &var)
+{
+	if(var.layout)
+	{
+		if(existing.layout)
+			merge_layouts(*existing.layout, *var.layout);
+		else
+			existing.layout = var.layout;
+	}
+	if(var.array_size)
+		existing.array_size = var.array_size;
+
+	redeclared_builtins.push_back(&existing);
+}
+
 void VariableResolver::visit(VariableDeclaration &var)
 {
 	TraversingVisitor::visit(var);
-	VariableDeclaration *&ptr = current_block->variables[var.name];
-	if(!ptr)
-		ptr = &var;
-	else if(!current_block->parent && ptr->interface==var.interface && ptr->type==var.type)
+
+	auto i = current_block->variables.find(var.name);
+	VariableDeclaration *existing = 0;
+	InterfaceBlock *block = 0;
+	if(i!=current_block->variables.end())
+		existing = i->second;
+	else if(!current_block->parent)
+	{
+		const map<string, InterfaceBlock *> &blocks = stage->interface_blocks;
+		for(auto j=blocks.begin(); j!=blocks.end(); ++j)
+			if(j->second->instance_name.empty() && j->second->struct_declaration)
+			{
+				map<string, VariableDeclaration *> &block_vars = j->second->struct_declaration->members.variables;
+				i = block_vars.find(var.name);
+				if(i!=block_vars.end())
+				{
+					existing = i->second;
+					block = j->second;
+					break;
+				}
+			}
+	}
+
+	if(!existing)
+		current_block->variables.insert(make_pair(var.name, &var));
+	else if(!current_block->parent && (block ? block->interface : existing->interface)==var.interface && existing->type==var.type && existing->array==var.array)
 	{
-		if(ptr->source==BUILTIN_SOURCE)
+		if(existing->source==BUILTIN_SOURCE)
 		{
-			redeclared_builtins.push_back(ptr);
+			redeclare_builtin(*existing, var);
 
-			if(var.layout)
+			if(block)
 			{
-				if(ptr->layout)
-					merge_layouts(*ptr->layout, *var.layout);
-				else
-					ptr->layout = var.layout;
+				redeclared_builtins.push_back(block);
+				for(const auto &kvp: block->struct_declaration->members.variables)
+					redeclared_builtins.push_back(kvp.second);
 			}
-			if(var.array_size)
-				ptr->array_size = var.array_size;
 
 			nodes_to_remove.insert(&var);
 			r_any_resolved = true;
 		}
-		else if(ptr->array && !ptr->array_size && !var.layout && !var.init_expression)
+		else if(existing->array && !existing->array_size && !var.layout && !var.init_expression)
 		{
-			ptr->array_size = var.array_size;
+			existing->array_size = var.array_size;
 			nodes_to_remove.insert(&var);
 			r_any_resolved = true;
 		}
@@ -426,11 +460,41 @@ void VariableResolver::visit(VariableDeclaration &var)
 
 void VariableResolver::visit(InterfaceBlock &iface)
 {
-	/* Block names can be reused in different interfaces.  Prefix the name with
-	the first character of the interface to avoid conflicts. */
-	stage->interface_blocks.insert(make_pair(format("%s %s", iface.interface, iface.block_name), &iface));
-	if(!iface.instance_name.empty())
-		stage->interface_blocks.insert(make_pair(iface.instance_name, &iface));
+	string key = format("%s %s", iface.interface, iface.block_name);
+	auto i = stage->interface_blocks.find(key);
+	if(i!=stage->interface_blocks.end())
+	{
+		if(i->second->source==BUILTIN_SOURCE && iface.struct_declaration && i->second->struct_declaration)
+		{
+			const map<string, VariableDeclaration *> &vars = iface.struct_declaration->members.variables;
+			const map<string, VariableDeclaration *> &existing_vars = i->second->struct_declaration->members.variables;
+
+			bool found_all = true;
+			for(const auto &kvp: vars)
+			{
+				auto j = existing_vars.find(kvp.first);
+				if(j!=existing_vars.end() && j->second->type==kvp.second->type && j->second->array==kvp.second->array)
+					redeclare_builtin(*j->second, *kvp.second);
+				else
+					found_all = false;
+			}
+
+			if(found_all)
+			{
+				redeclared_builtins.push_back(i->second);
+				nodes_to_remove.insert(&iface);
+				nodes_to_remove.insert(iface.struct_declaration);
+			}
+		}
+	}
+	else
+	{
+		/* Block names can be reused in different interfaces.  Prepend the interface
+		to the name to avoid conflicts. */
+		stage->interface_blocks.insert(make_pair(key, &iface));
+		if(!iface.instance_name.empty())
+			stage->interface_blocks.insert(make_pair(iface.instance_name, &iface));
+	}
 
 	TraversingVisitor::visit(iface);
 }
@@ -1077,6 +1141,28 @@ void ExpressionResolver::visit(VariableDeclaration &var)
 		convert_to(var.init_expression, *var_basic);
 }
 
+void ExpressionResolver::visit(FunctionDeclaration &func)
+{
+	SetForScope<const FunctionDeclaration *> set_func(current_function, &func);
+	TraversingVisitor::visit(func);
+}
+
+void ExpressionResolver::visit(Return &ret)
+{
+	TraversingVisitor::visit(ret);
+	if(!current_function || !ret.expression)
+		return;
+
+	BasicTypeDeclaration *ret_basic = dynamic_cast<BasicTypeDeclaration *>(current_function->return_type_declaration);
+	BasicTypeDeclaration *expr_basic = dynamic_cast<BasicTypeDeclaration *>(ret.expression->type);
+	if(!ret_basic || !expr_basic)
+		return;
+
+	Compatibility compat = get_compatibility(*ret_basic, *expr_basic);
+	if(compat==RIGHT_CONVERTIBLE)
+		convert_to(ret.expression, *ret_basic);
+}
+
 
 bool FunctionResolver::apply(Stage &s)
 {