MovieScenePropertyRegistry.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "CoreTypes.h"
#include "EntitySystem/IMovieScenePropertyComponentHandler.h"
#include "EntitySystem/MovieSceneEntityIDs.h"
#include "EntitySystem/MovieSceneEntitySystemTypes.h"
#include "EntitySystem/MovieScenePropertySystemTypes.h"
#include "EntitySystem/MovieSceneSystemTaskDependencies.h"
#include "Math/NumericLimits.h"
#include "Misc/AssertionMacros.h"
#include "Misc/GeneratedTypeName.h"
#include "Misc/InlineValue.h"
#include "Misc/Optional.h"
#include "Misc/TVariant.h"
#include "Stats/Stats.h"
#include "Templates/SharedPointer.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/UnrealTypeTraits.h"
#include "UObject/NameTypes.h"
#include "Templates/SubclassOf.h"
 
#include <initializer_list>
 
class FTrackInstancePropertyBindings;
class UClass;
class UMovieSceneBlenderSystem;
class UMovieSceneTrack;
class UMovieSceneEntitySystemLinker;
class UObject;
struct FMovieScenePropertyBinding;
 
namespace UE
{
namespace MovieScene
{
 
struct FFloatDecompositionParams;
struct FPropertyCompositeDefinition;
struct FPropertyDefinition;
struct IPropertyTraits;
 
DECLARE_CYCLE_STAT(TEXT("Apply properties"), MovieSceneEval_ApplyProperties,  STATGROUP_MovieSceneECS);
 
struct FPropertyStats
{
    int32 NumProperties = 0;
 
    int32 NumPartialProperties = 0;
};
 
 
struct FPropertyDefinition
{
    FPropertyDefinition() = default;
 
    FPropertyDefinition(
            uint16 InVariableSizeCompositeOffset,
            FComponentTypeID InPropertyType, FComponentTypeID InInitialValueType)
        : CustomPropertyRegistration(nullptr)
        , TraitsInstance(nullptr)
        , DoubleCompositeMask(0)
        , VariableSizeCompositeOffset(InVariableSizeCompositeOffset)
        , CompositeSize(0)
        , PropertyType(InPropertyType)
        , InitialValueType(InInitialValueType)
        , BlenderSystemClass(nullptr)
    {
    }
 
    FPropertyDefinition(FPropertyDefinition&&) = default;
    FPropertyDefinition(const FPropertyDefinition&) = delete;
 
    template<typename T>
    TComponentTypeID<T> GetMetaDataComponent(int32 Index) const
    {
        return MetaDataTypes[Index].ReinterpretCast<T>();
    }
 
    MOVIESCENE_API void SetupInitialValueProcessor() const;
 
    ICustomPropertyRegistration* CustomPropertyRegistration = nullptr;
 
    const IPropertyTraits* TraitsInstance = nullptr;
 
    TSubclassOf<UMovieSceneTrack> DefaultTrackType;
 
    TStatId StatID;
 
    uint32 DoubleCompositeMask = 0;
 
    uint16 VariableSizeCompositeOffset = INDEX_NONE;
 
    uint16 CompositeSize = 0;
 
    FComponentTypeID PropertyType;
 
    FComponentTypeID InitialValueType;
 
    TArrayView<const FComponentTypeID> MetaDataTypes;
 
    UClass* BlenderSystemClass;
 
    TInlineValue<IPropertyComponentHandler, 32> Handler;
};
 
struct FPropertyCompositeDefinition
{
    FComponentTypeID ComponentTypeID;
 
    uint16 CompositeOffset;
};
 
using FResolvedFastProperty = TVariant<uint16, UE::MovieScene::FCustomPropertyIndex>;
using FResolvedProperty = TVariant<uint16, UE::MovieScene::FCustomPropertyIndex, TSharedPtr<FTrackInstancePropertyBindings>>;
 
template<typename PropertyTraits, typename... Composites> struct TCompositePropertyDefinitionBuilder;
template<typename PropertyTraits> struct TPropertyDefinitionBuilder;
 
class FPropertyRegistry
{
public:
 
    FPropertyRegistry() = default;
 
    FPropertyRegistry(FPropertyRegistry&&) = delete;
    FPropertyRegistry(const FPropertyRegistry&) = delete;
 
    static MOVIESCENE_API TOptional< FResolvedFastProperty > ResolveFastProperty(UObject* Object, const FMovieScenePropertyBinding& PropertyBinding, FCustomAccessorView CustomAccessors);
 
    static MOVIESCENE_API TOptional< FResolvedProperty > ResolveProperty(UObject* Object, const FMovieScenePropertyBinding& PropertyBinding, FCustomAccessorView CustomAccessors);
 
    template<typename PropertyTraits>
    TCompositePropertyDefinitionBuilder<PropertyTraits> DefineCompositeProperty(TPropertyComponents<PropertyTraits>& InOutPropertyComponents, const TCHAR* InStatName)
    {
        DefinePropertyImpl(InOutPropertyComponents, InStatName);
        FPropertyDefinition* Property = &Properties[InOutPropertyComponents.CompositeID.AsIndex()];
        Property->TraitsInstance = &InOutPropertyComponents.PropertyTraits;
        return TCompositePropertyDefinitionBuilder<PropertyTraits>(Property, this);
    }
 
    template<typename PropertyTraits>
    TPropertyDefinitionBuilder<PropertyTraits> DefineProperty(TPropertyComponents<PropertyTraits>& InOutPropertyComponents, const TCHAR* InStatName)
    {
        DefinePropertyImpl(InOutPropertyComponents, InStatName);
        FPropertyDefinition* Property = &Properties[InOutPropertyComponents.CompositeID.AsIndex()];
        Property->TraitsInstance = &InOutPropertyComponents.PropertyTraits;
        return TPropertyDefinitionBuilder<PropertyTraits>(Property, this);
    }
 
    const FPropertyDefinition& GetDefinition(FCompositePropertyTypeID PropertyID) const
    {
        return Properties[PropertyID.TypeIndex];
    }
 
    TArrayView<const FPropertyDefinition> GetProperties() const
    {
        return Properties;
    }
 
    MOVIESCENE_API const FPropertyDefinition* FindPropertyDefinition(FComponentTypeID ComponentTypeID) const;
 
    TArrayView<const FPropertyCompositeDefinition> GetComposites(const FPropertyDefinition& Property) const
    {
        const int32 CompositeOffset = Property.VariableSizeCompositeOffset;
        const int32 NumComposites   = Property.CompositeSize;
        return MakeArrayView(CompositeDefinitions.GetData() + CompositeOffset, NumComposites);
    }
 
    TArrayView<const FPropertyCompositeDefinition> GetComposites(FCompositePropertyTypeID PropertyID) const
    {
        return GetComposites(GetDefinition(PropertyID));
    }
 
private:
 
    template<typename PropertyTraits>
    friend struct TPropertyDefinitionBuilder;
    
    template<typename PropertyTraits, typename... Composites>
    friend struct TCompositePropertyDefinitionBuilder;
 
    template<typename PropertyTraits>
    void DefinePropertyImpl(TPropertyComponents<PropertyTraits>& InOutPropertyComponents, const TCHAR* InStatName)
    {
        using StorageType = typename PropertyTraits::StorageType;
 
        const int32 CompositeOffsetInt32 = CompositeDefinitions.Num();
        checkf(CompositeOffsetInt32 <= MAX_uint16, TEXT("Maximum number of composite definitions reached"));
 
        const uint16 CompositeOffset = static_cast<uint16>(CompositeOffsetInt32);
 
        TStatId StatID;
 
#if STATS || ENABLE_STATNAMEDEVENTS
 
    #if STATS
        // Use FDynamicStats to create the stat in the right stat group if possible
        StatID = FDynamicStats::CreateStatId<STAT_GROUP_TO_FStatGroup(STATGROUP_MovieSceneECS)>( FName(InStatName) );
    #else
        // Otherwise just make a named stat
        const auto& ConversionData = StringCast<PROFILER_CHAR>(InStatName);
        const int32 NumStorageChars = (ConversionData.Length() + 1);    //length doesn't include null terminator
 
        // We leak this string
        PROFILER_CHAR* StoragePtr = new PROFILER_CHAR[NumStorageChars];
        FMemory::Memcpy(StoragePtr, ConversionData.Get(), NumStorageChars * sizeof(PROFILER_CHAR));
 
        StatID = TStatId(StoragePtr);
    #endif
#endif
 
        FPropertyDefinition NewDefinition(
            CompositeOffset, 
            InOutPropertyComponents.PropertyTag,
            InOutPropertyComponents.InitialValue);
 
        NewDefinition.StatID = StatID;
 
        NewDefinition.MetaDataTypes = InOutPropertyComponents.MetaDataComponents.GetTypes();
        checkf(!NewDefinition.MetaDataTypes.Contains(FComponentTypeID()), TEXT("Property meta-data component is not defined"));
 
        const int32 NewPropertyIndex = Properties.Add(MoveTemp(NewDefinition));
 
        checkf(!InOutPropertyComponents.CompositeID, TEXT("Property already defined"));
        static_cast<FCompositePropertyTypeID&>(InOutPropertyComponents.CompositeID) = FCompositePropertyTypeID::FromIndex(NewPropertyIndex);
    }
 
    TArray<FPropertyDefinition> Properties;
 
    TArray<FPropertyCompositeDefinition> CompositeDefinitions;
};
 
 
 
 
} // namespace MovieScene
} // namespace UE
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_5
#include "Templates/IsTriviallyDestructible.h"
#endif