From cbb77829eada65568cc42e4dc16479eb114f53b1 Mon Sep 17 00:00:00 2001 From: "alexey.lysiuk" Date: Sun, 21 Aug 2022 11:59:48 +0300 Subject: [PATCH] update sdl2_net to 2.2.0 --- deps/sdl2_net/include/SDL2/SDL_net.h | 931 ++++++++++++++---- .../SDL2_net-static-targets-release.cmake | 19 + .../SDL2_net/SDL2_net-static-targets.cmake | 99 ++ .../lib/cmake/SDL2_net/SDL2_netConfig.cmake | 14 + .../SDL2_net/SDL2_netConfigVersion.cmake | 48 + deps/sdl2_net/lib/libSDL2_net.a | Bin 40496 -> 37968 bytes deps/sdl2_net/lib/pkgconfig/SDL2_net.pc | 8 +- 7 files changed, 950 insertions(+), 169 deletions(-) create mode 100644 deps/sdl2_net/lib/cmake/SDL2_net/SDL2_net-static-targets-release.cmake create mode 100644 deps/sdl2_net/lib/cmake/SDL2_net/SDL2_net-static-targets.cmake create mode 100644 deps/sdl2_net/lib/cmake/SDL2_net/SDL2_netConfig.cmake create mode 100644 deps/sdl2_net/lib/cmake/SDL2_net/SDL2_netConfigVersion.cmake diff --git a/deps/sdl2_net/include/SDL2/SDL_net.h b/deps/sdl2_net/include/SDL2/SDL_net.h index bd5ec7f7..16c545c9 100644 --- a/deps/sdl2_net/include/SDL2/SDL_net.h +++ b/deps/sdl2_net/include/SDL2/SDL_net.h @@ -1,6 +1,6 @@ /* SDL_net: An example cross-platform network library for use with SDL - Copyright (C) 1997-2016 Sam Lantinga + Copyright (C) 1997-2022 Sam Lantinga Copyright (C) 2012 Simeon Maxein This software is provided 'as-is', without any express or implied @@ -20,10 +20,8 @@ 3. This notice may not be removed or altered from any source distribution. */ -/* $Id$ */ - -#ifndef _SDL_NET_H -#define _SDL_NET_H +#ifndef SDL_NET_H_ +#define SDL_NET_H_ #ifdef WITHOUT_SDL #include @@ -57,8 +55,8 @@ extern "C" { /* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL */ #define SDL_NET_MAJOR_VERSION 2 -#define SDL_NET_MINOR_VERSION 0 -#define SDL_NET_PATCHLEVEL 1 +#define SDL_NET_MINOR_VERSION 2 +#define SDL_NET_PATCHLEVEL 0 /* This macro can be used to fill a version structure with the compile-time * version of the SDL_net library. @@ -70,34 +68,85 @@ extern "C" { (X)->patch = SDL_NET_PATCHLEVEL; \ } -/* This function gets the version of the dynamically linked SDL_net library. - it should NOT be used to fill a version structure, instead you should - use the SDL_NET_VERSION() macro. +#if SDL_NET_MAJOR_VERSION < 3 && SDL_MAJOR_VERSION < 3 +/** + * This is the version number macro for the current SDL_net version. + * + * In versions higher than 2.9.0, the minor version overflows into + * the thousands digit: for example, 2.23.0 is encoded as 4300. + * This macro will not be available in SDL 3.x or SDL_net 3.x. + * + * Deprecated, use SDL_NET_VERSION_ATLEAST or SDL_NET_VERSION instead. + */ +#define SDL_NET_COMPILEDVERSION \ + SDL_VERSIONNUM(SDL_NET_MAJOR_VERSION, SDL_NET_MINOR_VERSION, SDL_NET_PATCHLEVEL) +#endif /* SDL_NET_MAJOR_VERSION < 3 && SDL_MAJOR_VERSION < 3 */ + +/** + * This macro will evaluate to true if compiled with SDL_net at least X.Y.Z. + */ +#define SDL_NET_VERSION_ATLEAST(X, Y, Z) \ + ((SDL_NET_MAJOR_VERSION >= X) && \ + (SDL_NET_MAJOR_VERSION > X || SDL_NET_MINOR_VERSION >= Y) && \ + (SDL_NET_MAJOR_VERSION > X || SDL_NET_MINOR_VERSION > Y || SDL_NET_PATCHLEVEL >= Z)) + +/** + * Query the version of SDL_net that the program is linked against. + * + * This function gets the version of the dynamically linked SDL_net library. + * This is separate from the SDL_NET_VERSION() macro, which tells you what + * version of the SDL_net headers you compiled against. + * + * This returns static internal data; do not free or modify it! + * + * \returns a pointer to the version information. + * + * \since This function is available since SDL_net 2.0.0. */ extern DECLSPEC const SDLNet_version * SDLCALL SDLNet_Linked_Version(void); -/* Initialize/Cleanup the network API - SDL must be initialized before calls to functions in this library, - because this library uses utility functions from the SDL library. -*/ -extern DECLSPEC int SDLCALL SDLNet_Init(void); +/** + * Initialize SDL_net. + * + * You must successfully call this function before it is safe to call any + * other function in this library, with one exception: a human-readable error + * message can be retrieved from SDLNet_GetError() if this function fails. + * + * SDL must be initialized before calls to functions in this library, because + * this library uses utility functions from the SDL library. + * + * It is safe to call this more than once; the library keeps a counter of init + * calls, and decrements it on each call to SDLNet_Quit, so you must pair your + * init and quit calls. + * + * \returns 0 on success, -1 on error. + * + * \since This function is available since SDL_net 2.0.0. + */ +extern DECLSPEC int SDLCALL SDLNet_Init(void); + +/** + * Deinitialize SDL_net. + * + * You must call this when done with the library, to free internal resources. + * It is safe to call this when the library isn't initialized, as it will just + * return immediately. + * + * Once you have as many quit calls as you have had successful calls to + * SDLNet_Init, the library will actually deinitialize. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC void SDLCALL SDLNet_Quit(void); -/***********************************************************************/ -/* IPv4 hostname resolution API */ -/***********************************************************************/ + +/* IPv4 hostname resolution API... */ typedef struct { Uint32 host; /* 32-bit IPv4 host address */ Uint16 port; /* 16-bit protocol port */ } IPaddress; -/* Resolve a host name and port to an IP address in network form. - If the function succeeds, it will return 0. - If the host couldn't be resolved, the host portion of the returned - address will be INADDR_NONE, and the function will return -1. - If 'host' is NULL, the resolved host will be set to INADDR_ANY. - */ #ifndef INADDR_ANY #define INADDR_ANY 0x00000000 #endif @@ -110,69 +159,179 @@ typedef struct { #ifndef INADDR_BROADCAST #define INADDR_BROADCAST 0xFFFFFFFF #endif + +/** + * Resolve a host name and port to an IP address in network form. + * + * If `host` is NULL, the resolved host will be set to `INADDR_ANY`. + * + * If the host couldn't be resolved, the host portion of the returned address + * will be INADDR_NONE, and the function will return -1. + * + * \param address to be filled in with the resolved address and port. + * \param host the hostname to lookup (like "libsdl.org") + * \param port the port intended to be connected to, to fill into address. + * \returns zero on success, -1 on error. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC int SDLCALL SDLNet_ResolveHost(IPaddress *address, const char *host, Uint16 port); -/* Resolve an ip address to a host name in canonical form. - If the ip couldn't be resolved, this function returns NULL, - otherwise a pointer to a static buffer containing the hostname - is returned. Note that this function is not thread-safe. -*/ +/** + * Resolve an IP address to a host name in canonical form. + * + * If the IP couldn't be resolved, this function returns NULL, otherwise a + * pointer to a static buffer containing the hostname is returned. + * + * **Warning**: This function is not thread-safe! + * + * \param ip the IP address to resolve into a hostname. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC const char * SDLCALL SDLNet_ResolveIP(const IPaddress *ip); -/* Get the addresses of network interfaces on this system. - This returns the number of addresses saved in 'addresses' +/** + * Get the addresses of network interfaces on this system. + * + * \param addresses where to store the returned information. + * \param maxcount the number of results that can be stored at `addresses` + * \returns the number of addresses saved in `addresses` + * + * \since This function is available since SDL_net 2.0.0. */ extern DECLSPEC int SDLCALL SDLNet_GetLocalAddresses(IPaddress *addresses, int maxcount); -/***********************************************************************/ -/* TCP network API */ -/***********************************************************************/ + +/* TCP network API */ typedef struct _TCPsocket *TCPsocket; -/* Open a TCP network socket - If ip.host is INADDR_NONE or INADDR_ANY, this creates a local server - socket on the given port, otherwise a TCP connection to the remote - host and port is attempted. The address passed in should already be - swapped to network byte order (addresses returned from - SDLNet_ResolveHost() are already in the correct form). - The newly created socket is returned, or NULL if there was an error. -*/ +/** + * Open a TCP network socket. + * + * If `ip->host` is INADDR_NONE or INADDR_ANY, this creates a local server + * socket on the given port, otherwise a TCP connection to the remote host and + * port is attempted. The address passed in should already be swapped to + * network byte order (addresses returned from SDLNet_ResolveHost() are + * already in the correct form). + * + * \param ip The address to open a connection to (or to host a server on). + * \returns the newly created socket, or NULL if there was an error. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_TCP_Close + */ extern DECLSPEC TCPsocket SDLCALL SDLNet_TCP_Open(IPaddress *ip); -/* Accept an incoming connection on the given server socket. - The newly created socket is returned, or NULL if there was an error. -*/ +/** + * Accept an incoming connection on the given server socket. + * + * `server` must be a socket returned by SDLNet_TCP_Open with an address of + * INADDR_NONE or INADDR_ANY (a "server socket"). Other sockets do not accept + * connections. + * + * \param server the server socket to accept a connection on. + * \returns the newly created socket, or NULL if there was an error. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC TCPsocket SDLCALL SDLNet_TCP_Accept(TCPsocket server); -/* Get the IP address of the remote system associated with the socket. - If the socket is a server socket, this function returns NULL. -*/ +/** + * Get the IP address of the remote system associated with the socket. + * + * If the socket is a server socket, this function returns NULL. + * + * This returns a pointer to internal memory; you should not modify or free + * it, and should assume it's only valid until the socket is given to + * SDLNet_TCP_Close. + * + * \param sock the socket to query. + * \returns the address information for the socket. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC IPaddress * SDLCALL SDLNet_TCP_GetPeerAddress(TCPsocket sock); -/* Send 'len' bytes of 'data' over the non-server socket 'sock' - This function returns the actual amount of data sent. If the return value - is less than the amount of data sent, then either the remote connection was - closed, or an unknown socket error occurred. -*/ -extern DECLSPEC int SDLCALL SDLNet_TCP_Send(TCPsocket sock, const void *data, - int len); +/** + * Send data over a non-server socket. + * + * `sock` must be a valid socket that was created by SDLNet_TCP_Open with a + * specific address, or SDLNet_TCP_Accept. + * + * This function sends `len` bytes, pointed to by `data` over the non-server + * socket `sock`. + * + * This function returns the actual amount of data sent. If the return value + * is less than the amount of data sent, then either the remote connection was + * closed, or an unknown socket error occurred. + * + * This function may block! + * + * \param sock the socket to send data to. + * \param data a pointer to the bytes to send. + * \param len the number of bytes, pointed to by `data`, to transmit. + * \returns number of bytes sent, which might be less if there was a problem + * or connection failure. If the socket is invalid, this function can + * return -1, but in valid uses it'll return >= 0. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_TCP_Recv + */ +extern DECLSPEC int SDLCALL SDLNet_TCP_Send(TCPsocket sock, const void *data, int len); -/* Receive up to 'maxlen' bytes of data over the non-server socket 'sock', - and store them in the buffer pointed to by 'data'. - This function returns the actual amount of data received. If the return - value is less than or equal to zero, then either the remote connection was - closed, or an unknown socket error occurred. -*/ +/** + * Receive data from a non-server socket. + * + * `sock` must be a valid socket that was created by SDLNet_TCP_Open with a + * specific address, or SDLNet_TCP_Accept. + * + * Receive up to `maxlen` bytes of data over the non-server socket `sock`, and + * store them in the buffer pointed to by `data`. + * + * This function returns the actual amount of data received. If the return + * value is less than or equal to zero, then either the remote connection was + * closed, or an unknown socket error occurred. + * + * Note that this will return the number of bytes available at the first + * moment the socket is able to see new data. If packets are coming in slowly + * from the network, this might be less data than you expect at a given time. + * + * This function may block! Use SDLNet_CheckSockets() to make sure there is + * data available before calling this function, if you want to avoid blocking. + * + * \param sock the socket to send data to. + * \param data a pointer to where to store received data. + * \param maxlen the maximum number of bytes that can be stored at `data`. + * \returns number of bytes received, which might be less than `maxlen`. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_TCP_Send + * \sa SDLNet_CheckSockets + */ extern DECLSPEC int SDLCALL SDLNet_TCP_Recv(TCPsocket sock, void *data, int maxlen); -/* Close a TCP network socket */ +/** + * Close a TCP network socket. + * + * All TCP sockets (server and non-server) are deinitialized through this + * function. Call this once you are done with a socket, and assume the handle + * is invalid once you have. + * + * Closing a socket will disconnect any communication and free its resources. + * + * \param sock socket to close. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC void SDLCALL SDLNet_TCP_Close(TCPsocket sock); -/***********************************************************************/ -/* UDP network API */ -/***********************************************************************/ +/* UDP network API */ /* The maximum channels on a a UDP socket */ #define SDLNET_MAX_UDPCHANNELS 32 @@ -189,105 +348,362 @@ typedef struct { IPaddress address; /* The source/dest address of an incoming/outgoing packet */ } UDPpacket; -/* Allocate/resize/free a single UDP packet 'size' bytes long. - The new packet is returned, or NULL if the function ran out of memory. +/** + * Allocate a single UDP packet. + * + * This allocates a packet with `size` bytes of space for payload. + * + * When done with this packet, you can free it with SDLNet_FreePacket. Packets + * can be reused multiple times; you don't have to allocate a new one for each + * piece of data you intend to send. + * + * You can allocate multiple packets at once with SDLNet_AllocPacketV. + * + * \param size the maximum number of bytes of payload this packet will + * contain. + * \returns the new packet, or NULL if the function ran out of memory. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_ResizePacket + * \sa SDLNet_FreePacket + * \sa SDLNet_AllocPacketV */ extern DECLSPEC UDPpacket * SDLCALL SDLNet_AllocPacket(int size); + + +/** + * Reallocate a UDP packet's payload space. + * + * This takes an existing packet and makes sure it can contain at least + * `newsize` bytes of space for payload. + * + * When done with this packet, you can free it with SDLNet_FreePacket. Packets + * can be used multiple times; you don't have to allocate a new one for each + * piece of data you intend to send. + * + * Please note that on memory allocation failure, this function will leave the + * existing buffer alone, and _will return the original buffer size_. It will + * not return an error value, it'll just leave the packet as it was! + * + * **Warning**: Existing contents of the packet's data are lost when resizing, + * whether you are growing or shrinking the payload space, since SDL_net does + * not realloc the existing data. + * + * \param newsize the new maximum number of bytes of payload this packet will + * contain. + * \returns the new maximum payload size, which will be unchanged from the + * previous if the system ran out of memory. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_AllocPacket + * \sa SDLNet_FreePacket + */ extern DECLSPEC int SDLCALL SDLNet_ResizePacket(UDPpacket *packet, int newsize); + + +/** + * Dispose of a UDP packet. + * + * This frees both the packet's payload and the packet itself. Once this call + * completes, the packet's pointer is invalid and should not be used anymore. + * + * \param packet the packet to free. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_AllocPacket + * \sa SDLNet_ResizePacket + */ extern DECLSPEC void SDLCALL SDLNet_FreePacket(UDPpacket *packet); -/* Allocate/Free a UDP packet vector (array of packets) of 'howmany' packets, - each 'size' bytes long. - A pointer to the first packet in the array is returned, or NULL if the - function ran out of memory. +/** + * Allocate a UDP packet vector (array of packets). + * + * This allocates `howmany` packets at once, each `size` bytes long. + * + * You must free the results of this function with SDLNet_FreePacketV, and + * must not free individual packets from this function with SDLNet_FreePacket. + * + * \param howmany the number of packets to allocate. + * \param size the maximum bytes of payload each packet should contain. + * \returns a pointer to the first packet in the array, or NULL if the + * function ran out of memory. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_FreePacketV */ extern DECLSPEC UDPpacket ** SDLCALL SDLNet_AllocPacketV(int howmany, int size); + + +/** + * Free a UDP packet vector (array of packets). + * + * This frees the results of a previous call to SDLNet_AllocPacketV(), freeing + * both the set of packets and the array that holds them. + * + * It is safe to free a NULL array through here; it's a harmless no-op. + * + * You must not use this to free packets allocated through any function other + * than SDLNet_AllocPacketV(). + * + * \param packetV the results of a call to SDLNet_AllocPacketV(). + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_AllocPacketV + */ extern DECLSPEC void SDLCALL SDLNet_FreePacketV(UDPpacket **packetV); - -/* Open a UDP network socket - If 'port' is non-zero, the UDP socket is bound to a local port. - The 'port' should be given in native byte order, but is used - internally in network (big endian) byte order, in addresses, etc. - This allows other systems to send to this socket via a known port. -*/ +/** + * Open a UDP network socket. + * + * If `port` is non-zero, the UDP socket is bound to a local port. + * + * The `port` should be given in native byte order, but is used internally in + * network (big endian) byte order, in addresses, etc. This allows other + * systems to send to this socket via a known port. + * + * Note that UDP sockets at the platform layer "bind" to a nework port number, + * but SDL_net's UDP sockets also "bind" to a "channel" on top of that, with + * SDLNet_UDP_Bind(). But the term is used for both. + * + * When you are done communicating over the returned socket, you can shut it + * down and free its resources with SDLNet_UDP_Close(). + * + * \param port the UDP port to bind this socket to. + * \returns a new UDP socket, ready to communicate. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_UDP_Close + * \sa SDLNet_UDP_Bind + */ extern DECLSPEC UDPsocket SDLCALL SDLNet_UDP_Open(Uint16 port); -/* Set the percentage of simulated packet loss for packets sent on the socket. -*/ +/** + * Set the percentage of simulated packet loss for packets sent on the socket. + * + * SDL_net can optionally, at random, drop packets that are being sent and + * received, to simulate bad networking conditions. As these sort of + * conditions can happen in the real world but likely won't between machines + * on the same LAN, you can use this function in testing to make sure your app + * is robust against network problems even on a fast, reliable network. + * + * You probably don't want to use this function outside of local testing. + * + * \param sock the socket to simulate packet loss on. + * \param percent a value from 0 to 100 of likelihood to drop a packet (higher + * the number means more likelihood of dropping. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC void SDLCALL SDLNet_UDP_SetPacketLoss(UDPsocket sock, int percent); -/* Bind the address 'address' to the requested channel on the UDP socket. - If the channel is -1, then the first unbound channel that has not yet - been bound to the maximum number of addresses will be bound with - the given address as it's primary address. - If the channel is already bound, this new address will be added to the - list of valid source addresses for packets arriving on the channel. - If the channel is not already bound, then the address becomes the primary - address, to which all outbound packets on the channel are sent. - This function returns the channel which was bound, or -1 on error. -*/ +/** + * Bind an address to the requested channel on the UDP socket. + * + * Note that UDP sockets at the platform layer "bind" to a nework port number, + * but SDL_net's UDP sockets also "bind" to a "channel" on top of that, with + * SDLNet_UDP_Bind(). But the term is used for both. + * + * If `channel` is -1, then the first unbound channel that has not yet been + * bound to the maximum number of addresses will be bound with the given + * address as it's primary address. + * + * If the channel is already bound, this new address will be added to the list + * of valid source addresses for packets arriving on the channel. If the + * channel is not already bound, then the address becomes the primary address, + * to which all outbound packets on the channel are sent. + * + * \param sock the UDP socket to bind an address to a channel on. + * \param channel the channel of the socket to bind to, or -1 to use the first + * available channel. + * \param address the address to bind to the socket's channel. + * \returns the channel which was bound, or -1 on error. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_UDP_Unbind + */ extern DECLSPEC int SDLCALL SDLNet_UDP_Bind(UDPsocket sock, int channel, const IPaddress *address); -/* Unbind all addresses from the given channel */ +/** + * Unbind all addresses from the given channel. + * + * Note that UDP sockets at the platform layer "bind" to a nework port number, + * but SDL_net's UDP sockets also "bind" to a "channel" on top of that, with + * SDLNet_UDP_Bind(). But the term is used for both. + * + * \param sock the UDP socket to unbind addresses from a channel on. + * \param channel the channel of the socket to unbind. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_UDP_Bind + */ extern DECLSPEC void SDLCALL SDLNet_UDP_Unbind(UDPsocket sock, int channel); -/* Get the primary IP address of the remote system associated with the - socket and channel. If the channel is -1, then the primary IP port - of the UDP socket is returned -- this is only meaningful for sockets - opened with a specific port. - If the channel is not bound and not -1, this function returns NULL. +/** + * Get the IP address of the remote system for a socket and channel. + * + * If `channel` is -1, then the primary IP port of the UDP socket is returned + * -- this is only meaningful for sockets opened with a specific port. + * + * If the channel is not bound and not -1, this function returns NULL. + * + * \param sock the UDP socket to unbind addresses from a channel on. + * \param channel the channel of the socket to unbind. + * \returns the address bound to the socket's channel, or + * + * \since This function is available since SDL_net 2.0.0. */ extern DECLSPEC IPaddress * SDLCALL SDLNet_UDP_GetPeerAddress(UDPsocket sock, int channel); -/* Send a vector of packets to the the channels specified within the packet. - If the channel specified in the packet is -1, the packet will be sent to - the address in the 'src' member of the packet. - Each packet will be updated with the status of the packet after it has - been sent, -1 if the packet send failed. - This function returns the number of packets sent. -*/ +/** + * Send a vector of packets to the the channels specified within the packet. + * + * If the channel specified in the packet is -1, the packet will be sent to + * the address in the `src` member of the packet. + * + * Each packet will be updated with the status of the packet after it has been + * sent, -1 if the packet send failed. + * + * This function takes an array of packets but does not need to be allocated + * through SDLNet_AllocPacketV; if you supply your own array of packets you + * allocated individually, that is okay. + * + * **Warning**: UDP is an _unreliable protocol_, which means we can report + * that your packet has been successfully sent from your machine, but then it + * never makes it to its destination when a router along the way quietly drops + * it. If this happens--and this is a common result on the internet!--you will + * not know the packet never made it. Also, packets may arrive in a different + * order than you sent them. Plan accordingly! + * + * **Warning**: The maximum size of the packet is limited by the MTU (Maximum + * Transfer Unit) of the transport medium. It can be as low as 250 bytes for + * some PPP links, and as high as 1500 bytes for ethernet. Different sizes can + * be sent, but the system might split it into multiple transmission fragments + * behind the scenes, that need to be reassembled on the other side (and the + * packet is lost if any fragment is lost in transit). So the less you can + * reasonably send in a single packet, the better, as it will be more reliable + * and lower latency. + * + * \param sock the UDP socket to send packets on. + * \param packets an array of packets to send to the network. + * \param npackets the number of packets in the `packets` array. + * \returns the number of packets successfully sent from this machine. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_UDP_RecV + */ extern DECLSPEC int SDLCALL SDLNet_UDP_SendV(UDPsocket sock, UDPpacket **packets, int npackets); -/* Send a single packet to the specified channel. - If the channel specified in the packet is -1, the packet will be sent to - the address in the 'src' member of the packet. - The packet will be updated with the status of the packet after it has - been sent. - This function returns 1 if the packet was sent, or 0 on error. - - NOTE: - The maximum size of the packet is limited by the MTU (Maximum Transfer Unit) - of the transport medium. It can be as low as 250 bytes for some PPP links, - and as high as 1500 bytes for ethernet. -*/ +/** + * Send a single UDP packet to the specified channel. + * + * If the channel specified is -1, the packet will be sent to the address in + * the `src` member of the packet. + * + * The packet will be updated with the status of the packet after it has been + * sent. + * + * **Warning**: UDP is an _unreliable protocol_, which means we can report + * that your packet has been successfully sent from your machine, but then it + * never makes it to its destination when a router along the way quietly drops + * it. If this happens--and this is a common result on the internet!--you will + * not know the packet never made it. Also, packets may arrive in a different + * order than you sent them. Plan accordingly! + * + * **Warning**: The maximum size of the packet is limited by the MTU (Maximum + * Transfer Unit) of the transport medium. It can be as low as 250 bytes for + * some PPP links, and as high as 1500 bytes for ethernet. Different sizes can + * be sent, but the system might split it into multiple transmission fragments + * behind the scenes, that need to be reassembled on the other side (and the + * packet is lost if any fragment is lost in transit). So the less you can + * reasonably send in a single packet, the better, as it will be more reliable + * and lower latency. + * + * \param sock the UDP socket to send packets on. + * \param packet a single packet to send to the network. + * \returns 1 if the packet was sent, or 0 on error. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC int SDLCALL SDLNet_UDP_Send(UDPsocket sock, int channel, UDPpacket *packet); -/* Receive a vector of pending packets from the UDP socket. - The returned packets contain the source address and the channel they arrived - on. If they did not arrive on a bound channel, the the channel will be set - to -1. - The channels are checked in highest to lowest order, so if an address is - bound to multiple channels, the highest channel with the source address - bound will be returned. - This function returns the number of packets read from the network, or -1 - on error. This function does not block, so can return 0 packets pending. -*/ +/** + * Receive a vector of pending packets from a UDP socket. + * + * The returned packets contain the source address and the channel they + * arrived on. If they did not arrive on a bound channel, the the channel will + * be set to -1. + * + * The channels are checked in highest to lowest order, so if an address is + * bound to multiple channels, the highest channel with the source address + * bound will be returned. + * + * This function takes an array of packets but does not need to be allocated + * through SDLNet_AllocPacketV; if you supply your own array of packets you + * allocated individually, that is okay, as long as the last element in the + * array is NULL, so SDL_net knows the array bounds. The arrays returned by + * SDLNet_AllocPacketV are properly NULL-terminated for these purposes. + * + * This function does not block, so it can return 0 packets pending, which is + * not an error condition. + * + * \param sock the UDP socket to receive packets on. + * \param packets an array of packets, NULL terminated. + * \returns the number of packets read from the network, or -1 on error. 0 + * means no packets were currently available. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_UDP_SendV + * \sa SDLNet_UDP_Recv + */ extern DECLSPEC int SDLCALL SDLNet_UDP_RecvV(UDPsocket sock, UDPpacket **packets); -/* Receive a single packet from the UDP socket. - The returned packet contains the source address and the channel it arrived - on. If it did not arrive on a bound channel, the the channel will be set - to -1. - The channels are checked in highest to lowest order, so if an address is - bound to multiple channels, the highest channel with the source address - bound will be returned. - This function returns the number of packets read from the network, or -1 - on error. This function does not block, so can return 0 packets pending. -*/ +/** + * Receive a single packet from a UDP socket. + * + * The returned packets contain the source address and the channel they + * arrived on. If they did not arrive on a bound channel, the the channel will + * be set to -1. + * + * The channels are checked in highest to lowest order, so if an address is + * bound to multiple channels, the highest channel with the source address + * bound will be returned. + * + * This function does not block, so it can return 0 packets pending, which is + * not an error condition. + * + * \param sock the UDP socket to receive packets on. + * \param packet a single packet to receive data into from the network. + * \returns 1 if a new packet is available, or -1 on error. 0 means no packets + * were currently available. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_UDP_Send + * \sa SDLNet_UDP_RecvV + */ extern DECLSPEC int SDLCALL SDLNet_UDP_Recv(UDPsocket sock, UDPpacket *packet); -/* Close a UDP network socket */ +/** + * Close a UDP socket. + * + * This disconnects the socket and frees any resources it retains. + * + * This socket may not be used again once given to this function. + * + * \param sock UDP socket to close. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC void SDLCALL SDLNet_UDP_Close(UDPsocket sock); @@ -302,74 +718,257 @@ typedef struct _SDLNet_GenericSocket { int ready; } *SDLNet_GenericSocket; -/* Allocate a socket set for use with SDLNet_CheckSockets() - This returns a socket set for up to 'maxsockets' sockets, or NULL if - the function ran out of memory. +/** + * Allocate a socket set for use with SDLNet_CheckSockets(). + * + * To query if new data is available on a socket, you use a "socket set" with + * SDLNet_CheckSockets(). A socket set is just a list of sockets behind the + * scenes; you allocate a set and then add/remove individual sockets to/from + * the set. + * + * When done with a socket set, you can free it with SDLNet_FreeSocketSet. + * + * \param maxsockets the maximum amount of sockets to include in this set. + * \returns a socket set for up to `maxsockets` sockets, or NULL if the + * function ran out of memory. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_FreeSocketSet */ extern DECLSPEC SDLNet_SocketSet SDLCALL SDLNet_AllocSocketSet(int maxsockets); -/* Add a socket to a set of sockets to be checked for available data */ +/** + * Add a socket to a socket set, to be checked for available data. + * + * Generally you don't want to call this generic function, but rather the + * specific, inline function that wraps it: SDLNet_TCP_AddSocket() or + * SDLNet_UDP_AddSocket(). + * + * This function will fail if you add a socket to the set when the set already + * has its maximum number of sockets added, but otherwise it will always + * succeed. + * + * If `sock` is NULL, nothing is added to the set; this lets you query the + * number of sockets currently contained in the set. + * + * \param set the socket set to add a new socket to. + * \param sock the socket to add to the set. + * \returns the total number of sockets contained in the set (including this + * new one), or -1 if the set is already full. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_TCP_AddSocket + * \sa SDLNet_UDP_AddSocket + * \sa SDLNet_DelSocket + * \sa SDLNet_TCP_DelSocket + * \sa SDLNet_UDP_DelSocket + * \sa SDLNet_CheckSockets + */ extern DECLSPEC int SDLCALL SDLNet_AddSocket(SDLNet_SocketSet set, SDLNet_GenericSocket sock); + +/** + * Add a TCP socket to a socket set, to be checked for available data. + * + * This is a small TCP-specific wrapper over SDLNet_AddSocket; please refer + * to that function's documentation. + * + * \param set the socket set to add a new socket to. + * \param sock the socket to add to the set. + * \returns the total number of sockets contained in the set (including this new one), + * or -1 if the set is already full. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_AddSocket + */ SDL_FORCE_INLINE int SDLNet_TCP_AddSocket(SDLNet_SocketSet set, TCPsocket sock) { return SDLNet_AddSocket(set, (SDLNet_GenericSocket)sock); } + +/** + * Add a UDP socket to a socket set, to be checked for available data. + * + * This is a small UDP-specific wrapper over SDLNet_AddSocket; please refer + * to that function's documentation. + * + * \param set the socket set to add a new socket to. + * \param sock the socket to add to the set. + * \returns the total number of sockets contained in the set (including this new one), + * or -1 if the set is already full. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_AddSocket + */ SDL_FORCE_INLINE int SDLNet_UDP_AddSocket(SDLNet_SocketSet set, UDPsocket sock) { return SDLNet_AddSocket(set, (SDLNet_GenericSocket)sock); } -/* Remove a socket from a set of sockets to be checked for available data */ +/** + * Remove a socket from a set of sockets to be checked for available data. + * + * Generally you don't want to call this generic function, but rather the + * specific, inline function that wraps it: SDLNet_TCP_DelSocket() or + * SDLNet_UDP_DelSocket(). + * + * If `sock` is NULL, nothing is removed from the set; this lets you query the + * number of sockets currently contained in the set. + * + * This will return -1 if the socket was not found in the set; in such a case, + * nothing is removed from the set. + * + * \param set the socket set to remove a socket from. + * \param sock the socket to remove from the set. + * \returns the total number of sockets contained in the set (after `sock`'s + * removal), or -1 if `sock` was not in the set. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_TCP_DelSocket + * \sa SDLNet_UDP_DelSocket + * \sa SDLNet_AddSocket + * \sa SDLNet_TCP_AddSocket + * \sa SDLNet_UDP_AddSocket + * \sa SDLNet_CheckSockets + */ extern DECLSPEC int SDLCALL SDLNet_DelSocket(SDLNet_SocketSet set, SDLNet_GenericSocket sock); + +/** + * Remove a TCP socket from a socket set. + * + * This is a small TCP-specific wrapper over SDLNet_DelSocket; please refer + * to that function's documentation. + * + * \param set the socket set to remove a socket from. + * \param sock the socket to remove from the set. + * \returns the total number of sockets contained in the set (after + * `sock`'s removal), or -1 if `sock` was not in the set. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_DelSocket + */ SDL_FORCE_INLINE int SDLNet_TCP_DelSocket(SDLNet_SocketSet set, TCPsocket sock) { return SDLNet_DelSocket(set, (SDLNet_GenericSocket)sock); } + +/** + * Remove a UDP socket from a socket set. + * + * This is a small UDP-specific wrapper over SDLNet_DelSocket; please refer + * to that function's documentation. + * + * \param set the socket set to remove a socket from. + * \param sock the socket to remove from the set. + * \returns the total number of sockets contained in the set (after + * `sock`'s removal), or -1 if `sock` was not in the set. + * + * \since This function is available since SDL_net 2.0.0. + * + * \sa SDLNet_DelSocket + */ SDL_FORCE_INLINE int SDLNet_UDP_DelSocket(SDLNet_SocketSet set, UDPsocket sock) { return SDLNet_DelSocket(set, (SDLNet_GenericSocket)sock); } -/* This function checks to see if data is available for reading on the - given set of sockets. If 'timeout' is 0, it performs a quick poll, - otherwise the function returns when either data is available for - reading, or the timeout in milliseconds has elapsed, which ever occurs - first. This function returns the number of sockets ready for reading, - or -1 if there was an error with the select() system call. -*/ +/** + * Check a socket set for data availability. + * + * This function checks to see if data is available for reading on the given + * set of sockets. If 'timeout' is 0, it performs a quick poll, otherwise the + * function returns when either data is available for reading, or the timeout + * in milliseconds has elapsed, whichever occurs first. + * + * \param set the socket set to check for ready sockets. + * \param timeout the time to wait in milliseconds for new data to arrive. A + * timeout of zero checks for new data and returns without + * blocking. + * \returns the number of sockets ready for reading, or -1 if there was an + * error with the select() system call. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC int SDLCALL SDLNet_CheckSockets(SDLNet_SocketSet set, Uint32 timeout); -/* After calling SDLNet_CheckSockets(), you can use this function on a - socket that was in the socket set, to find out if data is available - for reading. -*/ +/* !!! FIXME: wikiheaders.pl ignores macros, atm */ +/** + * See if a specific socket has data available after checking it in a set. + * + * After calling SDLNet_CheckSockets(), you can use this function on a + * socket that was in the socket set, to find out if data is available + * for reading. + * + * \param sock the socket to check. + * \returns non-zero if socket has new data available, zero otherwise. + * + * \since This function is available since SDL_net 2.0.0. + */ #define SDLNet_SocketReady(sock) _SDLNet_SocketReady((SDLNet_GenericSocket)(sock)) SDL_FORCE_INLINE int _SDLNet_SocketReady(SDLNet_GenericSocket sock) { return (sock != NULL) && (sock->ready); } -/* Free a set of sockets allocated by SDL_NetAllocSocketSet() */ +/** + * Free a set of sockets allocated by SDLNet_AllocSocketSet(). + * + * When done with a socket set, call this function to free its resources. + * + * This only frees the socket set, not the individual sockets in the set, + * which would still (at some future point) need to be closed with + * SDLNet_TCP_Close or SDLNet_UDP_Close. + * + * \param set the socket set to free. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC void SDLCALL SDLNet_FreeSocketSet(SDLNet_SocketSet set); -/***********************************************************************/ -/* Error reporting functions */ -/***********************************************************************/ +/* Error reporting functions */ + +/** + * Set an error message to be retrieved with SDLNet_GetError. + * + * Generally you don't need to call this (SDL_net will use it internally to + * report errors), but it could be useful if you need to inject an error + * message of your own in here. + * + * \param fmt a printf-style format string for the error message. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC void SDLCALL SDLNet_SetError(const char *fmt, ...); + +/** + * Get the latest error message from SDL_net. + * + * The error message, depending on how SDL_net was built, may or may not be + * thread-local data. Sometimes things will set an error message when no + * failure was reported; the error string is only meaningful right after a + * public API reports a failure, and should be ignored otherwise. + * + * \returns the last set error message in UTF-8 encoding. + * + * \since This function is available since SDL_net 2.0.0. + */ extern DECLSPEC const char * SDLCALL SDLNet_GetError(void); -/***********************************************************************/ -/* Inline functions to read/write network data */ -/***********************************************************************/ +/* Inline functions to read/write network data */ -/* Warning, some systems have data access alignment restrictions */ -#if defined(sparc) || defined(mips) || defined(__arm__) -#define SDL_DATA_ALIGNED 1 +/* Warning, most systems have data access alignment restrictions */ +#if defined(__i386__) || defined(__x86_64__) || defined(_M_X64) || defined(_M_IX86) || defined(_M_AMD64) +#define SDL_DATA_ALIGNED 0 #endif #ifndef SDL_DATA_ALIGNED -#define SDL_DATA_ALIGNED 0 +#define SDL_DATA_ALIGNED 1 #endif /* Write a 16/32-bit value to network packet buffer */ @@ -420,9 +1019,9 @@ SDL_FORCE_INLINE void _SDLNet_Write32(Uint32 value, void *areap) area[3] = value & 0xFF; } -SDL_FORCE_INLINE Uint16 _SDLNet_Read16(void *areap) +SDL_FORCE_INLINE Uint16 _SDLNet_Read16(const void *areap) { - Uint8 *area = (Uint8*)areap; + const Uint8 *area = (const Uint8*)areap; return ((Uint16)area[0]) << 8 | ((Uint16)area[1]); } @@ -440,4 +1039,4 @@ SDL_FORCE_INLINE Uint32 _SDLNet_Read32(const void *areap) #endif #include "close_code.h" -#endif /* _SDL_NET_H */ +#endif /* SDL_NET_H_ */ diff --git a/deps/sdl2_net/lib/cmake/SDL2_net/SDL2_net-static-targets-release.cmake b/deps/sdl2_net/lib/cmake/SDL2_net/SDL2_net-static-targets-release.cmake new file mode 100644 index 00000000..78934263 --- /dev/null +++ b/deps/sdl2_net/lib/cmake/SDL2_net/SDL2_net-static-targets-release.cmake @@ -0,0 +1,19 @@ +#---------------------------------------------------------------- +# Generated CMake target import file for configuration "Release". +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Import target "SDL2_net::SDL2_net-static" for configuration "Release" +set_property(TARGET SDL2_net::SDL2_net-static APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) +set_target_properties(SDL2_net::SDL2_net-static PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES_RELEASE "C" + IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/libSDL2_net.a" + ) + +list(APPEND _IMPORT_CHECK_TARGETS SDL2_net::SDL2_net-static ) +list(APPEND _IMPORT_CHECK_FILES_FOR_SDL2_net::SDL2_net-static "${_IMPORT_PREFIX}/lib/libSDL2_net.a" ) + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) diff --git a/deps/sdl2_net/lib/cmake/SDL2_net/SDL2_net-static-targets.cmake b/deps/sdl2_net/lib/cmake/SDL2_net/SDL2_net-static-targets.cmake new file mode 100644 index 00000000..8c46dfb5 --- /dev/null +++ b/deps/sdl2_net/lib/cmake/SDL2_net/SDL2_net-static-targets.cmake @@ -0,0 +1,99 @@ +# Generated by CMake + +if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.5) + message(FATAL_ERROR "CMake >= 2.6.0 required") +endif() +cmake_policy(PUSH) +cmake_policy(VERSION 2.6...3.19) +#---------------------------------------------------------------- +# Generated CMake target import file. +#---------------------------------------------------------------- + +# Commands may need to know the format version. +set(CMAKE_IMPORT_FILE_VERSION 1) + +# Protect against multiple inclusion, which would fail when already imported targets are added once more. +set(_targetsDefined) +set(_targetsNotDefined) +set(_expectedTargets) +foreach(_expectedTarget SDL2_net::SDL2_net-static) + list(APPEND _expectedTargets ${_expectedTarget}) + if(NOT TARGET ${_expectedTarget}) + list(APPEND _targetsNotDefined ${_expectedTarget}) + endif() + if(TARGET ${_expectedTarget}) + list(APPEND _targetsDefined ${_expectedTarget}) + endif() +endforeach() +if("${_targetsDefined}" STREQUAL "${_expectedTargets}") + unset(_targetsDefined) + unset(_targetsNotDefined) + unset(_expectedTargets) + set(CMAKE_IMPORT_FILE_VERSION) + cmake_policy(POP) + return() +endif() +if(NOT "${_targetsDefined}" STREQUAL "") + message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_targetsDefined}\nTargets not yet defined: ${_targetsNotDefined}\n") +endif() +unset(_targetsDefined) +unset(_targetsNotDefined) +unset(_expectedTargets) + + +# Compute the installation prefix relative to this file. +get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) +if(_IMPORT_PREFIX STREQUAL "/") + set(_IMPORT_PREFIX "") +endif() + +# Create imported target SDL2_net::SDL2_net-static +add_library(SDL2_net::SDL2_net-static STATIC IMPORTED) + +set_target_properties(SDL2_net::SDL2_net-static PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/SDL2" + INTERFACE_LINK_LIBRARIES "\$" +) + +if(CMAKE_VERSION VERSION_LESS 2.8.12) + message(FATAL_ERROR "This file relies on consumers using CMake 2.8.12 or greater.") +endif() + +# Load information for each installed configuration. +get_filename_component(_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) +file(GLOB CONFIG_FILES "${_DIR}/SDL2_net-static-targets-*.cmake") +foreach(f ${CONFIG_FILES}) + include(${f}) +endforeach() + +# Cleanup temporary variables. +set(_IMPORT_PREFIX) + +# Loop over all imported files and verify that they actually exist +foreach(target ${_IMPORT_CHECK_TARGETS} ) + foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} ) + if(NOT EXISTS "${file}" ) + message(FATAL_ERROR "The imported target \"${target}\" references the file + \"${file}\" +but this file does not exist. Possible reasons include: +* The file was deleted, renamed, or moved to another location. +* An install or uninstall procedure did not complete successfully. +* The installation package was faulty and contained + \"${CMAKE_CURRENT_LIST_FILE}\" +but not all the files it references. +") + endif() + endforeach() + unset(_IMPORT_CHECK_FILES_FOR_${target}) +endforeach() +unset(_IMPORT_CHECK_TARGETS) + +# This file does not depend on other imported targets which have +# been exported from the same project but in a separate export set. + +# Commands beyond this point should not need to know the version. +set(CMAKE_IMPORT_FILE_VERSION) +cmake_policy(POP) diff --git a/deps/sdl2_net/lib/cmake/SDL2_net/SDL2_netConfig.cmake b/deps/sdl2_net/lib/cmake/SDL2_net/SDL2_netConfig.cmake new file mode 100644 index 00000000..99e51fc1 --- /dev/null +++ b/deps/sdl2_net/lib/cmake/SDL2_net/SDL2_netConfig.cmake @@ -0,0 +1,14 @@ +set(SDL2_net_FOUND ON) + +set(SDL2NET_SDL2_REQUIRED_VERSION 2.0.4) + +include(CMakeFindDependencyMacro) + +#FIXME: can't add SDL2NET_SDL2_REQUIRED_VERSION since not all SDL2 installs ship SDL2ConfigVersion.cmake +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/SDL2_net-shared-targets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/SDL2_net-shared-targets.cmake") +endif() + +if(EXISTS "${CMAKE_CURRENT_LIST_DIR}/SDL2_net-static-targets.cmake") + include("${CMAKE_CURRENT_LIST_DIR}/SDL2_net-static-targets.cmake") +endif() diff --git a/deps/sdl2_net/lib/cmake/SDL2_net/SDL2_netConfigVersion.cmake b/deps/sdl2_net/lib/cmake/SDL2_net/SDL2_netConfigVersion.cmake new file mode 100644 index 00000000..55b85967 --- /dev/null +++ b/deps/sdl2_net/lib/cmake/SDL2_net/SDL2_netConfigVersion.cmake @@ -0,0 +1,48 @@ +# This is a basic version file for the Config-mode of find_package(). +# It is used by write_basic_package_version_file() as input file for configure_file() +# to create a version-file which can be installed along a config.cmake file. +# +# The created file sets PACKAGE_VERSION_EXACT if the current version string and +# the requested version string are exactly the same and it sets +# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. +# The variable CVF_VERSION must be set before calling configure_file(). + +set(PACKAGE_VERSION "2.2.0") + +if (PACKAGE_FIND_VERSION_RANGE) + # Package version must be in the requested version range + if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN) + OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX) + OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX))) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + endif() +else() + if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) + set(PACKAGE_VERSION_COMPATIBLE FALSE) + else() + set(PACKAGE_VERSION_COMPATIBLE TRUE) + if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION) + set(PACKAGE_VERSION_EXACT TRUE) + endif() + endif() +endif() + + +# if the installed project requested no architecture check, don't perform the check +if("FALSE") + return() +endif() + +# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it: +if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "8" STREQUAL "") + return() +endif() + +# check that the installed version has the same 32/64bit-ness as the one which is currently searching: +if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "8") + math(EXPR installedBits "8 * 8") + set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)") + set(PACKAGE_VERSION_UNSUITABLE TRUE) +endif() diff --git a/deps/sdl2_net/lib/libSDL2_net.a b/deps/sdl2_net/lib/libSDL2_net.a index 880d4dd37530b9593df5fc88d33a6ce97b0aa8de..b1bc46264e4b0a4c7f71b76b5e0a6d84de092c21 100644 GIT binary patch literal 37968 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 literal 40496 zcmeHw4SbZ*MG_Lr842m^DM+u_BYU*H^cA!a(2-aF-l7^(o5)wXwg=)H^ zLwcExX`#ifx3x8{cAKF0F88jsiK`NXHPK~lMBB~odbfkn-Wi~6+Ois2G57yJ=Q%U) zyfXvhw)=5^dvx-DpL3q`oUiA6J?FeHufG4>ih5`gIM>A1%DB?3#IVy(w3A{oIA~uA94H!3|#Tb#u!Qpo7ci&b@yAe6P2x ztn7NtT~}CJd-d&~u38-UnD_Qumn{!0W(s~J_V6Uj8VA*e=g})H>p{WqiT{g&ZwP)v z!gmP%RQxHgC*QKB34TP-FIXkGQgE$cNbp6G_f?^v5PVkfWx?M8OQu`a+2AL71#c9r z6s!?^1ITh65`0H+8uCs5O9ihL3<%yK*ev*<;6F(|jtH{#YHwd$`N_tP+K)GO1lFx< zUuXBItY4qSv%R6dbl)XuZ(N^bU((jnkt8Zx+Ez8Lti7Xg-TIdHwxsuM8*Dtw z8tYes%~stCxuT7x^+!ss+{Cq*4S`w8prL8Z7Y)=i&|UT z8>;IYRyC&5wE5kUWc=8=#zqHU$}7c&s%iOxlX1o3>e^dcY^l;Cy;StcQ7Q(dm5Lr| zr7|9=Y|tmIoW{e+(xJ;#*}gudLF8T0_E~#|QPa1#XI7H-Lt7`SsiL{DVU_ky30&OR z>WIy%OGQR6uq=#AW%E+Qk~cXn!86;qG=JfI8OG`g(RJDyJFaf0oFD%7=kH@cba6mL zH?=UFSk>rvmKQ&`3-B9dKn}OuqXX734xE3AM#xkH?PN__wY43M8#{ym)YdK!+_^kO zo2RQ85svbhmz`%>*5&lbw?YKtYHL4>Hb}YJ+Qo~OFG|rSAH@_R&i1IvYW#_{wGHb# z*0r>KPCT9YGx=gY(S4^tqxmbvHzeh?uU=E%&{4ag?eox$+S?iL9+{Y_4ruSHHSZ2RidN?$-W6iPemDFnMJN$Y#x<|IP*!@v)##c`zD= zb}NYX^b#?t97EpNoYnZzQ67KHALkrtdOUq_w;~w%>C2NR;3mDSb>rp9tO8fCTah(; zny&WD+^ht8X8JAi$4N!4nmwMGiVlX47DYPWiw53{1jcn>)p*1m4DT&UkB%B={NMve zdyvNFK~L!mMM&9G`mCkke~i6P>bo%o-yTu$@SuY3oeH{o0F{yMM-+5z1q37ATNFGT zQt<3X1uv`tcsAD~ubvVW%~RS{&2&mcR(GAEB!P$5C`wYT33*B+AB|f*C6cq%J)RQD z>xP}463Kn%U@+Rn3HlqjIJ0Bc9&Da zi|nqIk=?32g56ay_?M$egWcCLIMUS$!8VA>b@5H3efCoE4_86@mtnYg;KbUILzV7PPK@@%H+2BRCs6^9B; zz{e^Z)L9Adc12WuXkD`DTT(u?G*O8^QKhfp!HI}|fcUQYN>=3Ml=vXh?q^Pd3j^ah z(>KX!eTRO}4MsZS!N`VKQ)I)T)}8n zJiKti(-lk$iv&g>Vg$7?Tloj#U>pfXmrM^v%hY4TZNzwIW2CE}qN56;!F)Wi zHi8Wgvmzo>(eNs$DY|A-dRSAWV_qco9mllNtEZ z%v1)D&7#O~G8?@JPjI^E_mU^lr9AM+V(}T}ri`F#HwFi$k~o49!d7|FZk6S3HcM1B zPS81WM7o|tpl-jYdd4V1rAUq%y4+8Jo+0FPO{8aPzqE+vCULgkF ztJ!n8eTl>DTbHW87DtpcH&-Y%dg-NHTDV`RSsF9quaWRQIwT|9&t3y3%e#zlwPr+k zjpEA8-%g3&nj_pRikG>)*Ty1O(bO~DTagOWyBNRtI~-{zCZv5a!=7FArAZZMNwSJ> zG5E%WPue*vAM1Ej_-5f*xh(RwBOoSx((YO1JrBMu<2rxR{#p4Bfp3lQi5_I-n~HMx z3ZLjhR=)Y*8xua!i>!QigYS{!I)8P@gK}BQyBT~V!Y6u?Ro>I!8~vS@C;F0=?@jQ< zgirJ)E8lzIiwmFVPgcI!(A_cN6Fth{TMvc!Bg^tF0iJJJ<#T~pxBGsRukk0q8K55m zVodhc0m=7KAoR?4HV}I{-;?N1=K}8qVy^Pt1-uA&77%Isjv_C_9|7_IjD3QfxAFh# zCxrf{U^kHb+_w?$(*CPy+ri-P^8uM}50LqB1J41?JqG@t@pJq^(&xPmL|^g!Nc_JJ zB>yrrDwYF2E+&cWGjKDcU(JyIFhlyw>K+~cjF4cRpkL4{XbHw343B3F3ib$w1nUI- zf?h#@ipN?0Y?R6DJ3j_tq^qUFY%#QKn*I{}9{BmeLw6s3q|G>9A+#CSt~Rvr(-ud5 z<7P>?8E5}S!p*ovTO9e#IK}!RZN}XvB;1U%TP1vrB+w+ZU+8Cr-;As53zTQZ(LwNm zOuEM%G{fxS)gbIN#}7Mwl_PwEgRXVZuQ}p3Il}*sBm5CZ_~j1zqYnB;M|@?{sa@T; zx?#+u1v#d%6w`w zrhcxmqZu~L&u*%R#nh^8fxW0!KZ@No-BfyYtG1lp>#&@rb3smfLq{uYBem;0U_`8K zXkJy@RNn%h^(~)ks|TuLes)8XuFiYcx2=IqrUPVywrVEx)kaH5nxM~Zs9%?|R3d?O z9gUz>*4sMT>z%D)v&T9utqvQn)9@-bU#k!<=lMVmJKVJkuS=c}XgeINuG$m_jmmD1 zHNw@UPqlwZ~180hRI?cNFHLd6bZ0k2|^j%*avO zNJPI>@<~y2l3h*U@2Tu(W0J2yiBVLbZBxxtF^FrwG?AyWpY4?On_KF3MC6J14{Ses z1nJX`HXW9R#gN6}zuE{9Wd8WW{CC<;_S1FFt#0S&F13uLK{I)IPFp7hX_h@(l%v@m#Rs{C#_kt*U zC)kahdt~UjB2a46`*I+Gt!33{v@EjWC?A>@M;GNcEsg{ZGok3FeAtN)hwp3{H$Or@sr%C4h4>qB|Xidz&;RsRXzM7Rp>e88QHz4pM_9KMpv+|Mge@!(LjvgUKm{JY}@J0jFz;=!oFi{Y#-75jY`K5hIf}d!@F|WJK_hIh~^rG8*1E9TqUGQ>oPJuwIlp3rZ;xztyRY z>PkCVmv|N(z%<=oAr`cQipx}V1*73#4tB5DC%MkvKRl^CBvvCjZBSYT5Mbm-0>h$D z(ZFyx_B&+&i@YSMr?r>v8ECIXs=bC5DOG3eA+|KK_hA}wFxiNMsB*up5q0~C{Xy04 zX08lTpW{p}fl-WAG8UZd=98G-V8bvrdKr)W%Dxxb5Ra@l1b);V41kEIMba3C2KzON zAcY`mFtTD)O*dtOG<$9d{Lu52%Mg(wcDl9%Uh{mF z#Z&DY9?$n|-@T>kwJ!%=1LKziKkRjRy6#05qfCR=7+rHxUT=DN)62=VqobT3MM7oT z>TNGt97Q{%G7t&Gk{Q|j4@j5g*IFE{ifMZgasZ3xts6SL?M+@RHQU#1vMSm)w61Ks zqQl#;uCczO(JO1oly`euTVq3qx1-&=4l%&NbzLeN&n+2 zMEtJ>Vxse%BmPsw{|F*c{wqK%34JdBF;Dn-H-+ifN_ZuZ>0bh*o#UTDFdr`gnf_k` z5p>>DK-yg%7Jr^F(Ep1-mx3{}M<(E_!HB=>;;JOD~4EOZe?T z*h_rn;(xvPdx0z;*P|>?4-iS55fZEu^b2|g0gCS`Aouq%WPvXg9it@Pk*)D>(-#Y03?V!nP=l43~bDp<{f5JgqwHOxfP3~b+S9R7mc5uvZ=Pe*T^rkT_N?j15 zbpqVjY>U02LC+0o{4gS9yDJ34L8fit6b1)9eWXd(7jv2#+Ok^#WRou@29~iRd6@~9 z9~!go`1RErHKCYWVT_u*&{Mm*p4XP3{~uz%e#5m39s70M_xU~U*Q+rY(0Qd_8Jhit zKj|LW4}Y-xGs9fI!BHOLuE8K0q{nIQ*NvRNU|hI31}D3d>?XZVwO?Pur52ni=T;1& z7-FrR7_4|W2$v@ERQq+tryG=5J2BW&o^crGn$0tj{aZzG+;>@kj>iqlBUq!(hb+WP z?$;@rKNg*NL{*-)GwVehIbu`F9=@vtf8rE`Me-O6$cwS-_snR zgONpUE(U|)jc#yKDP()A7PsNfqwt+caoy#2p!H?ti5=dUmN66jX7mWPSBxS1cYe-5eCmJ|egNFtt-pS)J_WqgA#vxFQ(}JkLQOJt{W&&#RoOiyKk{RkoNRM1e*? zdr%N}Q*;H5DuYdt+olc$^xYni+M3m`OiIsr5yNJZL5*Gjd6B@Qx{lt71a=Muo&giG zVxsPR4(mz8a^r8Z;$W~DF$SAK?K>10(Gg+fb6$f$rEN{_^|zuct+DO(LyRW<)!yGZ z{891#HTIgKvcU+hZ|E^V`lT3o!kx!(ABJTUB~Sbjp5eRF^A$aq9a{+x>30|naF_1^ zZo82E9QXP3{irco6(cKRdI;?jBg1p3KgZ_#|Elzk!m9Wwm5ZbJiwqp~db$_k31x?U zL+J&_gO*n~R|H+dMgzkO@;&NuVy^Kau@DiWokvysP>H&9X|;)? z+E3JcF%(d>#z8HP2I4ZL4%Mqw*A^6`1R^mDM?s2wsupy$l!NONPU%iUnuq|~^RdUVBb_$60l#c(15`KDaS2&|Ltt&pP3Pw-wrIU~_E7c1L5C2OCi z=teK5hr`-x3+Ol751>-5ys z*GS-Lefu>UcpAD`mmIfKi#7Xw*JS^RtcauUpoZ1GPuSqQH^kMUfL5qn>%AQMEy}Hj zFRjksgEql7&N7w_N=u>>-1IsOs^9Z$=9(C7Lz}ruk)88l7*fCY<-qr7LRIUk+aV*V zcl)S!XwqKHfNIbci#tykv~u-AsfwvoP^il8Dt+t%yKZmfmg$7>7p6nGexXzDjRxTv z=#2!6q8Po^)5Us@4)iufs=f3Y;(hN4bVsg}!<|_0J@lw#JUM_2XHmGK@L_bRz2VNi zh{4H&!lJ>80aUZSH&%}1d%CWa0M8GCOihJ&e$X-EUid3d7xz7AcGO&N#FZdxN-v-< zdlQcteNp`aUc-sIQeOL%_UubwL8cNP^0UsY1g~i$Ejj3jR_%*a<Jz_FIAqq4^N)5 z`C&$mXiy6T8SQ09qF3{gp_e~=f% zk)r*506)|vW?K&7E<0wJQC!=^B1s>a;7mh_#H0!Tm*qL58}2jJ1tqr~m7Jc{{bW{k zTwxHyxtBL8@H(0`Z{GZ?=i*qXdq26NveFpyKMC7?d;4l{Q~Nq^TjS?V zG`z*Or0w4N)|QpthUR*h`CCyb#%U_M@Vis;WENw%G~I<3e(`xNM|cre z|8SqxkP$y5;RPBq!qt?BxSZeNGQwl|I-p)dMtC&`9Jmr4k`W%lgiW_ZLq_n zml1C6PkkpxxVcBLEl2sPx&DHiuOUPJRte8lKRq0q;a<>?5x-9CKg~J9i?x5w^N4C( zqox!6$*|+kM*PM2@xD8q=uuWa>Lc%*(}_N1|G`M99>{)=U1Y?8GJ86zt6`x#^XS27RtW~M3?Zj3wB|Hh^gCmBar+TivJG^ENd3%F}KE2AT~a}pJC4g z6Qu7aKosM=zXnpytw14ty8(D9un2fD&<&(Km-z3>)9LgB>E8>)a^2S@{$CXT zHX!c{&l3L&#s7Uox(xojCyf2Px+hHJ`55#6eIWinuZMp?M}f>=Gm!cJBoJBg{RWke zqWTU48SfyFQMic#`gpIC@r!_rcMO$DdLNMVpx_sQl(zv$Ic-47`C}mYk+wp5Lev>C z{2>ks_6UXq>jeFRUO`JR26=cqV^FY1FeF$f=oj<~0#v-45Se#)&3uGMMVs;cbD()X zmUPHBX}|a_m+&58plO-mX8z@PK{_Vk97{->`SCWP&3yZ?@SFMVeW620mkxbF#W(ZI zKbrXH7j!Qe`9hy3`8D(5ec(~~K_k)eUN>no-~J8!KqeixhIV?VgT5Dm_VCvnG#A?T z@Hvj~kc0jU2ffrmw>an{4*AzO=t~{^EGzy`x+}CECh2$ZWDm!flt$m+pf7O9b#p(|`RKd_*E_x|pe33k(rn)s;23Oq@q^=G)0Q;FRo=-zy_g^A zyfO|Mn$s$OGMs$i^U*$uKzV!|#$?H{4Md1w+^N0?VC2k|2(L&!O?=6&Ay0XqIVSlU zG%-*(OtsbmtT#k-n#fa~kM>|vrE^Q&4vIYOtIj!_%`4o9ScF}z?LY`|&h?idaM z_4~@O3*n^n7TPAwNhzm($6?^5A}tv8yJ1Q_8Z;+*$@9MbSoS8cuuzF6g^R%=0e>B! z>}uxw1bAPY_Bf=!!JK(k31d`c=*A$dL|CoyXzdxaYRcTsMRuZ8Gsj`67{lw>h_YfV zIxq5Wc*qs`<6y&&&2goEKUCdBq^;U%545NMGDHpq4&g71Pq-6VHFl%Rqu#_<6{L#~ z|NLQu#e)lnGfzMdDa+HL#Pi5vN`@)M1hmmnjL+y|;BD>j?um#y6{q`J31PKIs}A8U z`(OhOU||Mit3{WgEjAoNDSwSPk}A&8v=x>4brjt8fe3w`^}tas59CO}oFU?H069sx zB2{DRjQyd2&c(PiJ`&D{9XkNymII7wlc~I8fvBdu}`Lf%{?u2KW zjf|qw6R$%8Mtw3;d3ZSmG;}GroKt^fcha8rtn%Ic3)s`1WkL}Rj(q(YLTF-xF&Ia% zaVXil??eV+TZ0u0eu1*V#gUiZeWztVgK%hu<02jx{5@=MI`_1_jjG-k5gQ!u#BM$h za@EWEUul&pN-x)K;+s~fyr8bcDtYR>CR+s$snNqxknbWv@ruLH$A-1PGR^SfMV;D$GjuvlGBSL!R&3Y*^Vvn4dn|5rP@9@oIn@MvpWCMm!`06 z^0ut^Hf?BawX~0yw^^IoH{cp=OPje7i(6I>N81Hl#!NS;ye;bs8Z*NE;`5ta;W8`y zO!H;LpDXhUyC7Uf_!Ov>w&&qcQd~xBEddT2=4E0oiedN~#f5OQb^f!Q*`_%nX zm=t{b(H@v1ea{2kz+I?u%!@vDXLy}Aj!2|`1tk4AkaAf^m|}grXGH7)BFY&d!8$>| zpjQx}_`s|7kEXq^2F*RkAdv13{74(OT4+BqLB~$OaHDU2p^big1GFu=^|XV2&_UDA zW9J`o(9|n?_!|xy3#QtY_3QBIq}ryHwJorU6~^Sg zK&^^1y(_YPjtlWl`|4wA8^9;If0(w`KGpXH7haqFJ6<33`-0PN(cc$zU#`C|NaXhg z>CYQFM1Eh8_zg4!!})zd;!njNP4ch)z98j&RpdM&_^cooDLv>-&PWX1|@(D&yhYlIJp(7;}LrRpu~vIs;nf zu$ewcq63`d`+_%QAD8COy?%lD?kRGa_I*Lji|C>H54)Ee{m$~@2Y1T-KR29kC5!{t zBb!VDf0Re}LGMS8PS*UCN0Gyrd@rL{#{U20-xoCbpk3WK$)X}vflUDLRQ3duFAP1} zVew#hcG>hl)qU%jlygur;)XoRj$v`3>>axJ$t33Ci8gZ0j!Jjwif6j?=XWeV0_67? zc|OF@YW(P!RsJZK>wNCxPuC&-R@f@GEwMt&3S8F00^($AVJWe|S{Tc7?--7`&x%y62SlfE`%9S6P`I9N4!4#koNIE57&+#oZ>%j^2D@Vq0s*LnbvX2v-@K^wJmX` z|2X3@?8JSy^iAy1Y1s3cEuThCfy+MtImcmRzOKg=T2^9(_8&l+lovyqame3dSkoExUE0$NVBdv_KI&r48#Iml#TC+HwlCzd_B9aGpmORXyZ2c-^ zSa#-I_USsG5D#nzz>Qy zz%Z7n&&W-_80q%-WE)K za2fi})}l$Mk4ZQGc;Za|>l0zu>$>es8kda6u0Y*>T(>!12pm|d+P-kdfxN;UZ%bOS zo00a-sk*F3yWtRi;FHWB+NZ#Ja9QG7YoKtNwe3iQYuhJWC?ohEnBBeq0ayR84@0km z@MFGVkXW1e!DAQpS=J5Yp&w=4NLh#*KOb##zW;dQ+R(sZ&`Vqe(V4D-BX3W(meao= z;9q!ifwlGk+B05(dil720O6|&Nh937$l4Y^7c$NT?_~6aEBwa~SA+(Z{;Knhf|fb` z;=jrGyU!|&VocaXS#Ib*`tE>AAF}2w@-IxF9&TP_{R;1_98aL!Di83Fqi$4MXiudl z`RLPlW_u-|Qzb5Ulx6w5iHY+~IhjTrWsQAGjUgDLbUXBg?-^$qq2~h!kOp*e0PVF6 z?X``4;=T5l)VQSTs=|6bc9FH|0Co5x|E4(lM0}=yQv$zI=wZn$_ngDfXVmv5w5QfT z#(@s2IM7X$h5cgy`5Y*%nSOiejG}W&>fLh`-RTBB{T#QeK+*2{B}U#rnmneDbl4XX z$OF?qjGyTX-g4`l9Q;TZ`h>I(I>#58tE@Z`lYTyMSJU)&M|VFU$84d zg}^zdGfVu{T!V1itg84ezXtPtq>S)2624MnM);c&j_m_oMtEHNTeLyIWrQ!6c~sKL z2;VE=`*OrL?@2c22p^Xk;hqL#K!*Ic#AiO^7iHF8k<9niIl}8Cd~S~Ltr8y05k89a zVI%PM0&$@4OAD%{sB0d7V3|I-g9Owm-|6+|bQ-QFAx4Jdf#8B=_86Svo z#flCG@NSbmlG7YowP!ti4n%ijWGZQ|Ptq zKxCnkb_`&7FYp4&2O{ap?HbGP1YQJx)*BHrxkjo45X*b;2mk+@eP?V2GRJ+galga^ zzcXgmqxT?;^b@j9u3GTGz7Kh{6TK-J zcu?pPp(}(o`fTh_aS1;UaqV`fS;BAn*Z+}lqp#d6kl*Mh&!R}1{>JyJRXF(QXs05* zMp5`sozQ-v|4#T#f1-Yo-}Ij$@PSM^>V=)=vz=}RVW+8wc6z0Qf3YLH+d+TcLI21R z|BH_BLyqvBj_`5^eTRd_9G;e6wMG3yeaEb|_G)}&ou@o(xMu*mVPGcuJaRt$tEeUCbqeV}Zv!#h$FzVA$9*33~>;!&#WY`H#{@pVp2kTJf=1M+= zRI<%8@l^Zzpp5H-63L5vv20i?T9RcM2{ps1_Vq=m^x0so#^(J=l-0hkM-cB;D!JzX z`8!=Vv4?xYGqBHgZ9~zM>u2tjdcrftLwTY7khvY}W3G*lW4xt#cq@Ktj~~Gv!;k&V zEc~#qTlTi>ixc4WPR5!PSb{wR_lz^KXM7xMaeMqth~FEo;r=hVuMFi|%Z*=YzBRwM z0c&l@e z`*y@%#<-Ao&P=NyBTvX+G0Qsh0&CzV<}X|N*t;at=e`)WkX?>+5B`<4trYo7Tw@KS z91Gd8f+bm6AsbaUO@Plak zo&&!^lvkA-d;Nn?NZzm1evG$U^1NBnW4-k4xu;*1tpNMo$=Exw92a2!1nkYbWE{(q z;uxNpKiVwl*OPY-_u)xh>%*Q~?bWc?qkeENf8xH6!A_(1`iyJ0AH~Gxg1KGo?OAWe zCK2L(68nATm+@kJ2Bz6TuxCGU-(=XLGIc&Cd*y-)u$O}k262w09CgQhC9tPf{RDWjeuA}kG4-6~s+aad`l@W` zn*$~c{cWIh(~NUW8`It}N%)fO1vyJhd*NBN7m)f+IV=}3*?xFtUQPKwSo;NF%d@p# z1^ck_HlRh<|NrK3CDJD1S%AclwV&)}Ocvqlb|<)FJFB z*4jAYW2{-mJ$kRmQT~7b*oA6*fE@vP!z-lQXBL6~{Kqa-_A#4Xq4&3E-T<8&V3~Sg zJ3VpV;y%<(R$JHs)ZyD_q77;1I!WD}i@IT*nED{Ust?rv+h?ZN2ii{cC+2VP{fXt| zrJf}6INq8(rEIIG_db?<>E=KESJ3dDho0S`(&woFdr%V#Gs)0{&^2*EU79V z)mVN%5cUb*-9V;uClE!hT&}TvF_3nI5(%FTL{Tce8q4#6OyAO2a|rc*9{Aq^(th$J zkomkHNWP64Ynp+~=K|oRKrRevPl+LM=Ho3Os-lwXQDFHnkoFSVMHtR~ABtM}w8rvB zfwWg_22$QlK-xX{9tHWQ0+Gc^x5n~uG#czQzUP7DyB|otjX-3jvO{C}a^Pj~$GSy@ zF91SB<$R6hvw^IiA|T7h^&_yR2ME41LV|UIenGDwK=FMC%yv7+=iyH~g;`JY`)Q<` zQ2BIU61r1p?xPw0ZK2zQ9uT@w=)V{GZlTA8zFlaythbj6eVNc-724z{L>d(ul<=#N zC)yQEzx%b&rk~y|wCQ)dg$5``F^q5el@HIPO+WlP!a*h-#`iS(iw-&;%y#~dI_R4n z{Quyf*%tQrY-c+?%MpIW5q`Ua-tV9X95iLyG;{VU z2ut-jSP2~W1I7_g@nG`g7zd8z{Q%l*`D2n7;|JE$b~sbVI$h4|u^uep9tG=NYqHo6 zu(wNK%^1O+jc5OSE;-K{=-KmFKN8zc+B;eElupL}1XVbJ_&ig?9LVV_xew$1ka67H zKR~YDFQ(R>+4hRVat@63t%@7VwlB1o0rro_E3mGu(D{pDP0f8}kom`c)ySbA_pc?$ z`;LlQ>`Q9L3sEk`a~{vEZTYgxM;$#L*7qRXI3uOqWXb*huX}N(%Cf;;r0VOH{8T;k zq272dI|t{oIHy+irq4!01Mag5qUcp}R;pi z-bT6YRk2!YQ|N1=Z#nkkji`$l_Os9(*pl2k9t6MAQ>5S5z&$E#M5qVan3$)a?2pL% zHvH-LLHF!SkrwydOCZD8hYtU>wQWau#<o{dl8w+d&?Ex7ZbY*xsl zpLnn&!3Jj1#(t;xRI+Kuy&19(KsMqhbM-eVVTL0c#qb@8{3JnVuj%%R04(9M(`#dhbc0{vgwn{8%fHp6D4Xvi$YxTx}v z`sMg#>URocPH8FaPui{a*ycl-OHc>O-qnYB!q_Vlu=SL>tYxnt-&ha97LK+PI~ew* z#XaCY^~VcWC5+5Q|;)90kz<09)<}KZ5h@<+L3qu1L)nh12}XE}iBFTjk*^an}WUa~SD% zA|Dy?po_Jro5Sd%g=e4*opNWuo`&&x2lSrj6i1L|=~+{v)W124{F@4KcCZxf3S7uM za!hsd&6v8^X3ca2Pf`l_%&b_N>aL$M}a;+J!3Z z653%=HaF*Ml@2Z=u>NtTn1T}*>supfN<6SE<<^- z-YA3)CF=oUrMz>-Fx15yoT2byh;!TpT_y4^rqRtOq5qUme{8-e`*%elm45rZrv^8a{>CVoriZ4r$CpXd4olO7oME~-#=wCPwYk{+HCY6^whwa%jqkmU;2JcC$ z^{QEaB(N^yIu-MYTEk8%3hjqps5MmYo*JwLFrFcQeK>35+`a?nZ8*;b&Ky6C`4w~6 zGu%Hso`?AaGR&DR?`7NPM|DRVd#_%sBMPvNC@gs8n@c+ju$Cx1G6!>6aMtiQDf=me zw;*guK|%B?mw#Z3%RPsE<;jBIkf$UoCODB~jL88yeL zvxV`A<*3ho++|khAlQeTbK<@#oF(Pyvku#u$==6#Ud=rd&py~TtRt-JS#SGGChI*S z*PzsOd%Wb?Bl?vZ8_>7x_l(JZdS@B`{@<2Ep4GqC0HAp#%{?U40*x8rdnLRsN4T6X zSa0PBr!ktYSwn_=+R^EzYs?4_iBF|w%LwOr0$nco^Rb|%TY$wBTt@s>u^->5f-}SS zO1Mft%Q=hr{!VX>`21Qgotws*Ea?vxDu2tbAtQgvFoQ6x_vkXh{WR3Tp?}e3gg1*l zt3w56hL0lrGT8rj0%ybi|Fp)MULemEHj00T`1^sd3HcTPuL2Gt{Y!!TXQ)bn%|M=m zRBQj%N{ux)0hvxQkm(d@ta%=Wrz_!qHxO0fD*`fns>YfzcwPYi=YfpB9msHgcMn)o z0`%d3F9vO52|Du};27$i=OagfXu?X&gT(S-Ami`VSaUZJ|ND9nNd8BG5LNkz#`25B ze>xDND~mOjzX`o!yt{#ncP9`*mE1r9%a7)(e;d{p2bLlHd7wJ~0e%GZ{XmvyIdC@e zQ?0Sa4}{6lcNOqzU_P(}_+FkqPa4-)ehkQP{<}F$pZ9seTG^|y{1M<4@ZTum9YFkF zxkh7o9q@957XcZc_k5vZmDE#Uc^rSPf&ZJpS-?R-o`;dY2MCp`d{krkLqIS5c|JB9 z<>}B^b0?7H_5)#0^c_N^BH&v<%AuVV|5v`Lv7G0fPz_%tkn)Z}ZyBHC3+ZQsep+x1 zkaC-Wl(!OysFigZ%WndD;SZfv$igA~-~D@Hk0T%U^RiLokLO>;Zu|(t@jHxuMi&v< zg~HN(LFgGmuN8Ws&>UA8ze4C$C^XYE;~oDUB!=H9;e6MY^g5xzs`$Ltje!}>Oj z{)r>}yN>V^4*C-gem1*Z{-+)Mf9arq=tms1^WRIl)sY^*H;4a|&Uya$EeF5z z-(SAj5&kI$9dyY5nuEr@X8ZThk{=gn;4A<9!~i}pP}`1w)UK(u{qt$>>Hgurm!`j% zm6j+D4y*AmB=cW_#`l5E%jkS<*zw&oeWaG;_%H{K|MmH_#g%-s|3iE}?e~5pYUTX* zq;s5y&Rei>o>#fLLjB%#=J(g8O4nom<8ar{2QPkbSPPl8tfHNN)?o2L$9a{`&{(T* zy}~tsav$_O^iiy5=qQgvbr6dntWTJ+5WzT{U*c7PmbTA{M{Vu$z@5uYsAU;BbH%HJ znXx&U29iFfIu9L@eDz3-UdUtFV#uEarHMS%d8iwUzH<q*|V!SXYC9!h!UhhX*Y zG~l$H^E}j&^Ca$3dG;2>xgL>r1D@;gxnMGED?AUCGeG(wBZ}V*+f512(_q7bT|>oD z_Ep+Dz{l`}N86ELe^KXo{1#w;&-4l> z^ZcW5)d7c%9dgw<1?DqlBT0a_6nUfF;S;XVz|p)ZJ8*Yw8rFNtzKDH{Dj(%$yGLlR z$F%&Mkvv;eX9jZ+pZCjOwb#d)DZ3i&A+#?qLVj5fuo39G!M-1#z&@We^J?VeDi_w3 z#j354UMXx8v~xM*s`q9gOSK8)f^VAp?@HC#C+lG;>f;FVwiNbN%!{;FB=cgj@ zMgHsWwR`YRauM#t=BI2$;R|tIePREuJs0%%h3^_?Iba)KyCd(y{y5Ifdh_n;H+Hn% zNwmS;HO~C?<$bf?oXfIJpW5?jb^d!6>MO`?Vh|x8iU=Gv^u+l zZ3-P{JM&b6JefH5{0u9bVD|j%*mF@o?7etT{G#z4dp?77KZCQ=i-8x9$8ioAggq5Q zKygp_ZrHQ#cG$Bnw%M}~XV2aJab?f?)=BJHpMgE=TUqT{_A=8Z*jsT|e?ceSdnkD2 z!o#p-E$#Hb@#I0*>pQ~J#~C&S{;N6*E^@=>=mz%Yq25rx=+n~1eP-@9#d)*Tp*nX)yc*OY&J1B6 zOs~UxP=~ymZ?_3vVyi=a&Zz1TGWx>b?l0u|V!^B5oU#dL2%rn_Ea#0!N@;t8jj-9} zF6`YiqaOow@h%{3ly0^|79E6LaT)BB1NORp8Fk%*x;SxPHQw9475AR=wJk7gI|n>d z^`qm%AK;#c{xBRClpo?#acm$s*_CL5f5l%NcxDR^VveEX{Z6=y_}n+sabJ%8az^+{ zPDpSIG-QPHJ}&psn+5lR16ws8@7ZDw^YOc5xHserK|cK@9p5<8#rnh73WR?v_fx={ zeaI)~MBgwFUX^<_mUACO|1luEDvxR`e-y~{{XmTUzGA@;5PWCU3Hk-Sf&dks4<`Hm z_#5!&{?x1^ekb(*lzR9VNBA#EqiklK!1pHA{tigjfFEh&9u(TtJ8W4h+_Y1b(5Bx1 z3bZY{1wBinzvH0)!9gE%(3EADH_JiuJAC$VzLY87Tg$N}`h$IZ&9VJS`v}|bVS9sB Zv3!!5Px37`{nDen)tG)OQNQ2#{{UxMzo!5I diff --git a/deps/sdl2_net/lib/pkgconfig/SDL2_net.pc b/deps/sdl2_net/lib/pkgconfig/SDL2_net.pc index d90c86e0..42a9c1f1 100644 --- a/deps/sdl2_net/lib/pkgconfig/SDL2_net.pc +++ b/deps/sdl2_net/lib/pkgconfig/SDL2_net.pc @@ -5,7 +5,9 @@ includedir=${prefix}/include Name: SDL2_net Description: net library for Simple DirectMedia Layer -Version: 2.0.1 -Requires: sdl2 >= 2.0.0 +Version: 2.2.0 +Requires: sdl2 >= 2.0.4 +Requires.private: Libs: -L${libdir} -lSDL2_net -Cflags: -I${includedir}/SDL2 +Libs.private: +Cflags: -I${includedir} -I${includedir}/SDL2