RepLayout.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/NetworkGuid.h"
#include "UObject/CoreNet.h"
#include "Engine/EngineTypes.h"
#include "UObject/GCObject.h"
#include "Containers/StaticBitArray.h"
#include "Net/Core/Misc/GuidReferences.h"
#include "Net/Core/NetToken/NetTokenExportContext.h"
#include "Net/Core/PushModel/PushModel.h"
#include "Net/Core/PropertyConditions/RepChangedPropertyTracker.h"
#include "Templates/CopyQualifiersFromTo.h"
 
class FNetFieldExportGroup;
class FRepLayout;
class UActorChannel;
class UNetConnection;
class UPackageMapClient;
 
enum class EDiffPropertiesFlags : uint32
{
    None = 0,
    Sync = (1 << 0),                            
    IncludeConditionalProperties = (1 << 1)     
};
 
ENUM_CLASS_FLAGS(EDiffPropertiesFlags);
 
enum class EReceivePropertiesFlags : uint32
{
    None = 0,
    RepNotifies = (1 << 0),                     
    SkipRoleSwap = (1 << 1)                     
};
 
ENUM_CLASS_FLAGS(EReceivePropertiesFlags);
 
enum class ESerializePropertyType : uint8
{
    Handle, // Properties are seralized using handles in SendProperties_r
    Name    // Properties are seralized using their names in SendProperties_r
};
 
enum class ERepDataBufferType
{
    ObjectBuffer,   
    ShadowBuffer    
};
 
namespace UE_RepLayout_Private
{
    template<ERepDataBufferType DataType, typename ConstOrNotType>
    struct TRepDataBufferBase
    {
        static constexpr ERepDataBufferType Type = DataType;
        using ConstOrNotVoid = TCopyQualifiersFromTo_T<ConstOrNotType, void>;
 
    public:
 
        TRepDataBufferBase(ConstOrNotVoid* RESTRICT InDataBuffer) :
            Data((ConstOrNotType* RESTRICT)InDataBuffer)
        {}
 
        friend TRepDataBufferBase operator+(TRepDataBufferBase InBuffer, int32 Offset)
        {
            return InBuffer.Data + Offset;
        }
 
        explicit operator bool() const
        {
            return Data != nullptr;
        }
 
        operator ConstOrNotType* () const
        {
            return Data;
        }
 
        ConstOrNotType* RESTRICT Data;
    };
 
    template<typename TLayoutCmdType, typename ConstOrNotType>
    static TRepDataBufferBase<ERepDataBufferType::ObjectBuffer, ConstOrNotType> operator+(TRepDataBufferBase<ERepDataBufferType::ObjectBuffer, ConstOrNotType> InBuffer, const TLayoutCmdType& Cmd)
    {
        return InBuffer + Cmd.Offset;
    }
 
    template<typename TLayoutCmdType, typename ConstOrNotType>
    static TRepDataBufferBase<ERepDataBufferType::ShadowBuffer, ConstOrNotType> operator+(const TRepDataBufferBase<ERepDataBufferType::ShadowBuffer, ConstOrNotType> InBuffer, const TLayoutCmdType& Cmd)
    {
        return InBuffer + Cmd.ShadowOffset;
    }
}
 
template<ERepDataBufferType DataType> using TRepDataBuffer = UE_RepLayout_Private::TRepDataBufferBase<DataType, uint8>;
template<ERepDataBufferType DataType> using TConstRepDataBuffer = UE_RepLayout_Private::TRepDataBufferBase<DataType, const uint8>;
 
typedef TRepDataBuffer<ERepDataBufferType::ObjectBuffer> FRepObjectDataBuffer;
typedef TRepDataBuffer<ERepDataBufferType::ShadowBuffer> FRepShadowDataBuffer;
typedef TConstRepDataBuffer<ERepDataBufferType::ObjectBuffer> FConstRepObjectDataBuffer;
typedef TConstRepDataBuffer<ERepDataBufferType::ShadowBuffer> FConstRepShadowDataBuffer;
 
class FRepLayout;
class FRepLayoutCmd;
 
namespace UE::Net
{
    inline TStaticBitArray<COND_Max> BuildConditionMapFromRepFlags(const FReplicationFlags& RepFlags)
    {
        TStaticBitArray<COND_Max> ConditionMap;
 
        // Setup condition map
        const bool bIsInitial = RepFlags.bNetInitial ? true : false;
        const bool bIsOwner = RepFlags.bNetOwner ? true : false;
        const bool bIsSimulated = RepFlags.bNetSimulated ? true : false;
        const bool bIsPhysics = RepFlags.bRepPhysics ? true : false;
        const bool bIsReplay = RepFlags.bReplay ? true : false;
 
        ConditionMap[COND_None] = true;
        ConditionMap[COND_InitialOnly] = bIsInitial;
 
        ConditionMap[COND_OwnerOnly] = bIsOwner;
        ConditionMap[COND_SkipOwner] = !bIsOwner;
 
        ConditionMap[COND_SimulatedOnly] = bIsSimulated;
        ConditionMap[COND_SimulatedOnlyNoReplay] = bIsSimulated && !bIsReplay;
        ConditionMap[COND_AutonomousOnly] = !bIsSimulated;
 
        ConditionMap[COND_SimulatedOrPhysics] = bIsSimulated || bIsPhysics;
        ConditionMap[COND_SimulatedOrPhysicsNoReplay] = (bIsSimulated || bIsPhysics) && !bIsReplay;
 
        ConditionMap[COND_InitialOrOwner] = bIsInitial || bIsOwner;
        ConditionMap[COND_ReplayOrOwner] = bIsReplay || bIsOwner;
        ConditionMap[COND_ReplayOnly] = bIsReplay;
        ConditionMap[COND_SkipReplay] = !bIsReplay;
 
        ConditionMap[COND_Custom] = true;
        ConditionMap[COND_Dynamic] = true;
        ConditionMap[COND_Never] = false;
 
        return ConditionMap;
    }
}
 
struct FRepSharedPropertyKey
{
private:
    uint32 CmdIndex = 0;
    uint32 ArrayIndex = 0;
    uint32 ArrayDepth = 0;
    void* DataPtr = nullptr;
 
public:
    FRepSharedPropertyKey()
        : CmdIndex(0)
        , ArrayIndex(0)
        , ArrayDepth(0)
        , DataPtr(nullptr)
    {
    }
 
    explicit FRepSharedPropertyKey(uint32 InCmdIndex, uint32 InArrayIndex, uint32 InArrayDepth, void* InDataPtr)
        : CmdIndex(InCmdIndex)
        , ArrayIndex(InArrayIndex)
        , ArrayDepth(InArrayDepth)
        , DataPtr(InDataPtr)
    {
    }
 
    FString ToDebugString() const
    {
        return FString::Printf(TEXT("{Cmd: %u, Index: %u, Depth: %u, Ptr: 0x%08" UPTRINT_x_FMT "}"), CmdIndex, ArrayIndex, ArrayDepth, (UPTRINT)DataPtr);
    }
 
    friend bool operator==(const FRepSharedPropertyKey& A, const FRepSharedPropertyKey& B)
    {
        return (A.CmdIndex == B.CmdIndex) && (A.ArrayIndex == B.ArrayIndex) && (A.ArrayDepth == B.ArrayDepth) && (A.DataPtr == B.DataPtr);
    }
 
    friend uint32 GetTypeHash(const FRepSharedPropertyKey& Key)
    {
        return uint32(CityHash64((char*)&Key, sizeof(FRepSharedPropertyKey)));
    }
};
 
struct FRepSerializedPropertyInfo
{
    FRepSerializedPropertyInfo():
        BitOffset(0),
        BitLength(0),
        PropBitOffset(0),
        PropBitLength(0)
    {}
 
    FRepSharedPropertyKey PropertyKey;
 
    int32 BitOffset;
 
    int32 BitLength;
 
    int32 PropBitOffset;
 
    int32 PropBitLength;
};
 
struct FRepSerializationSharedInfo
{
    FRepSerializationSharedInfo():
        bIsValid(false)
    {}
 
    ~FRepSerializationSharedInfo()
    {
        // Explicitly reset members to improve resilience to double-destruction.
        SharedPropertyInfo = {};
        SerializedProperties = nullptr;
        bIsValid = false;
    }
 
    void SetValid()
    {
        bIsValid = true;
    }
 
    void Init()
    {
        if (!SerializedProperties.IsValid())
        {
            SerializedProperties.Reset(new FNetBitWriter(0));
        }
    }
 
    bool IsValid() const
    {
        return bIsValid;
    }
 
    void Reset()
    {
        if (bIsValid)
        {
            SharedPropertyInfo.Reset();
            SerializedProperties->Reset();
            NetTokensPendingExport.Reset();
 
            bIsValid = false;
        }
    }
 
    const FRepSerializedPropertyInfo* WriteSharedProperty(
        const FRepLayoutCmd& Cmd,
        const FRepSharedPropertyKey& PropertyKey,
        const int32 CmdIndex,
        const uint16 Handle,
        const FConstRepObjectDataBuffer Data,
        const bool bWriteHandle,
        const bool bDoChecksum);
 
    TArray<FRepSerializedPropertyInfo> SharedPropertyInfo;
 
    TUniquePtr<FNetBitWriter> SerializedProperties;
 
    UE::Net::FNetTokenExportContext::FNetTokenExports NetTokensPendingExport;
 
    void CountBytes(FArchive& Ar) const;
 
private:
 
    bool bIsValid = false;
};
 
class FRepChangedHistory
{
public:
    FRepChangedHistory():
        Resend(false)
    {}
 
    void CountBytes(FArchive& Ar) const
    {
        Changed.CountBytes(Ar);
    }
 
    bool WasSent() const
    {
        return OutPacketIdRange.First != INDEX_NONE;
    }
 
    void Reset()
    {
        OutPacketIdRange = FPacketIdRange();
        Changed.Empty();
        Resend = false;
    }
 
    FPacketIdRange OutPacketIdRange;
 
    TArray<uint16> Changed;
 
    bool Resend = false;
};
 
struct FRepStateStaticBuffer : public FNoncopyable
{
private:
 
    friend class FRepLayout;
 
    FRepStateStaticBuffer(const TSharedRef<const FRepLayout>& InRepLayout) :
        RepLayout(InRepLayout)
    {
    }
 
public:
 
    FRepStateStaticBuffer(FRepStateStaticBuffer&& InStaticBuffer) :
        Buffer(MoveTemp(InStaticBuffer.Buffer)),
        RepLayout(MoveTemp(InStaticBuffer.RepLayout))
    {
    }
 
    ~FRepStateStaticBuffer();
 
    uint8* GetData()
    {
        return Buffer.GetData();
    }
 
    const uint8* GetData() const
    {
        return Buffer.GetData();
    }
 
    int32 Num() const
    {
        return Buffer.Num();
    }
 
    void CountBytes(FArchive& Ar) const;
 
    void Empty()
    {
        Buffer.Empty();
    }
 
private:
 
    // Properties will be copied in here so memory needs aligned to largest type
    TArray<uint8, TAlignedHeapAllocator<16>> Buffer;
    TSharedRef<const FRepLayout> RepLayout;
};
 
class FRepChangelistState : public FNoncopyable
{
private:
 
    friend class FReplicationChangelistMgr;
 
    FRepChangelistState(
        const TSharedRef<const FRepLayout>& InRepLayout,
        const uint8* Source,
        const UObject* InRepresenting,
        struct FCustomDeltaChangelistState* InDeltaChangelistState);
 
public:
 
    ~FRepChangelistState();
 
    static const int32 MAX_CHANGE_HISTORY = 64;
 
    FRepChangedHistory ChangeHistory[MAX_CHANGE_HISTORY];
 
    TUniquePtr<struct FCustomDeltaChangelistState> CustomDeltaChangelistState;
 
    int32 HistoryStart = 0;
 
    int32 HistoryEnd = 0;
 
    int32 CompareIndex = 0;
 
    uint32 CustomDeltaChangeIndex = 0;
    
    FRepStateStaticBuffer StaticBuffer;
 
    FRepSerializationSharedInfo SharedSerialization;
 
    void CountBytes(FArchive& Ar) const;
 
#if WITH_PUSH_MODEL
 
    const UEPushModelPrivate::FPushModelPerNetDriverHandle& GetPushModelObjectHandle() const
    {
        return PushModelObjectHandle;
    }
 
    bool HasAnyDirtyProperties() const;
 
    bool HasValidPushModelHandle() const;
 
private:
    const UEPushModelPrivate::FPushModelPerNetDriverHandle PushModelObjectHandle;
#endif
};
 
class FReplicationChangelistMgr : public FNoncopyable
{
private:
 
    friend class FRepLayout;
 
    FReplicationChangelistMgr(
        const TSharedRef<const FRepLayout>& InRepLayout,
        const uint8* Source,
        const UObject* InRepresenting,
        struct FCustomDeltaChangelistState* CustomDeltaChangelistState);
 
public:
 
    ~FReplicationChangelistMgr();
 
    FRepChangelistState* GetRepChangelistState()
    {
        return &RepChangelistState;
    }
 
    const FRepChangelistState* GetRepChangelistState() const
    {
        return &RepChangelistState;
    }
 
    void CountBytes(FArchive& Ar) const;
 
private:
 
    uint32 LastReplicationFrame = 0;
    uint32 LastInitialReplicationFrame = 0;
 
    FRepChangelistState RepChangelistState;
};
 
class FReceivingRepState : public FNoncopyable
{
private:
 
    friend class FRepLayout;
 
    FReceivingRepState(FRepStateStaticBuffer&& InStaticBuffer);
 
public:
 
    void CountBytes(FArchive& Ar) const;
 
    FRepStateStaticBuffer StaticBuffer;
 
    FGuidReferencesMap GuidReferencesMap;
 
    TArray<FProperty*> RepNotifies;
 
    TMap<FProperty*, TArray<uint8>> RepNotifyMetaData;
};
 
class FSendingRepState : public FNoncopyable
{
private:
 
    friend class FRepLayout;
 
    FSendingRepState() :
        bOpenAckedCalled(false),
        HistoryStart(0),
        HistoryEnd(0),
        NumNaks(0),
        LastChangelistIndex(0),
        LastCompareIndex(0),
        InactiveChangelist({0})
    {}  
 
public:
 
    void CountBytes(FArchive& Ar) const;
 
    UE_DEPRECATED(5.4, "Use UE::Net::BuildConditionMapFromRepFlags instead")
    static inline TStaticBitArray<COND_Max> BuildConditionMapFromRepFlags(const FReplicationFlags InFlags) { return UE::Net::BuildConditionMapFromRepFlags(InFlags); }
 
    bool HasAnyPendingRetirements() const;
 
    bool bOpenAckedCalled;
 
    // Cache off the RemoteRole and Role per connection to avoid issues with
    // FScopedRoleDowngrade. See UE-66313 (among others).
 
    TEnumAsByte<ENetRole> SavedRemoteRole = ROLE_MAX;
    TEnumAsByte<ENetRole> SavedRole = ROLE_MAX;
 
    int32 HistoryStart;
 
    int32 HistoryEnd;
 
    int32 NumNaks;
 
    int32 LastChangelistIndex;
 
    int32 LastCompareIndex;
 
    uint32 CustomDeltaChangeIndex = 0;
 
    FReplicationFlags RepFlags;
 
    TSharedPtr<FRepChangedPropertyTracker> RepChangedPropertyTracker;
 
    static constexpr int32 MAX_CHANGE_HISTORY = 32;
 
    FRepChangedHistory ChangeHistory[MAX_CHANGE_HISTORY];
 
    TArray<FPropertyRetirement> Retirement;
 
    TArray<FRepChangedHistory> PreOpenAckHistory;
 
    TArray<uint16> LifetimeChangelist;
 
    TArray<uint16> InactiveChangelist;
 
    TBitArray<> InactiveParents;
 
    TArray<TSharedPtr<INetDeltaBaseState>> RecentCustomDeltaState;
 
    TArray<TSharedPtr<INetDeltaBaseState>>  CDOCustomDeltaState;
 
    TArray<TSharedPtr<INetDeltaBaseState>>  CheckpointCustomDeltaState;
};
 
class FRepState : public FNoncopyable
{
private:
 
    friend FRepLayout;
 
    FRepState() {}
 
    TUniquePtr<FReceivingRepState> ReceivingRepState;
 
    TUniquePtr<FSendingRepState> SendingRepState;
 
public:
 
    void CountBytes(FArchive& Ar) const;
 
    FReceivingRepState* GetReceivingRepState()
    {
        return ReceivingRepState.Get();
    }
 
    const FReceivingRepState* GetReceivingRepState() const
    {
        return ReceivingRepState.Get();
    }
 
    FSendingRepState* GetSendingRepState()
    {
        return SendingRepState.Get();
    }
 
    const FSendingRepState* GetSendingRepState() const
    {
        return SendingRepState.Get();
    }
};
 
enum class ECreateRepStateFlags : uint32
{
    None,
    SkipCreateReceivingState = 0x1, // Don't create a receiving RepState, as we never expect it to be used.
};
ENUM_CLASS_FLAGS(ECreateRepStateFlags);
 
enum class ERepLayoutCmdType : uint8
{
    DynamicArray            = 0,    
    Return                  = 1,    
    Property                = 2,    
 
    PropertyBool            = 3,
    PropertyFloat           = 4,
    PropertyInt             = 5,
    PropertyByte            = 6,
    PropertyName            = 7,
    PropertyObject          = 8,
    PropertyUInt32          = 9,
    PropertyVector          = 10,
    PropertyRotator         = 11,
    PropertyPlane           = 12,
    PropertyVector100       = 13,
    PropertyNetId           = 14,
    RepMovement             = 15,
    PropertyVectorNormal    = 16,
    PropertyVector10        = 17,
    PropertyVectorQ         = 18,
    PropertyString          = 19,
    PropertyUInt64          = 20,
    PropertyNativeBool      = 21,
    PropertySoftObject      = 22,
    PropertyWeakObject      = 23,
    PropertyInterface       = 24,
    NetSerializeStructWithObjectReferences = 25,
};
 
const TCHAR* LexToString(ERepLayoutCmdType CmdType);
 
enum class ERepParentFlags : uint32
{
    None                        = 0,
    IsLifetime                  = (1 << 0),  
    IsConditional               = (1 << 1),  
    IsConfig                    = (1 << 2),  
    IsCustomDelta               = (1 << 3),  
    IsNetSerialize              = (1 << 4),  
    IsStructProperty            = (1 << 5),  
    IsZeroConstructible         = (1 << 6),  
    IsFastArray                 = (1 << 7),  
    HasObjectProperties         = (1 << 8),  
    HasNetSerializeProperties   = (1 << 9),  
    HasDynamicArrayProperties   = (1 << 10), 
};
 
ENUM_CLASS_FLAGS(ERepParentFlags)
 
 
class FRepParentCmd
{
public:
 
    FRepParentCmd(FProperty* InProperty, int32 InArrayIndex): 
        Property(InProperty),
        CachedPropertyName(InProperty ? InProperty->GetFName() : NAME_None),
        ArrayIndex(InArrayIndex),
        ShadowOffset(0),
        CmdStart(0),
        CmdEnd(0),
        Condition(COND_None),
        RepNotifyCondition(REPNOTIFY_OnChanged),
        RepNotifyNumParams(INDEX_NONE),
        Flags(ERepParentFlags::None)
    {}
 
    FProperty* Property;
 
    const FName CachedPropertyName;
 
    int32 ArrayIndex;
 
    int32 Offset;
 
    int32 ShadowOffset;
 
    uint16 CmdStart;
 
    uint16 CmdEnd;
 
    ELifetimeCondition Condition;
    ELifetimeRepNotifyCondition RepNotifyCondition;
 
    int32 RepNotifyNumParams;
 
    ERepParentFlags Flags;
};
 
enum class ERepLayoutCmdFlags : uint8
{
    None                    = 0,        
    IsSharedSerialization   = (1 << 0), 
    IsStruct                = (1 << 1), 
    IsEmptyArrayStruct      = (1 << 2), 
};
 
ENUM_CLASS_FLAGS(ERepLayoutCmdFlags)
 
 
class FRepLayoutCmd
{
public:
 
    FProperty* Property;
 
    uint16 EndCmd;
 
    uint16 ElementSize;
 
    int32 Offset;
 
    int32 ShadowOffset;
 
    uint16 RelativeHandle;
 
    uint16 ParentIndex;
 
    uint32 CompatibleChecksum;
 
    ERepLayoutCmdType Type;
    ERepLayoutCmdFlags Flags;
};
    
class FHandleToCmdIndex
{
public:
    FHandleToCmdIndex():
        CmdIndex(INDEX_NONE)
    {
    }
 
    FHandleToCmdIndex(const int32 InHandleToCmdIndex):
        CmdIndex(InHandleToCmdIndex)
    {
    }
 
    FHandleToCmdIndex(FHandleToCmdIndex&& Other):
        CmdIndex(Other.CmdIndex),
        HandleToCmdIndex(MoveTemp(Other.HandleToCmdIndex))
    {
    }
 
    FHandleToCmdIndex& operator=(FHandleToCmdIndex&& Other)
    {
        if (this != &Other)
        {
            CmdIndex = Other.CmdIndex;
            HandleToCmdIndex = MoveTemp(Other.HandleToCmdIndex);
        }
 
        return *this;
    }
 
    int32 CmdIndex;
    TUniquePtr<TArray<FHandleToCmdIndex>> HandleToCmdIndex;
};
 
class FChangelistIterator
{
public:
 
    FChangelistIterator(const TArray<uint16>& InChanged, const int32 InChangedIndex):
        Changed(InChanged),
        ChangedIndex(InChangedIndex)
    {}
 
    const TArray<uint16>& Changed;
 
    int32 ChangedIndex;
};
 
class FRepHandleIterator
{
public:
 
    FRepHandleIterator(
        UStruct const * const InOwner,
        FChangelistIterator& InChangelistIterator,
        const TArray<FRepLayoutCmd>& InCmds,
        const TArray<FHandleToCmdIndex>& InHandleToCmdIndex,
        const int32 InElementSize,
        const int32 InMaxArrayIndex,
        const int32 InMinCmdIndex,
        const int32 InMaxCmdIndex
    ):
        ChangelistIterator(InChangelistIterator),
        Cmds(InCmds),
        HandleToCmdIndex(InHandleToCmdIndex),
        NumHandlesPerElement(HandleToCmdIndex.Num()),
        ArrayElementSize(InElementSize),
        MaxArrayIndex(InMaxArrayIndex),
        MinCmdIndex(InMinCmdIndex),
        MaxCmdIndex(InMaxCmdIndex),
        Owner(InOwner),
        LastSuccessfulCmdIndex(INDEX_NONE)
    {
        ensureMsgf(MaxCmdIndex >= MinCmdIndex, TEXT("Invalid Min / Max Command Indices. Owner=%s, MinCmdIndex=%d, MaxCmdIndex=%d"), *GetPathNameSafe(Owner), MinCmdIndex, MaxCmdIndex);
    }
 
    bool NextHandle();
 
    bool JumpOverArray();
 
    int32 PeekNextHandle() const;
 
    FChangelistIterator& ChangelistIterator;
 
    const TArray<FRepLayoutCmd>& Cmds;
 
    const TArray<FHandleToCmdIndex>& HandleToCmdIndex;
 
    const int32 NumHandlesPerElement;
 
    const int32 ArrayElementSize;
 
    const int32 MaxArrayIndex;
 
    const int32 MinCmdIndex;
 
    const int32 MaxCmdIndex;
 
    int32 Handle;
 
    int32 CmdIndex;
 
    int32 ArrayIndex;
 
    int32 ArrayOffset;
 
    UStruct const * const Owner;
 
private:
 
    int32 LastSuccessfulCmdIndex;
};
 
enum class ECreateReplicationChangelistMgrFlags
{
    None,
    SkipDeltaCustomState,   
};
ENUM_CLASS_FLAGS(ECreateReplicationChangelistMgrFlags);
 
enum class ECreateRepLayoutFlags
{
    None,
    MaySendProperties,  
};
ENUM_CLASS_FLAGS(ECreateRepLayoutFlags);
 
enum class ERepLayoutFlags : uint8
{
    None                                = 0,
    IsActor                             = (1 << 0), 
    PartialPushSupport                  = (1 << 1), 
    FullPushSupport                     = (1 << 2), 
    HasObjectOrNetSerializeProperties   = (1 << 3), 
    NoReplicatedProperties              = (1 << 4), 
    FullPushProperties                  = (1 << 5), 
    HasInitialOnlyProperties            = (1 << 6), 
    HasDynamicConditionProperties       = (1 << 7), 
};
ENUM_CLASS_FLAGS(ERepLayoutFlags);
 
const TCHAR* LexToString(ERepLayoutFlags Flag);
 
enum class ERepLayoutResult
{
    Success,    // Operation succeeded
    Empty,      // Operation succeeded, but didn't generate (or consume) any data.
    Error,      // Operation failed, but may succeed later.
    FatalError  // Operation failed, and connection should be terminated.
};
 
class FRepLayout : public FGCObject, public TSharedFromThis<FRepLayout>
{
private:
 
    friend struct FRepStateStaticBuffer;
    friend class UPackageMapClient;
    friend class FNetSerializeCB;
    friend struct FCustomDeltaPropertyIterator;
 
    FRepLayout();
 
public:
 
    virtual ~FRepLayout();
 
    ENGINE_API static TSharedPtr<FRepLayout> CreateFromClass(UClass* InObjectClass, const UNetConnection* ServerConnection = nullptr, const ECreateRepLayoutFlags Flags = ECreateRepLayoutFlags::None);
 
    ENGINE_API static TSharedPtr<FRepLayout> CreateFromStruct(UStruct * InStruct, const UNetConnection* ServerConnection = nullptr, const ECreateRepLayoutFlags Flags = ECreateRepLayoutFlags::None);
 
    static TSharedPtr<FRepLayout> CreateFromFunction(UFunction* InFunction, const UNetConnection* ServerConnection = nullptr, const ECreateRepLayoutFlags Flags = ECreateRepLayoutFlags::None);
 
    FRepStateStaticBuffer CreateShadowBuffer(const FConstRepObjectDataBuffer Source) const;
 
    TSharedPtr<FReplicationChangelistMgr> CreateReplicationChangelistMgr(const UObject* InObject, const ECreateReplicationChangelistMgrFlags CreateFlags) const;
 
    TUniquePtr<FRepState> CreateRepState(
        const FConstRepObjectDataBuffer Source,
        TSharedPtr<FRepChangedPropertyTracker>& InRepChangedPropertyTracker,
        ECreateRepStateFlags Flags) const;
 
    UE_DEPRECATED(5.1, "No longer used, trackers are initialized by the replication subsystem.")
    void InitChangedTracker(FRepChangedPropertyTracker * ChangedTracker) const;
 
    bool ReplicateProperties(
        FSendingRepState* RESTRICT RepState,
        FRepChangelistState* RESTRICT RepChangelistState,
        const FConstRepObjectDataBuffer Data,
        UClass* ObjectClass,
        UActorChannel* OwningChannel,
        FNetBitWriter& Writer,
        const FReplicationFlags& RepFlags) const;
 
    bool ReceiveProperties(
        UActorChannel* OwningChannel,
        UClass* InObjectClass,
        FReceivingRepState* RESTRICT RepState,
        UObject* Object,
        FNetBitReader& InBunch,
        bool& bOutHasUnmapped,
        bool& bOutGuidsChanged,
        const EReceivePropertiesFlags InFlags) const;
 
    void GatherGuidReferences(
        FReceivingRepState* RESTRICT RepState,
        struct FNetDeltaSerializeInfo& Params,
        TSet<FNetworkGUID>& OutReferencedGuids,
        int32& OutTrackedGuidMemoryBytes) const;
 
    bool MoveMappedObjectToUnmapped(
        FReceivingRepState* RESTRICT RepState,
        struct FNetDeltaSerializeInfo& Params,
        const FNetworkGUID& GUID) const;
 
    void UpdateUnmappedObjects(
        FReceivingRepState* RESTRICT RepState,
        UPackageMap* PackageMap,
        UObject* Object,
        struct FNetDeltaSerializeInfo& Params,
        bool& bCalledPreNetReceive,
        bool& bOutSomeObjectsWereMapped,
        bool& bOutHasMoreUnmapped) const;
 
    void CallRepNotifies(FReceivingRepState* RepState, UObject* Object) const;
 
    template<ERepDataBufferType DataType>
    void ValidateWithChecksum(TConstRepDataBuffer<DataType> Data, FBitArchive & Ar) const;
 
    uint32 GenerateChecksum(const FRepState* RepState) const;
 
    template<ERepDataBufferType DstType, ERepDataBufferType SrcType>
    bool DiffProperties(
        TArray<FProperty*>* RepNotifies,
        TRepDataBuffer<DstType> Destination,
        TConstRepDataBuffer<SrcType> Source,
        const EDiffPropertiesFlags Flags) const;
 
    template<ERepDataBufferType DstType, ERepDataBufferType SrcType>
    bool DiffStableProperties(
        TArray<FProperty*>* RepNotifies,
        TArray<UObject*>* ObjReferences,
        TRepDataBuffer<DstType> Destination,
        TConstRepDataBuffer<SrcType> Source) const;
 
    void ENGINE_API SendPropertiesForRPC(
        UFunction* Function,
        UActorChannel* Channel,
        FNetBitWriter& Writer,
        const FConstRepObjectDataBuffer Data) const;
 
    void ReceivePropertiesForRPC(
        UObject* Object,
        UFunction* Function,
        UActorChannel* Channel,
        FNetBitReader& Reader,
        FRepObjectDataBuffer Data,
        TSet<FNetworkGUID>& UnmappedGuids) const;
 
    void ENGINE_API BuildSharedSerializationForRPC(const FConstRepObjectDataBuffer Data, UE::Net::FNetTokenStore* NetTokenStore = nullptr);
 
    void ENGINE_API ClearSharedSerializationForRPC();
 
    // Struct support
    ENGINE_API void SerializePropertiesForStruct(
        UStruct* Struct,
        FBitArchive& Ar,
        UPackageMap* Map,
        FRepObjectDataBuffer Data,
        bool& bHasUnmapped,
        const UObject* OwningObject = nullptr) const;
 
    ENGINE_API void SerializeObjectReplicatedProperties(UObject* Object, FBitArchive & Ar) const;
 
    UObject* GetOwner() const { return Owner; }
 
    void SendProperties_BackwardsCompatible(
        FSendingRepState* RESTRICT RepState,
        FRepChangedPropertyTracker* ChangedTracker,
        const FConstRepObjectDataBuffer Data,
        UNetConnection* Connection,
        FNetBitWriter& Writer,
        TArray<uint16>& Changed) const;
 
    bool ReceiveProperties_BackwardsCompatible(
        UNetConnection* Connection,
        FReceivingRepState* RESTRICT RepState,
        FRepObjectDataBuffer Data,
        FNetBitReader& InBunch,
        bool& bOutHasUnmapped,
        const bool bEnableRepNotifies,
        bool& bOutGuidsChanged,
        UObject* OwningObject = nullptr) const;
 
    //~ Begin FGCObject Interface
    ENGINE_API virtual void AddReferencedObjects(FReferenceCollector& Collector) override;
    ENGINE_API virtual FString GetReferencerName() const override;
    //~ End FGCObject Interface
 
    template<typename T>
    T* GetShadowStateValue(FRepShadowDataBuffer Data, const FName PropertyName)
    {
        for (const FRepParentCmd& Parent : Parents)
        {
            if (Parent.CachedPropertyName == PropertyName)
            {
                return (T*)((Data + Parent).Data);
            }
        }
 
        return nullptr;
    }
 
    template<typename T>
    const T* GetShadowStateValue(FConstRepShadowDataBuffer Data, const FName PropertyName) const
    {
        for (const FRepParentCmd& Parent : Parents)
        {
            if (Parent.CachedPropertyName == PropertyName)
            {
                return (const T*)((Data + Parent).Data);
            }
        }
 
        return nullptr;
    }
 
    const ERepLayoutFlags GetFlags() const
    {
        return Flags;
    }
 
    const bool IsEmpty() const
    {
        return EnumHasAnyFlags(Flags, ERepLayoutFlags::NoReplicatedProperties) || (0 == Parents.Num());
    }
 
    const int32 GetNumParents() const
    {
        return Parents.Num();
    }
 
    const FProperty* GetParentProperty(int32 Index) const
    { 
        return Parents.IsValidIndex(Index) ? Parents[Index].Property : nullptr;
    }
 
    const int32 GetParentArrayIndex(int32 Index) const
    {
        return Parents.IsValidIndex(Index) ? Parents[Index].ArrayIndex : 0;
    }
 
    const int32 GetParentCondition(int32 Index) const
    {
        return Parents.IsValidIndex(Index) ? Parents[Index].Condition : COND_None;
    }
 
    const bool IsCustomDeltaProperty(int32 Index) const
    {
        return Parents.IsValidIndex(Index) ? EnumHasAnyFlags(Parents[Index].Flags, ERepParentFlags::IsCustomDelta) : false;
    }
 
#if WITH_PUSH_MODEL
    const bool IsPushModelProperty(int32 Index) const
    {
        return PushModelProperties.IsValidIndex(Index) ? PushModelProperties[Index] : false;
    }
#endif
 
    const uint16 GetCustomDeltaIndexFromPropertyRepIndex(const uint16 PropertyRepIndex) const;
 
    void CountBytes(FArchive& Ar) const;
 
private:
 
    void InitFromClass(UClass* InObjectClass, const UNetConnection* ServerConnection, const ECreateRepLayoutFlags Flags);
 
    void InitFromStruct(UStruct* InStruct, const UNetConnection* ServerConnection, const ECreateRepLayoutFlags Flags);
 
    void InitFromFunction(UFunction* InFunction, const UNetConnection* ServerConnection, const ECreateRepLayoutFlags Flags);
 
    ERepLayoutResult CompareProperties(
        FSendingRepState* RESTRICT RepState,
        FRepChangelistState* RESTRICT RepChangelistState,
        const FConstRepObjectDataBuffer Data,
        const FReplicationFlags& RepFlags,
        const bool bForceCompare) const;
 
    void SendProperties(
        FSendingRepState* RESTRICT RepState,
        FRepChangedPropertyTracker* ChangedTracker,
        const FConstRepObjectDataBuffer Data,
        UClass* ObjectClass,
        FNetBitWriter& Writer,
        TArray<uint16>& Changed,
        const FRepSerializationSharedInfo& SharedInfo,
        const ESerializePropertyType SerializePropertyType) const;
 
    void PruneChangeList(
        const FConstRepObjectDataBuffer Data,
        const TArray<uint16>& Changed,
        TArray<uint16>& PrunedChanged) const;
 
    void MergeChangeList(
        const FConstRepObjectDataBuffer Data,
        const TArray<uint16>& Dirty1,
        const TArray<uint16>& Dirty2,
        TArray<uint16>& MergedDirty) const;
 
    void RebuildConditionalProperties(
        FSendingRepState* RepState,
        const FReplicationFlags RepFlags) const;
 
    void UpdateChangelistHistory(
        FSendingRepState* RepState,
        UClass* ObjectClass,
        const FConstRepObjectDataBuffer Data,
        UNetConnection* Connection,
        TArray<uint16>* OutMerged) const;
 
    void SendProperties_BackwardsCompatible_r(
        FSendingRepState* RESTRICT RepState,
        UPackageMapClient* PackageMapClient,
        FNetFieldExportGroup* NetFieldExportGroup,
        FRepChangedPropertyTracker* ChangedTracker,
        FNetBitWriter& Writer,
        const bool bDoChecksum,
        FRepHandleIterator& HandleIterator,
        const FConstRepObjectDataBuffer Source) const;
 
    void SendAllProperties_BackwardsCompatible_r(
        FSendingRepState* RESTRICT RepState,
        FNetBitWriter& Writer,
        const bool bDoChecksum,
        UPackageMapClient* PackageMapClient,
        FNetFieldExportGroup* NetFieldExportGroup,
        const int32 CmdStart,
        const int32 CmdEnd,
        const FConstRepObjectDataBuffer SourceData) const;
 
    void SendProperties_r(
        FSendingRepState* RESTRICT RepState,
        FNetBitWriter& Writer,
        const bool bDoChecksum,
        FRepHandleIterator& HandleIterator,
        const FConstRepObjectDataBuffer SourceData,
        const int32  ArrayDepth,
        const FRepSerializationSharedInfo* const RESTRICT SharedInfo,
        const ESerializePropertyType SerializePropertyType) const;
 
    void BuildSharedSerialization(
        const FConstRepObjectDataBuffer Data,
        TArray<uint16>& Changed,
        const bool bWriteHandle,
        FRepSerializationSharedInfo& SharedInfo, 
        UE::Net::FNetTokenStore* NetTokenStore = nullptr) const;
 
    void BuildSharedSerialization_r(
        FRepHandleIterator& RepHandleIterator,
        const FConstRepObjectDataBuffer SourceData,
        const bool bWriteHandle,
        const bool bDoChecksum,
        const int32 ArrayDepth,
        FRepSerializationSharedInfo& SharedInfo) const;
 
    void BuildSharedSerializationForRPC_DynamicArray_r(
        const int32 CmdIndex,
        const FConstRepObjectDataBuffer Data,
        int32 ArrayDepth,
        FRepSerializationSharedInfo& SharedInfo);
 
    void BuildSharedSerializationForRPC_r(
        const int32 CmdStart,
        const int32 CmdEnd,
        const FConstRepObjectDataBuffer Data,
        int32 ArrayIndex,
        int32 ArrayDepth,
        FRepSerializationSharedInfo& SharedInfo);
 
    TSharedPtr<FNetFieldExportGroup> CreateNetfieldExportGroup() const;
 
    int32 FindCompatibleProperty(
        const int32 CmdStart,
        const int32 CmdEnd,
        const uint32 Checksum) const;
 
    bool ReceiveProperties_BackwardsCompatible_r(
        FReceivingRepState* RESTRICT RepState,
        FNetFieldExportGroup* NetFieldExportGroup,
        FNetBitReader& Reader,
        const int32 CmdStart,
        const int32 CmdEnd,
        FRepShadowDataBuffer ShadowData,
        FRepObjectDataBuffer OldData,
        FRepObjectDataBuffer Data,
        FGuidReferencesMap* GuidReferencesMap,
        bool& bOutHasUnmapped,
        bool& bOutGuidsChanged,
        UObject* OwningObject) const;
 
    void GatherGuidReferences_r(
        const FGuidReferencesMap* GuidReferencesMap,
        TSet<FNetworkGUID>& OutReferencedGuids,
        int32& OutTrackedGuidMemoryBytes) const;
 
    bool MoveMappedObjectToUnmapped_r(
        FGuidReferencesMap* GuidReferencesMap,
        const FNetworkGUID& GUID,
        const UObject* const OwningObject) const;
 
    void UpdateUnmappedObjects_r(
        FReceivingRepState* RESTRICT RepState, 
        FGuidReferencesMap* GuidReferencesMap,
        UObject* OriginalObject,
        UNetConnection* Connection,
        FRepShadowDataBuffer ShadowData, 
        FRepObjectDataBuffer Data, 
        const int32 MaxAbsOffset,
        bool& bCalledPreNetReceive,
        bool& bOutSomeObjectsWereMapped,
        bool& bOutHasMoreUnmapped) const;
 
    void SanityCheckChangeList_DynamicArray_r(
        const int32 CmdIndex, 
        const FConstRepObjectDataBuffer Data, 
        TArray<uint16>& Changed,
        int32& ChangedIndex) const;
 
    uint16 SanityCheckChangeList_r(
        const int32 CmdStart, 
        const int32 CmdEnd, 
        const FConstRepObjectDataBuffer Data, 
        TArray<uint16>& Changed,
        int32& ChangedIndex,
        uint16 Handle) const;
 
    void SanityCheckChangeList(const FConstRepObjectDataBuffer Data, TArray<uint16>& Changed) const;
 
    void SerializeProperties_DynamicArray_r(
        FBitArchive& Ar, 
        UPackageMap* Map,
        const int32 CmdIndex,
        FRepObjectDataBuffer Data,
        bool& bHasUnmapped,
        const int32 ArrayDepth,
        const FRepSerializationSharedInfo& SharedInfo,
        FNetTraceCollector* Collector,
        const UObject* OwningObject) const;
 
    void SerializeProperties_r(
        FBitArchive& Ar, 
        UPackageMap* Map,
        const int32 CmdStart, 
        const int32 CmdEnd, 
        FRepObjectDataBuffer Data,
        bool& bHasUnmapped,
        const int32 ArrayIndex,
        const int32 ArrayDepth,
        const FRepSerializationSharedInfo& SharedInfo,
        FNetTraceCollector* Collector,
        const UObject* OwningObject) const;
 
    void MergeChangeList_r(
        FRepHandleIterator& RepHandleIterator1,
        FRepHandleIterator& RepHandleIterator2,
        const FConstRepObjectDataBuffer SourceData,
        TArray<uint16>& OutChanged) const;
 
    void PruneChangeList_r(
        FRepHandleIterator& RepHandleIterator,
        const FConstRepObjectDataBuffer SourceData,
        TArray<uint16>& OutChanged) const;
 
    void FilterChangeList( 
        const TArray<uint16>& Changelist,
        const TBitArray<>& InactiveParentHandles,
        TArray<uint16>& OutInactiveProperties,
        TArray<uint16>& OutActiveProperties) const;
 
    void FilterChangeListToActive(
        const TArray<uint16>& Changelist,
        const TBitArray<>& InactiveParentHandles,
        TArray<uint16>& OutActiveProperties) const;
 
    void BuildChangeList_r(
        const TArray<FHandleToCmdIndex>& HandleToCmdIndex,
        const int32 CmdStart,
        const int32 CmdEnd,
        const FConstRepObjectDataBuffer Data,
        const int32 HandleOffset,
        const bool bForceArraySends,
        TArray<uint16>& Changed) const;
 
    void BuildHandleToCmdIndexTable_r(
        const int32 CmdStart,
        const int32 CmdEnd,
        TArray<FHandleToCmdIndex>& HandleToCmdIndex);
 
    ERepLayoutResult UpdateChangelistMgr(
        FSendingRepState* RESTRICT RepState,
        FReplicationChangelistMgr& InChangelistMgr,
        const UObject* InObject,
        const uint32 ReplicationFrame,
        const FReplicationFlags& RepFlags,
        const bool bForceCompare) const;
 
    void InitRepStateStaticBuffer(FRepStateStaticBuffer& ShadowData, const FConstRepObjectDataBuffer Source) const;
    void ConstructProperties(FRepStateStaticBuffer& ShadowData) const;
    void CopyProperties(FRepStateStaticBuffer& ShadowData, const FConstRepObjectDataBuffer Source) const;
    void DestructProperties(FRepStateStaticBuffer& RepStateStaticBuffer) const;
 
    bool SendCustomDeltaProperty(FNetDeltaSerializeInfo& Params, const uint16 CustomDeltaIndex) const;
 
    bool ReceiveCustomDeltaProperty(
        FReceivingRepState* RESTRICT ReceivingRepState,
        FNetDeltaSerializeInfo& Params,
        FStructProperty* Property) const;
 
    ERepLayoutResult DeltaSerializeFastArrayProperty(struct FFastArrayDeltaSerializeParams& Params, FReplicationChangelistMgr* ChangelistMgr) const;
 
    void GatherGuidReferencesForFastArray(struct FFastArrayDeltaSerializeParams& Params) const;
 
    bool MoveMappedObjectToUnmappedForFastArray(struct FFastArrayDeltaSerializeParams& Params) const;
 
    void UpdateUnmappedGuidsForFastArray(struct FFastArrayDeltaSerializeParams& Params) const;
 
    void PreSendCustomDeltaProperties(
        UObject* Object,
        UNetConnection* Connection,
        FReplicationChangelistMgr& ChangelistMgr,
        uint32 ReplicationFrame,
        TArray<TSharedPtr<INetDeltaBaseState>>& CustomDeltaStates) const;
 
    void PostSendCustomDeltaProperties(
        UObject* Object,
        UNetConnection* Connection,
        FReplicationChangelistMgr& ChangelistMgr,
        TArray<TSharedPtr<INetDeltaBaseState>>& CustomDeltaStates) const;
 
    const uint16 GetNumLifetimeCustomDeltaProperties() const;
 
    const uint16 GetLifetimeCustomDeltaPropertyRepIndex(const uint16 RepIndCustomDeltaPropertyIndex) const;
 
    FProperty* GetLifetimeCustomDeltaProperty(const uint16 CustomDeltaPropertyIndex) const;
 
    const ELifetimeCondition GetLifetimeCustomDeltaPropertyCondition(const uint16 RepIndCustomDeltaPropertyIndex) const;
 
    ERepLayoutFlags Flags;
 
    int32 ShadowDataBufferSize;
 
    TArray<FRepParentCmd> Parents;
 
    TArray<FRepLayoutCmd> Cmds;
 
    TArray<FHandleToCmdIndex> BaseHandleToCmdIndex;
 
    TUniquePtr<struct FLifetimeCustomDeltaState> LifetimeCustomPropertyState;
 
    UStruct* Owner;
 
    FRepSerializationSharedInfo SharedInfoRPC;
 
    TBitArray<> SharedInfoRPCParentsChanged;
 
#if WITH_PUSH_MODEL
    TBitArray<> PushModelProperties;
#endif
 
    TMap<FRepLayoutCmd*, TArray<FRepLayoutCmd>> NetSerializeLayouts;
};