### Install pygltflib

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Install the library using pip. This command installs the latest version of pygltflib.

```bash
pip install pygltflib
```

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

### Create a Simple Mesh with pygltflib

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

This example demonstrates the creation of basic glTF 2.0 objects for a scene containing a primitive triangle with indexed geometry. It initializes various components like GLTF2, Scene, Mesh, Primitive, Node, Buffer, BufferView, and Accessor objects.

```python
from pygltflib import *

# create gltf objects for a scene with a primitive triangle with indexed geometry
gltf = GLTF2()
scene = Scene()
mesh = Mesh()
primitive = Primitive()
node = Node()
buffer = Buffer()
bufferView1 = BufferView()
bufferView2 = BufferView()
accessor1 = Accessor()
accessor2 = Accessor()

```

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

### Build, Save, and Reload a Mesh with pygltflib

Source: https://context7.com/dodgyville/pygltflib/llms.txt

An end-to-end example showing how to procedurally build a mesh with vertices and indices, save it as a GLB file, and then reload and inspect the vertex data.

```python
import numpy as np
import struct
from pygltflib import (
    GLTF2, Scene, Node, Mesh, Primitive, Attributes,
    Accessor, BufferView, Buffer, Asset,
    FLOAT, VEC3, UNSIGNED_BYTE, SCALAR,
    ARRAY_BUFFER, ELEMENT_ARRAY_BUFFER,
)

triangles = np.array([[0,1,2],[3,2,1]], dtype="uint8")
points = np.array([
    [-0.5, -0.5, 0.0],
    [ 0.5, -0.5, 0.0],
    [-0.5,  0.5, 0.0],
    [ 0.5,  0.5, 0.0],
], dtype="float32")

tri_bytes = triangles.flatten().tobytes()
pts_bytes = points.tobytes()

gltf = GLTF2(
    scene=0,
    scenes=[Scene(nodes=[0])],
    nodes=[Node(mesh=0)],
    meshes=[Mesh(primitives=[
        Primitive(attributes=Attributes(POSITION=1), indices=0)
    ])],
    accessors=[
        Accessor(bufferView=0, componentType=UNSIGNED_BYTE,
                 count=triangles.size, type=SCALAR,
                 max=[int(triangles.max())], min=[int(triangles.min())]),
        Accessor(bufferView=1, componentType=FLOAT,
                 count=len(points), type=VEC3,
                 max=points.max(axis=0).tolist(),
                 min=points.min(axis=0).tolist()),
    ],
    bufferViews=[
        BufferView(buffer=0, byteLength=len(tri_bytes), target=ELEMENT_ARRAY_BUFFER),
        BufferView(buffer=0, byteOffset=len(tri_bytes), byteLength=len(pts_bytes), target=ARRAY_BUFFER),
    ],
    buffers=[Buffer(byteLength=len(tri_bytes) + len(pts_bytes))],
)
gltf.set_binary_blob(tri_bytes + pts_bytes)

gltf.save("quad.glb")

loaded = GLTF2().load("quad.glb")
acc = loaded.accessors[1]
bv  = loaded.bufferViews[acc.bufferView]
data = loaded.get_data_from_buffer_uri(loaded.buffers[bv.buffer].uri)
for i in range(acc.count):
    off = bv.byteOffset + acc.byteOffset + i * 12
    x, y, z = struct.unpack("<fff", data[off:off+12])
    print(f"  vertex {i}: ({x:.2f}, {y:.2f}, {z:.2f})")
```

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

### Create an empty GLTF2 object

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Initialize an empty GLTF2 object. This is the starting point for creating a new GLTF file.

```python
from pygltflib import GLTF2

gltf = GLTF2()
```

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

### Add Custom Attribute to Attributes

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Shows how to add custom attributes to mesh primitives. Application-specific semantics must start with an underscore (e.g., `_MYCUSTOMATTRIBUTE`).

```python
# Application-specific semantics must start with an underscore, e.g., _TEMPERATURE.
a = Attributes()
a._MYCUSTOMATTRIBUTE = 123

gltf.meshes[0].primitives[0].attributes._MYOTHERATTRIBUTE = 456
```

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

### Create Mesh and Binary Blob

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Demonstrates creating a glTF mesh with associated buffer views, accessors, and a binary blob. This is useful for defining geometry and its associated data.

```python
gltf = pygltflib.Gltf2Base(
    accessors=[pygltflib.Accessor(
        bufferView=0, byteOffset=0, componentType=pygltflib.FLOAT, count=2, type=pygltflib.VEC3
    )],
    bufferViews=[pygltflib.BufferView(buffer=0, byteOffset=36, byteLength=96, target=pygltflib.ARRAY_BUFFER)],
    buffers=[pygltflib.Buffer(byteLength=132)],
)
gltf.set_binary_blob(
    b"\x00\x01\x02\x03\x02\x01\x01\x00\x04\x05\x04\x00\x03\x01\x06\x04\x06\x01"
    b"\x02\x03\x07\x06\x07\x03\x00\x02\x05\x07\x05\x02\x05\x07\x04\x06\x04\x07"
    b"\x00\x00\x00\xbf\x00\x00\x00\xbf\x00\x00\x00?\x00\x00\x00?\x00\x00\x00"
    b"\xbf\x00\x00\x00?\x00\x00\x00\xbf\x00\x00\x00?\x00\x00\x00?\x00\x00\x00?"
    b"\x00\x00\x00?\x00\x00\x00?\x00\x00\x00?\x00\x00\x00\xbf\x00\x00\x00\xbf"
    b"\x00\x00\x00\xbf\x00\x00\x00\xbf\x00\x00\x00\xbf\x00\x00\x00?\x00\x00"
    b"\x00?\x00\x00\x00\xbf\x00\x00\x00\xbf\x00\x00\x00?\x00\x00\x00\xbf"
)
```

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

### Create and Save a Simple glTF Model

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

This snippet demonstrates how to programmatically create a basic glTF structure with buffers, buffer views, accessors, primitives, nodes, and scenes, then save it to a file.

```python
buffer.uri = "data:application/octet-stream;base64,AAABAAIAAAAAAAAAAAAAAAAAAAAAAIA/AAAAAAAAAAAAAAAAAACAPwAAAAA="
buffer.byteLength = 44

bufferView1.buffer = 0
bufferView1.byteOffset = 0
bufferView1.byteLength = 6
bufferView1.target = ELEMENT_ARRAY_BUFFER

bufferView2.buffer = 0
bufferView2.byteOffset = 8
bufferView2.byteLength = 36
bufferView2.target = ARRAY_BUFFER

accessor1.bufferView = 0
accessor1.byteOffset = 0
accessor1.componentType = UNSIGNED_SHORT
accessor1.count = 3
accessor1.type = SCALAR
accessor1.max = [2]
accessor1.min = [0]

accessor2.bufferView = 1
accessor2.byteOffset = 0
accessor2.componentType = FLOAT
accessor2.count = 3
accessor2.type = VEC3
accessor2.max = [1.0, 1.0, 0.0]
accessor2.min = [0.0, 0.0, 0.0]

primitive.attributes.POSITION = 1
node.mesh = 0
scene.nodes = [0]

# assemble into a gltf structure
gltf.scenes.append(scene)
gltf.meshes.append(mesh)
gltf.meshes[0].primitives.append(primitive)
gltf.nodes.append(node)
gltf.buffers.append(buffer)
gltf.bufferViews.append(bufferView1)
gltf.bufferViews.append(bufferView2)
gltf.accessors.append(accessor1)
gltf.accessors.append(accessor2)

# save to file
gltf.save("triangle.gltf")
```

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

### Create Texture, Image, and Sampler Objects

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Defines texture, image, and sampler configurations for glTF assets. Images can reference URIs or buffer views.

```python
from pygltflib import (
    Texture, Image, Sampler,
    NEAREST, LINEAR, LINEAR_MIPMAP_LINEAR,
    REPEAT, CLAMP_TO_EDGE,
)

sampler = Sampler(
    magFilter=LINEAR,
    minFilter=LINEAR_MIPMAP_LINEAR,
    wrapS=REPEAT,
    wrapT=CLAMP_TO_EDGE,
)

image = Image(uri="textures/albedo.png", name="albedo")
texture = Texture(sampler=0, source=0, name="AlbedoTex")
```

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

### Initialize and Access Asset Metadata in pygltflib

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Demonstrates creating a GLTF2 object and accessing its default asset metadata, including the generator version. Shows how to override asset metadata when saving the file.

```python
from pygltflib import GLTF2, Asset

gltf = GLTF2()
print(gltf.asset.version)    # "2.0"
print(gltf.asset.generator)  # "pygltflib@v1.16.5"

# Override metadata on save
gltf.save("output.gltf", asset=Asset(copyright="My Studio", version="2.0"))
```

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

### Clone glTF Sample Models

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Clone the official glTF sample models repository to use for testing.

```bash
git clone https://github.com/KhronosGroup/glTF-Sample-Models
```

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

### Import Libraries

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Import necessary libraries for numerical operations and glTF manipulation.

```python
import numpy as np
import pygltflib
```

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

### glb2gltf(source, destination=None, override=False)

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Convert a binary GLB file to a JSON glTF file, creating a companion .bin file for external data.

```APIDOC
## `glb2gltf(source, destination=None, override=False)` — Convert GLB to glTF

Converts a binary `.glb` file to a JSON `.gltf` file (with companion `.bin`).

### Usage

```python
from pygltflib.utils import glb2gltf

# Convert Box.glb → Box.gltf + Box.bin
glb2gltf("models/Box/Box.glb")

# Specify output path
glb2gltf("models/Box/Box.glb", destination="output/Box.gltf", override=True)
```
```

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

### Build Scene Graph with pygltflib

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Constructs a basic scene graph including a Scene, Node, Mesh, and Primitive. Demonstrates setting attributes, indices, mode, and material for a primitive, and adding custom attributes.

```python
from pygltflib import GLTF2, Scene, Node, Mesh, Primitive, Attributes, TRIANGLES

gltf = GLTF2()

# Build scene graph
scene = Scene(name="MainScene", nodes=[0])
node  = Node(name="MyMesh", mesh=0)
mesh  = Mesh(name="Box")
prim  = Primitive(
    attributes=Attributes(POSITION=1, NORMAL=2, TEXCOORD_0=3),
    indices=0,
    mode=TRIANGLES,
    material=0,
)
mesh.primitives.append(prim)

# Custom vertex attribute
prim.attributes._TEMPERATURE = 4  # application-specific must start with _

gltf.scenes.append(scene)
gltf.nodes.append(node)
gltf.meshes.append(mesh)
gltf.scene = 0
```

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

### Load a binary GLB file

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Load a GLB (binary GLTF) file. The load method automatically detects the binary format based on the file extension.

```python
glb_filename = "glTF-Sample-Models/2.0/Box/glTF-Binary/Box.glb"
glb = GLTF2().load(glb_filename)
```

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

### Define BufferView and Accessor for pygltflib

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Shows how to define BufferView objects for index and vertex data, specifying buffer, byte offset, byte length, and target. Also demonstrates creating Accessor objects to describe typed interpretations of buffer views.

```python
from pygltflib import (
    Buffer, BufferView, Accessor,
    FLOAT, VEC3, UNSIGNED_SHORT, SCALAR,
    ARRAY_BUFFER, ELEMENT_ARRAY_BUFFER,
)

# Index buffer view
bv_indices = BufferView(
    buffer=0, byteOffset=0, byteLength=6,
    target=ELEMENT_ARRAY_BUFFER,
)

# Vertex buffer view
bv_vertices = BufferView(
    buffer=0, byteOffset=8, byteLength=36,
    target=ARRAY_BUFFER,
)

# Accessor for indices (3 unsigned shorts)
acc_idx = Accessor(
    bufferView=0, byteOffset=0,
    componentType=UNSIGNED_SHORT,
    count=3, type=SCALAR,
    max=[2], min=[0],
)

# Accessor for positions (3 vec3 floats)
acc_pos = Accessor(
    bufferView=1, byteOffset=0,
    componentType=FLOAT,
    count=3, type=VEC3,
    max=[1.0, 1.0, 0.0], min=[0.0, 0.0, 0.0],
)
```

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

### Run pygltflib Unit Tests

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Execute the unit tests for pygltflib using pytest. Ensure the glTF Sample Models are cloned in the same directory.

```bash
pytest test_pygltflib.py
```

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

### Convert GLB to GLTF using utils

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Utilize the `glb2gltf` utility function for converting GLB files to GLTF format. This is a convenient alternative to manual loading and saving.

```python
from pygltflib.utils import glb2gltf

# convert glb to gltf
glb2gltf("glTF-Sample-Models/2.0/Box/glTF-Binary/Box.glb")
```

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

### Load a binary file with an unusual extension

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Use the load_binary helper method to load binary GLTF files that may have non-standard extensions. This bypasses automatic extension detection.

```python
glb = GLTF2().load_binary("BinaryGLTF.glk")
```

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

### Load glTF/GLB Files with GLTF2

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Loads glTF or GLB files by automatically detecting the format from the file extension. Returns a populated GLTF2 object.

```python
from pygltflib import GLTF2

# Load JSON glTF
gltf = GLTF2().load("models/AnimatedCube.gltf")
print(gltf.scene)           # 0
print(gltf.scenes[0].nodes) # [0]
print(gltf.nodes[0].name)   # 'AnimatedCube'

# Load binary GLB
glb = GLTF2().load("models/Box.glb")
print(glb.meshes[0].primitives[0].attributes)
# Attributes(POSITION=2, NORMAL=1, ...)
```

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

### Load and inspect a GLB file

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Load a GLB (binary glTF) file and access its scene, nodes, meshes, and attributes. GLB files embed binary data directly.

```python
from pygltflib import GLTF2
glb_filename = "glTF-Sample-Models/2.0/Box/glTF-Binary/Box.glb"
glb = GLTF2().load(glb_filename)
print(glb.scene)
print(glb.scenes)
print(glb.nodes[0])
print(glb.meshes[0].primitives[0].attributes)
```

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

### Convert GLTF to GLB using utils

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Use the `gltf2glb` utility function to convert GLTF files to GLB format. The `override` parameter allows overwriting existing files.

```python
from pygltflib.utils import gltf2glb

# convert gltf to glb
gltf2glb("glTF-Sample-Models/2.0/Box/glTF/Box.gltf", "test.glb", override=True)
```

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

### Load and inspect a GLTF file

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Load a GLTF file and access its scene, nodes, meshes, and attributes. Ensure the file path is correct.

```python
from pygltflib import GLTF2
filename = "glTF-Sample-Models/2.0/AnimatedCube/glTF/AnimatedCube.gltf"
gltf = GLTF2().load(filename)
print(gltf.scene)
print(gltf.scenes)
print(gltf.nodes[0])
print(gltf.nodes[0].name)
print(gltf.meshes[0].primitives[0].attributes)
```

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

### GLTF2.load(fname)

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Loads a glTF file, automatically detecting whether it is a JSON (.gltf) or binary (.glb) format based on the file extension. It returns a fully populated GLTF2 object.

```APIDOC
## GLTF2.load(fname) — Load any glTF file

Auto-detects `.gltf` (JSON) vs `.glb` / `.bin` (binary) by file extension. Returns a fully populated `GLTF2` object.

### Request Example
```python
from pygltflib import GLTF2

# Load JSON glTF
gltf = GLTF2().load("models/AnimatedCube.gltf")
print(gltf.scene)           # 0
print(gltf.scenes[0].nodes) # [0]
print(gltf.nodes[0].name)   # 'AnimatedCube'

# Load binary GLB
glb = GLTF2().load("models/Box.glb")
print(glb.meshes[0].primitives[0].attributes)
# Attributes(POSITION=2, NORMAL=1, ...)
```
```

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

### Load a GLTF file

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Load a GLTF file from the specified path. The load method automatically detects the file type.

```python
filename = "glTF-Sample-Models/2.0/AnimatedCube/glTF/AnimatedCube.gltf"
gltf = GLTF2().load(filename)
```

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

### GLTF2.load_json(fname) / GLTF2.load_binary(fname)

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Explicitly loads a glTF file in either JSON or binary format, without relying on file extension detection. This is useful for handling files with non-standard extensions or when specific format loading is required.

```APIDOC
## GLTF2.load_json(fname) / GLTF2.load_binary(fname) — Explicit format loading

Load a specific format without relying on extension detection.

### Request Example
```python
from pygltflib import GLTF2

# Force JSON load (useful for .gltf files with unexpected extensions)
gltf = GLTF2.load_json("model.gltf")

# Force binary load
glb = GLTF2.load_binary("model.glb")

# Load binary from a file-object (e.g. BytesIO from network)
from io import BytesIO
with open("model.glb", "rb") as f:
    glb2 = GLTF2.load_binary_from_file_object(f)

print(glb2.asset.version)  # "2.0"
```
```

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

### Access glTF Extensions

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Demonstrates how to access extension data attached to primitives and materials. Extension names are typically defined by registered KHR or custom schemas.

```python
# on a primitve
gltf.meshes[0].primitives[0].extensions['KHR_draco_mesh_compression']

# on a material
gltf.materials[0].extensions['ADOBE_materials_thin_transparency']
```

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

### Create Perspective and Orthographic Cameras

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Defines camera projections for glTF scenes. Supports perspective and orthographic views with various parameters.

```python
from pygltflib import Camera, Perspective, Orthographic, PERSPECTIVE, ORTHOGRAPHIC
import math

# Perspective camera
cam_perspective = Camera(
    type=PERSPECTIVE,
    name="MainCam",
    perspective=Perspective(
        yfov=math.radians(60),
        aspectRatio=16/9,
        znear=0.01,
        zfar=1000.0,
    ),
)

# Orthographic camera
cam_ortho = Camera(
    type=ORTHOGRAPHIC,
    orthographic=Orthographic(
        xmag=5.0, ymag=5.0,
        znear=0.01, zfar=100.0,
    ),
)
```

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

### Convert GLB to glTF

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Converts a binary .glb file to a JSON .gltf file with a companion .bin file. Specify the destination path and whether to override existing files.

```python
from pygltflib.utils import glb2gltf

# Convert Box.glb → Box.gltf + Box.bin
glb2gltf("models/Box/Box.glb")

# Specify output path
glb2gltf("models/Box/Box.glb", destination="output/Box.gltf", override=True)
```

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

### gltf2glb(source, destination=None, override=False)

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Convert a JSON glTF file to a binary GLB file, embedding external data into the .bin.

```APIDOC
## `gltf2glb(source, destination=None, override=False)` — Convert glTF to GLB

Converts a JSON `.gltf` file to a binary `.glb` file.

### Usage

```python
from pygltflib.utils import gltf2glb

# Convert Box.gltf → Box.glb
gltf2glb("models/Box/Box.gltf")

# Specify output path with override
gltf2glb("models/Box/Box.gltf", destination="output/Box.glb", override=True)
```
```

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

### GLTF2.convert_buffers(buffer_format, override=False)

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Converts all buffers between binary blob (for GLB), data URI (embedded base64 in JSON), or external .bin file storage formats.

```APIDOC
## GLTF2.convert_buffers(buffer_format, override=False)

### Description
Converts all buffers between three storage strategies: binary blob (for GLB), data URI (embedded base64 in JSON), or external `.bin` file.

### Method
`convert_buffers(buffer_format, override=False)`

### Parameters
- **buffer_format** (BufferFormat): The target storage format (e.g., `BufferFormat.DATAURI`, `BufferFormat.BINARYBLOB`, `BufferFormat.BINFILE`).
- **override** (bool, optional): Whether to override existing files if `BufferFormat.BINFILE` is used. Defaults to `False`.

### Request Example
```python
from pygltflib import GLTF2, BufferFormat

gltf = GLTF2().load("models/Box/Box.gltf")

# Convert external .bin file buffers to embedded data URIs
gltf.convert_buffers(BufferFormat.DATAURI)
gltf.save("box_embedded.gltf")  # single self-contained JSON file

# Convert back to binary blob for GLB export
gltf.convert_buffers(BufferFormat.BINARYBLOB)
gltf.save("box.glb")

# Convert a GLB's blob back out to external .bin files
glb = GLTF2().load("models/Box.glb")
glb.convert_buffers(BufferFormat.BINFILE)
glb.save("box_external.gltf")   # writes 0.bin alongside
```

### Response
This method modifies the GLTF object in place and does not return a value.
```

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

### Create image file from GLTF Data URI

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Create an image file from a Data URI embedded in a GLTF image object. An optional name can be provided for the output file.

```python
from pathlib import Path
from pygltflib.utils import ImageFormat, Image

gltf = GLTF2()
image = Image()
image.uri = "data:image/png;base64,iVBORw0KGg..."
image.name = "myfile.png"  # optional file name, if not provided, the image files will be called "0.png", "1.png"

gltf.convert_images(ImageFormat.FILE)  # image file will be imported into the GLTF
# gltf.images[0].uri will be myfile.png

assert Path("myfile.png").exists() is True
```

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

### Import pygltflib Constants and Enums

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Imports various integer constants for component types, accessor types, primitive modes, buffer view targets, material alpha modes, animation interpolation, texture wrapping, and texture filtering. Also imports BufferFormat and ImageFormat enums.

```python
from pygltflib import (
    BYTE,           # 5120
    UNSIGNED_BYTE,  # 5121
    SHORT,          # 5122
    UNSIGNED_SHORT, # 5123
    UNSIGNED_INT,   # 5125
    FLOAT,          # 5126
    SCALAR, VEC2, VEC3, VEC4, MAT2, MAT3, MAT4,  # accessor type strings
    TRIANGLES,      # 4  — mesh primitive mode
    ARRAY_BUFFER,         # 34962 — bufferView target for vertex data
    ELEMENT_ARRAY_BUFFER, # 34963 — bufferView target for index data
    BLEND, MASK, OPAQUE,  # material alpha modes
    ANIM_LINEAR, ANIM_STEP, ANIM_CUBICSPLINE,  # animation interpolation
    REPEAT, CLAMP_TO_EDGE, MIRRORED_REPEAT,    # texture wrapping
    NEAREST, LINEAR,  # texture filtering
)

# BufferFormat and ImageFormat enums control convert_buffers / convert_images
from pygltflib import BufferFormat, ImageFormat

print(BufferFormat.DATAURI)    # BufferFormat.DATAURI
print(BufferFormat.BINARYBLOB) # BufferFormat.BINARYBLOB
print(BufferFormat.BINFILE)    # BufferFormat.BINFILE

print(ImageFormat.DATAURI)     # ImageFormat.DATAURI
print(ImageFormat.FILE)        # ImageFormat.FILE
print(ImageFormat.BUFFERVIEW)  # ImageFormat.BUFFERVIEW
```

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

### Convert GLB to glTF

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Converts a binary glTF (GLB) file into a standard glTF file with separate binary buffers. Requires the `glb2gltf` utility function.

```python
from pygltflib.utils import glb2gltf, gltf2glb

# convert glb to gltf
glb2gltf("glTF-Sample-Models/2.0/Box/glTF-Binary/Box.glb")
```

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

### Convert Buffer Storage Format with GLTF2.convert_buffers()

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Change buffer storage between binary blob (for GLB), data URI (embedded base64), or external .bin file. This is essential for preparing models for different export formats.

```python
from pygltflib import GLTF2, BufferFormat

gltf = GLTF2().load("models/Box/Box.gltf")

# Convert external .bin file buffers to embedded data URIs
gltf.convert_buffers(BufferFormat.DATAURI)
gltf.save("box_embedded.gltf")  # single self-contained JSON file

# Convert back to binary blob for GLB export
gltf.convert_buffers(BufferFormat.BINARYBLOB)
gltf.save("box.glb")

# Convert a GLB's blob back out to external .bin files
glb = GLTF2().load("models/Box.glb")
glb.convert_buffers(BufferFormat.BINFILE)
glb.save("box_external.gltf")   # writes 0.bin alongside
```

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

### Import PNG as Texture

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Imports a PNG image file and adds it as a texture to the glTF object. The image is then converted to a data URI for embedding.

```python
from pygltflib import GLTF2
from pygltflib.utils import ImageFormat, Image
gltf = GLTF2()
image = Image()
image.uri = "myfile.png"
gltf.images.append(image)
gltf.convert_images(ImageFormat.DATAURI)
gltf.images[0].uri  # will now be something like "data:image/png;base64,iVBORw0KGg..."
gltf.images[0].name  # will be myfile.png
```

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

### Specify Path for Image Conversion

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Allows specifying a custom directory for saving converted image files. Use the `path` argument in `convert_images` to set the destination folder.

```python
from pygltflib import GLTF2
from pygltflib.utils import ImageFormat
filename = "glTF-Sample-Models/2.0/AnimatedCube/glTF/AnimatedCube.gltf"
gltf = GLTF2().load(filename)
gltf.images[0].name = "cube.png"  # will save the data uri to this file (regardless of data format)
gltf.convert_images(ImageFormat.FILE, path='/destination/') 
gltf.images[0].uri  # will now be cube.png and the texture image will be saved in /destination/cube.png
```

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

### Explicitly Load JSON or Binary glTF Files

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Loads glTF files by explicitly specifying the format (JSON or binary), useful for files with non-standard extensions.

```python
from pygltflib import GLTF2

# Force JSON load (useful for .gltf files with unexpected extensions)
gltf = GLTF2.load_json("model.gltf")

# Force binary load
glb = GLTF2.load_binary("model.glb")

# Load binary from a file-object (e.g. BytesIO from network)
from io import BytesIO
with open("model.glb", "rb") as f:
    glb2 = GLTF2.load_binary_from_file_object(f)

print(glb2.asset.version)  # "2.0"
```

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

### GLTF2.save(fname)

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Saves the current GLTF2 object to a file. If the filename has a `.glb` extension, it saves in binary format. Otherwise, it saves as a JSON `.gltf` file, creating a companion `.bin` file if necessary for binary data.

```APIDOC
## GLTF2.save(fname) — Save as glTF or GLB

Saves as `.glb` (binary) if the extension is `.glb`; otherwise saves as JSON `.gltf` (with a companion `.bin` file if a binary blob is present).

### Request Example
```python
from pygltflib import GLTF2, Asset

gltf = GLTF2().load("input.gltf")

# Save as JSON glTF
gltf.save("output.gltf")
```
```

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

### Read Vertex Data and Calculate Bounding Sphere

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

This snippet shows how to load a glTF file, extract vertex data from a mesh primitive's position accessor, and use a third-party library to compute the bounding sphere of the vertices.

```python
import pathlib
import struct

import miniball
import numpy
from pygltflib import GLTF2

# load an example gltf file from the khronos collection
fname = pathlib.Path("glTF-Sample-Models/2.0/Box/glTF-Embedded/Box.gltf")
gltf = GLTF2().load(fname)

# get the first mesh in the current scene (in this example there is only one scene and one mesh)
mesh = gltf.meshes[gltf.scenes[gltf.scene].nodes[0]]

# get the vertices for each primitive in the mesh (in this example there is only one)
for primitive in mesh.primitives:

    # get the binary data for this mesh primitive from the buffer
    accessor = gltf.accessors[primitive.attributes.POSITION]
    bufferView = gltf.bufferViews[accessor.bufferView]
    buffer = gltf.buffers[bufferView.buffer]
    data = gltf.get_data_from_buffer_uri(buffer.uri)

    # pull each vertex from the binary buffer and convert it into a tuple of python floats
    vertices = []
    for i in range(accessor.count):
        index = bufferView.byteOffset + accessor.byteOffset + i*12  # the location in the buffer of this vertex
        d = data[index:index+12]  # the vertex data
        v = struct.unpack("<fff", d)   # convert from base64 to three floats
        vertices.append(v)
        print(i, v)

# convert a numpy array for some manipulation
S = numpy.array(vertices)

# use a third party library to perform Ritter's algorithm for finding smallest bounding sphere
C, radius_squared = miniball.get_bounding_ball(S)

# output the results
print(f"center of bounding sphere: {C}\nradius squared of bounding sphere: {radius_squared}")
```

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

### Convert Buffers to External Binary Files

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Converts buffers to separate external binary files (e.g., .bin). The glTF file will reference these external files. Ensure to save the glTF object after conversion.

```python
gltf.convert_buffers(BufferFormat.BINFILE)   # convert buffers to files
gltf.save("test.gltf")  # all the buffers are saved in 0.bin, 1.bin, 2.bin.
```

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

### Convert Image Storage Format with GLTF2.convert_images()

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Modify image storage between external files, embedded data URIs, or buffer views. Use `override=True` to overwrite existing files when converting to `ImageFormat.FILE`.

```python
from pygltflib import GLTF2
from pygltflib import ImageFormat

gltf = GLTF2().load("models/AnimatedCube/AnimatedCube.gltf")

# Embed all external PNG/JPEG images as base64 data URIs
gltf.convert_images(ImageFormat.DATAURI)
print(gltf.images[0].uri[:40])  # "data:image/png;base64,iVBORw0KGg..."

# Extract embedded data URIs back to PNG files in a specific directory
gltf.convert_images(ImageFormat.FILE, path="/output/textures/", override=True)
print(gltf.images[0].uri)       # "0.png"

# Use a custom name before extracting
gltf.images[0].name = "albedo.png"
gltf.convert_images(ImageFormat.FILE)
print(gltf.images[0].uri)       # "albedo.png"
```

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

### Save a GLB file

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Save the loaded GLB object to a new file. This operation preserves the binary format.

```python
glb.save("test.glb")
```

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

### GLTF2.binary_blob() / GLTF2.set_binary_blob(blob) / GLTF2.destroy_binary_blob()

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Manage the raw binary blob associated with a GLB file. Allows reading, replacing, or removing the binary data.

```APIDOC
## `GLTF2.binary_blob()` / `GLTF2.set_binary_blob(blob)` / `GLTF2.destroy_binary_blob()` — GLB binary data management

Access, replace, or remove the raw binary blob associated with a loaded or constructed GLB file.

### Usage

```python
from pygltflib import GLTF2
import numpy as np

glb = GLTF2().load("model.glb")

# Read the binary blob
blob = glb.binary_blob()
print(f"Binary blob size: {len(blob)} bytes")

# Replace the binary blob with modified data
modified = bytearray(blob)
# ... modify bytes ...
glb.set_binary_blob(bytes(modified))

# Build a GLTF2 from scratch with a binary blob
triangles = np.array([[0, 1, 2]], dtype="uint8").tobytes()
points = np.array([[0,0,0],[1,0,0],[0,1,0]], dtype="float32").tobytes()
gltf = GLTF2()
gltf.set_binary_blob(triangles + points)
print(len(gltf.binary_blob()))  # 48

# Free memory
gltf.destroy_binary_blob()
print(gltf.binary_blob())  # None
```
```

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

### GLTF2.convert_images(image_format, path=None, override=False)

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Converts all images between external files, embedded base64 data URIs, and buffer views.

```APIDOC
## GLTF2.convert_images(image_format, path=None, override=False)

### Description
Converts all images between external files (`ImageFormat.FILE`), embedded base64 data URIs (`ImageFormat.DATAURI`), and buffer views (`ImageFormat.BUFFERVIEW`).

### Method
`convert_images(image_format, path=None, override=False)`

### Parameters
- **image_format** (ImageFormat): The target image storage format (e.g., `ImageFormat.FILE`, `ImageFormat.DATAURI`, `ImageFormat.BUFFERVIEW`).
- **path** (str, optional): The directory path to save external image files when using `ImageFormat.FILE`. Defaults to `None`.
- **override** (bool, optional): Whether to override existing image files when using `ImageFormat.FILE`. Defaults to `False`.

### Request Example
```python
from pygltflib import GLTF2
from pygltflib import ImageFormat

gltf = GLTF2().load("models/AnimatedCube/AnimatedCube.gltf")

# Embed all external PNG/JPEG images as base64 data URIs
gltf.convert_images(ImageFormat.DATAURI)
print(gltf.images[0].uri[:40])  # "data:image/png;base64,iVBORw0KGg..."

# Extract embedded data URIs back to PNG files in a specific directory
gltf.convert_images(ImageFormat.FILE, path="/output/textures/", override=True)
print(gltf.images[0].uri)       # "0.png"

# Use a custom name before extracting
gltf.images[0].name = "albedo.png"
gltf.convert_images(ImageFormat.FILE)
print(gltf.images[0].uri)       # "albedo.png"
```

### Response
This method modifies the GLTF object in place and does not return a value.
```

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

### GLTF2.to_json() / GLTF2.from_json(s) / GLTF2.gltf_to_json()

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Serialize and deserialize GLTF2 objects to and from JSON strings. Offers control over formatting and compactness.

```APIDOC
## `GLTF2.to_json()` / `GLTF2.from_json(s)` / `GLTF2.gltf_to_json()` — JSON serialization

Serialize and deserialize a `GLTF2` object to/from a JSON string. `to_json` provides full control; `gltf_to_json` uses glTF-appropriate defaults (no NaN, sorted keys optional, compact separators).

### Usage

```python
from pygltflib import GLTF2, Scene, Node, Mesh

gltf = GLTF2()
gltf.scenes.append(Scene(name="Scene", nodes=[0]))
gltf.nodes.append(Node(name="Root"))
gltf.scene = 0

# Serialize to JSON string
json_str = gltf.to_json(indent=2)
print(json_str[:200])

# Compact form for GLB embedding
compact = gltf.gltf_to_json(separators=(',', ':'), indent=None)

# Deserialize back from string
gltf2 = GLTF2.from_json(json_str)
print(gltf2.scenes[0].name)  # "Scene"
```
```

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

### Create PBR Metallic-Roughness Material

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Defines PBR material properties including base color, metallic, roughness, and textures. Supports opaque, masked, and blended alpha modes.

```python
from pygltflib import (
    Material, PbrMetallicRoughness, TextureInfo,
    NormalMaterialTexture, OcclusionTextureInfo,
    OPAQUE, MASK, BLEND,
)

mat = Material(
    name="MetalPlate",
    alphaMode=OPAQUE,
    doubleSided=False,
    pbrMetallicRoughness=PbrMetallicRoughness(
        baseColorFactor=[0.8, 0.8, 0.8, 1.0],
        metallicFactor=0.9,
        roughnessFactor=0.2,
        baseColorTexture=TextureInfo(index=0, texCoord=0),
    ),
    normalTexture=NormalMaterialTexture(index=1, scale=1.0),
    occlusionTexture=OcclusionTextureInfo(index=2, strength=1.0),
    emissiveFactor=[0.0, 0.0, 0.0],
)

# Alpha cutout material
cutout_mat = Material(
    alphaMode=MASK, alphaCutoff=0.5,
    pbrMetallicRoughness=PbrMetallicRoughness(
        baseColorTexture=TextureInfo(index=0),
    ),
)
```

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

### Convert glTF to GLB

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Converts a JSON .gltf file to a binary .glb file. You can specify the destination path and whether to override existing files.

```python
from pygltflib.utils import gltf2glb

# Convert Box.gltf → Box.glb
gltf2glb("models/Box/Box.gltf")

# Specify output path with override
gltf2glb("models/Box/Box.gltf", destination="output/Box.glb", override=True)
```

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

### Save GLTF to GLB or GLTF with Metadata

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Use the `save` method to export the GLTF object. You can save to a binary GLB file or a GLTF file with custom asset metadata.

```python
gltf.save("output.glb")
```

```python
gltf.save("output.gltf", asset=Asset(
    copyright="2024 My Studio",
    generator="MyPipeline/1.0",
    version="2.0",
))
```

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

### Clone pygltflib Repository

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Clone the pygltflib source code from its GitLab repository to access the project files directly.

```bash
git clone https://gitlab.com/dodgyville/pygltflib
```

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

### Serialize GLB to Byte Array with GLTF2.save_to_bytes()

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Convert GLTF buffers to BINARYBLOB format and then serialize the GLB to a byte array. This is useful for streaming or in-memory operations.

```python
from pygltflib import GLTF2
import numpy as np

gltf = GLTF2().load("model.gltf")
gltf.convert_buffers(from pygltflib import BufferFormat; BufferFormat.BINARYBLOB)

# Save to bytes and write manually
chunks = gltf.save_to_bytes()
glb_bytes = b"".join(chunks)

# Write to a BytesIO for in-memory use
from io import BytesIO
buf = BytesIO(glb_bytes)
print(f"GLB size: {len(glb_bytes)} bytes")

# Reload from the bytes to verify
from pygltflib import GLTF2
reloaded = GLTF2.load_from_bytes(glb_bytes)
print(len(reloaded.meshes))
```

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

### Print Validation Summary of a glTF Model

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Uses the `summary` function to run validation in warning mode and print a human-readable summary of all errors to standard output.

```python
from pygltflib import GLTF2
from pygltflib.validator import summary

gltf = GLTF2().load("models/AnimatedCube.gltf")

summary(gltf)
```

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

### Define glTF Skinning Data

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Configures skeletal skinning for glTF models, including inverse bind matrices, skeleton root, and joint indices.

```python
from pygltflib import Skin

skin = Skin(
    name="Armature",
    inverseBindMatrices=5,  # accessor index
    skeleton=0,             # root node index
    joints=[1, 2, 3, 4],
)
```

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

### Save glTF as JSON or GLB

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Saves a GLTF2 object to a file. Saves as GLB if the filename extension is '.glb', otherwise saves as JSON with a companion '.bin' file if binary data is present.

```python
from pygltflib import GLTF2, Asset

gltf = GLTF2().load("input.gltf")

# Save as JSON glTF
gltf.save("output.gltf")
```

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

### Serialize GLTF2 to JSON

Source: https://context7.com/dodgyville/pygltflib/llms.txt

Serialize and deserialize a GLTF2 object to and from a JSON string. Use `to_json` for full control and `gltf_to_json` for glTF-appropriate defaults.

```python
from pygltflib import GLTF2, Scene, Node, Mesh

gltf = GLTF2()
gltf.scenes.append(Scene(name="Scene", nodes=[0]))
gltf.nodes.append(Node(name="Root"))
gltf.scene = 0

# Serialize to JSON string
json_str = gltf.to_json(indent=2)
print(json_str[:200])

# Compact form for GLB embedding
compact = gltf.gltf_to_json(separators=(',', ':'), indent=None)

# Deserialize back from string
gltf2 = GLTF2.from_json(json_str)
print(gltf2.scenes[0].name)  # "Scene"
```

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

### Serialize GLTF2 Object to Bytes (GLB)

Source: https://gitlab.com/dodgyville/pygltflib/-/blob/master/README.md

Convert the GLTF2 object into a byte array representing the GLB (glTF Binary) file format. This is useful for saving or transmitting the asset.

```python
glb = b"".join(gltf.save_to_bytes())
```