@rig-c/parts 1.33.0 → 1.35.0

package/src/rig.ts

@@ -132,7 +132,7 @@
  * touches the disk, and the same inputs give the same bytes (key order is the
  * order the objects are built in, and every number is rounded by `pyRound`).
  */
-import { type AutoSpec, type BoneEntry, type WeightRule, type CharacterConfig, type ConfigConstraint, type ConfigStop, CONSTRAINT_FOLLOWS, constraintForRig, type ContourSpec, type Point, type RibsSpec, ROOT_BONE, stopForRig, weightsABone } from './config.ts';
+import { type AutoSpec, type BoneEntry, type WeightRule, type CharacterConfig, type ConfigConstraint, type ConfigStop, CONSTRAINT_FOLLOWS, constraintForRig, contourRegionsOf, type ContourSpec, DEFAULT_BUST_BONE_L, DEFAULT_BUST_BONE_R, type Point, type RibsSpec, ROOT_BONE, stopForRig, weightsABone } from './config.ts';
 import { type BoneTransform, computeExactFrameTransforms, cropToSpineY, normaliseDegrees, toBoneLocal, toWorld } from './coords.ts';
 import { type Problem, refuseIfAny } from './errors.ts';
 import { eyeLineDegrees } from './headframe.ts';
@@ -164,6 +164,7 @@ import {
 } from './automesh.ts';
 import { type ContourChainRibs, type ContourReport, contourMesh, type ContourRegion, type ContourRib } from './contour.ts';
 import { type LocalInfluence, localInfluences } from './localweights.ts';
+import { edgeLength } from './length.ts';
 import { artCoverage, ART_ALPHA, latticeCells, latticeMesh, latticeStray, ONE_LOOP_PASSES } from './mesh.ts';
 import { bindFaceSurfaceDeform, BLINK, blinkHoldMisses, blinkSpan, CONTROL_SUFFIX, controlledBones, IDLE_FPS, idleMotion, type MotionSpec, moveKeysToControls } from './motion.ts';
 import { type AlternateSetMap, PAINTING_RUN, type PartsFile, readFrom, tagOf } from './parts.ts';
@@ -1161,6 +1162,14 @@ export function buildRig(
       (m.contour.regions ?? []).forEach((rg, i) => {
         if (!B.has(rg.bone)) fail('RIG_NAME_RESOLVES', `config.meshes.${part}.contour.regions[${i}].bone`, `names the bone "${rg.bone}", which config.bones does not declare`);
       });
+      if (m.contour.bust !== undefined) {
+        for (const [k, bone] of [
+          ['bone_r', m.contour.bust.bone_r ?? DEFAULT_BUST_BONE_R],
+          ['bone_l', m.contour.bust.bone_l ?? DEFAULT_BUST_BONE_L],
+        ] as const) {
+          if (!B.has(bone)) fail('RIG_NAME_RESOLVES', `config.meshes.${part}.contour.bust.${k}`, `names the bone "${bone}", which config.bones does not declare`);
+        }
+      }
     }
     if ('auto' in m) {
       (m.auto.regions ?? []).forEach((rg, i) => {
@@ -1274,7 +1283,7 @@ export function buildRig(
   for (const segs of meshSegments.values()) for (const s of segs) meshBones.add(s.bone);
   // A contour region's control bone is weighted to like a segment's bone (issue #84), so the idle's keys on it move
   // to its control under `ctl` as theirs do. A config with no contour region adds nothing here.
-  for (const m of Object.values(cfg.meshes)) if ('contour' in m) for (const rg of m.contour.regions ?? []) meshBones.add(rg.bone);
+  for (const m of Object.values(cfg.meshes)) if ('contour' in m) for (const rg of contourRegionsOf(m.contour)) meshBones.add(rg.bone);
   for (const m of Object.values(cfg.meshes)) if ('auto' in m) for (const rg of m.auto.regions ?? []) if (weightsABone(rg)) meshBones.add(rg.bone);
   const meshKeyed = controlledBones(motion, meshBones);
   const controls = idleKeys === 'ctl' ? meshKeyed : [];
@@ -1600,7 +1609,7 @@ export function buildRig(
     const h = img.height;
     const alpha = new Uint8Array(w * h);
     for (let i = 0; i < alpha.length; i++) alpha[i] = img.data[i * 4 + 3];
-    const regions = spec.regions ?? [];
+    const regions = contourRegionsOf(spec);
     const inPart: ContourRegion[] = regions.map((rg) =>
       rg.shape === 'circle'
         ? { name: rg.name, shape: 'circle', cx: rg.cx - ox, cy: rg.cy - oy, r: rg.r, spacing: rg.spacing, band: rg.band }
@@ -1635,10 +1644,25 @@ export function buildRig(
       const li = localInfluences([wx, wy], vSegs, r, regions, limits, exponent ?? DISTANCE_EXPONENT, heat === null ? undefined : heatInfluences(heat, [vx, vy], limits));
       if ('first' in li) {
         if (!overlapped) {
+          let bustHint = '';
+          if (spec.bust !== undefined) {
+            const need: number[] = [];
+            for (const rg of [regions[li.first], regions[li.second]]) {
+              if (rg.name === 'bust_r' || rg.name === 'bust_l') {
+                const apex = rg.name === 'bust_r' ? spec.bust.apex_r : spec.bust.apex_l;
+                const d = edgeLength(spec.bust.cleavage[0] - apex[0], spec.bust.cleavage[1] - apex[1]);
+                const dist = edgeLength(wx - apex[0], wy - apex[1]);
+                need.push(pyRound(d - dist, 2));
+              }
+            }
+            if (need.length > 0) {
+              bustHint = ` (contour.bust.clearance >= ${Math.min(...need)} clears vertex ${vi})`;
+            }
+          }
           out.push({
             code: 'RIG_CONTOUR_REGIONS_OVERLAP',
             object: `config.meshes.${p.name}.contour.regions`,
-            detail: `vertex ${vi} at rig (${wx}, ${wy}) takes weight ${pyRound(li.g1, 5)} from region "${regions[li.first].name}" and ${pyRound(li.g2, 5)} from region "${regions[li.second].name}"; each vertex may be reached by one region's falloff (its region and band) — move the regions apart or narrow a band`,
+            detail: `vertex ${vi} at rig (${wx}, ${wy}) takes weight ${pyRound(li.g1, 5)} from region "${regions[li.first].name}" and ${pyRound(li.g2, 5)} from region "${regions[li.second].name}"; each vertex may be reached by one region's falloff (its region and band) — move the regions apart or narrow a band${bustHint}`,
           });
         }
         overlapped = true;
@@ -2296,7 +2320,10 @@ export function buildRig(
   if (axes.length > 0) rig.invariants = { ...rig.invariants, axes };
   const faceImg = outImages.find(([k]) => k === 'face.png')?.[1];
   const facePart = parts.parts.find((p) => p.name === 'face');
+  const partAreas: Record<string, number> = {};
+  for (const p of parts.parts) partAreas[p.name] = p.opaque_px;
   bindFaceSurfaceDeform(motion, (merged) => {
+    expandSetAttachmentKeys(rig, sets, merged);
     applyFaceSurfaceDeform(rig, merged, {
       imageWidth: faceImg?.width,
       imageHeight: faceImg?.height,
@@ -2304,6 +2331,9 @@ export function buildRig(
       opaqueHeight: facePart?.h,
       overrides: cfg.turn?.deform,
       hasAlternateFaceSet,
+      turn: cfg.turn,
+      partAreas,
+      requireTurn: true,
     });
     if (sets !== undefined && (merged.animations.turn !== undefined || merged.animations.tilt !== undefined)) {
       for (const entry of Object.values(sets.sets)) {
@@ -2329,6 +2359,132 @@ export function buildRig(
   };
 }
 
+/**
+ * Issue #473: expand `{"t": …, "set": "<name>" | null}` keys on slot attachment
+ * tracks in `merged.animations` into `{"t": …, "v": "<attachment>" | null}`
+ * keys against `rig.slots` and `sets.json`. When no key carries `"set"`, nothing
+ * is touched and no byte moves.
+ */
+function expandSetAttachmentKeys(rig: RigSpec, sets: AttachmentSetsFile | undefined, merged: MotionSpec): void {
+  let hasAnySetKey = false;
+  for (const [animName, anim] of Object.entries(merged.animations)) {
+    if (animName === 'idle' || typeof anim !== 'object' || anim === null || Array.isArray(anim)) continue;
+    const tracks = (anim as Record<string, unknown>).tracks;
+    if (!Array.isArray(tracks)) continue;
+    for (const tr of tracks) {
+      if (typeof tr !== 'object' || tr === null || Array.isArray(tr)) continue;
+      const keys = (tr as Record<string, unknown>).keys;
+      if (!Array.isArray(keys)) continue;
+      for (const k of keys) {
+        if (typeof k === 'object' && k !== null && !Array.isArray(k) && 'set' in k) {
+          hasAnySetKey = true;
+          break;
+        }
+      }
+      if (hasAnySetKey) break;
+    }
+    if (hasAnySetKey) break;
+  }
+  if (!hasAnySetKey) return;
+
+  const baseSlots = new Map<string, string | null>();
+  for (const sl of rig.slots) {
+    baseSlots.set(sl.name, sl.attachment ?? null);
+  }
+  const declaredSets =
+    sets === undefined || Object.keys(sets.sets).length === 0
+      ? 'none'
+      : Object.keys(sets.sets)
+          .map((n) => `"${n}"`)
+          .join(', ');
+  const problems: Problem[] = [];
+
+  for (const [animName, anim] of Object.entries(merged.animations)) {
+    if (animName === 'idle' || typeof anim !== 'object' || anim === null || Array.isArray(anim)) continue;
+    const tracks = (anim as Record<string, unknown>).tracks;
+    if (!Array.isArray(tracks)) continue;
+    tracks.forEach((tr, ti) => {
+      if (typeof tr !== 'object' || tr === null || Array.isArray(tr)) return;
+      const trRec = tr as Record<string, unknown>;
+      const keys = trRec.keys;
+      if (!Array.isArray(keys)) return;
+      const slot = typeof trRec.slot === 'string' && trRec.slot !== '' ? trRec.slot : null;
+      const isAttachmentTrack = trRec.property === 'attachment' && slot !== null;
+      keys.forEach((k, ki) => {
+        if (typeof k !== 'object' || k === null || Array.isArray(k) || !('set' in k)) return;
+        const kRec = k as Record<string, unknown>;
+        const keyAt = `animations.${animName}.tracks[${ti}].keys[${ki}].set`;
+        if (!isAttachmentTrack || slot === null) {
+          problems.push({
+            code: 'CONFIG_SET_COVERS_SLOT',
+            object: keyAt,
+            detail: `is ${JSON.stringify(kRec.set)} on a ${JSON.stringify(trRec.property)} track${slot === null ? '' : ` for slot "${slot}"`}; a "set" key belongs on a slot attachment track ({"slot": "<part>", "property": "attachment", "keys": [{"t": …, "set": "<name>" | null}]})`,
+          });
+          return;
+        }
+        if ('v' in kRec) {
+          problems.push({
+            code: 'CONFIG_FIELD_TYPE',
+            object: keyAt,
+            detail: `is declared beside v (${JSON.stringify(kRec.v)}); state either "set": "<name>" | null or "v": "<attachment>" | null on an attachment key, not both`,
+          });
+          return;
+        }
+        const setVal = kRec.set;
+        let resolvedV: string | null = null;
+        if (setVal === null) {
+          if (!baseSlots.has(slot)) {
+            problems.push({
+              code: 'CONFIG_SET_COVERS_SLOT',
+              object: keyAt,
+              detail: `restores the base attachment on slot "${slot}", which is not a declared slot of the rig (declared slots: ${[...baseSlots.keys()].map((s) => `"${s}"`).join(', ')})`,
+            });
+            return;
+          }
+          resolvedV = baseSlots.get(slot) ?? null;
+        } else if (typeof setVal !== 'string' || setVal === '') {
+          problems.push({
+            code: 'CONFIG_FIELD_TYPE',
+            object: keyAt,
+            detail: `is ${JSON.stringify(setVal)}; a non-empty alternate set name or null (the base pose) is required`,
+          });
+          return;
+        } else {
+          const entry = sets?.sets[setVal];
+          if (entry === undefined) {
+            problems.push({
+              code: 'CONFIG_SET_COVERS_SLOT',
+              object: keyAt,
+              detail: `names alternate set "${setVal}" for slot "${slot}", which config.assemble.alternates does not declare (declared sets: ${declaredSets})`,
+            });
+            return;
+          }
+          if (Object.hasOwn(entry.slots, slot)) {
+            resolvedV = entry.slots[slot];
+          } else if (entry.hides?.includes(slot) === true) {
+            resolvedV = null;
+          } else {
+            const covered = [...Object.keys(entry.slots), ...(entry.hides ?? [])].map((s) => `"${s}"`).join(', ') || 'none';
+            problems.push({
+              code: 'CONFIG_SET_COVERS_SLOT',
+              object: keyAt,
+              detail: `names alternate set "${setVal}" on slot "${slot}", which set "${setVal}" does not cover (set "${setVal}" covers: ${covered}); add "${slot}" to that set's parts (or hides) in config.assemble.alternates, or key a slot the set covers`,
+            });
+            return;
+          }
+        }
+        const expanded: Record<string, unknown> = {};
+        for (const [prop, val] of Object.entries(kRec)) {
+          if (prop === 'set') expanded.v = resolvedV;
+          else expanded[prop] = val;
+        }
+        keys[ki] = expanded;
+      });
+    });
+  }
+  refuseIfAny(problems);
+}
+
 /**
  * Re-parent every bone that hangs from a stopped link onto that link's drawn
  * link `<link>_d`, move slots and mesh weights from a stopped link onto

package/src/structure.ts

@@ -72,7 +72,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { CompileError } from 'rig-c/src/errors.ts';
 import { parseRigSpec, RIG_SPEC_VERSION, type RigBone as RigcBone, type RigSpec as RigcSpec, splitRigSkin } from 'rig-c/src/rig.ts';
-import { type ConfigConstraint, CONSTRAINT_FOLLOWS, parseConfig, parseProposalSections, type Point, ROOT_BONE, type SkeletonSections, weightsABone } from './config.ts';
+import { type ConfigConstraint, CONSTRAINT_FOLLOWS, contourRegionsOf, parseConfig, parseProposalSections, type Point, ROOT_BONE, type SkeletonSections, weightsABone } from './config.ts';
 import { computeExactFrameTransforms, cropToSpineY, normaliseDegrees, toWorld } from './coords.ts';
 import { PartsError, type Problem, refuseIfAny } from './errors.ts';
 import { edgeLength } from './length.ts';
@@ -183,8 +183,11 @@ export function configRoles(s: SkeletonSections & { constraints?: readonly Confi
       if (typeof sp === 'string') for (const b of chains.get(sp) ?? [sp]) push(bound, b, at);
       else push(bound, sp[0], at);
     });
-    // A contour mesh's region bone is weighted to, like a segment's (issue #84).
-    if ('contour' in m) (m.contour.regions ?? []).forEach((rg, i) => push(bound, rg.bone, `meshes.${part}.contour.regions[${i}]`));
+    // A contour mesh's region bone is weighted to, like a segment's (issue #84; including contour.bust, issue #475).
+    if ('contour' in m) {
+      const explicitCount = (m.contour.regions ?? []).length;
+      contourRegionsOf(m.contour).forEach((rg, i) => push(bound, rg.bone, i < explicitCount ? `meshes.${part}.contour.regions[${i}]` : `meshes.${part}.contour.bust`));
+    }
     if ('auto' in m) (m.auto.regions ?? []).forEach((rg, i) => {
         // A density-only region binds no bone (issue #155).
         if (weightsABone(rg)) push(bound, rg.bone, `meshes.${part}.auto.regions[${i}]`);