@nayan-ui/engine 1.0.0-beta.5 → 1.0.0-beta.6

package/lib/module/assets/shape.js

@@ -3,9 +3,10 @@
 // Custom shapes: 2D vector paths, and solids built from them (extrusions, lathes, tubes, merged
 // parts) that draw, collide and pick like loaded models.
 import NativeEngine from '../native/NativeNayanEngine';
-import { Builder, meshInfo, registerMesh, VERTEX_FLOATS } from "../render/meshes.js";
+import { meshInfo, registerMesh, VERTEX_FLOATS } from "../render/meshes.js";
 import { SHAPE_MESH } from "../types.js";
 import { nativeGeometry } from "./model.js";
+import { FieldFunction, paintGeometry } from "./procedural.js";
 const TAU = Math.PI * 2;
 /** Line segments per curve, arc or circle quarter when a path is flattened. */
 const CURVE_STEPS = 12;
@@ -369,10 +370,6 @@ function paint(g, color) {
   }
   return g;
 }
-const fromBuilder = b => ({
-  vertices: new Float32Array(b.vertices),
-  indices: new Uint32Array(b.indices)
-});
 
 /** A built-in shape's geometry (unit-sized, centered), to `merge` with others. */
 export function shapeGeometry(shape, options = {}) {
@@ -411,12 +408,19 @@ export function extrude(path, options = {}) {
 
 /** Where a color function is asked about: `u` around (0..1), `v` along (0..1), and the surface there. */
 
-/** A flat color, or one per point of the surface: blushes, stripes, speckles, spots. */
+/**
+ * A flat color, or one per point of the surface: blushes, stripes, speckles, spots. Prefer a
+ * `surfaceColor` field function (evaluated by the native core) to a JS function for detailed models.
+ */
 
-/** A flat color, or one per point of a round face: `r` from its center (0) to its rim (1), `angle` around it. */
+/** A flat color, or one per point of a round face (`faceColor`): `r` from its center (0) to its rim (1), `angle` around it. */
 
+/** A per-point option given as a JS function or a field function. */
+const perPoint = x => typeof x === 'function' || x instanceof FieldFunction;
+const asField = x => x instanceof FieldFunction ? x : undefined;
 /** Colors each vertex by `fn` of its surface point (u, v read from the texture coordinates). */
 function paintBy(g, color) {
+  if (color instanceof FieldFunction) return paintGeometry(g, color);
   if (typeof color !== 'function') return paint(g, color);
   const v = g.vertices;
   for (let i = 0; i < v.length; i += VERTEX_FLOATS) {
@@ -441,34 +445,54 @@ export function recolor(geometry, color) {
   return paintBy(geometry, color);
 }
 
+/** A flat color for the native builder (vertex colors are RGB). */
+const flat = color => color ? [color[0], color[1], color[2]] : undefined;
+
+/** Builds a sweep (lathe, tube or loft) part in the native core. */
+export function nativeSweep(part) {
+  const core = native();
+  if (typeof core.worldgenMesh !== 'function') throw new Error("shapes: this app's native core predates native lathes and tubes: rebuild it");
+  const built = core.worldgenMesh(JSON.stringify({
+    parts: [part]
+  }));
+  return {
+    vertices: new Float32Array(built.vertices),
+    indices: new Uint32Array(built.indices)
+  };
+}
+
+/** Colors vertices [from, to) by `color` of each surface point (u, v from the texture coordinates). */
+function paintRange(g, from, to, color) {
+  const v = g.vertices;
+  for (let i = from * VERTEX_FLOATS; i < to * VERTEX_FLOATS; i += VERTEX_FLOATS) {
+    const c = color({
+      u: v[i + 9],
+      v: v[i + 10],
+      position: [v[i], v[i + 1], v[i + 2]],
+      normal: [v[i + 3], v[i + 4], v[i + 5]]
+    });
+    v[i + 6] = c[0];
+    v[i + 7] = c[1];
+    v[i + 8] = c[2];
+  }
+}
+
 /**
- * A round face: a polar grid of `rings` x `segments` around `center` in the plane spanned by unit
- * vectors `x` and `y` (radius `radius(angle)` toward the rim), facing `normal`, swept `sweep` radians.
+ * Colors a round end face built with raw polar coordinates in its UVs (around 0..1, out 0..1) by
+ * `color(r, angle)`, then gives it planar disc UVs.
  */
-function roundFace(center, x, y, normal, radius, sweep, segments, rings, color) {
-  const b = new Builder();
-  b.grid(rings, segments, (u, v) => {
-    const a = u * sweep;
-    const r = radius(u) * v;
-    const [c, s] = [Math.cos(a) * r, Math.sin(a) * r];
-    return [[center[0] + x[0] * c + y[0] * s, center[1] + x[1] * c + y[1] * s, center[2] + x[2] * c + y[2] * s], normal];
-  });
-  const g = facingOutward(fromBuilder(b));
+function paintFace(g, from, to, sweep, color) {
   const vs = g.vertices;
-  for (let i = 0; i < vs.length; i += VERTEX_FLOATS) {
+  for (let i = from * VERTEX_FLOATS; i < to * VERTEX_FLOATS; i += VERTEX_FLOATS) {
     const a = vs[i + 9] * sweep;
     const r = vs[i + 10];
-    // Texture coordinates across the face, like a disc's.
     vs[i + 9] = 0.5 + Math.cos(a) * r / 2;
     vs[i + 10] = 0.5 + Math.sin(a) * r / 2;
-    if (typeof color === 'function') {
-      const c = color(r, a);
-      vs[i + 6] = c[0];
-      vs[i + 7] = c[1];
-      vs[i + 8] = c[2];
-    }
+    const c = color(r, a);
+    vs[i + 6] = c[0];
+    vs[i + 7] = c[1];
+    vs[i + 8] = c[2];
   }
-  return typeof color === 'function' ? g : paint(g, color);
 }
 
 /** Whether a typed array covers its whole ArrayBuffer (so the native passes can take the buffer). */
@@ -544,71 +568,53 @@ export function lathe(profile, options = {}) {
   const full = sweep >= TAU - 1e-6;
   const last = points.length - 1;
 
-  // Profile normals in the (radius, height) plane: the average of the neighbouring edges', turned outward.
-  const edge = i => {
-    const a = points[Math.max(0, i)];
-    const b = points[Math.min(last, i + 1)];
-    const len = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1;
-    return [(a[1] - b[1]) / len, (b[0] - a[0]) / len]; // going down the profile, outward is to the left
-  };
-  const normals = points.map(([r], i) => {
-    // On the axis the surface is a pole: straight up at the top, down at the bottom.
-    if (r < 1e-6 && (i === 0 || i === last)) return [0, i === 0 ? 1 : -1];
-    const e1 = edge(i - 1);
-    const e2 = edge(i);
-    const n = i === 0 ? e2 : i === last ? e1 : [e1[0] + e2[0], e1[1] + e2[1]];
-    const len = Math.hypot(n[0], n[1]) || 1;
-    return [n[0] / len, n[1] / len];
-  });
-  const b = new Builder();
+  // Only the game's own JS functions run here (field functions run in the core with the surface).
   const displace = options.displace;
-  // a = u * sweep around the axis; the same orientation as the built-in sphere, so faces point outward.
-  b.grid(last, segments, (u, v) => {
-    const i = Math.round(v * last);
-    const a = u * sweep;
-    const [r, y] = points[i];
-    const [nr, ny] = normals[i];
-    const n = [nr * Math.cos(a), ny, -nr * Math.sin(a)];
-    // The seam and the poles must move together, or the surface tears.
-    const d = displace ? displace(r < 1e-6 || full && u === 1 ? 0 : u, v) : 0;
-    return [[r * Math.cos(a) + n[0] * d, y + n[1] * d, -r * Math.sin(a) + n[2] * d], n];
-  });
-  const parts = [{
-    geometry: paintBy(displace ? smoothNormals(fromBuilder(b)) : fromBuilder(b), options.color)
-  }];
-
-  // Ends away from the axis: flat round faces (part of a circle when the sweep is partial).
-  const capColor = options.capColor ?? (typeof options.color === 'function' ? undefined : options.color);
-  const rings = Math.max(1, Math.round(options.capRings ?? (typeof capColor === 'function' ? 12 : 1)));
-  for (const [i, facing] of [[0, 1], [last, -1]]) {
-    const [r, y] = points[i];
-    if (r < 1e-6) continue;
-    parts.push({
-      geometry: roundFace([0, y, 0], [1, 0, 0], [0, 0, -1], [0, facing, 0], () => r, sweep, segments, rings, capColor)
-    });
+  let offsets;
+  if (typeof displace === 'function') {
+    offsets = new Array((last + 1) * (segments + 1));
+    for (let i = 0; i <= last; i++) {
+      const pole = points[i][0] < 1e-6;
+      for (let j = 0; j <= segments; j++) {
+        const u = j / segments;
+        // The seam and the poles must move together, or the surface tears.
+        offsets[i * (segments + 1) + j] = displace(pole || full && u === 1 ? 0 : u, i / last);
+      }
+    }
   }
-  if (full) return parts.length > 1 ? merge(parts) : parts[0].geometry;
-
-  // The cut: the region between the profile and the axis, laid into the planes at a = 0 and a = sweep.
-  // A profile whose height only falls gets a grid (so a color function has points to work with);
-  // one that turns back (a dimple) is filled exactly by the core.
-  const cutColor = options.cutColor ?? (typeof options.color === 'function' ? undefined : options.color);
-  const falling = points.every((p, i) => i === 0 || p[1] <= points[i - 1][1] + 1e-9);
-  let face;
-  if (falling) {
-    const g = new Builder();
-    const steps = Math.max(1, Math.round(options.cutSteps ?? (typeof cutColor === 'function' ? 12 : 1)));
-    g.grid(last, steps, (u, v) => {
-      const [r, y] = points[Math.round(v * last)];
-      return [[u * r, y, 0], [0, 0, 1]];
-    });
-    face = facingOutward(fromBuilder(g));
-  } else {
-    face = extrude(new Path().addPolygon([[0, -points[0][1]], ...points.map(([r, y]) => [r, -y]), [0, -points[last][1]]]), {
-      depth: 0
-    });
+  const color = options.color;
+  const capColor = options.capColor ?? (perPoint(color) ? undefined : color);
+  const capRings = Math.max(1, Math.round(options.capRings ?? (perPoint(capColor) ? 12 : 1)));
+  const cutColor = options.cutColor ?? (perPoint(color) ? undefined : color);
+  const cutSteps = Math.max(1, Math.round(options.cutSteps ?? (perPoint(cutColor) ? 12 : 1)));
+  const g = nativeSweep({
+    kind: 'lathe',
+    points,
+    segments,
+    sweep,
+    displace: offsets,
+    displaceField: asField(displace),
+    color: perPoint(color) ? undefined : flat(color),
+    colorField: asField(color),
+    capColor: perPoint(capColor) ? undefined : flat(capColor),
+    capColorField: asField(capColor),
+    rawCaps: typeof capColor === 'function',
+    capRings,
+    cutColor: perPoint(cutColor) ? undefined : flat(cutColor),
+    cutColorField: asField(cutColor),
+    cutSteps
+  });
+
+  // Vertices: the side grid, the caps away from the axis (top, bottom), then the two cut faces.
+  let at = (last + 1) * (segments + 1);
+  if (typeof color === 'function') paintRange(g, 0, at, color);
+  for (const i of [0, last]) {
+    if (points[i][0] < 1e-6) continue;
+    const end = at + (capRings + 1) * (segments + 1);
+    if (typeof capColor === 'function') paintFace(g, at, end, sweep, capColor);
+    at = end;
   }
-  if (typeof cutColor === 'function') {
+  if (!full && typeof cutColor === 'function') {
     const widest = Math.max(...points.map(p => p[0]), 1e-6);
     const skinAt = y => {
       // The profile's radius at height y (for r from the axis to the skin).
@@ -620,35 +626,20 @@ export function lathe(profile, options = {}) {
       }
       return best || widest;
     };
-    const fv = face.vertices;
-    for (let i = 0; i < fv.length; i += VERTEX_FLOATS) {
-      const c = cutColor(Math.min(1, fv[i] / skinAt(fv[i + 1])), fv[i + 1]);
-      fv.set(c.slice(0, 3), i + 6);
+    // Both cut faces hold the same points in the same order; the first lies in the a = 0 plane (x = r).
+    const v = g.vertices;
+    const half = (v.length / VERTEX_FLOATS - at) / 2;
+    for (let k = 0; k < half; k++) {
+      const i = (at + k) * VERTEX_FLOATS;
+      const c = cutColor(Math.min(1, v[i] / skinAt(v[i + 1])), v[i + 1]);
+      for (const o of [i, i + half * VERTEX_FLOATS]) {
+        v[o + 6] = c[0];
+        v[o + 7] = c[1];
+        v[o + 8] = c[2];
+      }
     }
-  } else {
-    paint(face, cutColor);
   }
-  const cut = (angle, flip) => {
-    const g = {
-      vertices: face.vertices.slice(),
-      indices: face.indices.slice()
-    };
-    const [c, s] = [Math.cos(angle), Math.sin(angle)];
-    const n = angle === 0 ? [0, 0, 1] : [-s, 0, -c];
-    for (let v = 0; v < g.vertices.length; v += VERTEX_FLOATS) {
-      const r = g.vertices[v];
-      g.vertices[v] = r * c;
-      g.vertices[v + 2] = -r * s;
-      g.vertices.set(n, v + 3);
-    }
-    if (flip) for (let t = 0; t < g.indices.length; t += 3) [g.indices[t + 1], g.indices[t + 2]] = [g.indices[t + 2], g.indices[t + 1]];
-    return g;
-  };
-  return merge([...parts, {
-    geometry: cut(0, false)
-  }, {
-    geometry: cut(sweep, true)
-  }]);
+  return g;
 }
 /**
  * A tube along a smooth curve through `points`: bananas, stems, chillies, worms, snakes, ropes,
@@ -662,140 +653,51 @@ export function tube(points, options = {}) {
   if (closed && points.length > 1 && distance(points[0], points[points.length - 1]) < 1e-9) points = points.slice(0, -1);
   if (points.length < (closed ? 3 : 2)) throw new Error(`tube: needs at least ${closed ? 'three' : 'two'} distinct points`);
   const radius = typeof options.radius === 'function' ? options.radius : () => options.radius ?? 0.1;
-  const shape = options.shape ?? (() => 1);
+  const shape = options.shape;
   const sides = Math.max(3, Math.round(options.sides ?? 12));
   const steps = Math.max(1, Math.round(options.smoothness ?? 8));
 
-  // Catmull-Rom through the points.
-  const p = i => points[closed ? (i + points.length) % points.length : Math.max(0, Math.min(points.length - 1, i))];
-  const curve = [];
-  for (let i = 0; i < points.length - (closed ? 0 : 1); i++) {
-    const [a, b, c, d] = [p(i - 1), p(i), p(i + 1), p(i + 2)];
-    for (let s = 0; s < steps; s++) {
-      const t = s / steps;
-      const t2 = t * t;
-      const t3 = t2 * t;
-      const coordinate = k => 0.5 * (2 * b[k] + (-a[k] + c[k]) * t + (2 * a[k] - 5 * b[k] + 4 * c[k] - d[k]) * t2 + (-a[k] + 3 * b[k] - 3 * c[k] + d[k]) * t3);
-      curve.push([coordinate(0), coordinate(1), coordinate(2)]);
-    }
-  }
-  curve.push(p(closed ? 0 : points.length - 1));
-  const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-  const cross = (a, b) => [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 dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-  const norm = a => {
-    const l = Math.hypot(a[0], a[1], a[2]) || 1;
-    return [a[0] / l, a[1] / l, a[2] / l];
-  };
-  const last = curve.length - 1;
-  const tangents = curve.map((_, i) => {
-    let delta = sub(curve[closed && i === last ? 1 : Math.min(last, i + 1)], curve[closed && i === 0 ? last - 1 : Math.max(0, i - 1)]);
-    // A reversing curve has no central derivative. Use its incoming/outgoing segment instead.
-    if (Math.hypot(...delta) < 1e-9) delta = i > 0 ? sub(curve[i], curve[i - 1]) : sub(curve[1], curve[0]);
-    return norm(delta);
+  // Only the game's own functions run here (a radius per curve point, a multiplier per side); the
+  // core smooths the curve, frames it and builds the surface.
+  const count = (points.length - (closed ? 0 : 1)) * steps + 1;
+  const last = count - 1;
+  const radii = Array.from({
+    length: count
+  }, (_, i) => Math.max(0, radius(closed && i === last ? 0 : i / last)));
+  const color = options.color;
+  const caps = !closed && (options.caps ?? true);
+  const capColor = options.capColor ?? (perPoint(color) ? undefined : color);
+  const capRings = perPoint(capColor) ? 8 : 1;
+  const g = nativeSweep({
+    kind: 'tube',
+    points,
+    closed,
+    sides,
+    steps,
+    radii,
+    shape: shape && Array.from({
+      length: sides + 1
+    }, (_, j) => shape(j === sides ? 0 : j / sides)),
+    // Taper changes the longitudinal component too; radial normals only describe a cylinder.
+    smooth: !!shape || typeof options.radius === 'function',
+    caps,
+    color: perPoint(color) ? undefined : flat(color),
+    colorField: asField(color),
+    capColor: perPoint(capColor) ? undefined : flat(capColor),
+    capColorField: asField(capColor),
+    rawCaps: typeof capColor === 'function',
+    capRings
   });
-  if (closed) tangents[last] = tangents[0];
-  // Minimal rotations between tangents: projecting the previous normal onto the next plane
-  // collapses at right-angle bends and adds unwanted twist to curls.
-  const t0 = tangents[0];
-  let normal = norm(cross(t0, Math.abs(t0[1]) < 0.9 ? [0, 1, 0] : [1, 0, 0]));
-  let previous = t0;
-  const frames = [];
-  for (const t of tangents) {
-    const axis = cross(previous, t);
-    const cosine = Math.max(-1, Math.min(1, dot(previous, t)));
-    if (cosine > -1 + 1e-8) {
-      const turn = cross(axis, normal);
-      const second = cross(axis, turn);
-      normal = [normal[0] + turn[0] + second[0] / (1 + cosine), normal[1] + turn[1] + second[1] / (1 + cosine), normal[2] + turn[2] + second[2] / (1 + cosine)];
-    }
-    // At a reversal, a half turn about the normal retains it and reverses the binormal.
-    const projection = dot(normal, t);
-    normal = norm(sub(normal, [t[0] * projection, t[1] * projection, t[2] * projection]));
-    frames.push([normal, cross(t, normal)]);
-    previous = t;
-  }
-  if (closed) {
-    const end = frames[last][0],
-      start = frames[0][0];
-    const correction = Math.atan2(dot(t0, cross(end, start)), dot(end, start));
-    const lengths = [0];
-    for (let i = 1; i <= last; i++) lengths.push(lengths[i - 1] + distance(curve[i], curve[i - 1]));
-    for (let i = 1; i <= last; i++) {
-      const angle = correction * lengths[i] / lengths[last];
-      const [n, bn] = frames[i];
-      const c = Math.cos(angle),
-        s = Math.sin(angle);
-      const corrected = [n[0] * c + bn[0] * s, n[1] * c + bn[1] * s, n[2] * c + bn[2] * s];
-      frames[i] = [corrected, cross(tangents[i], corrected)];
-    }
-    frames[last] = frames[0];
-  }
-  const b = new Builder();
-  const ring = curve.map((c, i) => {
-    const r = Math.max(0, radius(closed && i === last ? 0 : i / last));
-    const [n, bn] = frames[i];
-    const first = b.vertices.length / VERTEX_FLOATS;
-    for (let j = 0; j <= sides; j++) {
-      const a = (j === sides ? 0 : j / sides) * TAU;
-      const cosine = Math.cos(a),
-        sine = Math.sin(a);
-      const dir = [cosine * n[0] + sine * bn[0], cosine * n[1] + sine * bn[1], cosine * n[2] + sine * bn[2]];
-      const rj = r * shape(j === sides ? 0 : j / sides);
-      b.vertex([c[0] + dir[0] * rj, c[1] + dir[1] * rj, c[2] + dir[2] * rj], dir, j / sides, i / (curve.length - 1));
-    }
-    return {
-      first,
-      r
-    };
-  });
-  for (let i = 0; i < ring.length - 1; i++) {
-    for (let j = 0; j < sides; j++) {
-      const a = ring[i].first + j;
-      const c = ring[i + 1].first + j;
-      b.indices.push(a, a + 1, c, a + 1, c + 1, c);
-    }
-  }
-  let side = facingOutward(fromBuilder(b));
-  // Taper changes the longitudinal component too; radial normals only describe a cylinder.
-  if (options.shape || typeof options.radius === 'function') side = smoothNormals(side);
-  const parts = [{
-    geometry: paintBy(side, options.color)
-  }];
-  if (!closed && (options.caps ?? true)) {
-    const capColor = options.capColor ?? (typeof options.color === 'function' ? undefined : options.color);
-    const rings = typeof capColor === 'function' ? 8 : 1;
-    for (const [i, facing] of [[0, -1], [ring.length - 1, 1]]) {
-      const {
-        r
-      } = ring[i];
-      if (r < 1e-6) continue;
-      const t = tangents[i];
-      const [fn, fb] = frames[i];
-      parts.push({
-        geometry: roundFace(curve[i], fn, fb, [t[0] * facing, t[1] * facing, t[2] * facing], u => r * shape(u === 1 ? 0 : u), TAU, sides, rings, capColor)
-      });
-    }
-  }
-  return parts.length > 1 ? merge(parts) : parts[0].geometry;
-}
 
-/** Flips triangles whose winding disagrees with their vertex normals (so back-face culling keeps them). */
-function facingOutward(g) {
-  const native = nativeGeometry3(g);
-  if (native) {
-    native.geometryFaceOutward(g.vertices.buffer, g.indices.buffer);
-    return g;
-  }
-  const v = g.vertices;
-  const at = (i, k) => v[g.indices[i] * VERTEX_FLOATS + k];
-  for (let t = 0; t < g.indices.length; t += 3) {
-    const e1 = [0, 1, 2].map(k => at(t + 1, k) - at(t, k));
-    const e2 = [0, 1, 2].map(k => at(t + 2, k) - at(t, k));
-    const face = [e1[1] * e2[2] - e1[2] * e2[1], e1[2] * e2[0] - e1[0] * e2[2], e1[0] * e2[1] - e1[1] * e2[0]];
-    const n = [0, 1, 2].map(k => at(t, k + 3) + at(t + 1, k + 3) + at(t + 2, k + 3));
-    if (face[0] * n[0] + face[1] * n[1] + face[2] * n[2] < 0) {
-      [g.indices[t + 1], g.indices[t + 2]] = [g.indices[t + 2], g.indices[t + 1]];
+  // Vertices: the side rings, then the start and end caps (where the radius isn't 0).
+  let at = count * (sides + 1);
+  if (typeof color === 'function') paintRange(g, 0, at, color);
+  if (caps && typeof capColor === 'function') {
+    for (const i of [0, last]) {
+      if (radii[i] < 1e-6) continue;
+      const end = at + (capRings + 1) * (sides + 1);
+      paintFace(g, at, end, TAU, capColor);
+      at = end;
     }
   }
   return g;

package/lib/module/assets/texture.js

@@ -3,6 +3,7 @@
 import NativeEngine from '../native/NativeNayanEngine';
 // Textures: PNG / JPEG images, decoded by the Rust core, drawn on built-in shapes or models.
 import { meshInfo } from "../render/meshes.js";
+import { resolveColor } from "../world/color.js";
 import { AssetLoader } from "./AssetLoader.js";
 import { registerCoreMesh } from "./model.js";
 
@@ -66,4 +67,68 @@ export function texturedMesh(mesh, texture) {
   }
   return id;
 }
+
+/** One model in a bake. */
+
+/** A model's baked picture: its texture, and the square of the model's x/y it covers. */
+
+/**
+ * Draws a model once, in the native core, into an anti-aliased picture with a transparent
+ * background: seen from +z (orthographic), shaded as the renderer shades it under `light`. Show it
+ * instead of the model where it only ever faces the camera (icons, tiles, cards): on the built-in
+ * `"plane"` turned to face +z, scaled to `2 * extent`, under a `frontLight` (which shows camera-facing
+ * surfaces at exactly their color), with an alpha just below 1 so its soft edges blend. One quad
+ * then draws what took thousands of triangles, with smooth edges at every quality level.
+ */
+export function bakeModel(model, options) {
+  const mesh = model == null ? -1 : typeof model === 'number' ? model : model.id;
+  const native = NativeEngine;
+  if (typeof native.modelBake !== 'function') throw new Error("bakeModel: this app's native core predates baked models: rebuild it");
+  const {
+    light
+  } = options;
+  const lightColor = resolveColor(light.color ?? [1, 1, 1]);
+  const sky = resolveColor(options.background ?? [0, 0, 0]);
+  const spec = {
+    size: Math.max(1, Math.min(1024, Math.round(options.size))),
+    supersample: options.supersample ?? 4,
+    light: light.direction,
+    ambient: light.ambient,
+    lightColor: [lightColor[0], lightColor[1], lightColor[2]],
+    sky: [sky[0], sky[1], sky[2]],
+    shine: options.shine ?? meshInfo(mesh)?.shine ?? 0,
+    padding: options.padding ?? 0.04,
+    parts: options.parts?.map(part => {
+      const id = typeof part.model === 'number' ? part.model : part.model.id;
+      const scale = part.scale ?? 1;
+      const color = resolveColor(part.color ?? [1, 1, 1]);
+      return {
+        mesh: id,
+        position: part.position ?? [0, 0, 0],
+        scale: typeof scale === 'number' ? [scale, scale, scale] : scale,
+        color: [color[0], color[1], color[2]],
+        shine: part.shine ?? meshInfo(id)?.shine ?? 0
+      };
+    }),
+    frame: options.frame && [options.frame.center[0], options.frame.center[1], options.frame.extent],
+    key: options.key
+  };
+  const baked = native.modelBake(Math.max(0, mesh), JSON.stringify(spec));
+  if (baked.length !== 4) throw new Error(`bakeModel: ${native.loadError() || 'failed'}`);
+  const [texture, x, y, extent] = baked;
+  return {
+    texture: {
+      id: texture,
+      width: spec.size,
+      height: spec.size
+    },
+    center: [x, y],
+    extent
+  };
+}
+
+/** Whether a picture was kept under `key` by `bakeModel` (so it can be restored without its models). */
+export function isBakeKept(key) {
+  return typeof NativeEngine?.bakeKept === 'function' && NativeEngine.bakeKept(key);
+}
 //# sourceMappingURL=texture.js.map

package/lib/module/drawing/DrawingDocument.js

@@ -21,7 +21,7 @@ export class DrawingDocument {
   boundTexture = null;
   constructor(width, height, pixelRatio = 2) {
     if (!NativeEngine || typeof NativeEngine.drawingCreate !== 'function') {
-      throw new Error('Drawing requires a native app rebuild with the updated Nayan engine.');
+      throw new Error('Drawing requires a native app rebuild with the updated Nayan Game Engine.');
     }
     NativeEngine.renderWarmUp?.();
     const id = NativeEngine.drawingCreate(width, height, pixelRatio);

package/lib/module/index.js

@@ -19,14 +19,17 @@ export { warmUpEngine, getMeshIdLimit } from "./render/meshes.js";
 export { loadModel } from "./assets/model.js";
 export { clearAssetCache } from "./assets/AssetCache.js";
 export { ProceduralCache } from "./assets/ProceduralCache.js";
-export { loadTexture } from "./assets/texture.js";
+export { bakeModel, isBakeKept, loadTexture } from "./assets/texture.js";
 export { Solid, solidGeometry, createSolid, optimizeGeometry, createGeometryLods, getGeometryStats, deformGeometry } from "./assets/modelling.js";
 export { loft, block, ellipsoid, smoothCurve } from "./assets/loft.js";
 export { parametricSurface } from "./assets/surface.js";
+export { faceColor, FieldFunction, FieldGraph, FieldRef, generateMesh, generateWorld, generateWorldAsync, isWorldKept, ProceduralWorld, sectionColor, surfaceColor, surfaceDisplacement } from "./assets/procedural.js";
 export { createShape, extrude, lathe, merge, Path, recolor, shapeGeometry, smoothNormals, tube } from "./assets/shape.js";
 export { loadFont, measureText } from "./assets/font.js";
 // Sound and haptics.
 export { audio } from "./media/audio.js";
+export { speech } from "./media/speech.js";
+export { microphone } from "./media/microphone.js";
 export { haptics } from "./media/haptics.js";
 // Input.
 export { Joystick, useJoystick } from './input/Joystick';

package/lib/module/media/audio-worklet.js

@@ -31,4 +31,31 @@ class NayanMixer extends AudioWorkletProcessor {
   }
 }
 registerProcessor('nayan-mixer', NayanMixer);
+
+// The page's microphone: mixes each input block to mono and posts ~43 ms batches to the main thread,
+// which hands them to the core's capture buffer.
+class NayanMicrophone extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.batch = new Float32Array(2048);
+    this.filled = 0;
+  }
+  process(inputs) {
+    const channels = inputs[0];
+    if (!channels || !channels.length) return true;
+    const frames = channels[0].length;
+    for (let i = 0; i < frames; i++) {
+      let sum = 0;
+      for (let c = 0; c < channels.length; c++) sum += channels[c][i];
+      this.batch[this.filled++] = sum / channels.length;
+      if (this.filled === this.batch.length) {
+        this.port.postMessage(this.batch, [this.batch.buffer]);
+        this.batch = new Float32Array(2048);
+        this.filled = 0;
+      }
+    }
+    return true;
+  }
+}
+registerProcessor('nayan-microphone', NayanMicrophone);
 //# sourceMappingURL=audio-worklet.js.map

package/lib/module/media/audio.js

@@ -67,6 +67,26 @@ export const audio = {
   stop(voice) {
     if (voice) NativeEngine?.audioStop(voice);
   },
+  /**
+   * Frees a sound's samples, for sounds made at runtime (a `microphone.take` recording, once played).
+   * Its id then plays nothing; voices already playing it finish first. Don't release a bank's sounds.
+   */
+  release(sound) {
+    if (sound != null) NativeEngine?.audioRelease?.(sound);
+  },
+  /** A sound's length in seconds (0 if unknown or released). */
+  duration(sound) {
+    return NativeEngine?.audioDuration?.(sound) ?? 0;
+  },
+  /**
+   * A sound's loudness (RMS, 0..1) over time, one value per `1 / perSecond` seconds from its start:
+   * drive a talking mouth, a bobbing body or a meter from it while the sound plays (at `pitch` p,
+   * value i plays at i / (perSecond * p) seconds).
+   */
+  levels(sound, perSecond = 30) {
+    const buffer = NativeEngine?.audioLevels?.(sound, perSecond);
+    return buffer ? new Float32Array(buffer) : new Float32Array(0);
+  },
   get muted() {
     return muted;
   },