--- /dev/null
+/*
+ steamworks_thin.h - simple wrapper / macro set for building steamworks apps in pure C
+ Usage:
+ Put the latest steam_api.dll in your build folder
+ link against -lsteam_api
+
+ all functions are prefixed with sw_
+*/
+
+#ifndef STEAMWORKS_H
+#define STEAMWORKS_H
+
+#include <stdint.h>
+#include <stdio.h>
+
+GLuint _localplayer_image;
+char _localplayer_name[128];
+
+#ifndef NO_STEAM
+
+#ifndef VOYAGER_RELEASE_MODE
+ #define STRUCTURE_PACK_CHECK
+#endif
+
+/*______________________________________________________________________________________________________________________________
+
+ ENUMS
+______________________________________________________________________________________________________________________________*/
+
+typedef enum{
+
+ k_ESteamIPTypeIPv4 = 0,
+ k_ESteamIPTypeIPv6 = 1,
+
+} ESteamIPType_t;
+
+typedef enum{
+
+ k_ESNetSocketConnectionTypeNotConnected = 0,
+ k_ESNetSocketConnectionTypeUDP = 1,
+ k_ESNetSocketConnectionTypeUDPRelay = 2,
+
+} ESNetSocketConnectionType_t;
+
+//-----------------------------------------------------------------------------
+// Purpose: Base values for callback identifiers, each callback must
+// have a unique ID.
+//-----------------------------------------------------------------------------
+
+enum { k_iSteamUserCallbacks = 100 };
+enum { k_iSteamGameServerCallbacks = 200 };
+enum { k_iSteamFriendsCallbacks = 300 };
+enum { k_iSteamBillingCallbacks = 400 };
+enum { k_iSteamMatchmakingCallbacks = 500 };
+enum { k_iSteamContentServerCallbacks = 600 };
+enum { k_iSteamUtilsCallbacks = 700 };
+enum { k_iClientFriendsCallbacks = 800 };
+enum { k_iClientUserCallbacks = 900 };
+enum { k_iSteamAppsCallbacks = 1000 };
+enum { k_iSteamUserStatsCallbacks = 1100 };
+enum { k_iSteamNetworkingCallbacks = 1200 };
+enum { k_iSteamNetworkingSocketsCallbacks = 1220 };
+enum { k_iSteamNetworkingMessagesCallbacks = 1250 };
+enum { k_iSteamNetworkingUtilsCallbacks = 1280 };
+enum { k_iClientRemoteStorageCallbacks = 1300 };
+enum { k_iClientDepotBuilderCallbacks = 1400 };
+enum { k_iSteamGameServerItemsCallbacks = 1500 };
+enum { k_iClientUtilsCallbacks = 1600 };
+enum { k_iSteamGameCoordinatorCallbacks = 1700 };
+enum { k_iSteamGameServerStatsCallbacks = 1800 };
+enum { k_iSteam2AsyncCallbacks = 1900 };
+enum { k_iSteamGameStatsCallbacks = 2000 };
+enum { k_iClientHTTPCallbacks = 2100 };
+enum { k_iClientScreenshotsCallbacks = 2200 };
+enum { k_iSteamScreenshotsCallbacks = 2300 };
+enum { k_iClientAudioCallbacks = 2400 };
+enum { k_iClientUnifiedMessagesCallbacks = 2500 };
+enum { k_iSteamStreamLauncherCallbacks = 2600 };
+enum { k_iClientControllerCallbacks = 2700 };
+enum { k_iSteamControllerCallbacks = 2800 };
+enum { k_iClientParentalSettingsCallbacks = 2900 };
+enum { k_iClientDeviceAuthCallbacks = 3000 };
+enum { k_iClientNetworkDeviceManagerCallbacks = 3100 };
+enum { k_iClientMusicCallbacks = 3200 };
+enum { k_iClientRemoteClientManagerCallbacks = 3300 };
+enum { k_iClientUGCCallbacks = 3400 };
+enum { k_iSteamStreamClientCallbacks = 3500 };
+enum { k_IClientProductBuilderCallbacks = 3600 };
+enum { k_iClientShortcutsCallbacks = 3700 };
+enum { k_iClientRemoteControlManagerCallbacks = 3800 };
+enum { k_iSteamAppListCallbacks = 3900 };
+enum { k_iSteamMusicCallbacks = 4000 };
+enum { k_iSteamMusicRemoteCallbacks = 4100 };
+enum { k_iClientVRCallbacks = 4200 };
+enum { k_iClientGameNotificationCallbacks = 4300 };
+enum { k_iSteamGameNotificationCallbacks = 4400 };
+enum { k_iSteamHTMLSurfaceCallbacks = 4500 };
+enum { k_iClientVideoCallbacks = 4600 };
+enum { k_iClientInventoryCallbacks = 4700 };
+enum { k_iClientBluetoothManagerCallbacks = 4800 };
+enum { k_iClientSharedConnectionCallbacks = 4900 };
+enum { k_ISteamParentalSettingsCallbacks = 5000 };
+enum { k_iClientShaderCallbacks = 5100 };
+enum { k_iSteamGameSearchCallbacks = 5200 };
+enum { k_iSteamPartiesCallbacks = 5300 };
+enum { k_iClientPartiesCallbacks = 5400 };
+enum { k_iSteamSTARCallbacks = 5500 };
+enum { k_iClientSTARCallbacks = 5600 };
+enum { k_iSteamRemotePlayCallbacks = 5700 };
+enum { k_iClientCompatCallbacks = 5800 };
+enum { k_iSteamChatCallbacks = 5900 };
+
+// Steam universes. Each universe is a self-contained Steam instance.
+typedef enum {
+ k_EUniverseInvalid = 0,
+ k_EUniversePublic = 1,
+ k_EUniverseBeta = 2,
+ k_EUniverseInternal = 3,
+ k_EUniverseDev = 4,
+ // k_EUniverseRC = 5, // no such universe anymore
+ k_EUniverseMax
+} EUniverse_t;
+
+typedef enum{
+ // Basic UDP send. Packets can't be bigger than 1200 bytes (your typical MTU size). Can be lost, or arrive out of order (rare).
+ // The sending API does have some knowledge of the underlying connection, so if there is no NAT-traversal accomplished or
+ // there is a recognized adjustment happening on the connection, the packet will be batched until the connection is open again.
+ k_EP2PSendUnreliable = 0,
+
+ // As above, but if the underlying p2p connection isn't yet established the packet will just be thrown away. Using this on the first
+ // packet sent to a remote host almost guarantees the packet will be dropped.
+ // This is only really useful for kinds of data that should never buffer up, i.e. voice payload packets
+ k_EP2PSendUnreliableNoDelay = 1,
+
+ // Reliable message send. Can send up to 1MB of data in a single message.
+ // Does fragmentation/re-assembly of messages under the hood, as well as a sliding window for efficient sends of large chunks of data.
+ k_EP2PSendReliable = 2,
+
+ // As above, but applies the Nagle algorithm to the send - sends will accumulate
+ // until the current MTU size (typically ~1200 bytes, but can change) or ~200ms has passed (Nagle algorithm).
+ // Useful if you want to send a set of smaller messages but have the coalesced into a single packet
+ // Since the reliable stream is all ordered, you can do several small message sends with k_EP2PSendReliableWithBuffering and then
+ // do a normal k_EP2PSendReliable to force all the buffered data to be sent.
+ k_EP2PSendReliableWithBuffering = 3,
+
+} EP2PSend_t;
+
+// list of possible errors returned by SendP2PPacket() API
+// these will be posted in the P2PSessionConnectFail_t callback
+typedef enum {
+ k_EP2PSessionErrorNone = 0,
+ k_EP2PSessionErrorNotRunningApp = 1, // target is not running the same game
+ k_EP2PSessionErrorNoRightsToApp = 2, // local user doesn't own the app that is running
+ k_EP2PSessionErrorDestinationNotLoggedIn = 3, // target user isn't connected to Steam
+ k_EP2PSessionErrorTimeout = 4, // target isn't responding, perhaps not calling AcceptP2PSessionWithUser()
+ // corporate firewalls can also block this (NAT traversal is not firewall traversal)
+ // make sure that UDP ports 3478, 4379, and 4380 are open in an outbound direction
+ k_EP2PSessionErrorMax = 5
+} EP2PSessionError_t;
+
+typedef enum {
+
+ k_EFriendFlagNone = 0x00,
+ k_EFriendFlagBlocked = 0x01,
+ k_EFriendFlagFriendshipRequested = 0x02,
+ k_EFriendFlagImmediate = 0x04, // "regular" friend
+ k_EFriendFlagClanMember = 0x08,
+ k_EFriendFlagOnGameServer = 0x10,
+ // k_EFriendFlagHasPlayedWith = 0x20, // not currently used
+ // k_EFriendFlagFriendOfFriend = 0x40, // not currently used
+ k_EFriendFlagRequestingFriendship = 0x80,
+ k_EFriendFlagRequestingInfo = 0x100,
+ k_EFriendFlagIgnored = 0x200,
+ k_EFriendFlagIgnoredFriend = 0x400,
+ // k_EFriendFlagSuggested = 0x800, // not used
+ k_EFriendFlagChatMember = 0x1000,
+ k_EFriendFlagAll = 0xFFFF,
+
+} EFriendFlags_t;
+
+// size limits on Rich Presence data
+enum { k_cchMaxRichPresenceKeys = 30 };
+enum { k_cchMaxRichPresenceKeyLength = 64 };
+enum { k_cchMaxRichPresenceValueLength = 256 };
+
+/*______________________________________________________________________________________________________________________________
+
+ STEAM TYPES
+______________________________________________________________________________________________________________________________*/
+
+// Redefube class pointers to void
+typedef void ISteamFriends;
+typedef void ISteamUserStats;
+typedef void ISteamUtils;
+typedef void ISteamUser;
+typedef void ISteamNetworking;
+
+typedef int32_t HSteamPipe;
+typedef int32_t HSteamUser;
+
+typedef int E_iCallBack_t;
+
+typedef uint32_t SNetSocket_t; // CreateP2PConnectionSocket()
+typedef uint32_t SNetListenSocket_t; // CreateListenSocket()
+
+typedef uint64_t uint64_steamid;
+typedef uint64_t SteamAPICall_t;
+
+/*______________________________________________________________________________________________________________________________
+
+ PACKING: 1 Byte
+______________________________________________________________________________________________________________________________*/
+
+#pragma pack( push, 1 )
+
+typedef struct
+{
+ // 64 bits total
+ union {
+ struct SteamIDComponent_t
+ {
+#ifdef VALVE_BIG_ENDIAN
+ EUniverse_t m_EUniverse : 8; // universe this account belongs to
+ unsigned int m_EAccountType : 4; // type of account - can't show as EAccountType, due to signed / unsigned difference
+ unsigned int m_unAccountInstance : 20; // dynamic instance ID
+ uint32_t m_unAccountID : 32; // unique account identifier
+#else
+ uint32_t m_unAccountID : 32; // unique account identifier
+ unsigned int m_unAccountInstance : 20; // dynamic instance ID
+ unsigned int m_EAccountType : 4; // type of account - can't show as EAccountType, due to signed / unsigned difference
+ EUniverse_t m_EUniverse : 8; // universe this account belongs to
+#endif
+ } m_comp;
+
+ uint64_t m_unAll64Bits;
+ };
+} CSteamID;
+
+typedef struct{
+ union {
+
+ uint32_t m_unIPv4; // Host order
+ uint8_t m_rgubIPv6[16]; // Network order! Same as inaddr_in6. (0011:2233:4455:6677:8899:aabb:ccdd:eeff)
+
+ // Internal use only
+ uint64_t m_ipv6Qword[2]; // big endian
+
+ };
+
+ ESteamIPType_t m_eType;
+
+} SteamIPAddress_t;
+
+#pragma pack(pop)
+
+/*______________________________________________________________________________________________________________________________
+
+ PACKING: Some kind of strange alignment thing
+______________________________________________________________________________________________________________________________*/
+
+#if defined(__linux__) || defined(__APPLE__)
+// The 32-bit version of gcc has the alignment requirement for uint64 and double set to
+// 4 meaning that even with #pragma pack(8) these types will only be four-byte aligned.
+// The 64-bit version of gcc has the alignment requirement for these types set to
+// 8 meaning that unless we use #pragma pack(4) our structures will get bigger.
+// The 64-bit structure packing has to match the 32-bit structure packing for each platform.
+ #define VALVE_CALLBACK_PACK_SMALL
+#else
+ #define VALVE_CALLBACK_PACK_LARGE
+#endif
+
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+ #pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+ #pragma pack( push, 8 )
+#else
+ #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
+#endif
+
+typedef struct{
+
+ uint8_t m_bConnectionActive; // true if we've got an active open connection
+ uint8_t m_bConnecting; // true if we're currently trying to establish a connection
+ uint8_t m_eP2PSessionError; // last error recorded (see enum above)
+ uint8_t m_bUsingRelay; // true if it's going through a relay server (TURN)
+ int32_t m_nBytesQueuedForSend;
+ int32_t m_nPacketsQueuedForSend;
+ uint32_t m_nRemoteIP; // potential IP:Port of remote host. Could be TURN server.
+ uint16_t m_nRemotePort; // Only exists for compatibility with older authentication api's
+
+} P2PSessionState_t;
+
+typedef struct {
+
+ HSteamUser m_hSteamUser; // Specific user to whom this callback applies.
+ int m_iCallback; // Callback identifier. (Corresponds to the k_iCallback enum in the callback structure.)
+ uint8_t *m_pubParam; // Points to the callback structure
+ int m_cubParam; // Size of the data pointed to by m_pubParam
+
+} CallbackMsg_t;
+
+typedef struct {
+
+ SteamAPICall_t m_hAsyncCall;
+ int m_iCallback;
+ uint32_t m_cubParam;
+
+} SteamAPICallCompleted_t;
+#define SW_CBID_SteamAPICallCompleted (k_iSteamUtilsCallbacks + 3)
+
+
+// callback notification - a user wants to talk to us over the P2P channel via the SendP2PPacket() API
+// in response, a call to AcceptP2PPacketsFromUser() needs to be made, if you want to talk with them
+typedef struct {
+
+ CSteamID m_steamIDRemote; // user who wants to talk to us
+
+} P2PSessionRequest_t;
+#define SW_CBID_P2PSessionRequest (k_iSteamNetworkingCallbacks + 2)
+
+
+// callback notification - packets can't get through to the specified user via the SendP2PPacket() API
+// all packets queued packets unsent at this point will be dropped
+// further attempts to send will retry making the connection (but will be dropped if we fail again)
+typedef struct {
+
+ CSteamID m_steamIDRemote; // user we were sending packets to
+ uint8_t m_eP2PSessionError; // EP2PSessionError indicating why we're having trouble
+
+} P2PSessionConnectFail_t;
+#define SW_CBID_P2PSessionConnectFail (k_iSteamNetworkingCallbacks + 3)
+
+// callback notification - status of a socket has changed
+// used as part of the CreateListenSocket() / CreateP2PConnectionSocket()
+typedef struct {
+
+ SNetSocket_t m_hSocket; // the socket used to send/receive data to the remote host
+ SNetListenSocket_t m_hListenSocket; // this is the server socket that we were listening on; NULL if this was an outgoing connection
+ CSteamID m_steamIDRemote; // remote steamID we have connected to, if it has one
+ int m_eSNetSocketState; // socket state, ESNetSocketState
+
+} SocketStatusCallback_t;
+#define SW_CBID_SocketStatusCallback (k_iSteamNetworkingCallbacks + 1)
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the user tries to join a game from their friends list
+// rich presence will have been set with the "connect" key which is set here
+//-----------------------------------------------------------------------------
+typedef struct {
+ CSteamID m_steamIDFriend; // the friend they did the join via (will be invalid if not directly via a friend)
+ char m_rgchConnect[k_cchMaxRichPresenceValueLength];
+} GameRichPresenceJoinRequested_t;
+#define SW_CBID_GameRichPresenceJoinRequested (k_iSteamFriendsCallbacks + 37)
+
+// Making SURE we have alignment
+#ifdef STRUCTURE_PACK_CHECK
+typedef struct {
+ uint32_t m_u32;
+ uint64_t m_u64;
+ uint16_t m_u16;
+ double m_d;
+} ValvePackingSentinel_t;
+#endif
+
+#pragma pack( pop )
+
+#ifndef NO_STEAM
+
+/*______________________________________________________________________________________________________________________________
+
+ Forward linker declerations. Type: cdecl (obviously)
+______________________________________________________________________________________________________________________________*/
+
+void SteamAPI_Shutdown();
+int SteamAPI_Init();
+int SteamAPI_RestartAppIfNecessary( uint32_t unOwnAppID );
+
+void SteamAPI_ManualDispatch_Init();
+void SteamAPI_ManualDispatch_RunFrame( HSteamPipe hSteamPipe );
+int SteamAPI_ManualDispatch_GetNextCallback( HSteamPipe hSteamPipe, CallbackMsg_t *pCallbackMsg );
+void SteamAPI_ManualDispatch_FreeLastCallback( HSteamPipe hSteamPipe );
+int SteamAPI_ManualDispatch_GetAPICallResult( HSteamPipe hSteamPipe, SteamAPICall_t hSteamAPICall, void *pCallback, int cubCallback, int iCallbackExpected, int *pbFailed );
+
+
+char *SteamAPI_ISteamFriends_GetPersonaName( ISteamFriends *self );
+const char *SteamAPI_ISteamFriends_GetFriendPersonaName( ISteamFriends *self, uint64_steamid steamIDFriend );
+uint64_steamid SteamAPI_ISteamUser_GetSteamID( ISteamUser *self );
+int SteamAPI_ISteamFriends_SetRichPresence( ISteamFriends* self, const char * pchKey, const char * pchValue );
+int SteamAPI_ISteamFriends_HasFriend( ISteamFriends* self, uint64_steamid steamIDFriend, int iFriendFlags );
+int SteamAPI_ISteamFriends_GetSmallFriendAvatar ( ISteamFriends *self, uint64_steamid steamIDFriend ); // 32x32
+int SteamAPI_ISteamFriends_GetMediumFriendAvatar ( ISteamFriends *self, uint64_steamid steamIDFriend );
+int SteamAPI_ISteamFriends_GetLargeFriendAvatar ( ISteamFriends *self, uint64_steamid steamIDFriend );
+int SteamAPI_ISteamUtils_GetImageSize( ISteamUtils *self, int iImage, uint32_t *pnWidth, uint32_t *pnHeight );
+int SteamAPI_ISteamUtils_GetImageRGBA( ISteamUtils *self, int iImage, uint8_t *pubDest, int nDestBufferSize );
+int SteamAPI_ISteamUserStats_SetAchievement( ISteamUserStats *self, const char *pchName );
+
+HSteamPipe SteamAPI_GetHSteamPipe();
+HSteamUser SteamAPI_GetHSteamUser();
+
+/* NETWORKING INTERFACES
+-------------------------*/
+
+int /* SendP2PPacket */ SteamAPI_ISteamNetworking_SendP2PPacket( ISteamNetworking *self,
+ uint64_steamid steamIDRemote,
+ const void *pubData,
+ uint32_t cubData,
+ EP2PSend_t eP2PSendType,
+ int nChannel
+);
+
+int /* IsP2PPacketAvailable */ SteamAPI_ISteamNetworking_IsP2PPacketAvailable( ISteamNetworking *self,
+ uint32_t *pcubMsgSize,
+ int nChannel
+);
+
+int /* ReadP2PPacket */ SteamAPI_ISteamNetworking_ReadP2PPacket( ISteamNetworking *self,
+ void *pubDest,
+ uint32_t cubDest,
+ uint32_t *pcubMsgSize,
+ CSteamID *psteamIDRemote,
+ int nChannel
+);
+
+int /* AcceptP2PSessionWithUser */ SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser( ISteamNetworking *self,
+ uint64_steamid steamIDRemote
+);
+
+int /* CloseP2PSessionWithUser */ SteamAPI_ISteamNetworking_CloseP2PSessionWithUser( ISteamNetworking *self,
+ uint64_steamid steamIDRemote
+);
+
+int /* CloseP2PChannelWithUser */ SteamAPI_ISteamNetworking_CloseP2PChannelWithUser( ISteamNetworking *self,
+ uint64_steamid steamIDRemote,
+ int nChannel
+);
+
+int /* GetP2PSessionState */ SteamAPI_ISteamNetworking_GetP2PSessionState( ISteamNetworking *self,
+ uint64_steamid steamIDRemote,
+ P2PSessionState_t *pConnectionState
+);
+
+int /* AllowP2PPacketRelay */ SteamAPI_ISteamNetworking_AllowP2PPacketRelay( ISteamNetworking *self,
+ int bAllow
+);
+
+SNetListenSocket_t /* CreateListenSocket */ SteamAPI_ISteamNetworking_CreateListenSocket( ISteamNetworking *self,
+ int nVirtualP2PPort,
+ SteamIPAddress_t nIP,
+ uint16_t nPort,
+ int bAllowUseOfPacketRelay
+);
+
+SNetSocket_t /* CreateP2PConnectionSocket */ SteamAPI_ISteamNetworking_CreateP2PConnectionSocket( ISteamNetworking *self,
+ uint64_steamid steamIDTarget,
+ int nVirtualPort,
+ int nTimeoutSec,
+ int bAllowUseOfPacketRelay
+);
+
+SNetSocket_t /* CreateConnectionSocket */ SteamAPI_ISteamNetworking_CreateConnectionSocket( ISteamNetworking *self,
+ SteamIPAddress_t nIP,
+ uint16_t nPort,
+ int nTimeoutSec
+);
+
+int /* DestroySocket */ SteamAPI_ISteamNetworking_DestroySocket( ISteamNetworking *self,
+ SNetSocket_t hSocket,
+ int bNotifyRemoteEnd
+);
+
+int /* DestroyListenSocket */ SteamAPI_ISteamNetworking_DestroyListenSocket( ISteamNetworking *self,
+ SNetListenSocket_t hSocket,
+ int bNotifyRemoteEnd
+);
+
+int /* SendDataOnSocket */ SteamAPI_ISteamNetworking_SendDataOnSocket( ISteamNetworking *self,
+ SNetSocket_t hSocket,
+ void *pubData,
+ uint32_t cubData,
+ int bReliable
+);
+
+int /* IsDataAvailableOnSocket */ SteamAPI_ISteamNetworking_IsDataAvailableOnSocket( ISteamNetworking *self,
+ SNetSocket_t hSocket,
+ uint32_t *pcubMsgSize
+);
+
+int /* RetrieveDataFromSocket */ SteamAPI_ISteamNetworking_RetrieveDataFromSocket( ISteamNetworking *self,
+ SNetSocket_t hSocket,
+ void *pubDest,
+ uint32_t cubDest,
+ uint32_t *pcubMsgSize
+);
+
+int /* IsDataAvailable */ SteamAPI_ISteamNetworking_IsDataAvailable( ISteamNetworking *self,
+ SNetListenSocket_t hListenSocket,
+ uint32_t *pcubMsgSize,
+ SNetSocket_t *phSocket
+);
+
+int /* RetrieveData */ SteamAPI_ISteamNetworking_RetrieveData( ISteamNetworking *self,
+ SNetListenSocket_t hListenSocket,
+ void *pubDest,
+ uint32_t cubDest,
+ uint32_t *pcubMsgSize,
+ SNetSocket_t *phSocket
+);
+
+int /* GetSocketInfo */ SteamAPI_ISteamNetworking_GetSocketInfo( ISteamNetworking *self,
+ SNetSocket_t hSocket,
+ CSteamID *pSteamIDRemote,
+ int *peSocketStatus,
+ SteamIPAddress_t *punIPRemote,
+ uint16_t *punPortRemote
+);
+
+int /* GetListenSocketInfo */ SteamAPI_ISteamNetworking_GetListenSocketInfo( ISteamNetworking *self,
+ SNetListenSocket_t hListenSocket,
+ SteamIPAddress_t *pnIP,
+ uint16_t *pnPort
+);
+
+ESNetSocketConnectionType_t /* GetSocketConnectionType */ SteamAPI_ISteamNetworking_GetSocketConnectionType( ISteamNetworking *self,
+ SNetSocket_t hSocket
+);
+
+int /* GetMaxPacketSize */ SteamAPI_ISteamNetworking_GetMaxPacketSize( ISteamNetworking *self,
+ SNetSocket_t hSocket
+);
+
+#define sw_SteamAPI_Shutdown SteamAPI_Shutdown
+#define sw_SteamAPI_Init() SteamAPI_Init()
+#define sw_SteamAPI_RestartAppIfNecessary(...) SteamAPI_RestartAppIfNecessary( __VA_ARGS__ )
+
+// This method can only be cleared correctly in first party c++ mode
+// See: sw_SteamAPI_ManualDispatch_Init
+// #define sw_SteamAPI_RunCallbacks()
+
+// Steam pipe stuff
+#define sw_SteamAPI_GetHSteamPipe() SteamAPI_GetHSteamPipe()
+#define sw_SteamAPI_GetHSteamUser() SteamAPI_GetHSteamUser()
+
+#define sw_SteamAPI_ManualDispatch_Init() SteamAPI_ManualDispatch_Init()
+#define sw_SteamAPI_ManualDispatch_GetNextCallback(...) SteamAPI_ManualDispatch_GetNextCallback( __VA_ARGS__ )
+#define sw_SteamAPI_ManualDispatch_FreeLastCallback(...) SteamAPI_ManualDispatch_FreeLastCallback( __VA_ARGS__ )
+#define sw_SteamAPI_ManualDispatch_GetAPICallResult(...) SteamAPI_ManualDispatch_GetAPICallResult( __VA_ARGS__ )
+#define sw_SteamAPI_ManualDispatch_RunFrame(...) SteamAPI_ManualDispatch_RunFrame( __VA_ARGS__ )
+
+#define sw_GetPersonaName(...) SteamAPI_ISteamFriends_GetPersonaName( __thinsteam_friends, ##__VA_ARGS__ )
+#define sw_GetFriendPersonaName(...) SteamAPI_ISteamFriends_GetFriendPersonaName( __thinsteam_friends, __VA_ARGS__ )
+#define sw_GetSteamID(...) SteamAPI_ISteamUser_GetSteamID( __thinsteam_user, ##__VA_ARGS__ )
+#define sw_HasFriend(...) SteamAPI_ISteamFriends_HasFriend( __thinsteam_friends, __VA_ARGS__ )
+#define sw_SetRichPresence(...) SteamAPI_ISteamFriends_SetRichPresence( __thinsteam_friends, __VA_ARGS__ )
+
+#define sw_GetSmallFriendAvatar(...) SteamAPI_ISteamFriends_GetSmallFriendAvatar( __thinsteam_friends, ##__VA_ARGS__ )
+#define sw_GetMediumFriendAvatar(...) SteamAPI_ISteamFriends_GetMediumFriendAvatar( __thinsteam_friends, ##__VA_ARGS__ )
+#define sw_GetLargeFriendAvatar(...) SteamAPI_ISteamFriends_GetLargeFriendAvatar( __thinsteam_friends, ##__VA_ARGS__ )
+#define sw_GetImageSize(...) SteamAPI_ISteamUtils_GetImageSize( __thinsteam_utils, ##__VA_ARGS__ )
+#define sw_GetImageRGBA(...) SteamAPI_ISteamUtils_GetImageRGBA( __thinsteam_utils, ##__VA_ARGS__ )
+
+#define sw_SetAchievement(...) SteamAPI_ISteamUserStats_SetAchievement( __thinsteam_stats, ##__VA_ARGS__ )
+
+// https://partner.steamgames.com/doc/api/ISteamNetworkingUtils
+#define sw_SendP2PPacket(...) SteamAPI_ISteamNetworking_SendP2PPacket( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_IsP2PPacketAvailable(...) SteamAPI_ISteamNetworking_IsP2PPacketAvailable( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_ReadP2PPacket(...) SteamAPI_ISteamNetworking_ReadP2PPacket( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_AcceptP2PSessionWithUser(...) SteamAPI_ISteamNetworking_AcceptP2PSessionWithUser( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_CloseP2PSessionWithUser(...) SteamAPI_ISteamNetworking_CloseP2PSessionWithUser( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_CloseP2PChannelWithUser(...) SteamAPI_ISteamNetworking_CloseP2PChannelWithUser( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_GetP2PSessionState(...) SteamAPI_ISteamNetworking_GetP2PSessionState( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_AllowP2PPacketRelay(...) SteamAPI_ISteamNetworking_AllowP2PPacketRelay( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_CreateListenSocket(...) SteamAPI_ISteamNetworking_CreateListenSocket( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_CreateP2PConnectionSocket(...) SteamAPI_ISteamNetworking_CreateP2PConnectionSocket( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_CreateConnectionSocket(...) SteamAPI_ISteamNetworking_CreateConnectionSocket( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_DestroySocket(...) SteamAPI_ISteamNetworking_DestroySocket( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_DestroyListenSocket(...) SteamAPI_ISteamNetworking_DestroyListenSocket( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_SendDataOnSocket(...) SteamAPI_ISteamNetworking_SendDataOnSocket( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_IsDataAvailableOnSocket(...) SteamAPI_ISteamNetworking_IsDataAvailableOnSocket( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_RetrieveDataFromSocket(...) SteamAPI_ISteamNetworking_RetrieveDataFromSocket( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_IsDataAvailable(...) SteamAPI_ISteamNetworking_IsDataAvailable( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_RetrieveData(...) SteamAPI_ISteamNetworking_RetrieveData( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_GetSocketInfo(...) SteamAPI_ISteamNetworking_GetSocketInfo( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_GetListenSocketInfo(...) SteamAPI_ISteamNetworking_GetListenSocketInfo( __thinsteam_net, ##__VA_ARGS__ )
+#define sw_GetSocketConnectionType(...) SteamAPI_ISteamNetworking_GetSocketConnectionType( __thinsteam_net,##__VA_ARGS__ )
+#define sw_GetMaxPacketSize(...) SteamAPI_ISteamNetworking_GetMaxPacketSize( __thinsteam_net, ##__VA_ARGS__ )
+
+#define _sw__fill( self, func, ... ) func( self, ##__VA_ARGS__ )
+#endif
+
+/*______________________________________________________________________________________________________________________________
+
+ WRAPPER LAYER
+______________________________________________________________________________________________________________________________*/
+
+ISteamFriends *__thinsteam_friends = NULL;
+ISteamUser *__thinsteam_user = NULL;
+ISteamUtils *__thinsteam_utils = NULL;
+ISteamUserStats *__thinsteam_stats = NULL;
+ISteamNetworking *__thinsteam_net = NULL;
+
+ISteamFriends *SteamAPI_SteamFriends_v017();
+ISteamUser *SteamAPI_SteamUser_v021();
+ISteamUtils *SteamAPI_SteamUtils_v009();
+ISteamUserStats *SteamAPI_SteamUserStats_v012();
+ISteamNetworking *SteamAPI_SteamNetworking_v006();
+
+HSteamPipe g_hSteamPipe;
+
+GLuint get_player_image( uint64_steamid usr )
+{
+ GLuint gl_img;
+
+ uint32_t x = 64, y = 64;
+ int steam_image;
+
+ steam_image = sw_GetMediumFriendAvatar( usr );
+ sw_GetImageSize( steam_image, &x, &y );
+
+ unsigned char * img_buf = (unsigned char *)calloc( x * y * 4, 1 );
+
+ sw_GetImageRGBA( steam_image, img_buf, x * y * 4 );
+
+ glGenTextures( 1, &gl_img );
+ glBindTexture( GL_TEXTURE_2D, gl_img );
+
+ glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, x, y, 0, GL_RGBA, GL_UNSIGNED_BYTE, img_buf );
+ glGenerateMipmap( GL_TEXTURE_2D );
+
+ glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
+ glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
+
+ glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+ glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+
+ free( img_buf );
+
+ return gl_img;
+}
+
+int sw_vipid( uint64_steamid usr )
+{
+ static uint64_steamid massiveLEGENDS[] =
+ {
+ 76561198134179460, // Spud
+ 76561198020563704, // Assasssin
+ 76561198062961277, // lopen
+ 76561198084693332 // ernie
+ };
+
+ for( int i = 0; i < sizeof(massiveLEGENDS)/sizeof(massiveLEGENDS[0]); i ++ )
+ {
+ if( massiveLEGENDS[i] == usr )
+ return 1;
+ }
+
+ return 0;
+}
+
+// Initialize steamworks through this function and your appid
+int sw_init( uint32_t appid ) {
+
+#ifdef STRUCTURE_PACK_CHECK
+
+// This code should never fail and if it does something went wrong with the build
+// Remember to undefine STRUCTURE_PACK_CHECK for publishing!!!
+
+#if defined(VALVE_CALLBACK_PACK_SMALL)
+ if( sizeof(ValvePackingSentinel_t) != 24 ){
+ printf( "Struct packing error: ValvePackingSentinel_t expected 24 got %i\nThe application is built incorrectly\n", (int)sizeof(ValvePackingSentinel_t));
+ return 0;
+ }
+#elif defined(VALVE_CALLBACK_PACK_LARGE)
+ if( sizeof(ValvePackingSentinel_t) != 32 ){
+ printf( "Struct packing error: ValvePackingSentinel_t expected 32 got %i\nThe application is built incorrectly\n", (int)sizeof(ValvePackingSentinel_t));
+ return 0;
+ }
+#else
+ #error ???
+#endif
+
+#endif
+
+ #ifdef STEAMWORKS_VERBOSE
+ printf( "Initializing steamworks..\n" );
+ #endif
+
+ if( sw_SteamAPI_RestartAppIfNecessary( appid ) == 1 ){
+ #ifdef STEAMWORKS_VERBOSE
+ printf( "Restarting via steam\n" );
+ #endif
+ return 0;
+ }
+
+ if( !sw_SteamAPI_Init() ){
+ #ifdef STEAMWORKS_VERBOSE
+ printf( "Steamworks connection failed\n" );
+ #endif
+ return 0;
+ }
+
+ // We are using C so we have to deal with callbacks microsoft event loop style
+ sw_SteamAPI_ManualDispatch_Init();
+
+ __thinsteam_friends = SteamAPI_SteamFriends_v017();
+ __thinsteam_user = SteamAPI_SteamUser_v021();
+ __thinsteam_utils = SteamAPI_SteamUtils_v009();
+ __thinsteam_stats = SteamAPI_SteamUserStats_v012();
+ __thinsteam_net = SteamAPI_SteamNetworking_v006();
+
+ // This might happen if the DLL is too old
+ if( !__thinsteam_friends | !__thinsteam_user | !__thinsteam_utils | !__thinsteam_stats | !__thinsteam_net ){
+ #ifdef STEAMWORKS_VERBOSE
+ printf( "Interface hooks failed\n" );
+ #endif
+ return 0;
+ }
+
+ g_hSteamPipe = sw_SteamAPI_GetHSteamPipe();
+
+ #ifdef STEAMWORKS_VERBOSE
+ printf( "Steamworks ready\n" );
+ #endif
+
+ return 1;
+}
+
+void sw_init_postgl()
+{
+ _localplayer_image = get_player_image( sw_GetSteamID() );
+ strcpy( _localplayer_name, sw_GetPersonaName() );
+}
+
+/*______________________________________________________________________________________________________________________________
+
+ USER CODE
+______________________________________________________________________________________________________________________________*/
+
+// Macro Creates <name>(args):
+// Function(args) pointer definition
+// <name> Callback global pointer
+// sw_Set<name>Callback (*ptr) function
+
+#define _swCallbackPair( CNAME, ... ) \
+typedef void(*sw_##CNAME##Fun)( __VA_ARGS__ ); \
+sw_##CNAME##Fun CNAME = NULL; \
+void sw_Set##CNAME##Callback(sw_##CNAME##Fun d) { CNAME = d; }
+
+_swCallbackPair( OnSocketStatus, SNetSocket_t, SNetListenSocket_t, CSteamID, int )
+_swCallbackPair( OnP2PSessionConnectFail, CSteamID, EP2PSessionError_t )
+_swCallbackPair( OnP2PSessionRequest, CSteamID )
+_swCallbackPair( OnSteamJoinRequest, CSteamID, char * )
+
+void sw_RunSteamEventLoop(void)
+{
+ sw_SteamAPI_ManualDispatch_RunFrame( g_hSteamPipe );
+ CallbackMsg_t callback;
+ while( sw_SteamAPI_ManualDispatch_GetNextCallback( g_hSteamPipe, &callback ) ){
+
+ // Check for dispatching API call results
+ if( callback.m_iCallback == SW_CBID_SteamAPICallCompleted ){
+
+ SteamAPICallCompleted_t *pCallCompleted = (SteamAPICallCompleted_t *)&callback;
+ void *pTmpCallResult = malloc( pCallCompleted->m_cubParam );
+ int bFailed;
+
+ if( sw_SteamAPI_ManualDispatch_GetAPICallResult( g_hSteamPipe, pCallCompleted->m_hAsyncCall, pTmpCallResult, \
+ pCallCompleted->m_cubParam, pCallCompleted->m_iCallback, &bFailed ) ){
+
+ // Dispatch the call result to the registered handler(s) for the
+ // call identified by pCallCompleted->m_hAsyncCall
+
+ }
+
+ free( pTmpCallResult );
+
+ } else {
+
+ // Look at callback.m_iCallback to see what kind of callback it is,
+ // and dispatch to appropriate handler(s)
+
+ vg_info( "steamworks_event::callback( %i )\n", callback.m_iCallback );
+
+ void *data = callback.m_pubParam;
+
+ switch( callback.m_iCallback ){
+
+ case SW_CBID_P2PSessionRequest: if( OnP2PSessionRequest ) OnP2PSessionRequest(
+ ((P2PSessionRequest_t *)data)->m_steamIDRemote
+ ); break;
+
+ case SW_CBID_SocketStatusCallback: if( OnSocketStatus ) OnSocketStatus(
+ ((SocketStatusCallback_t *)data)->m_hSocket,
+ ((SocketStatusCallback_t *)data)->m_hListenSocket,
+ ((SocketStatusCallback_t *)data)->m_steamIDRemote,
+ ((SocketStatusCallback_t *)data)->m_eSNetSocketState
+ ); break;
+
+ case SW_CBID_P2PSessionConnectFail: if( OnP2PSessionConnectFail ) OnP2PSessionConnectFail(
+ ((P2PSessionConnectFail_t *)data)->m_steamIDRemote,
+ ((P2PSessionConnectFail_t *)data)->m_eP2PSessionError
+ ); break;
+
+ case SW_CBID_GameRichPresenceJoinRequested: if( OnSteamJoinRequest ) OnSteamJoinRequest(
+ ((GameRichPresenceJoinRequested_t *)data)->m_steamIDFriend,
+ ((GameRichPresenceJoinRequested_t *)data)->m_rgchConnect
+ ); break;
+
+ default: break;
+
+ }
+
+ }
+
+ SteamAPI_ManualDispatch_FreeLastCallback( g_hSteamPipe );
+
+ }
+
+}
+
+/*______________________________________________________________________________________________________________________________
+
+ NO_STEAM
+______________________________________________________________________________________________________________________________*/
+
+#else // #define NO_STEAM
+// In case we dont want to spam the steam servers
+
+char *__str_sw_unlinked = "__NO_STEAMWORKS__";
+
+#define SW_BLANK_RETURN 0
+
+#define sw_init( x ) 1
+#define sw_exit()
+#define sw_runcallbacks()
+#define sw_get_persona_name() __str_sw_unlinked
+#define sw_get_steamid() SW_BLANK_RETURN
+#define sw_get_friend_smallavatar( x ) SW_BLANK_RETURN
+#define sw_get_friend_mediumavatar( x ) SW_BLANK_RETURN
+#define sw_get_friend_largeavatar( x ) SW_BLANK_RETURN
+
+#define sw_get_image_size( x, y, z )
+#define sw_get_image_rgba( x, y, z )
+#define sw_set_achievement( x )
+
+#endif
+
+#endif
+
projects / vg.git / blobdiff