Introduction

Anim Pose Space, which is widely used across the Anim Graph.

Generally speaking, most nodes, except Aim Offset and Layered Bone Blend node, work in local space if its pose pins are shaded white:

and in component space if its pose pins are shaded blue:

Pose Input Pins

But what’s the key difference between a local space pose and a component space pose? What is happening deep inside when a space conversion is performed?

Local&Component Space Pose

Local Pose

You should override Evaluate_AnyThread(FPoseContext& Output) function if the node is calculated in local space. A FPoseContext, a struct containing a pose and a curve, is passed across animation nodes in Anim Graph Tree:

/** Evaluation context passed around during animation tree evaluation */
struct FPoseContext : public FAnimationBaseContext
{
public:
	/* These Pose/Curve is stack allocator. You should not use it outside of stack. */
	FCompactPose	Pose;
	FBlendedCurve	Curve;

This pose is in local space, which means that each bone’s transformation matrix is in relation to its parent bone.

Component Pose

You should override EvaluateComponentSpace_AnyThread(FComponentSpacePoseContext& Output) function if the node is calculated in component space.

A FComponentSpacePoseContext contains a FCSPose<FCompactPose> instead of a FCompactPose:

/** Evaluation context passed around during animation tree evaluation */
struct FComponentSpacePoseContext : public FAnimationBaseContext
{
public:
	FCSPose<FCompactPose>	Pose;
	FBlendedCurve			Curve;

The key difference between a FCSPose<FCompactPose> and a FCompactPose, in my opinion, is the ComponentSpaceFlags:

1 2	// Flags to track each bones current state (0 means local pose, 1 means component space pose) TCustomBoneIndexArray<uint8, BoneIndexType> ComponentSpaceFlags;

This is an array to track each bone’s current state (0 means local pose, 1 means component space pose).

Space Conversion

Local To Component

FAnimNode_ConvertLocalToComponentSpace is used to convert pose from local space to component space:

This is a cheap node because no matrix calculation is actually performed. UE4 use lazy calculation for FCSPose<FCompactPose>. In other words, a bone’s component space transform is calculated only when needed.

Lazy Calculation

Think about a pose like this:

It can be easily see that all bone’s transform are in local space. Now, after a FAnimNode_ConvertLocalToComponentSpace node is evaluated, this transformation matrix is not changed at all.

When we need to use a Skeletal Control Node, let’s say, a Transform (Modify) Bone to process bone D in component space:

During evaluation of this node, FA2CSPose::CalculateComponentSpaceTransform function would be called to recursively calculate component space transform of bone D, C, B andA:

/** Calculate all transform till parent **/
void FA2CSPose::CalculateComponentSpaceTransform(int32 BoneIndex)
{
	check( ComponentSpaceFlags[BoneIndex] == 0 );
	checkSlow( IsValid() );

	// root is already verified, so root should not come here
	// check AllocateLocalPoses
	const int32 ParentIndex = BoneContainer->GetParentBoneIndex(BoneIndex);

	// if Parent already has been calculated, use it
	if( ComponentSpaceFlags[ParentIndex] == 0 )
	{
		// if Parent hasn't been calculated, also calculate parents
		CalculateComponentSpaceTransform(ParentIndex);
	}

	// current Bones(Index) should contain LocalPoses.
	Bones[BoneIndex] = Bones[BoneIndex] * Bones[ParentIndex];
	Bones[BoneIndex].NormalizeRotation();
	ComponentSpaceFlags[BoneIndex] = 1;
}