@thunderclap-engine/engine 0.0.0-stage → 1.1.0

package/dist/assets/gltf.d.ts

@@ -0,0 +1,706 @@
+/**
+ * glTF 2.0 parser: bytes in, an engine-free `GltfDocument` out. Pure data, no DOM, no GPU, no
+ * fetch (the game fetches the file and any external resource; VISION rule: the engine never
+ * makes a network call). `gltf-load.ts` turns the document into meshes, textures and transforms.
+ *
+ * Handles the GLB container, `.gltf` JSON (as text bytes or a parsed object), `data:` URIs in
+ * buffers and images, and every accessor component type (float, normalised and unnormalised
+ * integers, interleaved strides). Static geometry only: `triangles` primitives, metallic-roughness
+ * materials, node hierarchies, plus skins (joints, inverse bind matrices, `JOINTS_0`/`WEIGHTS_0`)
+ * and animations (every sampler interpolation, cubic-spline tangents kept) and morph targets
+ * (`POSITION` and `NORMAL` deltas per target, sparse or dense, plus the mesh's default
+ * `weights`). Sparse accessors outside morph targets, other primitive modes and required
+ * extensions throw a `GltfError`; `extensionsUsed` entries the parser does not read are listed
+ * in `warnings`. Materials carry every metallic-roughness slot (`TextureRef` per map, with
+ * `KHR_texture_transform` and `KHR_materials_emissive_strength` applied) and textures their
+ * sampler; primitives also read `TANGENT` and `TEXCOORD_1`. `gltf-skin.ts` turns skins into the
+ * animation module's `Skeleton` shape and skinned primitives into the skinned vertex layout.
+ *
+ * Matrices follow the engine's `Transform` convention: 3×4 row-major, `local = T · R · S`,
+ * `world = parent.world · local`.
+ */
+export declare class GltfError extends Error {
+    constructor(message: string);
+}
+export type GltfComponentType = 5120 | 5121 | 5122 | 5123 | 5125 | 5126;
+export type GltfAccessorType = 'SCALAR' | 'VEC2' | 'VEC3' | 'VEC4' | 'MAT2' | 'MAT3' | 'MAT4';
+export interface GltfJsonAccessor {
+    bufferView?: number;
+    byteOffset?: number;
+    componentType: GltfComponentType;
+    normalized?: boolean;
+    count: number;
+    type: GltfAccessorType;
+    min?: number[];
+    max?: number[];
+    /** Sparse storage: `count` overrides at `indices` over the dense data (or zeros). */
+    sparse?: GltfJsonSparse;
+}
+/** A sparse accessor's indices and values (glTF `accessor.sparse`). */
+export interface GltfJsonSparse {
+    count: number;
+    indices: {
+        bufferView: number;
+        byteOffset?: number;
+        componentType: 5121 | 5123 | 5125;
+    };
+    values: {
+        bufferView: number;
+        byteOffset?: number;
+    };
+}
+export interface GltfJsonBufferView {
+    buffer: number;
+    byteOffset?: number;
+    byteLength: number;
+    byteStride?: number;
+    extensions?: {
+        EXT_meshopt_compression?: GltfJsonMeshoptView;
+    };
+}
+/** `EXT_meshopt_compression` on a buffer view: where the compressed stream is and how to decode it. */
+export interface GltfJsonMeshoptView {
+    buffer: number;
+    byteOffset?: number;
+    byteLength: number;
+    byteStride: number;
+    count: number;
+    mode: 'ATTRIBUTES' | 'TRIANGLES' | 'INDICES';
+    filter?: 'NONE' | 'OCTAHEDRAL' | 'QUATERNION' | 'EXPONENTIAL';
+}
+/** One `KHR_lights_punctual` light definition (`extensions.KHR_lights_punctual.lights[i]`). */
+export interface GltfJsonLight {
+    name?: string;
+    type: 'directional' | 'point' | 'spot';
+    color?: number[];
+    intensity?: number;
+    range?: number;
+    spot?: {
+        innerConeAngle?: number;
+        outerConeAngle?: number;
+    };
+}
+/** One glTF `camera`. */
+export interface GltfJsonCamera {
+    name?: string;
+    type: 'perspective' | 'orthographic';
+    perspective?: {
+        aspectRatio?: number;
+        yfov: number;
+        zfar?: number;
+        znear: number;
+    };
+    orthographic?: {
+        xmag: number;
+        ymag: number;
+        zfar: number;
+        znear: number;
+    };
+}
+/** `KHR_materials_variants` on a primitive: which material each set of variants binds. */
+export interface GltfJsonVariantMapping {
+    material: number;
+    variants: number[];
+    name?: string;
+}
+export interface GltfJsonPrimitive {
+    attributes: Record<string, number>;
+    indices?: number;
+    material?: number;
+    mode?: number;
+    /** Morph targets: one attribute map per target (`POSITION`, `NORMAL`, `TANGENT`, …). */
+    targets?: Record<string, number>[];
+    extensions?: {
+        KHR_materials_variants?: {
+            mappings?: GltfJsonVariantMapping[];
+        };
+    };
+}
+export interface GltfJsonMesh {
+    name?: string;
+    primitives: GltfJsonPrimitive[];
+    /** Default morph weight per target. */
+    weights?: number[];
+}
+export interface GltfJsonNode {
+    name?: string;
+    children?: number[];
+    mesh?: number;
+    skin?: number;
+    matrix?: number[];
+    translation?: number[];
+    rotation?: number[];
+    scale?: number[];
+    /** Index into `GltfJson.cameras`. */
+    camera?: number;
+    extensions?: {
+        KHR_lights_punctual?: {
+            light: number;
+        };
+    };
+}
+/** `KHR_texture_transform` on a texture reference (`extensions.KHR_texture_transform`). */
+export interface GltfJsonTextureTransform {
+    offset?: number[];
+    rotation?: number;
+    scale?: number[];
+    texCoord?: number;
+}
+/** A glTF `textureInfo` (`normalTextureInfo` adds `scale`, `occlusionTextureInfo` `strength`). */
+export interface GltfJsonTextureInfo {
+    index: number;
+    texCoord?: number;
+    scale?: number;
+    strength?: number;
+    extensions?: {
+        KHR_texture_transform?: GltfJsonTextureTransform;
+    };
+}
+export interface GltfJsonMaterial {
+    name?: string;
+    pbrMetallicRoughness?: {
+        baseColorFactor?: number[];
+        baseColorTexture?: GltfJsonTextureInfo;
+        metallicFactor?: number;
+        roughnessFactor?: number;
+        metallicRoughnessTexture?: GltfJsonTextureInfo;
+    };
+    normalTexture?: GltfJsonTextureInfo;
+    occlusionTexture?: GltfJsonTextureInfo;
+    emissiveTexture?: GltfJsonTextureInfo;
+    emissiveFactor?: number[];
+    doubleSided?: boolean;
+    alphaMode?: 'OPAQUE' | 'MASK' | 'BLEND';
+    alphaCutoff?: number;
+    extensions?: {
+        KHR_materials_emissive_strength?: {
+            emissiveStrength?: number;
+        };
+        KHR_materials_clearcoat?: {
+            clearcoatFactor?: number;
+            clearcoatTexture?: GltfJsonTextureInfo;
+            clearcoatRoughnessFactor?: number;
+            clearcoatRoughnessTexture?: GltfJsonTextureInfo;
+            clearcoatNormalTexture?: GltfJsonTextureInfo;
+        };
+        KHR_materials_sheen?: {
+            sheenColorFactor?: number[];
+            sheenColorTexture?: GltfJsonTextureInfo;
+            sheenRoughnessFactor?: number;
+            sheenRoughnessTexture?: GltfJsonTextureInfo;
+        };
+        KHR_materials_transmission?: {
+            transmissionFactor?: number;
+            transmissionTexture?: GltfJsonTextureInfo;
+        };
+        KHR_materials_volume?: {
+            thicknessFactor?: number;
+            thicknessTexture?: GltfJsonTextureInfo;
+            attenuationDistance?: number;
+            attenuationColor?: number[];
+        };
+        KHR_materials_ior?: {
+            ior?: number;
+        };
+        KHR_materials_specular?: {
+            specularFactor?: number;
+            specularTexture?: GltfJsonTextureInfo;
+            specularColorFactor?: number[];
+            specularColorTexture?: GltfJsonTextureInfo;
+        };
+    };
+}
+export interface GltfJsonSkin {
+    name?: string;
+    /** Accessor of `MAT4` inverse bind matrices, one per joint (identity when absent). */
+    inverseBindMatrices?: number;
+    /** The skeleton root node. */
+    skeleton?: number;
+    joints: number[];
+}
+export type GltfJsonInterpolation = 'LINEAR' | 'STEP' | 'CUBICSPLINE';
+export interface GltfJsonAnimationSampler {
+    /** Accessor of keyframe times (`SCALAR` float, seconds, ascending). */
+    input: number;
+    /** Accessor of keyframe values (`VEC3`, `VEC4` or `SCALAR` weights; ×3 for `CUBICSPLINE`). */
+    output: number;
+    interpolation?: GltfJsonInterpolation;
+}
+export interface GltfJsonAnimationChannel {
+    sampler: number;
+    target: {
+        node?: number;
+        path: string;
+    };
+}
+export interface GltfJsonAnimation {
+    name?: string;
+    channels: GltfJsonAnimationChannel[];
+    samplers: GltfJsonAnimationSampler[];
+}
+/** The parts of a glTF 2.0 JSON document the parser reads. Other properties pass through. */
+export interface GltfJson {
+    asset?: {
+        version?: string;
+        generator?: string;
+    };
+    extensionsRequired?: string[];
+    extensionsUsed?: string[];
+    scene?: number;
+    scenes?: {
+        name?: string;
+        nodes?: number[];
+    }[];
+    nodes?: GltfJsonNode[];
+    meshes?: GltfJsonMesh[];
+    accessors?: GltfJsonAccessor[];
+    bufferViews?: GltfJsonBufferView[];
+    buffers?: {
+        uri?: string;
+        byteLength: number;
+        /** `fallback: true` marks a buffer only `EXT_meshopt_compression` views point at (may have no data). */
+        extensions?: {
+            EXT_meshopt_compression?: {
+                fallback?: boolean;
+            };
+        };
+    }[];
+    materials?: GltfJsonMaterial[];
+    textures?: {
+        name?: string;
+        source?: number;
+        sampler?: number;
+        extensions?: {
+            KHR_texture_basisu?: {
+                source: number;
+            };
+        };
+    }[];
+    images?: {
+        name?: string;
+        uri?: string;
+        mimeType?: string;
+        bufferView?: number;
+    }[];
+    samplers?: {
+        magFilter?: number;
+        minFilter?: number;
+        wrapS?: number;
+        wrapT?: number;
+    }[];
+    skins?: GltfJsonSkin[];
+    animations?: GltfJsonAnimation[];
+    cameras?: GltfJsonCamera[];
+    extensions?: {
+        KHR_lights_punctual?: {
+            lights?: GltfJsonLight[];
+        };
+        KHR_materials_variants?: {
+            variants?: {
+                name?: string;
+            }[];
+        };
+    };
+}
+export type Vec3 = [number, number, number];
+export type Vec4 = [number, number, number, number];
+/** An axis-aligned box and the sphere around it. */
+export interface GltfBounds {
+    min: Vec3;
+    max: Vec3;
+    center: Vec3;
+    radius: number;
+}
+/** One `triangles` primitive, de-interleaved: `vertexCount` vertices, `indices.length / 3` triangles. */
+export interface GltfPrimitive {
+    vertexCount: number;
+    /** xyz per vertex. */
+    position: Float32Array;
+    /** xyz per vertex; flat face normals when the file has none (vertices are then unwelded). */
+    normal: Float32Array;
+    /** uv per vertex (`TEXCOORD_0`); zeros when missing. */
+    uv0: Float32Array;
+    /** `TEXCOORD_1`, uv per vertex, or null when missing (the loader binds `uv0` only). */
+    uv1: Float32Array | null;
+    /**
+     * `TANGENT`, xyzw per vertex (xyz the unit tangent along +u, w ±1 the handedness: the
+     * bitangent is `w · cross(normal, tangent)`), or null. Follows the unwelding.
+     */
+    tangent: Float32Array | null;
+    /** rgba per vertex (`COLOR_0`, a vec3 gets alpha 1); ones when missing. */
+    color0: Float32Array;
+    /** Triangle list; generated `0..n-1` when the file has none. */
+    indices: Uint16Array | Uint32Array;
+    /** Index into `GltfDocument.materials`, or null for the default material. */
+    material: number | null;
+    /** From the position accessor's `min`/`max` (computed from the data when absent). */
+    bounds: GltfBounds;
+    /** Whether the file carried normals (`false`: generated flat). */
+    hadNormals: boolean;
+    /**
+     * `JOINTS_0`, 4 joint indices per vertex (into the node's skin `joints`), or null when the
+     * primitive is not skinned. `Uint8Array` when every index fits a byte (the skinned vertex
+     * layout's `uint8x4`), `Uint16Array` otherwise.
+     */
+    joints: Uint8Array | Uint16Array | null;
+    /** `WEIGHTS_0`, 4 floats per vertex (normalised integers already divided), or null. */
+    weights: Float32Array | null;
+    /**
+     * Morph targets, in file order (empty when the primitive has none). Each holds per-vertex
+     * deltas (`vertexCount × 3`) that `anim`'s `createMorphBlender` adds to the base at the
+     * target's weight; both follow the unwelding when flat normals are generated.
+     */
+    targets: GltfMorphTarget[];
+    /** Target attributes the parser read past (`TANGENT`, `TEXCOORD_0`, …), once each. */
+    ignoredTargetAttributes: string[];
+    /**
+     * `KHR_materials_variants` mappings: each binds `material` when one of `variants` (indices
+     * into `GltfDocument.variants`) is active; empty when the primitive has none. A variant no
+     * mapping names leaves the primitive on `material`.
+     */
+    variants: GltfVariantMapping[];
+}
+/** One `KHR_materials_variants` mapping of a primitive. */
+export interface GltfVariantMapping {
+    /** Index into `GltfDocument.materials`. */
+    material: number;
+    /** Indices into `GltfDocument.variants`. */
+    variants: number[];
+}
+/**
+ * One morph target: position and normal deltas, 3 floats per vertex, or null when the target
+ * does not displace that attribute. The shape `anim/morph.ts` (`MorphTarget`) consumes.
+ */
+export interface GltfMorphTarget {
+    position: Float32Array | null;
+    normal: Float32Array | null;
+}
+export interface GltfMesh {
+    name: string | null;
+    primitives: GltfPrimitive[];
+    /**
+     * Default morph weights, one per target (`mesh.weights`), or null when the file gives none
+     * (every target then starts at 0). The `weights` animation path writes the same layout.
+     */
+    weights: Float32Array | null;
+}
+export interface GltfNode {
+    name: string | null;
+    parent: number | null;
+    children: number[];
+    mesh: number | null;
+    /** Index into `GltfDocument.skins`, or null. */
+    skin: number | null;
+    /** Index into the file's `cameras` the node carries, or null (`GltfDocument.cameras` places it). */
+    camera: number | null;
+    /** Index into the file's `KHR_lights_punctual` lights, or null (`GltfDocument.lights`). */
+    light: number | null;
+    /** TRS, decomposed from `matrix` when the node gave one. */
+    translation: Vec3;
+    rotation: Vec4;
+    scale: Vec3;
+    /** `T · R · S`, 3×4 row-major (the engine's `Transform.localMatrix` convention). */
+    local: Float32Array;
+    /** `parent.world · local`, 3×4 row-major. */
+    world: Float32Array;
+}
+export type GltfAlphaMode = 'OPAQUE' | 'MASK' | 'BLEND';
+/**
+ * `KHR_texture_transform`: `uv' = offset + R(rotation) · (scale ⊙ uv)`, the spec's
+ * `T · R · S` with `R` rotating by `rotation` radians counter-clockwise in uv space
+ * (`u' = cos·su − sin·sv`, `v' = sin·su + cos·sv`). `transformUv` applies one.
+ */
+export interface GltfTextureTransform {
+    offset: [number, number];
+    rotation: number;
+    scale: [number, number];
+}
+/** A material's reference to one of `GltfDocument.textures`. */
+export interface TextureRef {
+    /** Index into `GltfDocument.textures`. */
+    index: number;
+    /** Which `TEXCOORD_n` the slot reads (0 or 1; the loader binds `TEXCOORD_0` only). */
+    texCoord: number;
+    /** The slot's `KHR_texture_transform`, or null for identity. */
+    transform: GltfTextureTransform | null;
+}
+/**
+ * A glTF material, every slot of the metallic-roughness model. Factors default as the spec
+ * says (base colour 1, metallic 1, roughness 1, normal scale 1, occlusion strength 1, emissive
+ * 0); `emissiveFactor` already includes `KHR_materials_emissive_strength`. Texture conventions
+ * are glTF's: base colour and emissive are sRGB, metallic-roughness has roughness in G and
+ * metallic in B, occlusion is in R, the normal map is +Y up.
+ */
+export interface GltfMaterial {
+    name: string | null;
+    /** Linear RGBA multiplier (default 1, 1, 1, 1). */
+    baseColorFactor: Vec4;
+    baseColor: TextureRef | null;
+    /** Default 1. */
+    metallicFactor: number;
+    /** Default 1. */
+    roughnessFactor: number;
+    metallicRoughness: TextureRef | null;
+    normal: TextureRef | null;
+    /** `normalTexture.scale`, default 1. */
+    normalScale: number;
+    occlusion: TextureRef | null;
+    /** `occlusionTexture.strength`, default 1. */
+    occlusionStrength: number;
+    emissive: TextureRef | null;
+    /** Linear RGB × `KHR_materials_emissive_strength` (default 0, 0, 0). */
+    emissiveFactor: Vec3;
+    doubleSided: boolean;
+    alphaMode: GltfAlphaMode;
+    /** For `MASK` (default 0.5). */
+    alphaCutoff: number;
+    /**
+     * The `KHR_materials_*` extensions the parser reads but the standard material does not
+     * render yet (clearcoat, sheen, transmission, volume, ior, specular), defaults filled; null
+     * when the material does not carry one. `GltfDocument.unsupportedExtensions` lists them.
+     */
+    extensions: GltfMaterialExtensions;
+}
+/** `KHR_materials_clearcoat`, spec defaults (factors 0). */
+export interface GltfClearcoat {
+    clearcoatFactor: number;
+    clearcoatTexture: TextureRef | null;
+    clearcoatRoughnessFactor: number;
+    clearcoatRoughnessTexture: TextureRef | null;
+    clearcoatNormalTexture: TextureRef | null;
+}
+/** `KHR_materials_sheen`, spec defaults (colour 0, roughness 0). */
+export interface GltfSheen {
+    sheenColorFactor: Vec3;
+    sheenColorTexture: TextureRef | null;
+    sheenRoughnessFactor: number;
+    sheenRoughnessTexture: TextureRef | null;
+}
+/** `KHR_materials_transmission` (factor default 0). */
+export interface GltfTransmission {
+    transmissionFactor: number;
+    transmissionTexture: TextureRef | null;
+}
+/** `KHR_materials_volume` (thickness 0, attenuation distance Infinity, colour white). */
+export interface GltfVolume {
+    thicknessFactor: number;
+    thicknessTexture: TextureRef | null;
+    attenuationDistance: number;
+    attenuationColor: Vec3;
+}
+/** `KHR_materials_ior` (default 1.5). */
+export interface GltfIor {
+    ior: number;
+}
+/** `KHR_materials_specular` (factor 1, colour white). */
+export interface GltfSpecular {
+    specularFactor: number;
+    specularTexture: TextureRef | null;
+    specularColorFactor: Vec3;
+    specularColorTexture: TextureRef | null;
+}
+/** The parsed-but-not-rendered `KHR_materials_*` records of one material. */
+export interface GltfMaterialExtensions {
+    clearcoat: GltfClearcoat | null;
+    sheen: GltfSheen | null;
+    transmission: GltfTransmission | null;
+    volume: GltfVolume | null;
+    ior: GltfIor | null;
+    specular: GltfSpecular | null;
+}
+/**
+ * One `KHR_lights_punctual` light placed by a node of the default scene. Units are glTF's:
+ * world units are metres, angles radians, `intensity` candela (point, spot) or lux
+ * (directional); `loadGltf` turns it into the engine's light records (`GltfScene.lights`).
+ */
+export interface GltfLight {
+    name: string | null;
+    /** The node carrying the light (index into `GltfDocument.nodes`). */
+    node: number;
+    /** Index into the file's `KHR_lights_punctual.lights`. */
+    light: number;
+    type: 'directional' | 'point' | 'spot';
+    /** Linear RGB (default white). */
+    color: Vec3;
+    /** Default 1. */
+    intensity: number;
+    /** Distance where the light reaches zero; absent for "infinite" (and for directional lights). */
+    range?: number;
+    /** Spot only: full intensity inside this half-angle (default 0). */
+    innerConeAngle?: number;
+    /** Spot only: zero outside this half-angle (default π/4). */
+    outerConeAngle?: number;
+    /** World position of the node. */
+    position: Vec3;
+    /** Unit world direction the light travels: the node's local -Z. */
+    direction: Vec3;
+    /** The node's world matrix (3×4 row-major, shared with the node). */
+    world: Float32Array;
+}
+/**
+ * One glTF camera placed by a node of the default scene. Perspective: `yfov` radians,
+ * `aspectRatio` (null: the viewport's), `znear`, `zfar` (null: infinite). Orthographic:
+ * `xmag`, `ymag` (half extents), `znear`, `zfar`. The camera looks down its node's local -Z.
+ */
+export interface GltfCamera {
+    name: string | null;
+    /** The node carrying the camera. */
+    node: number;
+    /** Index into the file's `cameras`. */
+    camera: number;
+    type: 'perspective' | 'orthographic';
+    yfov: number;
+    aspectRatio: number | null;
+    znear: number;
+    zfar: number | null;
+    xmag: number;
+    ymag: number;
+    position: Vec3;
+    /** The node's world matrix (3×4 row-major, shared with the node). */
+    world: Float32Array;
+    /** The view matrix: the inverse of the node's world with scale removed, column-major 4×4. */
+    view: Float32Array;
+}
+export type GltfFilter = 'nearest' | 'linear';
+export type GltfWrap = 'repeat' | 'clamp-to-edge' | 'mirror-repeat';
+/** A texture's sampler in GPU terms (`GPUSamplerDescriptor` names), defaults filled. */
+export interface GltfSampler {
+    /** Default `'linear'`. */
+    magFilter: GltfFilter;
+    /** Default `'linear'`. */
+    minFilter: GltfFilter;
+    /** Between mip levels; null when `minFilter` names no mipmap mode (then no mips). */
+    mipmapFilter: GltfFilter | null;
+    /** Default `'repeat'`. */
+    wrapS: GltfWrap;
+    wrapT: GltfWrap;
+}
+export interface GltfTexture {
+    name: string | null;
+    /** Index into `GltfDocument.images`, or null (an extension-only texture). */
+    source: number | null;
+    /**
+     * `KHR_texture_basisu`: the KTX2 image (index into `GltfDocument.images`), or null. The
+     * loader does not upload it yet (`parseKtx2` reads the container); `source`, when given, is
+     * the file's PNG/JPEG fallback and is what `loadGltf` binds.
+     */
+    basisuSource: number | null;
+    /** `wrapS`/`wrapT` are 10497 repeat (default), 33071 clamp, 33648 mirror. */
+    wrapS: number;
+    wrapT: number;
+    /** 9728 nearest or 9729 linear, when the sampler gave one. */
+    magFilter: number | null;
+    /** The same sampler in GPU terms, defaults filled. */
+    sampler: GltfSampler;
+}
+export interface GltfImage {
+    name: string | null;
+    /** Encoded image bytes (from a bufferView or a `data:` URI), or null when `uri` is external. */
+    bytes: Uint8Array | null;
+    /** `image/png`, `image/jpeg`, …; from the file or the data URI, null when unknown. */
+    mimeType: string | null;
+    /** An external URI the game resolves (`loadGltf` `opts.resources[uri]`), or null. */
+    uri: string | null;
+}
+/** A skin: which nodes are joints and the matrix that takes a vertex into each joint's space. */
+export interface GltfSkin {
+    name: string | null;
+    /** Node index per joint (`joints[j]` is the node joint `j` follows). */
+    joints: number[];
+    /**
+     * Inverse bind matrix per joint, 3×4 row-major, 12 floats each (`joints.length * 12`),
+     * converted from the file's column-major 4×4; identity when the file has none.
+     */
+    inverseBind: Float32Array;
+    /** The skeleton root node the file named, or null. */
+    skeleton: number | null;
+}
+export type GltfAnimationPath = 'translation' | 'rotation' | 'scale' | 'weights';
+export type GltfInterpolation = 'STEP' | 'LINEAR' | 'CUBICSPLINE';
+/**
+ * One animated property of one node, in the shape of the animation module's `AnimationChannel`
+ * (`src/anim/clip.ts`; restated here so `assets` does not import `anim`). `times` holds `n`
+ * ascending seconds; `values` holds `n` elements of 3 (`translation`, `scale`), 4 (`rotation`,
+ * quaternion xyzw exactly as the file stored them) or `k` (`weights`, one per morph target)
+ * floats, or `3 * n` elements for `CUBICSPLINE` (in-tangent, value, out-tangent per keyframe).
+ */
+export interface GltfAnimationChannel {
+    /** Index into `GltfDocument.nodes`. */
+    node: number;
+    path: GltfAnimationPath;
+    interpolation: GltfInterpolation;
+    times: Float32Array;
+    values: Float32Array;
+}
+/** One clip, in the shape of the animation module's `AnimationClip`. */
+export interface GltfAnimation {
+    /** The file's name, or `animation<i>`. */
+    name: string;
+    /** The last keyframe time over every channel (0 for an empty clip). */
+    duration: number;
+    channels: GltfAnimationChannel[];
+}
+export interface GltfDocument {
+    /** `asset.version`. */
+    version: string;
+    /** Root node indices of the default scene. */
+    scene: number[];
+    /** Every node reachable from `scene`, parents before children. */
+    sceneNodes: number[];
+    nodes: GltfNode[];
+    meshes: GltfMesh[];
+    materials: GltfMaterial[];
+    textures: GltfTexture[];
+    images: GltfImage[];
+    skins: GltfSkin[];
+    animations: GltfAnimation[];
+    /** External (non-`data:`) URIs the game must fetch: images here, buffers at parse time. */
+    externalUris: string[];
+    /**
+     * `extensionsUsed` entries the parser does not read, and anything else it skipped. Read
+     * (never warned): `KHR_texture_transform`, `KHR_materials_emissive_strength`,
+     * `KHR_mesh_quantization`, `EXT_meshopt_compression`, `KHR_lights_punctual`,
+     * `KHR_materials_variants`, plus those in `unsupportedExtensions`.
+     */
+    warnings: string[];
+    /**
+     * `extensionsUsed` entries the parser reads into the document but the renderer does not
+     * draw yet, once each: `KHR_materials_clearcoat`, `_sheen`, `_transmission`, `_volume`,
+     * `_ior`, `_specular` (`GltfMaterial.extensions`) and `KHR_texture_basisu`
+     * (`GltfTexture.basisuSource`).
+     */
+    unsupportedExtensions: string[];
+    /** `KHR_lights_punctual` lights of the default scene, one per carrying node, in scene order. */
+    lights: GltfLight[];
+    /** Cameras of the default scene, one per carrying node, in scene order. */
+    cameras: GltfCamera[];
+    /** `KHR_materials_variants` names, in file order (`GltfScene.setVariant` takes one). */
+    variants: string[];
+    /** World-space bounds of the default scene's meshes; radius 0 at the origin when empty. */
+    bounds: GltfBounds;
+}
+/**
+ * A `.gltf` whose JSON the game already parsed. `buffers[i]` supplies `json.buffers[i]` when
+ * that buffer has an external `uri` (or none, as in a GLB); `data:` buffers decode themselves.
+ */
+export interface GltfJsonSource {
+    json: GltfJson;
+    buffers?: ArrayBuffer[];
+}
+/**
+ * Parse a GLB (`ArrayBuffer`), the UTF-8 text of a `.gltf` (`ArrayBuffer`), or a parsed
+ * `.gltf` with its buffers. Throws `GltfError` on anything this step does not support.
+ */
+export declare function parseGltf(source: ArrayBuffer | GltfJsonSource): GltfDocument;
+/**
+ * Apply a `KHR_texture_transform` to one uv (`T · R · S · uv`): `out[0], out[1]` ← the
+ * transformed `u, v`. Returns `out`.
+ */
+export declare function transformUv(t: GltfTextureTransform, u: number, v: number, out?: [number, number]): [number, number];
+/** `T · R · S` as 3×4 row-major (the same formula as `Transform.updateLocal`). */
+export declare function composeTrs(t: Vec3, q: Vec4, s: Vec3, out: Float32Array): void;
+/** Decode a `data:[<mime>][;base64],<payload>` URI. */
+export declare function decodeDataUri(uri: string): {
+    bytes: Uint8Array<ArrayBuffer>;
+    mimeType: string | null;
+};