ObjectReplicationBridge.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "HAL/Platform.h"
 
#include "Iris/ReplicationSystem/ReplicationBridge.h"
#include "Iris/ReplicationSystem/ReplicationSystemTypes.h"
#include "Iris/ReplicationSystem/NetObjectFactory.h"
#include "Iris/ReplicationSystem/NetObjectFactoryRegistry.h"
 
#include "Containers/ArrayView.h"
#include "Containers/Set.h"
 
#include "Delegates/IDelegateInstance.h"
 
#include "Misc/EnumClassFlags.h"
 
#include "Net/Core/NetBitArray.h"
#include "Net/Core/NetHandle/NetHandle.h"
 
#include "ObjectReplicationBridge.generated.h"
 
DECLARE_LOG_CATEGORY_EXTERN(LogIrisFilterConfig, Log, All);
 
namespace UE::Net
{
    enum class ENetRefHandleError : uint32;
    enum class EReplicationFragmentTraits : uint32;
 
    struct FNetObjectResolveContext;
 
    typedef uint32 FNetObjectFilterHandle;
    typedef uint32 FNetObjectPrioritizerHandle;
    typedef uint32 FReplicationProtocolIdentifier;
 
    class FNetObjectReference;
    class FWorldLocations;
 
    namespace Private
    {
        typedef uint32 FInternalNetRefIndex;
        class FObjectPollFrequencyLimiter;
        class FObjectPoller;
        class FReplicationSystemImpl;
        class FBridgeSerialization;
    }
}
 
namespace UE::Net::Private
{
 
struct FStaticDestructionInfo
{
    UE::Net::FNetObjectReference StaticRef;
    
    UE::Net::FNetObjectGroupHandle LevelGroupHandle;
    
    UE::Net::FNetObjectFactoryId NetFactoryId = UE::Net::InvalidNetObjectFactoryId;
 
    UE::Net::Private::FInternalNetRefIndex InternalReplicationIndex;
};
 
} // end namespace UE::Net::Private
 
struct FObjectReplicationBridgeInstantiateResult
{
    UObject* Object = nullptr;
    EReplicationBridgeCreateNetRefHandleResultFlags Flags = EReplicationBridgeCreateNetRefHandleResultFlags::None;
};
 
/*
* Partial implementation of ReplicationBridge that can be used as a foundation for 
* implementing support for replicating objects derived from UObject
*/
UCLASS(Transient, MinimalApi)
class UObjectReplicationBridge : public UReplicationBridge
{
    GENERATED_BODY()
 
public:
 
    using EGetRefHandleFlags = UE::Net::EGetRefHandleFlags;
 
    struct FRootObjectReplicationParams;
    struct FSubObjectReplicationParams;
 
    IRISCORE_API UObjectReplicationBridge();
 
    IRISCORE_API UObject* GetReplicatedObject(FNetRefHandle Handle) const;
 
    IRISCORE_API FNetRefHandle GetReplicatedRefHandle(const UObject* Object, EGetRefHandleFlags GetRefHandleFlags = EGetRefHandleFlags::None) const;
 
    IRISCORE_API FNetRefHandle GetReplicatedRefHandle(FNetHandle Handle) const;
 
    IRISCORE_API UObject* ResolveObjectReference(const UE::Net::FNetObjectReference& ObjectRef, const UE::Net::FNetObjectResolveContext& ResolveContext);
 
    IRISCORE_API FString DescribeObjectReference(const UE::Net::FNetObjectReference& ObjectRef, const UE::Net::FNetObjectResolveContext& ResolveContext);
 
    IRISCORE_API UE::Net::FNetObjectReference GetOrCreateObjectReference(const UObject* Instance) const;
 
    IRISCORE_API UE::Net::FNetObjectReference GetOrCreateObjectReference(const FString& Path, const UObject* Outer) const;
 
    IRISCORE_API FNetRefHandle StartReplicatingRootObject(UObject* Instance, const FRootObjectReplicationParams& Params, UE::Net::FNetObjectFactoryId NetFactoryId);
 
    IRISCORE_API FNetRefHandle StartReplicatingSubObject(UObject* Instance, const FSubObjectReplicationParams& Params, UE::Net::FNetObjectFactoryId NetFactoryId);
 
    IRISCORE_API void StopReplicatingNetObject(UObject* Instance, EEndReplicationFlags EndReplicationFlags = EEndReplicationFlags::Destroy);
 
    IRISCORE_API void SetSubObjectNetCondition(FNetRefHandle SubObjectHandle, ELifetimeCondition Condition);
 
    IRISCORE_API FNetRefHandle GetRootObjectOfAnyObject(FNetRefHandle NetRefHandle) const;
 
    IRISCORE_API FNetRefHandle GetRootObjectOfSubObject(FNetRefHandle SubObjectHandle) const;
 
    IRISCORE_API UNetObjectFactory* GetNetFactory(UE::Net::FNetObjectFactoryId FactoryId) const;
 
    IRISCORE_API void AddStaticDestructionInfo(const FString& ObjectPath, const UObject* Outer, const UE::Net::FDestructionParameters& Parameters);
 
    IRISCORE_API FNetRefHandle StoreDestructionInfo(FNetRefHandle Handle, const UE::Net::FDestructionParameters& Parameters);
    
    virtual bool RemapPathForPIE(uint32 ConnectionId, FString& Path, bool bReading) const { return false; }
 
    virtual bool ObjectLevelHasFinishedLoading(UObject* Object) const { return true; }
 
    IRISCORE_API void AddDependentObject(FNetRefHandle Parent, FNetRefHandle DependentObject, UE::Net::EDependentObjectSchedulingHint SchedulingHint = UE::Net::EDependentObjectSchedulingHint::Default);
 
    IRISCORE_API void RemoveDependentObject(FNetRefHandle Parent, FNetRefHandle DependentObject);
 
    IRISCORE_API void AddCreationDependencyLink(FNetRefHandle Parent, FNetRefHandle Child);
 
    IRISCORE_API void RemoveCreationDependencyLink(FNetRefHandle Parent, FNetRefHandle Child);
 
    // Dormancy support
 
    IRISCORE_API void SetObjectWantsToBeDormant(FNetRefHandle Handle, bool bWantsToBeDormant);
 
    IRISCORE_API bool GetObjectWantsToBeDormant(FNetRefHandle Handle) const;
 
    IRISCORE_API void NetFlushDormantObject(FNetRefHandle Handle);  
 
    IRISCORE_API void SetPollFrequency(FNetRefHandle RootHandle, float PollFrequency);
 
    IRISCORE_API void SetClassDynamicFilterConfig(FName ClassPathName, const UE::Net::FNetObjectFilterHandle FilterHandle, FName FilterProfile=NAME_None);
    IRISCORE_API void SetClassDynamicFilterConfig(FName ClassPathName, FName FilterName, FName FilterProfile=NAME_None);
 
    IRISCORE_API void SetClassTypeStatsConfig(FName ClassPathName, FName TypeStatsName);
    IRISCORE_API void SetClassTypeStatsConfig(const FString& ClassPathName, const FString& TypeStatsName);
 
    IRISCORE_API bool ShouldUseVerboseCsvStats() const;
 
    FName GetDefaultSpatialFilterName() const { return DefaultSpatialFilterName; }
 
    IRISCORE_API bool IsNetRefHandlePreRegistered(FNetRefHandle Handle);
 
    IRISCORE_API UObject* GetPreRegisteredObject(FNetRefHandle Handle) const;
 
    virtual void SendErrorWithNetRefHandle(UE::Net::ENetRefHandleError ErrorType, FNetRefHandle RefHandle, uint32 ConnectionId, TConstArrayView<const FNetRefHandle> ExtraNetRefHandle = {}) {}
 
    IRISCORE_API UE::Net::FNetRefHandle PreRegisterNewObjectReferenceHandle(UObject* Instance);
 
    IRISCORE_API void PreRegisterObjectWithReferenceHandle(const UObject* Instance, FNetRefHandle Handle);
 
public:
 
    struct FRootObjectReplicationParams
    {
        bool bNeedsPreUpdate = false;
 
        bool bNeedsWorldLocationUpdate = false;
 
        bool bIsDormant = false;
 
        bool bUseClassConfigDynamicFilter = true;
 
        bool bUseExplicitDynamicFilter = false;
 
        FName ExplicitDynamicFilterName;
 
        float StaticPriority = 0.0f;
 
        float PollFrequency = 0.0f;
    };
 
    struct FSubObjectReplicationParams
    {
        FNetRefHandle RootObjectHandle;
 
        FNetRefHandle InsertRelativeToSubObjectHandle; 
 
        UE::Net::ESubObjectInsertionOrder InsertionOrder = UE::Net::ESubObjectInsertionOrder::None;
    };
 
public:
 
    enum class EPrintDebugInfoTraits : uint32
    {
        Default = 0x0000,
        // Do not print the entire protocol state when this is set 
        NoProtocolState = 0x0001,
        // Also print the debug information of child dependents
        WithDependents = 0x0002,
    };
 
    // Debug functions that are triggered via console commands declared in ObjectReplicationBridgeDebugging.cpp
    void PrintDynamicFilterClassConfig(uint32 ArgTraits);
    void PrintReplicatedObjects(uint32 ArgTraits) const;
    void PrintAlwaysRelevantObjects(uint32 ArgTraits) const;
    void PrintRelevantObjects(uint32 ArgTraits) const;
    void PrintRelevantObjectsForConnections(const TArray<FString>& Args) const;
    void PrintNetCullDistances(const TArray<FString>& Args) const;
    void PrintPushBasedStatuses() const;
 
    void PrintDebugInfoForNetRefHandlesAndConnections(const TArray<FNetRefHandle>& NetHandles, const TArray<FString>& Args, EPrintDebugInfoTraits PrintTraits);
    IRISCORE_API void PrintDebugInfoForNetRefHandle(const FNetRefHandle NetHandle, uint32 ConnectionId, EPrintDebugInfoTraits PrintTraits=EPrintDebugInfoTraits::Default) const;
 
protected:
    IRISCORE_API virtual ~UObjectReplicationBridge();
 
    // UReplicationBridge
 
    IRISCORE_API virtual void Initialize(UReplicationSystem* InReplicationSystem) override;
    IRISCORE_API virtual void Deinitialize() override;
    IRISCORE_API virtual void PreSendUpdateSingleHandle(FNetRefHandle RefHandle) override;  
    IRISCORE_API virtual void PreSendUpdate() override; 
    IRISCORE_API virtual void OnStartPreSendUpdate() override;
    IRISCORE_API virtual void OnPostSendUpdate() override;
    IRISCORE_API virtual void OnPostReceiveUpdate() override;
    IRISCORE_API virtual void UpdateInstancesWorldLocation() override;
    IRISCORE_API virtual void PruneStaleObjects() override; 
    IRISCORE_API virtual bool CacheNetRefHandleCreationInfo(FNetRefHandle Handle) override;
    IRISCORE_API virtual void DetachInstance(FNetRefHandle Handle) override;
    IRISCORE_API virtual void OnProtocolMismatchReported(FNetRefHandle RefHandle, uint32 ConnectionId) override;
    IRISCORE_API virtual void OnErrorWithNetRefHandleReported(UE::Net::ENetRefHandleError ErrorType, FNetRefHandle RefHandle, uint32 ConnectionId, const TArray<FNetRefHandle>& ExtraHandles) override;
 
    IRISCORE_API virtual void RemoveDestructionInfosForGroup(UE::Net::FNetObjectGroupHandle GroupHandle) override;
 
private:
 
    void OnErrorBitstreamCorrupted(FNetRefHandle RefHandle, uint32 ConnectionId);
    void OnErrorCannotReplicateObject(FNetRefHandle RefHandle, uint32 ConnectionId);
    void OnErrorBlockedByAsyncLoading(FNetRefHandle RefHandle, uint32 ConnectionId, const TArray<FNetRefHandle>& MustBeMappedRefs);
    void OnErrorBlockedByParents(FNetRefHandle RefHandle, uint32 ConnectionId, const TArray<FNetRefHandle>& BlockedParents);
    
protected:
    
    virtual void OnProtocolMismatchDetected(FNetRefHandle ObjectHandle) {}
 
    IRISCORE_API UObject* GetObjectFromReferenceHandle(FNetRefHandle RefHandle) const;
 
    using FInstancePreUpdateFunction = TFunction<void(TArrayView<UObject*>, const UObjectReplicationBridge*)>;
 
    IRISCORE_API void SetInstancePreUpdateFunction(FInstancePreUpdateFunction InPreUpdateFunction);
    
    IRISCORE_API FInstancePreUpdateFunction GetInstancePreUpdateFunction() const;
 
    // Poll frequency support
 
    IRISCORE_API void SetPollWithObject(FNetRefHandle ObjectToPollWith, FNetRefHandle Object);
 
    IRISCORE_API uint8 ConvertPollFrequencyIntoFrames(float PollFrequency) const;
 
    IRISCORE_API void ReinitPollFrequency();
 
    IRISCORE_API void LoadConfig();
 
    IRISCORE_API void ForceUpdateWorldLocation(FNetRefHandle NetRefHandle, UE::Net::Private::FInternalNetRefIndex InternalObjectIndex);
 
    IRISCORE_API void SetShouldUseDefaultSpatialFilterFunction(TFunction<bool(const UClass*)>);
 
    IRISCORE_API void SetShouldSubclassUseSameFilterFunction(TFunction<bool(const UClass* Class, const UClass* Subclass)>);
 
    IRISCORE_API bool FindOrCachePollFrequency(const UClass* Class, float& OutPollPeriod);
 
    IRISCORE_API bool GetClassPollFrequency(const UClass* Class, float& OutPollPeriod) const;
 
    IRISCORE_API EIrisAsyncLoadingPriority GetClassIrisAsyncLoadingPriority(const UClass* Class);
 
    IRISCORE_API bool IsClassCritical(const UClass* Class);
 
    IRISCORE_API virtual bool IsClassReplicatedByDefault(const UClass* Class) const;
 
    [[nodiscard]] IRISCORE_API virtual FString PrintConnectionInfo(uint32 ConnectionId) const;
 
    float GetMaxTickRate() const { return MaxTickRate; }
 
    void SetMaxTickRate(float InMaxTickRate) { MaxTickRate = InMaxTickRate; }
 
    IRISCORE_API virtual TArray<uint32> FindConnectionsFromArgs(const TArray<FString>& Args) const;
 
    IRISCORE_API UE::Net::FNetObjectFilterHandle GetDynamicFilter(const UClass* Class, bool bRequireForceEnabled, FName& OutFilterProfile);
 
private:
 
    void ForcePollObject(FNetRefHandle RefHandle);
 
    void BuildPollList(UE::Net::FNetBitArrayView ObjectsConsideredForPolling);
 
    void PreUpdate(const UE::Net::FNetBitArrayView ObjectsConsideredForPolling);
 
    void FinalizeDirtyObjects();
 
    void ReconcileNewSubObjects(UE::Net::FNetBitArrayView ObjectsConsideredForPolling);
 
    void PollAndCopy(const UE::Net::FNetBitArrayView ObjectsConsideredForPolling);
 
    void UnregisterInstance(FNetRefHandle RefHandle);
 
    void RegisterRemoteInstance(FNetRefHandle RefHandle, UObject* InstancePtr, const UE::Net::FReplicationProtocol* Protocol, UE::Net::FReplicationInstanceProtocol* InstanceProtocol, uint32 ConnectionId);
 
    void DetachInstanceFromRemote(FNetRefHandle Handle, EReplicationBridgeDestroyInstanceReason DestroyReason, EReplicationBridgeDestroyInstanceFlags DestroyFlags,  UE::Net::FNetObjectFactoryId NetFactoryId);
 
    void DetachSubObjectInstancesFromRemote(UE::Net::Private::FInternalNetRefIndex InternalObjectIndex, EReplicationBridgeDestroyInstanceReason DestroyReason, EReplicationBridgeDestroyInstanceFlags DestroyFlags);
 
    void SetNetPushIdOnInstance(UE::Net::FReplicationInstanceProtocol* InstanceProtocol, FNetHandle NetHandle);
 
    void FindClassesInPollPeriodOverrides();
 
    float GetPollFrequencyOfRootObject(UE::Net::Private::FInternalNetRefIndex RootObjectIndex) const;
 
    UE::Net::FNetRefHandle StartReplicatingNetObject(UObject* Instance, UE::Net::EReplicationFragmentTraits Traits, UE::Net::FNetObjectFactoryId NetFactoryId);
 
    UE::Net::FNetObjectPrioritizerHandle GetPrioritizer(const UClass* Class, bool bRequireForceEnabled);
 
    void AssignDynamicFilter(UObject* Instance, const FRootObjectReplicationParams& Params, FNetRefHandle RefHandle);
 
    bool ShouldClassBeDeltaCompressed(const UClass* Class);
 
    void SetSubObjectDormancyStatus(FNetRefHandle SubObjectRefHandle, FNetRefHandle OwnerRefHandle);
 
    void OptionallySetObjectRequiresFrequentWorldLocationUpdate(FNetRefHandle RefHandle, bool bDesiresFrequentWorldLocationUpdate);
 
    struct FUpdateWorldInfoContext
    {
        UE::Net::FWorldLocations& WorldLocations;
        UE::Net::Private::FInternalNetRefIndex ObjectIndex;
        FNetRefHandle NetRefHandle;
    };
    void UpdateRootObjectWorldInfo(const FUpdateWorldInfoContext& Context);
 
    int32 GetTypeStatsIndex(const UClass* Class);
 
    FInstancePreUpdateFunction PreUpdateInstanceFunction;
    
    FName GetConfigClassPathName(const UClass* Class);
 
    void CreateDestructionProtocol();
    void InitConditionalPropertyDelegates();
    void InitNetObjectFactories();
    void DeinitNetObjectFactories();
 
    void OnMaxInternalNetRefIndexIncreased(UE::Net::Private::FInternalNetRefIndex NewMaxInternalIndex);
 
private:
 
    //------------------------------------------------------------------------
    // These private methods are available through the FBridgeSerialization interface
    //------------------------------------------------------------------------
 
    friend UE::Net::Private::FBridgeSerialization;
 
    const UE::Net::Private::FStaticDestructionInfo* GetStaticDestructionInfo(UE::Net::FNetRefHandle Handle) const
    {
        return StaticObjectsPendingDestroy.Find(Handle);
    }
 
    bool WriteNetRefHandleCreationInfo(FReplicationBridgeSerializationContext& Context, FNetRefHandle Handle);
 
    void DestroyNetObjectFromRemote(UE::Net::Private::FInternalNetRefIndex InternalObjectIndex, EReplicationBridgeDestroyInstanceReason DestroyReason);
 
    void ReadAndExecuteDestructionInfoFromRemote(FReplicationBridgeSerializationContext& Context);
 
    FReplicationBridgeCreateNetRefHandleResult CreateNetRefHandleFromRemote(FNetRefHandle RootObjectNetHandle, FNetRefHandle WantedNetHandle, FReplicationBridgeSerializationContext& Context);
 
    void PostApplyInitialState(UE::Net::Private::FInternalNetRefIndex InternalObjectIndex);
 
    void SubObjectCreatedFromReplication(UE::Net::Private::FInternalNetRefIndex RootObjectIndex, FNetRefHandle SubObjectCreated);
 
private:
 
    friend UE::Net::Private::FObjectPoller;
    friend UE::Net::Private::FReplicationSystemImpl;
    
    friend UReplicationSystem;
 
    TMap<const UClass*, FName> ConfigClassPathNameCache;
 
    // Prioritization
    struct FClassPrioritizerInfo
    {
        UE::Net::FNetObjectPrioritizerHandle PrioritizerHandle;
        bool bForceEnable = false;
    };
    
    // Filtering
    struct FClassFilterInfo
    {
        UE::Net::FNetObjectFilterHandle FilterHandle;
        FName FilterProfile;
        bool bForceEnable = false;
    };
 
    // Polling
 
    float MaxTickRate = 30.0f;
 
    struct FPollInfo
    {
        float PollFrequency = 0.0f;
        TWeakObjectPtr<const UClass> Class;
    };
    UE::Net::Private::FObjectPollFrequencyLimiter* PollFrequencyLimiter;
 
    //$IRIS TODO: The poll class config management code should be moved into it's own class. Maybe in a class that handles any type of per-class settings.
    // Class hierarchies with poll period overrides
    TMap<FName, FPollInfo> ClassHierarchyPollPeriodOverrides;
    // Exact classes with poll period overrides
    TMap<FName, FPollInfo> ClassesWithPollPeriodOverride;
    // Exact classes without poll period override
    TSet<FName> ClassesWithoutPollPeriodOverride;
 
    // Filter mapping
    //$IRIS TODO: Look into improving this class map by balancing runtime speed (implicit addition of new classes) with runtime modifications of base classes.
    //            Right-now any changes to say APawn's filter will not be read if a APlayerPawn entry was created based on the APawn entry.
    TMap<FName, FClassFilterInfo> ClassesWithDynamicFilter;
    TFunction<bool(const UClass*)> ShouldUseDefaultSpatialFilterFunction;
    TFunction<bool(const UClass*,const UClass*)> ShouldSubclassUseSameFilterFunction;
 
    // Prioritizer mapping
    TMap<FName, FClassPrioritizerInfo> ClassesWithPrioritizer;
 
    // Delta compression
    TMap<FName, bool> ClassesWithDeltaCompression;
 
    // Classes that may force a disconnection when a protocol mismatch is detected.
    TMap<FName, bool> ClassesFlaggedCritical;
 
    // Classes that have an async loading priority
    TMap<FName, EIrisAsyncLoadingPriority> ClassesIrisAsyncLoadingPriority;
 
    // Type stats
    TMap<FName, FName> ClassesWithTypeStats;
 
    // When we flush objects, we might need to defer sending creation info.
    TMap<FNetRefHandle, TUniquePtr<const UE::Net::FNetObjectCreationHeader>> CachedCreationHeaders;
 
    // Track the static objects that are destroyed so clients can be told to delete them after loading the level
    TMap<FNetRefHandle, UE::Net::Private::FStaticDestructionInfo> StaticObjectsPendingDestroy;
 
    // Objects which has object references and could be affected by garbage collection.
    UE::Net::FNetBitArray ObjectsWithObjectReferences;
    // Objects that needs to update their object references due to garbage collection.
    UE::Net::FNetBitArray GarbageCollectionAffectedObjects;
 
    FName DefaultSpatialFilterName;
    UE::Net::FNetObjectFilterHandle DefaultSpatialFilterHandle;
 
    FDelegateHandle OnCustomConditionChangedHandle;
    FDelegateHandle OnDynamicConditionChangedHandle;
 
    // Pre-built protocol used to send destruction requests for static objects
    const UE::Net::FReplicationProtocol* DestructionInfoProtocol = nullptr;
    
    UPROPERTY()
    TArray<TObjectPtr<UNetObjectFactory>> NetObjectFactories;
 
    bool bHasPollOverrides = false;
    bool bHasDirtyClassesInPollPeriodOverrides = false;
 
    bool bBlockStartRootObjectReplication = false;
 
protected:
    bool bSuppressCreateInstanceFailedEnsure = false;
 
private:
 
#if UE_NET_ASYNCLOADING_DEBUG
    friend UE::Net::Private::FAsyncLoadingSimulator;
    TArray<FNetRefHandle> DebugObjectsForcedToStall;
#endif
 
    TMap<FObjectKey, bool> ArchetypesAlreadyPrinted;
 
    TSet<FObjectKey> WorldLocationOOBWarnings;
 
    TArray<FString> ClassNamesToIgnoreProtocolMismatch;
};
 
//------------------------------------------------------------------------
 
ENUM_CLASS_FLAGS(UObjectReplicationBridge::EPrintDebugInfoTraits);
 
//------------------------------------------------------------------------
 
namespace UE::Net::Private
{
 
#if UE_NET_ASYNCLOADING_DEBUG
struct FAsyncLoadingSimulator
{
    static void AddStalledObject(UObjectReplicationBridge* Bridge, FNetRefHandle ReplicatedObject)
    {
        check(Bridge);
        if (ReplicatedObject.IsValid())
        {
            Bridge->DebugObjectsForcedToStall.AddUnique(ReplicatedObject);
        }
    }
 
    static void RemoveStalledObject(UObjectReplicationBridge* Bridge, FNetRefHandle ReplicatedObject)
    {
        check(Bridge);
        Bridge->DebugObjectsForcedToStall.Remove(ReplicatedObject);
    }
 
    static void RemoveAllStalledObjects(UObjectReplicationBridge* Bridge)
    {
        check(Bridge);
        Bridge->DebugObjectsForcedToStall.Empty();
    }
 
    static bool HasStalledObjects(UObjectReplicationBridge* Bridge)
    {
        check(Bridge);
        return !Bridge->DebugObjectsForcedToStall.IsEmpty();
    }
 
    static bool IsObjectStalled(UObjectReplicationBridge* Bridge, FNetRefHandle Handle)
    {
        check(Bridge);
        return Bridge->DebugObjectsForcedToStall.Contains(Handle);
    }
 
    static FReplicationBridgeCreateNetRefHandleResult CreateNetRefHandleFromRemote(UObjectReplicationBridge* Bridge, FNetRefHandle RootObjectNetHandle, FNetRefHandle WantedNetHandle, FReplicationBridgeSerializationContext& Context)
    {
        check(Bridge);
        return Bridge->CreateNetRefHandleFromRemote(RootObjectNetHandle, WantedNetHandle, Context);
    }
};
#endif // UE_NET_ASYNCLOADING_DEBUG
 
class FBridgeSerialization
{
public:
 
    static bool WriteNetRefHandleCreationInfo(UObjectReplicationBridge* Bridge, FReplicationBridgeSerializationContext& Context, FNetRefHandle Handle)
    {
        return Bridge->WriteNetRefHandleCreationInfo(Context, Handle);
    }
 
    static const UE::Net::Private::FStaticDestructionInfo* GetStaticDestructionInfo(UObjectReplicationBridge* Bridge, UE::Net::FNetRefHandle Handle)
    {
        return Bridge->GetStaticDestructionInfo(Handle);
    }
 
    static void DestroyNetObjectFromRemote(UObjectReplicationBridge* Bridge, FInternalNetRefIndex InternalObjectIndex, EReplicationBridgeDestroyInstanceReason DestroyReason)
    {
        Bridge->DestroyNetObjectFromRemote(InternalObjectIndex, DestroyReason);
    }
 
    static void ReadAndExecuteDestructionInfoFromRemote(UObjectReplicationBridge* Bridge, FReplicationBridgeSerializationContext& Context)
    {
        Bridge->ReadAndExecuteDestructionInfoFromRemote(Context);
    }
 
    static FReplicationBridgeCreateNetRefHandleResult CreateNetRefHandleFromRemote(UObjectReplicationBridge* Bridge, FNetRefHandle RootObjectNetHandle, FNetRefHandle WantedNetHandle, FReplicationBridgeSerializationContext& Context)
    {
        return Bridge->CreateNetRefHandleFromRemote(RootObjectNetHandle, WantedNetHandle, Context);
    }
 
    static void PostApplyInitialState(UObjectReplicationBridge* Bridge,  FInternalNetRefIndex InternalObjectIndex)
    {
        return Bridge->PostApplyInitialState(InternalObjectIndex);
    }
 
    static void SubObjectCreatedFromReplication(UObjectReplicationBridge* Bridge, UE::Net::Private::FInternalNetRefIndex RootObjectIndex, FNetRefHandle SubObjectCreated)
    {
        return Bridge->SubObjectCreatedFromReplication(RootObjectIndex, SubObjectCreated);
    }
};
 
} // end namespace UE::Net::Private