1
// 主要的CPU蒙皮对象
2
class FSkeletalMeshObjectCPUSkin : public FSkeletalMeshObject
3
{
4
    // LOD数据数组
5
    TArray<FSkeletalMeshObjectLOD> LODs;
6

7
    // 动态数据指针
8
    FDynamicSkelMeshObjectDataCPUSkin* DynamicData;
9

10
    // 缓存的顶点数据
11
    mutable TArray<FFinalSkinVertex> CachedFinalVertices;
12
    mutable int32 CachedVertexLOD;
13

14
    // 调试渲染相关
15
    bool bRenderOverlayMaterial;
16
    TArray<int32> BonesOfInterest;
17
    TArray<UMorphTarget*> MorphTargetOfInterest;
18
};
19

20
// LOD级别的数据管理
21
struct FSkeletalMeshObjectLOD
22
{
23
    // 顶点缓冲区
24
    FPositionVertexBuffer PositionVertexBuffer;
25
    FStaticMeshVertexBuffer StaticMeshVertexBuffer;
26

27
    // 顶点工厂
28
    FLocalVertexFactory VertexFactory;
29

30
    // 权重和颜色缓冲区指针
31
    FSkinWeightVertexBuffer* MeshObjectWeightBuffer;
32
    FColorVertexBuffer* MeshObjectColorBuffer;
33

34
    // 射线追踪支持
35
    #if RHI_RAYTRACING
36
    FRayTracingGeometry RayTracingGeometry;
37
    #endif
38
};

1
class FDynamicSkelMeshObjectDataCPUSkin
2
{
3
public:
4
    int32 LODIndex;                                    // 当前LOD级别
5
    FMorphTargetWeightMap ActiveMorphTargets;          // 活跃的Morph Target
6
    TArray<float> MorphTargetWeights;                  // Morph Target权重
7
    TArray<FMatrix44f> ReferenceToLocal;               // 骨骼变换矩阵
8

9
    // 布料模拟相关
10
    TMap<int32, FClothSimulData> ClothSimulUpdateData; // 布料模拟数据
11
    float ClothBlendWeight;                            // 布料混合权重
12
    FMatrix WorldToLocal;                              // 世界到局部空间变换
13

14
    #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
15
    TArray<FTransform> MeshComponentSpaceTransforms;   // 组件空间变换（调试用）
16
    #endif
17
};

1
void FSkeletalMeshObjectCPUSkin::Update(
2
    int32 LODIndex,
3
    USkinnedMeshComponent* InMeshComponent,
4
    const FMorphTargetWeightMap& InActiveMorphTargets,
5
    const TArray<float>& InMorphTargetWeights,
6
    EPreviousBoneTransformUpdateMode PreviousBoneTransformUpdateMode,
7
    const FExternalMorphWeightData& InExternalMorphWeightData)
8
{
9
    if (InMeshComponent)
10
    {
11
        // 创建新的动态数据
12
        FDynamicSkelMeshObjectDataCPUSkin* NewDynamicData =
13
            new FDynamicSkelMeshObjectDataCPUSkin(
14
                InMeshComponent, SkeletalMeshRenderData, LODIndex,
15
                InActiveMorphTargets, InMorphTargetWeights);
16

17
        uint64 FrameNumberToPrepare = GFrameCounter;
18
        uint32 RevisionNumber = 0;
19

20
        if (InMeshComponent->SceneProxy)
21
        {
22
            RevisionNumber = InMeshComponent->GetBoneTransformRevisionNumber();
23
        }
24

25
        // 提交渲染命令到特定的渲染管道
26
        FSkeletalMeshObjectCPUSkin* MeshObject = this;
27
        ENQUEUE_RENDER_COMMAND(SkelMeshObjectUpdateDataCommand)(
28
            UE::RenderCommandPipe::SkeletalMesh,
29
            [MeshObject, FrameNumberToPrepare, RevisionNumber, NewDynamicData]
30
            (FRHICommandList& RHICmdList)
31
            {
32
                FScopeCycleCounter Context(MeshObject->GetStatId());
33
                MeshObject->UpdateDynamicData_RenderThread(
34
                    RHICmdList, NewDynamicData, FrameNumberToPrepare, RevisionNumber);
35
            }
36
        );
37
    }
38
}

1
void FSkeletalMeshObjectCPUSkin::UpdateDynamicData_RenderThread(
2
    FRHICommandList& RHICmdList,
3
    FDynamicSkelMeshObjectDataCPUSkin* InDynamicData,
4
    uint64 FrameNumberToPrepare,
5
    uint32 RevisionNumber)
6
{
7
    // 删除旧数据，更新新数据
8
    delete DynamicData;
9
    DynamicData = InDynamicData;
10
    check(DynamicData);
11

12
    // 执行顶点缓存更新
13
    CacheVertices(DynamicData->LODIndex, true, RHICmdList);
14
}

1
void FSkeletalMeshObjectCPUSkin::CacheVertices(int32 LODIndex, bool bForce, FRHICommandList& RHICmdList) const
2
{
3
    SCOPE_CYCLE_COUNTER(STAT_CPUSkinUpdateRTTime);
4
    check(IsInParallelRenderingThread());
5

6
    FSkeletalMeshLODRenderData& LOD = SkeletalMeshRenderData->LODRenderData[LODIndex];
7
    const FSkeletalMeshObjectLOD& MeshLOD = LODs[LODIndex];
8

9
    // 只在LOD变化或强制更新时重新计算
10
    if ((LODIndex != CachedVertexLOD || bForce) &&
11
        DynamicData &&
12
        MeshLOD.StaticMeshVertexBuffer.IsValid())
13
    {
14
        // 获取骨骼变换矩阵
15
        FMatrix44f* ReferenceToLocal = DynamicData->ReferenceToLocal.GetData();
16

17
        int32 CachedFinalVerticesNum = LOD.GetNumVertices();
18
        CachedFinalVertices.Empty(CachedFinalVerticesNum);
19
        CachedFinalVertices.AddUninitialized(CachedFinalVerticesNum);
20

21
        FFinalSkinVertex* DestVertex = CachedFinalVertices.GetData();
22

23
        if (DestVertex)
24
        {
25
            check(GIsEditor || LOD.StaticVertexBuffers.StaticMeshVertexBuffer.GetAllowCPUAccess());
26
            SCOPE_CYCLE_COUNTER(STAT_SkinningTime);
27

28
            // 根据UV精度选择不同的蒙皮路径
29
            if (LOD.StaticVertexBuffers.StaticMeshVertexBuffer.GetUseFullPrecisionUVs())
30
            {
31
                SKIN_LOD_VERTICES(TGPUSkinVertexFloat32Uvs,
32
                    LOD.StaticVertexBuffers.StaticMeshVertexBuffer.GetNumTexCoords());
33
            }
34
            else
35
            {
36
                SKIN_LOD_VERTICES(TGPUSkinVertexFloat16Uvs,
37
                    LOD.StaticVertexBuffers.StaticMeshVertexBuffer.GetNumTexCoords());
38
            }
39

40
            // 处理调试渲染（骨骼权重或Morph Target可视化）
41
            if (bRenderOverlayMaterial)
42
            {
43
                if (MorphTargetOfInterest.Num() > 0)
44
                {
45
                    CalculateMorphTargetWeights(DestVertex, LOD, LODIndex, MorphTargetOfInterest);
46
                }
47
                else
48
                {
49
                    CalculateBoneWeights(DestVertex, LOD, *MeshLOD.MeshObjectWeightBuffer, BonesOfInterest);
50
                }
51
            }
52
        }
53

54
        CachedVertexLOD = LODIndex;
55

56
        // 将计算结果写入GPU缓冲区
57
        UpdateGPUBuffers(LOD, MeshLOD, RHICmdList);
58
    }
59
}

1
#define SKIN_LOD_VERTICES(VertexType, NumUVs) \
2
{\
3
    switch(NumUVs)\
4
    {\
5
        case 1:\
6
            SkinVertices<VertexType<1>, 1>(DestVertex, ReferenceToLocal, /*...*/);\
7
            break;\
8
        case 2:\
9
            SkinVertices<VertexType<2>, 2>(DestVertex, ReferenceToLocal, /*...*/);\
10
            break;\
11
        case 3:\
12
            SkinVertices<VertexType<3>, 3>(DestVertex, ReferenceToLocal, /*...*/);\
13
            break;\
14
        case 4:\
15
            SkinVertices<VertexType<4>, 4>(DestVertex, ReferenceToLocal, /*...*/);\
16
            break;\
17
        default:\
18
            checkf(false, TEXT("Invalid number of UV sets. Must be between 1 and 4"));\
19
            break;\
20
    }\
21
}

1
template<typename VertexType, int32 NumberOfUVs>
2
static void SkinVertices(
3
    FFinalSkinVertex* DestVertex,
4
    FMatrix44f* ReferenceToLocal,
5
    int32 LODIndex,
6
    FSkeletalMeshLODRenderData& LOD,
7
    FSkinWeightVertexBuffer& WeightBuffer,
8
    const FMorphTargetWeightMap& InActiveMorphTargets,
9
    const TArray<float>& MorphTargetWeights,
10
    const TMap<int32, FClothSimulData>& ClothSimulUpdateData,
11
    float ClothBlendWeight,
12
    const FMatrix& WorldToLocal,
13
    const FVector& WorldScale)
14
{
15
    // 设置SIMD寄存器控制
16
    uint32 StatusRegister = VectorGetControlRegister();
17
    VectorSetControlRegister(StatusRegister | VECTOR_ROUND_TOWARD_ZERO);
18

19
    // 初始化Morph Target评估信息
20
    TArray<FMorphTargetInfo> MorphEvalInfos;
21
    uint32 NumValidMorphs = InitEvalInfos(InActiveMorphTargets, MorphTargetWeights,
22
                                         LODIndex, MorphEvalInfos);
23

24
    // 预取骨骼矩阵到缓存
25
    const uint32 MaxGPUSkinBones = FGPUBaseSkinVertexFactory::GetMaxGPUSkinBones();
26
    for (uint32 MatrixIndex = 0; MatrixIndex < MaxGPUSkinBones; MatrixIndex += 2)
27
    {
28
        FPlatformMisc::Prefetch(ReferenceToLocal + MatrixIndex);
29
    }
30

31
    int32 CurBaseVertIdx = 0;
32
    int32 VertexBufferBaseIndex = 0;
33
    const FVector WorldScaleAbs = WorldScale.GetAbs();
34

35
    // 按Section处理顶点
36
    for(int32 SectionIndex = 0; SectionIndex < LOD.RenderSections.Num(); SectionIndex++)
37
    {
38
        FSkelMeshRenderSection& Section = LOD.RenderSections[SectionIndex];
39
        const FClothSimulData* ClothSimData = ClothSimulUpdateData.Find(Section.CorrespondClothAssetIndex);
40

41
        SkinVertexSection<VertexType, NumberOfUVs>(
42
            DestVertex, MorphEvalInfos, MorphTargetWeights, Section, LOD, WeightBuffer,
43
            VertexBufferBaseIndex, NumValidMorphs, CurBaseVertIdx, LODIndex,
44
            ReferenceToLocal, ClothSimData, ClothBlendWeight, WorldToLocal, WorldScaleAbs);
45
    }
46

47
    // 恢复SIMD寄存器状态
48
    VectorSetControlRegister(StatusRegister);
49
}

1
template<typename VertexType, int32 NumberOfUVs>
2
static void SkinVertexSection(/* 参数列表 */)
3
{
4
    static constexpr VectorRegister VECTOR_INV_65535 =
5
        MakeVectorRegisterDoubleConstant(1.0/65535, 1.0/65535, 1.0/65535, 1.0/65535);
6

7
    VertexType VertexCopy; // Morph Target处理用的临时顶点
8

9
    // 预取骨骼映射数据
10
    const FBoneIndexType* BoneMap = Section.BoneMap.GetData();
11
    FPlatformMisc::Prefetch(BoneMap);
12
    FPlatformMisc::Prefetch(BoneMap, PLATFORM_CACHE_LINE_SIZE);
13

14
    const int32 MaxSectionBoneInfluences = WeightBuffer.GetMaxBoneInfluences();
15
    const bool bLODUsesCloth = LOD.HasClothData() && ClothSimData != nullptr && ClothBlendWeight > 0.0f;
16
    const int32 NumSoftVertices = Section.GetNumVertices();
17

18
    if (NumSoftVertices > 0)
19
    {
20
        INC_DWORD_STAT_BY(STAT_CPUSkinVertices, NumSoftVertices);
21

22
        // 逐顶点处理
23
        for(int32 VertexIndex = VertexBufferBaseIndex; VertexIndex < NumSoftVertices;
24
            VertexIndex++, DestVertex++)
25
        {
26
            const int32 VertexBufferIndex = Section.GetVertexBufferIndex() + VertexIndex;
27

28
            // 加载源顶点数据
29
            VertexType SrcSoftVertex;
30
            const FVector& VertexPosition = (FVector)LOD.StaticVertexBuffers.PositionVertexBuffer.VertexPosition(VertexBufferIndex);
31
            FPlatformMisc::Prefetch(&VertexPosition, PLATFORM_CACHE_LINE_SIZE);
32

33
            SrcSoftVertex.Position = (FVector3f)VertexPosition;
34
            SrcSoftVertex.TangentX = LOD.StaticVertexBuffers.StaticMeshVertexBuffer.VertexTangentX(VertexBufferIndex);
35
            SrcSoftVertex.TangentZ = LOD.StaticVertexBuffers.StaticMeshVertexBuffer.VertexTangentZ(VertexBufferIndex);
36

37
            // 加载UV坐标
38
            for (uint32 j = 0; j < VertexType::NumTexCoords; j++)
39
            {
40
                SrcSoftVertex.UVs[j] = LOD.StaticVertexBuffers.StaticMeshVertexBuffer.GetVertexUV_Typed<VertexType::StaticMeshVertexUVType>(VertexBufferIndex, j);
41
            }
42

43
            // 处理Morph Target
44
            VertexType* MorphedVertex = &SrcSoftVertex;
45
            if(NumValidMorphs)
46
            {
47
                MorphedVertex = &VertexCopy;
48
                UpdateMorphedVertex<VertexType>(*MorphedVertex, SrcSoftVertex, CurBaseVertIdx, LODIndex, MorphEvalInfos, MorphTargetWeights);
49
            }
50

51
            // 获取蒙皮权重
52
            FSkinWeightInfo SrcWeights = WeightBuffer.GetVertexSkinWeights(VertexBufferIndex);
53

54
            // 执行SIMD优化的蒙皮计算
55
            PerformSIMDSkinning(MorphedVertex, SrcWeights, BoneMap, ReferenceToLocal,
56
                               MaxSectionBoneInfluences, DestVertex);
57

58
            // 处理布料模拟
59
            ProcessClothSimulation(VertexIndex, ClothVertData, ClothSimData,
60
                                 ClothBlendWeight, WorldToLocal, WorldScaleAbs, DestVertex);
61

62
            // 复制UV坐标
63
            CopyUVCoordinates(VertexIndex, Section, LOD, NumberOfUVs, DestVertex);
64

65
            CurBaseVertIdx++;
66
        }
67
    }
68
}

1
// 核心的SIMD蒙皮计算（简化版）
2
void PerformSIMDSkinning(/* 参数 */)
3
{
4
    const FBoneIndexType* RESTRICT BoneIndices = SrcWeights.InfluenceBones;
5
    const uint16* RESTRICT BoneWeights = SrcWeights.InfluenceWeights;
6

7
    // 将顶点数据加载到SIMD寄存器
8
    static VectorRegister SrcNormals[3];
9
    VectorRegister DstNormals[3];
10
    SrcNormals[0] = VectorLoadFloat3_W1(&MorphedVertex->Position);
11
    SrcNormals[1] = Unpack3(&MorphedVertex->TangentX.Vector.Packed);
12
    SrcNormals[2] = Unpack4(&MorphedVertex->TangentZ.Vector.Packed);
13

14
    // 权重归一化（从uint16转换为float）
15
    VectorRegister Weights = VectorMultiply(VectorLoadURGBA16N(BoneWeights), VECTOR_INV_65535);
16
    VectorRegister ExtraWeights = MakeVectorRegister(0.f, 0.f, 0.f, 0.f);
17
    VectorRegister ExtraWeights2 = MakeVectorRegister(0.f, 0.f, 0.f, 0.f);
18

19
    // 处理超过4个骨骼影响的情况
20
    if (MaxSectionBoneInfluences > 4)
21
    {
22
        ExtraWeights = VectorMultiply(VectorLoadURGBA16N(&BoneWeights[MAX_INFLUENCES_PER_STREAM]), VECTOR_INV_65535);
23
    }
24
    if (MaxSectionBoneInfluences > 8)
25
    {
26
        ExtraWeights2 = VectorMultiply(VectorLoadURGBA16N(&BoneWeights[EXTRA_BONE_INFLUENCES]), VECTOR_INV_65535);
27
    }
28

29
    VectorResetFloatRegisters();
30

31
    // 累积骨骼变换（支持最多12个骨骼影响）
32
    const FMatrix44f BoneMatrix0 = ReferenceToLocal[BoneMap[BoneIndices[INFLUENCE_0]]];
33
    VectorRegister Weight0 = VectorReplicate(Weights, INFLUENCE_0);
34
    VectorRegister M00 = VectorMultiply(VectorLoadAligned(&BoneMatrix0.M[0][0]), Weight0);
35
    VectorRegister M10 = VectorMultiply(VectorLoadAligned(&BoneMatrix0.M[1][0]), Weight0);
36
    VectorRegister M20 = VectorMultiply(VectorLoadAligned(&BoneMatrix0.M[2][0]), Weight0);
37
    VectorRegister M30 = VectorMultiply(VectorLoadAligned(&BoneMatrix0.M[3][0]), Weight0);
38

39
    // 展开循环处理其他骨骼影响（源码中有完整的if-else嵌套结构）
40
    if (MaxSectionBoneInfluences > 1)
41
    {
42
        const FMatrix44f BoneMatrix1 = ReferenceToLocal[BoneMap[BoneIndices[INFLUENCE_1]]];
43
        VectorRegister Weight1 = VectorReplicate(Weights, INFLUENCE_1);
44
        M00 = VectorMultiplyAdd(VectorLoadAligned(&BoneMatrix1.M[0][0]), Weight1, M00);
45
        M10 = VectorMultiplyAdd(VectorLoadAligned(&BoneMatrix1.M[1][0]), Weight1, M10);
46
        M20 = VectorMultiplyAdd(VectorLoadAligned(&BoneMatrix1.M[2][0]), Weight1, M20);
47
        M30 = VectorMultiplyAdd(VectorLoadAligned(&BoneMatrix1.M[3][0]), Weight1, M30);
48

49
        // ... 继续处理其他骨骼 (源码支持最多12个骨骼)
50
    }
51

52
    // 应用变换到顶点属性
53
    VectorRegister N_xxxx = VectorReplicate(SrcNormals[0], 0);
54
    VectorRegister N_yyyy = VectorReplicate(SrcNormals[0], 1);
55
    VectorRegister N_zzzz = VectorReplicate(SrcNormals[0], 2);
56
    DstNormals[0] = VectorMultiplyAdd(N_xxxx, M00,
57
                    VectorMultiplyAdd(N_yyyy, M10,
58
                    VectorMultiplyAdd(N_zzzz, M20, M30)));
59

60
    // 处理切线和法线
61
    N_xxxx = VectorReplicate(SrcNormals[1], 0);
62
    N_yyyy = VectorReplicate(SrcNormals[1], 1);
63
    N_zzzz = VectorReplicate(SrcNormals[1], 2);
64
    DstNormals[1] = VectorNormalize(VectorMultiplyAdd(N_xxxx, M00,
65
                    VectorMultiplyAdd(N_yyyy, M10, VectorMultiply(N_zzzz, M20))));
66

67
    N_xxxx = VectorReplicate(SrcNormals[2], 0);
68
    N_yyyy = VectorReplicate(SrcNormals[2], 1);
69
    N_zzzz = VectorReplicate(SrcNormals[2], 2);
70
    DstNormals[2] = VectorNormalize(VectorMultiplyAdd(N_xxxx, M00,
71
                    VectorMultiplyAdd(N_yyyy, M10, VectorMultiply(N_zzzz, M20))));
72

73
    // 保持W分量（基向量的行列式符号）
74
    DstNormals[2] = VectorMultiplyAdd(VECTOR_0001, SrcNormals[2], DstNormals[2]);
75

76
    // 写入内存
77
    VectorStoreFloat3(DstNormals[0], &DestVertex->Position);
78
    Pack3(DstNormals[1], &DestVertex->TangentX.Vector.Packed);
79
    Pack4(DstNormals[2], &DestVertex->TangentZ.Vector.Packed);
80
    VectorResetFloatRegisters();
81
}

1
struct FMorphTargetInfo
2
{
3
    int32 WeightIndex = INDEX_NONE;     // 权重列表中的索引
4
    int32 NextDeltaIndex = INDEX_NONE;  // 下一个要应用的Delta索引
5
    const FMorphTargetDelta* Deltas = nullptr;  // Delta数组
6
    int32 NumDeltas = 0;                // Delta数量
7
};
8

9
// 初始化Morph Target评估信息
10
static uint32 InitEvalInfos(const FMorphTargetWeightMap& InActiveMorphTargets,
11
                           const TArray<float>& MorphTargetWeights,
12
                           int32 LODIndex,
13
                           TArray<FMorphTargetInfo>& OutEvalInfos)
14
{
15
    uint32 NumValidMorphTargets = 0;
16
    const float MorphTargetMaxBlendWeight = UE::SkeletalRender::Settings::GetMorphTargetMaxBlendWeight();
17

18
    for(const TTuple<const UMorphTarget*, int32>& MorphItem : InActiveMorphTargets)
19
    {
20
        FMorphTargetInfo NewInfo;
21
        const UMorphTarget* MorphTarget = MorphItem.Key;
22
        const int32 WeightIndex = MorphItem.Value;
23

24
        const float ActiveMorphAbsVertexWeight = FMath::Abs(MorphTargetWeights[WeightIndex]);
25

26
        // 检查Morph Target是否有效且权重在有效范围内
27
        if(MorphTarget != nullptr &&
28
           ActiveMorphAbsVertexWeight >= MinMorphTargetBlendWeight &&
29
           ActiveMorphAbsVertexWeight <= MorphTargetMaxBlendWeight &&
30
           MorphTarget->HasDataForLOD(LODIndex))
31
        {
32
            NewInfo.WeightIndex = WeightIndex;
33
            NewInfo.NextDeltaIndex = 0;
34
            NewInfo.Deltas = MorphTarget->GetMorphTargetDelta(LODIndex, NewInfo.NumDeltas);
35
            NumValidMorphTargets++;
36
        }
37

38
        OutEvalInfos.Add(NewInfo);
39
    }
40
    return NumValidMorphTargets;
41
}

1
template<typename VertexType>
2
FORCEINLINE void UpdateMorphedVertex(
3
    VertexType& MorphedVertex,
4
    const VertexType& SrcVertex,
5
    int32 CurBaseVertIdx,
6
    int32 LODIndex,
7
    TArray<FMorphTargetInfo>& EvalInfos,
8
    const TArray<float>& MorphWeights)
9
{
10
    MorphedVertex = SrcVertex;
11

12
    // 遍历所有活跃的Morph Target
13
    for(int32 MorphIdx = 0; MorphIdx < EvalInfos.Num(); MorphIdx++)
14
    {
15
        FMorphTargetInfo& Info = EvalInfos[MorphIdx];
16

17
        // 检查下一个Delta是否匹配当前顶点
18
        if(Info.NextDeltaIndex != INDEX_NONE &&
19
           Info.NextDeltaIndex < Info.NumDeltas &&
20
           Info.Deltas[Info.NextDeltaIndex].SourceIdx == CurBaseVertIdx)
21
        {
22
            // 应用Morph Target混合
23
            ApplyMorphBlend(MorphedVertex, Info.Deltas[Info.NextDeltaIndex],
24
                           MorphWeights[Info.WeightIndex]);
25

26
            // 更新下一个Delta索引
27
            Info.NextDeltaIndex += 1;
28
        }
29
    }
30

31
    // 重建正交标准化的切线基
32
    RebuildTangentBasis(MorphedVertex);
33
}
34

35
template<typename VertexType>
36
FORCEINLINE void ApplyMorphBlend(VertexType& DestVertex,
37
                                const FMorphTargetDelta& SrcMorph,
38
                                float Weight)
39
{
40
    // 添加位置偏移
41
    DestVertex.Position += SrcMorph.PositionDelta * Weight;
42

43
    // 保存W分量（TangentZ的W存储基向量行列式符号）
44
    int8 W = DestVertex.TangentZ.Vector.W;
45

46
    FVector TanZ = DestVertex.TangentZ.ToFVector();
47

48
    // 添加法线偏移（法线Delta权重最大限制为1.0）
49
    DestVertex.TangentZ = (TanZ + FVector(SrcMorph.TangentZDelta * FMath::Min(Weight, 1.0f))).GetUnsafeNormal();
50

51
    // 恢复W分量
52
    DestVertex.TangentZ.Vector.W = W;
53
}
54

55
template<typename VertexType>
56
FORCEINLINE void RebuildTangentBasis(VertexType& DestVertex)
57
{
58
    // 通过将新法线与基切线向量正交标准化来重建切线
59
    FVector Tangent = DestVertex.TangentX.ToFVector();
60
    FVector Normal = DestVertex.TangentZ.ToFVector();
61
    Tangent = Tangent - ((Tangent | Normal) * Normal);
62
    Tangent.Normalize();
63
    DestVertex.TangentX = Tangent;
64
}

1
// 布料模拟的CPU实现
2
struct ClothCPU
3
{
4
    // 获取布料模拟位置
5
    FORCEINLINE static FVector GetClothSimulPosition(const FClothSimulData& InClothSimData, int32 InIndex)
6
    {
7
        if (InClothSimData.Positions.IsValidIndex(InIndex))
8
        {
9
            return FVector(InClothSimData.Transform.TransformPosition(
10
                (FVector)InClothSimData.Positions[InIndex]));
11
        }
12
        return FVector::ZeroVector;
13
    }
14

15
    // 获取布料模拟法线
16
    FORCEINLINE static FVector GetClothSimulNormal(const FClothSimulData& InClothSimData, int32 InIndex)
17
    {
18
        if (InClothSimData.Normals.IsValidIndex(InIndex))
19
        {
20
            return FVector(InClothSimData.Transform.TransformVector(
21
                (FVector)InClothSimData.Normals[InIndex]));
22
        }
23
        return FVector(0, 0, 1);
24
    }
25

26
    // 计算布料位置（使用重心坐标插值）
27
    FORCEINLINE static FVector ClothingPosition(const FMeshToMeshVertData& InClothVertData,
28
                                               const FClothSimulData& InClothSimData,
29
                                               const FVector& InWorldScaleAbs)
30
    {
31
        return InClothVertData.PositionBaryCoordsAndDist.X *
32
               (GetClothSimulPosition(InClothSimData, InClothVertData.SourceMeshVertIndices[0]) +
33
                GetClothSimulNormal(InClothSimData, InClothVertData.SourceMeshVertIndices[0]) *
34
                InClothVertData.PositionBaryCoordsAndDist.W * InWorldScaleAbs.X)
35
             + /* 类似地处理Y和Z分量 */;
36
    }
37
};

1
// 在SkinVertexSection中应用布料模拟
2
if (ClothVertData != nullptr && ClothVertData->SourceMeshVertIndices[3] < FIXED_VERTEX_INDEX)
3
{
4
    // 构建模拟位置（世界空间）
5
    FVector SimulatedPositionWorld = ClothCPU::ClothingPosition(*ClothVertData, *ClothSimData, WorldScaleAbs);
6

7
    // 转换回局部空间
8
    FVector3f SimulatedPosition = (FVector4f)WorldToLocal.TransformPosition(SimulatedPositionWorld);
9

10
    // 计算顶点混合权重
11
    const float VertexBlend = ClothBlendWeight * (1.0f - (ClothVertData->SourceMeshVertIndices[3] / 65535.0f));
12

13
    // 在蒙皮位置和模拟位置之间插值
14
    DestVertex->Position = FMath::Lerp(DestVertex->Position, SimulatedPosition, VertexBlend);
15

16
    // 重新计算切线和法线
17
    FVector TangentX, TangentZ;
18
    ClothCPU::ClothingTangents(*ClothVertData, *ClothSimData, SimulatedPositionWorld,
19
                              WorldToLocal, WorldScaleAbs, TangentX, TangentZ);
20

21
    // 在蒙皮切线和模拟切线之间插值
22
    FVector SkinnedTangentX = DestVertex->TangentX.ToFVector();
23
    FVector4 SkinnedTangentZ = DestVertex->TangentZ.ToFVector4();
24
    DestVertex->TangentX = (TangentX * VertexBlend) + (SkinnedTangentX * (1.0f - VertexBlend));
25
    DestVertex->TangentZ = FVector4((TangentZ * VertexBlend) + (SkinnedTangentZ * (1.0f - VertexBlend)),
26
                                   SkinnedTangentZ.W);
27
}

1
// 在CacheVertices函数的最后部分
2
void UpdateGPUBuffers(const FSkeletalMeshLODRenderData& LOD,
3
                     const FSkeletalMeshObjectLOD& MeshLOD,
4
                     FRHICommandList& RHICmdList)
5
{
6
    check(LOD.GetNumVertices() == CachedFinalVertices.Num());
7

8
    // 更新位置和切线数据
9
    for (int i = 0; i < CachedFinalVertices.Num(); i++)
10
    {
11
        // 位置缓冲区
12
        MeshLOD.PositionVertexBuffer.VertexPosition(i) = CachedFinalVertices[i].Position;
13

14
        // 切线缓冲区
15
        MeshLOD.StaticMeshVertexBuffer.SetVertexTangents(i,
16
            (FVector3f)CachedFinalVertices[i].TangentX.ToFVector(),
17
            CachedFinalVertices[i].GetTangentY(),
18
            (FVector3f)CachedFinalVertices[i].TangentZ.ToFVector());
19

20
        // UV坐标
21
        for (uint32 UVIndex = 0; UVIndex < LOD.StaticVertexBuffers.StaticMeshVertexBuffer.GetNumTexCoords(); ++UVIndex)
22
        {
23
            MeshLOD.StaticMeshVertexBuffer.SetVertexUV(i, UVIndex,
24
                FVector2f(CachedFinalVertices[i].TextureCoordinates[UVIndex].X,
25
                         CachedFinalVertices[i].TextureCoordinates[UVIndex].Y));
26
        }
27
    }
28

29
    // 更新RHI缓冲区
30
    MeshLOD.PositionVertexBuffer.UpdateRHI(RHICmdList);
31
    MeshLOD.StaticMeshVertexBuffer.UpdateRHI(RHICmdList);
32

33
    // 重新绑定顶点工厂
34
    FLocalVertexFactory::FDataType Data;
35
    MeshLOD.PositionVertexBuffer.BindPositionVertexBuffer(&MeshLOD.VertexFactory, Data);
36
    MeshLOD.StaticMeshVertexBuffer.BindTangentVertexBuffer(&MeshLOD.VertexFactory, Data);
37
    MeshLOD.StaticMeshVertexBuffer.BindPackedTexCoordVertexBuffer(&MeshLOD.VertexFactory, Data, MAX_TEXCOORDS);
38
    MeshLOD.StaticMeshVertexBuffer.BindLightMapVertexBuffer(&MeshLOD.VertexFactory, Data, 0);
39
    MeshLOD.MeshObjectColorBuffer->BindColorVertexBuffer(&MeshLOD.VertexFactory, Data);
40

41
    MeshLOD.VertexFactory.SetData(RHICmdList, Data);
42
    MeshLOD.VertexFactory.InitResource(RHICmdList);
43
}

1
static void CalculateBoneWeights(FFinalSkinVertex* DestVertex,
2
                                FSkeletalMeshLODRenderData& LOD,
3
                                FSkinWeightVertexBuffer& WeightBuffer,
4
                                TArray<int32> InBonesOfInterest)
5
{
6
    int32 VertexBufferBaseIndex = 0;
7

8
    for(int32 SectionIndex = 0; SectionIndex < LOD.RenderSections.Num(); SectionIndex++)
9
    {
10
        FSkelMeshRenderSection& Section = LOD.RenderSections[SectionIndex];
11
        CalculateSectionBoneWeights(DestVertex, WeightBuffer, Section, InBonesOfInterest);
12
    }
13
}
14

15
static FORCEINLINE void CalculateSectionBoneWeights(FFinalSkinVertex*& DestVertex,
16
                                                   FSkinWeightVertexBuffer& SkinWeightVertexBuffer,
17
                                                   FSkelMeshRenderSection& Section,
18
                                                   const TArray<int32>& BonesOfInterest)
19
{
20
    FBoneIndexType* BoneMap = Section.BoneMap.GetData();
21

22
    for(int32 VertexIndex = 0; VertexIndex < Section.GetNumVertices(); VertexIndex++, DestVertex++)
23
    {
24
        const int32 VertexBufferIndex = Section.GetVertexBufferIndex() + VertexIndex;
25
        FSkinWeightInfo SrcWeight = SkinWeightVertexBuffer.GetVertexSkinWeights(VertexBufferIndex);
26

27
        // 清零 UV 坐标
28
        DestVertex->TextureCoordinates[0].X = 0.0f;
29
        DestVertex->TextureCoordinates[0].Y = 0.0f;
30

31
        const FBoneIndexType* RESTRICT BoneIndices = SrcWeight.InfluenceBones;
32
        const uint16* RESTRICT BoneWeights = SrcWeight.InfluenceWeights;
33

34
        // 累积感兴趣骨骼的权重
35
        for (uint32 i = 0; i < SkinWeightVertexBuffer.GetMaxBoneInfluences(); i++)
36
        {
37
            if (BonesOfInterest.Contains(BoneMap[BoneIndices[i]]))
38
            {
39
                DestVertex->TextureCoordinates[0].X += BoneWeights[i] / 65535.0;
40
                DestVertex->TextureCoordinates[0].Y += BoneWeights[i] / 65535.0;
41
            }
42
        }
43
    }
44
}

1
static void CalculateMorphTargetWeights(FFinalSkinVertex* DestVertex,
2
                                       FSkeletalMeshLODRenderData& LOD,
3
                                       int LODIndex,
4
                                       TArray<UMorphTarget*> InMorphTargetOfInterest)
5
{
6
    const FFinalSkinVertex* EndVert = DestVertex + LOD.GetNumVertices();
7

8
    // 清零所有顶点的 UV 坐标
9
    for (FFinalSkinVertex* ClearVert = DestVertex; ClearVert != EndVert; ++ClearVert)
10
    {
11
        ClearVert->TextureCoordinates[0].X = 0.0f;
12
        ClearVert->TextureCoordinates[0].Y = 0.0f;
13
    }
14

15
    // 为每个感兴趣的 Morph Target 标记受影响的顶点
16
    for (const UMorphTarget* Morphtarget : InMorphTargetOfInterest)
17
    {
18
        int32 NumDeltas;
19
        const FMorphTargetDelta* MTLODVertices = Morphtarget->GetMorphTargetDelta(LODIndex, NumDeltas);
20

21
        for (int32 MorphVertexIndex = 0; MorphVertexIndex < NumDeltas; ++MorphVertexIndex)
22
        {
23
            FFinalSkinVertex* SetVert = DestVertex + MTLODVertices[MorphVertexIndex].SourceIdx;
24
            SetVert->TextureCoordinates[0].X += 1.0f;
25
            SetVert->TextureCoordinates[0].Y += 1.0f;
26
        }
27
    }
28
}