AnimBank.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AnimationAsset.h"
#include "Animation/TransformProviderData.h"
#include "Experimental/Containers/RobinHoodHashTable.h"
#include "HLOD/HLODBatchingPolicy.h"
#include "Interfaces/Interface_AsyncCompilation.h"
#include "IO/IoHash.h"
#include "Logging/LogMacros.h"
#include "RenderCommandFence.h"
#include "SkinningDefinitions.h"
#include "UObject/ObjectPtr.h"
#include "UObject/WeakObjectPtr.h"
 
#include "AnimBank.generated.h"
 
ENGINE_API DECLARE_LOG_CATEGORY_EXTERN(LogAnimBank, Log, All);
 
class FQueuedThreadPool;
enum class EQueuedWorkPriority : uint8;
struct FPropertyChangedEvent;
 
struct FRenderBounds;
struct FReferenceSkeleton;
class USkinnedAsset;
class UInstancedSkinnedMeshComponent;
class FAnimBankBuildAsyncCacheTask;
 
struct FSkinnedAssetMapping
{
    // Bone transforms in global pose.
    TArray<FTransform> MeshGlobalRefPose;
    TArray<FTransform> AnimGlobalRefPose;
 
    // A map to go from the mesh skeleton bone index to anim skeleton bone index.
    TArray<int32> MeshToAnimIndexMap;
 
    // Retargeting table to go from the anim skeleton to the mesh skeleton.
    TArray<TTuple<FQuat, FQuat>> RetargetingTable;
 
    // Inverse global space transforms
    TArray<FVector3f> PositionKeys;
    TArray<FQuat4f> RotationKeys;
 
    uint32 BoneCount = 0;
};
 
inline FArchive& operator<<(FArchive& Ar, FSkinnedAssetMapping& AssetMapping)
{
    Ar << AssetMapping.MeshGlobalRefPose;
    Ar << AssetMapping.AnimGlobalRefPose;
    Ar << AssetMapping.MeshToAnimIndexMap;
    Ar << AssetMapping.RetargetingTable;
    Ar << AssetMapping.PositionKeys;
    Ar << AssetMapping.RotationKeys;
    Ar << AssetMapping.BoneCount;
    return Ar;
}
 
struct FAnimBankEntry
{
    TArray<FVector3f>   PositionKeys;
    TArray<FQuat4f>     RotationKeys;
    TArray<FVector3f>   ScalingKeys;
 
    FBoxSphereBounds SampledBounds;
 
    float Position      = 0.0f;
    float PlayRate      = 1.0f;
 
    uint32 FrameCount   = 0u;
    uint32 KeyCount     = 0u;
    uint32 Flags        = 0u;
 
    inline bool IsLooping() const
    {
        return (Flags & ANIM_BANK_FLAG_LOOPING) != 0;
    }
 
    inline bool IsAutoStart() const
    {
        return (Flags & ANIM_BANK_FLAG_AUTOSTART) != 0;
    }
};
 
inline FArchive& operator<<(FArchive& Ar, FAnimBankEntry& BankEntry)
{
    Ar << BankEntry.PositionKeys;
    Ar << BankEntry.RotationKeys;
    Ar << BankEntry.ScalingKeys;
    Ar << BankEntry.SampledBounds;
    Ar << BankEntry.Position;
    Ar << BankEntry.PlayRate;
    Ar << BankEntry.FrameCount;
    Ar << BankEntry.KeyCount;
    Ar << BankEntry.Flags;
    return Ar;
}
 
struct FAnimBankData
{
    FSkinnedAssetMapping Mapping;
    TArray<FAnimBankEntry> Entries;
};
 
inline FArchive& operator<<(FArchive& Ar, FAnimBankData& BankData)
{
    Ar << BankData.Mapping;
    Ar << BankData.Entries;
    return Ar;
}
 
USTRUCT(BlueprintType)
struct FAnimBankSequence
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Animation)
    TObjectPtr<class UAnimSequence> Sequence;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Animation, meta = (DisplayName = "Looping"))
    uint32 bLooping : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Animation, meta = (DisplayName = "AutoStart"))
    uint32 bAutoStart : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Animation, meta = (DisplayName = "Position"))
    float Position;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Animation, meta = (DisplayName = "PlayRate"))
    float PlayRate;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Animation, meta = (UIMin = "1", UIMax = "10.0"))
    float BoundsScale;
 
    FAnimBankSequence()
    {
        Sequence    = nullptr;
        BoundsScale = 1.0f;
        PlayRate    = 1.0f;
        bLooping    = true;
        bAutoStart  = true;
        Position    = 0.0f;
    }
 
    ENGINE_API void ValidatePosition();
};
 
UCLASS(BlueprintType, hidecategories=Object, editinlinenew, MinimalAPI)
class UAnimBank : public UAnimationAsset, public IInterface_AsyncCompilation
{
    GENERATED_BODY()
 
private:
#if WITH_EDITOR
    DECLARE_MULTICAST_DELEGATE(FOnGPUDataChanged);
#endif
 
public:
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Sequences, meta = (ShowOnlyInnerProperties))
    TArray<struct FAnimBankSequence> Sequences;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Mapping, meta = (ShowOnlyInnerProperties))
    TObjectPtr<USkinnedAsset> Asset;
#endif
 
public:
    virtual void Serialize(FArchive& Ar) override;
    virtual void PostLoad() override;
    virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    virtual void BeginDestroy() override;
    virtual bool IsReadyForFinishDestroy() override;
    virtual bool NeedsLoadForTargetPlatform(const ITargetPlatform* TargetPlatform) const override;
 
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
 
    void InitResources();
    void ReleaseResources();
 
    inline const FAnimBankData& GetData() const
    {
#if WITH_EDITOR
        check(!IsCompiling());
#endif
        return Data;
    }
 
#if WITH_EDITOR
    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    virtual void BeginCacheForCookedPlatformData(const ITargetPlatform* TargetPlatform) override;
    virtual bool IsCachedCookedPlatformDataLoaded(const ITargetPlatform* TargetPlatform) override;
    virtual void ClearAllCachedCookedPlatformData() override;
 
    virtual bool GetAllAnimationSequencesReferred(TArray<UAnimationAsset*>& AnimationAssets, bool bRecursive = true) override;
    virtual void ReplaceReferredAnimations(const TMap<UAnimationAsset*, UAnimationAsset*>& ReplacementMap) override;
 
    bool IsCompiling() const override;
 
    bool TryCancelAsyncTasks();
 
    bool IsAsyncTaskComplete() const;
 
    bool WaitForAsyncTasks(float TimeLimitSeconds);
 
    void FinishAsyncTasks();
 
    typedef FOnGPUDataChanged::FDelegate FOnRebuild;
    FDelegateHandle RegisterOnGPUDataChanged(const FOnRebuild& Delegate);
    void UnregisterOnGPUDataChanged(FDelegateUserObject Unregister);
    void UnregisterOnGPUDataChanged(FDelegateHandle Handle);
    void NotifyOnGPUDataChanged();
#endif
 
private:
#if WITH_EDITOR
    friend class FAnimBankCompilingManager;
    void Reschedule(FQueuedThreadPool* InThreadPool, EQueuedWorkPriority InPriority);
 
    FIoHash CreateDerivedDataKeyHash(const ITargetPlatform* TargetPlatform);
    FIoHash BeginCacheDerivedData(const ITargetPlatform* TargetPlatform);
    bool PollCacheDerivedData(const FIoHash& KeyHash) const;
    void EndCacheDerivedData(const FIoHash& KeyHash);
 
    FAnimBankData& CacheDerivedData(const ITargetPlatform* TargetPlatform);
#endif
 
private:
    bool bIsInitialized = false;
 
    FAnimBankData Data;
    FRenderCommandFence ReleaseResourcesFence;
 
#if WITH_EDITOR
    FIoHash DataKeyHash;
    TMap<FIoHash, TUniquePtr<FAnimBankData>> DataByPlatformKeyHash;
    TMap<FIoHash, TPimplPtr<FAnimBankBuildAsyncCacheTask>> CacheTasksByKeyHash;
 
    FOnGPUDataChanged OnGPUDataChanged;
 
    DECLARE_EVENT_OneParam(UAnimBank, FOnDependenciesChanged, UAnimBank*);
    static FOnDependenciesChanged OnDependenciesChanged;
#endif
};
 
struct FSoftAnimBankItem;
 
USTRUCT(BlueprintType)
struct FAnimBankItem
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Animation)
    TObjectPtr<UAnimBank> BankAsset = nullptr;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Animation)
    int32 SequenceIndex = 0;
 
    ENGINE_API FAnimBankItem();
    ENGINE_API FAnimBankItem(const FAnimBankItem& InBankItem);
    ENGINE_API explicit FAnimBankItem(const FSoftAnimBankItem& InBankItem);
 
    ENGINE_API bool operator!=(const FAnimBankItem& Other) const;
    ENGINE_API bool operator==(const FAnimBankItem& Other) const;
};
 
inline uint32 GetTypeHash(const FAnimBankItem& Key)
{
    return HashCombine(GetTypeHash(Key.BankAsset.Get()), GetTypeHash(Key.SequenceIndex));
}
 
inline uint32 GetTypeHash(const TArray<FAnimBankItem>& InBankItems)
{
    uint32 Hash = 0;
    for (const FAnimBankItem& BankItem : InBankItems)
    {
        Hash = HashCombine(Hash, GetTypeHash(BankItem));
    }
    return Hash;
}
 
USTRUCT(BlueprintType)
struct FSoftAnimBankItem
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Animation)
    TSoftObjectPtr<UAnimBank> BankAsset = nullptr;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Animation)
    int32 SequenceIndex = 0;
 
    ENGINE_API FSoftAnimBankItem();
    ENGINE_API FSoftAnimBankItem(const FSoftAnimBankItem& InBankItem);
    ENGINE_API explicit FSoftAnimBankItem(const FAnimBankItem& InBankItem);
 
    ENGINE_API bool operator!=(const FSoftAnimBankItem& Other) const;
    ENGINE_API bool operator==(const FSoftAnimBankItem& Other) const;
};
 
inline uint32 GetTypeHash(const FSoftAnimBankItem& Key)
{
    return HashCombine(GetTypeHash(Key.BankAsset.Get()), GetTypeHash(Key.SequenceIndex));
}
 
inline uint32 GetTypeHash(const TArray<FSoftAnimBankItem>& InBankItems)
{
    uint32 Hash = 0;
    for (const FSoftAnimBankItem& BankItem : InBankItems)
    {
        Hash = HashCombine(Hash, GetTypeHash(BankItem));
    }
    return Hash;
}
 
USTRUCT()
struct FSkinnedMeshComponentDescriptorBase
{
    GENERATED_BODY()
    ENGINE_API FSkinnedMeshComponentDescriptorBase();
    ENGINE_API explicit FSkinnedMeshComponentDescriptorBase(ENoInit);
    ENGINE_API explicit FSkinnedMeshComponentDescriptorBase(const FSkinnedMeshComponentDescriptorBase&);
    ENGINE_API virtual ~FSkinnedMeshComponentDescriptorBase();
 
    ENGINE_API UInstancedSkinnedMeshComponent* CreateComponent(UObject* Outer, FName Name = NAME_None, EObjectFlags ObjectFlags = EObjectFlags::RF_NoFlags) const;
 
    ENGINE_API virtual void InitFrom(const UInstancedSkinnedMeshComponent* Component, bool bInitBodyInstance = true);
    ENGINE_API virtual void InitComponent(UInstancedSkinnedMeshComponent* ISMComponent) const;
 
    ENGINE_API bool operator!=(const FSkinnedMeshComponentDescriptorBase& Other) const;
    ENGINE_API bool operator==(const FSkinnedMeshComponentDescriptorBase& Other) const;
 
public:
    UPROPERTY()
    mutable uint32 Hash = 0;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings")
    TEnumAsByte<EComponentMobility::Type> Mobility;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings")
    TSubclassOf<UInstancedSkinnedMeshComponent> ComponentClass;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings")
    int32 InstanceMinDrawDistance;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings")
    int32 InstanceStartCullDistance;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings")
    int32 InstanceEndCullDistance;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings")
    uint8 bCastShadow : 1;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (EditCondition = "bCastShadow"))
    uint8 bCastDynamicShadow : 1;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (EditCondition = "bCastShadow"))
    uint8 bCastStaticShadow : 1;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (EditCondition = "bCastShadow"))
    uint8 bCastVolumetricTranslucentShadow : 1;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (EditCondition = "bCastShadow"))
    uint8 bCastContactShadow : 1;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (EditCondition = "bCastShadow"))
    uint8 bSelfShadowOnly : 1;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (EditCondition = "bCastShadow"))
    uint8 bCastFarShadow : 1;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (EditCondition = "bCastShadow"))
    uint8 bCastInsetShadow : 1;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (EditCondition = "bCastShadow"))
    uint8 bCastCinematicShadow : 1;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (EditCondition = "bCastShadow"))
    uint8 bCastShadowAsTwoSided : 1;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings")
    bool bVisibleInRayTracing = true;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings")
    bool bAffectDynamicIndirectLighting = true;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings")
    bool bAffectDistanceFieldLighting = true;
 
    UPROPERTY()
    FBox PrimitiveBoundsOverride;
 
    UPROPERTY()
    bool bIsInstanceDataGPUOnly = false;
 
    UPROPERTY()
    int32 NumInstancesGPUOnly = 0;
 
    UPROPERTY()
    int32 NumCustomDataFloatsGPUOnly = 0;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category = "Component Settings")
    uint8 bIncludeInHLOD : 1;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings")
    EHLODBatchingPolicy HLODBatchingPolicy;
#endif
};
 
USTRUCT()
struct FSkinnedMeshComponentDescriptor : public FSkinnedMeshComponentDescriptorBase
{
    GENERATED_BODY()
 
    ENGINE_API FSkinnedMeshComponentDescriptor();
    ENGINE_API explicit FSkinnedMeshComponentDescriptor(ENoInit);
    ENGINE_API explicit FSkinnedMeshComponentDescriptor(const FSkinnedMeshComponentDescriptor&);
    ENGINE_API explicit FSkinnedMeshComponentDescriptor(const FSoftSkinnedMeshComponentDescriptor&);
    ENGINE_API virtual ~FSkinnedMeshComponentDescriptor();
 
    ENGINE_API UInstancedSkinnedMeshComponent* CreateComponent(UObject* Outer, FName Name = NAME_None, EObjectFlags ObjectFlags = EObjectFlags::RF_NoFlags) const;
 
    ENGINE_API virtual void InitFrom(const UInstancedSkinnedMeshComponent* Component, bool bInitBodyInstance = true);
    ENGINE_API virtual uint32 ComputeHash() const;
    ENGINE_API virtual void InitComponent(UInstancedSkinnedMeshComponent* ISMComponent) const;
 
    ENGINE_API void PostLoadFixup(UObject* Loader);
 
    ENGINE_API bool operator!=(const FSkinnedMeshComponentDescriptor& Other) const;
    ENGINE_API bool operator==(const FSkinnedMeshComponentDescriptor& Other) const;
 
    friend inline uint32 GetTypeHash(const FSkinnedMeshComponentDescriptor& Key)
    {
        return Key.GetTypeHash();
    }
 
    uint32 GetTypeHash() const
    {
        if (Hash == 0)
        {
            ComputeHash();
        }
        return Hash;
    }
 
public:
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (DisplayAfter = "ComponentClass"))
    TObjectPtr<class USkinnedAsset> SkinnedAsset;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (DisplayAfter = "SkinnedAsset"))
    TObjectPtr<class UTransformProviderData> TransformProvider;
};
 
USTRUCT()
struct FSoftSkinnedMeshComponentDescriptor : public FSkinnedMeshComponentDescriptorBase
{
    GENERATED_BODY()
 
    ENGINE_API FSoftSkinnedMeshComponentDescriptor();
    ENGINE_API explicit FSoftSkinnedMeshComponentDescriptor(ENoInit);
    ENGINE_API explicit FSoftSkinnedMeshComponentDescriptor(const FSkinnedMeshComponentDescriptor&);
    ENGINE_API explicit FSoftSkinnedMeshComponentDescriptor(const FSoftSkinnedMeshComponentDescriptor&);
    ENGINE_API virtual ~FSoftSkinnedMeshComponentDescriptor();
 
    ENGINE_API UInstancedSkinnedMeshComponent* CreateComponent(UObject* Outer, FName Name = NAME_None, EObjectFlags ObjectFlags = EObjectFlags::RF_NoFlags) const;
 
    ENGINE_API virtual void InitFrom(const UInstancedSkinnedMeshComponent* Component, bool bInitBodyInstance = true);
    ENGINE_API virtual uint32 ComputeHash() const;
    ENGINE_API virtual void InitComponent(UInstancedSkinnedMeshComponent* ISMComponent) const;
 
    ENGINE_API void PostLoadFixup(UObject* Loader);
 
    ENGINE_API bool operator!=(const FSoftSkinnedMeshComponentDescriptor& Other) const;
    ENGINE_API bool operator==(const FSoftSkinnedMeshComponentDescriptor& Other) const;
 
    friend inline uint32 GetTypeHash(const FSoftSkinnedMeshComponentDescriptor& Key)
    {
        return Key.GetTypeHash();
    }
 
    uint32 GetTypeHash() const
    {
        if (Hash == 0)
        {
            ComputeHash();
        }
        return Hash;
    }
 
public:
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (DisplayAfter = "ComponentClass"))
    TSoftObjectPtr<class USkinnedAsset> SkinnedAsset;
 
    UPROPERTY(EditAnywhere, Category = "Component Settings", meta = (DisplayAfter = "SkinnedAsset"))
    TSoftObjectPtr<class UTransformProviderData> TransformProvider;
};
 
struct FAnimBankDesc
{
    typedef Experimental::FHashType FDescHash;
 
    TWeakObjectPtr<const UAnimBank> BankAsset;
    TWeakObjectPtr<const USkinnedAsset> Asset;
 
    uint32 SequenceIndex    = 0u;
    float Position          = 0.0f;
    float PlayRate          = 1.0f;
    uint8 bLooping   : 1    = 1;
    uint8 bAutoStart : 1    = 1;
 
    ENGINE_API uint32 GetHash() const;
 
    friend uint32 GetTypeHash(const FAnimBankDesc& Desc)
    {
        return Desc.GetHash();
    }
};
 
struct FAnimBankRecordHandle
{
    int32 Id    = INDEX_NONE;
    uint32 Hash = 0u;
 
    inline bool IsValid() const
    {
        return Id != INDEX_NONE && Hash != 0u;
    }
};
 
struct FAnimBankRecord
{
    typedef Experimental::FHashElementId FRecordId;
 
    FAnimBankDesc Desc;
    int32 RecordId = INDEX_NONE;
    int32 KeyOffset = INDEX_NONE;
    uint32 KeyCount = 0;
    int32 FrameCount = 0;
    int32 ReferenceCount = 0;
 
    // TODO: De-dup using USkinnedAsset*
    FSkinnedAssetMapping AssetMapping;
 
    TArray<FVector3f>   PositionKeys;
    TArray<FQuat4f>     RotationKeys;
 
    // Playback
    uint8               Playing : 1 = 0;
    float               CurrentTime = 0.0f;
    float               PreviousTime = 0.0f;
};
 
struct FAnimBankDescKeyFuncs : TDefaultMapHashableKeyFuncs<FAnimBankDesc, FAnimBankRecord, false>
{
    static inline bool Matches(KeyInitType A, KeyInitType B)
    {
        return
            A.BankAsset     == B.BankAsset &&
            A.SequenceIndex == B.SequenceIndex &&
            A.Asset         == B.Asset &&
            A.Position      == B.Position &&
            A.PlayRate      == B.PlayRate &&
            A.bLooping      == B.bLooping &&
            A.bAutoStart    == B.bAutoStart;
    }
 
    static inline uint32 GetKeyHash(KeyInitType Key)
    {
        return Key.GetHash();
    }
};
 
UCLASS(config=Engine, hidecategories=Object, MinimalAPI, BlueprintType)
class UAnimBankData : public UTransformProviderData
{
    GENERATED_BODY()
 
public:
    virtual bool IsEnabled() const override;
    virtual const FGuid& GetTransformProviderID() const override;
    virtual bool UsesSkeletonBatching() const override;
    virtual const uint32 GetUniqueAnimationCount() const override;
    virtual bool HasAnimationBounds() const override;
    virtual bool GetAnimationBounds(uint32 AnimationIndex, FRenderBounds& OutBounds) const override;
    virtual uint32 GetSkinningDataOffset(int32 InstanceIndex, const FTransform& ComponentTransform, const FSkinnedMeshInstanceData& InstanceData) const override;
    virtual FTransformProviderRenderProxy* CreateRenderThreadResources(FSkinningSceneExtensionProxy* SceneProxy, FSceneInterface& Scene, FRHICommandListBase& RHICmdList) override;
    virtual void DestroyRenderThreadResources(FTransformProviderRenderProxy* ProviderProxy) override;
    virtual bool IsCompiling() const override;
 
#if WITH_EDITOR
    void BeginCacheForCookedPlatformData(const ITargetPlatform* TargetPlatform) override;
    bool IsCachedCookedPlatformDataLoaded(const ITargetPlatform* TargetPlatform) override;
#endif
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = TransformProvider, meta = (ShowOnlyInnerProperties))
    TArray<struct FAnimBankItem> AnimBankItems;
};
 
class FAnimBankDataRenderProxy : public FTransformProviderRenderProxy
{
    friend class UAnimBankData;
 
public:
    ENGINE_API FAnimBankDataRenderProxy(UAnimBankData* BankData, FSkinningSceneExtensionProxy* SceneProxy, FSceneInterface& Scene);
    ENGINE_API virtual ~FAnimBankDataRenderProxy();
    ENGINE_API virtual void CreateRenderThreadResources(FRHICommandListBase& RHICmdList) override;
    ENGINE_API virtual void DestroyRenderThreadResources() override;
    ENGINE_API virtual const TConstArrayView<uint64> GetProviderData(bool& bOutValid) const override;
 
private:
    FSkinningSceneExtensionProxy* SceneProxy = nullptr;
    TObjectPtr<const class USkinnedAsset> SkinnedAsset = nullptr;
    FSceneInterface& Scene;
    TArray<uint64> AnimBankIds;
    TArray<FAnimBankRecordHandle> AnimBankHandles;
    TArray<FAnimBankItem> AnimBankItems;
    uint32 UniqueAnimationCount = 0;
};
 
using FAnimBankRecordMap = Experimental::TRobinHoodHashMap<FAnimBankDesc, FAnimBankRecord, FAnimBankDescKeyFuncs>;
 
namespace UE::AnimBank
{
 
// Convert a list of transforms from bone/local space to mesh/global space by walking through the
// hierarchy of a reference skeleton.
ENGINE_API void ConvertLocalToGlobalSpaceTransforms(
    const FReferenceSkeleton& InRefSkeleton,
    const TArray<FTransform>& InLocalSpaceTransforms,
    TArray<FTransform>& OutGlobalSpaceTransforms
);
 
ENGINE_API void BuildSkinnedAssetMapping(const USkinnedAsset& Asset, FSkinnedAssetMapping& Mapping);
 
}