@rig-c/pose 0.2.0 → 0.2.1

package/README.md

@@ -8,6 +8,16 @@ Part of the rig-c toolchain: [core](https://github.com/rig-c/core) compiles and
 
 <!-- demo -->
 
+## Try it
+
+[`examples/wave`](examples/wave) runs with nothing else: a bones-only stick rig (no art), a 3-second wave made from joint angles (`make-pose.ts` writes it), and the map that joins them.
+
+```sh
+rig-pose retarget --rig examples/wave/rig --map examples/wave/map.json --pose examples/wave/pose.json --out wave.motion.json --build wave-build
+```
+
+It prints the gate's verdict and where every mapped bone landed, then writes `wave.motion.json` and the gated build. `rigc preview --candidate wave-build` plays it in the Spine Web Player. A rig with no art shows only its bones.
+
 ## What it does
 
 ```sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/pose",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Puts motion from a body-18 pose sequence onto a rig built with rig-c: bone keys in rig-c's motion format, checked through rig-c's gate before anything is written. A CLI for agents that cannot see the rig.",
   "type": "module",
   "bin": {

package/src/rigc.ts

@@ -100,18 +100,27 @@ export function gate(rig: string, motion: Record<string, unknown>, dir: string,
   mkdirSync(dir, { recursive: true });
   const motionPath = join(dir, 'motion.json');
   writeFileSync(motionPath, `${JSON.stringify(motion, null, 2)}\n`);
-  const build = join(dir, 'build');
-  // --copy-images: a build's page paths are relative to its directory, and the
-  // gated build is copied out of the scratch directory for `--build`, so its
-  // pages travel with it (rigc refuses to draw a moved build otherwise).
-  const run = runRigc(['build', '--rig', rig, '--motion', motionPath, '--out', build, '--profile', profile, '--copy-images', '--report', join(dir, 'build-report.json')]);
+  return buildInto(rig, motionPath, join(dir, 'build'), profile, join(dir, 'build-report.json'));
+}
+
+/**
+ * `rigc build` of `rig` with the motion spec at `motionPath` into `out`, under
+ * rigc's gate (it writes nothing when red). rigc records each source image's
+ * path relative to `out` (`images[].page` in the model document), so a build is
+ * only right where it was built: the run gates in a scratch directory, and the
+ * build `--build` keeps is built again, by rigc, where it will live (#18) —
+ * never copied out, which would carry a path climbing from the scratch
+ * directory to the filesystem root. --copy-images puts the pages beside it.
+ */
+export function buildInto(rig: string, motionPath: string, out: string, profile: string, report?: string): Gate {
+  const run = runRigc(['build', '--rig', rig, '--motion', motionPath, '--out', out, '--profile', profile, '--copy-images', ...(report === undefined ? [] : ['--report', report])]);
   const lines = run.out.split('\n');
   return {
     run,
     green: run.status === 0,
     summary: lines.find((l) => /assertions: \d+ measured/.test(l))?.replace(/^[\s.]+/, '') ?? null,
     fails: lines.filter((l) => /^\s*FAIL\s/.test(l) || l.startsWith('rigc compile error')).map((l) => l.trim()),
-    build,
+    build: out,
   };
 }
 

package/src/run.ts

@@ -5,12 +5,12 @@
  */
 import { cpSync, existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { readMap, resolveMap } from './map.ts';
 import { convertCoco17, personTrack, readPoseSequence } from './pose.ts';
 import { lineOf, Problems, Refusal, type Problem } from './problems.ts';
 import { bendLine, flipLine, holdLine, retarget, type RetargetOptions } from './retarget.ts';
-import { baseMotionOf, folds, gate, readBuild, resolveRig, restOf } from './rigc.ts';
+import { baseMotionOf, buildInto, folds, gate, readBuild, resolveRig, restOf } from './rigc.ts';
 import { landed, measureLanding, measurePosture, poseFrames, postureLines, ANGLE_TOLERANCE, ORIGIN_TOLERANCE } from './verify.ts';
 
 export interface RetargetArgs extends RetargetOptions {
@@ -109,17 +109,21 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
 
     const dts = r.times.slice(1).map((t, i) => t - r.times[i]!).sort((x, y) => x - y);
     const fps = dts.length === 0 ? 12 : Math.max(1, Math.min(60, Math.round(1 / dts[dts.length >> 1]!)));
-    const f = folds(g1.build, a.name, join(scratch, 'folds'), fps);
-    if (f.meshes === null) say(`  FOLD   rigc render --folds did not read (exit ${f.run.status}); folds not measured`);
+    // A rig that draws nothing (bones only) has nothing to fold, and rigc's render refuses it.
+    const f = doc.slots.length === 0 ? { run: { args: [], status: 0, out: '' }, meshes: [], frames: '' } : folds(g1.build, a.name, join(scratch, 'folds'), fps);
+    if (doc.slots.length === 0) say('  FOLD   the rig has no slots, so it draws nothing to fold; not measured');
+    else if (f.meshes === null) say(`  FOLD   rigc render --folds did not read (exit ${f.run.status}); folds not measured`);
     else if (f.meshes.length === 0) say(`  FOLD   rigc render --folds at ${fps} fps: no mesh folds`);
     else for (const m of f.meshes) say(`  FOLD   mesh "${m.attachment}" (slot "${m.slot}") folds on ${m.times.length} frame(s) at ${fps} fps: t=${spans(m.times, 1 / fps)}`);
 
-    writeFileSync(a.out, `${JSON.stringify(motion, null, 2)}\n`);
     if (a.build !== undefined) {
+      // Built again where it will live, not copied: rigc's page paths are relative to the build (#18).
       rmSync(a.build, { recursive: true, force: true });
-      cpSync(g1.build, a.build, { recursive: true });
+      const kept = buildInto(input.rig, join(scratch, 'with', 'motion.json'), resolve(a.build), a.profile);
+      if (!kept.green) refuse([{ code: 'RIG_GATE', text: `rigc build into --build ${a.build} is red where the same build was green in scratch (exit ${kept.run.status}); nothing written` }, ...kept.fails.map((x) => ({ code: 'RIGC', text: x }))]);
     }
-    if (a.render !== undefined && f.meshes !== null) {
+    writeFileSync(a.out, `${JSON.stringify(motion, null, 2)}\n`);
+    if (a.render !== undefined && f.meshes !== null && f.frames !== '') {
       rmSync(a.render, { recursive: true, force: true });
       cpSync(f.frames, a.render, { recursive: true });
     }