update

3D/animations/540-hook/540-hook.glb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:59a281d94cb60a061e23f39d1108fe78f4a25f60d9b15e5700b271a19279d264
+size 2427592

3D/animations/540-hyper-round/540-hyper-round.glb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9c3e315887218ef506077a2c79729c4eafd5629752fd795068d59a10f2cacde1
-size 974712
+oid sha256:1bbcc4726bde32860565f2546d0319ca99dfa8a8724f61f08b56b5a3fd48ce8a
+size 2067292

3D/animations/hook-kick/hook-kick.glb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:70a571efa0b12ae4a3593f7d8e0d866ae6c439e6de239549cfc045ab758fc860
-size 468180
+oid sha256:960001f0fef339d34d47fbbf3cf0a85fe88ebd0bed3122c1a2b7a2ca30694fa8
+size 1175532

3D/animations/roundhouse-kick/roundhouse-kick.glb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:95a774c32018253659e5b3df4f7e34111fe68c927df7f63139472efb78c2fcca
-size 416920
+oid sha256:cd2791c6d49a32d0bcc7d67ca0cd20ebdcabde10ab9c5c2a05fb7edbfd3abeb4
+size 1124240

3D/animations/side-kick/side-kick.glb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e9d8ed045c36756c7d27bddb4dd13e224c7805eefd3d16817f08f4824cf64039
-size 550424
+oid sha256:044a470e8afd4aafb9796b7184400f1fe2497f91559b801823c5389367fbec94
+size 1257728

3D/animations/sketchfab_animation.py

@@ -7,14 +7,24 @@ Usage:
 Requires Python 3.9+ and a local Chrome/Chromium/Edge installation; no pip
 packages. Chrome runs in a temporary profile and never uses your open tabs.
 The default output is ./model-name/{model-name.bvh,model-name.glb}.
-Both files contain the animated skeleton, not the character mesh. BVH uses
-source units; GLB defaults to a 0.01 scale (centimeters to meters). Use --scale
+GLB includes available geometry, PBR materials/textures and skinning. BVH
+contains only the animated skeleton. BVH uses source units; GLB defaults
+to a 0.01 scale (centimeters to meters). Use --scale
 for models with different units. BVH is resampled near 30 fps while preserving
 the duration; GLB keeps original keyframe times except duplicate timestamps.
 
 This implements the viewer's current skeletal-animation layout. Unsupported
 layouts fail explicitly. It does not fetch original FBX files. Live viewer
 changes may require updating the decoder integration.
+
+Materials use glTF's metallic/roughness workflow. Base color/opacity, normal,
+occlusion, emissive and metallic/roughness maps are embedded in the GLB.
+Viewer-only effects and unsupported material channels remain in GLB extras;
+unsupported active surface channels produce warnings. Morph targets and
+non-bone animation tracks are not supported. Use --skeleton-only to omit meshes.
+
+In Blender, enable "Disable Bone Shape" when importing to avoid its generated
+glTF_not_exported collection and Icosphere bone-display helper.
 """
 import argparse
 import base64
@@ -38,7 +48,7 @@ import sys
 import tempfile
 import threading
 import time
-from urllib.parse import urlparse
+from urllib.parse import urlparse, urljoin
 from urllib.request import Request, urlopen
 
 
@@ -119,13 +129,16 @@ def find_chrome(explicit):
     raise ExportError("Install Chrome/Chromium locally or pass --chrome PATH. In WSL, use a Linux browser; alternatively run this script with Windows Python.")
 
 
-def decode_scene(payload, protection, scripts, directory, browser, no_sandbox):
-    try:
-        value = json.loads(payload)
-        if isinstance(value, dict):
-            return value
-    except (ValueError, UnicodeError):
-        pass
+def decode_scene(payload, protection, scripts, directory, browser, no_sandbox, binary=False):
+    if not binary:
+        try:
+            value = json.loads(payload)
+            if isinstance(value, dict):
+                return value
+        except (ValueError, UnicodeError):
+            pass
+    elif not protection:
+        return payload
     if not protection or not protection.get("b"):
         raise ExportError("Unrecognized scene format; no viewer decoder parameters were provided.")
     if protection.get("v") != 1:
@@ -136,17 +149,23 @@ def decode_scene(payload, protection, scripts, directory, browser, no_sandbox):
     required = ('"kbo/":', 'VHcI:', 'C04p:')
     found = set()
     selected = []
-    with ThreadPoolExecutor(max_workers=6) as pool:
-        for index, data in enumerate(pool.map(download, scripts)):
-            source = data.decode("utf-8")
-            markers = {marker for marker in required if marker in source}
-            if markers:
-                found.update(markers)
-                name = f"bundle-{index}.js"
-                (directory / name).write_text(source, encoding="utf-8")
-                selected.append(name)
+    cached = directory / 'decoder-bundles.json'
+    if cached.exists():
+        selected = json.loads(cached.read_text())
+        found = set(required)
+    else:
+        with ThreadPoolExecutor(max_workers=6) as pool:
+            for index, data in enumerate(pool.map(download, scripts)):
+                source = data.decode("utf-8")
+                markers = {marker for marker in required if marker in source}
+                if markers:
+                    found.update(markers)
+                    name = f"bundle-{index}.js"
+                    (directory / name).write_text(source, encoding="utf-8")
+                    selected.append(name)
     if found != set(required):
         raise ExportError("The Sketchfab viewer decoder modules changed; this script needs an update.")
+    cached.write_text(json.dumps(selected))
 
     token = secrets.token_hex(24)
     callback_path = "/result-" + token
@@ -184,6 +203,19 @@ try {
     });
 } catch (error) {failure(error.message);}
 </script>'''.replace('CALLBACK', json.dumps(callback_path))
+    payload = browser_document(document, callback_path, directory, browser, no_sandbox)
+    try:
+        decoded = json.loads(payload)
+    except (ValueError, UnicodeError):
+        require(binary, 'Viewer decoder did not return a JSON scene')
+        return payload
+    if isinstance(decoded, dict) and 'error' in decoded:
+        raise ExportError('Viewer decoder: ' + decoded['error'])
+    return payload if binary else decoded
+
+
+def browser_document(document, callback_path, directory, browser, no_sandbox):
+    """Run a local document in a disposable headless browser profile."""
     (directory / 'decode.html').write_text(document, encoding='utf-8')
     result = []
     finished = threading.Event()
@@ -225,10 +257,7 @@ try {
                     raise ExportError('Chrome exited before decoding. ' + (directory / 'chrome.log').read_text(errors='replace')[-1200:])
                 if time.monotonic() > deadline:
                     raise ExportError('Timed out waiting for the browser decoder.')
-        decoded = json.loads(result[0])
-        if 'error' in decoded:
-            raise ExportError('Viewer decoder: ' + decoded['error'])
-        return decoded
+        return result[0]
     finally:
         if process is not None and process.poll() is None:
             process.terminate()
@@ -257,9 +286,511 @@ def require(condition, message):
         raise ExportError(message)
 
 
+IDENTITY = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
+
+
+def metadata(obj):
+    return {v['Name']: v['Value'] for v in obj.get('UserDataContainer', {}).get('Values', [])}
+
+
+def matrix_multiply(a, b):
+    # OSG and glTF both serialize column-major matrices.
+    return [sum(a[k * 4 + row] * b[col * 4 + k] for k in range(4))
+            for col in range(4) for row in range(4)]
+
+
+class GeometryReader:
+    """Decode shared OSG arrays and the viewer's quantized geometry format."""
+
+    def __init__(self, scene, buffers):
+        self.buffers = buffers
+        self.references = {}
+        self.decoded = {}
+        for _, value in walk(scene):
+            if isinstance(value, dict) and 'UniqueID' in value and len(value) > 1:
+                self.references[value['UniqueID']] = value
+
+    def resolve(self, obj):
+        if set(obj) == {'UniqueID'}:
+            require(obj['UniqueID'] in self.references, 'Missing shared geometry reference')
+            return self.references[obj['UniqueID']]
+        return obj
+
+    def array(self, desc):
+        desc = self.resolve(desc)
+        dim = desc['ItemSize']
+        require(isinstance(dim, int) and 1 <= dim <= 16, 'Invalid geometry array dimensions')
+        if 'Elements' in desc:
+            return list(desc['Elements']), dim
+        typ, info = next(iter(desc['Array'].items()))
+        formats = {'Float32Array': 'f', 'Float64Array': 'd', 'Uint16Array': 'H',
+                   'Int16Array': 'h', 'Uint32Array': 'I', 'Int32Array': 'i',
+                   'Uint8Array': 'B', 'Int8Array': 'b'}
+        require(typ in formats, 'Unsupported geometry array type: ' + typ)
+        if 'Elements' in info:
+            return list(info['Elements']), dim
+        require(info.get('File') in self.buffers, 'Missing geometry buffer: ' + str(info.get('File')))
+        raw = self.buffers[info['File']]
+        count, pos = info['Size'] * dim, info.get('Offset', 0)
+        require(isinstance(count, int) and 0 < count <= 100_000_000 and
+                isinstance(pos, int) and 0 <= pos < len(raw), 'Invalid geometry buffer bounds')
+        if info.get('Encoding') == 'varint':
+            values = []
+            for _ in range(count):
+                value = shift = 0
+                while True:
+                    require(pos < len(raw) and shift <= 28, 'Malformed geometry varint')
+                    byte = raw[pos]; pos += 1
+                    value |= (byte & 127) << shift
+                    if byte < 128:
+                        break
+                    shift += 7
+                if typ.startswith('Int'):
+                    value = (value >> 1) ^ -(value & 1)
+                values.append(value)
+        else:
+            require(not info.get('Encoding'), 'Unsupported geometry array encoding')
+            require(pos + count * struct.calcsize(formats[typ]) <= len(raw), 'Truncated geometry array')
+            values = list(struct.unpack_from('<' + str(count) + formats[typ], raw, pos))
+        require(all(math.isfinite(x) for x in values), 'Non-finite geometry values')
+        return values, dim
+
+    def indices(self, primitive, user, watermark):
+        kind, primitive = next(iter(primitive.items()))
+        mode = primitive.get('Mode', 'TRIANGLES')
+        modes = {'POINTS': 0, 'LINES': 1, 'LINE_LOOP': 2, 'LINE_STRIP': 3,
+                 'TRIANGLES': 4, 'TRIANGLE_STRIP': 5, 'TRIANGLE_FAN': 6}
+        require(mode in modes or mode in modes.values(), 'Unsupported primitive mode: ' + str(mode))
+        mode = modes.get(mode, mode)
+        if kind == 'DrawArrays':
+            first = primitive.get('First', 0)
+            return list(range(first, first + primitive['Count'])), mode
+        require(kind.startswith('DrawElements'), 'Unsupported primitive: ' + kind)
+        values, dim = self.array(primitive['Indices'])
+        require(dim == 1, 'Index array must be scalar')
+        if int(user.get('attributes', 0)) & 16 and mode in (4, 5):
+            flags = int(user.get('triangle_mode', 0))
+            require(flags & ~7 == 0, 'Unsupported triangle compression flags')
+            start = 0
+            if flags & 4:
+                require(mode == 5 and len(values) >= 3, 'Invalid implicit triangle strip')
+                length, masks, expected = values[:3]
+                start = 3 + masks
+                require(0 < length <= 100_000_000 and masks == (length + 31) // 32 and
+                        start < len(values), 'Invalid implicit index header')
+            if flags & 1:
+                for i in range(start + 1, len(values)):
+                    v = values[i]
+                    values[i] = (values[i - 1] + ((v >> 1) ^ -(v & 1))) & 0xffffffff
+            if flags & 4:
+                expanded = []
+                cursor = start
+                for i in range(masks):
+                    padding = masks * 32 - length if i == masks - 1 else 0
+                    for bit in range(padding, 32):
+                        if values[3 + i] & (0x80000000 >> bit):
+                            require(cursor < len(values), 'Truncated implicit indices')
+                            expanded.append(values[cursor]); cursor += 1
+                        else:
+                            expanded.append(expected)
+                            if not flags & 2:
+                                expected += 1
+                require(cursor == len(values), 'Unexpected implicit index payload')
+                values = expanded
+            if flags & 2:
+                for i, value in enumerate(values):
+                    value = watermark[0] - value
+                    values[i] = value
+                    watermark[0] = max(watermark[0], value + 1)
+        return values, mode
+
+    def attribute(self, name, desc, user, strip):
+        desc = self.resolve(desc)
+        key = desc.get('UniqueID')
+        if key is not None and key in self.decoded:
+            return self.decoded[key]
+        values, dim = self.array(desc)
+        flag = 4 if name.startswith('TexCoord') else {'Vertex': 1, 'Normal': 2, 'Color': 8, 'Tangent': 32}.get(name, 0)
+        if int(user.get('attributes', 0)) & flag:
+            if name in ('Normal', 'Tangent'):
+                require(dim == 2, 'Unsupported packed normal/tangent layout')
+                result = []
+                nphi, epsilon = float(user.get('nphi', 720)), float(user.get('epsilon', 0.25))
+                require(nphi > 1, 'Invalid normal quantization')
+                for pole, azimuth in zip(values[::2], values[1::2]):
+                    sign = -1 if pole & 1024 else 1
+                    if name == 'Tangent':
+                        pole &= ~1024
+                    theta = pole * (3.14159265359 / (nphi - 1))
+                    cosine, sine = math.cos(theta), math.sin(theta)
+                    shifted = theta + 1.57079632679 / (nphi - 1)
+                    ratio = (math.cos(0.01745329251 * epsilon) - cosine * math.cos(shifted)) / max(1e-5, sine * math.sin(shifted))
+                    phi = 6.28318530718 * azimuth / math.ceil(3.14159265359 / max(1e-5, math.acos(max(-1, min(1, ratio)))))
+                    result.extend([sine * math.cos(phi), sine * math.sin(phi), cosine])
+                    if name == 'Tangent':
+                        result.append(sign)
+                values, dim = result, 4 if name == 'Tangent' else 3
+            elif name == 'Vertex' or name.startswith('TexCoord'):
+                prefix = 'vtx_' if name == 'Vertex' else 'uv_' + name[8:] + '_'
+                mode = int(user.get('vertex_mode' if name == 'Vertex' else prefix + 'mode', user.get('vertex_mode', 0)))
+                require(mode & ~3 == 0, 'Unsupported vertex compression flags')
+                if mode & 2:
+                    require(strip is not None and len(strip) >= 3, 'Predictive attributes need a triangle strip')
+                    visited = set(strip[:3])
+                    for a, b, c, d in zip(strip, strip[1:], strip[2:], strip[3:]):
+                        if d not in visited:
+                            visited.add(d)
+                            for axis in range(dim):
+                                values[d * dim + axis] += values[b * dim + axis] + values[c * dim + axis] - values[a * dim + axis]
+                if mode & 1:
+                    require(dim in (2, 3), 'Unsupported quantized vertex dimensions')
+                    low = [float(user[prefix + 'bbl_' + axis]) for axis in 'xyz'[:dim]]
+                    step = [float(user[prefix + 'h_' + axis]) for axis in 'xyz'[:dim]]
+                    values = [low[i % dim] + v * step[i % dim] for i, v in enumerate(values)]
+            else:
+                raise ExportError('Unsupported compressed attribute: ' + name)
+        if name == 'Color':
+            typ = next(iter(desc.get('Array', {'Float32Array': {}})))
+            divisor = {'Uint8Array': 255, 'Uint16Array': 65535}.get(typ, 1)
+            values = [x / divisor for x in values]
+        require(len(values) % dim == 0 and all(math.isfinite(x) for x in values), 'Invalid decoded attribute')
+        rows = [values[i:i + dim] for i in range(0, len(values), dim)]
+        if key is not None:
+            self.decoded[key] = rows
+        return rows
+
+
+def material_channels(material):
+    return {name: channel for name, channel in material.get('channels', {}).items()
+            if channel.get('enable', False)}
+
+
+def prepare_textures(materials, texture_records, directory, browser, no_sandbox):
+    """Bake separate scalar maps into glTF's base-color and metallic/roughness images.
+
+    Canvas handles PNG/JPEG decoding without adding Python dependencies. Flip
+    images vertically to keep OSG UVs and tangent bases unchanged in glTF.
+    """
+    records = {record['uid']: record for record in texture_records}
+    cache, jobs = {}, []
+
+    def image_data(channel):
+        tex = channel.get('texture')
+        if not tex:
+            return None
+        uid = tex['uid']
+        if uid not in cache:
+            require(uid in records, 'Texture is missing from viewer metadata: ' + uid)
+            images = records[uid].get('images', [])
+            images = [img for img in images if img.get('url') and
+                      img.get('options', {}).get('format', '').lower() not in ('ktx', 'ktx2', 'basis')]
+            require(images, 'No supported image for texture: ' + uid)
+            image = max(images, key=lambda img: img.get('width', 0) * img.get('height', 0))
+            raw = download(image['url'])
+            mime = 'image/png' if raw.startswith(b'\x89PNG') else 'image/jpeg' if raw.startswith(b'\xff\xd8') else 'image/webp' if raw[:4] == b'RIFF' else None
+            require(mime is not None, 'Unsupported texture image format for ' + uid)
+            cache[uid] = 'data:' + mime + ';base64,' + base64.b64encode(raw).decode()
+        return cache[uid]
+
+    def compatible(channels):
+        tex_channels = [c for c in channels if c.get('texture')]
+        if len(tex_channels) > 1:
+            first = tex_channels[0]
+            for channel in tex_channels[1:]:
+                require(channel.get('UVTransforms', {}) == first.get('UVTransforms', {}) and
+                        all(channel['texture'].get(k) == first['texture'].get(k)
+                            for k in ('texCoordUnit', 'wrapS', 'wrapT', 'minFilter', 'magFilter')),
+                        'Cannot pack material maps with different UV transforms or samplers')
+
+    for key, material in materials.items():
+        if not isinstance(material, dict):
+            continue
+        c = material_channels(material)
+        base = c.get('AlbedoPBR', c.get('DiffusePBR', c.get('DiffuseColor', {})))
+        opacity = c.get('Opacity', c.get('AlphaMask', {}))
+        metal, rough = c.get('MetalnessPBR', {}), c.get('RoughnessPBR', {})
+        for name, channels in [('baseColor', [base, opacity]), ('metallicRoughness', [metal, rough]),
+                               ('normal', [c.get('NormalMap', {})]), ('occlusion', [c.get('AOPBR', {})]),
+                               ('emissive', [c.get('EmitColor', {})])]:
+            if not any(ch.get('texture') for ch in channels):
+                continue
+            compatible(channels)
+            jobs.append({'key': key + '/' + name, 'kind': name,
+                         'images': [image_data(ch) for ch in channels],
+                         'invert': bool(opacity.get('invert')) if name == 'baseColor' else False,
+                         'flipY': bool(channels[0].get('flipY')) if name == 'normal' else False})
+    if not jobs:
+        return {}
+    progress(f'Embedding {len(cache)} textures and packing PBR channels...')
+    callback = '/result-' + secrets.token_hex(24)
+    document = '<!doctype html><script>const jobs=' + json.dumps(jobs).replace('<', '\\u003c') + ';'
+    document += r'''
+async function pixels(url) {
+    if (!url) return null;
+    const image = new Image(); image.src = url; await image.decode(); return image;
+}
+async function run() {
+    const result = {};
+    for (const job of jobs) {
+        const images = await Promise.all(job.images.map(pixels));
+        const width = Math.max(...images.map(i => i ? i.width : 1));
+        const height = Math.max(...images.map(i => i ? i.height : 1));
+        const canvas = document.createElement('canvas'); canvas.width = width; canvas.height = height;
+        const ctx = canvas.getContext('2d', {willReadFrequently:true});
+        const inputs = images.map(image => {
+            if (!image) return null;
+            ctx.clearRect(0,0,width,height);
+            ctx.save(); ctx.translate(0,height); ctx.scale(1,-1);
+            ctx.drawImage(image,0,0,width,height); ctx.restore();
+            return ctx.getImageData(0,0,width,height).data;
+        });
+        const output = ctx.createImageData(width,height), out = output.data;
+        for (let i=0; i<out.length; i+=4) {
+            const a=inputs[0], b=inputs[1];
+            if (job.kind === 'metallicRoughness') {
+                out[i]=255; out[i+1]=b?b[i]:255; out[i+2]=a?a[i]:255; out[i+3]=255;
+            } else {
+                for (let k=0;k<4;k++) out[i+k]=a?a[i+k]:255;
+                if (job.kind === 'baseColor' && b) out[i+3]=Math.round(out[i+3]*(job.invert?255-b[i]:b[i])/255);
+                if (job.kind === 'normal' && job.flipY) out[i+1]=255-out[i+1];
+            }
+        }
+        ctx.putImageData(output,0,0);
+        result[job.key]=canvas.toDataURL('image/png').split(',')[1];
+    }
+    return result;
+}
+run().then(result=>fetch(CALLBACK,{method:'POST',body:JSON.stringify(result)}))
+     .catch(error=>fetch(CALLBACK,{method:'POST',body:JSON.stringify({error:String(error)})}));
+</script>'''.replace('CALLBACK', json.dumps(callback))
+    result = json.loads(browser_document(document, callback, directory, browser, no_sandbox))
+    require('error' not in result, 'Texture conversion failed: ' + str(result.get('error')))
+    return {key: base64.b64decode(value) for key, value in result.items()}
+
+
+def append_materials(g, options, assets, buffer_view):
+    mapping = {}
+    sampler_codes = {'REPEAT': 10497, 'CLAMP_TO_EDGE': 33071, 'MIRRORED_REPEAT': 33648,
+                     'NEAREST': 9728, 'LINEAR': 9729, 'NEAREST_MIPMAP_NEAREST': 9984,
+                     'LINEAR_MIPMAP_NEAREST': 9985, 'NEAREST_MIPMAP_LINEAR': 9986, 'LINEAR_MIPMAP_LINEAR': 9987}
+
+    def extension(name):
+        used = g.setdefault('extensionsUsed', [])
+        if name not in used:
+            used.append(name)
+
+    def texture(key, name, channels):
+        active = next((c for c in channels if c.get('texture')), None)
+        if active is None:
+            return None
+        asset = key + '/' + name
+        require(asset in assets, 'Missing prepared material texture: ' + asset)
+        image = len(g.setdefault('images', []))
+        g['images'].append({'name': asset, 'bufferView': buffer_view(assets[asset]), 'mimeType': 'image/png'})
+        source = active['texture']
+        sampler = {k: sampler_codes.get(source.get(k), source.get(k)) for k in ('wrapS', 'wrapT', 'minFilter', 'magFilter') if k in source}
+        samplers = g.setdefault('samplers', [])
+        if sampler not in samplers:
+            samplers.append(sampler)
+        index = len(g.setdefault('textures', []))
+        g['textures'].append({'source': image, 'sampler': samplers.index(sampler)})
+        info = {'index': index, 'texCoord': int(source.get('texCoordUnit', 0))}
+        uv = active.get('UVTransforms', {})
+        transform = {k: uv[k] for k in ('offset', 'scale', 'rotation') if k in uv}
+        if transform:
+            extension('KHR_texture_transform')
+            info['extensions'] = {'KHR_texture_transform': transform}
+        return info
+
+    for key, material in options.items():
+        if not isinstance(material, dict):
+            continue
+        c = material_channels(material)
+        base = c.get('AlbedoPBR', c.get('DiffusePBR', c.get('DiffuseColor', {})))
+        opacity = c.get('Opacity', c.get('AlphaMask', {}))
+        metal, rough = c.get('MetalnessPBR', {}), c.get('RoughnessPBR', {})
+        color = [float(x) * float(base.get('factor', 1)) for x in base.get('color', [1, 1, 1])[:3]]
+        alpha = float(opacity.get('factor', 1))
+        if opacity.get('invert') and not opacity.get('texture'):
+            alpha = 1 - alpha
+        pbr = {'baseColorFactor': [max(0, min(1, x)) for x in color] + [max(0, min(1, alpha))],
+               'metallicFactor': float(metal.get('factor', 0)),
+               'roughnessFactor': float(rough.get('factor', 1))}
+        out = {'name': material.get('name', key), 'pbrMetallicRoughness': pbr,
+               'doubleSided': material.get('cullFace') == 'DISABLE',
+               'extras': {'sketchfabMaterial': material}}
+        for name, field, channels, owner in [
+                ('baseColor', 'baseColorTexture', [base, opacity], pbr),
+                ('metallicRoughness', 'metallicRoughnessTexture', [metal, rough], pbr),
+                ('normal', 'normalTexture', [c.get('NormalMap', {})], out),
+                ('occlusion', 'occlusionTexture', [c.get('AOPBR', {})], out),
+                ('emissive', 'emissiveTexture', [c.get('EmitColor', {})], out)]:
+            info = texture(key, name, channels)
+            if info is not None:
+                owner[field] = info
+        if 'normalTexture' in out:
+            out['normalTexture']['scale'] = float(c['NormalMap'].get('factor', 1))
+        if 'occlusionTexture' in out:
+            out['occlusionTexture']['strength'] = float(c['AOPBR'].get('factor', 1))
+        if 'EmitColor' in c:
+            emit = c['EmitColor']
+            out['emissiveFactor'] = [float(x) for x in emit.get('color', [1, 1, 1])]
+            extension('KHR_materials_emissive_strength')
+            out.setdefault('extensions', {})['KHR_materials_emissive_strength'] = {'emissiveStrength': float(emit.get('factor', 1))}
+        if opacity:
+            out['alphaMode'] = 'MASK' if 'AlphaMask' in c and 'Opacity' not in c else 'BLEND'
+            if out['alphaMode'] == 'MASK':
+                out['alphaCutoff'] = float(opacity.get('threshold', 0.5))
+        if material.get('shadeless'):
+            extension('KHR_materials_unlit')
+            out.setdefault('extensions', {})['KHR_materials_unlit'] = {}
+        unsupported = [name for name in ('BumpMap', 'Displacement', 'SpecularPBR', 'GlossinessPBR',
+                                         'ClearCoat', 'Sheen', 'SubsurfaceScattering', 'SubsurfaceTranslucency')
+                       if name in c and (c[name].get('texture') or c[name].get('factor', 0))]
+        if unsupported:
+            progress('Warning: material ' + out['name'] + ': unsupported channels kept in GLB extras: ' + ', '.join(unsupported))
+        index = len(g.setdefault('materials', []))
+        g['materials'].append(out)
+        if 'stateSetID' in material:
+            mapping[int(material['stateSetID'])] = index
+        else:
+            mapping[key] = index
+    return mapping
+
+
+def append_meshes(g, scene, bones, buffers, accessor, materials):
+    reader = GeometryReader(scene, buffers)
+    bone_ids = {b['source_id']: i for i, b in enumerate(bones)}
+    bone_names = {b['name']: i for i, b in enumerate(bones)}
+    require(len(bone_names) == len(bones), 'Duplicate bone names are ambiguous for skinning')
+    root = len(bones)
+    for node in g['nodes']:
+        node.pop('children', None)
+    mesh_count = 0
+
+    def visit(obj, parent, skeleton=None, relative=None, material=None):
+        nonlocal mesh_count
+        for kind, value in obj.items():
+            if not isinstance(value, dict) or not kind.startswith('osg'):
+                continue
+            value = reader.resolve(value)
+            user = metadata(value)
+            if str(user.get('wireframe', '0')) == '1':
+                continue
+            require(kind != 'osgAnimation.MorphGeometry', 'Morph geometry is not supported')
+            if 'StateSet' in value:
+                state = reader.resolve(value['StateSet'].get('osg.StateSet', value['StateSet']))
+                material = materials.get(int(metadata(state).get('UniqueID', state.get('UniqueID', -1))), material)
+            # The outer source transform converts source units/Y-up to the
+            # viewer's meters/Z-up. GLB uses our --scale wrapper and Y-up.
+            matrix = value.get('Matrix', IDENTITY) if 'source' not in user else IDENTITY
+            require(len(matrix) == 16 and all(math.isfinite(x) for x in matrix), 'Invalid scene transform')
+            relative = matrix_multiply(relative or IDENTITY, matrix)
+            is_geometry = kind in ('osg.Geometry', 'osgAnimation.RigGeometry')
+            if kind == 'osgAnimation.Bone':
+                index = bone_ids[id(value)]
+            else:
+                index = len(g['nodes'])
+                node = {'name': value.get('Name', kind.split('.')[-1])}
+                if matrix != IDENTITY and not is_geometry:
+                    node['matrix'] = matrix
+                g['nodes'].append(node)
+            g['nodes'][parent].setdefault('children', []).append(index)
+            if kind == 'osgAnimation.Skeleton':
+                skeleton, relative = index, IDENTITY
+            if is_geometry:
+                rig = value if kind == 'osgAnimation.RigGeometry' else None
+                source = reader.resolve(rig['SourceGeometry'].get('osg.Geometry', {})) if rig else value
+                require('VertexAttributeList' in source, 'Unsupported source geometry layout')
+                source_user = dict(user, **metadata(source))
+                if 'StateSet' in source:
+                    state = reader.resolve(source['StateSet'].get('osg.StateSet', source['StateSet']))
+                    material = materials.get(int(metadata(state).get('UniqueID', state.get('UniqueID', -1))), material)
+                require(material is not None or not materials, 'Cannot determine material for mesh: ' + source.get('Name', 'Mesh'))
+                attrs = dict(source['VertexAttributeList'])
+                if rig:
+                    attrs.update(rig.get('VertexAttributeList', {}))
+                require('Vertex' in attrs, 'Mesh has no positions')
+                position_desc = reader.resolve(attrs['Vertex'])
+                raw_positions, position_dim = reader.array(position_desc)
+                require(position_dim == 3, 'Positions must be VEC3')
+                count = len(raw_positions) // 3
+                primitives, watermark = [], [0]
+                for primitive in source.get('PrimitiveSetList', []):
+                    indices, mode = reader.indices(primitive, source_user, watermark)
+                    require(indices and all(isinstance(i, int) and 0 <= i < count for i in indices), 'Mesh index out of range')
+                    primitives.append((indices, mode))
+                require(primitives, 'Mesh has no primitives')
+                strip = next((indices for indices, mode in primitives if mode == 5), None)
+                attributes = {}
+                for name, desc in attrs.items():
+                    semantic = {'Vertex': 'POSITION', 'Normal': 'NORMAL', 'Tangent': 'TANGENT', 'Color': 'COLOR_0'}.get(name)
+                    if name.startswith('TexCoord') and name[8:].isdigit():
+                        semantic = 'TEXCOORD_' + name[8:]
+                    if semantic:
+                        rows = reader.attribute(name, desc, source_user, strip)
+                        require(len(rows) == count, 'Mismatched vertex attribute counts')
+                        expected = 2 if semantic.startswith('TEXCOORD') else 4 if name == 'Tangent' else 3
+                        require(len(rows[0]) == expected or name == 'Color' and len(rows[0]) == 4, 'Invalid attribute dimensions')
+                        attributes[semantic] = accessor(rows, len(rows[0]), bounds=name == 'Vertex')
+                if rig:
+                    require(skeleton is not None, 'Skinned mesh has no parent skeleton')
+                    require('Bones' in attrs and 'Weights' in attrs, 'Skinned mesh has no bone weights')
+                    palette = rig.get('BoneMap', {})
+                    require(palette and all(name in bone_names for name in palette), 'Skin references unknown bones')
+                    mapping = {slot: bone_names[name] for name, slot in palette.items()}
+                    require(len(mapping) == len(palette), 'Duplicate skin palette indices')
+                    joints = reader.attribute('Bones', attrs['Bones'], source_user, strip)
+                    weights = reader.attribute('Weights', attrs['Weights'], source_user, strip)
+                    require(len(joints) == len(weights) == count and all(len(x) == 4 for x in joints + weights), 'Expected four influences per vertex')
+                    mapped, normalized = [], []
+                    for js, ws in zip(joints, weights):
+                        require(all(w >= 0 for w in ws) and sum(ws) > 0, 'Invalid skin weights')
+                        require(all(j in mapping for j, w in zip(js, ws) if w > 0), 'Skin joint index out of range')
+                        mapped.append([mapping[j] if w > 0 else 0 for j, w in zip(js, ws)])
+                        normalized.append([w / sum(ws) for w in ws])
+                    attributes['JOINTS_0'] = accessor(mapped, 4, component_type=5123)
+                    attributes['WEIGHTS_0'] = accessor(normalized, 4)
+                    matrices = []
+                    for bone in bones:
+                        bind = bone.get('inverse_bind')
+                        require(bind is not None and len(bind) == 16, 'Bone has no inverse bind matrix: ' + bone['name'])
+                        matrices.append(matrix_multiply(bind, relative))
+                    skin = {'name': source.get('Name', 'Skin'), 'joints': list(range(len(bones))),
+                            'skeleton': skeleton, 'inverseBindMatrices': accessor(matrices, 16)}
+                    g['nodes'][index]['skin'] = len(g.setdefault('skins', []))
+                    g['skins'].append(skin)
+                mesh = {'name': source.get('Name', value.get('Name', 'Mesh')), 'primitives': []}
+                for indices, mode in primitives:
+                    # Explicit triangles avoid degenerate strip faces in DCCs.
+                    if mode == 5:
+                        triangles = []
+                        for i in range(len(indices) - 2):
+                            a, b, c = indices[i:i + 3]
+                            if len({a, b, c}) == 3:
+                                triangles.extend((b, a, c) if i % 2 else (a, b, c))
+                        indices, mode = triangles, 4
+                    require(indices, 'Mesh contains no nondegenerate primitives')
+                    primitive = {'attributes': attributes, 'mode': mode,
+                                 'indices': accessor([[i] for i in indices], 1, component_type=5125)}
+                    if material is not None:
+                        primitive['material'] = material
+                    mesh['primitives'].append(primitive)
+                g['nodes'][index]['mesh'] = len(g.setdefault('meshes', []))
+                g['meshes'].append(mesh)
+                mesh_count += 1
+            for child in value.get('Children', []):
+                visit(child, index, skeleton, relative, material)
+
+    default_material = next(iter(materials.values())) if len(set(materials.values())) == 1 else None
+    visit({'osg.Node': scene['osg.Node']}, root, material=default_material)
+    return mesh_count
+
+
 # Conversion uses the viewer's packed-vector and delta encodings, then writes
 # standard glTF quaternion tracks and a resampled BVH hierarchy.
-def export_animation(scene, animation, raw, clip_name, fps, scale):
+def export_animation(scene, animation, raw, clip_name, fps, scale, geometry_buffers=None,
+                     material_options=None, texture_assets=None):
     bones=[]; targets={}
     def hierarchy(obj, parent=None):
         for kind, v in obj.items():
@@ -267,7 +798,8 @@ def export_animation(scene, animation, raw, clip_name, fps, scale):
             current=parent
             if kind=='osgAnimation.Bone':
                 current=len(bones)
-                b={'name':v['Name'], 'parent':parent, 'children':[], 'translation':[0,0,0], 'rotation':[0,0,0,1], 'scale':[1,1,1]}
+                b={'name':v['Name'], 'parent':parent, 'children':[], 'translation':[0,0,0], 'rotation':[0,0,0,1], 'scale':[1,1,1],
+                   'source_id':id(v), 'inverse_bind':v.get('InvBindMatrixInSkeletonSpace')}
                 bones.append(b)
                 if parent is not None: bones[parent]['children'].append(current)
                 for cb in v.get('UpdateCallbacks',[]):
@@ -381,25 +913,42 @@ def export_animation(scene, animation, raw, clip_name, fps, scale):
             require(all(abs(x-1)<1e-5 for v in t['values'] for x in v), 'BVH cannot represent animated scale')
     duration=max(t['times'][-1] for t in tracks)
 
-    # A standard glTF scene with animated skeleton nodes. BVH below provides
-    # explicit joint hierarchy for applications that do not infer bones from nodes.
+    # Keep bone node indices stable while adding mesh and scene nodes below.
     g={'asset':{'version':'2.0','generator':'sketchfab_animation.py'},'scene':0,'scenes':[{'nodes':[len(bones)]}], 'nodes':[], 'buffers':[], 'bufferViews':[], 'accessors':[], 'animations':[{'name':clip_name,'channels':[],'samplers':[]}]}
     for b in bones:
-        g['nodes'].append({k:b[k] for k in ['name','translation','rotation','scale','children']})
-    g['nodes'].append({'name':'Source units to meters','scale':[scale]*3,'children':[i for i,b in enumerate(bones) if b['parent'] is None]})
+        node = {k:b[k] for k in ['name','translation','rotation','scale']}
+        if b['children']: node['children'] = list(b['children'])
+        q = node['rotation']; norm = math.sqrt(sum(x*x for x in q))
+        require(norm > 0, 'Invalid rest quaternion')
+        node['rotation'] = [x/norm for x in q]
+        g['nodes'].append(node)
+    # Keep the unit conversion on a root named after the model for the Outliner.
+    g['nodes'].append({'name':slugify(clip_name),'scale':[scale]*3,'children':[i for i,b in enumerate(bones) if b['parent'] is None]})
     binary=bytearray()
-    def accessor(vals,dim):
-        flat=[v for row in vals for v in row];offset=len(binary)
-        binary.extend(struct.pack('<'+str(len(flat))+'f',*flat))
-        vi=len(g['bufferViews']);g['bufferViews'].append({'buffer':0,'byteOffset':offset,'byteLength':len(flat)*4})
-        a={'bufferView':vi,'componentType':5126,'count':len(vals),'type':{1:'SCALAR',3:'VEC3',4:'VEC4'}[dim]}
-        if dim==1:a.update(min=[min(flat)],max=[max(flat)])
+    def buffer_view(data):
+        binary.extend(b'\0' * (-len(binary) % 4))
+        offset = len(binary); binary.extend(data)
+        g['bufferViews'].append({'buffer':0,'byteOffset':offset,'byteLength':len(data)})
+        return len(g['bufferViews']) - 1
+    def accessor(vals,dim,component_type=5126,bounds=False):
+        flat=[v for row in vals for v in row]
+        require(vals and all(len(v) == dim for v in vals) and all(math.isfinite(x) for x in flat), 'Invalid glTF accessor')
+        vi=buffer_view(struct.pack('<'+str(len(flat))+{5126:'f',5123:'H',5125:'I'}[component_type],*flat))
+        a={'bufferView':vi,'componentType':component_type,'count':len(vals),'type':{1:'SCALAR',2:'VEC2',3:'VEC3',4:'VEC4',16:'MAT4'}[dim]}
+        if dim==1 or bounds:
+            a.update(min=[min(row[i] for row in vals) for i in range(dim)],
+                     max=[max(row[i] for row in vals) for i in range(dim)])
         g['accessors'].append(a);return len(g['accessors'])-1
     for t in tracks:
         ai=g['animations'][0];i=accessor([[x] for x in t['times']],1);o=accessor(t['values'],len(t['values'][0]))
         ai['channels'].append({'sampler':len(ai['samplers']),'target':{'node':t['bone'],'path':t['path']}})
         ai['samplers'].append({'input':i,'output':o,'interpolation':'LINEAR'})
+    mesh_count = 0
+    if geometry_buffers is not None:
+        materials = append_materials(g, material_options or {}, texture_assets or {}, buffer_view)
+        mesh_count = append_meshes(g, scene, bones, geometry_buffers, accessor, materials)
     g['buffers']=[{'byteLength':len(binary)}]
+    binary.extend(b'\0' * (-len(binary) % 4))
     j=json.dumps(g,separators=(',',':')).encode();j+=b' '*(-len(j)%4)
     glb=struct.pack('<III',0x46546c67,2,12+8+len(j)+8+len(binary))+struct.pack('<II',len(j),0x4e4f534a)+j+struct.pack('<II',len(binary),0x004e4942)+binary
 
@@ -444,7 +993,8 @@ def export_animation(scene, animation, raw, clip_name, fps, scale):
             values += [v-o for v,o in zip(sample(i,'translation',f*dt),bones[i]['translation'])]
             values += euler_xyz(sample(i,'rotation',f*dt))
         lines.append(' '.join(f'{v:.8f}' for v in values))
-    return glb, '\n'.join(lines)+'\n', {'joints':len(bones),'tracks':len(tracks),'duration':duration,'frames':frames}
+    return glb, '\n'.join(lines)+'\n', {'joints':len(bones),'tracks':len(tracks),'duration':duration,'frames':frames,
+                                      'meshes':mesh_count,'materials':len(g.get('materials', [])),'skins':len(g.get('skins', []))}
 
 
 def choose_animation(scene, uid):
@@ -460,6 +1010,40 @@ def choose_animation(scene, uid):
     return candidates[0]
 
 
+def load_geometry_buffers(scene, file_info, scripts, directory, browser, no_sandbox):
+    reader = GeometryReader(scene, {})
+    files = set()
+
+    def collect(obj):
+        for kind, value in obj.items():
+            if not isinstance(value, dict):
+                continue
+            value = reader.resolve(value)
+            if str(metadata(value).get('wireframe', '0')) == '1':
+                continue
+            if kind in ('osg.Geometry', 'osgAnimation.RigGeometry', 'osgAnimation.MorphGeometry'):
+                for _, desc in walk(value):
+                    if isinstance(desc, dict):
+                        desc = reader.resolve(desc)
+                        for typ, info in desc.get('Array', {}).items():
+                            if 'File' in info:
+                                files.add(info['File'])
+            for child in value.get('Children', []):
+                collect(child)
+    collect({'osg.Node': scene['osg.Node']})
+    result = {}
+    for name in sorted(files):
+        url = urljoin(file_info['osgjsUrl'], name)
+        require(urlparse(url).scheme == 'https' and urlparse(url).hostname == urlparse(file_info['osgjsUrl']).hostname,
+                'Geometry buffer must be on the model asset host')
+        progress('Downloading geometry buffer: ' + name)
+        raw = download(url)
+        if urlparse(url).path.endswith('.binz') and file_info.get('p'):
+            raw = decode_scene(raw, file_info['p'][0], scripts, directory, browser, no_sandbox, binary=True)
+        result[name] = raw
+    return result
+
+
 def run(args):
     uid = model_id(args.url)
     progress('Fetching model metadata...')
@@ -496,9 +1080,18 @@ def run(args):
         except (ValueError, UnicodeError):
             protection = next(iter(file_info.get('p', [])), None)
             scene = decode_scene(payload, protection, page.scripts, directory, find_chrome(args.chrome), args.no_sandbox)
+        geometry_buffers = material_options = texture_assets = None
+        if not args.skeleton_only:
+            browser = find_chrome(args.chrome)
+            geometry_buffers = load_geometry_buffers(scene, file_info, page.scripts, directory, browser, args.no_sandbox)
+            material_options = model.get('options', {}).get('materials', {})
+            texture_records = next((v.get('results', []) for k, v in page.data.items()
+                                    if k.startswith(f'/i/models/{uid}/textures') and isinstance(v, dict)), [])
+            texture_assets = prepare_textures(material_options, texture_records, directory, browser, args.no_sandbox)
         progress('Reconstructing skeleton and exporting animation...')
         animation = choose_animation(scene, clip['uid'])
-        glb, bvh, summary = export_animation(scene, animation, raw, model['name'], args.fps, args.scale)
+        glb, bvh, summary = export_animation(scene, animation, raw, model['name'], args.fps, args.scale,
+                                           geometry_buffers, material_options, texture_assets)
         # Prepare both outputs before creating the final folder. Intermediate
         # downloads, scripts and the temporary browser profile are discarded.
         (directory / 'animation.glb').write_bytes(glb)
@@ -509,7 +1102,8 @@ def run(args):
             data = (directory / f'animation.{extension}').read_bytes()
             with target.open('wb' if args.overwrite else 'xb') as output:
                 output.write(data)
-    progress(f"Exported {summary['joints']} joints, {summary['tracks']} tracks, {summary['duration']:.3f} seconds. Skeleton only; no mesh.")
+    progress(f"Exported {summary['joints']} joints, {summary['tracks']} tracks, {summary['duration']:.3f} seconds; "
+             f"GLB: {summary['meshes']} meshes, {summary['materials']} materials, {summary['skins']} skins. BVH: skeleton only.")
     for extension in ('bvh', 'glb'):
         print(folder / f'{name}.{extension}')
 
@@ -530,6 +1124,7 @@ def main():
     parser.add_argument('--fps', type=positive_number, default=30, help='approximate BVH sample rate (default: 30)')
     parser.add_argument('--scale', type=positive_number, default=0.01, help='source-units-to-meters factor for GLB (default: 0.01); BVH keeps source units')
     parser.add_argument('--overwrite', action='store_true', help='replace existing output files')
+    parser.add_argument('--skeleton-only', action='store_true', help='omit GLB geometry, materials and skinning')
     parser.add_argument('--no-sandbox', action='store_true', help='disable Chrome sandbox only if required by your runtime environment')
     args = parser.parse_args()
     try:

3D/animations/test_sketchfab_animation.py

@@ -0,0 +1,170 @@
+"""Offline regression tests: python -B -m unittest discover -s animations."""
+import json
+import struct
+import unittest
+
+import sketchfab_animation as exporter
+
+
+def read_glb(data):
+    magic, version, length = struct.unpack_from('<III', data)
+    assert (magic, version, length) == (0x46546c67, 2, len(data))
+    size, kind = struct.unpack_from('<II', data, 12)
+    assert kind == 0x4e4f534a
+    g = json.loads(data[20:20 + size])
+    binary_size, kind = struct.unpack_from('<II', data, 20 + size)
+    assert kind == 0x004e4942
+    binary = data[28 + size:]
+    assert len(binary) == binary_size
+    return g, binary
+
+
+def read_accessor(g, binary, index):
+    a = g['accessors'][index]
+    view = g['bufferViews'][a['bufferView']]
+    dim = {'SCALAR': 1, 'VEC2': 2, 'VEC3': 3, 'VEC4': 4, 'MAT4': 16}[a['type']]
+    fmt = {5126: 'f', 5123: 'H', 5125: 'I'}[a['componentType']]
+    return list(struct.unpack_from('<' + str(a['count'] * dim) + fmt, binary, view.get('byteOffset', 0)))
+
+
+def fixture():
+    def bone(name, x, children):
+        bind = list(exporter.IDENTITY); bind[12] = -x
+        matrix = list(exporter.IDENTITY); matrix[12] = x
+        return {'osgAnimation.Bone': {
+            'Name': name, 'Matrix': matrix, 'InvBindMatrixInSkeletonSpace': bind,
+            'UpdateCallbacks': [{'osgAnimation.UpdateBone': {
+                'Name': name, 'StackedTransforms': [
+                    {'osgAnimation.StackedTranslate': {'Translate': [x, 0, 0]}}]}}],
+            'Children': children}}
+
+    def array(values, dim, typ='Float32Array'):
+        return {'Array': {typ: {'Elements': values}}, 'ItemSize': dim}
+
+    geometry = {'Name': 'Triangle', 'VertexAttributeList': {
+        'Vertex': array([0, 0, 0, 0, 1, 0, 0, 0, 1], 3),
+        'Normal': array([1, 0, 0] * 3, 3),
+        'TexCoord0': array([0, 0, 1, 0, 0, 1], 2)},
+        'PrimitiveSetList': [{'DrawElementsUShort': {
+            'Mode': 'TRIANGLES', 'Indices': array([0, 1, 2], 1, 'Uint16Array')}}]}
+    rig = {'osgAnimation.RigGeometry': {
+        'BoneMap': {'Child': 9}, 'SourceGeometry': {'osg.Geometry': geometry},
+        'VertexAttributeList': {'Bones': array([9, 65535, 0, 0] * 3, 4, 'Uint16Array'),
+                                'Weights': array([2, 0, 0, 0] * 3, 4)}}}
+    matrix = list(exporter.IDENTITY); matrix[12] = 3
+    scene = {'osg.Node': {'Children': [{'osgAnimation.Skeleton': {'Children': [
+        bone('Root', 0, [bone('Child', 1, [])]),
+        {'osg.MatrixTransform': {'Matrix': matrix, 'Children': [rig]}}]}}]}}
+    raw = struct.pack('<8f', 0, 1, 1, 0, 0, 2, 0, 0)
+    animation = {'osgAnimation.Vec3LerpChannel': {
+        'Name': 'translate', 'TargetName': 'Child', 'KeyFrames': {
+            'Time': {'ItemSize': 1, 'Array': {'Float32Array': {'Size': 2, 'Offset': 0}}},
+            'Key': {'ItemSize': 3, 'Array': {'Float32Array': {'Size': 2, 'Offset': 8}}}}}}
+    return scene, animation, raw, rig
+
+
+class MeshExportTests(unittest.TestCase):
+    def test_skin_palette_bind_transform_and_animation(self):
+        scene, animation, raw, _ = fixture()
+        glb, bvh, summary = exporter.export_animation(scene, animation, raw, 'Test', 30, .01, {})
+        g, binary = read_glb(glb)
+        self.assertEqual((summary['meshes'], summary['skins']), (1, 1))
+        skin = g['skins'][0]
+        self.assertEqual(skin['joints'], [0, 1])
+        binds = read_accessor(g, binary, skin['inverseBindMatrices'])
+        self.assertEqual(binds[12], 3)
+        self.assertEqual(binds[28], 2)  # inverse child bind (-1) times mesh transform (+3)
+        attrs = g['meshes'][0]['primitives'][0]['attributes']
+        self.assertEqual(read_accessor(g, binary, attrs['JOINTS_0']), [1, 0, 0, 0] * 3)
+        self.assertEqual(read_accessor(g, binary, attrs['WEIGHTS_0']), [1, 0, 0, 0] * 3)
+        self.assertEqual(g['animations'][0]['channels'][0]['target'], {'node': 1, 'path': 'translation'})
+        for view in g['bufferViews']:
+            self.assertEqual(view['byteOffset'] % 4, 0)
+            self.assertLessEqual(view['byteOffset'] + view['byteLength'], len(binary))
+        self.assertIn('Frames: 31', bvh)
+
+    def test_invalid_skin_fails_instead_of_exporting_broken_mesh(self):
+        scene, animation, raw, rig = fixture()
+        rig['osgAnimation.RigGeometry']['VertexAttributeList']['Weights']['Array']['Float32Array']['Elements'] = [0] * 12
+        with self.assertRaisesRegex(exporter.ExportError, 'Invalid skin weights'):
+            exporter.export_animation(scene, animation, raw, 'Test', 30, .01, {})
+
+    def test_skeleton_only_keeps_bvh_and_ignores_mesh_errors(self):
+        scene, animation, raw, rig = fixture()
+        _, expected, _ = exporter.export_animation(scene, animation, raw, 'Test', 30, .01, {})
+        rig['osgAnimation.RigGeometry']['SourceGeometry'] = {}
+        glb, bvh, summary = exporter.export_animation(scene, animation, raw, 'Test', 30, .01)
+        self.assertEqual(expected, bvh)
+        self.assertEqual(summary['meshes'], 0)
+        self.assertNotIn('meshes', read_glb(glb)[0])
+
+    def test_meshless_scene(self):
+        scene, animation, raw, _ = fixture()
+        scene['osg.Node']['Children'][0]['osgAnimation.Skeleton']['Children'].pop()
+        glb, _, summary = exporter.export_animation(scene, animation, raw, 'Test', 30, .01, {})
+        self.assertEqual(summary['meshes'], 0)
+        self.assertNotIn('meshes', read_glb(glb)[0])
+
+    def test_static_mesh_and_viewer_wireframe(self):
+        scene, animation, raw, rig = fixture()
+        transform = scene['osg.Node']['Children'][0]['osgAnimation.Skeleton']['Children'][1]['osg.MatrixTransform']
+        geometry = rig['osgAnimation.RigGeometry']['SourceGeometry']['osg.Geometry']
+        transform['Children'] = [{'osg.Geometry': geometry}, {'osg.Geometry': {
+            'UserDataContainer': {'Values': [{'Name': 'wireframe', 'Value': '1'}]}}}]
+        glb, _, summary = exporter.export_animation(scene, animation, raw, 'Test', 30, .01, {})
+        g, _ = read_glb(glb)
+        self.assertEqual(summary['meshes'], 1)
+        self.assertNotIn('skins', g)
+        self.assertNotIn('JOINTS_0', g['meshes'][0]['primitives'][0]['attributes'])
+        self.assertTrue(any(n.get('matrix', [0] * 16)[12] == 3 for n in g['nodes']))
+
+    def test_material_factors_and_odd_image_alignment(self):
+        scene, animation, raw, _ = fixture()
+        materials = {'purple': {'stateSetID': 0, 'name': 'Purple', 'cullFace': 'DISABLE', 'channels': {
+            'AlbedoPBR': {'enable': True, 'color': [.4, .02, .6], 'factor': .5,
+                          'texture': {'uid': 'image', 'texCoordUnit': 0}},
+            'MetalnessPBR': {'enable': True, 'factor': .2},
+            'RoughnessPBR': {'enable': True, 'factor': .6}}}}
+        glb, _, _ = exporter.export_animation(scene, animation, raw, 'Test', 30, .01, {}, materials,
+                                              {'purple/baseColor': b'odd length!'})
+        g, binary = read_glb(glb)
+        pbr = g['materials'][0]['pbrMetallicRoughness']
+        self.assertEqual(pbr['baseColorFactor'], [.2, .01, .3, 1])
+        self.assertEqual(pbr['roughnessFactor'], .6)
+        self.assertTrue(g['materials'][0]['doubleSided'])
+        self.assertEqual(g['meshes'][0]['primitives'][0]['material'], 0)
+        for view in g['bufferViews']:
+            self.assertEqual(view['byteOffset'] % 4, 0)
+        self.assertEqual(len(binary) % 4, 0)
+
+
+class GeometryCodecTests(unittest.TestCase):
+    def test_high_watermark_implicit_strip_and_predictive_positions(self):
+        # Explicit compressed values are all zero: implicit zero codes produce
+        # sequential indices through the high-watermark codec, including padding.
+        reader = exporter.GeometryReader({}, {})
+        desc = {'Array': {'Uint32Array': {'Elements': [4, 1, 0, 8, 0]}}, 'ItemSize': 1}
+        indices, mode = reader.indices({'DrawElementsUInt': {'Mode': 'TRIANGLE_STRIP', 'Indices': desc}},
+                                       {'attributes': 16, 'triangle_mode': 7}, [0])
+        self.assertEqual((indices, mode), ([0, 1, 2, 3], 5))
+        # The fourth point residual is zero: p3 = p1 + p2 - p0.
+        vertices = {'Array': {'Int32Array': {'Elements': [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0]}}, 'ItemSize': 3}
+        positions = reader.attribute('Vertex', vertices, {'attributes': 1, 'vertex_mode': 2}, indices)
+        self.assertEqual(positions[-1], [1, 1, 0])
+
+    def test_unsigned_indices_delta_codec(self):
+        reader = exporter.GeometryReader({}, {})
+        desc = {'Array': {'Uint32Array': {'Elements': [2, 3, 2]}}, 'ItemSize': 1}
+        indices, _ = reader.indices({'DrawElementsUInt': {'Mode': 'TRIANGLES', 'Indices': desc}},
+                                    {'attributes': 16, 'triangle_mode': 1}, [0])
+        self.assertEqual(indices, [2, 0, 1])
+
+    def test_truncated_buffer_and_varint(self):
+        reader = exporter.GeometryReader({}, {'mesh.bin': b'\x80'})
+        for typ, extra in [('Float32Array', {}), ('Int32Array', {'Encoding': 'varint'})]:
+            with self.assertRaises(exporter.ExportError):
+                reader.array({'ItemSize': 3, 'Array': {typ: {'File': 'mesh.bin', 'Size': 1, **extra}}})
+
+
+if __name__ == '__main__':
+    unittest.main()

3D/animations/touchdown-raiz/touchdown-raiz.glb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ae17a7fa50a687561288822c174bbbe68c90df3146f905cbdfcada20c134f4ef
-size 1115584
+oid sha256:504ca7d4d48b5dce59226bd51b2962d52ff109f835287ad4dedcc11bc60e6e0e
+size 2208156