SkinnedAsset.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "Engine/StreamableRenderAsset.h"
#include "Interfaces/Interface_AsyncCompilation.h"
#include "ReferenceSkeleton.h"
#include "UObject/PerPlatformProperties.h"
#include "SkinnedAsset.generated.h"
 
struct FSkeletalMaterial;
struct FSkeletalMeshLODInfo;
class FSkinnedAssetBuildContext;
class FSkinnedAssetPostLoadContext;
class FSkinnedAsyncTaskContext;
class FVertexFactoryType;
class ITargetPlatform;
class UMeshDeformer;
class UMeshDeformerCollection;
class UMorphTarget;
class UPhysicsAsset;
class USkeleton;
struct FPSOPrecacheVertexFactoryDataPerMaterialIndex;
struct FSkinnedAssetAsyncBuildTask;
enum class ESkeletalMeshVertexFlags : uint8;
typedef TArray<FPSOPrecacheVertexFactoryDataPerMaterialIndex, TInlineAllocator<4> > FPSOPrecacheVertexFactoryDataPerMaterialIndexList;
 
DECLARE_LOG_CATEGORY_EXTERN(LogSkinnedAsset, Log, All)
 
enum class ESkinnedAssetAsyncPropertyLockType
{
    None = 0,
    ReadOnly = 1,
    WriteOnly = 2,
    ReadWrite = 3
};
ENUM_CLASS_FLAGS(ESkinnedAssetAsyncPropertyLockType);
 
UCLASS(hidecategories = Object, config = Engine, editinlinenew, abstract, MinimalAPI)
class USkinnedAsset : public UStreamableRenderAsset, public IInterface_AsyncCompilation
{
    GENERATED_BODY()
 
public:
    ENGINE_API USkinnedAsset(const FObjectInitializer& ObjectInitializer);
    ENGINE_API virtual ~USkinnedAsset();
 
    virtual struct FReferenceSkeleton& GetRefSkeleton()
    PURE_VIRTUAL(USkinnedAsset::GetRefSkeleton, static FReferenceSkeleton Dummy; return Dummy;);
    virtual const struct FReferenceSkeleton& GetRefSkeleton() const
    PURE_VIRTUAL(USkinnedAsset::GetRefSkeleton, static const FReferenceSkeleton Dummy; return Dummy;);
 
    virtual FSkeletalMeshLODInfo* GetLODInfo(int32 Index)
    PURE_VIRTUAL(USkinnedAsset::GetLODInfo, return nullptr;);
    virtual const FSkeletalMeshLODInfo* GetLODInfo(int32 Index) const
    PURE_VIRTUAL(USkinnedAsset::GetLODInfo, return nullptr;);
 
    ENGINE_API virtual bool IsValidMaterialIndex(int32 Index) const;
 
    ENGINE_API virtual int32 GetNumMaterials() const;
 
    virtual UPhysicsAsset* GetShadowPhysicsAsset() const
    PURE_VIRTUAL(USkinnedAsset::GetShadowPhysicsAsset, return nullptr;);
 
    virtual FMatrix GetComposedRefPoseMatrix(FName InBoneName) const
    PURE_VIRTUAL(USkinnedAsset::GetComposedRefPoseMatrix, return FMatrix::Identity;);
 
    virtual FMatrix GetComposedRefPoseMatrix(int32 InBoneIndex) const
    PURE_VIRTUAL(USkinnedAsset::GetComposedRefPoseMatrix, return FMatrix::Identity;);
 
    virtual const FMeshUVChannelInfo* GetUVChannelData(int32 MaterialIndex) const
    PURE_VIRTUAL(USkinnedAsset::GetUVChannelData, return nullptr;);
 
    virtual bool GetSupportRayTracing() const
    PURE_VIRTUAL(USkinnedAsset::GetSupportRayTracing, return false;);
 
    virtual int32 GetRayTracingMinLOD() const
    PURE_VIRTUAL(USkinnedAsset::GetRayTracingMinLOD, return 0;);
 
    virtual TArray<FMatrix44f>& GetRefBasesInvMatrix()
    PURE_VIRTUAL(USkinnedAsset::GetRefBasesInvMatrix, static TArray<FMatrix44f> Dummy; return Dummy;);
    virtual const TArray<FMatrix44f>& GetRefBasesInvMatrix() const
    PURE_VIRTUAL(USkinnedAsset::GetRefBasesInvMatrix, static const TArray<FMatrix44f> Dummy; return Dummy;);
 
    UE_DEPRECATED(5.5, "Use GetLODInfo and GetLODNum instead.")
    virtual TArray<FSkeletalMeshLODInfo>& GetLODInfoArray()
    PURE_VIRTUAL(USkinnedAsset::GetLODInfoArray, return GetMeshLodInfoDummyArray(););
    UE_DEPRECATED(5.5, "Use GetLODInfo and GetLODNum instead.")
    virtual const TArray<FSkeletalMeshLODInfo>& GetLODInfoArray() const
    PURE_VIRTUAL(USkinnedAsset::GetLODInfoArray, return GetMeshLodInfoDummyArray(););
 
    virtual class FSkeletalMeshRenderData* GetResourceForRendering() const
    PURE_VIRTUAL(USkinnedAsset::GetResourceForRendering, return nullptr;);
 
    virtual int32 GetDefaultMinLod() const
    PURE_VIRTUAL(USkinnedAsset::GetDefaultMinLod, return 0;);
 
    virtual const FPerPlatformInt& GetMinLod() const
    PURE_VIRTUAL(USkinnedAsset::GetMinLod, static const FPerPlatformInt Dummy;  return Dummy;);
 
    virtual bool IsMinLodQualityLevelEnable() const { return false; }
 
    virtual UPhysicsAsset* GetPhysicsAsset() const
    PURE_VIRTUAL(USkinnedAsset::GetPhysicsAsset, return nullptr;);
 
    virtual TArray<FSkeletalMaterial>& GetMaterials()
    PURE_VIRTUAL(USkinnedAsset::GetMaterials, return GetSkeletalMaterialDummyArray(););
    virtual const TArray<FSkeletalMaterial>& GetMaterials() const
    PURE_VIRTUAL(USkinnedAsset::GetMaterials, return GetSkeletalMaterialDummyArray(););
 
    virtual int32 GetLODNum() const
    PURE_VIRTUAL(USkinnedAsset::GetLODNum, return 0;);
 
    virtual bool IsMaterialUsed(int32 MaterialIndex) const
    PURE_VIRTUAL(USkinnedAsset::IsMaterialUsed, return false;);
 
    virtual FBoxSphereBounds GetBounds() const
    PURE_VIRTUAL(USkinnedAsset::GetBounds, return FBoxSphereBounds(););
 
    virtual TArray<class USkeletalMeshSocket*> GetActiveSocketList() const
    PURE_VIRTUAL(USkinnedAsset::GetActiveSocketList, static TArray<class USkeletalMeshSocket*> Dummy; return Dummy;);
 
    UFUNCTION(BlueprintCallable, Category = "Animation")
    virtual USkeletalMeshSocket* FindSocket(FName InSocketName) const
    PURE_VIRTUAL(USkinnedAsset::FindSocket, return nullptr;);
 
    UFUNCTION(BlueprintCallable, Category = "Animation")
    virtual USkeletalMeshSocket* FindSocketInfo(FName InSocketName, FTransform& OutTransform, int32& OutBoneIndex, int32& OutIndex) const
    PURE_VIRTUAL(USkinnedAsset::FindSocketInfo, return nullptr;);
 
    virtual USkeleton* GetSkeleton()
    PURE_VIRTUAL(USkinnedAsset::GetSkeleton, return nullptr;);
    virtual const USkeleton* GetSkeleton() const
    PURE_VIRTUAL(USkinnedAsset::GetSkeleton, return nullptr;);
    virtual void SetSkeleton(USkeleton* InSkeleton)
    PURE_VIRTUAL(USkinnedAsset::SetSkeleton,);
 
    virtual UMeshDeformer* GetDefaultMeshDeformer() const
    PURE_VIRTUAL(USkinnedAsset::GetDefaultMeshDeformer, return nullptr;);
    
    virtual UMeshDeformerCollection* GetTargetMeshDeformers() const
    PURE_VIRTUAL(USkinnedAsset::GetTargetMeshDeformers, return nullptr;);
    
    virtual bool HasHalfEdgeBuffer(int32 LODIndex) const
    PURE_VIRTUAL(USkinnedAsset::HasHalfEdgeBuffer, return false;);
    
    virtual class UMaterialInterface* GetOverlayMaterial() const
    PURE_VIRTUAL(USkinnedAsset::GetOverlayMaterial, return nullptr;);
    virtual float GetOverlayMaterialMaxDrawDistance() const
    PURE_VIRTUAL(USkinnedAsset::GetOverlayMaterialMaxDrawDistance, return 0.f;);
    
    virtual bool IsValidLODIndex(int32 Index) const
    PURE_VIRTUAL(USkinnedAsset::IsValidLODIndex, return false;);
 
    virtual int32 GetMinLodIdx(bool bForceLowestLODIdx = false) const
    PURE_VIRTUAL(USkinnedAsset::GetMinLodIdx, return 0;);
 
    virtual TArray<TObjectPtr<UMorphTarget>>& GetMorphTargets()
    { static TArray<TObjectPtr<UMorphTarget>> Dummy; return Dummy; }
    virtual const TArray<TObjectPtr<UMorphTarget>>& GetMorphTargets() const
    { static const TArray<TObjectPtr<UMorphTarget>> Dummy; return Dummy; }
 
    virtual UMorphTarget* FindMorphTarget(FName MorphTargetName) const
    { return nullptr; }
 
    virtual bool NeedCPUData(int32 LODIndex) const
    PURE_VIRTUAL(USkinnedAsset::NeedCPUData, return false;);
 
    virtual bool GetHasVertexColors() const
    PURE_VIRTUAL(USkinnedAsset::GetHasVertexColors, return false;);
 
    virtual int32 GetPlatformMinLODIdx(const ITargetPlatform* TargetPlatform) const
    PURE_VIRTUAL(USkinnedAsset::GetPlatformMinLODIdx, return 0;);
 
    virtual const FPerPlatformBool& GetDisableBelowMinLodStripping() const
    PURE_VIRTUAL(USkinnedAsset::GetDisableBelowMinLodStripping, static const FPerPlatformBool Dummy; return Dummy;);
 
    virtual void SetSkinWeightProfilesData(int32 LODIndex, struct FSkinWeightProfilesData& SkinWeightProfilesData) {}
    virtual FSkinWeightProfilesData* GetSkinWeightProfilesData(int32 LODIndex) { return nullptr; }
 
    ENGINE_API virtual ESkeletalMeshVertexFlags GetVertexBufferFlags() const;
 
    ENGINE_API void FillComponentSpaceTransforms(const TArray<FTransform>& InBoneSpaceTransforms, const TArray<FBoneIndexType>& InFillComponentSpaceTransformsRequiredBones, TArray<FTransform>& OutComponentSpaceTransforms) const;
 
    //~ Begin UObject Interface
    virtual FString GetDetailedInfoInternal() const override
    { return GetPathName(nullptr); }
 
    ENGINE_API virtual void PostLoad() override;
    //~ End UObject Interface
        
    ENGINE_API void GetVertexFactoryTypesPerMaterialIndex(FPSOPrecacheVertexFactoryDataPerMaterialIndexList& OutList, USkinnedMeshComponent* SkinnedMeshComponent, int32 MinLODIndex, bool bCPUSkin, ERHIFeatureLevel::Type FeatureLevel);
 
    static ENGINE_API FString GetLODPathName(const USkinnedAsset* Mesh, int32 LODIndex);
 
#if WITH_EDITOR
    ENGINE_API virtual bool IsCompiling() const override;
#else
    inline bool IsCompiling() const { return false; }
#endif
#if WITH_EDITOR
    virtual FString BuildDerivedDataKey(const ITargetPlatform* TargetPlatform)
    PURE_VIRTUAL(USkinnedAsset::BuildDerivedDataKey, return TEXT(""););
 
    /* Return true if this asset was never build since its creation. */
    virtual bool IsInitialBuildDone() const
    PURE_VIRTUAL(USkinnedAsset::IsInitialBuildDone, return false;);
 
    /* Build a LOD model before creating its render data. */
    UE_DEPRECATED(5.6, "Use or override the overload that takes FSkeletalMeshRenderData instead")
    virtual void BuildLODModel(const ITargetPlatform* TargetPlatform, int32 LODIndex) final {}
    
    /* Build a LOD model for the given render data. */
    virtual void BuildLODModel(FSkeletalMeshRenderData& RenderData, const ITargetPlatform* TargetPlatform, int32 LODIndex) {}
 
    virtual bool GetEnableLODStreaming(const ITargetPlatform* TargetPlatform) const
    PURE_VIRTUAL(USkinnedAsset::GetEnableLODStreaming, return false;);
 
    virtual int32 GetMaxNumStreamedLODs(const ITargetPlatform* TargetPlatform) const
    PURE_VIRTUAL(USkinnedAsset::GetMaxNumStreamedLODs, return 0;);
 
    virtual int32 GetMaxNumOptionalLODs(const ITargetPlatform* TargetPlatform) const
    PURE_VIRTUAL(USkinnedAsset::GetMaxNumOptionalLODs, return 0;);
 
    virtual bool HasCompileDependencies() const { return false; }
    virtual bool HasAnyDependenciesCompiling() const { return false; }
    virtual TArray<USkinnedAsset*> GetSkinnedAssetDependencies() const { return {}; }
#endif // WITH_EDITOR
 
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.4, "This function and associated functionality is no longer supported.")
    static bool GetUseLegacyMeshDerivedDataKey()    { return false; }
 
    virtual class FSkeletalMeshModel* GetImportedModel() const
    PURE_VIRTUAL(USkinnedAsset::GetImportedModel, return nullptr;);
#endif // WITH_EDITORONLY_DATA
 
    ENGINE_API void UpdateUVChannelData(bool bResetOverrides);
 
protected:
#if WITH_EDITORONLY_DATA
    ENGINE_API virtual void UpdateMaterialUVChannelData(FMeshUVChannelInfo& UVChannelData, int32 MaterialIndex);
#endif
 
    ENGINE_API void AcquireAsyncProperty(uint64 AsyncProperties = MAX_uint64, ESkinnedAssetAsyncPropertyLockType LockType = ESkinnedAssetAsyncPropertyLockType::ReadWrite);
    ENGINE_API void ReleaseAsyncProperty(uint64 AsyncProperties = MAX_uint64, ESkinnedAssetAsyncPropertyLockType LockType = ESkinnedAssetAsyncPropertyLockType::ReadWrite);
 
    ENGINE_API void WaitUntilAsyncPropertyReleasedInternal(uint64 AsyncProperties, ESkinnedAssetAsyncPropertyLockType LockType = ESkinnedAssetAsyncPropertyLockType::ReadWrite) const;
 
#if WITH_EDITOR
    virtual void BeginBuildInternal(FSkinnedAssetBuildContext& Context) {}
    virtual void ExecuteBuildInternal(FSkinnedAssetBuildContext& Context) {}
    virtual void FinishBuildInternal(FSkinnedAssetBuildContext& Context) {}
 
    virtual void BeginAsyncTaskInternal(FSkinnedAsyncTaskContext& Context) {}
    virtual void ExecuteAsyncTaskInternal(FSkinnedAsyncTaskContext& Context) {}
    virtual void FinishAsyncTaskInternal(FSkinnedAsyncTaskContext& Context) {}
 
    ENGINE_API virtual bool TryCancelAsyncTasks();
 
    TUniquePtr<FSkinnedAssetAsyncBuildTask> AsyncTask;
#endif // WITH_EDITOR
 
private:
    virtual void BeginPostLoadInternal(FSkinnedAssetPostLoadContext& Context) {}
    virtual void ExecutePostLoadInternal(FSkinnedAssetPostLoadContext& Context) {}
    virtual void FinishPostLoadInternal(FSkinnedAssetPostLoadContext& Context) {}
 
    virtual FString GetAsyncPropertyName(uint64 Property) const { return TEXT(""); }
 
#if WITH_EDITOR
    virtual void PrepareForAsyncCompilation() {}
    virtual bool IsAsyncTaskComplete() const { return true; }
 
    std::atomic<uint64> AccessedProperties;
    std::atomic<uint64> ModifiedProperties;
#endif // WITH_EDITOR
 
    friend class FSkinnedAssetCompilingManager;
    friend class FSkinnedAssetAsyncBuildWorker;
 
    static ENGINE_API TArray<FSkeletalMeshLODInfo>& GetMeshLodInfoDummyArray();
    static ENGINE_API TArray<FSkeletalMaterial>& GetSkeletalMaterialDummyArray();
};
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "PSOPrecache.h"
#endif