Merge pull request #1003 from zeux/meshletcodec

Implement experimental meshlet codec

Author: zeux

CMakeLists.txt

@@ -32,6 +32,7 @@ set(SOURCES
     src/indexanalyzer.cpp
     src/indexcodec.cpp
     src/indexgenerator.cpp
+    src/meshletcodec.cpp
     src/overdrawoptimizer.cpp
     src/partition.cpp
     src/quantization.cpp

Makefile

@@ -86,6 +86,10 @@ ifeq ($(config),coverage)
 	LDFLAGS+=-coverage
 endif
 
+ifeq ($(config),release-avx)
+	CXXFLAGS+=-O3 -DNDEBUG -mavx
+endif
+
 ifeq ($(config),release-avx512)
 	CXXFLAGS+=-O3 -DNDEBUG -mavx512vl -mavx512vbmi -mavx512vbmi2
 endif
@@ -227,7 +231,7 @@ codecbench-simd.wasm: tools/codecbench.cpp $(LIBRARY_SOURCES)
 codectest: tools/codectest.cpp $(LIBRARY)
 	$(CXX) $^ $(CXXFLAGS) $(LDFLAGS) -o $@
 
-codecfuzz: tools/codecfuzz.cpp src/vertexcodec.cpp src/indexcodec.cpp
+codecfuzz: tools/codecfuzz.cpp src/vertexcodec.cpp src/indexcodec.cpp src/meshletcodec.cpp
 	$(CXX) $^ -fsanitize=fuzzer,address,undefined -O1 -g -o $@
 
 clusterfuzz: tools/clusterfuzz.cpp src/clusterizer.cpp

demo/main.cpp

@@ -760,6 +760,118 @@ void encodeIndexSequence(const std::vector<unsigned int>& data, size_t vertex_co
 	    (double(result.size() * 4) / 1e9) / (end - middle));
 }
 
+void encodeMeshlets(const Mesh& mesh, size_t max_vertices, size_t max_triangles, bool reorder = true)
+{
+	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(mesh.indices.size());
+	std::vector<unsigned char> meshlet_triangles(mesh.indices.size());
+
+	meshlets.resize(meshopt_buildMeshlets(&meshlets[0], &meshlet_vertices[0], &meshlet_triangles[0], &mesh.indices[0], mesh.indices.size(), &mesh.vertices[0].px, mesh.vertices.size(), sizeof(Vertex), max_vertices, max_triangles, 0.f));
+
+	if (meshlets.size())
+	{
+		const meshopt_Meshlet& last = meshlets.back();
+
+		// this is an example of how to trim the vertex/triangle arrays when copying data out to GPU storage
+		meshlet_vertices.resize(last.vertex_offset + last.vertex_count);
+		meshlet_triangles.resize(last.triangle_offset + last.triangle_count * 3);
+
+		// TODO: over-allocate meshlet_vertices to multiple of 3 to make meshopt_optimizeVertexFetch below work without assertions
+		meshlet_vertices.resize((meshlet_vertices.size() + 2) / 3 * 3);
+	}
+
+	std::vector<unsigned char> cbuf(meshopt_encodeMeshletBound(max_vertices, max_triangles));
+
+	// optimize each meshlet for locality; this is important for performance, and critical for good compression
+	for (size_t i = 0; i < meshlets.size(); ++i)
+		meshopt_optimizeMeshlet(&meshlet_vertices[meshlets[i].vertex_offset], &meshlet_triangles[meshlets[i].triangle_offset], meshlets[i].triangle_count, meshlets[i].vertex_count);
+
+	// optimize the order of vertex references within each meshlet and globally; this is valuable for access locality and critical for compression of vertex references
+	// note that this reorders the vertex buffer too, so if a traditional index buffer is required it would need to be reconstructed from the meshlet data for optimal locality
+	std::vector<Vertex> vertices = mesh.vertices;
+	if (reorder)
+		meshopt_optimizeVertexFetch(&vertices[0], &meshlet_vertices[0], meshlet_vertices.size(), &mesh.vertices[0], mesh.vertices.size(), sizeof(Vertex));
+
+	size_t mbst = 0;
+
+	std::vector<unsigned char> packed;
+
+	for (size_t i = 0; i < meshlets.size(); ++i)
+	{
+		const meshopt_Meshlet& meshlet = meshlets[i];
+
+		size_t mbs = meshopt_encodeMeshlet(&cbuf[0], cbuf.size(), &meshlet_vertices[meshlet.vertex_offset], meshlet.vertex_count, &meshlet_triangles[meshlet.triangle_offset], meshlet.triangle_count);
+		assert(mbs > 0);
+
+		packed.push_back((unsigned char)meshlet.vertex_count);
+		packed.push_back((unsigned char)meshlet.triangle_count);
+		packed.push_back((unsigned char)(mbs & 0xff));
+		packed.push_back((unsigned char)((mbs >> 8) & 0xff));
+		packed.insert(packed.end(), &cbuf[0], &cbuf[mbs]);
+
+		unsigned int rv[256];
+		unsigned int rt[256];
+		int rc = meshopt_decodeMeshlet(rv, meshlet.vertex_count, rt, meshlet.triangle_count, &cbuf[0], mbs);
+		assert(rc == 0);
+
+		for (size_t j = 0; j < meshlet.vertex_count; ++j)
+			assert(rv[j] == meshlet_vertices[meshlet.vertex_offset + j]);
+
+		for (size_t j = 0; j < meshlet.triangle_count; ++j)
+		{
+			unsigned int a = meshlet_triangles[meshlet.triangle_offset + j * 3 + 0];
+			unsigned int b = meshlet_triangles[meshlet.triangle_offset + j * 3 + 1];
+			unsigned int c = meshlet_triangles[meshlet.triangle_offset + j * 3 + 2];
+
+			unsigned int abc = (a << 0) | (b << 8) | (c << 16);
+			unsigned int bca = (b << 0) | (c << 8) | (a << 16);
+			unsigned int cba = (c << 0) | (a << 8) | (b << 16);
+
+			assert(rt[j] == abc || rt[j] == bca || rt[j] == cba);
+		}
+
+		mbst += mbs;
+	}
+
+	size_t mbc = compress(packed);
+
+	printf("MeshletCodec (%d/%d): %d meshlets, %d bytes/meshlet; %d bytes, %.1f bits/triangle\n",
+	    int(max_vertices), int(max_triangles),
+	    int(meshlets.size()),
+	    int(mbst / meshlets.size()),
+	    int(mbst), double(mbst * 8) / double(mesh.indices.size() / 3));
+	printf("MeshletCodec (%d/%d, packed): %d bytes/meshlet, %.1f bits/triangle; post-deflate: %d bytes/meshlet, %.1f bits/triangle)\n",
+	    int(max_vertices), int(max_triangles),
+	    int(packed.size() / meshlets.size()), double(packed.size() * 8) / double(mesh.indices.size() / 3),
+	    int(mbc / meshlets.size()), double(mbc * 8) / double(mesh.indices.size() / 3));
+
+#if !TRACE
+	double mbtime = 0;
+
+	for (int i = 0; i < 10; ++i)
+	{
+		unsigned int rv[256];
+		unsigned int rt[256];
+		double t0 = timestamp();
+		unsigned char* p = &packed[0];
+		for (size_t j = 0; j < meshlets.size(); ++j)
+		{
+			size_t size = p[2] | (p[3] << 8);
+			meshopt_decodeMeshlet(rv, p[0], rt, p[1], p + 4, size);
+			p += 4 + size;
+		}
+		double t1 = timestamp();
+
+		mbtime = (mbtime == 0 || t1 - t0 < mbtime) ? (t1 - t0) : mbtime;
+	}
+
+	printf("MeshletCodec (%d/%d, packed): decode time %.3f msec, %.3fB tri/sec, %.1f ns/meshlet\n",
+	    int(max_vertices), int(max_triangles),
+	    mbtime * 1000, double(mesh.indices.size() / 3) / 1e9 / mbtime, mbtime * 1e9 / double(meshlets.size()));
+#endif
+}
+
 template <typename PV>
 void packVertex(const Mesh& mesh, const char* pvn)
 {
@@ -1425,6 +1537,8 @@ void process(const char* path)
 	encodeVertex<PackedVertex>(copy, "");
 	encodeVertex<PackedVertexOct>(copy, "O");
 
+	encodeMeshlets(mesh, 64, 96);
+
 	simplify(mesh);
 	simplify(mesh, 0.1f, meshopt_SimplifyPrune);
 	simplifyAttr(mesh);
@@ -1453,7 +1567,9 @@ void processDev(const char* path)
 	if (!loadMesh(mesh, path))
 		return;
 
-	simplifyUpdate(mesh, 0.1f, meshopt_SimplifyPrune | meshopt_SimplifyPermissive);
+	encodeMeshlets(mesh, 32, 48);
+	encodeMeshlets(mesh, 64, 64);
+	encodeMeshlets(mesh, 64, 96);
 }
 
 void processNanite(const char* path)

src/clusterizer.cpp

@@ -1743,6 +1743,55 @@ void meshopt_optimizeMeshlet(unsigned int* meshlet_vertices, unsigned char* mesh
 		cache[c] = cache_last;
 	}
 
+	// rotate triangles to maximize compressibility
+	memset(cache, 0, vertex_count);
+
+	for (size_t i = 0; i < triangle_count; ++i)
+	{
+		unsigned char a = indices[i * 3 + 0], b = indices[i * 3 + 1], c = indices[i * 3 + 2];
+
+		// if only the middle vertex has been used, rotate triangle to ensure new vertices are always sequential
+		if (!cache[a] && cache[b] && !cache[c])
+		{
+			// abc -> bca
+			unsigned char t = a;
+			a = b, b = c, c = t;
+		}
+		else if (!cache[a] && !cache[b] && !cache[c])
+		{
+			// out of three edges, the edge ab can not be reused by subsequent triangles in some encodings
+			// if subsequent triangles don't share edges ca or bc, we can rotate the triangle to fix this
+			bool needab = false, needbc = false, needca = false;
+
+			for (size_t j = i + 1; j < triangle_count && j <= i + cache_cutoff; ++j)
+			{
+				unsigned char oa = indices[j * 3 + 0], ob = indices[j * 3 + 1], oc = indices[j * 3 + 2];
+
+				// note: edge comparisons are reversed as reused edges are flipped
+				needab |= (oa == b && ob == a) || (ob == b && oc == a) || (oc == b && oa == a);
+				needbc |= (oa == c && ob == b) || (ob == c && oc == b) || (oc == c && oa == b);
+				needca |= (oa == a && ob == c) || (ob == a && oc == c) || (oc == a && oa == c);
+			}
+
+			if (needab && !needbc)
+			{
+				// abc -> bca
+				unsigned char t = a;
+				a = b, b = c, c = t;
+			}
+			else if (needab && !needca)
+			{
+				// abc -> cab
+				unsigned char t = c;
+				c = b, b = a, a = t;
+			}
+		}
+
+		indices[i * 3 + 0] = a, indices[i * 3 + 1] = b, indices[i * 3 + 2] = c;
+
+		cache[a] = cache[b] = cache[c] = 1;
+	}
+
 	// reorder meshlet vertices for access locality assuming index buffer is scanned sequentially
 	unsigned int order[kMeshletMaxVertices];
 

src/indexcodec.cpp

@@ -19,12 +19,6 @@ const int kDecodeIndexVersion = 1;
 typedef unsigned int VertexFifo[16];
 typedef unsigned int EdgeFifo[16][2];
 
-static const unsigned int kTriangleIndexOrder[3][3] = {
-    {0, 1, 2},
-    {1, 2, 0},
-    {2, 0, 1},
-};
-
 static const unsigned char kCodeAuxEncodingTable[16] = {
     0x00, 0x76, 0x87, 0x56, 0x67, 0x78, 0xa9, 0x86, 0x65, 0x89, 0x68, 0x98, 0x01, 0x69,
     0, 0, // last two entries aren't used for encoding
@@ -194,6 +188,8 @@ size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, cons
 
 	int fecmax = version >= 1 ? 13 : 15;
 
+	static const int rotations[] = {0, 1, 2, 0, 1};
+
 	// use static encoding table; it's possible to pack the result and then build an optimal table and repack
 	// for now we keep it simple and use the table that has been generated based on symbol frequency on a training mesh set
 	const unsigned char* codeaux_table = kCodeAuxEncodingTable;
@@ -211,7 +207,7 @@ size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, cons
 		if (fer >= 0 && (fer >> 2) < 15)
 		{
 			// note: getEdgeFifo implicitly rotates triangles by matching a/b to existing edge
-			const unsigned int* order = kTriangleIndexOrder[fer & 3];
+			const int* order = rotations + (fer & 3);
 
 			unsigned int a = indices[i + order[0]], b = indices[i + order[1]], c = indices[i + order[2]];
 
@@ -247,7 +243,7 @@ size_t meshopt_encodeIndexBuffer(unsigned char* buffer, size_t buffer_size, cons
 		else
 		{
 			int rotation = rotateTriangle(indices[i + 0], indices[i + 1], indices[i + 2], next);
-			const unsigned int* order = kTriangleIndexOrder[rotation];
+			const int* order = rotations + rotation;
 
 			unsigned int a = indices[i + order[0]], b = indices[i + order[1]], c = indices[i + order[2]];