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()); }