Pose¶
One place the driver can be, and the float it publishes when the driver gets there.
| Node type | RigExecPose |
| Example | pose_interpolator.usda |
On this page:
Overview¶

A pose is a single authored sample of its interpolator's pose space:
where the driver stands, how wide that pose's influence reaches, and the
outputs:weight a blend channel connects to. Its weight is 1 when the
driver stands exactly on the pose and, after the interpolator's
normalization, a share of the total elsewhere — negative where the solve
says lean away from this pose. Poses are prims parented under their
interpolator rather than parallel arrays on it, so a layer can retune one
pose's radius, or switch it off, without restating the other seven.
One authored pose of a RigExecPoseInterpolator, and the float it publishes.
A pose is a place the driver can be, plus how wide its influence reaches. Its outputs:weight is what a RigExecBlendInput's inputs:weight connects to; the weight is 1 when the driver stands exactly on this pose and (after normalization) shares the rig with its neighbours elsewhere.
Poses are children of their interpolator rather than a parallel array on it so that each one composes independently -- a layer can retune one pose's radius, or disable it, without restating the other seven. That is the same reason RigExecBlendSample is a prim and not an array entry.
How it works¶
Six of the pose's attributes are read at compile time, when the
interpolator builds and inverts its RBF matrix once: rigExec:rotation
(the driver's local rotation relative to its own rest, in the driver's
parent frame), rigExec:translation, rigExec:poseType, the two radii,
and inputs:enabled all feed that solve; a RigLogic solve also reads
rigExec:rotations and rigExec:scale. Those eight are the
pose's share of the compiled rig signature, so editing any of them recompiles the
interpolator. The other three — rigExec:falloff,
rigExec:poseControls and rigExec:poseControlValues — are provenance
that evaluation never reads, and the translation pair is dropped unless
the interpolator sets rigExec:enableTranslation or names numeric drivers.
Evaluation is the interpolator's operation in the shared graph: it reads
the final version of its driver's frame, every constraint included, and
the geometry chains that consume the weights read its outputs, so
dependencies place it between them. There the
interpolator measures its driver's final local rotation against every
pose and publishes one float per pose into both the resolved-input map a
consumer reads through and the rig pose's movedProperties map. The metric is
the pose's own: a swing or twist pose is judged on that half of the
driver's rotation, split about the interpolator's rigExec:twistAxis,
while a whole pose is judged on the entire rotation.
Wiring¶
| Relationship | Points to | Required |
|---|---|---|
| (child of) | The RigExecPoseInterpolator that solves it. A pose anywhere else is never read, and a non-RigExecPose child of an interpolator is a compile error. |
yes |
rigExec:poseControls |
The exact control properties that put the rig into this pose, parallel to rigExec:poseControlValues. Authoring data for a shape editor; nothing in evaluation reads it. |
no |
outputs:weight |
Written by the interpolator every evaluation; a RigExecBlendInput's inputs:weight connects to it. An authored connection on it is a compile error. |
- |
Parameters¶
Interpolator settings¶
rigExec:driver¶
Relationship.
The driver: a RigExecJoint or RigExecControl whose LOCAL rotation -- its pose relative to its own rest, in the frame of its nearest joint or control ancestor -- is what every pose is measured against. At most one target for the pose solver; a RigLogic solver (rigExec:solver additive or interpolative) takes several, each one quaternion of the input row in target order.
LOCAL, not world, and relative to rest rather than absolute: the rest orientation is the joint orient the authored data removes from poseRotation, so a driver sitting at its rest measures as identity and the neutral pose reads 1.000 with the rig standing still.
rigExec:driverAttributes¶
Relationship.
A NUMERIC driver: one to three float or double PROPERTIES -- avars, usually -- read in order as the driver's position, in place of a transform's translation.
This is what lets a corrective be driven by a dial rather than by something the rig moves: a breath, a squash amount, a shot-specific knob. Each pose carries the values it stands at in rigExec:translation and their width in rigExec:translationRadius, so the solve, the fit and the baked program are the ones the translation channel already had -- the only difference is where the position comes from.
Authoring this makes rigExec:driver optional (a RigLogic solve refuses both) and measures no rotation: there is no frame to take one from. Up to three because that is what one position is; a corrective wanting more channels is two interpolators whose weights multiply.
rigExec:solver¶
Type: uniform token. Default: "pose".
Valid values: pose, additive, interpolative.
Which solve turns distances into weights.
pose is this interpolator's own solve: per-pose widths, swing, twist and whole pose types, an optional translation channel, and the inverse of the pose matrix.
additive and interpolative are RigLogic's solvers (Epic Games OpenRigLogic, see docs/references.md). additive sums each pose's kernel value; interpolative weights them through the inverse of the pose-to-pose kernel matrix and clamps each to [0, 1]. Both then apply rigExec:normalizeMethod, each pose's rigExec:scale and rigExec:weightThreshold. They read rigExec:distanceMethod, rigExec:radius, rigExec:automaticRadius and rigExec:twistAxis, and ignore the pose solver's radii, pose types, translation channel, regularization, normalize and allowNegativeWeights.
A RigLogic solve's input row is each frame driver's local rotation from rest as (x, y, z, w) on the w >= 0 hemisphere, in rigExec:driver order, or the numeric drivers' values as read. A pose's row is its rigExec:rotations (or rigExec:rotation for one driver), or the first values of its rigExec:translation.
rigExec:distanceMethod¶
Type: uniform token. Default: "quaternion".
Valid values: euclidean, quaternion, swingAngle, twistAngle.
A RigLogic solve's metric. euclidean is the n-dimensional distance over the raw row and is the only one numeric drivers may use. quaternion sums, over the drivers, the squared arc length between rotations, and takes the square root. swingAngle does the same on the swing about rigExec:twistAxis, and twistAngle on the difference of unwound twist angles, which keeps +120 and -120 degrees 240 apart.
rigExec:normalizeMethod¶
Type: uniform token. Default: "onlyAboveOne".
Valid values: onlyAboveOne, always.
A RigLogic solve's normalization: divide the weights by their sum only when it exceeds one, or always.
rigExec:automaticRadius¶
Type: uniform bool. Default: false.
A RigLogic solve's radius is the mean distance between every pair of poses, in place of rigExec:radius.
rigExec:radius¶
Type: uniform float. Default: 0.
A RigLogic solve's kernel width, in the metric's units: radians for quaternion, swing and twist, the drivers' own units for euclidean. Zero leaves only an exact match with any weight.
rigExec:weightThreshold¶
Type: uniform float. Default: 0.
A RigLogic solve publishes zero for any pose whose normalized, scaled weight is at or below this.
rigExec:kernel¶
Type: uniform token. Default: "gaussian".
Valid values: gaussian, linear, exponential, cubic, quintic.
How a pose's weight falls away with distance. Of the parity fixture's 67 biped interpolators, 16 are gaussian and 51 linear.
exponential, cubic and quintic are RigLogic's weight functions: exp(-2 d/r), max(0, 1 - (d/r)^3) and max(0, 1 - (d/r)^5). In the pose solver gaussian is exp(-(d/r)^2); in a RigLogic solve it is RigLogic's exp(-d / r^2), which depends on the radius's units.
Gaussian never quite reaches zero, so a little of every pose survives everywhere -- a soft blend. Linear reaches zero AT the radius and has compact support, so past the radius a pose is not nearly off, it is off, which is what makes the coverage floor in rbf.h worth measuring.
rigExec:enableRotation¶
Type: bool. Default: true.
enableRotation: measure the driver's rotation.
Honoured rather than assumed. On the biped the two channels are mutually exclusive -- 39 of the parity fixture's interpolators rotation, 28 translation -- and reading a translation interpolator as a rotation makes every one of its poses identity, so it solves degenerate and drives nothing.
rigExec:enableTranslation¶
Type: bool. Default: false.
enableTranslation: measure the driver's translation as well, in the driver's own frame. Radians and centimetres cannot be added, so each channel is divided by its own radius first and the two are combined as a right-angled triangle (rbf.h RigExecRbfCombine).
rigExec:allowNegativeWeights¶
Type: bool. Default: true.
allowNegativeWeights. A negative weight is not an error: it falls out of the matrix inverse and means lean AWAY from this pose. Clamping them is what produces the soft, muddy blend that makes a pose fail to reach its own shape, so the default keeps them. The clamp this selects is max(0, w) applied AFTER normalization, never before and never inside the solve.
rigExec:normalize¶
Type: bool. Default: true.
Divide the weights by their SUM, so they stay a partition of unity. By their sum and not by the sum of magnitudes, because a negative weight is a real instruction. Where the sum is smaller than 1e-6 there is nothing to divide by and the weights are left alone, which is what falling away to nothing outside the poses should look like.
rigExec:regularization¶
Type: float. Default: 0.
regularization, added to the matrix diagonal before inverting. Trades exactness at the poses for a calmer result between them, and rescues a solve whose poses sit so close together that the matrix is singular. Zero on every interpolator of the shipped biped.
rigExec:twistAxis¶
Type: uniform token. Default: "X".
Valid values: X, Y, Z.
The axis a twist pose spins about, in the DRIVER's own frame. driverTwistAxis (0 X, 1 Y, 2 Z), and X on every body interpolator of the shipped biped but the torso's (Y), because the bind skeleton aims +X down the bone.
Read only by poses whose rigExec:poseType is swing or twist; a whole pose measures the entire rotation and never splits it. A RigLogic solve reads it only for the swingAngle and twistAngle metrics.
inputs:enabled¶
Type: bool. Default: true.
Shape-preserving enable. A disabled interpolator publishes zero on every pose rather than holding its last value: a corrective that is off has to be off, not frozen.
Node parameters¶
rigExec:poseType¶
Type: uniform token. Default: "swing".
Valid values: swing, twist, whole.
poseType (1 swing, 2 twist, 0 whole): WHICH PART of the driver's rotation this pose is measured against.
The metric belongs to the pose and not to the interpolator because one driver usually carries both at once and they mean different things: a neck that has twisted has not bent, and its bend shapes should stay at zero. Measuring the whole rotation instead leaks about 0.05 of every swing pose into a pure twist on the shipped biped.
rigExec:rotation¶
Type: quatf. Default: (1, 0, 0, 0).
Where the driver stands in this pose: its LOCAL rotation relative to its own rest, in the driver's parent frame.
REBASED. The authored poseRotation is measured from whatever configuration the rig happened to be in when the poses were captured, which on this character is 3 to 10 degrees off the bind pose -- a wrist FK control reading 10 degrees, an elbow 4.7. This port's drivers DO read identity at bind, so the neutral quaternion is taken out of every pose (neutral^-1 * pose) before it is authored here. It is a rigid rotation applied to all of them, so every pairwise distance and therefore the whole solve is unchanged; only the point the poses are measured FROM moves, which is the thing that was wrong. Skipping it moved the skin about two millimetres.
Measured against this port's own drivers it lands at 0.00 degrees on the elbow, the knee and the toe and 1.64 on the shoulder.
rigExec:translation¶
Type: float3. Default: (0, 0, 0).
The driver's translation in this pose, in the driver's own rest frame and its frame's units (CENTIMETRES on the shipped biped). Read only when the interpolator has rigExec:enableTranslation on or numeric drivers, whose values it then holds in their own units (rigExec:driverAttributes); an interpolator with no authored translations has nothing to say about translation, and saying every pose is equally close would peg its weights at 1/n.
rigExec:rotationRadius¶
Type: float. Default: 0.
How far in RADIANS the driver may stray before this pose's kernel has fallen away -- one falloff width, this pose's own.
FITTED, NOT EXPORTED. The width a set of poses was tuned with is not in the data; rigExec:falloff, a share relative to the closest other pose, is. So the shape of the rule is preserved and the size is not recoverable, and one scale for the whole rig does not work because the pose layouts are not alike: the thigh has poses 25 to 150 degrees apart, the shoulder eight with pairs 45 apart, the index three in a line. Narrow enough for the shoulder leaves the thigh with a hole in the middle of every swing; wide enough for the thigh sends the shoulder's weights to 9.
RigExecRbfFitWidth therefore fits it per interpolator to two requirements, in order: no dead zone (the kernels sum to at least 0.5 everywhere between the poses), then the least overshoot among the widths that manage it. A painted rigExec:falloff other than the default 0.3 is applied on top as falloff/0.3.
Compile uses the authored width as it stands and fits nothing. Zero is a zero width: the pose reads as infinitely far from every rotation but its own, so its kernel contributes nothing between the poses. To get the fit, run rigexec.rbf_fit_width (RigExecRbfFitWidth) and author the widths it returns.
rigExec:translationRadius¶
Type: float. Default: 0.
The same width for the translation channel, in rigExec:translation's units.
It is NOT the rotation radius and must not be borrowed from it: a brow's poses sit millimetres apart and a rotation width would swallow every one of them. rigexec.rbf_fit_width fits it by the same swept scale, because the metric already divides each channel by its own width -- the shape of the pose space is fixed by the RATIO of the two and only its overall size is free. As with rigExec:rotationRadius, compile reads it as authored and zero is a zero width.
rigExec:rotations¶
Type: quatf[]. Default: [].
A RigLogic solve with several frame drivers: where each driver stands in this pose, one rotation per rigExec:driver target in order, measured as rigExec:rotation is. Empty with one driver reads rigExec:rotation; any other count than one per driver is a compile error.
rigExec:scale¶
Type: uniform float. Default: 1.
A RigLogic solve multiplies this pose's normalized weight by this before the threshold: RigLogic's pose scale.
rigExec:falloff¶
Type: float. Default: 0.3.
poseFalloff, kept as provenance and as the editable dial: the share the artist painted on top of the fitted width, where 0.3 is the default and means just reach the closest other pose. 0.3 on every pose of the shipped biped except the clavicles and the mouth corners, which are 0.5.
The radii above already carry it (falloff/0.3, floored at 0.05), so it is not applied a second time at runtime. It is here so that an editor changing it can re-derive them, and so that a rig whose radii were hand-tuned still says what it started from.
rigExec:poseControls¶
Relationship.
The exact control PROPERTIES that put the rig into this pose -- an L_LoArm control's avars:rz on the shipped biped, and the like -- parallel to rigExec:poseControlValues. Properties rather than prims because a control carries nine channels and a pose usually sets one.
It is authoring data for a tool that jumps the rig to a pose to sculpt against it: nothing in evaluation or in the bundled Shape Editor reads it, and a pose with none is still a valid pose.
rigExec:poseControlValues¶
Type: double[]. Default: [].
The value for each target of rigExec:poseControls, in OUR units and from OUR zero: degrees for a rotation avar, centimetres for a translation one, measured from the rig's rest rather than from the authored data's.
The authored numbers are absolute and in radians, and their zero is the configuration the poses were captured in rather than the bind pose. Measured: driving this rig with those absolute values reaches the authored quaternion to 45.4 degrees on the shoulder and 10.0 on the wrist; driving it with (pose - neutral) reaches 1.64 and 0.00. So the subtraction happens once, at build time, and what is stored is what an editor can set directly.
inputs:enabled¶
Type: bool. Default: true.
Shape-preserving enable. A disabled pose publishes zero and is left out of the solve entirely rather than solved and then silenced: leaving it in would keep it in every other pose's matrix row, so switching one pose off would quietly change all the others.
outputs:weight¶
Type: float. Default: 0.
How much this pose counts, for wherever the driver is now. The output a RigExecBlendInput's inputs:weight connects to.
1 with the driver standing on this pose, and elsewhere a share of the interpolator's normalized total -- which may be negative when rigExec:allowNegativeWeights is on, and should be: that is the instruction to lean away from a pose, and clamping it is what makes a blend muddy.
Example¶
The ElbowSwing interpolator carries three poses — neutral at
identity, half at 40 degrees and bent at 80, both about Z — and the
bent pose's outputs:weight is the only thing wired into the corrective
blend channel. Measured on the stage, the bent pose publishes 0.000 with
the arm straight and through the 40-degree hold, 0.529 at frame 1012
halfway to the second hold, and 1.000 from frame 1015, when the elbow
reaches the pose exactly.
Open it live with:
Re-render the GIF above with:
Tips¶
- Author a non-zero
rigExec:rotationRadiusby hand. The evaluator hands the per-pose radii straight to the solver, and a width of zero makes every non-zero distance infinite, so the pose's kernel is dead: on a two-pose test rig the zero-radius pose published 0.000 at every frame, including the one where the driver reached it. inputs:enabled = falsedrops the pose out of the solve entirely rather than solving it and silencing the result — the remaining poses re-solve as if it had never been authored — and the disabled pose publishes a hard zero whatever else the interpolator does.rigExec:poseTypedefaults toswing, which measures the driver's rotation with its twist aboutrigExec:twistAxisremoved. Usewholewhen one pose should account for the entire rotation. A swing pose captured from a driver that only twists measures as identical to neutral, and an interpolator whose poses are all coincident under its enabled channels is reported degenerate and pegs every weight at 1/n.- Under a RigLogic solve (
rigExec:solveradditive or interpolative) the pose's radii, type and translation radius are not read. With several frame drivers it authors one rotation per driver inrigExec:rotations; with numeric drivers itsrigExec:translationholds their values;rigExec:scalemultiplies its weight. See RigLogic behaviours.