DataReplication.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    DataReplication.h:
    Holds classes for data replication (properties and RPCs).
=============================================================================*/
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/NetworkGuid.h"
#include "UObject/CoreNet.h"
#include "Engine/EngineTypes.h"
#include "UObject/UnrealType.h"
#include "UObject/GCObject.h"
#include "HAL/LowLevelMemTracker.h"
 
LLM_DECLARE_TAG_API(NetObjReplicator, ENGINE_API);
 
class FNetFieldExportGroup;
class FOutBunch;
class FRepChangelistState;
class FRepLayout;
class FRepState;
class FSendingRepState;
class UNetConnection;
class UNetDriver;
class AActor;
 
bool inline IsCustomDeltaProperty(const FStructProperty* StructProperty)
{
    return EnumHasAnyFlags(StructProperty->Struct->StructFlags, STRUCT_NetDeltaSerializeNative);
}
 
bool inline IsCustomDeltaProperty(const FProperty* Property)
{
    const FStructProperty* StructProperty = CastField<FStructProperty>(Property);
    return StructProperty && IsCustomDeltaProperty(StructProperty);
}
 
struct FReplicatedActorProperty
{
    int32 Offset;
 
    const class FObjectPropertyBase* Property;
 
    FReplicatedActorProperty(int32 InOffset, const FObjectPropertyBase* InProperty)
        : Offset(InOffset)
        , Property(InProperty)
    {}
};
 
class FObjectReplicator
{
public:
 
    enum class ESkipRpcBehavior
    {
        // Always execute RPCs immediately
        NeverSkip,
 
        // Skip RPC execution only if it's not ready to execute
        SkipIfNotReady,
 
        // Always skip execution of RPC (do validation only, caller will handle execution)
        AlwaysSkip
    };
 
    ENGINE_API FObjectReplicator();
    ENGINE_API ~FObjectReplicator();
 
    struct FRPCCallInfo 
    {
        FName FuncName;
        int32 Calls;
        double LastCallTimestamp;
    };
 
    struct FRPCPendingLocalCall
    {
        int32 RPCFieldIndex;
 
        FReplicationFlags RepFlags;
 
        TArray<uint8> Buffer;
 
        int64 NumBits;
 
        uint32 FrameQueuedAt;
 
        TSet<FNetworkGUID> UnmappedGuids;
 
        FRPCPendingLocalCall(
            const FFieldNetCache* InRPCField,
            const FReplicationFlags& InRepFlags,
            FNetBitReader& InReader,
            uint32 InReplicationFrame,
            const TSet<FNetworkGUID>& InUnmappedGuids)
            : RPCFieldIndex(InRPCField->FieldNetIndex)
            , RepFlags(InRepFlags)
            , Buffer(InReader.GetBuffer())
            , NumBits(InReader.GetNumBits())
            , FrameQueuedAt(InReplicationFrame)
            , UnmappedGuids(InUnmappedGuids)
        {}
 
        void CountBytes(FArchive& Ar) const;
    };
 
    ENGINE_API void InitWithObject(
        UObject* InObject,
        UNetConnection* InConnection,
        bool bUseDefaultState = true);
 
    ENGINE_API void CleanUp();
 
    ENGINE_API void StartReplicating(class UActorChannel* InActorChannel);
    ENGINE_API void StopReplicating(class UActorChannel* InActorChannel);
 
    ENGINE_API void InitRecentProperties(uint8* Source);
 
    ENGINE_API bool ValidateAgainstState(const UObject* ObjectState);
 
    //~ Both of these should be private, IMO, but we'll leave them public for now for back compat
    //~ in case anyone was using SerializeCustomDeltaProperty already.
    ENGINE_API bool SendCustomDeltaProperty(
        UObject* InObject,
        uint16 CustomDeltaProperty,
        FNetBitWriter& OutBunch,
        TSharedPtr<INetDeltaBaseState>& NewFullState,
        TSharedPtr<INetDeltaBaseState>& OldState);
 
    ENGINE_API void ReceivedNak(int32 NakPacketId);
 
    ENGINE_API void CountBytes(FArchive& Ar) const;
 
    ENGINE_API void ReplicateCustomDeltaProperties(FNetBitWriter& Bunch, FReplicationFlags RepFlags, bool& bSkippedPropertyCondition);
    ENGINE_API bool ReplicateProperties(FOutBunch& Bunch, FReplicationFlags RepFlags);
    ENGINE_API bool ReplicateProperties(FOutBunch& Bunch, FReplicationFlags RepFlags, FNetBitWriter& Writer);
    ENGINE_API bool ReplicateProperties_r(FOutBunch& Bunch, FReplicationFlags RepFlags, FNetBitWriter& Writer);
 
    ENGINE_API void PostSendBunch(FPacketIdRange& PacketRange, uint8 bReliable);
 
    ENGINE_API bool ReceivedBunch(
        FNetBitReader& Bunch,
        const FReplicationFlags& RepFlags,
        const bool bHasRepLayout,
        bool& bOutHasUnmapped);
 
    ENGINE_API bool ReceivedRPC(
        FNetBitReader& Reader,
        TSet<FNetworkGUID>& OutUnmappedGuids,
        bool& bOutSkippedRpcExec,
        const FReplicationFlags& RepFlags,
        const FFieldNetCache* FieldCache,
        ESkipRpcBehavior SkipRpcBehavior);
 
    inline bool ReceivedRPC(
        FNetBitReader& Reader,
        const FReplicationFlags& RepFlags,
        const FFieldNetCache* FieldCache,
        const bool bCanDelayRPC,
        bool& bOutDelayRPC,
        TSet<FNetworkGUID>& OutUnmappedGuids)
    {
        return ReceivedRPC(Reader, OutUnmappedGuids, bOutDelayRPC, RepFlags, FieldCache, bCanDelayRPC ? ESkipRpcBehavior::SkipIfNotReady : ESkipRpcBehavior::NeverSkip);
    }
 
    ENGINE_API void UpdateGuidToReplicatorMap();
    ENGINE_API bool MoveMappedObjectToUnmapped(const FNetworkGUID& GUID);
    ENGINE_API void PostReceivedBunch();
 
    ENGINE_API void ForceRefreshUnreliableProperties();
 
    ENGINE_API void QueueRemoteFunctionBunch(UFunction* Func, FOutBunch &Bunch);
 
    ENGINE_API bool ReadyForDormancy(bool bDebug=false);
 
    ENGINE_API void StartBecomingDormant();
 
    ENGINE_API void CallRepNotifies(bool bSkipIfChannelHasQueuedBunches) const;
 
    ENGINE_API void UpdateUnmappedObjects(bool& bOutHasMoreUnmapped);
 
    ENGINE_API void ExecutePendingTransactionalRPCs();
 
    inline TWeakObjectPtr<UObject>  GetWeakObjectPtr() const
    {
        return WeakObjectPtr;
    }
 
    inline UObject* GetObject() const
    {
        // If this replicator is dormant we have released our strong ref but the object may still be alive.
        return ObjectPtr ? ObjectPtr : WeakObjectPtr.Get();
    }
 
    inline void SetObject(UObject* NewObj)
    {
        ObjectPtr = NewObj;
        WeakObjectPtr = NewObj;
    }
 
    void ReleaseStrongReference()
    {
        ObjectPtr = nullptr;
    }
 
    inline void PreNetReceive()
    { 
        UObject* Object = GetObject();
        if ( Object != NULL )
        {
            Object->PreNetReceive();
        }
    }
 
    inline void PostNetReceive()
    { 
        UObject* Object = GetObject();
        if ( Object != NULL )
        {
            Object->PostNetReceive();
        }
    }
 
    ENGINE_API void QueuePropertyRepNotify(
        UObject* Object,
        FProperty* Property,
        const int32 ElementIndex,
        TArray<uint8>& MetaData);
        
    ENGINE_API void WritePropertyHeaderAndPayload(
        UObject* Object,
        FProperty*              Property,
        FNetFieldExportGroup* NetFieldExportGroup,
        FNetBitWriter& Bunch,
        FNetBitWriter& Payload) const;  
 
    ENGINE_API bool CanSkipUpdate(FReplicationFlags Flags);
 
    bool IsDirtyForReplay() const { return bDirtyForReplay; }
    void ResetReplayDirtyTracking() { bDirtyForReplay = true; }
 
public:
 
    FNetworkGUID ObjectNetGUID;
 
    int32 TrackedGuidMemoryBytes;
 
    uint32 bLastUpdateEmpty : 1;
 
    uint32 bOpenAckCalled : 1;
 
    uint32 bForceUpdateUnmapped : 1;
 
    uint32 bHasReplicatedProperties : 1;
    
    uint32 bSentSubObjectCreation : 1;
 
private:
 
    uint32 bSupportsFastArrayDelta : 1;
 
    uint32 bCanUseNonDirtyOptimization : 1;
 
    uint32 bDirtyForReplay : 1;
 
public:
    
    TSharedPtr<class FReplicationChangelistMgr> ChangelistMgr;
    TSharedPtr<FRepLayout> RepLayout;
    TUniquePtr<FRepState>  RepState;
    TUniquePtr<FRepState> CheckpointRepState;
 
    TObjectPtr<UClass> ObjectClass;
 
    UObject* ObjectPtr;
 
    UNetConnection* Connection;
 
    class UActorChannel* OwningChannel;
 
    FOutBunch* RemoteFunctions;
 
    TArray<FRPCCallInfo> RemoteFuncInfo;
 
    TArray<FRPCPendingLocalCall> PendingLocalRPCs;
 
    //~ RepNotify properties were moved to FReceivingRepState.
    //~ CustomDeltaState properties were moved to FSendingRepState.
    //~ Retirement properties were moved to FSendingRepState.
 
    TSet<FNetworkGUID> ReferencedGuids;
 
private:
    TWeakObjectPtr<UObject> WeakObjectPtr;
 
    TArray<FRPCPendingLocalCall> PendingTransactionalRPCs;
 
    static void CallProcessEventForReceivedRPC(UObject* Object, UFunction* Function, uint8* Params);
};
 
class FScopedActorRoleSwap
{
public:
    ENGINE_API FScopedActorRoleSwap(AActor* InActor);
    ENGINE_API ~FScopedActorRoleSwap();
 
    FScopedActorRoleSwap(const FScopedActorRoleSwap&) = delete;
    FScopedActorRoleSwap& operator=(const FScopedActorRoleSwap&) = delete;
 
    FScopedActorRoleSwap(FScopedActorRoleSwap&& Other)
    {
        Actor = Other.Actor;
        Other.Actor = nullptr;
    }
    FScopedActorRoleSwap& operator=(FScopedActorRoleSwap&& Other)
    {
        Actor = Other.Actor;
        Other.Actor = nullptr;
        return *this;
    }
 
private:
    AActor* Actor;
};