com.unity.netcode@0.6.0-preview.7

## [0.6.0] - 2020-11-26
### New features
* Added DynamicBuffers serialization support to ghosts. Like IComponentData, is now possible to annotate IBufferElementData with GhostComponentAttribute and members with GhostFieldAttribute
and having the buffers replicated through the network.
* ICommandData are now serializable and can be sent to the remote players.
* Added new SendToOwner property to the GhostComponentAttribute that can be used to configure to witch
subset of players the component should be sent to: only to the owner, only to the non owner, or all.
* Ghost Component Serialization Variant. A new GhostComponentVariation attribute has been introduced that let you to specify different serialization options for a component or buffer, by overriding
the `[GhostField]` and `[GhostComponent]` properties present in the original type definition.
* It is possible to prevent a component to support variation by using the `[DontSupportVariation]` attribute. When present, if a GhostComponentVariation is defined for that type, an exception is triggered.
* Ghost components attributes and serialization variants can be customized per prefabs. For every component in a ghost prefab, it is possible to change:
    * PrefabType
    * GhostSendType
    * The variant to use, if variants for that component exist.
* Is possible to prevent a component to support per-prefab overrides by using the [DontSupportPrefabOverride] attribute. When present, the component can't be further customized in the inspector.
* It's now possible to register a prediction smoothing function, by calling the `GhostPredictionSmoothingSystem.RegisterSmoothingAction<ComponentType>(SmoothingActionDelegate)` and supplying a `ComponentType` and `GhostPredictionSmoothingSystem.SmoothingActionDelegate` (see Runtime/Snapshot/DefaultUserParams.cs for an example).
* Added a new `ClientTickRate` component which when added to a singleton entity controls the interpolation times used to calculate time on the client. The default values can be accessed through the static `NetworkTimeSystem.DefaultClientTickRate`.
* Added support for extrapolation when the tick being applied to interpolated ghosts on the client has not been received yet and is outside the interpolation delay. Set the new `Smoothing` field in the `GhostField` attribute to `SmoothingAction.InterpolateAndExtrapolate` to enable extrapolation.
* Added a `MaxSmoothingDistance` parameter to the `[GhostField]` attribute. If specified interpolation will be disabled when the values change more than that limit between two snapshots. This is useful for dealing with teleportation and similar changes which should not be interpolated.

### Changes
* It is no longer required to create a ghost collection, as long as there is a prefab for a ghost it will be picked up automatically. You can create a prefab by referencing it in a spawner component or by placing a pre spawned instance of a ghost.

### Fixes
* Fixed an issue where the elapsed time was not using the max simulation rate - causing the fixed time step physics to take more and more time.
* Fixed an issue causing time rollbacks when running client and server in the editor if performance is too low.

### Upgrade guide
The `Interpolate` bool in the `GhostField` attribute has been replaced with `Smoothing`. Replace `Interpolate=true` with `Smoothing=SmoothingAction.Interpolate` to keep the old value, or set it to `SmoothingAction.InterpolateAndExtrapolate` to enable extrapolation.

## [0.5.0] - 2020-10-01
### New features
* Added RpcSystem.DynamicAssemblyList which can be used to delay the checksums for RPCs and ghost components when the set of assemblies are different on the client and server.
* Added to RPC and Command the possiblity to send Entity reference from both client and server.

### Changes
* Change the system ordering to be compatible with latest physics. `NetworkTimeSystem` has moved to `ClientInitializationSystemGroup`. The SimulationSystemGroup runs `GhostSpawnSystemGroup` (client), `GhostReceiveSystemGroup` and `GhostSimulationSystemGroup` before `FixedStepSimulationSystemGroup` where physics is running. `RpcCommandRequestSystemGroup`, `RpcSystem` and `GhostSendSystem` (server) is running at the end of the frame, after all simulation code. Other systems has been moved into one of the groups.
* Created a new `GhostInputSystemGroup` where systems adding inputs to the input buffer should run.

### Fixes
### Upgrade guide
* The systems adding input to the `ICommandData` buffer needs to be moved to `GhostInputSystemGroup`

Author: Unity Technologies

CHANGELOG.md

@@ -1,5 +1,35 @@
 # Change log
 
+## [0.6.0] - 2020-11-26
+### New features
+* Added DynamicBuffers serialization support to ghosts. Like IComponentData, is now possible to annotate IBufferElementData with GhostComponentAttribute and members with GhostFieldAttribute
+and having the buffers replicated through the network.
+* ICommandData are now serializable and can be sent to the remote players.
+* Added new SendToOwner property to the GhostComponentAttribute that can be used to configure to witch
+subset of players the component should be sent to: only to the owner, only to the non owner, or all.
+* Ghost Component Serialization Variant. A new GhostComponentVariation attribute has been introduced that let you to specify different serialization options for a component or buffer, by overriding
+the `[GhostField]` and `[GhostComponent]` properties present in the original type definition.
+* It is possible to prevent a component to support variation by using the `[DontSupportVariation]` attribute. When present, if a GhostComponentVariation is defined for that type, an exception is triggered.
+* Ghost components attributes and serialization variants can be customized per prefabs. For every component in a ghost prefab, it is possible to change:
+    * PrefabType
+    * GhostSendType
+    * The variant to use, if variants for that component exist.
+* Is possible to prevent a component to support per-prefab overrides by using the [DontSupportPrefabOverride] attribute. When present, the component can't be further customized in the inspector.
+* It's now possible to register a prediction smoothing function, by calling the `GhostPredictionSmoothingSystem.RegisterSmoothingAction<ComponentType>(SmoothingActionDelegate)` and supplying a `ComponentType` and `GhostPredictionSmoothingSystem.SmoothingActionDelegate` (see Runtime/Snapshot/DefaultUserParams.cs for an example).
+* Added a new `ClientTickRate` component which when added to a singleton entity controls the interpolation times used to calculate time on the client. The default values can be accessed through the static `NetworkTimeSystem.DefaultClientTickRate`.
+* Added support for extrapolation when the tick being applied to interpolated ghosts on the client has not been received yet and is outside the interpolation delay. Set the new `Smoothing` field in the `GhostField` attribute to `SmoothingAction.InterpolateAndExtrapolate` to enable extrapolation.
+* Added a `MaxSmoothingDistance` parameter to the `[GhostField]` attribute. If specified interpolation will be disabled when the values change more than that limit between two snapshots. This is useful for dealing with teleportation and similar changes which should not be interpolated.
+
+### Changes
+* It is no longer required to create a ghost collection, as long as there is a prefab for a ghost it will be picked up automatically. You can create a prefab by referencing it in a spawner component or by placing a pre spawned instance of a ghost.
+
+### Fixes
+* Fixed an issue where the elapsed time was not using the max simulation rate - causing the fixed time step physics to take more and more time.
+* Fixed an issue causing time rollbacks when running client and server in the editor if performance is too low.
+
+### Upgrade guide
+The `Interpolate` bool in the `GhostField` attribute has been replaced with `Smoothing`. Replace `Interpolate=true` with `Smoothing=SmoothingAction.Interpolate` to keep the old value, or set it to `SmoothingAction.InterpolateAndExtrapolate` to enable extrapolation.
+
 ## [0.5.0] - 2020-10-01
 ### New features
 * Added RpcSystem.DynamicAssemblyList which can be used to delay the checksums for RPCs and ghost components when the set of assemblies are different on the client and server.

Documentation~/getting-started.md

@@ -182,7 +182,7 @@ public class SampleCubeInput : ComponentSystem
             return;
         }
         var input = default(CubeInput);
-        input.tick = World.GetExistingSystem<ClientSimulationSystemGroup>().ServerTick;
+        input.Tick = World.GetExistingSystem<ClientSimulationSystemGroup>().ServerTick;
         if (Input.GetKey("a"))
             input.horizontal -= 1;
         if (Input.GetKey("d"))

Documentation~/ghost-snapshots.md

@@ -45,7 +45,7 @@ For example, if you add `[GhostComponent(PrefabType=GhostPrefabType.Client)]` to
 A component can set __OwnerPredictedSendType__ in the __GhostComponentAttribute__ to control which clients the component is sent to when it is owner predicted. The available modes are:
 * __Interpolated__ - the component is only sent to clients which are interpolating the ghost.
 * __Predicted__ - the component is only sent to clients which are predicting the ghost.
-* __Interpolated__ - the component is sent to all clients.
+* __All__ - the component is sent to all clients.
 
 If a component is not sent to a client NetCode will not modify the component on the client which did not receive it.
 
@@ -55,7 +55,7 @@ For each component, you need to add an attribute to the values you want to sent.
 The __GhostFieldAttribute__ also has a `Interpolate` property which controls if the field will be interpolated or not on clients which are not predicting the ghost.
 Finally the __GhostFieldAttribute__ has a `SubType` property which can be set to an integer value to use special serialization rules supplied by the game for that specific field.
 
-As well as adding attributes, you can specify rules for components which you do not have source access to by creating an assembly with a name ending with `.NetCodeGen`. This assembly should contain a class implementing the interface __IGhostDefaultOverridesModifier__. Implement the method `public void Modify(Dictionary<string, GhostAuthoringComponentEditor.GhostComponent> overrides)` and add an entry to the ictionary with the full name of the component as key and a value containing the desired override attributes.
+As well as adding attributes, you can specify rules for components which you do not have source access to by creating an assembly with a name ending with `.NetCodeGen`. This assembly should contain a class implementing the interface __IGhostDefaultOverridesModifier__. Implement the method `public void Modify(Dictionary<string, GhostAuthoringComponentEditor.GhostComponent> overrides)` and add an entry to the dictionary with the full name of the component as key and a value containing the desired override attributes.
 
 
 ## Ghost collection
@@ -140,6 +140,6 @@ To look at an example of a scene using prespawn ghosts, see the test in *Assets/
 
 ## Snapshot visualization tool
 
-To understand what is being put on the wire in the netcode, you can use the prototype snapshot visualization tool, __NetDbg__ in the Stats folder. To open the tool, go to menu: __Multiplayer &gt; Open NetDbg__, and the tool opens in a browser window. It displays a vertical bar for each snapshot Unity receives, with a breakdown of the snapshot’s ghost types. To see more detailed information about the snapshot, click on one of the bars. 
+To understand what is being put on the wire in the netcode, you can use the prototype snapshot visualization tool, __NetDbg__ in the Stats folder. To open the tool, go to menu: __Multiplayer &gt; Open NetDbg__, and the tool opens in a browser window. It displays a vertical bar for each snapshot Unity receives, with a breakdown of the snapshot’s ghost types. To see more detailed information about the snapshot, click on one of the bars.
 > [!NOTE]
 > This tool is a prototype. In future versions of the package it will integrate with the Unity Profiler so you can easily correlate network traffic with memory usage and CPU performance.

Editor/CecilExtensions.cs

@@ -41,6 +41,15 @@ public static bool IsIComponentData(this Mono.Cecil.TypeReference typeReference)
                 i.InterfaceType.Name == typeof(IComponentData).Name &&
                 i.InterfaceType.Namespace == typeof(IComponentData).Namespace);
         }
+        public static bool IsBufferElementData(this Mono.Cecil.TypeReference typeReference)
+        {
+            var resolvedType = typeReference.Resolve();
+            if (resolvedType == null)
+                return false;
+            return resolvedType.Interfaces.Any(i =>
+                i.InterfaceType.Name == typeof(IBufferElementData).Name &&
+                i.InterfaceType.Namespace == typeof(IBufferElementData).Namespace);
+        }
         public static bool IsIRpcCommand(this Mono.Cecil.TypeReference typeReference)
         {
             var resolvedType = typeReference.Resolve();
@@ -60,9 +69,9 @@ public static bool IsICommandData(this Mono.Cecil.TypeReference typeReference)
                 i.InterfaceType.Namespace == typeof(ICommandData).Namespace);
         }
 
-        public static bool HasGhostFieldAttribute(Mono.Cecil.TypeReference parentType, Mono.Cecil.FieldDefinition componentField)
+        public static bool HasGhostFieldAttribute(Mono.Cecil.TypeReference parentType, Mono.Cecil.IMemberDefinition componentField)
         {
-            if (!GhostAuthoringComponentEditor.GhostDefaultOverrides.TryGetValue(parentType.FullName.Replace('/','+'), out var newComponent))
+            if (!GhostAuthoringModifiers.GhostDefaultOverrides.TryGetValue(parentType.FullName.Replace('/','+'), out var newComponent))
             {
                 return componentField.HasAttribute<GhostFieldAttribute>();
             }
@@ -72,9 +81,9 @@ public static bool HasGhostFieldAttribute(Mono.Cecil.TypeReference parentType, M
             }
         }
 
-        public static GhostFieldAttribute GetGhostFieldAttribute(Mono.Cecil.TypeReference parentType, Mono.Cecil.FieldDefinition componentField)
+        public static GhostFieldAttribute GetGhostFieldAttribute(Mono.Cecil.TypeReference parentType, Mono.Cecil.IMemberDefinition componentField)
         {
-            if (GhostAuthoringComponentEditor.GhostDefaultOverrides.TryGetValue(parentType.FullName.Replace('/','+'), out var newComponent))
+            if (parentType != null && GhostAuthoringModifiers.GhostDefaultOverrides.TryGetValue(parentType.FullName.Replace('/','+'), out var newComponent))
             {
                 foreach (var field in newComponent.fields)
                 {
@@ -103,10 +112,6 @@ public static GhostFieldAttribute GetGhostFieldAttribute(Mono.Cecil.TypeReferenc
 
         public static GhostComponentAttribute GetGhostComponentAttribute(Mono.Cecil.TypeDefinition managedType)
         {
-            if (GhostAuthoringComponentEditor.GhostDefaultOverrides.TryGetValue(managedType.FullName.Replace('/', '+'), out var newComponent))
-            {
-                return newComponent.attribute;
-            }
             var attribute = managedType.GetAttribute<GhostComponentAttribute>();
             if (attribute != null)
             {
@@ -125,6 +130,16 @@ public static GhostComponentAttribute GetGhostComponentAttribute(Mono.Cecil.Type
             return null;
         }
 
+        public static ulong ComputeVariantHash(Mono.Cecil.TypeReference variantType, Mono.Cecil.CustomAttribute attribute)
+        {
+            var hash = TypeHash.FNV1A64(attribute.AttributeType.FullName);
+            var componentType = attribute.ConstructorArguments[0].Value as Mono.Cecil.TypeReference;
+            var variantName = variantType.FullName;
+            hash = TypeHash.CombineFNV1A64(hash, TypeHash.FNV1A64(componentType.FullName));
+            hash = TypeHash.CombineFNV1A64(hash, TypeHash.FNV1A64(variantName));
+            return hash;
+        }
+
         public static bool IsStruct(this Mono.Cecil.TypeDefinition type)
         {
             return !type.IsPrimitive && type.IsValueType && !type.IsEnum;
@@ -140,23 +155,46 @@ public static bool IsBlittable(this Mono.Cecil.TypeReference type)
 
         public static string GetFieldTypeName(this Mono.Cecil.TypeReference type)
         {
-            if (type.IsTypeOf<System.Byte>()) return "byte";
-            if (type.IsTypeOf<System.SByte>()) return "sbyte";
-            if (type.IsTypeOf<System.Int16>()) return "short";
-            if (type.IsTypeOf<System.UInt16>()) return "ushort";
-            if (type.IsTypeOf<System.Int32>()) return "int";
-            if (type.IsTypeOf<System.UInt32>()) return "uint";
-            if (type.IsTypeOf<System.Int64>()) return "long";
-            if (type.IsTypeOf<System.UInt64>()) return "ulong";
+            if (type.IsTypeOf<Byte>()) return "byte";
+            if (type.IsTypeOf<SByte>()) return "sbyte";
+            if (type.IsTypeOf<Int16>()) return "short";
+            if (type.IsTypeOf<UInt16>()) return "ushort";
+            if (type.IsTypeOf<Int32>()) return "int";
+            if (type.IsTypeOf<UInt32>()) return "uint";
+            if (type.IsTypeOf<Int64>()) return "long";
+            if (type.IsTypeOf<UInt64>()) return "ulong";
 
-            if (type.IsTypeOf<System.IntPtr>()) return "iptr";
-            if (type.IsTypeOf<System.UIntPtr>()) return "uptr";
+            if (type.IsTypeOf<IntPtr>()) return "iptr";
+            if (type.IsTypeOf<UIntPtr>()) return "uptr";
 
-            if (type.IsTypeOf<System.Single>()) return "float";
-            if (type.IsTypeOf<System.Double>()) return "double";
+            if (type.IsTypeOf<Single>()) return "float";
+            if (type.IsTypeOf<Double>()) return "double";
 
             return type.ToString().Replace("/", ".");
         }
 
+        static public bool HasAttributeOnMemberOImplementedInterfaces<T>(this Mono.Cecil.FieldDefinition member) where T: Attribute
+        {
+            foreach (var m in member.DeclaringType.Interfaces)
+            {
+                var prop = m.InterfaceType.Resolve().Fields.FirstOrDefault(p => p.Name == member.Name);
+                if (prop != null && prop.GetAttribute<T>() != null)
+                    return true;
+            }
+
+            return false;
+        }
+        static public bool HasAttributeOnMemberOImplementedInterfaces<T>(this Mono.Cecil.PropertyDefinition member) where T: Attribute
+        {
+            foreach (var m in member.DeclaringType.Interfaces)
+            {
+                var prop = m.InterfaceType.Resolve().Properties.FirstOrDefault(p => p.Name == member.Name);
+                if (prop != null && prop.GetAttribute<T>() != null)
+                    return true;
+            }
+
+            return false;
+        }
+
     }
 }

Editor/CodeGenTemplates/DefaultTypes/GhostSnapshotValueFloat.cs

@@ -55,10 +55,15 @@ public unsafe void CopyFromSnapshot(ref Snapshot snapshot, ref IComponentData co
                 component.__GHOST_FIELD_REFERENCE__ = snapshotBefore.__GHOST_FIELD_NAME__ * __GHOST_DEQUANTIZE_SCALE__;
                 #endregion
 
+                #region __GHOST_COPY_FROM_SNAPSHOT_INTERPOLATE_SETUP__
+                var __GHOST_FIELD_NAME___Before = snapshotBefore.__GHOST_FIELD_NAME__ * __GHOST_DEQUANTIZE_SCALE__;
+                var __GHOST_FIELD_NAME___After = snapshotAfter.__GHOST_FIELD_NAME__ * __GHOST_DEQUANTIZE_SCALE__;
+                #endregion
+                #region __GHOST_COPY_FROM_SNAPSHOT_INTERPOLATE_DISTSQ__
+                var __GHOST_FIELD_NAME___DistSq = math.distancesq(__GHOST_FIELD_NAME___Before, __GHOST_FIELD_NAME___After);
+                #endregion
                 #region __GHOST_COPY_FROM_SNAPSHOT_INTERPOLATE__
-                component.__GHOST_FIELD_REFERENCE__ =
-                    math.lerp(snapshotBefore.__GHOST_FIELD_NAME__ * __GHOST_DEQUANTIZE_SCALE__,
-                        snapshotAfter.__GHOST_FIELD_NAME__ * __GHOST_DEQUANTIZE_SCALE__, snapshotInterpolationFactor);
+                component.__GHOST_FIELD_REFERENCE__ = math.lerp(__GHOST_FIELD_NAME___Before, __GHOST_FIELD_NAME___After, snapshotInterpolationFactor);
                 #endregion
             }
         }

Editor/CodeGenTemplates/DefaultTypes/GhostSnapshotValueFloat2.cs

@@ -10,11 +10,15 @@ public unsafe void CopyFromSnapshot(ref GhostDeserializerState deserializerState
                 component.__GHOST_FIELD_REFERENCE__ = new float2(snapshotBefore.__GHOST_FIELD_NAME___x * __GHOST_DEQUANTIZE_SCALE__, snapshotBefore.__GHOST_FIELD_NAME___y * __GHOST_DEQUANTIZE_SCALE__);
                 #endregion
 
+                #region __GHOST_COPY_FROM_SNAPSHOT_INTERPOLATE_SETUP__
+                var __GHOST_FIELD_NAME___Before = new float2(snapshotBefore.__GHOST_FIELD_NAME___x * __GHOST_DEQUANTIZE_SCALE__, snapshotBefore.__GHOST_FIELD_NAME___y * __GHOST_DEQUANTIZE_SCALE__);
+                var __GHOST_FIELD_NAME___After = new float2(snapshotAfter.__GHOST_FIELD_NAME___x * __GHOST_DEQUANTIZE_SCALE__, snapshotAfter.__GHOST_FIELD_NAME___y * __GHOST_DEQUANTIZE_SCALE__);
+                #endregion
+                #region __GHOST_COPY_FROM_SNAPSHOT_INTERPOLATE_DISTSQ__
+                var __GHOST_FIELD_NAME___DistSq = math.distancesq(__GHOST_FIELD_NAME___Before, __GHOST_FIELD_NAME___After);
+                #endregion
                 #region __GHOST_COPY_FROM_SNAPSHOT_INTERPOLATE__
-                component.__GHOST_FIELD_REFERENCE__ = math.lerp(
-                    new float2(snapshotBefore.__GHOST_FIELD_NAME___x * __GHOST_DEQUANTIZE_SCALE__, snapshotBefore.__GHOST_FIELD_NAME___y * __GHOST_DEQUANTIZE_SCALE__),
-                    new float2(snapshotAfter.__GHOST_FIELD_NAME___x * __GHOST_DEQUANTIZE_SCALE__, snapshotAfter.__GHOST_FIELD_NAME___y * __GHOST_DEQUANTIZE_SCALE__),
-                    snapshotInterpolationFactor);
+                component.__GHOST_FIELD_REFERENCE__ = math.lerp(__GHOST_FIELD_NAME___Before, __GHOST_FIELD_NAME___After, snapshotInterpolationFactor);
                 #endregion
             }
         }

Editor/CodeGenTemplates/DefaultTypes/GhostSnapshotValueFloat2Unquantized.cs

@@ -10,11 +10,15 @@ public unsafe void CopyFromSnapshot(ref GhostDeserializerState deserializerState
                 component.__GHOST_FIELD_REFERENCE__ = new float2(snapshotBefore.__GHOST_FIELD_NAME___x, snapshotBefore.__GHOST_FIELD_NAME___y);
                 #endregion
 
+                #region __GHOST_COPY_FROM_SNAPSHOT_INTERPOLATE_SETUP__
+                var __GHOST_FIELD_NAME___Before = new float2(snapshotBefore.__GHOST_FIELD_NAME___x, snapshotBefore.__GHOST_FIELD_NAME___y);
+                var __GHOST_FIELD_NAME___After = new float2(snapshotAfter.__GHOST_FIELD_NAME___x, snapshotAfter.__GHOST_FIELD_NAME___y);
+                #endregion
+                #region __GHOST_COPY_FROM_SNAPSHOT_INTERPOLATE_DISTSQ__
+                var __GHOST_FIELD_NAME___DistSq = math.distancesq(__GHOST_FIELD_NAME___Before, __GHOST_FIELD_NAME___After);
+                #endregion
                 #region __GHOST_COPY_FROM_SNAPSHOT_INTERPOLATE__
-                component.__GHOST_FIELD_REFERENCE__ = math.lerp(
-                    new float2(snapshotBefore.__GHOST_FIELD_NAME___x, snapshotBefore.__GHOST_FIELD_NAME___y),
-                    new float2(snapshotAfter.__GHOST_FIELD_NAME___x, snapshotAfter.__GHOST_FIELD_NAME___y),
-                    snapshotInterpolationFactor);
+                component.__GHOST_FIELD_REFERENCE__ = math.lerp(__GHOST_FIELD_NAME___Before, __GHOST_FIELD_NAME___After, snapshotInterpolationFactor);
                 #endregion
             }
         }