Unreal 骨骼动画源码剖析
概览
在 UE 中，骨骼动画相关类型关系如下：
其中，USkeletalMesh 是骨架网格体模型数据对象。USkinnedMeshComponent 支持了对骨架网格体的渲染，通过 FSkeletalMeshObject 将渲染所需数据发送到渲染线程，具体的渲染方式也由这个对象决定，例如使用 CPU 还是 GPU 进行渲染。 USkeletalMeshComponent 在此基础上支持了骨骼动画播放，具体动画播放逻辑由 UAnimInstance 实现。
在 USkinnedMeshComponent 的 TickComponent 中，会根据当前渲染状态和 tick 设置去决定是否要调用 TickPose 和 RefreshBoneTransforms。例如我们可以配置 Only Tick Pose When Rendered 来避免一个对象在不被渲染的时候 tick 动画。另外，当一个对象被配置了 master pose component 的时候，RefreshBoneTransforms 这个函数就不会被回调，引擎会直接使用 master pose component 的 transform 数据。
这里的 RefreshBoneTransforms 需要每个继承了 USkinnedMeshComponent 的类型自行实现，用以更新骨骼的位置。除此之外，USkeletalMeshComponent 也重写了 TickPose，在里面调用了 TickAnimation 函数更新动画。
动画更新
USkeletalMeshComponent 的 TickAnimation 调用了 TickAnimInstances，这个是动画的主逻辑：
void USkeletalMeshComponent::TickAnimation(...) {
if (!AreRequiredCurvesUpToDate()) {
// 基于 RequiredBones 计算所需要更新的曲线
RecalcRequiredCurves();
}
TickAnimInstances(DeltaTime, bNeedsValidRootMotion);
// ...
}
TickAnimInstances 会触发 UAnimInstance 的 UpdateAnimation 以计算当前帧动画的变量、收集动画通知、更新动画曲线等，这里会分别调用几个 animation instance 的 UpdateAnimation 方法：
void USkeletalMeshComponent::TickAnimInstances(...) {
for (UAnimInstance* LinkedInstance : LinkedInstances) {
LinkedInstance->UpdateAnimation(...);
}
if (AnimScriptInstance != nullptr) {
AnimScriptInstance->UpdateAnimation(...);
}
if(ShouldUpdatePostProcessInstance()) {
PostProcessAnimInstance->UpdateAnimation(...);
}
}
UAnimInstance 就是动画蓝图对象的类型。上面的 LinkedInstances 用于将动画模块化，具体使用可以参考 Animation Blueprint Linking，PostProcessAnimInstance 主要用于进行 IK 计算、物理骨骼计算、表情动画叠加等。AnimScriptInstance 是主动画蓝图对象，主要的动画计算都在此完成。
UAnimInstance 的 UpdateAnimation 这个过程分为几个阶段：
- Pre Update
- Update
- Parallel Update
- Post Update
void UAnimInstance::UpdateAnimation(...) {
// 获取 proxy 对象
FAnimInstanceProxy& Proxy = GetProxyOnGameThread<FAnimInstanceProxy>();
// > 主流程 1 Pre Update
PreUpdateAnimation(DeltaSeconds);
// > 主流程 2 Update
NativeUpdateAnimation(DeltaSeconds);
BlueprintUpdateAnimation(DeltaSeconds);
// 根据配置选择是否并行执行，如果无法并行，就在这里使用主线程来完成计算，
// 一般来说都会使用并行计算，不会在这里直接执行
bool bShouldImmediateUpdate = /* ... */;
if(bShouldImmediateUpdate) {
// > 主流程 3 Parallel Update
ParallelUpdateAnimation();
// > 主流程 4 Post Update
PostUpdateAnimation();
}
}
FAnimInstanceProxy 是一个用于多线程优化动画系统的结构体，它存放了大量有关 UAnimInstance 的数据，可以被多线程访问，用于在工作线程上执行动画图形节点的更新和计算。
UAnimInstance::PreUpdateAnimation 对动画通知数据和 RootMotion 混合数据进行重置，然后调用 FAnimInstanceProxy::PreUpdate 进行代理更新，这个代理的更新其实就是进行常规赋值操作，比如给 RootMotionMode、SkelMeshCompLocalToWorld、UngroupedActivePlayers、SyncGroups、ComponentTransform、ComponentRelativeTransform、ActorTransform 等赋值。
UAnimInstance::NativeUpdateAnimation 用于给子类增加 C++ 层的计算逻辑，一般会在这里实现数据收集工作，然后在 UAnimInstance 的 NativeThreadSafeUpdateAnimation 函数中具体进行动画处理。这个 NativeThreadSafeUpdateAnimation 会在工作线程中被 proxy 对象在 UpdateAnimation_WithRoot 中调用。这两个函数实现在 C++ 层，其蓝图对应为 BlueprintUpdateAnimation 和 BlueprintThreadSafeUpdateAnimation 。这两个蓝图的对应函数往往为实际使用最多的部分，蓝图中的状态机、动画节点均在此进行控制。
接下来会根据是否使用并行动画计算来决定是否在此处调用 ParallelUpdateAnimation 和 PostUpdateAnimation，一般来说，都不会在此进行。接下来应该就会进入前面提到的 RefreshBoneTransforms 这一步了。
更新骨骼 Transform
USkeletalMeshComponent 的 RefreshBoneTransforms 中会确定当前帧是否需要更新骨骼 transform 数据，例如在执行 URO 的时候，可能这一帧会被跳过，在需要更新时，根据配置确定是并行更新还是串行更新（一般都是并行）：
void USkeletalMeshComponent::RefreshBoneTransforms(...) {
// 更新 reuqired bones 和 required curves
if (!bRequiredBonesUpToDate) {
RecalcRequiredBones(GetPredictedLODLevel());
}
else if (!AreRequiredCurvesUpToDate()) {
RecalcRequiredCurves();
}
// 当没有执行 URO 的时候重置数据，后续进行填充
if (!bDoEvaluationRateOptimization) {
CachedBoneSpaceTransforms.Reset();
CachedComponentSpaceTransforms.Reset();
CachedCurve.Empty();
CachedAttributes.Empty();
}
if (bDoParallelEvaluation) {
// 派发并行计算任务
DispatchParallelEvaluationTasks(TickFunction);
} else {
// 同步计算动画的分支，一般不会执行 ...
}
if (TickFunction == nullptr && ShouldBlendPhysicsBones()) {
// 结束骨骼 transform 变换，在这个调用之后，获取到的骨骼信息应该都是最新的
FinalizeBoneTransform();
}
}
前面提到的并行计算任务会通过 DispatchParallelEvaluationTasks 间接调用，这里会新建类型为 FParallelAnimationEvaluationTask 的任务来实现并行计算，然后，还会新建类型为 FParallelAnimationCompletionTask 的任务，来等待计算结束：
void USkeletalMeshComponent::DispatchParallelEvaluationTasks(...) {
SwapEvaluationContextBuffers();
// 触发并行计算
ParallelAnimationEvaluationTask =
TGraphTask<FParallelAnimationEvaluationTask>::CreateTask()
.ConstructAndDispatchWhenReady(this);
// 设置计算结果依赖关系，等待计算任务结束后触发后续计算
FGraphEventArray Prerequistes;
Prerequistes.Add(ParallelAnimationEvaluationTask);
FGraphEventRef TickCompletionEvent =
TGraphTask<FParallelAnimationCompletionTask>::CreateTask(&Prerequistes)
.ConstructAndDispatchWhenReady(this);
}
FParallelAnimationEvaluationTask 的 DoTask 中会调用 USkeletalMeshComponent 中的 ParallelAnimationEvaluation。这里会通过调用 PerformAnimationProcessing 间接调用到 UAnimInstance 的 ParallelUpdateAnimation：
void USkeletalMeshComponent::PerformAnimationProcessing(...) {
// 并行更新主动画蓝图和后处理动画蓝图中动画所需的参数
if(InAnimInstance && InAnimInstance->NeedsUpdate()) {
InAnimInstance->ParallelUpdateAnimation();
}
if(ShouldPostUpdatePostProcessInstance()) {
PostProcessAnimInstance->ParallelUpdateAnimation();
}
// 动画计算，求出骨骼位置
if(bInDoEvaluation && OutSpaceBases.Num() > 0) {
// 分别计算主动画蓝图和后处理动画蓝图
EvaluateAnimation(...);
EvaluatePostProcessMeshInstance(...);
// 计算 local space transform
FinalizePoseEvaluationResult(...);
// 计算 component space transform
FillComponentSpaceTransforms(...);
}
}
UAnimInstance 的 ParallelUpdateAnimation 就是在调用 proxy 的 UpdateAnimation：
void UAnimInstance::ParallelUpdateAnimation() {
GetProxyOnAnyThread<FAnimInstanceProxy>().UpdateAnimation();
}
这里面主要是从 root 节点开始，去遍历动画蓝图的节点，并进行状态更新：
void FAnimInstanceProxy::UpdateAnimation() {
// 调用 UpdateAnimation_WithRoot
UpdateAnimation_WithRoot(Context, RootNode, NAME_AnimGraph);
}
void FAnimInstanceProxy::UpdateAnimation_WithRoot(...) {
// 进行一些计算，触发对 bone 的 cache，CacheBone 内部会进行缓存状态判断，
// 只有在缓存失效的时候才会调用节点的 CacheBone_AnyThread
if(InRootNode == RootNode) {
CacheBones();
} else {
CacheBones_WithRoot(InRootNode);
}
// 前面提到的 ThreadSaveUpdateAnimation 函数
GetAnimInstanceObject()->
NativeThreadSafeUpdateAnimation(CurrentDeltaSeconds);
GetAnimInstanceObject()->
BlueprintThreadSafeUpdateAnimation(CurrentDeltaSeconds);
Update(CurrentDeltaSeconds);
// Update 节点
// 内部调用 InRootNode->Update_AnyThread(InContext);
if(InRootNode == RootNode) {
UpdateAnimationNode(InContext);
} else {
UpdateAnimationNode_WithRoot(InContext, InRootNode, InLayerName);
}
}
在调用 UAnimInstance 的 ParallelUpdateAnimation 更新动画状态之后，就是调用 USkeletalMeshComponent 的 EvaluateAnimation 进行动画计算，其中调用 UAnimInstance 的 ParallelEvaluateAnimation：
void USkeletalMeshComponent::EvaluateAnimation(...) const {
if( InSkeletalMesh->GetSkeleton() &&
InAnimInstance &&
InAnimInstance->ParallelCanEvaluate(InSkeletalMesh)) {
FParallelEvaluationData EvaluationData = {
OutCurve, OutPose, OutAttributes };
InAnimInstance->ParallelEvaluateAnimation(
bForceRefpose, InSkeletalMesh, EvaluationData);
} else {
OutCurve.InitFrom(&CachedCurveUIDList);
}
}
ParallelEvaluateAnimation 中会调用 proxy 的 EvaluateAnimation 进行计算，然后把计算结果复制出去：
void UAnimInstance::ParallelEvaluateAnimation(...) {
FAnimInstanceProxy& Proxy = GetProxyOnAnyThread<FAnimInstanceProxy>();
OutEvaluationData.OutPose.SetBoneContainer(&Proxy.GetRequiredBones());
FPoseContext EvaluationContext(&Proxy);
EvaluationContext.ResetToRefPose();
// 具体 EvaluateAnimation
Proxy.EvaluateAnimation(EvaluationContext);
// 复制数据
OutEvaluationData.OutCurve.CopyFrom(EvaluationContext.Curve);
OutEvaluationData.OutPose.CopyBonesFrom(EvaluationContext.Pose);
// ...
}
到了 proxy 的 EvaluateAnimation 这里，就是调用节点的 Evaluate_AnyThread 来进行动画计算：
void FAnimInstanceProxy::EvaluateAnimation(FPoseContext& Output) {
EvaluateAnimation_WithRoot(Output, RootNode);
}
void FAnimInstanceProxy::EvaluateAnimation_WithRoot(...) {
// 这里同样也可能会触发 cache bone 的计算
if(InRootNode == RootNode) {
CacheBones();
} else {
CacheBones_WithRoot(InRootNode);
}
// 默认情况下，Evaluate_WithRoot 返回 false，
// 如果有 native 实现，则在此返回 true，可避免执行节点的 eval
if (!Evaluate_WithRoot(Output, InRootNode)) {
// 内部就是调用节点的 Evaluate_AnyThread
EvaluateAnimationNode_WithRoot(Output, InRootNode);
}
}
前面这几个过程涉及了 FAnimNode_Base 中几个需要子类实现的接口：
CacheBone_AnyThread一般在一开始或者是 LOD 切换的时候被调用，用于给动画节点缓存骨骼信息，例如调用FBoneReference的Initialize，记录下引用骨骼的下标，后续查找的时候可以加速。Update_AnyThread用于更新影响骨骼计算的参数数据，例如 blend weight。Evaluate_AnyThread是主要计算发生的地方，根据前面Update_AnyThread计算更新的参数来计算出 local space 的骨骼 transform，并输出到 pose，结果之后会被缓存到 component。
USkeletalMeshComponent 的 PerformAnimationProcessing 在执行完动画计算后，接下来会调用 FinalizePoseEvaluationResult 复制骨骼的 local space transform 到 component 里：
void USkeletalMeshComponent::FinalizePoseEvaluationResult(...) const {
OutBoneSpaceTransforms = InMesh->GetRefSkeleton().GetRefBonePose();
InFinalPose.NormalizeRotations();
for(auto BoneIndex : InFinalPose.ForEachBoneIndex()) {
FMeshPoseBoneIndex MeshPoseIndex =
InFinalPose.GetBoneContainer().MakeMeshPoseIndex(BoneIndex);
OutBoneSpaceTransforms[MeshPoseIndex.GetInt()] = InFinalPose[BoneIndex];
}
OutRootBoneTranslation =
OutBoneSpaceTransforms[0].GetTranslation() -
InMesh->GetRefSkeleton().GetRefBonePose()[0].GetTranslation();
}
这里的输出数组在之前的 ParallelAnimationEvaluation 中传入：
if (AnimEvaluationContext.bDoInterpolation) {
PerformAnimationProcessing(...,
AnimEvaluationContext.CachedBoneSpaceTransforms, ...);
} else {
PerformAnimationProcessing(...,
AnimEvaluationContext.BoneSpaceTransforms, ...);
}
在获得了骨骼的 local space transform 之后，就调用 FillComponentSpaceTransforms 来基于 local space 计算 component space transform：
void USkeletalMeshComponent::FillComponentSpaceTransforms(...) const {
const int32 NumBones = InBoneSpaceTransforms.Num();
const FTransform* LocalTransformsData = InBoneSpaceTransforms.GetData();
FTransform* ComponentSpaceData = OutComponentSpaceTransforms.GetData();
// 复制根节点数据
OutComponentSpaceTransforms[0] = InBoneSpaceTransforms[0];
if (bAnim_SkeletalMesh_ISPC_Enabled) {
// 这个分支使用 Intel ISPC 来实现，在 Intel CPU 上可以加速，参考：
// https://www.gdcvault.com/play/1026686/Intel-ISPC-in-Unreal-Engine
#if INTEL_ISPC
ispc::FillComponentSpaceTransforms(...);
#endif
} else {
// 一般的逻辑，0 是根骨骼，所以这里从 1 开始遍历
for (int32 i = 1; i < RequireBonesNum; i++) {
const int32 BoneIndex = RequiredBones[i];
FTransform* SpaceBase = ComponentSpaceData + BoneIndex;
FPlatformMisc::Prefetch(SpaceBase);
// 计算每一个骨骼的 component space transform
// 也就是对应骨骼的父骨骼的 component space transform 乘以该骨骼
// 的 local space transform
const int32 ParentIndex =
InSkeletalMesh->GetRefSkeleton().GetParentIndex(BoneIndex);
FTransform* ParentSpaceBase = ComponentSpaceData + ParentIndex;
FTransform::Multiply(
SpaceBase, LocalTransformsData + BoneIndex, ParentSpaceBase);
SpaceBase->NormalizeRotation();
}
}
}
FParallelAnimationEvaluationTask 中的 DoTask 到此就结束了，接下来是看到 FParallelAnimationCompletionTask 的 DoTask 逻辑，这里会等待计算结束，然后调用 USkeletalMeshComponent 的 CompleteParallelAnimationEvaluation 进行后置处理：
void USkeletalMeshComponent::CompleteParallelAnimationEvaluation(...) {
ParallelAnimationEvaluationTask.SafeRelease();
if (...) {
SwapEvaluationContextBuffers();
PostAnimEvaluation(AnimEvaluationContext);
}
AnimEvaluationContext.Clear();
}
PostAnimEvaluation 会调用 UAnimInstance 的 PostUpdateAnimation，这个函数会进一步调用到 proxy 的 PostUpdate 完成通知发送之类的后置工作。
void USkeletalMeshComponent::PostAnimEvaluation(...) {
// 调用 anim instance 的 PostUpdateAnimation
if (EvaluationContext.AnimInstance) {
EvaluationContext.AnimInstance->PostUpdateAnimation();
}
if (ShouldPostUpdatePostProcessInstance()) {
PostProcessAnimInstance->PostUpdateAnimation();
}
// 检查当前是否更新过骨骼 transform
// 在使用了 skeletal mesh budget 时，可能会出现跳过骨骼更新的情况，
// 此时，下面这段代码就不会执行
if (EvaluationContext.bDoEvaluation||EvaluationContext.bDoInterpolation) {
// 更新曲线
AnimScriptInstance->UpdateCurvesPostEvaluation();
for(UAnimInstance* LinkedInstance : LinkedInstances) {
LinkedInstance->CopyCurveValues(*AnimScriptInstance);
}
// 判断是否执行过动画计算，如果执行过，则需要执行 PostEvaluateAnimation
if (EvaluationContext.bDoEvaluation) {
DoInstancePostEvaluation();
}
// 更新物理
UpdateKinematicBonesToAnim(...);
UpdateRBJointMotors();
// 内部会调用 ConditionallyDispatchQueuedAnimEvents 发送通知
// 这里还会完成 buffer swap、更新包围盒等工作
FinalizeAnimationUpdate();
} else {
// 这个分支是在没有发生骨骼更新的时候调用的，依然可能发送通知
ConditionallyDispatchQueuedAnimEvents();
}
AnimEvaluationContext.Clear();
}
蒙皮计算
蒙皮计算通过 USkinnedMeshComponent 中持有的 MeshObject 实现，分为 CPU Skinning 和 GPU Skinning，分别对应于 FSkeletalMeshObjectCPUSkin 和 FSkeletalMeshObjectGPUSkin，他们都继承自 FSkeletalMeshObject，在 USkinnedMeshComponent 的 CreateRenderState_Concurrent 中进行初始化，然后调用 MeshObject 的 Update 函数更新动态数据：
void USkinnedMeshComponent::CreateRenderState_Concurrent(...) {
// 初始化 LOD
InitLODInfos();
// 如果用户指定了自己的 mesh object 构造器，就优先使用
if (MeshObjectFactory) {
MeshObject = MeshObjectFactory(...);
}
// 如果用户没有指定构造器，或者构造失败，就选择默认的
if (!MeshObject) {
if (bRenderStatic) {
MeshObject = ::new FSkeletalMeshObjectStatic(...);
} else if (ShouldCPUSkin()) {
MeshObject = ::new FSkeletalMeshObjectCPUSkin(...);
// 这里要确认数据符合 GPU skinning 的约束条件。
// 如果不满足，就直接不显示了，UE 不会自动将其换为 CPU 蒙皮。
// 这里会要求一个材质 section 所能使用的最大蒙皮骨骼数，
// 断点看到在 PC 平台和 Anroid 平台上，这个约束值为 256。
// 注意这里的骨骼数不是总骨骼数，而是实际有蒙皮的骨骼，
// 例如 A 骨骼有 B C 两个子骨骼，然后只有 B C 上刷了蒙皮权重，
// 那么虽然 A 也要参与动画计算，但并不影响此处的判定。
} else if (!SkelMeshRenderData->RequiresCPUSkinning(...)) {
MeshObject = ::new FSkeletalMeshObjectGPUSkin(...);
} else {
UE_LOG(LogSkinnedMeshComp, Warning, TEXT(...));
}
}
PostInitMeshObject(MeshObject);
Super::CreateRenderState_Concurrent(Context);
// 计算 LOD 等级
int32 ModifiedLODLevel = GetPredictedLODLevel();
ModifiedLODLevel = FMath::Clamp(ModifiedLODLevel, ...);
// 计算动态数据并发送到渲染线程
if(SkeletalMesh->IsValidLODIndex(ModifiedLODLevel)) {
MeshObject->Update(ModifiedLODLevel, this, ...);
}
}
Update 需要先在主线程计算动态数据，然后发送到渲染线程：
void FSkeletalMeshObjectGPUSkin::Update(...) {
// ...
// 构造新的用于发往渲染线程的临时动态数据
// 这些数据在下一次 update 的时候会释放掉
FDynamicSkelMeshObjectDataGPUSkin* NewDynamicData = /*...*/;
NewDynamicData->InitDynamicSkelMeshObjectDataGPUSkin(...);
// 将数据发往渲染线程
FSkeletalMeshObjectGPUSkin* MeshObject = this;
ENQUEUE_RENDER_COMMAND(SkelMeshObjectUpdateDataCommand)(
[...](FRHICommandListImmediate& RHICmdList) {
MeshObject->UpdateDynamicData_RenderThread(...);
}
);
}
在 InitDynamicSkelMeshObjectDataGPUSkin 中，会分别计算所有骨骼的 ref to local 矩阵，以及 local to world 矩阵。其中，ref to local 矩阵是到 local space 的蒙皮矩阵。叠加上 local to world 矩阵的变化后，就是完整的 world space 蒙皮矩阵。给定一个顶点和蒙皮权重，可以计算出动画播放后，该顶点在 world space 下的位置：
void
FDynamicSkelMeshObjectDataGPUSkin::InitDynamicSkelMeshObjectDataGPUSkin(...) {
LODIndex = InLODIndex;
// 一些额外需要计算的骨骼
const TArray<FBoneIndexType>* ExtraRequiredBoneIndices = /*...*/;
// 更新 ref to local 矩阵
UpdateRefToLocalMatrices(..., LODIndex, ExtraRequiredBoneIndices);
// ...
// 更新 local to world 矩阵
LocalToWorld = InMeshComponent ? InMeshComponent->GetComponentTransform().ToMatrixWithScale() : FMatrix::Identity;
// ...
}
UpdateRefToLocalMatrices 会将矩阵计算结果输出到传入的 ReferenceToLocal 数组中引用。需要注意的是，由于每一次 Update 都会申请新的 dynamic data，因此这个 ReferenceToLocal 数组每次调用都需要申请内存，如果骨骼数量过多，这里效率会比较低：
void UpdateRefToLocalMatrices(TArray<FMatrix44f>& ReferenceToLocal, ...) {
const USkeletalMesh* const ThisMesh = InMeshComponent->SkeletalMesh;
// Ref pose 矩阵的逆矩阵
const TArray<FMatrix44f>* RefBasesInvMatrix =
&ThisMesh->GetRefBasesInvMatrix();
// 如果用户设置了 ref pose 数据的 override，就在此处更改
if( InMeshComponent->GetRefPoseOverride() /*...*/ ) {
RefBasesInvMatrix =
&InMeshComponent->GetRefPoseOverride()->RefBasesInvMatrix;
}
// 这里申请内存，事实上对于内置的 skinning，这里传入的数组总是空的
if(ReferenceToLocal.Num() != RefBasesInvMatrix->Num()) {
ReferenceToLocal.Empty(RefBasesInvMatrix->Num());
ReferenceToLocal.AddUninitialized(RefBasesInvMatrix->Num());
for (int32 Index = 0; Index < ReferenceToLocal.Num(); ++Index) {
ReferenceToLocal[Index] = FMatrix44f::Identity;
}
}
// 具体计算 ref to local 矩阵
UpdateRefToLocalMatricesInner(ReferenceToLocal, ComponentTransform, ...);
}
这个 RefBaseInvMatrix 的数量由原始骨架中骨骼的数量决定：
void USkeletalMesh::CalculateInvRefMatrices() {
// 数量是 raw bone num，即原始骨架中的骨骼数
const int32 NumRealBones = GetRefSkeleton().GetRawBoneNum();
if (GetRefBasesInvMatrix().Num() != NumRealBones) {
GetRefBasesInvMatrix().Empty(NumRealBones);
GetRefBasesInvMatrix().AddUninitialized(NumRealBones);
for( int32 b=0; b<NumRealBones; b++) {
// 获取 bone space 的 ref pose 矩阵
ComposedRefPoseMatrices[b] = GetRefPoseMatrix(b);
// 如果不是根骨骼，那么 ref pose local space 矩阵是
// 自身的 bone space 和父骨骼的 local space 矩阵相乘
if( b>0 ) {
int32 Parent = GetRefSkeleton().GetRawParentIndex(b);
ComposedRefPoseMatrices[b] =
ComposedRefPoseMatrices[b] * ComposedRefPoseMatrices[Parent];
}
// 计算逆矩阵
GetRefBasesInvMatrix()[b] =
FMatrix44f(ComposedRefPoseMatrices[b].Inverse());
}
}
}
具体计算 ref to local 矩阵的逻辑在 UpdateRefToLocalMatricesInner 中实现，这里会先遍历所有会对蒙皮产生影响的骨骼，获取其 component space bone transform 对应的矩阵（即从 bone space 变到当前的 local space），对于不对蒙皮产生影响的骨骼，这里会保持为 identity 矩阵。然后，遍历所有骨骼，乘上 ref pose 下，bone space 到 local space 的变化矩阵的逆矩阵（即从 local space 变回 bone space）。
如果对骨骼蒙皮动画不了解的话，这里解释一下。我们假设一个顶点只会受一根骨骼影响，那么对于这根骨骼来说，动画前后顶点的相对位置是不变的，也就是说，这个顶点在这根骨骼的 bone space 下是静止的，所以我们先计算原始顶点从 local space 变到 bone space 下的位置，然后再应用从 bone space 到新 local space 的变化矩阵，得到动画播放后顶点的位置。过程如下图所示：
这里的紫色顶点跟随其中一根骨骼移动，对于多根骨骼影响一个顶点的情况，我们则是分别计算这几根骨骼的影响，并根据权重进行混合。其实这里 UE 的命名有点误导人，蒙皮矩阵计算前后都是 local space，只是一个是 ref pose，一个是当前 pose，也就是叠加动画后的 pose，但他将其命名为 ref to local，容易让人迷惑。总之，这两个矩阵相乘的结果就是将顶点从 local space 下 ref pose 状态的原始位置变到 local space 下当前状态的实际位置：
void UpdateRefToLocalMatricesInner(...) {
const FSkeletalMeshLODRenderData& LOD =
InSkeletalMeshRenderData->LODRenderData[LODIndex];
// 注意这里只会处理 active bones 和传入的 extra bones
const TArray<FBoneIndexType>* RequiredBoneSets[3] = { &LOD.ActiveBoneIndices, ExtraRequiredBoneIndices, NULL };
// 遍历所有骨骼集合
for (RequiredBoneIndices : RequiredBoneSets) {
// 遍历每个骨骼集合中的所有骨骼，乘上当前的变化矩阵（初始值是 identity 矩阵）
// 这里保留的是非 master pose 下的计算分支
for(BoneIndex=0; BoneIndex<RequiredBoneIndices.Num(); BoneIndex++) {
ThisBoneIndex = RequiredBoneIndices[BoneIndex];
ReferenceToLocal[ThisBoneIndex] =
(FMatrix44f)ComponentTransform[ThisBoneIndex].
ToMatrixWithScale();
}
}
// 将每个矩阵乘上从 ref pose 的逆矩阵
// 得到从 ref pose 到当前 local 的变化矩阵
for(BoneIndex=0; BoneIndex<ReferenceToLocal.Num(); ++BoneIndex) {
ReferenceToLocal[BoneIndex] =
(*RefBasesInvMatrix)[BoneIndex] * ReferenceToLocal[BoneIndex];
}
}
注意到在 LOD RenderData 中，有两个数据会影响骨骼动画的计算量，一个是 ActiveBoneIndices 一个是 RequiredBones，其中，前者是被蒙皮的骨骼的下标，后者是参与到动画计算的骨骼的下标。
我们可以参考 FMeshUtilities::BuildSkeletalModelFromChunks 来看一下这二者的区别：
void FMeshUtilities::BuildSkeletalModelFromChunks(...) {
// 计算 active bones
for (int32 ChunkIndex = 0; ChunkIndex < Chunks.Num(); ++ChunkIndex) {
// ...
// 这里 bone map 就是用来给顶点蒙皮下标做映射的，
// 因此这里记录的就是参与了蒙皮的骨骼下标
for (int32 BoneIndex = 0; BoneIndex < BoneMap.Num(); ++BoneIndex) {
LODModel.ActiveBoneIndices.AddUnique(Section.BoneMap[BoneIndex]);
}
}
// 这里确保父骨骼也在 active bone indices 中
RefSkeleton.EnsureParentsExistAndSort(LODModel.ActiveBoneIndices);
// ...
// 计算 required bones
USkeletalMesh::CalculateRequiredBones(LODModel, RefSkeleton, NULL);
}
void USkeletalMesh::CalculateRequiredBones(...) {
int32 RequiredBoneCount = InRefSkeleton.GetRawBoneNum();
LODModel.RequiredBones.Empty(RequiredBoneCount);
// 用户在 LOD 设置里填入想要裁剪的骨骼后，
// bones to remove 中会记录这些骨骼以及他们的所有子孙骨骼
for(int32 i=0; i<RequiredBoneCount; i++) {
if (!BonesToRemove || BonesToRemove->Find(i) == NULL) {
LODModel.RequiredBones.Add(i);
}
}
LODModel.RequiredBones.Shrink();
}
即一根骨骼如果被加入了 BonesToRemove 列表，那么它就会被从 RequiredBones 中移除，不会参与到动画计算。但不参与动画计算仅仅意味着这根骨骼在 bone space 下的位置不被更新，只要它会影响到被蒙上了顶点，那么它就会被加入 ActiveBoneIndices 列表中，牵动被它影响的顶点。
接下来，UpdateDynamicData_RenderThread 会在渲染线程中处理具体的数据传输：
void FSkeletalMeshObjectGPUSkin::UpdateDynamicData_RenderThread(...) {
WaitForRHIThreadFenceForDynamicData();
if (DynamicData) {
// 前面提到每一次都会新建一份动态数据，上一次的数据在这里释放
FreeDynamicSkelMeshObjectDataGPUSkin(DynamicData);
}
// 更新为新的数据
DynamicData = InDynamicData;
// 具体处理数据传输
ProcessUpdatedDynamicData(EGPUSkinCacheEntryMode::Raster, GPUSkinCache, RHICmdList, FrameNumberToPrepare, RevisionNumber, bMorphNeedsUpdate, DynamicData->LODIndex);
}
ProcessUpdatedDynamicData 会将数据更新到顶点工厂的 shader data 中：
void FSkeletalMeshObjectGPUSkin::ProcessUpdatedDynamicData(...) {
FSkeletalMeshObjectLOD& LOD = LODs[LODIndex];
const FSkeletalMeshLODRenderData& LODData =
SkeletalMeshRenderData->LODRenderData[LODIndex];
const TArray<FSkelMeshRenderSection>& Sections =
GetRenderSections(LODIndex);
// LOD 顶点工厂列表
FVertexFactoryData& VertexFactoryData = LOD.GPUSkinVertexFactories;
bool bSkinCacheResult = true;
for (int32 SectionIdx = 0; SectionIdx < Sections.Num(); SectionIdx++) {
const FSkelMeshRenderSection& Section = Sections[SectionIdx];
// 当前 section 的顶点工厂
FGPUBaseSkinVertexFactory* VertexFactory;
VertexFactory = VertexFactoryData.VertexFactories[SectionIdx].Get();
// 更新 shader 数据
FGPUBaseSkinVertexFactory::FShaderDataType& ShaderData =
VertexFactory->GetShaderData();
bool bNeedFence = ShaderData.UpdateBoneData(...);
if (bNeedFence) {
RHIThreadFenceForDynamicData = RHICmdList.RHIThreadFence(true);
}
}
}
在 UpdateBoneData 中，UE 并不会将蒙皮矩阵全部传到 GPU，对于任意一个 section，UE 只会传递这个 section 用到的骨骼。这里传送的矩阵数量就是前面提到的 bone map 的长度，传送的具体蒙皮矩阵和 bone map 下标一一对应：
bool FGPUBaseSkinVertexFactory::FShaderDataType::UpdateBoneData(...) {
FMatrix3x4* ChunkMatrices = nullptr;
uint32 NumBones = BoneMap.Num();
uint32 NumVectors = NumBones*3;
// 计算总蒙皮矩阵 buffer 大小
uint32 VectorArraySize = NumVectors * sizeof(FVector4f);
ChunkMatrices = (FMatrix3x4*)RHILockBuffer(...VectorArraySize...);
if (bGPUSkin_CopyBones_ISPC_Enabled) {
// Intel ISPC 优化分支
#if INTEL_ISPC
ispc::UpdateBoneData_CopyBones(...);
#endif
} else {
for (uint32 BoneIdx = 0; BoneIdx < NumBones; BoneIdx++) {
// 找到蒙皮骨骼本来的下标
FBoneIndexType RefToLocalIdx = BoneMap[BoneIdx];
FMatrix3x4& BoneMat = ChunkMatrices[BoneIdx];
FMatrix44f& RefToLocal =
ReferenceToLocalMatrices[RefToLocalIdx];
// 拷贝骨骼蒙皮矩阵数据
RefToLocal.To3x4MatrixTranspose((float*)BoneMat.M);
}
}
}
在 UE 中，每个 LOD 的渲染数据都包含了这个 LOD 下所有顶点的全部信息，包括顶点位置、UV、顶点颜色和蒙皮信息等等。这些数据按材质被划分成不同的 render section，每一个 render section 中，都带有一个 bone map。每一个顶点的蒙皮信息中，InfluenceBones 数组记录的并不是骨骼下标，而是 bone map 的下标，bone map 中记录的才是具体的骨骼下标。结合上面 UpdateBoneData 的实现，我们才能理解为什么 UE 使用这样一个间接的蒙皮骨骼下标表示方法：
// 每个 LOD 的数据
class FSkeletalMeshLODRenderData : public FRefCountBase {
// 持有该 LOD 下每个 section 的渲染数据
TArray<FSkelMeshRenderSection> RenderSections;
// 持有顶点权重 buffer
FSkinWeightVertexBuffer SkinWeightVertexBuffer;
};
// 一个 LOD 下每个材质 section 的数据
struct FSkelMeshRenderSection {
TArray<FBoneIndexType> BoneMap;
};
// 顶点蒙皮信息 buffer
class FSkinWeightVertexBuffer {
void GetSkinWeights(TArray<FSkinWeightInfo>& OutVertices) const;
FSkinWeightInfo GetVertexSkinWeights(uint32 VertexIndex) const;
};
// 一个顶点的蒙皮权重数据
struct FSkinWeightInfo {
// 蒙皮骨骼在 bone map 中的下标
FBoneIndexType InfluenceBones[MAX_TOTAL_INFLUENCES];
// 对应骨骼的蒙皮权重
uint8 InfluenceWeights[MAX_TOTAL_INFLUENCES];
};
再往后就是 GPU 内部计算顶点位置的事情了。