b5abc3ff7c
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.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)
249 lines
8.5 KiB
C#
249 lines
8.5 KiB
C#
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));
|
|
}
|
|
}
|