MovieSceneEntitySystemTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Algo/Find.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/BitArray.h"
#include "MovieSceneFwd.h"
#include "EntitySystem/MovieSceneEntityIDs.h"
#include "HAL/CriticalSection.h"
#include "Math/NumericLimits.h"
#include "Math/UnrealMathSSE.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/TransactionallySafeRWLock.h"
#include "Stats/Stats.h"
#include "Templates/UnrealTemplate.h"
 
#include <atomic>
#include <initializer_list>
 
class UMovieSceneSequence;
namespace UE { namespace MovieScene { class FEntityManager; } }
 
 
DECLARE_STATS_GROUP(TEXT("Movie Scene Evaluation Systems"), STATGROUP_MovieSceneECS, STATCAT_Advanced)
 
namespace UE
{
namespace MovieScene
{
 
struct FReadErased;
struct FReadErasedOptional;
struct FWriteErased;
struct FWriteErasedOptional;
template<typename T> struct TComponentLock;
template<typename T> struct TRead;
template<typename T> struct TReadOptional;
template<typename T> struct TWrite;
template<typename T> struct TWriteOptional;
 
enum class ESystemPhase : uint8
{
    None = 0,
 
    Import = 1 << 0,
 
    Spawn = 1 << 1,
 
    Instantiation = 1 << 2,
 
    Scheduling = 1 << 3,
 
    Evaluation = 1 << 4,
 
    Finalization = 1 << 5,
};
ENUM_CLASS_FLAGS(ESystemPhase);
 
enum class EComponentTypeFlags : uint8
{
    None = 0x00,
 
    Preserved = 0x1,
 
    CopyToChildren = 0x2,
 
    CopyToOutput = 0x4,
 
    MigrateToOutput = 0x8,
};
ENUM_CLASS_FLAGS(EComponentTypeFlags);
 
 
enum class EComplexFilterMode : uint8
{
    OneOf       = 1 << 0,
    OneOrMoreOf = 1 << 1,
    AllOf       = 1 << 2,
 
    // High bit modifiers
    Negate      = 1 << 7, 
};
ENUM_CLASS_FLAGS(EComplexFilterMode);
 
enum class EMutuallyInclusiveComponentType : uint8
{
    Mandatory = 1u << 0,
    Optional  = 1u << 1,
 
    All = Mandatory | Optional,
};
ENUM_CLASS_FLAGS(EMutuallyInclusiveComponentType)
 
 
enum class EComponentHeaderLockMode
{
    LockFree,
    Mutex,
};
 
struct FInterrogationChannel
{
    FInterrogationChannel()
        : Value(INDEX_NONE)
    {}
 
    FInterrogationChannel operator++()
    {
        check( Value != INDEX_NONE );
        return FInterrogationChannel(++Value);
    }
 
    explicit operator bool() const
    {
        return IsValid();
    }
 
    bool IsValid() const
    {
        return Value != INDEX_NONE;
    }
 
    int32 AsIndex() const
    {
        check(Value != INDEX_NONE);
        return Value;
    }
 
    static FInterrogationChannel Default()
    {
        return FInterrogationChannel(0);
    }
 
    static FInterrogationChannel First()
    {
        return FInterrogationChannel(1);
    }
 
    static FInterrogationChannel FromIndex(int32 InIndex)
    {
        return FInterrogationChannel(InIndex);
    }
 
    static FInterrogationChannel Last()
    {
        return FInterrogationChannel(MAX_int32);
    }
 
    static FInterrogationChannel Invalid()
    {
        return FInterrogationChannel(INDEX_NONE);
    }
 
    friend uint32 GetTypeHash(FInterrogationChannel In)
    {
        return In.Value;
    }
 
    friend bool operator==(FInterrogationChannel A, FInterrogationChannel B)
    {
        return A.Value == B.Value;
    }
 
    friend bool operator!=(FInterrogationChannel A, FInterrogationChannel B)
    {
        return A.Value != B.Value;
    }
 
    friend bool operator<(FInterrogationChannel A, FInterrogationChannel B)
    {
        return A.Value < B.Value;
    }
 
private:
 
    explicit FInterrogationChannel(int32 InValue) : Value(InValue) {}
 
    int32 Value;
};
 
 
struct FInterrogationKey
{
    FInterrogationChannel Channel;
 
    int32 InterrogationIndex;
 
    FInterrogationKey()
        : InterrogationIndex(-1)
    {}
 
    FInterrogationKey(FInterrogationChannel InChannel, int32 InInterrogationIndex)
        : Channel(InChannel)
        , InterrogationIndex(InInterrogationIndex)
    {}
 
    bool IsValid() const
    {
        return Channel.IsValid() && InterrogationIndex != INDEX_NONE;
    }
 
    friend uint32 GetTypeHash(const FInterrogationKey& In)
    {
        return GetTypeHash(In.Channel) ^ In.InterrogationIndex;
    }
 
    friend bool operator==(const FInterrogationKey& A, const FInterrogationKey& B)
    {
        return A.Channel == B.Channel && A.InterrogationIndex == B.InterrogationIndex;
    }
 
    friend bool operator!=(const FInterrogationKey& A, const FInterrogationKey& B)
    {
        return A.Channel != B.Channel || A.InterrogationIndex != B.InterrogationIndex;
    }
 
    static FInterrogationKey Default(int32 InInterrogationIndex = 0)
    {
        return FInterrogationKey(FInterrogationChannel::Default(), InInterrogationIndex);
    }
};
 
 
struct FInterrogationInstance
{
    UMovieSceneSequence* Sequence = nullptr;
 
    bool IsValid() const
    {
        return Sequence != nullptr;
    }
};
 
 
struct FEntityComponentFilter
{
 
    void Reset()
    {
        AllMask.Reset();
        NoneMask.Reset();
        ComplexMasks.Reset();
    }
 
    MOVIESCENE_API bool Match(const FComponentMask& Input) const;
 
    MOVIESCENE_API bool IsValid() const;
 
    FEntityComponentFilter& All(const FComponentMask& InComponentMask)
    {
        AllMask.CombineWithBitwiseOR(InComponentMask, EBitwiseOperatorFlags::MaxSize);
        return *this;
    }
    FEntityComponentFilter& All(std::initializer_list<FComponentTypeID> InComponentTypes)
    {
        AllMask.SetAll(InComponentTypes);
        return *this;
    }
 
 
    FEntityComponentFilter& None(const FComponentMask& InComponentMask)
    {
        NoneMask.CombineWithBitwiseOR(InComponentMask, EBitwiseOperatorFlags::MaxSize);
        return *this;
    }
    FEntityComponentFilter& None(std::initializer_list<FComponentTypeID> InComponentTypes)
    {
        NoneMask.SetAll(InComponentTypes);
        return *this;
    }
 
 
    FEntityComponentFilter& Any(const FComponentMask& InComponentMask)
    {
        return Complex(InComponentMask, EComplexFilterMode::OneOrMoreOf);
    }
    FEntityComponentFilter& Any(std::initializer_list<FComponentTypeID> InComponentTypes)
    {
        return Complex(InComponentTypes, EComplexFilterMode::OneOrMoreOf);
    }
 
    FEntityComponentFilter& AnyLenient(std::initializer_list<FComponentTypeID> InComponentTypes)
    {
        FComponentMask Mask;
        for (FComponentTypeID TypeID : InComponentTypes)
        {
            if (TypeID)
            {
                Mask.Set(TypeID);
            }
        }
        return Any(Mask);
    }
 
 
    FEntityComponentFilter& Deny(std::initializer_list<FComponentTypeID> InComponentTypes)
    {
        return Complex(InComponentTypes, EComplexFilterMode::AllOf | EComplexFilterMode::Negate);
    }
 
    FEntityComponentFilter& Deny(const FComponentMask& InComponentMask)
    {
        return Complex(InComponentMask, EComplexFilterMode::AllOf | EComplexFilterMode::Negate);
    }
 
 
    FEntityComponentFilter& Complex(std::initializer_list<FComponentTypeID> InComponentTypes, EComplexFilterMode ComplexMode)
    {
        if (InComponentTypes.size() > 0)
        {
            FComplexMask& ComplexMask = ComplexMasks.Emplace_GetRef(ComplexMode);
            ComplexMask.Mask.SetAll(InComponentTypes);
        }
        return *this;
    }
 
    FEntityComponentFilter& Complex(const FComponentMask& InComponentMask, EComplexFilterMode ComplexMode)
    {
        if (InComponentMask.Num() > 0)
        {
            ComplexMasks.Emplace(InComponentMask, ComplexMode);
        }
        return *this;
    }
 
    FEntityComponentFilter& Combine(const FEntityComponentFilter& CombineWith)
    {
        if (CombineWith.AllMask.Num() > 0)
        {
            AllMask.CombineWithBitwiseOR(CombineWith.AllMask, EBitwiseOperatorFlags::MaxSize);
        }
 
        if (CombineWith.NoneMask.Num() > 0)
        {
            NoneMask.CombineWithBitwiseOR(CombineWith.NoneMask, EBitwiseOperatorFlags::MaxSize);
        }
 
        if (CombineWith.ComplexMasks.Num() > 0)
        {
            ComplexMasks.Append(CombineWith.ComplexMasks);
        }
        return *this;
    }
 
private:
 
    struct FComplexMask
    {
        FComplexMask(EComplexFilterMode InMode)
            : Mode(InMode)
        {}
        FComplexMask(const FComponentMask& InMask, EComplexFilterMode InMode)
            : Mask(InMask), Mode(InMode)
        {}
 
        FComponentMask Mask;
        EComplexFilterMode Mode;
    };
    FComponentMask AllMask;
    FComponentMask NoneMask;
    TArray<FComplexMask> ComplexMasks;
};
 
 
struct FEntityAllocationWriteContext
{
    MOVIESCENE_API FEntityAllocationWriteContext(const FEntityManager& EntityManager);
 
    static FEntityAllocationWriteContext NewAllocation()
    {
        return FEntityAllocationWriteContext();
    }
 
    FEntityAllocationWriteContext Add(FEntityAllocationWriteContext InOther) const
    {
        FEntityAllocationWriteContext Context;
        Context.SystemSerial = SystemSerial + InOther.SystemSerial;
        return Context;
    }
    FEntityAllocationWriteContext Subtract(FEntityAllocationWriteContext InOther) const
    {
        FEntityAllocationWriteContext Context;
        Context.SystemSerial = SystemSerial - InOther.SystemSerial;
        return Context;
    }
    uint64 GetSystemSerial() const
    {
        return SystemSerial;
    }
 
private:
 
    FEntityAllocationWriteContext()
        : SystemSerial(0)
    {}
 
    uint64 SystemSerial;
};
 
struct FComponentHeader
{
    FComponentHeader() = default;
 
    FComponentHeader(FComponentHeader&&) = delete;
    FComponentHeader& operator=(FComponentHeader&&) = delete;
 
    FComponentHeader(const FComponentHeader&) = delete;
    FComponentHeader& operator=(const FComponentHeader&) = delete;
 
#if UE_MOVIESCENE_ENTITY_DEBUG
 
    // This virtual destructor exists in order to create a vftable for this type
    //    that is used by the debugger to locate and display the derived TComponentHeader<T> type
    //    enabling visualization of the concrete type in the debugger. It is completely compiled
    //    out when UE_MOVIESCENE_ENTITY_DEBUG is disabled ensuring this type is not polymorphic.
    MOVIESCENE_API virtual ~FComponentHeader();
 
    struct IComponentDebuggingTypedPtr* DebugComponents = nullptr;
 
    const uint16* Size = nullptr;
 
#endif // UE_MOVIESCENE_ENTITY_DEBUG
 
    mutable uint8* Components;
 
    mutable FTransactionallySafeRWLock ReadWriteLock;
 
private:
 
    mutable uint64 SerialNumber;
 
public:
 
    struct FAutoRTFMCompiledOutAtomicInt32 final
    {
        int32 fetch_add(const int32 Value, const std::memory_order) { return 0; }
        int32 fetch_sub(const int32 Value, const std::memory_order) { return 0; }
        int32 exchange(const int32 Value, const std::memory_order) { return 0; }
    };
 
#if UE_AUTORTFM
    using FScheduledAccessCountType = FAutoRTFMCompiledOutAtomicInt32;
#else
    using FScheduledAccessCountType = std::atomic<int32>;
#endif
 
    mutable FScheduledAccessCountType ScheduledAccessCount;
 
    uint8 Sizeof;
 
    FComponentTypeID ComponentType;
 
    bool IsTag() const
    {
        return Sizeof == 0;
    }
 
    bool HasData() const
    {
        return Components != nullptr;
    }
 
    void* GetValuePtr(int32 Offset) const
    {
        check(!IsTag() && Components != nullptr);
        return Components + Sizeof*Offset;
    }
 
    void PostWriteComponents(FEntityAllocationWriteContext InWriteContext) const
    {
        SerialNumber = FMath::Max(SerialNumber, InWriteContext.GetSystemSerial());
    }
 
    bool HasBeenWrittenToSince(uint64 InSystemSerial) const
    {
        return SerialNumber > InSystemSerial;
    }
};
 
 
struct FScopedHeaderReadLock
{
    FScopedHeaderReadLock();
    FScopedHeaderReadLock(const FComponentHeader* InHeader, EComponentHeaderLockMode InLockMode);
 
    FScopedHeaderReadLock(const FScopedHeaderReadLock& RHS) = delete;
    void operator=(const FScopedHeaderReadLock& RHS) = delete;
 
    FScopedHeaderReadLock(FScopedHeaderReadLock&& RHS);
    FScopedHeaderReadLock& operator=(FScopedHeaderReadLock&& RHS);
 
    ~FScopedHeaderReadLock();
 
private:
    const FComponentHeader* Header;
    EComponentHeaderLockMode LockMode;
};
 
 
struct FScopedHeaderWriteLock
{
    FScopedHeaderWriteLock();
    FScopedHeaderWriteLock(const FComponentHeader* InHeader, EComponentHeaderLockMode InLockMode, FEntityAllocationWriteContext InWriteContext);
 
    FScopedHeaderWriteLock(const FScopedHeaderWriteLock& RHS) = delete;
    void operator=(const FScopedHeaderWriteLock& RHS) = delete;
 
    FScopedHeaderWriteLock(FScopedHeaderWriteLock&& RHS);
    FScopedHeaderWriteLock& operator=(FScopedHeaderWriteLock&& RHS);
 
    ~FScopedHeaderWriteLock();
 
private:
    const FComponentHeader* Header;
    FEntityAllocationWriteContext WriteContext;
    EComponentHeaderLockMode LockMode;
};
 
 
struct FEntityAllocation
{
    FEntityAllocation()
        : SerialNumber(0)
        , NumComponents(0)
        , Size(0)
        , Capacity(0)
        , MaxCapacity(0)
        , LockMode(EComponentHeaderLockMode::Mutex)
    {}
 
    ~FEntityAllocation()
    {
        for (int32 Index = 0; Index < NumComponents; ++Index)
        {
            ComponentHeaders[Index].~FComponentHeader();
        }
    }
 
    FEntityAllocation(const FEntityAllocation&) = delete;
    FEntityAllocation& operator=(const FEntityAllocation&) = delete;
 
 
    TArrayView<const FComponentHeader> GetComponentHeaders() const
    {
        return MakeArrayView(ComponentHeaders, NumComponents);
    }
 
 
    TArrayView<FComponentHeader> GetComponentHeaders()
    {
        return MakeArrayView(ComponentHeaders, NumComponents);
    }
 
 
    bool HasComponent(FComponentTypeID ComponentTypeID) const
    {
        return FindComponentHeader(ComponentTypeID) != nullptr;
    }
 
 
    const FComponentHeader* FindComponentHeader(FComponentTypeID ComponentTypeID) const
    {
        return Algo::FindBy(GetComponentHeaders(), ComponentTypeID, &FComponentHeader::ComponentType);
    }
 
 
    FComponentHeader* FindComponentHeader(FComponentTypeID ComponentTypeID)
    {
        return Algo::FindBy(GetComponentHeaders(), ComponentTypeID, &FComponentHeader::ComponentType);
    }
 
 
    const FComponentHeader& GetComponentHeaderChecked(FComponentTypeID ComponentTypeID) const
    {
        const FComponentHeader* Header = FindComponentHeader(ComponentTypeID);
        check(Header);
        return *Header;
    }
 
 
    FComponentHeader& GetComponentHeaderChecked(FComponentTypeID ComponentTypeID)
    {
        FComponentHeader* Header = FindComponentHeader(ComponentTypeID);
        check(Header);
        return *Header;
    }
 
 
    TArrayView<const FMovieSceneEntityID> GetEntityIDs() const
    {
        return MakeArrayView(EntityIDs, Size);
    }
 
 
    const FMovieSceneEntityID* GetRawEntityIDs() const
    {
        return EntityIDs;
    }
 
 
    const void* GetComponentDataAddress() const
    {
        return ComponentData;
    }
 
 
    uint32 GetUniqueID() const
    {
        return UniqueID;
    }
 
 
    bool HasStructureChangedSince(uint64 InSystemVersion) const
    {
        return SerialNumber > InSystemVersion;
    }
 
 
    void PostModifyStructureExcludingHeaders(FEntityAllocationWriteContext InWriteContext)
    {
        SerialNumber = FMath::Max(SerialNumber, InWriteContext.GetSystemSerial());
    }
 
 
    void PostModifyStructure(FEntityAllocationWriteContext InWriteContext)
    {
        SerialNumber = FMath::Max(SerialNumber, InWriteContext.GetSystemSerial());
        for (FComponentHeader& Header : GetComponentHeaders())
        {
            Header.PostWriteComponents(InWriteContext);
        }
    }
 
    int32 GetNumComponentTypes() const
    {
        return int32(NumComponents);
    }
 
 
    int32 Num() const
    {
        return int32(Size);
    }
 
 
    int32 GetMaxCapacity() const
    {
        return int32(MaxCapacity);
    }
 
 
    int32 GetCapacity() const
    {
        return int32(Capacity);
    }
 
 
    int32 GetSlack() const
    {
        return int32(Capacity) - int32(Size);
    }
 
    EComponentHeaderLockMode GetCurrentLockMode() const
    {
        return LockMode;
    }
 
    [[nodiscard]] MOVIESCENE_API TComponentLock<FReadErased> ReadComponentsErased(FComponentTypeID ComponentType) const;
 
    [[nodiscard]] MOVIESCENE_API TComponentLock<FWriteErased> WriteComponentsErased(FComponentTypeID ComponentType, FEntityAllocationWriteContext InWriteContext) const;
 
    [[nodiscard]] MOVIESCENE_API TComponentLock<FReadErasedOptional> TryReadComponentsErased(FComponentTypeID ComponentType) const;
 
    [[nodiscard]] MOVIESCENE_API TComponentLock<FWriteErasedOptional> TryWriteComponentsErased(FComponentTypeID ComponentType, FEntityAllocationWriteContext InWriteContext) const;
 
    template<typename T>
    [[nodiscard]] TComponentLock<TRead<T>> ReadComponents(TComponentTypeID<T> ComponentType) const
    {
        const FComponentHeader& Header = GetComponentHeaderChecked(ComponentType);
        return TComponentLock<TRead<T>>(&Header, LockMode);
    }
 
    template<typename T>
    [[nodiscard]] TComponentLock<TReadOptional<T>> TryReadComponents(TComponentTypeID<T> ComponentType) const
    {
        if (const FComponentHeader* Header = FindComponentHeader(ComponentType))
        {
            return TComponentLock<TReadOptional<T>>(Header, LockMode);
        }
        return TComponentLock<TReadOptional<T>>();
    }
 
    template<typename T>
    [[nodiscard]] TComponentLock<TWrite<T>> WriteComponents(TComponentTypeID<T> ComponentType, FEntityAllocationWriteContext InWriteContext) const
    {
        const FComponentHeader& Header = GetComponentHeaderChecked(ComponentType);
        return TComponentLock<TWrite<T>>(&Header, LockMode, InWriteContext);
    }
 
    template<typename T>
    [[nodiscard]] TComponentLock<TWriteOptional<T>> TryWriteComponents(TComponentTypeID<T> ComponentType, FEntityAllocationWriteContext InWriteContext) const
    {
        if (const FComponentHeader* Header = FindComponentHeader(ComponentType))
        {
            return TComponentLock<TWriteOptional<T>>(Header, LockMode, InWriteContext);
        }
        return TComponentLock<TWriteOptional<T>>();
    }
 
private:
 
    friend struct FEntityInitializer;
    friend struct FEntityAllocationMutexGuard;
 
    uint64 SerialNumber;
    uint32 UniqueID;
    uint16 NumComponents;
    uint16 Size;
    uint16 Capacity;
    uint16 MaxCapacity;
 
    EComponentHeaderLockMode LockMode;
 
    FMovieSceneEntityID* EntityIDs;
 
    uint8* ComponentData;
 
public:
    FComponentHeader* ComponentHeaders;
};
 
 
struct FEntityAllocationMutexGuard
{
    FEntityAllocationMutexGuard(FEntityAllocation* InAllocation, EComponentHeaderLockMode InLockMode);
    ~FEntityAllocationMutexGuard();
 
    FEntityAllocationMutexGuard(const FEntityAllocationMutexGuard&) = delete;
    void operator=(const FEntityAllocationMutexGuard&) = delete;
 
    FEntityAllocationMutexGuard(const FEntityAllocationMutexGuard&&) = delete;
    void operator=(const FEntityAllocationMutexGuard&&) = delete;
 
private:
    FEntityAllocation* Allocation;
};
 
 
struct FEntityAllocationProxy
{
    MOVIESCENE_API const FEntityAllocation* GetAllocation() const;
 
    MOVIESCENE_API FEntityAllocation* GetAllocation();
 
    MOVIESCENE_API const FComponentMask& GetAllocationType() const;
 
    static FEntityAllocationProxy MakeInstance(const FEntityManager* InManager, int32 InAllocationIndex)
    {
        return FEntityAllocationProxy(InManager, InAllocationIndex);
    }
 
    int32 GetAllocationIndex() const
    {
        return AllocationIndex;
    }
 
    operator const FEntityAllocation*() const
    {
        return GetAllocation();
    }
 
    operator FEntityAllocation*()
    {
        return GetAllocation();
    }
 
    operator const FComponentMask&() const
    {
        return GetAllocationType();
    }
    
    friend bool operator==(const FEntityAllocationProxy& A, const FEntityAllocationProxy& B)
    {
        return A.Manager == B.Manager && A.AllocationIndex == B.AllocationIndex;
    }
    
    friend uint32 GetTypeHash(FEntityAllocationProxy Proxy)
    {
        return Proxy.AllocationIndex;
    }
 
private:
    friend struct FEntityAllocationIterator;
 
    FEntityAllocationProxy(const FEntityManager* InManager, int32 InAllocationIndex)
        : Manager(InManager), AllocationIndex(InAllocationIndex)
    {}
 
    const FEntityManager* Manager;
 
    int32 AllocationIndex;
};
 
 
struct FEntityRange
{
    const FEntityAllocation* Allocation = nullptr;
    int32 ComponentStartOffset = 0;
    int32 Num = 0;
};
 
struct FEntityDataLocation
{
    FEntityAllocation* Allocation;
    int32 ComponentOffset;
 
    FEntityRange AsRange() const
    {
        return FEntityRange{ Allocation, ComponentOffset, 1 };
    }
};
 
struct FEntityInfo
{
    FEntityDataLocation Data;
    FMovieSceneEntityID EntityID;
};
 
inline FEntityAllocationMutexGuard::FEntityAllocationMutexGuard(FEntityAllocation* InAllocation, EComponentHeaderLockMode InLockMode)
{
    // Since FEntityAllocation always defaults to Mutex locking, we only 
    // read/write to the allocation if LockFree is specified here (implying we are always in single-thread mode)
    if (InLockMode == EComponentHeaderLockMode::LockFree)
    {
        Allocation = InAllocation;
        InAllocation->LockMode = EComponentHeaderLockMode::LockFree;
    }
    else
    {
        Allocation = nullptr;
    }
}
 
inline FEntityAllocationMutexGuard::~FEntityAllocationMutexGuard()
{
    // Always reset back to Mutex
    if (Allocation)
    {
        Allocation->LockMode = EComponentHeaderLockMode::Mutex;
    }
}
 
inline FScopedHeaderReadLock::FScopedHeaderReadLock()
    : Header(nullptr)
{}
inline FScopedHeaderReadLock::FScopedHeaderReadLock(const FComponentHeader* InHeader, EComponentHeaderLockMode InLockMode)
    : Header(InHeader)
    , LockMode(InLockMode)
{
    if (InLockMode == EComponentHeaderLockMode::Mutex)
    {
        InHeader->ReadWriteLock.ReadLock();
    }
 
    InHeader->ScheduledAccessCount.fetch_add(1, std::memory_order_relaxed);
}
inline FScopedHeaderReadLock::FScopedHeaderReadLock(FScopedHeaderReadLock&& RHS)
    : Header(RHS.Header)
    , LockMode(RHS.LockMode)
{
    RHS.Header = nullptr;
}
inline FScopedHeaderReadLock& FScopedHeaderReadLock::operator=(FScopedHeaderReadLock&& RHS)
{
    if (Header)
    {
        Header->ScheduledAccessCount.fetch_add(1, std::memory_order_relaxed);
        if (LockMode == EComponentHeaderLockMode::Mutex)
        {
            Header->ReadWriteLock.ReadUnlock();
        }
    }
 
    Header = RHS.Header;
    LockMode = RHS.LockMode;
    RHS.Header = nullptr;
    return *this;
}
 
inline FScopedHeaderReadLock::~FScopedHeaderReadLock()
{
    if (Header)
    {
        Header->ScheduledAccessCount.fetch_sub(1, std::memory_order_relaxed);
        if (LockMode == EComponentHeaderLockMode::Mutex)
        {
            Header->ReadWriteLock.ReadUnlock();
        }
    }
}
 
inline FScopedHeaderWriteLock::FScopedHeaderWriteLock()
    : Header(nullptr)
    , WriteContext(FEntityAllocationWriteContext::NewAllocation())
    , LockMode(EComponentHeaderLockMode::Mutex)
{}
 
inline FScopedHeaderWriteLock::FScopedHeaderWriteLock(const FComponentHeader* InHeader, EComponentHeaderLockMode InLockMode, FEntityAllocationWriteContext InWriteContext)
    : Header(InHeader)
    , WriteContext(InWriteContext)
    , LockMode(InLockMode)
{
    if (InLockMode == EComponentHeaderLockMode::Mutex)
    {
        InHeader->ReadWriteLock.WriteLock();
    }
 
    const int32 PreviousAccessCount = InHeader->ScheduledAccessCount.fetch_add(1, std::memory_order_relaxed);
    checkf(PreviousAccessCount == 0, TEXT("Component header is still in use when it is being opened for write!"));
}
 
inline FScopedHeaderWriteLock::FScopedHeaderWriteLock(FScopedHeaderWriteLock&& RHS)
    : Header(RHS.Header)
    , WriteContext(RHS.WriteContext)
    , LockMode(RHS.LockMode)
{
    RHS.Header = nullptr;
}
inline FScopedHeaderWriteLock& FScopedHeaderWriteLock::operator=(FScopedHeaderWriteLock&& RHS)
{
    if (Header)
    {
        Header->PostWriteComponents(WriteContext);
        Header->ScheduledAccessCount.fetch_sub(1, std::memory_order_relaxed);
 
        if (LockMode == EComponentHeaderLockMode::Mutex)
        {
            Header->ReadWriteLock.WriteUnlock();
        }
    }
 
    Header = RHS.Header;
    WriteContext = RHS.WriteContext;
    LockMode = RHS.LockMode;
 
    RHS.Header = nullptr;
    return *this;
}
inline FScopedHeaderWriteLock::~FScopedHeaderWriteLock()
{
    if (Header)
    {
        Header->PostWriteComponents(WriteContext);
        Header->ScheduledAccessCount.fetch_sub(1, std::memory_order_relaxed);
 
        if (LockMode == EComponentHeaderLockMode::Mutex)
        {
            Header->ReadWriteLock.WriteUnlock();
        }
    }
}
 
 
} // namespace MovieScene
} // namespace UE