X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fglsl%2Foptimize.cpp;h=927047cc7c1e387890bf4a3d1a4a784e2039c7ac;hp=57182019012b731ba330e7fc38a1e86f1f2eeeaf;hb=3415ed0f925d781df9d8243e0f4c454516b1c450;hpb=fdf2d162b21f55ad60bfeec2ad98c58356a083c0

diff --git a/source/glsl/optimize.cpp b/source/glsl/optimize.cpp
index 57182019..927047cc 100644
--- a/source/glsl/optimize.cpp
+++ b/source/glsl/optimize.cpp
@@ -963,7 +963,8 @@ UnusedVariableRemover::UnusedVariableRemover():
 	interface_block(0),
 	r_assignment(0),
 	assignment_target(false),
-	r_side_effects(false)
+	r_side_effects(false),
+	composite_reference(false)
 { }
 
 bool UnusedVariableRemover::apply(Stage &s)
@@ -1008,18 +1009,80 @@ void UnusedVariableRemover::referenced(const Assignment::Target &target, Node &n
 	if(!assignment_target)
 	{
 		for(vector<AssignmentInfo *>::const_iterator i=var_info.assignments.begin(); i!=var_info.assignments.end(); ++i)
-			(*i)->used_by.push_back(&node);
+		{
+			bool covered = true;
+			for(unsigned j=0; (covered && j<(*i)->target.chain_len && j<target.chain_len); ++j)
+			{
+				Assignment::Target::ChainType type1 = static_cast<Assignment::Target::ChainType>((*i)->target.chain[j]&0xC0);
+				Assignment::Target::ChainType type2 = static_cast<Assignment::Target::ChainType>(target.chain[j]&0xC0);
+				if(type1==Assignment::Target::SWIZZLE || type2==Assignment::Target::SWIZZLE)
+				{
+					unsigned index1 = (*i)->target.chain[j]&0x3F;
+					unsigned index2 = target.chain[j]&0x3F;
+					if(type1==Assignment::Target::SWIZZLE && type2==Assignment::Target::SWIZZLE)
+						covered = index1&index2;
+					else if(type1==Assignment::Target::ARRAY && index1<4)
+						covered = index2&(1<<index1);
+					else if(type2==Assignment::Target::ARRAY && index2<4)
+						covered = index1&(1<<index2);
+					/* If it's some other combination (shouldn't happen), leave
+					covered as true */
+				}
+				else
+					covered = ((*i)->target.chain[j]==target.chain[j]);
+			}
+			if(covered)
+				(*i)->used_by.push_back(&node);
+		}
 	}
 }
 
 void UnusedVariableRemover::visit(VariableReference &var)
 {
-	referenced(var.declaration, var);
+	if(composite_reference)
+		r_reference.declaration = var.declaration;
+	else
+		referenced(var.declaration, var);
 }
 
 void UnusedVariableRemover::visit(InterfaceBlockReference &iface)
 {
-	referenced(iface.declaration, iface);
+	if(composite_reference)
+		r_reference.declaration = iface.declaration;
+	else
+		referenced(iface.declaration, iface);
+}
+
+void UnusedVariableRemover::visit_composite(Expression &expr)
+{
+	if(!composite_reference)
+		r_reference = Assignment::Target();
+
+	SetFlag set_composite(composite_reference);
+	expr.visit(*this);
+}
+
+void UnusedVariableRemover::visit(MemberAccess &memacc)
+{
+	visit_composite(*memacc.left);
+
+	add_to_chain(r_reference, Assignment::Target::MEMBER, memacc.index);
+
+	if(!composite_reference && r_reference.declaration)
+		referenced(r_reference, memacc);
+}
+
+void UnusedVariableRemover::visit(Swizzle &swizzle)
+{
+	visit_composite(*swizzle.left);
+
+	unsigned mask = 0;
+	for(unsigned i=0; i<swizzle.count; ++i)
+		mask |= 1<<swizzle.components[i];
+	add_to_chain(r_reference, Assignment::Target::SWIZZLE, mask);
+
+	if(!composite_reference && r_reference.declaration)
+		referenced(r_reference, swizzle);
 }
 
 void UnusedVariableRemover::visit(UnaryExpression &unary)
@@ -1033,12 +1096,30 @@ void UnusedVariableRemover::visit(BinaryExpression &binary)
 {
 	if(binary.oper->token[0]=='[')
 	{
-		binary.left->visit(*this);
-		SetFlag set(assignment_target, false);
-		binary.right->visit(*this);
+		visit_composite(*binary.left);
+
+		{
+			SetFlag clear_assignment(assignment_target, false);
+			SetFlag clear_composite(composite_reference, false);
+			binary.right->visit(*this);
+		}
+
+		add_to_chain(r_reference, Assignment::Target::ARRAY, 0x3F);
+
+		if(!composite_reference && r_reference.declaration)
+			referenced(r_reference, binary);
 	}
 	else
+	{
+		SetFlag clear_composite(composite_reference, false);
 		TraversingVisitor::visit(binary);
+	}
+}
+
+void UnusedVariableRemover::visit(TernaryExpression &ternary)
+{
+	SetFlag clear_composite(composite_reference, false);
+	TraversingVisitor::visit(ternary);
 }
 
 void UnusedVariableRemover::visit(Assignment &assign)
@@ -1054,6 +1135,7 @@ void UnusedVariableRemover::visit(Assignment &assign)
 
 void UnusedVariableRemover::visit(FunctionCall &call)
 {
+	SetFlag clear_composite(composite_reference, false);
 	TraversingVisitor::visit(call);
 	/* Treat function calls as having side effects so expression statements
 	consisting of nothing but a function call won't be optimized away. */