package vendor:cgltf

⌘K
Ctrl+K
or
/

    Types

    accessor ¶

    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,
    }
    Related Procedures With Parameters

    accessor_sparse ¶

    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 ¶

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

    animation ¶

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

    animation_channel ¶

    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 ¶

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

    animation_sampler ¶

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

    asset ¶

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

    attribute ¶

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

    attribute_type ¶

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

    buffer ¶

    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 ¶

    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 ¶

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

    camera ¶

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

    camera_orthographic ¶

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

    camera_perspective ¶

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

    camera_type ¶

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

    clearcoat ¶

    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 ¶

    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 ¶

    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,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    data_free_method ¶

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

    draco_mesh_compression ¶

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

    emissive_strength ¶

    emissive_strength :: struct {
    	emissive_strength: f32,
    }

    extension ¶

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

    extras_t ¶

    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,
    }
    Related Procedures With Parameters

    file_options ¶

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

    file_type ¶

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

    image ¶

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

    interpolation_type ¶

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

    ior ¶

    ior :: struct {
    	ior: f32,
    }

    iridescence ¶

    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 ¶

    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 ¶

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

    material ¶

    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 ¶

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

    material_variant ¶

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

    memory_options ¶

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

    mesh ¶

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

    mesh_gpu_instancing ¶

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

    meshopt_compression ¶

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

    meshopt_compression_filter ¶

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

    meshopt_compression_mode ¶

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

    morph_target ¶

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

    node ¶

    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,
    }
    Related Procedures With Parameters

    options ¶

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

    pbr_metallic_roughness ¶

    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 ¶

    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 ¶

    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 ¶

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

    result ¶

    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, 
    }
    Related Procedures With Returns

    sampler ¶

    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 ¶

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

    sheen ¶

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

    skin ¶

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

    specular ¶

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

    texture ¶

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

    texture_transform ¶

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

    texture_view ¶

    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 ¶

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

    type ¶

    type :: enum i32 {
    	invalid, 
    	scalar, 
    	vec2, 
    	vec3, 
    	vec4, 
    	mat2, 
    	mat3, 
    	mat4, 
    }
    Related Procedures With Parameters

    volume ¶

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

    Constants

    This section is empty.

    Variables

    This section is empty.

    Procedures

    accessor_read_float ¶

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

    accessor_read_index ¶

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

    accessor_read_uint ¶

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

    accessor_unpack_floats ¶

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

    copy_extras_json ¶

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

    this function is deprecated and will be removed in the future; use cgltf_extras::data instead

    decode_string ¶

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

    decode_uri ¶

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

    free ¶

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

    load_buffer_base64 ¶

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

    load_buffers ¶

    load_buffers :: proc "c" (#by_ptr options: options, data: ^data, gltf_path: cstring) -> result ---

    node_transform_local ¶

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

    node_transform_world ¶

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

    num_components ¶

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

    parse ¶

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

    parse_file ¶

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

    validate ¶

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

    write ¶

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

    write_file ¶

    write_file :: proc "c" (#by_ptr options: options, path: cstring, data: ^data) -> result ---

    Procedure Groups

    This section is empty.

    Source Files

    Generation Information

    Generated with odin version dev-2024-04 (vendor "odin") Windows_amd64 @ 2024-04-23 21:09:30.809972100 +0000 UTC