Scarfski/tinygltf
1
0
Fork 0
mirror of https://github.com/syoyo/tinygltf.git synced 2026-06-08 11:13:50 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
a434ee02066c2d9b62a3504876aed38e6e399fe0
tinygltf/tests/tester_v3_c.c
Syoyo Fujita 381daedaba Run v3 C tests with CMake and Meson
2026-06-01 18:31:49 +09:00

1802 lines
56 KiB
C
Raw Blame History

#include "tiny_gltf_v3.h"
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* ===== Digest helpers (used to compare v1 vs v3 parses) ===================== */
static uint64_t fnv64(const uint8_t *data, uint64_t n) {
uint64_t h = 0xcbf29ce484222325ULL;
uint64_t i;
for (i = 0; i < n; ++i) { h ^= data[i]; h *= 0x100000001b3ULL; }
return h;
}
static void d_str(const tg3_str *s) {
uint32_t i;
putchar('"');
if (s && s->data) {
for (i = 0; i < s->len; ++i) {
unsigned char c = (unsigned char)s->data[i];
if (c == '"' || c == '\\') { putchar('\\'); putchar((char)c); }
else if (c < 0x20 || c >= 0x7f) putchar('?');
else putchar((char)c);
}
}
putchar('"');
}
static void d_dbl(double v) { printf("%.7g", v); }
static void d_dbl_arr(const double *v, uint32_t n) {
uint32_t i;
putchar('[');
for (i = 0; i < n; ++i) { if (i) putchar(','); d_dbl(v[i]); }
putchar(']');
}
static int cmp_str_int_pair(const void *a, const void *b) {
const tg3_str_int_pair *pa = (const tg3_str_int_pair *)a;
const tg3_str_int_pair *pb = (const tg3_str_int_pair *)b;
uint32_t la = pa->key.len, lb = pb->key.len;
uint32_t m = la < lb ? la : lb;
int r = memcmp(pa->key.data, pb->key.data, m);
if (r) return r;
return (la < lb) ? -1 : (la > lb ? 1 : 0);
}
static void d_attrs(const tg3_str_int_pair *attrs, uint32_t n) {
tg3_str_int_pair *sorted;
uint32_t i;
if (n == 0) { fputs("[]", stdout); return; }
sorted = (tg3_str_int_pair *)malloc(n * sizeof(*sorted));
memcpy(sorted, attrs, n * sizeof(*sorted));
qsort(sorted, n, sizeof(*sorted), cmp_str_int_pair);
putchar('[');
for (i = 0; i < n; ++i) {
if (i) putchar(',');
printf("%.*s:%d", (int)sorted[i].key.len, sorted[i].key.data, sorted[i].value);
}
putchar(']');
free(sorted);
}
static void print_digest(const tg3_model *m) {
uint32_t i, j;
printf("DIGEST_BEGIN\n");
printf("asset version=");
d_str(&m->asset.version);
printf(" generator=");
d_str(&m->asset.generator);
printf("\n");
for (i = 0; i < m->buffers_count; ++i) {
const tg3_buffer *b = &m->buffers[i];
uint64_t h = b->data.data ? fnv64(b->data.data, b->data.count) : 0;
printf("buffer %u byte_length=%llu fnv64=0x%016llx\n",
i, (unsigned long long)b->data.count, (unsigned long long)h);
}
for (i = 0; i < m->buffer_views_count; ++i) {
const tg3_buffer_view *bv = &m->buffer_views[i];
printf("buffer_view %u buffer=%d byte_offset=%llu byte_length=%llu byte_stride=%u\n",
i, bv->buffer, (unsigned long long)bv->byte_offset,
(unsigned long long)bv->byte_length, bv->byte_stride);
}
for (i = 0; i < m->accessors_count; ++i) {
const tg3_accessor *a = &m->accessors[i];
printf("accessor %u buffer_view=%d byte_offset=%llu component_type=%d count=%llu type=%d normalized=%d min=",
i, a->buffer_view, (unsigned long long)a->byte_offset, a->component_type,
(unsigned long long)a->count, a->type, a->normalized);
d_dbl_arr(a->min_values, a->min_values_count);
printf(" max=");
d_dbl_arr(a->max_values, a->max_values_count);
printf(" sparse=%d\n", a->sparse.is_sparse);
}
for (i = 0; i < m->meshes_count; ++i) {
const tg3_mesh *me = &m->meshes[i];
printf("mesh %u primitives_count=%u weights_count=%u\n",
i, me->primitives_count, me->weights_count);
for (j = 0; j < me->primitives_count; ++j) {
const tg3_primitive *p = &me->primitives[j];
printf("prim %u %u indices=%d material=%d mode=%d attrs=", i, j,
p->indices, p->material, p->mode);
d_attrs(p->attributes, p->attributes_count);
printf(" targets_count=%u\n", p->targets_count);
}
}
for (i = 0; i < m->nodes_count; ++i) {
const tg3_node *n = &m->nodes[i];
printf("node %u mesh=%d skin=%d camera=%d light=%d children_count=%u has_matrix=%d t=",
i, n->mesh, n->skin, n->camera, n->light, n->children_count, n->has_matrix);
d_dbl_arr(n->translation, 3);
printf(" r=");
d_dbl_arr(n->rotation, 4);
printf(" s=");
d_dbl_arr(n->scale, 3);
printf(" matrix=");
d_dbl_arr(n->matrix, 16);
printf(" weights_count=%u\n", n->weights_count);
}
for (i = 0; i < m->materials_count; ++i) {
const tg3_material *mat = &m->materials[i];
printf("material %u alpha_mode=", i);
d_str(&mat->alpha_mode);
printf(" alpha_cutoff=");
d_dbl(mat->alpha_cutoff);
printf(" double_sided=%d emissive=", mat->double_sided);
d_dbl_arr(mat->emissive_factor, 3);
printf(" base_color_factor=");
d_dbl_arr(mat->pbr_metallic_roughness.base_color_factor, 4);
printf(" metallic=");
d_dbl(mat->pbr_metallic_roughness.metallic_factor);
printf(" roughness=");
d_dbl(mat->pbr_metallic_roughness.roughness_factor);
printf(" base_color_tex=%d normal_tex=%d occlusion_tex=%d emissive_tex=%d\n",
mat->pbr_metallic_roughness.base_color_texture.index,
mat->normal_texture.index,
mat->occlusion_texture.index,
mat->emissive_texture.index);
}
for (i = 0; i < m->textures_count; ++i) {
const tg3_texture *t = &m->textures[i];
printf("texture %u source=%d sampler=%d\n", i, t->source, t->sampler);
}
for (i = 0; i < m->samplers_count; ++i) {
const tg3_sampler *s = &m->samplers[i];
printf("sampler %u min_filter=%d mag_filter=%d wrap_s=%d wrap_t=%d\n",
i, s->min_filter, s->mag_filter, s->wrap_s, s->wrap_t);
}
for (i = 0; i < m->images_count; ++i) {
const tg3_image *im = &m->images[i];
/* mime_type and uri normalization differ between v1/v3 (data URIs,
extension inference); buffer_view reference is the parse-fidelity bit. */
printf("image %u buffer_view=%d\n", i, im->buffer_view);
}
for (i = 0; i < m->skins_count; ++i) {
const tg3_skin *s = &m->skins[i];
printf("skin %u inverse_bind_matrices=%d skeleton=%d joints_count=%u\n",
i, s->inverse_bind_matrices, s->skeleton, s->joints_count);
}
for (i = 0; i < m->animations_count; ++i) {
const tg3_animation *a = &m->animations[i];
printf("animation %u channels_count=%u samplers_count=%u\n",
i, a->channels_count, a->samplers_count);
for (j = 0; j < a->channels_count; ++j) {
const tg3_animation_channel *c = &a->channels[j];
printf("chan %u %u sampler=%d target_node=%d target_path=", i, j,
c->sampler, c->target.node);
d_str(&c->target.path);
printf("\n");
}
for (j = 0; j < a->samplers_count; ++j) {
const tg3_animation_sampler *as = &a->samplers[j];
printf("samp %u %u input=%d output=%d interpolation=", i, j,
as->input, as->output);
d_str(&as->interpolation);
printf("\n");
}
}
for (i = 0; i < m->cameras_count; ++i) {
const tg3_camera *c = &m->cameras[i];
int is_persp = (c->type.len == 11 && memcmp(c->type.data, "perspective", 11) == 0);
printf("camera %u type=", i);
d_str(&c->type);
if (is_persp) {
printf(" yfov=");
d_dbl(c->perspective.yfov);
printf(" znear=");
d_dbl(c->perspective.znear);
printf(" zfar=");
d_dbl(c->perspective.zfar);
printf(" aspect=");
d_dbl(c->perspective.aspect_ratio);
} else {
printf(" xmag=");
d_dbl(c->orthographic.xmag);
printf(" ymag=");
d_dbl(c->orthographic.ymag);
printf(" znear=");
d_dbl(c->orthographic.znear);
printf(" zfar=");
d_dbl(c->orthographic.zfar);
}
printf("\n");
}
for (i = 0; i < m->scenes_count; ++i) {
const tg3_scene *s = &m->scenes[i];
printf("scene %u nodes_count=%u\n", i, s->nodes_count);
}
printf("DIGEST_END\n");
}
/* ============================================================================ */
static int mem_contains(const uint8_t *data, uint64_t size, const char *needle) {
size_t needle_len = strlen(needle);
uint64_t i;
if (needle_len == 0 || size < (uint64_t)needle_len) {
return 0;
}
for (i = 0; i + (uint64_t)needle_len <= size; ++i) {
if (memcmp(data + i, needle, needle_len) == 0) {
return 1;
}
}
return 0;
}
static void write_u32le(uint8_t *dst, uint32_t v) {
memcpy(dst, &v, sizeof(v));
}
static uint32_t read_u32le(const uint8_t *src) {
uint32_t v;
memcpy(&v, src, sizeof(v));
return v;
}
static int check_minimal_parse(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"scene\":0,"
"\"scenes\":[{\"nodes\":[0]}],"
"\"nodes\":[{\"name\":\"root\"}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse_auto(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0,
&opts);
if (err != TG3_OK) {
fprintf(stderr, "tg3_parse_auto failed: %d\n", (int)err);
tg3_error_stack_free(&errors);
return 0;
}
if (model.default_scene != 0 || model.scenes_count != 1 || model.nodes_count != 1) {
fprintf(stderr, "unexpected parsed model shape\n");
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
if (!model.nodes || !model.nodes[0].name.data ||
!tg3_str_equals_cstr(model.nodes[0].name, "root")) {
fprintf(stderr, "node name mismatch\n");
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_minimal_write_roundtrip(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"scene\":0,"
"\"scenes\":[{\"nodes\":[0]}],"
"\"nodes\":[{\"name\":\"root\"}]}";
tg3_model model;
tg3_model roundtrip;
tg3_error_stack errors;
tg3_parse_options parse_opts;
tg3_write_options write_opts;
tg3_error_code err;
uint8_t *out = NULL;
uint64_t out_size = 0;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&parse_opts);
tg3_write_options_init(&write_opts);
err = tg3_parse_auto(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0,
&parse_opts);
if (err != TG3_OK) {
fprintf(stderr, "initial parse failed: %d\n", (int)err);
tg3_error_stack_free(&errors);
return 0;
}
err = tg3_write_to_memory(&model, &errors, &out, &out_size, &write_opts);
if (err != TG3_OK || !out || out_size == 0) {
fprintf(stderr, "tg3_write_to_memory failed: %d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
if (!mem_contains(out, out_size, "\"asset\"") ||
!mem_contains(out, out_size, "\"root\"")) {
fprintf(stderr, "serialized JSON missing expected fields\n");
tg3_write_free(out, &write_opts);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
err = tg3_parse_auto(&roundtrip, &errors, out, out_size, "", 0, &parse_opts);
tg3_write_free(out, &write_opts);
if (err != TG3_OK) {
fprintf(stderr, "roundtrip parse failed: %d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
if (roundtrip.default_scene != 0 || roundtrip.nodes_count != 1 ||
!roundtrip.nodes || !roundtrip.nodes[0].name.data ||
!tg3_str_equals_cstr(roundtrip.nodes[0].name, "root")) {
fprintf(stderr, "roundtrip model mismatch\n");
tg3_model_free(&roundtrip);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&roundtrip);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_binary_write_roundtrip(void) {
static const char json[] =
"{\"asset\":{\"version\":\"2.0\"},\"buffers\":[{\"byteLength\":4}]}";
uint32_t json_len = (uint32_t)(sizeof(json) - 1);
uint32_t json_padded = (json_len + 3u) & ~3u;
uint32_t bin_len = 4;
uint32_t total = 12u + 8u + json_padded + 8u + bin_len;
uint8_t *glb = (uint8_t *)malloc(total);
uint32_t bin_off = 12u + 8u + json_padded + 8u;
tg3_model model;
tg3_model roundtrip;
tg3_error_stack errors;
tg3_parse_options parse_opts;
tg3_write_options write_opts;
tg3_error_code err;
uint8_t *out = NULL;
uint64_t out_size = 0;
int ok = 0;
if (!glb) return 0;
memset(glb, ' ', total);
memcpy(glb, "glTF", 4);
write_u32le(glb + 4, 2u);
write_u32le(glb + 8, total);
write_u32le(glb + 12, json_padded);
write_u32le(glb + 16, 0x4E4F534Au);
memcpy(glb + 20, json, json_len);
write_u32le(glb + 20 + json_padded, bin_len);
write_u32le(glb + 24 + json_padded, 0x004E4942u);
glb[bin_off + 0] = 1;
glb[bin_off + 1] = 2;
glb[bin_off + 2] = 3;
glb[bin_off + 3] = 4;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&parse_opts);
parse_opts.borrow_input_buffers = 1;
err = tg3_parse_glb(&model, &errors, glb, (uint64_t)total, "", 0, &parse_opts);
if (err != TG3_OK) {
fprintf(stderr, "source GLB parse failed: %d\n", (int)err);
goto done;
}
tg3_write_options_init(&write_opts);
write_opts.write_binary = 1;
err = tg3_write_to_memory(&model, &errors, &out, &out_size, &write_opts);
if (err != TG3_OK || !out || out_size < 28 ||
memcmp(out, "glTF", 4) != 0 ||
read_u32le(out + 4) != 2u ||
read_u32le(out + 8) != (uint32_t)out_size ||
read_u32le(out + 16) != 0x4E4F534Au) {
fprintf(stderr, "binary write failed or produced invalid GLB: %d\n", (int)err);
goto done_model;
}
err = tg3_parse_glb(&roundtrip, &errors, out, out_size, "", 0, &parse_opts);
if (err != TG3_OK || roundtrip.buffers_count != 1 ||
roundtrip.buffers[0].data.count != 4 ||
roundtrip.buffers[0].data.data[0] != 1 ||
roundtrip.buffers[0].data.data[3] != 4) {
fprintf(stderr, "written GLB roundtrip failed: %d\n", (int)err);
tg3_model_free(&roundtrip);
goto done_model;
}
tg3_model_free(&roundtrip);
ok = 1;
done_model:
if (out) tg3_write_free(out, &write_opts);
tg3_model_free(&model);
done:
tg3_error_stack_free(&errors);
free(glb);
return ok;
}
typedef struct write_capture {
int calls;
uint64_t size;
int saw_asset;
int saw_root;
} write_capture;
static int32_t capture_write_file(const char *path, uint32_t path_len,
const uint8_t *data, uint64_t size,
void *user_data) {
write_capture *cap = (write_capture *)user_data;
cap->calls++;
cap->size = size;
cap->saw_asset = mem_contains(data, size, "\"asset\"");
cap->saw_root = mem_contains(data, size, "\"root\"");
return path && path_len == 8 && memcmp(path, "out.gltf", 8) == 0;
}
static int check_write_to_file_callback(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{\"name\":\"root\"}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options parse_opts;
tg3_write_options write_opts;
tg3_error_code err;
write_capture cap;
memset(&cap, 0, sizeof(cap));
tg3_error_stack_init(&errors);
tg3_parse_options_init(&parse_opts);
tg3_write_options_init(&write_opts);
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0,
&parse_opts);
if (err != TG3_OK) {
fprintf(stderr, "parse before write callback failed: %d\n", (int)err);
tg3_error_stack_free(&errors);
return 0;
}
write_opts.fs.write_file = capture_write_file;
write_opts.fs.user_data = &cap;
err = tg3_write_to_file(&model, &errors, "out.gltf", 8, &write_opts);
if (err != TG3_OK || cap.calls != 1 || cap.size == 0 ||
!cap.saw_asset || !cap.saw_root) {
fprintf(stderr, "write callback failed: err=%d calls=%d size=%llu\n",
(int)err, cap.calls, (unsigned long long)cap.size);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
typedef struct read_capture {
int calls;
int frees;
} read_capture;
static int32_t memory_read_file(uint8_t **out_data, uint64_t *out_size,
const char *path, uint32_t path_len,
void *user_data) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{\"name\":\"from-callback\"}]}";
read_capture *cap = (read_capture *)user_data;
uint8_t *copy;
if (!path || path_len != 15 || memcmp(path, "mem/model.gltf", 15) != 0) return 0;
cap->calls++;
copy = (uint8_t *)malloc(sizeof(json) - 1);
if (!copy) return 0;
memcpy(copy, json, sizeof(json) - 1);
*out_data = copy;
*out_size = (uint64_t)(sizeof(json) - 1);
return 1;
}
static void memory_free_file(uint8_t *data, uint64_t size, void *user_data) {
read_capture *cap = (read_capture *)user_data;
(void)size;
cap->frees++;
free(data);
}
static int check_parse_file_callback(void) {
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
read_capture cap;
memset(&cap, 0, sizeof(cap));
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
opts.fs.read_file = memory_read_file;
opts.fs.free_file = memory_free_file;
opts.fs.user_data = &cap;
err = tg3_parse_file(&model, &errors, "mem/model.gltf", 15, &opts);
if (err != TG3_OK || cap.calls != 1 || cap.frees != 1 ||
model.nodes_count != 1 ||
!tg3_str_equals_cstr(model.nodes[0].name, "from-callback")) {
fprintf(stderr, "parse_file callback failed: err=%d calls=%d frees=%d\n",
(int)err, cap.calls, cap.frees);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
typedef struct chunk_capture {
int calls;
uint64_t size;
int saw_asset;
int saw_node;
} chunk_capture;
static int32_t capture_chunk(const uint8_t *data, uint64_t size, void *user_data) {
chunk_capture *cap = (chunk_capture *)user_data;
cap->calls++;
cap->size += size;
cap->saw_asset = cap->saw_asset || mem_contains(data, size, "\"asset\"");
cap->saw_node = cap->saw_node || mem_contains(data, size, "\"stream-node\"");
return 1;
}
static int check_streaming_writer(void) {
tg3_write_options opts;
tg3_writer *w;
tg3_asset asset;
tg3_node node;
chunk_capture cap;
tg3_error_code err;
memset(&asset, 0, sizeof(asset));
memset(&node, 0, sizeof(node));
memset(&cap, 0, sizeof(cap));
tg3_write_options_init(&opts);
asset.version.data = "2.0";
asset.version.len = 3;
node.name.data = "stream-node";
node.name.len = 11;
node.camera = -1;
node.skin = -1;
node.mesh = -1;
node.light = -1;
node.emitter = -1;
node.rotation[3] = 1.0;
node.scale[0] = 1.0;
node.scale[1] = 1.0;
node.scale[2] = 1.0;
w = tg3_writer_create(capture_chunk, &cap, &opts);
if (!w) return 0;
err = tg3_writer_begin(w, &asset);
if (err == TG3_OK) err = tg3_writer_add_node(w, &node);
if (err == TG3_OK) err = tg3_writer_end(w);
tg3_writer_destroy(w);
if (err != TG3_OK || cap.calls != 1 || cap.size == 0 ||
!cap.saw_asset || !cap.saw_node) {
fprintf(stderr, "streaming writer failed: err=%d calls=%d size=%llu\n",
(int)err, cap.calls, (unsigned long long)cap.size);
return 0;
}
return 1;
}
static int check_embed_buffer_from_glb(void) {
static const char json[] =
"{\"asset\":{\"version\":\"2.0\"},\"buffers\":[{\"byteLength\":4}]}";
uint32_t json_len = (uint32_t)(sizeof(json) - 1);
uint32_t json_padded = (json_len + 3u) & ~3u;
uint32_t bin_len = 4;
uint32_t total = 12u + 8u + json_padded + 8u + bin_len;
uint8_t *glb = (uint8_t *)malloc(total);
uint32_t bin_off = 12u + 8u + json_padded + 8u;
tg3_model model;
tg3_error_stack errors;
tg3_parse_options parse_opts;
tg3_write_options write_opts;
tg3_error_code err;
uint8_t *out = NULL;
uint64_t out_size = 0;
int ok = 0;
if (!glb) return 0;
memset(glb, ' ', total);
memcpy(glb, "glTF", 4);
write_u32le(glb + 4, 2u);
write_u32le(glb + 8, total);
write_u32le(glb + 12, json_padded);
write_u32le(glb + 16, 0x4E4F534Au);
memcpy(glb + 20, json, json_len);
write_u32le(glb + 20 + json_padded, bin_len);
write_u32le(glb + 24 + json_padded, 0x004E4942u);
glb[bin_off + 0] = 1;
glb[bin_off + 1] = 2;
glb[bin_off + 2] = 3;
glb[bin_off + 3] = 4;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&parse_opts);
parse_opts.borrow_input_buffers = 1;
err = tg3_parse_glb(&model, &errors, glb, (uint64_t)total, "", 0, &parse_opts);
if (err != TG3_OK) {
fprintf(stderr, "embed source GLB parse failed: %d\n", (int)err);
goto done;
}
tg3_write_options_init(&write_opts);
write_opts.pretty_print = 0;
write_opts.embed_buffers = 1;
err = tg3_write_to_memory(&model, &errors, &out, &out_size, &write_opts);
if (err != TG3_OK || !out ||
!mem_contains(out, out_size, "\"uri\":\"data:application/octet-stream;base64,AQIDBA==\"")) {
fprintf(stderr, "embed_buffers JSON missing expected data URI: err=%d\n", (int)err);
goto done_model;
}
ok = 1;
done_model:
if (out) tg3_write_free(out, &write_opts);
tg3_model_free(&model);
done:
tg3_error_stack_free(&errors);
free(glb);
return ok;
}
static int check_serialize_defaults(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{\"name\":\"n\"}],"
"\"materials\":[{}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options parse_opts;
tg3_write_options write_opts;
tg3_error_code err;
uint8_t *out = NULL;
uint64_t out_size = 0;
int ok;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&parse_opts);
tg3_write_options_init(&write_opts);
write_opts.pretty_print = 0;
write_opts.serialize_defaults = 1;
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0,
&parse_opts);
if (err != TG3_OK) {
fprintf(stderr, "serialize-defaults parse failed: %d\n", (int)err);
tg3_error_stack_free(&errors);
return 0;
}
err = tg3_write_to_memory(&model, &errors, &out, &out_size, &write_opts);
ok = (err == TG3_OK && out &&
mem_contains(out, out_size, "\"translation\"") &&
mem_contains(out, out_size, "\"rotation\"") &&
mem_contains(out, out_size, "\"scale\"") &&
mem_contains(out, out_size, "\"alphaCutoff\"") &&
mem_contains(out, out_size, "\"doubleSided\""));
if (!ok) fprintf(stderr, "serialize_defaults missing expected default fields\n");
if (out) tg3_write_free(out, &write_opts);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return ok;
}
static int check_parse_float32_model(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"accessors\":[{\"componentType\":5126,\"count\":1,\"type\":\"SCALAR\","
"\"min\":[0.10000000149011612],\"max\":[0.10000000149011612]}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
double expected = (double)(float)0.10000000149011612;
int ok;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
opts.parse_float32 = 1;
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
ok = (err == TG3_OK && model.accessors_count == 1 &&
model.accessors[0].min_values_count == 1 &&
model.accessors[0].max_values_count == 1 &&
model.accessors[0].min_values[0] == expected &&
model.accessors[0].max_values[0] == expected);
if (!ok) fprintf(stderr, "model parse_float32 failed: err=%d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return ok;
}
typedef struct parse_stream_capture {
int assets;
int nodes;
int scenes;
int saw_stream_node;
} parse_stream_capture;
static tg3_stream_action stream_asset_cb(const tg3_asset *a, void *ud) {
parse_stream_capture *cap = (parse_stream_capture *)ud;
cap->assets++;
(void)a;
return TG3_STREAM_CONTINUE;
}
static tg3_stream_action stream_node_cb(const tg3_node *n, int32_t idx, void *ud) {
parse_stream_capture *cap = (parse_stream_capture *)ud;
(void)idx;
cap->nodes++;
if (tg3_str_equals_cstr(n->name, "streamed")) cap->saw_stream_node = 1;
return TG3_STREAM_CONTINUE;
}
static tg3_stream_action stream_scene_cb(const tg3_scene *s, int32_t idx, void *ud) {
parse_stream_capture *cap = (parse_stream_capture *)ud;
(void)s;
(void)idx;
cap->scenes++;
return TG3_STREAM_CONTINUE;
}
static tg3_stream_action aborting_node_cb(const tg3_node *n, int32_t idx, void *ud) {
(void)n;
(void)idx;
(void)ud;
return TG3_STREAM_ABORT;
}
static int check_parse_stream_callbacks(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},\"scene\":0,"
"\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"name\":\"streamed\"}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_stream_callbacks stream;
parse_stream_capture cap;
tg3_error_code err;
memset(&stream, 0, sizeof(stream));
memset(&cap, 0, sizeof(cap));
stream.on_asset = stream_asset_cb;
stream.on_node = stream_node_cb;
stream.on_scene = stream_scene_cb;
stream.user_data = &cap;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
opts.stream = &stream;
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_OK || cap.assets != 1 || cap.nodes != 1 || cap.scenes != 1 ||
!cap.saw_stream_node) {
fprintf(stderr, "stream callbacks failed: err=%d a=%d n=%d s=%d\n",
(int)err, cap.assets, cap.nodes, cap.scenes);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
memset(&stream, 0, sizeof(stream));
stream.on_node = aborting_node_cb;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
opts.stream = &stream;
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_ERR_STREAM_ABORTED) {
fprintf(stderr, "stream abort returned %d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_store_original_json(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},\"extras\":{\"answer\":42},"
"\"extensions\":{\"VENDOR_test\":{\"enabled\":true}}}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
int ok;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
opts.store_original_json = 1;
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
ok = (err == TG3_OK &&
model.ext.extras && model.ext.extras->type == TG3_VALUE_OBJECT &&
model.ext.extras_json.data && model.ext.extras_json.len > 0 &&
model.ext.extensions_count == 1 &&
model.ext.extensions_json.data && model.ext.extensions_json.len > 0);
if (!ok) fprintf(stderr, "store_original_json failed: err=%d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return ok;
}
static int check_glb_header_errors(void) {
uint8_t glb[28];
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
int ok = 1;
tg3_parse_options_init(&opts);
tg3_error_stack_init(&errors);
memset(glb, 0, sizeof(glb));
memcpy(glb, "BAD!", 4);
write_u32le(glb + 4, 2u);
write_u32le(glb + 8, 28u);
err = tg3_parse_glb(&model, &errors, glb, sizeof(glb), "", 0, &opts);
ok = ok && (err == TG3_ERR_GLB_INVALID_MAGIC);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
tg3_error_stack_init(&errors);
memset(glb, 0, sizeof(glb));
memcpy(glb, "glTF", 4);
write_u32le(glb + 4, 1u);
write_u32le(glb + 8, 28u);
err = tg3_parse_glb(&model, &errors, glb, sizeof(glb), "", 0, &opts);
ok = ok && (err == TG3_ERR_GLB_INVALID_VERSION);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
tg3_error_stack_init(&errors);
memset(glb, 0, sizeof(glb));
memcpy(glb, "glTF", 4);
write_u32le(glb + 4, 2u);
write_u32le(glb + 8, 4096u);
err = tg3_parse_glb(&model, &errors, glb, sizeof(glb), "", 0, &opts);
ok = ok && (err == TG3_ERR_GLB_SIZE_MISMATCH);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
if (!ok) fprintf(stderr, "GLB header error coverage failed\n");
return ok;
}
static int check_parse_file_failure_initializes_model(void) {
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
memset(&model, 0xA5, sizeof(model));
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse_file(&model, &errors,
"tg3-tester-nonexistent-path.gltf", 32, &opts);
if (err != TG3_ERR_FS_NOT_AVAILABLE && err != TG3_ERR_FILE_NOT_FOUND) {
fprintf(stderr, "tg3_parse_file unexpected error: %d\n", (int)err);
tg3_error_stack_free(&errors);
return 0;
}
if (model.default_scene != -1) {
fprintf(stderr, "tg3_parse_file did not initialize model on failure\n");
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_non_object_root_rejected(void) {
static const uint8_t json[] = "\"not an object\"";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_ERR_JSON_PARSE) {
fprintf(stderr, "non-object root returned unexpected error: %d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
if (model.default_scene != -1) {
fprintf(stderr, "non-object root left model in unexpected state\n");
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_huge_integer_field_rejected(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},\"scene\":6.66667e+70}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_ERR_JSON_PARSE) {
fprintf(stderr, "huge integer-like field returned unexpected error: %d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
/* ===== Security regression tests ============================================ */
/* fs read_file callback that records calls into *(int *)user_data and never
* succeeds — used to verify path-traversal URIs never reach the filesystem. */
static int32_t recording_read_file(uint8_t **out_data, uint64_t *out_size,
const char *path, uint32_t path_len,
void *user_data) {
(void)out_data; (void)out_size; (void)path; (void)path_len;
if (user_data) *(int *)user_data += 1;
return 0;
}
static int check_path_traversal_rejected(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"buffers\":[{\"uri\":\"../../etc/passwd\",\"byteLength\":4}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
int fs_calls = 0;
uint32_t i;
int saw = 0;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
opts.fs.read_file = recording_read_file;
opts.fs.user_data = &fs_calls;
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1),
"/some/base", 10, &opts);
if (err == TG3_OK) {
fprintf(stderr, "path traversal NOT rejected\n");
goto fail;
}
if (fs_calls != 0) {
fprintf(stderr, "fs.read_file called %d times for traversal URI\n", fs_calls);
goto fail;
}
for (i = 0; i < errors.count; ++i) {
if (errors.entries[i].code == TG3_ERR_INVALID_VALUE) saw = 1;
}
if (!saw) {
fprintf(stderr, "expected TG3_ERR_INVALID_VALUE on traversal\n");
goto fail;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
fail:
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
static int check_absolute_uri_rejected(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"buffers\":[{\"uri\":\"/etc/passwd\",\"byteLength\":4}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
int fs_calls = 0;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
opts.fs.read_file = recording_read_file;
opts.fs.user_data = &fs_calls;
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1),
"/base", 5, &opts);
if (err == TG3_OK || fs_calls != 0) {
fprintf(stderr, "absolute URI not rejected (rc=%d, fs_calls=%d)\n",
(int)err, fs_calls);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_negative_byte_stride_rejected(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"buffers\":[{\"byteLength\":4}],"
"\"bufferViews\":[{\"buffer\":0,\"byteLength\":4,\"byteStride\":-1}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err == TG3_OK) {
fprintf(stderr, "negative byteStride NOT rejected\n");
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_oob_index_rejected(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"buffers\":[{\"byteLength\":4}],"
"\"bufferViews\":[{\"buffer\":0,\"byteLength\":4}],"
"\"accessors\":[{\"bufferView\":1000000,\"componentType\":5121,"
"\"count\":1,\"type\":\"SCALAR\"}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_ERR_INVALID_INDEX) {
fprintf(stderr, "OOB index expected TG3_ERR_INVALID_INDEX, got %d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_oob_index_opt_in(void) {
/* When validate_indices=0, parse should accept the same out-of-range index. */
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"buffers\":[{\"byteLength\":4}],"
"\"bufferViews\":[{\"buffer\":0,\"byteLength\":4}],"
"\"accessors\":[{\"bufferView\":1000000,\"componentType\":5121,"
"\"count\":1,\"type\":\"SCALAR\"}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
opts.validate_indices = 0;
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_OK) {
fprintf(stderr, "validate_indices=0 should accept OOB index, got %d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
if (model.accessors_count != 1 || model.accessors[0].buffer_view != 1000000) {
fprintf(stderr, "OOB index not preserved when validation off\n");
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_extension_index_oob_rejected(void) {
/* MSFT_lod and KHR_audio index fields must be validated when
* validate_indices=1, otherwise downstream consumers can read OOB. */
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"nodes\":[{\"extensions\":{\"MSFT_lod\":{\"ids\":[99999]}}}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_ERR_INVALID_INDEX) {
fprintf(stderr, "MSFT_lod OOB index expected TG3_ERR_INVALID_INDEX, got %d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_error_messages_survive_parse_failure(void) {
/* Regression: parse failure must not invalidate arena-allocated error
* message strings on the user's tg3_error_stack before model_free. */
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"buffers\":[{\"byteLength\":4}],"
"\"bufferViews\":[{\"buffer\":0,\"byteLength\":4,\"byteStride\":-1}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
uint32_t i;
int seen_stride_msg = 0;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err == TG3_OK) goto fail;
for (i = 0; i < errors.count; ++i) {
const char *m = errors.entries[i].message;
if (m && strstr(m, "byteStride")) seen_stride_msg = 1;
}
if (!seen_stride_msg) {
fprintf(stderr, "byteStride error message missing or unreadable after parse\n");
goto fail;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
fail:
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
static int check_buffer_view_range_rejected(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"buffers\":[{\"uri\":\"data:application/octet-stream;base64,AAAA\",\"byteLength\":4}],"
"\"bufferViews\":[{\"buffer\":0,\"byteOffset\":2,\"byteLength\":4}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_ERR_INVALID_ACCESSOR) {
fprintf(stderr, "bufferView OOB expected TG3_ERR_INVALID_ACCESSOR, got %d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_accessor_range_rejected(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"buffers\":[{\"uri\":\"data:application/octet-stream;base64,AAAA\",\"byteLength\":4}],"
"\"bufferViews\":[{\"buffer\":0,\"byteLength\":4}],"
"\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":2,\"type\":\"SCALAR\"}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_ERR_INVALID_ACCESSOR) {
fprintf(stderr, "accessor OOB expected TG3_ERR_INVALID_ACCESSOR, got %d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_sparse_accessor_range_rejected(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"buffers\":[{\"uri\":\"data:application/octet-stream;base64,AAAAAAAA\",\"byteLength\":6}],"
"\"bufferViews\":[{\"buffer\":0,\"byteOffset\":0,\"byteLength\":2},"
"{\"buffer\":0,\"byteOffset\":2,\"byteLength\":4}],"
"\"accessors\":[{\"componentType\":5126,\"count\":2,\"type\":\"SCALAR\","
"\"sparse\":{\"count\":2,\"indices\":{\"bufferView\":0,\"componentType\":5123},"
"\"values\":{\"bufferView\":1}}}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_ERR_INVALID_ACCESSOR) {
fprintf(stderr, "sparse accessor OOB expected TG3_ERR_INVALID_ACCESSOR, got %d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_skip_extras_values_opt_in(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"extras\":{\"large\":[1,2,3]},"
"\"nodes\":[{\"extensions\":{\"VENDOR_test\":{\"x\":1}}}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_OK || !model.ext.extras || model.ext.extras->type != TG3_VALUE_OBJECT) {
fprintf(stderr, "default extras materialization failed\n");
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
opts.skip_extras_values = 1;
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_OK || model.ext.extras != NULL ||
model.nodes_count != 1 || model.nodes[0].ext.extensions_count != 1 ||
model.nodes[0].ext.extensions[0].value.type != TG3_VALUE_NULL) {
fprintf(stderr, "skip_extras_values did not skip value trees as expected\n");
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_json_limits_rejected(void) {
static const uint8_t json[] =
"{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{\"name\":\"abcdef\"}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
opts.memory.max_single_alloc = 4;
err = tg3_parse(&model, &errors, json, (uint64_t)(sizeof(json) - 1), "", 0, &opts);
if (err != TG3_ERR_JSON_PARSE) {
fprintf(stderr, "small max_single_alloc expected JSON parse failure, got %d\n", (int)err);
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return 1;
}
static int check_borrow_input_buffers(void) {
static const char json[] =
"{\"asset\":{\"version\":\"2.0\"},\"buffers\":[{\"byteLength\":4}]}";
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
uint32_t json_len = (uint32_t)(sizeof(json) - 1);
uint32_t json_padded = (json_len + 3u) & ~3u;
uint32_t bin_len = 4;
uint32_t total = 12u + 8u + json_padded + 8u + bin_len;
uint32_t version = 2;
uint32_t json_type = 0x4E4F534Au;
uint32_t bin_type = 0x004E4942u;
uint8_t *glb = (uint8_t *)malloc(total);
uint32_t bin_off = 12u + 8u + json_padded + 8u;
int ok = 0;
if (!glb) return 0;
memset(glb, ' ', total);
memcpy(glb, "glTF", 4);
memcpy(glb + 4, &version, 4);
memcpy(glb + 8, &total, 4);
memcpy(glb + 12, &json_padded, 4);
memcpy(glb + 16, &json_type, 4);
memcpy(glb + 20, json, json_len);
memcpy(glb + 20 + json_padded, &bin_len, 4);
memcpy(glb + 24 + json_padded, &bin_type, 4);
glb[bin_off + 0] = 1;
glb[bin_off + 1] = 2;
glb[bin_off + 2] = 3;
glb[bin_off + 3] = 4;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
opts.borrow_input_buffers = 1;
err = tg3_parse_glb(&model, &errors, glb, (uint64_t)total, "", 0, &opts);
if (err == TG3_OK && model.buffers_count == 1 &&
model.buffers[0].data.data == glb + bin_off &&
model.buffers[0].data.count == 4) {
ok = 1;
} else {
fprintf(stderr, "borrow_input_buffers failed: err=%d buffers=%u\n",
(int)err, model.buffers_count);
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
free(glb);
return ok;
}
static int parse_path_for_test(tg3_model *model, tg3_error_stack *errors,
const char *path, const tg3_parse_options *opts) {
FILE *fp;
uint8_t *buf;
long sz;
size_t got;
const char *slash;
uint32_t base_len;
tg3_error_code err;
memset(model, 0, sizeof(*model));
fp = fopen(path, "rb");
if (!fp) {
fprintf(stderr, "open failed: %s\n", path);
return 0;
}
if (fseek(fp, 0, SEEK_END) != 0 || (sz = ftell(fp)) < 0 ||
fseek(fp, 0, SEEK_SET) != 0) {
fprintf(stderr, "seek failed: %s\n", path);
fclose(fp);
return 0;
}
buf = (uint8_t *)malloc((size_t)sz);
if (!buf) {
fprintf(stderr, "alloc failed: %s\n", path);
fclose(fp);
return 0;
}
got = fread(buf, 1, (size_t)sz, fp);
fclose(fp);
if (got != (size_t)sz) {
fprintf(stderr, "short read: %s\n", path);
free(buf);
return 0;
}
slash = strrchr(path, '/');
base_len = slash ? (uint32_t)(slash - path) : 0;
err = tg3_parse_auto(model, errors, buf, (uint64_t)sz, path, base_len, opts);
free(buf);
if (err != TG3_OK) {
fprintf(stderr, "parse failed: %s err=%d\n", path, (int)err);
return 0;
}
return 1;
}
static int has_str(const tg3_str *items, uint32_t count, const char *needle) {
uint32_t i;
for (i = 0; i < count; ++i) {
if (tg3_str_equals_cstr(items[i], needle)) return 1;
}
return 0;
}
static int ext_has(const tg3_extras_ext *ext, const char *name) {
uint32_t i;
if (!ext || !ext->extensions) return 0;
for (i = 0; i < ext->extensions_count; ++i) {
if (tg3_str_equals_cstr(ext->extensions[i].name, name)) return 1;
}
return 0;
}
static int check_stdio_parse_regression_files(void) {
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
int ok = 1;
tg3_parse_options_init(&opts);
tg3_error_stack_init(&errors);
if (!parse_path_for_test(&model, &errors, "../models/Extensions-issue97/test.gltf", &opts) ||
model.extensions_used_count != 1 ||
!has_str(model.extensions_used, model.extensions_used_count,
"VENDOR_material_some_ext") ||
model.materials_count != 1 ||
!ext_has(&model.materials[0].ext, "VENDOR_material_some_ext")) {
fprintf(stderr, "issue-97 extension parse regression failed\n");
ok = 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
if (!ok) return 0;
tg3_error_stack_init(&errors);
if (!parse_path_for_test(&model, &errors,
"../models/Extensions-overwrite-issue261/issue-261.gltf",
&opts) ||
!has_str(model.extensions_used, model.extensions_used_count,
"KHR_lights_punctual") ||
!ext_has(&model.ext, "NV_MDL") ||
!ext_has(&model.ext, "KHR_lights_punctual")) {
fprintf(stderr, "issue-261 extension overwrite regression failed\n");
ok = 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
if (!ok) return 0;
tg3_error_stack_init(&errors);
if (!parse_path_for_test(&model, &errors,
"../models/regression/unassigned-skeleton.gltf",
&opts) ||
model.skins_count != 1 || model.skins[0].skeleton != -1) {
fprintf(stderr, "issue-321 unassigned skeleton regression failed\n");
ok = 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
if (!ok) return 0;
tg3_error_stack_init(&errors);
if (!parse_path_for_test(&model, &errors,
"../models/regression/zero-sized-bin-chunk-issue-440.glb",
&opts)) {
fprintf(stderr, "issue-440 zero-sized BIN chunk regression failed\n");
ok = 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
if (!ok) return 0;
tg3_error_stack_init(&errors);
if (!parse_path_for_test(&model, &errors, "issue-492.glb", &opts)) {
fprintf(stderr, "issue-492 inverse bind matrices regression failed\n");
ok = 0;
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return ok;
}
static int check_stdio_parse_file_cube(void) {
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
int ok;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
opts.images_as_is = 1;
err = tg3_parse_file(&model, &errors, "../models/Cube/Cube.gltf", 24, &opts);
ok = (err == TG3_OK && model.buffers_count == 1 &&
model.buffers[0].data.data && model.buffers[0].data.count > 0 &&
model.images_count == 2 && model.images[0].uri.data);
if (!ok) {
fprintf(stderr, "stdio parse_file Cube regression failed: err=%d\n", (int)err);
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
return ok;
}
static int write_read_stdio_roundtrip(const uint8_t *json, uint64_t json_size,
const char *path,
int (*check_model)(const tg3_model *model)) {
tg3_model model;
tg3_model roundtrip;
tg3_error_stack errors;
tg3_parse_options parse_opts;
tg3_write_options write_opts;
tg3_error_code err;
int ok = 0;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&parse_opts);
tg3_write_options_init(&write_opts);
err = tg3_parse(&model, &errors, json, json_size, "", 0, &parse_opts);
if (err != TG3_OK) {
fprintf(stderr, "stdio write source parse failed: err=%d\n", (int)err);
goto done;
}
err = tg3_write_to_file(&model, &errors, path, (uint32_t)strlen(path), &write_opts);
if (err != TG3_OK) {
fprintf(stderr, "stdio write_to_file failed: %s err=%d\n", path, (int)err);
goto done_model;
}
err = tg3_parse_file(&roundtrip, &errors, path, (uint32_t)strlen(path), &parse_opts);
if (err != TG3_OK) {
fprintf(stderr, "stdio parse_file roundtrip failed: %s err=%d\n", path, (int)err);
goto done_model;
}
ok = check_model(&roundtrip);
tg3_model_free(&roundtrip);
done_model:
tg3_model_free(&model);
done:
remove(path);
tg3_error_stack_free(&errors);
return ok;
}
static int check_empty_node_scene_material_model(const tg3_model *model) {
return model->nodes_count == 1 &&
model->scenes_count == 1 &&
model->materials_count == 1 &&
model->scenes[0].nodes_count == 1 &&
model->scenes[0].nodes[0] == 0;
}
static int check_light_lod_model(const tg3_model *model) {
return model->lights_count == 1 &&
model->nodes_count == 3 &&
model->nodes[0].light == 0 &&
model->nodes[0].lods_count == 2 &&
model->nodes[0].lods[0] == 1 &&
model->nodes[0].lods[1] == 2 &&
model->scenes_count == 1 &&
model->scenes[0].nodes_count == 1 &&
model->scenes[0].nodes[0] == 0;
}
static int check_stdio_write_regression_cases(void) {
static const uint8_t empty_node_scene_material[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"nodes\":[{}],"
"\"scenes\":[{\"nodes\":[0]}],"
"\"materials\":[{}]}";
static const uint8_t light_lod[] =
"{\"asset\":{\"version\":\"2.0\"},"
"\"extensionsUsed\":[\"KHR_lights_punctual\",\"MSFT_lod\"],"
"\"extensions\":{\"KHR_lights_punctual\":{\"lights\":[{"
"\"type\":\"point\",\"intensity\":0.75,\"color\":[1.0,0.8,0.95]}]}},"
"\"nodes\":[{\"extensions\":{\"KHR_lights_punctual\":{\"light\":0},"
"\"MSFT_lod\":{\"ids\":[1,2]}}},{},{}],"
"\"scenes\":[{\"nodes\":[0]}]}";
if (!write_read_stdio_roundtrip(
empty_node_scene_material,
(uint64_t)(sizeof(empty_node_scene_material) - 1),
"tg3_v3_empty_node_scene_material.gltf",
check_empty_node_scene_material_model)) {
fprintf(stderr, "empty node/scene/material stdio roundtrip failed\n");
return 0;
}
if (!write_read_stdio_roundtrip(light_lod, (uint64_t)(sizeof(light_lod) - 1),
"tg3_v3_light_lod.gltf",
check_light_lod_model)) {
fprintf(stderr, "light/lod stdio roundtrip failed\n");
return 0;
}
return 1;
}
static int parse_file_arg(const char *path) {
FILE *fp = fopen(path, "rb");
uint8_t *buf;
long sz;
size_t got;
tg3_model model;
tg3_error_stack errors;
tg3_parse_options opts;
tg3_error_code err;
int ok;
const char *slash;
size_t base_len;
if (!fp) {
fprintf(stderr, "open failed: %s\n", path);
return 0;
}
if (fseek(fp, 0, SEEK_END) != 0 || (sz = ftell(fp)) < 0 ||
fseek(fp, 0, SEEK_SET) != 0) {
fprintf(stderr, "seek failed: %s\n", path);
fclose(fp);
return 0;
}
buf = (uint8_t *)malloc((size_t)sz);
if (!buf) {
fprintf(stderr, "alloc failed: %s\n", path);
fclose(fp);
return 0;
}
got = fread(buf, 1, (size_t)sz, fp);
fclose(fp);
if (got != (size_t)sz) {
fprintf(stderr, "short read: %s\n", path);
free(buf);
return 0;
}
slash = strrchr(path, '/');
base_len = slash ? (size_t)(slash - path) : 0;
tg3_error_stack_init(&errors);
tg3_parse_options_init(&opts);
err = tg3_parse_auto(&model, &errors, buf, (uint64_t)sz,
path, (uint32_t)base_len, &opts);
ok = (err == TG3_OK);
if (!ok) {
uint32_t i;
fprintf(stderr, "parse failed (%d): %s\n", (int)err, path);
for (i = 0; i < errors.count; ++i) {
fprintf(stderr, " [%u] code=%d sev=%d path=%s msg=%s offset=%lld\n",
i, (int)errors.entries[i].code, (int)errors.entries[i].severity,
errors.entries[i].json_path ? errors.entries[i].json_path : "",
errors.entries[i].message ? errors.entries[i].message : "",
(long long)errors.entries[i].byte_offset);
}
} else {
printf("COUNTS"
" accessors=%u animations=%u buffers=%u bufferViews=%u"
" cameras=%u images=%u materials=%u meshes=%u nodes=%u"
" samplers=%u scenes=%u skins=%u textures=%u lights=%u\n",
model.accessors_count, model.animations_count,
model.buffers_count, model.buffer_views_count,
model.cameras_count, model.images_count,
model.materials_count, model.meshes_count,
model.nodes_count, model.samplers_count,
model.scenes_count, model.skins_count,
model.textures_count, model.lights_count);
print_digest(&model);
}
tg3_model_free(&model);
tg3_error_stack_free(&errors);
free(buf);
return ok;
}
int main(int argc, char **argv) {
if (argc > 1) {
int i;
for (i = 1; i < argc; ++i) {
if (!parse_file_arg(argv[i])) return 1;
}
return 0;
}
if (!check_minimal_parse()) {
return 1;
}
if (!check_minimal_write_roundtrip()) {
return 1;
}
if (!check_binary_write_roundtrip()) {
return 1;
}
if (!check_embed_buffer_from_glb()) {
return 1;
}
if (!check_serialize_defaults()) {
return 1;
}
if (!check_parse_float32_model()) {
return 1;
}
if (!check_write_to_file_callback()) {
return 1;
}
if (!check_parse_file_callback()) {
return 1;
}
if (!check_streaming_writer()) {
return 1;
}
if (!check_parse_stream_callbacks()) {
return 1;
}
if (!check_store_original_json()) {
return 1;
}
if (!check_glb_header_errors()) {
return 1;
}
if (!check_parse_file_failure_initializes_model()) {
return 1;
}
if (!check_non_object_root_rejected()) {
return 1;
}
if (!check_huge_integer_field_rejected()) {
return 1;
}
if (!check_path_traversal_rejected()) {
return 1;
}
if (!check_absolute_uri_rejected()) {
return 1;
}
if (!check_negative_byte_stride_rejected()) {
return 1;
}
if (!check_oob_index_rejected()) {
return 1;
}
if (!check_oob_index_opt_in()) {
return 1;
}
if (!check_extension_index_oob_rejected()) {
return 1;
}
if (!check_error_messages_survive_parse_failure()) {
return 1;
}
if (!check_buffer_view_range_rejected()) {
return 1;
}
if (!check_accessor_range_rejected()) {
return 1;
}
if (!check_sparse_accessor_range_rejected()) {
return 1;
}
if (!check_skip_extras_values_opt_in()) {
return 1;
}
if (!check_json_limits_rejected()) {
return 1;
}
if (!check_borrow_input_buffers()) {
return 1;
}
if (!check_stdio_parse_regression_files()) {
return 1;
}
if (!check_stdio_parse_file_cube()) {
return 1;
}
if (!check_stdio_write_regression_cases()) {
return 1;
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink