update

adding xml api documentation, tooltips, and some editor adjustments.

Author: NoelStephensUnity

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

@@ -32,6 +32,10 @@ public class NetworkTransformEditor : NetcodeEditorBase<NetworkTransform>
         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;
         private SerializedProperty m_UseHalfFloatPrecision;
@@ -66,8 +70,11 @@ public override void OnEnable()
             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));
@@ -150,9 +157,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);
@@ -173,18 +192,37 @@ private void DisplayNetworkTransformProperties()
                     if (networkTransform.SynchronizePosition)
                     {
                         EditorGUILayout.PropertyField(m_PositionInterpolationTypeProperty);
+                        // Only display when using Lerp.
+                        if (networkTransform.PositionInterpolationType == NetworkTransform.InterpolationTypes.Lerp)
+                        {
+                            EditorGUILayout.PropertyField(m_SlerpPosition);
+                            EditorGUILayout.PropertyField(m_PositionMaximumInterpolationTimeProperty);
+                        }
                     }
                     if (networkTransform.SynchronizeRotation)
                     {
                         EditorGUILayout.PropertyField(m_RotationInterpolationTypeProperty);
+
+                        // Only display when using Lerp.
+                        if (networkTransform.RotationInterpolationType == NetworkTransform.InterpolationTypes.Lerp)
+                        {
+                            EditorGUILayout.PropertyField(m_RotationMaximumInterpolationTimeProperty);
+                        }
                     }
                     if (networkTransform.SynchronizeScale)
                     {
                         EditorGUILayout.PropertyField(m_ScaleInterpolationTypeProperty);
+                        // Only display when using Lerp.
+                        if (networkTransform.ScaleInterpolationType == NetworkTransform.InterpolationTypes.Lerp)
+                        {
+                            EditorGUILayout.PropertyField(m_ScaleMaximumInterpolationTimeProperty);
+                        }
                     }
                 }
+
             }
-            EditorGUILayout.PropertyField(m_SlerpPosition);
+            
+            
             EditorGUILayout.PropertyField(m_UseQuaternionSynchronization);
             if (m_UseQuaternionSynchronization.boolValue)
             {

com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolator.cs

@@ -134,10 +134,15 @@ public void Reset(T currentValue)
 
         private const double k_SmallValue = 9.999999439624929E-11; // copied from Vector3's equal operator
 
-
         /// <summary>
-        /// There's two factors affecting interpolation: buffering (set in NetworkManager's NetworkTimeSystem) and interpolation time, which is the amount of time it'll take to reach the target. This is to affect the second one.
+        /// Determines how much smoothing will be applied to the 2nd lerp when using the <see cref="Update(float, double, double)"/> (i.e. lerping and not smooth dampening).
         /// </summary>
+        /// <remarks>
+        /// There's two factors affecting interpolation: <br />
+        /// - Buffering: Which can be adjusted in set in the <see cref="NetworkManager.NetworkTimeSystem"/>.<br />
+        /// - Interpolation time: The divisor applied to delta time where the quotient is used as the lerp time.
+        /// </remarks>
+        [Range(0.016f, 1.0f)]
         public float MaximumInterpolationTime = 0.1f;
 
         /// <summary>
@@ -435,7 +440,10 @@ public T Update(float deltaTime, double renderTime, double serverTime)
                     }
                 }
                 var target = Interpolate(InterpolateState.PreviousValue, InterpolateState.Target.Value.Item, t);
-                InterpolateState.CurrentValue = Interpolate(InterpolateState.CurrentValue, target, deltaTime / MaximumInterpolationTime);
+
+                // Assure our MaximumInterpolationTime is valid and that the second lerp time ranges between deltaTime and 1.0f.
+                var secondLerpTime = Mathf.Clamp(deltaTime / Mathf.Max(deltaTime, MaximumInterpolationTime), deltaTime, 1.0f);
+                InterpolateState.CurrentValue = Interpolate(InterpolateState.CurrentValue, target, secondLerpTime);
             }
             m_NbItemsReceivedThisFrame = 0;
             return InterpolateState.CurrentValue;

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

@@ -937,55 +937,105 @@ public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReade
         #region PROPERTIES AND GENERAL METHODS
 
         /// <summary>
-        /// The two ways to smooth during interpolation.
+        /// The different interpolation types used with <see cref="BufferedLinearInterpolator{T}"/> to help smooth interpolation results.
         /// </summary>
         public enum InterpolationTypes
         {
             /// <summary>
             /// Uses lerping and yields a linear progression between two values.
             /// </summary>
+            /// <remarks>
+            /// For more information:<br />
+            /// - <see cref="PositionMaxInterpolationTime"/><br />
+            /// - <see cref="RotationMaxInterpolationTime"/><br />
+            /// - <see cref="ScaleMaxInterpolationTime"/><br />
+            /// </remarks>
             Lerp,
             /// <summary>
-            /// Uses a smooth dampening approach and is recommended when <see cref="NetworkRigidbodyBase.UseRigidBodyForMotion"/> is enabled.
+            /// Uses a smooth dampening approach for interpolating between two data points and adjusts based on rate of change.
             /// </summary>
+            /// <remarks>
+            /// Unlike <see cref="Lerp"/>, there are no additional values needed to be adjusted for this interpolation type.
+            /// </remarks>
             SmoothDampening
         }
 
         /// <summary>
         /// The position interpolation type to use for the <see cref="NetworkTransform"/> instance.
         /// </summary>
         /// <remarks>
-        /// For more details review <see cref="InterpolationTypes"/>.
+        /// - <see cref="InterpolationTypes.Lerp"/> yields a traditional linear result.<br />
+        /// - <see cref="InterpolationTypes.SmoothDampening"/> adjusts based on the rate of change.<br />
+        /// - You can have mixed interpolation types between position, rotation, and scale on the same <see cref="NetworkTransform"/> instance.<br />
+        /// - You can change the interpolation type during runtime, but changing between <see cref="InterpolationTypes"/> can result in a slight stutter if the object is in motion.<br />
         /// </remarks>
+        [Tooltip("Lerping yields a traditional linear result where smooth dampening will adjust based on the rate of change. You can mix interpolation types for position, rotation, and scale.")]
         public InterpolationTypes PositionInterpolationType;
 
         /// <summary>
         /// The rotation interpolation type to use for the <see cref="NetworkTransform"/> instance.
         /// </summary>
         /// <remarks>
-        /// For more details review <see cref="InterpolationTypes"/>.
+        /// - <see cref="InterpolationTypes.Lerp"/> yields a traditional linear result.<br />
+        /// - <see cref="InterpolationTypes.SmoothDampening"/> adjusts based on the rate of change.<br />
+        /// - You can have mixed interpolation types between position, rotation, and scale on the same <see cref="NetworkTransform"/> instance.<br />
+        /// - You can change the interpolation type during runtime, but changing between <see cref="InterpolationTypes"/> can result in a slight stutter if the object is in motion.<br />
         /// </remarks>
+        [Tooltip("Lerping yields a traditional linear result where smooth dampening will adjust based on the rate of change. You can mix interpolation types for position, rotation, and scale.")]
         public InterpolationTypes RotationInterpolationType;
 
         /// <summary>
         /// The scale interpolation type to use for the <see cref="NetworkTransform"/> instance.
         /// </summary>
         /// <remarks>
-        /// For more details review <see cref="InterpolationTypes"/>.
+        /// - <see cref="InterpolationTypes.Lerp"/> yields a traditional linear result.<br />
+        /// - <see cref="InterpolationTypes.SmoothDampening"/> adjusts based on the rate of change.<br />
+        /// - You can have mixed interpolation types between position, rotation, and scale on the same <see cref="NetworkTransform"/> instance.<br />
+        /// - You can change the interpolation type during runtime, but changing between <see cref="InterpolationTypes"/> can result in a slight stutter if the object is in motion.<br />
         /// </remarks>
+        [Tooltip("Lerping yields a traditional linear result where smooth dampening will adjust based on the rate of change. You can mix interpolation types for position, rotation, and scale.")]
         public InterpolationTypes ScaleInterpolationType;
 
         /// <summary>
-        /// When <see cref="Interpolate"/> is enabled and using <see cref="InterpolationTypes.Lerp"/>, this adjust the maximum interpolation time for position.
+        /// The position interoplation time divisor applied to the current delta time (dividend) where the quotient yields the time used for the second smoothing lerp.
+        /// - The lower the value the smoother, but can result in lost data points (i.e. quick changes in direct). <br />
+        /// - The higher the value the more accurate/precise, but can result in slight stutter (i.e. due to jitter, latency, or a high threshold value). <br />
+        /// - This value can be adjusted during runtime in the event you want to dynamically adjust it based on some other value (i.e. velocity or the like).
         /// </summary>
+        /// <remarks>
+        /// - Only used When <see cref="Interpolate"/> is enabled and using <see cref="InterpolationTypes.Lerp"/>. <br />
+        /// - The quotient will be clamped to a value that ranges from 1.0f to the current delta time (i.e. <see cref="Time.deltaTime"/> or <see cref="Time.fixedDeltaTime"/>)
+        /// </remarks>
+        [Tooltip("The lower the value the smoother, but can result in lost data points (i.e. quick changes in direct). The higher the value the more accurate/precise, but can result in slight stutter (i.e. due to jitter, latency, or a high threshold value).")]
+        [Range(0.01f, 1.0f)]
         public float PositionMaxInterpolationTime = 0.1f;
+
         /// <summary>
-        /// When <see cref="Interpolate"/> is enabled and using <see cref="InterpolationTypes.Lerp"/>, this adjust the maximum interpolation time for rotation.
+        /// The rotation interoplation time divisor applied to the current delta time (dividend) where the quotient yields the time used for the second smoothing lerp.
+        /// - The lower the value the smoother, but can result in lost data points (i.e. quick changes in direct). <br />
+        /// - The higher the value the more accurate/precise, but can result in slight stutter (i.e. due to jitter, latency, or a high threshold value). <br />
+        /// - This value can be adjusted during runtime in the event you want to dynamically adjust it based on some other value (i.e. velocity or the like).
         /// </summary>
+        /// <remarks>
+        /// - Only used When <see cref="Interpolate"/> is enabled and using <see cref="InterpolationTypes.Lerp"/>. <br />
+        /// - The quotient will be clamped to a value that ranges from 1.0f to the current delta time (i.e. <see cref="Time.deltaTime"/> or <see cref="Time.fixedDeltaTime"/>)
+        /// </remarks>
+        [Tooltip("The lower the value the smoother, but can result in lost data points (i.e. quick changes in direct). The higher the value the more accurate/precise, but can result in slight stutter (i.e. due to jitter, latency, or a high threshold value).")]
+        [Range(0.01f, 1.0f)]
         public float RotationMaxInterpolationTime = 0.1f;
+
         /// <summary>
-        /// When <see cref="Interpolate"/> is enabled and using <see cref="InterpolationTypes.Lerp"/>, this adjust the maximum interpolation time for scale.
+        /// The scale interoplation time divisor applied to the current delta time (dividend) where the quotient yields the time used for the second smoothing lerp.
+        /// - The lower the value the smoother, but can result in lost data points (i.e. quick changes in direct). <br />
+        /// - The higher the value the more accurate/precise, but can result in slight stutter (i.e. due to jitter, latency, or a high threshold value). <br />
+        /// - This value can be adjusted during runtime in the event you want to dynamically adjust it based on some other value (i.e. velocity or the like).
         /// </summary>
+        /// <remarks>
+        /// - Only used When <see cref="Interpolate"/> is enabled and using <see cref="InterpolationTypes.Lerp"/>. <br />
+        /// - The quotient will be clamped to a value that ranges from 1.0f to the current delta time (i.e. <see cref="Time.deltaTime"/> or <see cref="Time.fixedDeltaTime"/>)
+        /// </remarks>
+        [Tooltip("The lower the value the smoother, but can result in lost data points (i.e. quick changes in direct). The higher the value the more accurate/precise, but can result in slight stutter (i.e. due to jitter, latency, or a high threshold value).")]
+        [Range(0.01f, 1.0f)]
         public float ScaleMaxInterpolationTime = 0.1f;
 
         public enum AuthorityModes