feat: INetworkMessage

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),