Merge branch 'sam/feature/client-network-transform' into sam/feature/transform-teleport

* sam/feature/client-network-transform:
  fixing issue with tests where we had tickrate set to 0. Removed singleton reference for this, since multiinstance tests don't like them :(
  delegate to allow server to override client changes
  work on setDelta
  feat: NetworkAnimator and ClientNetworkAnimator (#1191)

# Conflicts:
#	com.unity.netcode.gameobjects/Components/NetworkTransform.cs

Author: SamuelBellomo

com.unity.netcode.gameobjects/Components/NetworkAnimator.cs

@@ -14,6 +14,9 @@ namespace Unity.Netcode.Components
     [DefaultExecutionOrder(100000)] // this is needed to catch the update time after the transform was updated by user scripts
     public class NetworkTransform : NetworkBehaviour
     {
+        public delegate (Vector3 pos, Quaternion rotOut, Vector3 scale) OnClientRequestChangeDelegate(Vector3 pos, Quaternion rot, Vector3 scale);
+        public OnClientRequestChangeDelegate OnClientRequestChange;
+
         internal struct NetworkTransformState : INetworkSerializable
         {
             private const int k_InLocalSpaceBit = 0;
@@ -503,6 +506,8 @@ private void ApplyInterpolatedNetworkStateToTransform(NetworkTransformState netw
             m_PrevNetworkState = networkState;
 
             var interpolatedPosition = InLocalSpace ? transformToUpdate.localPosition : transformToUpdate.position;
+
+            // todo: we should store network state w/ quats vs. euler angles
             var interpolatedRotAngles = InLocalSpace ? transformToUpdate.localEulerAngles : transformToUpdate.eulerAngles;
             var interpolatedScale = InLocalSpace ? transformToUpdate.localScale : transformToUpdate.lossyScale;
 
@@ -524,19 +529,24 @@ private void ApplyInterpolatedNetworkStateToTransform(NetworkTransformState netw
                 interpolatedPosition.z = networkState.IsTeleporting || !Interpolate ? networkState.Position.z : m_PositionZInterpolator.GetInterpolatedValue();
             }
 
-            if (SyncRotAngleX)
+            // again, we should be using quats here
+            if (SyncRotAngleX || SyncRotAngleY || SyncRotAngleZ)
             {
-                interpolatedRotAngles.x = networkState.IsTeleporting || !Interpolate ? networkState.Rotation.x : m_RotationInterpolator.GetInterpolatedValue().eulerAngles.x;
-            }
+                var eulerAngles = m_RotationInterpolator.GetInterpolatedValue().eulerAngles;
+                if (SyncRotAngleX)
+                {
+                	interpolatedRotAngles.x = networkState.IsTeleporting || !Interpolate ? networkState.Rotation.x : eulerAngles.x;
+                }
 
-            if (SyncRotAngleY)
-            {
-                interpolatedRotAngles.y = networkState.IsTeleporting || !Interpolate ? networkState.Rotation.y : m_RotationInterpolator.GetInterpolatedValue().eulerAngles.y;
-            }
+                if (SyncRotAngleY)
+                {
+                	interpolatedRotAngles.y = networkState.IsTeleporting || !Interpolate ? networkState.Rotation.y : eulerAngles.y;
+                }
 
-            if (SyncRotAngleZ)
-            {
-                interpolatedRotAngles.z = networkState.IsTeleporting || !Interpolate ? networkState.Rotation.z : m_RotationInterpolator.GetInterpolatedValue().eulerAngles.z;
+                if (SyncRotAngleZ)
+                {
+                	interpolatedRotAngles.z = networkState.IsTeleporting || !Interpolate ? networkState.Rotation.z : eulerAngles.z;
+                }
             }
 
             // Scale Read
@@ -602,12 +612,11 @@ private void ApplyInterpolatedNetworkStateToTransform(NetworkTransformState netw
 
                 m_PrevNetworkState.Scale = interpolatedScale;
             }
-            Debug.DrawLine(transformToUpdate.position, transformToUpdate.position + Vector3.up, Color.magenta, 10, false);
         }
 
         private void AddInterpolatedState(NetworkTransformState newState)
         {
-            var sentTime = new NetworkTime(NetworkManager.Singleton.ServerTime.TickRate, newState.SentTime);
+            var sentTime = new NetworkTime(NetworkManager.ServerTime.TickRate, newState.SentTime);
 
             if (newState.HasPositionX)
             {
@@ -660,7 +669,7 @@ private void OnNetworkStateChanged(NetworkTransformState oldState, NetworkTransf
 
             AddInterpolatedState(newState);
 
-            if (NetworkManager.Singleton.LogLevel == LogLevel.Developer)
+            if (NetworkManager.LogLevel == LogLevel.Developer)
             {
                 var pos = new Vector3(newState.PositionX, newState.PositionY, newState.PositionZ);
                 Debug.DrawLine(pos, pos + Vector3.up + Vector3.left * Random.Range(0.5f, 2f), Color.green, k_DebugDrawLineTime, false);
@@ -734,110 +743,20 @@ private void OnDestroy()
             m_ReplicatedNetworkState.OnValueChanged -= OnNetworkStateChanged;
         }
 
-        #region delta input
-
-        private Vector3 m_CurrentPositionDirection;
-        private Vector3 m_PreviousPositionDirection;
-
-        private Vector3 m_CurrentRotationDirection;
-        private Vector3 m_PreviousRotationDirection;
-
-        private Vector3 m_CurrentScaleDirection;
-        private Vector3 m_PreviousScaleDirection;
-
-        /// <summary>
-        /// Simple way to affect your transform server side from clients, while still keeping a server authoritative transform. For more custom logic,
-        /// you can implement an RPC that does the same as this method, with custom movement logic.
-        /// It's not recommened to use this on non-kinematic or FixedUpdate based objects. Physics movements will need custom code to be synced with physics items.
-        /// To stop movements, set delta back to 0
-        /// </summary>
-        /// <param name="deltaPos"></param>
-        /// <param name="deltaRot"></param>
-        /// <param name="deltaScale"></param>
-        /// <exception cref="Exception"></exception>
-        public void CommitDeltaValues(Vector3 deltaPos, Vector3 deltaRot, Vector3 deltaScale)
-        {
-            if (!IsOwner)
-            {
-                throw new Exception("Trying to send a delta to a not owned transform");
-            }
-
-            if (m_PreviousPositionDirection == deltaPos && m_PreviousRotationDirection == deltaRot && m_PreviousScaleDirection == deltaScale)
-            {
-                return;
-            }
-
-            if (NetworkManager != null && !(NetworkManager.IsConnectedClient || NetworkManager.IsListening))
-            {
-                return;
-            }
-
-            if (!CanCommitToTransform)
-            {
-                if (!IsServer)
-                {
-                    SendDeltaServerRpc(deltaPos, deltaRot, deltaScale);
-                }
-            }
-            else
-            {
-                m_CurrentPositionDirection = deltaPos;
-                m_CurrentRotationDirection = deltaRot;
-                m_CurrentScaleDirection = deltaScale;
-            }
-
-            m_PreviousPositionDirection = deltaPos;
-            m_PreviousRotationDirection = deltaRot;
-            m_PreviousScaleDirection = deltaScale;
-        }
-
-        [ServerRpc]
-        private void SendDeltaServerRpc(Vector3 deltaPos, Vector3 deltaRot, Vector3 deltaScale)
-        {
-            m_CurrentPositionDirection = deltaPos;
-            m_CurrentRotationDirection = deltaRot;
-            m_CurrentScaleDirection = deltaScale;
-        }
-
-        private void UpdateWithDelta()
-        {
-            if (CanCommitToTransform)
-            {
-                // Custom logic for position update. You can also create your own RPC to have your own custom movement logic
-                // this is resistant to jitter, since the current direction is cached. This way, if we receive jittery inputs, this update still knows what to do
-                // An improvement could be to do input decay, and slowly decrease that direction over time if no new inputs. This is useful for when a client disconnects for example, so we don't
-                // have objects moving forever.
-                // This doesn't "impose" a position on the server from clients (which makes that client have authority), we’re making the client “suggest”
-                // a pos change, but the server could also do what it wants with that transform in between inputs
-                if (InLocalSpace)
-                {
-                    m_Transform.localPosition += m_CurrentPositionDirection * Time.deltaTime;
-                    m_Transform.localRotation = Quaternion.Euler(m_Transform.localRotation.eulerAngles + m_CurrentRotationDirection * Time.deltaTime);
-                    m_Transform.localScale += m_CurrentScaleDirection * Time.deltaTime;
-                }
-                else
-                {
-                    m_Transform.position += m_CurrentPositionDirection * Time.deltaTime;
-                    m_Transform.rotation = Quaternion.Euler(m_Transform.rotation.eulerAngles + m_CurrentRotationDirection * Time.deltaTime);
-                    m_Transform.localScale += m_CurrentScaleDirection * Time.deltaTime;
-                }
-            }
-        }
-
-        #endregion
-
         #region state set
 
         /// <summary>
         /// Directly sets a state on the 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="pos"></param>
-        /// <param name="rot"></param>
-        /// <param name="scale"></param>
+        /// <param name="posIn"></param> new position to move to.  Can be null
+        /// <param name="rotIn"></param> new rotation to rotate to.  Can be null
+        /// <param name="scaleIn"></param> new scale to scale to.  Can be null
         /// <exception cref="Exception"></exception>
-        public void SetState(Vector3 pos, Vector3 rot, Vector3 scale)
+        public void SetState(Vector3? posIn = null, Quaternion? rotIn = null, Vector3? scaleIn = null)
         {
             if (!IsOwner)
             {
@@ -849,6 +768,10 @@ public void SetState(Vector3 pos, Vector3 rot, Vector3 scale)
                 return;
             }
 
+            Vector3 pos = posIn == null ? transform.position : (Vector3)posIn;
+            Quaternion rot = rotIn == null ? transform.rotation : (Quaternion)rotIn;
+            Vector3 scale = scaleIn == null ? transform.localScale : (Vector3)scaleIn;
+
             if (!CanCommitToTransform)
             {
                 if (!IsServer)
@@ -859,16 +782,41 @@ public void SetState(Vector3 pos, Vector3 rot, Vector3 scale)
             else
             {
                 transform.position = pos;
-                transform.rotation = Quaternion.Euler(rot);
+                transform.rotation = rot;
                 transform.localScale = scale;
             }
         }
 
+        /// <summary>
+        /// Simple way to affect your transform server side from clients, while still keeping a server authoritative transform. For more custom logic,
+        /// you can implement an RPC that does the same as this method, with custom movement logic.
+        /// It's not recommended to use this on non-kinematic or FixedUpdate based objects. Physics movements will need custom code to be synced with physics items.
+        /// To stop movements, set delta back to 0
+        /// </summary>
+        /// <param name="deltaPos"></param>
+        /// <param name="deltaRot"></param>
+        /// <param name="deltaScale"></param>
+        /// <exception cref="Exception"></exception>
+        public void ApplyDelta(Vector3? deltaPosIn = null, Quaternion? deltaRotIn = null, Vector3? deltaScaleIn = null)
+        {
+            Vector3 deltaPos = (deltaPosIn == null ? Vector3.zero : (Vector3)deltaPosIn);
+            Quaternion deltaRot = (deltaRotIn == null ? Quaternion.identity : (Quaternion)deltaRotIn);
+            Vector3 deltaScale = (deltaScaleIn == null ? Vector3.zero : (Vector3)deltaScaleIn);
+
+            SetState(transform.position + deltaPos, transform.rotation * deltaRot, transform.localScale + deltaScale);
+        }
+
         [ServerRpc]
-        private void SetStateServerRpc(Vector3 pos, Vector3 rot, Vector3 scale)
+        private void SetStateServerRpc(Vector3 pos, Quaternion rot, Vector3 scale)
         {
+            // 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);
+            }
             transform.position = pos;
-            transform.rotation = Quaternion.Euler(rot);
+            transform.rotation = rot;
             transform.localScale = scale;
         }
         #endregion
@@ -882,8 +830,6 @@ protected virtual void Update()
                 return;
             }
 
-            UpdateWithDelta();
-
             if (CanCommitToTransform)
             {
                 if (IsServer)
@@ -895,7 +841,7 @@ protected virtual void Update()
             }
 
             // apply interpolated value
-            if ((NetworkManager.Singleton.IsConnectedClient || NetworkManager.Singleton.IsListening))
+            if (NetworkManager.IsConnectedClient || NetworkManager.IsListening)
             {
                 foreach (var interpolator in m_AllFloatInterpolators)
                 {
@@ -906,7 +852,7 @@ protected virtual void Update()
 
                 if (!CanCommitToTransform)
                 {
-                    if (NetworkManager.Singleton.LogLevel == LogLevel.Developer)
+                    if (NetworkManager.LogLevel == LogLevel.Developer)
                     {
                         var interpolatedPosition = new Vector3(m_PositionXInterpolator.GetInterpolatedValue(), m_PositionYInterpolator.GetInterpolatedValue(), m_PositionZInterpolator.GetInterpolatedValue());
                         Debug.DrawLine(interpolatedPosition, interpolatedPosition + Vector3.up, Color.magenta, k_DebugDrawLineTime, false);
@@ -916,6 +862,8 @@ protected virtual void Update()
                     // if we have any changes, that means made some updates locally
                     // we apply the latest ReplNetworkState again to revert our changes
                     var oldStateDirtyInfo = ApplyTransformToNetworkStateWithInfo(ref m_PrevNetworkState, 0, m_Transform);
+
+                    // there is a bug in this code, as we the message is dumped out under odd circumstances
                     if (oldStateDirtyInfo.isPositionDirty || oldStateDirtyInfo.isScaleDirty || (oldStateDirtyInfo.isRotationDirty && SyncRotAngleX && SyncRotAngleY && SyncRotAngleZ))
                     {
                         // ignoring rotation dirty since quaternions will mess with euler angles, making this impossible to determine if the change to a single axis comes

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

@@ -0,0 +1,17 @@
+{
+    "name": "ClientNetworkAnimator",
+    "rootNamespace": "",
+    "references": [
+        "GUID:1491147abca9d7d4bb7105af628b223e",
+        "GUID:3b8ed52f1b5c64994af4c4e0aa4b6c4b"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

com.unity.netcode.gameobjects/Samples/ClientNetworkAnimator.meta

@@ -0,0 +1,13 @@
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// A prototype component for syncing Mecanim Animator state in a client-driven manner
+    /// </summary>
+    [AddComponentMenu("Netcode/" + nameof(ClientNetworkAnimator))]
+    public class ClientNetworkAnimator : NetworkAnimator
+    {
+        public override bool CanCommitToAnimator => IsClient && IsOwner;
+    }
+}

com.unity.netcode.gameobjects/Samples/ClientNetworkAnimator/Scripts.meta

@@ -51,7 +51,7 @@ private void Tick(bool isFixed)
         if (IsServer)
         {
             var deltaTime = isFixed ? Time.fixedDeltaTime : Time.deltaTime;
-            GetComponent<NetworkTransform>().CommitDeltaValues(transform.forward * m_MoveSpeed, new Vector3(0, m_RotationSpeed, 0), Vector3.one);
+            GetComponent<NetworkTransform>().ApplyDelta(transform.forward * m_MoveSpeed, Quaternion.Euler(0, m_RotationSpeed, 0), Vector3.one);
             // transform.position = transform.position + transform.forward * (m_MoveSpeed * deltaTime);
             // transform.Rotate(0, m_RotationSpeed * deltaTime, 0);
             // transform.localScale = ((Mathf.Sin(isFixed ? Time.fixedTime : Time.time) + 1) * Vector3.one);

com.unity.netcode.gameobjects/Samples/ClientNetworkAnimator/Scripts/ClientNetworkAnimator.asmdef

@@ -24,11 +24,13 @@ public override void OnNetworkSpawn()
             {
                 enabled = false;
             }
+
+            transform.position += Vector3.up * NetworkObject.NetworkObjectId * 1.1f;
         }
 
         private void Update()
         {
-            if (m_NetworkAnimator.IsAuthorityOverAnimator)
+            if (m_NetworkAnimator.CanCommitToAnimator)
             {
                 if (Input.GetKeyDown(KeyCode.C))
                 {