BlendSpace.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 "BoneContainer.h"
#include "Animation/AnimationAsset.h"
#include "AnimationRuntime.h"
#include "AnimNodeBase.h"
#include "Containers/ArrayView.h"
#include "Animation/BoneSocketReference.h"
#include "BlendSpace.generated.h"
 
class UCachedAnalysisProperties;
class UBlendSpace;
 
UCLASS(MinimalAPI, config=Engine)
class UAnalysisProperties : public UObject
{
    GENERATED_BODY()
 
public:
    virtual void InitializeFromCache(TObjectPtr<UCachedAnalysisProperties> Cache) {};
    virtual void MakeCache(TObjectPtr<UCachedAnalysisProperties>& Cache, UBlendSpace* BlendSpace) {};
 
    UPROPERTY()
    FString Function = TEXT("None");
};
 
UENUM()
enum EBlendSpaceAxis : int
{
    BSA_None UMETA(DisplayName = "None"),
    BSA_X UMETA(DisplayName = "Horizontal (X) Axis"),
    BSA_Y UMETA(DisplayName = "Vertical (Y) Axis")
};
 
UENUM()
enum class EPreferredTriangulationDirection : uint8
{
    None UMETA(DisplayName = "None", ToolTip = "None"),
    Tangential UMETA(DisplayName = "Tangential", ToolTip = "When there is ambiguity, rectangles will be split so that the inserted edge tends to not point towards the origin"),
    Radial UMETA(DisplayName = "Radial", ToolTip = "When there is ambiguity, rectangles will be split so that the inserted edge tends to point towards the origin")
};
 
UENUM()
enum class EBlendSpacePerBoneBlendMode : uint8
{
    ManualPerBoneOverride UMETA(DisplayName = "Manual Per Bone Override", ToolTip = "Manually specify the bones and their smoothing interpolation times."),
    BlendProfile UMETA(DisplayName = "Blend Profile", ToolTip = "Use a blend profile to specify the bone smoothing interpolation times.")
};
 
USTRUCT()
struct FBlendSpaceBlendProfile
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, Category = SampleSmoothing, meta = (DisplayName = "Blend Profile", UseAsBlendMask = true, EditConditionHides))
    TObjectPtr<UBlendProfile> BlendProfile;
 
    UPROPERTY(EditAnywhere, Category = SampleSmoothing, meta = (DisplayName = "Weight Speed", ClampMin = "0"))
    float TargetWeightInterpolationSpeedPerSec = 0.0f;
};
 
USTRUCT()
struct FInterpolationParameter
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, DisplayName = "Smoothing Time", Category=Parameter, meta = (ClampMin = "0"))
    float InterpolationTime = 0.f;
 
    UPROPERTY(EditAnywhere, Category=Parameter, meta = (ClampMin = "0", EditCondition = "InterpolationType == EFilterInterpolationType::BSIT_SpringDamper && InterpolationTime > 0"))
    float DampingRatio = 1.f;
 
    UPROPERTY(EditAnywhere, Category=Parameter, meta = (ClampMin = "0"))
    float MaxSpeed = 0.f;
 
    UPROPERTY(EditAnywhere, DisplayName = "Smoothing Type", Category=Parameter, meta = (EditCondition = "InterpolationTime > 0"))
    TEnumAsByte<EFilterInterpolationType> InterpolationType = EFilterInterpolationType::BSIT_SpringDamper;
};
 
USTRUCT()
struct FBlendParameter
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, DisplayName = "Name", Category=BlendParameter)
    FString DisplayName;
 
    UPROPERTY(EditAnywhere, DisplayName = "Minimum Axis Value", Category=BlendParameter, meta=(NoResetToDefault))
    float Min;
 
    UPROPERTY(EditAnywhere, DisplayName = "Maximum Axis Value", Category=BlendParameter, meta=(NoResetToDefault))
    float Max;
 
    UPROPERTY(EditAnywhere, DisplayName = "Grid Divisions", Category=BlendParameter, meta=(UIMin="1", ClampMin="1"))
    int32 GridNum;
 
    UPROPERTY(EditAnywhere, DisplayName = "Snap to Grid", Category = BlendParameter)
    bool bSnapToGrid;
 
    UPROPERTY(EditAnywhere, DisplayName = "Wrap Input", Category = BlendParameter)
    bool bWrapInput;
 
    FBlendParameter()
        : DisplayName(TEXT("None"))
        , Min(0.f)
        , Max(100.f)
        , GridNum(4) // TODO when changing GridNum's default value, it breaks all grid samples ATM - provide way to rebuild grid samples during loading
        , bSnapToGrid(false)
        , bWrapInput(false)
    {
    }
 
    float GetRange() const
    {
        return Max-Min;
    }
    float GetGridSize() const
    {
        return GetRange()/(float)GridNum;
    }
    
};
 
USTRUCT()
struct FBlendSample
{
    GENERATED_BODY()
 
    // For linked animations
    UPROPERTY(EditAnywhere, Category=BlendSample)
    TObjectPtr<class UAnimSequence> Animation;
 
    //blend 0->x, blend 1->y, blend 2->z
 
    UPROPERTY(EditAnywhere, Category=BlendSample)
    FVector SampleValue;
    
    UPROPERTY(EditAnywhere, Category = BlendSample, meta=(UIMin="0.01", UIMax="2.0", ClampMin="0.01", ClampMax="64.0"))
    float RateScale = 1.0f;
    
    UPROPERTY(EditAnywhere, Category = BlendSample, meta=(InlineEditConditionToggle))
    bool bUseSingleFrameForBlending = false;
    
    // Single Frame Blending: If selected, instead of using the entire animation sequence, only the specified single frame is used for sampling the animation
    UPROPERTY(EditAnywhere, Category = BlendSample, meta=(EditCondition="bUseSingleFrameForBlending", DisplayName="Use Single Frame", UIMin="0"))
    uint32 FrameIndexToSample = 0;
 
#if WITH_EDITORONLY_DATA
    // Whether or not this sample will be moved when the "analyse all" button is used. Note that, even if disabled,
    // it will still be available for individual sample analysis/moving
    UPROPERTY(EditAnywhere, Category = BlendSample, meta=(UIMin="0.01", UIMax="2.0", ClampMin="0.01", ClampMax="64.0"))
    uint8 bIncludeInAnalyseAll : 1;
 
    UPROPERTY(transient)
    uint8 bIsValid : 1;
 
    // Cache the samples marker data counter so that we can track if it changes and revalidate the blendspace
    int32 CachedMarkerDataUpdateCounter;
 
#endif // WITH_EDITORONLY_DATA
 
    FBlendSample()
        : Animation(nullptr)
        , SampleValue(0.f)
        , RateScale(1.0f)
#if WITH_EDITORONLY_DATA
        , bIncludeInAnalyseAll(true)
        , bIsValid(false)
        , CachedMarkerDataUpdateCounter(INDEX_NONE)
#endif // WITH_EDITORONLY_DATA
    {       
    }
    
    FBlendSample(class UAnimSequence* InAnim, FVector InValue, bool bInIsSnapped, bool bInIsValid) 
        : Animation(InAnim)
        , SampleValue(InValue)
        , RateScale(1.0f)
#if WITH_EDITORONLY_DATA
        , bIncludeInAnalyseAll(true)
        , bIsValid(bInIsValid)
        , CachedMarkerDataUpdateCounter(INDEX_NONE)
#endif // WITH_EDITORONLY_DATA
    {        
    }
    
    bool operator==( const FBlendSample& Other ) const 
    {
        return (Other.Animation == Animation && Other.SampleValue == SampleValue && Other.bUseSingleFrameForBlending == bUseSingleFrameForBlending && Other.FrameIndexToSample == FrameIndexToSample && FMath::IsNearlyEqual(Other.RateScale, RateScale));
    }
 
    ENGINE_API float GetSamplePlayLength() const;
};
 
USTRUCT()
struct FBlendSpaceSegment
{
    GENERATED_BODY();
 
public:
    // Triangles have three vertices
    static const int32 NUM_VERTICES = 2;
 
    UPROPERTY()
    int32 SampleIndices[NUM_VERTICES] = { INDEX_NONE, INDEX_NONE };
 
    UPROPERTY()
    float Vertices[NUM_VERTICES]  = { 0.f, 0.f };
};
 
USTRUCT()
struct FBlendSpaceTriangleEdgeInfo
{
    GENERATED_BODY();
 
public:
    UPROPERTY()
    FVector2D Normal = FVector2D(0.f);
 
    UPROPERTY()
    int32 NeighbourTriangleIndex = INDEX_NONE;
 
    UPROPERTY()
    int32 AdjacentPerimeterTriangleIndices[2] = { INDEX_NONE, INDEX_NONE };
 
    UPROPERTY()
    int32 AdjacentPerimeterVertexIndices[2]  = { INDEX_NONE, INDEX_NONE };
};
 
USTRUCT()
struct FBlendSpaceTriangle
{
    GENERATED_BODY();
 
public:
    // Triangles have three vertices
    static const int32 NUM_VERTICES = 3;
 
public:
 
    UPROPERTY(EditAnywhere, Category = EditorElement)
    int32 SampleIndices[NUM_VERTICES] = { INDEX_NONE, INDEX_NONE, INDEX_NONE };
 
    UPROPERTY(EditAnywhere, Category = EditorElement)
    FVector2D Vertices[NUM_VERTICES] = { FVector2D(0.f), FVector2D(0.f), FVector2D(0.f) };
    
    UPROPERTY(EditAnywhere, Category = EditorElement)
    FBlendSpaceTriangleEdgeInfo EdgeInfo[NUM_VERTICES];
};
 
USTRUCT()
struct FWeightedBlendSample
{
    GENERATED_BODY();
 
public:
    FWeightedBlendSample(int32 Index = INDEX_NONE, float Weight = 0) : SampleIndex(Index), SampleWeight(Weight) {}
 
public:
    UPROPERTY()
    int32 SampleIndex;
 
    UPROPERTY()
    float SampleWeight;
};
 
USTRUCT()
struct FBlendSpaceData
{
    GENERATED_BODY();
public:
    void GetSamples(
        TArray<FWeightedBlendSample>& OutWeightedSamples,
        const TArray<int32>&          InDimensionIndices,
        const FVector&                InSamplePosition,
        int32&                        InOutTriangulationIndex) const;
 
    void Empty()
    {
        Segments.Empty();
        Triangles.Empty();
    }
 
    bool IsEmpty() const 
    {
        return Segments.Num() == 0 && Triangles.Num() == 0;
    }
public:
    UPROPERTY()
    TArray<FBlendSpaceSegment> Segments;
 
    UPROPERTY()
    TArray<FBlendSpaceTriangle> Triangles;
 
private:
    void GetSamples1D(
        TArray<FWeightedBlendSample>& OutWeightedSamples,
        const TArray<int32>&          InDimensionIndices,
        const FVector&                InSamplePosition,
        int32&                        InOutSegmentIndex) const;
 
    void GetSamples2D(
        TArray<FWeightedBlendSample>& OutWeightedSamples,
        const TArray<int32>&          InDimensionIndices,
        const FVector&                InSamplePosition,
        int32&                        InOutTriangleIndex) const;
};
 
USTRUCT()
struct FEditorElement
{
    GENERATED_BODY()
 
    // for now we only support triangles
    static const int32 MAX_VERTICES = 3;
 
    UPROPERTY(EditAnywhere, Category=EditorElement)
    int32 Indices[MAX_VERTICES];
 
    UPROPERTY(EditAnywhere, Category=EditorElement)
    float Weights[MAX_VERTICES];
 
    FEditorElement()
    {
        for (int32 ElementIndex = 0; ElementIndex < MAX_VERTICES; ElementIndex++)
        {
            Indices[ElementIndex] = INDEX_NONE;
            Weights[ElementIndex] = 0;
        }
    }
    
};
 
USTRUCT()
struct FGridBlendSample
{
    GENERATED_BODY()
 
    UPROPERTY()
    struct FEditorElement GridElement;
 
    UPROPERTY()
    float BlendWeight;
 
    FGridBlendSample()
        : BlendWeight(0)
    {
    }
 
};
 
USTRUCT()
struct FPerBoneInterpolation
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, Category=FPerBoneInterpolation)
    FBoneReference BoneReference;
 
    UPROPERTY(EditAnywhere, Category=FPerBoneInterpolation, meta=(DisplayName="Weight Speed"))
    float InterpolationSpeedPerSec;
 
    FPerBoneInterpolation()
        : InterpolationSpeedPerSec(6.f)
    {}
 
    void Initialize(const USkeleton* Skeleton)
    {
        BoneReference.Initialize(Skeleton);
    }
};
 
UENUM()
namespace ENotifyTriggerMode
{
    enum Type : int
    {
        AllAnimations UMETA(DisplayName="All Animations"),
        HighestWeightedAnimation UMETA(DisplayName="Highest Weighted Animation"),
        None,
    };
}
 
UCLASS(config=Engine, hidecategories=Object, MinimalAPI, BlueprintType)
class UBlendSpace : public UAnimationAsset, public IInterpolationIndexProvider
{
    GENERATED_UCLASS_BODY()
public:
 
    friend class FBlendSpaceDetails;
    friend class FBlendSampleDetails;
    friend class UAnimGraphNode_BlendSpaceGraphBase;
    friend class SBlendSpaceGridWidget;
 
    //~ Begin UObject Interface
    virtual void PostLoad() override;
    virtual void Serialize(FArchive& Ar) override;
#if WITH_EDITOR
    virtual void PreEditChange(FProperty* PropertyAboutToChange) override;
    virtual void PostEditChangeProperty( struct FPropertyChangedEvent& PropertyChangedEvent) override;
#endif // WITH_EDITOR
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    //~ End UObject Interface
 
    //~ Begin UAnimationAsset Interface
    virtual void TickAssetPlayer(FAnimTickRecord& Instance, struct FAnimNotifyQueue& NotifyQueue, FAnimAssetTickContext& Context) const override;
    // this is used in editor only when used for transition getter
    // this doesn't mean max time. In Sequence, this is SequenceLength,
    // but for BlendSpace CurrentTime is normalized [0,1], so this is 1
    virtual float GetPlayLength() const override { return 1.f; }
    virtual TArray<FName>* GetUniqueMarkerNames() override;
    virtual bool IsValidAdditive() const override;
#if WITH_EDITOR
    virtual bool GetAllAnimationSequencesReferred(TArray<UAnimationAsset*>& AnimationAssets, bool bRecursive = true) override;
    virtual void ReplaceReferredAnimations(const TMap<UAnimationAsset*, UAnimationAsset*>& ReplacementMap) override;
    virtual int32 GetMarkerUpdateCounter() const;
    void    RuntimeValidateMarkerData();
#endif
    //~ End UAnimationAsset Interface
    
    // Begin IInterpolationIndexProvider Overrides
 
    virtual TSharedPtr<IInterpolationIndexProvider::FPerBoneInterpolationData> GetPerBoneInterpolationData(const USkeleton* Skeleton) const override;
 
    virtual int32 GetPerBoneInterpolationIndex(const FCompactPoseBoneIndex& InCompactPoseBoneIndex, const FBoneContainer& RequiredBones, const IInterpolationIndexProvider::FPerBoneInterpolationData* Data) const override;
 
    virtual int32 GetPerBoneInterpolationIndex(const FSkeletonPoseBoneIndex InSkeletonBoneIndex, const USkeleton* TargetSkeleton, const IInterpolationIndexProvider::FPerBoneInterpolationData* Data) const override;
    // End IInterpolationIndexProvider Overrides
 
    ENGINE_API virtual bool IsValidAdditiveType(EAdditiveAnimationType AdditiveType) const;
 
    UE_DEPRECATED(4.26, "Use GetAnimationPose with other signature")
    ENGINE_API void GetAnimationPose(TArray<FBlendSampleData>& BlendSampleDataCache, /*out*/ FCompactPose& OutPose, /*out*/ FBlendedCurve& OutCurve) const;
    
    UE_DEPRECATED(5.0, "Use GetAnimationPose with extraction context signature")
    ENGINE_API void GetAnimationPose(TArray<FBlendSampleData>& BlendSampleDataCache, /*out*/ FAnimationPoseData& OutAnimationPoseData) const;
 
    UE_DEPRECATED(5.0, "Use GetAnimationPose with extraction context signature")
    ENGINE_API void GetAnimationPose(TArray<FBlendSampleData>& BlendSampleDataCache, TArrayView<FPoseLink> InPoseLinks, /*out*/ FPoseContext& Output) const;
 
    ENGINE_API void GetAnimationPose(TArray<FBlendSampleData>& BlendSampleDataCache, const FAnimExtractContext& ExtractionContext, /*out*/ FAnimationPoseData& OutAnimationPoseData) const;
 
    ENGINE_API void GetAnimationPose(TArray<FBlendSampleData>& BlendSampleDataCache, TArrayView<FPoseLink> InPoseLinks, const FAnimExtractContext& ExtractionContext, /*out*/ FPoseContext& Output) const;
 
    ENGINE_API const FBlendParameter& GetBlendParameter(const int32 Index) const;
 
    const TArray<struct FBlendSample>& GetBlendSamples() const { return SampleData; }
 
    ENGINE_API const struct FBlendSample& GetBlendSample(const int32 SampleIndex) const;
 
    ENGINE_API bool GetSamplesFromBlendInput(const FVector &BlendInput, TArray<FBlendSampleData> & OutSampleDataList, int32& InOutCachedTriangulationIndex, bool bCombineAnimations) const;
 
    ENGINE_API float GetAnimationLengthFromSampleData(const TArray<FBlendSampleData>& SampleDataList) const;
 
    ENGINE_API void InitializeFilter(FBlendFilter* Filter, int NumDimensions = 2) const;
 
    ENGINE_API void UpdateFilterParams(FBlendFilter* Filter) const;
 
    ENGINE_API FVector GetClampedAndWrappedBlendInput(const FVector& BlendInput) const;
 
    ENGINE_API bool UpdateBlendSamples(const FVector& InBlendSpacePosition, float InDeltaTime, TArray<FBlendSampleData>& InOutSampleDataCache, int32& InOutCachedTriangulationIndex) const;
    
    ENGINE_API void ResetBlendSamples(TArray<FBlendSampleData>& InOutSampleDataCache, float InNormalizedCurrentTime, bool bLooping, bool bMatchSyncPhases = true) const;
 
    ENGINE_API void ForEachImmutableSample(const TFunctionRef<void(const FBlendSample&)> Func) const;
    
    ENGINE_API FVector FilterInput(FBlendFilter* Filter, const FVector& BlendInput, float DeltaTime) const;
 
    ENGINE_API float ComputeAxisScaleFactor(const FVector& BlendSpacePosition, const FVector& FilteredBlendInput) const;
 
#if WITH_EDITOR 
    ENGINE_API static void UpdateBlendSpacesUsingAnimSequence(UAnimSequenceBase* Sequence);
 
    ENGINE_API void ValidateSampleData();
 
    ENGINE_API int32 AddSample(const FVector& SampleValue);
    ENGINE_API int32 AddSample(UAnimSequence* AnimationSequence, const FVector& SampleValue);
 
    ENGINE_API void ExpandRangeForSample(const FVector& SampleValue);
    
    ENGINE_API bool EditSampleValue(const int32 BlendSampleIndex, const FVector& NewValue);
 
    UE_DEPRECATED(5.0, "Please use ReplaceSampleAnimation instead")
    ENGINE_API bool UpdateSampleAnimation(UAnimSequence* AnimationSequence, const FVector& SampleValue);
 
    ENGINE_API bool ReplaceSampleAnimation(const int32 BlendSampleIndex, UAnimSequence* AnimationSequence);
 
    ENGINE_API bool DeleteSample(const int32 BlendSampleIndex);
    
    int32 GetNumberOfBlendSamples()  const { return SampleData.Num(); }
 
    ENGINE_API bool IsValidBlendSampleIndex(const int32 SampleIndex) const;
 
    ENGINE_API const TArray<FEditorElement>& GetGridSamples() const;
 
    ENGINE_API FVector GetGridPosition(int32 GridIndex) const;
 
    ENGINE_API FVector GetGridPosition(int32 GridX, int32 GridY) const;
 
    ENGINE_API const FBlendSpaceData& GetBlendSpaceData() const;
 
    ENGINE_API void ResampleData();
 
    ENGINE_API void SetBlendSpaceData(const TArray<FBlendSpaceSegment>& Segments);
 
    ENGINE_API bool ValidateAnimationSequence(const UAnimSequence* AnimationSequence) const;
 
    ENGINE_API bool DoesAnimationMatchExistingSamples(const UAnimSequence* AnimationSequence) const;
    
    ENGINE_API bool ShouldAnimationBeAdditive() const;
 
    ENGINE_API bool IsAnimationCompatibleWithSkeleton(const UAnimSequence* AnimationSequence) const;
 
    ENGINE_API bool IsAnimationCompatible(const UAnimSequence* AnimationSequence) const;
 
    ENGINE_API bool ValidateSampleValue(const FVector& SampleValue, int32 OriginalIndex = INDEX_NONE) const;
 
    ENGINE_API bool IsSampleWithinBounds(const FVector &SampleValue) const;
 
    ENGINE_API bool IsTooCloseToExistingSamplePoint(const FVector& SampleValue, int32 OriginalIndex) const;
#endif
 
protected:
    void GetRawSamplesFromBlendInput(const FVector& BlendInput, TArray<FGridBlendSample, TInlineAllocator<4> >& OutBlendSamples) const;
 
    virtual EBlendSpaceAxis GetAxisToScale() const { return AxisToScaleAnimation; }
 
    void InitializePerBoneBlend();
 
    void TickFollowerSamples(
        TArray<FBlendSampleData> &SampleDataList, const int32 HighestWeightIndex, FAnimAssetTickContext &Context, 
        bool bResetMarkerDataOnFollowers, bool bLooping, const UMirrorDataTable* MirrorDataTable = nullptr) const;
 
    FVector GetClampedBlendInput(const FVector& BlendInput) const;
    
    FVector ConvertBlendInputToGridSpace(const FVector& BlendInput) const;
 
    FVector GetNormalizedBlendInput(const FVector& BlendInput) const;
 
    const FEditorElement* GetGridSampleInternal(int32 Index) const;
    
    bool InterpolateWeightOfSampleData(float DeltaTime, const TArray<FBlendSampleData> & OldSampleDataList, const TArray<FBlendSampleData> & NewSampleDataList, TArray<FBlendSampleData> & FinalSampleDataList) const;
 
    bool ContainsMatchingSamples(EAdditiveAnimationType AdditiveType) const;
 
    bool IsSameSamplePoint(const FVector& SamplePointA, const FVector& SamplePointB) const; 
 
#if WITH_EDITOR
    bool ContainsNonAdditiveSamples() const;
    void UpdatePreviewBasePose();
    virtual void SnapSamplesToClosestGridPoint();
#endif // WITH_EDITOR
 
    ENGINE_API static bool IsSingleFrameBlendingIndexInBounds(const FBlendSample& BlendSample);
private:
    // Internal helper function for GetAnimationPose variants
    void GetAnimationPose_Internal(TArray<FBlendSampleData>& BlendSampleDataCache, TArrayView<FPoseLink> InPoseLinks, FAnimInstanceProxy* InProxy, bool bInExpectsAdditivePose, const FAnimExtractContext& ExtractionContext, /*out*/ FAnimationPoseData& OutAnimationPoseData) const;
 
    // Internal helper function for UpdateBlendSamples and TickAssetPlayer
    bool UpdateBlendSamples_Internal(const FVector& InBlendSpacePosition, float InDeltaTime, TArray<FBlendSampleData>& InOutOldSampleDataList, TArray<FBlendSampleData>& InOutSampleDataCache, int32& InOutCachedTriangulationIndex) const; 
 
public:
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.1, "This property is deprecated. Please use/see bContainsRotationOffsetMeshSpaceSamples instead")
    bool bRotationBlendInMeshSpace_DEPRECATED;
#endif
 
    UPROPERTY()
    bool bContainsRotationOffsetMeshSpaceSamples;
 
    UPROPERTY(EditAnywhere, Category = InputInterpolation)
    FInterpolationParameter InterpolationParam[3];
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category = AnalysisProperties)
    TObjectPtr<UAnalysisProperties> AnalysisProperties[3];
 
    TObjectPtr<UCachedAnalysisProperties> CachedAnalysisProperties[3];
#endif
 
    UPROPERTY(EditAnywhere, Category = SampleSmoothing, meta = (DisplayName = "Weight Speed", ClampMin = "0"))
    float TargetWeightInterpolationSpeedPerSec = 0.0f;
 
    UPROPERTY(EditAnywhere, Category = SampleSmoothing, meta = (DisplayName = "Smoothing"))
    bool bTargetWeightInterpolationEaseInOut = true;
 
    UPROPERTY(EditAnywhere, Category = SampleSmoothing)
    bool bAllowMeshSpaceBlending = false;
 
    UPROPERTY(EditAnywhere, Category=Animation)
    bool bLoop = true;
 
    UPROPERTY(EditAnywhere, Category = Animation)
    bool bAllowMarkerBasedSync = true;
 
    UPROPERTY(EditAnywhere, Category = Animation)
    bool bShouldMatchSyncPhases = false;
    
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category = AdditiveSettings)
    TObjectPtr<UAnimSequence> PreviewBasePose;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    float AnimLength;
 
    UPROPERTY(EditAnywhere, Category = AnimationNotifies)
    TEnumAsByte<ENotifyTriggerMode::Type> NotifyTriggerMode;
 
    UPROPERTY(EditAnywhere, Category = InputInterpolation, meta = (DisplayName="Use Grid"))
    bool bInterpolateUsingGrid = false;
 
    UPROPERTY(EditAnywhere, Category = InputInterpolation)
    EPreferredTriangulationDirection PreferredTriangulationDirection = EPreferredTriangulationDirection::Tangential;
 
protected:
 
    UPROPERTY(EditAnywhere, Category = SampleSmoothing)
    EBlendSpacePerBoneBlendMode PerBoneBlendMode = EBlendSpacePerBoneBlendMode::ManualPerBoneOverride;
 
    UPROPERTY(EditAnywhere, Category = SampleSmoothing, meta = (DisplayName="Per Bone Overrides", EditCondition = "PerBoneBlendMode == EBlendSpacePerBoneBlendMode::ManualPerBoneOverride", EditConditionHides))
    TArray<FPerBoneInterpolation> ManualPerBoneOverrides;
 
    UPROPERTY(EditAnywhere, Category = SampleSmoothing, meta = (DisplayName = "Per Bone Overrides", EditCondition = "PerBoneBlendMode == EBlendSpacePerBoneBlendMode::BlendProfile", EditConditionHides))
    FBlendSpaceBlendProfile PerBoneBlendProfile;
 
    TArray<FPerBoneInterpolation> PerBoneBlendValues;
 
    UPROPERTY()
    int32 SampleIndexWithMarkers = INDEX_NONE;
 
    UPROPERTY(EditAnywhere, Category=BlendSamples)
    TArray<struct FBlendSample> SampleData;
 
    UPROPERTY()
    TArray<struct FEditorElement> GridSamples;
 
    UPROPERTY()
    FBlendSpaceData BlendSpaceData;
    
    UPROPERTY(EditAnywhere, Category = BlendParametersTest)
    struct FBlendParameter BlendParameters[3];
 
    UPROPERTY(EditAnywhere, Category = InputInterpolation)
    TEnumAsByte<EBlendSpaceAxis> AxisToScaleAnimation;
 
    void ResetToRefPose(FCompactPose& OutPose) const;
 
    UPROPERTY()
    TArray<int32> DimensionIndices;
 
#if WITH_EDITOR
private:
    // Track whether we have updated markers so cached data can be updated
    int32 MarkerDataUpdateCounter;
protected:
    FVector PreviousAxisMinMaxValues[3];
    float   PreviousGridSpacings[3];
#endif  
 
private:
 
    void GetRawSamplesFromBlendInput1D(const FVector& BlendInput, TArray<FGridBlendSample, TInlineAllocator<4> >& OutBlendSamples) const;
 
    void GetRawSamplesFromBlendInput2D(const FVector& BlendInput, TArray<FGridBlendSample, TInlineAllocator<4> >& OutBlendSamples) const;
 
    void FillupGridElements(const TArray<FEditorElement>& GridElements, const TArray<int32>& InDimensionIndices);
 
    void EmptyGridElements();
 
    void ClearBlendSpaceData();
 
    void SetBlendSpaceData(const TArray<FBlendSpaceTriangle>& Triangles);
 
    void ResampleData1D();
    void ResampleData2D();
 
 
    const FEditorElement* GetEditorElement(int32 XIndex, int32 YIndex) const;
};