X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fvalidate.cpp;h=4a5ffe841801b064c04c7ea68d6d91eb53ea1c59;hb=c701c8787cb19fbb6dc5b0bfae1a94e2b07dd549;hp=889eee221b265ca98788fcd8dd73a8db22b76f64;hpb=8f5f54a9e165dae424e5b0bb8e488c3d01849bf6;p=libs%2Fgl.git

diff --git a/source/glsl/validate.cpp b/source/glsl/validate.cpp
index 889eee22..4a5ffe84 100644
--- a/source/glsl/validate.cpp
+++ b/source/glsl/validate.cpp
@@ -70,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")
 		{
@@ -104,7 +114,9 @@ void DeclarationValidator::visit(Layout &layout)
 			}
 		}
 		else if(i->name=="offset")
-			allowed = (variable && scope==INTERFACE_BLOCK);
+			allowed = (variable && scope==INTERFACE_BLOCK && iface_block->interface=="uniform");
+		else if(i->name=="align")
+			allowed = (scope==INTERFACE_BLOCK && iface_block->interface=="uniform");
 		else if(i->name=="points")
 		{
 			allowed = (stage->type==Stage::GEOMETRY && iface_layout && (iface_layout->interface=="in" || iface_layout->interface=="out"));
@@ -129,6 +141,18 @@ void DeclarationValidator::visit(Layout &layout)
 			allowed = (iface_block && !variable && iface_block->interface=="uniform");
 			value = false;
 		}
+		else if(i->name=="column_major" || i->name=="row_major")
+		{
+			allowed = (variable && scope==INTERFACE_BLOCK);
+			if(allowed)
+			{
+				BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(variable->type_declaration);
+				while(basic && basic->kind==BasicTypeDeclaration::ARRAY)
+					basic = dynamic_cast<BasicTypeDeclaration *>(basic->base_type);
+				allowed = (basic && basic->kind==BasicTypeDeclaration::MATRIX);
+				err_descr = "non-matrix variable";
+			}
+		}
 
 		if(!allowed)
 		{
@@ -204,6 +228,8 @@ void DeclarationValidator::visit(VariableDeclaration &var)
 	{
 		if(scope==STRUCT || scope==INTERFACE_BLOCK)
 			error(var, format("Constant qualifier not allowed on %s", descr));
+		if(!var.init_expression)
+			error(var, "Constant variable must have an initializer");
 	}
 
 	if(!var.interpolation.empty() || !var.sampling.empty())
@@ -225,8 +251,12 @@ void DeclarationValidator::visit(VariableDeclaration &var)
 	}
 
 	TypeDeclaration *type = var.type_declaration;
+	BasicTypeDeclaration::Kind kind = BasicTypeDeclaration::ALIAS;
 	while(BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(type))
+	{
+		kind = basic->kind;
 		type = basic->base_type;
+	}
 	if(dynamic_cast<ImageTypeDeclaration *>(type))
 	{
 		if(scope!=GLOBAL && scope!=FUNCTION_PARAM)
@@ -234,6 +264,10 @@ void DeclarationValidator::visit(VariableDeclaration &var)
 		else if(scope==GLOBAL && var.interface!="uniform")
 			error(var, format("Type '%s' only allowed with uniform interface", type->name));
 	}
+	else if(kind==BasicTypeDeclaration::VOID)
+		error(var, "Type 'void' not allowed on variable");
+	else if(kind==BasicTypeDeclaration::BOOL && !var.interface.empty() && var.source!=BUILTIN_SOURCE)
+		error(var, "Type 'bool' not allowed on interface variable");
 
 	if(var.init_expression)
 	{
@@ -327,7 +361,7 @@ void IdentifierValidator::visit(VariableDeclaration &var)
 
 void IdentifierValidator::visit(InterfaceBlock &iface)
 {
-	string key = iface.interface+iface.block_name;
+	string key = format("%s %s", iface.interface, iface.block_name);
 	map<string, InterfaceBlock *>::const_iterator i = interface_blocks.find(key);
 	if(i!=interface_blocks.end())
 		multiple_definition(format("interface block '%s %s'", iface.interface, iface.block_name), iface, *i->second);
@@ -591,6 +625,28 @@ void ExpressionValidator::visit(FunctionDeclaration &func)
 	TraversingVisitor::visit(func);
 }
 
+void ExpressionValidator::visit(Conditional &cond)
+{
+	if(cond.condition->type)
+	{
+		BasicTypeDeclaration *basic_cond = dynamic_cast<BasicTypeDeclaration *>(cond.condition->type);
+		if(!basic_cond || basic_cond->kind!=BasicTypeDeclaration::BOOL)
+			error(cond, "Condition is not a boolean");
+	}
+	TraversingVisitor::visit(cond);
+}
+
+void ExpressionValidator::visit(Iteration &iter)
+{
+	if(iter.condition->type)
+	{
+		BasicTypeDeclaration *basic_cond = dynamic_cast<BasicTypeDeclaration *>(iter.condition->type);
+		if(!basic_cond || basic_cond->kind!=BasicTypeDeclaration::BOOL)
+			error(iter, "Loop condition is not a boolean");
+	}
+	TraversingVisitor::visit(iter);
+}
+
 void ExpressionValidator::visit(Return &ret)
 {
 	if(current_function && current_function->return_type_declaration)
@@ -634,14 +690,14 @@ void StageInterfaceValidator::visit(VariableDeclaration &var)
 		}
 		if(var.type_declaration && var.linked_declaration->type_declaration)
 		{
-			const TypeDeclaration *type = var.type_declaration;
+			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))
+			if(!TypeComparer().apply(*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'",
@@ -694,7 +750,7 @@ void GlobalInterfaceValidator::check_uniform(const Uniform &uni)
 			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))
+		if(uni.type && i->second->type && !TypeComparer().apply(*uni.type, *i->second->type))
 		{
 			string type_name = (dynamic_cast<const StructDeclaration *>(uni.type) ?
 				"structure" : format("type '%s'", uni.type->name));