X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fglsl%2Fgenerate.cpp;h=1f229991f7b2427e45b7fe511099dd2a894774c5;hb=2a9f8f3803e1b57e0e5325454266d4e701b38cc5;hp=53676c26784cf7d32709639fea843459e3cf4269;hpb=041ba4b1acd55337239c5ce24cc310118c621206;p=libs%2Fgl.git

diff --git a/source/glsl/generate.cpp b/source/glsl/generate.cpp
index 53676c26..1f229991 100644
--- a/source/glsl/generate.cpp
+++ b/source/glsl/generate.cpp
@@ -1,3 +1,4 @@
+#include <algorithm>
 #include <msp/core/hash.h>
 #include <msp/core/raii.h>
 #include <msp/strings/lexicalcast.h>
@@ -256,8 +257,7 @@ VariableResolver::VariableResolver():
 	stage(0),
 	r_any_resolved(false),
 	record_target(false),
-	r_self_referencing(false),
-	r_assignment_target(0)
+	r_self_referencing(false)
 { }
 
 bool VariableResolver::apply(Stage &s)
@@ -274,18 +274,40 @@ 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);
 	if(r_replacement_expr)
 	{
 		expr = r_replacement_expr;
+		/* Don't record assignment target when doing a replacement, because chain
+		information won't be correct. */
+		r_assignment_target.declaration = 0;
 		r_any_resolved = true;
 	}
 	r_replacement_expr = 0;
 }
 
+void VariableResolver::check_assignment_target(Statement *declaration)
+{
+	if(record_target)
+	{
+		if(r_assignment_target.declaration)
+		{
+			/* More than one reference found in assignment target.  Unable to
+			determine what the primary target is. */
+			record_target = false;
+			r_assignment_target.declaration = 0;
+		}
+		else
+			r_assignment_target.declaration = declaration;
+	}
+	// TODO This check is overly broad and may prevent some optimizations.
+	else if(declaration && declaration==r_assignment_target.declaration)
+		r_self_referencing = true;
+}
+
 void VariableResolver::visit(VariableReference &var)
 {
 	VariableDeclaration *declaration = 0;
@@ -332,20 +354,7 @@ void VariableResolver::visit(VariableReference &var)
 	r_any_resolved |= (declaration!=var.declaration);
 	var.declaration = declaration;
 
-	if(record_target)
-	{
-		if(r_assignment_target)
-		{
-			/* More than one variable reference found in assignment target.
-			Unable to determine what the primary target is. */
-			record_target = false;
-			r_assignment_target = 0;
-		}
-		else
-			r_assignment_target = var.declaration;
-	}
-	else if(var.declaration && var.declaration==r_assignment_target)
-		r_self_referencing = true;
+	check_assignment_target(var.declaration);
 }
 
 void VariableResolver::visit(InterfaceBlockReference &iface)
@@ -354,27 +363,82 @@ void VariableResolver::visit(InterfaceBlockReference &iface)
 	InterfaceBlock *declaration = (i!=stage->interface_blocks.end() ? i->second : 0);
 	r_any_resolved |= (declaration!=iface.declaration);
 	iface.declaration = declaration;
+
+	check_assignment_target(iface.declaration);
+}
+
+void VariableResolver::add_to_chain(Assignment::Target::ChainType type, unsigned index)
+{
+	if(r_assignment_target.chain_len<7)
+		r_assignment_target.chain[r_assignment_target.chain_len] = type | min<unsigned>(index, 0x3F);
+	++r_assignment_target.chain_len;
 }
 
 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))
 	{
 		map<string, VariableDeclaration *>::iterator i = strct->members.variables.find(memacc.member);
 		if(i!=strct->members.variables.end())
+		{
 			declaration = i->second;
+
+			if(record_target)
+			{
+				unsigned index = 0;
+				for(NodeList<Statement>::const_iterator j=strct->members.body.begin(); (j!=strct->members.body.end() && j->get()!=i->second); ++j)
+					++index;
+
+				add_to_chain(Assignment::Target::MEMBER, index);
+			}
+		}
+	}
+	else if(BasicTypeDeclaration *basic = dynamic_cast<BasicTypeDeclaration *>(memacc.left->type))
+	{
+		bool scalar_swizzle = ((basic->kind==BasicTypeDeclaration::INT || basic->kind==BasicTypeDeclaration::FLOAT) && memacc.member.size()==1);
+		bool vector_swizzle = (basic->kind==BasicTypeDeclaration::VECTOR && memacc.member.size()<=4);
+		if(scalar_swizzle || vector_swizzle)
+		{
+			static const char component_names[] = { 'x', 'r', 's', 'y', 'g', 't', 'z', 'b', 'p', 'w', 'a', 'q' };
+
+			bool ok = true;
+			UInt8 components[4] = { };
+			for(unsigned i=0; (ok && i<memacc.member.size()); ++i)
+				ok = ((components[i] = (find(component_names, component_names+12, memacc.member[i])-component_names)/3) < 4);
+
+			if(ok)
+			{
+				Swizzle *swizzle = new Swizzle;
+				swizzle->source = memacc.source;
+				swizzle->line = memacc.line;
+				swizzle->oper = memacc.oper;
+				swizzle->left = memacc.left;
+				swizzle->component_group = memacc.member;
+				swizzle->count = memacc.member.size();
+				copy(components, components+memacc.member.size(), swizzle->components);
+				r_replacement_expr = swizzle;
+			}
+		}
 	}
 
 	r_any_resolved |= (declaration!=memacc.declaration);
 	memacc.declaration = declaration;
 }
 
-void VariableResolver::visit(UnaryExpression &unary)
+void VariableResolver::visit(Swizzle &swizzle)
 {
-	visit_and_replace(unary.expression);
+	TraversingVisitor::visit(swizzle);
+
+	if(record_target)
+	{
+		unsigned mask = 0;
+		for(unsigned i=0; i<swizzle.count; ++i)
+			mask |= 1<<swizzle.components[i];
+		add_to_chain(Assignment::Target::SWIZZLE, mask);
+	}
 }
 
 void VariableResolver::visit(BinaryExpression &binary)
@@ -385,46 +449,41 @@ 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(binary.left);
+
+		if(record_target)
+		{
+			unsigned index = 0x3F;
+			if(Literal *literal_subscript = dynamic_cast<Literal *>(binary.right.get()))
+				if(literal_subscript->value.check_type<int>())
+					index = literal_subscript->value.value<int>();
+			add_to_chain(Assignment::Target::ARRAY, index);
 		}
-		visit_and_replace(binary.left);
 	}
 	else
-	{
-		visit_and_replace(binary.left);
-		visit_and_replace(binary.right);
-	}
+		TraversingVisitor::visit(binary);
 }
 
 void VariableResolver::visit(Assignment &assign)
 {
 	{
 		SetFlag set(record_target);
-		r_assignment_target = 0;
-		visit_and_replace(assign.left);
-		r_any_resolved |= (r_assignment_target!=assign.target_declaration);
-		assign.target_declaration = r_assignment_target;
+		r_assignment_target = Assignment::Target();
+		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));
 }
 
@@ -589,6 +648,20 @@ void ExpressionResolver::visit(MemberAccess &memacc)
 		resolve(memacc, memacc.declaration->type_declaration, memacc.left->lvalue);
 }
 
+void ExpressionResolver::visit(Swizzle &swizzle)
+{
+	TraversingVisitor::visit(swizzle);
+
+	if(BasicTypeDeclaration *left_basic = dynamic_cast<BasicTypeDeclaration *>(swizzle.left->type))
+	{
+		BasicTypeDeclaration *left_elem = get_element_type(*left_basic);
+		if(swizzle.count==1)
+			resolve(swizzle, left_elem, swizzle.left->lvalue);
+		else if(left_basic->kind==BasicTypeDeclaration::VECTOR && left_elem)
+			resolve(swizzle, find_type(*left_elem, left_basic->kind, swizzle.count), swizzle.left->lvalue);
+	}
+}
+
 void ExpressionResolver::visit(UnaryExpression &unary)
 {
 	TraversingVisitor::visit(unary);