feat(NetworkTransformBase): Add Velocity and AngularVelocity

Assets/Mirror/Components/NetworkTransform/NetworkTransformBase.cs

@@ -144,6 +144,54 @@ protected override void OnValidate()
             if (coordinateSpace == CoordinateSpace.World) synchronizationSelections &= ~SyncInterpolateOptions.Scale;
         }
 
+        // These are in global coordinates for calculating velocity and angular velocity.
+        Vector3 lastPosition;
+        Quaternion lastRotation;
+
+        public Vector3 velocity { get; internal set; } = Vector3.zero;
+        public Vector3 angularVelocity { get; internal set; } = Vector3.zero;
+
+        protected virtual void Start()
+        {
+            // set target to self if none yet
+            if (target == null) target = transform;
+
+            // Set last position and rotation to current values
+            // so we can calculate velocity and angular velocity.
+            target.GetPositionAndRotation(out lastPosition, out lastRotation);
+        }
+
+        protected virtual void Update()
+        {
+            // set target to self if none yet
+            if (target == null) target = transform;
+
+            // Use global coordinates for velocity and angular velocity.
+            target.GetPositionAndRotation(out Vector3 pos, out Quaternion rot);
+
+            // Update velocity and angular velocity
+            velocity = (pos - lastPosition) / Time.deltaTime;
+            CalculateAngularVelocity(rot);
+
+            // Update last position and rotation
+            lastPosition = pos;
+            lastRotation = rot;
+        }
+
+        void CalculateAngularVelocity(Quaternion currentRot)
+        {
+            // calculate angle between two rotations
+            Quaternion deltaRotation = currentRot * Quaternion.Inverse(lastRotation);
+            //Quaternion deltaRotation = (currentRot * Quaternion.Inverse(lastRotation)).normalize;
+
+            // convert to angle axis
+            deltaRotation.ToAngleAxis(out float angle, out Vector3 axis);
+
+            // we assume the angle is always the shortest path
+            // we don't need to check for 360 degree rotations
+            angularVelocity = axis * angle * Mathf.Deg2Rad / Time.deltaTime;
+        }
+
         // snapshot functions //////////////////////////////////////////////////
         // get local/world position
         protected virtual Vector3 GetPosition() =>
@@ -394,6 +442,16 @@ public virtual void ResetState()
             // so let's clear the buffers.
             serverSnapshots.Clear();
             clientSnapshots.Clear();
+
+            // set target to self if none yet
+            if (target == null) target = transform;
+
+            // Reset last position and rotation
+            target.GetPositionAndRotation(out lastPosition, out lastRotation);
+
+            // Reset velocity / angular velocity
+            velocity = Vector3.zero;
+            angularVelocity = Vector3.zero;
         }
 
         public virtual void Reset()

Assets/Mirror/Components/NetworkTransform/NetworkTransformReliable.cs

@@ -44,13 +44,15 @@ public class NetworkTransformReliable : NetworkTransformBase
         protected int lastClientCount = 1;
 
         // update //////////////////////////////////////////////////////////////
-        void Update()
+        protected override void Update()
         {
             // if server then always sync to others.
             if (isServer) UpdateServer();
             // 'else if' because host mode shouldn't send anything to server.
             // it is the server. don't overwrite anything there.
             else if (isClient) UpdateClient();
+
+            base.Update();
         }
 
         void LateUpdate()

Assets/Mirror/Components/NetworkTransform/NetworkTransformUnreliable.cs

@@ -33,13 +33,15 @@ public class NetworkTransformUnreliable : NetworkTransformBase
 
         // update //////////////////////////////////////////////////////////////
         // Update applies interpolation
-        void Update()
+        protected override void Update()
         {
             if (isServer) UpdateServerInterpolation();
             // for all other clients (and for local player if !authority),
             // we need to apply snapshots from the buffer.
             // 'else if' because host mode shouldn't interpolate client
             else if (isClient && !IsClientWithAuthority) UpdateClientInterpolation();
+
+            base.Update();
         }
 
         // LateUpdate broadcasts.