07f206ff9e
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.8.0] - 2023-12-12 ### Added - Added a new RPC attribute, which is simply `Rpc`. (#2762) - This is a generic attribute that can perform the functions of both Server and Client RPCs, as well as enabling client-to-client RPCs. Includes several default targets: `Server`, `NotServer`, `Owner`, `NotOwner`, `Me`, `NotMe`, `ClientsAndHost`, and `Everyone`. Runtime overrides are available for any of these targets, as well as for sending to a specific ID or groups of IDs. - This attribute also includes the ability to defer RPCs that are sent to the local process to the start of the next frame instead of executing them immediately, treating them as if they had gone across the network. The default behavior is to execute immediately. - This attribute effectively replaces `ServerRpc` and `ClientRpc`. `ServerRpc` and `ClientRpc` remain in their existing forms for backward compatibility, but `Rpc` will be the recommended and most supported option. - Added `NetworkManager.OnConnectionEvent` as a unified connection event callback to notify clients and servers of all client connections and disconnections within the session (#2762) - Added `NetworkManager.ServerIsHost` and `NetworkBehaviour.ServerIsHost` to allow a client to tell if it is connected to a host or to a dedicated server (#2762) - Added `SceneEventProgress.SceneManagementNotEnabled` return status to be returned when a `NetworkSceneManager` method is invoked and scene management is not enabled. (#2735) - Added `SceneEventProgress.ServerOnlyAction` return status to be returned when a `NetworkSceneManager` method is invoked by a client. (#2735) - Added `NetworkObject.InstantiateAndSpawn` and `NetworkSpawnManager.InstantiateAndSpawn` methods to simplify prefab spawning by assuring that the prefab is valid and applies any override prior to instantiating the `GameObject` and spawning the `NetworkObject` instance. (#2710) ### Fixed - Fixed issue where a client disconnected by a server-host would not receive a local notification. (#2789) - Fixed issue where a server-host could shutdown during a relay connection but periodically the transport disconnect message sent to any connected clients could be dropped. (#2789) - Fixed issue where a host could disconnect its local client but remain running as a server. (#2789) - Fixed issue where `OnClientDisconnectedCallback` was not being invoked under certain conditions. (#2789) - Fixed issue where `OnClientDisconnectedCallback` was always returning 0 as the client identifier. (#2789) - Fixed issue where if a host or server shutdown while a client owned NetworkObjects (other than the player) it would throw an exception. (#2789) - Fixed issue where setting values on a `NetworkVariable` or `NetworkList` within `OnNetworkDespawn` during a shutdown sequence would throw an exception. (#2789) - Fixed issue where a teleport state could potentially be overridden by a previous unreliable delta state. (#2777) - Fixed issue where `NetworkTransform` was using the `NetworkManager.ServerTime.Tick` as opposed to `NetworkManager.NetworkTickSystem.ServerTime.Tick` during the authoritative side's tick update where it performed a delta state check. (#2777) - Fixed issue where a parented in-scene placed NetworkObject would be destroyed upon a client or server exiting a network session but not unloading the original scene in which the NetworkObject was placed. (#2737) - Fixed issue where during client synchronization and scene loading, when client synchronization or the scene loading mode are set to `LoadSceneMode.Single`, a `CreateObjectMessage` could be received, processed, and the resultant spawned `NetworkObject` could be instantiated in the client's currently active scene that could, towards the end of the client synchronization or loading process, be unloaded and cause the newly created `NetworkObject` to be destroyed (and throw and exception). (#2735) - Fixed issue where a `NetworkTransform` instance with interpolation enabled would result in wide visual motion gaps (stuttering) under above normal latency conditions and a 1-5% or higher packet are drop rate. (#2713) - Fixed issue where you could not have multiple source network prefab overrides targeting the same network prefab as their override. (#2710) ### Changed - Changed the server or host shutdown so it will now perform a "soft shutdown" when `NetworkManager.Shutdown` is invoked. This will send a disconnect notification to all connected clients and the server-host will wait for all connected clients to disconnect or timeout after a 5 second period before completing the shutdown process. (#2789) - Changed `OnClientDisconnectedCallback` will now return the assigned client identifier on the local client side if the client was approved and assigned one prior to being disconnected. (#2789) - Changed `NetworkTransform.SetState` (and related methods) now are cumulative during a fractional tick period and sent on the next pending tick. (#2777) - `NetworkManager.ConnectedClientsIds` is now accessible on the client side and will contain the list of all clients in the session, including the host client if the server is operating in host mode (#2762) - Changed `NetworkSceneManager` to return a `SceneEventProgress` status and not throw exceptions for methods invoked when scene management is disabled and when a client attempts to access a `NetworkSceneManager` method by a client. (#2735) - Changed `NetworkTransform` authoritative instance tick registration so a single `NetworkTransform` specific tick event update will update all authoritative instances to improve perofmance. (#2713) - Changed `NetworkPrefabs.OverrideToNetworkPrefab` dictionary is no longer used/populated due to it ending up being related to a regression bug and not allowing more than one override to be assigned to a network prefab asset. (#2710) - Changed in-scene placed `NetworkObject`s now store their source network prefab asset's `GlobalObjectIdHash` internally that is used, when scene management is disabled, by clients to spawn the correct prefab even if the `NetworkPrefab` entry has an override. This does not impact dynamically spawning the same prefab which will yield the override on both host and client. (#2710) - Changed in-scene placed `NetworkObject`s no longer require a `NetworkPrefab` entry with `GlobalObjectIdHash` override in order for clients to properly synchronize. (#2710) - Changed in-scene placed `NetworkObject`s now set their `IsSceneObject` value when generating their `GlobalObjectIdHash` value. (#2710) - Changed the default `NetworkConfig.SpawnTimeout` value from 1.0s to 10.0s. (#2710)
908 lines
48 KiB
C#
908 lines
48 KiB
C#
using NUnit.Framework;
|
|
using Unity.Netcode.Components;
|
|
using UnityEngine;
|
|
|
|
|
|
namespace Unity.Netcode.RuntimeTests
|
|
{
|
|
|
|
[TestFixture(TransformSpace.World, Precision.Full, Rotation.Euler)]
|
|
[TestFixture(TransformSpace.World, Precision.Half, Rotation.Euler)]
|
|
[TestFixture(TransformSpace.Local, Precision.Full, Rotation.Euler)]
|
|
[TestFixture(TransformSpace.Local, Precision.Half, Rotation.Euler)]
|
|
[TestFixture(TransformSpace.World, Precision.Full, Rotation.Quaternion)]
|
|
[TestFixture(TransformSpace.World, Precision.Half, Rotation.Quaternion)]
|
|
[TestFixture(TransformSpace.Local, Precision.Full, Rotation.Quaternion)]
|
|
[TestFixture(TransformSpace.Local, Precision.Half, Rotation.Quaternion)]
|
|
public class NetworkTransformStateTests
|
|
{
|
|
public enum SyncAxis
|
|
{
|
|
SyncPosX,
|
|
SyncPosY,
|
|
SyncPosZ,
|
|
SyncPosXY,
|
|
SyncPosXZ,
|
|
SyncPosYZ,
|
|
SyncPosXYZ,
|
|
SyncRotX,
|
|
SyncRotY,
|
|
SyncRotZ,
|
|
SyncRotXY,
|
|
SyncRotXZ,
|
|
SyncRotYZ,
|
|
SyncRotXYZ,
|
|
SyncScaleX,
|
|
SyncScaleY,
|
|
SyncScaleZ,
|
|
SyncScaleXY,
|
|
SyncScaleXZ,
|
|
SyncScaleYZ,
|
|
SyncScaleXYZ,
|
|
SyncAllX,
|
|
SyncAllY,
|
|
SyncAllZ,
|
|
SyncAllXY,
|
|
SyncAllXZ,
|
|
SyncAllYZ,
|
|
SyncAllXYZ
|
|
}
|
|
|
|
public enum TransformSpace
|
|
{
|
|
World,
|
|
Local
|
|
}
|
|
|
|
public enum Rotation
|
|
{
|
|
Euler,
|
|
Quaternion
|
|
}
|
|
|
|
public enum SynchronizationType
|
|
{
|
|
Delta,
|
|
Teleport
|
|
}
|
|
|
|
public enum Precision
|
|
{
|
|
Half,
|
|
Full
|
|
}
|
|
|
|
private TransformSpace m_TransformSpace;
|
|
private Precision m_Precision;
|
|
private Rotation m_Rotation;
|
|
|
|
public NetworkTransformStateTests(TransformSpace transformSpace, Precision precision, Rotation rotation)
|
|
{
|
|
m_TransformSpace = transformSpace;
|
|
m_Precision = precision;
|
|
m_Rotation = rotation;
|
|
}
|
|
|
|
private bool WillAnAxisBeSynchronized(ref NetworkTransform networkTransform)
|
|
{
|
|
return networkTransform.SyncScaleX || networkTransform.SyncScaleY || networkTransform.SyncScaleZ ||
|
|
networkTransform.SyncRotAngleX || networkTransform.SyncRotAngleY || networkTransform.SyncRotAngleZ ||
|
|
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)
|
|
|
|
{
|
|
bool inLocalSpace = m_TransformSpace == TransformSpace.Local;
|
|
bool isTeleporting = synchronizationType == SynchronizationType.Teleport;
|
|
bool syncPosX = syncAxis == SyncAxis.SyncPosX || syncAxis == SyncAxis.SyncPosXY || syncAxis == SyncAxis.SyncPosXZ || syncAxis == SyncAxis.SyncPosXYZ || syncAxis == SyncAxis.SyncAllX || syncAxis == SyncAxis.SyncAllXY || syncAxis == SyncAxis.SyncAllXZ || syncAxis == SyncAxis.SyncAllXYZ;
|
|
bool syncPosY = syncAxis == SyncAxis.SyncPosY || syncAxis == SyncAxis.SyncPosXY || syncAxis == SyncAxis.SyncPosYZ || syncAxis == SyncAxis.SyncPosXYZ || syncAxis == SyncAxis.SyncAllY || syncAxis == SyncAxis.SyncAllXY || syncAxis == SyncAxis.SyncAllYZ || syncAxis == SyncAxis.SyncAllXYZ;
|
|
bool syncPosZ = syncAxis == SyncAxis.SyncPosZ || syncAxis == SyncAxis.SyncPosXZ || syncAxis == SyncAxis.SyncPosYZ || syncAxis == SyncAxis.SyncPosXYZ || syncAxis == SyncAxis.SyncAllZ || syncAxis == SyncAxis.SyncAllXZ || syncAxis == SyncAxis.SyncAllYZ || syncAxis == SyncAxis.SyncAllXYZ;
|
|
|
|
bool syncRotX = syncAxis == SyncAxis.SyncRotX || syncAxis == SyncAxis.SyncRotXY || syncAxis == SyncAxis.SyncRotXZ || syncAxis == SyncAxis.SyncRotXYZ || syncAxis == SyncAxis.SyncRotX || syncAxis == SyncAxis.SyncAllXY || syncAxis == SyncAxis.SyncAllXZ || syncAxis == SyncAxis.SyncAllXYZ;
|
|
bool syncRotY = syncAxis == SyncAxis.SyncRotY || syncAxis == SyncAxis.SyncRotXY || syncAxis == SyncAxis.SyncRotYZ || syncAxis == SyncAxis.SyncRotXYZ || syncAxis == SyncAxis.SyncRotY || syncAxis == SyncAxis.SyncAllXY || syncAxis == SyncAxis.SyncAllYZ || syncAxis == SyncAxis.SyncAllXYZ;
|
|
bool syncRotZ = syncAxis == SyncAxis.SyncRotZ || syncAxis == SyncAxis.SyncRotXZ || syncAxis == SyncAxis.SyncRotYZ || syncAxis == SyncAxis.SyncRotXYZ || syncAxis == SyncAxis.SyncRotZ || syncAxis == SyncAxis.SyncAllXZ || syncAxis == SyncAxis.SyncAllYZ || syncAxis == SyncAxis.SyncAllXYZ;
|
|
|
|
bool syncScaX = syncAxis == SyncAxis.SyncScaleX || syncAxis == SyncAxis.SyncScaleXY || syncAxis == SyncAxis.SyncScaleXZ || syncAxis == SyncAxis.SyncScaleXYZ || syncAxis == SyncAxis.SyncAllX || syncAxis == SyncAxis.SyncAllXY || syncAxis == SyncAxis.SyncAllXZ || syncAxis == SyncAxis.SyncAllXYZ;
|
|
bool syncScaY = syncAxis == SyncAxis.SyncScaleY || syncAxis == SyncAxis.SyncScaleXY || syncAxis == SyncAxis.SyncScaleYZ || syncAxis == SyncAxis.SyncScaleXYZ || syncAxis == SyncAxis.SyncAllY || syncAxis == SyncAxis.SyncAllXY || syncAxis == SyncAxis.SyncAllYZ || syncAxis == SyncAxis.SyncAllXYZ;
|
|
bool syncScaZ = syncAxis == SyncAxis.SyncScaleZ || syncAxis == SyncAxis.SyncScaleXZ || syncAxis == SyncAxis.SyncScaleYZ || syncAxis == SyncAxis.SyncScaleXYZ || syncAxis == SyncAxis.SyncAllZ || syncAxis == SyncAxis.SyncAllXZ || syncAxis == SyncAxis.SyncAllYZ || syncAxis == SyncAxis.SyncAllXYZ;
|
|
|
|
var gameObject = new GameObject($"Test-{nameof(NetworkTransformStateTests)}.{nameof(TestSyncAxes)}");
|
|
var networkObject = gameObject.AddComponent<NetworkObject>();
|
|
var networkTransform = gameObject.AddComponent<NetworkTransform>();
|
|
|
|
var manager = new GameObject($"Test-{nameof(NetworkManager)}.{nameof(TestSyncAxes)}");
|
|
var networkManager = manager.AddComponent<NetworkManager>();
|
|
networkObject.NetworkManagerOwner = networkManager;
|
|
|
|
networkTransform.enabled = false; // do not tick `FixedUpdate()` or `Update()`
|
|
|
|
var initialPosition = Vector3.zero;
|
|
var initialRotAngles = Vector3.zero;
|
|
var initialScale = Vector3.one;
|
|
networkTransform.UseHalfFloatPrecision = m_Precision == Precision.Half;
|
|
networkTransform.UseQuaternionSynchronization = m_Rotation == Rotation.Quaternion;
|
|
networkTransform.transform.position = initialPosition;
|
|
networkTransform.transform.eulerAngles = initialRotAngles;
|
|
networkTransform.transform.localScale = initialScale;
|
|
networkTransform.SyncPositionX = syncPosX;
|
|
networkTransform.SyncPositionY = syncPosY;
|
|
networkTransform.SyncPositionZ = syncPosZ;
|
|
networkTransform.SyncRotAngleX = syncRotX;
|
|
networkTransform.SyncRotAngleY = syncRotY;
|
|
networkTransform.SyncRotAngleZ = syncRotZ;
|
|
networkTransform.SyncScaleX = syncScaX;
|
|
networkTransform.SyncScaleY = syncScaY;
|
|
networkTransform.SyncScaleZ = syncScaZ;
|
|
networkTransform.InLocalSpace = inLocalSpace;
|
|
|
|
// We want a relatively clean networkTransform state before we try to apply the transform to it
|
|
// We only preserve InLocalSpace and IsTeleportingNextFrame properties as they are the only things
|
|
// needed when applying a transform to a NetworkTransformState
|
|
var networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
NetworkDeltaPosition = new NetworkDeltaPosition(Vector3.zero, 0)
|
|
};
|
|
|
|
// Step 1: change properties, expect state to be dirty
|
|
{
|
|
networkTransform.transform.position = new Vector3(3, 4, 5);
|
|
networkTransform.transform.eulerAngles = new Vector3(30, 45, 90);
|
|
networkTransform.transform.localScale = new Vector3(1.1f, 0.5f, 2.5f);
|
|
|
|
if (syncPosX || syncPosY || syncPosZ || syncRotX || syncRotY || syncRotZ || syncScaX || syncScaY || syncScaZ)
|
|
{
|
|
Assert.NotNull(networkTransform.NetworkManager, "NetworkManager is NULL!");
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
|
|
// We want to start with a fresh NetworkTransformState since it could have other state
|
|
// information from the last time we applied the transform
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
var position = networkTransform.transform.position;
|
|
var rotAngles = networkTransform.transform.eulerAngles;
|
|
var scale = networkTransform.transform.localScale;
|
|
|
|
// Step 2: Verify the state changes in a tick are additive
|
|
// TODO: This will need to change if we update NetworkTransform to send all of the
|
|
// axis deltas that happened over a tick as a collection instead of collapsing them
|
|
// as the changes are detected.
|
|
{
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
|
|
// SyncPositionX
|
|
if (syncPosX)
|
|
{
|
|
position.x++;
|
|
networkTransform.transform.position = position;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsTrue(networkTransformState.HasPositionX);
|
|
}
|
|
|
|
// SyncPositionY
|
|
if (syncPosY)
|
|
{
|
|
position = networkTransform.transform.position;
|
|
position.y++;
|
|
networkTransform.transform.position = position;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsTrue(networkTransformState.HasPositionX || !syncPosX);
|
|
Assert.IsTrue(networkTransformState.HasPositionY);
|
|
}
|
|
|
|
// SyncPositionZ
|
|
if (syncPosZ)
|
|
{
|
|
position = networkTransform.transform.position;
|
|
position.z++;
|
|
networkTransform.transform.position = position;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsTrue(networkTransformState.HasPositionX || !syncPosX);
|
|
Assert.IsTrue(networkTransformState.HasPositionY || !syncPosY);
|
|
Assert.IsTrue(networkTransformState.HasPositionZ);
|
|
}
|
|
|
|
// SyncRotAngleX
|
|
if (syncRotX)
|
|
{
|
|
rotAngles = networkTransform.transform.eulerAngles;
|
|
rotAngles.x++;
|
|
networkTransform.transform.eulerAngles = rotAngles;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsTrue(networkTransformState.HasPositionX || !syncPosX);
|
|
Assert.IsTrue(networkTransformState.HasPositionY || !syncPosY);
|
|
Assert.IsTrue(networkTransformState.HasPositionZ || !syncPosZ);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleX);
|
|
}
|
|
|
|
// SyncRotAngleY
|
|
if (syncRotY)
|
|
{
|
|
rotAngles = networkTransform.transform.eulerAngles;
|
|
rotAngles.y++;
|
|
networkTransform.transform.eulerAngles = rotAngles;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsTrue(networkTransformState.HasPositionX || !syncPosX);
|
|
Assert.IsTrue(networkTransformState.HasPositionY || !syncPosY);
|
|
Assert.IsTrue(networkTransformState.HasPositionZ || !syncPosZ);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleX || !syncRotX);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleY);
|
|
}
|
|
// SyncRotAngleZ
|
|
if (syncRotZ)
|
|
{
|
|
rotAngles = networkTransform.transform.eulerAngles;
|
|
rotAngles.z++;
|
|
networkTransform.transform.eulerAngles = rotAngles;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsTrue(networkTransformState.HasPositionX || !syncPosX);
|
|
Assert.IsTrue(networkTransformState.HasPositionY || !syncPosY);
|
|
Assert.IsTrue(networkTransformState.HasPositionZ || !syncPosZ);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleX || !syncRotX);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleY || !syncRotY);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleZ);
|
|
}
|
|
|
|
// SyncScaleX
|
|
if (syncScaX)
|
|
{
|
|
scale = networkTransform.transform.localScale;
|
|
scale.x++;
|
|
networkTransform.transform.localScale = scale;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsTrue(networkTransformState.HasPositionX || !syncPosX);
|
|
Assert.IsTrue(networkTransformState.HasPositionY || !syncPosY);
|
|
Assert.IsTrue(networkTransformState.HasPositionZ || !syncPosZ);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleX || !syncRotX);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleY || !syncRotY);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleZ || !syncRotZ);
|
|
Assert.IsTrue(networkTransformState.HasScaleX);
|
|
}
|
|
// SyncScaleY
|
|
if (syncScaY)
|
|
{
|
|
scale = networkTransform.transform.localScale;
|
|
scale.y++;
|
|
networkTransform.transform.localScale = scale;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsTrue(networkTransformState.HasPositionX || !syncPosX);
|
|
Assert.IsTrue(networkTransformState.HasPositionY || !syncPosY);
|
|
Assert.IsTrue(networkTransformState.HasPositionZ || !syncPosZ);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleX || !syncRotX);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleY || !syncRotY);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleZ || !syncRotZ);
|
|
Assert.IsTrue(networkTransformState.HasScaleX || !syncScaX);
|
|
Assert.IsTrue(networkTransformState.HasScaleY);
|
|
}
|
|
// SyncScaleZ
|
|
if (syncScaZ)
|
|
{
|
|
scale = networkTransform.transform.localScale;
|
|
scale.z++;
|
|
networkTransform.transform.localScale = scale;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsTrue(networkTransformState.HasPositionX || !syncPosX);
|
|
Assert.IsTrue(networkTransformState.HasPositionY || !syncPosY);
|
|
Assert.IsTrue(networkTransformState.HasPositionZ || !syncPosZ);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleX || !syncRotX);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleY || !syncRotY);
|
|
Assert.IsTrue(networkTransformState.HasRotAngleZ || !syncRotZ);
|
|
Assert.IsTrue(networkTransformState.HasScaleX || !syncScaX);
|
|
Assert.IsTrue(networkTransformState.HasScaleY || !syncScaY);
|
|
Assert.IsTrue(networkTransformState.HasScaleZ);
|
|
}
|
|
}
|
|
|
|
// Step 3: disable a particular sync flag, expect state to be not dirty
|
|
// We do this last because it changes which axis will be synchronized.
|
|
{
|
|
// Reset the NetworkTransformState since teleporting will preserve
|
|
// any dirty values
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
|
|
position = networkTransform.transform.position;
|
|
rotAngles = networkTransform.transform.eulerAngles;
|
|
scale = networkTransform.transform.localScale;
|
|
|
|
// SyncPositionX
|
|
if (syncPosX)
|
|
{
|
|
networkTransform.SyncPositionX = false;
|
|
|
|
position.x++;
|
|
networkTransform.transform.position = position;
|
|
|
|
// If we are synchronizing more than 1 axis (teleporting impacts this too)
|
|
if (syncAxis != SyncAxis.SyncPosX && WillAnAxisBeSynchronized(ref networkTransform))
|
|
{
|
|
// For the x axis position value We should expect the state to still be considered dirty (more than one axis is being synchronized and we are teleporting)
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
// However, we expect it to not have applied the position x delta
|
|
Assert.IsFalse(networkTransformState.HasPositionX);
|
|
}
|
|
else
|
|
{
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
|
|
// Reset the NetworkTransformState since teleporting will preserve
|
|
// any dirty values
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
// SyncPositionY
|
|
if (syncPosY)
|
|
{
|
|
networkTransform.SyncPositionY = false;
|
|
|
|
position.y++;
|
|
networkTransform.transform.position = position;
|
|
if (syncAxis != SyncAxis.SyncPosY && WillAnAxisBeSynchronized(ref networkTransform))
|
|
{
|
|
// We want to start with a fresh NetworkTransformState since it could have other state
|
|
// information from the last time we applied the transform
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsFalse(networkTransformState.HasPositionY);
|
|
}
|
|
else
|
|
{
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
|
|
// Reset the NetworkTransformState since teleporting will preserve
|
|
// any dirty values
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
// SyncPositionZ
|
|
if (syncPosZ)
|
|
{
|
|
networkTransform.SyncPositionZ = false;
|
|
|
|
position.z++;
|
|
networkTransform.transform.position = position;
|
|
if (syncAxis != SyncAxis.SyncPosZ && WillAnAxisBeSynchronized(ref networkTransform))
|
|
{
|
|
// We want to start with a fresh NetworkTransformState since it could have other state
|
|
// information from the last time we applied the transform
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsFalse(networkTransformState.HasPositionZ);
|
|
}
|
|
else
|
|
{
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
|
|
// Reset the NetworkTransformState since teleporting will preserve
|
|
// any dirty values
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
// SyncRotAngleX - Now test that we don't synchronize this specific axis as long as we are not using quaternion synchronization
|
|
if (syncRotX && m_Rotation == Rotation.Euler)
|
|
{
|
|
networkTransform.SyncRotAngleX = false;
|
|
|
|
rotAngles.x++;
|
|
networkTransform.transform.eulerAngles = rotAngles;
|
|
if (syncAxis != SyncAxis.SyncRotX && WillAnAxisBeSynchronized(ref networkTransform))
|
|
{
|
|
// We want to start with a fresh NetworkTransformState since it could have other state
|
|
// information from the last time we applied the transform
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsFalse(networkTransformState.HasRotAngleX);
|
|
}
|
|
else
|
|
{
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
|
|
// Reset the NetworkTransformState since teleporting will preserve
|
|
// any dirty values
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
// SyncRotAngleY - Now test that we don't synchronize this specific axis as long as we are not using quaternion synchronization
|
|
if (syncRotY && m_Rotation == Rotation.Euler)
|
|
{
|
|
networkTransform.SyncRotAngleY = false;
|
|
|
|
rotAngles.y++;
|
|
networkTransform.transform.eulerAngles = rotAngles;
|
|
if (syncAxis != SyncAxis.SyncRotY && WillAnAxisBeSynchronized(ref networkTransform))
|
|
{
|
|
// We want to start with a fresh NetworkTransformState since it could have other state
|
|
// information from the last time we applied the transform
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsFalse(networkTransformState.HasRotAngleY);
|
|
}
|
|
else
|
|
{
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
|
|
// Reset the NetworkTransformState since teleporting will preserve
|
|
// any dirty values
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
// SyncRotAngleZ - Now test that we don't synchronize this specific axis as long as we are not using quaternion synchronization
|
|
if (syncRotZ && m_Rotation == Rotation.Euler)
|
|
{
|
|
networkTransform.SyncRotAngleZ = false;
|
|
|
|
rotAngles.z++;
|
|
networkTransform.transform.eulerAngles = rotAngles;
|
|
if (syncAxis != SyncAxis.SyncRotZ && WillAnAxisBeSynchronized(ref networkTransform))
|
|
{
|
|
// We want to start with a fresh NetworkTransformState since it could have other state
|
|
// information from the last time we applied the transform
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsFalse(networkTransformState.HasRotAngleZ);
|
|
}
|
|
else
|
|
{
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
|
|
// Reset the NetworkTransformState since teleporting will preserve
|
|
// any dirty values
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
// SyncScaleX
|
|
if (syncScaX)
|
|
{
|
|
networkTransform.SyncScaleX = false;
|
|
|
|
scale.x++;
|
|
networkTransform.transform.localScale = scale;
|
|
if (syncAxis != SyncAxis.SyncScaleX && WillAnAxisBeSynchronized(ref networkTransform))
|
|
{
|
|
// We want to start with a fresh NetworkTransformState since it could have other state
|
|
// information from the last time we applied the transform
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsFalse(networkTransformState.HasScaleX);
|
|
}
|
|
else
|
|
{
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
|
|
// Reset the NetworkTransformState since teleporting will preserve
|
|
// any dirty values
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
// SyncScaleY
|
|
if (syncScaY)
|
|
{
|
|
networkTransform.SyncScaleY = false;
|
|
|
|
scale.y++;
|
|
networkTransform.transform.localScale = scale;
|
|
if (syncAxis != SyncAxis.SyncScaleY && WillAnAxisBeSynchronized(ref networkTransform))
|
|
{
|
|
// We want to start with a fresh NetworkTransformState since it could have other state
|
|
// information from the last time we applied the transform
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsFalse(networkTransformState.HasScaleY);
|
|
}
|
|
else
|
|
{
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
|
|
// Reset the NetworkTransformState since teleporting will preserve
|
|
// any dirty values
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
// SyncScaleZ
|
|
if (syncScaZ)
|
|
{
|
|
networkTransform.SyncScaleZ = false;
|
|
|
|
scale.z++;
|
|
networkTransform.transform.localScale = scale;
|
|
if (syncAxis != SyncAxis.SyncScaleZ && WillAnAxisBeSynchronized(ref networkTransform))
|
|
{
|
|
// We want to start with a fresh NetworkTransformState since it could have other state
|
|
// information from the last time we applied the transform
|
|
networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
InLocalSpace = inLocalSpace,
|
|
IsTeleportingNextFrame = isTeleporting,
|
|
};
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
Assert.IsFalse(networkTransformState.HasScaleZ);
|
|
}
|
|
else
|
|
{
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
Object.DestroyImmediate(gameObject);
|
|
Object.DestroyImmediate(manager);
|
|
}
|
|
|
|
|
|
[Test]
|
|
public void TestThresholds(
|
|
[Values(NetworkTransform.PositionThresholdDefault, 1.0f)] float positionThreshold,
|
|
[Values(NetworkTransform.RotAngleThresholdDefault, 1.0f)] float rotAngleThreshold,
|
|
[Values(NetworkTransform.ScaleThresholdDefault, 0.5f)] float scaleThreshold)
|
|
{
|
|
var inLocalSpace = m_TransformSpace == TransformSpace.Local;
|
|
var gameObject = new GameObject($"Test-{nameof(NetworkTransformStateTests)}.{nameof(TestThresholds)}");
|
|
var networkTransform = gameObject.AddComponent<NetworkTransform>();
|
|
networkTransform.enabled = false; // do not tick `FixedUpdate()` or `Update()`
|
|
|
|
var initialPosition = Vector3.zero;
|
|
var initialRotAngles = Vector3.zero;
|
|
var initialScale = Vector3.one;
|
|
|
|
networkTransform.transform.position = initialPosition;
|
|
networkTransform.transform.eulerAngles = initialRotAngles;
|
|
networkTransform.transform.localScale = initialScale;
|
|
networkTransform.SyncPositionX = true;
|
|
networkTransform.SyncPositionY = true;
|
|
networkTransform.SyncPositionZ = true;
|
|
networkTransform.SyncRotAngleX = true;
|
|
networkTransform.SyncRotAngleY = true;
|
|
networkTransform.SyncRotAngleZ = true;
|
|
networkTransform.SyncScaleX = true;
|
|
networkTransform.SyncScaleY = true;
|
|
networkTransform.SyncScaleZ = true;
|
|
networkTransform.InLocalSpace = inLocalSpace;
|
|
networkTransform.PositionThreshold = positionThreshold;
|
|
networkTransform.RotAngleThreshold = rotAngleThreshold;
|
|
networkTransform.ScaleThreshold = scaleThreshold;
|
|
|
|
var networkTransformState = new NetworkTransform.NetworkTransformState
|
|
{
|
|
PositionX = initialPosition.x,
|
|
PositionY = initialPosition.y,
|
|
PositionZ = initialPosition.z,
|
|
RotAngleX = initialRotAngles.x,
|
|
RotAngleY = initialRotAngles.y,
|
|
RotAngleZ = initialRotAngles.z,
|
|
ScaleX = initialScale.x,
|
|
ScaleY = initialScale.y,
|
|
ScaleZ = initialScale.z,
|
|
InLocalSpace = inLocalSpace
|
|
};
|
|
|
|
// Step 1: change properties, expect state to be dirty
|
|
{
|
|
networkTransform.transform.position = new Vector3(3, 4, 5);
|
|
networkTransform.transform.eulerAngles = new Vector3(30, 45, 90);
|
|
networkTransform.transform.localScale = new Vector3(1.1f, 0.5f, 2.5f);
|
|
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
|
|
// Step 2: make changes below and above thresholds
|
|
// changes below the threshold should not make `NetworkState` dirty
|
|
// changes above the threshold should make `NetworkState` dirty
|
|
{
|
|
// Position
|
|
if (!Mathf.Approximately(positionThreshold, 0.0f))
|
|
{
|
|
var position = networkTransform.transform.position;
|
|
|
|
// PositionX
|
|
{
|
|
position.x += positionThreshold / 2;
|
|
networkTransform.transform.position = position;
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
|
|
position.x += positionThreshold * 2;
|
|
networkTransform.transform.position = position;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
|
|
// PositionY
|
|
{
|
|
position.y += positionThreshold / 2;
|
|
networkTransform.transform.position = position;
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
|
|
position.y += positionThreshold * 2;
|
|
networkTransform.transform.position = position;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
|
|
// PositionZ
|
|
{
|
|
position.z += positionThreshold / 2;
|
|
networkTransform.transform.position = position;
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
|
|
position.z += positionThreshold * 2;
|
|
networkTransform.transform.position = position;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
|
|
// RotAngles
|
|
if (!Mathf.Approximately(rotAngleThreshold, 0.0f))
|
|
{
|
|
var rotAngles = networkTransform.transform.eulerAngles;
|
|
|
|
// RotAngleX
|
|
{
|
|
rotAngles.x += rotAngleThreshold / 2;
|
|
networkTransform.transform.eulerAngles = rotAngles;
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
|
|
rotAngles.x += rotAngleThreshold * 2;
|
|
networkTransform.transform.eulerAngles = rotAngles;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
|
|
// RotAngleY
|
|
{
|
|
rotAngles.y += rotAngleThreshold / 2;
|
|
networkTransform.transform.eulerAngles = rotAngles;
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
|
|
rotAngles.y += rotAngleThreshold * 2;
|
|
networkTransform.transform.eulerAngles = rotAngles;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
|
|
// RotAngleZ
|
|
{
|
|
rotAngles.z += rotAngleThreshold / 2;
|
|
networkTransform.transform.eulerAngles = rotAngles;
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
|
|
rotAngles.z += rotAngleThreshold * 2;
|
|
networkTransform.transform.eulerAngles = rotAngles;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
|
|
// Scale
|
|
if (!Mathf.Approximately(scaleThreshold, 0.0f) && inLocalSpace)
|
|
{
|
|
var scale = networkTransform.transform.localScale;
|
|
|
|
// ScaleX
|
|
{
|
|
scale.x += scaleThreshold / 2;
|
|
networkTransform.transform.localScale = scale;
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
|
|
scale.x += scaleThreshold * 2;
|
|
networkTransform.transform.localScale = scale;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
|
|
// ScaleY
|
|
{
|
|
scale.y += scaleThreshold / 2;
|
|
networkTransform.transform.localScale = scale;
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
|
|
scale.y += scaleThreshold * 2;
|
|
networkTransform.transform.localScale = scale;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
|
|
// ScaleZ
|
|
{
|
|
scale.z += scaleThreshold / 2;
|
|
networkTransform.transform.localScale = scale;
|
|
Assert.IsFalse(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
|
|
scale.z += scaleThreshold * 2;
|
|
networkTransform.transform.localScale = scale;
|
|
Assert.IsTrue(networkTransform.ApplyTransformToNetworkState(ref networkTransformState, 0, networkTransform.transform));
|
|
}
|
|
}
|
|
}
|
|
|
|
Object.DestroyImmediate(gameObject);
|
|
}
|
|
}
|
|
}
|