@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/threesurfaces/SurfaceField.js

@@ -0,0 +1,158 @@
+import { contours, extent } from "d3";
+// src/charts/threesurfaces/SurfaceField.ts
+var numeric = (cell) => {
+	if (cell === null || cell === void 0 || cell === "") return NaN;
+	const value = +cell;
+	return Number.isFinite(value) ? value : NaN;
+};
+var catmullRom = (a, b, c, d, t) => b + .5 * t * (c - a + t * (2 * a - 5 * b + 4 * c - d + t * (3 * (b - c) + d - a)));
+/** Scalar field on a rectilinear grid. `NaN` marks a hole. All surface charts read their data through this. */
+var SurfaceField = class SurfaceField {
+	x;
+	y;
+	z;
+	nx;
+	ny;
+	zMin;
+	zMax;
+	constructor(x, y, z) {
+		this.x = x;
+		this.y = y;
+		this.z = z;
+		this.nx = x.length;
+		this.ny = y.length;
+		const [lo, hi] = extent(z);
+		this.zMin = lo ?? 0;
+		this.zMax = hi ?? 1;
+	}
+	static empty() {
+		return new SurfaceField([0, 1], [0, 1], (/* @__PURE__ */ new Float64Array(4)).fill(NaN));
+	}
+	static from(data, columns = {}) {
+		if (Array.isArray(data)) return SurfaceField.pivot(data, columns);
+		if (!data?.x?.length || !data.y?.length || !data.z?.length) return SurfaceField.empty();
+		const z = new Float64Array(data.x.length * data.y.length);
+		data.y.forEach((_, j) => data.x.forEach((_, i) => {
+			z[i + j * data.x.length] = numeric(data.z[j]?.[i]);
+		}));
+		return SurfaceField.widened(data.x.map(Number), data.y.map(Number), z);
+	}
+	/** Long rows to grid: duplicate cells average, missing cells become holes, text axes index by first appearance. */
+	static pivot(rows, { x = "x", y = "y", z = "z" }) {
+		if (!rows.length) return SurfaceField.empty();
+		const axis = (column) => {
+			const seen = [...new Set(rows.map((row) => row[column]))].filter((cell) => cell !== null && cell !== void 0);
+			if (seen.every((cell) => Number.isFinite(numeric(cell)))) return new Map([...new Set(seen.map(numeric))].sort((a, b) => a - b).map((value, i) => [value, i]));
+			return new Map(seen.map((cell, i) => [cell, i]));
+		};
+		const lookup = (map, cell) => map.get(cell) ?? map.get(numeric(cell));
+		const xs = axis(x), ys = axis(y);
+		if (!xs.size || !ys.size) return SurfaceField.empty();
+		const totals = new Float64Array(xs.size * ys.size), counts = new Uint32Array(xs.size * ys.size);
+		for (const row of rows) {
+			const i = lookup(xs, row[x]), j = lookup(ys, row[y]), value = numeric(row[z]);
+			if (i === void 0 || j === void 0 || Number.isNaN(value)) continue;
+			totals[i + j * xs.size] += value;
+			counts[i + j * xs.size]++;
+		}
+		const values = totals.map((total, k) => counts[k] ? total / counts[k] : NaN);
+		const labels = (map) => [...map.keys()].map((key, i) => typeof key === "number" ? key : i);
+		return SurfaceField.widened(labels(xs), labels(ys), values);
+	}
+	/** A single row or column still needs width to make a surface. */
+	static widened(x, y, z) {
+		if (x.length > 1 && y.length > 1) return new SurfaceField(x, y, z);
+		const gx = x.length > 1 ? x : [x[0], x[0] + 1], gy = y.length > 1 ? y : [y[0], y[0] + 1];
+		const out = new Float64Array(gx.length * gy.length);
+		gy.forEach((_, j) => gx.forEach((_, i) => {
+			out[i + j * gx.length] = z[Math.min(i, x.length - 1) + Math.min(j, y.length - 1) * x.length];
+		}));
+		return new SurfaceField(gx, gy, out);
+	}
+	static compute(x, y, fn) {
+		const z = new Float64Array(x.length * y.length);
+		y.forEach((v, j) => x.forEach((u, i) => {
+			const value = fn(u, v);
+			z[i + j * x.length] = Number.isFinite(value) ? value : NaN;
+		}));
+		return new SurfaceField(x, y, z);
+	}
+	get xDomain() {
+		return [this.x[0], this.x[this.nx - 1]];
+	}
+	get yDomain() {
+		return [this.y[0], this.y[this.ny - 1]];
+	}
+	get zDomain() {
+		return this.zMax > this.zMin ? [this.zMin, this.zMax] : [this.zMin - 1, this.zMin + 1];
+	}
+	get hasData() {
+		return this.z.some((value) => !Number.isNaN(value));
+	}
+	at(i, j) {
+		return this.z[Math.max(0, Math.min(this.nx - 1, i)) + Math.max(0, Math.min(this.ny - 1, j)) * this.nx];
+	}
+	/** Bilinear read at fractional indices. A hole with any weight makes the read a hole. */
+	sample(fi, fj) {
+		const i = Math.max(0, Math.min(this.nx - 2, Math.floor(fi))), j = Math.max(0, Math.min(this.ny - 2, Math.floor(fj)));
+		const a = fi - i, b = fj - j;
+		const part = (weight, value) => weight > 0 ? weight * value : 0;
+		return part((1 - a) * (1 - b), this.at(i, j)) + part(a * (1 - b), this.at(i + 1, j)) + part((1 - a) * b, this.at(i, j + 1)) + part(a * b, this.at(i + 1, j + 1));
+	}
+	/** Catmull-Rom read at fractional indices. */
+	cubic(fi, fj) {
+		const i = Math.floor(fi), j = Math.floor(fj);
+		const row = (r) => catmullRom(this.at(i - 1, r), this.at(i, r), this.at(i + 1, r), this.at(i + 2, r), fi - i);
+		return catmullRom(row(j - 1), row(j), row(j + 1), row(j + 2), fj - j);
+	}
+	resample(nx, ny, smooth = false) {
+		const lerp = (axis, t) => {
+			const i = Math.min(axis.length - 2, Math.floor(t));
+			return axis[i] + (axis[i + 1] - axis[i]) * (t - i);
+		};
+		const xs = Array.from({ length: nx }, (_, i) => i * (this.nx - 1) / (nx - 1)), ys = Array.from({ length: ny }, (_, j) => j * (this.ny - 1) / (ny - 1));
+		const z = new Float64Array(nx * ny);
+		ys.forEach((fj, j) => xs.forEach((fi, i) => {
+			z[i + j * nx] = smooth ? this.cubic(fi, fj) : this.sample(fi, fj);
+		}));
+		return new SurfaceField(xs.map((t) => lerp(this.x, t)), ys.map((t) => lerp(this.y, t)), z);
+	}
+	/** Keep vertex counts sane when a user hands in a huge grid. */
+	capped(limit) {
+		return this.nx <= limit && this.ny <= limit ? this : this.resample(Math.min(this.nx, limit), Math.min(this.ny, limit));
+	}
+	map(fn) {
+		const z = this.z.map((value, k) => {
+			const out = fn(value, k % this.nx, Math.floor(k / this.nx));
+			return Number.isFinite(out) ? out : NaN;
+		});
+		return new SurfaceField(this.x, this.y, z);
+	}
+	raw(thresholds) {
+		const clean = this.z.map((value) => Number.isNaN(value) ? -Infinity : value);
+		return contours().size([this.nx, this.ny]).thresholds(thresholds)(Array.from(clean));
+	}
+	toGrid = ([x, y]) => [Math.max(0, Math.min(this.nx - 1, x - .5)), Math.max(0, Math.min(this.ny - 1, y - .5))];
+	/** Filled iso-bands: each polygon is an outer ring followed by its holes. */
+	bands(thresholds) {
+		return this.raw(thresholds).map(({ value, coordinates }) => ({
+			value,
+			polygons: coordinates.map((polygon) => polygon.map((ring) => ring.map(this.toGrid)))
+		}));
+	}
+	/** Iso-lines with the grid border removed, so a contour ends at the edge rather than running along it. */
+	lines(thresholds) {
+		const edge = ([x, y]) => x <= 0 || y <= 0 || x >= this.nx || y >= this.ny;
+		return this.raw(thresholds).map(({ value, coordinates }) => ({
+			value,
+			paths: coordinates.flat().flatMap((ring) => {
+				const paths = [[]];
+				for (const point of ring) if (edge(point)) {
+					if (paths.at(-1).length) paths.push([]);
+				} else paths.at(-1).push(this.toGrid(point));
+				return paths.filter((path) => path.length > 1);
+			})
+		}));
+	}
+};
+export { SurfaceField };

package/dist/charts/threesurfaces/SurfaceGeometry.js

@@ -0,0 +1,121 @@
+import { BufferGeometry, Float32BufferAttribute } from "three";
+import { mergeGeometries } from "three/addons/utils/BufferGeometryUtils.js";
+// src/charts/threesurfaces/SurfaceGeometry.ts
+/** Builders for the triangle soups the surface charts share. */
+var SurfaceGeometry = class SurfaceGeometry {
+	/** `nx × ny` vertex lattice. A vertex with a non-finite coordinate is a hole and its triangles are skipped. */
+	static grid(nx, ny, place, paint, wrap = {}) {
+		const positions = new Float32Array(nx * ny * 3), colors = new Float32Array(nx * ny * 3), solid = new Uint8Array(nx * ny);
+		for (let j = 0; j < ny; j++) for (let i = 0; i < nx; i++) {
+			const point = place(i, j), k = i + j * nx;
+			if (!point.every(Number.isFinite)) continue;
+			solid[k] = 1;
+			positions.set(point, k * 3);
+			const color = paint(i, j);
+			colors.set([
+				color.r,
+				color.g,
+				color.b
+			], k * 3);
+		}
+		const indices = [];
+		const cellsX = wrap.x ? nx : nx - 1, cellsY = wrap.y ? ny : ny - 1;
+		for (let j = 0; j < cellsY; j++) for (let i = 0; i < cellsX; i++) {
+			const a = i + j * nx, b = (i + 1) % nx + j * nx, c = i + (j + 1) % ny * nx, d = (i + 1) % nx + (j + 1) % ny * nx;
+			if (solid[a] && solid[b] && solid[d]) indices.push(a, d, b);
+			if (solid[a] && solid[d] && solid[c]) indices.push(a, c, d);
+		}
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+		geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
+		geometry.setIndex(indices);
+		geometry.computeVertexNormals();
+		return geometry;
+	}
+	/** Split shared vertices so each triangle shades flat. `userData.source` keeps the way back to the grid for picking. */
+	static faceted(geometry) {
+		const source = Uint32Array.from(geometry.getIndex()?.array ?? []);
+		const flat = geometry.toNonIndexed();
+		flat.computeVertexNormals();
+		flat.userData.source = source;
+		return flat;
+	}
+	/** Vertical wall hanging from a polyline to `base`, with colours for its top and bottom edges. */
+	static curtain(top, base, upper, lower) {
+		const floor = typeof base === "number" ? () => base : base;
+		const finite = top.map((point) => point.every(Number.isFinite));
+		return SurfaceGeometry.grid(top.length, 2, (k, row) => finite[k] ? row ? top[k] : [
+			top[k][0],
+			floor(k),
+			top[k][2]
+		] : [
+			NaN,
+			NaN,
+			NaN
+		], (k, row) => row ? upper(k) : lower(k));
+	}
+	/** A curtain with thickness along `(dx, dz)`: front, back and lid. */
+	static slab(top, [dx, dz], base, upper, lower) {
+		const shift = (sign) => top.map(([x, y, z]) => [
+			x + dx * sign / 2,
+			y,
+			z + dz * sign / 2
+		]);
+		const front = shift(1), back = shift(-1);
+		const lid = SurfaceGeometry.grid(top.length, 2, (k, row) => (row ? back : front)[k], upper);
+		const ends = [0, top.length - 1].map((k) => {
+			const floor = typeof base === "number" ? base : base(k);
+			const wall = (point) => [[
+				point[0],
+				floor,
+				point[2]
+			], point];
+			return SurfaceGeometry.grid(2, 2, (i, row) => wall((i ? back : front)[k])[row], (_, row) => row ? upper(k) : lower(k));
+		});
+		return SurfaceGeometry.merge([
+			SurfaceGeometry.curtain(front, base, upper, lower),
+			SurfaceGeometry.curtain(back, base, upper, lower),
+			lid,
+			...ends
+		]);
+	}
+	/** Drop vertices no triangle uses. `userData.source` maps the survivors back to their original index. */
+	static compact(geometry) {
+		const index = geometry.getIndex();
+		const source = [...new Set(index.array)], renumber = new Map(source.map((vertex, k) => [vertex, k]));
+		const out = new BufferGeometry();
+		for (const name of Object.keys(geometry.attributes)) {
+			const attribute = geometry.getAttribute(name), size = attribute.itemSize;
+			const values = new Float32Array(source.length * size);
+			source.forEach((vertex, k) => {
+				for (let c = 0; c < size; c++) values[k * size + c] = attribute.array[vertex * size + c];
+			});
+			out.setAttribute(name, new Float32BufferAttribute(values, size));
+		}
+		out.setIndex(Array.from(index.array, (vertex) => renumber.get(vertex)));
+		out.userData.source = Uint32Array.from(source);
+		return out;
+	}
+	/** Give a three.js primitive the uniform vertex colour that lets it merge with painted geometry. */
+	static tinted(geometry, color) {
+		const count = geometry.getAttribute("position").count;
+		const colors = new Float32Array(count * 3);
+		for (let k = 0; k < count; k++) colors.set([
+			color.r,
+			color.g,
+			color.b
+		], k * 3);
+		geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
+		geometry.deleteAttribute("uv");
+		return geometry;
+	}
+	static merge(parts) {
+		const unified = parts.filter((part) => part.getAttribute("position").count).map((part) => part.index ? part : indexed(part));
+		return (unified.length ? mergeGeometries(unified) : null) ?? new BufferGeometry();
+	}
+};
+function indexed(geometry) {
+	geometry.setIndex(Array.from({ length: geometry.getAttribute("position").count }, (_, k) => k));
+	return geometry;
+}
+export { SurfaceGeometry };

package/dist/charts/threesurfaces/SurfaceMesh.js

@@ -0,0 +1,24 @@
+import { Mesh } from "three";
+// src/charts/threesurfaces/SurfaceMesh.ts
+/**
+* Mesh whose hits report the nearest vertex as `instanceId`, which is what `ctx.pick` receives,
+* so one continuous surface gets per-point tooltips without a lattice of invisible proxies.
+*/
+var SurfaceMesh = class extends Mesh {
+	raycast(raycaster, hits) {
+		const start = hits.length;
+		super.raycast(raycaster, hits);
+		const source = this.geometry.userData.source;
+		for (const hit of hits.slice(start)) {
+			if (!hit.face) continue;
+			const { x, y, z } = hit.barycoord ?? {
+				x: 1,
+				y: 0,
+				z: 0
+			};
+			const vertex = x >= y && x >= z ? hit.face.a : y >= z ? hit.face.b : hit.face.c;
+			hit.instanceId = source?.[vertex] ?? vertex;
+		}
+	}
+};
+export { SurfaceMesh };

package/dist/charts/threesurfaces/SurfaceSpace.js

@@ -0,0 +1,70 @@
+import { ScaleKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { scaleSymlog } from "d3";
+// src/charts/threesurfaces/SurfaceSpace.ts
+var FLOOR = -.7;
+var CEIL = .75;
+/** Maps grid indices to world space: data x → world x, data y → world depth, data z → world height. */
+var SurfaceSpace = class SurfaceSpace {
+	field;
+	range;
+	level;
+	constructor(field, kind = ScaleKind.Linear, range = [FLOOR, CEIL], domain = field.zDomain) {
+		this.field = field;
+		this.range = range;
+		this.level = SurfaceSpace.height(kind, domain, range);
+	}
+	/** Height scale. Log becomes symlog so zero and negative heights stay on the chart. */
+	static height(kind, [lo, hi], range) {
+		return (kind === ScaleKind.Log || kind === ScaleKind.Symlog ? scaleSymlog().constant(Math.max(hi - lo, 1e-9) / 8) : Scales.continuous(kind)).domain([lo, hi]).range(range);
+	}
+	/** Position of a fractional index along a possibly uneven axis, 0..1. */
+	fraction(axis, index) {
+		const i = Math.max(0, Math.min(axis.length - 2, Math.floor(index)));
+		const span = axis.at(-1) - axis[0] || 1;
+		return (axis[i] + (axis[i + 1] - axis[i]) * (index - i) - axis[0]) / span;
+	}
+	/** World x and z of a fractional grid index. */
+	ground(fi, fj) {
+		return [this.fraction(this.field.x, fi) * 2 - 1, 1 - this.fraction(this.field.y, fj) * 2];
+	}
+	at(fi, fj, lift = 0) {
+		const [x, z] = this.ground(fi, fj);
+		return [
+			x,
+			this.level(this.field.sample(fi, fj)) + lift,
+			z
+		];
+	}
+	floor(fi, fj, lift = 0) {
+		const [x, z] = this.ground(fi, fj);
+		return [
+			x,
+			this.range[0] + lift,
+			z
+		];
+	}
+};
+/** Wraps the grid around an annulus: x sweeps the angle, y runs out along the radius. */
+var PolarSurfaceSpace = class extends SurfaceSpace {
+	sweep;
+	inner;
+	swap;
+	constructor(field, kind, sweep, inner, swap = false) {
+		super(field, kind);
+		this.sweep = sweep;
+		this.inner = inner;
+		this.swap = swap;
+	}
+	polar(angle, radius) {
+		const a = ((angle - .5) * this.sweep - 90) * (Math.PI / 180);
+		return [Math.cos(a) * radius, Math.sin(a) * radius];
+	}
+	ground(fi, fj) {
+		const { x, y } = this.field;
+		const angular = this.swap ? y : x, radial = this.swap ? x : y;
+		const turn = this.fraction(angular, this.swap ? fj : fi) * (this.sweep === 360 ? (angular.length - 1) / angular.length : 1);
+		return this.polar(turn, this.inner + (1 - this.inner) * this.fraction(radial, this.swap ? fi : fj));
+	}
+};
+export { CEIL, FLOOR, PolarSurfaceSpace, SurfaceSpace };

package/dist/charts/threesurfaces/TerrainChart.js

@@ -0,0 +1,202 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { ColorRamp } from "./ColorRamp.js";
+import { GridSurfaceBase } from "./GridSurfaceBase.js";
+import { SurfaceField } from "./SurfaceField.js";
+import { SurfaceGeometry } from "./SurfaceGeometry.js";
+import { CEIL, FLOOR, SurfaceSpace } from "./SurfaceSpace.js";
+import { TubeBatch } from "./TubeBatch.js";
+import { BoxGeometry, CircleGeometry, Mesh, MeshStandardMaterial, PlaneGeometry } from "three";
+// src/charts/threesurfaces/TerrainChart.ts
+var TerrainBase = /* @__PURE__ */ function(TerrainBase) {
+	TerrainBase["Block"] = "block";
+	TerrainBase["Strata"] = "strata";
+	TerrainBase["Sheet"] = "sheet";
+	TerrainBase["Island"] = "island";
+	return TerrainBase;
+}({});
+var SEA = .3;
+var BEDROCK = .2;
+/** Layered ridged noise from three seeded sample surfaces. */
+function ridges(seed, n) {
+	const octaves = [
+		0,
+		1,
+		2
+	].map((k) => SurfaceField.from(SampleData.surface(seed + k * 2.3, n)));
+	const fold = (t) => {
+		const m = t % 2;
+		return m > 1 ? 2 - m : m;
+	};
+	const axis = Array.from({ length: n }, (_, i) => i / (n - 1));
+	const z = axis.map((v) => axis.map((u) => octaves.reduce((sum, octave, k) => {
+		const scale = 2 ** k, read = octave.sample(fold(u * scale * .9 + .05 * k) * (n - 1), fold(v * scale * .9 + .08 * k) * (n - 1));
+		return sum + (k ? .5 - Math.abs(read) * 1.6 : read * 1.5 + .4) / scale ** 1.8;
+	}, 0)));
+	return {
+		x: axis.map((t) => t * 100),
+		y: axis.map((t) => t * 100),
+		z
+	};
+}
+/** Elevation model as a physical object: for landscapes, bathymetry and any real height map worth showing in relief. */
+var TerrainChart = class extends GridSurfaceBase {
+	static meta = {
+		id: "terrain-3d",
+		name: "Terrain",
+		family: ChartFamily.Geospatial,
+		dimension: Dimension.Three,
+		shape: DataShape.Grid,
+		description: "Renders an elevation grid as a landscape, cut as a block, a strata section, a sheet or an island, with water and drainage.",
+		tags: [
+			"dem",
+			"elevation",
+			"relief",
+			"block diagram",
+			"landscape"
+		],
+		sample: (seed) => ridges(seed, 96),
+		variants: {
+			base: [
+				"block",
+				"strata",
+				"sheet",
+				"island"
+			],
+			water: [true, false],
+			rivers: [true, false],
+			contours: [false, true],
+			relief: [1, .6]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			base: "block",
+			water: true,
+			rivers: true,
+			contours: false,
+			relief: 1
+		};
+	}
+	shaped() {
+		const field = this.field(110);
+		if (this.options.base !== "island" || !field.hasData) return field;
+		const { nx, ny, zMin, zMax } = field;
+		return field.map((z, i, j) => {
+			const u = i / (nx - 1) * 2 - 1, v = j / (ny - 1) * 2 - 1, r = Math.hypot(u, v), wobble = .82 + .1 * Math.sin(Math.atan2(v, u) * 5);
+			if (r > 1) return NaN;
+			const edge = Math.min(1, Math.max(0, (1 - r / wobble) * 3.2));
+			return zMin + (z - zMin) * edge * edge * (3 - 2 * edge) * (zMax > zMin ? 1 : 0);
+		});
+	}
+	/** D8: every cell drains to its lowest neighbour; cells that collect enough flow become channels. */
+	channels(space, batch) {
+		const { field } = space;
+		const coarse = field.capped(72), { nx, ny } = coarse;
+		const order = Array.from(coarse.z.keys()).filter((k) => !Number.isNaN(coarse.z[k])).sort((a, b) => coarse.z[b] - coarse.z[a]);
+		const flow = new Float64Array(nx * ny).fill(1), next = new Int32Array(nx * ny).fill(-1);
+		for (const k of order) {
+			const i = k % nx, j = Math.floor(k / nx);
+			let low = coarse.z[k], target = -1;
+			for (const dj of [
+				-1,
+				0,
+				1
+			]) for (const di of [
+				-1,
+				0,
+				1
+			]) {
+				const u = i + di, v = j + dj;
+				if (u < 0 || v < 0 || u >= nx || v >= ny) continue;
+				const value = coarse.z[u + v * nx];
+				if (value < low) {
+					low = value;
+					target = u + v * nx;
+				}
+			}
+			next[k] = target;
+			if (target >= 0) flow[target] += flow[k];
+		}
+		const threshold = nx * ny / 220, seen = new Uint8Array(nx * ny);
+		const sx = (field.nx - 1) / (nx - 1), sy = (field.ny - 1) / (ny - 1);
+		const main = order.filter((k) => flow[k] > threshold);
+		for (const start of main) {
+			if (seen[start]) continue;
+			const path = [];
+			let k = start;
+			while (k >= 0) {
+				path.push(space.at(k % nx * sx, Math.floor(k / nx) * sy, .008));
+				if (seen[k]) break;
+				seen[k] = 1;
+				k = next[k];
+			}
+			batch.add(path, void 0, .0016 + 22e-5 * Math.sqrt(flow[start]));
+		}
+	}
+	strata(ctx, space, lift) {
+		const { nx, ny } = space.field;
+		const edges = [
+			Array.from({ length: nx }, (_, i) => [i, 0]),
+			Array.from({ length: ny }, (_, j) => [nx - 1, j]),
+			Array.from({ length: nx }, (_, i) => [i, ny - 1]),
+			Array.from({ length: ny }, (_, j) => [0, j])
+		];
+		const beds = 4, gap = .008, top = space.range[0];
+		const parts = [];
+		edges.forEach((edge) => {
+			const crest = edge.map(([i, j]) => space.at(i, j));
+			for (let bed = 0; bed < beds; bed++) {
+				const color = ctx.color(ctx.palette.sequential(.28 + .16 * bed));
+				const depth = (k, share) => {
+					const y = crest[k][1];
+					return FLOOR + ((Number.isFinite(y) ? y : top) - FLOOR) * share;
+				};
+				const upper = (beds - bed) / beds, lower = (beds - bed - 1) / beds;
+				parts.push(SurfaceGeometry.curtain(crest.map(([x, _y, z], k) => [
+					x,
+					depth(k, upper) - (bed ? gap / 2 : 0),
+					z
+				]), (k) => depth(k, lower) + (bed < 3 ? gap / 2 : 0), () => color, () => color));
+			}
+		});
+		this.solid(ctx, SurfaceGeometry.merge(parts), lift);
+	}
+	build(ctx) {
+		const { base, water, rivers, contours, relief } = this.options;
+		const field = this.shaped();
+		const bottom = FLOOR + (base === "block" || base === "strata" ? BEDROCK : .02);
+		const space = new SurfaceSpace(field, ScaleKind.Linear, [bottom, bottom + (CEIL - bottom) * relief]);
+		const [lo, hi] = field.zDomain, ramp = new ColorRamp(ctx.palette.sequential);
+		const tone = (value) => ramp.at(.1 + .8 * (value - lo) / (hi - lo));
+		this.box(ctx, this.axes(space), { walls: false });
+		const lift = this.rise(ctx);
+		this.solid(ctx, SurfaceGeometry.grid(field.nx, field.ny, (i, j) => space.at(i, j), (i, j) => tone(field.at(i, j))), lift, this.gridTip(space), { roughness: .85 });
+		if (!field.hasData) return;
+		if (base === "block") this.skirt(ctx, space, () => ctx.color(ctx.palette.sequential(.3)), lift);
+		if (base === "strata") this.strata(ctx, space, lift);
+		const sea = field.zMin + (field.zMax - field.zMin) * SEA;
+		if (contours) this.contourLines(ctx, space, lift, 7);
+		if (rivers) {
+			const batch = new TubeBatch();
+			this.channels(space, batch);
+			this.tubes(batch, lift, ctx.theme.surface, .85);
+		}
+		if (water) this.flood(ctx, space, sea, lift);
+	}
+	flood(ctx, space, sea, lift) {
+		const y = space.level(sea);
+		const material = new MeshStandardMaterial({
+			color: ctx.palette.sequential(.55),
+			roughness: .25,
+			transparent: true,
+			opacity: .6,
+			depthWrite: false
+		});
+		const bed = this.options.base;
+		const body = bed === "island" ? new CircleGeometry(1, 72).rotateX(-Math.PI / 2).translate(0, y, 0) : bed === "sheet" ? new PlaneGeometry(2, 2).rotateX(-Math.PI / 2).translate(0, y, 0) : new BoxGeometry(1.996, y - FLOOR, 1.996).translate(0, (y + FLOOR) / 2, 0);
+		lift.add(new Mesh(body, material));
+	}
+};
+export { TerrainBase, TerrainChart };