FK Chain¶
Composes per-control local animation down a joint hierarchy.
| Node type | RigExecFkChain |
| Example | fk_chain.usda |
On this page:
Overview¶

Forward kinematics in its simplest form: one control per joint, each
authoring a local rotation (or translation), composed down the chain so
every joint inherits its ancestors' motion. Use it for tails, spines,
fingers — anywhere the animator wants direct control of every link. The
controls are normally nested one under the next so each handle rides the
one above it, which is what rigExec:controlSpace = "parentRelative"
declares.
Applies control frames/offsets to a rest hierarchy. Publishes aggregate computePointFrameArray; addressable joint providers publish scalar frames.
How it works¶
The solver runs in the pose phase: it reads each targeted control's
computePointFrame and computeRestFrame, forms that control's
rest-to-pose delta, and publishes one aggregate computePointFrameArray
whose element N is written to rigExec:joints[N] — the two lists are
parallel, so control N poses joint N and joint N inherits the composed
frames above it. rigExec:controlSpace decides how the deltas compose:
world chains them (W_i = W_(i-1) . A_i) for sibling controls, while
parentRelative takes each delta as-is because a nested control's frame
already travels with its parent. The chain MEASURES its deltas from its
controls' rests and composes them onto those same rests, except on a
joint that a step below the chain wrote: there the basis is the frame that
step left
(How operators fire).
So a constraint below the chain moves the joint and the chain carries that
displacement through its solve instead of replacing it. Rest offsets between
joints set the bone lengths and pivots — nothing is measured in absolute
numbers — but the solve itself is absolute: unless rigExec:startFrame
names the provider the chain hangs from, or rigExec:startFramePolicy =
"parent" derives it from the joint hierarchy, the chain ignores whatever
its joints sit under.
A Joint Group listed on rigExec:jointGroups picks one of
several alternative chains among the joints: a joint under an inactive member
publishes the frame the chain gives it at rest, carried by the start frame.
Skinning movers then read the posed joints at the final phase.
Wiring¶
| Relationship | Points to | Required |
|---|---|---|
rigExec:controls |
Ordered animator controls, one per joint. | yes |
rigExec:joints |
Ordered nested joints the chain poses; with none, the solver publishes frames nothing reads. | no |
rigExec:controlSpace |
parentRelative when the controls are nested under each other; world for sibling controls. |
no |
rigExec:jointGroups |
Ordered joint groups (prims with RigExecJointGroupAPI) whose members are joints of this chain; empty keeps every joint active. |
no |
Parameters¶
Node parameters¶
purpose¶
Type: uniform token. Default: "guide".
Render purpose, overriding UsdGeomImageable's default
fallback: joint and solver guides are DIAGNOSTICS, drawn when a
viewer asks for guides.
This is the stock attribute rather than a RigExec-specific token so
that the bounds and the drawing cannot disagree: UsdGeomBBoxCache
classifies a prim's extent by this exact attribute, and the results
scene index stamps the same resolved value onto the guide it
synthesizes. A control keeps the inherited default -- it is the
rig's interaction surface, not a diagnostic -- and authoring
guide on one moves both its drawing and its bounds together.
rigExec:controls¶
Relationship.
Ordered chain controls, root to tip: element i composes onto element i-1 (see rigExec:controlSpace).
rigExec:segmentScale¶
Type: uniform token. Default: "none".
Valid values: none, toChild.
toChild: each joint scales along the bone to the next element (the chain is ordered root to tip) by the bone's posed length over its rest length, so a child control pushed outward stretches the joint above it rather than only moving the one below.
rigExec:controlSpace¶
Type: uniform token. Default: "world".
Valid values: world, parentRelative.
What each control's posed frame already contains, i.e. whether it carries the motion of the control before it in the chain.
world (the default): the controls are independent asset-space
frames, siblings under the rig's Controls scope, each contributing
only its own rest-to-pose delta A_i; the solver composes them down
the chain, W_i = W_(i-1) . A_i. Posing a control moves the joints
below it but NOT the child controls, which stay at their rest.
parentRelative: control i is authored as a namespace descendant of
control i-1 with a rest relative to it, so its computePointFrame is
already W_(i-1) . restLocal_i . D_i -- it travels with its parent
the way an FK limb control does -- and its asset-space
rest-to-pose delta is the whole W_i. The solver therefore takes
each control's delta as-is instead of composing the parent in
again, which would apply the parent's motion twice. The joint
result is identical to world for the same avars; only the
control frames differ. Nesting is what makes the controls follow;
this token is what keeps the solver honest about it.
rigExec:startFrame¶
Relationship.
Optional single provider (joint or control) whose POSED
frame is the base the whole chain hangs from: the solver composes
every element on top of that provider's rest-to-pose delta S, so
W_0 = S . A_0 instead of W_0 = A_0 (and in parentRelative,
W_i = S . A_i for every i, since there each control's delta is
already the whole chain map).
Unauthored, the chain is an ABSOLUTE world solve that ignores
whatever its joints hang from.
That is what this relationship exists to fix. Measured on a
synthetic a -> b -> c with an FkChain over [b, c] only: posing
a with avars:rz = 90 left b at (10,0,0) and c at (20,0,0) -- they
did not move at all, because nothing told the solver where its
chain starts. A hand built that way detaches from the wrist the
moment the arm moves.
Nesting the chain's first control under the thing it should follow is NOT a substitute when that thing is solver-posed: a solver-posed joint is an absolute override and namespace pose does not propagate through it, and nesting under the arm's FK control follows in FK and stands still in IK. Pointing this relationship at the joint the chain hangs from -- the wrist, claimed by the arm's IK/FK blend -- follows in BOTH.
The target is an ordinary frame input with positional read semantics: the chain reads the version standing at its own place in the pose stack, so the chain must execute AFTER whatever poses the target -- later in the stack, i.e. earlier in the file, since siblings execute bottom-first. A chain ordered before the target's writer reads the pre-write frame (measured: a finger chain left below the arm blend reads the rest wrist and stays frozen), and the compiler warns naming the reorder. The start provider's own frame is NOT published as an element: cardinality stays exactly rigExec:controls, and each joint's element index is unchanged.
rigExec:startFramePolicy¶
Type: uniform token. Default: "none".
Valid values: none, parent.
Who names the start provider when rigExec:startFrame has no authored targets.
none (the default): nobody. The chain is an absolute solve
that ignores whatever the joints hang from.
parent: the compiler derives the provider from the JOINT
HIERARCHY, structurally, with no name matching of any kind: the
nearest namespace ancestor of the chain's joints that is a
RigExecJoint or RigExecControl, which every joint in
rigExec:joints must share (descendants count). The chain then
hangs from that provider exactly as if rigExec:startFrame named
it.
Authored targets always win over the inference, silently: a
chain with both behaves as if the policy were none. A chain
whose joints span providers, or with no provider ancestor,
falls back to the absolute solve with a compile warning -- it
never guesses. The positional ordering rule above applies
unchanged: the chain must still execute after the provider's
writer, and the compiler warns when it does not.
Mechanics: the inference is compiled, not evaluated, and it
authors nothing. Each compile resolves the provider into the
compiled chain as its start-frame input, through one rule that
native, frozen, and .rigexec evaluation share, so scheduling
and every compiled program see it exactly as an authored target.
The relationship itself stays empty on the stage; a recompile
(a reparented joint, a policy edit) re-derives it.
rigExec:joints¶
Relationship.
Ordered output joints this solver poses. List position is the aggregate element index; length is the effective sample count. The compiler binds each joint to one aggregate element in the compiled program.
rigExec:jointGroups¶
Relationship.
Ordered joint groups of this chain: prims carrying RigExecJointGroupAPI (conventionally Scopes) whose members are joints of this chain. A joint under an inactive member publishes the rest frame the chain publishes for zero control motion: its output rest carried through the start frame's rest-to-pose delta. The chain still composes later elements from every control. Empty keeps every joint active.
guide:radius¶
Type: double. Default: 1.0.
Radius of the sphere and cone drawn at each aggregate element: the exact counterpart of RigExecJoint's guide:radius, including the rule that zero or negative draws no guides at all, which is how a solver's diagnostics are turned off.
Without it the elements draw at Hydra's fallback radius of 1.0, which is proportionate on an asset authored at tens of units and several times the size of the whole character on one authored at one unit.
guide:displayColor¶
Type: color3f. Default: (0.3, 0.6, 1.0).
guide:displayOpacity¶
Type: float. Default: 0.5.
Example¶
Three controls curl a ten-quad strip. C2 is a namespace child of C1
and C3 of C2, each with the same local rest offset as its joint (2 units),
so the rings sit on Seg1/Seg2/Seg3 at x = 0, 2, 4 and each one rides the
one above it — the chain reads them with rigExec:controlSpace =
"parentRelative". One matrix mover per joint skins the strip through a
linear weight ramp, so each joint hands its influence to the next across a
two-unit span: the column on Seg2 is split 0.5 with Seg1, the midline
between Seg2 and Seg3 is split 0.5 to each, and from the column on Seg3 to
the strip's end at x = 5 the strip is Seg3's alone. Both bends therefore
draw as arcs rather than creases.
Open it live with:
Re-render the GIF above with:
Tips¶
- Nesting the controls only works with
rigExec:controlSpace = "parentRelative": a nested control's frame already carries its parent's motion, so the defaultworldcomposes it in a second time. On this stage, dropping the token sends Seg3 to x = -0.45 at frame 1006 instead of x = 3.03. - Point
rigExec:startFrameat the joint the chain hangs from when that joint is posed by another solver, or setrigExec:startFramePolicy = "parent"to derive it from the joint hierarchy; without either the chain is an absolute solve and the limb detaches from its parent. - FK pairs well with IK: blend the two aggregates through a Blend Point Frames node, or stack both solvers on the same joints —
rigExec:jointsis an ordered write, so the later writer simply replaces the frames the earlier one committed.