Houdini 21.0 Nodes APEX nodes

rig::ExtractParmTransform 2.0

Extracts the transformation parameters from a local matrix with respect to a local rest matrix.

On this page	Inputs Outputs
Since	21.0

Extracts the translation, rotation, scale, and shear parameters from a local space matrix with respect to a local space rest matrix. This node represents the inverse functionality of rig::CombineParmTransform. The parameters are extracted according to the transformation mode such that they represent the corresponding “Pre-transform”, “Post-transform”, or “Override” parameters that could be used to recreate the local matrix.

This node is useful in rig inversion workflows, where it can generate the parameter values needed to reproduce the pose described by the local matrix given an arbitrary rest matrix.

Inputs ¶


                localxform:
                    Matrix4

The local space matrix from which to extract the transformation parameters with respect to the restlocal matrix.


                restlocal:
                    Matrix4

The local space rest matrix.


                p:
                    Vector3

The pivot position from which to extract the transformation parameters. The default is the origin.


                pr:
                    Vector3

The pivot orientation (represented as XYZ Euler angles, in degrees) from which to extract the transformation parameters. The default is no rotation.


                xord:
                    Int

The transformation order of the transformation parameters. The default is scale → rotate → translate. See transformation order.


                rord:
                    Int

The rotation order. The default is X → Y → Z. See rotation order.


                mode:
                    Int

The transformation mode, which affects how the transformation parameters are extracted from the rest matrix. The default is “Pre-transform”.

Outputs ¶


                t:
                    Vector3

The extracted translation.


                r:
                    Vector3

The extracted rotation represented as Euler angles, in degrees. The rotation order corresponds to the value of rord.


                s:
                    Vector3

The extracted scale.


                sh:
                    Vector3

The extracted shear.

See also

APEX nodes

Abs

Computes the absolute value.
Acos

Computes the inverse cosine.
Add

Calculates the sum of the input values.
AlmostEquals

Checks if two values are almost equal.
And

Performs a logical AND operation.
Asin

Computes the inverse sine.
Atan

Computes the inverse tangent.
Atan2

Computes the inverse tangent of y/x.
Average

Computes the average of the input values.
BitwiseAnd

Performs a bitwise AND operation.
BitwiseNot

Performs a bitwise inversion of each bit of an integer.
BitwiseOr

Performs a bitwise OR operation.
BitwiseXor

Performs a bitwise XOR operation.
BoolToIntBitMask

Constructs a bit mask from the entries of the input ports.
CartesianToGeodetic

Converts a 3D cartesian coordinate to its geodetic coordinate.
CartesianToPolar

Converts a 2D cartesian coordinate to its polar coordinate.
CartesianToSpherical

Converts a 3D cartesian coordinate to its spherical coordinate.
Ceil

Returns the smallest integer greater than or equal to a floating point number.
Clamp

Clamps a value between min and max.
Complement

Computes the complement of the input value by subtracting it from 1.
ComponentBoolsToInt

Constructs a component bitmask.
ComponentIntToBools

Checks the components that are active in a component bitmask.
Convert

Converts an input of type SrcT to an output of type DesT.
CopyArg

Copies the input argument.
Cosine

Computes the cosine of an angle.
CrossProduct

Computes the cross product of two vectors.
DegreesToRadians

Converts an angle in degrees to radians.
Distance

Returns the Euclidean distance between two vectors.
Divide

Calculates the quotient of the input values.
DotProduct

Computes the dot product of two vectors.
DragPlane

Intersects a ray with a plane.
Efit

Takes a value in one range and shifts it to a new range.
Equals

Returns True if two values are equal.
Exponent

Raises a value to an exponent.
Fit

Takes a (clamped) value in one range and shifts it to a new range.
Fit01

Takes a value in the range (0, 1) and shifts it to a new range.
Fit10

Takes a value in the range (1, 0) and shifts it to a new range.
Fit11

Takes a value in the range (-1, 1) and shifts it to a new range.
FloatToVector2

Builds a Vector2 from Floats.
FloatToVector3

Builds a Vector3 from Floats.
FloatToVector4

Builds a Vector4 from Floats.
Floor

Returns the largest integer less than or equal to a floating point number.
ForBegin

Defines the start of a for loop.
ForEachBegin

Defines the start of a for-each loop.
ForEachEnd

Defines the end of a for-each loop.
ForEnd

Defines the end of a for loop.
Frac

Returns the fractional component of a floating point number.
GeodeticToCartesian

Converts a geodetic coordinate to its 3D cartesian coordinate.
GetComponent

Extracts a single component of a vector or matrix type.
GreaterThan

Determines if a value is greater than another value.
GreaterThanOrEqual

Determines if a value is greater than or equal to another value.
IfBegin

Defines the start of an If block for conditional execution.
IfEnd

Defines the end of an If block for conditional execution.
Input

Provides inputs for a graph.
IntBitMaskToBool

Extracts individual bits from a bit mask.
Invert

Inverts a matrix.
Length

Computes the length of a vector.
Lerp

Performs linear interpolation between the input values.
LessThan

Determines if a value is less than another value.
LessThanOrEqual

Determines if a value is less than or equal to another value.
Log

Adds an APEX log entry to the log viewer.
Matrix3ToVector3

Extracts the row vectors from a Matrix3.
Matrix4ToVector4

Extracts the row vectors from a Matrix4.
Max

Calculates the maximum of the input values.
Min

Calculates the minimum of the input values.
Modulo

Applies the modulo operation to the two input values.
Multiply

Calculates the product of the input values.
NLerp

Performs linear interpolation between two vectors and normalizes the result.
Negate

Negates the input value.
Noise

Produces Perlin-style non-periodic noise.
Normalize

Normalizes a vector.
Not

Inverts the logical value.
Null

Utility node for passing through unmodified values.
Null

Utility node for passing through unmodified values of a given type.
Or

Performs a logical OR operation.
Output

Provides outputs for a graph.
PolarToCartesian

Converts a polar coordinate to its cartesian coordinate.
Quantize

Rounds down a value to a multiple of another value.
RadiansToDegrees

Converts an angle in radians to degrees.
RampLookup

Looks up the value of a ramp at a specified position.
Round

Rounds a floating point value to the nearest integer or to a specific number of decimal places.
RunVex

Executes a VEX snippet.
SetComponent

Sets a single component of a vector or matrix type.
Sine

Computes the sine of an angle.
SphericalToCartesian

Converts a spherical coordinate to its 3D cartesian coordinate.
Subnetwork

Provides a container of subgraphs.
Subtract

Calculates the difference between the input values.
Switch

Switches between different input values based on an index.
SwitchByName

Switches between different input values based on the name of the input port.
Tan

Computes the tangent of an angle.
TransformObject

Represents and builds a hierarchy of transformations in a rig.
Transpose

Transposes a matrix.
TwoWaySwitch

Switches between two inputs based on a Bool value.
Value

Holds a copy of an input value.
Vector2ToFloat

Extracts all the components of a Vector2.
Vector3ToFloat

Extracts all the components of a Vector3.
Vector3ToMatrix3

Constructs a Matrix3 from the input row vectors.
Vector4ToFloat

Extracts all the components of a Vector4.
Vector4ToMatrix4

Constructs a Matrix4 from the input row vectors.
Xor

Performs a logical XOR operation.
array::Add

Adds two arrays element-wise.
array::Append

Appends a value to an array.
array::Build

Builds an array with the provided values.
array::Clear

Clears an array.
array::Divide

Divides two arrays element-wise.
array::Extend

Extends an array with another array.
array::Find

Finds the index of an array element with a specific value.
array::Get

Gets an element in an array.
array::Insert

Inserts an element at a specific array index.
array::Length

Returns the length of an array.
array::Lerp

Performs linear interpolation between two arrays element-wise.
array::Max

Finds the maximum element in an array.
array::Min

Finds the minimum element in an array.
array::Multiply

Multiplies two arrays element-wise.
array::Remove

Removes an element from an array.
array::Reverse

Reverses the order of elements in an array.
array::Scale

Scales all elements of an array by a scalar.
array::Set

Sets an element in an array.
array::Sort

Sorts an array in ascending order.
array::SortAndRemoveDuplicates

Sorts an array in ascending order and removes duplicate elements.
array::Subtract

Subtracts two arrays element-wise.
array::Sum

Finds the sum of the array elements.
ch::AddKey

Adds a key to a channel.
ch::AddKeys

Adds keys to channels in a collection.
ch::AnimStackAddKeys

Adds keys to channels in an animation stack.
ch::AnimStackBuild

Creates an animation stack from the layers of an APEX scene’s animation.
ch::AnimStackEvaluate

Evaluates parameters from an animation stack.
ch::BlendKeys

Blend keys from 2 channels using a blend value or a blend channel.
ch::ChannelCollectionFromPrims

Creates a channel collection from the channel primitives on a geometry.
ch::ChannelFromCollection

Creates an APEX channel from a channel collection.
ch::ChannelFromPrim

Creates an APEX channel from a channel primitive.
ch::ChannelToPoints

Adds a channel to a geometry as a curve or collection of points.
ch::ChannelToPrim

Adds a channel primitive to a geometry.
ch::ChannelsFromCollection

Creates APEX channels from a channel collection.
ch::ChannelsFromPrims

Creates APEX channels from the channel primitives on a geometry.
ch::CollectionBlendKeys
ch::CollectionCopyKeys
ch::CollectionCycleKeys

Adds additional cycles of the channels in a collection.
ch::CollectionDeleteKeys

Deletes keyframes from a channel collection.
ch::CollectionEulerFilter

Applies an Euler filter on the rotation channels in a channel collection.
ch::CollectionGetChannel

Returns a channel from a channel collection.
ch::CollectionGetChannelArray

Returns an array of channels from a channel collection.
ch::CollectionLength

Returns the number of channels in a channel collection.
ch::CollectionNameAt

Returns the channel name at a given index in a channel collection.
ch::CollectionNames

Returns the channel names from a channel collection.
ch::CollectionReduceKeys

Reduces the keys of the channels in a collection while maintaining their shape.
ch::CollectionScaleKeys

Scales the key values of a collection of channels about a pivot.
ch::CollectionSetChannel

Adds an APEX channel to a channel collection.
ch::CollectionSetChannelArray

Sets the channels in a channel collection from an array.
ch::CollectionSetChannels

Adds APEX channels to a channel collection.
ch::CollectionShiftKeys

Shifts all the keys of a collection of channels by a constant time.
ch::CollectionSmoothAutoTangents

Computes the tangents on the keys of each channel in a collection that has auto tangents enabled.
ch::CollectionSmoothKeys

Smoothes the keyframes in a channel collection.
ch::CopyKeys
ch::CycleKeys

Adds additional cycles of a channel.
ch::DeleteKeys

Deletes keyframes from an APEX channel.
ch::DictUpdateFromChannelGeo

Evaluates a collection of channels and updates a dictionary with the results.
ch::EulerFilter

Applies an Euler filter on rotation channels.
ch::Evaluate

Evaluates a channel.
ch::EvaluateLayered

Creates a channel from the sum of a set of channels.
ch::EvaluateMulti

Evaluates a set of channels.
ch::PrimsFromChannelCollection

Adds channels from a channel collection to a geometry.
ch::ReduceKeys

Reduces the keys of a channel while maintaining its shape.
ch::ScaleKeys

Scales the key values of a channel about a pivot.
ch::ShiftKeys

Shifts all the keys of a channel by a constant time.
ch::SmoothAutoTangents

Computes the tangents on the keys of a channel that has auto tangents enabled.
ch::SmoothKeys

Smoothes the keyframes in a channel.
component::AddAbstractControl

Adds an abstract control to a graph.
component::Blendshape
component::Bonedeform
component::Deltamush
component::FBIK
component::FKIK
component::FindSegments

Finds the segments in a component to loop over.
component::GetRestTransform

Gets the rest transform of a TransformObject node.
component::GetTransformChildren

Gets the children of a TransformObject node.
component::GetTransformDescendants

Gets the descendants of a TransformObject node.
component::GetTransformParent

Gets the parent of a TransformObject node.
component::InsertTransformParent

Inserts a new TransformObject node between a node and its parent.
component::Lookat
component::MappedConstraints
component::MultiIk
component::ProcessSegment

Inserts the component segment name into a string.
component::Rename
component::ReverseFoot
component::SetRestTransform

Sets the rest transform of a TransformObject node.
component::SetRestTransformFromSkel

Sets the rest transform of a TransformObject node based on a skeleton.
component::SetTransformParent

Sets the parent of a TransformObject node.
component::Spline
component::Spline2
component::TransformDriver
component::Twist
component::UpdateControls

Updates the control shape of a TransformObject node.
component::UpdateParmLimits

Updates the parameter limits of a TransformObject or AbstractControl node.
controlgadget::SnapXFormToAxes

Snaps a transform to the specified axes during a mouse drag.
dict::Build

Copies a dictionary and adds new entries.
dict::Contains

Searches the input dictionary for a key.
dict::DebugDataIds

Creates a dictionary with the data IDs of the entries of an input dictionary.
dict::Extract

Extracts multiple values from a dictionary.
dict::Get

Gets a value from a dictionary.
dict::GetNested

Gets a value from a dictionary of dictionaries.
dict::Insert

Adds new entries to a dictionary.
dict::Keys

Gets an array of the keys of a dictionary.
dict::PatternRenameKeys

Performs pattern replacement on the keys of a dictionary.
dict::Remove

Removes from a dictionary all entries with keys matching a pattern.
dict::RenameKeys

Renames the keys of a dictionary.
dict::Set

Sets a value into a dictionary.
dict::SetNested

Sets a value into a nested dictionary.
dict::Transfer

Copies entries from one dictionary to another, using a third dictionary to define the key mapping.
dict::Update

Updates the entries of a dictionary with the entries of other dictionaries.
dynamicpath::Add

Adds one dynamic path to another.
dynamicpath::AddTweakTarget

Adds a target for the dynamic path tweak solver.
dynamicpath::Bake

Bakes a dynamic path.
dynamicpath::DeformLaplacian

Deforms a dynamic path as a mesh represented with Laplacian coordinates.
dynamicpath::Evaluate

Evaluates a dynamic path at the given time.
dynamicpath::EvaluateInSourceTime

Evaluates a dynamic path at the given source time.
dynamicpath::EvaluateMulti

Evaluates a dynamic path at multiple times.
dynamicpath::EvaluateMultiInSourceTime

Evaluates a dynamic path at multiple source times.
dynamicpath::GetAllSections

Gets sections of a dynamic path and their corresponding layer indices.
dynamicpath::GetKeyTimes

Gets the times at which to key a character to follow the motion of a dynamic path.
dynamicpath::GetSection

Gets a section of a dynamic path and its corresponding layer index.
dynamicpath::GetTiming

Gets the start time, end time, and life of a dynamic path.
dynamicpath::LoadFromAnimStack

Creates a dynamic path that represents the motion of a TransformObject by sampling the translate, rotate, and scale parameters from an animation stack.
dynamicpath::LoadFromArray

Creates a dynamic path from arrays of positions, times, and source times.
dynamicpath::LoadFromChannels

Creates a dynamic path by sampling a set of X, Y, and Z channels.
dynamicpath::LoadFromGeometry

Loads a dynamic path from the geometric representation of a dynamic path.
dynamicpath::LoadFromGraph

Constructs dynamic paths by evaluating Matrix4 outputs of a graph over time.
dynamicpath::LoadFromGraphChannels

Constructs dynamic paths by building a parameter dictionary for a graph from a channel collection, and evaluating Matrix4 outputs of the graph over time.
dynamicpath::ProjectileLifeFromPlane

Computes the life of a projectile arc based on the start position, end position, and maximum height of the projectile in a given direction.
dynamicpath::ProjectilePathEvaluatePeak

Determines the peak of a projectile path.
dynamicpath::ProjectilePathFromLife

Creates a dynamic path representing the arc of a projectile that is launched between two positions in a specific amount of time.
dynamicpath::ProjectilePathFromPlane

Creates a dynamic path representing the arc of a projectile that is launched between two positions while skimming a height plane.
dynamicpath::ProjectilePathFromSpeed

Creates a dynamic path representing the arc of a projectile that is launched between two positions with a specific initial speed.
dynamicpath::ResolveTweakTargets

Solves for a dynamic path using the Tweak algorithm.
dynamicpath::SaveToGeometry

Creates a geometry from a dynamic path.
dynamicpath::Subtract

Subtracts one dynamic path from another.
fbik::GetBoneTransform

Gets the transform of a bone in a full body IK skeleton.
fbik::GetCenterOfMass

Computes the center of mass of a full body IK skeleton.
fbik::SetComTarget

Sets a center of mass target on a full body IK solver.
fbik::SetSkeleton

Sets a skeleton on a full body IK solver.
fbik::SetTarget

Sets a target on a full body IK solver.
fbik::SetTargets

Sets multiple targets on a full body IK solver.
fbik::SetTargetsFromDict

Sets targets on a full body IK solver from a dictionary.
fbik::SetTargetsFromGeo

Sets targets on a full body IK solver from a geometry.
fbik::SkeletonFromGeo

Gets a full body IK skeleton stored in geometry.
fbik::SkeletonUpdateGeo

Updates geometry using information from a full body IK skeleton.
fbik::SolveFABRIK

Solves a full body IK skeleton using the FABRIK algorithm.
fbik::SolvePhysIK

Solves a full body IK skeleton using the PhysIK algorithm.
fbik::Solver

Creates a full body IK solver from a full body IK skeleton.
fbik::Target

Creates a full body IK skeleton target.
geo::AddPacked

Creates a packed primitive that contains the given geometry.
geo::ArrayAttribValue

Returns the values of an array attribute.
geo::AttribIntersectPoints

Performs ray intersection with a geometry and computes weights for nearby points, outputting the weights as geometry attributes.
geo::BoundingBox

Returns the bounding box of a geometry.
geo::CopyDetailAttrib

Copies a detail attribute between two geometries.
geo::DetailAttribValue

Returns the value of a detail attribute.
geo::ExtractPackedGeo

Returns the geometry embedded in a packed primitive.
geo::FindPointAttribValue

Finds all points in a geometry with a given attribute value.
geo::FindPrimAttribValue

Finds all primitives in a geometry with a given attribute value.
geo::FindVertexAttribValue

Finds all vertices in a geometry with a given attribute value.
geo::ForEachPointBegin

Defines the start of a for-each loop that iterates over the points in a geometry.
geo::ForEachPointEnd

Defines the end of a for-each loop that iterates over the points in a geometry.
geo::ForEachPrimBegin

Defines the start of a for-each loop that iterates over the primitives in a geometry.
geo::ForEachPrimEnd

Defines the end of a for-each loop that iterates over the primitives in a geometry.
geo::FromDisk

Returns a geometry from a geometry file read from disk.
geo::GlobPoints

Returns an array of points based on a pattern.
geo::GlobPrims

Returns an array of primitives based on a pattern.
geo::GuideDeform

Deforms groom geometry based on a joint skeleton and skin surface.
geo::InitIntersectCache

Computes an intersection cache for a geometry.
geo::Intersect

Determines the intersection point of a ray with an intersection cache.
geo::IntersectPoints

Performs ray intersection with a geometry and computes weights for nearby points, outputting the weights in an array.
geo::Lattice

Deforms geometry based on the reshaping of a control lattice.
geo::Merge

Merges the points and primitives from other geometry objects into this geometry.
geo::MergePacked

Packs each input and merges them together into a single geometry.
geo::NumPoints

Returns the number of points in a geometry.
geo::NumPrims

Returns the number of primitives in a geometry.
geo::PointAttribValue

Returns the value of a point attribute.
geo::PointAttribValuesByName

Returns the values of an attribute on the points that match a second attribute name.
geo::PointPrims

Returns all the primitives that contain a given point.
geo::PrimAttribValue

Returns the value of a primitive attribute.
geo::PrimAttribValuesByName

Returns the values of an attribute on the primitives that match a second attribute name.
geo::PrimPoints

Returns all the points on a given primitive.
geo::Replace

Replaces the contents of a geometry object with another geometry object.
geo::SetAgentTransforms

Overrides the transforms of an agent primitive.
geo::SetDetailAttribValue

Sets a detail attribute value on a geometry.
geo::SetPointAttribValue

Sets a point attribute value on a geometry.
geo::SetPointAttribValues

Sets the value of a given attribute on all the points in a geometry.
geo::SetPointAttribValuesByName

Sets the value of an attribute on the points that match a second attribute name.
geo::SetPrimAttribValue

Sets a primitive attribute value on a geometry.
geo::SetPrimAttribValues

Sets the value of a given attribute on all the primitives in a geometry.
geo::SetPrimAttribValuesByName

Sets the value of an attribute on the primitives that match a second attribute name.
geo::SetVertexAttribValue

Sets a vertex attribute value on a geometry.
geo::SetVertexAttribValues

Sets the value of a given attribute on all the vertices in a geometry.
geo::SetVertexAttribValuesByName

Sets the value of an attribute on the vertices that match a second attribute name.
geo::Transform

Transforms a geometry using a transformation matrix.
geo::UpdatePackedGeo

Embeds a geometry into a packed primitive, replacing the primitive’s contents.
geo::VertexAttribValue

Returns the value of a vertex attribute.
geo::VertexAttribValuesByName

Returns the values of an attribute on the vertices that match a second attribute name.
geoutils::CopyToPointsTargetAttribs

Sets up default target attributes for use in sop::copytopoints.
geoutils::DottedLine

Creates a dotted line geometry.
geoutils::Translate

Translates a geometry.
geoutils::UniformScale

Scales a geometry by a scale factor along the x, y, and z axes.
geoutils::Wrangle

Runs a VEX snippet on the incoming geometry.
graph::AddNode

Adds a node to an APEX graph.
graph::AddNodeToSubnet

Adds a node to a subnet in an APEX graph.
graph::AddOrUpdateNode

Adds or updates a node.
graph::AddSubnet

Adds a subnet node to an APEX graph, and sets the contents of the subnet.
graph::Compile

Compiles a graph and reports any execution errors.
graph::ConnectInput

Connects two APEX node ports given the port IDs.
graph::DefaultParms

Gets the default parameters of an APEX graph.
graph::DeleteNode

Deletes a node from an APEX graph.
graph::DeleteNodes

Deletes a set of nodes from an APEX graph.
graph::DisconnectPort

Disconnects the wires connected to the specified port.
graph::DuplicateNode

Duplicates the input node.
graph::EvaluateOutputs

Evaluates outputs from an APEX graph.
graph::FindAndConnectInput

Connects two APEX node ports given the node IDs and port names.
graph::FindAndRemoveWire

Removes the wire connecting the specified source and destination ports.
graph::FindFirstNode

Returns the first matched node in an APEX graph based on a pattern.
graph::FindFirstPort

Returns the first matched port in an APEX graph based on a pattern.
graph::FindNode

Finds a node in an APEX graph based on a node path.
graph::FindNodeInput

Finds an input port on an APEX node.
graph::FindNodeOutput

Finds an output port on an APEX node.
graph::FindNodeTags

Finds the tags of a node based on a pattern.
graph::FindNodes

Finds an array of node IDs in an APEX graph based on a pattern.
graph::FindOrAddNode

Finds or adds a node to an APEX graph.
graph::FindOrAddPort

Finds or adds a port or subport on an APEX node based on a port name.
graph::FindPort

Finds a port on an APEX node based on a port name.
graph::FindPorts

Finds the ports in an APEX graph based on a pattern.
graph::FindUniqueNodeName

Finds a unique node name given the desired name.
graph::GetConnectedNodes

Finds all APEX nodes that have a direct wire connection to a given port.
graph::GetConnectedPort

Finds the port that is connected to a given port.
graph::GetConnectedPorts

Finds all ports that have a direct wire connection to a given port.
graph::GetPromotedPort

Finds the promoted graph input or output port that is connected to a given port.
graph::GetSubPort

Finds or adds a subport to a variadic port.
graph::GetSubnetContents

Gets the contents of an APEX subnet node.
graph::GraphInputs

Finds all the top-level parameter input ports of an APEX graph.
graph::GraphOutputs

Finds all the top-level output ports of an APEX graph.
graph::HasNodeTag

Checks if a tag exists on a node.
graph::HasNodeTags

Checks if multiple tags exist on a node.
graph::IfConnected

Determines whether an input port to a subgraph or subnet is connected, and returns either that port’s value or a fallback value.
graph::Invoke

Invokes an APEX graph.
graph::IsConnected

Determines whether an input port to a subgraph or subnet is connected.
graph::Layout

Creates a default positional layout of a selection of APEX nodes.
graph::LoadFromGeometry

Loads an APEX graph from geometry.
graph::Merge

Merges the contents of an APEX graph into an existing graph.
graph::NodeData

Gets the data for a node in an APEX graph.
graph::NodeInputs

Finds all the input ports on an APEX node.
graph::NodeOutputs

Finds all the output ports on an APEX node.
graph::PackSubnet

Packs an array of APEX nodes into a subnet.
graph::ParentNodes

Parents two nodes in a graph.
graph::PortData

Gets the data for a port in an APEX graph.
graph::PortNode

Gets the node that contains a given port in an APEX graph.
graph::PromoteInput

Connects a port to an APEX graph input.
graph::PromoteNodeInput

Promotes an input port to the graph’s parms node.
graph::PromoteNodeInputs

Promotes multiple input ports to the graph’s parms node.
graph::PromoteNodeOutput

Promotes an output port to the graph’s output node.
graph::PromoteNodeOutputs

Promotes multiple output ports to the graph’s output node.
graph::PromoteOutput

Connects a port to an APEX graph output.
graph::PromotePort

Promotes a port to the graph’s parms or output node.
graph::Properties

Gets the properties of an APEX graph.
graph::RenamePort

Sets the name of an input port, output port, or subport.
graph::ReplaceNodeTag

Finds and replaces a tag on a node.
graph::RewireOutputs

Rewires the output ports on a node in an APEX graph.
graph::SaveToGeometry

Writes an APEX graph to geometry.
graph::SetDefaultParms

Updates the default parameter dictionary of an APEX graph.
graph::SetProperties

Updates the properties dictionary of an APEX graph.
graph::SetSubnetContents

Sets the contents of a subnet in an APEX graph.
graph::Sort

Sorts an APEX graph.
graph::Template

Compiles its internal subnetwork and outputs it as an APEX graph handle object.
graph::UnpackSubnet

Unpacks a subnet in an APEX graph.
graph::UpdateControls
graph::UpdateNode

Updates a node in an APEX graph.
graph::UpdateNodeParms

Updates the parameters on a node in an APEX graph.
graph::UpdateNodeProperties

Updates the properties of a node in an APEX graph.
graph::UpdateNodeTags

Updates the tags on a node in an APEX graph.
graphutils::AcceptsSubport

Returns whether a port can have subports.
graphutils::NodeAncestors

Returns all the subnets that contain a given node.
graphutils::NodeCallbackName

Returns the callback name of a node.
graphutils::NodeName

Returns the name of a node.
graphutils::NodeParent

Returns the parent subnet of a node.
graphutils::NodeParms

Returns the parameters on a node.
graphutils::NodePath

Gets the path for a node ID in an APEX graph.
graphutils::NodeProperties

Returns the properties of a node.
graphutils::NodeTags

Returns the tags on a node.
graphutils::OuterPort

Returns the outer port of a subport.
graphutils::PortPath

Gets the path for a port ID in an APEX graph.
guide::AddSetPointTransforms

Adds a skel::SetPointTransforms node to the graph.
guide::ControlsFromGuides

Adds or updates the TransformObject nodes for the joints in a guide skeleton.
guide::FindOrAddGuide

Finds or adds guide geometry.
guide::FindPrimaryAxis

Finds the primary axis of a joint.
guide::SetGuideParent

Parents joints and updates the matching nodes in the graph.
guide::SetGuideProperties

Sets the properties metadata on the guide joints.
guide::UpdatePatternFromGuides

Creates string patterns from skeleton joint names or a string array.
guide::UpdateShapesFromGuides

Sets shape data on TransformObjects.
quaternion::Distance

Finds the distance between two quaternions.
quaternion::FromAxisAngle

Creates a unit quaternion from an angle and an axis.
quaternion::FromEuler

Creates a unit quaternion from a set of Euler angles.
quaternion::FromMatrix

Converts a rotation matrix into a unit quaternion.
quaternion::Invert

Inverts a quaternion.
quaternion::Multiply

Multiplies two quaternions.
quaternion::Rotate

Rotates a vector by a quaternion.
quaternion::SwingTwistDecompose

Decomposes a quaternion into a swing and a twist along an axis.
quaternion::SwingTwistInterpolate

Interpolates between two quaternions while interpolating the swing and twist components separately.
quaternion::ToAxisAngle

Converts a quaternion to an axis vector and an angle.
quaternion::ToEuler

Creates a set of Euler angles from a quaternion.
quaternion::ToMatrix

Converts a quaternion to a rotation or transformation matrix.
ragdoll::Solve

Applies a ragdoll simulation to one or more characters.
rig::AbstractControl

Defines an abstract control in a rig.
rig::AddControlShape

Dynamically adds a deforming shape to a control shape library.
rig::CombineParmTransform

Constructs a local matrix by combining a local rest matrix with a set of transformation parameters.
rig::ControlShape

Adds the option of modifying the shape of a control in an APEX rig.
rig::ControlSpline

Builds a spline from a list of CVs.
rig::ControlSplineFromArray

Builds a spline from an array of CVs.
rig::CurveConstraint

Outputs a transform matrix derived from a location on a curve primitive.
rig::ExtractLocalTransform

Extracts a local transform given a child and parent transform, taking scale inheritance rules into account.
rig::ExtractParmTransform

Extracts the transformation parameters from a local matrix with respect to a local rest matrix.
rig::FkTransform

Represents a transformation in a transformation hierarchy.
rig::MultiBoneIK

Positions and orients joints from a root position, goal, and twist position using inverse kinematics.
rig::MultiBoneIKFromArray

Positions and orients joints from a root position, goal, and twist position using inverse kinematics, with inputs and outputs given as arrays.
rig::ParentBlend

Creates a parent constraint between two matrix transforms.
rig::PointConstraint

Computes a transform from a weighted mix of points on a geometry.
rig::PoseWeightInterpolation

Performs pose-weight interpolation.
rig::PrimConstraint

Computes a transform for a coordinate within a geometry primitive.
rig::RBFInterpolation

Performs radial basis function (RBF) interpolation.
rig::SampleSplineTransforms

Samples transforms from a spline.
rig::SampleSplineTransformsToArray

Samples transforms from a spline and outputs the samples in an array.
rig::SplineInterpolateTransforms

Generates and samples a spline.
rig::SplineInterpolateTransformsToArray

Generates and samples a spline, and outputs the samples in an array.
rig::SplineOffset

Converts a spline offset between its various representations.
rig::SplineOffsets

Converts multiple spline offsets between their various representations.
rig::SplineOffsetsToArray

Converts multiple spline offsets between their various representations.
rig::TwoBoneIK

Solves a two-joint IK chain.
rig::UVConstraint

Constrains a transform onto the surface of a geometry at the given UV texture coordinate.
sim::CreateObject

Adds a new dynamics object to a simulation.
sim::CreateRelationship

Adds a new dynamics relationship to a simulation.
sim::CreateSubData

Attaches data to a simulation object or relationship.
sim::EvaluateAtTime

Returns the geometry from a simulation at a specified time.
sim::FindObject

Finds the unique ID of a simulation object by name.
sim::FindRelationship

Finds the unique ID of a simulation relationship by name.
sim::GetGeometry

Returns the geometry from a simulation object or a relationship’s subdata.
sim::LoadSimFile

Loads a simulation state from a file.
sim::RemoveObject

Removes an object from a simulation.
sim::RemoveRelationship

Removes a relationship from a simulation.
sim::SetGeometry

Modifies the geometry subdata for a simulation object or relationship.
sim::SimEngine

Creates a new dynamics simulation.
skel::AddJoint

Creates a new KineFX point on a geometry.
skel::Blend

Blends two skeletons.
skel::DeleteJoint

Deletes a KineFX point from a geometry.
skel::DeleteJoints

Deletes a group of KineFX points from a geometry.
skel::EvaluateMotionClip

Evaluates a single pose from a MotionClip.
skel::EvaluateMotionClipArray

Evaluates a single pose from multiple MotionClips.
skel::FindFirstJoint

Finds the first point number in a geometry that matches a pattern.
skel::FindJoint

Finds a KineFX point by its name attribute.
skel::FindJoints

Finds an array of point indices in a geometry that matches a pattern.
skel::FindRoots

Finds all the KineFX points that do not have a parent.
skel::GetAncestors

Finds all the ancestors of a KineFX point.
skel::GetChildren

Finds all the children of a KineFX point.
skel::GetDescendants

Finds all the descendants of a KineFX point.
skel::GetParent

Finds the parent of a KineFX point.
skel::GetPointLocalTransform

Returns the local transform attribute value of a KineFX point.
skel::GetPointLocalTransforms

Returns the local transforms of multiple KineFX points.
skel::GetPointTransform

Returns the world transform of a KineFX point.
skel::GetPointTransforms

Returns the world transforms of multiple KineFX points.
skel::SetParent

Sets a new parent for a KineFX point.
skel::SetParents

Sets new parents for multiple KineFX points.
skel::SetPointTransforms

Sets the world transforms of multiple KineFX points.
skel::SetPointTransformsFromAgent

Sets the world transforms of multiple KineFX points from an agent.
skel::SmoothMotion

Smooths out unwanted noise from a MotionClip and outputs a single skeleton with the smoothing applied.
skel::SmoothMotionArray

Smooths out unwanted noise from an array of skeletons and outputs a single skeleton with the smoothing applied.
skel::SmoothMotionClip

Smooths out unwanted noise from a MotionClip.
skel::Sort

Sorts the KineFX points in a geometry based on its hierarchy.
skel::Traverse

Traverses the whole KineFX hierarchy and writes out the result.
skel::UpdateJoint

Updates the attribute values of a KineFX point.
string::CamelCase

Converts a string to CamelCase style.
string::EndsWith

Determines if a string ends with a specific string.
string::Find

Finds the first occurrence of a substring.
string::ForceValidName

Ensures the string contains only valid characters.
string::Format

Creates a formatted string from input values.
string::FromInteger

Converts an integer to string.
string::FromRamp

Converts a ramp to a string.
string::Join

Returns a string that is the concatenation of the strings in an array.
string::Length

Computes the length of a string.
string::Lower

Converts a string to all lowercase.
string::Partition

Splits a string at the first or last instance of a partition substring.
string::PathSplit

Splits a path into a folder and file name.
string::PatternRename

Performs pattern replacement in a string.
string::RegexFind

Finds the first instance of a regular expression in a string.
string::RegexFindAll

Finds all instances of a regular expression in a string.
string::RegexMatch

Matches an input string against a regular expression.
string::RegexReplace

Replaces instances of a regular expression with a replacement string.
string::RegexSplit

Splits a string based on a regular expression.
string::Replace

Performs substring replacement in a string.
string::Reverse

Reverses a string.
string::Split

Splits a string into multiple tokens.
string::StartsWith

Determines if a string starts with a specific string.
string::SubString

Extracts a substring from a string.
string::ToFloat

Converts a string to a float.
string::ToInteger

Converts a string to an integer.
string::ToRamp

Converts a string to a ramp.
string::Upper

Converts a string to all uppercase.
transform::Blend

Blends between two matrices.
transform::Build

Builds a transformation matrix from transform components.
transform::ClampedLookAtPorthole

Limits the rotational range of a LookAt to a porthole on a sphere’s surface.
transform::ClampedLookAtWindow

Limits the rotational range of a LookAt to a window on a sphere’s surface.
transform::Determinant

Computes the determinant of a matrix.
transform::Dihedral

Computes a transformation representing the rotation between two vectors.
transform::Explode

Decomposes a matrix into its individual transformation components.
transform::LookAt

Rotates a matrix’s local look at axis toward a target.
transform::MirrorTransform

Mirrors a transformation matrix around a specified plane.
transform::MultiBlend

Blends multiple matrices or quaternions using a set of weights.
transform::MultiBlendFromArray

Blends an array of matrices or quaternions using an array of weights.
transform::PolarDecompose

Decomposes a matrix into rotation and stretch matrices using polar decomposition.
transform::Prerotate

Applies a prerotation to a matrix.
transform::Prescale

Applies a prescale to a matrix.
transform::Pretranslate

Applies a pretranslation to a matrix.
transform::ProjectOnSphere

Projects a point onto a sphere.
transform::ProjectOnSphericalPorthole

Projects a point onto a circular porthole on the surface of a sphere.
transform::ProjectOnSphericalWindow

Projects a point onto a rectangular window located on the surface of a sphere.
transform::Rotate

Applies a rotation to a matrix.
transform::RotateAboutAxis

Prerotates a matrix using an angle-axis rotation.
transform::Scale

Applies scaling to a matrix transformation.
transform::Slerp

Performs spherical linear interpolation.
transform::SmoothRotation

Finds the closest Euler angles to a reference rotation.
transform::Translate

Translates a matrix by a vector.
uievent::CurViewport

Fetches information about the viewport transform from the uievent.
uievent::Device

Fetches information about the pressed mouse button from the uievent.
uievent::Drag

Fetches information from the uievent about the position of the control at the start of a drag.
uievent::MousePosition

Fetches information about the state of the mouse from the uievent.
uievent::Ndc

Fetches information about the NDC transform and mouse position in NDC space.
uievent::PrimaryXform

Fetches information about the reference transforms on the primary control.
uievent::ScreenRay

Fetches information about the mouse ray from the uievent.
uievent::XformHandle

Fetches information about the transform handle interaction.