Merge pull request #966 from zeux/gltf-khr

gltfpack: Introduce support for KHR_meshopt_compression

Author: zeux

extern/cgltf.h

@@ -296,6 +296,7 @@ typedef enum cgltf_meshopt_compression_filter {
 	cgltf_meshopt_compression_filter_octahedral,
 	cgltf_meshopt_compression_filter_quaternion,
 	cgltf_meshopt_compression_filter_exponential,
+	cgltf_meshopt_compression_filter_color,
 	cgltf_meshopt_compression_filter_max_enum
 } cgltf_meshopt_compression_filter;
 
@@ -308,6 +309,7 @@ typedef struct cgltf_meshopt_compression
 	cgltf_size count;
 	cgltf_meshopt_compression_mode mode;
 	cgltf_meshopt_compression_filter filter;
+	cgltf_bool is_khr;
 } cgltf_meshopt_compression;
 
 typedef struct cgltf_buffer_view
@@ -1658,8 +1660,8 @@ cgltf_result cgltf_validate(cgltf_data* data)
 			CGLTF_ASSERT_IF((mc->mode == cgltf_meshopt_compression_mode_triangles || mc->mode == cgltf_meshopt_compression_mode_indices) && mc->filter != cgltf_meshopt_compression_filter_none, cgltf_result_invalid_gltf);
 
 			CGLTF_ASSERT_IF(mc->filter == cgltf_meshopt_compression_filter_octahedral && mc->stride != 4 && mc->stride != 8, cgltf_result_invalid_gltf);
-
 			CGLTF_ASSERT_IF(mc->filter == cgltf_meshopt_compression_filter_quaternion && mc->stride != 8, cgltf_result_invalid_gltf);
+			CGLTF_ASSERT_IF(mc->filter == cgltf_meshopt_compression_filter_color && mc->stride != 4 && mc->stride != 8, cgltf_result_invalid_gltf);
 		}
 	}
 
@@ -5104,6 +5106,10 @@ static int cgltf_parse_json_meshopt_compression(cgltf_options* options, jsmntok_
 			{
 				out_meshopt_compression->filter = cgltf_meshopt_compression_filter_exponential;
 			}
+			else if (cgltf_json_strcmp(tokens+i, json_chunk, "COLOR") == 0)
+			{
+				out_meshopt_compression->filter = cgltf_meshopt_compression_filter_color;
+			}
 			++i;
 		}
 		else
@@ -5214,6 +5220,12 @@ static int cgltf_parse_json_buffer_view(cgltf_options* options, jsmntok_t const*
 					out_buffer_view->has_meshopt_compression = 1;
 					i = cgltf_parse_json_meshopt_compression(options, tokens, i + 1, json_chunk, &out_buffer_view->meshopt_compression);
 				}
+				else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_meshopt_compression") == 0)
+				{
+					out_buffer_view->has_meshopt_compression = 1;
+					out_buffer_view->meshopt_compression.is_khr = 1;
+					i = cgltf_parse_json_meshopt_compression(options, tokens, i + 1, json_chunk, &out_buffer_view->meshopt_compression);
+				}
 				else
 				{
 					i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_buffer_view->extensions[out_buffer_view->extensions_count++]));

gltf/gltfpack.cpp

@@ -23,7 +23,7 @@ std::string getVersion()
 	return result;
 }
 
-static void finalizeBufferViews(std::string& json, std::vector<BufferView>& views, std::string& bin, std::string* fallback, size_t& fallback_size, const char* meshopt_ext)
+static void finalizeBufferViews(std::string& json, std::vector<BufferView>& views, std::string& bin, std::string* fallback, size_t& fallback_size, const char* meshopt_ext, int attribute_level)
 {
 	for (size_t i = 0; i < views.size(); ++i)
 	{
@@ -43,7 +43,7 @@ static void finalizeBufferViews(std::string& json, std::vector<BufferView>& view
 			switch (view.compression)
 			{
 			case BufferView::Compression_Attribute:
-				compressVertexStream(bin, view.data, count, view.stride);
+				compressVertexStream(bin, view.data, count, view.stride, attribute_level);
 				break;
 			case BufferView::Compression_Index:
 				compressIndexStream(bin, view.data, count, view.stride);
@@ -885,7 +885,7 @@ static size_t process(cgltf_data* data, const char* input_path, const char* outp
 	size_t bufferspec_pos = json.size();
 
 	std::string json_views;
-	finalizeBufferViews(json_views, views, bin, settings.fallback ? &fallback : NULL, fallback_size, meshopt_ext);
+	finalizeBufferViews(json_views, views, bin, settings.fallback ? &fallback : NULL, fallback_size, meshopt_ext, settings.compresskhr ? (settings.compressmore ? 3 : 2) : 0);
 
 	writeArray(json, "bufferViews", json_views);
 	writeArray(json, "accessors", json_accessors);
@@ -1106,7 +1106,7 @@ int gltfpack(const char* input, const char* output, const char* report, Settings
 		}
 	}
 
-	const char* meshopt_ext = settings.compressexp ? "EXTX_meshopt_compression" : "EXT_meshopt_compression";
+	const char* meshopt_ext = settings.compresskhr ? "KHR_meshopt_compression" : "EXT_meshopt_compression";
 
 	std::string json, bin, fallback;
 	size_t fallback_size = 0;
@@ -1559,13 +1559,16 @@ int main(int argc, char** argv)
 			settings.compress = true;
 			settings.fallback = true;
 		}
-		else if (strcmp(arg, "-cx") == 0)
+		else if (strcmp(arg, "-cz") == 0)
 		{
-			fprintf(stderr, "Warning: experimental compression will produce files that are not compliant with EXT_meshopt_compression\n");
-			meshopt_encodeVertexVersion(1);
 			settings.compress = true;
 			settings.compressmore = true;
-			settings.compressexp = true;
+			settings.compresskhr = true;
+		}
+		else if (strcmp(arg, "-ce") == 0 && i + 1 < argc && (strcmp(argv[i + 1], "khr") == 0 || strcmp(argv[i + 1], "ext") == 0))
+		{
+			settings.compress = true;
+			settings.compresskhr = strcmp(argv[++i], "khr") == 0;
 		}
 		else if (strcmp(arg, "-v") == 0)
 		{
@@ -1629,7 +1632,7 @@ int main(int argc, char** argv)
 			fprintf(stderr, "\nBasics:\n");
 			fprintf(stderr, "\t-i file: input file to process, .obj/.gltf/.glb\n");
 			fprintf(stderr, "\t-o file: output file path, .gltf/.glb\n");
-			fprintf(stderr, "\t-c: produce compressed gltf/glb files (-cc for higher compression ratio)\n");
+			fprintf(stderr, "\t-c: produce compressed gltf/glb files (-cc/-cz for higher compression ratio)\n");
 			fprintf(stderr, "\nTextures:\n");
 			fprintf(stderr, "\t-tc: convert all textures to KTX2 with BasisU supercompression\n");
 			fprintf(stderr, "\t-tu: use UASTC when encoding textures (much higher quality and much larger size)\n");
@@ -1683,6 +1686,7 @@ int main(int argc, char** argv)
 			fprintf(stderr, "\t-mi: use EXT_mesh_gpu_instancing when serializing multiple mesh instances\n");
 			fprintf(stderr, "\nMiscellaneous:\n");
 			fprintf(stderr, "\t-cf: produce compressed gltf/glb files with fallback for loaders that don't support compression\n");
+			fprintf(stderr, "\t-ce ext|khr: use EXT or KHR version of meshopt compression extension for compression\n");
 			fprintf(stderr, "\t-noq: disable quantization; produces much larger glTF files with no extensions\n");
 			fprintf(stderr, "\t-v: verbose output (when used with other options)\n");
 			fprintf(stderr, "\t-v: print version (when used without other options)\n");
@@ -1694,7 +1698,7 @@ int main(int argc, char** argv)
 			fprintf(stderr, "\nBasics:\n");
 			fprintf(stderr, "\t-i file: input file to process, .obj/.gltf/.glb\n");
 			fprintf(stderr, "\t-o file: output file path, .gltf/.glb\n");
-			fprintf(stderr, "\t-c: produce compressed gltf/glb files (-cc for higher compression ratio)\n");
+			fprintf(stderr, "\t-c: produce compressed gltf/glb files (-cc/-cz for higher compression ratio)\n");
 			fprintf(stderr, "\t-tc: convert all textures to KTX2 with BasisU supercompression\n");
 			fprintf(stderr, "\t-tw: convert all textures to WebP\n");
 			fprintf(stderr, "\t-si R: simplify meshes targeting triangle/point count ratio R (between 0 and 1)\n");

gltf/gltfpack.h

@@ -173,7 +173,7 @@ struct Settings
 
 	bool compress;
 	bool compressmore;
-	bool compressexp;
+	bool compresskhr;
 	bool fallback;
 
 	int verbose;
@@ -379,7 +379,7 @@ StreamFormat writeIndexStream(std::string& bin, const std::vector<unsigned int>&
 StreamFormat writeTimeStream(std::string& bin, const std::vector<float>& data);
 StreamFormat writeKeyframeStream(std::string& bin, cgltf_animation_path_type type, const std::vector<Attr>& data, const Settings& settings, bool has_tangents = false);
 
-void compressVertexStream(std::string& bin, const std::string& data, size_t count, size_t stride);
+void compressVertexStream(std::string& bin, const std::string& data, size_t count, size_t stride, int level);
 void compressIndexStream(std::string& bin, const std::string& data, size_t count, size_t stride);
 void compressIndexSequence(std::string& bin, const std::string& data, size_t count, size_t stride);
 

gltf/parsegltf.cpp

@@ -552,8 +552,6 @@ static bool freeUnusedBuffers(cgltf_data* data)
 
 static cgltf_result decompressMeshopt(cgltf_data* data)
 {
-	bool warned = false;
-
 	for (size_t i = 0; i < data->buffer_views_count; ++i)
 	{
 		if (!data->buffer_views[i].has_meshopt_compression)
@@ -572,22 +570,18 @@ static cgltf_result decompressMeshopt(cgltf_data* data)
 		data->buffer_views[i].data = result;
 
 		int rc = -1;
-		bool warn = false;
 
 		switch (mc->mode)
 		{
 		case cgltf_meshopt_compression_mode_attributes:
-			warn = meshopt_decodeVertexVersion(source, mc->size) != 0;
 			rc = meshopt_decodeVertexBuffer(result, mc->count, mc->stride, source, mc->size);
 			break;
 
 		case cgltf_meshopt_compression_mode_triangles:
-			warn = meshopt_decodeIndexVersion(source, mc->size) != 1;
 			rc = meshopt_decodeIndexBuffer(result, mc->count, mc->stride, source, mc->size);
 			break;
 
 		case cgltf_meshopt_compression_mode_indices:
-			warn = meshopt_decodeIndexVersion(source, mc->size) != 1;
 			rc = meshopt_decodeIndexSequence(result, mc->count, mc->stride, source, mc->size);
 			break;
 
@@ -598,12 +592,6 @@ static cgltf_result decompressMeshopt(cgltf_data* data)
 		if (rc != 0)
 			return cgltf_result_io_error;
 
-		if (warn && !warned)
-		{
-			fprintf(stderr, "Warning: EXT_meshopt_compression data uses versions outside of the glTF specification (vertex 0 / index 1 expected)\n");
-			warned = true;
-		}
-
 		switch (mc->filter)
 		{
 		case cgltf_meshopt_compression_filter_octahedral:
@@ -618,6 +606,10 @@ static cgltf_result decompressMeshopt(cgltf_data* data)
 			meshopt_decodeFilterExp(result, mc->count, mc->stride);
 			break;
 
+		case cgltf_meshopt_compression_filter_color:
+			meshopt_decodeFilterColor(result, mc->count, mc->stride);
+			break;
+
 		default:
 			break;
 		}

gltf/stream.cpp

@@ -629,7 +629,7 @@ StreamFormat writeVertexStream(std::string& bin, const Stream& stream, const Qua
 	}
 	else if (stream.type == cgltf_attribute_type_color)
 	{
-		bool col = filters && settings.compressexp && settings.compressmore;
+		bool col = filters && settings.compresskhr && settings.compressmore;
 		int bits = settings.col_bits;
 
 		StreamFormat::Filter filter = col ? StreamFormat::Filter_Color : StreamFormat::Filter_None;
@@ -866,12 +866,12 @@ StreamFormat writeKeyframeStream(std::string& bin, cgltf_animation_path_type typ
 	}
 }
 
-void compressVertexStream(std::string& bin, const std::string& data, size_t count, size_t stride)
+void compressVertexStream(std::string& bin, const std::string& data, size_t count, size_t stride, int level)
 {
 	assert(data.size() == count * stride);
 
 	std::vector<unsigned char> compressed(meshopt_encodeVertexBufferBound(count, stride));
-	size_t size = meshopt_encodeVertexBuffer(&compressed[0], compressed.size(), data.c_str(), count, stride);
+	size_t size = meshopt_encodeVertexBufferLevel(&compressed[0], compressed.size(), data.c_str(), count, stride, level, level > 0);
 
 	bin.append(reinterpret_cast<const char*>(&compressed[0]), size);
 }