-#ifndef VG_STEAM_NETWORKING_H
-#define VG_STEAM_NETWORKING_H
-
+#pragma once
#include "vg_steam.h"
#ifdef VALVE_CALLBACK_PACK_SMALL
/* Handle used to identify a connection to a remote host. */
typedef u32 HSteamNetConnection;
-HSteamNetConnection const k_HSteamNetConnection_Invalid = 0;
+static HSteamNetConnection const k_HSteamNetConnection_Invalid = 0;
/*
* Handle used to identify a "listen socket". Unlike traditional
* different abstractions.
*/
typedef u32 HSteamListenSocket;
-HSteamListenSocket const k_HSteamListenSocket_Invalid = 0;
+static HSteamListenSocket const k_HSteamListenSocket_Invalid = 0;
typedef u32 SteamNetworkingPOPID;
typedef i64 SteamNetworkingMicroseconds;
* connections at once efficiently.
*/
typedef u32 HSteamNetPollGroup;
-HSteamNetPollGroup const k_HSteamNetPollGroup_Invalid = 0;
+static HSteamNetPollGroup const k_HSteamNetPollGroup_Invalid = 0;
ISteamNetworkingSockets
*SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012(void);
-ISteamNetworkingSockets
+static inline ISteamNetworkingSockets
*SteamAPI_SteamGameServerNetworkingSockets_SteamAPI(void)
{
return SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v012();
ISteamNetworkingSockets *SteamAPI_SteamNetworkingSockets_SteamAPI_v012();
+static inline
ISteamNetworkingSockets *SteamAPI_SteamNetworkingSockets_SteamAPI()
{
return SteamAPI_SteamNetworkingSockets_SteamAPI_v012();
* Migration note: This is not exactly the same as k_EP2PSendUnreliable! You
* probably want k_ESteamNetworkingSendType_UnreliableNoNagle
*/
-const int k_nSteamNetworkingSend_Unreliable = 0;
+static const int k_nSteamNetworkingSend_Unreliable = 0;
/*
* Disable Nagle's algorithm.
* server simulation tick to a particular client), and you use this flag to
* flush all messages.
*/
-const int k_nSteamNetworkingSend_NoNagle = 1;
+static const int k_nSteamNetworkingSend_NoNagle = 1;
/*
* Send a message unreliably, bypassing Nagle's algorithm for this message and
* ISteamNetworkingMessages::FlushMessagesToUser. (But using this flag is more
* efficient since you only make one API call.)
*/
-const int k_nSteamNetworkingSend_UnreliableNoNagle =
+static const int k_nSteamNetworkingSend_UnreliableNoNagle =
k_nSteamNetworkingSend_Unreliable |
k_nSteamNetworkingSend_NoNagle;
/*
* This is only applicable for unreliable messages. Using this flag on reliable
* messages is invalid.
*/
-const int k_nSteamNetworkingSend_NoDelay = 4;
+static const int k_nSteamNetworkingSend_NoDelay = 4;
/*
* Send an unreliable message, but if it cannot be sent relatively quickly, just
*
* If a message is dropped for these reasons, k_EResultIgnored will be returned.
*/
-const int k_nSteamNetworkingSend_UnreliableNoDelay =
+static const int k_nSteamNetworkingSend_UnreliableNoDelay =
k_nSteamNetworkingSend_Unreliable |
k_nSteamNetworkingSend_NoDelay |
k_nSteamNetworkingSend_NoNagle;
* Migration note: This is NOT the same as k_EP2PSendReliable, it's more like
* k_EP2PSendReliableWithBuffering
*/
-const int k_nSteamNetworkingSend_Reliable = 8;
+static const int k_nSteamNetworkingSend_Reliable = 8;
/*
* Send a message reliably, but bypass Nagle's algorithm.
*
* Migration note: This is equivalent to k_EP2PSendReliable
*/
-const int k_nSteamNetworkingSend_ReliableNoNagle =
+static const int k_nSteamNetworkingSend_ReliableNoNagle =
k_nSteamNetworkingSend_Reliable |
k_nSteamNetworkingSend_NoNagle;
* Utility
*/
-static const char *string_ESteamNetworkingConnectionState(
+static inline const char *string_ESteamNetworkingConnectionState(
ESteamNetworkingConnectionState s )
{
switch(s)
return "Error";
}
-static const char *string_ESteamNetworkingAvailability(
+static inline const char *string_ESteamNetworkingAvailability(
ESteamNetworkingAvailability s )
{
switch(s)
break;
}
}
-
-#endif /* VG_STEAM_NETWORKING_H */