package vendor:cgltf

Source

accessor :: struct {
	name:             cstring,
	component_type:   component_type,
	normalized:       b32,
	type:             type,
	offset:           uint,
	count:            uint,
	stride:           uint,
	buffer_view:      ^buffer_view,
	has_min:          b32,
	min:              [16]f32,
	has_max:          b32,
	max:              [16]f32,
	is_sparse:        b32,
	sparse:           accessor_sparse,
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

accessor_sparse :: struct {
	count:                    uint,
	indices_buffer_view:      ^buffer_view,
	indices_byte_offset:      uint,
	indices_component_type:   component_type,
	values_buffer_view:       ^buffer_view,
	values_byte_offset:       uint,
	extras:                   extras_t,
	indices_extras:           extras_t,
	values_extras:            extras_t,
	extensions_count:         uint,
	extensions:               [^]extension,
	indices_extensions_count: uint,
	indices_extensions:       [^]extension,
	values_extensions_count:  uint,
	values_extensions:        [^]extension,
}

alpha_mode :: enum i32 {
	opaque, 
	mask, 
	blend, 
}

animation :: struct {
	name:             cstring,
	samplers:         []animation_sampler,
	channels:         []animation_channel,
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

animation_channel :: struct {
	sampler:          ^animation_sampler,
	target_node:      ^node,
	target_path:      animation_path_type,
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

animation_path_type :: enum i32 {
	invalid, 
	translation, 
	rotation, 
	scale, 
	weights, 
}

animation_sampler :: struct {
	input:            ^accessor,
	output:           ^accessor,
	interpolation:    interpolation_type,
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

asset :: struct {
	copyright:        cstring,
	generator:        cstring,
	version:          cstring,
	min_version:      cstring,
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

attribute :: struct {
	name:  cstring,
	type:  attribute_type,
	index: i32,
	data:  ^accessor,
}

attribute_type :: enum i32 {
	invalid, 
	position, 
	normal, 
	tangent, 
	texcoord, 
	color, 
	joints, 
	weights, 
	custom, 
}

buffer :: struct {
	name:             cstring,
	size:             uint,
	uri:              cstring,
	data:             rawptr,
	// loaded by cgltf_load_buffers 
	data_free_method: data_free_method,
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

buffer_view :: struct {
	name:                    cstring,
	buffer:                  ^buffer,
	offset:                  uint,
	size:                    uint,
	stride:                  uint,
	// 0 == automatically determined by accessor 
	type:                    buffer_view_type,
	data:                    rawptr,
	// overrides buffer->data if present, filled by extensions 
	has_meshopt_compression: b32,
	meshopt_compression:     meshopt_compression,
	extras:                  extras_t,
	extensions_count:        uint,
	extensions:              [^]extension,
}

buffer_view_type :: enum i32 {
	invalid, 
	indices, 
	vertices, 
}

camera :: struct {
	name:             cstring,
	type:             camera_type,
	data:             struct #raw_union {
		perspective:  ,
		orthographic: ,
	},
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

camera_orthographic :: struct {
	xmag:   f32,
	ymag:   f32,
	zfar:   f32,
	znear:  f32,
	extras: extras_t,
}

camera_perspective :: struct {
	has_aspect_ratio: b32,
	aspect_ratio:     f32,
	yfov:             f32,
	has_zfar:         b32,
	zfar:             f32,
	znear:            f32,
	extras:           extras_t,
}

camera_type :: enum i32 {
	invalid, 
	perspective, 
	orthographic, 
}

clearcoat :: struct {
	clearcoat_texture:           texture_view,
	clearcoat_roughness_texture: texture_view,
	clearcoat_normal_texture:    texture_view,
	clearcoat_factor:            f32,
	clearcoat_roughness_factor:  f32,
}

component_type :: enum i32 {
	invalid, 
	r_8,     // BYTE
	r_8u,    // UNSIGNED_BYTE
	r_16,    // SHORT
	r_16u,   // UNSIGNED_SHORT
	r_32u,   // UNSIGNED_INT
	r_32f,   // FLOAT
}

data :: struct {
	file_type:             file_type,
	file_data:             rawptr,
	asset:                 asset,
	meshes:                []mesh,
	materials:             []material,
	accessors:             []accessor,
	buffer_views:          []buffer_view,
	buffers:               []buffer,
	images:                []image,
	textures:              []texture,
	samplers:              []sampler,
	skins:                 []skin,
	cameras:               []camera,
	lights:                []light,
	nodes:                 []node,
	scenes:                []scene,
	scene:                 ^scene,
	animations:            []animation,
	variants:              []material_variant,
	extras:                extras_t,
	data_extensions_count: uint,
	data_extensions:       [^]extension,
	extensions_used:       []cstring,
	extensions_required:   []cstring,
	json:                  string,
	bin:                   []u8,
	memory:                memory_options,
	file:                  file_options,
}

data_free_method :: enum i32 {
	none, 
	file_release, 
	memory_free, 
}

draco_mesh_compression :: struct {
	buffer_view: ^buffer_view,
	attributes:  []attribute,
}

emissive_strength :: struct {
	emissive_strength: f32,
}

extension :: struct {
	name: cstring,
	data: [^]u8,
}

extras_t :: struct {
	start_offset: uint,
	// this field is deprecated and will be removed in the future; use data instead 
	end_offset:   uint,
	// this field is deprecated and will be removed in the future; use data instead 
	data:         [^]u8,
}

file_options :: struct {
	read:      proc "cdecl" (memory_options: , file_options: , path: , size: , data: ) -> result,
	release:   proc "cdecl" (memory_options: , file_options: , data: ),
	user_data: rawptr,
}

file_type :: enum i32 {
	invalid, 
	gltf, 
	glb, 
}

image :: struct {
	name:             cstring,
	uri:              cstring,
	buffer_view:      ^buffer_view,
	mime_type:        cstring,
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

interpolation_type :: enum i32 {
	linear, 
	step, 
	cubic_spline, 
}

ior :: struct {
	ior: f32,
}

iridescence :: struct {
	iridescence_factor:            f32,
	iridescence_texture:           texture_view,
	iridescence_ior:               f32,
	iridescence_thickness_min:     f32,
	iridescence_thickness_max:     f32,
	iridescence_thickness_texture: texture_view,
}

light :: struct {
	name:                  cstring,
	color:                 [3]f32,
	intensity:             f32,
	type:                  light_type,
	range:                 f32,
	spot_inner_cone_angle: f32,
	spot_outer_cone_angle: f32,
	extras:                extras_t,
}

light_type :: enum i32 {
	invalid, 
	directional, 
	point, 
	spot, 
}

material :: struct {
	name:                        cstring,
	has_pbr_metallic_roughness:  b32,
	has_pbr_specular_glossiness: b32,
	has_clearcoat:               b32,
	has_transmission:            b32,
	has_volume:                  b32,
	has_ior:                     b32,
	has_specular:                b32,
	has_sheen:                   b32,
	has_emissive_strength:       b32,
	has_iridescence:             b32,
	pbr_metallic_roughness:      pbr_metallic_roughness,
	pbr_specular_glossiness:     pbr_specular_glossiness,
	clearcoat:                   clearcoat,
	ior:                         ior,
	specular:                    specular,
	sheen:                       sheen,
	transmission:                transmission,
	volume:                      volume,
	emissive_strength:           emissive_strength,
	iridescence:                 iridescence,
	normal_texture:              texture_view,
	occlusion_texture:           texture_view,
	emissive_texture:            texture_view,
	emissive_factor:             [3]f32,
	alpha_mode:                  alpha_mode,
	alpha_cutoff:                f32,
	double_sided:                b32,
	unlit:                       b32,
	extras:                      extras_t,
	extensions_count:            uint,
	extensions:                  [^]extension,
}

material_mapping :: struct {
	variant:  uint,
	material: ^material,
	extras:   extras_t,
}

material_variant :: struct {
	name:   cstring,
	extras: extras_t,
}

memory_options :: struct {
	alloc_func: proc "cdecl" (user: , size: ) -> rawptr,
	free_func:  proc "cdecl" (user: , ptr: ),
	user_data:  rawptr,
}

mesh :: struct {
	name:             cstring,
	primitives:       []primitive,
	weights:          []f32,
	target_names:     []cstring,
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

mesh_gpu_instancing :: struct {
	buffer_view: ^buffer_view,
	attributes:  []attribute,
}

meshopt_compression :: struct {
	buffer: ^buffer,
	offset: uint,
	size:   uint,
	stride: uint,
	count:  uint,
	mode:   meshopt_compression_mode,
	filter: meshopt_compression_filter,
}

meshopt_compression_filter :: enum i32 {
	none, 
	octahedral, 
	quaternion, 
	exponential, 
}

meshopt_compression_mode :: enum i32 {
	invalid, 
	attributes, 
	triangles, 
	indices, 
}

morph_target :: struct {
	attributes: []attribute,
}

node :: struct {
	name:                    cstring,
	parent:                  ^node,
	children:                []^node,
	skin:                    ^skin,
	mesh:                    ^mesh,
	camera:                  ^camera,
	light:                   ^light,
	weights:                 []f32,
	has_translation:         b32,
	has_rotation:            b32,
	has_scale:               b32,
	has_matrix:              b32,
	translation:             [3]f32,
	rotation:                [4]f32,
	scale:                   [3]f32,
	matrix_:                 [16]f32,
	extras:                  extras_t,
	has_mesh_gpu_instancing: b32,
	mesh_gpu_instancing:     mesh_gpu_instancing,
	extensions_count:        uint,
	extensions:              [^]extension,
}

options :: struct {
	type:             file_type,
	// invalid == auto detect 
	json_token_count: uint,
	// 0 == auto 
	memory:           memory_options,
	file:             file_options,
}

pbr_metallic_roughness :: struct {
	base_color_texture:         texture_view,
	metallic_roughness_texture: texture_view,
	base_color_factor:          [4]f32,
	metallic_factor:            f32,
	roughness_factor:           f32,
}

pbr_specular_glossiness :: struct {
	diffuse_texture:             texture_view,
	specular_glossiness_texture: texture_view,
	diffuse_factor:              [4]f32,
	specular_factor:             [3]f32,
	glossiness_factor:           f32,
}

primitive :: struct {
	type:                       primitive_type,
	indices:                    ^accessor,
	material:                   ^material,
	attributes:                 []attribute,
	targets:                    []morph_target,
	extras:                     extras_t,
	has_draco_mesh_compression: b32,
	draco_mesh_compression:     draco_mesh_compression,
	mappings:                   []material_mapping,
	extensions_count:           uint,
	extensions:                 [^]extension,
}

primitive_type :: enum i32 {
	points, 
	lines, 
	line_loop, 
	line_strip, 
	triangles, 
	triangle_strip, 
	triangle_fan, 
}

result :: enum i32 {
	success, 
	data_too_short, 
	unknown_format, 
	invalid_json, 
	invalid_gltf, 
	invalid_options, 
	file_not_found, 
	io_error, 
	out_of_memory, 
	legacy_gltf, 
}

sampler :: struct {
	name:             cstring,
	mag_filter:       i32,
	min_filter:       i32,
	wrap_s:           i32,
	wrap_t:           i32,
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

scene :: struct {
	name:             cstring,
	nodes:            []^node,
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

sheen :: struct {
	sheen_color_texture:     texture_view,
	sheen_color_factor:      [3]f32,
	sheen_roughness_texture: texture_view,
	sheen_roughness_factor:  f32,
}

skin :: struct {
	name:                  cstring,
	joints:                []^node,
	skeleton:              ^node,
	inverse_bind_matrices: ^accessor,
	extras:                extras_t,
	extensions_count:      uint,
	extensions:            [^]extension,
}

specular :: struct {
	specular_texture:       texture_view,
	specular_color_texture: texture_view,
	specular_color_factor:  [3]f32,
	specular_factor:        f32,
}

texture :: struct {
	name:             cstring,
	image_:           ^image,
	sampler:          ^sampler,
	has_basisu:       b32,
	basisu_image:     ^image,
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

texture_transform :: struct {
	offset:       [2]f32,
	rotation:     f32,
	scale:        [2]f32,
	has_texcoord: b32,
	texcoord:     i32,
}

texture_view :: struct {
	texture:          ^texture,
	texcoord:         i32,
	scale:            f32,
	// equivalent to strength for occlusion_texture 
	has_transform:    b32,
	transform:        texture_transform,
	extras:           extras_t,
	extensions_count: uint,
	extensions:       [^]extension,
}

transmission :: struct {
	transmission_texture: texture_view,
	transmission_factor:  f32,
}

type :: enum i32 {
	invalid, 
	scalar, 
	vec2, 
	vec3, 
	vec4, 
	mat2, 
	mat3, 
	mat4, 
}

volume :: struct {
	thickness_texture:    texture_view,
	thickness_factor:     f32,
	attenuation_color:    [3]f32,
	attenuation_distance: f32,
}

accessor_read_float :: proc "cdecl" (accessor: ^accessor, index: uint, out: [^]f32, element_size: uint) -> b32 ---

accessor_read_index :: proc "cdecl" (accessor: ^accessor, index: uint) -> uint ---

accessor_read_uint :: proc "cdecl" (accessor: ^accessor, index: uint, out: [^]u32, element_size: uint) -> b32 ---

accessor_unpack_floats :: proc "cdecl" (accessor: ^accessor, out: [^]f32, float_count: uint) -> uint ---

copy_extras_json :: proc "cdecl" (data: ^data, extras: ^extras_t, dest: [^]u8, dest_size: ^uint) -> result ---

decode_string :: proc "cdecl" (string: [^]u8) -> uint ---

decode_uri :: proc "cdecl" (uri: [^]u8) -> uint ---

free :: proc "cdecl" (data: ^data) ---

load_buffer_base64 :: proc "cdecl" (options: options, size: uint, base64: cstring) -> (out_data: rawptr, res: result) {…}

load_buffers :: proc "cdecl" (options: options, data: ^data, gltf_path: cstring) -> result ---

node_transform_local :: proc "cdecl" (node: ^node, out_matrix: [^]f32) ---

node_transform_world :: proc "cdecl" (node: ^node, out_matrix: [^]f32) ---

num_components :: proc "cdecl" (type: type) -> uint ---

parse :: proc "cdecl" (options: options, data_ptr: rawptr, size: uint) -> (out_data: ^data, res: result) {…}

parse_file :: proc "cdecl" (options: options, path: cstring) -> (out_data: ^data, res: result) {…}

validate :: proc "cdecl" (data: ^data) -> result ---

write :: proc "cdecl" (options: options, buffer: [^]u8, size: uint, data: ^data) -> uint ---

write_file :: proc "cdecl" (options: options, path: cstring, data: ^data) -> result ---