Fix typo in naming + fix comments

Author: noellie-velez

com.unity.netcode.gameobjects/Runtime/Components/QuaternionCompressor.cs

@@ -4,7 +4,7 @@
 namespace Unity.Netcode
 {
     /// <summary>
-    /// A Smallest Three Quaternion Compressor Implementation
+    /// The Smallest Three Quaternion Compressor Implementation
     /// </summary>
     /// <remarks>
     /// Explanation of why "The smallest three":
@@ -26,14 +26,14 @@ public static class QuaternionCompressor
 
         // We can further improve the encoding compression by dividing k_SqrtTwoOverTwo into 1.0f and multiplying that
         // by the precision mask (minor reduction of runtime calculations)
-        private const float k_CompressionEcodingMask = (1.0f / k_SqrtTwoOverTwoEncoding) * k_PrecisionMask;
+        private const float k_CompressionEncodingMask = (1.0f / k_SqrtTwoOverTwoEncoding) * k_PrecisionMask;
 
         // Used to shift the negative bit to the 10th bit position when compressing and encoding
         private const ushort k_ShiftNegativeBit = 9;
 
         // We can do the same for our decoding and decompression by dividing k_PrecisionMask into 1.0 and multiplying
         // that by k_SqrtTwoOverTwo (minor reduction of runtime calculations)
-        private const float k_DcompressionDecodingMask = (1.0f / k_PrecisionMask) * k_SqrtTwoOverTwoEncoding;
+        private const float k_DecompressionDecodingMask = (1.0f / k_PrecisionMask) * k_SqrtTwoOverTwoEncoding;
 
         // The sign bit position (10th bit) used when decompressing and decoding
         private const ushort k_NegShortBit = 0x200;
@@ -59,7 +59,7 @@ public static uint CompressQuaternion(ref Quaternion quaternion)
             // Get the largest element value of the quaternion to know what the remaining "Smallest Three" values are
             var quatMax = Mathf.Max(quatAbsValue0, quatAbsValue1, quatAbsValue2, quatAbsValue3);
 
-            // Find the index of the largest element so we can skip that element while compressing and decompressing
+            // Find the index of the largest element, so we can skip that element while compressing and decompressing
             var indexToSkip = (ushort)(quatAbsValue0 == quatMax ? 0 : quatAbsValue1 == quatMax ? 1 : quatAbsValue2 == quatMax ? 2 : 3);
 
             // Get the sign of the largest element which is all that is needed when calculating the sum of squares of a normalized quaternion.
@@ -68,14 +68,14 @@ public static uint CompressQuaternion(ref Quaternion quaternion)
             // Start with the index to skip which will be shifted to the highest two bits
             var compressed = (uint)indexToSkip;
 
-            // Step 2: If we are on the index to skip preserve the current compressed value, otherwise proceed to step 3 and 4
-            // Step 3: Get the sign of the element we are processing. If it is the not the same as the largest value's sign bit then we set the bit
-            // Step 4: Get the compressed and encoded value by multiplying the absolute value of the current element by k_CompressionEcodingMask and round that result up
-            compressed = 0 != indexToSkip ? (compressed << 10) | (uint)((quaternion[0] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * quatAbsValue0) : compressed;
-            // Repeat the last 3 steps for the remaining elements
-            compressed = 1 != indexToSkip ? (compressed << 10) | (uint)((quaternion[1] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * quatAbsValue1) : compressed;
-            compressed = 2 != indexToSkip ? (compressed << 10) | (uint)((quaternion[2] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * quatAbsValue2) : compressed;
-            compressed = 3 != indexToSkip ? (compressed << 10) | (uint)((quaternion[3] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * quatAbsValue3) : compressed;
+            // Step 1: If we are on the index to skip, preserve the current compressed value, otherwise proceed to step 2 and 3
+            // Step 2: Get the sign of the element we are processing. If it is not the same as the largest value's sign bit then we set the bit
+            // Step 3: Get the compressed and encoded value by multiplying the absolute value of the current element by k_CompressionEncodingMask and round that result up
+            compressed = 0 != indexToSkip ? (compressed << 10) | (uint)((quaternion[0] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEncodingMask * quatAbsValue0) : compressed;
+            // Repeat the 3 steps for the remaining elements
+            compressed = 1 != indexToSkip ? (compressed << 10) | (uint)((quaternion[1] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEncodingMask * quatAbsValue1) : compressed;
+            compressed = 2 != indexToSkip ? (compressed << 10) | (uint)((quaternion[2] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEncodingMask * quatAbsValue2) : compressed;
+            compressed = 3 != indexToSkip ? (compressed << 10) | (uint)((quaternion[3] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEncodingMask * quatAbsValue3) : compressed;
 
             // Return the compress quaternion
             return compressed;
@@ -101,7 +101,7 @@ public static void DecompressQuaternion(ref Quaternion quaternion, uint compress
                     continue;
                 }
                 // Check the negative bit and multiply that result with the decompressed and decoded value
-                quaternion[i] = ((compressed & k_NegShortBit) > 0 ? -1.0f : 1.0f) * ((compressed & k_PrecisionMask) * k_DcompressionDecodingMask);
+                quaternion[i] = ((compressed & k_NegShortBit) > 0 ? -1.0f : 1.0f) * ((compressed & k_PrecisionMask) * k_DecompressionDecodingMask);
                 sumOfSquaredMagnitudes += quaternion[i] * quaternion[i];
                 compressed = compressed >> 10;
             }