@aethervtt/shard-terrain 0.1.0 → 0.2.1

package/dist/heightfield/source.js

@@ -0,0 +1,402 @@
+import { isPlainObject, pointer, ShardError } from "@aethervtt/shard-core";
+import { BLOCK, PAGE } from "./kernel.js";
+const MAX_MATERIAL_LAYERS = 32;
+const MIN_SIZE = 256;
+const MAX_SIZE = 65536;
+const MIN_SPACING = 0.25;
+const MAX_SPACING = 4;
+const MAX_ROOTS = 64;
+const MAX_DEPTH = 10;
+const LAYER_TINTS = [
+  [0.16, 0.3, 0.08],
+  [0.32, 0.3, 0.28],
+  [0.45, 0.4, 0.33],
+  [0.7, 0.62, 0.42],
+  [0.9, 0.92, 0.95],
+  [0.25, 0.17, 0.1],
+  [0.12, 0.2, 0.12],
+  [0.5, 0.25, 0.15]
+];
+const shape = (path, message, hint) => new ShardError("terrain/bad-source", message, { path, ...hint ? { hint } : {} });
+function num(v, path, what) {
+  if (typeof v !== "number" || !Number.isFinite(v)) throw shape(path, `${what} must be a number`);
+  return v;
+}
+function opt(v, fallback, path, what) {
+  return v === void 0 ? fallback : num(v, path, what);
+}
+function pair(v, path, what) {
+  if (!Array.isArray(v) || v.length !== 2)
+    throw shape(path, `${what} must be [a, b]`, "Two numbers, e.g. [0, 140].");
+  return [num(v[0], pointer(path, 0), what), num(v[1], pointer(path, 1), what)];
+}
+function ref(v, path, what) {
+  if (typeof v === "string" && v !== "") return { path: v };
+  if (isPlainObject(v) && typeof v.path === "string" && v.path !== "") {
+    return typeof v.guid === "string" ? { path: v.path, guid: v.guid } : { path: v.path };
+  }
+  throw shape(path, `${what} must be { "path": "\u2026" }`, 'e.g. { "path": "noise/hills.noise.json" }');
+}
+function blendOf(v, fallback, path) {
+  if (v === void 0) return fallback;
+  if (v === "add" || v === "max" || v === "min" || v === "replace") return v;
+  throw shape(path, `blend must be "add", "max", "min" or "replace"`);
+}
+function rectOf(o, path) {
+  const size = pair(o.size, pointer(path, "size"), "size");
+  if (!(size[0] > 0 && size[1] > 0)) throw shape(pointer(path, "size"), "size must be positive");
+  return {
+    at: pair(o.at, pointer(path, "at"), "at"),
+    size,
+    rotation: opt(o.rotation, 0, pointer(path, "rotation"), "rotation")
+  };
+}
+function known(o, keys, path) {
+  for (const k of Object.keys(o)) {
+    if (k === "$schema" || keys.includes(k)) continue;
+    throw shape(pointer(path, k), `Unknown field "${k}"`, `Fields here: ${keys.join(", ")}.`);
+  }
+}
+function parseTerrainSource(json) {
+  if (!isPlainObject(json)) throw shape("", "A terrain file is a JSON object");
+  known(
+    json,
+    [
+      "size",
+      "spacing",
+      "paintSpacing",
+      "heightRange",
+      "seed",
+      "splines",
+      "height",
+      "layers",
+      "textures",
+      "paint"
+    ],
+    ""
+  );
+  const size = pair(json.size, "/size", "size");
+  const spacing = num(json.spacing, "/spacing", "spacing");
+  if (!(spacing >= MIN_SPACING && spacing <= MAX_SPACING)) {
+    throw new ShardError(
+      "terrain/bad-spacing",
+      `spacing ${spacing} m is outside ${MIN_SPACING}\u2013${MAX_SPACING} m`,
+      {
+        path: "/spacing",
+        hint: "Sample spacing is the leaf vertex spacing: 1 m for most open worlds, 0.5 m for detailed ground."
+      }
+    );
+  }
+  const paintSpacing = opt(json.paintSpacing, spacing * 2, "/paintSpacing", "paintSpacing");
+  const step = paintSpacing / spacing;
+  if (!(step === 1 || step === 2 || step === 4)) {
+    throw new ShardError(
+      "terrain/bad-spacing",
+      `paintSpacing ${paintSpacing} m isn't 1, 2 or 4 times spacing (${spacing} m)`,
+      {
+        path: "/paintSpacing",
+        hint: "The default, twice spacing, quarters control memory and keeps 8 m roads crisp."
+      }
+    );
+  }
+  const heightRange = pair(json.heightRange, "/heightRange", "heightRange");
+  if (!(heightRange[1] > heightRange[0]))
+    throw shape("/heightRange", "heightRange must be [lowest, highest] with lowest < highest");
+  const seed = opt(json.seed, 0, "/seed", "seed") >>> 0;
+  const splines = {};
+  if (json.splines !== void 0) {
+    if (!isPlainObject(json.splines))
+      throw shape(
+        "/splines",
+        "splines is an object of named splines",
+        'e.g. { "north-road": { \u2026 } }'
+      );
+    for (const [name, value] of Object.entries(json.splines)) {
+      const path = pointer("/splines", name);
+      if (!isPlainObject(value)) throw shape(path, "A spline is an object");
+      known(value, ["points", "width", "falloff"], path);
+      if (!Array.isArray(value.points) || value.points.length < 2)
+        throw shape(pointer(path, "points"), "A spline needs at least two points");
+      const points = value.points.map((p, i) => {
+        const pp = pointer(pointer(path, "points"), i);
+        if (!Array.isArray(p) || p.length !== 3)
+          throw shape(pp, "A point is [x, y, z]", 'y may be "ground": the height below at x, z.');
+        const y = p[1] === "ground" ? "ground" : num(p[1], pointer(pp, 1), "y");
+        return [num(p[0], pointer(pp, 0), "x"), y, num(p[2], pointer(pp, 2), "z")];
+      });
+      const width = num(value.width, pointer(path, "width"), "width");
+      if (!(width > 0)) throw shape(pointer(path, "width"), "width must be positive");
+      const falloff = opt(value.falloff, 0, pointer(path, "falloff"), "falloff");
+      if (falloff < 0) throw shape(pointer(path, "falloff"), "falloff must be \u2265 0");
+      splines[name] = { points, width, falloff };
+    }
+  }
+  const splineName = (v, path) => {
+    if (typeof v !== "string" || v === "") throw shape(path, "A spline is named by a string");
+    if (!splines[v]) {
+      throw new ShardError("terrain/unknown-spline", `No spline named "${v}"`, {
+        path,
+        hint: `Define it under "splines". Known: ${Object.keys(splines).join(", ") || "(none)"}.`
+      });
+    }
+    return v;
+  };
+  if (!Array.isArray(json.height))
+    throw shape(
+      "/height",
+      "height is a list of layers",
+      'e.g. [{ "noise": { "path": "\u2026" }, "scale": 200 }]'
+    );
+  const height = json.height.map((value, i) => {
+    const path = pointer("/height", i);
+    if (!isPlainObject(value)) throw shape(path, "A height layer is an object");
+    const kinds = ["noise", "image", "spline"].filter((k) => value[k] !== void 0);
+    if (kinds.length !== 1) {
+      throw shape(
+        path,
+        'A height layer has exactly one of "noise", "image" or "spline"',
+        'Noise: { "noise": { "path": \u2026 }, "scale": 200 }. Image: { "image": { "path": \u2026 }, "at", "size", "range" }. Spline: { "spline": "road", "mode": "flatten" }.'
+      );
+    }
+    const falloff = opt(value.falloff, 0, pointer(path, "falloff"), "falloff");
+    if (falloff < 0) throw shape(pointer(path, "falloff"), "falloff must be \u2265 0");
+    if (value.noise !== void 0) {
+      known(value, ["noise", "scale", "offset", "blend", "falloff", "at", "size", "rotation"], path);
+      const region = value.at !== void 0 || value.size !== void 0 ? rectOf(value, path) : null;
+      return {
+        kind: "noise",
+        noise: ref(value.noise, pointer(path, "noise"), "noise"),
+        scale: opt(value.scale, 1, pointer(path, "scale"), "scale"),
+        offset: opt(value.offset, 0, pointer(path, "offset"), "offset"),
+        blend: blendOf(value.blend, "add", pointer(path, "blend")),
+        falloff,
+        region
+      };
+    }
+    if (value.image !== void 0) {
+      known(value, ["image", "at", "size", "rotation", "range", "blend", "falloff"], path);
+      return {
+        kind: "image",
+        image: ref(value.image, pointer(path, "image"), "image"),
+        range: pair(value.range, pointer(path, "range"), "range"),
+        blend: blendOf(value.blend, "replace", pointer(path, "blend")),
+        falloff,
+        ...rectOf(value, path)
+      };
+    }
+    known(value, ["spline", "mode", "offset", "falloff"], path);
+    const name = splineName(value.spline, pointer(path, "spline"));
+    const mode = value.mode ?? "flatten";
+    if (mode !== "flatten" && mode !== "raise" && mode !== "carve")
+      throw shape(pointer(path, "mode"), 'mode must be "flatten", "raise" or "carve"');
+    return {
+      kind: "spline",
+      spline: name,
+      mode,
+      offset: opt(value.offset, 0, pointer(path, "offset"), "offset"),
+      falloff: value.falloff === void 0 ? splines[name].falloff : falloff
+    };
+  });
+  const layerList = json.layers ?? [];
+  if (!Array.isArray(layerList)) throw shape("/layers", "layers is a list of material layers");
+  if (layerList.length > MAX_MATERIAL_LAYERS) {
+    throw new ShardError(
+      "terrain/too-many-layers",
+      `${layerList.length} material layers; a terrain has at most ${MAX_MATERIAL_LAYERS}`,
+      {
+        path: "/layers",
+        hint: "Merge layers that look alike, or share texture array layers between them."
+      }
+    );
+  }
+  const layers = layerList.map((value, i) => {
+    const path = pointer("/layers", i);
+    if (!isPlainObject(value)) throw shape(path, "A material layer is an object");
+    known(value, ["name", "albedo", "normal", "orm", "scale", "triplanar", "tint"], path);
+    if (typeof value.name !== "string" || value.name === "")
+      throw shape(pointer(path, "name"), "A material layer needs a name");
+    const albedo = opt(value.albedo, i, pointer(path, "albedo"), "albedo");
+    const scale = opt(value.scale, 4, pointer(path, "scale"), "scale");
+    if (!(scale > 0)) throw shape(pointer(path, "scale"), "scale must be positive");
+    let tint = LAYER_TINTS[i % LAYER_TINTS.length];
+    if (value.tint !== void 0) {
+      const tp = pointer(path, "tint");
+      if (!Array.isArray(value.tint) || value.tint.length !== 3)
+        throw shape(tp, "tint is [r, g, b], linear, 0\u20131");
+      tint = [
+        num(value.tint[0], tp, "tint"),
+        num(value.tint[1], tp, "tint"),
+        num(value.tint[2], tp, "tint")
+      ];
+    }
+    return {
+      name: value.name,
+      albedo,
+      normal: opt(value.normal, albedo, pointer(path, "normal"), "normal"),
+      orm: opt(value.orm, albedo, pointer(path, "orm"), "orm"),
+      scale,
+      triplanar: value.triplanar === true,
+      tint
+    };
+  });
+  const names = new Map(layers.map((l, i) => [l.name, i]));
+  if (names.size !== layers.length) throw shape("/layers", "Material layer names must be unique");
+  const textures = { albedo: null, normal: null, orm: null };
+  if (json.textures !== void 0) {
+    if (!isPlainObject(json.textures)) throw shape("/textures", "textures is an object");
+    known(json.textures, ["albedo", "normal", "orm"], "/textures");
+    for (const k of ["albedo", "normal", "orm"]) {
+      const v = json.textures[k];
+      if (v !== void 0) textures[k] = ref(v, pointer("/textures", k), k);
+    }
+  }
+  const paintList = json.paint ?? [];
+  if (!Array.isArray(paintList)) throw shape("/paint", "paint is a list of paint layers");
+  const paint = paintList.map((value, i) => {
+    const path = pointer("/paint", i);
+    if (!isPlainObject(value)) throw shape(path, "A paint layer is an object");
+    known(value, ["layer", "height", "slope", "noise", "mask", "spline", "blend"], path);
+    if (typeof value.layer !== "string" || !names.has(value.layer)) {
+      throw new ShardError(
+        "terrain/unknown-layer",
+        `No material layer named ${JSON.stringify(value.layer)}`,
+        {
+          path: pointer(path, "layer"),
+          hint: `Paint names one of "layers": ${[...names.keys()].join(", ") || "(none defined)"}.`
+        }
+      );
+    }
+    let noise = null;
+    if (value.noise !== void 0) {
+      const np = pointer(path, "noise");
+      if (!isPlainObject(value.noise)) throw shape(np, 'noise is { "path": \u2026, "above": 0.2 }');
+      noise = {
+        ref: ref(value.noise, np, "noise"),
+        above: opt(value.noise.above, 0, pointer(np, "above"), "above")
+      };
+    }
+    let mask = null;
+    if (value.mask !== void 0) {
+      const mp = pointer(path, "mask");
+      if (!isPlainObject(value.mask))
+        throw shape(mp, 'mask is { "path": \u2026, "at": [x, z], "size": [w, d] }');
+      mask = { ref: ref(value.mask, mp, "mask"), ...rectOf(value.mask, mp) };
+    }
+    const blend = opt(value.blend, 0, pointer(path, "blend"), "blend");
+    if (blend < 0) throw shape(pointer(path, "blend"), "blend must be \u2265 0");
+    return {
+      layer: value.layer,
+      height: value.height === void 0 ? null : pair(value.height, pointer(path, "height"), "height"),
+      slope: value.slope === void 0 ? null : pair(value.slope, pointer(path, "slope"), "slope"),
+      noise,
+      mask,
+      spline: value.spline === void 0 ? null : splineName(value.spline, pointer(path, "spline")),
+      blend
+    };
+  });
+  const source = {
+    size,
+    spacing,
+    paintSpacing,
+    heightRange,
+    seed,
+    splines,
+    height,
+    layers,
+    textures,
+    paint
+  };
+  terrainLayout(source);
+  return source;
+}
+function terrainLayout(source, block = BLOCK) {
+  const [sizeX, sizeZ] = source.size;
+  const spacing = source.spacing;
+  const leafSize = PAGE * spacing;
+  for (const [i, side] of [sizeX, sizeZ].entries()) {
+    if (!(side >= MIN_SIZE && side <= MAX_SIZE)) {
+      throw new ShardError(
+        "terrain/bad-size",
+        `A side of ${side} m is outside ${MIN_SIZE} m \u2013 ${MAX_SIZE / 1024} km`,
+        {
+          path: pointer("/size", i),
+          hint: "Terrains run from 256 m to 64 km a side. Bigger worlds are planets (0043)."
+        }
+      );
+    }
+  }
+  const leavesX = sizeX / leafSize;
+  const leavesZ = sizeZ / leafSize;
+  const hint = `Sides are whole numbers of roots: ${leafSize} m \xD7 2^k (each leaf is ${PAGE} samples of ${spacing} m), at most ${MAX_ROOTS} roots, e.g. ${leafSize * 32} m.`;
+  if (!Number.isInteger(leavesX) || !Number.isInteger(leavesZ)) {
+    throw new ShardError(
+      "terrain/bad-size",
+      `size ${sizeX} \xD7 ${sizeZ} m isn't a whole number of ${leafSize} m leaves`,
+      { path: "/size", hint }
+    );
+  }
+  let depth = 0;
+  while (depth <= MAX_DEPTH) {
+    const n = 2 ** depth;
+    if (leavesX % n !== 0 || leavesZ % n !== 0) {
+      depth = MAX_DEPTH + 1;
+      break;
+    }
+    if (leavesX / n * (leavesZ / n) <= MAX_ROOTS) break;
+    depth++;
+  }
+  if (depth > MAX_DEPTH) {
+    throw new ShardError(
+      "terrain/bad-size",
+      `size ${sizeX} \xD7 ${sizeZ} m isn't a whole number of roots (at most ${MAX_ROOTS} of them)`,
+      { path: "/size", hint }
+    );
+  }
+  const paintStep = source.paintSpacing / spacing;
+  return {
+    sizeX,
+    sizeZ,
+    spacing,
+    paintSpacing: source.paintSpacing,
+    paintStep,
+    cells: PAGE / paintStep,
+    depth,
+    rootsX: leavesX / 2 ** depth,
+    rootsZ: leavesZ / 2 ** depth,
+    rootSize: leafSize * 2 ** depth,
+    leafSize,
+    leavesX,
+    leavesZ,
+    block,
+    blocksX: Math.ceil(leavesX / block),
+    blocksZ: Math.ceil(leavesZ / block),
+    blockLevels: Math.log2(block)
+  };
+}
+function sourceDependencies(source) {
+  const noise = /* @__PURE__ */ new Set();
+  const heightmaps = /* @__PURE__ */ new Set();
+  for (const l of source.height) {
+    if (l.kind === "noise") noise.add(l.noise.path);
+    if (l.kind === "image") heightmaps.add(l.image.path);
+  }
+  for (const p of source.paint) {
+    if (p.noise) noise.add(p.noise.ref.path);
+    if (p.mask) heightmaps.add(p.mask.ref.path);
+  }
+  const textures = [source.textures.albedo, source.textures.normal, source.textures.orm].filter((t) => t !== null).map((t) => t.path);
+  return { noise: [...noise], heightmaps: [...heightmaps], textures };
+}
+export {
+  LAYER_TINTS,
+  MAX_DEPTH,
+  MAX_MATERIAL_LAYERS,
+  MAX_ROOTS,
+  MAX_SIZE,
+  MAX_SPACING,
+  MIN_SIZE,
+  MIN_SPACING,
+  parseTerrainSource,
+  sourceDependencies,
+  terrainLayout
+};

package/dist/heightfield/stack.d.ts

@@ -0,0 +1,29 @@
+import { type NoiseGraph } from '@aethervtt/shard-noise';
+import { type NoiseAccess, type Stack, type StackMap, type StackRect } from './kernel.js';
+import type { SourceRect, SourceSpline, TerrainSource } from './source.js';
+/** What compiling a source needs: its assets, loaded. */
+export interface StackAssets {
+    noise(path: string): NoiseGraph;
+    heightmap(path: string): StackMap;
+}
+/** This thread's noise kernel, as the bake kernel reads it (it must be loaded). */
+export declare function mainNoise(): NoiseAccess;
+export declare function rectOf(r: SourceRect): StackRect;
+/**
+ * A spline's centerline: uniform Catmull-Rom through its points (ends repeated), in pieces of at
+ * most `step` metres, heights interpolated the same way. `heights` holds each point's y (its
+ * "ground" resolved).
+ */
+export declare function tessellate(spline: SourceSpline, heights: ArrayLike<number>, step: number): number[];
+/**
+ * Metres between a spline's tessellated points: a metre (or the spacing, if coarser). A road bend
+ * of 100 m radius then strays from its chords by about a millimetre.
+ */
+export declare function splineStep(spacing: number): number;
+/**
+ * Compiles a validated source and its loaded assets into what the bake kernel reads (spec 0071):
+ * noise programs, heightmaps, rectangles, and splines tessellated with their "ground" points
+ * resolved against the layers below the layer using them. Structured-cloneable, so it goes to pool
+ * workers as is. Needs the noise kernel loaded (splines on "ground" sample the stack).
+ */
+export declare function compileStack(source: TerrainSource, assets: StackAssets, noise?: NoiseAccess): Stack;

package/dist/heightfield/stack.js

@@ -0,0 +1,158 @@
+import { ShardError } from "@aethervtt/shard-core";
+import { computeOrigins, evalProgram, noiseKernel } from "@aethervtt/shard-noise";
+import {
+  BLEND_ADD,
+  BLEND_MAX,
+  BLEND_MIN,
+  BLEND_REPLACE,
+  buildSpline,
+  evalHeightPoints,
+  LAYER_IMAGE,
+  LAYER_NOISE,
+  LAYER_SPLINE,
+  MODE_CARVE,
+  MODE_FLATTEN,
+  MODE_RAISE
+} from "./kernel.js";
+function mainNoise() {
+  return {
+    state: noiseKernel().state,
+    computeOrigins,
+    evalProgram
+  };
+}
+const BLENDS = { add: BLEND_ADD, max: BLEND_MAX, min: BLEND_MIN, replace: BLEND_REPLACE };
+const MODES = { flatten: MODE_FLATTEN, raise: MODE_RAISE, carve: MODE_CARVE };
+function rectOf(r) {
+  const a = r.rotation * Math.PI / 180;
+  return {
+    cx: r.at[0],
+    cz: r.at[1],
+    hw: r.size[0] / 2,
+    hd: r.size[1] / 2,
+    cos: Math.cos(a),
+    sin: Math.sin(a)
+  };
+}
+function tessellate(spline, heights, step) {
+  const p = spline.points;
+  const n = p.length;
+  const out = [];
+  const at = (i) => {
+    const k = Math.min(n - 1, Math.max(0, i));
+    return [p[k][0], heights[k], p[k][2]];
+  };
+  for (let s = 0; s + 1 < n; s++) {
+    const p0 = at(s - 1);
+    const p1 = at(s);
+    const p2 = at(s + 1);
+    const p3 = at(s + 2);
+    const len = Math.hypot(p2[0] - p1[0], p2[2] - p1[2]);
+    const pieces = Math.max(1, Math.ceil(len / step));
+    for (let k = s === 0 ? 0 : 1; k <= pieces; k++) {
+      const t = k / pieces;
+      const t2 = t * t;
+      const t3 = t2 * t;
+      for (let c = 0; c < 3; c++) {
+        out.push(
+          0.5 * (2 * p1[c] + (-p0[c] + p2[c]) * t + (2 * p0[c] - 5 * p1[c] + 4 * p2[c] - p3[c]) * t2 + (-p0[c] + 3 * p1[c] - 3 * p2[c] + p3[c]) * t3)
+        );
+      }
+    }
+  }
+  return out;
+}
+function splineStep(spacing) {
+  return Math.max(1, spacing);
+}
+function compileStack(source, assets, noise = mainNoise()) {
+  const height = [];
+  const stack = {
+    spacing: source.spacing,
+    seed: source.seed,
+    lo: source.heightRange[0],
+    hi: source.heightRange[1],
+    layerCount: Math.max(1, source.layers.length),
+    height,
+    paint: []
+  };
+  const step = splineStep(source.spacing);
+  const splineFor = (name, reach, ground) => {
+    const s = source.splines[name];
+    if (!s) {
+      throw new ShardError("terrain/unknown-spline", `No spline named "${name}"`, {
+        hint: 'Define it under "splines".'
+      });
+    }
+    const ys = new Float64Array(s.points.length);
+    const xz = [];
+    const groundAt = [];
+    s.points.forEach((p, i) => {
+      if (p[1] === "ground") {
+        xz.push(p[0], p[2]);
+        groundAt.push(i);
+      } else ys[i] = p[1];
+    });
+    if (groundAt.length > 0 && ground >= 0) {
+      const out = new Float64Array(groundAt.length);
+      evalHeightPoints(noise, stack, xz, groundAt.length, ground, out);
+      groundAt.forEach((i, k) => {
+        ys[i] = out[k];
+      });
+    }
+    return buildSpline(tessellate(s, ys, step), s.width, s.falloff, reach(s));
+  };
+  source.height.forEach((l, index) => {
+    if (l.kind === "noise") {
+      height.push({
+        kind: LAYER_NOISE,
+        program: assets.noise(l.noise.path).program,
+        scale: l.scale,
+        offset: l.offset,
+        blend: BLENDS[l.blend],
+        rect: l.region ? rectOf(l.region) : null,
+        falloff: l.falloff
+      });
+    } else if (l.kind === "image") {
+      height.push({
+        kind: LAYER_IMAGE,
+        map: assets.heightmap(l.image.path),
+        rect: rectOf(l),
+        lo: l.range[0],
+        hi: l.range[1],
+        blend: BLENDS[l.blend],
+        falloff: l.falloff
+      });
+    } else {
+      const spline = splineFor(l.spline, (s) => s.width / 2 + l.falloff, index);
+      height.push({
+        kind: LAYER_SPLINE,
+        spline,
+        mode: MODES[l.mode],
+        offset: l.offset,
+        falloff: l.falloff
+      });
+    }
+  });
+  const names = new Map(source.layers.map((l, i) => [l.name, i]));
+  for (const p of source.paint) {
+    stack.paint.push({
+      layer: names.get(p.layer) ?? 0,
+      height: p.height,
+      slope: p.slope,
+      noise: p.noise ? { program: assets.noise(p.noise.ref.path).program, above: p.noise.above } : null,
+      mask: p.mask ? { map: assets.heightmap(p.mask.ref.path), rect: rectOf(p.mask) } : null,
+      // Paint reads where the spline is, not its heights.
+      spline: p.spline ? splineFor(p.spline, (s) => s.width / 2 + p.blend, -1) : null,
+      blend: p.blend
+    });
+  }
+  return stack;
+}
+export {
+  compileStack,
+  mainNoise,
+  rectOf,
+  splineStep,
+  tessellate
+};

package/dist/heightfield/system.d.ts

@@ -0,0 +1,22 @@
+import { type World } from '@aethervtt/shard-core';
+import type { App } from '@aethervtt/shard-runtime';
+import { type AnchorQueries } from '../colliders.js';
+import { HeightfieldRuntime } from './runtime.js';
+/**
+ * Anchors on a heightfield this frame, in its frame: every TerrainAnchor (unless disabled),
+ * character, awake dynamic body and NavAgent within reach of the terrain's ground.
+ */
+export declare function gatherHeightfieldAnchors(_world: World, rt: HeightfieldRuntime, q: AnchorQueries): void;
+/** Per-frame hooks other modules add (colliders, navigation, scatter). */
+export declare const heightfieldUpdates: ((world: World, rt: HeightfieldRuntime, frame: number) => void)[];
+/**
+ * Keeps a runtime per Terrain (spec 0071): reads its settings, resolves and compiles its source,
+ * checks and bakes its packs, tracks its frame against the floating origin, and gathers anchors.
+ * Runs with or without a GPU; colliders and the render side build on it.
+ */
+export declare const updateHeightfields: import("@aethervtt/shard-core").SystemDef<{
+    terrains: import("@aethervtt/shard-core").Query;
+    anchors: AnchorQueries;
+}>;
+/** Registers the heightfield shaders, its render feature, and its uniform node (GPU up). */
+export declare function registerHeightfield(app: App): void;