fix: NetworkTransform initial synchronization, parenting, smooth transitions between transform spaces, and UI updates

[NoelStephensUnity]

Parenting & Smooth Transform Space Transitions

This PR contains a handful of NetworkTransform fixes pertaining to parenting, the initial synchronizing parented NetworkObjects with newly/late joined clients, issues with smooth transform space transitions (specific to parenting) while interpolation is enabled, and provides the ability to tick synchronize nested and parented NetworkTransform instances.

Side Note: #3039 is the example project to that demonstrates these updates and includes additional (and useful) helper classes.

The below described properties allow for seamless transform space parenting and transitions when interpolation is enabled (primarily focusing on the owner authoritative motion model), and only requires setting the parent of the owned NetworkObject (i.e. no more predicting RTT between the server and client owner) to accomplish this.
Side Note: This is only for non-Rigidbody spawned instances. There will be a follow up PR to handle the Rigidbody approach that will still leverage from some of the below properties, but there is a different dynamic involved with PhysX based "parenting" (i_n reality there is no such thing as local space in the PhysX simulation so using Joints combined with tick synchronized children is the better approach_).

NetworkTransform.SwitchTransformSpaceWhenParented

When enabled, the "Tick Sync Children" property is automatically enabled to assure any already parented children will be synchronized properly as well as it handles tick synchronizing nested NetworkTransform components. This also automatically updates owner authoritative's NetworkTransform.InLocalSpace setting, handles updating/converting each LinearBufferInterpolator entries to the proper transform space relative to the current, previous, or current and previous (if doing a NetworkObject to NetworkObject transition) parent(s).

This does not apply to NetworkTransform component(s) paired with NetworkRigidbody component(s), as that will be the next PR update for v2.0.0.

NetworkTransform.TickSyncChildren

When enabled, nested NetworkTransform components will be synchronized with the root NetworkTransform or in the event they are all nested under a root GameObject with NetworkObject component the first NetworkTransform in that hierarchy.

How this works:

When the root NetworkTransform (on the authoritative instance) detects a state update needs to be sent, it will then have all nested and/or child (parented) NetworkTransforms (as long as the client has authority over them) send state updates. This helps to prevent a potential issue where nested or child NetworkTransform components could get into a state where they are all sending updates on different ticks which can lead to visual "jittering" between the associated GameObject transforms.
This property is automatically enabled when NetworkTransform.SwitchTransformSpaceWhenParented is enabled.

NetworkObject.AllowOwnerToParent

This is primarily a property for client-server network topology based projects that might use an owner authoritative motion model (typically for player avatars/prefabs). Enabling this property allows the client owner to immediately parent the owned object under another NetworkObject in order to assure there is no latency between the parenting event and NetworkTransform updates. This is especially important when handling NetworkObject to NetworkObject parenting when using a client-server network topology in order to maintain smooth transitions on non-authoritative instances.
Note: Setting this property when using a distributed authority network topology has no effect since client owners already have the authority to handle immediate local parenting.

NetworkObject.SyncOwnerTransformWhenParented

When disabled, this property will not apply the server-side transform values received via the ParentSyncMessage on the client owner side. This is more specific to owner authoritative motion models (i.e. NetworkTransform with owner authority) but can be useful under other scenarios where having the client owner not applying the server-side's transform state is required. Disabling this property impacts non-authoritative instances in the following ways (depending upon the network topology being used):

• Client-server: The non-authoritative instances will always apply the server's transform state. The server's transform state leads the non-authoritative instance(s) state(s) by roughly 1 network tick relative to the client owner's transform state.
• Distributed authority: The non-authoritative instances will always apply the owner's transform state. Since the client has authority. Because of this, enabling this property has no significant impact.
  When enabled (default), client owner will apply the server's transform state when receiving the ParentSyncMessage from the server (but has no impact when using a distributed authority network topology).

UI Updates & NetcodeEditorBase

This PR also includes a new NetcodeEditorBase editor that can be used with any MonoBehaviour derived component and helps to organize inspector view properties by child class generation. The NetworkTransform, NetworkRigidbodyBase, and NetworkManager editors now derive from NetcodeEditorBase so any child derived from one of these three components will provide this separation of child generation relative properties. When used in their original form (i.e. not a component derived from) it will show only the properties and not apply the foldout group.

Folder Grouping of Each Generational Child

The NetcodeEditorBase, used by NetworkTransform, NetworkRigidbodyBase, and NetworkManager custom editors, provides a clean separation between the base class and any derived child.

NetworkTransform Example:

The NetworkTransform derived both child generation properties are collapsed:

Expanding the last generation child, MoverScriptNoRigidbody, properties:

Expanding the NetworkTransform parent class properties:

NetworkManager Example:

For those who like to store additional netcode and/or project specific settings in the same place, deriving from the NetworkManager while using NetcodeEditorBase for the ExtendedNetworkManagerEditor:
Collapsed:

Fully expanded:

Multi-Object Compatible

The NetcodeEditorBase is Multi-Object compatible. Below is a prefab with several children selected that have the same PlayerBallMotion : NetworkTransform component:

When the NetworkTransform properties are expanded, you get the same custom editor view for all selected objects:

MTTB-66
MTTB-6

fix: #2959
fix: #2913
fix: #2856
fix: #2843
fix: #2842

Changelog

• Added NetworkTransform.SwitchTransformSpaceWhenParented property that, when enabled, will handle the world to local, local to world, and local to local transform space transitions when interpolation is enabled.
• Added NetworkTransform.TickSyncChildren that, when enabled, will tick synchronize nested and/or child NetworkTransform components to eliminate any potential visual jittering that could occur if the NetworkTransform instances get into a state where their state updates are landing on different network ticks.
• Added NetworkObject.AllowOwnerToParent property to provide the ability to allow clients to parent owned objects when running in a client-server network topology.
• Added NetworkObject.SyncOwnerTransformWhenParented property to provide a way to disable applying the server's transform information in the parenting message on the client owner instance which can be useful for owner authoritative motion models.
• Added NetcodeEditorBase editor helper class to provide easier modification and extension of the SDK's components.
• Fixed issue with newly/late joined clients and NetworkTransform synchronization of parented NetworkObject instances.
• Fixed issue with smooth transitions between transform spaces when interpolation is enabled (requires NetworkTransform.SwitchTransformSpaceWhenParented to be enabled).
• Changed NetworkTransformEditor so it now derives from NetcodeEditorBase.
• Changed NetworkRigidbodyBaseEditor so it now derives from NetcodeEditorBase.
• Changed NetworkManagerEditor so it now derives from NetcodeEditorBase.

Testing and Documentation

• Includes integration tests.
• Documentation additions are necessary.

[danni-lu]

I have a little comment here. I like the foldout idea, but I think maybe we can take the call-to-action buttons out so users can access them without expanding the foldout content, especially during runtime when there's nothing much within the foldout section. I made a quick mock here! Please lemme know if this makes sense!

Side note: would it make sense to show network manager properties during runtime? will people need this information?

[NoelStephensUnity]

Awesome feedback... and good points.
Made the suggested changes and pushed the update.
👍