Skip to content

Rig Root 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:

bin\launch_usdview.bat docs\examples\two_bone_ik.usda

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 nameChildren on 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. Put Solvers at the bottom of the rig root for the classic "solve, then revise" shape.

See also


UsdRig