InnoLab/com.unity.netcode.gameobjects
Archived
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

com.unity.netcode.gameobjects@1.6.0

Browse Source 
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).

## [1.6.0] - 2023-08-09

### Added

- Added a protected virtual method `NetworkTransform.OnInitialize(ref NetworkTransformState replicatedState)` that just returns the replicated state reference.

### Fixed

- Fixed  issue where invoking `NetworkManager.Shutdown` within `NetworkManager.OnClientStopped` or `NetworkManager.OnServerStopped` would force `NetworkManager.ShutdownInProgress` to remain true after completing the shutdown process. (#2661)
- Fixed issue with client synchronization of position when using half precision and the delta position reaches the maximum value and is collapsed on the host prior to being forwarded to the non-owner clients. (#2636)
- Fixed issue with scale not synchronizing properly depending upon the spawn order of NetworkObjects. (#2636)
- Fixed issue position was not properly transitioning between ownership changes with an owner authoritative NetworkTransform. (#2636)
- Fixed issue where a late joining non-owner client could update an owner authoritative NetworkTransform if ownership changed without any updates to position prior to the non-owner client joining. (#2636)

### Changed
This commit is contained in:
Unity Technologies
2023-08-09 00:00:00 +00:00
parent 0581a42b70
commit b3bd4727ab
16 changed files with 913 additions and 386 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
CHANGELOG.md
View File

@@ -6,6 +6,22 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).
## [1.6.0] - 2023-08-09
### Added
- Added a protected virtual method `NetworkTransform.OnInitialize(ref NetworkTransformState replicatedState)` that just returns the replicated state reference.
### Fixed
- Fixed issue where invoking `NetworkManager.Shutdown` within `NetworkManager.OnClientStopped` or `NetworkManager.OnServerStopped` would force `NetworkManager.ShutdownInProgress` to remain true after completing the shutdown process. (#2661)
- Fixed issue with client synchronization of position when using half precision and the delta position reaches the maximum value and is collapsed on the host prior to being forwarded to the non-owner clients. (#2636)
- Fixed issue with scale not synchronizing properly depending upon the spawn order of NetworkObjects. (#2636)
- Fixed issue position was not properly transitioning between ownership changes with an owner authoritative NetworkTransform. (#2636)
- Fixed issue where a late joining non-owner client could update an owner authoritative NetworkTransform if ownership changed without any updates to position prior to the non-owner client joining. (#2636)
### Changed
## [1.5.2] - 2023-07-24
### Added

13
Components/HalfVector3.cs
View File

@@ -27,7 +27,7 @@ namespace Unity.Netcode.Components
/// <summary>
/// The half float precision value of the z-axis as a <see cref="half"/>.
/// </summary>
public half Z => Axis.x;
public half Z => Axis.z;
/// <summary>
/// Used to store the half float precision values as a <see cref="half3"/>
@@ -39,6 +39,17 @@ namespace Unity.Netcode.Components
/// </summary>
public bool3 AxisToSynchronize;
/// <summary>
/// Directly sets each axial value to the passed in full precision values
/// that are converted to half precision
/// </summary>
internal void Set(float x, float y, float z)
{
Axis.x = math.half(x);
Axis.y = math.half(y);
Axis.z = math.half(z);
}
private void SerializeWrite(FastBufferWriter writer)
{
for (int i = 0; i < Length; i++)

424
Components/NetworkTransform.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using Unity.Collections;
using Unity.Mathematics;
using UnityEngine;
@@ -49,6 +50,11 @@ namespace Unity.Netcode.Components
/// </summary>
public OnClientRequestChangeDelegate OnClientRequestChange;
/// <summary>
/// When set each state update will contain a state identifier
/// </summary>
internal static bool TrackByStateId;
/// <summary>
/// Data structure used to synchronize the <see cref="NetworkTransform"/>
/// </summary>
@@ -71,9 +77,16 @@ namespace Unity.Netcode.Components
private const int k_UseHalfFloats = 0x00004000; // Persists between state updates (authority dictates if this is set)
private const int k_Synchronization = 0x00008000;
private const int k_PositionSlerp = 0x00010000; // Persists between state updates (authority dictates if this is set)
private const int k_IsParented = 0x00020000; // When parented and synchronizing, we need to have both lossy and local scale due to varying spawn order
private const int k_TrackStateId = 0x10000000; // (Internal Debugging) When set each state update will contain a state identifier
// Stores persistent and state relative flags
private uint m_Bitset;
internal uint BitSet
{
get { return m_Bitset; }
set { m_Bitset = value; }
}
// Used to store the tick calculated sent time
internal double SentTime;
@@ -98,6 +111,7 @@ namespace Unity.Netcode.Components
// Used for half precision scale
internal HalfVector3 HalfVectorScale;
internal Vector3 Scale;
internal Vector3 LossyScale;
// Used for half precision quaternion
internal HalfVector4 HalfVectorRotation;
@@ -118,7 +132,6 @@ namespace Unity.Netcode.Components
internal int NetworkTick;
// Used when tracking by state ID is enabled
internal bool TrackByStateId;
internal int StateId;
// Used during serialization
@@ -416,6 +429,24 @@ namespace Unity.Netcode.Components
}
}
internal bool IsParented
{
get => GetFlag(k_IsParented);
set
{
SetFlag(value, k_IsParented);
}
}
internal bool TrackByStateId
{
get => GetFlag(k_TrackStateId);
set
{
SetFlag(value, k_TrackStateId);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private bool GetFlag(int flag)
{
@@ -534,6 +565,8 @@ namespace Unity.Netcode.Components
return NetworkTick;
}
internal HalfVector3 HalfEulerRotation;
/// <summary>
/// Serializes this <see cref="NetworkTransformState"/>
/// </summary>
@@ -553,23 +586,6 @@ namespace Unity.Netcode.Components
positionStart = m_Reader.Position;
}
if (TrackByStateId)
{
var stateId = StateId;
if (IsSynchronizing)
{
StateId = -1;
}
else
{
if (serializer.IsWriter)
{
StateId++;
}
serializer.SerializeValue(ref StateId);
}
}
// Synchronize State Flags and Network Tick
{
if (isWriting)
@@ -589,11 +605,22 @@ namespace Unity.Netcode.Components
}
}
// If debugging states and track by state identifier is enabled, serialize the current state identifier
if (TrackByStateId)
{
serializer.SerializeValue(ref StateId);
}
// Synchronize Position
if (HasPositionChange)
{
if (UseHalfFloatPrecision)
{
// Apply which axis should be updated for both write/read (teleporting, synchronizing, or just updating)
NetworkDeltaPosition.HalfVector3.AxisToSynchronize[0] = HasPositionX;
NetworkDeltaPosition.HalfVector3.AxisToSynchronize[1] = HasPositionY;
NetworkDeltaPosition.HalfVector3.AxisToSynchronize[2] = HasPositionZ;
if (IsTeleportingNextFrame)
{
// **Always use full precision when teleporting and UseHalfFloatPrecision is enabled**
@@ -604,7 +631,7 @@ namespace Unity.Netcode.Components
serializer.SerializeValue(ref DeltaPosition);
if (!isWriting)
{
NetworkDeltaPosition = new NetworkDeltaPosition(Vector3.zero, 0, math.bool3(HasPositionX, HasPositionY, HasPositionZ));
NetworkDeltaPosition.NetworkTick = NetworkTick;
NetworkDeltaPosition.NetworkSerialize(serializer);
}
else
@@ -617,7 +644,7 @@ namespace Unity.Netcode.Components
{
if (!isWriting)
{
NetworkDeltaPosition = new NetworkDeltaPosition(Vector3.zero, 0, math.bool3(HasPositionX, HasPositionY, HasPositionZ));
NetworkDeltaPosition.NetworkTick = NetworkTick;
NetworkDeltaPosition.NetworkSerialize(serializer);
}
else
@@ -626,9 +653,8 @@ namespace Unity.Netcode.Components
}
}
}
else // Legacy Position Synchronization
else // Full precision axis specific position synchronization
{
// Position Values
if (HasPositionX)
{
serializer.SerializeValue(ref PositionX);
@@ -703,11 +729,21 @@ namespace Unity.Netcode.Components
{
if (HasRotAngleChange)
{
var halfPrecisionRotation = new HalfVector3(RotAngleX, RotAngleY, RotAngleZ, math.bool3(HasRotAngleX, HasRotAngleY, HasRotAngleZ));
serializer.SerializeValue(ref halfPrecisionRotation);
// Apply which axis should be updated for both write/read
HalfEulerRotation.AxisToSynchronize[0] = HasRotAngleX;
HalfEulerRotation.AxisToSynchronize[1] = HasRotAngleY;
HalfEulerRotation.AxisToSynchronize[2] = HasRotAngleZ;
if (isWriting)
{
HalfEulerRotation.Set(RotAngleX, RotAngleY, RotAngleZ);
}
serializer.SerializeValue(ref HalfEulerRotation);
if (!isWriting)
{
var eulerRotation = halfPrecisionRotation.ToVector3();
var eulerRotation = HalfEulerRotation.ToVector3();
if (HasRotAngleX)
{
RotAngleX = eulerRotation.x;
@@ -749,6 +785,12 @@ namespace Unity.Netcode.Components
// Synchronize Scale
if (HasScaleChange)
{
// If we are teleporting (which includes synchronizing) and the associated NetworkObject has a parent
// then we want to serialize the LossyScale since NetworkObject spawn order is not guaranteed
if (IsTeleportingNextFrame && IsParented)
{
serializer.SerializeValue(ref LossyScale);
}
// Half precision scale synchronization
if (UseHalfFloatPrecision)
{
@@ -758,9 +800,19 @@ namespace Unity.Netcode.Components
}
else
{
// Apply which axis should be updated for both write/read
HalfVectorScale.AxisToSynchronize[0] = HasScaleX;
HalfVectorScale.AxisToSynchronize[1] = HasScaleY;
HalfVectorScale.AxisToSynchronize[2] = HasScaleZ;
// For scale, when half precision is enabled we can still only send the axis with deltas
HalfVectorScale = new HalfVector3(Scale, math.bool3(HasScaleX, HasScaleY, HasScaleZ));
if (isWriting)
{
HalfVectorScale.Set(Scale[0], Scale[1], Scale[2]);
}
serializer.SerializeValue(ref HalfVectorScale);
if (!isWriting)
{
Scale = HalfVectorScale.ToVector3();
@@ -1029,26 +1081,6 @@ namespace Unity.Netcode.Components
/// </summary>
protected NetworkManager m_CachedNetworkManager; // Note: we no longer use this and are only keeping it until we decide to deprecate it
/// <summary>
/// We have two internal NetworkVariables.
/// One for server authoritative and one for "client/owner" authoritative.
/// </summary>
private readonly NetworkVariable<NetworkTransformState> m_ReplicatedNetworkStateServer = new NetworkVariable<NetworkTransformState>(new NetworkTransformState(), NetworkVariableReadPermission.Everyone, NetworkVariableWritePermission.Server);
private readonly NetworkVariable<NetworkTransformState> m_ReplicatedNetworkStateOwner = new NetworkVariable<NetworkTransformState>(new NetworkTransformState(), NetworkVariableReadPermission.Everyone, NetworkVariableWritePermission.Owner);
internal NetworkVariable<NetworkTransformState> ReplicatedNetworkState
{
get
{
if (!IsServerAuthoritative())
{
return m_ReplicatedNetworkStateOwner;
}
return m_ReplicatedNetworkStateServer;
}
}
/// <summary>
/// Helper method that returns the space relative position of the transform.
/// </summary>
@@ -1149,6 +1181,8 @@ namespace Unity.Netcode.Components
// This represents the most recent local authoritative state.
private NetworkTransformState m_LocalAuthoritativeNetworkState;
internal NetworkTransformState LocalAuthoritativeNetworkState => m_LocalAuthoritativeNetworkState;
private ClientRpcParams m_ClientRpcParams = new ClientRpcParams() { Send = new ClientRpcSendParams() };
private List<ulong> m_ClientIds = new List<ulong>() { 0 };
@@ -1165,6 +1199,9 @@ namespace Unity.Netcode.Components
private Quaternion m_CurrentRotation;
private Vector3 m_TargetRotation;
// Used to for each instance to uniquely identify the named message
private string m_MessageName;
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal void UpdatePositionInterpolator(Vector3 position, double time, bool resetInterpolator = false)
@@ -1258,7 +1295,13 @@ namespace Unity.Netcode.Components
protected override void OnSynchronize<T>(ref BufferSerializer<T> serializer)
{
var targetClientId = m_TargetIdBeingSynchronized;
var synchronizationState = new NetworkTransformState();
var synchronizationState = new NetworkTransformState()
{
HalfEulerRotation = new HalfVector3(),
HalfVectorRotation = new HalfVector4(),
HalfVectorScale = new HalfVector3(),
NetworkDeltaPosition = new NetworkDeltaPosition(),
};
if (serializer.IsWriter)
{
@@ -1286,6 +1329,7 @@ namespace Unity.Netcode.Components
m_LocalAuthoritativeNetworkState = synchronizationState;
m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame = false;
m_LocalAuthoritativeNetworkState.IsSynchronizing = false;
}
}
@@ -1366,11 +1410,11 @@ namespace Unity.Netcode.Components
// If the transform has deltas (returns dirty) then...
if (ApplyTransformToNetworkStateWithInfo(ref m_LocalAuthoritativeNetworkState, ref transformToCommit, synchronize))
{
m_LocalAuthoritativeNetworkState.LastSerializedSize = ReplicatedNetworkState.Value.LastSerializedSize;
m_LocalAuthoritativeNetworkState.LastSerializedSize = m_OldState.LastSerializedSize;
OnAuthorityPushTransformState(ref m_LocalAuthoritativeNetworkState);
// "push"/commit the state
ReplicatedNetworkState.Value = m_LocalAuthoritativeNetworkState;
// Update the state
UpdateTransformState();
m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame = false;
}
@@ -1651,7 +1695,43 @@ namespace Unity.Netcode.Components
}
}
// Only if we are not synchronizing...
// For scale, we need to check for parenting when synchronizing and/or teleporting
if (isSynchronization || networkState.IsTeleportingNextFrame)
{
// This all has to do with complex nested hierarchies and how it impacts scale
// when set for the first time and depending upon whether the NetworkObject is parented
// (or not parented) at the time the scale values are applied.
var hasParentNetworkObject = false;
// If the NetworkObject belonging to this NetworkTransform instance has a parent
// (i.e. this handles nested NetworkTransforms under a parent at some layer above)
if (NetworkObject.transform.parent != null)
{
var parentNetworkObject = NetworkObject.transform.parent.GetComponent<NetworkObject>();
// In-scene placed NetworkObjects parented under a GameObject with no
// NetworkObject preserve their lossyScale when synchronizing.
if (parentNetworkObject == null && NetworkObject.IsSceneObject != false)
{
hasParentNetworkObject = true;
}
else
{
// Or if the relative NetworkObject has a parent NetworkObject
hasParentNetworkObject = parentNetworkObject != null;
}
}
networkState.IsParented = hasParentNetworkObject;
// If we are synchronizing and the associated NetworkObject has a parent then we want to send the
// LossyScale if the NetworkObject has a parent since NetworkObject spawn order is not guaranteed
if (hasParentNetworkObject)
{
networkState.LossyScale = transform.lossyScale;
}
}
// Checking scale deltas when not synchronizing
if (!isSynchronization)
{
if (!UseHalfFloatPrecision)
@@ -1682,7 +1762,7 @@ namespace Unity.Netcode.Components
var previousScale = networkState.Scale;
for (int i = 0; i < 3; i++)
{
if (Mathf.Abs(Mathf.DeltaAngle(previousScale[i], scale[i])) >= ScaleThreshold || networkState.IsTeleportingNextFrame)
if (Mathf.Abs(scale[i] - previousScale[i]) >= ScaleThreshold || networkState.IsTeleportingNextFrame)
{
isScaleDirty = true;
networkState.Scale[i] = scale[i];
@@ -1691,46 +1771,18 @@ namespace Unity.Netcode.Components
}
}
}
else // If we are synchronizing then we need to determine which scale to use
else // Just apply the full local scale when synchronizing
if (SynchronizeScale)
{
// This all has to do with complex nested hierarchies and how it impacts scale
// when set for the first time.
var hasParentNetworkObject = false;
// If the NetworkObject belonging to this NetworkTransform instance has a parent
// (i.e. this handles nested NetworkTransforms under a parent at some layer above)
if (NetworkObject.transform.parent != null)
{
var parentNetworkObject = NetworkObject.transform.parent.GetComponent<NetworkObject>();
// In-scene placed NetworkObjects parented under a GameObject with no
// NetworkObject preserve their lossyScale when synchronizing.
if (parentNetworkObject == null && NetworkObject.IsSceneObject != false)
{
hasParentNetworkObject = true;
}
else
{
// Or if the relative NetworkObject has a parent NetworkObject
hasParentNetworkObject = parentNetworkObject != null;
}
}
// If world position stays is set and the relative NetworkObject is parented under a NetworkObject
// then we want to use the lossy scale for the initial synchronization.
var useLossy = NetworkObject.WorldPositionStays() && hasParentNetworkObject;
var scaleToUse = useLossy ? transform.lossyScale : transform.localScale;
if (!UseHalfFloatPrecision)
{
networkState.ScaleX = scaleToUse.x;
networkState.ScaleY = scaleToUse.y;
networkState.ScaleZ = scaleToUse.z;
networkState.ScaleX = transform.localScale.x;
networkState.ScaleY = transform.localScale.y;
networkState.ScaleZ = transform.localScale.z;
}
else
{
networkState.Scale = scaleToUse;
networkState.Scale = transform.localScale;
}
networkState.HasScaleX = true;
networkState.HasScaleY = true;
@@ -2027,28 +2079,41 @@ namespace Unity.Netcode.Components
if (newState.HasScaleChange)
{
bool shouldUseLossy = false;
if (newState.IsParented)
{
if (transform.parent == null)
{
shouldUseLossy = NetworkObject.WorldPositionStays();
}
else
{
shouldUseLossy = !NetworkObject.WorldPositionStays();
}
}
if (UseHalfFloatPrecision)
{
currentScale = newState.Scale;
currentScale = shouldUseLossy ? newState.LossyScale : newState.Scale;
}
else
{
// Adjust based on which axis changed
if (newState.HasScaleX)
{
currentScale.x = newState.ScaleX;
currentScale.x = shouldUseLossy ? newState.LossyScale.x : newState.ScaleX;
}
if (newState.HasScaleY)
{
currentScale.y = newState.ScaleY;
currentScale.y = shouldUseLossy ? newState.LossyScale.y : newState.ScaleY;
}
if (newState.HasScaleZ)
{
currentScale.z = newState.ScaleZ;
currentScale.z = shouldUseLossy ? newState.LossyScale.z : newState.ScaleZ;
}
}
m_CurrentScale = currentScale;
@@ -2112,7 +2177,7 @@ namespace Unity.Netcode.Components
/// <remarks>
/// Only non-authoritative instances should invoke this
/// </remarks>
private void UpdateState(NetworkTransformState oldState, NetworkTransformState newState)
private void ApplyUpdatedState(NetworkTransformState newState)
{
// Set the transforms's synchronization modes
InLocalSpace = newState.InLocalSpace;
@@ -2142,8 +2207,9 @@ namespace Unity.Netcode.Components
{
// assure our local NetworkDeltaPosition state is updated
m_HalfPositionState.HalfVector3.Axis = m_LocalAuthoritativeNetworkState.NetworkDeltaPosition.HalfVector3.Axis;
// and update our current position
m_LocalAuthoritativeNetworkState.CurrentPosition = m_HalfPositionState.ToVector3(newState.NetworkTick);
// and update our target position
m_TargetPosition = m_HalfPositionState.ToVector3(newState.NetworkTick);
m_LocalAuthoritativeNetworkState.CurrentPosition = m_TargetPosition;
}
if (!Interpolate)
@@ -2154,14 +2220,9 @@ namespace Unity.Netcode.Components
// Apply axial changes from the new state
// Either apply the delta position target position or the current state's delta position
// depending upon whether UsePositionDeltaCompression is enabled
if (m_LocalAuthoritativeNetworkState.HasPositionChange)
{
if (m_LocalAuthoritativeNetworkState.UseHalfFloatPrecision)
{
UpdatePositionInterpolator(m_LocalAuthoritativeNetworkState.CurrentPosition, sentTime);
}
else
if (!m_LocalAuthoritativeNetworkState.UseHalfFloatPrecision)
{
var newTargetPosition = m_TargetPosition;
if (m_LocalAuthoritativeNetworkState.HasPositionX)
@@ -2178,9 +2239,9 @@ namespace Unity.Netcode.Components
{
newTargetPosition.z = m_LocalAuthoritativeNetworkState.PositionZ;
}
UpdatePositionInterpolator(newTargetPosition, sentTime);
m_TargetPosition = newTargetPosition;
}
UpdatePositionInterpolator(m_TargetPosition, sentTime);
}
if (m_LocalAuthoritativeNetworkState.HasScaleChange)
@@ -2263,6 +2324,8 @@ namespace Unity.Netcode.Components
}
private NetworkTransformState m_OldState = new NetworkTransformState();
/// <summary>
/// Only non-authoritative instances should invoke this method
/// </summary>
@@ -2276,8 +2339,8 @@ namespace Unity.Netcode.Components
// Get the time when this new state was sent
newState.SentTime = new NetworkTime(NetworkManager.NetworkConfig.TickRate, newState.NetworkTick).Time;
// Update the state
UpdateState(oldState, newState);
// Apply the new state
ApplyUpdatedState(newState);
// Provide notifications when the state has been updated
OnNetworkTransformStateUpdated(ref oldState, ref newState);
@@ -2360,10 +2423,19 @@ namespace Unity.Netcode.Components
internal void OnUpdateAuthoritativeState(ref Transform transformSource)
{
// If our replicated state is not dirty and our local authority state is dirty, clear it.
if (!ReplicatedNetworkState.IsDirty() && m_LocalAuthoritativeNetworkState.IsDirty && !m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame)
if (m_LocalAuthoritativeNetworkState.IsDirty && !m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame)
{
// Now clear our bitset and prepare for next network tick state update
m_LocalAuthoritativeNetworkState.ClearBitSetForNextTick();
if (TrackByStateId)
{
m_LocalAuthoritativeNetworkState.TrackByStateId = true;
m_LocalAuthoritativeNetworkState.StateId++;
}
else
{
m_LocalAuthoritativeNetworkState.TrackByStateId = false;
}
}
AxisChangedDeltaPositionCheck();
@@ -2394,20 +2466,31 @@ namespace Unity.Netcode.Components
}
}
/// <inheritdoc/>
public override void OnNetworkSpawn()
{
///////////////////////////////////////////////////////////////
// NOTE: Legacy and no longer used (candidates for deprecation)
m_CachedIsServer = IsServer;
m_CachedNetworkManager = NetworkManager;
///////////////////////////////////////////////////////////////
// Register a custom named message specifically for this instance
m_MessageName = $"NTU_{NetworkObjectId}_{NetworkBehaviourId}";
NetworkManager.CustomMessagingManager.RegisterNamedMessageHandler(m_MessageName, TransformStateUpdate);
Initialize();
}
/// <inheritdoc/>
public override void OnNetworkDespawn()
{
ReplicatedNetworkState.OnValueChanged -= OnNetworkStateChanged;
if (!NetworkManager.ShutdownInProgress && NetworkManager.CustomMessagingManager != null)
{
NetworkManager.CustomMessagingManager.UnregisterNamedMessageHandler(m_MessageName);
}
CanCommitToTransform = false;
if (NetworkManager != null && NetworkManager.NetworkTickSystem != null)
{
@@ -2424,9 +2507,6 @@ namespace Unity.Netcode.Components
}
CanCommitToTransform = false;
base.OnDestroy();
m_ReplicatedNetworkStateServer.Dispose();
m_ReplicatedNetworkStateOwner.Dispose();
}
/// <inheritdoc/>
@@ -2453,7 +2533,20 @@ namespace Unity.Netcode.Components
/// <summary>
/// Invoked when first spawned and when ownership changes.
/// </summary>
/// <param name="replicatedState">the <see cref="NetworkVariable{T}"/> replicated <see cref="NetworkTransformState"/></param>
/// <param name="replicatedState">the current <see cref="NetworkTransformState"/> after initializing</param>
protected virtual void OnInitialize(ref NetworkTransformState replicatedState)
{
}
/// <summary>
/// An owner read and owner write NetworkVariable so it doesn't generate any messages
/// </summary>
private NetworkVariable<NetworkTransformState> m_InternalStatNetVar = new NetworkVariable<NetworkTransformState>(default, NetworkVariableReadPermission.Owner, NetworkVariableWritePermission.Owner);
/// <summary>
/// This method is only invoked by the owner
/// Use: OnInitialize(ref NetworkTransformState replicatedState) to be notified on all instances
/// </summary>
/// <param name="replicatedState"></param>
protected virtual void OnInitialize(ref NetworkVariable<NetworkTransformState> replicatedState)
{
@@ -2470,7 +2563,6 @@ namespace Unity.Netcode.Components
}
CanCommitToTransform = IsServerAuthoritative() ? IsServer : IsOwner;
var replicatedState = ReplicatedNetworkState;
var currentPosition = GetSpaceRelativePosition();
var currentRotation = GetSpaceRelativeRotation();
@@ -2490,14 +2582,12 @@ namespace Unity.Netcode.Components
}
else
{
// Sanity check to assure we only subscribe to OnValueChanged once
replicatedState.OnValueChanged -= OnNetworkStateChanged;
replicatedState.OnValueChanged += OnNetworkStateChanged;
// Assure we no longer subscribe to the tick event
NetworkManager.NetworkTickSystem.Tick -= NetworkTickSystem_Tick;
ResetInterpolatedStateToCurrentAuthoritativeState();
m_CurrentPosition = currentPosition;
m_TargetPosition = currentPosition;
m_CurrentScale = transform.localScale;
@@ -2506,8 +2596,13 @@ namespace Unity.Netcode.Components
m_TargetRotation = currentRotation.eulerAngles;
}
OnInitialize(ref m_LocalAuthoritativeNetworkState);
OnInitialize(ref replicatedState);
if (IsOwner)
{
m_InternalStatNetVar.Value = m_LocalAuthoritativeNetworkState;
OnInitialize(ref m_InternalStatNetVar);
}
}
/// <inheritdoc/>
@@ -2690,12 +2785,6 @@ namespace Unity.Netcode.Components
}
}
// If we have not received any additional state updates since the very
// initial synchronization, then exit early.
if (m_LocalAuthoritativeNetworkState.IsSynchronizing)
{
return;
}
// Apply the current authoritative state
ApplyAuthoritativeState();
}
@@ -2738,6 +2827,103 @@ namespace Unity.Netcode.Components
{
return OnIsServerAuthoritative();
}
/// <summary>
/// Receives the <see cref="NetworkTransformState"/> named message updates
/// </summary>
/// <param name="senderId">authority of the transform</param>
/// <param name="messagePayload">serialzied <see cref="NetworkTransformState"/></param>
private void TransformStateUpdate(ulong senderId, FastBufferReader messagePayload)
{
// Forward owner authoritative messages before doing anything else
if (IsServer && !OnIsServerAuthoritative())
{
ForwardStateUpdateMessage(messagePayload);
}
// Store the previous/old state
m_OldState = m_LocalAuthoritativeNetworkState;
// Deserialize the message
messagePayload.ReadNetworkSerializableInPlace(ref m_LocalAuthoritativeNetworkState);
// Apply the message
OnNetworkStateChanged(m_OldState, m_LocalAuthoritativeNetworkState);
}
/// <summary>
/// Forwards owner authoritative state updates when received by the server
/// </summary>
/// <param name="messagePayload">the owner state message payload</param>
private unsafe void ForwardStateUpdateMessage(FastBufferReader messagePayload)
{
var currentPosition = messagePayload.Position;
var messageSize = messagePayload.Length - currentPosition;
var writer = new FastBufferWriter(messageSize, Allocator.Temp);
using (writer)
{
writer.WriteBytesSafe(messagePayload.GetUnsafePtr(), messageSize, currentPosition);
var clientCount = NetworkManager.ConnectionManager.ConnectedClientsList.Count;
for (int i = 0; i < clientCount; i++)
{
var clientId = NetworkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
if (!OnIsServerAuthoritative() && (NetworkManager.ServerClientId == clientId || clientId == OwnerClientId))
{
continue;
}
NetworkManager.CustomMessagingManager.SendNamedMessage(m_MessageName, clientId, writer);
}
}
messagePayload.Seek(currentPosition);
}
/// <summary>
/// Sends <see cref="NetworkTransformState"/> named message updates by the authority of the transform
/// </summary>
private void UpdateTransformState()
{
if (NetworkManager.ShutdownInProgress)
{
return;
}
bool isServerAuthoritative = OnIsServerAuthoritative();
if (isServerAuthoritative && !IsServer)
{
Debug.LogError($"Server authoritative {nameof(NetworkTransform)} can only be updated by the server!");
}
else if (!isServerAuthoritative && !IsServer && !IsOwner)
{
Debug.LogError($"Owner authoritative {nameof(NetworkTransform)} can only be updated by the owner!");
}
var customMessageManager = NetworkManager.CustomMessagingManager;
var writer = new FastBufferWriter(128, Allocator.Temp);
using (writer)
{
writer.WriteNetworkSerializable(m_LocalAuthoritativeNetworkState);
// Server-host always sends updates to all clients (but itself)
if (IsServer)
{
var clientCount = NetworkManager.ConnectionManager.ConnectedClientsList.Count;
for (int i = 0; i < clientCount; i++)
{
var clientId = NetworkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
if (NetworkManager.ServerClientId == clientId)
{
continue;
}
customMessageManager.SendNamedMessage(m_MessageName, clientId, writer);
}
}
else
{
// Clients (owner authoritative) send messages to the server-host
customMessageManager.SendNamedMessage(m_MessageName, NetworkManager.ServerClientId, writer);
}
}
}
}
internal interface INetworkTransformLogStateEntry

68
Editor/CodeGen/INetworkMessageILPP.cs
View File

@@ -7,6 +7,7 @@ using Mono.Cecil.Cil;
using Mono.Cecil.Rocks;
using Unity.CompilationPipeline.Common.Diagnostics;
using Unity.CompilationPipeline.Common.ILPostProcessing;
using UnityEngine;
using ILPPInterface = Unity.CompilationPipeline.Common.ILPostProcessing.ILPostProcessor;
using MethodAttributes = Mono.Cecil.MethodAttributes;
@@ -101,6 +102,8 @@ namespace Unity.Netcode.Editor.CodeGen
private ModuleDefinition m_NetcodeModule;
private PostProcessorAssemblyResolver m_AssemblyResolver;
private MethodReference m_RuntimeInitializeOnLoadAttribute_Ctor;
private MethodReference m_MessageManager_ReceiveMessage_MethodRef;
private MethodReference m_MessageManager_CreateMessageAndGetVersion_MethodRef;
private TypeReference m_MessageManager_MessageWithHandler_TypeRef;
@@ -125,6 +128,7 @@ namespace Unity.Netcode.Editor.CodeGen
// (i.e., there's no #if UNITY_EDITOR in them that could create invalid IL code)
TypeDefinition typeTypeDef = moduleDefinition.ImportReference(typeof(Type)).Resolve();
TypeDefinition listTypeDef = moduleDefinition.ImportReference(typeof(List<>)).Resolve();
m_RuntimeInitializeOnLoadAttribute_Ctor = moduleDefinition.ImportReference(typeof(RuntimeInitializeOnLoadMethodAttribute).GetConstructor(new Type[] { }));
TypeDefinition messageHandlerTypeDef = null;
TypeDefinition versionGetterTypeDef = null;
@@ -232,25 +236,6 @@ namespace Unity.Netcode.Editor.CodeGen
return true;
}
private MethodDefinition GetOrCreateStaticConstructor(TypeDefinition typeDefinition)
{
var staticCtorMethodDef = typeDefinition.GetStaticConstructor();
if (staticCtorMethodDef == null)
{
staticCtorMethodDef = new MethodDefinition(
".cctor", // Static Constructor (constant-constructor)
MethodAttributes.HideBySig |
MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName |
MethodAttributes.Static,
typeDefinition.Module.TypeSystem.Void);
staticCtorMethodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
typeDefinition.Methods.Add(staticCtorMethodDef);
}
return staticCtorMethodDef;
}
private void CreateInstructionsToRegisterType(ILProcessor processor, List<Instruction> instructions, TypeReference type, MethodReference receiveMethod, MethodReference versionMethod)
{
// NetworkMessageManager.__network_message_types.Add(new NetworkMessageManager.MessageWithHandler{MessageType=typeof(type), Handler=type.Receive});
@@ -295,29 +280,32 @@ namespace Unity.Netcode.Editor.CodeGen
// https://web.archive.org/web/20100212140402/http://blogs.msdn.com/junfeng/archive/2005/11/19/494914.aspx
private void CreateModuleInitializer(AssemblyDefinition assembly, List<TypeDefinition> networkMessageTypes)
{
foreach (var typeDefinition in assembly.MainModule.Types)
var typeDefinition = new TypeDefinition("__GEN", "INetworkMessageHelper", TypeAttributes.NotPublic | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit, assembly.MainModule.TypeSystem.Object);
var staticCtorMethodDef = new MethodDefinition(
$"InitializeMessages",
MethodAttributes.Assembly |
MethodAttributes.Static,
assembly.MainModule.TypeSystem.Void);
staticCtorMethodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
staticCtorMethodDef.CustomAttributes.Add(new CustomAttribute(m_RuntimeInitializeOnLoadAttribute_Ctor));
typeDefinition.Methods.Add(staticCtorMethodDef);
var instructions = new List<Instruction>();
var processor = staticCtorMethodDef.Body.GetILProcessor();
foreach (var type in networkMessageTypes)
{
if (typeDefinition.FullName == "<Module>")
{
var staticCtorMethodDef = GetOrCreateStaticConstructor(typeDefinition);
var processor = staticCtorMethodDef.Body.GetILProcessor();
var instructions = new List<Instruction>();
foreach (var type in networkMessageTypes)
{
var receiveMethod = new GenericInstanceMethod(m_MessageManager_ReceiveMessage_MethodRef);
receiveMethod.GenericArguments.Add(type);
var versionMethod = new GenericInstanceMethod(m_MessageManager_CreateMessageAndGetVersion_MethodRef);
versionMethod.GenericArguments.Add(type);
CreateInstructionsToRegisterType(processor, instructions, type, receiveMethod, versionMethod);
}
instructions.ForEach(instruction => processor.Body.Instructions.Insert(processor.Body.Instructions.Count - 1, instruction));
break;
}
var receiveMethod = new GenericInstanceMethod(m_MessageManager_ReceiveMessage_MethodRef);
receiveMethod.GenericArguments.Add(type);
var versionMethod = new GenericInstanceMethod(m_MessageManager_CreateMessageAndGetVersion_MethodRef);
versionMethod.GenericArguments.Add(type);
CreateInstructionsToRegisterType(processor, instructions, type, receiveMethod, versionMethod);
}
instructions.ForEach(instruction => processor.Body.Instructions.Insert(processor.Body.Instructions.Count - 1, instruction));
assembly.MainModule.Types.Add(typeDefinition);
}
}
}

347
Editor/CodeGen/NetworkBehaviourILPP.cs
View File

@@ -109,25 +109,6 @@ namespace Unity.Netcode.Editor.CodeGen
return new ILPostProcessResult(new InMemoryAssembly(pe.ToArray(), pdb.ToArray()), m_Diagnostics);
}
private MethodDefinition GetOrCreateStaticConstructor(TypeDefinition typeDefinition)
{
var staticCtorMethodDef = typeDefinition.GetStaticConstructor();
if (staticCtorMethodDef == null)
{
staticCtorMethodDef = new MethodDefinition(
".cctor", // Static Constructor (constant-constructor)
MethodAttributes.HideBySig |
MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName |
MethodAttributes.Static,
typeDefinition.Module.TypeSystem.Void);
staticCtorMethodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
typeDefinition.Methods.Add(staticCtorMethodDef);
}
return staticCtorMethodDef;
}
private bool IsMemcpyableType(TypeReference type)
{
foreach (var supportedType in BaseSupportedTypes)
@@ -156,178 +137,182 @@ namespace Unity.Netcode.Editor.CodeGen
private void CreateNetworkVariableTypeInitializers(AssemblyDefinition assembly)
{
foreach (var typeDefinition in assembly.MainModule.Types)
var typeDefinition = new TypeDefinition("__GEN", "NetworkVariableSerializationHelper", TypeAttributes.NotPublic | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit, assembly.MainModule.TypeSystem.Object);
var staticCtorMethodDef = new MethodDefinition(
$"InitializeSerialization",
MethodAttributes.Assembly |
MethodAttributes.Static,
assembly.MainModule.TypeSystem.Void);
staticCtorMethodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
staticCtorMethodDef.CustomAttributes.Add(new CustomAttribute(m_RuntimeInitializeOnLoadAttribute_Ctor));
typeDefinition.Methods.Add(staticCtorMethodDef);
var instructions = new List<Instruction>();
var processor = staticCtorMethodDef.Body.GetILProcessor();
foreach (var type in m_WrappedNetworkVariableTypes)
{
if (typeDefinition.FullName == "<Module>")
if (type.Resolve() == null)
{
var staticCtorMethodDef = GetOrCreateStaticConstructor(typeDefinition);
continue;
}
var processor = staticCtorMethodDef.Body.GetILProcessor();
if (IsSpecialCaseType(type))
{
continue;
}
var instructions = new List<Instruction>();
// If a serializable type isn't found, FallbackSerializer will be used automatically, which will
// call into UserNetworkVariableSerialization, giving the user a chance to define their own serializaiton
// for types that aren't in our official supported types list.
GenericInstanceMethod serializeMethod = null;
GenericInstanceMethod equalityMethod;
foreach (var type in m_WrappedNetworkVariableTypes)
if (type.Resolve().FullName == "Unity.Collections.NativeArray`1")
{
var wrappedType = ((GenericInstanceType)type).GenericArguments[0];
if (IsSpecialCaseType(wrappedType) || wrappedType.HasInterface(typeof(INetworkSerializeByMemcpy).FullName) || wrappedType.Resolve().IsEnum || IsMemcpyableType(wrappedType))
{
if (type.Resolve() == null)
{
continue;
}
if (IsSpecialCaseType(type))
{
continue;
}
// If a serializable type isn't found, FallbackSerializer will be used automatically, which will
// call into UserNetworkVariableSerialization, giving the user a chance to define their own serializaiton
// for types that aren't in our official supported types list.
GenericInstanceMethod serializeMethod = null;
GenericInstanceMethod equalityMethod;
if (type.Resolve().FullName == "Unity.Collections.NativeArray`1")
{
var wrappedType = ((GenericInstanceType)type).GenericArguments[0];
if (IsSpecialCaseType(wrappedType) || wrappedType.HasInterface(typeof(INetworkSerializeByMemcpy).FullName) || wrappedType.Resolve().IsEnum || IsMemcpyableType(wrappedType))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyArray_MethodRef);
}
else if (wrappedType.HasInterface(typeof(INetworkSerializable).FullName))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableArray_MethodRef);
}
else if (wrappedType.HasInterface(CodeGenHelpers.IUTF8Bytes_FullName) && wrappedType.HasInterface(k_INativeListBool_FullName))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringArray_MethodRef);
}
if (wrappedType.HasInterface(typeof(IEquatable<>).FullName + "<" + wrappedType.FullName + ">"))
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableArray_MethodRef);
}
else
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsArray_MethodRef);
}
if (serializeMethod != null)
{
serializeMethod.GenericArguments.Add(wrappedType);
}
equalityMethod.GenericArguments.Add(wrappedType);
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
else if (type.Resolve().FullName == "Unity.Collections.NativeList`1")
{
var wrappedType = ((GenericInstanceType)type).GenericArguments[0];
if (IsSpecialCaseType(wrappedType) || wrappedType.HasInterface(typeof(INetworkSerializeByMemcpy).FullName) || wrappedType.Resolve().IsEnum || IsMemcpyableType(wrappedType))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyList_MethodRef);
}
else if (wrappedType.HasInterface(typeof(INetworkSerializable).FullName))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef);
}
else if (wrappedType.HasInterface(CodeGenHelpers.IUTF8Bytes_FullName) && wrappedType.HasInterface(k_INativeListBool_FullName))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringList_MethodRef);
}
if (wrappedType.HasInterface(typeof(IEquatable<>).FullName + "<" + wrappedType.FullName + ">"))
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableList_MethodRef);
}
else
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef);
}
if (serializeMethod != null)
{
serializeMethod.GenericArguments.Add(wrappedType);
}
equalityMethod.GenericArguments.Add(wrappedType);
}
#endif
else if (type.IsValueType)
{
if (type.HasInterface(typeof(INetworkSerializeByMemcpy).FullName) || type.Resolve().IsEnum || IsMemcpyableType(type))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpy_MethodRef);
}
else if (type.HasInterface(typeof(INetworkSerializable).FullName))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializable_MethodRef);
}
else if (type.HasInterface(CodeGenHelpers.IUTF8Bytes_FullName) && type.HasInterface(k_INativeListBool_FullName))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_FixedString_MethodRef);
}
if (type.HasInterface(typeof(IEquatable<>).FullName + "<" + type.FullName + ">"))
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatable_MethodRef);
}
else
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEquals_MethodRef);
}
if (serializeMethod != null)
{
serializeMethod.GenericArguments.Add(type);
}
equalityMethod.GenericArguments.Add(type);
}
else
{
if (type.HasInterface(typeof(INetworkSerializable).FullName))
{
var constructors = type.Resolve().GetConstructors();
var hasEmptyConstructor = false;
foreach (var constructor in constructors)
{
if (constructor.Parameters.Count == 0)
{
hasEmptyConstructor = true;
}
}
if (!hasEmptyConstructor)
{
m_Diagnostics.AddError($"{type} cannot be used in a network variable - Managed {nameof(INetworkSerializable)} instances must meet the `new()` (default empty constructor) constraint.");
continue;
}
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef);
}
if (type.HasInterface(typeof(IEquatable<>).FullName + "<" + type.FullName + ">"))
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedIEquatable_MethodRef);
}
else
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef);
}
if (serializeMethod != null)
{
serializeMethod.GenericArguments.Add(type);
}
equalityMethod.GenericArguments.Add(type);
}
if (serializeMethod != null)
{
instructions.Add(processor.Create(OpCodes.Call, m_MainModule.ImportReference(serializeMethod)));
}
instructions.Add(processor.Create(OpCodes.Call, m_MainModule.ImportReference(equalityMethod)));
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyArray_MethodRef);
}
else if (wrappedType.HasInterface(typeof(INetworkSerializable).FullName))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableArray_MethodRef);
}
else if (wrappedType.HasInterface(CodeGenHelpers.IUTF8Bytes_FullName) && wrappedType.HasInterface(k_INativeListBool_FullName))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringArray_MethodRef);
}
instructions.ForEach(instruction => processor.Body.Instructions.Insert(processor.Body.Instructions.Count - 1, instruction));
break;
if (wrappedType.HasInterface(typeof(IEquatable<>).FullName + "<" + wrappedType.FullName + ">"))
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableArray_MethodRef);
}
else
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsArray_MethodRef);
}
if (serializeMethod != null)
{
serializeMethod.GenericArguments.Add(wrappedType);
}
equalityMethod.GenericArguments.Add(wrappedType);
}
#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
else if (type.Resolve().FullName == "Unity.Collections.NativeList`1")
{
var wrappedType = ((GenericInstanceType)type).GenericArguments[0];
if (IsSpecialCaseType(wrappedType) || wrappedType.HasInterface(typeof(INetworkSerializeByMemcpy).FullName) || wrappedType.Resolve().IsEnum || IsMemcpyableType(wrappedType))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyList_MethodRef);
}
else if (wrappedType.HasInterface(typeof(INetworkSerializable).FullName))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef);
}
else if (wrappedType.HasInterface(CodeGenHelpers.IUTF8Bytes_FullName) && wrappedType.HasInterface(k_INativeListBool_FullName))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringList_MethodRef);
}
if (wrappedType.HasInterface(typeof(IEquatable<>).FullName + "<" + wrappedType.FullName + ">"))
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableList_MethodRef);
}
else
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef);
}
if (serializeMethod != null)
{
serializeMethod.GenericArguments.Add(wrappedType);
}
equalityMethod.GenericArguments.Add(wrappedType);
}
#endif
else if (type.IsValueType)
{
if (type.HasInterface(typeof(INetworkSerializeByMemcpy).FullName) || type.Resolve().IsEnum || IsMemcpyableType(type))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpy_MethodRef);
}
else if (type.HasInterface(typeof(INetworkSerializable).FullName))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializable_MethodRef);
}
else if (type.HasInterface(CodeGenHelpers.IUTF8Bytes_FullName) && type.HasInterface(k_INativeListBool_FullName))
{
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_FixedString_MethodRef);
}
if (type.HasInterface(typeof(IEquatable<>).FullName + "<" + type.FullName + ">"))
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatable_MethodRef);
}
else
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEquals_MethodRef);
}
if (serializeMethod != null)
{
serializeMethod.GenericArguments.Add(type);
}
equalityMethod.GenericArguments.Add(type);
}
else
{
if (type.HasInterface(typeof(INetworkSerializable).FullName))
{
var constructors = type.Resolve().GetConstructors();
var hasEmptyConstructor = false;
foreach (var constructor in constructors)
{
if (constructor.Parameters.Count == 0)
{
hasEmptyConstructor = true;
}
}
if (!hasEmptyConstructor)
{
m_Diagnostics.AddError($"{type} cannot be used in a network variable - Managed {nameof(INetworkSerializable)} instances must meet the `new()` (default empty constructor) constraint.");
continue;
}
serializeMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef);
}
if (type.HasInterface(typeof(IEquatable<>).FullName + "<" + type.FullName + ">"))
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedIEquatable_MethodRef);
}
else
{
equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef);
}
if (serializeMethod != null)
{
serializeMethod.GenericArguments.Add(type);
}
equalityMethod.GenericArguments.Add(type);
}
if (serializeMethod != null)
{
instructions.Add(processor.Create(OpCodes.Call, m_MainModule.ImportReference(serializeMethod)));
}
instructions.Add(processor.Create(OpCodes.Call, m_MainModule.ImportReference(equalityMethod)));
}
instructions.ForEach(instruction => processor.Body.Instructions.Insert(processor.Body.Instructions.Count - 1, instruction));
assembly.MainModule.Types.Add(typeDefinition);
}
private ModuleDefinition m_MainModule;

5
Editor/NetworkBehaviourEditor.cs
View File

@@ -345,8 +345,9 @@ namespace Unity.Netcode.Editor
/// <param name="networkObjectRemoved">used internally</param>
public static void CheckForNetworkObject(GameObject gameObject, bool networkObjectRemoved = false)
{
// If there are no NetworkBehaviours or no gameObject, then exit early
if (gameObject == null || (gameObject.GetComponent<NetworkBehaviour>() == null && gameObject.GetComponentInChildren<NetworkBehaviour>() == null))
// If there are no NetworkBehaviours or gameObjects then exit early
// If we are in play mode and a user is inspecting something then exit early (we don't add NetworkObjects to something when in play mode)
if (EditorApplication.isPlaying || gameObject == null || (gameObject.GetComponent<NetworkBehaviour>() == null && gameObject.GetComponentInChildren<NetworkBehaviour>() == null))
{
return;
}

5
Runtime/Core/NetworkManager.cs
View File

@@ -586,7 +586,7 @@ namespace Unity.Netcode
/// <param name="size"></param>
public int MaximumTransmissionUnitSize
{
set => MessageManager.NonFragmentedMessageMaxSize = value;
set => MessageManager.NonFragmentedMessageMaxSize = value & ~7; // Round down to nearest word aligned size
get => MessageManager.NonFragmentedMessageMaxSize;
}
@@ -1013,6 +1013,9 @@ namespace Unity.Netcode
OnServerStopped?.Invoke(ConnectionManager.LocalClient.IsClient);
}
// In the event shutdown is invoked within OnClientStopped or OnServerStopped, set it to false again
m_ShuttingDown = false;
// Reset the client's roles
ConnectionManager.LocalClient.SetRole(false, false);

6
Runtime/Messaging/Messages/NamedMessage.cs
View File

@@ -24,7 +24,11 @@ namespace Unity.Netcode
public void Handle(ref NetworkContext context)
{
((NetworkManager)context.SystemOwner).CustomMessagingManager.InvokeNamedMessage(Hash, context.SenderId, m_ReceiveData, context.SerializedHeaderSize);
var networkManager = (NetworkManager)context.SystemOwner;
if (!networkManager.ShutdownInProgress)
{
((NetworkManager)context.SystemOwner).CustomMessagingManager.InvokeNamedMessage(Hash, context.SenderId, m_ReceiveData, context.SerializedHeaderSize);
}
}
}
}

9
Runtime/Messaging/NetworkBatchHeader.cs
View File

@@ -12,6 +12,11 @@ namespace Unity.Netcode
/// </summary>
public ushort Magic;
/// <summary>
/// Total number of messages in the batch.
/// </summary>
public ushort BatchCount;
/// <summary>
/// Total number of bytes in the batch.
/// </summary>
@@ -22,9 +27,5 @@ namespace Unity.Netcode
/// </summary>
public ulong BatchHash;
/// <summary>
/// Total number of messages in the batch.
/// </summary>
public ushort BatchCount;
}
}

29
Runtime/Messaging/NetworkMessageManager.cs
View File

@@ -95,7 +95,7 @@ namespace Unity.Netcode
return m_MessageTypes[t];
}
public const int DefaultNonFragmentedMessageMaxSize = 1300;
public const int DefaultNonFragmentedMessageMaxSize = 1300 & ~7; // Round down to nearest word aligned size (1296)
public int NonFragmentedMessageMaxSize = DefaultNonFragmentedMessageMaxSize;
public int FragmentedMessageMaxSize = int.MaxValue;
@@ -518,15 +518,18 @@ namespace Unity.Netcode
{
if (!m_PerClientMessageVersions.TryGetValue(clientId, out var versionMap))
{
if (forReceive)
var networkManager = NetworkManager.Singleton;
if (networkManager != null && networkManager.LogLevel == LogLevel.Developer)
{
Debug.LogWarning($"Trying to receive {type.Name} from client {clientId} which is not in a connected state.");
if (forReceive)
{
NetworkLog.LogWarning($"Trying to receive {type.Name} from client {clientId} which is not in a connected state.");
}
else
{
NetworkLog.LogWarning($"Trying to send {type.Name} to client {clientId} which is not in a connected state.");
}
}
else
{
Debug.LogWarning($"Trying to send {type.Name} to client {clientId} which is not in a connected state.");
}
return -1;
}
@@ -826,11 +829,17 @@ namespace Unity.Netcode
// Skipping the Verify and sneaking the write mark in because we know it's fine.
queueItem.Writer.Handle->AllowedWriteMark = sizeof(NetworkBatchHeader);
#endif
queueItem.BatchHeader.BatchHash = XXHash.Hash64(queueItem.Writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), queueItem.Writer.Length - sizeof(NetworkBatchHeader));
queueItem.BatchHeader.BatchSize = queueItem.Writer.Length;
var alignedLength = (queueItem.Writer.Length + 7) & ~7;
queueItem.Writer.TryBeginWrite(alignedLength);
queueItem.BatchHeader.BatchHash = XXHash.Hash64(queueItem.Writer.GetUnsafePtr() + sizeof(NetworkBatchHeader), alignedLength - sizeof(NetworkBatchHeader));
queueItem.BatchHeader.BatchSize = alignedLength;
queueItem.Writer.WriteValue(queueItem.BatchHeader);
queueItem.Writer.Seek(alignedLength);
try

20
Tests/Runtime/Metrics/TransportBytesMetricsTests.cs
View File

@@ -41,7 +41,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
}
Assert.True(observer.Found);
Assert.AreEqual(FastBufferWriter.GetWriteSize(messageName) + k_MessageOverhead, observer.Value);
Assert.AreEqual(((FastBufferWriter.GetWriteSize(messageName) + k_MessageOverhead) + 7) & ~7, observer.Value);
}
[UnityTest]
@@ -61,8 +61,6 @@ namespace Unity.Netcode.RuntimeTests.Metrics
writer.Dispose();
}
var nbFrames = 0;
while (!observer.Found || nbFrames < 10)
{
@@ -71,7 +69,7 @@ namespace Unity.Netcode.RuntimeTests.Metrics
}
Assert.True(observer.Found);
Assert.AreEqual(FastBufferWriter.GetWriteSize(messageName) + k_MessageOverhead, observer.Value);
Assert.AreEqual(((FastBufferWriter.GetWriteSize(messageName) + k_MessageOverhead) + 7) & ~7, observer.Value);
}
private class TotalBytesObserver : IMetricObserver
@@ -89,12 +87,22 @@ namespace Unity.Netcode.RuntimeTests.Metrics
public long Value { get; private set; }
private int m_BytesFoundCounter;
private long m_TotalBytes;
public void Observe(MetricCollection collection)
{
if (collection.TryGetCounter(m_MetricInfo.Id, out var counter) && counter.Value > 0)
{
Found = true;
Value = counter.Value;
// Don't assign another observed value once one is already observed
if (!Found)
{
Found = true;
Value = counter.Value;
m_TotalBytes += ((counter.Value + 7) & ~7);
m_BytesFoundCounter++;
UnityEngine.Debug.Log($"[{m_BytesFoundCounter}] Bytes Observed {counter.Value} | Total Bytes Observed: {m_TotalBytes}");
}
}
}
}

87
Tests/Runtime/NetworkTransform/NetworkTransformOwnershipTests.cs
View File

@@ -46,6 +46,93 @@ namespace Unity.Netcode.RuntimeTests
base.OnServerAndClientsCreated();
}
/// <summary>
/// Clients created during a test need to have their prefabs list updated to
/// match the server's prefab list.
/// </summary>
protected override void OnNewClientCreated(NetworkManager networkManager)
{
foreach (var networkPrefab in m_ServerNetworkManager.NetworkConfig.Prefabs.Prefabs)
{
networkManager.NetworkConfig.Prefabs.Add(networkPrefab);
}
base.OnNewClientCreated(networkManager);
}
private bool ClientIsOwner()
{
var clientId = m_ClientNetworkManagers[0].LocalClientId;
if (!VerifyObjectIsSpawnedOnClient.GetClientsThatSpawnedThisPrefab().Contains(clientId))
{
return false;
}
if (VerifyObjectIsSpawnedOnClient.GetClientInstance(clientId).OwnerClientId != clientId)
{
return false;
}
return true;
}
/// <summary>
/// This test verifies a late joining client cannot change the transform when:
/// - A NetworkObject is spawned with a host and one or more connected clients
/// - The NetworkTransform is owner authoritative and spawned with the host as the owner
/// - The host does not change the transform values
/// - One of the already connected clients gains ownership of the spawned NetworkObject
/// - The new client owner does not change the transform values
/// - A new late joining client connects and is synchronized
/// - The newly connected late joining client tries to change the transform of the NetworkObject
/// it does not own
/// </summary>
[UnityTest]
public IEnumerator LateJoinedNonOwnerClientCannotChangeTransform()
{
// Spawn the m_ClientNetworkTransformPrefab with the host starting as the owner
var hostInstance = SpawnObject(m_ClientNetworkTransformPrefab, m_ServerNetworkManager);
// Wait for the client to spawn it
yield return WaitForConditionOrTimeOut(() => VerifyObjectIsSpawnedOnClient.GetClientsThatSpawnedThisPrefab().Contains(m_ClientNetworkManagers[0].LocalClientId));
// Change the ownership to the connectd client
hostInstance.GetComponent<NetworkObject>().ChangeOwnership(m_ClientNetworkManagers[0].LocalClientId);
// Wait until the client gains ownership
yield return WaitForConditionOrTimeOut(ClientIsOwner);
// Spawn a new client
yield return CreateAndStartNewClient();
// Get the instance of the object relative to the newly joined client
var newClientObjectInstance = VerifyObjectIsSpawnedOnClient.GetClientInstance(m_ClientNetworkManagers[1].LocalClientId);
// Attempt to change the transform values
var currentPosition = newClientObjectInstance.transform.position;
newClientObjectInstance.transform.position = GetRandomVector3(0.5f, 10.0f);
var rotation = newClientObjectInstance.transform.rotation;
var currentRotation = rotation.eulerAngles;
rotation.eulerAngles = GetRandomVector3(1.0f, 180.0f);
var currentScale = newClientObjectInstance.transform.localScale;
newClientObjectInstance.transform.localScale = GetRandomVector3(0.25f, 4.0f);
// Wait one frame so the NetworkTransform can apply the owner's last state received on the late joining client side
// (i.e. prevent the non-owner from changing the transform)
yield return null;
// Get the owner instance
var ownerInstance = VerifyObjectIsSpawnedOnClient.GetClientInstance(m_ClientNetworkManagers[0].LocalClientId);
// Verify that the non-owner instance transform values are the same before they were changed last frame
Assert.True(Approximately(currentPosition, newClientObjectInstance.transform.position), $"Non-owner instance was able to change the position!");
Assert.True(Approximately(currentRotation, newClientObjectInstance.transform.rotation.eulerAngles), $"Non-owner instance was able to change the rotation!");
Assert.True(Approximately(currentScale, newClientObjectInstance.transform.localScale), $"Non-owner instance was able to change the scale!");
// Verify that the non-owner instance transform is still the same as the owner instance transform
Assert.True(Approximately(ownerInstance.transform.position, newClientObjectInstance.transform.position), "Non-owner and owner instance position values are not the same!");
Assert.True(Approximately(ownerInstance.transform.rotation.eulerAngles, newClientObjectInstance.transform.rotation.eulerAngles), "Non-owner and owner instance rotation values are not the same!");
Assert.True(Approximately(ownerInstance.transform.localScale, newClientObjectInstance.transform.localScale), "Non-owner and owner instance scale values are not the same!");
}
public enum StartingOwnership
{
HostStartsAsOwner,

120
Tests/Runtime/NetworkTransform/NetworkTransformStateTests.cs
View File

@@ -2,6 +2,7 @@ using NUnit.Framework;
using Unity.Netcode.Components;
using UnityEngine;
namespace Unity.Netcode.RuntimeTests
{
@@ -89,6 +90,125 @@ namespace Unity.Netcode.RuntimeTests
networkTransform.SyncPositionX || networkTransform.SyncPositionY || networkTransform.SyncPositionZ;
}
[Test]
public void NetworkTransformStateFlags()
{
var indexValues = new System.Collections.Generic.List<uint>();
var currentFlag = (uint)0x00000001;
for (int j = 0; j < 18; j++)
{
indexValues.Add(currentFlag);
currentFlag = currentFlag << 1;
}
// TrackByStateId is unique
indexValues.Add(0x10000000);
var boolSet = new System.Collections.Generic.List<bool>();
var transformState = new NetworkTransform.NetworkTransformState();
// Test setting one at a time.
for (int j = 0; j < 19; j++)
{
boolSet = new System.Collections.Generic.List<bool>();
for (int i = 0; i < 19; i++)
{
if (i == j)
{
boolSet.Add(true);
}
else
{
boolSet.Add(false);
}
}
transformState = new NetworkTransform.NetworkTransformState()
{
InLocalSpace = boolSet[0],
HasPositionX = boolSet[1],
HasPositionY = boolSet[2],
HasPositionZ = boolSet[3],
HasRotAngleX = boolSet[4],
HasRotAngleY = boolSet[5],
HasRotAngleZ = boolSet[6],
HasScaleX = boolSet[7],
HasScaleY = boolSet[8],
HasScaleZ = boolSet[9],
IsTeleportingNextFrame = boolSet[10],
UseInterpolation = boolSet[11],
QuaternionSync = boolSet[12],
QuaternionCompression = boolSet[13],
UseHalfFloatPrecision = boolSet[14],
IsSynchronizing = boolSet[15],
UsePositionSlerp = boolSet[16],
IsParented = boolSet[17],
TrackByStateId = boolSet[18],
};
Assert.True((transformState.BitSet & indexValues[j]) == indexValues[j], $"[FlagTest][Individual] Set flag value {indexValues[j]} at index {j}, but BitSet value did not match!");
}
// Test setting all flag values
boolSet = new System.Collections.Generic.List<bool>();
for (int i = 0; i < 19; i++)
{
boolSet.Add(true);
}
transformState = new NetworkTransform.NetworkTransformState()
{
InLocalSpace = boolSet[0],
HasPositionX = boolSet[1],
HasPositionY = boolSet[2],
HasPositionZ = boolSet[3],
HasRotAngleX = boolSet[4],
HasRotAngleY = boolSet[5],
HasRotAngleZ = boolSet[6],
HasScaleX = boolSet[7],
HasScaleY = boolSet[8],
HasScaleZ = boolSet[9],
IsTeleportingNextFrame = boolSet[10],
UseInterpolation = boolSet[11],
QuaternionSync = boolSet[12],
QuaternionCompression = boolSet[13],
UseHalfFloatPrecision = boolSet[14],
IsSynchronizing = boolSet[15],
UsePositionSlerp = boolSet[16],
IsParented = boolSet[17],
TrackByStateId = boolSet[18],
};
for (int j = 0; j < 19; j++)
{
Assert.True((transformState.BitSet & indexValues[j]) == indexValues[j], $"[FlagTest][All] All flag values are set but failed to detect flag value {indexValues[j]}!");
}
// Test getting all flag values
transformState = new NetworkTransform.NetworkTransformState();
for (int i = 0; i < 19; i++)
{
transformState.BitSet |= indexValues[i];
}
Assert.True(transformState.InLocalSpace, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.InLocalSpace)}!");
Assert.True(transformState.HasPositionX, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.HasPositionX)}!");
Assert.True(transformState.HasPositionY, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.HasPositionY)}!");
Assert.True(transformState.HasPositionZ, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.HasPositionZ)}!");
Assert.True(transformState.HasRotAngleX, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.HasRotAngleX)}!");
Assert.True(transformState.HasRotAngleY, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.HasRotAngleY)}!");
Assert.True(transformState.HasRotAngleZ, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.HasRotAngleZ)}!");
Assert.True(transformState.HasScaleX, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.HasScaleX)}!");
Assert.True(transformState.HasScaleY, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.HasScaleY)}!");
Assert.True(transformState.HasScaleZ, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.HasScaleZ)}!");
Assert.True(transformState.IsTeleportingNextFrame, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.IsTeleportingNextFrame)}!");
Assert.True(transformState.UseInterpolation, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.UseInterpolation)}!");
Assert.True(transformState.QuaternionSync, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.QuaternionSync)}!");
Assert.True(transformState.QuaternionCompression, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.QuaternionCompression)}!");
Assert.True(transformState.UseHalfFloatPrecision, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.UseHalfFloatPrecision)}!");
Assert.True(transformState.IsSynchronizing, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.IsSynchronizing)}!");
Assert.True(transformState.UsePositionSlerp, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.UsePositionSlerp)}!");
Assert.True(transformState.IsParented, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.IsParented)}!");
Assert.True(transformState.TrackByStateId, $"[FlagTest][Get] Failed to detect {nameof(NetworkTransform.NetworkTransformState.TrackByStateId)}!");
}
[Test]
public void TestSyncAxes([Values] SynchronizationType synchronizationType, [Values] SyncAxis syncAxis)

138
Tests/Runtime/NetworkTransform/NetworkTransformTests.cs
View File

@@ -64,24 +64,50 @@ namespace Unity.Netcode.RuntimeTests
}
}
/// <summary>
/// Helper component for NetworkTransform parenting tests when
/// a child is a parent of another child (i.e. "sub child")
/// </summary>
public class SubChildObjectComponent : ChildObjectComponent
{
protected override bool IsSubChild()
{
return true;
}
}
/// <summary>
/// Helper component for NetworkTransform parenting tests
/// </summary>
public class ChildObjectComponent : NetworkTransform
{
public static readonly List<ChildObjectComponent> Instances = new List<ChildObjectComponent>();
public static readonly List<ChildObjectComponent> SubInstances = new List<ChildObjectComponent>();
public static ChildObjectComponent AuthorityInstance { get; internal set; }
public static ChildObjectComponent AuthoritySubInstance { get; internal set; }
public static readonly Dictionary<ulong, NetworkObject> ClientInstances = new Dictionary<ulong, NetworkObject>();
public static readonly Dictionary<ulong, NetworkObject> ClientSubChildInstances = new Dictionary<ulong, NetworkObject>();
public static bool HasSubChild;
public static void Reset()
{
AuthorityInstance = null;
AuthoritySubInstance = null;
HasSubChild = false;
ClientInstances.Clear();
ClientSubChildInstances.Clear();
Instances.Clear();
SubInstances.Clear();
}
public bool ServerAuthority;
protected virtual bool IsSubChild()
{
return false;
}
protected override bool OnIsServerAuthoritative()
{
return ServerAuthority;
@@ -92,13 +118,34 @@ namespace Unity.Netcode.RuntimeTests
base.OnNetworkSpawn();
if (CanCommitToTransform)
{
AuthorityInstance = this;
if (!IsSubChild())
{
AuthorityInstance = this;
}
else
{
AuthoritySubInstance = this;
}
}
else
{
Instances.Add(this);
if (!IsSubChild())
{
Instances.Add(this);
}
else
{
SubInstances.Add(this);
}
}
if (HasSubChild && IsSubChild())
{
ClientSubChildInstances.Add(NetworkManager.LocalClientId, NetworkObject);
}
else
{
ClientInstances.Add(NetworkManager.LocalClientId, NetworkObject);
}
ClientInstances.Add(NetworkManager.LocalClientId, NetworkObject);
}
}
@@ -117,6 +164,7 @@ namespace Unity.Netcode.RuntimeTests
private NetworkObject m_AuthoritativePlayer;
private NetworkObject m_NonAuthoritativePlayer;
private NetworkObject m_ChildObject;
private NetworkObject m_SubChildObject;
private NetworkObject m_ParentObject;
private NetworkTransformTestComponent m_AuthoritativeTransform;
@@ -232,6 +280,11 @@ namespace Unity.Netcode.RuntimeTests
protected override void OnServerAndClientsCreated()
{
var subChildObject = CreateNetworkObjectPrefab("SubChildObject");
var subChildNetworkTransform = subChildObject.AddComponent<SubChildObjectComponent>();
subChildNetworkTransform.ServerAuthority = m_Authority == Authority.ServerAuthority;
m_SubChildObject = subChildObject.GetComponent<NetworkObject>();
var childObject = CreateNetworkObjectPrefab("ChildObject");
var childNetworkTransform = childObject.AddComponent<ChildObjectComponent>();
childNetworkTransform.ServerAuthority = m_Authority == Authority.ServerAuthority;
@@ -242,13 +295,19 @@ namespace Unity.Netcode.RuntimeTests
parentNetworkTransform.ServerAuthority = m_Authority == Authority.ServerAuthority;
m_ParentObject = parentObject.GetComponent<NetworkObject>();
// Now apply local transform values
m_ChildObject.transform.position = m_ChildObjectLocalPosition;
var childRotation = m_ChildObject.transform.rotation;
childRotation.eulerAngles = m_ChildObjectLocalRotation;
m_ChildObject.transform.rotation = childRotation;
m_ChildObject.transform.localScale = m_ChildObjectLocalScale;
m_SubChildObject.transform.position = m_SubChildObjectLocalPosition;
var subChildRotation = m_SubChildObject.transform.rotation;
subChildRotation.eulerAngles = m_SubChildObjectLocalRotation;
m_SubChildObject.transform.rotation = childRotation;
m_SubChildObject.transform.localScale = m_SubChildObjectLocalScale;
if (m_EnableVerboseDebug)
{
m_ServerNetworkManager.LogLevel = LogLevel.Developer;
@@ -302,6 +361,11 @@ namespace Unity.Netcode.RuntimeTests
return false;
}
if (ChildObjectComponent.HasSubChild && ChildObjectComponent.AuthoritySubInstance == null)
{
return false;
}
foreach (var clientNetworkManager in m_ClientNetworkManagers)
{
if (!ChildObjectComponent.ClientInstances.ContainsKey(clientNetworkManager.LocalClientId))
@@ -321,6 +385,16 @@ namespace Unity.Netcode.RuntimeTests
return false;
}
}
if (ChildObjectComponent.HasSubChild)
{
foreach (var instance in ChildObjectComponent.ClientSubChildInstances.Values)
{
if (instance.transform.parent == null)
{
return false;
}
}
}
return true;
}
@@ -328,6 +402,10 @@ namespace Unity.Netcode.RuntimeTests
private Vector3 m_ChildObjectLocalPosition = new Vector3(5.0f, 0.0f, -5.0f);
private Vector3 m_ChildObjectLocalRotation = new Vector3(-35.0f, 90.0f, 270.0f);
private Vector3 m_ChildObjectLocalScale = new Vector3(0.1f, 0.5f, 0.4f);
private Vector3 m_SubChildObjectLocalPosition = new Vector3(2.0f, 1.0f, -1.0f);
private Vector3 m_SubChildObjectLocalRotation = new Vector3(5.0f, 15.0f, 124.0f);
private Vector3 m_SubChildObjectLocalScale = new Vector3(1.0f, 0.15f, 0.75f);
/// <summary>
/// A wait condition specific method that assures the local space coordinates
@@ -375,17 +453,17 @@ namespace Unity.Netcode.RuntimeTests
/// If not, it generates a message containing the axial values that did not match
/// the target/start local space values.
/// </summary>
private void AllChildrenLocalTransformValuesMatch()
private void AllChildrenLocalTransformValuesMatch(bool useSubChild)
{
var success = WaitForConditionOrTimeOutWithTimeTravel(AllInstancesKeptLocalTransformValues);
//TimeTravelToNextTick();
var infoMessage = new StringBuilder($"Timed out waiting for all children to have the correct local space values:\n");
var authorityObjectLocalPosition = m_AuthorityChildObject.transform.localPosition;
var authorityObjectLocalRotation = m_AuthorityChildObject.transform.localRotation.eulerAngles;
var authorityObjectLocalScale = m_AuthorityChildObject.transform.localScale;
var authorityObjectLocalPosition = useSubChild ? m_AuthoritySubChildObject.transform.localPosition : m_AuthorityChildObject.transform.localPosition;
var authorityObjectLocalRotation = useSubChild ? m_AuthoritySubChildObject.transform.localRotation.eulerAngles : m_AuthorityChildObject.transform.localRotation.eulerAngles;
var authorityObjectLocalScale = useSubChild ? m_AuthoritySubChildObject.transform.localScale : m_AuthorityChildObject.transform.localScale;
if (s_GlobalTimeoutHelper.TimedOut || !success)
{
var instances = useSubChild ? ChildObjectComponent.SubInstances : ChildObjectComponent.Instances;
foreach (var childInstance in ChildObjectComponent.Instances)
{
var childLocalPosition = childInstance.transform.localPosition;
@@ -428,8 +506,11 @@ namespace Unity.Netcode.RuntimeTests
private NetworkObject m_AuthorityParentObject;
private NetworkTransformTestComponent m_AuthorityParentNetworkTransform;
private NetworkObject m_AuthorityChildObject;
private NetworkObject m_AuthoritySubChildObject;
private ChildObjectComponent m_AuthorityChildNetworkTransform;
private ChildObjectComponent m_AuthoritySubChildNetworkTransform;
/// <summary>
/// Validates that transform values remain the same when a NetworkTransform is
/// parented under another NetworkTransform under all of the possible axial conditions
@@ -451,9 +532,11 @@ namespace Unity.Netcode.RuntimeTests
authorityNetworkManager = m_ClientNetworkManagers[0];
}
// Spawn a parent and child object
// Spawn a parent and children
ChildObjectComponent.HasSubChild = true;
var serverSideParent = SpawnObject(m_ParentObject.gameObject, authorityNetworkManager).GetComponent<NetworkObject>();
var serverSideChild = SpawnObject(m_ChildObject.gameObject, authorityNetworkManager).GetComponent<NetworkObject>();
var serverSideSubChild = SpawnObject(m_SubChildObject.gameObject, authorityNetworkManager).GetComponent<NetworkObject>();
// Assure all of the child object instances are spawned before proceeding to parenting
var success = WaitForConditionOrTimeOutWithTimeTravel(AllChildObjectInstancesAreSpawned);
@@ -462,6 +545,7 @@ namespace Unity.Netcode.RuntimeTests
// Get the authority parent and child instances
m_AuthorityParentObject = NetworkTransformTestComponent.AuthorityInstance.NetworkObject;
m_AuthorityChildObject = ChildObjectComponent.AuthorityInstance.NetworkObject;
m_AuthoritySubChildObject = ChildObjectComponent.AuthoritySubInstance.NetworkObject;
// The child NetworkTransform will use world space when world position stays and
// local space when world position does not stay when parenting.
@@ -470,15 +554,26 @@ namespace Unity.Netcode.RuntimeTests
ChildObjectComponent.AuthorityInstance.UseQuaternionSynchronization = rotation == Rotation.Quaternion;
ChildObjectComponent.AuthorityInstance.UseQuaternionCompression = rotationCompression == RotationCompression.QuaternionCompress;
ChildObjectComponent.AuthoritySubInstance.InLocalSpace = !worldPositionStays;
ChildObjectComponent.AuthoritySubInstance.UseHalfFloatPrecision = precision == Precision.Half;
ChildObjectComponent.AuthoritySubInstance.UseQuaternionSynchronization = rotation == Rotation.Quaternion;
ChildObjectComponent.AuthoritySubInstance.UseQuaternionCompression = rotationCompression == RotationCompression.QuaternionCompress;
// Set whether we are interpolating or not
m_AuthorityParentNetworkTransform = m_AuthorityParentObject.GetComponent<NetworkTransformTestComponent>();
m_AuthorityParentNetworkTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_AuthorityChildNetworkTransform = m_AuthorityChildObject.GetComponent<ChildObjectComponent>();
m_AuthorityChildNetworkTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
m_AuthoritySubChildNetworkTransform = m_AuthoritySubChildObject.GetComponent<ChildObjectComponent>();
m_AuthoritySubChildNetworkTransform.Interpolate = interpolation == Interpolation.EnableInterpolate;
// Apply a scale to the parent object to make sure the scale on the child is properly updated on
// non-authority instances.
m_AuthorityParentObject.transform.localScale = new Vector3(scale, scale, scale);
var halfScale = scale * 0.5f;
m_AuthorityParentObject.transform.localScale = GetRandomVector3(scale - halfScale, scale + halfScale);
m_AuthorityChildObject.transform.localScale = GetRandomVector3(scale - halfScale, scale + halfScale);
m_AuthoritySubChildObject.transform.localScale = GetRandomVector3(scale - halfScale, scale + halfScale);
// Allow one tick for authority to update these changes
TimeTravelToNextTick();
@@ -486,12 +581,18 @@ namespace Unity.Netcode.RuntimeTests
// Parent the child under the parent with the current world position stays setting
Assert.True(serverSideChild.TrySetParent(serverSideParent.transform, worldPositionStays), "[Server-Side Child] Failed to set child's parent!");
// Parent the sub-child under the child with the current world position stays setting
Assert.True(serverSideSubChild.TrySetParent(serverSideChild.transform, worldPositionStays), "[Server-Side SubChild] Failed to set sub-child's parent!");
// This waits for all child instances to be parented
success = WaitForConditionOrTimeOutWithTimeTravel(AllChildObjectInstancesHaveChild);
Assert.True(success, "Timed out waiting for all instances to have parented a child!");
// This validates each child instance has preserved their local space values
AllChildrenLocalTransformValuesMatch();
AllChildrenLocalTransformValuesMatch(false);
// This validates each sub-child instance has preserved their local space values
AllChildrenLocalTransformValuesMatch(true);
// Verify that a late joining client will synchronize to the parented NetworkObjects properly
CreateAndStartNewClientWithTimeTravel();
@@ -500,8 +601,15 @@ namespace Unity.Netcode.RuntimeTests
success = WaitForConditionOrTimeOutWithTimeTravel(AllChildObjectInstancesAreSpawned);
Assert.True(success, "Timed out waiting for all child instances to be spawned!");
// Assure the newly connected client's child object's transform values are correct
AllChildrenLocalTransformValuesMatch();
// This waits for all child instances to be parented
success = WaitForConditionOrTimeOutWithTimeTravel(AllChildObjectInstancesHaveChild);
Assert.True(success, "Timed out waiting for all instances to have parented a child!");
// This validates each child instance has preserved their local space values
AllChildrenLocalTransformValuesMatch(false);
// This validates each sub-child instance has preserved their local space values
AllChildrenLocalTransformValuesMatch(true);
}
/// <summary>
@@ -1054,7 +1162,7 @@ namespace Unity.Netcode.RuntimeTests
m_AuthoritativeTransform.transform.rotation = Quaternion.Euler(1, 2, 3);
var serverLastSentState = m_AuthoritativeTransform.AuthorityLastSentState;
var clientReplicatedState = m_NonAuthoritativeTransform.ReplicatedNetworkState.Value;
var clientReplicatedState = m_NonAuthoritativeTransform.LocalAuthoritativeNetworkState;
var success = WaitForConditionOrTimeOutWithTimeTravel(() => ValidateBitSetValues(serverLastSentState, clientReplicatedState));
Assert.True(success, $"Timed out waiting for Authoritative Bitset state to equal NonAuthoritative replicated Bitset state!");

2
Tests/Runtime/TransformInterpolationTests.cs
View File

@@ -37,7 +37,7 @@ namespace Unity.Netcode.RuntimeTests
return TestComplete;
}
protected override void OnInitialize(ref NetworkVariable<NetworkTransformState> replicatedState)
protected override void OnInitialize(ref NetworkTransformState replicatedState)
{
m_LocalSpaceToggles = 0;
m_FrameRateFractional = 1.0f / Application.targetFrameRate;

10
package.json
View File

@@ -2,23 +2,23 @@
"name": "com.unity.netcode.gameobjects",
"displayName": "Netcode for GameObjects",
"description": "Netcode for GameObjects is a high-level netcode SDK that provides networking capabilities to GameObject/MonoBehaviour workflows within Unity and sits on top of underlying transport layer.",
"version": "1.5.2",
"version": "1.6.0",
"unity": "2020.3",
"dependencies": {
"com.unity.nuget.mono-cecil": "1.10.1",
"com.unity.transport": "1.3.4"
},
"_upm": {
"changelog": "### Added\n\n### Fixed\n\n- Fixed issue where `NetworkClient.OwnedObjects` was not returning any owned objects due to the `NetworkClient.IsConnected` not being properly set. (#2631)\n- Fixed a crash when calling TrySetParent with a null Transform (#2625)\n- Fixed issue where a `NetworkTransform` using full precision state updates was losing transform state updates when interpolation was enabled. (#2624)\n- Fixed issue where `NetworkObject.SpawnWithObservers` was not being honored for late joining clients. (#2623)\n- Fixed issue where invoking `NetworkManager.Shutdown` multiple times, depending upon the timing, could cause an exception. (#2622)\n- Fixed issue where removing ownership would not notify the server that it gained ownership. This also resolves the issue where an owner authoritative NetworkTransform would not properly initialize upon removing ownership from a remote client. (#2618)\n- Fixed ILPP issues when using CoreCLR and for certain dedicated server builds. (#2614)\n- Fixed an ILPP compile error when creating a generic NetworkBehaviour singleton with a static T instance. (#2603)\n\n### Changed"
"changelog": "### Added\n\n- Added a protected virtual method `NetworkTransform.OnInitialize(ref NetworkTransformState replicatedState)` that just returns the replicated state reference.\n \n### Fixed\n\n- Fixed issue where invoking `NetworkManager.Shutdown` within `NetworkManager.OnClientStopped` or `NetworkManager.OnServerStopped` would force `NetworkManager.ShutdownInProgress` to remain true after completing the shutdown process. (#2661)\n- Fixed issue with client synchronization of position when using half precision and the delta position reaches the maximum value and is collapsed on the host prior to being forwarded to the non-owner clients. (#2636)\n- Fixed issue with scale not synchronizing properly depending upon the spawn order of NetworkObjects. (#2636)\n- Fixed issue position was not properly transitioning between ownership changes with an owner authoritative NetworkTransform. (#2636)\n- Fixed issue where a late joining non-owner client could update an owner authoritative NetworkTransform if ownership changed without any updates to position prior to the non-owner client joining. (#2636)\n\n### Changed"
},
"upmCi": {
"footprint": "e7549ba358ade416ab85285cdf53c5a6aac35cef"
"footprint": "58b37aee2ff0caec7a160473c56e62119d3b760a"
},
"documentationUrl": "https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@1.5/manual/index.html",
"documentationUrl": "https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@1.6/manual/index.html",
"repository": {
"url": "https://github.com/Unity-Technologies/com.unity.netcode.gameobjects.git",
"type": "git",
"revision": "36368846c5bfe6cfb93adc36282507614955955c"
"revision": "4ee8da05b439a5b8f76ee6d008221c6d58b7965a"
},
"samples": [
{