sindicate 0.13.0 → 0.15.0

package/tools/fbxToGlb.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+// FBX → GLB (pack bake) — Synty props arrive as raw .fbx with their unit scale living in
+// Unity's per-file import settings (PolygonCity is metre-authored at globalScale 100,
+// PolygonTown is centimetres at 1). Shipping raw FBX makes every consumer carry both an
+// FBXLoader and the scale table; baking to GLB with the scale applied kills both.
+//
+//   node tools/fbxToGlb.mjs <packDir>
+//
+// Reads <packDir>/fbxScale.json (written by truthToAssemblies from the Unity .meta files),
+// converts every listed .fbx, rewrites the assemblies + patches + index to point at the GLBs,
+// and leaves the .fbx sources in place (nothing is deleted — re-runnable).
+//
+// Geometry convention: whatever three's FBXLoader produces, world-baked. That is exactly what
+// the viewers rendered before, so the flipped instance transforms from truthToAssemblies keep
+// matching. No handedness change happens here.
+import fs from 'node:fs';
+import path from 'node:path';
+import { writeGlb } from './glbWrite.mjs';
+
+// three's FBXLoader touches a few DOM APIs (texture loading paths we never hit)
+globalThis.self = globalThis;
+globalThis.window = globalThis;
+const stubEl = () => ({ style: {}, addEventListener() {}, removeEventListener() {}, setAttribute() {}, getContext: () => null });
+globalThis.document = { createElementNS: stubEl, createElement: stubEl };
+
+const THREE = await import('three');
+const { FBXLoader } = await import('three/examples/jsm/loaders/FBXLoader.js');
+
+const [packDir] = process.argv.slice(2);
+if (!packDir) { console.error('usage: fbxToGlb.mjs <packDir>'); process.exit(1); }
+
+const modelsDir = path.join(packDir, 'models');
+const scalePath = path.join(packDir, 'fbxScale.json');
+const scales = fs.existsSync(scalePath) ? JSON.parse(fs.readFileSync(scalePath, 'utf8')) : {};
+const loader = new FBXLoader();
+
+function convert(fbxName, scale) {
+  const buf = fs.readFileSync(path.join(modelsDir, fbxName));
+  const root = loader.parse(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength), '');
+  root.scale.setScalar(scale);
+  root.updateMatrixWorld(true);
+
+  // world-bake every mesh into one buffer (parts get a single material from the truth data,
+  // so submesh splits buy nothing and cost draw calls)
+  const pos = [], nrm = [], uv = [], idx = [];
+  const v = new THREE.Vector3();
+  const nm = new THREE.Matrix3();
+  root.traverse((o) => {
+    if (!o.isMesh) return;
+    const g = o.geometry;
+    const p = g.attributes.position;
+    if (!p) return;
+    const base = pos.length / 3;
+    nm.getNormalMatrix(o.matrixWorld);
+    for (let i = 0; i < p.count; i++) {
+      v.fromBufferAttribute(p, i).applyMatrix4(o.matrixWorld);
+      pos.push(v.x, v.y, v.z);
+      if (g.attributes.normal) {
+        v.fromBufferAttribute(g.attributes.normal, i).applyMatrix3(nm).normalize();
+        nrm.push(v.x, v.y, v.z);
+      } else nrm.push(0, 1, 0);
+      if (g.attributes.uv) uv.push(g.attributes.uv.getX(i), g.attributes.uv.getY(i));
+      else uv.push(0, 0);
+    }
+    if (g.index) for (let i = 0; i < g.index.count; i++) idx.push(g.index.getX(i) + base);
+    else for (let i = 0; i < p.count; i++) idx.push(base + i);
+  });
+  if (!pos.length) throw new Error('no geometry');
+  const glbName = fbxName.replace(/\.fbx$/i, '.glb');
+  const r = writeGlb({
+    name: path.basename(glbName, '.glb'),
+    vertexCount: pos.length / 3,
+    indices: idx,
+    attrs: {
+      POSITION: { array: new Float32Array(pos), dim: 3 },
+      NORMAL: { array: new Float32Array(nrm), dim: 3 },
+      TEXCOORD_0: { array: new Float32Array(uv), dim: 2 },
+    },
+    subs: [{ firstIndex: 0, indexCount: idx.length, baseVertex: 0 }],
+  }, path.join(modelsDir, glbName));
+  return { glbName, ...r };
+}
+
+const renamed = {};
+for (const [fbxName, scale] of Object.entries(scales)) {
+  if (!fs.existsSync(path.join(modelsDir, fbxName))) { console.warn(`missing ${fbxName}`); continue; }
+  try {
+    const r = convert(fbxName, scale);
+    renamed[fbxName] = r.glbName;
+    console.log(`${fbxName} ×${scale} → ${r.glbName}  ${r.verts} verts, ${r.tris} tris`);
+  } catch (e) { console.warn(`FAILED ${fbxName}: ${e.message}`); }
+}
+
+// repoint assemblies, patches and the model index at the GLBs
+let touched = 0;
+for (const dir of ['assemblies', 'patches']) {
+  const d = path.join(packDir, dir);
+  if (!fs.existsSync(d)) continue;
+  for (const f of fs.readdirSync(d)) {
+    if (!f.endsWith('.json') || f === 'index.json') continue;
+    const p = path.join(d, f);
+    const man = JSON.parse(fs.readFileSync(p, 'utf8'));
+    let hit = false;
+    for (const part of man.parts) if (renamed[part.file]) { part.file = renamed[part.file]; hit = true; }
+    if (hit) { fs.writeFileSync(p, JSON.stringify(man)); touched++; }
+  }
+}
+const idxPath = path.join(packDir, 'index.json');
+if (fs.existsSync(idxPath)) {
+  const index = JSON.parse(fs.readFileSync(idxPath, 'utf8'))
+    .map((f) => renamed[f] ?? f)
+    .filter((f) => !/\.fbx$/i.test(f));
+  fs.writeFileSync(idxPath, JSON.stringify([...new Set(index)].sort()));
+}
+console.log(`${Object.keys(renamed).length} converted · ${touched} manifests repointed`);

package/tools/glbWrite.mjs

@@ -0,0 +1,62 @@
+// GLB WRITER — shared by unityMeshToGlb (Unity YAML mesh recovery) and
+// rebuildSimpleRoundabouts (synthesized replacements for Kiwi's deleted meshes).
+// mesh = { name, vertexCount, indices, attrs: { POSITION: {array, dim}, ... }, subs }
+import fs from 'node:fs';
+
+export function writeGlb(mesh, outFile) {
+  const buffers = [];
+  let byteLen = 0;
+  const views = [];
+  const push = (buf, target) => {
+    while (byteLen % 4) { buffers.push(Buffer.alloc(1)); byteLen++; }
+    views.push({ buffer: 0, byteOffset: byteLen, byteLength: buf.length, ...(target ? { target } : {}) });
+    buffers.push(buf); byteLen += buf.length;
+    return views.length - 1;
+  };
+  const accessors = [];
+  const attrAcc = {};
+  for (const [sem, a] of Object.entries(mesh.attrs)) {
+    const buf = Buffer.from(a.array.buffer, a.array.byteOffset, a.array.byteLength);
+    const view = push(buf, 34962);
+    let min, max;
+    if (sem === 'POSITION') {
+      min = [Infinity, Infinity, Infinity]; max = [-Infinity, -Infinity, -Infinity];
+      for (let v = 0; v < mesh.vertexCount; v++) for (let d = 0; d < 3; d++) {
+        const x = a.array[v * 3 + d];
+        if (x < min[d]) min[d] = x;
+        if (x > max[d]) max[d] = x;
+      }
+    }
+    accessors.push({ bufferView: view, componentType: 5126, count: mesh.vertexCount, type: ['SCALAR', 'VEC2', 'VEC3', 'VEC4'][a.dim - 1], ...(min ? { min, max } : {}) });
+    attrAcc[sem] = accessors.length - 1;
+  }
+  const primitives = mesh.subs.map((s) => {
+    const idx = new Uint32Array(mesh.indices.slice(s.firstIndex, s.firstIndex + s.indexCount).map((i) => i + s.baseVertex));
+    const view = push(Buffer.from(idx.buffer), 34963);
+    accessors.push({ bufferView: view, componentType: 5125, count: idx.length, type: 'SCALAR' });
+    return { attributes: attrAcc, indices: accessors.length - 1, mode: 4 };
+  });
+  const gltf = {
+    asset: { version: '2.0', generator: 'sindicate unityMeshToGlb' },
+    scene: 0,
+    scenes: [{ nodes: [0] }],
+    nodes: [{ mesh: 0, name: mesh.name }],
+    meshes: [{ name: mesh.name, primitives }],
+    accessors,
+    bufferViews: views,
+    buffers: [{ byteLength: byteLen }],
+  };
+  const bin = Buffer.concat(buffers, byteLen);
+  let json = Buffer.from(JSON.stringify(gltf));
+  while (json.length % 4) json = Buffer.concat([json, Buffer.from(' ')]);
+  const binPad = (4 - (bin.length % 4)) % 4;
+  const paddedBin = binPad ? Buffer.concat([bin, Buffer.alloc(binPad)]) : bin;
+  const total = 12 + 8 + json.length + 8 + paddedBin.length;
+  const out = Buffer.alloc(total);
+  out.writeUInt32LE(0x46546c67, 0); out.writeUInt32LE(2, 4); out.writeUInt32LE(total, 8);
+  out.writeUInt32LE(json.length, 12); out.writeUInt32LE(0x4e4f534a, 16); json.copy(out, 20);
+  let o = 20 + json.length;
+  out.writeUInt32LE(paddedBin.length, o); out.writeUInt32LE(0x004e4942, o + 4); paddedBin.copy(out, o + 8);
+  fs.writeFileSync(outFile, out);
+  return { verts: mesh.vertexCount, tris: mesh.indices.length / 3, prims: primitives.length, bytes: total };
+}

package/tools/rebuildSimpleRoundabouts.mjs

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+// REBUILD SIMPLE ROUNDABOUTS — Kiwi's SimpleRoundabout_01_R1..R4 prefabs reference five
+// generated meshes (Roundabout + CountryRoad_1..4) whose .assets were deleted from the
+// project (guids dangle in every copy; Unity renders the prefabs lights-only). This is a
+// 1:1 port of the generator that built them — InterCityRoadWindow_Roundabout.cs
+// GenerateRoundabout() / GenerateRoundaboutCountryRoad() with the batch defaults from
+// SaveAllSimpleRoundaboutPrefabs() — emitting pack GLBs plus assembly patches that
+// truthToAssemblies merges on every rebuild.
+//
+//   node tools/rebuildSimpleRoundabouts.mjs <packDir>
+//
+// Geometry is generated in Unity space exactly as the C# did, then flipped to the pack's
+// right-handed convention the same way unityMeshToGlb does (negate X, reverse winding).
+// UVs are constant palette texels into T_SimpligonUniverse_02_A_01.png (no tiling) —
+// same convention as every surviving generated road mesh.
+import fs from 'node:fs';
+import path from 'node:path';
+import { writeGlb } from './glbWrite.mjs';
+
+const [packDir] = process.argv.slice(2);
+if (!packDir) { console.error('usage: rebuildSimpleRoundabouts.mjs <packDir>'); process.exit(1); }
+
+// batch defaults (SaveAllSimpleRoundaboutPrefabs used the window's serialized defaults)
+const SEGMENTS = 64;
+const INNER_R = 30, LANES = 2, LANE_W = 5, SHOULDER = 1.5;
+const OUTER_R = INNER_R + LANES * LANE_W;               // 40
+const TOTAL_INNER = INNER_R - SHOULDER;                 // 28.5
+const TOTAL_OUTER = OUTER_R + SHOULDER;                 // 41.5
+const MARK_Y = 0.02;
+const RING_EDGE_W = 0.15;
+const CURB_H = 0.15, CURB_W = 0.4;
+const ISLAND_R = TOTAL_INNER - 0.5;                     // 28.0
+const ARM_LEN = 50, ARM_SEGS = 20;
+const VERGE_W = 1.5, ARM_HALF_W = LANE_W + VERGE_W;     // 6.5 (2 lanes @5 + verges: 5*2/2+1.5)
+const ARM_EDGE_W = 0.1;
+const TRI_LEN = 4, TRI_HALF_W = 1.25;
+const CAP_SEGS = 10, CAP_OVERLAP = 0.15;
+// palette texels in the Simpligon atlas (flat-colour sampling, no tiling)
+const UV_ASPHALT = [0.2871, 0.0361];
+const UV_WHITE = [0.2871, 0.1105];
+const UV_GRASS = [0.2141, 0.0398];
+const TEX = 'T_SimpligonUniverse_02_A_01.png';
+
+function builder(name) {
+  const pos = [], uv = [], idx = [];
+  const b = {
+    name,
+    get count() { return pos.length / 3; },
+    vert(p, t) { pos.push(p[0], p[1], p[2]); uv.push(t[0], t[1]); return pos.length / 3 - 1; },
+    tri(a, c, d) { idx.push(a, c, d); },
+    // strip quads over interleaved [left/inner, right/outer] pairs — the generator's pattern
+    stripTris(base, rows) {
+      for (let i = 0; i < rows - 1; i++) {
+        const k = base + i * 2;
+        b.tri(k, k + 2, k + 1);
+        b.tri(k + 1, k + 2, k + 3);
+      }
+    },
+    mesh() {
+      // Unity → pack handedness: negate X, reverse winding (same as unityMeshToGlb)
+      const P = new Float32Array(pos);
+      for (let i = 0; i < P.length; i += 3) P[i] *= -1;
+      for (let i = 0; i + 2 < idx.length; i += 3) { const t = idx[i]; idx[i] = idx[i + 2]; idx[i + 2] = t; }
+      const N = new Float32Array(P.length);
+      for (let i = 1; i < N.length; i += 3) N[i] = 1;    // everything is horizontal: (0,1,0)
+      return {
+        name, vertexCount: P.length / 3, indices: idx,
+        attrs: { POSITION: { array: P, dim: 3 }, NORMAL: { array: N, dim: 3 }, TEXCOORD_0: { array: new Float32Array(uv), dim: 2 } },
+        subs: [{ firstIndex: 0, indexCount: idx.length, baseVertex: 0 }],
+      };
+    },
+  };
+  return b;
+}
+
+// AddRingSegment: 65 rows inclusive (duplicated seam), pairs [inner, outer], x=cos z=sin
+function addRing(b, rI, rO, y, t) {
+  const base = b.count;
+  for (let i = 0; i <= SEGMENTS; i++) {
+    const a = i * (Math.PI * 2 / SEGMENTS);
+    b.vert([Math.cos(a) * rI, y, Math.sin(a) * rI], t);
+    b.vert([Math.cos(a) * rO, y, Math.sin(a) * rO], t);
+  }
+  b.stripTris(base, SEGMENTS + 1);
+}
+
+function buildRing() {
+  const b = builder('Roundabout');
+  addRing(b, TOTAL_INNER, TOTAL_OUTER, 0, UV_ASPHALT);                        // deck annulus
+  addRing(b, INNER_R - RING_EDGE_W, INNER_R, MARK_Y, UV_WHITE);               // inner edge line
+  addRing(b, OUTER_R, OUTER_R + RING_EDGE_W, MARK_Y, UV_WHITE);               // outer edge line
+  // lane-divider dash arcs at r=35 (lanes=2 → one divider)
+  const laneR = INNER_R + 1 * LANE_W, dashW = 0.12;
+  const numDashes = Math.floor((Math.PI * 2 * laneR) / 5);                    // 3m dash / 2m gap
+  const cycle = (Math.PI * 2) / numDashes, dashAngle = cycle * (3 / 5);
+  for (let d = 0; d < numDashes; d++) {
+    const base = b.count;
+    for (let s = 0; s <= 4; s++) {
+      const a = d * cycle + dashAngle * (s / 4);
+      b.vert([Math.cos(a) * (laneR - dashW / 2), MARK_Y, Math.sin(a) * (laneR - dashW / 2)], UV_WHITE);
+      b.vert([Math.cos(a) * (laneR + dashW / 2), MARK_Y, Math.sin(a) * (laneR + dashW / 2)], UV_WHITE);
+    }
+    b.stripTris(base, 5);
+  }
+  addRing(b, ISLAND_R - CURB_W, ISLAND_R, CURB_H, UV_GRASS);                  // island kerb ring
+  // island fill disk (fan)
+  const c = b.vert([0, CURB_H * 0.5, 0], UV_GRASS);
+  for (let i = 0; i <= SEGMENTS; i++) {
+    const a = i * (Math.PI * 2 / SEGMENTS);
+    b.vert([Math.cos(a) * (ISLAND_R - CURB_W), CURB_H * 0.5, Math.sin(a) * (ISLAND_R - CURB_W)], UV_GRASS);
+  }
+  for (let i = 0; i < SEGMENTS; i++) b.tri(c, c + 1 + i + 1, c + 1 + i);
+  return b.mesh();
+}
+
+function buildArm(k) {
+  const b = builder(`CountryRoad_${k}`);
+  const aDeg = (k - 1) * 90, aRad = (aDeg * Math.PI) / 180;
+  const out = [Math.sin(aRad), 0, Math.cos(aRad)];                            // 0° = +Z, 90° = +X
+  const end = out.map((v) => v * TOTAL_OUTER);                                // junction point
+  const start = out.map((v) => v * (TOTAL_OUTER + ARM_LEN));
+  const tangent = [-out[0], 0, -out[2]];                                      // toward the ring
+  const right = [tangent[2], 0, -tangent[0]];                                 // Cross(up, tangent)
+  const P = (i) => start.map((v, d) => v + (end[d] - v) * (i / ARM_SEGS));
+  const flare = (i) => { const t = i / ARM_SEGS; return t > 1 - TRI_LEN / ARM_LEN ? TRI_HALF_W * ((t - (1 - TRI_LEN / ARM_LEN)) / (TRI_LEN / ARM_LEN)) : 0; };
+  const at = (i, off, y) => { const p = P(i); return [p[0] + right[0] * off, y, p[2] + right[2] * off]; };
+
+  let base = b.count;                                                          // asphalt strip
+  for (let i = 0; i <= ARM_SEGS; i++) {
+    const f = flare(i);
+    b.vert(at(i, -ARM_HALF_W - f, 0), UV_ASPHALT);
+    b.vert(at(i, ARM_HALF_W + f, 0), UV_ASPHALT);
+  }
+  b.stripTris(base, ARM_SEGS + 1);
+  base = b.count;                                                              // left solid edge line
+  for (let i = 0; i <= ARM_SEGS; i++) {
+    const f = flare(i);
+    b.vert(at(i, -ARM_HALF_W - f, MARK_Y), UV_WHITE);
+    b.vert(at(i, -ARM_HALF_W - f + ARM_EDGE_W, MARK_Y), UV_WHITE);
+  }
+  b.stripTris(base, ARM_SEGS + 1);
+  base = b.count;                                                              // right solid edge line
+  for (let i = 0; i <= ARM_SEGS; i++) {
+    const f = flare(i);
+    b.vert(at(i, ARM_HALF_W + f - ARM_EDGE_W, MARK_Y), UV_WHITE);
+    b.vert(at(i, ARM_HALF_W + f, MARK_Y), UV_WHITE);
+  }
+  b.stripTris(base, ARM_SEGS + 1);
+  base = b.count;                                                              // centre dashed line
+  const flareStartIndex = Math.floor((1 - TRI_LEN / ARM_LEN) * ARM_SEGS);      // 18
+  for (let i = 0; i <= flareStartIndex; i++) {
+    b.vert(at(i, -ARM_EDGE_W / 2, MARK_Y), UV_WHITE);
+    b.vert(at(i, ARM_EDGE_W / 2, MARK_Y), UV_WHITE);
+  }
+  for (let i = 0; i < flareStartIndex; i += 2) {                               // even segments only → dashes
+    const k2 = base + i * 2;
+    b.tri(k2, k2 + 2, k2 + 1);
+    b.tri(k2 + 1, k2 + 2, k2 + 3);
+  }
+  base = b.count;                                                              // triangle ghost island
+  for (let i = flareStartIndex; i <= ARM_SEGS; i++) {
+    const halfW = TRI_HALF_W * ((i - flareStartIndex) / (ARM_SEGS - flareStartIndex));
+    b.vert(at(i, -halfW, MARK_Y), UV_WHITE);
+    b.vert(at(i, halfW, MARK_Y), UV_WHITE);
+  }
+  b.stripTris(base, ARM_SEGS - flareStartIndex + 1);
+  // curved end cap wrapping onto the ring
+  const totalEdge = ARM_HALF_W + TRI_HALF_W;                                   // 7.75
+  const angOff = totalEdge / TOTAL_OUTER;
+  const fFinal = flare(ARM_SEGS);
+  const capL = at(ARM_SEGS, -ARM_HALF_W - fFinal, 0), capR = at(ARM_SEGS, ARM_HALF_W + fFinal, 0);
+  const row1 = b.count;
+  for (let j = 0; j <= CAP_SEGS; j++) b.vert(capL.map((v, d) => v + (capR[d] - v) * (j / CAP_SEGS)), UV_ASPHALT);
+  const row2 = b.count;
+  for (let j = 0; j <= CAP_SEGS; j++) {
+    const a = aRad + angOff + (aRad - angOff - (aRad + angOff)) * (j / CAP_SEGS);
+    b.vert([Math.sin(a) * (TOTAL_OUTER - CAP_OVERLAP), 0, Math.cos(a) * (TOTAL_OUTER - CAP_OVERLAP)], UV_ASPHALT);
+  }
+  for (let j = 0; j < CAP_SEGS; j++) {
+    b.tri(row1 + j, row2 + j, row1 + j + 1);
+    b.tri(row2 + j, row2 + j + 1, row1 + j + 1);
+  }
+  return b.mesh();
+}
+
+// ---- emit GLBs + patches ----
+const modelsDir = path.join(packDir, 'models');
+const patchDir = path.join(packDir, 'patches');
+fs.mkdirSync(patchDir, { recursive: true });
+const files = { ring: 'SimpleRoundabout_Ring.glb' };
+const r = writeGlb(buildRing(), path.join(modelsDir, files.ring));
+console.log(`${files.ring}: ${r.verts} verts, ${r.tris} tris`);
+for (let k = 1; k <= 4; k++) {
+  files[k] = `SimpleRoundabout_Arm${k}.glb`;
+  const a = writeGlb(buildArm(k), path.join(modelsDir, files[k]));
+  console.log(`${files[k]}: ${a.verts} verts, ${a.tris} tris`);
+}
+const part = (file) => ({ file, pos: [0, 0, 0], quat: [0, 0, 0, 1], scale: [1, 1, 1], tex: TEX });
+for (let n = 1; n <= 4; n++) {
+  const parts = [part(files.ring)];
+  for (let k = 1; k <= n; k++) parts.push(part(files[k]));
+  fs.writeFileSync(path.join(patchDir, `SimpleRoundabout_01_R${n}.json`), JSON.stringify({ parts }, null, 1));
+}
+// list the new GLBs in the pack's model index so the Parts view can browse them
+const idxPath = path.join(packDir, 'index.json');
+if (fs.existsSync(idxPath)) {
+  const index = JSON.parse(fs.readFileSync(idxPath, 'utf8'));
+  const add = Object.values(files).filter((f) => !index.includes(f));
+  if (add.length) fs.writeFileSync(idxPath, JSON.stringify([...index, ...add].sort()));
+}
+console.log('4 assembly patches written — run truthToAssemblies to merge');