AnimNotifyQueue.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Math/RandomStream.h"
#include "Animation/AnimTypes.h"
#include "Animation/AnimNodeMessages.h"
#include "AnimNotifyQueue.generated.h"
 
#define UE_API ENGINE_API
 
class USkeletalMeshComponent;
struct FAnimInstanceProxy;
struct FAnimNotifyEvent;
class UMirrorDataTable;
struct FAnimTickRecord;
class UWorld;
 
USTRUCT(BlueprintType)
struct FAnimNotifyEventReference
{
    GENERATED_BODY()
 
    FAnimNotifyEventReference() = default;
 
    FAnimNotifyEventReference(const FAnimNotifyEvent* InNotify, const UObject* InNotifySource)
        : Notify(InNotify)
        , MirrorTable(nullptr)
        , NotifySource(InNotifySource)
    {}
 
    FAnimNotifyEventReference(const FAnimNotifyEvent* InNotify, const UObject* InNotifySource, const UMirrorDataTable* MirrorDataTable)
    : Notify(InNotify)
    , MirrorTable(MirrorDataTable)
    , NotifySource(InNotifySource)
    {}
 
 
    const FAnimNotifyEvent* GetNotify() const
    {
        return NotifySource ? Notify : nullptr;
    }
 
    void SetNotify(const FAnimNotifyEvent* InNotify)
    {
        if (NotifySource)
        {
            Notify = InNotify;
        }
    }
 
    const UMirrorDataTable* GetMirrorDataTable() const
    {
        return MirrorTable.Get();
    }
    
    friend bool operator==(const FAnimNotifyEventReference& Lhs, const FAnimNotifyEventReference& Rhs)
    {
        return(
            (Lhs.Notify == Rhs.Notify) ||
            (Lhs.Notify && Rhs.Notify && *Lhs.Notify == *Rhs.Notify)
        );
    }
 
    friend bool operator==(const FAnimNotifyEventReference& Lhs, const FAnimNotifyEvent& Rhs);
    
    template<typename Type> 
    const Type* GetContextData() const 
    {
        if(ContextData.IsValid())
        {
            for(const TUniquePtr<const UE::Anim::IAnimNotifyEventContextDataInterface>& DataInterface : *ContextData)
            {
                if (DataInterface->Is<Type>())
                {
                    return &(DataInterface->As<Type>()); 
                }
            }
        }
        return nullptr; 
    }
 
    // Pulls relevant data from the tick record
    UE_API void GatherTickRecordData(const FAnimTickRecord& InTickRecord);
 
    // Allows adding extra context data after GatherTickRecordData has been exectuted
    template<typename Type, typename... TArgs>
    void AddContextData(TArgs&&... Args)
    {
        static_assert(TPointerIsConvertibleFromTo<Type, const UE::Anim::IAnimNotifyEventContextDataInterface>::Value, "'Type' template parameter to MakeContextData must be derived from IAnimNotifyEventContextDataInterface");
        if (!ContextData.IsValid())
        {
            ContextData = MakeShared<TArray<TUniquePtr<const UE::Anim::IAnimNotifyEventContextDataInterface>>>();
        }
 
        ContextData->Add(MakeUnique<Type>(Forward<TArgs>(Args)...));
    }
 
    // Gets the source object of this notify (e.g. anim sequence), if any
    const UObject* GetSourceObject() const
    {
        return NotifySource;
    }
 
    // Gets the current animation's time that this notify was fired at
    float GetCurrentAnimationTime() const
    {
        return CurrentAnimTime;
    }
 
    // Whether the context this notify was fired from is active or not (active == not blending out).
    bool IsActiveContext() const
    {
        return bActiveContext;
    }
 
private:
    // Context data gleaned from the tick record
    TSharedPtr<TArray<TUniquePtr<const UE::Anim::IAnimNotifyEventContextDataInterface>>> ContextData;
    
    const FAnimNotifyEvent* Notify = nullptr;
 
    // If set, the Notify has been mirrored.  The mirrored name can be found in MirrorTable->AnimNotifyToMirrorAnimNotifyMap
    UPROPERTY(transient)
    TObjectPtr<const UMirrorDataTable> MirrorTable = nullptr; 
 
    UPROPERTY(transient)
    TObjectPtr<const UObject> NotifySource = nullptr;
 
    // The recorded time from the tick record that this notify event was fired at
    float CurrentAnimTime = 0.0f;
 
    // Whether the context this notify was fired from is active or not (active == not blending out).
    bool bActiveContext = false;
};
 
USTRUCT()
struct FAnimNotifyArray
{
    GENERATED_BODY()
 
    UPROPERTY(transient)
    TArray<FAnimNotifyEventReference> Notifies;
};
 
USTRUCT()
struct FAnimNotifyContext
{
    GENERATED_BODY()
    FAnimNotifyContext() {}
    FAnimNotifyContext(const FAnimTickRecord& InTickRecord)
    : TickRecord(&InTickRecord)
    {}
    const FAnimTickRecord* TickRecord = nullptr;
    TArray<FAnimNotifyEventReference> ActiveNotifies;
};
 
USTRUCT()
struct FAnimNotifyQueue
{
    GENERATED_BODY()
 
    FAnimNotifyQueue()
        : PredictedLODLevel(-1)
    {
        RandomStream.Initialize(0x05629063);
    }
 
    bool PassesFiltering(const FAnimNotifyEvent* Notify) const;
 
    bool PassesChanceOfTriggering(const FAnimNotifyEvent* Event) const;
 
    void AddAnimNotify(const FAnimNotifyEvent* Notify, const UObject* NotifySource);
 
    UE_API void AddAnimNotifies(bool bSrcIsLeader, const TArray<FAnimNotifyEventReference>& NewNotifies, const float InstanceWeight);
 
    void AddAnimNotifies(bool bSrcIsLeader, const TMap<FName, TArray<FAnimNotifyEventReference>>& NewNotifies, const float InstanceWeight);
 
    void AddAnimNotifies(const TArray<FAnimNotifyEventReference>& NewNotifies, const float InstanceWeight) { AddAnimNotifies(true, NewNotifies, InstanceWeight); }
    void AddAnimNotifies(const TMap<FName, TArray<FAnimNotifyEventReference>>& NewNotifies, const float InstanceWeight) { AddAnimNotifies(true, NewNotifies, InstanceWeight); }
 
    void Reset(USkeletalMeshComponent* Component);
 
    void Append(const FAnimNotifyQueue& Queue);
    
    int32 PredictedLODLevel;
 
    FRandomStream RandomStream;
 
    UPROPERTY(transient)
    TArray<FAnimNotifyEventReference> AnimNotifies;
 
    UPROPERTY(transient)
    TMap<FName, FAnimNotifyArray> UnfilteredMontageAnimNotifies;
 
    void ApplyMontageNotifies(const FAnimInstanceProxy& Proxy);
private:
    void AddAnimNotifiesToDest(bool bSrcIsLeader, const TArray<FAnimNotifyEventReference>& NewNotifies, TArray<FAnimNotifyEventReference>& DestArray, const float InstanceWeight);
 
    void AddAnimNotifiesToDestNoFiltering(const TArray<FAnimNotifyEventReference>& NewNotifies, TArray<FAnimNotifyEventReference>& DestArray) const;
 
    UPROPERTY(Transient)
    TWeakObjectPtr<UWorld> World;
};
 
#undef UE_API