update

NetworkTransform and BufferedLinearInterpolator related updates.

Author: NoelStephensUnity

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

@@ -28,6 +28,7 @@ public class NetworkTransformEditor : NetcodeEditorBase<NetworkTransform>
         private SerializedProperty m_ScaleThresholdProperty;
         private SerializedProperty m_InLocalSpaceProperty;
         private SerializedProperty m_InterpolateProperty;
+        private SerializedProperty m_InterpolationTypeProperty;
 
         private SerializedProperty m_UseQuaternionSynchronization;
         private SerializedProperty m_UseQuaternionCompression;
@@ -61,6 +62,7 @@ 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_InterpolationTypeProperty = serializedObject.FindProperty(nameof(NetworkTransform.InterpolationType));
             m_UseQuaternionSynchronization = serializedObject.FindProperty(nameof(NetworkTransform.UseQuaternionSynchronization));
             m_UseQuaternionCompression = serializedObject.FindProperty(nameof(NetworkTransform.UseQuaternionCompression));
             m_UseHalfFloatPrecision = serializedObject.FindProperty(nameof(NetworkTransform.UseHalfFloatPrecision));
@@ -159,6 +161,10 @@ private void DisplayNetworkTransformProperties()
             if (!networkTransform.HideInterpolateValue)
             {
                 EditorGUILayout.PropertyField(m_InterpolateProperty);
+                if (networkTransform.Interpolate)
+                {
+                    EditorGUILayout.PropertyField(m_InterpolationTypeProperty);
+                }
             }
             EditorGUILayout.PropertyField(m_SlerpPosition);
             EditorGUILayout.PropertyField(m_UseQuaternionSynchronization);

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

@@ -0,0 +1,42 @@
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <inheritdoc />
+    /// <remarks>
+    /// This is a buffered linear interpolator for a <see cref="float"/> type value
+    /// </remarks>
+    public class BufferedLinearInterpolatorFloat : BufferedLinearInterpolator<float>
+    {
+        /// <inheritdoc />
+        protected override float InterpolateUnclamped(float start, float end, float time)
+        {
+            return Mathf.LerpUnclamped(start, end, time);
+        }
+
+        /// <inheritdoc />
+        protected override float Interpolate(float start, float end, float time)
+        {
+            return Mathf.Lerp(start, end, time);
+        }
+
+        /// <inheritdoc />
+        protected internal override bool IsAproximately(float first, float second, float precision = 1E-07F)
+        {
+            return Mathf.Approximately(first, second);
+        }
+
+        /// <inheritdoc />
+        protected internal override float SmoothDamp(float current, float target, ref float rateOfChange, float duration, float deltaTime, float maxSpeed = float.PositiveInfinity)
+        {
+            if (IsAngularValue)
+            {
+                return Mathf.SmoothDampAngle(current, target, ref rateOfChange, duration, maxSpeed, deltaTime);
+            }
+            else
+            {
+                return Mathf.SmoothDamp(current, target, ref rateOfChange, duration, maxSpeed, deltaTime);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,83 @@
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <inheritdoc />
+    /// <remarks>
+    /// This is a buffered linear interpolator for a <see cref="Quaternion"/> type value
+    /// </remarks>
+    public class BufferedLinearInterpolatorQuaternion : BufferedLinearInterpolator<Quaternion>
+    {
+        /// <summary>
+        /// Use <see cref="Quaternion.Slerp"/> when <see cref="true"/>.
+        /// Use <see cref="Quaternion.Lerp"/> when <see cref="false"/>
+        /// </summary>
+        /// <remarks>
+        /// When using half precision (due to the imprecision) using <see cref="Quaternion.Lerp"/> is
+        /// less processor intensive (i.e. precision is already "imprecise").
+        /// When using full precision (to maintain precision) using <see cref="Quaternion.Slerp"/> is
+        /// more processor intensive yet yields more precise results.
+        /// </remarks>
+        public bool IsSlerp;
+
+        /// <inheritdoc />
+        protected override Quaternion InterpolateUnclamped(Quaternion start, Quaternion end, float time)
+        {
+            if (IsSlerp)
+            {
+                return Quaternion.SlerpUnclamped(start, end, time);
+            }
+            else
+            {
+                return Quaternion.LerpUnclamped(start, end, time);
+            }
+        }
+
+        /// <inheritdoc />
+        protected override Quaternion Interpolate(Quaternion start, Quaternion end, float time)
+        {
+            if (IsSlerp)
+            {
+                return Quaternion.Slerp(start, end, time);
+            }
+            else
+            {
+                return Quaternion.Lerp(start, end, time);
+            }
+        }
+
+        /// <inheritdoc />
+        protected internal override Quaternion SmoothDamp(Quaternion current, Quaternion target, ref Quaternion rateOfChange, float duration, float deltaTime, float maxSpeed = float.PositiveInfinity)
+        {
+            Vector3 currentEuler = current.eulerAngles;
+            Vector3 targetEuler = target.eulerAngles;
+            for (int i = 0; i < 3; i++)
+            {
+                var velocity = rateOfChange[i];
+                currentEuler[i] = Mathf.SmoothDampAngle(currentEuler[i], targetEuler[i], ref velocity, duration, maxSpeed, deltaTime);
+                rateOfChange[i] = velocity;
+            }
+            return Quaternion.Euler(currentEuler);
+        }
+
+        protected internal override bool IsAproximately(Quaternion first, Quaternion second, float precision)
+        {
+            return Mathf.Abs(first.x - second.x) <= precision &&
+                Mathf.Abs(first.y - second.y) <= precision &&
+                Mathf.Abs(first.z - second.z) <= precision &&
+                Mathf.Abs(first.w - second.w) <= precision;
+        }
+
+        protected internal override Quaternion OnConvertTransformSpace(Transform transform, Quaternion rotation, bool inLocalSpace)
+        {
+            if (inLocalSpace)
+            {
+                return Quaternion.Inverse(transform.rotation) * rotation;
+            }
+            else
+            {
+                return transform.rotation * rotation;
+            }
+        }
+    }
+}

com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolatorFloat.cs.meta

@@ -0,0 +1,77 @@
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// A <see cref="BufferedLinearInterpolator{T}"/> <see cref="Vector3"/> implementation.
+    /// </summary>
+    public class BufferedLinearInterpolatorVector3 : BufferedLinearInterpolator<Vector3>
+    {
+        /// <summary>
+        /// Use <see cref="Vector3.Slerp"/> when <see cref="true"/>.
+        /// Use <see cref="Vector3.Lerp"/> when <see cref="false"/>
+        /// </summary>
+        public bool IsSlerp;
+        /// <inheritdoc />
+        protected override Vector3 InterpolateUnclamped(Vector3 start, Vector3 end, float time)
+        {
+            if (IsSlerp)
+            {
+                return Vector3.SlerpUnclamped(start, end, time);
+            }
+            else
+            {
+                return Vector3.LerpUnclamped(start, end, time);
+            }
+        }
+
+        /// <inheritdoc />
+        protected override Vector3 Interpolate(Vector3 start, Vector3 end, float time)
+        {
+            if (IsSlerp)
+            {
+                return Vector3.Slerp(start, end, time);
+            }
+            else
+            {
+                return Vector3.Lerp(start, end, time);
+            }
+        }
+
+        /// <inheritdoc />
+        protected internal override Vector3 OnConvertTransformSpace(Transform transform, Vector3 position, bool inLocalSpace)
+        {
+            if (inLocalSpace)
+            {
+                return transform.InverseTransformPoint(position);
+
+            }
+            else
+            {
+                return transform.TransformPoint(position);
+            }
+        }
+
+        /// <inheritdoc />
+        protected internal override bool IsAproximately(Vector3 first, Vector3 second, float precision = 0.0001F)
+        {
+            return Vector3.Distance(first, second) <= precision;
+        }
+
+        /// <inheritdoc />
+        protected internal override Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 rateOfChange, float duration, float deltaTime, float maxSpeed)
+        {
+            if (IsAngularValue)
+            {
+                current.x = Mathf.SmoothDampAngle(current.x, target.x, ref rateOfChange.x, duration, maxSpeed, deltaTime);
+                current.y = Mathf.SmoothDampAngle(current.y, target.y, ref rateOfChange.y, duration, maxSpeed, deltaTime);
+                current.z = Mathf.SmoothDampAngle(current.z, target.z, ref rateOfChange.z, duration, maxSpeed, deltaTime);
+                return current;
+            }
+            else
+            {
+                return Vector3.SmoothDamp(current, target, ref rateOfChange, duration, maxSpeed, deltaTime);
+            }
+        }
+    }
+}