@aethervtt/shard-structure 0.0.0-stage → 0.2.0

package/dist/contact.js

@@ -0,0 +1,343 @@
+import { pointAt } from "./curve.js";
+import { chunkKey } from "./geometry.js";
+const CONTACT_STRIDE = 20;
+const CONTACT_STEP = 1.8;
+const CONTACT_LIFT = 2e-3;
+const SIDE_PROBE = 0.05;
+const CORNER_INSET = 0.2;
+class ContactQuads {
+  data = new Float64Array(CONTACT_STRIDE * 8);
+  count = 0;
+  reset() {
+    this.count = 0;
+  }
+  /** Room for one more quad; returns its offset. */
+  next() {
+    const o = this.count * CONTACT_STRIDE;
+    if (o + CONTACT_STRIDE > this.data.length) {
+      const grown = new Float64Array(this.data.length * 2);
+      grown.set(this.data);
+      this.data = grown;
+    }
+    this.count++;
+    return o;
+  }
+  /** Whether `other` holds the same quads (an edit that changed nothing here). */
+  equals(other) {
+    if (other.count !== this.count) return false;
+    for (let i = 0; i < this.count * CONTACT_STRIDE; i++)
+      if (this.data[i] !== other.data[i]) return false;
+    return true;
+  }
+  copy(other) {
+    if (this.data.length < other.data.length) this.data = new Float64Array(other.data.length);
+    this.data.set(other.data.subarray(0, other.count * CONTACT_STRIDE));
+    this.count = other.count;
+  }
+}
+const at = new Float64Array(4);
+const jointOut = new Float64Array(3);
+function sideFloor(w, s, sgn, env) {
+  pointAt(w.line, s, at);
+  const off = (w.thickness / 2 + SIDE_PROBE) * sgn;
+  return env.floorTop(at[0] + at[2] * off, at[1] + at[3] * off, w.elevation);
+}
+function quad(out, nx, ny, nz, c) {
+  const o = out.next();
+  const d = out.data;
+  d[o] = nx;
+  d[o + 1] = ny;
+  d[o + 2] = nz;
+  d[o + 3] = 0;
+  for (let i = 0; i < 16; i++) d[o + 4 + i] = c[i];
+}
+const corners = new Array(16).fill(0);
+function floorStrip(w, s0, s1, sgn, y, reach, out) {
+  const line = w.line;
+  const half = w.thickness / 2;
+  let a = s0;
+  let k = 1;
+  while (a < s1 - 1e-9) {
+    while (k < line.count - 1 && line.s[k] <= a + 1e-9) k++;
+    const b = k < line.count - 1 ? Math.min(s1, line.s[k]) : s1;
+    pointAt(line, a, at);
+    const ax = at[0];
+    const az = at[1];
+    const anx = at[2] * sgn;
+    const anz = at[3] * sgn;
+    pointAt(line, b, at);
+    const bx = at[0];
+    const bz = at[1];
+    const bnx = at[2] * sgn;
+    const bnz = at[3] * sgn;
+    const c = corners;
+    c[0] = ax + anx * half;
+    c[1] = y;
+    c[2] = az + anz * half;
+    c[3] = 0;
+    c[4] = bx + bnx * half;
+    c[5] = y;
+    c[6] = bz + bnz * half;
+    c[7] = 0;
+    c[8] = bx + bnx * (half + reach);
+    c[9] = y;
+    c[10] = bz + bnz * (half + reach);
+    c[11] = 1;
+    c[12] = ax + anx * (half + reach);
+    c[13] = y;
+    c[14] = az + anz * (half + reach);
+    c[15] = 1;
+    quad(out, 0, 1, 0, c);
+    a = b;
+  }
+}
+function cornerStrip(w, from, to, covered, sgn, y0, y1, reach, out) {
+  const line = w.line;
+  const off = w.thickness / 2 + CONTACT_LIFT;
+  const lo = Math.min(from, to);
+  const hi = Math.max(from, to);
+  let a = lo;
+  let k = 1;
+  while (a < hi - 1e-9) {
+    while (k < line.count - 1 && line.s[k] <= a + 1e-9) k++;
+    const b = k < line.count - 1 ? Math.min(hi, line.s[k]) : hi;
+    pointAt(line, a, at);
+    const ax = at[0] + at[2] * off * sgn;
+    const az = at[1] + at[3] * off * sgn;
+    const nx = at[2] * sgn;
+    const nz = at[3] * sgn;
+    pointAt(line, b, at);
+    const bx = at[0] + at[2] * off * sgn;
+    const bz = at[1] + at[3] * off * sgn;
+    const fa = (Math.abs(a - from) - covered) / reach;
+    const fb = (Math.abs(b - from) - covered) / reach;
+    const c = corners;
+    c[0] = ax;
+    c[1] = y0;
+    c[2] = az;
+    c[3] = fa;
+    c[4] = bx;
+    c[5] = y0;
+    c[6] = bz;
+    c[7] = fb;
+    c[8] = bx;
+    c[9] = y1;
+    c[10] = bz;
+    c[11] = fb;
+    c[12] = ax;
+    c[13] = y1;
+    c[14] = az;
+    c[15] = fa;
+    quad(out, (nx + at[2] * sgn) / 2, 0, (nz + at[3] * sgn) / 2, c);
+    a = b;
+  }
+}
+function contactQuads(w, openings, reach, env, out) {
+  out.reset();
+  const length = w.line.length;
+  if (length < 1e-6 || w.height <= 0) return;
+  if (reach.floorReach > 1e-6) {
+    let cursor = 0;
+    for (let i = 0; i <= openings.length; i++) {
+      const o = openings[i];
+      if (o && o.kind !== "door") continue;
+      const end = o ? Math.max(cursor, Math.min(length, o.offset)) : length;
+      const span2 = end - cursor;
+      if (span2 > 1e-6) {
+        const n = Math.max(1, Math.ceil(span2 / CONTACT_STEP));
+        for (let p = 0; p < n; p++) {
+          const s0 = cursor + span2 * p / n;
+          const s1 = cursor + span2 * (p + 1) / n;
+          for (let sgn = 1; sgn >= -1; sgn -= 2) {
+            const top = sideFloor(w, (s0 + s1) / 2, sgn, env);
+            if (Number.isNaN(top)) continue;
+            floorStrip(w, s0, s1, sgn, top + CONTACT_LIFT, reach.floorReach, out);
+          }
+        }
+      }
+      if (o) cursor = Math.max(cursor, Math.min(length, o.offset + o.width));
+    }
+  }
+  if (reach.cornerReach > 1e-6) {
+    for (let end = 0; end < 2; end++) {
+      if (!env.joint(end, jointOut)) continue;
+      const y0 = jointOut[0] + CORNER_INSET;
+      const y1 = jointOut[1] - CORNER_INSET;
+      const covered = Math.max(0, jointOut[2]);
+      if (y1 <= y0) continue;
+      const from = end === 0 ? 0 : length;
+      const run = Math.min(length, covered + reach.cornerReach);
+      const to = end === 0 ? run : length - run;
+      const probe = Math.min(length / 2, covered + reach.cornerReach / 2);
+      for (let sgn = 1; sgn >= -1; sgn -= 2) {
+        const top = sideFloor(w, end === 0 ? probe : length - probe, sgn, env);
+        if (Number.isNaN(top)) continue;
+        cornerStrip(w, from, to, covered, sgn, y0, y1, reach.cornerReach, out);
+      }
+    }
+  }
+}
+const polyA = new Float64Array(36);
+const polyB = new Float64Array(36);
+function clipEdge(src, n, dst, axis, edge, sign) {
+  if (n === 0) return 0;
+  let count = 0;
+  let p = (n - 1) * 3;
+  let pd = sign * (src[p + (axis === 0 ? 0 : 1)] - edge);
+  for (let i = 0; i < n; i++) {
+    const c = i * 3;
+    const d = sign * (src[c + (axis === 0 ? 0 : 1)] - edge);
+    if (d >= 0 !== pd >= 0) {
+      const t = pd / (pd - d);
+      dst[count * 3] = src[p] + (src[c] - src[p]) * t;
+      dst[count * 3 + 1] = src[p + 1] + (src[c + 1] - src[p + 1]) * t;
+      dst[count * 3 + 2] = src[p + 2] + (src[c + 2] - src[p + 2]) * t;
+      count++;
+    }
+    if (d >= 0) {
+      dst[count * 3] = src[c];
+      dst[count * 3 + 1] = src[c + 1];
+      dst[count * 3 + 2] = src[c + 2];
+      count++;
+    }
+    p = c;
+    pd = d;
+  }
+  return count;
+}
+function clipFloorQuad(d, o, minX, minZ, maxX, maxZ) {
+  for (let k = 0; k < 4; k++) {
+    polyA[k * 3] = d[o + 4 + k * 4];
+    polyA[k * 3 + 1] = d[o + 6 + k * 4];
+    polyA[k * 3 + 2] = d[o + 7 + k * 4];
+  }
+  let n = clipEdge(polyA, 4, polyB, 0, minX, 1);
+  n = clipEdge(polyB, n, polyA, 0, maxX, -1);
+  n = clipEdge(polyA, n, polyB, 1, minZ, 1);
+  n = clipEdge(polyB, n, polyA, 1, maxZ, -1);
+  if (n < 3) return 0;
+  let area = 0;
+  for (let i = 0; i < n; i++) {
+    const j = (i + 1) % n;
+    area += polyA[i * 3] * polyA[j * 3 + 1] - polyA[j * 3] * polyA[i * 3 + 1];
+  }
+  return Math.abs(area) > 1e-9 ? n : 0;
+}
+const span = new Float64Array(2);
+function clipCornerQuad(d, o, minX, minZ, maxX, maxZ) {
+  const ax = d[o + 4];
+  const az = d[o + 6];
+  const dx = d[o + 8] - ax;
+  const dz = d[o + 10] - az;
+  let t0 = 0;
+  let t1 = 1;
+  for (let k = 0; k < 4; k++) {
+    const p = k === 0 ? -dx : k === 1 ? dx : k === 2 ? -dz : dz;
+    const q = k === 0 ? ax - minX : k === 1 ? maxX - ax : k === 2 ? az - minZ : maxZ - az;
+    if (Math.abs(p) < 1e-12) {
+      if (q < 0 || q === 0 && (k === 1 || k === 3)) return false;
+      continue;
+    }
+    const t = q / p;
+    if (p < 0) {
+      if (t > t1) return false;
+      if (t > t0) t0 = t;
+    } else {
+      if (t < t0) return false;
+      if (t < t1) t1 = t;
+    }
+  }
+  if ((t1 - t0) * Math.sqrt(dx * dx + dz * dz) <= 1e-9) return false;
+  span[0] = t0;
+  span[1] = t1;
+  return true;
+}
+function contactChunks(quads, size, out) {
+  const d = quads.data;
+  for (let q = 0; q < quads.count; q++) {
+    const o = q * CONTACT_STRIDE;
+    let x0 = Infinity;
+    let z0 = Infinity;
+    let x1 = -Infinity;
+    let z1 = -Infinity;
+    for (let k = 0; k < 4; k++) {
+      const x = d[o + 4 + k * 4];
+      const z = d[o + 6 + k * 4];
+      if (x < x0) x0 = x;
+      if (x > x1) x1 = x;
+      if (z < z0) z0 = z;
+      if (z > z1) z1 = z;
+    }
+    const vertical = d[o + 1] === 0;
+    for (let cx = Math.floor(x0 / size); cx <= Math.floor(x1 / size); cx++)
+      for (let cz = Math.floor(z0 / size); cz <= Math.floor(z1 / size); cz++) {
+        const key = chunkKey(cx, cz);
+        if (out.has(key)) continue;
+        const minX = cx * size;
+        const minZ = cz * size;
+        const hit = vertical ? clipCornerQuad(d, o, minX, minZ, minX + size, minZ + size) : clipFloorQuad(d, o, minX, minZ, minX + size, minZ + size) > 0;
+        if (hit) out.add(key);
+      }
+  }
+}
+function emitContact(quads, minX, minZ, maxX, maxZ, m) {
+  const d = quads.data;
+  let any = false;
+  for (let q = 0; q < quads.count; q++) {
+    const o = q * CONTACT_STRIDE;
+    const nx = d[o];
+    const ny = d[o + 1];
+    const nz = d[o + 2];
+    if (ny !== 0) {
+      const n = clipFloorQuad(d, o, minX, minZ, maxX, maxZ);
+      if (n === 0) continue;
+      any = true;
+      const y = d[o + 5];
+      const first2 = m.vertexCount;
+      for (let k = 0; k < n; k++)
+        m.vertex(polyA[k * 3], y, polyA[k * 3 + 1], 0, 1, 0, polyA[k * 3 + 2], 0, 1, 0, 0, 1);
+      m.fan(first2, n, 0, 1, 0);
+      continue;
+    }
+    if (!clipCornerQuad(d, o, minX, minZ, maxX, maxZ)) continue;
+    any = true;
+    const first = m.vertexCount;
+    for (let e = 0; e < 4; e++) {
+      const t = e === 0 || e === 3 ? span[0] : span[1];
+      const y = e < 2 ? d[o + 5] : d[o + 13];
+      const x = d[o + 4] + (d[o + 8] - d[o + 4]) * t;
+      const z = d[o + 6] + (d[o + 10] - d[o + 6]) * t;
+      const fade = d[o + 7] + (d[o + 11] - d[o + 7]) * t;
+      m.vertex(x, y, z, nx, 0, nz, fade, 0, -nz, 0, nx, 1);
+    }
+    m.fan(first, 4, nx, 0, nz);
+  }
+  return any;
+}
+const CONTACT_CORE = 0.1;
+const CONTACT_CORE_BOOST = 0.55;
+function smoothstep(a, b, x) {
+  const t = Math.min(1, Math.max(0, (x - a) / (b - a)));
+  return t * t * (3 - 2 * t);
+}
+function contactAlpha(fade, n, look) {
+  const wobble = Math.min(1, Math.max(0, look.wobble));
+  const f = Math.min(1, Math.max(0, fade * (1 + wobble * (2 * n - 1))));
+  const falloff = 1 - smoothstep(0, 1, f);
+  const core = 1 - smoothstep(0, CONTACT_CORE, f);
+  const edge = 1 - smoothstep(0.8, 1, fade);
+  const alpha = look.opacity * (falloff * (0.8 + 0.2 * falloff) + core * CONTACT_CORE_BOOST) * (0.94 + 0.12 * n);
+  return Math.min(look.maxAlpha, alpha) * edge;
+}
+export {
+  CONTACT_CORE,
+  CONTACT_CORE_BOOST,
+  CONTACT_LIFT,
+  CONTACT_STEP,
+  CONTACT_STRIDE,
+  ContactQuads,
+  contactAlpha,
+  contactChunks,
+  contactQuads,
+  emitContact
+};

package/dist/curve.d.ts

@@ -0,0 +1,50 @@
+export type WallCurve = 'straight' | 'arc' | 'bezier';
+/** What a centreline is made from, in world (x, z). */
+export interface CurveInput {
+    a: ArrayLike<number>;
+    b: ArrayLike<number>;
+    shape?: WallCurve;
+    /** Arc: how far the midpoint bows off the line a → b; positive bows to the left of a → b. */
+    bow?: number;
+    /** Bézier: the cubic's control points. */
+    c0?: ArrayLike<number>;
+    c1?: ArrayLike<number>;
+}
+/**
+ * A sampled centreline: points, the arc length at each, and the unit normal to the left of the
+ * direction of travel. `radius` is the smallest radius of curvature (Infinity when straight).
+ */
+export interface Centerline {
+    count: number;
+    x: Float64Array;
+    z: Float64Array;
+    s: Float64Array;
+    nx: Float64Array;
+    nz: Float64Array;
+    length: number;
+    radius: number;
+}
+/** Default chord tolerance, metres (`StructureSettings.curveTolerance`). */
+export declare const CURVE_TOLERANCE = 0.01;
+/** A circular arc's centre, radius and sweep (signed radians, from a), or undefined if straight. */
+export declare function arcOf(input: CurveInput): {
+    cx: number;
+    cz: number;
+    r: number;
+    from: number;
+    sweep: number;
+} | undefined;
+/**
+ * Samples a wall's centreline so no chord strays more than `tolerance` from the curve. Straight
+ * walls give their two ends; arcs even angles; Béziers adaptive subdivision. Reuses `out`.
+ */
+export declare function sampleWall(input: CurveInput, tolerance?: number, out?: Centerline): Centerline;
+/** Index of the sample interval containing arc length `s` (clamped). */
+export declare function intervalAt(c: Centerline, s: number): number;
+/** The centreline point and left normal at arc length `s`, interpolated between samples. */
+export declare function pointAt(c: Centerline, s: number, out: Float64Array): Float64Array;
+/** A quadratic Bézier (one control point q) as the same curve in cubic form, exactly. */
+export declare function quadraticToCubic(a: ArrayLike<number>, q: ArrayLike<number>, b: ArrayLike<number>): {
+    c0: [number, number];
+    c1: [number, number];
+};

package/dist/curve.js

@@ -0,0 +1,224 @@
+const CURVE_TOLERANCE = 0.01;
+function alloc(n) {
+  return {
+    count: 0,
+    x: new Float64Array(n),
+    z: new Float64Array(n),
+    s: new Float64Array(n),
+    nx: new Float64Array(n),
+    nz: new Float64Array(n),
+    length: 0,
+    radius: Infinity
+  };
+}
+function push(c, x, z, tx, tz) {
+  if (c.count === c.x.length) {
+    const grow = (a) => {
+      const next = new Float64Array(a.length * 2);
+      next.set(a);
+      return next;
+    };
+    c.x = grow(c.x);
+    c.z = grow(c.z);
+    c.s = grow(c.s);
+    c.nx = grow(c.nx);
+    c.nz = grow(c.nz);
+  }
+  const i = c.count++;
+  c.x[i] = x;
+  c.z[i] = z;
+  c.s[i] = i === 0 ? 0 : c.s[i - 1] + Math.hypot(x - c.x[i - 1], z - c.z[i - 1]);
+  const l = Math.sqrt(tx * tx + tz * tz) || 1;
+  c.nx[i] = -tz / l;
+  c.nz[i] = tx / l;
+}
+function arcOf(input) {
+  const bow = input.bow ?? 0;
+  const ax = input.a[0];
+  const az = input.a[1];
+  const bx = input.b[0];
+  const bz = input.b[1];
+  const dx = bx - ax;
+  const dz = bz - az;
+  const chord = Math.sqrt(dx * dx + dz * dz);
+  if (chord < 1e-9 || Math.abs(bow) < 1e-9) return void 0;
+  const nx = -dz / chord;
+  const nz = dx / chord;
+  const r = chord * chord / 4 / (2 * Math.abs(bow)) + Math.abs(bow) / 2;
+  const mx = (ax + bx) / 2 + nx * bow;
+  const mz = (az + bz) / 2 + nz * bow;
+  const sign = Math.sign(bow);
+  const cx = mx - nx * sign * r;
+  const cz = mz - nz * sign * r;
+  const from = Math.atan2(az - cz, ax - cx);
+  const to = Math.atan2(bz - cz, bx - cx);
+  const mid = Math.atan2(mz - cz, mx - cx);
+  let ccw = to - from;
+  while (ccw <= 0) ccw += Math.PI * 2;
+  let m = mid - from;
+  while (m < 0) m += Math.PI * 2;
+  const sweep = m <= ccw ? ccw : ccw - Math.PI * 2;
+  return { cx, cz, r, from, sweep };
+}
+function bezier(p, t, out) {
+  const u = 1 - t;
+  const b0 = u * u * u;
+  const b1 = 3 * u * u * t;
+  const b2 = 3 * u * t * t;
+  const b3 = t * t * t;
+  out[0] = b0 * p[0] + b1 * p[2] + b2 * p[4] + b3 * p[6];
+  out[1] = b0 * p[1] + b1 * p[3] + b2 * p[5] + b3 * p[7];
+  const d0 = 3 * u * u;
+  const d1 = 6 * u * t;
+  const d2 = 3 * t * t;
+  out[2] = d0 * (p[2] - p[0]) + d1 * (p[4] - p[2]) + d2 * (p[6] - p[4]);
+  out[3] = d0 * (p[3] - p[1]) + d1 * (p[5] - p[3]) + d2 * (p[7] - p[5]);
+}
+function flatness(p, t0, t1, scratch) {
+  const q = scratch;
+  const sub = (t, i) => {
+    bezier(p, t, q);
+    q[8 + i * 2] = q[0];
+    q[9 + i * 2] = q[1];
+  };
+  sub(t0, 0);
+  sub(t1, 3);
+  bezier(p, t0, q);
+  const d0x = q[2] * ((t1 - t0) / 3);
+  const d0z = q[3] * ((t1 - t0) / 3);
+  bezier(p, t1, q);
+  const d1x = q[2] * ((t1 - t0) / 3);
+  const d1z = q[3] * ((t1 - t0) / 3);
+  const ax = q[8];
+  const az = q[9];
+  const bx = q[14];
+  const bz = q[15];
+  const c0x = ax + d0x;
+  const c0z = az + d0z;
+  const c1x = bx - d1x;
+  const c1z = bz - d1z;
+  const dx = bx - ax;
+  const dz = bz - az;
+  const len = Math.sqrt(dx * dx + dz * dz);
+  const dist = (x, z) => len < 1e-12 ? Math.hypot(x - ax, z - az) : Math.abs((x - ax) * dz - (z - az) * dx) / len;
+  return Math.max(dist(c0x, c0z), dist(c1x, c1z));
+}
+function bezierRadius(p, t) {
+  const u = 1 - t;
+  const dx = 3 * u * u * (p[2] - p[0]) + 6 * u * t * (p[4] - p[2]) + 3 * t * t * (p[6] - p[4]);
+  const dz = 3 * u * u * (p[3] - p[1]) + 6 * u * t * (p[5] - p[3]) + 3 * t * t * (p[7] - p[5]);
+  const ddx = 6 * u * (p[4] - 2 * p[2] + p[0]) + 6 * t * (p[6] - 2 * p[4] + p[2]);
+  const ddz = 6 * u * (p[5] - 2 * p[3] + p[1]) + 6 * t * (p[7] - 2 * p[5] + p[3]);
+  const cross = Math.abs(dx * ddz - dz * ddx);
+  const speed = Math.sqrt(dx * dx + dz * dz);
+  return cross < 1e-12 ? Infinity : speed * speed * speed / cross;
+}
+function sampleWall(input, tolerance = CURVE_TOLERANCE, out) {
+  const c = out ?? alloc(8);
+  c.count = 0;
+  c.radius = Infinity;
+  const ax = input.a[0];
+  const az = input.a[1];
+  const bx = input.b[0];
+  const bz = input.b[1];
+  const shape = input.shape ?? "straight";
+  const arc = shape === "arc" ? arcOf(input) : void 0;
+  if (arc) {
+    const { cx, cz, r, from, sweep } = arc;
+    const step = 2 * Math.acos(Math.max(-1, 1 - tolerance / r));
+    const n = Math.max(1, Math.ceil(Math.abs(sweep) / Math.max(step, 1e-6)));
+    for (let k = 0; k <= n; k++) {
+      const a = from + sweep * k / n;
+      const cos = Math.cos(a);
+      const sin = Math.sin(a);
+      const x = k === 0 ? ax : k === n ? bx : cx + r * cos;
+      const z = k === 0 ? az : k === n ? bz : cz + r * sin;
+      push(c, x, z, -sin * Math.sign(sweep), cos * Math.sign(sweep));
+    }
+    for (let k = 0; k <= n; k++) c.s[k] = r * Math.abs(sweep) * k / n;
+    c.radius = r;
+  } else if (shape === "bezier" && input.c0 && input.c1) {
+    const p = new Float64Array([
+      ax,
+      az,
+      input.c0[0],
+      input.c0[1],
+      input.c1[0],
+      input.c1[1],
+      bx,
+      bz
+    ]);
+    const q = new Float64Array(16);
+    const ts = [0];
+    const stack = [[0, 1]];
+    const done = [];
+    while (stack.length > 0) {
+      const [t0, t1] = stack.pop();
+      if (t1 - t0 > 1 / 4096 && (t1 - t0 > 0.25 || flatness(p, t0, t1, q) > tolerance)) {
+        const m = (t0 + t1) / 2;
+        stack.push([m, t1], [t0, m]);
+      } else done.push([t0, t1]);
+    }
+    for (const [, t1] of done) ts.push(t1);
+    for (const t of ts) {
+      bezier(p, t, q);
+      const x = t === 0 ? ax : t === 1 ? bx : q[0];
+      const z = t === 0 ? az : t === 1 ? bz : q[1];
+      let tx = q[2];
+      let tz = q[3];
+      if (tx * tx + tz * tz < 1e-18) {
+        bezier(p, t === 0 ? 1e-4 : 1 - 1e-4, q);
+        tx = q[2];
+        tz = q[3];
+      }
+      push(c, x, z, tx, tz);
+      c.radius = Math.min(c.radius, bezierRadius(p, t));
+    }
+    for (let i = 0; i + 1 < ts.length; i++)
+      c.radius = Math.min(c.radius, bezierRadius(p, (ts[i] + ts[i + 1]) / 2));
+  } else {
+    push(c, ax, az, bx - ax, bz - az);
+    push(c, bx, bz, bx - ax, bz - az);
+  }
+  c.length = c.s[c.count - 1];
+  return c;
+}
+function intervalAt(c, s) {
+  let lo = 0;
+  let hi = c.count - 2;
+  if (hi <= 0) return 0;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (c.s[mid] <= s) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo;
+}
+function pointAt(c, s, out) {
+  const i = intervalAt(c, s);
+  const s0 = c.s[i];
+  const s1 = c.s[i + 1] ?? s0;
+  const t = s1 > s0 ? Math.min(1, Math.max(0, (s - s0) / (s1 - s0))) : 0;
+  out[0] = c.x[i] + (c.x[i + 1] - c.x[i]) * t;
+  out[1] = c.z[i] + (c.z[i + 1] - c.z[i]) * t;
+  const nx = c.nx[i] + (c.nx[i + 1] - c.nx[i]) * t;
+  const nz = c.nz[i] + (c.nz[i + 1] - c.nz[i]) * t;
+  const l = Math.sqrt(nx * nx + nz * nz) || 1;
+  out[2] = nx / l;
+  out[3] = nz / l;
+  return out;
+}
+function quadraticToCubic(a, q, b) {
+  return {
+    c0: [a[0] + 2 / 3 * (q[0] - a[0]), a[1] + 2 / 3 * (q[1] - a[1])],
+    c1: [b[0] + 2 / 3 * (q[0] - b[0]), b[1] + 2 / 3 * (q[1] - b[1])]
+  };
+}
+export {
+  CURVE_TOLERANCE,
+  arcOf,
+  intervalAt,
+  pointAt,
+  quadraticToCubic,
+  sampleWall
+};

package/dist/fixtures.d.ts

@@ -0,0 +1,77 @@
+import { type AssetRef, type World } from '@aethervtt/shard-core';
+import { type Mirror } from '@aethervtt/shard-mirror';
+import { type Image } from '@aethervtt/shard-texture';
+import { type FloorDoc, LIMITS, type MaterialDoc, maxScene, type OpeningDoc, type PropDoc, type SceneDocs, type SceneGrid, shadowStress, type TokenDoc, type WallDoc } from '../fixtures/structure/index.mjs';
+export { LIMITS, maxScene, type SceneDocs, shadowStress };
+/**
+ * The fixed visual scale from Aether pixels to world units: 70 px (a cell) is 1.5 m. It never
+ * depends on the grid's game distance ("5 ft per square").
+ */
+export declare const PX_TO_WORLD: number;
+/** Resolves a host's texture asset ref to a decoded image (Aether: `asset:<sha256>`). */
+export type ImageSource = (ref: string) => Image | undefined;
+/**
+ * Aether's scene material as a `StandardMaterial` value (0066). `texture` makes (or finds) the
+ * texture for a ref and a use; `packed` is the packed roughness/metalness texture, if the material
+ * has either map. Repeat is pixels per tile, so a slot's scale is 1 / (repeat × pxToWorld) tiles per
+ * metre on structure's metre UVs.
+ */
+export declare function sceneMaterialValue(doc: MaterialDoc, pxToWorld: number, texture: (ref: string, usage: 'color' | 'normal' | 'data') => AssetRef<'Texture'> | null, packed?: AssetRef<'Texture'> | null): Record<string, unknown>;
+/** What one `sync` of every mirror did. */
+export interface HostSyncCounts {
+    spawned: number;
+    applied: number;
+    removed: number;
+    resized: number;
+}
+/**
+ * A reference host adapter for Aether-shaped scenes (the one Aether ships lives in Aether): each
+ * document list is mirrored onto entities (0055), in world units through one fixed visual scale.
+ * Tokens are a logical root with a flat disc as a visual child; token footprints and props are
+ * sized in cells, so the grid's pixel size resizes them, and nothing else about the grid does.
+ */
+export declare class HostScene {
+    readonly world: World;
+    readonly k: number;
+    readonly materials: Mirror<MaterialDoc>;
+    readonly walls: Mirror<WallDoc>;
+    readonly openings: Mirror<OpeningDoc>;
+    readonly floors: Mirror<FloorDoc>;
+    readonly props: Mirror<PropDoc>;
+    readonly tokens: Mirror<TokenDoc>;
+    /** Token root → its disc. */
+    readonly discs: Map<number, number>;
+    grid: SceneGrid | undefined;
+    private readonly materialRefs;
+    private readonly propMeshes;
+    private readonly tokenDocs;
+    private readonly propDocs;
+    private discMesh;
+    private tokenMaterial;
+    /** Textures made from the host's images, by ref and use. */
+    private readonly textureRefs;
+    private readonly images;
+    constructor(world: World, pxToWorld?: number, images?: ImageSource);
+    /** A scene material's value: its textures made from the host's images on first use. */
+    private materialValue;
+    /** World size of one grid cell: the grid's pixel size through the visual scale. */
+    get cell(): number;
+    /**
+     * Applies a full host state. Only documents whose revision changed are applied. A grid whose
+     * pixel size changed resizes cell-sized things (token footprints, props); its game distance,
+     * unit and diagonal rule place nothing.
+     */
+    sync(docs: SceneDocs): HostSyncCounts;
+    private sizeToken;
+    private placeProp;
+    private disc;
+    private tokenMat;
+    /**
+     * One mesh per prop asset: spheres of about 1,950 triangles, so 256 props come to Aether's
+     * 500k prop triangles.
+     */
+    private propMesh;
+}
+/** Mirrors Aether-shaped documents onto `world` (see `HostScene`). */
+export declare function hostScene(world: World, pxToWorld?: number, images?: ImageSource): HostScene;
+export { type BrickOptions, brickMaterial, brickTextures } from './bricks.js';