feat: INetworkMessage (#1187)

* FastBufferWriter implemented and tested (still need to add and update some xmldoc comments though)

* A few additional tests to cover the last missed cases I can think of (aside from INetworkSerializable, which isn't ready to be tested yet due to lack of BufferSerializer)

* FastBufferReader + tests

* - More tests
- Streamlined the implementations of bit-packing uints and ulongs.

* - Removed NativeArray from FastBufferReader and FastBufferWriter, replacing with byte* allocated directly through UnsafeUtility.Malloc() (same function used under the hood by NativeArray). This is required in order to be able to store pointers to FastBufferReader and FastBufferWriter in order to be able to wrap them with BufferSerializer - NativeArray contains a managed variable in it that disallows taking a pointer to it. And since FBW and FBR are structs, pointers are the only way to wrap them "by reference" in another struct - ref fields aren't allowed even inside ref structs.

* Added utility ref struct "Ref<T>" to more generically support wrapping values in other ref structs in a capture-by-reference style, updated BitReader and BitWriter to use that. Also aggressively inlining properties in FBW and FBR.

* BufferSerializer and tests.

* Removed unnecessary comment.

* XMLDocs + cleanup for PR

* Replaced possibly unaligned memory access with UnsafeUtility.MemCpy... it's a little slower, but apparently some platforms won't support unaligned memory access (e.g., WEBGL, ARM processors) and there's no compile time way to detect ARM processors since the bytecode is not processor-dependent... the cost of the runtime detection would be more expensive than the cost of just doing the memcpy.

* Resurrected BytewiseUtil.FastCopyBytes as a faster alternative to UnsafeUtility.MemCpy for small values, while still supporting unaligned access.

* Reverting an accidental change.

* Removed files that got accidentally duplicated from before the rename.

* Standards fixes

* Removed accidentally added files.

* Added BuildInfo.json to the .gitignore so I stop accidentally checking it in.

* Addressed most of the review feedback. Still need to do a little more restructuring of some of the other tests.

* standards.py --fix

* standards.py --fix

* Fixed incorrect namespaces.

* -Fixed a couple of issues where growing a FastBufferWriter wouldn't work correctly (requesting beyond MaxCapacity and requesting more than double current capacity)
-Added support for FastBufferReader to be used in a mode that doesn't copy the input buffer

* Fix a test failure and better implementation of large growths

* - Removed RefArray
- Fixed incorrect text in a warning in FastBufferReader

* First INetworkMessage WIP - not hooked up to anything yet.

* Killed DelayUtil.

* Hooked up MessagingSystem and converted ConnectionRequestMessage and ConnectionApprovedMessage.

A couple of tests are known to be failing... this is to let the work start being divided up.

* More converted messages

* Finished converting all messages over and removed all the now-dead code.

Several tests are failing... fixing them will be the next checkin.

* Removed IMessageHandler as it's no longer needed after DelayUtil went away.

* Fixed tests.

* standards.py --fix

* Corrected some incorrect xmldocs.

* -Added some tests for serializing RPC parameters using FastBufferReader/FastBufferWriter extension methods
-Fixed invalid IL code generated when using an extension method to serialize an array.

* Fixed missing send queue information for the server on StartClient().

* Added ILPP compile-time check for INetworkMessage Receive() function.

* Missed the meta file.

* Changed generic function lookup in ILPP to use Cecil instead of relying on system types.

* Changed scene management delivery type to ReliableFragmentedSequenced to support larger messages.

* Fixed DontDestroyWithOwner throwing an exception on disconnect, fixed memory leak if the server forcibly disconnects a client

* - Removed DynamicUnmanagedArray in favor of NativeList
- Changed ulong[] to IEnumerable<ulong> in ClientRpcParams

* standards.py --fix, plus some adjustments based on over-the-zoom-shoulder review with Fatih

* Not sure how standards.py --fix missed this the first time.

* increasing timeout in hopes it fixes test failure.

* Restored ClientConnected on the ServerClientId in StartClient... seems we can't rely on the server connect event to come in before messages get sent to it?

* Cherrypick from fast buffer reader/writer branch to fix accidentally reverted stuff.

* Applied much review feedback.

* Fixed snapshot stuff and also an outdated comment.

* More feedback.

* Fix standards check.

* Fixed an edge case where the temp serialize buffer could be too large to copy into the main one.

* Fixed metrics tests.

* standards.py --fix

* Renamed IBufferSerializerImplementation to IReaderWriter

* Ok... actually renamed IBufferSerializerImplementation to IReaderWriter...

* Missed a meta file

* Fixed missing OnAfterSendMessage hook when sending to localhost.

* Take 3 at a rename.

* standards.py --fix

Author: ShadauxCat

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

@@ -76,7 +76,7 @@ public bool SetTrigger(int key)
                 return TriggerParameters.Add(key);
             }
 
-            public void NetworkSerialize(NetworkSerializer serializer)
+            public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
             {
                 SerializeIntParameters(serializer);
                 SerializeFloatParameters(serializer);
@@ -85,28 +85,28 @@ public void NetworkSerialize(NetworkSerializer serializer)
                 SerializeAnimatorLayerStates(serializer);
             }
 
-            private void SerializeAnimatorLayerStates(NetworkSerializer serializer)
+            private void SerializeAnimatorLayerStates<T>(BufferSerializer<T> serializer) where T : IReaderWriter
             {
-                int layerCount = serializer.IsReading ? 0 : LayerStates.Length;
-                serializer.Serialize(ref layerCount);
+                int layerCount = serializer.IsReader ? 0 : LayerStates.Length;
+                serializer.SerializeValue(ref layerCount);
 
-                if (serializer.IsReading && LayerStates.Length != layerCount)
+                if (serializer.IsReader && LayerStates.Length != layerCount)
                 {
                     LayerStates = new LayerState[layerCount];
                 }
 
                 for (int paramIndex = 0; paramIndex < layerCount; paramIndex++)
                 {
-                    var stateHash = serializer.IsReading ? 0 : LayerStates[paramIndex].StateHash;
-                    serializer.Serialize(ref stateHash);
+                    var stateHash = serializer.IsReader ? 0 : LayerStates[paramIndex].StateHash;
+                    serializer.SerializeValue(ref stateHash);
 
-                    var layerWeight = serializer.IsReading ? 0 : LayerStates[paramIndex].LayerWeight;
-                    serializer.Serialize(ref layerWeight);
+                    var layerWeight = serializer.IsReader ? 0 : LayerStates[paramIndex].LayerWeight;
+                    serializer.SerializeValue(ref layerWeight);
 
-                    var normalizedStateTime = serializer.IsReading ? 0 : LayerStates[paramIndex].NormalizedStateTime;
-                    serializer.Serialize(ref normalizedStateTime);
+                    var normalizedStateTime = serializer.IsReader ? 0 : LayerStates[paramIndex].NormalizedStateTime;
+                    serializer.SerializeValue(ref normalizedStateTime);
 
-                    if (serializer.IsReading)
+                    if (serializer.IsReader)
                     {
                         LayerStates[paramIndex] = new LayerState()
                         {
@@ -118,103 +118,103 @@ private void SerializeAnimatorLayerStates(NetworkSerializer serializer)
                 }
             }
 
-            private void SerializeTriggerParameters(NetworkSerializer serializer)
+            private void SerializeTriggerParameters<T>(BufferSerializer<T> serializer) where T : IReaderWriter
             {
-                int paramCount = serializer.IsReading ? 0 : TriggerParameters.Count;
-                serializer.Serialize(ref paramCount);
+                int paramCount = serializer.IsReader ? 0 : TriggerParameters.Count;
+                serializer.SerializeValue(ref paramCount);
 
-                var paramArray = serializer.IsReading ? new int[paramCount] : TriggerParameters.ToArray();
+                var paramArray = serializer.IsReader ? new int[paramCount] : TriggerParameters.ToArray();
                 for (int i = 0; i < paramCount; i++)
                 {
-                    var paramId = serializer.IsReading ? 0 : paramArray[i];
-                    serializer.Serialize(ref paramId);
+                    var paramId = serializer.IsReader ? 0 : paramArray[i];
+                    serializer.SerializeValue(ref paramId);
 
-                    if (serializer.IsReading)
+                    if (serializer.IsReader)
                     {
                         paramArray[i] = paramId;
                     }
                 }
 
-                if (serializer.IsReading)
+                if (serializer.IsReader)
                 {
                     TriggerParameters = new HashSet<int>(paramArray);
                 }
             }
 
-            private void SerializeBoolParameters(NetworkSerializer serializer)
+            private void SerializeBoolParameters<T>(BufferSerializer<T> serializer) where T : IReaderWriter
             {
-                int paramCount = serializer.IsReading ? 0 : BoolParameters.Count;
-                serializer.Serialize(ref paramCount);
+                int paramCount = serializer.IsReader ? 0 : BoolParameters.Count;
+                serializer.SerializeValue(ref paramCount);
 
-                var paramArray = serializer.IsReading ? new KeyValuePair<int, bool>[paramCount] : BoolParameters.ToArray();
+                var paramArray = serializer.IsReader ? new KeyValuePair<int, bool>[paramCount] : BoolParameters.ToArray();
                 for (int paramIndex = 0; paramIndex < paramCount; paramIndex++)
                 {
-                    var paramId = serializer.IsReading ? 0 : paramArray[paramIndex].Key;
-                    serializer.Serialize(ref paramId);
+                    var paramId = serializer.IsReader ? 0 : paramArray[paramIndex].Key;
+                    serializer.SerializeValue(ref paramId);
 
-                    var paramBool = serializer.IsReading ? false : paramArray[paramIndex].Value;
-                    serializer.Serialize(ref paramBool);
+                    var paramBool = serializer.IsReader ? false : paramArray[paramIndex].Value;
+                    serializer.SerializeValue(ref paramBool);
 
-                    if (serializer.IsReading)
+                    if (serializer.IsReader)
                     {
                         paramArray[paramIndex] = new KeyValuePair<int, bool>(paramId, paramBool);
                     }
                 }
 
-                if (serializer.IsReading)
+                if (serializer.IsReader)
                 {
                     BoolParameters = paramArray.ToDictionary(pair => pair.Key, pair => pair.Value);
                 }
             }
 
-            private void SerializeFloatParameters(NetworkSerializer serializer)
+            private void SerializeFloatParameters<T>(BufferSerializer<T> serializer) where T : IReaderWriter
             {
-                int paramCount = serializer.IsReading ? 0 : FloatParameters.Count;
-                serializer.Serialize(ref paramCount);
+                int paramCount = serializer.IsReader ? 0 : FloatParameters.Count;
+                serializer.SerializeValue(ref paramCount);
 
-                var paramArray = serializer.IsReading ? new KeyValuePair<int, float>[paramCount] : FloatParameters.ToArray();
+                var paramArray = serializer.IsReader ? new KeyValuePair<int, float>[paramCount] : FloatParameters.ToArray();
                 for (int paramIndex = 0; paramIndex < paramCount; paramIndex++)
                 {
-                    var paramId = serializer.IsReading ? 0 : paramArray[paramIndex].Key;
-                    serializer.Serialize(ref paramId);
+                    var paramId = serializer.IsReader ? 0 : paramArray[paramIndex].Key;
+                    serializer.SerializeValue(ref paramId);
 
-                    var paramFloat = serializer.IsReading ? 0 : paramArray[paramIndex].Value;
-                    serializer.Serialize(ref paramFloat);
+                    var paramFloat = serializer.IsReader ? 0 : paramArray[paramIndex].Value;
+                    serializer.SerializeValue(ref paramFloat);
 
-                    if (serializer.IsReading)
+                    if (serializer.IsReader)
                     {
                         paramArray[paramIndex] = new KeyValuePair<int, float>(paramId, paramFloat);
                     }
                 }
 
-                if (serializer.IsReading)
+                if (serializer.IsReader)
                 {
                     FloatParameters = paramArray.ToDictionary(pair => pair.Key, pair => pair.Value);
                 }
             }
 
-            private void SerializeIntParameters(NetworkSerializer serializer)
+            private void SerializeIntParameters<T>(BufferSerializer<T> serializer) where T : IReaderWriter
             {
-                int paramCount = serializer.IsReading ? 0 : IntParameters.Count;
-                serializer.Serialize(ref paramCount);
+                int paramCount = serializer.IsReader ? 0 : IntParameters.Count;
+                serializer.SerializeValue(ref paramCount);
 
-                var paramArray = serializer.IsReading ? new KeyValuePair<int, int>[paramCount] : IntParameters.ToArray();
+                var paramArray = serializer.IsReader ? new KeyValuePair<int, int>[paramCount] : IntParameters.ToArray();
 
                 for (int paramIndex = 0; paramIndex < paramCount; paramIndex++)
                 {
-                    var paramId = serializer.IsReading ? 0 : paramArray[paramIndex].Key;
-                    serializer.Serialize(ref paramId);
+                    var paramId = serializer.IsReader ? 0 : paramArray[paramIndex].Key;
+                    serializer.SerializeValue(ref paramId);
 
-                    var paramInt = serializer.IsReading ? 0 : paramArray[paramIndex].Value;
-                    serializer.Serialize(ref paramInt);
+                    var paramInt = serializer.IsReader ? 0 : paramArray[paramIndex].Value;
+                    serializer.SerializeValue(ref paramInt);
 
-                    if (serializer.IsReading)
+                    if (serializer.IsReader)
                     {
                         paramArray[paramIndex] = new KeyValuePair<int, int>(paramId, paramInt);
                     }
                 }
 
-                if (serializer.IsReading)
+                if (serializer.IsReader)
                 {
                     IntParameters = paramArray.ToDictionary(pair => pair.Key, pair => pair.Value);
                 }

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

@@ -169,57 +169,57 @@ public Vector3 Scale
                 }
             }
 
-            public void NetworkSerialize(NetworkSerializer serializer)
+            public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
             {
-                serializer.Serialize(ref SentTime);
+                serializer.SerializeValue(ref SentTime);
                 // InLocalSpace + HasXXX Bits
-                serializer.Serialize(ref Bitset);
+                serializer.SerializeValue(ref Bitset);
                 // Position Values
                 if (HasPositionX)
                 {
-                    serializer.Serialize(ref PositionX);
+                    serializer.SerializeValue(ref PositionX);
                 }
 
                 if (HasPositionY)
                 {
-                    serializer.Serialize(ref PositionY);
+                    serializer.SerializeValue(ref PositionY);
                 }
 
                 if (HasPositionZ)
                 {
-                    serializer.Serialize(ref PositionZ);
+                    serializer.SerializeValue(ref PositionZ);
                 }
 
                 // RotAngle Values
                 if (HasRotAngleX)
                 {
-                    serializer.Serialize(ref RotAngleX);
+                    serializer.SerializeValue(ref RotAngleX);
                 }
 
                 if (HasRotAngleY)
                 {
-                    serializer.Serialize(ref RotAngleY);
+                    serializer.SerializeValue(ref RotAngleY);
                 }
 
                 if (HasRotAngleZ)
                 {
-                    serializer.Serialize(ref RotAngleZ);
+                    serializer.SerializeValue(ref RotAngleZ);
                 }
 
                 // Scale Values
                 if (HasScaleX)
                 {
-                    serializer.Serialize(ref ScaleX);
+                    serializer.SerializeValue(ref ScaleX);
                 }
 
                 if (HasScaleY)
                 {
-                    serializer.Serialize(ref ScaleY);
+                    serializer.SerializeValue(ref ScaleY);
                 }
 
                 if (HasScaleZ)
                 {
-                    serializer.Serialize(ref ScaleZ);
+                    serializer.SerializeValue(ref ScaleZ);
                 }
             }
         }

com.unity.netcode.gameobjects/Editor/CodeGen/CodeGenHelpers.cs

@@ -17,6 +17,7 @@ internal static class CodeGenHelpers
         public const string RuntimeAssemblyName = "Unity.Netcode.Runtime";
 
         public static readonly string NetworkBehaviour_FullName = typeof(NetworkBehaviour).FullName;
+        public static readonly string INetworkMessage_FullName = typeof(INetworkMessage).FullName;
         public static readonly string ServerRpcAttribute_FullName = typeof(ServerRpcAttribute).FullName;
         public static readonly string ClientRpcAttribute_FullName = typeof(ClientRpcAttribute).FullName;
         public static readonly string ServerRpcParams_FullName = typeof(ServerRpcParams).FullName;
@@ -264,9 +265,9 @@ public static void AddError(this List<DiagnosticMessage> diagnostics, SequencePo
             });
         }
 
-        public static AssemblyDefinition AssemblyDefinitionFor(ICompiledAssembly compiledAssembly)
+        public static AssemblyDefinition AssemblyDefinitionFor(ICompiledAssembly compiledAssembly, out PostProcessorAssemblyResolver assemblyResolver)
         {
-            var assemblyResolver = new PostProcessorAssemblyResolver(compiledAssembly);
+            assemblyResolver = new PostProcessorAssemblyResolver(compiledAssembly);
             var readerParameters = new ReaderParameters
             {
                 SymbolStream = new MemoryStream(compiledAssembly.InMemoryAssembly.PdbData),