@rig-c/parts 2.52.0 → 2.52.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/docs/AUTHORING.md +44 -39
- package/package.json +1 -1
- package/src/build.ts +7 -3
- package/src/check.ts +55 -31
package/docs/AUTHORING.md
CHANGED
|
@@ -7067,6 +7067,10 @@ assemble*, at the end of this section):
|
|
|
7067
7067
|
`loop physics: … "<name>" on bone "<bone>" (rig.json|motion.json)`, and written as `check.json`'s `loop_physics` after
|
|
7068
7068
|
`loop_max_diff`; they are reported, not judged. A rig with none is measured from the
|
|
7069
7069
|
idle render itself, exactly as before, and writes no such line or key.
|
|
7070
|
+
When removing physics tracks leaves a named animation beside `idle` without
|
|
7071
|
+
any timeline, the keyed build omits it and the `loop physics:` line names it
|
|
7072
|
+
(issue #1461). Bone tracks and other timelines, including events and draw order,
|
|
7073
|
+
stay in the keyed build.
|
|
7070
7074
|
|
|
7071
7075
|
On the examples: `reference-sample` 23/23, seam 0.207 with 0 pixels over 40, loop 0;
|
|
7072
7076
|
`reference-demo` (default rule) 23/23, seam 0.326 with 2 pixels over 40, loop 0.
|
|
@@ -7381,6 +7385,7 @@ exemption that exempts nothing.
|
|
|
7381
7385
|
| `animations` | every animation, the idle included, in `motion.json`'s order: each one read |
|
|
7382
7386
|
| `fps` | the rate the reading sampled at |
|
|
7383
7387
|
| `physics_left_out` | how many physics constraints the rig declares — stepped in `physics_on` and left out in `physics_off` (0 without any) |
|
|
7388
|
+
| `physics_off_skipped` | written when stripping physics removed a named animation's last timeline. Lists omitted names in motion order. The original build still supplies their fold verdicts. The console marks their physics-off readings `SKIP`, and `FEET_STAY_LEVEL` reads only the remaining keyed animations. A `physics_off: null` for a listed animation means no reading was taken. |
|
|
7384
7389
|
| `folding` | one row per mesh that folds in an animation: `animation`, `slot`, `attachment`, `frames` (how many show a folded triangle), `worst_frame`, `worst_triangles`, `triangles` (the mesh's), `physics_on` and `physics_off` (`{ frames, worst_frame, worst_triangles, line }` or null, side by side so a reader sees which folds physics adds), `physics_constraints` (the physics constraints on the mesh's bones, `"<name> on <bone>"`, when the fold appears only with physics on; empty otherwise), `declared` (the `may_fold` why, or null) and `line`, rigc's printed line verbatim |
|
|
7385
7390
|
| `folding_undeclared` | the rows no `may_fold` entry takes: the bar's figure |
|
|
7386
7391
|
| `declared_not_folding` | the `may_fold` entries no row matches, each a failure |
|
|
@@ -9916,8 +9921,8 @@ Internal `SeamSupport.drawings` never enters check JSON. Named requirement
|
|
|
9916
9921
|
<!-- check-row-table:begin -->
|
|
9917
9922
|
| Row family | Registered JSON paths | row_scope | row_kind | row_subjects (producer expression) | Producer |
|
|
9918
9923
|
| --- | --- | --- | --- | --- | --- |
|
|
9919
|
-
| `ANIMATIONS_DO_NOT_FOLD.declared_not_folding` | `ANIMATIONS_DO_NOT_FOLD.declared_not_folding` | part when the supplied mapping resolves a piece; otherwise rig | finding | resolved piece for e.slot; otherwise [] | [check.ts:
|
|
9920
|
-
| `ANIMATIONS_DO_NOT_FOLD.folding` | `ANIMATIONS_DO_NOT_FOLD.folding` | part when the supplied mapping resolves a piece; otherwise rig | finding when entry === undefined; otherwise evidence | resolved piece for slot; otherwise [] | [check.ts:
|
|
9924
|
+
| `ANIMATIONS_DO_NOT_FOLD.declared_not_folding` | `ANIMATIONS_DO_NOT_FOLD.declared_not_folding` | part when the supplied mapping resolves a piece; otherwise rig | finding | resolved piece for e.slot; otherwise [] | [check.ts:3729](../src/check.ts#L3729) |
|
|
9925
|
+
| `ANIMATIONS_DO_NOT_FOLD.folding` | `ANIMATIONS_DO_NOT_FOLD.folding` | part when the supplied mapping resolves a piece; otherwise rig | finding when entry === undefined; otherwise evidence | resolved piece for slot; otherwise [] | [check.ts:3689](../src/check.ts#L3689) |
|
|
9921
9926
|
| `ART_JOINT_DISTANCE.joints` | `ART_JOINT_DISTANCE.joints` | 'rig' | finding when status === 'FAIL'; otherwise evidence | [] | [artjoints.ts:86](../src/artjoints.ts#L86) |
|
|
9922
9927
|
| `BEHIND_PART_SEAMS.contributors` | `BEHIND_PART_SEAMS.turn.pairs[].frames[].standing.samples[].contributors`; `BEHIND_PART_SEAMS.turn.pairs[].frames[].motion_opened.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].setup.motion_opened.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].setup.standing.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].frames[].motion_opened.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].frames[].standing.samples[].contributors` | 'pair' | evidence | [pair.a, pair.b] | [behindseams.ts:664](../src/behindseams.ts#L664) |
|
|
9923
9928
|
| `BEHIND_PART_SEAMS.hits` | `BEHIND_PART_SEAMS.pairs[].motion_opened.frames`; `BEHIND_PART_SEAMS.pairs[].standing.frames`; `BEHIND_PART_SEAMS.pairs[].motion_opened.worst`; `BEHIND_PART_SEAMS.pairs[].standing.worst` | 'pair' | finding when r.px > allowance; otherwise evidence | parts | [behindseams.ts:750](../src/behindseams.ts#L750) |
|
|
@@ -9933,51 +9938,51 @@ Internal `SeamSupport.drawings` never enters check JSON. Named requirement
|
|
|
9933
9938
|
| `BEHIND_PART_SEAMS.unread_corridors` | `BEHIND_PART_SEAMS.turn.pairs[].frames[].standing.unread_corridors`; `BEHIND_PART_SEAMS.pairs[].setup.standing.unread_corridors`; `BEHIND_PART_SEAMS.pairs[].frames[].standing.unread_corridors` | 'pair' | evidence | [pair.a, pair.b] | [behindseams.ts:585](../src/behindseams.ts#L585) |
|
|
9934
9939
|
| `BOUNDARY_COLOUR_STEP.over` | `BOUNDARY_COLOUR_STEP.over` | 'pair' | finding | r.parts | [boundarycolour.ts:221](../src/boundarycolour.ts#L221) |
|
|
9935
9940
|
| `BOUNDARY_COLOUR_STEP.unmeasured` | `BOUNDARY_COLOUR_STEP.unmeasured` | part when the supplied mapping resolves a piece; otherwise rig | evidence | resolved piece for r.slot; otherwise [] | [boundarycolour.ts:222](../src/boundarycolour.ts#L222) |
|
|
9936
|
-
| `CLOTH_SETTLES.rows` | `CLOTH_SETTLES.rows` | 'rig' | finding when speeds.length > 0 && s < speeds.length; otherwise evidence | [] | [check.ts:
|
|
9941
|
+
| `CLOTH_SETTLES.rows` | `CLOTH_SETTLES.rows` | 'rig' | finding when speeds.length > 0 && s < speeds.length; otherwise evidence | [] | [check.ts:6178](../src/check.ts#L6178) |
|
|
9937
9942
|
| `CUT_JOINT_MATERIAL.rows` | `CUT_JOINT_MATERIAL.rows` | 'part' | finding when r.status === 'FAIL'; otherwise evidence | [r.part] | [cutmaterial.ts:280](../src/cutmaterial.ts#L280) |
|
|
9938
|
-
| `FEET_STAY_LEVEL.feet` | `FEET_STAY_LEVEL.feet` | 'part' | finding when row.status === 'FAIL'; otherwise evidence | [row.part] | [check.ts:
|
|
9939
|
-
| `FEET_STAY_LEVEL.feet[].worst.through` | `FEET_STAY_LEVEL.feet[].worst.through` | 'rig' | evidence | [] | [check.ts:
|
|
9940
|
-
| `LIMB_ONE_BONE.parts` | `LIMB_ONE_BONE.parts` | 'part' | finding when fail; otherwise evidence | [p.name] | [check.ts:
|
|
9943
|
+
| `FEET_STAY_LEVEL.feet` | `FEET_STAY_LEVEL.feet` | 'part' | finding when row.status === 'FAIL'; otherwise evidence | [row.part] | [check.ts:3931](../src/check.ts#L3931) |
|
|
9944
|
+
| `FEET_STAY_LEVEL.feet[].worst.through` | `FEET_STAY_LEVEL.feet[].worst.through` | 'rig' | evidence | [] | [check.ts:3906](../src/check.ts#L3906) |
|
|
9945
|
+
| `LIMB_ONE_BONE.parts` | `LIMB_ONE_BONE.parts` | 'part' | finding when fail; otherwise evidence | [p.name] | [check.ts:4224](../src/check.ts#L4224) |
|
|
9941
9946
|
| `PART_SUPPORT_REPORT.pairs` | `PART_SUPPORT_REPORT.pairs` | 'pair' | evidence; finding when length > 0; otherwise evidence | [F.name, B.name] | [coincide.ts:114](../src/coincide.ts#L114), [coincide.ts:130](../src/coincide.ts#L130) |
|
|
9942
9947
|
| `PART_SUPPORT_REPORT.raw_pairs` | `PART_SUPPORT_REPORT.raw_pairs` | 'pair' | evidence | [F.name, B.name] | [coincide.ts:110](../src/coincide.ts#L110) |
|
|
9943
9948
|
| `PART_SUPPORT_REPORT.unowned.regions` | `PART_SUPPORT_REPORT.unowned.regions` | 'rig' | finding | [] | [coincide.ts:145](../src/coincide.ts#L145) |
|
|
9944
9949
|
| `PHYSICS_CONTRIBUTES.rows` | `PHYSICS_CONTRIBUTES.rows` | 'part' | evidence; finding when !moves; otherwise evidence | [part] | [physicscontrib.ts:217](../src/physicscontrib.ts#L217), [physicscontrib.ts:220](../src/physicscontrib.ts#L220) |
|
|
9945
|
-
| `SEAM_OVER_MOTION.pairs` | `SEAM_OVER_MOTION.pairs` | 'pair' | evidence | [p.a, p.b] | [check.ts:
|
|
9946
|
-
| `SEAM_OVER_MOTION.required.pairs` | `SEAM_OVER_MOTION.required.pairs` | 'pair' | finding when open > 0; otherwise evidence | [p.a, p.b] | [check.ts:
|
|
9947
|
-
| `SEAM_OVER_MOTION.required.pairs[].open_frames` | `SEAM_OVER_MOTION.required.pairs[].open_frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:
|
|
9948
|
-
| `SEAM_OVER_MOTION.roots.unmeasured` | `SEAM_OVER_MOTION.roots.unmeasured` | 'part' | evidence | [root.part] | [check.ts:
|
|
9949
|
-
| `SEAM_OVER_MOTION.rows` | `SEAM_OVER_MOTION.rows` | 'pair'; unique ? 'pair' : 'rig' | finding when motionSeamFinding(want.root !== undefined, p.status, p.banded, opens.length); otherwise evidence; finding when motionSeamFinding(rootNames.has(r.pair), r.status, r.banded, r.opens.length); otherwise evidence | [want.a, want.b]; unique ? [pair.a, pair.b] : [] | [check.ts:
|
|
9950
|
-
| `SEAM_OVER_MOTION.rows[].cells` | `SEAM_OVER_MOTION.rows[].cells` | 'pair' | evidence | [want.a, want.b] | [check.ts:
|
|
9951
|
-
| `SEAM_OVER_MOTION.rows[].joint_contact.reasons` | `SEAM_OVER_MOTION.rows[].joint_contact.reasons` | 'pair' | evidence | [want.a, want.b] | [check.ts:
|
|
9950
|
+
| `SEAM_OVER_MOTION.pairs` | `SEAM_OVER_MOTION.pairs` | 'pair' | evidence | [p.a, p.b] | [check.ts:5575](../src/check.ts#L5575) |
|
|
9951
|
+
| `SEAM_OVER_MOTION.required.pairs` | `SEAM_OVER_MOTION.required.pairs` | 'pair' | finding when open > 0; otherwise evidence | [p.a, p.b] | [check.ts:4894](../src/check.ts#L4894) |
|
|
9952
|
+
| `SEAM_OVER_MOTION.required.pairs[].open_frames` | `SEAM_OVER_MOTION.required.pairs[].open_frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:4886](../src/check.ts#L4886) |
|
|
9953
|
+
| `SEAM_OVER_MOTION.roots.unmeasured` | `SEAM_OVER_MOTION.roots.unmeasured` | 'part' | evidence | [root.part] | [check.ts:5552](../src/check.ts#L5552) |
|
|
9954
|
+
| `SEAM_OVER_MOTION.rows` | `SEAM_OVER_MOTION.rows` | 'pair'; unique ? 'pair' : 'rig' | finding when motionSeamFinding(want.root !== undefined, p.status, p.banded, opens.length); otherwise evidence; finding when motionSeamFinding(rootNames.has(r.pair), r.status, r.banded, r.opens.length); otherwise evidence | [want.a, want.b]; unique ? [pair.a, pair.b] : [] | [check.ts:5509](../src/check.ts#L5509), [check.ts:5581](../src/check.ts#L5581) |
|
|
9955
|
+
| `SEAM_OVER_MOTION.rows[].cells` | `SEAM_OVER_MOTION.rows[].cells` | 'pair' | evidence | [want.a, want.b] | [check.ts:5522](../src/check.ts#L5522) |
|
|
9956
|
+
| `SEAM_OVER_MOTION.rows[].joint_contact.reasons` | `SEAM_OVER_MOTION.rows[].joint_contact.reasons` | 'pair' | evidence | [want.a, want.b] | [check.ts:5512](../src/check.ts#L5512) |
|
|
9952
9957
|
| `SEAM_OVER_MOTION.rows[].pose_at_worst.joints` | `SEAM_OVER_MOTION.rows[].pose_at_worst.joints` | 'rig' | evidence | [] | [motionseampose.ts:53](../src/motionseampose.ts#L53) |
|
|
9953
|
-
| `SEAM_OVER_MOTION.worlds.*.rows` | `SEAM_OVER_MOTION.worlds.*.rows` | 'pair' | evidence | [want.a, want.b] | [check.ts:
|
|
9954
|
-
| `SEAM_OVER_RANGE.joints` | `SEAM_OVER_RANGE.joints` | 'part' | evidence; finding when poses.some(p => p.status === 'FAIL'); otherwise evidence | [j.part] | [check.ts:
|
|
9955
|
-
| `SEAM_OVER_RANGE.joints[].poses` | `SEAM_OVER_RANGE.joints[].poses` | 'part' | finding when fail; otherwise evidence | [j.part] | [check.ts:
|
|
9958
|
+
| `SEAM_OVER_MOTION.worlds.*.rows` | `SEAM_OVER_MOTION.worlds.*.rows` | 'pair' | evidence | [want.a, want.b] | [check.ts:5506](../src/check.ts#L5506) |
|
|
9959
|
+
| `SEAM_OVER_RANGE.joints` | `SEAM_OVER_RANGE.joints` | 'part' | evidence; finding when poses.some(p => p.status === 'FAIL'); otherwise evidence | [j.part] | [check.ts:4548](../src/check.ts#L4548), [check.ts:4594](../src/check.ts#L4594) |
|
|
9960
|
+
| `SEAM_OVER_RANGE.joints[].poses` | `SEAM_OVER_RANGE.joints[].poses` | 'part' | finding when fail; otherwise evidence | [j.part] | [check.ts:4592](../src/check.ts#L4592) |
|
|
9956
9961
|
| `SETUP_MATCHES_PAINTING.regions` | `SETUP_MATCHES_PAINTING.regions` | 'rig' | finding when status === 'FAIL'; otherwise evidence | [] | [setuppainting.ts:175](../src/setuppainting.ts#L175) |
|
|
9957
9962
|
| `SETUP_MATCHES_PAINTING.regions[].slots` | `SETUP_MATCHES_PAINTING.regions[].slots` | part when the supplied mapping resolves a piece; otherwise rig | evidence | resolved piece for slot; otherwise [] | [setuppainting.ts:176](../src/setuppainting.ts#L176) |
|
|
9958
|
-
| `STILL_REGIONS_DARK.*.crossing` | `STILL_REGIONS_DARK.*.crossing` | part when the supplied mapping resolves a piece; otherwise rig | finding | resolved piece for sl.name; otherwise [] | [check.ts:
|
|
9959
|
-
| `STILL_REGIONS_DARK.*.still_slots` | `STILL_REGIONS_DARK.*.still_slots` | part when the supplied mapping resolves a piece; otherwise rig | evidence; finding when r.max > tolerance; otherwise evidence | resolved piece for slot; otherwise [] | [check.ts:
|
|
9960
|
-
| `STRESS_OFF_CHAIN.not_read` | `STRESS_OFF_CHAIN.not_read` | 'part' | evidence | [r.part] | [check.ts:
|
|
9961
|
-
| `STRESS_OFF_CHAIN.per_part` | `STRESS_OFF_CHAIN.per_part` | 'part' | finding when poses.some(p => typeof p.reading === 'number' && p.reading > STRESS_RIGID); otherwise evidence | [r.part] | [check.ts:
|
|
9962
|
-
| `STRESS_OFF_CHAIN.per_part[].off_chain` | `STRESS_OFF_CHAIN.per_part[].off_chain` | 'part' | evidence | [r.part] | [check.ts:
|
|
9963
|
-
| `STRESS_OFF_CHAIN.per_part[].poses` | `STRESS_OFF_CHAIN.per_part[].poses` | 'part' | evidence; finding when shown > STRESS_RIGID; otherwise evidence | [r.part] | [check.ts:
|
|
9964
|
-
| `TEXTURE_STRETCH.per_mesh` | `TEXTURE_STRETCH.per_mesh` | part when the supplied mapping resolves a piece; otherwise rig | evidence; finding when severity > TEXTURE_STRETCH_CEILING; otherwise evidence | resolved piece for m.slot; otherwise [] | [check.ts:
|
|
9965
|
-
| `TIP_OVER_ROOT.parts` | `TIP_OVER_ROOT.parts` | 'part' | evidence; finding when !ok && !(!rigid && hanging.onLink && Math.max(c.root, c.tip) < TIP_TRAVEL_FLOOR); otherwise evidence | [p.name] | [check.ts:
|
|
9966
|
-
| `WIND_BAND.pairs` | `WIND_BAND.pairs` | 'pair' | finding when !holdsAll; otherwise evidence | [p.a, p.b] | [check.ts:
|
|
9967
|
-
| `WIND_BAND.pairs[].steps` | `WIND_BAND.pairs[].steps` | 'pair' | finding when !s.holds; otherwise evidence | [p.a, p.b] | [check.ts:
|
|
9968
|
-
| `figure_openings.openings` | `figure_openings.openings` | 'pair' | finding | [ps.under, ps.above] | [check.ts:
|
|
9969
|
-
| `loop_physics` | `loop_physics` | 'rig' | evidence | [] | [check.ts:
|
|
9970
|
-
| `requirements.lines.* (bone)` | `requirements.lines.*` | 'rig' | finding when line.status === 'FAIL'; otherwise evidence | [] | [check.ts:
|
|
9971
|
-
| `requirements.lines.* (seam)` | `requirements.lines.*` | 'pair' | finding when line.status === 'FAIL'; otherwise evidence | [r.part, r.neighbour] | [check.ts:
|
|
9972
|
-
| `requirements.lines.* (stretch)` | `requirements.lines.*` | part when the supplied mapping resolves a piece; otherwise rig | finding when line.status === 'FAIL'; otherwise evidence | resolved piece for r.slot; otherwise [] | [check.ts:
|
|
9973
|
-
| `seam_cells.frames` | `frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:
|
|
9974
|
-
| `seam_cells.frames[].cells` | `frames[].cells` | part when the supplied mapping resolves a piece; otherwise rig | evidence | resolved piece for cell.setupTop ?? ''; otherwise [] | [check.ts:
|
|
9975
|
-
| `seam_pairs` | `seam_pairs`; `seam_scope.whole_pairs`; `sets.*.seam_pairs`; `sets.*.seam_scope.whole_pairs` | subjects.length === 0 ? 'rig' : subjects.length === 1 ? 'part' : 'pair' | evidence | subjects | [check.ts:
|
|
9976
|
-
| `seam_scope.changes` | `seam_scope.changes`; `sets.*.seam_scope.changes` | 'rig' | evidence | [] | [check.ts:
|
|
9977
|
-
| `seam_scope.domain.states` | `seam_scope.domain.states`; `sets.*.seam_scope.domain.states` | 'rig' | evidence | [] | [check.ts:
|
|
9978
|
-
| `seam_scope.pairs` | `seam_scope.pairs`; `sets.*.seam_scope.pairs` | subjects.length === 0 ? 'rig' : subjects.length === 1 ? 'part' : 'pair' | evidence | subjects | [check.ts:
|
|
9979
|
-
| `seam_scope.population.pairs` | `seam_scope.population.pairs`; `sets.*.seam_scope.population.pairs` | 'pair' | evidence | row.parts | [check.ts:
|
|
9980
|
-
| `seam_scope.population.single_art` | `seam_scope.population.single_art`; `sets.*.seam_scope.population.single_art` | 'part' | evidence | [row.part] | [check.ts:
|
|
9963
|
+
| `STILL_REGIONS_DARK.*.crossing` | `STILL_REGIONS_DARK.*.crossing` | part when the supplied mapping resolves a piece; otherwise rig | finding | resolved piece for sl.name; otherwise [] | [check.ts:9341](../src/check.ts#L9341) |
|
|
9964
|
+
| `STILL_REGIONS_DARK.*.still_slots` | `STILL_REGIONS_DARK.*.still_slots` | part when the supplied mapping resolves a piece; otherwise rig | evidence; finding when r.max > tolerance; otherwise evidence | resolved piece for slot; otherwise [] | [check.ts:9327](../src/check.ts#L9327), [check.ts:9332](../src/check.ts#L9332) |
|
|
9965
|
+
| `STRESS_OFF_CHAIN.not_read` | `STRESS_OFF_CHAIN.not_read` | 'part' | evidence | [r.part] | [check.ts:4152](../src/check.ts#L4152) |
|
|
9966
|
+
| `STRESS_OFF_CHAIN.per_part` | `STRESS_OFF_CHAIN.per_part` | 'part' | finding when poses.some(p => typeof p.reading === 'number' && p.reading > STRESS_RIGID); otherwise evidence | [r.part] | [check.ts:4140](../src/check.ts#L4140) |
|
|
9967
|
+
| `STRESS_OFF_CHAIN.per_part[].off_chain` | `STRESS_OFF_CHAIN.per_part[].off_chain` | 'part' | evidence | [r.part] | [check.ts:4140](../src/check.ts#L4140) |
|
|
9968
|
+
| `STRESS_OFF_CHAIN.per_part[].poses` | `STRESS_OFF_CHAIN.per_part[].poses` | 'part' | evidence; finding when shown > STRESS_RIGID; otherwise evidence | [r.part] | [check.ts:4108](../src/check.ts#L4108), [check.ts:4126](../src/check.ts#L4126) |
|
|
9969
|
+
| `TEXTURE_STRETCH.per_mesh` | `TEXTURE_STRETCH.per_mesh` | part when the supplied mapping resolves a piece; otherwise rig | evidence; finding when severity > TEXTURE_STRETCH_CEILING; otherwise evidence | resolved piece for m.slot; otherwise [] | [check.ts:9991](../src/check.ts#L9991), [check.ts:10001](../src/check.ts#L10001) |
|
|
9970
|
+
| `TIP_OVER_ROOT.parts` | `TIP_OVER_ROOT.parts` | 'part' | evidence; finding when !ok && !(!rigid && hanging.onLink && Math.max(c.root, c.tip) < TIP_TRAVEL_FLOOR); otherwise evidence | [p.name] | [check.ts:8716](../src/check.ts#L8716), [check.ts:8721](../src/check.ts#L8721), [check.ts:8742](../src/check.ts#L8742), [check.ts:8753](../src/check.ts#L8753) |
|
|
9971
|
+
| `WIND_BAND.pairs` | `WIND_BAND.pairs` | 'pair' | finding when !holdsAll; otherwise evidence | [p.a, p.b] | [check.ts:6682](../src/check.ts#L6682) |
|
|
9972
|
+
| `WIND_BAND.pairs[].steps` | `WIND_BAND.pairs[].steps` | 'pair' | finding when !s.holds; otherwise evidence | [p.a, p.b] | [check.ts:6693](../src/check.ts#L6693) |
|
|
9973
|
+
| `figure_openings.openings` | `figure_openings.openings` | 'pair' | finding | [ps.under, ps.above] | [check.ts:5999](../src/check.ts#L5999) |
|
|
9974
|
+
| `loop_physics` | `loop_physics` | 'rig' | evidence | [] | [check.ts:7755](../src/check.ts#L7755) |
|
|
9975
|
+
| `requirements.lines.* (bone)` | `requirements.lines.*` | 'rig' | finding when line.status === 'FAIL'; otherwise evidence | [] | [check.ts:8084](../src/check.ts#L8084) |
|
|
9976
|
+
| `requirements.lines.* (seam)` | `requirements.lines.*` | 'pair' | finding when line.status === 'FAIL'; otherwise evidence | [r.part, r.neighbour] | [check.ts:8084](../src/check.ts#L8084) |
|
|
9977
|
+
| `requirements.lines.* (stretch)` | `requirements.lines.*` | part when the supplied mapping resolves a piece; otherwise rig | finding when line.status === 'FAIL'; otherwise evidence | resolved piece for r.slot; otherwise [] | [check.ts:8084](../src/check.ts#L8084) |
|
|
9978
|
+
| `seam_cells.frames` | `frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:4883](../src/check.ts#L4883) |
|
|
9979
|
+
| `seam_cells.frames[].cells` | `frames[].cells` | part when the supplied mapping resolves a piece; otherwise rig | evidence | resolved piece for cell.setupTop ?? ''; otherwise [] | [check.ts:4843](../src/check.ts#L4843) |
|
|
9980
|
+
| `seam_pairs` | `seam_pairs`; `seam_scope.whole_pairs`; `sets.*.seam_pairs`; `sets.*.seam_scope.whole_pairs` | subjects.length === 0 ? 'rig' : subjects.length === 1 ? 'part' : 'pair' | evidence | subjects | [check.ts:2570](../src/check.ts#L2570) |
|
|
9981
|
+
| `seam_scope.changes` | `seam_scope.changes`; `sets.*.seam_scope.changes` | 'rig' | evidence | [] | [check.ts:2048](../src/check.ts#L2048) |
|
|
9982
|
+
| `seam_scope.domain.states` | `seam_scope.domain.states`; `sets.*.seam_scope.domain.states` | 'rig' | evidence | [] | [check.ts:2133](../src/check.ts#L2133) |
|
|
9983
|
+
| `seam_scope.pairs` | `seam_scope.pairs`; `sets.*.seam_scope.pairs` | subjects.length === 0 ? 'rig' : subjects.length === 1 ? 'part' : 'pair' | evidence | subjects | [check.ts:7614](../src/check.ts#L7614) |
|
|
9984
|
+
| `seam_scope.population.pairs` | `seam_scope.population.pairs`; `sets.*.seam_scope.population.pairs` | 'pair' | evidence | row.parts | [check.ts:2504](../src/check.ts#L2504) |
|
|
9985
|
+
| `seam_scope.population.single_art` | `seam_scope.population.single_art`; `sets.*.seam_scope.population.single_art` | 'part' | evidence | [row.part] | [check.ts:2505](../src/check.ts#L2505) |
|
|
9981
9986
|
|
|
9982
9987
|
| Open serialized type path | Reason for schema exclusion |
|
|
9983
9988
|
| --- | --- |
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@rig-c/parts",
|
|
3
|
-
"version": "2.52.
|
|
3
|
+
"version": "2.52.1",
|
|
4
4
|
"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.",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"exports": {
|
package/src/build.ts
CHANGED
|
@@ -2243,18 +2243,22 @@ export function judgementLine(name: string, line: JudgementLine | ReportedLine):
|
|
|
2243
2243
|
* where `may_fold` takes it.
|
|
2244
2244
|
*/
|
|
2245
2245
|
export function foldsLines(line: FoldsLine): string[] {
|
|
2246
|
-
const
|
|
2246
|
+
const skipped = new Set(line.physics_off_skipped);
|
|
2247
|
+
const sides = skipped.size === 0 ? 'on and off' : skipped.size === line.animations.length ? 'on' : 'on and off where a keyed animation remains';
|
|
2248
|
+
const physics = line.physics_left_out === 0 ? '' : `, with its ${line.physics_left_out} physics constraint(s) ${sides}`;
|
|
2247
2249
|
const head =
|
|
2248
2250
|
`${FOLD_LINE}: ${line.status} — ${line.animations.length} animation(s) read by rigc render --folds at ${line.fps} fps${physics} (${line.animations.join(', ')}): ` +
|
|
2249
2251
|
`${line.folding.length} folding mesh(es), ${line.folding_undeclared} not declared in may_fold (<= ${line.bar})` +
|
|
2250
2252
|
(line.declared_not_folding.length === 0 ? '' : `; may_fold declares ${line.declared_not_folding.map((d) => `slot "${d.slot}" in "${d.animation}"`).join(', ')}, which do(es) not fold`);
|
|
2251
2253
|
return [
|
|
2252
2254
|
head,
|
|
2255
|
+
...[...skipped].map(name => ` folds physics off: SKIP — ${JSON.stringify(name)} has no timeline after removing physics tracks`),
|
|
2253
2256
|
...line.folding.map((r) => {
|
|
2257
|
+
const off = skipped.has(r.animation) ? 'SKIP' : r.physics_off === null ? '0 frame(s)' : `${r.physics_off.frames} frame(s), worst frame ${r.physics_off.worst_frame} (${r.physics_off.worst_triangles}/${r.triangles} triangle(s))`;
|
|
2254
2258
|
const side =
|
|
2255
2259
|
line.physics_left_out === 0
|
|
2256
2260
|
? ''
|
|
2257
|
-
: ` — physics on: ${r.physics_on === null ? '0 frame(s)' : `${r.physics_on.frames} frame(s), worst frame ${r.physics_on.worst_frame} (${r.physics_on.worst_triangles}/${r.triangles} triangle(s))`}; physics off: ${
|
|
2261
|
+
: ` — physics on: ${r.physics_on === null ? '0 frame(s)' : `${r.physics_on.frames} frame(s), worst frame ${r.physics_on.worst_frame} (${r.physics_on.worst_triangles}/${r.triangles} triangle(s))`}; physics off: ${off}` +
|
|
2258
2262
|
(r.physics_constraints.length === 0 ? '' : `; physics constraint(s): ${r.physics_constraints.join(', ')}`);
|
|
2259
2263
|
return ` folds ${r.line}${side}${r.declared === null ? '' : ` — declared in may_fold: ${r.declared}`}`;
|
|
2260
2264
|
}),
|
|
@@ -2405,7 +2409,7 @@ export function checkStage(input: CheckStageInput, rigc: RigcRunner, bin: string
|
|
|
2405
2409
|
if (r.idle === null) log(` loop: SKIP — ${fig.skipped?.loop ?? ''}`);
|
|
2406
2410
|
else log(` ${loopCheckLine(r.idle, fig.loop_max_diff, fig.loop_physics?.length ?? 0)}`);
|
|
2407
2411
|
if (r.loopPhysics !== null) log(` ${r.loopPhysics}`);
|
|
2408
|
-
const beside = besideIdleLine(r.besideIdle,
|
|
2412
|
+
const beside = besideIdleLine(r.besideIdle, fig[LEVEL_LINE] !== undefined, (fig[FOLD_LINE]?.physics_off_skipped?.length ?? 0) > 0);
|
|
2409
2413
|
if (beside !== null) log(` ${beside}`);
|
|
2410
2414
|
if (r.seamViewport === null || fig.seam_mean === null) log(` seam: SKIP — ${fig.skipped?.seam ?? ''}`);
|
|
2411
2415
|
else {
|
package/src/check.ts
CHANGED
|
@@ -1230,10 +1230,11 @@ function withoutSliders(rig: Record<string, unknown>, animations: Record<string,
|
|
|
1230
1230
|
* `constraints` entry of `type` `"physics"` and every entry of motion.json's
|
|
1231
1231
|
* `physics` table are dropped, with what names them only to activate or key
|
|
1232
1232
|
* them — a skin's `physics` list, and an animation track whose target is a
|
|
1233
|
-
* `physics` constraint.
|
|
1234
|
-
*
|
|
1233
|
+
* `physics` constraint. A named animation beside the idle is dropped if this
|
|
1234
|
+
* removes its last timeline. The idle still has to pass the keyed build's
|
|
1235
|
+
* gate. The line naming what was left out reports it.
|
|
1235
1236
|
*/
|
|
1236
|
-
export function withoutPhysics(rig: Record<string, unknown>, motion: Record<string, unknown>): { rig: Record<string, unknown>; motion: Record<string, unknown>; physics: LoopPhysics[] } | null {
|
|
1237
|
+
export function withoutPhysics(rig: Record<string, unknown>, motion: Record<string, unknown>): { rig: Record<string, unknown>; motion: Record<string, unknown>; physics: LoopPhysics[]; droppedAnimations: string[] } | null {
|
|
1237
1238
|
const physics: LoopPhysics[] = [];
|
|
1238
1239
|
const constraints = Array.isArray(rig.constraints) ? rig.constraints : null;
|
|
1239
1240
|
if (constraints !== null) {
|
|
@@ -1258,18 +1259,29 @@ export function withoutPhysics(rig: Record<string, unknown>, motion: Record<stri
|
|
|
1258
1259
|
}
|
|
1259
1260
|
const m: Record<string, unknown> = { ...motion };
|
|
1260
1261
|
delete m.physics;
|
|
1262
|
+
const droppedAnimations: string[] = [];
|
|
1261
1263
|
if (isRecord(motion.animations)) {
|
|
1262
|
-
m.animations = Object.fromEntries(Object.entries(motion.animations).
|
|
1263
|
-
if (!isRecord(a) || !Array.isArray(a.tracks)) return [name, a];
|
|
1264
|
-
|
|
1264
|
+
m.animations = Object.fromEntries(Object.entries(motion.animations).flatMap(([name, a]): Array<[string, unknown]> => {
|
|
1265
|
+
if (!isRecord(a) || !Array.isArray(a.tracks)) return [[name, a]];
|
|
1266
|
+
const tracks = a.tracks.filter((t) => !(isRecord(t) && 'physics' in t));
|
|
1267
|
+
if (tracks.length === a.tracks.length) return [[name, a]];
|
|
1268
|
+
const hasOtherTimeline = [a.ik, a.transform, a.deform, a.sequence, a.drawOrder, a.events]
|
|
1269
|
+
.some(timeline => Array.isArray(timeline) && timeline.length > 0);
|
|
1270
|
+
if (name !== 'idle' && tracks.length === 0 && !hasOtherTimeline) {
|
|
1271
|
+
droppedAnimations.push(name);
|
|
1272
|
+
return [];
|
|
1273
|
+
}
|
|
1274
|
+
return [[name, { ...a, tracks }]];
|
|
1265
1275
|
}));
|
|
1266
1276
|
}
|
|
1267
|
-
return { rig: r, motion: m, physics };
|
|
1277
|
+
return { rig: r, motion: m, physics, droppedAnimations };
|
|
1268
1278
|
}
|
|
1269
1279
|
|
|
1270
1280
|
/** The one line naming what {@link withoutPhysics} left out of the loop's frames: reported, not judged. */
|
|
1271
|
-
export function loopPhysicsLine(physics: readonly LoopPhysics[]): string {
|
|
1272
|
-
|
|
1281
|
+
export function loopPhysicsLine(physics: readonly LoopPhysics[], droppedAnimations: readonly string[] = []): string {
|
|
1282
|
+
const dropped = droppedAnimations.length === 0 ? ''
|
|
1283
|
+
: `; physics-only animation(s) omitted from the keyed build: ${droppedAnimations.map(name => JSON.stringify(name)).join(', ')}`;
|
|
1284
|
+
return `loop physics: ${physics.length} physics constraint(s) left out of the loop's frames, reported, not judged — ${physics.map((p) => `"${p.name}" on bone "${p.bone}" (${p.in})`).join(', ')}${dropped}`;
|
|
1273
1285
|
}
|
|
1274
1286
|
|
|
1275
1287
|
// ---------------------------------------------------------------------------
|
|
@@ -3352,9 +3364,9 @@ export function checkStatuses(fig: Omit<CheckFigures, 'spec' | 'bar_outcomes' |
|
|
|
3352
3364
|
* idle (issue #183), or null when it holds none, so a rig of the idle alone
|
|
3353
3365
|
* prints what it printed before.
|
|
3354
3366
|
*/
|
|
3355
|
-
export function besideIdleLine(names: readonly string[], level = false): string | null {
|
|
3367
|
+
export function besideIdleLine(names: readonly string[], level = false, skipsKeyedAnimations = false): string | null {
|
|
3356
3368
|
if (names.length === 0) return null;
|
|
3357
|
-
const readers = level ? `${FOLD_LINE} reads each for folds and ${LEVEL_LINE} for how far the feet turn` : `${FOLD_LINE} reads each for folds`;
|
|
3369
|
+
const readers = level ? `${FOLD_LINE} reads each for folds and ${LEVEL_LINE} for how far the feet turn${skipsKeyedAnimations ? ' in the remaining keyed animations' : ''}` : `${FOLD_LINE} reads each for folds`;
|
|
3358
3370
|
return `beside the idle: ${names.length} animation(s), ${names.join(', ')} — built and gated by rigc with the rig; ${readers}, every other bar here reads the idle`;
|
|
3359
3371
|
}
|
|
3360
3372
|
|
|
@@ -3401,9 +3413,9 @@ export interface FoldRow {
|
|
|
3401
3413
|
triangles: number;
|
|
3402
3414
|
/** The reading with physics on, or null when the mesh folds only with physics off. */
|
|
3403
3415
|
physics_on: FoldSide | null;
|
|
3404
|
-
/** The reading with physics off, or null when
|
|
3416
|
+
/** The reading with physics off, or null when that side found no fold or skipped this animation. */
|
|
3405
3417
|
physics_off: FoldSide | null;
|
|
3406
|
-
/** When
|
|
3418
|
+
/** When physics on found a fold and physics off measured none, the physics constraints on the mesh's bones (`<name> on <bone>`); empty otherwise. */
|
|
3407
3419
|
physics_constraints: string[];
|
|
3408
3420
|
/** The `may_fold` entry's why when the requirements file declares this slot and animation; null when nothing does. */
|
|
3409
3421
|
declared: string | null;
|
|
@@ -3414,11 +3426,13 @@ export interface FoldRow {
|
|
|
3414
3426
|
/** `check.json`'s `ANIMATIONS_DO_NOT_FOLD`: written whenever the motion holds an animation, the idle included. */
|
|
3415
3427
|
export interface FoldsLine {
|
|
3416
3428
|
status: 'PASS' | 'FAIL';
|
|
3417
|
-
/** Every animation, the idle included, in motion.json's order
|
|
3429
|
+
/** Every animation read on the original build, the idle included, in motion.json's order. */
|
|
3418
3430
|
animations: string[];
|
|
3419
3431
|
fps: number;
|
|
3420
3432
|
/** How many physics constraints the rig declares ({@link withoutPhysics}) — stepped in `physics_on` and left out in `physics_off`; 0 when the rig has none. */
|
|
3421
3433
|
physics_left_out: number;
|
|
3434
|
+
/** Animations omitted from the keyed build when stripping physics removed their last timeline. */
|
|
3435
|
+
physics_off_skipped?: string[];
|
|
3422
3436
|
/** Every mesh that folds in an animation read, in that animation's order and rigc's mesh order. */
|
|
3423
3437
|
folding: FoldRow[];
|
|
3424
3438
|
/** The rows no `may_fold` entry takes: the bar's figure. */
|
|
@@ -3644,7 +3658,9 @@ export function foldsLine(
|
|
|
3644
3658
|
motion: Record<string, unknown> = {},
|
|
3645
3659
|
context?: WeightStepContext,
|
|
3646
3660
|
slotParts?: ReadonlyMap<string, string>,
|
|
3661
|
+
physicsOffSkipped: readonly string[] = [],
|
|
3647
3662
|
): FoldsLine {
|
|
3663
|
+
const offSkipped = new Set(physicsOffSkipped);
|
|
3648
3664
|
const toSide = (m: FoldingMesh | undefined): FoldSide | null =>
|
|
3649
3665
|
m === undefined ? null : { frames: m.frames, worst_frame: m.worstFrame, worst_triangles: m.worstTriangles, line: m.line };
|
|
3650
3666
|
const folding: FoldRow[] = [];
|
|
@@ -3667,7 +3683,7 @@ export function foldsLine(
|
|
|
3667
3683
|
const off = offList.find((m) => m.slot === slot && m.attachment === attachment);
|
|
3668
3684
|
const primary = (on ?? off) as FoldingMesh;
|
|
3669
3685
|
const entry = mayFold.find((e) => e.slot === slot && e.animation === name);
|
|
3670
|
-
const onlyPhysicsOn = on !== undefined && off === undefined;
|
|
3686
|
+
const onlyPhysicsOn = on !== undefined && off === undefined && !offSkipped.has(name);
|
|
3671
3687
|
const constraints = onlyPhysicsOn ? meshPhysicsConstraints(rig, slot, attachment, physicsList) : [];
|
|
3672
3688
|
const row: FoldRow = {
|
|
3673
3689
|
...checkSlotRow('ANIMATIONS_DO_NOT_FOLD.folding', entry === undefined, slot, slotParts),
|
|
@@ -3688,14 +3704,16 @@ export function foldsLine(
|
|
|
3688
3704
|
worstOf.set(row, primary.worstTriangleList);
|
|
3689
3705
|
}
|
|
3690
3706
|
}
|
|
3691
|
-
const physics =
|
|
3707
|
+
const physics = (name: string): string =>
|
|
3692
3708
|
physicsLeftOut === 0
|
|
3693
3709
|
? ''
|
|
3694
|
-
: `, with its ${physicsLeftOut} physics constraint(s) on and off`;
|
|
3710
|
+
: `, with its ${physicsLeftOut} physics constraint(s) ${offSkipped.has(name) ? 'on' : 'on and off'}`;
|
|
3695
3711
|
for (const r of folding) {
|
|
3696
3712
|
if (r.declared !== null) continue;
|
|
3697
3713
|
const sideClause =
|
|
3698
|
-
|
|
3714
|
+
offSkipped.has(r.animation)
|
|
3715
|
+
? ' (physics off: SKIP — removing physics leaves no timeline)'
|
|
3716
|
+
: r.physics_on !== null && r.physics_off === null && physicsLeftOut > 0
|
|
3699
3717
|
? ` (physics on: ${r.physics_on.frames} frame(s), worst frame ${r.physics_on.worst_frame} (${r.physics_on.worst_triangles}/${r.triangles} triangle(s)); physics off: 0 frame(s); physics constraint(s) on mesh "${r.attachment}": ${r.physics_constraints.join(', ')})`
|
|
3700
3718
|
: r.physics_on !== null && r.physics_off !== null && physicsLeftOut > 0
|
|
3701
3719
|
? ` (physics on: ${r.physics_on.frames} frame(s), worst frame ${r.physics_on.worst_frame}; physics off: ${r.physics_off.frames} frame(s), worst frame ${r.physics_off.worst_frame})`
|
|
@@ -3705,7 +3723,7 @@ export function foldsLine(
|
|
|
3705
3723
|
problems.push({
|
|
3706
3724
|
code: `CHECK_${FOLD_LINE}`,
|
|
3707
3725
|
object: `animation "${r.animation}", mesh "${r.attachment}" (slot "${r.slot}")`,
|
|
3708
|
-
detail: `rigc render --folds at ${fps} fps${physics}${sideClause}: ${r.line}; ${foldBonesText(rig, motion, r.slot, r.attachment, r.worst_frame, worstOf.get(r) ?? [], context)}; no triangle turned over against the setup pose is required — a fold the art means is declared in the --requirements file's may_fold, { "slot": "${r.slot}", "animation": "${r.animation}", "why": … }`,
|
|
3726
|
+
detail: `rigc render --folds at ${fps} fps${physics(r.animation)}${sideClause}: ${r.line}; ${foldBonesText(rig, motion, r.slot, r.attachment, r.worst_frame, worstOf.get(r) ?? [], context)}; no triangle turned over against the setup pose is required — a fold the art means is declared in the --requirements file's may_fold, { "slot": "${r.slot}", "animation": "${r.animation}", "why": … }`,
|
|
3709
3727
|
});
|
|
3710
3728
|
}
|
|
3711
3729
|
const declaredNotFolding = mayFold.filter((e) => !folding.some((r) => r.slot === e.slot && r.animation === e.animation)).map((e) => ({ ...checkSlotRow('ANIMATIONS_DO_NOT_FOLD.declared_not_folding', true, e.slot, slotParts), slot: e.slot, animation: e.animation }));
|
|
@@ -3713,7 +3731,7 @@ export function foldsLine(
|
|
|
3713
3731
|
problems.push({
|
|
3714
3732
|
code: `CHECK_${FOLD_LINE}`,
|
|
3715
3733
|
object: `${requirementsPath ?? 'the requirements file'} may_fold (slot "${e.slot}", animation "${e.animation}")`,
|
|
3716
|
-
detail: `declares a fold, and rigc render --folds at ${fps} fps${physics} reads no folded triangle on slot "${e.slot}" in animation "${e.animation}"; an exception that excepts nothing is taken out of the file`,
|
|
3734
|
+
detail: `declares a fold, and rigc render --folds at ${fps} fps${physics(e.animation)} reads no folded triangle on slot "${e.slot}" in animation "${e.animation}"; an exception that excepts nothing is taken out of the file`,
|
|
3717
3735
|
});
|
|
3718
3736
|
}
|
|
3719
3737
|
const undeclared = folding.filter((r) => r.declared === null).length;
|
|
@@ -3722,6 +3740,7 @@ export function foldsLine(
|
|
|
3722
3740
|
animations: [...named],
|
|
3723
3741
|
fps,
|
|
3724
3742
|
physics_left_out: physicsLeftOut,
|
|
3743
|
+
...(physicsOffSkipped.length === 0 ? {} : { physics_off_skipped: [...physicsOffSkipped] }),
|
|
3725
3744
|
folding,
|
|
3726
3745
|
folding_undeclared: undeclared,
|
|
3727
3746
|
declared_not_folding: declaredNotFolding,
|
|
@@ -3911,7 +3930,8 @@ export function levelLine(feet: readonly LevelFoot[], rig: Record<string, unknow
|
|
|
3911
3930
|
const names = readings.map((r) => r.animation);
|
|
3912
3931
|
const line: LevelLine = { status, animations: names, fps, physics_left_out: physicsLeftOut, bar_degrees: LEVEL_BAR_DEGREES, bar: LEVEL_BAR_SOURCE, feet: rows.map(row => ({ ...row, ...checkRow('FEET_STAY_LEVEL.feet', 'part', row.status === 'FAIL', [row.part]) })) };
|
|
3913
3932
|
if (status === 'SKIP') {
|
|
3914
|
-
line.reason =
|
|
3933
|
+
line.reason = names.length === 0 ? 'no animation remains in the physics-off build'
|
|
3934
|
+
: `no frame of ${names.map((n) => `"${n}"`).join(', ')} turns a bone above ${rows.map((r) => `"${r.bone}" (which "${r.part}" rides)`).join(', ')}, so no foot was seen while its leg was posed`;
|
|
3915
3935
|
}
|
|
3916
3936
|
return line;
|
|
3917
3937
|
}
|
|
@@ -6961,7 +6981,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
|
|
|
6961
6981
|
let loopSet: FrameSet | null = null;
|
|
6962
6982
|
let loopPhysics: LoopPhysics[] | null = null;
|
|
6963
6983
|
// The keyed build (issues #183, #320): with a physics constraint, the same rig and motion with every one left out,
|
|
6964
|
-
// built once the same way
|
|
6984
|
+
// built once the same way for the loop and the physics-off reading of the remaining animations.
|
|
6965
6985
|
const stripped = withoutPhysics(inp.rig, inp.motion);
|
|
6966
6986
|
let keyed: string | null = null;
|
|
6967
6987
|
const keyedBuild = (what: string): string => {
|
|
@@ -7116,17 +7136,21 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
|
|
|
7116
7136
|
const offDir = join(foldDir, 'off');
|
|
7117
7137
|
const frOn = measured(['render', '--candidate', buildDir, '--folds', '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', onDir]);
|
|
7118
7138
|
if (frOn.status !== 0) refuseIfAny(rigcFailed(`render --folds --fps ${fps}`, frOn, frOn.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
|
|
7119
|
-
// The physics-off half takes no schedule (issue #538): its candidate declares no physics constraint, so no
|
|
7120
|
-
// world moves it, and rigc render refuses a schedule on it by name.
|
|
7121
|
-
const frOff = rigc(['render', '--candidate', keyedBuild('the animations with their physics constraint(s) left out'), '--folds', ...geometry, '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', offDir]);
|
|
7122
|
-
if (frOff.status !== 0) refuseIfAny(rigcFailed(`render --folds${geometry.map((g) => ` ${g}`).join('')} --fps ${fps} (physics constraint(s) left out)`, frOff, frOff.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
|
|
7123
7139
|
const readingsOn = filterFolds(readFoldSets(onDir, animationNames, fps, frOn.out));
|
|
7124
|
-
const
|
|
7125
|
-
|
|
7140
|
+
const keyedNames = isRecord(stripped.motion.animations) ? Object.keys(stripped.motion.animations) : [];
|
|
7141
|
+
let readingsOff = new Map<string, FoldingMesh[]>();
|
|
7142
|
+
if (keyedNames.length > 0) {
|
|
7143
|
+
// The physics-off half takes no schedule (issue #538): its candidate declares no physics constraint, so no
|
|
7144
|
+
// world moves it, and rigc render refuses a schedule on it by name.
|
|
7145
|
+
const frOff = rigc(['render', '--candidate', keyedBuild('the animations with their physics constraint(s) left out'), '--folds', ...geometry, '--fps', String(fps), '--max', String(FOLD_RENDER_MAX), '--out', offDir]);
|
|
7146
|
+
if (frOff.status !== 0) refuseIfAny(rigcFailed(`render --folds${geometry.map((g) => ` ${g}`).join('')} --fps ${fps} (physics constraint(s) left out)`, frOff, frOff.out.split('\n').filter((l) => l.includes('FAIL') || l.includes('rigc:'))));
|
|
7147
|
+
readingsOff = filterFolds(readFoldSets(offDir, keyedNames, fps, frOff.out));
|
|
7148
|
+
}
|
|
7149
|
+
folds = foldsLine(animationNames, fps, stripped.physics.length, readingsOn, mayFoldForRun, reqFile === null ? null : reqFile.path, foldProblems, readingsOff, inp.rig, stripped.physics, inp.motion, { config, stage: inp.stage }, checkSlotParts(inp.rig, inp.parts?.parts.map(p => p.name) ?? [], inp.parts?.alternates?.map(set => set.name) ?? []), stripped.droppedAnimations);
|
|
7126
7150
|
if (feet.length > 0) {
|
|
7127
|
-
const sets = readJson(join(offDir, 'frames.json'), []);
|
|
7151
|
+
const sets = keyedNames.length === 0 ? null : readJson(join(offDir, 'frames.json'), []);
|
|
7128
7152
|
const listed = sets !== null && Array.isArray(sets.sets) ? sets.sets.filter(isRecord) : [];
|
|
7129
|
-
const levelReadings =
|
|
7153
|
+
const levelReadings = keyedNames.map((name) => {
|
|
7130
7154
|
const dir = join(offDir, String((listed.find((x) => x.animation === name) as Record<string, unknown>).dir));
|
|
7131
7155
|
return { animation: name, set: readFrameSet(dir), geometryPath: join(dir, GEOMETRY_FILE) };
|
|
7132
7156
|
});
|
|
@@ -7857,7 +7881,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
|
|
|
7857
7881
|
pack,
|
|
7858
7882
|
packOpaque,
|
|
7859
7883
|
idle: idle === null || loop === null ? null : { frames: idle.frames.length, fps: idle.fps, duration: idle.duration, lastIndex: idle.frames[idle.frames.length - 1].index, loopAt: { x: loop.x, y: loop.y } },
|
|
7860
|
-
loopPhysics: loopPhysics === null ? null : loopPhysicsLine(loopPhysics),
|
|
7884
|
+
loopPhysics: loopPhysics === null ? null : loopPhysicsLine(loopPhysics, stripped?.droppedAnimations),
|
|
7861
7885
|
seamViewport,
|
|
7862
7886
|
bars,
|
|
7863
7887
|
problems,
|