ReplicationBridge.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/ContainersFwd.h"
#include "Containers/Map.h"
 
#include "HAL/Platform.h"
 
#include "Iris/Core/NetObjectReference.h"
 
#include "Iris/IrisConfig.h"
 
#include "Iris/ReplicationSystem/NetObjectFactory.h"
#include "Iris/ReplicationSystem/NetObjectFactoryRegistry.h"
#include "Iris/ReplicationSystem/NetObjectGroupHandle.h"
#include "Iris/ReplicationSystem/NetRefHandle.h"
#include "Iris/ReplicationSystem/ObjectReferenceTypes.h"
#include "Iris/ReplicationSystem/ReplicationBridgeTypes.h"
 
#include "Misc/EnumClassFlags.h"
 
#include "Net/Core/NetHandle/NetHandle.h"
 
#include "UObject/ObjectKey.h"
#include "UObject/ObjectMacros.h"
 
#include "ReplicationBridge.generated.h"
 
class UObjectReplicationBridge;
class UReplicationSystem;
class UNetDriver;
 
namespace UE::Net
{
    enum class ENetRefHandleError : uint32;
 
    struct FNetDependencyInfo;
    struct FReplicationInstanceProtocol;
    struct FReplicationProtocol;
 
    class FNetBitStreamReader;
    class FNetBitStreamWriter;
    class FNetSerializationContext;
    class FNetTokenStoreState;  
    class FReplicationFragment;
 
    namespace Private
    {
        typedef uint32 FInternalNetRefIndex;
        class FNetRefHandleManager;
        class FNetObjectGroups;
        class FNetPushObjectHandle;
        class FObjectReferenceCache;
        class FReplicationProtocolManager;
        class FReplicationReader;
        class FReplicationStateDescriptorRegistry;
        class FReplicationSystemImpl;
        class FReplicationSystemInternal;
        class FReplicationWriter;
        
        struct FChangeMaskCache;
        struct FCreateNetObjectParams;
        struct FAsyncLoadingSimulator;
    }
 
    typedef TArray<FNetDependencyInfo, TInlineAllocator<32> > FNetDependencyInfoArray;
}
 
#define UE_LOG_BRIDGEID(Category, Verbosity, Format, ...)  UE_LOG(Category, Verbosity, TEXT("RepBridge(%u)::") Format, GetReplicationSystem()->GetId(), ##__VA_ARGS__)
 
struct FReplicationBridgeSerializationContext
{
    FReplicationBridgeSerializationContext(UE::Net::FNetSerializationContext& InSerialiazationContext, uint32 InConnectionId, bool bInIsDestructionInfo = false);
 
    UE::Net::FNetSerializationContext& SerializationContext;
    uint32 ConnectionId;
    bool bIsDestructionInfo;
};
 
//------------------------------------------------------------------------
 
namespace UE::Net
{
    struct FDestructionParameters
    {
        FVector Location;
        const UObject* Level = nullptr;
        bool bUseDistanceBasedPrioritization = false;
        UE::Net::FNetObjectFactoryId NetFactoryId = UE::Net::InvalidNetObjectFactoryId;
    };
 
    enum class ESubObjectInsertionOrder : uint8
    {
        None,
        ReplicateWith,
        InsertAtStart,
    };
 
} // end namespace UE::Net
 
//------------------------------------------------------------------------
UCLASS(Transient, MinimalAPI)
class UReplicationBridge : public UObject
{
    GENERATED_BODY()
 
protected:
    using FNetHandle = UE::Net::FNetHandle;
    using FNetRefHandle = UE::Net::FNetRefHandle;
    using FNetDependencyInfoArray = UE::Net::FNetDependencyInfoArray;
 
public:
    IRISCORE_API UReplicationBridge();
    IRISCORE_API virtual ~UReplicationBridge();
 
 
    IRISCORE_API void StopReplicatingNetRefHandle(FNetRefHandle Handle, EEndReplicationFlags EndReplicationFlags);
 
    IRISCORE_API bool IsReplicatedHandle(FNetRefHandle Handle) const;
 
    IRISCORE_API UE::Net::FNetObjectGroupHandle GetLevelGroup(const UObject* Level) const;
 
    IRISCORE_API const TMap<FObjectKey, UE::Net::FNetObjectGroupHandle>& GetAllLevelGroups() const;
 
    bool IsInReceiveUpdate() const { return bInReceiveUpdate; }
 
    [[nodiscard]] IRISCORE_API FString PrintObjectFromNetRefHandle(FNetRefHandle RefHandle) const;
 
protected:
    IRISCORE_API virtual void Initialize(UReplicationSystem* InReplicationSystem);
 
    IRISCORE_API virtual void Deinitialize();
 
    virtual void PreSendUpdate() {}
 
    virtual void OnStartPreSendUpdate() {}
    
    virtual void OnPostSendUpdate() {}
 
    virtual void OnPostReceiveUpdate() {}
    
    virtual void PreSendUpdateSingleHandle(FNetRefHandle Handle) {}
 
    virtual void UpdateInstancesWorldLocation() {}
 
    // Remote interface, invoked from Replication code during serialization
    
    IRISCORE_API virtual bool CacheNetRefHandleCreationInfo(FNetRefHandle Handle);
 
    IRISCORE_API virtual void DetachInstance(FNetRefHandle Handle);
 
    IRISCORE_API virtual void PruneStaleObjects();
 
    IRISCORE_API virtual void GetInitialDependencies(FNetRefHandle Handle, FNetDependencyInfoArray& OutDependencies) const;
 
    virtual bool CanCreateDestructionInfo() const { return true; }
 
    void PreSeamlessTravelGarbageCollect();
 
    void PostSeamlessTravelGarbageCollect();
 
protected:
 
    // Forward calls to internal operations that we allow replication bridges to access
 
    IRISCORE_API FNetRefHandle InternalCreateNetObject(FNetRefHandle AllocatedHandle, FNetHandle GlobalHandle, const UE::Net::Private::FCreateNetObjectParams& Params);
 
    IRISCORE_API FNetRefHandle InternalCreateNetObjectFromRemote(FNetRefHandle WantedNetHandle, const UE::Net::Private::FCreateNetObjectParams& Params);
 
    IRISCORE_API void InternalAttachInstanceToNetRefHandle(FNetRefHandle RefHandle, bool bBindInstanceProtocol, UE::Net::FReplicationInstanceProtocol* InstanceProtocol, UObject* Instance, FNetHandle NetHandle);
 
    IRISCORE_API void InternalDetachInstanceFromNetRefHandle(UE::Net::Private::FInternalNetRefIndex InternalObjectIndex);
 
    IRISCORE_API void InternalDestroyNetObject(FNetRefHandle Handle);
    
    IRISCORE_API void InternalAddSubObject(FNetRefHandle OwnerHandle, FNetRefHandle SubObjectHandle, FNetRefHandle InsertRelativeToSubObjectHandle, UE::Net::ESubObjectInsertionOrder InsertionOrder);
 
    inline UE::Net::Private::FReplicationProtocolManager* GetReplicationProtocolManager() const { return ReplicationProtocolManager; }
    inline UReplicationSystem* GetReplicationSystem() const { return ReplicationSystem; }
    inline UE::Net::Private::FReplicationStateDescriptorRegistry* GetReplicationStateDescriptorRegistry() const { return ReplicationStateDescriptorRegistry; }
    inline UE::Net::Private::FObjectReferenceCache* GetObjectReferenceCache() const { return ObjectReferenceCache; }
 
    IRISCORE_API UE::Net::FNetObjectFactoryId GetNetObjectFactoryId(FNetRefHandle RefHandle) const;
 
    IRISCORE_API UE::Net::FNetObjectGroupHandle CreateLevelGroup(const UObject* Level, FName PackageName);
 
    IRISCORE_API void DestroyLevelGroup(const UObject* Level);
 
    IRISCORE_API virtual bool IsAllowedToDestroyInstance(const UObject* Instance) const;
 
    virtual void OnProtocolMismatchReported(FNetRefHandle RefHandle, uint32 ConnectionId) {}
 
    virtual void OnErrorWithNetRefHandleReported(UE::Net::ENetRefHandleError ErrorType, FNetRefHandle RefHandle, uint32 ConnectionId, const TArray<FNetRefHandle>& ExtraNetRefHandle) {}
 
    IRISCORE_API virtual void OnPreSeamlessTravelGarbageCollect();
 
    IRISCORE_API virtual void OnPostSeamlessTravelGarbageCollect();
 
    virtual void RemoveDestructionInfosForGroup(UE::Net::FNetObjectGroupHandle GroupHandle) {}
 
private:
 
    // Internal operations invoked by ReplicationSystem/ReplicationWriter
    
    enum class EPendingEndReplicationImmediate : uint8
    {
        Yes,
        No,
    };
 
    // Adds the Handle to the list of handles pending deferred EndReplication, if bIsImmediate is true the object will be destroyed after the next update, otherwise
    // it will be kept around until the handle is no longer ref-counted by any connection. It will however be removed from the set of scopeable objects after the first update so new connections will not add it to their scope.
    void AddPendingEndReplication(FNetRefHandle Handle, EEndReplicationFlags DestroyFlags, EPendingEndReplicationImmediate Immediate = EPendingEndReplicationImmediate::No);
 
    void CallPreSendUpdate(float DeltaSeconds);
    void CallPreSendUpdateSingleHandle(FNetRefHandle Handle);
    void CallUpdateInstancesWorldLocation();
    bool CallCacheNetRefHandleCreationInfo(FNetRefHandle Handle);
    void CallPruneStaleObjects();
    void CallDetachInstance(FNetRefHandle Handle);
 
    void PreReceiveUpdate();
    void PostReceiveUpdate();
 
private:
 
    void InternalFlushStateData(UE::Net::FNetSerializationContext& SerializationContext, UE::Net::Private::FChangeMaskCache& ChangeMaskCache, UE::Net::FNetBitStreamWriter& ChangeMaskWriter, uint32 InternalObjectIndex);
    // Internal method to copy state data for Handle
    void InternalFlushStateData(FNetRefHandle Handle);
 
    // Internal method to copy state data for Handle and any SubObjects and mark them as being torn-off
    void InternalTearOff(FNetRefHandle OwnerHandle);
 
    // Destroy all SubObjects owned by provided handle
    void InternalDestroySubObjects(FNetRefHandle OwnerHandle, EEndReplicationFlags Flags);
 
    void NotifyStreamingLevelUnload(const UObject* Level);
 
    void DestroyLocalNetHandle(FNetRefHandle Handle, EEndReplicationFlags Flags);
 
    // Tear-off all handles in the PendingTearOff list that has not yet been torn-off
    void TearOffHandlesPendingTearOff();
 
    // Update all the handles pending EndReplication
    void UpdateHandlesPendingEndReplication();
 
    void SetNetPushIdOnFragments(const TArrayView<const UE::Net::FReplicationFragment*const>& Fragments, const UE::Net::Private::FNetPushObjectHandle& PushHandle);
    void ClearNetPushIdOnFragments(const TArrayView<const UE::Net::FReplicationFragment*const>& Fragments);
 
    void DestroyGlobalNetHandle(UE::Net::Private::FInternalNetRefIndex InternalReplicationIndex);
    void ClearNetPushIds(UE::Net::Private::FInternalNetRefIndex InternalReplicationIndex);
 
    friend UE::Net::Private::FReplicationSystemImpl;
    friend UE::Net::Private::FReplicationSystemInternal;
 
    friend UObjectReplicationBridge;
    friend UReplicationSystem;
 
    UReplicationSystem* ReplicationSystem;
    UE::Net::Private::FReplicationProtocolManager* ReplicationProtocolManager;
    UE::Net::Private::FReplicationStateDescriptorRegistry* ReplicationStateDescriptorRegistry;
    UE::Net::Private::FNetRefHandleManager* NetRefHandleManager;
    UE::Net::Private::FObjectReferenceCache* ObjectReferenceCache;
    UE::Net::Private::FNetObjectGroups* Groups;
 
    TMap<FObjectKey, UE::Net::FNetObjectGroupHandle> LevelGroups;
 
    bool bInReceiveUpdate = false;
 
    TMap<FNetRefHandle, EEndReplicationFlags> HandlesToStopReplicating;
 
private:
 
    struct FPendingEndReplicationInfo
    {
        FPendingEndReplicationInfo(FNetRefHandle InHandle, EEndReplicationFlags InDestroyFlags, EPendingEndReplicationImmediate InImmediate) : Handle(InHandle), DestroyFlags(InDestroyFlags), Immediate(InImmediate) {}
 
        FNetRefHandle Handle;
        EEndReplicationFlags DestroyFlags;
        EPendingEndReplicationImmediate Immediate;
    };
    TArray<FPendingEndReplicationInfo> HandlesPendingEndReplication;
 
};
 
 
inline FReplicationBridgeSerializationContext::FReplicationBridgeSerializationContext(UE::Net::FNetSerializationContext& InSerialiazationContext, uint32 InConnectionId, bool bInIsDestructionInfo)
: SerializationContext(InSerialiazationContext)
, ConnectionId(InConnectionId)
, bIsDestructionInfo(bInIsDestructionInfo)
{
}