@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/dist/chunk-dbq4qf52.js

@@ -0,0 +1,902 @@
+import {
+  Ts23dError2,
+  merge2,
+  encodePng2,
+  quatFromAxisAngle2,
+  worldTransforms2,
+  toWorld2,
+  rotateZ2,
+  worldMeshes2
+} from "./chunk-hg7pf34j.js";
+import {
+  hex2,
+  stripCredits2
+} from "./chunk-y63c6zcv.js";
+import {
+  optimize2
+} from "./chunk-drna2rny.js";
+
+// src/export/bin-writer.ts
+var ARRAY_BUFFER = 34962;
+var ELEMENT_ARRAY_BUFFER = 34963;
+var FLOAT = 5126;
+var UINT32 = 5125;
+var UINT16 = 5123;
+
+class BinWriter {
+  chunks = [];
+  length = 0;
+  views = [];
+  accessors = [];
+  push(bytes, target) {
+    const pad = (4 - this.length % 4) % 4;
+    if (pad) {
+      this.chunks.push(new Uint8Array(pad));
+      this.length += pad;
+    }
+    this.views.push({
+      buffer: 0,
+      byteOffset: this.length,
+      byteLength: bytes.byteLength,
+      ...target ? { target } : {}
+    });
+    this.chunks.push(bytes);
+    this.length += bytes.byteLength;
+    return this.views.length - 1;
+  }
+  accessor(data, type, target, bounds = false, normalized = false) {
+    const view = this.push(new Uint8Array(data.buffer, data.byteOffset, data.byteLength), target);
+    const width = { SCALAR: 1, VEC2: 2, VEC3: 3, VEC4: 4 }[type];
+    const acc = {
+      bufferView: view,
+      componentType: data instanceof Uint32Array ? UINT32 : data instanceof Uint16Array ? UINT16 : FLOAT,
+      count: data.length / width,
+      type,
+      ...normalized ? { normalized: true } : {}
+    };
+    if (bounds) {
+      const min = Array(width).fill(Infinity);
+      const max = Array(width).fill(-Infinity);
+      for (let i = 0;i < data.length; i++) {
+        const k = i % width;
+        const v = data[i] ?? 0;
+        if (v < (min[k] ?? 0))
+          min[k] = v;
+        if (v > (max[k] ?? 0))
+          max[k] = v;
+      }
+      acc["min"] = min;
+      acc["max"] = max;
+    }
+    this.accessors.push(acc);
+    return this.accessors.length - 1;
+  }
+  bytes() {
+    const out = new Uint8Array(Math.ceil(this.length / 4) * 4);
+    let o = 0;
+    for (const c of this.chunks) {
+      out.set(c, o);
+      o += c.byteLength;
+    }
+    return out;
+  }
+}
+
+// src/export/container.ts
+function packGlb(gltf, body) {
+  let json = new TextEncoder().encode(JSON.stringify(gltf));
+  const jsonPad = (4 - json.byteLength % 4) % 4;
+  if (jsonPad) {
+    const padded = new Uint8Array(json.byteLength + jsonPad).fill(32);
+    padded.set(json);
+    json = padded;
+  }
+  const total = 12 + 8 + json.byteLength + 8 + body.byteLength;
+  const out = new Uint8Array(total);
+  const dv = new DataView(out.buffer);
+  dv.setUint32(0, 1179937895, true);
+  dv.setUint32(4, 2, true);
+  dv.setUint32(8, total, true);
+  dv.setUint32(12, json.byteLength, true);
+  dv.setUint32(16, 1313821514, true);
+  out.set(json, 20);
+  const binAt = 20 + json.byteLength;
+  dv.setUint32(binAt, body.byteLength, true);
+  dv.setUint32(binAt + 4, 5130562, true);
+  out.set(body, binAt + 8);
+  return out;
+}
+function concat(a, b) {
+  const out = new Uint8Array(a.byteLength + b.byteLength);
+  out.set(a);
+  out.set(b, a.byteLength);
+  return out;
+}
+
+// src/export/credits.ts
+function creditsOf(asset) {
+  const out = new Set;
+  for (const p of asset.parts) {
+    const uv = p.mesh?.uvs;
+    if (!uv)
+      continue;
+    const v = new Float32Array(uv.length >> 1);
+    for (let i = 0;i < v.length; i++)
+      v[i] = uv[i * 2 + 1] ?? 0;
+    for (const c of stripCredits2(v))
+      out.add(c);
+  }
+  return [...out].sort();
+}
+function withCredits(asset, meta) {
+  const credits = creditsOf(asset);
+  if (!credits.length)
+    return meta;
+  return { ...meta, credits: [...meta?.credits ?? [], ...credits] };
+}
+
+// src/export/lights.ts
+var LIGHTS = "KHR_lights_punctual";
+function between(a, b) {
+  const d = a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  if (d < -0.999999)
+    return [1, 0, 0, 0];
+  const c = [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+  const w = 1 + d;
+  const n = Math.hypot(c[0], c[1], c[2], w);
+  return [c[0] / n, c[1] / n, c[2] / n, w / n];
+}
+var num = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback;
+function lightOf(part) {
+  const s = part.socket;
+  if (s?.kind !== "light")
+    return null;
+  const d = s.data ?? {};
+  const type = d["light"] === "point" || d["light"] === "directional" ? d["light"] : "spot";
+  const color = typeof d["color"] === "string" ? hex2(d["color"]) : [1, 1, 1];
+  const dir = s.dir ?? [1, 0, 0];
+  const len = Math.hypot(...dir) || 1;
+  const outer = Math.min(89, num(d["cone"], 30)) * Math.PI / 180;
+  const inner = Math.min(outer * 0.999, num(d["inner"], 0) * Math.PI / 180);
+  const range = num(d["range"], 0);
+  return {
+    light: {
+      name: part.name,
+      type,
+      color,
+      intensity: num(d["intensity"], type === "directional" ? 3 : type === "point" ? 20 : 100),
+      ...range > 0 && type !== "directional" ? { range } : {},
+      ...type === "spot" ? { spot: { innerConeAngle: inner, outerConeAngle: outer } } : {}
+    },
+    rotation: between([0, 0, -1], [dir[0] / len, dir[1] / len, dir[2] / len])
+  };
+}
+
+// src/export/motion.ts
+var LOOP_SECONDS = 4;
+var cyclesOf = (rate) => Math.max(1, Math.round(Math.abs(rate) * LOOP_SECONDS)) * Math.sign(rate || 1);
+var timeAccessors = new WeakMap;
+function times(bin, keys) {
+  const t = new Float32Array(keys + 1).map((_, i) => i / keys * LOOP_SECONDS);
+  const byBin = timeAccessors.get(bin) ?? new Map;
+  timeAccessors.set(bin, byBin);
+  let input = byBin.get(keys);
+  if (input === undefined) {
+    input = bin.accessor(t, "SCALAR", undefined, true);
+    byBin.set(keys, input);
+  }
+  return { input, t };
+}
+function motionChannel(bin, motion, node, rest) {
+  const rate = motion.kind === "spin" ? motion.rps : motion.hz;
+  const cycles = cyclesOf(rate);
+  const keys = Math.max(24, Math.abs(cycles) * (motion.kind === "spin" ? 12 : 16));
+  const { input, t } = times(bin, keys);
+  const phase = (time) => time / LOOP_SECONDS * cycles * Math.PI * 2;
+  const wave = (time) => motion.kind !== "spin" && motion.oneWay ? (1 - Math.cos(phase(time))) / 2 : Math.sin(phase(time));
+  if (motion.kind === "slide") {
+    const values = new Float32Array((keys + 1) * 3);
+    t.forEach((time, i) => {
+      const s = wave(time);
+      values.set([0, 1, 2].map((k) => (rest[k] ?? 0) + (motion.offset[k] ?? 0) * s), i * 3);
+    });
+    return {
+      sampler: { input, output: bin.accessor(values, "VEC3"), interpolation: "LINEAR" },
+      channel: { target: { node, path: "translation" } }
+    };
+  }
+  const values = new Float32Array((keys + 1) * 4);
+  const peak = motion.kind === "sway" ? motion.degrees * Math.PI / 180 : 0;
+  t.forEach((time, i) => {
+    const angle = motion.kind === "spin" ? phase(time) : peak * wave(time);
+    values.set(quatFromAxisAngle2(motion.axis, angle), i * 4);
+  });
+  return {
+    sampler: { input, output: bin.accessor(values, "VEC4"), interpolation: "LINEAR" },
+    channel: { target: { node, path: "rotation" } }
+  };
+}
+
+// src/export/tangents.ts
+function tangentsOf(m) {
+  const n = m.positions.length / 3;
+  const tan = new Float32Array(n * 3);
+  const bit = new Float32Array(n * 3);
+  const P = m.positions;
+  const U = m.uvs;
+  for (let t = 0;t < m.indices.length; t += 3) {
+    const a = m.indices[t] ?? 0;
+    const b = m.indices[t + 1] ?? 0;
+    const c = m.indices[t + 2] ?? 0;
+    const e1x = (P[b * 3] ?? 0) - (P[a * 3] ?? 0);
+    const e1y = (P[b * 3 + 1] ?? 0) - (P[a * 3 + 1] ?? 0);
+    const e1z = (P[b * 3 + 2] ?? 0) - (P[a * 3 + 2] ?? 0);
+    const e2x = (P[c * 3] ?? 0) - (P[a * 3] ?? 0);
+    const e2y = (P[c * 3 + 1] ?? 0) - (P[a * 3 + 1] ?? 0);
+    const e2z = (P[c * 3 + 2] ?? 0) - (P[a * 3 + 2] ?? 0);
+    const du1 = (U[b * 2] ?? 0) - (U[a * 2] ?? 0);
+    const dv1 = -((U[b * 2 + 1] ?? 0) - (U[a * 2 + 1] ?? 0));
+    const du2 = (U[c * 2] ?? 0) - (U[a * 2] ?? 0);
+    const dv2 = -((U[c * 2 + 1] ?? 0) - (U[a * 2 + 1] ?? 0));
+    const det = du1 * dv2 - du2 * dv1;
+    if (Math.abs(det) < 0.000000000001)
+      continue;
+    const r = 1 / det;
+    const tx = (e1x * dv2 - e2x * dv1) * r;
+    const ty = (e1y * dv2 - e2y * dv1) * r;
+    const tz = (e1z * dv2 - e2z * dv1) * r;
+    const bx = (e2x * du1 - e1x * du2) * r;
+    const by = (e2y * du1 - e1y * du2) * r;
+    const bz = (e2z * du1 - e1z * du2) * r;
+    for (const v of [a, b, c]) {
+      tan[v * 3] = (tan[v * 3] ?? 0) + tx;
+      tan[v * 3 + 1] = (tan[v * 3 + 1] ?? 0) + ty;
+      tan[v * 3 + 2] = (tan[v * 3 + 2] ?? 0) + tz;
+      bit[v * 3] = (bit[v * 3] ?? 0) + bx;
+      bit[v * 3 + 1] = (bit[v * 3 + 1] ?? 0) + by;
+      bit[v * 3 + 2] = (bit[v * 3 + 2] ?? 0) + bz;
+    }
+  }
+  const out = new Float32Array(n * 4);
+  for (let v = 0;v < n; v++) {
+    const nx = m.normals[v * 3] ?? 0;
+    const ny = m.normals[v * 3 + 1] ?? 0;
+    const nz = m.normals[v * 3 + 2] ?? 1;
+    let tx = tan[v * 3] ?? 0;
+    let ty = tan[v * 3 + 1] ?? 0;
+    let tz = tan[v * 3 + 2] ?? 0;
+    const d = nx * tx + ny * ty + nz * tz;
+    tx -= nx * d;
+    ty -= ny * d;
+    tz -= nz * d;
+    let len = Math.hypot(tx, ty, tz);
+    if (len < 0.00000001) {
+      [tx, ty, tz] = Math.abs(nx) < 0.9 ? [0, -nz, ny] : [nz, 0, -nx];
+      len = Math.hypot(tx, ty, tz) || 1;
+    }
+    tx /= len;
+    ty /= len;
+    tz /= len;
+    const cx = ny * tz - nz * ty;
+    const cy = nz * tx - nx * tz;
+    const cz = nx * ty - ny * tx;
+    const w = cx * (bit[v * 3] ?? 0) + cy * (bit[v * 3 + 1] ?? 0) + cz * (bit[v * 3 + 2] ?? 0);
+    out.set([tx, ty, tz, w < 0 ? -1 : 1], v * 4);
+  }
+  return out;
+}
+
+// src/export/primitive.ts
+function writePrimitive(bin, m, material, tangents) {
+  const colors = new Uint16Array(m.colors.length / 3 * 4);
+  const q = (v) => Math.round(Math.min(1, Math.max(0, v)) * 65535);
+  for (let i = 0;i < m.colors.length / 3; i++)
+    colors.set([q(m.colors[i * 3] ?? 1), q(m.colors[i * 3 + 1] ?? 1), q(m.colors[i * 3 + 2] ?? 1), 65535], i * 4);
+  return {
+    attributes: {
+      POSITION: bin.accessor(m.positions, "VEC3", ARRAY_BUFFER, true),
+      NORMAL: bin.accessor(m.normals, "VEC3", ARRAY_BUFFER),
+      TEXCOORD_0: bin.accessor(m.uvs, "VEC2", ARRAY_BUFFER),
+      COLOR_0: bin.accessor(colors, "VEC4", ARRAY_BUFFER, false, true),
+      ...tangents ? { TANGENT: bin.accessor(tangentsOf(m), "VEC4", ARRAY_BUFFER) } : {}
+    },
+    indices: bin.accessor(m.positions.length / 3 <= 65535 ? Uint16Array.from(m.indices) : m.indices, "SCALAR", ELEMENT_ARRAY_BUFFER),
+    material
+  };
+}
+
+// src/export/hierarchy.ts
+var newDoc = (bin) => ({
+  bin,
+  nodes: [],
+  meshes: [],
+  lights: [],
+  samplers: [],
+  channels: [],
+  motionSamplers: new Map,
+  lightIndex: new Map
+});
+function attach(doc, parentId, id) {
+  const parent = doc.nodes[parentId];
+  if (!parent)
+    return;
+  parent["children"] = [...parent["children"] ?? [], id];
+}
+function lightIndexOf(doc, light) {
+  const key = JSON.stringify(light);
+  const known = doc.lightIndex.get(key);
+  if (known !== undefined)
+    return known;
+  doc.lights.push(light);
+  doc.lightIndex.set(key, doc.lights.length - 1);
+  return doc.lights.length - 1;
+}
+function addMotion(doc, part, id) {
+  if (!part.motion)
+    return;
+  const key = JSON.stringify([part.motion, part.at]);
+  let sampler = doc.motionSamplers.get(key);
+  let channel;
+  if (sampler === undefined) {
+    const written = motionChannel(doc.bin, part.motion, id, part.at);
+    doc.samplers.push(written.sampler);
+    sampler = doc.samplers.length - 1;
+    doc.motionSamplers.set(key, sampler);
+    channel = written.channel;
+  } else {
+    channel = {
+      target: { node: id, path: part.motion.kind === "slide" ? "translation" : "rotation" }
+    };
+  }
+  doc.channels.push({ ...channel, sampler });
+}
+function writeHierarchy(doc, asset, rootName, o) {
+  doc.nodes.push({ name: rootName, children: [] });
+  const root = doc.nodes.length - 1;
+  const index = new Map;
+  asset.parts.forEach((part, i) => {
+    const node = { name: part.name, translation: [...part.at] };
+    if (part.yaw)
+      node["rotation"] = [...quatFromAxisAngle2([0, 0, 1], part.yaw)];
+    if (part.emitter || part.socket) {
+      node["extras"] = {
+        ts23d: {
+          ...part.emitter ? { emitter: part.emitter } : {},
+          ...part.socket ? { socket: part.socket } : {}
+        }
+      };
+    }
+    if (part.mesh && part.mesh.indices.length > 0) {
+      doc.meshes.push({
+        name: part.name,
+        primitives: [writePrimitive(doc.bin, part.mesh, o.materialOf(part, i), o.withSheet)]
+      });
+      node["mesh"] = doc.meshes.length - 1;
+    }
+    doc.nodes.push(node);
+    const id = doc.nodes.length - 1;
+    index.set(part.name, id);
+    attach(doc, part.parent === null ? root : index.get(part.parent) ?? root, id);
+    const lit = lightOf(part);
+    if (lit) {
+      doc.nodes.push({
+        name: `${part.name}_light`,
+        rotation: [...lit.rotation],
+        extensions: { [LIGHTS]: { light: lightIndexOf(doc, lit.light) } }
+      });
+      attach(doc, id, doc.nodes.length - 1);
+    }
+    if (o.animations)
+      addMotion(doc, part, id);
+  });
+  return root;
+}
+
+// src/export/lod-coverage.ts
+var MSFT_LOD2 = "MSFT_lod";
+var SCREEN_COVERAGE2 = "MSFT_screencoverage";
+var tris = (a) => a.parts.reduce((s, p) => s + (p.mesh ? p.mesh.indices.length / 3 : 0), 0);
+function extent(a) {
+  if (a.real)
+    return Math.max(a.real.length, a.real.width, a.real.height);
+  const lo = [Infinity, Infinity, Infinity];
+  const hi = [-Infinity, -Infinity, -Infinity];
+  for (const mesh of worldMeshes2(a.parts).values()) {
+    const p = mesh.positions;
+    for (let i = 0;i < p.length; i++) {
+      const k = i % 3;
+      const v = p[i] ?? 0;
+      lo[k] = Math.min(lo[k] ?? 0, v);
+      hi[k] = Math.max(hi[k] ?? 0, v);
+    }
+  }
+  return Math.max(0, ...hi.map((h, k) => h - (lo[k] ?? 0)));
+}
+var clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+var round = (v) => Math.round(v * 1000) / 1000;
+function defaultCoverage2(lods) {
+  const byLod = new Map(lods.map((a) => [a.lod, tris(a)]));
+  const top = lods[0];
+  const t0 = Math.max(1, top ? tris(top) : 1);
+  const ratio = (lod) => (byLod.get(lod) ?? t0) / t0;
+  const c1 = round(clamp(Math.sqrt(ratio(1)), 0.1, 0.6));
+  const c2 = round(clamp(Math.sqrt(ratio(2)), 0.02, c1 / 2));
+  const cull = top && extent(top) >= 10 ? 0.002 : 0.01;
+  return [c1, c2, Math.min(cull, round(c2 / 2))];
+}
+function checkCoverage2(c, asset) {
+  const [a = -1, b = -1, cull = -1] = c;
+  if (c.length !== 3 || !(a < 1 && a > b && b > cull && cull >= 0))
+    throw new Ts23dError2("T3D_RECIPE_INVALID", {
+      cause: `lodCoverage ${JSON.stringify(c)} on '${asset}' is not strictly descending in [0, 1)`,
+      fix: "give [LOD0→LOD1, LOD1→LOD2, cull] screen-height fractions, e.g. [0.5, 0.2, 0.01]; 0 = never cull"
+    });
+}
+function coverageFor2(levels, c) {
+  return levels.map((_, j) => {
+    const next = levels[j + 1];
+    return next === undefined ? c[2] : c[next - 1] ?? c[2];
+  });
+}
+
+// src/export/materials.ts
+var MATERIALS = {
+  opaque: {
+    name: "ts23d_trim",
+    pbrMetallicRoughness: {
+      baseColorFactor: [1, 1, 1, 1],
+      metallicFactor: 0,
+      roughnessFactor: 0.8
+    }
+  },
+  cutout: {
+    name: "ts23d_trim_cutout",
+    alphaMode: "MASK",
+    alphaCutoff: 0.5,
+    doubleSided: true,
+    pbrMetallicRoughness: {
+      baseColorFactor: [1, 1, 1, 1],
+      metallicFactor: 0,
+      roughnessFactor: 0.9
+    }
+  },
+  glass: {
+    name: "ts23d_glass",
+    alphaMode: "BLEND",
+    pbrMetallicRoughness: {
+      baseColorFactor: [1, 1, 1, 0.25],
+      metallicFactor: 0,
+      roughnessFactor: 0.05
+    },
+    extensions: {
+      KHR_materials_transmission: { transmissionFactor: 1 },
+      KHR_materials_volume: { thicknessFactor: 0.01 },
+      KHR_materials_ior: { ior: 1.5 }
+    }
+  },
+  translucent: {
+    name: "ts23d_translucent",
+    alphaMode: "BLEND",
+    pbrMetallicRoughness: {
+      baseColorFactor: [1, 1, 1, 0.6],
+      metallicFactor: 0,
+      roughnessFactor: 0.35
+    },
+    extensions: {
+      KHR_materials_transmission: { transmissionFactor: 0.6 },
+      KHR_materials_volume: { thicknessFactor: 0.02 },
+      KHR_materials_ior: { ior: 1.45 }
+    }
+  }
+};
+var ORDER = ["opaque", "cutout", "glass", "translucent"];
+function textured(m, surface) {
+  const pbr = m["pbrMetallicRoughness"];
+  const own = surface === "opaque" || surface === "cutout";
+  return {
+    ...m,
+    pbrMetallicRoughness: {
+      ...pbr,
+      baseColorTexture: { index: 0 },
+      metallicRoughnessTexture: { index: 2 },
+      ...own ? { metallicFactor: 1, roughnessFactor: 1 } : {}
+    },
+    normalTexture: { index: 1 },
+    occlusionTexture: { index: 2 }
+  };
+}
+function materialsFor(used, withSheet = false) {
+  const present = ORDER.filter((s) => s === "opaque" || used.has(s));
+  const index = new Map(present.map((s, i) => [s, i]));
+  const ext = new Set;
+  for (const s of present)
+    for (const e of Object.keys(MATERIALS[s]["extensions"] ?? {}))
+      ext.add(e);
+  const materials = present.map((s) => withSheet ? textured(MATERIALS[s], s) : MATERIALS[s]);
+  return { materials, index, extensionsUsed: [...ext].sort() };
+}
+var EMISSIVE_STRENGTH = "KHR_materials_emissive_strength";
+function glowMaterial(rule, i, withSheet) {
+  const base = withSheet ? textured(MATERIALS.opaque, "opaque") : MATERIALS.opaque;
+  const strength = rule.strength ?? 4;
+  return {
+    ...base,
+    name: `ts23d_glow_${i}`,
+    emissiveFactor: [...rule.color ?? [1, 0.85, 0.6]],
+    ...strength !== 1 ? { extensions: { [EMISSIVE_STRENGTH]: { emissiveStrength: strength } } } : {}
+  };
+}
+
+// src/export/merge-pivots.ts
+var isPivot = (p) => p.mesh === null || p.motion !== null;
+var glowLayer = new WeakMap;
+var globRe = (pattern) => new RegExp(`^${pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replaceAll("*", ".*").replaceAll("?", ".")}$`);
+var SURFACES = ["cutout", "glass", "translucent"];
+function intoPivot(mesh, part, pivot) {
+  const positions = new Float32Array(mesh.positions.length);
+  const normals = new Float32Array(mesh.normals.length);
+  for (let i = 0;i < positions.length; i += 3) {
+    const w = toWorld2(part, [
+      mesh.positions[i] ?? 0,
+      mesh.positions[i + 1] ?? 0,
+      mesh.positions[i + 2] ?? 0
+    ]);
+    positions.set(rotateZ2([w[0] - pivot.origin[0], w[1] - pivot.origin[1], w[2] - pivot.origin[2]], -pivot.yaw), i);
+    normals.set(rotateZ2(rotateZ2([mesh.normals[i] ?? 0, mesh.normals[i + 1] ?? 0, mesh.normals[i + 2] ?? 0], part.yaw), -pivot.yaw), i);
+  }
+  return { ...mesh, positions, normals };
+}
+function mergeToPivots2(asset, glow = []) {
+  const glowRes = glow.map((globs) => globs.map(globRe));
+  const glowOf = (name) => glowRes.findIndex((rs) => rs.some((r) => r.test(name)));
+  const byName = new Map(asset.parts.map((p) => [p.name, p]));
+  const xf = worldTransforms2(asset.parts);
+  const ROOT = "body";
+  const identity = { origin: [0, 0, 0], yaw: 0 };
+  const pivotOf = (p) => {
+    let cur = p.parent ? byName.get(p.parent) : undefined;
+    while (cur && !isPivot(cur))
+      cur = cur.parent ? byName.get(cur.parent) : undefined;
+    return cur?.name ?? ROOT;
+  };
+  const extra = new Map;
+  const bucket = (pivot, surface, mesh, g = -1) => {
+    const k = `${pivot}|${g >= 0 ? `glow_${g}` : surface ?? "opaque"}`;
+    extra.set(k, [...extra.get(k) ?? [], mesh]);
+  };
+  for (const p of asset.parts) {
+    if (!p.mesh)
+      continue;
+    const g = glowOf(p.name);
+    if (isPivot(p)) {
+      bucket(p.name, p.surface, p.mesh, g);
+      continue;
+    }
+    const pivot = pivotOf(p);
+    const t = xf.get(p.name) ?? identity;
+    const pt = pivot === ROOT ? identity : xf.get(pivot) ?? identity;
+    bucket(pivot, p.surface, intoPivot(p.mesh, t, pt), g);
+  }
+  const parts = [];
+  const layers = (pivot, parent) => {
+    for (const surface of SURFACES) {
+      const meshes = extra.get(`${pivot}|${surface}`);
+      if (!meshes)
+        continue;
+      parts.push({
+        name: `${pivot}_${surface}`,
+        mesh: merge2(meshes),
+        at: [0, 0, 0],
+        parent,
+        yaw: 0,
+        motion: null,
+        surface
+      });
+    }
+    glow.forEach((_, g) => {
+      const meshes = extra.get(`${pivot}|glow_${g}`);
+      if (!meshes)
+        return;
+      const part = {
+        name: `${pivot}_glow_${g}`,
+        mesh: merge2(meshes),
+        at: [0, 0, 0],
+        parent,
+        yaw: 0,
+        motion: null
+      };
+      glowLayer.set(part, g);
+      parts.push(part);
+    });
+  };
+  const body = extra.get(`${ROOT}|opaque`);
+  if (body)
+    parts.push({
+      name: ROOT,
+      mesh: merge2(body),
+      at: [0, 0, 0],
+      parent: null,
+      yaw: 0,
+      motion: null
+    });
+  layers(ROOT, null);
+  for (const p of asset.parts) {
+    if (!isPivot(p))
+      continue;
+    const own = extra.get(`${p.name}|opaque`);
+    const { surface: _drop, ...rest } = p;
+    parts.push({ ...rest, mesh: own ? merge2(own) : null });
+    layers(p.name, p.name);
+  }
+  return { ...asset, parts };
+}
+
+// src/export/version.ts
+var VERSION = "0.2.0";
+var GENERATOR = `@developerz.ai/ts23d ${VERSION}`;
+
+// src/export/metadata.ts
+var XMP = "KHR_xmp_json_ld";
+var alt = (value) => ({
+  "@type": "rdf:Alt",
+  "rdf:_1": { "@language": "x-default", "@value": value }
+});
+function metadata(name, meta) {
+  const asset = {
+    version: "2.0",
+    generator: GENERATOR,
+    ...meta?.copyright ? { copyright: meta.copyright } : {}
+  };
+  if (!meta)
+    return { asset, used: [] };
+  const packet = {
+    "@context": {
+      dc: "http://purl.org/dc/elements/1.1/",
+      rdf: "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+      xmp: "http://ns.adobe.com/xap/1.0/",
+      xmpRights: "http://ns.adobe.com/xap/1.0/rights/"
+    },
+    "dc:title": alt(meta.title ?? name),
+    ...meta.description ? { "dc:description": alt(meta.description) } : {},
+    ...meta.creators?.length ? { "dc:creator": { "@list": [...meta.creators] } } : {},
+    ...meta.copyright ? { "dc:rights": alt(meta.copyright) } : {},
+    ...meta.license ? { "xmpRights:UsageTerms": alt(meta.license) } : {},
+    ...meta.sources?.length ? { "dc:relation": { "@set": [...meta.sources] } } : {},
+    ...meta.credits?.length ? { "dc:contributor": { "@set": [...meta.credits] } } : {},
+    "xmp:CreatorTool": GENERATOR
+  };
+  return {
+    asset: { ...asset, extensions: { [XMP]: { packet: 0 } } },
+    extensions: { [XMP]: { packets: [packet] } },
+    used: [XMP]
+  };
+}
+
+// src/export/optimize-parts.ts
+function summarize2(parts, optimized) {
+  const sum = (f) => parts.reduce((s, r) => s + f(r), 0);
+  const tb = sum((r) => r.trianglesBefore);
+  const ta = sum((r) => r.trianglesAfter);
+  const mean = (f, by, w) => by ? sum((r) => f(r) * (w === "b" ? r.trianglesBefore : r.trianglesAfter)) / by : 0;
+  return {
+    optimized,
+    verticesBefore: sum((r) => r.verticesBefore),
+    verticesAfter: sum((r) => r.verticesAfter),
+    trianglesBefore: tb,
+    trianglesAfter: ta,
+    degenerate: sum((r) => r.degenerate),
+    duplicate: sum((r) => r.duplicate),
+    acmrBefore: mean((r) => r.acmrBefore, tb, "b"),
+    acmr: mean((r) => r.acmr, ta, "a"),
+    atvrBefore: mean((r) => r.atvrBefore, tb, "b"),
+    atvr: mean((r) => r.atvr, ta, "a"),
+    parts
+  };
+}
+function optimizeParts2(asset, o) {
+  const reports = [];
+  const parts = asset.parts.map((p) => {
+    if (!p.mesh || p.mesh.indices.length === 0)
+      return p;
+    if (o === false) {
+      const v = p.mesh.positions.length / 3;
+      const t = p.mesh.indices.length / 3;
+      reports.push({
+        part: p.name,
+        verticesBefore: v,
+        verticesAfter: v,
+        trianglesBefore: t,
+        trianglesAfter: t,
+        degenerate: 0,
+        duplicate: 0,
+        acmrBefore: 0,
+        acmr: 0,
+        atvrBefore: 0,
+        atvr: 0
+      });
+      return p;
+    }
+    const { mesh, report } = optimize2(p.mesh, o);
+    reports.push({ part: p.name, ...report });
+    return { ...p, mesh };
+  });
+  return { asset: { ...asset, parts }, report: summarize2(reports, o !== false) };
+}
+
+// src/export/textures.ts
+var SHEET_MAPS2 = ["albedo", "normal", "orm"];
+var sheetFileName2 = (map, prefix = "trim_sheet") => `${prefix}_${map}.png`;
+var LINEAR = 9729;
+var LINEAR_MIPMAP_LINEAR = 9987;
+var REPEAT = 10497;
+var CLAMP_TO_EDGE = 33071;
+var pngCache = new WeakMap;
+function sheetPngs2(sheet) {
+  const hit = pngCache.get(sheet);
+  if (hit)
+    return hit;
+  const pngs = {
+    albedo: encodePng2(sheet.size, sheet.size, sheet.albedo),
+    normal: encodePng2(sheet.size, sheet.size, sheet.normal),
+    orm: encodePng2(sheet.size, sheet.size, sheet.orm)
+  };
+  pngCache.set(sheet, pngs);
+  return pngs;
+}
+var isExternal = (s) => ("external" in s);
+function sheetGltf(sheet, views, offset) {
+  const textures = SHEET_MAPS2.map((_, i) => ({ sampler: 0, source: i }));
+  const samplers = [
+    { magFilter: LINEAR, minFilter: LINEAR_MIPMAP_LINEAR, wrapS: REPEAT, wrapT: CLAMP_TO_EDGE }
+  ];
+  if (isExternal(sheet)) {
+    const images = SHEET_MAPS2.map((m) => ({
+      name: `trim_sheet_${m}`,
+      uri: sheetFileName2(m, sheet.prefix)
+    }));
+    return { json: { images, textures, samplers }, tail: new Uint8Array };
+  }
+  const pngs = sheetPngs2(sheet);
+  const parts = [];
+  const images = [];
+  let at = offset;
+  for (const m of SHEET_MAPS2) {
+    const png = pngs[m];
+    views.push({ buffer: 0, byteOffset: at, byteLength: png.byteLength });
+    images.push({ name: `trim_sheet_${m}`, bufferView: views.length - 1, mimeType: "image/png" });
+    const pad = (4 - png.byteLength % 4) % 4;
+    parts.push(png, new Uint8Array(pad));
+    at += png.byteLength + pad;
+  }
+  const tail = new Uint8Array(at - offset);
+  let o = 0;
+  for (const p of parts) {
+    tail.set(p, o);
+    o += p.byteLength;
+  }
+  return { json: { images, textures, samplers }, tail };
+}
+
+// src/export/glb.ts
+var Z_UP_TO_Y_UP = [-0.5, -0.5, -0.5, 0.5];
+function restClip(bin, roots) {
+  const input = bin.accessor(new Float32Array([0, 1]), "SCALAR", undefined, true);
+  const output = bin.accessor(new Float32Array([...Z_UP_TO_Y_UP, ...Z_UP_TO_Y_UP]), "VEC4");
+  return {
+    name: "rest",
+    samplers: [{ input, output, interpolation: "STEP" }],
+    channels: roots.map((node) => ({ sampler: 0, target: { node, path: "rotation" } }))
+  };
+}
+function toGlb2(input, o = {}) {
+  return exportGlb2(input, o).glb;
+}
+function exportGlb2(input, o = {}) {
+  const { glb, reports } = exportLodGlb2([input], o);
+  return { glb, report: reports[0] ?? summarize2([], false) };
+}
+function toLodGlb2(lods, o = {}) {
+  return exportLodGlb2(lods, o).glb;
+}
+function checkGlow(rules) {
+  for (const r of rules)
+    if ((r.strength ?? 4) < 0 || (r.color ?? [0, 0, 0]).some((c) => c < 0 || c > 1))
+      throw new Ts23dError2("T3D_RECIPE_INVALID", {
+        cause: `glow rule for ${JSON.stringify(r.parts)} has a colour outside 0..1 or a negative strength`,
+        fix: "colour is linear 0..1 (hex() converts sRGB); brightness goes in `strength`"
+      });
+}
+function checkLods(lods) {
+  const names = new Set(lods.map((l) => l.name));
+  const levels = lods.map((l) => l.lod);
+  if (lods.length === 0 || names.size !== 1 || levels.some((l, i) => i > 0 && l <= (levels[i - 1] ?? 0)))
+    throw new Ts23dError2("T3D_RECIPE_INVALID", {
+      cause: `exportLodGlb got LODs [${levels.join(", ")}] of [${[...names].join(", ")}]`,
+      fix: "pass compile(asset, { lod }) results of ONE asset, highest detail first: LOD0, LOD1, LOD2"
+    });
+}
+function prepare(input, o, glow) {
+  const opt = o.optimize === false ? false : o.optimize === true ? {} : o.optimize ?? {};
+  const merged = o.keepParts ? input : mergeToPivots2(input, glow.map((g) => g.parts));
+  const { asset, report } = optimizeParts2(merged, opt);
+  const glowRes = glow.map((g) => g.parts.map(globRe));
+  const glowOf = (p, i) => glowLayer.get(merged.parts[i] ?? p) ?? (o.keepParts ? glowRes.findIndex((rs) => rs.some((r) => r.test(p.name))) : -1);
+  return { asset, report, glowOf };
+}
+function exportLodGlb2(lods, o = {}) {
+  checkLods(lods);
+  const top = lods[0];
+  const glow = o.glow ?? top.glow ?? [];
+  checkGlow(glow);
+  const preps = lods.map((l) => prepare(l, o, glow));
+  const withSheet = o.sheet !== undefined;
+  const mats = materialsFor(new Set(preps.flatMap((p) => p.asset.parts.flatMap((q) => q.surface ? [q.surface] : []))), withSheet);
+  const glowAt = mats.materials.length;
+  const materials = [...mats.materials, ...glow.map((g, i) => glowMaterial(g, i, withSheet))];
+  const doc = newDoc(new BinWriter);
+  const roots = preps.map(({ asset, glowOf }, k) => writeHierarchy(doc, asset, k === 0 ? asset.name : `${asset.name}_LOD${asset.lod}`, {
+    withSheet,
+    animations: o.animations === true,
+    materialOf: (part, i) => {
+      const g = glowOf(part, i);
+      return g >= 0 ? glowAt + g : mats.index.get(part.surface ?? "opaque") ?? 0;
+    }
+  }));
+  for (const r of roots) {
+    const node = doc.nodes[r];
+    if (node)
+      node["rotation"] = Z_UP_TO_Y_UP;
+  }
+  const coverage = [];
+  const rootNode = doc.nodes[0];
+  if (roots.length > 1 && rootNode) {
+    const c = o.lodCoverage ?? top.lodCoverage ?? defaultCoverage2(lods);
+    checkCoverage2(c, top.name);
+    coverage.push(...coverageFor2(lods.map((l) => l.lod), c));
+    rootNode["extensions"] = { [MSFT_LOD2]: { ids: roots.slice(1) } };
+    rootNode["extras"] = { [SCREEN_COVERAGE2]: coverage };
+  }
+  const { bin, lights, samplers, channels } = doc;
+  const animations = channels.length ? [restClip(bin, roots), { name: "run", samplers, channels }] : [];
+  const geometry = bin.bytes();
+  const tex = o.sheet ? sheetGltf(o.sheet, bin.views, geometry.byteLength) : null;
+  const body = tex?.tail.byteLength ? concat(geometry, tex.tail) : geometry;
+  const meta = metadata(top.name, withCredits(top, o.meta ?? top.meta));
+  const used = [
+    ...mats.extensionsUsed,
+    ...glow.some((g) => (g.strength ?? 4) !== 1) ? [EMISSIVE_STRENGTH] : [],
+    ...lights.length ? [LIGHTS] : [],
+    ...coverage.length ? [MSFT_LOD2] : [],
+    ...meta.used
+  ].sort();
+  const extensions = {
+    ...lights.length ? { [LIGHTS]: { lights } } : {},
+    ...meta.extensions ?? {}
+  };
+  const gltf = {
+    asset: meta.asset,
+    extras: {
+      kind: top.kind,
+      lod: coverage.length ? lods.map((l) => l.lod) : top.lod,
+      units: "metres",
+      up: "Z (rotated to glTF Y-up at the root)"
+    },
+    ...used.length ? { extensionsUsed: used } : {},
+    ...Object.keys(extensions).length ? { extensions } : {},
+    scene: 0,
+    scenes: [{ name: top.name, nodes: [0] }],
+    nodes: doc.nodes,
+    meshes: doc.meshes,
+    materials,
+    ...tex ? tex.json : {},
+    buffers: [{ byteLength: body.byteLength }],
+    bufferViews: bin.views,
+    accessors: bin.accessors,
+    ...animations.length ? { animations } : {}
+  };
+  return { glb: packGlb(gltf, body), reports: preps.map((p) => p.report), coverage };
+}
+export { MSFT_LOD2, SCREEN_COVERAGE2, defaultCoverage2, checkCoverage2, coverageFor2, mergeToPivots2, summarize2, optimizeParts2, SHEET_MAPS2, sheetFileName2, sheetPngs2, toGlb2, exportGlb2, toLodGlb2, exportLodGlb2 };
+
+//# debugId=48DF0BBA03847F0964756E2164756E21
+//# sourceMappingURL=chunk-dbq4qf52.js.map