@aethervtt/shard-terrain 0.0.1 → 0.2.0

package/dist/index.js

@@ -13,14 +13,14 @@ import {
 import {
   assembleChunk,
   buildChunk,
-  checkResolution,
-  chunkCenter,
-  chunkLayout
+  chunkCenter
 } from "./chunk.js";
 import {
   COLLIDER_DELAY,
   ColliderSet,
+  chunkSpec,
   collidersOf,
+  sampleChunkAsync,
   skirtDepth
 } from "./colliders.js";
 import {
@@ -49,14 +49,87 @@ import {
   parseKey,
   unpackKey
 } from "./cube.js";
+import { CubeSphere, NodeTree } from "./cube-sphere.js";
 import { PlanetFrame } from "./frame.js";
+import {
+  checkResolution,
+  chunkIndices,
+  chunkLayout,
+  lockCode
+} from "./grid-mesh.js";
+import {
+  bakeTerrain,
+  blockKeys,
+  packHash,
+  readManifest,
+  terrainStats
+} from "./heightfield/bake.js";
+import {
+  tilesOf
+} from "./heightfield/colliders.js";
+import { Terrain, TerrainChunk } from "./heightfield/component.js";
+import {
+  decodeHeightPng,
+  HeightmapAssetType,
+  HeightmapImporter,
+  Heightmaps
+} from "./heightfield/heightmap.js";
+import {
+  BAKE_VERSION,
+  BLOCK,
+  deflate,
+  inflate,
+  LEAF_SIDE,
+  PAGE,
+  SIDE
+} from "./heightfield/kernel.js";
+import { TerrainSurfaceMaterial } from "./heightfield/material.js";
+import {
+  fsPackStore,
+  memoryPackStore,
+  PACK,
+  packOf,
+  readIndex,
+  writePack
+} from "./heightfield/pack.js";
+import {
+  bakeIsCurrent,
+  bakeProjectTerrains,
+  stackFor,
+  terrainCacheDir
+} from "./heightfield/project.js";
+import {
+  finestPage,
+  heightfieldRuntime,
+  heightfieldSample,
+  loadTerrainRegion,
+  pageHeight,
+  terrainHeightAt
+} from "./heightfield/queries.js";
+import { HeightfieldDebug } from "./heightfield/render.js";
+import { HeightfieldRuntime } from "./heightfield/runtime.js";
+import {
+  MAX_MATERIAL_LAYERS,
+  parseTerrainSource,
+  sourceDependencies,
+  terrainLayout
+} from "./heightfield/source.js";
+import {
+  TerrainSourceAsset,
+  TerrainSourceAssetType,
+  TerrainSourceImporter,
+  TerrainSources,
+  terrainJsonSchema
+} from "./heightfield/source-asset.js";
+import { compileStack, mainNoise } from "./heightfield/stack.js";
+import { heightfieldUpdates, updateHeightfields } from "./heightfield/system.js";
 import {
   heightAt,
   planetHeightAt,
   planetRuntime,
   planetSurfaceAt,
-  Terrain,
   TerrainState,
+  TerrainWorld,
   terrainSample
 } from "./heights.js";
 import {
@@ -70,16 +143,29 @@ import {
   sampleKernel,
   VERTEX_KERNEL
 } from "./kernel.js";
-import { measureErrors } from "./lod.js";
+import {
+  adaptLodBias,
+  capErrors,
+  MAX_LOD_BIAS,
+  MORPH_WGSL,
+  measureErrors,
+  morphFactor
+} from "./lod.js";
 import { OceanMaterial, PlanetMaterial, TERRAIN_SHADERS, TEXTURE_PERIOD } from "./material.js";
 import { resolvePlanet, terrainMap, terrainMethods } from "./methods.js";
 import { clearPlanetNav, planetAgents, planetNavMesh, updatePlanetNav } from "./nav.js";
-import { terrainBiomesOverlay, terrainCollidersOverlay, terrainLodOverlay } from "./overlays.js";
+import {
+  terrainBiomesOverlay,
+  terrainCollidersOverlay,
+  terrainLodOverlay,
+  terrainPagesOverlay
+} from "./overlays.js";
 import { COLLIDER_SPACING, PlanetRuntime } from "./planet.js";
 import { terrainPlugin, updatePlanets } from "./plugin.js";
 import {
   createChunkPoints,
   gridDirection,
+  NOISE_OFFSET,
   prepareChunkPoints,
   SNAP,
   sampleChunkPoints,
@@ -89,19 +175,22 @@ import {
   createSelection,
   NODE_BOUNDS,
   NODE_READY,
-  NodeTree,
+  QuadTree,
   selectNodes
 } from "./quadtree.js";
 import { PlanetRender, renderOf, selectChunks, TerrainDebug } from "./render.js";
 import { createView, omniView, perspectiveView } from "./view.js";
 export {
+  BAKE_VERSION,
   BLENDED_BIOMES,
+  BLOCK,
   Biome,
   BiomeSet,
   COLLIDER_DELAY,
   COLLIDER_SPACING,
   Chunk,
   ColliderSet,
+  CubeSphere,
   EDGE_BOTTOM,
   EDGE_LEFT,
   EDGE_RIGHT,
@@ -110,14 +199,26 @@ export {
   GEN_HEIGHT,
   GEN_OCEAN,
   GEN_ROOT,
+  HeightfieldDebug,
+  HeightfieldRuntime,
+  HeightmapAssetType,
+  HeightmapImporter,
+  Heightmaps,
+  LEAF_SIDE,
   MAX_BIOMES,
   MAX_DEPTH,
   MAX_LAYERS,
+  MAX_LOD_BIAS,
+  MAX_MATERIAL_LAYERS,
   MAX_RADIUS,
+  MORPH_WGSL,
   NODE_BOUNDS,
   NODE_READY,
+  NOISE_OFFSET,
   NodeTree,
   OceanMaterial,
+  PACK,
+  PAGE,
   PARAMS_BYTES,
   POINT_FLOATS,
   Planet,
@@ -126,45 +227,80 @@ export {
   PlanetNav,
   PlanetRender,
   PlanetRuntime,
+  QuadTree,
+  SIDE,
   SNAP,
   TERRAIN_SHADERS,
   TEXTURE_PERIOD,
   Terrain,
   TerrainAnchor,
   TerrainBudget,
+  TerrainChunk,
   TerrainDebug,
+  TerrainSourceAsset,
+  TerrainSourceAssetType,
+  TerrainSourceImporter,
+  TerrainSources,
   TerrainState,
+  TerrainSurfaceMaterial,
+  TerrainWorld,
   VERTEX_KERNEL,
+  adaptLodBias,
   assembleChunk,
+  bakeIsCurrent,
+  bakeProjectTerrains,
+  bakeTerrain,
   biomeTable,
   biomeWeights,
   biomeWindow,
+  blockKeys,
   buildChunk,
+  capErrors,
   checkResolution,
   chunkCenter,
+  chunkIndices,
   chunkLayout,
+  chunkSpec,
   clearPlanetNav,
   collidersOf,
+  compileStack,
   createChunkPoints,
   createSelection,
   createView,
+  decodeHeightPng,
+  deflate,
   directionToFace,
   dominantBiome,
   effectiveTemperature,
   faceToDirection,
+  finestPage,
+  fsPackStore,
   gridDirection,
   heightAt,
+  heightfieldRuntime,
+  heightfieldSample,
+  heightfieldUpdates,
+  inflate,
   kernelGraph,
   keyString,
+  loadTerrainRegion,
+  lockCode,
+  mainNoise,
   maxDepthFor,
   measureErrors,
+  memoryPackStore,
+  morphFactor,
   neighborNode,
   nodeAt,
   nodeExtent,
   nodeSpacing,
   omniView,
+  packHash,
   packKey,
+  packOf,
+  pageHeight,
   parseKey,
+  parseTerrainSource,
   perspectiveView,
   planetAgents,
   planetHeightAt,
@@ -172,22 +308,36 @@ export {
   planetRuntime,
   planetSurfaceAt,
   prepareChunkPoints,
+  readIndex,
+  readManifest,
   renderOf,
   resolvePlanet,
+  sampleChunkAsync,
   sampleChunkPoints,
   sampleKernel,
   samplePoint,
   selectChunks,
   selectNodes,
   skirtDepth,
+  sourceDependencies,
+  stackFor,
   terrainBiomesOverlay,
+  terrainCacheDir,
   terrainCollidersOverlay,
+  terrainHeightAt,
+  terrainJsonSchema,
+  terrainLayout,
   terrainLodOverlay,
   terrainMap,
   terrainMethods,
+  terrainPagesOverlay,
   terrainPlugin,
   terrainSample,
+  terrainStats,
+  tilesOf,
   unpackKey,
+  updateHeightfields,
   updatePlanetNav,
-  updatePlanets
+  updatePlanets,
+  writePack
 };

package/dist/lod.d.ts

@@ -20,3 +20,30 @@ export interface ErrorSpec {
  * (not per node) keeps neighbors at one depth in the same band, so their shared edges morph alike.
  */
 export declare function measureErrors(spec: ErrorSpec): Float32Array;
+/**
+ * Caps each depth's error at the spacing that projects to `vertexPixels` wherever it projects to
+ * `errorPixels` (spec 0043): a node then splits only while its children's vertices stay that far
+ * apart on screen. Rough terrain otherwise keeps splitting into sub-pixel triangles. Selection and
+ * morphing read the same capped table, so morph bands still end where splits happen. Errors never
+ * grow with depth, like the measured ones. `vertexPixels` 0 leaves the errors as they are.
+ */
+export declare function capErrors(raw: Float32Array, spacing: (depth: number) => number, errorPixels: number, vertexPixels: number, out?: Float32Array): Float32Array;
+/** Largest LOD bias the triangle budget may set (errorPixels × 16). */
+export declare const MAX_LOD_BIAS = 16;
+/**
+ * Steers a LOD bias (a multiplier on errorPixels for selection and morphing) toward a triangle
+ * budget: up 1% a frame while `drawn` is over `budget`, back down 0.5% a frame once under 85% of
+ * it, never below 1 (the surface's own settings) or above MAX_LOD_BIAS. Slow on purpose: the bias
+ * moves split distances, so morphs shift with it (2× in about a second). `budget` 0: no limit.
+ */
+export declare function adaptLodBias(bias: number, drawn: number, budget: number): number;
+/**
+ * Where a vertex is in its morph toward the parent level (0 its own, 1 the parent's), by its
+ * distance from the camera: across [0.5, 0.95] of `split`, the distance at which the parent would
+ * split (`errors[depth] × pixelsPerRadian / (errorPixels × lodBias)`). Merging takes a 10% margin
+ * past that, so a chunk is fully morphed before it goes. The vertex shaders inline the same
+ * formula (`MORPH_WGSL`); CPU replays of the vertex stage call this.
+ */
+export declare function morphFactor(distance: number, split: number): number;
+/** `morphFactor` in WGSL, for a `d` (distance) and `split` in scope. */
+export declare const MORPH_WGSL = "clamp((d - 0.5 * split) / (0.45 * split), 0.0, 1.0)";

package/dist/lod.js

@@ -39,6 +39,28 @@ function measureErrors(spec) {
   for (let d = spec.maxDepth - 1; d >= 0; d--) out[d] = Math.max(out[d], out[d + 1]);
   return out;
 }
+function capErrors(raw, spacing, errorPixels, vertexPixels, out = new Float32Array(raw.length)) {
+  const k = vertexPixels > 0 ? errorPixels / vertexPixels : Number.POSITIVE_INFINITY;
+  for (let d = 0; d < raw.length; d++) out[d] = Math.min(raw[d], k * spacing(d));
+  for (let d = raw.length - 2; d >= 0; d--) out[d] = Math.max(out[d], out[d + 1]);
+  return out;
+}
+const MAX_LOD_BIAS = 16;
+function adaptLodBias(bias, drawn, budget) {
+  if (budget > 0 && drawn > budget) return Math.min(MAX_LOD_BIAS, bias * 1.01);
+  if (budget <= 0 || drawn < budget * 0.85) return Math.max(1, bias / 1.005);
+  return bias;
+}
+function morphFactor(distance, split) {
+  if (!(split > 0)) return 0;
+  return Math.min(1, Math.max(0, (distance - 0.5 * split) / (0.45 * split)));
+}
+const MORPH_WGSL = "clamp((d - 0.5 * split) / (0.45 * split), 0.0, 1.0)";
 export {
-  measureErrors
+  MAX_LOD_BIAS,
+  MORPH_WGSL,
+  adaptLodBias,
+  capErrors,
+  measureErrors,
+  morphFactor
 };

package/dist/material.js

@@ -1,5 +1,6 @@
 import { t } from "@aethervtt/shard-core";
 import { defineMaterial } from "@aethervtt/shard-render";
+import { MORPH_WGSL } from "./lod.js";
 const TEXTURE_PERIOD = 1024;
 const frame = {
   center: t.vec4({
@@ -109,7 +110,7 @@ fn terrain_morph(position: vec3f) -> f32 {
   let split = lock.y * ${u}.camera.w;
   if (split > 0.0) {
     let d = distance(vertex_world(position), ${u}.camera.xyz);
-    t = clamp((d - 0.5 * split) / (0.45 * split), 0.0, 1.0);
+    t = ${MORPH_WGSL};
   }
   let code = terrain_lock(grid.x, grid.y);
   if (code >= 0 && code < 4) {

package/dist/methods.js

@@ -6,7 +6,13 @@ import {
 } from "@aethervtt/shard-core";
 import { encodePng, toBase64 } from "@aethervtt/shard-protocol";
 import { collidersOf } from "./colliders.js";
-import { Terrain, terrainSample } from "./heights.js";
+import {
+  describeHeightfield,
+  heightfieldMap,
+  resolveHeightfield,
+  sampleHeightfield
+} from "./heightfield/methods.js";
+import { TerrainWorld, terrainSample } from "./heights.js";
 function scenePath(world, entity) {
   const member = findComponent("scene/SceneMember");
   if (!member || !world.isAlive(entity)) return null;
@@ -14,7 +20,7 @@ function scenePath(world, entity) {
   return v?.path || null;
 }
 function resolvePlanet(world, ref) {
-  const planets = world.tryResource(Terrain)?.planets;
+  const planets = world.tryResource(TerrainWorld)?.planets;
   if (!planets || planets.size === 0) {
     throw new ShardError("terrain/no-planet", "There is no terrain/Planet in the world", {
       hint: "Add terrain/Planet (with a Grid) to an entity, and the terrain plugin to the app."
@@ -181,28 +187,65 @@ function terrainMap(rt, width, mode) {
 const planetField = t.json({
   description: "The planet: entity id or scene path (default: the only planet)."
 });
+const named = (ref) => ref !== void 0 && ref !== null && ref !== "";
+function wantsHeightfield(world, p) {
+  if (named(p.terrain)) return true;
+  if (named(p.planet)) return false;
+  const state = world.tryResource(TerrainWorld);
+  return (state?.planets.size ?? 0) === 0 && (state?.heightfields.size ?? 0) > 0;
+}
+const terrainField = t.json({
+  description: "A heightfield terrain (0071): entity id or scene path (default: the only one)."
+});
 const terrainMethods = [
   {
     name: "terrain.describe",
-    description: "Planet terrain as data: per planet, the chunks selected by depth (and partial ones waiting for children), requests and chunks in flight, pool usage, generation counts, collider chunks and anchors, the vertex spacing at the finest and collider depths, and the height, biome, and slope under the camera. Problems (a bad radius, a climate graph without temperature/moisture) and what it waits for are here too.",
-    params: defineSchema("terrain/DescribeParams", { planet: planetField }),
+    description: "Terrain as data. Per planet: the chunks selected by depth (and partial ones waiting for children), requests and chunks in flight, pool usage, generation counts, collider chunks and anchors, the vertex spacing at the finest and collider depths, and the height, biome, and slope under the camera. Per heightfield terrain (0071): roots and depths, the bake (blocks current, stale, baking; the last bake\u2019s rebuilt blocks, time and heights clipped by heightRange), chunks selected by depth, pages resident, cached and read, the GPU pool, and collider tiles with their anchors. Problems and what each waits for are here too.",
+    params: defineSchema("terrain/DescribeParams", {
+      planet: planetField,
+      terrain: terrainField
+    }),
     handler: ({ world }, p) => {
-      const planets = world.tryResource(Terrain)?.planets;
-      if (!planets) return { planets: [] };
+      const state = world.tryResource(TerrainWorld);
+      if (!state) return { planets: [], terrains: [] };
+      if (p.terrain !== void 0 && p.terrain !== null && p.terrain !== "")
+        return {
+          planets: [],
+          terrains: [describeHeightfield(world, resolveHeightfield(world, p.terrain))]
+        };
       if (p.planet !== void 0 && p.planet !== null && p.planet !== "")
-        return { planets: [describePlanet(world, resolvePlanet(world, p.planet))] };
-      return { planets: [...planets.values()].map((rt) => describePlanet(world, rt)) };
+        return { planets: [describePlanet(world, resolvePlanet(world, p.planet))], terrains: [] };
+      return {
+        planets: [...state.planets.values()].map((rt) => describePlanet(world, rt)),
+        terrains: [...state.heightfields.values()].map((rt) => describeHeightfield(world, rt))
+      };
     }
   },
   {
     name: "terrain.sample",
-    description: "The surface at points on a planet, from the CPU noise the colliders use (headless-safe): height (m above radius), underwater and water depth, slope (degrees), climate, and biome weights with the dominant biome. Points are directions from the planet center in its frame ([x, y, z], any length) or [lat, lon] in degrees (lat from the +Y axis\u2019s equator, lon around it).",
+    description: "The ground at points. On a planet, from the CPU noise the colliders use (headless-safe): height (m above radius), underwater and water depth, slope (degrees), climate, and biome weights with the dominant biome; points are directions from the center in its frame ([x, y, z], any length) or [lat, lon] in degrees. On a heightfield terrain (0071, `terrain` or `points`): height, normal, slope, and the two heaviest paint layers with the second\u2019s share, from its leaf pages (loaded first, so exactly the colliders\u2019 ground); points are [x, z] metres from its corner.",
     params: defineSchema("terrain/SampleParams", {
       planet: planetField,
-      directions: t.json({ description: "Directions: [[x, y, z], \u2026] (at most 4096)." }),
-      latlon: t.json({ description: "Latitudes and longitudes in degrees: [[lat, lon], \u2026]." })
+      terrain: terrainField,
+      directions: t.json({ description: "Planets: directions [[x, y, z], \u2026] (at most 4096)." }),
+      latlon: t.json({
+        description: "Planets: latitudes and longitudes in degrees: [[lat, lon], \u2026]."
+      }),
+      points: t.json({
+        description: "Heightfields: [[x, z], \u2026] metres from the corner (at most 4096)."
+      })
     }),
-    handler: ({ world }, p) => {
+    handler: async ({ world }, p) => {
+      if (wantsHeightfield(world, p) || Array.isArray(p.points) && !named(p.planet)) {
+        const points = Array.isArray(p.points) ? p.points : [];
+        if (points.length === 0 || points.length > 4096) {
+          throw new ShardError("terrain/bad-points", "Pass 1 to 4096 points as [[x, z], \u2026]", {
+            hint: 'Points are metres from the terrain\u2019s corner, e.g. { "points": [[120, 300]] }.'
+          });
+        }
+        const rt2 = resolveHeightfield(world, p.terrain);
+        return { samples: await sampleHeightfield(world, rt2, points) };
+      }
       const rt = resolvePlanet(world, p.planet);
       usable(rt);
       const dirs = [];
@@ -238,15 +281,20 @@ const terrainMethods = [
   },
   {
     name: "terrain.map",
-    description: 'An equirectangular PNG of a planet (width \xD7 width/2; latitude +90 at the top, longitude \u2212180 to 180 left to right): mode "biomes" colors land by its dominant biome\u2019s tint (shaded by slope), mode "height" dark lowlands to white peaks; water is blue, darker when deeper. One image answers "are there continents, oceans, and polar caps".',
+    description: 'A PNG of terrain. A planet: equirectangular (width \xD7 width/2; latitude +90 at the top, longitude \u2212180 to 180 left to right), "biomes" colors land by its dominant biome\u2019s tint (shaded by slope), "height" dark lowlands to white peaks; water is blue, darker when deeper. A heightfield terrain (0071): top-down (+X right, +Z down), "height", "slope" (flat black to 60\xB0 white), "layers" (the heaviest paint layer\u2019s tint), or "bake" (blocks green when current, amber when stale, cyan where the last bake rebuilt them).',
     params: defineSchema("terrain/MapParams", {
       planet: planetField,
+      terrain: terrainField,
       size: t.u32({ default: 256, min: 16, max: 1024, description: "Width in pixels." }),
-      mode: t.enum(["biomes", "height"])
+      mode: t.enum(["biomes", "height", "layers", "slope", "bake"])
     }),
     handler: async ({ world }, p) => {
-      const rt = resolvePlanet(world, p.planet);
-      const image = terrainMap(rt, p.size, p.mode);
+      const mode = p.mode;
+      const image = wantsHeightfield(world, p) || (mode === "layers" || mode === "slope" || mode === "bake") && !named(p.planet) ? heightfieldMap(resolveHeightfield(world, p.terrain), p.size, mode) : terrainMap(
+        resolvePlanet(world, p.planet),
+        p.size,
+        mode === "height" ? "height" : "biomes"
+      );
       const png = await encodePng(image.data, image.width, image.height);
       return { width: image.width, height: image.height, data: toBase64(png) };
     }

package/dist/overlays.d.ts

@@ -1,5 +1,7 @@
 /** Chunk shading by depth: what `terrain-lod` turns on (the material's debug mode 3). */
 export declare const terrainLodOverlay: import("@aethervtt/shard-render").OverlayDef;
+/** Heightfield chunks shaded by the page each draws, with page streaming in the colliders' colors. */
+export declare const terrainPagesOverlay: import("@aethervtt/shard-render").OverlayDef;
 /** Chunk shading by dominant biome: what `terrain-biomes` turns on (debug mode 1). */
 export declare const terrainBiomesOverlay: import("@aethervtt/shard-render").OverlayDef;
 /** Collider chunks (their borders, on the surface) and the anchors that keep them. */

package/dist/overlays.js

@@ -1,10 +1,17 @@
 import { defineOverlay } from "@aethervtt/shard-render";
-import { chunkLayout } from "./chunk.js";
 import { collidersOf } from "./colliders.js";
-import { Terrain } from "./heights.js";
+import { chunkLayout } from "./grid-mesh.js";
+import { tilesOf } from "./heightfield/colliders.js";
+import { TerrainWorld } from "./heights.js";
 const terrainLodOverlay = defineOverlay({
   name: "terrain-lod",
-  description: "Planet terrain shaded by LOD depth (a hue per level, darker toward edges locked to a coarser neighbor), to see where chunks split.",
+  description: "Terrain (planets and heightfields) shaded by LOD depth (a hue per level), to see where chunks split.",
+  draw: () => {
+  }
+});
+const terrainPagesOverlay = defineOverlay({
+  name: "terrain-pages",
+  description: "Heightfield terrain (0071) shaded by the GPU pool page each chunk draws (a hue per slot): pages arriving show as new hues, coarse resident pages as the large patches. terrain.describe lists resident pages and reads in flight.",
   draw: () => {
   }
 });
@@ -21,9 +28,9 @@ const a = new Float64Array(3);
 const b = new Float64Array(3);
 const terrainCollidersOverlay = defineOverlay({
   name: "terrain-colliders",
-  description: "Planet collider chunks: each one\u2019s border on the surface (green; yellow while cached but not in use), and a circle per anchor showing the radius it keeps colliders within.",
+  description: "Collider chunks (planets) and tiles (heightfields): each one\u2019s border on the ground (green; yellow while cached but not in use), and a circle per anchor showing the radius it keeps colliders within.",
   draw: (world, g) => {
-    const state = world.tryResource(Terrain);
+    const state = world.tryResource(TerrainWorld);
     if (!state) return;
     for (const rt of state.planets.values()) {
       if (!rt.ready) continue;
@@ -58,10 +65,45 @@ const terrainCollidersOverlay = defineOverlay({
         g.sphere(a, rt.anchorRadius[i], ANCHOR);
       }
     }
+    for (const rt of state.heightfields.values()) {
+      if (!rt.ready || !rt.layout) continue;
+      const size = rt.layout.leafSize;
+      const n = 65;
+      for (const tile of tilesOf(rt).tiles.values()) {
+        const color = tile.entity >= 0 ? COLLIDER : PENDING;
+        const x0 = tile.x * size;
+        const z0 = tile.z * size;
+        const point = (i, j, out) => rt.frame.pointToOrigin(
+          x0 + i / (n - 1) * size,
+          tile.heights[j * n + i] + 0.05,
+          z0 + j / (n - 1) * size,
+          out
+        );
+        for (let k = 0; k < n - 1; k += 4) {
+          const k1 = Math.min(n - 1, k + 4);
+          for (const [i0, j0, i1, j1] of [
+            [k, 0, k1, 0],
+            [k, n - 1, k1, n - 1],
+            [0, k, 0, k1],
+            [n - 1, k, n - 1, k1]
+          ]) {
+            point(i0, j0, a);
+            point(i1, j1, b);
+            g.line(a, b, color);
+          }
+        }
+      }
+      for (let i = 0; i < rt.anchors; i++) {
+        const o = i * 3;
+        rt.frame.pointToOrigin(rt.anchorPos[o], rt.anchorPos[o + 1], rt.anchorPos[o + 2], a);
+        g.sphere(a, rt.anchorRadius[i], ANCHOR);
+      }
+    }
   }
 });
 export {
   terrainBiomesOverlay,
   terrainCollidersOverlay,
-  terrainLodOverlay
+  terrainLodOverlay,
+  terrainPagesOverlay
 };

package/dist/planet.d.ts

@@ -1,8 +1,8 @@
 import { type AssetRef, type Entity, ShardError, type World } from '@aethervtt/shard-core';
 import { type NoiseGraph } from '@aethervtt/shard-noise';
 import { type BiomeSetValue, type BiomeTable, type BiomeValue } from './biomes.js';
+import { NodeTree } from './cube-sphere.js';
 import { PlanetFrame } from './frame.js';
-import { NodeTree } from './quadtree.js';
 /** Collider chunks are the first depth whose vertices are at most this far apart (m). */
 export declare const COLLIDER_SPACING = 1;
 /** A planet's settings as numbers, read from its component when it changes. */
@@ -94,12 +94,7 @@ export declare class PlanetRuntime {
     private heightVersion;
     private climateVersion;
     private report;
-    /**
-     * Caps each depth's error at the spacing that projects to `vertexPixels` wherever it projects to
-     * `errorPixels`: a node then splits only while its children's vertices stay that far apart on
-     * screen. Rough terrain otherwise keeps splitting into sub-pixel triangles. Selection and
-     * morphing read the same capped table, so morph bands still end where splits happen.
-     */
+    /** Caps the measured errors by vertex spacing (`vertexPixels`, see `capErrors`). */
     private capErrors;
     /** Vertex spacing at a depth (m). */
     spacing(depth: number): number;

package/dist/planet.js

@@ -7,12 +7,13 @@ import {
   BiomeSet,
   biomeTable
 } from "./biomes.js";
-import { checkResolution } from "./chunk.js";
 import { Planet } from "./components.js";
 import { MAX_RADIUS, maxDepthFor, nodeSpacing } from "./cube.js";
+import { NodeTree } from "./cube-sphere.js";
 import { PlanetFrame } from "./frame.js";
-import { measureErrors } from "./lod.js";
-import { createSelection, NODE_BOUNDS, NodeTree } from "./quadtree.js";
+import { checkResolution } from "./grid-mesh.js";
+import { capErrors, measureErrors } from "./lod.js";
+import { createSelection, NODE_BOUNDS } from "./quadtree.js";
 const COLLIDER_SPACING = 1;
 class PlanetRuntime {
   entity;
@@ -221,26 +222,15 @@ class PlanetRuntime {
     this.problem = err;
     world.tryResource(LogResource)?.error(err);
   }
-  /**
-   * Caps each depth's error at the spacing that projects to `vertexPixels` wherever it projects to
-   * `errorPixels`: a node then splits only while its children's vertices stay that far apart on
-   * screen. Rough terrain otherwise keeps splitting into sub-pixel triangles. Selection and
-   * morphing read the same capped table, so morph bands still end where splits happen.
-   */
+  /** Caps the measured errors by vertex spacing (`vertexPixels`, see `capErrors`). */
   capErrors(bump = true) {
     const s = this.settings;
     if (!s) return;
-    const k = s.vertexPixels > 0 ? s.errorPixels / s.vertexPixels : Number.POSITIVE_INFINITY;
-    const cap = (raw, out) => {
-      const o = out.length === raw.length ? out : new Float32Array(raw.length);
-      for (let d = 0; d < raw.length; d++) o[d] = Math.min(raw[d], k * this.spacing(d));
-      for (let d = raw.length - 2; d >= 0; d--) o[d] = Math.max(o[d], o[d + 1]);
-      return o;
-    };
+    const spacing = (d) => this.spacing(d);
     const before = this.errors;
     const same = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
-    const errors = cap(this.rawErrors, new Float32Array(this.rawErrors.length));
-    const ocean = cap(this.rawOceanErrors, new Float32Array(this.rawOceanErrors.length));
+    const errors = capErrors(this.rawErrors, spacing, s.errorPixels, s.vertexPixels);
+    const ocean = capErrors(this.rawOceanErrors, spacing, s.errorPixels, s.vertexPixels);
     if (same(errors, before) && same(ocean, this.oceanErrors)) return;
     this.errors = errors;
     this.oceanErrors = ocean;