X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fgenerate.cpp;h=1e57ed649041cacdfaa58b56fa0a56dee5642dc9;hb=4414f0245005c8cfcd02b51ea394d612cc5776c4;hp=b7ab9d3f7b9fc956c37752f18e7e5bb36df0e0d3;hpb=cb8ee1f5ea24a5f7b561fc88d4ff5af3ae364038;p=libs%2Fgl.git

diff --git a/source/glsl/generate.cpp b/source/glsl/generate.cpp
index b7ab9d3f..1e57ed64 100644
--- a/source/glsl/generate.cpp
+++ b/source/glsl/generate.cpp
@@ -584,10 +584,8 @@ void ExpressionResolver::visit(UnaryExpression &unary)
 	resolve(unary, basic, unary.expression->lvalue);
 }
 
-void ExpressionResolver::visit(BinaryExpression &binary)
+void ExpressionResolver::visit(BinaryExpression &binary, bool assign)
 {
-	TraversingVisitor::visit(binary);
-
 	/* Binary operators are only defined for basic types (not for image or
 	structure types). */
 	BasicTypeDeclaration *basic_left = dynamic_cast<BasicTypeDeclaration *>(binary.left->type);
@@ -619,6 +617,8 @@ void ExpressionResolver::visit(BinaryExpression &binary)
 	Compatibility elem_compat = get_compatibility(*elem_left, *elem_right);
 	if(elem_compat==NOT_COMPATIBLE)
 		return;
+	if(assign && (compat==LEFT_CONVERTIBLE || elem_compat==LEFT_CONVERTIBLE))
+		return;
 
 	TypeDeclaration *type = 0;
 	char oper2 = binary.oper->token[1];
@@ -657,11 +657,17 @@ void ExpressionResolver::visit(BinaryExpression &binary)
 	}
 	else if((oper=='<' || oper=='>') && oper2==oper)
 	{
-		// Shifts only apply to integers.
-		if(basic_left->kind!=BasicTypeDeclaration::INT || basic_right->kind!=BasicTypeDeclaration::INT)
+		// Shifts apply to integer scalars and vectors, with some restrictions.
+		if(elem_left->kind!=BasicTypeDeclaration::INT || elem_right->kind!=BasicTypeDeclaration::INT)
+			return;
+		unsigned left_size = (basic_left->kind==BasicTypeDeclaration::INT ? 1 : basic_left->kind==BasicTypeDeclaration::VECTOR ? basic_left->size : 0);
+		unsigned right_size = (basic_right->kind==BasicTypeDeclaration::INT ? 1 : basic_right->kind==BasicTypeDeclaration::VECTOR ? basic_right->size : 0);
+		if(!left_size || (left_size==1 && right_size!=1) || (left_size>1 && right_size!=1 && right_size!=left_size))
 			return;
 
 		type = basic_left;
+		// Don't perform conversion even if the operands are of different sizes.
+		compat = SAME_TYPE;
 	}
 	else if(oper=='+' || oper=='-' || oper=='*' || oper=='/')
 	{
@@ -708,6 +714,9 @@ void ExpressionResolver::visit(BinaryExpression &binary)
 	else
 		return;
 
+	if(assign && type!=basic_left)
+		return;
+
 	bool converted = true;
 	if(compat==LEFT_CONVERTIBLE)
 		convert_to(binary.left, *basic_right);
@@ -721,12 +730,35 @@ void ExpressionResolver::visit(BinaryExpression &binary)
 	if(!converted)
 		type = 0;
 
-	resolve(binary, type, false);
+	resolve(binary, type, assign);
+}
+
+void ExpressionResolver::visit(BinaryExpression &binary)
+{
+	TraversingVisitor::visit(binary);
+	visit(binary, false);
 }
 
 void ExpressionResolver::visit(Assignment &assign)
 {
 	TraversingVisitor::visit(assign);
+
+	if(assign.oper->token[0]!='=')
+		return visit(assign, true);
+	else if(assign.left->type!=assign.right->type)
+	{
+		BasicTypeDeclaration *basic_left = dynamic_cast<BasicTypeDeclaration *>(assign.left->type);
+		BasicTypeDeclaration *basic_right = dynamic_cast<BasicTypeDeclaration *>(assign.right->type);
+		if(!basic_left || !basic_right)
+			return;
+
+		Compatibility compat = get_compatibility(*basic_left, *basic_right);
+		if(compat==RIGHT_CONVERTIBLE)
+			convert_to(assign.right, *basic_left);
+		else if(compat!=SAME_TYPE)
+			return;
+	}
+
 	resolve(assign, assign.left->type, true);
 }