X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fvalidate.cpp;h=54451bcd4714f337ec114a39f016b1930ef16fa0;hb=a3637962f082182d72998a35ea86e48d51e520c3;hp=154189aa2bc8c353398b9b92a6a521c47c5afe59;hpb=f2ad2730858046b08e8147297fa01bf3499b86a3;p=libs%2Fgl.git

diff --git a/source/glsl/validate.cpp b/source/glsl/validate.cpp
index 154189aa..54451bcd 100644
--- a/source/glsl/validate.cpp
+++ b/source/glsl/validate.cpp
@@ -3,6 +3,7 @@
 #include <msp/core/raii.h>
 #include <msp/strings/format.h>
 #include <msp/strings/utils.h>
+#include "reflect.h"
 #include "validate.h"
 
 using namespace std;
@@ -69,16 +70,26 @@ void DeclarationValidator::visit(Layout &layout)
 			allowed = (variable && scope==GLOBAL);
 		else if(i->name=="binding" || i->name=="set")
 		{
+			if(i->name=="set")
+			{
+				error(layout, "Layout qualifier 'set' not allowed when targeting OpenGL");
+				continue;
+			}
+
 			if(variable)
 			{
 				TypeDeclaration *type = variable->type_declaration;
 				while(BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(type))
 					type = basic->base_type;
-				allowed = (scope==GLOBAL && dynamic_cast<ImageTypeDeclaration *>(type));
-				err_descr = "variable of non-opaque type";
+				bool uniform = (variable->interface=="uniform");
+				allowed = (scope==GLOBAL && uniform && dynamic_cast<ImageTypeDeclaration *>(type));
+				err_descr = (uniform ? "variable of non-opaque type" : "non-uniform variable");
 			}
 			else if(iface_block)
-				allowed = true;
+			{
+				allowed = (iface_block->interface=="uniform");
+				err_descr = "non-uniform interface block";
+			}
 		}
 		else if(i->name=="constant_id")
 		{
@@ -609,6 +620,180 @@ void ExpressionValidator::visit(Return &ret)
 	TraversingVisitor::visit(ret);
 }
 
+
+int StageInterfaceValidator::get_location(const Layout &layout)
+{
+	for(vector<Layout::Qualifier>::const_iterator i=layout.qualifiers.begin(); i!=layout.qualifiers.end(); ++i)
+		if(i->name=="location")
+			return i->value;
+	return -1;
+}
+
+void StageInterfaceValidator::visit(VariableDeclaration &var)
+{
+	int location = (var.layout ? get_location(*var.layout) : -1);
+	if(var.interface=="in" && var.linked_declaration)
+	{
+		const Layout *linked_layout = var.linked_declaration->layout.get();
+		int linked_location = (linked_layout ? get_location(*linked_layout) : -1);
+		if(linked_location!=location)
+		{
+			error(var, format("Mismatched location %d for 'in %s'", location, var.name));
+			add_info(*var.linked_declaration, format("Linked to 'out %s' with location %d",
+				var.linked_declaration->name, linked_location));
+		}
+		if(var.type_declaration && var.linked_declaration->type_declaration)
+		{
+			const TypeDeclaration *type = var.type_declaration;
+			if(stage->type==Stage::GEOMETRY)
+			{
+				if(const BasicTypeDeclaration *basic = dynamic_cast<const BasicTypeDeclaration *>(type))
+					if(basic->kind==BasicTypeDeclaration::ARRAY && basic->base_type)
+						type = basic->base_type;
+			}
+			if(!is_same_type(*type, *var.linked_declaration->type_declaration))
+			{
+				error(var, format("Mismatched type '%s' for 'in %s'", type->name, var.name));
+				add_info(*var.linked_declaration, format("Linked to 'out %s' with type '%s'",
+					var.linked_declaration->name, var.linked_declaration->type_declaration->name));
+			}
+		}
+	}
+
+	if(location>=0 && !var.interface.empty())
+	{
+		map<unsigned, VariableDeclaration *> &used = used_locations[var.interface];
+
+		unsigned loc_count = LocationCounter().apply(var);
+		for(unsigned i=0; i<loc_count; ++i)
+		{
+			map<unsigned, VariableDeclaration *>::const_iterator j = used.find(location+i);
+			if(j!=used.end())
+			{
+				error(var, format("Overlapping location %d for '%s %s'", location+i, var.interface, var.name));
+				add_info(*j->second, format("Previously used here for '%s %s'", j->second->interface, j->second->name));
+			}
+			else
+				used[location+i] = &var;
+		}
+	}
+}
+
+
+void GlobalInterfaceValidator::apply(Module &module)
+{
+	for(list<Stage>::iterator i=module.stages.begin(); i!=module.stages.end(); ++i)
+	{
+		stage = &*i;
+		i->content.visit(*this);
+	}
+}
+
+void GlobalInterfaceValidator::check_uniform(const Uniform &uni)
+{
+	map<std::string, const Uniform *>::const_iterator i = used_names.find(uni.name);
+	if(i!=used_names.end())
+	{
+		if(uni.location>=0 && i->second->location>=0 && i->second->location!=uni.location)
+		{
+			error(*uni.node, format("Mismatched location %d for uniform '%s'", uni.location, uni.name));
+			add_info(*i->second->node, format("Previously declared here with location %d", i->second->location));
+		}
+		if(uni.bind_point>=0 && i->second->bind_point>=0 && i->second->bind_point!=uni.bind_point)
+		{
+			error(*uni.node, format("Mismatched binding %d for uniform '%s'", uni.bind_point, uni.name));
+			add_info(*i->second->node, format("Previously declared here with binding %d", i->second->bind_point));
+		}
+		if(uni.type && i->second->type && !is_same_type(*uni.type, *i->second->type))
+		{
+			string type_name = (dynamic_cast<const StructDeclaration *>(uni.type) ?
+				"structure" : format("type '%s'", uni.type->name));
+			error(*uni.node, format("Mismatched %s for uniform '%s'", type_name, uni.name));
+
+			string message = "Previously declared here";
+			if(!dynamic_cast<const StructDeclaration *>(i->second->type))
+				message += format(" with type '%s'", i->second->type->name);
+			add_info(*i->second->node, message);
+		}
+	}
+	else
+		used_names.insert(make_pair(uni.name, &uni));
+
+	if(uni.location>=0)
+	{
+		map<unsigned, const Uniform *>::const_iterator j = used_locations.find(uni.location);
+		if(j!=used_locations.end())
+		{
+			if(j->second->name!=uni.name)
+			{
+				error(*uni.node, format("Overlapping location %d for '%s'", uni.location, uni.name));
+				add_info(*j->second->node, format("Previously used here for '%s'", j->second->name));
+			}
+		}
+		else
+		{
+			for(unsigned k=0; k<uni.loc_count; ++k)
+				used_locations.insert(make_pair(uni.location+k, &uni));
+		}
+	}
+
+	if(uni.bind_point>=0)
+	{
+		map<unsigned, const Uniform *> &used = used_bindings[uni.desc_set];
+		map<unsigned, const Uniform *>::const_iterator j = used.find(uni.bind_point);
+		if(j!=used.end())
+		{
+			if(j->second->name!=uni.name)
+			{
+				error(*uni.node, format("Overlapping binding %d for '%s'", uni.bind_point, uni.name));
+				add_info(*j->second->node, format("Previously used here for '%s'", j->second->name));
+			}
+		}
+		else
+			used.insert(make_pair(uni.bind_point, &uni));
+	}
+}
+
+void GlobalInterfaceValidator::visit(VariableDeclaration &var)
+{
+	if(var.interface=="uniform")
+	{
+		Uniform uni;
+		uni.node = &var;
+		uni.type = var.type_declaration;
+		uni.name = var.name;
+		if(var.layout)
+		{
+			uni.location = get_layout_value(*var.layout, "location");
+			uni.loc_count = LocationCounter().apply(var);
+			uni.desc_set = get_layout_value(*var.layout, "set", 0);
+			uni.bind_point = get_layout_value(*var.layout, "binding");
+		}
+
+		uniforms.push_back(uni);
+		check_uniform(uniforms.back());
+	}
+}
+
+void GlobalInterfaceValidator::visit(InterfaceBlock &iface)
+{
+	if(iface.interface=="uniform")
+	{
+		Uniform uni;
+		uni.node = &iface;
+		uni.type = iface.struct_declaration;
+		uni.name = iface.block_name;
+		if(iface.layout)
+		{
+			uni.desc_set = get_layout_value(*iface.layout, "set", 0);
+			uni.bind_point = get_layout_value(*iface.layout, "binding");
+		}
+
+		uniforms.push_back(uni);
+		check_uniform(uniforms.back());
+	}
+}
+
 } // namespace SL
 } // namespace GL
 } // namespace Msp