BoneContainer.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/WeakObjectPtr.h"
#include "BoneIndices.h"
#include "ReferenceSkeleton.h"
#include "Animation/AnimCurveFilter.h"
#include "Animation/AnimTypes.h"
#include "Animation/BoneReference.h"
#include "Animation/AnimCurveMetadata.h"
#include "Animation/AnimBulkCurves.h"
 
class USkeletalMesh;
struct FBoneContainer;
struct FSkeletonRemapping;
struct FBlendedCurve;
struct FAnimCurveType;
 
namespace SmartName
{
typedef uint16 UID_Type;
}
 
struct FSkelMeshRefPoseOverride
{
    TArray<FMatrix44f> RefBasesInvMatrix;
    TArray<FTransform> RefBonePoses;
};
 
struct FVirtualBoneCompactPoseData
{
    FCompactPoseBoneIndex VBIndex;
    FCompactPoseBoneIndex SourceIndex;
    FCompactPoseBoneIndex TargetIndex;
 
    FVirtualBoneCompactPoseData(FCompactPoseBoneIndex InVBIndex, FCompactPoseBoneIndex InSourceIndex, FCompactPoseBoneIndex InTargetIndex)
        : VBIndex(InVBIndex)
        , SourceIndex(InSourceIndex)
        , TargetIndex(InTargetIndex)
    {}
};
 
// DEPRECATED - please use UE::Anim::FCurveFilterSettings
struct FCurveEvaluationOption
{
    bool bAllowCurveEvaluation;
    const TArray<FName>* DisallowedList;
    int32 LODIndex;
 
    UE_DEPRECATED(5.3, "Please use UE::Anim::FCurveFilterSettings.")
    FCurveEvaluationOption(bool bInAllowCurveEvaluation = true, const TArray<FName>* InDisallowedList = nullptr, int32 InLODIndex = 0)
        : bAllowCurveEvaluation(bInAllowCurveEvaluation)
        , DisallowedList(InDisallowedList)
        , LODIndex(InLODIndex)
    {
    }
};
 
namespace UE::Anim
{
 
struct FCurveFilterSettings
{
    FCurveFilterSettings(UE::Anim::ECurveFilterMode InFilterMode = UE::Anim::ECurveFilterMode::DisallowFiltered, const TArray<FName>* InFilterCurves = nullptr, int32 InLODIndex = 0)
        : FilterCurves(InFilterCurves)
        , FilterMode(InFilterMode)
        , LODIndex(InLODIndex)
    {}
 
    // Filter curves. Application of these curves is dependent on FilterMode
    const TArray<FName>* FilterCurves = nullptr;
    
    // Filtering mode - allows curves to be disable entirely or allow/deny-listed
    UE::Anim::ECurveFilterMode FilterMode = UE::Anim::ECurveFilterMode::DisallowFiltered;
 
    // LOD index
    int32 LODIndex = 0;
};
 
}
 
struct FOrientAndScaleRetargetingCachedData
{
    FQuat TranslationDeltaOrient;
    float TranslationScale;
    FVector SourceTranslation;
    FVector TargetTranslation;
 
    FOrientAndScaleRetargetingCachedData
    (
        const FQuat& InTranslationDeltaOrient, 
        const float InTranslationScale, 
        const FVector& InSourceTranslation,
        const FVector& InTargetTranslation
    )
        : TranslationDeltaOrient(InTranslationDeltaOrient)
        , TranslationScale(InTranslationScale)
        , SourceTranslation(InSourceTranslation)
        , TargetTranslation(InTargetTranslation)
    {
    }
};
 
struct FCachedSkeletonCurveMapping
{
    TArray<SmartName::UID_Type> UIDToArrayIndices; 
    bool bIsDirty = true; 
};
 
struct FRetargetSourceCachedData
{
    TArray<FOrientAndScaleRetargetingCachedData> OrientAndScaleData;
 
    TArray<int32> CompactPoseIndexToOrientAndScaleIndex;
};
 
struct FCompactPoseBoneIndexIterator
{
    int32 Index;
 
    FCompactPoseBoneIndexIterator(int32 InIndex) : Index(InIndex) {}
 
    FCompactPoseBoneIndexIterator& operator++() { ++Index; return (*this); }
    bool operator==(FCompactPoseBoneIndexIterator& Rhs) { return Index == Rhs.Index; }
    bool operator!=(FCompactPoseBoneIndexIterator& Rhs) { return Index != Rhs.Index; }
    FCompactPoseBoneIndex operator*() const { return FCompactPoseBoneIndex(Index); }
};
 
struct FCompactPoseBoneIndexReverseIterator
{
    int32 Index;
 
    FCompactPoseBoneIndexReverseIterator(int32 InIndex) : Index(InIndex) {}
 
    FCompactPoseBoneIndexReverseIterator& operator++() { --Index; return (*this); }
    bool operator==(FCompactPoseBoneIndexReverseIterator& Rhs) { return Index == Rhs.Index; }
    bool operator!=(FCompactPoseBoneIndexReverseIterator& Rhs) { return Index != Rhs.Index; }
    FCompactPoseBoneIndex operator*() const { return FCompactPoseBoneIndex(Index); }
};
 
struct FRetargetSourceCachedDataKey
{
    FTopLevelAssetPath SourceSkeletonPath;
    FName SourceRetargetName;
 
    FRetargetSourceCachedDataKey(const UObject* Skeleton, const FName& InSourceRetargetName)
        : SourceSkeletonPath(Skeleton)
        , SourceRetargetName(InSourceRetargetName)
    {
    }
 
    bool operator==(const FRetargetSourceCachedDataKey& Other) const
    {
        return SourceSkeletonPath == Other.SourceSkeletonPath && SourceRetargetName == Other.SourceRetargetName;
    }
    friend uint32 GetTypeHash(const FRetargetSourceCachedDataKey& Obj)
    {
        return HashCombine(GetTypeHash(Obj.SourceSkeletonPath), GetTypeHash(Obj.SourceRetargetName));
    }
};
 
struct FBoneContainer
{
private:
    TArray<FBoneIndexType>  BoneIndicesArray;
    TBitArray<>             BoneSwitchArray;
 
    TWeakObjectPtr<UObject> Asset;
    TWeakObjectPtr<USkeletalMesh> AssetSkeletalMesh;
    TWeakObjectPtr<USkeleton> AssetSkeleton;
 
    const FReferenceSkeleton* RefSkeleton;
 
    TArray<int32> SkeletonToPoseBoneIndexArray;
 
    TArray<int32> PoseToSkeletonBoneIndexArray;
 
    // Look up from skeleton to compact pose format
    TArray<int32> CompactPoseToSkeletonIndex;
 
    // Look up from compact pose format to skeleton
    TArray<FCompactPoseBoneIndex> SkeletonToCompactPose;
 
    // Compact pose format of Parent Bones (to save us converting to mesh space and back)
    TArray<FCompactPoseBoneIndex> CompactPoseParentBones;
 
    // Array of cached virtual bone data so that animations running from raw data can generate them.
    TArray<FVirtualBoneCompactPoseData> VirtualBoneCompactPoseData;
 
    UE::Anim::FCurveFilter CurveFilter;
 
    UE::Anim::FBulkCurveFlags CurveFlags;
    
    TSharedPtr<FSkelMeshRefPoseOverride> RefPoseOverride;
    
    // The serial number of this bone container. This is incremented each time the container is regenerated and can
    // be used to track whether to cache bone data. If this value is zero then the bone container is considered invalid
    // as it has never been regenerated.
    uint16 SerialNumber;
 
#if DO_CHECK
    int32 CalculatedForLOD;
#endif
    bool bDisableRetargeting;
    bool bUseRAWData;
    bool bUseSourceData;
 
public:
 
    ENGINE_API FBoneContainer();
 
    ENGINE_API FBoneContainer(const TArrayView<const FBoneIndexType>& InRequiredBoneIndexArray, const UE::Anim::FCurveFilterSettings& InCurveFilterSettings, UObject& InAsset);
    
    ENGINE_API void InitializeTo(const TArrayView<const FBoneIndexType>& InRequiredBoneIndexArray, const UE::Anim::FCurveFilterSettings& InCurveFilterSettings, const UObject& InAsset);
    
    UE_DEPRECATED(5.3, "Please use the constructor that takes a FCurveFilterSettings.")
    ENGINE_API FBoneContainer(const TArrayView<const FBoneIndexType>& InRequiredBoneIndexArray, const FCurveEvaluationOption& CurveEvalOption, UObject& InAsset);
 
    UE_DEPRECATED(5.3, "Please use InitializeTo that takes a FCurveFilterSettings.")
    ENGINE_API void InitializeTo(const TArrayView<const FBoneIndexType>& InRequiredBoneIndexArray, const FCurveEvaluationOption& CurveEvalOption, const UObject& InAsset);
 
    ENGINE_API void Reset();
 
    const bool IsValid() const
    {
        return (Asset.IsValid(
#if WITH_EDITOR
            true, true
#endif
            )
                && (RefSkeleton != nullptr) && (BoneIndicesArray.Num() > 0));
    }
 
    UObject* GetAsset() const
    {
        return Asset.Get();
    }
 
    USkeletalMesh* GetSkeletalMeshAsset() const
    {
        return AssetSkeletalMesh.Get();
    }
 
    USkeleton* GetSkeletonAsset(bool bEvenIfUnreachable = false) const
    {
        return
#if WITH_EDITOR
        bEvenIfUnreachable ? AssetSkeleton.GetEvenIfUnreachable() : 
#endif
        AssetSkeleton.Get();
    }
 
    void SetDisableRetargeting(bool InbDisableRetargeting)
    {
        bDisableRetargeting = InbDisableRetargeting;
    }
 
    bool GetDisableRetargeting() const
    {
        return bDisableRetargeting;
    }
 
    void SetUseRAWData(bool InbUseRAWData)
    {
        bUseRAWData = InbUseRAWData;
    }
 
    bool ShouldUseRawData() const
    {
        return bUseRAWData;
    }
 
    void SetUseSourceData(bool InbUseSourceData)
    {
        bUseSourceData = InbUseSourceData;
    }
 
    bool ShouldUseSourceData() const
    {
        return bUseSourceData;
    }
 
    const TArray<FBoneIndexType>& GetBoneIndicesArray() const
    {
        return BoneIndicesArray;
    }
 
    const TArray<FVirtualBoneCompactPoseData>& GetVirtualBoneCompactPoseData() const { return VirtualBoneCompactPoseData; }
 
    const TBitArray<>& GetBoneSwitchArray() const
    {
        return BoneSwitchArray;
    }
 
    const TArray<FTransform>& GetRefPoseArray() const
    {
        return RefSkeleton->GetRefBonePose();
    }
 
    const TArray<FCompactPoseBoneIndex>& GetCompactPoseParentBoneArray() const
    {
        return CompactPoseParentBones;
    }
 
    // Fill the supplied buffer with the compact pose reference pose
    template<typename ArrayType>
    void FillWithCompactRefPose(ArrayType& OutTransforms) const
    {
        const int32 CompactPoseBoneCount = GetCompactPoseNumBones();
        OutTransforms.Reset(CompactPoseBoneCount);
        OutTransforms.SetNumUninitialized(CompactPoseBoneCount);
        
        const TArray<FTransform>& RefPoseTransforms = RefPoseOverride.IsValid() ? RefPoseOverride->RefBonePoses : RefSkeleton->GetRefBonePose();
        for (int32 CompactBoneIndex = 0; CompactBoneIndex < CompactPoseBoneCount; ++CompactBoneIndex)
        {
            OutTransforms[CompactBoneIndex] = RefPoseTransforms[BoneIndicesArray[CompactBoneIndex]];
        }
    }
    
    const FTransform& GetRefPoseTransform(const FCompactPoseBoneIndex& BoneIndex) const
    {
        const TArray<FTransform>& RefPoseTransforms = RefPoseOverride.IsValid() ? RefPoseOverride->RefBonePoses : RefSkeleton->GetRefBonePose();
        return RefPoseTransforms[BoneIndicesArray[BoneIndex.GetInt()]];
    }
 
    void SetRefPoseOverride(const TSharedPtr<FSkelMeshRefPoseOverride>& InRefPoseOverride)
    {
        if (InRefPoseOverride.Get() != RefPoseOverride.Get())
        {
            RefPoseOverride = InRefPoseOverride;
        }
    }
 
    const FReferenceSkeleton& GetReferenceSkeleton() const
    {
        return *RefSkeleton;
    }
 
    const int32 GetNumBones() const
    {
        return RefSkeleton->GetNum();
    }
 
    const int32 GetCompactPoseNumBones() const
    {
        return BoneIndicesArray.Num();
    }
 
    ENGINE_API int32 GetPoseBoneIndexForBoneName(const FName& BoneName) const;
 
    ENGINE_API int32 GetParentBoneIndex(const int32 BoneIndex) const;
 
    ENGINE_API FCompactPoseBoneIndex GetParentBoneIndex(const FCompactPoseBoneIndex& BoneIndex) const;
 
    ENGINE_API int32 GetDepthBetweenBones(const int32 BoneIndex, const int32 ParentBoneIndex) const;
 
    ENGINE_API bool BoneIsChildOf(const int32 BoneIndex, const int32 ParentBoneIndex) const;
 
    ENGINE_API bool BoneIsChildOf(const FCompactPoseBoneIndex& BoneIndex, const FCompactPoseBoneIndex& ParentBoneIndex) const;
 
    const UE::Anim::FCurveFilter& GetCurveFilter() const
    {
        return CurveFilter;
    }
 
    const UE::Anim::FBulkCurveFlags& GetCurveFlags() const
    {
        return CurveFlags;
    }
 
    UE_DEPRECATED(5.3, "GetUIDToArrayLookupTable is deprecated, it is no longer used.")
    ENGINE_API TArray<uint16> const& GetUIDToArrayLookupTable() const;
 
    UE_DEPRECATED(5.3, "GetUIDToArrayIndexLookupTableValidCount is deprecated, it is no longer used.")
    ENGINE_API int32 GetUIDToArrayIndexLookupTableValidCount() const;
 
    UE_DEPRECATED(5.0, "GetUIDToNameLookupTable is deprecated, please access from the SmartNameMapping directly via GetSkeletonAsset()->GetSmartNameContainer(USkeleton::AnimCurveMappingName)")
    TArray<FName> const& GetUIDToNameLookupTable() const
    {
        static TArray<FName> Dummy;
        return Dummy;
    }
 
    UE_DEPRECATED(5.0, "GetUIDToCurveTypeLookupTable is deprecated, please access from the SmartNameMapping directly via GetSkeletonAsset()->GetSmartNameContainer(USkeleton::AnimCurveMappingName)")
    ENGINE_API TArray<FAnimCurveType> const& GetUIDToCurveTypeLookupTable() const;
 
    UE_DEPRECATED(5.3, "GetUIDToArrayLookupTableBackup is deprecated, it is no longer used.")
    ENGINE_API TArray<SmartName::UID_Type> const& GetUIDToArrayLookupTableBackup() const;
 
    friend FArchive& operator<<(FArchive& Ar, FBoneContainer& B)
    {
        Ar
            << B.BoneIndicesArray
            << B.BoneSwitchArray
            << B.Asset
            << B.AssetSkeletalMesh
            << B.AssetSkeleton
            << B.SkeletonToPoseBoneIndexArray
            << B.PoseToSkeletonBoneIndexArray
            << B.bDisableRetargeting
            << B.bUseRAWData
            << B.bUseSourceData
            ;
 
        return Ar;
    }
 
    bool Contains(FBoneIndexType NewIndex) const
    {
        return BoneSwitchArray[NewIndex];
    }
 
    UE_DEPRECATED(5.0, "Please use GetMeshPoseIndexFromSkeletonPoseIndex")
    TArray<int32> const & GetSkeletonToPoseBoneIndexArray() const
    {
        return SkeletonToPoseBoneIndexArray;
    }
 
    UE_DEPRECATED(5.0, "Please use GetSkeletonPoseIndexFromMeshPoseIndex")
    TArray<int32> const & GetPoseToSkeletonBoneIndexArray() const
    {
        return PoseToSkeletonBoneIndexArray;
    }
    
    template<typename IterType>
    struct FRangedForSupport
    {
        const FBoneContainer& BoneContainer;
 
        FRangedForSupport(const FBoneContainer& InBoneContainer) : BoneContainer(InBoneContainer) {};
        
        IterType begin() { return BoneContainer.MakeBeginIter(); }
        IterType end() { return BoneContainer.MakeEndIter(); }
    };
 
    template<typename IterType>
    struct FRangedForReverseSupport
    {
        const FBoneContainer& BoneContainer;
 
        FRangedForReverseSupport(const FBoneContainer& InBoneContainer) : BoneContainer(InBoneContainer) {};
 
        IterType begin() { return BoneContainer.MakeBeginIterReverse(); }
        IterType end() { return BoneContainer.MakeEndIterReverse(); }
    };
    
    inline FRangedForSupport<FCompactPoseBoneIndexIterator> ForEachCompactPoseBoneIndex() const
    {
        return FRangedForSupport<FCompactPoseBoneIndexIterator>(*this);
    }
    inline FRangedForReverseSupport<FCompactPoseBoneIndexReverseIterator> ForEachCompactPoseBoneIndexReverse() const
    {
        return FRangedForReverseSupport<FCompactPoseBoneIndexReverseIterator>(*this);
    }
    inline FCompactPoseBoneIndexIterator MakeBeginIter() const
    {
        return FCompactPoseBoneIndexIterator(0);
    }
    inline FCompactPoseBoneIndexIterator MakeEndIter() const
    {
        return FCompactPoseBoneIndexIterator(GetCompactPoseNumBones());
    }
    inline FCompactPoseBoneIndexReverseIterator MakeBeginIterReverse() const
    {
        return FCompactPoseBoneIndexReverseIterator(GetCompactPoseNumBones() - 1);
    }
    inline FCompactPoseBoneIndexReverseIterator MakeEndIterReverse() const
    {
        return FCompactPoseBoneIndexReverseIterator(-1);
    }
    
    FMeshPoseBoneIndex GetMeshPoseIndexFromSkeletonPoseIndex(const FSkeletonPoseBoneIndex& SkeletonIndex) const
    {
        if (SkeletonToPoseBoneIndexArray.IsValidIndex(SkeletonIndex.GetInt()))
        {
            return FMeshPoseBoneIndex(SkeletonToPoseBoneIndexArray[SkeletonIndex.GetInt()]);
        }
        
        return FMeshPoseBoneIndex(INDEX_NONE);
    }
 
    FSkeletonPoseBoneIndex GetSkeletonPoseIndexFromMeshPoseIndex(const FMeshPoseBoneIndex& MeshIndex) const
    {
        if (ensure(PoseToSkeletonBoneIndexArray.IsValidIndex(MeshIndex.GetInt())))
        {
            return FSkeletonPoseBoneIndex(PoseToSkeletonBoneIndexArray[MeshIndex.GetInt()]);
        }
        
        return FSkeletonPoseBoneIndex(INDEX_NONE);
    }
 
    // DEPRECATED - Ideally should use GetSkeletonPoseIndexFromCompactPoseIndex due to raw int32 here
    int32 GetSkeletonIndex(const FCompactPoseBoneIndex& BoneIndex) const
    {
        return CompactPoseToSkeletonIndex[BoneIndex.GetInt()];
    }
 
    FSkeletonPoseBoneIndex GetSkeletonPoseIndexFromCompactPoseIndex(const FCompactPoseBoneIndex& BoneIndex) const
    {
        if (ensure(CompactPoseToSkeletonIndex.IsValidIndex(BoneIndex.GetInt())))
        {
            return FSkeletonPoseBoneIndex(CompactPoseToSkeletonIndex[BoneIndex.GetInt()]);
        }
        
        return FSkeletonPoseBoneIndex(INDEX_NONE);
    }
 
    // DEPRECATED - Ideally should use GetCompactPoseIndexFromSkeletonPoseIndex due to raw int32 here
    FCompactPoseBoneIndex GetCompactPoseIndexFromSkeletonIndex(const int32 SkeletonIndex) const
    {
        if (ensure(SkeletonToCompactPose.IsValidIndex(SkeletonIndex)))
        {
            return SkeletonToCompactPose[SkeletonIndex];
        }
 
        return FCompactPoseBoneIndex(INDEX_NONE);
    }
 
    FCompactPoseBoneIndex GetCompactPoseIndexFromSkeletonPoseIndex(const FSkeletonPoseBoneIndex& SkeletonIndex) const
    {
        if (SkeletonToCompactPose.IsValidIndex(SkeletonIndex.GetInt()))
        {
            return SkeletonToCompactPose[SkeletonIndex.GetInt()];
        }
 
        return FCompactPoseBoneIndex(INDEX_NONE);
    }
 
    bool IsSkeletonPoseIndexValid(const FSkeletonPoseBoneIndex& SkeletonIndex) const
    {
        return SkeletonToCompactPose.IsValidIndex(SkeletonIndex.GetInt());
    }
 
    FMeshPoseBoneIndex MakeMeshPoseIndex(const FCompactPoseBoneIndex& BoneIndex) const
    {
        return FMeshPoseBoneIndex(GetBoneIndicesArray()[BoneIndex.GetInt()]);
    }
 
    FCompactPoseBoneIndex MakeCompactPoseIndex(const FMeshPoseBoneIndex& BoneIndex) const
    {
        return FCompactPoseBoneIndex(GetBoneIndicesArray().IndexOfByKey(BoneIndex.GetInt()));
    }
 
    UE_DEPRECATED(5.3, "Please use CacheRequiredAnimCurves with a FCurveFilterSettings.")
    void CacheRequiredAnimCurveUids(const FCurveEvaluationOption& CurveEvalOption)
    {
        const UE::Anim::FCurveFilterSettings CurveFilterSettings(CurveEvalOption.bAllowCurveEvaluation ? UE::Anim::ECurveFilterMode::None : UE::Anim::ECurveFilterMode::DisallowAll, CurveEvalOption.DisallowedList, CurveEvalOption.LODIndex);
        CacheRequiredAnimCurves(CurveFilterSettings);
    }
 
    ENGINE_API void CacheRequiredAnimCurves(const UE::Anim::FCurveFilterSettings& InCurveFilterSettings);
    
    ENGINE_API const FRetargetSourceCachedData& GetRetargetSourceCachedData(const FName& InRetargetSource) const;
    ENGINE_API const FRetargetSourceCachedData& GetRetargetSourceCachedData(const FName& InSourceName, const FSkeletonRemapping& InRemapping, const TArray<FTransform>& InRetargetTransforms) const;
 
#if DO_CHECK
    int32 GetCalculatedForLOD() const { return CalculatedForLOD; }
#endif
    
    // Curve remapping
    ENGINE_API const FCachedSkeletonCurveMapping& GetOrCreateCachedCurveMapping(const FSkeletonRemapping* SkeletonRemapping);
    ENGINE_API void MarkAllCachedCurveMappingsDirty();
 
    // Get the serial number of this bone container. @see SerialNumber
    uint16 GetSerialNumber() const { return SerialNumber; }
 
private:
    mutable TMap<FRetargetSourceCachedDataKey, FRetargetSourceCachedData> RetargetSourceCachedDataLUT;
 
    ENGINE_API void Initialize(const UE::Anim::FCurveFilterSettings& CurveFilterSettings);
 
    ENGINE_API void RemapFromSkelMesh(USkeletalMesh const & SourceSkeletalMesh, USkeleton& TargetSkeleton);
 
    ENGINE_API void RemapFromSkeleton(USkeleton const & SourceSkeleton);
 
    // Regenerate the serial number after internal data is updated
    ENGINE_API void RegenerateSerialNumber();
};