@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/dist/chunk-drna2rny.js

@@ -0,0 +1,836 @@
+import {
+  boundsOf2,
+  merge2,
+  worldMeshes2
+} from "./chunk-hg7pf34j.js";
+
+// src/passes/ray-grid.ts
+var CELL_SCALE = 0.3;
+
+class RayGrid2 {
+  tri;
+  edges;
+  planes;
+  start;
+  list;
+  min;
+  res;
+  cell;
+  stamp;
+  ray = 0;
+  constructor(mesh) {
+    const n = mesh.indices.length / 3;
+    this.tri = new Float64Array(n * 9);
+    for (let t = 0;t < n; t++)
+      for (let v = 0;v < 3; v++) {
+        const i = (mesh.indices[t * 3 + v] ?? 0) * 3;
+        for (let k = 0;k < 3; k++)
+          this.tri[t * 9 + v * 3 + k] = mesh.positions[i + k] ?? 0;
+      }
+    this.edges = new Float64Array(n * 9);
+    for (let t = 0;t < n; t++) {
+      const o = t * 9;
+      for (let k = 0;k < 3; k++) {
+        const v0 = this.tri[o + k] ?? 0;
+        this.edges[o + k] = v0;
+        this.edges[o + 3 + k] = (this.tri[o + 3 + k] ?? 0) - v0;
+        this.edges[o + 6 + k] = (this.tri[o + 6 + k] ?? 0) - v0;
+      }
+    }
+    this.planes = new Float64Array(n * 4);
+    for (let t = 0;t < n; t++) {
+      const E = this.edges;
+      const o = t * 9;
+      const [ax, ay, az] = [E[o + 3] ?? 0, E[o + 4] ?? 0, E[o + 5] ?? 0];
+      const [bx, by, bz] = [E[o + 6] ?? 0, E[o + 7] ?? 0, E[o + 8] ?? 0];
+      const nx = ay * bz - az * by;
+      const ny = az * bx - ax * bz;
+      const nz = ax * by - ay * bx;
+      this.planes.set([nx, ny, nz, nx * (E[o] ?? 0) + ny * (E[o + 1] ?? 0) + nz * (E[o + 2] ?? 0)], t * 4);
+    }
+    const b = boundsOf2(mesh);
+    const span = [0, 1, 2].map((k) => Math.max(0.000001, (b.max[k] ?? 0) - (b.min[k] ?? 0)));
+    const vol = (span[0] ?? 1) * (span[1] ?? 1) * (span[2] ?? 1);
+    this.cell = Math.max(CELL_SCALE * Math.cbrt(vol / Math.max(1, n / 2)), Math.max(...span) / 256, Math.cbrt(vol / 4000000), 0.0001);
+    this.min = [b.min[0] - 0.000001, b.min[1] - 0.000001, b.min[2] - 0.000001];
+    this.res = [0, 1, 2].map((k) => Math.max(1, Math.ceil((span[k] ?? 0) / this.cell) + 1));
+    const [rx, ry] = this.res;
+    const cells = rx * ry * this.res[2];
+    const box = new Int32Array(n * 6);
+    const T = this.tri;
+    for (let t = 0;t < n; t++)
+      for (let k = 0;k < 3; k++) {
+        const a = T[t * 9 + k] ?? 0;
+        const b2 = T[t * 9 + 3 + k] ?? 0;
+        const c = T[t * 9 + 6 + k] ?? 0;
+        box[t * 6 + k] = this.coord(Math.min(a, b2, c), k);
+        box[t * 6 + 3 + k] = this.coord(Math.max(a, b2, c), k);
+      }
+    const count = new Int32Array(cells + 1);
+    const visit = (t, f) => {
+      const o = t * 6;
+      for (let x = box[o] ?? 0;x <= (box[o + 3] ?? 0); x++)
+        for (let y = box[o + 1] ?? 0;y <= (box[o + 4] ?? 0); y++)
+          for (let z = box[o + 2] ?? 0;z <= (box[o + 5] ?? 0); z++)
+            f((z * ry + y) * rx + x);
+    };
+    const bump = (c) => {
+      count[c + 1] = (count[c + 1] ?? 0) + 1;
+    };
+    for (let t = 0;t < n; t++)
+      visit(t, bump);
+    for (let c = 0;c < cells; c++)
+      count[c + 1] = (count[c + 1] ?? 0) + (count[c] ?? 0);
+    this.start = count;
+    const list = new Int32Array(count[cells] ?? 0);
+    const fill = new Int32Array(cells);
+    for (let t = 0;t < n; t++)
+      visit(t, (c) => {
+        list[(count[c] ?? 0) + (fill[c] ?? 0)] = t;
+        fill[c] = (fill[c] ?? 0) + 1;
+      });
+    this.list = list;
+    this.stamp = new Int32Array(n);
+  }
+  coord(v, k) {
+    const r = this.res[k];
+    return Math.min(r - 1, Math.max(0, Math.floor((v - (this.min[k] ?? 0)) / this.cell)));
+  }
+  hit(ox, oy, oz, dx, dy, dz, tMax) {
+    const q = ++this.ray;
+    const start = this.start;
+    const list = this.list;
+    const stamp = this.stamp;
+    const size = this.cell;
+    const [rx, ry, rz] = this.res;
+    const [mx, my, mz] = this.min;
+    let cx = this.coord(ox, 0);
+    let cy = this.coord(oy, 1);
+    let cz = this.coord(oz, 2);
+    const sx = dx > 0 ? 1 : -1;
+    const sy = dy > 0 ? 1 : -1;
+    const sz = dz > 0 ? 1 : -1;
+    let nx = Math.abs(dx) < 0.000000000001 ? Infinity : (mx + (cx + (dx > 0 ? 1 : 0)) * size - ox) / dx;
+    let ny = Math.abs(dy) < 0.000000000001 ? Infinity : (my + (cy + (dy > 0 ? 1 : 0)) * size - oy) / dy;
+    let nz = Math.abs(dz) < 0.000000000001 ? Infinity : (mz + (cz + (dz > 0 ? 1 : 0)) * size - oz) / dz;
+    const ddx = Math.abs(dx) < 0.000000000001 ? Infinity : size / Math.abs(dx);
+    const ddy = Math.abs(dy) < 0.000000000001 ? Infinity : size / Math.abs(dy);
+    const ddz = Math.abs(dz) < 0.000000000001 ? Infinity : size / Math.abs(dz);
+    let t = 0;
+    while (t <= tMax) {
+      const c = (cz * ry + cy) * rx + cx;
+      const end = start[c + 1] ?? 0;
+      for (let i = start[c] ?? 0;i < end; i++) {
+        const tri = list[i] ?? 0;
+        if (stamp[tri] === q)
+          continue;
+        stamp[tri] = q;
+        if (this.test(tri, ox, oy, oz, dx, dy, dz, tMax))
+          return true;
+      }
+      if (nx < ny) {
+        if (nx < nz) {
+          t = nx;
+          cx += sx;
+          if (cx < 0 || cx >= rx)
+            return false;
+          nx = t + ddx;
+        } else {
+          t = nz;
+          cz += sz;
+          if (cz < 0 || cz >= rz)
+            return false;
+          nz = t + ddz;
+        }
+      } else if (ny < nz) {
+        t = ny;
+        cy += sy;
+        if (cy < 0 || cy >= ry)
+          return false;
+        ny = t + ddy;
+      } else {
+        t = nz;
+        cz += sz;
+        if (cz < 0 || cz >= rz)
+          return false;
+        nz = t + ddz;
+      }
+    }
+    return false;
+  }
+  test(tri, ox, oy, oz, dx, dy, dz, tMax) {
+    const P = this.planes;
+    const f = tri * 4;
+    const nx = P[f] ?? 0;
+    const ny = P[f + 1] ?? 0;
+    const nz = P[f + 2] ?? 0;
+    const th0 = ((P[f + 3] ?? 0) - (nx * ox + ny * oy + nz * oz)) / (nx * dx + ny * dy + nz * dz);
+    if (!(th0 > -0.000000001 && th0 <= tMax * (1 + 0.000000001) + 0.000000001))
+      return false;
+    const E = this.edges;
+    const b = tri * 9;
+    const e1x = E[b + 3] ?? 0;
+    const e1y = E[b + 4] ?? 0;
+    const e1z = E[b + 5] ?? 0;
+    const e2x = E[b + 6] ?? 0;
+    const e2y = E[b + 7] ?? 0;
+    const e2z = E[b + 8] ?? 0;
+    const px = dy * e2z - dz * e2y;
+    const py = dz * e2x - dx * e2z;
+    const pz = dx * e2y - dy * e2x;
+    const det = e1x * px + e1y * py + e1z * pz;
+    if (Math.abs(det) < 0.00000000000001)
+      return false;
+    const inv = 1 / det;
+    const tx = ox - (E[b] ?? 0);
+    const ty = oy - (E[b + 1] ?? 0);
+    const tz = oz - (E[b + 2] ?? 0);
+    const u = (tx * px + ty * py + tz * pz) * inv;
+    if (u < 0 || u > 1)
+      return false;
+    const qx = ty * e1z - tz * e1y;
+    const qy = tz * e1x - tx * e1z;
+    const qz = tx * e1y - ty * e1x;
+    const v = (dx * qx + dy * qy + dz * qz) * inv;
+    if (v < 0 || u + v > 1)
+      return false;
+    const th = (e2x * qx + e2y * qy + e2z * qz) * inv;
+    return th > 0 && th <= tMax;
+  }
+  occluded(o, d, tMax) {
+    return this.hit(o[0], o[1], o[2], d[0], d[1], d[2], tMax);
+  }
+}
+
+// src/passes/bake-ao.ts
+var GOLDEN = Math.PI * (3 - Math.sqrt(5));
+function hemisphere(n) {
+  return Array.from({ length: n }, (_, i) => {
+    const r = Math.sqrt((i + 0.5) / n);
+    const phi = i * GOLDEN;
+    return [r * Math.cos(phi), r * Math.sin(phi), Math.sqrt(Math.max(0, 1 - r * r))];
+  });
+}
+function frame(n) {
+  const s = n[2] >= 0 ? 1 : -1;
+  const a = -1 / (s + n[2]);
+  const b = n[0] * n[1] * a;
+  return [
+    [1 + s * n[0] * n[0] * a, s * b, -s * n[0]],
+    [b, s + n[1] * n[1] * a, -n[1]]
+  ];
+}
+
+class Memo {
+  keys;
+  vals;
+  used;
+  mask;
+  constructor(n) {
+    let cap = 16;
+    while (cap < n * 2)
+      cap *= 2;
+    this.mask = cap - 1;
+    this.keys = new Float64Array(cap * 6);
+    this.vals = new Float64Array(cap);
+    this.used = new Uint8Array(cap);
+  }
+  slot(k) {
+    let h = 2166136261;
+    for (let i = 0;i < 6; i++)
+      h = Math.imul(h ^ ((k[i] ?? 0) | 0), 16777619);
+    let at = h >>> 0 & this.mask;
+    for (;; ) {
+      if (!this.used[at])
+        return { at, found: false };
+      let same = true;
+      for (let i = 0;i < 6 && same; i++)
+        same = this.keys[at * 6 + i] === k[i];
+      if (same)
+        return { at, found: true };
+      at = at + 1 & this.mask;
+    }
+  }
+  get(at) {
+    return this.vals[at] ?? 0;
+  }
+  set(at, k, v) {
+    this.used[at] = 1;
+    this.keys.set(k, at * 6);
+    this.vals[at] = v;
+  }
+}
+function visibility(mesh, grid, o) {
+  const hemi = hemisphere(o.samples ?? 24);
+  const D = Float64Array.from(hemi.flat());
+  const count = hemi.length;
+  const radius = o.radius ?? 1;
+  const ground = o.ground ?? true;
+  const P = mesh.positions;
+  const N = mesh.normals;
+  const out = new Float32Array(P.length / 3);
+  const memo = new Memo(out.length);
+  const key = new Float64Array(6);
+  const bias = 0.002;
+  for (let v = 0;v < out.length; v++) {
+    const px = P[v * 3] ?? 0;
+    const py = P[v * 3 + 1] ?? 0;
+    const pz = P[v * 3 + 2] ?? 0;
+    const rx = N[v * 3] ?? 0;
+    const ry = N[v * 3 + 1] ?? 0;
+    const rz = N[v * 3 + 2] ?? 1;
+    const len = Math.hypot(rx, ry, rz) || 1;
+    const n = [rx / len, ry / len, rz / len];
+    key[0] = Math.round(px * 1e4);
+    key[1] = Math.round(py * 1e4);
+    key[2] = Math.round(pz * 1e4);
+    key[3] = Math.round(n[0] * 1000);
+    key[4] = Math.round(n[1] * 1000);
+    key[5] = Math.round(n[2] * 1000);
+    const s = memo.slot(key);
+    if (s.found) {
+      out[v] = memo.get(s.at);
+      continue;
+    }
+    const [t, b] = frame(n);
+    const ox = px + n[0] * bias;
+    const oy = py + n[1] * bias;
+    const oz = pz + n[2] * bias;
+    let blocked = 0;
+    for (let i = 0;i < count; i++) {
+      const d0 = D[i * 3] ?? 0;
+      const d1 = D[i * 3 + 1] ?? 0;
+      const d2 = D[i * 3 + 2] ?? 0;
+      const wx = t[0] * d0 + b[0] * d1 + n[0] * d2;
+      const wy = t[1] * d0 + b[1] * d1 + n[1] * d2;
+      const wz = t[2] * d0 + b[2] * d1 + n[2] * d2;
+      if (ground && wz < -0.000001 && oz >= 0 && -oz / wz <= radius)
+        blocked++;
+      else if (grid.hit(ox, oy, oz, wx, wy, wz, radius))
+        blocked++;
+    }
+    const vis = 1 - blocked / count;
+    memo.set(s.at, key, vis);
+    out[v] = vis;
+  }
+  return out;
+}
+var darken = (mesh, vis, strength) => {
+  const colors = new Float32Array(mesh.colors);
+  for (let v = 0;v < vis.length; v++) {
+    const f = 1 - strength * (1 - (vis[v] ?? 1));
+    for (let k = 0;k < 3; k++)
+      colors[v * 3 + k] = (colors[v * 3 + k] ?? 0) * f;
+  }
+  return { ...mesh, colors };
+};
+var grids = new WeakMap;
+var gridOf = (m) => {
+  const hit = grids.get(m);
+  if (hit)
+    return hit;
+  const g = new RayGrid2(m);
+  grids.set(m, g);
+  return g;
+};
+function bakeAo2(mesh, o = {}, occluder = mesh) {
+  return darken(mesh, visibility(mesh, gridOf(occluder), o), o.strength ?? 0.6);
+}
+function bakeAoAsset2(asset, o = {}) {
+  const world = worldMeshes2(asset.parts);
+  if (world.size === 0)
+    return asset;
+  const grid = new RayGrid2(merge2([...world.values()]));
+  const strength = o.strength ?? 0.6;
+  return {
+    ...asset,
+    parts: asset.parts.map((p) => {
+      const w = world.get(p.name);
+      return p.mesh && w ? { ...p, mesh: darken(p.mesh, visibility(w, grid, o), strength) } : p;
+    })
+  };
+}
+// src/passes/grime.ts
+function grime2(mesh, o) {
+  const colors = new Float32Array(mesh.colors);
+  const g = o.ground ?? 0;
+  const gs = o.groundStrength ?? 0.3;
+  for (let i = 0;i < mesh.positions.length / 3; i++) {
+    const x = mesh.positions[i * 3] ?? 0;
+    const y = mesh.positions[i * 3 + 1] ?? 0;
+    const z = mesh.positions[i * 3 + 2] ?? 0;
+    let f = g > 0 && z < g ? 1 - gs * (1 - Math.max(0, z) / g) : 1;
+    for (const zone of o.zones ?? []) {
+      const d = Math.hypot(x - zone.at[0], y - zone.at[1], z - zone.at[2]) / zone.radius;
+      if (d < 1)
+        f *= 1 - zone.strength * (1 - d);
+    }
+    for (let k = 0;k < 3; k++)
+      colors[i * 3 + k] = (colors[i * 3 + k] ?? 1) * f;
+  }
+  return { ...mesh, colors };
+}
+// src/passes/livery.ts
+function inPoly(poly, x, z) {
+  let inside = false;
+  for (let i = 0, j = poly.length - 1;i < poly.length; j = i++) {
+    const [xi, zi] = poly[i] ?? [0, 0];
+    const [xj, zj] = poly[j] ?? [0, 0];
+    if (zi > z !== zj > z && x < (xj - xi) * (z - zi) / (zj - zi) + xi)
+      inside = !inside;
+  }
+  return inside;
+}
+function faces(f, n) {
+  if (f === "roof")
+    return n[2] > 0.55;
+  if (f === "under")
+    return n[2] < -0.55;
+  if (f === "front")
+    return n[0] > 0.5;
+  if (f === "back")
+    return n[0] < -0.5;
+  return Math.abs(n[1]) > 0.5;
+}
+function livery2(mesh, l) {
+  const colors = new Float32Array(mesh.colors);
+  for (let i = 0;i < mesh.positions.length / 3; i++) {
+    const x = mesh.positions[i * 3] ?? 0;
+    const z = mesh.positions[i * 3 + 2] ?? 0;
+    const n = [
+      mesh.normals[i * 3] ?? 0,
+      mesh.normals[i * 3 + 1] ?? 0,
+      mesh.normals[i * 3 + 2] ?? 0
+    ];
+    let c = l.base ?? [colors[i * 3] ?? 1, colors[i * 3 + 1] ?? 1, colors[i * 3 + 2] ?? 1];
+    for (const r of l.rules) {
+      if (r.z && (z < r.z[0] || z > r.z[1]))
+        continue;
+      if (r.x && (x < r.x[0] || x > r.x[1]))
+        continue;
+      if (r.poly && !inPoly(r.poly, x, z))
+        continue;
+      if (r.facing && !faces(r.facing, n))
+        continue;
+      c = r.multiply ? [c[0] * r.color[0], c[1] * r.color[1], c[2] * r.color[2]] : r.color;
+    }
+    colors.set(c, i * 3);
+  }
+  return { ...mesh, colors };
+}
+// src/passes/optimize-cache.ts
+var CACHE = 32;
+var DECAY = 1.5;
+var LAST_TRI = 0.75;
+var VALENCE_SCALE = 2;
+var VALENCE_POWER = 0.5;
+var MAX_VALENCE = 64;
+var CACHE_SCORE = Float64Array.from({ length: CACHE }, (_, i) => i < 3 ? LAST_TRI : (1 - (i - 3) / (CACHE - 3)) ** DECAY);
+var VALENCE_SCORE = Float64Array.from({ length: MAX_VALENCE + 1 }, (_, n) => n === 0 ? 0 : VALENCE_SCALE * n ** -VALENCE_POWER);
+var vertexScore = (pos, live) => live === 0 ? -1 : (pos >= 0 ? CACHE_SCORE[pos] ?? 0 : 0) + (VALENCE_SCORE[Math.min(live, MAX_VALENCE)] ?? 0);
+function forsyth(indices, vertexCount) {
+  const triCount = indices.length / 3;
+  if (triCount === 0)
+    return new Uint32Array(0);
+  const live = new Int32Array(vertexCount);
+  for (const v of indices)
+    live[v] = (live[v] ?? 0) + 1;
+  const offset = new Int32Array(vertexCount + 1);
+  for (let v = 0;v < vertexCount; v++)
+    offset[v + 1] = (offset[v] ?? 0) + (live[v] ?? 0);
+  const adj = new Int32Array(indices.length);
+  const fill = new Int32Array(vertexCount);
+  for (let t = 0;t < triCount; t++)
+    for (let k = 0;k < 3; k++) {
+      const v = indices[t * 3 + k] ?? 0;
+      adj[(offset[v] ?? 0) + (fill[v] ?? 0)] = t;
+      fill[v] = (fill[v] ?? 0) + 1;
+    }
+  const cachePos = new Int32Array(vertexCount).fill(-1);
+  const score = new Float64Array(vertexCount);
+  for (let v = 0;v < vertexCount; v++)
+    score[v] = vertexScore(-1, live[v] ?? 0);
+  const emitted = new Uint8Array(triCount);
+  const triScoreOf = (t) => (score[indices[t * 3] ?? 0] ?? 0) + (score[indices[t * 3 + 1] ?? 0] ?? 0) + (score[indices[t * 3 + 2] ?? 0] ?? 0);
+  let best = 0;
+  let top = triScoreOf(0);
+  for (let t = 1;t < triCount; t++) {
+    const s = triScoreOf(t);
+    if (s > top) {
+      top = s;
+      best = t;
+    }
+  }
+  const out = new Uint32Array(indices.length);
+  let cache = new Int32Array(CACHE + 3);
+  let spare = new Int32Array(CACHE + 3);
+  let size = 0;
+  let cursor = 0;
+  for (let n = 0;n < triCount; n++) {
+    if (best < 0) {
+      while (emitted[cursor])
+        cursor++;
+      best = cursor;
+    }
+    const t = best;
+    emitted[t] = 1;
+    const a = indices[t * 3] ?? 0;
+    const b = indices[t * 3 + 1] ?? 0;
+    const c = indices[t * 3 + 2] ?? 0;
+    out[n * 3] = a;
+    out[n * 3 + 1] = b;
+    out[n * 3 + 2] = c;
+    for (const v of [a, b, c]) {
+      const o = offset[v] ?? 0;
+      const l = live[v] ?? 0;
+      for (let i = o;i < o + l; i++)
+        if (adj[i] === t) {
+          adj[i] = adj[o + l - 1] ?? 0;
+          adj[o + l - 1] = t;
+          break;
+        }
+      live[v] = l - 1;
+    }
+    spare[0] = a;
+    spare[1] = b;
+    spare[2] = c;
+    let m = 3;
+    for (let i = 0;i < size; i++) {
+      const v = cache[i] ?? 0;
+      if (v !== a && v !== b && v !== c)
+        spare[m++] = v;
+    }
+    for (let i = CACHE;i < m; i++) {
+      const v = spare[i] ?? 0;
+      cachePos[v] = -1;
+      score[v] = vertexScore(-1, live[v] ?? 0);
+    }
+    [cache, spare] = [spare, cache];
+    size = Math.min(m, CACHE);
+    for (let i = 0;i < size; i++) {
+      const v = cache[i] ?? 0;
+      cachePos[v] = i;
+      score[v] = vertexScore(i, live[v] ?? 0);
+    }
+    best = -1;
+    let bestScore = -Infinity;
+    for (let j = 0;j < size; j++) {
+      const v = cache[j] ?? 0;
+      const o = offset[v] ?? 0;
+      for (let i = o;i < o + (live[v] ?? 0); i++) {
+        const u = adj[i] ?? 0;
+        const s = triScoreOf(u);
+        if (s > bestScore || s === bestScore && u < best) {
+          bestScore = s;
+          best = u;
+        }
+      }
+    }
+  }
+  return out;
+}
+function fetchOrder(indices, vertexCount) {
+  const map = new Int32Array(vertexCount).fill(-1);
+  const order = [];
+  const out = new Uint32Array(indices.length);
+  for (let i = 0;i < indices.length; i++) {
+    const v = indices[i] ?? 0;
+    if ((map[v] ?? -1) < 0) {
+      map[v] = order.length;
+      order.push(v);
+    }
+    out[i] = map[v] ?? 0;
+  }
+  return { indices: out, order: Uint32Array.from(order) };
+}
+function cacheStats(indices, vertexCount, size = 16) {
+  const tris = indices.length / 3;
+  if (tris === 0)
+    return { acmr: 0, atvr: 0 };
+  const stamp = new Int32Array(vertexCount).fill(-1e9);
+  let misses = 0;
+  for (const v of indices) {
+    if (misses - (stamp[v] ?? 0) >= size) {
+      stamp[v] = misses;
+      misses++;
+    }
+  }
+  const seen = new Uint8Array(vertexCount);
+  let used = 0;
+  for (const v of indices)
+    if (!seen[v]) {
+      seen[v] = 1;
+      used++;
+    }
+  return { acmr: misses / tris, atvr: used ? misses / used : 0 };
+}
+
+// src/passes/optimize-weld.ts
+var DEFAULT_WELD = {
+  position: 0.00001,
+  normal: 0.001,
+  uv: 0.00001,
+  color: 1 / 131072
+};
+function cellOf(m, i, t, out) {
+  for (let k = 0;k < 3; k++) {
+    out[k] = Math.round((m.positions[i * 3 + k] ?? 0) / t.position);
+    out[3 + k] = Math.round((m.normals[i * 3 + k] ?? 0) / t.normal);
+    out[8 + k] = Math.round((m.colors[i * 3 + k] ?? 0) / t.color);
+  }
+  out[6] = Math.round((m.uvs[i * 2] ?? 0) / t.uv);
+  out[7] = Math.round((m.uvs[i * 2 + 1] ?? 0) / t.uv);
+  out[11] = 0;
+}
+var hashCell = (c) => {
+  let h = 2166136261;
+  for (let k = 0;k < 11; k++)
+    h = Math.imul(h ^ (c[k] ?? 0), 16777619);
+  return h >>> 0;
+};
+function weldMap(m, t) {
+  const n = m.positions.length / 3;
+  const cells = new Int32Array(n * 12);
+  const remap = new Uint32Array(n);
+  const keep = [];
+  let cap = 16;
+  while (cap < n * 2)
+    cap *= 2;
+  const table = new Int32Array(cap).fill(-1);
+  const cur = new Int32Array(12);
+  for (let i = 0;i < n; i++) {
+    cellOf(m, i, t, cur);
+    cells.set(cur, i * 12);
+    let slot = hashCell(cur) & cap - 1;
+    let found = -1;
+    for (;; ) {
+      const j = table[slot] ?? -1;
+      if (j < 0)
+        break;
+      const rep = (keep[j] ?? 0) * 12;
+      let same = true;
+      for (let k = 0;k < 11 && same; k++)
+        same = cells[rep + k] === cur[k];
+      if (same) {
+        found = j;
+        break;
+      }
+      slot = slot + 1 & cap - 1;
+    }
+    if (found < 0) {
+      found = keep.length;
+      keep.push(i);
+      table[slot] = found;
+    }
+    remap[i] = found;
+  }
+  return { remap, keep };
+}
+function area2(p, a, b, c) {
+  const ax = p[a * 3] ?? 0;
+  const ay = p[a * 3 + 1] ?? 0;
+  const az = p[a * 3 + 2] ?? 0;
+  const ux = (p[b * 3] ?? 0) - ax;
+  const uy = (p[b * 3 + 1] ?? 0) - ay;
+  const uz = (p[b * 3 + 2] ?? 0) - az;
+  const vx = (p[c * 3] ?? 0) - ax;
+  const vy = (p[c * 3 + 1] ?? 0) - ay;
+  const vz = (p[c * 3 + 2] ?? 0) - az;
+  return Math.hypot(uy * vz - uz * vy, uz * vx - ux * vz, ux * vy - uy * vx);
+}
+function weld(m, t = DEFAULT_WELD) {
+  const { remap, keep } = weldMap(m, t);
+  const pick = (src, w) => {
+    const out = new Float32Array(keep.length * w);
+    keep.forEach((i, j) => {
+      for (let k = 0;k < w; k++)
+        out[j * w + k] = src[i * w + k] ?? 0;
+    });
+    return out;
+  };
+  const positions = pick(m.positions, 3);
+  const idx = [];
+  const seen = new Map;
+  let degenerate = 0;
+  let duplicate = 0;
+  for (let f = 0;f < m.indices.length; f += 3) {
+    const a = remap[m.indices[f] ?? 0] ?? 0;
+    const b = remap[m.indices[f + 1] ?? 0] ?? 0;
+    const c = remap[m.indices[f + 2] ?? 0] ?? 0;
+    if (a === b || b === c || a === c || area2(positions, a, b, c) < 0.000000000001) {
+      degenerate++;
+      continue;
+    }
+    const [x, y, z] = a < b && a < c ? [a, b, c] : b < c ? [b, c, a] : [c, a, b];
+    const h = (Math.imul(x, 73856093) ^ Math.imul(y, 19349663) ^ Math.imul(z, 83492791)) >>> 0;
+    const list = seen.get(h);
+    if (list?.some((at) => idx[at] === x && idx[at + 1] === y && idx[at + 2] === z)) {
+      duplicate++;
+      continue;
+    }
+    if (list)
+      list.push(idx.length);
+    else
+      seen.set(h, [idx.length]);
+    idx.push(x, y, z);
+  }
+  return {
+    mesh: {
+      positions,
+      normals: pick(m.normals, 3),
+      uvs: pick(m.uvs, 2),
+      colors: pick(m.colors, 3),
+      indices: new Uint32Array(idx)
+    },
+    degenerate,
+    duplicate
+  };
+}
+
+// src/passes/optimize.ts
+function reorderVertices(m, order, indices) {
+  const pick = (src, w) => {
+    const out = new Float32Array(order.length * w);
+    for (let j = 0;j < order.length; j++)
+      for (let k = 0;k < w; k++)
+        out[j * w + k] = src[(order[j] ?? 0) * w + k] ?? 0;
+    return out;
+  };
+  return {
+    positions: pick(m.positions, 3),
+    normals: pick(m.normals, 3),
+    uvs: pick(m.uvs, 2),
+    colors: pick(m.colors, 3),
+    indices
+  };
+}
+function optimize2(mesh, o = {}) {
+  const vBefore = mesh.positions.length / 3;
+  const before = cacheStats(mesh.indices, vBefore);
+  const tol = { ...DEFAULT_WELD, position: o.weldEpsilon ?? DEFAULT_WELD.position };
+  const w = weld(mesh, tol);
+  const vWelded = w.mesh.positions.length / 3;
+  const reordered = o.vertexCache === false ? null : forsyth(w.mesh.indices, vWelded);
+  const tris = reordered && cacheStats(reordered, vWelded).acmr <= cacheStats(w.mesh.indices, vWelded).acmr ? reordered : w.mesh.indices;
+  const fetched = fetchOrder(tris, vWelded);
+  const out = reorderVertices(w.mesh, fetched.order, fetched.indices);
+  const after = cacheStats(out.indices, out.positions.length / 3);
+  return {
+    mesh: out,
+    report: {
+      verticesBefore: vBefore,
+      verticesAfter: out.positions.length / 3,
+      trianglesBefore: mesh.indices.length / 3,
+      trianglesAfter: out.indices.length / 3,
+      degenerate: w.degenerate,
+      duplicate: w.duplicate,
+      acmrBefore: before.acmr,
+      acmr: after.acmr,
+      atvrBefore: before.atvr,
+      atvr: after.atvr
+    }
+  };
+}
+// src/passes/weighted-normals.ts
+function faceData(m, t) {
+  const p = (k) => {
+    const i = (m.indices[t * 3 + k] ?? 0) * 3;
+    return [m.positions[i] ?? 0, m.positions[i + 1] ?? 0, m.positions[i + 2] ?? 0];
+  };
+  const v = [p(0), p(1), p(2)];
+  const e = (a, b) => [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+  const u = e(v[0], v[1]);
+  const w = e(v[0], v[2]);
+  const g = [u[1] * w[2] - u[2] * w[1], u[2] * w[0] - u[0] * w[2], u[0] * w[1] - u[1] * w[0]];
+  const len = Math.hypot(...g);
+  const angle = (k) => {
+    const a = e(v[k] ?? v[0], v[(k + 1) % 3] ?? v[0]);
+    const b = e(v[k] ?? v[0], v[(k + 2) % 3] ?? v[0]);
+    const d = Math.hypot(...a) * Math.hypot(...b);
+    return d ? Math.acos(Math.max(-1, Math.min(1, (a[0] * b[0] + a[1] * b[1] + a[2] * b[2]) / d))) : 0;
+  };
+  return {
+    n: len ? [g[0] / len, g[1] / len, g[2] / len] : [0, 0, 0],
+    area: len / 2,
+    angles: [angle(0), angle(1), angle(2)]
+  };
+}
+function weightedNormals2(m, o = {}) {
+  const cosHard = Math.cos((o.hardAngle ?? 40) * Math.PI / 180);
+  const eps = o.epsilon ?? 0.00001;
+  const tris = m.indices.length / 3;
+  const corners = [];
+  for (let t = 0;t < tris; t++) {
+    const f = faceData(m, t);
+    for (let k = 0;k < 3; k++)
+      corners.push({ n: f.n, w: f.area * (f.angles[k] ?? 0) });
+  }
+  const groups = new Map;
+  const keyOf = (i) => [0, 1, 2].map((k) => Math.round((m.positions[i * 3 + k] ?? 0) / eps)).join(",");
+  for (let c = 0;c < corners.length; c++) {
+    const key = keyOf(m.indices[c] ?? 0);
+    const g = groups.get(key);
+    if (g)
+      g.push(c);
+    else
+      groups.set(key, [c]);
+  }
+  const normal = new Float32Array(corners.length * 3);
+  for (const g of groups.values())
+    for (const c of g) {
+      const me = corners[c];
+      if (!me)
+        continue;
+      let x = 0;
+      let y = 0;
+      let z = 0;
+      for (const d of g) {
+        const o2 = corners[d];
+        if (!o2 || me.n[0] * o2.n[0] + me.n[1] * o2.n[1] + me.n[2] * o2.n[2] < cosHard)
+          continue;
+        x += o2.n[0] * o2.w;
+        y += o2.n[1] * o2.w;
+        z += o2.n[2] * o2.w;
+      }
+      const len = Math.hypot(x, y, z);
+      const src = (m.indices[c] ?? 0) * 3;
+      normal.set(len > 0.000000000001 ? [x / len, y / len, z / len] : [m.normals[src] ?? 0, m.normals[src + 1] ?? 0, m.normals[src + 2] ?? 0], c * 3);
+    }
+  return splitByNormal(m, normal);
+}
+function splitByNormal(m, cornerNormals) {
+  const seen = new Map;
+  const p = [];
+  const n = [];
+  const uv = [];
+  const col = [];
+  const idx = new Uint32Array(m.indices.length);
+  for (let c = 0;c < m.indices.length; c++) {
+    const v = m.indices[c] ?? 0;
+    const nx = cornerNormals[c * 3] ?? 0;
+    const ny = cornerNormals[c * 3 + 1] ?? 0;
+    const nz = cornerNormals[c * 3 + 2] ?? 0;
+    const key = `${v}:${Math.round(nx * 1e4)},${Math.round(ny * 1e4)},${Math.round(nz * 1e4)}`;
+    let out = seen.get(key);
+    if (out === undefined) {
+      out = p.length / 3;
+      seen.set(key, out);
+      p.push(m.positions[v * 3] ?? 0, m.positions[v * 3 + 1] ?? 0, m.positions[v * 3 + 2] ?? 0);
+      n.push(nx, ny, nz);
+      uv.push(m.uvs[v * 2] ?? 0, m.uvs[v * 2 + 1] ?? 0);
+      col.push(m.colors[v * 3] ?? 0, m.colors[v * 3 + 1] ?? 0, m.colors[v * 3 + 2] ?? 0);
+    }
+    idx[c] = out;
+  }
+  return {
+    positions: new Float32Array(p),
+    normals: new Float32Array(n),
+    uvs: new Float32Array(uv),
+    colors: new Float32Array(col),
+    indices: idx
+  };
+}
+export { RayGrid2, bakeAo2, bakeAoAsset2, grime2, livery2, optimize2, weightedNormals2 };
+
+//# debugId=BEEEAE9C1B221C7564756E2164756E21
+//# sourceMappingURL=chunk-drna2rny.js.map