cozyclay 3.0.3 → 3.1.1

package/src/sculpt-detail.js

@@ -0,0 +1,207 @@
+/**
+ * Surface detail: a part's `detail` (sculpt-surface-fields.js) turns a smooth
+ * primitive into a lumpy cloud, bush, rock or loaf by pushing its surface out
+ * along the normals with seeded, billowed fBm noise (|fBm|: rounded lumps with
+ * creases between them, which reads as puffs or stone where plain fBm reads as
+ * a dented ball). It is a post-process on any part's
+ * BufferGeometry, so a shape added later gets it without a line of its own.
+ *
+ * - Bounds: the base is shrunk by the bump height first and no vertex then
+ *   moves further than that, so the lumps end inside the declared size and
+ *   the record's measured box (which trusts size) still holds.
+ * - Seams: vertices are welded by position before anything moves, so both
+ *   sides of a sphere's seam (or a box's edge) move together and never split.
+ * - Tessellation: a box or a one-segment cylinder has too few vertices to
+ *   show a bump, so long edges are halved until they are a fraction of a bump.
+ *   The split test reads only the edge, so both triangles on an edge agree
+ *   and no T-junction cracks open once the surface moves.
+ */
+
+import * as THREE from "three";
+import { DETAIL_RELIEF } from "./sculpt-surface-fields.js";
+import { fbm3, isMirrorCopy, partSeed, seededRandom } from "./sculpt-noise.js";
+
+/** A detailed part stops splitting edges past this many triangles. */
+const MAX_TRIANGLES = 40000;
+/** Edges are split until a bump spans about this many of them. */
+const EDGES_PER_BUMP = 5;
+/** Faces meeting more sharply than this stay creased (a box edge); lumps shade smooth. */
+const CREASE_COS = Math.cos((65 * Math.PI) / 180);
+
+/** Vertex → id shared by every vertex at the same position (within `eps`), via
+ * an open-addressed table on the quantized position. */
+function weld(position, eps) {
+	const count = position.length / 3;
+	const ids = new Int32Array(count);
+	let size = 1;
+	while (size < count * 2) size <<= 1;
+	const table = new Int32Array(size).fill(-1);
+	const keys = new Int32Array(count * 3);
+	let unique = 0;
+	for (let i = 0; i < count; i += 1) {
+		const qx = Math.round(position[3 * i] / eps), qy = Math.round(position[3 * i + 1] / eps), qz = Math.round(position[3 * i + 2] / eps);
+		let slot = (Math.imul(qx, 73856093) ^ Math.imul(qy, 19349663) ^ Math.imul(qz, 83492791)) & (size - 1);
+		for (;;) {
+			const id = table[slot];
+			if (id < 0) {
+				table[slot] = unique;
+				keys[3 * unique] = qx; keys[3 * unique + 1] = qy; keys[3 * unique + 2] = qz;
+				ids[i] = unique++;
+				break;
+			}
+			if (keys[3 * id] === qx && keys[3 * id + 1] === qy && keys[3 * id + 2] === qz) {
+				ids[i] = id;
+				break;
+			}
+			slot = (slot + 1) & (size - 1);
+		}
+	}
+	return { ids, count: unique };
+}
+
+/** Local corners per split mask (bit 0 = edge ab, 1 = bc, 2 = ca); 3, 4, 5 are
+ * the midpoints of ab, bc, ca. Every pattern keeps the source winding. */
+const PATTERNS = [
+	[0, 1, 2],
+	[0, 3, 2, 3, 1, 2],
+	[1, 4, 0, 4, 2, 0],
+	[3, 1, 4, 0, 3, 4, 0, 4, 2],
+	[2, 5, 1, 5, 0, 1],
+	[5, 0, 3, 2, 5, 3, 2, 3, 1],
+	[4, 2, 5, 1, 4, 5, 1, 5, 0],
+	[0, 3, 5, 3, 1, 4, 5, 4, 2, 3, 4, 5],
+];
+
+/** Non-indexed attributes ([position, ...others]) with every edge longer
+ * than `maxEdge` halved, pass by pass, within MAX_TRIANGLES. */
+function subdivide(attributes, maxEdge) {
+	const limit = maxEdge * maxEdge;
+	for (let pass = 0; pass < 10; pass += 1) {
+		const position = attributes[0].array;
+		const triangles = position.length / 9;
+		const masks = new Uint8Array(triangles);
+		let next = 0;
+		for (let t = 0; t < triangles; t += 1) {
+			for (let e = 0; e < 3; e += 1) {
+				const a = 9 * t + 3 * e, b = 9 * t + 3 * ((e + 1) % 3);
+				const dx = position[a] - position[b], dy = position[a + 1] - position[b + 1], dz = position[a + 2] - position[b + 2];
+				if (dx * dx + dy * dy + dz * dz > limit) masks[t] |= 1 << e;
+			}
+			next += PATTERNS[masks[t]].length / 3;
+		}
+		if (next === triangles || next > MAX_TRIANGLES) break;
+		attributes = attributes.map(({ name, size, array }) => {
+			const out = new Float64Array(next * 3 * size);
+			let o = 0;
+			for (let t = 0; t < triangles; t += 1) {
+				const base = 3 * t * size;
+				for (const corner of PATTERNS[masks[t]]) {
+					// (a + b) / 2 is the same bits from either side, so neighbours share the midpoint exactly.
+					const a = corner < 3 ? corner : corner - 3, b = corner < 3 ? corner : (corner - 2) % 3;
+					for (let k = 0; k < size; k += 1) out[o++] = (array[base + a * size + k] + array[base + b * size + k]) / 2;
+				}
+			}
+			return { name, size, array: out };
+		});
+	}
+	return attributes;
+}
+
+/** Area-weighted (unnormalized) normal of every triangle. */
+function faceNormals(position) {
+	const normals = new Float64Array(position.length / 3);
+	for (let f = 0; f < position.length; f += 9) {
+		const ax = position[f + 3] - position[f], ay = position[f + 4] - position[f + 1], az = position[f + 5] - position[f + 2];
+		const bx = position[f + 6] - position[f], by = position[f + 7] - position[f + 1], bz = position[f + 8] - position[f + 2];
+		normals[f / 3] = ay * bz - az * by;
+		normals[f / 3 + 1] = az * bx - ax * bz;
+		normals[f / 3 + 2] = ax * by - ay * bx;
+	}
+	return normals;
+}
+
+/** Per-vertex normals: the faces around the welded vertex that meet the
+ * vertex's own face within the crease angle, area-weighted. */
+function creasedNormals(position, ids, count) {
+	const faces = faceNormals(position);
+	const unit = faces.map((value, i) => value / (Math.hypot(faces[i - (i % 3)], faces[i - (i % 3) + 1], faces[i - (i % 3) + 2]) || 1));
+	const start = new Int32Array(count + 1);
+	for (const id of ids) start[id + 1] += 1;
+	for (let id = 0; id < count; id += 1) start[id + 1] += start[id];
+	const fill = start.slice(0, count), around = new Int32Array(ids.length);
+	ids.forEach((id, v) => { around[fill[id]++] = Math.floor(v / 3); });
+	const normals = new Float32Array(position.length);
+	for (let v = 0; v < ids.length; v += 1) {
+		const own = 3 * Math.floor(v / 3);
+		const flat = unit[own] === 0 && unit[own + 1] === 0 && unit[own + 2] === 0;
+		let x = 0, y = 0, z = 0;
+		for (let k = start[ids[v]]; k < start[ids[v] + 1]; k += 1) {
+			const g = 3 * around[k];
+			if (!flat && unit[g] * unit[own] + unit[g + 1] * unit[own + 1] + unit[g + 2] * unit[own + 2] < CREASE_COS) continue;
+			x += faces[g]; y += faces[g + 1]; z += faces[g + 2];
+		}
+		const length = Math.hypot(x, y, z);
+		if (length > 0) normals.set([x / length, y / length, z / length], 3 * v);
+		else normals[3 * v + 1] = 1;
+	}
+	return normals;
+}
+
+/**
+ * The part's geometry with its `detail` applied, or the geometry untouched
+ * when the part has none. The result is non-indexed and keeps every other
+ * attribute (uv, colour), interpolated where edges were split.
+ */
+export function applySculptDetail(geometry, part) {
+	const amount = part.detail?.amount ?? 0;
+	if (!(amount > 0)) return geometry;
+	const half = part.size.map((value) => value / 2);
+	const longest = Math.max(...part.size);
+	const relief = amount * DETAIL_RELIEF * Math.min(...half);
+	geometry.scale(...half.map((h) => (h - relief) / h));
+	const source = geometry.index ? geometry.toNonIndexed() : geometry;
+	const names = ["position", ...Object.keys(source.attributes).filter((name) => name !== "position" && name !== "normal")];
+	let attributes = names.map((name) => ({ name, size: source.attributes[name].itemSize, array: Float64Array.from(source.attributes[name].array) }));
+	geometry.dispose();
+	source.dispose();
+	// Snap every vertex onto its welded twin so split decisions and midpoints match bit for bit.
+	const eps = longest * 1e-5;
+	let { ids, count } = weld(attributes[0].array, eps);
+	const first = new Int32Array(count).fill(-1);
+	ids.forEach((id, v) => {
+		if (first[id] < 0) first[id] = v;
+		else for (let k = 0; k < 3; k += 1) attributes[0].array[3 * v + k] = attributes[0].array[3 * first[id] + k];
+	});
+	attributes = subdivide(attributes, longest / part.detail.scale / EDGES_PER_BUMP);
+	const position = attributes[0].array;
+	({ ids, count } = weld(position, eps));
+	const faces = faceNormals(position);
+	const normal = new Float64Array(count * 3);
+	ids.forEach((id, v) => {
+		const f = 3 * Math.floor(v / 3);
+		for (let k = 0; k < 3; k += 1) normal[3 * id + k] += faces[f + k];
+	});
+	// Noise per welded vertex. A mirrored copy reads it at −x, so it lumps as its source's reflection.
+	const seed = partSeed(part, part.detail.seed);
+	const random = seededRandom(seed);
+	const offset = [random() * 64, random() * 64, random() * 64];
+	const frequency = part.detail.scale / longest, flip = isMirrorCopy(part) ? -1 : 1;
+	const lift = new Float64Array(count).fill(NaN);
+	ids.forEach((id, v) => {
+		if (Number.isNaN(lift[id])) lift[id] = Math.abs(fbm3(flip * position[3 * v] * frequency + offset[0], position[3 * v + 1] * frequency + offset[1], position[3 * v + 2] * frequency + offset[2], seed));
+	});
+	let low = Infinity, high = -Infinity;
+	for (const value of lift) { low = Math.min(low, value); high = Math.max(high, value); }
+	// Rescaled to 0..1, so the highest lump reaches the declared size and the deepest stays on the shrunk base.
+	const span = high - low || 1;
+	ids.forEach((id, v) => {
+		const n = 3 * id, length = Math.hypot(normal[n], normal[n + 1], normal[n + 2]);
+		if (!(length > 0)) return;
+		const push = (relief * (lift[id] - low)) / span / length;
+		for (let k = 0; k < 3; k += 1) position[3 * v + k] += normal[n + k] * push;
+	});
+	const detailed = new THREE.BufferGeometry();
+	for (const { name, size, array } of attributes) detailed.setAttribute(name, new THREE.BufferAttribute(Float32Array.from(array), size));
+	detailed.setAttribute("normal", new THREE.BufferAttribute(creasedNormals(position, ids, count), 3));
+	return detailed;
+}

package/src/sculpt-geometry-loft-convex.js

@@ -0,0 +1,100 @@
+/**
+ * Geometry for the `loft` and `convex` sculpt shapes. The points come from the
+ * pure modules (sculpt-loft-rings.js, sculpt-shapes-loft-convex.js), so the
+ * silhouette compare hulls exactly what is drawn; three.js only skins them.
+ */
+
+import * as THREE from "three";
+import { ConvexGeometry } from "three/examples/jsm/geometries/ConvexGeometry.js";
+import { LoftGeometry } from "three/examples/jsm/geometries/LoftGeometry.js";
+import { loftRings } from "./sculpt-loft-rings.js";
+import { convexPoints } from "./sculpt-shapes-loft-convex.js";
+
+/** An unsmoothed loft keeps edges sharper than this crisp; a rounded corner's
+ * small steps still shade as one curve. */
+const LOFT_CREASE = (40 * Math.PI) / 180;
+
+/**
+ * Normals for a non-indexed mesh: each corner averages the area-weighted
+ * normals of the faces that share its exact position and turn less than
+ * `crease` from its own face. (BufferGeometryUtils.toCreasedNormals hashes
+ * positions to 1 cm, which merges the corners of a small gem.)
+ */
+function creaseNormals(geometry, crease) {
+	const position = geometry.getAttribute("position");
+	const key = (i) => `${position.getX(i)},${position.getY(i)},${position.getZ(i)}`;
+	const a = new THREE.Vector3(), b = new THREE.Vector3(), c = new THREE.Vector3();
+	const faceNormals = [];
+	const facesAt = new Map();
+	for (let f = 0; f < position.count / 3; f += 1) {
+		a.fromBufferAttribute(position, 3 * f);
+		b.fromBufferAttribute(position, 3 * f + 1);
+		c.fromBufferAttribute(position, 3 * f + 2);
+		faceNormals.push(new THREE.Vector3().subVectors(c, b).cross(a.sub(b)));
+		for (let k = 0; k < 3; k += 1) {
+			const at = key(3 * f + k);
+			if (!facesAt.has(at)) facesAt.set(at, []);
+			facesAt.get(at).push(f);
+		}
+	}
+	const limit = Math.cos(crease);
+	const previous = geometry.getAttribute("normal");
+	const normals = new Float32Array(position.count * 3);
+	const own = new THREE.Vector3(), other = new THREE.Vector3(), sum = new THREE.Vector3();
+	for (let i = 0; i < position.count; i += 1) {
+		own.copy(faceNormals[Math.floor(i / 3)]).normalize();
+		sum.set(0, 0, 0);
+		for (const f of facesAt.get(key(i))) if (other.copy(faceNormals[f]).normalize().dot(own) >= limit) sum.add(faceNormals[f]);
+		// A zero-area face has no direction of its own: it keeps the one it had.
+		if (sum.lengthSq() === 0) sum.fromBufferAttribute(previous, i);
+		sum.normalize().toArray(normals, 3 * i);
+	}
+	geometry.setAttribute("normal", new THREE.BufferAttribute(normals, 3));
+}
+
+/** Box-projected uvs per triangle: each facet maps the two axes it faces
+ * most squarely, scaled by size, so a facet's texture is never smeared. */
+function boxUvs(geometry, size) {
+	const position = geometry.getAttribute("position");
+	const uvs = new Float32Array(position.count * 2);
+	const a = new THREE.Vector3(), b = new THREE.Vector3(), c = new THREE.Vector3();
+	for (let f = 0; f < position.count / 3; f += 1) {
+		a.fromBufferAttribute(position, 3 * f);
+		b.fromBufferAttribute(position, 3 * f + 1);
+		c.fromBufferAttribute(position, 3 * f + 2);
+		const n = c.sub(b).cross(a.sub(b));
+		const facing = [Math.abs(n.x), Math.abs(n.y), Math.abs(n.z)];
+		const axis = facing.indexOf(Math.max(...facing));
+		const [u, v] = [[2, 1], [0, 2], [0, 1]][axis];
+		for (let k = 0; k < 3; k += 1) {
+			uvs[(3 * f + k) * 2] = position.getComponent(3 * f + k, u) / size[u] + 0.5;
+			uvs[(3 * f + k) * 2 + 1] = position.getComponent(3 * f + k, v) / size[v] + 0.5;
+		}
+	}
+	geometry.setAttribute("uv", new THREE.BufferAttribute(uvs, 2));
+}
+
+function loftGeometry(part) {
+	const sections = loftRings(part).rings.map((ring) => ring.map(([x, y, z]) => new THREE.Vector3(x, y, z)));
+	const geometry = new LoftGeometry(sections, { capStart: true, capEnd: true });
+	// The caps come last, one vertex per ring point each, and are level (every
+	// section is horizontal). Earcut leaves zero-area slivers between collinear
+	// samples, whose computed normals can be zero, so the caps are set outright.
+	const normal = geometry.getAttribute("normal"), first = normal.count - 2 * sections[0].length;
+	for (let i = first; i < normal.count; i += 1) normal.setXYZ(i, 0, i < first + sections[0].length ? -1 : 1, 0);
+	if (part.smooth) return geometry;
+	const faceted = geometry.toNonIndexed();
+	geometry.dispose();
+	creaseNormals(faceted, LOFT_CREASE);
+	return faceted;
+}
+
+/** ConvexGeometry gives flat facet normals; `facets: false` smooths them all. */
+function convexGeometry(part) {
+	const geometry = new ConvexGeometry(convexPoints(part).map(([x, y, z]) => new THREE.Vector3(x, y, z)));
+	boxUvs(geometry, part.size);
+	if (!part.facets) creaseNormals(geometry, Math.PI);
+	return geometry;
+}
+
+export const LOFT_CONVEX_BUILDERS = Object.freeze({ loft: loftGeometry, convex: convexGeometry });

package/src/sculpt-geometry-shapes.js

@@ -0,0 +1,250 @@
+/**
+ * Geometry for the sculpt shapes that follow points (sculpt-shapes-curved.js):
+ * lathe, tube and extrude, each one indexed mesh with a uv in metres, so a
+ * texture keeps one scale across parts of different sizes.
+ *
+ * Normals are welded per piece: inside a piece, every vertex at one position
+ * shares one normal (a lathe's seam, a tube's round end); between pieces they
+ * stay apart, so a pot's bottom edge and a sign's face edge stay crisp. Like
+ * every sculpt shape, nothing is drawn outside the part's declared size.
+ */
+
+import * as THREE from "three";
+import { signedArea } from "./sculpt-curve.js";
+import { latheRows, tubeCentre, tubeRadii } from "./sculpt-shapes-curved.js";
+
+const AROUND = 48;
+const TUBE_SIDES = 20;
+const CAP_ROWS = 6;
+const BEVEL_ROWS = 4;
+/** An outline corner that turns more than this keeps a hard edge on the side wall. */
+const CREASE = (35 * Math.PI) / 180;
+
+const sub = (a, b) => a.map((value, axis) => value - b[axis]);
+const dot = (a, b) => a.reduce((sum, value, axis) => sum + value * b[axis], 0);
+const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+const unit = (v) => {
+	const length = Math.hypot(...v);
+	return length > 1e-12 ? v.map((value) => value / length) : null;
+};
+const clamp = (value, limit) => Math.min(limit, Math.max(-limit, value));
+
+class Pieces {
+	constructor() {
+		this.position = [];
+		this.uv = [];
+		this.index = [];
+		this.weld = [];
+	}
+
+	/** A rows × cols piece from `at(row, col)` → [x, y, z, u, v]. The column step
+	 * crossed with the row step must point out of the solid. */
+	grid(rows, cols, at) {
+		const keys = new Map();
+		const ids = [];
+		for (let i = 0; i < rows; i += 1) for (let j = 0; j < cols; j += 1) ids.push(this.vertex(keys, at(i, j)));
+		for (let i = 0; i + 1 < rows; i += 1) {
+			for (let j = 0; j + 1 < cols; j += 1) {
+				const a = ids[i * cols + j], b = ids[i * cols + j + 1], c = ids[(i + 1) * cols + j], d = ids[(i + 1) * cols + j + 1];
+				this.index.push(a, b, c, b, d, c);
+			}
+		}
+	}
+
+	/** A flat piece: points [x, y, z, u, v] and triangles over them, wound outward. */
+	fan(points, triangles) {
+		const keys = new Map();
+		const ids = points.map((point) => this.vertex(keys, point));
+		for (const triangle of triangles) this.index.push(...triangle.map((k) => ids[k]));
+	}
+
+	vertex(keys, [x, y, z, u, v]) {
+		const id = this.position.length / 3;
+		const key = `${x},${y},${z}`;
+		if (!keys.has(key)) keys.set(key, id);
+		this.weld.push(keys.get(key));
+		this.position.push(x, y, z);
+		this.uv.push(u, v);
+		return id;
+	}
+
+	/** Area-weighted face normals, summed on each welded position. */
+	build() {
+		const p = this.position, sum = new Float64Array(p.length);
+		for (let t = 0; t < this.index.length; t += 3) {
+			const [a, b, c] = [0, 1, 2].map((k) => this.index[t + k]);
+			const corner = (k) => [p[k * 3], p[k * 3 + 1], p[k * 3 + 2]];
+			const normal = cross(sub(corner(b), corner(a)), sub(corner(c), corner(a)));
+			for (const k of [a, b, c]) for (let axis = 0; axis < 3; axis += 1) sum[this.weld[k] * 3 + axis] += normal[axis];
+		}
+		const normals = new Float32Array(p.length);
+		this.weld.forEach((w, i) => {
+			const n = unit([sum[w * 3], sum[w * 3 + 1], sum[w * 3 + 2]]) ?? [0, 1, 0];
+			normals.set(n, i * 3);
+		});
+		const geometry = new THREE.BufferGeometry();
+		geometry.setAttribute("position", new THREE.Float32BufferAttribute(p, 3));
+		geometry.setAttribute("normal", new THREE.BufferAttribute(normals, 3));
+		geometry.setAttribute("uv", new THREE.Float32BufferAttribute(this.uv, 2));
+		geometry.setIndex(this.index);
+		return geometry;
+	}
+}
+
+/** The profile turned round y with an elliptical section; caps close the ends
+ * that stand off the axis, so a pot has a bottom. */
+export function latheGeometry(part) {
+	const [hx, , hz] = part.size.map((value) => value / 2);
+	const rows = latheRows(part, Math.min(12, Math.ceil(120 / (part.profile.length - 1))));
+	const arc = [0];
+	for (let k = 1; k < rows.length; k += 1) arc.push(arc[k - 1] + Math.hypot(((rows[k][0] - rows[k - 1][0]) * (hx + hz)) / 2, rows[k][1] - rows[k - 1][1]));
+	// `j % AROUND` makes the seam column the very same numbers as the first, so it welds.
+	const ring = ([r, y], j) => {
+		const angle = ((j % AROUND) / AROUND) * 2 * Math.PI;
+		return [r * hx * Math.sin(angle), y, r * hz * Math.cos(angle)];
+	};
+	const mesh = new Pieces();
+	const wall = (from, to) => mesh.grid(to - from + 1, AROUND + 1, (i, j) => [...ring(rows[from + i], j), (j / AROUND) * Math.PI * (hx + hz), arc[from + i]]);
+	if (part.smooth) wall(0, rows.length - 1);
+	else for (let k = 0; k + 1 < rows.length; k += 1) wall(k, k + 1);
+	const cap = (rim, top) => {
+		const order = top ? [rim, [0, rim[1]]] : [[0, rim[1]], rim];
+		mesh.grid(2, AROUND + 1, (i, j) => {
+			const point = ring(order[i], j);
+			return [...point, point[0], point[2]];
+		});
+	};
+	if (rows[0][0] > 0) cap(rows[0], false);
+	if (rows.at(-1)[0] > 0) cap(rows.at(-1), true);
+	return mesh.build();
+}
+
+/** Parallel-transport frames: the ring does not twist where the path bends. On
+ * a loop the leftover twist is spread along it, so the seam meets itself. */
+function tubeFrames(tangents, closed) {
+	const across = (t) => unit(cross(t, Math.abs(t[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0]));
+	let normal = across(tangents[0]);
+	const frames = tangents.map((t) => {
+		normal = unit(sub(normal, t.map((value) => value * dot(normal, t)))) ?? across(t);
+		return [normal, cross(t, normal)];
+	});
+	if (!closed) return frames;
+	const [n0, b0] = frames[0], t0 = tangents[0], last = frames.at(-1)[0];
+	const end = unit(sub(last, t0.map((value) => value * dot(last, t0)))) ?? n0;
+	const twist = Math.atan2(dot(end, b0), dot(end, n0));
+	return frames.map(([n, b], k) => {
+		const angle = (-twist * k) / frames.length;
+		const turned = n.map((value, axis) => Math.cos(angle) * value + Math.sin(angle) * b[axis]);
+		return [turned, cross(tangents[k], turned)];
+	});
+}
+
+/** A round tube along the path; an open one ends in half-balls. */
+export function tubeGeometry(part) {
+	const segments = part.closed ? part.path.length : part.path.length - 1;
+	const centre = tubeCentre(part, Math.min(24, Math.max(4, Math.ceil(128 / segments))));
+	const radii = tubeRadii(part, centre);
+	const n = centre.length;
+	const near = (k) => centre[part.closed ? (k + n) % n : Math.min(n - 1, Math.max(0, k))];
+	let previous = [0, 1, 0];
+	const tangents = centre.map((_, k) => (previous = unit(sub(near(k + 1), near(k - 1))) ?? previous));
+	const frames = tubeFrames(tangents, part.closed);
+	const run = [0];
+	for (let k = 1; k < n; k += 1) run.push(run[k - 1] + Math.hypot(...sub(centre[k], centre[k - 1])));
+	const rows = centre.map((c, k) => ({ c, r: radii[k], frame: frames[k], u: run[k] }));
+	if (part.closed) rows.push({ ...rows[0], u: run[n - 1] + Math.hypot(...sub(centre[0], centre[n - 1])) });
+	else {
+		// Rows of a half-ball from the pole to just short of the end ring.
+		const cap = (k, sign) => Array.from({ length: CAP_ROWS }, (_, i) => {
+			const angle = (((CAP_ROWS - i) / CAP_ROWS) * Math.PI) / 2;
+			const reach = radii[k] * Math.sin(angle);
+			return { c: centre[k].map((value, axis) => value + sign * tangents[k][axis] * reach), r: i ? radii[k] * Math.cos(angle) : 0, frame: frames[k], u: run[k] + sign * reach };
+		});
+		rows.unshift(...cap(0, -1));
+		rows.push(...cap(n - 1, 1).reverse());
+	}
+	const mesh = new Pieces();
+	mesh.grid(rows.length, TUBE_SIDES + 1, (i, j) => {
+		const { c, r, frame: [normal, binormal], u } = rows[i];
+		const angle = ((j % TUBE_SIDES) / TUBE_SIDES) * 2 * Math.PI;
+		const cos = Math.cos(angle), sin = Math.sin(angle);
+		return [...c.map((value, axis) => value + r * (cos * normal[axis] + sin * binormal[axis])), u, (j / TUBE_SIDES) * Math.PI * part.thickness];
+	});
+	return mesh.build();
+}
+
+/** Each corner's inward offset per metre of inset (a mitre, capped at 2× so a
+ * spike cannot shoot far); the solid is on every loop's left. */
+function mitres(loop) {
+	const left = (a, b) => unit([a[1] - b[1], b[0] - a[0]]);
+	return loop.map((p, i) => {
+		const n1 = left(loop[(i + loop.length - 1) % loop.length], p), n2 = left(p, loop[(i + 1) % loop.length]);
+		const m = unit([n1[0] + n2[0], n1[1] + n2[1]]) ?? n1;
+		const scale = 1 / Math.max(0.5, dot(m, n1));
+		return [m[0] * scale, m[1] * scale];
+	});
+}
+
+/** The deepest inset before an edge of the loop turns round, which is where a
+ * thin spike would fold through itself. */
+function insetLimit(loop, offsets) {
+	return loop.reduce((limit, p, i) => {
+		const k = (i + 1) % loop.length, edge = sub(loop[k], p), shrink = dot(sub(offsets[k], offsets[i]), edge);
+		return shrink < 0 ? Math.min(limit, -dot(edge, edge) / shrink) : limit;
+	}, Infinity);
+}
+
+/** The outline pushed through size z, with an optional rounded bevel and holes. */
+export function extrudeGeometry(part) {
+	const [hx, hy, hz] = part.size.map((value) => value / 2);
+	const metres = (loop, ccw) => {
+		const points = loop.map(([x, y]) => [x * part.size[0], y * part.size[1]]);
+		return signedArea(points) > 0 === ccw ? points : points.reverse();
+	};
+	const loops = [metres(part.outline, true), ...(part.holes ?? []).map((hole) => metres(hole, false))];
+	const span = (axis) => Math.max(...loops[0].map((p) => p[axis])) - Math.min(...loops[0].map((p) => p[axis]));
+	const bevel = (part.roundness * Math.min(part.size[2], span(0), span(1))) / 2;
+	const offsets = loops.map(mitres);
+	// Star points and thin arms take a shallower inset than the bevel's depth, so the face never folds.
+	const inset = Math.min(bevel, 0.5 * Math.min(...loops.map((loop, l) => insetLimit(loop, offsets[l]))));
+	// The side's section [inset, z] from the back face round to the front face.
+	const quarter = Array.from({ length: bevel > 0 ? BEVEL_ROWS + 1 : 1 }, (_, i) => {
+		const angle = (i / BEVEL_ROWS) * (Math.PI / 2);
+		return [inset * (1 - Math.sin(angle)), hz - bevel * (1 - Math.cos(angle))];
+	});
+	const back = quarter.map(([offset, z]) => [offset, -z]), front = [...quarter].reverse();
+	const section = back.at(-1)[1] === front[0][1] ? [...back, ...front.slice(1)] : [...back, ...front];
+	// A deep bevel on a thin spike can push a mitre past the outline; the clamp keeps the box honest.
+	const at = (l, i, depth) => [clamp(loops[l][i][0] + offsets[l][i][0] * depth, hx), clamp(loops[l][i][1] + offsets[l][i][1] * depth, hy)];
+	const mesh = new Pieces();
+	loops.forEach((loop, l) => {
+		const n = loop.length;
+		const along = [0];
+		for (let i = 1; i <= n; i += 1) along.push(along[i - 1] + Math.hypot(...sub(loop[i % n], loop[i - 1])));
+		const corners = loop.flatMap((p, i) => {
+			const turn = Math.acos(Math.max(-1, Math.min(1, dot(unit(sub(p, loop[(i + n - 1) % n])), unit(sub(loop[(i + 1) % n], p))))));
+			return turn > CREASE ? [i] : [];
+		});
+		const runs = corners.length ? corners.map((from, k) => [from, k + 1 < corners.length ? corners[k + 1] : corners[0] + n]) : [[0, n]];
+		for (const [from, to] of runs) {
+			mesh.grid(section.length, to - from + 1, (i, j) => {
+				const k = from + j;
+				return [...at(l, k % n, section[i][0]), section[i][1], along[k % n] + (k >= n ? along[n] : 0), section[i][1]];
+			});
+		}
+	});
+	const flat = loops.flatMap((loop, l) => loop.map((_, i) => [l, i]));
+	const vectors = loops.map((loop) => loop.map(([x, y]) => new THREE.Vector2(x, y)));
+	const faces = THREE.ShapeUtils.triangulateShape(vectors[0], vectors.slice(1)).map((face) => {
+		const [a, b, c] = face.map((k) => loops[flat[k][0]][flat[k][1]]);
+		return signedArea([a, b, c]) >= 0 ? face : [face[0], face[2], face[1]];
+	});
+	for (const sign of [1, -1]) {
+		const points = flat.map(([l, i]) => {
+			const [x, y] = at(l, i, inset);
+			return [x, y, sign * hz, x, y];
+		});
+		mesh.fan(points, sign > 0 ? faces : faces.map(([a, b, c]) => [a, c, b]));
+	}
+	return mesh.build();
+}

package/src/sculpt-geometry.js

@@ -12,11 +12,14 @@
 import * as THREE from "three";
 import { RoundedBoxGeometry } from "three/examples/jsm/geometries/RoundedBoxGeometry.js";
 import { expandSculptParts } from "./sculpt-recipe.js";
-
-const CLAY_ROUGHNESS = 0.82;
-/** How far a full taper narrows a blob's end. A blob at 1.0 would come to a
- * point, which reads as a cone; 0.6 keeps a pear a pear. */
-const BLOB_TAPER = 0.6;
+import { BLOB_TAPER } from "./sculpt-shapes.js";
+import { cutSculptGeometry } from "./sculpt-csg.js";
+import { LOFT_CONVEX_BUILDERS } from "./sculpt-geometry-loft-convex.js";
+import { extrudeGeometry, latheGeometry, tubeGeometry } from "./sculpt-geometry-shapes.js";
+import { applySculptDetail } from "./sculpt-detail.js";
+import { applySculptColours } from "./sculpt-colours.js";
+import { scatterMesh } from "./sculpt-scatter.js";
+import { lookMaterial } from "./material-look.js";
 
 /** roundness 0..1 → superellipse exponent 2..8 */
 const blobExponent = (roundness) => 2 + 6 * roundness;
@@ -97,32 +100,44 @@ function frameGeometry(part) {
 	return geometry;
 }
 
-const BUILDERS = { blob: blobGeometry, box: boxGeometry, cylinder: cylinderGeometry, torus: torusGeometry, frame: frameGeometry };
+const BUILDERS = { blob: blobGeometry, box: boxGeometry, cylinder: cylinderGeometry, torus: torusGeometry, frame: frameGeometry, lathe: latheGeometry, tube: tubeGeometry, extrude: extrudeGeometry, ...LOFT_CONVEX_BUILDERS };
+/** Shapes that draw their own mesh (many instances) instead of one geometry. */
+const MESH_BUILDERS = { scatter: scatterMesh };
 
+/** The part's geometry, with its surface `detail` applied. */
 export function sculptPartGeometry(part) {
 	const build = BUILDERS[part.shape];
 	if (!build) throw new Error(`unknown sculpt shape "${part.shape}"`);
-	return build(part);
+	return applySculptDetail(build(part), part);
 }
 
 /**
  * The drawable object for a normalized recipe. `materialFor(part)` lets the
- * caller decide the look (clay, auto-colour, depth rank); the default is the
- * matte clay every primitive wears. Meshes carry their part id as the name and
- * as `userData.sculptPart`, so a capture or a raycast can say which part it hit.
+ * caller decide the look (auto-colour, depth rank); the default is the part's
+ * own preset (material-look.js), clay when it names none, with the part's
+ * gradient and a scatter's per-item tint. Meshes (a scatter's InstancedMesh
+ * too) carry their part id as the name and as `userData.sculptPart`, so a
+ * capture or a raycast can say which part it hit. Glass casts no shadow: light
+ * passes through it.
  */
 export function buildSculptGroup(recipe, { materialFor } = {}) {
 	const group = new THREE.Group();
 	group.userData.sculpt = true;
 	const matrix = new THREE.Matrix4();
-	for (const part of expandSculptParts(recipe)) {
-		const material = materialFor ? materialFor(part) : new THREE.MeshStandardMaterial({ color: part.color, roughness: CLAY_ROUGHNESS, metalness: 0 });
-		const mesh = new THREE.Mesh(sculptPartGeometry(part), material);
+	const parts = expandSculptParts(recipe);
+	for (const part of parts) {
+		// A cutter (op) is never drawn: it cuts its parent's geometry instead.
+		if (part.op) continue;
+		const material = materialFor ? materialFor(part) : lookMaterial(part);
+		// A scatter draws its own InstancedMesh and is never cut; every other part is cut by its cutters.
+		const mesh = MESH_BUILDERS[part.shape]?.(part, material) ?? new THREE.Mesh(cutSculptGeometry(sculptPartGeometry(part), part, parts, sculptPartGeometry), material);
+		// Gradients and scatter tints belong to the shaded look; a flat display mode (materialFor) ignores them.
+		if (!materialFor) applySculptColours(mesh, part);
 		mesh.name = part.id;
 		mesh.userData.sculptPart = part.id;
 		matrix.fromArray(part.matrix);
 		matrix.decompose(mesh.position, mesh.quaternion, mesh.scale);
-		mesh.castShadow = true;
+		mesh.castShadow = !(material.transmission > 0);
 		mesh.receiveShadow = true;
 		group.add(mesh);
 	}
@@ -130,11 +145,14 @@ export function buildSculptGroup(recipe, { materialFor } = {}) {
 }
 
 /** Frees what buildSculptGroup allocated. Materials are disposed too, because
- * buildSculptGroup (or the caller's materialFor) minted one per part. */
+ * buildSculptGroup (or the caller's materialFor) minted one per part; a
+ * scatter's instance buffers go with its InstancedMesh. The preset pattern
+ * textures they sample are shared and stay. */
 export function disposeSculptGroup(group) {
 	group?.traverse((node) => {
 		if (!node.isMesh) return;
 		node.geometry.dispose();
+		if (node.isInstancedMesh) node.dispose();
 		const materials = Array.isArray(node.material) ? node.material : [node.material];
 		for (const material of materials) material.dispose();
 	});