ch::CollectionSmoothAutoTangents

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

On this page	Inputs Outputs
Since	20.0

For each channel in a collection that has auto tangents enabled, this node computes the tangents of all the keys on that channel.

The channels ports of this node are in-place ports, which means that the collection of channels is updated without creating a copy.

Inputs ¶


                *channels:
                    ApexChannelCollection

Required

A collection of channels for which the auto tangents on its keys are computed.


                force:
                    Bool

If set to True, all auto tangents are recomputed.

Outputs ¶


                *channels:
                    ApexChannelCollection

The channels input with the computed auto tangents on its keys.

See also

APEX nodes

Abs

Computes the absolute value.
AbstractControl

Defines an abstract control in a rig.
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.
BoolToIntBitMask

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

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

Clamps a value between min and max.
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.
Equals

Returns True if two values are equal.
Exponent

Raises a value to an exponent.
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.
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.
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.
Matrix3ToVector3

Extracts the row vectors from a Matrix3.
Matrix4ToVector4

Extracts the row vectors from a Matrix4.
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.
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.
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.
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.
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::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::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::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::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.
component::AddAbstractControl

Adds an abstract control to a graph.
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::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::UpdateControls

Updates the control shape of a TransformObject node.
dict::Build

Copies a dictionary and adds new entries.
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::Insert

Adds new entries to a dictionary.
dict::Keys

Gets an array of 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::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::Bake

Bakes a dynamic path.
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::WriteToGeometry

Creates a geometry from a dynamic path.
fbik::GetBoneTransform

Gets the transform of a bone in an FBIK skeleton by name.
fbik::PhysIKSolver

Creates a PhysIKSolver from a FBIK skeleton.
fbik::SetComTarget

Sets the center of mass target on an FBIK solver.
fbik::SetSkeleton

Sets the skeleton on an FBIK solver.
fbik::SetTarget

Set a target on an FBIK solver with a bone name.
fbik::SetTargets

Sets multiple targets on an FBIK solver.
fbik::SetTargetsFromDict

Sets targets on an FBIK solver from a Dict.
fbik::SkeletonFromGeo

Gets a FBIK skeleton stored in geometry.
fbik::SkeletonUpdateGeo

Update geometry according to an FBIK skeleton.
fbik::SolvePhysIK

Solves an FBIK skeleton using using a solver.
fbik::Target

Creates a FBIK skeleton target.
geo::AddPacked

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

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

Returns the value of a detail attribute.
geo::DisplacePoints
geo::DragPoints
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::InitIntersectCache

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

Determines the intersection point of a ray with an intersection cache.
geo::IntersectPoints
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::PointPrims

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

Returns the value of a primitive attribute.
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 given name.
geo::SmoothPoints
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.
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::AddWirePath

Connects two APEX node ports.
graph::Compile

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

Connects two APEX node ports that are on the same nesting level of a graph.
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::DuplicateNode

Duplicates the input node.
graph::EvaluateOutputs

Evaluates outputs from an APEX graph.
graph::FindAndConnectInput

Connects two APEX node ports together.
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::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::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::LoadFromGeo

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::ReplaceNodeTag

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

Rewires the output ports on a node in an APEX graph.
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.
graph::WriteToGeo

Writes an APEX graph to geometry.
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::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::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::CombineParmTransform

Combines an input transform matrix and a set of translation, rotation, and scale parameters into a new transform.
rig::ControlSpline

Creates a spline of a given order using a list of CVs.
rig::ControlSplineFromArray

Creates a spline of a given order using an array of CVs.
rig::CurveConstraint

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

Extracts a local transform given a child and parent transform, taking scale inheritance rules into account.
rig::ExtractParmTransform
rig::FkTransform
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
rig::PointConstraint

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

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

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

Samples a variable number of transforms from a spline.
rig::SampleSplineTransformsToArray

Samples a given number of transforms from a spline.
rig::SplineInterpolateTransforms

Generates and samples a spline.
rig::SplineInterpolateTransformsArray

Generates and samples a spline.
rig::TwoBoneIK
rig::UVConstraint
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::DeleteJoint

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

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

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

Finds a KineFX point by its name attribute.
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::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::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::Find

Finds the first occurrence of a substring.
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::Length

Computes the length of a string.
string::Lower

Converts a string to all lowercase.
string::PatternRename

Performs pattern replacement in a string.
string::Replace

Performs substring replacement in a string.
string::Split

Splits a string into multiple tokens.
string::ToRamp

Converts a string to a ramp.
string::Upper

Converts a string to all uppercase.
transform::Blend

Blends between two matrices.
transform::Build
transform::Determinant
transform::Dihedral
transform::Explode
transform::LookAt

Rotates a matrix’s local look at axis toward a target.
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
transform::Prerotate

Applies a prerotation to the given matrix.
transform::Prescale

Prescales the given matrix in three directions simultaneously by the components of a vector.
transform::Pretranslate

Pretranslates a matrix by a vector.
transform::Rotate

Applies a rotation to the given matrix.
transform::RotateAboutAxis
transform::Scale

Scales the given matrix in three directions simultaneously by the components of a vector.
transform::Slerp

Performs spherical linear interpolation.
transform::SmoothRotation
transform::Translate

Translates a matrix by a vector.