@logomarks/logo3d 0.0.0-stage → 0.1.0

package/src/geometry/index.d.ts

@@ -0,0 +1,114 @@
+import type { LogoShape, Ring2, Polygon2 } from '../shape/index.js';
+
+/** An edge profile's name. */
+export type ProfileKind = 'flat' | 'chamfer' | 'round' | 'pillow';
+/** Which part of the logo a draw group is. */
+export type Part = 'face' | 'side' | 'back';
+
+/** How a logo is extruded. */
+export interface GeometryOptions {
+	/** The edge: `'flat'`, `'chamfer'`, `'round'` (the default) or `'pillow'`. */
+	profile?: ProfileKind;
+	/** The depth, as a share of the longest side (0.14). */
+	depth?: number;
+	/** The bevel, 0–1: a share of the most the logo takes (0.6). */
+	bevel?: number;
+	/** Segments in each curve of a round (5) or pillow (8) edge. */
+	segments?: number;
+}
+
+/** One draw group: a layer's face, side or back. */
+export interface Group {
+	start: number;
+	count: number;
+	layer: number;
+	part: Part;
+	/** `layer * 3` plus 0 (face), 1 (side) or 2 (back). */
+	materialIndex: number;
+}
+
+/** A built geometry: typed arrays ready to post from a worker and wrap in a BufferGeometry. */
+export interface LogoGeometry {
+	position: Float32Array;
+	normal: Float32Array;
+	uv: Float32Array;
+	index: Uint32Array;
+	groups: Group[];
+	bounds: { min: [number, number, number]; max: [number, number, number] };
+	/** The bevel's width as built (capped, and cut back if a level crossed itself). */
+	bevel: number;
+	depth: number;
+	profile: string;
+	triangles: number;
+}
+
+/** A point of an edge profile. */
+export interface ProfilePoint {
+	inset: number;
+	z: number;
+}
+/** An edge profile, back to front. */
+export interface Profile {
+	points: ProfilePoint[];
+	smooth: boolean;
+}
+
+/** The geometry's defaults. */
+export const GEOMETRY_DEFAULTS: Readonly<{ profile: ProfileKind; depth: number; bevel: number }>;
+/** The profiles. */
+export const PROFILES: readonly ProfileKind[];
+/** The parts, in draw order within a layer. */
+export const PARTS: readonly Part[];
+
+/** A logo's geometry. Pure and deterministic. */
+export function buildGeometry(shape: LogoShape, o?: GeometryOptions): LogoGeometry;
+/** Every polygon made ready to inset, the bevel cut back while any deepest level crosses itself. */
+export function prepareInsets(shape: LogoShape, bevel: number): { bevel: number; polys: { pg: Polygon2; levels: Map<number, Ring2[]>; inset: (d: number) => Ring2[] }[][] };
+/** A profile's points. */
+export function profile(kind: string, o: { depth: number; bevel: number; segments?: number }): Profile;
+/** Each profile point's shading normal, and each segment's rows. */
+export function profileRows(p: Profile): { rows: { k: number; n: [number, number] }[]; bands: [number, number][] };
+/** The bevel's width for a look. */
+export function bevelWidth(kind: string, o: { depth: number; bevel: number; halfStroke: number }): number;
+/** Prepares a polygon for insetting to any depth up to `reach`. */
+export function insetter(rings: readonly (readonly (readonly number[])[])[], reach: number): (d: number) => Ring2[];
+/** A polygon moved inwards by `d`, point for point. */
+export function insetPolygon(rings: readonly (readonly (readonly number[])[])[], d: number): Ring2[];
+/** One ring moved inwards by `d`, point for point. */
+export function insetRing(r: readonly (readonly number[])[], d: number): Ring2;
+/** Each edge's unit normal into the solid. */
+export function edgeNormals(r: readonly (readonly number[])[]): [number, number][];
+/** Each point's direction inwards: the bisector of the solid's angle, looking `span` along the ring each way. */
+export function pointNormals(r: readonly (readonly number[])[], span?: number): [number, number][];
+/** The distance from a point to a polygon's outline, up to `reach`. */
+export function outlineDistance(rings: readonly (readonly (readonly number[])[])[], reach: number): (x: number, y: number) => number;
+/** How far a point travels along a direction to be `d` from the outline, and whether it stopped short. */
+export function travel(dist: (x: number, y: number) => number, p: readonly number[], m: readonly number[], d: number): { t: number; short: boolean };
+/** Closes each run of points that stopped short to the corner where the level's sides meet. */
+export function closeShort(r: readonly (readonly number[])[], p: [number, number][], short: boolean[], d: number, fits?: (q: [number, number]) => boolean): [number, number][];
+/** Where two lines meet, or null when parallel. */
+export function lineMeet(a: readonly number[], u: readonly number[], b: readonly number[], v: readonly number[]): [number, number] | null;
+/** Whether a point is inside a polygon (even-odd). */
+export function inside(rings: readonly (readonly (readonly number[])[])[], q: readonly number[]): boolean;
+/** Merges points wherever an inset edge turned over. */
+export function mergeTurned(r: readonly (readonly number[])[], p: [number, number][]): [number, number][];
+/** The first pair of crossing edges among some rings, or null. */
+export function firstCrossing(rings: readonly (readonly (readonly number[])[])[], o?: { cells?: number }): { a: [number, number]; b: [number, number] } | null;
+/** Whether two segments cross properly. */
+export function segmentsCross(a: readonly number[], b: readonly number[], c: readonly number[], d: readonly number[]): boolean;
+/** Triangles over a polygon's rings (earcut). */
+export function triangulate(rings: [number, number][][]): { flat: number[]; tris: number[] };
+/** A ring's side columns: one per point along curves, two at hard corners. */
+export function columns(r: readonly (readonly number[])[]): { cols: { i: number; n: [number, number]; u: number }[]; edges: [number, number][] };
+/** A growing indexed mesh. */
+export class MeshBuffer {
+	position: number[];
+	normal: number[];
+	uv: number[];
+	begin(layer: number, part: Part): void;
+	vertex(x: number, y: number, z: number, nx: number, ny: number, nz: number, u: number, v: number): number;
+	triangle(a: number, b: number, c: number): void;
+	pack(): { position: Float32Array; normal: Float32Array; uv: Float32Array; index: Uint32Array; groups: Group[] };
+}
+/** Whether two segments meet at all (crossing, touching or overlapping). */
+export function segmentsMeet(a: readonly number[], b: readonly number[], c: readonly number[], d: readonly number[]): boolean;

package/src/geometry/index.js

@@ -0,0 +1,112 @@
+/**
+ * @module @logomarks/logo3d/geometry
+ *
+ * A logo's shape extruded: for every polygon of every colour layer, its rings inset to each point of the edge
+ * profile, the sides banded between those levels, and the front and back faces triangulated at the face's inset.
+ * The bevel is capped below half the thinnest stroke, so no level crosses itself. The result is plain typed arrays
+ * (positions, normals, UVs, indices) with one draw group per layer and part (face, side, back), centred on the
+ * origin in depth: ready to post from a worker and wrap in a three.js BufferGeometry. Pure and deterministic.
+ */
+
+import { MeshBuffer } from './buffer.js';
+import { addCap } from './caps.js';
+import { addSide } from './sides.js';
+import { insetter } from './inset.js';
+import { firstCrossing } from './check.js';
+import { bevelWidth, profile, profileRows } from './profiles.js';
+
+export { PROFILES, profile, profileRows, bevelWidth } from './profiles.js';
+export { insetter, insetPolygon, insetRing, edgeNormals, pointNormals, outlineIndex, outlineDistance, travel, closeShort, lineMeet, inside, mergeTurned } from './inset.js';
+export { firstCrossing, segmentsCross, segmentsMeet } from './check.js';
+export { triangulate } from './caps.js';
+export { columns } from './sides.js';
+export { MeshBuffer, PARTS } from './buffer.js';
+
+/** The geometry's defaults. */
+export const GEOMETRY_DEFAULTS = Object.freeze({ profile: 'round', depth: 0.14, bevel: 0.6 });
+
+/**
+ * The box round a shape's outlines, for face UVs.
+ *
+ * @param {import('../shape/index.js').LogoShape} shape The shape.
+ * @returns {{ x0: number, y0: number, size: number }} Its corner and longest side.
+ */
+function uvBox(shape) {
+	return { x0: -shape.width / 2, y0: -shape.height / 2, size: Math.max(shape.width, shape.height) || 1 };
+}
+
+/**
+ * Every polygon of every layer made ready to inset up to the bevel, the bevel cut back (by 0.7 a try, up to three tries)
+ * while any polygon's deepest level crosses itself: a wall thinner than the cap's raster can see (a hairline between
+ * a hole and the outline) is the only way that happens.
+ *
+ * @param {import('../shape/index.js').LogoShape} shape The shape.
+ * @param {number} bevel The bevel wanted.
+ * @returns {{ bevel: number, polys: { pg: [number, number][][], levels: Map<number, [number, number][][]>, inset: (d: number) => [number, number][][] }[][] }}
+ *   The bevel that holds, and each layer's polygons with their deepest level worked out.
+ */
+export function prepareInsets(shape, bevel) {
+	for (let tries = 0; ; tries++) {
+		const polys = shape.layers.map((l) =>
+			l.polygons.map((pg) => {
+				const inset = insetter(pg, bevel);
+				return { pg, inset, levels: new Map([[bevel, inset(bevel)]]) };
+			}),
+		);
+		const crossed = bevel > 0 && polys.some((ps) => ps.some((p) => firstCrossing(/** @type {[number, number][][]} */ (p.levels.get(bevel)))));
+		if (!crossed || tries >= 3) return { bevel, polys };
+		bevel *= 0.7;
+	}
+}
+
+/**
+ * A logo's geometry.
+ *
+ * @param {import('../shape/index.js').LogoShape} shape The shape (`readLogo`).
+ * @param {import('./index.js').GeometryOptions} [o] The profile, depth and bevel.
+ * @returns {import('./index.js').LogoGeometry} The geometry.
+ */
+export function buildGeometry(shape, o = {}) {
+	const kind = o.profile ?? GEOMETRY_DEFAULTS.profile;
+	const depth = o.depth ?? GEOMETRY_DEFAULTS.depth;
+	const prepared = prepareInsets(shape, bevelWidth(kind, { depth, bevel: o.bevel ?? GEOMETRY_DEFAULTS.bevel, halfStroke: shape.halfStroke }));
+	const bevel = prepared.bevel;
+	const prof = profile(kind, { depth, bevel, segments: o.segments });
+	const shading = profileRows(prof);
+	const pts = prof.points;
+	const z0 = -depth / 2;
+	const box = uvBox(shape);
+	const mesh = new MeshBuffer();
+	const insets = pts.map((p) => p.inset);
+	shape.layers.forEach((layer, li) => {
+		const polys = prepared.polys[li].map(({ pg, inset, levels }) => {
+			for (const d of insets) if (!levels.has(d)) levels.set(d, inset(d));
+			return { pg, at: insets.map((d) => /** @type {[number, number][][]} */ (levels.get(d))) };
+		});
+		mesh.begin(li, 'face');
+		for (const { at } of polys) addCap(mesh, at[at.length - 1], z0 + depth, true, box);
+		mesh.begin(li, 'side');
+		for (const { pg, at } of polys)
+			pg.forEach((ring, ri) =>
+				addSide(
+					mesh,
+					ring,
+					at.map((rings) => rings[ri]),
+					prof,
+					shading,
+					z0,
+				),
+			);
+		mesh.begin(li, 'back');
+		for (const { at } of polys) addCap(mesh, at[0], z0, false, box);
+	});
+	const packed = mesh.pack();
+	return {
+		...packed,
+		bounds: { min: [-shape.width / 2, -shape.height / 2, z0], max: [shape.width / 2, shape.height / 2, z0 + depth] },
+		bevel,
+		depth,
+		profile: kind,
+		triangles: packed.index.length / 3,
+	};
+}

package/src/geometry/inset.js

@@ -0,0 +1,339 @@
+/**
+ * @module @logomarks/logo3d/geometry/inset
+ *
+ * A polygon moved inwards by a distance, point for point, so every level of a bevel has the same points and the
+ * bands between levels are simple quads. Each point travels inwards along its normal (its two edges' normals
+ * weighted by their lengths, so a stray short edge doesn't swing it) until it is exactly the distance from the
+ * outline: every point lands on the true round offset, a spike's tip as far in as its sides allow, a notch rounded.
+ * Where points pass each other (a convex curve tighter than the distance), the edges between them turn over, and
+ * those points are merged. The shape's own cap (half its thinnest stroke) keeps the far sides of a stroke apart.
+ */
+
+import { segDist2 } from '../shape/simplify.js';
+import { segmentsMeet } from './check.js';
+
+/**
+ * Each edge's unit normal pointing into the solid (to the left of the ring's direction).
+ *
+ * @param {readonly (readonly number[])[]} r The ring (open, the solid on its left).
+ * @returns {[number, number][]} One normal per edge, edge i running from point i to point i + 1.
+ */
+export function edgeNormals(r) {
+	const n = r.length;
+	/** @type {[number, number][]} */
+	const out = [];
+	for (let i = 0; i < n; i++) {
+		const a = r[i], b = r[(i + 1) % n];
+		const dx = b[0] - a[0], dy = b[1] - a[1];
+		const l = Math.hypot(dx, dy) || 1;
+		out.push([-dy / l, dx / l]);
+	}
+	return out;
+}
+
+/**
+ * Each point's direction inwards: the bisector of the solid's angle there, the directions in and out taken from
+ * points at least `span` away along the ring, so a step shorter than that (a stray notch) doesn't swing it. At a
+ * convex point it splits the corner; at a reflex point (a notch, a slit's end) it points away from the notch.
+ *
+ * @param {readonly (readonly number[])[]} r The ring (open, the solid on its left).
+ * @param {number} [span] How far along the ring to look each way (0: the neighbours).
+ * @returns {[number, number][]} One unit vector per point.
+ */
+export function pointNormals(r, span = 0) {
+	const n = r.length;
+	const len = r.map((p, i) => Math.hypot(r[(i + 1) % n][0] - p[0], r[(i + 1) % n][1] - p[1]));
+	/** The unit direction from point i to the first point at least `span` along, forwards (+1) or backwards (-1). */
+	const towards = (/** @type {number} */ i, /** @type {number} */ step) => {
+		let j = i, run = 0;
+		for (let c = 0; c < n - 1; c++) {
+			run += len[step > 0 ? j : (j + n - 1) % n];
+			j = (j + step + n) % n;
+			if (run >= span && run > 0) break;
+		}
+		const dx = r[j][0] - r[i][0], dy = r[j][1] - r[i][1], l = Math.hypot(dx, dy) || 1;
+		return [dx / l, dy / l];
+	};
+	return r.map((_, i) => {
+		const back = towards(i, -1), out = towards(i, 1);
+		const inn = [-back[0], -back[1]];
+		// the bisector of the angle between where it came from and where it goes
+		let x = out[0] + back[0], y = out[1] + back[1];
+		const turn = inn[0] * out[1] - inn[1] * out[0];
+		let l = Math.hypot(x, y);
+		if (l < 1e-9) {
+			// straight on: the normal
+			(x = -out[1]), (y = out[0]), (l = 1);
+		} else if (turn < 0) {
+			// reflex: the bisector points out of the solid; turn it round
+			(x = -x), (y = -y);
+		}
+		return [x / l, y / l];
+	});
+}
+
+/**
+ * A grid over a polygon's edges: the distance from a point to its outline, and whether a short step crosses it.
+ *
+ * @param {readonly (readonly (readonly number[])[])[]} rings The rings.
+ * @param {number} reach The farthest distance asked about, and the longest step.
+ * @returns {{ dist: (x: number, y: number) => number, crosses: (a: readonly number[], b: readonly number[]) => boolean }}
+ *   The distance to the outline, up to `reach` (anything farther is `reach`); and whether the step from a to b (no
+ *   longer than `reach`) meets an edge (crossing it, or through one of its ends).
+ */
+export function outlineIndex(rings, reach) {
+	let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+	for (const r of rings) for (const p of r) (x0 = Math.min(x0, p[0])), (y0 = Math.min(y0, p[1])), (x1 = Math.max(x1, p[0])), (y1 = Math.max(y1, p[1]));
+	const cell = Math.max(reach, (x1 - x0) / 96, (y1 - y0) / 96, 1e-9);
+	const cols = Math.max(1, Math.ceil((x1 - x0) / cell) + 1);
+	/** @type {Map<number, (readonly number[])[][]>} */
+	const grid = new Map();
+	for (const r of rings)
+		r.forEach((a, i) => {
+			const b = r[(i + 1) % r.length];
+			for (let cx = Math.floor((Math.min(a[0], b[0]) - x0) / cell); cx <= Math.floor((Math.max(a[0], b[0]) - x0) / cell); cx++)
+				for (let cy = Math.floor((Math.min(a[1], b[1]) - y0) / cell); cy <= Math.floor((Math.max(a[1], b[1]) - y0) / cell); cy++) {
+					const k = cy * cols + cx;
+					const list = grid.get(k);
+					if (list) list.push([a, b]);
+					else grid.set(k, [[a, b]]);
+				}
+		});
+	/** Every edge in the cells round a point. */
+	const near = function* (/** @type {number} */ x, /** @type {number} */ y) {
+		const cx = Math.floor((x - x0) / cell), cy = Math.floor((y - y0) / cell);
+		for (let j = cy - 1; j <= cy + 1; j++)
+			for (let i = cx - 1; i <= cx + 1; i++) {
+				if (i < 0 || j < 0 || i >= cols) continue;
+				const list = grid.get(j * cols + i);
+				if (list) yield* list;
+			}
+	};
+	return {
+		dist(x, y) {
+			let best = reach * reach;
+			const p = [x, y];
+			for (const [a, b] of near(x, y)) best = Math.min(best, segDist2(p, a, b));
+			return Math.sqrt(best);
+		},
+		crosses(a, b) {
+			for (const [c, d] of near(a[0], a[1])) if (segmentsMeet(a, b, c, d)) return true;
+			return false;
+		},
+	};
+}
+
+/**
+ * The distance from a point to a polygon's outline, up to `reach`.
+ *
+ * @param {readonly (readonly (readonly number[])[])[]} rings The rings.
+ * @param {number} reach The farthest distance asked about.
+ * @returns {(x: number, y: number) => number} The distance.
+ */
+export const outlineDistance = (rings, reach) => outlineIndex(rings, reach).dist;
+
+/**
+ * How far a point must travel along a direction to be `d` from the outline: the first such distance, by marching
+ * then halving. Where the solid is thinner than 2d (towards a tip), the point crosses the middle of the stroke
+ * before it gets there, and the distance starts to fall: it stops on the middle, and is marked short.
+ *
+ * @param {(x: number, y: number) => number} dist The distance to the outline.
+ * @param {readonly number[]} p The point.
+ * @param {readonly number[]} m The direction (unit).
+ * @param {number} d The distance wanted.
+ * @param {number} [far] The farthest it may go (12d): a long thin spike's tip draws back a long way.
+ * @param {(a: readonly number[], b: readonly number[]) => boolean} [crosses] Whether a step crosses the outline: a
+ *   step that would leave the solid (through a sliver thinner than a step) stops it short.
+ * @returns {{ t: number, short: boolean }} How far it travels, and whether it stopped short.
+ */
+export function travel(dist, p, m, d, far = 12 * d, crosses = () => false) {
+	const at = (/** @type {number} */ t) => dist(p[0] + m[0] * t, p[1] + m[1] * t);
+	const pt = (/** @type {number} */ t) => [p[0] + m[0] * t, p[1] + m[1] * t];
+	const step = d / 8;
+	// the march starts a hair inside, off the point's own edges, so meeting an edge means leaving the solid
+	const start = d * 1e-3;
+	let lo = 0, last = 0;
+	for (let hi = step; hi <= far + 1e-12; hi += step) {
+		if (crosses(pt(Math.max(lo, start)), pt(hi))) return { t: lo, short: true };
+		const v = at(hi);
+		if (v >= d * (1 - 1e-9)) {
+			let h = hi;
+			for (let k = 0; k < 24; k++) {
+				const mid = (lo + h) / 2;
+				if (at(mid) >= d) h = mid;
+				else lo = mid;
+			}
+			return { t: h, short: false };
+		}
+		// nearer the outline than a step ago: past the stroke's middle
+		if (v < last - 1e-12 * d) return { t: lo, short: true };
+		last = v;
+		lo = hi;
+	}
+	return { t: lo, short: true };
+}
+
+/**
+ * Where two lines meet: through a along u, and through b along v; null when they run (nearly) parallel.
+ *
+ * @param {readonly number[]} a
+ * @param {readonly number[]} u
+ * @param {readonly number[]} b
+ * @param {readonly number[]} v
+ * @returns {[number, number] | null} The point.
+ */
+export function lineMeet(a, u, b, v) {
+	const den = u[0] * v[1] - u[1] * v[0];
+	if (Math.abs(den) < 1e-6 * Math.hypot(u[0], u[1]) * Math.hypot(v[0], v[1])) return null;
+	const k = ((b[0] - a[0]) * v[1] - (b[1] - a[1]) * v[0]) / den;
+	return [a[0] + k * u[0], a[1] + k * u[1]];
+}
+
+/**
+ * Closes up each run of points that stopped short (near a convex corner, or a tip thinner than twice the inset):
+ * they all go to the corner where the level's two sides meet, the lines on through the points either side of the
+ * run (which did reach the inset) along their edges, or to those two points' mean when the lines run parallel or
+ * meet far off. So the level turns the corner in one point instead of folding back along the stroke's middle.
+ *
+ * @param {readonly (readonly number[])[]} r The original ring.
+ * @param {[number, number][]} p The inset points (changed in place).
+ * @param {boolean[]} short Which stopped short.
+ * @param {number} d The inset.
+ * @param {(q: [number, number]) => boolean} [fits] Whether a corner is a fair place to close to (inside the solid,
+ *   about `d` from the outline); the lines' meeting point is tried first, then the two points' mean; when neither fits,
+ *   the run's points stay where they stopped.
+ * @returns {[number, number][]} The same points.
+ */
+export function closeShort(r, p, short, d, fits = () => true) {
+	const n = p.length;
+	const start = short.findIndex((s) => !s);
+	if (start < 0) {
+		// all short: the polygon is thinner than the inset everywhere; it closes to its middle
+		const c = p.reduce((a, q) => [a[0] + q[0] / n, a[1] + q[1] / n], [0, 0]);
+		return p.map(() => /** @type {[number, number]} */ ([c[0], c[1]]));
+	}
+	const dir = (/** @type {number} */ i, /** @type {number} */ j) => [r[j][0] - r[i][0], r[j][1] - r[i][1]];
+	for (let c = 0; c < n; c++) {
+		const i = (start + c) % n;
+		if (!short[i] || short[(i + n - 1) % n]) continue;
+		// a run begins at i: find its end
+		let j = i, len = 0;
+		while (short[j] && len < n) (j = (j + 1) % n), len++;
+		const h = (i + n - 1) % n;
+		const a = p[h], b = p[j];
+		/** @type {[number, number]} */
+		const mean = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+		const hit = lineMeet(a, dir(h, (h + 1) % n), b, dir((j + n - 1) % n, j));
+		const at = [hit, mean].find((q) => q && Math.hypot(q[0] - mean[0], q[1] - mean[1]) < 4 * d && fits(q));
+		// neither is a fair corner: the run's points stay where they stopped, inside the solid
+		if (at) for (let k = i, q = 0; q < len; k = (k + 1) % n, q++) p[k] = [at[0], at[1]];
+	}
+	return p;
+}
+
+/**
+ * Merges points wherever an inset edge runs backwards against its original edge, until none does: the run of
+ * points either side of a turned edge meet at their mean.
+ *
+ * @param {readonly (readonly number[])[]} r The original ring.
+ * @param {[number, number][]} p The inset points (changed in place).
+ * @returns {[number, number][]} The same points.
+ */
+export function mergeTurned(r, p) {
+	const n = p.length;
+	// each point's run: runs are consecutive points merged into one position
+	const run = Int32Array.from({ length: n }, (_, i) => i);
+	const same = (/** @type {number} */ i, /** @type {number} */ j) => run[i] === run[j];
+	for (let pass = 0; pass < n; pass++) {
+		let turned = false;
+		for (let i = 0; i < n; i++) {
+			const j = (i + 1) % n;
+			if (same(i, j)) continue;
+			const ex = r[j][0] - r[i][0], ey = r[j][1] - r[i][1];
+			if ((p[j][0] - p[i][0]) * ex + (p[j][1] - p[i][1]) * ey >= 0) continue;
+			turned = true;
+			let first = i, count = 2;
+			while (count < n && same((first + n - 1) % n, i)) (first = (first + n - 1) % n), count++;
+			for (let last = j; count < n && same((last + 1) % n, j); ) (last = (last + 1) % n), count++;
+			let x = 0, y = 0;
+			for (let k = first, c = 0; c < count; k = (k + 1) % n, c++) (x += p[k][0]), (y += p[k][1]);
+			for (let k = first, c = 0; c < count; k = (k + 1) % n, c++) (p[k] = [x / count, y / count]), (run[k] = run[i]);
+		}
+		if (!turned) break;
+	}
+	return p;
+}
+
+/**
+ * Whether a point is inside a polygon (even-odd over its rings).
+ *
+ * @param {readonly (readonly (readonly number[])[])[]} rings The rings.
+ * @param {readonly number[]} q The point.
+ * @returns {boolean} True inside.
+ */
+export function inside(rings, q) {
+	let c = false;
+	for (const r of rings)
+		for (let i = 0, j = r.length - 1; i < r.length; j = i++)
+			if (r[i][1] > q[1] !== r[j][1] > q[1] && q[0] < ((r[j][0] - r[i][0]) * (q[1] - r[i][1])) / (r[j][1] - r[i][1]) + r[i][0]) c = !c;
+	return c;
+}
+
+/**
+ * How far along a ring a stray step can run and still be ignored when working out a point's direction: 1/150 of the
+ * polygon's size.
+ *
+ * @param {readonly (readonly (readonly number[])[])[]} rings The rings.
+ * @returns {number} The span.
+ */
+const spanOf = (rings) => {
+	let x0 = Infinity, x1 = -Infinity, y0 = Infinity, y1 = -Infinity;
+	for (const p of rings[0] ?? []) (x0 = Math.min(x0, p[0])), (x1 = Math.max(x1, p[0])), (y0 = Math.min(y0, p[1])), (y1 = Math.max(y1, p[1]));
+	return Math.max(x1 - x0, y1 - y0, 0) / 150;
+};
+
+/**
+ * Prepares a polygon for insetting to any depth up to `reach`: its points' directions, and the distance to its
+ * outline.
+ *
+ * @param {readonly (readonly (readonly number[])[])[]} rings The polygon's rings (open, the solid on their left).
+ * @param {number} reach The deepest inset that will be asked for.
+ * @returns {(d: number) => [number, number][][]} The polygon inset by `d`, ring by ring, point for point.
+ */
+export function insetter(rings, reach) {
+	const span = spanOf(rings);
+	const dirs = rings.map((r) => pointNormals(r, Math.min(reach / 2, span)));
+	const index = outlineIndex(rings, Math.max(reach, 1e-9) * 1.01);
+	const dist = index.dist;
+	return (d) =>
+		rings.map((r, ri) => {
+			if (!d) return r.map((q) => /** @type {[number, number]} */ ([q[0], q[1]]));
+			const m = dirs[ri];
+			/** @type {boolean[]} */
+			const short = [];
+			const pts = r.map((q, i) => {
+				const { t, short: s } = travel(dist, q, m[i], d, Math.max(12 * d, 150 * span), index.crosses);
+				short.push(s);
+				return /** @type {[number, number]} */ ([q[0] + m[i][0] * t, q[1] + m[i][1] * t]);
+			});
+			return mergeTurned(r, closeShort(r, pts, short, d, (q) => inside(rings, q) && Math.abs(dist(q[0], q[1]) - d) < 0.4 * d));
+		});
+}
+
+/**
+ * A polygon moved inwards by `d`, point for point.
+ *
+ * @param {readonly (readonly (readonly number[])[])[]} rings The polygon's rings (open, the solid on their left).
+ * @param {number} d The distance.
+ * @returns {[number, number][][]} The inset rings.
+ */
+export const insetPolygon = (rings, d) => insetter(rings, d)(d);
+
+/**
+ * One ring (an outline with no holes) moved inwards by `d`, point for point.
+ *
+ * @param {readonly (readonly number[])[]} r The ring.
+ * @param {number} d The distance.
+ * @returns {[number, number][]} The inset points.
+ */
+export const insetRing = (r, d) => insetPolygon([r], d)[0];