com.unity.netcode.gameobjects@1.10.0

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).
## [1.10.0] - 2024-07-22

### Added

- Added `NetworkBehaviour.OnNetworkPreSpawn` and `NetworkBehaviour.OnNetworkPostSpawn` methods that provide the ability to handle pre and post spawning actions during the `NetworkObject` spawn sequence. (#2906)
- Added a client-side only `NetworkBehaviour.OnNetworkSessionSynchronized` convenience method that is invoked on all `NetworkBehaviour`s after a newly joined client has finished synchronizing with the network session in progress. (#2906)
- Added `NetworkBehaviour.OnInSceneObjectsSpawned` convenience method that is invoked when all in-scene `NetworkObject`s have been spawned after a scene has been loaded or upon a host or server starting. (#2906)

### Fixed

- Fixed issue where the realtime network stats monitor was not able to display RPC traffic in release builds due to those stats being only available in development builds or the editor. (#2980)
- Fixed issue where `NetworkManager.ScenesLoaded` was not being updated if `PostSynchronizationSceneUnloading` was set and any loaded scenes not used during synchronization were unloaded.(#2977)
- Fixed issue where internal delta serialization could not have a byte serializer defined when serializing deltas for other types. Added `[GenerateSerializationForType(typeof(byte))]` to both the `NetworkVariable` and `AnticipatedNetworkVariable` classes to assure a byte serializer is defined. (#2953)
- Fixed issue with the client count not being correct on the host or server side when a client disconnects itself from a session. (#2941)
- Fixed issue with the host trying to send itself a message that it has connected when first starting up. (#2941)
- Fixed issue where in-scene placed NetworkObjects could be destroyed if a client disconnects early and/or before approval. (#2923)
- Fixed issue where `NetworkDeltaPosition` would "jitter" periodically if both unreliable delta state updates and half-floats were used together. (#2922)
- Fixed issue where `NetworkRigidbody2D` would not properly change body type based on the instance's authority when spawned. (#2916)
- Fixed issue where a `NetworkObject` component's associated `NetworkBehaviour` components would not be detected if scene loading is disabled in the editor and the currently loaded scene has in-scene placed `NetworkObject`s. (#2906)
- Fixed issue where an in-scene placed `NetworkObject` with `NetworkTransform` that is also parented under a `GameObject` would not properly synchronize when the parent `GameObject` had a world space position other than 0,0,0. (#2895)

### Changed

CHANGELOG.md

@@ -5,6 +5,583 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).
+## [1.10.0] - 2024-07-22
+
+### Added
+
+- Added `NetworkBehaviour.OnNetworkPreSpawn` and `NetworkBehaviour.OnNetworkPostSpawn` methods that provide the ability to handle pre and post spawning actions during the `NetworkObject` spawn sequence. (#2906)
+- Added a client-side only `NetworkBehaviour.OnNetworkSessionSynchronized` convenience method that is invoked on all `NetworkBehaviour`s after a newly joined client has finished synchronizing with the network session in progress. (#2906)
+- Added `NetworkBehaviour.OnInSceneObjectsSpawned` convenience method that is invoked when all in-scene `NetworkObject`s have been spawned after a scene has been loaded or upon a host or server starting. (#2906)
+
+### Fixed
+
+- Fixed issue where the realtime network stats monitor was not able to display RPC traffic in release builds due to those stats being only available in development builds or the editor. (#2980)
+- Fixed issue where `NetworkManager.ScenesLoaded` was not being updated if `PostSynchronizationSceneUnloading` was set and any loaded scenes not used during synchronization were unloaded.(#2977)
+- Fixed issue where internal delta serialization could not have a byte serializer defined when serializing deltas for other types. Added `[GenerateSerializationForType(typeof(byte))]` to both the `NetworkVariable` and `AnticipatedNetworkVariable` classes to assure a byte serializer is defined. (#2953)
+- Fixed issue with the client count not being correct on the host or server side when a client disconnects itself from a session. (#2941)
+- Fixed issue with the host trying to send itself a message that it has connected when first starting up. (#2941)
+- Fixed issue where in-scene placed NetworkObjects could be destroyed if a client disconnects early and/or before approval. (#2923)
+- Fixed issue where `NetworkDeltaPosition` would "jitter" periodically if both unreliable delta state updates and half-floats were used together. (#2922)
+- Fixed issue where `NetworkRigidbody2D` would not properly change body type based on the instance's authority when spawned. (#2916)
+- Fixed issue where a `NetworkObject` component's associated `NetworkBehaviour` components would not be detected if scene loading is disabled in the editor and the currently loaded scene has in-scene placed `NetworkObject`s. (#2906)
+- Fixed issue where an in-scene placed `NetworkObject` with `NetworkTransform` that is also parented under a `GameObject` would not properly synchronize when the parent `GameObject` had a world space position other than 0,0,0. (#2895)
+
+### Changed
+
+
+## [1.9.1] - 2024-04-18
+
+### Added
+- Added AnticipatedNetworkVariable<T>, which adds support for client anticipation of NetworkVariable values, allowing for more responsive gameplay (#2820)
+- Added AnticipatedNetworkTransform, which adds support for client anticipation of NetworkTransforms (#2820)
+- Added NetworkVariableBase.ExceedsDirtinessThreshold to allow network variables to throttle updates by only sending updates when the difference between the current and previous values exceeds a threshold. (This is exposed in NetworkVariable<T> with the callback NetworkVariable<T>.CheckExceedsDirtinessThreshold) (#2820)
+- Added NetworkVariableUpdateTraits, which add additional throttling support: MinSecondsBetweenUpdates will prevent the NetworkVariable from sending updates more often than the specified time period (even if it exceeds the dirtiness threshold), while MaxSecondsBetweenUpdates will force a dirty NetworkVariable to send an update after the specified time period even if it has not yet exceeded the dirtiness threshold. (#2820)
+- Added virtual method NetworkVariableBase.OnInitialize() which can be used by NetworkVariable subclasses to add initialization code (#2820)
+- Added virtual method NetworkVariableBase.Update(), which is called once per frame to support behaviors such as interpolation between an anticipated value and an authoritative one. (#2820)
+- Added NetworkTime.TickWithPartial, which represents the current tick as a double that includes the fractional/partial tick value. (#2820)
+- `NetworkVariable` now includes built-in support for `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, and `Dictionary` (#2813)
+- `NetworkVariable` now includes delta compression for collection values (`NativeList`, `NativeArray`, `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, `Dictionary`, and `FixedString` types) to save bandwidth by only sending the values that changed. (Note: For `NativeList`, `NativeArray`, and `List`, this algorithm works differently than that used in `NetworkList`. This algorithm will use less bandwidth for "set" and "add" operations, but `NetworkList` is more bandwidth-efficient if you are performing frequent "insert" operations.) (#2813)
+- `UserNetworkVariableSerialization` now has optional callbacks for `WriteDelta` and `ReadDelta`. If both are provided, they will be used for all serialization operations on NetworkVariables of that type except for the first one for each client. If either is missing, the existing `Write` and `Read` will always be used. (#2813)
+- Network variables wrapping `INetworkSerializable` types can perform delta serialization by setting `UserNetworkVariableSerialization<T>.WriteDelta` and `UserNetworkVariableSerialization<T>.ReadDelta` for those types. The built-in `INetworkSerializable` serializer will continue to be used for all other serialization operations, but if those callbacks are set, it will call into them on all but the initial serialization to perform delta serialization. (This could be useful if you have a large struct where most values do not change regularly and you want to send only the fields that did change.) (#2813)
+
+### Fixed
+
+- Fixed issue where NetworkTransformEditor would throw and exception if you excluded the physics package. (#2871)
+- Fixed issue where `NetworkTransform` could not properly synchronize its base position when using half float precision. (#2845)
+- Fixed issue where the host was not invoking `OnClientDisconnectCallback` for its own local client when internally shutting down. (#2822)
+- Fixed issue where NetworkTransform could potentially attempt to "unregister" a named message prior to it being registered. (#2807)
+- Fixed issue where in-scene placed `NetworkObject`s with complex nested children `NetworkObject`s (more than one child in depth) would not synchronize properly if WorldPositionStays was set to true. (#2796)
+
+### Changed
+
+- Changed `NetworkObjectReference` and `NetworkBehaviourReference` to allow null references when constructing and serializing. (#2874)
+- Changed `NetworkAnimator` no longer requires the `Animator` component to exist on the same `GameObject`. (#2872)
+- Changed `NetworkTransform` to now use `NetworkTransformMessage` as opposed to named messages for NetworkTransformState updates. (#2810)
+- Changed `CustomMessageManager` so it no longer attempts to register or "unregister" a null or empty string and will log an error if this condition occurs. (#2807)
+
+## [1.8.1] - 2024-02-05
+
+### Fixed
+
+- Fixed a compile error when compiling for IL2CPP targets when using the new `[Rpc]` attribute. (#2824)
+
+## [1.8.0] - 2023-12-12
+
+### Added
+
+- Added a new RPC attribute, which is simply `Rpc`. (#2762)
+  - This is a generic attribute that can perform the functions of both Server and Client RPCs, as well as enabling client-to-client RPCs. Includes several default targets: `Server`, `NotServer`, `Owner`, `NotOwner`, `Me`, `NotMe`, `ClientsAndHost`, and `Everyone`. Runtime overrides are available for any of these targets, as well as for sending to a specific ID or groups of IDs.
+  - This attribute also includes the ability to defer RPCs that are sent to the local process to the start of the next frame instead of executing them immediately, treating them as if they had gone across the network. The default behavior is to execute immediately.
+  - This attribute effectively replaces `ServerRpc` and `ClientRpc`. `ServerRpc` and `ClientRpc` remain in their existing forms for backward compatibility, but `Rpc` will be the recommended and most supported option.
+- Added `NetworkManager.OnConnectionEvent` as a unified connection event callback to notify clients and servers of all client connections and disconnections within the session (#2762)
+- Added `NetworkManager.ServerIsHost` and `NetworkBehaviour.ServerIsHost` to allow a client to tell if it is connected to a host or to a dedicated server (#2762)
+- Added `SceneEventProgress.SceneManagementNotEnabled` return status to be returned when a `NetworkSceneManager` method is invoked and scene management is not enabled. (#2735)
+- Added `SceneEventProgress.ServerOnlyAction` return status to be returned when a `NetworkSceneManager` method is invoked by a client. (#2735)
+- Added `NetworkObject.InstantiateAndSpawn` and `NetworkSpawnManager.InstantiateAndSpawn` methods to simplify prefab spawning by assuring that the prefab is valid and applies any override prior to instantiating the `GameObject` and spawning the `NetworkObject` instance. (#2710)
+
+### Fixed
+
+- Fixed issue where a client disconnected by a server-host would not receive a local notification. (#2789)
+- Fixed issue where a server-host could shutdown during a relay connection but periodically the transport disconnect message sent to any connected clients could be dropped. (#2789)
+- Fixed issue where a host could disconnect its local client but remain running as a server. (#2789)
+- Fixed issue where `OnClientDisconnectedCallback` was not being invoked under certain conditions. (#2789)
+- Fixed issue where `OnClientDisconnectedCallback` was always returning 0 as the client identifier. (#2789)
+- Fixed issue where if a host or server shutdown while a client owned NetworkObjects (other than the player) it would throw an exception. (#2789)
+- Fixed issue where setting values on a `NetworkVariable` or `NetworkList` within `OnNetworkDespawn` during a shutdown sequence would throw an exception. (#2789)
+- Fixed issue where a teleport state could potentially be overridden by a previous unreliable delta state. (#2777)
+- Fixed issue where `NetworkTransform` was using the `NetworkManager.ServerTime.Tick` as opposed to `NetworkManager.NetworkTickSystem.ServerTime.Tick` during the authoritative side's tick update where it performed a delta state check. (#2777)
+- Fixed issue where a parented in-scene placed NetworkObject would be destroyed upon a client or server exiting a network session but not unloading the original scene in which the NetworkObject was placed. (#2737)
+- Fixed issue where during client synchronization and scene loading, when client synchronization or the scene loading mode are set to `LoadSceneMode.Single`, a `CreateObjectMessage` could be received, processed, and the resultant spawned `NetworkObject` could be instantiated in the client's currently active scene that could, towards the end of the client synchronization or loading process, be unloaded and cause the newly created `NetworkObject` to be destroyed (and throw and exception). (#2735)
+- Fixed issue where a `NetworkTransform` instance with interpolation enabled would result in wide visual motion gaps (stuttering) under above normal latency conditions and a 1-5% or higher packet are drop rate. (#2713)
+- Fixed issue where  you could not have multiple source network prefab overrides targeting the same network prefab as their override. (#2710)
+
+### Changed
+- Changed the server or host shutdown so it will now perform a "soft shutdown" when `NetworkManager.Shutdown` is invoked. This will send a disconnect notification to all connected clients and the server-host will wait for all connected clients to disconnect or timeout after a 5 second period before completing the shutdown process. (#2789)
+- Changed `OnClientDisconnectedCallback` will now return the assigned client identifier on the local client side if the client was approved and assigned one prior to being disconnected. (#2789)
+- Changed `NetworkTransform.SetState` (and related methods) now are cumulative during a fractional tick period and sent on the next pending tick. (#2777)
+- `NetworkManager.ConnectedClientsIds` is now accessible on the client side and will contain the list of all clients in the session, including the host client if the server is operating in host mode (#2762)
+- Changed `NetworkSceneManager` to return a `SceneEventProgress` status and not throw exceptions for methods invoked when scene management is disabled and when a client attempts to access a `NetworkSceneManager` method by a client. (#2735)
+- Changed `NetworkTransform` authoritative instance tick registration so a single `NetworkTransform` specific tick event update will update all authoritative instances to improve perofmance. (#2713)
+- Changed `NetworkPrefabs.OverrideToNetworkPrefab` dictionary is no longer used/populated due to it ending up being related to a regression bug and not allowing more than one override to be assigned to a network prefab asset. (#2710)
+- Changed in-scene placed `NetworkObject`s now store their source network prefab asset's `GlobalObjectIdHash` internally that is used, when scene management is disabled, by clients to spawn the correct prefab even if the `NetworkPrefab` entry has an override. This does not impact dynamically spawning the same prefab which will yield the override on both host and client. (#2710)
+- Changed in-scene placed `NetworkObject`s no longer require a `NetworkPrefab` entry with `GlobalObjectIdHash` override in order for clients to properly synchronize. (#2710)
+- Changed in-scene placed `NetworkObject`s now set their `IsSceneObject` value when generating their `GlobalObjectIdHash` value. (#2710)
+- Changed the default `NetworkConfig.SpawnTimeout` value from 1.0s to 10.0s. (#2710)
+
+## [1.7.1] - 2023-11-15
+
+### Added
+
+### Fixed
+
+- Fixed a bug where having a class with Rpcs that inherits from a class without Rpcs that inherits from NetworkVariable would cause a compile error. (#2751)
+- Fixed issue where `NetworkBehaviour.Synchronize` was not truncating the write buffer if nothing was serialized during `NetworkBehaviour.OnSynchronize` causing an additional 6 bytes to be written per `NetworkBehaviour` component instance. (#2749)
+
+## [1.7.0] - 2023-10-11
+
+### Added
+
+- exposed NetworkObject.GetNetworkBehaviourAtOrderIndex as a public API (#2724)
+- Added context menu tool that provides users with the ability to quickly update the GlobalObjectIdHash value for all in-scene placed prefab instances that were created prior to adding a NetworkObject component to it. (#2707)
+- Added methods NetworkManager.SetPeerMTU and NetworkManager.GetPeerMTU to be able to set MTU sizes per-peer (#2676)
+- Added `GenerateSerializationForGenericParameterAttribute`, which can be applied to user-created Network Variable types to ensure the codegen generates serialization for the generic types they wrap. (#2694)
+- Added `GenerateSerializationForTypeAttribute`, which can be applied to any class or method to ensure the codegen generates serialization for the specific provided type. (#2694)
+- Exposed `NetworkVariableSerialization<T>.Read`, `NetworkVariableSerialization<T>.Write`, `NetworkVariableSerialization<T>.AreEqual`, and `NetworkVariableSerialization<T>.Duplicate` to further support the creation of user-created network variables by allowing users to access the generated serialization methods and serialize generic types efficiently without boxing. (#2694)
+- Added `NetworkVariableBase.MarkNetworkBehaviourDirty` so that user-created network variable types can mark their containing `NetworkBehaviour` to be processed by the update loop. (#2694)
+
+### Fixed
+
+- Fixed issue where the server side `NetworkSceneManager` instance was not adding the currently active scene to its list of scenes loaded. (#2723)
+- Generic NetworkBehaviour types no longer result in compile errors or runtime errors (#2720)
+- Rpcs within Generic NetworkBehaviour types can now serialize parameters of the class's generic types (but may not have generic types of their own) (#2720)
+- Errors are no longer thrown when entering play mode with domain reload disabled (#2720)
+- NetworkSpawn is now correctly called each time when entering play mode with scene reload disabled (#2720)
+- NetworkVariables of non-integer types will no longer break the inspector (#2714)
+- NetworkVariables with NonSerializedAttribute will not appear in the inspector (#2714)
+- Fixed issue where `UnityTransport` would attempt to establish WebSocket connections even if using UDP/DTLS Relay allocations when the build target was WebGL. This only applied to working in the editor since UDP/DTLS can't work in the browser. (#2695)
+- Fixed issue where a `NetworkBehaviour` component's `OnNetworkDespawn` was not being invoked on the host-server side for an in-scene placed `NetworkObject` when a scene was unloaded (during a scene transition) and the `NetworkBehaviour` component was positioned/ordered before the `NetworkObject` component. (#2685)
+- Fixed issue where `SpawnWithObservers` was not being honored when `NetworkConfig.EnableSceneManagement` was disabled. (#2682)
+- Fixed issue where `NetworkAnimator` was not internally tracking changes to layer weights which prevented proper layer weight synchronization back to the original layer weight value. (#2674)
+- Fixed "writing past the end of the buffer" error when calling ResetDirty() on managed network variables that are larger than 256 bytes when serialized. (#2670)
+- Fixed issue where generation of the `DefaultNetworkPrefabs` asset was not enabled by default. (#2662)
+- Fixed issue where the `GlobalObjectIdHash` value could be updated but the asset not marked as dirty. (#2662)
+- Fixed issue where the `GlobalObjectIdHash` value of a (network) prefab asset could be assigned an incorrect value when editing the prefab in a temporary scene. (#2662)
+- Fixed issue where the `GlobalObjectIdHash` value generated after creating a (network) prefab from an object constructed within the scene would not be the correct final value in a stand alone build. (#2662)
+
+### Changed
+
+- Updated dependency on `com.unity.transport` to version 1.4.0. (#2716)
+
+## [1.6.0] - 2023-08-09
+
+### Added
+
+- Added a protected virtual method `NetworkTransform.OnInitialize(ref NetworkTransformState replicatedState)` that just returns the replicated state reference.
+  
+### Fixed
+
+- Fixed issue where invoking `NetworkManager.Shutdown` within `NetworkManager.OnClientStopped` or `NetworkManager.OnServerStopped` would force `NetworkManager.ShutdownInProgress` to remain true after completing the shutdown process. (#2661)
+- Fixed issue where ARMv7 Android builds would crash when trying to validate the batch header. (#2654)
+- Fixed issue with client synchronization of position when using half precision and the delta position reaches the maximum value and is collapsed on the host prior to being forwarded to the non-owner clients. (#2636)
+- Fixed issue with scale not synchronizing properly depending upon the spawn order of NetworkObjects. (#2636)
+- Fixed issue position was not properly transitioning between ownership changes with an owner authoritative NetworkTransform. (#2636)
+- Fixed issue where a late joining non-owner client could update an owner authoritative NetworkTransform if ownership changed without any updates to position prior to the non-owner client joining. (#2636)
+
+### Changed
+
+## [1.5.2] - 2023-07-24
+
+### Added
+
+### Fixed
+- Bumped minimum Unity version supported to 2021.3 LTS
+- Fixed issue where `NetworkClient.OwnedObjects` was not returning any owned objects due to the `NetworkClient.IsConnected` not being properly set. (#2631)
+- Fixed a crash when calling TrySetParent with a null Transform (#2625)
+- Fixed issue where a `NetworkTransform` using full precision state updates was losing transform state updates when interpolation was enabled. (#2624)
+- Fixed issue where `NetworkObject.SpawnWithObservers` was not being honored for late joining clients. (#2623)
+- Fixed issue where invoking `NetworkManager.Shutdown` multiple times, depending upon the timing, could cause an exception. (#2622)
+- Fixed issue where removing ownership would not notify the server that it gained ownership. This also resolves the issue where an owner authoritative NetworkTransform would not properly initialize upon removing ownership from a remote client. (#2618)
+- Fixed ILPP issues when using CoreCLR and for certain dedicated server builds. (#2614)
+- Fixed an ILPP compile error when creating a generic NetworkBehaviour singleton with a static T instance. (#2603)
+
+### Changed
+
+## [1.5.1] - 2023-06-07
+
+### Added
+
+- Added support for serializing `NativeArray<>` and `NativeList<>` in `FastBufferReader`/`FastBufferWriter`, `BufferSerializer`, `NetworkVariable`, and RPCs. (To use `NativeList<>`, add `UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT` to your Scripting Define Symbols in `Project Settings > Player`) (#2375)
+- The location of the automatically-created default network prefab list can now be configured (#2544)
+- Added: Message size limits (max single message and max fragmented message) can now be set using NetworkManager.MaximumTransmissionUnitSize and NetworkManager.MaximumFragmentedMessageSize for transports that don't work with the default values (#2530)
+- Added `NetworkObject.SpawnWithObservers` property (default is true) that when set to false will spawn a `NetworkObject` with no observers and will not be spawned on any client until `NetworkObject.NetworkShow` is invoked. (#2568)
+
+### Fixed
+
+- Fixed: Fixed a null reference in codegen in some projects (#2581)
+- Fixed issue where the `OnClientDisconnected` client identifier was incorrect after a pending client connection was denied. (#2569)
+- Fixed warning "Runtime Network Prefabs was not empty at initialization time." being erroneously logged when no runtime network prefabs had been added (#2565)
+- Fixed issue where some temporary debug console logging was left in a merged PR. (#2562)
+- Fixed the "Generate Default Network Prefabs List" setting not loading correctly and always reverting to being checked. (#2545)
+- Fixed issue where users could not use NetworkSceneManager.VerifySceneBeforeLoading to exclude runtime generated scenes from client synchronization. (#2550)
+- Fixed missing value on `NetworkListEvent` for `EventType.RemoveAt` events.  (#2542,#2543)
+- Fixed issue where parenting a NetworkTransform under a transform with a scale other than Vector3.one would result in incorrect values on non-authoritative instances. (#2538)
+- Fixed issue where a server would include scene migrated and then despawned NetworkObjects to a client that was being synchronized. (#2532)
+- Fixed the inspector throwing exceptions when attempting to render `NetworkVariable`s of enum types. (#2529)
+- Making a `NetworkVariable` with an `INetworkSerializable` type that doesn't meet the `new()` constraint will now create a compile-time error instead of an editor crash (#2528)
+- Fixed Multiplayer Tools package installation docs page link on the NetworkManager popup. (#2526)
+- Fixed an exception and error logging when two different objects are shown and hidden on the same frame (#2524)
+- Fixed a memory leak in `UnityTransport` that occurred if `StartClient` failed. (#2518)
+- Fixed issue where a client could throw an exception if abruptly disconnected from a network session with one or more spawned `NetworkObject`(s). (#2510)
+- Fixed issue where invalid endpoint addresses were not being detected and returning false from NGO UnityTransport. (#2496)
+- Fixed some errors that could occur if a connection is lost and the loss is detected when attempting to write to the socket. (#2495)
+
+## Changed
+
+- Adding network prefabs before NetworkManager initialization is now supported. (#2565)
+- Connecting clients being synchronized now switch to the server's active scene before spawning and synchronizing NetworkObjects. (#2532)
+- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.4. (#2533)
+- Improved performance of NetworkBehaviour initialization by replacing reflection when initializing NetworkVariables with compile-time code generation, which should help reduce hitching during additive scene loads. (#2522)
+
+## [1.4.0] - 2023-04-10
+
+### Added
+
+- Added a way to access the GlobalObjectIdHash via PrefabIdHash for use in the Connection Approval Callback. (#2437)
+- Added `OnServerStarted` and `OnServerStopped` events that will trigger only on the server (or host player) to notify that the server just started or is no longer active (#2420)
+- Added `OnClientStarted` and `OnClientStopped` events that will trigger only on the client (or host player) to notify that the client just started or is no longer active (#2420)
+- Added `NetworkTransform.UseHalfFloatPrecision` property that, when enabled, will use half float values for position, rotation, and scale. This yields a 50% bandwidth savings a the cost of precision. (#2388)
+- Added `NetworkTransform.UseQuaternionSynchronization` property that, when enabled, will synchronize the entire quaternion. (#2388)
+- Added `NetworkTransform.UseQuaternionCompression` property that, when enabled, will use a smallest three implementation reducing a full quaternion synchronization update to the size of an unsigned integer. (#2388)
+- Added `NetworkTransform.SlerpPosition` property that, when enabled along with interpolation being enabled, will interpolate using `Vector3.Slerp`. (#2388)
+- Added `BufferedLinearInterpolatorVector3` that replaces the float version, is now used by `NetworkTransform`, and provides the ability to enable or disable `Slerp`. (#2388)
+- Added `HalfVector3` used for scale when half float precision is enabled. (#2388)
+- Added `HalfVector4` used for rotation when half float precision and quaternion synchronization is enabled. (#2388)
+- Added `HalfVector3DeltaPosition` used for position when half float precision is enabled. This handles loss in position precision by updating only the delta position as opposed to the full position. (#2388)
+- Added `NetworkTransform.GetSpaceRelativePosition` and `NetworkTransform.GetSpaceRelativeRotation` helper methods to return the proper values depending upon whether local or world space. (#2388)
+- Added `NetworkTransform.OnAuthorityPushTransformState` virtual method that is invoked just prior to sending the `NetworkTransformState` to non-authoritative instances. This provides users with the ability to obtain more precise delta values for prediction related calculations. (#2388)
+- Added `NetworkTransform.OnNetworkTransformStateUpdated` virtual method that is invoked just after the authoritative `NetworkTransformState` is applied. This provides users with the ability to obtain more precise delta values for prediction related calculations. (#2388)
+- Added `NetworkTransform.OnInitialize`virtual method that is invoked after the `NetworkTransform` has been initialized or re-initialized when ownership changes. This provides for a way to make adjustments when `NetworkTransform` is initialized (i.e. resetting client prediction etc) (#2388)
+- Added `NetworkObject.SynchronizeTransform` property (default is true) that provides users with another way to help with bandwidth optimizations where, when set to false, the `NetworkObject`'s associated transform will not be included when spawning and/or synchronizing late joining players. (#2388)
+- Added `NetworkSceneManager.ActiveSceneSynchronizationEnabled` property, disabled by default, that enables client synchronization of server-side active scene changes. (#2383)
+- Added `NetworkObject.ActiveSceneSynchronization`, disabled by default, that will automatically migrate a `NetworkObject` to a newly assigned active scene. (#2383)
+- Added `NetworkObject.SceneMigrationSynchronization`, enabled by default, that will synchronize client(s) when a `NetworkObject` is migrated into a new scene on the server side via `SceneManager.MoveGameObjectToScene`. (#2383)
+
+### Changed
+
+- Made sure the `CheckObjectVisibility` delegate is checked and applied, upon `NetworkShow` attempt. Found while supporting (#2454), although this is not a fix for this (already fixed) issue. (#2463)
+- Changed `NetworkTransform` authority handles delta checks on each new network tick and no longer consumes processing cycles checking for deltas for all frames in-between ticks. (#2388)
+- Changed the `NetworkTransformState` structure is now public and now has public methods that provide access to key properties of the `NetworkTransformState` structure. (#2388)
+- Changed `NetworkTransform` interpolation adjusts its interpolation "ticks ago" to be 2 ticks latent if it is owner authoritative and the instance is not the server or 1 tick latent if the instance is the server and/or is server authoritative. (#2388)
+- Updated `NetworkSceneManager` to migrate dynamically spawned `NetworkObject`s with `DestroyWithScene` set to false into the active scene if their current scene is unloaded. (#2383)
+- Updated the server to synchronize its local `NetworkSceneManager.ClientSynchronizationMode` during the initial client synchronization. (#2383)
+
+### Fixed
+
+- Fixed issue where during client synchronization the synchronizing client could receive a ObjectSceneChanged message before the client-side NetworkObject instance had been instantiated and spawned. (#2502)
+- Fixed issue where `NetworkAnimator` was building client RPC parameters to exclude the host from sending itself messages but was not including it in the ClientRpc parameters. (#2492)
+- Fixed issue where `NetworkAnimator` was not properly detecting and synchronizing cross fade initiated transitions. (#2481)
+- Fixed issue where `NetworkAnimator` was not properly synchronizing animation state updates. (#2481)
+- Fixed float NetworkVariables not being rendered properly in the inspector of NetworkObjects. (#2441)
+- Fixed an issue where Named Message Handlers could remove themselves causing an exception when the metrics tried to access the name of the message.(#2426)
+- Fixed registry of public `NetworkVariable`s in derived `NetworkBehaviour`s (#2423)
+- Fixed issue where runtime association of `Animator` properties to `AnimationCurve`s would cause `NetworkAnimator` to attempt to update those changes. (#2416)
+- Fixed issue where `NetworkAnimator` would not check if its associated `Animator` was valid during serialization and would spam exceptions in the editor console. (#2416)
+- Fixed issue with a child's rotation rolling over when interpolation is enabled on a `NetworkTransform`. Now using half precision or full quaternion synchronization will always update all axis. (#2388)
+- Fixed issue where `NetworkTransform` was not setting the teleport flag when the `NetworkTransform.InLocalSpace` value changed. This issue only impacted `NetworkTransform` when interpolation was enabled. (#2388)
+- Fixed issue when the `NetworkSceneManager.ClientSynchronizationMode` is `LoadSceneMode.Additive` and the server changes the currently active scene prior to a client connecting then upon a client connecting and being synchronized the NetworkSceneManager would clear its internal ScenePlacedObjects list that could already be populated. (#2383)
+- Fixed issue where a client would load duplicate scenes of already preloaded scenes during the initial client synchronization and `NetworkSceneManager.ClientSynchronizationMode` was set to `LoadSceneMode.Additive`. (#2383)
+
+## [1.3.1] - 2023-03-27
+
+### Added
+
+- Added detection and graceful handling of corrupt packets for additional safety. (#2419)
+
+### Changed
+
+- The UTP component UI has been updated to be more user-friendly for new users by adding a simple toggle to switch between local-only (127.0.0.1) and remote (0.0.0.0) binding modes, using the toggle "Allow Remote Connections" (#2408)
+- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.3. (#2450)
+- `NetworkShow()` of `NetworkObject`s are delayed until the end of the frame to ensure consistency of delta-driven variables like `NetworkList`.
+- Dirty `NetworkObject` are reset at end-of-frame and not at serialization time.
+- `NetworkHide()` of an object that was just `NetworkShow()`n produces a warning, as remote clients will _not_ get a spawn/despawn pair.
+- Renamed the NetworkTransform.SetState parameter `shouldGhostsInterpolate` to `teleportDisabled` for better clarity of what that parameter does. (#2228)
+- Network prefabs are now stored in a ScriptableObject that can be shared between NetworkManagers, and have been exposed for public access. By default, a Default Prefabs List is created that contains all NetworkObject prefabs in the project, and new NetworkManagers will default to using that unless that option is turned off in the Netcode for GameObjects settings. Existing NetworkManagers will maintain their existing lists, which can be migrated to the new format via a button in their inspector. (#2322)
+
+### Fixed
+
+- Fixed issue where changes to a layer's weight would not synchronize unless a state transition was occurring.(#2399)
+- Fixed issue where `NetworkManager.LocalClientId` was returning the `NetworkTransport.ServerClientId` as opposed to the `NetworkManager.m_LocalClientId`. (#2398)
+- Fixed issue where a dynamically spawned `NetworkObject` parented under an in-scene placed `NetworkObject` would have its `InScenePlaced` value changed to `true`. This would result in a soft synchronization error for late joining clients. (#2396)
+- Fixed a UTP test that was failing when you install Unity Transport package 2.0.0 or newer. (#2347)
+- Fixed issue where `NetcodeSettingsProvider` would throw an exception in Unity 2020.3.x versions. (#2345)
+- Fixed server side issue where, depending upon component ordering, some NetworkBehaviour components might not have their OnNetworkDespawn method invoked if the client side disconnected. (#2323)
+- Fixed a case where data corruption could occur when using UnityTransport when reaching a certain level of send throughput. (#2332)
+- Fixed an issue in `UnityTransport` where an exception would be thrown if starting a Relay host/server on WebGL. This exception should only be thrown if using direct connections (where WebGL can't act as a host/server). (#2321)
+- Fixed `NetworkAnimator` issue where it was not checking for `AnimatorStateTtansition.destinationStateMachine` and any possible sub-states defined within it. (#2309)
+- Fixed `NetworkAnimator` issue where the host client was receiving the ClientRpc animation updates when the host was the owner.(#2309)
+- Fixed `NetworkAnimator` issue with using pooled objects and when specific properties are cleaned during despawn and destroy.(#2309)
+- Fixed issue where `NetworkAnimator` was checking for animation changes when the associated `NetworkObject` was not spawned.(#2309)
+- Corrected an issue with the documentation for BufferSerializer (#2401)
+
+## [1.2.0] - 2022-11-21
+
+### Added
+
+- Added protected method `NetworkBehaviour.OnSynchronize` which is invoked during the initial `NetworkObject` synchronization process. This provides users the ability to include custom serialization information that will be applied to the `NetworkBehaviour` prior to the `NetworkObject` being spawned. (#2298)
+- Added support for different versions of the SDK to talk to each other in circumstances where changes permit it. Starting with this version and into future versions, patch versions should be compatible as long as the minor version is the same. (#2290)
+- Added `NetworkObject` auto-add helper and Multiplayer Tools install reminder settings to Project Settings. (#2285)
+- Added `public string DisconnectReason` getter to `NetworkManager` and `string Reason` to `ConnectionApprovalResponse`. Allows connection approval to communicate back a reason. Also added `public void DisconnectClient(ulong clientId, string reason)` allowing setting a disconnection reason, when explicitly disconnecting a client. (#2280)
+
+### Changed
+
+- Changed 3rd-party `XXHash` (32 & 64) implementation with an in-house reimplementation (#2310)
+- When `NetworkConfig.EnsureNetworkVariableLengthSafety` is disabled `NetworkVariable` fields do not write the additional `ushort` size value (_which helps to reduce the total synchronization message size_), but when enabled it still writes the additional `ushort` value. (#2298)
+- Optimized bandwidth usage by encoding most integer fields using variable-length encoding. (#2276)
+
+### Fixed
+- Fixed `IsSpawnedObjectsPendingInDontDestroyOnLoad` is only set to true when loading a scene using `LoadSceneMode.Singleonly`. (#2330)
+- Fixed issue where `NetworkTransform` components nested under a parent with a `NetworkObject` component  (i.e. network prefab) would not have their associated `GameObject`'s transform synchronized. (#2298)
+- Fixed issue where `NetworkObject`s that failed to instantiate could cause the entire synchronization pipeline to be disrupted/halted for a connecting client. (#2298)
+- Fixed issue where in-scene placed `NetworkObject`s nested under a `GameObject` would be added to the orphaned children list causing continual console warning log messages. (#2298)
+- Custom messages are now properly received by the local client when they're sent while running in host mode. (#2296)
+- Fixed issue where the host would receive more than one event completed notification when loading or unloading a scene only when no clients were connected. (#2292)
+- Fixed an issue in `UnityTransport` where an error would be logged if the 'Use Encryption' flag was enabled with a Relay configuration that used a secure protocol. (#2289)
+- Fixed issue where in-scene placed `NetworkObjects` were not honoring the `AutoObjectParentSync` property. (#2281)
+- Fixed the issue where `NetworkManager.OnClientConnectedCallback` was being invoked before in-scene placed `NetworkObject`s had been spawned when starting `NetworkManager` as a host. (#2277)
+- Creating a `FastBufferReader` with `Allocator.None` will not result in extra memory being allocated for the buffer (since it's owned externally in that scenario). (#2265)
+
+### Removed
+
+- Removed the `NetworkObject` auto-add and Multiplayer Tools install reminder settings from the Menu interface. (#2285)
+
+## [1.1.0] - 2022-10-21
+
+### Added
+
+- Added `NetworkManager.IsApproved` flag that is set to `true` a client has been approved.(#2261)
+- `UnityTransport` now provides a way to set the Relay server data directly from the `RelayServerData` structure (provided by the Unity Transport package) throuh its `SetRelayServerData` method. This allows making use of the new APIs in UTP 1.3 that simplify integration of the Relay SDK. (#2235)
+- IPv6 is now supported for direct connections when using `UnityTransport`. (#2232)
+- Added WebSocket support when using UTP 2.0 with `UseWebSockets` property in the `UnityTransport` component of the `NetworkManager` allowing to pick WebSockets for communication. When building for WebGL, this selection happens automatically. (#2201)
+- Added position, rotation, and scale to the `ParentSyncMessage` which provides users the ability to specify the final values on the server-side when `OnNetworkObjectParentChanged` is invoked just before the message is created (when the `Transform` values are applied to the message). (#2146)
+- Added `NetworkObject.TryRemoveParent` method for convenience purposes opposed to having to cast null to either `GameObject` or `NetworkObject`. (#2146)
+
+### Changed
+
+- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.0. (#2231)
+- The send queues of `UnityTransport` are now dynamically-sized. This means that there shouldn't be any need anymore to tweak the 'Max Send Queue Size' value. In fact, this field is now removed from the inspector and will not be serialized anymore. It is still possible to set it manually using the `MaxSendQueueSize` property, but it is not recommended to do so aside from some specific needs (e.g. limiting the amount of memory used by the send queues in very constrained environments). (#2212)
+- As a consequence of the above change, the `UnityTransport.InitialMaxSendQueueSize` field is now deprecated. There is no default value anymore since send queues are dynamically-sized. (#2212)
+- The debug simulator in `UnityTransport` is now non-deterministic. Its random number generator used to be seeded with a constant value, leading to the same pattern of packet drops, delays, and jitter in every run. (#2196)
+- `NetworkVariable<>` now supports managed `INetworkSerializable` types, as well as other managed types with serialization/deserialization delegates registered to `UserNetworkVariableSerialization<T>.WriteValue` and `UserNetworkVariableSerialization<T>.ReadValue` (#2219)
+- `NetworkVariable<>` and `BufferSerializer<BufferSerializerReader>` now deserialize `INetworkSerializable` types in-place, rather than constructing new ones. (#2219)
+
+### Fixed
+
+- Fixed `NetworkManager.ApprovalTimeout` will not timeout due to slower client synchronization times as it now uses the added `NetworkManager.IsApproved` flag to determined if the client has been approved or not.(#2261)
+- Fixed issue caused when changing ownership of objects hidden to some clients (#2242)
+- Fixed issue where an in-scene placed NetworkObject would not invoke NetworkBehaviour.OnNetworkSpawn if the GameObject was disabled when it was despawned. (#2239)
+- Fixed issue where clients were not rebuilding the `NetworkConfig` hash value for each unique connection request. (#2226)
+- Fixed the issue where player objects were not taking the `DontDestroyWithOwner` property into consideration when a client disconnected. (#2225)
+- Fixed issue where `SceneEventProgress` would not complete if a client late joins while it is still in progress. (#2222)
+- Fixed issue where `SceneEventProgress` would not complete if a client disconnects. (#2222)
+- Fixed issues with detecting if a `SceneEventProgress` has timed out. (#2222)
+- Fixed issue #1924 where `UnityTransport` would fail to restart after a first failure (even if what caused the initial failure was addressed). (#2220)
+- Fixed issue where `NetworkTransform.SetStateServerRpc` and `NetworkTransform.SetStateClientRpc` were not honoring local vs world space settings when applying the position and rotation. (#2203)
+- Fixed ILPP `TypeLoadException` on WebGL on MacOS Editor and potentially other platforms. (#2199)
+- Implicit conversion of NetworkObjectReference to GameObject will now return null instead of throwing an exception if the referenced object could not be found (i.e., was already despawned) (#2158)
+- Fixed warning resulting from a stray NetworkAnimator.meta file (#2153)
+- Fixed Connection Approval Timeout not working client side. (#2164)
+- Fixed issue where the `WorldPositionStays` parenting parameter was not being synchronized with clients. (#2146)
+- Fixed issue where parented in-scene placed `NetworkObject`s would fail for late joining clients. (#2146)
+- Fixed issue where scale was not being synchronized which caused issues with nested parenting and scale when `WorldPositionStays` was true. (#2146)
+- Fixed issue with `NetworkTransform.ApplyTransformToNetworkStateWithInfo` where it was not honoring axis sync settings when `NetworkTransformState.IsTeleportingNextFrame` was true. (#2146)
+- Fixed issue with `NetworkTransform.TryCommitTransformToServer` where it was not honoring the `InLocalSpace` setting. (#2146)
+- Fixed ClientRpcs always reporting in the profiler view as going to all clients, even when limited to a subset of clients by `ClientRpcParams`. (#2144)
+- Fixed RPC codegen failing to choose the correct extension methods for `FastBufferReader` and `FastBufferWriter` when the parameters were a generic type (i.e., List<int>) and extensions for multiple instantiations of that type have been defined (i.e., List<int> and List<string>) (#2142)
+- Fixed the issue where running a server (i.e. not host) the second player would not receive updates (unless a third player joined). (#2127)
+- Fixed issue where late-joining client transition synchronization could fail when more than one transition was occurring.(#2127)
+- Fixed throwing an exception in `OnNetworkUpdate` causing other `OnNetworkUpdate` calls to not be executed. (#1739)
+- Fixed synchronization when Time.timeScale is set to 0. This changes timing update to use unscaled deltatime. Now network updates rate are independent from the local time scale. (#2171)
+- Fixed not sending all NetworkVariables to all clients when a client connects to a server. (#1987)
+- Fixed IsOwner/IsOwnedByServer being wrong on the server after calling RemoveOwnership (#2211)
+
+## [1.0.2] - 2022-09-12
+
+### Fixed
+
+- Fixed issue where `NetworkTransform` was not honoring the InLocalSpace property on the authority side during OnNetworkSpawn. (#2170)
+- Fixed issue where `NetworkTransform` was not ending extrapolation for the previous state causing non-authoritative instances to become out of synch. (#2170)
+- Fixed issue where `NetworkTransform` was not continuing to interpolate for the remainder of the associated tick period. (#2170)
+- Fixed issue during `NetworkTransform.OnNetworkSpawn` for non-authoritative instances where it was initializing interpolators with the replicated network state which now only contains the transform deltas that occurred during a network tick and not the entire transform state. (#2170)
+
+## [1.0.1] - 2022-08-23
+
+### Changed
+
+- Changed version to 1.0.1. (#2131)
+- Updated dependency on `com.unity.transport` to 1.2.0. (#2129)
+- When using `UnityTransport`, _reliable_ payloads are now allowed to exceed the configured 'Max Payload Size'. Unreliable payloads remain bounded by this setting. (#2081)
+- Performance improvements for cases with large number of NetworkObjects, by not iterating over all unchanged NetworkObjects
+
+### Fixed
+
+- Fixed an issue where reading/writing more than 8 bits at a time with BitReader/BitWriter would write/read from the wrong place, returning and incorrect result. (#2130)
+- Fixed issue with the internal `NetworkTransformState.m_Bitset` flag not getting cleared upon the next tick advancement. (#2110)
+- Fixed interpolation issue with `NetworkTransform.Teleport`. (#2110)
+- Fixed issue where the authoritative side was interpolating its transform. (#2110)
+- Fixed Owner-written NetworkVariable infinitely write themselves (#2109)
+- Fixed NetworkList issue that showed when inserting at the very end of a NetworkList (#2099)
+- Fixed issue where a client owner of a `NetworkVariable` with both owner read and write permissions would not update the server side when changed. (#2097)
+- Fixed issue when attempting to spawn a parent `GameObject`, with `NetworkObject` component attached, that has one or more child `GameObject`s, that are inactive in the hierarchy, with `NetworkBehaviour` components it will no longer attempt to spawn the associated `NetworkBehaviour`(s) or invoke ownership changed notifications but will log a warning message. (#2096)
+- Fixed an issue where destroying a NetworkBehaviour would not deregister it from the parent NetworkObject, leading to exceptions when the parent was later destroyed. (#2091)
+- Fixed issue where `NetworkObject.NetworkHide` was despawning and destroying, as opposed to only despawning, in-scene placed `NetworkObject`s. (#2086)
+- Fixed `NetworkAnimator` synchronizing transitions twice due to it detecting the change in animation state once a transition is started by a trigger. (#2084)
+- Fixed issue where `NetworkAnimator` would not synchronize a looping animation for late joining clients if it was at the very end of its loop. (#2076)
+- Fixed issue where `NetworkAnimator` was not removing its subscription from `OnClientConnectedCallback` when despawned during the shutdown sequence. (#2074)
+- Fixed IsServer and IsClient being set to false before object despawn during the shutdown sequence. (#2074)
+- Fixed NetworkList Value event on the server. PreviousValue is now set correctly when a new value is set through property setter. (#2067)
+- Fixed NetworkLists not populating on client. NetworkList now uses the most recent list as opposed to the list at the end of previous frame, when sending full updates to dynamically spawned NetworkObject. The difference in behaviour is required as scene management spawns those objects at a different time in the frame, relative to updates. (#2062)
+
+## [1.0.0] - 2022-06-27
+
+### Changed
+
+- Changed version to 1.0.0. (#2046)
+
+## [1.0.0-pre.10] - 2022-06-21
+
+### Added
+
+- Added a new `OnTransportFailure` callback to `NetworkManager`. This callback is invoked when the manager's `NetworkTransport` encounters an unrecoverable error. Transport failures also cause the `NetworkManager` to shut down. Currently, this is only used by `UnityTransport` to signal a timeout of its connection to the Unity Relay servers. (#1994)
+- Added `NetworkEvent.TransportFailure`, which can be used by implementations of `NetworkTransport` to signal to `NetworkManager` that an unrecoverable error was encountered. (#1994)
+- Added test to ensure a warning occurs when nesting NetworkObjects in a NetworkPrefab (#1969)
+- Added `NetworkManager.RemoveNetworkPrefab(...)` to remove a prefab from the prefabs list (#1950)
+
+### Changed
+
+- Updated `UnityTransport` dependency on `com.unity.transport` to 1.1.0. (#2025)
+- (API Breaking) `ConnectionApprovalCallback` is no longer an `event` and will not allow more than 1 handler registered at a time. Also, `ConnectionApprovalCallback` is now an `Action<>` taking a `ConnectionApprovalRequest` and a `ConnectionApprovalResponse` that the client code must fill (#1972) (#2002)
+
+### Removed
+
+### Fixed
+- Fixed issue where dynamically spawned `NetworkObject`s could throw an exception if the scene of origin handle was zero (0) and the `NetworkObject` was already spawned. (#2017)
+- Fixed issue where `NetworkObject.Observers` was not being cleared when despawned. (#2009)
+- Fixed `NetworkAnimator` could not run in the server authoritative mode. (#2003)
+- Fixed issue where late joining clients would get a soft synchronization error if any in-scene placed NetworkObjects were parented under another `NetworkObject`. (#1985)
+- Fixed issue where `NetworkBehaviourReference` would throw a type cast exception if using `NetworkBehaviourReference.TryGet` and the component type was not found. (#1984)
+- Fixed `NetworkSceneManager` was not sending scene event notifications for the currently active scene and any additively loaded scenes when loading a new scene in `LoadSceneMode.Single` mode. (#1975)
+- Fixed issue where one or more clients disconnecting during a scene event would cause `LoadEventCompleted` or `UnloadEventCompleted` to wait until the `NetworkConfig.LoadSceneTimeOut` period before being triggered. (#1973)
+- Fixed issues when multiple `ConnectionApprovalCallback`s were registered (#1972)
+- Fixed a regression in serialization support: `FixedString`, `Vector2Int`, and `Vector3Int` types can now be used in NetworkVariables and RPCs again without requiring a `ForceNetworkSerializeByMemcpy<>` wrapper. (#1961)
+- Fixed generic types that inherit from NetworkBehaviour causing crashes at compile time. (#1976)
+- Fixed endless dialog boxes when adding a `NetworkBehaviour` to a `NetworkManager` or vice-versa. (#1947)
+- Fixed `NetworkAnimator` issue where it was only synchronizing parameters if the layer or state changed or was transitioning between states. (#1946)
+- Fixed `NetworkAnimator` issue where when it did detect a parameter had changed it would send all parameters as opposed to only the parameters that changed. (#1946)
+- Fixed `NetworkAnimator` issue where it was not always disposing the `NativeArray` that is allocated when spawned. (#1946)
+- Fixed `NetworkAnimator` issue where it was not taking the animation speed or state speed multiplier into consideration. (#1946)
+- Fixed `NetworkAnimator` issue where it was not properly synchronizing late joining clients if they joined while `Animator` was transitioning between states. (#1946)
+- Fixed `NetworkAnimator` issue where the server was not relaying changes to non-owner clients when a client was the owner. (#1946)
+- Fixed issue where the `PacketLoss` metric for tools would return the packet loss over a connection lifetime instead of a single frame. (#2004)
+
+## [1.0.0-pre.9] - 2022-05-10
+
+### Fixed
+
+- Fixed Hosting again after failing to host now works correctly (#1938)
+- Fixed NetworkManager to cleanup connected client lists after stopping (#1945)
+- Fixed NetworkHide followed by NetworkShow on the same frame works correctly (#1940)
+
+## [1.0.0-pre.8] - 2022-04-27
+
+### Changed
+
+- `unmanaged` structs are no longer universally accepted as RPC parameters because some structs (i.e., structs with pointers in them, such as `NativeList<T>`) can't be supported by the default memcpy struct serializer. Structs that are intended to be serialized across the network must add `INetworkSerializeByMemcpy` to the interface list (i.e., `struct Foo : INetworkSerializeByMemcpy`). This interface is empty and just serves to mark the struct as compatible with memcpy serialization. For external structs you can't edit, you can pass them to RPCs by wrapping them in `ForceNetworkSerializeByMemcpy<T>`. (#1901)
+- Changed requirement to register in-scene placed NetworkObjects with `NetworkManager` in order to respawn them.  In-scene placed NetworkObjects are now automatically tracked during runtime and no longer need to be registered as a NetworkPrefab.  (#1898)
+
+### Removed
+
+- Removed `SIPTransport` (#1870)
+- Removed `ClientNetworkTransform` from the package samples and moved to Boss Room's Utilities package which can be found [here](https://github.com/Unity-Technologies/com.unity.multiplayer.samples.coop/blob/main/Packages/com.unity.multiplayer.samples.coop/Utilities/Net/ClientAuthority/ClientNetworkTransform.cs) (#1912)
+
+### Fixed
+
+- Fixed issue where `NetworkSceneManager` did not synchronize despawned in-scene placed NetworkObjects. (#1898)
+- Fixed `NetworkTransform` generating false positive rotation delta checks when rolling over between 0 and 360 degrees. (#1890)
+- Fixed client throwing an exception if it has messages in the outbound queue when processing the `NetworkEvent.Disconnect` event and is using UTP. (#1884)
+- Fixed issue during client synchronization if 'ValidateSceneBeforeLoading' returned false it would halt the client synchronization process resulting in a client that was approved but not synchronized or fully connected with the server. (#1883)
+- Fixed an issue where UNetTransport.StartServer would return success even if the underlying transport failed to start (#854)
+- Passing generic types to RPCs no longer causes a native crash (#1901)
+- Fixed a compile failure when compiling against com.unity.nuget.mono-cecil >= 1.11.4 (#1920)
+- Fixed an issue where calling `Shutdown` on a `NetworkManager` that was already shut down would cause an immediate shutdown the next time it was started (basically the fix makes `Shutdown` idempotent). (#1877)
+
+## [1.0.0-pre.7] - 2022-04-06
+
+### Added
+
+- Added editor only check prior to entering into play mode if the currently open and active scene is in the build list and if not displays a dialog box asking the user if they would like to automatically add it prior to entering into play mode. (#1828)
+- Added `UnityTransport` implementation and `com.unity.transport` package dependency (#1823)
+- Added `NetworkVariableWritePermission` to `NetworkVariableBase` and implemented `Owner` client writable netvars. (#1762)
+- `UnityTransport` settings can now be set programmatically. (#1845)
+- `FastBufferWriter` and Reader IsInitialized property. (#1859)
+- Prefabs can now be added to the network at **runtime** (i.e., from an addressable asset). If `ForceSamePrefabs` is false, this can happen after a connection has been formed. (#1882)
+- When `ForceSamePrefabs` is false, a configurable delay (default 1 second, configurable via `NetworkConfig.SpawnTimeout`) has been introduced to gracefully handle race conditions where a spawn call has been received for an object whose prefab is still being loaded. (#1882)
+
+### Changed
+
+- Changed `NetcodeIntegrationTestHelpers` to use `UnityTransport` (#1870)
+- Updated `UnityTransport` dependency on `com.unity.transport` to 1.0.0 (#1849)
+
+### Removed
+
+- Removed `SnapshotSystem` (#1852)
+- Removed `com.unity.modules.animation`, `com.unity.modules.physics` and `com.unity.modules.physics2d` dependencies from the package (#1812)
+- Removed `com.unity.collections` dependency from the package (#1849)
+
+### Fixed
+
+- Fixed in-scene placed NetworkObjects not being found/ignored after a client disconnects and then reconnects. (#1850)
+- Fixed issue where `UnityTransport` send queues were not flushed when calling `DisconnectLocalClient` or `DisconnectRemoteClient`. (#1847)
+- Fixed NetworkBehaviour dependency verification check for an existing NetworkObject not searching from root parent transform relative GameObject. (#1841)
+- Fixed issue where entries were not being removed from the NetworkSpawnManager.OwnershipToObjectsTable. (#1838)
+- Fixed ClientRpcs would always send to all connected clients by default as opposed to only sending to the NetworkObject's Observers list by default. (#1836)
+- Fixed clarity for NetworkSceneManager client side notification when it receives a scene hash value that does not exist in its local hash table. (#1828)
+- Fixed client throws a key not found exception when it times out using UNet or UTP. (#1821)
+- Fixed network variable updates are no longer limited to 32,768 bytes when NetworkConfig.EnsureNetworkVariableLengthSafety is enabled. The limits are now determined by what the transport can send in a message. (#1811)
+- Fixed in-scene NetworkObjects get destroyed if a client fails to connect and shuts down the NetworkManager. (#1809)
+- Fixed user never being notified in the editor that a NetworkBehaviour requires a NetworkObject to function properly. (#1808)
+- Fixed PlayerObjects and dynamically spawned NetworkObjects not being added to the NetworkClient's OwnedObjects (#1801)
+- Fixed issue where NetworkManager would continue starting even if the NetworkTransport selected failed. (#1780)
+- Fixed issue when spawning new player if an already existing player exists it does not remove IsPlayer from the previous player (#1779)
+- Fixed lack of notification that NetworkManager and NetworkObject cannot be added to the same GameObject with in-editor notifications (#1777)
+- Fixed parenting warning printing for false positives (#1855)
+
+## [1.0.0-pre.6] - 2022-03-02
+
+### Added
+
+- NetworkAnimator now properly synchrhonizes all animation layers as well as runtime-adjusted weighting between them (#1765)
+- Added first set of tests for NetworkAnimator - parameter syncing, trigger set / reset, override network animator (#1735)
+
+### Fixed
+
+- Fixed an issue where sometimes the first client to connect to the server could see messages from the server as coming from itself. (#1683)
+- Fixed an issue where clients seemed to be able to send messages to ClientId 1, but these messages would actually still go to the server (id 0) instead of that client. (#1683)
+- Improved clarity of error messaging when a client attempts to send a message to a destination other than the server, which isn't allowed. (#1683)
+- Disallowed async keyword in RPCs (#1681)
+- Fixed an issue where Alpha release versions of Unity (version 2022.2.0a5 and later) will not compile due to the UNet Transport no longer existing (#1678)
+- Fixed messages larger than 64k being written with incorrectly truncated message size in header (#1686) (credit: @kaen)
+- Fixed overloading RPC methods causing collisions and failing on IL2CPP targets. (#1694)
+- Fixed spawn flow to propagate `IsSceneObject` down to children NetworkObjects, decouple implicit relationship between object spawning & `IsSceneObject` flag (#1685)
+- Fixed error when serializing ConnectionApprovalMessage with scene management disabled when one or more objects is hidden via the CheckObjectVisibility delegate (#1720)
+- Fixed CheckObjectVisibility delegate not being properly invoked for connecting clients when Scene Management is enabled. (#1680)
+- Fixed NetworkList to properly call INetworkSerializable's NetworkSerialize() method (#1682)
+- Fixed NetworkVariables containing more than 1300 bytes of data (such as large NetworkLists) no longer cause an OverflowException (the limit on data size is now whatever limit the chosen transport imposes on fragmented NetworkDelivery mechanisms) (#1725)
+- Fixed ServerRpcParams and ClientRpcParams must be the last parameter of an RPC in order to function properly. Added a compile-time check to ensure this is the case and trigger an error if they're placed elsewhere (#1721)
+- Fixed FastBufferReader being created with a length of 1 if provided an input of length 0 (#1724)
+- Fixed The NetworkConfig's checksum hash includes the NetworkTick so that clients with a different tickrate than the server are identified and not allowed to connect (#1728)
+- Fixed OwnedObjects not being properly modified when using ChangeOwnership (#1731)
+- Improved performance in NetworkAnimator (#1735)
+- Removed the "always sync" network animator (aka "autosend") parameters (#1746)
+- Fixed in-scene placed NetworkObjects not respawning after shutting down the NetworkManager and then starting it back up again (#1769)
+
+## [1.0.0-pre.5] - 2022-01-26
+
+### Added
+
+- Added `PreviousValue` in `NetworkListEvent`, when `Value` has changed (#1528)
+
+### Changed
+
+- NetworkManager's GameObject is no longer allowed to be nested under one or more GameObject(s).(#1484)
+- NetworkManager DontDestroy property was removed and now NetworkManager always is migrated into the DontDestroyOnLoad scene. (#1484)'
+
+### Fixed
+
+- Fixed network tick value sometimes being duplicated or skipped. (#1614)
+- Fixed The ClientNetworkTransform sample script to allow for owner changes at runtime. (#1606)
+- Fixed When the LogLevel is set to developer NetworkBehaviour generates warning messages when it should not (#1631)
+- Fixed NetworkTransport Initialize now can receive the associated NetworkManager instance to avoid using NetworkManager.Singleton in transport layer (#1677)
+- Fixed a bug where NetworkList.Contains value was inverted (#1363)
 
 ## [1.0.0-pre.4] - 2021-01-04
 
@@ -18,6 +595,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Removed `FixedQueue`, `StreamExtensions`, `TypeExtensions` (#1398)
 
 ### Fixed
+
 - Fixed in-scene NetworkObjects that are moved into the DDOL scene not getting restored to their original active state (enabled/disabled) after a full scene transition (#1354)
 - Fixed invalid IL code being generated when using `this` instead of `this ref` for the FastBufferReader/FastBufferWriter parameter of an extension method. (#1393)
 - Fixed an issue where if you are running as a server (not host) the LoadEventCompleted and UnloadEventCompleted events would fire early by the NetworkSceneManager (#1379)
@@ -29,10 +607,14 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Fixed KeyNotFound exception when removing ownership of a newly spawned NetworkObject that is already owned by the server. (#1500)
 - Fixed NetworkManager.LocalClient not being set when starting as a host. (#1511)
 - Fixed a few memory leak cases when shutting down NetworkManager during Incoming Message Queue processing. (#1323)
+- Fixed network tick value sometimes being duplicated or skipped. (#1614)
 
 ### Changed
+
 - The SDK no longer limits message size to 64k. (The transport may still impose its own limits, but the SDK no longer does.) (#1384)
 - Updated com.unity.collections to 1.1.0 (#1451)
+- NetworkManager's GameObject is no longer allowed to be nested under one or more GameObject(s).(#1484)
+- NetworkManager DontDestroy property was removed and now NetworkManager always is migrated into the DontDestroyOnLoad scene. (#1484)
 
 ## [1.0.0-pre.3] - 2021-10-22
 
@@ -40,7 +622,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 - ResetTrigger function to NetworkAnimator (#1327)
 
-### Fixed 
+### Fixed
 
 - Overflow exception when syncing Animator state. (#1327)
 - Added `try`/`catch` around RPC calls, preventing exception from causing further RPC calls to fail (#1329)
@@ -65,7 +647,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Added `ClientNetworkTransform` sample to the SDK package (#1168)
 - Added `Bootstrap` sample to the SDK package (#1140)
 - Enhanced `NetworkSceneManager` implementation with additive scene loading capabilities (#1080, #955, #913)
-  - `NetworkSceneManager.OnSceneEvent` provides improved scene event notificaitons  
+  - `NetworkSceneManager.OnSceneEvent` provides improved scene event notificaitons
 - Enhanced `NetworkTransform` implementation with per axis/component based and threshold based state replication (#1042, #1055, #1061, #1084, #1101)
 - Added a jitter-resistent `BufferedLinearInterpolator<T>` for `NetworkTransform` (#1060)
 - Implemented `NetworkPrefabHandler` that provides support for object pooling and `NetworkPrefab` overrides (#1073, #1004, #977, #905,#749, #727)
@@ -122,7 +704,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Removed `NetworkDictionary`, `NetworkSet` (#1149)
 - Removed `NetworkVariableSettings` (#1097)
 - Removed predefined `NetworkVariable<T>` types (#1093)
-    - Removed `NetworkVariableBool`, `NetworkVariableByte`, `NetworkVariableSByte`, `NetworkVariableUShort`, `NetworkVariableShort`, `NetworkVariableUInt`, `NetworkVariableInt`, `NetworkVariableULong`, `NetworkVariableLong`, `NetworkVariableFloat`, `NetworkVariableDouble`, `NetworkVariableVector2`, `NetworkVariableVector3`, `NetworkVariableVector4`, `NetworkVariableColor`, `NetworkVariableColor32`, `NetworkVariableRay`, `NetworkVariableQuaternion`
+  - Removed `NetworkVariableBool`, `NetworkVariableByte`, `NetworkVariableSByte`, `NetworkVariableUShort`, `NetworkVariableShort`, `NetworkVariableUInt`, `NetworkVariableInt`, `NetworkVariableULong`, `NetworkVariableLong`, `NetworkVariableFloat`, `NetworkVariableDouble`, `NetworkVariableVector2`, `NetworkVariableVector3`, `NetworkVariableVector4`, `NetworkVariableColor`, `NetworkVariableColor32`, `NetworkVariableRay`, `NetworkVariableQuaternion`
 - Removed `NetworkChannel` and `MultiplexTransportAdapter` (#1133)
 - Removed ILPP backend for 2019.4, minimum required version is 2020.3+ (#895)
 - `NetworkManager.NetworkConfig` had the following properties removed: (#1080)
@@ -194,14 +776,14 @@ This is the initial experimental Unity MLAPI Package, v0.1.0.
 - Integrated MLAPI with the Unity Profiler for versions 2020.2 and later:
   - Added new profiler modules for MLAPI that report important network data.
   - Attached the profiler to a remote player to view network data over the wire.
-- A test project is available for building and experimenting with MLAPI features. This project is available in the MLAPI GitHub [testproject folder](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/tree/release/0.1.0/testproject). 
+- A test project is available for building and experimenting with MLAPI features. This project is available in the MLAPI GitHub [testproject folder](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/tree/release/0.1.0/testproject).
 - Added a [MLAPI Community Contributions](https://github.com/Unity-Technologies/mlapi-community-contributions/tree/master/com.mlapi.contrib.extensions) new GitHub repository to accept extensions from the MLAPI community. Current extensions include moved MLAPI features for lag compensation (useful for Server Authoritative actions) and `TrackedObject`.
 
 ### Changed
 
 - [GitHub 520](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/520): MLAPI now uses the Unity Package Manager for installation management.
-- Added functionality and usability to `NetworkVariable`, previously called `NetworkVar`. Updates enhance options and fully replace the need for `SyncedVar`s. 
-- [GitHub 507](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/507): Reimplemented `NetworkAnimator`, which synchronizes animation states for networked objects. 
+- Added functionality and usability to `NetworkVariable`, previously called `NetworkVar`. Updates enhance options and fully replace the need for `SyncedVar`s.
+- [GitHub 507](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/507): Reimplemented `NetworkAnimator`, which synchronizes animation states for networked objects.
 - GitHub [444](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/444) and [455](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/455): Channels are now represented as bytes instead of strings.
 
 For users of previous versions of MLAPI, this release renames APIs due to refactoring. All obsolete marked APIs have been removed as per [GitHub 513](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/513) and [GitHub 514](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/514).
@@ -234,7 +816,7 @@ For users of previous versions of MLAPI, this release renames APIs due to refact
 
 ### Fixed
 
-- [GitHub 460](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/460): Fixed an issue for RPC where the host-server was not receiving RPCs from the host-client and vice versa without the loopback flag set in `NetworkingManager`. 
+- [GitHub 460](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/460): Fixed an issue for RPC where the host-server was not receiving RPCs from the host-client and vice versa without the loopback flag set in `NetworkingManager`.
 - Fixed an issue where data in the Profiler was incorrectly aggregated and drawn, which caused the profiler data to increment indefinitely instead of resetting each frame.
 - Fixed an issue the client soft-synced causing PlayMode client-only scene transition issues, caused when running the client in the editor and the host as a release build. Users may have encountered a soft sync of `NetworkedInstanceId` issues in the `SpawnManager.ClientCollectSoftSyncSceneObjectSweep` method.
 - [GitHub 458](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/458): Fixed serialization issues in `NetworkList` and `NetworkDictionary` when running in Server mode.
@@ -249,10 +831,10 @@ With a new release of MLAPI in Unity, some features have been removed:
 - SyncVars have been removed from MLAPI. Use `NetworkVariable`s in place of this functionality. <!-- MTT54 -->
 - [GitHub 527](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/527): Lag compensation systems and `TrackedObject` have moved to the new [MLAPI Community Contributions](https://github.com/Unity-Technologies/mlapi-community-contributions/tree/master/com.mlapi.contrib.extensions) repo.
 - [GitHub 509](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/509): Encryption has been removed from MLAPI. The `Encryption` option in `NetworkConfig` on the `NetworkingManager` is not available in this release. This change will not block game creation or running. A current replacement for this functionality is not available, and may be developed in future releases. See the following changes:
-    - Removed `SecuritySendFlags` from all APIs.
-    - Removed encryption, cryptography, and certificate configurations from APIs including `NetworkManager` and `NetworkConfig`.
-    - Removed "hail handshake", including `NetworkManager` implementation and `NetworkConstants` entries.
-    - Modified `RpcQueue` and `RpcBatcher` internals to remove encryption and authentication from reading and writing.
+  - Removed `SecuritySendFlags` from all APIs.
+  - Removed encryption, cryptography, and certificate configurations from APIs including `NetworkManager` and `NetworkConfig`.
+  - Removed "hail handshake", including `NetworkManager` implementation and `NetworkConstants` entries.
+  - Modified `RpcQueue` and `RpcBatcher` internals to remove encryption and authentication from reading and writing.
 - Removed the previous MLAPI Profiler editor window from Unity versions 2020.2 and later.
 - Removed previous MLAPI Convenience and Performance RPC APIs with the new standard RPC API. See [RFC #1](https://github.com/Unity-Technologies/com.unity.multiplayer.rfcs/blob/master/text/0001-std-rpc-api.md) for details.
 - [GitHub 520](https://github.com/Unity-Technologies/com.unity.multiplayer.mlapi/pull/520): Removed the MLAPI Installer.
@@ -265,7 +847,7 @@ With a new release of MLAPI in Unity, some features have been removed:
 - For `NetworkVariable`, the `NetworkDictionary` `List` and `Set` must use the `reliableSequenced` channel.
 - `NetworkObjects`s are supported but when spawning a prefab with nested child network objects you have to manually call spawn on them
 - `NetworkTransform` have the following issues:
-  - Replicated objects may have jitter. 
+  - Replicated objects may have jitter.
   - The owner is always authoritative about the object's position.
   - Scale is not synchronized.
 - Connection Approval is not called on the host client.

Components/AnticipatedNetworkTransform.cs

@@ -0,0 +1,500 @@
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+
+#pragma warning disable IDE0001
+    /// <summary>
+    /// A subclass of <see cref="NetworkTransform"/> that supports basic client anticipation - the client
+    /// can set a value on the belief that the server will update it to reflect the same value in a future update
+    /// (i.e., as the result of an RPC call). This value can then be adjusted as new updates from the server come in,
+    /// in three basic modes:
+    ///
+    /// <list type="bullet">
+    ///
+    /// <item><b>Snap:</b> In this mode (with <see cref="StaleDataHandling"/> set to
+    /// <see cref="StaleDataHandling.Ignore"/> and no <see cref="NetworkBehaviour.OnReanticipate"/> callback),
+    /// the moment a more up-to-date value is received from the authority, it will simply replace the anticipated value,
+    /// resulting in a "snap" to the new value if it is different from the anticipated value.</item>
+    ///
+    /// <item><b>Smooth:</b> In this mode (with <see cref="StaleDataHandling"/> set to
+    /// <see cref="Netcode.StaleDataHandling.Ignore"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> callback that calls
+    /// <see cref="Smooth"/> from the anticipated value to the authority value with an appropriate
+    /// <see cref="Mathf.Lerp"/>-style smooth function), when a more up-to-date value is received from the authority,
+    /// it will interpolate over time from an incorrect anticipated value to the correct authoritative value.</item>
+    ///
+    /// <item><b>Constant Reanticipation:</b> In this mode (with <see cref="StaleDataHandling"/> set to
+    /// <see cref="Netcode.StaleDataHandling.Reanticipate"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> that calculates a
+    /// new anticipated value based on the current authoritative value), when a more up-to-date value is received from
+    /// the authority, user code calculates a new anticipated value, possibly calling <see cref="Smooth"/> to interpolate
+    /// between the previous anticipation and the new anticipation. This is useful for values that change frequently and
+    /// need to constantly be re-evaluated, as opposed to values that change only in response to user action and simply
+    /// need a one-time anticipation when the user performs that action.</item>
+    ///
+    /// </list>
+    ///
+    /// Note that these three modes may be combined. For example, if an <see cref="NetworkBehaviour.OnReanticipate"/> callback
+    /// does not call either <see cref="Smooth"/> or one of the Anticipate methods, the result will be a snap to the
+    /// authoritative value, enabling for a callback that may conditionally call <see cref="Smooth"/> when the
+    /// difference between the anticipated and authoritative values is within some threshold, but fall back to
+    /// snap behavior if the difference is too large.
+    /// </summary>
+#pragma warning restore IDE0001
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Netcode/Anticipated Network Transform")]
+    [DefaultExecutionOrder(100000)] // this is needed to catch the update time after the transform was updated by user scripts
+    public class AnticipatedNetworkTransform : NetworkTransform
+    {
+        public struct TransformState
+        {
+            public Vector3 Position;
+            public Quaternion Rotation;
+            public Vector3 Scale;
+        }
+
+        private TransformState m_AuthoritativeTransform = new TransformState();
+        private TransformState m_AnticipatedTransform = new TransformState();
+        private TransformState m_PreviousAnticipatedTransform = new TransformState();
+        private ulong m_LastAnticipaionCounter;
+        private double m_LastAnticipationTime;
+        private ulong m_LastAuthorityUpdateCounter;
+
+        private TransformState m_SmoothFrom;
+        private TransformState m_SmoothTo;
+        private float m_SmoothDuration;
+        private float m_CurrentSmoothTime;
+
+        private bool m_OutstandingAuthorityChange = false;
+
+#if UNITY_EDITOR
+        private void Reset()
+        {
+            // Anticipation + smoothing is a form of interpolation, and adding NetworkTransform's buffered interpolation
+            // makes the anticipation get weird, so we default it to false.
+            Interpolate = false;
+        }
+#endif
+
+#pragma warning disable IDE0001
+        /// <summary>
+        /// Defines what the behavior should be if we receive a value from the server with an earlier associated
+        /// time value than the anticipation time value.
+        /// <br/><br/>
+        /// If this is <see cref="Netcode.StaleDataHandling.Ignore"/>, the stale data will be ignored and the authoritative
+        /// value will not replace the anticipated value until the anticipation time is reached. <see cref="OnAuthoritativeValueChanged"/>
+        /// and <see cref="OnReanticipate"/> will also not be invoked for this stale data.
+        /// <br/><br/>
+        /// If this is <see cref="Netcode.StaleDataHandling.Reanticipate"/>, the stale data will replace the anticipated data and
+        /// <see cref="OnAuthoritativeValueChanged"/> and <see cref="OnReanticipate"/> will be invoked.
+        /// In this case, the authoritativeTime value passed to <see cref="OnReanticipate"/> will be lower than
+        /// the anticipationTime value, and that callback can be used to calculate a new anticipated value.
+        /// </summary>
+#pragma warning restore IDE0001
+        public StaleDataHandling StaleDataHandling = StaleDataHandling.Reanticipate;
+
+        /// <summary>
+        /// Contains the current state of this transform on the server side.
+        /// Note that, on the server side, this gets updated at the end of the frame, and will not immediately reflect
+        /// changes to the transform.
+        /// </summary>
+        public TransformState AuthoritativeState => m_AuthoritativeTransform;
+
+        /// <summary>
+        /// Contains the current anticipated state, which will match the values of this object's
+        /// actual <see cref="MonoBehaviour.transform"/>. When a server
+        /// update arrives, this value will be overwritten by the new
+        /// server value (unless stale data handling is set to "Ignore"
+        /// and the update is determined to be stale). This value will
+        /// be duplicated in <see cref="PreviousAnticipatedState"/>, which
+        /// will NOT be overwritten in server updates.
+        /// </summary>
+        public TransformState AnticipatedState => m_AnticipatedTransform;
+
+        /// <summary>
+        /// Indicates whether this transform currently needs
+        /// reanticipation. If this is true, the anticipated value
+        /// has been overwritten by the authoritative value from the
+        /// server; the previous anticipated value is stored in <see cref="PreviousAnticipatedState"/>
+        /// </summary>
+        public bool ShouldReanticipate
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Holds the most recent anticipated state, whatever was
+        /// most recently set using the Anticipate methods. Unlike
+        /// <see cref="AnticipatedState"/>, this does not get overwritten
+        /// when a server update arrives.
+        /// </summary>
+        public TransformState PreviousAnticipatedState => m_PreviousAnticipatedTransform;
+
+        /// <summary>
+        /// Anticipate that, at the end of one round trip to the server, this transform will be in the given
+        /// <see cref="newPosition"/>
+        /// </summary>
+        /// <param name="newPosition"></param>
+        public void AnticipateMove(Vector3 newPosition)
+        {
+            if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
+            {
+                return;
+            }
+            transform.position = newPosition;
+            m_AnticipatedTransform.Position = newPosition;
+            if (CanCommitToTransform)
+            {
+                m_AuthoritativeTransform.Position = newPosition;
+            }
+
+            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+
+            m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
+            m_LastAnticipationTime = NetworkManager.LocalTime.Time;
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+        }
+
+        /// <summary>
+        /// Anticipate that, at the end of one round trip to the server, this transform will have the given
+        /// <see cref="newRotation"/>
+        /// </summary>
+        /// <param name="newRotation"></param>
+        public void AnticipateRotate(Quaternion newRotation)
+        {
+            if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
+            {
+                return;
+            }
+            transform.rotation = newRotation;
+            m_AnticipatedTransform.Rotation = newRotation;
+            if (CanCommitToTransform)
+            {
+                m_AuthoritativeTransform.Rotation = newRotation;
+            }
+
+            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+
+            m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
+            m_LastAnticipationTime = NetworkManager.LocalTime.Time;
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+        }
+
+        /// <summary>
+        /// Anticipate that, at the end of one round trip to the server, this transform will have the given
+        /// <see cref="newScale"/>
+        /// </summary>
+        /// <param name="newScale"></param>
+        public void AnticipateScale(Vector3 newScale)
+        {
+            if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
+            {
+                return;
+            }
+            transform.localScale = newScale;
+            m_AnticipatedTransform.Scale = newScale;
+            if (CanCommitToTransform)
+            {
+                m_AuthoritativeTransform.Scale = newScale;
+            }
+
+            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+
+            m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
+            m_LastAnticipationTime = NetworkManager.LocalTime.Time;
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+        }
+
+        /// <summary>
+        /// Anticipate that, at the end of one round trip to the server, the transform will have the given
+        /// <see cref="newState"/>
+        /// </summary>
+        /// <param name="newState"></param>
+        public void AnticipateState(TransformState newState)
+        {
+            if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
+            {
+                return;
+            }
+            var transform_ = transform;
+            transform_.position = newState.Position;
+            transform_.rotation = newState.Rotation;
+            transform_.localScale = newState.Scale;
+            m_AnticipatedTransform = newState;
+            if (CanCommitToTransform)
+            {
+                m_AuthoritativeTransform = newState;
+            }
+
+            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+
+            m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
+            m_LastAnticipationTime = NetworkManager.LocalTime.Time;
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+        }
+
+        protected override void Update()
+        {
+            // If not spawned or this instance has authority, exit early
+            if (!IsSpawned)
+            {
+                return;
+            }
+            // Do not call the base class implementation...
+            // AnticipatedNetworkTransform applies its authoritative state immediately rather than waiting for update
+            // This is because AnticipatedNetworkTransforms may need to reference each other in reanticipating
+            // and we will want all reanticipation done before anything else wants to reference the transform in
+            // Update()
+            //base.Update();
+
+            if (m_CurrentSmoothTime < m_SmoothDuration)
+            {
+                m_CurrentSmoothTime += NetworkManager.RealTimeProvider.DeltaTime;
+                var transform_ = transform;
+                var pct = math.min(m_CurrentSmoothTime / m_SmoothDuration, 1f);
+
+                m_AnticipatedTransform = new TransformState
+                {
+                    Position = Vector3.Lerp(m_SmoothFrom.Position, m_SmoothTo.Position, pct),
+                    Rotation = Quaternion.Slerp(m_SmoothFrom.Rotation, m_SmoothTo.Rotation, pct),
+                    Scale = Vector3.Lerp(m_SmoothFrom.Scale, m_SmoothTo.Scale, pct)
+                };
+                m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+                if (!CanCommitToTransform)
+                {
+                    transform_.position = m_AnticipatedTransform.Position;
+                    transform_.localScale = m_AnticipatedTransform.Scale;
+                    transform_.rotation = m_AnticipatedTransform.Rotation;
+                }
+            }
+        }
+
+        internal class AnticipatedObject : IAnticipationEventReceiver, IAnticipatedObject
+        {
+            public AnticipatedNetworkTransform Transform;
+
+
+            public void SetupForRender()
+            {
+                if (Transform.CanCommitToTransform)
+                {
+                    var transform_ = Transform.transform;
+                    Transform.m_AuthoritativeTransform = new TransformState
+                    {
+                        Position = transform_.position,
+                        Rotation = transform_.rotation,
+                        Scale = transform_.localScale
+                    };
+                    if (Transform.m_CurrentSmoothTime >= Transform.m_SmoothDuration)
+                    {
+                        // If we've had a call to Smooth() we'll continue interpolating.
+                        // Otherwise we'll go ahead and make the visual and actual locations
+                        // match.
+                        Transform.m_AnticipatedTransform = Transform.m_AuthoritativeTransform;
+                    }
+
+                    transform_.position = Transform.m_AnticipatedTransform.Position;
+                    transform_.rotation = Transform.m_AnticipatedTransform.Rotation;
+                    transform_.localScale = Transform.m_AnticipatedTransform.Scale;
+                }
+            }
+
+            public void SetupForUpdate()
+            {
+                if (Transform.CanCommitToTransform)
+                {
+                    var transform_ = Transform.transform;
+                    transform_.position = Transform.m_AuthoritativeTransform.Position;
+                    transform_.rotation = Transform.m_AuthoritativeTransform.Rotation;
+                    transform_.localScale = Transform.m_AuthoritativeTransform.Scale;
+                }
+            }
+
+            public void Update()
+            {
+                // No need to do this, it's handled by NetworkBehaviour.Update
+            }
+
+            public void ResetAnticipation()
+            {
+                Transform.ShouldReanticipate = false;
+            }
+
+            public NetworkObject OwnerObject => Transform.NetworkObject;
+        }
+
+        private AnticipatedObject m_AnticipatedObject = null;
+
+        private void ResetAnticipatedState()
+        {
+            var transform_ = transform;
+            m_AuthoritativeTransform = new TransformState
+            {
+                Position = transform_.position,
+                Rotation = transform_.rotation,
+                Scale = transform_.localScale
+            };
+            m_AnticipatedTransform = m_AuthoritativeTransform;
+            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+        }
+
+        protected override void OnSynchronize<T>(ref BufferSerializer<T> serializer)
+        {
+            base.OnSynchronize(ref serializer);
+            if (!CanCommitToTransform)
+            {
+                m_OutstandingAuthorityChange = true;
+                ApplyAuthoritativeState();
+                ResetAnticipatedState();
+            }
+        }
+
+        public override void OnNetworkSpawn()
+        {
+            base.OnNetworkSpawn();
+            m_OutstandingAuthorityChange = true;
+            ApplyAuthoritativeState();
+            ResetAnticipatedState();
+
+            m_AnticipatedObject = new AnticipatedObject { Transform = this };
+            NetworkManager.AnticipationSystem.RegisterForAnticipationEvents(m_AnticipatedObject);
+            NetworkManager.AnticipationSystem.AllAnticipatedObjects.Add(m_AnticipatedObject);
+        }
+
+        public override void OnNetworkDespawn()
+        {
+            if (m_AnticipatedObject != null)
+            {
+                NetworkManager.AnticipationSystem.DeregisterForAnticipationEvents(m_AnticipatedObject);
+                NetworkManager.AnticipationSystem.AllAnticipatedObjects.Remove(m_AnticipatedObject);
+                NetworkManager.AnticipationSystem.ObjectsToReanticipate.Remove(m_AnticipatedObject);
+                m_AnticipatedObject = null;
+            }
+            ResetAnticipatedState();
+
+            base.OnNetworkDespawn();
+        }
+
+        public override void OnDestroy()
+        {
+            if (m_AnticipatedObject != null)
+            {
+                NetworkManager.AnticipationSystem.DeregisterForAnticipationEvents(m_AnticipatedObject);
+                NetworkManager.AnticipationSystem.AllAnticipatedObjects.Remove(m_AnticipatedObject);
+                NetworkManager.AnticipationSystem.ObjectsToReanticipate.Remove(m_AnticipatedObject);
+                m_AnticipatedObject = null;
+            }
+
+            base.OnDestroy();
+        }
+
+        /// <summary>
+        /// Interpolate between the transform represented by <see cref="from"/> to the transform represented by
+        /// <see cref="to"/> over <see cref="durationSeconds"/> of real time. The duration uses
+        /// <see cref="Time.deltaTime"/>, so it is affected by <see cref="Time.timeScale"/>.
+        /// </summary>
+        /// <param name="from"></param>
+        /// <param name="to"></param>
+        /// <param name="durationSeconds"></param>
+        public void Smooth(TransformState from, TransformState to, float durationSeconds)
+        {
+            var transform_ = transform;
+            if (durationSeconds <= 0)
+            {
+                m_AnticipatedTransform = to;
+                m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+                transform_.position = to.Position;
+                transform_.rotation = to.Rotation;
+                transform_.localScale = to.Scale;
+                m_SmoothDuration = 0;
+                m_CurrentSmoothTime = 0;
+                return;
+            }
+            m_AnticipatedTransform = from;
+            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+
+            if (!CanCommitToTransform)
+            {
+                transform_.position = from.Position;
+                transform_.rotation = from.Rotation;
+                transform_.localScale = from.Scale;
+            }
+
+            m_SmoothFrom = from;
+            m_SmoothTo = to;
+            m_SmoothDuration = durationSeconds;
+            m_CurrentSmoothTime = 0;
+        }
+
+        protected override void OnBeforeUpdateTransformState()
+        {
+            // this is called when new data comes from the server
+            m_LastAuthorityUpdateCounter = NetworkManager.AnticipationSystem.LastAnticipationAck;
+            m_OutstandingAuthorityChange = true;
+        }
+
+        protected override void OnNetworkTransformStateUpdated(ref NetworkTransformState oldState, ref NetworkTransformState newState)
+        {
+            base.OnNetworkTransformStateUpdated(ref oldState, ref newState);
+            ApplyAuthoritativeState();
+        }
+
+        protected override void OnTransformUpdated()
+        {
+            if (CanCommitToTransform || m_AnticipatedObject == null)
+            {
+                return;
+            }
+            // this is called pretty much every frame and will change the transform
+            // If we've overridden the transform with an anticipated state, we need to be able to change it back
+            // to the anticipated state (while updating the authority state accordingly) or else
+            // mark this transform for reanticipation
+            var transform_ = transform;
+
+            var previousAnticipatedTransform = m_AnticipatedTransform;
+
+            // Update authority state to catch any possible interpolation data
+            m_AuthoritativeTransform.Position = transform_.position;
+            m_AuthoritativeTransform.Rotation = transform_.rotation;
+            m_AuthoritativeTransform.Scale = transform_.localScale;
+
+            if (!m_OutstandingAuthorityChange)
+            {
+                // Keep the anticipated value unchanged, we have no updates from the server at all.
+                transform_.position = previousAnticipatedTransform.Position;
+                transform_.localScale = previousAnticipatedTransform.Scale;
+                transform_.rotation = previousAnticipatedTransform.Rotation;
+                return;
+            }
+
+            if (StaleDataHandling == StaleDataHandling.Ignore && m_LastAnticipaionCounter > m_LastAuthorityUpdateCounter)
+            {
+                // Keep the anticipated value unchanged because it is more recent than the authoritative one.
+                transform_.position = previousAnticipatedTransform.Position;
+                transform_.localScale = previousAnticipatedTransform.Scale;
+                transform_.rotation = previousAnticipatedTransform.Rotation;
+                return;
+            }
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+            m_OutstandingAuthorityChange = false;
+            m_AnticipatedTransform = m_AuthoritativeTransform;
+
+            ShouldReanticipate = true;
+            NetworkManager.AnticipationSystem.ObjectsToReanticipate.Add(m_AnticipatedObject);
+        }
+    }
+}

Components/AnticipatedNetworkTransform.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 97616b67982a4be48d957d421e422433
+timeCreated: 1705597211

Components/AssemblyInfo.cs

@@ -1,10 +1,15 @@
 using System.Runtime.CompilerServices;
 
 #if UNITY_EDITOR
-[assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")]
-[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]
 [assembly: InternalsVisibleTo("Unity.Netcode.Editor")]
-[assembly: InternalsVisibleTo("TestProject.EditorTests")]
-[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
-#endif
+[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]
+#endif // UNITY_EDITOR
+
+#if UNITY_INCLUDE_TESTS
 [assembly: InternalsVisibleTo("Unity.Netcode.RuntimeTests")]
+[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
+#if UNITY_EDITOR
+[assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")]
+[assembly: InternalsVisibleTo("TestProject.EditorTests")]
+#endif // UNITY_EDITOR
+#endif // UNITY_INCLUDE_TESTS

Components/HalfVector3.cs

@@ -0,0 +1,170 @@
+using System.Runtime.CompilerServices;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// Half float precision <see cref="Vector3"/>.
+    /// </summary>
+    /// <remarks>
+    /// The Vector3T<ushort> values are half float values returned by <see cref="Mathf.FloatToHalf(float)"/> for each
+    /// individual axis and the 16 bits of the half float are stored as <see cref="ushort"/> values since C# does not have
+    /// a half float type.
+    /// </remarks>
+    public struct HalfVector3 : INetworkSerializable
+    {
+        internal const int Length = 3;
+
+        /// <summary>
+        /// The half float precision value of the x-axis as a <see cref="half"/>.
+        /// </summary>
+        public half X => Axis.x;
+        /// <summary>
+        /// The half float precision value of the y-axis as a <see cref="half"/>.
+        /// </summary>
+        public half Y => Axis.y;
+        /// <summary>
+        /// The half float precision value of the z-axis as a <see cref="half"/>.
+        /// </summary>
+        public half Z => Axis.z;
+
+        /// <summary>
+        /// Used to store the half float precision values as a <see cref="half3"/>
+        /// </summary>
+        public half3 Axis;
+
+        /// <summary>
+        /// Determine which axis will be synchronized during serialization
+        /// </summary>
+        public bool3 AxisToSynchronize;
+
+        /// <summary>
+        /// Directly sets each axial value to the passed in full precision values
+        /// that are converted to half precision
+        /// </summary>
+        internal void Set(float x, float y, float z)
+        {
+            Axis.x = math.half(x);
+            Axis.y = math.half(y);
+            Axis.z = math.half(z);
+        }
+
+        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 < Length; i++)
+            {
+                if (AxisToSynchronize[i])
+                {
+                    var axisValue = Axis[i];
+                    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>
+        /// <returns>a <see cref="Vector3"/> as the full precision value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 ToVector3()
+        {
+            Vector3 fullPrecision = Vector3.zero;
+            Vector3 fullConversion = math.float3(Axis);
+            for (int i = 0; i < Length; i++)
+            {
+                if (AxisToSynchronize[i])
+                {
+                    fullPrecision[i] = fullConversion[i];
+                }
+            }
+            return fullPrecision;
+        }
+
+        /// <summary>
+        /// Converts a full precision <see cref="Vector3"/> to half precision and updates the current instance.
+        /// </summary>
+        /// <param name="vector3">The <see cref="Vector3"/> to convert.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UpdateFrom(ref Vector3 vector3)
+        {
+            var half3Full = math.half3(vector3);
+            for (int i = 0; i < Length; i++)
+            {
+                if (AxisToSynchronize[i])
+                {
+                    Axis[i] = half3Full[i];
+                }
+            }
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </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, bool3 axisToSynchronize)
+        {
+            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, math.bool3(true))
+        {
+
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <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="axisToSynchronize">The axis to synchronize.</param>
+        public HalfVector3(float x, float y, float z, bool3 axisToSynchronize) : this(new Vector3(x, y, z), axisToSynchronize)
+        {
+        }
+
+        /// <summary>
+        /// Constructor that defaults to all axis being synchronized.
+        /// </summary>
+        /// <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), math.bool3(true))
+        {
+        }
+    }
+}

Components/HalfVector3.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: a32aeecf69a2542469927066f5b88005
+guid: b0e371533eaeac446b16b10886f64f84
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Components/HalfVector4.cs

@@ -0,0 +1,137 @@
+using System.Runtime.CompilerServices;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// Half Precision <see cref="Vector4"/> that can also be used to convert a <see cref="Quaternion"/> to half precision.
+    /// </summary>
+    /// <remarks>
+    /// The Vector4T<ushort> values are half float values returned by <see cref="Mathf.FloatToHalf(float)"/> for each
+    /// individual axis and the 16 bits of the half float are stored as <see cref="ushort"/> values since C# does not have
+    /// a half float type.
+    /// </remarks>
+    public struct HalfVector4 : INetworkSerializable
+    {
+        internal const int Length = 4;
+        /// <summary>
+        /// The half float precision value of the x-axis as a <see cref="half"/>.
+        /// </summary>
+        public half X => Axis.x;
+
+        /// <summary>
+        /// The half float precision value of the y-axis as a <see cref="half"/>.
+        /// </summary>
+        public half Y => Axis.y;
+
+        /// <summary>
+        /// The half float precision value of the z-axis as a <see cref="half"/>.
+        /// </summary>
+        public half Z => Axis.z;
+
+        /// <summary>
+        /// The half float precision value of the w-axis as a <see cref="half"/>.
+        /// </summary>
+        public half W => Axis.w;
+
+        /// <summary>
+        /// Used to store the half float precision values as a <see cref="half4"/>
+        /// </summary>
+        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"/>.
+        /// </summary>
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            if (serializer.IsReader)
+            {
+                SerializeRead(serializer.GetFastBufferReader());
+            }
+            else
+            {
+                SerializeWrite(serializer.GetFastBufferWriter());
+            }
+        }
+
+        /// <summary>
+        /// Converts this instance to a full precision <see cref="Vector4"/>.
+        /// </summary>
+        /// <returns>A <see cref="Vector4"/> as the full precision value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector4 ToVector4()
+        {
+            return math.float4(Axis);
+        }
+
+        /// <summary>
+        /// Converts this instance to a full precision <see cref="Quaternion"/>.
+        /// </summary>
+        /// <returns>A <see cref="Quaternion"/> as the full precision value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Quaternion ToQuaternion()
+        {
+            return math.quaternion(Axis);
+        }
+
+        /// <summary>
+        /// Converts a full precision <see cref="Vector4"/> to half precision and updates the current instance.
+        /// </summary>
+        /// <param name="vector4">The <see cref="Vector4"/> to convert and update this instance with.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UpdateFrom(ref Vector4 vector4)
+        {
+            Axis = math.half4(vector4);
+        }
+
+        /// <summary>
+        /// Converts a full precision <see cref="Vector4"/> to half precision and updates the current instance.
+        /// </summary>
+        /// <param name="quaternion">The <see cref="Quaternion"/> to convert and update this instance with.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UpdateFrom(ref Quaternion quaternion)
+        {
+            Axis = math.half4(math.half(quaternion.x), math.half(quaternion.y), math.half(quaternion.z), math.half(quaternion.w));
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="vector4">The initial axial values (converted to half floats) when instantiated.</param>
+        public HalfVector4(Vector4 vector4)
+        {
+            Axis = default;
+            UpdateFrom(ref vector4);
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <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="w">The initial w axis (converted to half float) value when instantiated.</param>
+        public HalfVector4(float x, float y, float z, float w) : this(new Vector4(x, y, z, w))
+        {
+        }
+    }
+}

Components/HalfVector4.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: bd9e1475e8c8e4a6d935fe2409e3bd26
+guid: 03c78136f41ff84499e2a6ac4a7dd7a5
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Components/Interpolator/BufferedLinearInterpolator.cs

@@ -4,14 +4,14 @@ using UnityEngine;
 
 namespace Unity.Netcode
 {
-
     /// <summary>
     /// Solves for incoming values that are jittered
     /// Partially solves for message loss. Unclamped lerping helps hide this, but not completely
     /// </summary>
-    /// <typeparam name="T"></typeparam>
-    internal abstract class BufferedLinearInterpolator<T> where T : struct
+    /// <typeparam name="T">The type of interpolated value</typeparam>
+    public abstract class BufferedLinearInterpolator<T> where T : struct
     {
+        internal float MaxInterpolationBound = 3.0f;
         private struct BufferedItem
         {
             public T Item;
@@ -24,6 +24,10 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// There's two factors affecting interpolation: buffering (set in NetworkManager's NetworkTimeSystem) and interpolation time, which is the amount of time it'll take to reach the target. This is to affect the second one.
+        /// </summary>
+        public float MaximumInterpolationTime = 0.1f;
 
         private const double k_SmallValue = 9.999999439624929E-11; // copied from Vector3's equal operator
 
@@ -69,6 +73,21 @@ namespace Unity.Netcode
 
         private bool InvalidState => m_Buffer.Count == 0 && m_LifetimeConsumedCount == 0;
 
+        /// <summary>
+        /// Resets interpolator to initial state
+        /// </summary>
+        public void Clear()
+        {
+            m_Buffer.Clear();
+            m_EndTimeConsumed = 0.0d;
+            m_StartTimeConsumed = 0.0d;
+        }
+
+        /// <summary>
+        /// Teleports current interpolation value to targetValue.
+        /// </summary>
+        /// <param name="targetValue">The target value to teleport instantly</param>
+        /// <param name="serverTime">The current server time</param>
         public void ResetTo(T targetValue, double serverTime)
         {
             m_LifetimeConsumedCount = 1;
@@ -82,7 +101,6 @@ namespace Unity.Netcode
             Update(0, serverTime, serverTime);
         }
 
-
         // todo if I have value 1, 2, 3 and I'm treating 1 to 3, I shouldn't interpolate between 1 and 3, I should interpolate from 1 to 2, then from 2 to 3 to get the best path
         private void TryConsumeFromBuffer(double renderTime, double serverTime)
         {
@@ -144,6 +162,7 @@ namespace Unity.Netcode
         /// </summary>
         /// <param name="deltaTime">time since call</param>
         /// <param name="serverTime">current server time</param>
+        /// <returns>The newly interpolated value of type 'T'</returns>
         public T Update(float deltaTime, NetworkTime serverTime)
         {
             return Update(deltaTime, serverTime.TimeTicksAgo(1).Time, serverTime.Time);
@@ -155,6 +174,7 @@ namespace Unity.Netcode
         /// <param name="deltaTime">time since last call</param>
         /// <param name="renderTime">our current time</param>
         /// <param name="serverTime">current server time</param>
+        /// <returns>The newly interpolated value of type 'T'</returns>
         public T Update(float deltaTime, double renderTime, double serverTime)
         {
             TryConsumeFromBuffer(renderTime, serverTime);
@@ -179,26 +199,36 @@ namespace Unity.Netcode
 
                     if (t < 0.0f)
                     {
-                        throw new OverflowException($"t = {t} but must be >= 0. range {range}, RenderTime {renderTime}, Start time {m_StartTimeConsumed}, end time {m_EndTimeConsumed}");
+                        // There is no mechanism to guarantee renderTime to not be before m_StartTimeConsumed
+                        // This clamps t to a minimum of 0 and fixes issues with longer frames and pauses
+
+                        if (NetworkLog.CurrentLogLevel <= LogLevel.Developer)
+                        {
+                            NetworkLog.LogError($"renderTime was before m_StartTimeConsumed. This should never happen. {nameof(renderTime)} is {renderTime}, {nameof(m_StartTimeConsumed)} is {m_StartTimeConsumed}");
+                        }
+                        t = 0.0f;
                     }
 
-                    if (t > 3.0f) // max extrapolation
+                    if (t > MaxInterpolationBound) // max extrapolation
                     {
                         // TODO this causes issues with teleport, investigate
-                        // todo make this configurable
                         t = 1.0f;
                     }
                 }
 
                 var target = InterpolateUnclamped(m_InterpStartValue, m_InterpEndValue, t);
-                float maxInterpTime = 0.1f;
-                m_CurrentInterpValue = Interpolate(m_CurrentInterpValue, target, deltaTime / maxInterpTime); // second interpolate to smooth out extrapolation jumps
+                m_CurrentInterpValue = Interpolate(m_CurrentInterpValue, target, deltaTime / MaximumInterpolationTime); // second interpolate to smooth out extrapolation jumps
             }
 
             m_NbItemsReceivedThisFrame = 0;
             return m_CurrentInterpValue;
         }
 
+        /// <summary>
+        /// Add measurements to be used during interpolation. These will be buffered before being made available to be displayed as "latest value".
+        /// </summary>
+        /// <param name="newMeasurement">The new measurement value to use</param>
+        /// <param name="sentTime">The time to record for measurement</param>
         public void AddMeasurement(T newMeasurement, double sentTime)
         {
             m_NbItemsReceivedThisFrame++;
@@ -211,11 +241,15 @@ namespace Unity.Netcode
                 {
                     m_LastBufferedItemReceived = new BufferedItem(newMeasurement, sentTime);
                     ResetTo(newMeasurement, sentTime);
+                    // Next line keeps renderTime above m_StartTimeConsumed. Fixes pause/unpause issues
+                    m_Buffer.Add(m_LastBufferedItemReceived);
                 }
 
                 return;
             }
 
+            // Part the of reason for disabling extrapolation is how we add and use measurements over time.
+            // TODO: Add detailed description of this area in Jira ticket
             if (sentTime > m_EndTimeConsumed || m_LifetimeConsumedCount == 0) // treat only if value is newer than the one being interpolated to right now
             {
                 m_LastBufferedItemReceived = new BufferedItem(newMeasurement, sentTime);
@@ -223,39 +257,134 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Gets latest value from the interpolator. This is updated every update as time goes by.
+        /// </summary>
+        /// <returns>The current interpolated value of type 'T'</returns>
         public T GetInterpolatedValue()
         {
             return m_CurrentInterpValue;
         }
 
+        /// <summary>
+        /// Method to override and adapted to the generic type. This assumes interpolation for that value will be clamped.
+        /// </summary>
+        /// <param name="start">The start value (min)</param>
+        /// <param name="end">The end value (max)</param>
+        /// <param name="time">The time value used to interpolate between start and end values (pos)</param>
+        /// <returns>The interpolated value</returns>
         protected abstract T Interpolate(T start, T end, float time);
+
+        /// <summary>
+        /// Method to override and adapted to the generic type. This assumes interpolation for that value will not be clamped.
+        /// </summary>
+        /// <param name="start">The start value (min)</param>
+        /// <param name="end">The end value (max)</param>
+        /// <param name="time">The time value used to interpolate between start and end values (pos)</param>
+        /// <returns>The interpolated value</returns>
         protected abstract T InterpolateUnclamped(T start, T end, float time);
     }
 
-
-    internal class BufferedLinearInterpolatorFloat : BufferedLinearInterpolator<float>
+    /// <inheritdoc />
+    /// <remarks>
+    /// This is a buffered linear interpolator for a <see cref="float"/> type value
+    /// </remarks>
+    public class BufferedLinearInterpolatorFloat : BufferedLinearInterpolator<float>
     {
+        /// <inheritdoc />
         protected override float InterpolateUnclamped(float start, float end, float time)
         {
-            return Mathf.LerpUnclamped(start, end, time);
+            // Disabling Extrapolation:
+            // TODO: Add Jira Ticket
+            return Mathf.Lerp(start, end, time);
         }
 
+        /// <inheritdoc />
         protected override float Interpolate(float start, float end, float time)
         {
             return Mathf.Lerp(start, end, time);
         }
     }
 
-    internal class BufferedLinearInterpolatorQuaternion : BufferedLinearInterpolator<Quaternion>
+    /// <inheritdoc />
+    /// <remarks>
+    /// This is a buffered linear interpolator for a <see cref="Quaternion"/> type value
+    /// </remarks>
+    public class BufferedLinearInterpolatorQuaternion : BufferedLinearInterpolator<Quaternion>
     {
+        /// <summary>
+        /// Use <see cref="Quaternion.Slerp"/> when <see cref="true"/>.
+        /// Use <see cref="Quaternion.Lerp"/> when <see cref="false"/>
+        /// </summary>
+        /// <remarks>
+        /// When using half precision (due to the imprecision) using <see cref="Quaternion.Lerp"/> is
+        /// less processor intensive (i.e. precision is already "imprecise").
+        /// When using full precision (to maintain precision) using <see cref="Quaternion.Slerp"/> is
+        /// more processor intensive yet yields more precise results.
+        /// </remarks>
+        public bool IsSlerp;
+
+        /// <inheritdoc />
         protected override Quaternion InterpolateUnclamped(Quaternion start, Quaternion end, float time)
         {
-            return Quaternion.SlerpUnclamped(start, end, time);
+            if (IsSlerp)
+            {
+                return Quaternion.Slerp(start, end, time);
+            }
+            else
+            {
+                return Quaternion.Lerp(start, end, time);
+            }
         }
 
+        /// <inheritdoc />
         protected override Quaternion Interpolate(Quaternion start, Quaternion end, float time)
         {
-            return Quaternion.SlerpUnclamped(start, end, time);
+            if (IsSlerp)
+            {
+                return Quaternion.Slerp(start, end, time);
+            }
+            else
+            {
+                return Quaternion.Lerp(start, end, time);
+            }
+        }
+    }
+
+    /// <summary>
+    /// A <see cref="BufferedLinearInterpolator<T>"/> <see cref="Vector3"/> implementation.
+    /// </summary>
+    public class BufferedLinearInterpolatorVector3 : BufferedLinearInterpolator<Vector3>
+    {
+        /// <summary>
+        /// Use <see cref="Vector3.Slerp"/> when <see cref="true"/>.
+        /// Use <see cref="Vector3.Lerp"/> when <see cref="false"/>
+        /// </summary>
+        public bool IsSlerp;
+        /// <inheritdoc />
+        protected override Vector3 InterpolateUnclamped(Vector3 start, Vector3 end, float time)
+        {
+            if (IsSlerp)
+            {
+                return Vector3.Slerp(start, end, time);
+            }
+            else
+            {
+                return Vector3.Lerp(start, end, time);
+            }
+        }
+
+        /// <inheritdoc />
+        protected override Vector3 Interpolate(Vector3 start, Vector3 end, float time)
+        {
+            if (IsSlerp)
+            {
+                return Vector3.Slerp(start, end, time);
+            }
+            else
+            {
+                return Vector3.Lerp(start, end, time);
+            }
         }
     }
 }

Components/Messages.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 2c61e8fe9a68a486fbbc3128d233ded2
+guid: a9db1d18fa0117f4da5e8e65386b894a
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Components/Messages/NetworkTransformMessage.cs

@@ -0,0 +1,116 @@
+using Unity.Netcode.Components;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// NetworkTransform State Update Message
+    /// </summary>
+    internal struct NetworkTransformMessage : INetworkMessage
+    {
+        public int Version => 0;
+        public ulong NetworkObjectId;
+        public int NetworkBehaviourId;
+        public NetworkTransform.NetworkTransformState State;
+
+        private NetworkTransform m_ReceiverNetworkTransform;
+        private FastBufferReader m_CurrentReader;
+
+        private unsafe void CopyPayload(ref FastBufferWriter writer)
+        {
+            writer.WriteBytesSafe(m_CurrentReader.GetUnsafePtrAtCurrentPosition(), m_CurrentReader.Length - m_CurrentReader.Position);
+        }
+
+        public void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            if (m_CurrentReader.IsInitialized)
+            {
+                CopyPayload(ref writer);
+            }
+            else
+            {
+                BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
+                BytePacker.WriteValueBitPacked(writer, NetworkBehaviourId);
+                writer.WriteNetworkSerializable(State);
+            }
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            var networkManager = context.SystemOwner as NetworkManager;
+            if (networkManager == null)
+            {
+                Debug.LogError($"[{nameof(NetworkTransformMessage)}] System owner context was not of type {nameof(NetworkManager)}!");
+                return false;
+            }
+            var currentPosition = reader.Position;
+            ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId);
+            if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
+            {
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
+                return false;
+            }
+            // Get the behaviour index
+            ByteUnpacker.ReadValueBitPacked(reader, out NetworkBehaviourId);
+
+            // Deserialize the state
+            reader.ReadNetworkSerializable(out State);
+
+            var networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
+
+            // Get the target NetworkTransform
+            m_ReceiverNetworkTransform = networkObject.ChildNetworkBehaviours[NetworkBehaviourId] as NetworkTransform;
+
+            var isServerAuthoritative = m_ReceiverNetworkTransform.IsServerAuthoritative();
+            var ownerAuthoritativeServerSide = !isServerAuthoritative && networkManager.IsServer;
+            if (ownerAuthoritativeServerSide)
+            {
+                var ownerClientId = networkObject.OwnerClientId;
+                if (ownerClientId == NetworkManager.ServerClientId)
+                {
+                    // Ownership must have changed, ignore any additional pending messages that might have
+                    // come from a previous owner client.
+                    return true;
+                }
+
+                var networkDelivery = State.IsReliableStateUpdate() ? NetworkDelivery.ReliableSequenced : NetworkDelivery.UnreliableSequenced;
+
+                // Forward the state update if there are any remote clients to foward it to
+                if (networkManager.ConnectionManager.ConnectedClientsList.Count > (networkManager.IsHost ? 2 : 1))
+                {
+                    // This is only to copy the existing and already serialized struct for forwarding purposes only.
+                    // This will not include any changes made to this struct at this particular stage of processing the message.
+                    var currentMessage = this;
+                    // Create a new reader that replicates this message
+                    currentMessage.m_CurrentReader = new FastBufferReader(reader, Collections.Allocator.None);
+                    // Rewind the new reader to the beginning of the message's payload
+                    currentMessage.m_CurrentReader.Seek(currentPosition);
+                    // Forward the message to all connected clients that are observers of the associated NetworkObject
+                    var clientCount = networkManager.ConnectionManager.ConnectedClientsList.Count;
+                    for (int i = 0; i < clientCount; i++)
+                    {
+                        var clientId = networkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
+                        if (NetworkManager.ServerClientId == clientId || (!isServerAuthoritative && clientId == ownerClientId) || !networkObject.Observers.Contains(clientId))
+                        {
+                            continue;
+                        }
+                        networkManager.MessageManager.SendMessage(ref currentMessage, networkDelivery, clientId);
+                    }
+                    // Dispose of the reader used for forwarding
+                    currentMessage.m_CurrentReader.Dispose();
+                }
+            }
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            if (m_ReceiverNetworkTransform == null)
+            {
+                Debug.LogError($"[{nameof(NetworkTransformMessage)}][Dropped] Reciever {nameof(NetworkTransform)} was not set!");
+                return;
+            }
+            m_ReceiverNetworkTransform.TransformStateUpdate(ref State);
+        }
+    }
+}

Components/Messages/NetworkTransformMessage.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 69c3c1c5a885d4aed99ee2e1fa40f763
+guid: dcfc8ac43fef97e42adb19b998d70c37
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Components/NetworkDeltaPosition.cs

@@ -0,0 +1,221 @@
+using System.Runtime.CompilerServices;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// Used to synchromnize delta position when half float precision is enabled
+    /// </summary>
+    public struct NetworkDeltaPosition : INetworkSerializable
+    {
+        internal const float MaxDeltaBeforeAdjustment = 64f;
+
+        /// <summary>
+        /// The HalfVector3 used to synchronize the delta in position
+        /// </summary>
+        public HalfVector3 HalfVector3;
+
+        internal Vector3 CurrentBasePosition;
+        internal Vector3 PrecisionLossDelta;
+        internal Vector3 HalfDeltaConvertedBack;
+        internal Vector3 PreviousPosition;
+        internal Vector3 DeltaPosition;
+        internal int NetworkTick;
+
+        internal bool SynchronizeBase;
+
+        internal bool CollapsedDeltaIntoBase;
+
+        /// <summary>
+        /// The serialization implementation of <see cref="INetworkSerializable"/>
+        /// </summary>
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            if (!SynchronizeBase)
+            {
+                HalfVector3.NetworkSerialize(serializer);
+            }
+            else
+            {
+                serializer.SerializeValue(ref DeltaPosition);
+                serializer.SerializeValue(ref CurrentBasePosition);
+            }
+        }
+
+        /// <summary>
+        /// Gets the full precision value of Vector3 position while also potentially updating the current base position.
+        /// </summary>
+        /// <param name="networkTick">Use the current network tick value.</param>
+        /// <returns>The full position as a <see cref="Vector3"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 ToVector3(int networkTick)
+        {
+            // When synchronizing, it is possible to have a state update arrive
+            // for the same synchronization network tick.  Under this scenario,
+            // we only want to return the existing CurrentBasePosition + DeltaPosition
+            // values and not process the X, Y, or Z values.
+            // (See the constructors below)
+            if (networkTick == NetworkTick)
+            {
+                return CurrentBasePosition + DeltaPosition;
+            }
+            for (int i = 0; i < HalfVector3.Length; i++)
+            {
+                if (HalfVector3.AxisToSynchronize[i])
+                {
+                    DeltaPosition[i] = Mathf.HalfToFloat(HalfVector3.Axis[i].value);
+                    // If we exceed or are equal to the maximum delta value then we need to
+                    // apply the delta to the CurrentBasePosition value and reset the delta
+                    // position for the axis.
+                    if (Mathf.Abs(DeltaPosition[i]) >= MaxDeltaBeforeAdjustment)
+                    {
+                        CurrentBasePosition[i] += DeltaPosition[i];
+                        DeltaPosition[i] = 0.0f;
+                        HalfVector3.Axis[i] = half.zero;
+                    }
+                }
+            }
+            return CurrentBasePosition + DeltaPosition;
+        }
+
+        /// <summary>
+        /// Returns the current base position (excluding the delta position offset).
+        /// </summary>
+        /// <returns>The current base position as a <see cref="Vector3"/></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetCurrentBasePosition()
+        {
+            return CurrentBasePosition;
+        }
+
+        /// <summary>
+        /// Returns the full position which includes the delta offset position.
+        /// </summary>
+        /// <returns>The full position as a <see cref="Vector3"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetFullPosition()
+        {
+            return CurrentBasePosition + DeltaPosition;
+        }
+
+        /// <summary>
+        /// The half float vector3 version of the current delta position.
+        /// </summary>
+        /// <remarks>
+        /// Only applies to the authoritative side for <see cref="NetworkTransform"/> instances.
+        /// </remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetConvertedDelta()
+        {
+            return HalfDeltaConvertedBack;
+        }
+
+        /// <summary>
+        /// The full precision current delta position.
+        /// </summary>
+        /// <remarks>
+        /// Authoritative: Will have no precision loss
+        /// Non-Authoritative: Has the current network tick's loss of precision.
+        /// Precision loss adjustments are one network tick behind on the
+        /// non-authoritative side.
+        /// </remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetDeltaPosition()
+        {
+            return DeltaPosition;
+        }
+
+        /// <summary>
+        /// Updates the position delta based off of the current base position.
+        /// </summary>
+        /// <param name="vector3">The full precision <see cref="Vector3"/> value to (converted to half floats) used to determine the delta offset positon.</param>
+        /// <param name="networkTick">Set the current network tick value when updating.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UpdateFrom(ref Vector3 vector3, int networkTick)
+        {
+            CollapsedDeltaIntoBase = false;
+            NetworkTick = networkTick;
+            DeltaPosition = (vector3 + PrecisionLossDelta) - CurrentBasePosition;
+            for (int i = 0; i < HalfVector3.Length; i++)
+            {
+                if (HalfVector3.AxisToSynchronize[i])
+                {
+                    HalfVector3.Axis[i] = math.half(DeltaPosition[i]);
+                    HalfDeltaConvertedBack[i] = Mathf.HalfToFloat(HalfVector3.Axis[i].value);
+                    PrecisionLossDelta[i] = DeltaPosition[i] - HalfDeltaConvertedBack[i];
+                    if (Mathf.Abs(HalfDeltaConvertedBack[i]) >= MaxDeltaBeforeAdjustment)
+                    {
+                        CurrentBasePosition[i] += HalfDeltaConvertedBack[i];
+                        HalfDeltaConvertedBack[i] = 0.0f;
+                        DeltaPosition[i] = 0.0f;
+                        CollapsedDeltaIntoBase = true;
+                    }
+                }
+            }
+
+            for (int i = 0; i < HalfVector3.Length; i++)
+            {
+                if (HalfVector3.AxisToSynchronize[i])
+                {
+                    PreviousPosition[i] = vector3[i];
+                }
+            }
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="vector3">The initial axial values (converted to half floats) when instantiated.</param>
+        /// <param name="networkTick">Set the network tick value to the current network tick when instantiating.</param>
+        /// <param name="axisToSynchronize">The axis to be synchronized.</param>
+        public NetworkDeltaPosition(Vector3 vector3, int networkTick, bool3 axisToSynchronize)
+        {
+            NetworkTick = networkTick;
+            CurrentBasePosition = vector3;
+            PreviousPosition = vector3;
+            PrecisionLossDelta = Vector3.zero;
+            DeltaPosition = Vector3.zero;
+            HalfDeltaConvertedBack = Vector3.zero;
+            HalfVector3 = new HalfVector3(vector3, axisToSynchronize);
+            SynchronizeBase = false;
+            CollapsedDeltaIntoBase = false;
+            UpdateFrom(ref vector3, networkTick);
+        }
+
+        /// <summary>
+        /// Constructor that defaults to all axis being synchronized.
+        /// </summary>
+        /// <param name="vector3">The initial axial values (converted to half floats) when instantiated.</param>
+        /// <param name="networkTick">Set the network tick value to the current network tick when instantiating.</param>
+        public NetworkDeltaPosition(Vector3 vector3, int networkTick) : this(vector3, networkTick, math.bool3(true))
+        {
+
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <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="networkTick">Set the network tick value to the current network tick when instantiating.</param>
+        /// <param name="axisToSynchronize">The axis to be synchronized.</param>
+        public NetworkDeltaPosition(float x, float y, float z, int networkTick, bool3 axisToSynchronize) :
+            this(new Vector3(x, y, z), networkTick, axisToSynchronize)
+        {
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <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="networkTick">Set the network tick value to the current network tick when instantiating.</param>
+        public NetworkDeltaPosition(float x, float y, float z, int networkTick) :
+            this(new Vector3(x, y, z), networkTick, math.bool3(true))
+        {
+        }
+    }
+}

Components/NetworkDeltaPosition.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: c275febadb27c4d18b41218e3353b84b
+guid: e45e6886578116f4c92fa0fe0d77fb85
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Components/NetworkRigidbody.cs

@@ -1,80 +1,113 @@
+#if COM_UNITY_MODULES_PHYSICS
 using UnityEngine;
 
 namespace Unity.Netcode.Components
 {
     /// <summary>
     /// NetworkRigidbody allows for the use of <see cref="Rigidbody"/> on network objects. By controlling the kinematic
-    /// mode of the rigidbody and disabling it on all peers but the authoritative one.
+    /// mode of the <see cref="Rigidbody"/> and disabling it on all peers but the authoritative one.
     /// </summary>
     [RequireComponent(typeof(Rigidbody))]
     [RequireComponent(typeof(NetworkTransform))]
+    [AddComponentMenu("Netcode/Network Rigidbody")]
     public class NetworkRigidbody : NetworkBehaviour
     {
+        /// <summary>
+        /// Determines if we are server (true) or owner (false) authoritative
+        /// </summary>
+        private bool m_IsServerAuthoritative;
+
         private Rigidbody m_Rigidbody;
         private NetworkTransform m_NetworkTransform;
-
-        private bool m_OriginalKinematic;
         private RigidbodyInterpolation m_OriginalInterpolation;
 
-        // Used to cache the authority state of this rigidbody during the last frame
+        // Used to cache the authority state of this Rigidbody during the last frame
         private bool m_IsAuthority;
 
-        /// <summary>
-        /// Gets a bool value indicating whether this <see cref="NetworkRigidbody"/> on this peer currently holds authority.
-        /// </summary>
-        private bool HasAuthority => m_NetworkTransform.CanCommitToTransform;
-
         private void Awake()
         {
-            m_Rigidbody = GetComponent<Rigidbody>();
             m_NetworkTransform = GetComponent<NetworkTransform>();
+            m_IsServerAuthoritative = m_NetworkTransform.IsServerAuthoritative();
+
+            SetupRigidBody();
         }
 
-        private void FixedUpdate()
+        /// <summary>
+        /// If the current <see cref="NetworkTransform"/> has authority,
+        /// then use the <see cref="RigidBody"/> interpolation strategy,
+        /// if the <see cref="NetworkTransform"/> is handling interpolation,
+        /// set interpolation to none on the <see cref="RigidBody"/>
+        /// <br/>
+        /// Turn off physics for the rigid body until spawned, otherwise
+        /// clients can run fixed update before the first
+        /// full <see cref="NetworkTransform"/> update
+        /// </summary>
+        private void SetupRigidBody()
         {
-            if (NetworkManager.IsListening)
-            {
-                if (HasAuthority != m_IsAuthority)
-                {
-                    m_IsAuthority = HasAuthority;
-                    UpdateRigidbodyKinematicMode();
-                }
-            }
+            m_Rigidbody = GetComponent<Rigidbody>();
+            m_OriginalInterpolation = m_Rigidbody.interpolation;
+
+            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : (m_NetworkTransform.Interpolate ? RigidbodyInterpolation.None : m_OriginalInterpolation);
+            m_Rigidbody.isKinematic = true;
         }
 
-        // Puts the rigidbody in a kinematic non-interpolated mode on everyone but the server.
-        private void UpdateRigidbodyKinematicMode()
+        /// <summary>
+        /// For owner authoritative (i.e. ClientNetworkTransform)
+        /// we adjust our authority when we gain ownership
+        /// </summary>
+        public override void OnGainedOwnership()
         {
-            if (m_IsAuthority == false)
-            {
-                m_OriginalKinematic = m_Rigidbody.isKinematic;
-                m_Rigidbody.isKinematic = true;
+            UpdateOwnershipAuthority();
+        }
 
-                m_OriginalInterpolation = m_Rigidbody.interpolation;
-                // Set interpolation to none, the NetworkTransform component interpolates the position of the object.
-                m_Rigidbody.interpolation = RigidbodyInterpolation.None;
+        /// <summary>
+        /// For owner authoritative(i.e. ClientNetworkTransform)
+        /// we adjust our authority when we have lost ownership
+        /// </summary>
+        public override void OnLostOwnership()
+        {
+            UpdateOwnershipAuthority();
+        }
+
+        /// <summary>
+        /// Sets the authority differently depending upon
+        /// whether it is server or owner authoritative
+        /// </summary>
+        private void UpdateOwnershipAuthority()
+        {
+            if (m_IsServerAuthoritative)
+            {
+                m_IsAuthority = NetworkManager.IsServer;
             }
             else
             {
-                // Resets the rigidbody back to it's non replication only state. Happens on shutdown and when authority is lost
-                m_Rigidbody.isKinematic = m_OriginalKinematic;
-                m_Rigidbody.interpolation = m_OriginalInterpolation;
+                m_IsAuthority = IsOwner;
             }
+
+            // If you have authority then you are not kinematic
+            m_Rigidbody.isKinematic = !m_IsAuthority;
+
+            // Set interpolation of the Rigidbody based on authority
+            // With authority: let local transform handle interpolation
+            // Without authority: let the NetworkTransform handle interpolation
+            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : RigidbodyInterpolation.None;
         }
 
         /// <inheritdoc />
         public override void OnNetworkSpawn()
         {
-            m_IsAuthority = HasAuthority;
-            m_OriginalKinematic = m_Rigidbody.isKinematic;
-            m_OriginalInterpolation = m_Rigidbody.interpolation;
-            UpdateRigidbodyKinematicMode();
+            UpdateOwnershipAuthority();
         }
 
         /// <inheritdoc />
         public override void OnNetworkDespawn()
         {
-            UpdateRigidbodyKinematicMode();
+            m_Rigidbody.interpolation = m_OriginalInterpolation;
+            // Turn off physics for the rigid body until spawned, otherwise
+            // non-owners can run fixed updates before the first full
+            // NetworkTransform update and physics will be applied (i.e. gravity, etc)
+            m_Rigidbody.isKinematic = true;
         }
     }
 }
+#endif // COM_UNITY_MODULES_PHYSICS

Components/NetworkRigidbody2D.cs

@@ -1,3 +1,4 @@
+#if COM_UNITY_MODULES_PHYSICS2D
 using UnityEngine;
 
 namespace Unity.Netcode.Components
@@ -8,73 +9,105 @@ namespace Unity.Netcode.Components
     /// </summary>
     [RequireComponent(typeof(Rigidbody2D))]
     [RequireComponent(typeof(NetworkTransform))]
+    [AddComponentMenu("Netcode/Network Rigidbody 2D")]
     public class NetworkRigidbody2D : NetworkBehaviour
     {
+        /// <summary>
+        /// Determines if we are server (true) or owner (false) authoritative
+        /// </summary>
+        private bool m_IsServerAuthoritative;
+
         private Rigidbody2D m_Rigidbody;
         private NetworkTransform m_NetworkTransform;
 
-        private bool m_OriginalKinematic;
         private RigidbodyInterpolation2D m_OriginalInterpolation;
 
         // Used to cache the authority state of this rigidbody during the last frame
         private bool m_IsAuthority;
 
-        /// <summary>
-        /// Gets a bool value indicating whether this <see cref="NetworkRigidbody2D"/> on this peer currently holds authority.
-        /// </summary>
-        private bool HasAuthority => m_NetworkTransform.CanCommitToTransform;
-
         private void Awake()
         {
-            m_Rigidbody = GetComponent<Rigidbody2D>();
             m_NetworkTransform = GetComponent<NetworkTransform>();
+            m_IsServerAuthoritative = m_NetworkTransform.IsServerAuthoritative();
+
+            SetupRigidBody();
         }
 
-        private void FixedUpdate()
+        /// <summary>
+        /// If the current <see cref="NetworkTransform"/> has authority,
+        /// then use the <see cref="Rigidbody2D"/> interpolation strategy,
+        /// if the <see cref="NetworkTransform"/> is handling interpolation,
+        /// set interpolation to none on the <see cref="Rigidbody2D"/>
+        /// <br/>
+        /// Turn off physics for the rigid body until spawned, otherwise
+        /// clients can run fixed update before the first
+        /// full <see cref="NetworkTransform"/> update
+        /// </summary>
+        private void SetupRigidBody()
         {
-            if (IsSpawned)
-            {
-                if (HasAuthority != m_IsAuthority)
-                {
-                    m_IsAuthority = HasAuthority;
-                    UpdateRigidbodyKinematicMode();
-                }
-            }
+            m_Rigidbody = GetComponent<Rigidbody2D>();
+            m_OriginalInterpolation = m_Rigidbody.interpolation;
+
+            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : (m_NetworkTransform.Interpolate ? RigidbodyInterpolation2D.None : m_OriginalInterpolation);
+            // Turn off physics for the rigid body until spawned, otherwise
+            // clients can run fixed update before the first full
+            // NetworkTransform update
+            m_Rigidbody.isKinematic = true;
         }
 
-        // Puts the rigidbody in a kinematic non-interpolated mode on everyone but the server.
-        private void UpdateRigidbodyKinematicMode()
+        /// <summary>
+        /// For owner authoritative (i.e. ClientNetworkTransform)
+        /// we adjust our authority when we gain ownership
+        /// </summary>
+        public override void OnGainedOwnership()
         {
-            if (m_IsAuthority == false)
-            {
-                m_OriginalKinematic = m_Rigidbody.isKinematic;
-                m_Rigidbody.isKinematic = true;
+            UpdateOwnershipAuthority();
+        }
 
-                m_OriginalInterpolation = m_Rigidbody.interpolation;
-                // Set interpolation to none, the NetworkTransform component interpolates the position of the object.
-                m_Rigidbody.interpolation = RigidbodyInterpolation2D.None;
+        /// <summary>
+        /// For owner authoritative(i.e. ClientNetworkTransform)
+        /// we adjust our authority when we have lost ownership
+        /// </summary>
+        public override void OnLostOwnership()
+        {
+            UpdateOwnershipAuthority();
+        }
+
+        /// <summary>
+        /// Sets the authority differently depending upon
+        /// whether it is server or owner authoritative
+        /// </summary>
+        private void UpdateOwnershipAuthority()
+        {
+            if (m_IsServerAuthoritative)
+            {
+                m_IsAuthority = NetworkManager.IsServer;
             }
             else
             {
-                // Resets the rigidbody back to it's non replication only state. Happens on shutdown and when authority is lost
-                m_Rigidbody.isKinematic = m_OriginalKinematic;
-                m_Rigidbody.interpolation = m_OriginalInterpolation;
+                m_IsAuthority = IsOwner;
             }
+
+            // If you have authority then you are not kinematic
+            m_Rigidbody.isKinematic = !m_IsAuthority;
+
+            // Set interpolation of the Rigidbody2D based on authority
+            // With authority: let local transform handle interpolation
+            // Without authority: let the NetworkTransform handle interpolation
+            m_Rigidbody.interpolation = m_IsAuthority ? m_OriginalInterpolation : RigidbodyInterpolation2D.None;
         }
 
         /// <inheritdoc />
         public override void OnNetworkSpawn()
         {
-            m_IsAuthority = HasAuthority;
-            m_OriginalKinematic = m_Rigidbody.isKinematic;
-            m_OriginalInterpolation = m_Rigidbody.interpolation;
-            UpdateRigidbodyKinematicMode();
+            UpdateOwnershipAuthority();
         }
 
         /// <inheritdoc />
         public override void OnNetworkDespawn()
         {
-            UpdateRigidbodyKinematicMode();
+            UpdateOwnershipAuthority();
         }
     }
 }
+#endif // COM_UNITY_MODULES_PHYSICS2D

Components/QuaternionCompressor.cs

@@ -0,0 +1,123 @@
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// A Smallest Three Quaternion Compressor Implementation
+    /// </summary>
+    /// <remarks>
+    /// Explanation of why "The smallest three":
+    /// Since a normalized Quaternion's unit value is 1.0f:
+    /// x*x + y*y + z*z + w*w = M*M (where M is the magnitude of the vector)
+    /// If w was the largest value and the quaternion is normalized:
+    /// M = 1.0f (which M * M would still yield 1.0f)
+    /// w*w = M*M - (x*x + y*y + z*z) or Mathf.Sqrt(1.0f - (x*x + y*y + z*z))
+    /// w = Math.Sqrt(1.0f - (x*x + y*y + z*z))
+    /// Using the largest the number avoids potential loss of precision in the smallest three values.
+    /// </remarks>
+    public static class QuaternionCompressor
+    {
+        private const ushort k_PrecisionMask = (1 << 9) - 1;
+
+        // Square root of 2 over 2 (Mathf.Sqrt(2.0f) / 2.0f == 1.0f / Mathf.Sqrt(2.0f))
+        // This provides encoding the smallest three components into a (+/-) Mathf.Sqrt(2.0f) / 2.0f range
+        private const float k_SqrtTwoOverTwoEncoding = 0.70710678118654752440084436210485f;
+
+        // We can further improve the encoding compression by dividing k_SqrtTwoOverTwo into 1.0f and multiplying that
+        // by the precision mask (minor reduction of runtime calculations)
+        private const float k_CompressionEcodingMask = (1.0f / k_SqrtTwoOverTwoEncoding) * k_PrecisionMask;
+
+        // Used to shift the negative bit to the 10th bit position when compressing and encoding
+        private const ushort k_ShiftNegativeBit = 9;
+
+        // We can do the same for our decoding and decompression by dividing k_PrecisionMask into 1.0 and multiplying
+        // that by k_SqrtTwoOverTwo (minor reduction of runtime calculations)
+        private const float k_DcompressionDecodingMask = (1.0f / k_PrecisionMask) * k_SqrtTwoOverTwoEncoding;
+
+        // The sign bit position (10th bit) used when decompressing and decoding
+        private const ushort k_NegShortBit = 0x200;
+
+        // Negative bit set values
+        private const ushort k_True = 1;
+        private const ushort k_False = 0;
+
+        // Used to store the absolute value of the 4 quaternion elements
+        private static Quaternion s_QuatAbsValues = Quaternion.identity;
+
+        /// <summary>
+        /// Compresses a Quaternion into an unsigned integer
+        /// </summary>
+        /// <param name="quaternion">the <see cref="Quaternion"/> to be compressed</param>
+        /// <returns>the <see cref="Quaternion"/> compressed as an unsigned integer</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint CompressQuaternion(ref Quaternion quaternion)
+        {
+            // Store off the absolute value for each Quaternion element
+            s_QuatAbsValues[0] = Mathf.Abs(quaternion[0]);
+            s_QuatAbsValues[1] = Mathf.Abs(quaternion[1]);
+            s_QuatAbsValues[2] = Mathf.Abs(quaternion[2]);
+            s_QuatAbsValues[3] = Mathf.Abs(quaternion[3]);
+
+            // Get the largest element value of the quaternion to know what the remaining "Smallest Three" values are
+            var quatMax = Mathf.Max(s_QuatAbsValues[0], s_QuatAbsValues[1], s_QuatAbsValues[2], s_QuatAbsValues[3]);
+
+            // Find the index of the largest element so we can skip that element while compressing and decompressing
+            var indexToSkip = (ushort)(s_QuatAbsValues[0] == quatMax ? 0 : s_QuatAbsValues[1] == quatMax ? 1 : s_QuatAbsValues[2] == quatMax ? 2 : 3);
+
+            // Get the sign of the largest element which is all that is needed when calculating the sum of squares of a normalized quaternion.
+
+            var quatMaxSign = (quaternion[indexToSkip] < 0 ? k_True : k_False);
+
+            // Start with the index to skip which will be shifted to the highest two bits
+            var compressed = (uint)indexToSkip;
+
+            // Step 1: Start with the first element
+            var currentIndex = 0;
+
+            // Step 2: If we are on the index to skip preserve the current compressed value, otherwise proceed to step 3 and 4
+            // Step 3: Get the sign of the element we are processing. If it is the not the same as the largest value's sign bit then we set the bit
+            // Step 4: Get the compressed and encoded value by multiplying the absolute value of the current element by k_CompressionEcodingMask and round that result up
+            compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+            currentIndex++;
+            // Repeat the last 3 steps for the remaining elements
+            compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+            currentIndex++;
+            compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+            currentIndex++;
+            compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+
+            // Return the compress quaternion
+            return compressed;
+        }
+
+        /// <summary>
+        /// Decompress a compressed quaternion
+        /// </summary>
+        /// <param name="quaternion">quaternion to store the decompressed values within</param>
+        /// <param name="compressed">the compressed quaternion</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void DecompressQuaternion(ref Quaternion quaternion, uint compressed)
+        {
+            // Get the last two bits for the index to skip (0-3)
+            var indexToSkip = (int)(compressed >> 30);
+
+            // Reverse out the values while skipping over the largest value index
+            var sumOfSquaredMagnitudes = 0.0f;
+            for (int i = 3; i >= 0; --i)
+            {
+                if (i == indexToSkip)
+                {
+                    continue;
+                }
+                // Check the negative bit and multiply that result with the decompressed and decoded value
+                quaternion[i] = ((compressed & k_NegShortBit) > 0 ? -1.0f : 1.0f) * ((compressed & k_PrecisionMask) * k_DcompressionDecodingMask);
+                sumOfSquaredMagnitudes += quaternion[i] * quaternion[i];
+                compressed = compressed >> 10;
+            }
+            // Since a normalized quaternion's magnitude is 1.0f, we subtract the sum of the squared smallest three from the unit value and take
+            // the square root of the difference to find the final largest value
+            quaternion[indexToSkip] = Mathf.Sqrt(1.0f - sumOfSquaredMagnitudes);
+        }
+    }
+}

Components/QuaternionCompressor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bb9d8b98d3c8bca469c8ee152353336f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Components/com.unity.netcode.components.asmdef

@@ -3,15 +3,25 @@
     "rootNamespace": "Unity.Netcode.Components",
     "references": [
         "Unity.Netcode.Runtime",
-        "Unity.Collections"
+        "Unity.Collections",
+        "Unity.Mathematics"
     ],
-    "includePlatforms": [],
-    "excludePlatforms": [],
     "allowUnsafeCode": true,
-    "overrideReferences": false,
-    "precompiledReferences": [],
-    "autoReferenced": true,
-    "defineConstraints": [],
-    "versionDefines": [],
-    "noEngineReferences": false
+    "versionDefines": [
+        {
+            "name": "com.unity.modules.animation",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_ANIMATION"
+        },
+        {
+            "name": "com.unity.modules.physics",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_PHYSICS"
+        },
+        {
+            "name": "com.unity.modules.physics2d",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_PHYSICS2D"
+        }
+    ]
 }

Documentation~/Index.md

@@ -1,31 +0,0 @@
-# About Netcode for GameObjects
-
-Unity Netcode for GameObjects is a high-level networking library built to abstract networking. This allows developers to focus on the game rather than low level protocols and networking frameworks. 
-
-## Guides
-
-See guides below to install Unity Netcode for GameObjects, set up your project, and get started with your first networked game:
-
-* [Documentation](https://docs-multiplayer.unity3d.com/docs/getting-started/about-mlapi)
-* [Installation](https://docs-multiplayer.unity3d.com/docs/migration/install)
-* [First Steps](https://docs-multiplayer.unity3d.com/docs/tutorials/helloworld/helloworldintro)
-* [API Reference](https://docs-multiplayer.unity3d.com/docs/mlapi-api/introduction)
-
-# Technical details
-
-## Requirements
-
-This version of Netcode for GameObjects is compatible with the following Unity versions and platforms:
-
-* 2020.3 and later
-* Windows, Mac, Linux platforms
-
-## Document revision history
-
-|Date|Reason|
-|---|---|
-|March 10, 2021|Document created. Matches package version 0.1.0|
-|June 1, 2021|Update and add links for additional content. Matches patch version 0.1.0 and hotfixes.|
-|June 3, 2021|Update document to acknowledge Unity min version change. Matches package version 0.2.0|
-|August 5, 2021|Update product/package name|
-|September 9,2021|Updated the links and name of the file.|

Documentation~/index.md

@@ -0,0 +1,35 @@
+# About Netcode for GameObjects
+
+Netcode for GameObjects is a Unity package that provides networking capabilities to GameObject & MonoBehaviour workflows.
+
+## Guides
+
+See guides below to install Unity Netcode for GameObjects, set up your project, and get started with your first networked game:
+
+- [Documentation](https://docs-multiplayer.unity3d.com/netcode/current/about)
+- [Installation](https://docs-multiplayer.unity3d.com/netcode/current/installation)
+- [First Steps](https://docs-multiplayer.unity3d.com/netcode/current/tutorials/get-started-ngo)
+- [API Reference](https://docs.unity3d.com/Packages/com.unity.netcode.gameobjects@1.6/api/index.html)
+
+# Technical details
+
+## Requirements
+
+Netcode for GameObjects targets the following Unity versions:
+- Unity 2021.3 (LTS), 2022.3 (LTS) and 2023.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.
+
+## Document revision history
+
+|Date|Reason|
+|---|---|
+|March 10, 2021|Document created. Matches package version 0.1.0|
+|June 1, 2021|Update and add links for additional content. Matches patch version 0.1.0 and hotfixes.|
+|June 3, 2021|Update document to acknowledge Unity min version change. Matches package version 0.2.0|
+|August 5, 2021|Update product/package name|
+|September 9,2021|Updated the links and name of the file.|
+|April 20, 2022|Updated links|

Editor/AnticipatedNetworkTransformEditor.cs

@@ -0,0 +1,14 @@
+using Unity.Netcode.Components;
+using UnityEditor;
+
+namespace Unity.Netcode.Editor
+{
+    /// <summary>
+    /// The <see cref="CustomEditor"/> for <see cref="AnticipatedNetworkTransform"/>
+    /// </summary>
+    [CustomEditor(typeof(AnticipatedNetworkTransform), true)]
+    public class AnticipatedNetworkTransformEditor : NetworkTransformEditor
+    {
+        public override bool HideInterpolateValue => true;
+    }
+}

Editor/AnticipatedNetworkTransformEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 34bc168605014eeeadf97b12080e11fa
+timeCreated: 1707514321

Editor/AssemblyInfo.cs

@@ -1,3 +1,7 @@
 using System.Runtime.CompilerServices;
 
+#if UNITY_INCLUDE_TESTS
+#if UNITY_EDITOR
 [assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")]
+#endif // UNITY_EDITOR
+#endif // UNITY_INCLUDE_TESTS

Editor/CodeGen/CodeGenHelpers.cs

@@ -6,23 +6,38 @@ using System.Text;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using Mono.Cecil.Rocks;
+using Unity.Collections;
 using Unity.CompilationPipeline.Common.Diagnostics;
 using Unity.CompilationPipeline.Common.ILPostProcessing;
 using UnityEngine;
+using Object = System.Object;
 
 namespace Unity.Netcode.Editor.CodeGen
 {
     internal static class CodeGenHelpers
     {
+        public const string DotnetModuleName = "netstandard.dll";
+        public const string UnityModuleName = "UnityEngine.CoreModule.dll";
+        public const string NetcodeModuleName = "Unity.Netcode.Runtime.dll";
+
         public const string RuntimeAssemblyName = "Unity.Netcode.Runtime";
+        public const string ComponentsAssemblyName = "Unity.Netcode.Components";
 
         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 RpcAttribute_FullName = typeof(RpcAttribute).FullName;
         public static readonly string ServerRpcParams_FullName = typeof(ServerRpcParams).FullName;
         public static readonly string ClientRpcParams_FullName = typeof(ClientRpcParams).FullName;
+        public static readonly string RpcParams_FullName = typeof(RpcParams).FullName;
+        public static readonly string ClientRpcSendParams_FullName = typeof(ClientRpcSendParams).FullName;
+        public static readonly string ClientRpcReceiveParams_FullName = typeof(ClientRpcReceiveParams).FullName;
+        public static readonly string ServerRpcSendParams_FullName = typeof(ServerRpcSendParams).FullName;
+        public static readonly string ServerRpcReceiveParams_FullName = typeof(ServerRpcReceiveParams).FullName;
         public static readonly string INetworkSerializable_FullName = typeof(INetworkSerializable).FullName;
+        public static readonly string INetworkSerializeByMemcpy_FullName = typeof(INetworkSerializeByMemcpy).FullName;
+        public static readonly string IUTF8Bytes_FullName = typeof(IUTF8Bytes).FullName;
         public static readonly string UnityColor_FullName = typeof(Color).FullName;
         public static readonly string UnityColor32_FullName = typeof(Color32).FullName;
         public static readonly string UnityVector2_FullName = typeof(Vector2).FullName;
@@ -47,7 +62,7 @@ namespace Unity.Netcode.Editor.CodeGen
 
         public static bool IsSubclassOf(this TypeDefinition typeDefinition, string classTypeFullName)
         {
-            if (!typeDefinition.IsClass)
+            if (typeDefinition == null || !typeDefinition.IsClass)
             {
                 return false;
             }
@@ -73,6 +88,93 @@ namespace Unity.Netcode.Editor.CodeGen
             return false;
         }
 
+        public static string FullNameWithGenericParameters(this TypeReference typeReference, GenericParameter[] contextGenericParameters, TypeReference[] contextGenericParameterTypes)
+        {
+            var name = typeReference.FullName;
+            if (typeReference.HasGenericParameters)
+            {
+                name += "<";
+                for (var i = 0; i < typeReference.Resolve().GenericParameters.Count; ++i)
+                {
+                    if (i != 0)
+                    {
+                        name += ", ";
+                    }
+
+                    for (var j = 0; j < contextGenericParameters.Length; ++j)
+                    {
+                        if (typeReference.GenericParameters[i].FullName == contextGenericParameters[i].FullName)
+                        {
+                            name += contextGenericParameterTypes[i].FullName;
+                            break;
+                        }
+                    }
+                }
+
+                name += ">";
+            }
+
+            return name;
+        }
+        public static TypeReference MakeGenericType(this TypeReference self, params TypeReference[] arguments)
+        {
+            if (self.GenericParameters.Count != arguments.Length)
+            {
+                throw new ArgumentException();
+            }
+
+            var instance = new GenericInstanceType(self);
+            foreach (var argument in arguments)
+            {
+                instance.GenericArguments.Add(argument);
+            }
+
+            return instance;
+        }
+
+        public static MethodReference MakeGeneric(this MethodReference self, params TypeReference[] arguments)
+        {
+            var reference = new MethodReference(self.Name, self.ReturnType)
+            {
+                DeclaringType = self.DeclaringType.MakeGenericType(arguments),
+                HasThis = self.HasThis,
+                ExplicitThis = self.ExplicitThis,
+                CallingConvention = self.CallingConvention,
+            };
+
+            foreach (var parameter in self.Parameters)
+            {
+                reference.Parameters.Add(new ParameterDefinition(parameter.ParameterType));
+            }
+
+            foreach (var generic_parameter in self.GenericParameters)
+            {
+                reference.GenericParameters.Add(new GenericParameter(generic_parameter.Name, reference));
+            }
+
+            return reference;
+        }
+
+        public static bool IsSubclassOf(this TypeReference typeReference, TypeReference baseClass)
+        {
+            if (typeReference == null)
+            {
+                return false;
+            }
+            var type = typeReference.Resolve();
+            if (type?.BaseType == null || type.BaseType.Name == nameof(Object))
+            {
+                return false;
+            }
+
+            if (type.BaseType.Resolve() == baseClass.Resolve())
+            {
+                return true;
+            }
+
+            return type.BaseType.IsSubclassOf(baseClass);
+        }
+
         public static bool HasInterface(this TypeReference typeReference, string interfaceTypeFullName)
         {
             if (typeReference.IsArray)
@@ -83,6 +185,19 @@ namespace Unity.Netcode.Editor.CodeGen
             try
             {
                 var typeDef = typeReference.Resolve();
+                // Note: this won't catch generics correctly.
+                //
+                //     class Foo<T>: IInterface<T> {}
+                //     class Bar: Foo<int> {}
+                //
+                // Bar.HasInterface(IInterface<int>) -> returns false even though it should be true.
+                //
+                // This can be fixed (see GetAllFieldsAndResolveGenerics() in NetworkBehaviourILPP to understand how)
+                // but right now we don't need that to work so it's left alone to reduce complexity
+                if (typeDef.BaseType.HasInterface(interfaceTypeFullName))
+                {
+                    return true;
+                }
                 var typeFaces = typeDef.Interfaces;
                 return typeFaces.Any(iface => iface.InterfaceType.FullName == interfaceTypeFullName);
             }
@@ -344,5 +459,74 @@ namespace Unity.Netcode.Editor.CodeGen
 
             return assemblyDefinition;
         }
+
+        private static void SearchForBaseModulesRecursive(AssemblyDefinition assemblyDefinition, PostProcessorAssemblyResolver assemblyResolver, ref ModuleDefinition unityModule, ref ModuleDefinition netcodeModule, HashSet<string> visited)
+        {
+
+            foreach (var module in assemblyDefinition.Modules)
+            {
+                if (module == null)
+                {
+                    continue;
+                }
+
+                if (unityModule != null && netcodeModule != null)
+                {
+                    return;
+                }
+
+                if (unityModule == null && module.Name == UnityModuleName)
+                {
+                    unityModule = module;
+                    continue;
+                }
+
+                if (netcodeModule == null && module.Name == NetcodeModuleName)
+                {
+                    netcodeModule = module;
+                    continue;
+                }
+            }
+            if (unityModule != null && netcodeModule != null)
+            {
+                return;
+            }
+
+            foreach (var assemblyNameReference in assemblyDefinition.MainModule.AssemblyReferences)
+            {
+                if (assemblyNameReference == null)
+                {
+                    continue;
+                }
+                if (visited.Contains(assemblyNameReference.Name))
+                {
+                    continue;
+                }
+
+                visited.Add(assemblyNameReference.Name);
+
+                var assembly = assemblyResolver.Resolve(assemblyNameReference);
+                if (assembly == null)
+                {
+                    continue;
+                }
+                SearchForBaseModulesRecursive(assembly, assemblyResolver, ref unityModule, ref netcodeModule, visited);
+
+                if (unityModule != null && netcodeModule != null)
+                {
+                    return;
+                }
+            }
+        }
+
+        public static (ModuleDefinition UnityModule, ModuleDefinition NetcodeModule) FindBaseModules(AssemblyDefinition assemblyDefinition, PostProcessorAssemblyResolver assemblyResolver)
+        {
+            ModuleDefinition unityModule = null;
+            ModuleDefinition netcodeModule = null;
+            var visited = new HashSet<string>();
+            SearchForBaseModulesRecursive(assemblyDefinition, assemblyResolver, ref unityModule, ref netcodeModule, visited);
+
+            return (unityModule, netcodeModule);
+        }
     }
 }

Editor/CodeGen/INetworkMessageILPP.cs

@@ -1,26 +1,23 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Collections.Generic;
-using System.Reflection;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using Mono.Cecil.Rocks;
 using Unity.CompilationPipeline.Common.Diagnostics;
 using Unity.CompilationPipeline.Common.ILPostProcessing;
+using UnityEngine;
 using ILPPInterface = Unity.CompilationPipeline.Common.ILPostProcessing.ILPostProcessor;
 using MethodAttributes = Mono.Cecil.MethodAttributes;
 
 namespace Unity.Netcode.Editor.CodeGen
 {
-
     internal sealed class INetworkMessageILPP : ILPPInterface
     {
         public override ILPPInterface GetInstance() => this;
 
-        public override bool WillProcess(ICompiledAssembly compiledAssembly) =>
-            compiledAssembly.Name == CodeGenHelpers.RuntimeAssemblyName ||
-            compiledAssembly.References.Any(filePath => Path.GetFileNameWithoutExtension(filePath) == CodeGenHelpers.RuntimeAssemblyName);
+        public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.Name == CodeGenHelpers.RuntimeAssemblyName || compiledAssembly.Name == CodeGenHelpers.ComponentsAssemblyName;
 
         private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>();
 
@@ -31,17 +28,25 @@ namespace Unity.Netcode.Editor.CodeGen
                 return null;
             }
 
-
             m_Diagnostics.Clear();
 
             // read
-            var assemblyDefinition = CodeGenHelpers.AssemblyDefinitionFor(compiledAssembly, out var resolver);
+            var assemblyDefinition = CodeGenHelpers.AssemblyDefinitionFor(compiledAssembly, out m_AssemblyResolver);
             if (assemblyDefinition == null)
             {
                 m_Diagnostics.AddError($"Cannot read assembly definition: {compiledAssembly.Name}");
                 return null;
             }
 
+            // modules
+            (_, m_NetcodeModule) = CodeGenHelpers.FindBaseModules(assemblyDefinition, m_AssemblyResolver);
+
+            if (m_NetcodeModule == null)
+            {
+                m_Diagnostics.AddError($"Cannot find Netcode module: {CodeGenHelpers.NetcodeModuleName}");
+                return null;
+            }
+
             // process
             var mainModule = assemblyDefinition.MainModule;
             if (mainModule != null)
@@ -63,7 +68,7 @@ namespace Unity.Netcode.Editor.CodeGen
                     }
                     catch (Exception e)
                     {
-                        m_Diagnostics.AddError((e.ToString() + e.StackTrace.ToString()).Replace("\n", "|").Replace("\r", "|"));
+                        m_Diagnostics.AddError((e.ToString() + e.StackTrace).Replace("\n", "|").Replace("\r", "|"));
                     }
                 }
                 else
@@ -94,188 +99,213 @@ namespace Unity.Netcode.Editor.CodeGen
             return new ILPostProcessResult(new InMemoryAssembly(pe.ToArray(), pdb.ToArray()), m_Diagnostics);
         }
 
+        private ModuleDefinition m_NetcodeModule;
+        private PostProcessorAssemblyResolver m_AssemblyResolver;
 
-        private TypeReference m_FastBufferReader_TypeRef;
-        private TypeReference m_NetworkContext_TypeRef;
-        private TypeReference m_MessagingSystem_MessageWithHandler_TypeRef;
-        private MethodReference m_MessagingSystem_MessageHandler_Constructor_TypeRef;
+        private MethodReference m_RuntimeInitializeOnLoadAttribute_Ctor;
+
+        private MethodReference m_MessageManager_ReceiveMessage_MethodRef;
+        private MethodReference m_MessageManager_CreateMessageAndGetVersion_MethodRef;
+        private TypeReference m_MessageManager_MessageWithHandler_TypeRef;
+        private MethodReference m_MessageManager_MessageHandler_Constructor_TypeRef;
+        private MethodReference m_MessageManager_VersionGetter_Constructor_TypeRef;
         private FieldReference m_ILPPMessageProvider___network_message_types_FieldRef;
-        private FieldReference m_MessagingSystem_MessageWithHandler_MessageType_FieldRef;
-        private FieldReference m_MessagingSystem_MessageWithHandler_Handler_FieldRef;
+        private FieldReference m_MessageManager_MessageWithHandler_MessageType_FieldRef;
+        private FieldReference m_MessageManager_MessageWithHandler_Handler_FieldRef;
+        private FieldReference m_MessageManager_MessageWithHandler_GetVersion_FieldRef;
         private MethodReference m_Type_GetTypeFromHandle_MethodRef;
-
         private MethodReference m_List_Add_MethodRef;
 
+        private const string k_ReceiveMessageName = nameof(NetworkMessageManager.ReceiveMessage);
+        private const string k_CreateMessageAndGetVersionName = nameof(NetworkMessageManager.CreateMessageAndGetVersion);
+
         private bool ImportReferences(ModuleDefinition moduleDefinition)
         {
-            m_FastBufferReader_TypeRef = moduleDefinition.ImportReference(typeof(FastBufferReader));
-            m_NetworkContext_TypeRef = moduleDefinition.ImportReference(typeof(NetworkContext));
-            m_MessagingSystem_MessageHandler_Constructor_TypeRef =
-                moduleDefinition.ImportReference(typeof(MessagingSystem.MessageHandler).GetConstructors()[0]);
+            // Different environments seem to have different situations...
+            // Some have these definitions in netstandard.dll, some seem to have them elsewhere...
+            // Since they're standard .net classes they're not going to cause the same issues as referencing other assemblies,
+            // in theory, since the definitions should be standard and consistent across platforms
+            // (i.e., there's no #if UNITY_EDITOR in them that could create invalid IL code)
+            TypeDefinition typeTypeDef = moduleDefinition.ImportReference(typeof(Type)).Resolve();
+            TypeDefinition listTypeDef = moduleDefinition.ImportReference(typeof(List<>)).Resolve();
+            m_RuntimeInitializeOnLoadAttribute_Ctor = moduleDefinition.ImportReference(typeof(RuntimeInitializeOnLoadMethodAttribute).GetConstructor(new Type[] { }));
 
-            var messageWithHandlerType = typeof(MessagingSystem.MessageWithHandler);
-            m_MessagingSystem_MessageWithHandler_TypeRef =
-                moduleDefinition.ImportReference(messageWithHandlerType);
-            foreach (var fieldInfo in messageWithHandlerType.GetFields())
+            TypeDefinition messageHandlerTypeDef = null;
+            TypeDefinition versionGetterTypeDef = null;
+            TypeDefinition messageWithHandlerTypeDef = null;
+            TypeDefinition ilppMessageProviderTypeDef = null;
+            TypeDefinition messageManagerSystemTypeDef = null;
+            foreach (var netcodeTypeDef in m_NetcodeModule.GetAllTypes())
             {
-                switch (fieldInfo.Name)
+                if (messageHandlerTypeDef == null && netcodeTypeDef.Name == nameof(NetworkMessageManager.MessageHandler))
                 {
-                    case nameof(MessagingSystem.MessageWithHandler.MessageType):
-                        m_MessagingSystem_MessageWithHandler_MessageType_FieldRef = moduleDefinition.ImportReference(fieldInfo);
+                    messageHandlerTypeDef = netcodeTypeDef;
+                    continue;
+                }
+
+                if (versionGetterTypeDef == null && netcodeTypeDef.Name == nameof(NetworkMessageManager.VersionGetter))
+                {
+                    versionGetterTypeDef = netcodeTypeDef;
+                    continue;
+                }
+
+                if (messageWithHandlerTypeDef == null && netcodeTypeDef.Name == nameof(NetworkMessageManager.MessageWithHandler))
+                {
+                    messageWithHandlerTypeDef = netcodeTypeDef;
+                    continue;
+                }
+
+                if (ilppMessageProviderTypeDef == null && netcodeTypeDef.Name == nameof(ILPPMessageProvider))
+                {
+                    ilppMessageProviderTypeDef = netcodeTypeDef;
+                    continue;
+                }
+
+                if (messageManagerSystemTypeDef == null && netcodeTypeDef.Name == nameof(NetworkMessageManager))
+                {
+                    messageManagerSystemTypeDef = netcodeTypeDef;
+                    continue;
+                }
+            }
+
+            m_MessageManager_MessageHandler_Constructor_TypeRef = moduleDefinition.ImportReference(messageHandlerTypeDef.GetConstructors().First());
+            m_MessageManager_VersionGetter_Constructor_TypeRef = moduleDefinition.ImportReference(versionGetterTypeDef.GetConstructors().First());
+
+            m_MessageManager_MessageWithHandler_TypeRef = moduleDefinition.ImportReference(messageWithHandlerTypeDef);
+            foreach (var fieldDef in messageWithHandlerTypeDef.Fields)
+            {
+                switch (fieldDef.Name)
+                {
+                    case nameof(NetworkMessageManager.MessageWithHandler.MessageType):
+                        m_MessageManager_MessageWithHandler_MessageType_FieldRef = moduleDefinition.ImportReference(fieldDef);
                         break;
-                    case nameof(MessagingSystem.MessageWithHandler.Handler):
-                        m_MessagingSystem_MessageWithHandler_Handler_FieldRef = moduleDefinition.ImportReference(fieldInfo);
+                    case nameof(NetworkMessageManager.MessageWithHandler.Handler):
+                        m_MessageManager_MessageWithHandler_Handler_FieldRef = moduleDefinition.ImportReference(fieldDef);
+                        break;
+                    case nameof(NetworkMessageManager.MessageWithHandler.GetVersion):
+                        m_MessageManager_MessageWithHandler_GetVersion_FieldRef = moduleDefinition.ImportReference(fieldDef);
                         break;
                 }
             }
 
-            var typeType = typeof(Type);
-            foreach (var methodInfo in typeType.GetMethods())
+            foreach (var methodDef in typeTypeDef.Methods)
             {
-                switch (methodInfo.Name)
+                switch (methodDef.Name)
                 {
                     case nameof(Type.GetTypeFromHandle):
-                        m_Type_GetTypeFromHandle_MethodRef = moduleDefinition.ImportReference(methodInfo);
+                        m_Type_GetTypeFromHandle_MethodRef = moduleDefinition.ImportReference(methodDef);
                         break;
                 }
             }
 
-            var ilppMessageProviderType = typeof(ILPPMessageProvider);
-            foreach (var fieldInfo in ilppMessageProviderType.GetFields(BindingFlags.Static | BindingFlags.NonPublic))
+            foreach (var fieldDef in ilppMessageProviderTypeDef.Fields)
             {
-                switch (fieldInfo.Name)
+                switch (fieldDef.Name)
                 {
                     case nameof(ILPPMessageProvider.__network_message_types):
-                        m_ILPPMessageProvider___network_message_types_FieldRef = moduleDefinition.ImportReference(fieldInfo);
+                        m_ILPPMessageProvider___network_message_types_FieldRef = moduleDefinition.ImportReference(fieldDef);
                         break;
                 }
             }
 
-            var listType = typeof(List<MessagingSystem.MessageWithHandler>);
-            foreach (var methodInfo in listType.GetMethods())
+            foreach (var methodDef in listTypeDef.Methods)
             {
-                switch (methodInfo.Name)
+                switch (methodDef.Name)
                 {
-                    case nameof(List<MessagingSystem.MessageWithHandler>.Add):
-                        m_List_Add_MethodRef = moduleDefinition.ImportReference(methodInfo);
+                    case "Add":
+                        m_List_Add_MethodRef = methodDef;
+                        m_List_Add_MethodRef.DeclaringType = listTypeDef.MakeGenericInstanceType(messageWithHandlerTypeDef);
+                        m_List_Add_MethodRef = moduleDefinition.ImportReference(m_List_Add_MethodRef);
                         break;
                 }
             }
 
+            foreach (var methodDef in messageManagerSystemTypeDef.Methods)
+            {
+                switch (methodDef.Name)
+                {
+                    case k_ReceiveMessageName:
+                        m_MessageManager_ReceiveMessage_MethodRef = moduleDefinition.ImportReference(methodDef);
+                        break;
+                    case k_CreateMessageAndGetVersionName:
+                        m_MessageManager_CreateMessageAndGetVersion_MethodRef = moduleDefinition.ImportReference(methodDef);
+                        break;
+                }
+            }
 
             return true;
         }
 
-        private MethodReference GetNetworkMessageRecieveHandler(TypeDefinition typeDefinition)
+        private void CreateInstructionsToRegisterType(ILProcessor processor, List<Instruction> instructions, TypeReference type, MethodReference receiveMethod, MethodReference versionMethod)
         {
-            SequencePoint typeSequence = null;
-            foreach (var method in typeDefinition.Methods)
-            {
-                var resolved = method.Resolve();
-                var methodSequence = resolved.DebugInformation.SequencePoints.FirstOrDefault();
-                if (typeSequence == null || methodSequence.StartLine < typeSequence.StartLine)
-                {
-                    typeSequence = methodSequence;
-                }
-
-                if (resolved.IsStatic && resolved.IsPublic && resolved.Name == "Receive" && resolved.Parameters.Count == 2
-                    && !resolved.Parameters[0].IsIn
-                    && !resolved.Parameters[0].ParameterType.IsByReference
-                    && resolved.Parameters[0].ParameterType.Resolve() ==
-                        m_FastBufferReader_TypeRef.Resolve()
-                    && resolved.Parameters[1].IsIn
-                    && resolved.Parameters[1].ParameterType.IsByReference
-                    && resolved.Parameters[1].ParameterType.GetElementType().Resolve() == m_NetworkContext_TypeRef.Resolve()
-                    && resolved.ReturnType == resolved.Module.TypeSystem.Void)
-                {
-                    return method;
-                }
-            }
-
-            m_Diagnostics.AddError(typeSequence, $"Class {typeDefinition.FullName} does not implement required method: `public static void Receive(FastBufferReader, in NetworkContext)`");
-            return null;
-        }
-
-        private MethodDefinition GetOrCreateStaticConstructor(TypeDefinition typeDefinition)
-        {
-            var staticCtorMethodDef = typeDefinition.GetStaticConstructor();
-            if (staticCtorMethodDef == null)
-            {
-                staticCtorMethodDef = new MethodDefinition(
-                    ".cctor", // Static Constructor (constant-constructor)
-                    MethodAttributes.HideBySig |
-                    MethodAttributes.SpecialName |
-                    MethodAttributes.RTSpecialName |
-                    MethodAttributes.Static,
-                    typeDefinition.Module.TypeSystem.Void);
-                staticCtorMethodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
-                typeDefinition.Methods.Add(staticCtorMethodDef);
-            }
-
-            return staticCtorMethodDef;
-        }
-
-        private void CreateInstructionsToRegisterType(ILProcessor processor, List<Instruction> instructions, TypeReference type, MethodReference receiveMethod)
-        {
-            // MessagingSystem.__network_message_types.Add(new MessagingSystem.MessageWithHandler{MessageType=typeof(type), Handler=type.Receive});
-            processor.Body.Variables.Add(new VariableDefinition(m_MessagingSystem_MessageWithHandler_TypeRef));
+            // NetworkMessageManager.__network_message_types.Add(new NetworkMessageManager.MessageWithHandler{MessageType=typeof(type), Handler=type.Receive});
+            processor.Body.Variables.Add(new VariableDefinition(m_MessageManager_MessageWithHandler_TypeRef));
             int messageWithHandlerLocIdx = processor.Body.Variables.Count - 1;
 
             instructions.Add(processor.Create(OpCodes.Ldsfld, m_ILPPMessageProvider___network_message_types_FieldRef));
             instructions.Add(processor.Create(OpCodes.Ldloca, messageWithHandlerLocIdx));
-            instructions.Add(processor.Create(OpCodes.Initobj, m_MessagingSystem_MessageWithHandler_TypeRef));
+            instructions.Add(processor.Create(OpCodes.Initobj, m_MessageManager_MessageWithHandler_TypeRef));
 
             // tmp.MessageType = typeof(type);
             instructions.Add(processor.Create(OpCodes.Ldloca, messageWithHandlerLocIdx));
             instructions.Add(processor.Create(OpCodes.Ldtoken, type));
             instructions.Add(processor.Create(OpCodes.Call, m_Type_GetTypeFromHandle_MethodRef));
-            instructions.Add(processor.Create(OpCodes.Stfld, m_MessagingSystem_MessageWithHandler_MessageType_FieldRef));
+            instructions.Add(processor.Create(OpCodes.Stfld, m_MessageManager_MessageWithHandler_MessageType_FieldRef));
 
-            // tmp.Handler = type.Receive
+            // tmp.Handler = MessageHandler.ReceveMessage<type>
             instructions.Add(processor.Create(OpCodes.Ldloca, messageWithHandlerLocIdx));
             instructions.Add(processor.Create(OpCodes.Ldnull));
 
             instructions.Add(processor.Create(OpCodes.Ldftn, receiveMethod));
-            instructions.Add(processor.Create(OpCodes.Newobj, m_MessagingSystem_MessageHandler_Constructor_TypeRef));
-            instructions.Add(processor.Create(OpCodes.Stfld, m_MessagingSystem_MessageWithHandler_Handler_FieldRef));
+            instructions.Add(processor.Create(OpCodes.Newobj, m_MessageManager_MessageHandler_Constructor_TypeRef));
+            instructions.Add(processor.Create(OpCodes.Stfld, m_MessageManager_MessageWithHandler_Handler_FieldRef));
+
+
+            // tmp.GetVersion = MessageHandler.CreateMessageAndGetVersion<type>
+            instructions.Add(processor.Create(OpCodes.Ldloca, messageWithHandlerLocIdx));
+            instructions.Add(processor.Create(OpCodes.Ldnull));
+
+            instructions.Add(processor.Create(OpCodes.Ldftn, versionMethod));
+            instructions.Add(processor.Create(OpCodes.Newobj, m_MessageManager_VersionGetter_Constructor_TypeRef));
+            instructions.Add(processor.Create(OpCodes.Stfld, m_MessageManager_MessageWithHandler_GetVersion_FieldRef));
 
             // ILPPMessageProvider.__network_message_types.Add(tmp);
             instructions.Add(processor.Create(OpCodes.Ldloc, messageWithHandlerLocIdx));
             instructions.Add(processor.Create(OpCodes.Callvirt, m_List_Add_MethodRef));
         }
 
-        // Creates a static module constructor (which is executed when the module is loaded) that registers all the
-        // message types in the assembly with MessagingSystem.
-        // This is the same behavior as annotating a static method with [ModuleInitializer] in standardized
-        // C# (that attribute doesn't exist in Unity, but the static module constructor still works)
+        // Creates a static module constructor (which is executed when the module is loaded) that registers all the message types in the assembly with NetworkMessageManager.
+        // This is the same behavior as annotating a static method with [ModuleInitializer] in standardized C# (that attribute doesn't exist in Unity, but the static module constructor still works).
         // https://docs.microsoft.com/en-us/dotnet/api/system.runtime.compilerservices.moduleinitializerattribute?view=net-5.0
         // https://web.archive.org/web/20100212140402/http://blogs.msdn.com/junfeng/archive/2005/11/19/494914.aspx
         private void CreateModuleInitializer(AssemblyDefinition assembly, List<TypeDefinition> networkMessageTypes)
         {
-            foreach (var typeDefinition in assembly.MainModule.Types)
+            var typeDefinition = new TypeDefinition("__GEN", "INetworkMessageHelper", TypeAttributes.NotPublic | TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit, assembly.MainModule.TypeSystem.Object);
+
+            var staticCtorMethodDef = new MethodDefinition(
+                $"InitializeMessages",
+                MethodAttributes.Assembly |
+                MethodAttributes.Static,
+                assembly.MainModule.TypeSystem.Void);
+            staticCtorMethodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
+            staticCtorMethodDef.CustomAttributes.Add(new CustomAttribute(m_RuntimeInitializeOnLoadAttribute_Ctor));
+            typeDefinition.Methods.Add(staticCtorMethodDef);
+
+            var instructions = new List<Instruction>();
+            var processor = staticCtorMethodDef.Body.GetILProcessor();
+
+            foreach (var type in networkMessageTypes)
             {
-                if (typeDefinition.FullName == "<Module>")
-                {
-                    var staticCtorMethodDef = GetOrCreateStaticConstructor(typeDefinition);
-
-                    var processor = staticCtorMethodDef.Body.GetILProcessor();
-
-                    var instructions = new List<Instruction>();
-
-                    foreach (var type in networkMessageTypes)
-                    {
-                        var receiveMethod = GetNetworkMessageRecieveHandler(type);
-                        if (receiveMethod == null)
-                        {
-                            continue;
-                        }
-                        CreateInstructionsToRegisterType(processor, instructions, type, receiveMethod);
-                    }
-
-                    instructions.ForEach(instruction => processor.Body.Instructions.Insert(processor.Body.Instructions.Count - 1, instruction));
-                    break;
-                }
+                var receiveMethod = new GenericInstanceMethod(m_MessageManager_ReceiveMessage_MethodRef);
+                receiveMethod.GenericArguments.Add(type);
+                var versionMethod = new GenericInstanceMethod(m_MessageManager_CreateMessageAndGetVersion_MethodRef);
+                versionMethod.GenericArguments.Add(type);
+                CreateInstructionsToRegisterType(processor, instructions, type, receiveMethod, versionMethod);
             }
+
+            instructions.ForEach(instruction => processor.Body.Instructions.Insert(processor.Body.Instructions.Count - 1, instruction));
+
+            assembly.MainModule.Types.Add(typeDefinition);
         }
     }
 }

Editor/CodeGen/INetworkSerializableILPP.cs

@@ -1,19 +1,15 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Collections.Generic;
-using System.Reflection;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
-using Mono.Cecil.Rocks;
 using Unity.CompilationPipeline.Common.Diagnostics;
 using Unity.CompilationPipeline.Common.ILPostProcessing;
 using ILPPInterface = Unity.CompilationPipeline.Common.ILPostProcessing.ILPostProcessor;
-using MethodAttributes = Mono.Cecil.MethodAttributes;
 
 namespace Unity.Netcode.Editor.CodeGen
 {
-
     internal sealed class INetworkSerializableILPP : ILPPInterface
     {
         public override ILPPInterface GetInstance() => this;
@@ -24,6 +20,30 @@ namespace Unity.Netcode.Editor.CodeGen
 
         private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>();
 
+        private TypeReference ResolveGenericType(TypeReference type, List<TypeReference> typeStack)
+        {
+            var genericName = type.Name;
+            var lastType = (GenericInstanceType)typeStack[typeStack.Count - 1];
+            var resolvedType = lastType.Resolve();
+            typeStack.RemoveAt(typeStack.Count - 1);
+            for (var i = 0; i < resolvedType.GenericParameters.Count; ++i)
+            {
+                var parameter = resolvedType.GenericParameters[i];
+                if (parameter.Name == genericName)
+                {
+                    var underlyingType = lastType.GenericArguments[i];
+                    if (underlyingType.Resolve() == null)
+                    {
+                        return ResolveGenericType(underlyingType, typeStack);
+                    }
+
+                    return underlyingType;
+                }
+            }
+
+            return null;
+        }
+
         public override ILPostProcessResult Process(ICompiledAssembly compiledAssembly)
         {
             if (!WillProcess(compiledAssembly))
@@ -31,7 +51,6 @@ namespace Unity.Netcode.Editor.CodeGen
                 return null;
             }
 
-
             m_Diagnostics.Clear();
 
             // read
@@ -48,27 +67,31 @@ namespace Unity.Netcode.Editor.CodeGen
             {
                 try
                 {
-                    if (ImportReferences(mainModule))
-                    {
-                        var types = mainModule.GetTypes()
-                            .Where(t => t.Resolve().HasInterface(CodeGenHelpers.INetworkSerializable_FullName) && !t.Resolve().IsAbstract && t.Resolve().IsValueType)
-                            .ToList();
-                        // process `INetworkMessage` types
-                        if (types.Count == 0)
-                        {
-                            return null;
-                        }
+                    var structTypes = mainModule.GetTypes()
+                        .Where(t => t.Resolve().HasInterface(CodeGenHelpers.INetworkSerializeByMemcpy_FullName) && !t.Resolve().IsAbstract && !t.Resolve().HasGenericParameters && t.Resolve().IsValueType)
+                        .ToList();
 
-                        CreateModuleInitializer(assemblyDefinition, types);
-                    }
-                    else
+                    foreach (var type in structTypes)
                     {
-                        m_Diagnostics.AddError($"Cannot import references into main module: {mainModule.Name}");
+                        // We'll avoid some confusion by ensuring users only choose one of the two
+                        // serialization schemes - by method OR by memcpy, not both. We'll also do a cursory
+                        // check that INetworkSerializeByMemcpy types are unmanaged.
+                        if (type.HasInterface(CodeGenHelpers.INetworkSerializeByMemcpy_FullName))
+                        {
+                            if (type.HasInterface(CodeGenHelpers.INetworkSerializable_FullName))
+                            {
+                                m_Diagnostics.AddError($"{nameof(INetworkSerializeByMemcpy)} types may not implement {nameof(INetworkSerializable)} - choose one or the other.");
+                            }
+                            if (!type.IsValueType)
+                            {
+                                m_Diagnostics.AddError($"{nameof(INetworkSerializeByMemcpy)} types must be unmanaged types.");
+                            }
+                        }
                     }
                 }
                 catch (Exception e)
                 {
-                    m_Diagnostics.AddError((e.ToString() + e.StackTrace.ToString()).Replace("\n", "|").Replace("\r", "|"));
+                    m_Diagnostics.AddError((e.ToString() + e.StackTrace).Replace("\n", "|").Replace("\r", "|"));
                 }
             }
             else
@@ -93,75 +116,5 @@ namespace Unity.Netcode.Editor.CodeGen
 
             return new ILPostProcessResult(new InMemoryAssembly(pe.ToArray(), pdb.ToArray()), m_Diagnostics);
         }
-
-        private MethodReference m_InitializeDelegates_MethodRef;
-
-        private const string k_InitializeMethodName = nameof(NetworkVariableHelper.InitializeDelegates);
-
-        private bool ImportReferences(ModuleDefinition moduleDefinition)
-        {
-
-            var helperType = typeof(NetworkVariableHelper);
-            foreach (var methodInfo in helperType.GetMethods(BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public))
-            {
-                switch (methodInfo.Name)
-                {
-                    case k_InitializeMethodName:
-                        m_InitializeDelegates_MethodRef = moduleDefinition.ImportReference(methodInfo);
-                        break;
-                }
-            }
-            return true;
-        }
-
-        private MethodDefinition GetOrCreateStaticConstructor(TypeDefinition typeDefinition)
-        {
-            var staticCtorMethodDef = typeDefinition.GetStaticConstructor();
-            if (staticCtorMethodDef == null)
-            {
-                staticCtorMethodDef = new MethodDefinition(
-                    ".cctor", // Static Constructor (constant-constructor)
-                    MethodAttributes.HideBySig |
-                    MethodAttributes.SpecialName |
-                    MethodAttributes.RTSpecialName |
-                    MethodAttributes.Static,
-                    typeDefinition.Module.TypeSystem.Void);
-                staticCtorMethodDef.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
-                typeDefinition.Methods.Add(staticCtorMethodDef);
-            }
-
-            return staticCtorMethodDef;
-        }
-
-        // Creates a static module constructor (which is executed when the module is loaded) that registers all the
-        // message types in the assembly with MessagingSystem.
-        // This is the same behavior as annotating a static method with [ModuleInitializer] in standardized
-        // C# (that attribute doesn't exist in Unity, but the static module constructor still works)
-        // https://docs.microsoft.com/en-us/dotnet/api/system.runtime.compilerservices.moduleinitializerattribute?view=net-5.0
-        // https://web.archive.org/web/20100212140402/http://blogs.msdn.com/junfeng/archive/2005/11/19/494914.aspx
-        private void CreateModuleInitializer(AssemblyDefinition assembly, List<TypeDefinition> networkSerializableTypes)
-        {
-            foreach (var typeDefinition in assembly.MainModule.Types)
-            {
-                if (typeDefinition.FullName == "<Module>")
-                {
-                    var staticCtorMethodDef = GetOrCreateStaticConstructor(typeDefinition);
-
-                    var processor = staticCtorMethodDef.Body.GetILProcessor();
-
-                    var instructions = new List<Instruction>();
-
-                    foreach (var type in networkSerializableTypes)
-                    {
-                        var method = new GenericInstanceMethod(m_InitializeDelegates_MethodRef);
-                        method.GenericArguments.Add(type);
-                        instructions.Add(processor.Create(OpCodes.Call, method));
-                    }
-
-                    instructions.ForEach(instruction => processor.Body.Instructions.Insert(processor.Body.Instructions.Count - 1, instruction));
-                    break;
-                }
-            }
-        }
     }
 }

Editor/CodeGen/RuntimeAccessModifiersILPP.cs

@@ -2,6 +2,7 @@ using System.Collections.Generic;
 using System.IO;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
+using Mono.Cecil.Rocks;
 using Unity.CompilationPipeline.Common.Diagnostics;
 using Unity.CompilationPipeline.Common.ILPostProcessing;
 using ILPPInterface = Unity.CompilationPipeline.Common.ILPostProcessing.ILPostProcessor;
@@ -52,10 +53,17 @@ namespace Unity.Netcode.Editor.CodeGen
                         case nameof(NetworkBehaviour):
                             ProcessNetworkBehaviour(typeDefinition);
                             break;
-                        case nameof(NetworkVariableHelper):
-                            ProcessNetworkVariableHelper(typeDefinition);
+                        case nameof(RpcAttribute):
+                            foreach (var methodDefinition in typeDefinition.GetConstructors())
+                            {
+                                if (methodDefinition.Parameters.Count == 0)
+                                {
+                                    methodDefinition.IsPublic = true;
+                                }
+                            }
                             break;
                         case nameof(__RpcParams):
+                        case nameof(RpcFallbackSerialization):
                             typeDefinition.IsPublic = true;
                             break;
                     }
@@ -82,6 +90,9 @@ namespace Unity.Netcode.Editor.CodeGen
             return new ILPostProcessResult(new InMemoryAssembly(pe.ToArray(), pdb.ToArray()), m_Diagnostics);
         }
 
+        // TODO: Deprecate...
+        // This is changing accessibility for values that are no longer used, but since our validator runs
+        // after ILPP and sees those values as public, they cannot be removed until a major version change.
         private void ProcessNetworkManager(TypeDefinition typeDefinition, string[] assemblyDefines)
         {
             foreach (var fieldDefinition in typeDefinition.Fields)
@@ -101,15 +112,12 @@ namespace Unity.Netcode.Editor.CodeGen
                     fieldDefinition.IsPublic = true;
                 }
             }
-        }
 
-        private void ProcessNetworkVariableHelper(TypeDefinition typeDefinition)
-        {
-            foreach (var methodDefinition in typeDefinition.Methods)
+            foreach (var nestedTypeDefinition in typeDefinition.NestedTypes)
             {
-                if (methodDefinition.Name == nameof(NetworkVariableHelper.InitializeDelegates))
+                if (nestedTypeDefinition.Name == nameof(NetworkManager.RpcReceiveHandler))
                 {
-                    methodDefinition.IsPublic = true;
+                    nestedTypeDefinition.IsNestedPublic = true;
                 }
             }
         }
@@ -122,23 +130,55 @@ namespace Unity.Netcode.Editor.CodeGen
                 {
                     nestedType.IsNestedFamily = true;
                 }
+                if (nestedType.Name == nameof(NetworkBehaviour.RpcReceiveHandler))
+                {
+                    nestedType.IsNestedPublic = true;
+                }
             }
 
             foreach (var fieldDefinition in typeDefinition.Fields)
             {
-                if (fieldDefinition.Name == nameof(NetworkBehaviour.__rpc_exec_stage))
+                if (fieldDefinition.Name == nameof(NetworkBehaviour.__rpc_exec_stage) || fieldDefinition.Name == nameof(NetworkBehaviour.NetworkVariableFields))
                 {
-                    fieldDefinition.IsFamily = true;
+                    fieldDefinition.IsFamilyOrAssembly = true;
+                }
+                if (fieldDefinition.Name == nameof(NetworkBehaviour.__rpc_func_table))
+                {
+                    fieldDefinition.IsFamilyOrAssembly = true;
+                }
+
+                if (fieldDefinition.Name == nameof(NetworkBehaviour.RpcReceiveHandler))
+                {
+                    fieldDefinition.IsFamilyOrAssembly = true;
+                }
+
+                if (fieldDefinition.Name == nameof(NetworkBehaviour.__rpc_name_table))
+                {
+                    fieldDefinition.IsFamilyOrAssembly = true;
                 }
             }
 
             foreach (var methodDefinition in typeDefinition.Methods)
             {
-                if (methodDefinition.Name == nameof(NetworkBehaviour.__sendServerRpc)
-                    || methodDefinition.Name == nameof(NetworkBehaviour.__sendClientRpc))
+                if (methodDefinition.Name == nameof(NetworkBehaviour.__beginSendServerRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__endSendServerRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__beginSendClientRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__endSendClientRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__beginSendRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__endSendRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__initializeVariables) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__initializeRpcs) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__registerRpc) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__nameNetworkVariable) ||
+                    methodDefinition.Name == nameof(NetworkBehaviour.__createNativeList))
                 {
                     methodDefinition.IsFamily = true;
                 }
+
+                if (methodDefinition.Name == nameof(NetworkBehaviour.__getTypeName))
+                {
+                    methodDefinition.IsFamilyOrAssembly = true;
+                }
             }
         }
     }

Editor/CodeGen/com.unity.netcode.editor.codegen.asmdef

@@ -2,11 +2,13 @@
     "name": "Unity.Netcode.Editor.CodeGen",
     "rootNamespace": "Unity.Netcode.Editor.CodeGen",
     "references": [
-        "Unity.Netcode.Runtime"
+        "Unity.Netcode.Runtime",
+        "Unity.Collections"
     ],
     "includePlatforms": [
         "Editor"
     ],
+    "excludePlatforms": [],
     "allowUnsafeCode": true,
     "overrideReferences": true,
     "precompiledReferences": [
@@ -15,5 +17,14 @@
         "Mono.Cecil.Pdb.dll",
         "Mono.Cecil.Rocks.dll"
     ],
-    "autoReferenced": false
+    "autoReferenced": false,
+    "defineConstraints": [],
+    "versionDefines": [
+        {
+            "name": "com.unity.nuget.mono-cecil",
+            "expression": "(0,1.11.4)",
+            "define": "CECIL_CONSTRAINTS_ARE_TYPE_REFERENCES"
+        }
+    ],
+    "noEngineReferences": false
 }

Editor/Configuration.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b2f70916f7024c66aa5dfe1e43c151a2
+timeCreated: 1654274400

Editor/Configuration/NetcodeForGameObjectsProjectSettings.cs

@@ -0,0 +1,30 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Netcode.Editor.Configuration
+{
+    [FilePath("ProjectSettings/NetcodeForGameObjects.asset", FilePathAttribute.Location.ProjectFolder)]
+    public class NetcodeForGameObjectsProjectSettings : ScriptableSingleton<NetcodeForGameObjectsProjectSettings>
+    {
+        internal static readonly string DefaultNetworkPrefabsPath = "Assets/DefaultNetworkPrefabs.asset";
+        [SerializeField] public string NetworkPrefabsPath = DefaultNetworkPrefabsPath;
+        public string TempNetworkPrefabsPath;
+
+        private void OnEnable()
+        {
+            if (NetworkPrefabsPath == "")
+            {
+                NetworkPrefabsPath = DefaultNetworkPrefabsPath;
+            }
+            TempNetworkPrefabsPath = NetworkPrefabsPath;
+        }
+
+        [SerializeField]
+        public bool GenerateDefaultNetworkPrefabs = true;
+
+        internal void SaveSettings()
+        {
+            Save(true);
+        }
+    }
+}

Editor/Configuration/NetcodeForGameObjectsProjectSettings.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2727d53a542a4c1aa312905c3a02d807
+timeCreated: 1685564945

Editor/Configuration/NetcodeForGameObjectsSettings.cs

@@ -0,0 +1,40 @@
+using UnityEditor;
+
+namespace Unity.Netcode.Editor.Configuration
+{
+    internal class NetcodeForGameObjectsEditorSettings
+    {
+        internal const string AutoAddNetworkObjectIfNoneExists = "AutoAdd-NetworkObject-When-None-Exist";
+        internal const string InstallMultiplayerToolsTipDismissedPlayerPrefKey = "Netcode_Tip_InstallMPTools_Dismissed";
+
+        internal static int GetNetcodeInstallMultiplayerToolTips()
+        {
+            if (EditorPrefs.HasKey(InstallMultiplayerToolsTipDismissedPlayerPrefKey))
+            {
+                return EditorPrefs.GetInt(InstallMultiplayerToolsTipDismissedPlayerPrefKey);
+            }
+
+            return 0;
+        }
+
+        internal static void SetNetcodeInstallMultiplayerToolTips(int toolTipPrefSetting)
+        {
+            EditorPrefs.SetInt(InstallMultiplayerToolsTipDismissedPlayerPrefKey, toolTipPrefSetting);
+        }
+
+        internal static bool GetAutoAddNetworkObjectSetting()
+        {
+            if (EditorPrefs.HasKey(AutoAddNetworkObjectIfNoneExists))
+            {
+                return EditorPrefs.GetBool(AutoAddNetworkObjectIfNoneExists);
+            }
+
+            return false;
+        }
+
+        internal static void SetAutoAddNetworkObjectSetting(bool autoAddSetting)
+        {
+            EditorPrefs.SetBool(AutoAddNetworkObjectIfNoneExists, autoAddSetting);
+        }
+    }
+}

Editor/Configuration/NetcodeForGameObjectsSettings.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2f9c9b10bc41a0e46ab71324dd0ac6e1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/Configuration/NetcodeSettingsProvider.cs

@@ -0,0 +1,243 @@
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+using Directory = UnityEngine.Windows.Directory;
+using File = UnityEngine.Windows.File;
+
+namespace Unity.Netcode.Editor.Configuration
+{
+    internal static class NetcodeSettingsProvider
+    {
+        private const float k_MaxLabelWidth = 450f;
+        private static float s_MaxLabelWidth;
+        private static bool s_ShowEditorSettingFields = true;
+        private static bool s_ShowProjectSettingFields = true;
+
+        [SettingsProvider]
+        public static SettingsProvider CreateNetcodeSettingsProvider()
+        {
+            // First parameter is the path in the Settings window.
+            // Second parameter is the scope of this setting: it only appears in the Settings window for the Project scope.
+            var provider = new SettingsProvider("Project/NetcodeForGameObjects", SettingsScope.Project)
+            {
+                label = "Netcode for GameObjects",
+                keywords = new[] { "netcode", "editor" },
+                guiHandler = OnGuiHandler,
+                deactivateHandler = OnDeactivate
+            };
+
+            return provider;
+        }
+
+        private static void OnDeactivate()
+        {
+            var settings = NetcodeForGameObjectsProjectSettings.instance;
+            if (settings.TempNetworkPrefabsPath != settings.NetworkPrefabsPath)
+            {
+                var newPath = settings.TempNetworkPrefabsPath;
+                if (newPath == "")
+                {
+                    newPath = NetcodeForGameObjectsProjectSettings.DefaultNetworkPrefabsPath;
+                    settings.TempNetworkPrefabsPath = newPath;
+                }
+                var oldPath = settings.NetworkPrefabsPath;
+                settings.NetworkPrefabsPath = settings.TempNetworkPrefabsPath;
+                var dirName = Path.GetDirectoryName(newPath);
+                if (!Directory.Exists(dirName))
+                {
+                    var dirs = dirName.Split(new[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar });
+                    var dirsQueue = new Queue<string>(dirs);
+                    var parent = dirsQueue.Dequeue();
+                    while (dirsQueue.Count != 0)
+                    {
+                        var child = dirsQueue.Dequeue();
+                        var together = Path.Combine(parent, child);
+                        if (!Directory.Exists(together))
+                        {
+                            AssetDatabase.CreateFolder(parent, child);
+                        }
+
+                        parent = together;
+                    }
+                }
+
+                if (Directory.Exists(dirName))
+                {
+                    if (File.Exists(oldPath))
+                    {
+                        AssetDatabase.MoveAsset(oldPath, newPath);
+                        if (File.Exists(oldPath))
+                        {
+                            File.Delete(oldPath);
+                        }
+                        AssetDatabase.Refresh();
+                    }
+                }
+                settings.SaveSettings();
+            }
+        }
+
+
+        internal static NetcodeSettingsLabel NetworkObjectsSectionLabel;
+        internal static NetcodeSettingsToggle AutoAddNetworkObjectToggle;
+        internal static NetcodeSettingsLabel MultiplayerToolsLabel;
+        internal static NetcodeSettingsToggle MultiplayerToolTipStatusToggle;
+
+        /// <summary>
+        /// Creates an instance of the settings UI Elements if they don't already exist.
+        /// </summary>
+        /// <remarks>
+        /// We have to construct any NetcodeGUISettings derived classes here because in
+        /// version 2020.x.x EditorStyles.label does not exist yet (higher versions it does)
+        /// </remarks>
+        private static void CheckForInitialize()
+        {
+            if (NetworkObjectsSectionLabel == null)
+            {
+                NetworkObjectsSectionLabel = new NetcodeSettingsLabel("NetworkObject Helper Settings", 20);
+            }
+
+            if (AutoAddNetworkObjectToggle == null)
+            {
+                AutoAddNetworkObjectToggle = new NetcodeSettingsToggle("Auto-Add NetworkObject Component", "When enabled, NetworkObject components are automatically added to GameObjects when NetworkBehaviour components are added first.", 20);
+            }
+
+            if (MultiplayerToolsLabel == null)
+            {
+                MultiplayerToolsLabel = new NetcodeSettingsLabel("Multiplayer Tools", 20);
+            }
+
+            if (MultiplayerToolTipStatusToggle == null)
+            {
+                MultiplayerToolTipStatusToggle = new NetcodeSettingsToggle("Multiplayer Tools Install Reminder", "When enabled, the NetworkManager will display the notification to install the multiplayer tools package.", 20);
+            }
+        }
+
+        private static void OnGuiHandler(string obj)
+        {
+            // Make sure all NetcodeGUISettings derived classes are instantiated first
+            CheckForInitialize();
+
+            var autoAddNetworkObjectSetting = NetcodeForGameObjectsEditorSettings.GetAutoAddNetworkObjectSetting();
+            var multiplayerToolsTipStatus = NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() == 0;
+            var settings = NetcodeForGameObjectsProjectSettings.instance;
+            var generateDefaultPrefabs = settings.GenerateDefaultNetworkPrefabs;
+            var networkPrefabsPath = settings.TempNetworkPrefabsPath;
+
+            EditorGUI.BeginChangeCheck();
+
+            GUILayout.BeginVertical("Box");
+            s_ShowEditorSettingFields = EditorGUILayout.BeginFoldoutHeaderGroup(s_ShowEditorSettingFields, "Editor Settings");
+
+            if (s_ShowEditorSettingFields)
+            {
+                GUILayout.BeginVertical("Box");
+                NetworkObjectsSectionLabel.DrawLabel();
+                autoAddNetworkObjectSetting = AutoAddNetworkObjectToggle.DrawToggle(autoAddNetworkObjectSetting);
+                GUILayout.EndVertical();
+
+                GUILayout.BeginVertical("Box");
+                MultiplayerToolsLabel.DrawLabel();
+                multiplayerToolsTipStatus = MultiplayerToolTipStatusToggle.DrawToggle(multiplayerToolsTipStatus);
+                GUILayout.EndVertical();
+            }
+            EditorGUILayout.EndFoldoutHeaderGroup();
+            GUILayout.EndVertical();
+
+            GUILayout.BeginVertical("Box");
+            s_ShowProjectSettingFields = EditorGUILayout.BeginFoldoutHeaderGroup(s_ShowProjectSettingFields, "Project Settings");
+            if (s_ShowProjectSettingFields)
+            {
+                GUILayout.BeginVertical("Box");
+                const string generateNetworkPrefabsString = "Generate Default Network Prefabs List";
+                const string networkPrefabsLocationString = "Default Network Prefabs List path";
+
+                if (s_MaxLabelWidth == 0)
+                {
+                    s_MaxLabelWidth = EditorStyles.label.CalcSize(new GUIContent(generateNetworkPrefabsString)).x;
+                    s_MaxLabelWidth = Mathf.Min(k_MaxLabelWidth, s_MaxLabelWidth);
+                }
+
+                EditorGUIUtility.labelWidth = s_MaxLabelWidth;
+
+                GUILayout.Label("Network Prefabs", EditorStyles.boldLabel);
+                generateDefaultPrefabs = EditorGUILayout.Toggle(
+                    new GUIContent(
+                        generateNetworkPrefabsString,
+                        "When enabled, a default NetworkPrefabsList object will be added to your project and kept up " +
+                        "to date with all NetworkObject prefabs."),
+                    generateDefaultPrefabs,
+                    GUILayout.Width(s_MaxLabelWidth + 20));
+
+                GUI.SetNextControlName("Location");
+                networkPrefabsPath = EditorGUILayout.TextField(
+                    new GUIContent(
+                        networkPrefabsLocationString,
+                        "The path to the asset the default NetworkPrefabList object should be stored in."),
+                    networkPrefabsPath,
+                    GUILayout.Width(s_MaxLabelWidth + 270));
+                GUILayout.EndVertical();
+            }
+            EditorGUILayout.EndFoldoutHeaderGroup();
+            GUILayout.EndVertical();
+            if (EditorGUI.EndChangeCheck())
+            {
+                NetcodeForGameObjectsEditorSettings.SetAutoAddNetworkObjectSetting(autoAddNetworkObjectSetting);
+                NetcodeForGameObjectsEditorSettings.SetNetcodeInstallMultiplayerToolTips(multiplayerToolsTipStatus ? 0 : 1);
+                settings.GenerateDefaultNetworkPrefabs = generateDefaultPrefabs;
+                settings.TempNetworkPrefabsPath = networkPrefabsPath;
+                settings.SaveSettings();
+            }
+        }
+    }
+
+    internal class NetcodeSettingsLabel : NetcodeGUISettings
+    {
+        private string m_LabelContent;
+
+        public void DrawLabel()
+        {
+            EditorGUIUtility.labelWidth = m_LabelSize;
+            GUILayout.Label(m_LabelContent, EditorStyles.boldLabel, m_LayoutWidth);
+        }
+
+        public NetcodeSettingsLabel(string labelText, float layoutOffset = 0.0f)
+        {
+            m_LabelContent = labelText;
+            AdjustLabelSize(labelText, layoutOffset);
+        }
+    }
+
+    internal class NetcodeSettingsToggle : NetcodeGUISettings
+    {
+        private GUIContent m_ToggleContent;
+
+        public bool DrawToggle(bool currentSetting)
+        {
+            EditorGUIUtility.labelWidth = m_LabelSize;
+            return EditorGUILayout.Toggle(m_ToggleContent, currentSetting, m_LayoutWidth);
+        }
+
+        public NetcodeSettingsToggle(string labelText, string toolTip, float layoutOffset)
+        {
+            AdjustLabelSize(labelText, layoutOffset);
+            m_ToggleContent = new GUIContent(labelText, toolTip);
+        }
+    }
+
+    internal class NetcodeGUISettings
+    {
+        private const float k_MaxLabelWidth = 450f;
+        protected float m_LabelSize { get; private set; }
+
+        protected GUILayoutOption m_LayoutWidth { get; private set; }
+
+        protected void AdjustLabelSize(string labelText, float offset = 0.0f)
+        {
+            m_LabelSize = Mathf.Min(k_MaxLabelWidth, EditorStyles.label.CalcSize(new GUIContent(labelText)).x);
+            m_LayoutWidth = GUILayout.Width(m_LabelSize + offset);
+        }
+    }
+
+}

Editor/Configuration/NetcodeSettingsProvider.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6b373a89fcbd41444a97ebd1798b326f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/Configuration/NetworkPrefabProcessor.cs

@@ -0,0 +1,186 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Netcode.Editor.Configuration
+{
+    /// <summary>
+    /// Updates the default <see cref="NetworkPrefabsList"/> instance when prefabs are updated (created, moved, deleted) in the project.
+    /// </summary>
+    public class NetworkPrefabProcessor : AssetPostprocessor
+    {
+        public static string DefaultNetworkPrefabsPath
+        {
+            get
+            {
+                return NetcodeForGameObjectsProjectSettings.instance.NetworkPrefabsPath;
+            }
+            internal set
+            {
+                NetcodeForGameObjectsProjectSettings.instance.NetworkPrefabsPath = value;
+                // Force a recache of the prefab list
+                s_PrefabsList = null;
+            }
+        }
+        private static NetworkPrefabsList s_PrefabsList;
+        private static Dictionary<string, NetworkPrefab> s_PrefabsListPath = new Dictionary<string, NetworkPrefab>();
+
+        private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
+        {
+            var settings = NetcodeForGameObjectsProjectSettings.instance;
+            if (!settings.GenerateDefaultNetworkPrefabs)
+            {
+                return;
+            }
+
+            bool ProcessImportedAssets(string[] importedAssets1)
+            {
+                var dirty = false;
+                foreach (var assetPath in importedAssets1)
+                {
+                    // We only care about GameObjects, skip everything else. Can't use the more targeted
+                    // OnPostProcessPrefabs since that's not called for moves or deletes
+                    if (AssetDatabase.GetMainAssetTypeAtPath(assetPath) != typeof(GameObject))
+                    {
+                        continue;
+                    }
+
+                    var go = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
+                    if (go.TryGetComponent<NetworkObject>(out _))
+                    {
+                        // Make sure we are not duplicating an already existing entry
+                        if (s_PrefabsListPath.ContainsKey(assetPath))
+                        {
+                            // Is the imported asset different from the one we already have in the list?
+                            if (s_PrefabsListPath[assetPath].Prefab.GetHashCode() != go.GetHashCode())
+                            {
+                                // If so remove the one in the list and continue on to add the imported one
+                                s_PrefabsList.List.Remove(s_PrefabsListPath[assetPath]);
+                            }
+                            else // If they are identical, then just ignore the import
+                            {
+                                continue;
+                            }
+                        }
+
+                        s_PrefabsList.List.Add(new NetworkPrefab { Prefab = go });
+                        dirty = true;
+                    }
+                }
+
+                return dirty;
+            }
+
+            bool ProcessDeletedAssets(string[] strings)
+            {
+                var dirty = false;
+                var deleted = new List<string>(strings);
+                for (int i = s_PrefabsList.List.Count - 1; i >= 0 && deleted.Count > 0; --i)
+                {
+                    GameObject prefab;
+                    try
+                    {
+                        prefab = s_PrefabsList.List[i].Prefab;
+                    }
+                    catch (MissingReferenceException)
+                    {
+                        s_PrefabsList.List.RemoveAt(i);
+                        continue;
+                    }
+                    if (prefab == null)
+                    {
+                        s_PrefabsList.List.RemoveAt(i);
+                    }
+                    else
+                    {
+                        string noPath = AssetDatabase.GetAssetPath(prefab);
+                        for (int j = strings.Length - 1; j >= 0; --j)
+                        {
+                            if (noPath == strings[j])
+                            {
+                                s_PrefabsList.List.RemoveAt(i);
+                                deleted.RemoveAt(j);
+                                dirty = true;
+                            }
+                        }
+                    }
+                }
+
+                return dirty;
+            }
+
+            if (s_PrefabsList == null)
+            {
+                s_PrefabsList = GetOrCreateNetworkPrefabs(DefaultNetworkPrefabsPath, out var newList, true);
+                // A new list already processed all existing assets, no need to double-process imports & deletes
+                if (newList)
+                {
+                    return;
+                }
+            }
+            // Clear our asset path to prefab table each time
+            s_PrefabsListPath.Clear();
+
+            // Create our asst path to prefab table
+            foreach (var prefabEntry in s_PrefabsList.List)
+            {
+                if (!s_PrefabsListPath.ContainsKey(AssetDatabase.GetAssetPath(prefabEntry.Prefab)))
+                {
+                    s_PrefabsListPath.Add(AssetDatabase.GetAssetPath(prefabEntry.Prefab), prefabEntry);
+                }
+            }
+
+            // Process the imported and deleted assets
+            var markDirty = ProcessImportedAssets(importedAssets);
+            markDirty &= ProcessDeletedAssets(deletedAssets);
+
+            if (markDirty)
+            {
+                EditorUtility.SetDirty(s_PrefabsList);
+            }
+        }
+
+        internal static NetworkPrefabsList GetOrCreateNetworkPrefabs(string path, out bool isNew, bool addAll)
+        {
+            var defaultPrefabs = AssetDatabase.LoadAssetAtPath<NetworkPrefabsList>(path);
+            if (defaultPrefabs == null)
+            {
+                isNew = true;
+                defaultPrefabs = ScriptableObject.CreateInstance<NetworkPrefabsList>();
+                defaultPrefabs.IsDefault = true;
+                AssetDatabase.CreateAsset(defaultPrefabs, path);
+
+                if (addAll)
+                {
+                    // This could be very expensive in large projects... maybe make it manually triggered via a menu?
+                    defaultPrefabs.List = FindAll();
+                }
+                EditorUtility.SetDirty(defaultPrefabs);
+                AssetDatabase.SaveAssetIfDirty(defaultPrefabs);
+                return defaultPrefabs;
+            }
+
+            isNew = false;
+            return defaultPrefabs;
+        }
+
+        private static List<NetworkPrefab> FindAll()
+        {
+            var list = new List<NetworkPrefab>();
+
+            string[] guids = AssetDatabase.FindAssets("t:GameObject");
+            foreach (var guid in guids)
+            {
+                string assetPath = AssetDatabase.GUIDToAssetPath(guid);
+                var go = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
+
+                if (go.TryGetComponent(out NetworkObject _))
+                {
+                    list.Add(new NetworkPrefab { Prefab = go });
+                }
+            }
+
+            return list;
+        }
+    }
+}

Editor/Configuration/NetworkPrefabProcessor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d8b62a05d80cc444f9c74731c01b8e39
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/Configuration/NetworkPrefabsEditor.cs

@@ -0,0 +1,97 @@
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+
+namespace Unity.Netcode.Editor
+{
+    [CustomEditor(typeof(NetworkPrefabsList), true)]
+    [CanEditMultipleObjects]
+    public class NetworkPrefabsEditor : UnityEditor.Editor
+    {
+        private ReorderableList m_NetworkPrefabsList;
+        private SerializedProperty m_IsDefaultBool;
+
+        private void OnEnable()
+        {
+            m_IsDefaultBool = serializedObject.FindProperty(nameof(NetworkPrefabsList.IsDefault));
+            m_NetworkPrefabsList = new ReorderableList(serializedObject, serializedObject.FindProperty("List"), true, true, true, true);
+            m_NetworkPrefabsList.elementHeightCallback = index =>
+            {
+                var networkOverrideInt = 0;
+                if (m_NetworkPrefabsList.count > 0)
+                {
+                    var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
+                    var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
+                    networkOverrideInt = networkOverrideProp.enumValueIndex;
+                }
+
+                return 8 + (networkOverrideInt == 0 ? EditorGUIUtility.singleLineHeight : (EditorGUIUtility.singleLineHeight * 2) + 5);
+            };
+            m_NetworkPrefabsList.drawElementCallback = (rect, index, isActive, isFocused) =>
+            {
+                rect.y += 5;
+
+                var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
+                var networkPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Prefab));
+                var networkSourceHashProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourceHashToOverride));
+                var networkSourcePrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourcePrefabToOverride));
+                var networkTargetPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.OverridingTargetPrefab));
+                var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
+                var networkOverrideInt = networkOverrideProp.enumValueIndex;
+                var networkOverrideEnum = (NetworkPrefabOverride)networkOverrideInt;
+                EditorGUI.LabelField(new Rect(rect.x + rect.width - 70, rect.y, 60, EditorGUIUtility.singleLineHeight), "Override");
+                if (networkOverrideEnum == NetworkPrefabOverride.None)
+                {
+                    if (EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), false))
+                    {
+                        networkOverrideProp.enumValueIndex = (int)NetworkPrefabOverride.Prefab;
+                    }
+                }
+                else
+                {
+                    if (!EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), true))
+                    {
+                        networkOverrideProp.enumValueIndex = 0;
+                        networkOverrideEnum = NetworkPrefabOverride.None;
+                    }
+                }
+
+                if (networkOverrideEnum == NetworkPrefabOverride.None)
+                {
+                    EditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width - 80, EditorGUIUtility.singleLineHeight), networkPrefabProp, GUIContent.none);
+                }
+                else
+                {
+                    networkOverrideProp.enumValueIndex = GUI.Toolbar(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), networkOverrideInt - 1, new[] { "Prefab", "Hash" }) + 1;
+
+                    if (networkOverrideEnum == NetworkPrefabOverride.Prefab)
+                    {
+                        EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourcePrefabProp, GUIContent.none);
+                    }
+                    else
+                    {
+                        EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourceHashProp, GUIContent.none);
+                    }
+
+                    rect.y += EditorGUIUtility.singleLineHeight + 5;
+
+                    EditorGUI.LabelField(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), "Overriding Prefab");
+                    EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 110, EditorGUIUtility.singleLineHeight), networkTargetPrefabProp, GUIContent.none);
+                }
+            };
+            m_NetworkPrefabsList.drawHeaderCallback = rect => EditorGUI.LabelField(rect, "NetworkPrefabs");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            using (new EditorGUI.DisabledScope(true))
+            {
+                EditorGUILayout.PropertyField(m_IsDefaultBool);
+            }
+
+            m_NetworkPrefabsList.DoLayoutList();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Editor/Configuration/NetworkPrefabsEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8d6d0919fa8ff41c9b1d1241256f7364
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/DontShowInTransportDropdownAttribute.cs

@@ -1,8 +0,0 @@
-using System;
-
-namespace Unity.Netcode.Editor
-{
-    public class DontShowInTransportDropdownAttribute : Attribute
-    {
-    }
-}

Editor/DontShowInTransportDropdownAttribute.cs.meta

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: 5f097067d4254dc7ad018d7ad90df7c3
-timeCreated: 1620386886

Editor/HiddenScriptEditor.cs

@@ -0,0 +1,184 @@
+using Unity.Netcode.Components;
+#if UNITY_UNET_PRESENT
+using Unity.Netcode.Transports.UNET;
+#endif
+using Unity.Netcode.Transports.UTP;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Netcode.Editor
+{
+    /// <summary>
+    /// Internal use. Hides the script field for the given component.
+    /// </summary>
+    public class HiddenScriptEditor : UnityEditor.Editor
+    {
+        private static readonly string[] k_HiddenFields = { "m_Script" };
+
+        /// <summary>
+        /// Draws inspector properties without the script field.
+        /// </summary>
+        public override void OnInspectorGUI()
+        {
+            EditorGUI.BeginChangeCheck();
+            serializedObject.UpdateIfRequiredOrScript();
+            DrawPropertiesExcluding(serializedObject, k_HiddenFields);
+            serializedObject.ApplyModifiedProperties();
+            EditorGUI.EndChangeCheck();
+        }
+    }
+#if UNITY_UNET_PRESENT
+    /// <summary>
+    /// Internal use. Hides the script field for UNetTransport.
+    /// </summary>
+    [CustomEditor(typeof(UNetTransport), true)]
+    public class UNetTransportEditor : HiddenScriptEditor
+    {
+
+    }
+#endif
+
+    /// <summary>
+    /// Internal use. Hides the script field for UnityTransport.
+    /// </summary>
+    [CustomEditor(typeof(UnityTransport), true)]
+    public class UnityTransportEditor : HiddenScriptEditor
+    {
+        private static readonly string[] k_HiddenFields = { "m_Script", "ConnectionData" };
+
+        private bool m_AllowIncomingConnections;
+        private bool m_Initialized;
+
+        private UnityTransport m_UnityTransport;
+
+        private SerializedProperty m_ServerAddressProperty;
+        private SerializedProperty m_ServerPortProperty;
+        private SerializedProperty m_OverrideBindIpProperty;
+
+        private const string k_LoopbackIpv4 = "127.0.0.1";
+        private const string k_LoopbackIpv6 = "::1";
+        private const string k_AnyIpv4 = "0.0.0.0";
+        private const string k_AnyIpv6 = "::";
+
+
+        private void Initialize()
+        {
+            if (m_Initialized)
+            {
+                return;
+            }
+            m_Initialized = true;
+            m_UnityTransport = (UnityTransport)target;
+
+            var connectionDataProperty = serializedObject.FindProperty(nameof(UnityTransport.ConnectionData));
+
+            m_ServerAddressProperty = connectionDataProperty.FindPropertyRelative(nameof(UnityTransport.ConnectionAddressData.Address));
+            m_ServerPortProperty = connectionDataProperty.FindPropertyRelative(nameof(UnityTransport.ConnectionAddressData.Port));
+            m_OverrideBindIpProperty = connectionDataProperty.FindPropertyRelative(nameof(UnityTransport.ConnectionAddressData.ServerListenAddress));
+        }
+
+        /// <summary>
+        /// Draws inspector properties without the script field.
+        /// </summary>
+        public override void OnInspectorGUI()
+        {
+            Initialize();
+            EditorGUI.BeginChangeCheck();
+            serializedObject.UpdateIfRequiredOrScript();
+            DrawPropertiesExcluding(serializedObject, k_HiddenFields);
+            serializedObject.ApplyModifiedProperties();
+            EditorGUI.EndChangeCheck();
+
+            EditorGUILayout.PropertyField(m_ServerAddressProperty);
+            EditorGUILayout.PropertyField(m_ServerPortProperty);
+
+            serializedObject.ApplyModifiedProperties();
+
+            EditorGUILayout.HelpBox("It's recommended to leave remote connections disabled for local testing to avoid exposing ports on your device.", MessageType.Info);
+            bool allowRemoteConnections = m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv4 && m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv6 && !string.IsNullOrEmpty(m_UnityTransport.ConnectionData.ServerListenAddress);
+            allowRemoteConnections = EditorGUILayout.Toggle(new GUIContent("Allow Remote Connections?", $"Bind IP: {m_UnityTransport.ConnectionData.ServerListenAddress}"), allowRemoteConnections);
+
+            bool isIpV6 = m_UnityTransport.ConnectionData.IsIpv6;
+
+            if (!allowRemoteConnections)
+            {
+                if (m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv4 && m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv6)
+                {
+                    if (isIpV6)
+                    {
+                        m_UnityTransport.ConnectionData.ServerListenAddress = k_LoopbackIpv6;
+                    }
+                    else
+                    {
+                        m_UnityTransport.ConnectionData.ServerListenAddress = k_LoopbackIpv4;
+                    }
+                    EditorUtility.SetDirty(m_UnityTransport);
+                }
+            }
+
+            using (new EditorGUI.DisabledScope(!allowRemoteConnections))
+            {
+                string overrideIp = m_UnityTransport.ConnectionData.ServerListenAddress;
+                if (overrideIp == k_AnyIpv4 || overrideIp == k_AnyIpv6 || overrideIp == k_LoopbackIpv4 || overrideIp == k_LoopbackIpv6)
+                {
+                    overrideIp = "";
+                }
+
+                overrideIp = EditorGUILayout.TextField("Override Bind IP (optional)", overrideIp);
+                if (allowRemoteConnections)
+                {
+                    if (overrideIp == "")
+                    {
+                        if (isIpV6)
+                        {
+                            overrideIp = k_AnyIpv6;
+                        }
+                        else
+                        {
+                            overrideIp = k_AnyIpv4;
+                        }
+                    }
+
+                    if (m_UnityTransport.ConnectionData.ServerListenAddress != overrideIp)
+                    {
+                        m_UnityTransport.ConnectionData.ServerListenAddress = overrideIp;
+                        EditorUtility.SetDirty(m_UnityTransport);
+                    }
+                }
+            }
+        }
+    }
+
+#if COM_UNITY_MODULES_ANIMATION
+    /// <summary>
+    /// Internal use. Hides the script field for NetworkAnimator.
+    /// </summary>
+    [CustomEditor(typeof(NetworkAnimator), true)]
+    public class NetworkAnimatorEditor : HiddenScriptEditor
+    {
+
+    }
+#endif
+
+#if COM_UNITY_MODULES_PHYSICS
+    /// <summary>
+    /// Internal use. Hides the script field for NetworkRigidbody.
+    /// </summary>
+    [CustomEditor(typeof(NetworkRigidbody), true)]
+    public class NetworkRigidbodyEditor : HiddenScriptEditor
+    {
+
+    }
+#endif
+
+#if COM_UNITY_MODULES_PHYSICS2D
+    /// <summary>
+    /// Internal use. Hides the script field for NetworkRigidbody2D.
+    /// </summary>
+    [CustomEditor(typeof(NetworkRigidbody2D), true)]
+    public class NetworkRigidbody2DEditor : HiddenScriptEditor
+    {
+
+    }
+#endif
+}

Editor/HiddenScriptEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ebf622cc80e94f488e59caf8b7419f50
+timeCreated: 1661959406

Editor/NetworkAnimatorEditor.cs

@@ -1,103 +0,0 @@
-using System;
-using Unity.Netcode.Components;
-using UnityEditor;
-using UnityEditor.Animations;
-using UnityEngine;
-
-namespace Unity.Netcode.Editor
-{
-    public static class TextUtility
-    {
-        public static GUIContent TextContent(string name, string tooltip)
-        {
-            var newContent = new GUIContent(name);
-            newContent.tooltip = tooltip;
-            return newContent;
-        }
-
-        public static GUIContent TextContent(string name)
-        {
-            return new GUIContent(name);
-        }
-    }
-
-    [CustomEditor(typeof(NetworkAnimator), true)]
-    [CanEditMultipleObjects]
-    public class NetworkAnimatorEditor : UnityEditor.Editor
-    {
-        private NetworkAnimator m_AnimSync;
-        [NonSerialized] private bool m_Initialized;
-        private SerializedProperty m_AnimatorProperty;
-        private GUIContent m_AnimatorLabel;
-
-        private void Init()
-        {
-            if (m_Initialized)
-            {
-                return;
-            }
-
-            m_Initialized = true;
-            m_AnimSync = target as NetworkAnimator;
-
-            m_AnimatorProperty = serializedObject.FindProperty("m_Animator");
-            m_AnimatorLabel = TextUtility.TextContent("Animator", "The Animator component to synchronize.");
-        }
-
-        public override void OnInspectorGUI()
-        {
-            Init();
-            serializedObject.Update();
-            DrawControls();
-            serializedObject.ApplyModifiedProperties();
-        }
-
-        private void DrawControls()
-        {
-            EditorGUI.BeginChangeCheck();
-            EditorGUILayout.PropertyField(m_AnimatorProperty, m_AnimatorLabel);
-            if (EditorGUI.EndChangeCheck())
-            {
-                m_AnimSync.ResetParameterOptions();
-            }
-
-            if (m_AnimSync.Animator == null)
-            {
-                return;
-            }
-
-            var controller = m_AnimSync.Animator.runtimeAnimatorController as AnimatorController;
-            if (controller != null)
-            {
-                var showWarning = false;
-                EditorGUI.indentLevel += 1;
-                int i = 0;
-
-                foreach (var p in controller.parameters)
-                {
-                    if (i >= NetworkAnimator.K_MaxAnimationParams)
-                    {
-                        showWarning = true;
-                        break;
-                    }
-
-                    bool oldSend = m_AnimSync.GetParameterAutoSend(i);
-                    bool send = EditorGUILayout.Toggle(p.name, oldSend);
-                    if (send != oldSend)
-                    {
-                        m_AnimSync.SetParameterAutoSend(i, send);
-                        EditorUtility.SetDirty(target);
-                    }
-                    i += 1;
-                }
-
-                if (showWarning)
-                {
-                    EditorGUILayout.HelpBox($"NetworkAnimator can only select between the first {NetworkAnimator.K_MaxAnimationParams} parameters in a mecanim controller", MessageType.Warning);
-                }
-
-                EditorGUI.indentLevel -= 1;
-            }
-        }
-    }
-}

Editor/NetworkBehaviourEditor.cs

@@ -1,11 +1,15 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using UnityEngine;
+using Unity.Netcode.Editor.Configuration;
 using UnityEditor;
+using UnityEngine;
 
 namespace Unity.Netcode.Editor
 {
+    /// <summary>
+    /// The <see cref="CustomEditor"/> for <see cref="NetworkBehaviour"/>
+    /// </summary>
     [CustomEditor(typeof(NetworkBehaviour), true)]
     [CanEditMultipleObjects]
     public class NetworkBehaviourEditor : UnityEditor.Editor
@@ -16,6 +20,7 @@ namespace Unity.Netcode.Editor
         private readonly Dictionary<string, object> m_NetworkVariableObjects = new Dictionary<string, object>();
 
         private GUIContent m_NetworkVariableLabelGuiContent;
+        private GUIContent m_NetworkListLabelGuiContent;
 
         private void Init(MonoScript script)
         {
@@ -26,15 +31,21 @@ namespace Unity.Netcode.Editor
             m_NetworkVariableObjects.Clear();
 
             m_NetworkVariableLabelGuiContent = new GUIContent("NetworkVariable", "This variable is a NetworkVariable. It can not be serialized and can only be changed during runtime.");
+            m_NetworkListLabelGuiContent = new GUIContent("NetworkList", "This variable is a NetworkList. It is rendered, but you can't serialize or change it.");
 
             var fields = script.GetClass().GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
             for (int i = 0; i < fields.Length; i++)
             {
                 var ft = fields[i].FieldType;
-                if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkVariable<>) && !fields[i].IsDefined(typeof(HideInInspector), true))
+                if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkVariable<>) && !fields[i].IsDefined(typeof(HideInInspector), true) && !fields[i].IsDefined(typeof(NonSerializedAttribute), true))
                 {
-                    m_NetworkVariableNames.Add(fields[i].Name);
-                    m_NetworkVariableFields.Add(fields[i].Name, fields[i]);
+                    m_NetworkVariableNames.Add(ObjectNames.NicifyVariableName(fields[i].Name));
+                    m_NetworkVariableFields.Add(ObjectNames.NicifyVariableName(fields[i].Name), fields[i]);
+                }
+                if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkList<>) && !fields[i].IsDefined(typeof(HideInInspector), true) && !fields[i].IsDefined(typeof(NonSerializedAttribute), true))
+                {
+                    m_NetworkVariableNames.Add(ObjectNames.NicifyVariableName(fields[i].Name));
+                    m_NetworkVariableFields.Add(ObjectNames.NicifyVariableName(fields[i].Name), fields[i]);
                 }
             }
         }
@@ -68,25 +79,82 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.BeginHorizontal();
             if (genericType.IsValueType)
             {
-                var method = typeof(NetworkBehaviourEditor).GetMethod("RenderNetworkVariableValueType", BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
+                var isEquatable = false;
+                foreach (var iface in genericType.GetInterfaces())
+                {
+                    if (iface.IsGenericType && iface.GetGenericTypeDefinition() == typeof(IEquatable<>))
+                    {
+                        isEquatable = true;
+                    }
+                }
+
+                MethodInfo method;
+                if (isEquatable)
+                {
+                    method = typeof(NetworkBehaviourEditor).GetMethod(nameof(RenderNetworkContainerValueTypeIEquatable), BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
+                }
+                else
+                {
+                    method = typeof(NetworkBehaviourEditor).GetMethod(nameof(RenderNetworkContainerValueType), BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
+                }
+
                 var genericMethod = method.MakeGenericMethod(genericType);
                 genericMethod.Invoke(this, new[] { (object)index });
             }
             else
             {
                 EditorGUILayout.LabelField("Type not renderable");
+
+                GUILayout.Label(m_NetworkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkVariableLabelGuiContent).x));
+                EditorGUILayout.EndHorizontal();
+            }
+        }
+
+        private void RenderNetworkContainerValueType<T>(int index) where T : unmanaged
+        {
+            try
+            {
+                var networkVariable = (NetworkVariable<T>)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target);
+                RenderNetworkVariableValueType(index, networkVariable);
+            }
+            catch (Exception e)
+            {
+                Debug.Log(e);
+                throw;
             }
 
-            GUILayout.Label(m_NetworkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkVariableLabelGuiContent).x));
             EditorGUILayout.EndHorizontal();
         }
 
-        private void RenderNetworkVariableValueType<T>(int index) where T : unmanaged
+        private void RenderNetworkContainerValueTypeIEquatable<T>(int index) where T : unmanaged, IEquatable<T>
+        {
+            try
+            {
+                var networkVariable = (NetworkVariable<T>)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target);
+                RenderNetworkVariableValueType(index, networkVariable);
+            }
+            catch (Exception)
+            {
+                try
+                {
+                    var networkList = (NetworkList<T>)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target);
+                    RenderNetworkListValueType(index, networkList);
+                }
+                catch (Exception e)
+                {
+                    Debug.Log(e);
+                    throw;
+                }
+            }
+
+            EditorGUILayout.EndHorizontal();
+        }
+
+        private void RenderNetworkVariableValueType<T>(int index, NetworkVariable<T> networkVariable) where T : unmanaged
         {
-            var networkVariable = (NetworkVariable<T>)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target);
             var type = typeof(T);
             object val = networkVariable.Value;
-            string name = m_NetworkVariableNames[index];
+            string variableName = m_NetworkVariableNames[index];
 
             var behaviour = (NetworkBehaviour)target;
 
@@ -95,47 +163,51 @@ namespace Unity.Netcode.Editor
             {
                 if (type == typeof(int))
                 {
-                    val = EditorGUILayout.IntField(name, (int)val);
+                    val = EditorGUILayout.IntField(variableName, (int)val);
                 }
                 else if (type == typeof(uint))
                 {
-                    val = (uint)EditorGUILayout.LongField(name, (long)((uint)val));
+                    val = (uint)EditorGUILayout.LongField(variableName, (uint)val);
                 }
                 else if (type == typeof(short))
                 {
-                    val = (short)EditorGUILayout.IntField(name, (int)((short)val));
+                    val = (short)EditorGUILayout.IntField(variableName, (short)val);
                 }
                 else if (type == typeof(ushort))
                 {
-                    val = (ushort)EditorGUILayout.IntField(name, (int)((ushort)val));
+                    val = (ushort)EditorGUILayout.IntField(variableName, (ushort)val);
                 }
                 else if (type == typeof(sbyte))
                 {
-                    val = (sbyte)EditorGUILayout.IntField(name, (int)((sbyte)val));
+                    val = (sbyte)EditorGUILayout.IntField(variableName, (sbyte)val);
                 }
                 else if (type == typeof(byte))
                 {
-                    val = (byte)EditorGUILayout.IntField(name, (int)((byte)val));
+                    val = (byte)EditorGUILayout.IntField(variableName, (byte)val);
                 }
                 else if (type == typeof(long))
                 {
-                    val = EditorGUILayout.LongField(name, (long)val);
+                    val = EditorGUILayout.LongField(variableName, (long)val);
                 }
                 else if (type == typeof(ulong))
                 {
-                    val = (ulong)EditorGUILayout.LongField(name, (long)((ulong)val));
+                    val = (ulong)EditorGUILayout.LongField(variableName, (long)((ulong)val));
+                }
+                else if (type == typeof(float))
+                {
+                    val = EditorGUILayout.FloatField(variableName, (float)((float)val));
                 }
                 else if (type == typeof(bool))
                 {
-                    val = EditorGUILayout.Toggle(name, (bool)val);
+                    val = EditorGUILayout.Toggle(variableName, (bool)val);
                 }
                 else if (type == typeof(string))
                 {
-                    val = EditorGUILayout.TextField(name, (string)val);
+                    val = EditorGUILayout.TextField(variableName, (string)val);
                 }
                 else if (type.IsEnum)
                 {
-                    val = EditorGUILayout.EnumPopup(name, (Enum)val);
+                    val = EditorGUILayout.EnumPopup(variableName, (Enum)val);
                 }
                 else
                 {
@@ -146,11 +218,33 @@ namespace Unity.Netcode.Editor
             }
             else
             {
-                EditorGUILayout.LabelField(name, EditorStyles.wordWrappedLabel);
+                EditorGUILayout.LabelField(variableName, EditorStyles.wordWrappedLabel);
                 EditorGUILayout.SelectableLabel(val.ToString(), EditorStyles.wordWrappedLabel);
             }
+            GUILayout.Label(m_NetworkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkVariableLabelGuiContent).x));
         }
 
+        private void RenderNetworkListValueType<T>(int index, NetworkList<T> networkList)
+            where T : unmanaged, IEquatable<T>
+        {
+            string variableName = m_NetworkVariableNames[index];
+
+            string value = "";
+            bool addComma = false;
+            foreach (var v in networkList)
+            {
+                if (addComma)
+                {
+                    value += ", ";
+                }
+                value += v.ToString();
+                addComma = true;
+            }
+            EditorGUILayout.LabelField(variableName, value);
+            GUILayout.Label(m_NetworkListLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkListLabelGuiContent).x));
+        }
+
+        /// <inheritdoc/>
         public override void OnInspectorGUI()
         {
             if (!m_Initialized)
@@ -178,7 +272,7 @@ namespace Unity.Netcode.Editor
             bool expanded = true;
             while (property.NextVisible(expanded))
             {
-                if (m_NetworkVariableNames.Contains(property.name))
+                if (m_NetworkVariableNames.Contains(ObjectNames.NicifyVariableName(property.name)))
                 {
                     // Skip rendering of NetworkVars, they have special rendering
                     continue;
@@ -211,5 +305,160 @@ namespace Unity.Netcode.Editor
             serializedObject.ApplyModifiedProperties();
             EditorGUI.EndChangeCheck();
         }
+
+        /// <summary>
+        /// Invoked once when a NetworkBehaviour component is
+        /// displayed in the inspector view.
+        /// </summary>
+        private void OnEnable()
+        {
+            // This can be null and throw an exception when running test runner in the editor
+            if (target == null)
+            {
+                return;
+            }
+            // When we first add a NetworkBehaviour this editor will be enabled
+            // so we go ahead and check for an already existing NetworkObject here
+            CheckForNetworkObject((target as NetworkBehaviour).gameObject);
+        }
+
+        /// <summary>
+        /// Recursively finds the root parent of a <see cref="Transform"/>
+        /// </summary>
+        /// <param name="transform">The current <see cref="Transform"/> we are inspecting for a parent</param>
+        /// <returns>the root parent for the first <see cref="Transform"/> passed into the method</returns>
+        public static Transform GetRootParentTransform(Transform transform)
+        {
+            if (transform.parent == null || transform.parent == transform)
+            {
+                return transform;
+            }
+            return GetRootParentTransform(transform.parent);
+        }
+
+        /// <summary>
+        /// Used to determine if a GameObject has one or more NetworkBehaviours but
+        /// does not already have a NetworkObject component.  If not it will notify
+        /// the user that NetworkBehaviours require a NetworkObject.
+        /// </summary>
+        /// <param name="gameObject"><see cref="GameObject"/> to start checking for a <see cref="NetworkObject"/></param>
+        /// <param name="networkObjectRemoved">used internally</param>
+        public static void CheckForNetworkObject(GameObject gameObject, bool networkObjectRemoved = false)
+        {
+            // If there are no NetworkBehaviours or gameObjects then exit early
+            // If we are in play mode and a user is inspecting something then exit early (we don't add NetworkObjects to something when in play mode)
+            if (EditorApplication.isPlaying || gameObject == null || (gameObject.GetComponent<NetworkBehaviour>() == null && gameObject.GetComponentInChildren<NetworkBehaviour>() == null))
+            {
+                return;
+            }
+
+            // Now get the root parent transform to the current GameObject (or itself)
+            var rootTransform = GetRootParentTransform(gameObject.transform);
+            if (!rootTransform.TryGetComponent<NetworkManager>(out var networkManager))
+            {
+                networkManager = rootTransform.GetComponentInChildren<NetworkManager>();
+            }
+
+            // If there is a NetworkManager, then notify the user that a NetworkManager cannot have NetworkBehaviour components
+            if (networkManager != null)
+            {
+                var networkBehaviours = networkManager.gameObject.GetComponents<NetworkBehaviour>();
+                var networkBehavioursChildren = networkManager.gameObject.GetComponentsInChildren<NetworkBehaviour>();
+                if (networkBehaviours.Length > 0 || networkBehavioursChildren.Length > 0)
+                {
+                    if (EditorUtility.DisplayDialog("NetworkBehaviour or NetworkManager Cannot Be Added", $"{nameof(NetworkManager)}s cannot have {nameof(NetworkBehaviour)} components added to the root parent or any of its children." +
+                        $" Would you like to remove the NetworkManager or NetworkBehaviour?", "NetworkManager", "NetworkBehaviour"))
+                    {
+                        DestroyImmediate(networkManager);
+                    }
+                    else
+                    {
+                        foreach (var networkBehaviour in networkBehaviours)
+                        {
+                            DestroyImmediate(networkBehaviour);
+                        }
+
+                        foreach (var networkBehaviour in networkBehaviours)
+                        {
+                            DestroyImmediate(networkBehaviour);
+                        }
+                    }
+                    return;
+                }
+            }
+
+            // Otherwise, check to see if there is any NetworkObject from the root GameObject down to all children.
+            // If not, notify the user that NetworkBehaviours require that the relative GameObject has a NetworkObject component.
+            if (!rootTransform.TryGetComponent<NetworkObject>(out var networkObject))
+            {
+                networkObject = rootTransform.GetComponentInChildren<NetworkObject>();
+
+                if (networkObject == null)
+                {
+                    // If we are removing a NetworkObject but there is still one or more NetworkBehaviour components
+                    // and the user has already turned "Auto-Add NetworkObject" on when first notified about the requirement
+                    // then just send a reminder to the user why the NetworkObject they just deleted seemingly "re-appeared"
+                    // again.
+                    if (networkObjectRemoved && NetcodeForGameObjectsEditorSettings.GetAutoAddNetworkObjectSetting())
+                    {
+                        Debug.LogWarning($"{gameObject.name} still has {nameof(NetworkBehaviour)}s and Auto-Add NetworkObjects is enabled. A NetworkObject is being added back to {gameObject.name}.");
+                        Debug.Log($"To reset Auto-Add NetworkObjects: Select the Netcode->General->Reset Auto-Add NetworkObject menu item.");
+                    }
+
+                    // Notify and provide the option to add it one time, always add a NetworkObject, or do nothing and let the user manually add it
+                    if (EditorUtility.DisplayDialog($"{nameof(NetworkBehaviour)}s require a {nameof(NetworkObject)}",
+                    $"{gameObject.name} does not have a {nameof(NetworkObject)} component.  Would you like to add one now?", "Yes", "No (manually add it)",
+                    DialogOptOutDecisionType.ForThisMachine, NetcodeForGameObjectsEditorSettings.AutoAddNetworkObjectIfNoneExists))
+                    {
+                        gameObject.AddComponent<NetworkObject>();
+                        var activeScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
+                        UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty(activeScene);
+                        UnityEditor.SceneManagement.EditorSceneManager.SaveScene(activeScene);
+                    }
+                }
+            }
+
+            if (networkObject != null)
+            {
+                OrderNetworkObject(networkObject);
+            }
+        }
+
+        // Assures the NetworkObject precedes any NetworkBehaviour on the same GameObject as the NetworkObject
+        private static void OrderNetworkObject(NetworkObject networkObject)
+        {
+            var monoBehaviours = networkObject.gameObject.GetComponents<MonoBehaviour>();
+            var networkObjectIndex = 0;
+            var firstNetworkBehaviourIndex = -1;
+            for (int i = 0; i < monoBehaviours.Length; i++)
+            {
+                if (monoBehaviours[i] == networkObject)
+                {
+                    networkObjectIndex = i;
+                    break;
+                }
+
+                var networkBehaviour = monoBehaviours[i] as NetworkBehaviour;
+                if (networkBehaviour != null)
+                {
+                    // Get the index of the first NetworkBehaviour Component
+                    if (firstNetworkBehaviourIndex == -1)
+                    {
+                        firstNetworkBehaviourIndex = i;
+                    }
+                }
+            }
+
+            if (firstNetworkBehaviourIndex != -1 && networkObjectIndex > firstNetworkBehaviourIndex)
+            {
+                var positionsToMove = networkObjectIndex - firstNetworkBehaviourIndex;
+                for (int i = 0; i < positionsToMove; i++)
+                {
+                    UnityEditorInternal.ComponentUtility.MoveComponentUp(networkObject);
+                }
+
+                EditorUtility.SetDirty(networkObject.gameObject);
+            }
+        }
     }
 }

Editor/NetworkManagerEditor.cs

@@ -1,21 +1,27 @@
+#if UNITY_2022_3_OR_NEWER && (RELAY_SDK_INSTALLED && !UNITY_WEBGL ) || (RELAY_SDK_INSTALLED && UNITY_WEBGL && UTP_TRANSPORT_2_0_ABOVE)
+#define RELAY_INTEGRATION_AVAILABLE
+#endif
 using System;
 using System.Collections.Generic;
+using System.IO;
+using Unity.Netcode.Editor.Configuration;
 using UnityEditor;
 using UnityEngine;
-using UnityEditorInternal;
 
 namespace Unity.Netcode.Editor
 {
+    /// <summary>
+    /// This <see cref="CustomEditor"/> handles the translation between the <see cref="NetworkConfig"/> and
+    /// the <see cref="NetworkManager"/> properties.
+    /// </summary>
     [CustomEditor(typeof(NetworkManager), true)]
     [CanEditMultipleObjects]
     public class NetworkManagerEditor : UnityEditor.Editor
     {
-        internal const string InstallMultiplayerToolsTipDismissedPlayerPrefKey = "Netcode_Tip_InstallMPTools_Dismissed";
         private static GUIStyle s_CenteredWordWrappedLabelStyle;
         private static GUIStyle s_HelpBoxStyle;
 
         // Properties
-        private SerializedProperty m_DontDestroyOnLoadProperty;
         private SerializedProperty m_RunInBackgroundProperty;
         private SerializedProperty m_LogLevelProperty;
 
@@ -37,8 +43,7 @@ namespace Unity.Netcode.Editor
         private SerializedProperty m_NetworkIdRecycleDelayProperty;
         private SerializedProperty m_RpcHashSizeProperty;
         private SerializedProperty m_LoadSceneTimeOutProperty;
-
-        private ReorderableList m_NetworkPrefabsList;
+        private SerializedProperty m_PrefabsList;
 
         private NetworkManager m_NetworkManager;
         private bool m_Initialized;
@@ -46,6 +51,27 @@ namespace Unity.Netcode.Editor
         private readonly List<Type> m_TransportTypes = new List<Type>();
         private string[] m_TransportNames = { "Select transport..." };
 
+        /// <inheritdoc/>
+        public override void OnInspectorGUI()
+        {
+            Initialize();
+            CheckNullProperties();
+
+#if !MULTIPLAYER_TOOLS
+            DrawInstallMultiplayerToolsTip();
+#endif
+
+            if (m_NetworkManager.IsServer || m_NetworkManager.IsClient)
+            {
+                DrawDisconnectButton();
+            }
+            else
+            {
+                DrawAllPropertyFields();
+                ShowStartConnectionButtons();
+            }
+        }
+
         private void ReloadTransports()
         {
             m_TransportTypes.Clear();
@@ -58,7 +84,7 @@ namespace Unity.Netcode.Editor
 
                 foreach (var type in types)
                 {
-                    if (type.IsSubclassOf(typeof(NetworkTransport)) && type.GetCustomAttributes(typeof(DontShowInTransportDropdownAttribute), true).Length == 0)
+                    if (type.IsSubclassOf(typeof(NetworkTransport)) && !type.IsSubclassOf(typeof(TestingNetworkTransport)) && type != typeof(TestingNetworkTransport))
                     {
                         m_TransportTypes.Add(type);
                     }
@@ -85,7 +111,6 @@ namespace Unity.Netcode.Editor
             m_NetworkManager = (NetworkManager)target;
 
             // Base properties
-            m_DontDestroyOnLoadProperty = serializedObject.FindProperty(nameof(NetworkManager.DontDestroy));
             m_RunInBackgroundProperty = serializedObject.FindProperty(nameof(NetworkManager.RunInBackground));
             m_LogLevelProperty = serializedObject.FindProperty(nameof(NetworkManager.LogLevel));
             m_NetworkConfigProperty = serializedObject.FindProperty(nameof(NetworkManager.NetworkConfig));
@@ -104,7 +129,9 @@ namespace Unity.Netcode.Editor
             m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay");
             m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
             m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut");
-
+            m_PrefabsList = m_NetworkConfigProperty
+                .FindPropertyRelative(nameof(NetworkConfig.Prefabs))
+                .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
 
             ReloadTransports();
         }
@@ -112,7 +139,6 @@ namespace Unity.Netcode.Editor
         private void CheckNullProperties()
         {
             // Base properties
-            m_DontDestroyOnLoadProperty = serializedObject.FindProperty(nameof(NetworkManager.DontDestroy));
             m_RunInBackgroundProperty = serializedObject.FindProperty(nameof(NetworkManager.RunInBackground));
             m_LogLevelProperty = serializedObject.FindProperty(nameof(NetworkManager.LogLevel));
             m_NetworkConfigProperty = serializedObject.FindProperty(nameof(NetworkManager.NetworkConfig));
@@ -131,257 +157,337 @@ namespace Unity.Netcode.Editor
             m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay");
             m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
             m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut");
+            m_PrefabsList = m_NetworkConfigProperty
+                .FindPropertyRelative(nameof(NetworkConfig.Prefabs))
+                .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
         }
 
-        private void OnEnable()
+        private void DrawAllPropertyFields()
         {
-            m_NetworkPrefabsList = new ReorderableList(serializedObject, serializedObject.FindProperty(nameof(NetworkManager.NetworkConfig)).FindPropertyRelative(nameof(NetworkConfig.NetworkPrefabs)), true, true, true, true);
-            m_NetworkPrefabsList.elementHeightCallback = index =>
+            serializedObject.Update();
+            EditorGUILayout.PropertyField(m_RunInBackgroundProperty);
+            EditorGUILayout.PropertyField(m_LogLevelProperty);
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(m_PlayerPrefabProperty);
+            EditorGUILayout.Space();
+
+            DrawPrefabListField();
+
+            EditorGUILayout.Space();
+
+            EditorGUILayout.LabelField("General", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_ProtocolVersionProperty);
+
+            DrawTransportField();
+
+            EditorGUILayout.PropertyField(m_TickRateProperty);
+
+            EditorGUILayout.LabelField("Performance", EditorStyles.boldLabel);
+
+            EditorGUILayout.PropertyField(m_EnsureNetworkVariableLengthSafetyProperty);
+
+            EditorGUILayout.LabelField("Connection", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_ConnectionApprovalProperty);
+
+            using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.ConnectionApproval))
             {
-                var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
-                var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
-                var networkOverrideInt = networkOverrideProp.enumValueIndex;
-
-                return 8 + (networkOverrideInt == 0 ? EditorGUIUtility.singleLineHeight : (EditorGUIUtility.singleLineHeight * 2) + 5);
-            };
-            m_NetworkPrefabsList.drawElementCallback = (rect, index, isActive, isFocused) =>
-            {
-                rect.y += 5;
-
-                var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
-                var networkPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Prefab));
-                var networkSourceHashProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourceHashToOverride));
-                var networkSourcePrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourcePrefabToOverride));
-                var networkTargetPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.OverridingTargetPrefab));
-                var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
-                var networkOverrideInt = networkOverrideProp.enumValueIndex;
-                var networkOverrideEnum = (NetworkPrefabOverride)networkOverrideInt;
-                EditorGUI.LabelField(new Rect(rect.x + rect.width - 70, rect.y, 60, EditorGUIUtility.singleLineHeight), "Override");
-                if (networkOverrideEnum == NetworkPrefabOverride.None)
-                {
-                    if (EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), false))
-                    {
-                        networkOverrideProp.enumValueIndex = (int)NetworkPrefabOverride.Prefab;
-                    }
-                }
-                else
-                {
-                    if (!EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), true))
-                    {
-                        networkOverrideProp.enumValueIndex = 0;
-                        networkOverrideEnum = NetworkPrefabOverride.None;
-                    }
-                }
-
-                if (networkOverrideEnum == NetworkPrefabOverride.None)
-                {
-                    EditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width - 80, EditorGUIUtility.singleLineHeight), networkPrefabProp, GUIContent.none);
-                }
-                else
-                {
-                    networkOverrideProp.enumValueIndex = GUI.Toolbar(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), networkOverrideInt - 1, new[] { "Prefab", "Hash" }) + 1;
-
-                    if (networkOverrideEnum == NetworkPrefabOverride.Prefab)
-                    {
-                        EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourcePrefabProp, GUIContent.none);
-                    }
-                    else
-                    {
-                        EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourceHashProp, GUIContent.none);
-                    }
-
-                    rect.y += EditorGUIUtility.singleLineHeight + 5;
-
-                    EditorGUI.LabelField(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), "Overriding Prefab");
-                    EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 110, EditorGUIUtility.singleLineHeight), networkTargetPrefabProp, GUIContent.none);
-                }
-            };
-            m_NetworkPrefabsList.drawHeaderCallback = rect => EditorGUI.LabelField(rect, "NetworkPrefabs");
-        }
-
-        public override void OnInspectorGUI()
-        {
-            Initialize();
-            CheckNullProperties();
-
-#if !MULTIPLAYER_TOOLS
-            DrawInstallMultiplayerToolsTip();
-#endif
-
-            {
-                var iterator = serializedObject.GetIterator();
-
-                for (bool enterChildren = true; iterator.NextVisible(enterChildren); enterChildren = false)
-                {
-                    using (new EditorGUI.DisabledScope("m_Script" == iterator.propertyPath))
-                    {
-                        EditorGUILayout.PropertyField(iterator, false);
-                    }
-                }
+                EditorGUILayout.PropertyField(m_ClientConnectionBufferTimeoutProperty);
             }
 
-            if (!m_NetworkManager.IsServer && !m_NetworkManager.IsClient)
+            EditorGUILayout.LabelField("Spawning", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
+
+            EditorGUILayout.PropertyField(m_RecycleNetworkIdsProperty);
+
+            using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.RecycleNetworkIds))
             {
-                serializedObject.Update();
-                EditorGUILayout.PropertyField(m_DontDestroyOnLoadProperty);
-                EditorGUILayout.PropertyField(m_RunInBackgroundProperty);
-                EditorGUILayout.PropertyField(m_LogLevelProperty);
-                EditorGUILayout.Space();
+                EditorGUILayout.PropertyField(m_NetworkIdRecycleDelayProperty);
+            }
 
-                EditorGUILayout.PropertyField(m_PlayerPrefabProperty);
-                EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Bandwidth", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_RpcHashSizeProperty);
 
-                m_NetworkPrefabsList.DoLayoutList();
-                EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Scene Management", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_EnableSceneManagementProperty);
 
-                EditorGUILayout.LabelField("General", EditorStyles.boldLabel);
-                EditorGUILayout.PropertyField(m_ProtocolVersionProperty);
+            using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.EnableSceneManagement))
+            {
+                EditorGUILayout.PropertyField(m_LoadSceneTimeOutProperty);
+            }
 
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DrawTransportField()
+        {
+#if RELAY_INTEGRATION_AVAILABLE
+            var useRelay = EditorPrefs.GetBool(m_UseEasyRelayIntegrationKey, false);
+#else
+            var useRelay = false;
+#endif
+
+            if (useRelay)
+            {
+                EditorGUILayout.HelpBox("Test connection with relay is enabled, so the default Unity Transport will be used", MessageType.Info);
+                GUI.enabled = false;
                 EditorGUILayout.PropertyField(m_NetworkTransportProperty);
+                GUI.enabled = true;
+                return;
+            }
 
-                if (m_NetworkTransportProperty.objectReferenceValue == null)
+            EditorGUILayout.PropertyField(m_NetworkTransportProperty);
+
+            if (m_NetworkTransportProperty.objectReferenceValue == null)
+            {
+                EditorGUILayout.HelpBox("You have no transport selected. A transport is required for netcode to work. Which one do you want?", MessageType.Warning);
+
+                int selection = EditorGUILayout.Popup(0, m_TransportNames);
+
+                if (selection > 0)
                 {
-                    EditorGUILayout.HelpBox("You have no transport selected. A transport is required for netcode to work. Which one do you want?", MessageType.Warning);
+                    ReloadTransports();
 
-                    int selection = EditorGUILayout.Popup(0, m_TransportNames);
+                    var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]) ?? m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
+                    m_NetworkTransportProperty.objectReferenceValue = transportComponent;
 
-                    if (selection > 0)
-                    {
-                        ReloadTransports();
-
-                        var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]);
-
-                        if (transportComponent == null)
-                        {
-                            transportComponent = m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
-                        }
-
-                        m_NetworkTransportProperty.objectReferenceValue = transportComponent;
-
-                        Repaint();
-                    }
+                    Repaint();
                 }
+            }
+        }
 
-                EditorGUILayout.PropertyField(m_TickRateProperty);
+#if RELAY_INTEGRATION_AVAILABLE
+        private readonly string m_UseEasyRelayIntegrationKey = "NetworkManagerUI_UseRelay_" + Application.dataPath.GetHashCode();
+        private string m_JoinCode = "";
+        private string m_StartConnectionError = null;
+        private string m_Region = "";
 
-                EditorGUILayout.LabelField("Performance", EditorStyles.boldLabel);
+        // wait for next frame so that ImGui finishes the current frame
+        private static void RunNextFrame(Action action) => EditorApplication.delayCall += () => action();
+#endif
 
-                EditorGUILayout.PropertyField(m_EnsureNetworkVariableLengthSafetyProperty);
+        private void ShowStartConnectionButtons()
+        {
+            EditorGUILayout.LabelField("Start Connection", EditorStyles.boldLabel);
 
-                EditorGUILayout.LabelField("Connection", EditorStyles.boldLabel);
-                EditorGUILayout.PropertyField(m_ConnectionApprovalProperty);
+#if RELAY_INTEGRATION_AVAILABLE
+            // use editor prefs to persist the setting when entering / leaving play mode / exiting Unity
+            var useRelay = EditorPrefs.GetBool(m_UseEasyRelayIntegrationKey, false);
+            GUILayout.BeginHorizontal();
+            useRelay = GUILayout.Toggle(useRelay, "Try Relay in the Editor");
 
-                using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.ConnectionApproval))
+            var icon = EditorGUIUtility.IconContent("_Help");
+            icon.tooltip = "This will help you test relay in the Editor. Click here to know how to integrate Relay in your build";
+            if (GUILayout.Button(icon, GUIStyle.none, GUILayout.Width(20)))
+            {
+                Application.OpenURL("https://docs-multiplayer.unity3d.com/netcode/current/relay/");
+            }
+            GUILayout.EndHorizontal();
+
+            EditorPrefs.SetBool(m_UseEasyRelayIntegrationKey, useRelay);
+            if (useRelay && !Application.isPlaying && !CloudProjectSettings.projectBound)
+            {
+                EditorGUILayout.HelpBox("To use relay, you need to setup your project in the Project Settings in the Services section.", MessageType.Warning);
+                if (GUILayout.Button("Open Project settings"))
                 {
-                    EditorGUILayout.PropertyField(m_ClientConnectionBufferTimeoutProperty);
+                    SettingsService.OpenProjectSettings("Project/Services");
                 }
+            }
+#else
+            var useRelay = false;
+#endif
 
-                EditorGUILayout.LabelField("Spawning", EditorStyles.boldLabel);
-                EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
+            string buttonDisabledReasonSuffix = "";
 
+            if (!EditorApplication.isPlaying)
+            {
+                buttonDisabledReasonSuffix = ". This can only be done in play mode";
+                GUI.enabled = false;
+            }
 
-                EditorGUILayout.PropertyField(m_RecycleNetworkIdsProperty);
-
-                using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.RecycleNetworkIds))
-                {
-                    EditorGUILayout.PropertyField(m_NetworkIdRecycleDelayProperty);
-                }
-
-                EditorGUILayout.LabelField("Bandwidth", EditorStyles.boldLabel);
-                EditorGUILayout.PropertyField(m_RpcHashSizeProperty);
-
-                EditorGUILayout.LabelField("Scene Management", EditorStyles.boldLabel);
-                EditorGUILayout.PropertyField(m_EnableSceneManagementProperty);
-
-                using (new EditorGUI.DisabledScope(!m_NetworkManager.NetworkConfig.EnableSceneManagement))
-                {
-                    EditorGUILayout.PropertyField(m_LoadSceneTimeOutProperty);
-                }
-
-                serializedObject.ApplyModifiedProperties();
-
-
-                // Start buttons below
-                {
-                    string buttonDisabledReasonSuffix = "";
-
-                    if (!EditorApplication.isPlaying)
-                    {
-                        buttonDisabledReasonSuffix = ". This can only be done in play mode";
-                        GUI.enabled = false;
-                    }
-
-                    if (GUILayout.Button(new GUIContent("Start Host", "Starts a host instance" + buttonDisabledReasonSuffix)))
-                    {
-                        m_NetworkManager.StartHost();
-                    }
-
-                    if (GUILayout.Button(new GUIContent("Start Server", "Starts a server instance" + buttonDisabledReasonSuffix)))
-                    {
-                        m_NetworkManager.StartServer();
-                    }
-
-                    if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance" + buttonDisabledReasonSuffix)))
-                    {
-                        m_NetworkManager.StartClient();
-                    }
-
-                    if (!EditorApplication.isPlaying)
-                    {
-                        GUI.enabled = true;
-                    }
-                }
+            if (useRelay)
+            {
+                ShowStartConnectionButtons_Relay(buttonDisabledReasonSuffix);
             }
             else
             {
-                string instanceType = string.Empty;
+                ShowStartConnectionButtons_Standard(buttonDisabledReasonSuffix);
+            }
 
-                if (m_NetworkManager.IsHost)
-                {
-                    instanceType = "Host";
-                }
-                else if (m_NetworkManager.IsServer)
-                {
-                    instanceType = "Server";
-                }
-                else if (m_NetworkManager.IsClient)
-                {
-                    instanceType = "Client";
-                }
-
-                EditorGUILayout.HelpBox("You cannot edit the NetworkConfig when a " + instanceType + " is running.", MessageType.Info);
-
-                if (GUILayout.Button(new GUIContent("Stop " + instanceType, "Stops the " + instanceType + " instance.")))
-                {
-                    m_NetworkManager.Shutdown();
-                }
+            if (!EditorApplication.isPlaying)
+            {
+                GUI.enabled = true;
             }
         }
 
+        private void ShowStartConnectionButtons_Relay(string buttonDisabledReasonSuffix)
+        {
+#if RELAY_INTEGRATION_AVAILABLE
+
+            void AddStartServerOrHostButton(bool isServer)
+            {
+                var type = isServer ? "Server" : "Host";
+                if (GUILayout.Button(new GUIContent($"Start {type}", $"Starts a {type} instance with Relay{buttonDisabledReasonSuffix}")))
+                {
+                    m_StartConnectionError = null;
+                    RunNextFrame(async () =>
+                    {
+                        try
+                        {
+                            var (joinCode, allocation) = isServer ? await m_NetworkManager.StartServerWithRelay() : await m_NetworkManager.StartHostWithRelay();
+                            m_JoinCode = joinCode;
+                            m_Region = allocation.Region;
+                            Repaint();
+                        }
+                        catch (Exception e)
+                        {
+                            m_StartConnectionError = e.Message;
+                            throw;
+                        }
+                    });
+                }
+            }
+
+            AddStartServerOrHostButton(isServer: true);
+            AddStartServerOrHostButton(isServer: false);
+
+            GUILayout.Space(8f);
+            m_JoinCode = EditorGUILayout.TextField("Relay Join Code", m_JoinCode);
+            if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance with Relay" + buttonDisabledReasonSuffix)))
+            {
+                m_StartConnectionError = null;
+                RunNextFrame(async () =>
+                {
+                    if (string.IsNullOrEmpty(m_JoinCode))
+                    {
+                        m_StartConnectionError = "Please provide a join code!";
+                        return;
+                    }
+
+                    try
+                    {
+                        var allocation = await m_NetworkManager.StartClientWithRelay(m_JoinCode);
+                        m_Region = allocation.Region;
+                        Repaint();
+                    }
+                    catch (Exception e)
+                    {
+                        m_StartConnectionError = e.Message;
+                        throw;
+                    }
+                });
+            }
+
+            if (Application.isPlaying && !string.IsNullOrEmpty(m_StartConnectionError))
+            {
+                EditorGUILayout.HelpBox(m_StartConnectionError, MessageType.Error);
+            }
+#endif
+        }
+
+        private void ShowStartConnectionButtons_Standard(string buttonDisabledReasonSuffix)
+        {
+            if (GUILayout.Button(new GUIContent("Start Host", "Starts a host instance" + buttonDisabledReasonSuffix)))
+            {
+                m_NetworkManager.StartHost();
+            }
+
+            if (GUILayout.Button(new GUIContent("Start Server", "Starts a server instance" + buttonDisabledReasonSuffix)))
+            {
+                m_NetworkManager.StartServer();
+            }
+
+            if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance" + buttonDisabledReasonSuffix)))
+            {
+                m_NetworkManager.StartClient();
+            }
+        }
+
+        private void DrawDisconnectButton()
+        {
+            string instanceType = string.Empty;
+
+            if (m_NetworkManager.IsHost)
+            {
+                instanceType = "Host";
+            }
+            else if (m_NetworkManager.IsServer)
+            {
+                instanceType = "Server";
+            }
+            else if (m_NetworkManager.IsClient)
+            {
+                instanceType = "Client";
+            }
+
+            EditorGUILayout.HelpBox($"You cannot edit the NetworkConfig when a {instanceType} is running.", MessageType.Info);
+
+#if RELAY_INTEGRATION_AVAILABLE
+            if (!string.IsNullOrEmpty(m_JoinCode) && !string.IsNullOrEmpty(m_Region))
+            {
+                var style = new GUIStyle(EditorStyles.helpBox)
+                {
+                    fontSize = 10,
+                    alignment = TextAnchor.MiddleCenter,
+                };
+
+                GUILayout.BeginHorizontal(style, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false), GUILayout.MaxWidth(800));
+                GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(k_InfoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
+                GUILayout.Space(25f);
+                GUILayout.BeginVertical();
+                GUILayout.Space(4f);
+                GUILayout.Label($"Connected via relay ({m_Region}).\nJoin code: {m_JoinCode}", EditorStyles.miniLabel, GUILayout.ExpandHeight(true));
+
+                if (GUILayout.Button("Copy code", GUILayout.ExpandHeight(true)))
+                {
+                    GUIUtility.systemCopyBuffer = m_JoinCode;
+                }
+
+                GUILayout.Space(4f);
+                GUILayout.EndVertical();
+                GUILayout.Space(2f);
+                GUILayout.EndHorizontal();
+            }
+#endif
+
+            if (GUILayout.Button(new GUIContent($"Stop {instanceType}", $"Stops the {instanceType} instance.")))
+            {
+#if RELAY_INTEGRATION_AVAILABLE
+                m_JoinCode = "";
+#endif
+                m_NetworkManager.Shutdown();
+            }
+        }
+
+        private const string k_InfoIconName = "console.infoicon";
         private static void DrawInstallMultiplayerToolsTip()
         {
             const string getToolsText = "Access additional tools for multiplayer development by installing the Multiplayer Tools package in the Package Manager.";
             const string openDocsButtonText = "Open Docs";
             const string dismissButtonText = "Dismiss";
-            const string targetUrl = "https://docs-multiplayer.unity3d.com/docs/tools/install-tools";
-            const string infoIconName = "console.infoicon";
+            const string targetUrl = "https://docs-multiplayer.unity3d.com/tools/current/install-tools";
 
-            if (PlayerPrefs.GetInt(InstallMultiplayerToolsTipDismissedPlayerPrefKey, 0) != 0)
+
+            if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0)
             {
                 return;
             }
 
             if (s_CenteredWordWrappedLabelStyle == null)
             {
-                s_CenteredWordWrappedLabelStyle = new GUIStyle(GUI.skin.label);
-                s_CenteredWordWrappedLabelStyle.wordWrap = true;
-                s_CenteredWordWrappedLabelStyle.alignment = TextAnchor.MiddleLeft;
+                s_CenteredWordWrappedLabelStyle = new GUIStyle(GUI.skin.label)
+                {
+                    wordWrap = true,
+                    alignment = TextAnchor.MiddleLeft
+                };
             }
 
             if (s_HelpBoxStyle == null)
             {
-                s_HelpBoxStyle = new GUIStyle(EditorStyles.helpBox);
-                s_HelpBoxStyle.padding = new RectOffset(10, 10, 10, 10);
+                s_HelpBoxStyle = new GUIStyle(EditorStyles.helpBox)
+                {
+                    padding = new RectOffset(10, 10, 10, 10)
+                };
             }
 
             var openDocsButtonStyle = GUI.skin.button;
@@ -391,7 +497,7 @@ namespace Unity.Netcode.Editor
             GUILayout.FlexibleSpace();
             GUILayout.BeginHorizontal(s_HelpBoxStyle, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(false), GUILayout.MaxWidth(800));
             {
-                GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(infoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
+                GUILayout.Label(new GUIContent(EditorGUIUtility.IconContent(k_InfoIconName)), GUILayout.ExpandWidth(false), GUILayout.ExpandHeight(true));
                 GUILayout.Space(4);
                 GUILayout.Label(getToolsText, s_CenteredWordWrappedLabelStyle, GUILayout.ExpandHeight(true));
 
@@ -412,7 +518,7 @@ namespace Unity.Netcode.Editor
                 GUILayout.FlexibleSpace();
                 if (GUILayout.Button(dismissButtonText, dismissButtonStyle, GUILayout.ExpandWidth(false)))
                 {
-                    PlayerPrefs.SetInt(InstallMultiplayerToolsTipDismissedPlayerPrefKey, 1);
+                    NetcodeForGameObjectsEditorSettings.SetNetcodeInstallMultiplayerToolTips(1);
                 }
                 EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
                 GUILayout.FlexibleSpace();
@@ -424,5 +530,69 @@ namespace Unity.Netcode.Editor
 
             GUILayout.Space(10);
         }
+
+        private void DrawPrefabListField()
+        {
+            if (!m_NetworkManager.NetworkConfig.HasOldPrefabList())
+            {
+                if (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabsLists.Count == 0)
+                {
+                    EditorGUILayout.HelpBox("You have no prefab list selected. You will have to add your prefabs manually at runtime for netcode to work.", MessageType.Warning);
+                }
+
+                EditorGUILayout.PropertyField(m_PrefabsList);
+                return;
+            }
+
+            // Old format of prefab list
+            EditorGUILayout.HelpBox("Network Prefabs serialized in old format. Migrate to new format to edit the list.", MessageType.Info);
+            if (GUILayout.Button(new GUIContent("Migrate Prefab List", "Converts the old format Network Prefab list to a new Scriptable Object")))
+            {
+                // Default directory
+                var directory = "Assets/";
+                var assetPath = AssetDatabase.GetAssetPath(m_NetworkManager);
+                if (assetPath == "")
+                {
+                    assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(m_NetworkManager);
+                }
+
+                if (assetPath != "")
+                {
+                    directory = Path.GetDirectoryName(assetPath);
+                }
+                else
+                {
+
+#if UNITY_2021_1_OR_NEWER
+                    var prefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
+#else
+                    var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
+#endif
+                    if (prefabStage != null)
+                    {
+                        var prefabPath = prefabStage.assetPath;
+                        if (!string.IsNullOrEmpty(prefabPath))
+                        {
+                            directory = Path.GetDirectoryName(prefabPath);
+                        }
+                    }
+
+                    if (m_NetworkManager.gameObject.scene != null)
+                    {
+                        var scenePath = m_NetworkManager.gameObject.scene.path;
+                        if (!string.IsNullOrEmpty(scenePath))
+                        {
+                            directory = Path.GetDirectoryName(scenePath);
+                        }
+                    }
+                }
+
+                var networkPrefabs = m_NetworkManager.NetworkConfig.MigrateOldNetworkPrefabsToNetworkPrefabsList();
+                string path = Path.Combine(directory, $"NetworkPrefabs-{m_NetworkManager.GetInstanceID()}.asset");
+                Debug.Log("Saving migrated Network Prefabs List to " + path);
+                AssetDatabase.CreateAsset(networkPrefabs, path);
+                EditorUtility.SetDirty(m_NetworkManager);
+            }
+        }
     }
 }

Editor/NetworkManagerHelper.cs

@@ -0,0 +1,217 @@
+using System.Collections.Generic;
+using System.Linq;
+using Unity.Netcode.Editor.Configuration;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Unity.Netcode.Editor
+{
+#if UNITY_EDITOR
+    /// <summary>
+    /// Specialized editor specific NetworkManager code
+    /// </summary>
+    public class NetworkManagerHelper : NetworkManager.INetworkManagerHelper
+    {
+        internal static NetworkManagerHelper Singleton;
+
+        // This is primarily to handle IntegrationTest scenarios where more than 1 NetworkManager could exist
+        private static Dictionary<NetworkManager, Transform> s_LastKnownNetworkManagerParents = new Dictionary<NetworkManager, Transform>();
+
+        /// <summary>
+        /// Initializes the singleton instance and registers for:
+        /// Hierarchy changed notification: to notify the user when they nest a NetworkManager
+        /// Play mode state change notification: to capture when entering or exiting play mode (currently only exiting)
+        /// </summary>
+        [InitializeOnLoadMethod]
+        private static void InitializeOnload()
+        {
+            Singleton = new NetworkManagerHelper();
+            NetworkManager.NetworkManagerHelper = Singleton;
+            EditorApplication.playModeStateChanged -= EditorApplication_playModeStateChanged;
+            EditorApplication.hierarchyChanged -= EditorApplication_hierarchyChanged;
+
+            EditorApplication.playModeStateChanged += EditorApplication_playModeStateChanged;
+            EditorApplication.hierarchyChanged += EditorApplication_hierarchyChanged;
+
+            // Initialize default values for new NetworkManagers
+            //
+            // When the default prefab list is enabled, this will default
+            // new NetworkManagers to using it.
+            //
+            // This will get run when new NetworkManagers are added, and
+            // when the user presses the "reset" button on a NetworkManager
+            // in the inspector.
+            NetworkManager.OnNetworkManagerReset = manager =>
+            {
+                var settings = NetcodeForGameObjectsProjectSettings.instance;
+                if (settings.GenerateDefaultNetworkPrefabs)
+                {
+                    manager.NetworkConfig = new NetworkConfig();
+                    manager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out _, true) };
+                }
+            };
+        }
+
+        private static void EditorApplication_playModeStateChanged(PlayModeStateChange playModeStateChange)
+        {
+            switch (playModeStateChange)
+            {
+                case PlayModeStateChange.ExitingEditMode:
+                    {
+                        s_LastKnownNetworkManagerParents.Clear();
+                        ScenesInBuildActiveSceneCheck();
+                        break;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// Detects if a user is trying to enter into play mode when both conditions are true:
+        /// - the currently active and open scene is not added to the scenes in build list
+        /// - an instance of a NetworkManager with scene management enabled can be found
+        /// If both conditions are met then the user is presented with a dialog box that
+        /// provides the user with the option to add the scene to the scenes in build list
+        /// before entering into play mode or the user can continue under those conditions.
+        ///
+        /// ** When scene management is enabled the user should treat all scenes that need to
+        /// be synchronized using network scene management as if they were preparing for a build.
+        /// Any scene that needs to be loaded at run time has to be included in the scenes in
+        /// build list. **
+        /// </summary>
+        private static void ScenesInBuildActiveSceneCheck()
+        {
+            var scenesList = EditorBuildSettings.scenes.ToList();
+            var activeScene = SceneManager.GetActiveScene();
+            var isSceneInBuildSettings = scenesList.Count((c) => c.path == activeScene.path) == 1;
+#if UNITY_2023_1_OR_NEWER
+            var networkManager = Object.FindFirstObjectByType<NetworkManager>();
+#else
+            var networkManager = Object.FindObjectOfType<NetworkManager>();
+#endif
+            if (!isSceneInBuildSettings && networkManager != null)
+            {
+                if (networkManager.NetworkConfig != null && networkManager.NetworkConfig.EnableSceneManagement)
+                {
+                    if (EditorUtility.DisplayDialog("Add Scene to Scenes in Build", $"The current scene was not found in the scenes" +
+                        $" in build and a {nameof(NetworkManager)} instance was found with scene management enabled! Clients will not be able " +
+                        $"to synchronize to this scene unless it is added to the scenes in build list.\n\nWould you like to add it now?",
+                        "Yes", "No - Continue"))
+                    {
+                        scenesList.Add(new EditorBuildSettingsScene(activeScene.path, true));
+                        EditorBuildSettings.scenes = scenesList.ToArray();
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Invoked only when the hierarchy changes
+        /// </summary>
+        private static void EditorApplication_hierarchyChanged()
+        {
+            var allNetworkManagers = Resources.FindObjectsOfTypeAll<NetworkManager>();
+            foreach (var networkManager in allNetworkManagers)
+            {
+                if (!networkManager.NetworkManagerCheckForParent())
+                {
+                    Singleton.CheckAndNotifyUserNetworkObjectRemoved(networkManager);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Handles notifying users that they cannot add a NetworkObject component
+        /// to a GameObject that also has a NetworkManager component. The NetworkObject
+        /// will always be removed.
+        /// GameObject + NetworkObject then NetworkManager = NetworkObject removed
+        /// GameObject + NetworkManager then NetworkObject = NetworkObject removed
+        /// Note: Since this is always invoked after <see cref="NetworkManagerCheckForParent"/>
+        /// we do not need to check for parent when searching for a NetworkObject component
+        /// </summary>
+        public void CheckAndNotifyUserNetworkObjectRemoved(NetworkManager networkManager, bool editorTest = false)
+        {
+            // Check for any NetworkObject at the same gameObject relative layer
+
+            if (!networkManager.gameObject.TryGetComponent<NetworkObject>(out var networkObject))
+            {
+                // if none is found, check to see if any children have a NetworkObject
+                networkObject = networkManager.gameObject.GetComponentInChildren<NetworkObject>();
+                if (networkObject == null)
+                {
+                    return;
+                }
+            }
+
+            if (!EditorApplication.isUpdating)
+            {
+                Object.DestroyImmediate(networkObject);
+
+                if (!EditorApplication.isPlaying && !editorTest)
+                {
+                    EditorUtility.DisplayDialog($"Removing {nameof(NetworkObject)}", NetworkManagerAndNetworkObjectNotAllowedMessage(), "OK");
+                }
+                else
+                {
+                    Debug.LogError(NetworkManagerAndNetworkObjectNotAllowedMessage());
+                }
+            }
+        }
+
+        public string NetworkManagerAndNetworkObjectNotAllowedMessage()
+        {
+            return $"A {nameof(GameObject)} cannot have both a {nameof(NetworkManager)} and {nameof(NetworkObject)} assigned to it or any children under it.";
+        }
+
+        /// <summary>
+        /// Handles notifying the user, via display dialog window, that they have nested a NetworkManager.
+        /// When in edit mode it provides the option to automatically fix the issue
+        /// When in play mode it just notifies the user when entering play mode as well as when the user
+        /// tries to start a network session while a NetworkManager is still nested.
+        /// </summary>
+        public bool NotifyUserOfNestedNetworkManager(NetworkManager networkManager, bool ignoreNetworkManagerCache = false, bool editorTest = false)
+        {
+            var gameObject = networkManager.gameObject;
+            var transform = networkManager.transform;
+            var isParented = transform.root != transform;
+
+            var message = NetworkManager.GenerateNestedNetworkManagerMessage(transform);
+            if (s_LastKnownNetworkManagerParents.ContainsKey(networkManager) && !ignoreNetworkManagerCache)
+            {
+                // If we have already notified the user, then don't notify them again
+                if (s_LastKnownNetworkManagerParents[networkManager] == transform.root)
+                {
+                    return isParented;
+                }
+                else // If we are no longer a child, then we can remove ourself from this list
+                if (transform.root == gameObject.transform)
+                {
+                    s_LastKnownNetworkManagerParents.Remove(networkManager);
+                }
+            }
+            if (!EditorApplication.isUpdating && isParented)
+            {
+                if (!EditorApplication.isPlaying && !editorTest)
+                {
+                    message += $"Click 'Auto-Fix' to automatically remove it from {transform.root.gameObject.name} or 'Manual-Fix' to fix it yourself in the hierarchy view.";
+                    if (EditorUtility.DisplayDialog("Invalid Nested NetworkManager", message, "Auto-Fix", "Manual-Fix"))
+                    {
+                        transform.parent = null;
+                        isParented = false;
+                    }
+                }
+                else
+                {
+                    Debug.LogError(message);
+                }
+
+                if (!s_LastKnownNetworkManagerParents.ContainsKey(networkManager) && isParented)
+                {
+                    s_LastKnownNetworkManagerParents.Add(networkManager, networkManager.transform.root);
+                }
+            }
+            return isParented;
+        }
+    }
+#endif
+}

Editor/NetworkManagerHelper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b26b53dc28ae1b5488bbbecc3e499bbc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/NetworkManagerRelayIntegration.cs

@@ -0,0 +1,120 @@
+#if UNITY_2022_3_OR_NEWER && (RELAY_SDK_INSTALLED && !UNITY_WEBGL ) || (RELAY_SDK_INSTALLED && UNITY_WEBGL && UTP_TRANSPORT_2_0_ABOVE)
+using System;
+using System.Threading.Tasks;
+using Unity.Netcode.Transports.UTP;
+using Unity.Networking.Transport.Relay;
+using Unity.Services.Authentication;
+using Unity.Services.Core;
+using Unity.Services.Relay;
+using Unity.Services.Relay.Models;
+
+namespace Unity.Netcode.Editor
+{
+    /// <summary>
+    /// Integration with Unity Relay SDK and Unity Transport that support the additional buttons in the NetworkManager inspector.
+    /// This code could theoretically be used at runtime, but we would like to avoid the additional dependencies in the runtime assembly of netcode for gameobjects.
+    /// </summary>
+    public static class NetworkManagerRelayIntegration
+    {
+
+#if UNITY_WEBGL
+        private const string k_DefaultConnectionType = "wss";
+#else
+        private const string k_DefaultConnectionType = "dtls";
+#endif
+
+        /// <summary>
+        /// Easy relay integration (host): it will initialize the unity services, sign in anonymously and start the host with a new relay allocation.
+        /// Note that this will force the use of Unity Transport.
+        /// </summary>
+        /// <param name="networkManager">The network manager that will start the connection</param>
+        /// <param name="maxConnections">Maximum number of connections to the created relay.</param>
+        /// <param name="connectionType">The connection type of the <see cref="RelayServerData"/> (wss, ws, dtls or udp) </param>
+        /// <returns>The join code that a potential client can use and the allocation</returns>
+        /// <exception cref="ServicesInitializationException"> Exception when there's an error during services initialization </exception>
+        /// <exception cref="UnityProjectNotLinkedException"> Exception when the project is not linked to a cloud project id </exception>
+        /// <exception cref="CircularDependencyException"> Exception when two registered <see cref="IInitializablePackage"/> depend on the other </exception>
+        /// <exception cref="AuthenticationException"> The task fails with the exception when the task cannot complete successfully due to Authentication specific errors. </exception>
+        /// <exception cref="RequestFailedException"> See <see cref="IAuthenticationService.SignInAnonymouslyAsync"/></exception>
+        /// <exception cref="ArgumentException">Thrown when the maxConnections argument fails validation in Relay Service SDK.</exception>
+        /// <exception cref="RelayServiceException">Thrown when the request successfully reach the Relay Allocation Service but results in an error.</exception>
+        internal static async Task<(string, Allocation)> StartHostWithRelay(this NetworkManager networkManager, int maxConnections = 5)
+        {
+            var codeAndAllocation = await InitializeAndCreateAllocAsync(networkManager, maxConnections, k_DefaultConnectionType);
+            return networkManager.StartHost() ? codeAndAllocation : (null, null);
+        }
+
+        /// <summary>
+        /// Easy relay integration (server): it will initialize the unity services, sign in anonymously and start the server with a new relay allocation.
+        /// Note that this will force the use of Unity Transport.
+        /// </summary>
+        /// <param name="networkManager">The network manager that will start the connection</param>
+        /// <param name="maxConnections">Maximum number of connections to the created relay.</param>
+        /// <returns>The join code that a potential client can use and the allocation.</returns>
+        /// <exception cref="ServicesInitializationException"> Exception when there's an error during services initialization </exception>
+        /// <exception cref="UnityProjectNotLinkedException"> Exception when the project is not linked to a cloud project id </exception>
+        /// <exception cref="CircularDependencyException"> Exception when two registered <see cref="IInitializablePackage"/> depend on the other </exception>
+        /// <exception cref="AuthenticationException"> The task fails with the exception when the task cannot complete successfully due to Authentication specific errors. </exception>
+        /// <exception cref="RequestFailedException"> See <see cref="IAuthenticationService.SignInAnonymouslyAsync"/></exception>
+        /// <exception cref="ArgumentException">Thrown when the maxConnections argument fails validation in Relay Service SDK.</exception>
+        /// <exception cref="RelayServiceException">Thrown when the request successfully reach the Relay Allocation Service but results in an error.</exception>
+        internal static async Task<(string, Allocation)> StartServerWithRelay(this NetworkManager networkManager, int maxConnections = 5)
+        {
+            var codeAndAllocation = await InitializeAndCreateAllocAsync(networkManager, maxConnections, k_DefaultConnectionType);
+            return networkManager.StartServer() ? codeAndAllocation : (null, null);
+        }
+
+        /// <summary>
+        /// Easy relay integration (client): it will initialize the unity services, sign in anonymously, join the relay with the given join code and start the client.
+        /// Note that this will force the use of Unity Transport.
+        /// </summary>
+        /// <param name="networkManager">The network manager that will start the connection</param>
+        /// <param name="joinCode">The join code of the allocation</param>
+        /// <exception cref="ServicesInitializationException"> Exception when there's an error during services initialization </exception>
+        /// <exception cref="UnityProjectNotLinkedException"> Exception when the project is not linked to a cloud project id </exception>
+        /// <exception cref="CircularDependencyException"> Exception when two registered <see cref="IInitializablePackage"/> depend on the other </exception>
+        /// <exception cref="AuthenticationException"> The task fails with the exception when the task cannot complete successfully due to Authentication specific errors. </exception>
+        /// <exception cref="RequestFailedException">Thrown when the request does not reach the Relay Allocation Service.</exception>
+        /// <exception cref="ArgumentException">Thrown if the joinCode has the wrong format.</exception>
+        /// <exception cref="RelayServiceException">Thrown when the request successfully reach the Relay Allocation Service but results in an error.</exception>
+        /// <returns>True if starting the client was successful</returns>
+        internal static async Task<JoinAllocation> StartClientWithRelay(this NetworkManager networkManager, string joinCode)
+        {
+            await UnityServices.InitializeAsync();
+            if (!AuthenticationService.Instance.IsSignedIn)
+            {
+                await AuthenticationService.Instance.SignInAnonymouslyAsync();
+            }
+            var joinAllocation = await RelayService.Instance.JoinAllocationAsync(joinCode: joinCode);
+            GetUnityTransport(networkManager, k_DefaultConnectionType).SetRelayServerData(new RelayServerData(joinAllocation, k_DefaultConnectionType));
+            return networkManager.StartClient() ? joinAllocation : null;
+        }
+
+        private static async Task<(string, Allocation)> InitializeAndCreateAllocAsync(NetworkManager networkManager, int maxConnections, string connectionType)
+        {
+            await UnityServices.InitializeAsync();
+            if (!AuthenticationService.Instance.IsSignedIn)
+            {
+                await AuthenticationService.Instance.SignInAnonymouslyAsync();
+            }
+            Allocation allocation = await RelayService.Instance.CreateAllocationAsync(maxConnections);
+            GetUnityTransport(networkManager, connectionType).SetRelayServerData(new RelayServerData(allocation, connectionType));
+            var joinCode = await RelayService.Instance.GetJoinCodeAsync(allocation.AllocationId);
+            return (joinCode, allocation);
+        }
+
+        private static UnityTransport GetUnityTransport(NetworkManager networkManager, string connectionType)
+        {
+            if (!networkManager.TryGetComponent<UnityTransport>(out var transport))
+            {
+                transport = networkManager.gameObject.AddComponent<UnityTransport>();
+            }
+#if UTP_TRANSPORT_2_0_ABOVE
+            transport.UseWebSockets = connectionType.StartsWith("ws"); // Probably should be part of SetRelayServerData, but not possible at this point
+#endif
+            networkManager.NetworkConfig.NetworkTransport = transport; // Force using UnityTransport
+            return transport;
+        }
+    }
+}
+#endif

Editor/NetworkManagerRelayIntegration.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 23b658b1c2e443109a8a131ef3632c9b
+timeCreated: 1698673251

Editor/NetworkObjectEditor.cs

@@ -1,9 +1,12 @@
 using System.Collections.Generic;
-using UnityEngine;
 using UnityEditor;
+using UnityEngine;
 
 namespace Unity.Netcode.Editor
 {
+    /// <summary>
+    /// The <see cref="CustomEditor"/> for <see cref="NetworkObject"/>
+    /// </summary>
     [CustomEditor(typeof(NetworkObject), true)]
     [CanEditMultipleObjects]
     public class NetworkObjectEditor : UnityEditor.Editor
@@ -12,6 +15,8 @@ namespace Unity.Netcode.Editor
         private NetworkObject m_NetworkObject;
         private bool m_ShowObservers;
 
+        private static readonly string[] k_HiddenFields = { "m_Script" };
+
         private void Initialize()
         {
             if (m_Initialized)
@@ -23,6 +28,7 @@ namespace Unity.Netcode.Editor
             m_NetworkObject = (NetworkObject)target;
         }
 
+        /// <inheritdoc/>
         public override void OnInspectorGUI()
         {
             Initialize();
@@ -91,7 +97,11 @@ namespace Unity.Netcode.Editor
             }
             else
             {
-                base.OnInspectorGUI();
+                EditorGUI.BeginChangeCheck();
+                serializedObject.UpdateIfRequiredOrScript();
+                DrawPropertiesExcluding(serializedObject, k_HiddenFields);
+                serializedObject.ApplyModifiedProperties();
+                EditorGUI.EndChangeCheck();
 
                 var guiEnabled = GUI.enabled;
                 GUI.enabled = false;
@@ -100,5 +110,32 @@ namespace Unity.Netcode.Editor
                 GUI.enabled = guiEnabled;
             }
         }
+
+        // Saved for use in OnDestroy
+        private GameObject m_GameObject;
+
+        /// <summary>
+        /// Invoked once when a NetworkObject component is
+        /// displayed in the inspector view.
+        /// </summary>
+        private void OnEnable()
+        {
+            // We set the GameObject upon being enabled because when the
+            // NetworkObject component is removed (i.e. when OnDestroy is invoked)
+            // it is no longer valid/available.
+            m_GameObject = (target as NetworkObject).gameObject;
+        }
+
+        /// <summary>
+        /// Invoked once when a NetworkObject component is
+        /// no longer displayed in the inspector view.
+        /// </summary>
+        private void OnDestroy()
+        {
+            // Since this is also invoked when a NetworkObject component is removed
+            // from a GameObject, we go ahead and check for a NetworkObject when
+            // this custom editor is destroyed.
+            NetworkBehaviourEditor.CheckForNetworkObject(m_GameObject, true);
+        }
     }
 }

Editor/NetworkTransformEditor.cs

@@ -1,12 +1,16 @@
+using Unity.Netcode.Components;
 using UnityEditor;
 using UnityEngine;
-using Unity.Netcode.Components;
 
 namespace Unity.Netcode.Editor
 {
-    [CustomEditor(typeof(NetworkTransform))]
+    /// <summary>
+    /// The <see cref="CustomEditor"/> for <see cref="NetworkTransform"/>
+    /// </summary>
+    [CustomEditor(typeof(NetworkTransform), true)]
     public class NetworkTransformEditor : UnityEditor.Editor
     {
+        private SerializedProperty m_UseUnreliableDeltas;
         private SerializedProperty m_SyncPositionXProperty;
         private SerializedProperty m_SyncPositionYProperty;
         private SerializedProperty m_SyncPositionZProperty;
@@ -22,14 +26,23 @@ namespace Unity.Netcode.Editor
         private SerializedProperty m_InLocalSpaceProperty;
         private SerializedProperty m_InterpolateProperty;
 
+        private SerializedProperty m_UseQuaternionSynchronization;
+        private SerializedProperty m_UseQuaternionCompression;
+        private SerializedProperty m_UseHalfFloatPrecision;
+        private SerializedProperty m_SlerpPosition;
+
         private static int s_ToggleOffset = 45;
         private static float s_MaxRowWidth = EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth + 5;
         private static GUIContent s_PositionLabel = EditorGUIUtility.TrTextContent("Position");
         private static GUIContent s_RotationLabel = EditorGUIUtility.TrTextContent("Rotation");
         private static GUIContent s_ScaleLabel = EditorGUIUtility.TrTextContent("Scale");
 
+        public virtual bool HideInterpolateValue => false;
+
+        /// <inheritdoc/>
         public void OnEnable()
         {
+            m_UseUnreliableDeltas = serializedObject.FindProperty(nameof(NetworkTransform.UseUnreliableDeltas));
             m_SyncPositionXProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionX));
             m_SyncPositionYProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionY));
             m_SyncPositionZProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionZ));
@@ -44,8 +57,13 @@ namespace Unity.Netcode.Editor
             m_ScaleThresholdProperty = serializedObject.FindProperty(nameof(NetworkTransform.ScaleThreshold));
             m_InLocalSpaceProperty = serializedObject.FindProperty(nameof(NetworkTransform.InLocalSpace));
             m_InterpolateProperty = serializedObject.FindProperty(nameof(NetworkTransform.Interpolate));
+            m_UseQuaternionSynchronization = serializedObject.FindProperty(nameof(NetworkTransform.UseQuaternionSynchronization));
+            m_UseQuaternionCompression = serializedObject.FindProperty(nameof(NetworkTransform.UseQuaternionCompression));
+            m_UseHalfFloatPrecision = serializedObject.FindProperty(nameof(NetworkTransform.UseHalfFloatPrecision));
+            m_SlerpPosition = serializedObject.FindProperty(nameof(NetworkTransform.SlerpPosition));
         }
 
+        /// <inheritdoc/>
         public override void OnInspectorGUI()
         {
             EditorGUILayout.LabelField("Syncing", EditorStyles.boldLabel);
@@ -66,6 +84,8 @@ namespace Unity.Netcode.Editor
 
                 GUILayout.EndHorizontal();
             }
+
+            if (!m_UseQuaternionSynchronization.boolValue)
             {
                 GUILayout.BeginHorizontal();
 
@@ -83,6 +103,13 @@ namespace Unity.Netcode.Editor
 
                 GUILayout.EndHorizontal();
             }
+            else
+            {
+                m_SyncRotationXProperty.boolValue = true;
+                m_SyncRotationYProperty.boolValue = true;
+                m_SyncRotationZProperty.boolValue = true;
+            }
+
             {
                 GUILayout.BeginHorizontal();
 
@@ -106,25 +133,47 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.PropertyField(m_PositionThresholdProperty);
             EditorGUILayout.PropertyField(m_RotAngleThresholdProperty);
             EditorGUILayout.PropertyField(m_ScaleThresholdProperty);
-
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Delivery", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(m_UseUnreliableDeltas);
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Configurations", EditorStyles.boldLabel);
             EditorGUILayout.PropertyField(m_InLocalSpaceProperty);
-            EditorGUILayout.PropertyField(m_InterpolateProperty);
+            if (!HideInterpolateValue)
+            {
+                EditorGUILayout.PropertyField(m_InterpolateProperty);
+            }
+
+            EditorGUILayout.PropertyField(m_SlerpPosition);
+            EditorGUILayout.PropertyField(m_UseQuaternionSynchronization);
+            if (m_UseQuaternionSynchronization.boolValue)
+            {
+                EditorGUILayout.PropertyField(m_UseQuaternionCompression);
+            }
+            else
+            {
+                m_UseQuaternionCompression.boolValue = false;
+            }
+            EditorGUILayout.PropertyField(m_UseHalfFloatPrecision);
 
             // if rigidbody is present but network rigidbody is not present
             var go = ((NetworkTransform)target).gameObject;
+
+#if COM_UNITY_MODULES_PHYSICS
             if (go.TryGetComponent<Rigidbody>(out _) && go.TryGetComponent<NetworkRigidbody>(out _) == false)
             {
                 EditorGUILayout.HelpBox("This GameObject contains a Rigidbody but no NetworkRigidbody.\n" +
                     "Add a NetworkRigidbody component to improve Rigidbody synchronization.", MessageType.Warning);
             }
+#endif // COM_UNITY_MODULES_PHYSICS
 
+#if COM_UNITY_MODULES_PHYSICS2D
             if (go.TryGetComponent<Rigidbody2D>(out _) && go.TryGetComponent<NetworkRigidbody2D>(out _) == false)
             {
                 EditorGUILayout.HelpBox("This GameObject contains a Rigidbody2D but no NetworkRigidbody2D.\n" +
                     "Add a NetworkRigidbody2D component to improve Rigidbody2D synchronization.", MessageType.Warning);
             }
+#endif // COM_UNITY_MODULES_PHYSICS2D
 
             serializedObject.ApplyModifiedProperties();
         }

Editor/PackageChecker.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 03def738b58f746408d456f1f8c99264
+guid: a325130169714440ba1b4878082e8956
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Editor/PackageChecker/UTPAdapterChecker.cs

@@ -0,0 +1,53 @@
+#if COM_UNITY_NETCODE_ADAPTER_UTP
+using System.Linq;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.PackageManager;
+using UnityEditor.PackageManager.Requests;
+
+namespace Unity.Netcode.Editor.PackageChecker
+{
+    [InitializeOnLoad]
+    internal class UTPAdapterChecker
+    {
+        private const string k_UTPAdapterPackageName = "com.unity.netcode.adapter.utp";
+
+        private static ListRequest s_ListRequest = null;
+
+        static UTPAdapterChecker()
+        {
+            if (s_ListRequest == null)
+            {
+                s_ListRequest = Client.List();
+                EditorApplication.update += EditorUpdate;
+            }
+        }
+
+        private static void EditorUpdate()
+        {
+            if (!s_ListRequest.IsCompleted)
+            {
+                return;
+            }
+
+            EditorApplication.update -= EditorUpdate;
+
+            if (s_ListRequest.Status == StatusCode.Success)
+            {
+                if (s_ListRequest.Result.Any(p => p.name == k_UTPAdapterPackageName))
+                {
+                    Debug.Log($"({nameof(UTPAdapterChecker)}) Found UTP Adapter package, it is no longer needed, `UnityTransport` is now directly integrated into the SDK therefore removing it from the project.");
+                    Client.Remove(k_UTPAdapterPackageName);
+                }
+            }
+            else
+            {
+                var error = s_ListRequest.Error;
+                Debug.LogError($"({nameof(UTPAdapterChecker)}) Cannot check the list of packages -> error #{error.errorCode}: {error.message}");
+            }
+
+            s_ListRequest = null;
+        }
+    }
+}
+#endif // COM_UNITY_NETCODE_ADAPTER_UTP

Editor/PackageChecker/UTPAdapterChecker.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: df5ed97df956b4aad91a221ba59fa304
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/PackageChecker/com.unity.netcode.editor.packagechecker.asmdef

@@ -0,0 +1,14 @@
+{
+    "name": "Unity.Netcode.Editor.PackageChecker",
+    "rootNamespace": "Unity.Netcode.Editor.PackageChecker",
+    "includePlatforms": [
+        "Editor"
+    ],
+    "versionDefines": [
+        {
+            "name": "com.unity.netcode.adapter.utp",
+            "expression": "",
+            "define": "COM_UNITY_NETCODE_ADAPTER_UTP"
+        }
+    ]
+}

Editor/PackageChecker/com.unity.netcode.editor.packagechecker.asmdef.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 78ac2a8d1365141f68da5d0a9e10dbc6
+guid: de64d7f9ca85d4bf59c8c24738bc1057
 AssemblyDefinitionImporter:
   externalObjects: {}
   userData: 

Editor/com.unity.netcode.editor.asmdef

@@ -3,7 +3,11 @@
     "rootNamespace": "Unity.Netcode.Editor",
     "references": [
         "Unity.Netcode.Runtime",
-        "Unity.Netcode.Components"
+        "Unity.Netcode.Components",
+        "Unity.Services.Relay",
+        "Unity.Networking.Transport",
+        "Unity.Services.Core",
+        "Unity.Services.Authentication"
     ],
     "includePlatforms": [
         "Editor"
@@ -19,6 +23,36 @@
             "name": "com.unity.multiplayer.tools",
             "expression": "",
             "define": "MULTIPLAYER_TOOLS"
+        },
+        {
+            "name": "Unity",
+            "expression": "(0,2022.2.0a5)",
+            "define": "UNITY_UNET_PRESENT"
+        },
+        {
+            "name": "com.unity.modules.animation",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_ANIMATION"
+        },
+        {
+            "name": "com.unity.modules.physics",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_PHYSICS"
+        },
+        {
+            "name": "com.unity.modules.physics2d",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_PHYSICS2D"
+        },
+        {
+            "name": "com.unity.services.relay",
+            "expression": "1.0",
+            "define": "RELAY_SDK_INSTALLED"
+        },
+        {
+            "name": "com.unity.transport",
+            "expression": "2.0",
+            "define": "UTP_TRANSPORT_2_0_ABOVE"
         }
     ],
     "noEngineReferences": false

README.md

@@ -1,10 +1,16 @@
-[![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)
+# Netcode for GameObjects
 
-Netcode for GameObjects provides networking capabilities to GameObject & MonoBehaviour Unity 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).
+[![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)
+[![Manual](https://img.shields.io/badge/docs-manual-informational.svg)](https://docs-multiplayer.unity3d.com/netcode/current/about) [![API](https://img.shields.io/badge/docs-api-informational.svg)](https://docs-multiplayer.unity3d.com/netcode/current/api/introduction)
+
+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-multiplayer.unity3d.com/transport/current/about).
 
 ### Getting Started
+
 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/netcode/current/tutorials/helloworld) 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 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/).

Runtime/AssemblyInfo.cs

@@ -1,12 +1,25 @@
 using System.Runtime.CompilerServices;
+[assembly: InternalsVisibleTo("Unity.Netcode.Components")]
+#if UNITY_EDITOR
+[assembly: InternalsVisibleTo("Unity.Netcode.Editor")]
+[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]
+#endif // UNITY_EDITOR
+#if MULTIPLAYER_TOOLS
+[assembly: InternalsVisibleTo("Unity.Multiplayer.Tools.Adapters.Ngo1WithUtp2")]
+#endif // MULTIPLAYER_TOOLS
+#if COM_UNITY_NETCODE_ADAPTER_UTP
+[assembly: InternalsVisibleTo("Unity.Netcode.Adapter.UTP")]
+#endif // COM_UNITY_NETCODE_ADAPTER_UTP
 
+#if UNITY_INCLUDE_TESTS
+[assembly: InternalsVisibleTo("Unity.Netcode.RuntimeTests")]
+[assembly: InternalsVisibleTo("Unity.Netcode.TestHelpers.Runtime")]
+[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
 #if UNITY_EDITOR
 [assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")]
-[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]
-[assembly: InternalsVisibleTo("Unity.Netcode.Editor")]
 [assembly: InternalsVisibleTo("TestProject.EditorTests")]
-[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
+#endif // UNITY_EDITOR
+#if MULTIPLAYER_TOOLS
 [assembly: InternalsVisibleTo("TestProject.ToolsIntegration.RuntimeTests")]
-#endif
-[assembly: InternalsVisibleTo("Unity.Netcode.RuntimeTests")]
-
+#endif // MULTIPLAYER_TOOLS
+#endif // UNITY_INCLUDE_TESTS

Runtime/Configuration/NetworkConfig.cs

@@ -1,8 +1,9 @@
 using System;
 using System.Collections.Generic;
-using UnityEngine;
 using System.Linq;
 using Unity.Collections;
+using UnityEngine;
+using UnityEngine.Serialization;
 
 namespace Unity.Netcode
 {
@@ -30,20 +31,8 @@ namespace Unity.Netcode
         [Tooltip("When set, NetworkManager will automatically create and spawn the assigned player prefab. This can be overridden by adding it to the NetworkPrefabs list and selecting override.")]
         public GameObject PlayerPrefab;
 
-        /// <summary>
-        /// A list of prefabs that can be dynamically spawned.
-        /// </summary>
         [SerializeField]
-        [Tooltip("The prefabs that can be spawned across the network")]
-        internal List<NetworkPrefab> NetworkPrefabs = new List<NetworkPrefab>();
-
-        /// <summary>
-        /// This dictionary provides a quick way to check and see if a NetworkPrefab has a NetworkPrefab override.
-        /// Generated at runtime and OnValidate
-        /// </summary>
-        internal Dictionary<uint, NetworkPrefab> NetworkPrefabOverrideLinks = new Dictionary<uint, NetworkPrefab>();
-
-        internal Dictionary<uint, uint> OverrideToNetworkPrefab = new Dictionary<uint, uint>();
+        public NetworkPrefabs Prefabs = new NetworkPrefabs();
 
 
         /// <summary>
@@ -53,9 +42,21 @@ namespace Unity.Netcode
         public uint TickRate = 30;
 
         /// <summary>
-        /// The amount of seconds to wait for handshake to complete before timing out a client
+        /// The amount of seconds for the server to wait for the connection approval handshake to complete before the client is disconnected.
+        ///
+        /// If the timeout is reached before approval is completed the client will be disconnected.
         /// </summary>
-        [Tooltip("The amount of seconds to wait for the handshake to complete before the client times out")]
+        /// <remarks>
+        /// The period begins after the <see cref="NetworkEvent.Connect"/> is received on the server.
+        /// The period ends once the server finishes processing a <see cref="ConnectionRequestMessage"/> from the client.
+        ///
+        /// This setting is independent of any Transport-level timeouts that may be in effect. It covers the time between
+        /// the connection being established on the Transport layer, the client sending a
+        /// <see cref="ConnectionRequestMessage"/>, and the server processing that message through <see cref="ConnectionApproval"/>.
+        ///
+        /// This setting is server-side only.
+        /// </remarks>
+        [Tooltip("The amount of seconds for the server to wait for the connection approval handshake to complete before the client is disconnected")]
         public int ClientConnectionBufferTimeout = 10;
 
         /// <summary>
@@ -128,10 +129,10 @@ namespace Unity.Netcode
         public int LoadSceneTimeOut = 120;
 
         /// <summary>
-        /// The amount of time a message should be buffered for without being consumed. If it is not consumed within this time, it will be dropped.
+        /// The amount of time a message should be buffered if the asset or object needed to process it doesn't exist yet. If the asset is not added/object is not spawned within this time, it will be dropped.
         /// </summary>
-        [Tooltip("The amount of time a message should be buffered for without being consumed. If it is not consumed within this time, it will be dropped")]
-        public float MessageBufferTimeout = 20f;
+        [Tooltip("The amount of time a message should be buffered if the asset or object needed to process it doesn't exist yet. If the asset is not added/object is not spawned within this time, it will be dropped")]
+        public float SpawnTimeout = 10f;
 
         /// <summary>
         /// Whether or not to enable network logs.
@@ -139,20 +140,15 @@ namespace Unity.Netcode
         public bool EnableNetworkLogs = true;
 
         /// <summary>
-        /// Whether or not to enable Snapshot System for variable updates. Not supported in this version.
+        /// The number of RTT samples that is kept as an average for calculations
         /// </summary>
-        public bool UseSnapshotDelta { get; internal set; } = false;
-        /// <summary>
-        /// Whether or not to enable Snapshot System for spawn and despawn commands. Not supported in this version.
-        /// </summary>
-        public bool UseSnapshotSpawn { get; internal set; } = false;
-        /// <summary>
-        /// When Snapshot System spawn is enabled: max size of Snapshot Messages. Meant to fit MTU.
-        /// </summary>
-        public int SnapshotMaxSpawnUsage { get; } = 1000;
-
         public const int RttAverageSamples = 5; // number of RTT to keep an average of (plus one)
+
+        /// <summary>
+        /// The number of slots used for RTT calculations. This is the maximum amount of in-flight messages
+        /// </summary>
         public const int RttWindowSize = 64; // number of slots to use for RTT computations (max number of in-flight packets)
+
         /// <summary>
         /// Returns a base64 encoded version of the configuration
         /// </summary>
@@ -160,7 +156,7 @@ namespace Unity.Netcode
         public string ToBase64()
         {
             NetworkConfig config = this;
-            var writer = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp);
+            var writer = new FastBufferWriter(1024, Allocator.Temp);
             using (writer)
             {
                 writer.WriteValueSafe(config.ProtocolVersion);
@@ -212,6 +208,14 @@ namespace Unity.Netcode
 
         private ulong? m_ConfigHash = null;
 
+        /// <summary>
+        /// Clears out the configuration hash value generated for a specific network session
+        /// </summary>
+        internal void ClearConfigHash()
+        {
+            m_ConfigHash = null;
+        }
+
         /// <summary>
         /// Gets a SHA256 hash of parts of the NetworkConfig instance
         /// </summary>
@@ -224,7 +228,7 @@ namespace Unity.Netcode
                 return m_ConfigHash.Value;
             }
 
-            var writer = new FastBufferWriter(MessagingSystem.NON_FRAGMENTED_MESSAGE_MAX_SIZE, Allocator.Temp, int.MaxValue);
+            var writer = new FastBufferWriter(1024, Allocator.Temp, int.MaxValue);
             using (writer)
             {
                 writer.WriteValueSafe(ProtocolVersion);
@@ -232,13 +236,15 @@ namespace Unity.Netcode
 
                 if (ForceSamePrefabs)
                 {
-                    var sortedDictionary = NetworkPrefabOverrideLinks.OrderBy(x => x.Key);
+                    var sortedDictionary = Prefabs.NetworkPrefabOverrideLinks.OrderBy(x => x.Key);
                     foreach (var sortedEntry in sortedDictionary)
 
                     {
                         writer.WriteValueSafe(sortedEntry.Key);
                     }
                 }
+
+                writer.WriteValueSafe(TickRate);
                 writer.WriteValueSafe(ConnectionApproval);
                 writer.WriteValueSafe(ForceSamePrefabs);
                 writer.WriteValueSafe(EnableSceneManagement);
@@ -264,6 +270,75 @@ namespace Unity.Netcode
         {
             return hash == GetConfig();
         }
+
+        internal void InitializePrefabs()
+        {
+            if (HasOldPrefabList())
+            {
+                MigrateOldNetworkPrefabsToNetworkPrefabsList();
+            }
+
+            Prefabs.Initialize();
+        }
+
+        [NonSerialized]
+        private bool m_DidWarnOldPrefabList = false;
+
+        private void WarnOldPrefabList()
+        {
+            if (!m_DidWarnOldPrefabList)
+            {
+                Debug.LogWarning("Using Legacy Network Prefab List. Consider Migrating.");
+                m_DidWarnOldPrefabList = true;
+            }
+        }
+
+        /// <summary>
+        /// Returns true if the old List&lt;NetworkPrefab&gt; serialized data is present.
+        /// </summary>
+        /// <remarks>
+        /// Internal use only to help migrate projects. <seealso cref="MigrateOldNetworkPrefabsToNetworkPrefabsList"/></remarks>
+        internal bool HasOldPrefabList()
+        {
+            return OldPrefabList?.Count > 0;
+        }
+
+        /// <summary>
+        /// Migrate the old format List&lt;NetworkPrefab&gt; prefab registration to the new NetworkPrefabsList ScriptableObject.
+        /// </summary>
+        /// <remarks>
+        /// OnAfterDeserialize cannot instantiate new objects (e.g. NetworkPrefabsList SO) since it executes in a thread, so we have to do it later.
+        /// Since NetworkConfig isn't a Unity.Object it doesn't get an Awake callback, so we have to do this in NetworkManager and expose this API.
+        /// </remarks>
+        internal NetworkPrefabsList MigrateOldNetworkPrefabsToNetworkPrefabsList()
+        {
+            if (OldPrefabList == null || OldPrefabList.Count == 0)
+            {
+                return null;
+            }
+
+            if (Prefabs == null)
+            {
+                throw new Exception("Prefabs field is null.");
+            }
+
+            Prefabs.NetworkPrefabsLists.Add(ScriptableObject.CreateInstance<NetworkPrefabsList>());
+
+            if (OldPrefabList?.Count > 0)
+            {
+                // Migrate legacy types/fields
+                foreach (var networkPrefab in OldPrefabList)
+                {
+                    Prefabs.NetworkPrefabsLists[Prefabs.NetworkPrefabsLists.Count - 1].Add(networkPrefab);
+                }
+            }
+
+            OldPrefabList = null;
+            return Prefabs.NetworkPrefabsLists[Prefabs.NetworkPrefabsLists.Count - 1];
+        }
+
+        [FormerlySerializedAs("NetworkPrefabs")]
+        [SerializeField]
+        internal List<NetworkPrefab> OldPrefabList;
     }
 }
-

Runtime/Configuration/NetworkPrefab.cs

@@ -3,10 +3,25 @@ using UnityEngine;
 
 namespace Unity.Netcode
 {
-    internal enum NetworkPrefabOverride
+    /// <summary>
+    /// The method of NetworkPrefab override used to identify the source prefab
+    /// </summary>
+    public enum NetworkPrefabOverride
     {
+        /// <summary>
+        /// No oeverride is present
+        /// </summary>
         None,
+
+        /// <summary>
+        /// Override the prefab when the given SourcePrefabToOverride is requested
+        /// </summary>
         Prefab,
+
+        /// <summary>
+        /// Override the prefab when the given SourceHashToOverride is requested
+        /// Used in situations where the server assets do not exist in client builds
+        /// </summary>
         Hash
     }
 
@@ -14,10 +29,10 @@ namespace Unity.Netcode
     /// Class that represents a NetworkPrefab
     /// </summary>
     [Serializable]
-    internal class NetworkPrefab
+    public class NetworkPrefab
     {
         /// <summary>
-        /// The override setttings for this NetworkPrefab
+        /// The override settings for this NetworkPrefab
         /// </summary>
         public NetworkPrefabOverride Override;
 
@@ -41,5 +56,177 @@ namespace Unity.Netcode
         /// The prefab to replace (override) the source prefab with
         /// </summary>
         public GameObject OverridingTargetPrefab;
+
+        public bool Equals(NetworkPrefab other)
+        {
+            return Override == other.Override &&
+                   Prefab == other.Prefab &&
+                   SourcePrefabToOverride == other.SourcePrefabToOverride &&
+                   SourceHashToOverride == other.SourceHashToOverride &&
+                   OverridingTargetPrefab == other.OverridingTargetPrefab;
+        }
+
+        public uint SourcePrefabGlobalObjectIdHash
+        {
+            get
+            {
+                switch (Override)
+                {
+                    case NetworkPrefabOverride.None:
+                        {
+                            if (Prefab != null && Prefab.TryGetComponent(out NetworkObject networkObject))
+                            {
+                                return networkObject.GlobalObjectIdHash;
+                            }
+
+                            throw new InvalidOperationException($"Prefab field is not set or is not a {nameof(NetworkObject)}");
+                        }
+                    case NetworkPrefabOverride.Prefab:
+                        {
+                            if (SourcePrefabToOverride != null && SourcePrefabToOverride.TryGetComponent(out NetworkObject networkObject))
+                            {
+                                return networkObject.GlobalObjectIdHash;
+                            }
+
+                            throw new InvalidOperationException($"Source Prefab field is not set or is not a {nameof(NetworkObject)}");
+                        }
+                    case NetworkPrefabOverride.Hash:
+                        return SourceHashToOverride;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+        }
+
+        public uint TargetPrefabGlobalObjectIdHash
+        {
+            get
+            {
+                switch (Override)
+                {
+                    case NetworkPrefabOverride.None:
+                        return 0;
+                    case NetworkPrefabOverride.Prefab:
+                    case NetworkPrefabOverride.Hash:
+                        {
+                            if (OverridingTargetPrefab != null && OverridingTargetPrefab.TryGetComponent(out NetworkObject networkObject))
+                            {
+                                return networkObject.GlobalObjectIdHash;
+                            }
+
+                            throw new InvalidOperationException($"Target Prefab field is not set or is not a {nameof(NetworkObject)}");
+                        }
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+        }
+
+        public bool Validate(int index = -1)
+        {
+            NetworkObject networkObject;
+            if (Override == NetworkPrefabOverride.None)
+            {
+                if (Prefab == null)
+                {
+                    NetworkLog.LogWarning($"{nameof(NetworkPrefab)} cannot be null ({nameof(NetworkPrefab)} at index: {index})");
+                    return false;
+                }
+
+                networkObject = Prefab.GetComponent<NetworkObject>();
+                if (networkObject == null)
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                    {
+                        NetworkLog.LogWarning($"{NetworkPrefabHandler.PrefabDebugHelper(this)} is missing a {nameof(NetworkObject)} component (entry will be ignored).");
+                    }
+
+                    return false;
+                }
+
+                return true;
+            }
+
+            // Validate source prefab override values first
+            switch (Override)
+            {
+                case NetworkPrefabOverride.Hash:
+                    {
+                        if (SourceHashToOverride == 0)
+                        {
+                            if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                            {
+                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(SourceHashToOverride)} is zero (entry will be ignored).");
+                            }
+
+                            return false;
+                        }
+
+                        break;
+                    }
+                case NetworkPrefabOverride.Prefab:
+                    {
+                        if (SourcePrefabToOverride == null)
+                        {
+                            // This is a leftover side-effect from NetworkManager's OnValidate. It's a usability
+                            // adjustment to automatically set the "Prefab" field as the source prefab when a user
+                            // swaps from the default Inspector to the override one.
+                            if (Prefab != null)
+                            {
+                                SourcePrefabToOverride = Prefab;
+                            }
+                            else if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                            {
+                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(SourcePrefabToOverride)} is null (entry will be ignored).");
+                                return false;
+                            }
+                        }
+
+                        if (!SourcePrefabToOverride.TryGetComponent(out networkObject))
+                        {
+                            if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                            {
+                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} ({SourcePrefabToOverride.name}) is missing a {nameof(NetworkObject)} component (entry will be ignored).");
+                            }
+
+                            return false;
+                        }
+
+                        break;
+                    }
+            }
+
+            // Validate target prefab override values next
+            if (OverridingTargetPrefab == null)
+            {
+                if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                {
+                    NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(OverridingTargetPrefab)} is null!");
+                }
+
+                switch (Override)
+                {
+                    case NetworkPrefabOverride.Hash:
+                        {
+                            Debug.LogWarning($"{nameof(NetworkPrefab)} override entry {SourceHashToOverride} will be removed and ignored.");
+                            break;
+                        }
+                    case NetworkPrefabOverride.Prefab:
+                        {
+                            Debug.LogWarning($"{nameof(NetworkPrefab)} override entry ({SourcePrefabToOverride.name}) will be removed and ignored.");
+                            break;
+                        }
+                }
+
+                return false;
+            }
+
+            return true;
+        }
+
+        public override string ToString()
+        {
+            return $"{{SourceHash: {SourceHashToOverride}, TargetHash: {TargetPrefabGlobalObjectIdHash}}}";
+        }
     }
 }

Runtime/Configuration/NetworkPrefabs.cs

@@ -0,0 +1,323 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// A class that represents the runtime aspect of network prefabs.
+    /// This class contains processed prefabs from the NetworkPrefabsList, as
+    /// well as additional modifications (additions and removals) made at runtime.
+    /// </summary>
+    [Serializable]
+    public class NetworkPrefabs
+    {
+        /// <summary>
+        /// Edit-time scripted object containing a list of NetworkPrefabs.
+        /// </summary>
+        /// <remarks>
+        /// This field can be null if no prefabs are pre-configured.
+        /// Runtime usages of <see cref="NetworkPrefabs"/> should not depend on this edit-time field for execution.
+        /// </remarks>
+        [SerializeField]
+        public List<NetworkPrefabsList> NetworkPrefabsLists = new List<NetworkPrefabsList>();
+
+        /// <summary>
+        /// This dictionary provides a quick way to check and see if a NetworkPrefab has a NetworkPrefab override.
+        /// Generated at runtime and OnValidate
+        /// </summary>
+        [NonSerialized]
+        public Dictionary<uint, NetworkPrefab> NetworkPrefabOverrideLinks = new Dictionary<uint, NetworkPrefab>();
+
+        /// <summary>
+        /// This is used for the legacy way of spawning NetworkPrefabs with an override when manually instantiating and spawning.
+        /// To handle multiple source NetworkPrefab overrides that all point to the same target NetworkPrefab use
+        /// <see cref="NetworkSpawnManager.InstantiateAndSpawn(NetworkObject, ulong, bool, bool, bool, Vector3, Quaternion)"/>
+        /// or <see cref="NetworkObject.InstantiateAndSpawn(NetworkManager, ulong, bool, bool, bool, Vector3, Quaternion)"/>
+        /// </summary>
+        [NonSerialized]
+        public Dictionary<uint, uint> OverrideToNetworkPrefab = new Dictionary<uint, uint>();
+
+        public IReadOnlyList<NetworkPrefab> Prefabs => m_Prefabs;
+
+        [NonSerialized]
+        private List<NetworkPrefab> m_Prefabs = new List<NetworkPrefab>();
+
+        [NonSerialized]
+        private List<NetworkPrefab> m_RuntimeAddedPrefabs = new List<NetworkPrefab>();
+
+        private void AddTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
+        {
+            if (AddPrefabRegistration(networkPrefab))
+            {
+                // Don't add this to m_RuntimeAddedPrefabs
+                // This prefab is now in the PrefabList, so if we shutdown and initialize again, we'll pick it up from there.
+                m_Prefabs.Add(networkPrefab);
+            }
+        }
+
+        private void RemoveTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
+        {
+            m_Prefabs.Remove(networkPrefab);
+        }
+
+        ~NetworkPrefabs()
+        {
+            Shutdown();
+        }
+
+        /// <summary>
+        /// Deregister from add and remove events
+        /// Clear the list
+        /// </summary>
+        internal void Shutdown()
+        {
+            foreach (var list in NetworkPrefabsLists)
+            {
+                list.OnAdd -= AddTriggeredByNetworkPrefabList;
+                list.OnRemove -= RemoveTriggeredByNetworkPrefabList;
+            }
+        }
+
+        /// <summary>
+        /// Processes the <see cref="NetworkPrefabsList"/> if one is present for use during runtime execution,
+        /// else processes <see cref="Prefabs"/>.
+        /// </summary>
+        public void Initialize(bool warnInvalid = true)
+        {
+            m_Prefabs.Clear();
+            foreach (var list in NetworkPrefabsLists)
+            {
+                list.OnAdd += AddTriggeredByNetworkPrefabList;
+                list.OnRemove += RemoveTriggeredByNetworkPrefabList;
+            }
+
+            NetworkPrefabOverrideLinks.Clear();
+            OverrideToNetworkPrefab.Clear();
+
+            var prefabs = new List<NetworkPrefab>();
+
+            if (NetworkPrefabsLists.Count != 0)
+            {
+                foreach (var list in NetworkPrefabsLists)
+                {
+                    foreach (var networkPrefab in list.PrefabList)
+                    {
+                        prefabs.Add(networkPrefab);
+                    }
+                }
+            }
+
+            m_Prefabs = new List<NetworkPrefab>();
+
+            List<NetworkPrefab> removeList = null;
+            if (warnInvalid)
+            {
+                removeList = new List<NetworkPrefab>();
+            }
+
+            foreach (var networkPrefab in prefabs)
+            {
+                if (AddPrefabRegistration(networkPrefab))
+                {
+                    m_Prefabs.Add(networkPrefab);
+                }
+                else
+                {
+                    removeList?.Add(networkPrefab);
+                }
+            }
+
+            foreach (var networkPrefab in m_RuntimeAddedPrefabs)
+            {
+                if (AddPrefabRegistration(networkPrefab))
+                {
+                    m_Prefabs.Add(networkPrefab);
+                }
+                else
+                {
+                    removeList?.Add(networkPrefab);
+                }
+            }
+
+            // Clear out anything that is invalid or not used
+            if (removeList?.Count > 0)
+            {
+                if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                {
+                    var sb = new StringBuilder("Removing invalid prefabs from Network Prefab registration: ");
+                    sb.Append(string.Join(", ", removeList));
+                    NetworkLog.LogWarning(sb.ToString());
+                }
+            }
+        }
+
+        /// <summary>
+        /// Add a new NetworkPrefab instance to the list
+        /// </summary>
+        /// <remarks>
+        /// The framework does not synchronize this list between clients. Any runtime changes must be handled manually.
+        ///
+        /// Any modifications made here are not persisted. Permanent configuration changes should be done
+        /// through the <see cref="NetworkPrefabsList"/> scriptable object property.
+        /// </remarks>
+        public bool Add(NetworkPrefab networkPrefab)
+        {
+            if (AddPrefabRegistration(networkPrefab))
+            {
+                m_Prefabs.Add(networkPrefab);
+                m_RuntimeAddedPrefabs.Add(networkPrefab);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Remove a NetworkPrefab instance from the list
+        /// </summary>
+        /// <remarks>
+        /// The framework does not synchronize this list between clients. Any runtime changes must be handled manually.
+        ///
+        /// Any modifications made here are not persisted. Permanent configuration changes should be done
+        /// through the <see cref="NetworkPrefabsList"/> scriptable object property.
+        /// </remarks>
+        public void Remove(NetworkPrefab prefab)
+        {
+            if (prefab == null)
+            {
+                throw new ArgumentNullException(nameof(prefab));
+            }
+
+            m_Prefabs.Remove(prefab);
+            m_RuntimeAddedPrefabs.Remove(prefab);
+            OverrideToNetworkPrefab.Remove(prefab.TargetPrefabGlobalObjectIdHash);
+            NetworkPrefabOverrideLinks.Remove(prefab.SourcePrefabGlobalObjectIdHash);
+        }
+
+        /// <summary>
+        /// Remove a NetworkPrefab instance with matching <see cref="NetworkPrefab.Prefab"/> from the list
+        /// </summary>
+        /// <remarks>
+        /// The framework does not synchronize this list between clients. Any runtime changes must be handled manually.
+        ///
+        /// Any modifications made here are not persisted. Permanent configuration changes should be done
+        /// through the <see cref="NetworkPrefabsList"/> scriptable object property.
+        /// </remarks>
+        public void Remove(GameObject prefab)
+        {
+            if (prefab == null)
+            {
+                throw new ArgumentNullException(nameof(prefab));
+            }
+
+            for (int i = 0; i < m_Prefabs.Count; i++)
+            {
+                if (m_Prefabs[i].Prefab == prefab)
+                {
+                    Remove(m_Prefabs[i]);
+                    return;
+                }
+            }
+
+            for (int i = 0; i < m_RuntimeAddedPrefabs.Count; i++)
+            {
+                if (m_RuntimeAddedPrefabs[i].Prefab == prefab)
+                {
+                    Remove(m_RuntimeAddedPrefabs[i]);
+                    return;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Check if the given GameObject is present as a prefab within the list
+        /// </summary>
+        /// <param name="prefab">The prefab to check</param>
+        /// <returns>Whether or not the prefab exists</returns>
+        public bool Contains(GameObject prefab)
+        {
+            for (int i = 0; i < m_Prefabs.Count; i++)
+            {
+                // Check both values as Prefab and be different than SourcePrefabToOverride
+                if (m_Prefabs[i].Prefab == prefab || m_Prefabs[i].SourcePrefabToOverride == prefab)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Check if the given NetworkPrefab is present within the list
+        /// </summary>
+        /// <param name="prefab">The prefab to check</param>
+        /// <returns>Whether or not the prefab exists</returns>
+        public bool Contains(NetworkPrefab prefab)
+        {
+            for (int i = 0; i < m_Prefabs.Count; i++)
+            {
+                if (m_Prefabs[i].Equals(prefab))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Configures <see cref="NetworkPrefabOverrideLinks"/> for the given <see cref="NetworkPrefab"/>
+        /// </summary>
+        private bool AddPrefabRegistration(NetworkPrefab networkPrefab)
+        {
+            if (networkPrefab == null)
+            {
+                return false;
+            }
+            // Safeguard validation check since this method is called from outside of NetworkConfig and we can't control what's passed in.
+            if (!networkPrefab.Validate())
+            {
+                return false;
+            }
+
+            uint source = networkPrefab.SourcePrefabGlobalObjectIdHash;
+            uint target = networkPrefab.TargetPrefabGlobalObjectIdHash;
+
+            // Make sure the prefab isn't already registered.
+            if (NetworkPrefabOverrideLinks.ContainsKey(source))
+            {
+                var networkObject = networkPrefab.Prefab.GetComponent<NetworkObject>();
+
+                // This should never happen, but in the case it somehow does log an error and remove the duplicate entry
+                Debug.LogError($"{nameof(NetworkPrefab)} ({networkObject.name}) has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} source entry value of: {source}!");
+                return false;
+            }
+
+            // If we don't have an override configured, registration is simple!
+            if (networkPrefab.Override == NetworkPrefabOverride.None)
+            {
+                NetworkPrefabOverrideLinks.Add(source, networkPrefab);
+                return true;
+            }
+
+            switch (networkPrefab.Override)
+            {
+                case NetworkPrefabOverride.Prefab:
+                case NetworkPrefabOverride.Hash:
+                    {
+                        NetworkPrefabOverrideLinks.Add(source, networkPrefab);
+                        if (!OverrideToNetworkPrefab.ContainsKey(target))
+                        {
+                            OverrideToNetworkPrefab.Add(target, source);
+                        }
+                    }
+                    break;
+            }
+
+            return true;
+        }
+    }
+}

Runtime/Configuration/NetworkPrefabs.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 230fc75f5639e46dc91734aa67d56a3e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Configuration/NetworkPrefabsList.cs

@@ -0,0 +1,95 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// A ScriptableObject for holding a network prefabs list, which can be
+    /// shared between multiple NetworkManagers.
+    ///
+    /// When NetworkManagers hold references to this list, modifications to the
+    /// list at runtime will be picked up by all NetworkManagers that reference it.
+    /// </summary>
+    [CreateAssetMenu(fileName = "NetworkPrefabsList", menuName = "Netcode/Network Prefabs List")]
+    public class NetworkPrefabsList : ScriptableObject
+    {
+        internal delegate void OnAddDelegate(NetworkPrefab prefab);
+        internal OnAddDelegate OnAdd;
+
+        internal delegate void OnRemoveDelegate(NetworkPrefab prefab);
+        internal OnRemoveDelegate OnRemove;
+
+        [SerializeField]
+        internal bool IsDefault;
+
+        [FormerlySerializedAs("Prefabs")]
+        [SerializeField]
+        internal List<NetworkPrefab> List = new List<NetworkPrefab>();
+
+        /// <summary>
+        /// Read-only view into the prefabs list, enabling iterating and examining the list.
+        /// Actually modifying the list should be done using <see cref="Add"/>
+        /// and <see cref="Remove"/>.
+        /// </summary>
+        public IReadOnlyList<NetworkPrefab> PrefabList => List;
+
+        /// <summary>
+        /// Adds a prefab to the prefab list. Performing this here will apply the operation to all
+        /// <see cref="NetworkManager"/>s that reference this list.
+        /// </summary>
+        /// <param name="prefab"></param>
+        public void Add(NetworkPrefab prefab)
+        {
+            List.Add(prefab);
+            OnAdd?.Invoke(prefab);
+        }
+
+        /// <summary>
+        /// Removes a prefab from the prefab list. Performing this here will apply the operation to all
+        /// <see cref="NetworkManager"/>s that reference this list.
+        /// </summary>
+        /// <param name="prefab"></param>
+        public void Remove(NetworkPrefab prefab)
+        {
+            List.Remove(prefab);
+            OnRemove?.Invoke(prefab);
+        }
+
+        /// <summary>
+        /// Check if the given GameObject is present as a prefab within the list
+        /// </summary>
+        /// <param name="prefab">The prefab to check</param>
+        /// <returns>Whether or not the prefab exists</returns>
+        public bool Contains(GameObject prefab)
+        {
+            for (int i = 0; i < List.Count; i++)
+            {
+                if (List[i].Prefab == prefab)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Check if the given NetworkPrefab is present within the list
+        /// </summary>
+        /// <param name="prefab">The prefab to check</param>
+        /// <returns>Whether or not the prefab exists</returns>
+        public bool Contains(NetworkPrefab prefab)
+        {
+            for (int i = 0; i < List.Count; i++)
+            {
+                if (List[i].Equals(prefab))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}

Runtime/Configuration/NetworkPrefabsList.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e651dbb3fbac04af2b8f5abf007ddc23
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Connection/NetworkClient.cs

@@ -7,6 +7,32 @@ namespace Unity.Netcode
     /// </summary>
     public class NetworkClient
     {
+        /// <summary>
+        /// Returns true if the session instance is considered a server
+        /// </summary>
+        internal bool IsServer { get; set; }
+
+        /// <summary>
+        /// Returns true if the session instance is considered a client
+        /// </summary>
+        internal bool IsClient { get; set; }
+
+        /// <summary>
+        /// Returns true if the session instance is considered a host
+        /// </summary>
+        internal bool IsHost => IsClient && IsServer;
+
+        /// <summary>
+        /// When true, the client is connected, approved, and synchronized with
+        /// the server.
+        /// </summary>
+        internal bool IsConnected { get; set; }
+
+        /// <summary>
+        /// Is true when the client has been approved.
+        /// </summary>
+        internal bool IsApproved { get; set; }
+
         /// <summary>
         /// The ClientId of the NetworkClient
         /// </summary>
@@ -18,8 +44,33 @@ namespace Unity.Netcode
         public NetworkObject PlayerObject;
 
         /// <summary>
-        /// The NetworkObject's owned by this Client
+        /// The list of NetworkObject's owned by this client instance
         /// </summary>
-        public readonly List<NetworkObject> OwnedObjects = new List<NetworkObject>();
+        public List<NetworkObject> OwnedObjects => IsConnected ? SpawnManager.GetClientOwnedObjects(ClientId) : new List<NetworkObject>();
+
+        internal NetworkSpawnManager SpawnManager { get; private set; }
+
+        internal void SetRole(bool isServer, bool isClient, NetworkManager networkManager = null)
+        {
+            IsServer = isServer;
+            IsClient = isClient;
+            if (!IsServer && !isClient)
+            {
+                PlayerObject = null;
+                ClientId = 0;
+                IsConnected = false;
+                IsApproved = false;
+            }
+
+            if (networkManager != null)
+            {
+                SpawnManager = networkManager.SpawnManager;
+            }
+        }
+
+        internal void AssignPlayerObject(ref NetworkObject networkObject)
+        {
+            PlayerObject = networkObject;
+        }
     }
 }

Runtime/Connection/NetworkConnectionManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d98eff74d73bc2a42bd5624c47ce8fe1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Connection/PendingClient.cs

@@ -1,10 +1,15 @@
+using UnityEngine;
+
 namespace Unity.Netcode
 {
     /// <summary>
+    /// Server-Side Only:
     /// A class representing a client that is currently in the process of connecting
     /// </summary>
     public class PendingClient
     {
+        internal Coroutine ApprovalCoroutine = null;
+
         /// <summary>
         /// The ClientId of the client
         /// </summary>

Runtime/Core/ComponentFactory.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This class is used to support testable code by allowing any supported component used by NetworkManager to be replaced
+    /// with a mock component or a test version that overloads certain methods to change or record their behavior.
+    /// Components currently supported by ComponentFactory:
+    /// - IDeferredMessageManager
+    /// </summary>
+    internal static class ComponentFactory
+    {
+        internal delegate object CreateObjectDelegate(NetworkManager networkManager);
+
+        private static Dictionary<Type, CreateObjectDelegate> s_Delegates = new Dictionary<Type, CreateObjectDelegate>();
+
+        /// <summary>
+        /// Instantiates an instance of a given interface
+        /// </summary>
+        /// <param name="networkManager">The network manager</param>
+        /// <typeparam name="T">The interface to instantiate it with</typeparam>
+        /// <returns></returns>
+        public static T Create<T>(NetworkManager networkManager)
+        {
+            return (T)s_Delegates[typeof(T)](networkManager);
+        }
+
+        /// <summary>
+        /// Overrides the default creation logic for a given interface type
+        /// </summary>
+        /// <param name="creator">The factory delegate to create the instance</param>
+        /// <typeparam name="T">The interface type to override</typeparam>
+        public static void Register<T>(CreateObjectDelegate creator)
+        {
+            s_Delegates[typeof(T)] = creator;
+        }
+
+        /// <summary>
+        /// Reverts the creation logic for a given interface type to the default logic
+        /// </summary>
+        /// <typeparam name="T">The interface type to revert</typeparam>
+        public static void Deregister<T>()
+        {
+            s_Delegates.Remove(typeof(T));
+            SetDefaults();
+        }
+
+        /// <summary>
+        /// Initializes the default creation logic for all supported component types
+        /// </summary>
+        public static void SetDefaults()
+        {
+            SetDefault<IDeferredNetworkMessageManager>(networkManager => new DeferredMessageManager(networkManager));
+
+            SetDefault<IRealTimeProvider>(networkManager => new RealTimeProvider());
+        }
+
+        private static void SetDefault<T>(CreateObjectDelegate creator)
+        {
+            if (!s_Delegates.ContainsKey(typeof(T)))
+            {
+                s_Delegates[typeof(T)] = creator;
+            }
+        }
+    }
+}

Runtime/Core/ComponentFactory.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: fda4c0eb89644fcea5416bbf98ea0ba0
+timeCreated: 1649966562

Runtime/Core/IndexAllocator.cs

@@ -1,388 +0,0 @@
-using UnityEngine;
-
-namespace Unity.Netcode
-{
-    internal struct IndexAllocatorEntry
-    {
-        internal int Pos; // Position where the memory of this slot is
-        internal int Length; // Length of the memory allocated to this slot
-        internal int Next; // Next and Prev define the order of the slots in the buffer
-        internal int Prev;
-        internal bool Free;  // Whether this is a free slot
-    }
-
-    internal class IndexAllocator
-    {
-        private const int k_NotSet = -1;
-        private readonly int m_MaxSlot; // Maximum number of sections (free or not) in the buffer
-        private readonly int m_BufferSize; // Size of the buffer we allocated into
-        private int m_LastSlot = 0; // Last allocated slot
-        private IndexAllocatorEntry[] m_Slots; // Array of slots
-        private int[] m_IndexToSlot; // Mapping from the client's index to the slot index
-
-        internal IndexAllocator(int bufferSize, int maxSlot)
-        {
-            m_MaxSlot = maxSlot;
-            m_BufferSize = bufferSize;
-            m_Slots = new IndexAllocatorEntry[m_MaxSlot];
-            m_IndexToSlot = new int[m_MaxSlot];
-            Reset();
-        }
-
-        /// <summary>
-        /// Reset this IndexAllocator to an empty one, with the same sized buffer and slots
-        /// </summary>
-        internal void Reset()
-        {
-            // todo: could be made faster, for example by having a last index
-            // and not needing valid stuff past it
-            for (int i = 0; i < m_MaxSlot; i++)
-            {
-                m_Slots[i].Free = true;
-                m_Slots[i].Next = i + 1;
-                m_Slots[i].Prev = i - 1;
-                m_Slots[i].Pos = m_BufferSize;
-                m_Slots[i].Length = 0;
-
-                m_IndexToSlot[i] = k_NotSet;
-            }
-
-            m_Slots[0].Pos = 0;
-            m_Slots[0].Length = m_BufferSize;
-            m_Slots[0].Prev = k_NotSet;
-            m_Slots[m_MaxSlot - 1].Next = k_NotSet;
-        }
-
-        /// <summary>
-        /// Returns the amount of memory used
-        /// </summary>
-        /// <returns>
-        /// Returns the amount of memory used, starting at 0, ending after the last used slot
-        /// </returns>
-        internal int Range
-        {
-            get
-            {
-                // when the whole buffer is free, m_LastSlot points to an empty slot
-                if (m_Slots[m_LastSlot].Free)
-                {
-                    return 0;
-                }
-                // otherwise return the end of the last slot used
-                return m_Slots[m_LastSlot].Pos + m_Slots[m_LastSlot].Length;
-            }
-        }
-
-        /// <summary>
-        /// Allocate a slot with "size" position, for index "index"
-        /// </summary>
-        /// <param name="index">The client index to identify this. Used in Deallocate to identify which slot</param>
-        /// <param name="size">The size required. </param>
-        /// <param name="pos">Returns the position to use in the buffer </param>
-        /// <returns>
-        /// true if successful, false is there isn't enough memory available or no slots are large enough
-        /// </returns>
-        internal bool Allocate(int index, int size, out int pos)
-        {
-            pos = 0;
-            // size must be positive, index must be within range
-            if (size < 0 || index < 0 || index >= m_MaxSlot)
-            {
-                return false;
-            }
-
-            // refuse allocation if the index is already in use
-            if (m_IndexToSlot[index] != k_NotSet)
-            {
-                return false;
-            }
-
-            // todo: this is the slowest part
-            // improvement 1: list of free blocks (minor)
-            // improvement 2: heap of free blocks
-            for (int i = 0; i < m_MaxSlot; i++)
-            {
-                if (m_Slots[i].Free && m_Slots[i].Length >= size)
-                {
-                    m_IndexToSlot[index] = i;
-
-                    int leftOver = m_Slots[i].Length - size;
-                    int next = m_Slots[i].Next;
-                    if (m_Slots[next].Free)
-                    {
-                        m_Slots[next].Pos -= leftOver;
-                        m_Slots[next].Length += leftOver;
-                    }
-                    else
-                    {
-                        int add = MoveSlotAfter(i);
-
-                        m_Slots[add].Pos = m_Slots[i].Pos + size;
-                        m_Slots[add].Length = m_Slots[i].Length - size;
-                    }
-
-                    m_Slots[i].Free = false;
-                    m_Slots[i].Length = size;
-
-                    pos = m_Slots[i].Pos;
-
-                    // if we allocate past the current range, we are the last slot
-                    if (m_Slots[i].Pos + m_Slots[i].Length > Range)
-                    {
-                        m_LastSlot = i;
-                    }
-
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Deallocate a slot
-        /// </summary>
-        /// <param name="index">The client index to identify this. Same index used in Allocate </param>
-        /// <returns>
-        /// true if successful, false is there isn't an allocated slot at this index
-        /// </returns>
-        internal bool Deallocate(int index)
-        {
-            // size must be positive, index must be within range
-            if (index < 0 || index >= m_MaxSlot)
-            {
-                return false;
-            }
-
-            int slot = m_IndexToSlot[index];
-
-            if (slot == k_NotSet)
-            {
-                return false;
-            }
-
-            if (m_Slots[slot].Free)
-            {
-                return false;
-            }
-
-            m_Slots[slot].Free = true;
-
-            int prev = m_Slots[slot].Prev;
-            int next = m_Slots[slot].Next;
-
-            // if previous slot was free, merge and grow
-            if (prev != k_NotSet && m_Slots[prev].Free)
-            {
-                m_Slots[prev].Length += m_Slots[slot].Length;
-                m_Slots[slot].Length = 0;
-
-                // if the slot we're merging was the last one, the last one is now the one we merged with
-                if (slot == m_LastSlot)
-                {
-                    m_LastSlot = prev;
-                }
-
-                // todo: verify what this does on full or nearly full cases
-                MoveSlotToEnd(slot);
-                slot = prev;
-            }
-
-            next = m_Slots[slot].Next;
-
-            // merge with next slot if it is free
-            if (next != k_NotSet && m_Slots[next].Free)
-            {
-                m_Slots[slot].Length += m_Slots[next].Length;
-                m_Slots[next].Length = 0;
-                MoveSlotToEnd(next);
-            }
-
-            // if we just deallocate the last one, we need to move last back
-            if (slot == m_LastSlot)
-            {
-                m_LastSlot = m_Slots[m_LastSlot].Prev;
-                // if there's nothing allocated anymore, use 0
-                if (m_LastSlot == k_NotSet)
-                {
-                    m_LastSlot = 0;
-                }
-            }
-
-            // mark the index as available
-            m_IndexToSlot[index] = k_NotSet;
-
-            return true;
-        }
-
-        // Take a slot at the end and link it to go just after "slot".
-        // Used when allocating part of a slot and we need an entry for the rest
-        // Returns the slot that was picked
-        private int MoveSlotAfter(int slot)
-        {
-            int ret = m_Slots[m_MaxSlot - 1].Prev;
-            int p0 = m_Slots[ret].Prev;
-
-            m_Slots[p0].Next = m_MaxSlot - 1;
-            m_Slots[m_MaxSlot - 1].Prev = p0;
-
-            int p1 = m_Slots[slot].Next;
-            m_Slots[slot].Next = ret;
-            m_Slots[p1].Prev = ret;
-
-            m_Slots[ret].Prev = slot;
-            m_Slots[ret].Next = p1;
-
-            return ret;
-        }
-
-        // Move the slot "slot" to the end of the list.
-        // Used when merging two slots, that gives us an extra entry at the end
-        private void MoveSlotToEnd(int slot)
-        {
-            // if we're already there
-            if (m_Slots[slot].Next == k_NotSet)
-            {
-                return;
-            }
-
-            int prev = m_Slots[slot].Prev;
-            int next = m_Slots[slot].Next;
-
-            m_Slots[prev].Next = next;
-            if (next != k_NotSet)
-            {
-                m_Slots[next].Prev = prev;
-            }
-
-            int p0 = m_Slots[m_MaxSlot - 1].Prev;
-
-            m_Slots[p0].Next = slot;
-            m_Slots[slot].Next = m_MaxSlot - 1;
-
-            m_Slots[m_MaxSlot - 1].Prev = slot;
-            m_Slots[slot].Prev = p0;
-
-            m_Slots[slot].Pos = m_BufferSize;
-        }
-
-        // runs a bunch of consistency check on the Allocator
-        internal bool Verify()
-        {
-            int pos = k_NotSet;
-            int count = 0;
-            int total = 0;
-            int endPos = 0;
-
-            do
-            {
-                int prev = pos;
-                if (pos != k_NotSet)
-                {
-                    pos = m_Slots[pos].Next;
-                    if (pos == k_NotSet)
-                    {
-                        break;
-                    }
-                }
-                else
-                {
-                    pos = 0;
-                }
-
-                if (m_Slots[pos].Prev != prev)
-                {
-                    // the previous is not correct
-                    return false;
-                }
-
-                if (m_Slots[pos].Length < 0)
-                {
-                    // Length should be positive
-                    return false;
-                }
-
-                if (prev != k_NotSet && m_Slots[prev].Free && m_Slots[pos].Free && m_Slots[pos].Length > 0)
-                {
-                    // should not have two consecutive free slots
-                    return false;
-                }
-
-                if (m_Slots[pos].Pos != total)
-                {
-                    // slots should all line up nicely
-                    return false;
-                }
-
-                if (!m_Slots[pos].Free)
-                {
-                    endPos = m_Slots[pos].Pos + m_Slots[pos].Length;
-                }
-
-                total += m_Slots[pos].Length;
-                count++;
-
-            } while (pos != k_NotSet);
-
-            if (count != m_MaxSlot)
-            {
-                // some slots were lost
-                return false;
-            }
-
-            if (total != m_BufferSize)
-            {
-                // total buffer should be accounted for
-                return false;
-            }
-
-            if (endPos != Range)
-            {
-                // end position should match reported end position
-                return false;
-            }
-
-            return true;
-        }
-
-        // Debug display the allocator structure
-        internal void DebugDisplay()
-        {
-            string logMessage = "IndexAllocator structure\n";
-
-            bool[] seen = new bool[m_MaxSlot];
-
-            int pos = 0;
-            int count = 0;
-            bool prevEmpty = false;
-            do
-            {
-                seen[pos] = true;
-                count++;
-                if (m_Slots[pos].Length == 0 && prevEmpty)
-                {
-                    // don't display repetitive empty slots
-                }
-                else
-                {
-                    logMessage += string.Format("{0}:{1}, {2} ({3}) \n", m_Slots[pos].Pos, m_Slots[pos].Length,
-                        m_Slots[pos].Free ? "Free" : "Used", pos);
-                    if (m_Slots[pos].Length == 0)
-                    {
-                        prevEmpty = true;
-                    }
-                    else
-                    {
-                        prevEmpty = false;
-                    }
-                }
-
-                pos = m_Slots[pos].Next;
-            } while (pos != k_NotSet && !seen[pos]);
-
-            logMessage += string.Format("{0} Total entries\n", count);
-
-            Debug.Log(logMessage);
-        }
-    }
-}

Runtime/Core/NetworkBehaviourUpdater.cs

@@ -3,74 +3,104 @@ using Unity.Profiling;
 
 namespace Unity.Netcode
 {
+    /// <summary>
+    /// An helper class that helps NetworkManager update NetworkBehaviours and replicate them down to connected clients.
+    /// </summary>
     public class NetworkBehaviourUpdater
     {
-        private HashSet<NetworkObject> m_Touched = new HashSet<NetworkObject>();
+        private NetworkManager m_NetworkManager;
+        private NetworkConnectionManager m_ConnectionManager;
+        private HashSet<NetworkObject> m_DirtyNetworkObjects = new HashSet<NetworkObject>();
+        private HashSet<NetworkObject> m_PendingDirtyNetworkObjects = new HashSet<NetworkObject>();
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
         private ProfilerMarker m_NetworkBehaviourUpdate = new ProfilerMarker($"{nameof(NetworkBehaviour)}.{nameof(NetworkBehaviourUpdate)}");
 #endif
 
-        internal void NetworkBehaviourUpdate(NetworkManager networkManager)
+        internal void AddForUpdate(NetworkObject networkObject)
+        {
+            m_PendingDirtyNetworkObjects.Add(networkObject);
+        }
+
+        internal void NetworkBehaviourUpdate()
         {
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
             m_NetworkBehaviourUpdate.Begin();
 #endif
             try
             {
-                if (networkManager.IsServer)
+                m_DirtyNetworkObjects.UnionWith(m_PendingDirtyNetworkObjects);
+                m_PendingDirtyNetworkObjects.Clear();
+
+                // NetworkObject references can become null, when hidden or despawned. Once NUll, there is no point
+                // trying to process them, even if they were previously marked as dirty.
+                m_DirtyNetworkObjects.RemoveWhere((sobj) => sobj == null);
+
+                if (m_ConnectionManager.LocalClient.IsServer)
                 {
-                    m_Touched.Clear();
-                    for (int i = 0; i < networkManager.ConnectedClientsList.Count; i++)
+                    foreach (var dirtyObj in m_DirtyNetworkObjects)
                     {
-                        var client = networkManager.ConnectedClientsList[i];
-                        var spawnedObjs = networkManager.SpawnManager.SpawnedObjectsList;
-                        m_Touched.UnionWith(spawnedObjs);
-                        foreach (var sobj in spawnedObjs)
+                        for (int k = 0; k < dirtyObj.ChildNetworkBehaviours.Count; k++)
                         {
-                            if (sobj.IsNetworkVisibleTo(client.ClientId))
+                            dirtyObj.ChildNetworkBehaviours[k].PreVariableUpdate();
+                        }
+
+                        for (int i = 0; i < m_ConnectionManager.ConnectedClientsList.Count; i++)
+                        {
+                            var client = m_ConnectionManager.ConnectedClientsList[i];
+
+                            if (dirtyObj.IsNetworkVisibleTo(client.ClientId))
                             {
                                 // Sync just the variables for just the objects this client sees
-                                for (int k = 0; k < sobj.ChildNetworkBehaviours.Count; k++)
+                                for (int k = 0; k < dirtyObj.ChildNetworkBehaviours.Count; k++)
                                 {
-                                    sobj.ChildNetworkBehaviours[k].VariableUpdate(client.ClientId);
+                                    dirtyObj.ChildNetworkBehaviours[k].VariableUpdate(client.ClientId);
                                 }
                             }
                         }
                     }
-
-                    // Now, reset all the no-longer-dirty variables
-                    foreach (var sobj in m_Touched)
-                    {
-                        for (int k = 0; k < sobj.ChildNetworkBehaviours.Count; k++)
-                        {
-                            sobj.ChildNetworkBehaviours[k].PostNetworkVariableWrite();
-                        }
-                    }
                 }
                 else
                 {
                     // when client updates the server, it tells it about all its objects
-                    foreach (var sobj in networkManager.SpawnManager.SpawnedObjectsList)
+                    foreach (var sobj in m_DirtyNetworkObjects)
                     {
                         if (sobj.IsOwner)
                         {
                             for (int k = 0; k < sobj.ChildNetworkBehaviours.Count; k++)
                             {
-                                sobj.ChildNetworkBehaviours[k].VariableUpdate(networkManager.ServerClientId);
+                                sobj.ChildNetworkBehaviours[k].PreVariableUpdate();
+                            }
+                            for (int k = 0; k < sobj.ChildNetworkBehaviours.Count; k++)
+                            {
+                                sobj.ChildNetworkBehaviours[k].VariableUpdate(NetworkManager.ServerClientId);
                             }
                         }
                     }
+                }
 
-                    // Now, reset all the no-longer-dirty variables
-                    foreach (var sobj in networkManager.SpawnManager.SpawnedObjectsList)
+                foreach (var dirtyObj in m_DirtyNetworkObjects)
+                {
+                    for (int k = 0; k < dirtyObj.ChildNetworkBehaviours.Count; k++)
                     {
-                        for (int k = 0; k < sobj.ChildNetworkBehaviours.Count; k++)
+                        var behaviour = dirtyObj.ChildNetworkBehaviours[k];
+                        for (int i = 0; i < behaviour.NetworkVariableFields.Count; i++)
                         {
-                            sobj.ChildNetworkBehaviours[k].PostNetworkVariableWrite();
+                            if (behaviour.NetworkVariableFields[i].IsDirty() &&
+                                !behaviour.NetworkVariableIndexesToResetSet.Contains(i))
+                            {
+                                behaviour.NetworkVariableIndexesToResetSet.Add(i);
+                                behaviour.NetworkVariableIndexesToReset.Add(i);
+                            }
                         }
                     }
                 }
+                // Now, reset all the no-longer-dirty variables
+                foreach (var dirtyobj in m_DirtyNetworkObjects)
+                {
+                    dirtyobj.PostNetworkVariableWrite();
+                }
+                m_DirtyNetworkObjects.Clear();
             }
             finally
             {
@@ -80,5 +110,26 @@ namespace Unity.Netcode
             }
         }
 
+        internal void Initialize(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+            m_ConnectionManager = networkManager.ConnectionManager;
+            m_NetworkManager.NetworkTickSystem.Tick += NetworkBehaviourUpdater_Tick;
+        }
+
+        internal void Shutdown()
+        {
+            m_NetworkManager.NetworkTickSystem.Tick -= NetworkBehaviourUpdater_Tick;
+        }
+
+        // Order of operations requires NetworkVariable updates first then showing NetworkObjects
+        private void NetworkBehaviourUpdater_Tick()
+        {
+            // First update NetworkVariables
+            NetworkBehaviourUpdate();
+
+            // Then show any NetworkObjects queued to be made visible/shown
+            m_NetworkManager.SpawnManager.HandleNetworkObjectShow();
+        }
     }
 }

Runtime/Core/NetworkObjectRefreshTool.cs

@@ -0,0 +1,118 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This is a helper tool to update all in-scene placed instances of a prefab that 
+    /// originally did not have a NetworkObject component but one was added to the prefab
+    /// later.
+    /// </summary>
+    internal class NetworkObjectRefreshTool
+    {
+        private static List<string> s_ScenesToUpdate = new List<string>();
+        private static bool s_ProcessScenes;
+        private static bool s_CloseScenes;
+
+        internal static Action AllScenesProcessed;
+
+        internal static void ProcessScene(string scenePath, bool processScenes = true)
+        {
+            if (!s_ScenesToUpdate.Contains(scenePath))
+            {
+                if (s_ScenesToUpdate.Count == 0)
+                {
+                    EditorSceneManager.sceneOpened += EditorSceneManager_sceneOpened;
+                    EditorSceneManager.sceneSaved += EditorSceneManager_sceneSaved;
+                }
+                s_ScenesToUpdate.Add(scenePath);
+            }
+            s_ProcessScenes = processScenes;
+        }
+
+        internal static void ProcessActiveScene()
+        {
+            var activeScene = SceneManager.GetActiveScene();
+            if (s_ScenesToUpdate.Contains(activeScene.path) && s_ProcessScenes)
+            {
+                SceneOpened(activeScene);
+            }
+        }
+
+        internal static void ProcessScenes()
+        {
+            if (s_ScenesToUpdate.Count != 0)
+            {
+                s_CloseScenes = true;
+                var scenePath = s_ScenesToUpdate.First();
+                EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Additive);
+            }
+            else
+            {
+                s_CloseScenes = false;
+                EditorSceneManager.sceneSaved -= EditorSceneManager_sceneSaved;
+                EditorSceneManager.sceneOpened -= EditorSceneManager_sceneOpened;
+                AllScenesProcessed?.Invoke();
+            }
+        }
+
+        private static void FinishedProcessingScene(Scene scene, bool refreshed = false)
+        {
+            if (s_ScenesToUpdate.Contains(scene.path))
+            {
+                // Provide a log of all scenes that were modified to the user
+                if (refreshed)
+                {
+                    Debug.Log($"Refreshed and saved updates to scene: {scene.name}");
+                }
+                s_ProcessScenes = false;
+                s_ScenesToUpdate.Remove(scene.path);
+
+                if (scene != SceneManager.GetActiveScene())
+                {
+                    EditorSceneManager.CloseScene(scene, s_CloseScenes);
+                }
+                ProcessScenes();
+            }
+        }
+
+        private static void EditorSceneManager_sceneSaved(Scene scene)
+        {
+            FinishedProcessingScene(scene, true);
+        }
+
+        private static void SceneOpened(Scene scene)
+        {
+            if (s_ScenesToUpdate.Contains(scene.path))
+            {
+                if (s_ProcessScenes)
+                {
+                    if (!EditorSceneManager.MarkSceneDirty(scene))
+                    {
+                        Debug.Log($"Scene {scene.name} did not get marked as dirty!");
+                        FinishedProcessingScene(scene);
+                    }
+                    else
+                    {
+                        EditorSceneManager.SaveScene(scene);
+                    }
+                }
+                else
+                {
+                    FinishedProcessingScene(scene);
+                }
+            }
+        }
+
+        private static void EditorSceneManager_sceneOpened(Scene scene, OpenSceneMode mode)
+        {
+            SceneOpened(scene);
+        }
+    }
+}
+#endif // UNITY_EDITOR

Runtime/Core/NetworkObjectRefreshTool.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d24d5e8371c3cca4890e2713bdeda288
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Core/NetworkUpdateLoop.cs

@@ -7,25 +7,62 @@ using UnityEngine.PlayerLoop;
 namespace Unity.Netcode
 {
     /// <summary>
-    /// Defines the required interface of a network update system being executed by the network update loop.
+    /// Defines the required interface of a network update system being executed by the <see cref="NetworkUpdateLoop"/>.
     /// </summary>
     public interface INetworkUpdateSystem
     {
+        /// <summary>
+        /// The update method that is being executed in the context of related <see cref="NetworkUpdateStage"/>.
+        /// </summary>
+        /// <param name="updateStage">The <see cref="NetworkUpdateStage"/> that is being executed.</param>
         void NetworkUpdate(NetworkUpdateStage updateStage);
     }
 
     /// <summary>
     /// Defines network update stages being executed by the network update loop.
+    /// See for more details on update stages:
+    /// https://docs.unity3d.com/ScriptReference/PlayerLoop.Initialization.html
     /// </summary>
     public enum NetworkUpdateStage : byte
     {
-        Unset = 0, // Default
+        /// <summary>
+        /// Default value
+        /// </summary>
+        Unset = 0,
+        /// <summary>
+        /// Very first initialization update
+        /// </summary>
         Initialization = 1,
+        /// <summary>
+        /// Invoked before Fixed update
+        /// </summary>
         EarlyUpdate = 2,
+        /// <summary>
+        /// Fixed Update (i.e. state machine, physics, animations, etc)
+        /// </summary>
         FixedUpdate = 3,
+        /// <summary>
+        /// Updated before the Monobehaviour.Update for all components is invoked
+        /// </summary>
         PreUpdate = 4,
+        /// <summary>
+        /// Updated when the Monobehaviour.Update for all components is invoked
+        /// </summary>
         Update = 5,
+        /// <summary>
+        /// Updated before the Monobehaviour.LateUpdate for all components is invoked
+        /// </summary>
         PreLateUpdate = 6,
+        /// <summary>
+        /// Updated after Monobehaviour.LateUpdate, but BEFORE rendering
+        /// </summary>
+        // Yes, these numbers are out of order due to backward compatibility requirements.
+        // The enum values are listed in the order they will be called.
+        PostScriptLateUpdate = 8,
+        /// <summary>
+        /// Updated after the Monobehaviour.LateUpdate for all components is invoked
+        /// and all rendering is complete
+        /// </summary>
         PostLateUpdate = 7
     }
 
@@ -53,6 +90,7 @@ namespace Unity.Netcode
         /// <summary>
         /// Registers a network update system to be executed in all network update stages.
         /// </summary>
+        /// <param name="updateSystem">The <see cref="INetworkUpdateSystem"/> implementation to register for all network updates</param>
         public static void RegisterAllNetworkUpdates(this INetworkUpdateSystem updateSystem)
         {
             foreach (NetworkUpdateStage updateStage in Enum.GetValues(typeof(NetworkUpdateStage)))
@@ -64,6 +102,8 @@ namespace Unity.Netcode
         /// <summary>
         /// Registers a network update system to be executed in a specific network update stage.
         /// </summary>
+        /// <param name="updateSystem">The <see cref="INetworkUpdateSystem"/> implementation to register for all network updates</param>
+        /// <param name="updateStage">The <see cref="NetworkUpdateStage"/> being registered for the <see cref="INetworkUpdateSystem"/> implementation</param>
         public static void RegisterNetworkUpdate(this INetworkUpdateSystem updateSystem, NetworkUpdateStage updateStage = NetworkUpdateStage.Update)
         {
             var sysSet = s_UpdateSystem_Sets[updateStage];
@@ -94,6 +134,7 @@ namespace Unity.Netcode
         /// <summary>
         /// Unregisters a network update system from all network update stages.
         /// </summary>
+        /// <param name="updateSystem">The <see cref="INetworkUpdateSystem"/> implementation to deregister from all network updates</param>
         public static void UnregisterAllNetworkUpdates(this INetworkUpdateSystem updateSystem)
         {
             foreach (NetworkUpdateStage updateStage in Enum.GetValues(typeof(NetworkUpdateStage)))
@@ -105,6 +146,8 @@ namespace Unity.Netcode
         /// <summary>
         /// Unregisters a network update system from a specific network update stage.
         /// </summary>
+        /// <param name="updateSystem">The <see cref="INetworkUpdateSystem"/> implementation to deregister from all network updates</param>
+        /// <param name="updateStage">The <see cref="NetworkUpdateStage"/> to be deregistered from the <see cref="INetworkUpdateSystem"/> implementation</param>
         public static void UnregisterNetworkUpdate(this INetworkUpdateSystem updateSystem, NetworkUpdateStage updateStage = NetworkUpdateStage.Update)
         {
             var sysSet = s_UpdateSystem_Sets[updateStage];
@@ -131,7 +174,7 @@ namespace Unity.Netcode
         /// </summary>
         public static NetworkUpdateStage UpdateStage;
 
-        private static void RunNetworkUpdateStage(NetworkUpdateStage updateStage)
+        internal static void RunNetworkUpdateStage(NetworkUpdateStage updateStage)
         {
             UpdateStage = updateStage;
 
@@ -222,6 +265,18 @@ namespace Unity.Netcode
             }
         }
 
+        internal struct NetworkPostScriptLateUpdate
+        {
+            public static PlayerLoopSystem CreateLoopSystem()
+            {
+                return new PlayerLoopSystem
+                {
+                    type = typeof(NetworkPostScriptLateUpdate),
+                    updateDelegate = () => RunNetworkUpdateStage(NetworkUpdateStage.PostScriptLateUpdate)
+                };
+            }
+        }
+
         internal struct NetworkPostLateUpdate
         {
             public static PlayerLoopSystem CreateLoopSystem()
@@ -363,6 +418,7 @@ namespace Unity.Netcode
                 else if (currentSystem.type == typeof(PreLateUpdate))
                 {
                     TryAddLoopSystem(ref currentSystem, NetworkPreLateUpdate.CreateLoopSystem(), typeof(PreLateUpdate.ScriptRunBehaviourLateUpdate), LoopSystemPosition.Before);
+                    TryAddLoopSystem(ref currentSystem, NetworkPostScriptLateUpdate.CreateLoopSystem(), typeof(PreLateUpdate.ScriptRunBehaviourLateUpdate), LoopSystemPosition.After);
                 }
                 else if (currentSystem.type == typeof(PostLateUpdate))
                 {
@@ -404,6 +460,7 @@ namespace Unity.Netcode
                 else if (currentSystem.type == typeof(PreLateUpdate))
                 {
                     TryRemoveLoopSystem(ref currentSystem, typeof(NetworkPreLateUpdate));
+                    TryRemoveLoopSystem(ref currentSystem, typeof(NetworkPostScriptLateUpdate));
                 }
                 else if (currentSystem.type == typeof(PostLateUpdate))
                 {

Runtime/Core/SnapshotRtt.cs

@@ -1,93 +0,0 @@
-using System;
-
-namespace Unity.Netcode
-{
-    internal class ConnectionRtt
-    {
-        private double[] m_RttSendTimes; // times at which packet were sent for RTT computations
-        private int[] m_SendSequence; // tick, or other key, at which packets were sent (to allow matching)
-        private double[] m_MeasuredLatencies; // measured latencies (ring buffer)
-        private int m_LatenciesBegin = 0; // ring buffer begin
-        private int m_LatenciesEnd = 0; // ring buffer end
-
-        /// <summary>
-        /// Round-trip-time data
-        /// </summary>
-        public struct Rtt
-        {
-            public double BestSec; // best RTT
-            public double AverageSec; // average RTT
-            public double WorstSec; // worst RTT
-            public double LastSec; // latest ack'ed RTT
-            public int SampleCount; // number of contributing samples
-        }
-
-        public ConnectionRtt()
-        {
-            m_RttSendTimes = new double[NetworkConfig.RttWindowSize];
-            m_SendSequence = new int[NetworkConfig.RttWindowSize];
-            m_MeasuredLatencies = new double[NetworkConfig.RttWindowSize];
-        }
-
-        /// <summary>
-        /// Returns the Round-trip-time computation for this client
-        /// </summary>
-        public Rtt GetRtt()
-        {
-            var ret = new Rtt();
-            var index = m_LatenciesBegin;
-            double total = 0.0;
-            ret.BestSec = m_MeasuredLatencies[m_LatenciesBegin];
-            ret.WorstSec = m_MeasuredLatencies[m_LatenciesBegin];
-
-            while (index != m_LatenciesEnd)
-            {
-                total += m_MeasuredLatencies[index];
-                ret.SampleCount++;
-                ret.BestSec = Math.Min(ret.BestSec, m_MeasuredLatencies[index]);
-                ret.WorstSec = Math.Max(ret.WorstSec, m_MeasuredLatencies[index]);
-                index = (index + 1) % NetworkConfig.RttAverageSamples;
-            }
-
-            if (ret.SampleCount != 0)
-            {
-                ret.AverageSec = total / ret.SampleCount;
-                // the latest RTT is one before m_LatenciesEnd
-                ret.LastSec = m_MeasuredLatencies[(m_LatenciesEnd + (NetworkConfig.RttWindowSize - 1)) % NetworkConfig.RttWindowSize];
-            }
-            else
-            {
-                ret.AverageSec = 0;
-                ret.BestSec = 0;
-                ret.WorstSec = 0;
-                ret.SampleCount = 0;
-                ret.LastSec = 0;
-            }
-
-            return ret;
-        }
-
-        internal void NotifySend(int sequence, double timeSec)
-        {
-            m_RttSendTimes[sequence % NetworkConfig.RttWindowSize] = timeSec;
-            m_SendSequence[sequence % NetworkConfig.RttWindowSize] = sequence;
-        }
-
-        internal void NotifyAck(int sequence, double timeSec)
-        {
-            // if the same slot was not used by a later send
-            if (m_SendSequence[sequence % NetworkConfig.RttWindowSize] == sequence)
-            {
-                double latency = timeSec - m_RttSendTimes[sequence % NetworkConfig.RttWindowSize];
-
-                m_MeasuredLatencies[m_LatenciesEnd] = latency;
-                m_LatenciesEnd = (m_LatenciesEnd + 1) % NetworkConfig.RttAverageSamples;
-
-                if (m_LatenciesEnd == m_LatenciesBegin)
-                {
-                    m_LatenciesBegin = (m_LatenciesBegin + 1) % NetworkConfig.RttAverageSamples;
-                }
-            }
-        }
-    }
-}

Runtime/Exceptions/InvalidParentException.cs

@@ -7,8 +7,18 @@ namespace Unity.Netcode
     /// </summary>
     public class InvalidParentException : Exception
     {
+        /// <summary>
+        /// Constructor for <see cref="InvalidParentException"/>
+        /// </summary>
         public InvalidParentException() { }
+
+        /// <inheritdoc/>
+        /// <param name="message"></param>
         public InvalidParentException(string message) : base(message) { }
+
+        /// <inheritdoc/>
+        /// <param name="message"></param>
+        /// <param name="innerException"></param>
         public InvalidParentException(string message, Exception innerException) : base(message, innerException) { }
     }
 }

Runtime/Exceptions/SpawnStateException.cs

@@ -26,8 +26,15 @@ namespace Unity.Netcode
         public SpawnStateException(string message, Exception inner) : base(message, inner) { }
     }
 
+    /// <summary>
+    /// Exception thrown when a specified network channel is invalid
+    /// </summary>
     public class InvalidChannelException : Exception
     {
+        /// <summary>
+        /// Constructs an InvalidChannelException with a message
+        /// </summary>
+        /// <param name="message">the message</param>
         public InvalidChannelException(string message) : base(message) { }
     }
 }

Runtime/Hashing/XXHash.cs

@@ -0,0 +1,248 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace Unity.Netcode
+{
+    internal static class XXHash
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe uint Hash32(byte* input, int length, uint seed = 0)
+        {
+            unchecked
+            {
+                const uint prime1 = 2654435761u;
+                const uint prime2 = 2246822519u;
+                const uint prime3 = 3266489917u;
+                const uint prime4 = 0668265263u;
+                const uint prime5 = 0374761393u;
+
+                uint hash = seed + prime5;
+
+                if (length >= 16)
+                {
+                    uint val0 = seed + prime1 + prime2;
+                    uint val1 = seed + prime2;
+                    uint val2 = seed + 0;
+                    uint val3 = seed - prime1;
+
+                    int count = length >> 4;
+                    for (int i = 0; i < count; i++)
+                    {
+                        var pos0 = *(uint*)(input + 0);
+                        var pos1 = *(uint*)(input + 4);
+                        var pos2 = *(uint*)(input + 8);
+                        var pos3 = *(uint*)(input + 12);
+
+                        val0 += pos0 * prime2;
+                        val0 = (val0 << 13) | (val0 >> (32 - 13));
+                        val0 *= prime1;
+
+                        val1 += pos1 * prime2;
+                        val1 = (val1 << 13) | (val1 >> (32 - 13));
+                        val1 *= prime1;
+
+                        val2 += pos2 * prime2;
+                        val2 = (val2 << 13) | (val2 >> (32 - 13));
+                        val2 *= prime1;
+
+                        val3 += pos3 * prime2;
+                        val3 = (val3 << 13) | (val3 >> (32 - 13));
+                        val3 *= prime1;
+
+                        input += 16;
+                    }
+
+                    hash = ((val0 << 01) | (val0 >> (32 - 01))) +
+                           ((val1 << 07) | (val1 >> (32 - 07))) +
+                           ((val2 << 12) | (val2 >> (32 - 12))) +
+                           ((val3 << 18) | (val3 >> (32 - 18)));
+                }
+
+                hash += (uint)length;
+
+                length &= 15;
+                while (length >= 4)
+                {
+                    hash += *(uint*)input * prime3;
+                    hash = ((hash << 17) | (hash >> (32 - 17))) * prime4;
+                    input += 4;
+                    length -= 4;
+                }
+                while (length > 0)
+                {
+                    hash += *input * prime5;
+                    hash = ((hash << 11) | (hash >> (32 - 11))) * prime1;
+                    ++input;
+                    --length;
+                }
+
+                hash ^= hash >> 15;
+                hash *= prime2;
+                hash ^= hash >> 13;
+                hash *= prime3;
+                hash ^= hash >> 16;
+
+                return hash;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe ulong Hash64(byte* input, int length, uint seed = 0)
+        {
+            unchecked
+            {
+                const ulong prime1 = 11400714785074694791ul;
+                const ulong prime2 = 14029467366897019727ul;
+                const ulong prime3 = 01609587929392839161ul;
+                const ulong prime4 = 09650029242287828579ul;
+                const ulong prime5 = 02870177450012600261ul;
+
+                ulong hash = seed + prime5;
+
+                if (length >= 32)
+                {
+                    ulong val0 = seed + prime1 + prime2;
+                    ulong val1 = seed + prime2;
+                    ulong val2 = seed + 0;
+                    ulong val3 = seed - prime1;
+
+                    int count = length >> 5;
+                    for (int i = 0; i < count; i++)
+                    {
+                        var pos0 = *(ulong*)(input + 0);
+                        var pos1 = *(ulong*)(input + 8);
+                        var pos2 = *(ulong*)(input + 16);
+                        var pos3 = *(ulong*)(input + 24);
+
+                        val0 += pos0 * prime2;
+                        val0 = (val0 << 31) | (val0 >> (64 - 31));
+                        val0 *= prime1;
+
+                        val1 += pos1 * prime2;
+                        val1 = (val1 << 31) | (val1 >> (64 - 31));
+                        val1 *= prime1;
+
+                        val2 += pos2 * prime2;
+                        val2 = (val2 << 31) | (val2 >> (64 - 31));
+                        val2 *= prime1;
+
+                        val3 += pos3 * prime2;
+                        val3 = (val3 << 31) | (val3 >> (64 - 31));
+                        val3 *= prime1;
+
+                        input += 32;
+                    }
+
+                    hash = ((val0 << 01) | (val0 >> (64 - 01))) +
+                           ((val1 << 07) | (val1 >> (64 - 07))) +
+                           ((val2 << 12) | (val2 >> (64 - 12))) +
+                           ((val3 << 18) | (val3 >> (64 - 18)));
+
+                    val0 *= prime2;
+                    val0 = (val0 << 31) | (val0 >> (64 - 31));
+                    val0 *= prime1;
+                    hash ^= val0;
+                    hash = hash * prime1 + prime4;
+
+                    val1 *= prime2;
+                    val1 = (val1 << 31) | (val1 >> (64 - 31));
+                    val1 *= prime1;
+                    hash ^= val1;
+                    hash = hash * prime1 + prime4;
+
+                    val2 *= prime2;
+                    val2 = (val2 << 31) | (val2 >> (64 - 31));
+                    val2 *= prime1;
+                    hash ^= val2;
+                    hash = hash * prime1 + prime4;
+
+                    val3 *= prime2;
+                    val3 = (val3 << 31) | (val3 >> (64 - 31));
+                    val3 *= prime1;
+                    hash ^= val3;
+                    hash = hash * prime1 + prime4;
+                }
+
+                hash += (ulong)length;
+
+                length &= 31;
+                while (length >= 8)
+                {
+                    ulong lane = *(ulong*)input * prime2;
+                    lane = ((lane << 31) | (lane >> (64 - 31))) * prime1;
+                    hash ^= lane;
+                    hash = ((hash << 27) | (hash >> (64 - 27))) * prime1 + prime4;
+                    input += 8;
+                    length -= 8;
+                }
+                if (length >= 4)
+                {
+                    hash ^= *(uint*)input * prime1;
+                    hash = ((hash << 23) | (hash >> (64 - 23))) * prime2 + prime3;
+                    input += 4;
+                    length -= 4;
+                }
+                while (length > 0)
+                {
+                    hash ^= *input * prime5;
+                    hash = ((hash << 11) | (hash >> (64 - 11))) * prime1;
+                    ++input;
+                    --length;
+                }
+
+                hash ^= hash >> 33;
+                hash *= prime2;
+                hash ^= hash >> 29;
+                hash *= prime3;
+                hash ^= hash >> 32;
+
+                return hash;
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint Hash32(this byte[] buffer)
+        {
+            int length = buffer.Length;
+            unsafe
+            {
+                fixed (byte* pointer = buffer)
+                {
+                    return Hash32(pointer, length);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint Hash32(this string text) => Hash32(Encoding.UTF8.GetBytes(text));
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint Hash32(this Type type) => Hash32(type.FullName);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint Hash32<T>() => Hash32(typeof(T));
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ulong Hash64(this byte[] buffer)
+        {
+            int length = buffer.Length;
+            unsafe
+            {
+                fixed (byte* pointer = buffer)
+                {
+                    return Hash64(pointer, length);
+                }
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ulong Hash64(this string text) => Hash64(Encoding.UTF8.GetBytes(text));
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ulong Hash64(this Type type) => Hash64(type.FullName);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static ulong Hash64<T>() => Hash64(typeof(T));
+    }
+}

Runtime/Hashing/XXHash.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: b5aa7a49e9e694f148d810d34577546b
+guid: c3077af091aa443acbdea9d3e97727b0
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Runtime/Hashing/XXHash/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015, 2016 Sedat Kapanoglu
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

Runtime/Hashing/XXHash/XXHash.cs

@@ -1,318 +0,0 @@
-// <copyright file="XXHash.cs" company="Sedat Kapanoglu">
-// Copyright (c) 2015-2019 Sedat Kapanoglu
-// MIT License (see LICENSE file for details)
-// </copyright>
-
-// @mfatihmar (Unity): Modified for Unity support
-
-using System.Text;
-using System.Runtime.CompilerServices;
-
-namespace Unity.Netcode
-{
-    /// <summary>
-    /// XXHash implementation.
-    /// </summary>
-    internal static class XXHash
-    {
-        private const ulong k_Prime64v1 = 11400714785074694791ul;
-        private const ulong k_Prime64v2 = 14029467366897019727ul;
-        private const ulong k_Prime64v3 = 1609587929392839161ul;
-        private const ulong k_Prime64v4 = 9650029242287828579ul;
-        private const ulong k_Prime64v5 = 2870177450012600261ul;
-
-        private const uint k_Prime32v1 = 2654435761u;
-        private const uint k_Prime32v2 = 2246822519u;
-        private const uint k_Prime32v3 = 3266489917u;
-        private const uint k_Prime32v4 = 668265263u;
-        private const uint k_Prime32v5 = 374761393u;
-
-        public static uint Hash32(string text) => Hash32(text, Encoding.UTF8);
-        public static uint Hash32(string text, Encoding encoding) => Hash32(encoding.GetBytes(text));
-        public static uint Hash32(byte[] buffer)
-        {
-            unsafe
-            {
-                fixed (byte* ptr = buffer)
-                {
-                    return Hash32(ptr, buffer.Length);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Generate a 32-bit xxHash value.
-        /// </summary>
-        /// <param name="buffer">Input buffer.</param>
-        /// <param name="bufferLength">Input buffer length.</param>
-        /// <param name="seed">Optional seed.</param>
-        /// <returns>32-bit hash value.</returns>
-        public static unsafe uint Hash32(byte* buffer, int bufferLength, uint seed = 0)
-        {
-            const int stripeLength = 16;
-
-            int len = bufferLength;
-            int remainingLen = len;
-            uint acc;
-
-            byte* pInput = buffer;
-            if (len >= stripeLength)
-            {
-                uint acc1 = seed + k_Prime32v1 + k_Prime32v2;
-                uint acc2 = seed + k_Prime32v2;
-                uint acc3 = seed;
-                uint acc4 = seed - k_Prime32v1;
-
-                do
-                {
-                    acc = processStripe32(ref pInput, ref acc1, ref acc2, ref acc3, ref acc4);
-                    remainingLen -= stripeLength;
-                } while (remainingLen >= stripeLength);
-            }
-            else
-            {
-                acc = seed + k_Prime32v5;
-            }
-
-            acc += (uint)len;
-            acc = processRemaining32(pInput, acc, remainingLen);
-
-            return avalanche32(acc);
-        }
-
-        public static ulong Hash64(string text) => Hash64(text, Encoding.UTF8);
-        public static ulong Hash64(string text, Encoding encoding) => Hash64(encoding.GetBytes(text));
-        public static ulong Hash64(byte[] buffer)
-        {
-            unsafe
-            {
-                fixed (byte* ptr = buffer)
-                {
-                    return Hash64(ptr, buffer.Length);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Generate a 64-bit xxHash value.
-        /// </summary>
-        /// <param name="buffer">Input buffer.</param>
-        /// <param name="bufferLength">Input buffer length.</param>
-        /// <param name="seed">Optional seed.</param>
-        /// <returns>Computed 64-bit hash value.</returns>
-        public static unsafe ulong Hash64(byte* buffer, int bufferLength, ulong seed = 0)
-        {
-            const int stripeLength = 32;
-
-            int len = bufferLength;
-            int remainingLen = len;
-            ulong acc;
-
-            byte* pInput = buffer;
-            if (len >= stripeLength)
-            {
-                ulong acc1 = seed + k_Prime64v1 + k_Prime64v2;
-                ulong acc2 = seed + k_Prime64v2;
-                ulong acc3 = seed;
-                ulong acc4 = seed - k_Prime64v1;
-
-                do
-                {
-                    acc = processStripe64(ref pInput, ref acc1, ref acc2, ref acc3, ref acc4);
-                    remainingLen -= stripeLength;
-                } while (remainingLen >= stripeLength);
-            }
-            else
-            {
-                acc = seed + k_Prime64v5;
-            }
-
-            acc += (ulong)len;
-            acc = processRemaining64(pInput, acc, remainingLen);
-
-
-            return avalanche64(acc);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe ulong processStripe64(
-            ref byte* pInput,
-            ref ulong acc1,
-            ref ulong acc2,
-            ref ulong acc3,
-            ref ulong acc4)
-        {
-            processLane64(ref acc1, ref pInput);
-            processLane64(ref acc2, ref pInput);
-            processLane64(ref acc3, ref pInput);
-            processLane64(ref acc4, ref pInput);
-
-            ulong acc = Bits.RotateLeft(acc1, 1)
-                        + Bits.RotateLeft(acc2, 7)
-                        + Bits.RotateLeft(acc3, 12)
-                        + Bits.RotateLeft(acc4, 18);
-
-            mergeAccumulator64(ref acc, acc1);
-            mergeAccumulator64(ref acc, acc2);
-            mergeAccumulator64(ref acc, acc3);
-            mergeAccumulator64(ref acc, acc4);
-            return acc;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe void processLane64(ref ulong accn, ref byte* pInput)
-        {
-            ulong lane = *(ulong*)pInput;
-            accn = round64(accn, lane);
-            pInput += 8;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe ulong processRemaining64(
-            byte* pInput,
-            ulong acc,
-            int remainingLen)
-        {
-            for (ulong lane; remainingLen >= 8; remainingLen -= 8, pInput += 8)
-            {
-                lane = *(ulong*)pInput;
-
-                acc ^= round64(0, lane);
-                acc = Bits.RotateLeft(acc, 27) * k_Prime64v1;
-                acc += k_Prime64v4;
-            }
-
-            for (uint lane32; remainingLen >= 4; remainingLen -= 4, pInput += 4)
-            {
-                lane32 = *(uint*)pInput;
-
-                acc ^= lane32 * k_Prime64v1;
-                acc = Bits.RotateLeft(acc, 23) * k_Prime64v2;
-                acc += k_Prime64v3;
-            }
-
-            for (byte lane8; remainingLen >= 1; remainingLen--, pInput++)
-            {
-                lane8 = *pInput;
-                acc ^= lane8 * k_Prime64v5;
-                acc = Bits.RotateLeft(acc, 11) * k_Prime64v1;
-            }
-
-            return acc;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static ulong avalanche64(ulong acc)
-        {
-            acc ^= acc >> 33;
-            acc *= k_Prime64v2;
-            acc ^= acc >> 29;
-            acc *= k_Prime64v3;
-            acc ^= acc >> 32;
-            return acc;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static ulong round64(ulong accn, ulong lane)
-        {
-            accn += lane * k_Prime64v2;
-            return Bits.RotateLeft(accn, 31) * k_Prime64v1;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static void mergeAccumulator64(ref ulong acc, ulong accn)
-        {
-            acc ^= round64(0, accn);
-            acc *= k_Prime64v1;
-            acc += k_Prime64v4;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe uint processStripe32(
-            ref byte* pInput,
-            ref uint acc1,
-            ref uint acc2,
-            ref uint acc3,
-            ref uint acc4)
-        {
-            processLane32(ref pInput, ref acc1);
-            processLane32(ref pInput, ref acc2);
-            processLane32(ref pInput, ref acc3);
-            processLane32(ref pInput, ref acc4);
-
-            return Bits.RotateLeft(acc1, 1)
-                   + Bits.RotateLeft(acc2, 7)
-                   + Bits.RotateLeft(acc3, 12)
-                   + Bits.RotateLeft(acc4, 18);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe void processLane32(ref byte* pInput, ref uint accn)
-        {
-            uint lane = *(uint*)pInput;
-            accn = round32(accn, lane);
-            pInput += 4;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe uint processRemaining32(
-            byte* pInput,
-            uint acc,
-            int remainingLen)
-        {
-            for (uint lane; remainingLen >= 4; remainingLen -= 4, pInput += 4)
-            {
-                lane = *(uint*)pInput;
-                acc += lane * k_Prime32v3;
-                acc = Bits.RotateLeft(acc, 17) * k_Prime32v4;
-            }
-
-            for (byte lane; remainingLen >= 1; remainingLen--, pInput++)
-            {
-                lane = *pInput;
-                acc += lane * k_Prime32v5;
-                acc = Bits.RotateLeft(acc, 11) * k_Prime32v1;
-            }
-
-            return acc;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static uint round32(uint accn, uint lane)
-        {
-            accn += lane * k_Prime32v2;
-            accn = Bits.RotateLeft(accn, 13);
-            accn *= k_Prime32v1;
-            return accn;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static uint avalanche32(uint acc)
-        {
-            acc ^= acc >> 15;
-            acc *= k_Prime32v2;
-            acc ^= acc >> 13;
-            acc *= k_Prime32v3;
-            acc ^= acc >> 16;
-            return acc;
-        }
-
-        /// <summary>
-        /// Bit operations.
-        /// </summary>
-        private static class Bits
-        {
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal static ulong RotateLeft(ulong value, int bits)
-            {
-                return (value << bits) | (value >> (64 - bits));
-            }
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            internal static uint RotateLeft(uint value, int bits)
-            {
-                return (value << bits) | (value >> (32 - bits));
-            }
-        }
-    }
-}

Runtime/Logging/NetworkLog.cs

@@ -14,9 +14,24 @@ namespace Unity.Netcode
         public static LogLevel CurrentLogLevel => NetworkManager.Singleton == null ? LogLevel.Normal : NetworkManager.Singleton.LogLevel;
 
         // internal logging
-        internal static void LogInfo(string message) => Debug.Log($"[Netcode] {message}");
-        internal static void LogWarning(string message) => Debug.LogWarning($"[Netcode] {message}");
-        internal static void LogError(string message) => Debug.LogError($"[Netcode] {message}");
+
+        /// <summary>
+        /// Locally logs a info log with Netcode prefixing.
+        /// </summary>
+        /// <param name="message">The message to log</param>
+        public static void LogInfo(string message) => Debug.Log($"[Netcode] {message}");
+
+        /// <summary>
+        /// Locally logs a warning log with Netcode prefixing.
+        /// </summary>
+        /// <param name="message">The message to log</param>
+        public static void LogWarning(string message) => Debug.LogWarning($"[Netcode] {message}");
+
+        /// <summary>
+        /// Locally logs a error log with Netcode prefixing.
+        /// </summary>
+        /// <param name="message">The message to log</param>
+        public static void LogError(string message) => Debug.LogError($"[Netcode] {message}");
 
         /// <summary>
         /// Logs an info log locally and on the server if possible.
@@ -36,36 +51,58 @@ namespace Unity.Netcode
         /// <param name="message">The message to log</param>
         public static void LogErrorServer(string message) => LogServer(message, LogType.Error);
 
+        internal static NetworkManager NetworkManagerOverride;
+
         private static void LogServer(string message, LogType logType)
         {
+            var networkManager = NetworkManagerOverride ??= NetworkManager.Singleton;
             // Get the sender of the local log
-            ulong localId = NetworkManager.Singleton != null ? NetworkManager.Singleton.LocalClientId : 0;
-
+            ulong localId = networkManager?.LocalClientId ?? 0;
+            bool isServer = networkManager?.IsServer ?? true;
             switch (logType)
             {
                 case LogType.Info:
-                    LogInfoServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogInfoServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogInfo(message);
+                    }
                     break;
                 case LogType.Warning:
-                    LogWarningServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogWarningServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogWarning(message);
+                    }
                     break;
                 case LogType.Error:
-                    LogErrorServerLocal(message, localId);
+                    if (isServer)
+                    {
+                        LogErrorServerLocal(message, localId);
+                    }
+                    else
+                    {
+                        LogError(message);
+                    }
                     break;
             }
 
-            if (NetworkManager.Singleton != null && !NetworkManager.Singleton.IsServer && NetworkManager.Singleton.NetworkConfig.EnableNetworkLogs)
+            if (!isServer && networkManager.NetworkConfig.EnableNetworkLogs)
             {
-
                 var networkMessage = new ServerLogMessage
                 {
                     LogType = logType,
                     Message = message
                 };
-                var size = NetworkManager.Singleton.SendMessage(networkMessage, NetworkDelivery.ReliableFragmentedSequenced,
-                    NetworkManager.Singleton.ServerClientId);
+                var size = networkManager.ConnectionManager.SendMessage(ref networkMessage, NetworkDelivery.ReliableFragmentedSequenced, NetworkManager.ServerClientId);
 
-                NetworkManager.Singleton.NetworkMetrics.TrackServerLogSent(NetworkManager.Singleton.ServerClientId, (uint)logType, size);
+                networkManager.NetworkMetrics.TrackServerLogSent(NetworkManager.ServerClientId, (uint)logType, size);
             }
         }
 

Runtime/Messaging/BatchHeader.cs

@@ -1,13 +0,0 @@
-namespace Unity.Netcode
-{
-    /// <summary>
-    /// Header placed at the start of each message batch
-    /// </summary>
-    internal struct BatchHeader
-    {
-        /// <summary>
-        /// Total number of messages in the batch.
-        /// </summary>
-        public ushort BatchSize;
-    }
-}

Runtime/Messaging/CustomMessageManager.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using Unity.Collections;
+using UnityEngine;
 
 namespace Unity.Netcode
 {
@@ -68,14 +70,28 @@ namespace Unity.Netcode
 
             if (clientIds == null)
             {
-                throw new ArgumentNullException("You must pass in a valid clientId List");
+                throw new ArgumentNullException(nameof(clientIds), "You must pass in a valid clientId List");
             }
 
+            if (m_NetworkManager.IsHost)
+            {
+                for (var i = 0; i < clientIds.Count; ++i)
+                {
+                    if (clientIds[i] == m_NetworkManager.LocalClientId)
+                    {
+                        InvokeUnnamedMessage(
+                            m_NetworkManager.LocalClientId,
+                            new FastBufferReader(messageBuffer, Allocator.None),
+                            0
+                        );
+                    }
+                }
+            }
             var message = new UnnamedMessage
             {
-                Data = messageBuffer
+                SendData = messageBuffer
             };
-            var size = m_NetworkManager.SendMessage(message, networkDelivery, clientIds);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientIds);
 
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)
@@ -92,11 +108,23 @@ namespace Unity.Netcode
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendUnnamedMessage(ulong clientId, FastBufferWriter messageBuffer, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
         {
+            if (m_NetworkManager.IsHost)
+            {
+                if (clientId == m_NetworkManager.LocalClientId)
+                {
+                    InvokeUnnamedMessage(
+                        m_NetworkManager.LocalClientId,
+                        new FastBufferReader(messageBuffer, Allocator.None),
+                        0
+                    );
+                    return;
+                }
+            }
             var message = new UnnamedMessage
             {
-                Data = messageBuffer
+                SendData = messageBuffer
             };
-            var size = m_NetworkManager.SendMessage(message, networkDelivery, clientId);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientId);
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)
             {
@@ -124,14 +152,18 @@ namespace Unity.Netcode
                 // We dont know what size to use. Try every (more collision prone)
                 if (m_NamedMessageHandlers32.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler32))
                 {
+                    // handler can remove itself, cache the name for metrics
+                    string messageName = m_MessageHandlerNameLookup32[hash];
                     messageHandler32(sender, reader);
-                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup32[hash], bytesCount);
+                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
                 }
 
                 if (m_NamedMessageHandlers64.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler64))
                 {
+                    // handler can remove itself, cache the name for metrics
+                    string messageName = m_MessageHandlerNameLookup64[hash];
                     messageHandler64(sender, reader);
-                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup64[hash], bytesCount);
+                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
                 }
             }
             else
@@ -142,15 +174,19 @@ namespace Unity.Netcode
                     case HashSize.VarIntFourBytes:
                         if (m_NamedMessageHandlers32.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler32))
                         {
+                            // handler can remove itself, cache the name for metrics
+                            string messageName = m_MessageHandlerNameLookup32[hash];
                             messageHandler32(sender, reader);
-                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup32[hash], bytesCount);
+                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
                         }
                         break;
                     case HashSize.VarIntEightBytes:
                         if (m_NamedMessageHandlers64.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler64))
                         {
+                            // handler can remove itself, cache the name for metrics
+                            string messageName = m_MessageHandlerNameLookup64[hash];
                             messageHandler64(sender, reader);
-                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup64[hash], bytesCount);
+                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
                         }
                         break;
                 }
@@ -164,6 +200,14 @@ namespace Unity.Netcode
         /// <param name="callback">The callback to run when a named message is received.</param>
         public void RegisterNamedMessageHandler(string name, HandleNamedMessageDelegate callback)
         {
+            if (string.IsNullOrEmpty(name))
+            {
+                if (m_NetworkManager.LogLevel <= LogLevel.Error)
+                {
+                    Debug.LogError($"[{nameof(RegisterNamedMessageHandler)}] Cannot register a named message of type null or empty!");
+                }
+                return;
+            }
             var hash32 = XXHash.Hash32(name);
             var hash64 = XXHash.Hash64(name);
 
@@ -180,6 +224,15 @@ namespace Unity.Netcode
         /// <param name="name">The name of the message.</param>
         public void UnregisterNamedMessageHandler(string name)
         {
+            if (string.IsNullOrEmpty(name))
+            {
+                if (m_NetworkManager.LogLevel <= LogLevel.Error)
+                {
+                    Debug.LogError($"[{nameof(UnregisterNamedMessageHandler)}] Cannot unregister a named message of type null or empty!");
+                }
+                return;
+            }
+
             var hash32 = XXHash.Hash32(name);
             var hash64 = XXHash.Hash64(name);
 
@@ -193,6 +246,7 @@ namespace Unity.Netcode
         /// <summary>
         /// Sends a named message to all clients
         /// </summary>
+        /// <param name="messageName">The message name to send</param>
         /// <param name="messageStream">The message stream containing the data</param>
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendNamedMessageToAll(string messageName, FastBufferWriter messageStream, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
@@ -219,13 +273,27 @@ namespace Unity.Netcode
                     hash = XXHash.Hash64(messageName);
                     break;
             }
+            if (m_NetworkManager.IsHost)
+            {
+                if (clientId == m_NetworkManager.LocalClientId)
+                {
+                    InvokeNamedMessage(
+                        hash,
+                        m_NetworkManager.LocalClientId,
+                        new FastBufferReader(messageStream, Allocator.None),
+                        0
+                    );
+
+                    return;
+                }
+            }
 
             var message = new NamedMessage
             {
                 Hash = hash,
-                Data = messageStream
+                SendData = messageStream,
             };
-            var size = m_NetworkManager.SendMessage(message, networkDelivery, clientId);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientId);
 
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)
@@ -238,7 +306,7 @@ namespace Unity.Netcode
         /// Sends the named message
         /// </summary>
         /// <param name="messageName">The message name to send</param>
-        /// <param name="clientIds">The clients to send to, sends to everyone if null</param>
+        /// <param name="clientIds">The clients to send to</param>
         /// <param name="messageStream">The message stream containing the data</param>
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendNamedMessage(string messageName, IReadOnlyList<ulong> clientIds, FastBufferWriter messageStream, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
@@ -250,7 +318,7 @@ namespace Unity.Netcode
 
             if (clientIds == null)
             {
-                throw new ArgumentNullException("You must pass in a valid clientId List");
+                throw new ArgumentNullException(nameof(clientIds), "You must pass in a valid clientId List");
             }
 
             ulong hash = 0;
@@ -263,12 +331,27 @@ namespace Unity.Netcode
                     hash = XXHash.Hash64(messageName);
                     break;
             }
+            if (m_NetworkManager.IsHost)
+            {
+                for (var i = 0; i < clientIds.Count; ++i)
+                {
+                    if (clientIds[i] == m_NetworkManager.LocalClientId)
+                    {
+                        InvokeNamedMessage(
+                            hash,
+                            m_NetworkManager.LocalClientId,
+                            new FastBufferReader(messageStream, Allocator.None),
+                            0
+                        );
+                    }
+                }
+            }
             var message = new NamedMessage
             {
                 Hash = hash,
-                Data = messageStream
+                SendData = messageStream
             };
-            var size = m_NetworkManager.SendMessage(message, networkDelivery, clientIds);
+            var size = m_NetworkManager.ConnectionManager.SendMessage(ref message, networkDelivery, clientIds);
 
             // Size is zero if we were only sending the message to ourself in which case it isn't sent.
             if (size != 0)

Runtime/Messaging/DefaultMessageSender.cs

@@ -0,0 +1,26 @@
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// Default NetworkTransport Message Sender
+    /// <see cref="NetworkMessageManager"/>
+    /// </summary>
+    internal class DefaultMessageSender : INetworkMessageSender
+    {
+        private NetworkTransport m_NetworkTransport;
+        private NetworkConnectionManager m_ConnectionManager;
+
+        public DefaultMessageSender(NetworkManager manager)
+        {
+            m_NetworkTransport = manager.NetworkConfig.NetworkTransport;
+            m_ConnectionManager = manager.ConnectionManager;
+        }
+
+        public void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
+        {
+            var sendBuffer = batchData.ToTempByteArray();
+
+            m_NetworkTransport.Send(m_ConnectionManager.ClientIdToTransportId(clientId), sendBuffer, delivery);
+        }
+    }
+}

Runtime/Messaging/DefaultMessageSender.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5ea6bdd38832d9947bb21c4b35bf61d0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Messaging/DeferredMessageManager.cs

@@ -0,0 +1,148 @@
+using System.Collections.Generic;
+using Unity.Collections;
+
+namespace Unity.Netcode
+{
+    internal class DeferredMessageManager : IDeferredNetworkMessageManager
+    {
+        protected struct TriggerData
+        {
+            public FastBufferReader Reader;
+            public NetworkMessageHeader Header;
+            public ulong SenderId;
+            public float Timestamp;
+            public int SerializedHeaderSize;
+        }
+        protected struct TriggerInfo
+        {
+            public float Expiry;
+            public NativeList<TriggerData> TriggerData;
+        }
+
+        protected readonly Dictionary<IDeferredNetworkMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>> m_Triggers = new Dictionary<IDeferredNetworkMessageManager.TriggerType, Dictionary<ulong, TriggerInfo>>();
+
+        private readonly NetworkManager m_NetworkManager;
+
+        internal DeferredMessageManager(NetworkManager networkManager)
+        {
+            m_NetworkManager = networkManager;
+        }
+
+        /// <summary>
+        /// Defers processing of a message until the moment a specific networkObjectId is spawned.
+        /// This is to handle situations where an RPC or other object-specific message arrives before the spawn does,
+        /// either due to it being requested in OnNetworkSpawn before the spawn call has been executed
+        ///
+        /// There is a one second maximum lifetime of triggers to avoid memory leaks. After one second has passed
+        /// without the requested object ID being spawned, the triggers for it are automatically deleted.
+        /// </summary>
+        public virtual unsafe void DeferMessage(IDeferredNetworkMessageManager.TriggerType trigger, ulong key, FastBufferReader reader, ref NetworkContext context)
+        {
+            if (!m_Triggers.TryGetValue(trigger, out var triggers))
+            {
+                triggers = new Dictionary<ulong, TriggerInfo>();
+                m_Triggers[trigger] = triggers;
+            }
+
+            if (!triggers.TryGetValue(key, out var triggerInfo))
+            {
+                triggerInfo = new TriggerInfo
+                {
+                    Expiry = m_NetworkManager.RealTimeProvider.RealTimeSinceStartup + m_NetworkManager.NetworkConfig.SpawnTimeout,
+                    TriggerData = new NativeList<TriggerData>(Allocator.Persistent)
+                };
+                triggers[key] = triggerInfo;
+            }
+
+            triggerInfo.TriggerData.Add(new TriggerData
+            {
+                Reader = new FastBufferReader(reader.GetUnsafePtr(), Allocator.Persistent, reader.Length),
+                Header = context.Header,
+                Timestamp = context.Timestamp,
+                SenderId = context.SenderId,
+                SerializedHeaderSize = context.SerializedHeaderSize
+            });
+        }
+
+        /// <summary>
+        /// Cleans up any trigger that's existed for more than a second.
+        /// These triggers were probably for situations where a request was received after a despawn rather than before a spawn.
+        /// </summary>
+        public virtual unsafe void CleanupStaleTriggers()
+        {
+            foreach (var kvp in m_Triggers)
+            {
+                ulong* staleKeys = stackalloc ulong[kvp.Value.Count];
+                int index = 0;
+                foreach (var kvp2 in kvp.Value)
+                {
+                    if (kvp2.Value.Expiry < m_NetworkManager.RealTimeProvider.RealTimeSinceStartup)
+                    {
+                        staleKeys[index++] = kvp2.Key;
+                        PurgeTrigger(kvp.Key, kvp2.Key, kvp2.Value);
+                    }
+                }
+
+                for (var i = 0; i < index; ++i)
+                {
+                    kvp.Value.Remove(staleKeys[i]);
+                }
+            }
+        }
+
+        protected virtual void PurgeTrigger(IDeferredNetworkMessageManager.TriggerType triggerType, ulong key, TriggerInfo triggerInfo)
+        {
+            if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+            {
+                NetworkLog.LogWarning($"Deferred messages were received for a trigger of type {triggerType} with key {key}, but that trigger was not received within within {m_NetworkManager.NetworkConfig.SpawnTimeout} second(s).");
+            }
+
+            foreach (var data in triggerInfo.TriggerData)
+            {
+                data.Reader.Dispose();
+            }
+
+            triggerInfo.TriggerData.Dispose();
+        }
+
+        public virtual void ProcessTriggers(IDeferredNetworkMessageManager.TriggerType trigger, ulong key)
+        {
+            if (m_Triggers.TryGetValue(trigger, out var triggers))
+            {
+                // This must happen after InvokeBehaviourNetworkSpawn, otherwise ClientRPCs and other messages can be
+                // processed before the object is fully spawned. This must be the last thing done in the spawn process.
+                if (triggers.TryGetValue(key, out var triggerInfo))
+                {
+                    triggers.Remove(key);
+                    foreach (var deferredMessage in triggerInfo.TriggerData)
+                    {
+                        // Reader will be disposed within HandleMessage
+                        m_NetworkManager.ConnectionManager.MessageManager.HandleMessage(deferredMessage.Header, deferredMessage.Reader, deferredMessage.SenderId, deferredMessage.Timestamp, deferredMessage.SerializedHeaderSize);
+                    }
+
+                    triggerInfo.TriggerData.Dispose();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Cleans up any trigger that's existed for more than a second.
+        /// These triggers were probably for situations where a request was received after a despawn rather than before a spawn.
+        /// </summary>
+        public virtual void CleanupAllTriggers()
+        {
+            foreach (var kvp in m_Triggers)
+            {
+                foreach (var kvp2 in kvp.Value)
+                {
+                    foreach (var data in kvp2.Value.TriggerData)
+                    {
+                        data.Reader.Dispose();
+                    }
+                    kvp2.Value.TriggerData.Dispose();
+                }
+            }
+            m_Triggers.Clear();
+        }
+    }
+}

Runtime/Messaging/DeferredMessageManager.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ac7f57f7d16a46e2aba65558e873727f
+timeCreated: 1649799187

Runtime/Messaging/DisconnectReasonMessage.cs

@@ -0,0 +1,43 @@
+namespace Unity.Netcode
+{
+    internal struct DisconnectReasonMessage : INetworkMessage
+    {
+        public string Reason;
+
+        public int Version => 0;
+
+        public void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            string reasonSent = Reason ?? string.Empty;
+
+            // Since we don't send a ConnectionApprovedMessage, the version for this message is encded with the message itself.
+            // However, note that we HAVE received a ConnectionRequestMessage, so we DO have a valid targetVersion on this side of things.
+            // We just have to make sure the receiving side knows what version we sent it, since whoever has the higher version number is responsible for versioning and they may be the one with the higher version number.
+            BytePacker.WriteValueBitPacked(writer, Version);
+
+            if (writer.TryBeginWrite(FastBufferWriter.GetWriteSize(reasonSent)))
+            {
+                writer.WriteValue(reasonSent);
+            }
+            else
+            {
+                writer.WriteValueSafe(string.Empty);
+                NetworkLog.LogWarning("Disconnect reason didn't fit. Disconnected without sending a reason. Consider shortening the reason string.");
+            }
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            // Since we don't get a ConnectionApprovedMessage, the version for this message is encded with the message itself.
+            // This will override what we got from MessageManager... which will always be 0 here.
+            ByteUnpacker.ReadValueBitPacked(reader, out receivedMessageVersion);
+            reader.ReadValueSafe(out Reason);
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            ((NetworkManager)context.SystemOwner).ConnectionManager.DisconnectReason = Reason;
+        }
+    };
+}