AAA_WORKFLOW_CORRESPONDENCE_2026-08-06.md

pipelines/AAA_WORKFLOW_CORRESPONDENCE_2026-08-06.md

THE AAA WORKFLOW CORRESPONDENCE DOSSIER — 2026-08-06

What this is. Josh's charter, verbatim: *"Make sure youre understanding how AAAA games workflows

actually work on this and how we are doing the same but even better quality using the AI pipelines."*

This dossier answers it stage by stage. For each stage of real AAA character/creature/animation/VFX

production it states what a studio actually does, what leaves the stage, and **what the quality gate

is** — then puts our own pipeline beside it with a MATCH / PARTIAL / MISSING verdict carried on a

measured number and the record it came from. It closes with the ROM/calisthenics spec the

JOINT-ROM CORRECTNESS LAW demands, and with the correspondence gaps ranked as wave candidates.

Authority. PROPOSAL-TIER. This dossier rules nothing. Canon, the CVD and Josh's rulings bind every

line of it. It is a MAP of two pipelines against each other; where our pipeline and a studio's differ,

that difference is a finding, never an instruction to change canon.

The honest register, held throughout. Per the 2026-08-06 universal calibration ruling, every

generated asset class in this project is GREYBOX until its plates pass Josh's graded floor. Nothing in

this dossier upgrades any asset's tier. Where a stage reads MATCH, the claim is that the STAGE exists

and has a gate — never that its output is shippable. The count of Josh-graded-acceptable generated

plates across three generations is 0 *(superseded 2026-08-10, director-rows wave: the V4 body

plates postdate this dossier and are generated and Josh-approved — "Yeah v4 is approved",

build/art/characters/body_evidence/BODY_V4_CARRY_SEVEN_AGE.json; the shippability register above

is unchanged)*, and the gallery's own tier census reads

AAAAA-VERIFIED: 0 of 334 assets (build/gallery/gallery_data.json totals.tiers). Both numbers

stand behind every row below.

---

1. Method, and the two things this dossier refuses to do

How the AAA column was built. Two research lanes ran against the public record — GDC Vault talk

pages and transcripts, SIGGRAPH-adjacent course material, first-party Epic/Autodesk/Vicon/Simplygon

documentation, studio blogs and vendor production features. Every AAA claim below carries its source.

Where the public record is thin and the claim rests on general industry practice rather than a

citable source, it is marked [INDUSTRY-GENERAL] and is never used to ground a verdict against us.

Two prior lanes already did comparator research and this dossier extends rather than repeats them:

the Capcom creature-infrastructure addendum in PIPE_3D_2026-07-29.md §7 and the moveset-cadence

addendum in PIPE_ANIMATION_2026-07-29.md §7, plus the FF7 Remake VFX source-library findings in

PIPE_ART_2026-07-29.md §7.

Refusal one: no headcount transfer. Monster Hunter Wilds ran a character section of roughly 60

people (PIPE_3D_2026-07-29.md §7.1, which already marks it NO-ADOPT). Nothing here claims we do

what a 60-person section does. What transfers is stage ORDER and GATE SHAPE.

Refusal two: no verdict on taste. This dossier measures whether a stage EXISTS and whether it has

a gate. Whether our output is beautiful is Josh's call and has already been made — three times, in the

negative. A stage can read MATCH and its output can still be rejected; those are different questions,

and collapsing them is exactly the inflation defect the face judge was recalibrated for.

---

2. THE STAGE MAP — fifteen stages, one line each

Four stages read MISSING outright (2, 4, 9, 11) and one is MISSING at its delivery end (12). Stage 2 is

missing on purpose and costs us a cheap iteration rung rather than a quality floor. The other four are

the correspondence gaps section 6 turns into waves.

One cross-cutting finding, and it reframes the whole comparison. Across fifteen stages, the public

AAA record contains exactly two mechanised gates: texel-density tooling with an engine-side scaling

API and, in some in-house engines, a submit block; and Unreal's Data Validation running on save and on

changelist. Everything else — concept sign-off, blockout approval, anatomy review, deformation review,

lookdev approval, VFX readability — is a human looking at the work. That asymmetry is the honest

frame for section 4: our advantage is not that we generate faster, it is that most of what a studio

holds in a lead's judgement, we hold as a measured artifact with a positive control — and our

corresponding weakness is that the two things a studio has and we do not are the sculptor's hands and

the art director's daily eye. Josh's grading rulings this week are that second thing arriving.

---

3. Stage by stage

3.1 Concept art and the art-direction gate

AAA. The sequence is published. Sucker Punch's lead concept artist describes the *Ghost of Tsushima*

process as narrative brief → research and reference gathering → thumbnail sketches → *"rounds of

iterations, and reworks to address any technical issues"* → likeness fitting once actors were cast, and

notes that *"what ends up in the game is often a toned-down version of the concepts"*

(https://blog.playstation.com/2020/10/26/from-brush-to-blade-the-concept-art-process-behind-ghost-of-tsushima/).

The strongest published case is Guerrilla's, because it makes the concept package a CONTRACT: they

outsource assets on a very large scale and therefore run a very small internal asset-art team against a

relatively large concept team, and the GDC 2016 Art Direction Bootcamp talk is explicitly about

*"creating the highly detailed briefs that are required"* and how quality is guarded across outsourcing

vendors (Maarten van der Gaag, https://gdcvault.com/play/1023158/Art-Direction-Bootcamp-Guerrilla-Games).

When the 3D work leaves the building, the brief IS the spec and the art director's leverage is

front-loaded into it. The standard components — orthographic turnarounds at one camera height, material

and detail callouts, palette, scale reference — are convention rather than a citable standard

[INDUSTRY-GENERAL].

• Deliverable: a brief-plus-concept package complete enough that someone who was not in the room can

build from it without a conversation.

• Gate: art-director sign-off per iteration stage, not once at the end — a checkpoint after

rough sketch, after refined concept, after final

(https://vsquad.art/blog/why-3d-game-concept-art-outsourcing-fails-and-how-to-prevent-it-in-your-pipeline).

Nothing automatic checks concept art; the gate is human and what is measured is brief completeness.

OURS. This is the stage we have built hardest, and it is the one Josh's rulings have been aimed at.

The chain is: a canon-keyed plate prompt → n candidate plates from the ratified Z-Image-Turbo graph

→ a contact sheet → a cold judge against a written rubric → a pick → and now, above all of it,

Josh's own grade.

• Object classes run n ≥ 4 candidates keyed to the row's own mesh_tags

(build/3d/V2_ROUTING_RATIFIED.json routing.weapon_identity_failed.conditioning). The face ran

40 plates across two generations, then 24 more in a third

(build/3d/characters/CHAR_0001_FACE_PIVOT_RECORD.json plates.plates_generated;

CHAR_0001_FACE_G3_JUDGE.json).

• The rubric is written and versioned: harness/qa/comparator_rubrics/character_appeal.json carries

eight checks APP-C1..C8 (age-band truth, proportion harmony, eye rendering, hair quality, skin read,

cultural authenticity, authorship, roster coverage), each naming its instrument and its instrument's

state (EXISTING / PARTIAL / NONE).

• The concept-first law is enforced structurally, not by habit: an identity-bearing class **cannot

emit** without a judged plate (V2_ROUTING_RATIFIED.json teeth.T1-T4), and the cost of arming

it is recorded rather than hidden — 154 rows refused on the day it armed

(PIPE_3D_2026-07-29.md §10.4).

VERDICT: MATCH in structure, and the output is rejected. The stage exists, has a written gate, and

now has the one thing it was missing — a human art director whose eye outranks the automated judge.

That correction is itself recorded: the gen-3 judge scored "stylized medium" as FF7R and was

recalibrated against Josh's read, not the reverse. **Honest tier: concept/greybox. Zero generated

plates have been acceptable across three generations.** The ability/VFX plates are the same stage at

volume and read the same way — 96 rows × 4 candidates = 384 plates judged, **GO 1 / GO_WITH_FIXES 14

/ NO_GO 81** (harness/ability_vfx/avx_judge.json verdicts).

The one structural difference worth naming. A studio's concept stage produces an ORTHO SET whose

purpose is to constrain geometry from three sides. Ours produces a hero plate whose purpose is to

condition a generator from one side. That is why the face pivot's texture record reads

observed_fraction 0.8072 with the unobserved remainder "concentrated on the BACK of the head, which

the front-three-quarter conditioning plate never showed"

(CHAR_0001_FACE_PIVOT_RECORD.json texture.hole_fill_note). The model sheet's back view is not a

stylistic convention; it is the input the back of the head needs, and our plate ladder measured

BACK 0 of 6 genuinely turned (plates.measured_findings.M1_orientation_clause_is_weak_not_inert).

3.2 Blockout / proxy

AAA. The 2D concept is translated into simple 3D forms and validated for **proportion, scale and

silhouette readability in engine** — *"often the first point where gameplay and camera constraints

affect the design"* — with the stated payoff being *"faster approvals with visual, animation, and engine

criteria reviewed together instead of sequentially"*

(https://nastyrodent.com/stylized-3d-characters-art-direction-principles/). Blockout is a named

production stage: primitives, correct scale, no detail (https://nhance-school.com/tools/glossary/blockout).

• Deliverable: a proxy mesh at correct scale, in engine, on the game camera, ideally on a temp rig.
• Gate: AD plus animation plus design reviewing silhouette-at-distance and camera readability before

any high-poly time is spent. This is the least-documented stage in the public AAA record — no

named studio talk formalises a character blockout gate. [INDUSTRY-GENERAL.]

OURS. There is no blockout stage. The generator emits a final-density shell in one pass

(TripoSG, seed 42 / 50 steps / guidance 7.0 / 250k faces / octree 9 —

V2_ROUTING_RATIFIED.json routing.*.geometry), and the plate ladder plays the role a blockout plays

elsewhere: it is where cheap iteration happens.

VERDICT: MISSING BY DESIGN. This is a genuine structural difference and not obviously a defect —

generation collapses blockout and final into one 25-second step. The cost is real and should be named:

we have no cheap rung between "a picture" and "119,994 triangles", so every silhouette question is

answered either in 2D (where it does not bind the geometry) or after a full lift. The

build/3d/silhouette/ proof lane exists precisely because that rung is missing, and its own finding is

that a whole-body PCA silhouette proof could not distinguish the epaxial ridge it was built to prove

(compactness delta +0.00101, hull-fill delta +0.00184 — AAAAA register row 42).

3.3 High-poly sculpt and the anatomy review

AAA. ZBrush sculpting at roughly a million polygons, then decimation, is Square Enix's disclosed

approach on the *FFVII Remake* project — **our ruled appeal bar, and its published numbers are the most

useful budget signal in this dossier**: 1997 Cloud ≈ 900 polygons, *Remake* Cloud ≈ 110,000, *Rebirth*

Cloud ≈ 220,000

(https://blog.playstation.com/2024/03/21/final-fantasy-vii-rebirth-the-polygonal-evolution-from-1997-to-the-modern-remake-project/).

Lead character artist Dai Suzuki adds the number that should reorder our own priorities: Cloud's hair

*"was an extremely high-priority element and in fact accounted for half of the total polygon count for

the whole model"*

(https://www.gamesradar.com/final-fantasy-7-remake-devs-put-special-effort-into-creating-clouds-hair-half-of-the-characters-total-polygon-count-in-fact/).

Naughty Dog describe the same stage as *"sculpting our character, building our arbitrary meshes and

sampling the hi-resolution detail down to this new mesh"* (Diamant & Simantov, *Uncharted 2 Character

Pipeline*, GDC 2010, https://gdcvault.com/play/1012552/Uncharted-2-Character-Pipeline-An). Skin

micro-detail is usually SOURCED rather than sculpted — multi-channel displacement packs split low-,

medium- and high-frequency detail across RGB channels

(https://texturing.xyz/pages/discover-unwrapped-multi-channel-faces).

On creatures the anatomy layer is increasingly simulated rather than sculpted: Ziva VFX is an FEM

soft-tissue plugin *"used to digitally replicate and couple the physics and materiality of soft

tissue"*, with game credits including *Senua's Saga: Hellblade II*

(https://www.fxguide.com/quicktakes/unity-acquires-ziva-dynamics/) — though Unity has since

discontinued the suite, which is a planning caveat rather than a capability one. Capcom designed Wilds'

fictional monsters against real animal anatomy references

(https://blogs.autodesk.com/media-and-entertainment/2026/04/23/the-production-infrastructure-behind-capcoms-monster-hunter-wilds/,

already recorded at PIPE_3D_2026-07-29.md §7.2).

• Deliverable: a multi-subtool high-poly with primary, secondary and tertiary detail separated.
• Gate: anatomy and likeness review by a lead character artist or AD; the checkable measure is

silhouette plus landmark accuracy against reference photography. [INDUSTRY-GENERAL for the ceremony.]

OURS. The generator produces the dense source: raw_faces 2,408,700 decimated to 250,000 and

finished at 119,994 on the face pivot (CHAR_0001_FACE_PIVOT_RECORD.json geometry). There is no

sculpt and no human sculptor's anatomy review — but there is something a studio typically does NOT

have, and it deserves to be counted: the anatomy review is arithmetic and it is armed.

harness/asset_factory/check_anatomy_conformance.py (tooth T7) asserts five things against a per

archetype reference table — A1 bone roster, A2 segment count, A3 required bones, A4 ROM on sampled

poses, A5 centreline follows the body — with a fixture proving it fires and a

build/3d/schema/anatomy_conformance_baseline.json ratchet whose own header reads

*"THIS IS A MEASURED BACKLOG, NEVER A CLEAN BILL OF HEALTH."*

The reference table it reads is not a guess. build/3d/schema/anatomy_reference/ carries eight

archetype files (QUADRUPED, SPRAWLING_QUADRUPED, LIMBLESS, WINGED, AQUATIC, ARBOREAL_PRIMATE,

MULTI_LEGGED, HUMANOID) in which every joint carries its type, its per-axis degree range, its sign

convention, its basis (measurement / morphology / UNMEASURED) and its citations —

and mechanism notes a rigger can act on: the quadruped scapula slides on the ribcage rather than

articulating to the spine; the horse's stifle and hock are mechanically coupled by the reciprocal

apparatus so posing them separately produces a posture no horse can hold; a bird's radius and ulna form

a parallel linkage so elbow and wrist carry one degree of freedom between them; a snake's

zygosphene-zygantrum permits lateral flexion and BLOCKS axial rotation.

Two numbers worth putting side by side. Our shipped face pivot is 119,994 triangles — the same order

as *Remake* Cloud's ≈110,000 polygons, and roughly half *Rebirth* Cloud's ≈220,000. We are not short of

density; the appeal bar is not a polygon count. And the FF7R hair figure reframes our own groom debt:

the teacher spends half its hero budget on hair, which makes converting the pivot's 2,558 strand

shells to cards a budget-legitimate priority rather than an extravagance, and makes 73 bald creature

rows a larger deficit than their triangle count suggests.

VERDICT: PARTIAL. No sculpt, no craft review — and a machine-checkable anatomy specification that

most studios keep in a lead's head. The gap is not the specification; it is that **nothing yet drives

the specification** (stage 9).

3.4 Retopology, shared-topology cages and wrap — THE BINDING CONSTRAINT

AAA. This is the stage where the industry has genuinely converged, and the public record is strong.

Studios do not retopologize each head. They non-rigidly fit one standard base cage onto every scan

or sculpt. R3DS states the mechanism and its payoff directly: Wrap lets you *"take an existing base

topology and automatically fit it to each scan"*, turning *"a series of 3D scans of an actor into a

digital character with identical topology"* with *"the same … texture coordinates"*, and it can

*"generate a set of morph targets for further animation"* from expression scans — and because the node

graph is a recipe, *"after processing one scan you can apply the same actions to an unlimited number of

other scans"* (https://www.russian3dscanner.com/). The blendshape consequence is the whole point:

identically-topologised wraps *"naturally become blendshapes of each other"* (https://docs.r3ds.com/Wrap/).

Wrap4D extends it to performance capture, processing each frame independently so error cannot

accumulate and frames can be farmed across machines

(https://www.fxguide.com/fxfeatured/4d-processing-with-r3ds-wrap4d/).

What the cage buys, in the published record:

• One rig serving many characters. Naughty Dog: *"we use Maya referencing to allow us to maintain

one skeleton for all the different outfits"*, and *"one skeleton for both male and female characters"*

(https://gdcvault.com/play/1012552/Uncharted-2-Character-Pipeline-An).

• Blendshape reuse at volume. John Hable, *Next-Gen Characters: From Facial Scans to Facial

Animation*, GDC 2014 — raw scans → aligned blendshapes → compressed for real time → driven by

mocap, framed explicitly as solving *"quality and volume"*

(https://www.gdcvault.com/play/1021248/Next-Gen-Characters-From-Facial).

• Head MIXING as a content multiplier, and batch repair as the payoff. Guerrilla built **168

high-quality heads in three years** for *Horizon Forbidden West*; 3Lateral supplied a custom "Gene

Splicer" enabling new faces by mixing existing assets, and Guerrilla needed batching tools to push

shader, texture, skinning, rig and optimisation changes across 100+ head rigs at once

(https://www.gamedeveloper.com/marketing/creating-and-integrating-the-many-faces-of-horizon-forbidden-west;

talk: Arno Schmitz, GDC 2022,

https://www.guerrilla-games.com/read/creating-the-many-faces-of-horizon-forbidden-west).

• The commodity version. MetaHuman DNA encodes head and body geometry and skeleton in the neutral

pose at multiple LODs, with skin weights encoded per LOD and expressions stored as joint

animations augmented by per-vertex displacement at LOD0 only

(https://dev.epicgames.com/documentation/metahuman/metahuman-dna-rig-definition-and-rig-operation).

Its "Creator From Custom Mesh" tool accepts sculpts, scans **or AI-generated meshes "of any

topology"** and outputs standard MetaHuman topology in the A pose while preserving proportions

(https://dev.epicgames.com/documentation/metahuman/metahuman-creator-from-custom-mesh-tool-in-unreal-engine)

— which is precisely the conform operation our route is missing, offered as a product.

Capcom's chain names Quad Remesher for the general retopology role

(https://blogs.autodesk.com/media-and-entertainment/2026/04/23/the-production-infrastructure-behind-capcoms-monster-hunter-wilds/).

• Deliverable: a game-resolution mesh on the studio's standard cage, UVs inherited from the cage,

high-poly detail projected in.

• Gate: Epic publishes the actual failure modes, which doubles as the review checklist — *"heavily

stylized meshes or meshes with extreme proportions may not solve well"*, loose clothing fits the

garment silhouette rather than the body, and *"severe scan artifacts (holes, self-intersections)

destabilize results"* and must be cleaned first (same MetaHuman source). Beyond that: topology

conformance to the cage, which is automatable because a head off the cage breaks every shared asset

downstream. [INDUSTRY-GENERAL for the check's form.]

OURS. This stage does not exist, and the measurement is unambiguous. The stack's one quad-retopo

tool returned literally zero: build/3d/candidates/face_pivot/CHAR_0001_FACE_finish.json reads

remesh_used: false, out_quads: 0, topology_route: "tri_decimate", with the tool's own note

kept in the record — *"AutoRemesher produced no usable quad mesh; the finished asset carries the

cleaned triangle mesh. Recorded, not hidden."*

Everything the AAA cage buys is therefore absent, and each absence is separately measured:

• Continuous aging is RULED canon and structurally impossible today.

V2_ROUTING_RATIFIED.json states it flat: two age states generated independently cannot be blended,

because there is no vertex correspondence to blend along. 187 aging meshes and 103 characters

touching a child band sit behind this.

• No facial rig. 0 face bones on either head route; no FACS.
• No morph-target customization, which CVD Selection 3 face/skin-tone customization requires.
• No cast reuse. 1 of 167 cast rows has been through the appeal rubric (APP-C8, whose instrument

state is NONE).

The correspondence argument, stated as sharply as the evidence allows. Guerrilla's cast is 168

heads; ours is 167 cast rows. Their batching tools push a shader, rig or optimisation change across

100+ heads in one operation. We cannot build that tool at all — not because we lack the engineering,

but because a batch operation over heads requires the heads to be the same shape of thing, and ours are

167 independent iso-surfaces. Every improvement we make to CHAR_0001 is an improvement to CHAR_0001.

That is the cost of this gap stated in the teacher's own units.

And the off-the-shelf answer was evaluated and does not fit. MetaHuman's conform tool takes "any

topology" and would close this in a product — except its parametric body exposes 30 live constraints

and not one of them is age; all 18 fixed archetypes are adult, and while stature reaches the canon

child (129.0 cm requested, 129.19 measured on real geometry), PROPORTION does not: two independent

geometric proxies bracket head-units at 6.62-7.35 against the canon child's 6.567

(docs/proposals/METAHUMAN_ROUTE_EVIDENCE.md §3, quoted in V2_ROUTING_RATIFIED.json

routing.generated_character_head.supersession_evidence). The industry's standard cage cannot make our

protagonist, which is exactly why the cage is ours to build rather than to buy — and why the register's

row 19 takes the MetaHuman body for the ADULT and ADOLESCENT bands while leaving the child on our own

solve.

VERDICT: MISSING, and it is the binding constraint — the AAAAA register reaches the same

conclusion independently (row 34, held out of the ratio ranking on purpose). The fix shape is already

diagnosed and should not be re-litigated: **a WRAP solver conforming a cage that already has

correspondence, not a second attempt at deriving one** (register §4). The R3DS framing is the one to

copy: the wrap is a RECIPE applied to an unlimited number of subsequent subjects, which is what turns a

one-asset fix into a 167-asset capability.

One correction this dossier carries forward rather than repeating: the "2,558 disconnected hair-strand

bodies" that were blamed for the LOD floor were xatlas UV charts, not bodies — welding by position

collapses 2,558 components to 2, and the welded chain lands every LOD target

(119,994 / 59,996 / 29,998 / 11,998, ear retained 99.20%;

build/3d/candidates/face_pivot/lods2/CHAR_0001_FACE_LODS2.json). The cage is still missing; the LOD

floor was never its evidence.

3.5 UVs and texel density

AAA. Texel density is fixed as a project-wide constant in pixels per centimetre so that unrelated

assets read consistently. Published reference points: 2.56 px/cm (= a 1024² map over 4 m × 4 m) cited

as an FPS baseline, with 2048² currently standard for character assets and studios moving to 4096²

relying on mips below

(https://forums.unrealengine.com/t/texel-density-standards-for-aaa-first-person-shooter-games/1646118);

a widely-repeated tiering of 5.12 px/cm for background props against 10.24 px/cm for hero assets

(https://rebusfarm.net/blog/texel-density-basics-every-artist-should-know); and the rule that density

scales with camera distance — first-person highest, third-person lower with compensating detail

(https://www.beyondextent.com/deep-dives/deepdive-texeldensity). UDIMs are film-tier standard and are

reserved in games for ultra-close-up hero characters (https://nastyrodent.com/uv-unwrapping-for-games/).

Naughty Dog's practical rule on *TLOU2* is to extract as much texel density as the layout allows, with

weapon low-polys capped under 25,000 triangles

(https://80.lv/articles/how-naughty-dog-created-the-immersive-world-of-the-last-of-us-part-ii).

Our own genre-baseline audit already recorded the px/cm standard as an industry default and marked it

CLOSE_WITH_DEFAULT

(docs/pipeline_review/art_pipeline_reviews_2026-08-03/genre_baseline_audit.json, character-animation

lane) — and it was never closed.

• Deliverable: UV sets with a declared density, seams placed away from deforming and visible areas.
• Gate: this is one of only two stages in the whole pipeline with a genuinely MECHANISED public

gate. Per-DCC density tools (Blender's Texel Density Checker, Maya's UV Toolkit readout) plus

engine-side ApplyTexelDensityUVScaling in Unreal's Geometry Script

(https://dev.epicgames.com/documentation/en-us/unreal-engine/BlueprintAPI/GeometryScript/UVs/ApplyTexelDensityUVScaling)

and density visualisation viewmodes. Some in-house engines go further and **block a source-control

submit** on it outright (https://www.beyondextent.com/deep-dives/deepdive-texeldensity).

OURS. Texel density is a real, gated deliverable — per asset, not per project.

• The garment route makes it explicit and refuses below a floor: stage_outfit_uv_dense.py's own

docstring says *"texel density IS the deliverable"*, and the measured move is 24.8% atlas use at

1.13 mm/texel (MVA staging) → 50.1% at 0.384 mm/texel (dense staging).

V2_ROUTING_RATIFIED.json records the rule: *"texel density is gated, not hoped: the staging

refuses to proceed below a stated packing floor and prints mm/texel every run."*

• Population-wide, build/3d/texel_coverage.json measures 254 assets: median untextured fraction

0.24, worst 0.7395, best 0.0064 — and it REPORTS, does not reject, by its own declaration.

• UV utilization is recorded per asset (face pivot uv_area_utilization 0.5577), and the mesh battery

carries uv_in_unit_square: true and min_uv_utilization: 0.18 as hard teeth

(build/3d/verify_all.json battery_thresholds).

VERDICT: PARTIAL. The instrument exists and in one route it is stricter than most studios' (a

refusal, not a report). What is missing is the project-wide standard the instrument would measure

against: 0.384 mm/texel is 26 px/cm, the MVA staging's 1.13 mm/texel is 8.8 px/cm, and nothing

declares which is right for which class. Against the published tiering (10.24 px/cm hero, 5.12 world,

2.56 background) our garment is authored roughly 2.5× above the hero tier and our MVA staging roughly

at it — which is not a defect in either number, it is the absence of a declaration that would make one

of them wrong. Adjacent assets at different densities is the exact defect the standard exists to

prevent, and we are currently generating it.

3.6 Texturing, materials and de-lighting

AAA. PBR authoring is bounded by physically-derived value ranges — dielectric base colour should not

fall below roughly 30 sRGB (tolerant) or 50 sRGB (strict), nor exceed roughly 240 sRGB, with charcoal at

~4% albedo landing near sRGB 50 and fresh snow at the top

(https://www.racoon-artworks.de/blog_PBRfromrulestomeasurements.php) — and studios wrap those ranges in

an in-engine validator that flags out-of-range albedo and metallic per pixel

(https://80.lv/articles/validating-pbr-materials-in-ue4).

Anything captured or generated must be DE-LIT before it can serve as albedo, because the capture's

own shadows and highlights are baked into the diffuse. Two named tools: Unity's open-source De-Lighting

Tool, which needs the lit diffuse plus object-space normals, bent normals and AO

(https://github.com/Unity-Technologies/DeLightingTool), and Agisoft De-Lighter, which needs no

additional maps

(https://www.cgchannel.com/2019/07/download-free-texture-de-lighting-tool-agisoft-de-lighter/).

Detail is layered by frequency (multi-channel displacement carrying secondary, tertiary and micro

bands, plus haemoglobin and melanin maps —

https://www.cgchannel.com/2026/03/texturing-xyzs-skap-takes-your-skin-textures-to-the-next-level/), and

identity is then re-differentiated on top: Guerrilla layered decals — *"little stickers that can be

moved around very precisely, most often to add dirt"* — plus per-head cavity maps driving faceprint

transparency so wrinkle identity survives head reuse, with heavy tribal facepaint used deliberately to

disguise reuse

(https://www.gamedeveloper.com/marketing/creating-and-integrating-the-many-faces-of-horizon-forbidden-west).

• Deliverable: a calibrated PBR set (base colour, roughness, metallic, normal, AO, plus

skin-specific masks).

• Gate: in-engine lookdev under multiple lighting setups, with Guerrilla explicitly using the

photogrammetry photographs themselves as the lookdev TARGET

(https://80.lv/articles/the-production-pipeline-behind-horizon-forbidden-west-s-faces); automated,

the PBR range validator plus Data Validation checks on texture suffixes and compression settings.

**Guerrilla's own postmortem is the best gate argument in the public record, and it is a failure

report.** Review happened too much on Maya rigs and not enough in engine at LOD, and normal maps were

baked only for PS5 — so characters shipped *"overly smooth on PS4"* (same Game Developer source). Read

that as a rule: the gate must run in engine, at ship LOD, on every target platform.

OURS. The observation half of this stage is genuinely strong and is our best-measured route.

• The ratified texture route is **MV-Adapter ig2mv, 6 views, merged through mv_texture_bake.py

(frustum × visibility × facing), holes reported not invented**, with a texel-coverage tooth

(V2_ROUTING_RATIFIED.json texture_route). The positive control that justified it is exact: the

superseded single-projection path observed 30.3% of the surface on MN_0001 and invented the rest;

the 6-view route observes 51.6-79.4%, and a 24-view ablation reaches 98.6%.

• On the face it reached observed_fraction 0.80715, above the whole programme range to date

(n=9, mean 0.61, max 0.79).

• A de-light pass exists. It was simply not run on the pivot head, whose plate lighting is baked

into basecolor and does not respond to a light change (APP-C5;

CHAR_0001_FACE_PIVOT_RECORD.json gaps_named_not_papered_over). It is AAAAA register row 6, cost

class free/config.

Against that, the material AUTHORING half is below the bar and the records say so:

• The protagonist's body is a flat cream CONSTANT sampling zero textures across 45,110 verts

occupying the lower two-thirds of every full-body frame

(CHAR_0001_HEAD_AUTHORED_RECORD.json body_half + known_limits.still_open). This is the named

violation of the whole-entity beauty floor.

• The garment atlas multiplies a 0.74-1.00 occlusion range directly into albedo, so engine AO and

GI double-darken every crease the bake already darkened, and 5 mm of authored ornament relief has no

normal support (CHAR_0001_OUTFIT_V3_TEXTURE.json; register row 41).

• The pivot head ships 1 basecolor and 2 constants — no SSS, no ORM, no authored normal stack —

where the incumbent head has all three.

VERDICT: PARTIAL. Our texture OBSERVATION is measured to a standard studios do not publish;

our material AUTHORING is one basecolor deep on the hero asset. The de-light stage exists and skipping

it is a scheduling failure, not a capability gap. Two AAA checks we do not have at all and could

build cheaply: a PBR range validator (nothing anywhere asserts that our albedo sits inside the

30-240 sRGB dielectric band, and a plate-conditioned bake with baked lighting is exactly the thing that

violates it), and Guerrilla's rule that review happens in engine at ship LOD — our appeal judgements

run on offline Blender renders, which is the same review-surface mistake their postmortem names.

3.7 Grooms and cloth

AAA — grooms. The engine does not author hair. Epic states it flatly: *"the groom system does not

provide a hair grooming solution"* — grooms are built in Maya XGen, Ornatrix, Yeti or Houdini and

imported through a naming-convention-based Alembic schema, with groups for head hair, vellus,

beard, eyelashes and eyebrows, transferring width and color attributes and flagging guide curves

for interpolation and simulation

(https://dev.epicgames.com/documentation/unreal-engine/groom-components-and-assets-in-unreal-engine,

https://docs.unrealengine.com/4.26/en-US/WorkingWithContent/Hair/AlembicForGrooms). The engine-side

trio is Groom Asset / Groom Binding Asset (which binds the groom to the skeletal mesh so skin

deformation drives the hair) / Groom Component, and LODs are expressible as strands, cards OR mesh

— the ladder our own head is halfway up. Fur on creatures is the same class at larger scale; Capcom

runs Houdini Engine inside Maya for fur reduction and alpha optimisation

(https://blogs.autodesk.com/media-and-entertainment/2026/04/23/the-production-infrastructure-behind-capcoms-monster-hunter-wilds/).

AAA — cloth. Marvelous Designer patterns → simulate → ZBrush cleanup of folds, wrinkles and wear →

retopology → bake

(https://discover.therookies.co/2021/05/06/real-time-character-production-workflow-for-games/). At

runtime Naughty Dog drives the visible high-res mesh from a hidden low-res simulation mesh, and swaps

between in-engine gameplay cloth and offline Maya nCloth / Houdini simulation for cinematics, because

multi-layer clothing, self-collision and multi-layer collision *"in game engines are expensive"*

(https://80.lv/articles/how-naughty-dog-created-the-immersive-world-of-the-last-of-us-part-ii); the

whole cloth/hair/fur and automated-LOD culture is the subject of Maximov's *Technical Art Culture of

'Uncharted 4'*, GDC 2016 (https://gdcvault.com/play/1023251/Technical-Art-Culture-of-Uncharted). The

penetration problem is solved by a per-costume template, not per-shot fixes — Capcom's

skirt-animation template uses auxiliary bones and leg movement vectors to prevent foot penetration

(Autodesk source above; recorded at PIPE_3D_2026-07-29.md §7.4).

• Deliverable: groom cache or hair cards with alpha, plus a binding asset; simulated garment with

its collision proxies and its LOD ladder.

• Gate: the groom's Alembic schema is itself a gate — a malformed groom fails import — plus a

strand→card→mesh LOD review in engine, and hard runtime budgets: Naughty Dog capped rigid-body count

at roughly 1,000 live physics objects and used Simplygon for automated LOD with tooling that computes

optimal reduction distances (80.lv source above). The review ceremony itself is a motion test,

because a static groom that reads well can still explode on a run cycle. [INDUSTRY-GENERAL for the

ceremony half.]

OURS. Split verdict, and the creature half is a hole.

• Hair, one asset: the authored incumbent head carries a real card groom — 1,488 cards, 262

excluded by the ear window, 192 whorl-fill cards roofing the crown gap, built against authored

T_HAIR_BCA / T_HAIR_FLOW maps (CHAR_0001_HEAD_AUTHORED_RECORD.json). The PIVOT head — the

route that won on appeal — carries 2,558 strand shells instead of cards, and converting them is

the register's own highest-value next step (row 13).

• Hair, everything else: zero. A grep for groom|fur|hair card|xgen|fibermesh across harness/,

build/3d/schema/ and the game repo's Tools/ returns only the CHAR_0001 head's cards and the

rubric's lens list — re-derived at HEAD this sitting. **73 creature rows (62 QUADRUPED + 11

ARBOREAL_PRIMATE) cannot reach the bar as bald shells no matter how good the rig is** (register

row 47).

• Cloth: no simulation, and a deliberate substitute. The ratified fitted_garment route is

FIT-FIRST AUTHORED GEOMETRY — the garment surface is cut from the body-only mesh with planar

bisects so hems and necklines are exact edge loops, displaced along smoothed normals by a stated

stand-off, and structured with real hems, bands and panels, so *"fit is then guaranteed by

construction rather than measured and hoped"* (V2_ROUTING_RATIFIED.json routing.fitted_garment).

It is measured: combined penetration 1.324%, p01 -0.337 mm, deep tail 0.

Capcom's per-costume template principle is answered by our construction rule, which is the same

insight arrived at from the other end.

VERDICT: PARTIAL on the protagonist, MISSING for creatures. The cloth substitution is defensible

and measured — and it buys fit at the cost of all secondary motion, which is a real quality delta and

is named as one here rather than papered over. **The groom hole is the AAAAA-blocking one, and the

teacher's own number sizes it:** FF7R spends half of Cloud's polygon budget on hair. There is also a

free route correspondence worth recording — Unreal's groom pipeline is Alembic-schema-driven with

strand/card/mesh LODs and a binding asset, which means a creature-coat stage does not need a new engine

capability, only an authoring stage that emits conforming .abc. The engine end is already built and

waiting.

3.8 Skeleton standards

AAA. Studios lock a skeleton template because animation reuse is the whole economy. Autodesk's

HumanIK formalises it: a character must be *characterized* by mapping its joints to a canonical

definition, at minimum fifteen required nodes, and the definition is then locked

(https://help.autodesk.com/cloudhelp/2024/ENU/Maya-CharacterAnimation/files/GUID-5DEFC6E5-033C-45D5-9A0E-224E7A35131B.htm).

Epic's equivalent is the IK Rig / IK Retargeter pair, where one bone is flagged Set Retarget Root

so root motion transfers proportionally and retarget CHAINS map limb to limb, letting animation move

between skeletons with different bone counts, names and orientations while IK goals hold contact

(https://dev.epicgames.com/documentation/unreal-engine/ik-rig-animation-retargeting-in-unreal-engine).

The UE5 skeleton also carries non-deforming CONVENTION bones — root, ik_foot_root, ik_hand_root,

ik_hand_gun — that exist purely as a contract for IK and attachment code

(https://forums.unrealengine.com/t/explanation-of-the-mannequin-ik-bones/45166). Bone counts are

standards in themselves: MetaHuman ≈342, UE5 Mannequin 89, UEFN 88

(https://mocaponline.com/blogs/mocap-news/skeleton-hierarchy-animation-guide — trade source).

Epic's in-house standardisation tool is A.R.T., whose order is skeleton creation → joint-mover

placement → rig build → animation

(https://www.unrealengine.com/en-US/blog/animation-and-rigging-toolkit-arrives-on-the-marketplace).

The two best-documented studio precedents are DICE's *Modular Rigging in Battlefield 3* — small rig

changes previously forced updates to nearly every asset, solved by modular rig assembly

(https://www.gdcvault.com/play/1015573/Modular-Rigging-in-Battlefield) — and Ubisoft's *IK Rig:

Procedural Pose Animation* (Bereznyak, GDC 2016), which defines a pose representation invariant to the

actor's proportions so animation can be shared across morphologies

(https://www.gdcvault.com/play/1023279/IK-Rig-Procedural-Pose).

• Deliverable: a locked template + per-character characterization + naming conventions

(SK_ skeletal mesh, SKEL_ skeleton;

https://dev.epicgames.com/documentation/en-us/unreal-engine/recommended-asset-naming-conventions-in-unreal-engine-projects).

• Gate: automated hierarchy diff against the template, name/case check, characterization lock,

retarget root set. Human: tech-anim lead signs the skeleton once, after which it is versioned canon.

OURS.

• The human is on the standard. The arrival set imports against

/Game/Characters/Mannequins/Meshes/SK_Mannequin with Bones: 89 and MaxBoneInfluences: 4,

read back from the engine rather than declared (GAME:QA/bench/char_0001_arrival_set_import_result.json).

Asset naming follows the SK_/SM_/T_/M_ convention throughout the import records.

• Creatures have authored rosters and two rigs. ANATOMY_REFERENCE.md names a bone roster with

parents per archetype — QUADRUPED lists root, pelvis, spine_lumbar, spine_thoracic, spine_cervical,

head, jaw, scapula_L, humerus_L, radioulna_L, carpus_L, metacarpus_L, digits_L, femur_L, tibia_L,

tarsus_L, metatarsus_L, toes_L, tail_00, with an identical _R sibling per side — and tooth T7 A1

refuses an out-of-roster bone. On disk: CR_0001 at 21 bones (BRANCHING_TREE), CR_0002 shipped at

12 bones and rebuilt at 38 (GAME:QA/bench/creature_rig_truth.json; build/3d/creature_rig/CR_0002_rig.json).

• Joint PLACEMENT is solved, not eyeballed. The rebuild places joints at

equal intervals of ds * (1 + k * local_turn_deg) with k solved by bisection against the law's own

25° per-joint cap, taking max_turn_at_equal_arc_deg 28.257 down to exactly 25.0 with

joints_over_cap: 0 — and it records the cost of the weighting (uneven bone lengths) rather than

hiding it. This is the A.R.T. joint-mover step done arithmetically.

VERDICT: MATCH for the human, PARTIAL for creatures. The template concept is present and enforced;

what is absent is the retarget layer. There is no IK Rig / IK Retargeter asset in the creature chain,

which is the reason the generated-motion lane is stalled at the format boundary (stage 11).

3.9 ROM specification and the calisthenics pass — THE LAW'S TARGET

AAA. This stage exists in two distinct places, and both are documented.

(a) The mocap ROM take. Every capture shoot opens with it. It is subject CALIBRATION, not content:

each actor performs a full range of motion of all joints so marker positions map correctly to joint

locations, and the solve quality depends on the performer moving **every joint through its entire

range**

(https://vicon-help.atlassian.net/wiki/spaces/Nexus216/pages/11608932/Choose+the+appropriate+subject+calibration+workflow).

The procedure is published and ordered — A-pose for initial calibration, T-pose bookends, then head

(look L/R, up/down, tilt, thrust), arms (overhead palms-down, palms-up, wrist/elbow/shoulder

rotations, reach front and back), torso (twist, bend, hip circles both directions), legs (lift and

circle, kicks, ankle rotations, deep squat, lunge), fingers (bend, fist, wiggle, thumb-to-each-finger,

spread) — with the instruction to expand the ROM for extreme activities, because the ROM must span

what the shoot will demand (https://mocappys.com/how-to-mocap-a-performer-using-a-vicon-system/,

https://mocap.csit.carleton.ca/index.php?Section=ViconBlade&Item=StepByStep&Page=RangeOfMotion).

The deliverable is a labelled ROM take and a solved subject skeleton; the gate is the mocap

supervisor's acceptance, and a bad ROM is re-shot before the day proceeds.

(b) The rig-side ROM / calisthenics clip. The same idea reused as rig validation: a canned clip

driving every joint through its authored limits so skinning failures surface deterministically. Trade

documentation of the practice names a full 360° rotation test on each major joint to verify IK

constraints do not clip the range unexpectedly, plus skinning validation at elbow, knee, shoulder and

wrist "to confirm skin weights produce clean deformation at extreme poses", with **thigh/pelvis and

shoulder/neck called out as the volume-loss hotspots**

(https://game-developers.org/character-rigging-explained-the-complete-guide-to-skeletons-skinning-ik-fk-game-ready-rigs).

The prescribed suite is extreme-range pose tests, cycle tests, and performance tests; the final

pre-handoff step is a deformation test in extreme poses (deep squat, overhead reach, tight fist)

looking for pinching, collapsing mesh and floating geometry; and retargeted animation must be previewed

on the game mesh, not the skeleton, because interpenetration and spine compression are invisible in

skeleton preview (https://mocaponline.com/blogs/mocap-news/character-rigging-game-dev-guide,

https://mocaponline.com/blogs/mocap-news/animation-retargeting-guide).

(c) Joint limits as authored data. Maya joints carry Joint Limit Information — min/max translate,

rotate and scale per axis, joint damping to decelerate into a limit rather than hard-stop, and degrees

of freedom governing which local axes IK may rotate

(https://help.autodesk.com/cloudhelp/2017/ENU/Maya/files/GUID-5A8BB621-96E0-4CE8-9792-085EC8F07164.htm).

Those limits are the natural source for generating the clip.

(d) The automated half. Public, inspectable rig/asset validators show the shape of the checks —

modelChecker, Inspector, assetQC, and a Maya Game Asset Validator built for game rig requirements

(https://github.com/JakobJK/modelChecker, https://github.com/david-cattermole/assetQC,

https://github.com/MaoBoulve/Maya-Game-Asset-Validator-Tool). And the one place the industry publishes

a NUMERIC ROM requirement is Epic's ML Deformer, whose training corpus IS a ROM corpus: **minimum

~3,000 training frames, ideally 7,500+**, poses must "cover sufficient range of motion for all required

deformations", and quality is judged by **heatmap error visualisation against the ground-truth geometry

cache** (https://dev.epicgames.com/documentation/en-us/unreal-engine/ml-deformer-framework-in-unreal-engine).

• Deliverable: a versioned ROM clip per skeleton + its measured result.
• Gate: the ROM playblast is reviewed by the tech-anim lead; the rig is not published until it

passes. The quantitative skin-collapse and interpenetration METRICS are near-universally practised

and essentially undocumented publicly — this is the thinnest part of the AAA record.

[INDUSTRY-GENERAL for the metrics.]

OURS. The spec half exists and is unusually strong. The exercise half does not exist at all.

What exists:

• Per-joint ROM ranges are authored per archetype with sign conventions and citations, described in

3.3 above. This is the artifact a studio would call the joint-limit spec, and ours is cited.

• Bind-pose ROM is measured. build/3d/creature_rig/CR_0002_rig.json bind_pose_rom reads

per_joint_turn_deg_max 25.0, per_joint_turn_deg_mean 11.874, cumulative_curvature_deg 439.32,

joints_over_cap 0, and derives the minimum segment count from the curvature the bind pose requires

(segments_this_bind_pose_requires: 18).

• Deformation instruments exist and are already discriminating. Every authored clip records

edge_stretch_p99_max, min_self_clearance_body_radii, self_intersects, and a silhouette-change

fraction (build/3d/creature_rig/CR_0002_MOTION.json). The accepted seven-clip rebuild set runs

per-clip p99 edge stretch 1.0624 to 1.7804 (means 1.0307-1.7752) with self-clearance

5.06-5.19 body radii and

self_intersects: false throughout; the v1 rig's NO-GO reads 11.73 with the judge's note

*"the subject READS AS A BREATHING CINNAMON ROLL"*. The instrument distinguishes a good rig from a

bad one already.

• Tooth T7 A4 exists — and it is the INVERSE test. A4 asserts that *no sampled pose may exceed the

archetype's per-joint cap*. That catches a clip that over-bends. It cannot catch a rig that

cannot bend at all, or one whose skin destroys itself the moment it does.

What does not exist: anything that drives a joint through its declared range on purpose. A grep for

calisthen|range of motion|rom_pass|rom_test|joint_limit|full range across harness/, build/3d/,

docs/pipeline_review/ and the game repo's Tools/ and bench markdown returns zero hits naming

this practice — positive-controlled: the phrase "full range" does match four times, every one of them

unrelated amplitude or dynamic-range prose. There is no bone→joint binding map either: the archetype

tables name anatomical joints (glenohumeral, intervertebral, tarsocrural) and the rigs name bones

(spine_02), and nothing joins the two, which is why A4 measures deflection between consecutive

bone direction vectors rather than against a named joint's named axis.

VERDICT: MISSING. Section 5 is the implementable spec.

3.10 Skinning and corrective shapes

AAA. Linear skin weights first, under a per-vertex influence cap that is an engine contract

(historically 4 bones/vertex; UE's skeletal reduction exposes Max Bone Influence directly —

https://dev.epicgames.com/documentation/unreal-engine/skeletal-mesh-lods-in-unreal-engine). Artifacts

at shoulder, underarm, knee and groin are then fixed by pose-space deformation: sculpt a corrective

at the offending pose and let RBF interpolation activate it as the rig passes through pose space

(https://help.autodesk.com/cloudhelp/2022/ENU/Maya-CharacterAnimation/files/GUID-00699C13-8CA1-450C-937D-57C7B3DFD8C6-htm.html);

Unreal's runtime equivalent is the Pose Driver node

(https://docs.unrealengine.com/4.26/en-US/AnimatingObjects/SkeletalMeshAnimation/AnimPose/PoseDriverNode).

Delta Mush acts as a low-pass filter on deformation artifacts and is baked back to weights for export

(https://help.autodesk.com/cloudhelp/2023/ENU/Maya-CharacterAnimation/files/GUID-139B703C-28E7-4787-8FD4-C2991BD6C990.htm).

At the top end: Sony Santa Monica shipped a joint-based rig fitted to muscle curve-fibre structure with

volume preservation plus dynamic bones approximating muscle/fat/skin jiggle **explicitly to improve the

impact feel of combat** (Tenghao Wang, GDC 2023 —

https://80.lv/articles/joint-based-skin-deformation-in-god-of-war-ragnar-k-will-be-explained-at-gdc-2023);

ZivaRT trains on Ziva VFX simulation to reproduce non-linear deformation in-engine at predictable cost

(https://blog.unity.com/games/simulate-stylized-characters-with-ziva-vfx-and-machine-learning);

Epic's ML Deformer trains from a skeletal mesh + animation + Alembic geometry cache

(https://dev.epicgames.com/documentation/en-us/unreal-engine/ml-deformer-framework-in-unreal-engine).

Capcom's chain names ngSkinTools for skin-weight authoring and repair and Ziva VFX for

muscle/fat simulation, outputting the simulation result including skin and fat to the engine

(https://blogs.autodesk.com/media-and-entertainment/2026/04/23/the-production-infrastructure-behind-capcoms-monster-hunter-wilds/).

• Deliverable: weighted mesh inside the influence cap; corrective set + drivers, or a trained model.
• Gate: the ML Deformer's heatmap error against the ground-truth cache is the closest thing to a

numeric, automatable skinning gate in the public record. Otherwise: human review of the ROM playblast

beside the DCC ground truth.

OURS.

• Weights are bone-heat automatic, produced by harness/asset_factory/bl_limbless_rig.py.
• There is no declared skin-weight repair stage. PIPE_3D_2026-07-29.md §7.3 already names this

as *"THE GAP, the real one"* against ngSkinTools, with the reasoning that auto-generated weights on

non-humanoid anatomy are not shippable raw — *"even hand-built rigs need a dedicated weight-painting

tool."*

• There are no correctives, no PSD, no muscle simulation. The Ziva substitute is declared as "a

corrective-shape / secondary-motion pass declared per creature" and that pass is not built. §7.2 of

that dossier already states the honest delta: *"their skin slides over simulated muscle; ours will

not."*

• We DO have the influence cap (MaxBoneInfluences: 4, read back from the engine) and a real

deformation metric (edge stretch p99, above).

• And we have a routed, measured skinning DEFECT of exactly the class ngSkinTools exists for: the

CR_0002 bone-heat rig was bound in a tight coil, so touching turns of the body share bones —

p99 edge stretch 11.73 first pass, 2.82 after retune, worst single edge on the shipped idle 6.1179

(GAME:QA/creature_anim/CR_0002/frames/render_report.json; register row 56).

VERDICT: PARTIAL. A real metric, no repair tool, no corrective stage. Note the ordering trap: the

ML Deformer route — the one AAA skinning technique with a published numeric gate — needs 3,000+ ROM

frames as its training corpus, which means **stage 9 is the prerequisite for the strongest available

fix to stage 10.** One ROM asset per skeleton would serve as rig gate, skinning gate, deformer training

set and regression fixture at once.

3.11 Animation production

AAA. Capture → solve against the ROM-derived subject skeleton → cleanup → retarget → hand-key

polish. Mocap is treated as MATERIAL, not delivery: Capcom's finished animation often differs

substantially from the capture while retaining its detail

(https://news.capcomusa.com/2023/04/07/animating-the-monsters-of-sunbreak/, recorded at

PIPE_ANIMATION_2026-07-29.md §7.1, which also carries the five-step per-monster cadence and its

finding that VFX must be in the loop BEFORE final polish). Runtime is either an authored state graph or

motion matching — Clavet's GDC 2016 formulation is "every frame, look at all mocap and jump at the

best place", matching a small pose feature set plus a trajectory predicted by running the gameplay

simulation forward, scored by a cost function, with transitions emergent rather than authored

(https://www.gdcvault.com/play/1023280/Motion-Matching-and-The-Road). Naughty Dog shipped it on

*TLOU2* for locomotion, traversal, melee and cover

(https://www.gdcvault.com/play/1027118/Motion-Matching-in-The-Last); Ubisoft La Forge's Learned Motion

Matching attacked its linear memory scaling (SIGGRAPH 2020); Epic productionised it in UE 5.4+ as the

Pose Search plugin with schema channels, databases, a Motion Matching node and Chooser tables

(https://dev.epicgames.com/documentation/en-us/unreal-engine/motion-matching-in-unreal-engine).

• Deliverable: cleaned, retargeted clips plus the database or graph, with notify tracks.
• Gate: Epic ships the inspection tooling — Pose Search Debugger (see and edit which pose was

selected and why) and Rewind Debugger

(https://dev.epicgames.com/documentation/en-us/unreal-engine/motion-matching-debugging-in-unreal-engine).

Human: animation director review on the game mesh, in game, at gameplay camera.

OURS. This is the least-built stage in the project, and every part of the gap is measured.

• One procedural solver, no capture. limbless_solver.py authored the CR_0002 clip set — eight clips shipped on the v1 rig, seven re-authored on the 38-bone rebuild with the eighth (a tail strike) correctly WITHHELD because the solver gates strikes on the head end and has no tail-side term — with each

clip's numbers derived from cited literature and canon rather than taste: the wave parameters cite

JAYNE1986 and GRAY1946, the amplitude is rescaled by amp_scale 0.63158 because per-joint angles

accumulate along a serial chain, cruise frequency is derived

(frequency_hz = cruise_speed / (body_length / wave_cycles)) and the strike windows are **the

shipped canon phase windows verbatim** — *"the animation is retimed to the canon row, never the row

to the animation."*

• Zero mocap. *"There is no authored hit-reaction mocap in this project"* — verbatim,

GAME:TODO_CANON.md. The three-tier reaction roster is Epic LANDING clips repurposed.

• The generated-motion lane is licence-cleared, budgeted and completely unexercised. The one

format-chain link the contract specifies — NPZ → BVH → Blender headless FBX bake → UE import → IK

Retargeter — does not exist (Tools/npz_to_bvh.py is unwritten; register row 33).

• Motion matching: tested as a controlled variable and it lost. Epic's motion-matched library wired

in as ONE variable made the whole-run foot-slide number worse, 0.5650 → 0.6726. That is a real

result about our instrument, not about motion matching — two independently authored AAA sets both

floor at 0.32-0.36 at walk on their own paces, which is why the register rules the band a STATISTIC

problem rather than a content problem (register §4).

• There is no animation ASSET CLASS in the schema, re-derived at HEAD by this lane. Across all

registries, 0 of 1,776 columns match anim|montage|mocap|keyframe|lip|viseme|facial|shot|camera|perform

— and that pattern is deliberately UNBOUNDED, so it would also have matched clip or multiplier

and still returns zero. Positive control: mesh|generation matches 90 columns in the same sweep.

(Register row 3 recorded 0 of 1,415 against a 65-column control on 2026-07-29; the schema has grown

by 361 columns since and not one of them is animation. GAP-199 / GAP-200 remain open.)

• Twelve authored clips have never been bound by anything. Both creature records read

binder_resolves = STATIC and skeletal_visible_at_runtime = false; 8 AnimSequences and 4

AnimMontages exist with windows read back off the saved asset and nothing plays them. The C++ patch

is pre-written verbatim with its own verification checklist (GAME:QA/bench/CREATURE_ANIM_CXX_GAP.md;

register row 1, the highest-ratio row on the whole register).

• There is no craft doctrine to author against. T1_Combat_System_Spec contains "animation" ×0 and

"VFX" ×0 against a "parry" ×14 positive control (register row 53, GAP-204).

VERDICT: MISSING as a production pipeline; PARTIAL as a procedural vocabulary. The vocabulary half

is genuinely good — derived, cited, canon-retimed, self-measuring — and it covers 13 of 187 creature

rows (6.95%; GAME:QA/bench/creature_archetype_census.json coverage).

3.12 VFX and world impact

AAA. Niagara authoring with a baked SOURCE-ASSET library underneath it — FF7 Remake's spectacle

came from Houdini-produced sprite sheets and Vertex Animation Textures, 8×8 sheets carrying emissive,

opacity, normal and occlusion, plus procedural volume textures, with effects tuned to sit INSIDE the

PBR shading rather than float on top (https://cgworld.jp/feature/202012-ffvll-03.html, already recorded

at PIPE_ART_2026-07-29.md §7.2). FF7 Rebirth then consolidated via Niagara user parameters so one

base effect covers minor variations (https://cgworld.jp/article/202408-ff7reb-04.html) — with the scope

correction our own dossier already made: the documented consolidation is on the ambient tier, not hero

battle magic.

The VFX↔gameplay contract has a named engine mechanism: Gameplay Cues in GAS — tag-addressed

cosmetic events with a target, a type (OnActive / WhileActive / OnExecute / OnRemoved) and

parameters including instigator and hit location, fired by abilities and effects, and **unreliably

replicated and therefore cosmetic only** — the gameplay result never depends on the VFX

(https://dev.epicgames.com/documentation/en-us/unreal-engine/gameplay-effects-for-the-gameplay-ability-system-in-unreal-engine).

Frame-accurate hookups (impact decal, hit reaction, sound) ride Anim Notifies. Epic ships 50+ reference

Niagara systems including explosions, bullet impacts and hit dissolves in UE 5.7

(https://www.unrealengine.com/news/discover-over-50-free-niagara-systems-ready-to-use-in-unreal-engine-5-7).

• Deliverable: a Niagara system + its cue/notify wiring + its decal and impact set, budgeted.
• Gate: cost per system against a ms budget, plus a readability pass at gameplay camera distance;

persistence caps enforced by pooling. **[INDUSTRY-GENERAL — the public record on VFX cost gates is

thinner than for any other stage.]**

OURS. The data half is ahead of the baseline and the delivery half is at zero.

• The authored data is complete and verified at HEAD this sitting:

registries/T0_Ability_Tree_Registry [ACTIVE v0.1]/Sheet1.csv carries **185 of 185 rows populated on

cast_visual_form, somatic_form AND aftermath_state**, alongside signature_read,

cast_pattern and per-ability SFX id arrays. A studio hand-authors the aftermath of each effect

inside the effect; ours is a table that exists before any effect does.

• The runtime realizes none of it. Josh named it directly — *"there are no impacts to environment

or anything"* — and the ruling records it as a named gap between authored canon and the runtime.

• The budget doctrine exists and is not armed. docs/ENGINE_OPTIMIZATION_DOCTRINE.md §5.4 sets

D1 (1.10 ms translucency + Niagara at 60 fps), D3 cutout textures, D4 material instruction ceiling,

D5 scalability entries, D8 motion vectors, D9 Niagara-only, and **D10 — the mastery-tier variant must

remain visually distinguishable from tier 1 at minimum spec; only its cost scales**. D2 is explicitly

marked *"UNVERIFIED — NOT A GATE"* rather than being smuggled in as one, which is the right

discipline and also an admission of how much of §5.4 is declared rather than measured.

• The authoring surface is blocked from automation. 5 of the 9 shipped element-contract parameters

(ScaleCm, Beat, Tier, Silhouette, Motion) are C++-only because Niagara module inputs are neither

writable nor readable from UE 5.8's Python (GAME:QA/bench/d127_niagara_link_witness.json;

register row 54).

• And the generation architecture was condemned and halted. The D1-27 strips were generated with

independent per-tile text prompts — 96 rows × 4 candidates — with no identity anchor and no exemplar.

The judge's own defect census names the mechanism: a family's silhouette primitive is a vocabulary

written for a human critic ("rope, sheet and bead"), and dispatched into an image model as bare nouns

every one renders as the physical object it names — *"Air 'fan' renders a physical hand fan on 24 of

24 Air candidates"* (harness/ability_vfx/avx_judge.json defect_classes.J1_PRIMITIVE_NOUN_LITERALIZED).

The exemplar-first motion law now bans per-tile independent prompts on multi-frame surfaces.

VERDICT: MISSING at delivery, EXCEEDS in data. The honest count of acceptable ability visuals is 0.

3.13 Lookdev

AAA. Assets are approved under a canonical lighting environment — a neutral studio HDRI at

fixed exposure with a standard key:fill ratio — so that the material is judged and not the lighting

(https://cglounge.studio/journal/calibrated-lighting-for-lookdev). The turntable carries calibration

geometry in frame: an 18% grey ball (light direction, intensity, shadow), a chrome ball (light

positions, camera, set) and a Macbeth/ColorChecker chart (24 patches of known value) used to

white-balance and expose consistently; a mismatched Macbeth means the colour pipeline is broken

(https://caveacademy.com/wiki/onset-production/data-acquisition/data-acquisition-training/the-grey-the-chrome-and-the-macbeth-chart/).

Review happens under several environments — neutral studio, sunlit exterior, overcast, night interior —

because a material that only works under one is not finished.

• Deliverable: turntable renders under N standard environments with the calibration objects in frame.
• Gate: art-director sign-off on the turntable; reviews arriving without a grey ball are reportedly

returned before the asset is looked at (https://cglounge.studio/journal/calibrated-lighting-for-lookdev).

OURS.

• Turntables exist. The character staging manifest records a full eight-view turntable at

preview_final, and deliberately circulates only the front hemisphere for a child figure — a care

decision recorded in the record itself (CHAR_0001_STAGING_IMPORT_MANIFEST.json evidence_frames).

• The A/B discipline is stricter than the norm and was won by being wrong first. The

Hunyuan3D-vs-TripoSG bench's first read said the opposite of its final verdict because it compared

one lane's cavity-shaded clay render against another lane's flat turnaround; the correction is now

law in the dossier — *"an A/B is only an A/B when BOTH arms are re-rendered by the instrument doing

the comparing"* (PIPE_CHARACTER_MODELS_2026-08-06.md §2.1). The head-to-head that produced the face

route pivot ran at identical camera, lights, views and samples.

• What is missing is the STANDARD. There is no declared neutral-HDRI set, no grey/chrome/Macbeth

convention, no per-asset lookdev sheet, and no multi-environment requirement. The consequence is

already measured twice: the pivot head's plate lighting is baked into basecolor and does not respond

to a light change (APP-C5), and the world lane's creature rim light was measured **arithmetically

dead** — 45 cd at 232 cm is 8.36 lux against a 128,000 lux key, 0.0065% of key and 36× weaker than

the map's own "trace" fill (register row 26). A calibrated rig makes both of those visible before a

capture, not after.

VERDICT: PARTIAL. Turntables and matched-instrument A/B: MATCH. Calibrated environment and

calibration geometry: MISSING.

3.14 LOD chains

AAA. Unreal's skeletal reduction exposes a termination criterion, Max Bone Influence per LOD,

volumetric correction, and Bones to Prioritize with a weight so geometry skinned to key bones

resists reduction — the silhouette-preservation lever

(https://dev.epicgames.com/documentation/unreal-engine/skeletal-mesh-lods-in-unreal-engine).

Skeleton LOD is separate and manual: Bones to Remove per LOD drops face, tongue, finger and toe

bones at distance. Switching is by screen size, not distance. MetaHuman is the reference chain —

8 LODs (0-7) with topological density AND joint count descending, driven by DNA that encodes

geometry, skeleton and skin weights separately per LOD, with a hard runtime constraint that the DNA

LOD count and the face mesh LOD count match one to one

(https://dev.epicgames.com/documentation/metahuman/controlling-metahuman-levels-of-detail-lods-in-unreal-engine).

At scale it is automated: Simplygon offers an SDK plus distributed batch via Agent and Grid, Quad

Reducer (topology-preserving and animation-safe) and Modular Seams so optimised modular parts do not

gap (https://www.simplygon.com/features/distributedbatchprocessing) — and Capcom's chain names

Simplygon for exactly this role.

• Deliverable: the LOD chain + LODSettings + per-LOD bone-removal list + screen-size thresholds.
• Gate: tri/vert/bone counts per LOD asserted against the budget in CI, a silhouette diff at each

threshold, and a pop test walking the camera through the thresholds.

OURS.

• Chains ship and are read back from the engine. The arrival garment carries 4 LODs at

85,358 / 44,565 / 24,270 / 13,686 verts, imported through SkeletalMeshEditorSubsystem and verified

in-engine (GAME:QA/bench/char_0001_arrival_set_import_result.json). The face chain lands

119,994 / 59,996 / 29,998 / 11,998 with the ear retained at 99.20% — and the retention number is the

silhouette-preservation instrument, arrived at independently of Epic's Bones-to-Prioritize.

• The budgets are declared. T1_Build_Pipeline_Contracts §1.7 sets per-class, per-spec-class

numbers (Creatures 24k/60k/120k LOD0, chain 4/4/3/2-3; Familiars 18k/45k/90k; material-slot caps

4/6/8), every number self-tagged ILLUSTRATIVE-until-5090-benchmark. ENGINE_OPTIMIZATION_DOCTRINE

§5.3 restates them as C1 and C2 and marks both GATE-TIER.

• No gate reads them. No check in harness/ or the game repo reads a triangle budget; the LOD

tooth checks orphan_vertices == 0 and bounding-box drift only (register row 40). The consequences

are already on disk: the arrival chest ships **134,136 triangles at LOD0 — 5.59× the

steam_deck_minimum floor and 6.34× its own 21,154-triangle base body** — and the debt exists only

in a commit message (register rows 22 and 57). Per-LOD absorption in engine reads UNMEASURED

because UE 5.8's Python exposes no lod_info on SkeletalMesh (register row 37).

• Skeleton LODs: absent. Nothing removes bones per LOD on any asset.
• Material slots: 4 per garment piece with exactly ONE used, sitting on the

steam_deck_minimum cap of 4 with three dead entries (register row 29).

VERDICT: PARTIAL. The chain and the silhouette instrument are real; the budget layer is declared

canon that nothing enforces, which is the exact failure mode this repo mints gates against.

3.15 Engine-integration QA

AAA. Unreal's Data Validation plugin runs rules as IsDataValid overrides or

UEditorValidatorBase subclasses, in the editor, in the Content Browser, on asset save by default,

and headless via -run=DataValidation; changelist-level validation is used as a submit gate

(https://dev.epicgames.com/documentation/unreal-engine/data-validation-in-unreal-engine). Automated

visual regression rides the Automation Test Framework's Functional Screenshot Test against an

approved ground-truth image with per-channel colour tolerance, Maximum Local Error and **Maximum

Global Error**, results shown as ground truth / difference map / incoming in Session Frontend, with a

first run warning until a human approves the baseline

(https://dev.epicgames.com/documentation/en-us/unreal-engine/screenshot-comparison-tool-in-unreal-engine);

Gauntlet drives the suite in the editor and in a packaged client

(https://dev.epicgames.com/documentation/unreal-engine/running-gauntlet-tests-in-unreal-engine).

Performance is enforced, not merely measured: the Animation Budget Allocator sets a fixed

per-platform game-thread budget in milliseconds and throttles skeletal component tick rates,

degrading between Hi / Lo / Interpolating fidelity to stay inside it

(https://dev.epicgames.com/documentation/unreal-engine/animation-budget-allocator-in-unreal-engine).

• Deliverable: the asset, in the engine, passing validation.
• Gate: validation on save and on changelist. A failing asset does not submit.

OURS.

• Read-back verification is real and is the strongest single correspondence in this dossier. Every

import emits a record measured FROM the engine, not declared: metadata stamped and read back

(Humanity.CanonId, Humanity.PieceId, Humanity.EquipSlot, and a Humanity.Source naming the

manifest and its hash), texture settings compared want vs observed_on_disk (sRGB, compression),

material_assigned, material_used_with_skeletal_mesh, skeleton_used, lod_count,

bind_height_cm, sits_on_floor_cm, material_slot_count

(GAME:QA/bench/char_0001_arrival_set_import_result.json). That is a screenshot-comparison-grade

discipline applied to asset METADATA.

• A mesh battery exists with real thresholds, re-measured rather than trusted:

build/3d/verify_all.json records 254 checked / 254 clean across seven teeth (id, media presence,

registry join, battery re-measurement, licence pairing, care-gating, withdrawn-never-importable)

with thresholds watertight, manifold, max_bodies 8, max_deviation_pct 3.0,

uv_in_unit_square, min_uv_utilization 0.18, min_tris 1200, max_tris 60000, normal_baked,

ao_mean_range [0.05, 0.98] — plus a vacuity control (254 candidate records resolved), which

is a discipline the studio validators do not publish.

• What is missing is the BLOCK. Nothing runs on save. Nothing runs on commit in the game repo.

There is no screenshot-diff regression suite with an approved baseline. There is no ms budget that

throttles anything, and the one Epic mechanism that would — the Animation Budget Allocator — is

declared as rule C3 in ENGINE_OPTIMIZATION_DOCTRINE §5.3 with "component-type audit" as its check,

and is not wired. The performance picture we do have says the tail is not where a budget would look:

FrameTime p99 61.486 ms against GPUTime p99 13.282 ms inside a 16.67 ms budget, with

GameThreadTime p99 23.73 ms and a 5,297 ms worst sample over 9,038 samples (register row 45).

VERDICT: MATCH on presence and metadata, MISSING on blocking. Our verification is arguably richer

per asset than a studio's IsDataValid; it simply runs when a lane chooses to run it, and a check that

is not in the runner is not armed — the gates config's own note for gates 55-57 states exactly that

rule, and the music lane already has a row against it (register row 27).

---

4. THE EXCEED COLUMN — where the AI pipelines genuinely beat the AAA baseline

Six claims, argued concretely, each with its own counter-argument named. Followed by the places we do

NOT exceed, which is the longer list and the honest half of this section.

4.1 EXCEEDS — registry-driven per-ability aftermath, authored before any effect exists

At a studio, what an ability leaves behind in the world is authored INSIDE the effect, by the VFX

artist who makes it, one effect at a time; the design intent lives in a spec document and a design

lead's head. Ours is a table: **185 of 185 ability rows carry cast_visual_form, somatic_form AND

aftermath_state**, verified at HEAD, alongside signature_read and per-ability aftermath SFX id

arrays. The consequence is structural rather than cosmetic — the aftermath of every ability in the game

is queryable, diffable, gate-checkable and consistent by construction before a single Niagara system

exists, and a designer changing the elemental grammar changes 185 effects by editing a column.

The counter-argument, and it is currently winning: authored data that no runtime realizes is worth

zero to a player, and ours realizes none of it. This is an exceed in POTENTIAL that becomes an exceed

in FACT only when the engine ability wave lands. Until then it belongs in this column with that caveat

attached, not without it.

4.2 EXCEEDS — measured QA where the industry eyeballs

The AAA record is thin on quantitative asset metrics for a reason: most of it is a lead looking at a

turntable. Our records carry numbers where a studio carries a signature:

• surface OBSERVATION as a fraction (observed_fraction 0.80715), with holes counted and pushed rather

than invented, against a measured programme range;

• garment fit as a signed-distance distribution (1.324% penetrating, p01 -0.337 mm, deep tail 0),

not "it doesn't poke through";

• skinning quality as p99 edge stretch per clip, with a NO-GO at 11.73 and an accepted band at

1.03-1.78;

• self-intersection as minimum clearance in body radii with a stated interpretation ("below 2.0 the

surfaces touch; below 1.0 the body is passing through itself");

• facial landmark placement to eye_line_placement_error_mm 0.0 against a canon eye line;
• texel density in mm/texel with a refusal floor.

And two disciplines above the industry norm: positive controls on every zero (a search that cannot

match reads exactly like a corpus with nothing in it, so every "0 found" is controlled), and **declared

backlogs instead of clean bills of health** — anatomy_conformance_baseline.json states in its own

header that a waiver matching nothing measured ALSO fails, so the list can only shrink.

The counter-argument, already proven true once: a measurement can be exactly right about the wrong

subject. Two of our instruments were lying this week — the foot-slide mean and a far-field probe pinned

to a station that moved 3.65 km horizontally and 802 m down under an unchanged id — and the automated

face judge scored a stylized medium as FF7R. Measurement exceeds eyeballing only where the instrument's

SUBJECT is asserted; where it is not, it produces confident nonsense faster than an eye can.

4.3 EXCEEDS — deterministic regeneration from records

A studio versions binaries: the FBX in Perforce is the asset, and reproducing it from its inputs is

usually impossible. Our records invert that. CR_0002_MOTION.json states it outright — *"the RECORD is

tracked and the bytes are not — the FBX/GLB and the rendered frames stay on the assetgen staging root

and regenerate from the tools; this json is the join and it diffs."* Every generation stage pins its

constants (TripoSG seed 42 / 50 steps / guidance 7.0 / 250k faces / octree 9; Z-Image-Turbo at

8 steps / cfg 1.0 / res_multistep / shift 3.0 / zeroed negative). The consequences are real: an asset

diff is a semantic diff, storage is bounded, and a route change can be re-run across a whole class.

The counter-argument: determinism holds only as far as the pinned constants reach, and the

multi-view texture stage's own record notes nvdiffrast_imported: false on the face — an environment

difference that a seed does not capture. The claim is honest as "reproducible from a recorded recipe on

this box", not as "bit-identical anywhere".

4.4 EXCEEDS — anatomy as machine-checkable specification

Capcom designs fictional creatures against real animal anatomy references. We do the same thing and

then make it arithmetic: eight archetype tables where every joint carries a cited degree range, a sign

convention and a stated basis, with the ranges refusing to be invented — 42 of 187 rows are marked

NEEDS_CANON_BODY_PLAN and the reference table says outright that guessing one would be inventing

creature canon. Tooth T7 then asserts roster, segment count, required bones and centreline against it,

with a fixture proving it fires. A studio's equivalent lives in a lead rigger's judgement and does not

survive that rigger leaving.

The counter-argument: a specification nothing exercises is a document, and section 3.9 is exactly

that finding. This exceeds today only as an INPUT; section 5 is what turns it into a gate.

4.5 EXCEEDS — persona and canon density at volume

167 cast rows and 187 creature rows carry authored persona, physical and behavioural fields; a studio

authors that depth for its named cast and gives the rest a job title. Our density is real and it is

already producing gate-checkable structure (the 13-field persona, the no-dead-end gate, the

significance lenses).

A second, sharper form of the same claim: the brief itself. Guerrilla's whole outsourcing model

rests on the concept package being complete enough to build from without a conversation, and the GDC

talk is about the labour of writing those briefs. Ours is not a document that has to be written — it is

a canon row plus a rubric plus a router, resolvable live

(python harness/route.py <work-kind> --chapter CH_NN --region <region>), and a lane that produces

something must declare which canon lines it realized. A studio's brief is prose that a vendor might

misread; ours is queryable, diffable and gate-checkable, and the gate that reads it

(canon_derivation) refuses an undeclared id. **That is a genuine exceed and it is the one that

scales**, because brief-writing is the labour Guerrilla's model spends its concept team on.

The counter-argument, and it is severe: 1 of 167 cast rows has been through the appeal rubric, and

the register's own row 44 warns that parameterizing the CHAR_0001-shaped scripts across the cast

must follow the wrap cage or it bakes the correspondence gap into 167 assets. Depth in the table is

not depth on the screen.

4.6 DOES NOT EXCEED — the 24/7 factory cadence, which is a MATCH

Nightly automation is not an AI-pipeline advantage: Capcom already runs nightly mayapy automation for

texture baking, LOD creation and asset commits, and our own dossier adopted it verbatim precisely

because it is theirs (PIPE_3D_2026-07-29.md §7.5). Our box is live 24/7 and compute-clean, and the

honest read is MATCH-once-built, not exceed. It is listed here because it is the claim most likely to

be overstated in a status report.

4.7 Where we do NOT exceed — stated plainly

• The hero face. Zero acceptable plates across three generations. Nothing in this dossier changes

that count.

• Exemplar-conditioned identity at scale. This is the headline candidate for an AI-pipeline exceed

and it is NOT PROVEN. The architecture is now ruled (one judged exemplar, everything derived from

it) precisely because the previous architecture failed. A ruling is not a result.

• Sculpt craft and retopology. No sculptor, no cage. Section 3.4.
• Muscle, fat and skin sliding over them. PIPE_3D §7.2's own words: their skin slides over

simulated muscle; ours will not.

• Groom. One asset has cards; 73 creature rows have nothing — against a teacher that spends half a

hero's polygon budget on hair.

• Mocap performance and hand-key polish. Zero of both. The comparator's own lesson is that capture

is MATERIAL and the craft is what happens after it — we have neither the material nor the craft pass.

• Cloth in motion. Fit by construction is a real win on fit and a total loss on secondary motion.
• Animation craft vocabulary. "animation" ×0 in the combat spec.
• Throughput as a quality claim. Machine seconds per asset are 81.3 (103.1 with one re-plate), and

the bottleneck is not machine time — it is judged exemplars and human grading, which do not

parallelize. Throughput is not on this list for a reason.

---

5. THE ROM / CALISTHENICS SPEC — the JOINT-ROM CORRECTNESS LAW made implementable

The law, verbatim: *"Every joint motion range of movement etc needs to be correct."* Its recorded

strengthening: every rigged entity carries a per-joint ROM spec derived from its real anatomy (or its

coherent-supernatural design), and a deterministic CALISTHENICS PASS drives every joint through its

full declared range and measures the result before any clip binds.

This section specifies that pass. It does not implement it. Implementation is the next

creature/character rig wave's work.

5.1 Artifact one — the ROM SPEC, per rigged entity

Name: build/3d/rom/<ENTITY_ID>_ROM_SPEC.json, emitted by a script, never typed.

Why it must exist as its own artifact rather than being read from the archetype table directly.

The archetype tables name ANATOMICAL joints (glenohumeral, intervertebral, tarsocrural); the rigs

name BONES (spine_02, femur_L). Nothing joins them today, which is why tooth T7's A4 measures

deflection between consecutive bone direction vectors — convention-free, and therefore also

joint-blind. The bone→joint binding is the missing artifact, and it is the whole reason the ROM

spec cannot be a lookup.

Shape (fields, not magnitudes — the magnitudes come from the source and are never authored here):

• entity_id, archetype, sub_plan, rig_source (the FBX/GLB the bones were read from),

spec_source (the archetype JSON path and its schema version), emitted_utc.

• joints[], one entry per DRIVEN joint:
• joint — the anatomical name, verbatim from the archetype table.
• bone / parent_bone — the rig bones this joint is realized by, read from the rig.
• type — hinge / ball-and-socket / condylar / amphiarthrosis / synsarcosis, verbatim.
• angle_convention — goniometric_angle_between_segments or excursion_about_neutral, verbatim.

This field is load-bearing: veterinary goniometry measures the angle between segments while

gait kinematics measure excursion about neutral, and a pass that mixes them produces false fails.

• axes — {axis_name: [min_deg, max_deg]}, verbatim from the source.
• forbidden_axes[] — axes this joint class does NOT have. A hinge that rotates axially is a

counter-anatomical fail even at 1°, and this is the field that makes that detectable.

• couplings[] — the mechanical linkages the reference already names: the horse stifle↔hock

reciprocal apparatus, the bird elbow↔wrist parallel linkage (one DOF shared between two joints),

the snake zygosphene's block on axial rotation, the quadruped scapulothoracic sling.

Each carries kind (drives / blocks / shares_dof) and its partner joint.

• basis — measurement / morphology / UNMEASURED / canon, verbatim.
• cite[] — the source keys, verbatim.
• unbound_bones[] — every rig bone with NO joint entry, with a reason. **This list is the spec's own

vacuity control.** A spec that silently covers three bones of a 38-bone chain and reports PASS is the

failure mode; an unexplained unbound bone refuses the emit. The reasons are a closed set, and the

first of them is already needed: the UE5 Mannequin's root, ik_foot_root, ik_hand_root and

ik_hand_gun are non-deforming convention bones that exist as a contract for IK and attachment

code (https://forums.unrealengine.com/t/explanation-of-the-mannequin-ik-bones/45166). They have no

anatomy, must never be driven by a sweep, and must be declared rather than silently skipped.

• coverage — bones_total, bones_bound, joints_specified, axes_specified.

Sources, in strict order.

1. Real anatomy — build/3d/schema/anatomy_reference/<ARCHETYPE>.json, which already carries every

field above except bone, forbidden_axes and unbound_bones. Seven creature archetypes plus

HUMANOID. The protagonist and every human NPC bind to HUMANOID clinical goniometry, mapped onto the

UE5 Mannequin's 89 bones.

2. Canon sheets for supernaturals — the bestiary's section 10 physical_profile panel is the

declared home (1 of 29 sheets carries it today; register row 31 is the authoring gap). A

supernatural body plan takes its ranges from its own canon sheet with basis: canon, and the

citation is the sheet section.

3. Nothing else. The 42 NEEDS_CANON_BODY_PLAN rows emit no ROM spec at all and are counted as

BLOCKED, exactly as the anatomy reference already refuses to guess them. A guessed range would be

invented creature canon.

5.2 Artifact two — the CALISTHENICS PASS

Name: harness/asset_factory/rom_calisthenics.py, emitting

build/3d/rom/<ENTITY_ID>_CALISTHENICS.json.

Where it sits. Immediately after bind/skin, before any clip binds — between the rigger

(bl_limbless_rig.py and its future archetype siblings) and the motion solver

(bl_limbless_motion.py / limbless_solver.py). A rig that has not passed cannot be handed to a

solver, and the twelve currently-unbindable creature animation assets are the cautionary exhibit for what

"a bind that never exercised its joints" costs.

The drive schedule, lifted from the published Vicon ROM procedure and adapted from a performer to

a rig:

• Bookends. Bind pose → declared neutral pose → bind pose. Every sweep starts and ends at neutral,

so drift is detectable.

• Sweep A — one joint, one axis, at a time. For each joint, for each axis: neutral → min → neutral

→ max → neutral, at a fixed angular step. This is the isolating pass and it is where a

single-joint skinning failure is attributable.

• Sweep B — one joint, all axes together. The corner poses of the joint's axis box, which is where

ball-and-socket rigs fail that hinge sweeps miss (the shoulder at full abduction AND full axial

rotation is the classic).

• Sweep C — the coupled set. Every couplings[] entry driven as its mechanism requires — the

stifle driven with the hock following, the bird's elbow driving the wrist. A coupling that does not

hold is a rig defect, not an animation choice.

• Sweep D — the whole-body extremes. The archetype's own named hotspots, taken from the reference's

solver notes: for HUMANOID the deep squat, overhead reach and tight fist the industry names; for

QUADRUPED gallop-extreme spine flexion plus fetlock dorsiflexion under load; for LIMBLESS full

lateral undulation at the mid-body peak plus the vertical rear the canon sheet requires; for WINGED

full wing fold and full extension; for ARBOREAL_PRIMATE all four grasping end-effectors at closure.

• Frame budget is derived, not chosen: axes_specified × steps_per_axis × 4 for sweep A, plus the

corner and coupled sets. For a 38-bone limbless chain at 10 steps this is a few thousand frames —

the same order as ML Deformer's 3,000-frame minimum, which is not a coincidence and is the reuse

argument in 5.5.

What is measured, per frame and per joint. Six metrics, and the split between REFUSING and

REPORTING is deliberate.

Why four refuse and two report. M1-M4 are convention-free and need no population to be

interpretable: a joint outside its own declared range is wrong by arithmetic, a hinge that twisted is

wrong by morphology, a surface passing through itself is wrong at any threshold, and a face with

negative area is broken. M5 and M6 are continuous and their thresholds must be DERIVED from a

population that does not exist yet — the only calibration data on disk today is seven clips of one

archetype (per-clip p99 edge stretch 1.0624-1.7804 accepted, 11.73 on a NO-GO rig, 2.82 after a retune that is

still owed). Arming a hard band off that would be a gate built on an unverified number, which is the

one thing ENGINE_OPTIMIZATION_DOCTRINE's own reading rules forbid, and it is why texel_coverage was

built to report rather than reject. **The provisional bands are declared, printed every run, and

tightened when a second archetype lands**; the pass records bands_provisional: true on its own face

until then.

Provisional bands, declared with their derivation:

• M5 edge stretch p99 — PASS ≤ 1.80 (the accepted seven-clip maximum, 1.7804), WARN 1.80-2.50,

FAIL-CANDIDATE > 2.50 (below the 2.82 the retune left owed, well below the 11.73 NO-GO).

• M6 volume loss — WARN below 0.90 of bind volume, FAIL-CANDIDATE below 0.75, both marked

UNCALIBRATED until a population exists. The reference's own hotspot notes (thigh/pelvis,

shoulder/neck) name where these will first fire.

The output record.

{ entity_id, spec_ref, rig_source, emitted_utc,
  schedule: {sweeps_run, frames, steps_per_axis, frame_budget_derivation},
  per_joint: [ {joint, bone, axis, reached_min_deg, reached_max_deg,
                M1_over_range_frames, M2_forbidden_axis_max_deg,
                M3_min_clearance_body_radii, M3_self_intersects,
                M4_inverted_faces_max, M5_edge_stretch_p99, M6_volume_fraction_min,
                worst_frame, worst_frame_render} ],
  refusals: [...], reports: [...],
  coverage: {joints_specified, joints_exercised, axes_exercised, unexercised: [...]},
  vacuity_control: "<n> joints resolved from the spec and driven",
  bands_provisional: true,
  verdict: "PASS" | "REFUSE" }

joints_exercised versus joints_specified is the control that makes a green run meaningful: a pass

that drove 3 of 38 joints and found nothing must read as a failure of the pass, not a pass of the rig.

5.3 The gate and its ratchet

• A new tooth rom_calisthenics in harness/gates_config.json, reading every

build/3d/rom/*_CALISTHENICS.json against

build/3d/schema/rom_calisthenics_baseline.json — the same declared-backlog ratchet as

anatomy_conformance_baseline.json: a finding not in waived FAILS, **and a waiver matching nothing

measured also FAILS**, so the list can only shrink and it shrinks in the same commit as the fix.

• It must ship with a mutation fixture proving it fires — a rig deliberately bent past its cap, and a

hinge deliberately twisted — because a tooth without a mutation proof is not armed.

• Relationship to tooth T7 A4: they are complements and both stay. A4 asks *did any authored clip

exceed the cap?* The calisthenics pass asks *can every joint REACH its cap without destroying the

skin?* Neither implies the other, and the CR_0002 history contains one instance of each failure.

5.4 Scope, and what this pass does NOT claim

It measures ARTICULATION, not beauty. A rig can pass every metric here and still read as a floating

ribbon — the v1 CR_0002 judge read is the proof, and that judgement stays with the cold judge and with

Josh. It also does not measure whether a clip is good; it measures whether the rig a clip will be

authored on can hold the poses that clip will ask for.

5.5 The reuse argument — one artifact, four jobs

The ROM clip is not overhead. It is simultaneously (1) the rig gate specified here, (2) the skinning

gate of stage 10, (3) the training corpus for an ML Deformer should we ever take that route, since

Epic's own requirement is 3,000+ frames covering "sufficient range of motion for all required

deformations", and (4) a stable screenshot-regression fixture, because the same deterministic clip

re-rendered after any route change produces a diffable image set. That is why it is the highest-leverage

missing stage per unit of build cost in this whole dossier, and it is ENGINE-class under the reuse

directive — game two inherits it whole.

---

6. THE CORRESPONDENCE GAPS AS WAVE CANDIDATES

Ranked slice-first — the AAAAA-polished PROLOGUE→CH 13 slice, not the whole arc. **Every wave below is

BEYOND THE FLOOR of what Josh asked for and is NAMED here so it can be vetoed.** Where a gap is already

an AAAAA register row, this dossier does not re-charter it; it adds the correspondence argument and

points at the existing row.

Two ordering findings that outrank their own rank.

1. W-ROM before W-ARCH. Building the quadruped solver first and gating it later means retrofitting

the gate onto 79 rows instead of 13.

2. W-BUDGET before Q4. This is the register's own QG finding restated from the correspondence side:

the garment route's LOD0 is 5.59× its floor and Q4 as queued copies that route into every hood,

cloak and armour piece.

---

7. Provenance, and what this dossier could not check

Built from. Two fresh research lanes against the public AAA record (sources cited inline; claims

resting on general practice marked [INDUSTRY-GENERAL] and never used to ground a verdict), plus a cold

read of our own records at HEAD: AAAAA_IMPROVEMENT_REGISTER_2026-08-06.md, the PIPE dossiers for 3D,

animation, art and character models, build/3d/V2_ROUTING_RATIFIED.json, the CR_0002 rig/motion/marks/

elevation records, the CHAR_0001 character records, build/3d/schema/anatomy_reference/, the harness

gate roster and rubrics, and the game repo's bench records read READ-ONLY.

Re-derived at HEAD by this lane rather than carried on trust: remesh_used=false / out_quads=0 /

topology_route=tri_decimate in the face finish record; bind_pose_rom.joints_over_cap=0 and

per_joint_turn_deg_max=25.0 in the CR_0002 rig record; the seven-clip edge-stretch and self-clearance

band in the motion record; cast_visual_form / somatic_form / aftermath_state at 185/185 in the

ability registry; the ability-VFX judge's GO 1 / GO_WITH_FIXES 14 / NO_GO 81 over 384 plates; the

verify_all.json seven-tooth battery and its thresholds; the gallery's AAAAA-VERIFIED: 0 of 334; the

solver coverage at 13/187; the animation-column sweep at 0 of 1,776 with a 90-column positive

control; the arrival-set engine read-back (89 bones, 4 LODs, 134,136 triangles); and

the zero-hit calisthenics grep with its positive control.

Honest limits.

• No GDC Vault video was watched. Every conference claim comes from talk pages, published

transcripts, or written coverage, and is marked where it is second-hand. A director who wants a

number from one of these talks quoted inside a gate should watch the source first.

• The AAA record is thinnest exactly where we most need it — quantitative skin-collapse,

interpenetration and volume-loss thresholds, and VFX cost gates. Both are near-universally practised

and essentially undocumented publicly. That is why section 5's M5 and M6 report rather than refuse:

the honest position is that nobody publishes the number, so we must derive our own from our own

population. The other thin areas are the character blockout gate (no named studio talk formalises

one) and internal sign-off ceremony generally — studios publish their tools far more readily than

their approval protocols, so every "the AD signs it" line in this dossier is inference from practice

rather than a quoted process.

• **Several of our verdicts rest on the AAAAA register's measurements rather than on this lane's own

re-derivation.** Where that is so the register row is cited by number and the register's own

provenance section names what it spot-verified.

• The game repo was read READ-ONLY and nothing under build/ was touched. No engine state was

probed live; every engine-side number here is from a committed bench record.

• This dossier's artifact kind is not enrolled in docs/canon_derivation.json, so its derivation

declaration is the prose one in this section rather than a machine-readable coverage key.

Generated by harness/site/structure_site.py — the URL path is the repo path. review root