glTF Transform

https://gltf-transform.dev
Admin
glTF Transform is a glTF 2.0 SDK for JavaScript and TypeScript, providing an API for reading,...
Tokens:149,438
Snippets:1,590
Trust Score:6.9
Update:1 week ago
Show doc for...
Tokens:
Raw
### Root Usage Example

Source: https://gltf-transform.dev/modules/core/classes/Root

Example showing how to access the root, create a scene and node, and list scenes.

```APIDOC
## Root Usage Example

### Description
Demonstrates accessing the root, creating a scene and node, and listing scenes.

### Code Example
```javascript
const root = document.getRoot();
const scene = document.createScene('myScene');
const node = document.createNode('myNode');
scene.addChild(node);

console.log(root.listScenes()); // → [scene x 1]
```
```

--------------------------------

### Install scripting packages

Source: https://gltf-transform.dev/

Install the core, extensions, and functions packages for the scripting API.

```bash
npm install --save @gltf-transform/core @gltf-transform/extensions @gltf-transform/functions
```

--------------------------------

### Root usage example

Source: https://gltf-transform.dev/modules/core/classes/Root

Shows how to get the root from a document, create a scene and node, add the node to the scene, and list scenes. The output is [scene x 1].

```javascript
const root = document.getRoot();
const scene = document.createScene('myScene');
const node = document.createNode('myNode');
scene.addChild(node);

console.log(root.listScenes()); // → [scene x 1]
```

--------------------------------

### setProperty Examples

Source: https://gltf-transform.dev/modules/extensions/classes/Packet

Shows how to set property values on the packet. The examples set a list, an object with language and value, and another list.

```javascript
packet.setProperty('dc:Creator', {'@list': ['Acme, Inc.']});
packet.setProperty('dc:Title', {
    '@type': 'rdf:Alt',
    'rdf:_1': {'@language': 'en-US', '@value': 'Lamp'}
});
packet.setProperty('model3d:preferredSurfaces', {'@list': ['vertical']});
```

--------------------------------

### Configure Sharp mirrors for China installation

Source: https://gltf-transform.dev/cli

Troubleshooting installation in China: sets Sharp binary hosts to Alibaba mirror and reinstalls the CLI. Required if Sharp-related errors occur during installation.

```bash
npm config set sharp_binary_host "https://npmmirror.com/mirrors/sharp"
npm config set sharp_libvips_binary_host "https://npmmirror.com/mirrors/sharp-libvips"
npm install --global @gltf-transform/cli
```

--------------------------------

### getProperty Examples

Source: https://gltf-transform.dev/modules/extensions/classes/Packet

Shows how to retrieve property values from the packet. The examples demonstrate different return types: a list, an object, and a string.

```javascript
packet.getProperty('dc:Creator'); // → {"@list": ["Acme, Inc."]}
packet.getProperty('dc:Title'); // → {"@type": "rdf:Alt", "rdf:_1": {"@language": "en-US", "@value": "Lamp"}}
packet.getProperty('xmp:CreateDate'); // → "2022-01-01"
```

--------------------------------

### Material Usage Example

Source: https://gltf-transform.dev/modules/core/classes/Material

Example of creating a material, setting its properties, and assigning it to primitives.

```APIDOC
## Material Usage Example

### Description
Creates a new material, sets its base color factor, occlusion texture, and occlusion strength, then assigns it to all primitives of a mesh.

### Usage
```javascript
const material = doc.createMaterial('myMaterial')
    .setBaseColorFactor([1, 0.5, 0.5, 1]) // RGBA
    .setOcclusionTexture(aoTexture)
    .setOcclusionStrength(0.5);

mesh.listPrimitives()
    .forEach((prim) => prim.setMaterial(material));
```

### Methods Used
- `createMaterial(name)` - Creates a new material.
- `setBaseColorFactor(rgba)` - Sets the base color factor as an RGBA array.
- `setOcclusionTexture(texture)` - Sets the occlusion texture.
- `setOcclusionStrength(strength)` - Sets the occlusion strength.
- `listPrimitives()` - Returns a list of primitives in the mesh.
- `setMaterial(material)` - Assigns a material to a primitive.

### Static Properties
- `AlphaMode: Record<string, GLTF.MaterialAlphaMode>` - Constants for alpha modes.

### Property
- `propertyType: PropertyType.MATERIAL` - Indicates the property type.
```

--------------------------------

### Install CLI

Source: https://gltf-transform.dev/

Install the glTF Transform command-line interface globally.

```bash
npm install --global @gltf-transform/cli
```

--------------------------------

### listProperties Example

Source: https://gltf-transform.dev/modules/extensions/classes/Packet

Lists the properties defined in the packet. The example shows the expected output for a packet with three properties.

```javascript
packet.listProperties(); // → ['dc:Language', 'dc:Creator', 'xmp:CreateDate']
```

--------------------------------

### setContext Example

Source: https://gltf-transform.dev/modules/extensions/classes/Packet

Sets the XMP context definition URL for terms. The example defines the 'dc' and 'model3d' namespaces.

```javascript
packet.setContext({
  dc: 'http://purl.org/dc/elements/1.1/',
  model3d: 'https://schema.khronos.org/model3d/xsd/1.0/',
});
```

--------------------------------

### AnimationChannel Usage Example

Source: https://gltf-transform.dev/modules/core/classes/AnimationChannel

Example showing how to create an AnimationChannel and set its target path, target node, and sampler.

```APIDOC
## AnimationChannel Usage

### Description
Creates an AnimationChannel and configures its target path, target node, and sampler.

### Example
```javascript
const node = doc.getRoot()
    .listNodes()
    .find((node) => node.getName() === 'Cog');

const channel = doc.createAnimationChannel('cogRotation')
    .setTargetPath('rotation')
    .setTargetNode(node)
    .setSampler(rotateSampler);
```

```

--------------------------------

### Example gltf-transform.config.mjs

Source: https://gltf-transform.dev/cli-configuration

Example configuration file that defines a custom extension (GizmoExtension) and a custom command. The extension is added to the list of extensions, and the onProgramReady hook registers a custom command. The file must be plain JavaScript or compiled to it.

```javascript
// gltf-transform.config.mjs
import { Extension } from '@gltf-transform/core';
import { ALL_EXTENSIONS } from '@gltf-transform/extensions';

// NOTE: The minimal implementation below does not read or write any data
// associated with the extension. See the Extension documentation and
// official implementations in the @gltf-transform/extensions package
// for full usage.
class GizmoExtension extends Extension {
 static EXTENSION_NAME = 'ACME_gizmo';
 extensionName = 'ACME_gizmo';
 write(context) { return this; }
 read(context) { return this; }
}

export default {
 extensions: [...ALL_EXTENSIONS, GizmoExtension],
 onProgramReady: ({ program, io, Session }) => {
     // Usage: https://caporal.io/
     program
         .command('custom', 'Custom command')
         .help('Lorem ipsum dolorem...')
         .argument('<input>', 'Path to read glTF 2.0 (.glb, .gltf) model')
         .argument('<output>', 'Path to write output')
         .action(({ args, options, logger }) =>
         	Session.create(io, logger, args.input, args.output).transform(customTransform(options))
         );
 },
};

// Custom transform example; clears materials.
function customTransform(options) {
 return async (document) => {
     for (const material of document.getRoot().listMaterials()) {
         material.dispose();
     }
 };
}
```

--------------------------------

### Create and use KHRAccessorFloat64 extension

Source: https://gltf-transform.dev/modules/extensions/classes/KHRAccessorFloat64

Example showing how to create the KHRAccessorFloat64 extension, mark it as required, and store Float64Array data in accessors.

```javascript
import {Accessor} from '@gltf-transform/core';
import {KHRAccessorFloat64} from '@gltf-transform/extensions';

// Create an Extension attached to the Document.
document.createExtension(KHRAccessorFloat64).setRequired(true);

// Store Float64Array instances in one or more Accessors.
const mesh = document.getRoot().listMeshes()
  .find((mesh) => mesh.getName() === 'MyMesh');

for (const prim of mesh.listPrimitives()) {
  const position = document.createAccessor()
    .setType('VEC3')
    .setArray(new Float64Array([...]));
  prim.setAttribute('POSITION', position);
}
```

--------------------------------

### Install glTF-Transform extensions package

Source: https://gltf-transform.dev/extensions

Install the required package to access glTF extensions.

```bash
npm install --save @gltf-transform/extensions
```

--------------------------------

### Install @gltf-transform/functions

Source: https://gltf-transform.dev/functions

Install the @gltf-transform/functions module via npm.

```bash
npm install --save @gltf-transform/functions
```

--------------------------------

### compressTexture example

Source: https://gltf-transform.dev/modules/functions/functions/compressTexture

Optimizes a single texture, optionally resizing or converting to JPEG, PNG, WebP, or AVIF formats. For best results use a Node.js environment, install the `sharp` module, and provide an encoder. When the encoder is omitted — `sharp` works only in Node.js — the implementation will use a platform-specific fallback encoder, and most quality- and compression-related options are ignored.

```javascript
import { compressTexture } from '@gltf-transform/functions';
import sharp from 'sharp';

const texture = document.getRoot().listTextures()
    .find((texture) => texture.getName() === 'MyTexture');

// (A) Node.js.
await compressTexture(texture, {
    encoder: sharp,
    targetFormat: 'webp',
    resize: [1024, 1024]
});

// (B) Web.
await compressTexture(texture, {
    targetFormat: 'webp',
    resize: [1024, 1024]
});
```

--------------------------------

### meshopt compression example

Source: https://gltf-transform.dev/modules/functions/functions/meshopt

Shows how to apply Meshopt compression with the meshopt transform. Requires the MeshoptEncoder from 'meshoptimizer' and awaiting its ready promise. Compression is deferred until generating output with an I/O class.

```javascript
import { MeshoptEncoder } from 'meshoptimizer';
import { meshopt } from '@gltf-transform/functions';

await MeshoptEncoder.ready;

await document.transform(
  meshopt({encoder: MeshoptEncoder, level: 'medium'})
);

```

--------------------------------

### listTextureInfoByMaterial example

Source: https://gltf-transform.dev/modules/functions/functions/listTextureInfoByMaterial

Lists all TextureInfo definitions for a material and extracts the texCoord indices. The example maps over the results to get an array of texCoord values, e.g., [0, 1].

```javascript
const results = listTextureInfoByMaterial(material);

const texCoords = results.map((info) => info.getTexCoord());
// → [0, 1]

```

--------------------------------

### Define material variants with KHRMaterialsVariants

Source: https://gltf-transform.dev/modules/extensions/classes/KHRMaterialsVariants

Create a KHRMaterialsVariants extension, define Healthy and Damaged variants, map them to materials, and attach the mapping list to a primitive using KHRMaterialsVariants.createMappingList() and Primitive.setExtension(). This example shows the complete setup required to use the extension. Viewers that don't recognize the extension will fall back to the default material on the primitive, so assign that default material as needed. Each mapping can include multiple variants; the first matching variant is chosen.

```javascript
import { KHRMaterialsVariants } from '@gltf-transform/extensions';

// Create an Extension attached to the Document.
const variantExtension = document.createExtension(KHRMaterialsVariants);

// Create some Variant states.
const healthyVariant = variantExtension.createVariant('Healthy');
const damagedVariant = variantExtension.createVariant('Damaged');

// Create mappings from a Variant state to a Material.
const healthyMapping = variantExtension.createMapping()
    .addVariant(healthyVariant)
    .setMaterial(healthyMat);
const damagedMapping = variantExtension.createMapping()
    .addVariant(damagedVariant)
    .setMaterial(damagedMat);

// Attach the mappings to a Primitive.
primitive.setExtension(
    'KHR_materials_variants',
    variantExtension.createMappingList()
        .addMapping(healthyMapping)
        .addMapping(damagedMapping)
);
```

--------------------------------

### prune example with propertyTypes and keepExtras

Source: https://gltf-transform.dev/modules/functions/functions/prune

Example showing how to use the prune transform to remove unused materials. It imports PropertyType and prune, then applies the transform with propertyTypes set to MATERIAL and keepExtras set to true. The example shows that after the transform, the number of materials is reduced from two to one.

```javascript
import { PropertyType } from '@gltf-transform/core';
import { prune } from '@gltf-transform/functions';

document.getRoot().listMaterials(); // → [Material, Material]

await document.transform(
    prune({
        propertyTypes: [PropertyType.MATERIAL],
        keepExtras: true
    })
);

document.getRoot().listMaterials(); // → [Material]

```

--------------------------------

### NodeIO usage: read/write Document and enable network

Source: https://gltf-transform.dev/modules/core/classes/NodeIO

First example shows NodeIO import and methods read/readBinary/write/writeBinary\/ on a Document. Second example enables network requests with a Fetch implementation and setAllowNetwork(true).

```typescript
import { NodeIO } from '@gltf-transform/core';

const io = new NodeIO();

// Read.
let document;
document = await io.read('model.glb'); // → Document
document = await io.readBinary(glb);   // Uint8Array → Document

// Write.
await io.write('model.glb', document);      // → void
const glb = await io.writeBinary(document); // Document → Uint8Array

```

```typescript
const io = new NodeIO(fetch, {headers: {...}}).setAllowNetwork(true);

const document = await io.read('https://example.com/path/to/model.glb');

```

--------------------------------

### Accessor Usage Example

Source: https://gltf-transform.dev/modules/core/classes/Accessor

Demonstrates creating an Accessor, setting its array, type, and buffer, and using getCount, getElementSize, getByteLength, getElement, and setElement methods.

```APIDOC
## Accessor Usage Example

### Description
Demonstrates creating an Accessor, setting its array, type, and buffer, and using getCount, getElementSize, getByteLength, getElement, and setElement methods.

### Methods
- **createAccessor(name)** - Creates a new Accessor with the given name.
- **setArray(array)** - Sets the underlying typed array for the accessor.
- **setType(type)** - Sets the element type (e.g., Accessor.Type.VEC3).
- **setBuffer(buffer)** - Assigns the accessor to a Buffer.
- **getCount()** - Returns the number of elements in the accessor.
- **getElementSize()** - Returns the number of components per element.
- **getByteLength()** - Returns the total byte length of the accessor's data.
- **getElement(index, target)** - Returns the element at the given index as an array.
- **setElement(index, value)** - Sets the element at the given index to the provided array.

### Example
```
const accessor = doc.createAccessor('myData')
    .setArray(new Float32Array([1,2,3,4,5,6,7,8,9,10,11,12]))
    .setType(Accessor.Type.VEC3)
    .setBuffer(doc.getRoot().listBuffers()[0]);

accessor.getCount();        // → 4
accessor.getElementSize();  // → 3
accessor.getByteLength();   // → 48
accessor.getElement(1, []); // → [4, 5, 6]

accessor.setElement(0, [10, 20, 30]);
```

```

--------------------------------

### AnimationSampler Usage Example

Source: https://gltf-transform.dev/modules/core/classes/AnimationSampler

Demonstrates how to create an AnimationSampler with input and output accessors and set interpolation.

```APIDOC
## AnimationSampler

### Description
Reusable collection of keyframes affecting particular property of an object. Each AnimationSampler refers to an input and an output Accessor. Input contains times (in seconds) for each keyframe. Output contains values (of any Accessor.Type) for the animated property at each keyframe. Samplers using `CUBICSPLINE` interpolation will also contain in/out tangents in the output, with the layout: in1, value1, out1, in2, value2, out2, in3, value3, out3, ...

### Usage
```javascript
// Create accessor containing input times, in seconds.
const input = doc.createAccessor('bounceTimes')
    .setArray(new Float32Array([0, 1, 2]))
    .setType(Accessor.Type.SCALAR);

// Create accessor containing output values, in local units.
const output = doc.createAccessor('bounceValues')
    .setArray(new Float32Array([
        0, 0, 0, // y = 0
        0, 1, 0, // y = 1
        0, 0, 0, // y = 0
    ]))
    .setType(Accessor.Type.VEC3);

// Create sampler.
const sampler = doc.createAnimationSampler('bounce')
    .setInput(input)
    .setOutput(output)
    .setInterpolation('LINEAR');
```

### Static Properties
- **Interpolation**: Record<string, GLTF.AnimationSamplerInterpolation> - Interpolation method.

### Properties
- **propertyType**: PropertyType.ANIMATION_SAMPLER
```

--------------------------------

### Advanced manual EXTMeshoptCompression setup

Source: https://gltf-transform.dev/modules/extensions/classes/EXTMeshoptCompression

Manually reorders and quantizes vertex data before adding the EXTMeshoptCompression extension with quantization encoder options. Compression is deferred until output generation.

```javascript
import { reorder, quantize } from '@gltf-transform/functions';
import { EXTMeshoptCompression } from '@gltf-transform/extensions';
import { MeshoptEncoder } from 'meshoptimizer';

await document.transform(
    reorder({encoder: MeshoptEncoder}),
    quantize()
);

document.createExtension(EXTMeshoptCompression)
    .setRequired(true)
    .setEncoderOptions({ method: EXTMeshoptCompression.EncoderMethod.QUANTIZE });
```

--------------------------------

### EXTTextureWebP Extension Usage

Source: https://gltf-transform.dev/modules/extensions/classes/EXTTextureWebP

Example of creating and using the EXTTextureWebP extension with a Document, including setting it as required and creating a WebP texture.

```APIDOC
## EXTTextureWebP

### Description
Enables WebP images for any material texture in a glTF document. Attach this extension to the Document to allow use of the `image/webp` MIME type and WebP image data.

### Usage Example
```javascript
import { EXTTextureWebP } from '@gltf-transform/extensions';

// Create an Extension attached to the Document.
const webpExtension = document.createExtension(EXTTextureWebP)
    .setRequired(true);
document.createTexture('MyWebPTexture')
    .setMimeType('image/webp')
    .setImage(fs.readFileSync('my-texture.webp'));
```

### Methods

#### dispose(): void
Disables and removes the extension from the Document.

#### isRequired(): boolean
Indicates to the client whether it is OK to load the asset when this extension is not recognized. Optional extensions are generally preferred, if there is not a good reason to require a client to completely fail when an extension isn't known.

#### listProperties(): ExtensionProperty[]
Lists all ExtensionProperty instances associated with, or created by, this extension. Includes only instances that are attached to the Document's graph; detached instances will be excluded.

#### setRequired(required: boolean): Extension
Indicates to the client whether it is OK to load the asset when this extension is not recognized. Optional extensions are generally preferred, if there is not a good reason to require a client to completely fail when an extension isn't known.

### Static Properties
- `EXTENSION_NAME`: typeof EXT_TEXTURE_WEBP

### Instance Properties
- `extensionName`: typeof EXT_TEXTURE_WEBP

```

--------------------------------

### DenoIO usage example

Source: https://gltf-transform.dev/modules/core/classes/DenoIO

Shows how to import DenoIO and use it to read and write glTF files. Requires the Deno standard library path module. The read method accepts a URI, readBinary accepts a Uint8Array, and writeBinary returns a Uint8Array.

```typescript
import { DenoIO } from 'https://esm.sh/@gltf-transform/core';
import * as path from 'https://deno.land/std/path/mod.ts';

const io = new DenoIO(path);

// Read.
let document;
document = io.read('model.glb');  // → Document
document = io.readBinary(glb);    // Uint8Array → Document

// Write.
const glb = io.writeBinary(document);  // Document → Uint8Array
```

--------------------------------

### EXTTextureAVIF Extension Usage

Source: https://gltf-transform.dev/modules/extensions/classes/EXTTextureAVIF

Example of creating and using the EXTTextureAVIF extension with a texture.

```APIDOC
## EXTTextureAVIF Extension

### Description
Enables AVIF images for any material texture. Attach to the Document to allow use of the `image/avif` MIME type and AVIF image data.

### Usage Example
```javascript
import { TextureAVIF } from '@gltf-transform/extensions';

// Create an Extension attached to the Document.
const avifExtension = document.createExtension(TextureAVIF)
    .setRequired(true);
document.createTexture('MyAVIFTexture')
    .setMimeType('image/avif')
    .setImage(fs.readFileSync('my-texture.avif'));
```

### Methods

#### dispose(): void
Disables and removes the extension from the Document.

#### isRequired(): boolean
Indicates to the client whether it is OK to load the asset when this extension is not recognized. Optional extensions are generally preferred, if there is not a good reason to require a client to completely fail when an extension isn't known.

#### listProperties(): ExtensionProperty[]
Lists all ExtensionProperty instances associated with, or created by, this extension. Includes only instances that are attached to the Document's graph; detached instances will be excluded.

#### setRequired(required: boolean): Extension
Indicates to the client whether it is OK to load the asset when this extension is not recognized. Optional extensions are generally preferred, if there is not a good reason to require a client to completely fail when an extension isn't known.

### Static Properties
- **EXTENSION_NAME**: typeof EXT_TEXTURE_AVIF

### Properties
- **extensionName**: typeof EXT_TEXTURE_AVIF
```

--------------------------------

### uninstance usage example

Source: https://gltf-transform.dev/modules/functions/functions/uninstance

Imports the uninstance transform and applies it to a document. The example shows the node count increasing from 10 to 1000 after the transform, as each instance becomes a separate node.

```javascript
import { uninstance } from '@gltf-transform/functions';

document.getRoot().listNodes(); // → [ Node x 10 ]

await document.transform(uninstance());

document.getRoot().listNodes(); // → [ Node x 1000 ]
```

--------------------------------

### joinPrimitives example

Source: https://gltf-transform.dev/modules/functions/functions/joinPrimitives

Joins all primitives of a mesh into one, disposing the originals and adding the result. Throws an error if primitives are incompatible.

```javascript
import { joinPrimitives } from '@gltf-transform/functions';

// Succeeds if Primitives are compatible, or throws an error.
const result = joinPrimitives(mesh.listPrimitives());

for (const prim of mesh.listPrimitives()) {
    prim.dispose();
}

mesh.addPrimitive(result);
```

--------------------------------

### KHRAccessorFloat64 Extension Usage

Source: https://gltf-transform.dev/modules/extensions/classes/KHRAccessorFloat64

Example of creating and using the KHRAccessorFloat64 extension with @gltf-transform/core and @gltf-transform/extensions.

```APIDOC
## KHRAccessorFloat64

### Description
Enables support for IEEE-754 binary64 ("double-precision" or "float64") Accessors, in all contexts where the base glTF 2.0 specification already allows binary32 ("single-precision" or "float32") Accessors. This extension must be marked as required.

### Example
```javascript
import {Accessor} from '@gltf-transform/core';
import {KHRAccessorFloat64} from '@gltf-transform/extensions';

// Create an Extension attached to the Document.
document.createExtension(KHRAccessorFloat64).setRequired(true);

// Store Float64Array instances in one or more Accessors.
const mesh = document.getRoot().listMeshes()
  .find((mesh) => mesh.getName() === 'MyMesh');

for (const prim of mesh.listPrimitives()) {
  const position = document.createAccessor()
    .setType('VEC3')
    .setArray(new Float64Array([...]));
  prim.setAttribute('POSITION', position);
}
```

### Static Properties
- **EXTENSION_NAME**: "KHR_accessor_float64"

### Properties
- **extensionName**: "KHR_accessor_float64"

### Methods

#### dispose(): void
Disables and removes the extension from the Document.

#### isRequired(): boolean
Indicates to the client whether it is OK to load the asset when this extension is not recognized. Optional extensions are generally preferred, if there is not a good reason to require a client to completely fail when an extension isn't known.

#### listProperties(): ExtensionProperty[]
Lists all ExtensionProperty instances associated with, or created by, this extension. Includes only instances that are attached to the Document's graph; detached instances will be excluded.

#### setRequired(required: boolean): Extension
Indicates to the client whether it is OK to load the asset when this extension is not recognized. Optional extensions are generally preferred, if there is not a good reason to require a client to completely fail when an extension isn't known.
```

--------------------------------

### Unpack instanced mesh with createInstanceNodes

Source: https://gltf-transform.dev/modules/functions/functions/createInstanceNodes

Given a batchNode with an InstancedMesh extension, this example creates a node for each instance, adds them as children of the batchNode, then clears the mesh and the EXTMeshGPUInstancing extension. Use this to unpack instancing previously applied with instance or EXTMeshGPUInstancing.

```javascript
import { createInstanceNodes } from '@gltf-transform/functions';

for (const instanceNode of createInstanceNodes(batchNode)) {
  batchNode.addChild(instanceNode);
}

batchNode.setMesh(null).setExtension('EXTMeshGPUInstancing', null);

```

--------------------------------

### Assemble a JSONDocument and convert to Document with NodeIO.readJSON

Source: https://gltf-transform.dev/modules/core/interfaces/JSONDocument

Shows how to create a JSONDocument with JSON and resources, then convert it to a Document using NodeIO.readJSON. The resources map URIs to Uint8Array buffers, and the example uses fs/promises to read image files.

```javascript
import fs from 'fs/promises';

const jsonDocument = {
    // glTF JSON schema.
    json: {
        asset: {version: '2.0'},
        images: [{uri: 'image1.png'}, {uri: 'image2.png'}]
    },

    // URI → Uint8Array mapping.
    resources: {
        'image1.png': await fs.readFile('image1.png'),
        'image2.png': await fs.readFile('image2.png'),
    }
};

const document = await new NodeIO().readJSON(jsonDocument);
```

--------------------------------

### Create and configure a Node

Source: https://gltf-transform.dev/modules/core/classes/Node

Shows how to create a Node, attach a mesh, set a translation, and add a child node.

```javascript
const node = doc.createNode('myNode')
    .setMesh(mesh)
    .setTranslation([0, 0, 0])
    .addChild(otherNode);
```

--------------------------------

### init()

Source: https://gltf-transform.dev/modules/core/classes/NodeIO

Initializes the NodeIO instance. This method is part of the I/O lifecycle.

```APIDOC
## init

### Description
Initializes the NodeIO instance. This method is part of the I/O lifecycle.

### Method
init

### Signature
`init(): Promise<void>`

### Returns
- Promise<void> - A promise that resolves when initialization is complete.
```

--------------------------------

### Read and Write glTF Documents with WebIO

Source: https://gltf-transform.dev/modules/core/classes/WebIO

Demonstrates initializing the WebIO service and performing basic read and write operations for glTF models.

```javascript
import { WebIO } from '@gltf-transform/core';

const io = new WebIO({credentials: 'include'});

// Read.
let document;
document = await io.read('model.glb');  // → Document
document = await io.readBinary(glb);    // Uint8Array → Document

// Write.
const glb = await io.writeBinary(document); // Document → Uint8Array
```

--------------------------------

### constructor(fetch?, fetchConfig?)

Source: https://gltf-transform.dev/modules/core/classes/NodeIO

Constructs a new NodeIO service. Instances are reusable. By default, only reads/writes paths on disk. To enable HTTP requests, provide a Fetch API implementation and enable setAllowNetwork.

```APIDOC
## Constructor

### Description
Constructs a new NodeIO service. Instances are reusable. By default, only reads/writes paths on disk. To enable HTTP requests, provide a Fetch API implementation and enable setAllowNetwork.

### Signature
`constructor(_fetch?: unknown, _fetchConfig?: RequestInit): NodeIO`

### Parameters
- `_fetch` (unknown) - Optional - Fetch API implementation for network requests.
- `_fetchConfig` (RequestInit) - Optional - Configuration for network requests.

### Returns
- NodeIO - The constructed NodeIO instance.
```

--------------------------------

### listTextureInfo usage example

Source: https://gltf-transform.dev/modules/functions/functions/listTextureInfo

Lists all TextureInfo instances associated with a texture and maps them to their texCoord indices. The example shows the expected result [0, 1] for the texCoords array.

```javascript
// Find TextureInfo instances associated with the texture.
const results = listTextureInfo(texture);

// Find which UV sets (TEXCOORD_0, TEXCOORD_1, ...) are required.
const texCoords = results.map((info) => info.getTexCoord());
// → [0, 1]

```

--------------------------------

### Create and configure a Primitive

Source: https://gltf-transform.dev/modules/core/classes/Primitive

Shows how to create a primitive, set POSITION and TEXCOORD_0 attributes, assign a material, and add it to a mesh.

```javascript
const primitive = doc.createPrimitive()
    .setAttribute('POSITION', positionAccessor)
    .setAttribute('TEXCOORD_0', uvAccessor)
    .setMaterial(material);
mesh.addPrimitive(primitive);
node.setMesh(mesh);
```

--------------------------------

### clearNodeParent usage example

Source: https://gltf-transform.dev/modules/functions/functions/clearNodeParent

Imports clearNodeParent from '@gltf-transform/functions' and demonstrates clearing a node's parent. The example shows scene traversal before and after the operation, with the node moving from a nested hierarchy to directly under the scene.

```javascript
import { clearNodeParent } from '@gltf-transform/functions';

scene.traverse((node) => { ... }); // Scene → … → Node

clearNodeParent(node);

scene.traverse((node) => { ... }); // Scene → Node

```

--------------------------------

### Create and assign an XMP packet with KHRXMP

Source: https://gltf-transform.dev/modules/extensions/classes/KHRXMP

Shows how to create a KHRXMP extension, create a Packet with a Dublin Core context, set a property, and assign the packet to either the document root or a specific property like a texture.

```javascript
import { KHRXMP, Packet } from '@gltf-transform/extensions';

// Create an Extension attached to the Document.
const xmpExtension = document.createExtension(KHRXMP);

// Create Packet property.
const packet = xmpExtension.createPacket()
    .setContext({
        dc: 'http://purl.org/dc/elements/1.1/',
    })
.setProperty('dc:Creator', {"@list": ["Acme, Inc."]});

// Option 1: Assign to Document Root.
document.getRoot().setExtension('KHR_xmp_json_ld', packet);

// Option 2: Assign to a specific Property.
texture.setExtension('KHR_xmp_json_ld', packet);
```

--------------------------------

### listTextureChannels usage example

Source: https://gltf-transform.dev/modules/functions/functions/listTextureChannels

Use this snippet to check if a texture uses a specific channel, such as the red channel. The function returns an array of TextureChannel values, and the example logs a message when the red channel is included.

```javascript
const channels = listTextureChannels(texture);
if (channels.includes(TextureChannel.R)) {
  console.log('texture red channel used');
}
```

--------------------------------

### Optimize glTF with CLI

Source: https://gltf-transform.dev/

Run the optimize command with WebP texture compression.

```bash
gltf-transform optimize input.glb output.glb --texture-compress webp
```

--------------------------------

### constructor

Source: https://gltf-transform.dev/modules/core/classes/WebIO

Creates a new WebIO instance for reading and writing glTF assets in web environments.

```APIDOC
## WebIO constructor

### Description
Constructs a new WebIO service. Instances are reusable.

### Syntax
`new WebIO(fetchConfig?: RequestInit): WebIO`

### Parameters
- **fetchConfig** (RequestInit) - Optional - Configuration for fetch requests.

### Returns
- **WebIO** - The new WebIO instance.
```

--------------------------------

### Create KHRTextureBasisu extension and set KTX2 texture

Source: https://gltf-transform.dev/modules/extensions/classes/KHRTextureBasisu

Creates a KHRTextureBasisu extension on the document, marks it as required, and creates a texture with MIME type 'image/ktx2' and image data from a .ktx2 file. Compression is not automatic; the image data must be pre-compressed.

```javascript
import { KHRTextureBasisu } from '@gltf-transform/extensions';

// Create an Extension attached to the Document.
const basisuExtension = document.createExtension(KHRTextureBasisu)
    .setRequired(true);
document.createTexture('MyCompressedTexture')
    .setMimeType('image/ktx2')
    .setImage(fs.readFileSync('my-texture.ktx2'));

```

--------------------------------

### JSONDocument Usage

Source: https://gltf-transform.dev/modules/core/interfaces/JSONDocument

Example of constructing a JSONDocument and converting it to a Document using NodeIO.readJSON().

```APIDOC
## JSONDocument Usage

### Description
Demonstrates how to create a JSONDocument object and convert it to a Document using NodeIO.readJSON().

### Usage Example
```javascript
import fs from 'fs/promises';

const jsonDocument = {
    // glTF JSON schema.
    json: {
        asset: {version: '2.0'},
        images: [{uri: 'image1.png'}, {uri: 'image2.png'}]
    },

    // URI → Uint8Array mapping.
    resources: {
        'image1.png': await fs.readFile('image1.png'),
        'image2.png': await fs.readFile('image2.png'),
    }
};

const document = await new NodeIO().readJSON(jsonDocument);
```

### Properties
- **json** (GLTF.IGLTF) - The glTF JSON schema.
- **resources** ({ [s: string]: Uint8Array<ArrayBuffer> }) - A mapping of URI strings to binary resources.
```

--------------------------------

### listTextureSlots usage example

Source: https://gltf-transform.dev/modules/functions/functions/listTextureSlots

Retrieves an array of slot names where the specified texture is applied.

```javascript
const slots = listTextureSlots(texture);
// → ['occlusionTexture', 'metallicRoughnessTexture']
```

--------------------------------

### Resize and compress textures with CLI

Source: https://gltf-transform.dev/

Resize textures, compress with WebP, or use KTX2/Basis Universal codecs (UASTC and ETC1S).

```bash
# Resize textures.
gltf-transform resize input.glb output.glb --width 1024 --height 1024

# Compress textures with WebP.
gltf-transform webp input.glb output.glb --slots "baseColor"

# Compress textures with KTX2 + Basis Universal codecs, UASTC and ETC1S.
gltf-transform uastc input.glb output1.glb     --slots "{normalTexture,occlusionTexture,metallicRoughnessTexture}"     --level 4 --rdo --rdo-lambda 4 --zstd 18 --verbose
gltf-transform etc1s output1.glb output2.glb --quality 255 --verbose
```

--------------------------------

### metalRough(_options?: MetalRoughOptions): Transform

Source: https://gltf-transform.dev/modules/functions/functions/metalRough

Converts materials from spec/gloss PBR workflow to metal/rough PBR workflow. Removes KHR_materials_pbrSpecularGlossiness and adds KHR_materials_ior and KHR_materials_specular. No options are currently implemented.

```APIDOC
## metalRough(_options?: MetalRoughOptions): Transform

### Description
Converts Materials from spec/gloss PBR workflow to metal/rough PBR workflow, removing `KHR_materials_pbrSpecularGlossiness` and adding `KHR_materials_ior` and `KHR_materials_specular`. The metal/rough PBR workflow is preferred for most use cases, and is a prerequisite for other advanced PBR extensions provided by glTF.

### Method
Function

### Signature
metalRough(_options?: MetalRoughOptions): Transform

### Parameters
#### Options
- **_options** (MetalRoughOptions) - Optional - No options are currently implemented for this function.

### Returns
- **Transform** - A Transform object for use in glTF processing pipelines.

```

--------------------------------

### Join Primitives transformation

Source: https://gltf-transform.dev/modules/functions/functions/join

Example showing the application of join alongside dedup and flatten transformations to optimize a glTF document.

```typescript
import { PropertyType } from '@gltf-transform/core';
import { join, flatten, dedup } from '@gltf-transform/functions';

await document.transform(
    dedup({ propertyTypes: [PropertyType.MATERIAL] }),
    flatten(),
    join({ keepNamed: false }),
);
```

--------------------------------

### constructor(path: unknown): DenoIO

Source: https://gltf-transform.dev/modules/core/classes/DenoIO

Creates a new DenoIO instance with the provided path module.

```APIDOC
## constructor(path: unknown): DenoIO

### Description
Creates a new DenoIO instance with the provided path module.

### Method
constructor

### Parameters
- **path** (unknown) - Required - The path module from Deno's standard library.

### Returns
- **DenoIO** - A new DenoIO instance.

```

--------------------------------

### getBounds usage example

Source: https://gltf-transform.dev/modules/functions/functions/getBounds

Imports getBounds from @gltf-transform/functions and computes the bounding box for a scene, returning the min and max coordinates.

```javascript
import { getBounds } from '@gltf-transform/functions';

const {min, max} = getBounds(scene);
```

--------------------------------

### vertexColorSpace usage example

Source: https://gltf-transform.dev/modules/functions/functions/vertexColorSpace

Imports vertexColorSpace from @gltf-transform/functions and applies it to a document transform with inputColorSpace set to 'srgb' to correct vertex colors.

```javascript
import { vertexColorSpace } from '@gltf-transform/functions';

await document.transform(
  vertexColorSpace({ inputColorSpace: 'srgb' })
);
```

--------------------------------

### Using EXT_texture_webp

Source: https://gltf-transform.dev/modules/extensions/classes/EXTTextureWebP

Creates an EXTTextureWebP extension, marks it required, and creates a texture with the WebP MIME type. The image data must be converted to WebP before passing it to the texture. The extension should always be required when used.

```javascript
import { EXTTextureWebP } from '@gltf-transform/extensions';

// Create an Extension attached to the Document.
const webpExtension = document.createExtension(EXTTextureWebP)
    .setRequired(true);
document.createTexture('MyWebPTexture')
    .setMimeType('image/webp')
    .setImage(fs.readFileSync('my-texture.webp'));
```

--------------------------------

### Create node and reference mesh

Source: https://gltf-transform.dev/concepts

Shows how to find a mesh by name, create a new node that instantiates it, add the node to a scene, and list all parents referencing the mesh.

```javascript
// Find an existing Mesh named 'Cog'.
const mesh = doc.getRoot()
  .listMeshes()
  .find((mesh) => mesh.getName() === 'Cog');

// Instantiate a copy of the 'Cog' mesh at a new node, 'CogInstance1'.
const cogNode = doc.createNode('CogInstance1')
  .setMesh(mesh);

// Add the Node to a Scene.
doc.listScenes()[0]
  .addChild(cogNode);

// List all references to the 'Cog' mesh.
mesh.listParents(); // → [cogNode, ...]
```

--------------------------------

### gltf-transform CLI full command list

Source: https://gltf-transform.dev/cli

Full command list output from `gltf-transform` (version 4.5.0). Shows usage syntax and all available commands grouped by category: INSPECT, PACKAGE, SCENE, and GEOMETRY. Use `gltf-transform help <command>` for details on a specific command.

```text
  gltf-transform 4.5.0 — Command-line interface (CLI) for the glTF Transform SDK.

  USAGE 
  
    ▸ gltf-transform <command> [ARGUMENTS...] [OPTIONS...]


  COMMANDS — Type 'gltf-transform help <command>' to get some help about a command

                                                                                                
                                                                                                
                                         🔎 INSPECT ──────────────────────────────────────────  
    inspect                              Inspect contents of the model                          
    validate                             Validate model against the glTF spec                   
                                                                                                
                                                                                                
                                         📦 PACKAGE ──────────────────────────────────────────  
    copy                                 Copy model with minimal changes                        
    optimize                             Optimize model by all available methods                
    merge                                Merge two or more models into one                      
    partition                            Partition binary data into separate .bin files         
    dedup                                Deduplicate accessors and textures                     
    prune                                Remove unreferenced properties from the file           
    gzip                                 Compress model with lossless gzip                      
    xmp                                  Add or modify XMP metadata                             
                                                                                                
                                                                                                
                                         🌍 SCENE ────────────────────────────────────────────  
    center                               Center the scene at the origin, or above/below it      
    instance                             Create GPU instances from shared mesh references       
    flatten                              Flatten scene graph                                    
    join                                 Join meshes and reduce draw calls                      
                                                                                                
                                                                                                
                                         🫖  GEOMETRY ─────────────────────────────────────────  
    draco                                Compress geometry with Draco                           
    meshopt                              Compress geometry and animation with Meshopt           
    quantize                             Quantize geometry, reducing precision and memory       
    dequantize                           Dequantize geometry                                    
    weld                                 Merge equivalent vertices to optimize geometry         
    unweld                               De-index geometry, disconnecting any shared vertices   
```

--------------------------------

### transformMesh usage example

Source: https://gltf-transform.dev/modules/functions/functions/transformMesh

Applies a translation matrix to a mesh, offsetting its vertices by 10 units on the Y axis. Requires the gl-matrix and @gltf-transform/functions packages.

```javascript
import { fromTranslation } from 'gl-matrix/mat4';
import { transformMesh } from '@gltf-transform/functions';

// offset vertices, y += 10.
transformMesh(mesh, fromTranslation([], [0, 10, 0]));
```

--------------------------------

### getTextureColorSpace usage example

Source: https://gltf-transform.dev/modules/functions/functions/getTextureColorSpace

Imports getTextureColorSpace from '@gltf-transform/functions' and calls it on base color and normal textures. The base color texture returns 'srgb', while the normal texture returns null.

```javascript
import { getTextureColorSpace } from '@gltf-transform/functions';

const baseColorTexture = material.getBaseColorTexture();
const normalTexture = material.getNormalTexture();

getTextureColorSpace(baseColorTexture); // → 'srgb'
getTextureColorSpace(normalTexture); // → null

```

--------------------------------

### Create EXTTextureAVIF extension and set AVIF texture

Source: https://gltf-transform.dev/modules/extensions/classes/EXTTextureAVIF

Shows how to create an EXTTextureAVIF extension, mark it as required, and create a texture with an AVIF image. Note that AVIF conversion is not automatic; you must convert the image data first and pass the .avif payload to Texture.setImage.

```javascript
import { TextureAVIF } from '@gltf-transform/extensions';

// Create an Extension attached to the Document.
const avifExtension = document.createExtension(TextureAVIF)
    .setRequired(true);
document.createTexture('MyAVIFTexture')
    .setMimeType('image/avif')
    .setImage(fs.readFileSync('my-texture.avif'));
```

--------------------------------

### Create and attach Anisotropy property

Source: https://gltf-transform.dev/modules/extensions/classes/KHRMaterialsAnisotropy

Creates an Anisotropy property using the KHRMaterialsAnisotropy extension and attaches it to a material. The example sets anisotropy strength to 1.0 and rotation to Math.PI / 4.

```javascript
import { KHRMaterialsAnisotropy, Anisotropy } from '@gltf-transform/extensions';

// Create an Extension attached to the Document.
const anisotropyExtension = document.createExtension(KHRMaterialsAnisotropy);

// Create an Anisotropy property.
const anisotropy = anisotropyExtension.createAnisotropy()
    .setAnisotropyStrength(1.0)
    .setAnisotropyRotation(Math.PI / 4);

// Attach the property to a Material.
material.setExtension('KHR_materials_anisotropy', anisotropy);
```

--------------------------------

### Create and assign a Material with base color, occlusion texture, and strength

Source: https://gltf-transform.dev/modules/core/classes/Material

Creates a material named 'myMaterial', sets its base color factor to RGBA [1, 0.5, 0.5, 1], assigns an occlusion texture, sets occlusion strength to 0.5, and then assigns the material to all primitives of a mesh.

```javascript
const material = doc.createMaterial('myMaterial')
    .setBaseColorFactor([1, 0.5, 0.5, 1]) // RGBA
    .setOcclusionTexture(aoTexture)
    .setOcclusionStrength(0.5);

mesh.listPrimitives()
    .forEach((prim) => prim.setMaterial(material));

```

--------------------------------

### isRelativePath(path: string): boolean

Source: https://gltf-transform.dev/modules/core/classes/HTTPUtils

Returns true for paths that are declared relative to some unknown base path. For example, "foo/bar/" is relative both "/foo/bar/" is not.

```APIDOC
## isRelativePath(path: string): boolean

### Description
Returns true for paths that are declared relative to some unknown base path. For example, "foo/bar/" is relative both "/foo/bar/" is not.

### Method
isRelativePath

### Parameters
- **path** (string) - Required - The path to check.

### Returns
- **boolean** - True if the path is relative, false otherwise.
```

--------------------------------

### Create Document and deduplicate textures

Source: https://gltf-transform.dev/modules/core/classes/Document

Creates a Document, adds two textures with the same image, then uses the dedup function to remove duplicates. The example shows the texture count before and after the transform.

```javascript
import fs from 'fs/promises';
import { Document } from '@gltf-transform/core';
import { dedup } from '@gltf-transform/functions';

const document = new Document();

const texture1 = document.createTexture('myTexture')
    .setImage(await fs.readFile('path/to/image.png'))
    .setMimeType('image/png');
const texture2 = document.createTexture('myTexture2')
    .setImage(await fs.readFile('path/to/image2.png'))
    .setMimeType('image/png');

// Document containing duplicate copies of the same texture.
document.getRoot().listTextures(); // → [texture x 2]

await document.transform(
    dedup({textures: true}),
    // ...
);

// Document with duplicate textures removed.
document.getRoot().listTextures(); // → [texture x 1]
```
Tokens:
Raw