fix(serialization): Fixes reading and writing rotations

Fixes: #178

Author: TwoTenPvP

MLAPI/NetworkingManagerComponents/Binary/BitReader.cs

@@ -126,7 +126,7 @@ public object ReadObjectPacked(Type type)
             if (type == typeof(Ray))
                 return ReadRayPacked();
             if (type == typeof(Quaternion))
-                return ReadRotation(3);
+                return ReadRotationPacked();
             if (type == typeof(char))
                 return ReadCharPacked();
             if (type.IsEnum)
@@ -332,19 +332,24 @@ public double ReadRangedDouble(double minValue, double maxValue, int bytes)
         }
 
         /// <summary>
-        /// Read a rotation from the stream.
+        /// Reads the rotation from the stream
         /// </summary>
-        /// <param name="bytesPerAngle">How many bytes each angle occupies. Must be between 1 and 4 (inclusive)</param>
         /// <returns>The rotation read from the stream</returns>
+        public Quaternion ReadRotationPacked()
+        {
+            float x = ReadSinglePacked();
+            float y = ReadSinglePacked();
+            float z = ReadSinglePacked();
+
+            float w = Mathf.Sqrt(1 - ((Mathf.Pow(x, 2) - (Mathf.Pow(y, 2) - (Mathf.Pow(z, 2))))));
+
+            return new Quaternion(x, y, z, w);
+        }
+
+        [Obsolete("Use ReadRotationPacked instead")]
         public Quaternion ReadRotation(int bytesPerAngle)
         {
-            if (bytesPerAngle < 1 || bytesPerAngle > 4) throw new ArgumentOutOfRangeException("Bytes per angle must be at least 1 byte and at most 4 bytes!");
-            if (bytesPerAngle == 4) return Quaternion.Euler(ReadVector3());
-            else return Quaternion.Euler(
-                ReadRangedSingle(0f, 360f, bytesPerAngle),  // X
-                ReadRangedSingle(0f, 360f, bytesPerAngle),  // Y
-                ReadRangedSingle(0f, 360f, bytesPerAngle)   // Z
-                );
+            return ReadRotationPacked();
         }
 
         /// <summary>

MLAPI/NetworkingManagerComponents/Binary/BitWriter.cs

@@ -141,7 +141,7 @@ public void WriteObjectPacked(object value)
             }
             else if (value is Quaternion)
             {
-                WriteRotation((Quaternion)value, 3);
+                WriteRotationPacked((Quaternion)value);
                 return;
             }
             else if (value is char)
@@ -389,23 +389,31 @@ public void WriteRangedDouble(double value, double minValue, double maxValue, in
         }
 
         /// <summary>
-        /// Write a rotation to the stream.
+        /// Writes the rotation to the stream.
         /// </summary>
         /// <param name="rotation">Rotation to write</param>
-        /// <param name="bytesPerAngle">How many bytes each written angle should occupy. Must be between 1 and 4 (inclusive)</param>
-        public void WriteRotation(Quaternion rotation, int bytesPerAngle)
+        public void WriteRotationPacked(Quaternion rotation)
         {
-            if (bytesPerAngle < 1 || bytesPerAngle > 4) throw new ArgumentOutOfRangeException("Bytes per angle must be at least 1 byte and at most 4 bytes!");
-            if (bytesPerAngle == 4) WriteVector3(rotation.eulerAngles);
+            if (Mathf.Sign(rotation.w) < 0)
+            {
+                WriteSinglePacked(-rotation.x);
+                WriteSinglePacked(-rotation.y);
+                WriteSinglePacked(-rotation.z);
+            }
             else
             {
-                Vector3 rot = rotation.eulerAngles;
-                WriteRangedSingle(rot.x, 0f, 360f, bytesPerAngle);
-                WriteRangedSingle(rot.y, 0f, 360f, bytesPerAngle);
-                WriteRangedSingle(rot.z, 0f, 360f, bytesPerAngle);
+                WriteSinglePacked(rotation.x);
+                WriteSinglePacked(rotation.y);
+                WriteSinglePacked(rotation.z);
             }
         }
 
+        [Obsolete("Use WriteRotationPacked instead")]
+        public void WriteRotation(Quaternion rotation, int bytesPerAngle)
+        {
+            WriteRotationPacked(rotation);
+        }
+
         /// <summary>
         /// Writes a single bit
         /// </summary>