rig-c 2.32.1 → 2.32.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-c",
-  "version": "2.32.1",
+  "version": "2.32.2",
   "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

@@ -30,12 +30,27 @@ export interface Carrier {
   bary: [number, number, number];
 }
 
+/**
+ * Issue #1323's faults in resolving several carriers, for the `mesh-compare` suite's controls: the rule before the
+ * issue (the per-coordinate support alone, `slackSupport` never read); the slack read as the narrowest triangle's
+ * rather than the widest's; and any shared vertex excused whatever the distance, so two triangles that both hold a
+ * sample well inside — an overlap — carry it by the first.
+ */
+export type CarrierPlant = 'slack-support-unread' | 'narrowest-slack' | 'any-shared-vertex';
+
 /**
  * Each sample's carrier in one mesh's UV triangulation — §3 and correction 4.
  * Throws `COMPARE_UV_CARRIER_NOT_UNIQUE` for a sample two triangles carry
- * other than across a vertex or edge they share.
+ * other than across a vertex or edge they share — where "across" is read, since
+ * issue #1323, to the distance the containment slack itself allows
+ * (`slackSupport`).
  */
 export function uvCarriers(uvs: readonly number[], triangles: readonly number[], samples: ReadonlyArray<{ uv: [number, number] }>, who: string): Array<Carrier | null> {
+  return uvCarriersWith(uvs, triangles, samples, who, null);
+}
+
+/** `uvCarriers` with a fault planted in resolving several carriers (`CarrierPlant`). Internal: on no entry. */
+export function uvCarriersWith(uvs: readonly number[], triangles: readonly number[], samples: ReadonlyArray<{ uv: [number, number] }>, who: string, plant: CarrierPlant | null): Array<Carrier | null> {
   const areas = triangleAreas(uvs, triangles);
   const band = areaBand(areas, uvs);
   const live: number[] = [];
@@ -101,7 +116,8 @@ export function uvCarriers(uvs: readonly number[], triangles: readonly number[],
       }
     });
   }
-  return samples.map((s, j) => resolveCarriers(s.uv[0], s.uv[1], hits[j] ?? [], who));
+  const uvOf = (v: number): readonly [number, number] => [uvs[v * 2], uvs[v * 2 + 1]];
+  return samples.map((s, j) => resolveCarriers(s.uv[0], s.uv[1], hits[j] ?? [], who, uvOf, plant));
 }
 
 /**
@@ -143,21 +159,32 @@ export function carrierIn(
 
 /**
  * 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).
+ * meet there at a shared vertex or edge; else `COMPARE_UV_CARRIER_NOT_UNIQUE` (correction 4). Where the per-coordinate
+ * support refuses, the support is read again to the slack's distance (issue #1323, {@link slackSupport}) when the
+ * corners' UVs are given (`uvOf`).
  */
-export function resolveCarriers(px: number, py: number, hits: readonly Carrier[], who: string): Carrier | null {
+export function resolveCarriers(
+  px: number,
+  py: number,
+  hits: readonly Carrier[],
+  who: string,
+  uvOf: ((v: number) => readonly [number, number]) | null = null,
+  plant: CarrierPlant | null = null,
+): 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 =>
+  const shared = (supportOf: (c: Carrier) => string): boolean => {
+    const first = supportOf(hits[0]);
+    return first.split(',').length <= 2 && hits.every((c) => supportOf(c) === first);
+  };
+  const byCoordinate = (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) {
+  if (!shared(byCoordinate) && (uvOf === null || plant === 'slack-support-unread' || !shared(slackSupport(hits, uvOf, plant)))) {
     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)`,
@@ -165,3 +192,48 @@ export function resolveCarriers(px: number, py: number, hits: readonly Carrier[]
   }
   return hits[0];
 }
+
+/**
+ * Issue #1323: a carrier's support read to the slack's distance rather than per coordinate — the corners the sample
+ * lies further than `CONTAINS × H` (UV units) inside of, measured from each corner's opposite edge, with `H` the widest
+ * triangle height among the hits: the furthest outside a triangle the containment test (`carrierIn`) admitted any of
+ * them at this sample.
+ *
+ * Why: the slack is per barycentric coordinate, so in distance it is `CONTAINS` times the height of the corner it is
+ * read against. A sample on a shared edge, a hair to one side — a pixel centre on a 45° or axis-parallel edge between
+ * whole-pixel vertices, put off it by the UVs' rounding — is admitted by the triangle it is outside of, while the
+ * triangle it is inside of, if it is a sliver, reads its third corner's coordinate above `CONTAINS` because its height
+ * is small: two per-coordinate supports, read as an overlap though the sample is within the slack of the edge both
+ * share. Measured on demo/bottomwear's reduction at source spacing 18: 1.35e-10 uv from the edge, coordinates −3.2e-10
+ * and +6.5e-8, heights 0.42 and 0.0021. Read in distance, both corners are within the slack and the support is the
+ * shared edge. A sample two triangles both hold further inside than that — an overlap or a fold — is still refused.
+ */
+function slackSupport(hits: readonly Carrier[], uvOf: (v: number) => readonly [number, number], plant: CarrierPlant | null): (c: Carrier) => string {
+  if (plant === 'any-shared-vertex') {
+    const common = hits[0].corners.filter((v) => hits.every((c) => c.corners.includes(v)));
+    return () => (common.length > 0 ? [...common].sort((a, b) => a - b).slice(0, 1).join(',') : 'none');
+  }
+  const heights = new Map<Carrier, [number, number, number]>();
+  let widest = 0;
+  let narrowest = Infinity;
+  for (const c of hits) {
+    const p = c.corners.map(uvOf);
+    const twice = Math.abs((p[1][0] - p[0][0]) * (p[2][1] - p[0][1]) - (p[2][0] - p[0][0]) * (p[1][1] - p[0][1]));
+    const h = [0, 1, 2].map((k) => {
+      const a = p[(k + 1) % 3];
+      const b = p[(k + 2) % 3];
+      return twice / Math.hypot(b[0] - a[0], b[1] - a[1]);
+    }) as [number, number, number];
+    heights.set(c, h);
+    widest = Math.max(widest, ...h);
+    narrowest = Math.min(narrowest, ...h);
+  }
+  const slack = CONTAINS * (plant === 'narrowest-slack' ? narrowest : widest);
+  return (c: Carrier): string => {
+    const h = heights.get(c)!;
+    return c.corners
+      .filter((_v, k) => c.bary[k] * h[k] > slack)
+      .sort((a, b) => a - b)
+      .join(',');
+  };
+}

package/src/meshcompare.ts

@@ -104,7 +104,7 @@ import {
   type WorstSample,
 } from './meshquality.ts';
 import { areaBand, stretchSingularValues, triangleAreas } from './areaband.ts';
-import { uvCarriers, type Carrier } from './meshcarriers.ts';
+import { uvCarriers, uvCarriersWith, type Carrier, type CarrierPlant } from './meshcarriers.ts';
 import { CoreInputError, readModel, underNoSkin, underSkin, type CompiledDocument } from './core/index.ts';
 import { poseRawAnimationEach, poseRawSetup, type RawPose } from './core/raw.ts';
 import { sampleTime } from './core/animation.ts';
@@ -186,7 +186,9 @@ export interface MotionComparisonInput {
  * Issue #1291's faults in carrying `motionAmplitude` into the setup measurement, for the `mesh-compare` suite's
  * negative controls: the amplitude not handed over; `null` handed over as the field left out; the field not validated
  * before the builds are read; `null` echoed for a field left out; and the load counted as a required row, so the
- * amplitude moves a verdict. `compareMeshesInMotion` plants none.
+ * amplitude moves a verdict. `compareMeshesInMotion` plants none. Issue #1323 adds `CarrierPlant`
+ * (`src/meshcarriers.ts`): a fault in resolving a sample's several carriers, planted in every `uvCarriers` the
+ * comparison reads.
  */
 export type ComparePlant =
   | 'amplitude-not-carried'
@@ -194,7 +196,8 @@ export type ComparePlant =
   | 'amplitude-unvalidated'
   | 'echo-when-unset'
   | 'amplitude-gates-acceptance'
-  | OverBoundPlant;
+  | OverBoundPlant
+  | CarrierPlant;
 
 /**
  * Issue #1315's faults in `overBound`, for the `mesh-compare` suite's negative controls: a listed sample's triangle
@@ -995,11 +998,14 @@ function compareMeshesInMotionWith(input: MotionComparisonInput, plant: CompareP
       }
       return { samples: out, art };
     });
-    const refCarriers = order.map((i, k) => uvCarriers(reference.meshes[i].uvs, reference.meshes[i].triangles, samplesOf[k].samples, `reference "${reference.id}", attachment ${nameOf(refs[i])}`));
+    const carrierPlant: CarrierPlant | null = plant === 'slack-support-unread' || plant === 'narrowest-slack' || plant === 'any-shared-vertex' ? plant : null;
+    const carriersOf = (uvs: readonly number[], triangles: readonly number[], samples: ReadonlyArray<{ uv: [number, number] }>, who: string): Array<Carrier | null> =>
+      uvCarriersWith(uvs, triangles, samples, who, carrierPlant);
+    const refCarriers = order.map((i, k) => carriersOf(reference.meshes[i].uvs, reference.meshes[i].triangles, samplesOf[k].samples, `reference "${reference.id}", attachment ${nameOf(refs[i])}`));
     const posedRef = poseBuild(reference.doc, order.map((i) => refs[i]), frames, walks);
 
     motionOf = (b: Build, isReference: boolean) => {
-      const carriers = isReference ? refCarriers : order.map((i, k) => uvCarriers(b.meshes[i].uvs, b.meshes[i].triangles, samplesOf[k].samples, `candidate "${b.id}", attachment ${nameOf(refs[i])}`));
+      const carriers = isReference ? refCarriers : order.map((i, k) => carriersOf(b.meshes[i].uvs, b.meshes[i].triangles, samplesOf[k].samples, `candidate "${b.id}", attachment ${nameOf(refs[i])}`));
       const posed = isReference ? posedRef : poseBuild(b.doc, order.map((i) => refs[i]), frames, walks);
       const built: Built[] = [];
       const perFrame: NonNullable<CandidateReport['perFrame']> = [];

package/src/meshskinning.ts

@@ -1235,7 +1235,7 @@ export class SkinningCarry {
       }
       let carrier: Carrier | null;
       try {
-        carrier = resolveCarriers(this.su[j], this.sv[j], hits, `${this.who}: candidate (working vertex ids)`);
+        carrier = resolveCarriers(this.su[j], this.sv[j], hits, `${this.who}: candidate (working vertex ids)`, (v) => this.mesh.uv[v]);
       } catch (err) {
         if (!(err instanceof MeshReductionError)) throw err;
         if (pending.refused === null) pending.refused = `SKINNING_UV_CARRIER_NOT_UNIQUE: ${err.message}`;