+#if defined(__linux__) || defined(__APPLE__)
+// The 32-bit version of gcc has the alignment requirement for u64 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
+
+// Types
+typedef void ISteamFriends;
+typedef void ISteamUserStats;
+typedef void ISteamUtils;
+typedef void ISteamUser;
+typedef void ISteamNetworking;
+
+typedef i32 HSteamPipe;
+typedef i32 HSteamUser;
+
+typedef int E_iCallBack_t;
+
+typedef u32 SNetSocket_t; // CreateP2PConnectionSocket()
+typedef u32 SNetListenSocket_t; // CreateListenSocket()
+
+typedef u64 u64_steamid;
+typedef u64 SteamAPICall_t;
+
+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 };
+
+// General result codes
+typedef enum EResult
+{
+ k_EResultNone = 0, // no result
+ k_EResultOK = 1, // success
+ k_EResultFail = 2, // generic failure
+ k_EResultNoConnection = 3, // no/failed network connection
+// k_EResultNoConnectionRetry = 4, // OBSOLETE - removed
+ k_EResultInvalidPassword = 5, // password/ticket is invalid
+ k_EResultLoggedInElsewhere = 6, // same user logged in elsewhere
+ k_EResultInvalidProtocolVer = 7, // protocol version is incorrect
+ k_EResultInvalidParam = 8, // a parameter is incorrect
+ k_EResultFileNotFound = 9, // file was not found
+ k_EResultBusy = 10, // called method busy - action not taken
+ k_EResultInvalidState = 11, // called object was in an invalid state
+ k_EResultInvalidName = 12, // name is invalid
+ k_EResultInvalidEmail = 13, // email is invalid
+ k_EResultDuplicateName = 14, // name is not unique
+ k_EResultAccessDenied = 15, // access is denied
+ k_EResultTimeout = 16, // operation timed out
+ k_EResultBanned = 17, // VAC2 banned
+ k_EResultAccountNotFound = 18, // account not found
+ k_EResultInvalidSteamID = 19, // steamID is invalid
+ k_EResultServiceUnavailable = 20, // The requested service is currently unavailable
+ k_EResultNotLoggedOn = 21, // The user is not logged on
+ k_EResultPending = 22, // Request is pending (may be in process, or waiting on third party)
+ k_EResultEncryptionFailure = 23, // Encryption or Decryption failed
+ k_EResultInsufficientPrivilege = 24, // Insufficient privilege
+ k_EResultLimitExceeded = 25, // Too much of a good thing
+ k_EResultRevoked = 26, // Access has been revoked (used for revoked guest passes)
+ k_EResultExpired = 27, // License/Guest pass the user is trying to access is expired
+ k_EResultAlreadyRedeemed = 28, // Guest pass has already been redeemed by account, cannot be acked again
+ k_EResultDuplicateRequest = 29, // The request is a duplicate and the action has already occurred in the past, ignored this time
+ k_EResultAlreadyOwned = 30, // All the games in this guest pass redemption request are already owned by the user
+ k_EResultIPNotFound = 31, // IP address not found
+ k_EResultPersistFailed = 32, // failed to write change to the data store
+ k_EResultLockingFailed = 33, // failed to acquire access lock for this operation
+ k_EResultLogonSessionReplaced = 34,
+ k_EResultConnectFailed = 35,
+ k_EResultHandshakeFailed = 36,
+ k_EResultIOFailure = 37,
+ k_EResultRemoteDisconnect = 38,
+ k_EResultShoppingCartNotFound = 39, // failed to find the shopping cart requested
+ k_EResultBlocked = 40, // a user didn't allow it
+ k_EResultIgnored = 41, // target is ignoring sender
+ k_EResultNoMatch = 42, // nothing matching the request found
+ k_EResultAccountDisabled = 43,
+ k_EResultServiceReadOnly = 44, // this service is not accepting content changes right now
+ k_EResultAccountNotFeatured = 45, // account doesn't have value, so this feature isn't available
+ k_EResultAdministratorOK = 46, // allowed to take this action, but only because requester is admin
+ k_EResultContentVersion = 47, // A Version mismatch in content transmitted within the Steam protocol.
+ k_EResultTryAnotherCM = 48, // The current CM can't service the user making a request, user should try another.
+ k_EResultPasswordRequiredToKickSession = 49,// You are already logged in elsewhere, this cached credential login has failed.
+ k_EResultAlreadyLoggedInElsewhere = 50, // You are already logged in elsewhere, you must wait
+ k_EResultSuspended = 51, // Long running operation (content download) suspended/paused
+ k_EResultCancelled = 52, // Operation canceled (typically by user: content download)
+ k_EResultDataCorruption = 53, // Operation canceled because data is ill formed or unrecoverable
+ k_EResultDiskFull = 54, // Operation canceled - not enough disk space.
+ k_EResultRemoteCallFailed = 55, // an remote call or IPC call failed
+ k_EResultPasswordUnset = 56, // Password could not be verified as it's unset server side
+ k_EResultExternalAccountUnlinked = 57, // External account (PSN, Facebook...) is not linked to a Steam account
+ k_EResultPSNTicketInvalid = 58, // PSN ticket was invalid
+ k_EResultExternalAccountAlreadyLinked = 59, // External account (PSN, Facebook...) is already linked to some other account, must explicitly request to replace/delete the link first
+ k_EResultRemoteFileConflict = 60, // The sync cannot resume due to a conflict between the local and remote files
+ k_EResultIllegalPassword = 61, // The requested new password is not legal
+ k_EResultSameAsPreviousValue = 62, // new value is the same as the old one ( secret question and answer )
+ k_EResultAccountLogonDenied = 63, // account login denied due to 2nd factor authentication failure
+ k_EResultCannotUseOldPassword = 64, // The requested new password is not legal
+ k_EResultInvalidLoginAuthCode = 65, // account login denied due to auth code invalid
+ k_EResultAccountLogonDeniedNoMail = 66, // account login denied due to 2nd factor auth failure - and no mail has been sent
+ k_EResultHardwareNotCapableOfIPT = 67, //
+ k_EResultIPTInitError = 68, //
+ k_EResultParentalControlRestricted = 69, // operation failed due to parental control restrictions for current user
+ k_EResultFacebookQueryError = 70, // Facebook query returned an error
+ k_EResultExpiredLoginAuthCode = 71, // account login denied due to auth code expired
+ k_EResultIPLoginRestrictionFailed = 72,
+ k_EResultAccountLockedDown = 73,
+ k_EResultAccountLogonDeniedVerifiedEmailRequired = 74,
+ k_EResultNoMatchingURL = 75,
+ k_EResultBadResponse = 76, // parse failure, missing field, etc.
+ k_EResultRequirePasswordReEntry = 77, // The user cannot complete the action until they re-enter their password
+ k_EResultValueOutOfRange = 78, // the value entered is outside the acceptable range
+ k_EResultUnexpectedError = 79, // something happened that we didn't expect to ever happen
+ k_EResultDisabled = 80, // The requested service has been configured to be unavailable
+ k_EResultInvalidCEGSubmission = 81, // The set of files submitted to the CEG server are not valid !
+ k_EResultRestrictedDevice = 82, // The device being used is not allowed to perform this action
+ k_EResultRegionLocked = 83, // The action could not be complete because it is region restricted
+ k_EResultRateLimitExceeded = 84, // Temporary rate limit exceeded, try again later, different from k_EResultLimitExceeded which may be permanent
+ k_EResultAccountLoginDeniedNeedTwoFactor = 85, // Need two-factor code to login
+ k_EResultItemDeleted = 86, // The thing we're trying to access has been deleted
+ k_EResultAccountLoginDeniedThrottle = 87, // login attempt failed, try to throttle response to possible attacker
+ k_EResultTwoFactorCodeMismatch = 88, // two factor code mismatch
+ k_EResultTwoFactorActivationCodeMismatch = 89, // activation code for two-factor didn't match
+ k_EResultAccountAssociatedToMultiplePartners = 90, // account has been associated with multiple partners
+ k_EResultNotModified = 91, // data not modified
+ k_EResultNoMobileDevice = 92, // the account does not have a mobile device associated with it
+ k_EResultTimeNotSynced = 93, // the time presented is out of range or tolerance
+ k_EResultSmsCodeFailed = 94, // SMS code failure (no match, none pending, etc.)
+ k_EResultAccountLimitExceeded = 95, // Too many accounts access this resource
+ k_EResultAccountActivityLimitExceeded = 96, // Too many changes to this account
+ k_EResultPhoneActivityLimitExceeded = 97, // Too many changes to this phone
+ k_EResultRefundToWallet = 98, // Cannot refund to payment method, must use wallet
+ k_EResultEmailSendFailure = 99, // Cannot send an email
+ k_EResultNotSettled = 100, // Can't perform operation till payment has settled
+ k_EResultNeedCaptcha = 101, // Needs to provide a valid captcha
+ k_EResultGSLTDenied = 102, // a game server login token owned by this token's owner has been banned
+ k_EResultGSOwnerDenied = 103, // game server owner is denied for other reason (account lock, community ban, vac ban, missing phone)
+ k_EResultInvalidItemType = 104, // the type of thing we were requested to act on is invalid
+ k_EResultIPBanned = 105, // the ip address has been banned from taking this action
+ k_EResultGSLTExpired = 106, // this token has expired from disuse; can be reset for use
+ k_EResultInsufficientFunds = 107, // user doesn't have enough wallet funds to complete the action
+ k_EResultTooManyPending = 108, // There are too many of this thing pending already
+ k_EResultNoSiteLicensesFound = 109, // No site licenses found
+ k_EResultWGNetworkSendExceeded = 110, // the WG couldn't send a response because we exceeded max network send size
+ k_EResultAccountNotFriends = 111, // the user is not mutually friends
+ k_EResultLimitedUserAccount = 112, // the user is limited
+ k_EResultCantRemoveItem = 113, // item can't be removed
+ k_EResultAccountDeleted = 114, // account has been deleted
+ k_EResultExistingUserCancelledLicense = 115, // A license for this already exists, but cancelled
+ k_EResultCommunityCooldown = 116, // access is denied because of a community cooldown (probably from support profile data resets)
+ k_EResultNoLauncherSpecified = 117, // No launcher was specified, but a launcher was needed to choose correct realm for operation.
+ k_EResultMustAgreeToSSA = 118, // User must agree to china SSA or global SSA before login
+ k_EResultLauncherMigrated = 119, // The specified launcher type is no longer supported; the user should be directed elsewhere
+ k_EResultSteamRealmMismatch = 120, // The user's realm does not match the realm of the requested resource
+ k_EResultInvalidSignature = 121, // signature check did not match
+ k_EResultParseFailure = 122, // Failed to parse input
+ k_EResultNoVerifiedPhone = 123, // account does not have a verified phone number
+} EResult;
+
+// Structures
+typedef struct {
+ u32 m_u32;
+ u64 m_u64;
+ u16 m_u16;
+ double m_d;
+} ValvePackingSentinel_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.)
+ u8 *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;
+ u32 m_cubParam;
+
+} SteamAPICallCompleted_t;
+
+// 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 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
+ u32 m_unAccountID : 32; // unique account identifier
+#else
+ u32 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;
+
+ u64 m_unAll64Bits;
+ };
+} CSteamID;
+
+typedef struct GameID_t
+{
+#ifdef VALVE_BIG_ENDIAN
+ unsigned int m_nModID : 32;
+ unsigned int m_nType : 8;
+ unsigned int m_nAppID : 24;
+#else
+ unsigned int m_nAppID : 24;
+ unsigned int m_nType : 8;
+ unsigned int m_nModID : 32;
+#endif
+} CGameID;
+
+#define SW_CBID_SteamAPICallCompleted (k_iSteamUtilsCallbacks + 3)
+
+typedef enum ESteamAPICallFailure
+{
+ k_ESteamAPICallFailureNone = -1, // no failure
+ k_ESteamAPICallFailureSteamGone = 0, // the local Steam process has gone away
+ k_ESteamAPICallFailureNetworkFailure = 1, // the network connection to Steam has been broken, or was already broken
+ // SteamServersDisconnected_t callback will be sent around the same time
+ // SteamServersConnected_t will be sent when the client is able to talk to the Steam servers again
+ k_ESteamAPICallFailureInvalidHandle = 2, // the SteamAPICall_t handle passed in no longer exists
+ k_ESteamAPICallFailureMismatchedCallback = 3,// GetAPICallResult() was called with the wrong callback type for this API call
+} ESteamAPICallFailure;
+
+typedef u64 UGCHandle_t;
+typedef u64 PublishedFileUpdateHandle_t;
+typedef u64 PublishedFileId_t;
+const PublishedFileId_t k_PublishedFileIdInvalid = 0;
+const UGCHandle_t k_UGCHandleInvalid = 0xffffffffffffffffull;
+const PublishedFileUpdateHandle_t k_PublishedFileUpdateHandleInvalid = 0xffffffffffffffffull;
+
+// Handle for writing to Steam Cloud
+typedef u64 UGCFileWriteStreamHandle_t;
+
+// size limit on stat or achievement name (UTF-8 encoded)
+enum { k_cchStatNameMax = 128 };
+
+// maximum number of bytes for a leaderboard name (UTF-8 encoded)
+enum { k_cchLeaderboardNameMax = 128 };
+
+// maximum number of details i32's storable for a single leaderboard entry
+enum { k_cLeaderboardDetailsMax = 64 };
+
+// handle to a single leaderboard
+typedef u64 SteamLeaderboard_t;
+
+// handle to a set of downloaded entries in a leaderboard
+typedef u64 SteamLeaderboardEntries_t;
+
+// type of data request, when downloading leaderboard entries
+typedef enum ELeaderboardDataRequest
+{
+ k_ELeaderboardDataRequestGlobal = 0,
+ k_ELeaderboardDataRequestGlobalAroundUser = 1,
+ k_ELeaderboardDataRequestFriends = 2,
+ k_ELeaderboardDataRequestUsers = 3
+} ELeaderboardDataRequest;
+
+// the sort order of a leaderboard
+typedef enum ELeaderboardSortMethod
+{
+ k_ELeaderboardSortMethodNone = 0,
+ k_ELeaderboardSortMethodAscending = 1, // top-score is lowest number
+ k_ELeaderboardSortMethodDescending = 2, // top-score is highest number
+} ELeaderboardSortMethod;
+
+// the display type (used by the Steam Community web site) for a leaderboard
+typedef enum ELeaderboardDisplayType
+{
+ k_ELeaderboardDisplayTypeNone = 0,
+ k_ELeaderboardDisplayTypeNumeric = 1, // simple numerical score
+ k_ELeaderboardDisplayTypeTimeSeconds = 2, // the score represents a time, in seconds
+ k_ELeaderboardDisplayTypeTimeMilliSeconds = 3, // the score represents a time, in milliseconds
+} ELeaderboardDisplayType;
+
+typedef enum ELeaderboardUploadScoreMethod
+{
+ k_ELeaderboardUploadScoreMethodNone = 0,
+ k_ELeaderboardUploadScoreMethodKeepBest = 1, // Leaderboard will keep user's best score
+ k_ELeaderboardUploadScoreMethodForceUpdate = 2, // Leaderboard will always replace score with specified
+} ELeaderboardUploadScoreMethod;
+
+// a single entry in a leaderboard, as returned by GetDownloadedLeaderboardEntry()
+typedef struct LeaderboardEntry_t
+{
+ CSteamID m_steamIDUser; // user with the entry - use SteamFriends()->GetFriendPersonaName() & SteamFriends()->GetFriendAvatar() to get more info
+ i32 m_nGlobalRank; // [1..N], where N is the number of users with an entry in the leaderboard
+ i32 m_nScore; // score as set in the leaderboard
+ i32 m_cDetails; // number of i32 details available for this entry
+ UGCHandle_t m_hUGC; // handle for UGC attached to the entry
+} LeaderboardEntry_t;
+
+//-----------------------------------------------------------------------------
+// Purpose: called when the latests stats and achievements have been received
+// from the server
+//-----------------------------------------------------------------------------
+typedef struct UserStatsReceived_t
+{
+ u64 m_nGameID; // Game these stats are for
+ EResult m_eResult; // Success / error fetching the stats
+ CSteamID m_steamIDUser; // The user for whom the stats are retrieved for
+} UserStatsReceived_t;
+#define SW_CBID_UserStatsReceived (k_iSteamUserStatsCallbacks + 1)
+
+//-----------------------------------------------------------------------------
+// Purpose: result of a request to store the user stats for a game
+//-----------------------------------------------------------------------------
+typedef struct UserStatsStored_t
+{
+ u64 m_nGameID; // Game these stats are for
+ EResult m_eResult; // success / error
+} UserStatsStored_t;
+#define SW_CBID_UserStatsStored (k_iSteamUserStatsCallbacks + 2)
+
+//-----------------------------------------------------------------------------
+// Purpose: result of a request to store the achievements for a game, or an
+// "indicate progress" call. If both m_nCurProgress and m_nMaxProgress
+// are zero, that means the achievement has been fully unlocked.
+//-----------------------------------------------------------------------------
+typedef struct UserAchievementStored_t
+{
+ u64 m_nGameID; // Game this is for
+ int m_bGroupAchievement; // if this is a "group" achievement
+ char m_rgchAchievementName[k_cchStatNameMax]; // name of the achievement
+ u32 m_nCurProgress; // current progress towards the achievement
+ u32 m_nMaxProgress; // "out of" this many
+} UserAchievementStored_t;
+#define SW_CBID_UserAchievementStored (k_iSteamUserStatsCallbacks + 3)
+
+//-----------------------------------------------------------------------------
+// Purpose: call result for finding a leaderboard, returned as a result of FindOrCreateLeaderboard() or FindLeaderboard()
+// use CCallResult<> to map this async result to a member function
+//-----------------------------------------------------------------------------
+typedef struct LeaderboardFindResult_t
+{
+ SteamLeaderboard_t m_hSteamLeaderboard; // handle to the leaderboard serarched for, 0 if no leaderboard found
+ u8 m_bLeaderboardFound; // 0 if no leaderboard found
+} LeaderboardFindResult_t;
+#define SW_CBID_LeaderboardFindResult (k_iSteamUserStatsCallbacks + 4)
+
+//-----------------------------------------------------------------------------
+// Purpose: call result indicating scores for a leaderboard have been downloaded and are ready to be retrieved, returned as a result of DownloadLeaderboardEntries()
+// use CCallResult<> to map this async result to a member function
+//-----------------------------------------------------------------------------
+typedef struct LeaderboardScoresDownloaded_t
+{
+ SteamLeaderboard_t m_hSteamLeaderboard;
+ SteamLeaderboardEntries_t m_hSteamLeaderboardEntries; // the handle to pass into GetDownloadedLeaderboardEntries()
+ int m_cEntryCount; // the number of entries downloaded
+} LeaderboardScoresDownloaded_t;
+#define SW_CBID_LeaderboardScoresDownloaded (k_iSteamUserStatsCallbacks + 5)
+
+//-----------------------------------------------------------------------------
+// Purpose: call result indicating scores has been uploaded, returned as a result of UploadLeaderboardScore()
+// use CCallResult<> to map this async result to a member function
+//-----------------------------------------------------------------------------
+typedef struct LeaderboardScoreUploaded_t
+{
+ u8 m_bSuccess; // 1 if the call was successful
+ SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was
+ i32 m_nScore; // the score that was attempted to set
+ u8 m_bScoreChanged; // true if the score in the leaderboard change, false if the existing score was better
+ int m_nGlobalRankNew; // the new global rank of the user in this leaderboard
+ int m_nGlobalRankPrevious; // the previous global rank of the user in this leaderboard; 0 if the user had no existing entry in the leaderboard
+} LeaderboardScoreUploaded_t;
+#define SW_CBID_LeaderboardScoreUploaded (k_iSteamUserStatsCallbacks + 6)
+
+typedef struct NumberOfCurrentPlayers_t
+{
+ u8 m_bSuccess; // 1 if the call was successful
+ i32 m_cPlayers; // Number of players currently playing
+} NumberOfCurrentPlayers_t;
+#define SW_CBID_NumberOfCurrentPlayers (k_iSteamUserStatsCallbacks + 7)
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback indicating that a user's stats have been unloaded.
+// Call RequestUserStats again to access stats for this user
+//-----------------------------------------------------------------------------
+typedef struct UserStatsUnloaded_t
+{
+ CSteamID m_steamIDUser; // User whose stats have been unloaded
+} UserStatsUnloaded_t;
+#define SW_CBID_UserStatsUnloaded (k_iSteamUserStatsCallbacks + 8)
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback indicating that an achievement icon has been fetched
+//-----------------------------------------------------------------------------
+typedef struct UserAchievementIconFetched_t
+{
+ CGameID m_nGameID; // Game this is for
+ char m_rgchAchievementName[k_cchStatNameMax]; // name of the achievement
+ int m_bAchieved; // Is the icon for the achieved or not achieved version?
+ int m_nIconHandle; // Handle to the image, which can be used in SteamUtils()->GetImageRGBA(), 0 means no image is set for the achievement
+} UserAchievementIconFetched_t;
+#define SW_CBID_UserAchievementIconFetched (k_iSteamUserStatsCallbacks + 9)
+
+//-----------------------------------------------------------------------------
+// Purpose: Callback indicating that global achievement percentages are fetched
+//-----------------------------------------------------------------------------
+typedef struct GlobalAchievementPercentagesReady_t
+{
+ u64 m_nGameID; // Game this is for
+ EResult m_eResult; // Result of the operation
+} GlobalAchievementPercentagesReady_t;
+#define SW_CBID_GlobalAchievementPercentagesReady (k_iSteamUserStatsCallbacks + 10)
+
+//-----------------------------------------------------------------------------
+// Purpose: call result indicating UGC has been uploaded, returned as a result of SetLeaderboardUGC()
+//-----------------------------------------------------------------------------
+typedef struct LeaderboardUGCSet_t
+{
+ EResult m_eResult; // The result of the operation
+ SteamLeaderboard_t m_hSteamLeaderboard; // the leaderboard handle that was
+} LeaderboardUGCSet_t;
+#define SW_CBID_LeaderboardUGCSet (k_iSteamUserStatsCallbacks + 11)
+
+//-----------------------------------------------------------------------------
+// Purpose: callback indicating that PS3 trophies have been installed
+//-----------------------------------------------------------------------------
+typedef struct PS3TrophiesInstalled_t
+{
+ u64 m_nGameID; // Game these stats are for
+ EResult m_eResult; // The result of the operation
+ u64 m_ulRequiredDiskSpace; // If m_eResult is k_EResultDiskFull, will contain the amount of space needed to install trophies
+
+} PS3TrophiesInstalled_t;
+#define SW_CBID_TrophiesInstalled (k_iSteamUserStatsCallbacks + 12)
+
+//-----------------------------------------------------------------------------
+// Purpose: callback indicating global stats have been received.
+// Returned as a result of RequestGlobalStats()
+//-----------------------------------------------------------------------------
+typedef struct GlobalStatsReceived_t
+{
+ u64 m_nGameID; // Game global stats were requested for
+ EResult m_eResult; // The result of the request
+} GlobalStatsReceived_t;
+#define SW_CBID_GlobalStatsReceived (k_iSteamUserStatsCallbacks + 12)
+
+#pragma pack( pop )
+
+// API
+void SteamAPI_Shutdown();
+int SteamAPI_Init();
+int SteamAPI_RestartAppIfNecessary( u32 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 );
+void SteamAPI_ReleaseCurrentThreadMemory();
+
+int SteamAPI_ISteamUserStats_SetAchievement( ISteamUserStats *self, const char *pchName );
+
+ESteamAPICallFailure SteamAPI_ISteamUtils_GetAPICallFailureReason( ISteamUtils* self, SteamAPICall_t hSteamAPICall );
+
+// Friends
+char *SteamAPI_ISteamFriends_GetPersonaName( ISteamFriends *self );
+const char *SteamAPI_ISteamFriends_GetFriendPersonaName( ISteamFriends *self, u64_steamid steamIDFriend );
+u64_steamid SteamAPI_ISteamUser_GetSteamID( ISteamUser *self );
+int SteamAPI_ISteamFriends_GetSmallFriendAvatar( ISteamFriends *self, u64_steamid steamIDFriend ); // 32x32
+int SteamAPI_ISteamUtils_GetImageSize( ISteamUtils *self, int iImage, u32 *pnWidth, u32 *pnHeight );
+int SteamAPI_ISteamUtils_GetImageRGBA( ISteamUtils *self, int iImage, u8 *pubDest, int nDestBufferSize );
+
+// Leaderboards
+SteamAPICall_t SteamAPI_ISteamUserStats_FindOrCreateLeaderboard( ISteamUserStats* self, const char * pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType );
+SteamAPICall_t SteamAPI_ISteamUserStats_FindLeaderboard( ISteamUserStats* self, const char * pchLeaderboardName );
+const char * SteamAPI_ISteamUserStats_GetLeaderboardName( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard );
+int SteamAPI_ISteamUserStats_GetLeaderboardEntryCount( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard );
+ELeaderboardSortMethod SteamAPI_ISteamUserStats_GetLeaderboardSortMethod( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard );
+ELeaderboardDisplayType SteamAPI_ISteamUserStats_GetLeaderboardDisplayType( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard );
+SteamAPICall_t SteamAPI_ISteamUserStats_DownloadLeaderboardEntries( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd );
+SteamAPICall_t SteamAPI_ISteamUserStats_DownloadLeaderboardEntriesForUsers( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard, CSteamID * prgUsers, int cUsers );
+int SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry( ISteamUserStats* self, SteamLeaderboardEntries_t hSteamLeaderboardEntries, int index, LeaderboardEntry_t * pLeaderboardEntry, i32 * pDetails, int cDetailsMax );
+SteamAPICall_t SteamAPI_ISteamUserStats_UploadLeaderboardScore( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, i32 nScore, const i32 * pScoreDetails, int cScoreDetailsCount );
+SteamAPICall_t SteamAPI_ISteamUserStats_AttachLeaderboardUGC( ISteamUserStats* self, SteamLeaderboard_t hSteamLeaderboard, UGCHandle_t hUGC );
+
+#define sw_get_image_size(...) SteamAPI_ISteamUtils_GetImageSize( steam_api_classes.utils, __VA_ARGS__ )
+#define sw_get_image_rgba(...) SteamAPI_ISteamUtils_GetImageRGBA( steam_api_classes.utils, __VA_ARGS__ )
+#define sw_get_small_friend_avatar(...) SteamAPI_ISteamFriends_GetSmallFriendAvatar( steam_api_classes.friends, __VA_ARGS__ )
+#define sw_get_steamid() SteamAPI_ISteamUser_GetSteamID( steam_api_classes.friends )
+#define sw_get_friend_persona_name(...) SteamAPI_ISteamFriends_GetFriendPersonaName( steam_api_classes.friends, __VA_ARGS__ )
+#define sw_get_persona_name() SteamAPI_ISteamFriends_GetPersonaName( steam_api_classes.friends )
+#define sw_find_leaderboard(...) SteamAPI_ISteamUserStats_FindLeaderboard( steam_api_classes.stats, __VA_ARGS__ );
+#define sw_get_leaderboard_name(...) SteamAPI_ISteamUserStats_GetLeaderboardName( steam_api_classes.stats, __VA_ARGS__ )
+#define sw_download_leaderboard_entries(...) SteamAPI_ISteamUserStats_DownloadLeaderboardEntries( steam_api_classes.stats, __VA_ARGS__ )
+#define sw_get_downloaded_entry(...) SteamAPI_ISteamUserStats_GetDownloadedLeaderboardEntry( steam_api_classes.stats, __VA_ARGS__ )
+#define sw_upload_leaderboard_score(...) SteamAPI_ISteamUserStats_UploadLeaderboardScore( steam_api_classes.stats, __VA_ARGS__ )
+
+HSteamPipe SteamAPI_GetHSteamPipe();
+HSteamUser SteamAPI_GetHSteamUser();
+
+struct
+{
+ ISteamFriends *friends;
+ ISteamUser *user;
+ ISteamUserStats *stats;
+ ISteamNetworking *net;
+ ISteamUtils *utils;
+
+ HSteamPipe pipe;
+
+ struct cached_player
+ {
+ u64_steamid id;
+ GLuint avatar_texture; // tex_unkown.name
+
+ struct cached_player *l, *r;
+ }
+ cached_players[20];
+
+ struct cached_player *cache_head, *cache_tail;
+
+ u32 cache_count;
+
+} steam_api_classes;
+
+static void _sw_cache_push( struct cached_player *player )
+{
+ player->l = NULL;
+ player->r = steam_api_classes.cache_head;
+ if( steam_api_classes.cache_head ) steam_api_classes.cache_head->l = player;
+ if( !steam_api_classes.cache_tail ) steam_api_classes.cache_tail = player;
+ steam_api_classes.cache_head = player;
+ steam_api_classes.cache_count ++;
+}
+
+static void _sw_cache_evict( struct cached_player *player )
+{
+ if( player == steam_api_classes.cache_tail ) steam_api_classes.cache_tail = player->l;
+ if( player == steam_api_classes.cache_head ) steam_api_classes.cache_head = player->r;
+ if( player->l ) player->l->r = player->r;
+ if( player->r ) player->r->l = player->l;
+ steam_api_classes.cache_count --;
+}
+
+static void _sw_access_cache( struct cached_player *player )
+{
+ _sw_cache_evict( player );
+ _sw_cache_push( player );
+}
+
+static GLuint sw_get_player_image( u64_steamid usr )
+{
+ // Look for player in cache
+ for( int i = 0; i < steam_api_classes.cache_count; i ++ )
+ {
+ struct cached_player *player = &steam_api_classes.cached_players[i];
+
+ if( player->id == usr )
+ {
+ _sw_access_cache( player );
+ return player->avatar_texture;
+ }
+ }
+
+ struct cached_player *dest;
+
+ if( steam_api_classes.cache_count == vg_list_size( steam_api_classes.cached_players ) )
+ {
+ dest = steam_api_classes.cache_tail;
+ _sw_access_cache( dest );
+
+ // Delete previous before creating a new one
+ glDeleteTextures( 1, &dest->avatar_texture );
+ }
+ else
+ {
+ dest = &steam_api_classes.cached_players[ steam_api_classes.cache_count ];
+ _sw_cache_push( dest );
+ }
+
+ dest->id = usr;
+ dest->avatar_texture = 0;
+
+ // Upload new image
+ u32 x = 32, y = 32;
+ int steam_image;
+
+ steam_image = sw_get_small_friend_avatar( usr );
+ if( !steam_image )
+ return 0;
+
+ if( !sw_get_image_size( steam_image, &x, &y ) )
+ return 0;
+
+ u8 * img_buf = (u8 *)malloc( x * y * 4 );
+
+ if( !sw_get_image_rgba(steam_image, img_buf, x * y * 4) )
+ {
+ free( img_buf );
+ return 0;
+ }
+
+ glGenTextures( 1, &dest->avatar_texture );
+ glBindTexture( GL_TEXTURE_2D, dest->avatar_texture );
+
+ 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 dest->avatar_texture;
+}
+
+ISteamFriends *SteamAPI_SteamFriends_v017();
+ISteamUser *SteamAPI_SteamUser_v021();
+ISteamUserStats *SteamAPI_SteamUserStats_v012();
+ISteamNetworking *SteamAPI_SteamNetworking_v006();
+ISteamUtils *SteamAPI_SteamUtils_v010();
+
+static void sw_exit(void)
+{
+ SteamAPI_Shutdown();
+}
+
+// Needs to be manually called by client unfortunately
+static void sw_free_opengl(void)
+{
+ for( int i = 0; i < steam_api_classes.cache_count; i ++ )
+ if( steam_api_classes.cached_players[i].avatar_texture )
+ glDeleteTextures( 1, &steam_api_classes.cached_players[i].avatar_texture );
+}
+
+static int sw_init(void)
+{
+ #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;
+ }
+ #else
+ 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;
+ }
+ #endif
+
+ vg_info( "Intializing steamworks\n" );
+
+ if( SteamAPI_RestartAppIfNecessary( VG_STEAM_APPID ) == 1 )
+ {
+ vg_info( "Restarting app via steam\n" );
+ return 0;
+ }
+
+ if( !SteamAPI_Init() )
+ {
+ vg_error( "Steamworks connection failed\n" );
+ return 0;
+ }
+
+ SteamAPI_ManualDispatch_Init();
+
+ steam_api_classes.friends = SteamAPI_SteamFriends_v017();
+ steam_api_classes.user = SteamAPI_SteamUser_v021();
+ steam_api_classes.stats = SteamAPI_SteamUserStats_v012();
+ steam_api_classes.net = SteamAPI_SteamNetworking_v006();
+ steam_api_classes.utils = SteamAPI_SteamUtils_v010();
+
+ if( !steam_api_classes.friends || !steam_api_classes.user || !steam_api_classes.stats || !steam_api_classes.net || !steam_api_classes.utils )
+ {
+ vg_error( "Steamworks interface pointers failed. Steamworks DLL may be old\n" );
+ SteamAPI_Shutdown();
+ return 0;
+ }
+
+ steam_api_classes.pipe = SteamAPI_GetHSteamPipe();
+ vg_success( "Steamworks API running\n" );
+
+ vg_register_exit( &sw_exit, "SteamAPI" );
+ return 1;
+}
+
+
+void (*sw_leaderboard_found)( LeaderboardFindResult_t *pCallback );
+void (*sw_leaderboard_downloaded)( LeaderboardScoresDownloaded_t *pCallback );
+
+static void sw_event_loop(void)
+{
+ SteamAPI_ManualDispatch_RunFrame( steam_api_classes.pipe );
+ CallbackMsg_t callback;
+
+ while( SteamAPI_ManualDispatch_GetNextCallback( steam_api_classes.pipe, &callback ) )
+ {
+ vg_info( "steamworks_event::callback( %i )\n", callback.m_iCallback );
+
+ // Check for dispatching API call results
+ if( callback.m_iCallback == SW_CBID_SteamAPICallCompleted ){
+
+ SteamAPICallCompleted_t *pCallCompleted = (SteamAPICallCompleted_t *)callback.m_pubParam;
+ void *pTmpCallResult = malloc( pCallCompleted->m_cubParam );
+ int bFailed;
+
+ if( SteamAPI_ManualDispatch_GetAPICallResult(
+ steam_api_classes.pipe,
+ 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
+
+ vg_info( "steamworks_event::api_call_completed( %lu )\n", pCallCompleted->m_hAsyncCall );
+
+ switch( pCallCompleted->m_iCallback )
+ {
+ case SW_CBID_LeaderboardFindResult:
+ if( sw_leaderboard_found ) sw_leaderboard_found( (LeaderboardFindResult_t*)pTmpCallResult );
+ break;
+ case SW_CBID_LeaderboardScoresDownloaded:
+ if( sw_leaderboard_downloaded ) sw_leaderboard_downloaded( (LeaderboardScoresDownloaded_t*)pTmpCallResult );
+ break;
+ default:break;
+ }
+ }
+ else
+ {
+ typedef enum ESteamAPICallFailure
+ {
+ k_ESteamAPICallFailureNone = -1, // no failure
+ k_ESteamAPICallFailureSteamGone = 0, // the local Steam process has gone away
+ k_ESteamAPICallFailureNetworkFailure = 1, // the network connection to Steam has been broken, or was already broken
+ // SteamServersDisconnected_t callback will be sent around the same time
+ // SteamServersConnected_t will be sent when the client is able to talk to the Steam servers again
+ k_ESteamAPICallFailureInvalidHandle = 2, // the SteamAPICall_t handle passed in no longer exists
+ k_ESteamAPICallFailureMismatchedCallback = 3,// GetAPICallResult() was called with the wrong callback type for this API call
+ } ESteamAPICallFailure;
+
+ ESteamAPICallFailure fail_why =
+ SteamAPI_ISteamUtils_GetAPICallFailureReason( steam_api_classes.utils, pCallCompleted->m_hAsyncCall );
+
+ vg_error( "steamworks_event: error getting call result on %lu (code %d)\n", pCallCompleted->m_hAsyncCall, fail_why );
+ }
+
+ free( pTmpCallResult );
+ }
+ else
+ {
+ // Look at callback.m_iCallback to see what kind of callback it is,
+ // and dispatch to appropriate handler(s)
+ //void *data = callback.m_pubParam;
+
+ switch( callback.m_iCallback )
+ {
+ default: break;
+ }
+ }
+
+ SteamAPI_ManualDispatch_FreeLastCallback( steam_api_classes.pipe );
+ }
+}
+
+static void sw_set_achievement( const char *vg_ach_name )
+{
+ struct vg_achievement *ach = NULL;
+
+ for( int i = 0; i < vg_list_size( vg_achievements ); i ++ )
+ if( !strcmp( vg_ach_name, vg_achievements[i].name ) )
+ ach = &vg_achievements[i];
+
+ if( !ach->is_set )
+ {
+ SteamAPI_ISteamUserStats_SetAchievement( steam_api_classes.stats, vg_ach_name );
+ ach->is_set = 1;
+ vg_success( "Achievement set: '%s'\n", vg_ach_name );
+ }
+}
projects / fishladder.git / blobdiff