SkeletalMeshMerge.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    SkeletalMeshMerge.h: Merging of unreal skeletal mesh objects.
=============================================================================*/
 
/*-----------------------------------------------------------------------------
FSkeletalMeshMerge
-----------------------------------------------------------------------------*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Engine/EngineTypes.h"
#include "ReferenceSkeleton.h"
#include "Components.h"
 
#include "SkeletalMeshMerge.generated.h"
 
class UMaterialInterface;
class USkeletalMesh;
class USkeletalMeshSocket;
class USkeleton;
class FSkeletalMeshLODRenderData;
struct FSkelMeshRenderSection;
 
struct FRefPoseOverride
{
 public:
 
    enum EBoneOverrideMode
    {
        BoneOnly,           // Override the bone only.
        ChildrenOnly,       // Override the bone's children only.
        BoneAndChildren,    // Override both the bone & children.
        MAX,
    };
 
    FRefPoseOverride(const USkeletalMesh* ReferenceMesh)
    {
        this->SkeletalMesh = ReferenceMesh;
    }
 
    void AddOverride(FName BoneName, EBoneOverrideMode OverrideMode = BoneOnly)
    {
        FBoneOverrideInfo OverrideInfo;
        OverrideInfo.BoneName = BoneName;
        OverrideInfo.OverrideMode = OverrideMode;
 
        Overrides.Add(OverrideInfo);
    }
 
 private:
 
     struct FBoneOverrideInfo
     {
         FName BoneName;
 
         EBoneOverrideMode OverrideMode;
     };
 
    const USkeletalMesh* SkeletalMesh;
 
    TArray<FBoneOverrideInfo> Overrides;
 
    friend class FSkeletalMeshMerge;
};
 
USTRUCT(BlueprintType)
struct FSkelMeshMergeSectionMapping
{
    GENERATED_USTRUCT_BODY()
    
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Merge Parameters")
    TArray<int32> SectionIDs;
};
 
USTRUCT(BlueprintType)
struct FSkelMeshMergeMeshUVTransforms
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Merge Parameters")
    TArray<FTransform> UVTransforms;
};
 
struct UE_DEPRECATED(5.0, "FSkelMeshMergeUVTransforms has been deprecated, use FSkelMeshMergeMeshUVTransforms instead") FSkelMeshMergeUVTransforms
{
    TArray<TArray<FTransform>> UVTransformsPerMesh;
};
 
USTRUCT(BlueprintType)
struct FSkelMeshMergeUVTransformMapping
{
    GENERATED_USTRUCT_BODY()
    
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Mesh Merge Parameters")
    TArray<FSkelMeshMergeMeshUVTransforms> UVTransformsPerMesh;
};
 
class FSkeletalMeshMerge
{
public:
    ENGINE_API FSkeletalMeshMerge( 
        USkeletalMesh* InMergeMesh, 
        const TArray<USkeletalMesh*>& InSrcMeshList, 
        const TArray<FSkelMeshMergeSectionMapping>& InForceSectionMapping,
        int32 StripTopLODs,
        EMeshBufferAccess MeshBufferAccess=EMeshBufferAccess::Default,
        const FSkelMeshMergeUVTransformMapping* InSectionUVTransforms = nullptr
        );
 
    UE_DEPRECATED(5.0, "FSkelMeshMergeUVTransforms has been replaced with FSkelMeshMergeMeshUVTransforms, use different signature")
    ENGINE_API FSkeletalMeshMerge( 
            USkeletalMesh* InMergeMesh, 
            const TArray<USkeletalMesh*>& InSrcMeshList, 
            const TArray<FSkelMeshMergeSectionMapping>& InForceSectionMapping,
            int32 StripTopLODs,
            EMeshBufferAccess MeshBufferAccess,
            PRAGMA_DISABLE_DEPRECATION_WARNINGS
            FSkelMeshMergeUVTransforms* InSectionUVTransforms
            PRAGMA_ENABLE_DEPRECATION_WARNINGS
            );
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    FSkeletalMeshMerge(const FSkeletalMeshMerge&) = default;
    ENGINE_API PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    bool DoMerge(TArray<FRefPoseOverride>* RefPoseOverrides = nullptr);
 
    ENGINE_API void MergeSkeleton(const TArray<FRefPoseOverride>* RefPoseOverrides = nullptr);
 
    ENGINE_API bool FinalizeMesh();
 
private:
    USkeletalMesh* MergeMesh;
    
    TArray<USkeletalMesh*> SrcMeshList;
 
    int32 StripTopLODs;
 
    EMeshBufferAccess MeshBufferAccess;
 
    struct FMergeMeshInfo
    {
        TArray<int32> SrcToDestRefSkeletonMap;
    };
 
    TArray<FMergeMeshInfo> SrcMeshInfo;
 
    FReferenceSkeleton NewRefSkeleton;
 
    const TArray<FSkelMeshMergeSectionMapping>& ForceSectionMapping;
 
    const FSkelMeshMergeUVTransformMapping* SectionUVTransforms;
 
    UE_DEPRECATED(5.0, "Used to facilitate backwards compatibility with old constructor")
    FSkelMeshMergeUVTransformMapping DummySectionUVTransforms;
 
    TArray<int32>   MaterialIds;
 
    struct FMergeSectionInfo
    {
        const USkeletalMesh* SkelMesh;
        const FSkelMeshRenderSection* Section;
        TArray<FBoneIndexType> BoneMapToMergedBoneMap;
        TArray<FTransform> UVTransforms;
 
        FMergeSectionInfo( const USkeletalMesh* InSkelMesh,const FSkelMeshRenderSection* InSection, TArray<FTransform> & InUVTransforms )
            :   SkelMesh(InSkelMesh)
            ,   Section(InSection)
            ,   UVTransforms(InUVTransforms)
        {}
    };
 
    struct FNewSectionInfo
    {
        TArray<FMergeSectionInfo> MergeSections;
        TArray<FBoneIndexType> MergedBoneMap;
        UMaterialInterface* Material;
 
        int32 MaterialId;
 
        FName SlotName;
 
        FMeshUVChannelInfo UVChannelData;
 
        FNewSectionInfo( UMaterialInterface* InMaterial, int32 InMaterialId, FName InSlotName, const FMeshUVChannelInfo& InUVChannelData )
            :   Material(InMaterial)
            ,   MaterialId(InMaterialId)
            ,   SlotName(InSlotName)
            ,   UVChannelData(InUVChannelData)
        {}
    };
 
    ENGINE_API void MergeBoneMap( TArray<FBoneIndexType>& MergedBoneMap, TArray<FBoneIndexType>& BoneMapToMergedBoneMap, const TArray<FBoneIndexType>& BoneMap );
 
    template<typename VertexDataType>
    void GenerateLODModel( int32 LODIdx);
 
    ENGINE_API void GenerateNewSectionArray( TArray<FNewSectionInfo>& NewSectionArray, int32 LODIdx );
 
    ENGINE_API bool ProcessMergeMesh();
 
    ENGINE_API int32 CalculateLodCount(const TArray<USkeletalMesh*>& SourceMeshList) const;
 
    static ENGINE_API void BuildReferenceSkeleton(const TArray<USkeletalMesh*>& SourceMeshList, FReferenceSkeleton& RefSkeleton, const USkeleton* SkeletonAsset);
 
    static ENGINE_API void OverrideReferenceSkeletonPose(const TArray<FRefPoseOverride>& PoseOverrides, FReferenceSkeleton& TargetSkeleton, const USkeleton* SkeletonAsset);
 
    static ENGINE_API bool OverrideReferenceBonePose(int32 SourceBoneIndex, const FReferenceSkeleton& SourceSkeleton, FReferenceSkeletonModifier& TargetSkeleton);
 
    ENGINE_API void ReleaseResources(int32 Slack = 0);
 
    ENGINE_API bool AddSocket(const USkeletalMeshSocket* NewSocket, bool bIsSkeletonSocket);
 
    ENGINE_API void AddSockets(const TArray<USkeletalMeshSocket*>& NewSockets, bool bAreSkeletonSockets);
 
    ENGINE_API void BuildSockets(const TArray<USkeletalMesh*>& SourceMeshList);
 
    //void OverrideSockets(const TArray<FRefPoseOverride>& PoseOverrides);
 
    ENGINE_API void OverrideSocket(const USkeletalMeshSocket* SourceSocket);
 
    ENGINE_API void OverrideBoneSockets(const FName& BoneName, const TArray<USkeletalMeshSocket*>& SourceSocketList);
 
    ENGINE_API void OverrideMergedSockets(const TArray<FRefPoseOverride>& PoseOverrides);
 
    /*
     * Copy Vertex Buffer from Source LOD Model
     */
    template<typename VertexDataType>
    void CopyVertexFromSource(VertexDataType& DestVert, const FSkeletalMeshLODRenderData& SrcLODData, int32 SourceVertIdx, const FMergeSectionInfo& MergeSectionInfo);
};