4342 lines
111 KiB
C++
4342 lines
111 KiB
C++
// gltfpack is part of meshoptimizer library; see meshoptimizer.h for version/license details
|
|
//
|
|
// gltfpack is a command-line tool that takes a glTF file as an input and can produce two types of files:
|
|
// - regular glb/gltf files that use data that has been optimized for GPU consumption using various cache optimizers
|
|
// and quantization
|
|
// - packed glb/gltf files that additionally use meshoptimizer codecs to reduce the size of vertex/index data; these
|
|
// files can be further compressed with deflate/etc.
|
|
//
|
|
// To load regular glb files, it should be sufficient to use a standard glTF loader (although note that these files
|
|
// use quantized position/texture coordinates that require support for KHR_mesh_quantization; THREE.js and BabylonJS
|
|
// support these files out of the box).
|
|
// To load packed glb files, meshoptimizer vertex decoder needs to be integrated into the loader; demo/GLTFLoader.js
|
|
// contains a work-in-progress loader - please note that the extension specification isn't ready yet so the format
|
|
// will change!
|
|
|
|
#ifndef _CRT_SECURE_NO_WARNINGS
|
|
#define _CRT_SECURE_NO_WARNINGS
|
|
#endif
|
|
|
|
#ifndef _CRT_NONSTDC_NO_WARNINGS
|
|
#define _CRT_NONSTDC_NO_WARNINGS
|
|
#endif
|
|
|
|
#include "../src/meshoptimizer.h"
|
|
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include <float.h>
|
|
#include <limits.h>
|
|
#include <math.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#ifdef _WIN32
|
|
#include <io.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include "cgltf.h"
|
|
#include "fast_obj.h"
|
|
|
|
struct Attr
|
|
{
|
|
float f[4];
|
|
};
|
|
|
|
struct Stream
|
|
{
|
|
cgltf_attribute_type type;
|
|
int index;
|
|
int target; // 0 = base mesh, 1+ = morph target
|
|
|
|
std::vector<Attr> data;
|
|
};
|
|
|
|
struct Mesh
|
|
{
|
|
cgltf_node* node;
|
|
|
|
cgltf_material* material;
|
|
cgltf_skin* skin;
|
|
|
|
cgltf_primitive_type type;
|
|
|
|
std::vector<Stream> streams;
|
|
std::vector<unsigned int> indices;
|
|
|
|
size_t targets;
|
|
std::vector<float> target_weights;
|
|
std::vector<const char*> target_names;
|
|
};
|
|
|
|
struct Settings
|
|
{
|
|
int pos_bits;
|
|
int tex_bits;
|
|
int nrm_bits;
|
|
bool nrm_unnormalized;
|
|
|
|
int anim_freq;
|
|
bool anim_const;
|
|
|
|
bool keep_named;
|
|
|
|
float simplify_threshold;
|
|
bool simplify_aggressive;
|
|
|
|
bool texture_embed;
|
|
bool texture_basis;
|
|
|
|
int texture_quality;
|
|
|
|
bool compress;
|
|
bool fallback;
|
|
|
|
int verbose;
|
|
};
|
|
|
|
struct QuantizationParams
|
|
{
|
|
float pos_offset[3];
|
|
float pos_scale;
|
|
int pos_bits;
|
|
|
|
float uv_offset[2];
|
|
float uv_scale[2];
|
|
int uv_bits;
|
|
};
|
|
|
|
struct StreamFormat
|
|
{
|
|
cgltf_type type;
|
|
cgltf_component_type component_type;
|
|
bool normalized;
|
|
size_t stride;
|
|
};
|
|
|
|
struct NodeInfo
|
|
{
|
|
bool keep;
|
|
bool animated;
|
|
|
|
unsigned int animated_paths;
|
|
|
|
int remap;
|
|
std::vector<size_t> meshes;
|
|
};
|
|
|
|
struct MaterialInfo
|
|
{
|
|
bool keep;
|
|
|
|
int remap;
|
|
};
|
|
|
|
struct ImageInfo
|
|
{
|
|
bool normal_map;
|
|
};
|
|
|
|
struct BufferView
|
|
{
|
|
enum Kind
|
|
{
|
|
Kind_Vertex,
|
|
Kind_Index,
|
|
Kind_Skin,
|
|
Kind_Time,
|
|
Kind_Keyframe,
|
|
Kind_Image,
|
|
Kind_Count
|
|
};
|
|
|
|
Kind kind;
|
|
int variant;
|
|
size_t stride;
|
|
bool compressed;
|
|
|
|
std::string data;
|
|
|
|
size_t bytes;
|
|
};
|
|
|
|
const char* getError(cgltf_result result)
|
|
{
|
|
switch (result)
|
|
{
|
|
case cgltf_result_file_not_found:
|
|
return "file not found";
|
|
|
|
case cgltf_result_io_error:
|
|
return "I/O error";
|
|
|
|
case cgltf_result_invalid_json:
|
|
return "invalid JSON";
|
|
|
|
case cgltf_result_invalid_gltf:
|
|
return "invalid GLTF";
|
|
|
|
case cgltf_result_out_of_memory:
|
|
return "out of memory";
|
|
|
|
default:
|
|
return "unknown error";
|
|
}
|
|
}
|
|
|
|
cgltf_accessor* getAccessor(const cgltf_attribute* attributes, size_t attribute_count, cgltf_attribute_type type, int index = 0)
|
|
{
|
|
for (size_t i = 0; i < attribute_count; ++i)
|
|
if (attributes[i].type == type && attributes[i].index == index)
|
|
return attributes[i].data;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void readAccessor(std::vector<float>& data, const cgltf_accessor* accessor)
|
|
{
|
|
assert(accessor->type == cgltf_type_scalar);
|
|
|
|
data.resize(accessor->count);
|
|
cgltf_accessor_unpack_floats(accessor, &data[0], data.size());
|
|
}
|
|
|
|
void readAccessor(std::vector<Attr>& data, const cgltf_accessor* accessor)
|
|
{
|
|
size_t components = cgltf_num_components(accessor->type);
|
|
|
|
std::vector<float> temp(accessor->count * components);
|
|
cgltf_accessor_unpack_floats(accessor, &temp[0], temp.size());
|
|
|
|
data.resize(accessor->count);
|
|
|
|
for (size_t i = 0; i < accessor->count; ++i)
|
|
{
|
|
for (size_t k = 0; k < components && k < 4; ++k)
|
|
data[i].f[k] = temp[i * components + k];
|
|
}
|
|
}
|
|
|
|
void transformPosition(float* ptr, const float* transform)
|
|
{
|
|
float x = ptr[0] * transform[0] + ptr[1] * transform[4] + ptr[2] * transform[8] + transform[12];
|
|
float y = ptr[0] * transform[1] + ptr[1] * transform[5] + ptr[2] * transform[9] + transform[13];
|
|
float z = ptr[0] * transform[2] + ptr[1] * transform[6] + ptr[2] * transform[10] + transform[14];
|
|
|
|
ptr[0] = x;
|
|
ptr[1] = y;
|
|
ptr[2] = z;
|
|
}
|
|
|
|
void transformNormal(float* ptr, const float* transform)
|
|
{
|
|
float x = ptr[0] * transform[0] + ptr[1] * transform[4] + ptr[2] * transform[8];
|
|
float y = ptr[0] * transform[1] + ptr[1] * transform[5] + ptr[2] * transform[9];
|
|
float z = ptr[0] * transform[2] + ptr[1] * transform[6] + ptr[2] * transform[10];
|
|
|
|
float l = sqrtf(x * x + y * y + z * z);
|
|
float s = (l == 0.f) ? 0.f : 1 / l;
|
|
|
|
ptr[0] = x * s;
|
|
ptr[1] = y * s;
|
|
ptr[2] = z * s;
|
|
}
|
|
|
|
void transformMesh(Mesh& mesh, const cgltf_node* node)
|
|
{
|
|
float transform[16];
|
|
cgltf_node_transform_world(node, transform);
|
|
|
|
for (size_t si = 0; si < mesh.streams.size(); ++si)
|
|
{
|
|
Stream& stream = mesh.streams[si];
|
|
|
|
if (stream.type == cgltf_attribute_type_position)
|
|
{
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
transformPosition(stream.data[i].f, transform);
|
|
}
|
|
else if (stream.type == cgltf_attribute_type_normal || stream.type == cgltf_attribute_type_tangent)
|
|
{
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
transformNormal(stream.data[i].f, transform);
|
|
}
|
|
}
|
|
}
|
|
|
|
void parseMeshesGltf(cgltf_data* data, std::vector<Mesh>& meshes)
|
|
{
|
|
for (size_t ni = 0; ni < data->nodes_count; ++ni)
|
|
{
|
|
cgltf_node& node = data->nodes[ni];
|
|
|
|
if (!node.mesh)
|
|
continue;
|
|
|
|
const cgltf_mesh& mesh = *node.mesh;
|
|
int mesh_id = int(&mesh - data->meshes);
|
|
|
|
for (size_t pi = 0; pi < mesh.primitives_count; ++pi)
|
|
{
|
|
const cgltf_primitive& primitive = mesh.primitives[pi];
|
|
|
|
if (primitive.type != cgltf_primitive_type_triangles && primitive.type != cgltf_primitive_type_points)
|
|
{
|
|
fprintf(stderr, "Warning: ignoring primitive %d of mesh %d because type %d is not supported\n", int(pi), mesh_id, primitive.type);
|
|
continue;
|
|
}
|
|
|
|
if (primitive.type == cgltf_primitive_type_points && primitive.indices)
|
|
{
|
|
fprintf(stderr, "Warning: ignoring primitive %d of mesh %d because indexed points are not supported\n", int(pi), mesh_id);
|
|
continue;
|
|
}
|
|
|
|
Mesh result;
|
|
|
|
result.node = &node;
|
|
|
|
result.material = primitive.material;
|
|
result.skin = node.skin;
|
|
|
|
result.type = primitive.type;
|
|
|
|
if (primitive.indices)
|
|
{
|
|
result.indices.resize(primitive.indices->count);
|
|
for (size_t i = 0; i < primitive.indices->count; ++i)
|
|
result.indices[i] = unsigned(cgltf_accessor_read_index(primitive.indices, i));
|
|
}
|
|
else if (primitive.type != cgltf_primitive_type_points)
|
|
{
|
|
size_t count = primitive.attributes ? primitive.attributes[0].data->count : 0;
|
|
|
|
// note, while we could generate a good index buffer, reindexMesh will take care of this
|
|
result.indices.resize(count);
|
|
for (size_t i = 0; i < count; ++i)
|
|
result.indices[i] = unsigned(i);
|
|
}
|
|
|
|
for (size_t ai = 0; ai < primitive.attributes_count; ++ai)
|
|
{
|
|
const cgltf_attribute& attr = primitive.attributes[ai];
|
|
|
|
if (attr.type == cgltf_attribute_type_invalid)
|
|
{
|
|
fprintf(stderr, "Warning: ignoring unknown attribute %s in primitive %d of mesh %d\n", attr.name, int(pi), mesh_id);
|
|
continue;
|
|
}
|
|
|
|
Stream s = {attr.type, attr.index};
|
|
readAccessor(s.data, attr.data);
|
|
|
|
result.streams.push_back(s);
|
|
}
|
|
|
|
for (size_t ti = 0; ti < primitive.targets_count; ++ti)
|
|
{
|
|
const cgltf_morph_target& target = primitive.targets[ti];
|
|
|
|
for (size_t ai = 0; ai < target.attributes_count; ++ai)
|
|
{
|
|
const cgltf_attribute& attr = target.attributes[ai];
|
|
|
|
if (attr.type == cgltf_attribute_type_invalid)
|
|
{
|
|
fprintf(stderr, "Warning: ignoring unknown attribute %s in morph target %d of primitive %d of mesh %d\n", attr.name, int(ti), int(pi), mesh_id);
|
|
continue;
|
|
}
|
|
|
|
Stream s = {attr.type, attr.index, int(ti + 1)};
|
|
readAccessor(s.data, attr.data);
|
|
|
|
result.streams.push_back(s);
|
|
}
|
|
}
|
|
|
|
result.targets = primitive.targets_count;
|
|
result.target_weights.assign(mesh.weights, mesh.weights + mesh.weights_count);
|
|
result.target_names.assign(mesh.target_names, mesh.target_names + mesh.target_names_count);
|
|
|
|
meshes.push_back(result);
|
|
}
|
|
}
|
|
}
|
|
|
|
void defaultFree(void*, void* p)
|
|
{
|
|
free(p);
|
|
}
|
|
|
|
int textureIndex(const std::vector<std::string>& textures, const char* name)
|
|
{
|
|
for (size_t i = 0; i < textures.size(); ++i)
|
|
if (textures[i] == name)
|
|
return int(i);
|
|
|
|
return -1;
|
|
}
|
|
|
|
cgltf_data* parseSceneObj(fastObjMesh* obj)
|
|
{
|
|
cgltf_data* data = (cgltf_data*)calloc(1, sizeof(cgltf_data));
|
|
data->memory_free = defaultFree;
|
|
|
|
std::vector<std::string> textures;
|
|
|
|
for (unsigned int mi = 0; mi < obj->material_count; ++mi)
|
|
{
|
|
fastObjMaterial& om = obj->materials[mi];
|
|
|
|
if (om.map_Kd.name && textureIndex(textures, om.map_Kd.name) < 0)
|
|
textures.push_back(om.map_Kd.name);
|
|
}
|
|
|
|
data->images = (cgltf_image*)calloc(textures.size(), sizeof(cgltf_image));
|
|
data->images_count = textures.size();
|
|
|
|
for (size_t i = 0; i < textures.size(); ++i)
|
|
{
|
|
data->images[i].uri = strdup(textures[i].c_str());
|
|
}
|
|
|
|
data->textures = (cgltf_texture*)calloc(textures.size(), sizeof(cgltf_texture));
|
|
data->textures_count = textures.size();
|
|
|
|
for (size_t i = 0; i < textures.size(); ++i)
|
|
{
|
|
data->textures[i].image = &data->images[i];
|
|
}
|
|
|
|
data->materials = (cgltf_material*)calloc(obj->material_count, sizeof(cgltf_material));
|
|
data->materials_count = obj->material_count;
|
|
|
|
for (unsigned int mi = 0; mi < obj->material_count; ++mi)
|
|
{
|
|
cgltf_material& gm = data->materials[mi];
|
|
fastObjMaterial& om = obj->materials[mi];
|
|
|
|
gm.has_pbr_metallic_roughness = true;
|
|
gm.pbr_metallic_roughness.base_color_factor[0] = 1.0f;
|
|
gm.pbr_metallic_roughness.base_color_factor[1] = 1.0f;
|
|
gm.pbr_metallic_roughness.base_color_factor[2] = 1.0f;
|
|
gm.pbr_metallic_roughness.base_color_factor[3] = 1.0f;
|
|
gm.pbr_metallic_roughness.metallic_factor = 0.0f;
|
|
gm.pbr_metallic_roughness.roughness_factor = 1.0f;
|
|
|
|
gm.alpha_cutoff = 0.5f;
|
|
|
|
if (om.map_Kd.name)
|
|
{
|
|
gm.pbr_metallic_roughness.base_color_texture.texture = &data->textures[textureIndex(textures, om.map_Kd.name)];
|
|
gm.pbr_metallic_roughness.base_color_texture.scale = 1.0f;
|
|
|
|
gm.alpha_mode = (om.illum == 4 || om.illum == 6 || om.illum == 7 || om.illum == 9) ? cgltf_alpha_mode_mask : cgltf_alpha_mode_opaque;
|
|
}
|
|
|
|
if (om.map_d.name)
|
|
{
|
|
gm.alpha_mode = cgltf_alpha_mode_blend;
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
void parseMeshesObj(fastObjMesh* obj, cgltf_data* data, std::vector<Mesh>& meshes)
|
|
{
|
|
unsigned int material_count = std::max(obj->material_count, 1u);
|
|
|
|
std::vector<size_t> vertex_count(material_count);
|
|
std::vector<size_t> index_count(material_count);
|
|
|
|
for (unsigned int fi = 0; fi < obj->face_count; ++fi)
|
|
{
|
|
unsigned int mi = obj->face_materials[fi];
|
|
|
|
vertex_count[mi] += obj->face_vertices[fi];
|
|
index_count[mi] += (obj->face_vertices[fi] - 2) * 3;
|
|
}
|
|
|
|
std::vector<size_t> mesh_index(material_count);
|
|
|
|
for (unsigned int mi = 0; mi < material_count; ++mi)
|
|
{
|
|
if (index_count[mi] == 0)
|
|
continue;
|
|
|
|
mesh_index[mi] = meshes.size();
|
|
|
|
meshes.push_back(Mesh());
|
|
|
|
Mesh& mesh = meshes.back();
|
|
|
|
if (data->materials_count)
|
|
{
|
|
assert(mi < data->materials_count);
|
|
mesh.material = &data->materials[mi];
|
|
}
|
|
|
|
mesh.type = cgltf_primitive_type_triangles;
|
|
|
|
mesh.streams.resize(3);
|
|
mesh.streams[0].type = cgltf_attribute_type_position;
|
|
mesh.streams[0].data.resize(vertex_count[mi]);
|
|
mesh.streams[1].type = cgltf_attribute_type_normal;
|
|
mesh.streams[1].data.resize(vertex_count[mi]);
|
|
mesh.streams[2].type = cgltf_attribute_type_texcoord;
|
|
mesh.streams[2].data.resize(vertex_count[mi]);
|
|
mesh.indices.resize(index_count[mi]);
|
|
mesh.targets = 0;
|
|
}
|
|
|
|
std::vector<size_t> vertex_offset(material_count);
|
|
std::vector<size_t> index_offset(material_count);
|
|
|
|
size_t group_offset = 0;
|
|
|
|
for (unsigned int fi = 0; fi < obj->face_count; ++fi)
|
|
{
|
|
unsigned int mi = obj->face_materials[fi];
|
|
Mesh& mesh = meshes[mesh_index[mi]];
|
|
|
|
size_t vo = vertex_offset[mi];
|
|
size_t io = index_offset[mi];
|
|
|
|
for (unsigned int vi = 0; vi < obj->face_vertices[fi]; ++vi)
|
|
{
|
|
fastObjIndex ii = obj->indices[group_offset + vi];
|
|
|
|
Attr p = {{obj->positions[ii.p * 3 + 0], obj->positions[ii.p * 3 + 1], obj->positions[ii.p * 3 + 2]}};
|
|
Attr n = {{obj->normals[ii.n * 3 + 0], obj->normals[ii.n * 3 + 1], obj->normals[ii.n * 3 + 2]}};
|
|
Attr t = {{obj->texcoords[ii.t * 2 + 0], 1.f - obj->texcoords[ii.t * 2 + 1]}};
|
|
|
|
mesh.streams[0].data[vo + vi] = p;
|
|
mesh.streams[1].data[vo + vi] = n;
|
|
mesh.streams[2].data[vo + vi] = t;
|
|
}
|
|
|
|
for (unsigned int vi = 2; vi < obj->face_vertices[fi]; ++vi)
|
|
{
|
|
size_t to = io + (vi - 2) * 3;
|
|
|
|
mesh.indices[to + 0] = unsigned(vo);
|
|
mesh.indices[to + 1] = unsigned(vo + vi - 1);
|
|
mesh.indices[to + 2] = unsigned(vo + vi);
|
|
}
|
|
|
|
vertex_offset[mi] += obj->face_vertices[fi];
|
|
index_offset[mi] += (obj->face_vertices[fi] - 2) * 3;
|
|
group_offset += obj->face_vertices[fi];
|
|
}
|
|
}
|
|
|
|
bool areTextureViewsEqual(const cgltf_texture_view& lhs, const cgltf_texture_view& rhs)
|
|
{
|
|
if (lhs.has_transform != rhs.has_transform)
|
|
return false;
|
|
|
|
if (lhs.has_transform)
|
|
{
|
|
const cgltf_texture_transform& lt = lhs.transform;
|
|
const cgltf_texture_transform& rt = rhs.transform;
|
|
|
|
if (memcmp(lt.offset, rt.offset, sizeof(cgltf_float) * 2) != 0)
|
|
return false;
|
|
|
|
if (lt.rotation != rt.rotation)
|
|
return false;
|
|
|
|
if (memcmp(lt.scale, rt.scale, sizeof(cgltf_float) * 2) != 0)
|
|
return false;
|
|
|
|
if (lt.texcoord != rt.texcoord)
|
|
return false;
|
|
}
|
|
|
|
if (lhs.texture != rhs.texture)
|
|
return false;
|
|
|
|
if (lhs.texcoord != rhs.texcoord)
|
|
return false;
|
|
|
|
if (lhs.scale != rhs.scale)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool areMaterialsEqual(const cgltf_material& lhs, const cgltf_material& rhs)
|
|
{
|
|
if (lhs.has_pbr_metallic_roughness != rhs.has_pbr_metallic_roughness)
|
|
return false;
|
|
|
|
if (lhs.has_pbr_metallic_roughness)
|
|
{
|
|
const cgltf_pbr_metallic_roughness& lpbr = lhs.pbr_metallic_roughness;
|
|
const cgltf_pbr_metallic_roughness& rpbr = rhs.pbr_metallic_roughness;
|
|
|
|
if (!areTextureViewsEqual(lpbr.base_color_texture, rpbr.base_color_texture))
|
|
return false;
|
|
|
|
if (!areTextureViewsEqual(lpbr.metallic_roughness_texture, rpbr.metallic_roughness_texture))
|
|
return false;
|
|
|
|
if (memcmp(lpbr.base_color_factor, rpbr.base_color_factor, sizeof(cgltf_float) * 4) != 0)
|
|
return false;
|
|
|
|
if (lpbr.metallic_factor != rpbr.metallic_factor)
|
|
return false;
|
|
|
|
if (lpbr.roughness_factor != rpbr.roughness_factor)
|
|
return false;
|
|
}
|
|
|
|
if (lhs.has_pbr_specular_glossiness != rhs.has_pbr_specular_glossiness)
|
|
return false;
|
|
|
|
if (lhs.has_pbr_specular_glossiness)
|
|
{
|
|
const cgltf_pbr_specular_glossiness& lpbr = lhs.pbr_specular_glossiness;
|
|
const cgltf_pbr_specular_glossiness& rpbr = rhs.pbr_specular_glossiness;
|
|
|
|
if (!areTextureViewsEqual(lpbr.diffuse_texture, rpbr.diffuse_texture))
|
|
return false;
|
|
|
|
if (!areTextureViewsEqual(lpbr.specular_glossiness_texture, rpbr.specular_glossiness_texture))
|
|
return false;
|
|
|
|
if (memcmp(lpbr.diffuse_factor, rpbr.diffuse_factor, sizeof(cgltf_float) * 4) != 0)
|
|
return false;
|
|
|
|
if (memcmp(lpbr.specular_factor, rpbr.specular_factor, sizeof(cgltf_float) * 3) != 0)
|
|
return false;
|
|
|
|
if (lpbr.glossiness_factor != rpbr.glossiness_factor)
|
|
return false;
|
|
}
|
|
|
|
if (!areTextureViewsEqual(lhs.normal_texture, rhs.normal_texture))
|
|
return false;
|
|
|
|
if (!areTextureViewsEqual(lhs.occlusion_texture, rhs.occlusion_texture))
|
|
return false;
|
|
|
|
if (!areTextureViewsEqual(lhs.emissive_texture, rhs.emissive_texture))
|
|
return false;
|
|
|
|
if (memcmp(lhs.emissive_factor, rhs.emissive_factor, sizeof(cgltf_float) * 3) != 0)
|
|
return false;
|
|
|
|
if (lhs.alpha_mode != rhs.alpha_mode)
|
|
return false;
|
|
|
|
if (lhs.alpha_cutoff != rhs.alpha_cutoff)
|
|
return false;
|
|
|
|
if (lhs.double_sided != rhs.double_sided)
|
|
return false;
|
|
|
|
if (lhs.unlit != rhs.unlit)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void mergeMeshMaterials(cgltf_data* data, std::vector<Mesh>& meshes)
|
|
{
|
|
for (size_t i = 0; i < meshes.size(); ++i)
|
|
{
|
|
Mesh& mesh = meshes[i];
|
|
|
|
if (!mesh.material)
|
|
continue;
|
|
|
|
for (int j = 0; j < mesh.material - data->materials; ++j)
|
|
{
|
|
if (areMaterialsEqual(*mesh.material, data->materials[j]))
|
|
{
|
|
mesh.material = &data->materials[j];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool compareMeshTargets(const Mesh& lhs, const Mesh& rhs)
|
|
{
|
|
if (lhs.targets != rhs.targets)
|
|
return false;
|
|
|
|
if (lhs.target_weights.size() != rhs.target_weights.size())
|
|
return false;
|
|
|
|
for (size_t i = 0; i < lhs.target_weights.size(); ++i)
|
|
if (lhs.target_weights[i] != rhs.target_weights[i])
|
|
return false;
|
|
|
|
if (lhs.target_names.size() != rhs.target_names.size())
|
|
return false;
|
|
|
|
for (size_t i = 0; i < lhs.target_names.size(); ++i)
|
|
if (strcmp(lhs.target_names[i], rhs.target_names[i]) != 0)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool canMergeMeshes(const Mesh& lhs, const Mesh& rhs, const Settings& settings)
|
|
{
|
|
if (lhs.node != rhs.node)
|
|
{
|
|
if (!lhs.node || !rhs.node)
|
|
return false;
|
|
|
|
if (lhs.node->parent != rhs.node->parent)
|
|
return false;
|
|
|
|
bool lhs_transform = lhs.node->has_translation | lhs.node->has_rotation | lhs.node->has_scale | lhs.node->has_matrix | (!!lhs.node->weights);
|
|
bool rhs_transform = rhs.node->has_translation | rhs.node->has_rotation | rhs.node->has_scale | rhs.node->has_matrix | (!!rhs.node->weights);
|
|
|
|
if (lhs_transform || rhs_transform)
|
|
return false;
|
|
|
|
if (settings.keep_named)
|
|
{
|
|
if (lhs.node->name && *lhs.node->name)
|
|
return false;
|
|
|
|
if (rhs.node->name && *rhs.node->name)
|
|
return false;
|
|
}
|
|
|
|
// we can merge nodes that don't have transforms of their own and have the same parent
|
|
// this is helpful when instead of splitting mesh into primitives, DCCs split mesh into mesh nodes
|
|
}
|
|
|
|
if (lhs.material != rhs.material)
|
|
return false;
|
|
|
|
if (lhs.skin != rhs.skin)
|
|
return false;
|
|
|
|
if (lhs.type != rhs.type)
|
|
return false;
|
|
|
|
if (!compareMeshTargets(lhs, rhs))
|
|
return false;
|
|
|
|
if (lhs.indices.empty() != rhs.indices.empty())
|
|
return false;
|
|
|
|
if (lhs.streams.size() != rhs.streams.size())
|
|
return false;
|
|
|
|
for (size_t i = 0; i < lhs.streams.size(); ++i)
|
|
if (lhs.streams[i].type != rhs.streams[i].type || lhs.streams[i].index != rhs.streams[i].index || lhs.streams[i].target != rhs.streams[i].target)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void mergeMeshes(Mesh& target, const Mesh& mesh)
|
|
{
|
|
assert(target.streams.size() == mesh.streams.size());
|
|
|
|
size_t vertex_offset = target.streams[0].data.size();
|
|
size_t index_offset = target.indices.size();
|
|
|
|
for (size_t i = 0; i < target.streams.size(); ++i)
|
|
target.streams[i].data.insert(target.streams[i].data.end(), mesh.streams[i].data.begin(), mesh.streams[i].data.end());
|
|
|
|
target.indices.resize(target.indices.size() + mesh.indices.size());
|
|
|
|
size_t index_count = mesh.indices.size();
|
|
|
|
for (size_t i = 0; i < index_count; ++i)
|
|
target.indices[index_offset + i] = unsigned(vertex_offset + mesh.indices[i]);
|
|
}
|
|
|
|
void mergeMeshes(std::vector<Mesh>& meshes, const Settings& settings)
|
|
{
|
|
size_t write = 0;
|
|
|
|
for (size_t i = 0; i < meshes.size(); ++i)
|
|
{
|
|
if (meshes[i].streams.empty())
|
|
continue;
|
|
|
|
Mesh& target = meshes[write];
|
|
|
|
if (i != write)
|
|
{
|
|
Mesh& mesh = meshes[i];
|
|
|
|
// note: this copy is expensive; we could use move in C++11 or swap manually which is a bit painful...
|
|
target = mesh;
|
|
|
|
mesh.streams.clear();
|
|
mesh.indices.clear();
|
|
}
|
|
|
|
size_t target_vertices = target.streams[0].data.size();
|
|
size_t target_indices = target.indices.size();
|
|
|
|
for (size_t j = i + 1; j < meshes.size(); ++j)
|
|
{
|
|
Mesh& mesh = meshes[j];
|
|
|
|
if (!mesh.streams.empty() && canMergeMeshes(target, mesh, settings))
|
|
{
|
|
target_vertices += mesh.streams[0].data.size();
|
|
target_indices += mesh.indices.size();
|
|
}
|
|
}
|
|
|
|
for (size_t j = 0; j < target.streams.size(); ++j)
|
|
target.streams[j].data.reserve(target_vertices);
|
|
|
|
target.indices.reserve(target_indices);
|
|
|
|
for (size_t j = i + 1; j < meshes.size(); ++j)
|
|
{
|
|
Mesh& mesh = meshes[j];
|
|
|
|
if (!mesh.streams.empty() && canMergeMeshes(target, mesh, settings))
|
|
{
|
|
mergeMeshes(target, mesh);
|
|
|
|
mesh.streams.clear();
|
|
mesh.indices.clear();
|
|
}
|
|
}
|
|
|
|
assert(target.streams[0].data.size() == target_vertices);
|
|
assert(target.indices.size() == target_indices);
|
|
|
|
write++;
|
|
}
|
|
|
|
meshes.resize(write);
|
|
}
|
|
|
|
void reindexMesh(Mesh& mesh)
|
|
{
|
|
size_t total_vertices = mesh.streams[0].data.size();
|
|
size_t total_indices = mesh.indices.size();
|
|
|
|
std::vector<meshopt_Stream> streams;
|
|
for (size_t i = 0; i < mesh.streams.size(); ++i)
|
|
{
|
|
if (mesh.streams[i].target)
|
|
continue;
|
|
|
|
assert(mesh.streams[i].data.size() == total_vertices);
|
|
|
|
meshopt_Stream stream = {&mesh.streams[i].data[0], sizeof(Attr), sizeof(Attr)};
|
|
streams.push_back(stream);
|
|
}
|
|
|
|
std::vector<unsigned int> remap(total_vertices);
|
|
size_t unique_vertices = meshopt_generateVertexRemapMulti(&remap[0], &mesh.indices[0], total_indices, total_vertices, &streams[0], streams.size());
|
|
assert(unique_vertices <= total_vertices);
|
|
|
|
meshopt_remapIndexBuffer(&mesh.indices[0], &mesh.indices[0], total_indices, &remap[0]);
|
|
|
|
for (size_t i = 0; i < mesh.streams.size(); ++i)
|
|
{
|
|
assert(mesh.streams[i].data.size() == total_vertices);
|
|
|
|
meshopt_remapVertexBuffer(&mesh.streams[i].data[0], &mesh.streams[i].data[0], total_vertices, sizeof(Attr), &remap[0]);
|
|
mesh.streams[i].data.resize(unique_vertices);
|
|
}
|
|
}
|
|
|
|
void filterMesh(Mesh& mesh)
|
|
{
|
|
unsigned int* indices = &mesh.indices[0];
|
|
size_t total_indices = mesh.indices.size();
|
|
|
|
size_t write = 0;
|
|
|
|
for (size_t i = 0; i < total_indices; i += 3)
|
|
{
|
|
unsigned int a = indices[i + 0], b = indices[i + 1], c = indices[i + 2];
|
|
|
|
if (a != b && a != c && b != c)
|
|
{
|
|
indices[write + 0] = a;
|
|
indices[write + 1] = b;
|
|
indices[write + 2] = c;
|
|
write += 3;
|
|
}
|
|
}
|
|
|
|
mesh.indices.resize(write);
|
|
}
|
|
|
|
Stream* getStream(Mesh& mesh, cgltf_attribute_type type, int index = 0)
|
|
{
|
|
for (size_t i = 0; i < mesh.streams.size(); ++i)
|
|
if (mesh.streams[i].type == type && mesh.streams[i].index == index)
|
|
return &mesh.streams[i];
|
|
|
|
return 0;
|
|
}
|
|
|
|
void simplifyMesh(Mesh& mesh, float threshold, bool aggressive)
|
|
{
|
|
if (threshold >= 1)
|
|
return;
|
|
|
|
const Stream* positions = getStream(mesh, cgltf_attribute_type_position);
|
|
if (!positions)
|
|
return;
|
|
|
|
size_t vertex_count = mesh.streams[0].data.size();
|
|
|
|
size_t target_index_count = size_t(double(mesh.indices.size() / 3) * threshold) * 3;
|
|
float target_error = 1e-2f;
|
|
|
|
if (target_index_count < 1)
|
|
return;
|
|
|
|
std::vector<unsigned int> indices(mesh.indices.size());
|
|
indices.resize(meshopt_simplify(&indices[0], &mesh.indices[0], mesh.indices.size(), positions->data[0].f, vertex_count, sizeof(Attr), target_index_count, target_error));
|
|
mesh.indices.swap(indices);
|
|
|
|
// Note: if the simplifier got stuck, we can try to reindex without normals/tangents and retry
|
|
// For now we simply fall back to aggressive simplifier instead
|
|
|
|
// if the mesh is complex enough and the precise simplifier got "stuck", we'll try to simplify using the sloppy simplifier which is guaranteed to reach the target count
|
|
if (aggressive && target_index_count > 50 * 3 && mesh.indices.size() > target_index_count)
|
|
{
|
|
indices.resize(meshopt_simplifySloppy(&indices[0], &mesh.indices[0], mesh.indices.size(), positions->data[0].f, vertex_count, sizeof(Attr), target_index_count));
|
|
mesh.indices.swap(indices);
|
|
}
|
|
}
|
|
|
|
void optimizeMesh(Mesh& mesh)
|
|
{
|
|
size_t vertex_count = mesh.streams[0].data.size();
|
|
|
|
meshopt_optimizeVertexCache(&mesh.indices[0], &mesh.indices[0], mesh.indices.size(), vertex_count);
|
|
|
|
std::vector<unsigned int> remap(vertex_count);
|
|
size_t unique_vertices = meshopt_optimizeVertexFetchRemap(&remap[0], &mesh.indices[0], mesh.indices.size(), vertex_count);
|
|
assert(unique_vertices <= vertex_count);
|
|
|
|
meshopt_remapIndexBuffer(&mesh.indices[0], &mesh.indices[0], mesh.indices.size(), &remap[0]);
|
|
|
|
for (size_t i = 0; i < mesh.streams.size(); ++i)
|
|
{
|
|
assert(mesh.streams[i].data.size() == vertex_count);
|
|
|
|
meshopt_remapVertexBuffer(&mesh.streams[i].data[0], &mesh.streams[i].data[0], vertex_count, sizeof(Attr), &remap[0]);
|
|
mesh.streams[i].data.resize(unique_vertices);
|
|
}
|
|
}
|
|
|
|
struct BoneInfluence
|
|
{
|
|
float i;
|
|
float w;
|
|
};
|
|
|
|
struct BoneInfluenceIndexPredicate
|
|
{
|
|
bool operator()(const BoneInfluence& lhs, const BoneInfluence& rhs) const
|
|
{
|
|
return lhs.i < rhs.i;
|
|
}
|
|
};
|
|
|
|
struct BoneInfluenceWeightPredicate
|
|
{
|
|
bool operator()(const BoneInfluence& lhs, const BoneInfluence& rhs) const
|
|
{
|
|
return lhs.w > rhs.w;
|
|
}
|
|
};
|
|
|
|
void filterBones(Mesh& mesh)
|
|
{
|
|
const int kMaxGroups = 8;
|
|
|
|
std::pair<Stream*, Stream*> groups[kMaxGroups];
|
|
int group_count = 0;
|
|
|
|
// gather all joint/weight groups; each group contains 4 bone influences
|
|
for (int i = 0; i < kMaxGroups; ++i)
|
|
{
|
|
Stream* jg = getStream(mesh, cgltf_attribute_type_joints, int(i));
|
|
Stream* wg = getStream(mesh, cgltf_attribute_type_weights, int(i));
|
|
|
|
if (!jg || !wg)
|
|
break;
|
|
|
|
groups[group_count++] = std::make_pair(jg, wg);
|
|
}
|
|
|
|
if (group_count == 0)
|
|
return;
|
|
|
|
// weights below cutoff can't be represented in quantized 8-bit storage
|
|
const float weight_cutoff = 0.5f / 255.f;
|
|
|
|
size_t vertex_count = mesh.streams[0].data.size();
|
|
|
|
BoneInfluence inf[kMaxGroups * 4] = {};
|
|
|
|
for (size_t i = 0; i < vertex_count; ++i)
|
|
{
|
|
int count = 0;
|
|
|
|
// gather all bone influences for this vertex
|
|
for (int j = 0; j < group_count; ++j)
|
|
{
|
|
const Attr& ja = groups[j].first->data[i];
|
|
const Attr& wa = groups[j].second->data[i];
|
|
|
|
for (int k = 0; k < 4; ++k)
|
|
if (wa.f[k] > weight_cutoff)
|
|
{
|
|
inf[count].i = ja.f[k];
|
|
inf[count].w = wa.f[k];
|
|
count++;
|
|
}
|
|
}
|
|
|
|
// pick top 4 influences - could use partial_sort but it is slower on small sets
|
|
std::sort(inf, inf + count, BoneInfluenceWeightPredicate());
|
|
|
|
// now sort top 4 influences by bone index - this improves compression ratio
|
|
std::sort(inf, inf + std::min(4, count), BoneInfluenceIndexPredicate());
|
|
|
|
// copy the top 4 influences back into stream 0 - we will remove other streams at the end
|
|
Attr& ja = groups[0].first->data[i];
|
|
Attr& wa = groups[0].second->data[i];
|
|
|
|
for (int k = 0; k < 4; ++k)
|
|
{
|
|
if (k < count)
|
|
{
|
|
ja.f[k] = inf[k].i;
|
|
wa.f[k] = inf[k].w;
|
|
}
|
|
else
|
|
{
|
|
ja.f[k] = 0.f;
|
|
wa.f[k] = 0.f;
|
|
}
|
|
}
|
|
}
|
|
|
|
// remove redundant weight/joint streams
|
|
for (size_t i = 0; i < mesh.streams.size();)
|
|
{
|
|
Stream& s = mesh.streams[i];
|
|
|
|
if ((s.type == cgltf_attribute_type_joints || s.type == cgltf_attribute_type_weights) && s.index > 0)
|
|
mesh.streams.erase(mesh.streams.begin() + i);
|
|
else
|
|
++i;
|
|
}
|
|
}
|
|
|
|
void simplifyPointMesh(Mesh& mesh, float threshold)
|
|
{
|
|
if (threshold >= 1)
|
|
return;
|
|
|
|
const Stream* positions = getStream(mesh, cgltf_attribute_type_position);
|
|
if (!positions)
|
|
return;
|
|
|
|
size_t vertex_count = mesh.streams[0].data.size();
|
|
|
|
size_t target_vertex_count = size_t(double(vertex_count) * threshold);
|
|
|
|
if (target_vertex_count < 1)
|
|
return;
|
|
|
|
std::vector<unsigned int> indices(target_vertex_count);
|
|
indices.resize(meshopt_simplifyPoints(&indices[0], positions->data[0].f, vertex_count, sizeof(Attr), target_vertex_count));
|
|
|
|
std::vector<Attr> scratch(indices.size());
|
|
|
|
for (size_t i = 0; i < mesh.streams.size(); ++i)
|
|
{
|
|
std::vector<Attr>& data = mesh.streams[i].data;
|
|
|
|
assert(data.size() == vertex_count);
|
|
|
|
for (size_t j = 0; j < indices.size(); ++j)
|
|
scratch[j] = data[indices[j]];
|
|
|
|
data = scratch;
|
|
}
|
|
}
|
|
|
|
void sortPointMesh(Mesh& mesh)
|
|
{
|
|
const Stream* positions = getStream(mesh, cgltf_attribute_type_position);
|
|
if (!positions)
|
|
return;
|
|
|
|
size_t vertex_count = mesh.streams[0].data.size();
|
|
|
|
std::vector<unsigned int> remap(vertex_count);
|
|
meshopt_spatialSortRemap(&remap[0], positions->data[0].f, vertex_count, sizeof(Attr));
|
|
|
|
for (size_t i = 0; i < mesh.streams.size(); ++i)
|
|
{
|
|
assert(mesh.streams[i].data.size() == vertex_count);
|
|
|
|
meshopt_remapVertexBuffer(&mesh.streams[i].data[0], &mesh.streams[i].data[0], vertex_count, sizeof(Attr), &remap[0]);
|
|
}
|
|
}
|
|
|
|
void processMesh(Mesh& mesh, const Settings& settings)
|
|
{
|
|
switch (mesh.type)
|
|
{
|
|
case cgltf_primitive_type_points:
|
|
assert(mesh.indices.empty());
|
|
simplifyPointMesh(mesh, settings.simplify_threshold);
|
|
sortPointMesh(mesh);
|
|
break;
|
|
|
|
case cgltf_primitive_type_triangles:
|
|
filterBones(mesh);
|
|
reindexMesh(mesh);
|
|
filterMesh(mesh);
|
|
simplifyMesh(mesh, settings.simplify_threshold, settings.simplify_aggressive);
|
|
optimizeMesh(mesh);
|
|
break;
|
|
|
|
default:
|
|
assert(!"Unknown primitive type");
|
|
}
|
|
}
|
|
|
|
bool getAttributeBounds(const std::vector<Mesh>& meshes, cgltf_attribute_type type, Attr& min, Attr& max)
|
|
{
|
|
min.f[0] = min.f[1] = min.f[2] = min.f[3] = +FLT_MAX;
|
|
max.f[0] = max.f[1] = max.f[2] = max.f[3] = -FLT_MAX;
|
|
|
|
Attr pad = {};
|
|
|
|
bool valid = false;
|
|
|
|
for (size_t i = 0; i < meshes.size(); ++i)
|
|
{
|
|
const Mesh& mesh = meshes[i];
|
|
|
|
for (size_t j = 0; j < mesh.streams.size(); ++j)
|
|
{
|
|
const Stream& s = mesh.streams[j];
|
|
|
|
if (s.type == type)
|
|
{
|
|
if (s.target == 0)
|
|
{
|
|
for (size_t k = 0; k < s.data.size(); ++k)
|
|
{
|
|
const Attr& a = s.data[k];
|
|
|
|
min.f[0] = std::min(min.f[0], a.f[0]);
|
|
min.f[1] = std::min(min.f[1], a.f[1]);
|
|
min.f[2] = std::min(min.f[2], a.f[2]);
|
|
min.f[3] = std::min(min.f[3], a.f[3]);
|
|
|
|
max.f[0] = std::max(max.f[0], a.f[0]);
|
|
max.f[1] = std::max(max.f[1], a.f[1]);
|
|
max.f[2] = std::max(max.f[2], a.f[2]);
|
|
max.f[3] = std::max(max.f[3], a.f[3]);
|
|
|
|
valid = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (size_t k = 0; k < s.data.size(); ++k)
|
|
{
|
|
const Attr& a = s.data[k];
|
|
|
|
pad.f[0] = std::max(pad.f[0], fabsf(a.f[0]));
|
|
pad.f[1] = std::max(pad.f[1], fabsf(a.f[1]));
|
|
pad.f[2] = std::max(pad.f[2], fabsf(a.f[2]));
|
|
pad.f[3] = std::max(pad.f[3], fabsf(a.f[3]));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (valid)
|
|
{
|
|
for (int k = 0; k < 4; ++k)
|
|
{
|
|
min.f[k] -= pad.f[k];
|
|
max.f[k] += pad.f[k];
|
|
}
|
|
}
|
|
|
|
return valid;
|
|
}
|
|
|
|
QuantizationParams prepareQuantization(const std::vector<Mesh>& meshes, const Settings& settings)
|
|
{
|
|
QuantizationParams result = {};
|
|
|
|
result.pos_bits = settings.pos_bits;
|
|
|
|
Attr pos_min, pos_max;
|
|
if (getAttributeBounds(meshes, cgltf_attribute_type_position, pos_min, pos_max))
|
|
{
|
|
result.pos_offset[0] = pos_min.f[0];
|
|
result.pos_offset[1] = pos_min.f[1];
|
|
result.pos_offset[2] = pos_min.f[2];
|
|
result.pos_scale = std::max(pos_max.f[0] - pos_min.f[0], std::max(pos_max.f[1] - pos_min.f[1], pos_max.f[2] - pos_min.f[2]));
|
|
}
|
|
|
|
result.uv_bits = settings.tex_bits;
|
|
|
|
Attr uv_min, uv_max;
|
|
if (getAttributeBounds(meshes, cgltf_attribute_type_texcoord, uv_min, uv_max))
|
|
{
|
|
result.uv_offset[0] = uv_min.f[0];
|
|
result.uv_offset[1] = uv_min.f[1];
|
|
result.uv_scale[0] = uv_max.f[0] - uv_min.f[0];
|
|
result.uv_scale[1] = uv_max.f[1] - uv_min.f[1];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void rescaleNormal(float& nx, float& ny, float& nz)
|
|
{
|
|
// scale the normal to make sure the largest component is +-1.0
|
|
// this reduces the entropy of the normal by ~1.5 bits without losing precision
|
|
// it's better to use octahedral encoding but that requires special shader support
|
|
float nm = std::max(fabsf(nx), std::max(fabsf(ny), fabsf(nz)));
|
|
float ns = nm == 0.f ? 0.f : 1 / nm;
|
|
|
|
nx *= ns;
|
|
ny *= ns;
|
|
nz *= ns;
|
|
}
|
|
|
|
void renormalizeWeights(uint8_t (&w)[4])
|
|
{
|
|
int sum = w[0] + w[1] + w[2] + w[3];
|
|
|
|
if (sum == 255)
|
|
return;
|
|
|
|
// we assume that the total error is limited to 0.5/component = 2
|
|
// this means that it's acceptable to adjust the max. component to compensate for the error
|
|
int max = 0;
|
|
|
|
for (int k = 1; k < 4; ++k)
|
|
if (w[k] > w[max])
|
|
max = k;
|
|
|
|
w[max] += uint8_t(255 - sum);
|
|
}
|
|
|
|
StreamFormat writeVertexStream(std::string& bin, const Stream& stream, const QuantizationParams& params, const Settings& settings, bool has_targets)
|
|
{
|
|
if (stream.type == cgltf_attribute_type_position)
|
|
{
|
|
if (stream.target == 0)
|
|
{
|
|
float pos_rscale = params.pos_scale == 0.f ? 0.f : 1.f / params.pos_scale;
|
|
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
uint16_t v[4] = {
|
|
uint16_t(meshopt_quantizeUnorm((a.f[0] - params.pos_offset[0]) * pos_rscale, params.pos_bits)),
|
|
uint16_t(meshopt_quantizeUnorm((a.f[1] - params.pos_offset[1]) * pos_rscale, params.pos_bits)),
|
|
uint16_t(meshopt_quantizeUnorm((a.f[2] - params.pos_offset[2]) * pos_rscale, params.pos_bits)),
|
|
0};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_vec3, cgltf_component_type_r_16u, false, 8};
|
|
return format;
|
|
}
|
|
else
|
|
{
|
|
float pos_rscale = params.pos_scale == 0.f ? 0.f : 1.f / params.pos_scale;
|
|
|
|
int maxv = 0;
|
|
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
maxv = std::max(maxv, meshopt_quantizeUnorm(fabsf(a.f[0]) * pos_rscale, params.pos_bits));
|
|
maxv = std::max(maxv, meshopt_quantizeUnorm(fabsf(a.f[1]) * pos_rscale, params.pos_bits));
|
|
maxv = std::max(maxv, meshopt_quantizeUnorm(fabsf(a.f[2]) * pos_rscale, params.pos_bits));
|
|
}
|
|
|
|
if (maxv <= 127)
|
|
{
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
int8_t v[4] = {
|
|
int8_t((a.f[0] >= 0.f ? 1 : -1) * meshopt_quantizeUnorm(fabsf(a.f[0]) * pos_rscale, params.pos_bits)),
|
|
int8_t((a.f[1] >= 0.f ? 1 : -1) * meshopt_quantizeUnorm(fabsf(a.f[1]) * pos_rscale, params.pos_bits)),
|
|
int8_t((a.f[2] >= 0.f ? 1 : -1) * meshopt_quantizeUnorm(fabsf(a.f[2]) * pos_rscale, params.pos_bits)),
|
|
0};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_vec3, cgltf_component_type_r_8, false, 4};
|
|
return format;
|
|
}
|
|
else
|
|
{
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
int16_t v[4] = {
|
|
int16_t((a.f[0] >= 0.f ? 1 : -1) * meshopt_quantizeUnorm(fabsf(a.f[0]) * pos_rscale, params.pos_bits)),
|
|
int16_t((a.f[1] >= 0.f ? 1 : -1) * meshopt_quantizeUnorm(fabsf(a.f[1]) * pos_rscale, params.pos_bits)),
|
|
int16_t((a.f[2] >= 0.f ? 1 : -1) * meshopt_quantizeUnorm(fabsf(a.f[2]) * pos_rscale, params.pos_bits)),
|
|
0};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_vec3, cgltf_component_type_r_16, false, 8};
|
|
return format;
|
|
}
|
|
}
|
|
}
|
|
else if (stream.type == cgltf_attribute_type_texcoord)
|
|
{
|
|
float uv_rscale[2] = {
|
|
params.uv_scale[0] == 0.f ? 0.f : 1.f / params.uv_scale[0],
|
|
params.uv_scale[1] == 0.f ? 0.f : 1.f / params.uv_scale[1],
|
|
};
|
|
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
uint16_t v[2] = {
|
|
uint16_t(meshopt_quantizeUnorm((a.f[0] - params.uv_offset[0]) * uv_rscale[0], params.uv_bits)),
|
|
uint16_t(meshopt_quantizeUnorm((a.f[1] - params.uv_offset[1]) * uv_rscale[1], params.uv_bits)),
|
|
};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_vec2, cgltf_component_type_r_16u, false, 4};
|
|
return format;
|
|
}
|
|
else if (stream.type == cgltf_attribute_type_normal)
|
|
{
|
|
bool unnormalized = settings.nrm_unnormalized && !has_targets;
|
|
int bits = unnormalized ? settings.nrm_bits : (settings.nrm_bits > 8 ? 16 : 8);
|
|
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
float nx = a.f[0], ny = a.f[1], nz = a.f[2];
|
|
|
|
if (unnormalized)
|
|
rescaleNormal(nx, ny, nz);
|
|
|
|
if (bits > 8)
|
|
{
|
|
int16_t v[4] = {
|
|
int16_t(meshopt_quantizeSnorm(nx, bits)),
|
|
int16_t(meshopt_quantizeSnorm(ny, bits)),
|
|
int16_t(meshopt_quantizeSnorm(nz, bits)),
|
|
0};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
else
|
|
{
|
|
int8_t v[4] = {
|
|
int8_t(meshopt_quantizeSnorm(nx, bits)),
|
|
int8_t(meshopt_quantizeSnorm(ny, bits)),
|
|
int8_t(meshopt_quantizeSnorm(nz, bits)),
|
|
0};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
}
|
|
|
|
if (bits > 8)
|
|
{
|
|
StreamFormat format = {cgltf_type_vec3, cgltf_component_type_r_16, true, 8};
|
|
return format;
|
|
}
|
|
else
|
|
{
|
|
StreamFormat format = {cgltf_type_vec3, cgltf_component_type_r_8, true, 4};
|
|
return format;
|
|
}
|
|
}
|
|
else if (stream.type == cgltf_attribute_type_tangent)
|
|
{
|
|
bool unnormalized = settings.nrm_unnormalized && !has_targets;
|
|
int bits = unnormalized ? settings.nrm_bits : (settings.nrm_bits > 8 ? 16 : 8);
|
|
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
float nx = a.f[0], ny = a.f[1], nz = a.f[2], nw = a.f[3];
|
|
|
|
if (unnormalized)
|
|
rescaleNormal(nx, ny, nz);
|
|
|
|
if (bits > 8)
|
|
{
|
|
int16_t v[4] = {
|
|
int16_t(meshopt_quantizeSnorm(nx, bits)),
|
|
int16_t(meshopt_quantizeSnorm(ny, bits)),
|
|
int16_t(meshopt_quantizeSnorm(nz, bits)),
|
|
int16_t(meshopt_quantizeSnorm(nw, 8))};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
else
|
|
{
|
|
int8_t v[4] = {
|
|
int8_t(meshopt_quantizeSnorm(nx, bits)),
|
|
int8_t(meshopt_quantizeSnorm(ny, bits)),
|
|
int8_t(meshopt_quantizeSnorm(nz, bits)),
|
|
int8_t(meshopt_quantizeSnorm(nw, 8))};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
}
|
|
|
|
cgltf_type type = (stream.target == 0) ? cgltf_type_vec4 : cgltf_type_vec3;
|
|
|
|
if (bits > 8)
|
|
{
|
|
StreamFormat format = {type, cgltf_component_type_r_16, true, 8};
|
|
return format;
|
|
}
|
|
else
|
|
{
|
|
StreamFormat format = {type, cgltf_component_type_r_8, true, 4};
|
|
return format;
|
|
}
|
|
}
|
|
else if (stream.type == cgltf_attribute_type_color)
|
|
{
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
uint8_t v[4] = {
|
|
uint8_t(meshopt_quantizeUnorm(a.f[0], 8)),
|
|
uint8_t(meshopt_quantizeUnorm(a.f[1], 8)),
|
|
uint8_t(meshopt_quantizeUnorm(a.f[2], 8)),
|
|
uint8_t(meshopt_quantizeUnorm(a.f[3], 8))};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_vec4, cgltf_component_type_r_8u, true, 4};
|
|
return format;
|
|
}
|
|
else if (stream.type == cgltf_attribute_type_weights)
|
|
{
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
float ws = a.f[0] + a.f[1] + a.f[2] + a.f[3];
|
|
float wsi = (ws == 0.f) ? 0.f : 1.f / ws;
|
|
|
|
uint8_t v[4] = {
|
|
uint8_t(meshopt_quantizeUnorm(a.f[0] * wsi, 8)),
|
|
uint8_t(meshopt_quantizeUnorm(a.f[1] * wsi, 8)),
|
|
uint8_t(meshopt_quantizeUnorm(a.f[2] * wsi, 8)),
|
|
uint8_t(meshopt_quantizeUnorm(a.f[3] * wsi, 8))};
|
|
|
|
if (wsi != 0.f)
|
|
renormalizeWeights(v);
|
|
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_vec4, cgltf_component_type_r_8u, true, 4};
|
|
return format;
|
|
}
|
|
else if (stream.type == cgltf_attribute_type_joints)
|
|
{
|
|
unsigned int maxj = 0;
|
|
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
maxj = std::max(maxj, unsigned(stream.data[i].f[0]));
|
|
|
|
assert(maxj <= 65535);
|
|
|
|
if (maxj <= 255)
|
|
{
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
uint8_t v[4] = {
|
|
uint8_t(a.f[0]),
|
|
uint8_t(a.f[1]),
|
|
uint8_t(a.f[2]),
|
|
uint8_t(a.f[3])};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_vec4, cgltf_component_type_r_8u, false, 4};
|
|
return format;
|
|
}
|
|
else
|
|
{
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
uint16_t v[4] = {
|
|
uint16_t(a.f[0]),
|
|
uint16_t(a.f[1]),
|
|
uint16_t(a.f[2]),
|
|
uint16_t(a.f[3])};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_vec4, cgltf_component_type_r_16u, false, 8};
|
|
return format;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
float v[4] = {a.f[0], a.f[1], a.f[2], a.f[3]};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_vec4, cgltf_component_type_r_32f, false, 16};
|
|
return format;
|
|
}
|
|
}
|
|
|
|
void getPositionBounds(int min[3], int max[3], const Stream& stream, const QuantizationParams& params)
|
|
{
|
|
assert(stream.type == cgltf_attribute_type_position);
|
|
assert(stream.data.size() > 0);
|
|
|
|
min[0] = min[1] = min[2] = INT_MAX;
|
|
max[0] = max[1] = max[2] = INT_MIN;
|
|
|
|
float pos_rscale = params.pos_scale == 0.f ? 0.f : 1.f / params.pos_scale;
|
|
|
|
if (stream.target == 0)
|
|
{
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
for (int k = 0; k < 3; ++k)
|
|
{
|
|
int v = meshopt_quantizeUnorm((a.f[k] - params.pos_offset[k]) * pos_rscale, params.pos_bits);
|
|
|
|
min[k] = std::min(min[k], v);
|
|
max[k] = std::max(max[k], v);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (size_t i = 0; i < stream.data.size(); ++i)
|
|
{
|
|
const Attr& a = stream.data[i];
|
|
|
|
for (int k = 0; k < 3; ++k)
|
|
{
|
|
int v = (a.f[k] >= 0.f ? 1 : -1) * meshopt_quantizeUnorm(fabsf(a.f[k]) * pos_rscale, params.pos_bits);
|
|
|
|
min[k] = std::min(min[k], v);
|
|
max[k] = std::max(max[k], v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
StreamFormat writeIndexStream(std::string& bin, const std::vector<unsigned int>& stream)
|
|
{
|
|
unsigned int maxi = 0;
|
|
for (size_t i = 0; i < stream.size(); ++i)
|
|
maxi = std::max(maxi, stream[i]);
|
|
|
|
// save 16-bit indices if we can; note that we can't use restart index (65535)
|
|
if (maxi < 65535)
|
|
{
|
|
for (size_t i = 0; i < stream.size(); ++i)
|
|
{
|
|
uint16_t v[1] = {uint16_t(stream[i])};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_scalar, cgltf_component_type_r_16u, false, 2};
|
|
return format;
|
|
}
|
|
else
|
|
{
|
|
for (size_t i = 0; i < stream.size(); ++i)
|
|
{
|
|
uint32_t v[1] = {stream[i]};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_scalar, cgltf_component_type_r_32u, false, 4};
|
|
return format;
|
|
}
|
|
}
|
|
|
|
StreamFormat writeTimeStream(std::string& bin, const std::vector<float>& data)
|
|
{
|
|
for (size_t i = 0; i < data.size(); ++i)
|
|
{
|
|
float v[1] = {data[i]};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_scalar, cgltf_component_type_r_32f, false, 4};
|
|
return format;
|
|
}
|
|
|
|
StreamFormat writeKeyframeStream(std::string& bin, cgltf_animation_path_type type, const std::vector<Attr>& data)
|
|
{
|
|
if (type == cgltf_animation_path_type_rotation)
|
|
{
|
|
for (size_t i = 0; i < data.size(); ++i)
|
|
{
|
|
const Attr& a = data[i];
|
|
|
|
int16_t v[4] = {
|
|
int16_t(meshopt_quantizeSnorm(a.f[0], 16)),
|
|
int16_t(meshopt_quantizeSnorm(a.f[1], 16)),
|
|
int16_t(meshopt_quantizeSnorm(a.f[2], 16)),
|
|
int16_t(meshopt_quantizeSnorm(a.f[3], 16)),
|
|
};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_vec4, cgltf_component_type_r_16, true, 8};
|
|
return format;
|
|
}
|
|
else if (type == cgltf_animation_path_type_weights)
|
|
{
|
|
for (size_t i = 0; i < data.size(); ++i)
|
|
{
|
|
const Attr& a = data[i];
|
|
|
|
uint8_t v[1] = {uint8_t(meshopt_quantizeUnorm(a.f[0], 8))};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_scalar, cgltf_component_type_r_8u, true, 1};
|
|
return format;
|
|
}
|
|
else if (type == cgltf_animation_path_type_translation || type == cgltf_animation_path_type_scale)
|
|
{
|
|
int bits = 15;
|
|
|
|
for (size_t i = 0; i < data.size(); ++i)
|
|
{
|
|
const Attr& a = data[i];
|
|
|
|
float v[3] = {
|
|
meshopt_quantizeFloat(a.f[0], bits),
|
|
meshopt_quantizeFloat(a.f[1], bits),
|
|
meshopt_quantizeFloat(a.f[2], bits)};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_vec3, cgltf_component_type_r_32f, false, 12};
|
|
return format;
|
|
}
|
|
else
|
|
{
|
|
for (size_t i = 0; i < data.size(); ++i)
|
|
{
|
|
const Attr& a = data[i];
|
|
|
|
float v[4] = {a.f[0], a.f[1], a.f[2], a.f[3]};
|
|
bin.append(reinterpret_cast<const char*>(v), sizeof(v));
|
|
}
|
|
|
|
StreamFormat format = {cgltf_type_vec4, cgltf_component_type_r_32f, false, 16};
|
|
return format;
|
|
}
|
|
}
|
|
|
|
void compressVertexStream(std::string& bin, const std::string& data, size_t count, size_t stride)
|
|
{
|
|
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);
|
|
|
|
bin.append(reinterpret_cast<const char*>(&compressed[0]), size);
|
|
}
|
|
|
|
void compressIndexStream(std::string& bin, const std::string& data, size_t count, size_t stride)
|
|
{
|
|
assert(stride == 2 || stride == 4);
|
|
assert(data.size() == count * stride);
|
|
|
|
std::vector<unsigned char> compressed(meshopt_encodeIndexBufferBound(count, count * 3));
|
|
size_t size = 0;
|
|
|
|
if (stride == 2)
|
|
size = meshopt_encodeIndexBuffer(&compressed[0], compressed.size(), reinterpret_cast<const uint16_t*>(data.c_str()), count);
|
|
else
|
|
size = meshopt_encodeIndexBuffer(&compressed[0], compressed.size(), reinterpret_cast<const uint32_t*>(data.c_str()), count);
|
|
|
|
bin.append(reinterpret_cast<const char*>(&compressed[0]), size);
|
|
}
|
|
|
|
void comma(std::string& s)
|
|
{
|
|
char ch = s.empty() ? 0 : s[s.size() - 1];
|
|
|
|
if (ch != 0 && ch != '[' && ch != '{')
|
|
s += ",";
|
|
}
|
|
|
|
void append(std::string& s, size_t v)
|
|
{
|
|
char buf[32];
|
|
sprintf(buf, "%zu", v);
|
|
s += buf;
|
|
}
|
|
|
|
void append(std::string& s, float v)
|
|
{
|
|
char buf[512];
|
|
sprintf(buf, "%.9g", v);
|
|
s += buf;
|
|
}
|
|
|
|
void append(std::string& s, const char* v)
|
|
{
|
|
s += v;
|
|
}
|
|
|
|
void append(std::string& s, const std::string& v)
|
|
{
|
|
s += v;
|
|
}
|
|
|
|
const char* componentType(cgltf_component_type type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case cgltf_component_type_r_8:
|
|
return "5120";
|
|
case cgltf_component_type_r_8u:
|
|
return "5121";
|
|
case cgltf_component_type_r_16:
|
|
return "5122";
|
|
case cgltf_component_type_r_16u:
|
|
return "5123";
|
|
case cgltf_component_type_r_32u:
|
|
return "5125";
|
|
case cgltf_component_type_r_32f:
|
|
return "5126";
|
|
default:
|
|
return "0";
|
|
}
|
|
}
|
|
|
|
const char* shapeType(cgltf_type type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case cgltf_type_scalar:
|
|
return "SCALAR";
|
|
case cgltf_type_vec2:
|
|
return "VEC2";
|
|
case cgltf_type_vec3:
|
|
return "VEC3";
|
|
case cgltf_type_vec4:
|
|
return "VEC4";
|
|
case cgltf_type_mat2:
|
|
return "MAT2";
|
|
case cgltf_type_mat3:
|
|
return "MAT3";
|
|
case cgltf_type_mat4:
|
|
return "MAT4";
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
const char* attributeType(cgltf_attribute_type type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case cgltf_attribute_type_position:
|
|
return "POSITION";
|
|
case cgltf_attribute_type_normal:
|
|
return "NORMAL";
|
|
case cgltf_attribute_type_tangent:
|
|
return "TANGENT";
|
|
case cgltf_attribute_type_texcoord:
|
|
return "TEXCOORD";
|
|
case cgltf_attribute_type_color:
|
|
return "COLOR";
|
|
case cgltf_attribute_type_joints:
|
|
return "JOINTS";
|
|
case cgltf_attribute_type_weights:
|
|
return "WEIGHTS";
|
|
default:
|
|
return "ATTRIBUTE";
|
|
}
|
|
}
|
|
|
|
const char* animationPath(cgltf_animation_path_type type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case cgltf_animation_path_type_translation:
|
|
return "translation";
|
|
case cgltf_animation_path_type_rotation:
|
|
return "rotation";
|
|
case cgltf_animation_path_type_scale:
|
|
return "scale";
|
|
case cgltf_animation_path_type_weights:
|
|
return "weights";
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
const char* lightType(cgltf_light_type type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case cgltf_light_type_directional:
|
|
return "directional";
|
|
case cgltf_light_type_point:
|
|
return "point";
|
|
case cgltf_light_type_spot:
|
|
return "spot";
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
void writeTextureInfo(std::string& json, const cgltf_data* data, const cgltf_texture_view& view, const QuantizationParams& qp)
|
|
{
|
|
assert(view.texture);
|
|
|
|
cgltf_texture_transform transform = {};
|
|
|
|
if (view.has_transform)
|
|
{
|
|
transform = view.transform;
|
|
}
|
|
else
|
|
{
|
|
transform.scale[0] = transform.scale[1] = 1.f;
|
|
}
|
|
|
|
transform.offset[0] += qp.uv_offset[0];
|
|
transform.offset[1] += qp.uv_offset[1];
|
|
transform.scale[0] *= qp.uv_scale[0] / float((1 << qp.uv_bits) - 1);
|
|
transform.scale[1] *= qp.uv_scale[1] / float((1 << qp.uv_bits) - 1);
|
|
|
|
append(json, "{\"index\":");
|
|
append(json, size_t(view.texture - data->textures));
|
|
append(json, ",\"texCoord\":");
|
|
append(json, size_t(view.texcoord));
|
|
append(json, ",\"extensions\":{\"KHR_texture_transform\":{");
|
|
append(json, "\"offset\":[");
|
|
append(json, transform.offset[0]);
|
|
append(json, ",");
|
|
append(json, transform.offset[1]);
|
|
append(json, "],\"scale\":[");
|
|
append(json, transform.scale[0]);
|
|
append(json, ",");
|
|
append(json, transform.scale[1]);
|
|
append(json, "]");
|
|
if (transform.rotation != 0.f)
|
|
{
|
|
append(json, ",\"rotation\":");
|
|
append(json, transform.rotation);
|
|
}
|
|
append(json, "}}}");
|
|
}
|
|
|
|
void writeMaterialInfo(std::string& json, const cgltf_data* data, const cgltf_material& material, const QuantizationParams& qp)
|
|
{
|
|
static const float white[4] = {1, 1, 1, 1};
|
|
static const float black[4] = {0, 0, 0, 0};
|
|
|
|
if (material.name && *material.name)
|
|
{
|
|
comma(json);
|
|
append(json, "\"name\":\"");
|
|
append(json, material.name);
|
|
append(json, "\"");
|
|
}
|
|
|
|
if (material.has_pbr_metallic_roughness)
|
|
{
|
|
const cgltf_pbr_metallic_roughness& pbr = material.pbr_metallic_roughness;
|
|
|
|
comma(json);
|
|
append(json, "\"pbrMetallicRoughness\":{");
|
|
if (memcmp(pbr.base_color_factor, white, 16) != 0)
|
|
{
|
|
comma(json);
|
|
append(json, "\"baseColorFactor\":[");
|
|
append(json, pbr.base_color_factor[0]);
|
|
append(json, ",");
|
|
append(json, pbr.base_color_factor[1]);
|
|
append(json, ",");
|
|
append(json, pbr.base_color_factor[2]);
|
|
append(json, ",");
|
|
append(json, pbr.base_color_factor[3]);
|
|
append(json, "]");
|
|
}
|
|
if (pbr.base_color_texture.texture)
|
|
{
|
|
comma(json);
|
|
append(json, "\"baseColorTexture\":");
|
|
writeTextureInfo(json, data, pbr.base_color_texture, qp);
|
|
}
|
|
if (pbr.metallic_factor != 1)
|
|
{
|
|
comma(json);
|
|
append(json, "\"metallicFactor\":");
|
|
append(json, pbr.metallic_factor);
|
|
}
|
|
if (pbr.roughness_factor != 1)
|
|
{
|
|
comma(json);
|
|
append(json, "\"roughnessFactor\":");
|
|
append(json, pbr.roughness_factor);
|
|
}
|
|
if (pbr.metallic_roughness_texture.texture)
|
|
{
|
|
comma(json);
|
|
append(json, "\"metallicRoughnessTexture\":");
|
|
writeTextureInfo(json, data, pbr.metallic_roughness_texture, qp);
|
|
}
|
|
append(json, "}");
|
|
}
|
|
|
|
if (material.normal_texture.texture)
|
|
{
|
|
comma(json);
|
|
append(json, "\"normalTexture\":");
|
|
writeTextureInfo(json, data, material.normal_texture, qp);
|
|
}
|
|
|
|
if (material.occlusion_texture.texture)
|
|
{
|
|
comma(json);
|
|
append(json, "\"occlusionTexture\":");
|
|
writeTextureInfo(json, data, material.occlusion_texture, qp);
|
|
}
|
|
|
|
if (material.emissive_texture.texture)
|
|
{
|
|
comma(json);
|
|
append(json, "\"emissiveTexture\":");
|
|
writeTextureInfo(json, data, material.emissive_texture, qp);
|
|
}
|
|
|
|
if (memcmp(material.emissive_factor, black, 12) != 0)
|
|
{
|
|
comma(json);
|
|
append(json, "\"emissiveFactor\":[");
|
|
append(json, material.emissive_factor[0]);
|
|
append(json, ",");
|
|
append(json, material.emissive_factor[1]);
|
|
append(json, ",");
|
|
append(json, material.emissive_factor[2]);
|
|
append(json, "]");
|
|
}
|
|
|
|
if (material.alpha_mode != cgltf_alpha_mode_opaque)
|
|
{
|
|
comma(json);
|
|
append(json, "\"alphaMode\":");
|
|
append(json, (material.alpha_mode == cgltf_alpha_mode_blend) ? "\"BLEND\"" : "\"MASK\"");
|
|
}
|
|
|
|
if (material.alpha_cutoff != 0.5f)
|
|
{
|
|
comma(json);
|
|
append(json, "\"alphaCutoff\":");
|
|
append(json, material.alpha_cutoff);
|
|
}
|
|
|
|
if (material.double_sided)
|
|
{
|
|
comma(json);
|
|
append(json, "\"doubleSided\":true");
|
|
}
|
|
|
|
if (material.has_pbr_specular_glossiness || material.unlit)
|
|
{
|
|
comma(json);
|
|
append(json, "\"extensions\":{");
|
|
|
|
if (material.has_pbr_specular_glossiness)
|
|
{
|
|
const cgltf_pbr_specular_glossiness& pbr = material.pbr_specular_glossiness;
|
|
|
|
comma(json);
|
|
append(json, "\"KHR_materials_pbrSpecularGlossiness\":{");
|
|
if (pbr.diffuse_texture.texture)
|
|
{
|
|
comma(json);
|
|
append(json, "\"diffuseTexture\":");
|
|
writeTextureInfo(json, data, pbr.diffuse_texture, qp);
|
|
}
|
|
if (pbr.specular_glossiness_texture.texture)
|
|
{
|
|
comma(json);
|
|
append(json, "\"specularGlossinessTexture\":");
|
|
writeTextureInfo(json, data, pbr.specular_glossiness_texture, qp);
|
|
}
|
|
if (memcmp(pbr.diffuse_factor, white, 16) != 0)
|
|
{
|
|
comma(json);
|
|
append(json, "\"diffuseFactor\":[");
|
|
append(json, pbr.diffuse_factor[0]);
|
|
append(json, ",");
|
|
append(json, pbr.diffuse_factor[1]);
|
|
append(json, ",");
|
|
append(json, pbr.diffuse_factor[2]);
|
|
append(json, ",");
|
|
append(json, pbr.diffuse_factor[3]);
|
|
append(json, "]");
|
|
}
|
|
if (memcmp(pbr.specular_factor, white, 12) != 0)
|
|
{
|
|
comma(json);
|
|
append(json, "\"specularFactor\":[");
|
|
append(json, pbr.specular_factor[0]);
|
|
append(json, ",");
|
|
append(json, pbr.specular_factor[1]);
|
|
append(json, ",");
|
|
append(json, pbr.specular_factor[2]);
|
|
append(json, "]");
|
|
}
|
|
if (pbr.glossiness_factor != 1)
|
|
{
|
|
comma(json);
|
|
append(json, "\"glossinessFactor\":");
|
|
append(json, pbr.glossiness_factor);
|
|
}
|
|
append(json, "}");
|
|
}
|
|
if (material.unlit)
|
|
{
|
|
comma(json);
|
|
append(json, "\"KHR_materials_unlit\":{}");
|
|
}
|
|
|
|
append(json, "}");
|
|
}
|
|
}
|
|
|
|
bool usesTextureSet(const cgltf_material& material, int set)
|
|
{
|
|
if (material.has_pbr_metallic_roughness)
|
|
{
|
|
const cgltf_pbr_metallic_roughness& pbr = material.pbr_metallic_roughness;
|
|
|
|
if (pbr.base_color_texture.texture && pbr.base_color_texture.texcoord == set)
|
|
return true;
|
|
|
|
if (pbr.metallic_roughness_texture.texture && pbr.metallic_roughness_texture.texcoord == set)
|
|
return true;
|
|
}
|
|
|
|
if (material.has_pbr_specular_glossiness)
|
|
{
|
|
const cgltf_pbr_specular_glossiness& pbr = material.pbr_specular_glossiness;
|
|
|
|
if (pbr.diffuse_texture.texture && pbr.diffuse_texture.texcoord == set)
|
|
return true;
|
|
|
|
if (pbr.specular_glossiness_texture.texture && pbr.specular_glossiness_texture.texcoord == set)
|
|
return true;
|
|
}
|
|
|
|
if (material.normal_texture.texture && material.normal_texture.texcoord == set)
|
|
return true;
|
|
|
|
if (material.occlusion_texture.texture && material.occlusion_texture.texcoord == set)
|
|
return true;
|
|
|
|
if (material.emissive_texture.texture && material.emissive_texture.texcoord == set)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
size_t getBufferView(std::vector<BufferView>& views, BufferView::Kind kind, int variant, size_t stride, bool compressed)
|
|
{
|
|
if (variant >= 0)
|
|
{
|
|
for (size_t i = 0; i < views.size(); ++i)
|
|
if (views[i].kind == kind && views[i].variant == variant && views[i].stride == stride && views[i].compressed == compressed)
|
|
return i;
|
|
}
|
|
|
|
BufferView view = {kind, variant, stride, compressed};
|
|
views.push_back(view);
|
|
|
|
return views.size() - 1;
|
|
}
|
|
|
|
void writeBufferView(std::string& json, BufferView::Kind kind, size_t count, size_t stride, size_t bin_offset, size_t bin_size, int compression, size_t compressed_offset, size_t compressed_size)
|
|
{
|
|
assert(bin_size == count * stride);
|
|
|
|
// when compression is enabled, we store uncompressed data in buffer 1 and compressed data in buffer 0
|
|
// when compression is disabled, we store uncompressed data in buffer 0
|
|
size_t buffer = compression >= 0 ? 1 : 0;
|
|
|
|
append(json, "{\"buffer\":");
|
|
append(json, buffer);
|
|
append(json, ",\"byteOffset\":");
|
|
append(json, bin_offset);
|
|
append(json, ",\"byteLength\":");
|
|
append(json, bin_size);
|
|
if (kind == BufferView::Kind_Vertex)
|
|
{
|
|
append(json, ",\"byteStride\":");
|
|
append(json, stride);
|
|
}
|
|
if (kind == BufferView::Kind_Vertex || kind == BufferView::Kind_Index)
|
|
{
|
|
append(json, ",\"target\":");
|
|
append(json, (kind == BufferView::Kind_Vertex) ? "34962" : "34963");
|
|
}
|
|
if (compression >= 0)
|
|
{
|
|
append(json, ",\"extensions\":{");
|
|
append(json, "\"MESHOPT_compression\":{");
|
|
append(json, "\"buffer\":0");
|
|
append(json, ",\"byteOffset\":");
|
|
append(json, size_t(compressed_offset));
|
|
append(json, ",\"byteLength\":");
|
|
append(json, size_t(compressed_size));
|
|
append(json, ",\"byteStride\":");
|
|
append(json, stride);
|
|
append(json, ",\"mode\":");
|
|
append(json, size_t(compression));
|
|
append(json, ",\"count\":");
|
|
append(json, count);
|
|
append(json, "}}");
|
|
}
|
|
append(json, "}");
|
|
}
|
|
|
|
void writeAccessor(std::string& json, size_t view, size_t offset, cgltf_type type, cgltf_component_type component_type, bool normalized, size_t count, const float* min = 0, const float* max = 0, size_t numminmax = 0)
|
|
{
|
|
append(json, "{\"bufferView\":");
|
|
append(json, view);
|
|
append(json, ",\"byteOffset\":");
|
|
append(json, offset);
|
|
append(json, ",\"componentType\":");
|
|
append(json, componentType(component_type));
|
|
append(json, ",\"count\":");
|
|
append(json, count);
|
|
append(json, ",\"type\":\"");
|
|
append(json, shapeType(type));
|
|
append(json, "\"");
|
|
|
|
if (normalized)
|
|
{
|
|
append(json, ",\"normalized\":true");
|
|
}
|
|
|
|
if (min && max)
|
|
{
|
|
assert(numminmax);
|
|
|
|
append(json, ",\"min\":[");
|
|
for (size_t k = 0; k < numminmax; ++k)
|
|
{
|
|
comma(json);
|
|
append(json, min[k]);
|
|
}
|
|
append(json, "],\"max\":[");
|
|
for (size_t k = 0; k < numminmax; ++k)
|
|
{
|
|
comma(json);
|
|
append(json, max[k]);
|
|
}
|
|
append(json, "]");
|
|
}
|
|
|
|
append(json, "}");
|
|
}
|
|
|
|
float getDelta(const Attr& l, const Attr& r, cgltf_animation_path_type type)
|
|
{
|
|
if (type == cgltf_animation_path_type_rotation)
|
|
{
|
|
float error = 1.f - fabsf(l.f[0] * r.f[0] + l.f[1] * r.f[1] + l.f[2] * r.f[2] + l.f[3] * r.f[3]);
|
|
|
|
return error;
|
|
}
|
|
else
|
|
{
|
|
float error = 0;
|
|
for (int k = 0; k < 4; ++k)
|
|
error += fabsf(r.f[k] - l.f[k]);
|
|
|
|
return error;
|
|
}
|
|
}
|
|
|
|
bool isTrackConstant(const cgltf_animation_sampler& sampler, cgltf_animation_path_type type, cgltf_node* target_node, Attr* out_first = 0)
|
|
{
|
|
const float tolerance = 1e-3f;
|
|
|
|
size_t value_stride = (sampler.interpolation == cgltf_interpolation_type_cubic_spline) ? 3 : 1;
|
|
size_t value_offset = (sampler.interpolation == cgltf_interpolation_type_cubic_spline) ? 1 : 0;
|
|
|
|
size_t components = (type == cgltf_animation_path_type_weights) ? target_node->mesh->primitives[0].targets_count : 1;
|
|
|
|
assert(sampler.input->count * value_stride * components == sampler.output->count);
|
|
|
|
std::vector<Attr> output;
|
|
readAccessor(output, sampler.output);
|
|
|
|
for (size_t j = 0; j < components; ++j)
|
|
{
|
|
Attr first = output[j * value_stride + value_offset];
|
|
|
|
for (size_t i = 1; i < sampler.input->count; ++i)
|
|
{
|
|
const Attr& attr = output[(i * components + j) * value_stride + value_offset];
|
|
|
|
if (getDelta(first, attr, type) > tolerance)
|
|
return false;
|
|
}
|
|
|
|
if (sampler.interpolation == cgltf_interpolation_type_cubic_spline)
|
|
{
|
|
for (size_t i = 0; i < sampler.input->count; ++i)
|
|
{
|
|
for (int k = 0; k < 2; ++k)
|
|
{
|
|
const Attr& t = output[(i * components + j) * 3 + k * 2];
|
|
|
|
float error = fabsf(t.f[0]) + fabsf(t.f[1]) + fabsf(t.f[2]) + fabsf(t.f[3]);
|
|
|
|
if (error > tolerance)
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (out_first)
|
|
*out_first = output[value_offset];
|
|
|
|
return true;
|
|
}
|
|
|
|
Attr interpolateLinear(const Attr& l, const Attr& r, float t, cgltf_animation_path_type type)
|
|
{
|
|
if (type == cgltf_animation_path_type_rotation)
|
|
{
|
|
// Approximating slerp, https://zeux.io/2015/07/23/approximating-slerp/
|
|
// We also handle quaternion double-cover
|
|
float ca = l.f[0] * r.f[0] + l.f[1] * r.f[1] + l.f[2] * r.f[2] + l.f[3] * r.f[3];
|
|
|
|
float d = fabsf(ca);
|
|
float A = 1.0904f + d * (-3.2452f + d * (3.55645f - d * 1.43519f));
|
|
float B = 0.848013f + d * (-1.06021f + d * 0.215638f);
|
|
float k = A * (t - 0.5f) * (t - 0.5f) + B;
|
|
float ot = t + t * (t - 0.5f) * (t - 1) * k;
|
|
|
|
float t0 = 1 - ot;
|
|
float t1 = ca > 0 ? ot : -ot;
|
|
|
|
Attr lerp = {{
|
|
l.f[0] * t0 + r.f[0] * t1,
|
|
l.f[1] * t0 + r.f[1] * t1,
|
|
l.f[2] * t0 + r.f[2] * t1,
|
|
l.f[3] * t0 + r.f[3] * t1,
|
|
}};
|
|
|
|
float len = sqrtf(lerp.f[0] * lerp.f[0] + lerp.f[1] * lerp.f[1] + lerp.f[2] * lerp.f[2] + lerp.f[3] * lerp.f[3]);
|
|
|
|
if (len > 0.f)
|
|
{
|
|
lerp.f[0] /= len;
|
|
lerp.f[1] /= len;
|
|
lerp.f[2] /= len;
|
|
lerp.f[3] /= len;
|
|
}
|
|
|
|
return lerp;
|
|
}
|
|
else
|
|
{
|
|
Attr lerp = {{
|
|
l.f[0] * (1 - t) + r.f[0] * t,
|
|
l.f[1] * (1 - t) + r.f[1] * t,
|
|
l.f[2] * (1 - t) + r.f[2] * t,
|
|
l.f[3] * (1 - t) + r.f[3] * t,
|
|
}};
|
|
|
|
return lerp;
|
|
}
|
|
}
|
|
|
|
Attr interpolateHermite(const Attr& v0, const Attr& t0, const Attr& v1, const Attr& t1, float t, float dt, cgltf_animation_path_type type)
|
|
{
|
|
float s0 = 1 + t * t * (2 * t - 3);
|
|
float s1 = t + t * t * (t - 2);
|
|
float s2 = 1 - s0;
|
|
float s3 = t * t * (t - 1);
|
|
|
|
float ts1 = dt * s1;
|
|
float ts3 = dt * s3;
|
|
|
|
Attr lerp = {{
|
|
s0 * v0.f[0] + ts1 * t0.f[0] + s2 * v1.f[0] + ts3 * t1.f[0],
|
|
s0 * v0.f[1] + ts1 * t0.f[1] + s2 * v1.f[1] + ts3 * t1.f[1],
|
|
s0 * v0.f[2] + ts1 * t0.f[2] + s2 * v1.f[2] + ts3 * t1.f[2],
|
|
s0 * v0.f[3] + ts1 * t0.f[3] + s2 * v1.f[3] + ts3 * t1.f[3],
|
|
}};
|
|
|
|
if (type == cgltf_animation_path_type_rotation)
|
|
{
|
|
float len = sqrtf(lerp.f[0] * lerp.f[0] + lerp.f[1] * lerp.f[1] + lerp.f[2] * lerp.f[2] + lerp.f[3] * lerp.f[3]);
|
|
|
|
if (len > 0.f)
|
|
{
|
|
lerp.f[0] /= len;
|
|
lerp.f[1] /= len;
|
|
lerp.f[2] /= len;
|
|
lerp.f[3] /= len;
|
|
}
|
|
}
|
|
|
|
return lerp;
|
|
}
|
|
|
|
void resampleKeyframes(std::vector<Attr>& data, const cgltf_animation_sampler& sampler, cgltf_animation_path_type type, cgltf_node* target_node, int frames, float mint, int freq)
|
|
{
|
|
size_t components = (type == cgltf_animation_path_type_weights) ? target_node->mesh->primitives[0].targets_count : 1;
|
|
|
|
std::vector<float> input;
|
|
readAccessor(input, sampler.input);
|
|
std::vector<Attr> output;
|
|
readAccessor(output, sampler.output);
|
|
|
|
size_t cursor = 0;
|
|
|
|
for (int i = 0; i < frames; ++i)
|
|
{
|
|
float time = mint + float(i) / freq;
|
|
|
|
while (cursor + 1 < sampler.input->count)
|
|
{
|
|
float next_time = input[cursor + 1];
|
|
|
|
if (next_time > time)
|
|
break;
|
|
|
|
cursor++;
|
|
}
|
|
|
|
if (cursor + 1 < sampler.input->count)
|
|
{
|
|
float cursor_time = input[cursor + 0];
|
|
float next_time = input[cursor + 1];
|
|
|
|
float range = next_time - cursor_time;
|
|
float inv_range = (range == 0.f) ? 0.f : 1.f / (next_time - cursor_time);
|
|
float t = std::max(0.f, std::min(1.f, (time - cursor_time) * inv_range));
|
|
|
|
for (size_t j = 0; j < components; ++j)
|
|
{
|
|
switch (sampler.interpolation)
|
|
{
|
|
case cgltf_interpolation_type_linear:
|
|
{
|
|
const Attr& v0 = output[(cursor + 0) * components + j];
|
|
const Attr& v1 = output[(cursor + 1) * components + j];
|
|
data.push_back(interpolateLinear(v0, v1, t, type));
|
|
}
|
|
break;
|
|
|
|
case cgltf_interpolation_type_step:
|
|
{
|
|
const Attr& v = output[cursor * components + j];
|
|
data.push_back(v);
|
|
}
|
|
break;
|
|
|
|
case cgltf_interpolation_type_cubic_spline:
|
|
{
|
|
const Attr& v0 = output[(cursor * 3 + 1) * components + j];
|
|
const Attr& b0 = output[(cursor * 3 + 2) * components + j];
|
|
const Attr& a1 = output[(cursor * 3 + 3) * components + j];
|
|
const Attr& v1 = output[(cursor * 3 + 4) * components + j];
|
|
data.push_back(interpolateHermite(v0, b0, v1, a1, t, range, type));
|
|
}
|
|
break;
|
|
|
|
default:
|
|
assert(!"Unknown interpolation type");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
size_t offset = (sampler.interpolation == cgltf_interpolation_type_cubic_spline) ? cursor * 3 + 1 : cursor;
|
|
|
|
for (size_t j = 0; j < components; ++j)
|
|
{
|
|
const Attr& v = output[offset * components + j];
|
|
data.push_back(v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void markAnimated(cgltf_data* data, std::vector<NodeInfo>& nodes)
|
|
{
|
|
for (size_t i = 0; i < data->animations_count; ++i)
|
|
{
|
|
const cgltf_animation& animation = data->animations[i];
|
|
|
|
for (size_t j = 0; j < animation.channels_count; ++j)
|
|
{
|
|
const cgltf_animation_channel& channel = animation.channels[j];
|
|
const cgltf_animation_sampler& sampler = *channel.sampler;
|
|
|
|
if (!channel.target_node)
|
|
continue;
|
|
|
|
NodeInfo& ni = nodes[channel.target_node - data->nodes];
|
|
|
|
// mark nodes that have animation tracks that change their base transform as animated
|
|
Attr first = {};
|
|
if (!isTrackConstant(sampler, channel.target_path, channel.target_node, &first))
|
|
{
|
|
ni.animated_paths |= (1 << channel.target_path);
|
|
}
|
|
else if (channel.target_path == cgltf_animation_path_type_weights)
|
|
{
|
|
// we currently preserve constant weight tracks because the usecase is very rare and
|
|
// isTrackConstant doesn't return the full set of weights to compare against
|
|
ni.animated_paths |= (1 << channel.target_path);
|
|
}
|
|
else
|
|
{
|
|
Attr base = {};
|
|
|
|
switch (channel.target_path)
|
|
{
|
|
case cgltf_animation_path_type_translation:
|
|
memcpy(base.f, channel.target_node->translation, 3 * sizeof(float));
|
|
break;
|
|
case cgltf_animation_path_type_rotation:
|
|
memcpy(base.f, channel.target_node->rotation, 4 * sizeof(float));
|
|
break;
|
|
case cgltf_animation_path_type_scale:
|
|
memcpy(base.f, channel.target_node->scale, 3 * sizeof(float));
|
|
break;
|
|
default:
|
|
assert(!"Unknown target path");
|
|
}
|
|
|
|
const float tolerance = 1e-3f;
|
|
|
|
if (getDelta(base, first, channel.target_path) > tolerance)
|
|
{
|
|
ni.animated_paths |= (1 << channel.target_path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (size_t i = 0; i < data->nodes_count; ++i)
|
|
{
|
|
NodeInfo& ni = nodes[i];
|
|
|
|
for (cgltf_node* node = &data->nodes[i]; node; node = node->parent)
|
|
ni.animated |= nodes[node - data->nodes].animated_paths != 0;
|
|
}
|
|
}
|
|
|
|
void markNeededNodes(cgltf_data* data, std::vector<NodeInfo>& nodes, const std::vector<Mesh>& meshes, const Settings& settings)
|
|
{
|
|
// mark all joints as kept
|
|
for (size_t i = 0; i < data->skins_count; ++i)
|
|
{
|
|
const cgltf_skin& skin = data->skins[i];
|
|
|
|
// for now we keep all joints directly referenced by the skin and the entire ancestry tree; we keep names for joints as well
|
|
for (size_t j = 0; j < skin.joints_count; ++j)
|
|
{
|
|
NodeInfo& ni = nodes[skin.joints[j] - data->nodes];
|
|
|
|
ni.keep = true;
|
|
}
|
|
}
|
|
|
|
// mark all animated nodes as kept
|
|
for (size_t i = 0; i < data->animations_count; ++i)
|
|
{
|
|
const cgltf_animation& animation = data->animations[i];
|
|
|
|
for (size_t j = 0; j < animation.channels_count; ++j)
|
|
{
|
|
const cgltf_animation_channel& channel = animation.channels[j];
|
|
|
|
if (channel.target_node)
|
|
{
|
|
NodeInfo& ni = nodes[channel.target_node - data->nodes];
|
|
|
|
ni.keep = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// mark all mesh nodes as kept
|
|
for (size_t i = 0; i < meshes.size(); ++i)
|
|
{
|
|
const Mesh& mesh = meshes[i];
|
|
|
|
if (mesh.node)
|
|
{
|
|
NodeInfo& ni = nodes[mesh.node - data->nodes];
|
|
|
|
ni.keep = true;
|
|
}
|
|
}
|
|
|
|
// mark all light/camera nodes as kept
|
|
for (size_t i = 0; i < data->nodes_count; ++i)
|
|
{
|
|
const cgltf_node& node = data->nodes[i];
|
|
|
|
if (node.light || node.camera)
|
|
{
|
|
nodes[i].keep = true;
|
|
}
|
|
}
|
|
|
|
// mark all named nodes as needed (if -kn is specified)
|
|
if (settings.keep_named)
|
|
{
|
|
for (size_t i = 0; i < data->nodes_count; ++i)
|
|
{
|
|
const cgltf_node& node = data->nodes[i];
|
|
|
|
if (node.name && *node.name)
|
|
{
|
|
nodes[i].keep = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void markNeededMaterials(cgltf_data* data, std::vector<MaterialInfo>& materials, const std::vector<Mesh>& meshes)
|
|
{
|
|
// mark all used materials as kept
|
|
for (size_t i = 0; i < meshes.size(); ++i)
|
|
{
|
|
const Mesh& mesh = meshes[i];
|
|
|
|
if (mesh.material)
|
|
{
|
|
MaterialInfo& mi = materials[mesh.material - data->materials];
|
|
|
|
mi.keep = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void remapNodes(cgltf_data* data, std::vector<NodeInfo>& nodes, size_t& node_offset)
|
|
{
|
|
// to keep a node, we currently need to keep the entire ancestry chain
|
|
for (size_t i = 0; i < data->nodes_count; ++i)
|
|
{
|
|
if (!nodes[i].keep)
|
|
continue;
|
|
|
|
for (cgltf_node* node = &data->nodes[i]; node; node = node->parent)
|
|
nodes[node - data->nodes].keep = true;
|
|
}
|
|
|
|
// generate sequential indices for all nodes; they aren't sorted topologically
|
|
for (size_t i = 0; i < data->nodes_count; ++i)
|
|
{
|
|
NodeInfo& ni = nodes[i];
|
|
|
|
if (ni.keep)
|
|
{
|
|
ni.remap = int(node_offset);
|
|
|
|
node_offset++;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool parseDataUri(const char* uri, std::string& mime_type, std::string& result)
|
|
{
|
|
if (strncmp(uri, "data:", 5) == 0)
|
|
{
|
|
const char* comma = strchr(uri, ',');
|
|
|
|
if (comma && comma - uri >= 7 && strncmp(comma - 7, ";base64", 7) == 0)
|
|
{
|
|
const char* base64 = comma + 1;
|
|
size_t base64_size = strlen(base64);
|
|
size_t size = base64_size - base64_size / 4;
|
|
|
|
if (base64_size >= 2)
|
|
{
|
|
size -= base64[base64_size - 2] == '=';
|
|
size -= base64[base64_size - 1] == '=';
|
|
}
|
|
|
|
void* data = 0;
|
|
|
|
cgltf_options options = {};
|
|
cgltf_result res = cgltf_load_buffer_base64(&options, size, base64, &data);
|
|
|
|
if (res != cgltf_result_success)
|
|
return false;
|
|
|
|
mime_type = std::string(uri + 5, comma - 7);
|
|
result = std::string(static_cast<const char*>(data), size);
|
|
|
|
free(data);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void writeEmbeddedImage(std::string& json, std::vector<BufferView>& views, const char* data, size_t size, const char* mime_type)
|
|
{
|
|
size_t view = getBufferView(views, BufferView::Kind_Image, -1, 1, false);
|
|
|
|
assert(views[view].data.empty());
|
|
views[view].data.assign(data, size);
|
|
|
|
append(json, "\"bufferView\":");
|
|
append(json, view);
|
|
append(json, ",\"mimeType\":\"");
|
|
append(json, mime_type);
|
|
append(json, "\"");
|
|
}
|
|
|
|
std::string inferMimeType(const char* path)
|
|
{
|
|
const char* ext = strrchr(path, '.');
|
|
if (!ext)
|
|
return "";
|
|
|
|
std::string extl = ext + 1;
|
|
for (size_t i = 0; i < extl.length(); ++i)
|
|
extl[i] = tolower(extl[i]);
|
|
|
|
if (extl == "jpg")
|
|
return "image/jpeg";
|
|
else
|
|
return "image/" + extl;
|
|
}
|
|
|
|
std::string getFullPath(const char* path, const char* base_path)
|
|
{
|
|
std::string result = base_path;
|
|
|
|
std::string::size_type slash = result.find_last_of("/\\");
|
|
result.erase(slash == std::string::npos ? 0 : slash + 1);
|
|
|
|
result += path;
|
|
|
|
return result;
|
|
}
|
|
|
|
std::string getFileName(const char* path)
|
|
{
|
|
std::string result = path;
|
|
|
|
std::string::size_type slash = result.find_last_of("/\\");
|
|
if (slash != std::string::npos)
|
|
result.erase(0, slash + 1);
|
|
|
|
std::string::size_type dot = result.find_last_of('.');
|
|
if (dot != std::string::npos)
|
|
result.erase(dot);
|
|
|
|
return result;
|
|
}
|
|
|
|
bool readFile(const char* path, std::string& data)
|
|
{
|
|
FILE* file = fopen(path, "rb");
|
|
if (!file)
|
|
return false;
|
|
|
|
fseek(file, 0, SEEK_END);
|
|
long length = ftell(file);
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
if (length <= 0)
|
|
{
|
|
fclose(file);
|
|
return false;
|
|
}
|
|
|
|
data.resize(length);
|
|
size_t result = fread(&data[0], 1, data.size(), file);
|
|
fclose(file);
|
|
|
|
return result == data.size();
|
|
}
|
|
|
|
bool writeFile(const char* path, const std::string& data)
|
|
{
|
|
FILE* file = fopen(path, "wb");
|
|
if (!file)
|
|
return false;
|
|
|
|
size_t result = fwrite(&data[0], 1, data.size(), file);
|
|
fclose(file);
|
|
|
|
return result == data.size();
|
|
}
|
|
|
|
struct TempFile
|
|
{
|
|
std::string path;
|
|
int fd;
|
|
|
|
TempFile(const char* suffix)
|
|
: fd(-1)
|
|
{
|
|
#ifdef _WIN32
|
|
const char* temp_dir = getenv("TEMP");
|
|
path = temp_dir ? temp_dir : ".";
|
|
path += "\\gltfpack-XXXXXX";
|
|
(void)_mktemp(&path[0]);
|
|
path += suffix;
|
|
#else
|
|
path = "/tmp/gltfpack-XXXXXX";
|
|
path += suffix;
|
|
fd = mkstemps(&path[0], strlen(suffix));
|
|
#endif
|
|
}
|
|
|
|
~TempFile()
|
|
{
|
|
unlink(path.c_str());
|
|
#ifndef _WIN32
|
|
close(fd);
|
|
#endif
|
|
}
|
|
};
|
|
|
|
bool encodeBasis(const std::string& data, std::string& result, bool normal_map, int quality)
|
|
{
|
|
TempFile temp_input(".raw");
|
|
TempFile temp_output(".basis");
|
|
|
|
if (!writeFile(temp_input.path.c_str(), data))
|
|
return false;
|
|
|
|
const char* basisu_path = getenv("BASISU_PATH");
|
|
std::string cmd = basisu_path ? basisu_path : "basisu";
|
|
|
|
char ql[16];
|
|
sprintf(ql, "%d", (quality * 255 + 50) / 100);
|
|
|
|
cmd += " -q ";
|
|
cmd += ql;
|
|
|
|
cmd += " -mipmap";
|
|
if (normal_map)
|
|
{
|
|
cmd += " -normal_map";
|
|
// for optimal quality we should specify seperate_rg_to_color_alpha but this requires renderer awareness
|
|
}
|
|
|
|
cmd += " -file ";
|
|
cmd += temp_input.path;
|
|
cmd += " -output_file ";
|
|
cmd += temp_output.path;
|
|
|
|
#ifdef _WIN32
|
|
cmd += " >nul";
|
|
#else
|
|
cmd += " >/dev/null";
|
|
#endif
|
|
|
|
int rc = system(cmd.c_str());
|
|
|
|
return rc == 0 && readFile(temp_output.path.c_str(), result);
|
|
}
|
|
|
|
void writeImage(std::string& json, std::vector<BufferView>& views, const cgltf_image& image, const ImageInfo& info, size_t index, const char* input_path, const char* output_path, const Settings& settings)
|
|
{
|
|
std::string img_data;
|
|
std::string mime_type;
|
|
|
|
if (image.uri && parseDataUri(image.uri, mime_type, img_data))
|
|
{
|
|
// we will re-embed img_data below
|
|
}
|
|
else if (image.buffer_view && image.buffer_view->buffer->data && image.mime_type)
|
|
{
|
|
const cgltf_buffer_view* view = image.buffer_view;
|
|
|
|
img_data.assign(static_cast<const char*>(view->buffer->data) + view->offset, view->size);
|
|
mime_type = image.mime_type;
|
|
}
|
|
else if (image.uri && settings.texture_embed)
|
|
{
|
|
std::string full_path = getFullPath(image.uri, input_path);
|
|
|
|
if (!readFile(full_path.c_str(), img_data))
|
|
{
|
|
fprintf(stderr, "Warning: unable to read image %s, skipping\n", image.uri);
|
|
}
|
|
|
|
mime_type = inferMimeType(image.uri);
|
|
}
|
|
|
|
if (!img_data.empty())
|
|
{
|
|
if (settings.texture_basis)
|
|
{
|
|
std::string encoded;
|
|
|
|
if (encodeBasis(img_data, encoded, info.normal_map, settings.texture_quality))
|
|
{
|
|
writeEmbeddedImage(json, views, encoded.c_str(), encoded.size(), "image/basis");
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Warning: unable to encode image %d with Basis, skipping\n", int(index));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
writeEmbeddedImage(json, views, img_data.c_str(), img_data.size(), mime_type.c_str());
|
|
}
|
|
}
|
|
else if (image.uri)
|
|
{
|
|
if (settings.texture_basis)
|
|
{
|
|
std::string full_path = getFullPath(image.uri, input_path);
|
|
std::string basis_path = getFileName(image.uri) + ".basis";
|
|
std::string basis_full_path = getFullPath(basis_path.c_str(), output_path);
|
|
|
|
if (!readFile(full_path.c_str(), img_data))
|
|
{
|
|
fprintf(stderr, "Warning: unable to read image %s, skipping\n", image.uri);
|
|
}
|
|
else
|
|
{
|
|
std::string encoded;
|
|
|
|
if (!encodeBasis(img_data, encoded, info.normal_map, settings.texture_quality))
|
|
{
|
|
fprintf(stderr, "Warning: unable to encode image %s with Basis, skipping\n", image.uri);
|
|
}
|
|
else if (!writeFile(basis_full_path.c_str(), encoded))
|
|
{
|
|
fprintf(stderr, "Warning: unable to save Basis image %s, skipping\n", image.uri);
|
|
}
|
|
else
|
|
{
|
|
append(json, "\"uri\":\"");
|
|
append(json, basis_path);
|
|
append(json, "\"");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
append(json, "\"uri\":\"");
|
|
append(json, image.uri);
|
|
append(json, "\"");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Warning: ignoring image %d since it has no URI and no valid buffer data\n", int(index));
|
|
}
|
|
}
|
|
|
|
void writeMeshAttributes(std::string& json, std::vector<BufferView>& views, std::string& json_accessors, size_t& accr_offset, const Mesh& mesh, int target, const QuantizationParams& qp, const Settings& settings)
|
|
{
|
|
std::string scratch;
|
|
|
|
for (size_t j = 0; j < mesh.streams.size(); ++j)
|
|
{
|
|
const Stream& stream = mesh.streams[j];
|
|
|
|
if (stream.target != target)
|
|
continue;
|
|
|
|
if (stream.type == cgltf_attribute_type_texcoord && (!mesh.material || !usesTextureSet(*mesh.material, stream.index)))
|
|
continue;
|
|
|
|
if (stream.type == cgltf_attribute_type_tangent && (!mesh.material || !mesh.material->normal_texture.texture))
|
|
continue;
|
|
|
|
if ((stream.type == cgltf_attribute_type_joints || stream.type == cgltf_attribute_type_weights) && !mesh.skin)
|
|
continue;
|
|
|
|
scratch.clear();
|
|
StreamFormat format = writeVertexStream(scratch, stream, qp, settings, mesh.targets > 0);
|
|
|
|
size_t view = getBufferView(views, BufferView::Kind_Vertex, stream.type, format.stride, settings.compress);
|
|
size_t offset = views[view].data.size();
|
|
views[view].data += scratch;
|
|
|
|
comma(json_accessors);
|
|
if (stream.type == cgltf_attribute_type_position)
|
|
{
|
|
int min[3] = {};
|
|
int max[3] = {};
|
|
getPositionBounds(min, max, stream, qp);
|
|
|
|
float minf[3] = {float(min[0]), float(min[1]), float(min[2])};
|
|
float maxf[3] = {float(max[0]), float(max[1]), float(max[2])};
|
|
|
|
writeAccessor(json_accessors, view, offset, format.type, format.component_type, format.normalized, stream.data.size(), minf, maxf, 3);
|
|
}
|
|
else
|
|
{
|
|
writeAccessor(json_accessors, view, offset, format.type, format.component_type, format.normalized, stream.data.size());
|
|
}
|
|
|
|
size_t vertex_accr = accr_offset++;
|
|
|
|
comma(json);
|
|
append(json, "\"");
|
|
append(json, attributeType(stream.type));
|
|
if (stream.type != cgltf_attribute_type_position && stream.type != cgltf_attribute_type_normal && stream.type != cgltf_attribute_type_tangent)
|
|
{
|
|
append(json, "_");
|
|
append(json, size_t(stream.index));
|
|
}
|
|
append(json, "\":");
|
|
append(json, vertex_accr);
|
|
}
|
|
}
|
|
|
|
size_t writeMeshIndices(std::vector<BufferView>& views, std::string& json_accessors, size_t& accr_offset, const Mesh& mesh, const Settings& settings)
|
|
{
|
|
std::string scratch;
|
|
StreamFormat format = writeIndexStream(scratch, mesh.indices);
|
|
|
|
// note: we prefer to merge all index streams together; however, index codec currently doesn't handle concatenated index streams well and loses compression ratio
|
|
int variant = settings.compress ? -1 : 0;
|
|
|
|
size_t view = getBufferView(views, BufferView::Kind_Index, variant, format.stride, settings.compress);
|
|
size_t offset = views[view].data.size();
|
|
views[view].data += scratch;
|
|
|
|
comma(json_accessors);
|
|
writeAccessor(json_accessors, view, offset, format.type, format.component_type, format.normalized, mesh.indices.size());
|
|
|
|
size_t index_accr = accr_offset++;
|
|
|
|
return index_accr;
|
|
}
|
|
|
|
size_t writeAnimationTime(std::vector<BufferView>& views, std::string& json_accessors, size_t& accr_offset, float mint, int frames, const Settings& settings)
|
|
{
|
|
std::vector<float> time(frames);
|
|
|
|
for (int j = 0; j < frames; ++j)
|
|
time[j] = mint + float(j) / settings.anim_freq;
|
|
|
|
std::string scratch;
|
|
StreamFormat format = writeTimeStream(scratch, time);
|
|
|
|
size_t view = getBufferView(views, BufferView::Kind_Time, 0, format.stride, settings.compress);
|
|
size_t offset = views[view].data.size();
|
|
views[view].data += scratch;
|
|
|
|
comma(json_accessors);
|
|
writeAccessor(json_accessors, view, offset, cgltf_type_scalar, format.component_type, format.normalized, frames, &time.front(), &time.back(), 1);
|
|
|
|
size_t time_accr = accr_offset++;
|
|
|
|
return time_accr;
|
|
}
|
|
|
|
size_t writeJointBindMatrices(std::vector<BufferView>& views, std::string& json_accessors, size_t& accr_offset, const cgltf_skin& skin, const QuantizationParams& qp, const Settings& settings)
|
|
{
|
|
std::string scratch;
|
|
|
|
for (size_t j = 0; j < skin.joints_count; ++j)
|
|
{
|
|
float transform[16] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};
|
|
|
|
if (skin.inverse_bind_matrices)
|
|
{
|
|
cgltf_accessor_read_float(skin.inverse_bind_matrices, j, transform, 16);
|
|
}
|
|
|
|
float node_scale = qp.pos_scale / float((1 << qp.pos_bits) - 1);
|
|
|
|
// pos_offset has to be applied first, thus it results in an offset rotated by the bind matrix
|
|
transform[12] += qp.pos_offset[0] * transform[0] + qp.pos_offset[1] * transform[4] + qp.pos_offset[2] * transform[8];
|
|
transform[13] += qp.pos_offset[0] * transform[1] + qp.pos_offset[1] * transform[5] + qp.pos_offset[2] * transform[9];
|
|
transform[14] += qp.pos_offset[0] * transform[2] + qp.pos_offset[1] * transform[6] + qp.pos_offset[2] * transform[10];
|
|
|
|
// node_scale will be applied before the rotation/scale from transform
|
|
for (int k = 0; k < 12; ++k)
|
|
transform[k] *= node_scale;
|
|
|
|
scratch.append(reinterpret_cast<const char*>(transform), sizeof(transform));
|
|
}
|
|
|
|
size_t view = getBufferView(views, BufferView::Kind_Skin, 0, 64, settings.compress);
|
|
size_t offset = views[view].data.size();
|
|
views[view].data += scratch;
|
|
|
|
comma(json_accessors);
|
|
writeAccessor(json_accessors, view, offset, cgltf_type_mat4, cgltf_component_type_r_32f, false, skin.joints_count);
|
|
|
|
size_t matrix_accr = accr_offset++;
|
|
|
|
return matrix_accr;
|
|
}
|
|
|
|
void writeMeshNode(std::string& json, size_t mesh_offset, const Mesh& mesh, cgltf_data* data, const QuantizationParams& qp)
|
|
{
|
|
float node_scale = qp.pos_scale / float((1 << qp.pos_bits) - 1);
|
|
|
|
comma(json);
|
|
append(json, "{\"mesh\":");
|
|
append(json, mesh_offset);
|
|
if (mesh.skin)
|
|
{
|
|
comma(json);
|
|
append(json, "\"skin\":");
|
|
append(json, size_t(mesh.skin - data->skins));
|
|
}
|
|
append(json, ",\"translation\":[");
|
|
append(json, qp.pos_offset[0]);
|
|
append(json, ",");
|
|
append(json, qp.pos_offset[1]);
|
|
append(json, ",");
|
|
append(json, qp.pos_offset[2]);
|
|
append(json, "],\"scale\":[");
|
|
append(json, node_scale);
|
|
append(json, ",");
|
|
append(json, node_scale);
|
|
append(json, ",");
|
|
append(json, node_scale);
|
|
append(json, "]");
|
|
if (mesh.node && mesh.node->weights_count)
|
|
{
|
|
append(json, ",\"weights\":[");
|
|
for (size_t j = 0; j < mesh.node->weights_count; ++j)
|
|
{
|
|
comma(json);
|
|
append(json, mesh.node->weights[j]);
|
|
}
|
|
append(json, "]");
|
|
}
|
|
append(json, "}");
|
|
}
|
|
|
|
void writeNode(std::string& json, const cgltf_node& node, const std::vector<NodeInfo>& nodes, cgltf_data* data)
|
|
{
|
|
const NodeInfo& ni = nodes[&node - data->nodes];
|
|
|
|
comma(json);
|
|
append(json, "{");
|
|
if (node.name && *node.name)
|
|
{
|
|
comma(json);
|
|
append(json, "\"name\":\"");
|
|
append(json, node.name);
|
|
append(json, "\"");
|
|
}
|
|
if (node.has_translation)
|
|
{
|
|
comma(json);
|
|
append(json, "\"translation\":[");
|
|
append(json, node.translation[0]);
|
|
append(json, ",");
|
|
append(json, node.translation[1]);
|
|
append(json, ",");
|
|
append(json, node.translation[2]);
|
|
append(json, "]");
|
|
}
|
|
if (node.has_rotation)
|
|
{
|
|
comma(json);
|
|
append(json, "\"rotation\":[");
|
|
append(json, node.rotation[0]);
|
|
append(json, ",");
|
|
append(json, node.rotation[1]);
|
|
append(json, ",");
|
|
append(json, node.rotation[2]);
|
|
append(json, ",");
|
|
append(json, node.rotation[3]);
|
|
append(json, "]");
|
|
}
|
|
if (node.has_scale)
|
|
{
|
|
comma(json);
|
|
append(json, "\"scale\":[");
|
|
append(json, node.scale[0]);
|
|
append(json, ",");
|
|
append(json, node.scale[1]);
|
|
append(json, ",");
|
|
append(json, node.scale[2]);
|
|
append(json, "]");
|
|
}
|
|
if (node.has_matrix)
|
|
{
|
|
comma(json);
|
|
append(json, "\"matrix\":[");
|
|
for (int k = 0; k < 16; ++k)
|
|
{
|
|
comma(json);
|
|
append(json, node.matrix[k]);
|
|
}
|
|
append(json, "]");
|
|
}
|
|
if (node.children_count || !ni.meshes.empty())
|
|
{
|
|
comma(json);
|
|
append(json, "\"children\":[");
|
|
for (size_t j = 0; j < node.children_count; ++j)
|
|
{
|
|
const NodeInfo& ci = nodes[node.children[j] - data->nodes];
|
|
|
|
if (ci.keep)
|
|
{
|
|
comma(json);
|
|
append(json, size_t(ci.remap));
|
|
}
|
|
}
|
|
for (size_t j = 0; j < ni.meshes.size(); ++j)
|
|
{
|
|
comma(json);
|
|
append(json, ni.meshes[j]);
|
|
}
|
|
append(json, "]");
|
|
}
|
|
if (node.camera)
|
|
{
|
|
comma(json);
|
|
append(json, "\"camera\":");
|
|
append(json, size_t(node.camera - data->cameras));
|
|
}
|
|
if (node.light)
|
|
{
|
|
comma(json);
|
|
append(json, "\"extensions\":{\"KHR_lights_punctual\":{\"light\":");
|
|
append(json, size_t(node.light - data->lights));
|
|
append(json, "}}");
|
|
}
|
|
append(json, "}");
|
|
}
|
|
|
|
void writeAnimation(std::string& json, std::vector<BufferView>& views, std::string& json_accessors, size_t& accr_offset, const cgltf_animation& animation, cgltf_data* data, const std::vector<NodeInfo>& nodes, const Settings& settings)
|
|
{
|
|
std::vector<const cgltf_animation_channel*> tracks;
|
|
|
|
for (size_t j = 0; j < animation.channels_count; ++j)
|
|
{
|
|
const cgltf_animation_channel& channel = animation.channels[j];
|
|
|
|
if (!channel.target_node)
|
|
{
|
|
fprintf(stderr, "Warning: ignoring channel %d of animation %d because it has no target node\n", int(j), int(&animation - data->animations));
|
|
continue;
|
|
}
|
|
|
|
const NodeInfo& ni = nodes[channel.target_node - data->nodes];
|
|
|
|
if (!ni.keep)
|
|
continue;
|
|
|
|
if (!settings.anim_const && (ni.animated_paths & (1 << channel.target_path)) == 0)
|
|
continue;
|
|
|
|
tracks.push_back(&channel);
|
|
}
|
|
|
|
if (tracks.empty())
|
|
{
|
|
fprintf(stderr, "Warning: ignoring animation %d because it has no valid tracks\n", int(&animation - data->animations));
|
|
return;
|
|
}
|
|
|
|
float mint = 0, maxt = 0;
|
|
bool needs_time = false;
|
|
bool needs_pose = false;
|
|
|
|
for (size_t j = 0; j < tracks.size(); ++j)
|
|
{
|
|
const cgltf_animation_channel& channel = *tracks[j];
|
|
const cgltf_animation_sampler& sampler = *channel.sampler;
|
|
|
|
mint = std::min(mint, sampler.input->min[0]);
|
|
maxt = std::max(maxt, sampler.input->max[0]);
|
|
|
|
bool tc = isTrackConstant(sampler, channel.target_path, channel.target_node);
|
|
|
|
needs_time = needs_time || !tc;
|
|
needs_pose = needs_pose || tc;
|
|
}
|
|
|
|
// round the number of frames to nearest but favor the "up" direction
|
|
// this means that at 10 Hz resampling, we will try to preserve the last frame <10ms
|
|
// but if the last frame is <2ms we favor just removing this data
|
|
int frames = 1 + int((maxt - mint) * settings.anim_freq + 0.8f);
|
|
|
|
size_t time_accr = needs_time ? writeAnimationTime(views, json_accessors, accr_offset, mint, frames, settings) : 0;
|
|
size_t pose_accr = needs_pose ? writeAnimationTime(views, json_accessors, accr_offset, mint, 1, settings) : 0;
|
|
|
|
std::string json_samplers;
|
|
std::string json_channels;
|
|
|
|
size_t track_offset = 0;
|
|
|
|
for (size_t j = 0; j < tracks.size(); ++j)
|
|
{
|
|
const cgltf_animation_channel& channel = *tracks[j];
|
|
const cgltf_animation_sampler& sampler = *channel.sampler;
|
|
|
|
bool tc = isTrackConstant(sampler, channel.target_path, channel.target_node);
|
|
|
|
std::vector<Attr> track;
|
|
resampleKeyframes(track, sampler, channel.target_path, channel.target_node, tc ? 1 : frames, mint, settings.anim_freq);
|
|
|
|
std::string scratch;
|
|
StreamFormat format = writeKeyframeStream(scratch, channel.target_path, track);
|
|
|
|
size_t view = getBufferView(views, BufferView::Kind_Keyframe, channel.target_path, format.stride, settings.compress && channel.target_path != cgltf_animation_path_type_weights);
|
|
size_t offset = views[view].data.size();
|
|
views[view].data += scratch;
|
|
|
|
comma(json_accessors);
|
|
writeAccessor(json_accessors, view, offset, format.type, format.component_type, format.normalized, track.size());
|
|
|
|
size_t data_accr = accr_offset++;
|
|
|
|
comma(json_samplers);
|
|
append(json_samplers, "{\"input\":");
|
|
append(json_samplers, tc ? pose_accr : time_accr);
|
|
append(json_samplers, ",\"output\":");
|
|
append(json_samplers, data_accr);
|
|
append(json_samplers, "}");
|
|
|
|
const NodeInfo& tni = nodes[channel.target_node - data->nodes];
|
|
size_t target_node = size_t(tni.remap);
|
|
|
|
if (channel.target_path == cgltf_animation_path_type_weights)
|
|
{
|
|
assert(tni.meshes.size() == 1);
|
|
target_node = tni.meshes[0];
|
|
}
|
|
|
|
comma(json_channels);
|
|
append(json_channels, "{\"sampler\":");
|
|
append(json_channels, track_offset);
|
|
append(json_channels, ",\"target\":{\"node\":");
|
|
append(json_channels, target_node);
|
|
append(json_channels, ",\"path\":\"");
|
|
append(json_channels, animationPath(channel.target_path));
|
|
append(json_channels, "\"}}");
|
|
|
|
track_offset++;
|
|
}
|
|
|
|
comma(json);
|
|
append(json, "{");
|
|
if (animation.name && *animation.name)
|
|
{
|
|
append(json, "\"name\":\"");
|
|
append(json, animation.name);
|
|
append(json, "\",");
|
|
}
|
|
append(json, "\"samplers\":[");
|
|
append(json, json_samplers);
|
|
append(json, "],\"channels\":[");
|
|
append(json, json_channels);
|
|
append(json, "]}");
|
|
}
|
|
|
|
void writeCamera(std::string& json, const cgltf_camera& camera)
|
|
{
|
|
comma(json);
|
|
append(json, "{");
|
|
|
|
switch (camera.type)
|
|
{
|
|
case cgltf_camera_type_perspective:
|
|
append(json, "\"type\":\"perspective\",\"perspective\":{");
|
|
append(json, "\"yfov\":");
|
|
append(json, camera.perspective.yfov);
|
|
append(json, ",\"znear\":");
|
|
append(json, camera.perspective.znear);
|
|
if (camera.perspective.aspect_ratio != 0.f)
|
|
{
|
|
append(json, ",\"aspectRatio\":");
|
|
append(json, camera.perspective.aspect_ratio);
|
|
}
|
|
if (camera.perspective.zfar != 0.f)
|
|
{
|
|
append(json, ",\"zfar\":");
|
|
append(json, camera.perspective.zfar);
|
|
}
|
|
append(json, "}");
|
|
break;
|
|
|
|
case cgltf_camera_type_orthographic:
|
|
append(json, "\"type\":\"orthographic\",\"orthographic\":{");
|
|
append(json, "\"xmag\":");
|
|
append(json, camera.orthographic.xmag);
|
|
append(json, ",\"ymag\":");
|
|
append(json, camera.orthographic.ymag);
|
|
append(json, ",\"znear\":");
|
|
append(json, camera.orthographic.znear);
|
|
append(json, ",\"zfar\":");
|
|
append(json, camera.orthographic.zfar);
|
|
append(json, "}");
|
|
break;
|
|
|
|
default:
|
|
fprintf(stderr, "Warning: skipping camera of unknown type\n");
|
|
}
|
|
|
|
append(json, "}");
|
|
}
|
|
|
|
void writeLight(std::string& json, const cgltf_light& light)
|
|
{
|
|
static const float white[3] = {1, 1, 1};
|
|
|
|
comma(json);
|
|
append(json, "{\"type\":\"");
|
|
append(json, lightType(light.type));
|
|
append(json, "\"");
|
|
if (memcmp(light.color, white, sizeof(white)) != 0)
|
|
{
|
|
comma(json);
|
|
append(json, "\"color\":[");
|
|
append(json, light.color[0]);
|
|
append(json, ",");
|
|
append(json, light.color[1]);
|
|
append(json, ",");
|
|
append(json, light.color[2]);
|
|
append(json, "]");
|
|
}
|
|
if (light.intensity != 1.f)
|
|
{
|
|
comma(json);
|
|
append(json, "\"intensity\":");
|
|
append(json, light.intensity);
|
|
}
|
|
if (light.range != 0.f)
|
|
{
|
|
comma(json);
|
|
append(json, "\"range\":");
|
|
append(json, light.range);
|
|
}
|
|
if (light.type == cgltf_light_type_spot)
|
|
{
|
|
comma(json);
|
|
append(json, "\"spot\":{");
|
|
append(json, "\"innerConeAngle\":");
|
|
append(json, light.spot_inner_cone_angle);
|
|
append(json, ",\"outerConeAngle\":");
|
|
append(json, light.spot_outer_cone_angle == 0.f ? 0.78539816339f : light.spot_outer_cone_angle);
|
|
append(json, "}");
|
|
}
|
|
append(json, "}");
|
|
}
|
|
|
|
void finalizeBufferViews(std::string& json, std::vector<BufferView>& views, std::string& bin, std::string& fallback)
|
|
{
|
|
for (size_t i = 0; i < views.size(); ++i)
|
|
{
|
|
BufferView& view = views[i];
|
|
|
|
size_t bin_offset = bin.size();
|
|
size_t fallback_offset = fallback.size();
|
|
|
|
size_t count = view.data.size() / view.stride;
|
|
|
|
int compression = -1;
|
|
|
|
if (view.compressed)
|
|
{
|
|
if (view.kind == BufferView::Kind_Index)
|
|
{
|
|
compressIndexStream(bin, view.data, count, view.stride);
|
|
compression = 1;
|
|
}
|
|
else
|
|
{
|
|
compressVertexStream(bin, view.data, count, view.stride);
|
|
compression = 0;
|
|
}
|
|
|
|
fallback += view.data;
|
|
}
|
|
else
|
|
{
|
|
bin += view.data;
|
|
}
|
|
|
|
size_t raw_offset = (compression >= 0) ? fallback_offset : bin_offset;
|
|
|
|
comma(json);
|
|
writeBufferView(json, view.kind, count, view.stride, raw_offset, view.data.size(), compression, bin_offset, bin.size() - bin_offset);
|
|
|
|
// record written bytes for statistics
|
|
view.bytes = bin.size() - bin_offset;
|
|
|
|
// align each bufferView by 4 bytes
|
|
bin.resize((bin.size() + 3) & ~3);
|
|
fallback.resize((fallback.size() + 3) & ~3);
|
|
}
|
|
}
|
|
|
|
void printMeshStats(const std::vector<Mesh>& meshes, const char* name)
|
|
{
|
|
size_t triangles = 0;
|
|
size_t vertices = 0;
|
|
|
|
for (size_t i = 0; i < meshes.size(); ++i)
|
|
{
|
|
const Mesh& mesh = meshes[i];
|
|
|
|
triangles += mesh.indices.size() / 3;
|
|
vertices += mesh.streams.empty() ? 0 : mesh.streams[0].data.size();
|
|
}
|
|
|
|
printf("%s: %d triangles, %d vertices\n", name, int(triangles), int(vertices));
|
|
}
|
|
|
|
void printAttributeStats(const std::vector<BufferView>& views, BufferView::Kind kind, const char* name)
|
|
{
|
|
for (size_t i = 0; i < views.size(); ++i)
|
|
{
|
|
const BufferView& view = views[i];
|
|
|
|
if (view.kind != kind)
|
|
continue;
|
|
|
|
const char* variant = "unknown";
|
|
|
|
switch (kind)
|
|
{
|
|
case BufferView::Kind_Vertex:
|
|
variant = attributeType(cgltf_attribute_type(view.variant));
|
|
break;
|
|
|
|
case BufferView::Kind_Index:
|
|
variant = "index";
|
|
break;
|
|
|
|
case BufferView::Kind_Keyframe:
|
|
variant = animationPath(cgltf_animation_path_type(view.variant));
|
|
break;
|
|
|
|
default:;
|
|
}
|
|
|
|
size_t count = view.data.size() / view.stride;
|
|
|
|
printf("stats: %s %s: compressed %d bytes (%.1f bits), raw %d bytes (%d bits)\n",
|
|
name,
|
|
variant,
|
|
int(view.bytes),
|
|
double(view.bytes) / double(count) * 8,
|
|
int(view.data.size()),
|
|
int(view.stride * 8));
|
|
}
|
|
}
|
|
|
|
void process(cgltf_data* data, const char* input_path, const char* output_path, std::vector<Mesh>& meshes, const Settings& settings, std::string& json, std::string& bin, std::string& fallback)
|
|
{
|
|
if (settings.verbose)
|
|
{
|
|
printf("input: %d nodes, %d meshes (%d primitives), %d materials, %d skins, %d animations\n",
|
|
int(data->nodes_count), int(data->meshes_count), int(meshes.size()), int(data->materials_count), int(data->skins_count), int(data->animations_count));
|
|
}
|
|
|
|
std::vector<NodeInfo> nodes(data->nodes_count);
|
|
|
|
markAnimated(data, nodes);
|
|
|
|
for (size_t i = 0; i < meshes.size(); ++i)
|
|
{
|
|
Mesh& mesh = meshes[i];
|
|
|
|
// note: when -kn is specified, we keep mesh-node attachment so that named nodes can be transformed
|
|
if (mesh.node && !settings.keep_named)
|
|
{
|
|
NodeInfo& ni = nodes[mesh.node - data->nodes];
|
|
|
|
// we transform all non-skinned non-animated meshes to world space
|
|
// this makes sure that quantization doesn't introduce gaps if the original scene was watertight
|
|
if (!ni.animated && !mesh.skin && mesh.targets == 0)
|
|
{
|
|
transformMesh(mesh, mesh.node);
|
|
mesh.node = 0;
|
|
}
|
|
|
|
// skinned and animated meshes will be anchored to the same node that they used to be in
|
|
// for animated meshes, this is important since they need to be transformed by the same animation
|
|
// for skinned meshes, in theory this isn't important since the transform of the skinned node doesn't matter; in practice this affects generated bounding box in three.js
|
|
}
|
|
}
|
|
|
|
mergeMeshMaterials(data, meshes);
|
|
mergeMeshes(meshes, settings);
|
|
|
|
markNeededNodes(data, nodes, meshes, settings);
|
|
|
|
std::vector<MaterialInfo> materials(data->materials_count);
|
|
|
|
markNeededMaterials(data, materials, meshes);
|
|
|
|
if (settings.verbose)
|
|
{
|
|
printMeshStats(meshes, "input");
|
|
}
|
|
|
|
for (size_t i = 0; i < meshes.size(); ++i)
|
|
{
|
|
processMesh(meshes[i], settings);
|
|
}
|
|
|
|
if (settings.verbose)
|
|
{
|
|
printMeshStats(meshes, "output");
|
|
}
|
|
|
|
std::vector<ImageInfo> images(data->images_count);
|
|
|
|
for (size_t i = 0; i < data->materials_count; ++i)
|
|
{
|
|
const cgltf_material& material = data->materials[i];
|
|
|
|
if (material.normal_texture.texture && material.normal_texture.texture->image)
|
|
images[material.normal_texture.texture->image - data->images].normal_map = true;
|
|
}
|
|
|
|
QuantizationParams qp = prepareQuantization(meshes, settings);
|
|
|
|
std::string json_images;
|
|
std::string json_textures;
|
|
std::string json_materials;
|
|
std::string json_accessors;
|
|
std::string json_meshes;
|
|
std::string json_nodes;
|
|
std::string json_skins;
|
|
std::string json_roots;
|
|
std::string json_animations;
|
|
std::string json_cameras;
|
|
std::string json_lights;
|
|
|
|
std::vector<BufferView> views;
|
|
|
|
bool ext_pbr_specular_glossiness = false;
|
|
bool ext_unlit = false;
|
|
|
|
size_t accr_offset = 0;
|
|
size_t node_offset = 0;
|
|
size_t mesh_offset = 0;
|
|
size_t material_offset = 0;
|
|
|
|
for (size_t i = 0; i < data->images_count; ++i)
|
|
{
|
|
if (settings.verbose && settings.texture_basis)
|
|
{
|
|
const char* uri = data->images[i].uri;
|
|
bool embedded = !uri || strncmp(uri, "data:", 5) == 0;
|
|
|
|
printf("image %d (%s) is being encoded with Basis\n", int(i), embedded ? "embedded" : uri);
|
|
}
|
|
|
|
comma(json_images);
|
|
append(json_images, "{");
|
|
writeImage(json_images, views, data->images[i], images[i], i, input_path, output_path, settings);
|
|
append(json_images, "}");
|
|
}
|
|
|
|
for (size_t i = 0; i < data->textures_count; ++i)
|
|
{
|
|
const cgltf_texture& texture = data->textures[i];
|
|
|
|
comma(json_textures);
|
|
append(json_textures, "{");
|
|
if (texture.image)
|
|
{
|
|
append(json_textures, "\"source\":");
|
|
append(json_textures, size_t(texture.image - data->images));
|
|
}
|
|
append(json_textures, "}");
|
|
}
|
|
|
|
for (size_t i = 0; i < data->materials_count; ++i)
|
|
{
|
|
MaterialInfo& mi = materials[i];
|
|
|
|
if (!mi.keep)
|
|
continue;
|
|
|
|
const cgltf_material& material = data->materials[i];
|
|
|
|
comma(json_materials);
|
|
append(json_materials, "{");
|
|
writeMaterialInfo(json_materials, data, material, qp);
|
|
append(json_materials, "}");
|
|
|
|
mi.remap = int(material_offset);
|
|
material_offset++;
|
|
|
|
ext_pbr_specular_glossiness = ext_pbr_specular_glossiness || material.has_pbr_specular_glossiness;
|
|
ext_unlit = ext_unlit || material.unlit;
|
|
}
|
|
|
|
for (size_t i = 0; i < meshes.size(); ++i)
|
|
{
|
|
const Mesh& mesh = meshes[i];
|
|
|
|
comma(json_meshes);
|
|
append(json_meshes, "{\"primitives\":[");
|
|
|
|
size_t pi = i;
|
|
for (; pi < meshes.size(); ++pi)
|
|
{
|
|
const Mesh& prim = meshes[pi];
|
|
|
|
if (prim.node != mesh.node || prim.skin != mesh.skin || prim.targets != mesh.targets)
|
|
break;
|
|
|
|
if (!compareMeshTargets(mesh, prim))
|
|
break;
|
|
|
|
comma(json_meshes);
|
|
append(json_meshes, "{\"attributes\":{");
|
|
writeMeshAttributes(json_meshes, views, json_accessors, accr_offset, prim, 0, qp, settings);
|
|
append(json_meshes, "}");
|
|
append(json_meshes, ",\"mode\":");
|
|
append(json_meshes, size_t(prim.type));
|
|
|
|
if (mesh.targets)
|
|
{
|
|
append(json_meshes, ",\"targets\":[");
|
|
for (size_t j = 0; j < mesh.targets; ++j)
|
|
{
|
|
comma(json_meshes);
|
|
append(json_meshes, "{");
|
|
writeMeshAttributes(json_meshes, views, json_accessors, accr_offset, prim, int(1 + j), qp, settings);
|
|
append(json_meshes, "}");
|
|
}
|
|
append(json_meshes, "]");
|
|
}
|
|
|
|
if (!prim.indices.empty())
|
|
{
|
|
size_t index_accr = writeMeshIndices(views, json_accessors, accr_offset, prim, settings);
|
|
|
|
append(json_meshes, ",\"indices\":");
|
|
append(json_meshes, index_accr);
|
|
}
|
|
|
|
if (prim.material)
|
|
{
|
|
MaterialInfo& mi = materials[prim.material - data->materials];
|
|
|
|
assert(mi.keep);
|
|
append(json_meshes, ",\"material\":");
|
|
append(json_meshes, size_t(mi.remap));
|
|
}
|
|
|
|
append(json_meshes, "}");
|
|
}
|
|
|
|
append(json_meshes, "]");
|
|
|
|
if (mesh.target_weights.size())
|
|
{
|
|
append(json_meshes, ",\"weights\":[");
|
|
for (size_t j = 0; j < mesh.target_weights.size(); ++j)
|
|
{
|
|
comma(json_meshes);
|
|
append(json_meshes, mesh.target_weights[j]);
|
|
}
|
|
append(json_meshes, "]");
|
|
}
|
|
|
|
if (mesh.target_names.size())
|
|
{
|
|
append(json_meshes, ",\"extras\":{\"targetNames\":[");
|
|
for (size_t j = 0; j < mesh.target_names.size(); ++j)
|
|
{
|
|
comma(json_meshes);
|
|
append(json_meshes, "\"");
|
|
append(json_meshes, mesh.target_names[j]);
|
|
append(json_meshes, "\"");
|
|
}
|
|
append(json_meshes, "]}");
|
|
}
|
|
|
|
append(json_meshes, "}");
|
|
|
|
writeMeshNode(json_nodes, mesh_offset, mesh, data, qp);
|
|
|
|
if (mesh.node)
|
|
{
|
|
NodeInfo& ni = nodes[mesh.node - data->nodes];
|
|
|
|
assert(ni.keep);
|
|
ni.meshes.push_back(node_offset);
|
|
}
|
|
else
|
|
{
|
|
comma(json_roots);
|
|
append(json_roots, node_offset);
|
|
}
|
|
|
|
node_offset++;
|
|
mesh_offset++;
|
|
|
|
// skip all meshes that we've written in this iteration
|
|
assert(pi > i);
|
|
i = pi - 1;
|
|
}
|
|
|
|
remapNodes(data, nodes, node_offset);
|
|
|
|
for (size_t i = 0; i < data->nodes_count; ++i)
|
|
{
|
|
NodeInfo& ni = nodes[i];
|
|
|
|
if (!ni.keep)
|
|
continue;
|
|
|
|
const cgltf_node& node = data->nodes[i];
|
|
|
|
if (!node.parent)
|
|
{
|
|
comma(json_roots);
|
|
append(json_roots, size_t(ni.remap));
|
|
}
|
|
|
|
writeNode(json_nodes, node, nodes, data);
|
|
}
|
|
|
|
for (size_t i = 0; i < data->skins_count; ++i)
|
|
{
|
|
const cgltf_skin& skin = data->skins[i];
|
|
|
|
size_t matrix_accr = writeJointBindMatrices(views, json_accessors, accr_offset, skin, qp, settings);
|
|
|
|
comma(json_skins);
|
|
append(json_skins, "{");
|
|
append(json_skins, "\"joints\":[");
|
|
for (size_t j = 0; j < skin.joints_count; ++j)
|
|
{
|
|
comma(json_skins);
|
|
append(json_skins, size_t(nodes[skin.joints[j] - data->nodes].remap));
|
|
}
|
|
append(json_skins, "]");
|
|
append(json_skins, ",\"inverseBindMatrices\":");
|
|
append(json_skins, matrix_accr);
|
|
if (skin.skeleton)
|
|
{
|
|
comma(json_skins);
|
|
append(json_skins, "\"skeleton\":");
|
|
append(json_skins, size_t(nodes[skin.skeleton - data->nodes].remap));
|
|
}
|
|
append(json_skins, "}");
|
|
}
|
|
|
|
for (size_t i = 0; i < data->animations_count; ++i)
|
|
{
|
|
const cgltf_animation& animation = data->animations[i];
|
|
|
|
writeAnimation(json_animations, views, json_accessors, accr_offset, animation, data, nodes, settings);
|
|
}
|
|
|
|
for (size_t i = 0; i < data->cameras_count; ++i)
|
|
{
|
|
const cgltf_camera& camera = data->cameras[i];
|
|
|
|
writeCamera(json_cameras, camera);
|
|
}
|
|
|
|
for (size_t i = 0; i < data->lights_count; ++i)
|
|
{
|
|
const cgltf_light& light = data->lights[i];
|
|
|
|
writeLight(json_lights, light);
|
|
}
|
|
|
|
char version[32];
|
|
sprintf(version, "%d.%d", MESHOPTIMIZER_VERSION / 1000, (MESHOPTIMIZER_VERSION % 1000) / 10);
|
|
|
|
append(json, "\"asset\":{");
|
|
append(json, "\"version\":\"2.0\",\"generator\":\"gltfpack ");
|
|
append(json, version);
|
|
append(json, "\"");
|
|
if (data->asset.extras.start_offset)
|
|
{
|
|
append(json, ",\"extras\":");
|
|
json.append(data->json + data->asset.extras.start_offset, data->json + data->asset.extras.end_offset);
|
|
}
|
|
append(json, "}");
|
|
|
|
append(json, ",\"extensionsUsed\":[");
|
|
append(json, "\"KHR_mesh_quantization\"");
|
|
if (settings.compress)
|
|
{
|
|
comma(json);
|
|
append(json, "\"MESHOPT_compression\"");
|
|
}
|
|
if (!json_textures.empty())
|
|
{
|
|
comma(json);
|
|
append(json, "\"KHR_texture_transform\"");
|
|
}
|
|
if (ext_pbr_specular_glossiness)
|
|
{
|
|
comma(json);
|
|
append(json, "\"KHR_materials_pbrSpecularGlossiness\"");
|
|
}
|
|
if (ext_unlit)
|
|
{
|
|
comma(json);
|
|
append(json, "\"KHR_materials_unlit\"");
|
|
}
|
|
if (data->lights_count)
|
|
{
|
|
comma(json);
|
|
append(json, "\"KHR_lights_punctual\"");
|
|
}
|
|
append(json, "]");
|
|
|
|
append(json, ",\"extensionsRequired\":[");
|
|
append(json, "\"KHR_mesh_quantization\"");
|
|
if (settings.compress && !settings.fallback)
|
|
{
|
|
comma(json);
|
|
append(json, "\"MESHOPT_compression\"");
|
|
}
|
|
append(json, "]");
|
|
|
|
if (!views.empty())
|
|
{
|
|
std::string json_views;
|
|
finalizeBufferViews(json_views, views, bin, fallback);
|
|
|
|
append(json, ",\"bufferViews\":[");
|
|
append(json, json_views);
|
|
append(json, "]");
|
|
}
|
|
if (!json_accessors.empty())
|
|
{
|
|
append(json, ",\"accessors\":[");
|
|
append(json, json_accessors);
|
|
append(json, "]");
|
|
}
|
|
if (!json_images.empty())
|
|
{
|
|
append(json, ",\"images\":[");
|
|
append(json, json_images);
|
|
append(json, "]");
|
|
}
|
|
if (!json_textures.empty())
|
|
{
|
|
append(json, ",\"textures\":[");
|
|
append(json, json_textures);
|
|
append(json, "]");
|
|
}
|
|
if (!json_materials.empty())
|
|
{
|
|
append(json, ",\"materials\":[");
|
|
append(json, json_materials);
|
|
append(json, "]");
|
|
}
|
|
if (!json_meshes.empty())
|
|
{
|
|
append(json, ",\"meshes\":[");
|
|
append(json, json_meshes);
|
|
append(json, "]");
|
|
}
|
|
if (!json_skins.empty())
|
|
{
|
|
append(json, ",\"skins\":[");
|
|
append(json, json_skins);
|
|
append(json, "]");
|
|
}
|
|
if (!json_animations.empty())
|
|
{
|
|
append(json, ",\"animations\":[");
|
|
append(json, json_animations);
|
|
append(json, "]");
|
|
}
|
|
if (!json_roots.empty())
|
|
{
|
|
append(json, ",\"nodes\":[");
|
|
append(json, json_nodes);
|
|
append(json, "],\"scenes\":[");
|
|
append(json, "{\"nodes\":[");
|
|
append(json, json_roots);
|
|
append(json, "]}]");
|
|
}
|
|
if (!json_cameras.empty())
|
|
{
|
|
append(json, ",\"cameras\":[");
|
|
append(json, json_cameras);
|
|
append(json, "]");
|
|
}
|
|
if (!json_lights.empty())
|
|
{
|
|
append(json, ",\"extensions\":{\"KHR_lights_punctual\":{\"lights\":[");
|
|
append(json, json_lights);
|
|
append(json, "]}}");
|
|
}
|
|
if (!json_roots.empty())
|
|
{
|
|
append(json, ",\"scene\":0");
|
|
}
|
|
|
|
if (settings.verbose)
|
|
{
|
|
size_t bytes[BufferView::Kind_Count] = {};
|
|
|
|
for (size_t i = 0; i < views.size(); ++i)
|
|
{
|
|
BufferView& view = views[i];
|
|
bytes[view.kind] += view.bytes;
|
|
}
|
|
|
|
printf("output: %d nodes, %d meshes (%d primitives), %d materials\n", int(node_offset), int(mesh_offset), int(meshes.size()), int(material_offset));
|
|
printf("output: JSON %d bytes, buffers %d bytes\n", int(json.size()), int(bin.size()));
|
|
printf("output: buffers: vertex %d bytes, index %d bytes, skin %d bytes, time %d bytes, keyframe %d bytes, image %d bytes\n",
|
|
int(bytes[BufferView::Kind_Vertex]), int(bytes[BufferView::Kind_Index]), int(bytes[BufferView::Kind_Skin]),
|
|
int(bytes[BufferView::Kind_Time]), int(bytes[BufferView::Kind_Keyframe]), int(bytes[BufferView::Kind_Image]));
|
|
}
|
|
|
|
if (settings.verbose > 1)
|
|
{
|
|
printAttributeStats(views, BufferView::Kind_Vertex, "vertex");
|
|
printAttributeStats(views, BufferView::Kind_Index, "index");
|
|
printAttributeStats(views, BufferView::Kind_Keyframe, "keyframe");
|
|
}
|
|
}
|
|
|
|
void writeU32(FILE* out, uint32_t data)
|
|
{
|
|
fwrite(&data, 4, 1, out);
|
|
}
|
|
|
|
bool requiresExtension(cgltf_data* data, const char* name)
|
|
{
|
|
for (size_t i = 0; i < data->extensions_required_count; ++i)
|
|
if (strcmp(data->extensions_required[i], name) == 0)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
const char* getBaseName(const char* path)
|
|
{
|
|
const char* slash = strrchr(path, '/');
|
|
const char* backslash = strrchr(path, '\\');
|
|
|
|
const char* rs = slash ? slash + 1 : path;
|
|
const char* bs = backslash ? backslash + 1 : path;
|
|
|
|
return std::max(rs, bs);
|
|
}
|
|
|
|
std::string getBufferSpec(const char* bin_path, size_t bin_size, const char* fallback_path, size_t fallback_size, bool fallback_ref)
|
|
{
|
|
std::string json;
|
|
append(json, "\"buffers\":[");
|
|
append(json, "{");
|
|
if (bin_path)
|
|
{
|
|
append(json, "\"uri\":\"");
|
|
append(json, bin_path);
|
|
append(json, "\"");
|
|
}
|
|
comma(json);
|
|
append(json, "\"byteLength\":");
|
|
append(json, bin_size);
|
|
append(json, "}");
|
|
if (fallback_ref)
|
|
{
|
|
comma(json);
|
|
append(json, "{");
|
|
if (fallback_path)
|
|
{
|
|
append(json, "\"uri\":\"");
|
|
append(json, fallback_path);
|
|
append(json, "\"");
|
|
}
|
|
comma(json);
|
|
append(json, "\"byteLength\":");
|
|
append(json, fallback_size);
|
|
append(json, ",\"extensions\":{");
|
|
append(json, "\"MESHOPT_compression\":{");
|
|
append(json, "\"fallback\":true");
|
|
append(json, "}}");
|
|
append(json, "}");
|
|
}
|
|
append(json, "]");
|
|
|
|
return json;
|
|
}
|
|
|
|
int gltfpack(const char* input, const char* output, const Settings& settings)
|
|
{
|
|
cgltf_data* data = 0;
|
|
std::vector<Mesh> meshes;
|
|
|
|
const char* iext = strrchr(input, '.');
|
|
|
|
if (iext && (strcmp(iext, ".gltf") == 0 || strcmp(iext, ".GLTF") == 0 || strcmp(iext, ".glb") == 0 || strcmp(iext, ".GLB") == 0))
|
|
{
|
|
cgltf_options options = {};
|
|
cgltf_result result = cgltf_parse_file(&options, input, &data);
|
|
result = (result == cgltf_result_success) ? cgltf_validate(data) : result;
|
|
result = (result == cgltf_result_success) ? cgltf_load_buffers(&options, data, input) : result;
|
|
|
|
const char* error = NULL;
|
|
|
|
if (result != cgltf_result_success)
|
|
error = getError(result);
|
|
else if (requiresExtension(data, "KHR_draco_mesh_compression"))
|
|
error = "file requires Draco mesh compression support";
|
|
else if (requiresExtension(data, "MESHOPT_compression"))
|
|
error = "file has already been compressed using gltfpack";
|
|
|
|
if (error)
|
|
{
|
|
fprintf(stderr, "Error loading %s: %s\n", input, error);
|
|
cgltf_free(data);
|
|
return 2;
|
|
}
|
|
|
|
parseMeshesGltf(data, meshes);
|
|
}
|
|
else if (iext && (strcmp(iext, ".obj") == 0 || strcmp(iext, ".OBJ") == 0))
|
|
{
|
|
fastObjMesh* obj = fast_obj_read(input);
|
|
|
|
if (!obj)
|
|
{
|
|
fprintf(stderr, "Error loading %s: file not found\n", input);
|
|
cgltf_free(data);
|
|
return 2;
|
|
}
|
|
|
|
data = parseSceneObj(obj);
|
|
parseMeshesObj(obj, data, meshes);
|
|
|
|
fast_obj_destroy(obj);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Error loading %s: unknown extension (expected .gltf or .glb or .obj)\n", input);
|
|
return 2;
|
|
}
|
|
|
|
std::string json, bin, fallback;
|
|
process(data, input, output, meshes, settings, json, bin, fallback);
|
|
|
|
cgltf_free(data);
|
|
|
|
if (!output)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
const char* oext = strrchr(output, '.');
|
|
|
|
if (oext && (strcmp(oext, ".gltf") == 0 || strcmp(oext, ".GLTF") == 0))
|
|
{
|
|
std::string binpath = output;
|
|
binpath.replace(binpath.size() - 5, 5, ".bin");
|
|
|
|
std::string fbpath = output;
|
|
fbpath.replace(fbpath.size() - 5, 5, ".fallback.bin");
|
|
|
|
FILE* outjson = fopen(output, "wb");
|
|
FILE* outbin = fopen(binpath.c_str(), "wb");
|
|
FILE* outfb = settings.fallback ? fopen(fbpath.c_str(), "wb") : NULL;
|
|
if (!outjson || !outbin || (!outfb && settings.fallback))
|
|
{
|
|
fprintf(stderr, "Error saving %s\n", output);
|
|
return 4;
|
|
}
|
|
|
|
std::string bufferspec = getBufferSpec(getBaseName(binpath.c_str()), bin.size(), settings.fallback ? getBaseName(fbpath.c_str()) : NULL, fallback.size(), settings.compress);
|
|
|
|
fprintf(outjson, "{");
|
|
fwrite(bufferspec.c_str(), bufferspec.size(), 1, outjson);
|
|
fprintf(outjson, ",");
|
|
fwrite(json.c_str(), json.size(), 1, outjson);
|
|
fprintf(outjson, "}");
|
|
|
|
fwrite(bin.c_str(), bin.size(), 1, outbin);
|
|
|
|
if (settings.fallback)
|
|
fwrite(fallback.c_str(), fallback.size(), 1, outfb);
|
|
|
|
fclose(outjson);
|
|
fclose(outbin);
|
|
if (outfb)
|
|
fclose(outfb);
|
|
}
|
|
else if (oext && (strcmp(oext, ".glb") == 0 || strcmp(oext, ".GLB") == 0))
|
|
{
|
|
std::string fbpath = output;
|
|
fbpath.replace(fbpath.size() - 4, 4, ".fallback.bin");
|
|
|
|
FILE* out = fopen(output, "wb");
|
|
FILE* outfb = settings.fallback ? fopen(fbpath.c_str(), "wb") : NULL;
|
|
if (!out || (!outfb && settings.fallback))
|
|
{
|
|
fprintf(stderr, "Error saving %s\n", output);
|
|
return 4;
|
|
}
|
|
|
|
std::string bufferspec = getBufferSpec(NULL, bin.size(), settings.fallback ? getBaseName(fbpath.c_str()) : NULL, fallback.size(), settings.compress);
|
|
|
|
json.insert(0, "{" + bufferspec + ",");
|
|
json.push_back('}');
|
|
|
|
while (json.size() % 4)
|
|
json.push_back(' ');
|
|
|
|
while (bin.size() % 4)
|
|
bin.push_back('\0');
|
|
|
|
writeU32(out, 0x46546C67);
|
|
writeU32(out, 2);
|
|
writeU32(out, uint32_t(12 + 8 + json.size() + 8 + bin.size()));
|
|
|
|
writeU32(out, uint32_t(json.size()));
|
|
writeU32(out, 0x4E4F534A);
|
|
fwrite(json.c_str(), json.size(), 1, out);
|
|
|
|
writeU32(out, uint32_t(bin.size()));
|
|
writeU32(out, 0x004E4942);
|
|
fwrite(bin.c_str(), bin.size(), 1, out);
|
|
|
|
if (settings.fallback)
|
|
fwrite(fallback.c_str(), fallback.size(), 1, outfb);
|
|
|
|
fclose(out);
|
|
if (outfb)
|
|
fclose(outfb);
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Error saving %s: unknown extension (expected .gltf or .glb)\n", output);
|
|
return 4;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
Settings settings = {};
|
|
settings.pos_bits = 14;
|
|
settings.tex_bits = 12;
|
|
settings.nrm_bits = 8;
|
|
settings.anim_freq = 30;
|
|
settings.simplify_threshold = 1.f;
|
|
settings.texture_quality = 50;
|
|
|
|
const char* input = 0;
|
|
const char* output = 0;
|
|
bool help = false;
|
|
int test = 0;
|
|
|
|
for (int i = 1; i < argc; ++i)
|
|
{
|
|
const char* arg = argv[i];
|
|
|
|
if (strcmp(arg, "-vp") == 0 && i + 1 < argc && isdigit(argv[i + 1][0]))
|
|
{
|
|
settings.pos_bits = atoi(argv[++i]);
|
|
}
|
|
else if (strcmp(arg, "-vt") == 0 && i + 1 < argc && isdigit(argv[i + 1][0]))
|
|
{
|
|
settings.tex_bits = atoi(argv[++i]);
|
|
}
|
|
else if (strcmp(arg, "-vn") == 0 && i + 1 < argc && isdigit(argv[i + 1][0]))
|
|
{
|
|
settings.nrm_bits = atoi(argv[++i]);
|
|
}
|
|
else if (strcmp(arg, "-vu") == 0)
|
|
{
|
|
settings.nrm_unnormalized = true;
|
|
}
|
|
else if (strcmp(arg, "-af") == 0 && i + 1 < argc && isdigit(argv[i + 1][0]))
|
|
{
|
|
settings.anim_freq = atoi(argv[++i]);
|
|
}
|
|
else if (strcmp(arg, "-ac") == 0)
|
|
{
|
|
settings.anim_const = true;
|
|
}
|
|
else if (strcmp(arg, "-kn") == 0)
|
|
{
|
|
settings.keep_named = true;
|
|
}
|
|
else if (strcmp(arg, "-si") == 0 && i + 1 < argc && isdigit(argv[i + 1][0]))
|
|
{
|
|
settings.simplify_threshold = float(atof(argv[++i]));
|
|
}
|
|
else if (strcmp(arg, "-sa") == 0)
|
|
{
|
|
settings.simplify_aggressive = true;
|
|
}
|
|
else if (strcmp(arg, "-te") == 0)
|
|
{
|
|
settings.texture_embed = true;
|
|
}
|
|
else if (strcmp(arg, "-tb") == 0)
|
|
{
|
|
settings.texture_basis = true;
|
|
}
|
|
else if (strcmp(arg, "-tq") == 0 && i + 1 < argc && isdigit(argv[i + 1][0]))
|
|
{
|
|
settings.texture_quality = atoi(argv[++i]);
|
|
}
|
|
else if (strcmp(arg, "-i") == 0 && i + 1 < argc && !input)
|
|
{
|
|
input = argv[++i];
|
|
}
|
|
else if (strcmp(arg, "-o") == 0 && i + 1 < argc && !output)
|
|
{
|
|
output = argv[++i];
|
|
}
|
|
else if (strcmp(arg, "-c") == 0)
|
|
{
|
|
settings.compress = true;
|
|
}
|
|
else if (strcmp(arg, "-cf") == 0)
|
|
{
|
|
settings.compress = true;
|
|
settings.fallback = true;
|
|
}
|
|
else if (strcmp(arg, "-v") == 0)
|
|
{
|
|
settings.verbose = 1;
|
|
}
|
|
else if (strcmp(arg, "-vv") == 0)
|
|
{
|
|
settings.verbose = 2;
|
|
}
|
|
else if (strcmp(arg, "-h") == 0)
|
|
{
|
|
help = true;
|
|
}
|
|
else if (strcmp(arg, "-test") == 0)
|
|
{
|
|
test = i + 1;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
fprintf(stderr, "Unrecognized option %s\n", arg);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (test)
|
|
{
|
|
for (int i = test; i < argc; ++i)
|
|
{
|
|
printf("%s\n", argv[i]);
|
|
gltfpack(argv[i], NULL, settings);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
if (!input || !output || help)
|
|
{
|
|
fprintf(stderr, "Usage: gltfpack [options] -i input -o output\n");
|
|
fprintf(stderr, "\n");
|
|
fprintf(stderr, "Options:\n");
|
|
fprintf(stderr, "-i file: input file to process, .obj/.gltf/.glb\n");
|
|
fprintf(stderr, "-o file: output file path, .gltf/.glb\n");
|
|
fprintf(stderr, "-vp N: use N-bit quantization for positions (default: 14; N should be between 1 and 16)\n");
|
|
fprintf(stderr, "-vt N: use N-bit quantization for texture corodinates (default: 12; N should be between 1 and 16)\n");
|
|
fprintf(stderr, "-vn N: use N-bit quantization for normals and tangents (default: 8; N should be between 1 and 16)\n");
|
|
fprintf(stderr, "-vu: use unnormalized normal/tangent vectors to improve compression (default: off)\n");
|
|
fprintf(stderr, "-af N: resample animations at N Hz (default: 30)\n");
|
|
fprintf(stderr, "-ac: keep constant animation tracks even if they don't modify the node transform\n");
|
|
fprintf(stderr, "-kn: keep named nodes and meshes attached to named nodes so that named nodes can be transformed externally\n");
|
|
fprintf(stderr, "-si R: simplify meshes to achieve the ratio R (default: 1; R should be between 0 and 1)\n");
|
|
fprintf(stderr, "-sa: aggressively simplify to the target ratio disregarding quality\n");
|
|
fprintf(stderr, "-te: embed all textures into main buffer\n");
|
|
fprintf(stderr, "-tb: convert all textures to Basis Universal format (with basisu executable)\n");
|
|
fprintf(stderr, "-tq N: set texture encoding quality (default: 50; N should be between 1 and 100\n");
|
|
fprintf(stderr, "-c: produce compressed gltf/glb files\n");
|
|
fprintf(stderr, "-cf: produce compressed gltf/glb files with fallback for loaders that don't support compression\n");
|
|
fprintf(stderr, "-v: verbose output\n");
|
|
fprintf(stderr, "-h: display this help and exit\n");
|
|
|
|
return 1;
|
|
}
|
|
|
|
return gltfpack(input, output, settings);
|
|
}
|