Enhance State Serialization API (#114)

Author: lucasteles

samples/SpaceWar.Shared/Extensions.cs

@@ -21,12 +21,17 @@ public static void Write(this BinaryBufferWriter writer, in Vector2 rect)
         writer.Write(rect.Y);
     }
 
-    public static Rectangle ReadRectangle(this BinaryBufferReader reader) =>
-        new()
-        {
-            X = reader.ReadInt32(),
-            Y = reader.ReadInt32(),
-            Width = reader.ReadInt32(),
-            Height = reader.ReadInt32(),
-        };
+    public static void Read(this BinaryBufferReader reader, ref Vector2 vector)
+    {
+        reader.Read(ref vector.X);
+        reader.Read(ref vector.Y);
+    }
+
+    public static void Read(this BinaryBufferReader reader, ref Rectangle rect)
+    {
+        rect.X = reader.ReadInt32();
+        rect.Y = reader.ReadInt32();
+        rect.Width = reader.ReadInt32();
+        rect.Height = reader.ReadInt32();
+    }
 }

samples/SpaceWar.Shared/Logic/GameState.cs

@@ -47,9 +47,9 @@ public void SaveState(ref readonly BinaryBufferWriter writer)
 
     public void LoadState(ref readonly BinaryBufferReader reader)
     {
-        Bounds = reader.ReadRectangle();
-        FrameNumber = reader.ReadInt32();
-        reader.Read(in Ships);
+        reader.Read(ref Bounds);
+        reader.Read(ref FrameNumber);
+        reader.Read(Ships);
     }
 
     static GameInput GetShipAI(in Ship ship) => new(

samples/SpaceWar.Shared/Logic/Ship.cs

@@ -1,5 +1,4 @@
 using Backdash.Serialization;
-using Backdash.Serialization.Numerics;
 
 namespace SpaceWar.Logic;
 
@@ -17,7 +16,7 @@ public sealed record Ship : IBinarySerializable
     public int Invincible;
     public int Score;
     public int Thrust;
-    public Missile Missile;
+    public Missile Missile = new();
     public readonly Bullet[] Bullets = new Bullet[Config.MaxBullets];
 
     public void Serialize(ref readonly BinaryBufferWriter writer)
@@ -34,28 +33,28 @@ public void Serialize(ref readonly BinaryBufferWriter writer)
         writer.Write(in Invincible);
         writer.Write(in Score);
         writer.Write(in Thrust);
+        writer.Write(in Missile);
 
         // Caution: WriteStruct not normalize endianness
-        writer.WriteStruct(in Missile);
         writer.WriteStruct(in Bullets);
     }
 
     public void Deserialize(ref readonly BinaryBufferReader reader)
     {
-        Id = reader.ReadByte();
-        Active = reader.ReadBoolean();
-        Position = reader.ReadVector2();
-        Velocity = reader.ReadVector2();
-        Radius = reader.ReadInt32();
-        Heading = reader.ReadInt32();
-        Health = reader.ReadInt32();
-        FireCooldown = reader.ReadInt32();
-        MissileCooldown = reader.ReadInt32();
-        Invincible = reader.ReadInt32();
-        Score = reader.ReadInt32();
-        Thrust = reader.ReadInt32();
+        reader.Read(ref Id);
+        reader.Read(ref Active);
+        reader.Read(ref Position);
+        reader.Read(ref Velocity);
+        reader.Read(ref Radius);
+        reader.Read(ref Heading);
+        reader.Read(ref Health);
+        reader.Read(ref FireCooldown);
+        reader.Read(ref MissileCooldown);
+        reader.Read(ref Invincible);
+        reader.Read(ref Score);
+        reader.Read(ref Thrust);
+        reader.Read(Missile);
 
-        reader.ReadStruct(ref Missile);
         reader.ReadStruct(in Bullets);
     }
 }
@@ -67,7 +66,7 @@ public record struct Bullet
     public Vector2 Velocity;
 }
 
-public record struct Missile
+public record Missile : IBinarySerializable
 {
     public bool Active;
     public int ExplodeTimeout;
@@ -77,5 +76,29 @@ public record struct Missile
     public int Heading;
     public Vector2 Position;
     public Vector2 Velocity;
-    public readonly bool IsExploding() => ExplodeTimeout is 0 && HitBoxTime > 0;
+    public bool IsExploding() => ExplodeTimeout is 0 && HitBoxTime > 0;
+
+    public void Serialize(ref readonly BinaryBufferWriter writer)
+    {
+        writer.Write(in Active);
+        writer.Write(in ExplodeTimeout);
+        writer.Write(in HitBoxTime);
+        writer.Write(in ExplosionRadius);
+        writer.Write(in ProjectileRadius);
+        writer.Write(in Heading);
+        writer.Write(in Position);
+        writer.Write(in Velocity);
+    }
+
+    public void Deserialize(ref readonly BinaryBufferReader reader)
+    {
+        reader.Read(ref Active);
+        reader.Read(ref ExplodeTimeout);
+        reader.Read(ref HitBoxTime);
+        reader.Read(ref ExplosionRadius);
+        reader.Read(ref ProjectileRadius);
+        reader.Read(ref Heading);
+        reader.Read(ref Position);
+        reader.Read(ref Velocity);
+    }
 }

src/Backdash.Analyzers/SourceGenerationHelper.cs

@@ -99,7 +99,7 @@ void BuildArrayMember(ITypeSymbol itemType, ClassMember member)
                 writes.AppendLine($"binaryWriter.Write(data.{member.Name});");
 
                 reads.Append(tab2);
-                reads.AppendLine($"binaryReader.Read{itemType.Name}(result.{member.Name});");
+                reads.AppendLine($"binaryReader.Read(result.{member.Name});");
             }
             else
             {

src/Backdash/Core/Mem.cs

@@ -38,22 +38,16 @@ public static Span<byte> AsBytesUnsafe<T>(scoped ref readonly T data) where T :
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    public static ref TInt EnumAsInteger<TEnum, TInt>(ref TEnum enumValue)
+    public static ref TInt EnumAsInteger<TEnum, TInt>(ref readonly TEnum enumValue)
         where TEnum : unmanaged, Enum
-        where TInt : unmanaged, IBinaryInteger<TInt>
-    {
-        if (Unsafe.SizeOf<TEnum>() != Unsafe.SizeOf<TInt>()) throw new NetcodeException("type mismatch");
-        return ref Unsafe.As<TEnum, TInt>(ref enumValue);
-    }
+        where TInt : unmanaged, IBinaryInteger<TInt> =>
+        ref Unsafe.As<TEnum, TInt>(ref Unsafe.AsRef(in enumValue));
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static ref TEnum IntegerAsEnum<TEnum, TInt>(ref TInt intValue)
         where TEnum : unmanaged, Enum
-        where TInt : unmanaged, IBinaryInteger<TInt>
-    {
-        if (Unsafe.SizeOf<TEnum>() != Unsafe.SizeOf<TInt>()) throw new NetcodeException("type mismatch");
-        return ref Unsafe.As<TInt, TEnum>(ref intValue);
-    }
+        where TInt : unmanaged, IBinaryInteger<TInt> =>
+        ref Unsafe.As<TInt, TEnum>(ref intValue);
 
     public static bool EqualBytes(ReadOnlySpan<byte> left, ReadOnlySpan<byte> right, bool truncate = false)
     {

src/Backdash/Data/DefaultObjectPool.cs

@@ -0,0 +1,52 @@
+namespace Backdash.Data;
+
+sealed class DefaultObjectPool<T> : IObjectPool<T> where T : class, new()
+{
+    public static readonly IObjectPool<T> Instance = new DefaultObjectPool<T>();
+
+    const int MaxCapacity = 99; // -1 to account for fastItem
+
+    int numItems;
+    readonly Stack<T> items = new(MaxCapacity);
+    readonly HashSet<T> set = new(MaxCapacity, ReferenceEqualityComparer.Instance);
+    T? fastItem;
+
+    public T Rent()
+    {
+        var item = fastItem;
+
+        if (item is not null)
+        {
+            fastItem = null;
+            return item;
+        }
+
+        if (!items.TryPop(out item))
+            return new();
+
+        numItems--;
+        set.Remove(item);
+        return item;
+    }
+
+    public void Return(T value)
+    {
+        ArgumentNullException.ThrowIfNull(value);
+
+        if (ReferenceEquals(fastItem, value) || set.Contains(value))
+            return;
+
+        if (fastItem is null)
+        {
+            fastItem = value;
+            return;
+        }
+
+        if (numItems >= MaxCapacity)
+            return;
+
+        numItems++;
+        items.Push(value);
+        set.Add(value);
+    }
+}

src/Backdash/Data/IObjectPool.cs

@@ -0,0 +1,18 @@
+namespace Backdash.Data;
+
+/// <summary>
+/// Defines a object pooling contract
+/// </summary>
+/// <typeparam name="T"></typeparam>
+public interface IObjectPool<T>
+{
+    /// <summary>
+    /// Rent an instance on <typeparamref name="T"/> from the pool
+    /// </summary>
+    T Rent();
+
+    /// <summary>
+    /// Return <paramref name="value"/> to the pool
+    /// </summary>
+    void Return(T value);
+}

src/Backdash/NetcodeOptions.cs

@@ -32,12 +32,21 @@ public sealed class NetcodeOptions
     public int RecommendationInterval { get; init; } = Default.RecommendationInterval;
 
     /// <summary>
-    /// Forces serialization byte order to network order <see cref="Endianness.BigEndian"/>.
+    /// Forces input serialization byte order to network order <see cref="Endianness.BigEndian"/>.
     /// </summary>
     /// <seealso cref="Endianness"/>
     /// <value>Defaults to <see langword="true"/></value>
     public bool UseNetworkEndianness { get; init; } = true;
 
+    /// <summary>
+    /// Sets the endianness used for state serialization.
+    /// If null, the same endianness as the input serializer will be used.
+    /// </summary>
+    /// <seealso cref="Endianness"/>
+    /// <seealso cref="UseNetworkEndianness"/>
+    /// <value>Defaults to <see cref="Endianness.LittleEndian"/></value>
+    public Endianness? StateSerializationEndianness { get; init; } = Endianness.LittleEndian;
+
     /// <summary>
     /// Max length for player input queues.
     /// </summary>

src/Backdash/Network/Messages/InputMessage.cs

@@ -57,7 +57,7 @@ public void Deserialize(in BinaryBufferReader reader)
         InputSize = reader.ReadByte();
         NumBits = reader.ReadUInt16();
         var bitCount = (int)Math.Ceiling(NumBits / (float)ByteSize.ByteToBits);
-        reader.ReadByte(Bits[..bitCount]);
+        reader.Read(Bits[..bitCount]);
     }
 
     public readonly bool TryFormat(