Rig Root¶
The prim that makes a namespace a rig: partition, discovery root, evaluation unit.
| Node type | RigExecRoot |
| Example | two_bone_ik.usda |
On this page:
Overview¶
Every rig is one RigExecRoot prim and everything composed
beneath it. The root declares no membership lists: a RigExecControl under it
is a control, a RigExecJoint is a joint output, a placed volume prim is a
weight field, and a prim carrying rigExec:moves anywhere beneath
the root is a mover. It is what a host activates — one rig, or every
RigExecRoot on the stage — and it is the unit that compiles, publishes a
generation, and carries the pose diagnostics. It is Imageable but deliberately
not Xformable, so guide bounds propagate up to the enclosing asset for camera
framing while the rig itself never adds a transform.
Character root: partition and namespace root for control, joint, and mover discovery. It is Imageable (but deliberately not Xformable) so bounds from guide-only controls and joints propagate through the rig root to the enclosing asset for host camera framing.
The rig declares no membership lists. Controls, joints, and movers are all discovered from the composed namespace beneath it: a RigExecControl is a control, a RigExecJoint is a joint output, and a prim carrying rigExec:moves is a mover. Operator wiring (a solver's ordered rigExec:joints and rigExec:controls) is the graph, and the rig is where that graph is rooted -- not a second place to restate it.
How it works¶
Nothing on the root evaluates per frame; it is read during the
evaluator's compile phase, in the discover-and-validate pass. Compile walks the
composed namespace beneath the root and collects controls, joints, pose
interpolators, placed volume weights, and aggregate solvers by prim type
anywhere under it, then walks the WHOLE RIG in reverse-sibling post-order —
descendants before their parent, and the bottom sibling branch in usdview
first — to number ONE pose stack of joint-writing solvers and frame
constraints, of which the mover order is a restriction; the walk uses the standard
UsdPrimRange predicate, so a deactivated or unloaded branch is simply not
part of the rig and changing that is a structural (rig-recompiling) edit
rather than a value edit. A rig that finds no controls, joints, volume weights,
and no movers at all is a compile error ("Rig publishes no outputs"), and every
mover target is checked against the root's parent prim, which is the rig
asset and the boundary of what the rig may write. The evaluator compiles one
production operation graph. Scene sampling, detached frozen jobs, and binary
playback execute typed declarations through that graph; reference checks are
optional judges and do not choose an evaluation path.
Wiring¶
| Relationship | Points to | Required |
|---|---|---|
| (namespace) | Everything composed beneath the root is the rig; controls, joints, solvers, and weight volumes are discovered by prim type. | - |
Movers child |
The conventional scope for movers: discovery is by rigExec:moves anywhere beneath the root; the scope only groups them in the walk order. |
no |
| (parent prim) | The rig root's parent is the asset: movers may only target prims under it, and geometry lives there too. | - |
Parameters¶
Node parameters¶
rigExec:partition¶
Type: uniform token. Default: "".
rigExec:asset¶
Type: uniform asset. Default: @@.
Baked-playback selector: when set, hosts that can play a .rigexec file (usdview through rigExecImaging) answer this rig from the binary instead of evaluating it, and when unset the rig evaluates live. The path resolves like any asset attribute -- relative to the layer that authors it -- and names a single .rigexec file with no sidecar.
Uniform because it is a decision about the whole rig -- which source answers it -- and not a channel an animator keys. Setting it can change how fast a frame arrives and not what the frame is: the binary preserves the compiled scene program's published-value contract, and a host that cannot open the file it names evaluates live and says so, rather than rendering a rig it did not evaluate.
Example¶
Every shipped example is one of these: two_bone_ik.usda puts a
RigExecRoot named Rig inside the IkAsset Xform, with Controls,
Solvers, Joints, Weights, and Movers scopes beneath it and the deformed
cards in a sibling Geom scope. The scope names are all convention — the
compiler discovers by prim type — and the geometry sits
under IkAsset because that parent is what bounds the rig's write set.
Open it live with:
Tips¶
- Keep the deformed geometry inside the same asset prim as the rig: compile sets aside a mover whose target is outside the rig root's parent, with "targets outside the rig asset", and that mover writes nothing.
- Order two movers that write the same target — or a solver against a constraint, or two solvers against each other, which are all steps of ONE pose stack — by arranging them in namespace: nesting, or
reorder nameChildrenon their parent. The bottom composed sibling executes first, the compiler reads the final composed order and nothing about how it arose, and nothing else breaks a tie. PutSolversat the bottom of the rig root for the classic "solve, then revise" shape.