@driftengine/assets 4.3.0 → 4.4.1

package/src/bake/collapseHeap.ts

@@ -0,0 +1,81 @@
+/**
+ * The simplifier's queue: candidate edge collapses, cheapest first.
+ *
+ * A binary min-heap in parallel typed arrays grown by doubling, because a scene's meshes queue
+ * millions of candidates and an object each would be most of the bake's memory. A candidate carries
+ * the version its vertex had when it was costed; the caller discards one whose vertex has moved on
+ * since, rather than the heap finding and removing it.
+ */
+export class CollapseHeap {
+  private costs = new Float64Array(1024);
+  private us = new Int32Array(1024);
+  private vs = new Int32Array(1024);
+  private versions = new Uint32Array(1024);
+  size = 0;
+
+  push(cost: number, u: number, v: number, version: number): void {
+    if (this.size === this.costs.length) this.grow();
+    let i = this.size++;
+    while (i > 0) {
+      const parent = (i - 1) >> 1;
+      if (this.costs[parent]! <= cost) break;
+      this.move(parent, i);
+      i = parent;
+    }
+    this.costs[i] = cost;
+    this.us[i] = u;
+    this.vs[i] = v;
+    this.versions[i] = version;
+  }
+
+  topCost(): number {
+    return this.costs[0]!;
+  }
+
+  pop(): { u: number; v: number; version: number } {
+    const top = { u: this.us[0]!, v: this.vs[0]!, version: this.versions[0]! };
+    const last = --this.size;
+    const cost = this.costs[last]!;
+    const u = this.us[last]!;
+    const v = this.vs[last]!;
+    const version = this.versions[last]!;
+    let i = 0;
+    for (;;) {
+      const left = i * 2 + 1;
+      if (left >= last) break;
+      const right = left + 1;
+      const child = right < last && this.costs[right]! < this.costs[left]! ? right : left;
+      if (this.costs[child]! >= cost) break;
+      this.move(child, i);
+      i = child;
+    }
+    this.costs[i] = cost;
+    this.us[i] = u;
+    this.vs[i] = v;
+    this.versions[i] = version;
+    return top;
+  }
+
+  private move(from: number, to: number): void {
+    this.costs[to] = this.costs[from]!;
+    this.us[to] = this.us[from]!;
+    this.vs[to] = this.vs[from]!;
+    this.versions[to] = this.versions[from]!;
+  }
+
+  private grow(): void {
+    const size = this.costs.length * 2;
+    const costs = new Float64Array(size);
+    costs.set(this.costs);
+    const us = new Int32Array(size);
+    us.set(this.us);
+    const vs = new Int32Array(size);
+    vs.set(this.vs);
+    const versions = new Uint32Array(size);
+    versions.set(this.versions);
+    this.costs = costs;
+    this.us = us;
+    this.vs = vs;
+    this.versions = versions;
+  }
+}

package/src/bake/collapseMeasures.ts

@@ -0,0 +1,215 @@
+/**
+ * What an edge collapse is judged by: how far it moves the surface, and how far it slides a texture.
+ *
+ * The surface is measured by quadrics (Garland and Heckbert): each vertex carries the planes of the
+ * faces around it as ten sums, weighted by area, and a point's cost is its squared distance from
+ * them. The texture is measured against the uv each vertex was painted with, read back off the
+ * triangles a collapse leaves. Positions are a flat `Float64Array` of xyz and uvs a flat
+ * `Float32Array` of uv, both indexed by vertex.
+ */
+
+/** How much a border's own planes weigh against the faces', per unit of edge length squared. */
+const BORDER_WEIGHT = 4;
+/**
+ * How far past a triangle's edge a sample may lie, in barycentric units, and still be measured
+ * against it: a vertex on a border that curves, which the straightened border no longer quite
+ * reaches. Further out, the surface the sample was painted on has gone from under it.
+ */
+const NEAR_EDGE = 0.05;
+
+/** A key for the undirected edge `a`–`b` among `v` vertices. */
+export function edgeKey(a: number, b: number, v: number): number {
+  return a < b ? a * v + b : b * v + a;
+}
+
+/** The unit normal of a triangle into `out`, returning twice its area, or 0 for none. */
+export function triangleNormal(
+  p: Float64Array,
+  a: number,
+  b: number,
+  c: number,
+  out: number[],
+): number {
+  const ux = p[b * 3]! - p[a * 3]!;
+  const uy = p[b * 3 + 1]! - p[a * 3 + 1]!;
+  const uz = p[b * 3 + 2]! - p[a * 3 + 2]!;
+  const vx = p[c * 3]! - p[a * 3]!;
+  const vy = p[c * 3 + 1]! - p[a * 3 + 1]!;
+  const vz = p[c * 3 + 2]! - p[a * 3 + 2]!;
+  const nx = uy * vz - uz * vy;
+  const ny = uz * vx - ux * vz;
+  const nz = ux * vy - uy * vx;
+  const length = Math.hypot(nx, ny, nz);
+  if (length <= 1e-30) return 0;
+  out[0] = nx / length;
+  out[1] = ny / length;
+  out[2] = nz / length;
+  return length;
+}
+
+/** Adds the plane `ax + by + cz + d = 0`, weighted by `w`, to vertex `vert`'s quadric. */
+export function addPlane(
+  q: Float64Array,
+  vert: number,
+  a: number,
+  b: number,
+  c: number,
+  d: number,
+  w: number,
+): void {
+  const at = vert * 10;
+  q[at] = q[at]! + w * a * a;
+  q[at + 1] = q[at + 1]! + w * a * b;
+  q[at + 2] = q[at + 2]! + w * a * c;
+  q[at + 3] = q[at + 3]! + w * a * d;
+  q[at + 4] = q[at + 4]! + w * b * b;
+  q[at + 5] = q[at + 5]! + w * b * c;
+  q[at + 6] = q[at + 6]! + w * b * d;
+  q[at + 7] = q[at + 7]! + w * c * c;
+  q[at + 8] = q[at + 8]! + w * c * d;
+  q[at + 9] = q[at + 9]! + w * d * d;
+}
+
+/** Vertex `vert`'s quadric at the point `x, y, z`: its planes' weighted squared distance from it. */
+export function quadricAt(q: Float64Array, vert: number, x: number, y: number, z: number): number {
+  const at = vert * 10;
+  return (
+    q[at]! * x * x +
+    2 * q[at + 1]! * x * y +
+    2 * q[at + 2]! * x * z +
+    2 * q[at + 3]! * x +
+    q[at + 4]! * y * y +
+    2 * q[at + 5]! * y * z +
+    2 * q[at + 6]! * y +
+    q[at + 7]! * z * z +
+    2 * q[at + 8]! * z +
+    q[at + 9]!
+  );
+}
+
+/** Every face's plane on its three corners, weighted by its area, and each corner's area summed. */
+export function addFacePlanes(
+  p: Float64Array,
+  faces: Uint32Array,
+  quadric: Float64Array,
+  area: Float64Array,
+): void {
+  const f = faces.length / 3;
+  const n = [0, 0, 0];
+  for (let face = 0; face < f; face++) {
+    const a = faces[face * 3] as number;
+    const b = faces[face * 3 + 1] as number;
+    const c = faces[face * 3 + 2] as number;
+    const twice = triangleNormal(p, a, b, c, n);
+    if (twice <= 0) continue;
+    const w = twice / 2;
+    const d = -(n[0]! * p[a * 3]! + n[1]! * p[a * 3 + 1]! + n[2]! * p[a * 3 + 2]!);
+    for (const vert of [a, b, c]) {
+      addPlane(quadric, vert, n[0]!, n[1]!, n[2]!, d, w);
+      area[vert] = area[vert]! + w;
+    }
+  }
+}
+
+/**
+ * A plane standing on every open edge, perpendicular to its face, so a border holds its line.
+ * `edges` counts the faces on each edge, keyed by `edgeKey`.
+ */
+export function addBorderPlanes(
+  p: Float64Array,
+  faces: Uint32Array,
+  edges: ReadonlyMap<number, number>,
+  quadric: Float64Array,
+): void {
+  const v = p.length / 3;
+  const f = faces.length / 3;
+  const n = [0, 0, 0];
+  for (let face = 0; face < f; face++) {
+    const a0 = faces[face * 3] as number;
+    const b0 = faces[face * 3 + 1] as number;
+    const c0 = faces[face * 3 + 2] as number;
+    if (triangleNormal(p, a0, b0, c0, n) <= 0) continue;
+    for (let k = 0; k < 3; k++) {
+      const a = faces[face * 3 + k] as number;
+      const b = faces[face * 3 + ((k + 1) % 3)] as number;
+      if (edges.get(edgeKey(a, b, v)) !== 1) continue;
+      const ex = p[b * 3]! - p[a * 3]!;
+      const ey = p[b * 3 + 1]! - p[a * 3 + 1]!;
+      const ez = p[b * 3 + 2]! - p[a * 3 + 2]!;
+      let px = ey * n[2]! - ez * n[1]!;
+      let py = ez * n[0]! - ex * n[2]!;
+      let pz = ex * n[1]! - ey * n[0]!;
+      const length = Math.hypot(px, py, pz);
+      if (length <= 0) continue;
+      px /= length;
+      py /= length;
+      pz /= length;
+      const d = -(px * p[a * 3]! + py * p[a * 3 + 1]! + pz * p[a * 3 + 2]!);
+      const w = BORDER_WEIGHT * (ex * ex + ey * ey + ez * ez);
+      addPlane(quadric, a, px, py, pz, d, w);
+      addPlane(quadric, b, px, py, pz, d, w);
+    }
+  }
+}
+
+/** A triangle's signed area in uv. */
+export function uvArea(uvs: Float32Array, a: number, b: number, c: number): number {
+  const ux = uvs[b * 2]! - uvs[a * 2]!;
+  const uy = uvs[b * 2 + 1]! - uvs[a * 2 + 1]!;
+  const vx = uvs[c * 2]! - uvs[a * 2]!;
+  const vy = uvs[c * 2 + 1]! - uvs[a * 2 + 1]!;
+  return (ux * vy - uy * vx) / 2;
+}
+
+/**
+ * How far `sample`'s own uv is from what the triangles in `corners` interpolate where it lies: the
+ * triangle it projects into, or the nearest one where it projects into none.
+ */
+export function uvMiss(
+  p: Float64Array,
+  uvs: Float32Array,
+  corners: readonly number[],
+  sample: number,
+): number {
+  let inside = Infinity;
+  let nearest = Infinity;
+  let nearestMiss = Infinity;
+  const px = p[sample * 3]!;
+  const py = p[sample * 3 + 1]!;
+  const pz = p[sample * 3 + 2]!;
+  for (let t = 0; t < corners.length; t += 3) {
+    const a = corners[t] as number;
+    const b = corners[t + 1] as number;
+    const c = corners[t + 2] as number;
+    const e0x = p[b * 3]! - p[a * 3]!;
+    const e0y = p[b * 3 + 1]! - p[a * 3 + 1]!;
+    const e0z = p[b * 3 + 2]! - p[a * 3 + 2]!;
+    const e1x = p[c * 3]! - p[a * 3]!;
+    const e1y = p[c * 3 + 1]! - p[a * 3 + 1]!;
+    const e1z = p[c * 3 + 2]! - p[a * 3 + 2]!;
+    const qx = px - p[a * 3]!;
+    const qy = py - p[a * 3 + 1]!;
+    const qz = pz - p[a * 3 + 2]!;
+    const d00 = e0x * e0x + e0y * e0y + e0z * e0z;
+    const d01 = e0x * e1x + e0y * e1y + e0z * e1z;
+    const d11 = e1x * e1x + e1y * e1y + e1z * e1z;
+    const d20 = qx * e0x + qy * e0y + qz * e0z;
+    const d21 = qx * e1x + qy * e1y + qz * e1z;
+    const denominator = d00 * d11 - d01 * d01;
+    if (denominator <= 1e-30) continue;
+    const beta = (d11 * d20 - d01 * d21) / denominator;
+    const gamma = (d00 * d21 - d01 * d20) / denominator;
+    const alpha = 1 - beta - gamma;
+    const outside = Math.max(0, -alpha, -beta, -gamma);
+    const u = alpha * uvs[a * 2]! + beta * uvs[b * 2]! + gamma * uvs[c * 2]!;
+    const w = alpha * uvs[a * 2 + 1]! + beta * uvs[b * 2 + 1]! + gamma * uvs[c * 2 + 1]!;
+    const miss = Math.hypot(u - uvs[sample * 2]!, w - uvs[sample * 2 + 1]!);
+    if (outside < 1e-6) inside = Math.min(inside, miss);
+    else if (outside < nearest) {
+      nearest = outside;
+      nearestMiss = miss;
+    }
+  }
+  if (inside !== Infinity) return inside;
+  return nearest < NEAR_EDGE ? nearestMiss : Infinity;
+}

package/src/bake/sceneField.ts

@@ -0,0 +1,50 @@
+/**
+ * One distance field over a file's static geometry, for tracing indirect light through a scene.
+ *
+ * **One field for the scene rather than one per mesh, because a bought scene is shaped against the
+ * per-mesh bake.** Its walls come as a few meshes spanning the whole of it, so a field sized to
+ * each mesh's longest side is metre-wide voxels on exactly the walls the light bounces off, and
+ * four hundred of them add more than the model's own geometry. Merged, the same scene is one grid
+ * at a voxel size the caller chooses: 25 cm resolves a column, and a courtyard is three megabytes.
+ *
+ * **What goes in is the caller's to say**, for the reason `addDistanceField` gives: light is traced
+ * against what it is safe to be blocked by. Walls and floors, not foliage, not cloth, not the copies
+ * of a candle drawn ten thousand times. What it gives up is movement: a merged field is static, so
+ * anything that moves wants a field of its own.
+ */
+import { concatMeshes } from '@driftengine/core';
+import { SDFV_WHOLE_FILE } from '@driftengine/drft';
+import type { DrftSdfvEntry, MeshData } from '@driftengine/drft';
+import { bakeObjectSdf } from './sdf.ts';
+
+/**
+ * The field of every mesh `include` admits, merged, at `voxelM` spacing, as the file's
+ * whole-geometry entry. Null when nothing is admitted.
+ */
+export function bakeSceneField(
+  meshes: readonly MeshData[],
+  voxelM: number,
+  include: (index: number) => boolean,
+): DrftSdfvEntry | null {
+  const chosen: MeshData[] = [];
+  for (let index = 0; index < meshes.length; index++) {
+    if (include(index)) chosen.push(meshes[index] as MeshData);
+  }
+  if (chosen.length === 0) return null;
+  const merged = concatMeshes(chosen);
+  const positions = merged.positions;
+  let longest = 0;
+  for (let axis = 0; axis < 3; axis++) {
+    let lo = Number.POSITIVE_INFINITY;
+    let hi = Number.NEGATIVE_INFINITY;
+    for (let at = axis; at < positions.length; at += 3) {
+      const value = positions[at] as number;
+      if (value < lo) lo = value;
+      if (value > hi) hi = value;
+    }
+    longest = Math.max(longest, hi - lo);
+  }
+  const resolution = Math.max(2, Math.ceil(longest / voxelM) + 1);
+  const baked = bakeObjectSdf(merged, resolution);
+  return { mesh: SDFV_WHOLE_FILE, dims: baked.dims, bounds: baked.bounds, field: baked.field };
+}

package/src/bake/sdf.ts

@@ -1,5 +1,6 @@
 /** A signed distance field per object, baked offline, for tracing light through a world. */
 
+import { surfaceDepth } from './surfaceDepth.ts';
 import type { MeshData } from '@driftengine/drft';
 
 /**
@@ -57,11 +58,11 @@ const UNREACHED = 1e30;
  * has a gradient whose length varies with direction, which is the one property a sphere trace
  * depends on, and the failure is a march that overshoots along the coarse axis.
  *
- * **The sign comes from crossing parity, not from the winding.** A face normal, an
- * angle-weighted pseudonormal and a generalised winding number all flip when a mesh is exported
- * with its triangles the other way round, and importers disagree about that constantly — so a
- * model from the wrong tool would come back solid where it is empty. Counting how many times a
- * ray along `x` crosses the surface does not care which way a triangle faces.
+ * **The sign comes from how many surfaces separate a point from open air, not from the winding.**
+ * A face normal, an angle-weighted pseudonormal and a generalised winding number all flip when a
+ * mesh is exported with its triangles the other way round, and importers disagree about that
+ * constantly. A walk over the grid from its own faces does not care which way a triangle faces, and
+ * unlike crossing parity along one axis it does not need the mesh to be closed. See `surfaceDepth.ts`.
  *
  * **The magnitude comes from exact point-to-triangle distance, not from voxelisation.** Marking
  * the cells a triangle passes through and flooding outward loses any wall thinner than a cell,
@@ -130,8 +131,6 @@ export function bakeObjectSdf(mesh: MeshData, resolution: number): ObjectSdf {
   const field = new Float32Array(count).fill(UNREACHED);
   /** The triangle each grid point's distance was measured to, and -1 where none has reached. */
   const closest = new Int32Array(count).fill(-1);
-  /** How many times the surface is crossed between grid point `i - 1` and `i` along `x`. */
-  const crossings = new Int32Array(count);
 
   const ox = origin[0] as number;
   const oy = origin[1] as number;
@@ -173,34 +172,6 @@ export function bakeObjectSdf(mesh: MeshData, resolution: number): ObjectSdf {
         }
       }
     }
-
-    /*
-     * Where a ray along `x` through each grid column crosses this triangle. Recorded at the first
-     * grid point past the crossing, so a scan along `x` accumulating these counts knows, at every
-     * point, how many surfaces stand between it and the grid's `-x` face.
-     */
-    for (let k = clampIndex(Math.ceil((Math.min(az, bz, cz) - oz) / step), nz); k < nz; k++) {
-      const gz = oz + k * step;
-      if (gz > Math.max(az, bz, cz)) break;
-      for (let j = clampIndex(Math.ceil((Math.min(ay, by, cy) - oy) / step), ny); j < ny; j++) {
-        const gy = oy + j * step;
-        if (gy > Math.max(ay, by, cy)) break;
-        const bary = barycentric2d(gy, gz, ay, az, by, bz, cy, cz);
-        if (bary === null) continue;
-        const x = bary[0] * ax + bary[1] * bx + bary[2] * cx;
-        const i = Math.ceil((x - ox) / step);
-        /*
-         * **Unreachable while `PAD_VOXELS` is at least one, and kept because it is a constant.**
-         * The grid reaches two voxels past the mesh on every axis, so no crossing can land past
-         * the `+x` face; with no padding one could, and clamping it would mark the last grid point
-         * as having one more surface behind it than it does — flipping the parity of a point that
-         * is outside. A crossing before the `-x` face is clamped to zero, where it is true: the
-         * grid's first point really does have that surface behind it.
-         */
-        if (i >= nx) continue;
-        crossings[Math.max(0, i) + nx * (j + ny * k)]++;
-      }
-    }
   }
 
   /*
@@ -221,15 +192,14 @@ export function bakeObjectSdf(mesh: MeshData, resolution: number): ObjectSdf {
     if ((field[index] as number) >= UNREACHED) field[index] = reach;
   }
 
-  for (let k = 0; k < nz; k++) {
-    for (let j = 0; j < ny; j++) {
-      let total = 0;
-      const row = nx * (j + ny * k);
-      for (let i = 0; i < nx; i++) {
-        total += crossings[row + i] as number;
-        if (total % 2 === 1) field[row + i] = -(field[row + i] as number);
-      }
-    }
+  /*
+   * **The sign is how many surfaces stand between a point and the open air**: odd is inside. A walk
+   * over the grid answers that for every point, where crossing parity along one axis answered it
+   * only for a closed solid and striped the air of anything built from sheets. See `surfaceDepth.ts`.
+   */
+  const depth = surfaceDepth(field, dims, step);
+  for (let index = 0; index < count; index++) {
+    if ((depth[index] as number) % 2 === 1) field[index] = -(field[index] as number);
   }
 
   return { field, dims, bounds };
@@ -333,61 +303,6 @@ function clampIndex(value: number, count: number): number {
   return value < 0 ? 0 : value > count - 1 ? count - 1 : value;
 }
 
-/**
- * Where a point stands in a triangle projected onto one plane, or null if it stands outside.
- *
- * **The tie-break is what stops a shared edge being counted twice or not at all.** A grid column
- * passing exactly along the edge two triangles share is inside both or neither depending on the
- * sign of a zero, and either answer flips the parity of an entire row. Breaking the tie on the
- * coordinates themselves makes the choice consistent between the two triangles: whichever way it
- * goes, exactly one of them claims the column.
- */
-function barycentric2d(
-  px: number,
-  py: number,
-  ax: number,
-  ay: number,
-  bx: number,
-  by: number,
-  cx: number,
-  cy: number,
-): [number, number, number] | null {
-  const bxr = bx - px;
-  const byr = by - py;
-  const cxr = cx - px;
-  const cyr = cy - py;
-  const axr = ax - px;
-  const ayr = ay - py;
-
-  const areaA = orientation(bxr, byr, cxr, cyr);
-  if (areaA.sign === 0) return null;
-  const areaB = orientation(cxr, cyr, axr, ayr);
-  if (areaB.sign !== areaA.sign) return null;
-  const areaC = orientation(axr, ayr, bxr, byr);
-  if (areaC.sign !== areaA.sign) return null;
-
-  const sum = areaA.area + areaB.area + areaC.area;
-  if (sum === 0) return null;
-  return [areaA.area / sum, areaB.area / sum, areaC.area / sum];
-}
-
-/** Twice the signed area of a triangle with the origin, with zero broken deterministically. */
-function orientation(
-  x1: number,
-  y1: number,
-  x2: number,
-  y2: number,
-): { sign: number; area: number } {
-  const area = y1 * x2 - x1 * y2;
-  if (area > 0) return { sign: 1, area };
-  if (area < 0) return { sign: -1, area };
-  if (y2 > y1) return { sign: 1, area };
-  if (y2 < y1) return { sign: -1, area };
-  if (x1 > x2) return { sign: 1, area };
-  if (x1 < x2) return { sign: -1, area };
-  return { sign: 0, area };
-}
-
 /**
  * The distance from a point to the nearest point of a triangle.
  *