EngineReplicationBridge.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Iris/ReplicationSystem/ObjectReplicationBridge.h"
#include "Engine/EngineTypes.h"
#include "UObject/ObjectPtr.h"
#include "EngineReplicationBridge.generated.h"
 
class UNetDriver;
class UIrisObjectReferencePackageMap;
struct FAnalyticsEventAttribute;
 
class UActorComponent;
class UWorld;
 
namespace UE::Net
{
    enum class ENetRefHandleError : uint32;
}
 
namespace UE::Net
{
 
// If actor should be replicated using IRIS or old replication system
ENGINE_API bool ShouldUseIrisReplication(const UObject* Actor);
 
// Currently just a direct mapping of EEEndPlayReason::Type but we might want to add more specific reasons later on
enum class EStopReplicatingReason : uint32
{
    Destroyed = 0,
    LevelTransition,
    EndPlayInEditor,
    RemovedFromWorld,
    Quit,
};
 
ENGINE_API const TCHAR* LexToString(EStopReplicatingReason Reason);
 
}
 
struct FActorReplicationParams
{
    enum EFilterType
    {
        ConfigFilter = 0,
        AlwaysRelevant,
        DefaultSpatial,
        ExplicitFilter,
    };
 
    EFilterType FilterType = ConfigFilter;
 
    FName ExplicitDynamicFilterName;
 
    FName NetFactoryName;
};
 
struct FStopReplicatingActorParams
{
    explicit ENGINE_API FStopReplicatingActorParams(EEndPlayReason::Type);
 
    UE::Net::EStopReplicatingReason StopReplicatingReason = UE::Net::EStopReplicatingReason::Destroyed;
 
    //$TODO: Remove when we can remove EndReplication
    EEndPlayReason::Type EndPlayReason = EEndPlayReason::Type::Destroyed;
};
 
UCLASS(Transient, MinimalAPI, config=Engine)
class UEngineReplicationBridge final : public UObjectReplicationBridge
{
    GENERATED_BODY()
 
public:
    ENGINE_API UEngineReplicationBridge();
    virtual ENGINE_API ~UEngineReplicationBridge() override;
 
    ENGINE_API static UEngineReplicationBridge* Create(UNetDriver* NetDriver);
 
    ENGINE_API void SetNetDriver(UNetDriver* const InNetDriver);
    
    inline UNetDriver* GetNetDriver() const { return NetDriver; }
 
    ENGINE_API FNetRefHandle StartReplicatingActor(AActor* Instance);
 
    ENGINE_API void StopReplicatingActor(AActor* Actor, const FStopReplicatingActorParams& Params);
 
    ENGINE_API EEndReplicationFlags ConvertToEndReplicationFlags(UE::Net::EStopReplicatingReason StopReplicatingReason) const;
        
    ENGINE_API FNetRefHandle StartReplicatingComponent(FNetRefHandle RootObjectHandle, UActorComponent* ActorComponent);
 
    ENGINE_API FNetRefHandle StartReplicatingSubObject(UObject* SubObject, const FSubObjectReplicationParams& Params);
 
    ENGINE_API void StopReplicatingComponent(UActorComponent* ActorComponent, EEndReplicationFlags EndReplicationFlags = EEndReplicationFlags::None);
 
    UIrisObjectReferencePackageMap* GetObjectReferencePackageMap() const { return ObjectReferencePackageMap; }
 
    ENGINE_API virtual void SendErrorWithNetRefHandle(UE::Net::ENetRefHandleError ErrorType, FNetRefHandle RefHandle, uint32 ConnectionId, TConstArrayView<const FNetRefHandle> ExtraNetRefHandle = {}) override;
 
    ENGINE_API void AddRootObjectToLevelGroup(const UObject* RootObject, const ULevel* Level);
    
    void ActorChangedLevel(const AActor* Actor, const ULevel* PreviousLevel);
 
    void OnNetUpdateFrequencyChanged(const AActor* Actor);
 
    void WakeUpObjectInstantiatedFromRemote(AActor* Actor) const;
 
    ENGINE_API void ConsumeNetMetrics(TArray<FAnalyticsEventAttribute>& OutAttrs);
 
    UE::Net::FNetObjectFactoryId GetActorFactoryId() const { return ActorFactoryId; }
 
    UE::Net::FNetObjectFactoryId GetSubObjectFactoryId() const { return SubObjectFactoryId; }
 
protected:
    // UReplicationBridge
    virtual void OnPreSeamlessTravelGarbageCollect() override;
 
    // UObjectReplicationBridge
    virtual void Initialize(UReplicationSystem* ReplicationSystem) override;
    virtual void Deinitialize() override;
    virtual void GetInitialDependencies(FNetRefHandle Handle, FNetDependencyInfoArray& OutDependencies) const override;
    virtual bool RemapPathForPIE(uint32 ConnectionId, FString& Path, bool bReading) const override;
    virtual bool ObjectLevelHasFinishedLoading(UObject* Object) const override;
    virtual bool IsAllowedToDestroyInstance(const UObject* Instance) const override;
    virtual void OnProtocolMismatchDetected(FNetRefHandle ObjectHandle) override;
    virtual void OnProtocolMismatchReported(FNetRefHandle RefHandle, uint32 ConnectionId) override;
    virtual bool CanCreateDestructionInfo() const override;
 
    virtual bool IsClassReplicatedByDefault(const UClass* Class) const;
 
    [[nodiscard]] virtual FString PrintConnectionInfo(uint32 ConnectionId) const override;
 
private:
    
    void OnMaxTickRateChanged(UNetDriver* InNetDriver, int32 NewMaxTickRate, int32 OldMaxTickRate);
 
private:
 
    UE::Net::FNetObjectFactoryId ActorFactoryId;
    UE::Net::FNetObjectFactoryId SubObjectFactoryId;
 
    UNetDriver* NetDriver = nullptr;
 
    UPROPERTY(Transient)
    TObjectPtr<UIrisObjectReferencePackageMap> ObjectReferencePackageMap = nullptr;
 
    UPROPERTY(Config)
    FName ActorFactoryName;
 
    UPROPERTY(Config)
    FName SubObjectFactoryName;
};