update

Fixing some access permissions and sorting through what we are ready to release as a public API.

Author: NoelStephensUnity

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

@@ -18,8 +18,9 @@ namespace Unity.Netcode.Editor
     public partial class NetcodeEditorBase<TT> : UnityEditor.Editor where TT : MonoBehaviour
     {
         private const int k_IndentOffset = 15;
-        protected int IndentOffset { get; private set; } = 0;
-        protected int IndentLevel { get; private set; } = 0;
+        private int m_IndentOffset = 0;
+        private int m_IndentLevel = 0;
+        private float m_OriginalLabelWidth;
 
         /// <inheritdoc cref="UnityEditor.Editor.OnEnable"/>
         public virtual void OnEnable()
@@ -31,29 +32,14 @@ public virtual void OnEnable()
         /// </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>
-        protected void DrawPropertyField(SerializedProperty property, FontStyle fontStyle = FontStyle.Normal)
+        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;
-        }
-
-        /// <summary>
-        /// Draws an indented <see cref="SerializedProperty"/> with the option to provide the font style to use.
-        /// </summary>
-        /// <remarks>
-        /// For additional information:<br />
-        /// - <see cref="BeginIndent"/><br />
-        /// - <see cref="EndIndent"/><br />
-        /// </remarks>
-        /// <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>
-        protected void DrawIndentedPropertyField(SerializedProperty property, FontStyle fontStyle = FontStyle.Normal)
-        {
-            var originalWidth = EditorGUIUtility.labelWidth;
-            EditorGUIUtility.labelWidth = originalWidth - (IndentOffset * IndentLevel);
-            DrawPropertyField(property, fontStyle);
             EditorGUIUtility.labelWidth = originalWidth;
         }
 
@@ -64,15 +50,15 @@ protected void DrawIndentedPropertyField(SerializedProperty property, FontStyle
         /// 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="DrawIndentedPropertyField"/><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>
-        protected void BeginIndent(int offset = k_IndentOffset)
+        private protected void BeginIndent(int offset = k_IndentOffset)
         {
-            IndentOffset = offset;
-            IndentLevel++;
+            m_IndentOffset = offset;
+            m_IndentLevel++;
             GUILayout.BeginHorizontal();
-            GUILayout.Space(IndentOffset);
+            GUILayout.Space(m_IndentOffset);
             GUILayout.BeginVertical();
         }
 
@@ -82,16 +68,16 @@ protected void BeginIndent(int offset = k_IndentOffset)
         /// <remarks>
         /// For additional information:<br />
         /// - <see cref="BeginIndent"/><br />
-        /// - <see cref="DrawIndentedPropertyField"/><br />
+        /// - <see cref="DrawPropertyField"/><br />
         /// </remarks>
-        protected void EndIndent()
+        private protected void EndIndent()
         {
-            if (IndentLevel == 0)
+            if (m_IndentLevel == 0)
             {
                 Debug.LogWarning($"Invoking {nameof(EndIndent)} when the indent level is already 0!");
                 return;
             }
-            IndentLevel--;
+            m_IndentLevel--;
             GUILayout.EndVertical();
             GUILayout.EndHorizontal();
         }
@@ -113,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

@@ -197,35 +197,35 @@ private void DisplayNetworkTransformProperties()
                     BeginIndent();
                     if (networkTransform.SynchronizePosition)
                     {
-                        DrawIndentedPropertyField(m_PositionInterpolationTypeProperty);
+                        DrawPropertyField(m_PositionInterpolationTypeProperty);
                         // Only display when using Lerp.
                         if (networkTransform.PositionInterpolationType == NetworkTransform.InterpolationTypes.Lerp)
                         {
                             BeginIndent();
-                            DrawIndentedPropertyField(m_SlerpPosition);
-                            DrawIndentedPropertyField(m_PositionMaximumInterpolationTimeProperty);
+                            DrawPropertyField(m_SlerpPosition);
+                            DrawPropertyField(m_PositionMaximumInterpolationTimeProperty);
                             EndIndent();
                         }
                     }
                     if (networkTransform.SynchronizeRotation)
                     {
-                        DrawIndentedPropertyField(m_RotationInterpolationTypeProperty);
+                        DrawPropertyField(m_RotationInterpolationTypeProperty);
                         // Only display when using Lerp.
                         if (networkTransform.RotationInterpolationType == NetworkTransform.InterpolationTypes.Lerp)
                         {
                             BeginIndent();
-                            DrawIndentedPropertyField(m_RotationMaximumInterpolationTimeProperty);
+                            DrawPropertyField(m_RotationMaximumInterpolationTimeProperty);
                             EndIndent();
                         }
                     }
                     if (networkTransform.SynchronizeScale)
                     {
-                        DrawIndentedPropertyField(m_ScaleInterpolationTypeProperty);
+                        DrawPropertyField(m_ScaleInterpolationTypeProperty);
                         // Only display when using Lerp.
                         if (networkTransform.ScaleInterpolationType == NetworkTransform.InterpolationTypes.Lerp)
                         {
                             BeginIndent();
-                            DrawIndentedPropertyField(m_ScaleMaximumInterpolationTimeProperty);
+                            DrawPropertyField(m_ScaleMaximumInterpolationTimeProperty);
                             EndIndent();
                         }
                     }

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

@@ -156,7 +156,7 @@ public void Reset(T currentValue)
         private int m_NbItemsReceivedThisFrame;
 
         private double m_LastMeasurementAddedTime = 0.0f;
-        internal bool EndOfBuffer => m_Buffer.Count == 0;
+        internal bool EndOfBuffer => m_BufferQueue.Count == 0;
 
         internal bool InLocalSpace;
 
@@ -168,7 +168,37 @@ public void Reset(T currentValue)
         /// <summary>
         /// The current buffered items received by the authority.
         /// </summary>
-        protected internal readonly Queue<BufferedItem> m_Buffer = new Queue<BufferedItem>(k_BufferCountLimit);
+        protected internal readonly Queue<BufferedItem> m_BufferQueue = new Queue<BufferedItem>(k_BufferCountLimit);
+
+        /// <summary>
+        /// The legacy list of <see cref="BufferedItem"/> items.
+        /// </summary>
+        /// <remarks>
+        /// This is replaced by the <see cref="m_BufferQueue"/> of type <see cref="Queue{T}"/>.
+        /// </remarks>
+        [Obsolete("This list is no longer used and will be deprecated.", false)]
+        protected internal readonly List<BufferedItem> m_Buffer = new List<BufferedItem>();
+
+        /// <summary>
+        /// ** Deprecating **
+        /// The starting value of type <see cref="T"/> to interpolate from.
+        /// </summary>
+        [Obsolete("This property will be deprecated.", false)]
+        protected internal T m_InterpStartValue;
+
+        /// <summary>
+        /// ** Deprecating **
+        /// The current value of type <see cref="T"/>.
+        /// </summary>
+        [Obsolete("This property will be deprecated.", false)]
+        protected internal T m_CurrentInterpValue;
+
+        /// <summary>
+        /// ** Deprecating **
+        /// The end (or target) value of type <see cref="T"/> to interpolate towards.
+        /// </summary>
+        [Obsolete("This property will be deprecated.", false)]
+        protected internal T m_InterpEndValue;
 
         /// <summary>
         /// Represents the rate of change for the value being interpolated when smooth dampening is enabled.
@@ -192,7 +222,7 @@ public void Reset(T currentValue)
         /// </summary>
         public void Clear()
         {
-            m_Buffer.Clear();
+            m_BufferQueue.Clear();
             m_BufferCount = 0;
             m_LastMeasurementAddedTime = 0.0;
             InterpolateState.Reset(default);
@@ -244,7 +274,7 @@ private void TryConsumeFromBuffer(double renderTime, float minDeltaTime, float m
                 BufferedItem? previousItem = null;
                 var startTime = 0.0;
                 var alreadyHasBufferItem = false;
-                while (m_Buffer.TryPeek(out BufferedItem potentialItem))
+                while (m_BufferQueue.TryPeek(out BufferedItem potentialItem))
                 {
                     // If we are still on the same buffered item (FIFO Queue), then exit early as there is nothing
                     // to consume.
@@ -261,7 +291,7 @@ private void TryConsumeFromBuffer(double renderTime, float minDeltaTime, float m
                     if (!InterpolateState.Target.HasValue ||
                         ((potentialItem.TimeSent <= renderTime) && InterpolateState.Target.Value.TimeSent <= potentialItem.TimeSent))
                     {
-                        if (m_Buffer.TryDequeue(out BufferedItem target))
+                        if (m_BufferQueue.TryDequeue(out BufferedItem target))
                         {
                             if (!InterpolateState.Target.HasValue)
                             {
@@ -316,7 +346,7 @@ private void TryConsumeFromBuffer(double renderTime, float minDeltaTime, float m
         /// <param name="minDeltaTime">The minimum time delta between the current and target value.</param>
         /// <param name="maxDeltaTime">The maximum time delta between the current and target value.</param>
         /// <returns>The newly interpolated value of type 'T'</returns>
-        public T Update(float deltaTime, double tickLatencyAsTime, float minDeltaTime, float maxDeltaTime)
+        internal T Update(float deltaTime, double tickLatencyAsTime, float minDeltaTime, float maxDeltaTime)
         {
             TryConsumeFromBuffer(tickLatencyAsTime, minDeltaTime, maxDeltaTime);
             // Only interpolate when there is a start and end point and we have not already reached the end value
@@ -353,7 +383,7 @@ private void TryConsumeFromBuffer(double renderTime, double serverTime)
             {
                 BufferedItem? previousItem = null;
                 var alreadyHasBufferItem = false;
-                while (m_Buffer.TryPeek(out BufferedItem potentialItem))
+                while (m_BufferQueue.TryPeek(out BufferedItem potentialItem))
                 {
                     // If we are still on the same buffered item (FIFO Queue), then exit early as there is nothing
                     // to consume.
@@ -365,12 +395,11 @@ private void TryConsumeFromBuffer(double renderTime, double serverTime)
                     if ((potentialItem.TimeSent <= serverTime) &&
                         (!InterpolateState.Target.HasValue || InterpolateState.Target.Value.TimeSent < potentialItem.TimeSent))
                     {
-                        if (m_Buffer.TryDequeue(out BufferedItem target))
+                        if (m_BufferQueue.TryDequeue(out BufferedItem target))
                         {
                             if (!InterpolateState.Target.HasValue)
                             {
                                 InterpolateState.Target = target;
-
                                 alreadyHasBufferItem = true;
                                 InterpolateState.PreviousValue = InterpolateState.CurrentValue;
                                 InterpolateState.StartTime = target.TimeSent;
@@ -494,7 +523,7 @@ public void AddMeasurement(T newMeasurement, double sentTime)
                     m_LastMeasurementAddedTime = sentTime;
                     m_LastBufferedItemReceived = new BufferedItem(newMeasurement, sentTime, m_BufferCount);
                     // Next line keeps renderTime above m_StartTimeConsumed. Fixes pause/unpause issues
-                    m_Buffer.Enqueue(m_LastBufferedItemReceived);
+                    m_BufferQueue.Enqueue(m_LastBufferedItemReceived);
                 }
                 return;
             }
@@ -504,7 +533,7 @@ public void AddMeasurement(T newMeasurement, double sentTime)
             {
                 m_BufferCount++;
                 m_LastBufferedItemReceived = new BufferedItem(newMeasurement, sentTime, m_BufferCount);
-                m_Buffer.Enqueue(m_LastBufferedItemReceived);
+                m_BufferQueue.Enqueue(m_LastBufferedItemReceived);
                 m_LastMeasurementAddedTime = sentTime;
             }
         }
@@ -547,7 +576,7 @@ public T GetInterpolatedValue()
         /// <param name="deltaTime">The increasing delta time from when start to finish.</param>
         /// <param name="maxSpeed">Maximum rate of change per pass.</param>
         /// <returns>The smoothed <see cref="T"/> value.</returns>
-        protected internal virtual T SmoothDamp(T current, T target, ref T rateOfChange, float duration, float deltaTime, float maxSpeed = Mathf.Infinity)
+        private protected virtual T SmoothDamp(T current, T target, ref T rateOfChange, float duration, float deltaTime, float maxSpeed = Mathf.Infinity)
         {
             return target;
         }
@@ -559,7 +588,7 @@ protected internal virtual T SmoothDamp(T current, T target, ref T rateOfChange,
         /// <param name="second">Second value of type <see cref="T"/>.</param>
         /// <param name="precision">The precision of the aproximation.</param>
         /// <returns>true if the two values are aproximately the same and false if they are not</returns>
-        protected internal virtual bool IsAproximately(T first, T second, float precision = k_AproximatePrecision)
+        private protected virtual bool IsAproximately(T first, T second, float precision = k_AproximatePrecision)
         {
             return false;
         }
@@ -578,12 +607,12 @@ protected internal virtual T OnConvertTransformSpace(Transform transform, T item
 
         internal void ConvertTransformSpace(Transform transform, bool inLocalSpace)
         {
-            var count = m_Buffer.Count;
+            var count = m_BufferQueue.Count;
             for (int i = 0; i < count; i++)
             {
-                var entry = m_Buffer.Dequeue();
+                var entry = m_BufferQueue.Dequeue();
                 entry.Item = OnConvertTransformSpace(transform, entry.Item, inLocalSpace);
-                m_Buffer.Enqueue(entry);
+                m_BufferQueue.Enqueue(entry);
             }
             InterpolateState.CurrentValue = OnConvertTransformSpace(transform, InterpolateState.CurrentValue, inLocalSpace);
             var end = InterpolateState.Target.Value;

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

@@ -21,13 +21,13 @@ protected override float Interpolate(float start, float end, float time)
         }
 
         /// <inheritdoc />
-        protected internal override bool IsAproximately(float first, float second, float precision = 1E-07F)
+        private protected 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)
+        private protected override float SmoothDamp(float current, float target, ref float rateOfChange, float duration, float deltaTime, float maxSpeed = float.PositiveInfinity)
         {
             if (IsAngularValue)
             {

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

@@ -47,7 +47,7 @@ protected override Quaternion Interpolate(Quaternion start, Quaternion end, floa
         }
 
         /// <inheritdoc />
-        protected internal override Quaternion SmoothDamp(Quaternion current, Quaternion target, ref Quaternion rateOfChange, float duration, float deltaTime, float maxSpeed = float.PositiveInfinity)
+        private protected 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;
@@ -61,7 +61,7 @@ protected internal override Quaternion SmoothDamp(Quaternion current, Quaternion
         }
 
         /// <inheritdoc />
-        protected internal override bool IsAproximately(Quaternion first, Quaternion second, float precision)
+        private protected override bool IsAproximately(Quaternion first, Quaternion second, float precision)
         {
             return (1.0f - Quaternion.Dot(first, second)) <= precision;
         }

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

@@ -53,13 +53,13 @@ protected internal override Vector3 OnConvertTransformSpace(Transform transform,
         }
 
         /// <inheritdoc />
-        protected internal override bool IsAproximately(Vector3 first, Vector3 second, float precision = 0.0001F)
+        private protected 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)
+        private protected override Vector3 SmoothDamp(Vector3 current, Vector3 target, ref Vector3 rateOfChange, float duration, float deltaTime, float maxSpeed)
         {
             if (IsAngularValue)
             {