AnimSingleNodeInstanceProxy.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 "Animation/AnimTypes.h"
#include "Animation/AnimationAsset.h"
#include "Animation/AnimInstanceProxy.h"
#include "Animation/AnimNodeBase.h"
#include "AnimSingleNodeInstanceProxy.generated.h"
 
struct FAnimSingleNodeInstanceProxy;
class UMirrorDataTable;
 
USTRUCT(BlueprintInternalUseOnly)
struct FAnimNode_SingleNode : public FAnimNode_Base
{
    friend struct FAnimSingleNodeInstanceProxy;
 
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Links)
    FPoseLink SourcePose;
 
    // Slot to use if we are evaluating a montage
    FName ActiveMontageSlot;
 
    // FAnimNode_Base interface
    ENGINE_API virtual void Evaluate_AnyThread(FPoseContext& Output) override;
    ENGINE_API virtual void Update_AnyThread(const FAnimationUpdateContext& Context) override;
    // End of FAnimNode_Base interface
 
private:
    FAnimSingleNodeInstanceProxy* Proxy;
};
 
USTRUCT()
struct FAnimSingleNodeInstanceProxy : public FAnimInstanceProxy
{
    friend struct FAnimNode_SingleNode;
 
    GENERATED_BODY()
 
public:
    FAnimSingleNodeInstanceProxy()
    {
#if WITH_EDITOR
        bCanProcessAdditiveAnimations = false;
        bIgnoreRootLock = false;
        bIgnoreRootMotion = false;
#endif
    }
 
    FAnimSingleNodeInstanceProxy(UAnimInstance* InAnimInstance)
        : FAnimInstanceProxy(InAnimInstance)
        , CurrentAsset(nullptr)
        , MirrorDataTable(nullptr)
        , BlendSpacePosition(0.0f, 0.0f, 0.0f)
        , CurrentTime(0.0f)
        , DeltaTimeRecord()
#if WITH_EDITORONLY_DATA
        , PreviewPoseCurrentTime(0.0f)
#endif
        , PlayRate(1.f)
        , bLooping(true)
        , bPlaying(true)
        , bReverse(false)
    {
        SingleNode.Proxy = this;
 
#if WITH_EDITOR
        bCanProcessAdditiveAnimations = false;
        bIgnoreRootLock = false;
        bIgnoreRootMotion = false;
#endif
    }
 
    ENGINE_API virtual ~FAnimSingleNodeInstanceProxy();
 
    ENGINE_API virtual void Initialize(UAnimInstance* InAnimInstance) override;
    ENGINE_API virtual bool Evaluate(FPoseContext& Output) override;
    ENGINE_API virtual void UpdateAnimationNode(const FAnimationUpdateContext& InContext) override;
    ENGINE_API virtual void PostUpdate(UAnimInstance* InAnimInstance) const override;
    ENGINE_API virtual void PreUpdate(UAnimInstance* InAnimInstance, float DeltaSeconds) override;
    ENGINE_API virtual void InitializeObjects(UAnimInstance* InAnimInstance) override;
    ENGINE_API virtual void ClearObjects() override;
 
    void SetPlaying(bool bIsPlaying)
    {
        bPlaying = bIsPlaying;
    }
 
    bool IsPlaying() const
    {
        return bPlaying;
    }
 
    bool IsReverse() const
    {
        return bReverse;
    }
 
    void SetLooping(bool bIsLooping)
    {
        bLooping = bIsLooping;
    }
 
    bool IsLooping() const
    {
        return bLooping;
    }
 
    void ResetWeightInfo()
    {
        WeightInfo.Reset();
    }
 
    ENGINE_API virtual void SetAnimationAsset(UAnimationAsset* NewAsset, USkeletalMeshComponent* MeshComponent, bool bIsLooping, float InPlayRate);
 
    ENGINE_API void UpdateBlendspaceSamples(FVector InBlendInput);
 
    void SetCurrentTime(float InCurrentTime)
    {
        if (InCurrentTime != CurrentTime)
        {
            // If the current time is changed externally then our record of where we are in relation to markers will be
            // out of sync, so reset it and it will be updated when necessary.
            MarkerTickRecord.Reset();
        }
        CurrentTime = InCurrentTime;
    }
 
    float GetCurrentTime() const
    {
        return CurrentTime;
    }
 
    float GetPlayRate() const
    {
        return PlayRate;
    }
 
    void SetPlayRate(float InPlayRate)
    {
        PlayRate = InPlayRate;
    }
 
    FVector GetFilterLastOutput()
    {
        return BlendFilter.GetFilterLastOutput();
    }
 
    ENGINE_API void SetReverse(bool bInReverse);
 
    ENGINE_API void SetBlendSpacePosition(const FVector& InPosition);
 
    ENGINE_API void GetBlendSpaceState(FVector& OutPosition, FVector& OutFilteredPosition) const;
 
    ENGINE_API float GetBlendSpaceLength() const;
 
#if WITH_EDITOR
    bool CanProcessAdditiveAnimations() const
    {
        return bCanProcessAdditiveAnimations;
    }
#endif
 
    ENGINE_API void SetMirrorDataTable(const UMirrorDataTable* InMirrorDataTable);
 
    ENGINE_API const UMirrorDataTable* GetMirrorDataTable();
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void PropagatePreviewCurve(FPoseContext& Output);
#endif // WITH_EDITORONLY_DATA
 
    ENGINE_API void SetPreviewCurveOverride(const FName& PoseName, float Value, bool bRemoveIfZero);
 
    // Update internal weight structures for supplied slot name
    ENGINE_API void UpdateMontageWeightForSlot(const FName CurrentSlotNodeName, float InGlobalNodeWeight);
 
    // Set the montage slot to preview
    ENGINE_API void SetMontagePreviewSlot(FName PreviewSlot);
 
private:
    ENGINE_API void InternalBlendSpaceEvaluatePose(class UBlendSpace* BlendSpace, TArray<FBlendSampleData>& BlendSampleDataCache, FPoseContext& OutContext);
 
protected:
#if WITH_EDITOR
    bool bCanProcessAdditiveAnimations;
 
    bool bIgnoreRootLock;
 
    bool bIgnoreRootMotion;
#endif
 
    TMap<FName, float> PreviewCurveOverride;
 
    UAnimationAsset* CurrentAsset;
 
    const UMirrorDataTable* MirrorDataTable;
    
    FAnimNode_SingleNode SingleNode;
 
private:
    FVector BlendSpacePosition;
 
    TArray<FBlendSampleData> BlendSampleData;
 
    FBlendFilter BlendFilter;
 
    FSlotNodeWeightInfo WeightInfo;
 
    float CurrentTime;
 
    FDeltaTimeRecord DeltaTimeRecord;
 
#if WITH_EDITORONLY_DATA
    float PreviewPoseCurrentTime;
#endif
 
    FMarkerTickRecord MarkerTickRecord;
 
    float PlayRate;
    bool bLooping;
    bool bPlaying;
    bool bReverse;
};