sindicate 0.13.0 → 0.15.0

package/tools/unityPrefabToAssembly.mjs

@@ -0,0 +1,276 @@
+#!/usr/bin/env node
+// UNITY .PREFAB → ASSEMBLY MANIFEST — rebuild Nick's CONSTRUCTED Kiwi road junctions
+// (roundabouts, overpasses, dumbbells) as manifests of SHARED parts + transforms:
+//   { name, parts: [{ file, pos:[x,y,z], quat:[x,y,z,w], scale:[x,y,z] }], missing: [] }
+// Parts reference the deduped KiwiRoads library (aliases.json), so a hundred-piece
+// interchange costs a few kilobytes and every guardrail mesh is loaded ONCE — reuse,
+// never copies.
+//
+//   node tools/unityPrefabToAssembly.mjs <kiwiAssetsDir> <packDir> <prefabDir...>
+//
+// Parses the YAML class docs: GameObject(1), Transform(4), MeshFilter(33) and nested
+// PrefabInstance(1001) (m_SourcePrefab guid + m_Modifications overrides on the source's
+// root transform), recursing into Kiwi-local source prefabs. Meshes referenced from FBX
+// model files (Synty signs/barriers) are recorded in `missing` with their file names —
+// they wire to the POLYGON_City pack import later. Handedness matches unityMeshToGlb:
+// position x negated, quaternion (x,y,z,w) → (x,-y,-z,w).
+import fs from 'node:fs';
+import path from 'node:path';
+
+const [kiwiAssets, packDir, ...prefabDirs] = process.argv.slice(2);
+if (!kiwiAssets || !packDir || !prefabDirs.length) {
+  console.error('usage: unityPrefabToAssembly.mjs <kiwiAssetsDir> <packDir> <prefabDir...>');
+  process.exit(1);
+}
+
+// ── guid → asset path map (scan .meta files once) ──
+const guidMap = new Map();
+(function scan(dir) {
+  for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) { scan(p); continue; }
+    if (!e.name.endsWith('.meta')) continue;
+    const m = fs.readFileSync(p, 'utf8').match(/guid: ([0-9a-f]{32})/);
+    if (m) guidMap.set(m[1], p.slice(0, -5));
+  }
+})(kiwiAssets);
+console.log(`guid map: ${guidMap.size} assets`);
+
+// material guid → its main texture's asset path (URP _BaseMap or legacy _MainTex)
+const texNeeded = new Map();
+const matTexCache = new Map();
+function textureOfMaterial(matGuid) {
+  if (!matGuid) return null;
+  if (matTexCache.has(matGuid)) return matTexCache.get(matGuid);
+  let texPath = null;
+  const matPath = guidMap.get(matGuid);
+  if (matPath && matPath.endsWith('.mat')) {
+    const y = fs.readFileSync(matPath, 'utf8');
+    const m = y.match(/_(?:BaseMap|MainTex):\n\s+m_Texture: \{fileID: \d+, guid: ([0-9a-f]{32})/);
+    const tp = m ? guidMap.get(m[1]) : null;
+    if (tp && /\.(png|jpg|jpeg|tga)$/i.test(tp)) { texPath = tp; texNeeded.set(path.basename(tp), tp); }
+  }
+  matTexCache.set(matGuid, texPath);
+  return texPath;
+}
+
+// ── converted-name resolution: asset path → canonical lib GLB (via aliases.json) ──
+const aliases = JSON.parse(fs.readFileSync(path.join(packDir, 'aliases.json'), 'utf8'));
+const ROADMESHES = path.join(kiwiAssets, 'AIGenerateMap/Generated/RoadMeshes');
+function libNameFor(assetPath) {
+  let rel;
+  if (assetPath.startsWith(ROADMESHES)) rel = path.relative(ROADMESHES, assetPath).replace(/\.asset$/, '.glb');
+  else rel = path.basename(assetPath).replace(/\.asset$/, '.glb');
+  return aliases[rel] ?? null;
+}
+
+// ── minimal Unity YAML doc parser ──
+function parseDocs(text) {
+  const docs = [];
+  const re = /^--- !u!(\d+) &(-?\d+)( stripped)?$/gm;
+  let m, prev = null;
+  while ((m = re.exec(text))) {
+    if (prev) prev.body = text.slice(prev.end, m.index);
+    prev = { cls: +m[1], id: m[2], stripped: !!m[3], end: m.index + m[0].length };
+    docs.push(prev);
+  }
+  if (prev) prev.body = text.slice(prev.end);
+  return docs;
+}
+const ref = (body, key) => body.match(new RegExp(`${key}: \\{fileID: (-?\\d+)(?:, guid: ([0-9a-f]{32}))?`))?.slice(1) ?? [null, null];
+const vec = (body, key, dims) => {
+  const m = body.match(new RegExp(`${key}: \\{x: ([-\\d.e]+), y: ([-\\d.e]+), z: ([-\\d.e]+)(?:, w: ([-\\d.e]+))?\\}`));
+  if (!m) return null;
+  return m.slice(1, 1 + dims).map(Number);
+};
+
+// ── quaternion/matrix helpers (column-major 4x4, y-up) ──
+const qMul = (a, b) => [
+  a[3] * b[0] + a[0] * b[3] + a[1] * b[2] - a[2] * b[1],
+  a[3] * b[1] - a[0] * b[2] + a[1] * b[3] + a[2] * b[0],
+  a[3] * b[2] + a[0] * b[1] - a[1] * b[0] + a[2] * b[3],
+  a[3] * b[3] - a[0] * b[0] - a[1] * b[1] - a[2] * b[2],
+];
+const qRot = (q, v) => {
+  const [x, y, z, w] = q, [vx, vy, vz] = v;
+  const 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];
+};
+const trsCompose = (p, q, s, cp, cq, cs) => ({
+  // parent (p,q,s) ∘ child (cp,cq,cs)
+  p: (() => { const sc = [cp[0] * s[0], cp[1] * s[1], cp[2] * s[2]]; const r = qRot(q, sc); return [p[0] + r[0], p[1] + r[1], p[2] + r[2]]; })(),
+  q: qMul(q, cq),
+  s: [s[0] * cs[0], s[1] * cs[1], s[2] * cs[2]],
+});
+const ID = { p: [0, 0, 0], q: [0, 0, 0, 1], s: [1, 1, 1] };
+
+// ── prefab → parts (recursive over nested PrefabInstances) ──
+const prefabCache = new Map();
+const fbxNeeded = new Map();   // basename → source path (copied into the pack after assembly)
+function loadPrefab(file) {
+  if (prefabCache.has(file)) return prefabCache.get(file);
+  const docs = parseDocs(fs.readFileSync(file, 'utf8'));
+  const gos = new Map(), transforms = new Map(), filters = [], instances = [], renderers = new Map(), stripped = new Map();
+  for (const d of docs) {
+    if (d.cls === 1) gos.set(d.id, { name: d.body.match(/m_Name: (.*)/)?.[1] ?? '?' });
+    else if (d.cls === 4) {
+      if (d.stripped) {
+        // a stripped Transform stands in for a transform INSIDE a PrefabInstance —
+        // children parented to it belong under that instance's world transform
+        stripped.set(d.id, d.body.match(/m_PrefabInstance: \{fileID: (-?\d+)/)?.[1] ?? null);
+        continue;
+      }
+      transforms.set(d.id, {
+        go: ref(d.body, 'm_GameObject')[0],
+        father: ref(d.body, 'm_Father')[0],
+        p: vec(d.body, 'm_LocalPosition', 3) ?? [0, 0, 0],
+        q: vec(d.body, 'm_LocalRotation', 4) ?? [0, 0, 0, 1],
+        s: vec(d.body, 'm_LocalScale', 3) ?? [1, 1, 1],
+      });
+    } else if (d.cls === 33) {
+      const [fid, guid] = ref(d.body, 'm_Mesh');
+      filters.push({ go: ref(d.body, 'm_GameObject')[0], meshGuid: guid, meshFid: fid });
+    } else if (d.cls === 23) {
+      const matGuid = d.body.match(/m_Materials:\n\s+- \{fileID: \d+, guid: ([0-9a-f]{32})/)?.[1] ?? null;
+      renderers.set(ref(d.body, 'm_GameObject')[0], matGuid);
+    } else if (d.cls === 1001) {
+      const srcGuid = d.body.match(/m_SourcePrefab: \{fileID: \d+, guid: ([0-9a-f]{32})/)?.[1];
+      const parent = d.body.match(/m_TransformParent: \{fileID: (-?\d+)/)?.[1] ?? '0';
+      // OVERRIDES ARE PER-TARGET: group by the fileID they modify inside the source
+      const modsByTarget = {};
+      for (const mm of d.body.matchAll(/- target: \{fileID: (-?\d+), guid: [0-9a-f]{32}, type: \d+\}\n\s+propertyPath: (m_Local(?:Position|Rotation|Scale)\.[xyzw])\n\s+value: ([-\d.e]+)/g)) {
+        (modsByTarget[mm[1]] ??= {})[mm[2]] = Number(mm[3]);
+      }
+      instances.push({ id: d.id, srcGuid, parent, modsByTarget });
+    }
+  }
+  const out = { gos, transforms, filters, instances, renderers, stripped };
+  prefabCache.set(file, out);
+  return out;
+}
+
+function worldOf(transforms, tid) {
+  const chain = [];
+  let cur = tid;
+  let guard = 0;
+  while (cur && cur !== '0' && transforms.has(cur) && guard++ < 64) { chain.unshift(transforms.get(cur)); cur = transforms.get(cur).father; }
+  let acc = ID;
+  for (const t of chain) acc = trsCompose(acc.p, acc.q, acc.s, t.p, t.q, t.s);
+  return acc;
+}
+
+function assemble(file, base = ID, depth = 0) {
+  if (depth > 4) return { parts: [], missing: [] };
+  const { gos, transforms, filters, instances } = loadPrefab(file);
+  const tByGo = new Map([...transforms.entries()].map(([id, t]) => [t.go, id]));
+  const parts = [], missing = [];
+  for (const f of filters) {
+    const tid = tByGo.get(f.go);
+    const w = tid ? worldOf(transforms, tid) : ID;
+    const acc = trsCompose(base.p, base.q, base.s, w.p, w.q, w.s);
+    const assetPath = f.meshGuid ? guidMap.get(f.meshGuid) : null;
+    const texPath = textureOfMaterial(loadPrefab(file).renderers.get(f.go));
+    const tex = texPath ? path.basename(texPath) : undefined;
+    if (assetPath && assetPath.endsWith('.asset')) {
+      const lib = libNameFor(assetPath);
+      if (lib) { parts.push({ file: lib, ...(tex ? { tex } : {}), ...acc }); continue; }
+    }
+    if (assetPath && /\.fbx$/i.test(assetPath)) {
+      fbxNeeded.set(path.basename(assetPath), assetPath);
+      parts.push({ file: path.basename(assetPath), ...(tex ? { tex } : {}), ...acc });
+      continue;
+    }
+    missing.push({ mesh: assetPath ? path.basename(assetPath) : `guid:${f.meshGuid}#${f.meshFid}`, from: gos.get(f.go)?.name });
+  }
+  const instWorlds = new Map();   // instance id → resolved world (for stripped-parented children)
+  for (const inst of instances) {
+    const src = inst.srcGuid ? guidMap.get(inst.srcGuid) : null;
+    // the SOURCE's own root transform provides the DEFAULTS; mods targeting that root override
+    let srcRoot = { p: [0, 0, 0], q: [0, 0, 0, 1], s: [1, 1, 1] }, srcRootId = null;
+    if (src && src.endsWith('.prefab')) {
+      const sp = loadPrefab(src);
+      for (const [tid, t] of sp.transforms) if (!t.father || t.father === '0') { srcRoot = t; srcRootId = tid; break; }
+    }
+    const mods = (srcRootId && inst.modsByTarget[srcRootId]) ?? Object.values(inst.modsByTarget)[0] ?? {};
+    const local = {
+      p: [mods['m_LocalPosition.x'] ?? srcRoot.p[0], mods['m_LocalPosition.y'] ?? srcRoot.p[1], mods['m_LocalPosition.z'] ?? srcRoot.p[2]],
+      q: [mods['m_LocalRotation.x'] ?? srcRoot.q[0], mods['m_LocalRotation.y'] ?? srcRoot.q[1], mods['m_LocalRotation.z'] ?? srcRoot.q[2], mods['m_LocalRotation.w'] ?? srcRoot.q[3]],
+      s: [mods['m_LocalScale.x'] ?? srcRoot.s[0], mods['m_LocalScale.y'] ?? srcRoot.s[1], mods['m_LocalScale.z'] ?? srcRoot.s[2]],
+    };
+    // the instance parents into THIS prefab's hierarchy — possibly via a STRIPPED transform
+    // standing in for a transform inside an earlier PrefabInstance
+    const here = loadPrefab(file);
+    let parentW = ID;
+    if (inst.parent && inst.parent !== '0') {
+      if (here.transforms.has(inst.parent)) parentW = worldOf(here.transforms, inst.parent);
+      else if (here.stripped.has(inst.parent)) parentW = instWorlds.get(here.stripped.get(inst.parent)) ?? ID;
+    }
+    const baseW = trsCompose(base.p, base.q, base.s, parentW.p, parentW.q, parentW.s);
+    const instW = trsCompose(baseW.p, baseW.q, baseW.s, local.p, local.q, local.s);
+    instWorlds.set(inst.id, instW);
+    if (src && src.endsWith('.prefab')) {
+      const sub = assemble(src, instW, depth + 1);
+      parts.push(...sub.parts);
+      missing.push(...sub.missing);
+    } else if (src && /\.fbx$/i.test(src)) {
+      fbxNeeded.set(path.basename(src), src);
+      parts.push({ file: path.basename(src), ...instW });
+    } else if (src) {
+      missing.push({ mesh: path.basename(src), from: 'unresolved instance' });
+    }
+  }
+  return { parts, missing };
+}
+
+// unity → three handedness on the FINAL transforms
+const flip = (t) => ({
+  pos: [-t.p[0], t.p[1], t.p[2]].map((v) => +v.toFixed(5)),
+  quat: [t.q[0], -t.q[1], -t.q[2], t.q[3]].map((v) => +v.toFixed(6)),
+  scale: t.s.map((v) => +v.toFixed(5)),
+});
+
+const outDir = path.join(packDir, 'assemblies');
+fs.mkdirSync(outDir, { recursive: true });
+const made = [];
+for (const dir of prefabDirs) {
+  const files = [];
+  (function walk(d) {
+    for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+      const p = path.join(d, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.name.endsWith('.prefab')) files.push(p);
+    }
+  })(dir);
+  for (const f of files) {
+    // variant dirs (Motorway/DualCarriageway/L2-R1…) share basenames — the name carries the path
+    const relName = path.relative(dir, f).replace(/\.prefab$/, '');
+    const name = relName.split(path.sep).filter((seg, i, a) => !a[i + 1]?.startsWith(seg)).join('_').replace(/[^\w.-]+/g, '_');
+    try {
+      const { parts, missing } = assemble(f);
+      const manifest = {
+        name,
+        parts: parts.map((p) => ({ file: p.file, ...(p.tex ? { tex: p.tex } : {}), ...flip(p) })),
+        missing: missing.map((m) => (m.p ? { mesh: m.mesh, from: m.from, ...flip(m) } : m)),
+      };
+      fs.writeFileSync(path.join(outDir, `${name}.json`), JSON.stringify(manifest));
+      made.push(name);
+      console.log(`${name}: ${parts.length} parts, ${missing.length} missing`);
+    } catch (e) { console.warn(`SKIP ${name}: ${e.message}`); }
+  }
+}
+fs.writeFileSync(path.join(outDir, 'index.json'), JSON.stringify([...new Set(made)].sort()));
+// copy every referenced Synty FBX into the pack's model library (shared, deduped by name)
+const modelsDir = path.join(packDir, 'models');
+let copied = 0;
+for (const [name, srcPath] of fbxNeeded) {
+  const dst = path.join(modelsDir, name);
+  if (!fs.existsSync(dst)) { fs.copyFileSync(srcPath, dst); copied++; }
+}
+const texDir = path.join(packDir, 'textures');
+fs.mkdirSync(texDir, { recursive: true });
+let texCopied = 0;
+for (const [name, srcPath] of texNeeded) {
+  const dst = path.join(texDir, name);
+  if (!fs.existsSync(dst)) { fs.copyFileSync(srcPath, dst); texCopied++; }
+}
+console.log(`\n${made.length} assemblies · ${fbxNeeded.size} shared FBX parts (${copied} copied) · ${texNeeded.size} textures (${texCopied} copied)`);