fix: networktransform double lerp (MTTB-539) (#3337)

This PR fixes the issue with double lerping by providing two types of
interpolators to select from while also exposing the
`MaximumInterpolationTime` for each respective interpolator type. Smooth
Dampening is added as an alternative to using lerp for each respective
interpolator (position, rotation, and scale).

This PR includes a few new additions:
- Additional updates to the inspector view which allows for interpolator
type selection and if available additional properties associated with
the interpolator.

![image](https://github.com/user-attachments/assets/f643c015-646f-4c1a-a979-05a6287b41d7)

![image](https://github.com/user-attachments/assets/335cd68d-98fd-44b7-b6f3-88c4d44a60fd)

![image](https://github.com/user-attachments/assets/63c6d44c-09a4-4bad-b74e-46218a3a4b8c)

![image](https://github.com/user-attachments/assets/d966dd7c-0c82-4bcd-85ce-e7cf8455d3a6)
- A new `NetworkTimeSystem.TickLatency` property that provides the
average latency of a client.
- An new `NetworkTime.FixedDeltaTimeAsDouble` property that returns a
`double` version of the `NetworkTime.FixedDeltaTime`.

This PR also starts the deprecation process for
`BufferedLinearInterpolator<T>.Update(float deltaTime, NetworkTime
serverTime)` as this method is only for internal testing purposes.


[MTTB-539](https://jira.unity3d.com/browse/MTTB-539)
[MTT-11338](https://jira.unity3d.com/browse/MTT-11338) -- Fixing
disabled tests

fix: #3112
close: #3112 

## Changelog

- Added: Interpolator types as an inspector view selection for position,
rotation, and scale.
- Added: A new smooth dampening interpolator type that provides a nice
balance between precision and smoothing results.
- Added: `NetworkTimeSystem.TickLatency` property that provides the
average latency of a client.
- Fixed: Issue where the `MaximumInterpolationTime` could not be
modified from within the inspector view or runtime.
- Changed: `BufferedLinearInterpolator<T>.Update(float deltaTime,
NetworkTime serverTime)` as being deprecated since this method is only
used for internal testing purposes.

## Testing and Documentation

- Includes integration test updates:
- `InterpolatorTests` was updated to changes and two disabled tests were
refactored and re-enabled.
- `NetworkTransformGeneral` includes additional TestFixture passes using
Smooth Dampening.
- `NetworktTransformTests` includes additional TestFixture passes using
Smooth Dampening.
- `NestedNetworkTransformTests` includes additional TestFixture passes
using Smooth Dampening.
- Includes updates and additions to public documentation
([PR-1443](Unity-Technologies/com.unity.multiplayer.docs#1443))

<!-- Uncomment and mark items off with a * if this PR deprecates any
API:
### Deprecated API
- [ ] An `[Obsolete]` attribute was added along with a `(RemovedAfter
yyyy-mm-dd)` entry.
- [ ] An [api updater] was added.
- [ ] Deprecation of the API is explained in the CHANGELOG.
- [ ] The users can understand why this API was removed and what they
should use instead.
-->

Author: NoelStephensUnity

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -10,11 +10,15 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Added
 
+- Added interpolator types as an inspector view selection for position, rotation, and scale. (#3337)
+- Added a new smooth dampening interpolator type that provides a nice balance between precision and smoothing results. (#3337)
+- Added `NetworkTimeSystem.TickLatency` property that provides the average latency of a client. (#3337)
 - Added `FastBufferReader(ArraySegment<byte> buffer, Allocator copyAllocator)` constructor that uses the `ArraySegment.Offset` as the `FastBufferReader` offset and the `ArraySegment.Count` as the `FastBufferReader` length. (#3321)
 - Added `FastBufferReader(ArraySegment<byte> buffer, Allocator copyAllocator, int length = -1)` constructor that uses the `ArraySegment.Offset` as the `FastBufferReader` offset. (#3321)
 
 ### Fixed
 
+- Fixed issue where the `MaximumInterpolationTime` could not be modified from within the inspector view or runtime. (#3337)
 - Fixed `ChangeOwnership` changing ownership to clients that are not observers. This also happened with automated object distribution. (#3323)
 - Fixed issue where `AnticipatedNetworkVariable` previous value returned by `AnticipatedNetworkVariable.OnAuthoritativeValueChanged` is updated correctly on the non-authoritative side. (#3306)
 - Fixed `OnClientConnectedCallback` passing incorrect `clientId` when scene management is disabled. (#3312)
@@ -31,6 +35,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Changed
 
+- Changed `BufferedLinearInterpolator<T>.Update(float deltaTime, NetworkTime serverTime)` as being deprecated since this method is only used for internal testing purposes. (#3337)
 - Ensured that a useful error is thrown when attempting to build a dedicated server with Unity Transport that uses websockets. (#3336)
 - Changed root in-scene placed `NetworkObject` instances now will always have either the `Distributable` permission set unless the `SessionOwner` permission is set. (#3305)
 - Changed the `DestroyObject` message to reduce the serialized message size and remove the unnecessary message field. (#3304)

com.unity.netcode.gameobjects/Editor/Configuration/NetcodeForGameObjectsProjectSettings.cs

@@ -3,11 +3,21 @@
 
 namespace Unity.Netcode.Editor.Configuration
 {
+    /// <summary>
+    /// A <see cref="ScriptableSingleton{T}"/> of type <see cref="NetcodeForGameObjectsProjectSettings"/>.
+    /// </summary>
     [FilePath("ProjectSettings/NetcodeForGameObjects.asset", FilePathAttribute.Location.ProjectFolder)]
     public class NetcodeForGameObjectsProjectSettings : ScriptableSingleton<NetcodeForGameObjectsProjectSettings>
     {
         internal static readonly string DefaultNetworkPrefabsPath = "Assets/DefaultNetworkPrefabs.asset";
+        /// <summary>
+        /// The path and name for the DefaultNetworkPrefabs asset.
+        /// </summary>
         [SerializeField] public string NetworkPrefabsPath = DefaultNetworkPrefabsPath;
+
+        /// <summary>
+        /// A temporary network prefabs path used internally.
+        /// </summary>
         public string TempNetworkPrefabsPath;
 
         private void OnEnable()
@@ -19,6 +29,9 @@ private void OnEnable()
             TempNetworkPrefabsPath = NetworkPrefabsPath;
         }
 
+        /// <summary>
+        /// Used to determine whether the default network prefabs asset should be generated or not.
+        /// </summary>
         [SerializeField]
         public bool GenerateDefaultNetworkPrefabs = true;
 

com.unity.netcode.gameobjects/Editor/Configuration/NetworkPrefabProcessor.cs

@@ -9,6 +9,9 @@ namespace Unity.Netcode.Editor.Configuration
     /// </summary>
     public class NetworkPrefabProcessor : AssetPostprocessor
     {
+        /// <summary>
+        /// The path to the default network prefabs list.
+        /// </summary>
         public static string DefaultNetworkPrefabsPath
         {
             get

com.unity.netcode.gameobjects/Editor/Configuration/NetworkPrefabsEditor.cs

@@ -4,6 +4,9 @@
 
 namespace Unity.Netcode.Editor
 {
+    /// <summary>
+    /// The custom editor for the <see cref="NetworkPrefabsList"/> <see cref="ScriptableObject"/>.
+    /// </summary>
     [CustomEditor(typeof(NetworkPrefabsList), true)]
     [CanEditMultipleObjects]
     public class NetworkPrefabsEditor : UnityEditor.Editor
@@ -82,6 +85,7 @@ private void OnEnable()
             m_NetworkPrefabsList.drawHeaderCallback = rect => EditorGUI.LabelField(rect, "NetworkPrefabs");
         }
 
+        /// <inheritdoc />
         public override void OnInspectorGUI()
         {
             using (new EditorGUI.DisabledScope(true))

com.unity.netcode.gameobjects/Editor/NetcodeEditorBase.cs

@@ -8,18 +8,87 @@ namespace Unity.Netcode.Editor
     /// The base Netcode Editor helper class to display derived <see cref="MonoBehaviour"/> based components <br />
     /// where each child generation's properties will be displayed within a FoldoutHeaderGroup.
     /// </summary>
+    /// <remarks>
+    /// <see cref="TT"/> Defines the base <see cref="MonoBehaviour"/> derived component type where <see cref="DrawFoldOutGroup"/>'s type T
+    /// refers to any child derived class of <see cref="TT"/>. This provides the ability to have multiple child generation derived custom
+    /// editos that each child derivation handles drawing its unique properies from that of its parent class.
+    /// </remarks>
+    /// <typeparam name="TT">The base <see cref="MonoBehaviour"/> derived component type</typeparam>
     [CanEditMultipleObjects]
     public partial class NetcodeEditorBase<TT> : UnityEditor.Editor where TT : MonoBehaviour
     {
+        private const int k_IndentOffset = 15;
+        private int m_IndentOffset = 0;
+        private int m_IndentLevel = 0;
+        private float m_OriginalLabelWidth;
+
         /// <inheritdoc cref="UnityEditor.Editor.OnEnable"/>
         public virtual void OnEnable()
         {
         }
 
+        /// <summary>
+        /// Draws a <see cref="SerializedProperty"/> with the option to provide the font style to use.
+        /// </summary>
+        /// <param name="property">The serialized property (<see cref="SerializedProperty"/>) to draw within the inspector view.</param>
+        /// <param name="fontStyle">The font style (<see cref="FontStyle"/>) to use when drawing the label of the property field.</param>
+        private protected void DrawPropertyField(SerializedProperty property, FontStyle fontStyle = FontStyle.Normal)
+        {
+            var originalWidth = EditorGUIUtility.labelWidth;
+            EditorGUIUtility.labelWidth = originalWidth - (m_IndentOffset * m_IndentLevel);
+            var originalLabelFontStyle = EditorStyles.label.fontStyle;
+            EditorStyles.label.fontStyle = fontStyle;
+            EditorGUILayout.PropertyField(property);
+            EditorStyles.label.fontStyle = originalLabelFontStyle;
+            EditorGUIUtility.labelWidth = originalWidth;
+        }
+
+        /// <summary>
+        /// Will begin a new indention level for drawing propery fields.
+        /// </summary>
+        /// <remarks>
+        /// You *must* call <see cref="EndIndent"/> when returning back to the previous indention level.<br />
+        /// For additional information:<br />
+        /// - <see cref="EndIndent"/><br />
+        /// - <see cref="DrawPropertyField"/><br />
+        /// </remarks>
+        /// <param name="offset">(optional) The size in pixels of the offset. If no value passed, then it uses a default of 15 pixels.</param>
+        private protected void BeginIndent(int offset = k_IndentOffset)
+        {
+            m_IndentOffset = offset;
+            m_IndentLevel++;
+            GUILayout.BeginHorizontal();
+            GUILayout.Space(m_IndentOffset);
+            GUILayout.BeginVertical();
+        }
+
+        /// <summary>
+        /// Will end the current indention level when drawing propery fields.
+        /// </summary>
+        /// <remarks>
+        /// For additional information:<br />
+        /// - <see cref="BeginIndent"/><br />
+        /// - <see cref="DrawPropertyField"/><br />
+        /// </remarks>
+        private protected void EndIndent()
+        {
+            if (m_IndentLevel == 0)
+            {
+                Debug.LogWarning($"Invoking {nameof(EndIndent)} when the indent level is already 0!");
+                return;
+            }
+            m_IndentLevel--;
+            GUILayout.EndVertical();
+            GUILayout.EndHorizontal();
+        }
+
         /// <summary>
         /// Helper method to draw the properties of the specified child type <typeparamref name="T"/> component within a FoldoutHeaderGroup.
         /// </summary>
-        /// <typeparam name="T">The specific child type that should have its properties drawn.</typeparam>
+        /// <remarks>
+        /// <see cref="T"/> must be a sub-class of the root parent class type <see cref="TT"/>.
+        /// </remarks>
+        /// <typeparam name="T">The specific child derived type of <see cref="TT"/> or the type of <see cref="TT"/> that should have its properties drawn.</typeparam>
         /// <param name="type">The component type of the <see cref="UnityEditor.Editor.target"/>.</param>
         /// <param name="displayProperties">The <see cref="Action"/> to invoke that will draw the type <typeparamref name="T"/> properties.</param>
         /// <param name="expanded">The <typeparamref name="T"/> current expanded property value</param>
@@ -30,9 +99,11 @@ protected void DrawFoldOutGroup<T>(Type type, Action displayProperties, bool exp
             EditorGUI.BeginChangeCheck();
             serializedObject.Update();
             var currentClass = typeof(T);
+
             if (type.IsSubclassOf(currentClass) || (!type.IsSubclassOf(currentClass) && currentClass.IsSubclassOf(typeof(TT))))
             {
                 var expandedValue = EditorGUILayout.BeginFoldoutHeaderGroup(expanded, $"{currentClass.Name} Properties");
+
                 if (expandedValue)
                 {
                     EditorGUILayout.EndFoldoutHeaderGroup();

com.unity.netcode.gameobjects/Editor/NetworkTransformEditor.cs

@@ -28,6 +28,13 @@ public class NetworkTransformEditor : NetcodeEditorBase<NetworkTransform>
         private SerializedProperty m_ScaleThresholdProperty;
         private SerializedProperty m_InLocalSpaceProperty;
         private SerializedProperty m_InterpolateProperty;
+        private SerializedProperty m_PositionInterpolationTypeProperty;
+        private SerializedProperty m_RotationInterpolationTypeProperty;
+        private SerializedProperty m_ScaleInterpolationTypeProperty;
+
+        private SerializedProperty m_PositionMaximumInterpolationTimeProperty;
+        private SerializedProperty m_RotationMaximumInterpolationTimeProperty;
+        private SerializedProperty m_ScaleMaximumInterpolationTimeProperty;
 
         private SerializedProperty m_UseQuaternionSynchronization;
         private SerializedProperty m_UseQuaternionCompression;
@@ -36,6 +43,7 @@ public class NetworkTransformEditor : NetcodeEditorBase<NetworkTransform>
         private SerializedProperty m_AuthorityMode;
 
         private static int s_ToggleOffset = 45;
+
         private static float s_MaxRowWidth = EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth + 5;
         private static GUIContent s_PositionLabel = EditorGUIUtility.TrTextContent("Position");
         private static GUIContent s_RotationLabel = EditorGUIUtility.TrTextContent("Rotation");
@@ -61,6 +69,15 @@ public override void OnEnable()
             m_ScaleThresholdProperty = serializedObject.FindProperty(nameof(NetworkTransform.ScaleThreshold));
             m_InLocalSpaceProperty = serializedObject.FindProperty(nameof(NetworkTransform.InLocalSpace));
             m_InterpolateProperty = serializedObject.FindProperty(nameof(NetworkTransform.Interpolate));
+
+            m_PositionInterpolationTypeProperty = serializedObject.FindProperty(nameof(NetworkTransform.PositionInterpolationType));
+            m_PositionMaximumInterpolationTimeProperty = serializedObject.FindProperty(nameof(NetworkTransform.PositionMaxInterpolationTime));
+            m_RotationInterpolationTypeProperty = serializedObject.FindProperty(nameof(NetworkTransform.RotationInterpolationType));
+            m_RotationMaximumInterpolationTimeProperty = serializedObject.FindProperty(nameof(NetworkTransform.RotationMaxInterpolationTime));
+            m_ScaleInterpolationTypeProperty = serializedObject.FindProperty(nameof(NetworkTransform.ScaleInterpolationType));
+            m_ScaleMaximumInterpolationTimeProperty = serializedObject.FindProperty(nameof(NetworkTransform.ScaleMaxInterpolationTime));
+
+
             m_UseQuaternionSynchronization = serializedObject.FindProperty(nameof(NetworkTransform.UseQuaternionSynchronization));
             m_UseQuaternionCompression = serializedObject.FindProperty(nameof(NetworkTransform.UseQuaternionCompression));
             m_UseHalfFloatPrecision = serializedObject.FindProperty(nameof(NetworkTransform.UseHalfFloatPrecision));
@@ -141,9 +158,21 @@ private void DisplayNetworkTransformProperties()
             }
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Thresholds", EditorStyles.boldLabel);
-            EditorGUILayout.PropertyField(m_PositionThresholdProperty);
-            EditorGUILayout.PropertyField(m_RotAngleThresholdProperty);
-            EditorGUILayout.PropertyField(m_ScaleThresholdProperty);
+            if (networkTransform.SynchronizePosition)
+            {
+                EditorGUILayout.PropertyField(m_PositionThresholdProperty);
+            }
+
+            if (networkTransform.SynchronizeRotation)
+            {
+                EditorGUILayout.PropertyField(m_RotAngleThresholdProperty);
+            }
+
+            if (networkTransform.SynchronizeScale)
+            {
+                EditorGUILayout.PropertyField(m_ScaleThresholdProperty);
+            }
+
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Delivery", EditorStyles.boldLabel);
             EditorGUILayout.PropertyField(m_TickSyncChildren);
@@ -158,9 +187,53 @@ private void DisplayNetworkTransformProperties()
             EditorGUILayout.PropertyField(m_InLocalSpaceProperty);
             if (!networkTransform.HideInterpolateValue)
             {
-                EditorGUILayout.PropertyField(m_InterpolateProperty);
+                if (networkTransform.Interpolate)
+                {
+                    EditorGUILayout.Space();
+                }
+                DrawPropertyField(m_InterpolateProperty, networkTransform.Interpolate ? FontStyle.Bold : FontStyle.Normal);
+                if (networkTransform.Interpolate)
+                {
+                    BeginIndent();
+                    if (networkTransform.SynchronizePosition)
+                    {
+                        DrawPropertyField(m_PositionInterpolationTypeProperty);
+                        // Only display when using Lerp.
+                        if (networkTransform.PositionInterpolationType == NetworkTransform.InterpolationTypes.Lerp)
+                        {
+                            BeginIndent();
+                            DrawPropertyField(m_SlerpPosition);
+                            DrawPropertyField(m_PositionMaximumInterpolationTimeProperty);
+                            EndIndent();
+                        }
+                    }
+                    if (networkTransform.SynchronizeRotation)
+                    {
+                        DrawPropertyField(m_RotationInterpolationTypeProperty);
+                        // Only display when using Lerp.
+                        if (networkTransform.RotationInterpolationType == NetworkTransform.InterpolationTypes.Lerp)
+                        {
+                            BeginIndent();
+                            DrawPropertyField(m_RotationMaximumInterpolationTimeProperty);
+                            EndIndent();
+                        }
+                    }
+                    if (networkTransform.SynchronizeScale)
+                    {
+                        DrawPropertyField(m_ScaleInterpolationTypeProperty);
+                        // Only display when using Lerp.
+                        if (networkTransform.ScaleInterpolationType == NetworkTransform.InterpolationTypes.Lerp)
+                        {
+                            BeginIndent();
+                            DrawPropertyField(m_ScaleMaximumInterpolationTimeProperty);
+                            EndIndent();
+                        }
+                    }
+                    EndIndent();
+                    EditorGUILayout.Space();
+                }
             }
-            EditorGUILayout.PropertyField(m_SlerpPosition);
+
             EditorGUILayout.PropertyField(m_UseQuaternionSynchronization);
             if (m_UseQuaternionSynchronization.boolValue)
             {
@@ -190,8 +263,6 @@ private void DisplayNetworkTransformProperties()
 #endif // COM_UNITY_MODULES_PHYSICS2D
         }
 
-
-
         /// <inheritdoc/>
         public override void OnInspectorGUI()
         {

com.unity.netcode.gameobjects/Runtime/Components/HalfVector3.cs

@@ -74,9 +74,7 @@ private void SerializeRead(FastBufferReader reader)
             }
         }
 
-        /// <summary>
-        /// The serialization implementation of <see cref="INetworkSerializable"/>.
-        /// </summary>
+        /// <inheritdoc />
         public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
         {
             if (serializer.IsReader)

com.unity.netcode.gameobjects/Runtime/Components/HalfVector4.cs

@@ -58,9 +58,7 @@ private void SerializeRead(FastBufferReader reader)
             }
         }
 
-        /// <summary>
-        /// The serialization implementation of <see cref="INetworkSerializable"/>.
-        /// </summary>
+        /// <inheritdoc />
         public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
         {
             if (serializer.IsReader)