/// <summary>
/// Compress a Normalized float. For bit-based settings, you must supply floats in the range of 0 to 1.
/// Values outside of that range will produce a looping modulus behaviour.
/// </summary>
/// <returns>Returns the compressed value as a uint, with an out bits value for convenience with bitpacking.</returns>
public static uint CompressNorm(this float value, int bits)
{
switch (bits)
{
case 0:
return((uint)0);
case 1:
return((uint)value);
case 2:
return((uint)(value * NORM_COMP_ENCODE2));
case 3:
return((uint)(value * NORM_COMP_ENCODE3));
case 4:
return((uint)(value * NORM_COMP_ENCODE4));
case 5:
return((uint)(value * NORM_COMP_ENCODE5));
case 6:
return((uint)(value * NORM_COMP_ENCODE6));
case 7:
return((uint)(value * NORM_COMP_ENCODE7));
case 8:
return((uint)(value * NORM_COMP_ENCODE8));
case 9:
return((uint)(value * NORM_COMP_ENCODE9));
case 10:
return((uint)(value * NORM_COMP_ENCODE10));
case 11:
return((uint)(value * NORM_COMP_ENCODE11));
case 12:
return((uint)(value * NORM_COMP_ENCODE12));
case 13:
return((uint)(value * NORM_COMP_ENCODE13));
case 14:
return((uint)(value * NORM_COMP_ENCODE14));
case 15:
return((uint)(value * NORM_COMP_ENCODE15));
case 16:
return(HalfUtilities.Pack(value));
default:
return((ByteConverter)value);
}
}
public void Pack(Network.ByteOutStream stream)
{
Vector3 p;
Quaternion r;
byte angle = 0;
if (Actor.Context.IsServer)
{
p = position;
r = rotation;
if (yawOnly)
{
angle = (byte)(yaw * 0.71111f);
}
}
else
{
p = Actor.Transform.Position;
r = Actor.Transform.Rotation;
if (yawOnly)
{
angle = (byte)(Vector3.SignedAngle(Vector3.Forward, Actor.Transform.Forward, Vector3.Up) * 0.71111f);
}
}
if (compressPosition)
{
stream.WriteUShort(HalfUtilities.Pack(p.X));
stream.WriteUShort(HalfUtilities.Pack(p.Y));
stream.WriteUShort(HalfUtilities.Pack(p.Z));
}
else
{
stream.WriteVector3(p);
}
if (yawOnly)
{
stream.WriteByte(angle);
}
else
{
p = r.Axis;
stream.WriteUShort(HalfUtilities.Pack(p.X));
stream.WriteUShort(HalfUtilities.Pack(p.Y));
stream.WriteUShort(HalfUtilities.Pack(p.Z));
stream.WriteByte((byte)(r.Angle * SlimMath.Single.Rad2Deg * 0.71111f));
}
}
/// <summary>
/// Compress and Write a Normalized float. For bit-based settings, you must supply floats in the range of 0 to 1.
/// Values outside of that range will produce a looping modulus behaviour.
/// </summary>
/// <returns>Returns the compressed value as a uint.</returns>
public static uint WriteNorm(this byte[] buffer, float value, ref int bitposition, int bits)
{
uint cval;
switch (bits)
{
case 0:
cval = 0;
break;
case 1:
cval = (uint)value;
break;
case 2:
cval = (uint)(value * NORM_COMP_ENCODE2);
break;
case 3:
cval = (uint)(value * NORM_COMP_ENCODE3);
break;
case 4:
cval = (uint)(value * NORM_COMP_ENCODE4);
break;
case 5:
cval = (uint)(value * NORM_COMP_ENCODE5);
break;
case 6:
cval = (uint)(value * NORM_COMP_ENCODE6);
break;
case 7:
cval = (uint)(value * NORM_COMP_ENCODE7);
break;
case 8:
cval = (uint)(value * NORM_COMP_ENCODE8);
break;
case 9:
cval = (uint)(value * NORM_COMP_ENCODE9);
break;
case 10:
cval = (uint)(value * NORM_COMP_ENCODE10);
break;
case 11:
cval = (uint)(value * NORM_COMP_ENCODE11);
break;
case 12:
cval = (uint)(value * NORM_COMP_ENCODE12);
break;
case 13:
cval = (uint)(value * NORM_COMP_ENCODE13);
break;
case 14:
cval = (uint)(value * NORM_COMP_ENCODE14);
break;
case 15:
cval = (uint)(value * NORM_COMP_ENCODE15);
break;
case 16:
cval = HalfUtilities.Pack(value);
break;
default:
cval = (ByteConverter)value;
break;
}
buffer.Write(cval, ref bitposition, bits);
return(cval);
}
public static void AppendHalf(this byte[] buffer, float value, ref int bitposition)
{
buffer.Append(HalfUtilities.Pack(value), ref bitposition, 16);
}
