perf(PredictedRigidbody): next round of optimizations

Author: mischa

Assets/Mirror/Components/PredictedRigidbody/PredictedRigidbody.cs

@@ -251,11 +251,9 @@ protected virtual void SmoothFollowPhysicsCopy()
             */
 
             // FAST VERSION: this shows in profiler a lot, so cache EVERYTHING!
-            Vector3    currentPosition = tf.position;
-            Quaternion currentRotation = tf.rotation;
-            Vector3    physicsPosition = physicsCopyTransform.position; // faster than accessing physicsCopyRigidbody!
-            Quaternion physicsRotation = physicsCopyTransform.rotation; // faster than accessing physicsCopyRigidbody!
-            float      deltaTime       = Time.deltaTime;
+            tf.GetPositionAndRotation(out Vector3 currentPosition, out Quaternion currentRotation);                   // faster than tf.position + tf.rotation
+            physicsCopyTransform.GetPositionAndRotation(out Vector3 physicsPosition, out Quaternion physicsRotation); // faster than physicsCopyRigidbody.position + physicsCopyRigidbody.rotation
+            float deltaTime = Time.deltaTime;
 
             float distance = Vector3.Distance(currentPosition, physicsPosition);
             if (distance > smoothFollowThreshold)
@@ -356,27 +354,35 @@ void RecordState()
             if (stateHistory.Count >= stateHistoryLimit)
                 stateHistory.RemoveAt(0);
 
+            // grab current position/rotation/velocity only once.
+            // this is performance critical, avoid calling .transform multiple times.
+            tf.GetPositionAndRotation(out Vector3 currentPosition, out Quaternion currentRotation); // faster than accessing .position + .rotation manually
+            Vector3 currentVelocity = physicsCopyRigidbody.velocity;
+
             // calculate delta to previous state (if any)
             Vector3 positionDelta = Vector3.zero;
             Vector3 velocityDelta = Vector3.zero;
-            Quaternion rotationDelta = Quaternion.identity;
+            // Quaternion rotationDelta = Quaternion.identity; // currently unused
             if (stateHistory.Count > 0)
             {
                 RigidbodyState last = stateHistory.Values[stateHistory.Count - 1];
-                positionDelta = physicsCopyRigidbody.position - last.position;
-                velocityDelta = physicsCopyRigidbody.velocity - last.velocity;
-                rotationDelta = physicsCopyRigidbody.rotation * Quaternion.Inverse(last.rotation); // this is how you calculate a quaternion delta
+                positionDelta = currentPosition - last.position;
+                velocityDelta = currentVelocity - last.velocity;
+                // rotationDelta = currentRotation * Quaternion.Inverse(last.rotation); // this is how you calculate a quaternion delta (currently unused, don't do the computation)
 
                 // debug draw the recorded state
-                Debug.DrawLine(last.position, physicsCopyRigidbody.position, Color.red, lineTime);
+                // Debug.DrawLine(last.position, currentPosition, Color.red, lineTime);
             }
 
             // create state to insert
             RigidbodyState state = new RigidbodyState(
                 predictedTime,
-                positionDelta, physicsCopyRigidbody.position,
-                rotationDelta, physicsCopyRigidbody.rotation,
-                velocityDelta, physicsCopyRigidbody.velocity
+                positionDelta,
+                currentPosition,
+                // rotationDelta, // currently unused
+                currentRotation,
+                velocityDelta,
+                currentVelocity
             );
 
             // add state to history
@@ -412,9 +418,12 @@ void ApplyState(double timestamp, Vector3 position, Quaternion rotation, Vector3
                 stateHistory.Clear();
                 stateHistory.Add(timestamp, new RigidbodyState(
                     timestamp,
-                    Vector3.zero, position,
-                    Quaternion.identity, rotation,
-                    Vector3.zero, velocity
+                    Vector3.zero,
+                    position,
+                    // Quaternion.identity, // rotationDelta: currently unused
+                    rotation,
+                    Vector3.zero,
+                    velocity
                 ));
 
                 // user callback
@@ -446,9 +455,9 @@ void OnReceivedState(double timestamp, RigidbodyState state)
             // always update remote state ghost
             if (remoteCopy != null)
             {
-                remoteCopy.transform.position = state.position;
-                remoteCopy.transform.rotation = state.rotation;
-                remoteCopy.transform.localScale = tf.lossyScale; // world scale! see CreateGhosts comment.
+                Transform remoteCopyTransform = remoteCopy.transform;
+                remoteCopyTransform.SetPositionAndRotation(state.position, state.rotation); // faster than .position + .rotation setters
+                remoteCopyTransform.localScale = tf.lossyScale; // world scale! see CreateGhosts comment.
             }
 
             // OPTIONAL performance optimization when comparing idle objects.
@@ -552,7 +561,7 @@ void OnReceivedState(double timestamp, RigidbodyState state)
 
                 // show the received correction position + velocity for debugging.
                 // helps to compare with the interpolated/applied correction locally.
-                Debug.DrawLine(state.position, state.position + state.velocity * 0.1f, Color.white, lineTime);
+                //Debug.DrawLine(state.position, state.position + state.velocity * 0.1f, Color.white, lineTime);
 
                 // insert the correction and correct the history on top of it.
                 // returns the final recomputed state after rewinding.
@@ -563,7 +572,7 @@ void OnReceivedState(double timestamp, RigidbodyState state)
                 // for example, on same machine with near zero latency.
                 // int correctedAmount = stateHistory.Count - afterIndex;
                 // Debug.Log($"Correcting {name}: {correctedAmount} / {stateHistory.Count} states to final position from: {rb.position} to: {last.position}");
-                Debug.DrawLine(physicsCopyRigidbody.position, recomputed.position, Color.green, lineTime);
+                //Debug.DrawLine(physicsCopyRigidbody.position, recomputed.position, Color.green, lineTime);
                 ApplyState(recomputed.timestamp, recomputed.position, recomputed.rotation, recomputed.velocity);
 
                 // user callback
@@ -620,7 +629,7 @@ public override void OnDeserialize(NetworkReader reader, bool initialState)
             Vector3 velocity    = reader.ReadVector3();
 
             // process received state
-            OnReceivedState(timestamp, new RigidbodyState(timestamp, Vector3.zero, position, Quaternion.identity, rotation, Vector3.zero, velocity));
+            OnReceivedState(timestamp, new RigidbodyState(timestamp, Vector3.zero, position, /*Quaternion.identity,*/ rotation, Vector3.zero, velocity));
         }
 
         protected override void OnValidate()

Assets/Mirror/Components/PredictedRigidbody/RigidbodyState.cs

@@ -12,22 +12,25 @@ public struct RigidbodyState : PredictedState
         public Vector3    positionDelta { get; set; } // delta to get from last to this position
         public Vector3    position { get; set; }
 
-        public Quaternion rotationDelta { get; set; } // delta to get from last to this rotation
+        // public Quaternion rotationDelta { get; set; } // delta to get from last to this rotation
         public Quaternion rotation { get; set; }
 
         public Vector3 velocityDelta { get; set; } // delta to get from last to this velocity
         public Vector3 velocity { get; set; }
 
         public RigidbodyState(
             double timestamp,
-            Vector3 positionDelta, Vector3 position,
-            Quaternion rotationDelta, Quaternion rotation,
-            Vector3 velocityDelta, Vector3 velocity)
+            Vector3 positionDelta,
+            Vector3 position,
+            // Quaternion rotationDelta, // currently unused
+            Quaternion rotation,
+            Vector3 velocityDelta,
+            Vector3 velocity)
         {
             this.timestamp     = timestamp;
             this.positionDelta = positionDelta;
             this.position      = position;
-            this.rotationDelta = rotationDelta;
+            // this.rotationDelta = rotationDelta;
             this.rotation      = rotation;
             this.velocityDelta = velocityDelta;
             this.velocity      = velocity;

Assets/Mirror/Core/Prediction/Prediction.cs

@@ -15,7 +15,7 @@ public interface PredictedState
         Vector3 positionDelta { get; set; }
 
         Quaternion rotation { get; set; }
-        Quaternion rotationDelta { get; set; }
+        // Quaternion rotationDelta { get; set; } // currently unused
 
         Vector3 velocity { get; set; }
         Vector3 velocityDelta { get; set; }

Assets/Mirror/Tests/Editor/Prediction/PredictionTests.cs

@@ -14,7 +14,7 @@ struct TestState : PredictedState
             public Vector3 positionDelta { get; set; }
 
             public Quaternion rotation { get; set; }
-            public Quaternion rotationDelta { get; set; }
+            // public Quaternion rotationDelta { get; set; } // currently unused
 
             public Vector3 velocity { get; set; }
             public Vector3 velocityDelta { get; set; }
@@ -25,7 +25,7 @@ public TestState(double timestamp, Vector3 position, Vector3 positionDelta, Vect
                 this.position = position;
                 this.positionDelta = positionDelta;
                 this.rotation = Quaternion.identity;
-                this.rotationDelta = Quaternion.identity;
+                // this.rotationDelta = Quaternion.identity;
                 this.velocity = velocity;
                 this.velocityDelta = velocityDelta;
             }