@aethervtt/shard-terrain 0.0.1

package/dist/plugin.js

@@ -0,0 +1,98 @@
+import { AssetServerResource, assetServer } from "@aethervtt/shard-assets";
+import { defineSystem, onRemove, PostUpdate } from "@aethervtt/shard-core";
+import { computeVisibility } from "@aethervtt/shard-render";
+import { definePlugin } from "@aethervtt/shard-runtime";
+import { TransformSystems } from "@aethervtt/shard-transform";
+import * as biomesModule from "./biomes.js";
+import { anchorQueries, clearColliders, gatherAnchors, updateColliders } from "./colliders.js";
+import * as componentsModule from "./components.js";
+import { Planet, TerrainBudget } from "./components.js";
+import * as heightsModule from "./heights.js";
+import { Terrain } from "./heights.js";
+import * as materialModule from "./material.js";
+import { terrainMethods } from "./methods.js";
+import { clearPlanetNav, updatePlanetNav } from "./nav.js";
+import * as overlaysModule from "./overlays.js";
+import { PlanetRuntime } from "./planet.js";
+import { cleanupRender, registerNode, selectChunks } from "./render.js";
+const watching = /* @__PURE__ */ new WeakSet();
+function watchAssets(world) {
+  if (watching.has(world) || !world.tryResource(AssetServerResource)) return;
+  watching.add(world);
+  assetServer(world).onEvent((event) => {
+    if (event.kind === "loaded" || event.kind === "modified" || event.kind === "failed")
+      world.resource(Terrain).dirty = true;
+  });
+}
+const updatePlanets = defineSystem({
+  name: "terrain/planets",
+  description: "Resolves each Planet\u2019s graphs and biomes, measures its LOD errors, and keeps collider chunks (fixed trimesh bodies) around characters, dynamic bodies, and TerrainAnchors.",
+  setup: (world) => ({
+    planets: world.query({ with: [Planet] }),
+    anchors: anchorQueries(world)
+  }),
+  run: (s, world) => {
+    const state = world.resource(Terrain);
+    watchAssets(world);
+    state.frame++;
+    const frame = state.frame;
+    for (const table of s.planets.tables) {
+      for (let row = 0; row < table.count; row++) {
+        const entity = table.entities[row];
+        if (!state.planets.has(entity)) state.planets.set(entity, new PlanetRuntime(entity));
+      }
+    }
+    const budget = world.resource(TerrainBudget);
+    const dirty = state.dirty;
+    state.dirty = false;
+    for (const rt of state.planets.values()) {
+      if (!world.isAlive(rt.entity)) continue;
+      rt.refresh(world, dirty);
+      rt.frame.update(world, rt.entity);
+      if (!rt.ready) continue;
+      gatherAnchors(world, rt, s.anchors);
+      updateColliders(world, rt, state.workers, frame, budget.colliderCache);
+      updatePlanetNav(world, rt, s.anchors.agents);
+    }
+  }
+});
+function terrainPlugin(options = {}) {
+  return definePlugin({
+    name: "terrain",
+    provides: [biomesModule, componentsModule, heightsModule, materialModule, overlaysModule],
+    dependencies: ["core/transform"],
+    build(app) {
+      const world = app.world;
+      const state = world.initResource(Terrain);
+      state.workers = options.workers;
+      world.initResource(TerrainBudget);
+      world.observe(onRemove(Planet), ({ entity, world: world2 }) => {
+        const rt = world2.resource(Terrain).planets.get(entity);
+        if (!rt) return;
+        clearColliders(world2, rt);
+        clearPlanetNav(world2, rt);
+        cleanupRender(world2, rt);
+        for (const cleanup of terrainCleanups) cleanup(world2, rt);
+        world2.resource(Terrain).planets.delete(entity);
+      });
+      app.addSystems(PostUpdate, updatePlanets.after(TransformSystems));
+      app.addMethod(...terrainMethods);
+      app.addSystems(PostUpdate, selectChunks.after(updatePlanets).before(computeVisibility));
+      for (const extend of terrainExtensions) extend(app);
+    },
+    async ready(app) {
+      registerNode(app);
+      for (const hook of terrainReadyHooks) await hook(app);
+    }
+  });
+}
+const terrainExtensions = [];
+const terrainReadyHooks = [];
+const terrainCleanups = [];
+export {
+  terrainCleanups,
+  terrainExtensions,
+  terrainPlugin,
+  terrainReadyHooks,
+  updatePlanets
+};

package/dist/points.d.ts

@@ -0,0 +1,62 @@
+import { type NoiseGraph } from '@aethervtt/shard-noise';
+/**
+ * Noise origins sit on a lattice this many metres apart in the planet frame. A point samples
+ * relative to its nearest lattice point, which depends only on where the point is, so every chunk
+ * that has a vertex (a neighbor, a parent, a coarser neighbor at a 2:1 edge) computes the same
+ * height for it, bit for bit. Offsets stay under ~55 m, which keeps fine octaves' lattice
+ * coordinates in the range 0041's CPU/GPU tolerance is measured over.
+ */
+export declare const SNAP = 64;
+/**
+ * Terrain noise is sampled at `direction × radius + NOISE_OFFSET`. Canonical points on cube edges
+ * have exactly equal coordinates (x = z), which puts them exactly on a tie of OpenSimplex2's
+ * rotated lattice, where the GPU's fused multiply-adds can pick the other lattice branch than the
+ * CPU and differ past 0041's tolerance. An asymmetric offset of tens of metres moves the terrain's
+ * points off every such plane; to the terrain it's just a shift of the noise.
+ */
+export declare const NOISE_OFFSET: readonly [13.71, 27.13, 41.92];
+/**
+ * The unit direction of grid point (gi, gj) of a face at a grid resolution of `size` segments per
+ * face edge. Points on a face's boundary belong to two or three faces; they're computed from the
+ * lowest-numbered one, so every chunk sharing the point gets the same bits. Points past the boundary
+ * (a chunk's outer border ring) extrapolate the face's plane.
+ */
+export declare function gridDirection(face: number, gi: number, gj: number, size: number, out: Float64Array, o: number): void;
+/**
+ * A chunk's sample points: its (n + 2)² grid (one-vertex border for normals) as canonical unit
+ * directions, grouped by noise origin (lattice point), with each point's f32 offset from its
+ * origin on the noise sphere (direction × radius).
+ */
+export interface ChunkPoints {
+    /** Points per side: n + 2. */
+    side: number;
+    count: number;
+    dirs: Float64Array;
+    /** Group (origin) of each point. */
+    group: Int32Array;
+    groups: number;
+    /** Origins (f64 xyzw, w = 0), 4 per group. */
+    origins: Float64Array;
+    /** Offsets from the point's origin (f32 xyz), per point. */
+    local: Float32Array;
+    /** Points sorted by group: group g is order[start[g] .. start[g + 1]). */
+    order: Int32Array;
+    start: Int32Array;
+}
+export declare function createChunkPoints(): ChunkPoints;
+/**
+ * Fills `out` with a node's sample points, grouped by lattice origins `snap` metres apart. Without
+ * `snap`, each point's lattice follows its level (the coarsest depth it's a vertex at, from its
+ * grid index): SNAP for points only fine chunks have, up to a quarter of a chunk at that level (at
+ * most 4 096 m) for coarser vertices. Every chunk sampling a point picks the same lattice, so shared vertices stay
+ * bit-identical across chunks and depths, while a coarse chunk's points fall into a few groups
+ * instead of one each (their per-octave origins were most of a job's upload).
+ */
+export declare function prepareChunkPoints(face: number, depth: number, x: number, y: number, resolution: number, radius: number, out: ChunkPoints, snap?: number): ChunkPoints;
+/**
+ * Samples a graph at every point on the CPU, one kernel batch per origin, into `out` (per point).
+ * `node` samples an intermediate node (the climate graph's temperature and moisture).
+ */
+export declare function sampleChunkPoints(graph: NoiseGraph, seed: number, pts: ChunkPoints, out: Float32Array, node?: string): void;
+/** One point's height-graph value (a gameplay query): relative to its own lattice origin. */
+export declare function samplePoint(graph: NoiseGraph, seed: number, dx: number, dy: number, dz: number, radius: number, out: Float32Array, node?: string): number;

package/dist/points.js

@@ -0,0 +1,207 @@
+import { sampleOffset } from "@aethervtt/shard-noise";
+import { faceToDirection } from "./cube.js";
+const SNAP = 64;
+const NOISE_OFFSET = [13.71, 27.13, 41.92];
+const FACES = [
+  [1, 0, 0, 0, 0, -1, 0, 1, 0],
+  [-1, 0, 0, 0, 0, 1, 0, 1, 0],
+  [0, 1, 0, 1, 0, 0, 0, 0, -1],
+  [0, -1, 0, 1, 0, 0, 0, 0, 1],
+  [0, 0, 1, 1, 0, 0, 0, 1, 0],
+  [0, 0, -1, -1, 0, 0, 0, 1, 0]
+];
+const QUARTER_PI = Math.PI / 4;
+const probe = new Float64Array(3);
+function gridDirection(face, gi, gj, size, out, o) {
+  faceToDirection(face, -1 + 2 * gi / size, -1 + 2 * gj / size, out, o);
+  if (face === 0 || gi !== 0 && gi !== size && gj !== 0 && gj !== size) return;
+  const x = out[o];
+  const y = out[o + 1];
+  const z = out[o + 2];
+  for (let f = 0; f < face; f++) {
+    const a = FACES[f];
+    const n = x * a[0] + y * a[1] + z * a[2];
+    if (n <= 0.5) continue;
+    const u = Math.atan((x * a[3] + y * a[4] + z * a[5]) / n) / QUARTER_PI;
+    const v = Math.atan((x * a[6] + y * a[7] + z * a[8]) / n) / QUARTER_PI;
+    if (Math.abs(u) > 1 + 1e-9 || Math.abs(v) > 1 + 1e-9) continue;
+    const ci = Math.round((u + 1) / 2 * size);
+    const cj = Math.round((v + 1) / 2 * size);
+    faceToDirection(f, -1 + 2 * ci / size, -1 + 2 * cj / size, probe, 0);
+    out[o] = probe[0];
+    out[o + 1] = probe[1];
+    out[o + 2] = probe[2];
+    return;
+  }
+}
+function createChunkPoints() {
+  return {
+    side: 0,
+    count: 0,
+    dirs: new Float64Array(0),
+    group: new Int32Array(0),
+    groups: 0,
+    origins: new Float64Array(0),
+    local: new Float32Array(0),
+    order: new Int32Array(0),
+    start: new Int32Array(0)
+  };
+}
+let tableCell = new Int32Array(0);
+let tableGroup = new Int32Array(0);
+const chunkMetres = (radius, depth) => radius * Math.PI / 2 / 2 ** depth;
+function trailingZeros(i, cap) {
+  if (i === 0) return cap;
+  let v = i < 0 ? -i : i;
+  let z = 0;
+  while ((v & 1) === 0 && z < cap) {
+    v >>>= 1;
+    z++;
+  }
+  return z;
+}
+const levelSnaps = new Float64Array(32);
+const MAX_SNAP = 4096;
+function prepareChunkPoints(face, depth, x, y, resolution, radius, out, snap) {
+  const side = resolution + 2;
+  const count = side * side;
+  if (out.dirs.length < count * 3) {
+    out.dirs = new Float64Array(count * 3);
+    out.group = new Int32Array(count);
+    out.local = new Float32Array(count * 3);
+    out.order = new Int32Array(count);
+    out.origins = new Float64Array(count * 4);
+    out.start = new Int32Array(count + 1);
+  }
+  out.side = side;
+  out.count = count;
+  const size = 2 ** depth * (resolution - 1);
+  const gi0 = x * (resolution - 1) - 1;
+  const gj0 = y * (resolution - 1) - 1;
+  const slots = highBit(count * 4);
+  if (tableGroup.length < slots) {
+    tableCell = new Int32Array(slots * 4);
+    tableGroup = new Int32Array(slots);
+  }
+  const levels = Math.min(depth, 31);
+  for (let L = 0; L <= levels; L++) {
+    let sn = SNAP;
+    const size2 = chunkMetres(radius, L);
+    while (sn * 4 < size2 && sn < MAX_SNAP) sn *= 2;
+    levelSnaps[L] = snap ?? sn;
+  }
+  const segBits = Math.round(Math.log2(resolution - 1));
+  const mask = slots - 1;
+  tableGroup.fill(-1, 0, slots);
+  let groups = 0;
+  const d = out.dirs;
+  for (let J = 0; J < side; J++) {
+    for (let I = 0; I < side; I++) {
+      const k = I + J * side;
+      const gi = gi0 + I;
+      const gj = gj0 + J;
+      gridDirection(face, gi, gj, size, d, k * 3);
+      const tz = Math.min(trailingZeros(gi, depth + segBits), trailingZeros(gj, depth + segBits));
+      const level = Math.max(0, depth - Math.max(0, tz));
+      const sn = levelSnaps[Math.min(level, levels)];
+      const px = d[k * 3] * radius + NOISE_OFFSET[0];
+      const py = d[k * 3 + 1] * radius + NOISE_OFFSET[1];
+      const pz = d[k * 3 + 2] * radius + NOISE_OFFSET[2];
+      const cx = Math.round(px / sn);
+      const cy = Math.round(py / sn);
+      const cz = Math.round(pz / sn);
+      let h = (hashCell(cx, cy, cz) ^ Math.imul(sn, 668265261)) & mask;
+      while (tableGroup[h] !== -1 && (tableCell[h * 4] !== cx || tableCell[h * 4 + 1] !== cy || tableCell[h * 4 + 2] !== cz || tableCell[h * 4 + 3] !== sn))
+        h = h + 1 & mask;
+      let g;
+      if (tableGroup[h] !== -1) g = tableGroup[h];
+      else {
+        tableCell[h * 4] = cx;
+        tableCell[h * 4 + 1] = cy;
+        tableCell[h * 4 + 2] = cz;
+        tableCell[h * 4 + 3] = sn;
+        g = groups++;
+        tableGroup[h] = g;
+        out.origins[g * 4] = cx * sn;
+        out.origins[g * 4 + 1] = cy * sn;
+        out.origins[g * 4 + 2] = cz * sn;
+        out.origins[g * 4 + 3] = 0;
+      }
+      out.group[k] = g;
+      out.local[k * 3] = px - cx * sn;
+      out.local[k * 3 + 1] = py - cy * sn;
+      out.local[k * 3 + 2] = pz - cz * sn;
+    }
+  }
+  out.groups = groups;
+  const start = out.start;
+  start.fill(0, 0, groups + 1);
+  for (let k = 0; k < count; k++) start[out.group[k] + 1]++;
+  for (let g = 0; g < groups; g++) start[g + 1] += start[g];
+  for (let k = 0; k < count; k++) {
+    const g = out.group[k];
+    out.order[start[g]] = k;
+    start[g]++;
+  }
+  for (let g = groups; g > 0; g--) start[g] = start[g - 1];
+  start[0] = 0;
+  return out;
+}
+function highBit(n) {
+  let p = 1;
+  while (p < n) p *= 2;
+  return p;
+}
+function hashCell(x, y, z) {
+  let h = Math.imul(x, 2654435761) ^ Math.imul(y, 2246822507) ^ Math.imul(z, 3266489909);
+  h ^= h >>> 15;
+  return h >>> 0;
+}
+let gathered = new Float32Array(0);
+let sampled = new Float32Array(0);
+const origin = new Float64Array(4);
+function sampleChunkPoints(graph, seed, pts, out, node) {
+  if (gathered.length < pts.count * 3) {
+    gathered = new Float32Array(pts.count * 3);
+    sampled = new Float32Array(pts.count);
+  }
+  for (let g = 0; g < pts.groups; g++) {
+    const a = pts.start[g];
+    const b = pts.start[g + 1];
+    for (let i = a; i < b; i++) {
+      const k = pts.order[i];
+      gathered[(i - a) * 3] = pts.local[k * 3];
+      gathered[(i - a) * 3 + 1] = pts.local[k * 3 + 1];
+      gathered[(i - a) * 3 + 2] = pts.local[k * 3 + 2];
+    }
+    origin[0] = pts.origins[g * 4];
+    origin[1] = pts.origins[g * 4 + 1];
+    origin[2] = pts.origins[g * 4 + 2];
+    const values = sampled.subarray(0, b - a);
+    sampleOffset(graph, seed, origin, gathered.subarray(0, (b - a) * 3), values, node);
+    for (let i = a; i < b; i++) out[pts.order[i]] = values[i - a];
+  }
+}
+function samplePoint(graph, seed, dx, dy, dz, radius, out, node) {
+  const px = dx * radius + NOISE_OFFSET[0];
+  const py = dy * radius + NOISE_OFFSET[1];
+  const pz = dz * radius + NOISE_OFFSET[2];
+  origin[0] = Math.round(px / SNAP) * SNAP;
+  origin[1] = Math.round(py / SNAP) * SNAP;
+  origin[2] = Math.round(pz / SNAP) * SNAP;
+  pointLocal[0] = px - origin[0];
+  pointLocal[1] = py - origin[1];
+  pointLocal[2] = pz - origin[2];
+  sampleOffset(graph, seed, origin, pointLocal, out, node);
+  return out[0];
+}
+const pointLocal = new Float32Array(3);
+export {
+  NOISE_OFFSET,
+  SNAP,
+  createChunkPoints,
+  gridDirection,
+  prepareChunkPoints,
+  sampleChunkPoints,
+  samplePoint
+};

package/dist/quadtree.d.ts

@@ -0,0 +1,153 @@
+/** The node's mesh exists (GPU dispatched, or a CPU mesh assigned): it can render. */
+export declare const NODE_READY = 1;
+/** Heights are known exactly (CPU mesh, or the GPU readback arrived). */
+export declare const NODE_BOUNDS = 2;
+/**
+ * One cube-sphere quadtree per planet surface (terrain or ocean), stored as flat typed arrays
+ * indexed by node, so the per-frame walk allocates nothing. The six roots are nodes 0–5; children
+ * are made on first split as a block of four consecutive nodes, and freed as a block when their
+ * subtree hasn't been needed for a while.
+ */
+export declare class NodeTree {
+    capacity: number;
+    count: number;
+    face: Uint8Array<ArrayBuffer>;
+    depth: Uint8Array<ArrayBuffer>;
+    x: Uint32Array<ArrayBuffer>;
+    y: Uint32Array<ArrayBuffer>;
+    parent: Int32Array<ArrayBuffer>;
+    /** First of four children (in order (2x, 2y), (2x+1, 2y), (2x, 2y+1), (2x+1, 2y+1)), or −1. */
+    child: Int32Array<ArrayBuffer>;
+    flags: Uint8Array<ArrayBuffer>;
+    /** Bounding sphere in the planet frame (f64): center xyz, radius. */
+    sphere: Float64Array<ArrayBuffer>;
+    /** Height range (m above radius): exact once NODE_BOUNDS, else inherited or the planet's. */
+    minH: Float32Array<ArrayBuffer>;
+    maxH: Float32Array<ArrayBuffer>;
+    /** Horizon test directions (unit, 9 per node). */
+    dirs: Float64Array<ArrayBuffer>;
+    /** Stamps: last walk (frame), rendered and culled (walk stamp), forced split, last needed (frame). */
+    visited: Uint32Array<ArrayBuffer>;
+    rendered: Uint32Array<ArrayBuffer>;
+    forced: Uint32Array<ArrayBuffer>;
+    culled: Uint32Array<ArrayBuffer>;
+    used: Uint32Array<ArrayBuffer>;
+    /** Pass stamp when the node was last requested, so each pass lists it once. */
+    requestedAt: Uint32Array<ArrayBuffer>;
+    /** Frame the node was last split (children walked): merging then takes a margin. */
+    splitAt: Uint32Array<ArrayBuffer>;
+    /**
+     * Frame the node was last needed on screen: rendered, or a visible child a split waits for.
+     * Prefetched and out-of-view nodes are only `used`; a full pool evicts them first.
+     */
+    neededAt: Uint32Array<ArrayBuffer>;
+    /** Render slot holding its mesh, or −1. */
+    slot: Int32Array<ArrayBuffer>;
+    /** Projected error (px) and distance when last requested: generation priority. */
+    priority: Float32Array<ArrayBuffer>;
+    distance: Float64Array<ArrayBuffer>;
+    /** Edge locks when rendered: bottom, right, top, left (−1, 0, 1). */
+    locks: Int8Array<ArrayBuffer>;
+    /** Quadrants drawn when rendered (15: all; fewer while a split waits for some children). */
+    mask: Uint8Array<ArrayBuffer>;
+    /** The planet version the node's mesh was made for: older is stale (it renders until replaced). */
+    gen: Uint32Array<ArrayBuffer>;
+    /**
+     * 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: Float64Array<ArrayBuffer>;
+    /** Starts of freed child blocks. */
+    private blocks;
+    radius: number;
+    readonly shape: Float64Array<ArrayBuffer>;
+    /** Height range for nodes whose heights aren't known yet. */
+    lowest: number;
+    highest: number;
+    constructor(capacity?: number);
+    private grow;
+    /** Clears every node and makes the six roots (after a planet's shape or graphs change). */
+    reset(radius: number, shape: ArrayLike<number>, lowest: number, highest: number): void;
+    /** Root of a face (nodes 0–5). */
+    root(face: number): number;
+    private init;
+    /** Children of `n`, made if needed. Returns the first (the others follow it). */
+    split(n: number): number;
+    /** Frees `n`'s subtree. `release` is called for every freed node that holds a render slot. */
+    merge(n: number, release: (node: number) => void): void;
+    /** Live nodes (roots plus allocated blocks). */
+    get live(): number;
+    /** Sets a node's exact height range and recomputes its bounds. */
+    setHeights(n: number, minH: number, maxH: number): void;
+    /** Bounding sphere of the node's 9 test points at its lowest and highest heights, plus bulge. */
+    updateSphere(n: number): void;
+    /**
+     * 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.
+     */
+    bounds(n: number, center: ArrayLike<number>, out: {
+        [i: number]: number;
+    }): void;
+    /** The node at (face, depth, x, y) if the tree has it, else the deepest existing ancestor. */
+    find(face: number, depth: number, x: number, y: number): number;
+    /** Frees subtrees nobody has needed since frame `before`. */
+    prune(before: number, release: (node: number) => void): void;
+    /** Returns whether `n` and its whole subtree are idle. */
+    private pruneNode;
+}
+/** What selection sees of the camera, in the planet frame (f64). */
+export interface SelectionView {
+    /** Camera position. */
+    position: Float64Array;
+    /** Planes (nx, ny, nz, d), inside where n · p + d ≥ 0; `planes` of them. */
+    frustum: Float64Array;
+    planes: number;
+    /**
+     * A wider frustum (1.5× the field of view), same count: nodes just outside the view are
+     * generated ahead of nodes far outside, so turning or moving shows them ready.
+     */
+    wide: Float64Array;
+    /** Pixels per radian at the view center: viewport height / (2 tan(fovY / 2)). */
+    pixelsPerRadian: number;
+}
+export interface SelectionParams {
+    maxDepth: number;
+    /** Geometric error per depth (m). A depth-d node splits by errors[d + 1]. */
+    errors: Float32Array;
+    errorPixels: number;
+    /** Occluder radius for the horizon test (the lowest the surface gets), 0 for none. */
+    occluder: number;
+    /** Depth colliders use: forced near anchors, and the deepest rendered there. */
+    colliderDepth: number;
+    /** Anchor positions in the planet frame (xyz) and their radii; `anchors` of them. */
+    anchorPos: Float64Array;
+    anchorRadius: Float64Array;
+    anchors: number;
+}
+/** A selection's output: rendered nodes, and nodes to generate with their priority. */
+export interface Selection {
+    rendered: Int32Array;
+    renderedCount: number;
+    requested: Int32Array;
+    requestedCount: number;
+    /** Splits waiting for children: the parent renders meanwhile. */
+    waiting: number;
+    /** The first child each waiting split is missing (debugging and terrain.describe). */
+    missing: Int32Array;
+    /** Walks this frame (2:1 balance adds some). */
+    passes: number;
+    /** Stamp of the final walk: `tree.rendered[n] === stamp` for nodes rendered this frame. */
+    stamp: number;
+}
+export declare function createSelection(): Selection;
+/**
+ * Picks the nodes to render this frame (spec 0043): walks the six trees, culls nodes behind the
+ * horizon or outside the frustum, splits a node when its children's geometric error projects past
+ * `errorPixels` (or an anchor needs collider depth nearby, where nothing goes deeper), and renders
+ * a split node's children only once all of the visible ones are ready, so a split never shows a
+ * hole. Then enforces 2:1 balance between neighbors (marking coarse nodes to split and walking
+ * again) and sets each rendered node's edge locks. Allocates nothing once its arrays are big enough.
+ */
+export declare function selectNodes(tree: NodeTree, view: SelectionView, params: SelectionParams, frame: number, out: Selection): void;
+/** Whether any anchor is within its radius of the node's bounds. */
+export declare function nearAnchor(tree: NodeTree, n: number, params: SelectionParams): boolean;