@aethervtt/shard-terrain 0.1.0 → 0.2.0

package/dist/quadtree.js

@@ -1,12 +1,13 @@
-import { EDGE_LEFT, faceToDirection, neighborNode, nodeExtent } from "./cube.js";
+import { EDGE_LEFT } from "./cube.js";
 const NODE_READY = 1;
 const NODE_BOUNDS = 2;
 const NONE = -1;
-const POINTS = 9;
-class NodeTree {
+class QuadTree {
+  surface;
   capacity = 0;
   count = 0;
-  face = new Uint8Array(0);
+  /** The root each node is under (a cube face on a planet, a grid cell on a heightfield). */
+  root = new Uint8Array(0);
   depth = new Uint8Array(0);
   x = new Uint32Array(0);
   y = new Uint32Array(0);
@@ -14,13 +15,11 @@ class NodeTree {
   /** First of four children (in order (2x, 2y), (2x+1, 2y), (2x, 2y+1), (2x+1, 2y+1)), or −1. */
   child = new Int32Array(0);
   flags = new Uint8Array(0);
-  /** Bounding sphere in the planet frame (f64): center xyz, radius. */
+  /** Bounding sphere in the surface's frame (f64): center xyz, radius. */
   sphere = new Float64Array(0);
-  /** Height range (m above radius): exact once NODE_BOUNDS, else inherited or the planet's. */
+  /** Height range (m): exact once NODE_BOUNDS, else inherited or the surface's. */
   minH = new Float32Array(0);
   maxH = new Float32Array(0);
-  /** Horizon test directions (unit, 9 per node). */
-  dirs = new Float64Array(0);
   /** Stamps: last walk (frame), rendered and culled (walk stamp), forced split, last needed (frame). */
   visited = new Uint32Array(0);
   rendered = new Uint32Array(0);
@@ -36,7 +35,7 @@ class NodeTree {
    * Prefetched and out-of-view nodes are only `used`; a full pool evicts them first.
    */
   neededAt = new Uint32Array(0);
-  /** Render slot holding its mesh, or −1. */
+  /** Render slot holding its mesh (or its page), or −1. */
   slot = new Int32Array(0);
   /** Projected error (px) and distance when last requested: generation priority. */
   priority = new Float32Array(0);
@@ -45,21 +44,15 @@ class NodeTree {
   locks = new Int8Array(0);
   /** Quadrants drawn when rendered (15: all; fewer while a split waits for some children). */
   mask = new Uint8Array(0);
-  /** The planet version the node's mesh was made for: older is stale (it renders until replaced). */
+  /** The content version the node's mesh was made for: older is stale (it renders until replaced). */
   gen = new Uint32Array(0);
-  /**
-   * 1 / cos(half the widest angle between neighboring test points, diagonals included): lifting
-   * the points by it puts the surface between them inside their hull (horizon test, bulge).
-   */
-  lift = new Float64Array(0);
   /** Starts of freed child blocks. */
   blocks = [];
-  radius = 1;
-  shape = new Float64Array([1, 1, 1]);
   /** Height range for nodes whose heights aren't known yet. */
   lowest = 0;
   highest = 0;
-  constructor(capacity = 1024) {
+  constructor(surface, capacity = 1024) {
+    this.surface = surface;
     this.grow(capacity);
   }
   grow(capacity) {
@@ -68,7 +61,7 @@ class NodeTree {
       next.set(old);
       return next;
     };
-    this.face = re(this.face);
+    this.root = re(this.root);
     this.depth = re(this.depth);
     this.x = re(this.x);
     this.y = re(this.y);
@@ -78,7 +71,6 @@ class NodeTree {
     this.sphere = re(this.sphere, 4);
     this.minH = re(this.minH);
     this.maxH = re(this.maxH);
-    this.dirs = re(this.dirs, POINTS * 3);
     this.visited = re(this.visited);
     this.rendered = re(this.rendered);
     this.forced = re(this.forced);
@@ -93,27 +85,21 @@ class NodeTree {
     this.locks = re(this.locks, 4);
     this.mask = re(this.mask);
     this.gen = re(this.gen);
-    this.lift = re(this.lift);
+    this.surface.grow(capacity);
     this.capacity = capacity;
   }
-  /** Clears every node and makes the six roots (after a planet's shape or graphs change). */
-  reset(radius, shape, lowest, highest) {
-    this.count = 6;
+  /** Clears every node and makes the roots (after the surface's shape or contents change). */
+  resetRoots(lowest, highest) {
+    const roots = this.surface.roots;
+    if (roots > this.capacity) this.grow(Math.max(roots, this.capacity * 2));
+    this.count = roots;
     this.blocks.length = 0;
-    this.radius = radius;
-    this.shape[0] = shape[0];
-    this.shape[1] = shape[1];
-    this.shape[2] = shape[2];
     this.lowest = lowest;
     this.highest = highest;
-    for (let f = 0; f < 6; f++) this.init(f, f, 0, 0, 0, NONE);
+    for (let r = 0; r < roots; r++) this.init(r, r, 0, 0, 0, NONE);
   }
-  /** Root of a face (nodes 0–5). */
-  root(face) {
-    return face;
-  }
-  init(n, face, depth, x, y, parent) {
-    this.face[n] = face;
+  init(n, root, depth, x, y, parent) {
+    this.root[n] = root;
     this.depth[n] = depth;
     this.x[n] = x;
     this.y[n] = y;
@@ -134,28 +120,6 @@ class NodeTree {
     this.gen[n] = 0;
     this.mask[n] = 15;
     this.locks.fill(-1, n * 4, n * 4 + 4);
-    const ext = nodeExtent(depth);
-    const u0 = -1 + x * ext;
-    const v0 = -1 + y * ext;
-    let k = n * POINTS * 3;
-    for (let j = 0; j < 3; j++) {
-      for (let i = 0; i < 3; i++) {
-        faceToDirection(face, u0 + ext * i / 2, v0 + ext * j / 2, this.dirs, k);
-        k += 3;
-      }
-    }
-    let widest = 0;
-    const base = n * POINTS * 3;
-    for (let a = 0; a < POINTS; a++) {
-      for (let b = a + 1; b < POINTS; b++) {
-        if (Math.abs(a % 3 - b % 3) > 1 || Math.abs(Math.floor(a / 3) - Math.floor(b / 3)) > 1)
-          continue;
-        const d = this.dirs;
-        const cos = d[base + a * 3] * d[base + b * 3] + d[base + a * 3 + 1] * d[base + b * 3 + 1] + d[base + a * 3 + 2] * d[base + b * 3 + 2];
-        widest = Math.max(widest, Math.acos(Math.min(1, cos)));
-      }
-    }
-    this.lift[n] = 1 / Math.cos(widest / 2) + 1e-9;
     if (parent !== NONE && this.flags[parent] & NODE_BOUNDS) {
       this.minH[n] = this.minH[parent];
       this.maxH[n] = this.maxH[parent];
@@ -163,7 +127,8 @@ class NodeTree {
       this.minH[n] = this.lowest;
       this.maxH[n] = this.highest;
     }
-    this.updateSphere(n);
+    this.surface.initNode(this, n);
+    this.surface.updateSphere(this, n);
   }
   /** Children of `n`, made if needed. Returns the first (the others follow it). */
   split(n) {
@@ -176,11 +141,11 @@ class NodeTree {
       c = this.count;
       this.count += 4;
     }
-    const face = this.face[n];
+    const root = this.root[n];
     const depth = this.depth[n] + 1;
     const x = this.x[n] * 2;
     const y = this.y[n] * 2;
-    for (let i = 0; i < 4; i++) this.init(c + i, face, depth, x + (i & 1), y + (i >> 1), n);
+    for (let i = 0; i < 4; i++) this.init(c + i, root, depth, x + (i & 1), y + (i >> 1), n);
     this.child[n] = c;
     return c;
   }
@@ -208,96 +173,17 @@ class NodeTree {
     this.flags[n] |= NODE_BOUNDS;
     this.updateSphere(n);
   }
-  /** Bounding sphere of the node's 9 test points at its lowest and highest heights, plus bulge. */
+  /** Recomputes the node's bounding sphere from its height range. */
   updateSphere(n) {
-    const d = this.dirs;
-    const s = this.shape;
-    const lo = this.radius + this.minH[n];
-    const hi = this.radius + this.maxH[n];
-    let minX = Infinity;
-    let minY = Infinity;
-    let minZ = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    let maxZ = -Infinity;
-    for (let p = 0; p < POINTS; p++) {
-      const o2 = (n * POINTS + p) * 3;
-      for (let k = 0; k < 2; k++) {
-        const r = k === 0 ? lo : hi;
-        const x = d[o2] * s[0] * r;
-        const y = d[o2 + 1] * s[1] * r;
-        const z = d[o2 + 2] * s[2] * r;
-        if (x < minX) minX = x;
-        if (y < minY) minY = y;
-        if (z < minZ) minZ = z;
-        if (x > maxX) maxX = x;
-        if (y > maxY) maxY = y;
-        if (z > maxZ) maxZ = z;
-      }
-    }
-    const cx = (minX + maxX) / 2;
-    const cy = (minY + maxY) / 2;
-    const cz = (minZ + maxZ) / 2;
-    let r2 = 0;
-    for (let p = 0; p < POINTS; p++) {
-      const o2 = (n * POINTS + p) * 3;
-      for (let k = 0; k < 2; k++) {
-        const r = k === 0 ? lo : hi;
-        const x = d[o2] * s[0] * r - cx;
-        const y = d[o2 + 1] * s[1] * r - cy;
-        const z = d[o2 + 2] * s[2] * r - cz;
-        const q = x * x + y * y + z * z;
-        if (q > r2) r2 = q;
-      }
-    }
-    const bulge = hi * (this.lift[n] - 1) + 1e-3;
-    const o = n * 4;
-    this.sphere[o] = cx;
-    this.sphere[o + 1] = cy;
-    this.sphere[o + 2] = cz;
-    this.sphere[o + 3] = Math.sqrt(r2) + bulge;
+    this.surface.updateSphere(this, n);
   }
-  /**
-   * Axis-aligned bounds of the node relative to `center` (its chunk's reference point), from its
-   * test points at its lowest and highest heights plus the bulge between them.
-   */
+  /** Axis-aligned bounds of the node relative to `center` (its chunk's reference point). */
   bounds(n, center, out) {
-    const d = this.dirs;
-    const s = this.shape;
-    const lo = this.radius + this.minH[n];
-    const hi = this.radius + this.maxH[n];
-    let minX = Infinity;
-    let minY = Infinity;
-    let minZ = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    let maxZ = -Infinity;
-    for (let p = 0; p < POINTS; p++) {
-      const o = (n * POINTS + p) * 3;
-      for (let k = 0; k < 2; k++) {
-        const r = k === 0 ? lo : hi;
-        const x = d[o] * s[0] * r - center[0];
-        const y = d[o + 1] * s[1] * r - center[1];
-        const z = d[o + 2] * s[2] * r - center[2];
-        if (x < minX) minX = x;
-        if (y < minY) minY = y;
-        if (z < minZ) minZ = z;
-        if (x > maxX) maxX = x;
-        if (y > maxY) maxY = y;
-        if (z > maxZ) maxZ = z;
-      }
-    }
-    const bulge = hi * (this.lift[n] - 1) + 1e-3;
-    out[0] = minX - bulge;
-    out[1] = minY - bulge;
-    out[2] = minZ - bulge;
-    out[3] = maxX + bulge;
-    out[4] = maxY + bulge;
-    out[5] = maxZ + bulge;
+    this.surface.bounds(this, n, center, out);
   }
-  /** The node at (face, depth, x, y) if the tree has it, else the deepest existing ancestor. */
-  find(face, depth, x, y) {
-    let n = face;
+  /** The node at (root, depth, x, y) if the tree has it, else the deepest existing ancestor. */
+  find(root, depth, x, y) {
+    let n = root;
     for (let k = 0; k < depth; k++) {
       const c = this.child[n];
       if (c === NONE) return n;
@@ -308,7 +194,7 @@ class NodeTree {
   }
   /** Frees subtrees nobody has needed since frame `before`. */
   prune(before, release) {
-    for (let f = 0; f < 6; f++) this.pruneNode(f, before, release);
+    for (let r = 0; r < this.surface.roots; r++) this.pruneNode(r, before, release);
   }
   /** Returns whether `n` and its whole subtree are idle. */
   pruneNode(n, before, release) {
@@ -349,67 +235,17 @@ function selectNodes(tree, view, params, frame, out) {
     out.requestedCount = 0;
     out.waiting = 0;
     out.passes++;
-    for (let f = 0; f < 6; f++) {
-      tree.visited[f] = frame;
-      tree.used[f] = frame;
-      if (culledNode(tree, f, view, params)) tree.culled[f] = passStamp;
-      else visit(tree, f, view, params, frame, out);
+    for (let r = 0; r < tree.surface.roots; r++) {
+      tree.visited[r] = frame;
+      tree.used[r] = frame;
+      if (tree.surface.culled(tree, r, view, params)) tree.culled[r] = passStamp;
+      else visit(tree, r, view, params, frame, out);
     }
     if (!balance(tree, frame, out)) break;
   }
   out.stamp = passStamp;
   setLocks(tree, out);
 }
-function culledNode(tree, n, view, params) {
-  const s = tree.sphere;
-  const o = n * 4;
-  const cx = s[o];
-  const cy = s[o + 1];
-  const cz = s[o + 2];
-  const r = s[o + 3];
-  const f = view.frustum;
-  const d = tree.dirs;
-  const sh = tree.shape;
-  const lo = tree.radius + tree.minH[n];
-  const hi = (tree.radius + tree.maxH[n]) * tree.lift[n];
-  for (let p = 0; p < view.planes; p++) {
-    const q = p * 4;
-    const nx = f[q];
-    const ny = f[q + 1];
-    const nz = f[q + 2];
-    const dist = nx * cx + ny * cy + nz * cz + f[q + 3];
-    if (dist < -r) return true;
-    if (dist > r) continue;
-    let inside = false;
-    for (let k = 0; k < POINTS && !inside; k++) {
-      const i = (n * POINTS + k) * 3;
-      const dx = d[i] * sh[0];
-      const dy = d[i + 1] * sh[1];
-      const dz = d[i + 2] * sh[2];
-      const along = nx * dx + ny * dy + nz * dz;
-      if (along * lo + f[q + 3] >= 0 || along * hi + f[q + 3] >= 0) inside = true;
-    }
-    if (!inside) return true;
-  }
-  if (params.occluder <= 0) return false;
-  const inv = 1 / params.occluder;
-  const px = view.position[0] / sh[0] * inv;
-  const py = view.position[1] / sh[1] * inv;
-  const pz = view.position[2] / sh[2] * inv;
-  const vh2 = px * px + py * py + pz * pz - 1;
-  if (vh2 <= 0) return false;
-  const top = hi * inv;
-  for (let k = 0; k < POINTS; k++) {
-    const i = (n * POINTS + k) * 3;
-    const tx = d[i] * top - px;
-    const ty = d[i + 1] * top - py;
-    const tz = d[i + 2] * top - pz;
-    const dot = -(tx * px + ty * py + tz * pz);
-    if (dot <= vh2) return false;
-    if (dot * dot / (tx * tx + ty * ty + tz * tz) <= vh2) return false;
-  }
-  return true;
-}
 function nearView(tree, n, view) {
   const s = tree.sphere;
   const o = n * 4;
@@ -489,7 +325,7 @@ function visit(tree, n, view, params, frame, out) {
       tree.visited[k] = frame;
       tree.used[k] = frame;
       tree.neededAt[k] = frame;
-      if (culledNode(tree, k, view, params)) {
+      if (tree.surface.culled(tree, k, view, params)) {
         tree.culled[k] = passStamp;
         if (!(tree.flags[k] & NODE_READY)) {
           const d = nodeDistance(tree, k, view.position);
@@ -527,7 +363,7 @@ function visit(tree, n, view, params, frame, out) {
       if (tree.flags[k] & NODE_READY) continue;
       const d = nodeDistance(tree, k, view.position);
       const e = view.pixelsPerRadian * params.errors[depth + 1] / Math.max(d, 1e-3);
-      const scale = !culledNode(tree, k, view, params) ? 1 : nearView(tree, k, view) ? NEAR_VIEW : OUT_OF_VIEW;
+      const scale = !tree.surface.culled(tree, k, view, params) ? 1 : nearView(tree, k, view) ? NEAR_VIEW : OUT_OF_VIEW;
       request(tree, k, e * scale, d, frame, out);
     }
   }
@@ -544,7 +380,8 @@ function balance(tree, frame, out) {
     const depth = tree.depth[n];
     if (depth < 2) continue;
     for (let edge = 0; edge <= EDGE_LEFT; edge++) {
-      neighborNode(tree.face[n], depth, tree.x[n], tree.y[n], edge, neighbor);
+      if (!tree.surface.neighbor(tree.root[n], depth, tree.x[n], tree.y[n], edge, neighbor))
+        continue;
       const m = tree.find(neighbor[0], depth, neighbor[1], neighbor[2]);
       const k = renderedAbove(tree, m);
       if (k === NONE) continue;
@@ -566,8 +403,7 @@ function setLocks(tree, out) {
     const depth = tree.depth[n];
     for (let edge = 0; edge <= EDGE_LEFT; edge++) {
       let lock = -1;
-      if (depth > 0) {
-        neighborNode(tree.face[n], depth, tree.x[n], tree.y[n], edge, neighbor);
+      if (depth > 0 && tree.surface.neighbor(tree.root[n], depth, tree.x[n], tree.y[n], edge, neighbor)) {
         const m = tree.find(neighbor[0], depth, neighbor[1], neighbor[2]);
         const k = renderedAbove(tree, m);
         if (k !== NONE) lock = tree.depth[k] < depth ? 1 : -1;
@@ -580,7 +416,7 @@ function setLocks(tree, out) {
 export {
   NODE_BOUNDS,
   NODE_READY,
-  NodeTree,
+  QuadTree,
   createSelection,
   nearAnchor,
   selectNodes

package/dist/render.d.ts

@@ -5,9 +5,9 @@ import { MaterialAsset } from '@aethervtt/shard-render';
 import type { App } from '@aethervtt/shard-runtime';
 import { Texture } from '@aethervtt/shard-texture';
 import { type ColliderChunk } from './colliders.js';
+import type { NodeTree } from './cube-sphere.js';
 import { type KernelGraph } from './kernel.js';
 import type { PlanetRuntime } from './planet.js';
-import { type NodeTree } from './quadtree.js';
 /**
  * One render chunk: an entity drawing its range of an arena's vertex buffers, which a GPU job
  * writes (or a collider chunk's vertices are copied into).
@@ -138,6 +138,12 @@ export declare class PlanetRender {
     nextJobId(): number;
 }
 export declare function renderOf(world: World, rt: PlanetRuntime): PlanetRender;
+/** The camera that drives selection: the active one with the lowest `order`, then the lowest entity. */
+export declare function pickCamera(q: Query): {
+    entity: Entity;
+    table: number;
+    row: number;
+} | undefined;
 /**
  * Chooses each planet's chunks for the selecting camera (spec 0043): walks both quadtrees, gives
  * new nodes pool slots and queues their GPU jobs within the frame's budget (nodes at collider depth

package/dist/render.js

@@ -34,11 +34,12 @@ import {
   propagateSubtree,
   Transform
 } from "@aethervtt/shard-transform";
-import { chunkCenter, chunkIndices, chunkLayout } from "./chunk.js";
+import { chunkCenter } from "./chunk.js";
 import { collidersOf, skirtDepth } from "./colliders.js";
 import { Chunk, Planet, TerrainBudget } from "./components.js";
 import { keyString } from "./cube.js";
-import { Terrain } from "./heights.js";
+import { chunkIndices, chunkLayout } from "./grid-mesh.js";
+import { TerrainWorld } from "./heights.js";
 import {
   GEN_CLIMATE,
   GEN_HEIGHT,
@@ -49,6 +50,7 @@ import {
   POINT_FLOATS,
   registerKernel
 } from "./kernel.js";
+import { adaptLodBias } from "./lod.js";
 import { OceanMaterial, PlanetMaterial, TERRAIN_SHADERS, TEXTURE_PERIOD } from "./material.js";
 import { createChunkPoints, prepareChunkPoints, SNAP } from "./points.js";
 import { NODE_READY, selectNodes } from "./quadtree.js";
@@ -187,8 +189,7 @@ function selectionParams(rt, kind) {
 const chunkTriangles = (n) => 2 * (n - 1) * (n - 1);
 function adaptDetail(rt, triangles) {
   const drawn = rt.selection.renderedCount * chunkTriangles(rt.settings.resolution);
-  if (triangles > 0 && drawn > triangles) rt.lodBias = Math.min(16, rt.lodBias * 1.01);
-  else if (triangles <= 0 || drawn < triangles * 0.85) rt.lodBias = Math.max(1, rt.lodBias / 1.005);
+  rt.lodBias = adaptLodBias(rt.lodBias, drawn, triangles);
 }
 const selectChunks = defineSystem({
   name: "terrain/select",
@@ -196,7 +197,7 @@ const selectChunks = defineSystem({
   setup: (world) => ({ cameras: world.query({ with: [Camera3d, GlobalTransform] }) }),
   run: (s, world) => {
     if (!world.tryResource(GpuAssetsResource)) return;
-    const state = world.resource(Terrain);
+    const state = world.resource(TerrainWorld);
     const frame = state.frame;
     const budget = world.resource(TerrainBudget);
     let jobs = budget.chunksPerFrame;
@@ -1177,7 +1178,7 @@ function registerNode(app) {
       const frame = world.resource(Time).frame;
       if (frame === lastFrame) return;
       lastFrame = frame;
-      const state = world.tryResource(Terrain);
+      const state = world.tryResource(TerrainWorld);
       if (!state) return;
       for (const rt of state.planets.values()) {
         const pr = rt.parts.get("render");
@@ -1222,6 +1223,7 @@ export {
   PlanetRender,
   TerrainDebug,
   cleanupRender,
+  pickCamera,
   registerNode,
   renderOf,
   selectChunks,

package/dist/test-planet.d.ts

@@ -19,6 +19,8 @@ export interface PlanetOptions {
     errorPixels?: number;
     /** MSAA samples (default 1). */
     msaa?: 1 | 4;
+    /** A fixed render scale (0051): the view renders at it and is upscaled, as a window view is. */
+    renderScale?: number;
     /** Planet.vertexPixels (default: the component's). */
     vertexPixels?: number;
     minSpacing?: number;
@@ -57,3 +59,40 @@ export declare function sunOver(p: PlanetApp, direction: ArrayLike<number>, elev
  * sphere of the lowest possible surface (radius − heightScale) is terrain whatever the LOD.
  */
 export declare function holes(data: Uint8Array, W: number, H: number, FOV: number, eye: ArrayLike<number>, right: number[], up: number[], forward: number[], lowest: number): number;
+/**
+ * 0043's Earth descent (the bench's `terrain/descent-frame` and 0075's `planet-descent` scenario):
+ * the height graph of an Earth-sized planet with 3 km of relief.
+ */
+export declare const EARTH_HEIGHT: {
+    output: string;
+    nodes: {
+        continents: {
+            fbm: {
+                source: string;
+                octaves: number;
+                frequency: number;
+                seed: number;
+            };
+        };
+        ridges: {
+            ridged: {
+                source: string;
+                octaves: number;
+                frequency: number;
+                seed: number;
+            };
+        };
+        h: {
+            add: (string | {
+                multiply: (string | number)[];
+            })[];
+        };
+    };
+};
+/**
+ * The Earth descent's camera path: from 40 000 km to 2 m over `frames` frames, exponentially,
+ * looking at the ground ahead. `look(f)` places the camera at frame `f` (held at 2 m after).
+ */
+export declare function earthDescent(p: PlanetApp, radius: number, frames: number): {
+    look(frame: number): void;
+};

package/dist/test-planet.js

@@ -23,12 +23,18 @@ import {
   TransformPlugin
 } from "@aethervtt/shard-transform";
 import { Planet, TerrainBudget } from "./components.js";
-import { Terrain } from "./heights.js";
+import { heightAt, TerrainWorld } from "./heights.js";
 import { terrainPlugin } from "./plugin.js";
 async function planetApp(gpu, o) {
   const app = new App().addPlugin(TransformPlugin);
   if (gpu)
-    app.addPlugin(renderPlugin({ gpu, windowView: false }), forwardPlugin({ msaa: o.msaa ?? 1 }));
+    app.addPlugin(
+      renderPlugin({ gpu, windowView: false }),
+      forwardPlugin({
+        msaa: o.msaa ?? 1,
+        ...o.renderScale ? { renderScale: { mode: "fixed", scale: o.renderScale } } : {}
+      })
+    );
   if (o.physics) app.addPlugin(physics3dPlugin());
   app.addPlugin(terrainPlugin(), ...o.extra ?? []);
   await app.init();
@@ -66,7 +72,8 @@ async function planetApp(gpu, o) {
       label: "terrain-test",
       width: o.width ?? 96,
       height: o.heightPx ?? 64,
-      pixelRatio: o.pixelRatio ?? 1
+      pixelRatio: o.pixelRatio ?? 1,
+      renderScale: o.renderScale !== void 0
     });
     const targetRef = world.resource(RenderTargets).add(target, "terrain-test");
     camera = world.spawn(
@@ -103,7 +110,7 @@ async function planetApp(gpu, o) {
     camera,
     sun,
     view,
-    runtime: () => world.resource(Terrain).planets.get(planet)
+    runtime: () => world.resource(TerrainWorld).planets.get(planet)
   };
 }
 function placeCamera(p, eye, target) {
@@ -179,8 +186,37 @@ function holes(data, W, H, FOV, eye, right, up, forward, lowest) {
   }
   return count;
 }
+const EARTH_HEIGHT = {
+  output: "h",
+  nodes: {
+    continents: { fbm: { source: "simplex", octaves: 7, frequency: 3e-6, seed: 1 } },
+    ridges: { ridged: { source: "simplex", octaves: 8, frequency: 3e-4, seed: 2 } },
+    h: { add: ["continents", { multiply: ["ridges", 0.15] }] }
+  }
+};
+function earthDescent(p, radius, frames) {
+  const rt = p.runtime();
+  const n = [0.3, 0.9, 0.3].map((v, _, a) => v / Math.hypot(a[0], a[1], a[2]));
+  const east = [n[2], 0, -n[0]].map((v, _, a) => v / Math.hypot(a[0], a[1], a[2]));
+  const ground = Math.max(0, heightAt(rt, n[0], n[1], n[2]));
+  const ratio = (2 / 4e7) ** (1 / frames);
+  return {
+    look(frame) {
+      const altitude = 4e7 * ratio ** Math.min(frame, frames);
+      const eye = n.map((v) => v * (radius + ground + altitude));
+      const ahead = Math.min(altitude * 1.2, radius * 0.5);
+      placeCamera(
+        p,
+        eye,
+        n.map((v, k) => v * (radius + ground) + east[k] * ahead)
+      );
+    }
+  };
+}
 export {
+  EARTH_HEIGHT,
   capture,
+  earthDescent,
   holes,
   placeCamera,
   planetApp,

package/dist/testing.d.ts

@@ -40,3 +40,5 @@ export interface WalkResult {
  * all deterministic.
  */
 export declare function walkChecksum(characters?: number, seconds?: number): Promise<WalkResult>;
+export { capture as captureHeightfield, type HeightfieldApp, type HeightfieldOptions, type HeightfieldWalk, heightfieldApp, heightfieldWalk, holes as heightfieldHoles, lookAt as lookAtTerrain, settleHeightfield, sourceAsset, untilStreaming, VALLEY_HILLS, valleySource, } from './heightfield/testing.js';
+export { capture, EARTH_HEIGHT, earthDescent, holes, type PlanetApp, type PlanetOptions, placeCamera, planetApp, settleTerrain, sunOver, } from './test-planet.js';

package/dist/testing.js

@@ -19,7 +19,7 @@ import {
 } from "@aethervtt/shard-transform";
 import { collidersOf } from "./colliders.js";
 import { Planet } from "./components.js";
-import { planetHeightAt, Terrain } from "./heights.js";
+import { planetHeightAt, TerrainWorld } from "./heights.js";
 import { terrainPlugin } from "./plugin.js";
 const WALK_PLANET = {
   output: "h",
@@ -79,7 +79,7 @@ async function walkChecksum(characters = 4, seconds = 3) {
     f64.set(p, k * 3);
     w.despawn(c);
   }
-  const colliders = collidersOf(w.resource(Terrain).planets.get(planet)).chunks.size;
+  const colliders = collidersOf(w.resource(TerrainWorld).planets.get(planet)).chunks.size;
   new DataView(bytes.buffer).setUint32(characters * 24, colliders, true);
   let hash = 2166136261;
   for (let i = 0; i < bytes.length; i++) hash = Math.imul(hash ^ bytes[i], 16777619);
@@ -90,7 +90,47 @@ async function walkChecksum(characters = 4, seconds = 3) {
     ms: performance.now() - t0
   };
 }
+import {
+  capture,
+  heightfieldApp,
+  heightfieldWalk,
+  holes,
+  lookAt,
+  settleHeightfield,
+  sourceAsset,
+  untilStreaming,
+  VALLEY_HILLS,
+  valleySource
+} from "./heightfield/testing.js";
+import {
+  capture as capture2,
+  EARTH_HEIGHT,
+  earthDescent,
+  holes as holes2,
+  placeCamera,
+  planetApp,
+  settleTerrain,
+  sunOver
+} from "./test-planet.js";
 export {
+  EARTH_HEIGHT,
+  VALLEY_HILLS,
   WALK_PLANET,
+  capture2 as capture,
+  capture as captureHeightfield,
+  earthDescent,
+  heightfieldApp,
+  holes as heightfieldHoles,
+  heightfieldWalk,
+  holes2 as holes,
+  lookAt as lookAtTerrain,
+  placeCamera,
+  planetApp,
+  settleHeightfield,
+  settleTerrain,
+  sourceAsset,
+  sunOver,
+  untilStreaming,
+  valleySource,
   walkChecksum
 };