Source code for SDL3_net

from sdl3.SDL import * # type: ignore
from sdl3 import SDL_POINTER

import ctypes, typing

LP_NET_Address: typing.TypeAlias = SDL_POINTER[NET_Address]
LP_NET_DatagramSocket: typing.TypeAlias = SDL_POINTER[NET_DatagramSocket]
LP_NET_StreamSocket: typing.TypeAlias = SDL_POINTER[NET_StreamSocket]
LP_NET_Server: typing.TypeAlias = SDL_POINTER[NET_Server]
LP_LP_NET_Address: typing.TypeAlias = SDL_POINTER[SDL_POINTER[NET_Address]]
LP_c_void_p: typing.TypeAlias = SDL_POINTER[ctypes.c_void_p]
LP_c_int: typing.TypeAlias = SDL_POINTER[ctypes.c_int]
LP_LP_NET_Datagram: typing.TypeAlias = SDL_POINTER[SDL_POINTER[NET_Datagram]]
LP_NET_Datagram: typing.TypeAlias = SDL_POINTER[NET_Datagram]
LP_LP_NET_StreamSocket: typing.TypeAlias = SDL_POINTER[SDL_POINTER[NET_StreamSocket]]



def NET_Version() -> ctypes.c_int:
    """
    This function gets the version of the dynamically linked SDL_net library.
    """




def NET_Init() -> ctypes.c_bool:
    """
    Initialize the SDL_net library.
    """




def NET_Quit() -> None:
    """
    Deinitialize the SDL_net library.
    """




def NET_ResolveHostname(host: ctypes.c_char_p) -> LP_NET_Address:
    """
    Resolve a human-readable hostname.
    """




def NET_WaitUntilResolved(address: LP_NET_Address, timeout: ctypes.c_int32) -> NET_Status:
    """
    Block until an address is resolved.
    """




def NET_GetAddressStatus(address: LP_NET_Address) -> NET_Status:
    """
    Check if an address is resolved, without blocking.
    """




def NET_GetAddressString(address: LP_NET_Address) -> ctypes.c_char_p:
    """
    Get a human-readable string from a resolved address.
    """




def NET_RefAddress(address: LP_NET_Address) -> LP_NET_Address:
    """
    Add a reference to an NET_Address.
    """




def NET_UnrefAddress(address: LP_NET_Address) -> None:
    """
    Drop a reference to an NET_Address.
    """




def NET_SimulateAddressResolutionLoss(percent_loss: ctypes.c_int) -> None:
    """
    Enable simulated address resolution failures.
    """




def NET_CompareAddresses(a: LP_NET_Address, b: LP_NET_Address) -> ctypes.c_int:
    """
    Compare two NET_Address objects.
    """




def NET_GetLocalAddresses(num_addresses: LP_c_int) -> LP_LP_NET_Address:
    """
    Obtain a list of local addresses on the system.
    """




def NET_FreeLocalAddresses(addresses: LP_LP_NET_Address) -> None:
    """
    Free the results from NET_GetLocalAddresses.
    """




def NET_CreateClient(address: LP_NET_Address, port: ctypes.c_uint16) -> LP_NET_StreamSocket:
    """
    Begin connecting a socket as a client to a remote server.
    """




def NET_WaitUntilConnected(sock: LP_NET_StreamSocket, timeout: ctypes.c_int32) -> NET_Status:
    """
    Block until a stream socket has connected to a server.
    """




def NET_CreateServer(addr: LP_NET_Address, port: ctypes.c_uint16) -> LP_NET_Server:
    """
    Create a server, which listens for connections to accept.
    """




def NET_AcceptClient(server: LP_NET_Server, client_stream: LP_LP_NET_StreamSocket) -> ctypes.c_bool:
    """
    Create a stream socket for the next pending client connection.
    """




def NET_DestroyServer(server: LP_NET_Server) -> None:
    """
    Dispose of a previously-created server.
    """




def NET_GetStreamSocketAddress(sock: LP_NET_StreamSocket) -> LP_NET_Address:
    """
    Get the remote address of a stream socket.
    """




def NET_GetConnectionStatus(sock: LP_NET_StreamSocket) -> NET_Status:
    """
    Check if a stream socket is connected, without blocking.
    """




def NET_WriteToStreamSocket(sock: LP_NET_StreamSocket, buf: ctypes.c_void_p, buflen: ctypes.c_int) -> ctypes.c_bool:
    """
    Send bytes over a stream socket to a remote system.
    """




def NET_GetStreamSocketPendingWrites(sock: LP_NET_StreamSocket) -> ctypes.c_int:
    """
    Query bytes still pending transmission on a stream socket.
    """




def NET_WaitUntilStreamSocketDrained(sock: LP_NET_StreamSocket, timeout: ctypes.c_int32) -> ctypes.c_int:
    """
    Block until all of a stream socket's pending data is sent.
    """




def NET_ReadFromStreamSocket(sock: LP_NET_StreamSocket, buf: ctypes.c_void_p, buflen: ctypes.c_int) -> ctypes.c_int:
    """
    Receive bytes that a remote system sent to a stream socket.
    """




def NET_SimulateStreamPacketLoss(sock: LP_NET_StreamSocket, percent_loss: ctypes.c_int) -> None:
    """
    Enable simulated stream socket failures.
    """




def NET_DestroyStreamSocket(sock: LP_NET_StreamSocket) -> None:
    """
    Dispose of a previously-created stream socket.
    """




def NET_CreateDatagramSocket(addr: LP_NET_Address, port: ctypes.c_uint16) -> LP_NET_DatagramSocket:
    """
    Create and bind a new datagram socket.
    """




def NET_SendDatagram(sock: LP_NET_DatagramSocket, address: LP_NET_Address, port: ctypes.c_uint16, buf: ctypes.c_void_p, buflen: ctypes.c_int) -> ctypes.c_bool:
    """
    Send a new packet over a datagram socket to a remote system.
    """




def NET_ReceiveDatagram(sock: LP_NET_DatagramSocket, dgram: LP_LP_NET_Datagram) -> ctypes.c_bool:
    """
    Receive a new packet that a remote system sent to a datagram socket.
    """




def NET_DestroyDatagram(dgram: LP_NET_Datagram) -> None:
    """
    Dispose of a datagram packet previously received.
    """




def NET_SimulateDatagramPacketLoss(sock: LP_NET_DatagramSocket, percent_loss: ctypes.c_int) -> None:
    """
    Enable simulated datagram socket failures.
    """




def NET_DestroyDatagramSocket(sock: LP_NET_DatagramSocket) -> None:
    """
    Dispose of a previously-created datagram socket.
    """




def NET_WaitUntilInputAvailable(vsockets: LP_c_void_p, numsockets: ctypes.c_int, timeout: ctypes.c_int32) -> ctypes.c_int:
    """
    Block on multiple sockets until at least one has data available.
    """