@call-me-sensei/toonlab 0.1.1

package/src/rockgen/mesh/surfaceNets.js

@@ -0,0 +1,329 @@
+// Surface nets over a dense sampled grid: one vertex per sign-changing
+// cell, one quad per sign-changing grid edge — the even, quad-dominant
+// topology that cel-shades cleanly at low resolutions.
+//
+// Vertex placement has two modes:
+//   - mass point (classic naive nets): the mean of the cell's edge
+//     crossings. Chamfers sharp creases by ~1 voxel.
+//   - DUAL CONTOURING (pass `evaluate`): solve the QEF — the point that
+//     best satisfies every crossing's tangent plane (normals from field
+//     gradients) — so planar-cut edges and heightfield ridgelines stay
+//     knife-sharp. Tikhonov-regularized toward the mass point and clamped
+//     into the cell, so smooth surfaces degrade gracefully to classic
+//     nets instead of growing spikes.
+
+// Cube corner offsets in (x, y, z) bit order.
+const CORNER_OFFSETS = [
+  [0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0],
+  [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1],
+];
+
+// The 12 cube edges as corner index pairs.
+const CUBE_EDGES = [
+  [0, 1], [2, 3], [4, 5], [6, 7],
+  [0, 2], [1, 3], [4, 6], [5, 7],
+  [0, 4], [1, 5], [2, 6], [3, 7],
+];
+
+/**
+ * Samples `evaluate` over a uniform grid covering `bounds`. `resolution` is
+ * the cell count along the longest axis; other axes derive from aspect so
+ * cells stay cubic.
+ *
+ * Returns { values, dims, origin, cellSize } where `values` holds
+ * (nx+1)*(ny+1)*(nz+1) corner samples (x fastest, then y, then z).
+ */
+export function sampleGrid(evaluate, bounds, resolution) {
+  const sizeX = bounds.max[0] - bounds.min[0];
+  const sizeY = bounds.max[1] - bounds.min[1];
+  const sizeZ = bounds.max[2] - bounds.min[2];
+  const longest = Math.max(sizeX, sizeY, sizeZ);
+  if (!(longest > 0)) throw new Error('Rockgen grid bounds are empty.');
+  const cellSize = longest / resolution;
+  const nx = Math.max(Math.ceil(sizeX / cellSize), 1);
+  const ny = Math.max(Math.ceil(sizeY / cellSize), 1);
+  const nz = Math.max(Math.ceil(sizeZ / cellSize), 1);
+
+  const values = new Float32Array((nx + 1) * (ny + 1) * (nz + 1));
+  const origin = [bounds.min[0], bounds.min[1], bounds.min[2]];
+  let write = 0;
+  for (let z = 0; z <= nz; z += 1) {
+    const wz = origin[2] + z * cellSize;
+    for (let y = 0; y <= ny; y += 1) {
+      const wy = origin[1] + y * cellSize;
+      for (let x = 0; x <= nx; x += 1) {
+        values[write] = evaluate(origin[0] + x * cellSize, wy, wz);
+        write += 1;
+      }
+    }
+  }
+  return { cellSize, dims: [nx, ny, nz], origin, values };
+}
+
+// Solves the 3x3 symmetric system (A + λI) x = b via the adjugate;
+// returns false when the matrix is too ill-conditioned to trust.
+function solveSymmetric3(a00, a01, a02, a11, a12, a22, b0, b1, b2, out) {
+  const c00 = a11 * a22 - a12 * a12;
+  const c01 = a02 * a12 - a01 * a22;
+  const c02 = a01 * a12 - a02 * a11;
+  const det = a00 * c00 + a01 * c01 + a02 * c02;
+  if (Math.abs(det) < 1e-10) return false;
+  const inv = 1 / det;
+  out[0] = (c00 * b0 + c01 * b1 + c02 * b2) * inv;
+  out[1] = (c01 * b0 + (a00 * a22 - a02 * a02) * b1 + (a02 * a01 - a00 * a12) * b2) * inv;
+  out[2] = (c02 * b0 + (a01 * a02 - a00 * a12) * b1 + (a00 * a11 - a01 * a01) * b2) * inv;
+  return true;
+}
+
+/**
+ * Extracts the zero isosurface from a sampled grid. Returns
+ * { positions: Float32Array, indices: Uint32Array } in world space.
+ *
+ * @param {object} grid From sampleGrid().
+ * @param {object} [options]
+ * @param {(x,y,z)=>number} [options.evaluate] Field for gradient normals —
+ *   enables dual-contouring (QEF) vertex placement; omit for mass points.
+ */
+export function surfaceNets(grid, { evaluate = null } = {}) {
+  const [nx, ny, nz] = grid.dims;
+  const { cellSize, origin, values } = grid;
+  const rowStride = nx + 1;
+  const sliceStride = (nx + 1) * (ny + 1);
+
+  // Vertex index per cell, -1 where the cell has no crossing.
+  const cellVertex = new Int32Array(nx * ny * nz).fill(-1);
+  const positions = [];
+
+  const cornerValues = new Float32Array(8);
+  const crossX = new Float32Array(12);
+  const crossY = new Float32Array(12);
+  const crossZ = new Float32Array(12);
+  const normX = new Float32Array(12);
+  const normY = new Float32Array(12);
+  const normZ = new Float32Array(12);
+  const solved = new Float32Array(3);
+  const gradEps = cellSize * 0.5;
+  // Regularization weight: high enough that near-flat cells stay at the
+  // mass point, low enough that two crossing cut planes pin the crease.
+  const LAMBDA = 0.12;
+
+  for (let z = 0; z < nz; z += 1) {
+    for (let y = 0; y < ny; y += 1) {
+      for (let x = 0; x < nx; x += 1) {
+        let mask = 0;
+        for (let corner = 0; corner < 8; corner += 1) {
+          const [ox, oy, oz] = CORNER_OFFSETS[corner];
+          const value = values[(x + ox) + (y + oy) * rowStride + (z + oz) * sliceStride];
+          cornerValues[corner] = value;
+          if (value < 0) mask |= 1 << corner;
+        }
+        if (mask === 0 || mask === 0xff) continue;
+
+        // Edge zero-crossings (cell-local coordinates in [0, 1]).
+        let px = 0;
+        let py = 0;
+        let pz = 0;
+        let crossings = 0;
+        for (const [c0, c1] of CUBE_EDGES) {
+          const v0 = cornerValues[c0];
+          const v1 = cornerValues[c1];
+          if ((v0 < 0) === (v1 < 0)) continue;
+          const t = v0 / (v0 - v1);
+          const [ax, ay, az] = CORNER_OFFSETS[c0];
+          const [bx, by, bz] = CORNER_OFFSETS[c1];
+          crossX[crossings] = ax + (bx - ax) * t;
+          crossY[crossings] = ay + (by - ay) * t;
+          crossZ[crossings] = az + (bz - az) * t;
+          px += crossX[crossings];
+          py += crossY[crossings];
+          pz += crossZ[crossings];
+          crossings += 1;
+        }
+        const inv = 1 / crossings;
+        px *= inv;
+        py *= inv;
+        pz *= inv;
+
+        if (evaluate) {
+          // QEF: minimize Σ (n_i · (v - p_i))² + λ|v - masspoint|² over the
+          // crossing tangent planes (normals = field gradients).
+          let a00 = LAMBDA;
+          let a01 = 0;
+          let a02 = 0;
+          let a11 = LAMBDA;
+          let a12 = 0;
+          let a22 = LAMBDA;
+          let b0 = LAMBDA * px;
+          let b1 = LAMBDA * py;
+          let b2 = LAMBDA * pz;
+          for (let i = 0; i < crossings; i += 1) {
+            const wx = origin[0] + (x + crossX[i]) * cellSize;
+            const wy = origin[1] + (y + crossY[i]) * cellSize;
+            const wz = origin[2] + (z + crossZ[i]) * cellSize;
+            let gx = evaluate(wx + gradEps, wy, wz) - evaluate(wx - gradEps, wy, wz);
+            let gy = evaluate(wx, wy + gradEps, wz) - evaluate(wx, wy - gradEps, wz);
+            let gz = evaluate(wx, wy, wz + gradEps) - evaluate(wx, wy, wz - gradEps);
+            const len = Math.sqrt(gx * gx + gy * gy + gz * gz);
+            if (len < 1e-9) continue;
+            gx /= len;
+            gy /= len;
+            gz /= len;
+            const dot = gx * crossX[i] + gy * crossY[i] + gz * crossZ[i];
+            a00 += gx * gx;
+            a01 += gx * gy;
+            a02 += gx * gz;
+            a11 += gy * gy;
+            a12 += gy * gz;
+            a22 += gz * gz;
+            b0 += gx * dot;
+            b1 += gy * dot;
+            b2 += gz * dot;
+          }
+          if (solveSymmetric3(a00, a01, a02, a11, a12, a22, b0, b1, b2, solved)) {
+            // Clamp into the cell: an out-of-cell QEF solution means the
+            // planes meet elsewhere — trust the topology, not the spike.
+            px = Math.min(Math.max(solved[0], 0), 1);
+            py = Math.min(Math.max(solved[1], 0), 1);
+            pz = Math.min(Math.max(solved[2], 0), 1);
+          }
+        }
+
+        cellVertex[x + y * nx + z * nx * ny] = positions.length / 3;
+        positions.push(
+          origin[0] + (x + px) * cellSize,
+          origin[1] + (y + py) * cellSize,
+          origin[2] + (z + pz) * cellSize,
+        );
+      }
+    }
+  }
+
+  // One quad (two triangles) per sign-changing interior grid edge, joining
+  // the four cells around that edge. Axis loops are unrolled per direction
+  // so the winding stays consistent with the sign of the near corner.
+  const indices = [];
+  const pushQuad = (a, b, c, d, flip) => {
+    if (a < 0 || b < 0 || c < 0 || d < 0) return;
+    if (flip) {
+      indices.push(a, b, c, c, b, d);
+    } else {
+      indices.push(a, c, b, b, c, d);
+    }
+  };
+
+  for (let z = 0; z < nz; z += 1) {
+    for (let y = 0; y < ny; y += 1) {
+      for (let x = 0; x < nx; x += 1) {
+        const corner = values[x + y * rowStride + z * sliceStride];
+        const inside = corner < 0;
+
+        // Edge along +X: shared by cells (x, y-1..y, z-1..z).
+        if (y > 0 && z > 0 && x < nx) {
+          const next = values[(x + 1) + y * rowStride + z * sliceStride];
+          if ((next < 0) !== inside) {
+            pushQuad(
+              cellVertex[x + (y - 1) * nx + (z - 1) * nx * ny],
+              cellVertex[x + y * nx + (z - 1) * nx * ny],
+              cellVertex[x + (y - 1) * nx + z * nx * ny],
+              cellVertex[x + y * nx + z * nx * ny],
+              inside,
+            );
+          }
+        }
+        // Edge along +Y: shared by cells (x-1..x, y, z-1..z).
+        if (x > 0 && z > 0 && y < ny) {
+          const next = values[x + (y + 1) * rowStride + z * sliceStride];
+          if ((next < 0) !== inside) {
+            pushQuad(
+              cellVertex[(x - 1) + y * nx + (z - 1) * nx * ny],
+              cellVertex[(x - 1) + y * nx + z * nx * ny],
+              cellVertex[x + y * nx + (z - 1) * nx * ny],
+              cellVertex[x + y * nx + z * nx * ny],
+              inside,
+            );
+          }
+        }
+        // Edge along +Z: shared by cells (x-1..x, y-1..y, z).
+        if (x > 0 && y > 0 && z < nz) {
+          const next = values[x + y * rowStride + (z + 1) * sliceStride];
+          if ((next < 0) !== inside) {
+            pushQuad(
+              cellVertex[(x - 1) + (y - 1) * nx + z * nx * ny],
+              cellVertex[x + (y - 1) * nx + z * nx * ny],
+              cellVertex[(x - 1) + y * nx + z * nx * ny],
+              cellVertex[x + y * nx + z * nx * ny],
+              inside,
+            );
+          }
+        }
+      }
+    }
+  }
+
+  return {
+    indices: new Uint32Array(indices),
+    positions: new Float32Array(positions),
+  };
+}
+
+/**
+ * Drops disconnected surface fragments smaller than `minRatio` of the
+ * largest component's triangle count, compacting the vertex list. Strong
+ * domain warp / high noise amplitudes routinely pinch off small floating
+ * islands; they read as artifacts, so meshDocument filters them by default.
+ */
+export function filterSmallIslands({ indices, positions }, minRatio = 0.02) {
+  const vertexCount = positions.length / 3;
+  const parent = new Int32Array(vertexCount);
+  for (let v = 0; v < vertexCount; v += 1) parent[v] = v;
+  const find = (v) => {
+    let root = v;
+    while (parent[root] !== root) root = parent[root];
+    while (parent[v] !== root) {
+      const next = parent[v];
+      parent[v] = root;
+      v = next;
+    }
+    return root;
+  };
+  for (let t = 0; t < indices.length; t += 3) {
+    const a = find(indices[t]);
+    const b = find(indices[t + 1]);
+    const c = find(indices[t + 2]);
+    if (b !== a) parent[b] = a;
+    if (c !== a) parent[c] = a;
+  }
+
+  const triangleCounts = new Map();
+  let largest = 0;
+  for (let t = 0; t < indices.length; t += 3) {
+    const root = find(indices[t]);
+    const count = (triangleCounts.get(root) ?? 0) + 1;
+    triangleCounts.set(root, count);
+    if (count > largest) largest = count;
+  }
+  const threshold = Math.max(largest * minRatio, 1);
+  if ([...triangleCounts.values()].every((count) => count >= threshold)) {
+    return { indices, positions };
+  }
+
+  // Compact kept triangles and remap their vertices.
+  const remap = new Int32Array(vertexCount).fill(-1);
+  const keptPositions = [];
+  const keptIndices = [];
+  for (let t = 0; t < indices.length; t += 3) {
+    if (triangleCounts.get(find(indices[t])) < threshold) continue;
+    for (let corner = 0; corner < 3; corner += 1) {
+      const source = indices[t + corner];
+      if (remap[source] === -1) {
+        remap[source] = keptPositions.length / 3;
+        keptPositions.push(positions[source * 3], positions[source * 3 + 1], positions[source * 3 + 2]);
+      }
+      keptIndices.push(remap[source]);
+    }
+  }
+  return {
+    indices: new Uint32Array(keptIndices),
+    positions: new Float32Array(keptPositions),
+  };
+}

package/src/rockgen/noise/cellularNoise3.js

@@ -0,0 +1,92 @@
+// Seeded 3D cellular (Voronoi/Worley) noise. F2 - F1 approaches zero along
+// cell borders, which rockgen carves into the field as facet creases — the
+// hard-planed, fractured look that sells stylized rock without any texture.
+
+import { hash3u } from './prng.js';
+
+/**
+ * Returns the two nearest feature-point distances { f1, f2 } for a point.
+ * `jitter` in [0, 1] moves feature points from cell centers (0) to fully
+ * random positions (1). Distances are Euclidean, in noise-space units.
+ */
+export function cellular3(seed, x, y, z, jitter = 1) {
+  const xi = Math.floor(x);
+  const yi = Math.floor(y);
+  const zi = Math.floor(z);
+
+  let f1 = Infinity;
+  let f2 = Infinity;
+  for (let dz = -1; dz <= 1; dz += 1) {
+    for (let dy = -1; dy <= 1; dy += 1) {
+      for (let dx = -1; dx <= 1; dx += 1) {
+        const cx = xi + dx;
+        const cy = yi + dy;
+        const cz = zi + dz;
+        const h = hash3u(seed, cx, cy, cz);
+        // Derive three decorrelated offsets from one hash (11/11/10 bits).
+        const ox = 0.5 + jitter * (((h & 0x7ff) / 0x7ff) - 0.5);
+        const oy = 0.5 + jitter * ((((h >>> 11) & 0x7ff) / 0x7ff) - 0.5);
+        const oz = 0.5 + jitter * ((((h >>> 22) & 0x3ff) / 0x3ff) - 0.5);
+        const px = cx + ox - x;
+        const py = cy + oy - y;
+        const pz = cz + oz - z;
+        const d = px * px + py * py + pz * pz;
+        if (d < f1) {
+          f2 = f1;
+          f1 = d;
+        } else if (d < f2) {
+          f2 = d;
+        }
+      }
+    }
+  }
+  return { f1: Math.sqrt(f1), f2: Math.sqrt(f2) };
+}
+
+/**
+ * 2D cellular noise in the XZ plane with a stable per-cell id — the basis
+ * of the columnar-jointing stage (each Voronoi cell = one rock column).
+ * Returns { f1, f2, id } where `id` is the nearest cell's hash in [0, 1).
+ */
+export function cellular2(seed, x, z, jitter = 1) {
+  const xi = Math.floor(x);
+  const zi = Math.floor(z);
+
+  let f1 = Infinity;
+  let f2 = Infinity;
+  let id = 0;
+  for (let dz = -1; dz <= 1; dz += 1) {
+    for (let dx = -1; dx <= 1; dx += 1) {
+      const cx = xi + dx;
+      const cz = zi + dz;
+      const h = hash3u(seed, cx, 0, cz);
+      const ox = 0.5 + jitter * (((h & 0xffff) / 0xffff) - 0.5);
+      const oz = 0.5 + jitter * ((((h >>> 16) & 0xffff) / 0xffff) - 0.5);
+      const px = cx + ox - x;
+      const pz = cz + oz - z;
+      const d = px * px + pz * pz;
+      if (d < f1) {
+        f2 = f1;
+        f1 = d;
+        id = h / 4294967296;
+      } else if (d < f2) {
+        f2 = d;
+      }
+    }
+  }
+  return { f1: Math.sqrt(f1), f2: Math.sqrt(f2), id };
+}
+
+/**
+ * Facet crease profile: 1 at cell borders (F2 ≈ F1), falling to 0 inside
+ * cells. `width` controls how far the crease reaches into the cell.
+ */
+export function cellularCrease3(seed, x, y, z, jitter = 1, width = 0.35) {
+  const { f1, f2 } = cellular3(seed, x, y, z, jitter);
+  const edge = (f2 - f1) / width;
+  if (edge >= 1) return 0;
+  if (edge <= 0) return 1;
+  // Smoothstep falloff keeps the crease shoulder soft at mesh resolution.
+  const t = 1 - edge;
+  return t * t * (3 - 2 * t);
+}

package/src/rockgen/noise/prng.js

@@ -0,0 +1,62 @@
+// Deterministic integer hashing for all rockgen randomness. Every
+// generation-time random value flows through these functions — no
+// Math.random, and nothing here calls transcendental Math functions whose
+// rounding may vary between JS engines — so the same document produces
+// bit-identical geometry on every run (verified by scripts/verify-rockgen.mjs).
+
+/** Chris Wellons' lowbias32: uint32 -> well-mixed uint32. */
+export function lowbias32(x) {
+  let h = x >>> 0;
+  h = Math.imul(h ^ (h >>> 16), 0x7feb352d) >>> 0;
+  h = Math.imul(h ^ (h >>> 15), 0x846ca68b) >>> 0;
+  return (h ^ (h >>> 16)) >>> 0;
+}
+
+/** Mixes two uint32 seeds into one (order-sensitive). */
+export function hashCombine(a, b) {
+  return lowbias32((a >>> 0) ^ (Math.imul(b >>> 0, 0x9e3779b9) >>> 0));
+}
+
+/** Hashes a 3D integer lattice coordinate under a seed -> uint32. */
+export function hash3u(seed, xi, yi, zi) {
+  let h = seed >>> 0;
+  h = (h ^ (Math.imul(xi | 0, 0x8da6b343) >>> 0)) >>> 0;
+  h = (h ^ (Math.imul(yi | 0, 0xd8163841) >>> 0)) >>> 0;
+  h = (h ^ (Math.imul(zi | 0, 0xcb1ab31f) >>> 0)) >>> 0;
+  return lowbias32(h);
+}
+
+/** Hashes a 3D integer lattice coordinate under a seed -> [0, 1). */
+export function hash3f(seed, xi, yi, zi) {
+  return hash3u(seed, xi, yi, zi) / 4294967296;
+}
+
+/**
+ * sfc32 PRNG for sequential draws (piece placement jitter, preset scatter).
+ * Returns a function yielding floats in [0, 1). Seed all four words for a
+ * healthy state; hashSeeds(seed) below does that from one uint32.
+ */
+export function sfc32(a, b, c, d) {
+  let sa = a >>> 0;
+  let sb = b >>> 0;
+  let sc = c >>> 0;
+  let sd = d >>> 0;
+  return function next() {
+    const t = (sa + sb + sd) >>> 0;
+    sd = (sd + 1) >>> 0;
+    sa = sb ^ (sb >>> 9);
+    sb = (sc + (sc << 3)) >>> 0;
+    sc = ((sc << 21) | (sc >>> 11)) >>> 0;
+    sc = (sc + t) >>> 0;
+    return t / 4294967296;
+  };
+}
+
+/** Builds an sfc32 generator from a single uint32 seed. */
+export function createRandom(seed) {
+  const s = seed >>> 0;
+  const random = sfc32(lowbias32(s), lowbias32(s + 1), lowbias32(s + 2), lowbias32(s + 3));
+  // sfc32 needs a few warm-up rounds before the state is well mixed.
+  for (let i = 0; i < 8; i += 1) random();
+  return random;
+}

package/src/rockgen/noise/simplexNoise3.js

@@ -0,0 +1,89 @@
+// Seeded 3D simplex noise (Gustavson's reference algorithm with the
+// permutation table replaced by the rockgen lattice hash, so it is seedable
+// without table setup). Used for domain warp, where value noise's lattice
+// alignment would leave visible grid bias in the warped shapes.
+
+import { hash3u } from './prng.js';
+
+const F3 = 1 / 3;
+const G3 = 1 / 6;
+
+// 12 cube-edge gradient directions.
+const GRAD3 = new Float32Array([
+  1, 1, 0, -1, 1, 0, 1, -1, 0, -1, -1, 0,
+  1, 0, 1, -1, 0, 1, 1, 0, -1, -1, 0, -1,
+  0, 1, 1, 0, -1, 1, 0, 1, -1, 0, -1, -1,
+]);
+
+function gradDot(seed, xi, yi, zi, x, y, z) {
+  const g = (hash3u(seed, xi, yi, zi) % 12) * 3;
+  return GRAD3[g] * x + GRAD3[g + 1] * y + GRAD3[g + 2] * z;
+}
+
+/** Seeded 3D simplex noise -> approximately [-1, 1]. */
+export function simplexNoise3(seed, x, y, z) {
+  const s = (x + y + z) * F3;
+  const i = Math.floor(x + s);
+  const j = Math.floor(y + s);
+  const k = Math.floor(z + s);
+  const t = (i + j + k) * G3;
+  const x0 = x - (i - t);
+  const y0 = y - (j - t);
+  const z0 = z - (k - t);
+
+  // Rank the simplex corner offsets by descending coordinate.
+  let i1;
+  let j1;
+  let k1;
+  let i2;
+  let j2;
+  let k2;
+  if (x0 >= y0) {
+    if (y0 >= z0) {
+      i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 1; k2 = 0;
+    } else if (x0 >= z0) {
+      i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 0; k2 = 1;
+    } else {
+      i1 = 0; j1 = 0; k1 = 1; i2 = 1; j2 = 0; k2 = 1;
+    }
+  } else if (y0 < z0) {
+    i1 = 0; j1 = 0; k1 = 1; i2 = 0; j2 = 1; k2 = 1;
+  } else if (x0 < z0) {
+    i1 = 0; j1 = 1; k1 = 0; i2 = 0; j2 = 1; k2 = 1;
+  } else {
+    i1 = 0; j1 = 1; k1 = 0; i2 = 1; j2 = 1; k2 = 0;
+  }
+
+  const x1 = x0 - i1 + G3;
+  const y1 = y0 - j1 + G3;
+  const z1 = z0 - k1 + G3;
+  const x2 = x0 - i2 + 2 * G3;
+  const y2 = y0 - j2 + 2 * G3;
+  const z2 = z0 - k2 + 2 * G3;
+  const x3 = x0 - 1 + 3 * G3;
+  const y3 = y0 - 1 + 3 * G3;
+  const z3 = z0 - 1 + 3 * G3;
+
+  let n = 0;
+  let f = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
+  if (f > 0) {
+    f *= f;
+    n += f * f * gradDot(seed, i, j, k, x0, y0, z0);
+  }
+  f = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
+  if (f > 0) {
+    f *= f;
+    n += f * f * gradDot(seed, i + i1, j + j1, k + k1, x1, y1, z1);
+  }
+  f = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
+  if (f > 0) {
+    f *= f;
+    n += f * f * gradDot(seed, i + i2, j + j2, k + k2, x2, y2, z2);
+  }
+  f = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
+  if (f > 0) {
+    f *= f;
+    n += f * f * gradDot(seed, i + 1, j + 1, k + 1, x3, y3, z3);
+  }
+  return 32 * n;
+}

package/src/rockgen/noise/valueNoise3.js

@@ -0,0 +1,87 @@
+// Seeded 3D value noise + FBM stacks. Value noise (hashed lattice values,
+// quintic interpolation) is the workhorse for rock displacement: cheaper than
+// simplex per sample and its slightly blocky character reads well on stylized
+// rock at the amplitudes rockgen uses.
+
+import { hash3f } from './prng.js';
+
+function fade(t) {
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+
+/** Seeded 3D value noise -> [-1, 1]. */
+export function valueNoise3(seed, x, y, z) {
+  const xi = Math.floor(x);
+  const yi = Math.floor(y);
+  const zi = Math.floor(z);
+  const tx = fade(x - xi);
+  const ty = fade(y - yi);
+  const tz = fade(z - zi);
+
+  const c000 = hash3f(seed, xi, yi, zi);
+  const c100 = hash3f(seed, xi + 1, yi, zi);
+  const c010 = hash3f(seed, xi, yi + 1, zi);
+  const c110 = hash3f(seed, xi + 1, yi + 1, zi);
+  const c001 = hash3f(seed, xi, yi, zi + 1);
+  const c101 = hash3f(seed, xi + 1, yi, zi + 1);
+  const c011 = hash3f(seed, xi, yi + 1, zi + 1);
+  const c111 = hash3f(seed, xi + 1, yi + 1, zi + 1);
+
+  const x00 = lerp(c000, c100, tx);
+  const x10 = lerp(c010, c110, tx);
+  const x01 = lerp(c001, c101, tx);
+  const x11 = lerp(c011, c111, tx);
+  const y0 = lerp(x00, x10, ty);
+  const y1 = lerp(x01, x11, ty);
+  return lerp(y0, y1, tz) * 2 - 1;
+}
+
+/**
+ * Fractional Brownian motion over valueNoise3, normalized by the octave
+ * amplitude sum so the result stays in roughly [-1, 1] for any octave count.
+ */
+export function fbm3(seed, x, y, z, octaves = 4, lacunarity = 2, gain = 0.5) {
+  let sum = 0;
+  let amplitude = 1;
+  let amplitudeSum = 0;
+  let fx = x;
+  let fy = y;
+  let fz = z;
+  for (let i = 0; i < octaves; i += 1) {
+    sum += amplitude * valueNoise3(seed + i, fx, fy, fz);
+    amplitudeSum += amplitude;
+    amplitude *= gain;
+    fx *= lacunarity;
+    fy *= lacunarity;
+    fz *= lacunarity;
+  }
+  return sum / amplitudeSum;
+}
+
+/**
+ * Ridged FBM: sharp creases where the underlying noise crosses zero.
+ * Returns [0, 1] with 1 at the ridge lines.
+ */
+export function ridgedFbm3(seed, x, y, z, octaves = 4, lacunarity = 2, gain = 0.5) {
+  let sum = 0;
+  let amplitude = 1;
+  let amplitudeSum = 0;
+  let fx = x;
+  let fy = y;
+  let fz = z;
+  for (let i = 0; i < octaves; i += 1) {
+    const n = valueNoise3(seed + i, fx, fy, fz);
+    const ridge = 1 - Math.abs(n);
+    sum += amplitude * ridge * ridge;
+    amplitudeSum += amplitude;
+    amplitude *= gain;
+    fx *= lacunarity;
+    fy *= lacunarity;
+    fz *= lacunarity;
+  }
+  return sum / amplitudeSum;
+}