@logomarks/logo3d 0.0.0-stage → 0.1.0

package/src/shape/normalise.js

@@ -0,0 +1,92 @@
+/**
+ * @module @logomarks/logo3d/shape/normalise
+ *
+ * Colour layers to the units the geometry works in: y up, centred on the origin, the longest side 1. Every ring is
+ * open (no repeated closing point), simplified, and wound so the solid is on its left: outlines anticlockwise, holes
+ * clockwise. Slivers are dropped.
+ */
+
+import { signedArea, simplifyRing } from './simplify.js';
+
+/**
+ * The box round every point of every layer.
+ *
+ * @param {{ shape: import('@logomarks/core/geometry').Shape }[]} layers The layers (y down, file units).
+ * @returns {[number, number, number, number]} `[x0, y0, x1, y1]`.
+ */
+export function boundsOf(layers) {
+	let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+	for (const l of layers) for (const pg of l.shape) for (const r of pg) for (const [x, y] of r) {
+		if (x < x0) x0 = x;
+		if (x > x1) x1 = x;
+		if (y < y0) y0 = y;
+		if (y > y1) y1 = y;
+	}
+	return [x0, y0, x1, y1];
+}
+
+/**
+ * @typedef {[number, number][]} Ring2
+ * @typedef {Ring2[]} Polygon2 An outline, then its holes.
+ * @typedef {object} NormalLayer
+ * @property {string | null} color The layer's colour, or null for the ink.
+ * @property {Polygon2[]} polygons Its polygons.
+ */
+
+/**
+ * Layers normalised.
+ *
+ * @param {import('./layers.js').Layer[]} layers The layers (y down, file units).
+ * @param {{ tolerance?: number }} [o] `tolerance`: the simplification, as a share of the longest side (1/1200).
+ * @returns {{ layers: NormalLayer[], width: number, height: number, scale: number }} The layers, their size (the
+ *   longest side 1) and the scale from file units.
+ */
+export function normalise(layers, { tolerance = 1 / 1200 } = {}) {
+	const [x0, y0, x1, y1] = boundsOf(layers);
+	const span = Math.max(x1 - x0, y1 - y0);
+	if (!Number.isFinite(span) || span <= 0) return { layers: [], width: 0, height: 0, scale: 1 };
+	const s = 1 / span, cx = (x0 + x1) / 2, cy = (y0 + y1) / 2;
+	const minArea = (tolerance * 4) ** 2;
+	/** @type {NormalLayer[]} */
+	const out = [];
+	for (const l of layers) {
+		/** @type {Polygon2[]} */
+		const polygons = [];
+		for (const pg of l.shape) {
+			/** @type {Ring2[]} */
+			const rings = [];
+			pg.forEach((ring, i) => {
+				/** @type {Ring2} */
+				let r = ring.map(([x, y]) => [(x - cx) * s, (cy - y) * s]);
+				r = simplifyRing(r, tolerance);
+				if (r.length < 3) return;
+				const a = signedArea(r);
+				if (Math.abs(a) < minArea) return;
+				// the outline (the first ring) anticlockwise, holes clockwise
+				if ((i === 0) !== a > 0) r.reverse();
+				rings.push(r);
+			});
+			if (rings.length && signedArea(rings[0]) > 0 && pg.length) polygons.push(rings);
+		}
+		if (polygons.length) out.push({ color: l.color, polygons });
+	}
+	return recentre(out, s);
+}
+
+/**
+ * Layers moved and scaled once more after simplifying (which can move an extreme point a hair), so they are exactly
+ * centred with the longest side exactly 1.
+ *
+ * @param {NormalLayer[]} layers The layers (changed in place).
+ * @param {number} s The scale so far.
+ * @returns {{ layers: NormalLayer[], width: number, height: number, scale: number }} The layers and their size.
+ */
+function recentre(layers, s) {
+	let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+	for (const l of layers) for (const pg of l.polygons) for (const [x, y] of pg[0]) (x0 = Math.min(x0, x)), (x1 = Math.max(x1, x)), (y0 = Math.min(y0, y)), (y1 = Math.max(y1, y));
+	const span = Math.max(x1 - x0, y1 - y0);
+	if (!(span > 0)) return { layers: [], width: 0, height: 0, scale: s };
+	const k = 1 / span, cx = (x0 + x1) / 2, cy = (y0 + y1) / 2;
+	for (const l of layers) for (const pg of l.polygons) for (const r of pg) for (const p of r) (p[0] = (p[0] - cx) * k), (p[1] = (p[1] - cy) * k);
+	return { layers, width: (x1 - x0) * k, height: (y1 - y0) * k, scale: s * k };
+}

package/src/shape/simplify.js

@@ -0,0 +1,95 @@
+/**
+ * @module @logomarks/logo3d/shape/simplify
+ *
+ * Ring clean-up before extrusion: the shoelace area, and Douglas–Peucker simplification of a closed ring, so long
+ * straight runs become single edges while curves keep their sampling.
+ */
+
+/**
+ * A ring's signed area, positive anticlockwise with y up.
+ *
+ * @param {readonly (readonly number[])[]} r The ring (open: the last point is not the first).
+ * @returns {number} The area.
+ */
+export function signedArea(r) {
+	let s = 0;
+	for (let i = 0, j = r.length - 1; i < r.length; j = i++) s += (r[j][0] - r[i][0]) * (r[j][1] + r[i][1]);
+	return s / 2;
+}
+
+/**
+ * The squared distance from p to the segment ab.
+ *
+ * @param {readonly number[]} p The point.
+ * @param {readonly number[]} a The segment's start.
+ * @param {readonly number[]} b Its end.
+ * @returns {number} The squared distance.
+ */
+export function segDist2(p, a, b) {
+	const dx = b[0] - a[0], dy = b[1] - a[1];
+	const l2 = dx * dx + dy * dy;
+	const t = l2 ? Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / l2)) : 0;
+	const x = a[0] + t * dx - p[0], y = a[1] + t * dy - p[1];
+	return x * x + y * y;
+}
+
+/**
+ * Douglas–Peucker on an open polyline (its ends kept).
+ *
+ * @param {[number, number][]} pts The polyline.
+ * @param {number} tol The tolerance.
+ * @returns {[number, number][]} The kept points.
+ */
+function dp(pts, tol) {
+	if (pts.length < 3) return pts.slice();
+	const keep = new Uint8Array(pts.length);
+	keep[0] = keep[pts.length - 1] = 1;
+	const stack = [[0, pts.length - 1]];
+	const t2 = tol * tol;
+	while (stack.length) {
+		const [a, b] = /** @type {number[]} */ (stack.pop());
+		let far = -1, fd = t2;
+		for (let i = a + 1; i < b; i++) {
+			const d = segDist2(pts[i], pts[a], pts[b]);
+			if (d > fd) (fd = d), (far = i);
+		}
+		if (far > 0) {
+			keep[far] = 1;
+			stack.push([a, far], [far, b]);
+		}
+	}
+	return pts.filter((_, i) => keep[i]);
+}
+
+/**
+ * A closed ring simplified to a tolerance: Douglas–Peucker, then any step shorter than the tolerance dropped.
+ *
+ * @param {[number, number][]} ring The ring (open).
+ * @param {number} tol The tolerance, in the ring's units.
+ * @returns {[number, number][]} The simplified ring (open).
+ */
+export function simplifyRing(ring, tol) {
+	/** @type {[number, number][]} */
+	const pts = [];
+	for (const p of ring) {
+		const q = pts[pts.length - 1];
+		if (!q || Math.hypot(p[0] - q[0], p[1] - q[1]) > tol * 1e-3) pts.push(p);
+	}
+	while (pts.length > 1 && Math.hypot(pts[0][0] - pts[pts.length - 1][0], pts[0][1] - pts[pts.length - 1][1]) <= tol * 1e-3) pts.pop();
+	if (pts.length < 4 || !tol) return pts;
+	let far = 0, fd = -1;
+	pts.forEach((p, i) => {
+		const d = Math.hypot(p[0] - pts[0][0], p[1] - pts[0][1]);
+		if (d > fd) (fd = d), (far = i);
+	});
+	const kept = [...dp(pts.slice(0, far + 1), tol).slice(0, -1), ...dp([...pts.slice(far), pts[0]], tol).slice(0, -1)];
+	// steps shorter than the tolerance (a stray notch) go: each point that close to the last kept one is dropped
+	/** @type {[number, number][]} */
+	const out = [];
+	for (const p of kept) {
+		const q = out[out.length - 1];
+		if (!q || Math.hypot(p[0] - q[0], p[1] - q[1]) >= tol) out.push(p);
+	}
+	while (out.length > 3 && Math.hypot(out[0][0] - out[out.length - 1][0], out[0][1] - out[out.length - 1][1]) < tol) out.pop();
+	return out.length >= 3 ? out : kept;
+}

package/src/shape/svg.js

@@ -0,0 +1,196 @@
+/**
+ * @module @logomarks/logo3d/shape/svg
+ *
+ * Reads an SVG file's filled elements without a DOM (it runs in a worker and in Node): a small tag walker that keeps
+ * the element tree's transforms, fills and fill rules (attributes, inline `style`, and simple `.class` rules in a
+ * `<style>`), skips what never paints (`<defs>`, clip paths, masks, `display: none`, `fill: none`), and returns each
+ * filled `<path>`, `<rect>` (rounded too), `<circle>`, `<ellipse>`, `<polygon>` and `<polyline>` as rings in the
+ * file's user space, curves sampled by @logomarks/core.
+ */
+
+import { parsePath, rings } from '@logomarks/core/svg';
+import { IDENTITY, apply, multiply, parseTransform, scaleOf } from './matrix.js';
+
+/** Elements whose content never paints. */
+const SKIP = new Set(['defs', 'clippath', 'mask', 'symbol', 'pattern', 'marker', 'lineargradient', 'radialgradient', 'filter', 'title', 'desc', 'metadata', 'style', 'text', 'script', 'foreignobject']);
+/** The filled elements read. */
+const SHAPES = new Set(['path', 'rect', 'circle', 'ellipse', 'polygon', 'polyline']);
+
+/**
+ * A tag's attributes.
+ *
+ * @param {string} text Everything between the tag's name and its `>`.
+ * @returns {Record<string, string>} The attributes by lower-case name.
+ */
+export function attributes(text) {
+	/** @type {Record<string, string>} */
+	const out = {};
+	for (const [, name, dq, sq] of text.matchAll(/([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)) out[name.toLowerCase()] = dq ?? sq ?? '';
+	return out;
+}
+
+/**
+ * CSS declarations (`fill: #f00; fill-rule: evenodd`) as properties.
+ *
+ * @param {string | undefined} text The declarations.
+ * @returns {Record<string, string>} The properties by lower-case name.
+ */
+export function declarations(text) {
+	/** @type {Record<string, string>} */
+	const out = {};
+	for (const part of (text ?? '').split(';')) {
+		const i = part.indexOf(':');
+		if (i > 0) out[part.slice(0, i).trim().toLowerCase()] = part.slice(i + 1).replace(/!important/i, '').trim();
+	}
+	return out;
+}
+
+/**
+ * The class rules in a file's `<style>` elements (`.a, .b { fill: … }`); other selectors are ignored.
+ *
+ * @param {string} svg The file.
+ * @returns {Map<string, Record<string, string>>} Each class's properties.
+ */
+export function classRules(svg) {
+	/** @type {Map<string, Record<string, string>>} */
+	const out = new Map();
+	for (const [, css] of svg.matchAll(/<style\b[^>]*>([\s\S]*?)<\/style>/gi)) {
+		for (const [, selectors, body] of css.replace(/<!\[CDATA\[|\]\]>/g, '').matchAll(/([^{}]+)\{([^}]*)\}/g)) {
+			const props = declarations(body);
+			for (const sel of selectors.split(',').map((s) => s.trim())) {
+				const m = /^\.([\w-]+)$/.exec(sel);
+				if (m) out.set(m[1], { ...out.get(m[1]), ...props });
+			}
+		}
+	}
+	return out;
+}
+
+/**
+ * A number attribute (lengths in user units; a `%` or unit suffix is dropped).
+ *
+ * @param {Record<string, string>} a The attributes.
+ * @param {string} name The attribute.
+ * @param {number} [fallback] When it is missing.
+ * @returns {number} Its value.
+ */
+const num = (a, name, fallback = 0) => {
+	const v = parseFloat(a[name] ?? '');
+	return Number.isFinite(v) ? v : fallback;
+};
+
+/**
+ * A filled element's outline as path data.
+ *
+ * @param {string} name The element.
+ * @param {Record<string, string>} a Its attributes.
+ * @returns {string | undefined} Its path data.
+ */
+export function outline(name, a) {
+	if (name === 'path') return a.d;
+	if (name === 'circle' || name === 'ellipse') {
+		const cx = num(a, 'cx'), cy = num(a, 'cy');
+		const rx = num(a, name === 'circle' ? 'r' : 'rx'), ry = num(a, name === 'circle' ? 'r' : 'ry');
+		if (rx <= 0 || ry <= 0) return undefined;
+		return `M${cx - rx} ${cy}A${rx} ${ry} 0 1 0 ${cx + rx} ${cy}A${rx} ${ry} 0 1 0 ${cx - rx} ${cy}Z`;
+	}
+	if (name === 'rect') {
+		const x = num(a, 'x'), y = num(a, 'y'), w = num(a, 'width'), h = num(a, 'height');
+		if (w <= 0 || h <= 0) return undefined;
+		let rx = num(a, 'rx', NaN), ry = num(a, 'ry', NaN);
+		if (Number.isNaN(rx)) rx = Number.isNaN(ry) ? 0 : ry;
+		if (Number.isNaN(ry)) ry = rx;
+		rx = Math.min(Math.max(rx, 0), w / 2);
+		ry = Math.min(Math.max(ry, 0), h / 2);
+		if (!rx || !ry) return `M${x} ${y}H${x + w}V${y + h}H${x}Z`;
+		const arc = (/** @type {number} */ ex, /** @type {number} */ ey) => `A${rx} ${ry} 0 0 1 ${ex} ${ey}`;
+		return `M${x + rx} ${y}H${x + w - rx}${arc(x + w, y + ry)}V${y + h - ry}${arc(x + w - rx, y + h)}H${x + rx}${arc(x, y + h - ry)}V${y + ry}${arc(x + rx, y)}Z`;
+	}
+	const points = a.points?.trim();
+	return points ? `M${points.replace(/\s+/g, ' ')}Z` : undefined;
+}
+
+/**
+ * @typedef {object} Paint
+ * @property {number[]} matrix The transform to the file's user space.
+ * @property {string | undefined} fill The fill, as written (`undefined`: inherited black).
+ * @property {string | undefined} rule The fill rule.
+ * @property {boolean} hidden Whether it is `display: none` or `visibility: hidden`.
+ * @property {boolean} skip Whether it is inside something that never paints.
+ */
+
+/**
+ * One element's paint, from its parent's.
+ *
+ * @param {Paint} parent The parent's paint.
+ * @param {Record<string, string>} a The element's attributes.
+ * @param {Map<string, Record<string, string>>} classes The file's class rules.
+ * @param {string} name The element.
+ * @returns {Paint} Its own.
+ */
+function paintOf(parent, a, classes, name) {
+	const props = { ...a };
+	for (const c of (a.class ?? '').split(/\s+/)) Object.assign(props, classes.get(c));
+	Object.assign(props, declarations(a.style));
+	return {
+		matrix: a.transform ? multiply(parent.matrix, parseTransform(a.transform)) : parent.matrix,
+		fill: props.fill && props.fill !== 'inherit' ? props.fill : parent.fill,
+		rule: props['fill-rule'] && props['fill-rule'] !== 'inherit' ? props['fill-rule'] : parent.rule,
+		hidden: parent.hidden || props.display === 'none' || props.visibility === 'hidden' || props.opacity === '0' || props['fill-opacity'] === '0',
+		skip: parent.skip || SKIP.has(name),
+	};
+}
+
+/**
+ * @typedef {object} Element
+ * @property {import('@logomarks/core/geometry').Ring[]} rings Its rings in the file's user space.
+ * @property {boolean} evenodd Whether it fills even-odd.
+ * @property {string | undefined} fill Its fill as written (`currentColor`, a colour, a `url(#…)`), or undefined.
+ * @property {boolean} first Whether it is the first filled element (for dropping a background).
+ */
+
+/**
+ * Every filled element of a file, in paint order, as rings in its user space.
+ *
+ * @param {string} svg The file's text.
+ * @param {{ step?: number }} [o] `step`: the longest chord along a curve, as a share of the file's size (1/340).
+ * @returns {{ elements: Element[], box: [number, number, number, number] | undefined }} The elements, and the viewBox.
+ */
+export function readElements(svg, { step = 1 / 340 } = {}) {
+	const text = svg.replace(/<!--[\s\S]*?-->/g, '').replace(/<\?[\s\S]*?\?>/g, '').replace(/<!DOCTYPE[^>]*>/gi, '');
+	const classes = classRules(text);
+	const vb = /<svg\b[^>]*\sviewBox\s*=\s*["']([^"']+)["']/i.exec(text)?.[1].trim().split(/[\s,]+/).map(Number);
+	const root = /<svg\b([^>]*)>/i.exec(text);
+	const ra = root ? attributes(root[1]) : {};
+	/** @type {[number, number, number, number] | undefined} */
+	const box = vb?.length === 4 && vb.every(Number.isFinite) ? [vb[0], vb[1], vb[2], vb[3]] : num(ra, 'width') && num(ra, 'height') ? [0, 0, num(ra, 'width'), num(ra, 'height')] : undefined;
+	const size = box ? Math.max(box[2], box[3]) : 512;
+	/** @type {Paint[]} */
+	const stack = [{ matrix: [...IDENTITY], fill: undefined, rule: undefined, hidden: false, skip: false }];
+	/** @type {Element[]} */
+	const elements = [];
+	for (const [, close, rawName, rest, selfClose] of text.matchAll(/<(\/?)([A-Za-z][\w:.-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>/g)) {
+		const name = rawName.toLowerCase().replace(/^svg:/, '');
+		if (close) {
+			if (stack.length > 1) stack.pop();
+			continue;
+		}
+		const a = attributes(rest);
+		const paint = paintOf(stack[stack.length - 1], a, classes, name);
+		// every open tag (a shape's too: <path …></path>) holds its paint until it closes
+		if (!selfClose) stack.push(paint);
+		if (!SHAPES.has(name) || paint.skip || paint.hidden || paint.fill === 'none' || paint.fill === 'transparent') continue;
+		const d = outline(name, a);
+		if (!d) continue;
+		let segs;
+		try {
+			segs = parsePath(d);
+		} catch {
+			continue;
+		}
+		const local = (size * step) / scaleOf(paint.matrix);
+		const rs = rings(segs, local).map((r) => r.map((p) => apply(paint.matrix, /** @type {[number, number]} */ (p))));
+		if (rs.length) elements.push({ rings: rs, evenodd: paint.rule === 'evenodd', fill: paint.fill, first: elements.length === 0 });
+	}
+	return { elements, box };
+}

package/src/shape/thinnest.js

@@ -0,0 +1,77 @@
+/**
+ * @module @logomarks/logo3d/shape/thinnest
+ *
+ * How far a logo can be inset before it changes: the cap on its bevel, which is about half its thinnest stroke. Each
+ * layer is rasterised (@logomarks/core's scanline), every ink pixel's distance to the nearest empty one measured
+ * (core's distance transform), and the deepest inset found (a binary search) that keeps as many pieces and holes as
+ * the layer has (core's components): no stroke is cut through, no dot vanishes, no hole opens into another. Corners
+ * don't count against it, as they would for a measure of stroke widths.
+ */
+
+import { components, distance, fill } from '@logomarks/core/raster';
+
+/**
+ * A raster frame tight round a layer, three pixels of margin.
+ *
+ * @param {import('./normalise.js').NormalLayer} l The layer.
+ * @param {number} scale Pixels a unit.
+ * @returns {import('@logomarks/core/raster').RasterFrame} The frame.
+ */
+function frameAround(l, scale) {
+	let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+	for (const pg of l.polygons) for (const [x, y] of pg[0]) (x0 = Math.min(x0, x)), (y0 = Math.min(y0, y)), (x1 = Math.max(x1, x)), (y1 = Math.max(y1, y));
+	const pad = 3 / scale;
+	return { x0: x0 - pad, y0: y0 - pad, scale, width: Math.ceil((x1 - x0 + 2 * pad) * scale), height: Math.ceil((y1 - y0 + 2 * pad) * scale) };
+}
+
+/**
+ * A raster's topology: its ink pieces and empty regions, counted.
+ *
+ * @param {import('@logomarks/core/raster').Bitmap} bm The raster.
+ * @returns {string} `"<ink>/<empty>"`.
+ */
+export function topology(bm) {
+	let ink = 0, empty = 0;
+	for (const c of components(bm)) c.ink ? ink++ : empty++;
+	return `${ink}/${empty}`;
+}
+
+/**
+ * The deepest inset (in pixels) that keeps a raster's topology.
+ *
+ * @param {import('@logomarks/core/raster').Bitmap} bm The raster.
+ * @param {{ steps?: number }} [o] `steps`: the binary search's steps (12).
+ * @returns {number} The inset.
+ */
+export function deepestInset(bm, { steps = 12 } = {}) {
+	const d = distance(bm, 1);
+	const same = topology(bm);
+	let lo = 0, hi = 0;
+	for (const v of d) if (v > hi) hi = v;
+	const eroded = { ...bm, data: new Uint8Array(bm.data.length) };
+	for (let s = 0; s < steps; s++) {
+		const t = (lo + hi) / 2;
+		for (let i = 0; i < d.length; i++) eroded.data[i] = d[i] > t ? 1 : 0;
+		if (topology(eroded) === same) lo = t;
+		else hi = t;
+	}
+	return lo;
+}
+
+/**
+ * About half the thinnest stroke of normalised layers (in their units: the longest side is 1): the deepest inset
+ * that keeps every layer's pieces and holes.
+ *
+ * @param {import('./normalise.js').NormalLayer[]} layers The layers.
+ * @param {{ resolution?: number }} [o] `resolution`: pixels a unit (448).
+ * @returns {number} The half-width.
+ */
+export function halfThinnest(layers, { resolution = 448 } = {}) {
+	let best = Infinity;
+	for (const l of layers) {
+		const paths = l.polygons.map((pg) => ({ rings: pg, evenodd: true }));
+		const bm = fill(paths, frameAround(l, resolution));
+		best = Math.min(best, Math.max(0.5, deepestInset(bm)) / resolution);
+	}
+	return Number.isFinite(best) ? best : 0;
+}

package/src/three/geometry.d.ts

@@ -0,0 +1,5 @@
+import type * as THREE from 'three';
+import type { LogoGeometry } from '../geometry/index.js';
+
+/** A BufferGeometry from a built geometry, its groups' material indices matching `logoMaterials`. */
+export function toBufferGeometry(three: typeof THREE, g: LogoGeometry): THREE.BufferGeometry;

package/src/three/geometry.js

@@ -0,0 +1,25 @@
+/**
+ * @module @logomarks/logo3d/three/geometry
+ *
+ * The geometry's typed arrays as a three.js BufferGeometry: positions, normals, UVs and indices as attributes, each
+ * layer's face, side and back as a draw group whose material index matches `logoMaterials`.
+ */
+
+/**
+ * A BufferGeometry from a built geometry.
+ *
+ * @param {typeof import('three')} THREE three.js.
+ * @param {import('../geometry/index.js').LogoGeometry} g The geometry (`buildGeometry`, or a worker's reply).
+ * @returns {import('three').BufferGeometry} The BufferGeometry.
+ */
+export function toBufferGeometry(THREE, g) {
+	const geo = new THREE.BufferGeometry();
+	geo.setAttribute('position', new THREE.BufferAttribute(g.position, 3));
+	geo.setAttribute('normal', new THREE.BufferAttribute(g.normal, 3));
+	geo.setAttribute('uv', new THREE.BufferAttribute(g.uv, 2));
+	geo.setIndex(new THREE.BufferAttribute(g.index, 1));
+	for (const grp of g.groups) geo.addGroup(grp.start, grp.count, grp.materialIndex);
+	geo.boundingBox = new THREE.Box3(new THREE.Vector3(...g.bounds.min), new THREE.Vector3(...g.bounds.max));
+	geo.computeBoundingSphere();
+	return geo;
+}

package/src/three/index.d.ts

@@ -0,0 +1,11 @@
+export { createView, DEFAULT_LOOK, colorsFor } from '../scene/view.js';
+export type { Look, LogoView, ViewOptions } from '../scene/view.js';
+export { toBufferGeometry } from './geometry.js';
+export { logoMaterials, presetMaterial, flatSides, exportable } from '../materials/factory.js';
+export { environmentCache } from '../scene/environments.js';
+export { studioScene } from '../scene/studio.js';
+export { makeBackdrop, sweepMesh } from '../scene/backdrop.js';
+export type { Backdrop } from '../scene/backdrop.js';
+export { stillRenderer, pngOf, unpremultiply, placeTile, tileSide } from '../export/still.js';
+export type { Pixels } from '../export/still.js';
+export { glbOf } from '../export/glb.js';

package/src/three/index.js

@@ -0,0 +1,15 @@
+/**
+ * @module @logomarks/logo3d/three
+ *
+ * The three.js side: the live view (`createView`), the geometry as a BufferGeometry, the materials, the environments
+ * and backdrops, and the exports (off-screen stills as PNG, GLB, video frames). three.js is a peer dependency.
+ */
+
+export { createView, DEFAULT_LOOK, colorsFor } from '../scene/view.js';
+export { toBufferGeometry } from './geometry.js';
+export { logoMaterials, presetMaterial, flatSides, exportable } from '../materials/factory.js';
+export { environmentCache } from '../scene/environments.js';
+export { studioScene } from '../scene/studio.js';
+export { makeBackdrop, sweepMesh } from '../scene/backdrop.js';
+export { stillRenderer, pngOf, unpremultiply, placeTile, tileSide } from '../export/still.js';
+export { glbOf } from '../export/glb.js';

package/src/worker/build.d.ts

@@ -0,0 +1,6 @@
+import type { BuildRequest, BuildResult } from './client.js';
+
+/** A builder with a one-file memory (the shape is kept while the same SVG comes again). */
+export function makeBuild(): (req: BuildRequest) => BuildResult;
+/** The typed arrays a result can hand over without copying. */
+export function transferables(r: BuildResult): ArrayBuffer[];

package/src/worker/build.js

@@ -0,0 +1,37 @@
+/**
+ * @module @logomarks/logo3d/worker/build
+ *
+ * One build, as the worker runs it: the SVG read into a shape (kept while the same SVG comes again, so changing the
+ * depth or profile doesn't read the file again) and extruded. Pure; the worker and the main-thread fallback share it.
+ */
+
+import { readLogo } from '../shape/index.js';
+import { buildGeometry } from '../geometry/index.js';
+
+/**
+ * A builder with a one-file memory.
+ *
+ * @returns {(req: import('./client.js').BuildRequest) => import('./client.js').BuildResult} Builds a request.
+ */
+export function makeBuild() {
+	/** @type {{ svg: string, shape: import('../shape/index.js').LogoShape } | null} */
+	let last = null;
+	return (req) => {
+		if (!last || last.svg !== req.svg) last = { svg: req.svg, shape: readLogo(req.svg) };
+		const { shape } = last;
+		if (!shape.layers.length) throw new Error('This SVG has no filled shapes to extrude.');
+		return {
+			geometry: buildGeometry(shape, req.options ?? {}),
+			colors: shape.layers.map((l) => l.color),
+			halfStroke: shape.halfStroke,
+		};
+	};
+}
+
+/**
+ * The typed arrays a result can hand over without copying.
+ *
+ * @param {import('./client.js').BuildResult} r The result.
+ * @returns {ArrayBuffer[]} Their buffers.
+ */
+export const transferables = (r) => [r.geometry.position.buffer, r.geometry.normal.buffer, r.geometry.uv.buffer, r.geometry.index.buffer].map((b) => /** @type {ArrayBuffer} */ (b));

package/src/worker/client.d.ts

@@ -0,0 +1,29 @@
+import type { GeometryOptions, LogoGeometry } from '../geometry/index.js';
+
+/** One build: an SVG and how to extrude it. */
+export interface BuildRequest {
+	svg: string;
+	options?: GeometryOptions;
+}
+/** What a build gives back. */
+export interface BuildResult {
+	geometry: LogoGeometry;
+	/** Each layer's own colour (null for the ink). */
+	colors: (string | null)[];
+	/** Half the logo's thinnest stroke. */
+	halfStroke: number;
+}
+/** What the client needs of a worker. */
+export interface WorkerLike {
+	postMessage(message: unknown): void;
+	onmessage: ((e: MessageEvent) => void) | null;
+	terminate(): void;
+}
+/** A builder: latest request wins. */
+export interface Builder {
+	/** Builds; rejects with an `AbortError` when a newer request replaces it before it starts. */
+	build(req: BuildRequest): Promise<BuildResult>;
+	dispose(): void;
+}
+/** A builder over a worker (or on the main thread when `makeWorker` is null). */
+export function createBuilder(makeWorker?: (() => WorkerLike) | null): Builder;