@bitmagic/cli 0.1.61 → 0.1.62-dev.1

package/assets/unity-import/build_parts.py

@@ -0,0 +1,263 @@
+"""Turn raw Unity colliders into the four depth-sorted sets `src/work/ArenaData.ts` exports.
+
+    python3 tools/unity_extract.py "<scene>.unity"  > tools/colliders.json
+    python3 tools/unity_markers.py "<scene>.unity"  > tools/markers.json
+    python3 tools/build_parts.py [--map]            > tools/arena_parts.json
+
+Ships fly at z=0 with a 0.8-radius collider and their Z frozen, so only geometry crossing
+z ∈ [-0.8, 0.8] can be hit. Everything else is set dressing at its own depth, in front of the plane
+or behind it. `--map` prints an ASCII plan of the result.
+
+Unity renumbered its collision layers between the two project trees — TERRAIN is 7 in
+one tree and 10 in the other, and the level lived in the second — so the
+number is read by NAME out of the project's own TagManager. It used to be inferred as "whichever
+layer holds the most in-plane boxes", which silently picked Default once the extractor started
+finding the colliders nested inside prefabs, and quietly dropped every real Terrain box.
+"""
+
+import collections
+import json
+import os
+import re
+import sys
+
+SC = os.path.dirname(os.path.abspath(__file__))
+
+# Must match unity_extract's slice: the depth band a ship is deemed to occupy, in Unity's Z. The
+# arena's doorways are archways cut at z -3..-1, so the play plane is not at zero — see the note in
+# unity_extract.py. Classifying around a different centre than the extractor sliced at would drop
+# every sliced wall into "foreground" and leave the level with no collision at all.
+PLANE_HALF = float(_CFG['planeHalf'])
+PLANE_CENTER = float(_CFG['planeZ'])
+PLANE_LO = PLANE_CENTER - PLANE_HALF
+PLANE_HI = PLANE_CENTER + PLANE_HALF
+
+# The project the scene belongs to; its TagManager names the collision layers.
+from import_config import CFG as _CFG, unity_root as _unity_root
+UNITY_ROOT = _unity_root()
+
+
+def layer_index(name):
+    """The number Unity gave a named collision layer, or None if the project cannot be read."""
+    path = os.path.join(UNITY_ROOT, 'ProjectSettings', 'TagManager.asset')
+    try:
+        with open(path, encoding='utf-8', errors='ignore') as fh:
+            text = fh.read()
+    except OSError:
+        return None
+    block = re.search(r'\n  layers:\n(.*?)(?=\n  m_\w)', text, re.S)
+    if not block:
+        return None
+    for i, line in enumerate(block.group(1).split('\n')):
+        entry = line.strip()
+        if entry.startswith('- '):
+            entry = entry[2:].strip()
+        elif entry == '-':
+            entry = ''
+        else:
+            continue
+        if entry == name:
+            return i
+    return None
+
+# An FBX whose bounds are junk — LOD or pivot geometry that swamps the real mesh.
+BAD_TAGS = set(_CFG['badTags'])
+
+
+def qrot(q, v):
+    x, y, z, w = q
+    vx, vy, vz = v
+    tx = 2 * (y * vz - z * vy)
+    ty = 2 * (z * vx - x * vz)
+    tz = 2 * (x * vy - y * vx)
+    return (vx + w * tx + (y * tz - z * ty),
+            vy + w * ty + (z * tx - x * tz),
+            vz + w * tz + (x * ty - y * tx))
+
+
+def to_aabb(colliders):
+    out = []
+    for c in colliders:
+        sx, sy, sz = c['size']
+        scx, scy, scz = c['scale']
+        cx, cy, cz = c['center']
+        hx, hy, hz = sx * scx / 2, sy * scy / 2, sz * scz / 2
+        q = c['quat']
+        p = c['pos']
+        wc = qrot(q, (cx * scx, cy * scy, cz * scz))
+        ctr = (p[0] + wc[0], p[1] + wc[1], p[2] + wc[2])
+        mn = [1e9] * 3
+        mx = [-1e9] * 3
+        for ix in (-1, 1):
+            for iy in (-1, 1):
+                for iz in (-1, 1):
+                    v = qrot(q, (ix * hx, iy * hy, iz * hz))
+                    for k in range(3):
+                        w = ctr[k] + v[k]
+                        mn[k] = min(mn[k], w)
+                        mx[k] = max(mx[k], w)
+        out.append(dict(tag=c['tag'], name=c.get('name', ''), layer=c['layer'],
+                        trigger=c['trigger'],
+                        min=[round(v, 3) for v in mn], max=[round(v, 3) for v in mx]))
+    return out
+
+
+def merge(rects):
+    """Fuse rectangles that share an edge, so the wall list stays short.
+
+    A fused rectangle keeps the first source's name and tag; the pieces being merged are runs of
+    one object's cross-section, so that is the object either way.
+    """
+    rs = [dict(r) for r in rects]
+    changed = True
+    while changed:
+        changed = False
+        for i in range(len(rs)):
+            for j in range(i + 1, len(rs)):
+                a, b = rs[i], rs[j]
+                if (abs(a['y0'] - b['y0']) < 0.02 and abs(a['y1'] - b['y1']) < 0.02
+                        and a['x0'] <= b['x1'] + 0.02 and b['x0'] <= a['x1'] + 0.02):
+                    a['x0'] = min(a['x0'], b['x0'])
+                    a['x1'] = max(a['x1'], b['x1'])
+                    rs.pop(j)
+                    changed = True
+                    break
+                if (abs(a['x0'] - b['x0']) < 0.02 and abs(a['x1'] - b['x1']) < 0.02
+                        and a['y0'] <= b['y1'] + 0.02 and b['y0'] <= a['y1'] + 0.02):
+                    a['y0'] = min(a['y0'], b['y0'])
+                    a['y1'] = max(a['y1'], b['y1'])
+                    rs.pop(j)
+                    changed = True
+                    break
+            if changed:
+                break
+    return rs
+
+
+def main():
+    colliders = json.load(open(os.path.join(SC, 'colliders.json')))
+    markers_path = os.path.join(SC, 'markers.json')
+    markers = json.load(open(markers_path)) if os.path.exists(markers_path) else []
+
+    boxes = to_aabb(colliders)
+    in_plane = [o for o in boxes if o['min'][2] <= PLANE_HI and o['max'][2] >= PLANE_LO]
+
+    terrain_layer = layer_index('Terrain')
+    if terrain_layer is None:
+        counts = collections.Counter(o['layer'] for o in in_plane if not o['trigger'])
+        terrain_layer = counts.most_common(1)[0][0] if counts else 0
+        print(f'warning: no TagManager under {UNITY_ROOT}; inferred terrain layer {terrain_layer}',
+              file=sys.stderr)
+    # Solid is Terrain plus Default — Unity's collision matrix is the default all-on, so a ship
+    # hits both, and a level's walls really can be spread across the two (in the origin game a
+    # base was enclosed by Default-layer facades, one of which carried its doorway).
+    #
+    # SHADOWS is never solid. Those are the low-poly stand-ins the original rendered only into its
+    # line-of-sight mask; they sit inside the geometry they stand in for, and making them solid
+    # seals a base shut. Unity records which copy is which as a per-instance m_Layer override, so
+    # this only became visible once those were honoured.
+    shadow_layer = layer_index('Shadows')
+    solid_layers = {terrain_layer, 0}
+
+    bases = [m for m in markers if m['kind'] == 'Base']
+    if bases:
+        bx = [b['pos'][0] for b in bases]
+        by = [b['pos'][1] for b in bases]
+        pad = 14
+        X0, X1 = min(bx) - pad, max(bx) + pad
+        Y0, Y1 = min(by) - pad, max(by) + pad
+    else:
+        xs = [o['min'][0] for o in in_plane] + [o['max'][0] for o in in_plane]
+        ys = [o['min'][1] for o in in_plane] + [o['max'][1] for o in in_plane]
+        X0, X1, Y0, Y1 = min(xs), max(xs), min(ys), max(ys)
+
+    def inside(o, pad=6):
+        return (o['max'][0] > X0 - pad and o['min'][0] < X1 + pad
+                and o['max'][1] > Y0 - pad and o['min'][1] < Y1 + pad)
+
+    def rect(o, pad=6):
+        return dict(x0=round(max(o['min'][0], X0 - pad), 2), y0=round(max(o['min'][1], Y0 - pad), 2),
+                    x1=round(min(o['max'][0], X1 + pad), 2), y1=round(min(o['max'][1], Y1 + pad), 2))
+
+    def slab(o):
+        r = rect(o, 14)
+        r['z0'] = round(o['min'][2], 2)
+        r['z1'] = round(min(o['max'][2], 40), 2)
+        return r
+
+    walls = []
+    for o in boxes:
+        if o['trigger'] or o['tag'] in BAD_TAGS or o['layer'] not in solid_layers:
+            continue
+        if shadow_layer is not None and o['layer'] == shadow_layer:
+            continue
+        if not (o['min'][2] <= PLANE_HI and o['max'][2] >= PLANE_LO) or not inside(o):
+            continue
+        r = rect(o)
+        if r['x1'] - r['x0'] < 0.15 or r['y1'] - r['y0'] < 0.15:
+            continue
+        r['tag'] = o['tag'] or 'wall'
+        # The Unity GameObject this rectangle came from. Carried all the way into ArenaData so a
+        # wall the player hits can be named in the console instead of guessed at.
+        r['name'] = o.get('name') or ''
+        walls.append(r)
+    walls = merge(walls)
+
+    back = [slab(o) for o in boxes
+            if not o['trigger'] and o['tag'] not in BAD_TAGS and o['min'][2] > PLANE_HI and inside(o)
+            and (o['max'][0] - o['min'][0]) > 0.3 and (o['max'][1] - o['min'][1]) > 0.3]
+    fore = [slab(o) for o in boxes
+            if not o['trigger'] and o['tag'] not in BAD_TAGS and o['max'][2] < PLANE_LO and inside(o)
+            and (o['max'][0] - o['min'][0]) > 0.15 and (o['max'][1] - o['min'][1]) > 0.15]
+
+    # "Over land": the origin game's land check sphere-casts from the player along +Z with
+    # radius 0.25 for 3 units, against the TERRAIN layer. So a ship is over land wherever solid
+    # terrain sits within 3 units BEHIND the gameplay plane — the raised decks the level is flown
+    # over — not where a trigger volume is. The cast is masked to TERRAIN alone, so Default-layer
+    # decoration does not count. Reduced here to the XY footprint of every terrain box whose Z span
+    # the cast would reach, which is what `Arena.isOverLand` tests against.
+    LAND_CAST_RADIUS = 0.25
+    LAND_CAST_DISTANCE = 3.0
+    # the cast starts at the player, which is at PLANE_CENTER, not at zero
+    floors = [rect(o) for o in boxes
+              if not o['trigger'] and o['tag'] not in BAD_TAGS and o['layer'] == terrain_layer
+              and o['min'][2] <= PLANE_CENTER + LAND_CAST_DISTANCE + LAND_CAST_RADIUS
+              and o['max'][2] >= PLANE_CENTER - LAND_CAST_RADIUS
+              and inside(o)]
+    floors = merge(floors)
+
+    result = dict(walls=walls, plates=[], back=back, fore=fore, floors=floors,
+                  bounds=dict(x0=round(X0, 2), y0=round(Y0, 2), x1=round(X1, 2), y1=round(Y1, 2)),
+                  terrainLayer=terrain_layer)
+    json.dump(result, open(os.path.join(SC, 'arena_parts.json'), 'w'))
+    print(f"terrain layer {terrain_layer} | walls {len(walls)} | back {len(back)} | "
+          f"fore {len(fore)} | floors {len(floors)} | bases {len(bases)}", file=sys.stderr)
+
+    if '--map' in sys.argv:
+        W, H = 118, 46
+        grid = [[' '] * W for _ in range(H)]
+
+        def paint(items, ch):
+            for o in items:
+                for gx in range(W):
+                    wx = X0 + (gx + 0.5) * (X1 - X0) / W
+                    if not (o['x0'] <= wx <= o['x1']):
+                        continue
+                    for gy in range(H):
+                        wy = Y0 + (gy + 0.5) * (Y1 - Y0) / H
+                        if o['y0'] <= wy <= o['y1']:
+                            grid[gy][gx] = ch
+        paint(back, '-')
+        paint(floors, '.')
+        paint(walls, '#')
+        for i, b in enumerate(bases):
+            gx = int((b['pos'][0] - X0) / (X1 - X0) * W)
+            gy = int((b['pos'][1] - Y0) / (Y1 - Y0) * H)
+            if 0 <= gx < W and 0 <= gy < H:
+                grid[gy][gx] = str((i + 1) % 10)
+        for row in reversed(grid):
+            print(''.join(row), file=sys.stderr)
+
+
+if __name__ == '__main__':
+    main()

package/assets/unity-import/convert_assets.py

@@ -0,0 +1,193 @@
+"""Convert the original Unity level and ship models into GLBs the engine can load.
+
+    python3 tools/convert_assets.py [prefab name ...]
+
+For each prefab: walk it for renderers (unity_renderers), resolve every material to its real
+texture files (unity_assets), then hand the lot to Blender, which imports the source FBX models
+and writes one GLB per prefab into build/glb/.
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from import_config import CFG as _CFG, unity_root as _unity_root  # noqa: E402
+UNITY = _unity_root()
+ASSETS = os.path.join(UNITY, 'Assets')
+BLENDER = '/Applications/Blender.app/Contents/MacOS/Blender'
+HERE = os.path.dirname(os.path.abspath(__file__))
+PROJECT = os.path.dirname(HERE)
+OUT_DIR = os.path.join(PROJECT, 'build', 'glb')
+SPEC_DIR = os.path.join(PROJECT, 'build', 'specs')
+
+# unity_renderers resolves the Unity project root from argv[1] at import time; take a copy of the
+# real arguments first, since that import consumes them.
+_ARGS = sys.argv[1:]
+sys.argv = [sys.argv[0], os.path.join(ASSETS, 'Scenes')]
+from fbx_axis import build_axis_map, permutation_for  # noqa: E402
+from fbx_bounds import read_fbx  # noqa: E402
+from unity_assets import build_guid_index, parse_material  # noqa: E402
+from unity_renderers import extract  # noqa: E402
+import unity_extract as _ue  # noqa: E402
+
+# Prefabs to convert when not run in scene mode (`prefabs` in unity-import.json). Marker-only
+# prefabs (spawners, force walls) are Unity primitives with no
+# model of their own, so they stay procedural.
+PREFABS = list(_CFG['prefabs'])
+
+
+# The arena is 68 units across; a few stray prefab copies sit far outside it in the scene file
+# and are never seen in play.
+ARENA_LIMIT = float(_CFG['arenaLimit'])
+
+
+def find_scene(name):
+    path = os.path.join(ASSETS, 'Scenes', name + '.unity')
+    return path if os.path.exists(path) else None
+
+
+def find_prefab(name):
+    for base, _dirs, files in os.walk(ASSETS):
+        if name + '.prefab' in files:
+            return os.path.join(base, name + '.prefab')
+    return None
+
+
+_meta_cache = {}
+
+
+def mesh_name_for(fbx, file_id):
+    """Which mesh inside a multi-mesh FBX a Unity fileID refers to.
+
+    Unity records the mapping in the model's .meta, under either the modern
+    internalIDToNameTable or the older fileIDToRecycleName.
+    """
+    if fbx not in _meta_cache:
+        table = {}
+        try:
+            with open(fbx + '.meta', encoding='utf-8', errors='ignore') as fh:
+                text = fh.read()
+        except OSError:
+            text = ''
+        for m in re.finditer(r'second: (-?\d+)\s*\n\s*second: (.+)', text):
+            table[m.group(1)] = m.group(2).strip()
+        for m in re.finditer(r'- first:\s*\n\s*(?:\d+): (-?\d+)\s*\n\s*second: (.+)', text):
+            table[m.group(1)] = m.group(2).strip()
+        for m in re.finditer(r'^\s{4}(-?\d+): (.+)$', text, re.M):
+            table[m.group(1)] = m.group(2).strip()
+        _meta_cache[fbx] = table
+    name = _meta_cache[fbx].get(str(file_id))
+    if not name or name.startswith('//'):
+        return None
+    return name
+
+
+def slug(name):
+    return re.sub(r'[^a-z0-9]+', '-', name.lower()).strip('-')
+
+
+def main():
+    wanted = _ARGS if _ARGS else PREFABS
+    os.makedirs(OUT_DIR, exist_ok=True)
+    os.makedirs(SPEC_DIR, exist_ok=True)
+    print('indexing Unity GUIDs...')
+    guid_index = build_guid_index(ASSETS)
+    print(f'  {len(guid_index)} assets')
+    # Unity's mesh axes are a per-pack permutation of the raw FBX axes; derive it from Unity's own
+    # BoxCollider sizes so the GLB and the extracted colliders agree.
+    print('deriving FBX axis corrections...')
+    axis_map = build_axis_map(_ue, ASSETS, verbose=True)
+
+    manifest = []
+    for name in wanted:
+        is_scene = name.startswith('scene:')
+        if is_scene:
+            label = name[6:]
+            path = find_scene(label)
+            if not path:
+                print(f'!! {label}: no scene found')
+                continue
+        else:
+            label = name
+            path = find_prefab(name)
+            if not path:
+                print(f'!! {name}: no prefab found')
+                continue
+        renderers = extract(path)
+        if is_scene:
+            renderers = [r for r in renderers
+                         if abs(r['pos'][0]) <= ARENA_LIMIT and abs(r['pos'][1]) <= ARENA_LIMIT]
+        # Layer 18 is Unity's SHADOWS layer: low-poly stand-ins the original rendered only into
+        # the line-of-sight mask, never to the screen.
+        visible = [r for r in renderers if r.get('layer') != 18]
+        if not visible:
+            print(f'-- {label}: nothing visible')
+            continue
+
+        mat_paths = sorted({m for r in visible for m in r['materials']})
+        materials = []
+        for mp in mat_paths:
+            parsed = parse_material(mp, guid_index)
+            if parsed:
+                parsed['path'] = mp
+                materials.append(parsed)
+
+        for r in visible:
+            r['meshName'] = mesh_name_for(r['fbx'], r['meshFileId'])
+
+        out_glb = os.path.join(OUT_DIR, slug(label) + '.glb')
+        axis = {}
+        geometric = {}
+        for r in visible:
+            perm, signs = permutation_for(r['fbx'], ASSETS, axis_map)
+            axis[r['fbx']] = {'perm': list(perm), 'signs': list(signs)}
+            if r['fbx'] not in geometric:
+                # The Model node's geometric transform, per mesh, in the file's own units. Unity
+                # bakes this into the mesh; Blender folds it into the object matrix we discard, so
+                # the GLB build has to apply it to the mesh data itself.
+                try:
+                    ms, _us = read_fbx(r['fbx'])
+                except Exception:
+                    ms = None
+                geometric[r['fbx']] = [
+                    ({k: list(v) for k, v in e[5].items() if k != '_model'} if (ms and e[5]) else None)
+                    for e in (ms or [])
+                ]
+        spec = {'name': label, 'out': out_glb, 'renderers': visible, 'materials': materials,
+                'axis': axis, 'geometric': geometric}
+        spec_path = os.path.join(SPEC_DIR, slug(label) + '.json')
+        with open(spec_path, 'w') as fh:
+            json.dump(spec, fh)
+
+        print(f'>> {label}: {len(visible)} renderers, {len(materials)} materials -> blender')
+        res = subprocess.run(
+            [BLENDER, '--background', '--python', os.path.join(HERE, 'blender_build.py'),
+             '--', spec_path],
+            capture_output=True, text=True,
+        )
+        tail = [ln for ln in res.stdout.splitlines()
+                if ln.startswith(('PLACED', 'EXPORTED', 'FBXFAIL'))]
+        for ln in tail:
+            print('   ', ln)
+        if not os.path.exists(out_glb):
+            print('   !! no GLB produced')
+            print(res.stdout[-2500:])
+            print(res.stderr[-2500:])
+            continue
+        manifest.append({'name': label, 'glb': out_glb, 'size': os.path.getsize(out_glb)})
+
+    print()
+    total = 0
+    for m in manifest:
+        print(f"  {m['size']/1e6:7.2f} MB  {os.path.basename(m['glb'])}")
+        total += m['size']
+    print(f"  {total/1e6:7.2f} MB  TOTAL")
+    with open(os.path.join(OUT_DIR, 'manifest.json'), 'w') as fh:
+        json.dump(manifest, fh, indent=1)
+
+
+if __name__ == '__main__':
+    main()

package/assets/unity-import/fbx_ascii.py

@@ -0,0 +1,156 @@
+"""Reader for ASCII FBX 6100 — an old text format some model packs still use (the origin game's ship packs, for one).
+
+Blender dropped ASCII FBX support, and all three ship packs were exported from Blender 2.71 in
+FBX 6.1.0 text form, so `import_scene.fbx` refuses them outright. The format is plain text and the
+meshes are simple (one geometry, one material, no rig), so it is cheaper to read the handful of
+arrays that matter than to bring in a converter.
+
+Returns meshes in FBX axes and units; the caller converts. `blender_build.py` maps them the same
+way Blender's own importer maps a binary FBX, which measurement showed to be (x, z, y) scaled by
+the file's UnitScaleFactor/100 — no sign flips.
+"""
+import re
+
+# A value block runs from `Key:` to the next key or the closing brace of its parent.
+_UNTIL_NEXT_KEY = r'(?=\n\s*[A-Za-z_][\w ]*:|\n\s*\})'
+
+
+def _array(text, key):
+    m = re.search(r'\n\s*' + re.escape(key) + r':[ \t]*(.*?)' + _UNTIL_NEXT_KEY, text, re.S)
+    if not m:
+        return []
+    out = []
+    for tok in m.group(1).split(','):
+        tok = tok.strip()
+        if not tok:
+            continue
+        try:
+            out.append(float(tok))
+        except ValueError:
+            pass
+    return out
+
+
+def _string(text, key):
+    m = re.search(r'\n\s*' + re.escape(key) + r':[ \t]*"([^"]*)"', text)
+    return m.group(1) if m else None
+
+
+def _blocks(text, header_re):
+    """Every `Name ... {` block matching header_re, sliced by brace depth."""
+    for m in re.finditer(header_re, text):
+        start = text.find('{', m.end() - 1)
+        if start < 0:
+            continue
+        depth = 0
+        for i in range(start, len(text)):
+            c = text[i]
+            if c == '{':
+                depth += 1
+            elif c == '}':
+                depth -= 1
+                if depth == 0:
+                    yield m, text[start + 1:i]
+                    break
+
+
+def _prop(text, name, count):
+    """A Properties60 entry: Property: "Lcl Translation", "...", "A+",x,y,z"""
+    m = re.search(r'Property:\s*"' + re.escape(name) + r'"\s*,[^,]*,[^,]*,(.*)', text)
+    if not m:
+        return None
+    vals = []
+    for tok in m.group(1).split(','):
+        tok = tok.strip()
+        try:
+            vals.append(float(tok))
+        except ValueError:
+            pass
+    return vals[:count] if len(vals) >= count else None
+
+
+def unit_scale(text):
+    v = _prop(text, 'UnitScaleFactor', 1)
+    return v[0] if v else 1.0
+
+
+def read_ascii_fbx(path):
+    """Parse the mesh models out of an ASCII FBX. Returns (meshes, unit_scale_factor)."""
+    with open(path, encoding='utf-8', errors='ignore') as fh:
+        text = fh.read()
+    if 'Kaydara' in text[:64]:
+        raise ValueError('binary FBX passed to the ASCII reader')
+
+    meshes = []
+    seen = set()
+    for m, body in _blocks(text, r'\n\s*Model:\s*"Model::([^"]+)"\s*,\s*"Mesh"\s*'):
+        name = m.group(1)
+        verts = _array(body, 'Vertices')
+        idx = _array(body, 'PolygonVertexIndex')
+        # The Relations section repeats every Model header with an empty body.
+        if not verts or not idx or name in seen:
+            continue
+        seen.add(name)
+
+        polys = []
+        cur = []
+        for raw in idx:
+            i = int(raw)
+            if i < 0:
+                cur.append(-i - 1)
+                if len(cur) >= 3:
+                    polys.append(cur)
+                cur = []
+            else:
+                cur.append(i)
+
+        normals = []
+        nmap = nref = None
+        for _nm, nbody in _blocks(body, r'\n\s*LayerElementNormal:\s*\d+\s*'):
+            normals = _array(nbody, 'Normals')
+            nmap = _string(nbody, 'MappingInformationType')
+            nref = _string(nbody, 'ReferenceInformationType')
+            break
+
+        uvs = []
+        uv_index = []
+        umap = uref = None
+        for _um, ubody in _blocks(body, r'\n\s*LayerElementUV:\s*\d+\s*'):
+            uvs = _array(ubody, 'UV')
+            uv_index = [int(v) for v in _array(ubody, 'UVIndex')]
+            umap = _string(ubody, 'MappingInformationType')
+            uref = _string(ubody, 'ReferenceInformationType')
+            break
+
+        meshes.append({
+            'name': name,
+            'verts': [(verts[i], verts[i + 1], verts[i + 2]) for i in range(0, len(verts) - 2, 3)],
+            'polys': polys,
+            'normals': normals,
+            'normalMapping': nmap,
+            'normalReference': nref,
+            'uvs': uvs,
+            'uvIndex': uv_index,
+            'uvMapping': umap,
+            'uvReference': uref,
+            'translation': _prop(body, 'Lcl Translation', 3) or [0.0, 0.0, 0.0],
+            'rotation': _prop(body, 'Lcl Rotation', 3) or [0.0, 0.0, 0.0],
+            'scaling': _prop(body, 'Lcl Scaling', 3) or [1.0, 1.0, 1.0],
+        })
+
+    return meshes, unit_scale(text)
+
+
+if __name__ == '__main__':
+    import sys
+    ms, us = read_ascii_fbx(sys.argv[1])
+    print(f'unit scale {us}, {len(ms)} meshes')
+    for mesh in ms:
+        vs = mesh['verts']
+        if not vs:
+            continue
+        mn = [min(v[i] for v in vs) for i in range(3)]
+        mx = [max(v[i] for v in vs) for i in range(3)]
+        print(f"  {mesh['name']}: {len(vs)} verts, {len(mesh['polys'])} polys, "
+              f"uv={len(mesh['uvs'])//2} ({mesh['uvMapping']}/{mesh['uvReference']}), "
+              f"bounds {[round(a,2) for a in mn]}..{[round(a,2) for a in mx]}")