SkeletalMeshLODModel.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#if WITH_EDITOR
 
#include "Animation/SkeletalMeshVertexAttribute.h"
#include "Animation/SkinWeightProfile.h"
#include "Async/Mutex.h"
#include "Async/UniqueLock.h"
#include "BoneIndices.h"
#include "Components.h"
#include "GPUSkinPublicDefs.h"
#include "HAL/CriticalSection.h"
#include "Rendering/SkeletalMeshLODImporterData.h"
#include "Serialization/BulkData.h"
#include "SkeletalMeshTypes.h"
 
struct FSkelMeshSection
{
    uint16 MaterialIndex;
 
    uint32 BaseIndex;
 
    uint32 NumTriangles;
 
    uint8 bSelected : 1;
 
    bool bRecomputeTangent;
 
    ESkinVertexColorChannel RecomputeTangentsVertexMaskChannel;
 
    bool bCastShadow;
    
    bool bVisibleInRayTracing;
 
    bool bLegacyClothingSection_DEPRECATED;
 
    int16 CorrespondClothSectionIndex_DEPRECATED;
 
    uint32 BaseVertexIndex;
 
    TArray<FSoftSkinVertex> SoftVertices;
 
    TArray<TArray<FMeshToMeshVertData>> ClothMappingDataLODs;
 
    TArray<FBoneIndexType> BoneMap;
 
    int32 NumVertices;
 
    int32 MaxBoneInfluences;
 
    bool bUse16BitBoneIndex;
 
    // INDEX_NONE if not set
    int16 CorrespondClothAssetIndex;
 
    FClothingSectionData ClothingData;
 
    TMap<int32, TArray<int32>> OverlappingVertices;
 
    bool bDisabled;
 
    /*
     * The LOD index at which any generated lower quality LODs will include this section.
     * A value of -1 mean the section will always be include when generating a LOD
     */
    int32 GenerateUpToLodIndex;
 
    /*
     * This represent the original section index in the imported data. The original data is chunk per material,
     * we use this index to store user section modification. The user cannot change a BONE chunked section data,
     * since the BONE chunk can be per-platform. Do not use this value to index the Sections array, only the user
     * section data should be index by this value.
     */
    int32 OriginalDataSectionIndex;
 
    /*
     * If this section was produce because of BONE chunking, the parent section index will be valid.
     * If the section is not the result of skin vertex chunking, this value will be INDEX_NONE.
     * Use this value to know if the section was BONE chunked:
     * if(ChunkedParentSectionIndex != INDEX_NONE) will be true if the section is BONE chunked
     */
    int32 ChunkedParentSectionIndex;
 
 
 
    FSkelMeshSection()
        : MaterialIndex(0)
        , BaseIndex(0)
        , NumTriangles(0)
        , bSelected(false)
        , bRecomputeTangent(false)
        , RecomputeTangentsVertexMaskChannel(ESkinVertexColorChannel::None)
        , bCastShadow(true)
        , bVisibleInRayTracing(true)
        , bLegacyClothingSection_DEPRECATED(false)
        , CorrespondClothSectionIndex_DEPRECATED(-1)
        , BaseVertexIndex(0)
        , NumVertices(0)
        , MaxBoneInfluences(4)
        , bUse16BitBoneIndex(false)
        , CorrespondClothAssetIndex(INDEX_NONE)
        , bDisabled(false)
        , GenerateUpToLodIndex(INDEX_NONE)
        , OriginalDataSectionIndex(INDEX_NONE)
        , ChunkedParentSectionIndex(INDEX_NONE)
    {}
 
 
    inline int32 GetNumVertices() const
    {
        // Either SoftVertices should be empty, or size should match NumVertices
        check(SoftVertices.Num() == 0 || SoftVertices.Num() == NumVertices);
        return NumVertices;
    }
 
    inline int32 GetVertexBufferIndex() const
    {
        return BaseVertexIndex;
    }
 
    inline bool HasClothingData() const
    {
        constexpr int32 ClothLODBias = 0;  // Must at least have the mapping for the matching cloth LOD
        return ClothMappingDataLODs.Num() && ClothMappingDataLODs[ClothLODBias].Num();
    }
 
    ENGINE_API void CalcMaxBoneInfluences();
 
    inline int32 GetMaxBoneInfluences() const
    {
        return MaxBoneInfluences;
    }
 
    ENGINE_API void CalcUse16BitBoneIndex();
 
    inline bool Use16BitBoneIndex() const
    {
        return bUse16BitBoneIndex;
    }
 
    // Serialization.
    friend FArchive& operator<<(FArchive& Ar, FSkelMeshSection& S);
    static void DeclareCustomVersions(FArchive& Ar);
};
 
class FSkelMeshSectionArray : public TArray<FSkelMeshSection, TInlineAllocator<1>>
{
    using Super = TArray<FSkelMeshSection, TInlineAllocator<1>>;
public:
    using Super::Super;
};
 
struct FSkelMeshSourceSectionUserData
{
    bool bRecomputeTangent;
    
    ESkinVertexColorChannel RecomputeTangentsVertexMaskChannel;
 
    bool bCastShadow;
 
    bool bVisibleInRayTracing;
 
    // INDEX_NONE if not set
    int16 CorrespondClothAssetIndex;
 
    FClothingSectionData ClothingData;
 
 
    // Skeletal mesh DDC key members, Add sections member that impact generated skel mesh here
 
    bool bDisabled;
 
    /*
     * The LOD index at which any generated lower quality LODs will include this section.
     * A value of -1 mean the section will always be include when generating a LOD
     */
    int32 GenerateUpToLodIndex;
 
    // End DDC members
 
 
 
    FSkelMeshSourceSectionUserData()
        : bRecomputeTangent(false)
        , RecomputeTangentsVertexMaskChannel(ESkinVertexColorChannel::None)
        , bCastShadow(true)
        , bVisibleInRayTracing(true)
        , CorrespondClothAssetIndex(INDEX_NONE)
        , bDisabled(false)
        , GenerateUpToLodIndex(INDEX_NONE)
    {}
 
    inline bool HasClothingData() const
    {
        return (ClothingData.AssetGuid.IsValid());
    }
 
    static FSkelMeshSourceSectionUserData& GetSourceSectionUserData(TMap<int32, FSkelMeshSourceSectionUserData>& UserSectionsData, const FSkelMeshSection& Section)
    {
        FSkelMeshSourceSectionUserData* UserSectionData = UserSectionsData.Find(Section.OriginalDataSectionIndex);
        if (!UserSectionData)
        {
            //If the UserSectionData do not exist add it and copy from the section data
            UserSectionData = &UserSectionsData.Add(Section.OriginalDataSectionIndex);
            UserSectionData->bCastShadow = Section.bCastShadow;
            UserSectionData->bVisibleInRayTracing = Section.bVisibleInRayTracing;           
            UserSectionData->bDisabled = Section.bDisabled;
            UserSectionData->bRecomputeTangent = Section.bRecomputeTangent;
            UserSectionData->RecomputeTangentsVertexMaskChannel = Section.RecomputeTangentsVertexMaskChannel;
            UserSectionData->GenerateUpToLodIndex = Section.GenerateUpToLodIndex;
            UserSectionData->CorrespondClothAssetIndex = Section.CorrespondClothAssetIndex;
            UserSectionData->ClothingData.AssetGuid = Section.ClothingData.AssetGuid;
            UserSectionData->ClothingData.AssetLodIndex = Section.ClothingData.AssetLodIndex;
        }
        check(UserSectionData);
        return *UserSectionData;
    }
    // Serialization.
    friend FArchive& operator<<(FArchive& Ar, FSkelMeshSourceSectionUserData& S);
};
 
class FSkeletalMeshLODModel
{
public:
    TArray<FSkelMeshSection> Sections;
 
    /*
     * When user change section data in the UI, we store it here to be able to regenerate the changes
     * Note: the key (int32) is the original imported section data, because of BONE chunk the size of
     * this array is not the same as the Sections array. Use the section's OriginalDataSectionIndex to
     * index it.
     */
    TMap<int32, FSkelMeshSourceSectionUserData> UserSectionsData;
 
    uint32                      NumVertices;
    uint32                      NumTexCoords;
 
    TArray<uint32> IndexBuffer;
 
    TArray<FBoneIndexType> ActiveBoneIndices;
 
    TArray<FBoneIndexType> RequiredBones;
 
    TMap<FName, FImportedSkinWeightProfileData> SkinWeightProfiles;
 
    TMap<FName, FSkeletalMeshModelVertexAttribute> VertexAttributes;
 
    TArray<int32>               MeshToImportVertexMap;
    
    int32                       MaxImportVertex;
 
    const TArray<uint32>& GetRawPointIndices() const
    {
        return RawPointIndices2;
    }
 
    TArray<uint32>& GetRawPointIndices()
    {
        return RawPointIndices2;
    }
    
    UE_DEPRECATED(5.0, "Please do not access this function anymore. This data is not use anymore.")
    FRawSkeletalMeshBulkData& GetRawSkeletalMeshBulkData_DEPRECATED()
    {
        return RawSkeletalMeshBulkData_DEPRECATED;
    }
 
    FString                     RawSkeletalMeshBulkDataID;
    bool                        bIsBuildDataAvailable;
    bool                        bIsRawSkeletalMeshBulkDataEmpty;
 
    FSkeletalMeshLODModel()
        : NumVertices(0)
        , NumTexCoords(0)
        , MaxImportVertex(-1)
        , RawSkeletalMeshBulkDataID(TEXT(""))
        , bIsBuildDataAvailable(false)
        , bIsRawSkeletalMeshBulkDataEmpty(true)
        , BuildStringID(TEXT(""))
    {
        //Sice this ID is part of the DDC Key, we have to set it to an empty GUID not an empty string
        RawSkeletalMeshBulkDataID = FGuid().ToString();
        //Allocate the private mutex
        BulkDataReadMutex = new FCriticalSection();
    }
 
    ~FSkeletalMeshLODModel()
    {
        //Release the allocate resources
        if(BulkDataReadMutex != nullptr)
        {
            delete BulkDataReadMutex;
            BulkDataReadMutex = nullptr;
        }
    }
 
    FSkeletalMeshLODModel(FSkeletalMeshLODModel&& InOther)
    {
        Sections = MoveTemp(InOther.Sections);
        UserSectionsData = MoveTemp(InOther.UserSectionsData);
        NumVertices = InOther.NumVertices;
        NumTexCoords = InOther.NumTexCoords;
        IndexBuffer = MoveTemp(InOther.IndexBuffer);
        ActiveBoneIndices = MoveTemp(InOther.ActiveBoneIndices);
        RequiredBones = MoveTemp(InOther.RequiredBones);
        SkinWeightProfiles = MoveTemp(InOther.SkinWeightProfiles);
        VertexAttributes = MoveTemp(InOther.VertexAttributes);
        MeshToImportVertexMap = MoveTemp(InOther.MeshToImportVertexMap);
        MaxImportVertex = InOther.MaxImportVertex;
        RawSkeletalMeshBulkDataID = MoveTemp(InOther.RawSkeletalMeshBulkDataID);
        bIsBuildDataAvailable = InOther.bIsBuildDataAvailable;
        bIsRawSkeletalMeshBulkDataEmpty = InOther.bIsRawSkeletalMeshBulkDataEmpty;
        ImportedMeshInfos = MoveTemp(InOther.ImportedMeshInfos);
        RawPointIndices2 = MoveTemp(InOther.RawPointIndices2);
        BulkDataReadMutex = InOther.BulkDataReadMutex;
        InOther.BulkDataReadMutex = nullptr;
        BuildStringID = InOther.BuildStringID;
    }
 
    /*Empty the skeletal mesh LOD model. Empty copy a default constructed FSkeletalMeshLODModel but will not copy the BulkDataReadMutex which will be the same after*/
    void Empty()
    {
        FCriticalSection* BackupBulkDataReadMutex = BulkDataReadMutex;
        *this = FSkeletalMeshLODModel();
        BulkDataReadMutex = BackupBulkDataReadMutex;
    }
 
private:
    friend struct FSkeletalMeshSourceModel;
    
    struct FSkelMeshImportedMeshInfo
    {
        FName Name; // The name of the mesh.
        int32 NumVertices;  // The number of imported (dcc) vertices that are part of this mesh. This is a value of 8 for a cube. So NOT the number of render vertices.
        int32 StartImportedVertex;  // The first index of imported (dcc) vertices in the mesh. So this NOT an index into the render vertex buffer. In range of 0..7 for a cube.
 
        void Serialize(FArchive& Ar)
        {
            Ar << Name;
            Ar << NumVertices;
            Ar << StartImportedVertex;
        }
    };
    friend FArchive& operator<<(FArchive& Ar, FSkelMeshImportedMeshInfo& Info)
    {
        Info.Serialize(Ar);
        return Ar;
    }
 
    TArray<FSkelMeshImportedMeshInfo> ImportedMeshInfos;
 
    TArray<uint32>              RawPointIndices2;
 
    FIntBulkData                RawPointIndices_DEPRECATED;
    FWordBulkData               LegacyRawPointIndices_DEPRECATED;
    FRawSkeletalMeshBulkData    RawSkeletalMeshBulkData_DEPRECATED;
 
    //Mutex use by the CopyStructure function. It's a pointer because FCriticalSection privatize the operator= function, which will prevent this class operator= to use the default.
    //We want to avoid having a custom equal operator that will get deprecated if dev forget to add the new member in this class
    //The CopyStructure function will copy everything but make sure the destination mutex is set to a new mutex pointer.
    FCriticalSection* BulkDataReadMutex;
 
    //Use the static FSkeletalMeshLODModel::CopyStructure function to copy from one instance to another
    //The reason is we want the copy to be multithread safe and use the BulkDataReadMutex.
    FSkeletalMeshLODModel& operator=(const FSkeletalMeshLODModel& Other) = default;
 
    //Use the static FSkeletalMeshLODModel::CreateCopy function to copy from one instance to another
    //The reason is we want the copy to be multithread safe and use the BulkDataReadMutex.
    FSkeletalMeshLODModel(const FSkeletalMeshLODModel& Other) = delete;
 
public:
    void Serialize(FArchive& Ar, UObject* Owner, int32 Idx);
    static void DeclareCustomVersions(FArchive& Ar);
 
    ENGINE_API void GetVertices(TArray<FSoftSkinVertex>& Vertices) const;
 
    void GetClothMappingData(TArray<FMeshToMeshVertData>& MappingData, TArray<FClothBufferIndexMapping>& OutClothIndexMapping) const;
 
 
 
    ENGINE_API void GetSectionFromVertexIndex(int32 InVertIndex, int32& OutSectionIndex, int32& OutVertIndex) const;
 
    ENGINE_API bool HasClothData() const;
 
    ENGINE_API int32 NumNonClothingSections() const;
 
    ENGINE_API int32 GetNumNonClothingVertices() const;
 
    ENGINE_API void GetNonClothVertices(TArray<FSoftSkinVertex>& OutVertices) const;
 
    ENGINE_API int32 GetMaxBoneInfluences() const;
    ENGINE_API bool DoSectionsUse16BitBoneIndex() const;
 
    void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) const;
 
    ENGINE_API void SyncronizeUserSectionsDataArray(bool bResetNonUsedSection = false);
 
    // Offers protected access while supporting copy.
    struct FThreadSafeBuildStringID
    {
    private:
        FString    BuildStringID;
        mutable UE::FMutex Mutex;
    public:
        FThreadSafeBuildStringID() = default;
        FThreadSafeBuildStringID(const TCHAR* InText)
            : BuildStringID(InText)
        {
        }
 
        FThreadSafeBuildStringID(const FThreadSafeBuildStringID& Other)
        {
            UE::TUniqueLock OtherLock(Other.Mutex);
            UE::TUniqueLock Lock(Mutex);
            BuildStringID = Other.BuildStringID;
        }
 
        FThreadSafeBuildStringID& operator=(const FThreadSafeBuildStringID& Other)
        {
            if (&Other != this)
            {
                UE::TUniqueLock OtherLock(Other.Mutex);
                UE::TUniqueLock Lock(Mutex);
                BuildStringID = Other.BuildStringID;
            }
            return *this;
        }
 
        bool operator==(const FString& Other) const
        {
            UE::TUniqueLock Lock(Mutex);
            return BuildStringID == Other;
        }
 
        bool operator==(const FThreadSafeBuildStringID& Other) const
        {
            if (&Other == this)
            {
                return true;
            }
 
            UE::TUniqueLock OtherLock(Other.Mutex);
            UE::TUniqueLock Lock(Mutex);
            return BuildStringID == Other.BuildStringID;
        }
 
        void operator=(const FString& Other)
        {
            UE::TUniqueLock Lock(Mutex);
            BuildStringID = Other;
        }
 
        operator FString() const
        {
            UE::TUniqueLock Lock(Mutex);
            return BuildStringID;
        }
 
        FThreadSafeBuildStringID(FThreadSafeBuildStringID&&) = delete;
        FThreadSafeBuildStringID& operator=(FThreadSafeBuildStringID&&) = delete;
    };
 
    //Temporary build String ID
    //We use this string to store the LOD model data so we can know if the LOD need to be rebuild
    //This GUID is set when we Cache the render data (build function)
    mutable FThreadSafeBuildStringID BuildStringID;
 
    ENGINE_API FString GetLODModelDeriveDataKey() const;
 
    ENGINE_API void UpdateChunkedSectionInfo(const FString& SkeletalMeshName);
 
    static ENGINE_API void CopyStructure(FSkeletalMeshLODModel* Destination, const FSkeletalMeshLODModel* Source);
 
    static FSkeletalMeshLODModel* CreateCopy(const FSkeletalMeshLODModel* Other)
    {
        FSkeletalMeshLODModel* Destination = new FSkeletalMeshLODModel();
        FSkeletalMeshLODModel::CopyStructure(Destination, Other);
        return Destination;
    }
 
    void ENGINE_API GetMeshDescription(const USkeletalMesh *InSkeletalMesh, const int32 InLODIndex, FMeshDescription& OutMeshDescription) const;
};
 
#endif // WITH_EDITOR