ReplicationSystem.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "Templates/PimplPtr.h"
#include "Templates/RefCounting.h"
#include "Iris/IrisConfig.h"
#include "Iris/ReplicationSystem/NetRefHandle.h"
#include "Iris/ReplicationSystem/NetObjectGroupHandle.h"
#include "Iris/ReplicationSystem/ReplicationSystemTypes.h"
#include "Net/Core/Connection/ConnectionHandle.h"
#include "Net/Core/NetHandle/NetHandle.h"
 
#include "ReplicationSystem.generated.h"
 
// The number of inline elements the TInlineAllocator for ReplicationSystems can store.
// Projects may define this to a value best suited for their needs.
#ifndef UE_NUM_INLINE_REPLICATIONSYSTEMS
    #define UE_NUM_INLINE_REPLICATIONSYSTEMS 8
#endif
 
class UDataStreamManager;
class UDataStream;
class UFunction;
class UNetBlobHandler;
class UNetDriver;
class UNetObjectFilter;
class UNetObjectPrioritizer;
class UObjectReplicationBridge;
class UReplicationSystem;
namespace UE::Net
{
    typedef uint32 FNetObjectFilterHandle;
    typedef uint32 FNetObjectPrioritizerHandle;
 
    class FNetBitArray;
    class FNetCullDistanceOverrides;
    class FNetObjectAttachment; 
    class FNetObjectReference;
    class FReplicationSystemDelegates;
    class FReplicationSystemFactory;
    class FNetTokenStore;
    class FStringTokenStore;
    class FNameTokenStore;
    class FWorldLocations;
    class FNetTokenResolveContext;
 
    struct FReplicationSystemUtil;
    struct FReplicationView;
    struct FNetDebugName;
    struct FNetMetrics;
    struct FReplicationProtocol;
 
    enum class ENetFilterStatus : uint32;
    enum class ENetObjectDeltaCompressionStatus : unsigned;
    enum class ENetRefHandleError : uint32;
    enum class EReplicationCondition : uint32;
 
    namespace Private
    {
        class FReplicationSystemImpl;
        class FReplicationSystemInternal;
    }
}
 
UCLASS(transient)
class UReplicationSystem : public UObject
{
    GENERATED_BODY()
 
    using FNetRefHandle = UE::Net::FNetRefHandle;
    using FNetObjectGroupHandle = UE::Net::FNetObjectGroupHandle;
    using FNetHandle = UE::Net::FNetHandle;
 
public:
 
    struct FReplicationSystemParams
    {
        UObjectReplicationBridge* ReplicationBridge = nullptr;
 
        uint32 MaxReplicatedObjectCount = 65536U;
 
        uint32 InitialNetObjectListCount = 65536U;
 
        uint32 NetObjectListGrowCount = 16384U;
 
        uint32 PreAllocatedMemoryBuffersObjectCount = 65536U;
 
        uint32 MaxReplicationWriterObjectCount = 0;
 
        uint32 MaxDeltaCompressedObjectCount = 2048U;
 
        uint32 MaxNetObjectGroupCount = 2048U;
 
        bool bIsServer = false;
 
        bool bAllowObjectReplication = false;
 
        bool bUseRemoteObjectReferences = false;
 
        bool bAllowParallelTasks = false;
 
        bool bAllowMinimalUpdateIfNoConnections = true;
 
        UE::Net::FForwardNetRPCCallDelegate ForwardNetRPCCallDelegate;
 
        UE::Net::FNetTokenStore* NetTokenStore = nullptr;
    };
 
    uint32 GetId() const { return Id; }
    
    IRISCORE_API uint32 GetMaxConnectionCount() const;
 
    bool IsServer() const { return bIsServer; }
 
    bool AllowObjectReplication() { return bAllowObjectReplication; }
 
    IRISCORE_API bool IsUsingRemoteObjectReferences() const;
 
    IRISCORE_API void NetUpdate(float DeltaSeconds);
 
    IRISCORE_API void TickPostReceive();
 
    IRISCORE_API void PreReceiveUpdate();
 
    IRISCORE_API void PostReceiveUpdate();
 
    IRISCORE_API void SendUpdate(TFunctionRef<void(TArrayView<uint32>)> SendFunction);
 
    IRISCORE_API void PostSendUpdate();
 
    IRISCORE_API void AddConnection(uint32 ConnectionId);
 
    IRISCORE_API void RemoveConnection(uint32 ConnectionId);
 
    IRISCORE_API bool IsValidConnection(uint32 ConnectionId) const;
 
    IRISCORE_API void SetConnectionGracefullyClosing(uint32 ConnectionId) const;
 
    IRISCORE_API void SetReplicationEnabledForConnection(uint32 ConnectionId, bool bReplicationEnabled);
 
    IRISCORE_API bool IsReplicationEnabledForConnection(uint32 ConnectionId) const;
 
    // Prioritization
 
    IRISCORE_API void SetReplicationView(uint32 ConnectionId, const UE::Net::FReplicationView& View);
 
    IRISCORE_API void SetStaticPriority(FNetRefHandle Handle, float Priority);
 
    IRISCORE_API bool SetPrioritizer(FNetRefHandle Handle, UE::Net::FNetObjectPrioritizerHandle PrioritizerHandle);
 
 
    IRISCORE_API UE::Net::FNetObjectPrioritizerHandle GetPrioritizerHandle(const FName PrioritizerName) const;
 
 
    IRISCORE_API UNetObjectPrioritizer* GetPrioritizer(const FName PrioritizerName) const;
 
    IRISCORE_API UDataStream* GetDataStream(uint32 ConnectionId, FName Name);
 
    IRISCORE_API const UDataStream* GetDataStream(uint32 ConnectionId, FName Name) const;
 
    IRISCORE_API bool IsKnownDataStreamDefinition(FName Name) const;
 
    IRISCORE_API UDataStream* OpenDataStream(uint32 ConnectionId, FName Name);
 
    IRISCORE_API void CloseDataStream(uint32 ConnectionId, FName Name);
    
    // NetBlob 
 
    IRISCORE_API bool RegisterNetBlobHandler(UNetBlobHandler* Handler);
 
    IRISCORE_API bool QueueNetObjectAttachment(uint32 ConnectionId, const UE::Net::FNetObjectReference& TargetRef, const TRefCountPtr<UE::Net::FNetObjectAttachment>& Attachment);
 
    IRISCORE_API bool SendRPC(const UObject* RootObject, const UObject* SubObject, const UFunction* Function, const void* Parameters);
 
    IRISCORE_API bool SendRPC(uint32 ConnectionId, const UObject* RootObject, const UObject* SubObject, const UFunction* Function, const void* Parameters);
 
    IRISCORE_API bool SetRPCSendPolicyFlags(const UFunction* Function, UE::Net::ENetObjectAttachmentSendPolicyFlags SendFlags);
 
    IRISCORE_API void ResetRPCSendPolicyFlags();
 
    IRISCORE_API UObjectReplicationBridge* GetReplicationBridge() const;
 
    template<typename T>
    T* GetReplicationBridgeAs() const { return Cast<T>(GetReplicationBridge()); }
 
    IRISCORE_API UE::Net::FNetTokenStore* GetNetTokenStore();
 
    IRISCORE_API const UE::Net::FNetTokenStore* GetNetTokenStore() const;
 
    IRISCORE_API UE::Net::FNetTokenResolveContext GetNetTokenResolveContext(uint32 ConnectionId) const;
 
    IRISCORE_API bool IsNetRefHandleAssigned(FNetRefHandle Handle) const;
 
    IRISCORE_API const UE::Net::FReplicationProtocol* GetReplicationProtocol(FNetRefHandle Handle) const;
 
    IRISCORE_API const UE::Net::FNetDebugName* GetDebugName(FNetRefHandle Handle) const;
 
    // Groups
 
    IRISCORE_API FNetObjectGroupHandle CreateGroup(FName GroupName);
 
    IRISCORE_API void DestroyGroup(FNetObjectGroupHandle GroupHandle);
 
    IRISCORE_API FNetObjectGroupHandle FindGroup(FName GroupName) const;
 
    IRISCORE_API void AddToGroup(FNetObjectGroupHandle GroupHandle, FNetRefHandle Handle);
 
    IRISCORE_API void RemoveFromGroup(FNetObjectGroupHandle GroupHandle, FNetRefHandle Handle);
 
    IRISCORE_API void RemoveFromAllGroups(FNetRefHandle Handle);
 
    IRISCORE_API bool IsInGroup(FNetObjectGroupHandle GroupHandle, FNetRefHandle Handle) const;
 
    IRISCORE_API bool IsValidGroup(FNetObjectGroupHandle GroupHandle) const;
 
    IRISCORE_API FNetObjectGroupHandle GetNotReplicatedNetObjectGroup() const;
 
    IRISCORE_API FNetObjectGroupHandle GetNetGroupOwnerNetObjectGroup() const;
 
    IRISCORE_API FNetObjectGroupHandle GetNetGroupReplayNetObjectGroup() const;
 
    // Filtering
 
    IRISCORE_API void SetOwningNetConnection(FNetRefHandle Handle, uint32 ConnectionId);
 
    IRISCORE_API uint32 GetOwningNetConnection(FNetRefHandle Handle) const;
 
    IRISCORE_API bool SetFilter(FNetRefHandle Handle, UE::Net::FNetObjectFilterHandle FilterHandle, FName FilterConfigProfile=NAME_None);
 
    IRISCORE_API UE::Net::FNetObjectFilterHandle GetFilterHandle(const FName FilterName) const;
 
    IRISCORE_API UNetObjectFilter* GetFilter(const FName FilterName) const;
 
    IRISCORE_API FName GetFilterName(UE::Net::FNetObjectFilterHandle Filter) const;
 
    // Group Filtering
 
    IRISCORE_API bool AddExclusionFilterGroup(FNetObjectGroupHandle GroupHandle);
 
    IRISCORE_API bool AddInclusionFilterGroup(FNetObjectGroupHandle GroupHandle);
 
    IRISCORE_API void RemoveGroupFilter(FNetObjectGroupHandle GroupHandle);
 
    IRISCORE_API void SetGroupFilterStatus(FNetObjectGroupHandle GroupHandle, uint32 ConnectionId, UE::Net::ENetFilterStatus ReplicationStatus);
 
    IRISCORE_API void SetGroupFilterStatus(FNetObjectGroupHandle GroupHandle, const UE::Net::FNetBitArray& Connections, UE::Net::ENetFilterStatus ReplicationStatus);
 
    IRISCORE_API void SetGroupFilterStatus(FNetObjectGroupHandle GroupHandle, UE::Net::ENetFilterStatus ReplicationStatus);
 
 
    // SubObject filtering
    IRISCORE_API FNetObjectGroupHandle GetOrCreateSubObjectFilter(FName GroupName);
 
    IRISCORE_API FNetObjectGroupHandle GetSubObjectFilterGroupHandle(FName GroupName) const;
 
    IRISCORE_API void SetSubObjectFilterStatus(FName GroupName, UE::Net::FConnectionHandle ConnectionHandle, UE::Net::ENetFilterStatus ReplicationStatus);
 
    IRISCORE_API void RemoveSubObjectFilter(FName GroupName);
 
    IRISCORE_API bool SetReplicationConditionConnectionFilter(FNetRefHandle Handle, UE::Net::EReplicationCondition Condition, uint32 ConnectionId, bool bEnable);
 
    IRISCORE_API bool SetReplicationCondition(FNetRefHandle Handle, UE::Net::EReplicationCondition Condition, bool bEnable);
 
 
    IRISCORE_API void SetDeltaCompressionStatus(FNetRefHandle Handle, UE::Net::ENetObjectDeltaCompressionStatus Status);
 
    IRISCORE_API void SetIsNetTemporary(FNetRefHandle Handle);
 
    IRISCORE_API void TearOffNextUpdate(FNetRefHandle Handle);
 
    IRISCORE_API void ForceNetUpdate(FNetRefHandle Handle);
 
    IRISCORE_API void MarkDirty(FNetRefHandle Handle);
 
    IRISCORE_API const UE::Net::FWorldLocations& GetWorldLocations() const;
 
    /* Init data streams for a connection. For internal use by UDataStreamChannel. */
    IRISCORE_API void InitDataStreamManager(uint32 ConnectionId, UDataStreamManager* DataStreamManager);
 
    IRISCORE_API void SetConnectionUserData(uint32 ConnectionId, UObject* UserData);
 
    IRISCORE_API UObject* GetConnectionUserData(uint32 ConnectionId) const;
 
    int32 GetPIEInstanceID() const { return PIEInstanceID; }
 
    IRISCORE_API void SetCullDistanceOverride(FNetRefHandle Handle, float Dist);
 
    IRISCORE_API void ClearCullDistanceOverride(FNetRefHandle Handle);
 
    IRISCORE_API float GetCullDistance(FNetRefHandle Handle, float DefaultValue = -1.0f) const;
 
    double GetElapsedTime() const { return ElapsedTime; }
 
    IRISCORE_API void ReportProtocolMismatch(uint64 NetRefHandleId, uint32 ConnectionId);
 
    IRISCORE_API void ReportErrorWithNetRefHandle(UE::Net::ENetRefHandleError ErrorType, uint64 NetRefHandleId, uint32 ConnectionId, const TArray<uint64>& ExtraNetRefHandles);
 
    IRISCORE_API void CollectNetMetrics(UE::Net::FNetMetrics& OutNetMetrics) const;
 
    IRISCORE_API void ResetNetMetrics();
 
    IRISCORE_API UE::Net::FReplicationSystemDelegates& GetDelegates();
 
public:
    // For internal use and not exported.
    UE::Net::Private::FReplicationSystemInternal* GetReplicationSystemInternal();
    const UE::Net::Private::FReplicationSystemInternal* GetReplicationSystemInternal() const;
 
private:
    friend UE::Net::FReplicationSystemFactory;
 
    UReplicationSystem();
    ~UReplicationSystem();
 
    void Init(uint32 InId, const FReplicationSystemParams& Params);
    void Shutdown();
 
    // UObject interface
    IRISCORE_API static void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
private:
    friend UNetDriver;
 
    IRISCORE_API void NotifyStreamingLevelUnload(const UObject* Level);
 
    IRISCORE_API void PreSeamlessTravelGarbageCollect();
 
    IRISCORE_API void PostSeamlessTravelGarbageCollect();
 
    void SetPIEInstanceID(int32 InPIEInstanceID) { PIEInstanceID = InPIEInstanceID; }
 
private:
 
    void PostGarbageCollection();
    void CollectGarbage();
 
    TPimplPtr<UE::Net::Private::FReplicationSystemImpl> Impl;
 
    FDelegateHandle PostGarbageCollectHandle;
 
    UPROPERTY(transient)
    TObjectPtr<UObjectReplicationBridge> ReplicationBridge;
 
    double ElapsedTime = 0;
    uint32 Id;
    int32 PIEInstanceID;
    uint32 bIsServer : 1;
    uint32 bAllowObjectReplication : 1;
    uint32 bDoCollectGarbage : 1;
};
 
namespace UE::Net
{
 
DECLARE_MULTICAST_DELEGATE_OneParam(FReplicationSystemLifeTime, UReplicationSystem*);
 
using FReplicationSystemCreatedDelegate = FReplicationSystemLifeTime;
using FReplicationSystemDestroyedDelegate = FReplicationSystemLifeTime;
 
class FReplicationSystemFactory
{
public:
    IRISCORE_API static UReplicationSystem* CreateReplicationSystem(const UReplicationSystem::FReplicationSystemParams& Params);
    IRISCORE_API static void DestroyReplicationSystem(UReplicationSystem* System);
 
    IRISCORE_API static TArrayView<UReplicationSystem*> GetAllReplicationSystems();
 
    IRISCORE_API static FReplicationSystemCreatedDelegate& GetReplicationSystemCreatedDelegate();
 
    IRISCORE_API static FReplicationSystemDestroyedDelegate& GetReplicationSystemDestroyedDelegate();
 
private:
 
    friend UReplicationSystem* GetReplicationSystem(uint32 Id);
 
    using FReplicationSystemArray = TArray<UReplicationSystem*, TInlineAllocator<UE_NUM_INLINE_REPLICATIONSYSTEMS>>;
    IRISCORE_API static FReplicationSystemArray ReplicationSystems;
};
 
inline UReplicationSystem* GetReplicationSystem(uint32 Id)
{
    return Id >= static_cast<uint32>(FReplicationSystemFactory::ReplicationSystems.Num()) ? nullptr : FReplicationSystemFactory::ReplicationSystems[Id];
}
 
} // end namespace UE::Net