MovieScenePropertyInstantiator.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "EntitySystem/BuiltInComponentTypes.h"
#include "EntitySystem/EntityAllocationIterator.h"
#include "EntitySystem/MovieSceneDecompositionQuery.h"
#include "EntitySystem/MovieSceneEntityIDs.h"
#include "EntitySystem/MovieSceneEntityInstantiatorSystem.h"
#include "EntitySystem/MovieSceneEntitySystem.h"
#include "EntitySystem/MovieScenePropertyComponentHandler.h"
#include "EntitySystem/MovieScenePropertyRegistry.h"
 
#include "Misc/TVariant.h"
#include "Misc/Optional.h"
#include "Containers/BitArray.h"
#include "Containers/Map.h"
#include "Containers/SortedMap.h"
 
#include "MovieScenePropertyInstantiator.generated.h"
 
namespace UE
{
namespace MovieScene
{
 
struct FPropertyStats;
struct FPropertyDefinition;
class FEntityManager;
 
} // namespace MovieScene
} // namespace UE
 
class UMovieSceneBlenderSystem;
 
UCLASS(MinimalAPI)
class UMovieScenePropertyInstantiatorSystem
    : public UMovieSceneEntityInstantiatorSystem
{
public:
 
    using FMovieSceneEntityID = UE::MovieScene::FMovieSceneEntityID;
 
    GENERATED_BODY()
 
    MOVIESCENETRACKS_API UMovieScenePropertyInstantiatorSystem(const FObjectInitializer& ObjInit);
 
    MOVIESCENETRACKS_API UE::MovieScene::FPropertyStats GetStatsForProperty(UE::MovieScene::FCompositePropertyTypeID PropertyID) const;
 
    template<typename PropertyTraits, typename ValueType>
    UE::MovieScene::TRecompositionResult<ValueType> RecomposeBlend(const UE::MovieScene::TPropertyComponents<PropertyTraits>& InComponents, const UE::MovieScene::FDecompositionQuery& InQuery, const ValueType& InCurrentValue)
    {
        using namespace UE::MovieScene;
 
        using StorageType = typename PropertyTraits::StorageType;
 
        StorageType TmpStorage{};
        ConvertOperationalProperty(InCurrentValue, TmpStorage);
 
        UE::MovieScene::TRecompositionResult<StorageType> Result = RecomposeBlendOperational(InComponents, InQuery, TmpStorage);
 
        UE::MovieScene::TRecompositionResult<ValueType> ConversionResult(InCurrentValue, Result.Values.Num());
        for (int32 Index = 0; Index < Result.Values.Num(); ++Index)
        {
            ConvertOperationalProperty(Result.Values[Index], ConversionResult.Values[Index]);
        }
        return ConversionResult;
    }
 
 
    template<typename PropertyTraits>
    UE::MovieScene::TRecompositionResult<typename PropertyTraits::StorageType> RecomposeBlendOperational(const UE::MovieScene::TPropertyComponents<PropertyTraits>& InComponents, const UE::MovieScene::FDecompositionQuery& InQuery, const typename PropertyTraits::StorageType& InCurrentValue);
 
    MOVIESCENETRACKS_API UE::MovieScene::FPropertyRecomposerPropertyInfo FindPropertyFromSource(FMovieSceneEntityID EntityID, UObject* Object) const;
 
private:
 
    MOVIESCENETRACKS_API virtual void OnRun(FSystemTaskPrerequisites& InPrerequisites, FSystemSubsequentTasks& Subsequents) override;
    MOVIESCENETRACKS_API virtual void OnLink() override;
    MOVIESCENETRACKS_API virtual void OnUnlink() override;
    MOVIESCENETRACKS_API virtual void OnCleanTaggedGarbage() override;
 
private:
 
    void OnObjectsReplaced(const TMap<UObject*, UObject*>& ReplacementMap);
 
private:
 
    using FChannelMask     = TBitArray<TFixedAllocator< 1 >>;
    using FSlowPropertyPtr = TSharedPtr<FTrackInstancePropertyBindings>;
 
    struct FContributorKey
    {
        FContributorKey(int32 InPropertyIndex)
            : PropertyIndex(InPropertyIndex)
        {}
 
        int32 PropertyIndex;
 
        friend uint32 GetTypeHash(FContributorKey In)
        {
            return GetTypeHash(In.PropertyIndex);
        }
 
        friend bool operator==(FContributorKey A, FContributorKey B)
        {
            return A.PropertyIndex == B.PropertyIndex;
        }
    };
 
    struct FObjectPropertyInfo
    {
        FObjectPropertyInfo(UE::MovieScene::FResolvedProperty&& InProperty)
            : Property(MoveTemp(InProperty))
            , BoundObject(nullptr)
            , BlendChannel(FMovieSceneBlendChannelID::INVALID_BLEND_CHANNEL)
            , bWantsRestoreState( false)
            , bSupportsFastPath( true)
            , bNeedsInitialValue( false)
            , bMaxHBiasHasChanged(false)
            , bIsPartiallyAnimated(false)
        {}
 
        UE::MovieScene::FResolvedProperty Property;
        TWeakObjectPtr<UMovieSceneBlenderSystem> Blender;
        UObject* BoundObject;
        FMovieScenePropertyBinding PropertyBinding;
        FChannelMask EmptyChannels;
        UE::MovieScene::FMovieSceneEntityID FinalBlendOutputID;
        UE::MovieScene::FMovieSceneEntityID PreviousFastPathID;
        uint16 BlendChannel;
        int32 PropertyDefinitionIndex;
        TOptional<int32> ConvertedFromPropertyDefinitionIndex;
        int16 HBias = 0;
        uint8 bWantsRestoreState : 1;
        uint8 bSupportsFastPath : 1;
        uint8 bNeedsInitialValue : 1;
        uint8 bMaxHBiasHasChanged : 1;
        uint8 bIsPartiallyAnimated : 1;
    };
 
private:
 
    struct FBlenderSystemInfo
    {
        UClass* BlenderSystemClass = nullptr;
        UE::MovieScene::FComponentTypeID BlenderTypeTag;
    };
 
    struct FSetupBlenderSystemResult
    {
        FBlenderSystemInfo CurrentInfo;
        FBlenderSystemInfo PreviousInfo;
    };
 
    /* Parameter structure passed around when instantiating a specific instance of a property */
    struct FPropertyParameters
    {
        FObjectPropertyInfo* PropertyInfo;
        const UE::MovieScene::FPropertyDefinition* PropertyDefinition;
        int32 PropertyInfoIndex;
 
        FContributorKey MakeContributorKey() const;
 
        void MakeOutputComponentType(
            const UE::MovieScene::FEntityManager& EntityManager,
            TArrayView<const UE::MovieScene::FPropertyCompositeDefinition> Composites,
            UE::MovieScene::FComponentMask& OutComponentType) const;
    };
 
    void DiscoverInvalidatedProperties(TBitArray<>& OutInvalidatedProperties);
    void DiscoverExpiredProperties(TBitArray<>& OutInvalidatedProperties);
    void DiscoverNewProperties(TBitArray<>& OutInvalidatedProperties);
    void UpgradeFloatToDoubleProperties(const TBitArray<>& InvalidatedProperties);
    void ProcessInvalidatedProperties(const TBitArray<>& InvalidatedProperties);
    void UpdatePropertyInfo(const FPropertyParameters& Params);
    void InitializeFastPath(const FPropertyParameters& Params);
    void InitializeBlendPath(const FPropertyParameters& Params);
 
    void DestroyStaleProperty(int32 PropertyIndex);
    void PostDestroyStaleProperties();
 
    FSetupBlenderSystemResult SetupBlenderSystem(const FPropertyParameters& Params);
 
    bool ResolveProperty(UE::MovieScene::FCustomAccessorView CustomAccessors, UObject* Object, const FMovieScenePropertyBinding& PropertyBinding, const UE::MovieScene::FEntityGroupID& GroupID, int32 PropertyDefinitionIndex);
 
    void InitializePropertyMetaData(FSystemTaskPrerequisites& InPrerequisites, FSystemSubsequentTasks& Subsequents);
 
private:
 
    static constexpr uint16 INVALID_BLEND_CHANNEL = uint16(-1);
 
    UE::MovieScene::FEntityGroupingPolicyKey PropertyGroupingKey;
 
    TSparseArray<FObjectPropertyInfo> ResolvedProperties;
    TMultiMap<FContributorKey, FMovieSceneEntityID> Contributors;
    TMultiMap<FContributorKey, FMovieSceneEntityID> NewContributors;
 
    TArray<UE::MovieScene::FPropertyStats> PropertyStats;
 
    UE::MovieScene::FComponentMask CleanFastPathMask;
 
    TBitArray<> PendingInvalidatedProperties;
    TBitArray<> InitializePropertyMetaDataTasks;
    TBitArray<> SaveGlobalStateTasks;
 
    UE::MovieScene::FBuiltInComponentTypes* BuiltInComponents;
     
    UE::MovieScene::FPropertyRecomposerImpl RecomposerImpl;
};
 
 
template<typename PropertyTraits>
UE::MovieScene::TRecompositionResult<typename PropertyTraits::StorageType> UMovieScenePropertyInstantiatorSystem::RecomposeBlendOperational(const UE::MovieScene::TPropertyComponents<PropertyTraits>& Components, const UE::MovieScene::FDecompositionQuery& InQuery, const typename PropertyTraits::StorageType& InCurrentValue)
{
    return RecomposerImpl.RecomposeBlendOperational<PropertyTraits>(Components, InQuery, InCurrentValue);
}