ReplicationSystemUtil.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
// HEADER_UNIT_SKIP - Can't find includes if UE_WITH_IRIS is not set
 
 
#include "Iris/ReplicationSystem/Conditionals/ReplicationCondition.h"
#include "Net/Core/NetHandle/NetHandle.h"
#include "Engine/EngineTypes.h"
 
class AActor;
class UActorComponent;
class UEngine;
class UEngineReplicationBridge;
class UObject;
class UReplicationSystem;
class UWorld;
class UNetConnection;
class UNetDriver;
class FRepChangedPropertyTracker;
 
struct FActorReplicationParams;
struct FStopReplicatingActorParams;
 
namespace UE::Net
{
    enum class EDependentObjectSchedulingHint : uint8;
}
 
namespace UE::Net
{
 
// Helper methods to interact with ReplicationSystem from engine code
struct FReplicationSystemUtil
{
    enum class EType : uint8 
    {
        Any,
        Client,
        Server,
    };
 
    ENGINE_API static void ForEachBridge(const UWorld* World, TFunctionRef<void(UEngineReplicationBridge*)> Function, EType Type = EType::Any);
 
    ENGINE_API static void ForEachSystem(const UWorld* World, TFunctionRef<void(UReplicationSystem*)> Function, EType Type = EType::Any);
 
    ENGINE_API static void ForEachSystemAndBridge(const UWorld* World, TFunctionRef<void(UReplicationSystem*, UEngineReplicationBridge*)> Function, EType Type = EType::Any);
 
    static void ForEachServerBridge(const UWorld* World, TFunctionRef<void(UEngineReplicationBridge*)> Function)
    {
        ForEachBridge(World, Function, EType::Server);
    }
 
    static void ForEachServerSystem(const UWorld* World, TFunctionRef<void(UReplicationSystem*)> Function)
    {
        ForEachSystem(World, Function, EType::Server);
    }
 
    static void ForEachServerSystemAndBridge(const UWorld* World, TFunctionRef<void(UReplicationSystem*, UEngineReplicationBridge* Bridge)> Function)
    {
        ForEachSystemAndBridge(World, Function, EType::Server);
    }
 
    ENGINE_API static void ForEachReplicationSystem(const UEngine* Engine, const UWorld* World, TFunctionRef<void(UReplicationSystem*)> Function);
 
    ENGINE_API static void ForEachReplicationSystem(TFunctionRef<void(UReplicationSystem*)> Function);
 
    ENGINE_API static UReplicationSystem* GetReplicationSystem(const AActor* Actor);
 
    ENGINE_API static UReplicationSystem* GetReplicationSystem(const UNetDriver* NetDriver);
 
    ENGINE_API static UReplicationSystem* GetReplicationSystem(const UWorld* World);
 
    ENGINE_API static UEngineReplicationBridge* GetActorReplicationBridge(const AActor* Actor);
 
    ENGINE_API static UEngineReplicationBridge* GetActorReplicationBridge(const UNetConnection* NetConnection);
 
    ENGINE_API static UEngineReplicationBridge* GetEngineReplicationBridge(const UWorld* World);
 
    ENGINE_API static FNetHandle GetNetHandle(const UObject* ReplicatedObject);
 
    ENGINE_API static void StartReplicatingActor(AActor* Actor);
    
    ENGINE_API static void StopReplicatingActor(AActor* Actor, const FStopReplicatingActorParams& StopReplicatingActorParams);
 
    ENGINE_API static void StartReplicatingActorComponent(const AActor* Actor, UActorComponent* ActorComponent);
 
    ENGINE_API static void StopReplicatingActorComponent(UActorComponent* SubObject);
 
    ENGINE_API static void StartReplicatingActorSubObject(const AActor* Actor, UObject* SubObject, ELifetimeCondition NetCondition);
 
    ENGINE_API static void StopReplicatingActorSubObject(const AActor* Actor, UObject* SubObject);
 
    ENGINE_API static void StartReplicatingActorComponentSubObject(UActorComponent* ActorComponent, UObject* SubObject, ELifetimeCondition Condition);
 
    ENGINE_API static void StopReplicatingActorComponentSubObject(UActorComponent* ActorComponent, UObject* SubObject);
 
    ENGINE_API static void SetNetConditionForActorSubObject(const AActor* Actor, UObject* SubObject, ELifetimeCondition NetCondition);
    
    ENGINE_API static void SetNetConditionForActorComponent(const UActorComponent* SubObject, ELifetimeCondition Condition);
 
    ENGINE_API static void UpdateSubObjectGroupMemberships(const UObject* SubObject, const UWorld* World);
 
    ENGINE_API static void UpdateSubObjectGroupMemberships(const APlayerController* PC);
 
    ENGINE_API static void RemoveSubObjectGroupMembership(const APlayerController* PC, const FName NetGroup);
 
    ENGINE_API static void AddDependentActor(const AActor* Parent, AActor* Child, EDependentObjectSchedulingHint SchedulingHint);
 
    ENGINE_API static void AddDependentActor(const AActor* Parent, AActor* Child);
 
    ENGINE_API static void RemoveDependentActor(const AActor* Parent, AActor* Child);
 
    ENGINE_API static void StartReplicatingActorsInWorldForNetDriver(UWorld* World, UNetDriver* NetDriver);
 
    ENGINE_API static void NotifyActorDormancyChange(UReplicationSystem* ReplicationSystem, AActor* Actor, ENetDormancy OldDormancyState);
 
    ENGINE_API static void FlushNetDormancy(UReplicationSystem* ReplicationSystem, AActor* Actor, bool bWasDormInitial);
 
    ENGINE_API static void SetReplicationCondition(FNetHandle NetHandle, EReplicationCondition Condition, bool bEnableCondition);
 
    ENGINE_API static void SetStaticPriority(const AActor* Actor, float Priority);
 
    ENGINE_API static void SetCullDistanceOverride(const AActor* Actor, float CullDistSqr);
 
    ENGINE_API static void ClearCullDistanceOverride(const AActor* Actor);
 
    ENGINE_API static void SetPollFrequency(const UObject* Object, float PollFrequency);
};
 
}