public ENetPacket(Span <byte> data, ENetPacketFlags flags)
{
fixed(byte *p = data)
{
m_Native = LibENet.PacketCreate(new IntPtr(p), unchecked ((UIntPtr)data.Length), flags);
}
}
public ENetPacket(int dataLength, ENetPacketFlags flags)
{
if (dataLength < 0)
{
throw new ArgumentOutOfRangeException(nameof(dataLength));
}
m_Native = LibENet.PacketCreate(IntPtr.Zero, unchecked ((UIntPtr)dataLength), flags);
}
public void Broadcast(byte[] buffer, byte channel, ENetPacketFlags flags)
{
CheckDispose();
Native.ENetPacket *packet;
fixed(byte *p = buffer)
{
packet = LibENet.PacketCreate((IntPtr)p, (UIntPtr)buffer.Length, flags & ~ENetPacketFlags.NoAllocate);
}
LibENet.HostBroadcast(Pointer, channel, packet);
}
public void Send(byte[] buffer, byte channel, ENetPacketFlags flags)
{
Native.ENetPacket *packet;
fixed(byte *p = buffer)
{
packet = LibENet.PacketCreate((IntPtr)p, (UIntPtr)buffer.Length, flags & ~ENetPacketFlags.NoAllocate);
}
if (LibENet.PeerSend(Unsafe, channel, packet) < 0)
{
throw new Exception("Failed to send packet to peer.");
}
}
/// <summary>
/// Queues a packet to be sent.
/// </summary>
/// <param name="channelId">Destination channel Id</param>
/// <param name="buffer">Buffer containing packet data</param>
/// <param name="flags">Packet flags</param>
/// <remarks>
/// <see cref="ENetPacketFlags.NoAllocate"/> will be ignored.
/// </remarks>
public void Send(byte channelId, ReadOnlySpan <byte> buffer, ENetPacketFlags flags)
{
ThrowIfNull();
NativeENetPacket *packet;
fixed(byte *p = buffer)
{
packet = LibENet.PacketCreate((IntPtr)p, unchecked ((UIntPtr)buffer.Length), flags & ~ENetPacketFlags.NoAllocate);
}
if (LibENet.PeerSend(m_Native, channelId, packet) < 0)
{
ThrowHelper.ThrowENetPeerSendFailed();
}
}
public void Multicast(byte[] buffer, byte channel, ENetPacketFlags flags, IEnumerable <ENetPeer> peers, ENetPeer except)
{
CheckDispose();
Native.ENetPacket *packet;
fixed(byte *p = buffer)
{
packet = LibENet.PacketCreate((IntPtr)p, (UIntPtr)buffer.Length, flags & ~ENetPacketFlags.NoAllocate);
}
foreach (var peer in peers)
{
if (peer == null)
{
throw new NullReferenceException();
}
if (peer.Host != this)
{
throw new ENetMulticastException("Speicfied peer is not of this host.", peer);
}
if (peer == except)
{
continue;
}
if (peer.Unsafe->State != ENetPeerState.Connected)
{
continue;
}
if (LibENet.PeerSend(peer.Unsafe, channel, packet) != 0)
{
throw new ENetMulticastException("Failed to send packet to speicfied peer.", peer);
}
}
if (packet->ReferenceCount.ToUInt32() == 0)
{
LibENet.PacketDestroy(packet);
}
}
private ENetInterceptionResult InterceptCallback(IntPtr host, Native.ENetEvent *e)
{
if (Interceptor.Method == ENetInterceptor.InterceptionMethod.Unmanaged)
{
return(Interceptor.Intercept(m_pReceivedAddress, (byte **)m_pReceivedData, m_pReceivedDataLength, e));
}
if (Interceptor.Method == ENetInterceptor.InterceptionMethod.Managed)
{
IPEndPoint endPoint = (*m_pReceivedAddress).ToEndPoint();
byte[] buffer = new byte[(*m_pReceivedDataLength).ToUInt32()];
fixed(byte *dest = buffer)
{
Platform.Current.MemoryCopy((IntPtr)dest, *m_pReceivedData, *m_pReceivedDataLength);
}
byte[] bufferRef = buffer;
var result = Interceptor.Intercept(endPoint, ref bufferRef, out ENetEvent @event);
if (result == ENetInterceptionResult.Error)
{
return(result);
}
if (bufferRef == buffer)
{
fixed(byte *src = bufferRef)
{
Platform.Current.MemoryCopy((IntPtr)src, *m_pReceivedData, *m_pReceivedDataLength);
}
}
else if (bufferRef != null)
{
Marshal.FreeHGlobal(*m_pReceivedData);
var bufferPtr = Marshal.AllocHGlobal(bufferRef.Length);
* m_pReceivedData = bufferPtr;
* m_pReceivedDataLength = (UIntPtr)bufferRef.Length;
fixed(byte *src = bufferRef)
{
Platform.Current.MemoryCopy((IntPtr)src, bufferPtr, (UIntPtr)bufferRef.Length);
}
}
if (result == ENetInterceptionResult.Ignore)
{
return(result);
}
if (@event == null)
{
e->Type = ENetEventType.None;
return(result);
}
if (@event is ENetConnectEventArgs)
{
var connect = @event as ENetConnectEventArgs;
e->Type = ENetEventType.Connect;
e->Peer = connect.Peer.Unsafe;
e->Data = connect.Data;
return(result);
}
if (@event is ENetDisconnectEventArgs)
{
var disconnect = @event as ENetConnectEventArgs;
e->Type = ENetEventType.Disconnect;
e->Peer = disconnect.Peer.Unsafe;
e->Data = disconnect.Data;
return(result);
}
if (@event is ENetReceiveEventArgs)
{
var receive = @event as ENetReceiveEventArgs;
e->Type = ENetEventType.Receive;
e->Peer = receive.Peer.Unsafe;
e->ChannelID = receive.Packet.Channel;
fixed(byte *data = receive.Packet.m_Payload)
{
e->Packet = LibENet.PacketCreate((IntPtr)data, (UIntPtr)receive.Packet.m_Payload.Length, receive.Packet.Flags & ~ENetPacketFlags.NoAllocate);
}
return(result);
}
}
throw new NotImplementedException(Interceptor.Method.ToString());
}
