simplifier: Use parallel collapses for complex vertices based on loops

Collapsing all wedges into a single wedge for complex-complex collapses
is simple but results in high-error collapses alongside attribute
discontinuities. This is a problem because it either results in poor
attribute quality, or in poor geometric quality elsewhere as the
simplifier is forced to look for lower error collapses.

This change instead adjusts complex collapses to use parallel collapses
if possible: wedges are collapsed individually towards different wedges
along the original edges. This makes complex collapses work similarly to
seam collapses if possible.

To implement this without extra performance issues, we use loop
metadata. Because loops are really tracking a single incoming/outgoing
half-edge in the original (unwelded) topology, a typical attribute
discontinuity will have X wedges (seams only have 2), and each of the
wedges will have their own loop/loopback that correctly trace the
adjoining triangle boundary. Thus we can use these to guide the
collapses.

In some complex topological situations this may not always find the
correct wedge target, but fundamentally complex-complex collapses may
*not* have a correct wedge target in all cases (if a discontinuity has 3
wedges then any collapse will have to collapse one of them onto a wedge
that was not connected to the original). In the future we could use
error or position patching to resolve these cases but that requires
invasive changes with potentially problematic consequences, whereas
using loop metadata should be cheap and safe.

This has no effect on performance on most meshes (and no effect unless
permissive mode is used); on meshes where almost every vertex is
complex, this costs under 10% performance but results in much better
quality. In general, after this "soft" protection like normal creases is
mostly unnecessary because the simplifier will do the right thing while
it's possible. Protecting UV edges may still be important to avoid UV
distortion, although even without UV protection the quality can remain
quite high if the UVs are weighted properly.

Author: zeux

src/simplifier.cpp

@@ -367,8 +367,8 @@ static void classifyVertices(unsigned char* result, unsigned int* loop, unsigned
 	memset(loopback, -1, vertex_count * sizeof(unsigned int));
 
 	// incoming & outgoing open edges: ~0u if no open edges, i if there are more than 1
-	// note that this is the same data as required in loop[] arrays; loop[] data is only valid for border/seam
-	// but here it's okay to fill the data out for other types of vertices as well
+	// note that this is the same data as required in loop[] arrays; loop[] data is only used for border/seam by default
+	// in permissive mode we also use it to guide complex-complex collapses, so we fill it for all vertices
 	unsigned int* openinc = loopback;
 	unsigned int* openout = loop;
 
@@ -1271,6 +1271,20 @@ static float getNeighborhoodRadius(const EdgeAdjacency& adjacency, const Vector3
 	return sqrtf(result);
 }
 
+static unsigned int getComplexTarget(unsigned int v, unsigned int target, const unsigned int* remap, const unsigned int* loop, const unsigned int* loopback)
+{
+	unsigned int r = remap[target];
+
+	// use loop metadata to guide complex collapses towards the correct wedge
+	// this works for edges on attribute discontinuities because loop/loopback track the single half-edge without a pair, similar to seams
+	if (loop[v] != ~0u && remap[loop[v]] == r)
+		return loop[v];
+	else if (loopback[v] != ~0u && remap[loopback[v]] == r)
+		return loopback[v];
+	else
+		return target;
+}
+
 static size_t boundEdgeCollapses(const EdgeAdjacency& adjacency, size_t vertex_count, size_t index_count, unsigned char* vertex_kind)
 {
 	size_t dual_count = 0;
@@ -1393,15 +1407,22 @@ static void rankEdgeCollapses(Collapse* collapses, size_t collapse_count, const
 			}
 			else
 			{
-				// complex edges can have multiple wedges, so we need to aggregate errors for all wedges
-				// this is different from seams (where we aggregate pairwise) because all wedges collapse onto the same target
+				// complex edges can have multiple wedges, so we need to aggregate errors for all wedges based on the selected target
 				if (vertex_kind[i0] == Kind_Complex)
 					for (unsigned int v = wedge[i0]; v != i0; v = wedge[v])
-						ei += quadricError(attribute_quadrics[v], &attribute_gradients[v * attribute_count], attribute_count, vertex_positions[i1], &vertex_attributes[i1 * attribute_count]);
+					{
+						unsigned int t = getComplexTarget(v, i1, remap, loop, loopback);
+
+						ei += quadricError(attribute_quadrics[v], &attribute_gradients[v * attribute_count], attribute_count, vertex_positions[t], &vertex_attributes[t * attribute_count]);
+					}
 
 				if (vertex_kind[i1] == Kind_Complex && bidi)
 					for (unsigned int v = wedge[i1]; v != i1; v = wedge[v])
-						ej += quadricError(attribute_quadrics[v], &attribute_gradients[v * attribute_count], attribute_count, vertex_positions[i0], &vertex_attributes[i0 * attribute_count]);
+					{
+						unsigned int t = getComplexTarget(v, i0, remap, loop, loopback);
+
+						ej += quadricError(attribute_quadrics[v], &attribute_gradients[v * attribute_count], attribute_count, vertex_positions[t], &vertex_attributes[t * attribute_count]);
+					}
 			}
 		}
 
@@ -1553,7 +1574,9 @@ static size_t performEdgeCollapses(unsigned int* collapse_remap, unsigned char*
 
 			do
 			{
-				collapse_remap[v] = i1;
+				unsigned int t = getComplexTarget(v, i1, remap, loop, loopback);
+
+				collapse_remap[v] = t;
 				v = wedge[v];
 			} while (v != i0);
 		}