@bitmagic/cli 0.1.61 → 0.1.62-dev.0

package/assets/unity-import/unity_extract.py

@@ -0,0 +1,774 @@
+import re, os, json, math, sys
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from fbx_bounds import read_fbx
+
+_meshcache = {}
+_metaidx = {}
+
+
+def mesh_index_for(fbx_path, file_id):
+    """Which mesh inside a multi-mesh FBX a MeshFilter's fileID refers to.
+
+    A model file can hold many meshes — one statue pack here held eight statues spread over 141
+    units — and a MeshFilter picks exactly one. Unioning them all gives an object the size of the
+    whole collection, centred on the collection's centroid: the statue came out 141 units long and
+    10.8 units off the origin it is placed at.
+
+    Unity's .meta lists each mesh by fileID in the file's own order, so the position of this fileID
+    among the 43000xx (Mesh class) entries is the index of the mesh to use.
+    """
+    if fbx_path not in _metaidx:
+        order = []
+        try:
+            with open(fbx_path + '.meta', encoding='utf-8', errors='ignore') as fh:
+                text = fh.read()
+        except OSError:
+            text = ''
+        for m in re.finditer(r'^\s{4}(43000\d\d): (.+)$', text, re.M):
+            name = m.group(2).strip()
+            if not name.startswith('//'):
+                order.append(m.group(1))
+        _metaidx[fbx_path] = {fid: i for i, fid in enumerate(sorted(order, key=int))}
+    return _metaidx[fbx_path].get(str(file_id))
+
+
+_axis_map = None
+_axis_ready = False
+
+def _axis():
+    """Unity's mesh axes are not always the raw FBX axes; derive the per-pack correction once."""
+    global _axis_map, _axis_ready
+    if not _axis_ready:
+        _axis_ready = True   # set first: build_axis_map calls back into mesh_bounds_raw
+        try:
+            from fbx_axis import build_axis_map
+            _axis_map = build_axis_map(sys.modules[__name__], os.path.join(ROOT, 'Assets'))
+        except Exception as exc:
+            print(f'warning: could not derive FBX axis map ({exc}); assuming identity', file=sys.stderr)
+            _axis_map = {}
+    return _axis_map
+
+def mesh_bounds(guid, guid2path, file_id=None):
+    """Mesh bounds in UNITY's mesh space, which may be a permutation of the raw FBX axes."""
+    res = mesh_bounds_raw(guid, guid2path, file_id)
+    if not res: return res
+    p = guid2path.get(guid)
+    if not p: return res
+    # fbx_bounds.read_fbx already delivers Unity's mesh: geometric transform applied and X negated.
+    # Applying any further axis change here would double it.
+    return res
+
+# The depth band the player occupies, in Unity's Z. PLANE_HALF is the player's collider radius.
+#
+# PLANE_CENTER is NOT zero, and that was the bug behind "I collide with air where I can see an
+# opening". The arena's walls are building facades with archways cut through them, and those
+# archways sit at z -5..0 with the lintel from 0 up — a ship sliced at z=0 meets the lintel and
+# every base seals shut (a depth sweep on the corrected geometry: base reachability 0.8% at z 0
+# and -0.5). Between -2.5 and -1.0 the wall cross-section was flat in the origin game (~68 units² either
+# way); -1 sits in the walls' densest band (41% of their area lies in -1..0) and every base reaches
+# 100% of the level there, so that was the plane. Measure yours the same way: slice at a few
+# depths and pick the one where walls are flat and every spawn reaches everything.
+#
+# `planeZ` in unity-import.json; re-measure if the level changes.
+#
+# NOTE: for a 2D-physics game walls do not come from this slice at all — the player collides with Unity's 2D colliders
+# (see unity_colliders2d.py). This band now only classifies backdrop/foreground and the land-check
+# floors.
+from import_config import CFG as _CFG, scene_path as scene_path_from_config
+PLANE_HALF = float(_CFG['planeHalf'])
+PLANE_CENTER = float(_CFG['planeZ'])
+
+_vertcache = {}
+
+def mesh_geometry(guid, guid2path, file_id=None):
+    """(vertices in Unity mesh space, triangle index triples) for a model, or None."""
+    key = ('geo', guid, file_id)
+    if key in _vertcache: return _vertcache[key]
+    res = None
+    p = guid2path.get(guid)
+    if p and os.path.exists(p) and p.lower().endswith('.fbx'):
+        try:
+            r = read_fbx(p, keep_vertices=True)
+            if r:
+                ms, us = r
+                gscale, usefile = 1.0, True
+                meta = p + '.meta'
+                if os.path.exists(meta):
+                    t = open(meta, encoding='utf-8', errors='ignore').read()
+                    m1 = re.search(r'globalScale: ([-\d.eE+]+)', t)
+                    if m1: gscale = float(m1.group(1))
+                    m2 = re.search(r'useFileScale: (\d)', t)
+                    if m2: usefile = m2.group(1) == '1'
+                sc = gscale * ((us / 100.0) if (usefile and us) else 1.0)
+                tf = None   # reader output is already Unity's mesh; see mesh_bounds
+                want = mesh_index_for(p, file_id) if file_id is not None else None
+                verts, tris, base = [], [], 0
+                for mi, entry in enumerate(ms):
+                    if want is not None and mi != want:
+                        continue
+                    ev = entry[3] if len(entry) > 3 else None
+                    ei = entry[4] if len(entry) > 4 else None
+                    if not ev: continue
+                    verts.extend(tuple(v * sc for v in pt) for pt in ev)
+                    if ei:
+                        face = []
+                        for raw in ei:
+                            i = int(raw)
+                            if i < 0:
+                                face.append(-i - 1)
+                                for k in range(1, len(face) - 1):   # fan-triangulate
+                                    tris.append((base + face[0], base + face[k], base + face[k + 1]))
+                                face = []
+                            else:
+                                face.append(i)
+                    base += len(ev)
+                if verts: res = (verts, tris)
+        except Exception:
+            res = None
+    _vertcache[key] = res
+    return res
+
+
+def mesh_vertices(guid, guid2path):
+    """Mesh vertices in UNITY's mesh space, or None."""
+    if guid in _vertcache: return _vertcache[guid]
+    res = None
+    p = guid2path.get(guid)
+    if p and os.path.exists(p) and p.lower().endswith('.fbx'):
+        try:
+            r = read_fbx(p, keep_vertices=True)
+            if r:
+                ms, us = r
+                pts = []
+                for entry in ms:
+                    if len(entry) > 3 and entry[3]:
+                        pts.extend(entry[3])
+                if pts:
+                    gscale, usefile = 1.0, True
+                    meta = p + '.meta'
+                    if os.path.exists(meta):
+                        t = open(meta, encoding='utf-8', errors='ignore').read()
+                        m1 = re.search(r'globalScale: ([-\d.eE+]+)', t)
+                        if m1: gscale = float(m1.group(1))
+                        m2 = re.search(r'useFileScale: (\d)', t)
+                        if m2: usefile = m2.group(1) == '1'
+                    sc = gscale * ((us / 100.0) if (usefile and us) else 1.0)
+                    res = [tuple(v * sc for v in pt) for pt in pts]
+        except Exception:
+            res = None
+    _vertcache[guid] = res
+    return res
+
+
+# How finely a mesh's cross-section is traced. Small enough to keep a doorway open, coarse enough
+# that a whole level's worth of geometry stays cheap.
+SLICE_CELL = 0.5
+
+
+def _clip_to_slab(tri, lo, hi):
+    """Clip a triangle to the slab lo <= z <= hi. Returns a convex polygon, possibly empty."""
+    poly = list(tri)
+    for sign, bound in ((1.0, hi), (-1.0, lo)):
+        out = []
+        n = len(poly)
+        for i in range(n):
+            a = poly[i]
+            b = poly[(i + 1) % n]
+            da = sign * (a[2] - bound)
+            db = sign * (b[2] - bound)
+            if da <= 0:
+                out.append(a)
+            if (da <= 0) != (db <= 0):
+                t = da / (da - db)
+                out.append((a[0] + (b[0] - a[0]) * t,
+                            a[1] + (b[1] - a[1]) * t,
+                            a[2] + (b[2] - a[2]) * t))
+        poly = out
+        if not poly:
+            return []
+    return poly
+
+
+def _point_in_poly(px, py, poly):
+    inside = False
+    n = len(poly)
+    for i in range(n):
+        x0, y0 = poly[i][0], poly[i][1]
+        x1, y1 = poly[(i + 1) % n][0], poly[(i + 1) % n][1]
+        if (y0 > py) != (y1 > py):
+            xx = x0 + (py - y0) * (x1 - x0) / (y1 - y0)
+            if xx > px:
+                inside = not inside
+    return inside
+
+
+def mesh_plane_rects(guid, world, file_id=None):
+    """The XY rectangles a MeshCollider actually occupies AT the gameplay plane, in world space.
+
+    Two things matter here, and both were learned from walls that behaved wrongly in play:
+
+    * A MeshCollider collides with triangles, not with its bounding box, and these walls are
+      building facades with doorways cut through them. Reducing one to a rectangle paves the
+      doorway over and seals a ship inside its base.
+    * A triangle that *crosses* the plane must be clipped TO the plane before its footprint is
+      taken. A facade panel runs from z=-6 to z=+2; only a thin band of it is at the height a ship
+      flies at, but its full XY extent spans the doorway. Rasterising the whole triangle therefore
+      fills the opening back in even though nothing is there at the player's level — which is what
+      put walls across the gaps either side of every base.
+
+    So each triangle is clipped to the slab the player occupies, and only what survives is rasterised.
+    Returns None when nothing reaches the plane.
+    """
+    geo = mesh_geometry(guid, guid2path, file_id)
+    if not geo:
+        return None
+    verts, tris = geo
+    if not tris:
+        return None
+    (p, q, sc) = world
+
+    def to_world(v):
+        rv = qrot(q, (v[0] * sc[0], v[1] * sc[1], v[2] * sc[2]))
+        return (p[0] + rv[0], p[1] + rv[1], p[2] + rv[2])
+
+    cells = set()
+    nv = len(verts)
+    for (ia, ib, ic) in tris:
+        if ia >= nv or ib >= nv or ic >= nv:
+            continue
+        a, b, c = to_world(verts[ia]), to_world(verts[ib]), to_world(verts[ic])
+        if (min(a[2], b[2], c[2]) > PLANE_CENTER + PLANE_HALF
+                or max(a[2], b[2], c[2]) < PLANE_CENTER - PLANE_HALF):
+            continue
+        poly = _clip_to_slab((a, b, c), PLANE_CENTER - PLANE_HALF, PLANE_CENTER + PLANE_HALF)
+        if len(poly) < 2:
+            continue
+
+        xs = [v[0] for v in poly]
+        ys = [v[1] for v in poly]
+        gx0 = int(math.floor(min(xs) / SLICE_CELL)); gx1 = int(math.floor(max(xs) / SLICE_CELL))
+        gy0 = int(math.floor(min(ys) / SLICE_CELL)); gy1 = int(math.floor(max(ys) / SLICE_CELL))
+        if (gx1 - gx0) > 400 or (gy1 - gy0) > 400:
+            continue
+
+        # Edges first: a clipped triangle is often a sliver whose cell centres all miss.
+        n = len(poly)
+        for i in range(n):
+            x0, y0 = poly[i][0], poly[i][1]
+            x1, y1 = poly[(i + 1) % n][0], poly[(i + 1) % n][1]
+            steps = int(max(abs(x1 - x0), abs(y1 - y0)) / (SLICE_CELL * 0.5)) + 1
+            for k in range(steps + 1):
+                t = k / steps
+                cells.add((int(math.floor((x0 + (x1 - x0) * t) / SLICE_CELL)),
+                           int(math.floor((y0 + (y1 - y0) * t) / SLICE_CELL))))
+        # Then the interior.
+        if n >= 3 and (gx1 - gx0) + (gy1 - gy0) > 1:
+            for gx in range(gx0, gx1 + 1):
+                for gy in range(gy0, gy1 + 1):
+                    if (gx, gy) in cells:
+                        continue
+                    if _point_in_poly((gx + 0.5) * SLICE_CELL, (gy + 0.5) * SLICE_CELL, poly):
+                        cells.add((gx, gy))
+
+    if not cells:
+        return None
+
+    rows = {}
+    for (gx, gy) in cells:
+        rows.setdefault(gy, []).append(gx)
+    out = []
+    for gy, xs in rows.items():
+        xs.sort()
+        start = prev = xs[0]
+        for x in xs[1:] + [None]:
+            if x is not None and x == prev + 1:
+                prev = x
+                continue
+            out.append((start * SLICE_CELL, gy * SLICE_CELL,
+                        (prev + 1) * SLICE_CELL, (gy + 1) * SLICE_CELL))
+            if x is None:
+                break
+            start = prev = x
+    return out
+
+
+def mesh_bounds_raw(guid, guid2path, file_id=None):
+    key = (guid, file_id)
+    if key in _meshcache: return _meshcache[key]
+    p = guid2path.get(guid)
+    res = None
+    if p and os.path.exists(p) and p.lower().endswith(('.fbx',)):
+        try:
+            r = read_fbx(p)
+            if r:
+                ms, us = r
+                # One model file can hold many meshes; a MeshFilter picks exactly one by fileID.
+                want = mesh_index_for(p, file_id) if file_id is not None else None
+                if want is not None and want < len(ms):
+                    ms = [ms[want]]
+                if ms:
+                    mn = [min(m[1][k] for m in ms) for k in range(3)]
+                    mx = [max(m[2][k] for m in ms) for k in range(3)]
+                    scale = 1.0
+                    meta = p + '.meta'
+                    gscale = 1.0; usefile = True
+                    if os.path.exists(meta):
+                        t = open(meta, encoding='utf-8', errors='ignore').read()
+                        m1 = re.search(r'globalScale: ([-\d.eE+]+)', t)
+                        if m1: gscale = float(m1.group(1))
+                        m2 = re.search(r'useFileScale: (\d)', t)
+                        if m2: usefile = m2.group(1) == '1'
+                    fs = (us / 100.0) if (usefile and us) else 1.0
+                    scale = gscale * fs
+                    res = ([v*scale for v in mn], [v*scale for v in mx])
+        except Exception as e:
+            res = None
+    _meshcache[key] = res
+    return res
+
+
+def _find_unity_root(start):
+    """Walk up from the scene file to the folder that holds `Assets/`."""
+    d = os.path.dirname(os.path.abspath(start))
+    while d != os.path.dirname(d):
+        if os.path.isdir(os.path.join(d, 'Assets')):
+            return d
+        d = os.path.dirname(d)
+    raise SystemExit('could not find the Unity project root above ' + start)
+
+
+_SCENE = sys.argv[1] if len(sys.argv) > 1 else os.path.join(os.path.expanduser(_CFG['unityRoot']), _CFG['scene'])
+ROOT = _find_unity_root(_SCENE)
+
+# ---------- guid map ----------
+guid2path = {}
+for root, dirs, files in os.walk(os.path.join(ROOT, 'Assets')):
+    for f in files:
+        if f.endswith('.meta'):
+            p = os.path.join(root, f)
+            try:
+                t = open(p, encoding='utf-8', errors='ignore').read(500)
+            except Exception:
+                continue
+            m = re.search(r'guid: ([0-9a-f]{32})', t)
+            if m:
+                guid2path[m.group(1)] = p[:-5]
+
+DOC_RE = re.compile(r'\n--- !u!(\d+) &(\d+)(?: stripped)?\n')
+
+_cache = {}
+def parse_file(path):
+    if path in _cache: return _cache[path]
+    try:
+        txt = open(path, encoding='utf-8', errors='ignore').read()
+    except Exception:
+        _cache[path] = {}
+        return {}
+    parts = DOC_RE.split(txt)
+    docs = {}
+    i = 1
+    while i + 2 <= len(parts) - 1:
+        docs[parts[i+1]] = (parts[i], parts[i+2])
+        i += 3
+    _cache[path] = docs
+    return docs
+
+# ---------- math ----------
+def qmul(a, b):
+    ax,ay,az,aw=a; bx,by,bz,bw=b
+    return (aw*bx+ax*bw+ay*bz-az*by,
+            aw*by-ax*bz+ay*bw+az*bx,
+            aw*bz+ax*by-ay*bx+az*bw,
+            aw*bw-ax*bx-ay*by-az*bz)
+def qrot(q, v):
+    x,y,z,w=q; vx,vy,vz=v
+    # t = 2*q_vec x 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 compose(parent, local):
+    # parent/local = (pos, rot, scale)
+    pp, pr, ps = parent
+    lp, lr, ls = local
+    sp = (lp[0]*ps[0], lp[1]*ps[1], lp[2]*ps[2])
+    rp = qrot(pr, sp)
+    pos = (pp[0]+rp[0], pp[1]+rp[1], pp[2]+rp[2])
+    rot = qmul(pr, lr)
+    scale = (ps[0]*ls[0], ps[1]*ls[1], ps[2]*ls[2])
+    return (pos, rot, scale)
+
+def quat_euler_z(q):
+    x,y,z,w = q
+    return math.degrees(math.atan2(2*(w*z+x*y), 1-2*(y*y+z*z)))
+
+def vec3(body, key, default):
+    m = re.search(re.escape(key) + r': \{x: ([-\d.eE+]+), y: ([-\d.eE+]+), z: ([-\d.eE+]+)\}', body)
+    return (float(m.group(1)), float(m.group(2)), float(m.group(3))) if m else default
+
+def quat(body, key):
+    m = re.search(re.escape(key) + r': \{x: ([-\d.eE+]+), y: ([-\d.eE+]+), z: ([-\d.eE+]+), w: ([-\d.eE+]+)\}', body)
+    return (float(m.group(1)), float(m.group(2)), float(m.group(3)), float(m.group(4))) if m else (0.0,0.0,0.0,1.0)
+
+def fid(body, key):
+    m = re.search(re.escape(key) + r': \{fileID: (-?\d+)', body)
+    return m.group(1) if m else '0'
+
+MAX_DEPTH = 8
+
+# ---------- level patches (see tools/level_patches.json) ----------
+def _load_patches():
+    path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'level_patches.json')
+    try:
+        return json.load(open(path))
+    except Exception:
+        return {"add_instances": [], "remove_instances": []}
+LEVEL_PATCHES = _load_patches()
+
+def patch_skips_instance(prefab_name, world_pos):
+    """True when a level patch removes this scene instance (matched by prefab and position)."""
+    for r in LEVEL_PATCHES.get('remove_instances', []):
+        if r.get('prefab') == prefab_name and 'near' in r:
+            if abs(world_pos[0] - r['near'][0]) < 2.0 and abs(world_pos[1] - r['near'][1]) < 2.0:
+                return True
+    return False
+
+def patch_move_for(object_name, world_pos):
+    """Offset a scene object by a `move_objects` patch entry, or (0,0,0).
+
+    `{"name": "CornerTowerTopLeft", "toward_center": 3.0}` slides the object 3 units toward
+    the map centre on each horizontal axis (sign taken from its own position), so a corner block
+    overlaps the wall runs it is meant to close. `"dpos": [x, y, z]` is an explicit offset.
+    """
+    for m in LEVEL_PATCHES.get('move_objects', []) or []:
+        if m.get('name') != object_name: continue
+        if 'dpos' in m:
+            d = m['dpos']; return (float(d[0]), float(d[1]), float(d[2]) if len(d) > 2 else 0.0)
+        t = float(m.get('toward_center', 0.0))
+        sx = -1.0 if world_pos[0] > 0 else (1.0 if world_pos[0] < 0 else 0.0)
+        sy = -1.0 if world_pos[1] > 0 else (1.0 if world_pos[1] < 0 else 0.0)
+        return (sx * t, sy * t, 0.0)
+    return (0.0, 0.0, 0.0)
+
+def patch_added_instances(prefab_name):
+    """Extra scene-level placements a level patch adds for this prefab: [(pos, quat)]."""
+    out = []
+    for a in LEVEL_PATCHES.get('add_instances', []):
+        if a.get('prefab') == prefab_name:
+            zr = math.radians(a.get('zrot', 0.0)) / 2.0
+            out.append((tuple(a['pos']), (0.0, 0.0, math.sin(zr), math.cos(zr))))
+    return out
+
+results = []   # collected colliders
+visited_gos = set()   # (file path, gameObject fileID) actually walked
+
+def parse_mods(body):
+    """Return dict: targetFileID -> {property: value} and prefab guid overrides."""
+    mods = {}
+    # each modification entry
+    for m in re.finditer(r'- target: \{fileID: (-?\d+), guid: ([0-9a-f]{32}), type: \d+\}\s*\n\s*propertyPath: (\S+)\s*\n\s*value: (.*?)\n\s*objectReference:', body):
+        tgt, guid, prop, val = m.group(1), m.group(2), m.group(3), m.group(4).strip()
+        mods.setdefault((guid, tgt), {})[prop] = val
+    return mods
+
+def local_trs(body):
+    return (vec3(body, 'm_LocalPosition', (0,0,0)),
+            quat(body, 'm_LocalRotation'),
+            vec3(body, 'm_LocalScale', (1,1,1)))
+
+def apply_mods(trs, mod):
+    (p, r, s) = trs
+    p = list(p); r = list(r); s = list(s)
+    for k, v in mod.items():
+        try: fv = float(v)
+        except Exception: continue
+        if k == 'm_LocalPosition.x': p[0]=fv
+        elif k == 'm_LocalPosition.y': p[1]=fv
+        elif k == 'm_LocalPosition.z': p[2]=fv
+        elif k == 'm_LocalRotation.x': r[0]=fv
+        elif k == 'm_LocalRotation.y': r[1]=fv
+        elif k == 'm_LocalRotation.z': r[2]=fv
+        elif k == 'm_LocalRotation.w': r[3]=fv
+        elif k == 'm_LocalScale.x': s[0]=fv
+        elif k == 'm_LocalScale.y': s[1]=fv
+        elif k == 'm_LocalScale.z': s[2]=fv
+    return (tuple(p), tuple(r), tuple(s))
+
+def go_name(docs, goid):
+    d = docs.get(goid)
+    if not d: return ''
+    m = re.search(r'm_Name: (.*)', d[1])
+    return m.group(1).strip() if m else ''
+
+def go_active(docs, goid, mods=None):
+    """Is this GameObject active — honouring the prefab instance's m_IsActive override.
+
+    A scene can switch whole prefab instances off this way (in the scene this was built on, two
+    wall prefabs were root-inactive in every placement), so reading the source prefab alone
+    builds a level Unity never shows.
+    """
+    if mods:
+        over = mods.get(goid, {}).get('m_IsActive')
+        if over is not None: return str(over).strip() == '1'
+    d = docs.get(goid)
+    if not d: return True
+    m = re.search(r'm_IsActive: (\d)', d[1])
+    return (m.group(1) == '1') if m else True
+
+def comp_enabled(cbody, cid=None, mods=None):
+    """A component's m_Enabled, honouring the instance override that targets it."""
+    if mods and cid is not None:
+        over = mods.get(cid, {}).get('m_Enabled')
+        if over is not None: return str(over).strip() == '1'
+    m = re.search(r'm_Enabled: (\d)', cbody)
+    return (m.group(1) == '1') if m else True
+
+NESTED_ID_MASK = 0x7FFFFFFFFFFFFFFF
+
+def instance_mods(body, docs, pid, pdocs, outer_mods=None):
+    """The modification map a prefab instance applies to its source file.
+
+    Overrides written on the instance itself come from its m_Modifications. Overrides that an
+    OUTER instance wrote against objects inside this nested one are keyed, in the outer file's
+    namespace, by (nestedObjectFileID ^ nestedInstanceFileID) & 0x7FFF..., so they are
+    re-keyed here into the nested file's own ids. Verified on the origin scene: an instance's
+    m_Enabled override resolved to a MeshCollider inside a nested prefab, exactly as Unity shows it.
+    """
+    modmap = {}
+    for (_g, t), props in parse_mods(body).items():
+        modmap.setdefault(t, {}).update(props)
+    if outer_mods:
+        try: p_int = int(pid)
+        except ValueError: return modmap
+        pending = {t: props for t, props in outer_mods.items() if t not in docs}
+        if pending:
+            for oid in pdocs:
+                try: comp = (int(oid) ^ p_int) & NESTED_ID_MASK
+                except ValueError: continue
+                props = pending.get(str(comp))
+                if props: modmap.setdefault(oid, {}).update(props)
+    return modmap
+
+def go_layer(docs, goid, mods=None):
+    """A GameObject's collision layer, honouring the instance's override.
+
+    Unity stores "this copy lives on Terrain" as an `m_Layer` modification on the prefab instance,
+    not in the source prefab, so reading the source alone reports every piece as Default and the
+    real wall set disappears into the decoration.
+    """
+    if mods:
+        over = mods.get(goid, {}).get('m_Layer')
+        if over is not None:
+            try: return int(float(over))
+            except ValueError: pass
+    d = docs.get(goid)
+    if not d: return 0
+    m = re.search(r'm_Layer: (\d+)', d[1])
+    return int(m.group(1)) if m else 0
+
+def walk(path, docs, tid, world, depth, mods_for_file, tag):
+    """Walk transform tid in file `path`, world = parent world TRS."""
+    if depth > MAX_DEPTH: return
+    cls, body = docs[tid]
+    if cls == '1001':
+        # nested prefab instance
+        handle_prefab_instance(path, docs, tid, body, world, depth, mods_for_file, tag)
+        return
+    if 'm_LocalPosition' not in body:
+        return   # stripped stub for a nested prefab; expand_file/sweep_orphan_colliders place it
+    trs = local_trs(body)
+    key = mods_for_file.get(tid)
+    if key: trs = apply_mods(trs, key)
+    w = compose(world, trs)
+    goid = fid(body, 'm_GameObject')
+    if not go_active(docs, goid, mods_for_file):
+        return
+    name = go_name(docs, goid)
+    layer = go_layer(docs, goid, mods_for_file)
+    visited_gos.add((path, goid))
+    # find components on this GameObject
+    gd = docs.get(goid)
+    if gd:
+        for m in re.finditer(r'- component: \{fileID: (\d+)\}', gd[1]):
+            cid = m.group(1)
+            cd = docs.get(cid)
+            if not cd: continue
+            ccls, cbody = cd
+            if ccls == '65':  # BoxCollider
+                if not comp_enabled(cbody, cid, mods_for_file): continue
+                size = vec3(cbody, 'm_Size', (1,1,1))
+                center = vec3(cbody, 'm_Center', (0,0,0))
+                trig = re.search(r'm_IsTrigger: (\d)', cbody)
+                results.append(dict(kind='box', name=name, tag=tag, layer=layer,
+                                    world=w, size=size, center=center,
+                                    trigger=(trig.group(1)=='1') if trig else False))
+            elif ccls == '64':  # MeshCollider
+                if not comp_enabled(cbody, cid, mods_for_file): continue
+                mm = re.search(r'm_Mesh: \{fileID: (-?\d+), guid: ([0-9a-f]{32})', cbody)
+                if not mm: continue
+                rects = mesh_plane_rects(mm.group(2), w, mm.group(1))
+                if rects is not None:
+                    for (rx0, ry0, rx1, ry1) in rects:
+                        cw = ((rx0 + rx1) / 2, (ry0 + ry1) / 2, PLANE_CENTER)
+                        results.append(dict(kind='box', name=name, tag=tag, layer=layer,
+                                            world=(cw, (0.0, 0.0, 0.0, 1.0), (1.0, 1.0, 1.0)),
+                                            size=(rx1 - rx0, ry1 - ry0, 2 * PLANE_HALF),
+                                            center=(0.0, 0.0, 0.0), trigger=False, src='mesh'))
+                    continue
+                mb = mesh_bounds(mm.group(2), guid2path, mm.group(1))
+                if not mb: continue
+                mn, mx = mb
+                if mn[2] > PLANE_CENTER + PLANE_HALF or mx[2] < PLANE_CENTER - PLANE_HALF:
+                    pass
+                size = (mx[0]-mn[0], mx[1]-mn[1], mx[2]-mn[2])
+                center = ((mx[0]+mn[0])/2, (mx[1]+mn[1])/2, (mx[2]+mn[2])/2)
+                results.append(dict(kind='box', name=name, tag=tag, layer=layer,
+                                    world=w, size=size, center=center, trigger=False, src='meshbox'))
+            elif ccls == '135':  # SphereCollider
+                if not comp_enabled(cbody, cid, mods_for_file): continue
+                rad = re.search(r'm_Radius: ([-\d.eE+]+)', cbody)
+                center = vec3(cbody, 'm_Center', (0,0,0))
+                trig = re.search(r'm_IsTrigger: (\d)', cbody)
+                results.append(dict(kind='sphere', name=name, tag=tag, layer=layer,
+                                    world=w, radius=float(rad.group(1)) if rad else 0.5,
+                                    center=center, trigger=(trig.group(1)=='1') if trig else False))
+    # children
+    for m in re.finditer(r'- \{fileID: (\d+)\}', body[body.find('m_Children:'):body.find('m_Father:')] if 'm_Children:' in body and 'm_Father:' in body else ''):
+        cid = m.group(1)
+        if cid in docs:
+            walk(path, docs, cid, w, depth+1, mods_for_file, tag)
+
+def handle_prefab_instance(path, docs, tid, body, world, depth, outer_mods, tag):
+    if depth > MAX_DEPTH: return
+    m = re.search(r'm_SourcePrefab: \{fileID: \d+, guid: ([0-9a-f]{32})', body)
+    if not m: return
+    src = guid2path.get(m.group(1))
+    if not src or not os.path.exists(src): return
+    pdocs = parse_file(src)
+    if not pdocs: return
+    modmap = instance_mods(body, docs, tid, pdocs, outer_mods)
+    # find prefab root transform: the transform with m_Father 0
+    root = None
+    for pid, (pcls, pbody) in pdocs.items():
+        if pcls in ('4',) and fid(pbody, 'm_Father') == '0':
+            root = pid; break
+    if root is None:
+        for pid, (pcls, pbody) in pdocs.items():
+            if pcls == '1001':
+                root = pid; break
+    if root is None: return
+    newtag = tag or os.path.basename(src).replace('.prefab','')
+    expand_file(src, pdocs, world, depth+1, modmap, newtag)
+    # Orphan colliders are stored relative to the prefab ROOT, so they need the root's world
+    # transform (parent chain + this instance's own placement), not the parent's.
+    root_world = world
+    rcls, rbody = pdocs[root]
+    if rcls == '4':
+        root_world = compose(world, apply_mods(local_trs(rbody), modmap.get(root, {})))
+    sweep_orphan_colliders(src, pdocs, root_world, newtag)
+
+
+def expand_file(path, docs, world, depth, mods, tag):
+    """Every collider one file places: its root transforms, then its own nested prefab instances.
+
+    The second half is what was missing. A nested instance is listed in its parent's m_Children only
+    as a stripped stub the transform walk cannot follow, so a prefab assembled out of other prefabs
+    contributed only the colliders stored directly in its own file — one prefab arrived with no
+    collision at all, another with 6 of its 56 boxes.
+    """
+    if depth > MAX_DEPTH: return
+    for tid, (cls, body) in docs.items():
+        if cls == '4' and fid(body, 'm_Father') == '0' and 'm_LocalPosition' in body:
+            walk(path, docs, tid, world, depth, mods, tag)
+    for tid, (cls, body) in docs.items():
+        if cls != '1001': continue
+        chain = []
+        cur = fid(body, 'm_TransformParent')
+        guard = 0
+        while cur != '0' and cur in docs and guard < 40:
+            ccls, cbody = docs[cur]
+            if ccls != '4' or 'm_LocalPosition' not in cbody: break
+            chain.append((cur, cbody))
+            cur = fid(cbody, 'm_Father')
+            guard += 1
+        w = world
+        for cid, cbody in reversed(chain):
+            trs = local_trs(cbody)
+            m = mods.get(cid)
+            if m: trs = apply_mods(trs, m)
+            w = compose(w, trs)
+        handle_prefab_instance(path, docs, tid, body, w, depth, mods, tag)
+
+
+def sweep_orphan_colliders(path, docs, world, tag):
+    """Colliders defined in a prefab file but attached to a GameObject that lives inside a nested
+    prefab instance never get reached by the transform walk (their Transform is a stripped stub).
+    Unity stores their center/size relative to the object, which for these cases is the prefab
+    root, so attaching them there is correct. Dedupe identical boxes: destructible props carry a
+    second, inactive copy for their fracture pieces."""
+    seen = set()
+    for cid, (ccls, cbody) in docs.items():
+        if ccls not in ('65',):
+            continue
+        goid = fid(cbody, 'm_GameObject')
+        if (path, goid) in visited_gos:
+            continue
+        gd = docs.get(goid)
+        if gd is not None and go_active(docs, goid) is False:
+            continue
+        enabled = re.search(r'm_Enabled: (\d)', cbody)
+        if enabled and enabled.group(1) != '1':
+            continue
+        size = vec3(cbody, 'm_Size', (1, 1, 1))
+        center = vec3(cbody, 'm_Center', (0, 0, 0))
+        key = (round(size[0], 3), round(size[1], 3), round(size[2], 3),
+               round(center[0], 3), round(center[1], 3), round(center[2], 3))
+        if key in seen:
+            continue
+        seen.add(key)
+        trig = re.search(r'm_IsTrigger: (\d)', cbody)
+        results.append(dict(kind='box', name=tag, tag=tag, layer=7,
+                            world=world, size=size, center=center,
+                            trigger=(trig.group(1) == '1') if trig else False))
+
+def extract_scene(scene_path):
+    docs = parse_file(scene_path)
+    IDENT = ((0.0,0.0,0.0), (0.0,0.0,0.0,1.0), (1.0,1.0,1.0))
+    expand_file(scene_path, docs, IDENT, 0, {}, None)
+
+
+def dedupe(items):
+    """One collider reached by two paths is still one collider."""
+    seen = set()
+    out = []
+    for it in items:
+        (p, q, sc) = it['world']
+        key = (it['kind'], it['tag'],
+               tuple(round(v, 4) for v in p), tuple(round(v, 4) for v in q),
+               tuple(round(v, 4) for v in sc),
+               tuple(round(v, 4) for v in it.get('size', (0,0,0))),
+               tuple(round(v, 4) for v in it.get('center', (0,0,0))),
+               round(it.get('radius', 0), 4), it.get('trigger', False))
+        if key in seen: continue
+        seen.add(key)
+        out.append(it)
+    return out
+
+
+if __name__ == '__main__':
+    scene = _SCENE
+    extract_scene(scene)
+    out = []
+    for r in dedupe(results):
+        (p, q, s) = r['world']
+        e = dict(r)
+        e['pos'] = [round(v,4) for v in p]
+        e['scale'] = [round(v,4) for v in s]
+        e['zrot'] = round(quat_euler_z(q), 2)
+        e['quat'] = [round(v,5) for v in q]
+        del e['world']
+        e['size'] = [round(v,4) for v in r.get('size',(0,0,0))]
+        e['center'] = [round(v,4) for v in r.get('center',(0,0,0))]
+        out.append(e)
+    print(json.dumps(out))