SkinnedAssetCommon.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "BoneContainer.h"
#include "Components.h"
#include "CoreMinimal.h"
#include "Engine/EngineTypes.h"
#include "UObject/PerPlatformProperties.h"
#include "SkeletalMeshReductionSettings.h"
#include "Animation/SkeletalMeshVertexAttribute.h"
 
#include "SkinnedAssetCommon.generated.h"
 
 
class FSkeletalMeshLODModel;
class UAnimSequence;
class UMaterialInterface;
struct FSkelMeshSection;
struct FSkeletalMeshLODGroupSettings;
 
 
//This is the total cloth time split up among multiple computation (updating gpu, updating sim, etc...)
DECLARE_CYCLE_STAT_EXTERN(TEXT("Cloth Total"), STAT_ClothTotalTime, STATGROUP_Physics, ENGINE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Cloth Writeback"), STAT_ClothWriteback, STATGROUP_Physics, ENGINE_API);
 
UENUM()
enum class ESkinCacheUsage : uint8
{
    // Auto will defer to child or global behavior based on context
    Auto        = 0,
 
    // Mesh will not use the skin cache. However, if Support Ray Tracing is enabled on the mesh, the skin cache will still be used for Ray Tracing updates
    Disabled    = uint8(-1),
 
    // Mesh will use the skin cache
    Enabled     = 1,
};
 
UENUM()
enum class ESkinCacheDefaultBehavior : uint8
{
    // All skeletal meshes are excluded from the skin cache. Each must opt in individually. If Support Ray Tracing is enabled on a mesh, will force inclusive behavior on that mesh
    Exclusive = 0,
 
    // All skeletal meshes are included into the skin cache. Each must opt out individually
    Inclusive = 1,
};
 
USTRUCT()
struct FSectionReference
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, Category = SectionReference)
    int32 SectionIndex;
 
    FSectionReference()
        : SectionIndex(INDEX_NONE)
    {
    }
 
    FSectionReference(const int32& InSectionIndex)
        : SectionIndex(InSectionIndex)
    {
    }
 
    bool operator==(const FSectionReference& Other) const
    {
        return SectionIndex == Other.SectionIndex;
    }
 
#if WITH_EDITOR
    ENGINE_API bool IsValidToEvaluate(const FSkeletalMeshLODModel& LodModel) const;
 
    const FSkelMeshSection* GetMeshLodSection(const FSkeletalMeshLODModel& LodModel) const;
    int32 GetMeshLodSectionIndex(const FSkeletalMeshLODModel& LodModel) const;
#endif
 
    bool Serialize(FArchive& Ar)
    {
        Ar << SectionIndex;
        return true;
    }
 
    friend FArchive& operator<<(FArchive& Ar, FSectionReference& B)
    {
        B.Serialize(Ar);
        return Ar;
    }
};
 
USTRUCT()
struct FMorphTargetImportedSourceFileInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    static FString GeneratedByEnginePrefix;
 
    ENGINE_API const FString& GetSourceFilename() const;
 
    ENGINE_API void SetSourceFilename(const FString& Filename);
 
    ENGINE_API bool IsGeneratedByEngine() const;
 
    ENGINE_API void SetGeneratedByEngine(bool bInGeneratedByEngine);
 
private:
    UPROPERTY(EditAnywhere, Category = MorphTargetInfo)
    FString SourceFilename;
 
    
    UPROPERTY()
    FGuid DerivedDataHash;
 
    friend FArchive& operator<<(FArchive& Ar, FMorphTargetImportedSourceFileInfo& MorphTargetImportedSourceFileInfo);
};
 
USTRUCT()
struct FSkeletalMeshLODInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=SkeletalMeshLODInfo)
    FPerPlatformFloat ScreenSize{ 1.0 };
 
    UPROPERTY(EditAnywhere, Category=SkeletalMeshLODInfo, meta=(DisplayName="LOD Hysteresis"))
    float LODHysteresis = 0.0f;
 
    UPROPERTY()
    TArray<int32> LODMaterialMap;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TArray<bool> bEnableShadowCasting_DEPRECATED;
 
    UPROPERTY()
    TArray<FName> RemovedBones_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, Category = BuildSettings)
    FSkeletalMeshBuildSettings BuildSettings;
 
    UPROPERTY(EditAnywhere, Category = ReductionSettings)
    FSkeletalMeshOptimizationSettings ReductionSettings;
 
    UPROPERTY(EditAnywhere, Category = ReductionSettings)
    TArray<FBoneReference> BonesToRemove;
 
    UPROPERTY(EditAnywhere, Category = ReductionSettings)
    TArray<FBoneReference> BonesToPrioritize;
 
    UPROPERTY(EditAnywhere, Category = ReductionSettings)
    TArray<FSectionReference> SectionsToPrioritize;
 
    UPROPERTY(EditAnywhere, Category = ReductionSettings, meta = (UIMin = "0.0", ClampMin = "0.0"))
    float WeightOfPrioritization = 1.0f;
 
    UPROPERTY(EditAnywhere, Category = ReductionSettings)
    TObjectPtr<UAnimSequence> BakePose;
 
    UPROPERTY(EditAnywhere, Category = ReductionSettings)
    TObjectPtr<UAnimSequence> BakePoseOverride;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(VisibleAnywhere, Category= SkeletalMeshLODInfo, AdvancedDisplay)
    FString SourceImportFilename;
#endif
 
    UPROPERTY(EditAnywhere, Category = SkeletalMeshLODInfo)
    ESkinCacheUsage SkinCacheUsage = ESkinCacheUsage::Auto;
 
    UPROPERTY(EditAnywhere, Category = SkeletalMeshLODInfo, meta = (UIMin = "0.01", ClampMin = "0.01", UIMax = "10000.0", ClampMax = "10000.0"))
    float MorphTargetPositionErrorTolerance = 20.0f;
 
#if WITH_EDITORONLY_DATA
 
    UPROPERTY(VisibleAnywhere, Category = SkeletalMeshLODInfo)
    TMap<FString, FMorphTargetImportedSourceFileInfo> ImportedMorphTargetSourceFilename;
 
#endif //WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, Category = SkeletalMeshLODInfo, AdvancedDisplay, EditFixedSize, Meta=(NoResetToDefault))
    TArray<FSkeletalMeshVertexAttributeInfo> VertexAttributes;  
    
    UPROPERTY()
    uint8 bHasBeenSimplified:1;
 
    UPROPERTY()
    uint8 bHasPerLODVertexColors : 1;
 
    UPROPERTY(EditAnywhere, Category = SkeletalMeshLODInfo)
    uint8 bAllowCPUAccess : 1;
    
    UPROPERTY(EditAnywhere, Category = SkeletalMeshLODInfo, meta=(DisplayName="Force Build Half Edge Buffers", EditCondition=bAllowMeshDeformer))
    uint8 bBuildHalfEdgeBuffers : 1;
 
    UPROPERTY(EditAnywhere, Category = SkeletalMeshLODInfo)
    uint8 bAllowMeshDeformer : 1;
    
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = SkeletalMeshLODInfo, meta=(EditCondition="bAllowCPUAccess"))
    uint8 bSupportUniformlyDistributedSampling : 1;
 
#if WITH_EDITORONLY_DATA
    /*
     * This boolean specify if the LOD was imported with the base mesh or not.
     */
    UPROPERTY()
    uint8 bImportWithBaseMesh:1;
 
    // Protects access to the build guid.
    struct FThreadSafeBuildGUID
    {
    private:
        FGuid   BuildGuid;
        mutable UE::FMutex Mutex;
    public:
        FThreadSafeBuildGUID() = default;
        FThreadSafeBuildGUID(const FGuid& InGuid)
            : BuildGuid(InGuid)
        {
        }
 
        FThreadSafeBuildGUID(const FThreadSafeBuildGUID& Other)
        {
            UE::TUniqueLock OtherLock(Other.Mutex);
            UE::TUniqueLock Lock(Mutex);
            BuildGuid = Other.BuildGuid;
        }
 
        FThreadSafeBuildGUID& operator=(const FThreadSafeBuildGUID& Other)
        {
            if (&Other != this)
            {
                UE::TUniqueLock OtherLock(Other.Mutex);
                UE::TUniqueLock Lock(Mutex);
                BuildGuid = Other.BuildGuid;
            }
            return *this;
        }
 
        bool operator==(const FGuid& Other) const
        {
            UE::TUniqueLock Lock(Mutex);
            return BuildGuid == Other;
        }
 
        bool operator==(const FThreadSafeBuildGUID& Other) const
        {
            if (&Other == this)
            {
                return true;
            }
 
            UE::TUniqueLock OtherLock(Other.Mutex);
            UE::TUniqueLock Lock(Mutex);
            return BuildGuid == Other.BuildGuid;
        }
 
        void operator=(const FGuid& Other)
        {
            UE::TUniqueLock Lock(Mutex);
            BuildGuid = Other;
        }
 
        void Invalidate()
        {
            UE::TUniqueLock Lock(Mutex);
            BuildGuid.Invalidate();
        }
 
        operator FGuid() const
        {
            UE::TUniqueLock Lock(Mutex);
            return BuildGuid;
        }
 
        bool IsValid() const
        {
            UE::TUniqueLock Lock(Mutex);
            return BuildGuid.IsValid();
        }
 
        FString ToString(EGuidFormats Format = EGuidFormats::Digits) const
        {
            UE::TUniqueLock Lock(Mutex);
            FString Out;
            BuildGuid.AppendString(Out, Format);
            return Out;
        }
 
        FThreadSafeBuildGUID(FThreadSafeBuildGUID&&) = delete;
        FThreadSafeBuildGUID& operator=(FThreadSafeBuildGUID&&) = delete;
    };
 
    //Temporary build GUID data
    //We use this GUID to store the LOD Key so we can know if the LOD needs to be rebuilt
    //This GUID is set when we Cache the render data (build function)
    FThreadSafeBuildGUID BuildGUID;
 
    ENGINE_API FGuid ComputeDeriveDataCacheKey(const FSkeletalMeshLODGroupSettings* SkeletalMeshLODGroupSettings);
#endif
 
    FSkeletalMeshLODInfo()
        : bHasBeenSimplified(false)
        , bHasPerLODVertexColors(false)
        , bAllowCPUAccess(false)
        , bBuildHalfEdgeBuffers(false)
        , bAllowMeshDeformer(true)
        , bSupportUniformlyDistributedSampling(false)
#if WITH_EDITORONLY_DATA
        , bImportWithBaseMesh(false)
#endif
    {
    }
 
};
 
//~ Begin Material Interface for USkeletalMesh
USTRUCT(BlueprintType)
struct FSkeletalMaterial
{
    GENERATED_USTRUCT_BODY()
 
    FSkeletalMaterial()
        : MaterialInterface(nullptr)
        , MaterialSlotName(NAME_None)
#if WITH_EDITORONLY_DATA
        , bEnableShadowCasting_DEPRECATED(true)
        , bRecomputeTangent_DEPRECATED(false)
        , ImportedMaterialSlotName(NAME_None)
#endif
        , OverlayMaterialInterface(nullptr)
    {
 
    }
 
    FSkeletalMaterial(
        UMaterialInterface* InMaterialInterface,
        FName InMaterialSlotName,
        FName InImportedMaterialSlotName = NAME_None,
        UMaterialInterface* InOverlayMaterialInterface = nullptr)
        : MaterialInterface( InMaterialInterface )
        , MaterialSlotName(InMaterialSlotName)
    #if WITH_EDITORONLY_DATA
        , bEnableShadowCasting_DEPRECATED(true)
        , bRecomputeTangent_DEPRECATED(false)
        , ImportedMaterialSlotName(InImportedMaterialSlotName)
    #endif
        , OverlayMaterialInterface(InOverlayMaterialInterface)
    {
 
    }
 
    FSkeletalMaterial( UMaterialInterface* InMaterialInterface
                        , bool bInEnableShadowCasting = true
                        , bool bInRecomputeTangent = false
                        , FName InMaterialSlotName = NAME_None
                        , FName InImportedMaterialSlotName = NAME_None
                        , UMaterialInterface* InOverlayMaterialInterface = nullptr)
        : MaterialInterface( InMaterialInterface )
        , MaterialSlotName(InMaterialSlotName)
    #if WITH_EDITORONLY_DATA
        , bEnableShadowCasting_DEPRECATED(bInEnableShadowCasting)
        , bRecomputeTangent_DEPRECATED(bInRecomputeTangent)
        , ImportedMaterialSlotName(InImportedMaterialSlotName)
    #endif
        , OverlayMaterialInterface(InOverlayMaterialInterface)
    {
 
    }
 
    friend FArchive& operator<<( FArchive& Ar, FSkeletalMaterial& Elem );
#if WITH_EDITORONLY_DATA
    static void DeclareCustomVersions(FArchive& Ar);
#endif
 
    ENGINE_API friend bool operator==( const FSkeletalMaterial& LHS, const FSkeletalMaterial& RHS );
    ENGINE_API friend bool operator==( const FSkeletalMaterial& LHS, const UMaterialInterface& RHS );
    ENGINE_API friend bool operator==( const UMaterialInterface& LHS, const FSkeletalMaterial& RHS );
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SkeletalMesh)
    TObjectPtr<UMaterialInterface>  MaterialInterface;
    
    /*This name should be use by the gameplay to avoid error if the skeletal mesh Materials array topology change*/
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = SkeletalMesh)
    FName                       MaterialSlotName;
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    bool                        bEnableShadowCasting_DEPRECATED;
    UPROPERTY()
    bool                        bRecomputeTangent_DEPRECATED;
    /*This name should be use when we re-import a skeletal mesh so we can order the Materials array like it should be*/
    UPROPERTY(VisibleAnywhere, Category = SkeletalMesh)
    FName                       ImportedMaterialSlotName;
#endif
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = SkeletalMesh)
    FMeshUVChannelInfo          UVChannelData;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=SkeletalMesh)
    TObjectPtr<UMaterialInterface>  OverlayMaterialInterface;
};