fix(compression): improve dominance computation

nfrechette · nfrechette · commit 25cae6511501 · 2025-01-16T17:58:32.000-05:00
diff --git a/includes/acl/compression/impl/rigid_shell_utils.h b/includes/acl/compression/impl/rigid_shell_utils.h
@@ -76,6 +76,9 @@ namespace acl
 			// retain the largest value. We then use this maximum value to compute our dominance.
 
 			rtm::qvvf* object_transforms = allocate_type_array<rtm::qvvf>(allocator, num_transforms);
+			float* max_distance_to_parents = allocate_type_array<float>(allocator, num_transforms);
+
+			std::memset(max_distance_to_parents, 0, sizeof(float) * num_transforms);
 
 			// Our output buffer we'll return
 			rigid_shell_metadata_t* shell_metadata = allocate_type_array<rigid_shell_metadata_t>(allocator, num_transforms);
@@ -155,10 +158,11 @@ namespace acl
 						object_parent_position = object_transforms[parent_index].translation;
 
 					const float distance_to_parent = rtm::vector_distance3(object_transform.translation, object_parent_position);
-					const float shell_distance = distance_to_parent + object_shell_distance;
 
 					rigid_shell_metadata_t& transform_shell_metadata = shell_metadata[transform_index];
-					transform_shell_metadata.local_shell_distance = rtm::scalar_max(shell_distance, transform_shell_metadata.local_shell_distance);
+					transform_shell_metadata.local_shell_distance = rtm::scalar_max(object_shell_distance, transform_shell_metadata.local_shell_distance);
+
+					max_distance_to_parents[transform_index] = rtm::scalar_max(distance_to_parent, max_distance_to_parents[transform_index]);
 				}
 			}
 
@@ -179,17 +183,20 @@ namespace acl
 
 					rigid_shell_metadata_t& parent_shell = shell_metadata[parent_index];
 
-					if (shell_distance > parent_shell.local_shell_distance)
+					const float distance_to_parent = max_distance_to_parents[transform_index];
+					const float new_parent_shell_distance = shell_distance + distance_to_parent;
+					if (new_parent_shell_distance > parent_shell.local_shell_distance)
 					{
 						// We are the new dominant transform, use our shell distance and precision
-						parent_shell.local_shell_distance += shell_distance;
+						parent_shell.local_shell_distance = new_parent_shell_distance;
 						parent_shell.precision = transform_shell.precision;
 						parent_shell.dominant_transform_index = transform_shell.dominant_transform_index;
 					}
 				}
 			}
 
 			deallocate_type_array(allocator, object_transforms, num_transforms);
+			deallocate_type_array(allocator, max_distance_to_parents, num_transforms);
 
 			return shell_metadata;
 		}
@@ -223,6 +230,9 @@ namespace acl
 			// retain the largest value. We then use this maximum value to compute our dominance.
 
 			rtm::qvvf* object_transforms = allocate_type_array<rtm::qvvf>(allocator, num_transforms);
+			float* max_distance_to_parents = allocate_type_array<float>(allocator, num_transforms);
+
+			std::memset(max_distance_to_parents, 0, sizeof(float) * num_transforms);
 
 			// Initialize our output shell metadata
 			for (uint32_t transform_index = 0; transform_index < num_transforms; ++transform_index)
@@ -312,10 +322,11 @@ namespace acl
 						object_parent_position = object_transforms[parent_index].translation;
 
 					const float distance_to_parent = rtm::vector_distance3(object_transform.translation, object_parent_position);
-					const float shell_distance = distance_to_parent + object_shell_distance;
 
 					rigid_shell_metadata_t& transform_shell_metadata = out_shell_metadata[transform_index];
-					transform_shell_metadata.local_shell_distance = rtm::scalar_max(shell_distance, transform_shell_metadata.local_shell_distance);
+					transform_shell_metadata.local_shell_distance = rtm::scalar_max(object_shell_distance, transform_shell_metadata.local_shell_distance);
+
+					max_distance_to_parents[transform_index] = rtm::scalar_max(distance_to_parent, max_distance_to_parents[transform_index]);
 				}
 			}
 
@@ -336,17 +347,20 @@ namespace acl
 
 					rigid_shell_metadata_t& parent_shell = out_shell_metadata[parent_index];
 
-					if (shell_distance > parent_shell.local_shell_distance)
+					const float distance_to_parent = max_distance_to_parents[transform_index];
+					const float new_parent_shell_distance = shell_distance + distance_to_parent;
+					if (new_parent_shell_distance > parent_shell.local_shell_distance)
 					{
 						// We are the new dominant transform, use our shell distance and precision
-						parent_shell.local_shell_distance += shell_distance;
+						parent_shell.local_shell_distance = new_parent_shell_distance;
 						parent_shell.precision = transform_shell.precision;
 						parent_shell.dominant_transform_index = transform_shell.dominant_transform_index;
 					}
 				}
 			}
 
 			deallocate_type_array(allocator, object_transforms, num_transforms);
+			deallocate_type_array(allocator, max_distance_to_parents, num_transforms);
 		}
 
 		// We use the provided object space transforms to compute the rigid shell
@@ -365,6 +379,9 @@ namespace acl
 			const clip_context& owner_clip_context = *segment.clip;
 			const clip_topology_t* topology = owner_clip_context.topology;
 
+			float* max_distance_to_parents = allocate_type_array<float>(*segment.clip->allocator, num_transforms);
+			std::memset(max_distance_to_parents, 0, sizeof(float) * num_transforms);
+
 			// Initialize our output shell metadata
 			for (uint32_t transform_index = 0; transform_index < num_transforms; ++transform_index)
 			{
@@ -399,10 +416,11 @@ namespace acl
 						object_parent_position = object_pose_transforms[parent_index].translation;
 
 					const float distance_to_parent = rtm::vector_distance3(object_transform.translation, object_parent_position);
-					const float shell_distance = distance_to_parent + object_shell_distance;
 
 					rigid_shell_metadata_t& transform_shell_metadata = out_shell_metadata[transform_index];
-					transform_shell_metadata.local_shell_distance = rtm::scalar_max(shell_distance, transform_shell_metadata.local_shell_distance);
+					transform_shell_metadata.local_shell_distance = rtm::scalar_max(object_shell_distance, transform_shell_metadata.local_shell_distance);
+
+					max_distance_to_parents[transform_index] = rtm::scalar_max(distance_to_parent, max_distance_to_parents[transform_index]);
 				}
 			}
 
@@ -423,15 +441,19 @@ namespace acl
 
 					rigid_shell_metadata_t& parent_shell = out_shell_metadata[parent_index];
 
-					if (shell_distance > parent_shell.local_shell_distance)
+					const float distance_to_parent = max_distance_to_parents[transform_index];
+					const float new_parent_shell_distance = shell_distance + distance_to_parent;
+					if (new_parent_shell_distance > parent_shell.local_shell_distance)
 					{
 						// We are the new dominant transform, use our shell distance and precision
-						parent_shell.local_shell_distance += shell_distance;
+						parent_shell.local_shell_distance = new_parent_shell_distance;
 						parent_shell.precision = transform_shell.precision;
 						parent_shell.dominant_transform_index = transform_shell.dominant_transform_index;
 					}
 				}
 			}
+
+			deallocate_type_array(*segment.clip->allocator, max_distance_to_parents, num_transforms);
 		}
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -76,6 +76,9 @@ namespace acl`
`76`	`76`	`// retain the largest value. We then use this maximum value to compute our dominance.`
`77`	`77`
`78`	`78`	`rtm::qvvf* object_transforms = allocate_type_array<rtm::qvvf>(allocator, num_transforms);`
	`79`	`+ float* max_distance_to_parents = allocate_type_array<float>(allocator, num_transforms);`
	`80`	`+`
	`81`	`+ std::memset(max_distance_to_parents, 0, sizeof(float) * num_transforms);`
`79`	`82`
`80`	`83`	`// Our output buffer we'll return`
`81`	`84`	`rigid_shell_metadata_t* shell_metadata = allocate_type_array<rigid_shell_metadata_t>(allocator, num_transforms);`
`@@ -155,10 +158,11 @@ namespace acl`
`155`	`158`	`object_parent_position = object_transforms[parent_index].translation;`
`156`	`159`
`157`	`160`	`const float distance_to_parent = rtm::vector_distance3(object_transform.translation, object_parent_position);`
`158`		`- const float shell_distance = distance_to_parent + object_shell_distance;`
`159`	`161`
`160`	`162`	`rigid_shell_metadata_t& transform_shell_metadata = shell_metadata[transform_index];`
`161`		`- transform_shell_metadata.local_shell_distance = rtm::scalar_max(shell_distance, transform_shell_metadata.local_shell_distance);`
	`163`	`+ transform_shell_metadata.local_shell_distance = rtm::scalar_max(object_shell_distance, transform_shell_metadata.local_shell_distance);`
	`164`	`+`
	`165`	`+ max_distance_to_parents[transform_index] = rtm::scalar_max(distance_to_parent, max_distance_to_parents[transform_index]);`
`162`	`166`	`}`
`163`	`167`	`}`
`164`	`168`
`@@ -179,17 +183,20 @@ namespace acl`
`179`	`183`
`180`	`184`	`rigid_shell_metadata_t& parent_shell = shell_metadata[parent_index];`
`181`	`185`
`182`		`- if (shell_distance > parent_shell.local_shell_distance)`
	`186`	`+ const float distance_to_parent = max_distance_to_parents[transform_index];`
	`187`	`+ const float new_parent_shell_distance = shell_distance + distance_to_parent;`
	`188`	`+ if (new_parent_shell_distance > parent_shell.local_shell_distance)`
`183`	`189`	`{`
`184`	`190`	`// We are the new dominant transform, use our shell distance and precision`
`185`		`- parent_shell.local_shell_distance += shell_distance;`
	`191`	`+ parent_shell.local_shell_distance = new_parent_shell_distance;`
`186`	`192`	`parent_shell.precision = transform_shell.precision;`
`187`	`193`	`parent_shell.dominant_transform_index = transform_shell.dominant_transform_index;`
`188`	`194`	`}`
`189`	`195`	`}`
`190`	`196`	`}`
`191`	`197`
`192`	`198`	`deallocate_type_array(allocator, object_transforms, num_transforms);`
	`199`	`+ deallocate_type_array(allocator, max_distance_to_parents, num_transforms);`
`193`	`200`
`194`	`201`	`return shell_metadata;`
`195`	`202`	`}`
`@@ -223,6 +230,9 @@ namespace acl`
`223`	`230`	`// retain the largest value. We then use this maximum value to compute our dominance.`
`224`	`231`
`225`	`232`	`rtm::qvvf* object_transforms = allocate_type_array<rtm::qvvf>(allocator, num_transforms);`
	`233`	`+ float* max_distance_to_parents = allocate_type_array<float>(allocator, num_transforms);`
	`234`	`+`
	`235`	`+ std::memset(max_distance_to_parents, 0, sizeof(float) * num_transforms);`
`226`	`236`
`227`	`237`	`// Initialize our output shell metadata`
`228`	`238`	`for (uint32_t transform_index = 0; transform_index < num_transforms; ++transform_index)`
`@@ -312,10 +322,11 @@ namespace acl`
`312`	`322`	`object_parent_position = object_transforms[parent_index].translation;`
`313`	`323`
`314`	`324`	`const float distance_to_parent = rtm::vector_distance3(object_transform.translation, object_parent_position);`
`315`		`- const float shell_distance = distance_to_parent + object_shell_distance;`
`316`	`325`
`317`	`326`	`rigid_shell_metadata_t& transform_shell_metadata = out_shell_metadata[transform_index];`
`318`		`- transform_shell_metadata.local_shell_distance = rtm::scalar_max(shell_distance, transform_shell_metadata.local_shell_distance);`
	`327`	`+ transform_shell_metadata.local_shell_distance = rtm::scalar_max(object_shell_distance, transform_shell_metadata.local_shell_distance);`
	`328`	`+`
	`329`	`+ max_distance_to_parents[transform_index] = rtm::scalar_max(distance_to_parent, max_distance_to_parents[transform_index]);`
`319`	`330`	`}`
`320`	`331`	`}`
`321`	`332`
`@@ -336,17 +347,20 @@ namespace acl`
`336`	`347`
`337`	`348`	`rigid_shell_metadata_t& parent_shell = out_shell_metadata[parent_index];`
`338`	`349`
`339`		`- if (shell_distance > parent_shell.local_shell_distance)`
	`350`	`+ const float distance_to_parent = max_distance_to_parents[transform_index];`
	`351`	`+ const float new_parent_shell_distance = shell_distance + distance_to_parent;`
	`352`	`+ if (new_parent_shell_distance > parent_shell.local_shell_distance)`
`340`	`353`	`{`
`341`	`354`	`// We are the new dominant transform, use our shell distance and precision`
`342`		`- parent_shell.local_shell_distance += shell_distance;`
	`355`	`+ parent_shell.local_shell_distance = new_parent_shell_distance;`
`343`	`356`	`parent_shell.precision = transform_shell.precision;`
`344`	`357`	`parent_shell.dominant_transform_index = transform_shell.dominant_transform_index;`
`345`	`358`	`}`
`346`	`359`	`}`
`347`	`360`	`}`
`348`	`361`
`349`	`362`	`deallocate_type_array(allocator, object_transforms, num_transforms);`
	`363`	`+ deallocate_type_array(allocator, max_distance_to_parents, num_transforms);`
`350`	`364`	`}`
`351`	`365`
`352`	`366`	`// We use the provided object space transforms to compute the rigid shell`
`@@ -365,6 +379,9 @@ namespace acl`
`365`	`379`	`const clip_context& owner_clip_context = *segment.clip;`
`366`	`380`	`const clip_topology_t* topology = owner_clip_context.topology;`
`367`	`381`
	`382`	`+ float* max_distance_to_parents = allocate_type_array<float>(*segment.clip->allocator, num_transforms);`
	`383`	`+ std::memset(max_distance_to_parents, 0, sizeof(float) * num_transforms);`
	`384`	`+`
`368`	`385`	`// Initialize our output shell metadata`
`369`	`386`	`for (uint32_t transform_index = 0; transform_index < num_transforms; ++transform_index)`
`370`	`387`	`{`
`@@ -399,10 +416,11 @@ namespace acl`
`399`	`416`	`object_parent_position = object_pose_transforms[parent_index].translation;`
`400`	`417`
`401`	`418`	`const float distance_to_parent = rtm::vector_distance3(object_transform.translation, object_parent_position);`
`402`		`- const float shell_distance = distance_to_parent + object_shell_distance;`
`403`	`419`
`404`	`420`	`rigid_shell_metadata_t& transform_shell_metadata = out_shell_metadata[transform_index];`
`405`		`- transform_shell_metadata.local_shell_distance = rtm::scalar_max(shell_distance, transform_shell_metadata.local_shell_distance);`
	`421`	`+ transform_shell_metadata.local_shell_distance = rtm::scalar_max(object_shell_distance, transform_shell_metadata.local_shell_distance);`
	`422`	`+`
	`423`	`+ max_distance_to_parents[transform_index] = rtm::scalar_max(distance_to_parent, max_distance_to_parents[transform_index]);`
`406`	`424`	`}`
`407`	`425`	`}`
`408`	`426`
`@@ -423,15 +441,19 @@ namespace acl`
`423`	`441`
`424`	`442`	`rigid_shell_metadata_t& parent_shell = out_shell_metadata[parent_index];`
`425`	`443`
`426`		`- if (shell_distance > parent_shell.local_shell_distance)`
	`444`	`+ const float distance_to_parent = max_distance_to_parents[transform_index];`
	`445`	`+ const float new_parent_shell_distance = shell_distance + distance_to_parent;`
	`446`	`+ if (new_parent_shell_distance > parent_shell.local_shell_distance)`
`427`	`447`	`{`
`428`	`448`	`// We are the new dominant transform, use our shell distance and precision`
`429`		`- parent_shell.local_shell_distance += shell_distance;`
	`449`	`+ parent_shell.local_shell_distance = new_parent_shell_distance;`
`430`	`450`	`parent_shell.precision = transform_shell.precision;`
`431`	`451`	`parent_shell.dominant_transform_index = transform_shell.dominant_transform_index;`
`432`	`452`	`}`
`433`	`453`	`}`
`434`	`454`	`}`
	`455`	`+`
	`456`	`+ deallocate_type_array(*segment.clip->allocator, max_distance_to_parents, num_transforms);`
`435`	`457`	`}`
`436`	`458`	`}`
`437`	`459`