Esc

Gltf

moduleextensionSource
  • macOS: Everything works on macOS
  • Linux: Everything works on Linux
  • Windows: Everything works on Windows
  • Wasm: 1 item is not available on Wasm
·since 0.36.1

#import "Extensions/Gltf";

Loads, validates and writes glTF 2.0 assets (JSON text or binary GLB) within explicit limits. Nothing here touches the file system or network: external buffers and images come from a Gltf_Resolver you supply. Closed sets in the document are enums, such as asset.document.accessors[0].component_type == .FLOAT and .type == .VEC3.

Example↗
#import "Extensions/Gltf";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"}}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(asset.document.asset.version == "2.0");

Procedures#

General#

gltf_loadsince 0.36.1Source
(bytes: string, resolver := Gltf_Resolver.{}, options := Gltf_Options.{}) -> (Gltf_Asset, Gltf_Error)

Decode text or GLB bytes and validate before returning.

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scene\":0,\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"mesh\":0}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0},\"indices\":1}]}],\"buffers\":[{\"byteLength\":42,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAAAAABAAIA\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":36,\"target\":34962},{\"buffer\":0,\"byteOffset\":36,\"byteLength\":6,\"target\":34963}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]},{\"bufferView\":1,\"componentType\":5123,\"count\":3,\"type\":\"SCALAR\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(asset.document.meshes.count == 1);
assert(asset.document.accessors[0].type == .VEC3);

_, bad := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{\"children\":[3]}]}");
assert(bad.kind == .INVALID);
↗
gltf_freesince 0.36.1Source
(asset: *Gltf_Asset)

Release a loaded asset.

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"buffers\":[{\"byteLength\":4,\"uri\":\"data:application/octet-stream;base64,AAAAAA==\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":4,\"target\":34962}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
gltf_free(*asset);
assert(asset.buffers.count == 0);
↗

Validate#

(asset: *Gltf_Asset, options := Gltf_Options.{}) -> Gltf_Error

Check core references, layouts and hierarchy.

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scene\":0,\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"mesh\":0}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0},\"indices\":1}]}],\"buffers\":[{\"byteLength\":42,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAAAAABAAIA\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":36,\"target\":34962},{\"buffer\":0,\"byteOffset\":36,\"byteLength\":6,\"target\":34963}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]},{\"bufferView\":1,\"componentType\":5123,\"count\":3,\"type\":\"SCALAR\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(gltf_validate(*asset).kind == .NONE);

limited := gltf_validate(*asset, .{ max_count = 1 }); // fewer objects than the document has
assert(limited.kind == .LIMIT);
gltf_error_free(*limited);
↗

Accessor#

(asset: *Gltf_Asset, index: s64) -> (Gltf_Cursor, Gltf_Error)

Start allocation-free iteration over an asset from gltf_load or gltf_validate. Do not mutate it. .

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scene\":0,\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"mesh\":0}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0},\"indices\":1}]}],\"buffers\":[{\"byteLength\":42,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAAAAABAAIA\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":36,\"target\":34962},{\"buffer\":0,\"byteOffset\":36,\"byteLength\":6,\"target\":34963}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]},{\"bufferView\":1,\"componentType\":5123,\"count\":3,\"type\":\"SCALAR\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
cursor, cursor_error := gltf_accessor(*asset, 0);
assert(cursor_error.kind == .NONE);

count: int;
while true {
    vertex, more, step := gltf_next_floats(*cursor);
    if !more break;
    assert(step.kind == .NONE);
    if count == 1 assert(vertex[0] == 1 && vertex[1] == 0);
    count += 1;
}
assert(count == 3);
↗
(cursor: *Gltf_Cursor) -> ([16] float32, bool, Gltf_Error)

Read the next vector or matrix (column-major); use cursor.components lanes. End gives false. .

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scene\":0,\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"mesh\":0}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0},\"indices\":1}]}],\"buffers\":[{\"byteLength\":42,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAAAAABAAIA\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":36,\"target\":34962},{\"buffer\":0,\"byteOffset\":36,\"byteLength\":6,\"target\":34963}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]},{\"bufferView\":1,\"componentType\":5123,\"count\":3,\"type\":\"SCALAR\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
cursor, _ := gltf_accessor(*asset, 0);
first, more, step := gltf_next_floats(*cursor);
assert(more && step.kind == .NONE);
assert(first[0] == 0 && first[1] == 0 && first[2] == 0); // `cursor.components` lanes are used
↗
(asset: *Gltf_Asset, index: s64) -> ([] float32, Gltf_Error)

Read a whole accessor into a flat array of count * components floats, element after element (matrices column-major). Any component type works; normalized values are converted and sparse replacements applied, as with gltf_next_floats. Free the result with free(floats.data).

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scene\":0,\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"mesh\":0}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0},\"indices\":1}]}],\"buffers\":[{\"byteLength\":42,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAAAAABAAIA\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":36,\"target\":34962},{\"buffer\":0,\"byteOffset\":36,\"byteLength\":6,\"target\":34963}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]},{\"bufferView\":1,\"componentType\":5123,\"count\":3,\"type\":\"SCALAR\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
floats, unpack_error := gltf_unpack_floats(*asset, 0);
assert(unpack_error.kind == .NONE);
defer free(floats.data);
assert(floats.count == 9); // three VEC3 elements
assert(floats[3] == 1 && floats[4] == 0);
↗
(cursor: *Gltf_Cursor) -> (u32, bool, Gltf_Error)

Read an unsigned SCALAR without float rounding.

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scene\":0,\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"mesh\":0}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0},\"indices\":1}]}],\"buffers\":[{\"byteLength\":42,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAAAAABAAIA\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":36,\"target\":34962},{\"buffer\":0,\"byteOffset\":36,\"byteLength\":6,\"target\":34963}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]},{\"bufferView\":1,\"componentType\":5123,\"count\":3,\"type\":\"SCALAR\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
cursor, _ := gltf_accessor(*asset, 1);
total: u32;
while true {
    index, more, step := gltf_next_index(*cursor);
    if !more break;
    assert(step.kind == .NONE);
    total += index;
}
assert(total == 3); // 0 + 1 + 2
↗

Transform#

(node: Gltf_Node) -> Matrix4

A node's transform relative to its parent, as a Matrix4 (column vectors, m * v). A node with a matrix uses it, converted from glTF's column-major order; otherwise the result is translation times rotation times scale, with absent parts as identity. Rotation is the [x, y, z, w] quaternion. The node must come from a loaded or validated asset, which checks the lengths.

#import "Math";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{\"translation\":[1,2,3],\"scale\":[2,2,2]}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
local := gltf_node_local(asset.document.nodes[0]);
assert(transform_point(local, xyz(1, 1, 1)) == xyz(3, 4, 5));
↗
(asset: *Gltf_Asset, index: s64) -> (Matrix4, bool)

A node's transform in the scene: its local matrix after those of its ancestors, root first. The parent of every node is indexed once by gltf_load or gltf_validate, so each call only walks up the chain. It gives false for an index out of range, or an asset that was never validated.

#import "Math";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{\"translation\":[1,0,0],\"children\":[1]},{\"translation\":[0,2,0]}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
world, ok := gltf_node_world(*asset, 1);
assert(ok);
assert(transform_point(world, xyz(0, 0, 0)) == xyz(1, 2, 0));
↗

Extensions#

(extensions: *Json_Value, name: string, $T: Type) -> (T, bool, Gltf_Error)

Decode one named extension object, such as KHR_materials_ior, from the extensions of a document, node, material or texture reference into a typed struct. The result is true when the extension is present; an object of the wrong shape gives a .JSON error and found is still true. Extensions that no struct covers stay raw in extensions. Release the value with free_json (needed only for types with pointers or extras, but always allowed) and the error with gltf_error_free.

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_ior\"],\"materials\":[{\"extensions\":{\"KHR_materials_ior\":{\"ior\":1.33}}},{}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
ior, found, ior_error := gltf_extension(*asset.document.materials[0].extensions, "KHR_materials_ior", Gltf_Ior);
assert(found && ior_error.kind == .NONE && ior.ior == 1.33);
_, found = gltf_extension(*asset.document.materials[1].extensions, "KHR_materials_ior", Gltf_Ior);
assert(!found);
↗
(extensions: *Json_Value, name: string, value: $T) -> Gltf_Error

Store a typed extension in the extensions of a document, node, material or texture reference, replacing the extension of that name: the write-back of gltf_extension. An extensions that is absent becomes an object. The value is encoded straight away, so it may be freed or changed afterwards. An extensions that is not an object gives an error and is left unchanged. Declare the extension with gltf_use_extension, or the written asset will not load.

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_ior\"],\"materials\":[{\"extensions\":{\"KHR_materials_ior\":{\"ior\":1.33}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
extensions := *asset.document.materials[0].extensions;
ior, _, _ := gltf_extension(extensions, "KHR_materials_ior", Gltf_Ior);
ior.ior = 2.4;
set_error := gltf_set_extension(extensions, "KHR_materials_ior", ior);
assert(set_error.kind == .NONE);
again, _, _ := gltf_extension(extensions, "KHR_materials_ior", Gltf_Ior);
assert(again.ior == 2.4);
↗
(asset: *Gltf_Asset, name: string)

Add name to the extensionsUsed of an asset unless it is there. A written asset must list every extension its objects use; do this before gltf_set_extension adds a new one. Works on a loaded asset and on one built by hand, whose literal lists are copied (see Gltf_Asset).

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"materials\":[{}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
gltf_use_extension(*asset, "KHR_materials_ior");
gltf_use_extension(*asset, "KHR_materials_ior");
assert(asset.document.extensions_used.count == 1);
↗
(asset: *Gltf_Asset, extensions: *Json_Value, name: string) -> bool

Remove the extension name from the extensions of a document, node, material or texture reference of asset: the undo of gltf_set_extension. Once no object of the asset has the extension any more, its name also leaves extensionsUsed and extensionsRequired, so the asset still writes and loads. The result is false when extensions had no such member. extensions must belong to asset.

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_ior\"],\"materials\":[{\"extensions\":{\"KHR_materials_ior\":{\"ior\":1.33}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(gltf_remove_extension(*asset, *asset.document.materials[0].extensions, "KHR_materials_ior"));
assert(asset.document.extensions_used.count == 0);
↗

Write#

gltf_writesince 0.36.1Source
(asset: *Gltf_Asset, binary := false, options := Gltf_Options.{}) -> (string, Gltf_Error)

Encode an asset as self-contained buffer JSON or GLB; image URIs remain unchanged. .

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scene\":0,\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"mesh\":0}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0},\"indices\":1}]}],\"buffers\":[{\"byteLength\":42,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAAAAABAAIA\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":36,\"target\":34962},{\"buffer\":0,\"byteOffset\":36,\"byteLength\":6,\"target\":34963}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]},{\"bufferView\":1,\"componentType\":5123,\"count\":3,\"type\":\"SCALAR\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
text, write_error := gltf_write(*asset);
assert(write_error.kind == .NONE);
defer free(text);

again, read_error := gltf_load(text);
assert(read_error.kind == .NONE && again.buffers[0].count == 42);
gltf_free(*again);

glb, _ := gltf_write(*asset, binary = true); // the same asset as a GLB
defer free(glb);
assert(glb.count > 12 && glb[0] == #char "g" && glb[1] == #char "l");
↗

Local#

gltf_local_resolveWasm: not availablesince 0.36.1Source
(user: *void, uri: string, limit: s64) -> (string, bool)

Pass the asset's folder as user data, pointing to a string. Resolves only contained files.

folder := "assets"; // contains the .bin and image files the glTF names
resolver := Gltf_Resolver.{ gltf_local_resolve, *folder };
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"}}", resolver);
assert(error.kind == .NONE);
gltf_free(*asset);

Types#

Gltf_Error_Kindenumsince 0.36.1Source

Which stage of loading or validating failed.

Gltf_Error_Kind :: enum {
    NONE;
    JSON;
    CONTAINER;
    LIMIT;
    RESOLVE;
    INVALID;
}
_, error := gltf_load("{");
assert(error.kind == .JSON);
gltf_error_free(*error);
↗
Gltf_Errorstructsince 0.36.1Source

The outcome of a glTF operation; kind is .NONE on success. Release it with gltf_error_free.

Gltf_Error :: struct {
    kind: Gltf_Error_Kind;
    message: string;
    offset: s64;
    path: string;
}
_, error := gltf_load("glTF");
assert(error.kind == .CONTAINER);
gltf_error_free(*error);
assert(error.message.count == 0);
↗
Gltf_Optionsstructsince 0.36.1Source

Limits that keep hostile input bounded; each is checked while loading.

Gltf_Options :: struct {
    max_size: s64 = 64 * 1024 * 1024;
    max_buffer_bytes: s64 = 512 * 1024 * 1024;
    max_count: s64 = 1000000;
    max_depth: s64 = 64;
}
text := "{\"asset\":{\"version\":\"2.0\"}}";
_, error := gltf_load(text, .{}, .{ max_size = 8 });
assert(error.kind == .LIMIT);
gltf_error_free(*error);
↗
Gltf_Resolvetypesince 0.36.1Source
:: #type (user: *void, uri: string, limit: s64) -> string, bool

Resolver results are owned allocations, including on failure. Never return more than limit.

Gltf_Resolverstructsince 0.36.1Source

Fetches the external buffers and images of a document for gltf_load. resolve is called with user; leave it unset to refuse every URI except base64 data: ones.

Gltf_Resolver :: struct {
    resolve: Gltf_Resolve;
    user: *void;
}
resolve :: (user: *void, uri: string, limit: s64) -> string, bool {
    if uri != "data.bin" return "", false;
    return copy_string("\x00\x00\x00\x00"), true; // owned by the loader
}

main :: () {
    text := "{\"asset\":{\"version\":\"2.0\"},\"buffers\":[{\"byteLength\":4,\"uri\":\"data.bin\"}]}";
    asset, error := gltf_load(text, .{ resolve = resolve });
    assert(error.kind == .NONE && asset.buffers[0].count == 4);
    gltf_free(*asset);
}
↗
Gltf_Assetstructsince 0.36.1Source

A loaded asset: the decoded document plus the bytes of each of its buffers, in the document's order. Owned; release it with gltf_free.

Gltf_Asset :: struct {
    document: Gltf_Document;
    buffers: [..] string;
    parents: [..] s64;
    owns_extension_lists: bool;
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"buffers\":[{\"byteLength\":4,\"uri\":\"data:application/octet-stream;base64,AAAAAA==\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":4,\"target\":34962}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(asset.document.buffers.count == 1);
assert(asset.buffers[0].count == 4); // the bytes of buffer 0
↗
Gltf_Cursorstructsince 0.36.1Source

A position in an accessor's elements, for gltf_next_floats and gltf_next_index. Start one with gltf_accessor; the asset must outlive it and stay unchanged. components is the number of values per element.

Gltf_Cursor :: struct {
    asset: *Gltf_Asset;
    accessor: s64;
    element: s64;
    sparse_element: s64;
    components: s64;
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scene\":0,\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"mesh\":0}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0},\"indices\":1}]}],\"buffers\":[{\"byteLength\":42,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAAAAABAAIA\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":36,\"target\":34962},{\"buffer\":0,\"byteOffset\":36,\"byteLength\":6,\"target\":34963}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]},{\"bufferView\":1,\"componentType\":5123,\"count\":3,\"type\":\"SCALAR\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
cursor, _ := gltf_accessor(*asset, 0);
assert(cursor.components == 3); // a VEC3 element has three values
↗
Gltf_Componentenumsince 0.36.1Source

The type of an accessor's components, with the glTF numeric codes. The enums in this file mirror the spec's closed sets: numeric ones are written as numbers, string ones in the spec's spelling, and a value outside the set fails to decode.

Gltf_Component :: enum u32 {
    BYTE :: 5120;
    UNSIGNED_BYTE :: 5121;
    SHORT :: 5122;
    UNSIGNED_SHORT :: 5123;
    UNSIGNED_INT :: 5125;
    FLOAT :: 5126;
}
assert(cast(u32) Gltf_Component.FLOAT == 5126);
assert(cast(u32) Gltf_Component.UNSIGNED_SHORT == 5123);
↗
Gltf_Accessor_Typeenumsince 0.36.1Source

How many components make one accessor element: a scalar, a vector of 2 to 4, or a 2x2 to 4x4 matrix.

Gltf_Accessor_Type :: enum u8 {
    SCALAR;
    VEC2;
    VEC3;
    VEC4;
    MAT2;
    MAT3;
    MAT4;
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"accessors\":[{\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0}}]}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(asset.document.accessors[0].type == .VEC3);
↗
Gltf_Modeenumsince 0.36.1Source

How a primitive's vertices are assembled into shapes. The default is .TRIANGLES.

Gltf_Mode :: enum u32 {
    POINTS :: 0;
    LINES :: 1;
    LINE_LOOP :: 2;
    LINE_STRIP :: 3;
    TRIANGLES :: 4;
    TRIANGLE_STRIP :: 5;
    TRIANGLE_FAN :: 6;
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"accessors\":[{\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0}}]}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(asset.document.meshes[0].primitives[0].mode == .TRIANGLES); // the default
↗
Gltf_Targetenumsince 0.36.1Source

The GPU buffer a buffer view is meant for: vertex attributes or indices.

Gltf_Target :: enum u32 {
    ARRAY_BUFFER :: 34962;
    ELEMENT_ARRAY_BUFFER :: 34963;
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"buffers\":[{\"byteLength\":4,\"uri\":\"data:application/octet-stream;base64,AAAAAA==\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":4,\"target\":34962}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
view := asset.document.buffer_views[0];
assert(view.target.state == .SET && view.target.value == .ARRAY_BUFFER);
↗
Gltf_Filterenumsince 0.36.1Source

A sampler's texture filtering mode, with the glTF numeric codes.

Gltf_Filter :: enum u32 {
    NEAREST :: 9728;
    LINEAR :: 9729;
    NEAREST_MIPMAP_NEAREST :: 9984;
    LINEAR_MIPMAP_NEAREST :: 9985;
    NEAREST_MIPMAP_LINEAR :: 9986;
    LINEAR_MIPMAP_LINEAR :: 9987;
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"images\":[{\"uri\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\"}],\"samplers\":[{\"magFilter\":9729,\"wrapS\":33071}],\"textures\":[{\"sampler\":0,\"source\":0}],\"materials\":[{\"pbrMetallicRoughness\":{\"baseColorTexture\":{\"index\":0},\"metallicFactor\":0.5},\"alphaMode\":\"BLEND\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
sampler := asset.document.samplers[0];
assert(sampler.mag_filter.state == .SET && sampler.mag_filter.value == .LINEAR);
assert(sampler.min_filter.state == .MISSING);
↗
Gltf_Wrapenumsince 0.36.1Source

A sampler's texture wrapping mode, with the glTF numeric codes. The default is .REPEAT.

Gltf_Wrap :: enum u32 {
    CLAMP_TO_EDGE :: 33071;
    MIRRORED_REPEAT :: 33648;
    REPEAT :: 10497;
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"images\":[{\"uri\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\"}],\"samplers\":[{\"magFilter\":9729,\"wrapS\":33071}],\"textures\":[{\"sampler\":0,\"source\":0}],\"materials\":[{\"pbrMetallicRoughness\":{\"baseColorTexture\":{\"index\":0},\"metallicFactor\":0.5},\"alphaMode\":\"BLEND\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
sampler := asset.document.samplers[0];
assert(sampler.wrap_s == .CLAMP_TO_EDGE && sampler.wrap_t == .REPEAT);
↗
Gltf_Alpha_Modeenumsince 0.36.1Source

How a material's alpha is interpreted: ignored, thresholded by alpha_cutoff, or blended.

Gltf_Alpha_Mode :: enum u8 {
    OPAQUE;
    MASK;
    BLEND;
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"images\":[{\"uri\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\"}],\"samplers\":[{\"magFilter\":9729,\"wrapS\":33071}],\"textures\":[{\"sampler\":0,\"source\":0}],\"materials\":[{\"pbrMetallicRoughness\":{\"baseColorTexture\":{\"index\":0},\"metallicFactor\":0.5},\"alphaMode\":\"BLEND\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(asset.document.materials[0].alpha_mode == .BLEND);
↗
Gltf_Interpolationenumsince 0.36.1Source

How an animation sampler blends between keyframes. The default is .LINEAR.

Gltf_Interpolation :: enum u8 {
    LINEAR;
    STEP;
    CUBICSPLINE;
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{}],\"buffers\":[{\"byteLength\":32,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAgD8AAAAAAAAAAAAAAAAAAIA/AAAAQAAAQEA=\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":32}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":2,\"type\":\"SCALAR\",\"min\":[0],\"max\":[1]},{\"bufferView\":0,\"byteOffset\":8,\"componentType\":5126,\"count\":2,\"type\":\"VEC3\"}],\"animations\":[{\"samplers\":[{\"input\":0,\"output\":1}],\"channels\":[{\"sampler\":0,\"target\":{\"node\":0,\"path\":\"translation\"}}]}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(asset.document.animations[0].samplers[0].interpolation == .LINEAR); // the default
↗
Gltf_Pathenumsince 0.36.1Source

Which property of a node an animation channel drives. POINTER is KHR_animation_pointer's target and needs the extension object on the target.

Gltf_Path :: enum u8 {
    TRANSLATION;
    ROTATION;
    SCALE;
    WEIGHTS;
    POINTER;
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{}],\"buffers\":[{\"byteLength\":32,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAgD8AAAAAAAAAAAAAAAAAAIA/AAAAQAAAQEA=\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":32}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":2,\"type\":\"SCALAR\",\"min\":[0],\"max\":[1]},{\"bufferView\":0,\"byteOffset\":8,\"componentType\":5126,\"count\":2,\"type\":\"VEC3\"}],\"animations\":[{\"samplers\":[{\"input\":0,\"output\":1}],\"channels\":[{\"sampler\":0,\"target\":{\"node\":0,\"path\":\"translation\"}}]}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(asset.document.animations[0].channels[0].target.path == .TRANSLATION);
↗
Gltf_Camera_Typeenumsince 0.36.1Source

Whether a camera is a Gltf_Perspective or a Gltf_Orthographic projection.

Gltf_Camera_Type :: enum u8 {
    PERSPECTIVE;
    ORTHOGRAPHIC;
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"cameras\":[{\"type\":\"orthographic\",\"orthographic\":{\"xmag\":1,\"ymag\":1,\"zfar\":10,\"znear\":1}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(asset.document.cameras[0].type == .ORTHOGRAPHIC);
↗
Gltf_Documentstructsince 0.36.1Source

The glTF root object: every array of scene data, which refer to each other by index. Decoded from and encoded to JSON through the @json notes; an optional index is a Json_Maybe so that omission differs from index 0. extensions and extras keep unknown data as Json_Value.

Gltf_Document :: struct @json(rename_all=camelCase) {
    asset: Gltf_Metadata;
    scene: Json_Maybe(u32);
    scenes: [] Gltf_Scene; @json(default,skip_serializing_if=empty)
    nodes: [] Gltf_Node; @json(default,skip_serializing_if=empty)
    meshes: [] Gltf_Mesh; @json(default,skip_serializing_if=empty)
    accessors: [] Gltf_Accessor; @json(default,skip_serializing_if=empty)
    buffer_views: [] Gltf_Buffer_View; @json(default,skip_serializing_if=empty)
    buffers: [] Gltf_Buffer; @json(default,skip_serializing_if=empty)
    materials: [] Gltf_Material; @json(default,skip_serializing_if=empty)
    textures: [] Gltf_Texture; @json(default,skip_serializing_if=empty)
    images: [] Gltf_Image; @json(default,skip_serializing_if=empty)
    samplers: [] Gltf_Sampler; @json(default,skip_serializing_if=empty)
    skins: [] Gltf_Skin; @json(default,skip_serializing_if=empty)
    animations: [] Gltf_Animation; @json(default,skip_serializing_if=empty)
    cameras: [] Gltf_Camera; @json(default,skip_serializing_if=empty)
    extensions_used: [] string; @json(default,skip_serializing_if=empty)
    extensions_required: [] string; @json(default,skip_serializing_if=empty)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scene\":0,\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"mesh\":0}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0},\"indices\":1}]}],\"buffers\":[{\"byteLength\":42,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAAAAABAAIA\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":36,\"target\":34962},{\"buffer\":0,\"byteOffset\":36,\"byteLength\":6,\"target\":34963}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]},{\"bufferView\":1,\"componentType\":5123,\"count\":3,\"type\":\"SCALAR\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
document := asset.document;
assert(document.scene.state == .SET && document.scene.value == 0);
assert(document.nodes.count == 1 && document.meshes.count == 1);
↗
Gltf_Metadatastructsince 0.36.1Source

The asset object: the glTF version the file targets plus optional authoring details.

Gltf_Metadata :: struct @json(rename_all=camelCase) {
    version: string;
    min_version: string; @json(default,skip_serializing_if=empty)
    generator: string; @json(default,skip_serializing_if=empty)
    copyright: string; @json(default,skip_serializing_if=empty)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\",\"generator\":\"jacket\"}}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(asset.document.asset.version == "2.0");
assert(asset.document.asset.generator == "jacket");
↗
Gltf_Scenestructsince 0.36.1Source

A set of root nodes, by index into nodes.

Gltf_Scene :: struct @json(rename_all=camelCase) {
    nodes: [] u32; @json(default,skip_serializing_if=empty)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scenes\":[{\"name\":\"main\",\"nodes\":[0]}],\"nodes\":[{}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
scene := asset.document.scenes[0];
assert(scene.name == "main" && scene.nodes.count == 1 && scene.nodes[0] == 0);
↗
Gltf_Nodestructsince 0.36.1Source

A node in the scene hierarchy: it may place a mesh, skin or camera and has either a matrix or translation, rotation and scale. children and the references are indices.

Gltf_Node :: struct @json(rename_all=camelCase) {
    children: [] u32; @json(default,skip_serializing_if=empty)
    mesh: Json_Maybe(u32);
    skin: Json_Maybe(u32);
    camera: Json_Maybe(u32);
    matrix: [] float32; @json(default,skip_serializing_if=empty)
    rotation: [] float32; @json(default,skip_serializing_if=empty)
    scale: [] float32; @json(default,skip_serializing_if=empty)
    translation: [] float32; @json(default,skip_serializing_if=empty)
    weights: [] float32; @json(default,skip_serializing_if=empty)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{\"name\":\"parent\",\"translation\":[1,2,3],\"children\":[1]},{}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
parent := asset.document.nodes[0];
assert(parent.translation[1] == 2 && parent.children[0] == 1);
assert(parent.mesh.state == .MISSING);
↗
Gltf_Meshstructsince 0.36.1Source

A list of primitives drawn together, with optional default morph target weights.

Gltf_Mesh :: struct @json(rename_all=camelCase) {
    primitives: [] Gltf_Primitive;
    weights: [] float32; @json(default,skip_serializing_if=empty)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"accessors\":[{\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0}}]}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
assert(asset.document.meshes[0].primitives.count == 1);
↗
Gltf_Primitivestructsince 0.36.1Source

One draw call of a mesh: vertex attributes by name (such as POSITION) to accessor index, optional indices and material, the assembly mode, and morph targets.

Gltf_Primitive :: struct @json(rename_all=camelCase) {
    attributes: Table(string, u32);
    indices: Json_Maybe(u32);
    material: Json_Maybe(u32);
    mode: Gltf_Mode = .TRIANGLES; @json(default,as_number)
    targets: [] Table(string, u32); @json(default,skip_serializing_if=empty)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
#import "Hash_Table";
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scene\":0,\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"mesh\":0}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0},\"indices\":1}]}],\"buffers\":[{\"byteLength\":42,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAAAAABAAIA\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":36,\"target\":34962},{\"buffer\":0,\"byteOffset\":36,\"byteLength\":6,\"target\":34963}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]},{\"bufferView\":1,\"componentType\":5123,\"count\":3,\"type\":\"SCALAR\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
primitive := asset.document.meshes[0].primitives[0];
found, position := table_find(*primitive.attributes, "POSITION");
assert(found && position == 0);
assert(primitive.indices.state == .SET && primitive.indices.value == 1);
↗
Gltf_Bufferstructsince 0.36.1Source

A block of binary data: byte_length bytes, from uri or from the GLB binary chunk when uri is empty.

Gltf_Buffer :: struct @json(rename_all=camelCase) {
    uri: string; @json(default,skip_serializing_if=empty)
    byte_length: u32;
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"buffers\":[{\"byteLength\":4,\"uri\":\"data:application/octet-stream;base64,AAAAAA==\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":4,\"target\":34962}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
buffer := asset.document.buffers[0];
assert(buffer.byte_length == 4 && asset.buffers[0].count == 4);
↗
Gltf_Buffer_Viewstructsince 0.36.1Source

A byte range of a Gltf_Buffer, optionally strided and tagged with its GPU target.

Gltf_Buffer_View :: struct @json(rename_all=camelCase) {
    buffer: u32;
    byte_offset: u32 = 0; @json(default,skip_serializing_if=zero)
    byte_length: u32;
    byte_stride: Json_Maybe(u32);
    target: Json_Maybe(Gltf_Target); @json(as_number)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scene\":0,\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"mesh\":0}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0},\"indices\":1}]}],\"buffers\":[{\"byteLength\":42,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAAAAABAAIA\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":36,\"target\":34962},{\"buffer\":0,\"byteOffset\":36,\"byteLength\":6,\"target\":34963}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]},{\"bufferView\":1,\"componentType\":5123,\"count\":3,\"type\":\"SCALAR\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
indices := asset.document.buffer_views[1];
assert(indices.byte_offset == 36 && indices.byte_length == 6);
↗
Gltf_Accessorstructsince 0.36.1Source

A typed view onto a buffer view: count elements of type made of component_type, with optional min and max bounds and a sparse override. Read one with gltf_accessor.

Gltf_Accessor :: struct @json(rename_all=camelCase) {
    buffer_view: Json_Maybe(u32);
    byte_offset: u32 = 0; @json(default,skip_serializing_if=zero)
    component_type: Gltf_Component; @json(as_number)
    normalized: bool = false; @json(default)
    count: u32;
    type: Gltf_Accessor_Type;
    min: [] float64; @json(default,skip_serializing_if=empty)
    max: [] float64; @json(default,skip_serializing_if=empty)
    sparse: *Gltf_Sparse; @json(default,skip_serializing_if=null)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"scene\":0,\"scenes\":[{\"nodes\":[0]}],\"nodes\":[{\"mesh\":0}],\"meshes\":[{\"primitives\":[{\"attributes\":{\"POSITION\":0},\"indices\":1}]}],\"buffers\":[{\"byteLength\":42,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAAAAAAAAAAACAPwAAAAAAAAAAAAAAAAAAgD8AAAAAAAABAAIA\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":36,\"target\":34962},{\"buffer\":0,\"byteOffset\":36,\"byteLength\":6,\"target\":34963}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":3,\"type\":\"VEC3\",\"min\":[0,0,0],\"max\":[1,1,0]},{\"bufferView\":1,\"componentType\":5123,\"count\":3,\"type\":\"SCALAR\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
accessor := asset.document.accessors[0];
assert(accessor.component_type == .FLOAT && accessor.type == .VEC3 && accessor.count == 3);
↗
Gltf_Sparsestructsince 0.36.1Source

An accessor's sparse storage: count replaced elements, their indices and new values.

Gltf_Sparse :: struct @json(rename_all=camelCase) {
    count: u32;
    indices: Gltf_Sparse_Indices;
    values: Gltf_Sparse_Values;
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"buffers\":[{\"byteLength\":8,\"uri\":\"data:application/octet-stream;base64,AQAAAACAAEA=\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":1},{\"buffer\":0,\"byteOffset\":4,\"byteLength\":4}],\"accessors\":[{\"componentType\":5126,\"count\":3,\"type\":\"SCALAR\",\"sparse\":{\"count\":1,\"indices\":{\"bufferView\":0,\"componentType\":5121},\"values\":{\"bufferView\":1}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
sparse := asset.document.accessors[0].sparse;
assert(sparse != null && sparse.count == 1);
↗
Gltf_Sparse_Indicesstructsince 0.36.1Source

The positions replaced by a Gltf_Sparse accessor, read from a buffer view.

Gltf_Sparse_Indices :: struct @json(rename_all=camelCase) {
    buffer_view: u32;
    byte_offset: u32 = 0; @json(default,skip_serializing_if=zero)
    component_type: Gltf_Component; @json(as_number)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"buffers\":[{\"byteLength\":8,\"uri\":\"data:application/octet-stream;base64,AQAAAACAAEA=\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":1},{\"buffer\":0,\"byteOffset\":4,\"byteLength\":4}],\"accessors\":[{\"componentType\":5126,\"count\":3,\"type\":\"SCALAR\",\"sparse\":{\"count\":1,\"indices\":{\"bufferView\":0,\"componentType\":5121},\"values\":{\"bufferView\":1}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
indices := asset.document.accessors[0].sparse.indices;
assert(indices.buffer_view == 0 && indices.component_type == .UNSIGNED_BYTE);
↗
Gltf_Sparse_Valuesstructsince 0.36.1Source

The replacement elements of a Gltf_Sparse accessor, read from a buffer view.

Gltf_Sparse_Values :: struct @json(rename_all=camelCase) {
    buffer_view: u32;
    byte_offset: u32 = 0; @json(default,skip_serializing_if=zero)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"buffers\":[{\"byteLength\":8,\"uri\":\"data:application/octet-stream;base64,AQAAAACAAEA=\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":1},{\"buffer\":0,\"byteOffset\":4,\"byteLength\":4}],\"accessors\":[{\"componentType\":5126,\"count\":3,\"type\":\"SCALAR\",\"sparse\":{\"count\":1,\"indices\":{\"bufferView\":0,\"componentType\":5121},\"values\":{\"bufferView\":1}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
values := asset.document.accessors[0].sparse.values;
assert(values.buffer_view == 1);
↗
Gltf_Texturestructsince 0.36.1Source

A sampler and an image source, by index.

Gltf_Texture :: struct @json(rename_all=camelCase) {
    sampler: Json_Maybe(u32);
    source: Json_Maybe(u32);
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"images\":[{\"uri\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\"}],\"samplers\":[{\"magFilter\":9729,\"wrapS\":33071}],\"textures\":[{\"sampler\":0,\"source\":0}],\"materials\":[{\"pbrMetallicRoughness\":{\"baseColorTexture\":{\"index\":0},\"metallicFactor\":0.5},\"alphaMode\":\"BLEND\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
texture := asset.document.textures[0];
assert(texture.sampler.state == .SET && texture.source.value == 0);
↗
Gltf_Imagestructsince 0.36.1Source

Image data from a uri or from a buffer view, in which case mime_type must be image/png or image/jpeg. URIs are kept as written.

Gltf_Image :: struct @json(rename_all=camelCase) {
    uri: string; @json(default,skip_serializing_if=empty)
    mime_type: string; @json(default,skip_serializing_if=empty)
    buffer_view: Json_Maybe(u32);
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"images\":[{\"uri\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\"}],\"samplers\":[{\"magFilter\":9729,\"wrapS\":33071}],\"textures\":[{\"sampler\":0,\"source\":0}],\"materials\":[{\"pbrMetallicRoughness\":{\"baseColorTexture\":{\"index\":0},\"metallicFactor\":0.5},\"alphaMode\":\"BLEND\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
image := asset.document.images[0];
assert(image.uri == "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="); // URIs are kept as written
↗
Gltf_Samplerstructsince 0.36.1Source

How a texture is filtered and wrapped.

Gltf_Sampler :: struct @json(rename_all=camelCase) {
    mag_filter: Json_Maybe(Gltf_Filter); @json(as_number)
    min_filter: Json_Maybe(Gltf_Filter); @json(as_number)
    wrap_s: Gltf_Wrap = .REPEAT; @json(default,as_number)
    wrap_t: Gltf_Wrap = .REPEAT; @json(default,as_number)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"images\":[{\"uri\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\"}],\"samplers\":[{\"magFilter\":9729,\"wrapS\":33071}],\"textures\":[{\"sampler\":0,\"source\":0}],\"materials\":[{\"pbrMetallicRoughness\":{\"baseColorTexture\":{\"index\":0},\"metallicFactor\":0.5},\"alphaMode\":\"BLEND\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
sampler := asset.document.samplers[0];
assert(sampler.wrap_s == .CLAMP_TO_EDGE);
↗
Gltf_Texture_Infostructsince 0.36.1Source

A texture reference from a material: the texture index, the UV set tex_coord, and the scale (normal) or strength (occlusion) that applies.

Gltf_Texture_Info :: struct @json(rename_all=camelCase) {
    index: u32;
    tex_coord: u32 = 0; @json(default)
    scale: float32 = 1.0; @json(default)
    strength: float32 = 1.0; @json(default)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"images\":[{\"uri\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\"}],\"samplers\":[{\"magFilter\":9729,\"wrapS\":33071}],\"textures\":[{\"sampler\":0,\"source\":0}],\"materials\":[{\"pbrMetallicRoughness\":{\"baseColorTexture\":{\"index\":0},\"metallicFactor\":0.5},\"alphaMode\":\"BLEND\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
info := asset.document.materials[0].pbr_metallic_roughness.base_color_texture;
assert(info.index == 0 && info.tex_coord == 0);
↗
Gltf_Pbrstructsince 0.36.1Source

The metallic-roughness parameters of a Gltf_Material: base color, metalness and roughness, with their textures.

Gltf_Pbr :: struct @json(rename_all=camelCase) {
    base_color_factor: [4] float32 = .[1, 1, 1, 1]; @json(default)
    base_color_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    metallic_factor: float32 = 1.0; @json(default)
    roughness_factor: float32 = 1.0; @json(default)
    metallic_roughness_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"images\":[{\"uri\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\"}],\"samplers\":[{\"magFilter\":9729,\"wrapS\":33071}],\"textures\":[{\"sampler\":0,\"source\":0}],\"materials\":[{\"pbrMetallicRoughness\":{\"baseColorTexture\":{\"index\":0},\"metallicFactor\":0.5},\"alphaMode\":\"BLEND\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
pbr := asset.document.materials[0].pbr_metallic_roughness;
assert(pbr.metallic_factor == 0.5 && pbr.roughness_factor == 1.0);
↗
Gltf_Materialstructsince 0.36.1Source

How a surface looks: PBR parameters, normal, occlusion and emissive inputs, and alpha handling.

Gltf_Material :: struct @json(rename_all=camelCase) {
    pbr_metallic_roughness: *Gltf_Pbr; @json(default,skip_serializing_if=null)
    normal_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    occlusion_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    emissive_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    emissive_factor: [3] float32 = .[0, 0, 0]; @json(default)
    alpha_mode: Gltf_Alpha_Mode = .OPAQUE; @json(default)
    alpha_cutoff: float32 = 0.5; @json(default)
    double_sided: bool = false; @json(default)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"images\":[{\"uri\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\"}],\"samplers\":[{\"magFilter\":9729,\"wrapS\":33071}],\"textures\":[{\"sampler\":0,\"source\":0}],\"materials\":[{\"pbrMetallicRoughness\":{\"baseColorTexture\":{\"index\":0},\"metallicFactor\":0.5},\"alphaMode\":\"BLEND\"}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
material := asset.document.materials[0];
assert(material.alpha_mode == .BLEND && !material.double_sided);
↗
Gltf_Skinstructsince 0.36.1Source

The joints that deform a mesh: the joint node indices, the optional skeleton root and inverse bind matrices accessor.

Gltf_Skin :: struct @json(rename_all=camelCase) {
    inverse_bind_matrices: Json_Maybe(u32);
    skeleton: Json_Maybe(u32);
    joints: [] u32;
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{},{}],\"skins\":[{\"joints\":[1]}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
skin := asset.document.skins[0];
assert(skin.joints.count == 1 && skin.joints[0] == 1);
↗
Gltf_Animationstructsince 0.36.1Source

Keyframed motion: channels that connect samplers to node properties.

Gltf_Animation :: struct @json(rename_all=camelCase) {
    channels: [] Gltf_Channel;
    samplers: [] Gltf_Animation_Sampler;
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{}],\"buffers\":[{\"byteLength\":32,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAgD8AAAAAAAAAAAAAAAAAAIA/AAAAQAAAQEA=\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":32}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":2,\"type\":\"SCALAR\",\"min\":[0],\"max\":[1]},{\"bufferView\":0,\"byteOffset\":8,\"componentType\":5126,\"count\":2,\"type\":\"VEC3\"}],\"animations\":[{\"samplers\":[{\"input\":0,\"output\":1}],\"channels\":[{\"sampler\":0,\"target\":{\"node\":0,\"path\":\"translation\"}}]}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
animation := asset.document.animations[0];
assert(animation.channels.count == 1 && animation.samplers.count == 1);
↗
Gltf_Channelstructsince 0.36.1Source

Connects the animation sampler at index sampler to the property in target.

Gltf_Channel :: struct @json(rename_all=camelCase) {
    sampler: u32;
    target: Gltf_Animation_Target;
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{}],\"buffers\":[{\"byteLength\":32,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAgD8AAAAAAAAAAAAAAAAAAIA/AAAAQAAAQEA=\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":32}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":2,\"type\":\"SCALAR\",\"min\":[0],\"max\":[1]},{\"bufferView\":0,\"byteOffset\":8,\"componentType\":5126,\"count\":2,\"type\":\"VEC3\"}],\"animations\":[{\"samplers\":[{\"input\":0,\"output\":1}],\"channels\":[{\"sampler\":0,\"target\":{\"node\":0,\"path\":\"translation\"}}]}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
channel := asset.document.animations[0].channels[0];
assert(channel.sampler == 0 && channel.target.node.value == 0);
↗
Gltf_Animation_Targetstructsince 0.36.1Source

The node and property (path) an animation channel writes.

Gltf_Animation_Target :: struct @json(rename_all=camelCase) {
    node: Json_Maybe(u32);
    path: Gltf_Path; @json(rename_all=lowercase)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{}],\"buffers\":[{\"byteLength\":32,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAgD8AAAAAAAAAAAAAAAAAAIA/AAAAQAAAQEA=\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":32}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":2,\"type\":\"SCALAR\",\"min\":[0],\"max\":[1]},{\"bufferView\":0,\"byteOffset\":8,\"componentType\":5126,\"count\":2,\"type\":\"VEC3\"}],\"animations\":[{\"samplers\":[{\"input\":0,\"output\":1}],\"channels\":[{\"sampler\":0,\"target\":{\"node\":0,\"path\":\"translation\"}}]}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
target := asset.document.animations[0].channels[0].target;
assert(target.path == .TRANSLATION);
↗

Keyframes: the accessor of times (input), the accessor of values (output) and the interpolation between them.

Gltf_Animation_Sampler :: struct @json(rename_all=camelCase) {
    input: u32;
    output: u32;
    interpolation: Gltf_Interpolation = .LINEAR; @json(default)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"nodes\":[{}],\"buffers\":[{\"byteLength\":32,\"uri\":\"data:application/octet-stream;base64,AAAAAAAAgD8AAAAAAAAAAAAAAAAAAIA/AAAAQAAAQEA=\"}],\"bufferViews\":[{\"buffer\":0,\"byteLength\":32}],\"accessors\":[{\"bufferView\":0,\"componentType\":5126,\"count\":2,\"type\":\"SCALAR\",\"min\":[0],\"max\":[1]},{\"bufferView\":0,\"byteOffset\":8,\"componentType\":5126,\"count\":2,\"type\":\"VEC3\"}],\"animations\":[{\"samplers\":[{\"input\":0,\"output\":1}],\"channels\":[{\"sampler\":0,\"target\":{\"node\":0,\"path\":\"translation\"}}]}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
sampler := asset.document.animations[0].samplers[0];
assert(sampler.input == 0 && sampler.output == 1);
↗
Gltf_Camerastructsince 0.36.1Source

A camera, with the projection for its type filled in.

Gltf_Camera :: struct @json(rename_all=camelCase) {
    type: Gltf_Camera_Type; @json(rename_all=lowercase)
    perspective: *Gltf_Perspective; @json(default,skip_serializing_if=null)
    orthographic: *Gltf_Orthographic; @json(default,skip_serializing_if=null)
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"cameras\":[{\"type\":\"perspective\",\"perspective\":{\"yfov\":0.8,\"znear\":0.1}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
camera := asset.document.cameras[0];
assert(camera.type == .PERSPECTIVE && camera.perspective != null);
↗
Gltf_Perspectivestructsince 0.36.1Source

A perspective projection; a missing zfar means an infinite far plane.

Gltf_Perspective :: struct @json(rename_all=camelCase) {
    aspect_ratio: Json_Maybe(float32);
    yfov: float32;
    zfar: Json_Maybe(float32);
    znear: float32;
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"cameras\":[{\"type\":\"perspective\",\"perspective\":{\"yfov\":0.8,\"znear\":0.1}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
perspective := asset.document.cameras[0].perspective;
assert(perspective.yfov == 0.8 && perspective.zfar.state == .MISSING); // an infinite far plane
↗
Gltf_Orthographicstructsince 0.36.1Source

An orthographic projection with half-widths xmag and ymag.

Gltf_Orthographic :: struct @json(rename_all=camelCase) {
    xmag: float32;
    ymag: float32;
    zfar: float32;
    znear: float32;
    name: string; @json(default,skip_serializing_if=empty)
    extensions: Json_Value; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"cameras\":[{\"type\":\"orthographic\",\"orthographic\":{\"xmag\":2,\"ymag\":1,\"zfar\":10,\"znear\":1}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
box := asset.document.cameras[0].orthographic;
assert(box.xmag == 2 && box.zfar == 10);
↗

KHR_materials_emissive_strength: scales emissive_factor beyond 1. Read it from material.extensions.

Gltf_Emissive_Strength :: struct @json(rename_all=camelCase) {
    emissive_strength: float32 = 1.0; @json(default)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_emissive_strength\"],\"materials\":[{\"extensions\":{\"KHR_materials_emissive_strength\":{\"emissiveStrength\":4.5}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
strength, found, _ := gltf_extension(*asset.document.materials[0].extensions, "KHR_materials_emissive_strength", Gltf_Emissive_Strength);
assert(found && strength.emissive_strength == 4.5);
↗
Gltf_Iorstructsince 0.36.1Source

KHR_materials_ior: the index of refraction of a dielectric surface. Read it from material.extensions.

Gltf_Ior :: struct @json(rename_all=camelCase) {
    ior: float32 = 1.5; @json(default)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_ior\"],\"materials\":[{\"extensions\":{\"KHR_materials_ior\":{\"ior\":1.33}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
ior, found, _ := gltf_extension(*asset.document.materials[0].extensions, "KHR_materials_ior", Gltf_Ior);
assert(found && ior.ior == 1.33);
↗
Gltf_Transmissionstructsince 0.36.1Source

KHR_materials_transmission: how much light passes through a surface, with an optional texture. The texture is allocated: release the value with free_json.

Gltf_Transmission :: struct @json(rename_all=camelCase) {
    transmission_factor: float32 = 0.0; @json(default)
    transmission_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
#import "Extensions/Json";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_transmission\"],\"materials\":[{\"extensions\":{\"KHR_materials_transmission\":{\"transmissionFactor\":0.25}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
transmission, found, _ := gltf_extension(*asset.document.materials[0].extensions, "KHR_materials_transmission", Gltf_Transmission);
assert(found && transmission.transmission_factor == 0.25 && transmission.transmission_texture == null);
free_json(*transmission);
↗
Gltf_Clearcoatstructsince 0.36.1Source

KHR_materials_clearcoat: a glossy layer over the base material, with its own roughness and normal map. The textures are allocated: release the value with free_json.

Gltf_Clearcoat :: struct @json(rename_all=camelCase) {
    clearcoat_factor: float32 = 0.0; @json(default)
    clearcoat_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    clearcoat_roughness_factor: float32 = 0.0; @json(default)
    clearcoat_roughness_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    clearcoat_normal_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
#import "Extensions/Json";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_clearcoat\"],\"materials\":[{\"extensions\":{\"KHR_materials_clearcoat\":{\"clearcoatFactor\":0.8,\"clearcoatRoughnessFactor\":0.1}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
coat, found, _ := gltf_extension(*asset.document.materials[0].extensions, "KHR_materials_clearcoat", Gltf_Clearcoat);
assert(found && coat.clearcoat_factor == 0.8 && coat.clearcoat_roughness_factor == 0.1);
free_json(*coat);
↗
Gltf_Sheenstructsince 0.36.1Source

KHR_materials_sheen: a fabric-like layer of fuzz on the surface. Read it from material.extensions. The textures are allocated: release the value with free_json.

Gltf_Sheen :: struct @json(rename_all=camelCase) {
    sheen_color_factor: [3] float32 = .[0, 0, 0]; @json(default)
    sheen_color_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    sheen_roughness_factor: float32 = 0.0; @json(default)
    sheen_roughness_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
#import "Extensions/Json";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_sheen\"],\"materials\":[{\"extensions\":{\"KHR_materials_sheen\":{\"sheenColorFactor\":[0.9,0.5,0.1],\"sheenRoughnessFactor\":0.3}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
sheen, found, _ := gltf_extension(*asset.document.materials[0].extensions, "KHR_materials_sheen", Gltf_Sheen);
assert(found && sheen.sheen_color_factor[1] == 0.5 && sheen.sheen_roughness_factor == 0.3);
free_json(*sheen);
↗
Gltf_Specularstructsince 0.36.1Source

KHR_materials_specular: the strength and tint of the specular reflection of a dielectric. Read it from material.extensions. The textures are allocated: release the value with free_json.

Gltf_Specular :: struct @json(rename_all=camelCase) {
    specular_factor: float32 = 1.0; @json(default)
    specular_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    specular_color_factor: [3] float32 = .[1, 1, 1]; @json(default)
    specular_color_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
#import "Extensions/Json";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_specular\"],\"materials\":[{\"extensions\":{\"KHR_materials_specular\":{\"specularColorFactor\":[1,0.8,0.6]}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
specular, found, _ := gltf_extension(*asset.document.materials[0].extensions, "KHR_materials_specular", Gltf_Specular);
assert(found && specular.specular_factor == 1 && specular.specular_color_factor[2] == 0.6);
free_json(*specular);
↗
Gltf_Volumestructsince 0.36.1Source

KHR_materials_volume: the thickness of a transmissive surface and how light fades inside it. Read it from material.extensions. attenuation_distance is unset when light does not fade (the glTF default is infinity, which JSON cannot write). The texture is allocated: release the value with free_json.

Gltf_Volume :: struct @json(rename_all=camelCase) {
    thickness_factor: float32 = 0.0; @json(default)
    thickness_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    attenuation_distance: Json_Maybe(float32);
    attenuation_color: [3] float32 = .[1, 1, 1]; @json(default)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
#import "Extensions/Json";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_volume\"],\"materials\":[{\"extensions\":{\"KHR_materials_volume\":{\"thicknessFactor\":0.5,\"attenuationDistance\":2,\"attenuationColor\":[0.2,0.9,0.4]}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
volume, found, _ := gltf_extension(*asset.document.materials[0].extensions, "KHR_materials_volume", Gltf_Volume);
assert(found && volume.thickness_factor == 0.5 && volume.attenuation_distance.state == .SET && volume.attenuation_distance.value == 2);
free_json(*volume);
↗
Gltf_Iridescencestructsince 0.36.1Source

KHR_materials_iridescence: a thin film that shifts colour with the viewing angle. Read it from material.extensions. The thickness is in nanometres. The textures are allocated: release the value with free_json.

Gltf_Iridescence :: struct @json(rename_all=camelCase) {
    iridescence_factor: float32 = 0.0; @json(default)
    iridescence_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    iridescence_ior: float32 = 1.3; @json(default)
    iridescence_thickness_minimum: float32 = 100.0; @json(default)
    iridescence_thickness_maximum: float32 = 400.0; @json(default)
    iridescence_thickness_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
#import "Extensions/Json";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_iridescence\"],\"materials\":[{\"extensions\":{\"KHR_materials_iridescence\":{\"iridescenceFactor\":1,\"iridescenceThicknessMaximum\":800}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
film, found, _ := gltf_extension(*asset.document.materials[0].extensions, "KHR_materials_iridescence", Gltf_Iridescence);
assert(found && film.iridescence_factor == 1 && film.iridescence_ior == 1.3 && film.iridescence_thickness_minimum == 100 && film.iridescence_thickness_maximum == 800);
free_json(*film);
↗
Gltf_Anisotropystructsince 0.36.1Source

KHR_materials_anisotropy: highlights stretched along a direction, as on brushed metal. Read it from material.extensions. anisotropy_rotation is in radians. The texture is allocated: release the value with free_json.

Gltf_Anisotropy :: struct @json(rename_all=camelCase) {
    anisotropy_strength: float32 = 0.0; @json(default)
    anisotropy_rotation: float32 = 0.0; @json(default)
    anisotropy_texture: *Gltf_Texture_Info; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
#import "Extensions/Json";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_anisotropy\"],\"materials\":[{\"extensions\":{\"KHR_materials_anisotropy\":{\"anisotropyStrength\":0.6,\"anisotropyRotation\":1.5}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
stretch, found, _ := gltf_extension(*asset.document.materials[0].extensions, "KHR_materials_anisotropy", Gltf_Anisotropy);
assert(found && stretch.anisotropy_strength == 0.6 && stretch.anisotropy_rotation == 1.5);
free_json(*stretch);
↗
Gltf_Unlitstructsince 0.36.1Source

KHR_materials_unlit: the material ignores lighting and shows its base colour. The extension has no properties, so finding it is the information.

Gltf_Unlit :: struct @json(rename_all=camelCase) {
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_materials_unlit\"],\"materials\":[{\"extensions\":{\"KHR_materials_unlit\":{}}},{}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
_, flat := gltf_extension(*asset.document.materials[0].extensions, "KHR_materials_unlit", Gltf_Unlit);
_, lit := gltf_extension(*asset.document.materials[1].extensions, "KHR_materials_unlit", Gltf_Unlit);
assert(flat && !lit);
↗

KHR_texture_transform: moves, rotates and scales the UVs of one texture reference. Read it from the reference's extensions; a set tex_coord replaces the reference's own UV set.

Gltf_Texture_Transform :: struct @json(rename_all=camelCase) {
    offset: [2] float32 = .[0, 0]; @json(default)
    rotation: float32 = 0.0; @json(default)
    scale: [2] float32 = .[1, 1]; @json(default)
    tex_coord: Json_Maybe(u32);
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_texture_transform\"],\"images\":[{\"uri\":\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\"}],\"textures\":[{\"source\":0}],\"materials\":[{\"emissiveTexture\":{\"index\":0,\"extensions\":{\"KHR_texture_transform\":{\"offset\":[0.5,0.25],\"scale\":[2,2]}}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
reference := asset.document.materials[0].emissive_texture;
transform, found, _ := gltf_extension(*reference.extensions, "KHR_texture_transform", Gltf_Texture_Transform);
assert(found && transform.offset[0] == 0.5 && transform.scale[1] == 2 && transform.rotation == 0);
↗
Gltf_Light_Typeenumsince 0.36.1Source

The kind of a KHR_lights_punctual light.

Gltf_Light_Type :: enum u8 {
    DIRECTIONAL;
    POINT;
    SPOT;
}
#import "Extensions/Json";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_lights_punctual\"],\"extensions\":{\"KHR_lights_punctual\":{\"lights\":[{\"type\":\"point\"}]}}}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
lights, found, _ := gltf_extension(*asset.document.extensions, "KHR_lights_punctual", Gltf_Lights);
assert(found && lights.lights[0].type == .POINT);
free_json(*lights);
↗
Gltf_Light_Spotstructsince 0.36.1Source

The cone of a spot light, in radians.

Gltf_Light_Spot :: struct @json(rename_all=camelCase) {
    inner_cone_angle: float32 = 0.0; @json(default)
    outer_cone_angle: float32 = cast(float32) 0.7853981633974483; @json(default)
}
spot := Gltf_Light_Spot.{};
assert(spot.inner_cone_angle == 0 && spot.outer_cone_angle > 0.78 && spot.outer_cone_angle < 0.79);
↗
Gltf_Lightstructsince 0.36.1Source

One light of KHR_lights_punctual. A range of zero means unlimited, as the glTF default of no range; spot is set only for spot lights.

Gltf_Light :: struct @json(rename_all=camelCase) {
    name: string; @json(default,skip_serializing_if=empty)
    color: [3] float32 = .[1, 1, 1]; @json(default)
    intensity: float32 = 1.0; @json(default)
    type: Gltf_Light_Type; @json(rename_all=lowercase)
    range: float32 = 0.0; @json(default)
    spot: *Gltf_Light_Spot; @json(default,skip_serializing_if=null)
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
#import "Extensions/Json";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_lights_punctual\"],\"extensions\":{\"KHR_lights_punctual\":{\"lights\":[{\"type\":\"spot\",\"intensity\":3,\"spot\":{\"outerConeAngle\":0.5}}]}}}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
lights, found, _ := gltf_extension(*asset.document.extensions, "KHR_lights_punctual", Gltf_Lights);
assert(found);
light := lights.lights[0];
assert(light.type == .SPOT && light.intensity == 3 && light.color[0] == 1 && light.spot.outer_cone_angle == 0.5);
free_json(*lights);
↗
Gltf_Lightsstructsince 0.36.1Source

KHR_lights_punctual on the document: the list of lights that nodes refer to by index. Release it with free_json.

Gltf_Lights :: struct @json(rename_all=camelCase) {
    lights: [] Gltf_Light; @json(default,skip_serializing_if=empty)
}
#import "Extensions/Json";

asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_lights_punctual\"],\"extensions\":{\"KHR_lights_punctual\":{\"lights\":[{\"type\":\"directional\"},{\"type\":\"point\"}]}}}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
lights, found, _ := gltf_extension(*asset.document.extensions, "KHR_lights_punctual", Gltf_Lights);
assert(found && lights.lights.count == 2);
free_json(*lights);
↗
Gltf_Node_Lightstructsince 0.36.1Source

KHR_lights_punctual on a node: the index of the light it carries, into Gltf_Lights.

Gltf_Node_Light :: struct @json(rename_all=camelCase) {
    light: u32;
    extras: Json_Value; @json(default,skip_serializing_if=null)
}
asset, error := gltf_load("{\"asset\":{\"version\":\"2.0\"},\"extensionsUsed\":[\"KHR_lights_punctual\"],\"nodes\":[{\"extensions\":{\"KHR_lights_punctual\":{\"light\":1}}}]}");
assert(error.kind == .NONE);
defer gltf_free(*asset);
carried, found, _ := gltf_extension(*asset.document.nodes[0].extensions, "KHR_lights_punctual", Gltf_Node_Light);
assert(found && carried.light == 1);
↗