scripts/glb_probe.py

#!/usr/bin/env python3
"""Extract structural metadata from a .glb by parsing only its JSON chunk.

GLB layout: 12-byte header ('glTF', version, length) then chunks
(uint32 length, uint32 type, data). Chunk 0 is JSON, so we never touch the
binary payload — probing 23 GB of assets costs only a few hundred MB of reads.
"""
import json, os, struct, sys

def read_gltf_json(path, max_json=64 << 20):
    with open(path, "rb") as f:
        head = f.read(12)
        if len(head) < 12 or head[:4] != b"glTF":
            raise ValueError("not a GLB")
        ver, total = struct.unpack("<II", head[4:12])
        ch = f.read(8)
        if len(ch) < 8:
            raise ValueError("truncated")
        clen, ctype = struct.unpack("<II", ch)
        if ctype != 0x4E4F534A:            # 'JSON'
            raise ValueError("first chunk not JSON")
        if clen > max_json:
            raise ValueError("json chunk too large: %d" % clen)
        raw = f.read(clen)
        if len(raw) < clen:
            raise ValueError("truncated json chunk")
    return ver, json.loads(raw.decode("utf-8", "replace"))


def probe(path):
    ver, g = read_gltf_json(path)
    nodes = g.get("nodes", []) or []
    skins = g.get("skins", []) or []
    anims = g.get("animations", []) or []
    accs  = g.get("accessors", []) or []
    meshes= g.get("meshes", []) or []

    # parent map from node children
    parent = {}
    for i, n in enumerate(nodes):
        for c in (n.get("children") or []):
            parent[c] = i

    joints = set()
    per_skin = []
    for s in skins:
        js = s.get("joints") or []
        per_skin.append(len(js))
        joints.update(js)

    # kinematic-tree roots among joints: a joint whose parent is not a joint
    roots = [j for j in joints if parent.get(j) not in joints]

    # animation stats: max time from each sampler's input accessor max
    dur = 0.0
    channels = 0
    keyframes = 0
    anim_names = []
    for a in anims:
        anim_names.append(a.get("name") or "")
        channels += len(a.get("channels") or [])
        for smp in (a.get("samplers") or []):
            ai = smp.get("input")
            if ai is None or ai >= len(accs):
                continue
            acc = accs[ai]
            keyframes = max(keyframes, acc.get("count", 0) or 0)
            mx = acc.get("max")
            if isinstance(mx, list) and mx:
                try: dur = max(dur, float(mx[0]))
                except (TypeError, ValueError): pass

    # does any animation actually drive a joint?
    animated_nodes = set()
    for a in anims:
        for c in (a.get("channels") or []):
            t = (c.get("target") or {}).get("node")
            if t is not None: animated_nodes.add(t)
    animated_joints = len(animated_nodes & joints)

    verts = 0
    for m in meshes:
        for p in (m.get("primitives") or []):
            ai = (p.get("attributes") or {}).get("POSITION")
            if ai is not None and ai < len(accs):
                verts += accs[ai].get("count", 0) or 0

    gen = (g.get("asset") or {}).get("generator", "")
    return {
        "gltf_version": ver,
        "generator": gen[:80],
        "num_nodes": len(nodes),
        "num_meshes": len(meshes),
        "num_vertices": verts,
        "num_skins": len(skins),
        "num_joints": len(joints),
        "max_skin_joints": max(per_skin) if per_skin else 0,
        "num_skeleton_roots": len(roots),
        "num_animations": len(anims),
        "num_anim_channels": channels,
        "animated_joints": animated_joints,
        "max_keyframes": keyframes,
        "duration_sec": round(dur, 4),
        "anim_names": "|".join(n for n in anim_names if n)[:200],
    }

if __name__ == "__main__":
    for p in sys.argv[1:]:
        try: print(os.path.basename(p), json.dumps(probe(p)))
        except Exception as e: print(os.path.basename(p), "ERROR", e)