cozyclay 3.1.0 → 3.1.1

package/src/sculpt-scatter-items.js

@@ -0,0 +1,183 @@
+/**
+ * The scatter items (sculpt-scatter-shape.js names them): small closed clay
+ * shapes, each built once and cached; a scatter part draws a clone of one as
+ * an InstancedMesh. Standing items (blade, tuft, flower) are about one unit
+ * tall from y = 0; lying items (leaf, pebble, twig) are about one unit long
+ * and lie on y = 0. All are centred on x = 0, so a reflected copy fits the
+ * same box. Each carries a grey `color` ramp that darkens its foot, so a
+ * field reads with depth (it multiplies the per-item colour in the shaded
+ * look; flat display modes ignore it).
+ *
+ *   stand   true: sized by the part's height on the ground
+ *   tilt    the most an item leans from its surface's normal, in degrees
+ *   cover   size against the spacing `count` leaves (lying items, shells)
+ */
+
+import * as THREE from "three";
+import { mergeGeometries } from "three/examples/jsm/utils/BufferGeometryUtils.js";
+import { fbm3, seededRandom } from "./sculpt-noise.js";
+
+/** `sides` points around (cx, y, cz), ordered so a loft's faces point outward. */
+function ring(sides, rx, rz, y, cx = 0, cz = 0, twist = 0) {
+	const points = [];
+	for (let i = 0; i < sides; i += 1) {
+		const angle = twist + (i / sides) * 2 * Math.PI;
+		points.push([cx + rx * Math.cos(angle), y, cz - rz * Math.sin(angle)]);
+	}
+	return points;
+}
+
+/** A closed tube up through `rings` (bottom capped; a one-point last ring is
+ * a tip), shaded grey by `shade(0 bottom .. 1 top)`. */
+function loft(rings, shade) {
+	const positions = [], colours = [], index = [], starts = [];
+	rings.forEach((points, k) => {
+		starts.push(positions.length / 3);
+		const grey = shade(k / (rings.length - 1));
+		for (const point of points) {
+			positions.push(...point);
+			colours.push(grey, grey, grey);
+		}
+	});
+	for (let k = 0; k + 1 < rings.length; k += 1) {
+		const a = starts[k], b = starts[k + 1], n = rings[k].length;
+		for (let i = 0; i < n; i += 1) {
+			const j = (i + 1) % n;
+			if (rings[k + 1].length === 1) index.push(a + i, a + j, b);
+			else index.push(a + i, a + j, b + j, a + i, b + j, b + i);
+		}
+	}
+	for (let i = 1; i + 1 < rings[0].length; i += 1) index.push(starts[0], starts[0] + i + 1, starts[0] + i);
+	const geometry = new THREE.BufferGeometry();
+	geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+	geometry.setAttribute("color", new THREE.Float32BufferAttribute(colours, 3));
+	geometry.setIndex(index);
+	return geometry;
+}
+
+const footShade = (t) => 0.5 + 0.5 * Math.min(1, t * 1.4);
+
+/** A blade of grass: a flat three-sided spike curving toward +z. */
+function blade() {
+	const rings = [];
+	for (let k = 0; k < 4; k += 1) {
+		const t = k / 4, width = 0.04 * (1 - t) ** 0.7;
+		rings.push(ring(3, width, width * 0.4, t, 0, 0.18 * t * t, Math.PI / 2));
+	}
+	rings.push([[0, 1, 0.18]]);
+	return loft(rings, footShade);
+}
+
+/** Six blades fanned out from one root. */
+function tuft() {
+	const random = seededRandom(0x7a1f);
+	const blades = [];
+	for (let i = 0; i < 6; i += 1) {
+		const one = blade();
+		one.scale(1.3, 0.7 + 0.3 * random(), 1.3);
+		one.rotateX(0.2 + 0.35 * random());
+		one.rotateY((i / 6) * 2 * Math.PI + random() * 0.6);
+		blades.push(one);
+	}
+	return mergeGeometries(blades);
+}
+
+/** A stem with a five-petal head facing +y. */
+function flower() {
+	const stem = loft([ring(4, 0.02, 0.02, 0), ring(4, 0.018, 0.018, 0.45, 0.01, 0.02), ring(4, 0.016, 0.016, 0.8, 0, 0.03)], () => 0.55);
+	const petals = [];
+	for (let i = 0; i < 15; i += 1) {
+		const angle = (i / 15) * 2 * Math.PI, r = 0.24 * (0.7 + 0.3 * Math.cos(5 * angle));
+		petals.push([r * Math.cos(angle), 0.86, 0.03 - r * Math.sin(angle)]);
+	}
+	const head = loft([ring(15, 0.05, 0.05, 0.78, 0, 0.03), petals, ring(15, 0.09, 0.09, 0.93, 0, 0.03), [[0, 0.97, 0.03]]], () => 1);
+	return mergeGeometries([stem, head]);
+}
+
+/** A leaf lying on y = 0: a thin arched lens one unit long along z. */
+function leaf() {
+	const rings = [];
+	for (let k = 0; k < 6; k += 1) {
+		const t = k / 6, half = Math.max(0.015, 0.21 * Math.sin(Math.PI * Math.min(1, 0.15 + t)) ** 0.8);
+		rings.push(ring(6, half, 0.02, t, 0, -0.07 * Math.sin(Math.PI * t)));
+	}
+	rings.push([[0, 1, 0]]);
+	const geometry = loft(rings, (t) => 0.8 + 0.2 * t);
+	geometry.rotateX(Math.PI / 2);
+	return geometry;
+}
+
+/** A flattened, faceted stone; the facets read as gravel. */
+function pebble() {
+	const geometry = new THREE.IcosahedronGeometry(0.5, 1);
+	const position = geometry.getAttribute("position");
+	for (let i = 0; i < position.count; i += 1) {
+		const x = position.getX(i), y = position.getY(i), z = position.getZ(i);
+		const k = 1 + 0.2 * fbm3(x * 2.4 + 3.1, y * 2.4 + 1.7, z * 2.4 + 5.3, 11);
+		position.setXYZ(i, x * k, y * k * 0.5, z * k * 0.8);
+	}
+	geometry.deleteAttribute("uv");
+	geometry.setAttribute("color", new THREE.Float32BufferAttribute(new Array(position.count * 3).fill(1), 3));
+	return geometry;
+}
+
+/** A crooked stick with one side branch, lying along x. */
+function twig() {
+	const stick = (length, radius) => loft(Array.from({ length: 6 }, (_, k) => {
+		const t = k / 5;
+		return ring(5, radius * (1 - 0.5 * t), radius * (1 - 0.5 * t), t * length, 0.04 * Math.sin(t * 7.3), 0.03 * Math.sin(t * 4.1 + 1));
+	}), () => 0.85);
+	const branch = stick(0.35, 0.018);
+	branch.rotateX(-0.7);
+	branch.translate(0, 0.45, 0);
+	const geometry = mergeGeometries([stick(1, 0.03), branch]);
+	geometry.rotateZ(-Math.PI / 2);
+	return geometry;
+}
+
+const ITEMS = {
+	blade: { build: blade, stand: true, tilt: 16, cover: 2.2 },
+	tuft: { build: tuft, stand: true, tilt: 6, cover: 1.4 },
+	flower: { build: flower, stand: true, tilt: 10, cover: 1.4 },
+	leaf: { build: leaf, stand: false, tilt: 18, cover: 1.6 },
+	pebble: { build: pebble, stand: false, tilt: 20, cover: 1 },
+	twig: { build: twig, stand: false, tilt: 5, cover: 2 },
+};
+
+const built = new Map();
+
+/** The item's distinct vertices plus their reflections across x = 0, flat
+ * [x, y, z, ...]: what an item's fit is measured on, so a turned item fits by
+ * its real outline (not its looser box) and its mirrored twin fits too. */
+function outline(geometry) {
+	const position = geometry.getAttribute("position");
+	const seen = new Set(), points = [];
+	for (let i = 0; i < position.count; i += 1) {
+		const x = position.getX(i), y = position.getY(i), z = position.getZ(i);
+		for (const sx of [x, -x]) {
+			const key = `${sx},${y},${z}`;
+			if (!seen.has(key)) {
+				seen.add(key);
+				points.push(sx, y, z);
+			}
+		}
+	}
+	return Float64Array.from(points);
+}
+
+/** The item's cached template ({ geometry, points, stand, tilt, cover });
+ * clone the geometry before handing it to a mesh, which will dispose its own. */
+export function scatterItem(name) {
+	if (!built.has(name)) {
+		const geometry = ITEMS[name].build();
+		geometry.computeBoundingBox();
+		const { min, max } = geometry.boundingBox;
+		// Centred on x, standing on y = 0, a lying item centred on z too.
+		geometry.translate(-(min.x + max.x) / 2, -min.y, ITEMS[name].stand ? 0 : -(min.z + max.z) / 2);
+		geometry.computeVertexNormals();
+		geometry.computeBoundingBox();
+		geometry.computeBoundingSphere();
+		built.set(name, { ...ITEMS[name], geometry, points: outline(geometry) });
+	}
+	return built.get(name);
+}

package/src/sculpt-scatter-shape.js

@@ -0,0 +1,57 @@
+/**
+ * The scatter shape's recipe half (registered in sculpt-shapes.js): `count`
+ * small copies of one item, drawn as ONE instanced mesh by sculpt-scatter.js.
+ * A grass field built from hundreds of cone parts still looked sparse; as one
+ * scatter part it is thousands of blades and counts once toward maxParts
+ * (the whole recipe's items are capped by SCULPT_LIMITS.maxScatterItems).
+ *
+ *   item     blade | tuft | flower stand up; leaf | pebble | twig lie down
+ *   count    1..SCATTER_MAX_COUNT items
+ *   seed     picks another layout of the same items (default 0)
+ *   spread   "ground" (default): items stand on the bottom face of the size
+ *            box, anywhere in its x/z rectangle. Standing items are up to
+ *            size[1] tall; lying items are sized so `count` of them cover
+ *            the rectangle.
+ *            "shell": items sit on the ellipsoid inscribed in the size box,
+ *            facing outward (leaves on a tree crown, flowers on a bush),
+ *            sized so `count` of them cover it.
+ *
+ * Every item is fitted inside the size box. A mirrored copy draws its
+ * source's layout reflected (sculpt-scatter.js), so no `mirror` hook is needed.
+ * Pure: no three.js.
+ */
+
+import { readChoice, readInteger, readSeed } from "./sculpt-recipe-read.js";
+
+export const SCATTER_ITEMS = Object.freeze(["blade", "tuft", "flower", "leaf", "pebble", "twig"]);
+const SCATTER_SPREADS = ["ground", "shell"];
+const SCATTER_MAX_COUNT = 4000;
+
+/** Ground: the box the items fill. Shell: the ellipsoid they cover, as rings. */
+function scatterSamples(part) {
+	const [sx, sy, sz] = part.size.map((value) => value / 2);
+	const points = [];
+	if (part.spread === "ground") {
+		for (const x of [-sx, sx]) for (const y of [-sy, sy]) for (const z of [-sz, sz]) points.push([x, y, z]);
+		return [points];
+	}
+	for (let i = 0; i <= 16; i += 1) {
+		const polar = (i / 16) * Math.PI;
+		for (let j = 0; j < 24; j += 1) {
+			const t = (j / 24) * 2 * Math.PI;
+			points.push([Math.sin(polar) * Math.cos(t) * sx, Math.cos(polar) * sy, Math.sin(polar) * Math.sin(t) * sz]);
+		}
+	}
+	return [points];
+}
+
+export const SCATTER_SHAPE = {
+	keys: ["item", "count", "seed", "spread"],
+	read(raw, part, where) {
+		part.item = readChoice(raw.item, `${where}.item`, undefined, SCATTER_ITEMS);
+		part.count = readInteger(raw.count, `${where}.count`, undefined, 1, SCATTER_MAX_COUNT);
+		part.seed = readSeed(raw.seed, `${where}.seed`);
+		part.spread = readChoice(raw.spread, `${where}.spread`, "ground", SCATTER_SPREADS);
+	},
+	samples: scatterSamples,
+};

package/src/sculpt-scatter.js

@@ -0,0 +1,124 @@
+/**
+ * Scatter geometry: `count` copies of one small item (sculpt-scatter-items.js)
+ * as ONE InstancedMesh, laid out from the part's seed. The contract is in
+ * sculpt-scatter-shape.js.
+ *
+ * - Ground items take a low-discrepancy (R2) spread with a little jitter, so
+ *   a field is even without looking planted in rows.
+ * - Shell items take an area-uniform spread over the ellipsoid, leaning
+ *   further off its normal than ground items so a crown looks leafy, not scaly.
+ * - Every item is fitted inside the size box by its turned vertices: one that
+ *   would poke out is pulled in, one larger than the box is shrunk. The
+ *   record's measured box trusts size, so it holds.
+ * - A mirrored copy is seeded like its source and reflects each item's place
+ *   and turn (position x and the quaternion's y, z), so the pair is symmetric.
+ */
+
+import * as THREE from "three";
+import { scatterItem } from "./sculpt-scatter-items.js";
+import { isMirrorCopy, partSeed, seededRandom } from "./sculpt-noise.js";
+
+const UP = new THREE.Vector3(0, 1, 0);
+const SIDE = new THREE.Vector3(1, 0, 0);
+const DEG = Math.PI / 180;
+/** Extra lean on a shell, in degrees. */
+const SHELL_LEAN = 25;
+/** The R2 sequence's steps (1/g, 1/g² for the plastic number g). */
+const R2 = [0.7548776662466927, 0.5698402909980532];
+
+/** Surface area of an ellipsoid (Knud Thomsen, within about 1%). */
+function ellipsoidArea(a, b, c) {
+	const p = 1.6075;
+	return 4 * Math.PI * (((a * b) ** p + (a * c) ** p + (b * c) ** p) / 3) ** (1 / p);
+}
+
+/** A point on the ellipsoid with semi-axes `axes`, area-uniform, and its outward normal. */
+function shellPoint(axes, random, point, normal) {
+	const [a, b, c] = axes, least = Math.min(a, b, c);
+	for (let tries = 0; ; tries += 1) {
+		const y = random() * 2 - 1, angle = random() * 2 * Math.PI, r = Math.sqrt(1 - y * y);
+		const dx = r * Math.cos(angle), dz = r * Math.sin(angle);
+		normal.set(dx / a, y / b, dz / c);
+		// Stretching a sphere into an ellipsoid stretches area by |normal| · abc; keep points in proportion.
+		if (random() <= normal.length() * least || tries >= 32) {
+			point.set(dx * a, y * b, dz * c);
+			normal.normalize();
+			return;
+		}
+	}
+}
+
+/** The box (low, high per axis) of `points` turned by `q` and scaled, around the item's origin. */
+function turnedExtent(points, q, scale, low, high) {
+	low.fill(Infinity);
+	high.fill(-Infinity);
+	// Quaternion rotation written out: this runs for every vertex of every item.
+	const { x: qx, y: qy, z: qz, w: qw } = q;
+	for (let i = 0; i < points.length; i += 3) {
+		const x = points[i], y = points[i + 1], z = points[i + 2];
+		const tx = 2 * (qy * z - qz * y), ty = 2 * (qz * x - qx * z), tz = 2 * (qx * y - qy * x);
+		const rx = (x + qw * tx + qy * tz - qz * ty) * scale, ry = (y + qw * ty + qz * tx - qx * tz) * scale, rz = (z + qw * tz + qx * ty - qy * tx) * scale;
+		if (rx < low[0]) low[0] = rx;
+		if (rx > high[0]) high[0] = rx;
+		if (ry < low[1]) low[1] = ry;
+		if (ry > high[1]) high[1] = ry;
+		if (rz < low[2]) low[2] = rz;
+		if (rz > high[2]) high[2] = rz;
+	}
+}
+
+export function scatterMesh(part, material) {
+	const item = scatterItem(part.item);
+	const mesh = new THREE.InstancedMesh(item.geometry.clone(), material, part.count);
+	const half = part.size.map((value) => value / 2);
+	const random = seededRandom(partSeed(part, part.seed));
+	const shell = part.spread === "shell";
+	const { min, max } = item.geometry.boundingBox;
+	const height = max.y - min.y, length = Math.max(max.x - min.x, max.z - min.z);
+	const points = item.points;
+	const spacing = Math.sqrt((shell ? ellipsoidArea(...half) : part.size[0] * part.size[2]) / part.count);
+	const nominal = !shell && item.stand ? part.size[1] / height : (item.cover * spacing) / (item.stand ? height : length);
+	const lean = (item.tilt + (shell ? SHELL_LEAN : 0)) * DEG;
+	// Shell anchors sit inside the ellipsoid by about an item's outward reach, so the items end near its surface.
+	const outward = nominal * (item.stand ? height : height + 0.5 * length * Math.sin(lean)) * 0.85;
+	const axes = half.map((h) => Math.max(h - outward, h * 0.35));
+	const start = [random(), random()], jitter = 0.35 / Math.sqrt(part.count);
+	const point = new THREE.Vector3(), up = new THREE.Vector3();
+	const tilt = new THREE.Quaternion(), spin = new THREE.Quaternion(), turn = new THREE.Quaternion();
+	const matrix = new THREE.Matrix4(), scaled = new THREE.Vector3();
+	const low = [0, 0, 0], high = [0, 0, 0], bounds = new THREE.Box3();
+	for (let i = 0; i < part.count; i += 1) {
+		if (shell) shellPoint(axes, random, point, up);
+		else {
+			const u = (start[0] + i * R2[0]) % 1 + (random() - 0.5) * jitter, v = (start[1] + i * R2[1]) % 1 + (random() - 0.5) * jitter;
+			point.set((u - 0.5) * part.size[0], -half[1], (v - 0.5) * part.size[2]);
+			up.copy(UP);
+		}
+		let scale = nominal * (0.6 + 0.4 * random());
+		spin.setFromAxisAngle(UP, random() * 2 * Math.PI);
+		tilt.setFromAxisAngle(SIDE, random() * lean);
+		turn.setFromUnitVectors(UP, up).multiply(tilt).multiply(spin);
+		turnedExtent(points, turn, scale, low, high);
+		const fit = Math.min(1, ...half.map((h, axis) => (2 * h * 0.999) / (high[axis] - low[axis])));
+		scale *= fit;
+		for (let axis = 0; axis < 3; axis += 1) {
+			const lo = low[axis] * fit, hi = high[axis] * fit;
+			// Ground items stand on the bottom face; everything else is pulled inside the box.
+			const value = !shell && axis === 1 ? -half[1] - lo : THREE.MathUtils.clamp(point.getComponent(axis), -half[axis] - lo, half[axis] - hi);
+			point.setComponent(axis, value);
+			bounds.min.setComponent(axis, Math.min(bounds.min.getComponent(axis), value + lo));
+			bounds.max.setComponent(axis, Math.max(bounds.max.getComponent(axis), value + hi));
+		}
+		if (isMirrorCopy(part)) {
+			point.x = -point.x;
+			turn.set(turn.x, -turn.y, -turn.z, turn.w);
+		}
+		mesh.setMatrixAt(i, matrix.compose(point, turn, scaled.setScalar(scale)));
+	}
+	mesh.instanceMatrix.needsUpdate = true;
+	// The fitted outline, not three's box-of-boxes (which turns each item's box and overshoots size).
+	if (isMirrorCopy(part)) [bounds.min.x, bounds.max.x] = [-bounds.max.x, -bounds.min.x];
+	mesh.boundingBox = bounds;
+	mesh.boundingSphere = bounds.getBoundingSphere(new THREE.Sphere());
+	return mesh;
+}

package/src/sculpt-shapes-curved.js

@@ -0,0 +1,211 @@
+/**
+ * The sculpt shapes that follow points (SCULPT_SHAPE_SPECS entries, same
+ * contract as sculpt-shapes.js). Pure: no three.js.
+ *
+ *   lathe    profile [[r, y]] turned round the part's y axis: vase, pot, bottle
+ *   tube     a round tube swept along path [[x, y, z]]: rope, vine, frame tube
+ *   extrude  a flat outline [[x, y]] pushed through size z: sign, leaf, gable
+ *
+ * Every point is a fraction of the part's size, so `size` stays the box the
+ * record trusts: a tube's centreline is drawn in the box shrunk by its
+ * thickness, and the curves never overshoot their points (sculpt-curve.js).
+ */
+
+import { RecipeError, isFiniteNumber, readUnit, tidy } from "./sculpt-recipe-read.js";
+import { earClip, insideLoop, loopCrossing, monotoneCurve, signedArea } from "./sculpt-curve.js";
+
+/** The thinnest tube: the same floor as a part's extent (SCULPT_LIMITS.minExtent). */
+const MIN_THICKNESS = 0.005;
+const RING = 24;
+const half = (part) => part.size.map((value) => value / 2);
+
+function readFlag(value, path, fallback) {
+	if (value === undefined) return fallback;
+	if (typeof value !== "boolean") throw new RecipeError(path, `must be true or false, got ${JSON.stringify(value)}`);
+	return value;
+}
+
+/** A fresh list of points, each `label`-shaped with every component in [lo, hi]. */
+function readPoints(value, path, label, [min, max], [lo, hi]) {
+	if (!Array.isArray(value) || value.length < min || value.length > max) {
+		throw new RecipeError(path, `must be a list of ${min}-${max} points ${label}, got ${Array.isArray(value) ? `${value.length} points` : JSON.stringify(value)}`);
+	}
+	const dims = label.split(",").length;
+	return value.map((point, i) => {
+		if (!Array.isArray(point) || point.length !== dims || !point.every(isFiniteNumber)) {
+			throw new RecipeError(`${path}[${i}]`, `must be ${dims} numbers ${label}, got ${JSON.stringify(point)}`);
+		}
+		point.forEach((component, axis) => {
+			if (component < lo || component > hi) throw new RecipeError(`${path}[${i}][${axis}]`, `must be from ${lo} to ${hi}, got ${component}`);
+		});
+		return point.map(tidy);
+	});
+}
+
+/** An outline or hole: x and y as fractions of size, any winding, no repeated point. */
+function readLoop(value, path, counts) {
+	const loop = readPoints(value, path, "[x, y]", counts, [-0.5, 0.5]);
+	loop.forEach(([x, y], i) => {
+		const [px, py] = loop[(i + loop.length - 1) % loop.length];
+		if (x === px && y === py) throw new RecipeError(`${path}[${i}]`, i ? "repeats the point before it" : "repeats the last point; the loop closes by itself");
+	});
+	return loop;
+}
+
+/* ------------------------------------------------------------- lathe ---- */
+
+/** The drawn profile: [r fraction, y metres from the part's centre]. */
+export function latheRows(part, steps) {
+	const rows = part.smooth ? monotoneCurve(part.profile, steps) : part.profile;
+	return rows.map(([r, y]) => [r, (y - 0.5) * part.size[1]]);
+}
+
+/** Rings on the drawn profile, one hull per band, so a vase keeps its neck. */
+function latheSamples(part) {
+	const [hx, , hz] = half(part);
+	const rings = latheRows(part, Math.ceil(24 / (part.profile.length - 1))).map(([r, y]) => Array.from({ length: RING }, (_, j) => {
+		const angle = (j / RING) * 2 * Math.PI;
+		return [r * hx * Math.sin(angle), y, r * hz * Math.cos(angle)];
+	}));
+	return rings.slice(1).map((ring, k) => [...rings[k], ...ring]);
+}
+
+const lathe = {
+	keys: ["profile", "smooth"],
+	read(raw, part, where) {
+		const profile = readPoints(raw.profile, `${where}.profile`, "[r, y]", [3, 32], [0, 1]);
+		profile.forEach(([, y], i) => {
+			if (i && y < profile[i - 1][1]) throw new RecipeError(`${where}.profile[${i}][1]`, `y must not go down the profile (${y} after ${profile[i - 1][1]}); list it from bottom (0) to top (1)`);
+		});
+		if (profile.at(-1)[1] === profile[0][1]) throw new RecipeError(`${where}.profile`, "must climb: the last y must be above the first");
+		if (profile.every(([r]) => r === 0)) throw new RecipeError(`${where}.profile`, "has every r at 0, so nothing would be drawn");
+		part.profile = profile;
+		part.smooth = readFlag(raw.smooth, `${where}.smooth`, true);
+	},
+	samples: latheSamples,
+};
+
+/* -------------------------------------------------------------- tube ---- */
+
+/** The path's points in metres: the box shrunk by the thickness, so the round wall fits. */
+const tubeKnots = (part) => part.path.map((point) => point.map((value, axis) => value * (part.size[axis] - part.thickness)));
+
+export const tubeCentre = (part, steps) => monotoneCurve(tubeKnots(part), steps, part.closed);
+
+/** Radius at each centreline sample; taper runs by length, so uneven points taper evenly. */
+export function tubeRadii(part, centre) {
+	const radius = part.thickness / 2;
+	if (!part.taper) return centre.map(() => radius);
+	const run = [0];
+	for (let k = 1; k < centre.length; k += 1) run.push(run[k - 1] + Math.hypot(...centre[k].map((value, axis) => value - centre[k - 1][axis])));
+	return run.map((length) => {
+		const s = length / run.at(-1);
+		return radius * (1 - Math.max(0, part.taper) * s - Math.max(0, -part.taper) * (1 - s));
+	});
+}
+
+/** 26 unit directions (a cube's faces, edges and corners): a ball the hull can trace. */
+const BALL = [];
+for (const x of [-1, 0, 1]) for (const y of [-1, 0, 1]) for (const z of [-1, 0, 1]) {
+	const length = Math.hypot(x, y, z);
+	if (length) BALL.push([x / length, y / length, z / length]);
+}
+
+/** One hull per segment between path points, so a U-shaped rope stays open inside. */
+function tubeSamples(part) {
+	const steps = 4;
+	const centre = tubeCentre(part, steps);
+	const radii = tubeRadii(part, centre);
+	const segments = part.closed ? part.path.length : part.path.length - 1;
+	return Array.from({ length: segments }, (_, segment) => {
+		const points = [];
+		for (let i = segment * steps; i <= (segment + 1) * steps; i += 1) {
+			const k = i % centre.length;
+			for (const direction of BALL) points.push(centre[k].map((value, axis) => value + direction[axis] * radii[k]));
+		}
+		return points;
+	});
+}
+
+const tube = {
+	keys: ["path", "thickness", "taper", "closed"],
+	read(raw, part, where) {
+		part.path = readPoints(raw.path, `${where}.path`, "[x, y, z]", [2, 32], [-0.5, 0.5]);
+		const smallest = Math.min(...part.size);
+		if (!isFiniteNumber(raw.thickness) || raw.thickness < MIN_THICKNESS || raw.thickness > smallest) {
+			throw new RecipeError(`${where}.thickness`, `must be the tube's diameter in metres, from ${MIN_THICKNESS} to the part's smallest size (${tidy(smallest)} m), got ${JSON.stringify(raw.thickness)}`);
+		}
+		part.thickness = tidy(raw.thickness);
+		part.taper = readUnit(raw.taper, `${where}.taper`, 0, -1, 1);
+		part.closed = readFlag(raw.closed, `${where}.closed`, false);
+		if (part.closed && part.taper) throw new RecipeError(`${where}.taper`, "a closed tube cannot taper: its two ends meet");
+		if (part.closed && part.path.length < 3) throw new RecipeError(`${where}.path`, "a closed tube needs at least 3 points");
+		const knots = tubeKnots(part);
+		knots.forEach((point, i) => {
+			if (!i && !part.closed) return;
+			const before = knots[(i + knots.length - 1) % knots.length];
+			if (Math.hypot(...point.map((value, axis) => value - before[axis])) < 1e-6) {
+				throw new RecipeError(`${where}.path[${i}]`, i ? "sits on the point before it once fitted to the size" : "repeats the last point; a closed path joins its ends by itself");
+			}
+		});
+	},
+	mirror(copy) {
+		copy.path = copy.path.map(([x, y, z]) => [tidy(-x), y, z]);
+	},
+	samples: tubeSamples,
+};
+
+/* ----------------------------------------------------------- extrude ---- */
+
+/** One prism per ear-clipped triangle of the outline. The bevel is ignored. */
+function extrudeSamples(part) {
+	const [w, h, d] = part.size;
+	return earClip(part.outline).map((triangle) => triangle.flatMap((k) => {
+		const [x, y] = part.outline[k];
+		return [[x * w, y * h, d / 2], [x * w, y * h, -d / 2]];
+	}));
+}
+
+/** The compare cuts one opening: the largest hole, as its convex hull. */
+function extrudeHole(part) {
+	if (!part.holes) return null;
+	const largest = part.holes.reduce((best, hole) => (Math.abs(signedArea(hole)) > Math.abs(signedArea(best)) ? hole : best));
+	return largest.map(([x, y]) => [x * part.size[0], y * part.size[1], 0]);
+}
+
+const flipX = (loop) => loop.map(([x, y]) => [tidy(-x), y]);
+
+const extrude = {
+	keys: ["outline", "holes", "roundness"],
+	read(raw, part, where) {
+		part.outline = readLoop(raw.outline, `${where}.outline`, [3, 64]);
+		if (raw.holes !== undefined && (!Array.isArray(raw.holes) || raw.holes.length > 4)) {
+			throw new RecipeError(`${where}.holes`, `must be a list of at most 4 hole outlines, got ${JSON.stringify(raw.holes).slice(0, 60)}`);
+		}
+		const holes = (raw.holes ?? []).map((hole, i) => readLoop(hole, `${where}.holes[${i}]`, [3, 32]));
+		const names = [`${where}.outline`, ...holes.map((_, i) => `${where}.holes[${i}]`)];
+		const crossing = loopCrossing([part.outline, ...holes]);
+		if (crossing) {
+			const { a, b } = crossing;
+			const other = a.loop === b.loop ? "another of its edges" : `${names[b.loop]} (edge ${b.edge})`;
+			throw new RecipeError(names[a.loop], `edge ${a.edge} (point ${a.edge} to the next) touches or crosses ${other}; an outline must not cross itself or its holes`);
+		}
+		[part.outline, ...holes].forEach((loop, i) => {
+			if (Math.abs(signedArea(loop)) < 1e-5) throw new RecipeError(names[i], "encloses no area");
+		});
+		holes.forEach((hole, i) => {
+			if (!insideLoop(hole[0], part.outline)) throw new RecipeError(names[i + 1], "must lie inside the outline");
+			if (holes.some((other, j) => j !== i && insideLoop(hole[0], other))) throw new RecipeError(names[i + 1], "must not lie inside another hole");
+		});
+		if (holes.length) part.holes = holes;
+		part.roundness = readUnit(raw.roundness, `${where}.roundness`, 0.1, 0, 1);
+	},
+	mirror(copy) {
+		copy.outline = flipX(copy.outline);
+		if (copy.holes) copy.holes = copy.holes.map(flipX);
+	},
+	samples: extrudeSamples,
+	hole: extrudeHole,
+};
+
+export const CURVED_SHAPE_SPECS = Object.freeze({ lathe, tube, extrude });