1. Epic GamesDeveloper
  3. UActorChannel

UActorChannel

A channel for exchanging actor and its subobject's properties and RPCs.

Unreal Engine C++ API Reference > Runtime > Engine > Engine

Inheritance Hierarchy

References

   
Module Engine
Header /Engine/Source/Runtime/Engine/Classes/Engine/ActorChannel.h
Include #include "Engine/ActorChannel.h"

Syntax

UCLASS (Transient, CustomConstructor, MinimalAPI)  
class UActorChannel : public UChannel

Remarks

A channel for exchanging actor and its subobject's properties and RPCs.

ActorChannel manages the creation and lifetime of a replicated actor. Actual replication of properties and RPCs actually happens in FObjectReplicator now (see DataReplication.h).

An ActorChannel bunch looks like this:

+-------------------+------------------------------------------------------------------------+ | SpawnInfo | (Spawn Info) Initial bunch only | | -Actor Class | -Created by ActorChannel | | -Spawn Loc/Rot | | | NetGUID assigns | | | -Actor NetGUID | | | -Component NetGUIDs | | +-------------------+------------------------------------------------------------------------+ | | | +-------------------+------------------------------------------------------------------------+ | NetGUID ObjRef | (Content chunks) x number of replicating objects (Actor + any components) | | | -Each chunk created by its own FObjectReplicator instance. | +-------------------+------------------------------------------------------------------------+ | | |

Properties...

RPCs...

+-------------------+------------------------------------------------------------------------+ | | | +-------------------+------------------------------------------------------------------------+

Variables

  Type Name Description
Public variable UProperty TObjectPtr< AActor > Actor Variables.
Public variable FNetworkGUID ActorNetGUID  
Public variable TSharedPtr< FObjectReplicator > ActorReplicator  
Public variable uint32: 1 bBlockChannelFailure Whether or not to block sending of NMT_ActorChannelFailure (for NetcodeUnitTest)
Public variable uint32: 1 bClearRecentActorRefs Whether we should nullptr references to this channel's Actor in other channels' Recent data when this channel is closed set to false in cases where the Actor can't become relevant again (e.g. destruction) as it's unnecessary in that case
Public variable uint32: 1 bForceCompareProperties  
Public variable uint32: 1 bHoldQueuedExportBunchesAndGUIDs  
Public variable uint32: 1 bIsReplicatingActor  
Public variable UProperty TArray< TObjectPtr< UObject > > CreateSubObjects  
Public variable float CustomTimeDilation  
Public variable double LastUpdateTime  
Public variable TSet< FNetworkGUID > PendingGuidResolves  
Public variable TArray< int32 > PendingObjKeys Keys pending in this bunch.
Public variable TArray< class FInBunch * > QueuedBunches Async networking loading support state.
Public variable double QueuedBunchStartTime  
Public variable EChannelCloseReason QueuedCloseReason  
Public variable TArray< class FOutBunch * > QueuedExportBunches  
Public variable TArray< FNetworkGUID > QueuedMustBeMappedGuidsInLastBunch  
Public variable double RelevantTime Variables.
Public variable TMap< UObject *, TSharedRef< FObjectReplicator > > ReplicationMap  
Public variable uint32: 1 SpawnAcked  
Public variable TMap< int32, FPacketRepKeyInfo > SubobjectNakMap Maps packetId to keys in Subobject.
Public variable TMap< int32, int32 > SubobjectRepKeyMap Maps ObjID to the current RepKey.

Constructors

  Type Name Description
Public function  

UActorChannel ( const FObjectInitializer& ObjectInitializer
)

 Default constructor

Destructors

  Type Name Description
Public function    

Functions

  Type Name Description
Public function Static void  
Public function void Release any references this channel is holding to UObjects and object replicators and mark it as broken.
Public function Static bool Only returns true when calling ReplicateSubobjects() while we are trying to detect bad usage of the legacy function.
Public function Static bool

CanSubObjectReplicateToClient ( const APlayerController* PlayerController,
ELifetimeCondition NetCondition,
FObjectKey SubObjectKey,
const TStaticBitArray< COND_Max >& ConditionMap,
const UE::Net::FNetConditionGroupManager& ConditionGroupManager
)

  
Public function void

CleanupReplicators ( const bool bKeepReplicators
)

 Cleans up replicators and clears references to the actor class this channel was associated with.
Protected function TSharedRef< FObjectReplicator > &

CreateReplicator ( UObject* Obj,
bool bCheckDormantReplicators
)

 Creates a new object replicator.
Protected function TSharedRef< FObjectReplicator > & Creates a new object replicator or reuses a replicator if it was stored for dormancy in the Connection.
Protected function void  
Protected function bool Handle the replication of subobjects for this actor.
Protected function TSharedRef< FObjectReplicator > &

FindOrCreateReplicator ( UObject* Obj,
bool* bOutCreated
)

 Convenience method for finding a replicator, and creating one if necessary, all at once.
Protected function TSharedRef< FObjectReplicator > * Attempts to find a valid, non-dormant replicator for the given object.
Protected function TSharedRef< FObjectReplicator > *

FindReplicator ( UObject* Obj,
bool* bOutFoundInvalid
)

 Attempts to find a valid, non-dormant replicator for the given object.
Public function Const AActor * UActorChannel interface and accessors.
Public function FObjectReplicator & Returns the replicator for the actor associated with this channel. Guaranteed to exist.
Public function Const const TArray< TObjectPtr< UObject > > &  
Public function FNetFieldExportGroup * Finds the net field export group for a class net cache, if not found, creates one
Public function FNetFieldExportGroup * Finds (or creates) the net field export group for a class net cache, if not found, creates one
Public function Const bool  
Public function Const bool Tells if the actor is ready to be replicated since he is BeginPlay or inside BeginPlay
Public function bool

KeyNeedsToReplicate ( int32 ObjID,
int32 RepKey
)

 Returns true if the given ObjID is not up to date with RepKey this implicitly 'writes' the RepKey to the current out bunch.
Protected function void Unmap all references to this object, so that if later we receive this object again, we can remap the original references
Public function Virtual void

NotifyActorChannelOpen ( AActor* InActor,
FInBunch& InBunch
)

  
Protected function Const bool  
Public function void If not queueing the RPC, prepare the channel for replicating the call.
Public function void

ProcessBunch ( FInBunch& Bunch
)

  
Public function bool  
Public function void

QueueRemoteFunctionBunch ( UObject* CallTarget,
UFunction* Func,
FOutBunch& Bunch
)

 Queue a function bunch for this channel to be sent on the next property update.
Public function UObject *

ReadContentBlockHeader ( FInBunch& Bunch,
bool& bObjectDeleted,
bool& bOutHasRepLayout
)

 Reads the header of the content block and instantiates the subobject if necessary
Public function UObject *

ReadContentBlockPayload ( FInBunch& Bunch,
FNetBitReader& OutPayload,
bool& bOutHasRepLayout
)

 Reads content block header and payload
Public function Const bool

ReadFieldHeaderAndPayload ( UObject* Object,
const FClassNetCache* ClassCache,
FNetFieldExportGroup* NetFieldExportGroup,
FNetBitReader& Bunch,
const FFieldNetCache** OutField,
FNetBitReader& OutPayload
)

 Reads property/function header and data blob from network stream
Public function void

ReleaseReferences ( bool bKeepReplicators
)

  
Public function int64 Replicate this channel's actor differences.
Public function bool

ReplicateSubobject ( UActorComponent* ActorChannel,
FOutBunch& Bunch,
FReplicationFlags RepFlags
)

 Replicates an ActorComponent subobject.
Public function bool Replicates given subobject on this actor channel
Public function Virtual bool

ReplicateSubobjectCustom ( UObject* Obj,
FOutBunch& Bunch,
const FReplicationFlags& RepFlags
)

 Custom implementation for ReplicateSubobject when RepFlags.bUseCustomSubobjectReplication is true
Public function bool

ReplicateSubobjectList ( TArray< Type* >& ObjectList,
FOutBunch& Bunch,
const FReplicationFlags& RepFlags
)

 Utility template for replicating list of replicated subobjects
Public function void Set this channel's actor to the given actor.
Public function Static void  
Public function Static void

SetCurrentSubObjectOwner ( AActor* SubObjectOwner
)

 Subobject Replication state
Public function void

SetForcedSerializeFromRPC ( bool bInFromRPC
)

  
Public function void

SetSkipRoleSwap ( const bool bShouldSkip
)

  
Protected function const TCHAR *  
Protected function void Writes the header for a content block specifically for deleting sub-objects
Public function void Writes the header for a content block specifically for deleting sub-objects
Public function void

WriteContentBlockHeader ( UObject* Obj,
FNetBitWriter& Bunch,
const bool bHasRepLayout
)

 Writes the header for a content block of properties / RPCs for the given object (either the actor a subobject of the actor)
Public function int32

WriteContentBlockPayload ( UObject* Obj,
FNetBitWriter& Bunch,
const bool bHasRepLayout,
FNetBitWriter& Payload
)

 Writes header and payload of content block
Public function int32

WriteFieldHeaderAndPayload ( FNetBitWriter& Bunch,
const FClassNetCache* ClassCache,
const FFieldNetCache* FieldCache,
FNetFieldExportGroup* NetFieldExportGroup,
FNetBitWriter& Payload,
bool bIgnoreInternalAck
)

 Writes property/function header and data blob to network stream

Overridden from UChannel

  Type Name Description
Public function Virtual void Notification that this channel has been placed in a channel pool and needs to reset to its original state so it can be used again like a new channel
Public function Virtual void

AppendExportBunches ( TArray< FOutBunch* >& OutExportBunches
)

 Append any export bunches
Public function Virtual void Append any "must be mapped" guids to front of bunch.
Protected function Virtual void Closes the actor channel but with a 'dormant' flag set so it can be reopened
Public function Virtual Const bool Return true to indicate that this channel no longer needs to Tick() every frame.
Protected function Virtual bool

CleanUp ( const bool bForDestroy,
EChannelCloseReason CloseReason
)

 Cleans up channel structures and nulls references to the channel
Public function Virtual int64 Close the base channel. Returns how many bits were written to the send buffer
Public function Virtual FString Describe the channel.
Public function Virtual void

Init ( UNetConnection* InConnection,
int32 InChIndex,
EChannelCreateFlags CreateFlags
)

 UChannel interface.
Public function Virtual bool

ReadyForDormancy ( bool debug
)

 Returns true if channel is ready to go dormant (e.g., all outstanding property updates have been ACK'd)
Public function Virtual void

ReceivedBunch ( FInBunch& Bunch
)

 Handle an incoming bunch.
Public function Virtual void

ReceivedNak ( int32 NakPacketId
)

 Negative acknowledgment processing.
Public function Virtual void Set the closing flag.
Public function Virtual void Puts the channel in a state to start becoming dormant.
Public function Virtual void

Tick ()

 Handle time passing on this channel.

Overridden from UObject

  Type Name Description
Public function Virtual void Handles reading, writing, and reference collecting using FArchive.

Classes

  Type Name Description
Public struct FPacketRepKeyInfo    

Enums

  Type Name Description
Protected enum ESubObjectDeleteFlag    

Constants

Name Description
ClassNetCacheSuffix  
SubobjectRepKeyBufferSize Static size for SubobjectRepKeyMap. Allows us to resuse arrays and avoid dyanmic memory allocations.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page