Class GhostSendSystem
Inheritance
GhostSendSystem
Inherited Members
Unity.Entities.SystemBase.UnmanagedUpdate$BurstManaged(System.IntPtr, Unity.Entities.SystemDependencySafetyUtility.SafetyErrorDetails)
Syntax
[UpdateInGroup(typeof(ServerSimulationSystemGroup), OrderLast = true)]
[UpdateAfter(typeof(EndSimulationEntityCommandBufferSystem))]
public class GhostSendSystem : SystemBase, IGhostMappingSystem
Fields
CleanupConnectionStatePerTick
The number of connections to cleanup unused serialization data for in a single tick. Setting this
higher can recover memory faster, but uses more CPU time.
Declaration
public int CleanupConnectionStatePerTick
Field Value
EnablePerComponentProfiling
Enable profiling scopes for each component in a ghost. They can help tracking down why a ghost
is expensive to serialize - but they come with a performance cost so they are not enabled by default.
Declaration
public bool EnablePerComponentProfiling
Field Value
ForcePreSerialize
Force all ghosts to use pre serialization. This means part of the serialization will be done once for
all connection instead of once per connection. This can increase CPU time for simple ghosts and ghosts
which are rarely sent. This switch is meant as a way of measuring which ghosts would benefit from using
pre-serialization.
Declaration
public bool ForcePreSerialize
Field Value
ForceSingleBaseline
Force all ghosts to use a single baseline. This will reduce CPU usage at the expense of increased
bandwidth usage. This is mostly meant as a way of measuring which ghosts should use static optimization
instead of dynamic. If the bits / ghost does not significantly increase when enabling this the ghost
can use static optimization to save CPU.
Declaration
public bool ForceSingleBaseline
Field Value
KeepSnapshotHistoryOnStructuralChange
Try to keep the snapshot history buffer for an entity when there is a structucal change.
Doing this will require a lookup and copy of data whenever a ghost has a structucal change
which will add additional CPU cost on the server.
Keeping the snapshot history will not always be possible so this flag does no give a 100% guarantee,
you are expected to measure CPU and bandwidth when changing this.
Declaration
public bool KeepSnapshotHistoryOnStructuralChange
Field Value
m_AllocatedGhostIds
Declaration
protected NativeArray<int> m_AllocatedGhostIds
Field Value
MaxSendChunks
The maximum number of chunks the system will try to send to a single connection in a single frame.
A chunk will count as sent even if it does not contain any ghosts which needed to be sent (because
of relevancy or static optimization).
If there are more chunks than this the least important chunks will not be sent even if there is space
in the packet. This can be used to control CPU time on the server.
Declaration
Field Value
MaxSendEntities
The maximum number of entities the system will try to send to a single connection in a single frame.
An entity will count even if it is not actually sent (because of relevancy or static optimization).
If there are more chunks than this the least important chunks will not be sent even if there is space
in the packet. This can be used to control CPU time on the server.
Declaration
public int MaxSendEntities
Field Value
MinDistanceScaledSendImportance
The minimum importance considered for inclusion in a snapshot after applying distance based
priority scaling. Any ghost importance lower than this value will not be send every frame
even if there is enough space in the packet.
Declaration
public int MinDistanceScaledSendImportance
Field Value
MinSendImportance
The minimum importance considered for inclusion in a snapshot. Any ghost importance lower
than this value will not be send every frame even if there is enough space in the packet.
E.g. Value=60, tick-rate=60, ghost.importance=1 implies a ghost will be replicated roughly once per second.
Declaration
public int MinSendImportance
Field Value
Properties
FirstSendImportanceMultiplier
Non-zero values for MinSendImportance can cause both:
a) 'unchanged chunks that are "new" to a new-joiner' and b) 'newly spawned chunks'
to be ignored by the replication priority system for multiple seconds.
If this behaviour is undesirable, set this to be above MinSendImportance.
This multiplies the importance value used on those "new" (to the player or to the world) ghost chunks.
Note: This does not guarantee delivery of all "new" chunks,
it only guarantees that every ghost chunk will get serialized and sent at least once per connection,
as quickly as possible (e.g. assuming you have the bandwidth for it).
Declaration
public uint FirstSendImportanceMultiplier { get; set; }
Property Value
GhostRelevancyMode
Declaration
public GhostRelevancyMode GhostRelevancyMode { get; set; }
Property Value
GhostRelevancySet
Declaration
public NativeParallelHashMap<RelevantGhostForConnection, int> GhostRelevancySet { get; }
Property Value
GhostRelevancySetWriteHandle
Declaration
public JobHandle GhostRelevancySetWriteHandle { get; set; }
Property Value
IrrelevantImportanceDownScale
Value used to scale down the importance of chunks where all entities were irrelevant last time it was sent.
The importance is divided by this value. It can be used together with MinSendImportance to make sure
relevancy is not updated every frame for things with low importance.
Declaration
public int IrrelevantImportanceDownScale { get; set; }
Property Value
LastGhostMapWriter
Declaration
public JobHandle LastGhostMapWriter { get; set; }
Property Value
Implements
SpawnedGhostEntityMap
Declaration
public NativeParallelHashMap<SpawnedGhost, Entity> SpawnedGhostEntityMap { get; }
Property Value
Implements
Methods
OnCreate()
Declaration
protected override void OnCreate()
Overrides
OnDestroy()
Declaration
protected override void OnDestroy()
Overrides
OnUpdate()
Declaration
protected override void OnUpdate()
Overrides