Merge pull request #841 from zeux/partition

Experimental cluster partitioning

Author: zeux

CMakeLists.txt

@@ -29,6 +29,7 @@ set(SOURCES
     src/indexgenerator.cpp
     src/overdrawanalyzer.cpp
     src/overdrawoptimizer.cpp
+    src/partition.cpp
     src/quantization.cpp
     src/simplifier.cpp
     src/spatialorder.cpp

demo/main.cpp

@@ -657,12 +657,13 @@ void simplifyComplete(const Mesh& mesh)
 
 void simplifyClusters(const Mesh& mesh, float threshold = 0.2f)
 {
-	// note: we use clusters that are larger than normal to give simplifier room to work; in practice you'd use cluster groups merged from smaller clusters and build a cluster DAG
-	const size_t max_vertices = 255;
-	const size_t max_triangles = 512;
+	const size_t max_vertices = 64;
+	const size_t max_triangles = 64;
+	const size_t target_group_size = 8;
 
 	double start = timestamp();
 
+	// build clusters (meshlets) out of the mesh
 	size_t max_meshlets = meshopt_buildMeshletsBound(mesh.indices.size(), max_vertices, max_triangles);
 	std::vector<meshopt_Meshlet> meshlets(max_meshlets);
 	std::vector<unsigned int> meshlet_vertices(max_meshlets * max_vertices);
@@ -672,6 +673,44 @@ void simplifyClusters(const Mesh& mesh, float threshold = 0.2f)
 
 	double middle = timestamp();
 
+	// partition clusters in groups; each group will be simplified separately and the boundaries between groups will be preserved
+	std::vector<unsigned int> cluster_indices;
+	cluster_indices.reserve(mesh.indices.size()); // slight underestimate, vector should realloc once
+	std::vector<unsigned int> cluster_sizes(meshlets.size());
+
+	for (size_t i = 0; i < meshlets.size(); ++i)
+	{
+		const meshopt_Meshlet& m = meshlets[i];
+
+		for (size_t j = 0; j < m.triangle_count * 3; ++j)
+			cluster_indices.push_back(meshlet_vertices[m.vertex_offset + meshlet_triangles[m.triangle_offset + j]]);
+
+		cluster_sizes[i] = m.triangle_count * 3;
+	}
+
+	// makes sure clusters are partitioned using position-only adjacency
+	meshopt_generateShadowIndexBuffer(&cluster_indices[0], &cluster_indices[0], cluster_indices.size(), &mesh.vertices[0].px, mesh.vertices.size(), sizeof(float) * 3, sizeof(Vertex));
+
+	std::vector<unsigned int> partition(meshlets.size());
+	size_t partition_count = meshopt_partitionClusters(&partition[0], &cluster_indices[0], cluster_indices.size(), &cluster_sizes[0], cluster_sizes.size(), mesh.vertices.size(), target_group_size);
+
+	// convert partitions to linked lists to make it easier to iterate over (vectors of vectors would work too)
+	std::vector<int> partnext(meshlets.size(), -1);
+	std::vector<int> partlast(partition_count, -1);
+
+	for (size_t i = 0; i < meshlets.size(); ++i)
+	{
+		unsigned int part = partition[i];
+
+		if (partlast[part] >= 0)
+			partnext[partlast[part]] = int(i);
+
+		partlast[part] = int(i);
+		partnext[i] = -1;
+	}
+
+	double parttime = timestamp();
+
 	float scale = meshopt_simplifyScale(&mesh.vertices[0].px, mesh.vertices.size(), sizeof(Vertex));
 
 	std::vector<unsigned int> lod;
@@ -681,33 +720,47 @@ void simplifyClusters(const Mesh& mesh, float threshold = 0.2f)
 
 	for (size_t i = 0; i < meshlets.size(); ++i)
 	{
-		const meshopt_Meshlet& m = meshlets[i];
+		if (partlast[partition[i]] < 0)
+			continue; // part of a group that was already processed
 
-		size_t cluster_offset = lod.size();
+		// mark group as processed
+		partlast[partition[i]] = -1;
 
-		for (size_t j = 0; j < m.triangle_count * 3; ++j)
-			lod.push_back(meshlet_vertices[m.vertex_offset + meshlet_triangles[m.triangle_offset + j]]);
+		size_t group_offset = lod.size();
+
+		for (int j = int(i); j >= 0; j = partnext[j])
+		{
+			const meshopt_Meshlet& m = meshlets[j];
+
+			for (size_t k = 0; k < m.triangle_count * 3; ++k)
+				lod.push_back(meshlet_vertices[m.vertex_offset + meshlet_triangles[m.triangle_offset + k]]);
+		}
+
+		size_t group_triangles = (lod.size() - group_offset) / 3;
 
+		// simplify the group, preserving the border vertices
+		// note: this technically also locks the exterior border; a full mesh analysis (see nanite.cpp / lockBoundary) would work better for some meshes
 		unsigned int options = meshopt_SimplifyLockBorder | meshopt_SimplifySparse | meshopt_SimplifyErrorAbsolute;
 
-		float cluster_target_error = 1e-2f * scale;
-		size_t cluster_target = size_t(float(m.triangle_count) * threshold) * 3;
-		float cluster_error = 0.f;
-		size_t cluster_size = meshopt_simplify(&lod[cluster_offset], &lod[cluster_offset], m.triangle_count * 3, &mesh.vertices[0].px, mesh.vertices.size(), sizeof(Vertex), cluster_target, cluster_target_error, options, &cluster_error);
+		float group_target_error = 1e-2f * scale;
+		size_t group_target = size_t(float(group_triangles) * threshold) * 3;
+		float group_error = 0.f;
+		size_t group_size = meshopt_simplify(&lod[group_offset], &lod[group_offset], group_triangles * 3, &mesh.vertices[0].px, mesh.vertices.size(), sizeof(Vertex), group_target, group_target_error, options, &group_error);
 
-		error = cluster_error > error ? cluster_error : error;
+		error = group_error > error ? group_error : error;
 
-		// simplified cluster is available in lod[cluster_offset..cluster_offset + cluster_size]
-		lod.resize(cluster_offset + cluster_size);
+		// simplified group is available in lod[group_offset..group_offset + group_size]
+		lod.resize(group_offset + group_size);
 	}
 
 	double end = timestamp();
 
-	printf("%-9s: %d triangles => %d triangles (%.2f%% deviation) in %.2f msec, clusterized in %.2f msec\n",
+	printf("%-9s: %d triangles => %d triangles (%.2f%% deviation) in %.2f msec, clusterized in %.2f msec, partitioned in %.2f msec (%d clusters in %d groups)\n",
 	    "SimplifyN", // N for Nanite
 	    int(mesh.indices.size() / 3), int(lod.size() / 3),
 	    error / scale * 100,
-	    (end - middle) * 1000, (middle - start) * 1000);
+	    (end - parttime) * 1000, (middle - start) * 1000, (parttime - middle) * 1000,
+	    int(meshlets.size()), int(partition_count));
 }
 
 void optimize(const Mesh& mesh, const char* name, void (*optf)(Mesh& mesh))
@@ -1402,7 +1455,7 @@ void processDev(const char* path)
 	if (!loadMesh(mesh, path))
 		return;
 
-	meshlets(mesh);
+	simplifyClusters(mesh, 0.2f);
 }
 
 void processNanite(const char* path)

demo/nanite.cpp

@@ -349,26 +349,36 @@ static std::vector<std::vector<int> > partition(const std::vector<Cluster>& clus
 	if (METIS & 1)
 		return partitionMetis(clusters, pending, remap);
 
-	(void)remap;
+	std::vector<unsigned int> cluster_indices;
+	std::vector<unsigned int> cluster_counts(pending.size());
 
-	std::vector<std::vector<int> > result;
+	size_t total_index_count = 0;
+	for (size_t i = 0; i < pending.size(); ++i)
+		total_index_count += clusters[pending[i]].indices.size();
 
-	size_t last_indices = 0;
+	cluster_indices.reserve(total_index_count);
 
-	// rough merge; while clusters are approximately spatially ordered, this should use a proper partitioning algorithm
 	for (size_t i = 0; i < pending.size(); ++i)
 	{
-		if (result.empty() || last_indices + clusters[pending[i]].indices.size() > kClusterSize * kGroupSize * 3)
-		{
-			result.push_back(std::vector<int>());
-			last_indices = 0;
-		}
+		const Cluster& cluster = clusters[pending[i]];
+
+		cluster_counts[i] = unsigned(cluster.indices.size());
 
-		result.back().push_back(pending[i]);
-		last_indices += clusters[pending[i]].indices.size();
+		for (size_t j = 0; j < cluster.indices.size(); ++j)
+			cluster_indices.push_back(remap[cluster.indices[j]]);
 	}
 
-	return result;
+	std::vector<unsigned int> cluster_part(pending.size());
+	size_t partition_count = meshopt_partitionClusters(&cluster_part[0], &cluster_indices[0], cluster_indices.size(), &cluster_counts[0], cluster_counts.size(), remap.size(), kGroupSize);
+
+	std::vector<std::vector<int> > partitions(partition_count);
+	for (size_t i = 0; i < partition_count; ++i)
+		partitions[i].reserve(kGroupSize + 4);
+
+	for (size_t i = 0; i < pending.size(); ++i)
+		partitions[cluster_part[i]].push_back(pending[i]);
+
+	return partitions;
 }
 
 static void lockBoundary(std::vector<unsigned char>& locks, const std::vector<std::vector<int> >& groups, const std::vector<Cluster>& clusters, const std::vector<unsigned int>& remap)
@@ -481,7 +491,7 @@ static int measureUnique(std::vector<int>& used, const std::vector<unsigned int>
 	for (size_t i = 0; i < indices.size(); ++i)
 	{
 		unsigned int v = indices[i];
-		vertices += used[v] && (!locks || !(*locks)[v]);
+		vertices += used[v] && (!locks || (*locks)[v]);
 		used[v] = 0;
 	}
 

demo/tests.cpp

@@ -1084,6 +1084,33 @@ static void meshletsSparse()
 	assert(memcmp(tri1, ibd + 3, 3 * sizeof(unsigned int)) == 0);
 }
 
+static void partitionBasic()
+{
+	// 0   1   2
+	//     3
+	// 4 5 6 7 8
+	//     9
+	// 10 11  12
+	const unsigned int ci[] = {
+	    0, 1, 3, 4, 5, 6,   //
+	    1, 2, 3, 6, 7, 8,   //
+	    4, 5, 6, 9, 10, 11, //
+	    6, 7, 8, 9, 11, 12, //
+	};
+
+	const unsigned int cc[4] = {6, 6, 6, 6};
+	unsigned int part[4];
+
+	assert(meshopt_partitionClusters(part, ci, sizeof(ci) / sizeof(ci[0]), cc, 4, 13, 1) == 4);
+	assert(part[0] == 0 && part[1] == 1 && part[2] == 2 && part[3] == 3);
+
+	assert(meshopt_partitionClusters(part, ci, sizeof(ci) / sizeof(ci[0]), cc, 4, 13, 2) == 2);
+	assert(part[0] == 0 && part[1] == 0 && part[2] == 1 && part[3] == 1);
+
+	assert(meshopt_partitionClusters(part, ci, sizeof(ci) / sizeof(ci[0]), cc, 4, 13, 4) == 1);
+	assert(part[0] == 0 && part[1] == 0 && part[2] == 0 && part[3] == 0);
+}
+
 static size_t allocCount;
 static size_t freeCount;
 
@@ -2142,6 +2169,8 @@ void runTests()
 	meshletsDense();
 	meshletsSparse();
 
+	partitionBasic();
+
 	customAllocator();
 
 	emptyMesh();

src/meshoptimizer.h

@@ -589,6 +589,18 @@ struct meshopt_Bounds
 MESHOPTIMIZER_API struct meshopt_Bounds meshopt_computeClusterBounds(const unsigned int* indices, size_t index_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
 MESHOPTIMIZER_API struct meshopt_Bounds meshopt_computeMeshletBounds(const unsigned int* meshlet_vertices, const unsigned char* meshlet_triangles, size_t triangle_count, const float* vertex_positions, size_t vertex_count, size_t vertex_positions_stride);
 
+/**
+ * Experimental: Cluster partitioner
+ * Partitions clusters into groups of similar size, prioritizing grouping clusters that share vertices.
+ *
+ * destination must contain enough space for the resulting partiotion data (cluster_count elements)
+ * destination[i] will contain the partition id for cluster i, with the total number of partitions returned by the function
+ * cluster_indices should have the vertex indices referenced by each cluster, stored sequentially
+ * cluster_index_counts should have the number of indices in each cluster; sum of all cluster_index_counts must be equal to total_index_count
+ * target_partition_size is a target size for each partition, in clusters; the resulting partitions may be smaller or larger
+ */
+MESHOPTIMIZER_EXPERIMENTAL size_t meshopt_partitionClusters(unsigned int* destination, const unsigned int* cluster_indices, size_t total_index_count, const unsigned int* cluster_index_counts, size_t cluster_count, size_t vertex_count, size_t target_partition_size);
+
 /**
  * Spatial sorter
  * Generates a remap table that can be used to reorder points for spatial locality.