public static void Put(this INetBuffer writer, Vector3 value, bool delta = false)
{
if (GameConfig.deltaZeroCompression && delta)
{
if (Vector3.SqrMagnitude(value) < 0.0001)
{
writer.Put(false);
return;
}
writer.Put(true);
}
if (GameConfig.deltaZeroDeep && delta)
{
writer.Put(value.x, true);
writer.Put(value.y, true);
writer.Put(value.z, true);
}
else
{
writer.Put(value.x);
writer.Put(value.y);
writer.Put(value.z);
}
}
public static void Put(this INetBuffer writer, Quaternion value, bool delta = false)
{
if (GameConfig.deltaZeroCompression && delta)
{
if (value == Quaternion.identity)
{
writer.Put(false);
return;
}
writer.Put(true);
}
bool deltaZero = GameConfig.deltaZeroDeep && delta;
if (GameConfig.smallestThree)
{
SmallestThree.EncodeQuaternion(writer, value, delta);
}
else
{
writer.Put(value.x, deltaZero);
writer.Put(value.y, deltaZero);
writer.Put(value.z, deltaZero);
writer.Put(value.w, deltaZero);
}
}
public static Quaternion GetQuaternion(this INetBuffer reader, bool delta = false)
{
if (reader.CompressionSchema.DeltaZeroCompression && delta)
{
bool changed = reader.GetBool();
if (!changed)
{
return(Quaternion.identity);
}
}
bool deltaZero = reader.CompressionSchema.DeltaZeroDeep && delta;
if (reader.CompressionSchema.SmallestThree)
{
return(SmallestThree.DecodeQuaternion(reader, delta));
}
float x = reader.GetFloat(deltaZero);
float y = reader.GetFloat(deltaZero);
float z = reader.GetFloat(deltaZero);
float w = reader.GetFloat(deltaZero);
return(new Quaternion(x, y, z, w));
}
public static Quaternion DecodeQuaternion(INetBuffer reader, bool delta = false)
{
bool deltaZero = reader.CompressionSchema.DeltaZeroDeep && delta;
byte maxIndex = reader.GetByte();
float a = reader.GetShort(deltaZero) / QUAT_FLOAT_PRECISION_MULT;
float b = reader.GetShort(deltaZero) / QUAT_FLOAT_PRECISION_MULT;
float c = reader.GetShort(deltaZero) / QUAT_FLOAT_PRECISION_MULT;
float d = Mathf.Sqrt(1f - (a * a + b * b + c * c));
switch (maxIndex)
{
case 0:
return(new Quaternion(d, a, b, c));
case 1:
return(new Quaternion(a, d, b, c));
case 2:
return(new Quaternion(a, b, d, c));
case 3:
return(new Quaternion(a, b, c, d));
default:
throw new InvalidProgramException("Unexpected quaternion index.");
}
}
public void Serialize(INetBuffer writer)
{
writer.Put(Tick);
writer.Put(PlayerStates.Length);
foreach (var playerState in PlayerStates)
{
playerState.Serialize(writer);
}
}
public void Deserialize(INetBuffer reader)
{
Tick = reader.GetInt();
int playerStateCount = reader.GetInt();
PlayerStates = new PlayerState[playerStateCount];
PlayerState playerState = new PlayerState();
for (int i = 0; i < playerStateCount; i++)
{
playerState.Deserialize(reader);
PlayerStates[i] = playerState;
}
}
public static Vector3 GetVector3(this INetBuffer reader, bool delta = false)
{
if (reader.CompressionSchema.DeltaZeroCompression && delta)
{
bool changed = reader.GetBool();
if (!changed)
{
return(Vector3.zero);
}
}
if (reader.CompressionSchema.DeltaZeroDeep && delta)
{
return(new Vector3(reader.GetFloat(true), reader.GetFloat(true), reader.GetFloat(true)));
}
return(new Vector3(reader.GetFloat(), reader.GetFloat(), reader.GetFloat()));
}
public void Deserialize(INetBuffer reader)
{
PlayerId = reader.GetInt();
Position = reader.GetVector3(true);
Rotation = reader.GetQuaternion(true);
}
public void Serialize(INetBuffer writer)
{
writer.Put(PlayerId);
writer.Put(Position, true);
writer.Put(Rotation, true);
}
public void Write(INetBuffer buffer)
{
throw new NotImplementedException();
}
/// <summary>
/// Append all the bits of message to this message
/// </summary>
public void Write(INetBuffer buffer)
{
NetBuffer _buffer = (NetBuffer)buffer;
EnsureBufferSize(m_bitLength + (buffer.LengthBytes * 8));
Write(_buffer.m_data, 0, buffer.LengthBytes);
// did we write excessive bits?
int bitsInLastByte = (_buffer.m_bitLength % 8);
if (bitsInLastByte != 0)
{
int excessBits = 8 - bitsInLastByte;
m_bitLength -= excessBits;
}
}
public static void EncodeQuaternion(INetBuffer writer, Quaternion quaternion, bool delta = false)
{
byte maxIndex = 0;
float maxValue = float.MinValue;
float maxValueSign = 1;
// Find the largest value in the quaternion and save its index.
for (byte i = 0; i < 4; i++)
{
var value = quaternion[i];
var absValue = Mathf.Abs(value);
if (absValue > maxValue)
{
maxIndex = i;
maxValue = absValue;
// Note the sign of the maxValue for later.
maxValueSign = Mathf.Sign(value);
}
}
// Encode the smallest three components.
short a, b, c;
switch (maxIndex)
{
case 0:
a = (short)(quaternion.y * maxValueSign * QUAT_FLOAT_PRECISION_MULT);
b = (short)(quaternion.z * maxValueSign * QUAT_FLOAT_PRECISION_MULT);
c = (short)(quaternion.w * maxValueSign * QUAT_FLOAT_PRECISION_MULT);
break;
case 1:
a = (short)(quaternion.x * maxValueSign * QUAT_FLOAT_PRECISION_MULT);
b = (short)(quaternion.z * maxValueSign * QUAT_FLOAT_PRECISION_MULT);
c = (short)(quaternion.w * maxValueSign * QUAT_FLOAT_PRECISION_MULT);
break;
case 2:
a = (short)(quaternion.x * maxValueSign * QUAT_FLOAT_PRECISION_MULT);
b = (short)(quaternion.y * maxValueSign * QUAT_FLOAT_PRECISION_MULT);
c = (short)(quaternion.w * maxValueSign * QUAT_FLOAT_PRECISION_MULT);
break;
case 3:
a = (short)(quaternion.x * maxValueSign * QUAT_FLOAT_PRECISION_MULT);
b = (short)(quaternion.y * maxValueSign * QUAT_FLOAT_PRECISION_MULT);
c = (short)(quaternion.z * maxValueSign * QUAT_FLOAT_PRECISION_MULT);
break;
default:
throw new InvalidProgramException("Unexpected quaternion index.");
}
bool deltaZero = GameConfig.deltaZeroDeep && delta;
writer.Put(maxIndex);
writer.Put(a, deltaZero);
writer.Put(b, deltaZero);
writer.Put(c, deltaZero);
}
