void RecvUnconnectedPacket(UdpBitStream buff, UdpEndPoint ep)
{
buff.Ptr = UdpHeader.GetSize(this);
if (buff.ReadByte(8) == (byte)UdpCommandType.Connect)
{
if (Config.AllowIncommingConnections && ((connLookup.Count + pendingConnections.Count) < Config.ConnectionLimit || Config.ConnectionLimit == -1))
{
if (Config.AutoAcceptIncommingConnections)
{
AcceptConnection(ep);
}
else
{
if (pendingConnections.Add(ep))
{
Raise(UdpEvent.PUBLIC_CONNECT_REQUEST, ep);
}
}
}
else
{
SendRefusedCommand(ep);
}
}
else
{
UdpLog.Debug("received invalid header byte in unconnected packet from {0}", ep.ToString());
}
}
public static void WriteColorRGBAHalf(ref UdpBitStream stream, Color value)
{
stream.WriteHalf(value.r);
stream.WriteHalf(value.g);
stream.WriteHalf(value.b);
stream.WriteHalf(value.a);
}
public static void WriteRigidbodyHalf(ref UdpBitStream stream, Rigidbody rigidbody)
{
UdpBitStreamExt.WriteVector3Half(ref stream, rigidbody.position);
UdpBitStreamExt.WriteQuaternionHalf(ref stream, rigidbody.rotation);
UdpBitStreamExt.WriteVector3Half(ref stream, rigidbody.velocity);
UdpBitStreamExt.WriteVector3Half(ref stream, rigidbody.angularVelocity);
}
public static void WriteVector4Half(ref UdpBitStream stream, Vector4 value)
{
stream.WriteHalf(value.x);
stream.WriteHalf(value.y);
stream.WriteHalf(value.z);
stream.WriteHalf(value.w);
}
public static void ReadRigidbodyHalf(ref UdpBitStream stream, Rigidbody rigidbody)
{
rigidbody.position = UdpBitStreamExt.ReadVector3Half(ref stream);
rigidbody.rotation = UdpBitStreamExt.ReadQuaternionHalf(ref stream);
rigidbody.velocity = UdpBitStreamExt.ReadVector3Half(ref stream);
rigidbody.angularVelocity = UdpBitStreamExt.ReadVector3Half(ref stream);
}
public static Plane ReadPlaneHalf(ref UdpBitStream stream)
{
return(new Plane(
UdpBitStreamExt.ReadVector3Half(ref stream),
stream.ReadHalf()
));
}
public static Plane ReadPlane(ref UdpBitStream stream)
{
return(new Plane(
UdpBitStreamExt.ReadVector3(ref stream),
stream.ReadFloat()
));
}
public static void WriteColor32RGBA(ref UdpBitStream stream, Color32 value)
{
stream.WriteByte(value.r, 8);
stream.WriteByte(value.g, 8);
stream.WriteByte(value.b, 8);
stream.WriteByte(value.a, 8);
}
public static void WriteQuaternionHalf(ref UdpBitStream stream, Quaternion value)
{
stream.WriteHalf(value.x);
stream.WriteHalf(value.y);
stream.WriteHalf(value.z);
stream.WriteHalf(value.w);
}
public static Ray ReadRayHalf(ref UdpBitStream stream)
{
return(new Ray(
UdpBitStreamExt.ReadVector3Half(ref stream),
UdpBitStreamExt.ReadVector3Half(ref stream)
));
}
void OnCommandReceived(UdpBitStream buffer)
{
if (ParseHeader(ref buffer))
{
stats.CommandsReceived += 1;
buffer.Ptr = UdpHeader.GetSize(socket);
UdpCommandType cmd = (UdpCommandType)buffer.ReadByte(8);
switch (cmd)
{
case UdpCommandType.Connect: OnCommandConnect(buffer); break;
case UdpCommandType.Accepted: OnCommandAccepted(buffer); break;
case UdpCommandType.Refused: OnCommandRefused(buffer); break;
case UdpCommandType.Disconnected: OnCommandDisconnected(buffer); break;
case UdpCommandType.Ping: OnCommandPing(buffer); break;
default: ConnectionError(UdpConnectionError.IncorrectCommand); break;
}
}
}
public static void WriteRectHalf(ref UdpBitStream stream, Rect rect)
{
stream.WriteHalf(rect.xMin);
stream.WriteHalf(rect.yMin);
stream.WriteHalf(rect.width);
stream.WriteHalf(rect.height);
}
public static void ReadRigidbodyHalf(ref UdpBitStream stream, out Vector3 position, out Quaternion rotation, out Vector3 velocity, out Vector3 angularVelocity)
{
position = UdpBitStreamExt.ReadVector3Half(ref stream);
rotation = UdpBitStreamExt.ReadQuaternionHalf(ref stream);
velocity = UdpBitStreamExt.ReadVector3Half(ref stream);
angularVelocity = UdpBitStreamExt.ReadVector3Half(ref stream);
}
void OnCommandDisconnected(UdpBitStream buffer)
{
EnsureClientIsConnected();
if (CheckState(UdpConnectionState.Connected))
{
ChangeState(UdpConnectionState.Disconnected);
}
}
public static Rect ReadRectHalf(ref UdpBitStream stream)
{
return(new Rect(
stream.ReadHalf(),
stream.ReadHalf(),
stream.ReadHalf(),
stream.ReadHalf()
));
}
public static Rect ReadRect(ref UdpBitStream stream)
{
return(new Rect(
stream.ReadFloat(),
stream.ReadFloat(),
stream.ReadFloat(),
stream.ReadFloat()
));
}
public override bool Unpack(ref UdpBitStream stream, ref object o)
{
// read length and create array, then read bytes into array
byte[] bytes = new byte[stream.ReadInt()];
stream.ReadByteArray(bytes);
// convert bytes to string
o = Encoding.UTF8.GetString(bytes);
return true;
}
public override bool Pack(ref UdpBitStream stream, ref object o)
{
// cast to string and get bytes
string msg = (string) o;
byte[] bytes = Encoding.UTF8.GetBytes(msg);
// write length and bytes into buffer
stream.WriteInt(bytes.Length);
stream.WriteByteArray(bytes);
return true;
}
internal void OnPacket(UdpBitStream buffer)
{
recvTime = socket.GetCurrentTime();
if ((buffer.Data[0] & 1) == 1)
{
OnObjectReceived(buffer);
}
else
{
OnCommandReceived(buffer);
}
}
internal void SendObject(object o)
{
serializer.SendNext(o);
while (serializer.HasQueuedObjects)
{
UdpSendFailReason reason = CheckCanSend(false);
if (reason != UdpSendFailReason.None)
{
while (serializer.HasQueuedObjects)
{
socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, serializer.NextObject(), reason);
}
break;
}
UdpBitStream stream = new UdpBitStream(socket.GetWriteBuffer(), mtu, UdpHeader.GetSize(socket));
object obj = serializer.NextObject();
if (serializer.Pack(ref stream, ref obj))
{
if (stream.Overflowing && (socket.Config.AllowPacketOverflow == false))
{
UdpLog.Error("stream to {0} is overflowing, not sending", endpoint.ToString());
socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, obj, UdpSendFailReason.StreamOverflow);
return;
}
UdpHeader header = MakeHeader(true);
header.Pack(new UdpBitStream(stream.Data, mtu, 0), socket);
UdpHandle handle = MakeHandle(ref header);
handle.Object = obj;
if (SendStream(stream, handle, alwaysSendMtu) == false)
{
socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, obj, UdpSendFailReason.SocketError);
}
else
{
stats.PacketSent();
}
}
else
{
socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, obj, UdpSendFailReason.SerializerReturnedFalse);
}
}
}
void OnCommandAccepted(UdpBitStream buffer)
{
if (IsClient)
{
if (CheckState(UdpConnectionState.Connecting))
{
ChangeState(UdpConnectionState.Connected);
}
}
else
{
ConnectionError(UdpConnectionError.IncorrectCommand);
}
}
void OnCommandConnect(UdpBitStream buffer)
{
if (IsServer)
{
if (CheckState(UdpConnectionState.Connected))
{
SendCommand(UdpCommandType.Accepted);
}
}
else
{
ConnectionError(UdpConnectionError.IncorrectCommand);
}
}
bool SendStream(UdpBitStream stream, UdpHandle handle, bool expandToMtu)
{
int bytesToSend = UdpMath.BytesRequired(stream.Ptr);
if (bytesToSend < mtu && expandToMtu)
{
bytesToSend = mtu;
}
sendTime = handle.SendTime;
sendSequence = handle.ObjSequence;
sendWindow.Enqueue(handle);
recvSinceLastSend = 0;
return(socket.Send(endpoint, stream.Data, bytesToSend));
}
bool ParseHeader(ref UdpBitStream buffer)
{
UdpHeader header = new UdpHeader();
header.Unpack(new UdpBitStream(buffer.Data, buffer.Length, 0), socket);
// Assign bit size
if (socket.Config.WritePacketBitSize)
{
buffer.Length = header.BitSize;
}
int seqDistance = UdpMath.SeqDistance(header.ObjSequence, recvSequence, UdpHeader.SEQ_PADD);
// we have to be within window size
if (seqDistance > socket.Config.PacketWindow || seqDistance < -socket.Config.PacketWindow)
{
ConnectionError(UdpConnectionError.SequenceOutOfBounds);
return(false);
}
// this is an old packet
if (seqDistance <= 0)
{
return(false);
}
// update receive history
if (seqDistance >= socket.Config.AckRedundancy)
{
recvHistory = 1UL;
}
else
{
recvHistory = (recvHistory << seqDistance) | 1UL;
}
// update our receive stats
recvSequence = header.ObjSequence;
recvSinceLastSend += 1;
// ack sent objects
AckHandles(header, true);
return(true);
}
void OnCommandRefused(UdpBitStream buffer)
{
if (IsClient)
{
if (CheckState(UdpConnectionState.Connecting))
{
socket.Raise(UdpEvent.PUBLIC_CONNECT_REFUSED, endpoint);
// destroy this connection on next timeout check
ChangeState(UdpConnectionState.Destroy);
}
}
else
{
ConnectionError(UdpConnectionError.IncorrectCommand);
}
}
public static void WriteMatrix4x4Half(ref UdpBitStream stream, ref Matrix4x4 m)
{
stream.WriteHalf(m.m00);
stream.WriteHalf(m.m01);
stream.WriteHalf(m.m02);
stream.WriteHalf(m.m03);
stream.WriteHalf(m.m10);
stream.WriteHalf(m.m11);
stream.WriteHalf(m.m12);
stream.WriteHalf(m.m13);
stream.WriteHalf(m.m20);
stream.WriteHalf(m.m21);
stream.WriteHalf(m.m22);
stream.WriteHalf(m.m23);
stream.WriteHalf(m.m30);
stream.WriteHalf(m.m31);
stream.WriteHalf(m.m32);
stream.WriteHalf(m.m33);
}
void SendRefusedCommand(UdpEndPoint endpoint)
{
UdpBitStream stream = new UdpBitStream(GetWriteBuffer(), Config.DefaultMtu, UdpHeader.GetSize(this));
stream.WriteByte((byte)UdpCommandType.Refused, 8);
UdpHeader header = new UdpHeader();
header.IsObject = false;
header.AckHistory = 0;
header.AckSequence = 1;
header.ObjSequence = 1;
header.Now = 0;
header.Pack(new UdpBitStream(stream.Data, Config.DefaultMtu, 0), this);
if (Send(endpoint, stream.Data, UdpMath.BytesRequired(stream.Ptr)) == false)
{
// do something here?
}
}
internal void SendCommand(UdpCommandType cmd)
{
if (CheckCanSend(true) == UdpSendFailReason.None)
{
UdpBitStream stream = new UdpBitStream(socket.GetWriteBuffer(), mtu, UdpHeader.GetSize(socket));
stream.WriteByte((byte)cmd, 8);
UdpHeader header = MakeHeader(false);
header.Pack(new UdpBitStream(stream.Data, mtu, 0), socket);
UdpHandle handle = MakeHandle(ref header);
handle.Object = null;
if (SendStream(stream, handle, false) == false)
{
// do something here?
}
stats.CommandSent += 1;
}
}
public static Matrix4x4 ReadMatrix4x4(ref UdpBitStream stream)
{
Matrix4x4 m = default(Matrix4x4);
m.m00 = stream.ReadFloat();
m.m01 = stream.ReadFloat();
m.m02 = stream.ReadFloat();
m.m03 = stream.ReadFloat();
m.m10 = stream.ReadFloat();
m.m11 = stream.ReadFloat();
m.m12 = stream.ReadFloat();
m.m13 = stream.ReadFloat();
m.m20 = stream.ReadFloat();
m.m21 = stream.ReadFloat();
m.m22 = stream.ReadFloat();
m.m23 = stream.ReadFloat();
m.m30 = stream.ReadFloat();
m.m31 = stream.ReadFloat();
m.m32 = stream.ReadFloat();
m.m33 = stream.ReadFloat();
return m;
}
public static Matrix4x4 ReadMatrix4x4Half(ref UdpBitStream stream)
{
Matrix4x4 m = default(Matrix4x4);
m.m00 = stream.ReadHalf();
m.m01 = stream.ReadHalf();
m.m02 = stream.ReadHalf();
m.m03 = stream.ReadHalf();
m.m10 = stream.ReadHalf();
m.m11 = stream.ReadHalf();
m.m12 = stream.ReadHalf();
m.m13 = stream.ReadHalf();
m.m20 = stream.ReadHalf();
m.m21 = stream.ReadHalf();
m.m22 = stream.ReadHalf();
m.m23 = stream.ReadHalf();
m.m30 = stream.ReadHalf();
m.m31 = stream.ReadHalf();
m.m32 = stream.ReadHalf();
m.m33 = stream.ReadHalf();
return(m);
}
void OnObjectReceived(UdpBitStream buffer)
{
EnsureClientIsConnected();
if (CheckState(UdpConnectionState.Connected) == false)
{
return;
}
if (ParseHeader(ref buffer))
{
object obj = null;
buffer.Ptr = UdpHeader.GetSize(socket);
if (serializer.Unpack(ref buffer, ref obj))
{
socket.Raise(UdpEvent.PUBLIC_OBJECT_RECEIVED, this, obj);
}
stats.PacketReceived();
}
}
public static void ReadAllElements<T>(ref UdpKit.UdpBitStream bitstream, MsgType msgType, FrameBuffer buffer, int packetId, List<T> elements)
where T : TransformElement
{
Frame frame = buffer.frames[packetId];
bool isCurrentFrame = (packetId == buffer.CurrentIndex);
bool isPos = ((typeof(T) == typeof(PositionElement)));
for (int i = 0; i < elements.Count; i++)
{
TransformElement e = elements[i];
bool forcedUpdate = e.IsUpdateForced(msgType, packetId);
bool isKeyframe = e.IsKeyframe(packetId);
// Read element from the buffer if it is expected
if (forcedUpdate || e.sendCulling.ChangesType())
{
bool hasChanged = e.ReadFromBitstream(ref bitstream, msgType, frame, i, forcedUpdate, isKeyframe);
// reapply snapshot if this frame is mid lerping (current), this is more accurate than the reconstructed rot being used.
if (isCurrentFrame && hasChanged)
{
DebugX.Log("Mid lerp child update");
if (isPos)
e.Snapshot(frame.positions, i, true);
else
e.Snapshot(frame.rotations, i, true);
}
// Set the mask if this element sent an update
if (isPos)
i.SetBitInMask(ref frame.positionsMask, hasChanged);
else
i.SetBitInMask(ref frame.rotationsMask, hasChanged);
}
}
}
public static void WriteAllElements<T>(ref UdpKit.UdpBitStream bitstream, MsgType msgType, FrameBuffer buffer, int packetId, List<T> elements)
where T : TransformElement
{
Frame frame = buffer.frames[packetId];
for (int i = 0; i < elements.Count; i++)
{
TransformElement e = elements[i];
bool forcedUpdate = e.IsUpdateForced(msgType, packetId);
bool isKeyframe = e.IsKeyframe(packetId);
// Write this element to the stream if it is expected
if (forcedUpdate || e.sendCulling.ChangesType())
e.WriteToBitstream(ref bitstream, msgType, forcedUpdate, isKeyframe);
// Store the current transform in the frame buffer if this has local authority TODO: (may not actually be used anywhere)
if ((typeof(T) == typeof(PositionElement)))
frame.positions[i] = (e as PositionElement).Localized;
else
frame.rotations[i] = (e as RotationElement).Localized;
}
}
public static Color32 ReadColor32RGBA(ref UdpBitStream stream)
{
return new Color32(stream.ReadByte(8), stream.ReadByte(8), stream.ReadByte(8), stream.ReadByte(8));
}
internal void OnPacket(UdpBitStream buffer)
{
recvTime = socket.GetCurrentTime();
if ((buffer.Data[0] & 1) == 1) {
OnObjectReceived(buffer);
} else {
OnCommandReceived(buffer);
}
}
public static void WriteLayerMask(ref UdpBitStream stream, LayerMask mask)
{
stream.WriteInt(mask.value, 32);
}
public static void WritePlaneHalf(ref UdpBitStream stream, Plane plane)
{
UdpBitStreamExt.WriteVector3Half(ref stream, plane.normal);
stream.WriteHalf(plane.distance);
}
public static void WriteRayHalf(ref UdpBitStream stream, Ray ray)
{
UdpBitStreamExt.WriteVector3Half(ref stream, ray.origin);
UdpBitStreamExt.WriteVector3Half(ref stream, ray.direction);
}
public static void WriteRectHalf(ref UdpBitStream stream, Rect rect)
{
stream.WriteHalf(rect.xMin);
stream.WriteHalf(rect.yMin);
stream.WriteHalf(rect.width);
stream.WriteHalf(rect.height);
}
public static void WriteTransformHalf(ref UdpBitStream stream, Transform transform)
{
UdpBitStreamExt.WriteVector3Half(ref stream, transform.position);
UdpBitStreamExt.WriteQuaternionHalf(ref stream, transform.rotation);
}
void OnCommandReceived(UdpBitStream buffer)
{
if (ParseHeader(ref buffer)) {
stats.CommandsReceived += 1;
buffer.Ptr = UdpHeader.GetSize(socket);
UdpCommandType cmd = (UdpCommandType) buffer.ReadByte(8);
switch (cmd) {
case UdpCommandType.Connect: OnCommandConnect(buffer); break;
case UdpCommandType.Accepted: OnCommandAccepted(buffer); break;
case UdpCommandType.Refused: OnCommandRefused(buffer); break;
case UdpCommandType.Disconnected: OnCommandDisconnected(buffer); break;
case UdpCommandType.Ping: OnCommandPing(buffer); break;
default: ConnectionError(UdpConnectionError.IncorrectCommand); break;
}
}
}
void OnCommandPing(UdpBitStream buffer)
{
EnsureClientIsConnected();
}
void OnCommandDisconnected(UdpBitStream buffer)
{
EnsureClientIsConnected();
if (CheckState(UdpConnectionState.Connected)) {
ChangeState(UdpConnectionState.Disconnected);
}
}
void OnCommandConnect(UdpBitStream buffer)
{
if (IsServer) {
if (CheckState(UdpConnectionState.Connected)) {
SendCommand(UdpCommandType.Accepted);
}
} else {
ConnectionError(UdpConnectionError.IncorrectCommand);
}
}
void OnCommandAccepted(UdpBitStream buffer)
{
if (IsClient) {
if (CheckState(UdpConnectionState.Connecting)) {
ChangeState(UdpConnectionState.Connected);
}
} else {
ConnectionError(UdpConnectionError.IncorrectCommand);
}
}
internal void SendObject(object o)
{
serializer.SendNext(o);
while (serializer.HasQueuedObjects) {
UdpSendFailReason reason = CheckCanSend(false);
if (reason != UdpSendFailReason.None) {
while (serializer.HasQueuedObjects) {
socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, serializer.NextObject(), reason);
}
break;
}
UdpBitStream stream = new UdpBitStream(socket.GetWriteBuffer(), mtu, UdpHeader.GetSize(socket));
object obj = serializer.NextObject();
if (serializer.Pack(ref stream, ref obj)) {
if (stream.Overflowing && (socket.Config.AllowPacketOverflow == false)) {
UdpLog.Error("stream to {0} is overflowing, not sending", endpoint.ToString());
socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, obj, UdpSendFailReason.StreamOverflow);
return;
}
UdpHeader header = MakeHeader(true);
header.Pack(new UdpBitStream(stream.Data, mtu, 0), socket);
UdpHandle handle = MakeHandle(ref header);
handle.Object = obj;
if (SendStream(stream, handle, alwaysSendMtu) == false) {
socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, obj, UdpSendFailReason.SocketError);
} else {
stats.PacketSent();
}
} else {
socket.Raise(UdpEvent.PUBLIC_OBJECT_SEND_FAILED, this, obj, UdpSendFailReason.SerializerReturnedFalse);
}
}
}
internal void SendCommand(UdpCommandType cmd)
{
if (CheckCanSend(true) == UdpSendFailReason.None) {
UdpBitStream stream = new UdpBitStream(socket.GetWriteBuffer(), mtu, UdpHeader.GetSize(socket));
stream.WriteByte((byte) cmd, 8);
UdpHeader header = MakeHeader(false);
header.Pack(new UdpBitStream(stream.Data, mtu, 0), socket);
UdpHandle handle = MakeHandle(ref header);
handle.Object = null;
if (SendStream(stream, handle, false) == false) {
// do something here?
}
stats.CommandSent += 1;
}
}
public static void WriteVector4Half(ref UdpBitStream stream, Vector4 value)
{
stream.WriteHalf(value.x);
stream.WriteHalf(value.y);
stream.WriteHalf(value.z);
stream.WriteHalf(value.w);
}
public static void WriteVector3(ref UdpBitStream stream, Vector3 value)
{
stream.WriteFloat(value.x);
stream.WriteFloat(value.y);
stream.WriteFloat(value.z);
}
void OnCommandRefused(UdpBitStream buffer)
{
if (IsClient) {
if (CheckState(UdpConnectionState.Connecting)) {
socket.Raise(UdpEvent.PUBLIC_CONNECT_REFUSED, endpoint);
// destroy this connection on next timeout check
ChangeState(UdpConnectionState.Destroy);
}
} else {
ConnectionError(UdpConnectionError.IncorrectCommand);
}
}
public static void WriteRigidbodyHalf(ref UdpBitStream stream, Rigidbody rigidbody)
{
UdpBitStreamExt.WriteVector3Half(ref stream, rigidbody.position);
UdpBitStreamExt.WriteQuaternionHalf(ref stream, rigidbody.rotation);
UdpBitStreamExt.WriteVector3Half(ref stream, rigidbody.velocity);
UdpBitStreamExt.WriteVector3Half(ref stream, rigidbody.angularVelocity);
}
void OnObjectReceived(UdpBitStream buffer)
{
EnsureClientIsConnected();
if (CheckState(UdpConnectionState.Connected) == false)
return;
if (ParseHeader(ref buffer)) {
object obj = null;
buffer.Ptr = UdpHeader.GetSize(socket);
if (serializer.Unpack(ref buffer, ref obj)) {
socket.Raise(UdpEvent.PUBLIC_OBJECT_RECEIVED, this, obj);
}
stats.PacketReceived();
}
}
public static Bounds ReadBoundsHalf(ref UdpBitStream stream)
{
return new Bounds(UdpBitStreamExt.ReadVector3Half(ref stream), UdpBitStreamExt.ReadVector3Half(ref stream));
}
bool ParseHeader(ref UdpBitStream buffer)
{
UdpHeader header = new UdpHeader();
header.Unpack(new UdpBitStream(buffer.Data, buffer.Length, 0), socket);
// Assign bit size
if (socket.Config.WritePacketBitSize) {
buffer.Length = header.BitSize;
}
int seqDistance = UdpMath.SeqDistance(header.ObjSequence, recvSequence, UdpHeader.SEQ_PADD);
// we have to be within window size
if (seqDistance > socket.Config.PacketWindow || seqDistance < -socket.Config.PacketWindow) {
ConnectionError(UdpConnectionError.SequenceOutOfBounds);
return false;
}
// this is an old packet
if (seqDistance <= 0)
return false;
// update receive history
if (seqDistance >= socket.Config.AckRedundancy) {
recvHistory = 1UL;
} else {
recvHistory = (recvHistory << seqDistance) | 1UL;
}
// update our receive stats
recvSequence = header.ObjSequence;
recvSinceLastSend += 1;
// ack sent objects
AckHandles(header, true);
return true;
}
public static void WriteQuaternionHalf(ref UdpBitStream stream, Quaternion value)
{
stream.WriteHalf(value.x);
stream.WriteHalf(value.y);
stream.WriteHalf(value.z);
stream.WriteHalf(value.w);
}
bool SendStream(UdpBitStream stream, UdpHandle handle, bool expandToMtu)
{
int bytesToSend = UdpMath.BytesRequired(stream.Ptr);
if (bytesToSend < mtu && expandToMtu) {
bytesToSend = mtu;
}
sendTime = handle.SendTime;
sendSequence = handle.ObjSequence;
sendWindow.Enqueue(handle);
recvSinceLastSend = 0;
return socket.Send(endpoint, stream.Data, bytesToSend);
}
public static void WriteMatrix4x4Half(ref UdpBitStream stream, ref Matrix4x4 m)
{
stream.WriteHalf(m.m00);
stream.WriteHalf(m.m01);
stream.WriteHalf(m.m02);
stream.WriteHalf(m.m03);
stream.WriteHalf(m.m10);
stream.WriteHalf(m.m11);
stream.WriteHalf(m.m12);
stream.WriteHalf(m.m13);
stream.WriteHalf(m.m20);
stream.WriteHalf(m.m21);
stream.WriteHalf(m.m22);
stream.WriteHalf(m.m23);
stream.WriteHalf(m.m30);
stream.WriteHalf(m.m31);
stream.WriteHalf(m.m32);
stream.WriteHalf(m.m33);
}
public static Color ReadColorRGBA(ref UdpBitStream stream)
{
return new Color(stream.ReadFloat(), stream.ReadFloat(), stream.ReadFloat(), stream.ReadFloat());
}
public static Color ReadColorRGBHalf(ref UdpBitStream stream)
{
return new Color(stream.ReadHalf(), stream.ReadHalf(), stream.ReadHalf());
}
public static LayerMask ReadLayerMask(ref UdpBitStream stream)
{
return stream.ReadInt(32);
}
