NetworkTransform.cs

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Text;
using Unity.Mathematics;
using Unity.Netcode.Runtime;
using UnityEngine;

namespace Unity.Netcode.Components
{
    /// <summary>
    /// A component for syncing transforms.
    /// NetworkTransform will read the underlying transform and replicate it to clients.
    /// The replicated value will be automatically be interpolated (if active) and applied to the underlying GameObject's transform.
    /// </summary>
    [DisallowMultipleComponent]
    [AddComponentMenu("Netcode/Network Transform")]
    [HelpURL(HelpUrls.NetworkTransform)]
    public class NetworkTransform : NetworkBehaviour
    {
#if UNITY_EDITOR
        internal virtual bool HideInterpolateValue => false;

        [HideInInspector]
        [SerializeField]
        internal bool NetworkTransformExpanded;
#endif

        #region NETWORK TRANSFORM STATE
        /// <summary>
        /// Data structure used to synchronize the <see cref="NetworkTransform"/>
        /// </summary>
        public struct NetworkTransformState : INetworkSerializable
        {
            // Persists between state updates (authority dictates if this is set)
            private const int k_InLocalSpaceBit = 0x00000001;
            private const int k_PositionXBit = 0x00000002;
            private const int k_PositionYBit = 0x00000004;
            private const int k_PositionZBit = 0x00000008;
            private const int k_RotAngleXBit = 0x00000010;
            private const int k_RotAngleYBit = 0x00000020;
            private const int k_RotAngleZBit = 0x00000040;
            private const int k_ScaleXBit = 0x00000080;
            private const int k_ScaleYBit = 0x00000100;
            private const int k_ScaleZBit = 0x00000200;
            private const int k_TeleportingBit = 0x00000400;
            // Persists between state updates (authority dictates if this is set)
            private const int k_Interpolate = 0x00000800;
            // Persists between state updates (authority dictates if this is set)
            private const int k_QuaternionSync = 0x00001000;
            // Persists between state updates (authority dictates if this is set)
            private const int k_QuaternionCompress = 0x00002000;
            // Persists between state updates (authority dictates if this is set)
            private const int k_UseHalfFloats = 0x00004000;
            private const int k_Synchronization = 0x00008000;
            // Persists between state updates (authority dictates if this is set)
            private const int k_PositionSlerp = 0x00010000;
            // When parented and synchronizing, we need to have both lossy and local scale due to varying spawn order
            private const int k_IsParented = 0x00020000;
            private const int k_SynchBaseHalfFloat = 0x00040000;
            private const int k_ReliableSequenced = 0x00080000;
            private const int k_UseUnreliableDeltas = 0x00100000;
            private const int k_UnreliableFrameSync = 0x00200000;
            // (Internal Debugging) When set each state update will contain a state identifier
            private const int k_TrackStateId = 0x10000000;

            // Stores persistent and state relative flags
            private uint m_Bitset;
            internal uint BitSet
            {
                get { return m_Bitset; }
                set { m_Bitset = value; }
            }

            // Used to store the tick calculated sent time
            internal double SentTime;

            // Used for full precision position updates
            internal float PositionX, PositionY, PositionZ;

            // Used for full precision Euler updates
            internal float RotAngleX, RotAngleY, RotAngleZ;

            // Used for full precision quaternion updates
            internal Quaternion Rotation;

            // Used for full precision scale updates
            internal float ScaleX, ScaleY, ScaleZ;

            // Used for half precision delta position updates
            internal Vector3 CurrentPosition;
            internal Vector3 DeltaPosition;
            internal NetworkDeltaPosition NetworkDeltaPosition;

            // Used for half precision scale
            internal HalfVector3 HalfVectorScale;
            internal Vector3 Scale;
            internal Vector3 LossyScale;

            // Used for half precision quaternion
            internal HalfVector4 HalfVectorRotation;

            // Used to store a compressed quaternion
            internal uint QuaternionCompressed;

            // Authoritative and non-authoritative sides use this to determine if a NetworkTransformState is
            // dirty or not.
            internal bool IsDirty { get; set; }

            /// <summary>
            /// The last byte size of the <see cref="NetworkTransformState"/> updated.
            /// </summary>
            public int LastSerializedSize { get; internal set; }

            // Used for NetworkDeltaPosition delta position synchronization
            internal int NetworkTick;

            // Used when tracking by state ID is enabled
            internal int StateId;

            // Set when a state has been explicitly set (i.e. SetState)
            internal bool ExplicitSet;

            // Used during serialization
            private FastBufferReader m_Reader;
            private FastBufferWriter m_Writer;

            /// <summary>
            /// When set, the <see cref="NetworkTransform"/> is operates in local space
            /// </summary>
            public bool InLocalSpace
            {
                get => GetFlag(k_InLocalSpaceBit);
                internal set
                {
                    SetFlag(value, k_InLocalSpaceBit);
                }
            }

            // Position
            /// <summary>
            /// When set, the X-Axis position value has changed
            /// </summary>
            public bool HasPositionX
            {
                get => GetFlag(k_PositionXBit);
                internal set
                {
                    SetFlag(value, k_PositionXBit);
                }
            }

            /// <summary>
            /// When set, the Y-Axis position value has changed
            /// </summary>
            public bool HasPositionY
            {
                get => GetFlag(k_PositionYBit);
                internal set
                {
                    SetFlag(value, k_PositionYBit);
                }
            }

            /// <summary>
            /// When set, the Z-Axis position value has changed
            /// </summary>
            public bool HasPositionZ
            {
                get => GetFlag(k_PositionZBit);
                internal set
                {
                    SetFlag(value, k_PositionZBit);
                }
            }

            /// <summary>
            /// When set, at least one of the position axis values has changed.
            /// </summary>
            public bool HasPositionChange
            {
                get
                {
                    return HasPositionX || HasPositionY || HasPositionZ;
                }
            }

            // RotAngles
            /// <summary>
            /// When set, the Euler rotation X-Axis value has changed.
            /// </summary>
            /// <remarks>
            /// When quaternion synchronization is enabled all axis are always updated.
            /// </remarks>
            public bool HasRotAngleX
            {
                get => GetFlag(k_RotAngleXBit);
                internal set
                {
                    SetFlag(value, k_RotAngleXBit);
                }
            }

            /// <summary>
            /// When set, the Euler rotation Y-Axis value has changed.
            /// </summary>
            /// <remarks>
            /// When quaternion synchronization is enabled all axis are always updated.
            /// </remarks>
            public bool HasRotAngleY
            {
                get => GetFlag(k_RotAngleYBit);
                internal set
                {
                    SetFlag(value, k_RotAngleYBit);
                }
            }

            /// <summary>
            /// When set, the Euler rotation Z-Axis value has changed.
            /// </summary>
            /// <remarks>
            /// When quaternion synchronization is enabled all axis are always updated.
            /// </remarks>
            public bool HasRotAngleZ
            {
                get => GetFlag(k_RotAngleZBit);
                internal set
                {
                    SetFlag(value, k_RotAngleZBit);
                }
            }

            /// <summary>
            /// When set, at least one of the rotation axis values has changed.
            /// </summary>
            /// <remarks>
            /// When quaternion synchronization is enabled all axis are always updated.
            /// </remarks>
            public bool HasRotAngleChange
            {
                get
                {
                    return HasRotAngleX || HasRotAngleY || HasRotAngleZ;
                }
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal bool HasScale(int axisIndex)
            {
                return GetFlag(k_ScaleXBit << axisIndex);
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            internal void SetHasScale(int axisIndex, bool isSet)
            {
                SetFlag(isSet, k_ScaleXBit << axisIndex);
            }

            // Scale
            /// <summary>
            /// When set, the X-Axis scale value has changed.
            /// </summary>
            public bool HasScaleX
            {
                get => GetFlag(k_ScaleXBit);
                internal set
                {
                    SetFlag(value, k_ScaleXBit);
                }
            }

            /// <summary>
            /// When set, the Y-Axis scale value has changed.
            /// </summary>
            public bool HasScaleY
            {
                get => GetFlag(k_ScaleYBit);
                internal set
                {
                    SetFlag(value, k_ScaleYBit);
                }
            }

            /// <summary>
            /// When set, the Z-Axis scale value has changed.
            /// </summary>
            public bool HasScaleZ
            {
                get => GetFlag(k_ScaleZBit);
                internal set
                {
                    SetFlag(value, k_ScaleZBit);
                }
            }

            /// <summary>
            /// When set, at least one of the scale axis values has changed.
            /// </summary>
            public bool HasScaleChange
            {
                get
                {
                    return HasScaleX || HasScaleY || HasScaleZ;
                }
            }

            /// <summary>
            /// When set, the current state will be treated as a teleport.
            /// </summary>
            /// <remarks>
            /// When teleporting:
            /// - Interpolation is reset.
            /// - If using half precision, full precision values are used.
            /// - All axis marked to be synchronized will be updated.
            /// </remarks>
            public bool IsTeleportingNextFrame
            {
                get => GetFlag(k_TeleportingBit);
                internal set
                {
                    SetFlag(value, k_TeleportingBit);
                }
            }

            /// <summary>
            /// When set the <see cref="NetworkTransform"/> is uses interpolation.
            /// </summary>
            /// <remarks>
            /// Authority does not apply interpolation via <see cref="NetworkTransform"/>.
            /// Authority should handle its own motion/rotation/scale smoothing locally.
            /// </remarks>
            public bool UseInterpolation
            {
                get => GetFlag(k_Interpolate);
                internal set
                {
                    SetFlag(value, k_Interpolate);
                }
            }

            /// <summary>
            /// When enabled, this <see cref="NetworkTransform"/> instance uses <see cref="Quaternion"/> synchronization.
            /// </summary>
            /// <remarks>
            /// Use quaternion synchronization if you are nesting <see cref="NetworkTransform"/>s and rotation can occur on both the parent and child.
            /// When quaternion synchronization is enabled, the entire quaternion is updated when there are any changes to any axial values.
            /// You can use half float precision or quaternion compression to reduce the bandwidth cost.
            /// </remarks>
            public bool QuaternionSync
            {
                get => GetFlag(k_QuaternionSync);
                internal set
                {
                    SetFlag(value, k_QuaternionSync);
                }
            }

            /// <summary>
            /// When set <see cref="Quaternion"/>s will be compressed down to 4 bytes using a smallest three implementation.
            /// </summary>
            /// <remarks>
            /// This only will be applied when <see cref="QuaternionSync"/> is enabled.
            /// Half float precision provides a higher precision than quaternion compression but at the cost of 4 additional bytes per update.
            /// - Quaternion Compression: 4 bytes per delta update
            /// - Half float precision: 8 bytes per delta update
            /// </remarks>
            public bool QuaternionCompression
            {
                get => GetFlag(k_QuaternionCompress);
                internal set
                {
                    SetFlag(value, k_QuaternionCompress);
                }
            }

            /// <summary>
            /// When set, the <see cref="NetworkTransform"/> will use half float precision for position, rotation, and scale.
            /// </summary>
            /// <remarks>
            /// Postion is synchronized through delta position updates in order to reduce precision loss/drift and to extend to positions beyond the limitation of half float maximum values.
            /// Rotation and scale both use half float precision (<see cref="HalfVector4"/> and <see cref="HalfVector3"/>)
            /// </remarks>
            public bool UseHalfFloatPrecision
            {
                get => GetFlag(k_UseHalfFloats);
                internal set
                {
                    SetFlag(value, k_UseHalfFloats);
                }
            }

            /// <summary>
            /// When set, this indicates it is the first state being synchronized.
            /// Typically when the associate <see cref="NetworkObject"/> is spawned or a client is being synchronized after connecting to a network session in progress.
            /// </summary>
            public bool IsSynchronizing
            {
                get => GetFlag(k_Synchronization);
                internal set
                {
                    SetFlag(value, k_Synchronization);
                }
            }

            /// <summary>
            /// Determines if position interpolation will Slerp towards its target position.
            /// This is only really useful if you are moving around a point in a circular pattern.
            /// </summary>
            public bool UsePositionSlerp
            {
                get => GetFlag(k_PositionSlerp);
                internal set
                {
                    SetFlag(value, k_PositionSlerp);
                }
            }

            /// <summary>
            /// Returns whether this state update was a frame synchronization when
            /// UseUnreliableDeltas is enabled. When set, the entire transform will
            /// be or has been synchronized.
            /// </summary>
            /// <returns>true or false as to whether this state update was an unreliable frame synchronization.</returns>
            public bool IsUnreliableFrameSync()
            {
                return UnreliableFrameSync;
            }

            /// <summary>
            /// Returns true if this state was sent with reliable delivery.
            /// If false, then it was sent with unreliable delivery.
            /// </summary>
            /// <remarks>
            /// Unreliable delivery will only be used if <see cref="UseUnreliableDeltas"/> is set.
            /// </remarks>
            /// <returns>true or false as to whether this state update was sent with reliable delivery.</returns>
            public bool IsReliableStateUpdate()
            {
                return ReliableSequenced;
            }

            internal bool IsParented
            {
                get => GetFlag(k_IsParented);
                set
                {
                    SetFlag(value, k_IsParented);
                }
            }

            internal bool SynchronizeBaseHalfFloat
            {
                get => GetFlag(k_SynchBaseHalfFloat);
                set
                {
                    SetFlag(value, k_SynchBaseHalfFloat);
                }
            }

            internal bool ReliableSequenced
            {
                get => GetFlag(k_ReliableSequenced);
                set
                {
                    SetFlag(value, k_ReliableSequenced);
                }
            }

            internal bool UseUnreliableDeltas
            {
                get => GetFlag(k_UseUnreliableDeltas);
                set
                {
                    SetFlag(value, k_UseUnreliableDeltas);
                }
            }

            internal bool UnreliableFrameSync
            {
                get => GetFlag(k_UnreliableFrameSync);
                set
                {
                    SetFlag(value, k_UnreliableFrameSync);
                }
            }

            internal bool TrackByStateId
            {
                get => GetFlag(k_TrackStateId);
                set
                {
                    SetFlag(value, k_TrackStateId);
                }
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            private bool GetFlag(int flag)
            {
                return (m_Bitset & flag) != 0;
            }

            [MethodImpl(MethodImplOptions.AggressiveInlining)]
            private void SetFlag(bool set, int flag)
            {
                if (set) { m_Bitset = m_Bitset | (uint)flag; }
                else { m_Bitset = m_Bitset & (uint)~flag; }
            }

            internal void ClearBitSetForNextTick()
            {
                // Clear everything but flags that should persist between state updates until changed by authority
                m_Bitset &= k_InLocalSpaceBit | k_Interpolate | k_UseHalfFloats | k_QuaternionSync | k_QuaternionCompress | k_PositionSlerp | k_UseUnreliableDeltas;
                IsDirty = false;
            }

            /// <summary>
            /// Returns the current state's rotation. If there is no change in the rotation,
            /// then it will return <see cref="Quaternion.identity"/>.
            /// </summary>
            /// <remarks>
            /// When there is no change in an updated state's rotation then there are no values to return.
            /// Checking for <see cref="HasRotAngleChange"/> is one way to detect this.
            /// </remarks>
            /// <returns><see cref="Quaternion"/></returns>
            public Quaternion GetRotation()
            {
                if (HasRotAngleChange)
                {
                    if (QuaternionSync)
                    {
                        return Rotation;
                    }
                    else
                    {
                        return Quaternion.Euler(RotAngleX, RotAngleY, RotAngleZ);
                    }
                }
                return Quaternion.identity;
            }

            /// <summary>
            /// Returns the current state's position. If there is no change in position,
            /// then it returns <see cref="Vector3.zero"/>.
            /// </summary>
            /// <remarks>
            /// When there is no change in an updated state's position then there are no values to return.
            /// Checking for <see cref="HasPositionChange"/> is one way to detect this.
            /// When used with half precision it returns the half precision delta position state update
            /// which will not be the full position.
            /// To get a NettworkTransform's full position, use <see cref="GetSpaceRelativePosition(bool)"/> and
            /// pass true as the parameter.
            /// </remarks>
            /// <returns><see cref="Vector3"/></returns>
            public Vector3 GetPosition()
            {
                if (HasPositionChange)
                {
                    if (UseHalfFloatPrecision)
                    {
                        if (IsTeleportingNextFrame)
                        {
                            return CurrentPosition;
                        }
                        else
                        {
                            return NetworkDeltaPosition.GetFullPosition();
                        }
                    }
                    else
                    {
                        return new Vector3(PositionX, PositionY, PositionZ);
                    }
                }
                return Vector3.zero;
            }

            /// <summary>
            /// Returns the current state's scale. If there is no change in scale,
            /// then it returns <see cref="Vector3.zero"/>.
            /// </summary>
            /// <remarks>
            /// When there is no change in an updated state's scale then there are no values to return.
            /// Checking for <see cref="HasScaleChange"/> is one way to detect this.
            /// </remarks>
            /// <returns><see cref="Vector3"/></returns>
            public Vector3 GetScale()
            {
                if (HasScaleChange)
                {
                    if (UseHalfFloatPrecision)
                    {
                        if (IsTeleportingNextFrame)
                        {
                            return Scale;
                        }
                        else
                        {
                            return HalfVectorScale.ToVector3();
                        }
                    }
                    else
                    {
                        return new Vector3(ScaleX, ScaleY, ScaleZ);
                    }
                }
                return Vector3.zero;
            }

            /// <summary>
            /// The network tick that this state was sent by the authoritative instance.
            /// </summary>
            /// <returns><see cref="int"/></returns>
            public int GetNetworkTick()
            {
                return NetworkTick;
            }

            internal HalfVector3 HalfEulerRotation;

            /// <inheritdoc />
            public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
            {
                // Used to calculate the LastSerializedSize value
                var positionStart = 0;
                var isWriting = serializer.IsWriter;
                if (isWriting)
                {
                    m_Writer = serializer.GetFastBufferWriter();
                    positionStart = m_Writer.Position;
                }
                else
                {
                    m_Reader = serializer.GetFastBufferReader();
                    positionStart = m_Reader.Position;
                }

                // Synchronize State Flags and Network Tick
                {
                    if (isWriting)
                    {
                        if (UseUnreliableDeltas)
                        {
                            // If teleporting, synchronizing, doing an axial frame sync, or using half float precision and we collapsed a delta into the base position
                            if (IsTeleportingNextFrame || IsSynchronizing || UnreliableFrameSync || (UseHalfFloatPrecision && NetworkDeltaPosition.CollapsedDeltaIntoBase))
                            {
                                // Send the message reliably
                                ReliableSequenced = true;
                            }
                            else
                            {
                                ReliableSequenced = false;
                            }
                        }
                        else // If not using UseUnreliableDeltas, then always use reliable fragmented sequenced
                        {
                            ReliableSequenced = true;
                        }

                        BytePacker.WriteValueBitPacked(m_Writer, m_Bitset);
                        // We use network ticks as opposed to absolute time as the authoritative
                        // side updates on every new tick.
                        BytePacker.WriteValueBitPacked(m_Writer, NetworkTick);
                    }
                    else
                    {
                        ByteUnpacker.ReadValueBitPacked(m_Reader, out m_Bitset);
                        // We use network ticks as opposed to absolute time as the authoritative
                        // side updates on every new tick.
                        ByteUnpacker.ReadValueBitPacked(m_Reader, out NetworkTick);
                    }
                }

                // If debugging states and track by state identifier is enabled, serialize the current state identifier
                if (TrackByStateId)
                {
                    serializer.SerializeValue(ref StateId);
                }

                // Synchronize Position
                if (HasPositionChange)
                {
                    if (UseHalfFloatPrecision)
                    {
                        NetworkDeltaPosition.SynchronizeBase = SynchronizeBaseHalfFloat;

                        // Apply which axis should be updated for both write/read (teleporting, synchronizing, or just updating)
                        NetworkDeltaPosition.HalfVector3.AxisToSynchronize[0] = HasPositionX;
                        NetworkDeltaPosition.HalfVector3.AxisToSynchronize[1] = HasPositionY;
                        NetworkDeltaPosition.HalfVector3.AxisToSynchronize[2] = HasPositionZ;

                        if (IsTeleportingNextFrame)
                        {
                            // **Always use full precision when teleporting and UseHalfFloatPrecision is enabled**
                            serializer.SerializeValue(ref CurrentPosition);
                            // If we are synchronizing, then include the half vector position's delta offset
                            if (IsSynchronizing)
                            {
                                serializer.SerializeValue(ref DeltaPosition);
                                if (!isWriting)
                                {
                                    NetworkDeltaPosition.NetworkTick = NetworkTick;
                                    NetworkDeltaPosition.NetworkSerialize(serializer);
                                }
                                else
                                {
                                    serializer.SerializeNetworkSerializable(ref NetworkDeltaPosition);
                                }
                            }
                        }
                        else
                        {
                            if (!isWriting)
                            {
                                NetworkDeltaPosition.NetworkTick = NetworkTick;
                                NetworkDeltaPosition.NetworkSerialize(serializer);
                            }
                            else
                            {
                                serializer.SerializeNetworkSerializable(ref NetworkDeltaPosition);
                            }
                        }
                    }
                    else // Full precision axis specific position synchronization
                    {
                        if (HasPositionX)
                        {
                            serializer.SerializeValue(ref PositionX);
                        }

                        if (HasPositionY)
                        {
                            serializer.SerializeValue(ref PositionY);
                        }

                        if (HasPositionZ)
                        {
                            serializer.SerializeValue(ref PositionZ);
                        }
                    }
                }

                // Synchronize Rotation
                if (HasRotAngleChange)
                {
                    if (QuaternionSync)
                    {
                        // Always use the full quaternion if teleporting
                        if (IsTeleportingNextFrame)
                        {
                            serializer.SerializeValue(ref Rotation);
                        }
                        else
                        {
                            // Use the quaternion compressor if enabled
                            if (QuaternionCompression)
                            {
                                if (isWriting)
                                {
                                    QuaternionCompressed = QuaternionCompressor.CompressQuaternion(ref Rotation);
                                }

                                serializer.SerializeValue(ref QuaternionCompressed);

                                if (!isWriting)
                                {
                                    QuaternionCompressor.DecompressQuaternion(ref Rotation, QuaternionCompressed);
                                }
                            }
                            else
                            {
                                if (UseHalfFloatPrecision)
                                {
                                    if (isWriting)
                                    {
                                        HalfVectorRotation.UpdateFrom(ref Rotation);
                                    }

                                    serializer.SerializeNetworkSerializable(ref HalfVectorRotation);

                                    if (!isWriting)
                                    {
                                        Rotation = HalfVectorRotation.ToQuaternion();
                                    }
                                }
                                else
                                {
                                    serializer.SerializeValue(ref Rotation);
                                }
                            }
                        }
                    }
                    else // Euler Rotation Synchronization
                    {
                        // Half float precision (full precision when teleporting)
                        if (UseHalfFloatPrecision && !IsTeleportingNextFrame)
                        {
                            if (HasRotAngleChange)
                            {
                                // Apply which axis should be updated for both write/read
                                HalfEulerRotation.AxisToSynchronize[0] = HasRotAngleX;
                                HalfEulerRotation.AxisToSynchronize[1] = HasRotAngleY;
                                HalfEulerRotation.AxisToSynchronize[2] = HasRotAngleZ;

                                if (isWriting)
                                {
                                    HalfEulerRotation.Set(RotAngleX, RotAngleY, RotAngleZ);
                                }

                                serializer.SerializeValue(ref HalfEulerRotation);

                                if (!isWriting)
                                {
                                    var eulerRotation = HalfEulerRotation.ToVector3();
                                    if (HasRotAngleX)
                                    {
                                        RotAngleX = eulerRotation.x;
                                    }

                                    if (HasRotAngleY)
                                    {
                                        RotAngleY = eulerRotation.y;
                                    }

                                    if (HasRotAngleZ)
                                    {
                                        RotAngleZ = eulerRotation.z;
                                    }
                                }
                            }
                        }
                        else // Full precision Euler
                        {
                            // RotAngle Values
                            if (HasRotAngleX)
                            {
                                serializer.SerializeValue(ref RotAngleX);
                            }

                            if (HasRotAngleY)
                            {
                                serializer.SerializeValue(ref RotAngleY);
                            }

                            if (HasRotAngleZ)
                            {
                                serializer.SerializeValue(ref RotAngleZ);
                            }
                        }
                    }
                }

                // Synchronize Scale
                if (HasScaleChange)
                {
                    // If we are teleporting (which includes synchronizing) and the associated NetworkObject has a parent
                    // then we want to serialize the LossyScale since NetworkObject spawn order is not guaranteed
                    if (IsTeleportingNextFrame && IsParented)
                    {
                        serializer.SerializeValue(ref LossyScale);
                    }
                    // Half precision scale synchronization
                    if (UseHalfFloatPrecision)
                    {
                        if (IsTeleportingNextFrame)
                        {
                            serializer.SerializeValue(ref Scale);
                        }
                        else
                        {
                            // Apply which axis should be updated for both write/read
                            HalfVectorScale.AxisToSynchronize[0] = HasScaleX;
                            HalfVectorScale.AxisToSynchronize[1] = HasScaleY;
                            HalfVectorScale.AxisToSynchronize[2] = HasScaleZ;

                            // For scale, when half precision is enabled we can still only send the axis with deltas
                            if (isWriting)
                            {
                                HalfVectorScale.Set(Scale[0], Scale[1], Scale[2]);
                            }

                            serializer.SerializeValue(ref HalfVectorScale);

                            if (!isWriting)
                            {
                                Scale = HalfVectorScale.ToVector3();
                                if (HasScaleX)
                                {
                                    ScaleX = Scale.x;
                                }

                                if (HasScaleY)
                                {
                                    ScaleY = Scale.y;
                                }

                                if (HasScaleZ)
                                {
                                    ScaleZ = Scale.x;
                                }
                            }
                        }
                    }
                    else // Full precision scale synchronization
                    {
                        if (HasScaleX)
                        {
                            serializer.SerializeValue(ref ScaleX);
                        }

                        if (HasScaleY)
                        {
                            serializer.SerializeValue(ref ScaleY);
                        }

                        if (HasScaleZ)
                        {
                            serializer.SerializeValue(ref ScaleZ);
                        }
                    }
                }

                // Only if we are receiving state
                if (!isWriting)
                {
                    // Go ahead and mark the local state dirty
                    IsDirty = HasPositionChange || HasRotAngleChange || HasScaleChange;
                    LastSerializedSize = m_Reader.Position - positionStart;
                }
                else
                {
                    LastSerializedSize = m_Writer.Position - positionStart;
                }
            }
        }
        #endregion

        #region PROPERTIES AND GENERAL METHODS

        /// <summary>
        /// Used on the authority side only.
        /// This is the current network tick and is set within <see cref="NetworkManager.NetworkUpdate(NetworkUpdateStage)"/>.
        /// </summary>
        internal static int CurrentTick;

        /// <summary>
        /// Pertains to Owner Authority and Interpolation<br />
        /// When enabled (default), 1 additional tick is added to the total number of ticks used to calculate the tick latency ("ticks ago") as a time.
        /// This calculated time value is passed into the respective <see cref="BufferedLinearInterpolator{T}"/> and used to determine if any pending
        /// state updates in the queue should be processed.
        /// The additional tick value is only applied when:
        /// <list type="bullet">
        /// <item><description>The <see cref="NetworkTransform"/> is using a <see cref="AuthorityModes.Owner"/> authority mode.</description></item>
        /// <item><description>The non-authority instance is a client (i.e. not host or server).</description></item>
        /// <item><description>The network topology being used is <see cref="NetworkTopologyTypes.ClientServer"/>.</description></item>
        /// </list>
        /// </summary>
        /// <remarks>
        /// When calculating the total tick latency as time value, the <see cref="NetworkTimeSystem.TickLatency"/> is added to the <see cref="InterpolationBufferTickOffset"/>
        /// and if this property is enabled (and the conditions above are met) an additional tick is added to the final resultant value. <br />
        /// Note: The reason behind this additional tick latency value is due to the 2 RTT timespan when a client state update is sent to the host or server (1 RTT)
        /// and the host or server relays this state update to all non-authority instances (1 RTT).
        /// </remarks>
        public bool AutoOwnerAuthorityTickOffset = true;

        /// <summary>
        /// The different interpolation types used with <see cref="BufferedLinearInterpolator{T}"/> to help smooth interpolation results.
        /// Interpolation types can be changed during runtime.
        /// </summary>
        public enum InterpolationTypes
        {
            /// <summary>
            /// Legacy Lerp (original NGO lerping model)<br />
            /// Uses a 1 to 2 phase lerp approach where:<br />
            /// <list type="bullet">
            /// <item><description>The first phase lerps from the previous state update value to the next state update value.</description></item>
            /// <item><description>The second phase (optional) performs lerp smoothing where the current respective transform value is lerped towards the result of the first phase at a rate of delta time divided by the respective max interpolation time.</description></item>
            /// </list>
            /// !!! NOTE !!!<br />
            /// The legacy lerp interpolation type does not use <see cref="NetworkTimeSystem.TickLatency"/> to determine the buffer depth. This is to preserve the same interpolation results when lerp smoothing is enabled.<br />
            /// </summary>
            /// <remarks>
            /// For more information:<br />
            /// <list type="bullet">
            /// <item><term><see cref="PositionMaxInterpolationTime"/></term></item>
            /// <item><term><see cref="PositionLerpSmoothing"/></term></item>
            /// <item><term><see cref="RotationMaxInterpolationTime"/></term></item>
            /// <item><term><see cref="RotationLerpSmoothing"/></term></item>
            /// <item><term><see cref="ScaleMaxInterpolationTime"/></term></item>
            /// <item><term><see cref="ScaleLerpSmoothing"/></term></item>
            /// </list>
            /// </remarks>
            LegacyLerp,
            /// <summary>
            /// Lerp (maintains time to target when <see cref="InterpolationBufferTickOffset"/> under higher <see cref="NetworkTimeSystem.TickLatency"/> conditions) <br />
            /// Uses a 1 to 2 phase interpolation approach where:<br />
            /// <list type="bullet">
            /// <item><description>The first phase lerps from the previous state update value to the next state update value.</description></item>
            /// <item><description>The second phase (optional) performs lerp smoothing where the current respective transform value is lerped towards the result of the first phase at a rate of 1.0 minus the respective maximum interpolation time.</description></item>
            /// </list>
            /// </summary>
            /// <remarks>
            /// For more information:<br />
            /// <list type="bullet">
            /// <item><term><see cref="PositionMaxInterpolationTime"/></term></item>
            /// <item><term><see cref="PositionLerpSmoothing"/></term></item>
            /// <item><term><see cref="RotationMaxInterpolationTime"/></term></item>
            /// <item><term><see cref="RotationLerpSmoothing"/></term></item>
            /// <item><term><see cref="ScaleMaxInterpolationTime"/></term></item>
            /// <item><term><see cref="ScaleLerpSmoothing"/></term></item>
            /// </list>
            /// </remarks>
            Lerp,
            /// <summary>
            /// Smooth Dampening (maintains time to target when <see cref="InterpolationBufferTickOffset"/> under higher <see cref="NetworkTimeSystem.TickLatency"/> conditions) <br />
            /// Uses a 1 to 2 phase smooth dampening approach where:<br />
            /// <list type="bullet">
            /// <item><description>The first phase smooth dampens towards the current tick state update being processed by the accumulated delta time relative to the time to target.</description></item>
            /// <item><description>The second phase (optional) performs lerp smoothing where the current respective transform value is lerped towards the result of the first phase at a rate of delta time divided by the respective max interpolation time.</description></item>
            /// </list>
            /// </summary>
            /// <remarks>
            /// Note: Smooth dampening is computationally more expensive than the <see cref="Lerp"/> and <see cref="LegacyLerp"/> approaches.<br />
            /// It is recommended to turn lerp smoothing off or adjust the maximum interpolation time to a lower value if you want a more precise end result.
            /// For more information:<br />
            /// <list type="bullet">
            /// <item><term><see cref="PositionMaxInterpolationTime"/></term></item>
            /// <item><term><see cref="PositionLerpSmoothing"/></term></item>
            /// <item><term><see cref="RotationMaxInterpolationTime"/></term></item>
            /// <item><term><see cref="RotationLerpSmoothing"/></term></item>
            /// <item><term><see cref="ScaleMaxInterpolationTime"/></term></item>
            /// <item><term><see cref="ScaleLerpSmoothing"/></term></item>
            /// </list>
            /// </remarks>
            SmoothDampening
        }

        /// <summary>
        /// The position interpolation type to use for the <see cref="NetworkTransform"/> instance.
        /// </summary>
        /// <remarks>
        /// <list type="bullet">
        /// <item><term><see cref="InterpolationTypes.LegacyLerp"/></term><description>Yields the original Netcode for GameObjects lerp result.</description></item>
        /// <item><term><see cref="InterpolationTypes.Lerp"/></term><description>Uses the newer linear buffer queue consumption approach that maintains a consistent time to the next target.</description></item>
        /// <item><term><see cref="InterpolationTypes.SmoothDampening"/></term><description>Uses the newer linear buffer queue consumption approach and adjusts based on the rate of change.</description></item>
        /// </list>
        /// Things to consider:<br />
        /// <list type="bullet">
        /// <item><description>You can have mixed interpolation types between position, rotation, and scale on the same <see cref="NetworkTransform"/> instance.</description></item>
        /// <item><description>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.</description></item>
        /// </list>
        /// </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;
        private InterpolationTypes m_PreviousPositionInterpolationType;

        /// <summary>
        /// The rotation interpolation type to use for the <see cref="NetworkTransform"/> instance.
        /// </summary>
        /// <remarks>
        /// <list type="bullet">
        /// <item><term><see cref="InterpolationTypes.LegacyLerp"/></term><description>Yields the original Netcode for GameObjects lerp result.</description></item>
        /// <item><term><see cref="InterpolationTypes.Lerp"/></term><description>Uses the newer linear buffer queue consumption approach that maintains a consistent time to the next target.</description></item>
        /// <item><term><see cref="InterpolationTypes.SmoothDampening"/></term><description>Uses the newer linear buffer queue consumption approach and adjusts based on the rate of change.</description></item>
        /// </list>
        /// Things to consider:<br />
        /// <list type="bullet">
        /// <item><description>You can have mixed interpolation types between position, rotation, and scale on the same <see cref="NetworkTransform"/> instance.</description></item>
        /// <item><description>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.</description></item>
        /// </list>
        /// </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;
        private InterpolationTypes m_PreviousRotationInterpolationType;

        /// <summary>
        /// The scale interpolation type to use for the <see cref="NetworkTransform"/> instance.
        /// </summary>
        /// <remarks>
        /// <list type="bullet">
        /// <item><term><see cref="InterpolationTypes.LegacyLerp"/></term><description>Yields the original Netcode for GameObjects lerp result.</description></item>
        /// <item><term><see cref="InterpolationTypes.Lerp"/></term><description>Uses the newer linear buffer queue consumption approach that maintains a consistent time to the next target.</description></item>
        /// <item><term><see cref="InterpolationTypes.SmoothDampening"/></term><description>Uses the newer linear buffer queue consumption approach and adjusts based on the rate of change.</description></item>
        /// </list>
        /// Things to consider:<br />
        /// <list type="bullet">
        /// <item><description>You can have mixed interpolation types between position, rotation, and scale on the same <see cref="NetworkTransform"/> instance.</description></item>
        /// <item><description>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.</description></item>
        /// </list>
        /// </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;
        private InterpolationTypes m_PreviousScaleInterpolationType;

        /// <summary>
        /// Controls position interpolation smoothing.
        /// </summary>
        /// <remarks>
        /// When enabled, the <see cref="BufferedLinearInterpolator{T}"/> will apply a final lerping pass where the "t" parameter is calculated by dividing the frame time divided by the <see cref="PositionMaxInterpolationTime"/>.
        /// </remarks>
        public bool PositionLerpSmoothing = true;
        private bool m_PreviousPositionLerpSmoothing;

        /// <summary>
        /// The position interoplation maximum interpolation time.<br />
        /// <list type="bullet">
        /// <item><description>The higher the value the smoother, but can result in lost data points (i.e. quick changes in direct).</description></item>
        /// <item><description>The lower the value the more accurate/precise, but can result in slight stutter (i.e. due to jitter, latency, or a high threshold value).</description></item>
        /// <item><description>This value can be adjusted during runtime in the event you want to dynamically adjust it based on some other value (i.e. linear velocity or the like).</description></item>
        /// </list>
        /// </summary>
        [Tooltip("The higher the value the smoother, but can result in lost data points (i.e. quick changes in direct). The lower 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>
        /// Controls rotation interpolation smoothing.
        /// </summary>
        /// <remarks>
        /// When enabled, the <see cref="BufferedLinearInterpolator{T}"/> will apply a final lerping pass where the "t" parameter is calculated by dividing the frame time divided by the <see cref="RotationMaxInterpolationTime"/>.
        /// </remarks>
        public bool RotationLerpSmoothing = true;
        private bool m_PreviousRotationLerpSmoothing;

        /// <summary>
        /// The rotation interoplation maximum interpolation time.<br />
        /// <list type="bullet">
        /// <item><description>The higher the value the smoother, but can result in lost data points (i.e. quick changes in direct).</description></item>
        /// <item><description>The lower the value the more accurate/precise, but can result in slight stutter (i.e. due to jitter, latency, or a high threshold value).</description></item>
        /// <item><description>This value can be adjusted during runtime in the event you want to dynamically adjust it based on some other value (i.e. angular velocity).</description></item>
        /// </list>
        /// </summary>
        [Tooltip("The higher the value the smoother, but can result in lost data points (i.e. quick changes in direct). The lower 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>
        /// Controls scale interpolation smoothing.
        /// </summary>
        /// <remarks>
        /// When enabled, the <see cref="BufferedLinearInterpolator{T}"/> will apply a final lerping pass where the "t" parameter is calculated by dividing the frame time divided by the <see cref="ScaleMaxInterpolationTime"/>.
        /// </remarks>
        public bool ScaleLerpSmoothing = true;
        private bool m_PreviousScaleLerpSmoothing;

        /// <summary>
        /// The scale interoplation maximum interpolation time.<br />
        /// <list type="bullet">
        /// <item><description>The higher the value the smoother, but can result in lost data points (i.e. quick changes in direct).</description></item>
        /// <item><description>The lower the value the more accurate/precise, but can result in slight stutter (i.e. due to jitter, latency, or a high threshold value).</description></item>
        /// <item><description>This value can be adjusted during runtime in the event you want to dynamically adjust it based on some other value.</description></item>
        /// </list>
        /// </summary>
        [Tooltip("The higher the value the smoother, but can result in lost data points (i.e. quick changes in direct). The lower 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;

        /// <summary>
        /// Determines if the server or client owner pushes transform states.
        /// </summary>
        public enum AuthorityModes
        {
            /// <summary>
            /// Server pushes transform state updates.
            /// </summary>
            Server,
            /// <summary>
            /// Client owner pushes transform state updates.
            /// </summary>
            Owner,
        }

        /// <summary>
        /// Determines whether this <see cref="NetworkTransform"/> instance will have state updates pushed by the server or the client owner.
        /// <see cref="AuthorityModes"/>
        /// </summary>
#if MULTIPLAYER_SERVICES_SDK_INSTALLED
        [Tooltip("Selects who has authority (sends state updates) over the transform. When the network topology is set to distributed authority, this always defaults to owner authority. If server (the default), then only server-side adjustments to the " +
            "transform will be synchronized with clients. If owner (or client), then only the owner-side adjustments to the transform will be synchronized with both the server and other clients.")]
#else
        [Tooltip("Selects who has authority (sends state updates) over the transform. If server (the default), then only server-side adjustments to the transform will be synchronized with clients. If owner (or client), " +
            "then only the owner-side adjustments to the transform will be synchronized with both the server and other clients.")]
#endif
        public AuthorityModes AuthorityMode;

        /// <summary>
        /// When enabled, any parented <see cref="NetworkObject"/>s (children) of this <see cref="NetworkObject"/> will be forced to synchronize their transform when this <see cref="NetworkObject"/> instance sends a state update.<br />
        /// This can help to reduce out of sync updates that can lead to slight jitter between a parent and its child/children.
        /// </summary>
        /// <remarks>
        /// <list type="bullet">
        /// <item><description>If this is set on a child and the parent does not have this set then the child will not be tick synchronized with its parent.</description></item>
        /// <item><description>If the parent instance does not send any state updates, the children will still send state updates when exceeding axis delta threshold.</description></item>
        /// <item><description>This does not need to be set on children to be applied.</description></item>
        /// </list>
        /// </remarks>
        [Tooltip("When enabled, any parented children of this instance will send a state update when this instance sends a state update. If this instance doesn't send a state update, the children will still send state updates when reaching their axis specified threshold delta. Children do not have to have this setting enabled.")]
        public bool TickSyncChildren = false;

        /// <summary>
        /// The default position change threshold value.<br />
        /// Any changes above this threshold will be replicated.
        /// </summary>
        public const float PositionThresholdDefault = 0.001f;

        /// <summary>
        /// The default rotation angle change threshold value.<br />
        /// Any changes above this threshold will be replicated.
        /// </summary>
        public const float RotAngleThresholdDefault = 0.01f;

        /// <summary>
        /// The default scale change threshold value.<br />
        /// Any changes above this threshold will be replicated.
        /// </summary>
        public const float ScaleThresholdDefault = 0.01f;

        /// <summary>
        /// The handler delegate type that takes client requested changes and returns resulting changes handled by the server.
        /// </summary>
        /// <param name="pos">The position requested by the client.</param>
        /// <param name="rot">The rotation requested by the client.</param>
        /// <param name="scale">The scale requested by the client.</param>
        /// <returns>The resulting position, rotation and scale changes after handling.</returns>
        public delegate (Vector3 pos, Quaternion rotOut, Vector3 scale) OnClientRequestChangeDelegate(Vector3 pos, Quaternion rot, Vector3 scale);

        /// <summary>
        /// The handler that gets invoked when server receives a change from a client.
        /// This handler would be useful for server to modify pos/rot/scale before applying client's request.
        /// </summary>
        public OnClientRequestChangeDelegate OnClientRequestChange;

        /// <summary>
        /// When set each state update will contain a state identifier
        /// </summary>
        internal static bool TrackByStateId = false;

        /// <summary>
        /// Enabled by default.
        /// When set (enabled by default), NetworkTransform will send common state updates using unreliable network delivery
        /// to provide a higher tolerance to poor network conditions (especially packet loss). When disabled, all state updates
        /// are sent using a reliable fragmented sequenced network delivery.
        /// </summary>
        /// <remarks>
        /// The following more critical state updates are still sent as reliable fragmented sequenced:<br />
        /// <list type="bullet">
        /// <item><description>The initial synchronization state update.</description></item>
        /// <item><description>The teleporting state update.</description></item>
        /// <item><description>When using half float precision and the `NetworkDeltaPosition` delta exceeds the maximum delta forcing the axis in
        /// question to be collapsed into the core base position, this state update will be sent as reliable fragmented sequenced.</description></item>
        /// </list>
        /// In order to preserve a continual consistency of axial values when unreliable delta messaging is enabled (due to the
        /// possibility of dropping packets), NetworkTransform instances will send 1 axial frame synchronization update per
        /// second (only for the axis marked to synchronize are sent as reliable fragmented sequenced) as long as a delta state
        /// update had been previously sent. When a NetworkObject is at rest, axial frame synchronization updates are not sent.
        /// </remarks>
        [Tooltip("When set, NetworkTransform will send common state updates using unreliable network delivery " +
            "to provide a higher tolerance to poor network conditions (especially packet loss). When disabled, all state updates are " +
            "sent using reliable fragmented sequenced network delivery.")]
        public bool UseUnreliableDeltas = false;

        /// <summary>
        /// When enabled (default), the x component of position will be synchronized by authority.
        /// </summary>
        /// <remarks>
        /// Changes to this on non-authoritative instances has no effect.
        /// </remarks>
        public bool SyncPositionX = true;

        /// <summary>
        /// When enabled (default), the y component of position will be synchronized by authority.
        /// </summary>
        /// <remarks>
        /// Changes to this on non-authoritative instances has no effect.
        /// </remarks>
        public bool SyncPositionY = true;

        /// <summary>
        /// When enabled (default), the z component of position will be synchronized by authority.
        /// </summary>
        /// <remarks>
        /// Changes to this on non-authoritative instances has no effect.
        /// </remarks>
        public bool SyncPositionZ = true;

        internal bool SynchronizePosition
        {
            get
            {
                return SyncPositionX || SyncPositionY || SyncPositionZ;
            }
        }

        /// <summary>
        /// When enabled (default), the x component of rotation will be synchronized by authority.
        /// </summary>
        /// <remarks>
        /// When <see cref="UseQuaternionSynchronization"/> is enabled this does not apply.
        /// Changes to this on non-authoritative instances has no effect.
        /// </remarks>
        public bool SyncRotAngleX = true;

        /// <summary>
        /// When enabled (default), the y component of rotation will be synchronized by authority.
        /// </summary>
        /// <remarks>
        /// When <see cref="UseQuaternionSynchronization"/> is enabled this does not apply.
        /// Changes to this on non-authoritative instances has no effect.
        /// </remarks>
        public bool SyncRotAngleY = true;

        /// <summary>
        /// When enabled (default), the z component of rotation will be synchronized by authority.
        /// </summary>
        /// <remarks>
        /// When <see cref="UseQuaternionSynchronization"/> is enabled this does not apply.
        /// Changes to this on non-authoritative instances has no effect.
        /// </remarks>
        public bool SyncRotAngleZ = true;

        internal bool SynchronizeRotation
        {
            get
            {
                return SyncRotAngleX || SyncRotAngleY || SyncRotAngleZ;
            }
        }

        /// <summary>
        /// When enabled (default), the x component of scale will be synchronized by authority.
        /// </summary>
        /// <remarks>
        /// Changes to this on non-authoritative instances has no effect.
        /// </remarks>
        public bool SyncScaleX = true;

        /// <summary>
        /// When enabled (default), the y component of scale will be synchronized by authority.
        /// </summary>
        /// <remarks>
        /// Changes to this on non-authoritative instances has no effect.
        /// </remarks>
        public bool SyncScaleY = true;

        /// <summary>
        /// When enabled (default), the z component of scale will be synchronized by authority.
        /// </summary>
        /// <remarks>
        /// Changes to this on non-authoritative instances has no effect.
        /// </remarks>
        public bool SyncScaleZ = true;

        internal bool SynchronizeScale
        {
            get
            {
                return SyncScaleX || SyncScaleY || SyncScaleZ;
            }
        }

        /// <summary>
        /// The position threshold value that triggers a delta state update by the authoritative instance.
        /// </summary>
        /// <remarks>
        /// Note: setting this to zero will update position every network tick whether it changed or not.
        /// </remarks>
        public float PositionThreshold = PositionThresholdDefault;

        /// <summary>
        /// The rotation threshold value that triggers a delta state update by the authoritative instance.
        /// </summary>
        /// <remarks>
        /// <list type="bullet">
        /// <item>
        /// <term>Minimum Value</term>
        /// <description>0.00001</description>
        /// </item>
        /// <item>
        /// <term>Maximum Value</term>
        /// <description>360.0</description>
        /// </item>
        /// </list>
        /// </remarks>
        [Range(0.00001f, 360.0f)]
        public float RotAngleThreshold = RotAngleThresholdDefault;

        /// <summary>
        /// The scale threshold value that triggers a delta state update by the authoritative instance.
        /// </summary>
        /// <remarks>
        /// Note: setting this to zero will update position every network tick whether it changed or not.
        /// </remarks>
        public float ScaleThreshold = ScaleThresholdDefault;

        /// <summary>
        /// Enable this on the authority side for quaternion synchronization.
        /// </summary>
        /// <remarks>
        /// This is synchronized by authority. During runtime, this should only be changed by the
        /// authoritative side. Non-authoritative instances will be overridden by the next
        /// authoritative state update.
        /// </remarks>
        [Tooltip("When enabled, this will synchronize the full Quaternion (i.e. all Euler rotation axis are updated if one axis has a delta)")]
        public bool UseQuaternionSynchronization = false;

        /// <summary>
        /// Enabled this on the authority side for quaternion compression
        /// </summary>
        /// <remarks>
        /// This has a lower precision than half float precision. Recommended only for low precision
        /// scenarios. <see cref="UseHalfFloatPrecision"/> provides better precision at roughly half
        /// the cost of a full quaternion update.<br />
        /// This is synchronized by authority. During runtime, this should only be changed by the
        /// authoritative side. Non-authoritative instances will be overridden by the next
        /// authoritative state update.
        /// </remarks>
        [Tooltip("When enabled, this uses a smallest three implementation that reduces full Quaternion updates down to the size of an unsigned integer (ignores half float precision settings).")]
        public bool UseQuaternionCompression = false;

        /// <summary>
        /// Enable this to use half float precision for position, rotation, and scale.<br />
        /// When enabled, delta position synchronization is used.
        /// </summary>
        /// <remarks>
        /// This is synchronized by authority. During runtime, this should only be changed by the
        /// authoritative side. Non-authoritative instances will be overridden by the next
        /// authoritative state update.
        /// </remarks>
        [Tooltip("When enabled, this will use half float precision values for position (uses delta position updating), rotation (except when Quaternion compression is enabled), and scale.")]
        public bool UseHalfFloatPrecision = false;

        /// <summary>
        /// Sets whether the transform should be treated as local (true) or world (false) space.
        /// </summary>
        /// <remarks>
        /// This is synchronized by authority. During runtime, this should only be changed by the
        /// authoritative side. Non-authoritative instances will be overridden by the next
        /// authoritative state update.
        /// </remarks>
        [Tooltip("Sets whether this transform should sync in local space or in world space")]
        public bool InLocalSpace = false;

        /// <summary>
        /// When enabled, the NetworkTransform will automatically handle transitioning into the respective transform space when its <see cref="NetworkObject"/> parent changes.<br />
        /// When parented: Automatically transitions into local space and coverts any existing pending interpolated states to local space on non-authority instances.<br />
        /// When deparented: Automatically transitions into world space and converts any existing pending interpolated states to world space on non-authority instances.<br />
        /// Set on the root <see cref="NetworkTransform"/> instance (nested <see cref="NetworkTransform"/> components should be pre-set in-editor to local space. <br />
        /// </summary>
        /// <remarks>
        /// Only works with <see cref="NetworkTransform"/> components that are not paired with a <see cref="NetworkRigidbody"/> or <see cref="NetworkRigidbody2D"/> component that is configured to use the rigid body for motion.<br />
        /// <see cref="TickSyncChildren"/> will automatically be set when this is enabled.
        /// Does not auto-synchronize clients if changed on the authority instance during runtime (i.e. apply this setting in-editor).
        /// </remarks>
        public bool SwitchTransformSpaceWhenParented = false;

        /// <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);

        /// <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);

        /// <summary>
        /// When enabled (default) interpolation is applied.
        /// When disabled interpolation is disabled.
        /// </summary>
        /// <remarks>
        /// This is synchronized by authority and changes to interpolation during runtime forces a
        /// teleport/full update. During runtime, this should only be changed by the authoritative
        /// side. Non-authoritative instances will be overridden by the next authoritative state update.
        /// </remarks>
        public bool Interpolate = true;

        /// <summary>
        /// When true and interpolation is enabled, this will Slerp to the target position.
        /// </summary>
        /// <remarks>
        /// This is synchronized by authority and only applies to position interpolation.
        /// During runtime, this should only be changed by the authoritative side. Non-authoritative
        /// instances will be overridden by the next authoritative state update.
        /// </remarks>
        [Tooltip("When enabled the position interpolator will Slerp towards its current target position.")]
        public bool SlerpPosition = false;

        /// <summary>
        /// Used to determine who can write to this transform. Server only for this transform.
        /// Changing this value alone in a child implementation will not allow you to create a NetworkTransform which can be written to by clients. See the ClientNetworkTransform Sample
        /// in the package samples for how to implement a NetworkTransform with client write support.
        /// If using different values, please use RPCs to write to the server. Netcode doesn't support client side network variable writing
        /// </summary>
        public bool CanCommitToTransform { get; protected set; }

        /// <summary>
        /// Internally used by <see cref="NetworkTransform"/> to keep track of the <see cref="NetworkManager"/> instance assigned to this
        /// this <see cref="NetworkBehaviour"/> derived class instance.
        /// </summary>
        protected NetworkManager m_CachedNetworkManager;

        /// <summary>
        /// Helper method that returns the space relative position of the transform.
        /// </summary>
        /// <remarks>
        /// <list type="bullet">
        /// <item><description>If InLocalSpace is <see cref="true"/> then it returns the transform.localPosition.</description></item>
        /// <item><description>If InLocalSpace is <see cref="false"/> then it returns the transform.position.</description></item>
        /// </list>
        /// <list type="bullet">
        /// <item>
        /// <term>When invoked on the non-authority side:</term>
        /// <description>If <see cref="getCurrentState"/> is true then it will return the most
        /// current authority position from the most recent state update. This can be useful
        /// if interpolation is enabled and you need to determine the final target position.
        /// </description></item>
        /// <item>
        /// <term>When invoked on the authority side:</term>
        /// <description>It will always return the space relative position.
        /// </description></item>
        /// </list>
        /// </remarks>
        /// <param name="getCurrentState">
        /// Authority always returns the space relative transform position (whether true or false).<br />
        /// Non-authority:<br />
        /// When false (default): returns the space relative transform position.<br />
        /// When true: returns the authority position from the most recent state update.
        /// </param>
        /// <returns><see cref="Vector3"/></returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Vector3 GetSpaceRelativePosition(bool getCurrentState = false)
        {
            if (!getCurrentState || CanCommitToTransform)
            {
                return InLocalSpace ? transform.localPosition : transform.position;
            }
            else
            {
                // When half float precision is enabled, get the NetworkDeltaPosition's full position
                if (UseHalfFloatPrecision)
                {
                    return m_HalfPositionState.GetFullPosition();
                }
                else
                {
                    // Otherwise, just get the current position
                    return m_InternalCurrentPosition;
                }
            }
        }

        /// <summary>
        /// Helper method that returns the space relative rotation of the transform.
        /// </summary>
        /// <remarks>
        /// <list type="bullet">
        /// <item><description>If InLocalSpace is <see cref="true"/> then it returns the transform.localRotation.</description></item>
        /// <item><description>If InLocalSpace is <see cref="false"/> then it returns the transform.rotation.</description></item>
        /// </list>
        /// <list type="bullet">
        /// <item>
        /// <term>When invoked on the non-authority side:</term>
        /// <description>If <see cref="getCurrentState"/> is true then it will return the most
        /// current authority position from the most recent state update. This can be useful
        /// if interpolation is enabled and you need to determine the final target rotation.
        /// </description></item>
        /// <item>
        /// <term>When invoked on the authority side:</term>
        /// <description>It will always return the space relative rotation.
        /// </description></item>
        /// </list>
        /// </remarks>
        /// <param name="getCurrentState">
        /// Authority always returns the space relative transform rotation (whether true or false).<br />
        /// Non-authority:<br />
        /// When false (default): returns the space relative transform rotation.<br />
        /// When true: returns the authority rotation from the most recent state update.
        /// </param>
        /// <returns><see cref="Quaternion"/></returns>
        public Quaternion GetSpaceRelativeRotation(bool getCurrentState = false)
        {
            if (!getCurrentState || CanCommitToTransform)
            {
                return InLocalSpace ? transform.localRotation : transform.rotation;
            }
            else
            {
                return m_InternalCurrentRotation;
            }
        }

        /// <summary>
        /// Helper method that returns the scale of the transform.
        /// </summary>
        /// <remarks>
        /// When invoked on the non-authority side:<br />
        /// If <see cref="getCurrentState"/> is true then it will return the most
        /// current authority scale from the most recent state update. This can be useful
        /// if interpolation is enabled and you need to determine the final target scale.<br />
        /// When invoked on the authority side:<br />
        /// It will always return the space relative scale.
        /// </remarks>
        /// <param name="getCurrentState">
        /// Authority always returns the space relative transform scale (whether true or false).<br />
        /// Non-authority:<br />
        /// When false (default): returns the space relative transform scale.<br />
        /// When true: returns the authority scale from the most recent state update.
        /// </param>
        /// <returns><see cref="Vector3"/></returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Vector3 GetScale(bool getCurrentState = false)
        {
            if (!getCurrentState || CanCommitToTransform)
            {
                return transform.localScale;
            }
            else
            {
                return m_InternalCurrentScale;
            }
        }

        // Used by both authoritative and non-authoritative instances.
        // This represents the most recent local authoritative state.
        private NetworkTransformState m_LocalAuthoritativeNetworkState;

        internal NetworkTransformState LocalAuthoritativeNetworkState
        {
            get
            {
                return m_LocalAuthoritativeNetworkState;
            }
            set
            {
                m_LocalAuthoritativeNetworkState = value;
            }
        }

        private ClientRpcParams m_ClientRpcParams = new ClientRpcParams() { Send = new ClientRpcSendParams() };
        private List<ulong> m_ClientIds = new List<ulong>() { 0 };

        private BufferedLinearInterpolatorVector3 m_PositionInterpolator;
        private BufferedLinearInterpolatorVector3 m_ScaleInterpolator;
        // rotation is a single Quaternion since each Euler axis will affect the quaternion's final value
        private BufferedLinearInterpolatorQuaternion m_RotationInterpolator;

        // The previous network state
        private NetworkTransformState m_OldState = new NetworkTransformState();

        // Non-Authoritative's current position, scale, and rotation that is used to assure the non-authoritative side cannot make adjustments to
        // the portions of the transform being synchronized.
        private Vector3 m_InternalCurrentPosition;
        private Vector3 m_TargetPosition;
        private Vector3 m_InternalCurrentScale;
        private Vector3 m_TargetScale;
        private Quaternion m_InternalCurrentRotation;
        private Vector3 m_TargetRotation;

#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
        private bool m_UseRigidbodyForMotion;
        private NetworkRigidbodyBase m_NetworkRigidbodyInternal;

        internal void RegisterRigidbody(NetworkRigidbodyBase networkRigidbody)
        {
            if (networkRigidbody != null)
            {
                m_NetworkRigidbodyInternal = networkRigidbody;
                m_UseRigidbodyForMotion = m_NetworkRigidbodyInternal.UseRigidBodyForMotion;
            }
        }
#endif

#if DEBUG_NETWORKTRANSFORM || UNITY_INCLUDE_TESTS
        /// <summary>
        /// For debugging delta position and half vector3
        /// </summary>
        protected delegate void AddLogEntryHandler(ref NetworkTransformState networkTransformState, ulong targetClient, bool preUpdate = false);
        protected AddLogEntryHandler m_AddLogEntry;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void AddLogEntry(ref NetworkTransformState networkTransformState, ulong targetClient, bool preUpdate = false)
        {
            m_AddLogEntry?.Invoke(ref networkTransformState, targetClient, preUpdate);
        }


        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        protected int GetStateId(ref NetworkTransformState state)
        {
            return state.StateId;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        protected NetworkDeltaPosition GetHalfPositionState()
        {
            return m_HalfPositionState;
        }

#else
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void AddLogEntry(ref NetworkTransformState networkTransformState, ulong targetClient, bool preUpdate = false)
        {
        }
#endif

        /// <summary>
        /// Only used when UseHalfFloatPrecision is enabled
        /// </summary>
        private NetworkDeltaPosition m_HalfPositionState = new NetworkDeltaPosition(Vector3.zero, 0);

        internal void UpdatePositionSlerp()
        {
            if (m_PositionInterpolator != null)
            {
                m_PositionInterpolator.IsSlerp = SlerpPosition;
            }
        }

        /// <summary>
        /// Determines if synchronization is needed.
        /// Basically only if we are running in owner authoritative mode and it
        /// is the owner being synchronized we don't want to synchronize with
        /// the exception of the NetworkObject being owned by the server.
        /// </summary>
        private bool ShouldSynchronizeHalfFloat(ulong targetClientId)
        {
            if (!IsServerAuthoritative() && NetworkObject.OwnerClientId == targetClientId)
            {
                // In distributed authority mode we want to synchronize the half float if we are the owner.
                return (!NetworkManager.DistributedAuthorityMode && NetworkObject.IsOwnedByServer) || (NetworkManager.DistributedAuthorityMode);
            }
            return true;
        }

        // For test logging purposes
        internal NetworkTransformState SynchronizeState;

        #endregion

        #region ONSYNCHRONIZE

        /// <inheritdoc />
        /// <remarks>
        /// This is invoked when a new client joins (server and client sides).
        /// Server Side: Serializes as if we were teleporting (everything is sent via NetworkTransformState).
        /// Client Side: Adds the interpolated state which applies the NetworkTransformState as well.
        /// </remarks>
        protected override void OnSynchronize<T>(ref BufferSerializer<T> serializer)
        {
            var targetClientId = m_TargetIdBeingSynchronized;
            SynchronizeState = new NetworkTransformState()
            {
                HalfEulerRotation = new HalfVector3(),
                HalfVectorRotation = new HalfVector4(),
                HalfVectorScale = new HalfVector3(),
                NetworkDeltaPosition = new NetworkDeltaPosition(),
            };

            if (serializer.IsWriter)
            {
                SynchronizeState.IsTeleportingNextFrame = true;
                var transformToCommit = transform;
                // If we are using Half Float Precision, then we want to only synchronize the authority's m_HalfPositionState.FullPosition in order for
                // for the non-authority side to be able to properly synchronize delta position updates.
                CheckForStateChange(ref SynchronizeState, ref transformToCommit, true, targetClientId);
                SynchronizeState.NetworkSerialize(serializer);
            }
            else
            {
                SynchronizeState.NetworkSerialize(serializer);
            }
        }

        /// <summary>
        /// We now apply synchronization after everything has spawned
        /// </summary>
        private void ApplySynchronization()
        {
            // Set the transform's synchronization modes
            InLocalSpace = SynchronizeState.InLocalSpace;
            Interpolate = SynchronizeState.UseInterpolation;
            UseQuaternionSynchronization = SynchronizeState.QuaternionSync;
            UseHalfFloatPrecision = SynchronizeState.UseHalfFloatPrecision;
            UseQuaternionCompression = SynchronizeState.QuaternionCompression;
            SlerpPosition = SynchronizeState.UsePositionSlerp;
            UpdatePositionSlerp();
            // Teleport/Fully Initialize based on the state
            ApplyTeleportingState(SynchronizeState);
            m_LocalAuthoritativeNetworkState = SynchronizeState;
            m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame = false;
            m_LocalAuthoritativeNetworkState.IsSynchronizing = false;
            SynchronizeState.IsSynchronizing = false;
        }
        #endregion

        #region AUTHORITY STATE UPDATE
        /// <summary>
        /// This will try to send/commit the current transform delta states (if any)
        /// </summary>
        /// <remarks>
        /// Only client owners or the server should invoke this method
        /// </remarks>
        /// <param name="transformToCommit">the transform to be committed</param>
        /// <param name="dirtyTime">time it was marked dirty</param>
        internal void TryCommitTransformToServer(Transform transformToCommit, double dirtyTime)
        {
            if (!IsSpawned)
            {
                NetworkLog.LogError($"Cannot commit transform when not spawned!");
                return;
            }

            // Only the server or the owner is allowed to commit a transform
            if (!IsServer && !IsOwner)
            {
                var errorMessage = gameObject != NetworkObject.gameObject ?
                    $"Non-authority instance of {NetworkObject.gameObject.name} is trying to commit a transform on {gameObject.name}!" :
                    $"Non-authority instance of {NetworkObject.gameObject.name} is trying to commit a transform!";
                NetworkLog.LogError(errorMessage);
                return;
            }

            // If we are authority, update the authoritative state
            if (CanCommitToTransform)
            {
                OnUpdateAuthoritativeState(ref transformToCommit);
            }
            else // Non-Authority
            {
                var position = InLocalSpace ? transformToCommit.localPosition : transformToCommit.position;
                var rotation = InLocalSpace ? transformToCommit.localRotation : transformToCommit.rotation;
                // We are an owner requesting to update our state
                if (!IsServer)
                {
                    SetStateServerRpc(position, rotation, transformToCommit.localScale, false);
                }
                else // Server is always authoritative (including owner authoritative)
                {
                    SetStateClientRpc(position, rotation, transformToCommit.localScale, false);
                }
            }
        }

        /// <summary>
        /// Invoked just prior to being pushed to non-authority instances.
        /// </summary>
        /// <remarks>
        /// This is useful to know the exact position, rotation, or scale values sent
        /// to non-authoritative instances. This is only invoked on the authoritative
        /// instance.
        /// </remarks>
        /// <param name="networkTransformState">the state being pushed</param>
        protected virtual void OnAuthorityPushTransformState(ref NetworkTransformState networkTransformState)
        {
        }

        // Only set if a delta has been sent, this is reset after an axial synch has been sent
        // to assure the instance doesn't continue to send axial synchs when an object is at rest.
        private bool m_DeltaSynch;

        /// <summary>
        /// Authoritative side only
        /// If there are any transform delta states, this method will synchronize the
        /// state with all non-authority instances.
        /// </summary>
        private void TryCommitTransform(ref Transform transformToCommit, bool synchronize = false, bool settingState = false)
        {
            // Only the server or the owner is allowed to commit a transform
            if (!IsServer && !IsOwner)
            {
                NetworkLog.LogError($"[{name}] is trying to commit the transform without authority!");
                return;
            }
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
            // TODO: Make this an authority flag
            // For now, just synchronize with the NetworkRigidbodyBase UseRigidBodyForMotion
            if (m_NetworkRigidbodyInternal != null)
            {
                m_UseRigidbodyForMotion = m_NetworkRigidbodyInternal.UseRigidBodyForMotion;
            }
#endif

            // If the transform has deltas (returns dirty) or if an explicitly set state is pending
            if (m_LocalAuthoritativeNetworkState.ExplicitSet || CheckForStateChange(ref m_LocalAuthoritativeNetworkState, ref transformToCommit, synchronize, forceState: settingState))
            {
                // If the state was explicitly set, then update the network tick to match the locally calculate tick
                if (m_LocalAuthoritativeNetworkState.ExplicitSet)
                {
                    // For explicit set, we use the current ServerTime.Tick and not CurrentTick since this is a SetState specific flow
                    // that is outside of the normal internal tick flow.
                    m_LocalAuthoritativeNetworkState.NetworkTick = m_CachedNetworkManager.NetworkTickSystem.ServerTime.Tick;
                }

                // Send the state update
                UpdateTransformState();

                // Mark the last tick and the old state (for next ticks)
                m_OldState = m_LocalAuthoritativeNetworkState;

                // Reset the teleport and explicit state flags after we have sent the state update.
                // These could be set again in the below OnAuthorityPushTransformState virtual method
                m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame = false;
                m_LocalAuthoritativeNetworkState.ExplicitSet = false;

                try
                {
                    // Notify of the pushed state update
                    OnAuthorityPushTransformState(ref m_LocalAuthoritativeNetworkState);
                }
                catch (Exception ex)
                {
                    Debug.LogException(ex);
                }

                // The below is part of assuring we only send a frame synch, when sending unreliable deltas, if
                // we have already sent at least one unreliable delta state update. At this point in the callstack,
                // a delta state update has just been sent in the above UpdateTransformState() call and as long as
                // we didn't send a frame synch and we are not synchronizing then we know at least one unreliable
                // delta has been sent. Under this scenario, we should start checking for this instance's alloted
                // frame synch "tick slot". Once we send a frame synch, if no other deltas occur after that
                // (i.e. the object is at rest) then we will stop sending frame synch's until the object begins
                // moving, rotating, or scaling again.
                if (UseUnreliableDeltas && !m_LocalAuthoritativeNetworkState.UnreliableFrameSync && !synchronize)
                {
                    m_DeltaSynch = true;
                }

#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
                // We handle updating attached bodies when the "parent" body has a state update in order to keep their delta state updates tick synchronized.
                if (m_UseRigidbodyForMotion && m_NetworkRigidbodyInternal.NetworkRigidbodyConnections.Count > 0)
                {
                    foreach (var childRigidbody in m_NetworkRigidbodyInternal.NetworkRigidbodyConnections)
                    {
                        childRigidbody.NetworkTransform.OnNetworkTick(true);
                    }
                }
#endif
                // When enabled, any children will get tick synchronized with state updates
                if (TickSyncChildren)
                {
                    // Synchronize any nested NetworkTransforms with the parent's
                    foreach (var childNetworkTransform in NetworkObject.NetworkTransforms)
                    {
                        // Don't update the same instance or any nested NetworkTransform with a different authority mode
                        if (childNetworkTransform == this || childNetworkTransform.AuthorityMode != AuthorityMode)
                        {
                            continue;
                        }
                        if (childNetworkTransform.CanCommitToTransform)
                        {
                            childNetworkTransform.OnNetworkTick(true);
                        }
                    }

                    // Synchronize any parented children with the parent's motion
                    foreach (var child in m_ParentedChildren)
                    {
                        // Synchronize any nested NetworkTransforms of the child with the parent's
                        foreach (var childNetworkTransform in child.NetworkTransforms)
                        {
                            if (childNetworkTransform.CanCommitToTransform)
                            {
                                childNetworkTransform.OnNetworkTick(true);
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Used for integration testing:
        /// Will apply the transform to the LocalAuthoritativeNetworkState and get detailed dirty information returned
        /// in the <see cref="NetworkTransformState"/> returned.
        /// </summary>
        /// <param name="transform">transform to apply</param>
        /// <returns>NetworkTransformState</returns>
        internal NetworkTransformState ApplyLocalNetworkState(Transform transform)
        {
            // Since we never commit these changes, we need to simulate that any changes were committed previously and the bitset
            // value would already be reset prior to having the state applied
            m_LocalAuthoritativeNetworkState.ClearBitSetForNextTick();

            // Now check the transform for any threshold value changes
            CheckForStateChange(ref m_LocalAuthoritativeNetworkState, ref transform);

            // Return the entire state to be used by the integration test
            return m_LocalAuthoritativeNetworkState;
        }

        /// <summary>
        /// Used for integration testing
        /// </summary>
        internal bool ApplyTransformToNetworkState(ref NetworkTransformState networkState, double dirtyTime, Transform transformToUse)
        {
            m_CachedNetworkManager = NetworkManager;
            // Apply the interpolate and PostionDeltaCompression flags, otherwise we get false positives whether something changed or not.
            networkState.UseInterpolation = Interpolate;
            networkState.QuaternionSync = UseQuaternionSynchronization;
            networkState.UseHalfFloatPrecision = UseHalfFloatPrecision;
            networkState.QuaternionCompression = UseQuaternionCompression;
            networkState.UseUnreliableDeltas = UseUnreliableDeltas;
            m_HalfPositionState = new NetworkDeltaPosition(Vector3.zero, 0, math.bool3(SyncPositionX, SyncPositionY, SyncPositionZ));

            return CheckForStateChange(ref networkState, ref transformToUse);
        }

        /// <summary>
        /// Applies the transform to the <see cref="NetworkTransformState"/> specified.
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private bool CheckForStateChange(ref NetworkTransformState networkState, ref Transform transformToUse, bool isSynchronization = false, ulong targetClientId = 0, bool forceState = false)
        {
            // As long as we are not doing our first synchronization and we are sending unreliable deltas, each
            // NetworkTransform will stagger its full transfom synchronization over a 1 second period based on the
            // assigned tick slot (m_TickSync).
            // More about m_DeltaSynch:
            // If we have not sent any deltas since our last frame synch, then this will prevent us from sending
            // frame synch's when the object is at rest. If this is false and a state update is detected and sent,
            // then it will be set to true and each subsequent tick will do this check to determine if it should
            // send a full frame synch.
            var isAxisSync = false;
            // We compare against the NetworkTickSystem version since ServerTime is set when updating ticks
            if (UseUnreliableDeltas && !isSynchronization && m_DeltaSynch && m_NextTickSync <= CurrentTick)
            {
                // Increment to the next frame synch tick position for this instance
                m_NextTickSync += (int)m_CachedNetworkManager.NetworkConfig.TickRate;
                // If we are teleporting, we do not need to send a frame synch for this tick slot
                // as a "frame synch" really is effectively just a teleport.
                isAxisSync = !networkState.IsTeleportingNextFrame;
                // Reset our delta synch trigger so we don't send another frame synch until we
                // send at least 1 unreliable state update after this fame synch or teleport
                m_DeltaSynch = false;
            }
            // This is used to determine if we need to send the state update reliably (if we are doing an axial sync)
            networkState.UnreliableFrameSync = isAxisSync;

            var isTeleportingAndNotSynchronizing = networkState.IsTeleportingNextFrame && !isSynchronization;
            var isDirty = false;
            var isPositionDirty = isTeleportingAndNotSynchronizing ? networkState.HasPositionChange : false;
            var isRotationDirty = isTeleportingAndNotSynchronizing ? networkState.HasRotAngleChange : false;
            var isScaleDirty = isTeleportingAndNotSynchronizing ? networkState.HasScaleChange : false;

#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
            var position = m_UseRigidbodyForMotion ? m_NetworkRigidbodyInternal.GetPosition() : InLocalSpace ? transformToUse.localPosition : transformToUse.position;
            var rotation = m_UseRigidbodyForMotion ? m_NetworkRigidbodyInternal.GetRotation() : InLocalSpace ? transformToUse.localRotation : transformToUse.rotation;

            var positionThreshold = Vector3.one * PositionThreshold;
            var rotationThreshold = Vector3.one * RotAngleThreshold;

            // NSS: Disabling this for the time being
            // TODO: Determine if we actually need this and if not remove this from NetworkRigidBodyBase
            //if (m_UseRigidbodyForMotion)
            //{
            //    positionThreshold = m_NetworkRigidbodyInternal.GetAdjustedPositionThreshold();
            //    rotationThreshold = m_NetworkRigidbodyInternal.GetAdjustedRotationThreshold();
            //}
#else
            var position = InLocalSpace ? transformToUse.localPosition : transformToUse.position;
            var rotation = InLocalSpace ? transformToUse.localRotation : transformToUse.rotation;
            var positionThreshold = Vector3.one * PositionThreshold;
            var rotationThreshold = Vector3.one * RotAngleThreshold;
#endif
            var rotAngles = rotation.eulerAngles;
            var scale = transformToUse.localScale;
            networkState.IsSynchronizing = isSynchronization;

            // All of the checks below, up to the delta position checking portion, are to determine if the
            // authority changed a property during runtime that requires a full synchronizing.
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
            if ((InLocalSpace != networkState.InLocalSpace || isSynchronization) && !m_UseRigidbodyForMotion)
#else
            if (InLocalSpace != networkState.InLocalSpace)
#endif
            {
                // When SwitchTransformSpaceWhenParented is set we automatically set our local space based on whether
                // we are parented or not.
                networkState.InLocalSpace = SwitchTransformSpaceWhenParented ? transform.parent != null : InLocalSpace;
                isDirty = true;
                // If SwitchTransformSpaceWhenParented is not set, then we will want to teleport
                networkState.IsTeleportingNextFrame = !SwitchTransformSpaceWhenParented;
                // Otherwise, if SwitchTransformSpaceWhenParented is set we force a full state update.
                // If interpolation is enabled, then any non-authority instance will update any pending
                // buffered values to the correct world or local space values.
                forceState = SwitchTransformSpaceWhenParented;
            }

            // Check for parenting when synchronizing and/or teleporting
            if (isSynchronization || networkState.IsTeleportingNextFrame)
            {
                // This all has to do with complex nested hierarchies and how it impacts scale
                // when set for the first time or teleporting and depends upon whether the
                // NetworkObject is parented (or "de-parented") at the same time any scale
                // values are applied.
                var hasParentNetworkObject = false;

                var parentNetworkObject = (NetworkObject)null;

                // If the NetworkObject belonging to this NetworkTransform instance has a parent
                // (i.e. this handles nested NetworkTransforms under a parent at some layer above)
                if (NetworkObject.transform.parent != null)
                {
                    parentNetworkObject = NetworkObject.transform.parent.GetComponent<NetworkObject>();

                    // In-scene placed NetworkObjects parented under a GameObject with no
                    // NetworkObject preserve their lossyScale when synchronizing.
                    if (parentNetworkObject == null && NetworkObject.IsSceneObject != false)
                    {
                        hasParentNetworkObject = true;
                    }
                    else
                    {
                        // Or if the relative NetworkObject has a parent NetworkObject
                        hasParentNetworkObject = parentNetworkObject != null;
                    }
                }

                networkState.IsParented = hasParentNetworkObject;
            }

            if (Interpolate != networkState.UseInterpolation)
            {
                networkState.UseInterpolation = Interpolate;
                isDirty = true;
                // When we change from interpolating to not interpolating (or vice versa) we need to synchronize/reset everything
                networkState.IsTeleportingNextFrame = true;
            }

            if (UseQuaternionSynchronization != networkState.QuaternionSync)
            {
                networkState.QuaternionSync = UseQuaternionSynchronization;
                isDirty = true;
                networkState.IsTeleportingNextFrame = true;
            }

            if (UseQuaternionCompression != networkState.QuaternionCompression)
            {
                networkState.QuaternionCompression = UseQuaternionCompression;
                isDirty = true;
                networkState.IsTeleportingNextFrame = true;
            }

            if (UseHalfFloatPrecision != networkState.UseHalfFloatPrecision)
            {
                networkState.UseHalfFloatPrecision = UseHalfFloatPrecision;
                isDirty = true;
                networkState.IsTeleportingNextFrame = true;
            }

            if (SlerpPosition != networkState.UsePositionSlerp)
            {
                networkState.UsePositionSlerp = SlerpPosition;
                isDirty = true;
                networkState.IsTeleportingNextFrame = true;
            }

            if (UseUnreliableDeltas != networkState.UseUnreliableDeltas)
            {
                networkState.UseUnreliableDeltas = UseUnreliableDeltas;
                isDirty = true;
                networkState.IsTeleportingNextFrame = true;
            }

            // Begin delta checks against last sent state update
            if (!UseHalfFloatPrecision)
            {
                if (SyncPositionX && (Mathf.Abs(networkState.PositionX - position.x) >= positionThreshold.x || networkState.IsTeleportingNextFrame || isAxisSync || forceState))
                {
                    networkState.PositionX = position.x;
                    networkState.HasPositionX = true;
                    isPositionDirty = true;
                }

                if (SyncPositionY && (Mathf.Abs(networkState.PositionY - position.y) >= positionThreshold.y || networkState.IsTeleportingNextFrame || isAxisSync || forceState))
                {
                    networkState.PositionY = position.y;
                    networkState.HasPositionY = true;
                    isPositionDirty = true;
                }

                if (SyncPositionZ && (Mathf.Abs(networkState.PositionZ - position.z) >= positionThreshold.z || networkState.IsTeleportingNextFrame || isAxisSync || forceState))
                {
                    networkState.PositionZ = position.z;
                    networkState.HasPositionZ = true;
                    isPositionDirty = true;
                }
            }
            else if (SynchronizePosition)
            {
                // If we are teleporting then we can skip the delta threshold check
                isPositionDirty = networkState.IsTeleportingNextFrame || isAxisSync || forceState;
                if (m_HalfFloatTargetTickOwnership > CurrentTick)
                {
                    isPositionDirty = true;
                }

                // For NetworkDeltaPosition, if any axial value is dirty then we always send a full update
                if (!isPositionDirty)
                {
                    for (int i = 0; i < 3; i++)
                    {
                        if (Math.Abs(position[i] - m_HalfPositionState.PreviousPosition[i]) >= positionThreshold[i])
                        {
                            isPositionDirty = i == 0 ? SyncPositionX : i == 1 ? SyncPositionY : SyncPositionZ;
                            if (!isPositionDirty)
                            {
                                continue;
                            }
                            break;
                        }
                    }
                }

                // If the position is dirty or we are teleporting (which includes synchronization)
                // then determine what parts of the NetworkDeltaPosition should be updated
                if (isPositionDirty)
                {
                    // If we are not synchronizing the transform state for the first time
                    if (!isSynchronization)
                    {
                        // With global teleporting (broadcast to all non-authority instances)
                        // we re-initialize authority's NetworkDeltaPosition and synchronize all
                        // non-authority instances with the new full precision position
                        if (networkState.IsTeleportingNextFrame)
                        {
                            m_HalfPositionState = new NetworkDeltaPosition(position, networkState.NetworkTick, math.bool3(SyncPositionX, SyncPositionY, SyncPositionZ));
                            networkState.CurrentPosition = position;
                        }
                        else // Otherwise, just synchronize the delta position value
                        {
                            m_HalfPositionState.HalfVector3.AxisToSynchronize = math.bool3(SyncPositionX, SyncPositionY, SyncPositionZ);
                            m_HalfPositionState.UpdateFrom(ref position, networkState.NetworkTick);
                        }

                        networkState.NetworkDeltaPosition = m_HalfPositionState;

                        // If ownership offset is greater or we are doing an axial synchronization then synchronize the base position
                        if ((m_HalfFloatTargetTickOwnership > CurrentTick || isAxisSync) && !networkState.IsTeleportingNextFrame)
                        {
                            networkState.SynchronizeBaseHalfFloat = true;
                        }
                        else
                        {
                            networkState.SynchronizeBaseHalfFloat = UseUnreliableDeltas ? m_HalfPositionState.CollapsedDeltaIntoBase : false;
                        }
                    }
                    else // If synchronizing is set, then use the current full position value on the server side
                    {
                        if (ShouldSynchronizeHalfFloat(targetClientId))
                        {
                            // If we have a NetworkDeltaPosition that has a state applied, then we want to determine
                            // what needs to be synchronized. For owner authoritative mode, the server side
                            // will have no valid state yet.
                            if (m_HalfPositionState.NetworkTick > 0)
                            {
                                // Always synchronize the base position and the ushort values of the
                                // current m_HalfPositionState
                                networkState.CurrentPosition = m_HalfPositionState.CurrentBasePosition;
                                networkState.NetworkDeltaPosition = m_HalfPositionState;
                                // If the server is the owner, in both server and owner authoritative modes,
                                // or we are running in server authoritative mode, then we use the
                                // HalfDeltaConvertedBack value as the delta position
                                if (NetworkObject.IsOwnedByServer || IsServerAuthoritative())
                                {
                                    networkState.DeltaPosition = m_HalfPositionState.HalfDeltaConvertedBack;
                                }
                                else
                                {
                                    // Otherwise, we are in owner authoritative mode and the server's NetworkDeltaPosition
                                    // state is "non-authoritative" relative so we use the DeltaPosition.
                                    networkState.DeltaPosition = m_HalfPositionState.DeltaPosition;
                                }
                            }
                            else // Reset everything and just send the current position
                            {
                                networkState.NetworkDeltaPosition = new NetworkDeltaPosition(Vector3.zero, 0, math.bool3(SyncPositionX, SyncPositionY, SyncPositionZ));
                                networkState.DeltaPosition = Vector3.zero;
                                networkState.CurrentPosition = position;
                            }
                        }
                        else
                        {
                            networkState.NetworkDeltaPosition = new NetworkDeltaPosition(Vector3.zero, 0, math.bool3(SyncPositionX, SyncPositionY, SyncPositionZ));
                            networkState.CurrentPosition = position;
                        }
                        // Add log entry for this update relative to the client being synchronized
                        AddLogEntry(ref networkState, targetClientId, true);
                    }
                    networkState.HasPositionX = SyncPositionX;
                    networkState.HasPositionY = SyncPositionY;
                    networkState.HasPositionZ = SyncPositionZ;
                }
            }

            if (!UseQuaternionSynchronization)
            {
                if (SyncRotAngleX && (Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleX, rotAngles.x)) >= rotationThreshold.x || networkState.IsTeleportingNextFrame || isAxisSync || forceState))
                {
                    networkState.RotAngleX = rotAngles.x;
                    networkState.HasRotAngleX = true;
                    isRotationDirty = true;
                }

                if (SyncRotAngleY && (Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleY, rotAngles.y)) >= rotationThreshold.y || networkState.IsTeleportingNextFrame || isAxisSync || forceState))
                {
                    networkState.RotAngleY = rotAngles.y;
                    networkState.HasRotAngleY = true;
                    isRotationDirty = true;
                }

                if (SyncRotAngleZ && (Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleZ, rotAngles.z)) >= rotationThreshold.z || networkState.IsTeleportingNextFrame || isAxisSync || forceState))
                {
                    networkState.RotAngleZ = rotAngles.z;
                    networkState.HasRotAngleZ = true;
                    isRotationDirty = true;
                }
            }
            else if (SynchronizeRotation)
            {
                // If we are teleporting then we can skip the delta threshold check
                isRotationDirty = networkState.IsTeleportingNextFrame || isAxisSync || forceState;
                // For quaternion synchronization, if one angle is dirty we send a full update
                if (!isRotationDirty)
                {
                    var previousRotation = networkState.Rotation.eulerAngles;
                    for (int i = 0; i < 3; i++)
                    {
                        if (Mathf.Abs(Mathf.DeltaAngle(previousRotation[i], rotAngles[i])) >= rotationThreshold[i])
                        {
                            isRotationDirty = true;
                            break;
                        }
                    }
                }
                if (isRotationDirty)
                {
                    networkState.Rotation = rotation;
                    networkState.HasRotAngleX = true;
                    networkState.HasRotAngleY = true;
                    networkState.HasRotAngleZ = true;
                }
            }

            // For scale, we need to check for parenting when synchronizing and/or teleporting (synchronization is always teleporting)
            if (networkState.IsTeleportingNextFrame)
            {
                // If we are synchronizing and the associated NetworkObject has a parent then we want to send the
                // LossyScale if the NetworkObject has a parent since NetworkObject spawn order is not guaranteed
                if (networkState.IsParented)
                {
                    networkState.LossyScale = transform.lossyScale;
                }
            }

            // Checking scale deltas when not synchronizing
            if (!isSynchronization)
            {
                if (!UseHalfFloatPrecision)
                {
                    if (SyncScaleX && (Mathf.Abs(networkState.ScaleX - scale.x) >= ScaleThreshold || networkState.IsTeleportingNextFrame || isAxisSync || forceState))
                    {
                        networkState.ScaleX = scale.x;
                        networkState.HasScaleX = true;
                        isScaleDirty = true;
                    }

                    if (SyncScaleY && (Mathf.Abs(networkState.ScaleY - scale.y) >= ScaleThreshold || networkState.IsTeleportingNextFrame || isAxisSync || forceState))
                    {
                        networkState.ScaleY = scale.y;
                        networkState.HasScaleY = true;
                        isScaleDirty = true;
                    }

                    if (SyncScaleZ && (Mathf.Abs(networkState.ScaleZ - scale.z) >= ScaleThreshold || networkState.IsTeleportingNextFrame || isAxisSync || forceState))
                    {
                        networkState.ScaleZ = scale.z;
                        networkState.HasScaleZ = true;
                        isScaleDirty = true;
                    }
                }
                else if (SynchronizeScale)
                {
                    var previousScale = networkState.Scale;
                    for (int i = 0; i < 3; i++)
                    {
                        if (Mathf.Abs(scale[i] - previousScale[i]) >= ScaleThreshold || networkState.IsTeleportingNextFrame || isAxisSync || forceState)
                        {
                            isScaleDirty = true;
                            networkState.Scale[i] = scale[i];
                            networkState.SetHasScale(i, i == 0 ? SyncScaleX : i == 1 ? SyncScaleY : SyncScaleZ);
                        }
                    }
                }
            }
            else // Just apply the full local scale when synchronizing
            if (SynchronizeScale)
            {
                if (!UseHalfFloatPrecision)
                {
                    networkState.ScaleX = transform.localScale.x;
                    networkState.ScaleY = transform.localScale.y;
                    networkState.ScaleZ = transform.localScale.z;
                }
                else
                {
                    networkState.Scale = transform.localScale;
                }
                networkState.HasScaleX = true;
                networkState.HasScaleY = true;
                networkState.HasScaleZ = true;
                isScaleDirty = true;
            }
            isDirty |= isPositionDirty || isRotationDirty || isScaleDirty;

            if (isDirty)
            {
                // Some integration/unit tests disable the NetworkTransform and there is no
                // NetworkManager
                if (enabled)
                {
                    // We use the NetworkTickSystem version since ServerTime is set when updating ticks
                    networkState.NetworkTick = CurrentTick;
                }
            }

            // Mark the state dirty for the next network tick update to clear out the bitset values
            networkState.IsDirty |= isDirty;
            return isDirty;
        }

        /// <summary>
        /// Authority subscribes to network tick events and will invoke
        /// <see cref="OnUpdateAuthoritativeState(ref Transform)"/> each network tick.
        /// </summary>
        private void OnNetworkTick(bool isCalledFromParent = false)
        {
            // If not active, then ignore the update
            if (!gameObject.activeInHierarchy)
            {
                return;
            }

            // As long as we are still authority
            if (CanCommitToTransform)
            {
                if (m_CachedNetworkManager.DistributedAuthorityMode && !IsOwner)
                {
                    Debug.LogError($"Non-owner Client-{m_CachedNetworkManager.LocalClientId} is being updated by network tick still!!!!");
                    return;
                }

                // If we are nested and have already sent a state update this tick, then exit early (otherwise check for any changes in state)
                if (IsNested && m_LocalAuthoritativeNetworkState.NetworkTick == CurrentTick)
                {
                    return;
                }

#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
                // Let the parent handle the updating of this to keep the two synchronized
                if (!isCalledFromParent && m_UseRigidbodyForMotion && m_NetworkRigidbodyInternal.ParentBody != null && !m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame)
                {
                    return;
                }
#endif

                // Update any changes to the transform
                var transformSource = transform;
                OnUpdateAuthoritativeState(ref transformSource, isCalledFromParent);
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
                m_InternalCurrentPosition = m_TargetPosition = m_UseRigidbodyForMotion ? m_NetworkRigidbodyInternal.GetPosition() : GetSpaceRelativePosition();
#else
                m_InternalCurrentPosition = GetSpaceRelativePosition();
                m_TargetPosition = GetSpaceRelativePosition();
#endif
            }
            else // If we are no longer authority, unsubscribe to the tick event
            {
                DeregisterForTickUpdate(this);
            }
        }
        #endregion

        #region NON-AUTHORITY STATE UPDATE

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        internal void UpdatePositionInterpolator(Vector3 position, double time, bool resetInterpolator = false)
        {
            if (!CanCommitToTransform)
            {
                if (resetInterpolator)
                {
                    m_PositionInterpolator.ResetTo(position, time);
                }
                else
                {
                    m_PositionInterpolator.AddMeasurement(position, time);
                }
            }
        }

        internal bool LogMotion;

        /// <summary>
        /// Virtual method invoked on the non-authority side after a new state has been received and applied.
        /// </summary>
        protected virtual void OnTransformUpdated()
        {

        }

        /// <summary>
        /// Applies the authoritative state to the transform
        /// </summary>
        protected internal void ApplyAuthoritativeState()
        {
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
            // TODO: Make this an authority flag
            // For now, just synchronize with the NetworkRigidbodyBase UseRigidBodyForMotion
            if (m_NetworkRigidbodyInternal != null)
            {
                m_UseRigidbodyForMotion = m_NetworkRigidbodyInternal.UseRigidBodyForMotion;
            }
#endif
            var networkState = m_LocalAuthoritativeNetworkState;
            // The m_InternalCurrentPosition, m_InternalCurrentRotation, and m_InternalCurrentScale values are continually updated
            // at the end of this method and assure that when not interpolating the non-authoritative side
            // cannot make adjustments to any portions the transform not being synchronized.
            var adjustedPosition = m_InternalCurrentPosition;
            var currentPosistion = GetSpaceRelativePosition();
            adjustedPosition.x = SyncPositionX ? m_InternalCurrentPosition.x : currentPosistion.x;
            adjustedPosition.y = SyncPositionY ? m_InternalCurrentPosition.y : currentPosistion.y;
            adjustedPosition.z = SyncPositionZ ? m_InternalCurrentPosition.z : currentPosistion.z;

            var adjustedRotation = m_InternalCurrentRotation;
            var adjustedRotAngles = adjustedRotation.eulerAngles;
            var currentRotation = GetSpaceRelativeRotation().eulerAngles;
            adjustedRotAngles.x = SyncRotAngleX ? adjustedRotAngles.x : currentRotation.x;
            adjustedRotAngles.y = SyncRotAngleY ? adjustedRotAngles.y : currentRotation.y;
            adjustedRotAngles.z = SyncRotAngleZ ? adjustedRotAngles.z : currentRotation.z;
            adjustedRotation.eulerAngles = adjustedRotAngles;


            var adjustedScale = m_InternalCurrentScale;
            var currentScale = GetScale();
            adjustedScale.x = SyncScaleX ? adjustedScale.x : currentScale.x;
            adjustedScale.y = SyncScaleY ? adjustedScale.y : currentScale.y;
            adjustedScale.z = SyncScaleZ ? adjustedScale.z : currentScale.z;

            // Non-Authority Preservers the authority's transform state update modes
            InLocalSpace = networkState.InLocalSpace;
            Interpolate = networkState.UseInterpolation;
            UseHalfFloatPrecision = networkState.UseHalfFloatPrecision;
            UseQuaternionSynchronization = networkState.QuaternionSync;
            UseQuaternionCompression = networkState.QuaternionCompression;
            UseUnreliableDeltas = networkState.UseUnreliableDeltas;

            if (SlerpPosition != networkState.UsePositionSlerp)
            {
                SlerpPosition = networkState.UsePositionSlerp;
                UpdatePositionSlerp();
            }

            // NOTE ABOUT INTERPOLATING AND THE CODE BELOW:
            // We always apply the interpolated state for any axis we are synchronizing even when the state has no deltas
            // to assure we fully interpolate to our target even after we stop extrapolating 1 tick later.

            if (Interpolate)
            {
                if (SynchronizePosition)
                {
                    var interpolatedPosition = m_PositionInterpolator.GetInterpolatedValue();
                    if (UseHalfFloatPrecision)
                    {
                        adjustedPosition = interpolatedPosition;
                    }
                    else
                    {
                        if (SyncPositionX) { adjustedPosition.x = interpolatedPosition.x; }
                        if (SyncPositionY) { adjustedPosition.y = interpolatedPosition.y; }
                        if (SyncPositionZ) { adjustedPosition.z = interpolatedPosition.z; }
                    }
                }

                if (SynchronizeScale)
                {
                    if (UseHalfFloatPrecision)
                    {
                        adjustedScale = m_ScaleInterpolator.GetInterpolatedValue();
                    }
                    else
                    {
                        var interpolatedScale = m_ScaleInterpolator.GetInterpolatedValue();
                        if (SyncScaleX) { adjustedScale.x = interpolatedScale.x; }
                        if (SyncScaleY) { adjustedScale.y = interpolatedScale.y; }
                        if (SyncScaleZ) { adjustedScale.z = interpolatedScale.z; }
                    }
                }

                if (SynchronizeRotation)
                {
                    var interpolatedRotation = m_RotationInterpolator.GetInterpolatedValue();
                    if (UseQuaternionSynchronization)
                    {
                        adjustedRotation = interpolatedRotation;
                    }
                    else
                    {
                        var interpolatedEulerAngles = interpolatedRotation.eulerAngles;
                        if (SyncRotAngleX) { adjustedRotAngles.x = interpolatedEulerAngles.x; }
                        if (SyncRotAngleY) { adjustedRotAngles.y = interpolatedEulerAngles.y; }
                        if (SyncRotAngleZ) { adjustedRotAngles.z = interpolatedEulerAngles.z; }
                        adjustedRotation.eulerAngles = adjustedRotAngles;
                    }
                }
            }
            else
            {
                // Non-Interpolated Position and Scale
                if (UseHalfFloatPrecision)
                {
                    if (networkState.HasPositionChange && SynchronizePosition)
                    {
                        adjustedPosition = m_TargetPosition;
                    }

                    if (networkState.HasScaleChange && SynchronizeScale)
                    {
                        for (int i = 0; i < 3; i++)
                        {
                            if (m_LocalAuthoritativeNetworkState.HasScale(i))
                            {
                                adjustedScale[i] = m_LocalAuthoritativeNetworkState.Scale[i];
                            }
                        }
                    }
                }
                else
                {
                    if (networkState.HasPositionX) { adjustedPosition.x = networkState.PositionX; }
                    if (networkState.HasPositionY) { adjustedPosition.y = networkState.PositionY; }
                    if (networkState.HasPositionZ) { adjustedPosition.z = networkState.PositionZ; }
                    if (networkState.HasScaleX) { adjustedScale.x = networkState.ScaleX; }
                    if (networkState.HasScaleY) { adjustedScale.y = networkState.ScaleY; }
                    if (networkState.HasScaleZ) { adjustedScale.z = networkState.ScaleZ; }
                }

                // Non-interpolated rotation
                if (SynchronizeRotation)
                {
                    if (networkState.QuaternionSync && networkState.HasRotAngleChange)
                    {
                        adjustedRotation = networkState.Rotation;
                    }
                    else
                    {
                        if (networkState.HasRotAngleX) { adjustedRotAngles.x = networkState.RotAngleX; }
                        if (networkState.HasRotAngleY) { adjustedRotAngles.y = networkState.RotAngleY; }
                        if (networkState.HasRotAngleZ) { adjustedRotAngles.z = networkState.RotAngleZ; }
                        adjustedRotation.eulerAngles = adjustedRotAngles;
                    }
                }
            }

            // Apply the position if we are synchronizing position
            if (SynchronizePosition)
            {
                // Update our current position if it changed or we are interpolating
                if (networkState.HasPositionChange || Interpolate)
                {
                    if (SyncPositionX && SyncPositionY && SyncPositionZ)
                    {
                        m_InternalCurrentPosition = adjustedPosition;
                    }
                    else
                    {
                        // Preserve any non-synchronized changes to the local instance's position
                        var position = InLocalSpace ? transform.localPosition : transform.position;
                        m_InternalCurrentPosition.x = SyncPositionX ? adjustedPosition.x : position.x;
                        m_InternalCurrentPosition.y = SyncPositionY ? adjustedPosition.y : position.y;
                        m_InternalCurrentPosition.z = SyncPositionZ ? adjustedPosition.z : position.z;
                    }
                }
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
                if (m_UseRigidbodyForMotion)
                {
                    m_NetworkRigidbodyInternal.MovePosition(m_InternalCurrentPosition);
                    if (LogMotion)
                    {
                        Debug.Log($"[Client-{m_CachedNetworkManager.LocalClientId}][Interpolate: {networkState.UseInterpolation}][TransPos: {transform.position}][RBPos: {m_NetworkRigidbodyInternal.GetPosition()}][CurrentPos: {m_InternalCurrentPosition}");
                    }

                }
                else
#endif
                {
                    if (PositionInLocalSpace)
                    {
                        // This handles the edge case of transitioning from local to world space where applying a local
                        // space value to a non-parented transform will be applied in world space. Since parenting is not
                        // tick synchronized, there can be one or two ticks between a state update with the InLocalSpace
                        // state update which can cause the body to seemingly "teleport" when it is just applying a local
                        // space value relative to world space 0,0,0.
                        if (SwitchTransformSpaceWhenParented && m_IsFirstNetworkTransform && Interpolate && m_PreviousNetworkObjectParent != null
                            && transform.parent == null)
                        {
                            m_InternalCurrentPosition = m_PreviousNetworkObjectParent.transform.TransformPoint(m_InternalCurrentPosition);
                            transform.position = m_InternalCurrentPosition;
                        }
                        else
                        {
                            transform.localPosition = m_InternalCurrentPosition;
                        }
                    }
                    else
                    {
                        transform.position = m_InternalCurrentPosition;
                    }
                }
            }

            // Apply the rotation if we are synchronizing rotation
            if (SynchronizeRotation)
            {
                // Update our current rotation if it changed or we are interpolating
                if (networkState.HasRotAngleChange || Interpolate)
                {
                    if ((SyncRotAngleX && SyncRotAngleY && SyncRotAngleZ) || UseQuaternionSynchronization)
                    {
                        m_InternalCurrentRotation = adjustedRotation;
                    }
                    else
                    {
                        // Preserve any non-synchronized changes to the local instance's rotation
                        var rotation = InLocalSpace ? transform.localRotation.eulerAngles : transform.rotation.eulerAngles;
                        var currentEuler = m_InternalCurrentRotation.eulerAngles;
                        var updatedEuler = adjustedRotation.eulerAngles;
                        currentEuler.x = SyncRotAngleX ? updatedEuler.x : rotation.x;
                        currentEuler.y = SyncRotAngleY ? updatedEuler.y : rotation.y;
                        currentEuler.z = SyncRotAngleZ ? updatedEuler.z : rotation.z;
                        m_InternalCurrentRotation.eulerAngles = currentEuler;
                    }
                }

#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
                if (m_UseRigidbodyForMotion)
                {
                    m_NetworkRigidbodyInternal.MoveRotation(m_InternalCurrentRotation);
                }
                else
#endif
                {
                    if (RotationInLocalSpace)
                    {
                        // This handles the edge case of transitioning from local to world space where applying a local
                        // space value to a non-parented transform will be applied in world space. Since parenting is not
                        // tick synchronized, there can be one or two ticks between a state update with the InLocalSpace
                        // state update which can cause the body to rotate world space relative and cause a slight rotation
                        // of the body in-between this transition period.
                        if (SwitchTransformSpaceWhenParented && m_IsFirstNetworkTransform && Interpolate && m_PreviousNetworkObjectParent != null && transform.parent == null)
                        {
                            m_InternalCurrentRotation = m_PreviousNetworkObjectParent.transform.rotation * m_InternalCurrentRotation;
                            transform.rotation = m_InternalCurrentRotation;
                        }
                        else
                        {
                            transform.localRotation = m_InternalCurrentRotation;
                        }
                    }
                    else
                    {
                        transform.rotation = m_InternalCurrentRotation;
                    }
                }
            }

            // Apply the scale if we are synchronizing scale
            if (SynchronizeScale)
            {
                // Update our current scale if it changed or we are interpolating
                if (networkState.HasScaleChange || Interpolate)
                {
                    if (SyncScaleX && SyncScaleY && SyncScaleZ)
                    {
                        m_InternalCurrentScale = adjustedScale;
                    }
                    else
                    {
                        // Preserve any non-synchronized changes to the local instance's scale
                        var scale = transform.localScale;
                        m_InternalCurrentScale.x = SyncScaleX ? adjustedScale.x : scale.x;
                        m_InternalCurrentScale.y = SyncScaleY ? adjustedScale.y : scale.y;
                        m_InternalCurrentScale.z = SyncScaleZ ? adjustedScale.z : scale.z;
                    }
                }
                transform.localScale = m_InternalCurrentScale;
            }
            OnTransformUpdated();
        }

        /// <summary>
        /// Handles applying the full authoritative state (i.e. teleporting)
        /// </summary>
        /// <remarks>
        /// Only non-authoritative instances should invoke this
        /// </remarks>
        private void ApplyTeleportingState(NetworkTransformState newState)
        {
            if (!newState.IsTeleportingNextFrame)
            {
                return;
            }

            var sentTime = newState.SentTime;
            var currentPosition = GetSpaceRelativePosition();
            var currentRotation = GetSpaceRelativeRotation();
            var currentEulerAngles = currentRotation.eulerAngles;
            var currentScale = transform.localScale;

            var isSynchronization = newState.IsSynchronizing;

            // Clear all interpolators
            m_ScaleInterpolator.Clear();
            m_PositionInterpolator.Clear();
            m_RotationInterpolator.Clear();

            if (newState.HasPositionChange)
            {
                if (!UseHalfFloatPrecision)
                {
                    // Adjust based on which axis changed
                    if (newState.HasPositionX)
                    {
                        currentPosition.x = newState.PositionX;
                    }

                    if (newState.HasPositionY)
                    {
                        currentPosition.y = newState.PositionY;
                    }

                    if (newState.HasPositionZ)
                    {
                        currentPosition.z = newState.PositionZ;
                    }
                }
                else
                {
                    // With delta position teleport updates or synchronization, we create a new instance and provide the current network tick.
                    m_HalfPositionState = new NetworkDeltaPosition(newState.CurrentPosition, newState.NetworkTick, math.bool3(SyncPositionX, SyncPositionY, SyncPositionZ));

                    // When first synchronizing we determine if we need to apply the current delta position
                    // offset or not. This is specific to owner authoritative mode on the owner side only
                    if (isSynchronization)
                    {
                        // Need to use NetworkManager vs m_CachedNetworkManager here since we are yet to be spawned
                        if (ShouldSynchronizeHalfFloat(NetworkManager.LocalClientId))
                        {
                            m_HalfPositionState.HalfVector3.Axis = newState.NetworkDeltaPosition.HalfVector3.Axis;
                            m_HalfPositionState.DeltaPosition = newState.DeltaPosition;
                            currentPosition = m_HalfPositionState.ToVector3(newState.NetworkTick);
                        }
                        else
                        {
                            currentPosition = newState.CurrentPosition;
                        }
                        // Before the state is applied add a log entry if AddLogEntry is assigned
                        AddLogEntry(ref newState, NetworkObject.OwnerClientId, true);
                    }
                    else
                    {
                        // If we are just teleporting, then we already created a new NetworkDeltaPosition value.
                        // set the current position to the state's current position
                        currentPosition = newState.CurrentPosition;
                    }
                }

                m_InternalCurrentPosition = currentPosition;
                m_TargetPosition = currentPosition;

                // Apply the position
                if (newState.InLocalSpace)
                {
                    transform.localPosition = currentPosition;
                }
                else
                {
                    transform.position = currentPosition;
                }

#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
                if (m_UseRigidbodyForMotion)
                {
                    m_NetworkRigidbodyInternal.SetPosition(transform.position);
                }
#endif

                if (Interpolate)
                {
                    UpdatePositionInterpolator(currentPosition, sentTime, true);
                }
            }

            if (newState.HasScaleChange)
            {
                bool shouldUseLossy = false;

                if (UseHalfFloatPrecision)
                {
                    currentScale = shouldUseLossy ? newState.LossyScale : newState.Scale;
                }
                else
                {
                    // Adjust based on which axis changed
                    if (newState.HasScaleX)
                    {
                        currentScale.x = shouldUseLossy ? newState.LossyScale.x : newState.ScaleX;
                    }

                    if (newState.HasScaleY)
                    {
                        currentScale.y = shouldUseLossy ? newState.LossyScale.y : newState.ScaleY;
                    }

                    if (newState.HasScaleZ)
                    {
                        currentScale.z = shouldUseLossy ? newState.LossyScale.z : newState.ScaleZ;
                    }
                }

                m_InternalCurrentScale = currentScale;
                m_TargetScale = currentScale;

                // Apply the adjusted scale
                transform.localScale = currentScale;

                if (Interpolate)
                {
                    m_ScaleInterpolator.ResetTo(currentScale, sentTime);
                }
            }

            if (newState.HasRotAngleChange)
            {
                if (newState.QuaternionSync)
                {
                    currentRotation = newState.Rotation;
                }
                else
                {
                    // Adjust based on which axis changed
                    if (newState.HasRotAngleX)
                    {
                        currentEulerAngles.x = newState.RotAngleX;
                    }

                    if (newState.HasRotAngleY)
                    {
                        currentEulerAngles.y = newState.RotAngleY;
                    }

                    if (newState.HasRotAngleZ)
                    {
                        currentEulerAngles.z = newState.RotAngleZ;
                    }
                    currentRotation.eulerAngles = currentEulerAngles;
                }

                m_InternalCurrentRotation = currentRotation;
                m_TargetRotation = currentRotation.eulerAngles;

                if (InLocalSpace)
                {
                    transform.localRotation = currentRotation;
                }
                else
                {
                    transform.rotation = currentRotation;
                }

#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
                if (m_UseRigidbodyForMotion)
                {
                    m_NetworkRigidbodyInternal.SetRotation(transform.rotation);
                }
#endif

                if (Interpolate)
                {
                    m_RotationInterpolator.ResetTo(currentRotation, sentTime);
                }
            }

            // Add log after to applying the update if AddLogEntry is defined
            if (isSynchronization)
            {
                AddLogEntry(ref newState, NetworkObject.OwnerClientId);
            }

            OnTransformUpdated();
        }

        /// <summary>
        /// Adds the new state's values to their respective interpolator
        /// </summary>
        /// <remarks>
        /// Only non-authoritative instances should invoke this
        /// </remarks>
        internal void ApplyUpdatedState(NetworkTransformState newState)
        {
            // Set the transforms's synchronization modes
            InLocalSpace = newState.InLocalSpace;
            Interpolate = newState.UseInterpolation;
            UseQuaternionSynchronization = newState.QuaternionSync;
            UseQuaternionCompression = newState.QuaternionCompression;
            UseHalfFloatPrecision = newState.UseHalfFloatPrecision;
            UseUnreliableDeltas = newState.UseUnreliableDeltas;

            if (SlerpPosition != newState.UsePositionSlerp)
            {
                SlerpPosition = newState.UsePositionSlerp;
                UpdatePositionSlerp();
            }

            m_LocalAuthoritativeNetworkState = newState;
            if (m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame)
            {
                ApplyTeleportingState(m_LocalAuthoritativeNetworkState);
                return;
            }

            var sentTime = newState.SentTime;
            var currentRotation = GetSpaceRelativeRotation();

            // Only if using half float precision and our position had changed last update then
            if (UseHalfFloatPrecision && m_LocalAuthoritativeNetworkState.HasPositionChange)
            {
                if (m_LocalAuthoritativeNetworkState.SynchronizeBaseHalfFloat)
                {
                    m_HalfPositionState = m_LocalAuthoritativeNetworkState.NetworkDeltaPosition;
                }
                else
                {
                    // assure our local NetworkDeltaPosition state is updated
                    m_HalfPositionState.HalfVector3.Axis = m_LocalAuthoritativeNetworkState.NetworkDeltaPosition.HalfVector3.Axis;
                    m_LocalAuthoritativeNetworkState.NetworkDeltaPosition.CurrentBasePosition = m_HalfPositionState.CurrentBasePosition;

                    // This is to assure when you get the position of the state it is the correct position
                    m_LocalAuthoritativeNetworkState.NetworkDeltaPosition.ToVector3(0);
                }
                // Update our target position
                m_TargetPosition = m_HalfPositionState.ToVector3(newState.NetworkTick);
                m_LocalAuthoritativeNetworkState.CurrentPosition = m_TargetPosition;
            }

            if (!Interpolate)
            {
                ApplyAuthoritativeState();
                return;
            }

            AdjustForChangeInTransformSpace();

            // Apply axial changes from the new state
            // Either apply the delta position target position or the current state's delta position
            // depending upon whether UsePositionDeltaCompression is enabled
            if (m_LocalAuthoritativeNetworkState.HasPositionChange)
            {
                if (!m_LocalAuthoritativeNetworkState.UseHalfFloatPrecision)
                {
                    var position = m_LocalAuthoritativeNetworkState.GetPosition();
                    var newTargetPosition = m_TargetPosition;
                    if (m_LocalAuthoritativeNetworkState.HasPositionX)
                    {
                        newTargetPosition.x = position.x;
                    }

                    if (m_LocalAuthoritativeNetworkState.HasPositionY)
                    {
                        newTargetPosition.y = position.y;
                    }

                    if (m_LocalAuthoritativeNetworkState.HasPositionZ)
                    {
                        newTargetPosition.z = position.z;
                    }
                    m_TargetPosition = newTargetPosition;
                }
                UpdatePositionInterpolator(m_TargetPosition, sentTime);
            }

            if (m_LocalAuthoritativeNetworkState.HasScaleChange)
            {
                var currentScale = m_TargetScale;
                if (UseHalfFloatPrecision)
                {
                    for (int i = 0; i < 3; i++)
                    {
                        if (m_LocalAuthoritativeNetworkState.HasScale(i))
                        {
                            currentScale[i] = m_LocalAuthoritativeNetworkState.Scale[i];
                        }
                    }
                }
                else
                {
                    if (m_LocalAuthoritativeNetworkState.HasScaleX)
                    {
                        currentScale.x = m_LocalAuthoritativeNetworkState.ScaleX;
                    }

                    if (m_LocalAuthoritativeNetworkState.HasScaleY)
                    {
                        currentScale.y = m_LocalAuthoritativeNetworkState.ScaleY;
                    }

                    if (m_LocalAuthoritativeNetworkState.HasScaleZ)
                    {
                        currentScale.z = m_LocalAuthoritativeNetworkState.ScaleZ;
                    }
                }
                m_TargetScale = currentScale;
                m_ScaleInterpolator.AddMeasurement(currentScale, sentTime);
            }

            // With rotation, we check if there are any changes first and
            // if so then apply the changes to the current Euler rotation
            // values.
            if (m_LocalAuthoritativeNetworkState.HasRotAngleChange)
            {
                if (m_LocalAuthoritativeNetworkState.QuaternionSync)
                {
                    currentRotation = m_LocalAuthoritativeNetworkState.Rotation;
                }
                else
                {
                    var currentEulerAngles = m_TargetRotation;
                    // Adjust based on which axis changed
                    // (both half precision and full precision apply Eulers to the RotAngle properties when reading the update)
                    if (m_LocalAuthoritativeNetworkState.HasRotAngleX)
                    {
                        currentEulerAngles.x = m_LocalAuthoritativeNetworkState.RotAngleX;
                    }

                    if (m_LocalAuthoritativeNetworkState.HasRotAngleY)
                    {
                        currentEulerAngles.y = m_LocalAuthoritativeNetworkState.RotAngleY;
                    }

                    if (m_LocalAuthoritativeNetworkState.HasRotAngleZ)
                    {
                        currentEulerAngles.z = m_LocalAuthoritativeNetworkState.RotAngleZ;
                    }
                    m_TargetRotation = currentEulerAngles;
                    currentRotation.eulerAngles = currentEulerAngles;
                }

                m_RotationInterpolator.AddMeasurement(currentRotation, sentTime);
            }
        }

        /// <summary>
        /// Invoked on the non-authoritative side when the NetworkTransformState has been updated
        /// </summary>
        /// <param name="oldState">the previous <see cref="NetworkTransformState"/></param>
        /// <param name="newState">the new <see cref="NetworkTransformState"/></param>
        protected virtual void OnNetworkTransformStateUpdated(ref NetworkTransformState oldState, ref NetworkTransformState newState)
        {

        }

        /// <summary>
        /// Virtual method that is invoked on the non-authority side when a state update has been recieved but not yet applied.
        /// </summary>
        protected virtual void OnBeforeUpdateTransformState()
        {

        }

        internal bool LogStateUpdate;
        /// <summary>
        /// Only non-authoritative instances should invoke this method
        /// </summary>
        private void OnNetworkStateChanged(NetworkTransformState oldState, NetworkTransformState newState)
        {
            if (!NetworkObject.IsSpawned || CanCommitToTransform)
            {
                return;
            }

            // If we are using UseUnreliableDeltas and our old state tick is greater than the new state tick,
            // then just ignore the newstate. This avoids any scenario where the new state is out of order
            // from the old state (with unreliable traffic and/or mixed unreliable and reliable)
            if (UseUnreliableDeltas && oldState.NetworkTick > newState.NetworkTick && !newState.IsTeleportingNextFrame && !newState.UnreliableFrameSync)
            {
                return;
            }

            // Get the time when this new state was sent
            newState.SentTime = new NetworkTime(m_CachedNetworkManager.NetworkTickSystem.TickRate, newState.NetworkTick).Time;

            if (LogStateUpdate)
            {
                var builder = new StringBuilder();
                builder.AppendLine($"[Client-{m_CachedNetworkManager.LocalClientId}][State Update: {newState.GetNetworkTick()}][HasPos: {newState.HasPositionChange}][Has Rot: {newState.HasRotAngleChange}][Has Scale: {newState.HasScaleChange}]");
                if (newState.HasPositionChange)
                {
                    builder.AppendLine($"Position = {newState.GetPosition()}");
                }
                if (newState.HasRotAngleChange)
                {
                    builder.AppendLine($"Rotation = {newState.GetRotation()}");
                }
                if (newState.HasScaleChange)
                {
                    builder.AppendLine($"Scale = {newState.GetScale()}");
                }
                Debug.Log(builder);
            }

            // Notification prior to applying a state update
            OnBeforeUpdateTransformState();

            // Apply the new state
            ApplyUpdatedState(newState);

            // Tick synchronize any parented child NetworkObject(s) NetworkTransform(s)
            if (TickSyncChildren && m_IsFirstNetworkTransform)
            {
                // Synchronize any nested NetworkTransforms with the parent's
                foreach (var childNetworkTransform in NetworkObject.NetworkTransforms)
                {
                    // Don't update the same instance or any nested NetworkTransform with a different authority mode
                    if (childNetworkTransform == this || childNetworkTransform.AuthorityMode != AuthorityMode)
                    {
                        continue;
                    }
                    if (childNetworkTransform.CanCommitToTransform)
                    {
                        childNetworkTransform.OnNetworkTick(true);
                    }
                }

                // Synchronize any parented children with the parent's motion
                foreach (var child in m_ParentedChildren)
                {
                    // Synchronize any nested NetworkTransforms of the child with the parent's
                    foreach (var childNetworkTransform in child.NetworkTransforms)
                    {
                        if (childNetworkTransform.CanCommitToTransform)
                        {
                            childNetworkTransform.OnNetworkTick(true);
                        }
                    }
                }
            }

            // Provide notifications when the state has been updated
            // We use the m_LocalAuthoritativeNetworkState because newState has been applied and adjustments could have
            // been made (i.e. half float precision position values will have been updated)
            OnNetworkTransformStateUpdated(ref oldState, ref m_LocalAuthoritativeNetworkState);
        }

        /// <summary>
        /// Will set the maximum interpolation boundary for the interpolators of this <see cref="NetworkTransform"/> instance.
        /// This value roughly translates to the maximum value of 't' in <see cref="Vector3.Lerp(Vector3, Vector3, float)"/> and
        /// <see cref="Quaternion.Lerp(Quaternion, Quaternion, float)"/> for all transform elements being monitored by
        /// <see cref="NetworkTransform"/> (i.e. Position, Scale, and Rotation)
        /// </summary>
        /// <remarks>
        /// All of three max interpolation time properties will have this maximum interpolation bound value applied:<br />
        /// - <see cref="PositionMaxInterpolationTime"/><br />
        /// - <see cref="RotationMaxInterpolationTime"/><br />
        /// - <see cref="ScaleMaxInterpolationTime"/><br />
        /// </remarks>
        /// <param name="maxInterpolationBound">Maximum time boundary that can be used in a frame when interpolating between two values</param>
        public void SetMaxInterpolationBound(float maxInterpolationBound)
        {
            PositionMaxInterpolationTime = maxInterpolationBound;
            RotationMaxInterpolationTime = maxInterpolationBound;
            ScaleMaxInterpolationTime = maxInterpolationBound;
            m_RotationInterpolator.MaxInterpolationBound = maxInterpolationBound;
            m_PositionInterpolator.MaxInterpolationBound = maxInterpolationBound;
            m_ScaleInterpolator.MaxInterpolationBound = maxInterpolationBound;
        }

        /// <summary>
        /// Checks for changes in the axis to synchronize. If one or more did change it
        /// then determines if the axis were enabled and if the delta between the last known
        /// delta position and the current position for the axis exceeds the adjustment range
        /// before it is collapsed into the base position.
        /// If it does exceed the adjustment range, then we have to teleport the object so
        /// a full position synchronization takes place and the NetworkDeltaPosition is
        /// reset with the updated base position that it then will generating a new delta position from.
        /// </summary>
        /// <remarks>
        /// This only happens if a user disables an axis, continues to update the disabled axis,
        /// and then later enables the axis. (which will not be a recommended best practice)
        /// </remarks>
        private void AxisChangedDeltaPositionCheck()
        {
            if (UseHalfFloatPrecision && SynchronizePosition)
            {
                var synAxis = m_HalfPositionState.HalfVector3.AxisToSynchronize;
                if (SyncPositionX != synAxis.x || SyncPositionY != synAxis.y || SyncPositionZ != synAxis.z)
                {
                    var positionState = m_HalfPositionState.GetFullPosition();
                    var relativePosition = GetSpaceRelativePosition();
                    bool needsToTeleport = false;
                    // Only if the synchronization of an axis is turned on do we need to
                    // check if a teleport is required due to the delta from the last known
                    // to the currently known axis value exceeds MaxDeltaBeforeAdjustment.
                    if (SyncPositionX && SyncPositionX != synAxis.x)
                    {
                        needsToTeleport = Mathf.Abs(relativePosition.x - positionState.x) >= NetworkDeltaPosition.MaxDeltaBeforeAdjustment;
                    }
                    if (SyncPositionY && SyncPositionY != synAxis.y)
                    {
                        needsToTeleport = Mathf.Abs(relativePosition.y - positionState.y) >= NetworkDeltaPosition.MaxDeltaBeforeAdjustment;
                    }
                    if (SyncPositionZ && SyncPositionZ != synAxis.z)
                    {
                        needsToTeleport = Mathf.Abs(relativePosition.z - positionState.z) >= NetworkDeltaPosition.MaxDeltaBeforeAdjustment;
                    }
                    // If needed, force a teleport as the delta is outside of the valid delta boundary
                    m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame = needsToTeleport;
                }
            }
        }

        /// <summary>
        /// Called by authority to check for deltas and update non-authoritative instances
        /// if any are found.
        /// </summary>
        internal void OnUpdateAuthoritativeState(ref Transform transformSource, bool settingState = false)
        {
            // If our replicated state is not dirty and our local authority state is dirty, clear it.
            if (!m_LocalAuthoritativeNetworkState.ExplicitSet && m_LocalAuthoritativeNetworkState.IsDirty && !m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame)
            {
                // Now clear our bitset and prepare for next network tick state update
                m_LocalAuthoritativeNetworkState.ClearBitSetForNextTick();
                if (TrackByStateId)
                {
                    m_LocalAuthoritativeNetworkState.TrackByStateId = true;
                    m_LocalAuthoritativeNetworkState.StateId++;
                }
                else
                {
                    m_LocalAuthoritativeNetworkState.TrackByStateId = false;
                }
            }

            AxisChangedDeltaPositionCheck();

            TryCommitTransform(ref transformSource, settingState: settingState);
        }
        #endregion

        #region SPAWN, DESPAWN, AND INITIALIZATION

        private void NonAuthorityFinalizeSynchronization()
        {
            // For all child NetworkTransforms nested under the same NetworkObject,
            // we apply the initial synchronization based on their parented/ordered
            // heirarchy.
            if (SynchronizeState.IsSynchronizing)
            {
                if (m_IsFirstNetworkTransform)
                {
                    foreach (var child in NetworkObject.NetworkTransforms)
                    {
                        // Don't initialize any nested NetworkTransforms that this instance has authority over
                        if (child.CanCommitToTransform)
                        {
                            continue;
                        }
                        child.ApplySynchronization();

                        // For all like-authority nested (under the root/same NetworkObject) child NetworkTransforms, we need to run through
                        // initialization once more to assure any values applied or stored are relative to the Root's transform.
                        child.InternalInitialization();
                    }
                }
                else // Otherwise, just run through standard synchronization of this instance
                if (!CanCommitToTransform)
                {
                    ApplySynchronization();
                    InternalInitialization();
                }
            }
        }

        /// <summary>
        /// Handle applying the synchronization state once everything has spawned.
        /// The first NetowrkTransform handles invoking this on any other nested NetworkTransform.
        /// </summary>
        protected internal override void InternalOnNetworkSessionSynchronized()
        {
            NonAuthorityFinalizeSynchronization();

            base.InternalOnNetworkSessionSynchronized();
        }

        private void ApplyPlayerTransformState()
        {
            SynchronizeState.InLocalSpace = InLocalSpace;
            SynchronizeState.UseInterpolation = Interpolate;
            SynchronizeState.QuaternionSync = UseQuaternionSynchronization;
            SynchronizeState.UseHalfFloatPrecision = UseHalfFloatPrecision;
            SynchronizeState.QuaternionCompression = UseQuaternionCompression;
            SynchronizeState.UsePositionSlerp = SlerpPosition;
        }

        /// <summary>
        /// For dynamically spawned NetworkObjects, when the non-authority instance's client is already connected and
        /// the SynchronizeState is still pending synchronization then we want to finalize the synchornization at this time.
        /// </summary>
        protected internal override void InternalOnNetworkPostSpawn()
        {
            // This is a special case for client-server where a server is spawning an owner authoritative NetworkObject but has yet to serialize anything.
            // When the server detects that:
            // - We are not in a distributed authority session (DAHost check).
            // - We are in owner authoritative mode.
            // - The NetworkObject is not owned by the server.
            // - The SynchronizeState.IsSynchronizing is set to false.
            // Then we want to:
            // - Force the "IsSynchronizing" flag so the NetworkTransform has its state updated properly and runs through the initialization again.
            // - Make sure the SynchronizingState is updated to the instantiated prefab's default flags/settings.
            if (NetworkManager.IsServer && !NetworkManager.DistributedAuthorityMode && !IsOwner && !OnIsServerAuthoritative() && !SynchronizeState.IsSynchronizing)
            {
                // Handle the first/root NetworkTransform slightly differently to have a sequenced synchronization of like authority nested NetworkTransform components
                if (m_IsFirstNetworkTransform)
                {
                    // Assure the NetworkTransform has the synchronizing flag set so the server runs through the final post initialization steps
                    SynchronizeState.IsSynchronizing = true;

                    // Assure the SynchronizeState matches the initial prefab's values for each associated NetworkTransfrom (this includes root + all children)
                    foreach (var child in NetworkObject.NetworkTransforms)
                    {
                        // Don't ApplyPlayerTransformState to any nested NetworkTransform with a different authority mode
                        if (child != this && child.AuthorityMode != AuthorityMode)
                        {
                            continue;
                        }
                        child.ApplyPlayerTransformState();
                    }
                }
                else
                {
                    ApplyPlayerTransformState();
                }

                // Now fall through to the final synchronization portion of the spawning for NetworkTransform
            }

            // Standard non-authority synchronization is handled here
            if (!CanCommitToTransform && NetworkManager.IsConnectedClient && SynchronizeState.IsSynchronizing)
            {
                NonAuthorityFinalizeSynchronization();
            }

            base.InternalOnNetworkPostSpawn();
        }

        /// <summary>
        /// For testing purposes to quickly change the default from Lerp to SmoothDamp
        /// </summary>
        internal static bool AssignDefaultInterpolationType;
        internal static InterpolationTypes DefaultInterpolationType;

        /// <summary>
        /// Create interpolators when first instantiated to avoid memory allocations if the
        /// associated NetworkObject persists (i.e. despawned but not destroyed or pools)
        /// </summary>
        protected virtual void Awake()
        {
            if (AssignDefaultInterpolationType)
            {
                PositionInterpolationType = DefaultInterpolationType;
                RotationInterpolationType = DefaultInterpolationType;
                ScaleInterpolationType = DefaultInterpolationType;
            }
            // Rotation is a single Quaternion since each Euler axis will affect the quaternion's final value
            m_RotationInterpolator = new BufferedLinearInterpolatorQuaternion();
            m_PositionInterpolator = new BufferedLinearInterpolatorVector3();
            m_ScaleInterpolator = new BufferedLinearInterpolatorVector3();
        }

        /// <inheritdoc/>
        public override void OnNetworkSpawn()
        {
            m_ParentedChildren.Clear();
            m_CachedNetworkManager = NetworkManager;

            Initialize();

            if (CanCommitToTransform)
            {
                SetState(GetSpaceRelativePosition(), GetSpaceRelativeRotation(), GetScale(), false);
            }
        }

        private void CleanUpOnDestroyOrDespawn()
        {
            m_ParentedChildren.Clear();
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
            var forUpdate = !m_UseRigidbodyForMotion;
#else
            var forUpdate = true;
#endif
            if (m_CachedNetworkObject != null)
            {
                NetworkManager?.NetworkTransformRegistration(m_CachedNetworkObject, forUpdate, false);
            }

            DeregisterForTickUpdate(this);
            CanCommitToTransform = false;
        }

        /// <inheritdoc/>
        public override void OnNetworkDespawn()
        {
            CleanUpOnDestroyOrDespawn();
            base.OnNetworkDespawn();
        }

        /// <inheritdoc/>
        public override void OnDestroy()
        {
            CleanUpOnDestroyOrDespawn();
            base.OnDestroy();
        }

        /// <summary>
        /// Invoked when first spawned and when ownership changes.
        /// </summary>
        /// <param name="replicatedState">the current <see cref="NetworkTransformState"/> after initializing</param>
        protected virtual void OnInitialize(ref NetworkTransformState replicatedState)
        {
        }

        /// <summary>
        /// This method is only invoked by the owner
        /// Use: OnInitialize(ref NetworkTransformState replicatedState) to be notified on all instances
        /// </summary>
        /// <param name="replicatedState">The NetworkVariable containing the <see cref="NetworkTransformState"/></param>
        protected virtual void OnInitialize(ref NetworkVariable<NetworkTransformState> replicatedState)
        {

        }

        private int m_HalfFloatTargetTickOwnership;

        /// <summary>
        /// Initializes the interpolators with the current transform values
        /// </summary>
        private void ResetInterpolatedStateToCurrentAuthoritativeState()
        {
            var serverTime = NetworkManager.ServerTime.Time;
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
            var position = m_UseRigidbodyForMotion ? m_NetworkRigidbodyInternal.GetPosition() : GetSpaceRelativePosition();
            var rotation = m_UseRigidbodyForMotion ? m_NetworkRigidbodyInternal.GetRotation() : GetSpaceRelativeRotation();
#else
            var position = GetSpaceRelativePosition();
            var rotation = GetSpaceRelativeRotation();
#endif
            m_PositionInterpolator.InLocalSpace = InLocalSpace;
            m_RotationInterpolator.InLocalSpace = InLocalSpace;

            UpdatePositionInterpolator(position, serverTime, true);
            UpdatePositionSlerp();

            m_ScaleInterpolator.ResetTo(transform.localScale, serverTime);
            m_RotationInterpolator.ResetTo(rotation, serverTime);
        }
        private NetworkObject m_CachedNetworkObject;
        /// <summary>
        /// The internal initialzation method to allow for internal API adjustments
        /// </summary>
        /// <param name="isOwnershipChange"></param>
        private void InternalInitialization(bool isOwnershipChange = false)
        {
            if (!IsSpawned)
            {
                return;
            }
            m_CachedNetworkObject = NetworkObject;

            // Determine if this is the first NetworkTransform in the associated NetworkObject's list
            m_IsFirstNetworkTransform = NetworkObject.NetworkTransforms[0] == this;

            if (m_CachedNetworkManager && m_CachedNetworkManager.DistributedAuthorityMode)
            {
                AuthorityMode = AuthorityModes.Owner;
            }
            CanCommitToTransform = IsServerAuthoritative() ? IsServer : IsOwner;

            if (SwitchTransformSpaceWhenParented)
            {
                if (CanCommitToTransform)
                {
                    if (NetworkObject.HasParentNetworkObject(transform))
                    {
                        InLocalSpace = true;
                    }
                }
                // Always apply this if SwitchTransformSpaceWhenParented is set.
                TickSyncChildren = true;
            }

            var currentPosition = GetSpaceRelativePosition();
            var currentRotation = GetSpaceRelativeRotation();

            if (NetworkManager.DistributedAuthorityMode)
            {
                RegisterNetworkManagerForTickUpdate(NetworkManager);
                m_NetworkTransformTickRegistration = s_NetworkTickRegistration[m_CachedNetworkManager];
            }

#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
            // Depending upon order of operations, we invoke this in order to assure that proper settings are applied.
            if (m_NetworkRigidbodyInternal)
            {
                m_NetworkRigidbodyInternal.UpdateOwnershipAuthority();
            }

            if (m_UseRigidbodyForMotion)
            {
                m_NetworkRigidbodyInternal.SetPosition(currentPosition);
                m_NetworkRigidbodyInternal.SetRotation(currentRotation);
            }

            var forUpdate = !m_UseRigidbodyForMotion;
#else
            var forUpdate = true;
#endif
            m_LocalAuthoritativeNetworkState.SynchronizeBaseHalfFloat = false;

            if (CanCommitToTransform)
            {
                // Make sure authority doesn't get added to updates (no need to do this on the authority side)
                m_CachedNetworkManager.NetworkTransformRegistration(NetworkObject, forUpdate, false);
                if (UseHalfFloatPrecision)
                {
                    m_HalfPositionState = new NetworkDeltaPosition(currentPosition, m_CachedNetworkManager.ServerTime.Tick, math.bool3(SyncPositionX, SyncPositionY, SyncPositionZ));
                    m_LocalAuthoritativeNetworkState.SynchronizeBaseHalfFloat = isOwnershipChange;
                    SetState(teleportDisabled: false);
                }

                m_InternalCurrentPosition = currentPosition;
                m_TargetPosition = currentPosition;

                RegisterForTickUpdate(this);

                if (UseHalfFloatPrecision && isOwnershipChange && !IsServerAuthoritative() && Interpolate)
                {
                    m_HalfFloatTargetTickOwnership = m_CachedNetworkManager.ServerTime.Tick;
                }
            }
            else
            {
                // Always set these during initialization for non-authority so we can detect a change in interpolator types
                m_PreviousPositionInterpolationType = PositionInterpolationType;
                m_PreviousRotationInterpolationType = RotationInterpolationType;
                m_PreviousScaleInterpolationType = ScaleInterpolationType;
                m_PreviousPositionLerpSmoothing = PositionLerpSmoothing;
                m_PreviousRotationLerpSmoothing = RotationLerpSmoothing;
                m_PreviousScaleLerpSmoothing = ScaleLerpSmoothing;

                // Non-authority needs to be added to updates for interpolation and applying state purposes
                m_CachedNetworkManager.NetworkTransformRegistration(NetworkObject, forUpdate, true);
                // Remove this instance from the tick update
                DeregisterForTickUpdate(this);
                ResetInterpolatedStateToCurrentAuthoritativeState();
                m_InternalCurrentPosition = currentPosition;
                m_TargetPosition = currentPosition;
                m_InternalCurrentScale = transform.localScale;
                m_TargetScale = transform.localScale;
                m_InternalCurrentRotation = currentRotation;
                m_TargetRotation = currentRotation.eulerAngles;
            }
            OnInitialize(ref m_LocalAuthoritativeNetworkState);
        }

        /// <summary>
        /// Initializes NetworkTransform when spawned and ownership changes.
        /// </summary>
        protected void Initialize()
        {
            InternalInitialization();
        }
        #endregion

        #region PARENTING AND OWNERSHIP
        // This might seem aweful, but when transitioning between two parents in local space we need to
        // catch the moment the transition happens and only apply the special case parenting from one parent
        // to another parent once. Keeping track of the "previous previous" allows us to detect the
        // back and fourth scenario:
        // - No parent (world space)
        // - Parent under NetworkObjectA (world to local)
        // - Parent under NetworkObjectB (local to local) (catch with "previous previous")
        // - Parent under NetworkObjectA (local to local) (catch with "previous previous")
        // - Parent under NetworkObjectB (local to local) (catch with "previous previous")
        private NetworkObject m_PreviousCurrentParent;
        private NetworkObject m_PreviousPreviousParent;
        private void AdjustForChangeInTransformSpace()
        {
            if (SwitchTransformSpaceWhenParented && m_IsFirstNetworkTransform && (m_PositionInterpolator.InLocalSpace != InLocalSpace ||
                m_RotationInterpolator.InLocalSpace != InLocalSpace ||
                (InLocalSpace && m_CurrentNetworkObjectParent && m_PreviousNetworkObjectParent && m_PreviousCurrentParent != m_CurrentNetworkObjectParent && m_PreviousPreviousParent != m_PreviousNetworkObjectParent)))
            {
                var parent = m_CurrentNetworkObjectParent ? m_CurrentNetworkObjectParent : m_PreviousNetworkObjectParent;
                if (parent)
                {
                    // In the event it is a NetworkObject to NetworkObject parenting transfer, we will need to migrate our interpolators
                    // and our current position and rotation to world space relative to the previous parent before converting them to local
                    // space relative to the new parent
                    if (InLocalSpace && m_CurrentNetworkObjectParent && m_PreviousNetworkObjectParent)
                    {
                        m_PreviousCurrentParent = m_CurrentNetworkObjectParent;
                        m_PreviousPreviousParent = m_PreviousNetworkObjectParent;
                        // Convert our current postion and rotation to world space based on the previous parent's transform
                        m_InternalCurrentPosition = m_PreviousNetworkObjectParent.transform.TransformPoint(m_InternalCurrentPosition);
                        m_InternalCurrentRotation = m_PreviousNetworkObjectParent.transform.rotation * m_InternalCurrentRotation;
                        // Convert our current postion and rotation to local space based on the current parent's transform
                        m_InternalCurrentPosition = m_CurrentNetworkObjectParent.transform.InverseTransformPoint(m_InternalCurrentPosition);
                        m_InternalCurrentRotation = Quaternion.Inverse(m_CurrentNetworkObjectParent.transform.rotation) * m_InternalCurrentRotation;
                        // Convert both interpolators to world space based on the previous parent's transform
                        m_PositionInterpolator.ConvertTransformSpace(m_PreviousNetworkObjectParent.transform, false);
                        m_RotationInterpolator.ConvertTransformSpace(m_PreviousNetworkObjectParent.transform, false);
                        // Next, fall into normal transform space conversion of both interpolators to local space based on the current parent's transform
                    }

                    m_PositionInterpolator.ConvertTransformSpace(parent.transform, InLocalSpace);
                    m_RotationInterpolator.ConvertTransformSpace(parent.transform, InLocalSpace);
                }
            }
        }

        /// <inheritdoc/>
        public override void OnLostOwnership()
        {
            base.OnLostOwnership();
        }

        /// <inheritdoc/>
        public override void OnGainedOwnership()
        {
            base.OnGainedOwnership();
        }

        /// <inheritdoc/>
        protected override void OnOwnershipChanged(ulong previous, ulong current)
        {
            // If we were the previous owner or the newly assigned owner then reinitialize
            if (current == m_CachedNetworkManager.LocalClientId || previous == m_CachedNetworkManager.LocalClientId)
            {
                InternalInitialization(true);
            }
            base.OnOwnershipChanged(previous, current);
        }

        internal bool IsNested;
        private List<NetworkObject> m_ParentedChildren = new List<NetworkObject>();

        private bool m_IsFirstNetworkTransform;
        private NetworkObject m_CurrentNetworkObjectParent = null;
        private NetworkObject m_PreviousNetworkObjectParent = null;

        internal void ChildRegistration(NetworkObject child, bool isAdding)
        {
            if (isAdding)
            {
                m_ParentedChildren.Add(child);
            }
            else
            {
                m_ParentedChildren.Remove(child);
            }
        }

        /// <inheritdoc/>
        /// <remarks>
        /// When not using a NetworkRigidbody and using an owner authoritative motion model, you can<br />
        /// improve parenting transitions into and out of world and local space by:<br />
        /// - Disabling <see cref="NetworkObject.SyncOwnerTransformWhenParented"/><br />
        /// - Enabling <see cref="NetworkObject.AllowOwnerToParent"/><br />
        /// - Enabling <see cref="SwitchTransformSpaceWhenParented"/><br />
        /// -- Note: This handles changing from world space to local space for you.<br />
        /// When these settings are applied, transitioning from:<br />
        /// - World space to local space (root-null parent/null to <see cref="NetworkObject"/> parent)
        /// - Local space back to world space (<see cref="NetworkObject"/> parent to root-null parent)
        /// - Local space to local space (<see cref="NetworkObject"/> parent to <see cref="NetworkObject"/> parent)
        /// Will all smoothly transition while interpolation is enabled.
        /// (Does not work if using a <see cref="Rigidbody"/> or <see cref="Rigidbody2D"/> for motion)
        ///
        /// When a parent changes, non-authoritative instances should:<br />
        /// - Apply the resultant position, rotation, and scale from the parenting action.<br />
        /// - Clear interpolators (even if not enabled on this frame)<br />
        /// - Reset the interpolators to the position, rotation, and scale resultant values.<br />
        /// This prevents interpolation visual anomalies and issues during initial synchronization<br />
        /// </remarks>
        public override void OnNetworkObjectParentChanged(NetworkObject parentNetworkObject)
        {
            base.OnNetworkObjectParentChanged(parentNetworkObject);
        }


        internal override void InternalOnNetworkObjectParentChanged(NetworkObject parentNetworkObject)
        {
            // The root NetworkTransform handles tracking any NetworkObject parenting since nested NetworkTransforms (of the same NetworkObject)
            // will never (or rather should never) change their world space once spawned.
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
            // Handling automatic transform space switching can only be applied to NetworkTransforms that don't use the Rigidbody for motion
            if (!m_UseRigidbodyForMotion && SwitchTransformSpaceWhenParented)
#else
            if (SwitchTransformSpaceWhenParented)
#endif
            {
                m_PreviousNetworkObjectParent = m_CurrentNetworkObjectParent;
                m_CurrentNetworkObjectParent = parentNetworkObject;
                if (m_IsFirstNetworkTransform)
                {
                    if (CanCommitToTransform)
                    {
                        InLocalSpace = m_CurrentNetworkObjectParent != null;
                    }
                    if (m_PreviousNetworkObjectParent && m_PreviousNetworkObjectParent.NetworkTransforms != null && m_PreviousNetworkObjectParent.NetworkTransforms.Count > 0)
                    {
                        // Always deregister with the first NetworkTransform in the list
                        m_PreviousNetworkObjectParent.NetworkTransforms[0].ChildRegistration(NetworkObject, false);
                    }
                    if (m_CurrentNetworkObjectParent && m_CurrentNetworkObjectParent.NetworkTransforms != null && m_CurrentNetworkObjectParent.NetworkTransforms.Count > 0)
                    {
                        // Always register with the first NetworkTransform in the list
                        m_CurrentNetworkObjectParent.NetworkTransforms[0].ChildRegistration(NetworkObject, true);
                    }
                }
            }
            else
            {
                // Keep the same legacy behaviour for compatibility purposes
                if (!CanCommitToTransform)
                {
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
                    var position = m_UseRigidbodyForMotion ? m_NetworkRigidbodyInternal.GetPosition() : GetSpaceRelativePosition();
                    var rotation = m_UseRigidbodyForMotion ? m_NetworkRigidbodyInternal.GetRotation() : GetSpaceRelativeRotation();
#else
                    var position = GetSpaceRelativePosition();
                    var rotation = GetSpaceRelativeRotation();
#endif
                    m_TargetPosition = m_InternalCurrentPosition = position;
                    m_InternalCurrentRotation = rotation;
                    m_TargetRotation = m_InternalCurrentRotation.eulerAngles;
                    m_TargetScale = m_InternalCurrentScale = GetScale();

                    if (Interpolate)
                    {
                        m_ScaleInterpolator.Clear();
                        m_PositionInterpolator.Clear();
                        m_RotationInterpolator.Clear();

                        // Always use NetworkManager here as this can be invoked prior to spawning
                        var tempTime = new NetworkTime(NetworkManager.NetworkConfig.TickRate, NetworkManager.ServerTime.Tick).Time;
                        UpdatePositionInterpolator(m_InternalCurrentPosition, tempTime, true);
                        m_ScaleInterpolator.ResetTo(m_InternalCurrentScale, tempTime);
                        m_RotationInterpolator.ResetTo(m_InternalCurrentRotation, tempTime);
                    }
                }
            }
            base.InternalOnNetworkObjectParentChanged(parentNetworkObject);
        }
        #endregion

        #region API STATE UPDATE METHODS
        /// <summary>
        /// Directly sets a state on the authoritative transform.
        /// Owner clients can directly set the state on a server authoritative transform
        /// This will override any changes made previously to the transform
        /// This isn't resistant to network jitter. Server side changes due to this method won't be interpolated.
        /// The parameters are broken up into pos / rot / scale on purpose so that the caller can perturb
        ///  just the desired one(s)
        /// </summary>
        /// <param name="posIn">new position to move to. Can be null</param>
        /// <param name="rotIn">new rotation to rotate to. Can be null</param>
        /// <param name="scaleIn">new scale to scale to. Can be null</param>
        /// <param name="teleportDisabled">When true (the default) the <see cref="NetworkObject"/> will not be teleported and, if enabled, will interpolate. When false the <see cref="NetworkObject"/> will teleport/apply the parameters provided immediately.</param>
        /// <exception cref="Exception">Thrown when the function is called on non-spawned object or, when it's called without proper authority</exception>
        public void SetState(Vector3? posIn = null, Quaternion? rotIn = null, Vector3? scaleIn = null, bool teleportDisabled = true)
        {
            if (!IsSpawned)
            {
                NetworkLog.LogError($"Cannot commit transform when not spawned!");
                return;
            }

            // Only the server or the owner is allowed to commit a transform
            if (!IsServer && !IsOwner)
            {
                var errorMessage = gameObject != NetworkObject.gameObject ?
                    $"Non-authority instance of {NetworkObject.gameObject.name} is trying to commit a transform on {gameObject.name}!" :
                    $"Non-authority instance of {NetworkObject.gameObject.name} is trying to commit a transform!";
                NetworkLog.LogError(errorMessage);
                return;
            }
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
            var position = m_UseRigidbodyForMotion ? m_NetworkRigidbodyInternal.GetPosition() : GetSpaceRelativePosition();
            var rotation = m_UseRigidbodyForMotion ? m_NetworkRigidbodyInternal.GetRotation() : GetSpaceRelativeRotation();
#else
            var position = GetSpaceRelativePosition();
            var rotation = GetSpaceRelativeRotation();
#endif
            Vector3 pos = posIn == null ? position : posIn.Value;
            Quaternion rot = rotIn == null ? rotation : rotIn.Value;
            Vector3 scale = scaleIn == null ? transform.localScale : scaleIn.Value;

            if (!CanCommitToTransform)
            {
                // Preserving the ability for owner authoritative mode to accept state changes from server
                if (IsServer)
                {
                    m_ClientIds[0] = OwnerClientId;
                    m_ClientRpcParams.Send.TargetClientIds = m_ClientIds;
                    SetStateClientRpc(pos, rot, scale, !teleportDisabled, m_ClientRpcParams);
                }
                else // Preserving the ability for server authoritative mode to accept state changes from owner
                {
                    SetStateServerRpc(pos, rot, scale, !teleportDisabled);
                }
                return;
            }

            SetStateInternal(pos, rot, scale, !teleportDisabled);
        }

        /// <summary>
        /// Authoritative only method
        /// Sets the internal state (teleporting or just set state) of the authoritative
        /// transform directly.
        /// </summary>
        private void SetStateInternal(Vector3 pos, Quaternion rot, Vector3 scale, bool shouldTeleport)
        {
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
            if (m_UseRigidbodyForMotion)
            {
                m_NetworkRigidbodyInternal.SetPosition(pos);
                m_NetworkRigidbodyInternal.SetRotation(rot);
            }
            else
#endif
            {
                if (InLocalSpace)
                {
                    transform.SetLocalPositionAndRotation(pos, rot);
                }
                else
                {
                    transform.SetPositionAndRotation(pos, rot);
                }
            }

            transform.localScale = scale;
            m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame = shouldTeleport;

            var transformToCommit = transform;

            // Explicit set states are cumulative during a fractional tick period of time (i.e. each SetState invocation will
            // update the axial deltas to whatever changes are applied). As such, we need to preserve the dirty and explicit
            // state flags.
            var stateWasDirty = m_LocalAuthoritativeNetworkState.IsDirty;
            var explicitState = m_LocalAuthoritativeNetworkState.ExplicitSet;

            // Apply any delta states to the m_LocalAuthoritativeNetworkState
            var isDirty = CheckForStateChange(ref m_LocalAuthoritativeNetworkState, ref transformToCommit);

            // If we were dirty and the explicit state was set (prior to checking for deltas) or the current explicit state is dirty,
            // then we set the explicit state flag.
            m_LocalAuthoritativeNetworkState.ExplicitSet = (stateWasDirty && explicitState) || isDirty;

            // If the current explicit set flag is set, then we are dirty. This assures if more than one explicit set state is invoked
            // in between a fractional tick period and the current explicit set state did not find any deltas that we preserve any
            // previous dirty state.
            m_LocalAuthoritativeNetworkState.IsDirty = m_LocalAuthoritativeNetworkState.ExplicitSet;
        }

        /// <summary>
        /// Invoked by <see cref="SetState"/>, allows a non-owner server to update the transform state
        /// </summary>
        /// <remarks>
        /// Continued support for client-driven server authority model
        /// </remarks>
        [ClientRpc]
        private void SetStateClientRpc(Vector3 pos, Quaternion rot, Vector3 scale, bool shouldTeleport, ClientRpcParams clientRpcParams = default)
        {
            // Server dictated state is always applied
            SetStateInternal(pos, rot, scale, shouldTeleport);
        }

        /// <summary>
        /// Invoked by <see cref="SetState"/>, allows an owner-client update the transform state
        /// </summary>
        /// <remarks>
        /// Continued support for client-driven server authority model
        /// </remarks>
        [ServerRpc]
        private void SetStateServerRpc(Vector3 pos, Quaternion rot, Vector3 scale, bool shouldTeleport)
        {
            // server has received this RPC request to move change transform. give the server a chance to modify or even reject the move
            if (OnClientRequestChange != null)
            {
                (pos, rot, scale) = OnClientRequestChange(pos, rot, scale);
            }
            SetStateInternal(pos, rot, scale, shouldTeleport);
        }

        /// <summary>
        /// Teleport an already spawned object to the given values without interpolating.
        /// </summary>
        /// <remarks>
        /// This is intended to be used on already spawned objects, for setting the position of a dynamically spawned object just apply the transform values prior to spawning. <br />
        /// With player objects, override the <see cref="OnNetworkSpawn"/> method and have the authority make adjustments to the transform prior to invoking base.OnNetworkSpawn.
        /// </remarks>
        /// <param name="newPosition">new position to move to.</param>
        /// <param name="newRotation">new rotation to rotate to.</param>
        /// <param name="newScale">new scale to scale to.</param>
        /// <exception cref="Exception">Thrown when called from a non-authoritative context (client without ownership)</exception>
        public void Teleport(Vector3 newPosition, Quaternion newRotation, Vector3 newScale)
        {
            if (!CanCommitToTransform)
            {
                throw new Exception("Teleporting on non-authoritative side is not allowed!");
            }

            // Teleporting now is as simple as setting the internal state and passing the teleport flag
            SetStateInternal(newPosition, newRotation, newScale, true);
        }
        #endregion

        #region UPDATES AND AUTHORITY CHECKS
        private NetworkTransformTickRegistration m_NetworkTransformTickRegistration;

#if DEBUG_LINEARBUFFER
#if UNITY_EDITOR
        // For debugging purposes
        public struct BufferEntry
        {
            public double TimeSent;
            public Vector3 Position;
        }
        public struct NTPositionStats
        {
            public int FrameCount;
            public int FixedFrameCount;
            public int FixedUpdatesPerFrameCount;
            public int TimeSynchCount;
            public int Tick;
            public double Time;
            public double TicksAgoTime;
            public int BufferCount;
            public int TickMeasured;
            public float LerpT;
            public double DeltaTime;
            public double MaxDeltaTime;
            public double TimeSent;
            public double TimeToTargetValue;
            public Vector3 PreviousValue;
            public Vector3 NextValue;
            public Vector3 CurrentValue;
            public Vector3 TargetValue;

            public List<BufferEntry> Buffer;
        }

        public Dictionary<int, List<NTPositionStats>> PositionStats = new Dictionary<int, List<NTPositionStats>>();
        public bool GatherStats;
        private int m_LastTimeSyncCount;

        public void ClearStats()
        {
            PositionStats.Clear();
        }

        public BufferedLinearInterpolatorVector3 GetPositionInterpolator()
        {
            return m_PositionInterpolator;
        }

        public BufferedLinearInterpolatorQuaternion GetRotationInterpolator()
        {
            return m_RotationInterpolator;
        }
#endif
        public int GetPositionBufferCount()
        {
            return m_PositionInterpolator.m_BufferQueue.Count;
        }

        public double GetPositionCurrentStateTimeToTarget()
        {
            return m_PositionInterpolator.InterpolateState.TimeToTargetValue;
        }

        public double GetPositionLerpT()
        {
            return m_PositionInterpolator.InterpolateState.LerpT;
        }

        public double GetPositionLastRemainingTime()
        {
            return m_PositionInterpolator.InterpolateState.LastRemainingTime;
        }
#else
        internal BufferedLinearInterpolatorVector3 GetPositionInterpolator()
        {
            return m_PositionInterpolator;
        }

        internal BufferedLinearInterpolatorQuaternion GetRotationInterpolator()
        {
            return m_RotationInterpolator;
        }
#endif

        // Non-Authority
        private void UpdateInterpolation()
        {
            AdjustForChangeInTransformSpace();
            // Select the time system relative to the type of NetworkManager instance.
            var timeSystem = m_CachedNetworkManager.IsServer ? m_CachedNetworkManager.ServerTime : m_CachedNetworkManager.LocalTime;
            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;
#else
            var cachedDeltaTime = m_CachedNetworkManager.RealTimeProvider.DeltaTime;
#endif
            // Optional user defined tick offset to be used to push the "render time" (the time that will be used to determine if a state update is available)
            // back in order to provide more room for the interpolator to interpolate towards when latency conditions are impacting the frequency that state
            // updates are received.
            var tickLatency = Mathf.Max(1, m_CachedNetworkManager.NetworkTimeSystem.TickLatency + InterpolationBufferTickOffset);

            // If using an owner authoritative motion model
            if (!IsServerAuthoritative())
            {
                // and if we are in a client-server topology (including DAHost)
                if (!m_CachedNetworkManager.DistributedAuthorityMode ||
                    (m_CachedNetworkManager.DistributedAuthorityMode && !m_CachedNetworkManager.CMBServiceConnection))
                {
                    // If this instance belongs to another client (i.e. not the server/host), then add 1 to our tick latency.
                    if (!m_CachedNetworkManager.IsServer && !NetworkObject.IsOwnedByServer)
                    {
                        // Account for the 2xRTT with owner authoritative
                        tickLatency += 1;
                    }
                }
            }

            // Note: This is for the legacy lerp type in order to maintain the same end result for any games under development that have tuned their
            // project's to match the legacy lerp's end result.
            var cachedRenderTime = 0.0;
            if (PositionInterpolationType == InterpolationTypes.LegacyLerp || RotationInterpolationType == InterpolationTypes.LegacyLerp || ScaleInterpolationType == InterpolationTypes.LegacyLerp)
            {
                // Since InterpolationBufferTickOffset defaults to zero, this should not impact exist projects but still provides users with the ability to tweak
                // their ticks ago time.
                var ticksAgo = (!IsServerAuthoritative() && !IsServer ? 2 : 1) + InterpolationBufferTickOffset;
                cachedRenderTime = timeSystem.TimeTicksAgo(ticksAgo).Time;
            }

            // Get the tick latency (ticks ago) as time (in the past) to process state updates in the queue.
            var tickLatencyAsTime = timeSystem.TimeTicksAgo(tickLatency).Time;

#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
            // If using rigid body for motion, then we need to increment
            // our tick latency based on the number of times FixedUpdate
            // is executed.
            if (m_UseRigidbodyForMotion)
            {
                tickLatencyAsTime += m_FixedTimeFrameDelta;
                currentTime += m_FixedTimeFrameDelta;
            }
#endif

            // Smooth dampening and extrapolation specific:
            // We clamp between the tick rate frequency and the tick latency x tick rate frequency
            var minDeltaTime = timeSystem.FixedDeltaTimeAsDouble;

            // Maximum delta time is the maximum time we will lerp between values. If the time exceeds this due to extreme
            // latency then the value's interpolation rate will be accelerated to reach the goal and continue interpolating
            // the next state updates.
            var maxDeltaTime = tickLatency * minDeltaTime;

            // Now only update the interpolators for the portions of the transform being synchronized
            if (SynchronizePosition)
            {
                if (PositionLerpSmoothing)
                {
                    m_PositionInterpolator.MaximumInterpolationTime = PositionMaxInterpolationTime;
                }
                m_PositionInterpolator.LerpSmoothEnabled = PositionLerpSmoothing;

                // If either of these two position interpolation related values have changed, then reset the current state being interpolated.
                if (m_PreviousPositionInterpolationType != PositionInterpolationType || m_PreviousPositionLerpSmoothing != PositionLerpSmoothing)
                {
                    m_PreviousPositionInterpolationType = PositionInterpolationType;
                    m_PreviousPositionLerpSmoothing = PositionLerpSmoothing;
                    m_PositionInterpolator.ResetCurrentState();
                }

                if (PositionInterpolationType == InterpolationTypes.LegacyLerp)
                {
                    m_PositionInterpolator.Update(cachedDeltaTime, cachedRenderTime, currentTime);
                }
                else
                {
                    m_PositionInterpolator.Update(cachedDeltaTime, tickLatencyAsTime, minDeltaTime, maxDeltaTime,
                        PositionInterpolationType == InterpolationTypes.Lerp);
                }
            }

            if (SynchronizeRotation)
            {
                if (RotationLerpSmoothing)
                {
                    m_RotationInterpolator.MaximumInterpolationTime = RotationMaxInterpolationTime;
                }

                m_RotationInterpolator.LerpSmoothEnabled = RotationLerpSmoothing;

                // If either of these two rotation interpolation related values have changed, then reset the current state being interpolated.
                if (m_PreviousRotationInterpolationType != RotationInterpolationType || m_PreviousRotationLerpSmoothing != RotationLerpSmoothing)
                {
                    m_PreviousRotationInterpolationType = RotationInterpolationType;
                    m_PreviousRotationLerpSmoothing = RotationLerpSmoothing;
                    m_RotationInterpolator.ResetCurrentState();
                }
                // When using half precision Lerp towards the target rotation.
                // When using full precision Slerp towards the target rotation.
                /// <see cref="BufferedLinearInterpolatorQuaternion.IsSlerp"/>
                m_RotationInterpolator.IsSlerp = !UseHalfFloatPrecision;
                if (RotationInterpolationType == InterpolationTypes.LegacyLerp)
                {
                    m_RotationInterpolator.Update(cachedDeltaTime, cachedRenderTime, currentTime);
                }
                else
                {
                    m_RotationInterpolator.Update(cachedDeltaTime, tickLatencyAsTime, minDeltaTime, maxDeltaTime,
                        RotationInterpolationType == InterpolationTypes.Lerp);
                }
            }

            if (SynchronizeScale)
            {
                if (ScaleLerpSmoothing)
                {
                    m_ScaleInterpolator.MaximumInterpolationTime = ScaleMaxInterpolationTime;
                }

                m_ScaleInterpolator.LerpSmoothEnabled = ScaleLerpSmoothing;

                // If either of these two rotation interpolation related values have changed, then reset the current state being interpolated.
                if (m_PreviousScaleInterpolationType != ScaleInterpolationType || m_PreviousScaleLerpSmoothing != ScaleLerpSmoothing)
                {
                    m_PreviousScaleInterpolationType = ScaleInterpolationType;
                    m_PreviousScaleLerpSmoothing = ScaleLerpSmoothing;
                    m_ScaleInterpolator.ResetCurrentState();
                }

                if (ScaleInterpolationType == InterpolationTypes.LegacyLerp)
                {
                    m_ScaleInterpolator.Update(cachedDeltaTime, cachedRenderTime, currentTime);
                }
                else
                {
                    m_ScaleInterpolator.Update(cachedDeltaTime, tickLatencyAsTime, minDeltaTime, maxDeltaTime,
                        ScaleInterpolationType == InterpolationTypes.Lerp);
                }
            }

#if DEBUG_LINEARBUFFER && UNITY_EDITOR
            // For debugging purposes
            if (GatherStats)
            {
                if (!m_PositionInterpolator.InterpolateState.Target.HasValue)
                {
                    return;
                }
                var posStats = new NTPositionStats()
                {
                    FrameCount = m_FrameCount,
                    FixedFrameCount = m_FixedFrameCount,
                    FixedUpdatesPerFrameCount = m_FixedUpdatesPerFrameCount,
                    TimeSynchCount = m_CachedNetworkManager.NetworkTimeSystem.SyncCount,
                    Tick = timeSystem.Tick,
                    Time = timeSystem.Time,
                    TicksAgoTime = tickLatencyAsTime,
                    BufferCount = m_PositionInterpolator.m_BufferQueue.Count,
                    TickMeasured = (int)Math.Round(m_PositionInterpolator.InterpolateState.Target.Value.TimeSent / timeSystem.FixedDeltaTimeAsDouble, MidpointRounding.AwayFromZero),
                    LerpT = m_PositionInterpolator.InterpolateState.LerpT,
                    DeltaTime = m_PositionInterpolator.InterpolateState.DeltaTime,
                    MaxDeltaTime = m_PositionInterpolator.InterpolateState.MaxDeltaTime,
                    TimeSent = m_PositionInterpolator.InterpolateState.Target.Value.TimeSent,
                    TimeToTargetValue = m_PositionInterpolator.InterpolateState.TimeToTargetValue,
                    PreviousValue = m_PositionInterpolator.InterpolateState.PreviousValue,
                    NextValue = m_PositionInterpolator.InterpolateState.NextValue,
                    CurrentValue = m_PositionInterpolator.InterpolateState.CurrentValue,
                    TargetValue = m_PositionInterpolator.InterpolateState.Target.Value.Item,
                    Buffer = new List<BufferEntry>(),
                };

                foreach (var entry in m_PositionInterpolator.m_BufferQueue)
                {
                    posStats.Buffer.Add(new BufferEntry()
                    {
                        TimeSent = entry.TimeSent,
                        Position = entry.Item,
                    });
                }
                if (!PositionStats.ContainsKey(posStats.TickMeasured))
                {
                    PositionStats.Add(posStats.TickMeasured, new List<NTPositionStats>());
                }
                PositionStats[posStats.TickMeasured].Add(posStats);
            }
#endif
        }

        /// <inheritdoc cref="INetworkUpdateSystem.OnUpdate"/>
        /// <remarks>
        /// If you override this method, be sure that:
        /// - Non-authority always invokes this base class method.
        /// </remarks>
        public virtual void OnUpdate()
        {
            // If not spawned or this instance has authority, exit early
#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
            if (!IsSpawned || CanCommitToTransform || m_UseRigidbodyForMotion)
#else
            if (!IsSpawned || CanCommitToTransform)
#endif
            {
                return;
            }

            // Update interpolation
            if (Interpolate)
            {
                UpdateInterpolation();
            }

            // Apply the current authoritative state
            ApplyAuthoritativeState();
        }

#if COM_UNITY_MODULES_PHYSICS || COM_UNITY_MODULES_PHYSICS2D
#if DEBUG_LINEARBUFFER && UNITY_EDITOR
        // For debugging purposes
        private int m_FrameCount = 0;
        private int m_FixedFrameCount = 0;
        private int m_FixedUpdatesPerFrameCount = 0;
#endif

        // This is used during fixed update in case there are multiple fixed update passes without any frame pass.
        private float m_FixedTimeFrameDelta;

        // The fixed time (static time step) value for the current frame (in the event it is changed at runtime).
        private float m_DeltaFixedUpdateCached;

        /// <summary>
        /// Resets the total fixed update time passed.
        /// This handles dealing with multiple passes within FixedUpdate and interpolation.
        /// </summary>
        internal void ResetFixedTimeDelta()
        {
            // If not spawned or this instance has authority, exit early
            if (!m_UseRigidbodyForMotion || !IsSpawned || CanCommitToTransform)
            {
                return;
            }

            // Get the current fixed delta time (used in fixed upate)
            m_DeltaFixedUpdateCached = m_CachedNetworkManager.RealTimeProvider.FixedDeltaTime;
            // Reset the total fixed update time (increased each time physics invokes FixedUpdate within the same frame)
            m_FixedTimeFrameDelta = 0.0f;
#if DEBUG_LINEARBUFFER && UNITY_EDITOR
            // For debugging purposes
            m_FrameCount++;
            m_FixedUpdatesPerFrameCount = 0;
#endif
        }

        /// <summary>
        /// When paired with a NetworkRigidbody and NetworkRigidbody.UseRigidBodyForMotion is enabled,
        /// this will be invoked during <see cref="NetworkRigidbody.FixedUpdate"/>.
        /// </summary>
        public virtual void OnFixedUpdate()
        {
            // If not spawned or this instance has authority, exit early
            if (!m_UseRigidbodyForMotion || !IsSpawned || CanCommitToTransform)
            {
                return;
            }

            m_NetworkRigidbodyInternal.WakeIfSleeping();

#if DEBUG_LINEARBUFFER && UNITY_EDITOR
            // For debugging purposes
            m_FixedFrameCount++;
            m_FixedUpdatesPerFrameCount++;
#endif

            // Update interpolation when enabled
            if (Interpolate)
            {
                UpdateInterpolation();
            }

            // Apply the current authoritative state
            ApplyAuthoritativeState();

            // Increment the time passed based on our current fixed update rate in case
            // FixedUpdate is invoked more than once within a single frame.
            m_FixedTimeFrameDelta += m_DeltaFixedUpdateCached;
        }
#endif

        /// <summary>
        /// Determines whether the <see cref="NetworkTransform"/> is <see cref="AuthorityModes.Server"/> or <see cref="AuthorityModes.Owner"/> based on the <see cref="AuthorityMode"/> property.
        /// You can override this method to control this logic.
        /// </summary>
        /// <returns><see cref="true"/> or <see cref="false"/></returns>
        protected virtual bool OnIsServerAuthoritative()
        {
            return AuthorityMode == AuthorityModes.Server;
        }

        /// <summary>
        /// Method to determine if this <see cref="NetworkTransform"/> instance is owner or server authoritative.
        /// </summary>
        /// <remarks>
        /// When using a <see cref="NetworkTopologyTypes.DistributedAuthority"/> <see cref="NetworkConfig.NetworkTopology"/>, this will always be viewed as a <see cref="AuthorityModes.Owner"/> authoritative motion model.
        /// </remarks>
        /// <returns><see cref="true"/> or <see cref="false"/></returns>
        public bool IsServerAuthoritative()
        {
            if (m_CachedNetworkManager && m_CachedNetworkManager.DistributedAuthorityMode)
            {
                return false;
            }
            else
            {
                return OnIsServerAuthoritative();
            }
        }
        #endregion

        #region MESSAGE HANDLING

        internal NetworkTransformState InboundState = new NetworkTransformState();
        internal NetworkTransformState OutboundState
        {
            get
            {
                return m_LocalAuthoritativeNetworkState;
            }
        }

        /// <summary>
        /// Invoked by <see cref="NetworkTransformMessage"/> to update the transform state
        /// </summary>
        /// <param name="networkTransformState"></param>
        internal void TransformStateUpdate(ulong senderId)
        {
            if (CanCommitToTransform)
            {
                // TODO: Investigate where this state should be applied or just discarded.
                // For now, discard the state if we assumed ownership.
                return;
            }
            // Store the previous/old state
            m_OldState = m_LocalAuthoritativeNetworkState;

            // Assign the new incoming state
            m_LocalAuthoritativeNetworkState = InboundState;

            // Apply the state update
            OnNetworkStateChanged(m_OldState, m_LocalAuthoritativeNetworkState);
        }

        // Used to send outbound messages
        private NetworkTransformMessage m_OutboundMessage = new NetworkTransformMessage();


        internal int SerializeMessage(FastBufferWriter writer, int targetVersion)
        {
            var networkObject = NetworkObject;
            var position = writer.Position;
            BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
            BytePacker.WriteValueBitPacked(writer, (int)NetworkBehaviourId);
            writer.WriteNetworkSerializable(m_LocalAuthoritativeNetworkState);
            if (m_CachedNetworkManager.DistributedAuthorityMode)
            {
                BytePacker.WriteValuePacked(writer, networkObject.Observers.Count - 1);

                foreach (var targetId in networkObject.Observers)
                {
                    if (OwnerClientId == targetId)
                    {
                        continue;
                    }
                    BytePacker.WriteValuePacked(writer, targetId);
                }
            }
            return writer.Position - position;
        }

        /// <summary>
        /// Invoked by the authoritative instance to sends a <see cref="NetworkTransformMessage"/> containing the <see cref="NetworkTransformState"/>
        /// </summary>
        private void UpdateTransformState()
        {
            if (m_CachedNetworkManager.ShutdownInProgress || (m_CachedNetworkManager.DistributedAuthorityMode && !m_CachedNetworkManager.CMBServiceConnection && m_CachedNetworkObject.Observers.Count - 1 == 0))
            {
                return;
            }

            bool isServerAuthoritative = IsServerAuthoritative();
            if (isServerAuthoritative && !IsServer)
            {
                Debug.LogError($"Server authoritative {nameof(NetworkTransform)} can only be updated by the server!");
            }
            else if (!isServerAuthoritative && !IsServer && !IsOwner)
            {
                Debug.LogError($"Owner authoritative {nameof(NetworkTransform)} can only be updated by the owner!");
            }
            var customMessageManager = m_CachedNetworkManager.CustomMessagingManager;
            m_OutboundMessage.NetworkTransform = this;

            // Determine what network delivery method to use:
            // When to send reliable packets:
            // - If UsUnrealiable is not enabled
            // - If teleporting or synchronizing
            // - If sending an UnrealiableFrameSync or synchronizing the base position of the NetworkDeltaPosition
            var networkDelivery = !UseUnreliableDeltas || m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame || m_LocalAuthoritativeNetworkState.IsSynchronizing
                || m_LocalAuthoritativeNetworkState.UnreliableFrameSync || m_LocalAuthoritativeNetworkState.SynchronizeBaseHalfFloat
                ? NetworkDelivery.ReliableSequenced : NetworkDelivery.UnreliableSequenced;

            // Server-host-dahost always sends updates to all clients (but itself)
            if (IsServer)
            {
                var clientCount = m_CachedNetworkManager.ConnectionManager.ConnectedClientsList.Count;
                for (int i = 0; i < clientCount; i++)
                {
                    var clientId = m_CachedNetworkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
                    if (NetworkManager.ServerClientId == clientId)
                    {
                        continue;
                    }
                    if (!NetworkObject.Observers.Contains(clientId))
                    {
                        continue;
                    }
                    NetworkManager.MessageManager.SendMessage(ref m_OutboundMessage, networkDelivery, clientId);
                }
            }
            else
            {
                // Clients (owner authoritative) send messages to the server-host
                NetworkManager.MessageManager.SendMessage(ref m_OutboundMessage, networkDelivery, NetworkManager.ServerClientId);
            }
            m_LocalAuthoritativeNetworkState.LastSerializedSize = m_OutboundMessage.BytesWritten;
        }
        #endregion

        #region NETWORK TICK REGISTRATOIN AND HANDLING
        private static Dictionary<NetworkManager, NetworkTransformTickRegistration> s_NetworkTickRegistration = new Dictionary<NetworkManager, NetworkTransformTickRegistration>();

        internal static void UpdateNetworkTick(NetworkManager networkManager)
        {
            if (s_NetworkTickRegistration.ContainsKey(networkManager))
            {
                s_NetworkTickRegistration[networkManager].TickUpdate();
            }
        }

        /// <summary>
        /// Adjusts the over-all tick offset (i.e. how many ticks ago) and how wide of a maximum delta time will be used for the
        /// various <see cref="InterpolationTypes"/>.
        /// </summary>
        /// <remarks>
        /// Note: You can adjust this value during runtime. Increasing this value will set non-authority instances that much further
        /// behind the authority instance but will increase the number of state updates to be processed. Increasing this can be useful
        /// under higher latency conditions.<br />
        /// The default value is 1 tick (plus the tick latency). When running on a local network, reducing this to 0 is recommended.<br />
        /// <see cref="NetworkTimeSystem.TickLatency"/>
        /// </remarks>
        public static int InterpolationBufferTickOffset = 0;
        internal static float GetTickLatency(NetworkManager networkManager)
        {
            if (networkManager.IsListening)
            {
                return (float)(networkManager.NetworkTimeSystem.TickLatency + InterpolationBufferTickOffset + networkManager.LocalTime.TickOffset);
            }
            return 0;
        }

        /// <summary>
        /// Returns the number of ticks (fractional) a client is latent relative
        /// to its current averaged RTT.
        /// </summary>
        /// <remarks>
        /// Only valid on clients.
        /// </remarks>
        /// <returns>Returns the tick latency and local offset in seconds and as a float value.</returns>
        public static float GetTickLatency()
        {
            return GetTickLatency(NetworkManager.Singleton);
        }

        internal static float GetTickLatencyInSeconds(NetworkManager networkManager)
        {
            if (networkManager.IsListening)
            {
                return (float)networkManager.LocalTime.TimeTicksAgo(networkManager.NetworkTimeSystem.TickLatency + InterpolationBufferTickOffset).Time;
            }
            return 0f;
        }

        /// <summary>
        /// Returns the tick latency in seconds (typically fractional)
        /// </summary>
        /// <returns>Returns the current tick latency in seconds as a float value.</returns>
        public static float GetTickLatencyInSeconds()
        {
            return GetTickLatencyInSeconds(NetworkManager.Singleton);
        }

        private static void RemoveTickUpdate(NetworkManager networkManager)
        {
            s_NetworkTickRegistration.Remove(networkManager);
        }

        /// <summary>
        /// Having the tick update once and cycling through registered instances to update is evidently less processor
        /// intensive than having each instance subscribe and update individually.
        /// </summary>
        internal class NetworkTransformTickRegistration
        {
            private NetworkManager m_NetworkManager;
            public HashSet<NetworkTransform> NetworkTransforms = new HashSet<NetworkTransform>();

            private int m_LastTick;
            private void OnNetworkManagerStopped(bool value)
            {
                Remove();
            }

            public void Remove()
            {
                NetworkTransforms.Clear();
                RemoveTickUpdate(m_NetworkManager);
            }

            /// <summary>
            /// Invoked once per network tick, this will update any registered
            /// authority instances.
            /// </summary>
            internal void TickUpdate()
            {
                // TODO FIX: The local NetworkTickSystem can invoke with the same network tick as before
                if (CurrentTick <= m_LastTick)
                {
                    return;
                }
                foreach (var networkTransform in NetworkTransforms)
                {
                    if (networkTransform.IsSpawned)
                    {
                        networkTransform.OnNetworkTick();
                    }
                }
                m_LastTick = CurrentTick;
            }
            public NetworkTransformTickRegistration(NetworkManager networkManager)
            {
                m_NetworkManager = networkManager;
                if (networkManager.IsServer)
                {
                    networkManager.OnServerStopped += OnNetworkManagerStopped;
                }
                else
                {
                    networkManager.OnClientStopped += OnNetworkManagerStopped;
                }
            }
        }
        private static int s_TickSynchPosition;
        private int m_NextTickSync;

        internal void RegisterForTickSynchronization()
        {
            s_TickSynchPosition++;
            m_NextTickSync = NetworkManager.ServerTime.Tick + (s_TickSynchPosition % (int)NetworkManager.NetworkConfig.TickRate);
        }

        private static void RegisterNetworkManagerForTickUpdate(NetworkManager networkManager)
        {
            if (!s_NetworkTickRegistration.ContainsKey(networkManager))
            {
                s_NetworkTickRegistration.Add(networkManager, new NetworkTransformTickRegistration(networkManager));
            }
        }

        /// <summary>
        /// Will register the NetworkTransform instance for the single tick update entry point.
        /// If a NetworkTransformTickRegistration has not yet been registered for the NetworkManager
        /// instance, then create an entry.
        /// </summary>
        /// <param name="networkTransform"></param>
        private static void RegisterForTickUpdate(NetworkTransform networkTransform)
        {

            if (!networkTransform.NetworkManager.DistributedAuthorityMode && !s_NetworkTickRegistration.ContainsKey(networkTransform.NetworkManager))
            {
                s_NetworkTickRegistration.Add(networkTransform.NetworkManager, new NetworkTransformTickRegistration(networkTransform.NetworkManager));
            }

            networkTransform.RegisterForTickSynchronization();
            s_NetworkTickRegistration[networkTransform.NetworkManager].NetworkTransforms.Add(networkTransform);
        }

        /// <summary>
        /// If a NetworkTransformTickRegistration exists for the NetworkManager instance, then this will
        /// remove the NetworkTransform instance from the single tick update entry point.
        /// </summary>
        /// <param name="networkTransform"></param>
        private static void DeregisterForTickUpdate(NetworkTransform networkTransform)
        {
            if (networkTransform.NetworkManager == null)
            {
                return;
            }
            if (s_NetworkTickRegistration.ContainsKey(networkTransform.NetworkManager))
            {
                s_NetworkTickRegistration[networkTransform.NetworkManager].NetworkTransforms.Remove(networkTransform);
                if (!networkTransform.NetworkManager.DistributedAuthorityMode && s_NetworkTickRegistration[networkTransform.NetworkManager].NetworkTransforms.Count == 0)
                {
                    var registrationEntry = s_NetworkTickRegistration[networkTransform.NetworkManager];
                    registrationEntry.Remove();
                }
            }
        }
        #endregion
    }

    internal interface INetworkTransformLogStateEntry
    {
        void AddLogEntry(NetworkTransform.NetworkTransformState networkTransformState, ulong targetClient, bool preUpdate = false);
    }
}