步幅匹配

2025-11-30

字数统计: 4.1k字 | 阅读时长≈ 18分

步幅匹配

主要用于角色的循环移动动画，当角色完成起步后回进入循环移动动画，但角色的移动速度与动画的速度不匹配时依然会出现滑步的情况，所以我们通常会拿到角色的移动速度与动画的移动速度做比值来调整动画的播放速度从而使动画的移动与角色的速度相匹配。

除了动态调整循环动画的播放速度外，还需要调整角色的脚步步幅，一般来讲，当人的奔跑速度增加时，出了步频会增加外，步幅同样也会增加，所以为了防止角色的高速或低速情况下出现脚步鬼畜的情况，还需要对角色进行footik来调整步幅。

综上步幅匹配主要包括两部分：速度匹配和脚步ik

速度匹配

SpeedMatch

主要通过SetPlayrateToMatchSpeed来实现

/**
* Set the play rate of the sequence player so that the speed of the animation matches in-game movement speed.
* While distance matching is commonly used for transition animations, cycle animations (walk, jog, etc) typically just adjust their play rate to match
* the in-game movement speed.
* This function assumes that the animation has a constant speed.
* @param SequencePlayer - The sequence player node to operate on.
* @param SpeedToMatch - The in-game movement speed to match. This is usually the current speed of the movement component.
* @param PlayRateClamp - A clamp on how much the animation's play rate can change to match the in-game movement speed. Set to (0,0) for no clamping.
*/
UFUNCTION(BlueprintCallable, Category = "Distance Matching", meta=(BlueprintThreadSafe))
static FSequencePlayerReference SetPlayrateToMatchSpeed(const FSequencePlayerReference& SequencePlayer, 
    float SpeedToMatch, FVector2D PlayRateClamp = FVector2D(0.75f, 1.25f));

注释为：根据角色在游戏中的移动速度来设置动画的播放速度

SequencePlayer：序列播放器，包含需要播放的动画序列
SpeedToMatch：需要匹配的移动速度，通常为角色的地面移动速度
PlayRateClamp：播放速度的上下限，默认为0.75到1.25

FSequencePlayerReference UAnimDistanceMatchingLibrary::SetPlayrateToMatchSpeed(const FSequencePlayerReference& SequencePlayer, float SpeedToMatch, FVector2D PlayRateClamp)
{
    // 绑定了一个lambda函数作为参数一并传入CallAnimNodeFunction中被调用
	SequencePlayer.CallAnimNodeFunction<FAnimNode_SequencePlayer>(
		TEXT("SetPlayrateToMatchSpeed"),
		[SpeedToMatch, PlayRateClamp](FAnimNode_SequencePlayer& InSequencePlayer)
		{
            // 获取当前播放的动画序列
			if (const UAnimSequence* AnimSequence = Cast<UAnimSequence>(InSequencePlayer.GetSequence()))
			{
                // 获取序列的长度，如果长度大于0则进行调整
				const float AnimLength = AnimSequence->GetPlayLength();
				if (!FMath::IsNearlyZero(AnimLength))
				{
					// Calculate the speed as: (distance traveled by the animation) / (length of the animation)
                    // 获取动画从开始到结束的根运动距离并计算平面的移动距离
					const FVector RootMotionTranslation = AnimSequence->ExtractRootMotionFromRange(0.0f, AnimLength).GetTranslation();
					const float RootMotionDistance = RootMotionTranslation.Size2D();
                    // 当角色的移动距离大于0时则进行调整
					if (!FMath::IsNearlyZero(RootMotionDistance))
					{
                        // 获取动画速度
						const float AnimationSpeed = RootMotionDistance / AnimLength;
                        // 获取速度当前的移动速度与动画的速度的比值
						float DesiredPlayRate = SpeedToMatch / AnimationSpeed;
						if (PlayRateClamp.X >= 0.0f && PlayRateClamp.X < PlayRateClamp.Y)
						{
							DesiredPlayRate = FMath::Clamp(DesiredPlayRate, PlayRateClamp.X, PlayRateClamp.Y);
						}

						// 根据比值来动态调整动画的播放速度
						if (!InSequencePlayer.SetPlayRate(DesiredPlayRate))
						{
							UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Could not set play rate on sequence player, value is not dynamic. Set it as Always Dynamic."));
						}
					}
					else
					{
						UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Unable to adjust playrate for animation with no root motion delta (%s)."), *GetNameSafe(AnimSequence));
					}
				}
				else
				{
					UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Unable to adjust playrate for zero length animation (%s)."), *GetNameSafe(AnimSequence));
				}
			}
			else
			{
				UE_LOG(LogAnimDistanceMatchingLibrary, Warning, TEXT("Sequence player does not have an anim sequence to play."));
			}
		});

	return SequencePlayer;
}

脚步IK

主要是通过跨步扭曲(StrideWarping)来实现。

StrideWarping

在细节面板中展示了需要调整的选项，主要为添加需要进行匹配的脚步骨骼，StrideWarping节点本身需要传入开始混入的alpha值(skeleton control的强度)以及角色地面的移动速度（MatchSpeed）。

该节点定义在UAnimGraphNode_StrideWarping中，其中最主要的内容为声明的一个FAnimNode_StrideWarping类型的成员变量Node，在这个Node中定义了大多在细节面板中使用到的属性，同时还包括一些节点使用的初始化和更新方法。

初始化

其中初始化方法为:Initialize_AnyThread

void FAnimNode_StrideWarping::Initialize_AnyThread(const FAnimationInitializeContext& Context)
{
	FAnimNode_SkeletalControlBase::Initialize_AnyThread(Context);
	
    // 初始化代理
	AnimInstanceProxy = Context.AnimInstanceProxy;
	// 用于夹值和插值
    StrideScaleModifierState.Reinitialize();
	// 初始化朝向
    ActualStrideDirection = FVector::ForwardVector;
	// 初始化步幅
    ActualStrideScale = 1.f;
#if WITH_EDITORONLY_DATA
    // 调试模式下使用，获取根骨骼的位移和速度
	CachedRootMotionDeltaTranslation = FVector::ZeroVector;
	CachedRootMotionDeltaSpeed = 0.f;
#endif
}

其中还有另一个初始化方法:InitializeBoneReferences，这个方法用于初始化我们在节点中写入的骨骼引用

更新

其中更新的方法为:EvaluateSkeletalControl_AnyThread，这是更新的主要方法，也是进行跨步扭曲的核心方法，接下来将对这个方法进行解析。

void FAnimNode_StrideWarping::EvaluateSkeletalControl_AnyThread(FComponentSpacePoseContext& Output, TArray<FBoneTransform>& OutBoneTransforms)
{
	SCOPE_CYCLE_COUNTER(STAT_StrideWarping_Eval);
	check(OutBoneTransforms.IsEmpty());

	// 获取当前帧的跨步朝向以及上一帧的朝向
	const FVector PreviousStrideDirection = ActualStrideDirection;
	ActualStrideDirection = StrideDirection;
	// 跨步缩放值->步幅的大小
	ActualStrideScale = StrideScale;

	// 是否使用图表模式
	bool bGraphDrivenWarping = false;
	// 获取根运动提取器,如果改提取器是有效的则使用图表模式
	const UE::Anim::IAnimRootMotionProvider* RootMotionProvider = UE::Anim::IAnimRootMotionProvider::Get();

	// 判断是否为图表模式,在节点的细节面板中可以选择
	if (Mode == EWarpingEvaluationMode::Graph)
	{
		bGraphDrivenWarping = !!RootMotionProvider;
		ensureMsgf(bGraphDrivenWarping, TEXT("Graph driven Stride Warping expected a valid root motion delta provider interface."));
	}

	// 初始化运动距离
	FTransform RootMotionTransformDelta = FTransform::Identity;
#if WITH_EDITORONLY_DATA
	// 编辑器下的调试设置
	bFoundRootMotionAttribute = false;
#else
	FVector CachedRootMotionDeltaTranslation = FVector::ZeroVector;
#endif
	if (bGraphDrivenWarping)
	{
		// 如果根运动是有效的话则提取根运动
		// Output的含义:在AnimInstance更新时会从Root开始递归更新骨骼的pose,这个output就是动画节点左边的连线所计算的pose
		// Graph driven stride warping will override the manual stride direction with the intent of the current animation sub-graph's accumulated root motion
		bGraphDrivenWarping = RootMotionProvider->ExtractRootMotion(Output.CustomAttributes, RootMotionTransformDelta);
		if (bGraphDrivenWarping)
		{
			// 缓存根运动的位移数据
			CachedRootMotionDeltaTranslation = RootMotionTransformDelta.GetTranslation();
			// If there's no root motion delta, keep the previous stride direction
			// 根据两帧之间的位移差值拿到运动的朝向
			ActualStrideDirection = CachedRootMotionDeltaTranslation.GetSafeNormal(UE_SMALL_NUMBER, PreviousStrideDirection);
#if WITH_EDITORONLY_DATA
			// Graph driven Stride Warping expects a root motion delta to be present in the attribute stream.
			// 编辑器下的调试设置
			bFoundRootMotionAttribute = true;
#endif
		}
		// Early exit on missing root motion delta attribute
		// 否则说明在图表模式下没有开启根运动,提前返回
		else if (bDisableIfMissingRootMotion)
		{
			return;
		}
	}

	// 拿到output中的骨骼数据
	const FBoneContainer& RequiredBones = Output.Pose.GetPose().GetBoneContainer();
	// 从output的骨骼数据中拿到脚步ik骨骼的空间网格体数据
	const FTransform IKFootRootTransform = Output.Pose.GetComponentSpaceTransform(IKFootRootBone.GetCompactPoseIndex(RequiredBones));
	// 获取地面的法线向量,一般为(0, 0, 1)
	const FVector ResolvedFloorNormal = FloorNormalDirection.AsComponentSpaceDirection(AnimInstanceProxy, IKFootRootTransform);
	// 获取重力方向,一般默认向下(0 ,0, -1)
	const FVector ResolvedGravityDirection = GravityDirection.AsComponentSpaceDirection(AnimInstanceProxy, IKFootRootTransform);

	// 是否使用地面方向来旋转跨步朝向
	// 根据下面的计算可以得到:
	// 首先将实际跨步方向和地面法线方向进行叉乘,可以得到横向的轴向向量
	// 再将轴向向量和地面法向向量进行叉乘得到实际方向
	// 主要用来处理一些上下坡等非水平面的运动方向
	if (bOrientStrideDirectionUsingFloorNormal)
	{
		const FVector StrideWarpingAxis = ResolvedFloorNormal ^ ActualStrideDirection;
		ActualStrideDirection = StrideWarpingAxis ^ ResolvedFloorNormal;
	}

#if ENABLE_ANIM_DEBUG
	bool bDebugging = false;
#if WITH_EDITORONLY_DATA
	bDebugging = bDebugging || bEnableDebugDraw;
#else
	constexpr float DebugDrawScale = 1.f;
#endif
	bDebugging = bDebugging || CVarAnimNodeStrideWarpingDebug.GetValueOnAnyThread() == 1;
	if (bDebugging)
	{
		// 绘制骨骼信息用于调试
		// Draw Floor Normal
		AnimInstanceProxy->AnimDrawDebugDirectionalArrow(
			AnimInstanceProxy->GetComponentTransform().TransformPosition(IKFootRootTransform.GetLocation()),
			AnimInstanceProxy->GetComponentTransform().TransformPosition(IKFootRootTransform.GetLocation() + ResolvedFloorNormal * 25.f * DebugDrawScale),
			40.f * DebugDrawScale, FColor::Blue, false, 0.f, 2.f * DebugDrawScale);
	}
#endif

	// Get all foot IK Transforms
	// FootData在InitializeBoneReferences中初始化,数据来源与output一致,从节点左边输出的骨骼数据中获取
	for (auto& Foot : FootData)
	{
		Foot.IKFootBoneTransform = Output.Pose.GetComponentSpaceTransform(Foot.IKFootBoneIndex);
#if ENABLE_ANIM_DEBUG
		if (bDebugging
#if WITH_EDITORONLY_DATA
			&& bDebugDrawIKFootOrigin
#endif
		)
		{
			const FVector FootWorldLocation = AnimInstanceProxy->GetComponentTransform().TransformPosition(Foot.IKFootBoneTransform.GetLocation());
			AnimInstanceProxy->AnimDrawDebugSphere(FootWorldLocation, 8.f * DebugDrawScale, 16, FColor::Red);
		}
#endif
	}

	// 如果开启根运动则对实际步幅进行调整
	if (bGraphDrivenWarping)
	{
		// CachedRootMotionDeltaSpeed,存储根运动的速度
#if WITH_EDITORONLY_DATA
		CachedRootMotionDeltaSpeed = CachedRootMotionDeltaTranslation.Size() / CachedDeltaTime;
#else
		const float CachedRootMotionDeltaSpeed = CachedRootMotionDeltaTranslation.Size() / CachedDeltaTime;
#endif

		// 如果速度小于根运动的最小移动速度则不调整步幅
		// 否则根据实际速度对步幅进行等比缩放
		if (CachedRootMotionDeltaSpeed <= MinRootMotionSpeedThreshold)
		{
			// If root motion speed is under the threshold, snap back to no stride adjustment.
			// If interpolation is on, it will blend the result
			ActualStrideScale = 1.0f;
		}
		else
		{
			// Graph driven stride scale factor will be determined by the ratio of the
			// locomotion (capsule/physics) speed against the animation root motion speed
			ActualStrideScale = LocomotionSpeed / CachedRootMotionDeltaSpeed;
		}
	}

	// Allow the opportunity for stride scale clamping and interpolation regardless of evaluation mode
	// 翻译无论采用哪种模式(EWarpingEvaluationMode中的定义),都对步幅进行夹值和插值(可能是用于平滑过渡)
	ActualStrideScale = StrideScaleModifierState.ApplyTo(StrideScaleModifier, ActualStrideScale, CachedDeltaTime);

	// 如果开启了根运动则根据实际的步幅大小对运动位移进行缩放
	// 同时尝试对输入的骨骼数据使用缩放后的位移数据进行覆盖
	if (bGraphDrivenWarping)
	{
		// Forward the side effects of stride warping on the root motion contribution for this sub-graph
		RootMotionTransformDelta.ScaleTranslation(ActualStrideScale);
		const bool bRootMotionOverridden = RootMotionProvider->OverrideRootMotion(RootMotionTransformDelta, Output.CustomAttributes);
		ensureMsgf(bRootMotionOverridden, TEXT("Graph driven Stride Warping expected a root motion delta to be present in the attribute stream prior to warping/overriding it."));
	}

	// 处理脚步ik
	// Scale IK feet bones along Stride Warping Axis, from the Thigh bone location.
	// 翻译:从大腿骨开始沿着跨步扭曲的轴向对脚步ik数据进行缩放
	for (auto& Foot : FootData)
	{
		// Stride Warping along Stride Warping Axis
		// 获取脚步ik骨骼的位置以及大腿骨的位置
		const FVector IKFootLocation = Foot.IKFootBoneTransform.GetLocation();
		const FVector ThighBoneLocation = Output.Pose.GetComponentSpaceTransform(Foot.ThighBoneIndex).GetLocation();

		// Project Thigh Bone Location on plane made of FootIKLocation and FloorPlaneNormal, along Gravity Dir.
		// 翻译:沿着重力方向将大腿骨的位置投影在由脚步ik骨的位置和地面法线所组成的平面上
		// LinePlaneIntersection:线平面交点
		// This will be the StrideWarpingPlaneOrigin
		// 首先判断重力和地面法线是否平行,如果平行,则直接使用脚步ik骨骼的位置
		// 否则进行投影:以脚步ik骨的位置作为平面的原点,以地面的法线作为平面的法线得到一个片面,将大腿骨的位置沿着重力的方向投影在这个平面上
		// 实际得到的就是大腿骨在脚步ik骨位置的运动平面上的投影位置
		const FVector StrideWarpingPlaneOrigin = (FMath::Abs(ResolvedGravityDirection | ResolvedFloorNormal) > DELTA) ? FMath::LinePlaneIntersection(ThighBoneLocation, ThighBoneLocation + ResolvedGravityDirection, IKFootLocation, ResolvedFloorNormal) : IKFootLocation;

		// Project FK Foot along StrideWarping Plane, this will be our Scale Origin
		// 翻译:将脚步ik骨的位置投影在跨步平面上(运动平面)
		// 以上一步得到的投影位置作为平面的原点,实际的运动方向作为该平面的法线构造平面
		// 计算脚步ik骨在这个平面上的投影
		const FVector ScaleOrigin = FVector::PointPlaneProject(IKFootLocation, StrideWarpingPlaneOrigin, ActualStrideDirection);

		// 由IKFootLocation和ScaleOrigin可以计算出脚步ik骨的运动方向,再乘以实际的步幅加上投影位置就是新的脚步骨骼应该在的位置
		// Now the ScaleOrigin and IKFootLocation are forming a line parallel to the floor, and we can scale the IK foot.
		const FVector WarpedLocation = ScaleOrigin + (IKFootLocation - ScaleOrigin) * ActualStrideScale;
		Foot.IKFootBoneTransform.SetLocation(WarpedLocation);

#if ENABLE_ANIM_DEBUG
		if (bDebugging
#if WITH_EDITORONLY_DATA
			&& bDebugDrawIKFootAdjustment
#endif
		)
		{
			const FVector FootWorldLocation = AnimInstanceProxy->GetComponentTransform().TransformPosition(Foot.IKFootBoneTransform.GetLocation());
			AnimInstanceProxy->AnimDrawDebugSphere(FootWorldLocation, 8.f * DebugDrawScale, 16, FColor::Green);

			const FVector ScaleOriginWorldLoc = AnimInstanceProxy->GetComponentTransform().TransformPosition(ScaleOrigin);
			AnimInstanceProxy->AnimDrawDebugSphere(ScaleOriginWorldLoc, 8.f * DebugDrawScale, 16, FColor::Yellow);
		}
#endif
	}

	// 开始计算盆骨偏移,首先进行初始化
	FVector PelvisOffset = FVector::ZeroVector;
	const FCompactPoseBoneIndex PelvisBoneIndex = PelvisBone.GetCompactPoseIndex(RequiredBones);

	// 获取盆骨的位置信息并初始化盆骨的位置
	FTransform PelvisTransform = Output.Pose.GetComponentSpaceTransform(PelvisBoneIndex);
	const FVector InitialPelvisLocation = PelvisTransform.GetLocation();

	// 声明一个容器用于存储所有FK骨骼到盆骨的距离
	TArray<float, TInlineAllocator<10>> FKFootDistancesToPelvis;
	FKFootDistancesToPelvis.Reserve(FootData.Num());

	// 声明一个容器储存所有IK骨骼的位置
	TArray<FVector, TInlineAllocator<10>> IKFootLocations;
	IKFootLocations.Reserve(FootData.Num());

	// 遍历脚步ik骨骼的数据并获取距离和位置信息
	for (auto& Foot : FootData)
	{
		const FVector FKFootLocation = Output.Pose.GetComponentSpaceTransform(Foot.FKFootBoneIndex).GetLocation();
		FKFootDistancesToPelvis.Add(FVector::Dist(FKFootLocation, InitialPelvisLocation));

		const FVector IKFootLocation = Foot.IKFootBoneTransform.GetLocation();
		IKFootLocations.Add(IKFootLocation);
	}

	// Adjust Pelvis down if needed to keep foot contact with the ground and prevent over-extension
	// 翻译:将盆骨的位置向下进行调整以保证脚步解除地面同时防止过度拉伸
	PelvisTransform = PelvisIKFootSolver.Solve(PelvisTransform, FKFootDistancesToPelvis, IKFootLocations, CachedDeltaTime);

#if ENABLE_ANIM_DEBUG
	if (bDebugging
#if WITH_EDITORONLY_DATA
		&& bDebugDrawPelvisAdjustment
#endif
	)
	{
		// Draw Adjustments in Pelvis location
		AnimInstanceProxy->AnimDrawDebugSphere(AnimInstanceProxy->GetComponentTransform().TransformPosition(InitialPelvisLocation), 8.f * DebugDrawScale, 16, FColor::Red);
		AnimInstanceProxy->AnimDrawDebugSphere(AnimInstanceProxy->GetComponentTransform().TransformPosition(PelvisTransform.GetLocation()), 8.f * DebugDrawScale, 16, FColor::Blue);
	}

	if (bDebugging)
	{
		// Draw Stride Direction
		AnimInstanceProxy->AnimDrawDebugDirectionalArrow(
			AnimInstanceProxy->GetComponentTransform().TransformPosition(InitialPelvisLocation),
			AnimInstanceProxy->GetComponentTransform().TransformPosition(InitialPelvisLocation + ActualStrideDirection * ActualStrideScale * 100.f * DebugDrawScale),
			40.f * DebugDrawScale, FColor::Red, false, 0.f, 2.f * DebugDrawScale);

		// Draw text on mesh in world space
		{
			TStringBuilder<1024> DebugLine;

			DebugLine.Appendf(TEXT("\n - Stride Scale: (%.3fd)"), ActualStrideScale);
			DebugLine.Appendf(TEXT("\n - Stride Direction: (%s)"), *(ActualStrideDirection.ToCompactString()));
			
			if (Mode == EWarpingEvaluationMode::Graph)
			{
				DebugLine.Appendf(TEXT("\n - Locomotion Speed: (%.3fd)"), LocomotionSpeed);

#if WITH_EDITORONLY_DATA
				if (bFoundRootMotionAttribute)
				{
					DebugLine.Appendf(TEXT("\n - Root Motion: Direction(%s), Speed(%.3fd)"), *(CachedRootMotionDeltaTranslation.GetSafeNormal().ToCompactString()), CachedRootMotionDeltaSpeed);
				}
				else
				{
					DebugLine.Appendf(TEXT("\n - Root Motion: NO ATTRIBUTE FOUND"), *(ActualStrideDirection.ToCompactString()));
				}
#endif

				DebugLine.Appendf(TEXT("\n - Min Root Motion Speed Threshold: (%.3fd)"), MinRootMotionSpeedThreshold);
			}

			AnimInstanceProxy->AnimDrawDebugInWorldMessage(DebugLine.ToString(), FVector::UpVector * 50.0f, FColor::Yellow, 1.f /*TextScale*/);
		}
	}
#endif
	// Add adjusted pelvis transform
	check(!PelvisTransform.ContainsNaN());
	// 将盆骨偏移后的位置数据添加到输出骨骼中
	OutBoneTransforms.Add(FBoneTransform(PelvisBoneIndex, PelvisTransform));

	// Compute final offset to use below
	// 获取盆骨调整后的差值
	PelvisOffset = (PelvisTransform.GetLocation() - InitialPelvisLocation);

	// Rotate Thigh bones to help IK, and maintain leg shape.
	// 翻译:旋转大腿骨骼以适配脚步ik,同时保证腿部的形状(应该是为了防止位移过大导致变形)
	if (bCompensateIKUsingFKThighRotation)
	{
		for (auto& Foot : FootData)
		{
			// 获取大腿骨位置和脚步位置
			const FTransform ThighTransform = Output.Pose.GetComponentSpaceTransform(Foot.ThighBoneIndex);
			const FTransform FKFootTransform = Output.Pose.GetComponentSpaceTransform(Foot.FKFootBoneIndex);

			// 将盆骨偏移应用的大腿骨的位置中
			FTransform AdjustedThighTransform = ThighTransform;
			AdjustedThighTransform.AddToTranslation(PelvisOffset);

			// 获取当前的脚步-大腿朝向以及目标的脚步-大腿朝向
			const FVector InitialDir = (FKFootTransform.GetLocation() - ThighTransform.GetLocation()).GetSafeNormal();
			const FVector TargetDir = (Foot.IKFootBoneTransform.GetLocation() - AdjustedThighTransform.GetLocation()).GetSafeNormal();
			
#if ENABLE_ANIM_DEBUG
			if (bDebugging
#if WITH_EDITORONLY_DATA
				&& bDebugDrawThighAdjustment
#endif
			)
			{
				AnimInstanceProxy->AnimDrawDebugLine(
					AnimInstanceProxy->GetComponentTransform().TransformPosition(ThighTransform.GetLocation()),
					AnimInstanceProxy->GetComponentTransform().TransformPosition(FKFootTransform.GetLocation()),
					FColor::Red, false, 0.f, 2.f * DebugDrawScale);

				AnimInstanceProxy->AnimDrawDebugLine(
					AnimInstanceProxy->GetComponentTransform().TransformPosition(AdjustedThighTransform.GetLocation()),
					AnimInstanceProxy->GetComponentTransform().TransformPosition(Foot.IKFootBoneTransform.GetLocation()),
					FColor::Green, false, 0.f, 2.f * DebugDrawScale);
			}
#endif
			// Find Delta Rotation take takes us from Old to New dir
			// 获取两个方向之间的旋转值
			const FQuat DeltaRotation = FQuat::FindBetweenNormals(InitialDir, TargetDir);

			// Rotate our Joint quaternion by this delta rotation
			// 将旋转值应用值大腿骨
			AdjustedThighTransform.SetRotation(DeltaRotation * AdjustedThighTransform.GetRotation());

			// Add adjusted thigh transform
			check(!AdjustedThighTransform.ContainsNaN());
			// 将调整后的骨骼添加到输出中
			OutBoneTransforms.Add(FBoneTransform(Foot.ThighBoneIndex, AdjustedThighTransform));

			// Clamp IK Feet bone based on FK leg. To prevent over-extension and preserve animated motion.
			// 通过大腿的FK限制脚步IK防止腿部过度拉伸
			// 如果调整后的脚步IK骨与调整后的大腿骨的距离大于FK的距离则使用FK的距离重新调整这个脚步IK的位置
			if (bClampIKUsingFKLimits)
			{
				const float FKLength = FVector::Dist(FKFootTransform.GetLocation(), ThighTransform.GetLocation());
				const float IKLength = FVector::Dist(Foot.IKFootBoneTransform.GetLocation(), AdjustedThighTransform.GetLocation());
				if (IKLength > FKLength)
				{
					const FVector ClampedFootLocation = AdjustedThighTransform.GetLocation() + TargetDir * FKLength;
					Foot.IKFootBoneTransform.SetLocation(ClampedFootLocation);
				}
			}
		}
	}

	// Add final IK feet transforms
	// 将调整后的脚步数据应用到输出数据中
	for (auto& Foot : FootData)
	{
#if ENABLE_ANIM_DEBUG
		if (bDebugging
#if WITH_EDITORONLY_DATA
			&& bDebugDrawIKFootFinal
#endif
		)
		{
			AnimInstanceProxy->AnimDrawDebugSphere(AnimInstanceProxy->GetComponentTransform().TransformPosition(Foot.IKFootBoneTransform.GetLocation()), 8.f * DebugDrawScale, 16, FColor::Blue);
		}
#endif
		check(!Foot.IKFootBoneTransform.ContainsNaN());
		OutBoneTransforms.Add(FBoneTransform(Foot.IKFootBoneIndex, Foot.IKFootBoneTransform));
	}

	// Sort OutBoneTransforms so indices are in increasing order.
	// 按照骨骼树的位置对骨骼进行排序让其对应骨骼树中的索引
	OutBoneTransforms.Sort(FCompareBoneTransformIndex());
}

更新流程:

获取实际的运动方向和运动速度
根据速度和方向调整脚步的位置
调整盆骨位置
根据盆骨的偏移和大腿的旋转限制脚步的位置
将调整后的骨骼数据添加到输出中并按照骨骼树进行排序

流程图

flowchart TD
    A[开始步幅匹配] --> B{匹配模式选择}
    
    B --> C[速度匹配模式]
    B --> D[脚步IK模式]
    
    %% 速度匹配分支
    subgraph C [速度匹配流程]
        direction LR
        C1[循环移动动画] --> C2[计算动画固有速度<br/>根运动距离/动画时长]
        C2 --> C3[计算速度比值<br/>角色速度/动画速度]
        C3 --> C4[应用播放速率<br/>限制范围:0.75-1.25]
        C4 --> C5[速度匹配完成]
    end
    
    %% 脚步IK分支
    subgraph D [脚步IK流程]
        direction LR
        D1[获取运动参数<br/>方向与速度] --> D2[计算步幅缩放比例<br/>角色速度/根运动速度]
        D2 --> D3[脚步骨骼空间投影<br/>基于运动平面]
        D3 --> D4[应用步幅缩放<br/>调整骨骼位置]
        D4 --> D5[盆骨偏移计算<br/>保持腿部形态]
        D5 --> D6[大腿旋转补偿<br/>防止过度拉伸]
        D6 --> D7[应用所有骨骼调整]
        D7 --> D8[脚步IK完成]
    end
    
    C5 --> E[动态调整步频<br/>保持动画节奏]
    D8 --> F[调整步幅大小<br/>防止鬼畜现象]
    
    E --> G[自然流畅的循环移动]
    F --> G

本文作者： KongXinQing
本文链接： https://13114987559.github.io/2025/11/30/essay/步幅匹配/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！