@weasel-js/core 1.9.3 → 1.9.4

package/dist/features/meshPaint/lazyKind.js

@@ -1,4 +1,17 @@
 //#region ../paint/dist/index.js
+var HEX = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+function parseHexBytes(input) {
+	if (!HEX.test(input)) return null;
+	const digits = input.slice(1);
+	const long = digits.length <= 4 ? digits.replace(/./g, "$&$&") : digits;
+	const byte = (i) => Number.parseInt(long.slice(i, i + 2), 16);
+	return [
+		byte(0),
+		byte(2),
+		byte(4),
+		long.length === 8 ? byte(6) : 255
+	];
+}
 var SRGB_TO_LINEAR = (() => {
 	const lut = /* @__PURE__ */ new Float64Array(256);
 	for (let i = 0; i < 256; i++) {
@@ -251,32 +264,14 @@ function rgbaToHex(rgba) {
 	return a >= 1 ? base : `${base}${f(a)}`;
 }
 function parseHex(s) {
-	const hex = s.slice(1);
-	if (hex.length === 3) return [
-		parseInt(hex[0] + hex[0], 16) / 255,
-		parseInt(hex[1] + hex[1], 16) / 255,
-		parseInt(hex[2] + hex[2], 16) / 255,
-		1
-	];
-	if (hex.length === 4) return [
-		parseInt(hex[0] + hex[0], 16) / 255,
-		parseInt(hex[1] + hex[1], 16) / 255,
-		parseInt(hex[2] + hex[2], 16) / 255,
-		parseInt(hex[3] + hex[3], 16) / 255
-	];
-	if (hex.length === 6) return [
-		parseInt(hex.slice(0, 2), 16) / 255,
-		parseInt(hex.slice(2, 4), 16) / 255,
-		parseInt(hex.slice(4, 6), 16) / 255,
-		1
-	];
-	if (hex.length === 8) return [
-		parseInt(hex.slice(0, 2), 16) / 255,
-		parseInt(hex.slice(2, 4), 16) / 255,
-		parseInt(hex.slice(4, 6), 16) / 255,
-		parseInt(hex.slice(6, 8), 16) / 255
+	const bytes = parseHexBytes(s);
+	if (!bytes) throw new Error(`parseColor: invalid hex "${s}"`);
+	return [
+		bytes[0] / 255,
+		bytes[1] / 255,
+		bytes[2] / 255,
+		bytes[3] / 255
 	];
-	throw new Error(`parseColor: invalid hex "${s}"`);
 }
 /** Match `name( body )` and return the trimmed body, or null. */
 function unwrapFn(s, name) {
@@ -569,6 +564,169 @@ const NAMED_COLORS = (() => {
 	return out;
 })();
 //#endregion
+//#region ../geom/src/mat3.ts
+/**
+* 2D affine transforms in canvas/DOMMatrix order: [a, b, c, d, e, f].
+*   x' = a·x + c·y + e
+*   y' = b·x + d·y + f
+* Represented as a readonly 6-tuple (f64). The affine tier of the kernel.
+*
+* Convention alignment: the renderer already has a `Mat3` in
+* `src/renderer/math/mat3.ts`. That one is a 9-element column-major
+* array (a full 3×3) laid out for `uniformMatrix3fv` — a deliberately
+* different *representation* for the WebGL upload path. Its *logical element
+* order* is identical to ours: `create(a, b, c, d, tx, ty)` maps
+* `x' = a·x + c·y + tx`, `y' = b·x + d·y + ty` (canvas/DOMMatrix a,b,c,d,e,f).
+* We keep the pure 6-tuple form here (the kernel form); the 9-element form
+* stays a render-layer concern. No second logical convention is created.
+*/
+/** Inverse, or null when the matrix is singular, non-finite, or too
+*  ill-conditioned to invert meaningfully at its own scale. */
+function invert$1(m) {
+	const det = m[0] * m[3] - m[1] * m[2];
+	const norm2 = Math.max(m[0] * m[0] + m[1] * m[1], m[2] * m[2] + m[3] * m[3]);
+	if (!(Math.abs(det) > 1e-12 * norm2)) return null;
+	const id = 1 / det;
+	const a = m[3] * id;
+	const b = -m[1] * id;
+	const c = -m[2] * id;
+	const d = m[0] * id;
+	return [
+		a,
+		b,
+		c,
+		d,
+		-(m[4] * a + m[5] * c),
+		-(m[4] * b + m[5] * d)
+	];
+}
+//#endregion
+//#region src/renderer/math/mat3.ts
+/**
+* 2D affine matrix utilities. Column-major 9 elements, matching
+* `WebGL2RenderingContext.uniformMatrix3fv` element order so an upload needs
+* no transpose flag.
+*
+* Layout (column-major):
+*   [m00, m10, 0,
+*    m01, m11, 0,
+*    tx,  ty,  1]
+*
+* `apply(m, x, y)` returns `[m * (x, y, 1)] = [m00*x + m01*y + tx,
+*                                              m10*x + m11*y + ty]`.
+*/
+function create(a, b, c, d, tx, ty) {
+	return new Float64Array([
+		a,
+		b,
+		0,
+		c,
+		d,
+		0,
+		tx,
+		ty,
+		1
+	]);
+}
+function identity() {
+	return create(1, 0, 0, 1, 0, 0);
+}
+function multiply(out, m) {
+	const a = out[0], b = out[1];
+	const c = out[3], d = out[4];
+	const tx = out[6], ty = out[7];
+	const ma = m[0], mb = m[1];
+	const mc = m[3], md = m[4];
+	const mtx = m[6], mty = m[7];
+	return create(a * ma + c * mb, b * ma + d * mb, a * mc + c * md, b * mc + d * md, a * mtx + c * mty + tx, b * mtx + d * mty + ty);
+}
+/** `m · T(tx, ty)`: composes onto `m`, where `@weasel-js/geom`'s `translate`
+*  constructs a fresh matrix. */
+function translated(m, tx, ty) {
+	return multiply(m, create(1, 0, 0, 1, tx, ty));
+}
+/** `m · S(sx, sy)`: composes onto `m`, where geom's `scale` constructs one. */
+function scaled(m, sx, sy) {
+	return multiply(m, create(sx, 0, 0, sy, 0, 0));
+}
+/** This layout read as the kernel's 6-element affine. The two carry the same
+*  logical order, so the conversion is a repack and nothing else — it exists
+*  so the repack has a name instead of appearing inline at each crossing. */
+function toAffine(m) {
+	return [
+		m[0],
+		m[1],
+		m[3],
+		m[4],
+		m[6],
+		m[7]
+	];
+}
+/** The kernel's affine in this layout. The inverse of {@link toAffine}, and
+*  what an `SvgGroupNode.transform` (also a kernel affine) becomes on its way
+*  to a `GroupDrawCommand`. */
+function fromAffine(a) {
+	return create(a[0], a[1], a[2], a[3], a[4], a[5]);
+}
+/** Inverse of an affine matrix, or `null` when `@weasel-js/geom`'s `invert`
+*  finds it singular — the same rule, read through this layout. */
+function invert(m) {
+	const inv = invert$1(toAffine(m));
+	return inv && fromAffine(inv);
+}
+/** A float32 copy of `m`, for `uniformMatrix3fv` or a shader uniform value. */
+function toUniform(m) {
+	return Float32Array.from(m);
+}
+function apply(m, x, y) {
+	const a = m[0], b = m[1];
+	const c = m[3], d = m[4];
+	const tx = m[6], ty = m[7];
+	return [a * x + c * y + tx, b * x + d * y + ty];
+}
+/**
+* Map screen pixel coords (0..width on X, 0..height on Y, top-left origin)
+* into clip space (-1..1 on X, 1..-1 on Y — note Y flip so screen-down
+* matches clip-down).
+*/
+function screenToClip(width, height) {
+	return create(2 / width, 0, 0, -2 / height, -1, 1);
+}
+/**
+* Uniform-equivalent scale factor: the square root of the absolute
+* determinant of the linear part, i.e. the geometric mean of the two axis
+* scales. Rotation-invariant. Under non-uniform scale it is between the two
+* axes and exact on neither — the same compromise `meanScale` documents.
+*/
+function meanScaleOf(m) {
+	return Math.sqrt(Math.abs(m[0] * m[4] - m[1] * m[3]));
+}
+/** The least any direction is scaled by the linear part — its smaller singular
+*  value. What a screen length is worth in world units, at most. */
+function minScaleOf(m) {
+	const sum = m[0] * m[0] + m[1] * m[1] + m[3] * m[3] + m[4] * m[4];
+	const det = m[0] * m[4] - m[1] * m[3];
+	return Math.sqrt(Math.max(0, (sum - Math.sqrt(Math.max(0, sum * sum - 4 * det * det))) / 2));
+}
+/** The renderer's 3x3 matrix operations, as one namespace. These work on the
+*  9-element form the GL uniform upload wants — distinct from
+*  `@weasel-js/geom`'s 6-element affine `GlMat3`, though the logical element
+*  order is the same. */
+const mat3 = {
+	identity,
+	toAffine,
+	fromAffine,
+	multiply,
+	translated,
+	scaled,
+	invert,
+	toUniform,
+	apply,
+	screenToClip,
+	meanScaleOf,
+	minScaleOf
+};
+//#endregion
 //#region src/features/meshPaint/surface.ts
 /** Corner `i` of the boundary walk. */
 function patchCorner(patch, i) {
@@ -1159,12 +1317,15 @@ function mapPatches(mesh, move) {
 		points: patch.points.map(move)
 	}));
 }
+/** The paint a pose-frame copy was made from. A copy is rebuilt whenever its
+*  node's pose changes, and bakes the same texels as its source. */
+const BAKE_SOURCE = /* @__PURE__ */ new WeakMap();
 const CACHES = /* @__PURE__ */ new WeakMap();
 function cacheFor(ctx) {
 	let cache = CACHES.get(ctx.resources);
 	if (!cache) {
 		const gl = ctx.gl;
-		const made = new MeshBakeCache((entry) => gl.deleteTexture(entry.texture));
+		const made = new MeshBakeCache((texture) => gl.deleteTexture(texture));
 		ctx.resources.onRelease(() => {
 			made.clear();
 			CACHES.delete(ctx.resources);
@@ -1185,8 +1346,12 @@ function bakeFor(ctx, mesh) {
 	if (!box) return null;
 	const size = meshBakeSize(devicePixelsOf(ctx, mesh, box), ctx.maxTextureSize);
 	const cache = cacheFor(ctx);
-	const hit = cache.get(mesh, size);
-	if (hit) return hit;
+	const key = BAKE_SOURCE.get(mesh) ?? mesh;
+	const hit = cache.get(key, size);
+	if (hit) return {
+		texture: hit,
+		box
+	};
 	const baked = bakeMesh(mesh.patches, mesh.interpolate ?? "rgb", size);
 	if (!baked) return null;
 	const gl = ctx.gl;
@@ -1199,12 +1364,11 @@ function bakeFor(ctx, mesh) {
 	gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
 	gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, baked.size, baked.size, 0, gl.RGBA, gl.UNSIGNED_BYTE, baked.pixels);
 	gl.bindTexture(gl.TEXTURE_2D, null);
-	const entry = {
+	cache.set(key, size, texture);
+	return {
 		texture,
-		baked
+		box
 	};
-	cache.set(mesh, size, entry);
-	return entry;
 }
 function bindMesh(ctx, fill) {
 	const mesh = asMesh(fill);
@@ -1218,11 +1382,11 @@ function bindMesh(ctx, fill) {
 	const gl = ctx.gl;
 	gl.useProgram(program.handle);
 	ctx.setProjAndModel(program);
-	gl.uniformMatrix3fv(program.uniform("u_worldInv"), false, inverse);
+	gl.uniformMatrix3fv(program.uniform("u_worldInv"), false, mat3.toUniform(inverse));
 	gl.activeTexture(gl.TEXTURE0);
 	gl.bindTexture(gl.TEXTURE_2D, entry.texture);
 	gl.uniform1i(program.uniform("u_sampler"), 0);
-	const { box } = entry.baked;
+	const { box } = entry;
 	gl.uniform2f(program.uniform("u_meshOrigin"), box.x, box.y);
 	gl.uniform2f(program.uniform("u_meshSize"), box.width, box.height);
 	gl.uniform1f(program.uniform("u_opacity"), mesh.opacity ?? 1);
@@ -1247,7 +1411,7 @@ const meshGradientKind = {
 	inPoseFrame: (fill, box) => {
 		const mesh = asMesh(fill);
 		if (mesh.units !== "bounds") return fill;
-		return asFill({
+		const posed = asFill({
 			...mesh,
 			patches: mapPatches(mesh, (p) => ({
 				x: box.x + p.x * box.width,
@@ -1255,6 +1419,8 @@ const meshGradientKind = {
 			})),
 			units: "local"
 		});
+		BAKE_SOURCE.set(posed, fill);
+		return posed;
 	},
 	toBoundsFrame: (fill, box) => {
 		const mesh = asMesh(fill);