rig-parts 1.72.0 → 1.72.1

package/docs/AUTHORING.md

@@ -4518,7 +4518,7 @@ and stay absent).
 | <a id="CONFIG_TURN_HEAD_BONE"></a>`CONFIG_TURN_HEAD_BONE` | `config.turn.roles` is declared without a single bone `"head"` in `config.bones`, or `config.turn.body` without a single bone `"chest"` / `"hip"` (or its declared `bone`) | declare `"head"` (or the body turn root bone) as a single bone in `config.bones` |
 | <a id="CONFIG_TURN_SLIDER_NAME_FREE"></a>`CONFIG_TURN_SLIDER_NAME_FREE` | `config.turn.body.slider` (or the default `"body_yaw_dial"`) collides with a head turn dial (`"yaw"`, `"pitch"`, `"yaw_dial"`, `"pitch_dial"`) or an existing slider constraint in `config.constraints` (#787) | choose a distinct slider name in `config.turn.body.slider` |
 | <a id="RIG_TURN_SURFACE_MESH_GROUPS"></a>`RIG_TURN_SURFACE_MESH_GROUPS` | a surface part contains a blended attachment but lacks one 2.5D group, includes an ungrouped positive influence in any attachment, or also declares a unit/rear role | declare both `turn.roles` and `turn.body`, a body root outside head, surface in one or both groups, and bindings wholly inside those two subtrees |
-| <a id="RIG_TURN_SURFACE_MESH_BINDINGS"></a>`RIG_TURN_SURFACE_MESH_BINDINGS` | an authored surface mesh has unresolved/nonclosing weights or shares a frame moved by a unit/rear turn carrier | provide weighted bindings closing at 1 in the authored frame; use independent chains for parts with different roles |
+| <a id="RIG_TURN_SURFACE_MESH_BINDINGS"></a>`RIG_TURN_SURFACE_MESH_BINDINGS` | an authored surface mesh has unresolved/nonclosing weights or shares a frame moved by a unit/rear turn carrier; declared stop draw aliases resolve to their links for setup sampling | provide weighted bindings closing at 1 in the authored frame; `<link>_d` resolves only for links declared in `config.stops`; use independent chains for parts with different roles |
 | <a id="RIG_TURN_SURFACE_MESH_ATTACHMENT"></a>`RIG_TURN_SURFACE_MESH_ATTACHMENT` | a surface mesh has an alternate drawing without its own registered depth sampling frame | use the base attachment; explicit islands retain their own slot, attachment and bindings |
 | <a id="RIG_TURN_SURFACE_DEPTH_REQUIRED"></a>`RIG_TURN_SURFACE_DEPTH_REQUIRED` | a part with role `"surface"` in `config.turn.roles` or `config.turn.body.roles` carries no depth sheet in `parts.json` | run `assemble` with `config.depth` or provide `<part>_depth.png` in `parts.json` |
 | <a id="RIG_TURN_GRID_BUDGET"></a>`RIG_TURN_GRID_BUDGET` | a `"surface"` grid exceeds 2,400 triangles on one slot or 4,000 triangles across all `"surface"` slots | lower `config.turn.grid` / `config.turn.body.grid` `[cols, rows]` within the per-slot and total budgets |
@@ -5575,6 +5575,13 @@ dial; see [`CONFIG_TURN_ROLE_UNKNOWN`](#CONFIG_TURN_ROLE_UNKNOWN),
 [`RIG_TURN_SURFACE_MESH_BINDINGS`](#RIG_TURN_SURFACE_MESH_BINDINGS),
 [`CONFIG_TURN_UNIT_MESH_BONES`](#CONFIG_TURN_UNIT_MESH_BONES) and
 [`CONFIG_TURN_SLIDER_NAME_FREE`](#CONFIG_TURN_SLIDER_NAME_FREE).
+Weighted surfaces may bind chains declared in `config.stops` (#800). The
+sampler resolves each declared `<link>_d` draw alias and any child parent using
+it to the original link's setup frame, as `flattenRig` does. Weights, child
+parents and stops keep their emitted names; Core creates the draw bones later.
+A name ending in `_d` alone is not an alias: a missing non-stop bone still
+raises `RIG_TURN_SURFACE_MESH_BINDINGS`. No new config field is required.
+
 A weighted surface spanning the head and body subtrees (#796) takes both
 fields. Declare it as `"surface"` in `turn.roles` or `turn.body.roles` (both is
 also accepted), with both 2.5D groups present. Head descendants belong to the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-parts",
-  "version": "1.72.0",
+  "version": "1.72.1",
   "description": "AI-authored 2D character parts from one anime painting and its See-through layer decomposition: measured parts, weighted-mesh rig specs, verified through rig-c before anything is written. A CLI for agents that cannot see the image.",
   "type": "module",
   "bin": {

package/src/turn.ts

@@ -1512,12 +1512,25 @@ interface Depth25DGroupSpec {
   }>;
 }
 
+interface Depth25DTurnRig {
+  bones: Array<{ name: string; parent?: string; x: number; y: number; rotation?: number; length?: number }>;
+  slots: Array<{ name: string; bone: string; attachment: string | null }>;
+  constraints?: Array<Record<string, unknown>>;
+  stops?: ReadonlyArray<{ links: readonly string[] }>;
+}
+
+/** Stop draw bones share their link's setup frame; Core emits them later. */
+function surfaceSetupGraph(rig: Depth25DTurnRig) {
+  const aliases = new Map<string, string>();
+  for (const stop of rig.stops ?? []) for (const link of stop.links) aliases.set(`${link}_d`, link);
+  const resolve = (name: string): string => aliases.get(name) ?? name;
+  // Like flattenRig: resolve parents as well as weights, without changing the rig.
+  const bones = rig.bones.map(b => b.parent === undefined ? b : { ...b, parent: resolve(b.parent) });
+  return { bones, resolve };
+}
+
 function buildDepth25DTurnGroup(
-  rig: {
-    bones: Array<{ name: string; parent?: string; x: number; y: number; rotation?: number; length?: number }>;
-    slots: Array<{ name: string; bone: string; attachment: string | null }>;
-    constraints?: Array<Record<string, unknown>>;
-  },
+  rig: Depth25DTurnRig,
   motion: {
     groups?: Record<string, string[]>;
     animations: Record<string, unknown>;
@@ -1814,7 +1827,8 @@ function buildDepth25DTurnGroup(
     for (const [part, { rec, ext, zRef }] of surfaceSheets) {
       const authored = opts.surfaceMeshes?.filter((m) => m.part === part) ?? [];
       if (authored.length > 0) {
-        const world = computeWorldTransforms(rig.bones);
+        const setup = surfaceSetupGraph(rig);
+        const world = computeWorldTransforms(setup.bones);
         for (const mesh of authored) {
           // An all-zero timeline can overwrite another slider's deform (Core A40).
           // A sibling with no positive binding in this group owns no timeline here.
@@ -1822,19 +1836,19 @@ function buildDepth25DTurnGroup(
           const vertices = mesh.weights.map((row, index) => {
             let wx = 0, wy = 0, total = 0;
             for (const w of row) {
-              const frame = world.get(w.bone);
+              const frame = world.get(setup.resolve(w.bone));
               if (frame === undefined) {
                 problems.push({ code: 'RIG_TURN_SURFACE_MESH_BINDINGS', object: `surface mesh "${mesh.slot}/${mesh.attachment}" vertex ${index}`, detail: `names missing bone "${w.bone}"; every influence must resolve in the final setup` });
                 continue;
               }
               // A unit/rear mesh sharing this root would move our bindings too.
-              let ancestor = rig.bones.find((b) => b.name === w.bone);
+              let ancestor = setup.bones.find((b) => b.name === setup.resolve(w.bone));
               while (ancestor !== undefined) {
                 if ([FACESHIFT_BONE, REAR_SHIFT_BONE, BODYSHIFT_BONE, BODY_REAR_SHIFT_BONE].includes(ancestor.name)) {
                   problems.push({ code: 'RIG_TURN_SURFACE_MESH_BINDINGS', object: `${group.fieldPrefix}.roles.${part}`, detail: `binds "${w.bone}" through turn carrier "${ancestor.name}" shared with another role; surface mesh bindings must retain their authored frame` });
                   break;
                 }
-                ancestor = rig.bones.find((b) => b.name === ancestor?.parent);
+                ancestor = setup.bones.find((b) => b.name === ancestor?.parent);
               }
               const [x, y] = toWorld(frame, w.x, w.y);
               wx += x * w.weight; wy += y * w.weight; total += w.weight;
@@ -1858,7 +1872,7 @@ function buildDepth25DTurnGroup(
                 const d = -depth * Math.sin(deg * Math.PI / 180);
                 return row.flatMap((w) => {
                   if (mesh.groups !== undefined && (w.weight === 0 || mesh.groups.get(w.bone) !== (group.fieldPrefix === 'config.turn' ? 'head' : 'body'))) return [0, 0];
-                  const frame = world.get(w.bone)!; // every influence resolved before emitting keys
+                  const frame = world.get(setup.resolve(w.bone))!; // every influence resolved before emitting keys
                   const [x, y] = toBoneLocalVector(frame, kind === 'yaw' ? d : 0, kind === 'pitch' ? d : 0);
                   return [pyRound(x, 6), pyRound(y, 6)];
                 });
@@ -1947,11 +1961,7 @@ function buildDepth25DTurnGroup(
  * `derive` and `deform` `transform` (`depth: true, narrowing: false`).
  */
 export function buildDepth25DTurn(
-  rig: {
-    bones: Array<{ name: string; parent?: string; x: number; y: number; rotation?: number; length?: number }>;
-    slots: Array<{ name: string; bone: string; attachment: string | null }>;
-    constraints?: Array<Record<string, unknown>>;
-  },
+  rig: Depth25DTurnRig,
   motion: {
     groups?: Record<string, string[]>;
     animations: Record<string, unknown>;
@@ -1963,11 +1973,12 @@ export function buildDepth25DTurn(
 
   // Only a surface opt-in spanning both authored subtrees changes paths (#796).
   // Single-group meshes keep #795's role and bytes, including explicit islands.
-  const parents = new Map(rig.bones.map((b) => [b.name, b.parent]));
+  const setup = surfaceSetupGraph(rig);
+  const parents = new Map(setup.bones.map((b) => [b.name, b.parent]));
   const bodyRoot = opts.turn.body?.bone ?? (parents.has('chest') ? 'chest' : 'hip');
   const descends = (bone: string, root: string): boolean => {
     const seen = new Set<string>();
-    for (let cur: string | undefined = bone; cur !== undefined && !seen.has(cur); cur = parents.get(cur)) {
+    for (let cur: string | undefined = setup.resolve(bone); cur !== undefined && !seen.has(cur); cur = parents.get(cur)) {
       if (cur === root) return true;
       seen.add(cur);
     }