Merge pull request #1103 from zeux/perftune

Assorted performance improvements

Author: zeux

src/clusterizer.cpp

@@ -560,9 +560,12 @@ static size_t kdtreeBuild(size_t offset, KDNode* nodes, size_t node_count, const
 	float split = mean[axis];
 	size_t middle = kdtreePartition(indices, count, points, stride, axis, split);
 
-	// when the partition is degenerate simply consolidate the points into a single node
-	// this also ensures recursion depth is bounded on pathological inputs
-	if (middle <= leaf_size / 2 || middle >= count - leaf_size / 2 || depth >= kMeshletMaxTreeDepth)
+	// when the partition is degenerate, consolidate the points into a single node; also ensure recursion depth is bounded on pathological inputs
+	if (middle == 0 || middle == count || depth >= kMeshletMaxTreeDepth)
+		return kdtreeBuildLeaf(offset, nodes, node_count, indices, count);
+
+	// when the partition is unbalanced, consolidate the points into a single small node; large nodes are still split to prevent outlier points from creating very large leaves
+	if ((middle <= leaf_size / 2 || middle >= count - leaf_size / 2) && count <= leaf_size * 8)
 		return kdtreeBuildLeaf(offset, nodes, node_count, indices, count);
 
 	KDNode& result = nodes[offset];

src/indexcodec.cpp

@@ -33,18 +33,23 @@ static int rotateTriangle(unsigned int a, unsigned int b, unsigned int c, unsign
 
 static int getEdgeFifo(EdgeFifo fifo, unsigned int a, unsigned int b, unsigned int c, size_t offset)
 {
+	unsigned long long ab = ((unsigned long long)a << 32) | b;
+	unsigned long long bc = ((unsigned long long)b << 32) | c;
+	unsigned long long ca = ((unsigned long long)c << 32) | a;
+
 	for (int i = 0; i < 16; ++i)
 	{
 		size_t index = (offset - 1 - i) & 15;
 
 		unsigned int e0 = fifo[index][0];
 		unsigned int e1 = fifo[index][1];
+		unsigned long long e = ((unsigned long long)e0 << 32) | e1;
 
-		if (e0 == a && e1 == b)
+		if (e == ab)
 			return (i << 2) | 0;
-		if (e0 == b && e1 == c)
+		if (e == bc)
 			return (i << 2) | 1;
-		if (e0 == c && e1 == a)
+		if (e == ca)
 			return (i << 2) | 2;
 	}
 

src/meshletutils.cpp

@@ -19,7 +19,8 @@ const size_t kMeshletMaxVertices = 256;
 // A reasonable limit is around 2*max_vertices or less
 const size_t kMeshletMaxTriangles = 512;
 
-static void computeBoundingSphere(float result[4], const float* points, size_t count, size_t points_stride, const float* radii, size_t radii_stride, size_t axis_count, const unsigned int* indices = NULL)
+template <int Axes>
+static void computeBoundingSphere(float result[4], const float* points, size_t count, size_t points_stride, const float* radii, size_t radii_stride, const unsigned int* indices = NULL)
 {
 	static const float axes[7][3] = {
 	    // X, Y, Z
@@ -35,7 +36,7 @@ static void computeBoundingSphere(float result[4], const float* points, size_t c
 	};
 
 	assert(count > 0);
-	assert(axis_count <= sizeof(axes) / sizeof(axes[0]));
+	assert(size_t(Axes) <= sizeof(axes) / sizeof(axes[0]));
 
 	size_t points_stride_float = points_stride / sizeof(float);
 	size_t radii_stride_float = radii_stride / sizeof(float);
@@ -44,7 +45,7 @@ static void computeBoundingSphere(float result[4], const float* points, size_t c
 	unsigned int pmin[7], pmax[7];
 	float tmin[7], tmax[7];
 
-	for (size_t axis = 0; axis < axis_count; ++axis)
+	for (int axis = 0; axis < Axes; ++axis)
 	{
 		pmin[axis] = pmax[axis] = 0;
 		tmin[axis] = FLT_MAX;
@@ -57,7 +58,7 @@ static void computeBoundingSphere(float result[4], const float* points, size_t c
 		const float* p = points + v * points_stride_float;
 		float r = radii[v * radii_stride_float];
 
-		for (size_t axis = 0; axis < axis_count; ++axis)
+		for (int axis = 0; axis < Axes; ++axis)
 		{
 			const float* ax = axes[axis];
 
@@ -75,7 +76,7 @@ static void computeBoundingSphere(float result[4], const float* points, size_t c
 	size_t paxis = 0;
 	float paxisdr = 0;
 
-	for (size_t axis = 0; axis < axis_count; ++axis)
+	for (int axis = 0; axis < Axes; ++axis)
 	{
 		const float* p1 = points + pmin[axis] * points_stride_float;
 		const float* p2 = points + pmax[axis] * points_stride_float;
@@ -182,13 +183,13 @@ static meshopt_Bounds computeClusterBounds(const unsigned int* indices, size_t i
 
 	// compute cluster bounding sphere; we'll use the center to determine normal cone apex as well
 	float psphere[4] = {};
-	computeBoundingSphere(psphere, vertex_positions, corner_count, vertex_positions_stride, &rzero, 0, 7, corners);
+	computeBoundingSphere<7>(psphere, vertex_positions, corner_count, vertex_positions_stride, &rzero, 0, corners);
 
 	float center[3] = {psphere[0], psphere[1], psphere[2]};
 
 	// treating triangle normals as points, find the bounding sphere - the sphere center determines the optimal cone axis
 	float nsphere[4] = {};
-	computeBoundingSphere(nsphere, normals[0], triangles, sizeof(float) * 4, &rzero, 0, 3);
+	computeBoundingSphere<3>(nsphere, normals[0], triangles, sizeof(float) * 4, &rzero, 0);
 
 	float axis[3] = {nsphere[0], nsphere[1], nsphere[2]};
 	float axislength = sqrtf(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]);
@@ -353,7 +354,7 @@ meshopt_Bounds meshopt_computeSphereBounds(const float* positions, size_t count,
 	const float rzero = 0.f;
 
 	float psphere[4] = {};
-	computeBoundingSphere(psphere, positions, count, positions_stride, radii ? radii : &rzero, radii ? radii_stride : 0, 7);
+	computeBoundingSphere<7>(psphere, positions, count, positions_stride, radii ? radii : &rzero, radii ? radii_stride : 0);
 
 	bounds.center[0] = psphere[0];
 	bounds.center[1] = psphere[1];