mirror of https://github.com/bkaradzic/bgfx
Updated cgltf.
This commit is contained in:
parent
6dea6a22b6
commit
2b136890a2
|
@ -63,9 +63,14 @@
|
|||
* By passing null for the output pointer, users can find out how many floats are required in the
|
||||
* output buffer.
|
||||
*
|
||||
* `cgltf_accessor_unpack_indices` reads in the index data from an accessor. Assumes that
|
||||
* `cgltf_load_buffers` has already been called. By passing null for the output pointer, users can
|
||||
* find out how many indices are required in the output buffer. Returns 0 if the accessor is
|
||||
* sparse or if the output component size is less than the accessor's component size.
|
||||
*
|
||||
* `cgltf_num_components` is a tiny utility that tells you the dimensionality of
|
||||
* a certain accessor type. This can be used before `cgltf_accessor_unpack_floats` to help allocate
|
||||
* the necessary amount of memory. `cgltf_component_size` and `cgltf_calc_size` exist for
|
||||
* the necessary amount of memory. `cgltf_component_size` and `cgltf_calc_size` exist for
|
||||
* similar purposes.
|
||||
*
|
||||
* `cgltf_accessor_read_float` reads a certain element from a non-sparse accessor and converts it to
|
||||
|
@ -75,7 +80,7 @@
|
|||
*
|
||||
* `cgltf_accessor_read_uint` is similar to its floating-point counterpart, but limited to reading
|
||||
* vector types and does not support matrix types. The passed-in element size is the number of uints
|
||||
* in the output buffer, which should be in the range [1, 4]. Returns false if the passed-in
|
||||
* in the output buffer, which should be in the range [1, 4]. Returns false if the passed-in
|
||||
* element_size is too small, or if the accessor is sparse.
|
||||
*
|
||||
* `cgltf_accessor_read_index` is similar to its floating-point counterpart, but it returns size_t
|
||||
|
@ -197,6 +202,7 @@ typedef enum cgltf_type
|
|||
|
||||
typedef enum cgltf_primitive_type
|
||||
{
|
||||
cgltf_primitive_type_invalid,
|
||||
cgltf_primitive_type_points,
|
||||
cgltf_primitive_type_lines,
|
||||
cgltf_primitive_type_line_loop,
|
||||
|
@ -838,7 +844,7 @@ cgltf_size cgltf_component_size(cgltf_component_type component_type);
|
|||
cgltf_size cgltf_calc_size(cgltf_type type, cgltf_component_type component_type);
|
||||
|
||||
cgltf_size cgltf_accessor_unpack_floats(const cgltf_accessor* accessor, cgltf_float* out, cgltf_size float_count);
|
||||
cgltf_size cgltf_accessor_unpack_indices(const cgltf_accessor* accessor, cgltf_uint* out, cgltf_size index_count);
|
||||
cgltf_size cgltf_accessor_unpack_indices(const cgltf_accessor* accessor, void* out, cgltf_size out_component_size, cgltf_size index_count);
|
||||
|
||||
/* this function is deprecated and will be removed in the future; use cgltf_extras::data instead */
|
||||
cgltf_result cgltf_copy_extras_json(const cgltf_data* data, const cgltf_extras* extras, char* dest, cgltf_size* dest_size);
|
||||
|
@ -938,8 +944,8 @@ static int jsmn_parse(jsmn_parser *parser, const char *js, size_t len, jsmntok_t
|
|||
|
||||
|
||||
#ifndef CGLTF_CONSTS
|
||||
static const cgltf_size GlbHeaderSize = 12;
|
||||
static const cgltf_size GlbChunkHeaderSize = 8;
|
||||
#define GlbHeaderSize 12
|
||||
#define GlbChunkHeaderSize 8
|
||||
static const uint32_t GlbVersion = 2;
|
||||
static const uint32_t GlbMagic = 0x46546C67;
|
||||
static const uint32_t GlbMagicJsonChunk = 0x4E4F534A;
|
||||
|
@ -1033,7 +1039,7 @@ static cgltf_result cgltf_default_file_read(const struct cgltf_memory_options* m
|
|||
fclose(file);
|
||||
return cgltf_result_out_of_memory;
|
||||
}
|
||||
|
||||
|
||||
cgltf_size read_size = fread(file_data, 1, file_size, file);
|
||||
|
||||
fclose(file);
|
||||
|
@ -1552,6 +1558,9 @@ cgltf_result cgltf_validate(cgltf_data* data)
|
|||
{
|
||||
cgltf_accessor* accessor = &data->accessors[i];
|
||||
|
||||
CGLTF_ASSERT_IF(data->accessors[i].component_type == cgltf_component_type_invalid, cgltf_result_invalid_gltf);
|
||||
CGLTF_ASSERT_IF(data->accessors[i].type == cgltf_type_invalid, cgltf_result_invalid_gltf);
|
||||
|
||||
cgltf_size element_size = cgltf_calc_size(accessor->type, accessor->component_type);
|
||||
|
||||
if (accessor->buffer_view)
|
||||
|
@ -1565,7 +1574,7 @@ cgltf_result cgltf_validate(cgltf_data* data)
|
|||
{
|
||||
cgltf_accessor_sparse* sparse = &accessor->sparse;
|
||||
|
||||
cgltf_size indices_component_size = cgltf_calc_size(cgltf_type_scalar, sparse->indices_component_type);
|
||||
cgltf_size indices_component_size = cgltf_component_size(sparse->indices_component_type);
|
||||
cgltf_size indices_req_size = sparse->indices_byte_offset + indices_component_size * sparse->count;
|
||||
cgltf_size values_req_size = sparse->values_byte_offset + element_size * sparse->count;
|
||||
|
||||
|
@ -1631,43 +1640,48 @@ cgltf_result cgltf_validate(cgltf_data* data)
|
|||
|
||||
for (cgltf_size j = 0; j < data->meshes[i].primitives_count; ++j)
|
||||
{
|
||||
CGLTF_ASSERT_IF(data->meshes[i].primitives[j].type == cgltf_primitive_type_invalid, cgltf_result_invalid_gltf);
|
||||
CGLTF_ASSERT_IF(data->meshes[i].primitives[j].targets_count != data->meshes[i].primitives[0].targets_count, cgltf_result_invalid_gltf);
|
||||
|
||||
if (data->meshes[i].primitives[j].attributes_count)
|
||||
CGLTF_ASSERT_IF(data->meshes[i].primitives[j].attributes_count == 0, cgltf_result_invalid_gltf);
|
||||
|
||||
cgltf_accessor* first = data->meshes[i].primitives[j].attributes[0].data;
|
||||
|
||||
CGLTF_ASSERT_IF(first->count == 0, cgltf_result_invalid_gltf);
|
||||
|
||||
for (cgltf_size k = 0; k < data->meshes[i].primitives[j].attributes_count; ++k)
|
||||
{
|
||||
cgltf_accessor* first = data->meshes[i].primitives[j].attributes[0].data;
|
||||
CGLTF_ASSERT_IF(data->meshes[i].primitives[j].attributes[k].data->count != first->count, cgltf_result_invalid_gltf);
|
||||
}
|
||||
|
||||
for (cgltf_size k = 0; k < data->meshes[i].primitives[j].attributes_count; ++k)
|
||||
for (cgltf_size k = 0; k < data->meshes[i].primitives[j].targets_count; ++k)
|
||||
{
|
||||
for (cgltf_size m = 0; m < data->meshes[i].primitives[j].targets[k].attributes_count; ++m)
|
||||
{
|
||||
CGLTF_ASSERT_IF(data->meshes[i].primitives[j].attributes[k].data->count != first->count, cgltf_result_invalid_gltf);
|
||||
CGLTF_ASSERT_IF(data->meshes[i].primitives[j].targets[k].attributes[m].data->count != first->count, cgltf_result_invalid_gltf);
|
||||
}
|
||||
}
|
||||
|
||||
for (cgltf_size k = 0; k < data->meshes[i].primitives[j].targets_count; ++k)
|
||||
{
|
||||
for (cgltf_size m = 0; m < data->meshes[i].primitives[j].targets[k].attributes_count; ++m)
|
||||
{
|
||||
CGLTF_ASSERT_IF(data->meshes[i].primitives[j].targets[k].attributes[m].data->count != first->count, cgltf_result_invalid_gltf);
|
||||
}
|
||||
}
|
||||
cgltf_accessor* indices = data->meshes[i].primitives[j].indices;
|
||||
|
||||
cgltf_accessor* indices = data->meshes[i].primitives[j].indices;
|
||||
CGLTF_ASSERT_IF(indices &&
|
||||
indices->component_type != cgltf_component_type_r_8u &&
|
||||
indices->component_type != cgltf_component_type_r_16u &&
|
||||
indices->component_type != cgltf_component_type_r_32u, cgltf_result_invalid_gltf);
|
||||
|
||||
CGLTF_ASSERT_IF(indices &&
|
||||
indices->component_type != cgltf_component_type_r_8u &&
|
||||
indices->component_type != cgltf_component_type_r_16u &&
|
||||
indices->component_type != cgltf_component_type_r_32u, cgltf_result_invalid_gltf);
|
||||
CGLTF_ASSERT_IF(indices && indices->type != cgltf_type_scalar, cgltf_result_invalid_gltf);
|
||||
CGLTF_ASSERT_IF(indices && indices->stride != cgltf_component_size(indices->component_type), cgltf_result_invalid_gltf);
|
||||
|
||||
if (indices && indices->buffer_view && indices->buffer_view->buffer->data)
|
||||
{
|
||||
cgltf_size index_bound = cgltf_calc_index_bound(indices->buffer_view, indices->offset, indices->component_type, indices->count);
|
||||
if (indices && indices->buffer_view && indices->buffer_view->buffer->data)
|
||||
{
|
||||
cgltf_size index_bound = cgltf_calc_index_bound(indices->buffer_view, indices->offset, indices->component_type, indices->count);
|
||||
|
||||
CGLTF_ASSERT_IF(index_bound >= first->count, cgltf_result_data_too_short);
|
||||
}
|
||||
CGLTF_ASSERT_IF(index_bound >= first->count, cgltf_result_data_too_short);
|
||||
}
|
||||
|
||||
for (cgltf_size k = 0; k < data->meshes[i].primitives[j].mappings_count; ++k)
|
||||
{
|
||||
CGLTF_ASSERT_IF(data->meshes[i].primitives[j].mappings[k].variant >= data->variants_count, cgltf_result_invalid_gltf);
|
||||
}
|
||||
for (cgltf_size k = 0; k < data->meshes[i].primitives[j].mappings_count; ++k)
|
||||
{
|
||||
CGLTF_ASSERT_IF(data->meshes[i].primitives[j].mappings[k].variant >= data->variants_count, cgltf_result_invalid_gltf);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1728,6 +1742,11 @@ cgltf_result cgltf_validate(cgltf_data* data)
|
|||
}
|
||||
}
|
||||
|
||||
for (cgltf_size i = 0; i < data->variants_count; ++i)
|
||||
{
|
||||
CGLTF_ASSERT_IF(!data->variants[i].name, cgltf_result_invalid_gltf);
|
||||
}
|
||||
|
||||
return cgltf_result_success;
|
||||
}
|
||||
|
||||
|
@ -1902,7 +1921,7 @@ void cgltf_free(cgltf_data* data)
|
|||
|
||||
data->memory.free_func(data->memory.user_data, data->materials);
|
||||
|
||||
for (cgltf_size i = 0; i < data->images_count; ++i)
|
||||
for (cgltf_size i = 0; i < data->images_count; ++i)
|
||||
{
|
||||
data->memory.free_func(data->memory.user_data, data->images[i].name);
|
||||
data->memory.free_func(data->memory.user_data, data->images[i].uri);
|
||||
|
@ -2550,7 +2569,7 @@ cgltf_size cgltf_animation_channel_index(const cgltf_animation* animation, const
|
|||
return (cgltf_size)(object - animation->channels);
|
||||
}
|
||||
|
||||
cgltf_size cgltf_accessor_unpack_indices(const cgltf_accessor* accessor, cgltf_uint* out, cgltf_size index_count)
|
||||
cgltf_size cgltf_accessor_unpack_indices(const cgltf_accessor* accessor, void* out, cgltf_size out_component_size, cgltf_size index_count)
|
||||
{
|
||||
if (out == NULL)
|
||||
{
|
||||
|
@ -2558,6 +2577,7 @@ cgltf_size cgltf_accessor_unpack_indices(const cgltf_accessor* accessor, cgltf_u
|
|||
}
|
||||
|
||||
index_count = accessor->count < index_count ? accessor->count : index_count;
|
||||
cgltf_size index_component_size = cgltf_component_size(accessor->component_type);
|
||||
|
||||
if (accessor->is_sparse)
|
||||
{
|
||||
|
@ -2567,6 +2587,10 @@ cgltf_size cgltf_accessor_unpack_indices(const cgltf_accessor* accessor, cgltf_u
|
|||
{
|
||||
return 0;
|
||||
}
|
||||
if (index_component_size > out_component_size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
const uint8_t* element = cgltf_buffer_view_data(accessor->buffer_view);
|
||||
if (element == NULL)
|
||||
{
|
||||
|
@ -2574,18 +2598,29 @@ cgltf_size cgltf_accessor_unpack_indices(const cgltf_accessor* accessor, cgltf_u
|
|||
}
|
||||
element += accessor->offset;
|
||||
|
||||
if (accessor->component_type == cgltf_component_type_r_32u && accessor->stride == sizeof(cgltf_uint))
|
||||
if (index_component_size == out_component_size && accessor->stride == out_component_size)
|
||||
{
|
||||
memcpy(out, element, index_count * sizeof(cgltf_uint));
|
||||
memcpy(out, element, index_count * index_component_size);
|
||||
return index_count;
|
||||
}
|
||||
else
|
||||
{
|
||||
cgltf_uint* dest = out;
|
||||
|
||||
for (cgltf_size index = 0; index < index_count; index++, dest++, element += accessor->stride)
|
||||
// The component size of the output array is larger than the component size of the index data, so index data will be padded.
|
||||
switch (out_component_size)
|
||||
{
|
||||
case 2:
|
||||
for (cgltf_size index = 0; index < index_count; index++, element += accessor->stride)
|
||||
{
|
||||
*dest = (cgltf_uint)cgltf_component_read_index(element, accessor->component_type);
|
||||
((uint16_t*)out)[index] = (uint16_t)cgltf_component_read_index(element, accessor->component_type);
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
for (cgltf_size index = 0; index < index_count; index++, element += accessor->stride)
|
||||
{
|
||||
((uint32_t*)out)[index] = (uint32_t)cgltf_component_read_index(element, accessor->component_type);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return index_count;
|
||||
|
@ -2596,7 +2631,7 @@ cgltf_size cgltf_accessor_unpack_indices(const cgltf_accessor* accessor, cgltf_u
|
|||
#define CGLTF_ERROR_LEGACY -3
|
||||
|
||||
#define CGLTF_CHECK_TOKTYPE(tok_, type_) if ((tok_).type != (type_)) { return CGLTF_ERROR_JSON; }
|
||||
#define CGLTF_CHECK_TOKTYPE_RETTYPE(tok_, type_, ret_) if ((tok_).type != (type_)) { return (ret_)CGLTF_ERROR_JSON; }
|
||||
#define CGLTF_CHECK_TOKTYPE_RET(tok_, type_, ret_) if ((tok_).type != (type_)) { return ret_; }
|
||||
#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 */
|
||||
|
||||
#define CGLTF_PTRINDEX(type, idx) (type*)((cgltf_size)idx + 1)
|
||||
|
@ -2623,12 +2658,13 @@ static int cgltf_json_to_int(jsmntok_t const* tok, const uint8_t* json_chunk)
|
|||
|
||||
static cgltf_size cgltf_json_to_size(jsmntok_t const* tok, const uint8_t* json_chunk)
|
||||
{
|
||||
CGLTF_CHECK_TOKTYPE_RETTYPE(*tok, JSMN_PRIMITIVE, cgltf_size);
|
||||
CGLTF_CHECK_TOKTYPE_RET(*tok, JSMN_PRIMITIVE, 0);
|
||||
char tmp[128];
|
||||
int size = (size_t)(tok->end - tok->start) < sizeof(tmp) ? (int)(tok->end - tok->start) : (int)(sizeof(tmp) - 1);
|
||||
strncpy(tmp, (const char*)json_chunk + tok->start, size);
|
||||
tmp[size] = 0;
|
||||
return (cgltf_size)CGLTF_ATOLL(tmp);
|
||||
long long res = CGLTF_ATOLL(tmp);
|
||||
return res < 0 ? 0 : (cgltf_size)res;
|
||||
}
|
||||
|
||||
static cgltf_float cgltf_json_to_float(jsmntok_t const* tok, const uint8_t* json_chunk)
|
||||
|
@ -2810,6 +2846,11 @@ static void cgltf_parse_attribute_type(const char* name, cgltf_attribute_type* o
|
|||
if (us && *out_type != cgltf_attribute_type_invalid)
|
||||
{
|
||||
*out_index = CGLTF_ATOI(us + 1);
|
||||
if (*out_index < 0)
|
||||
{
|
||||
*out_type = cgltf_attribute_type_invalid;
|
||||
*out_index = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -3142,6 +3183,31 @@ static int cgltf_parse_json_material_mappings(cgltf_options* options, jsmntok_t
|
|||
return i;
|
||||
}
|
||||
|
||||
static cgltf_primitive_type cgltf_json_to_primitive_type(jsmntok_t const* tok, const uint8_t* json_chunk)
|
||||
{
|
||||
int type = cgltf_json_to_int(tok, json_chunk);
|
||||
|
||||
switch (type)
|
||||
{
|
||||
case 0:
|
||||
return cgltf_primitive_type_points;
|
||||
case 1:
|
||||
return cgltf_primitive_type_lines;
|
||||
case 2:
|
||||
return cgltf_primitive_type_line_loop;
|
||||
case 3:
|
||||
return cgltf_primitive_type_line_strip;
|
||||
case 4:
|
||||
return cgltf_primitive_type_triangles;
|
||||
case 5:
|
||||
return cgltf_primitive_type_triangle_strip;
|
||||
case 6:
|
||||
return cgltf_primitive_type_triangle_fan;
|
||||
default:
|
||||
return cgltf_primitive_type_invalid;
|
||||
}
|
||||
}
|
||||
|
||||
static int cgltf_parse_json_primitive(cgltf_options* options, jsmntok_t const* tokens, int i, const uint8_t* json_chunk, cgltf_primitive* out_prim)
|
||||
{
|
||||
CGLTF_CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
|
||||
|
@ -3158,9 +3224,7 @@ static int cgltf_parse_json_primitive(cgltf_options* options, jsmntok_t const* t
|
|||
if (cgltf_json_strcmp(tokens+i, json_chunk, "mode") == 0)
|
||||
{
|
||||
++i;
|
||||
out_prim->type
|
||||
= (cgltf_primitive_type)
|
||||
cgltf_json_to_int(tokens+i, json_chunk);
|
||||
out_prim->type = cgltf_json_to_primitive_type(tokens+i, json_chunk);
|
||||
++i;
|
||||
}
|
||||
else if (cgltf_json_strcmp(tokens+i, json_chunk, "indices") == 0)
|
||||
|
@ -3410,7 +3474,7 @@ static int cgltf_parse_json_accessor_sparse(jsmntok_t const* tokens, int i, cons
|
|||
if (cgltf_json_strcmp(tokens+i, json_chunk, "count") == 0)
|
||||
{
|
||||
++i;
|
||||
out_sparse->count = cgltf_json_to_int(tokens + i, json_chunk);
|
||||
out_sparse->count = cgltf_json_to_size(tokens + i, json_chunk);
|
||||
++i;
|
||||
}
|
||||
else if (cgltf_json_strcmp(tokens+i, json_chunk, "indices") == 0)
|
||||
|
@ -3546,8 +3610,7 @@ static int cgltf_parse_json_accessor(cgltf_options* options, jsmntok_t const* to
|
|||
else if (cgltf_json_strcmp(tokens+i, json_chunk, "count") == 0)
|
||||
{
|
||||
++i;
|
||||
out_accessor->count =
|
||||
cgltf_json_to_int(tokens+i, json_chunk);
|
||||
out_accessor->count = cgltf_json_to_size(tokens+i, json_chunk);
|
||||
++i;
|
||||
}
|
||||
else if (cgltf_json_strcmp(tokens+i, json_chunk, "type") == 0)
|
||||
|
@ -3700,7 +3763,7 @@ static int cgltf_parse_json_texture_view(cgltf_options* options, jsmntok_t const
|
|||
out_texture_view->texcoord = cgltf_json_to_int(tokens + i, json_chunk);
|
||||
++i;
|
||||
}
|
||||
else if (cgltf_json_strcmp(tokens + i, json_chunk, "scale") == 0)
|
||||
else if (cgltf_json_strcmp(tokens + i, json_chunk, "scale") == 0)
|
||||
{
|
||||
++i;
|
||||
out_texture_view->scale = cgltf_json_to_float(tokens + i, json_chunk);
|
||||
|
@ -3769,11 +3832,11 @@ static int cgltf_parse_json_pbr_metallic_roughness(cgltf_options* options, jsmnt
|
|||
if (cgltf_json_strcmp(tokens+i, json_chunk, "metallicFactor") == 0)
|
||||
{
|
||||
++i;
|
||||
out_pbr->metallic_factor =
|
||||
out_pbr->metallic_factor =
|
||||
cgltf_json_to_float(tokens + i, json_chunk);
|
||||
++i;
|
||||
}
|
||||
else if (cgltf_json_strcmp(tokens+i, json_chunk, "roughnessFactor") == 0)
|
||||
else if (cgltf_json_strcmp(tokens+i, json_chunk, "roughnessFactor") == 0)
|
||||
{
|
||||
++i;
|
||||
out_pbr->roughness_factor =
|
||||
|
@ -4241,11 +4304,11 @@ static int cgltf_parse_json_image(cgltf_options* options, jsmntok_t const* token
|
|||
int size = tokens[i].size;
|
||||
++i;
|
||||
|
||||
for (int j = 0; j < size; ++j)
|
||||
for (int j = 0; j < size; ++j)
|
||||
{
|
||||
CGLTF_CHECK_KEY(tokens[i]);
|
||||
|
||||
if (cgltf_json_strcmp(tokens + i, json_chunk, "uri") == 0)
|
||||
if (cgltf_json_strcmp(tokens + i, json_chunk, "uri") == 0)
|
||||
{
|
||||
i = cgltf_parse_json_string(options, tokens, i + 1, json_chunk, &out_image->uri);
|
||||
}
|
||||
|
@ -4325,7 +4388,7 @@ static int cgltf_parse_json_sampler(cgltf_options* options, jsmntok_t const* tok
|
|||
= cgltf_json_to_int(tokens + i, json_chunk);
|
||||
++i;
|
||||
}
|
||||
else if (cgltf_json_strcmp(tokens + i, json_chunk, "wrapT") == 0)
|
||||
else if (cgltf_json_strcmp(tokens + i, json_chunk, "wrapT") == 0)
|
||||
{
|
||||
++i;
|
||||
out_sampler->wrap_t
|
||||
|
@ -4375,7 +4438,7 @@ static int cgltf_parse_json_texture(cgltf_options* options, jsmntok_t const* tok
|
|||
out_texture->sampler = CGLTF_PTRINDEX(cgltf_sampler, cgltf_json_to_int(tokens + i, json_chunk));
|
||||
++i;
|
||||
}
|
||||
else if (cgltf_json_strcmp(tokens + i, json_chunk, "source") == 0)
|
||||
else if (cgltf_json_strcmp(tokens + i, json_chunk, "source") == 0)
|
||||
{
|
||||
++i;
|
||||
out_texture->image = CGLTF_PTRINDEX(cgltf_image, cgltf_json_to_int(tokens + i, json_chunk));
|
||||
|
@ -4786,7 +4849,7 @@ static int cgltf_parse_json_meshopt_compression(cgltf_options* options, jsmntok_
|
|||
else if (cgltf_json_strcmp(tokens+i, json_chunk, "count") == 0)
|
||||
{
|
||||
++i;
|
||||
out_meshopt_compression->count = cgltf_json_to_int(tokens+i, json_chunk);
|
||||
out_meshopt_compression->count = cgltf_json_to_size(tokens+i, json_chunk);
|
||||
++i;
|
||||
}
|
||||
else if (cgltf_json_strcmp(tokens+i, json_chunk, "mode") == 0)
|
||||
|
|
|
@ -178,8 +178,8 @@ typedef struct {
|
|||
cgltf_write_line(context, "}"); }
|
||||
|
||||
#ifndef CGLTF_CONSTS
|
||||
static const cgltf_size GlbHeaderSize = 12;
|
||||
static const cgltf_size GlbChunkHeaderSize = 8;
|
||||
#define GlbHeaderSize 12
|
||||
#define GlbChunkHeaderSize 8
|
||||
static const uint32_t GlbVersion = 2;
|
||||
static const uint32_t GlbMagic = 0x46546C67;
|
||||
static const uint32_t GlbMagicJsonChunk = 0x4E4F534A;
|
||||
|
|
Loading…
Reference in New Issue