package vendor:ENet

Source

Acknowledgment :: struct {
	acknowledgementList: ListNode,
	sentTime:            u32,
	command:             Protocol,
}

Address :: struct {
	host: u32,
	port: u16,
}

Buffer :: struct {
	data:       rawptr,
	dataLength: uint,
}

Callbacks :: struct {
	malloc:    proc "c" (size: uint) -> rawptr,
	free:      proc "c" (memory: rawptr),
	no_memory: proc "c" (),
}

Channel :: struct {
	outgoingReliableSequenceNumber:   u16,
	outgoingUnreliableSequenceNumber: u16,
	usedReliableWindows:              u16,
	reliableWindows:                  [16]u16,
	incomingReliableSequenceNumber:   u16,
	incomingUnreliableSequenceNumber: u16,
	incomingReliableCommands:         List,
	incomingUnreliableCommands:       List,
}

ChecksumCallback :: proc "c" (buffers: [^]Buffer, bufferCount: uint) -> u32

Compressor :: struct {
	context_:   rawptr,
	compress:   proc "c" (context_: rawptr, inBuffers: [^]Buffer, inBufferCount: uint, inLimit: uint, outData: [^]u8, outLimit: uint) -> uint,
	decompress: proc "c" (context_: rawptr, inData: [^]u8, inLimit: uint, outData: [^]u8, outLimit: uint) -> uint,
	destroy:    proc "c" (context_: rawptr),
}

Event :: struct {
	type:      EventType,
	peer:      ^Peer,
	channelID: u8,
	data:      u32,
	packet:    ^Packet,
}

EventType :: enum i32 {
	NONE       = 0, 
	CONNECT    = 1, 
	DISCONNECT = 2, 
	RECEIVE    = 3, 
}

Host :: struct {
	socket:                     Socket,
	address:                    Address,
	incomingBandwidth:          u32,
	outgoingBandwidth:          u32,
	bandwidthThrottleEpoch:     u32,
	mtu:                        u32,
	randomSeed:                 u32,
	recalculateBandwidthLimits: i32,
	peers:                      [^]Peer `fmt:"v,peerCount"`,
	peerCount:                  uint,
	channelLimit:               uint,
	serviceTime:                u32,
	dispatchQueue:              List,
	continueSending:            i32,
	packetSize:                 uint,
	headerFlags:                u16,
	commands:                   [32]Protocol,
	commandCount:               uint,
	buffers:                    [65]Buffer,
	bufferCount:                uint,
	checksum:                   ChecksumCallback,
	compressor:                 Compressor,
	packetData:                 [2][4096]u8,
	receivedAddress:            Address,
	receivedData:               [^]u8 `fmt:"v,receivedDataLength"`,
	receivedDataLength:         uint,
	totalSentData:              u32,
	totalSentPackets:           u32,
	totalReceivedData:          u32,
	totalReceivedPackets:       u32,
	intercept:                  InterceptCallback,
	connectedPeers:             uint,
	bandwidthLimitedPeers:      uint,
	duplicatePeers:             uint,
	maximumPacketSize:          uint,
	maximumWaitingData:         uint,
}

IncomingCommand :: struct {
	incomingCommandList:      ListNode,
	reliableSequenceNumber:   u16,
	unreliableSequenceNumber: u16,
	command:                  Protocol,
	fragmentCount:            u32,
	fragmentsRemaining:       u32,
	fragments:                [^]u32 `fmt:"v,fragmentCount"`,
	packet:                   ^Packet,
}

InterceptCallback :: proc "c" (host: ^Host, event: ^Event) -> i32

List :: struct {
	sentinel: ListNode,
}

ListNode :: struct {
	next:     ^ListNode,
	previous: ^ListNode,
}

OutgoingCommand :: struct {
	outgoingCommandList:      ListNode,
	reliableSequenceNumber:   u16,
	unreliableSequenceNumber: u16,
	sentTime:                 u32,
	roundTripTimeout:         u32,
	roundTripTimeoutLimit:    u32,
	fragmentOffset:           u32,
	fragmentLength:           u16,
	sendAttempts:             u16,
	command:                  Protocol,
	packet:                   ^Packet,
}

Packet :: struct {
	referenceCount: uint,
	flags:          u32,
	data:           [^]u8 `fmt:"v,dataLength"`,
	dataLength:     uint,
	freeCallback:   PacketFreeCallback,
	userData:       rawptr,
}

PacketFlag :: enum i32 {
	RELIABLE            = 0, 
	UNSEQUENCED         = 1, 
	NO_ALLOCATE         = 2, 
	UNRELIABLE_FRAGMENT = 3, 
	FLAG_SENT           = 8, 
}

PacketFlags :: bit_set[PacketFlag; i32]

PacketFreeCallback :: proc "c" (packet: ^Packet)

Peer :: struct {
	dispatchList:                   ListNode,
	host:                           ^Host,
	outgoingPeerID:                 u16,
	incomingPeerID:                 u16,
	connectID:                      u32,
	outgoingSessionID:              u8,
	incomingSessionID:              u8,
	address:                        Address,
	data:                           rawptr,
	state:                          PeerState,
	channels:                       [^]Channel `fmt:"v,channelCount"`,
	channelCount:                   uint,
	incomingBandwidth:              u32,
	outgoingBandwidth:              u32,
	incomingBandwidthThrottleEpoch: u32,
	outgoingBandwidthThrottleEpoch: u32,
	incomingDataTotal:              u32,
	outgoingDataTotal:              u32,
	lastSendTime:                   u32,
	lastReceiveTime:                u32,
	nextTimeout:                    u32,
	earliestTimeout:                u32,
	packetLossEpoch:                u32,
	packetsSent:                    u32,
	packetsLost:                    u32,
	packetLoss:                     u32,
	packetLossVariance:             u32,
	packetThrottle:                 u32,
	packetThrottleLimit:            u32,
	packetThrottleCounter:          u32,
	packetThrottleEpoch:            u32,
	packetThrottleAcceleration:     u32,
	packetThrottleDeceleration:     u32,
	packetThrottleInterval:         u32,
	pingInterval:                   u32,
	timeoutLimit:                   u32,
	timeoutMinimum:                 u32,
	timeoutMaximum:                 u32,
	lastRoundTripTime:              u32,
	lowestRoundTripTime:            u32,
	lastRoundTripTimeVariance:      u32,
	highestRoundTripTimeVariance:   u32,
	roundTripTime:                  u32,
	roundTripTimeVariance:          u32,
	mtu:                            u32,
	windowSize:                     u32,
	reliableDataInTransit:          u32,
	outgoingReliableSequenceNumber: u16,
	acknowledgements:               List,
	sentReliableCommands:           List,
	sentUnreliableCommands:         List,
	outgoingCommands:               List,
	dispatchedCommands:             List,
	flags:                          u16,
	reserved:                       u16,
	incomingUnsequencedGroup:       u16,
	outgoingUnsequencedGroup:       u16,
	unsequencedWindow:              [32]u32,
	eventData:                      u32,
	totalWaitingData:               uint,
}

PeerFlag :: enum i32 {
	NEEDS_DISPATCH, 
}

PeerState :: enum i32 {
	DISCONNECTED, 
	CONNECTING, 
	ACKNOWLEDGING_CONNECT, 
	CONNECTION_PENDING, 
	CONNECTION_SUCCEEDED, 
	CONNECTED, 
	DISCONNECT_LATER, 
	DISCONNECTING, 
	ACKNOWLEDGING_DISCONNECT, 
	ZOMBIE, 
}

Protocol :: struct #raw_union {
	header:            ProtocolCommandHeader,
	acknowledge:       ProtocolAcknowledge,
	connect:           ProtocolConnect,
	verifyConnect:     ProtocolVerifyConnect,
	disconnect:        ProtocolDisconnect,
	ping:              ProtocolPing,
	sendReliable:      ProtocolSendReliable,
	sendUnreliable:    ProtocolSendUnreliable,
	sendUnsequenced:   ProtocolSendUnsequenced,
	sendFragment:      ProtocolSendFragment,
	bandwidthLimit:    ProtocolBandwidthLimit,
	throttleConfigure: ProtocolThrottleConfigure,
}

ProtocolAcknowledge :: struct #packed {
	header:                     ProtocolCommandHeader,
	outgoingPeerID:             u16,
	incomingSessionID:          u8,
	outgoingSessionID:          u8,
	mtu:                        u32,
	windowSize:                 u32,
	channelCount:               u32,
	incomingBandwidth:          u32,
	outgoingBandwidth:          u32,
	packetThrottleInterval:     u32,
	packetThrottleAcceleration: u32,
	packetThrottleDeceleration: u32,
	connectID:                  u32,
	data:                       u32,
}

ProtocolBandwidthLimit :: struct #packed {
	header:            ProtocolCommandHeader,
	incomingBandwidth: u32,
	outgoingBandwidth: u32,
}

ProtocolCommand :: enum i32 {
	NONE                     = 0, 
	ACKNOWLEDGE              = 1, 
	CONNECT                  = 2, 
	VERIFY_CONNECT           = 3, 
	DISCONNECT               = 4, 
	PING                     = 5, 
	SEND_RELIABLE            = 6, 
	SEND_UNRELIABLE          = 7, 
	SEND_FRAGMENT            = 8, 
	SEND_UNSEQUENCED         = 9, 
	BANDWIDTH_LIMIT          = 10, 
	THROTTLE_CONFIGURE       = 11, 
	SEND_UNRELIABLE_FRAGMENT = 12, 
	COUNT                    = 13, 
	MASK                     = 15, 
}

ProtocolCommandHeader :: struct #packed {
	command:                u8,
	channelID:              u8,
	reliableSequenceNumber: u16,
}

ProtocolConnect :: struct #packed {
	header:                     ProtocolCommandHeader,
	outgoingPeerID:             u16,
	incomingSessionID:          u8,
	outgoingSessionID:          u8,
	mtu:                        u32,
	windowSize:                 u32,
	channelCount:               u32,
	incomingBandwidth:          u32,
	outgoingBandwidth:          u32,
	packetThrottleInterval:     u32,
	packetThrottleAcceleration: u32,
	packetThrottleDeceleration: u32,
	connectID:                  u32,
	data:                       u32,
}

ProtocolDisconnect :: struct #packed {
	header: ProtocolCommandHeader,
	data:   u32,
}

ProtocolFlag :: enum i32 {
	COMMAND_ACKNOWLEDGE  = 128, 
	COMMAND_UNSEQUENCED  = 64, 
	HEADER_COMPRESSED    = 16384, 
	HEADER_SENT_TIME     = 32768, 
	HEADER_MASK          = 49152, 
	HEADER_SESSION_MASK  = 12288, 
	HEADER_SESSION_SHIFT = 12, 
}

ProtocolHeader :: struct #packed {
	peerID:   u16,
	sentTime: u16,
}

ProtocolPing :: struct #packed {
	header: ProtocolCommandHeader,
}

ProtocolSendFragment :: struct #packed {
	header:              ProtocolCommandHeader,
	startSequenceNumber: u16,
	dataLength:          u16,
	fragmentCount:       u32,
	fragmentNumber:      u32,
	totalLength:         u32,
	fragmentOffset:      u32,
}

ProtocolSendReliable :: struct #packed {
	header:     ProtocolCommandHeader,
	dataLength: u16,
}

ProtocolSendUnreliable :: struct #packed {
	header:                   ProtocolCommandHeader,
	unreliableSequenceNumber: u16,
	dataLength:               u16,
}

ProtocolSendUnsequenced :: struct #packed {
	header:           ProtocolCommandHeader,
	unsequencedGroup: u16,
	dataLength:       u16,
}

ProtocolThrottleConfigure :: struct #packed {
	header:                     ProtocolCommandHeader,
	packetThrottleInterval:     u32,
	packetThrottleAcceleration: u32,
	packetThrottleDeceleration: u32,
}

ProtocolVerifyConnect :: struct #packed {
	header:                     ProtocolCommandHeader,
	outgoingPeerID:             u16,
	incomingSessionID:          u8,
	outgoingSessionID:          u8,
	mtu:                        u32,
	windowSize:                 u32,
	channelCount:               u32,
	incomingBandwidth:          u32,
	outgoingBandwidth:          u32,
	packetThrottleInterval:     u32,
	packetThrottleAcceleration: u32,
	packetThrottleDeceleration: u32,
	connectID:                  u32,
}

Socket :: distinct uintptr

SocketOption :: enum i32 {
	NONBLOCK  = 1, 
	BROADCAST = 2, 
	RCVBUF    = 3, 
	SNDBUF    = 4, 
	REUSEADDR = 5, 
	RCVTIMEO  = 6, 
	SNDTIMEO  = 7, 
	ERROR     = 8, 
	NODELAY   = 9, 
}

SocketSet :: struct {
	fd_count: u32,
	fd_array: [64]uintptr,
}

SocketShutdown :: enum i32 {
	READ       = 0, 
	WRITE      = 1, 
	READ_WRITE = 2, 
}

SocketType :: enum i32 {
	STREAM   = 1, 
	DATAGRAM = 2, 
}

SocketWait :: enum i32 {
	NONE      = 0, 
	SEND      = 1, 
	RECEIVE   = 2, 
	INTERRUPT = 4, 
}

Version :: u32

BUFFER_MAXIMUM :: 1 + 2 * PROTOCOL_MAXIMUM_PACKET_COMMANDS

HOST_ANY :: u32(0)

HOST_BANDWIDTH_THROTTLE_INTERVAL :: 1000

HOST_BROADCAST :: u32(0xffffffff)

HOST_DEFAULT_MAXIMUM_PACKET_SIZE :: 32 * 1024 * 1024

HOST_DEFAULT_MAXIMUM_WAITING_DATA :: 32 * 1024 * 1024

HOST_DEFAULT_MTU :: 1400

HOST_RECEIVE_BUFFER_SIZE :: 256 * 1024

HOST_SEND_BUFFER_SIZE :: 256 * 1024

PEER_DEFAULT_PACKET_THROTTLE :: 32

PEER_DEFAULT_ROUND_TRIP_TIME :: 500

PEER_FREE_RELIABLE_WINDOWS :: 8

PEER_FREE_UNSEQUENCED_WINDOWS :: 32

PEER_PACKET_LOSS_INTERVAL :: 10000

PEER_PACKET_LOSS_SCALE :: 1 << 16

PEER_PACKET_THROTTLE_ACCELERATION :: 2

PEER_PACKET_THROTTLE_COUNTER :: 7

PEER_PACKET_THROTTLE_DECELERATION :: 2

PEER_PACKET_THROTTLE_INTERVAL :: 5000

PEER_PACKET_THROTTLE_SCALE :: 32

PEER_PING_INTERVAL :: 500

PEER_RELIABLE_WINDOWS :: 16

PEER_RELIABLE_WINDOW_SIZE :: 0x1000

PEER_TIMEOUT_LIMIT :: 32

PEER_TIMEOUT_MAXIMUM :: 30000

PEER_TIMEOUT_MINIMUM :: 5000

PEER_UNSEQUENCED_WINDOWS :: 64

PEER_UNSEQUENCED_WINDOW_SIZE :: 1024

PEER_WINDOW_SIZE_SCALE :: 64 * 1024

PORT_ANY :: u16(0)

PROTOCOL_MAXIMUM_CHANNEL_COUNT :: 255

PROTOCOL_MAXIMUM_FRAGMENT_COUNT :: 1024 * 1024

PROTOCOL_MAXIMUM_MTU :: 4096

PROTOCOL_MAXIMUM_PACKET_COMMANDS :: 32

PROTOCOL_MAXIMUM_PEER_ID :: 0xFFF

PROTOCOL_MAXIMUM_WINDOW_SIZE :: 65536

PROTOCOL_MINIMUM_CHANNEL_COUNT :: 1

PROTOCOL_MINIMUM_MTU :: 576

PROTOCOL_MINIMUM_WINDOW_SIZE :: 4096

SOCKET_NULL :: Socket(~uintptr(0))

TIME_OVERFLOW :: u32(86400000)

VERSION: u32 : (u32(VERSION_MAJOR) << 16) | (u32(VERSION_MINOR) << 8) | u32(VERSION_PATCH)

VERSION_MAJOR :: u8(1)

VERSION_MINOR :: u8(3)

VERSION_PATCH :: u8(17)

HOST_TO_NET_16 :: proc "contextless" (value: u16) -> u16 {…}

HOST_TO_NET_32 :: proc "contextless" (value: u32) -> u32 {…}

NET_TO_HOST_16 :: proc "contextless" (value: u16) -> u16 {…}

NET_TO_HOST_32 :: proc "contextless" (value: u32) -> u32 {…}

SOCKETSET_ADD :: proc "contextless" (sockset: ^SocketSet, socket: Socket) {…}

SOCKETSET_EMPTY :: proc "contextless" (sockset: ^SocketSet) {…}

SOCKETSET_REMOVE :: proc "contextless" (sockset: ^SocketSet, socket: Socket) {…}

SOCKSET_CHECK :: proc "contextless" (sockset: ^SocketSet, socket: Socket) -> bool {…}

TIME_DIFFERENCE :: proc "contextless" (a, b: u32) -> u32 {…}

TIME_GREATER :: proc "contextless" (a, b: u32) -> bool {…}

TIME_GREATER_EQUAL :: proc "contextless" (a, b: u32) -> bool {…}

TIME_LESS :: proc "contextless" (a, b: u32) -> bool {…}

TIME_LESS_EQUAL :: proc "contextless" (a, b: u32) -> bool {…}

VERSION_CREATE :: proc "contextless" (major, minor, patch: u8) -> u32 {…}

VERSION_GET_MAJOR :: proc "contextless" (version: u32) -> u8 {…}

VERSION_GET_MINOR :: proc "contextless" (version: u32) -> u8 {…}

VERSION_GET_PATCH :: proc "contextless" (version: u32) -> u8 {…}

address_get_host :: proc "c" (address: ^Address, hostName: [^]u8, nameLength: uint) -> i32 ---

address_get_host_ip :: proc "c" (address: ^Address, hostName: [^]u8, nameLength: uint) -> i32 ---

address_set_host :: proc "c" (address: ^Address, hostName: cstring) -> i32 ---

address_set_host_ip :: proc "c" (address: ^Address, hostName: cstring) -> i32 ---

crc32 :: proc "c" (buffers: [^]Buffer, bufferCount: uint) -> u32 ---

deinitialize :: proc "c" () ---

host_bandwidth_limit :: proc "c" (host: ^Host, incomingBandwidth: u32, outgoingBandwidth: u32) ---

host_broadcast :: proc "c" (host: ^Host, channelID: u8, packet: ^Packet) ---

host_channel_limit :: proc "c" (host: ^Host, channelLimit: uint) ---

host_check_events :: proc "c" (host: ^Host, event: ^Event) -> i32 ---

host_compress :: proc "c" (host: ^Host, compressor: ^Compressor) ---

host_compress_with_range_coder :: proc "c" (host: ^Host) -> i32 ---

host_connect :: proc "c" (host: ^Host, address: ^Address, channelCount: uint, data: u32) -> ^Peer ---

host_create :: proc "c" (address: ^Address, peerCount: uint, channelLimit: uint, incomingBandwidth: u32, outgoingBandwidth: u32) -> ^Host ---

host_destroy :: proc "c" (host: ^Host) ---

host_flush :: proc "c" (host: ^Host) ---

host_service :: proc "c" (host: ^Host, event: ^Event, timeout: u32) -> i32 ---

initialize :: proc "c" () -> i32 ---

initialize_with_callbacks :: proc "c" (version: u32, inits: ^Callbacks) -> i32 ---

linked_version :: proc "c" () -> u32 ---

packet_create :: proc "c" (data: rawptr, dataLength: uint, flags: bit_set[PacketFlag; i32]) -> ^Packet ---

packet_destroy :: proc "c" (packet: ^Packet) ---

packet_resize :: proc "c" (packet: ^Packet, dataLength: uint) -> i32 ---

peer_disconnect :: proc "c" (peer: ^Peer, data: u32) ---

peer_disconnect_later :: proc "c" (peer: ^Peer, data: u32) ---

peer_disconnect_now :: proc "c" (peer: ^Peer, data: u32) ---

peer_ping :: proc "c" (peer: ^Peer) ---

peer_ping_interval :: proc "c" (peer: ^Peer, pingInterval: u32) ---

peer_receive :: proc "c" (peer: ^Peer, channelID: ^u8) -> ^Packet ---

peer_reset :: proc "c" (peer: ^Peer) ---

peer_send :: proc "c" (peer: ^Peer, channelID: u8, packet: ^Packet) -> i32 ---

peer_throttle_configure :: proc "c" (peer: ^Peer, interval: u32, acceleration: u32, deceleration: u32) ---

peer_timeout :: proc "c" (peer: ^Peer, timoutLimit: u32, timeoutMinimum: u32, timeoutMaximum: u32) ---

range_coder_compress :: proc "c" (
	ctx:           rawptr, 
	inBuffers:     [^]Buffer, 
	inBufferCount: uint, 
	inLimit:       uint, 
	outData:       [^]u8, 
	outLimit:      uint, 
) -> uint ---

range_coder_create :: proc "c" () -> rawptr ---

range_coder_decompress :: proc "c" (ctx: rawptr, inData: [^]u8, inLimit: uint, outData: [^]u8, outLimit: uint) -> uint ---

range_coder_destroy :: proc "c" (ctx: rawptr) ---

socket_accept :: proc "c" (socket: Socket, address: ^Address) -> Socket ---

socket_bind :: proc "c" (socket: Socket, address: ^Address) -> i32 ---

socket_connect :: proc "c" (socket: Socket, address: ^Address) -> i32 ---

socket_create :: proc "c" (SocketType) -> Socket ---

socket_destroy :: proc "c" (socket: Socket) ---

socket_get_address :: proc "c" (socket: Socket, address: ^Address) -> i32 ---

socket_get_option :: proc "c" (socket: Socket, option: SocketOption, value: ^i32) -> i32 ---

socket_listen :: proc "c" (socket: Socket, backlog: i32) -> i32 ---

socket_receive :: proc "c" (socket: Socket, address: ^Address, buffers: [^]Buffer, bufferCount: uint) -> i32 ---

socket_send :: proc "c" (socket: Socket, address: ^Address, buffers: [^]Buffer, bufferCount: uint) -> i32 ---

socket_set_option :: proc "c" (socket: Socket, option: SocketOption, value: i32) -> i32 ---

socket_shutdown :: proc "c" (socket: Socket, how: SocketShutdown) -> i32 ---

socket_wait :: proc "c" (socket: Socket, condition: ^u32, timeout: u32) -> i32 ---

socketset_select :: proc "c" (socket: Socket, readSet: ^SocketSet, writeSet: ^SocketSet, timeout: u32) -> i32 ---

time_get :: proc "c" () -> u32 ---

time_set :: proc "c" (newTimeBase: u32) ---