Merge branch 'develop' into sam/feature/client-network-transform

* develop:
  feat: INetworkMessage (#1187)
  fix: Increase timeout for UTP adapter tests (#1199)
  docs: Update repo and both package readme files (#1180)
  chore: updating UTP package to pull in DTLS fixes (#1197)
  fix: network time arguments (#1194)
  feat: network physics (#1175)

# Conflicts:
#	com.unity.netcode.gameobjects/Components/Interpolator/BufferedLinearInterpolator.cs
#	com.unity.netcode.gameobjects/Components/NetworkTransform.cs
#	testproject/Assets/Prefabs/PlayerCube.prefab

Author: SamuelBellomo

README.md

@@ -1,80 +1,46 @@
-[![](https://i.imgur.com/d0amtqs.png)](https://mlapi.network/)
+[![Forums](https://img.shields.io/badge/unity--forums-multiplayer-blue)](https://forum.unity.com/forums/multiplayer.26/) [![Discord](https://img.shields.io/discord/449263083769036810.svg?label=discord&logo=discord&color=informational)](https://discord.gg/FM8SE9E)
+[![Website](https://img.shields.io/badge/docs-website-informational.svg)](https://docs-multiplayer.unity3d.com/) [![Api](https://img.shields.io/badge/docs-api-informational.svg)](https://docs-multiplayer.unity3d.com/docs/mlapi-api/introduction)
 
-[![GitHub Release](https://img.shields.io/github/release/MidLevel/MLAPI.svg?logo=github)](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/releases/latest)
-[![Github All Releases](https://img.shields.io/github/downloads/MidLevel/MLAPI/total.svg?logo=github&color=informational)](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/releases)
+[![GitHub Release](https://img.shields.io/github/release/Unity-Technologies/com.unity.netcode.gameobjects.svg?logo=github)](https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/releases/latest)
 
-[![Forums](https://img.shields.io/badge/unity--forums-multiplayer-blue)](https://forum.unity.com/forums/multiplayer.26/)
-[![Discord](https://img.shields.io/discord/449263083769036810.svg?label=discord&logo=discord&color=informational)](https://discord.gg/FM8SE9E)
+### Welcome!
 
+Welcome to the Netcode for GameObjects repository.
 
-[![Website](https://img.shields.io/badge/docs-website-informational.svg)](https://docs-multiplayer.unity3d.com/)
-[![Api](https://img.shields.io/badge/docs-api-informational.svg)](https://docs-multiplayer.unity3d.com/docs/mlapi-api/introduction)
-
-
-The Unity MLAPI (Mid level API) is a framework that simplifies building networked games in Unity. It offers **low level** access to core networking while at the same time providing **high level** abstractions. The MLAPI aims to remove the repetitive tasks and reduces the network code dramatically, no matter how many of the **modular** features you use.
+Netcode for GameObjects is a Unity package that provides networking capabilities to GameObject & MonoBehaviour workflows. The framework is interoperable with many low-level transports, including the official [Unity Transport Package](https://docs.unity3d.com/Packages/com.unity.transport@1.0/manual/index.html).
 
 ### Getting Started
-To get started, check the [Multiplayer Docs Site](https://docs-multiplayer.unity3d.com/).
+Visit the [Multiplayer Docs Site](https://docs-multiplayer.unity3d.com/) for package & API documentation, as well as information about several samples which leverage the Netcode for GameObjects package.
+
+You can also jump right into our [Hello World](https://docs-multiplayer.unity3d.com/docs/tutorials/helloworld/helloworldintro/index.html) guide for a taste of how to use the framework for basic networked tasks.
 
 ### Community and Feedback
-For general questions, networking advice or discussions about MLAPI, please join our [Discord Community](https://discord.gg/FM8SE9E) or create a post in the [Unity Multiplayer Forum](https://forum.unity.com/forums/multiplayer.26/).
+For general questions, networking advice or discussions about Netcode for GameObjects, please join our [Discord Community](https://discord.gg/FM8SE9E) or create a post in the [Unity Multiplayer Forum](https://forum.unity.com/forums/multiplayer.26/).
 
 ### Compatibility
-The MLAPI supports all major Unity platforms. To use the WebGL platform a custom WebGL transport based on web sockets is needed.
 
-MLAPI is compatible with Unity 2019 and newer versions.
+Netcode for GameObjects targets the following Unity versions:
+- Unity 2020.3, 2021.1, and 2021.2
+
+On the following runtime platforms:
+- Windows, MacOS, and Linux
+- iOS and Android
+- Most closed platforms, such as consoles. Contact us for more information about specific closed platforms.
 
 ### Development
 We follow the [Gitflow Workflow](https://www.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow). The master branch contains our latest stable release version while the develop branch tracks our current work.
 
 This repository is broken into multiple components, each one implemented as a Unity Package.
 ```
     .
-    ├── com.unity.multiplayer.mlapi             # The core netcode SDK unity package (source + tests)
-    ├── com.unity.netcode.adapter.utp           # Transport wrapper for com.unity.transport experimental package (not currently supported)
-    └── testproject                             # A Unity project with various test implementations & scenes which exercise the features in the above package(s).
+    ├── com.unity.netcode.gameobjects           # The core netcode SDK unity package (source + tests)
+    ├── com.unity.netcode.adapter.utp           # Transport wrapper for com.unity.transport
+    └── testproject                             # A Unity project with various test implementations & scenes which exercise the features in the above packages.
 ```
 
 ### Contributing
-The MLAPI is an open-source project and we encourage and welcome
-contributions. If you wish to contribute, be sure to review our
-[contribution guidelines](CONTRIBUTING.md)
+We are an open-source project and we encourage and welcome contributions. If you wish to contribute, be sure to review our [contribution guidelines](CONTRIBUTING.md).
 
-### Issues and missing features
+#### Issues and missing features
 If you have an issue, bug or feature request, please follow the information in our [contribution guidelines](CONTRIBUTING.md) to submit an issue.
-
-### Example
-Here is a sample MonoBehaviour showing a chat script where everyone can write and read from. This shows the basis of the MLAPI and the abstractions it adds.
-
-```csharp
-public class Chat : NetworkBehaviour
-{
-    private NetworkList<string> ChatMessages = new NetworkList<string>(new MLAPI.NetworkVariable.NetworkVariableSettings()
-    {
-        ReadPermission = MLAPI.NetworkVariable.NetworkVariablePermission.Everyone,
-        WritePermission = MLAPI.NetworkVariable.NetworkVariablePermission.Everyone,
-        SendTickrate = 5
-    }, new List<string>());
-
-    private string textField = "";
-
-    private void OnGUI()
-    {
-        if (IsClient)
-        {
-            textField = GUILayout.TextField(textField, GUILayout.Width(200));
-            
-            if (GUILayout.Button("Send") && !string.IsNullOrWhiteSpace(textField))
-            {
-                ChatMessages.Add(textField);
-                textField = "";
-            }
-
-            for (int i = ChatMessages.Count - 1; i >= 0; i--)
-            {
-                GUILayout.Label(ChatMessages[i]);
-            }
-        }
-    }
-}
-```
+You can also check out our public [roadmap](https://unity.com/roadmap/unity-platform/multiplayer-networking) to get an idea for what we might be working on next!

com.unity.netcode.adapter.utp/README.md

@@ -1,3 +1,3 @@
-com.unity.transport transport for Netcode for GameObjects
+Unity Transport for Netcode for GameObjects is a transport adapter which enables the use of [Unity Transport Package](https://docs.unity3d.com/Packages/com.unity.transport@1.0/manual/index.html) as a low-level transport for Netcode for GameObjects.
 
-WIP: This is not a functional transport just a work in progress and should not be used as any measure of current state a very early proof of concept and place holder package. 
+This library is an implementation of NetworkTransport to provide configuration and interoperability for Unity Transport with the Netcode for GameObjects package, enabling cross platform UDP-based network communication to a Unity project.

com.unity.netcode.adapter.utp/Tests/Runtime/Helpers/RuntimeTestsHelpers.cs

@@ -9,12 +9,10 @@ namespace Unity.Netcode.UTP.RuntimeTests
 {
     public static class RuntimeTestsHelpers
     {
-        // 50ms should be plenty enough for any network interaction to occur (even roundtrips).
-#if UNITY_STANDALONE_OSX || UNITY_EDITOR_OSX || UNITY_ANDROID
-        public const float MaxNetworkEventWaitTime = 0.35f;
-#else
-        public const float MaxNetworkEventWaitTime = 0.15f;
-#endif
+        // Half a second might seem like a very long time to wait for a network event, but in CI
+        // many of the machines are underpowered (e.g. old Android devices or Macs) and there are
+        // sometimes lag spikes that cause can cause delays upwards of 300ms.
+        public const float MaxNetworkEventWaitTime = 0.5f;
 
         // Wait for an event to appear in the given event list (must be the very next event).
         public static IEnumerator WaitForNetworkEvent(NetworkEvent type, List<TransportEvent> events)

com.unity.netcode.adapter.utp/package.json

@@ -6,6 +6,6 @@
   "unity": "2020.3",
   "dependencies": {
     "com.unity.netcode.gameobjects": "0.0.1-preview.1",
-    "com.unity.transport": "1.0.0-pre.4"
+    "com.unity.transport": "1.0.0-pre.5"
   }
 }

com.unity.netcode.gameobjects/Components/Interpolator/BufferedLinearInterpolator.cs

@@ -16,7 +16,7 @@ internal interface IInterpolatorTime
         {
             double BufferedServerTime { get; }
             double BufferedServerFixedTime { get; }
-            int TickRate { get; }
+            uint TickRate { get; }
         }
 
         private class InterpolatorTime : IInterpolatorTime
@@ -28,7 +28,7 @@ public InterpolatorTime(NetworkManager manager)
             }
             public double BufferedServerTime => m_Manager.ServerTime.Time;
             public double BufferedServerFixedTime => m_Manager.ServerTime.FixedTime;
-            public int TickRate => m_Manager.ServerTime.TickRate;
+            public uint TickRate => m_Manager.ServerTime.TickRate;
         }
 
         internal IInterpolatorTime InterpolatorTimeProxy;

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);
                 }