Skeleton.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 "UObject/Object.h"
#include "HAL/CriticalSection.h"
#include "Misc/Guid.h"
#include "Misc/TransactionallySafeRWLock.h"
#include "ReferenceSkeleton.h"
#include "Animation/PreviewAssetAttachComponent.h"
#include "Animation/SmartName.h"
#include "Engine/AssetUserData.h"
#include "HAL/CriticalSection.h"  // jira SOL-6812: Remove this (duplicate include).
#include "Interfaces/Interface_AssetUserData.h"
#include "Interfaces/Interface_PreviewMeshProvider.h"
#include "Delegates/DelegateCombinations.h"
#include "UObject/ObjectKey.h"
#include "Skeleton.generated.h"
 
class UAnimCurveMetaData;
class UAnimSequence;
class UBlendProfile;
class URig;
class USkeletalMeshSocket;
class USkinnedAsset;
class FPackageReloadedEvent;
struct FAssetData;
enum class EPackageReloadPhase : uint8;
class USkeleton;
typedef SmartName::UID_Type SkeletonAnimCurveUID;
class USkeleton;
struct FSkeletonRemapping;
class FEditableSkeleton;
 
// Delegate used to control global skeleton compatibility
DECLARE_DELEGATE_RetVal(bool, FAreAllSkeletonsCompatible);
 
USTRUCT()
struct FSkeletonToMeshLinkup
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TArray<int32> SkeletonToMeshTable;
 
    UPROPERTY()
    TArray<int32> MeshToSkeletonTable;
 
};
 
UENUM()
namespace EBoneTranslationRetargetingMode
{
    enum Type : int
    {
        Animation,
        Skeleton,
        AnimationScaled,
        AnimationRelative,
        OrientAndScale,
    };
}
 
#define BONE_TRANS_RT_ORIENT_AND_SCALE_PRECISION (0.001f) 
 
USTRUCT()
struct FBoneNode
{
    GENERATED_USTRUCT_BODY()
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FName Name_DEPRECATED;
 
    UPROPERTY()
    int32 ParentIndex_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, Category=BoneNode)
    TEnumAsByte<EBoneTranslationRetargetingMode::Type> TranslationRetargetingMode;
 
    FBoneNode()
        :
#if WITH_EDITORONLY_DATA
        ParentIndex_DEPRECATED(INDEX_NONE),
#endif
        TranslationRetargetingMode(EBoneTranslationRetargetingMode::Animation)
    {
    }
 
    FBoneNode(FName InBoneName, int32 InParentIndex)
        :
#if WITH_EDITORONLY_DATA
        Name_DEPRECATED(InBoneName),
        ParentIndex_DEPRECATED(InParentIndex),
#endif
        TranslationRetargetingMode(EBoneTranslationRetargetingMode::Animation)
    {
    }
};
 
USTRUCT()
struct FReferencePose
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FName   PoseName;
 
    UPROPERTY()
    TArray<FTransform>  ReferencePose;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TSoftObjectPtr<USkeletalMesh> SourceReferenceMesh;
#endif
 
    friend void SerializeReferencePose(FArchive& Ar, FReferencePose& P, UObject* Outer);
};
 
USTRUCT()
struct FBoneReductionSetting
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    TArray<FName> BonesToRemove;
 
    bool Add(FName BoneName)
    {
        if ( BoneName!=NAME_None && !BonesToRemove.Contains(BoneName) )
        {
            BonesToRemove.Add(BoneName);
            return true;
        }
 
        return false;
    }
 
    void Remove(FName BoneName)
    {
        BonesToRemove.Remove(BoneName);
    }
 
    bool Contains(FName BoneName)
    {
        return (BonesToRemove.Contains(BoneName));
    }
};
 
USTRUCT()
struct FNameMapping
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FName NodeName;
 
    UPROPERTY()
    FName BoneName;
 
    FNameMapping()
        : NodeName(NAME_None)
        , BoneName(NAME_None)
    {
    }
 
    FNameMapping(FName InNodeName)
        : NodeName(InNodeName)
        , BoneName(NAME_None)
    {
    }
 
    FNameMapping(FName InNodeName, FName InBoneName)
        : NodeName(InNodeName)
        , BoneName(InBoneName)
    {
    }
};
 
USTRUCT()
struct FAnimSlotGroup
{
    GENERATED_USTRUCT_BODY()
 
public:
    static ENGINE_API const FName DefaultGroupName;
    static ENGINE_API const FName DefaultSlotName;
 
    UPROPERTY()
    FName GroupName;
 
    UPROPERTY()
    TArray<FName> SlotNames;
 
    FAnimSlotGroup()
        : GroupName(DefaultGroupName)
    {
    }
 
    FAnimSlotGroup(FName InGroupName)
        : GroupName(InGroupName)
    {
    }
};
 
namespace VirtualBoneNameHelpers
{
    extern ENGINE_API const FString VirtualBonePrefix;
 
    ENGINE_API FString AddVirtualBonePrefix(const FString& InName);
    ENGINE_API FName RemoveVirtualBonePrefix(const FString& InName);
    ENGINE_API bool CheckVirtualBonePrefix(const FString& InName);
}
 
USTRUCT()
struct FVirtualBone
{
    GENERATED_USTRUCT_BODY()
 
public:
    UPROPERTY()
    FName SourceBoneName;
 
    UPROPERTY()
    FName TargetBoneName;
 
    UPROPERTY()
    FName VirtualBoneName;
 
    FVirtualBone() {}
 
    FVirtualBone(FName InSource, FName InTarget, FName InVirtual)
        : SourceBoneName(InSource)
        , TargetBoneName(InTarget)
        , VirtualBoneName(InVirtual)
    {
    }
 
    FVirtualBone(FName InSource, FName InTarget)
        : SourceBoneName(InSource)
        , TargetBoneName(InTarget)
    {
        FString VBNameString = VirtualBoneNameHelpers::AddVirtualBonePrefix(SourceBoneName.ToString() + TEXT("_") + TargetBoneName.ToString());
        VirtualBoneName = FName(*VBNameString);
    }
};
 
 
UCLASS(hidecategories=Object, MinimalAPI, BlueprintType)
class USkeleton : public UObject, public IInterface_AssetUserData, public IInterface_PreviewMeshProvider
{
    friend class UAnimationBlueprintLibrary;
    friend class FSkeletonDetails;
 
    GENERATED_UCLASS_BODY()
 
protected:
    UPROPERTY(VisibleAnywhere, Category=Skeleton)
    TArray<struct FBoneNode> BoneTree;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TArray<FTransform> RefLocalPoses_DEPRECATED;
 
    // Preview axis to consider as "forward" for the skeleton. Only used for preview purposes.
    UPROPERTY(EditAnywhere, Category = Preview)
    TEnumAsByte<EAxis::Type> PreviewForwardAxis;
#endif
 
    FReferenceSkeleton ReferenceSkeleton;
 
    FGuid Guid;
 
    UPROPERTY()
    FGuid VirtualBoneGuid;
 
    void ConvertToFReferenceSkeleton();
 
    UPROPERTY()
    TArray<FVirtualBone> VirtualBones;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = CompatibleSkeletons)
    TArray<TSoftObjectPtr<USkeleton>> CompatibleSkeletons;
 
    UPROPERTY(EditAnywhere, Category = CompatibleSkeletons)
    bool bUseRetargetModesFromCompatibleSkeleton = false;
 
public:
    //~ Begin UObject Interface.
#if WITH_EDITOR
    ENGINE_API virtual void PreEditUndo() override;
    ENGINE_API virtual void PostEditUndo() override;
    EAxis::Type GetPreviewForwardAxis() const { return PreviewForwardAxis; }
#endif
    ENGINE_API virtual void BeginDestroy() override;
 
    const FReferenceSkeleton& GetReferenceSkeleton() const
    {
        return ReferenceSkeleton;
    }
 
    const TArray<FVirtualBone>& GetVirtualBones() const { return VirtualBones; }
 
    UPROPERTY()
    TArray<TObjectPtr<class USkeletalMeshSocket>> Sockets;
 
    TMap< FName, FReferencePose > AnimRetargetSources;
 
    UE_DEPRECATED(5.7, "AnimCurveUID is deprecated and no longer used.")
    typedef SmartName::UID_Type AnimCurveUID;
 
    ENGINE_API FCurveMetaData* GetCurveMetaData(FName CurveName);
    ENGINE_API const FCurveMetaData* GetCurveMetaData(FName CurveName) const;
 
    ENGINE_API void ForEachCurveMetaData(TFunctionRef<void(FName, const FCurveMetaData&)> InFunction) const;
    
    ENGINE_API int32 GetNumCurveMetaData() const;
 
    ENGINE_API bool AddCurveMetaData(FName CurveName, bool bTransact = true);
 
    ENGINE_API void GetCurveMetaDataNames(TArray<FName>& OutNames) const;
 
#if WITH_EDITOR
    ENGINE_API bool RenameCurveMetaData(FName OldName, FName NewName);
 
    ENGINE_API bool RemoveCurveMetaData(FName CurveName);
 
    ENGINE_API bool RemoveCurveMetaData(TArrayView<FName> CurveNames);
 
    ENGINE_API bool GetCurveMetaDataMaterial(FName CurveName) const;
 
    ENGINE_API bool GetCurveMetaDataMorphTarget(FName CurveName) const;
 
    ENGINE_API void SetCurveMetaDataMaterial(FName CurveName, bool bOverrideMaterial);
 
    ENGINE_API void SetCurveMetaDataMorphTarget(FName CurveName, bool bOverrideMorphTarget);
#endif
 
    // this is called when you know both flags - called by post serialize and import
    ENGINE_API void AccumulateCurveMetaData(FName CurveName, bool bMaterialSet, bool bMorphtargetSet);
 
    ENGINE_API bool AddNewVirtualBone(const FName SourceBoneName, const FName TargetBoneName);
 
    ENGINE_API bool AddNewVirtualBone(const FName SourceBoneName, const FName TargetBoneName, FName& NewVirtualBoneName);
 
    ENGINE_API bool AddNewNamedVirtualBone(const FName SourceBoneName, const FName TargetBoneName, const FName NewVirtualBoneName);
    
    ENGINE_API void RemoveVirtualBones(const TArray<FName>& BonesToRemove);
 
    ENGINE_API void RenameVirtualBone(const FName OriginalBoneName, const FName NewBoneName);
    
    void HandleVirtualBoneChanges();
 
    // return version of AnimCurveUidVersion
    uint16 GetAnimCurveUidVersion() const;
 
    const TArray<TSoftObjectPtr<USkeleton>>& GetCompatibleSkeletons() const { return CompatibleSkeletons; }
 
    UE_DEPRECATED(5.2, "Please use UE::Anim::FSkeletonRemappingRegistry::GetRemapping.")
    ENGINE_API const FSkeletonRemapping* GetSkeletonRemapping(const USkeleton* SourceSkeleton) const;
 
    ENGINE_API bool GetUseRetargetModesFromCompatibleSkeleton() const;
    ENGINE_API void SetUseRetargetModesFromCompatibleSkeleton(bool bUse);
 
#if WITH_EDITOR
    // Get existing (seen) sync marker names for this Skeleton
    const TArray<FName>& GetExistingMarkerNames() const { return ExistingMarkerNames; }
 
    // Register a new sync marker name
    void RegisterMarkerName(FName MarkerName) { ExistingMarkerNames.AddUnique(MarkerName); ExistingMarkerNames.Sort(FNameLexicalLess()); }
 
    // Remove a sync marker name
    ENGINE_API bool RemoveMarkerName(FName MarkerName);
 
    // Rename a sync marker name
    ENGINE_API bool RenameMarkerName(FName InOldName, FName InNewName);
#endif
 
protected:
    UE_DEPRECATED(5.7, "SmartNames in Skeleton have been deprecated, use CurveMetaData instead.")
    UPROPERTY()
    FSmartNameContainer SmartNames_DEPRECATED;
 
    //Cached marker sync marker names (stripped for non editor)
    TArray<FName> ExistingMarkerNames;
 
private:
    // Refresh skeleton metadata (updates bone indices for linked bone references)
    void RefreshSkeletonMetaData();
 
    // Returns the UAnimCurveMetaData from this skeleton's AssetUserData, creating one if it doesn't exist
    UAnimCurveMetaData* GetOrCreateCurveMetaDataObject();
 
public:
    // Blend Profiles
 
    UPROPERTY(Instanced)
    TArray<TObjectPtr<UBlendProfile>> BlendProfiles;
 
    UFUNCTION(BlueprintPure, Category = Skeleton, meta = (BlueprintThreadSafe))
    ENGINE_API UBlendProfile* GetBlendProfile(const FName& InProfileName);
 
    ENGINE_API UBlendProfile* CreateNewBlendProfile(const FName& InProfileName);
 
    ENGINE_API UBlendProfile* RenameBlendProfile(const FName& InProfileName, const FName& InNewProfileName);
 
 
    /************************************************************************/
    /* Slot Groups */
    /************************************************************************/
private:
    // serialized slot groups and slot names.
    UPROPERTY()
    TArray<FAnimSlotGroup> SlotGroups;
 
    TMap<FName, FName> SlotToGroupNameMap;
 
    void BuildSlotToGroupMap(bool bInRemoveDuplicates = false);
 
public:
    ENGINE_API FAnimSlotGroup* FindAnimSlotGroup(const FName& InGroupName);
    ENGINE_API const FAnimSlotGroup* FindAnimSlotGroup(const FName& InGroupName) const;
    ENGINE_API const TArray<FAnimSlotGroup>& GetSlotGroups() const;
    ENGINE_API bool ContainsSlotName(const FName& InSlotName) const;
 
    ENGINE_API bool RegisterSlotNode(const FName& InSlotName);
 
    ENGINE_API void SetSlotGroupName(const FName& InSlotName, const FName& InGroupName);
    ENGINE_API bool AddSlotGroupName(const FName& InNewGroupName);
    ENGINE_API FName GetSlotGroupName(const FName& InSlotName) const;
 
    // Edits/removes slot group data
    // WARNING: Does not verify that the names aren't used anywhere - if it isn't checked
    // by the caller the names will be recreated when referencing assets load again.
    ENGINE_API void RemoveSlotName(const FName& InSlotName);
    ENGINE_API void RemoveSlotGroup(const FName& InSlotName);
    ENGINE_API void RenameSlotName(const FName& OldName, const FName& NewName);
 
#if WITH_EDITORONLY_DATA
private:
    UPROPERTY(duplicatetransient, AssetRegistrySearchable)
    TSoftObjectPtr<class USkeletalMesh> PreviewSkeletalMesh;
 
    UPROPERTY(duplicatetransient, AssetRegistrySearchable)
    TSoftObjectPtr<class UDataAsset> AdditionalPreviewSkeletalMeshes;
 
    ENGINE_API virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    ENGINE_API virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
 
public:
 
    UPROPERTY()
    TArray<FName> AnimationNotifies;
 
    /* Attached assets component for this skeleton */
    UPROPERTY()
    FPreviewAssetAttachContainer PreviewAttachedAssetContainer;
#endif // WITH_EDITORONLY_DATA
 
private:
    DECLARE_MULTICAST_DELEGATE( FOnRetargetSourceChangedMulticaster )
    FOnRetargetSourceChangedMulticaster OnRetargetSourceChanged;
 
public:
    typedef FOnRetargetSourceChangedMulticaster::FDelegate FOnRetargetSourceChanged;
 
    FDelegateHandle RegisterOnRetargetSourceChanged(const FOnRetargetSourceChanged& Delegate)
    {
        return OnRetargetSourceChanged.Add(Delegate);
    }
 
    const FGuid GetGuid() const
    {
        return Guid;
    }
 
    FGuid GetVirtualBoneGuid() const
    {
        return VirtualBoneGuid;
    }
 
    void UnregisterOnRetargetSourceChanged(FDelegateHandle Handle)
    {
        OnRetargetSourceChanged.Remove(Handle);
    }
 
    void CallbackRetargetSourceChanged()
    {
        OnRetargetSourceChanged.Broadcast();
    }
 
    typedef TArray<FBoneNode> FBoneTreeType;
 
private:
    //Use this Lock everytime you change or access SkinnedAssetLinkupCache member.
    FTransactionallySafeRWLock SkinnedAssetLinkupCacheLock;
 
    TMap<TObjectKey<USkinnedAsset>, TUniquePtr<FSkeletonToMeshLinkup>> SkinnedAssetLinkupCache;
 
public:
    TSoftObjectPtr<USkeleton> CachedSoftObjectPtr;
 
    virtual USkeletalMesh* GetPreviewMesh(bool bFindIfNotSet = false) override;
    virtual USkeletalMesh* GetPreviewMesh() const override;
    virtual void SetPreviewMesh(USkeletalMesh* PreviewMesh, bool bMarkAsDirty=true);
 
#if WITH_EDITORONLY_DATA
 
    UE_DEPRECATED(5.4, "Please do not use this function - notifies are stored collectively in the asset registry now rather than centrally on the skeleton")
    ENGINE_API void CollectAnimationNotifies();
 
    /*
     * Collect animation notifies that are referenced in all animations that use this skeleton (uses the asset registry).
     * @param   OutNotifies     All the notifies that were found
     */
    ENGINE_API void CollectAnimationNotifies(TArray<FName>& OutNotifies) const;
 
    // Adds a new anim notify to the cached AnimationNotifies array.
    ENGINE_API void AddNewAnimationNotify(FName NewAnimNotifyName);
 
    // Removes an anim notify from the cached AnimationNotifies array.
    ENGINE_API void RemoveAnimationNotify(FName AnimNotifyName);
 
    // Renames an anim notify
    ENGINE_API void RenameAnimationNotify(FName OldAnimNotifyName, FName NewAnimNotifyName);
 
    ENGINE_API USkeletalMesh* GetAssetPreviewMesh(UObject* InAsset);
 
    ENGINE_API USkeletalMesh* FindCompatibleMesh() const;
 
    ENGINE_API void LoadAdditionalPreviewSkeletalMeshes();
 
    ENGINE_API UDataAsset* GetAdditionalPreviewSkeletalMeshes() const;
 
    ENGINE_API void SetAdditionalPreviewSkeletalMeshes(UDataAsset* InPreviewCollectionAsset);
 
    ENGINE_API int32 ValidatePreviewAttachedObjects();
 
    ENGINE_API int32 GetChildBones(int32 ParentBoneIndex, TArray<int32> & Children) const;
    
    ENGINE_API bool IsCompatibleForEditor(const USkeleton* InSkeleton) const;
 
    ENGINE_API bool IsCompatibleForEditor(const FAssetData& AssetData, const TCHAR* InTag = TEXT("Skeleton")) const;
 
    ENGINE_API bool IsCompatibleForEditor(const FString& SkeletonAssetString) const;
 
    ENGINE_API bool ShouldFilterAsset(const FAssetData& InAssetData, const TCHAR* InTag = TEXT("Skeleton")) const;
    
    ENGINE_API void GetCompatibleSkeletonAssets(TArray<FAssetData>& OutAssets) const;
 
    ENGINE_API void GetCompatibleAssets(UClass* AssetClass, const TCHAR* InTag, TArray<FAssetData>& OutAssets) const;
#endif
 
    DECLARE_EVENT(USkeleton, FSmartNamesChangedEvent);
 
#if WITH_EDITORONLY_DATA
    ENGINE_API static FAreAllSkeletonsCompatible AreAllSkeletonsCompatibleDelegate;
#endif
 
public:
    UFUNCTION(BlueprintCallable, Category=Skeleton)
    ENGINE_API void AddCompatibleSkeleton(const USkeleton* SourceSkeleton);
 
    UFUNCTION(BlueprintCallable, Category = Skeleton, DisplayName = "AddCompatibleSkeleton")
    ENGINE_API void AddCompatibleSkeletonSoft(const TSoftObjectPtr<USkeleton>& SourceSkeleton);
 
    ENGINE_API void RemoveCompatibleSkeleton(const USkeleton* SourceSkeleton);
    ENGINE_API void RemoveCompatibleSkeleton(const TSoftObjectPtr<USkeleton>& SourceSkeleton);
 
    ENGINE_API bool IsCompatibleMesh(const USkinnedAsset* InSkinnedAsset, bool bDoParentChainCheck=true) const;
 
    ENGINE_API void ClearCacheData();
 
    ENGINE_API const FSkeletonToMeshLinkup& FindOrAddMeshLinkupData(const USkinnedAsset* InSkinnedAsset);
 
    ENGINE_API const FSkeletonToMeshLinkup& AddMeshLinkupData(const USkinnedAsset* InSkinnedAsset);
 
    ENGINE_API bool MergeBonesToBoneTree(const USkinnedAsset* InSkinnedAsset, const TArray<int32> &RequiredRefBones, bool bShowProgress = true);
 
    ENGINE_API bool MergeAllBonesToBoneTree(const USkinnedAsset* InSkinnedAsset, bool bShowProgress = true);
 
    ENGINE_API bool RecreateBoneTree(USkinnedAsset* InSkinnedAsset);
 
    
    ENGINE_API const TArray<FTransform>& GetRefLocalPoses( FName RetargetSource = NAME_None ) const;
 
#if WITH_EDITORONLY_DATA
    ENGINE_API FName GetRetargetSourceForMesh(USkinnedAsset* InSkinnedAsset) const;
 
    ENGINE_API void GetRetargetSources(TArray<FName>& OutRetargetSources) const;
#endif
 
    UE_DEPRECATED(5.2, "GetRawAnimationTrackIndex has been deprecated, use tracks are referenced by name instead")
    ENGINE_API int32 GetRawAnimationTrackIndex(const int32 InSkeletonBoneIndex, const UAnimSequence* InAnimSeq);
 
    ENGINE_API int32 GetSkeletonBoneIndexFromMeshBoneIndex(const USkinnedAsset* InSkinnedAsset, const int32 MeshBoneIndex);
 
    ENGINE_API int32 GetMeshBoneIndexFromSkeletonBoneIndex(const USkinnedAsset* InSkinnedAsset, const int32 SkeletonBoneIndex);
 
    EBoneTranslationRetargetingMode::Type GetBoneTranslationRetargetingMode(const int32 BoneTreeIdx, bool bDisableRetargeting = false) const
    {
        if (!bDisableRetargeting && BoneTree.IsValidIndex(BoneTreeIdx))
        {
            return BoneTree[BoneTreeIdx].TranslationRetargetingMode;
        }
        return EBoneTranslationRetargetingMode::Animation;
    }
 
    ENGINE_API void RebuildLinkup(const USkinnedAsset* InSkinnedAsset);
 
    void RemoveLinkup(const USkinnedAsset* InSkinnedAsset);
 
    ENGINE_API void SetBoneTranslationRetargetingMode(const int32 BoneIndex, EBoneTranslationRetargetingMode::Type NewRetargetingMode, bool bChildrenToo=false);
 
    virtual bool IsPostLoadThreadSafe() const override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
 
    ENGINE_API void UpdateReferencePoseFromMesh(const USkinnedAsset* InSkinnedAsset);
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void UpdateRetargetSource( const FName InName );
#endif
protected:
    bool DoesParentChainMatch(int32 StartBoneTreeIndex, const USkinnedAsset* InSkinnedAsset) const;
 
    void BuildLinkupData(const USkinnedAsset* InSkinnedAsset, FSkeletonToMeshLinkup& NewMeshLinkup);
 
#if WITH_EDITORONLY_DATA
    void RefreshAllRetargetSources();
#endif
    bool CreateReferenceSkeletonFromMesh(const USkinnedAsset* InSkinnedAsset, const TArray<int32> & RequiredRefBones);
 
#if WITH_EDITOR
    DECLARE_MULTICAST_DELEGATE( FOnSkeletonHierarchyChangedMulticaster );
    FOnSkeletonHierarchyChangedMulticaster OnSkeletonHierarchyChanged;
 
    ENGINE_API void HandleSkeletonHierarchyChange(bool bShowProgress = true);
 
public:
    typedef FOnSkeletonHierarchyChangedMulticaster::FDelegate FOnSkeletonHierarchyChanged;
 
    ENGINE_API void RegisterOnSkeletonHierarchyChanged(const FOnSkeletonHierarchyChanged& Delegate);
    ENGINE_API void UnregisterOnSkeletonHierarchyChanged(FDelegateUserObject Unregister);
 
    ENGINE_API void RemoveBonesFromSkeleton(const TArray<FName>& BonesToRemove, bool bRemoveChildBones);
 
    // Asset registry information for animation notifies
    ENGINE_API static const FName AnimNotifyTag;
    ENGINE_API static const FString AnimNotifyTagDelimiter;
 
    // Asset registry information for animation sync markers
    ENGINE_API static const FName AnimSyncMarkerTag;
    ENGINE_API static const FString AnimSyncMarkerTagDelimiter;
    
    // Asset registry information for animation curves
    ENGINE_API static const FName CurveNameTag;
    ENGINE_API static const FString CurveTagDelimiter;
 
    // Asset registry information for animation attributes
    ENGINE_API static const FName AttributeTag;
 
    // Asset registry information for compatible skeletons
    ENGINE_API static const FName CompatibleSkeletonsNameTag;
    ENGINE_API static const FString CompatibleSkeletonsTagDelimiter;
 
#endif
 
public:
    ENGINE_API USkeletalMeshSocket* FindSocketAndIndex(FName InSocketName, int32& OutIndex) const;
    ENGINE_API USkeletalMeshSocket* FindSocket(FName InSocketName) const;
 
private:
    void RegenerateGuid();
    void RegenerateVirtualBoneGuid();
 
    // Handle skeletons being reloaded via the content browser
    static void HandlePackageReloaded(const EPackageReloadPhase InPackageReloadPhase, FPackageReloadedEvent* InPackageReloadedEvent);
 
public:
    //~ Begin IInterface_AssetUserData Interface
    ENGINE_API virtual void AddAssetUserData(UAssetUserData* InUserData) override;
    ENGINE_API virtual void RemoveUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    ENGINE_API virtual UAssetUserData* GetAssetUserDataOfClass(TSubclassOf<UAssetUserData> InUserDataClass) override;
    ENGINE_API virtual const TArray<UAssetUserData*>* GetAssetUserDataArray() const override;
    //~ End IInterface_AssetUserData Interface
protected:
    UPROPERTY(EditAnywhere, AdvancedDisplay, Instanced, Category = Skeleton)
    TArray<TObjectPtr<UAssetUserData>> AssetUserData;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, AdvancedDisplay, Instanced, Category = Skeleton)
    TArray<TObjectPtr<UAssetUserData>> AssetUserDataEditorOnly;
#endif
 
 
    friend struct FReferenceSkeletonModifier;
    friend class FEditableSkeleton;
};