fix

NoelStephensUnity · NoelStephensUnity · commit 158821c96754 · 2025-10-02T14:16:07.000-05:00
This resolves the issue where there was a de-synch between converting transform spaces.
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolator.cs b/com.unity.netcode.gameobjects/Runtime/Components/Interpolator/BufferedLinearInterpolator.cs
@@ -286,24 +286,24 @@ private void ConvertInterpolateStateValues(Transform parent, bool inLocalSpace)
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private void ConvertTransformSpace()
+        private void ConvertTransformSpace(BufferedItem newTarget)
         {
             if (!AutoConvertTransformSpace)
             {
                 return;
             }
-            if (InterpolateState.TargetParent != Parent)
+            if (InterpolateState.TargetParent != newTarget.MeasurementParent)
             {
                 if (InterpolateState.TargetParent != null)
                 {
                     // Convert to world space or local space depending upon what our current parent is.
                     ConvertInterpolateStateValues(InterpolateState.TargetParent, false);
                 }
 
-                if (Parent != null)
+                if (newTarget.MeasurementParent != null)
                 {
                     // Convert to local space.
-                    ConvertInterpolateStateValues(Parent, true);
+                    ConvertInterpolateStateValues(newTarget.MeasurementParent, true);
                 }
             }
         }
@@ -366,7 +366,7 @@ private void TryConsumeFromBuffer(double renderTime, double minDeltaTime, double
                 {
                     if (m_BufferQueue.TryDequeue(out BufferedItem target))
                     {
-                        ConvertTransformSpace();
+                        ConvertTransformSpace(target);
 
                         if (!InterpolateState.Target.HasValue)
                         {
@@ -516,7 +516,7 @@ private void TryConsumeFromBuffer(double renderTime, double serverTime)
                     {
                         if (m_BufferQueue.TryDequeue(out BufferedItem target))
                         {
-                            ConvertTransformSpace();
+                            ConvertTransformSpace(target);
                             if (!InterpolateState.Target.HasValue)
                             {
                                 InterpolateState.Target = target;
@@ -679,6 +679,29 @@ internal void AddMeasurement(Transform parent, T newMeasurement, double sentTime
             }
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private T GetParentRelativeValue(T currentValue)
+        {
+            if (!AutoConvertTransformSpace || InterpolateState.TargetParent == Parent)
+            {
+                return currentValue;
+            }
+
+            // Just convert on the fly until the next state is reached where it will do a full
+            // conversion when popped from the queue.
+            if (InterpolateState.TargetParent)
+            {
+                currentValue = OnConvertTransformSpace(InterpolateState.TargetParent, currentValue, false);
+            }
+
+            if (Parent != null)
+            {
+                var previousCurrent = currentValue.ToString();
+                currentValue = OnConvertTransformSpace(Parent, currentValue, true);
+            }
+            return currentValue;
+        }
+
         /// <summary>
         /// Gets latest value from the interpolator. This is updated every update as time goes by.
         /// </summary>
@@ -689,16 +712,17 @@ public T GetInterpolatedValue()
             var currentValue = InterpolateState.CurrentValue;
             if (AutoConvertTransformSpace && InterpolateState.TargetParent != Parent)
             {
-                // Just convert on the fly until the next state is reached where it will do a full
-                // conversion when popped from the queue.
-                if (InterpolateState.TargetParent != null)
-                {
-                    currentValue = OnConvertTransformSpace(InterpolateState.TargetParent, currentValue, false);
-                }
+                currentValue = GetParentRelativeValue(currentValue);
 
-                if (Parent != null)
+                // When there are no more states and we have reached our target,
+                // hijack the last state as if it was submitted by the current
+                // parent.
+                if (m_BufferQueue.Count == 0 && (InterpolateState.TargetReached || !InterpolateState.Target.HasValue))
                 {
-                    currentValue = OnConvertTransformSpace(Parent, currentValue, true);
+                    InterpolateState.CurrentValue = currentValue;
+                    InterpolateState.NextValue = currentValue;
+                    InterpolateState.PreviousValue = currentValue;
+                    InterpolateState.TargetParent = Parent;
                 }
             }
             return currentValue;
diff --git a/com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs b/com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs
@@ -1526,12 +1526,12 @@ internal bool SynchronizeScale
         /// <summary>
         /// Returns true if position is currently in local space and false if it is in world space.
         /// </summary>
-        protected bool PositionInLocalSpace => (!SwitchTransformSpaceWhenParented && InLocalSpace) || (m_PositionInterpolator != null && m_PositionInterpolator.InLocalSpace && SwitchTransformSpaceWhenParented);
+        protected bool PositionInLocalSpace => InLocalSpace;
 
         /// <summary>
         /// Returns true if rotation is currently in local space and false if it is in world space.
         /// </summary>
-        protected bool RotationInLocalSpace => (!SwitchTransformSpaceWhenParented && InLocalSpace) || (m_RotationInterpolator != null && m_RotationInterpolator.InLocalSpace && SwitchTransformSpaceWhenParented);
+        protected bool RotationInLocalSpace => InLocalSpace;
 
         /// <summary>
         /// When enabled (default) interpolation is applied.
@@ -3146,10 +3146,12 @@ internal void ApplyUpdatedState(NetworkTransformState newState)
             // depending upon whether UsePositionDeltaCompression is enabled
             if (m_LocalAuthoritativeNetworkState.HasPositionChange)
             {
+                // If interpolating, get the current value as the final next position or current position
+                // depending upon if the interpolator is still processing a state or not.
+                var newTargetPosition = Interpolate ? m_PositionInterpolator.GetInterpolatedValue() : m_TargetPosition;
                 if (!m_LocalAuthoritativeNetworkState.UseHalfFloatPrecision)
                 {
                     var position = m_LocalAuthoritativeNetworkState.GetPosition();
-                    var newTargetPosition = m_TargetPosition;
                     if (m_LocalAuthoritativeNetworkState.HasPositionX)
                     {
                         newTargetPosition.x = position.x;
@@ -3164,8 +3166,8 @@ internal void ApplyUpdatedState(NetworkTransformState newState)
                     {
                         newTargetPosition.z = position.z;
                     }
-                    m_TargetPosition = newTargetPosition;
                 }
+                m_TargetPosition = newTargetPosition;
                 UpdatePositionInterpolator(m_TargetPosition, sentTime);
             }
 
@@ -3900,7 +3902,6 @@ internal override void InternalOnNetworkObjectParentChanged(NetworkObject parent
                     m_PositionInterpolator.AutoConvertTransformSpace = SwitchTransformSpaceWhenParented;
                     m_PositionInterpolator.InLocalSpace = InLocalSpace;
                     m_PositionInterpolator.Parent = InLocalSpace ? parentNetworkObject.transform : null;
-                    var parentName = InLocalSpace ? parentNetworkObject.name : "root";
 
                     if (LastTickSync == m_LocalAuthoritativeNetworkState.GetNetworkTick())
                     {
@@ -3917,7 +3918,14 @@ internal override void InternalOnNetworkObjectParentChanged(NetworkObject parent
                     }
                     else
                     {
-                        m_InternalCurrentPosition = m_TargetPosition = Interpolate ? m_PositionInterpolator.GetInterpolatedValue() : GetSpaceRelativePosition();
+                        if (CanCommitToTransform)
+                        {
+                            m_InternalCurrentPosition = GetSpaceRelativePosition();
+                        }
+                        else
+                        {
+                            m_InternalCurrentPosition = m_TargetPosition = Interpolate ? m_PositionInterpolator.GetInterpolatedValue() : GetSpaceRelativePosition();
+                        }
                     }
                 }
 
@@ -3942,7 +3950,14 @@ internal override void InternalOnNetworkObjectParentChanged(NetworkObject parent
                     }
                     else
                     {
-                        m_InternalCurrentRotation = Interpolate ? m_RotationInterpolator.GetInterpolatedValue() : GetSpaceRelativeRotation();
+                        if (CanCommitToTransform)
+                        {
+                            m_InternalCurrentRotation = GetSpaceRelativeRotation();
+                        }
+                        else
+                        {
+                            m_InternalCurrentRotation = Interpolate ? m_RotationInterpolator.GetInterpolatedValue() : GetSpaceRelativeRotation();
+                        }
                         m_TargetRotation = m_InternalCurrentRotation.eulerAngles;
                     }
                 }
@@ -4207,7 +4222,7 @@ internal BufferedLinearInterpolatorQuaternion GetRotationInterpolator()
         private void UpdateInterpolation()
         {
             // Select the time system relative to the type of NetworkManager instance.
-            var timeSystem = m_CachedNetworkManager.IsServer ? m_CachedNetworkManager.ServerTime : m_CachedNetworkManager.LocalTime;
+            var timeSystem = m_CachedNetworkManager.IsServer ? m_CachedNetworkManager.LocalTime : m_CachedNetworkManager.ServerTime;
             var currentTime = timeSystem.Time;
 #if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
             var cachedDeltaTime = m_UseRigidbodyForMotion ? m_CachedNetworkManager.RealTimeProvider.FixedDeltaTime : m_CachedNetworkManager.RealTimeProvider.DeltaTime;

Original file line number	Diff line number	Diff line change
`@@ -286,24 +286,24 @@ private void ConvertInterpolateStateValues(Transform parent, bool inLocalSpace)`
`286`	`286`	`}`
`287`	`287`
`288`	`288`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`289`		`- private void ConvertTransformSpace()`
	`289`	`+ private void ConvertTransformSpace(BufferedItem newTarget)`
`290`	`290`	`{`
`291`	`291`	`if (!AutoConvertTransformSpace)`
`292`	`292`	`{`
`293`	`293`	`return;`
`294`	`294`	`}`
`295`		`- if (InterpolateState.TargetParent != Parent)`
	`295`	`+ if (InterpolateState.TargetParent != newTarget.MeasurementParent)`
`296`	`296`	`{`
`297`	`297`	`if (InterpolateState.TargetParent != null)`
`298`	`298`	`{`
`299`	`299`	`// Convert to world space or local space depending upon what our current parent is.`
`300`	`300`	`ConvertInterpolateStateValues(InterpolateState.TargetParent, false);`
`301`	`301`	`}`
`302`	`302`
`303`		`- if (Parent != null)`
	`303`	`+ if (newTarget.MeasurementParent != null)`
`304`	`304`	`{`
`305`	`305`	`// Convert to local space.`
`306`		`- ConvertInterpolateStateValues(Parent, true);`
	`306`	`+ ConvertInterpolateStateValues(newTarget.MeasurementParent, true);`
`307`	`307`	`}`
`308`	`308`	`}`
`309`	`309`	`}`
`@@ -366,7 +366,7 @@ private void TryConsumeFromBuffer(double renderTime, double minDeltaTime, double`
`366`	`366`	`{`
`367`	`367`	`if (m_BufferQueue.TryDequeue(out BufferedItem target))`
`368`	`368`	`{`
`369`		`- ConvertTransformSpace();`
	`369`	`+ ConvertTransformSpace(target);`
`370`	`370`
`371`	`371`	`if (!InterpolateState.Target.HasValue)`
`372`	`372`	`{`
`@@ -516,7 +516,7 @@ private void TryConsumeFromBuffer(double renderTime, double serverTime)`
`516`	`516`	`{`
`517`	`517`	`if (m_BufferQueue.TryDequeue(out BufferedItem target))`
`518`	`518`	`{`
`519`		`- ConvertTransformSpace();`
	`519`	`+ ConvertTransformSpace(target);`
`520`	`520`	`if (!InterpolateState.Target.HasValue)`
`521`	`521`	`{`
`522`	`522`	`InterpolateState.Target = target;`
`@@ -679,6 +679,29 @@ internal void AddMeasurement(Transform parent, T newMeasurement, double sentTime`
`679`	`679`	`}`
`680`	`680`	`}`
`681`	`681`
	`682`	`+ [MethodImpl(MethodImplOptions.AggressiveInlining)]`
	`683`	`+ private T GetParentRelativeValue(T currentValue)`
	`684`	`+ {`
	`685`	`+ if (!AutoConvertTransformSpace \|\| InterpolateState.TargetParent == Parent)`
	`686`	`+ {`
	`687`	`+ return currentValue;`
	`688`	`+ }`
	`689`	`+`
	`690`	`+ // Just convert on the fly until the next state is reached where it will do a full`
	`691`	`+ // conversion when popped from the queue.`
	`692`	`+ if (InterpolateState.TargetParent)`
	`693`	`+ {`
	`694`	`+ currentValue = OnConvertTransformSpace(InterpolateState.TargetParent, currentValue, false);`
	`695`	`+ }`
	`696`	`+`
	`697`	`+ if (Parent != null)`
	`698`	`+ {`
	`699`	`+ var previousCurrent = currentValue.ToString();`
	`700`	`+ currentValue = OnConvertTransformSpace(Parent, currentValue, true);`
	`701`	`+ }`
	`702`	`+ return currentValue;`
	`703`	`+ }`
	`704`	`+`
`682`	`705`	`/// <summary>`
`683`	`706`	`/// Gets latest value from the interpolator. This is updated every update as time goes by.`
`684`	`707`	`/// </summary>`
`@@ -689,16 +712,17 @@ public T GetInterpolatedValue()`
`689`	`712`	`var currentValue = InterpolateState.CurrentValue;`
`690`	`713`	`if (AutoConvertTransformSpace && InterpolateState.TargetParent != Parent)`
`691`	`714`	`{`
`692`		`- // Just convert on the fly until the next state is reached where it will do a full`
`693`		`- // conversion when popped from the queue.`
`694`		`- if (InterpolateState.TargetParent != null)`
`695`		`- {`
`696`		`- currentValue = OnConvertTransformSpace(InterpolateState.TargetParent, currentValue, false);`
`697`		`- }`
	`715`	`+ currentValue = GetParentRelativeValue(currentValue);`
`698`	`716`
`699`		`- if (Parent != null)`
	`717`	`+ // When there are no more states and we have reached our target,`
	`718`	`+ // hijack the last state as if it was submitted by the current`
	`719`	`+ // parent.`
	`720`	`+ if (m_BufferQueue.Count == 0 && (InterpolateState.TargetReached \|\| !InterpolateState.Target.HasValue))`
`700`	`721`	`{`
`701`		`- currentValue = OnConvertTransformSpace(Parent, currentValue, true);`
	`722`	`+ InterpolateState.CurrentValue = currentValue;`
	`723`	`+ InterpolateState.NextValue = currentValue;`
	`724`	`+ InterpolateState.PreviousValue = currentValue;`
	`725`	`+ InterpolateState.TargetParent = Parent;`
`702`	`726`	`}`
`703`	`727`	`}`
`704`	`728`	`return currentValue;`
Original file line number	Diff line number	Diff line change
`@@ -1526,12 +1526,12 @@ internal bool SynchronizeScale`
`1526`	`1526`	`/// <summary>`
`1527`	`1527`	`/// Returns true if position is currently in local space and false if it is in world space.`
`1528`	`1528`	`/// </summary>`
`1529`		`- protected bool PositionInLocalSpace => (!SwitchTransformSpaceWhenParented && InLocalSpace) \|\| (m_PositionInterpolator != null && m_PositionInterpolator.InLocalSpace && SwitchTransformSpaceWhenParented);`
	`1529`	`+ protected bool PositionInLocalSpace => InLocalSpace;`
`1530`	`1530`
`1531`	`1531`	`/// <summary>`
`1532`	`1532`	`/// Returns true if rotation is currently in local space and false if it is in world space.`
`1533`	`1533`	`/// </summary>`
`1534`		`- protected bool RotationInLocalSpace => (!SwitchTransformSpaceWhenParented && InLocalSpace) \|\| (m_RotationInterpolator != null && m_RotationInterpolator.InLocalSpace && SwitchTransformSpaceWhenParented);`
	`1534`	`+ protected bool RotationInLocalSpace => InLocalSpace;`
`1535`	`1535`
`1536`	`1536`	`/// <summary>`
`1537`	`1537`	`/// When enabled (default) interpolation is applied.`
`@@ -3146,10 +3146,12 @@ internal void ApplyUpdatedState(NetworkTransformState newState)`
`3146`	`3146`	`// depending upon whether UsePositionDeltaCompression is enabled`
`3147`	`3147`	`if (m_LocalAuthoritativeNetworkState.HasPositionChange)`
`3148`	`3148`	`{`
	`3149`	`+ // If interpolating, get the current value as the final next position or current position`
	`3150`	`+ // depending upon if the interpolator is still processing a state or not.`
	`3151`	`+ var newTargetPosition = Interpolate ? m_PositionInterpolator.GetInterpolatedValue() : m_TargetPosition;`
`3149`	`3152`	`if (!m_LocalAuthoritativeNetworkState.UseHalfFloatPrecision)`
`3150`	`3153`	`{`
`3151`	`3154`	`var position = m_LocalAuthoritativeNetworkState.GetPosition();`
`3152`		`- var newTargetPosition = m_TargetPosition;`
`3153`	`3155`	`if (m_LocalAuthoritativeNetworkState.HasPositionX)`
`3154`	`3156`	`{`
`3155`	`3157`	`newTargetPosition.x = position.x;`
`@@ -3164,8 +3166,8 @@ internal void ApplyUpdatedState(NetworkTransformState newState)`
`3164`	`3166`	`{`
`3165`	`3167`	`newTargetPosition.z = position.z;`
`3166`	`3168`	`}`
`3167`		`- m_TargetPosition = newTargetPosition;`
`3168`	`3169`	`}`
	`3170`	`+ m_TargetPosition = newTargetPosition;`
`3169`	`3171`	`UpdatePositionInterpolator(m_TargetPosition, sentTime);`
`3170`	`3172`	`}`
`3171`	`3173`
`@@ -3900,7 +3902,6 @@ internal override void InternalOnNetworkObjectParentChanged(NetworkObject parent`
`3900`	`3902`	`m_PositionInterpolator.AutoConvertTransformSpace = SwitchTransformSpaceWhenParented;`
`3901`	`3903`	`m_PositionInterpolator.InLocalSpace = InLocalSpace;`
`3902`	`3904`	`m_PositionInterpolator.Parent = InLocalSpace ? parentNetworkObject.transform : null;`
`3903`		`- var parentName = InLocalSpace ? parentNetworkObject.name : "root";`
`3904`	`3905`
`3905`	`3906`	`if (LastTickSync == m_LocalAuthoritativeNetworkState.GetNetworkTick())`
`3906`	`3907`	`{`
`@@ -3917,7 +3918,14 @@ internal override void InternalOnNetworkObjectParentChanged(NetworkObject parent`
`3917`	`3918`	`}`
`3918`	`3919`	`else`
`3919`	`3920`	`{`
`3920`		`- m_InternalCurrentPosition = m_TargetPosition = Interpolate ? m_PositionInterpolator.GetInterpolatedValue() : GetSpaceRelativePosition();`
	`3921`	`+ if (CanCommitToTransform)`
	`3922`	`+ {`
	`3923`	`+ m_InternalCurrentPosition = GetSpaceRelativePosition();`
	`3924`	`+ }`
	`3925`	`+ else`
	`3926`	`+ {`
	`3927`	`+ m_InternalCurrentPosition = m_TargetPosition = Interpolate ? m_PositionInterpolator.GetInterpolatedValue() : GetSpaceRelativePosition();`
	`3928`	`+ }`
`3921`	`3929`	`}`
`3922`	`3930`	`}`
`3923`	`3931`
`@@ -3942,7 +3950,14 @@ internal override void InternalOnNetworkObjectParentChanged(NetworkObject parent`
`3942`	`3950`	`}`
`3943`	`3951`	`else`
`3944`	`3952`	`{`
`3945`		`- m_InternalCurrentRotation = Interpolate ? m_RotationInterpolator.GetInterpolatedValue() : GetSpaceRelativeRotation();`
	`3953`	`+ if (CanCommitToTransform)`
	`3954`	`+ {`
	`3955`	`+ m_InternalCurrentRotation = GetSpaceRelativeRotation();`
	`3956`	`+ }`
	`3957`	`+ else`
	`3958`	`+ {`
	`3959`	`+ m_InternalCurrentRotation = Interpolate ? m_RotationInterpolator.GetInterpolatedValue() : GetSpaceRelativeRotation();`
	`3960`	`+ }`
`3946`	`3961`	`m_TargetRotation = m_InternalCurrentRotation.eulerAngles;`
`3947`	`3962`	`}`
`3948`	`3963`	`}`
`@@ -4207,7 +4222,7 @@ internal BufferedLinearInterpolatorQuaternion GetRotationInterpolator()`
`4207`	`4222`	`private void UpdateInterpolation()`
`4208`	`4223`	`{`
`4209`	`4224`	`// Select the time system relative to the type of NetworkManager instance.`
`4210`		`- var timeSystem = m_CachedNetworkManager.IsServer ? m_CachedNetworkManager.ServerTime : m_CachedNetworkManager.LocalTime;`
	`4225`	`+ var timeSystem = m_CachedNetworkManager.IsServer ? m_CachedNetworkManager.LocalTime : m_CachedNetworkManager.ServerTime;`
`4211`	`4226`	`var currentTime = timeSystem.Time;`
`4212`	`4227`	`#if COM_UNITY_MODULES_PHYSICS \|\| COM_UNITY_MODULES_PHYSICS2D`
`4213`	`4228`	`var cachedDeltaTime = m_UseRigidbodyForMotion ? m_CachedNetworkManager.RealTimeProvider.FixedDeltaTime : m_CachedNetworkManager.RealTimeProvider.DeltaTime;`