MovieSceneInitialValueCache.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/ArrayView.h"
#include "Containers/Map.h"
#include "Containers/SparseArray.h"
#include "EntitySystem/MovieSceneEntityIDs.h"
#include "EntitySystem/MovieSceneEntitySystemLinkerExtension.h"
#include "EntitySystem/MovieScenePropertySystemTypes.h"
#include "HAL/Platform.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Optional.h"
#include "Misc/TVariant.h"
#include "MovieSceneCommonHelpers.h"
#include "Templates/SharedPointer.h"
#include "Templates/Tuple.h"
#include "Templates/TypeHash.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectKey.h"
 
class UObject;
 
namespace UE
{
namespace MovieScene
{
 
template<typename PropertyTraits> struct TPropertyValueStorage;
 
struct FInitialValueIndex
{
    uint16 Index;
};
 
struct IPropertyValueStorage
{
    virtual ~IPropertyValueStorage(){}
 
    virtual void Reset(TArrayView<const FInitialValueIndex> Indices) = 0;
};
 
struct FInitialValueCache
{
    MOVIESCENE_API static TEntitySystemLinkerExtensionID<FInitialValueCache> GetExtensionID();
 
 
    MOVIESCENE_API static TSharedPtr<FInitialValueCache> GetGlobalInitialValues();
 
public:
 
    void Reset(FComponentTypeID InitialValueType, TArrayView<const FInitialValueIndex> InitialValueIndices)
    {
        if (TUniquePtr<IPropertyValueStorage>* Storage = StorageByComponent.Find(InitialValueType))
        {
            Storage->Get()->Reset(InitialValueIndices);
        }
    }
 
    template<typename PropertyTraits>
    TPropertyValueStorage<PropertyTraits>* GetStorage(FComponentTypeID InitialValueType)
    {
        if (TPropertyValueStorage<PropertyTraits>* Storage = FindStorage<PropertyTraits>(InitialValueType))
        {
            return Storage;
        }
 
        TPropertyValueStorage<PropertyTraits>* NewStorage = new TPropertyValueStorage<PropertyTraits>();
        StorageByComponent.Add(InitialValueType, TUniquePtr<IPropertyValueStorage>(NewStorage));
        return NewStorage;
    }
 
    template<typename PropertyTraits>
    TPropertyValueStorage<PropertyTraits>* GetStorage(const TPropertyComponents<PropertyTraits>& PropertyComponents)
    {
        return GetStorage<PropertyTraits>(PropertyComponents.InitialValueType);
    }
 
 
    template<typename PropertyTraits>
    TPropertyValueStorage<PropertyTraits>* FindStorage(FComponentTypeID InitialValueType)
    {
        if (TUniquePtr<IPropertyValueStorage>* Existing = StorageByComponent.Find(InitialValueType))
        {
            // If the ptr exists, it cannot be null
            check(Existing->IsValid());
            return static_cast<TPropertyValueStorage<PropertyTraits>*>(Existing->Get());
        }
 
        return nullptr;
    }
 
 
    template<typename PropertyTraits>
    TPropertyValueStorage<PropertyTraits>* FindStorage(const TPropertyComponents<PropertyTraits>& PropertyComponents)
    {
        return FindStorage<PropertyTraits>(PropertyComponents.InitialValue);
    }
 
private:
 
    TMap<FComponentTypeID, TUniquePtr<IPropertyValueStorage>> StorageByComponent;
};
 
template<typename PropertyTraits>
struct TPropertyValueStorage : IPropertyValueStorage
{
    using StorageType = typename PropertyTraits::StorageType;
 
    virtual void Reset(TArrayView<const FInitialValueIndex> Indices) override
    {
        for (FInitialValueIndex Index : Indices)
        {
            if (PropertyValues.IsValidIndex(Index.Index))
            {
                PropertyValues.RemoveAt(Index.Index);
            }
        }
        bLUTContainsInvalidEntries = true;
    }
 
 
    FInitialValueIndex AddInitialValue(UObject* BoundObject, const StorageType& InValue, uint16 ResolvedPropertyOffset)
    {
        FKeyType Key{ FObjectKey(BoundObject), FPropertyKey(TInPlaceType<uint16>(), ResolvedPropertyOffset) };
 
        return AddInitialValue(Key, InValue);
    }
 
 
    FInitialValueIndex AddInitialValue(UObject* BoundObject, const StorageType& InValue, FCustomPropertyIndex AccessorIndex)
    {
        FKeyType Key{ FObjectKey(BoundObject), FPropertyKey(TInPlaceType<FCustomPropertyIndex>(), AccessorIndex) };
 
        return AddInitialValue(Key, InValue);
    }
 
 
    FInitialValueIndex AddInitialValue(UObject* BoundObject, const StorageType& InValue, FTrackInstancePropertyBindings* SlowBindings)
    {
        FKeyType Key{ FObjectKey(BoundObject), FPropertyKey(TInPlaceType<FName>(), SlowBindings->GetPropertyPath())};
 
        return AddInitialValue(Key, InValue);
    }
 
 
    FInitialValueIndex AddInitialValue(UObject* BoundObject, const StorageType& InValue, const FName& PropertyPath)
    {
        FKeyType Key{ FObjectKey(BoundObject), FPropertyKey(TInPlaceType<FName>(), PropertyPath)};
 
        return AddInitialValue(Key, InValue);
    }
 
 
    TOptional<FInitialValueIndex> FindPropertyIndex(UObject* BoundObject, uint16 ResolvedPropertyOffset)
    {
        CleanupStaleEntries();
        return FindPropertyIndex(FKeyType{ FObjectKey(BoundObject), FPropertyKey(TInPlaceType<uint16>(), ResolvedPropertyOffset) });
    }
 
 
    TOptional<FInitialValueIndex> FindPropertyIndex(UObject* BoundObject, FCustomPropertyIndex AccessorIndex)
    {
        CleanupStaleEntries();
        return FindPropertyIndex(FKeyType{ FObjectKey(BoundObject), FPropertyKey(TInPlaceType<FCustomPropertyIndex>(), AccessorIndex) });
    }
 
 
    TOptional<FInitialValueIndex> FindPropertyIndex(UObject* BoundObject, const FName& PropertyPath)
    {
        CleanupStaleEntries();
        return FindPropertyIndex(FKeyType{ FObjectKey(BoundObject), FPropertyKey(TInPlaceType<FName>(), PropertyPath) });
    }
 
 
    const StorageType* FindCachedValue(UObject* BoundObject, uint16 ResolvedPropertyOffset)
    {
        TOptional<FInitialValueIndex> Index = FindPropertyIndex(BoundObject, ResolvedPropertyOffset);
        return Index.IsSet() ? &PropertyValues[Index.GetValue().Index] : nullptr;
    }
 
 
    const StorageType* FindCachedValue(UObject* BoundObject, FCustomPropertyIndex CustomIndex)
    {
        TOptional<FInitialValueIndex> Index = FindPropertyIndex(BoundObject, CustomIndex);
        return Index.IsSet() ? &PropertyValues[Index.GetValue().Index] : nullptr;
    }
 
 
    const StorageType* FindCachedValue(UObject* BoundObject, const FName& PropertyPath)
    {
        TOptional<FInitialValueIndex> Index = FindPropertyIndex(BoundObject, PropertyPath);
        return Index.IsSet() ? &PropertyValues[Index.GetValue().Index] : nullptr;
    }
 
    const StorageType& GetCachedValue(FInitialValueIndex Index)
    {
        return PropertyValues[Index.Index];
    }
 
private:
 
    using FPropertyKey = TVariant<uint16, FCustomPropertyIndex, FName>;
 
    struct FKeyType
    {
        FObjectKey Object;
        FPropertyKey Property;
 
        friend uint32 GetTypeHash(const FKeyType& InKey)
        {
            // Hash only considers the _type_ of the resolved property
            // which defers the final comparison to the equality operator
            uint32 Hash = GetTypeHash(InKey.Object);
            Hash = HashCombine(Hash, static_cast<uint32>(InKey.Property.GetIndex()));
            return Hash;
        }
        friend bool operator==(const FKeyType& A, const FKeyType& B)
        {
            if (A.Object != B.Object || A.Property.GetIndex() != B.Property.GetIndex())
            {
                return false;
            }
            switch (A.Property.GetIndex())
            {
                case 0: return A.Property.template Get<uint16>() == B.Property.template Get<uint16>();
                case 1: return A.Property.template Get<FCustomPropertyIndex>().Value == B.Property.template Get<FCustomPropertyIndex>().Value;
                case 2: return A.Property.template Get<FName>() == B.Property.template Get<FName>();
            }
            return true;
        }
    };
 
    inline void CleanupStaleEntries()
    {
        if (!bLUTContainsInvalidEntries)
        {
            return;
        }
        for (auto It = KeyToPropertyIndex.CreateIterator(); It; ++It)
        {
            if (!PropertyValues.IsValidIndex(It.Value()))
            {
                It.RemoveCurrent();
            }
        }
        PropertyValues.Shrink();
        bLUTContainsInvalidEntries = false;
    }
 
    TOptional<FInitialValueIndex> FindPropertyIndex(const FKeyType& InKey)
    {
        CleanupStaleEntries();
 
        const uint16* Index = KeyToPropertyIndex.Find(InKey);
        return Index ? TOptional<FInitialValueIndex>(FInitialValueIndex{*Index}) : TOptional<FInitialValueIndex>();
    }
 
    FInitialValueIndex AddInitialValue(const FKeyType& InKey, const StorageType& InValue)
    {
        checkSlow(!KeyToPropertyIndex.Contains(InKey));
 
        const int32 NewIndex = PropertyValues.Add(InValue);
        check(NewIndex < int32(uint16(0xFFFF)));
 
        const uint16 NarrowIndex = static_cast<uint16>(NewIndex);
        KeyToPropertyIndex.Add(InKey, NarrowIndex);
 
        return FInitialValueIndex{NarrowIndex};
    }
 
    TSparseArray<StorageType> PropertyValues;
    TMap<FKeyType, uint16> KeyToPropertyIndex;
    bool bLUTContainsInvalidEntries = false;
};
 
 
} // namespace MovieScene
} // namespace UE