Debian Codegraph @

third_party/cgltf/cgltf.h

raw
1 /**
2 * cgltf - a single-file glTF 2.0 parser written in C99.
3 *
4 * Version: 1.10
5 *
6 * Website: https://github.com/jkuhlmann/cgltf
7 *
8 * Distributed under the MIT License, see notice at the end of this file.
9 *
10 * Building:
11 * Include this file where you need the struct and function
12 * declarations. Have exactly one source file where you define
13 * `CGLTF_IMPLEMENTATION` before including this file to get the
14 * function definitions.
15 *
16 * Reference:
17 * `cgltf_result cgltf_parse(const cgltf_options*, const void*,
18 * cgltf_size, cgltf_data**)` parses both glTF and GLB data. If
19 * this function returns `cgltf_result_success`, you have to call
20 * `cgltf_free()` on the created `cgltf_data*` variable.
21 * Note that contents of external files for buffers and images are not
22 * automatically loaded. You'll need to read these files yourself using
23 * URIs in the `cgltf_data` structure.
24 *
25 * `cgltf_options` is the struct passed to `cgltf_parse()` to control
26 * parts of the parsing process. You can use it to force the file type
27 * and provide memory allocation as well as file operation callbacks.
28 * Should be zero-initialized to trigger default behavior.
29 *
30 * `cgltf_data` is the struct allocated and filled by `cgltf_parse()`.
31 * It generally mirrors the glTF format as described by the spec (see
32 * https://github.com/KhronosGroup/glTF/tree/master/specification/2.0).
33 *
34 * `void cgltf_free(cgltf_data*)` frees the allocated `cgltf_data`
35 * variable.
36 *
37 * `cgltf_result cgltf_load_buffers(const cgltf_options*, cgltf_data*,
38 * const char* gltf_path)` can be optionally called to open and read buffer
39 * files using the `FILE*` APIs. The `gltf_path` argument is the path to
40 * the original glTF file, which allows the parser to resolve the path to
41 * buffer files.
42 *
43 * `cgltf_result cgltf_load_buffer_base64(const cgltf_options* options,
44 * cgltf_size size, const char* base64, void** out_data)` decodes
45 * base64-encoded data content. Used internally by `cgltf_load_buffers()`.
46 * This is useful when decoding data URIs in images.
47 *
48 * `cgltf_result cgltf_parse_file(const cgltf_options* options, const
49 * char* path, cgltf_data** out_data)` can be used to open the given
50 * file using `FILE*` APIs and parse the data using `cgltf_parse()`.
51 *
52 * `cgltf_result cgltf_validate(cgltf_data*)` can be used to do additional
53 * checks to make sure the parsed glTF data is valid.
54 *
55 * `cgltf_node_transform_local` converts the translation / rotation / scale properties of a node
56 * into a mat4.
57 *
58 * `cgltf_node_transform_world` calls `cgltf_node_transform_local` on every ancestor in order
59 * to compute the root-to-node transformation.
60 *
61 * `cgltf_accessor_unpack_floats` reads in the data from an accessor, applies sparse data (if any),
62 * and converts them to floating point. Assumes that `cgltf_load_buffers` has already been called.
63 * By passing null for the output pointer, users can find out how many floats are required in the
64 * output buffer.
65 *
66 * `cgltf_accessor_num_components` is a tiny utility that tells you the dimensionality of
67 * a certain accessor type. This can be used before `cgltf_accessor_unpack_floats` to help allocate
68 * the necessary amount of memory.
69 *
70 * `cgltf_accessor_read_float` reads a certain element from a non-sparse accessor and converts it to
71 * floating point, assuming that `cgltf_load_buffers` has already been called. The passed-in element
72 * size is the number of floats in the output buffer, which should be in the range [1, 16]. Returns
73 * false if the passed-in element_size is too small, or if the accessor is sparse.
74 *
75 * `cgltf_accessor_read_uint` is similar to its floating-point counterpart, but limited to reading
76 * vector types and does not support matrix types. The passed-in element size is the number of uints
77 * in the output buffer, which should be in the range [1, 4]. Returns false if the passed-in
78 * element_size is too small, or if the accessor is sparse.
79 *
80 * `cgltf_accessor_read_index` is similar to its floating-point counterpart, but it returns size_t
81 * and only works with single-component data types.
82 *
83 * `cgltf_result cgltf_copy_extras_json(const cgltf_data*, const cgltf_extras*,
84 * char* dest, cgltf_size* dest_size)` allows users to retrieve the "extras" data that
85 * can be attached to many glTF objects (which can be arbitrary JSON data). The
86 * `cgltf_extras` struct stores the offsets of the start and end of the extras JSON data
87 * as it appears in the complete glTF JSON data. This function copies the extras data
88 * into the provided buffer. If `dest` is NULL, the length of the data is written into
89 * `dest_size`. You can then parse this data using your own JSON parser
90 * or, if you've included the cgltf implementation using the integrated JSMN JSON parser.
91 */
92 #ifndef CGLTF_H_INCLUDED__
93 #define CGLTF_H_INCLUDED__
94
95 #include <stddef.h>
96
97 #ifdef __cplusplus
98 extern "C" {
99 #endif
100
101 typedef size_t cgltf_size;
102 typedef float cgltf_float;
103 typedef int cgltf_int;
104 typedef unsigned int cgltf_uint;
105 typedef int cgltf_bool;
106
107 typedef enum cgltf_file_type
108 {
109 cgltf_file_type_invalid,
110 cgltf_file_type_gltf,
111 cgltf_file_type_glb,
112 } cgltf_file_type;
113
114 typedef enum cgltf_result
115 {
116 cgltf_result_success,
117 cgltf_result_data_too_short,
118 cgltf_result_unknown_format,
119 cgltf_result_invalid_json,
120 cgltf_result_invalid_gltf,
121 cgltf_result_invalid_options,
122 cgltf_result_file_not_found,
123 cgltf_result_io_error,
124 cgltf_result_out_of_memory,
125 cgltf_result_legacy_gltf,
126 } cgltf_result;
127
128 typedef struct cgltf_memory_options
129 {
130 void* (*alloc)(void* user, cgltf_size size);
131 void (*free) (void* user, void* ptr);
132 void* user_data;
133 } cgltf_memory_options;
134
135 typedef struct cgltf_file_options
136 {
137 cgltf_result(*read)(const struct cgltf_memory_options* memory_options, const struct cgltf_file_options* file_options, const char* path, cgltf_size* size, void** data);
138 void (*release)(const struct cgltf_memory_options* memory_options, const struct cgltf_file_options* file_options, void* data);
139 void* user_data;
140 } cgltf_file_options;
141
142 typedef struct cgltf_options
143 {
144 cgltf_file_type type; /* invalid == auto detect */
145 cgltf_size json_token_count; /* 0 == auto */
146 cgltf_memory_options memory;
147 cgltf_file_options file;
148 } cgltf_options;
149
150 typedef enum cgltf_buffer_view_type
151 {
152 cgltf_buffer_view_type_invalid,
153 cgltf_buffer_view_type_indices,
154 cgltf_buffer_view_type_vertices,
155 } cgltf_buffer_view_type;
156
157 typedef enum cgltf_attribute_type
158 {
159 cgltf_attribute_type_invalid,
160 cgltf_attribute_type_position,
161 cgltf_attribute_type_normal,
162 cgltf_attribute_type_tangent,
163 cgltf_attribute_type_texcoord,
164 cgltf_attribute_type_color,
165 cgltf_attribute_type_joints,
166 cgltf_attribute_type_weights,
167 } cgltf_attribute_type;
168
169 typedef enum cgltf_component_type
170 {
171 cgltf_component_type_invalid,
172 cgltf_component_type_r_8, /* BYTE */
173 cgltf_component_type_r_8u, /* UNSIGNED_BYTE */
174 cgltf_component_type_r_16, /* SHORT */
175 cgltf_component_type_r_16u, /* UNSIGNED_SHORT */
176 cgltf_component_type_r_32u, /* UNSIGNED_INT */
177 cgltf_component_type_r_32f, /* FLOAT */
178 } cgltf_component_type;
179
180 typedef enum cgltf_type
181 {
182 cgltf_type_invalid,
183 cgltf_type_scalar,
184 cgltf_type_vec2,
185 cgltf_type_vec3,
186 cgltf_type_vec4,
187 cgltf_type_mat2,
188 cgltf_type_mat3,
189 cgltf_type_mat4,
190 } cgltf_type;
191
192 typedef enum cgltf_primitive_type
193 {
194 cgltf_primitive_type_points,
195 cgltf_primitive_type_lines,
196 cgltf_primitive_type_line_loop,
197 cgltf_primitive_type_line_strip,
198 cgltf_primitive_type_triangles,
199 cgltf_primitive_type_triangle_strip,
200 cgltf_primitive_type_triangle_fan,
201 } cgltf_primitive_type;
202
203 typedef enum cgltf_alpha_mode
204 {
205 cgltf_alpha_mode_opaque,
206 cgltf_alpha_mode_mask,
207 cgltf_alpha_mode_blend,
208 } cgltf_alpha_mode;
209
210 typedef enum cgltf_animation_path_type {
211 cgltf_animation_path_type_invalid,
212 cgltf_animation_path_type_translation,
213 cgltf_animation_path_type_rotation,
214 cgltf_animation_path_type_scale,
215 cgltf_animation_path_type_weights,
216 } cgltf_animation_path_type;
217
218 typedef enum cgltf_interpolation_type {
219 cgltf_interpolation_type_linear,
220 cgltf_interpolation_type_step,
221 cgltf_interpolation_type_cubic_spline,
222 } cgltf_interpolation_type;
223
224 typedef enum cgltf_camera_type {
225 cgltf_camera_type_invalid,
226 cgltf_camera_type_perspective,
227 cgltf_camera_type_orthographic,
228 } cgltf_camera_type;
229
230 typedef enum cgltf_light_type {
231 cgltf_light_type_invalid,
232 cgltf_light_type_directional,
233 cgltf_light_type_point,
234 cgltf_light_type_spot,
235 } cgltf_light_type;
236
237 typedef struct cgltf_extras {
238 cgltf_size start_offset;
239 cgltf_size end_offset;
240 } cgltf_extras;
241
242 typedef struct cgltf_extension {
243 char* name;
244 char* data;
245 } cgltf_extension;
246
247 typedef struct cgltf_buffer
248 {
249 char* name;
250 cgltf_size size;
251 char* uri;
252 void* data; /* loaded by cgltf_load_buffers */
253 cgltf_extras extras;
254 cgltf_size extensions_count;
255 cgltf_extension* extensions;
256 } cgltf_buffer;
257
258 typedef enum cgltf_meshopt_compression_mode {
259 cgltf_meshopt_compression_mode_invalid,
260 cgltf_meshopt_compression_mode_attributes,
261 cgltf_meshopt_compression_mode_triangles,
262 cgltf_meshopt_compression_mode_indices,
263 } cgltf_meshopt_compression_mode;
264
265 typedef enum cgltf_meshopt_compression_filter {
266 cgltf_meshopt_compression_filter_none,
267 cgltf_meshopt_compression_filter_octahedral,
268 cgltf_meshopt_compression_filter_quaternion,
269 cgltf_meshopt_compression_filter_exponential,
270 } cgltf_meshopt_compression_filter;
271
272 typedef struct cgltf_meshopt_compression
273 {
274 cgltf_buffer* buffer;
275 cgltf_size offset;
276 cgltf_size size;
277 cgltf_size stride;
278 cgltf_size count;
279 cgltf_meshopt_compression_mode mode;
280 cgltf_meshopt_compression_filter filter;
281 } cgltf_meshopt_compression;
282
283 typedef struct cgltf_buffer_view
284 {
285 char *name;
286 cgltf_buffer* buffer;
287 cgltf_size offset;
288 cgltf_size size;
289 cgltf_size stride; /* 0 == automatically determined by accessor */
290 cgltf_buffer_view_type type;
291 void* data; /* overrides buffer->data if present, filled by extensions */
292 cgltf_bool has_meshopt_compression;
293 cgltf_meshopt_compression meshopt_compression;
294 cgltf_extras extras;
295 cgltf_size extensions_count;
296 cgltf_extension* extensions;
297 } cgltf_buffer_view;
298
299 typedef struct cgltf_accessor_sparse
300 {
301 cgltf_size count;
302 cgltf_buffer_view* indices_buffer_view;
303 cgltf_size indices_byte_offset;
304 cgltf_component_type indices_component_type;
305 cgltf_buffer_view* values_buffer_view;
306 cgltf_size values_byte_offset;
307 cgltf_extras extras;
308 cgltf_extras indices_extras;
309 cgltf_extras values_extras;
310 cgltf_size extensions_count;
311 cgltf_extension* extensions;
312 cgltf_size indices_extensions_count;
313 cgltf_extension* indices_extensions;
314 cgltf_size values_extensions_count;
315 cgltf_extension* values_extensions;
316 } cgltf_accessor_sparse;
317
318 typedef struct cgltf_accessor
319 {
320 char* name;
321 cgltf_component_type component_type;
322 cgltf_bool normalized;
323 cgltf_type type;
324 cgltf_size offset;
325 cgltf_size count;
326 cgltf_size stride;
327 cgltf_buffer_view* buffer_view;
328 cgltf_bool has_min;
329 cgltf_float min[16];
330 cgltf_bool has_max;
331 cgltf_float max[16];
332 cgltf_bool is_sparse;
333 cgltf_accessor_sparse sparse;
334 cgltf_extras extras;
335 cgltf_size extensions_count;
336 cgltf_extension* extensions;
337 } cgltf_accessor;
338
339 typedef struct cgltf_attribute
340 {
341 char* name;
342 cgltf_attribute_type type;
343 cgltf_int index;
344 cgltf_accessor* data;
345 } cgltf_attribute;
346
347 typedef struct cgltf_image
348 {
349 char* name;
350 char* uri;
351 cgltf_buffer_view* buffer_view;
352 char* mime_type;
353 cgltf_extras extras;
354 cgltf_size extensions_count;
355 cgltf_extension* extensions;
356 } cgltf_image;
357
358 typedef struct cgltf_sampler
359 {
360 char* name;
361 cgltf_int mag_filter;
362 cgltf_int min_filter;
363 cgltf_int wrap_s;
364 cgltf_int wrap_t;
365 cgltf_extras extras;
366 cgltf_size extensions_count;
367 cgltf_extension* extensions;
368 } cgltf_sampler;
369
370 typedef struct cgltf_texture
371 {
372 char* name;
373 cgltf_image* image;
374 cgltf_sampler* sampler;
375 cgltf_extras extras;
376 cgltf_size extensions_count;
377 cgltf_extension* extensions;
378 } cgltf_texture;
379
380 typedef struct cgltf_texture_transform
381 {
382 cgltf_float offset[2];
383 cgltf_float rotation;
384 cgltf_float scale[2];
385 cgltf_int texcoord;
386 } cgltf_texture_transform;
387
388 typedef struct cgltf_texture_view
389 {
390 cgltf_texture* texture;
391 cgltf_int texcoord;
392 cgltf_float scale; /* equivalent to strength for occlusion_texture */
393 cgltf_bool has_transform;
394 cgltf_texture_transform transform;
395 cgltf_extras extras;
396 cgltf_size extensions_count;
397 cgltf_extension* extensions;
398 } cgltf_texture_view;
399
400 typedef struct cgltf_pbr_metallic_roughness
401 {
402 cgltf_texture_view base_color_texture;
403 cgltf_texture_view metallic_roughness_texture;
404
405 cgltf_float base_color_factor[4];
406 cgltf_float metallic_factor;
407 cgltf_float roughness_factor;
408
409 cgltf_extras extras;
410 } cgltf_pbr_metallic_roughness;
411
412 typedef struct cgltf_pbr_specular_glossiness
413 {
414 cgltf_texture_view diffuse_texture;
415 cgltf_texture_view specular_glossiness_texture;
416
417 cgltf_float diffuse_factor[4];
418 cgltf_float specular_factor[3];
419 cgltf_float glossiness_factor;
420 } cgltf_pbr_specular_glossiness;
421
422 typedef struct cgltf_clearcoat
423 {
424 cgltf_texture_view clearcoat_texture;
425 cgltf_texture_view clearcoat_roughness_texture;
426 cgltf_texture_view clearcoat_normal_texture;
427
428 cgltf_float clearcoat_factor;
429 cgltf_float clearcoat_roughness_factor;
430 } cgltf_clearcoat;
431
432 typedef struct cgltf_transmission
433 {
434 cgltf_texture_view transmission_texture;
435 cgltf_float transmission_factor;
436 } cgltf_transmission;
437
438 typedef struct cgltf_ior
439 {
440 cgltf_float ior;
441 } cgltf_ior;
442
443 typedef struct cgltf_specular
444 {
445 cgltf_texture_view specular_texture;
446 cgltf_texture_view specular_color_texture;
447 cgltf_float specular_color_factor[3];
448 cgltf_float specular_factor;
449 } cgltf_specular;
450
451 typedef struct cgltf_volume
452 {
453 cgltf_texture_view thickness_texture;
454 cgltf_float thickness_factor;
455 cgltf_float attenuation_color[3];
456 cgltf_float attenuation_distance;
457 } cgltf_volume;
458
459 typedef struct cgltf_sheen
460 {
461 cgltf_texture_view sheen_color_texture;
462 cgltf_float sheen_color_factor[3];
463 cgltf_texture_view sheen_roughness_texture;
464 cgltf_float sheen_roughness_factor;
465 } cgltf_sheen;
466
467 typedef struct cgltf_material
468 {
469 char* name;
470 cgltf_bool has_pbr_metallic_roughness;
471 cgltf_bool has_pbr_specular_glossiness;
472 cgltf_bool has_clearcoat;
473 cgltf_bool has_transmission;
474 cgltf_bool has_volume;
475 cgltf_bool has_ior;
476 cgltf_bool has_specular;
477 cgltf_bool has_sheen;
478 cgltf_pbr_metallic_roughness pbr_metallic_roughness;
479 cgltf_pbr_specular_glossiness pbr_specular_glossiness;
480 cgltf_clearcoat clearcoat;
481 cgltf_ior ior;
482 cgltf_specular specular;
483 cgltf_sheen sheen;
484 cgltf_transmission transmission;
485 cgltf_volume volume;
486 cgltf_texture_view normal_texture;
487 cgltf_texture_view occlusion_texture;
488 cgltf_texture_view emissive_texture;
489 cgltf_float emissive_factor[3];
490 cgltf_alpha_mode alpha_mode;
491 cgltf_float alpha_cutoff;
492 cgltf_bool double_sided;
493 cgltf_bool unlit;
494 cgltf_extras extras;
495 cgltf_size extensions_count;
496 cgltf_extension* extensions;
497 } cgltf_material;
498
499 typedef struct cgltf_material_mapping
500 {
501 cgltf_size variant;
502 cgltf_material* material;
503 cgltf_extras extras;
504 } cgltf_material_mapping;
505
506 typedef struct cgltf_morph_target {
507 cgltf_attribute* attributes;
508 cgltf_size attributes_count;
509 } cgltf_morph_target;
510
511 typedef struct cgltf_draco_mesh_compression {
512 cgltf_buffer_view* buffer_view;
513 cgltf_attribute* attributes;
514 cgltf_size attributes_count;
515 } cgltf_draco_mesh_compression;
516
517 typedef struct cgltf_primitive {
518 cgltf_primitive_type type;
519 cgltf_accessor* indices;
520 cgltf_material* material;
521 cgltf_attribute* attributes;
522 cgltf_size attributes_count;
523 cgltf_morph_target* targets;
524 cgltf_size targets_count;
525 cgltf_extras extras;
526 cgltf_bool has_draco_mesh_compression;
527 cgltf_draco_mesh_compression draco_mesh_compression;
528 cgltf_material_mapping* mappings;
529 cgltf_size mappings_count;
530 cgltf_size extensions_count;
531 cgltf_extension* extensions;
532 } cgltf_primitive;
533
534 typedef struct cgltf_mesh {
535 char* name;
536 cgltf_primitive* primitives;
537 cgltf_size primitives_count;
538 cgltf_float* weights;
539 cgltf_size weights_count;
540 char** target_names;
541 cgltf_size target_names_count;
542 cgltf_extras extras;
543 cgltf_size extensions_count;
544 cgltf_extension* extensions;
545 } cgltf_mesh;
546
547 typedef struct cgltf_node cgltf_node;
548
549 typedef struct cgltf_skin {
550 char* name;
551 cgltf_node** joints;
552 cgltf_size joints_count;
553 cgltf_node* skeleton;
554 cgltf_accessor* inverse_bind_matrices;
555 cgltf_extras extras;
556 cgltf_size extensions_count;
557 cgltf_extension* extensions;
558 } cgltf_skin;
559
560 typedef struct cgltf_camera_perspective {
561 cgltf_bool has_aspect_ratio;
562 cgltf_float aspect_ratio;
563 cgltf_float yfov;
564 cgltf_bool has_zfar;
565 cgltf_float zfar;
566 cgltf_float znear;
567 cgltf_extras extras;
568 } cgltf_camera_perspective;
569
570 typedef struct cgltf_camera_orthographic {
571 cgltf_float xmag;
572 cgltf_float ymag;
573 cgltf_float zfar;
574 cgltf_float znear;
575 cgltf_extras extras;
576 } cgltf_camera_orthographic;
577
578 typedef struct cgltf_camera {
579 char* name;
580 cgltf_camera_type type;
581 union {
582 cgltf_camera_perspective perspective;
583 cgltf_camera_orthographic orthographic;
584 } data;
585 cgltf_extras extras;
586 cgltf_size extensions_count;
587 cgltf_extension* extensions;
588 } cgltf_camera;
589
590 typedef struct cgltf_light {
591 char* name;
592 cgltf_float color[3];
593 cgltf_float intensity;
594 cgltf_light_type type;
595 cgltf_float range;
596 cgltf_float spot_inner_cone_angle;
597 cgltf_float spot_outer_cone_angle;
598 } cgltf_light;
599
600 struct cgltf_node {
601 char* name;
602 cgltf_node* parent;
603 cgltf_node** children;
604 cgltf_size children_count;
605 cgltf_skin* skin;
606 cgltf_mesh* mesh;
607 cgltf_camera* camera;
608 cgltf_light* light;
609 cgltf_float* weights;
610 cgltf_size weights_count;
611 cgltf_bool has_translation;
612 cgltf_bool has_rotation;
613 cgltf_bool has_scale;
614 cgltf_bool has_matrix;
615 cgltf_float translation[3];
616 cgltf_float rotation[4];
617 cgltf_float scale[3];
618 cgltf_float matrix[16];
619 cgltf_extras extras;
620 cgltf_size extensions_count;
621 cgltf_extension* extensions;
622 };
623
624 typedef struct cgltf_scene {
625 char* name;
626 cgltf_node** nodes;
627 cgltf_size nodes_count;
628 cgltf_extras extras;
629 cgltf_size extensions_count;
630 cgltf_extension* extensions;
631 } cgltf_scene;
632
633 typedef struct cgltf_animation_sampler {
634 cgltf_accessor* input;
635 cgltf_accessor* output;
636 cgltf_interpolation_type interpolation;
637 cgltf_extras extras;
638 cgltf_size extensions_count;
639 cgltf_extension* extensions;
640 } cgltf_animation_sampler;
641
642 typedef struct cgltf_animation_channel {
643 cgltf_animation_sampler* sampler;
644 cgltf_node* target_node;
645 cgltf_animation_path_type target_path;
646 cgltf_extras extras;
647 cgltf_size extensions_count;
648 cgltf_extension* extensions;
649 } cgltf_animation_channel;
650
651 typedef struct cgltf_animation {
652 char* name;
653 cgltf_animation_sampler* samplers;
654 cgltf_size samplers_count;
655 cgltf_animation_channel* channels;
656 cgltf_size channels_count;
657 cgltf_extras extras;
658 cgltf_size extensions_count;
659 cgltf_extension* extensions;
660 } cgltf_animation;
661
662 typedef struct cgltf_material_variant
663 {
664 char* name;
665 cgltf_extras extras;
666 } cgltf_material_variant;
667
668 typedef struct cgltf_asset {
669 char* copyright;
670 char* generator;
671 char* version;
672 char* min_version;
673 cgltf_extras extras;
674 cgltf_size extensions_count;
675 cgltf_extension* extensions;
676 } cgltf_asset;
677
678 typedef struct cgltf_data
679 {
680 cgltf_file_type file_type;
681 void* file_data;
682
683 cgltf_asset asset;
684
685 cgltf_mesh* meshes;
686 cgltf_size meshes_count;
687
688 cgltf_material* materials;
689 cgltf_size materials_count;
690
691 cgltf_accessor* accessors;
692 cgltf_size accessors_count;
693
694 cgltf_buffer_view* buffer_views;
695 cgltf_size buffer_views_count;
696
697 cgltf_buffer* buffers;
698 cgltf_size buffers_count;
699
700 cgltf_image* images;
701 cgltf_size images_count;
702
703 cgltf_texture* textures;
704 cgltf_size textures_count;
705
706 cgltf_sampler* samplers;
707 cgltf_size samplers_count;
708
709 cgltf_skin* skins;
710 cgltf_size skins_count;
711
712 cgltf_camera* cameras;
713 cgltf_size cameras_count;
714
715 cgltf_light* lights;
716 cgltf_size lights_count;
717
718 cgltf_node* nodes;
719 cgltf_size nodes_count;
720
721 cgltf_scene* scenes;
722 cgltf_size scenes_count;
723
724 cgltf_scene* scene;
725
726 cgltf_animation* animations;
727 cgltf_size animations_count;
728
729 cgltf_material_variant* variants;
730 cgltf_size variants_count;
731
732 cgltf_extras extras;
733
734 cgltf_size data_extensions_count;
735 cgltf_extension* data_extensions;
736
737 char** extensions_used;
738 cgltf_size extensions_used_count;
739
740 char** extensions_required;
741 cgltf_size extensions_required_count;
742
743 const char* json;
744 cgltf_size json_size;
745
746 const void* bin;
747 cgltf_size bin_size;
748
749 cgltf_memory_options memory;
750 cgltf_file_options file;
751 } cgltf_data;
752
753 cgltf_result cgltf_parse(
754 const cgltf_options* options,
755 const void* data,
756 cgltf_size size,
757 cgltf_data** out_data);
758
759 cgltf_result cgltf_parse_file(
760 const cgltf_options* options,
761 const char* path,
762 cgltf_data** out_data);
763
764 cgltf_result cgltf_load_buffers(
765 const cgltf_options* options,
766 cgltf_data* data,
767 const char* gltf_path);
768
769 cgltf_result cgltf_load_buffer_base64(const cgltf_options* options, cgltf_size size, const char* base64, void** out_data);
770
771 void cgltf_decode_uri(char* uri);
772
773 cgltf_result cgltf_validate(cgltf_data* data);
774
775 void cgltf_free(cgltf_data* data);
776
777 void cgltf_node_transform_local(const cgltf_node* node, cgltf_float* out_matrix);
778 void cgltf_node_transform_world(const cgltf_node* node, cgltf_float* out_matrix);
779
780 cgltf_bool cgltf_accessor_read_float(const cgltf_accessor* accessor, cgltf_size index, cgltf_float* out, cgltf_size element_size);
781 cgltf_bool cgltf_accessor_read_uint(const cgltf_accessor* accessor, cgltf_size index, cgltf_uint* out, cgltf_size element_size);
782 cgltf_size cgltf_accessor_read_index(const cgltf_accessor* accessor, cgltf_size index);
783
784 cgltf_size cgltf_num_components(cgltf_type type);
785
786 cgltf_size cgltf_accessor_unpack_floats(const cgltf_accessor* accessor, cgltf_float* out, cgltf_size float_count);
787
788 cgltf_result cgltf_copy_extras_json(const cgltf_data* data, const cgltf_extras* extras, char* dest, cgltf_size* dest_size);
789
790 #ifdef __cplusplus
791 }
792 #endif
793
794 #endif /* #ifndef CGLTF_H_INCLUDED__ */
795
796 /*
797 *
798 * Stop now, if you are only interested in the API.
799 * Below, you find the implementation.
800 *
801 */
802
803 #if defined(__INTELLISENSE__) || defined(__JETBRAINS_IDE__)
804 /* This makes MSVC/CLion intellisense work. */
805 #define CGLTF_IMPLEMENTATION
806 #endif
807
808 #ifdef CGLTF_IMPLEMENTATION
809
810 #include <stdint.h> /* For uint8_t, uint32_t */
811 #include <string.h> /* For strncpy */
812 #include <stdio.h> /* For fopen */
813 #include <limits.h> /* For UINT_MAX etc */
814 #include <float.h> /* For FLT_MAX */
815
816 #if !defined(CGLTF_MALLOC) || !defined(CGLTF_FREE) || !defined(CGLTF_ATOI) || !defined(CGLTF_ATOF)
817 #include <stdlib.h> /* For malloc, free, atoi, atof */
818 #endif
819
820 /* JSMN_PARENT_LINKS is necessary to make parsing large structures linear in input size */
821 #define JSMN_PARENT_LINKS
822
823 /* JSMN_STRICT is necessary to reject invalid JSON documents */
824 #define JSMN_STRICT
825
826 /*
827 * -- jsmn.h start --
828 * Source: https://github.com/zserge/jsmn
829 * License: MIT
830 */
831 typedef enum {
832 JSMN_UNDEFINED = 0,
833 JSMN_OBJECT = 1,
834 JSMN_ARRAY = 2,
835 JSMN_STRING = 3,
836 JSMN_PRIMITIVE = 4
837 } jsmntype_t;
838 enum jsmnerr {
839 /* Not enough tokens were provided */
840 JSMN_ERROR_NOMEM = -1,
841 /* Invalid character inside JSON string */
842 JSMN_ERROR_INVAL = -2,
843 /* The string is not a full JSON packet, more bytes expected */
844 JSMN_ERROR_PART = -3
845 };
846 typedef struct {
847 jsmntype_t type;
848 int start;
849 int end;
850 int size;
851 #ifdef JSMN_PARENT_LINKS
852 int parent;
853 #endif
854 } jsmntok_t;
855 typedef struct {
856 unsigned int pos; /* offset in the JSON string */
857 unsigned int toknext; /* next token to allocate */
858 int toksuper; /* superior token node, e.g parent object or array */
859 } jsmn_parser;
860 static void jsmn_init(jsmn_parser *parser);
861 static int jsmn_parse(jsmn_parser *parser, const char *js, size_t len, jsmntok_t *tokens, size_t num_tokens);
862 /*
863 * -- jsmn.h end --
864 */
865
866
867 static const cgltf_size GlbHeaderSize = 12;
868 static const cgltf_size GlbChunkHeaderSize = 8;
869 static const uint32_t GlbVersion = 2;
870 static const uint32_t GlbMagic = 0x46546C67;
871 static const uint32_t GlbMagicJsonChunk = 0x4E4F534A;
872 static const uint32_t GlbMagicBinChunk = 0x004E4942;
873
874 #ifndef CGLTF_MALLOC
875 #define CGLTF_MALLOC(size) malloc(size)
876 #endif
877 #ifndef CGLTF_FREE
878 #define CGLTF_FREE(ptr) free(ptr)
879 #endif
880 #ifndef CGLTF_ATOI
881 #define CGLTF_ATOI(str) atoi(str)
882 #endif
883 #ifndef CGLTF_ATOF
884 #define CGLTF_ATOF(str) atof(str)
885 #endif
886 #ifndef CGLTF_VALIDATE_ENABLE_ASSERTS
887 #define CGLTF_VALIDATE_ENABLE_ASSERTS 0
888 #endif
889
890 static void* cgltf_default_alloc(void* user, cgltf_size size)
891 {
892 (void)user;
893 return CGLTF_MALLOC(size);
894 }
895
896 static void cgltf_default_free(void* user, void* ptr)
897 {
898 (void)user;
899 CGLTF_FREE(ptr);
900 }
901
902 static void* cgltf_calloc(cgltf_options* options, size_t element_size, cgltf_size count)
903 {
904 if (SIZE_MAX / element_size < count)
905 {
906 return NULL;
907 }
908 void* result = options->memory.alloc(options->memory.user_data, element_size * count);
909 if (!result)
910 {
911 return NULL;
912 }
913 memset(result, 0, element_size * count);
914 return result;
915 }
916
917 static cgltf_result cgltf_default_file_read(const struct cgltf_memory_options* memory_options, const struct cgltf_file_options* file_options, const char* path, cgltf_size* size, void** data)
918 {
919 (void)file_options;
920 void* (*memory_alloc)(void*, cgltf_size) = memory_options->alloc ? memory_options->alloc : &cgltf_default_alloc;
921 void (*memory_free)(void*, void*) = memory_options->free ? memory_options->free : &cgltf_default_free;
922
923 FILE* file = fopen(path, "rb");
924 if (!file)
925 {
926 return cgltf_result_file_not_found;
927 }
928
929 cgltf_size file_size = size ? *size : 0;
930
931 if (file_size == 0)
932 {
933 fseek(file, 0, SEEK_END);
934
935 long length = ftell(file);
936 if (length < 0)
937 {
938 fclose(file);
939 return cgltf_result_io_error;
940 }
941
942 fseek(file, 0, SEEK_SET);
943 file_size = (cgltf_size)length;
944 }
945
946 char* file_data = (char*)memory_alloc(memory_options->user_data, file_size);
947 if (!file_data)
948 {
949 fclose(file);
950 return cgltf_result_out_of_memory;
951 }
952
953 cgltf_size read_size = fread(file_data, 1, file_size, file);
954
955 fclose(file);
956
957 if (read_size != file_size)
958 {
959 memory_free(memory_options->user_data, file_data);
960 return cgltf_result_io_error;
961 }
962
963 if (size)
964 {
965 *size = file_size;
966 }
967 if (data)
968 {
969 *data = file_data;
970 }
971
972 return cgltf_result_success;
973 }
974
975 static void cgltf_default_file_release(const struct cgltf_memory_options* memory_options, const struct cgltf_file_options* file_options, void* data)
976 {
977 (void)file_options;
978 void (*memfree)(void*, void*) = memory_options->free ? memory_options->free : &cgltf_default_free;
979 memfree(memory_options->user_data, data);
980 }
981
982 static cgltf_result cgltf_parse_json(cgltf_options* options, const uint8_t* json_chunk, cgltf_size size, cgltf_data** out_data);
983
984 cgltf_result cgltf_parse(const cgltf_options* options, const void* data, cgltf_size size, cgltf_data** out_data)
985 {
986 if (size < GlbHeaderSize)
987 {
988 return cgltf_result_data_too_short;
989 }
990
991 if (options == NULL)
992 {
993 return cgltf_result_invalid_options;
994 }
995
996 cgltf_options fixed_options = *options;
997 if (fixed_options.memory.alloc == NULL)
998 {
999 fixed_options.memory.alloc = &cgltf_default_alloc;
1000 }
1001 if (fixed_options.memory.free == NULL)
1002 {
1003 fixed_options.memory.free = &cgltf_default_free;
1004 }
1005
1006 uint32_t tmp;
1007 // Magic
1008 memcpy(&tmp, data, 4);
1009 if (tmp != GlbMagic)
1010 {
1011 if (fixed_options.type == cgltf_file_type_invalid)
1012 {
1013 fixed_options.type = cgltf_file_type_gltf;
1014 }
1015 else if (fixed_options.type == cgltf_file_type_glb)
1016 {
1017 return cgltf_result_unknown_format;
1018 }
1019 }
1020
1021 if (fixed_options.type == cgltf_file_type_gltf)
1022 {
1023 cgltf_result json_result = cgltf_parse_json(&fixed_options, (const uint8_t*)data, size, out_data);
1024 if (json_result != cgltf_result_success)
1025 {
1026 return json_result;
1027 }
1028
1029 (*out_data)->file_type = cgltf_file_type_gltf;
1030
1031 return cgltf_result_success;
1032 }
1033
1034 const uint8_t* ptr = (const uint8_t*)data;
1035 // Version
1036 memcpy(&tmp, ptr + 4, 4);
1037 uint32_t version = tmp;
1038 if (version != GlbVersion)
1039 {
1040 return version < GlbVersion ? cgltf_result_legacy_gltf : cgltf_result_unknown_format;
1041 }
1042
1043 // Total length
1044 memcpy(&tmp, ptr + 8, 4);
1045 if (tmp > size)
1046 {
1047 return cgltf_result_data_too_short;
1048 }
1049
1050 const uint8_t* json_chunk = ptr + GlbHeaderSize;
1051
1052 if (GlbHeaderSize + GlbChunkHeaderSize > size)
1053 {
1054 return cgltf_result_data_too_short;
1055 }
1056
1057 // JSON chunk: length
1058 uint32_t json_length;
1059 memcpy(&json_length, json_chunk, 4);
1060 if (GlbHeaderSize + GlbChunkHeaderSize + json_length > size)
1061 {
1062 return cgltf_result_data_too_short;
1063 }
1064
1065 // JSON chunk: magic
1066 memcpy(&tmp, json_chunk + 4, 4);
1067 if (tmp != GlbMagicJsonChunk)
1068 {
1069 return cgltf_result_unknown_format;
1070 }
1071
1072 json_chunk += GlbChunkHeaderSize;
1073
1074 const void* bin = 0;
1075 cgltf_size bin_size = 0;
1076
1077 if (GlbHeaderSize + GlbChunkHeaderSize + json_length + GlbChunkHeaderSize <= size)
1078 {
1079 // We can read another chunk
1080 const uint8_t* bin_chunk = json_chunk + json_length;
1081
1082 // Bin chunk: length
1083 uint32_t bin_length;
1084 memcpy(&bin_length, bin_chunk, 4);
1085 if (GlbHeaderSize + GlbChunkHeaderSize + json_length + GlbChunkHeaderSize + bin_length > size)
1086 {
1087 return cgltf_result_data_too_short;
1088 }
1089
1090 // Bin chunk: magic
1091 memcpy(&tmp, bin_chunk + 4, 4);
1092 if (tmp != GlbMagicBinChunk)
1093 {
1094 return cgltf_result_unknown_format;
1095 }
1096
1097 bin_chunk += GlbChunkHeaderSize;
1098
1099 bin = bin_chunk;
1100 bin_size = bin_length;
1101 }
1102
1103 cgltf_result json_result = cgltf_parse_json(&fixed_options, json_chunk, json_length, out_data);
1104 if (json_result != cgltf_result_success)
1105 {
1106 return json_result;
1107 }
1108
1109 (*out_data)->file_type = cgltf_file_type_glb;
1110 (*out_data)->bin = bin;
1111 (*out_data)->bin_size = bin_size;
1112
1113 return cgltf_result_success;
1114 }
1115
1116 cgltf_result cgltf_parse_file(const cgltf_options* options, const char* path, cgltf_data** out_data)
1117 {
1118 if (options == NULL)
1119 {
1120 return cgltf_result_invalid_options;
1121 }
1122
1123 void (*memory_free)(void*, void*) = options->memory.free ? options->memory.free : &cgltf_default_free;
1124 cgltf_result (*file_read)(const struct cgltf_memory_options*, const struct cgltf_file_options*, const char*, cgltf_size*, void**) = options->file.read ? options->file.read : &cgltf_default_file_read;
1125
1126 void* file_data = NULL;
1127 cgltf_size file_size = 0;
1128 cgltf_result result = file_read(&options->memory, &options->file, path, &file_size, &file_data);
1129 if (result != cgltf_result_success)
1130 {
1131 return result;
1132 }
1133
1134 result = cgltf_parse(options, file_data, file_size, out_data);
1135
1136 if (result != cgltf_result_success)
1137 {
1138 memory_free(options->memory.user_data, file_data);
1139 return result;
1140 }
1141
1142 (*out_data)->file_data = file_data;
1143
1144 return cgltf_result_success;
1145 }
1146
1147 static void cgltf_combine_paths(char* path, const char* base, const char* uri)
1148 {
1149 const char* s0 = strrchr(base, '/');
1150 const char* s1 = strrchr(base, '\\');
1151 const char* slash = s0 ? (s1 && s1 > s0 ? s1 : s0) : s1;
1152
1153 if (slash)
1154 {
1155 size_t prefix = slash - base + 1;
1156
1157 strncpy(path, base, prefix);
1158 strcpy(path + prefix, uri);
1159 }
1160 else
1161 {
1162 strcpy(path, uri);
1163 }
1164 }
1165
1166 static cgltf_result cgltf_load_buffer_file(const cgltf_options* options, cgltf_size size, const char* uri, const char* gltf_path, void** out_data)
1167 {
1168 void* (*memory_alloc)(void*, cgltf_size) = options->memory.alloc ? options->memory.alloc : &cgltf_default_alloc;
1169 void (*memory_free)(void*, void*) = options->memory.free ? options->memory.free : &cgltf_default_free;
1170 cgltf_result (*file_read)(const struct cgltf_memory_options*, const struct cgltf_file_options*, const char*, cgltf_size*, void**) = options->file.read ? options->file.read : &cgltf_default_file_read;
1171
1172 char* path = (char*)memory_alloc(options->memory.user_data, strlen(uri) + strlen(gltf_path) + 1);
1173 if (!path)
1174 {
1175 return cgltf_result_out_of_memory;
1176 }
1177
1178 cgltf_combine_paths(path, gltf_path, uri);
1179
1180 // after combining, the tail of the resulting path is a uri; decode_uri converts it into path
1181 cgltf_decode_uri(path + strlen(path) - strlen(uri));
1182
1183 void* file_data = NULL;
1184 cgltf_result result = file_read(&options->memory, &options->file, path, &size, &file_data);
1185
1186 memory_free(options->memory.user_data, path);
1187
1188 *out_data = (result == cgltf_result_success) ? file_data : NULL;
1189
1190 return result;
1191 }
1192
1193 cgltf_result cgltf_load_buffer_base64(const cgltf_options* options, cgltf_size size, const char* base64, void** out_data)
1194 {
1195 void* (*memory_alloc)(void*, cgltf_size) = options->memory.alloc ? options->memory.alloc : &cgltf_default_alloc;
1196 void (*memory_free)(void*, void*) = options->memory.free ? options->memory.free : &cgltf_default_free;
1197
1198 unsigned char* data = (unsigned char*)memory_alloc(options->memory.user_data, size);
1199 if (!data)
1200 {
1201 return cgltf_result_out_of_memory;
1202 }
1203
1204 unsigned int buffer = 0;
1205 unsigned int buffer_bits = 0;
1206
1207 for (cgltf_size i = 0; i < size; ++i)
1208 {
1209 while (buffer_bits < 8)
1210 {
1211 char ch = *base64++;
1212
1213 int index =
1214 (unsigned)(ch - 'A') < 26 ? (ch - 'A') :
1215 (unsigned)(ch - 'a') < 26 ? (ch - 'a') + 26 :
1216 (unsigned)(ch - '0') < 10 ? (ch - '0') + 52 :
1217 ch == '+' ? 62 :
1218 ch == '/' ? 63 :
1219 -1;
1220
1221 if (index < 0)
1222 {
1223 memory_free(options->memory.user_data, data);
1224 return cgltf_result_io_error;
1225 }
1226
1227 buffer = (buffer << 6) | index;
1228 buffer_bits += 6;
1229 }
1230
1231 data[i] = (unsigned char)(buffer >> (buffer_bits - 8));
1232 buffer_bits -= 8;
1233 }
1234
1235 *out_data = data;
1236
1237 return cgltf_result_success;
1238 }
1239
1240 static int cgltf_unhex(char ch)
1241 {
1242 return
1243 (unsigned)(ch - '0') < 10 ? (ch - '0') :
1244 (unsigned)(ch - 'A') < 6 ? (ch - 'A') + 10 :
1245 (unsigned)(ch - 'a') < 6 ? (ch - 'a') + 10 :
1246 -1;
1247 }
1248
1249 void cgltf_decode_uri(char* uri)
1250 {
1251 char* write = uri;
1252 char* i = uri;
1253
1254 while (*i)
1255 {
1256 if (*i == '%')
1257 {
1258 int ch1 = cgltf_unhex(i[1]);
1259
1260 if (ch1 >= 0)
1261 {
1262 int ch2 = cgltf_unhex(i[2]);
1263
1264 if (ch2 >= 0)
1265 {
1266 *write++ = (char)(ch1 * 16 + ch2);
1267 i += 3;
1268 continue;
1269 }
1270 }
1271 }
1272
1273 *write++ = *i++;
1274 }
1275
1276 *write = 0;
1277 }
1278
1279 cgltf_result cgltf_load_buffers(const cgltf_options* options, cgltf_data* data, const char* gltf_path)
1280 {
1281 if (options == NULL)
1282 {
1283 return cgltf_result_invalid_options;
1284 }
1285
1286 if (data->buffers_count && data->buffers[0].data == NULL && data->buffers[0].uri == NULL && data->bin)
1287 {
1288 if (data->bin_size < data->buffers[0].size)
1289 {
1290 return cgltf_result_data_too_short;
1291 }
1292
1293 data->buffers[0].data = (void*)data->bin;
1294 }
1295
1296 for (cgltf_size i = 0; i < data->buffers_count; ++i)
1297 {
1298 if (data->buffers[i].data)
1299 {
1300 continue;
1301 }
1302
1303 const char* uri = data->buffers[i].uri;
1304
1305 if (uri == NULL)
1306 {
1307 continue;
1308 }
1309
1310 if (strncmp(uri, "data:", 5) == 0)
1311 {
1312 const char* comma = strchr(uri, ',');
1313
1314 if (comma && comma - uri >= 7 && strncmp(comma - 7, ";base64", 7) == 0)
1315 {
1316 cgltf_result res = cgltf_load_buffer_base64(options, data->buffers[i].size, comma + 1, &data->buffers[i].data);
1317
1318 if (res != cgltf_result_success)
1319 {
1320 return res;
1321 }
1322 }
1323 else
1324 {
1325 return cgltf_result_unknown_format;
1326 }
1327 }
1328 else if (strstr(uri, "://") == NULL && gltf_path)
1329 {
1330 cgltf_result res = cgltf_load_buffer_file(options, data->buffers[i].size, uri, gltf_path, &data->buffers[i].data);
1331
1332 if (res != cgltf_result_success)
1333 {
1334 return res;
1335 }
1336 }
1337 else
1338 {
1339 return cgltf_result_unknown_format;
1340 }
1341 }
1342
1343 return cgltf_result_success;
1344 }
1345
1346 static cgltf_size cgltf_calc_size(cgltf_type type, cgltf_component_type component_type);
1347
1348 static cgltf_size cgltf_calc_index_bound(cgltf_buffer_view* buffer_view, cgltf_size offset, cgltf_component_type component_type, cgltf_size count)
1349 {
1350 char* data = (char*)buffer_view->buffer->data + offset + buffer_view->offset;
1351 cgltf_size bound = 0;
1352
1353 switch (component_type)
1354 {
1355 case cgltf_component_type_r_8u:
1356 for (size_t i = 0; i < count; ++i)
1357 {
1358 cgltf_size v = ((unsigned char*)data)[i];
1359 bound = bound > v ? bound : v;
1360 }
1361 break;
1362
1363 case cgltf_component_type_r_16u:
1364 for (size_t i = 0; i < count; ++i)
1365 {
1366 cgltf_size v = ((unsigned short*)data)[i];
1367 bound = bound > v ? bound : v;
1368 }
1369 break;
1370
1371 case cgltf_component_type_r_32u:
1372 for (size_t i = 0; i < count; ++i)
1373 {
1374 cgltf_size v = ((unsigned int*)data)[i];
1375 bound = bound > v ? bound : v;
1376 }
1377 break;
1378
1379 default:
1380 ;
1381 }
1382
1383 return bound;
1384 }
1385
1386 #if CGLTF_VALIDATE_ENABLE_ASSERTS
1387 #define CGLTF_ASSERT_IF(cond, result) assert(!(cond)); if (cond) return result;
1388 #else
1389 #define CGLTF_ASSERT_IF(cond, result) if (cond) return result;
1390 #endif
1391
1392 cgltf_result cgltf_validate(cgltf_data* data)
1393 {
1394 for (cgltf_size i = 0; i < data->accessors_count; ++i)
1395 {
1396 cgltf_accessor* accessor = &data->accessors[i];
1397
1398 cgltf_size element_size = cgltf_calc_size(accessor->type, accessor->component_type);
1399
1400 if (accessor->buffer_view)
1401 {
1402 cgltf_size req_size = accessor->offset + accessor->stride * (accessor->count - 1) + element_size;
1403
1404 CGLTF_ASSERT_IF(accessor->buffer_view->size < req_size, cgltf_result_data_too_short);
1405 }
1406
1407 if (accessor->is_sparse)
1408 {
1409 cgltf_accessor_sparse* sparse = &accessor->sparse;
1410
1411 cgltf_size indices_component_size = cgltf_calc_size(cgltf_type_scalar, sparse->indices_component_type);
1412 cgltf_size indices_req_size = sparse->indices_byte_offset + indices_component_size * sparse->count;
1413 cgltf_size values_req_size = sparse->values_byte_offset + element_size * sparse->count;
1414
1415 CGLTF_ASSERT_IF(sparse->indices_buffer_view->size < indices_req_size ||
1416 sparse->values_buffer_view->size < values_req_size, cgltf_result_data_too_short);
1417
1418 CGLTF_ASSERT_IF(sparse->indices_component_type != cgltf_component_type_r_8u &&
1419 sparse->indices_component_type != cgltf_component_type_r_16u &&
1420 sparse->indices_component_type != cgltf_component_type_r_32u, cgltf_result_invalid_gltf);
1421
1422 if (sparse->indices_buffer_view->buffer->data)
1423 {
1424 cgltf_size index_bound = cgltf_calc_index_bound(sparse->indices_buffer_view, sparse->indices_byte_offset, sparse->indices_component_type, sparse->count);
1425
1426 CGLTF_ASSERT_IF(index_bound >= accessor->count, cgltf_result_data_too_short);
1427 }
1428 }
1429 }
1430
1431 for (cgltf_size i = 0; i < data->buffer_views_count; ++i)
1432 {
1433 cgltf_size req_size = data->buffer_views[i].offset + data->buffer_views[i].size;
1434
1435 CGLTF_ASSERT_IF(data->buffer_views[i].buffer && data->buffer_views[i].buffer->size < req_size, cgltf_result_data_too_short);
1436
1437 if (data->buffer_views[i].has_meshopt_compression)
1438 {
1439 cgltf_meshopt_compression* mc = &data->buffer_views[i].meshopt_compression;
1440
1441 CGLTF_ASSERT_IF(mc->buffer == NULL || mc->buffer->size < mc->offset + mc->size, cgltf_result_data_too_short);
1442
1443 CGLTF_ASSERT_IF(data->buffer_views[i].stride && mc->stride != data->buffer_views[i].stride, cgltf_result_invalid_gltf);
1444
1445 CGLTF_ASSERT_IF(data->buffer_views[i].size != mc->stride * mc->count, cgltf_result_invalid_gltf);
1446
1447 CGLTF_ASSERT_IF(mc->mode == cgltf_meshopt_compression_mode_invalid, cgltf_result_invalid_gltf);
1448
1449 CGLTF_ASSERT_IF(mc->mode == cgltf_meshopt_compression_mode_attributes && !(mc->stride % 4 == 0 && mc->stride <= 256), cgltf_result_invalid_gltf);
1450
1451 CGLTF_ASSERT_IF(mc->mode == cgltf_meshopt_compression_mode_triangles && mc->count % 3 != 0, cgltf_result_invalid_gltf);
1452
1453 CGLTF_ASSERT_IF((mc->mode == cgltf_meshopt_compression_mode_triangles || mc->mode == cgltf_meshopt_compression_mode_indices) && mc->stride != 2 && mc->stride != 4, cgltf_result_invalid_gltf);
1454
1455 CGLTF_ASSERT_IF((mc->mode == cgltf_meshopt_compression_mode_triangles || mc->mode == cgltf_meshopt_compression_mode_indices) && mc->filter != cgltf_meshopt_compression_filter_none, cgltf_result_invalid_gltf);
1456
1457 CGLTF_ASSERT_IF(mc->filter == cgltf_meshopt_compression_filter_octahedral && mc->stride != 4 && mc->stride != 8, cgltf_result_invalid_gltf);
1458
1459 CGLTF_ASSERT_IF(mc->filter == cgltf_meshopt_compression_filter_quaternion && mc->stride != 8, cgltf_result_invalid_gltf);
1460 }
1461 }
1462
1463 for (cgltf_size i = 0; i < data->meshes_count; ++i)
1464 {
1465 if (data->meshes[i].weights)
1466 {
1467 CGLTF_ASSERT_IF(data->meshes[i].primitives_count && data->meshes[i].primitives[0].targets_count != data->meshes[i].weights_count, cgltf_result_invalid_gltf);
1468 }
1469
1470 if (data->meshes[i].target_names)
1471 {
1472 CGLTF_ASSERT_IF(data->meshes[i].primitives_count && data->meshes[i].primitives[0].targets_count != data->meshes[i].target_names_count, cgltf_result_invalid_gltf);
1473 }
1474
1475 for (cgltf_size j = 0; j < data->meshes[i].primitives_count; ++j)
1476 {
1477 CGLTF_ASSERT_IF(data->meshes[i].primitives[j].targets_count != data->meshes[i].primitives[0].targets_count, cgltf_result_invalid_gltf);
1478
1479 if (data->meshes[i].primitives[j].attributes_count)
1480 {
1481 cgltf_accessor* first = data->meshes[i].primitives[j].attributes[0].data;
1482
1483 for (cgltf_size k = 0; k < data->meshes[i].primitives[j].attributes_count; ++k)
1484 {
1485 CGLTF_ASSERT_IF(data->meshes[i].primitives[j].attributes[k].data->count != first->count, cgltf_result_invalid_gltf);
1486 }
1487
1488 for (cgltf_size k = 0; k < data->meshes[i].primitives[j].targets_count; ++k)
1489 {
1490 for (cgltf_size m = 0; m < data->meshes[i].primitives[j].targets[k].attributes_count; ++m)
1491 {
1492 CGLTF_ASSERT_IF(data->meshes[i].primitives[j].targets[k].attributes[m].data->count != first->count, cgltf_result_invalid_gltf);
1493 }
1494 }
1495
1496 cgltf_accessor* indices = data->meshes[i].primitives[j].indices;
1497
1498 CGLTF_ASSERT_IF(indices &&
1499 indices->component_type != cgltf_component_type_r_8u &&
1500 indices->component_type != cgltf_component_type_r_16u &&
1501 indices->component_type != cgltf_component_type_r_32u, cgltf_result_invalid_gltf);
1502
1503 if (indices && indices->buffer_view && indices->buffer_view->buffer->data)
1504 {
1505 cgltf_size index_bound = cgltf_calc_index_bound(indices->buffer_view, indices->offset, indices->component_type, indices->count);
1506
1507 CGLTF_ASSERT_IF(index_bound >= first->count, cgltf_result_data_too_short);
1508 }
1509
1510 for (cgltf_size k = 0; k < data->meshes[i].primitives[j].mappings_count; ++k)
1511 {
1512 CGLTF_ASSERT_IF(data->meshes[i].primitives[j].mappings[k].variant >= data->variants_count, cgltf_result_invalid_gltf);
1513 }
1514 }
1515 }
1516 }
1517
1518 for (cgltf_size i = 0; i < data->nodes_count; ++i)
1519 {
1520 if (data->nodes[i].weights && data->nodes[i].mesh)
1521 {
1522 CGLTF_ASSERT_IF (data->nodes[i].mesh->primitives_count && data->nodes[i].mesh->primitives[0].targets_count != data->nodes[i].weights_count, cgltf_result_invalid_gltf);
1523 }
1524 }
1525
1526 for (cgltf_size i = 0; i < data->nodes_count; ++i)
1527 {
1528 cgltf_node* p1 = data->nodes[i].parent;
1529 cgltf_node* p2 = p1 ? p1->parent : NULL;
1530
1531 while (p1 && p2)
1532 {
1533 CGLTF_ASSERT_IF(p1 == p2, cgltf_result_invalid_gltf);
1534
1535 p1 = p1->parent;
1536 p2 = p2->parent ? p2->parent->parent : NULL;
1537 }
1538 }
1539
1540 for (cgltf_size i = 0; i < data->scenes_count; ++i)
1541 {
1542 for (cgltf_size j = 0; j < data->scenes[i].nodes_count; ++j)
1543 {
1544 CGLTF_ASSERT_IF(data->scenes[i].nodes[j]->parent, cgltf_result_invalid_gltf);
1545 }
1546 }
1547
1548 for (cgltf_size i = 0; i < data->animations_count; ++i)
1549 {
1550 for (cgltf_size j = 0; j < data->animations[i].channels_count; ++j)
1551 {
1552 cgltf_animation_channel* channel = &data->animations[i].channels[j];
1553
1554 if (!channel->target_node)
1555 {
1556 continue;
1557 }
1558
1559 cgltf_size components = 1;
1560
1561 if (channel->target_path == cgltf_animation_path_type_weights)
1562 {
1563 CGLTF_ASSERT_IF(!channel->target_node->mesh || !channel->target_node->mesh->primitives_count, cgltf_result_invalid_gltf);
1564
1565 components = channel->target_node->mesh->primitives[0].targets_count;
1566 }
1567
1568 cgltf_size values = channel->sampler->interpolation == cgltf_interpolation_type_cubic_spline ? 3 : 1;
1569
1570 CGLTF_ASSERT_IF(channel->sampler->input->count * components * values != channel->sampler->output->count, cgltf_result_data_too_short);
1571 }
1572 }
1573
1574 return cgltf_result_success;
1575 }
1576
1577 cgltf_result cgltf_copy_extras_json(const cgltf_data* data, const cgltf_extras* extras, char* dest, cgltf_size* dest_size)
1578 {
1579 cgltf_size json_size = extras->end_offset - extras->start_offset;
1580
1581 if (!dest)
1582 {
1583 if (dest_size)
1584 {
1585 *dest_size = json_size + 1;
1586 return cgltf_result_success;
1587 }
1588 return cgltf_result_invalid_options;
1589 }
1590
1591 if (*dest_size + 1 < json_size)
1592 {
1593 strncpy(dest, data->json + extras->start_offset, *dest_size - 1);
1594 dest[*dest_size - 1] = 0;
1595 }
1596 else
1597 {
1598 strncpy(dest, data->json + extras->start_offset, json_size);
1599 dest[json_size] = 0;
1600 }
1601
1602 return cgltf_result_success;
1603 }
1604
1605 void cgltf_free_extensions(cgltf_data* data, cgltf_extension* extensions, cgltf_size extensions_count)
1606 {
1607 for (cgltf_size i = 0; i < extensions_count; ++i)
1608 {
1609 data->memory.free(data->memory.user_data, extensions[i].name);
1610 data->memory.free(data->memory.user_data, extensions[i].data);
1611 }
1612 data->memory.free(data->memory.user_data, extensions);
1613 }
1614
1615 void cgltf_free(cgltf_data* data)
1616 {
1617 if (!data)
1618 {
1619 return;
1620 }
1621
1622 void (*file_release)(const struct cgltf_memory_options*, const struct cgltf_file_options*, void* data) = data->file.release ? data->file.release : cgltf_default_file_release;
1623
1624 data->memory.free(data->memory.user_data, data->asset.copyright);
1625 data->memory.free(data->memory.user_data, data->asset.generator);
1626 data->memory.free(data->memory.user_data, data->asset.version);
1627 data->memory.free(data->memory.user_data, data->asset.min_version);
1628
1629 cgltf_free_extensions(data, data->asset.extensions, data->asset.extensions_count);
1630
1631 for (cgltf_size i = 0; i < data->accessors_count; ++i)
1632 {
1633 data->memory.free(data->memory.user_data, data->accessors[i].name);
1634
1635 if(data->accessors[i].is_sparse)
1636 {
1637 cgltf_free_extensions(data, data->accessors[i].sparse.extensions, data->accessors[i].sparse.extensions_count);
1638 cgltf_free_extensions(data, data->accessors[i].sparse.indices_extensions, data->accessors[i].sparse.indices_extensions_count);
1639 cgltf_free_extensions(data, data->accessors[i].sparse.values_extensions, data->accessors[i].sparse.values_extensions_count);
1640 }
1641 cgltf_free_extensions(data, data->accessors[i].extensions, data->accessors[i].extensions_count);
1642 }
1643 data->memory.free(data->memory.user_data, data->accessors);
1644
1645 for (cgltf_size i = 0; i < data->buffer_views_count; ++i)
1646 {
1647 data->memory.free(data->memory.user_data, data->buffer_views[i].name);
1648 data->memory.free(data->memory.user_data, data->buffer_views[i].data);
1649
1650 cgltf_free_extensions(data, data->buffer_views[i].extensions, data->buffer_views[i].extensions_count);
1651 }
1652 data->memory.free(data->memory.user_data, data->buffer_views);
1653
1654 for (cgltf_size i = 0; i < data->buffers_count; ++i)
1655 {
1656 data->memory.free(data->memory.user_data, data->buffers[i].name);
1657
1658 if (data->buffers[i].data != data->bin)
1659 {
1660 file_release(&data->memory, &data->file, data->buffers[i].data);
1661 }
1662 data->memory.free(data->memory.user_data, data->buffers[i].uri);
1663
1664 cgltf_free_extensions(data, data->buffers[i].extensions, data->buffers[i].extensions_count);
1665 }
1666
1667 data->memory.free(data->memory.user_data, data->buffers);
1668
1669 for (cgltf_size i = 0; i < data->meshes_count; ++i)
1670 {
1671 data->memory.free(data->memory.user_data, data->meshes[i].name);
1672
1673 for (cgltf_size j = 0; j < data->meshes[i].primitives_count; ++j)
1674 {
1675 for (cgltf_size k = 0; k < data->meshes[i].primitives[j].attributes_count; ++k)
1676 {
1677 data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].attributes[k].name);
1678 }
1679
1680 data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].attributes);
1681
1682 for (cgltf_size k = 0; k < data->meshes[i].primitives[j].targets_count; ++k)
1683 {
1684 for (cgltf_size m = 0; m < data->meshes[i].primitives[j].targets[k].attributes_count; ++m)
1685 {
1686 data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].targets[k].attributes[m].name);
1687 }
1688
1689 data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].targets[k].attributes);
1690 }
1691
1692 data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].targets);
1693
1694 if (data->meshes[i].primitives[j].has_draco_mesh_compression)
1695 {
1696 for (cgltf_size k = 0; k < data->meshes[i].primitives[j].draco_mesh_compression.attributes_count; ++k)
1697 {
1698 data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].draco_mesh_compression.attributes[k].name);
1699 }
1700
1701 data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].draco_mesh_compression.attributes);
1702 }
1703
1704 data->memory.free(data->memory.user_data, data->meshes[i].primitives[j].mappings);
1705
1706 cgltf_free_extensions(data, data->meshes[i].primitives[j].extensions, data->meshes[i].primitives[j].extensions_count);
1707 }
1708
1709 data->memory.free(data->memory.user_data, data->meshes[i].primitives);
1710 data->memory.free(data->memory.user_data, data->meshes[i].weights);
1711
1712 for (cgltf_size j = 0; j < data->meshes[i].target_names_count; ++j)
1713 {
1714 data->memory.free(data->memory.user_data, data->meshes[i].target_names[j]);
1715 }
1716
1717 cgltf_free_extensions(data, data->meshes[i].extensions, data->meshes[i].extensions_count);
1718
1719 data->memory.free(data->memory.user_data, data->meshes[i].target_names);
1720 }
1721
1722 data->memory.free(data->memory.user_data, data->meshes);
1723
1724 for (cgltf_size i = 0; i < data->materials_count; ++i)
1725 {
1726 data->memory.free(data->memory.user_data, data->materials[i].name);
1727
1728 if(data->materials[i].has_pbr_metallic_roughness)
1729 {
1730 cgltf_free_extensions(data, data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.extensions, data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.extensions_count);
1731 cgltf_free_extensions(data, data->materials[i].pbr_metallic_roughness.base_color_texture.extensions, data->materials[i].pbr_metallic_roughness.base_color_texture.extensions_count);
1732 }
1733 if(data->materials[i].has_pbr_specular_glossiness)
1734 {
1735 cgltf_free_extensions(data, data->materials[i].pbr_specular_glossiness.diffuse_texture.extensions, data->materials[i].pbr_specular_glossiness.diffuse_texture.extensions_count);
1736 cgltf_free_extensions(data, data->materials[i].pbr_specular_glossiness.specular_glossiness_texture.extensions, data->materials[i].pbr_specular_glossiness.specular_glossiness_texture.extensions_count);
1737 }
1738 if(data->materials[i].has_clearcoat)
1739 {
1740 cgltf_free_extensions(data, data->materials[i].clearcoat.clearcoat_texture.extensions, data->materials[i].clearcoat.clearcoat_texture.extensions_count);
1741 cgltf_free_extensions(data, data->materials[i].clearcoat.clearcoat_roughness_texture.extensions, data->materials[i].clearcoat.clearcoat_roughness_texture.extensions_count);
1742 cgltf_free_extensions(data, data->materials[i].clearcoat.clearcoat_normal_texture.extensions, data->materials[i].clearcoat.clearcoat_normal_texture.extensions_count);
1743 }
1744 if(data->materials[i].has_specular)
1745 {
1746 cgltf_free_extensions(data, data->materials[i].specular.specular_texture.extensions, data->materials[i].specular.specular_texture.extensions_count);
1747 cgltf_free_extensions(data, data->materials[i].specular.specular_color_texture.extensions, data->materials[i].specular.specular_color_texture.extensions_count);
1748 }
1749 if(data->materials[i].has_transmission)
1750 {
1751 cgltf_free_extensions(data, data->materials[i].transmission.transmission_texture.extensions, data->materials[i].transmission.transmission_texture.extensions_count);
1752 }
1753 if (data->materials[i].has_volume)
1754 {
1755 cgltf_free_extensions(data, data->materials[i].volume.thickness_texture.extensions, data->materials[i].volume.thickness_texture.extensions_count);
1756 }
1757 if(data->materials[i].has_sheen)
1758 {
1759 cgltf_free_extensions(data, data->materials[i].sheen.sheen_color_texture.extensions, data->materials[i].sheen.sheen_color_texture.extensions_count);
1760 cgltf_free_extensions(data, data->materials[i].sheen.sheen_roughness_texture.extensions, data->materials[i].sheen.sheen_roughness_texture.extensions_count);
1761 }
1762
1763 cgltf_free_extensions(data, data->materials[i].normal_texture.extensions, data->materials[i].normal_texture.extensions_count);
1764 cgltf_free_extensions(data, data->materials[i].occlusion_texture.extensions, data->materials[i].occlusion_texture.extensions_count);
1765 cgltf_free_extensions(data, data->materials[i].emissive_texture.extensions, data->materials[i].emissive_texture.extensions_count);
1766
1767 cgltf_free_extensions(data, data->materials[i].extensions, data->materials[i].extensions_count);
1768 }
1769
1770 data->memory.free(data->memory.user_data, data->materials);
1771
1772 for (cgltf_size i = 0; i < data->images_count; ++i)
1773 {
1774 data->memory.free(data->memory.user_data, data->images[i].name);
1775 data->memory.free(data->memory.user_data, data->images[i].uri);
1776 data->memory.free(data->memory.user_data, data->images[i].mime_type);
1777
1778 cgltf_free_extensions(data, data->images[i].extensions, data->images[i].extensions_count);
1779 }
1780
1781 data->memory.free(data->memory.user_data, data->images);
1782
1783 for (cgltf_size i = 0; i < data->textures_count; ++i)
1784 {
1785 data->memory.free(data->memory.user_data, data->textures[i].name);
1786 cgltf_free_extensions(data, data->textures[i].extensions, data->textures[i].extensions_count);
1787 }
1788
1789 data->memory.free(data->memory.user_data, data->textures);
1790
1791 for (cgltf_size i = 0; i < data->samplers_count; ++i)
1792 {
1793 data->memory.free(data->memory.user_data, data->samplers[i].name);
1794 cgltf_free_extensions(data, data->samplers[i].extensions, data->samplers[i].extensions_count);
1795 }
1796
1797 data->memory.free(data->memory.user_data, data->samplers);
1798
1799 for (cgltf_size i = 0; i < data->skins_count; ++i)
1800 {
1801 data->memory.free(data->memory.user_data, data->skins[i].name);
1802 data->memory.free(data->memory.user_data, data->skins[i].joints);
1803
1804 cgltf_free_extensions(data, data->skins[i].extensions, data->skins[i].extensions_count);
1805 }
1806
1807 data->memory.free(data->memory.user_data, data->skins);
1808
1809 for (cgltf_size i = 0; i < data->cameras_count; ++i)
1810 {
1811 data->memory.free(data->memory.user_data, data->cameras[i].name);
1812 cgltf_free_extensions(data, data->cameras[i].extensions, data->cameras[i].extensions_count);
1813 }
1814
1815 data->memory.free(data->memory.user_data, data->cameras);
1816
1817 for (cgltf_size i = 0; i < data->lights_count; ++i)
1818 {
1819 data->memory.free(data->memory.user_data, data->lights[i].name);
1820 }
1821
1822 data->memory.free(data->memory.user_data, data->lights);
1823
1824 for (cgltf_size i = 0; i < data->nodes_count; ++i)
1825 {
1826 data->memory.free(data->memory.user_data, data->nodes[i].name);
1827 data->memory.free(data->memory.user_data, data->nodes[i].children);
1828 data->memory.free(data->memory.user_data, data->nodes[i].weights);
1829 cgltf_free_extensions(data, data->nodes[i].extensions, data->nodes[i].extensions_count);
1830 }
1831
1832 data->memory.free(data->memory.user_data, data->nodes);
1833
1834 for (cgltf_size i = 0; i < data->scenes_count; ++i)
1835 {
1836 data->memory.free(data->memory.user_data, data->scenes[i].name);
1837 data->memory.free(data->memory.user_data, data->scenes[i].nodes);
1838
1839 cgltf_free_extensions(data, data->scenes[i].extensions, data->scenes[i].extensions_count);
1840 }
1841
1842 data->memory.free(data->memory.user_data, data->scenes);
1843
1844 for (cgltf_size i = 0; i < data->animations_count; ++i)
1845 {
1846 data->memory.free(data->memory.user_data, data->animations[i].name);
1847 for (cgltf_size j = 0; j < data->animations[i].samplers_count; ++j)
1848 {
1849 cgltf_free_extensions(data, data->animations[i].samplers[j].extensions, data->animations[i].samplers[j].extensions_count);
1850 }
1851 data->memory.free(data->memory.user_data, data->animations[i].samplers);
1852
1853 for (cgltf_size j = 0; j < data->animations[i].channels_count; ++j)
1854 {
1855 cgltf_free_extensions(data, data->animations[i].channels[j].extensions, data->animations[i].channels[j].extensions_count);
1856 }
1857 data->memory.free(data->memory.user_data, data->animations[i].channels);
1858
1859 cgltf_free_extensions(data, data->animations[i].extensions, data->animations[i].extensions_count);
1860 }
1861
1862 data->memory.free(data->memory.user_data, data->animations);
1863
1864 for (cgltf_size i = 0; i < data->variants_count; ++i)
1865 {
1866 data->memory.free(data->memory.user_data, data->variants[i].name);
1867 }
1868
1869 data->memory.free(data->memory.user_data, data->variants);
1870
1871 cgltf_free_extensions(data, data->data_extensions, data->data_extensions_count);
1872
1873 for (cgltf_size i = 0; i < data->extensions_used_count; ++i)
1874 {
1875 data->memory.free(data->memory.user_data, data->extensions_used[i]);
1876 }
1877
1878 data->memory.free(data->memory.user_data, data->extensions_used);
1879
1880 for (cgltf_size i = 0; i < data->extensions_required_count; ++i)
1881 {
1882 data->memory.free(data->memory.user_data, data->extensions_required[i]);
1883 }
1884
1885 data->memory.free(data->memory.user_data, data->extensions_required);
1886
1887 file_release(&data->memory, &data->file, data->file_data);
1888
1889 data->memory.free(data->memory.user_data, data);
1890 }
1891
1892 void cgltf_node_transform_local(const cgltf_node* node, cgltf_float* out_matrix)
1893 {
1894 cgltf_float* lm = out_matrix;
1895
1896 if (node->has_matrix)
1897 {
1898 memcpy(lm, node->matrix, sizeof(float) * 16);
1899 }
1900 else
1901 {
1902 float tx = node->translation[0];
1903 float ty = node->translation[1];
1904 float tz = node->translation[2];
1905
1906 float qx = node->rotation[0];
1907 float qy = node->rotation[1];
1908 float qz = node->rotation[2];
1909 float qw = node->rotation[3];
1910
1911 float sx = node->scale[0];
1912 float sy = node->scale[1];
1913 float sz = node->scale[2];
1914
1915 lm[0] = (1 - 2 * qy*qy - 2 * qz*qz) * sx;
1916 lm[1] = (2 * qx*qy + 2 * qz*qw) * sx;
1917 lm[2] = (2 * qx*qz - 2 * qy*qw) * sx;
1918 lm[3] = 0.f;
1919
1920 lm[4] = (2 * qx*qy - 2 * qz*qw) * sy;
1921 lm[5] = (1 - 2 * qx*qx - 2 * qz*qz) * sy;
1922 lm[6] = (2 * qy*qz + 2 * qx*qw) * sy;
1923 lm[7] = 0.f;
1924
1925 lm[8] = (2 * qx*qz + 2 * qy*qw) * sz;
1926 lm[9] = (2 * qy*qz - 2 * qx*qw) * sz;
1927 lm[10] = (1 - 2 * qx*qx - 2 * qy*qy) * sz;
1928 lm[11] = 0.f;
1929
1930 lm[12] = tx;
1931 lm[13] = ty;
1932 lm[14] = tz;
1933 lm[15] = 1.f;
1934 }
1935 }
1936
1937 void cgltf_node_transform_world(const cgltf_node* node, cgltf_float* out_matrix)
1938 {
1939 cgltf_float* lm = out_matrix;
1940 cgltf_node_transform_local(node, lm);
1941
1942 const cgltf_node* parent = node->parent;
1943
1944 while (parent)
1945 {
1946 float pm[16];
1947 cgltf_node_transform_local(parent, pm);
1948
1949 for (int i = 0; i < 4; ++i)
1950 {
1951 float l0 = lm[i * 4 + 0];
1952 float l1 = lm[i * 4 + 1];
1953 float l2 = lm[i * 4 + 2];
1954
1955 float r0 = l0 * pm[0] + l1 * pm[4] + l2 * pm[8];
1956 float r1 = l0 * pm[1] + l1 * pm[5] + l2 * pm[9];
1957 float r2 = l0 * pm[2] + l1 * pm[6] + l2 * pm[10];
1958
1959 lm[i * 4 + 0] = r0;
1960 lm[i * 4 + 1] = r1;
1961 lm[i * 4 + 2] = r2;
1962 }
1963
1964 lm[12] += pm[12];
1965 lm[13] += pm[13];
1966 lm[14] += pm[14];
1967
1968 parent = parent->parent;
1969 }
1970 }
1971
1972 static cgltf_size cgltf_component_read_index(const void* in, cgltf_component_type component_type)
1973 {
1974 switch (component_type)
1975 {
1976 case cgltf_component_type_r_16:
1977 return *((const int16_t*) in);
1978 case cgltf_component_type_r_16u:
1979 return *((const uint16_t*) in);
1980 case cgltf_component_type_r_32u:
1981 return *((const uint32_t*) in);
1982 case cgltf_component_type_r_32f:
1983 return (cgltf_size)*((const float*) in);
1984 case cgltf_component_type_r_8:
1985 return *((const int8_t*) in);
1986 case cgltf_component_type_r_8u:
1987 return *((const uint8_t*) in);
1988 default:
1989 return 0;
1990 }
1991 }
1992
1993 static cgltf_float cgltf_component_read_float(const void* in, cgltf_component_type component_type, cgltf_bool normalized)
1994 {
1995 if (component_type == cgltf_component_type_r_32f)
1996 {
1997 return *((const float*) in);
1998 }
1999
2000 if (normalized)
2001 {
2002 switch (component_type)
2003 {
2004 // note: glTF spec doesn't currently define normalized conversions for 32-bit integers
2005 case cgltf_component_type_r_16:
2006 return *((const int16_t*) in) / (cgltf_float)32767;
2007 case cgltf_component_type_r_16u:
2008 return *((const uint16_t*) in) / (cgltf_float)65535;
2009 case cgltf_component_type_r_8:
2010 return *((const int8_t*) in) / (cgltf_float)127;
2011 case cgltf_component_type_r_8u:
2012 return *((const uint8_t*) in) / (cgltf_float)255;
2013 default:
2014 return 0;
2015 }
2016 }
2017
2018 return (cgltf_float)cgltf_component_read_index(in, component_type);
2019 }
2020
2021 static cgltf_size cgltf_component_size(cgltf_component_type component_type);
2022
2023 static cgltf_bool cgltf_element_read_float(const uint8_t* element, cgltf_type type, cgltf_component_type component_type, cgltf_bool normalized, cgltf_float* out, cgltf_size element_size)
2024 {
2025 cgltf_size num_components = cgltf_num_components(type);
2026
2027 if (element_size < num_components) {
2028 return 0;
2029 }
2030
2031 // There are three special cases for component extraction, see #data-alignment in the 2.0 spec.
2032
2033 cgltf_size component_size = cgltf_component_size(component_type);
2034
2035 if (type == cgltf_type_mat2 && component_size == 1)
2036 {
2037 out[0] = cgltf_component_read_float(element, component_type, normalized);
2038 out[1] = cgltf_component_read_float(element + 1, component_type, normalized);
2039 out[2] = cgltf_component_read_float(element + 4, component_type, normalized);
2040 out[3] = cgltf_component_read_float(element + 5, component_type, normalized);
2041 return 1;
2042 }
2043
2044 if (type == cgltf_type_mat3 && component_size == 1)
2045 {
2046 out[0] = cgltf_component_read_float(element, component_type, normalized);
2047 out[1] = cgltf_component_read_float(element + 1, component_type, normalized);
2048 out[2] = cgltf_component_read_float(element + 2, component_type, normalized);
2049 out[3] = cgltf_component_read_float(element + 4, component_type, normalized);
2050 out[4] = cgltf_component_read_float(element + 5, component_type, normalized);
2051 out[5] = cgltf_component_read_float(element + 6, component_type, normalized);
2052 out[6] = cgltf_component_read_float(element + 8, component_type, normalized);
2053 out[7] = cgltf_component_read_float(element + 9, component_type, normalized);
2054 out[8] = cgltf_component_read_float(element + 10, component_type, normalized);
2055 return 1;
2056 }
2057
2058 if (type == cgltf_type_mat3 && component_size == 2)
2059 {
2060 out[0] = cgltf_component_read_float(element, component_type, normalized);
2061 out[1] = cgltf_component_read_float(element + 2, component_type, normalized);
2062 out[2] = cgltf_component_read_float(element + 4, component_type, normalized);
2063 out[3] = cgltf_component_read_float(element + 8, component_type, normalized);
2064 out[4] = cgltf_component_read_float(element + 10, component_type, normalized);
2065 out[5] = cgltf_component_read_float(element + 12, component_type, normalized);
2066 out[6] = cgltf_component_read_float(element + 16, component_type, normalized);
2067 out[7] = cgltf_component_read_float(element + 18, component_type, normalized);
2068 out[8] = cgltf_component_read_float(element + 20, component_type, normalized);
2069 return 1;
2070 }
2071
2072 for (cgltf_size i = 0; i < num_components; ++i)
2073 {
2074 out[i] = cgltf_component_read_float(element + component_size * i, component_type, normalized);
2075 }
2076 return 1;
2077 }
2078
2079 const uint8_t* cgltf_buffer_view_data(const cgltf_buffer_view* view)
2080 {
2081 if (view->data)
2082 return (const uint8_t*)view->data;
2083
2084 if (!view->buffer->data)
2085 return NULL;
2086
2087 const uint8_t* result = (const uint8_t*)view->buffer->data;
2088 result += view->offset;
2089 return result;
2090 }
2091
2092 cgltf_bool cgltf_accessor_read_float(const cgltf_accessor* accessor, cgltf_size index, cgltf_float* out, cgltf_size element_size)
2093 {
2094 if (accessor->is_sparse)
2095 {
2096 return 0;
2097 }
2098 if (accessor->buffer_view == NULL)
2099 {
2100 memset(out, 0, element_size * sizeof(cgltf_float));
2101 return 1;
2102 }
2103 const uint8_t* element = cgltf_buffer_view_data(accessor->buffer_view);
2104 if (element == NULL)
2105 {
2106 return 0;
2107 }
2108 element += accessor->offset + accessor->stride * index;
2109 return cgltf_element_read_float(element, accessor->type, accessor->component_type, accessor->normalized, out, element_size);
2110 }
2111
2112 cgltf_size cgltf_accessor_unpack_floats(const cgltf_accessor* accessor, cgltf_float* out, cgltf_size float_count)
2113 {
2114 cgltf_size floats_per_element = cgltf_num_components(accessor->type);
2115 cgltf_size available_floats = accessor->count * floats_per_element;
2116 if (out == NULL)
2117 {
2118 return available_floats;
2119 }
2120
2121 float_count = available_floats < float_count ? available_floats : float_count;
2122 cgltf_size element_count = float_count / floats_per_element;
2123
2124 // First pass: convert each element in the base accessor.
2125 cgltf_float* dest = out;
2126 cgltf_accessor dense = *accessor;
2127 dense.is_sparse = 0;
2128 for (cgltf_size index = 0; index < element_count; index++, dest += floats_per_element)
2129 {
2130 if (!cgltf_accessor_read_float(&dense, index, dest, floats_per_element))
2131 {
2132 return 0;
2133 }
2134 }
2135
2136 // Second pass: write out each element in the sparse accessor.
2137 if (accessor->is_sparse)
2138 {
2139 const cgltf_accessor_sparse* sparse = &dense.sparse;
2140
2141 const uint8_t* index_data = cgltf_buffer_view_data(sparse->indices_buffer_view);
2142 const uint8_t* reader_head = cgltf_buffer_view_data(sparse->values_buffer_view);
2143
2144 if (index_data == NULL || reader_head == NULL)
2145 {
2146 return 0;
2147 }
2148
2149 index_data += sparse->indices_byte_offset;
2150 reader_head += sparse->values_byte_offset;
2151
2152 cgltf_size index_stride = cgltf_component_size(sparse->indices_component_type);
2153 for (cgltf_size reader_index = 0; reader_index < sparse->count; reader_index++, index_data += index_stride)
2154 {
2155 size_t writer_index = cgltf_component_read_index(index_data, sparse->indices_component_type);
2156 float* writer_head = out + writer_index * floats_per_element;
2157
2158 if (!cgltf_element_read_float(reader_head, dense.type, dense.component_type, dense.normalized, writer_head, floats_per_element))
2159 {
2160 return 0;
2161 }
2162
2163 reader_head += dense.stride;
2164 }
2165 }
2166
2167 return element_count * floats_per_element;
2168 }
2169
2170 static cgltf_uint cgltf_component_read_uint(const void* in, cgltf_component_type component_type)
2171 {
2172 switch (component_type)
2173 {
2174 case cgltf_component_type_r_8:
2175 return *((const int8_t*) in);
2176
2177 case cgltf_component_type_r_8u:
2178 return *((const uint8_t*) in);
2179
2180 case cgltf_component_type_r_16:
2181 return *((const int16_t*) in);
2182
2183 case cgltf_component_type_r_16u:
2184 return *((const uint16_t*) in);
2185
2186 case cgltf_component_type_r_32u:
2187 return *((const uint32_t*) in);
2188
2189 default:
2190 return 0;
2191 }
2192 }
2193
2194 static cgltf_bool cgltf_element_read_uint(const uint8_t* element, cgltf_type type, cgltf_component_type component_type, cgltf_uint* out, cgltf_size element_size)
2195 {
2196 cgltf_size num_components = cgltf_num_components(type);
2197
2198 if (element_size < num_components)
2199 {
2200 return 0;
2201 }
2202
2203 // Reading integer matrices is not a valid use case
2204 if (type == cgltf_type_mat2 || type == cgltf_type_mat3 || type == cgltf_type_mat4)
2205 {
2206 return 0;
2207 }
2208
2209 cgltf_size component_size = cgltf_component_size(component_type);
2210
2211 for (cgltf_size i = 0; i < num_components; ++i)
2212 {
2213 out[i] = cgltf_component_read_uint(element + component_size * i, component_type);
2214 }
2215 return 1;
2216 }
2217
2218 cgltf_bool cgltf_accessor_read_uint(const cgltf_accessor* accessor, cgltf_size index, cgltf_uint* out, cgltf_size element_size)
2219 {
2220 if (accessor->is_sparse)
2221 {
2222 return 0;
2223 }
2224 if (accessor->buffer_view == NULL)
2225 {
2226 memset(out, 0, element_size * sizeof( cgltf_uint ));
2227 return 1;
2228 }
2229 const uint8_t* element = cgltf_buffer_view_data(accessor->buffer_view);
2230 if (element == NULL)
2231 {
2232 return 0;
2233 }
2234 element += accessor->offset + accessor->stride * index;
2235 return cgltf_element_read_uint(element, accessor->type, accessor->component_type, out, element_size);
2236 }
2237
2238 cgltf_size cgltf_accessor_read_index(const cgltf_accessor* accessor, cgltf_size index)
2239 {
2240 if (accessor->is_sparse)
2241 {
2242 return 0; // This is an error case, but we can't communicate the error with existing interface.
2243 }
2244 if (accessor->buffer_view == NULL)
2245 {
2246 return 0;
2247 }
2248 const uint8_t* element = cgltf_buffer_view_data(accessor->buffer_view);
2249 if (element == NULL)
2250 {
2251 return 0; // This is an error case, but we can't communicate the error with existing interface.
2252 }
2253 element += accessor->offset + accessor->stride * index;
2254 return cgltf_component_read_index(element, accessor->component_type);
2255 }
2256
2257 #define CGLTF_ERROR_JSON -1
2258 #define CGLTF_ERROR_NOMEM -2
2259 #define CGLTF_ERROR_LEGACY -3
2260
2261 #define CGLTF_CHECK_TOKTYPE(tok_, type_) if ((tok_).type != (type_)) { return CGLTF_ERROR_JSON; }
2262 #define CGLTF_CHECK_KEY(tok_) if ((tok_).type != JSMN_STRING || (tok_).size == 0) { return CGLTF_ERROR_JSON; } /* checking size for 0 verifies that a value follows the key */
2263
2264 #define CGLTF_PTRINDEX(type, idx) (type*)((cgltf_size)idx + 1)
2265 #define CGLTF_PTRFIXUP(var, data, size) if (var) { if ((cgltf_size)var > size) { return CGLTF_ERROR_JSON; } var = &data[(cgltf_size)var-1]; }
2266 #define CGLTF_PTRFIXUP_REQ(var, data, size) if (!var || (cgltf_size)var > size) { return CGLTF_ERROR_JSON; } var = &data[(cgltf_size)var-1];
2267
2268 static int cgltf_json_strcmp(jsmntok_t const* tok, const uint8_t* json_chunk, const char* str)
2269 {
2270 CGLTF_CHECK_TOKTYPE(*tok, JSMN_STRING);
2271 size_t const str_len = strlen(str);
2272 size_t const name_length = tok->end - tok->start;
2273 return (str_len == name_length) ? strncmp((const char*)json_chunk + tok->start, str, str_len) : 128;
2274 }
2275
2276 static int cgltf_json_to_int(jsmntok_t const* tok, const uint8_t* json_chunk)
2277 {
2278 CGLTF_CHECK_TOKTYPE(*tok, JSMN_PRIMITIVE);
2279 char tmp[128];
2280 int size = (cgltf_size)(tok->end - tok->start) < sizeof(tmp) ? tok->end - tok->start : (int)(sizeof(tmp) - 1);
2281 strncpy(tmp, (const char*)json_chunk + tok->start, size);
2282 tmp[size] = 0;
2283 return CGLTF_ATOI(tmp);
2284 }
2285
2286 static cgltf_float cgltf_json_to_float(jsmntok_t const* tok, const uint8_t* json_chunk)
2287 {
2288 CGLTF_CHECK_TOKTYPE(*tok, JSMN_PRIMITIVE);
2289 char tmp[128];
2290 int size = (cgltf_size)(tok->end - tok->start) < sizeof(tmp) ? tok->end - tok->start : (int)(sizeof(tmp) - 1);
2291 strncpy(tmp, (const char*)json_chunk + tok->start, size);
2292 tmp[size] = 0;
2293 return (cgltf_float)CGLTF_ATOF(tmp);
2294 }
2295
2296 static cgltf_bool cgltf_json_to_bool(jsmntok_t const* tok, const uint8_t* json_chunk)
2297 {
2298 int size = tok->end - tok->start;
2299 return size == 4 && memcmp(json_chunk + tok->start, "true", 4) == 0;
2300 }
2301
2302 static int cgltf_skip_json(jsmntok_t const* tokens, int i)
2303 {
2304 int end = i + 1;
2305
2306 while (i < end)
2307 {
2308 switch (tokens[i].type)
2309 {
2310 case JSMN_OBJECT:
2311 end += tokens[i].size * 2;
2312 break;
2313
2314 case JSMN_ARRAY:
2315 end += tokens[i].size;
2316 break;
2317
2318 case JSMN_PRIMITIVE:
2319 case JSMN_STRING:
2320 break;
2321
2322 default:
2323 return -1;
2324 }
2325
2326 i++;
2327 }
2328
2329 return i;
2330 }
2331
2332 static void cgltf_fill_float_array(float* out_array, int size, float value)
2333 {
2334 for (int j = 0; j < size; ++j)
2335 {
2336 out_array[j] = value;
2337 }
2338 }
2339
2340 static int cgltf_parse_json_float_array(jsmntok_t const* tokens, int i, const uint8_t* json_chunk, float* out_array, int size)
2341 {
2342 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_ARRAY);
2343 if (tokens[i].size != size)
2344 {
2345 return CGLTF_ERROR_JSON;
2346 }
2347 ++i;
2348 for (int j = 0; j < size; ++j)
2349 {
2350 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
2351 out_array[j] = cgltf_json_to_float(tokens + i, json_chunk);
2352 ++i;
2353 }
2354 return i;
2355 }
2356
2357 static int cgltf_parse_json_string(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, char** out_string)
2358 {
2359 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_STRING);
2360 if (*out_string)
2361 {
2362 return CGLTF_ERROR_JSON;
2363 }
2364 int size = tokens[i].end - tokens[i].start;
2365 char* result = (char*)options->memory.alloc(options->memory.user_data, size + 1);
2366 if (!result)
2367 {
2368 return CGLTF_ERROR_NOMEM;
2369 }
2370 strncpy(result, (const char*)json_chunk + tokens[i].start, size);
2371 result[size] = 0;
2372 *out_string = result;
2373 return i + 1;
2374 }
2375
2376 static int cgltf_parse_json_array(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, size_t element_size, void** out_array, cgltf_size* out_size)
2377 {
2378 (void)json_chunk;
2379 if (tokens[i].type != JSMN_ARRAY)
2380 {
2381 return tokens[i].type == JSMN_OBJECT ? CGLTF_ERROR_LEGACY : CGLTF_ERROR_JSON;
2382 }
2383 if (*out_array)
2384 {
2385 return CGLTF_ERROR_JSON;
2386 }
2387 int size = tokens[i].size;
2388 void* result = cgltf_calloc(options, element_size, size);
2389 if (!result)
2390 {
2391 return CGLTF_ERROR_NOMEM;
2392 }
2393 *out_array = result;
2394 *out_size = size;
2395 return i + 1;
2396 }
2397
2398 static int cgltf_parse_json_string_array(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, char*** out_array, cgltf_size* out_size)
2399 {
2400 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_ARRAY);
2401 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(char*), (void**)out_array, out_size);
2402 if (i < 0)
2403 {
2404 return i;
2405 }
2406
2407 for (cgltf_size j = 0; j < *out_size; ++j)
2408 {
2409 i = cgltf_parse_json_string(options, tokens, i, json_chunk, j + (*out_array));
2410 if (i < 0)
2411 {
2412 return i;
2413 }
2414 }
2415 return i;
2416 }
2417
2418 static void cgltf_parse_attribute_type(const char* name, cgltf_attribute_type* out_type, int* out_index)
2419 {
2420 const char* us = strchr(name, '_');
2421 size_t len = us ? (size_t)(us - name) : strlen(name);
2422
2423 if (len == 8 && strncmp(name, "POSITION", 8) == 0)
2424 {
2425 *out_type = cgltf_attribute_type_position;
2426 }
2427 else if (len == 6 && strncmp(name, "NORMAL", 6) == 0)
2428 {
2429 *out_type = cgltf_attribute_type_normal;
2430 }
2431 else if (len == 7 && strncmp(name, "TANGENT", 7) == 0)
2432 {
2433 *out_type = cgltf_attribute_type_tangent;
2434 }
2435 else if (len == 8 && strncmp(name, "TEXCOORD", 8) == 0)
2436 {
2437 *out_type = cgltf_attribute_type_texcoord;
2438 }
2439 else if (len == 5 && strncmp(name, "COLOR", 5) == 0)
2440 {
2441 *out_type = cgltf_attribute_type_color;
2442 }
2443 else if (len == 6 && strncmp(name, "JOINTS", 6) == 0)
2444 {
2445 *out_type = cgltf_attribute_type_joints;
2446 }
2447 else if (len == 7 && strncmp(name, "WEIGHTS", 7) == 0)
2448 {
2449 *out_type = cgltf_attribute_type_weights;
2450 }
2451 else
2452 {
2453 *out_type = cgltf_attribute_type_invalid;
2454 }
2455
2456 if (us && *out_type != cgltf_attribute_type_invalid)
2457 {
2458 *out_index = CGLTF_ATOI(us + 1);
2459 }
2460 }
2461
2462 static int cgltf_parse_json_attribute_list(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_attribute** out_attributes, cgltf_size* out_attributes_count)
2463 {
2464 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
2465
2466 if (*out_attributes)
2467 {
2468 return CGLTF_ERROR_JSON;
2469 }
2470
2471 *out_attributes_count = tokens[i].size;
2472 *out_attributes = (cgltf_attribute*)cgltf_calloc(options, sizeof(cgltf_attribute), *out_attributes_count);
2473 ++i;
2474
2475 if (!*out_attributes)
2476 {
2477 return CGLTF_ERROR_NOMEM;
2478 }
2479
2480 for (cgltf_size j = 0; j < *out_attributes_count; ++j)
2481 {
2482 CGLTF_CHECK_KEY(tokens[i]);
2483
2484 i = cgltf_parse_json_string(options, tokens, i, json_chunk, &(*out_attributes)[j].name);
2485 if (i < 0)
2486 {
2487 return CGLTF_ERROR_JSON;
2488 }
2489
2490 cgltf_parse_attribute_type((*out_attributes)[j].name, &(*out_attributes)[j].type, &(*out_attributes)[j].index);
2491
2492 (*out_attributes)[j].data = CGLTF_PTRINDEX(cgltf_accessor, cgltf_json_to_int(tokens + i, json_chunk));
2493 ++i;
2494 }
2495
2496 return i;
2497 }
2498
2499 static int cgltf_parse_json_extras(jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_extras* out_extras)
2500 {
2501 (void)json_chunk;
2502 out_extras->start_offset = tokens[i].start;
2503 out_extras->end_offset = tokens[i].end;
2504 i = cgltf_skip_json(tokens, i);
2505 return i;
2506 }
2507
2508 static int cgltf_parse_json_unprocessed_extension(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_extension* out_extension)
2509 {
2510 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_STRING);
2511 CGLTF_CHECK_TOKTYPE(tokens[i+1], JSMN_OBJECT);
2512 if (out_extension->name)
2513 {
2514 return CGLTF_ERROR_JSON;
2515 }
2516
2517 cgltf_size name_length = tokens[i].end - tokens[i].start;
2518 out_extension->name = (char*)options->memory.alloc(options->memory.user_data, name_length + 1);
2519 if (!out_extension->name)
2520 {
2521 return CGLTF_ERROR_NOMEM;
2522 }
2523 strncpy(out_extension->name, (const char*)json_chunk + tokens[i].start, name_length);
2524 out_extension->name[name_length] = 0;
2525 i++;
2526
2527 size_t start = tokens[i].start;
2528 size_t size = tokens[i].end - start;
2529 out_extension->data = (char*)options->memory.alloc(options->memory.user_data, size + 1);
2530 if (!out_extension->data)
2531 {
2532 return CGLTF_ERROR_NOMEM;
2533 }
2534 strncpy(out_extension->data, (const char*)json_chunk + start, size);
2535 out_extension->data[size] = '\0';
2536
2537 i = cgltf_skip_json(tokens, i);
2538
2539 return i;
2540 }
2541
2542 static int cgltf_parse_json_unprocessed_extensions(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_size* out_extensions_count, cgltf_extension** out_extensions)
2543 {
2544 ++i;
2545
2546 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
2547 if(*out_extensions)
2548 {
2549 return CGLTF_ERROR_JSON;
2550 }
2551
2552 int extensions_size = tokens[i].size;
2553 *out_extensions_count = 0;
2554 *out_extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
2555
2556 if (!*out_extensions)
2557 {
2558 return CGLTF_ERROR_NOMEM;
2559 }
2560
2561 ++i;
2562
2563 for (int j = 0; j < extensions_size; ++j)
2564 {
2565 CGLTF_CHECK_KEY(tokens[i]);
2566
2567 cgltf_size extension_index = (*out_extensions_count)++;
2568 cgltf_extension* extension = &((*out_extensions)[extension_index]);
2569 i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, extension);
2570
2571 if (i < 0)
2572 {
2573 return i;
2574 }
2575 }
2576 return i;
2577 }
2578
2579 static int cgltf_parse_json_draco_mesh_compression(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_draco_mesh_compression* out_draco_mesh_compression)
2580 {
2581 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
2582
2583 int size = tokens[i].size;
2584 ++i;
2585
2586 for (int j = 0; j < size; ++j)
2587 {
2588 CGLTF_CHECK_KEY(tokens[i]);
2589
2590 if (cgltf_json_strcmp(tokens + i, json_chunk, "attributes") == 0)
2591 {
2592 i = cgltf_parse_json_attribute_list(options, tokens, i + 1, json_chunk, &out_draco_mesh_compression->attributes, &out_draco_mesh_compression->attributes_count);
2593 }
2594 else if (cgltf_json_strcmp(tokens + i, json_chunk, "bufferView") == 0)
2595 {
2596 ++i;
2597 out_draco_mesh_compression->buffer_view = CGLTF_PTRINDEX(cgltf_buffer_view, cgltf_json_to_int(tokens + i, json_chunk));
2598 ++i;
2599 }
2600
2601 if (i < 0)
2602 {
2603 return i;
2604 }
2605 }
2606
2607 return i;
2608 }
2609
2610 static int cgltf_parse_json_material_mapping_data(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_material_mapping* out_mappings, cgltf_size* offset)
2611 {
2612 (void)options;
2613 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_ARRAY);
2614
2615 int size = tokens[i].size;
2616 ++i;
2617
2618 for (int j = 0; j < size; ++j)
2619 {
2620 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
2621
2622 int obj_size = tokens[i].size;
2623 ++i;
2624
2625 int material = -1;
2626 int variants_tok = -1;
2627 cgltf_extras extras = {0, 0};
2628
2629 for (int k = 0; k < obj_size; ++k)
2630 {
2631 CGLTF_CHECK_KEY(tokens[i]);
2632
2633 if (cgltf_json_strcmp(tokens + i, json_chunk, "material") == 0)
2634 {
2635 ++i;
2636 material = cgltf_json_to_int(tokens + i, json_chunk);
2637 ++i;
2638 }
2639 else if (cgltf_json_strcmp(tokens + i, json_chunk, "variants") == 0)
2640 {
2641 variants_tok = i+1;
2642 CGLTF_CHECK_TOKTYPE(tokens[variants_tok], JSMN_ARRAY);
2643
2644 i = cgltf_skip_json(tokens, i+1);
2645 }
2646 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
2647 {
2648 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &extras);
2649 }
2650 else
2651 {
2652 i = cgltf_skip_json(tokens, i+1);
2653 }
2654
2655 if (i < 0)
2656 {
2657 return i;
2658 }
2659 }
2660
2661 if (material < 0 || variants_tok < 0)
2662 {
2663 return CGLTF_ERROR_JSON;
2664 }
2665
2666 if (out_mappings)
2667 {
2668 for (int k = 0; k < tokens[variants_tok].size; ++k)
2669 {
2670 int variant = cgltf_json_to_int(&tokens[variants_tok + 1 + k], json_chunk);
2671 if (variant < 0)
2672 return variant;
2673
2674 out_mappings[*offset].material = CGLTF_PTRINDEX(cgltf_material, material);
2675 out_mappings[*offset].variant = variant;
2676 out_mappings[*offset].extras = extras;
2677
2678 (*offset)++;
2679 }
2680 }
2681 else
2682 {
2683 (*offset) += tokens[variants_tok].size;
2684 }
2685 }
2686
2687 return i;
2688 }
2689
2690 static int cgltf_parse_json_material_mappings(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_primitive* out_prim)
2691 {
2692 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
2693
2694 int size = tokens[i].size;
2695 ++i;
2696
2697 for (int j = 0; j < size; ++j)
2698 {
2699 CGLTF_CHECK_KEY(tokens[i]);
2700
2701 if (cgltf_json_strcmp(tokens + i, json_chunk, "mappings") == 0)
2702 {
2703 if (out_prim->mappings)
2704 {
2705 return CGLTF_ERROR_JSON;
2706 }
2707
2708 cgltf_size mappings_offset = 0;
2709 int k = cgltf_parse_json_material_mapping_data(options, tokens, i + 1, json_chunk, NULL, &mappings_offset);
2710 if (k < 0)
2711 {
2712 return k;
2713 }
2714
2715 out_prim->mappings_count = mappings_offset;
2716 out_prim->mappings = (cgltf_material_mapping*)cgltf_calloc(options, sizeof(cgltf_material_mapping), out_prim->mappings_count);
2717
2718 mappings_offset = 0;
2719 i = cgltf_parse_json_material_mapping_data(options, tokens, i + 1, json_chunk, out_prim->mappings, &mappings_offset);
2720 }
2721 else
2722 {
2723 i = cgltf_skip_json(tokens, i+1);
2724 }
2725
2726 if (i < 0)
2727 {
2728 return i;
2729 }
2730 }
2731
2732 return i;
2733 }
2734
2735 static int cgltf_parse_json_primitive(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_primitive* out_prim)
2736 {
2737 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
2738
2739 out_prim->type = cgltf_primitive_type_triangles;
2740
2741 int size = tokens[i].size;
2742 ++i;
2743
2744 for (int j = 0; j < size; ++j)
2745 {
2746 CGLTF_CHECK_KEY(tokens[i]);
2747
2748 if (cgltf_json_strcmp(tokens+i, json_chunk, "mode") == 0)
2749 {
2750 ++i;
2751 out_prim->type
2752 = (cgltf_primitive_type)
2753 cgltf_json_to_int(tokens+i, json_chunk);
2754 ++i;
2755 }
2756 else if (cgltf_json_strcmp(tokens+i, json_chunk, "indices") == 0)
2757 {
2758 ++i;
2759 out_prim->indices = CGLTF_PTRINDEX(cgltf_accessor, cgltf_json_to_int(tokens + i, json_chunk));
2760 ++i;
2761 }
2762 else if (cgltf_json_strcmp(tokens+i, json_chunk, "material") == 0)
2763 {
2764 ++i;
2765 out_prim->material = CGLTF_PTRINDEX(cgltf_material, cgltf_json_to_int(tokens + i, json_chunk));
2766 ++i;
2767 }
2768 else if (cgltf_json_strcmp(tokens+i, json_chunk, "attributes") == 0)
2769 {
2770 i = cgltf_parse_json_attribute_list(options, tokens, i + 1, json_chunk, &out_prim->attributes, &out_prim->attributes_count);
2771 }
2772 else if (cgltf_json_strcmp(tokens+i, json_chunk, "targets") == 0)
2773 {
2774 i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_morph_target), (void**)&out_prim->targets, &out_prim->targets_count);
2775 if (i < 0)
2776 {
2777 return i;
2778 }
2779
2780 for (cgltf_size k = 0; k < out_prim->targets_count; ++k)
2781 {
2782 i = cgltf_parse_json_attribute_list(options, tokens, i, json_chunk, &out_prim->targets[k].attributes, &out_prim->targets[k].attributes_count);
2783 if (i < 0)
2784 {
2785 return i;
2786 }
2787 }
2788 }
2789 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
2790 {
2791 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_prim->extras);
2792 }
2793 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
2794 {
2795 ++i;
2796
2797 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
2798 if(out_prim->extensions)
2799 {
2800 return CGLTF_ERROR_JSON;
2801 }
2802
2803 int extensions_size = tokens[i].size;
2804 out_prim->extensions_count = 0;
2805 out_prim->extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
2806
2807 if (!out_prim->extensions)
2808 {
2809 return CGLTF_ERROR_NOMEM;
2810 }
2811
2812 ++i;
2813 for (int k = 0; k < extensions_size; ++k)
2814 {
2815 CGLTF_CHECK_KEY(tokens[i]);
2816
2817 if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_draco_mesh_compression") == 0)
2818 {
2819 out_prim->has_draco_mesh_compression = 1;
2820 i = cgltf_parse_json_draco_mesh_compression(options, tokens, i + 1, json_chunk, &out_prim->draco_mesh_compression);
2821 }
2822 else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_variants") == 0)
2823 {
2824 i = cgltf_parse_json_material_mappings(options, tokens, i + 1, json_chunk, out_prim);
2825 }
2826 else
2827 {
2828 i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_prim->extensions[out_prim->extensions_count++]));
2829 }
2830
2831 if (i < 0)
2832 {
2833 return i;
2834 }
2835 }
2836 }
2837 else
2838 {
2839 i = cgltf_skip_json(tokens, i+1);
2840 }
2841
2842 if (i < 0)
2843 {
2844 return i;
2845 }
2846 }
2847
2848 return i;
2849 }
2850
2851 static int cgltf_parse_json_mesh(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_mesh* out_mesh)
2852 {
2853 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
2854
2855 int size = tokens[i].size;
2856 ++i;
2857
2858 for (int j = 0; j < size; ++j)
2859 {
2860 CGLTF_CHECK_KEY(tokens[i]);
2861
2862 if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
2863 {
2864 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_mesh->name);
2865 }
2866 else if (cgltf_json_strcmp(tokens+i, json_chunk, "primitives") == 0)
2867 {
2868 i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_primitive), (void**)&out_mesh->primitives, &out_mesh->primitives_count);
2869 if (i < 0)
2870 {
2871 return i;
2872 }
2873
2874 for (cgltf_size prim_index = 0; prim_index < out_mesh->primitives_count; ++prim_index)
2875 {
2876 i = cgltf_parse_json_primitive(options, tokens, i, json_chunk, &out_mesh->primitives[prim_index]);
2877 if (i < 0)
2878 {
2879 return i;
2880 }
2881 }
2882 }
2883 else if (cgltf_json_strcmp(tokens + i, json_chunk, "weights") == 0)
2884 {
2885 i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_float), (void**)&out_mesh->weights, &out_mesh->weights_count);
2886 if (i < 0)
2887 {
2888 return i;
2889 }
2890
2891 i = cgltf_parse_json_float_array(tokens, i - 1, json_chunk, out_mesh->weights, (int)out_mesh->weights_count);
2892 }
2893 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
2894 {
2895 ++i;
2896
2897 out_mesh->extras.start_offset = tokens[i].start;
2898 out_mesh->extras.end_offset = tokens[i].end;
2899
2900 if (tokens[i].type == JSMN_OBJECT)
2901 {
2902 int extras_size = tokens[i].size;
2903 ++i;
2904
2905 for (int k = 0; k < extras_size; ++k)
2906 {
2907 CGLTF_CHECK_KEY(tokens[i]);
2908
2909 if (cgltf_json_strcmp(tokens+i, json_chunk, "targetNames") == 0 && tokens[i+1].type == JSMN_ARRAY)
2910 {
2911 i = cgltf_parse_json_string_array(options, tokens, i + 1, json_chunk, &out_mesh->target_names, &out_mesh->target_names_count);
2912 }
2913 else
2914 {
2915 i = cgltf_skip_json(tokens, i+1);
2916 }
2917
2918 if (i < 0)
2919 {
2920 return i;
2921 }
2922 }
2923 }
2924 else
2925 {
2926 i = cgltf_skip_json(tokens, i);
2927 }
2928 }
2929 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
2930 {
2931 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_mesh->extensions_count, &out_mesh->extensions);
2932 }
2933 else
2934 {
2935 i = cgltf_skip_json(tokens, i+1);
2936 }
2937
2938 if (i < 0)
2939 {
2940 return i;
2941 }
2942 }
2943
2944 return i;
2945 }
2946
2947 static int cgltf_parse_json_meshes(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
2948 {
2949 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_mesh), (void**)&out_data->meshes, &out_data->meshes_count);
2950 if (i < 0)
2951 {
2952 return i;
2953 }
2954
2955 for (cgltf_size j = 0; j < out_data->meshes_count; ++j)
2956 {
2957 i = cgltf_parse_json_mesh(options, tokens, i, json_chunk, &out_data->meshes[j]);
2958 if (i < 0)
2959 {
2960 return i;
2961 }
2962 }
2963 return i;
2964 }
2965
2966 static cgltf_component_type cgltf_json_to_component_type(jsmntok_t const* tok, const uint8_t* json_chunk)
2967 {
2968 int type = cgltf_json_to_int(tok, json_chunk);
2969
2970 switch (type)
2971 {
2972 case 5120:
2973 return cgltf_component_type_r_8;
2974 case 5121:
2975 return cgltf_component_type_r_8u;
2976 case 5122:
2977 return cgltf_component_type_r_16;
2978 case 5123:
2979 return cgltf_component_type_r_16u;
2980 case 5125:
2981 return cgltf_component_type_r_32u;
2982 case 5126:
2983 return cgltf_component_type_r_32f;
2984 default:
2985 return cgltf_component_type_invalid;
2986 }
2987 }
2988
2989 static int cgltf_parse_json_accessor_sparse(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_accessor_sparse* out_sparse)
2990 {
2991 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
2992
2993 int size = tokens[i].size;
2994 ++i;
2995
2996 for (int j = 0; j < size; ++j)
2997 {
2998 CGLTF_CHECK_KEY(tokens[i]);
2999
3000 if (cgltf_json_strcmp(tokens+i, json_chunk, "count") == 0)
3001 {
3002 ++i;
3003 out_sparse->count = cgltf_json_to_int(tokens + i, json_chunk);
3004 ++i;
3005 }
3006 else if (cgltf_json_strcmp(tokens+i, json_chunk, "indices") == 0)
3007 {
3008 ++i;
3009 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3010
3011 int indices_size = tokens[i].size;
3012 ++i;
3013
3014 for (int k = 0; k < indices_size; ++k)
3015 {
3016 CGLTF_CHECK_KEY(tokens[i]);
3017
3018 if (cgltf_json_strcmp(tokens+i, json_chunk, "bufferView") == 0)
3019 {
3020 ++i;
3021 out_sparse->indices_buffer_view = CGLTF_PTRINDEX(cgltf_buffer_view, cgltf_json_to_int(tokens + i, json_chunk));
3022 ++i;
3023 }
3024 else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteOffset") == 0)
3025 {
3026 ++i;
3027 out_sparse->indices_byte_offset = cgltf_json_to_int(tokens + i, json_chunk);
3028 ++i;
3029 }
3030 else if (cgltf_json_strcmp(tokens+i, json_chunk, "componentType") == 0)
3031 {
3032 ++i;
3033 out_sparse->indices_component_type = cgltf_json_to_component_type(tokens + i, json_chunk);
3034 ++i;
3035 }
3036 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
3037 {
3038 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_sparse->indices_extras);
3039 }
3040 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
3041 {
3042 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_sparse->indices_extensions_count, &out_sparse->indices_extensions);
3043 }
3044 else
3045 {
3046 i = cgltf_skip_json(tokens, i+1);
3047 }
3048
3049 if (i < 0)
3050 {
3051 return i;
3052 }
3053 }
3054 }
3055 else if (cgltf_json_strcmp(tokens+i, json_chunk, "values") == 0)
3056 {
3057 ++i;
3058 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3059
3060 int values_size = tokens[i].size;
3061 ++i;
3062
3063 for (int k = 0; k < values_size; ++k)
3064 {
3065 CGLTF_CHECK_KEY(tokens[i]);
3066
3067 if (cgltf_json_strcmp(tokens+i, json_chunk, "bufferView") == 0)
3068 {
3069 ++i;
3070 out_sparse->values_buffer_view = CGLTF_PTRINDEX(cgltf_buffer_view, cgltf_json_to_int(tokens + i, json_chunk));
3071 ++i;
3072 }
3073 else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteOffset") == 0)
3074 {
3075 ++i;
3076 out_sparse->values_byte_offset = cgltf_json_to_int(tokens + i, json_chunk);
3077 ++i;
3078 }
3079 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
3080 {
3081 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_sparse->values_extras);
3082 }
3083 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
3084 {
3085 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_sparse->values_extensions_count, &out_sparse->values_extensions);
3086 }
3087 else
3088 {
3089 i = cgltf_skip_json(tokens, i+1);
3090 }
3091
3092 if (i < 0)
3093 {
3094 return i;
3095 }
3096 }
3097 }
3098 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
3099 {
3100 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_sparse->extras);
3101 }
3102 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
3103 {
3104 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_sparse->extensions_count, &out_sparse->extensions);
3105 }
3106 else
3107 {
3108 i = cgltf_skip_json(tokens, i+1);
3109 }
3110
3111 if (i < 0)
3112 {
3113 return i;
3114 }
3115 }
3116
3117 return i;
3118 }
3119
3120 static int cgltf_parse_json_accessor(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_accessor* out_accessor)
3121 {
3122 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3123
3124 int size = tokens[i].size;
3125 ++i;
3126
3127 for (int j = 0; j < size; ++j)
3128 {
3129 CGLTF_CHECK_KEY(tokens[i]);
3130
3131 if (cgltf_json_strcmp(tokens + i, json_chunk, "name") == 0)
3132 {
3133 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_accessor->name);
3134 }
3135 else if (cgltf_json_strcmp(tokens+i, json_chunk, "bufferView") == 0)
3136 {
3137 ++i;
3138 out_accessor->buffer_view = CGLTF_PTRINDEX(cgltf_buffer_view, cgltf_json_to_int(tokens + i, json_chunk));
3139 ++i;
3140 }
3141 else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteOffset") == 0)
3142 {
3143 ++i;
3144 out_accessor->offset =
3145 cgltf_json_to_int(tokens+i, json_chunk);
3146 ++i;
3147 }
3148 else if (cgltf_json_strcmp(tokens+i, json_chunk, "componentType") == 0)
3149 {
3150 ++i;
3151 out_accessor->component_type = cgltf_json_to_component_type(tokens + i, json_chunk);
3152 ++i;
3153 }
3154 else if (cgltf_json_strcmp(tokens+i, json_chunk, "normalized") == 0)
3155 {
3156 ++i;
3157 out_accessor->normalized = cgltf_json_to_bool(tokens+i, json_chunk);
3158 ++i;
3159 }
3160 else if (cgltf_json_strcmp(tokens+i, json_chunk, "count") == 0)
3161 {
3162 ++i;
3163 out_accessor->count =
3164 cgltf_json_to_int(tokens+i, json_chunk);
3165 ++i;
3166 }
3167 else if (cgltf_json_strcmp(tokens+i, json_chunk, "type") == 0)
3168 {
3169 ++i;
3170 if (cgltf_json_strcmp(tokens+i, json_chunk, "SCALAR") == 0)
3171 {
3172 out_accessor->type = cgltf_type_scalar;
3173 }
3174 else if (cgltf_json_strcmp(tokens+i, json_chunk, "VEC2") == 0)
3175 {
3176 out_accessor->type = cgltf_type_vec2;
3177 }
3178 else if (cgltf_json_strcmp(tokens+i, json_chunk, "VEC3") == 0)
3179 {
3180 out_accessor->type = cgltf_type_vec3;
3181 }
3182 else if (cgltf_json_strcmp(tokens+i, json_chunk, "VEC4") == 0)
3183 {
3184 out_accessor->type = cgltf_type_vec4;
3185 }
3186 else if (cgltf_json_strcmp(tokens+i, json_chunk, "MAT2") == 0)
3187 {
3188 out_accessor->type = cgltf_type_mat2;
3189 }
3190 else if (cgltf_json_strcmp(tokens+i, json_chunk, "MAT3") == 0)
3191 {
3192 out_accessor->type = cgltf_type_mat3;
3193 }
3194 else if (cgltf_json_strcmp(tokens+i, json_chunk, "MAT4") == 0)
3195 {
3196 out_accessor->type = cgltf_type_mat4;
3197 }
3198 ++i;
3199 }
3200 else if (cgltf_json_strcmp(tokens + i, json_chunk, "min") == 0)
3201 {
3202 ++i;
3203 out_accessor->has_min = 1;
3204 // note: we can't parse the precise number of elements since type may not have been computed yet
3205 int min_size = tokens[i].size > 16 ? 16 : tokens[i].size;
3206 i = cgltf_parse_json_float_array(tokens, i, json_chunk, out_accessor->min, min_size);
3207 }
3208 else if (cgltf_json_strcmp(tokens + i, json_chunk, "max") == 0)
3209 {
3210 ++i;
3211 out_accessor->has_max = 1;
3212 // note: we can't parse the precise number of elements since type may not have been computed yet
3213 int max_size = tokens[i].size > 16 ? 16 : tokens[i].size;
3214 i = cgltf_parse_json_float_array(tokens, i, json_chunk, out_accessor->max, max_size);
3215 }
3216 else if (cgltf_json_strcmp(tokens + i, json_chunk, "sparse") == 0)
3217 {
3218 out_accessor->is_sparse = 1;
3219 i = cgltf_parse_json_accessor_sparse(options, tokens, i + 1, json_chunk, &out_accessor->sparse);
3220 }
3221 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
3222 {
3223 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_accessor->extras);
3224 }
3225 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
3226 {
3227 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_accessor->extensions_count, &out_accessor->extensions);
3228 }
3229 else
3230 {
3231 i = cgltf_skip_json(tokens, i+1);
3232 }
3233
3234 if (i < 0)
3235 {
3236 return i;
3237 }
3238 }
3239
3240 return i;
3241 }
3242
3243 static int cgltf_parse_json_texture_transform(jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_texture_transform* out_texture_transform)
3244 {
3245 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3246
3247 int size = tokens[i].size;
3248 ++i;
3249
3250 for (int j = 0; j < size; ++j)
3251 {
3252 CGLTF_CHECK_KEY(tokens[i]);
3253
3254 if (cgltf_json_strcmp(tokens + i, json_chunk, "offset") == 0)
3255 {
3256 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_texture_transform->offset, 2);
3257 }
3258 else if (cgltf_json_strcmp(tokens + i, json_chunk, "rotation") == 0)
3259 {
3260 ++i;
3261 out_texture_transform->rotation = cgltf_json_to_float(tokens + i, json_chunk);
3262 ++i;
3263 }
3264 else if (cgltf_json_strcmp(tokens + i, json_chunk, "scale") == 0)
3265 {
3266 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_texture_transform->scale, 2);
3267 }
3268 else if (cgltf_json_strcmp(tokens + i, json_chunk, "texCoord") == 0)
3269 {
3270 ++i;
3271 out_texture_transform->texcoord = cgltf_json_to_int(tokens + i, json_chunk);
3272 ++i;
3273 }
3274 else
3275 {
3276 i = cgltf_skip_json(tokens, i + 1);
3277 }
3278
3279 if (i < 0)
3280 {
3281 return i;
3282 }
3283 }
3284
3285 return i;
3286 }
3287
3288 static int cgltf_parse_json_texture_view(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_texture_view* out_texture_view)
3289 {
3290 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3291
3292 out_texture_view->scale = 1.0f;
3293 cgltf_fill_float_array(out_texture_view->transform.scale, 2, 1.0f);
3294
3295 int size = tokens[i].size;
3296 ++i;
3297
3298 for (int j = 0; j < size; ++j)
3299 {
3300 CGLTF_CHECK_KEY(tokens[i]);
3301
3302 if (cgltf_json_strcmp(tokens + i, json_chunk, "index") == 0)
3303 {
3304 ++i;
3305 out_texture_view->texture = CGLTF_PTRINDEX(cgltf_texture, cgltf_json_to_int(tokens + i, json_chunk));
3306 ++i;
3307 }
3308 else if (cgltf_json_strcmp(tokens + i, json_chunk, "texCoord") == 0)
3309 {
3310 ++i;
3311 out_texture_view->texcoord = cgltf_json_to_int(tokens + i, json_chunk);
3312 ++i;
3313 }
3314 else if (cgltf_json_strcmp(tokens + i, json_chunk, "scale") == 0)
3315 {
3316 ++i;
3317 out_texture_view->scale = cgltf_json_to_float(tokens + i, json_chunk);
3318 ++i;
3319 }
3320 else if (cgltf_json_strcmp(tokens + i, json_chunk, "strength") == 0)
3321 {
3322 ++i;
3323 out_texture_view->scale = cgltf_json_to_float(tokens + i, json_chunk);
3324 ++i;
3325 }
3326 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
3327 {
3328 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_texture_view->extras);
3329 }
3330 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
3331 {
3332 ++i;
3333
3334 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3335 if(out_texture_view->extensions)
3336 {
3337 return CGLTF_ERROR_JSON;
3338 }
3339
3340 int extensions_size = tokens[i].size;
3341 out_texture_view->extensions_count = 0;
3342 out_texture_view->extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
3343
3344 if (!out_texture_view->extensions)
3345 {
3346 return CGLTF_ERROR_NOMEM;
3347 }
3348
3349 ++i;
3350
3351 for (int k = 0; k < extensions_size; ++k)
3352 {
3353 CGLTF_CHECK_KEY(tokens[i]);
3354
3355 if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_texture_transform") == 0)
3356 {
3357 out_texture_view->has_transform = 1;
3358 i = cgltf_parse_json_texture_transform(tokens, i + 1, json_chunk, &out_texture_view->transform);
3359 }
3360 else
3361 {
3362 i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_texture_view->extensions[out_texture_view->extensions_count++]));
3363 }
3364
3365 if (i < 0)
3366 {
3367 return i;
3368 }
3369 }
3370 }
3371 else
3372 {
3373 i = cgltf_skip_json(tokens, i + 1);
3374 }
3375
3376 if (i < 0)
3377 {
3378 return i;
3379 }
3380 }
3381
3382 return i;
3383 }
3384
3385 static int cgltf_parse_json_pbr_metallic_roughness(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_pbr_metallic_roughness* out_pbr)
3386 {
3387 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3388
3389 int size = tokens[i].size;
3390 ++i;
3391
3392 for (int j = 0; j < size; ++j)
3393 {
3394 CGLTF_CHECK_KEY(tokens[i]);
3395
3396 if (cgltf_json_strcmp(tokens+i, json_chunk, "metallicFactor") == 0)
3397 {
3398 ++i;
3399 out_pbr->metallic_factor =
3400 cgltf_json_to_float(tokens + i, json_chunk);
3401 ++i;
3402 }
3403 else if (cgltf_json_strcmp(tokens+i, json_chunk, "roughnessFactor") == 0)
3404 {
3405 ++i;
3406 out_pbr->roughness_factor =
3407 cgltf_json_to_float(tokens+i, json_chunk);
3408 ++i;
3409 }
3410 else if (cgltf_json_strcmp(tokens+i, json_chunk, "baseColorFactor") == 0)
3411 {
3412 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_pbr->base_color_factor, 4);
3413 }
3414 else if (cgltf_json_strcmp(tokens+i, json_chunk, "baseColorTexture") == 0)
3415 {
3416 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk,
3417 &out_pbr->base_color_texture);
3418 }
3419 else if (cgltf_json_strcmp(tokens + i, json_chunk, "metallicRoughnessTexture") == 0)
3420 {
3421 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk,
3422 &out_pbr->metallic_roughness_texture);
3423 }
3424 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
3425 {
3426 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_pbr->extras);
3427 }
3428 else
3429 {
3430 i = cgltf_skip_json(tokens, i+1);
3431 }
3432
3433 if (i < 0)
3434 {
3435 return i;
3436 }
3437 }
3438
3439 return i;
3440 }
3441
3442 static int cgltf_parse_json_pbr_specular_glossiness(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_pbr_specular_glossiness* out_pbr)
3443 {
3444 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3445 int size = tokens[i].size;
3446 ++i;
3447
3448 for (int j = 0; j < size; ++j)
3449 {
3450 CGLTF_CHECK_KEY(tokens[i]);
3451
3452 if (cgltf_json_strcmp(tokens+i, json_chunk, "diffuseFactor") == 0)
3453 {
3454 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_pbr->diffuse_factor, 4);
3455 }
3456 else if (cgltf_json_strcmp(tokens+i, json_chunk, "specularFactor") == 0)
3457 {
3458 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_pbr->specular_factor, 3);
3459 }
3460 else if (cgltf_json_strcmp(tokens+i, json_chunk, "glossinessFactor") == 0)
3461 {
3462 ++i;
3463 out_pbr->glossiness_factor = cgltf_json_to_float(tokens + i, json_chunk);
3464 ++i;
3465 }
3466 else if (cgltf_json_strcmp(tokens+i, json_chunk, "diffuseTexture") == 0)
3467 {
3468 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_pbr->diffuse_texture);
3469 }
3470 else if (cgltf_json_strcmp(tokens+i, json_chunk, "specularGlossinessTexture") == 0)
3471 {
3472 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_pbr->specular_glossiness_texture);
3473 }
3474 else
3475 {
3476 i = cgltf_skip_json(tokens, i+1);
3477 }
3478
3479 if (i < 0)
3480 {
3481 return i;
3482 }
3483 }
3484
3485 return i;
3486 }
3487
3488 static int cgltf_parse_json_clearcoat(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_clearcoat* out_clearcoat)
3489 {
3490 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3491 int size = tokens[i].size;
3492 ++i;
3493
3494 for (int j = 0; j < size; ++j)
3495 {
3496 CGLTF_CHECK_KEY(tokens[i]);
3497
3498 if (cgltf_json_strcmp(tokens+i, json_chunk, "clearcoatFactor") == 0)
3499 {
3500 ++i;
3501 out_clearcoat->clearcoat_factor = cgltf_json_to_float(tokens + i, json_chunk);
3502 ++i;
3503 }
3504 else if (cgltf_json_strcmp(tokens+i, json_chunk, "clearcoatRoughnessFactor") == 0)
3505 {
3506 ++i;
3507 out_clearcoat->clearcoat_roughness_factor = cgltf_json_to_float(tokens + i, json_chunk);
3508 ++i;
3509 }
3510 else if (cgltf_json_strcmp(tokens+i, json_chunk, "clearcoatTexture") == 0)
3511 {
3512 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_clearcoat->clearcoat_texture);
3513 }
3514 else if (cgltf_json_strcmp(tokens+i, json_chunk, "clearcoatRoughnessTexture") == 0)
3515 {
3516 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_clearcoat->clearcoat_roughness_texture);
3517 }
3518 else if (cgltf_json_strcmp(tokens+i, json_chunk, "clearcoatNormalTexture") == 0)
3519 {
3520 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_clearcoat->clearcoat_normal_texture);
3521 }
3522 else
3523 {
3524 i = cgltf_skip_json(tokens, i+1);
3525 }
3526
3527 if (i < 0)
3528 {
3529 return i;
3530 }
3531 }
3532
3533 return i;
3534 }
3535
3536 static int cgltf_parse_json_ior(jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_ior* out_ior)
3537 {
3538 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3539 int size = tokens[i].size;
3540 ++i;
3541
3542 // Default values
3543 out_ior->ior = 1.5f;
3544
3545 for (int j = 0; j < size; ++j)
3546 {
3547 CGLTF_CHECK_KEY(tokens[i]);
3548
3549 if (cgltf_json_strcmp(tokens+i, json_chunk, "ior") == 0)
3550 {
3551 ++i;
3552 out_ior->ior = cgltf_json_to_float(tokens + i, json_chunk);
3553 ++i;
3554 }
3555 else
3556 {
3557 i = cgltf_skip_json(tokens, i+1);
3558 }
3559
3560 if (i < 0)
3561 {
3562 return i;
3563 }
3564 }
3565
3566 return i;
3567 }
3568
3569 static int cgltf_parse_json_specular(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_specular* out_specular)
3570 {
3571 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3572 int size = tokens[i].size;
3573 ++i;
3574
3575 // Default values
3576 out_specular->specular_factor = 1.0f;
3577 cgltf_fill_float_array(out_specular->specular_color_factor, 3, 1.0f);
3578
3579 for (int j = 0; j < size; ++j)
3580 {
3581 CGLTF_CHECK_KEY(tokens[i]);
3582
3583 if (cgltf_json_strcmp(tokens+i, json_chunk, "specularFactor") == 0)
3584 {
3585 ++i;
3586 out_specular->specular_factor = cgltf_json_to_float(tokens + i, json_chunk);
3587 ++i;
3588 }
3589 else if (cgltf_json_strcmp(tokens+i, json_chunk, "specularColorFactor") == 0)
3590 {
3591 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_specular->specular_color_factor, 3);
3592 }
3593 else if (cgltf_json_strcmp(tokens+i, json_chunk, "specularTexture") == 0)
3594 {
3595 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_specular->specular_texture);
3596 }
3597 else if (cgltf_json_strcmp(tokens + i, json_chunk, "specularColorTexture") == 0)
3598 {
3599 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_specular->specular_color_texture);
3600 }
3601 else
3602 {
3603 i = cgltf_skip_json(tokens, i+1);
3604 }
3605
3606 if (i < 0)
3607 {
3608 return i;
3609 }
3610 }
3611
3612 return i;
3613 }
3614
3615 static int cgltf_parse_json_transmission(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_transmission* out_transmission)
3616 {
3617 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3618 int size = tokens[i].size;
3619 ++i;
3620
3621 for (int j = 0; j < size; ++j)
3622 {
3623 CGLTF_CHECK_KEY(tokens[i]);
3624
3625 if (cgltf_json_strcmp(tokens+i, json_chunk, "transmissionFactor") == 0)
3626 {
3627 ++i;
3628 out_transmission->transmission_factor = cgltf_json_to_float(tokens + i, json_chunk);
3629 ++i;
3630 }
3631 else if (cgltf_json_strcmp(tokens+i, json_chunk, "transmissionTexture") == 0)
3632 {
3633 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_transmission->transmission_texture);
3634 }
3635 else
3636 {
3637 i = cgltf_skip_json(tokens, i+1);
3638 }
3639
3640 if (i < 0)
3641 {
3642 return i;
3643 }
3644 }
3645
3646 return i;
3647 }
3648
3649 static int cgltf_parse_json_volume(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_volume* out_volume)
3650 {
3651 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3652 int size = tokens[i].size;
3653 ++i;
3654
3655 for (int j = 0; j < size; ++j)
3656 {
3657 CGLTF_CHECK_KEY(tokens[i]);
3658
3659 if (cgltf_json_strcmp(tokens + i, json_chunk, "thicknessFactor") == 0)
3660 {
3661 ++i;
3662 out_volume->thickness_factor = cgltf_json_to_float(tokens + i, json_chunk);
3663 ++i;
3664 }
3665 else if (cgltf_json_strcmp(tokens + i, json_chunk, "thicknessTexture") == 0)
3666 {
3667 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_volume->thickness_texture);
3668 }
3669 else if (cgltf_json_strcmp(tokens + i, json_chunk, "attenuationColor") == 0)
3670 {
3671 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_volume->attenuation_color, 3);
3672 }
3673 else if (cgltf_json_strcmp(tokens + i, json_chunk, "attenuationDistance") == 0)
3674 {
3675 ++i;
3676 out_volume->attenuation_distance = cgltf_json_to_float(tokens + i, json_chunk);
3677 ++i;
3678 }
3679 else
3680 {
3681 i = cgltf_skip_json(tokens, i + 1);
3682 }
3683
3684 if (i < 0)
3685 {
3686 return i;
3687 }
3688 }
3689
3690 return i;
3691 }
3692
3693 static int cgltf_parse_json_sheen(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_sheen* out_sheen)
3694 {
3695 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3696 int size = tokens[i].size;
3697 ++i;
3698
3699 for (int j = 0; j < size; ++j)
3700 {
3701 CGLTF_CHECK_KEY(tokens[i]);
3702
3703 if (cgltf_json_strcmp(tokens+i, json_chunk, "sheenColorFactor") == 0)
3704 {
3705 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_sheen->sheen_color_factor, 3);
3706 }
3707 else if (cgltf_json_strcmp(tokens+i, json_chunk, "sheenColorTexture") == 0)
3708 {
3709 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_sheen->sheen_color_texture);
3710 }
3711 else if (cgltf_json_strcmp(tokens+i, json_chunk, "sheenRoughnessFactor") == 0)
3712 {
3713 ++i;
3714 out_sheen->sheen_roughness_factor = cgltf_json_to_float(tokens + i, json_chunk);
3715 ++i;
3716 }
3717 else if (cgltf_json_strcmp(tokens+i, json_chunk, "sheenRoughnessTexture") == 0)
3718 {
3719 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk, &out_sheen->sheen_roughness_texture);
3720 }
3721 else
3722 {
3723 i = cgltf_skip_json(tokens, i+1);
3724 }
3725
3726 if (i < 0)
3727 {
3728 return i;
3729 }
3730 }
3731
3732 return i;
3733 }
3734
3735 static int cgltf_parse_json_image(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_image* out_image)
3736 {
3737 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3738
3739 int size = tokens[i].size;
3740 ++i;
3741
3742 for (int j = 0; j < size; ++j)
3743 {
3744 CGLTF_CHECK_KEY(tokens[i]);
3745
3746 if (cgltf_json_strcmp(tokens + i, json_chunk, "uri") == 0)
3747 {
3748 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_image->uri);
3749 }
3750 else if (cgltf_json_strcmp(tokens+i, json_chunk, "bufferView") == 0)
3751 {
3752 ++i;
3753 out_image->buffer_view = CGLTF_PTRINDEX(cgltf_buffer_view, cgltf_json_to_int(tokens + i, json_chunk));
3754 ++i;
3755 }
3756 else if (cgltf_json_strcmp(tokens + i, json_chunk, "mimeType") == 0)
3757 {
3758 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_image->mime_type);
3759 }
3760 else if (cgltf_json_strcmp(tokens + i, json_chunk, "name") == 0)
3761 {
3762 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_image->name);
3763 }
3764 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
3765 {
3766 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_image->extras);
3767 }
3768 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
3769 {
3770 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_image->extensions_count, &out_image->extensions);
3771 }
3772 else
3773 {
3774 i = cgltf_skip_json(tokens, i + 1);
3775 }
3776
3777 if (i < 0)
3778 {
3779 return i;
3780 }
3781 }
3782
3783 return i;
3784 }
3785
3786 static int cgltf_parse_json_sampler(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_sampler* out_sampler)
3787 {
3788 (void)options;
3789 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3790
3791 out_sampler->wrap_s = 10497;
3792 out_sampler->wrap_t = 10497;
3793
3794 int size = tokens[i].size;
3795 ++i;
3796
3797 for (int j = 0; j < size; ++j)
3798 {
3799 CGLTF_CHECK_KEY(tokens[i]);
3800
3801 if (cgltf_json_strcmp(tokens + i, json_chunk, "name") == 0)
3802 {
3803 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_sampler->name);
3804 }
3805 else if (cgltf_json_strcmp(tokens + i, json_chunk, "magFilter") == 0)
3806 {
3807 ++i;
3808 out_sampler->mag_filter
3809 = cgltf_json_to_int(tokens + i, json_chunk);
3810 ++i;
3811 }
3812 else if (cgltf_json_strcmp(tokens + i, json_chunk, "minFilter") == 0)
3813 {
3814 ++i;
3815 out_sampler->min_filter
3816 = cgltf_json_to_int(tokens + i, json_chunk);
3817 ++i;
3818 }
3819 else if (cgltf_json_strcmp(tokens + i, json_chunk, "wrapS") == 0)
3820 {
3821 ++i;
3822 out_sampler->wrap_s
3823 = cgltf_json_to_int(tokens + i, json_chunk);
3824 ++i;
3825 }
3826 else if (cgltf_json_strcmp(tokens + i, json_chunk, "wrapT") == 0)
3827 {
3828 ++i;
3829 out_sampler->wrap_t
3830 = cgltf_json_to_int(tokens + i, json_chunk);
3831 ++i;
3832 }
3833 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
3834 {
3835 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_sampler->extras);
3836 }
3837 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
3838 {
3839 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_sampler->extensions_count, &out_sampler->extensions);
3840 }
3841 else
3842 {
3843 i = cgltf_skip_json(tokens, i + 1);
3844 }
3845
3846 if (i < 0)
3847 {
3848 return i;
3849 }
3850 }
3851
3852 return i;
3853 }
3854
3855 static int cgltf_parse_json_texture(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_texture* out_texture)
3856 {
3857 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3858
3859 int size = tokens[i].size;
3860 ++i;
3861
3862 for (int j = 0; j < size; ++j)
3863 {
3864 CGLTF_CHECK_KEY(tokens[i]);
3865
3866 if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
3867 {
3868 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_texture->name);
3869 }
3870 else if (cgltf_json_strcmp(tokens + i, json_chunk, "sampler") == 0)
3871 {
3872 ++i;
3873 out_texture->sampler = CGLTF_PTRINDEX(cgltf_sampler, cgltf_json_to_int(tokens + i, json_chunk));
3874 ++i;
3875 }
3876 else if (cgltf_json_strcmp(tokens + i, json_chunk, "source") == 0)
3877 {
3878 ++i;
3879 out_texture->image = CGLTF_PTRINDEX(cgltf_image, cgltf_json_to_int(tokens + i, json_chunk));
3880 ++i;
3881 }
3882 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
3883 {
3884 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_texture->extras);
3885 }
3886 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
3887 {
3888 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_texture->extensions_count, &out_texture->extensions);
3889 }
3890 else
3891 {
3892 i = cgltf_skip_json(tokens, i + 1);
3893 }
3894
3895 if (i < 0)
3896 {
3897 return i;
3898 }
3899 }
3900
3901 return i;
3902 }
3903
3904 static int cgltf_parse_json_material(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_material* out_material)
3905 {
3906 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3907
3908 cgltf_fill_float_array(out_material->pbr_metallic_roughness.base_color_factor, 4, 1.0f);
3909 out_material->pbr_metallic_roughness.metallic_factor = 1.0f;
3910 out_material->pbr_metallic_roughness.roughness_factor = 1.0f;
3911
3912 cgltf_fill_float_array(out_material->pbr_specular_glossiness.diffuse_factor, 4, 1.0f);
3913 cgltf_fill_float_array(out_material->pbr_specular_glossiness.specular_factor, 3, 1.0f);
3914 out_material->pbr_specular_glossiness.glossiness_factor = 1.0f;
3915
3916 cgltf_fill_float_array(out_material->volume.attenuation_color, 3, 1.0f);
3917 out_material->volume.attenuation_distance = FLT_MAX;
3918
3919 out_material->alpha_cutoff = 0.5f;
3920
3921 int size = tokens[i].size;
3922 ++i;
3923
3924 for (int j = 0; j < size; ++j)
3925 {
3926 CGLTF_CHECK_KEY(tokens[i]);
3927
3928 if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
3929 {
3930 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_material->name);
3931 }
3932 else if (cgltf_json_strcmp(tokens+i, json_chunk, "pbrMetallicRoughness") == 0)
3933 {
3934 out_material->has_pbr_metallic_roughness = 1;
3935 i = cgltf_parse_json_pbr_metallic_roughness(options, tokens, i + 1, json_chunk, &out_material->pbr_metallic_roughness);
3936 }
3937 else if (cgltf_json_strcmp(tokens+i, json_chunk, "emissiveFactor") == 0)
3938 {
3939 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_material->emissive_factor, 3);
3940 }
3941 else if (cgltf_json_strcmp(tokens + i, json_chunk, "normalTexture") == 0)
3942 {
3943 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk,
3944 &out_material->normal_texture);
3945 }
3946 else if (cgltf_json_strcmp(tokens + i, json_chunk, "occlusionTexture") == 0)
3947 {
3948 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk,
3949 &out_material->occlusion_texture);
3950 }
3951 else if (cgltf_json_strcmp(tokens + i, json_chunk, "emissiveTexture") == 0)
3952 {
3953 i = cgltf_parse_json_texture_view(options, tokens, i + 1, json_chunk,
3954 &out_material->emissive_texture);
3955 }
3956 else if (cgltf_json_strcmp(tokens + i, json_chunk, "alphaMode") == 0)
3957 {
3958 ++i;
3959 if (cgltf_json_strcmp(tokens + i, json_chunk, "OPAQUE") == 0)
3960 {
3961 out_material->alpha_mode = cgltf_alpha_mode_opaque;
3962 }
3963 else if (cgltf_json_strcmp(tokens + i, json_chunk, "MASK") == 0)
3964 {
3965 out_material->alpha_mode = cgltf_alpha_mode_mask;
3966 }
3967 else if (cgltf_json_strcmp(tokens + i, json_chunk, "BLEND") == 0)
3968 {
3969 out_material->alpha_mode = cgltf_alpha_mode_blend;
3970 }
3971 ++i;
3972 }
3973 else if (cgltf_json_strcmp(tokens + i, json_chunk, "alphaCutoff") == 0)
3974 {
3975 ++i;
3976 out_material->alpha_cutoff = cgltf_json_to_float(tokens + i, json_chunk);
3977 ++i;
3978 }
3979 else if (cgltf_json_strcmp(tokens + i, json_chunk, "doubleSided") == 0)
3980 {
3981 ++i;
3982 out_material->double_sided =
3983 cgltf_json_to_bool(tokens + i, json_chunk);
3984 ++i;
3985 }
3986 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
3987 {
3988 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_material->extras);
3989 }
3990 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
3991 {
3992 ++i;
3993
3994 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
3995 if(out_material->extensions)
3996 {
3997 return CGLTF_ERROR_JSON;
3998 }
3999
4000 int extensions_size = tokens[i].size;
4001 ++i;
4002 out_material->extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
4003 out_material->extensions_count= 0;
4004
4005 if (!out_material->extensions)
4006 {
4007 return CGLTF_ERROR_NOMEM;
4008 }
4009
4010 for (int k = 0; k < extensions_size; ++k)
4011 {
4012 CGLTF_CHECK_KEY(tokens[i]);
4013
4014 if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_pbrSpecularGlossiness") == 0)
4015 {
4016 out_material->has_pbr_specular_glossiness = 1;
4017 i = cgltf_parse_json_pbr_specular_glossiness(options, tokens, i + 1, json_chunk, &out_material->pbr_specular_glossiness);
4018 }
4019 else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_unlit") == 0)
4020 {
4021 out_material->unlit = 1;
4022 i = cgltf_skip_json(tokens, i+1);
4023 }
4024 else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_clearcoat") == 0)
4025 {
4026 out_material->has_clearcoat = 1;
4027 i = cgltf_parse_json_clearcoat(options, tokens, i + 1, json_chunk, &out_material->clearcoat);
4028 }
4029 else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_ior") == 0)
4030 {
4031 out_material->has_ior = 1;
4032 i = cgltf_parse_json_ior(tokens, i + 1, json_chunk, &out_material->ior);
4033 }
4034 else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_specular") == 0)
4035 {
4036 out_material->has_specular = 1;
4037 i = cgltf_parse_json_specular(options, tokens, i + 1, json_chunk, &out_material->specular);
4038 }
4039 else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_transmission") == 0)
4040 {
4041 out_material->has_transmission = 1;
4042 i = cgltf_parse_json_transmission(options, tokens, i + 1, json_chunk, &out_material->transmission);
4043 }
4044 else if (cgltf_json_strcmp(tokens + i, json_chunk, "KHR_materials_volume") == 0)
4045 {
4046 out_material->has_volume = 1;
4047 i = cgltf_parse_json_volume(options, tokens, i + 1, json_chunk, &out_material->volume);
4048 }
4049 else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_sheen") == 0)
4050 {
4051 out_material->has_sheen = 1;
4052 i = cgltf_parse_json_sheen(options, tokens, i + 1, json_chunk, &out_material->sheen);
4053 }
4054 else
4055 {
4056 i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_material->extensions[out_material->extensions_count++]));
4057 }
4058
4059 if (i < 0)
4060 {
4061 return i;
4062 }
4063 }
4064 }
4065 else
4066 {
4067 i = cgltf_skip_json(tokens, i+1);
4068 }
4069
4070 if (i < 0)
4071 {
4072 return i;
4073 }
4074 }
4075
4076 return i;
4077 }
4078
4079 static int cgltf_parse_json_accessors(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
4080 {
4081 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_accessor), (void**)&out_data->accessors, &out_data->accessors_count);
4082 if (i < 0)
4083 {
4084 return i;
4085 }
4086
4087 for (cgltf_size j = 0; j < out_data->accessors_count; ++j)
4088 {
4089 i = cgltf_parse_json_accessor(options, tokens, i, json_chunk, &out_data->accessors[j]);
4090 if (i < 0)
4091 {
4092 return i;
4093 }
4094 }
4095 return i;
4096 }
4097
4098 static int cgltf_parse_json_materials(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
4099 {
4100 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_material), (void**)&out_data->materials, &out_data->materials_count);
4101 if (i < 0)
4102 {
4103 return i;
4104 }
4105
4106 for (cgltf_size j = 0; j < out_data->materials_count; ++j)
4107 {
4108 i = cgltf_parse_json_material(options, tokens, i, json_chunk, &out_data->materials[j]);
4109 if (i < 0)
4110 {
4111 return i;
4112 }
4113 }
4114 return i;
4115 }
4116
4117 static int cgltf_parse_json_images(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
4118 {
4119 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_image), (void**)&out_data->images, &out_data->images_count);
4120 if (i < 0)
4121 {
4122 return i;
4123 }
4124
4125 for (cgltf_size j = 0; j < out_data->images_count; ++j)
4126 {
4127 i = cgltf_parse_json_image(options, tokens, i, json_chunk, &out_data->images[j]);
4128 if (i < 0)
4129 {
4130 return i;
4131 }
4132 }
4133 return i;
4134 }
4135
4136 static int cgltf_parse_json_textures(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
4137 {
4138 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_texture), (void**)&out_data->textures, &out_data->textures_count);
4139 if (i < 0)
4140 {
4141 return i;
4142 }
4143
4144 for (cgltf_size j = 0; j < out_data->textures_count; ++j)
4145 {
4146 i = cgltf_parse_json_texture(options, tokens, i, json_chunk, &out_data->textures[j]);
4147 if (i < 0)
4148 {
4149 return i;
4150 }
4151 }
4152 return i;
4153 }
4154
4155 static int cgltf_parse_json_samplers(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
4156 {
4157 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_sampler), (void**)&out_data->samplers, &out_data->samplers_count);
4158 if (i < 0)
4159 {
4160 return i;
4161 }
4162
4163 for (cgltf_size j = 0; j < out_data->samplers_count; ++j)
4164 {
4165 i = cgltf_parse_json_sampler(options, tokens, i, json_chunk, &out_data->samplers[j]);
4166 if (i < 0)
4167 {
4168 return i;
4169 }
4170 }
4171 return i;
4172 }
4173
4174 static int cgltf_parse_json_meshopt_compression(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_meshopt_compression* out_meshopt_compression)
4175 {
4176 (void)options;
4177 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4178
4179 int size = tokens[i].size;
4180 ++i;
4181
4182 for (int j = 0; j < size; ++j)
4183 {
4184 CGLTF_CHECK_KEY(tokens[i]);
4185
4186 if (cgltf_json_strcmp(tokens+i, json_chunk, "buffer") == 0)
4187 {
4188 ++i;
4189 out_meshopt_compression->buffer = CGLTF_PTRINDEX(cgltf_buffer, cgltf_json_to_int(tokens + i, json_chunk));
4190 ++i;
4191 }
4192 else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteOffset") == 0)
4193 {
4194 ++i;
4195 out_meshopt_compression->offset = cgltf_json_to_int(tokens+i, json_chunk);
4196 ++i;
4197 }
4198 else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteLength") == 0)
4199 {
4200 ++i;
4201 out_meshopt_compression->size = cgltf_json_to_int(tokens+i, json_chunk);
4202 ++i;
4203 }
4204 else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteStride") == 0)
4205 {
4206 ++i;
4207 out_meshopt_compression->stride = cgltf_json_to_int(tokens+i, json_chunk);
4208 ++i;
4209 }
4210 else if (cgltf_json_strcmp(tokens+i, json_chunk, "count") == 0)
4211 {
4212 ++i;
4213 out_meshopt_compression->count = cgltf_json_to_int(tokens+i, json_chunk);
4214 ++i;
4215 }
4216 else if (cgltf_json_strcmp(tokens+i, json_chunk, "mode") == 0)
4217 {
4218 ++i;
4219 if (cgltf_json_strcmp(tokens+i, json_chunk, "ATTRIBUTES") == 0)
4220 {
4221 out_meshopt_compression->mode = cgltf_meshopt_compression_mode_attributes;
4222 }
4223 else if (cgltf_json_strcmp(tokens+i, json_chunk, "TRIANGLES") == 0)
4224 {
4225 out_meshopt_compression->mode = cgltf_meshopt_compression_mode_triangles;
4226 }
4227 else if (cgltf_json_strcmp(tokens+i, json_chunk, "INDICES") == 0)
4228 {
4229 out_meshopt_compression->mode = cgltf_meshopt_compression_mode_indices;
4230 }
4231 ++i;
4232 }
4233 else if (cgltf_json_strcmp(tokens+i, json_chunk, "filter") == 0)
4234 {
4235 ++i;
4236 if (cgltf_json_strcmp(tokens+i, json_chunk, "NONE") == 0)
4237 {
4238 out_meshopt_compression->filter = cgltf_meshopt_compression_filter_none;
4239 }
4240 else if (cgltf_json_strcmp(tokens+i, json_chunk, "OCTAHEDRAL") == 0)
4241 {
4242 out_meshopt_compression->filter = cgltf_meshopt_compression_filter_octahedral;
4243 }
4244 else if (cgltf_json_strcmp(tokens+i, json_chunk, "QUATERNION") == 0)
4245 {
4246 out_meshopt_compression->filter = cgltf_meshopt_compression_filter_quaternion;
4247 }
4248 else if (cgltf_json_strcmp(tokens+i, json_chunk, "EXPONENTIAL") == 0)
4249 {
4250 out_meshopt_compression->filter = cgltf_meshopt_compression_filter_exponential;
4251 }
4252 ++i;
4253 }
4254 else
4255 {
4256 i = cgltf_skip_json(tokens, i+1);
4257 }
4258
4259 if (i < 0)
4260 {
4261 return i;
4262 }
4263 }
4264
4265 return i;
4266 }
4267
4268 static int cgltf_parse_json_buffer_view(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_buffer_view* out_buffer_view)
4269 {
4270 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4271
4272 int size = tokens[i].size;
4273 ++i;
4274
4275 for (int j = 0; j < size; ++j)
4276 {
4277 CGLTF_CHECK_KEY(tokens[i]);
4278
4279 if (cgltf_json_strcmp(tokens + i, json_chunk, "name") == 0)
4280 {
4281 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_buffer_view->name);
4282 }
4283 else if (cgltf_json_strcmp(tokens+i, json_chunk, "buffer") == 0)
4284 {
4285 ++i;
4286 out_buffer_view->buffer = CGLTF_PTRINDEX(cgltf_buffer, cgltf_json_to_int(tokens + i, json_chunk));
4287 ++i;
4288 }
4289 else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteOffset") == 0)
4290 {
4291 ++i;
4292 out_buffer_view->offset =
4293 cgltf_json_to_int(tokens+i, json_chunk);
4294 ++i;
4295 }
4296 else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteLength") == 0)
4297 {
4298 ++i;
4299 out_buffer_view->size =
4300 cgltf_json_to_int(tokens+i, json_chunk);
4301 ++i;
4302 }
4303 else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteStride") == 0)
4304 {
4305 ++i;
4306 out_buffer_view->stride =
4307 cgltf_json_to_int(tokens+i, json_chunk);
4308 ++i;
4309 }
4310 else if (cgltf_json_strcmp(tokens+i, json_chunk, "target") == 0)
4311 {
4312 ++i;
4313 int type = cgltf_json_to_int(tokens+i, json_chunk);
4314 switch (type)
4315 {
4316 case 34962:
4317 type = cgltf_buffer_view_type_vertices;
4318 break;
4319 case 34963:
4320 type = cgltf_buffer_view_type_indices;
4321 break;
4322 default:
4323 type = cgltf_buffer_view_type_invalid;
4324 break;
4325 }
4326 out_buffer_view->type = (cgltf_buffer_view_type)type;
4327 ++i;
4328 }
4329 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
4330 {
4331 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_buffer_view->extras);
4332 }
4333 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
4334 {
4335 ++i;
4336
4337 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4338 if(out_buffer_view->extensions)
4339 {
4340 return CGLTF_ERROR_JSON;
4341 }
4342
4343 int extensions_size = tokens[i].size;
4344 out_buffer_view->extensions_count = 0;
4345 out_buffer_view->extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
4346
4347 if (!out_buffer_view->extensions)
4348 {
4349 return CGLTF_ERROR_NOMEM;
4350 }
4351
4352 ++i;
4353 for (int k = 0; k < extensions_size; ++k)
4354 {
4355 CGLTF_CHECK_KEY(tokens[i]);
4356
4357 if (cgltf_json_strcmp(tokens+i, json_chunk, "EXT_meshopt_compression") == 0)
4358 {
4359 out_buffer_view->has_meshopt_compression = 1;
4360 i = cgltf_parse_json_meshopt_compression(options, tokens, i + 1, json_chunk, &out_buffer_view->meshopt_compression);
4361 }
4362 else
4363 {
4364 i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_buffer_view->extensions[out_buffer_view->extensions_count++]));
4365 }
4366
4367 if (i < 0)
4368 {
4369 return i;
4370 }
4371 }
4372 }
4373 else
4374 {
4375 i = cgltf_skip_json(tokens, i+1);
4376 }
4377
4378 if (i < 0)
4379 {
4380 return i;
4381 }
4382 }
4383
4384 return i;
4385 }
4386
4387 static int cgltf_parse_json_buffer_views(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
4388 {
4389 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_buffer_view), (void**)&out_data->buffer_views, &out_data->buffer_views_count);
4390 if (i < 0)
4391 {
4392 return i;
4393 }
4394
4395 for (cgltf_size j = 0; j < out_data->buffer_views_count; ++j)
4396 {
4397 i = cgltf_parse_json_buffer_view(options, tokens, i, json_chunk, &out_data->buffer_views[j]);
4398 if (i < 0)
4399 {
4400 return i;
4401 }
4402 }
4403 return i;
4404 }
4405
4406 static int cgltf_parse_json_buffer(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_buffer* out_buffer)
4407 {
4408 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4409
4410 int size = tokens[i].size;
4411 ++i;
4412
4413 for (int j = 0; j < size; ++j)
4414 {
4415 CGLTF_CHECK_KEY(tokens[i]);
4416
4417 if (cgltf_json_strcmp(tokens + i, json_chunk, "name") == 0)
4418 {
4419 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_buffer->name);
4420 }
4421 else if (cgltf_json_strcmp(tokens+i, json_chunk, "byteLength") == 0)
4422 {
4423 ++i;
4424 out_buffer->size =
4425 cgltf_json_to_int(tokens+i, json_chunk);
4426 ++i;
4427 }
4428 else if (cgltf_json_strcmp(tokens+i, json_chunk, "uri") == 0)
4429 {
4430 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_buffer->uri);
4431 }
4432 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
4433 {
4434 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_buffer->extras);
4435 }
4436 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
4437 {
4438 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_buffer->extensions_count, &out_buffer->extensions);
4439 }
4440 else
4441 {
4442 i = cgltf_skip_json(tokens, i+1);
4443 }
4444
4445 if (i < 0)
4446 {
4447 return i;
4448 }
4449 }
4450
4451 return i;
4452 }
4453
4454 static int cgltf_parse_json_buffers(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
4455 {
4456 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_buffer), (void**)&out_data->buffers, &out_data->buffers_count);
4457 if (i < 0)
4458 {
4459 return i;
4460 }
4461
4462 for (cgltf_size j = 0; j < out_data->buffers_count; ++j)
4463 {
4464 i = cgltf_parse_json_buffer(options, tokens, i, json_chunk, &out_data->buffers[j]);
4465 if (i < 0)
4466 {
4467 return i;
4468 }
4469 }
4470 return i;
4471 }
4472
4473 static int cgltf_parse_json_skin(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_skin* out_skin)
4474 {
4475 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4476
4477 int size = tokens[i].size;
4478 ++i;
4479
4480 for (int j = 0; j < size; ++j)
4481 {
4482 CGLTF_CHECK_KEY(tokens[i]);
4483
4484 if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
4485 {
4486 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_skin->name);
4487 }
4488 else if (cgltf_json_strcmp(tokens+i, json_chunk, "joints") == 0)
4489 {
4490 i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_node*), (void**)&out_skin->joints, &out_skin->joints_count);
4491 if (i < 0)
4492 {
4493 return i;
4494 }
4495
4496 for (cgltf_size k = 0; k < out_skin->joints_count; ++k)
4497 {
4498 out_skin->joints[k] = CGLTF_PTRINDEX(cgltf_node, cgltf_json_to_int(tokens + i, json_chunk));
4499 ++i;
4500 }
4501 }
4502 else if (cgltf_json_strcmp(tokens+i, json_chunk, "skeleton") == 0)
4503 {
4504 ++i;
4505 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
4506 out_skin->skeleton = CGLTF_PTRINDEX(cgltf_node, cgltf_json_to_int(tokens + i, json_chunk));
4507 ++i;
4508 }
4509 else if (cgltf_json_strcmp(tokens+i, json_chunk, "inverseBindMatrices") == 0)
4510 {
4511 ++i;
4512 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
4513 out_skin->inverse_bind_matrices = CGLTF_PTRINDEX(cgltf_accessor, cgltf_json_to_int(tokens + i, json_chunk));
4514 ++i;
4515 }
4516 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
4517 {
4518 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_skin->extras);
4519 }
4520 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
4521 {
4522 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_skin->extensions_count, &out_skin->extensions);
4523 }
4524 else
4525 {
4526 i = cgltf_skip_json(tokens, i+1);
4527 }
4528
4529 if (i < 0)
4530 {
4531 return i;
4532 }
4533 }
4534
4535 return i;
4536 }
4537
4538 static int cgltf_parse_json_skins(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
4539 {
4540 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_skin), (void**)&out_data->skins, &out_data->skins_count);
4541 if (i < 0)
4542 {
4543 return i;
4544 }
4545
4546 for (cgltf_size j = 0; j < out_data->skins_count; ++j)
4547 {
4548 i = cgltf_parse_json_skin(options, tokens, i, json_chunk, &out_data->skins[j]);
4549 if (i < 0)
4550 {
4551 return i;
4552 }
4553 }
4554 return i;
4555 }
4556
4557 static int cgltf_parse_json_camera(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_camera* out_camera)
4558 {
4559 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4560
4561 int size = tokens[i].size;
4562 ++i;
4563
4564 for (int j = 0; j < size; ++j)
4565 {
4566 CGLTF_CHECK_KEY(tokens[i]);
4567
4568 if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
4569 {
4570 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_camera->name);
4571 }
4572 else if (cgltf_json_strcmp(tokens+i, json_chunk, "type") == 0)
4573 {
4574 ++i;
4575 if (cgltf_json_strcmp(tokens + i, json_chunk, "perspective") == 0)
4576 {
4577 out_camera->type = cgltf_camera_type_perspective;
4578 }
4579 else if (cgltf_json_strcmp(tokens + i, json_chunk, "orthographic") == 0)
4580 {
4581 out_camera->type = cgltf_camera_type_orthographic;
4582 }
4583 ++i;
4584 }
4585 else if (cgltf_json_strcmp(tokens+i, json_chunk, "perspective") == 0)
4586 {
4587 ++i;
4588
4589 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4590
4591 int data_size = tokens[i].size;
4592 ++i;
4593
4594 out_camera->type = cgltf_camera_type_perspective;
4595
4596 for (int k = 0; k < data_size; ++k)
4597 {
4598 CGLTF_CHECK_KEY(tokens[i]);
4599
4600 if (cgltf_json_strcmp(tokens+i, json_chunk, "aspectRatio") == 0)
4601 {
4602 ++i;
4603 out_camera->data.perspective.has_aspect_ratio = 1;
4604 out_camera->data.perspective.aspect_ratio = cgltf_json_to_float(tokens + i, json_chunk);
4605 ++i;
4606 }
4607 else if (cgltf_json_strcmp(tokens+i, json_chunk, "yfov") == 0)
4608 {
4609 ++i;
4610 out_camera->data.perspective.yfov = cgltf_json_to_float(tokens + i, json_chunk);
4611 ++i;
4612 }
4613 else if (cgltf_json_strcmp(tokens+i, json_chunk, "zfar") == 0)
4614 {
4615 ++i;
4616 out_camera->data.perspective.has_zfar = 1;
4617 out_camera->data.perspective.zfar = cgltf_json_to_float(tokens + i, json_chunk);
4618 ++i;
4619 }
4620 else if (cgltf_json_strcmp(tokens+i, json_chunk, "znear") == 0)
4621 {
4622 ++i;
4623 out_camera->data.perspective.znear = cgltf_json_to_float(tokens + i, json_chunk);
4624 ++i;
4625 }
4626 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
4627 {
4628 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_camera->data.perspective.extras);
4629 }
4630 else
4631 {
4632 i = cgltf_skip_json(tokens, i+1);
4633 }
4634
4635 if (i < 0)
4636 {
4637 return i;
4638 }
4639 }
4640 }
4641 else if (cgltf_json_strcmp(tokens+i, json_chunk, "orthographic") == 0)
4642 {
4643 ++i;
4644
4645 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4646
4647 int data_size = tokens[i].size;
4648 ++i;
4649
4650 out_camera->type = cgltf_camera_type_orthographic;
4651
4652 for (int k = 0; k < data_size; ++k)
4653 {
4654 CGLTF_CHECK_KEY(tokens[i]);
4655
4656 if (cgltf_json_strcmp(tokens+i, json_chunk, "xmag") == 0)
4657 {
4658 ++i;
4659 out_camera->data.orthographic.xmag = cgltf_json_to_float(tokens + i, json_chunk);
4660 ++i;
4661 }
4662 else if (cgltf_json_strcmp(tokens+i, json_chunk, "ymag") == 0)
4663 {
4664 ++i;
4665 out_camera->data.orthographic.ymag = cgltf_json_to_float(tokens + i, json_chunk);
4666 ++i;
4667 }
4668 else if (cgltf_json_strcmp(tokens+i, json_chunk, "zfar") == 0)
4669 {
4670 ++i;
4671 out_camera->data.orthographic.zfar = cgltf_json_to_float(tokens + i, json_chunk);
4672 ++i;
4673 }
4674 else if (cgltf_json_strcmp(tokens+i, json_chunk, "znear") == 0)
4675 {
4676 ++i;
4677 out_camera->data.orthographic.znear = cgltf_json_to_float(tokens + i, json_chunk);
4678 ++i;
4679 }
4680 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
4681 {
4682 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_camera->data.orthographic.extras);
4683 }
4684 else
4685 {
4686 i = cgltf_skip_json(tokens, i+1);
4687 }
4688
4689 if (i < 0)
4690 {
4691 return i;
4692 }
4693 }
4694 }
4695 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
4696 {
4697 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_camera->extras);
4698 }
4699 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
4700 {
4701 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_camera->extensions_count, &out_camera->extensions);
4702 }
4703 else
4704 {
4705 i = cgltf_skip_json(tokens, i+1);
4706 }
4707
4708 if (i < 0)
4709 {
4710 return i;
4711 }
4712 }
4713
4714 return i;
4715 }
4716
4717 static int cgltf_parse_json_cameras(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
4718 {
4719 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_camera), (void**)&out_data->cameras, &out_data->cameras_count);
4720 if (i < 0)
4721 {
4722 return i;
4723 }
4724
4725 for (cgltf_size j = 0; j < out_data->cameras_count; ++j)
4726 {
4727 i = cgltf_parse_json_camera(options, tokens, i, json_chunk, &out_data->cameras[j]);
4728 if (i < 0)
4729 {
4730 return i;
4731 }
4732 }
4733 return i;
4734 }
4735
4736 static int cgltf_parse_json_light(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_light* out_light)
4737 {
4738 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4739
4740 int size = tokens[i].size;
4741 ++i;
4742
4743 for (int j = 0; j < size; ++j)
4744 {
4745 CGLTF_CHECK_KEY(tokens[i]);
4746
4747 if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
4748 {
4749 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_light->name);
4750 }
4751 else if (cgltf_json_strcmp(tokens + i, json_chunk, "color") == 0)
4752 {
4753 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_light->color, 3);
4754 }
4755 else if (cgltf_json_strcmp(tokens + i, json_chunk, "intensity") == 0)
4756 {
4757 ++i;
4758 out_light->intensity = cgltf_json_to_float(tokens + i, json_chunk);
4759 ++i;
4760 }
4761 else if (cgltf_json_strcmp(tokens+i, json_chunk, "type") == 0)
4762 {
4763 ++i;
4764 if (cgltf_json_strcmp(tokens + i, json_chunk, "directional") == 0)
4765 {
4766 out_light->type = cgltf_light_type_directional;
4767 }
4768 else if (cgltf_json_strcmp(tokens + i, json_chunk, "point") == 0)
4769 {
4770 out_light->type = cgltf_light_type_point;
4771 }
4772 else if (cgltf_json_strcmp(tokens + i, json_chunk, "spot") == 0)
4773 {
4774 out_light->type = cgltf_light_type_spot;
4775 }
4776 ++i;
4777 }
4778 else if (cgltf_json_strcmp(tokens + i, json_chunk, "range") == 0)
4779 {
4780 ++i;
4781 out_light->range = cgltf_json_to_float(tokens + i, json_chunk);
4782 ++i;
4783 }
4784 else if (cgltf_json_strcmp(tokens+i, json_chunk, "spot") == 0)
4785 {
4786 ++i;
4787
4788 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4789
4790 int data_size = tokens[i].size;
4791 ++i;
4792
4793 for (int k = 0; k < data_size; ++k)
4794 {
4795 CGLTF_CHECK_KEY(tokens[i]);
4796
4797 if (cgltf_json_strcmp(tokens+i, json_chunk, "innerConeAngle") == 0)
4798 {
4799 ++i;
4800 out_light->spot_inner_cone_angle = cgltf_json_to_float(tokens + i, json_chunk);
4801 ++i;
4802 }
4803 else if (cgltf_json_strcmp(tokens+i, json_chunk, "outerConeAngle") == 0)
4804 {
4805 ++i;
4806 out_light->spot_outer_cone_angle = cgltf_json_to_float(tokens + i, json_chunk);
4807 ++i;
4808 }
4809 else
4810 {
4811 i = cgltf_skip_json(tokens, i+1);
4812 }
4813
4814 if (i < 0)
4815 {
4816 return i;
4817 }
4818 }
4819 }
4820 else
4821 {
4822 i = cgltf_skip_json(tokens, i+1);
4823 }
4824
4825 if (i < 0)
4826 {
4827 return i;
4828 }
4829 }
4830
4831 return i;
4832 }
4833
4834 static int cgltf_parse_json_lights(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
4835 {
4836 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_light), (void**)&out_data->lights, &out_data->lights_count);
4837 if (i < 0)
4838 {
4839 return i;
4840 }
4841
4842 for (cgltf_size j = 0; j < out_data->lights_count; ++j)
4843 {
4844 i = cgltf_parse_json_light(options, tokens, i, json_chunk, &out_data->lights[j]);
4845 if (i < 0)
4846 {
4847 return i;
4848 }
4849 }
4850 return i;
4851 }
4852
4853 static int cgltf_parse_json_node(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_node* out_node)
4854 {
4855 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4856
4857 out_node->rotation[3] = 1.0f;
4858 out_node->scale[0] = 1.0f;
4859 out_node->scale[1] = 1.0f;
4860 out_node->scale[2] = 1.0f;
4861 out_node->matrix[0] = 1.0f;
4862 out_node->matrix[5] = 1.0f;
4863 out_node->matrix[10] = 1.0f;
4864 out_node->matrix[15] = 1.0f;
4865
4866 int size = tokens[i].size;
4867 ++i;
4868
4869 for (int j = 0; j < size; ++j)
4870 {
4871 CGLTF_CHECK_KEY(tokens[i]);
4872
4873 if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
4874 {
4875 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_node->name);
4876 }
4877 else if (cgltf_json_strcmp(tokens+i, json_chunk, "children") == 0)
4878 {
4879 i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_node*), (void**)&out_node->children, &out_node->children_count);
4880 if (i < 0)
4881 {
4882 return i;
4883 }
4884
4885 for (cgltf_size k = 0; k < out_node->children_count; ++k)
4886 {
4887 out_node->children[k] = CGLTF_PTRINDEX(cgltf_node, cgltf_json_to_int(tokens + i, json_chunk));
4888 ++i;
4889 }
4890 }
4891 else if (cgltf_json_strcmp(tokens+i, json_chunk, "mesh") == 0)
4892 {
4893 ++i;
4894 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
4895 out_node->mesh = CGLTF_PTRINDEX(cgltf_mesh, cgltf_json_to_int(tokens + i, json_chunk));
4896 ++i;
4897 }
4898 else if (cgltf_json_strcmp(tokens+i, json_chunk, "skin") == 0)
4899 {
4900 ++i;
4901 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
4902 out_node->skin = CGLTF_PTRINDEX(cgltf_skin, cgltf_json_to_int(tokens + i, json_chunk));
4903 ++i;
4904 }
4905 else if (cgltf_json_strcmp(tokens+i, json_chunk, "camera") == 0)
4906 {
4907 ++i;
4908 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
4909 out_node->camera = CGLTF_PTRINDEX(cgltf_camera, cgltf_json_to_int(tokens + i, json_chunk));
4910 ++i;
4911 }
4912 else if (cgltf_json_strcmp(tokens+i, json_chunk, "translation") == 0)
4913 {
4914 out_node->has_translation = 1;
4915 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_node->translation, 3);
4916 }
4917 else if (cgltf_json_strcmp(tokens+i, json_chunk, "rotation") == 0)
4918 {
4919 out_node->has_rotation = 1;
4920 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_node->rotation, 4);
4921 }
4922 else if (cgltf_json_strcmp(tokens+i, json_chunk, "scale") == 0)
4923 {
4924 out_node->has_scale = 1;
4925 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_node->scale, 3);
4926 }
4927 else if (cgltf_json_strcmp(tokens+i, json_chunk, "matrix") == 0)
4928 {
4929 out_node->has_matrix = 1;
4930 i = cgltf_parse_json_float_array(tokens, i + 1, json_chunk, out_node->matrix, 16);
4931 }
4932 else if (cgltf_json_strcmp(tokens + i, json_chunk, "weights") == 0)
4933 {
4934 i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_float), (void**)&out_node->weights, &out_node->weights_count);
4935 if (i < 0)
4936 {
4937 return i;
4938 }
4939
4940 i = cgltf_parse_json_float_array(tokens, i - 1, json_chunk, out_node->weights, (int)out_node->weights_count);
4941 }
4942 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
4943 {
4944 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_node->extras);
4945 }
4946 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
4947 {
4948 ++i;
4949
4950 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4951 if(out_node->extensions)
4952 {
4953 return CGLTF_ERROR_JSON;
4954 }
4955
4956 int extensions_size = tokens[i].size;
4957 out_node->extensions_count= 0;
4958 out_node->extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
4959
4960 if (!out_node->extensions)
4961 {
4962 return CGLTF_ERROR_NOMEM;
4963 }
4964
4965 ++i;
4966
4967 for (int k = 0; k < extensions_size; ++k)
4968 {
4969 CGLTF_CHECK_KEY(tokens[i]);
4970
4971 if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_lights_punctual") == 0)
4972 {
4973 ++i;
4974
4975 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
4976
4977 int data_size = tokens[i].size;
4978 ++i;
4979
4980 for (int m = 0; m < data_size; ++m)
4981 {
4982 CGLTF_CHECK_KEY(tokens[i]);
4983
4984 if (cgltf_json_strcmp(tokens + i, json_chunk, "light") == 0)
4985 {
4986 ++i;
4987 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
4988 out_node->light = CGLTF_PTRINDEX(cgltf_light, cgltf_json_to_int(tokens + i, json_chunk));
4989 ++i;
4990 }
4991 else
4992 {
4993 i = cgltf_skip_json(tokens, i + 1);
4994 }
4995
4996 if (i < 0)
4997 {
4998 return i;
4999 }
5000 }
5001 }
5002 else
5003 {
5004 i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_node->extensions[out_node->extensions_count++]));
5005 }
5006
5007 if (i < 0)
5008 {
5009 return i;
5010 }
5011 }
5012 }
5013 else
5014 {
5015 i = cgltf_skip_json(tokens, i+1);
5016 }
5017
5018 if (i < 0)
5019 {
5020 return i;
5021 }
5022 }
5023
5024 return i;
5025 }
5026
5027 static int cgltf_parse_json_nodes(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
5028 {
5029 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_node), (void**)&out_data->nodes, &out_data->nodes_count);
5030 if (i < 0)
5031 {
5032 return i;
5033 }
5034
5035 for (cgltf_size j = 0; j < out_data->nodes_count; ++j)
5036 {
5037 i = cgltf_parse_json_node(options, tokens, i, json_chunk, &out_data->nodes[j]);
5038 if (i < 0)
5039 {
5040 return i;
5041 }
5042 }
5043 return i;
5044 }
5045
5046 static int cgltf_parse_json_scene(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_scene* out_scene)
5047 {
5048 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
5049
5050 int size = tokens[i].size;
5051 ++i;
5052
5053 for (int j = 0; j < size; ++j)
5054 {
5055 CGLTF_CHECK_KEY(tokens[i]);
5056
5057 if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
5058 {
5059 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_scene->name);
5060 }
5061 else if (cgltf_json_strcmp(tokens+i, json_chunk, "nodes") == 0)
5062 {
5063 i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_node*), (void**)&out_scene->nodes, &out_scene->nodes_count);
5064 if (i < 0)
5065 {
5066 return i;
5067 }
5068
5069 for (cgltf_size k = 0; k < out_scene->nodes_count; ++k)
5070 {
5071 out_scene->nodes[k] = CGLTF_PTRINDEX(cgltf_node, cgltf_json_to_int(tokens + i, json_chunk));
5072 ++i;
5073 }
5074 }
5075 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
5076 {
5077 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_scene->extras);
5078 }
5079 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
5080 {
5081 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_scene->extensions_count, &out_scene->extensions);
5082 }
5083 else
5084 {
5085 i = cgltf_skip_json(tokens, i+1);
5086 }
5087
5088 if (i < 0)
5089 {
5090 return i;
5091 }
5092 }
5093
5094 return i;
5095 }
5096
5097 static int cgltf_parse_json_scenes(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
5098 {
5099 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_scene), (void**)&out_data->scenes, &out_data->scenes_count);
5100 if (i < 0)
5101 {
5102 return i;
5103 }
5104
5105 for (cgltf_size j = 0; j < out_data->scenes_count; ++j)
5106 {
5107 i = cgltf_parse_json_scene(options, tokens, i, json_chunk, &out_data->scenes[j]);
5108 if (i < 0)
5109 {
5110 return i;
5111 }
5112 }
5113 return i;
5114 }
5115
5116 static int cgltf_parse_json_animation_sampler(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_animation_sampler* out_sampler)
5117 {
5118 (void)options;
5119 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
5120
5121 int size = tokens[i].size;
5122 ++i;
5123
5124 for (int j = 0; j < size; ++j)
5125 {
5126 CGLTF_CHECK_KEY(tokens[i]);
5127
5128 if (cgltf_json_strcmp(tokens+i, json_chunk, "input") == 0)
5129 {
5130 ++i;
5131 out_sampler->input = CGLTF_PTRINDEX(cgltf_accessor, cgltf_json_to_int(tokens + i, json_chunk));
5132 ++i;
5133 }
5134 else if (cgltf_json_strcmp(tokens+i, json_chunk, "output") == 0)
5135 {
5136 ++i;
5137 out_sampler->output = CGLTF_PTRINDEX(cgltf_accessor, cgltf_json_to_int(tokens + i, json_chunk));
5138 ++i;
5139 }
5140 else if (cgltf_json_strcmp(tokens+i, json_chunk, "interpolation") == 0)
5141 {
5142 ++i;
5143 if (cgltf_json_strcmp(tokens + i, json_chunk, "LINEAR") == 0)
5144 {
5145 out_sampler->interpolation = cgltf_interpolation_type_linear;
5146 }
5147 else if (cgltf_json_strcmp(tokens + i, json_chunk, "STEP") == 0)
5148 {
5149 out_sampler->interpolation = cgltf_interpolation_type_step;
5150 }
5151 else if (cgltf_json_strcmp(tokens + i, json_chunk, "CUBICSPLINE") == 0)
5152 {
5153 out_sampler->interpolation = cgltf_interpolation_type_cubic_spline;
5154 }
5155 ++i;
5156 }
5157 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
5158 {
5159 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_sampler->extras);
5160 }
5161 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
5162 {
5163 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_sampler->extensions_count, &out_sampler->extensions);
5164 }
5165 else
5166 {
5167 i = cgltf_skip_json(tokens, i+1);
5168 }
5169
5170 if (i < 0)
5171 {
5172 return i;
5173 }
5174 }
5175
5176 return i;
5177 }
5178
5179 static int cgltf_parse_json_animation_channel(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_animation_channel* out_channel)
5180 {
5181 (void)options;
5182 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
5183
5184 int size = tokens[i].size;
5185 ++i;
5186
5187 for (int j = 0; j < size; ++j)
5188 {
5189 CGLTF_CHECK_KEY(tokens[i]);
5190
5191 if (cgltf_json_strcmp(tokens+i, json_chunk, "sampler") == 0)
5192 {
5193 ++i;
5194 out_channel->sampler = CGLTF_PTRINDEX(cgltf_animation_sampler, cgltf_json_to_int(tokens + i, json_chunk));
5195 ++i;
5196 }
5197 else if (cgltf_json_strcmp(tokens+i, json_chunk, "target") == 0)
5198 {
5199 ++i;
5200
5201 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
5202
5203 int target_size = tokens[i].size;
5204 ++i;
5205
5206 for (int k = 0; k < target_size; ++k)
5207 {
5208 CGLTF_CHECK_KEY(tokens[i]);
5209
5210 if (cgltf_json_strcmp(tokens+i, json_chunk, "node") == 0)
5211 {
5212 ++i;
5213 out_channel->target_node = CGLTF_PTRINDEX(cgltf_node, cgltf_json_to_int(tokens + i, json_chunk));
5214 ++i;
5215 }
5216 else if (cgltf_json_strcmp(tokens+i, json_chunk, "path") == 0)
5217 {
5218 ++i;
5219 if (cgltf_json_strcmp(tokens+i, json_chunk, "translation") == 0)
5220 {
5221 out_channel->target_path = cgltf_animation_path_type_translation;
5222 }
5223 else if (cgltf_json_strcmp(tokens+i, json_chunk, "rotation") == 0)
5224 {
5225 out_channel->target_path = cgltf_animation_path_type_rotation;
5226 }
5227 else if (cgltf_json_strcmp(tokens+i, json_chunk, "scale") == 0)
5228 {
5229 out_channel->target_path = cgltf_animation_path_type_scale;
5230 }
5231 else if (cgltf_json_strcmp(tokens+i, json_chunk, "weights") == 0)
5232 {
5233 out_channel->target_path = cgltf_animation_path_type_weights;
5234 }
5235 ++i;
5236 }
5237 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
5238 {
5239 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_channel->extras);
5240 }
5241 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
5242 {
5243 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_channel->extensions_count, &out_channel->extensions);
5244 }
5245 else
5246 {
5247 i = cgltf_skip_json(tokens, i+1);
5248 }
5249
5250 if (i < 0)
5251 {
5252 return i;
5253 }
5254 }
5255 }
5256 else
5257 {
5258 i = cgltf_skip_json(tokens, i+1);
5259 }
5260
5261 if (i < 0)
5262 {
5263 return i;
5264 }
5265 }
5266
5267 return i;
5268 }
5269
5270 static int cgltf_parse_json_animation(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_animation* out_animation)
5271 {
5272 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
5273
5274 int size = tokens[i].size;
5275 ++i;
5276
5277 for (int j = 0; j < size; ++j)
5278 {
5279 CGLTF_CHECK_KEY(tokens[i]);
5280
5281 if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
5282 {
5283 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_animation->name);
5284 }
5285 else if (cgltf_json_strcmp(tokens+i, json_chunk, "samplers") == 0)
5286 {
5287 i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_animation_sampler), (void**)&out_animation->samplers, &out_animation->samplers_count);
5288 if (i < 0)
5289 {
5290 return i;
5291 }
5292
5293 for (cgltf_size k = 0; k < out_animation->samplers_count; ++k)
5294 {
5295 i = cgltf_parse_json_animation_sampler(options, tokens, i, json_chunk, &out_animation->samplers[k]);
5296 if (i < 0)
5297 {
5298 return i;
5299 }
5300 }
5301 }
5302 else if (cgltf_json_strcmp(tokens+i, json_chunk, "channels") == 0)
5303 {
5304 i = cgltf_parse_json_array(options, tokens, i + 1, json_chunk, sizeof(cgltf_animation_channel), (void**)&out_animation->channels, &out_animation->channels_count);
5305 if (i < 0)
5306 {
5307 return i;
5308 }
5309
5310 for (cgltf_size k = 0; k < out_animation->channels_count; ++k)
5311 {
5312 i = cgltf_parse_json_animation_channel(options, tokens, i, json_chunk, &out_animation->channels[k]);
5313 if (i < 0)
5314 {
5315 return i;
5316 }
5317 }
5318 }
5319 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
5320 {
5321 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_animation->extras);
5322 }
5323 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
5324 {
5325 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_animation->extensions_count, &out_animation->extensions);
5326 }
5327 else
5328 {
5329 i = cgltf_skip_json(tokens, i+1);
5330 }
5331
5332 if (i < 0)
5333 {
5334 return i;
5335 }
5336 }
5337
5338 return i;
5339 }
5340
5341 static int cgltf_parse_json_animations(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
5342 {
5343 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_animation), (void**)&out_data->animations, &out_data->animations_count);
5344 if (i < 0)
5345 {
5346 return i;
5347 }
5348
5349 for (cgltf_size j = 0; j < out_data->animations_count; ++j)
5350 {
5351 i = cgltf_parse_json_animation(options, tokens, i, json_chunk, &out_data->animations[j]);
5352 if (i < 0)
5353 {
5354 return i;
5355 }
5356 }
5357 return i;
5358 }
5359
5360 static int cgltf_parse_json_variant(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_material_variant* out_variant)
5361 {
5362 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
5363
5364 int size = tokens[i].size;
5365 ++i;
5366
5367 for (int j = 0; j < size; ++j)
5368 {
5369 CGLTF_CHECK_KEY(tokens[i]);
5370
5371 if (cgltf_json_strcmp(tokens+i, json_chunk, "name") == 0)
5372 {
5373 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_variant->name);
5374 }
5375 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
5376 {
5377 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_variant->extras);
5378 }
5379 else
5380 {
5381 i = cgltf_skip_json(tokens, i+1);
5382 }
5383
5384 if (i < 0)
5385 {
5386 return i;
5387 }
5388 }
5389
5390 return i;
5391 }
5392
5393 static int cgltf_parse_json_variants(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
5394 {
5395 i = cgltf_parse_json_array(options, tokens, i, json_chunk, sizeof(cgltf_material_variant), (void**)&out_data->variants, &out_data->variants_count);
5396 if (i < 0)
5397 {
5398 return i;
5399 }
5400
5401 for (cgltf_size j = 0; j < out_data->variants_count; ++j)
5402 {
5403 i = cgltf_parse_json_variant(options, tokens, i, json_chunk, &out_data->variants[j]);
5404 if (i < 0)
5405 {
5406 return i;
5407 }
5408 }
5409 return i;
5410 }
5411
5412 static int cgltf_parse_json_asset(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_asset* out_asset)
5413 {
5414 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
5415
5416 int size = tokens[i].size;
5417 ++i;
5418
5419 for (int j = 0; j < size; ++j)
5420 {
5421 CGLTF_CHECK_KEY(tokens[i]);
5422
5423 if (cgltf_json_strcmp(tokens+i, json_chunk, "copyright") == 0)
5424 {
5425 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_asset->copyright);
5426 }
5427 else if (cgltf_json_strcmp(tokens+i, json_chunk, "generator") == 0)
5428 {
5429 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_asset->generator);
5430 }
5431 else if (cgltf_json_strcmp(tokens+i, json_chunk, "version") == 0)
5432 {
5433 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_asset->version);
5434 }
5435 else if (cgltf_json_strcmp(tokens+i, json_chunk, "minVersion") == 0)
5436 {
5437 i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_asset->min_version);
5438 }
5439 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extras") == 0)
5440 {
5441 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_asset->extras);
5442 }
5443 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
5444 {
5445 i = cgltf_parse_json_unprocessed_extensions(options, tokens, i, json_chunk, &out_asset->extensions_count, &out_asset->extensions);
5446 }
5447 else
5448 {
5449 i = cgltf_skip_json(tokens, i+1);
5450 }
5451
5452 if (i < 0)
5453 {
5454 return i;
5455 }
5456 }
5457
5458 if (out_asset->version && CGLTF_ATOF(out_asset->version) < 2)
5459 {
5460 return CGLTF_ERROR_LEGACY;
5461 }
5462
5463 return i;
5464 }
5465
5466 cgltf_size cgltf_num_components(cgltf_type type) {
5467 switch (type)
5468 {
5469 case cgltf_type_vec2:
5470 return 2;
5471 case cgltf_type_vec3:
5472 return 3;
5473 case cgltf_type_vec4:
5474 return 4;
5475 case cgltf_type_mat2:
5476 return 4;
5477 case cgltf_type_mat3:
5478 return 9;
5479 case cgltf_type_mat4:
5480 return 16;
5481 case cgltf_type_invalid:
5482 case cgltf_type_scalar:
5483 default:
5484 return 1;
5485 }
5486 }
5487
5488 static cgltf_size cgltf_component_size(cgltf_component_type component_type) {
5489 switch (component_type)
5490 {
5491 case cgltf_component_type_r_8:
5492 case cgltf_component_type_r_8u:
5493 return 1;
5494 case cgltf_component_type_r_16:
5495 case cgltf_component_type_r_16u:
5496 return 2;
5497 case cgltf_component_type_r_32u:
5498 case cgltf_component_type_r_32f:
5499 return 4;
5500 case cgltf_component_type_invalid:
5501 default:
5502 return 0;
5503 }
5504 }
5505
5506 static cgltf_size cgltf_calc_size(cgltf_type type, cgltf_component_type component_type)
5507 {
5508 cgltf_size component_size = cgltf_component_size(component_type);
5509 if (type == cgltf_type_mat2 && component_size == 1)
5510 {
5511 return 8 * component_size;
5512 }
5513 else if (type == cgltf_type_mat3 && (component_size == 1 || component_size == 2))
5514 {
5515 return 12 * component_size;
5516 }
5517 return component_size * cgltf_num_components(type);
5518 }
5519
5520 static int cgltf_fixup_pointers(cgltf_data* out_data);
5521
5522 static int cgltf_parse_json_root(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_data* out_data)
5523 {
5524 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
5525
5526 int size = tokens[i].size;
5527 ++i;
5528
5529 for (int j = 0; j < size; ++j)
5530 {
5531 CGLTF_CHECK_KEY(tokens[i]);
5532
5533 if (cgltf_json_strcmp(tokens + i, json_chunk, "asset") == 0)
5534 {
5535 i = cgltf_parse_json_asset(options, tokens, i + 1, json_chunk, &out_data->asset);
5536 }
5537 else if (cgltf_json_strcmp(tokens + i, json_chunk, "meshes") == 0)
5538 {
5539 i = cgltf_parse_json_meshes(options, tokens, i + 1, json_chunk, out_data);
5540 }
5541 else if (cgltf_json_strcmp(tokens + i, json_chunk, "accessors") == 0)
5542 {
5543 i = cgltf_parse_json_accessors(options, tokens, i + 1, json_chunk, out_data);
5544 }
5545 else if (cgltf_json_strcmp(tokens + i, json_chunk, "bufferViews") == 0)
5546 {
5547 i = cgltf_parse_json_buffer_views(options, tokens, i + 1, json_chunk, out_data);
5548 }
5549 else if (cgltf_json_strcmp(tokens + i, json_chunk, "buffers") == 0)
5550 {
5551 i = cgltf_parse_json_buffers(options, tokens, i + 1, json_chunk, out_data);
5552 }
5553 else if (cgltf_json_strcmp(tokens + i, json_chunk, "materials") == 0)
5554 {
5555 i = cgltf_parse_json_materials(options, tokens, i + 1, json_chunk, out_data);
5556 }
5557 else if (cgltf_json_strcmp(tokens + i, json_chunk, "images") == 0)
5558 {
5559 i = cgltf_parse_json_images(options, tokens, i + 1, json_chunk, out_data);
5560 }
5561 else if (cgltf_json_strcmp(tokens + i, json_chunk, "textures") == 0)
5562 {
5563 i = cgltf_parse_json_textures(options, tokens, i + 1, json_chunk, out_data);
5564 }
5565 else if (cgltf_json_strcmp(tokens + i, json_chunk, "samplers") == 0)
5566 {
5567 i = cgltf_parse_json_samplers(options, tokens, i + 1, json_chunk, out_data);
5568 }
5569 else if (cgltf_json_strcmp(tokens + i, json_chunk, "skins") == 0)
5570 {
5571 i = cgltf_parse_json_skins(options, tokens, i + 1, json_chunk, out_data);
5572 }
5573 else if (cgltf_json_strcmp(tokens + i, json_chunk, "cameras") == 0)
5574 {
5575 i = cgltf_parse_json_cameras(options, tokens, i + 1, json_chunk, out_data);
5576 }
5577 else if (cgltf_json_strcmp(tokens + i, json_chunk, "nodes") == 0)
5578 {
5579 i = cgltf_parse_json_nodes(options, tokens, i + 1, json_chunk, out_data);
5580 }
5581 else if (cgltf_json_strcmp(tokens + i, json_chunk, "scenes") == 0)
5582 {
5583 i = cgltf_parse_json_scenes(options, tokens, i + 1, json_chunk, out_data);
5584 }
5585 else if (cgltf_json_strcmp(tokens + i, json_chunk, "scene") == 0)
5586 {
5587 ++i;
5588 out_data->scene = CGLTF_PTRINDEX(cgltf_scene, cgltf_json_to_int(tokens + i, json_chunk));
5589 ++i;
5590 }
5591 else if (cgltf_json_strcmp(tokens + i, json_chunk, "animations") == 0)
5592 {
5593 i = cgltf_parse_json_animations(options, tokens, i + 1, json_chunk, out_data);
5594 }
5595 else if (cgltf_json_strcmp(tokens+i, json_chunk, "extras") == 0)
5596 {
5597 i = cgltf_parse_json_extras(tokens, i + 1, json_chunk, &out_data->extras);
5598 }
5599 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensions") == 0)
5600 {
5601 ++i;
5602
5603 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
5604 if(out_data->data_extensions)
5605 {
5606 return CGLTF_ERROR_JSON;
5607 }
5608
5609 int extensions_size = tokens[i].size;
5610 out_data->data_extensions_count = 0;
5611 out_data->data_extensions = (cgltf_extension*)cgltf_calloc(options, sizeof(cgltf_extension), extensions_size);
5612
5613 if (!out_data->data_extensions)
5614 {
5615 return CGLTF_ERROR_NOMEM;
5616 }
5617
5618 ++i;
5619
5620 for (int k = 0; k < extensions_size; ++k)
5621 {
5622 CGLTF_CHECK_KEY(tokens[i]);
5623
5624 if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_lights_punctual") == 0)
5625 {
5626 ++i;
5627
5628 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
5629
5630 int data_size = tokens[i].size;
5631 ++i;
5632
5633 for (int m = 0; m < data_size; ++m)
5634 {
5635 CGLTF_CHECK_KEY(tokens[i]);
5636
5637 if (cgltf_json_strcmp(tokens + i, json_chunk, "lights") == 0)
5638 {
5639 i = cgltf_parse_json_lights(options, tokens, i + 1, json_chunk, out_data);
5640 }
5641 else
5642 {
5643 i = cgltf_skip_json(tokens, i + 1);
5644 }
5645
5646 if (i < 0)
5647 {
5648 return i;
5649 }
5650 }
5651 }
5652 else if (cgltf_json_strcmp(tokens+i, json_chunk, "KHR_materials_variants") == 0)
5653 {
5654 ++i;
5655
5656 CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
5657
5658 int data_size = tokens[i].size;
5659 ++i;
5660
5661 for (int m = 0; m < data_size; ++m)
5662 {
5663 CGLTF_CHECK_KEY(tokens[i]);
5664
5665 if (cgltf_json_strcmp(tokens + i, json_chunk, "variants") == 0)
5666 {
5667 i = cgltf_parse_json_variants(options, tokens, i + 1, json_chunk, out_data);
5668 }
5669 else
5670 {
5671 i = cgltf_skip_json(tokens, i + 1);
5672 }
5673
5674 if (i < 0)
5675 {
5676 return i;
5677 }
5678 }
5679 }
5680 else
5681 {
5682 i = cgltf_parse_json_unprocessed_extension(options, tokens, i, json_chunk, &(out_data->data_extensions[out_data->data_extensions_count++]));
5683 }
5684
5685 if (i < 0)
5686 {
5687 return i;
5688 }
5689 }
5690 }
5691 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensionsUsed") == 0)
5692 {
5693 i = cgltf_parse_json_string_array(options, tokens, i + 1, json_chunk, &out_data->extensions_used, &out_data->extensions_used_count);
5694 }
5695 else if (cgltf_json_strcmp(tokens + i, json_chunk, "extensionsRequired") == 0)
5696 {
5697 i = cgltf_parse_json_string_array(options, tokens, i + 1, json_chunk, &out_data->extensions_required, &out_data->extensions_required_count);
5698 }
5699 else
5700 {
5701 i = cgltf_skip_json(tokens, i + 1);
5702 }
5703
5704 if (i < 0)
5705 {
5706 return i;
5707 }
5708 }
5709
5710 return i;
5711 }
5712
5713 cgltf_result cgltf_parse_json(cgltf_options* options, const uint8_t* json_chunk, cgltf_size size, cgltf_data** out_data)
5714 {
5715 jsmn_parser parser = { 0, 0, 0 };
5716
5717 if (options->json_token_count == 0)
5718 {
5719 int token_count = jsmn_parse(&parser, (const char*)json_chunk, size, NULL, 0);
5720
5721 if (token_count <= 0)
5722 {
5723 return cgltf_result_invalid_json;
5724 }
5725
5726 options->json_token_count = token_count;
5727 }
5728
5729 jsmntok_t* tokens = (jsmntok_t*)options->memory.alloc(options->memory.user_data, sizeof(jsmntok_t) * (options->json_token_count + 1));
5730
5731 if (!tokens)
5732 {
5733 return cgltf_result_out_of_memory;
5734 }
5735
5736 jsmn_init(&parser);
5737
5738 int token_count = jsmn_parse(&parser, (const char*)json_chunk, size, tokens, options->json_token_count);
5739
5740 if (token_count <= 0)
5741 {
5742 options->memory.free(options->memory.user_data, tokens);
5743 return cgltf_result_invalid_json;
5744 }
5745
5746 // this makes sure that we always have an UNDEFINED token at the end of the stream
5747 // for invalid JSON inputs this makes sure we don't perform out of bound reads of token data
5748 tokens[token_count].type = JSMN_UNDEFINED;
5749
5750 cgltf_data* data = (cgltf_data*)options->memory.alloc(options->memory.user_data, sizeof(cgltf_data));
5751
5752 if (!data)
5753 {
5754 options->memory.free(options->memory.user_data, tokens);
5755 return cgltf_result_out_of_memory;
5756 }
5757
5758 memset(data, 0, sizeof(cgltf_data));
5759 data->memory = options->memory;
5760 data->file = options->file;
5761
5762 int i = cgltf_parse_json_root(options, tokens, 0, json_chunk, data);
5763
5764 options->memory.free(options->memory.user_data, tokens);
5765
5766 if (i < 0)
5767 {
5768 cgltf_free(data);
5769
5770 switch (i)
5771 {
5772 case CGLTF_ERROR_NOMEM: return cgltf_result_out_of_memory;
5773 case CGLTF_ERROR_LEGACY: return cgltf_result_legacy_gltf;
5774 default: return cgltf_result_invalid_gltf;
5775 }
5776 }
5777
5778 if (cgltf_fixup_pointers(data) < 0)
5779 {
5780 cgltf_free(data);
5781 return cgltf_result_invalid_gltf;
5782 }
5783
5784 data->json = (const char*)json_chunk;
5785 data->json_size = size;
5786
5787 *out_data = data;
5788
5789 return cgltf_result_success;
5790 }
5791
5792 static int cgltf_fixup_pointers(cgltf_data* data)
5793 {
5794 for (cgltf_size i = 0; i < data->meshes_count; ++i)
5795 {
5796 for (cgltf_size j = 0; j < data->meshes[i].primitives_count; ++j)
5797 {
5798 CGLTF_PTRFIXUP(data->meshes[i].primitives[j].indices, data->accessors, data->accessors_count);
5799 CGLTF_PTRFIXUP(data->meshes[i].primitives[j].material, data->materials, data->materials_count);
5800
5801 for (cgltf_size k = 0; k < data->meshes[i].primitives[j].attributes_count; ++k)
5802 {
5803 CGLTF_PTRFIXUP_REQ(data->meshes[i].primitives[j].attributes[k].data, data->accessors, data->accessors_count);
5804 }
5805
5806 for (cgltf_size k = 0; k < data->meshes[i].primitives[j].targets_count; ++k)
5807 {
5808 for (cgltf_size m = 0; m < data->meshes[i].primitives[j].targets[k].attributes_count; ++m)
5809 {
5810 CGLTF_PTRFIXUP_REQ(data->meshes[i].primitives[j].targets[k].attributes[m].data, data->accessors, data->accessors_count);
5811 }
5812 }
5813
5814 if (data->meshes[i].primitives[j].has_draco_mesh_compression)
5815 {
5816 CGLTF_PTRFIXUP_REQ(data->meshes[i].primitives[j].draco_mesh_compression.buffer_view, data->buffer_views, data->buffer_views_count);
5817 for (cgltf_size m = 0; m < data->meshes[i].primitives[j].draco_mesh_compression.attributes_count; ++m)
5818 {
5819 CGLTF_PTRFIXUP_REQ(data->meshes[i].primitives[j].draco_mesh_compression.attributes[m].data, data->accessors, data->accessors_count);
5820 }
5821 }
5822
5823 for (cgltf_size k = 0; k < data->meshes[i].primitives[j].mappings_count; ++k)
5824 {
5825 CGLTF_PTRFIXUP_REQ(data->meshes[i].primitives[j].mappings[k].material, data->materials, data->materials_count);
5826 }
5827 }
5828 }
5829
5830 for (cgltf_size i = 0; i < data->accessors_count; ++i)
5831 {
5832 CGLTF_PTRFIXUP(data->accessors[i].buffer_view, data->buffer_views, data->buffer_views_count);
5833
5834 if (data->accessors[i].is_sparse)
5835 {
5836 CGLTF_PTRFIXUP_REQ(data->accessors[i].sparse.indices_buffer_view, data->buffer_views, data->buffer_views_count);
5837 CGLTF_PTRFIXUP_REQ(data->accessors[i].sparse.values_buffer_view, data->buffer_views, data->buffer_views_count);
5838 }
5839
5840 if (data->accessors[i].buffer_view)
5841 {
5842 data->accessors[i].stride = data->accessors[i].buffer_view->stride;
5843 }
5844
5845 if (data->accessors[i].stride == 0)
5846 {
5847 data->accessors[i].stride = cgltf_calc_size(data->accessors[i].type, data->accessors[i].component_type);
5848 }
5849 }
5850
5851 for (cgltf_size i = 0; i < data->textures_count; ++i)
5852 {
5853 CGLTF_PTRFIXUP(data->textures[i].image, data->images, data->images_count);
5854 CGLTF_PTRFIXUP(data->textures[i].sampler, data->samplers, data->samplers_count);
5855 }
5856
5857 for (cgltf_size i = 0; i < data->images_count; ++i)
5858 {
5859 CGLTF_PTRFIXUP(data->images[i].buffer_view, data->buffer_views, data->buffer_views_count);
5860 }
5861
5862 for (cgltf_size i = 0; i < data->materials_count; ++i)
5863 {
5864 CGLTF_PTRFIXUP(data->materials[i].normal_texture.texture, data->textures, data->textures_count);
5865 CGLTF_PTRFIXUP(data->materials[i].emissive_texture.texture, data->textures, data->textures_count);
5866 CGLTF_PTRFIXUP(data->materials[i].occlusion_texture.texture, data->textures, data->textures_count);
5867
5868 CGLTF_PTRFIXUP(data->materials[i].pbr_metallic_roughness.base_color_texture.texture, data->textures, data->textures_count);
5869 CGLTF_PTRFIXUP(data->materials[i].pbr_metallic_roughness.metallic_roughness_texture.texture, data->textures, data->textures_count);
5870
5871 CGLTF_PTRFIXUP(data->materials[i].pbr_specular_glossiness.diffuse_texture.texture, data->textures, data->textures_count);
5872 CGLTF_PTRFIXUP(data->materials[i].pbr_specular_glossiness.specular_glossiness_texture.texture, data->textures, data->textures_count);
5873
5874 CGLTF_PTRFIXUP(data->materials[i].clearcoat.clearcoat_texture.texture, data->textures, data->textures_count);
5875 CGLTF_PTRFIXUP(data->materials[i].clearcoat.clearcoat_roughness_texture.texture, data->textures, data->textures_count);
5876 CGLTF_PTRFIXUP(data->materials[i].clearcoat.clearcoat_normal_texture.texture, data->textures, data->textures_count);
5877
5878 CGLTF_PTRFIXUP(data->materials[i].specular.specular_texture.texture, data->textures, data->textures_count);
5879 CGLTF_PTRFIXUP(data->materials[i].specular.specular_color_texture.texture, data->textures, data->textures_count);
5880
5881 CGLTF_PTRFIXUP(data->materials[i].transmission.transmission_texture.texture, data->textures, data->textures_count);
5882
5883 CGLTF_PTRFIXUP(data->materials[i].volume.thickness_texture.texture, data->textures, data->textures_count);
5884
5885 CGLTF_PTRFIXUP(data->materials[i].sheen.sheen_color_texture.texture, data->textures, data->textures_count);
5886 CGLTF_PTRFIXUP(data->materials[i].sheen.sheen_roughness_texture.texture, data->textures, data->textures_count);
5887 }
5888
5889 for (cgltf_size i = 0; i < data->buffer_views_count; ++i)
5890 {
5891 CGLTF_PTRFIXUP_REQ(data->buffer_views[i].buffer, data->buffers, data->buffers_count);
5892
5893 if (data->buffer_views[i].has_meshopt_compression)
5894 {
5895 CGLTF_PTRFIXUP_REQ(data->buffer_views[i].meshopt_compression.buffer, data->buffers, data->buffers_count);
5896 }
5897 }
5898
5899 for (cgltf_size i = 0; i < data->skins_count; ++i)
5900 {
5901 for (cgltf_size j = 0; j < data->skins[i].joints_count; ++j)
5902 {
5903 CGLTF_PTRFIXUP_REQ(data->skins[i].joints[j], data->nodes, data->nodes_count);
5904 }
5905
5906 CGLTF_PTRFIXUP(data->skins[i].skeleton, data->nodes, data->nodes_count);
5907 CGLTF_PTRFIXUP(data->skins[i].inverse_bind_matrices, data->accessors, data->accessors_count);
5908 }
5909
5910 for (cgltf_size i = 0; i < data->nodes_count; ++i)
5911 {
5912 for (cgltf_size j = 0; j < data->nodes[i].children_count; ++j)
5913 {
5914 CGLTF_PTRFIXUP_REQ(data->nodes[i].children[j], data->nodes, data->nodes_count);
5915
5916 if (data->nodes[i].children[j]->parent)
5917 {
5918 return CGLTF_ERROR_JSON;
5919 }
5920
5921 data->nodes[i].children[j]->parent = &data->nodes[i];
5922 }
5923
5924 CGLTF_PTRFIXUP(data->nodes[i].mesh, data->meshes, data->meshes_count);
5925 CGLTF_PTRFIXUP(data->nodes[i].skin, data->skins, data->skins_count);
5926 CGLTF_PTRFIXUP(data->nodes[i].camera, data->cameras, data->cameras_count);
5927 CGLTF_PTRFIXUP(data->nodes[i].light, data->lights, data->lights_count);
5928 }
5929
5930 for (cgltf_size i = 0; i < data->scenes_count; ++i)
5931 {
5932 for (cgltf_size j = 0; j < data->scenes[i].nodes_count; ++j)
5933 {
5934 CGLTF_PTRFIXUP_REQ(data->scenes[i].nodes[j], data->nodes, data->nodes_count);
5935
5936 if (data->scenes[i].nodes[j]->parent)
5937 {
5938 return CGLTF_ERROR_JSON;
5939 }
5940 }
5941 }
5942
5943 CGLTF_PTRFIXUP(data->scene, data->scenes, data->scenes_count);
5944
5945 for (cgltf_size i = 0; i < data->animations_count; ++i)
5946 {
5947 for (cgltf_size j = 0; j < data->animations[i].samplers_count; ++j)
5948 {
5949 CGLTF_PTRFIXUP_REQ(data->animations[i].samplers[j].input, data->accessors, data->accessors_count);
5950 CGLTF_PTRFIXUP_REQ(data->animations[i].samplers[j].output, data->accessors, data->accessors_count);
5951 }
5952
5953 for (cgltf_size j = 0; j < data->animations[i].channels_count; ++j)
5954 {
5955 CGLTF_PTRFIXUP_REQ(data->animations[i].channels[j].sampler, data->animations[i].samplers, data->animations[i].samplers_count);
5956 CGLTF_PTRFIXUP(data->animations[i].channels[j].target_node, data->nodes, data->nodes_count);
5957 }
5958 }
5959
5960 return 0;
5961 }
5962
5963 /*
5964 * -- jsmn.c start --
5965 * Source: https://github.com/zserge/jsmn
5966 * License: MIT
5967 *
5968 * Copyright (c) 2010 Serge A. Zaitsev
5969
5970 * Permission is hereby granted, free of charge, to any person obtaining a copy
5971 * of this software and associated documentation files (the "Software"), to deal
5972 * in the Software without restriction, including without limitation the rights
5973 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
5974 * copies of the Software, and to permit persons to whom the Software is
5975 * furnished to do so, subject to the following conditions:
5976
5977 * The above copyright notice and this permission notice shall be included in
5978 * all copies or substantial portions of the Software.
5979
5980 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
5981 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
5982 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
5983 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
5984 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
5985 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
5986 * THE SOFTWARE.
5987 */
5988
5989 /**
5990 * Allocates a fresh unused token from the token pull.
5991 */
5992 static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser,
5993 jsmntok_t *tokens, size_t num_tokens) {
5994 jsmntok_t *tok;
5995 if (parser->toknext >= num_tokens) {
5996 return NULL;
5997 }
5998 tok = &tokens[parser->toknext++];
5999 tok->start = tok->end = -1;
6000 tok->size = 0;
6001 #ifdef JSMN_PARENT_LINKS
6002 tok->parent = -1;
6003 #endif
6004 return tok;
6005 }
6006
6007 /**
6008 * Fills token type and boundaries.
6009 */
6010 static void jsmn_fill_token(jsmntok_t *token, jsmntype_t type,
6011 int start, int end) {
6012 token->type = type;
6013 token->start = start;
6014 token->end = end;
6015 token->size = 0;
6016 }
6017
6018 /**
6019 * Fills next available token with JSON primitive.
6020 */
6021 static int jsmn_parse_primitive(jsmn_parser *parser, const char *js,
6022 size_t len, jsmntok_t *tokens, size_t num_tokens) {
6023 jsmntok_t *token;
6024 int start;
6025
6026 start = parser->pos;
6027
6028 for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
6029 switch (js[parser->pos]) {
6030 #ifndef JSMN_STRICT
6031 /* In strict mode primitive must be followed by "," or "}" or "]" */
6032 case ':':
6033 #endif
6034 case '\t' : case '\r' : case '\n' : case ' ' :
6035 case ',' : case ']' : case '}' :
6036 goto found;
6037 }
6038 if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
6039 parser->pos = start;
6040 return JSMN_ERROR_INVAL;
6041 }
6042 }
6043 #ifdef JSMN_STRICT
6044 /* In strict mode primitive must be followed by a comma/object/array */
6045 parser->pos = start;
6046 return JSMN_ERROR_PART;
6047 #endif
6048
6049 found:
6050 if (tokens == NULL) {
6051 parser->pos--;
6052 return 0;
6053 }
6054 token = jsmn_alloc_token(parser, tokens, num_tokens);
6055 if (token == NULL) {
6056 parser->pos = start;
6057 return JSMN_ERROR_NOMEM;
6058 }
6059 jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
6060 #ifdef JSMN_PARENT_LINKS
6061 token->parent = parser->toksuper;
6062 #endif
6063 parser->pos--;
6064 return 0;
6065 }
6066
6067 /**
6068 * Fills next token with JSON string.
6069 */
6070 static int jsmn_parse_string(jsmn_parser *parser, const char *js,
6071 size_t len, jsmntok_t *tokens, size_t num_tokens) {
6072 jsmntok_t *token;
6073
6074 int start = parser->pos;
6075
6076 parser->pos++;
6077
6078 /* Skip starting quote */
6079 for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
6080 char c = js[parser->pos];
6081
6082 /* Quote: end of string */
6083 if (c == '\"') {
6084 if (tokens == NULL) {
6085 return 0;
6086 }
6087 token = jsmn_alloc_token(parser, tokens, num_tokens);
6088 if (token == NULL) {
6089 parser->pos = start;
6090 return JSMN_ERROR_NOMEM;
6091 }
6092 jsmn_fill_token(token, JSMN_STRING, start+1, parser->pos);
6093 #ifdef JSMN_PARENT_LINKS
6094 token->parent = parser->toksuper;
6095 #endif
6096 return 0;
6097 }
6098
6099 /* Backslash: Quoted symbol expected */
6100 if (c == '\\' && parser->pos + 1 < len) {
6101 int i;
6102 parser->pos++;
6103 switch (js[parser->pos]) {
6104 /* Allowed escaped symbols */
6105 case '\"': case '/' : case '\\' : case 'b' :
6106 case 'f' : case 'r' : case 'n' : case 't' :
6107 break;
6108 /* Allows escaped symbol \uXXXX */
6109 case 'u':
6110 parser->pos++;
6111 for(i = 0; i < 4 && parser->pos < len && js[parser->pos] != '\0'; i++) {
6112 /* If it isn't a hex character we have an error */
6113 if(!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */
6114 (js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */
6115 (js[parser->pos] >= 97 && js[parser->pos] <= 102))) { /* a-f */
6116 parser->pos = start;
6117 return JSMN_ERROR_INVAL;
6118 }
6119 parser->pos++;
6120 }
6121 parser->pos--;
6122 break;
6123 /* Unexpected symbol */
6124 default:
6125 parser->pos = start;
6126 return JSMN_ERROR_INVAL;
6127 }
6128 }
6129 }
6130 parser->pos = start;
6131 return JSMN_ERROR_PART;
6132 }
6133
6134 /**
6135 * Parse JSON string and fill tokens.
6136 */
6137 static int jsmn_parse(jsmn_parser *parser, const char *js, size_t len,
6138 jsmntok_t *tokens, size_t num_tokens) {
6139 int r;
6140 int i;
6141 jsmntok_t *token;
6142 int count = parser->toknext;
6143
6144 for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
6145 char c;
6146 jsmntype_t type;
6147
6148 c = js[parser->pos];
6149 switch (c) {
6150 case '{': case '[':
6151 count++;
6152 if (tokens == NULL) {
6153 break;
6154 }
6155 token = jsmn_alloc_token(parser, tokens, num_tokens);
6156 if (token == NULL)
6157 return JSMN_ERROR_NOMEM;
6158 if (parser->toksuper != -1) {
6159 tokens[parser->toksuper].size++;
6160 #ifdef JSMN_PARENT_LINKS
6161 token->parent = parser->toksuper;
6162 #endif
6163 }
6164 token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
6165 token->start = parser->pos;
6166 parser->toksuper = parser->toknext - 1;
6167 break;
6168 case '}': case ']':
6169 if (tokens == NULL)
6170 break;
6171 type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
6172 #ifdef JSMN_PARENT_LINKS
6173 if (parser->toknext < 1) {
6174 return JSMN_ERROR_INVAL;
6175 }
6176 token = &tokens[parser->toknext - 1];
6177 for (;;) {
6178 if (token->start != -1 && token->end == -1) {
6179 if (token->type != type) {
6180 return JSMN_ERROR_INVAL;
6181 }
6182 token->end = parser->pos + 1;
6183 parser->toksuper = token->parent;
6184 break;
6185 }
6186 if (token->parent == -1) {
6187 if(token->type != type || parser->toksuper == -1) {
6188 return JSMN_ERROR_INVAL;
6189 }
6190 break;
6191 }
6192 token = &tokens[token->parent];
6193 }
6194 #else
6195 for (i = parser->toknext - 1; i >= 0; i--) {
6196 token = &tokens[i];
6197 if (token->start != -1 && token->end == -1) {
6198 if (token->type != type) {
6199 return JSMN_ERROR_INVAL;
6200 }
6201 parser->toksuper = -1;
6202 token->end = parser->pos + 1;
6203 break;
6204 }
6205 }
6206 /* Error if unmatched closing bracket */
6207 if (i == -1) return JSMN_ERROR_INVAL;
6208 for (; i >= 0; i--) {
6209 token = &tokens[i];
6210 if (token->start != -1 && token->end == -1) {
6211 parser->toksuper = i;
6212 break;
6213 }
6214 }
6215 #endif
6216 break;
6217 case '\"':
6218 r = jsmn_parse_string(parser, js, len, tokens, num_tokens);
6219 if (r < 0) return r;
6220 count++;
6221 if (parser->toksuper != -1 && tokens != NULL)
6222 tokens[parser->toksuper].size++;
6223 break;
6224 case '\t' : case '\r' : case '\n' : case ' ':
6225 break;
6226 case ':':
6227 parser->toksuper = parser->toknext - 1;
6228 break;
6229 case ',':
6230 if (tokens != NULL && parser->toksuper != -1 &&
6231 tokens[parser->toksuper].type != JSMN_ARRAY &&
6232 tokens[parser->toksuper].type != JSMN_OBJECT) {
6233 #ifdef JSMN_PARENT_LINKS
6234 parser->toksuper = tokens[parser->toksuper].parent;
6235 #else
6236 for (i = parser->toknext - 1; i >= 0; i--) {
6237 if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT) {
6238 if (tokens[i].start != -1 && tokens[i].end == -1) {
6239 parser->toksuper = i;
6240 break;
6241 }
6242 }
6243 }
6244 #endif
6245 }
6246 break;
6247 #ifdef JSMN_STRICT
6248 /* In strict mode primitives are: numbers and booleans */
6249 case '-': case '0': case '1' : case '2': case '3' : case '4':
6250 case '5': case '6': case '7' : case '8': case '9':
6251 case 't': case 'f': case 'n' :
6252 /* And they must not be keys of the object */
6253 if (tokens != NULL && parser->toksuper != -1) {
6254 jsmntok_t *t = &tokens[parser->toksuper];
6255 if (t->type == JSMN_OBJECT ||
6256 (t->type == JSMN_STRING && t->size != 0)) {
6257 return JSMN_ERROR_INVAL;
6258 }
6259 }
6260 #else
6261 /* In non-strict mode every unquoted value is a primitive */
6262 default:
6263 #endif
6264 r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
6265 if (r < 0) return r;
6266 count++;
6267 if (parser->toksuper != -1 && tokens != NULL)
6268 tokens[parser->toksuper].size++;
6269 break;
6270
6271 #ifdef JSMN_STRICT
6272 /* Unexpected char in strict mode */
6273 default:
6274 return JSMN_ERROR_INVAL;
6275 #endif
6276 }
6277 }
6278
6279 if (tokens != NULL) {
6280 for (i = parser->toknext - 1; i >= 0; i--) {
6281 /* Unmatched opened object or array */
6282 if (tokens[i].start != -1 && tokens[i].end == -1) {
6283 return JSMN_ERROR_PART;
6284 }
6285 }
6286 }
6287
6288 return count;
6289 }
6290
6291 /**
6292 * Creates a new parser based over a given buffer with an array of tokens
6293 * available.
6294 */
6295 static void jsmn_init(jsmn_parser *parser) {
6296 parser->pos = 0;
6297 parser->toknext = 0;
6298 parser->toksuper = -1;
6299 }
6300 /*
6301 * -- jsmn.c end --
6302 */
6303
6304 #endif /* #ifdef CGLTF_IMPLEMENTATION */
6305
6306 /* cgltf is distributed under MIT license:
6307 *
6308 * Copyright (c) 2018 Johannes Kuhlmann
6309
6310 * Permission is hereby granted, free of charge, to any person obtaining a copy
6311 * of this software and associated documentation files (the "Software"), to deal
6312 * in the Software without restriction, including without limitation the rights
6313 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
6314 * copies of the Software, and to permit persons to whom the Software is
6315 * furnished to do so, subject to the following conditions:
6316
6317 * The above copyright notice and this permission notice shall be included in all
6318 * copies or substantial portions of the Software.
6319
6320 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
6321 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
6322 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
6323 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
6324 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
6325 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
6326 * SOFTWARE.
6327 */