refactor: use unity.mathematics.half in place of added types (#2473)

Author: NoelStephensUnity

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

@@ -1,5 +1,6 @@
 using System.Runtime.CompilerServices;
 using UnityEngine;
+using Unity.Mathematics;
 
 namespace Unity.Netcode.Components
 {
@@ -13,45 +14,70 @@ namespace Unity.Netcode.Components
     /// </remarks>
     public struct HalfVector3 : INetworkSerializable
     {
+        internal const int Length = 3;
+
         /// <summary>
-        /// The half float precision value of the x-axis as a <see cref="ushort"/>.
+        /// The half float precision value of the x-axis as a <see cref="half"/>.
         /// </summary>
-        public ushort X => Axis.X;
+        public half X => Axis.x;
         /// <summary>
-        /// The half float precision value of the y-axis as a <see cref="ushort"/>.
+        /// The half float precision value of the y-axis as a <see cref="half"/>.
         /// </summary>
-        public ushort Y => Axis.Y;
+        public half Y => Axis.y;
         /// <summary>
-        /// The half float precision value of the z-axis as a <see cref="ushort"/>.
+        /// The half float precision value of the z-axis as a <see cref="half"/>.
         /// </summary>
-        public ushort Z => Axis.Z;
+        public half Z => Axis.x;
 
         /// <summary>
-        /// Used to store the half float precision value as a <see cref="ushort"/>.
+        /// Used to store the half float precision values as a <see cref="half3"/>
         /// </summary>
-        public Vector3T<ushort> Axis;
-
-        internal Vector3AxisToSynchronize AxisToSynchronize;
+        public half3 Axis;
 
         /// <summary>
-        /// The serialization implementation of <see cref="INetworkSerializable"/>.
+        /// Determine which axis will be synchronized during serialization
         /// </summary>
-        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        public bool3 AxisToSynchronize;
+
+        private void SerializeWrite(FastBufferWriter writer)
+        {
+            for (int i = 0; i < Length; i++)
+            {
+                if (AxisToSynchronize[i])
+                {
+                    writer.WriteUnmanagedSafe(Axis[i]);
+                }
+            }
+        }
+
+        private void SerializeRead(FastBufferReader reader)
         {
-            for (int i = 0; i < Axis.Length; i++)
+            for (int i = 0; i < Length; i++)
             {
-                if (AxisToSynchronize.SyncAxis[i])
+                if (AxisToSynchronize[i])
                 {
                     var axisValue = Axis[i];
-                    serializer.SerializeValue(ref axisValue);
-                    if (serializer.IsReader)
-                    {
-                        Axis[i] = axisValue;
-                    }
+                    reader.ReadUnmanagedSafe(out axisValue);
+                    Axis[i] = axisValue;
                 }
             }
         }
 
+        /// <summary>
+        /// The serialization implementation of <see cref="INetworkSerializable"/>.
+        /// </summary>
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            if (serializer.IsReader)
+            {
+                SerializeRead(serializer.GetFastBufferReader());
+            }
+            else
+            {
+                SerializeWrite(serializer.GetFastBufferWriter());
+            }
+        }
+
         /// <summary>
         /// Gets the full precision value as a <see cref="Vector3"/>.
         /// </summary>
@@ -60,11 +86,12 @@ public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReade
         public Vector3 ToVector3()
         {
             Vector3 fullPrecision = Vector3.zero;
-            for (int i = 0; i < Axis.Length; i++)
+            Vector3 fullConversion = math.float3(Axis);
+            for (int i = 0; i < Length; i++)
             {
-                if (AxisToSynchronize.SyncAxis[i])
+                if (AxisToSynchronize[i])
                 {
-                    fullPrecision[i] = Mathf.HalfToFloat(Axis[i]);
+                    fullPrecision[i] = fullConversion[i];
                 }
             }
             return fullPrecision;
@@ -77,11 +104,12 @@ public Vector3 ToVector3()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void UpdateFrom(ref Vector3 vector3)
         {
-            for (int i = 0; i < Axis.Length; i++)
+            var half3Full = math.half3(vector3);
+            for (int i = 0; i < Length; i++)
             {
-                if (AxisToSynchronize.SyncAxis[i])
+                if (AxisToSynchronize[i])
                 {
-                    Axis[i] = Mathf.FloatToHalf(vector3[i]);
+                    Axis[i] = half3Full[i];
                 }
             }
         }
@@ -91,18 +119,18 @@ public void UpdateFrom(ref Vector3 vector3)
         /// </summary>
         /// <param name="vector3">The initial axial values (converted to half floats) when instantiated.</param>
         /// <param name="vector3AxisToSynchronize">The axis to synchronize.</param>
-        public HalfVector3(Vector3 vector3, Vector3AxisToSynchronize vector3AxisToSynchronize)
+        public HalfVector3(Vector3 vector3, bool3 axisToSynchronize)
         {
-            Axis = default;
-            AxisToSynchronize = vector3AxisToSynchronize;
+            Axis = half3.zero;
+            AxisToSynchronize = axisToSynchronize;
             UpdateFrom(ref vector3);
         }
 
         /// <summary>
         /// Constructor that defaults to all axis being synchronized.
         /// </summary>
         /// <param name="vector3">The initial axial values (converted to half floats) when instantiated.</param>
-        public HalfVector3(Vector3 vector3) : this(vector3, Vector3AxisToSynchronize.AllAxis)
+        public HalfVector3(Vector3 vector3) : this(vector3, math.bool3(true))
         {
 
         }
@@ -113,8 +141,8 @@ public HalfVector3(Vector3 vector3) : this(vector3, Vector3AxisToSynchronize.All
         /// <param name="x">The initial x axis (converted to half float) value when instantiated.</param>
         /// <param name="y">The initial y axis (converted to half float) value when instantiated.</param>
         /// <param name="z">The initial z axis (converted to half float) value when instantiated.</param>
-        /// <param name="vector3AxisToSynchronize">The axis to synchronize.</param>
-        public HalfVector3(float x, float y, float z, Vector3AxisToSynchronize vector3AxisToSynchronize) : this(new Vector3(x, y, z), vector3AxisToSynchronize)
+        /// <param name="axisToSynchronize">The axis to synchronize.</param>
+        public HalfVector3(float x, float y, float z, bool3 axisToSynchronize) : this(new Vector3(x, y, z), axisToSynchronize)
         {
         }
 
@@ -124,7 +152,7 @@ public HalfVector3(float x, float y, float z, Vector3AxisToSynchronize vector3Ax
         /// <param name="x">The initial x axis (converted to half float) value when instantiated.</param>
         /// <param name="y">The initial y axis (converted to half float) value when instantiated.</param>
         /// <param name="z">The initial z axis (converted to half float) value when instantiated.</param>
-        public HalfVector3(float x, float y, float z) : this(new Vector3(x, y, z), Vector3AxisToSynchronize.AllAxis)
+        public HalfVector3(float x, float y, float z) : this(new Vector3(x, y, z), math.bool3(true))
         {
         }
     }

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

@@ -1,4 +1,5 @@
 using System.Runtime.CompilerServices;
+using Unity.Mathematics;
 using UnityEngine;
 
 namespace Unity.Netcode.Components
@@ -13,44 +14,62 @@ namespace Unity.Netcode.Components
     /// </remarks>
     public struct HalfVector4 : INetworkSerializable
     {
+        internal const int Length = 4;
         /// <summary>
-        /// The half float precision value of the x-axis as a <see cref="ushort"/>.
+        /// The half float precision value of the x-axis as a <see cref="half"/>.
         /// </summary>
-        public ushort X => Axis.X;
+        public half X => Axis.x;
 
         /// <summary>
-        /// The half float precision value of the y-axis as a <see cref="ushort"/>.
+        /// The half float precision value of the y-axis as a <see cref="half"/>.
         /// </summary>
-        public ushort Y => Axis.Y;
+        public half Y => Axis.y;
 
         /// <summary>
-        /// The half float precision value of the z-axis as a <see cref="ushort"/>.
+        /// The half float precision value of the z-axis as a <see cref="half"/>.
         /// </summary>
-        public ushort Z => Axis.Z;
+        public half Z => Axis.z;
 
         /// <summary>
-        /// The half float precision value of the w-axis as a <see cref="ushort"/>.
+        /// The half float precision value of the w-axis as a <see cref="half"/>.
         /// </summary>
-        public ushort W => Axis.W;
+        public half W => Axis.w;
 
         /// <summary>
-        /// Used to store the half float precision value as a <see cref="ushort"/>
+        /// Used to store the half float precision values as a <see cref="half4"/>
         /// </summary>
-        public Vector4T<ushort> Axis;
+        public half4 Axis;
+
+        private void SerializeWrite(FastBufferWriter writer)
+        {
+            for (int i = 0; i < Length; i++)
+            {
+                writer.WriteUnmanagedSafe(Axis[i]);
+            }
+        }
+
+        private void SerializeRead(FastBufferReader reader)
+        {
+            for (int i = 0; i < Length; i++)
+            {
+                var axisValue = Axis[i];
+                reader.ReadUnmanagedSafe(out axisValue);
+                Axis[i] = axisValue;
+            }
+        }
 
         /// <summary>
-        /// The serialization implementation of <see cref="INetworkSerializable"/>
+        /// The serialization implementation of <see cref="INetworkSerializable"/>.
         /// </summary>
         public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
         {
-            for (int i = 0; i < Axis.Length; i++)
+            if (serializer.IsReader)
             {
-                var axisValue = Axis[i];
-                serializer.SerializeValue(ref axisValue);
-                if (serializer.IsReader)
-                {
-                    Axis[i] = axisValue;
-                }
+                SerializeRead(serializer.GetFastBufferReader());
+            }
+            else
+            {
+                SerializeWrite(serializer.GetFastBufferWriter());
             }
         }
 
@@ -61,12 +80,7 @@ public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReade
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Vector4 ToVector4()
         {
-            Vector4 fullPrecision = Vector4.zero;
-            for (int i = 0; i < Axis.Length; i++)
-            {
-                fullPrecision[i] = Mathf.HalfToFloat(Axis[i]);
-            }
-            return fullPrecision;
+            return math.float4(Axis);
         }
 
         /// <summary>
@@ -76,12 +90,7 @@ public Vector4 ToVector4()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Quaternion ToQuaternion()
         {
-            var quaternion = Quaternion.identity;
-            for (int i = 0; i < Axis.Length; i++)
-            {
-                quaternion[i] = Mathf.HalfToFloat(Axis[i]);
-            }
-            return quaternion;
+            return math.quaternion(Axis);
         }
 
         /// <summary>
@@ -91,10 +100,7 @@ public Quaternion ToQuaternion()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void UpdateFrom(ref Vector4 vector4)
         {
-            for (int i = 0; i < Axis.Length; i++)
-            {
-                Axis[i] = Mathf.FloatToHalf(vector4[i]);
-            }
+            Axis = math.half4(vector4);
         }
 
         /// <summary>
@@ -104,10 +110,7 @@ public void UpdateFrom(ref Vector4 vector4)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void UpdateFrom(ref Quaternion quaternion)
         {
-            for (int i = 0; i < Axis.Length; i++)
-            {
-                Axis[i] = Mathf.FloatToHalf(quaternion[i]);
-            }
+            Axis = math.half4(math.half(quaternion.x), math.half(quaternion.y), math.half(quaternion.z), math.half(quaternion.w));
         }
 
         /// <summary>