PersistentEvaluationData.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Map.h"
#include "CoreMinimal.h"
#include "Evaluation/MovieSceneEvaluationKey.h"
#include "Evaluation/MovieSceneEvaluationOperand.h"
#include "Evaluation/MovieSceneSequenceInstanceData.h"
#include "HAL/Platform.h"
#include "Misc/AssertionMacros.h"
#include "MovieSceneFwd.h"
#include "Stats/Stats.h"
#include "Templates/TypeHash.h"
#include "Templates/UniquePtr.h"
 
class IMovieScenePlayer;
 
struct FMovieSceneSharedDataId
{
    static MOVIESCENE_API FMovieSceneSharedDataId Allocate();
 
    FMovieSceneSharedDataId(const FMovieSceneSharedDataId&) = default;
    FMovieSceneSharedDataId& operator=(const FMovieSceneSharedDataId&) = default;
 
    friend bool operator==(FMovieSceneSharedDataId A, FMovieSceneSharedDataId B) { return A.UniqueId == B.UniqueId; }
 
    friend uint32 GetTypeHash(FMovieSceneSharedDataId In) { return GetTypeHash(In.UniqueId); }
 
private:
    FMovieSceneSharedDataId() {}
    uint32 UniqueId;
};
 
struct FSharedPersistentDataKey
{
    FSharedPersistentDataKey(FMovieSceneSharedDataId InUniqueId, const FMovieSceneEvaluationOperand& InOperand)
        : UniqueId(InUniqueId)
        , Operand(InOperand)
    {}
 
    friend bool operator==(const FSharedPersistentDataKey& A, const FSharedPersistentDataKey& B)
    {
        return A.UniqueId == B.UniqueId && A.Operand == B.Operand;
    }
 
    friend uint32 GetTypeHash(const FSharedPersistentDataKey& In)
    {
        return HashCombine(GetTypeHash(In.Operand), GetTypeHash(In.UniqueId));
    }
 
    FMovieSceneSharedDataId UniqueId;
 
    FMovieSceneEvaluationOperand Operand;
};
 
 
struct IPersistentEvaluationData
{
    virtual ~IPersistentEvaluationData(){}
};
 
 
DECLARE_CYCLE_STAT(TEXT("Persistent Data Access"), MovieSceneEval_PersistentData_Access, STATGROUP_MovieSceneEval);
 
struct FPersistentEvaluationData
{
    MOVIESCENE_API FPersistentEvaluationData(IMovieScenePlayer& InPlayer);
 
    FPersistentEvaluationData(const FPersistentEvaluationData&) = delete;
    FPersistentEvaluationData& operator=(const FPersistentEvaluationData&) = delete;
 
public:
    template<typename T>       T&   GetOrAddTrackData()     { return GetOrAdd<T>(TrackKey); }
    template<typename T>       T&   AddTrackData()          { return Add<T>(TrackKey); }
    template<typename T>       T&   GetTrackData()          { return Get<T>(TrackKey); }
    template<typename T>       T*   FindTrackData()         { return Find<T>(TrackKey); }
    template<typename T>       T&   GetTrackData() const    { return Get<T>(TrackKey); }
    template<typename T>       T*   FindTrackData() const   { return Find<T>(TrackKey); }
    void                            ResetTrackData()        { Reset(TrackKey); }
 
    template<typename T>       T&   GetOrAddSectionData()   { return GetOrAdd<T>(SectionKey); }
    template<typename T>       T&   AddSectionData()        { return Add<T>(SectionKey); }
    template<typename T>       T&   GetSectionData() const  { return Get<T>(SectionKey); }
    template<typename T>       T*   FindSectionData() const { return Find<T>(SectionKey); }
    void                            ResetSectionData()      { Reset(SectionKey); }
 
    MOVIESCENE_API const FMovieSceneSequenceInstanceData* GetInstanceData() const;
 
    IMovieScenePlayer& GetMovieScenePlayer() const { return Player; }
 
    template<typename T> const T*   FindInstanceData() const
    {
        const FMovieSceneSequenceInstanceData* InstanceData = GetInstanceData();
        if (InstanceData && (&InstanceData->GetScriptStruct() == T::StaticStruct()))
        {
            return static_cast<const T*>(InstanceData);
        }
        return nullptr;
    }
 
public:
    
    const FMovieSceneEvaluationKey& GetTrackKey() const
    {
        return TrackKey;
    }
 
    const FMovieSceneEvaluationKey& GetSectionKey() const
    {
        return SectionKey;
    }
 
    void SetTrackKey(const FMovieSceneEvaluationKey& Key) const
    {
        TrackKey = Key;
    }
 
    void SetSectionKey(const FMovieSceneEvaluationKey& Key) const
    {
        SectionKey = Key;
    }
 
    const FMovieSceneEvaluationKey& DeriveSectionKey(uint32 InSectionIdentifier) const
    {
        SectionKey = TrackKey.AsSection(InSectionIdentifier);
        return SectionKey;
    }
 
public:
 
    template<typename T>
    T& GetOrAdd(const FSharedPersistentDataKey& InKey)
    {
        MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER(MovieSceneEval_PersistentData_Access)
 
        check(SharedData);
 
        if (TUniquePtr<IPersistentEvaluationData>* Existing = SharedData->Find(InKey))
        {
            return static_cast<T&>(*Existing->Get());
        }
 
        return Add<T>(InKey);
    }
 
    template<typename T>
    T& Add(const FSharedPersistentDataKey& InKey)
    {
        MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER(MovieSceneEval_PersistentData_Access)
 
        check(SharedData);
 
        T* Ptr = new T;
        SharedData->Add(InKey, TUniquePtr<IPersistentEvaluationData>(Ptr));
        return *Ptr;
    }
 
    template<typename T>
    T* Find(const FSharedPersistentDataKey& InKey)
    {
        MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER(MovieSceneEval_PersistentData_Access)
 
        if (ensure(SharedData))
        {
            TUniquePtr<IPersistentEvaluationData>* Existing = SharedData->Find(InKey);
            return Existing ? static_cast<T*>(Existing->Get()) : nullptr;
        }
        return nullptr;
    }
 
    template<typename T>
    const T* Find(const FSharedPersistentDataKey& InKey) const
    {
        MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER(MovieSceneEval_PersistentData_Access)
 
        if (ensure(SharedData))
        {
            const TUniquePtr<IPersistentEvaluationData>* Existing = SharedData->Find(InKey);
            return Existing ? static_cast<const T*>(Existing->Get()) : nullptr;
        }
        return nullptr;
    }
 
    template<typename T>
    T& Get(const FSharedPersistentDataKey& InKey)
    {
        MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER(MovieSceneEval_PersistentData_Access)
 
        T* Ptr = Find<T>(InKey);
        check(Ptr);
        return *Ptr;
    }
 
    template<typename T>
    const T& Get(const FSharedPersistentDataKey& InKey) const
    {
        MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER(MovieSceneEval_PersistentData_Access)
 
        const T* Ptr = Find<T>(InKey);
        check(Ptr);
        return *Ptr;
    }
 
    void Reset(const FSharedPersistentDataKey& InKey)
    {
        MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER(MovieSceneEval_PersistentData_Access)
        
        if (ensure(SharedData))
        {
            SharedData->Remove(InKey);
        }
    }
 
private:
 
    template<typename T>
    T& GetOrAdd(const FMovieSceneEvaluationKey& InKey)
    {
        MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER(MovieSceneEval_PersistentData_Access)
 
        check(EntityData);
 
        if (TUniquePtr<IPersistentEvaluationData>* Existing = EntityData->Find(InKey))
        {
            return static_cast<T&>(*Existing->Get());
        }
 
        return Add<T>(InKey);
    }
 
    template<typename T>
    T& Add(const FMovieSceneEvaluationKey& InKey)
    {
        MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER(MovieSceneEval_PersistentData_Access)
 
        check(EntityData);
 
        T* Ptr = new T;
        EntityData->Add(InKey, TUniquePtr<IPersistentEvaluationData>(Ptr));
        return *Ptr;
    }
 
    template<typename T>
    T* Find(const FMovieSceneEvaluationKey& InKey) const
    {
        MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER(MovieSceneEval_PersistentData_Access)
 
        if (ensure(EntityData))
        {
            const TUniquePtr<IPersistentEvaluationData>* Existing = EntityData->Find(InKey);
            return Existing ? static_cast<T*>(Existing->Get()) : nullptr;
        }
        return nullptr;
    }
 
    template<typename T>
    T& Get(const FMovieSceneEvaluationKey& InKey) const
    {
        MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER(MovieSceneEval_PersistentData_Access)
 
        T* Ptr = Find<T>(InKey);
        check(Ptr);
        return *Ptr;
    }
 
    void Reset(const FMovieSceneEvaluationKey& InKey)
    {
        MOVIESCENE_DETAILED_SCOPE_CYCLE_COUNTER(MovieSceneEval_PersistentData_Access)
        
        if (ensure(EntityData))
        {
            EntityData->Remove(InKey);
        }
    }
 
private:
    
    IMovieScenePlayer& Player;
 
    TMap<FMovieSceneEvaluationKey, TUniquePtr<IPersistentEvaluationData>>* EntityData;
 
    TMap<FSharedPersistentDataKey, TUniquePtr<IPersistentEvaluationData>>* SharedData;
 
    // The keys themselves are mutable since this a proxy representation of the data above.
    // For a const FPersistentEvaluationData& we can change the ptr to the persistent data, but we can't change the data itself (as with a const T*)
    mutable FMovieSceneEvaluationKey TrackKey;
    mutable FMovieSceneEvaluationKey SectionKey;
};