@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/threesurfaces/ImplicitSurface.js

@@ -0,0 +1,237 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { ColorRamp } from "./ColorRamp.js";
+import { IsoSurfaceMesher } from "./IsoSurfaceMesher.js";
+import { SurfaceBase } from "./SurfaceBase.js";
+import { short } from "./GridSurfaceBase.js";
+import { median } from "d3";
+import { Float32BufferAttribute } from "three";
+// src/charts/threesurfaces/ImplicitSurface.ts
+var ImplicitSurfaceForm = /* @__PURE__ */ function(ImplicitSurfaceForm) {
+	ImplicitSurfaceForm["Data"] = "data";
+	ImplicitSurfaceForm["Gyroid"] = "gyroid";
+	ImplicitSurfaceForm["SchwarzP"] = "schwarz-p";
+	ImplicitSurfaceForm["SchwarzD"] = "schwarz-d";
+	ImplicitSurfaceForm["Neovius"] = "neovius";
+	ImplicitSurfaceForm["Torus"] = "torus";
+	ImplicitSurfaceForm["Tangle"] = "tangle-cube";
+	ImplicitSurfaceForm["Cayley"] = "cayley";
+	ImplicitSurfaceForm["Chmutov"] = "chmutov";
+	ImplicitSurfaceForm["Heart"] = "heart";
+	ImplicitSurfaceForm["GenusTwo"] = "genus-two";
+	ImplicitSurfaceForm["Metaballs"] = "metaballs";
+	return ImplicitSurfaceForm;
+}({});
+var ImplicitClip = /* @__PURE__ */ function(ImplicitClip) {
+	ImplicitClip["None"] = "whole";
+	ImplicitClip["Half"] = "half";
+	ImplicitClip["Octant"] = "octant";
+	return ImplicitClip;
+}({});
+var { sin, cos, PI, hypot } = Math;
+var pow2 = (v) => v * v;
+/** Fields scaled to the cube -1..1. */
+var FORMS = {
+	["gyroid"]: (x, y, z) => {
+		const k = PI * 2.4;
+		return sin(k * x) * cos(k * y) + sin(k * y) * cos(k * z) + sin(k * z) * cos(k * x);
+	},
+	["schwarz-p"]: (x, y, z) => cos(PI * 2 * x / .9) + cos(PI * 2 * y / .9) + cos(PI * 2 * z / .9),
+	["schwarz-d"]: (x, y, z) => {
+		const k = PI * 1.2, [sx, sy, sz, cx, cy, cz] = [
+			sin(k * x),
+			sin(k * y),
+			sin(k * z),
+			cos(k * x),
+			cos(k * y),
+			cos(k * z)
+		];
+		return sx * sy * sz + sx * cy * cz + cx * sy * cz + cx * cy * sz;
+	},
+	["neovius"]: (x, y, z) => {
+		const k = PI * 2, [cx, cy, cz] = [
+			cos(k * x),
+			cos(k * y),
+			cos(k * z)
+		];
+		return 3 * (cx + cy + cz) + 4 * cx * cy * cz;
+	},
+	["torus"]: (x, y, z) => hypot(hypot(x, z) - .62, y) - .26,
+	["tangle-cube"]: (x, y, z) => {
+		const [a, b, c] = [
+			x * 2.4,
+			y * 2.4,
+			z * 2.4
+		];
+		return (a ** 4 - 5 * a * a + b ** 4 - 5 * b * b + c ** 4 - 5 * c * c + 11.8) / 12;
+	},
+	["cayley"]: (x, y, z) => {
+		const [a, b, c] = [
+			x * .8,
+			y * .8,
+			z * .8
+		];
+		return 4 * (a * a + b * b + c * c) + 16 * a * b * c - 1;
+	},
+	["chmutov"]: (x, y, z) => {
+		const t = (v) => 8 * v ** 4 - 8 * v * v + 1;
+		return t(x * 1.1) + t(y * 1.1) + t(z * 1.1) + 1;
+	},
+	["heart"]: (x, y, z) => {
+		const [a, b, c] = [
+			x * 1.45,
+			z * 1.45,
+			y * 1.45 + .1
+		];
+		return (a * a + 9 / 4 * b * b + c * c - 1) ** 3 - a * a * c ** 3 - 9 / 80 * b * b * c ** 3;
+	},
+	["genus-two"]: (x, y, z) => {
+		const [a, b, c] = [
+			x * 1.25,
+			z * 1.25,
+			y * 1.25
+		];
+		return 2 * b * (b * b - 3 * a * a) * (1 - c * c) + pow2(a * a + b * b) - (9 * c * c - 1) * (1 - c * c);
+	},
+	["metaballs"]: (x, y, z) => 1 - [
+		[
+			-.4,
+			-.2,
+			.1,
+			.11
+		],
+		[
+			.4,
+			.1,
+			-.2,
+			.09
+		],
+		[
+			.05,
+			.42,
+			.3,
+			.07
+		],
+		[
+			.1,
+			-.5,
+			-.3,
+			.06
+		]
+	].reduce((sum, [cx, cy, cz, power]) => sum + power / (pow2(x - cx) + pow2(y - cy) + pow2(z - cz) + 1e-6), 0)
+};
+/** Solid bounded by `f(x, y, z) = 0`: for minimal surfaces, level sets of a volume, and any shape with no parametrisation. */
+var ImplicitSurface = class extends SurfaceBase {
+	static meta = {
+		id: "implicit-surface",
+		name: "Implicit surface",
+		family: ChartFamily.Mathematical,
+		dimension: Dimension.Three,
+		shape: DataShape.Function,
+		description: "Extracts the level set of a three-dimensional field, from a measured volume to gyroids and other classic implicit solids.",
+		tags: [
+			"iso-surface",
+			"level set",
+			"gyroid",
+			"minimal surface",
+			"schwarz"
+		],
+		sample: (seed) => SampleData.volume(seed, 24),
+		variants: {
+			form: Object.values(ImplicitSurfaceForm),
+			clip: [
+				"whole",
+				"half",
+				"octant"
+			],
+			shell: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			form: "data",
+			clip: "whole",
+			shell: false,
+			iso: .45,
+			elevation: 24,
+			distance: 5.6
+		};
+	}
+	volume() {
+		const { data, iso } = this.options;
+		const [nx = 0, ny = 0, nz = 0] = data?.size ?? [];
+		const values = data?.values;
+		if (!values?.length || nx < 2 || ny < 2 || nz < 2) return () => 1;
+		let peak = -Infinity;
+		for (let k = 0; k < values.length; k++) if (values[k] > peak) peak = values[k];
+		const level = peak * iso;
+		const read = (x, y, z) => values[x + y * nx + z * nx * ny];
+		const axis = (v, n) => {
+			const position = (v + 1) / 2 * (n - 1), low = Math.max(0, Math.min(n - 2, Math.floor(position)));
+			return [low, position - low];
+		};
+		return (x, y, z) => {
+			const [i, a] = axis(x, nx), [j, b] = axis(y, ny), [k, c] = axis(z, nz);
+			const bottom = (read(i, j, k) * (1 - a) + read(i + 1, j, k) * a) * (1 - b) + (read(i, j + 1, k) * (1 - a) + read(i + 1, j + 1, k) * a) * b;
+			const top = (read(i, j, k + 1) * (1 - a) + read(i + 1, j, k + 1) * a) * (1 - b) + (read(i, j + 1, k + 1) * (1 - a) + read(i + 1, j + 1, k + 1) * a) * b;
+			return level - (bottom * (1 - c) + top * c);
+		};
+	}
+	/** Cut with a solid box so every form closes into a clean, printable object. */
+	shaped() {
+		const { form, field, clip, shell } = this.options;
+		const base = field ?? (form === "data" ? this.volume() : FORMS[form]);
+		const e = .01;
+		const slope = (x, y, z) => {
+			const value = base(x, y, z);
+			return hypot(base(x + e, y, z) - value, base(x, y + e, z) - value, base(x, y, z + e) - value) / e;
+		};
+		const lattice = shell ? Array.from({ length: 216 }, (_, k) => slope((k % 6 - 2.5) / 3, (Math.floor(k / 6) % 6 - 2.5) / 3, (Math.floor(k / 36) - 2.5) / 3)) : [];
+		const steepness = (median(lattice.filter(Number.isFinite)) ?? 1) * .3 || 1;
+		const distance = (x, y, z) => base(x, y, z) / Math.max(slope(x, y, z), steepness);
+		const edge = .9;
+		return (x, y, z) => {
+			const body = shell ? Math.abs(distance(x, y, z)) - .05 : base(x, y, z);
+			const box = Math.max(Math.abs(x) - edge, Math.abs(y) - edge, Math.abs(z) - edge);
+			const cut = clip === "half" ? x * .8 + z * .6 : clip === "octant" ? Math.min(x, y, z) : -Infinity;
+			return Math.max(Math.max(-1, Math.min(1, body)), box, cut);
+		};
+	}
+	build(ctx) {
+		const geometry = IsoSurfaceMesher.mesh(this.shaped(), this.options.shell ? 58 : 44, 1);
+		const heights = geometry.getAttribute("position");
+		const ramp = new ColorRamp(ctx.palette.sequential);
+		const colors = new Float32Array(heights.count * 3);
+		for (let k = 0; k < heights.count; k++) {
+			const color = ramp.at(.2 + .7 * (heights.getY(k) + .9) / 1.8);
+			colors.set([
+				color.r,
+				color.g,
+				color.b
+			], k * 3);
+		}
+		geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
+		const tick = [
+			[-1, ""],
+			[-.5, ""],
+			[0, ""],
+			[.5, ""],
+			[1, ""]
+		];
+		this.box(ctx, {
+			x: tick,
+			y: tick,
+			z: []
+		}, {
+			walls: false,
+			bottom: -1
+		});
+		const group = this.bloom(ctx);
+		this.solid(ctx, geometry, group, () => ({
+			title: this.options.form ?? "field",
+			rows: [["vertices", short(heights.count)]]
+		}));
+	}
+};
+export { ImplicitClip, ImplicitSurface, ImplicitSurfaceForm };

package/dist/charts/threesurfaces/IsoSurfaceMesher.js

@@ -0,0 +1,75 @@
+import { BufferGeometry, Float32BufferAttribute } from "three";
+// src/charts/threesurfaces/IsoSurfaceMesher.ts
+/** Naive surface nets: one vertex per cell the iso-surface crosses, averaged from its edge crossings. Negative is inside. */
+var IsoSurfaceMesher = class {
+	static mesh(field, n, extent = 1) {
+		const at = (k) => -extent + 2 * extent * k / (n - 1);
+		const values = new Float32Array(n * n * n);
+		for (let z = 0, w = 0; z < n; z++) for (let y = 0; y < n; y++) for (let x = 0; x < n; x++, w++) values[w] = field(at(x), at(y), at(z));
+		const stride = [
+			1,
+			n,
+			n * n
+		];
+		const cell = new Int32Array(n * n * n).fill(-1);
+		const positions = [], indices = [];
+		const corners = Array.from({ length: 8 }, (_, c) => [
+			c & 1,
+			c >> 1 & 1,
+			c >> 2 & 1
+		]);
+		const edges = [];
+		for (let a = 0; a < 8; a++) for (const axis of [
+			1,
+			2,
+			4
+		]) if (!(a & axis)) edges.push([a, a | axis]);
+		for (let z = 0; z < n - 1; z++) for (let y = 0; y < n - 1; y++) for (let x = 0; x < n - 1; x++) {
+			const base = x + y * n + z * n * n;
+			const read = (c) => values[base + (c & 1) + (c >> 1 & 1) * n + (c >> 2 & 1) * n * n];
+			let sx = 0, sy = 0, sz = 0, crossings = 0;
+			for (const [a, b] of edges) {
+				const va = read(a), vb = read(b);
+				if (va < 0 === vb < 0) continue;
+				const t = va / (va - vb), ca = corners[a], cb = corners[b];
+				sx += ca[0] + (cb[0] - ca[0]) * t;
+				sy += ca[1] + (cb[1] - ca[1]) * t;
+				sz += ca[2] + (cb[2] - ca[2]) * t;
+				crossings++;
+			}
+			if (!crossings) continue;
+			cell[base] = positions.length / 3;
+			positions.push(at(x + sx / crossings), at(y + sy / crossings), at(z + sz / crossings));
+		}
+		for (let z = 1; z < n - 1; z++) for (let y = 1; y < n - 1; y++) for (let x = 1; x < n - 1; x++) {
+			const base = x + y * n + z * n * n;
+			for (let axis = 0; axis < 3; axis++) {
+				const next = base + stride[axis];
+				const inside = values[base] < 0;
+				if (inside === values[next] < 0) continue;
+				const u = stride[(axis + 1) % 3], v = stride[(axis + 2) % 3];
+				const a = cell[base], b = cell[base - u], c = cell[base - u - v], d = cell[base - v];
+				if (a < 0 || b < 0 || c < 0 || d < 0) continue;
+				if (inside) indices.push(a, b, c, a, c, d);
+				else indices.push(a, c, b, a, d, c);
+			}
+		}
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+		geometry.setIndex(indices);
+		const normals = new Float32Array(positions.length), e = 2 * extent / (n - 1) / 2;
+		for (let k = 0; k < positions.length; k += 3) {
+			const px = positions[k], py = positions[k + 1], pz = positions[k + 2];
+			const nx = field(px + e, py, pz) - field(px - e, py, pz), ny = field(px, py + e, pz) - field(px, py - e, pz), nz = field(px, py, pz + e) - field(px, py, pz - e);
+			const length = Math.hypot(nx, ny, nz) || 1;
+			normals.set([
+				nx / length,
+				ny / length,
+				nz / length
+			], k);
+		}
+		geometry.setAttribute("normal", new Float32BufferAttribute(normals, 3));
+		return geometry;
+	}
+};
+export { IsoSurfaceMesher };

package/dist/charts/threesurfaces/LayeredSurfaces.js

@@ -0,0 +1,178 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { short } from "./GridSurfaceBase.js";
+import { SurfaceBase } from "./SurfaceBase.js";
+import { SurfaceField } from "./SurfaceField.js";
+import { SurfaceGeometry } from "./SurfaceGeometry.js";
+import { CEIL, FLOOR, SurfaceSpace } from "./SurfaceSpace.js";
+import { TubeBatch } from "./TubeBatch.js";
+// src/charts/threesurfaces/LayeredSurfaces.ts
+var LayerArrangement = /* @__PURE__ */ function(LayerArrangement) {
+	LayerArrangement["Exploded"] = "exploded";
+	LayerArrangement["Overlaid"] = "overlaid";
+	LayerArrangement["Stacked"] = "stacked";
+	LayerArrangement["Difference"] = "difference-from-first";
+	return LayerArrangement;
+}({});
+var LayerMark = /* @__PURE__ */ function(LayerMark) {
+	LayerMark["Solid"] = "solid";
+	LayerMark["Lattice"] = "lattice";
+	LayerMark["Rows"] = "rows";
+	return LayerMark;
+}({});
+/** Several surfaces over one floor: for comparing scenarios, or seeing how layers add up. */
+var LayeredSurfaces = class extends SurfaceBase {
+	static meta = {
+		id: "layered-surfaces",
+		name: "Layered surfaces",
+		family: ChartFamily.Comparison,
+		dimension: Dimension.Three,
+		shape: DataShape.Grid,
+		description: "Places several height fields over the same floor, exploded, overlaid, stacked or as differences from the first.",
+		tags: [
+			"multiple surfaces",
+			"scenarios",
+			"stacked surface",
+			"difference"
+		],
+		sample: (seed) => [
+			"Alpha",
+			"Bravo",
+			"Charlie"
+		].map((name, k) => ({
+			name,
+			grid: SampleData.surface(seed + k * 1.9, 36)
+		})),
+		variants: {
+			arrangement: [
+				"exploded",
+				"overlaid",
+				"stacked",
+				"difference-from-first"
+			],
+			mark: [
+				"solid",
+				"lattice",
+				"rows"
+			],
+			links: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			arrangement: "exploded",
+			mark: "solid",
+			links: false,
+			distance: 4.9
+		};
+	}
+	/** A bare grid is a stack of one. */
+	layers() {
+		const { data } = this.options;
+		if (Array.isArray(data)) return data.filter((layer) => layer?.grid);
+		return data ? [{
+			name: "Surface",
+			grid: data
+		}] : [];
+	}
+	table() {
+		return {
+			columns: [
+				"layer",
+				"x",
+				"y",
+				"z"
+			],
+			rows: this.layers().flatMap(({ name, grid }) => {
+				const field = SurfaceField.from(grid);
+				return Array.from(field.z, (z, k) => [
+					name,
+					field.x[k % field.nx],
+					field.y[Math.floor(k / field.nx)],
+					z
+				]);
+			})
+		};
+	}
+	arranged(fields) {
+		const { arrangement } = this.options;
+		const shared = (list) => [Math.min(...list.map((f) => f.zDomain[0])), Math.max(...list.map((f) => f.zDomain[1]))];
+		if (arrangement === "stacked") {
+			let running = null;
+			const stacked = fields.map((field) => {
+				const previous = running;
+				const base = field.zDomain[0];
+				const next = field.map((z, i, j) => z - base + (previous ? previous.sample(i / (field.nx - 1) * (previous.nx - 1), j / (field.ny - 1) * (previous.ny - 1)) + .04 * (previous.zMax - previous.zMin + 1) : 0));
+				running = next;
+				return next;
+			});
+			return {
+				fields: stacked,
+				domain: shared(stacked)
+			};
+		}
+		if (arrangement === "difference-from-first" && fields.length > 1) {
+			const first = fields[0];
+			const delta = fields.slice(1).map((field) => field.map((z, i, j) => z - first.sample(i / (field.nx - 1) * (first.nx - 1), j / (field.ny - 1) * (first.ny - 1))));
+			const [lo, hi] = shared(delta), reach = Math.max(Math.abs(lo), Math.abs(hi));
+			return {
+				fields: delta,
+				domain: [-reach, reach]
+			};
+		}
+		return {
+			fields,
+			domain: shared(fields)
+		};
+	}
+	build(ctx) {
+		const { arrangement, mark, links } = this.options;
+		const layers = this.layers().map(({ name, grid }) => ({
+			name,
+			field: SurfaceField.from(grid).capped(64)
+		}));
+		const names = arrangement === "difference-from-first" && layers.length > 1 ? layers.slice(1).map(({ name }) => name) : layers.map(({ name }) => name);
+		const { fields, domain } = layers.length ? this.arranged(layers.map(({ field }) => field)) : {
+			fields: [],
+			domain: [0, 1]
+		};
+		const reference = fields[0] ?? SurfaceField.empty();
+		const exploded = arrangement === "exploded";
+		const span = (CEIL - FLOOR) / Math.max(1, fields.length);
+		const spaces = fields.map((field, k) => new SurfaceSpace(field, ScaleKind.Linear, exploded ? [FLOOR + k * span + .03, FLOOR + (k + 1) * span - .03] : [FLOOR, CEIL], domain));
+		const whole = new SurfaceSpace(reference, ScaleKind.Linear, [FLOOR, CEIL], domain);
+		const [x0, x1] = reference.xDomain, [y0, y1] = reference.yDomain;
+		this.box(ctx, {
+			x: this.ticks(reference.xDomain, (v) => (v - x0) / (x1 - x0 || 1) * 2 - 1),
+			y: this.ticks(reference.yDomain, (v) => 1 - (v - y0) / (y1 - y0 || 1) * 2),
+			z: exploded ? [] : this.ticks(domain, whole.level, 3)
+		});
+		const lift = this.rise(ctx);
+		fields.forEach((field, k) => {
+			const name = names[k] ?? "", space = spaces[k], color = ctx.color(ctx.palette.color(name));
+			const tip = (v) => ({
+				title: name,
+				color: ctx.palette.color(name),
+				rows: [["z", short(field.at(v % field.nx, Math.floor(v / field.nx)))]]
+			});
+			if (mark === "solid") {
+				this.solid(ctx, SurfaceGeometry.grid(field.nx, field.ny, (i, j) => space.at(i, j), () => color), lift, tip);
+				return;
+			}
+			const batch = new TubeBatch(.0052), stride = Math.max(1, Math.round((field.ny - 1) / (mark === "rows" ? 18 : 12)));
+			for (let j = 0; j < field.ny; j += stride) batch.add(Array.from({ length: field.nx }, (_, i) => space.at(i, j)), color);
+			if (mark === "lattice") for (let i = 0; i < field.nx; i += stride) batch.add(Array.from({ length: field.ny }, (_, j) => space.at(i, j)), color);
+			this.tubes(batch, lift);
+		});
+		if (links && spaces.length > 1) {
+			const stems = new TubeBatch(.0032, 4), lattice = Array.from({ length: 6 }, (_, k) => (k + .5) / 6);
+			for (const v of lattice) for (const u of lattice) {
+				const path = spaces.map((space) => space.at(u * (space.field.nx - 1), v * (space.field.ny - 1)));
+				stems.add(path);
+			}
+			this.tubes(stems, lift, ctx.theme.inkMuted);
+		}
+	}
+};
+export { LayerArrangement, LayerMark, LayeredSurfaces };

package/dist/charts/threesurfaces/MeshSurface.js

@@ -0,0 +1,186 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { GridSurfaceBase } from "./GridSurfaceBase.js";
+import { FLOOR, SurfaceSpace } from "./SurfaceSpace.js";
+import { SurfaceMesh } from "./SurfaceMesh.js";
+import { BufferGeometry, Float32BufferAttribute } from "three";
+// src/charts/threesurfaces/MeshSurface.ts
+var MeshTile = /* @__PURE__ */ function(MeshTile) {
+	MeshTile["Quad"] = "quad";
+	MeshTile["Triangle"] = "triangle";
+	MeshTile["Hexagon"] = "hexagon";
+	MeshTile["Diamond"] = "diamond";
+	return MeshTile;
+}({});
+var MeshPose = /* @__PURE__ */ function(MeshPose) {
+	MeshPose["Tilted"] = "tilted";
+	MeshPose["Level"] = "level";
+	return MeshPose;
+}({});
+var MeshBody = /* @__PURE__ */ function(MeshBody) {
+	MeshBody["Skin"] = "skin";
+	MeshBody["Plate"] = "plate";
+	MeshBody["Column"] = "column";
+	return MeshBody;
+}({});
+/** Tessellated tiles: for a surface where each measured cell should stay a separate, countable object. */
+var MeshSurface = class extends GridSurfaceBase {
+	static meta = {
+		id: "mesh-surface",
+		name: "Mesh surface",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Three,
+		shape: DataShape.Grid,
+		description: "Breaks a height field into separated tiles of quads, triangles, hexagons or diamonds, posed along the slope or level.",
+		tags: [
+			"tessellation",
+			"low poly",
+			"tiles",
+			"faceted"
+		],
+		sample: (seed) => SampleData.surface(seed, 40),
+		variants: {
+			tile: [
+				"quad",
+				"triangle",
+				"hexagon",
+				"diamond"
+			],
+			pose: ["tilted", "level"],
+			body: [
+				"skin",
+				"plate",
+				"column"
+			],
+			cells: [24, 16]
+		},
+		valid: ({ pose, body }) => !(pose === "tilted" && body === "column")
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			tile: "quad",
+			pose: "tilted",
+			body: "skin",
+			cells: 24
+		};
+	}
+	/** Tile outlines in unit grid space, with 2px of surface left between neighbours. */
+	tiles(cells) {
+		const unit = 1 / cells, inset = .04 * unit, tiles = [];
+		const add = (cx, cy, corners) => {
+			const inside = corners.map(([x, y]) => [cx + x, cy + y]);
+			if (inside.every(([x, y]) => x >= -1e-9 && y >= -1e-9 && x <= 1 + 1e-9 && y <= 1 + 1e-9)) tiles.push(inside);
+		};
+		const half = unit / 2 - inset;
+		switch (this.options.tile) {
+			case "triangle": {
+				const r = unit * .97, h = r * Math.sqrt(3) / 2;
+				for (let row = 0; row * h < 1; row++) for (let col = -1; col * r < 1 + r; col++) {
+					const x = col * r + (row % 2 ? r / 2 : 0), y = row * h;
+					add(x + r / 2, y + h / 3, [
+						[-r / 2 + inset * 1.6, -h / 3 + inset],
+						[r / 2 - inset * 1.6, -h / 3 + inset],
+						[0, 2 * h / 3 - inset * 1.8]
+					]);
+					add(x + r, y + 2 * h / 3, [
+						[-r / 2 + inset * 1.6, h / 3 - inset],
+						[0, -2 * h / 3 + inset * 1.8],
+						[r / 2 - inset * 1.6, h / 3 - inset]
+					]);
+				}
+				break;
+			}
+			case "hexagon": {
+				const r = unit * .62, w = r * Math.sqrt(3), rim = r - inset * 1.6;
+				const corners = Array.from({ length: 6 }, (_, k) => [rim * Math.sin(k * Math.PI / 3), rim * Math.cos(k * Math.PI / 3)]);
+				for (let row = 0; row * r * 1.5 < 1 + r; row++) for (let col = 0; col * w < 1 + w; col++) add(col * w + (row % 2 ? w / 2 : 0) + w / 2, row * r * 1.5 + r, corners);
+				break;
+			}
+			case "diamond": {
+				const r = unit * .72, q = r - inset * 1.5;
+				for (let row = 0; row * r < 1 + r; row++) for (let col = 0; col * 2 * r < 1 + r; col++) add(col * 2 * r + (row % 2 ? r : 0) + r, row * r + r, [
+					[0, -q],
+					[q, 0],
+					[0, q],
+					[-q, 0]
+				]);
+				break;
+			}
+			default: for (let row = 0; row < cells; row++) for (let col = 0; col < cells; col++) add((col + .5) * unit, (row + .5) * unit, [
+				[-half, -half],
+				[half, -half],
+				[half, half],
+				[-half, half]
+			]);
+		}
+		return tiles;
+	}
+	build(ctx) {
+		const { pose, body, cells } = this.options;
+		const field = this.field();
+		const space = new SurfaceSpace(field);
+		const paint = this.painter(ctx, field.zDomain);
+		this.box(ctx, this.axes(space));
+		const lift = this.rise(ctx);
+		const fi = (u) => u * (field.nx - 1), fj = (v) => v * (field.ny - 1);
+		const positions = [], colors = [], owners = [];
+		const push = (points, color, owner) => {
+			for (const point of points) {
+				positions.push(...point);
+				colors.push(color.r, color.g, color.b);
+				owners.push(owner);
+			}
+		};
+		const tiles = this.tiles(cells).filter((tile) => tile.every(([u, v]) => !Number.isNaN(field.sample(fi(u), fj(v)))));
+		tiles.forEach((tile, owner) => {
+			const cx = tile.reduce((sum, [u]) => sum + u, 0) / tile.length, cy = tile.reduce((sum, [, v]) => sum + v, 0) / tile.length;
+			const centre = field.sample(fi(cx), fj(cy)), color = paint(centre);
+			const top = tile.map(([u, v]) => pose === "level" ? [...spread(space.ground(fi(u), fj(v)), space.level(centre))] : space.at(fi(u), fj(v)));
+			const hub = pose === "level" ? spread(space.ground(fi(cx), fj(cy)), space.level(centre)) : space.at(fi(cx), fj(cy));
+			top.forEach((point, k) => push([
+				hub,
+				point,
+				top[(k + 1) % top.length]
+			], color, owner));
+			if (body === "skin") return;
+			const low = (point) => [
+				point[0],
+				body === "column" ? FLOOR : point[1] - .05,
+				point[2]
+			];
+			top.forEach((point, k) => {
+				const next = top[(k + 1) % top.length];
+				push([
+					point,
+					low(point),
+					next,
+					next,
+					low(point),
+					low(next)
+				], color, owner);
+			});
+		});
+		const geometry = new BufferGeometry();
+		geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+		geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
+		geometry.computeVertexNormals();
+		const mesh = new SurfaceMesh(geometry, this.material());
+		geometry.userData.source = Uint32Array.from(owners);
+		mesh.castShadow = true;
+		lift.add(mesh);
+		ctx.pick(mesh, (owner) => {
+			const tile = tiles[owner];
+			if (!tile) return {};
+			const [u, v] = [tile.reduce((sum, [a]) => sum + a, 0) / tile.length, tile.reduce((sum, [, b]) => sum + b, 0) / tile.length];
+			const i = Math.round(fi(u)), j = Math.round(fj(v));
+			return this.gridTip(space)(i + j * field.nx);
+		});
+	}
+};
+var spread = ([x, z], y) => [
+	x,
+	y,
+	z
+];
+export { MeshBody, MeshPose, MeshSurface, MeshTile };