@rig-c/parts 1.9.0 → 1.10.0

package/src/headframe.ts

@@ -34,6 +34,7 @@
 import type { Point } from './config.ts';
 import { cropToSpineY } from './coords.ts';
 import type { Mask } from './raster/types.ts';
+import { edgeLength } from './length.ts';
 
 /**
  * The eye line's angle in Spine degrees (counter-clockwise, y up) through two
@@ -167,7 +168,7 @@ export function headFrame(
   const [l, r] = eyes[0][0] < eyes[1][0] ? [eyes[0], eyes[1]] : [eyes[1], eyes[0]];
   const dx = r[0] - l[0];
   const dy = r[1] - l[1];
-  const bar = Math.hypot(dx, dy);
+  const bar = edgeLength(dx, dy);
   const u: [number, number] = [dx / bar, dy / bar];
   // The bar's perpendicular toward the chin: u turned a quarter clockwise as drawn (y down).
   const n: [number, number] = [-u[1], u[0]];

package/src/instruments.ts

@@ -23,6 +23,7 @@
  */
 import type { StageBox, Viewport } from './check.ts';
 import { cropToSpineY } from './coords.ts';
+import { edgeLength } from './length.ts';
 import { OPAQUE_ALPHA_ABOVE } from './layers.ts';
 import { type PartRecord, type PartsFile, tagOf } from './parts.ts';
 import type { Raster } from './raster/types.ts';
@@ -446,7 +447,7 @@ export function halfTravels(art: ArtMask, box: { x: number; y: number; w: number
     for (const f of frames) {
       const c = f === null ? null : centroidIn(f, ...band);
       if (c === null) continue;
-      max = Math.max(max, Math.hypot(c[0] - c0[0], c[1] - c0[1]));
+      max = Math.max(max, edgeLength(c[0] - c0[0], c[1] - c0[1]));
     }
     return max;
   };
@@ -508,7 +509,7 @@ export function readSine(keys: readonly Key[], duration: number): SineReading |
     }
     a *= 2 / n;
     b *= 2 / n;
-    const mag = Math.hypot(a, b);
+    const mag = edgeLength(a, b);
     if (mag > best.mag) best = { j, a, b, mag };
   }
   if (best.j === 0) return null;
@@ -780,6 +781,9 @@ export function stretchSeverity(ratio: number): number {
   return ratio >= 1 ? ratio : 1 / ratio;
 }
 
+/** An edge's length: {@link edgeLength} of `src/length.ts` (issues #270, #279), re-exported where the stretch reader first used it. */
+export { edgeLength } from './length.ts';
+
 /**
  * For every mesh in `rest`, every triangle's three edges in every frame that
  * shows the attachment: deformed length over rest length, the largest and the
@@ -792,7 +796,7 @@ export function stretchFigures(rest: readonly MeshRest[], frames: readonly Geome
   return rest.map((m) => {
     const t = m.triangles;
     const v0 = m.vertices;
-    const len = (v: readonly number[], a: number, b: number): number => Math.hypot(v[2 * a] - v[2 * b], v[2 * a + 1] - v[2 * b + 1]);
+    const len = (v: readonly number[], a: number, b: number): number => edgeLength(v[2 * a] - v[2 * b], v[2 * a + 1] - v[2 * b + 1]);
     const out: MeshStretch = { slot: m.slot, attachment: m.attachment, triangles: t.length / 3, frames: 0, max: null, min: null, degenerate: [] };
     const restLen: number[] = [];
     for (let i = 0; i < t.length; i += 3) {
@@ -1032,7 +1036,7 @@ export function stillReading(art: ArtMask, stage: StageBox, frames: ReadonlyArra
       const e2x = d[2 * l] - x0;
       const e2y = d[2 * l + 1] - y0;
       for (const bary of pc.pieces[t]) {
-        for (let q = 0; q < bary.length; q += 2) fmax = Math.max(fmax, Math.hypot(x0 + bary[q] * e1x + bary[q + 1] * e2x, y0 + bary[q] * e1y + bary[q + 1] * e2y));
+        for (let q = 0; q < bary.length; q += 2) fmax = Math.max(fmax, edgeLength(x0 + bary[q] * e1x + bary[q + 1] * e2x, y0 + bary[q] * e1y + bary[q + 1] * e2y));
       }
       const cx = x0 + pc.centroid[2 * t] * e1x + pc.centroid[2 * t + 1] * e2x;
       const cy = y0 + pc.centroid[2 * t] * e1y + pc.centroid[2 * t + 1] * e2y;
@@ -1101,7 +1105,7 @@ export function crossingOf(art: ArtMask, stage: StageBox, frames: ReadonlyArray<
           if (Math.max(Math.abs(u - u0), Math.abs(v - v0)) !== r || inR(u, v)) continue;
           const sx0 = stage.x + u;
           const sy1 = stage.y + cropToSpineY(v, H);
-          best = Math.min(best, Math.hypot(Math.max(sx0 - x, 0, x - sx0 - 1), Math.max(sy1 - 1 - y, 0, y - sy1)));
+          best = Math.min(best, edgeLength(Math.max(sx0 - x, 0, x - sx0 - 1), Math.max(sy1 - 1 - y, 0, y - sy1)));
         }
       }
     }

package/src/layers.ts

@@ -25,6 +25,11 @@
  * and for a PSD it is the stacking order itself, with `depth` null because a
  * PSD carries none. Every refusal is collected and thrown once, so one run
  * names every missing file.
+ *
+ * A layer is named by a See-through v3 tag or, for a layer the author made
+ * by hand and added to the run (issue #256), by `author:<label>`
+ * (`src/tags.ts`, `AUTHOR_PREFIX`): read with `group` "author", it has no
+ * role, and its place in the draw order is read like any other layer's.
  */
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
@@ -32,7 +37,7 @@ import { initializeCanvas, type Layer as PsdLayer, readPsd } from 'ag-psd';
 import { type Problem, refuseIfAny } from './errors.ts';
 import { decodePngBytes } from './raster/png.ts';
 import type { Raster } from './raster/types.ts';
-import { acceptedTagNames, readTag, type TagReading } from './tags.ts';
+import { type LayerTagReading, layerTagRequirement, readLayerTag } from './tags.ts';
 
 /** Alpha strictly above this counts as painted. The reference uses the same cut for its ghost clean-up and its sheets. */
 export const OPAQUE_ALPHA_ABOVE = 8;
@@ -45,9 +50,9 @@ export const OPAQUE_ALPHA_ABOVE = 8;
 export const NEAR_WHITE_MIN = 235;
 
 export interface Layer {
-  /** As the input names it; always a v3 tag, possibly with a `-r`/`-l` side. */
+  /** As the input names it: a v3 tag, possibly with a `-r`/`-l` side, or an author-made layer's `author:<label>`. */
   name: string;
-  tag: TagReading;
+  tag: LayerTagReading;
   /** The file the pixels came from, or null for a PSD layer. */
   file: string | null;
   /** The layer's own pixels, `(right-left)x(bottom-top)`, straight alpha. */
@@ -197,9 +202,9 @@ export function readWrapperLayers(path: string): LayerSet {
       return;
     }
     const name = e.name;
-    const tag = readTag(name);
+    const tag = readLayerTag(name);
     if (tag === null) {
-      refuse('LAYERS_TAG_KNOWN', `layer "${name}"`, `is not a See-through v3 tag; one of ${acceptedTagNames().join(', ')} is required`);
+      refuse('LAYERS_TAG_KNOWN', `layer "${name}"`, layerTagRequirement(name));
       ok = false;
     }
     for (const key of ['left', 'top', 'right', 'bottom'] as const) {
@@ -369,9 +374,9 @@ export function readPsdLayers(path: string): LayerSet {
   const layers: Layer[] = [];
   leaves.forEach((layer) => {
     const name = layer.name ?? '';
-    const tag = readTag(name);
+    const tag = readLayerTag(name);
     if (tag === null) {
-      refuse('LAYERS_TAG_KNOWN', `PSD layer "${name}"`, `is not a See-through v3 tag; one of ${acceptedTagNames().join(', ')} is required`);
+      refuse('LAYERS_TAG_KNOWN', `PSD layer "${name}"`, layerTagRequirement(name));
       return;
     }
     if (seen.has(name)) {

package/src/length.ts

@@ -0,0 +1,21 @@
+/**
+ * The one length this package writes (issues #270, #279): `sqrt(dx * dx + dy * dy)`.
+ *
+ * Not `Math.hypot`. The language does not promise how `Math.hypot` rounds, and
+ * Bun 1.4.2 rounds it differently on two platforms: on the demo's `earring`,
+ * edge 11-10 at idle frame 10 (dx 34.26716181006313, dy 0.5713103861783111),
+ * it is 34.27192399143071 on macOS and 34.27192399143072 on Linux, measured,
+ * with the posed vertices bit-identical on both. That last bit decided which of
+ * two edges 2 ulp apart held a mesh's largest ratio, so `TEXTURE_STRETCH`'s
+ * `max_at` named one triangle on one machine and another on the other (#276).
+ * A multiply, an add and a square root are each correctly rounded by IEEE 754,
+ * so this gives the same bits everywhere (34.27192399143071 on both, measured).
+ * At pixel scale `Math.hypot`'s guard against overflow is not needed: a
+ * coordinate would have to pass about 1e154 for the squares to overflow.
+ *
+ * The tree rule `TY15` refuses a call of `Math.hypot` anywhere under `src/` and in
+ * `cli.ts`, so every length is this one.
+ */
+export function edgeLength(dx: number, dy: number): number {
+  return Math.sqrt(dx * dx + dy * dy);
+}