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)
839 lines
31 KiB
C#
839 lines
31 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using NUnit.Framework;
|
|
using Unity.Collections;
|
|
using UnityEngine;
|
|
using Random = System.Random;
|
|
|
|
namespace Unity.Netcode.EditorTests
|
|
{
|
|
public class BytePackerTests
|
|
{
|
|
private enum ByteEnum : byte
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum SByteEnum : sbyte
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum ShortEnum : short
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum UShortEnum : ushort
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum IntEnum
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum UIntEnum : uint
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum LongEnum : long
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
private enum ULongEnum : ulong
|
|
{
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
|
|
public enum WriteType
|
|
{
|
|
WriteDirect,
|
|
WriteAsObject
|
|
}
|
|
|
|
private unsafe void VerifyBytewiseEquality<T>(T value, T otherValue) where T : unmanaged
|
|
{
|
|
byte* asBytePointer = (byte*)&value;
|
|
byte* otherBytePointer = (byte*)&otherValue;
|
|
for (var i = 0; i < sizeof(T); ++i)
|
|
{
|
|
Assert.AreEqual(asBytePointer[i], otherBytePointer[i]);
|
|
}
|
|
}
|
|
|
|
private unsafe void RunTypeTest<T>(T value) where T : unmanaged
|
|
{
|
|
var writer = new FastBufferWriter(sizeof(T) * 2, Allocator.Temp);
|
|
using (writer)
|
|
{
|
|
BytePacker.WriteValuePacked(writer, (dynamic)value);
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
|
|
var outVal = new T();
|
|
MethodInfo method;
|
|
if (value is Enum)
|
|
{
|
|
method = typeof(ByteUnpacker).GetMethods().Single(x =>
|
|
x.Name == "ReadValuePacked" && x.IsGenericMethodDefinition)
|
|
.MakeGenericMethod(typeof(T));
|
|
}
|
|
else
|
|
{
|
|
method = typeof(ByteUnpacker).GetMethod("ReadValuePacked",
|
|
new[] { typeof(FastBufferReader), typeof(T).MakeByRefType() });
|
|
}
|
|
|
|
object[] args = { reader, outVal };
|
|
method.Invoke(null, args);
|
|
outVal = (T)args[1];
|
|
Assert.AreEqual(value, outVal);
|
|
VerifyBytewiseEquality(value, outVal);
|
|
}
|
|
}
|
|
}
|
|
|
|
private int GetByteCount64Bits(ulong value)
|
|
{
|
|
|
|
if (value <= 0b0000_1111)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
if (value <= 0b0000_1111_1111_1111)
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
if (value <= 0b0000_1111_1111_1111_1111_1111)
|
|
{
|
|
return 3;
|
|
}
|
|
|
|
if (value <= 0b0000_1111_1111_1111_1111_1111_1111_1111)
|
|
{
|
|
return 4;
|
|
}
|
|
|
|
if (value <= 0b0000_1111_1111_1111_1111_1111_1111_1111_1111_1111)
|
|
{
|
|
return 5;
|
|
}
|
|
|
|
if (value <= 0b0000_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111)
|
|
{
|
|
return 6;
|
|
}
|
|
|
|
if (value <= 0b0000_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111)
|
|
{
|
|
return 7;
|
|
}
|
|
|
|
if (value <= 0b0000_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111)
|
|
{
|
|
return 8;
|
|
}
|
|
|
|
return 9;
|
|
}
|
|
|
|
private int GetByteCount32Bits(uint value)
|
|
{
|
|
|
|
if (value <= 0b0001_1111)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
if (value <= 0b0001_1111_1111_1111)
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
if (value <= 0b0001_1111_1111_1111_1111_1111)
|
|
{
|
|
return 3;
|
|
}
|
|
|
|
if (value <= 0b0001_1111_1111_1111_1111_1111_1111_1111)
|
|
{
|
|
return 4;
|
|
}
|
|
|
|
return 5;
|
|
}
|
|
|
|
private int GetByteCount16Bits(ushort value)
|
|
{
|
|
|
|
if (value <= 0b0011_1111)
|
|
{
|
|
return 1;
|
|
}
|
|
if (value <= 0b0011_1111_1111_1111)
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
return 3;
|
|
}
|
|
|
|
private ulong Get64BitEncodedValue(FastBufferWriter writer)
|
|
{
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out ulong value);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private long Get64BitSignedEncodedValue(FastBufferWriter writer)
|
|
{
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out long value);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private uint Get32BitEncodedValue(FastBufferWriter writer)
|
|
{
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out uint value);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private int Get32BitSignedEncodedValue(FastBufferWriter writer)
|
|
{
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out int value);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private ushort Get16BitEncodedValue(FastBufferWriter writer)
|
|
{
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out ushort value);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
private short Get16BitSignedEncodedValue(FastBufferWriter writer)
|
|
{
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValueBitPacked(reader, out short value);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBitPacking64BitsUnsigned()
|
|
{
|
|
var writer = new FastBufferWriter(9, Allocator.Temp);
|
|
|
|
using (writer)
|
|
{
|
|
writer.TryBeginWrite(8);
|
|
ulong value = 0;
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(1, writer.Position);
|
|
Assert.AreEqual(1, writer.ToArray()[0] & 0b1111);
|
|
Assert.AreEqual(value, Get64BitEncodedValue(writer));
|
|
|
|
for (var i = 0; i < 64; ++i)
|
|
{
|
|
value = 1UL << i;
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount64Bits(value), writer.Position, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(GetByteCount64Bits(value), writer.ToArray()[0] & 0b1111, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(value, Get64BitEncodedValue(writer));
|
|
|
|
for (var j = 0; j < 8; ++j)
|
|
{
|
|
value = (1UL << i) | (1UL << j);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount64Bits(value), writer.Position, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(GetByteCount64Bits(value), writer.ToArray()[0] & 0b1111, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(value, Get64BitEncodedValue(writer));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBitPacking64BitsSigned()
|
|
{
|
|
var writer = new FastBufferWriter(9, Allocator.Temp);
|
|
|
|
using (writer)
|
|
{
|
|
writer.TryBeginWrite(8);
|
|
long value = 0;
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(1, writer.Position);
|
|
Assert.AreEqual(1, writer.ToArray()[0] & 0b1111);
|
|
Assert.AreEqual(value, Get64BitSignedEncodedValue(writer));
|
|
|
|
for (var i = 0; i < 64; ++i)
|
|
{
|
|
value = 1U << i;
|
|
ulong zzvalue = Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.ToArray()[0] & 0b1111, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(value, Get64BitSignedEncodedValue(writer));
|
|
|
|
value = -value;
|
|
zzvalue = Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.ToArray()[0] & 0b1111, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(value, Get64BitSignedEncodedValue(writer));
|
|
|
|
for (var j = 0; j < 8; ++j)
|
|
{
|
|
value = (1U << i) | (1U << j);
|
|
zzvalue = Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.ToArray()[0] & 0b1111, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(value, Get64BitSignedEncodedValue(writer));
|
|
|
|
value = -value;
|
|
zzvalue = Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(GetByteCount64Bits(zzvalue), writer.ToArray()[0] & 0b1111, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(value, Get64BitSignedEncodedValue(writer));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBitPacking32BitsUnsigned()
|
|
{
|
|
var writer = new FastBufferWriter(9, Allocator.Temp);
|
|
|
|
using (writer)
|
|
{
|
|
writer.TryBeginWrite(4);
|
|
uint value = 0;
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(1, writer.Position);
|
|
Assert.AreEqual(1, writer.ToArray()[0] & 0b111);
|
|
Assert.AreEqual(value, Get32BitEncodedValue(writer));
|
|
|
|
for (var i = 0; i < 32; ++i)
|
|
{
|
|
value = 1U << i;
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount32Bits(value), writer.Position, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(GetByteCount32Bits(value), writer.ToArray()[0] & 0b111, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(value, Get32BitEncodedValue(writer));
|
|
|
|
for (var j = 0; j < 8; ++j)
|
|
{
|
|
value = (1U << i) | (1U << j);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount32Bits(value), writer.Position, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(GetByteCount32Bits(value), writer.ToArray()[0] & 0b111, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(value, Get32BitEncodedValue(writer));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBitPacking32BitsSigned()
|
|
{
|
|
var writer = new FastBufferWriter(9, Allocator.Temp);
|
|
|
|
using (writer)
|
|
{
|
|
writer.TryBeginWrite(4);
|
|
int value = 0;
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(1, writer.Position);
|
|
Assert.AreEqual(1, writer.ToArray()[0] & 0b111);
|
|
Assert.AreEqual(value, Get32BitEncodedValue(writer));
|
|
|
|
for (var i = 0; i < 32; ++i)
|
|
{
|
|
value = 1 << i;
|
|
uint zzvalue = (uint)Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.ToArray()[0] & 0b111, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(value, Get32BitSignedEncodedValue(writer));
|
|
|
|
value = -value;
|
|
zzvalue = (uint)Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.ToArray()[0] & 0b111, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(value, Get32BitSignedEncodedValue(writer));
|
|
|
|
for (var j = 0; j < 8; ++j)
|
|
{
|
|
value = (1 << i) | (1 << j);
|
|
zzvalue = (uint)Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.ToArray()[0] & 0b111, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(value, Get32BitSignedEncodedValue(writer));
|
|
|
|
value = -value;
|
|
zzvalue = (uint)Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(GetByteCount32Bits(zzvalue), writer.ToArray()[0] & 0b111, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(value, Get32BitSignedEncodedValue(writer));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestBitPacking16BitsUnsigned()
|
|
{
|
|
var writer = new FastBufferWriter(9, Allocator.Temp);
|
|
|
|
using (writer)
|
|
{
|
|
writer.TryBeginWrite(2);
|
|
ushort value = 0;
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(1, writer.Position);
|
|
Assert.AreEqual(1, writer.ToArray()[0] & 0b11);
|
|
Assert.AreEqual(value, Get16BitEncodedValue(writer));
|
|
|
|
for (var i = 0; i < 16; ++i)
|
|
{
|
|
value = (ushort)(1U << i);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount16Bits(value), writer.Position, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(GetByteCount16Bits(value), writer.ToArray()[0] & 0b11, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(value, Get16BitEncodedValue(writer));
|
|
|
|
for (var j = 0; j < 8; ++j)
|
|
{
|
|
value = (ushort)((1U << i) | (1U << j));
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount16Bits(value), writer.Position, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(GetByteCount16Bits(value), writer.ToArray()[0] & 0b11, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(value, Get16BitEncodedValue(writer));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
[Test]
|
|
public void TestBitPacking16BitsSigned()
|
|
{
|
|
var writer = new FastBufferWriter(9, Allocator.Temp);
|
|
|
|
using (writer)
|
|
{
|
|
writer.TryBeginWrite(2);
|
|
short value = 0;
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(1, writer.Position);
|
|
Assert.AreEqual(1, writer.ToArray()[0] & 0b11);
|
|
Assert.AreEqual(value, Get16BitEncodedValue(writer));
|
|
|
|
for (var i = 0; i < 16; ++i)
|
|
{
|
|
value = (short)(1 << i);
|
|
ushort zzvalue = (ushort)Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.ToArray()[0] & 0b11, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(value, Get16BitSignedEncodedValue(writer));
|
|
|
|
value = (short)-value;
|
|
zzvalue = (ushort)Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.Position, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.ToArray()[0] & 0b11, $"Failed on {value} ({i})");
|
|
Assert.AreEqual(value, Get16BitSignedEncodedValue(writer));
|
|
|
|
for (var j = 0; j < 8; ++j)
|
|
{
|
|
value = (short)((1 << i) | (1 << j));
|
|
zzvalue = (ushort)Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.ToArray()[0] & 0b11, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(value, Get16BitSignedEncodedValue(writer));
|
|
|
|
value = (short)-value;
|
|
zzvalue = (ushort)Arithmetic.ZigZagEncode(value);
|
|
writer.Seek(0);
|
|
writer.Truncate();
|
|
BytePacker.WriteValueBitPacked(writer, value);
|
|
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.Position, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(GetByteCount16Bits(zzvalue), writer.ToArray()[0] & 0b11, $"Failed on {value} ({i}, {j})");
|
|
Assert.AreEqual(value, Get16BitSignedEncodedValue(writer));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPackingBasicTypes(
|
|
[Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
|
|
typeof(long), typeof(ulong), typeof(bool), typeof(char), typeof(float), typeof(double),
|
|
typeof(ByteEnum), typeof(SByteEnum), typeof(ShortEnum), typeof(UShortEnum), typeof(IntEnum),
|
|
typeof(UIntEnum), typeof(LongEnum), typeof(ULongEnum), typeof(Vector2), typeof(Vector3), typeof(Vector4),
|
|
typeof(Quaternion), typeof(Color), typeof(Color32), typeof(Ray), typeof(Ray2D))]
|
|
Type testType,
|
|
[Values] WriteType writeType)
|
|
{
|
|
var random = new Random();
|
|
|
|
if (testType == typeof(byte))
|
|
{
|
|
byte b = (byte)random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(b);
|
|
}
|
|
}
|
|
else if (testType == typeof(sbyte))
|
|
{
|
|
sbyte sb = (sbyte)random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(sb);
|
|
}
|
|
}
|
|
else if (testType == typeof(short))
|
|
{
|
|
short s = (short)random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(s);
|
|
}
|
|
}
|
|
else if (testType == typeof(ushort))
|
|
{
|
|
ushort us = (ushort)random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(us);
|
|
}
|
|
}
|
|
else if (testType == typeof(int))
|
|
{
|
|
int i = random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(i);
|
|
}
|
|
}
|
|
else if (testType == typeof(uint))
|
|
{
|
|
uint ui = (uint)random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(ui);
|
|
}
|
|
}
|
|
else if (testType == typeof(long))
|
|
{
|
|
long l = ((long)random.Next() << 32) + random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(l);
|
|
}
|
|
}
|
|
else if (testType == typeof(ulong))
|
|
{
|
|
ulong ul = ((ulong)random.Next() << 32) + (ulong)random.Next();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(ul);
|
|
}
|
|
}
|
|
else if (testType == typeof(bool))
|
|
{
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(true);
|
|
}
|
|
}
|
|
else if (testType == typeof(char))
|
|
{
|
|
char c = 'a';
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(c);
|
|
}
|
|
|
|
c = '\u263a';
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(c);
|
|
}
|
|
}
|
|
else if (testType == typeof(float))
|
|
{
|
|
float f = (float)random.NextDouble();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(f);
|
|
}
|
|
}
|
|
else if (testType == typeof(double))
|
|
{
|
|
double d = random.NextDouble();
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(d);
|
|
}
|
|
}
|
|
else if (testType == typeof(ByteEnum))
|
|
{
|
|
ByteEnum e = ByteEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(SByteEnum))
|
|
{
|
|
SByteEnum e = SByteEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(ShortEnum))
|
|
{
|
|
ShortEnum e = ShortEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(UShortEnum))
|
|
{
|
|
UShortEnum e = UShortEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(IntEnum))
|
|
{
|
|
IntEnum e = IntEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(UIntEnum))
|
|
{
|
|
UIntEnum e = UIntEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(LongEnum))
|
|
{
|
|
LongEnum e = LongEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(ULongEnum))
|
|
{
|
|
ULongEnum e = ULongEnum.C;
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(e);
|
|
}
|
|
}
|
|
else if (testType == typeof(Vector2))
|
|
{
|
|
var v = new Vector2((float)random.NextDouble(), (float)random.NextDouble());
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(v);
|
|
}
|
|
}
|
|
else if (testType == typeof(Vector3))
|
|
{
|
|
var v = new Vector3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(v);
|
|
}
|
|
}
|
|
else if (testType == typeof(Vector4))
|
|
{
|
|
var v = new Vector4((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(v);
|
|
}
|
|
}
|
|
else if (testType == typeof(Quaternion))
|
|
{
|
|
var v = new Quaternion((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(v);
|
|
}
|
|
}
|
|
else if (testType == typeof(Color))
|
|
{
|
|
var v = new Color((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble());
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(v);
|
|
}
|
|
}
|
|
else if (testType == typeof(Color32))
|
|
{
|
|
var v = new Color32((byte)random.Next(), (byte)random.Next(), (byte)random.Next(), (byte)random.Next());
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
RunTypeTest(v);
|
|
}
|
|
}
|
|
else if (testType == typeof(Ray))
|
|
{
|
|
// Rays need special handling on the equality checks because the constructor normalizes direction
|
|
// Which can cause slight variations in the result
|
|
var v = new Ray(
|
|
new Vector3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble()),
|
|
new Vector3((float)random.NextDouble(), (float)random.NextDouble(), (float)random.NextDouble()));
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
unsafe
|
|
{
|
|
var writer = new FastBufferWriter(sizeof(Ray) * 2, Allocator.Temp);
|
|
using (writer)
|
|
{
|
|
BytePacker.WriteValuePacked(writer, v);
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValuePacked(reader, out Ray outVal);
|
|
Assert.AreEqual(v.origin, outVal.origin);
|
|
Assert.AreEqual(v.direction.x, outVal.direction.x, 0.00001);
|
|
Assert.AreEqual(v.direction.y, outVal.direction.y, 0.00001);
|
|
Assert.AreEqual(v.direction.z, outVal.direction.z, 0.00001);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (testType == typeof(Ray2D))
|
|
{
|
|
// Rays need special handling on the equality checks because the constructor normalizes direction
|
|
// Which can cause slight variations in the result
|
|
var v = new Ray2D(
|
|
new Vector2((float)random.NextDouble(), (float)random.NextDouble()),
|
|
new Vector2((float)random.NextDouble(), (float)random.NextDouble()));
|
|
if (writeType == WriteType.WriteDirect)
|
|
{
|
|
unsafe
|
|
{
|
|
var writer = new FastBufferWriter(sizeof(Ray2D) * 2, Allocator.Temp);
|
|
using (writer)
|
|
{
|
|
BytePacker.WriteValuePacked(writer, v);
|
|
var reader = new FastBufferReader(writer, Allocator.Temp);
|
|
using (reader)
|
|
{
|
|
ByteUnpacker.ReadValuePacked(reader, out Ray2D outVal);
|
|
Assert.AreEqual(v.origin, outVal.origin);
|
|
Assert.AreEqual(v.direction.x, outVal.direction.x, 0.00001);
|
|
Assert.AreEqual(v.direction.y, outVal.direction.y, 0.00001);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Assert.Fail("No type handler was provided for this type in the test!");
|
|
}
|
|
}
|
|
}
|
|
}
|