rig-c 2.30.0 → 2.31.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-c",
-  "version": "2.30.0",
+  "version": "2.31.0",
   "description": "AI-authored Spine 2D rigging and animation, verified before it is written. rigc compiles a rig spec into Spine 4.3 skeleton data, gates it with named assertions held to a spine-core round trip's verdicts, and emits nothing that fails. Output imports into the Spine editor. Ships as an agent skill.",
   "type": "module",
   "bin": {

package/src/meshcarriers.ts

@@ -17,7 +17,7 @@ import { MeshReductionError } from './mesh.ts';
 import { areaBand, triangleAreas } from './areaband.ts';
 
 /** `pointInTriangle`'s epsilon in `src/mesh.ts`, applied to each barycentric coordinate. */
-const CONTAINS = 1e-9;
+export const CONTAINS = 1e-9;
 
 function refuse(code: string, message: string): never {
   throw new MeshReductionError(code, message);
@@ -47,47 +47,121 @@ export function uvCarriers(uvs: readonly number[], triangles: readonly number[],
     const ys = [uvs[triangles[t * 3] * 2 + 1], uvs[triangles[t * 3 + 1] * 2 + 1], uvs[triangles[t * 3 + 2] * 2 + 1]];
     boxes.push(Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys));
   }
-  return samples.map((s) => {
-    const [px, py] = s.uv;
-    const hits: Carrier[] = [];
+  const u = (v: number): number => uvs[v * 2];
+  const w = (v: number): number => uvs[v * 2 + 1];
+  // Issue #1295: the samples bucketed on a uniform grid, so each live triangle is tested only against the samples in
+  // the cells its box (with the containment slack) overlaps — every (sample, triangle) pair the box test could pass is
+  // still tested, by the same `carrierIn`, and each sample's hits are gathered in ascending triangle index, the order
+  // a scan of every live triangle per sample gathered them in. The carriers are that scan's, value for value; what
+  // changes is that the work no longer grows with samples × triangles.
+  const n = samples.length;
+  const hits: Array<Carrier[] | null> = new Array(n).fill(null);
+  if (n > 0 && live.length > 0) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const s of samples) {
+      minX = Math.min(minX, s.uv[0]);
+      minY = Math.min(minY, s.uv[1]);
+      maxX = Math.max(maxX, s.uv[0]);
+      maxY = Math.max(maxY, s.uv[1]);
+    }
+    const G = Math.max(1, Math.min(1024, Math.ceil(Math.sqrt(n / 4))));
+    const cw = (maxX - minX) / G || 1;
+    const ch = (maxY - minY) / G || 1;
+    const cellX = (x: number): number => Math.min(G - 1, Math.max(0, Math.floor((x - minX) / cw)));
+    const cellY = (y: number): number => Math.min(G - 1, Math.max(0, Math.floor((y - minY) / ch)));
+    const start = new Int32Array(G * G + 1);
+    const cellOf = new Int32Array(n);
+    samples.forEach((s, j) => {
+      cellOf[j] = cellY(s.uv[1]) * G + cellX(s.uv[0]);
+      start[cellOf[j] + 1]++;
+    });
+    for (let c = 0; c < G * G; c++) start[c + 1] += start[c];
+    const order = new Int32Array(n);
+    const fill = start.slice(0, G * G);
+    for (let j = 0; j < n; j++) order[fill[cellOf[j]]++] = j;
+    const slack = 1e-9;
     live.forEach((t, k) => {
-      const slack = 1e-9;
-      if (px < boxes[k * 4] - slack || py < boxes[k * 4 + 1] - slack || px > boxes[k * 4 + 2] + slack || py > boxes[k * 4 + 3] + slack) return;
-      const i0 = triangles[t * 3];
-      const i1 = triangles[t * 3 + 1];
-      const i2 = triangles[t * 3 + 2];
-      const ax = uvs[i0 * 2];
-      const ay = uvs[i0 * 2 + 1];
-      const bx = uvs[i1 * 2] - ax;
-      const by = uvs[i1 * 2 + 1] - ay;
-      const cx = uvs[i2 * 2] - ax;
-      const cy = uvs[i2 * 2 + 1] - ay;
-      const qx = px - ax;
-      const qy = py - ay;
-      const det = bx * cy - cx * by;
-      const l1 = (qx * cy - cx * qy) / det;
-      const l2 = (bx * qy - qx * by) / det;
-      const l0 = 1 - l1 - l2;
-      if (l0 < -CONTAINS || l1 < -CONTAINS || l2 < -CONTAINS) return;
-      hits.push({ triangle: t, corners: [i0, i1, i2], bary: [l0, l1, l2] });
+      const [x0, y0, x1, y1] = [boxes[k * 4], boxes[k * 4 + 1], boxes[k * 4 + 2], boxes[k * 4 + 3]];
+      const cy0 = cellY(y0 - slack);
+      const cy1 = cellY(y1 + slack);
+      const cx0 = cellX(x0 - slack);
+      const cx1 = cellX(x1 + slack);
+      for (let cy = cy0; cy <= cy1; cy++) {
+        for (let cx = cx0; cx <= cx1; cx++) {
+          const c = cy * G + cx;
+          for (let q = start[c]; q < start[c + 1]; q++) {
+            const j = order[q];
+            const hit = carrierIn(samples[j].uv[0], samples[j].uv[1], x0, y0, x1, y1, triangles[t * 3], triangles[t * 3 + 1], triangles[t * 3 + 2], u, w, t);
+            if (hit !== null) (hits[j] ??= []).push(hit);
+          }
+        }
+      }
     });
-    if (hits.length === 0) return null;
-    if (hits.length === 1) return hits[0];
-    // Several carriers are one hit only across a vertex or an edge they all share: the sample's support — the corners
-    // it does not sit at zero weight on — is then the same vertex indices in each, and the carried point is theirs.
-    const support = (c: Carrier): string =>
-      c.corners
-        .filter((_v, k) => c.bary[k] > CONTAINS)
-        .sort((a, b) => a - b)
-        .join(',');
-    const first = support(hits[0]);
-    const shared = first.split(',').length <= 2 && hits.every((c) => support(c) === first);
-    if (!shared) {
-      refuse(
-        'COMPARE_UV_CARRIER_NOT_UNIQUE',
-        `${who}: the sample at uv (${px}, ${py}) lies in ${hits.length} UV triangles — ${hits.map((c) => `triangle ${c.triangle} (vertices ${c.corners.join(', ')})`).join(' and ')} — that do not meet there at a shared vertex or edge; required one carrier per sample (correction 4: overlapping or folded UV triangles would carry it by an arbitrary one)`,
-      );
-    }
-    return hits[0];
-  });
+  }
+  return samples.map((s, j) => resolveCarriers(s.uv[0], s.uv[1], hits[j] ?? [], who));
+}
+
+/**
+ * Whether the UV triangle i0, i1, i2 (`t`, its box x0..x1, y0..y1) carries the sample at (px, py), and where: the
+ * carrier, or null. The one containment test — `uvCarriers` and the reduction's carried residual (issue #1295) both
+ * read it, so a sample is in a triangle by one arithmetic.
+ */
+export function carrierIn(
+  px: number,
+  py: number,
+  x0: number,
+  y0: number,
+  x1: number,
+  y1: number,
+  i0: number,
+  i1: number,
+  i2: number,
+  u: (v: number) => number,
+  v: (v: number) => number,
+  t: number,
+): Carrier | null {
+  const slack = 1e-9;
+  if (px < x0 - slack || py < y0 - slack || px > x1 + slack || py > y1 + slack) return null;
+  const ax = u(i0);
+  const ay = v(i0);
+  const bx = u(i1) - ax;
+  const by = v(i1) - ay;
+  const cx = u(i2) - ax;
+  const cy = v(i2) - ay;
+  const qx = px - ax;
+  const qy = py - ay;
+  const det = bx * cy - cx * by;
+  const l1 = (qx * cy - cx * qy) / det;
+  const l2 = (bx * qy - qx * by) / det;
+  const l0 = 1 - l1 - l2;
+  if (l0 < -CONTAINS || l1 < -CONTAINS || l2 < -CONTAINS) return null;
+  return { triangle: t, corners: [i0, i1, i2], bary: [l0, l1, l2] };
+}
+
+/**
+ * The carrier of a sample from every triangle that contains it: none, the one, or — several — the first when they all
+ * meet there at a shared vertex or edge; else `COMPARE_UV_CARRIER_NOT_UNIQUE` (correction 4).
+ */
+export function resolveCarriers(px: number, py: number, hits: readonly Carrier[], who: string): Carrier | null {
+  if (hits.length === 0) return null;
+  if (hits.length === 1) return hits[0];
+  // Several carriers are one hit only across a vertex or an edge they all share: the sample's support — the corners
+  // it does not sit at zero weight on — is then the same vertex indices in each, and the carried point is theirs.
+  const support = (c: Carrier): string =>
+    c.corners
+      .filter((_v, k) => c.bary[k] > CONTAINS)
+      .sort((a, b) => a - b)
+      .join(',');
+  const first = support(hits[0]);
+  const shared = first.split(',').length <= 2 && hits.every((c) => support(c) === first);
+  if (!shared) {
+    refuse(
+      'COMPARE_UV_CARRIER_NOT_UNIQUE',
+      `${who}: the sample at uv (${px}, ${py}) lies in ${hits.length} UV triangles — ${hits.map((c) => `triangle ${c.triangle} (vertices ${c.corners.join(', ')})`).join(' and ')} — that do not meet there at a shared vertex or edge; required one carrier per sample (correction 4: overlapping or folded UV triangles would carry it by an arbitrary one)`,
+    );
+  }
+  return hits[0];
 }

package/src/meshquality.ts

@@ -71,7 +71,7 @@ import {
 } from './mesh.ts';
 import { areaBand, triangleAreas } from './areaband.ts';
 import { allocationContrast, boundaryNecessityOnce, deformLoad, gradeMax, minAngleP10, type AllocationArt, type AllocationPlant } from './meshallocation.ts';
-import { skinningEchoOf, skinningResidual, validateSkinning, type SkinningDetail, type SkinningEcho, type SkinningPlant, type SkinningResidualInput } from './meshskinning.ts';
+import { skinningEchoOf, skinningResidual, validateSkinning, type ReductionSkinning, type SkinningDetail, type SkinningEcho, type SkinningPlant, type SkinningResidualInput } from './meshskinning.ts';
 import { artRastersOf, type ArtRasters, type CoverageReading, type OutlineMemo, type RegionEdgeReading, type SilhouetteReading, type StepRasters } from './meshrasters.ts';
 import { cropToSpineY } from './transform.ts';
 
@@ -147,6 +147,16 @@ export interface ReductionTargets {
   minAngle?: number;
   /** Local density requirements — §5. */
   regions: RefinementRegion[];
+  /**
+   * Issue #1295 (§7 mechanism 1, the reducer half) — opt-in. Left out = no step reads a residual and the call is the
+   * one it was before the field existed, byte for byte. Set, every removal, boundary run and triangulation post-pass is
+   * taken only when `MQ_SKINNING_RESIDUAL` of its result against the call's own `source` — the original, never a
+   * previous step — is within `maxResidual` and every other required row passes; refinement insertions are not vetoed
+   * one by one, and the refined mesh is held to it before any removal. The result's measurement carries the row.
+   * `null` declares it absent (no row read by a step, the result's row `not-measurable` saying so); anything else that
+   * is not `{ envelope, maxResidual }` in full is refused `REDUCE_INPUT_MISSING` naming its path, before any work.
+   */
+  skinning?: ReductionSkinning | null;
 }
 
 /** P16/P17: a local density requirement over a closed polygon. */
@@ -2359,6 +2369,11 @@ function targetsJson(t: ReductionTargets | MeasureTargets | null): Json {
   const out: { [key: string]: Json } = { artFit: fitJson(t.artFit), maxBoundaryDeviation: t.maxBoundaryDeviation };
   if (t.minAngle !== undefined) out.minAngle = t.minAngle;
   out.regions = t.regions.map(regionJson);
+  // Issue #1295: a reduction's `targets.skinning`, echoed when the input set it — `null` included — and never otherwise.
+  if ('skinning' in t && t.skinning !== undefined) {
+    const k = t.skinning;
+    out.skinning = k === null ? null : { envelope: { reference: k.envelope.reference, bones: k.envelope.bones.map((b) => ({ bone: b.bone, linear: b.linear, pivot: pair(b.pivot), translation: b.translation })) }, maxResidual: k.maxResidual };
+  }
   return out;
 }