From 0ebbd7e9a06107c9c6163aebcb1387a68b0aad1c Mon Sep 17 00:00:00 2001 From: Michael Dirks Date: Sat, 6 Feb 2016 00:17:29 +0100 Subject: [PATCH] BlitzSteam update 06.02.2016 --- Blitz/BlitzSteam.bb | 589 +++++++++++++++++++++++------ Blitz/BlitzSteam.decls | 263 ++++++++----- Blitz/BlitzSteamUtility.bb | 20 +- dllmain.cpp => BlitzSteam.cpp | 2 +- BlitzSteam.h | 40 ++ BlitzSteam.vcxproj | 46 +-- BlitzSteam.vcxproj.filters | 18 +- Helpers/BlitzPointer.h | 12 +- Helpers/CSteamID.cpp | 78 ++-- Helpers/CSteamID.h | 79 ++-- Helpers/Callbacks.cpp | 63 ++- Helpers/Callbacks.h | 29 ++ Helpers/Helper.cpp | 27 ++ dllmain.h => Helpers/Helper.h | 19 +- Wrapper/Steam.cpp | 158 ++------ Wrapper/SteamAppList.cpp | 17 +- Wrapper/SteamApps.cpp | 56 +-- Wrapper/SteamClient.cpp | 77 ++-- Wrapper/SteamController.cpp | 19 +- Wrapper/SteamFriends.cpp | 167 ++++---- Wrapper/SteamGameServer.cpp | 283 ++++++++++++-- Wrapper/SteamGameServerStats.cpp | 63 +++ Wrapper/SteamHTMLSurface.cpp | 23 ++ Wrapper/SteamHTTP.cpp | 28 ++ Wrapper/SteamInventory.cpp | 28 ++ Wrapper/SteamMatchmaking.cpp | 23 ++ Wrapper/SteamMatchmakingServer.cpp | 23 ++ Wrapper/SteamMusic.cpp | 23 ++ Wrapper/SteamMusicRemote.cpp | 23 ++ Wrapper/SteamNetworking.cpp | 67 ++++ Wrapper/SteamRemoteStorage.cpp | 23 ++ Wrapper/SteamScreenshots.cpp | 23 ++ Wrapper/SteamUGC.cpp | 28 ++ Wrapper/SteamUnifiedMessages.cpp | 23 ++ Wrapper/SteamUser.cpp | 59 +-- Wrapper/SteamUserStats.cpp | 93 ++--- Wrapper/SteamUtils.cpp | 23 ++ Wrapper/SteamVideo.cpp | 23 ++ 38 files changed, 1871 insertions(+), 787 deletions(-) rename dllmain.cpp => BlitzSteam.cpp (97%) create mode 100644 BlitzSteam.h create mode 100644 Helpers/Helper.cpp rename dllmain.h => Helpers/Helper.h (69%) diff --git a/Blitz/BlitzSteam.bb b/Blitz/BlitzSteam.bb index 273e278..fee960f 100644 --- a/Blitz/BlitzSteam.bb +++ b/Blitz/BlitzSteam.bb @@ -12,11 +12,32 @@ ; GNU General Public License for more details. ; ; You should have received a copy of the GNU Lesser General Public License -; along with this program. If not, see . +; along with this program. If not, see . -; Steam ------------------------------------------------------------------------- +;------------------------------------------------------------------------------ +;! Enumeration - EDenyReason +;------------------------------------------------------------------------------ +; Result codes to GSHandleClientDeny/Kick +Const BS_EDenyReason_Invalid = 0 +Const BS_EDenyReason_InvalidVersion = 1 +Const BS_EDenyReason_Generic = 2 +Const BS_EDenyReason_NotLoggedOn = 3 +Const BS_EDenyReason_NoLicense = 4 +Const BS_EDenyReason_Cheater = 5 +Const BS_EDenyReason_LoggedInElseWhere = 6 +Const BS_EDenyReason_UnknownText = 7 +Const BS_EDenyReason_IncompatibleAnticheat = 8 +Const BS_EDenyReason_MemoryCorruption = 9 +Const BS_EDenyReason_IncompatibleSoftware = 10 +Const BS_EDenyReason_SteamConnectionLost = 11 +Const BS_EDenyReason_SteamConnectionError = 12 +Const BS_EDenyReason_SteamResponseTimedOut = 13 +Const BS_EDenyReason_SteamValidationStalled = 14 +Const BS_EDenyReason_SteamOwnerLeftGuestUser = 15 -; SteamClient ------------------------------------------------------------------- +;------------------------------------------------------------------------------ +;! Enumeration - EAccountType +;------------------------------------------------------------------------------ Const BS_EAccountType_Invalid = 0 Const BS_EAccountType_Individual = 1 Const BS_EAccountType_Multiseat = 2 @@ -29,6 +50,19 @@ Const BS_EAccountType_Chat = 8 Const BS_EAccountType_ConsoleUser = 9 Const BS_EAccountType_AnonUser = 10 +;------------------------------------------------------------------------------ +;! Enumeration - EBeginAuthSessionResult +;------------------------------------------------------------------------------ +Const BS_EBeginAuthSessionResult_OK = 0 ; Ticket is valid for this game and this steamID. +Const BS_EBeginAuthSessionResult_InvalidTicket = 1 ; Ticket is not valid. +Const BS_EBeginAuthSessionResult_DuplicateRequest = 2 ; A ticket has already been submitted for this steamID +Const BS_EBeginAuthSessionResult_InvalidVersion = 3 ; Ticket is from an incompatible interface version +Const BS_EBeginAuthSessionResult_GameMismatch = 4 ; Ticket is not for this game +Const BS_EBeginAuthSessionResult_ExpiredTicket = 5 ; Ticket has expired + +;------------------------------------------------------------------------------ +;! Enumeration - ECallback +;------------------------------------------------------------------------------ Const BS_ECallback_SteamAppListCallbacks = 3900 Const BS_ECallback_SteamAppsCallbacks = 1000 Const BS_ECallback_SteamBillingCallbacks = 400 @@ -75,22 +109,311 @@ Const BS_ECallback_ClientUnifiedMessagesCallbacks = 2500 Const BS_ECallback_ClientUserCallbacks = 900 Const BS_ECallback_ClientUtilsCallbacks = 1600 Const BS_ECallback_ClientVideoCallbacks = 4600 -Const BS_ECallback_ClientVRCallbacks = 4200 +Const BS_ECallback_ClientVRCallbacks = 4200 -; SteamAppList ------------------------------------------------------------------ +;------------------------------------------------------------------------------ +;! Enumeration - EFriendRelationShip +;------------------------------------------------------------------------------ +Const BS_EFriendRelationShip_None = 0 +Const BS_EFriendRelationShip_Blocked = 1 +Const BS_EFriendRelationShip_RequestRecipient = 2 +Const BS_EFriendRelationShip_Friend = 3 +Const BS_EFriendRelationShip_RequestInitiator = 4 +Const BS_EFriendRelationShip_Ignored = 5 +Const BS_EFriendRelationShip_IgnoredFriend = 6 +Const BS_EFriendRelationShip_Suggested = 7 + +;------------------------------------------------------------------------------ +;! Enumeration - EFriendFlags +;------------------------------------------------------------------------------ +Const BS_EFriendFlags_None = $00000000 +Const BS_EFriendFlags_Blocked = $00000001 +Const BS_EFriendFlags_FriendshipRequested = $00000002 +Const BS_EFriendFlags_Immediate = $00000004 +Const BS_EFriendFlags_ClanMember = $00000008 +Const BS_EFriendFlags_OnGameServer = $00000010 +Const BS_EFriendFlags_RequestingFriendship = $00000080 +Const BS_EFriendFlags_RequestingInfo = $00000100 +Const BS_EFriendFlags_Ignored = $00000200 +Const BS_EFriendFlags_IgnoredFriend = $00000400 +Const BS_EFriendFlags_Suggested = $00000800 +Const BS_EFriendFlags_All = $0000FFFF + +;------------------------------------------------------------------------------ +;! Enumeration - ELeaderboardDataRequest +;------------------------------------------------------------------------------ +Const BS_ELeaderboardDataRequest_Global = 0 +Const BS_ELeaderboardDataRequest_GlobalAroundUser = 1 +Const BS_ELeaderboardDataRequest_Friends = 2 +Const BS_ELeaderboardDataRequest_Users = 3 + +;------------------------------------------------------------------------------ +;! Enumeration - ELeaderboardDisplayType +;------------------------------------------------------------------------------ +Const BS_ELeaderboardDisplayType_None = 0 +Const BS_ELeaderboardDisplayType_Numeric = 1 ; simple numerical score +Const BS_ELeaderboardDisplayType_TimeSeconds = 2 ; the score represents a time, in seconds +Const BS_ELeaderboardDisplayType_TimeMilliSeconds = 3 ; the score represents a time, in milliseconds + +;------------------------------------------------------------------------------ +;! Enumeration - ELeaderboardSortMethod +;------------------------------------------------------------------------------ +Const BS_ELeaderboardSortMethod_None = 0 +Const BS_ELeaderboardSortMethod_Ascending = 1 ; top-score is lowest number +Const BS_ELeaderboardSortMethod_Descending = 2 ; top-score is highest number + +;------------------------------------------------------------------------------ +;! Enumeration - ELeaderboardUploadScoreMethod +;------------------------------------------------------------------------------ +Const BS_ELeaderboardUploadScoreMethod_None = 0 +Const BS_ELeaderboardUploadScoreMethod_KeepBest = 1 ; Leaderboard will keep user's best score +Const BS_ELeaderboardUploadScoreMethod_ForceUpdate = 2 ; Leaderboard will always replace score with specified + +;------------------------------------------------------------------------------ +;! Enumeration - EOverlayToStoreFlag +;------------------------------------------------------------------------------ +Const BS_EOverlayToStoreFlag_None = 0 +Const BS_EOverlayToStoreFlag_AddToCart = 1 +Const BS_EOverlayToStoreFlag_AddToCartAndShow = 2 + +;------------------------------------------------------------------------------ +;! Enumeration - EPersonaChange +;------------------------------------------------------------------------------ +Const BS_EPersonaChange_Name = $0001 +Const BS_EPersonaChange_Status = $0002 +Const BS_EPersonaChange_ComeOnline = $0004 +Const BS_EPersonaChange_GoneOffline = $0008 +Const BS_EPersonaChange_GamePlayed = $0010 +Const BS_EPersonaChange_GameServer = $0020 +Const BS_EPersonaChange_Avatar = $0040 +Const BS_EPersonaChange_JoinedSource = $0080 +Const BS_EPersonaChange_LeftSource = $0100 +Const BS_EPersonaChange_RelationshipChanged = $0200 +Const BS_EPersonaChange_NameFirstSet = $0400 +Const BS_EPersonaChange_FacebookInfo = $0800 +Const BS_EPersonaChange_Nickname = $1000 +Const BS_EPersonaChange_SteamLevel = $2000 + +;------------------------------------------------------------------------------ +;! Enumeration - EPersonaState +;------------------------------------------------------------------------------ +Const BS_EPersonaState_Offline = 0 +Const BS_EPersonaState_Online = 1 +Const BS_EPersonaState_Busy = 2 +Const BS_EPersonaState_Away = 3 +Const BS_EPersonaState_Snooze = 4 +Const BS_EPersonaState_LookingToTrade = 5 +Const BS_EPersonaState_LookingToPlay = 6 + +;------------------------------------------------------------------------------ +;! Enumeration - EP2PSend +;------------------------------------------------------------------------------ +; SendP2PPacket() send types +; Typically k_EP2PSendUnreliable is what you want for UDP-like packets, k_EP2PSendReliable for TCP-like packets + ; 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. +Const BS_EP2PSend_Unreliable = 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 +Const BS_EP2PSend_UnreliableNoDelay = 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. +Const BS_EP2PSend_Reliable = 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. +Const BS_EP2PSend_ReliableWithBuffering = 3 + +;------------------------------------------------------------------------------ +;! Enumeration - EP2PSessionError +;------------------------------------------------------------------------------ +; list of possible errors returned by SendP2PPacket() API +; these will be posted in the P2PSessionConnectFail_t callback +Const BS_EP2PSessionError_None = 0 +Const BS_EP2PSessionError_NotRunningApp = 1 ; target is not running the same game +Const BS_EP2PSessionError_NoRightsToApp = 2 ; local user doesn't own the app that is running +Const BS_EP2PSessionError_DestinationNotLoggedIn = 3 ; target user isn't connected to Steam +Const BS_EP2PSessionError_Timeout = 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 +Const BS_EP2PSessionError_Max = 5 + +;------------------------------------------------------------------------------ +;! Enumeration - EResult +;------------------------------------------------------------------------------ +Const BS_EResult_OK = 1 ; success +Const BS_EResult_Fail = 2 ; generic failure +Const BS_EResult_NoConnection = 3 ; no/failed network connection +Const BS_EResult_NoConnectionRetry = 4 ; OBSOLETE - removed +Const BS_EResult_InvalidPassword = 5 ; password/ticket is invalid +Const BS_EResult_LoggedInElsewhere = 6 ; same user logged in elsewhere +Const BS_EResult_InvalidProtocolVer = 7 ; protocol version is incorrect +Const BS_EResult_InvalidParam = 8 ; a parameter is incorrect +Const BS_EResult_FileNotFound = 9 ; file was not found +Const BS_EResult_Busy = 10 ; called method busy - action not taken +Const BS_EResult_InvalidState = 11 ; called object was in an invalid state +Const BS_EResult_InvalidName = 12 ; name is invalid +Const BS_EResult_InvalidEmail = 13 ; email is invalid +Const BS_EResult_DuplicateName = 14 ; name is not unique +Const BS_EResult_AccessDenied = 15 ; access is denied +Const BS_EResult_Timeout = 16 ; operation timed out +Const BS_EResult_Banned = 17 ; VAC2 banned +Const BS_EResult_AccountNotFound = 18 ; account not found +Const BS_EResult_InvalidSteamID = 19 ; steamID is invalid +Const BS_EResult_ServiceUnavailable = 20 ; The requested service is currently unavailable +Const BS_EResult_NotLoggedOn = 21 ; The user is not logged on +Const BS_EResult_Pending = 22 ; Request is pending (may be in process, or waiting on third party) +Const BS_EResult_EncryptionFailure = 23 ; Encryption or Decryption failed +Const BS_EResult_InsufficientPrivilege = 24 ; Insufficient privilege +Const BS_EResult_LimitExceeded = 25 ; Too much of a good thing +Const BS_EResult_Revoked = 26 ; Access has been revoked (used for revoked guest passes) +Const BS_EResult_Expired = 27 ; License/Guest pass the user is trying to access is expired +Const BS_EResult_AlreadyRedeemed = 28 ; Guest pass has already been redeemed by account, cannot be acked again +Const BS_EResult_DuplicateRequest = 29 ; The request is a duplicate and the action has already occurred in the past, ignored this time +Const BS_EResult_AlreadyOwned = 30 ; All the games in this guest pass redemption request are already owned by the user +Const BS_EResult_IPNotFound = 31 ; IP address not found +Const BS_EResult_PersistFailed = 32 ; failed to write change to the data store +Const BS_EResult_LockingFailed = 33 ; failed to acquire access lock for this operation +Const BS_EResult_LogonSessionReplaced = 34 +Const BS_EResult_ConnectFailed = 35 +Const BS_EResult_HandshakeFailed = 36 +Const BS_EResult_IOFailure = 37 +Const BS_EResult_RemoteDisconnect = 38 +Const BS_EResult_ShoppingCartNotFound = 39 ; failed to find the shopping cart requested +Const BS_EResult_Blocked = 40 ; a user didn't allow it +Const BS_EResult_Ignored = 41 ; target is ignoring sender +Const BS_EResult_NoMatch = 42 ; nothing matching the request found +Const BS_EResult_AccountDisabled = 43 +Const BS_EResult_ServiceReadOnly = 44 ; this service is not accepting content changes right now +Const BS_EResult_AccountNotFeatured = 45 ; account doesn't have value, so this feature isn't available +Const BS_EResult_AdministratorOK = 46 ; allowed to take this action, but only because requester is admin +Const BS_EResult_ContentVersion = 47 ; A Version mismatch in content transmitted within the Steam protocol. +Const BS_EResult_TryAnotherCM = 48 ; The current CM can't service the user making a request, user should try another. +Const BS_EResult_PasswordRequiredToKickSession = 49 ; You are already logged in elsewhere, this cached credential login has failed. +Const BS_EResult_AlreadyLoggedInElsewhere = 50 ; You are already logged in elsewhere, you must wait +Const BS_EResult_Suspended = 51 ; Long running operation (content download) suspended/paused +Const BS_EResult_Cancelled = 52 ; Operation canceled (typically by user: content download) +Const BS_EResult_DataCorruption = 53 ; Operation canceled because data is ill formed or unrecoverable +Const BS_EResult_DiskFull = 54 ; Operation canceled - not enough disk space. +Const BS_EResult_RemoteCallFailed = 55 ; an remote call or IPC call failed +Const BS_EResult_PasswordUnset = 56 ; Password could not be verified as it's unset server side +Const BS_EResult_ExternalAccountUnlinked = 57 ; External account (PSN, Facebook...) is not linked to a Steam account +Const BS_EResult_PSNTicketInvalid = 58 ; PSN ticket was invalid +Const BS_EResult_ExternalAccountAlreadyLinked = 59 ; External account (PSN, Facebook...) is already linked to some other account, must explicitly request to replace/delete the link first +Const BS_EResult_RemoteFileConflict = 60 ; The sync cannot resume due to a conflict between the local and remote files +Const BS_EResult_IllegalPassword = 61 ; The requested new password is not legal +Const BS_EResult_SameAsPreviousValue = 62 ; new value is the same as the old one ( secret question and answer ) +Const BS_EResult_AccountLogonDenied = 63 ; account login denied due to 2nd factor authentication failure +Const BS_EResult_CannotUseOldPassword = 64 ; The requested new password is not legal +Const BS_EResult_InvalidLoginAuthCode = 65 ; account login denied due to auth code invalid +Const BS_EResult_AccountLogonDeniedNoMail = 66 ; account login denied due to 2nd factor auth failure - and no mail has been sent +Const BS_EResult_HardwareNotCapableOfIPT = 67 +Const BS_EResult_IPTInitError = 68 +Const BS_EResult_ParentalControlRestricted = 69 ; operation failed due to parental control restrictions for current user +Const BS_EResult_FacebookQueryError = 70 ; Facebook query returned an error +Const BS_EResult_ExpiredLoginAuthCode = 71 ; account login denied due to auth code expired +Const BS_EResult_IPLoginRestrictionFailed = 72 +Const BS_EResult_AccountLockedDown = 73 +Const BS_EResult_AccountLogonDeniedVerifiedEmailRequired = 74 +Const BS_EResult_NoMatchingURL = 75 +Const BS_EResult_BadResponse = 76 ; parse failure, missing field, etc. +Const BS_EResult_RequirePasswordReEntry = 77 ; The user cannot complete the action until they re-enter their password +Const BS_EResult_ValueOutOfRange = 78 ; the value entered is outside the acceptable range +Const BS_EResult_UnexpectedError = 79 ; something happened that we didn't expect to ever happen +Const BS_EResult_Disabled = 80 ; The requested service has been configured to be unavailable +Const BS_EResult_InvalidCEGSubmission = 81 ; The set of files submitted to the CEG server are not valid ! +Const BS_EResult_RestrictedDevice = 82 ; The device being used is not allowed to perform this action +Const BS_EResult_RegionLocked = 83 ; The action could not be complete because it is region restricted +Const BS_EResult_RateLimitExceeded = 84 ; Temporary rate limit exceeded, try again later, different from k_EResultLimitExceeded which may be permanent +Const BS_EResult_AccountLoginDeniedNeedTwoFactor = 85 ; Need two-factor code to login +Const BS_EResult_ItemDeleted = 86 ; The thing we're trying to access has been deleted +Const BS_EResult_AccountLoginDeniedThrottle = 87 ; login attempt failed, try to throttle response to possible attacker +Const BS_EResult_TwoFactorCodeMismatch = 88 ; two factor code mismatch +Const BS_EResult_TwoFactorActivationCodeMismatch = 89 ; activation code for two-factor didn't match +Const BS_EResult_AccountAssociatedToMultiplePartners = 90 ; account has been associated with multiple partners +Const BS_EResult_NotModified = 91 ; data not modified +Const BS_EResult_NoMobileDevice = 92 ; the account does not have a mobile device associated with it +Const BS_EResult_TimeNotSynced = 93 ; the time presented is out of range or tolerance +Const BS_EResult_SmsCodeFailed = 94 ; SMS code failure (no match, none pending, etc.) +Const BS_EResult_AccountLimitExceeded = 95 ; Too many accounts access this resource +Const BS_EResult_AccountActivityLimitExceeded = 96 ; Too many changes to this account +Const BS_EResult_PhoneActivityLimitExceeded = 97 ; Too many changes to this phone +Const BS_EResult_RefundToWallet = 98 ; Cannot refund to payment method, must use wallet +Const BS_EResult_EmailSendFailure = 99 ; Cannot send an email +Const BS_EResult_NotSettled = 100 ; Can't perform operation till payment has settled +Const BS_EResult_NeedCaptcha = 101 ; Needs to provide a valid captcha + +;------------------------------------------------------------------------------ +;! Enumeration - EServerMode +;------------------------------------------------------------------------------ +Const BS_EServerMode_Invalid = 0 +Const BS_EServerMode_NoAuthentication = 1 +Const BS_EServerMode_Authentication = 2 +Const BS_EServerMode_AuthenticationAndSecure = 3 + +;------------------------------------------------------------------------------ +;! Enumeration - EServerFlag +;------------------------------------------------------------------------------ +Const BS_EServerFlag_None = $00 +Const BS_EServerFlag_Active = $01 ; Server has Users playing +Const BS_EServerFlag_Secure = $02 ; Server wants to be Secure +Const BS_EServerFlag_Dedicated = $04 ; Server is Dedicated +Const BS_EServerFlag_Linux = $08 ; Linux Build +Const BS_EServerFlag_Passworded = $10 ; Password Protected +Const BS_EServerFlag_Private = $20 ; server shouldn't list on master server and + ; won't enforce authentication of users that connect to the server. + ; Useful when you run a server where the clients may not + ; be connected to the internet but you want them to play (i.e LANs) + +;------------------------------------------------------------------------------ +;! Enumeration - EUserHasLicenseResult +;------------------------------------------------------------------------------ +Const BS_EUserHasLicenseResult_HasLicense = 0 ; User has a license for specified app +Const BS_EUserHasLicenseResult_DoesNotHaveLicense = 1 ; User does not have a license for the specified app +Const BS_EUserHasLicenseResult_NoAuth = 2 ; User has not been authenticated + +;------------------------------------------------------------------------------ +;! Enumeration - EUserRestriction +;------------------------------------------------------------------------------ +Const BS_EUserRestrictionNone = 0 +Const BS_EUserRestrictionUnknown = 1 +Const BS_EUserRestrictionAnyChat = 2 +Const BS_EUserRestrictionVoiceChat = 4 +Const BS_EUserRestrictionGroupChat = 8 +Const BS_EUserRestrictionRating = 16 +Const BS_EUserRestrictionGameInvites = 32 +Const BS_EUserRestrictionTrading = 64 + +;------------------------------------------------------------------------------ +;! Enumeration - EVoiceResult +;------------------------------------------------------------------------------ +Const BS_EVoiceResult_OK = 0 +Const BS_EVoiceResult_NotInitialized = 1 +Const BS_EVoiceResult_NotRecording = 2 +Const BS_EVoiceResult_NoData = 3 +Const BS_EVoiceResult_BufferTooSmall = 4 +Const BS_EVoiceResult_DataCorrupted = 5 +Const BS_EVoiceResult_Restricted = 6 +Const BS_EVoiceResult_UnsupportedCodec = 7 +Const BS_EVoiceResult_ReceiverOutOfDate = 8 +Const BS_EVoiceResult_ReceiverDidNotAnswer = 9 + + + +;[Block] Old +;! AppList --------------------------------------------------------------------- Const BS_CALLBACK_AppInstalled = BS_ECallback_SteamAppListCallbacks + 1 Const BS_CALLBACK_AppUninstalled = BS_ECallback_SteamAppListCallbacks + 2 - - -; SteamApps --------------------------------------------------------------------- +;! Apps ------------------------------------------------------------------------ Const BS_CALLBACK_DLCInstalled = BS_ECallback_SteamAppsCallbacks + 5 Const BS_CALLBACK_APPProofOfPurchaseKeyResponse = BS_ECallback_SteamAppsCallbacks + 13 Const BS_CALLBACK_NewLaunchQueryParameters = BS_ECallback_SteamAppsCallbacks + 14 -; The following things are PS3 only: -; ERegisterActivationCodeResult -; RegisterActivationCodeResponse_t -; SteamController --------------------------------------------------------------- +;! Controller ------------------------------------------------------------------ Const BS_MASK_RIGHT_TRIGGER = $00000001 Const BS_MASK_LEFT_TRIGGER = $00000002 Const BS_MASK_RIGHT_BUMPER = $00000004 @@ -123,37 +446,7 @@ Type BS_ControllerState Field sRightPadXY ; Left/High = X, Right/Low = Y End Type -; SteamFriends ------------------------------------------------------------------ -Const BS_EFriendRelationShip_None = 0 -Const BS_EFriendRelationShip_Blocked = 1 -Const BS_EFriendRelationShip_RequestRecipient = 2 -Const BS_EFriendRelationShip_Friend = 3 -Const BS_EFriendRelationShip_RequestInitiator = 4 -Const BS_EFriendRelationShip_Ignored = 5 -Const BS_EFriendRelationShip_IgnoredFriend = 6 -Const BS_EFriendRelationShip_Suggested = 7 - -Const BS_EPersonaState_Offline = 0 -Const BS_EPersonaState_Online = 1 -Const BS_EPersonaState_Busy = 2 -Const BS_EPersonaState_Away = 3 -Const BS_EPersonaState_Snooze = 4 -Const BS_EPersonaState_LookingToTrade = 5 -Const BS_EPersonaState_LookingToPlay = 6 - -Const BS_EFriendFlags_None = $00000000 -Const BS_EFriendFlags_Blocked = $00000001 -Const BS_EFriendFlags_FriendshipRequested = $00000002 -Const BS_EFriendFlags_Immediate = $00000004 -Const BS_EFriendFlags_ClanMember = $00000008 -Const BS_EFriendFlags_OnGameServer = $00000010 -Const BS_EFriendFlags_RequestingFriendship = $00000080 -Const BS_EFriendFlags_RequestingInfo = $00000100 -Const BS_EFriendFlags_Ignored = $00000200 -Const BS_EFriendFlags_IgnoredFriend = $00000400 -Const BS_EFriendFlags_Suggested = $00000800 -Const BS_EFriendFlags_All = $0000FFFF - +;! Friends --------------------------------------------------------------------- Const BS_cchMaxFriendsGroupName = 64 Const BS_cFriendsGroupLimit = 100 Const BS_FriendsGroupID_Invalid = -1 @@ -168,14 +461,6 @@ Type BS_FriendGameInfo Field m_steamIDLobby% End Type -Const BS_EUserRestrictionNone = 0 -Const BS_EUserRestrictionUnknown = 1 -Const BS_EUserRestrictionAnyChat = 2 -Const BS_EUserRestrictionVoiceChat = 4 -Const BS_EUserRestrictionGroupChat = 8 -Const BS_EUserRestrictionRating = 16 -Const BS_EUserRestrictionGameInvites = 32 -Const BS_EUserRestrictionTrading = 64 Type BS_FriendSessionStateInfo Field m_uiOnlineSessionInstances @@ -187,24 +472,6 @@ Const BS_cchMaxRichPresenceKeys = 20 Const BS_cchMaxRichPresenceKeyLength = 64 Const BS_cchMaxRichPresenceValueLength = 256 -Const BS_EOverlayToStoreFlag_None = 0 -Const BS_EOverlayToStoreFlag_AddToCart = 1 -Const BS_EOverlayToStoreFlag_AddToCartAndShow = 2 - -Const BS_EPersonaChange_Name = $0001 -Const BS_EPersonaChange_Status = $0002 -Const BS_EPersonaChange_ComeOnline = $0004 -Const BS_EPersonaChange_GoneOffline = $0008 -Const BS_EPersonaChange_GamePlayed = $0010 -Const BS_EPersonaChange_GameServer = $0020 -Const BS_EPersonaChange_Avatar = $0040 -Const BS_EPersonaChange_JoinedSource = $0080 -Const BS_EPersonaChange_LeftSource = $0100 -Const BS_EPersonaChange_RelationshipChanged = $0200 -Const BS_EPersonaChange_NameFirstSet = $0400 -Const BS_EPersonaChange_FacebookInfo = $0800 -Const BS_EPersonaChange_Nickname = $1000 -Const BS_EPersonaChange_SteamLevel = $2000 Const BS_CALLBACK_PersonaStateChange = BS_ECallback_SteamFriendsCallbacks + 4 Const BS_CALLBACK_GameOverlayActivated = BS_ECallback_SteamFriendsCallbacks + 31 @@ -225,57 +492,132 @@ Const BS_CALLBACK_FriendsIsFollowing = BS_ECallback_SteamFriendsCallbacks + Const BS_CALLBACK_FriendsEnumerateFollowingList = BS_ECallback_SteamFriendsCallbacks + 46 Const BS_CALLBACK_SetPersonaNameResponse = BS_ECallback_SteamFriendsCallbacks + 47 -; SteamGameServer --------------------------------------------------------------- -Const BS_EServerMode_Invalid = 0 -Const BS_EServerMode_NoAuthentication = 1 -Const BS_EServerMode_Authentication = 2 -Const BS_EServerMode_AuthenticationAndSecure = 3 +;! GameServer ------------------------------------------------------------------ -; SteamUser --------------------------------------------------------------------- -Const BS_EVoiceResult_OK = 0 -Const BS_EVoiceResult_NotInitialized = 1 -Const BS_EVoiceResult_NotRecording = 2 -Const BS_EVoiceResult_NoData = 3 -Const BS_EVoiceResult_BufferTooSmall = 4 -Const BS_EVoiceResult_DataCorrupted = 5 -Const BS_EVoiceResult_Restricted = 6 -Const BS_EVoiceResult_UnsupportedCodec = 7 -Const BS_EVoiceResult_ReceiverOutOfDate = 8 -Const BS_EVoiceResult_ReceiverDidNotAnswer = 9 +; client has been approved to connect to this game server +Const BS_CALLBACK_GSClientApprove = BS_ECallback_SteamGameServerCallbacks + 1 +Type BS_GSClientApprove_t + Field SteamIDHigh%, SteamIDLow% ; SteamID of approved player + Field OwnerSteamIDHigh%, OwnerSteamIDLow% ; SteamID of original owner for game license +End Type -Const BS_EBeginAuthSessionResult_OK = 0 ; Ticket is valid for this game and this steamID. -Const BS_EBeginAuthSessionResult_InvalidTicket = 1 ; Ticket is not valid. -Const BS_EBeginAuthSessionResult_DuplicateRequest = 2 ; A ticket has already been submitted for this steamID -Const BS_EBeginAuthSessionResult_InvalidVersion = 3 ; Ticket is from an incompatible interface version -Const BS_EBeginAuthSessionResult_GameMismatch = 4 ; Ticket is not for this game -Const BS_EBeginAuthSessionResult_ExpiredTicket = 5 ; Ticket has expired +; client has been denied to connection to this game server +Const BS_CALLBACK_GSClientDeny = BS_ECallback_SteamGameServerCallbacks + 2 +Type BS_GSClientDeny_t + Field SteamIDHigh%, SteamIDLow% + Field eDenyReason%, pad0% + Field rgchOptionalText%[31] ; 128 Bytes of Optional Text +End Type -Const BS_EUserHasLicenseResult_HasLicense = 0 ; User has a license for specified app -Const BS_EUserHasLicenseResult_DoesNotHaveLicense = 1 ; User does not have a license for the specified app -Const BS_EUserHasLicenseResult_NoAuth = 2 ; User has not been authenticated +; request the game server should kick the user +Const BS_CALLBACK_GSClientKick = BS_ECallback_SteamGameServerCallbacks + 3 +Type BS_GSClientKick_t + Field SteamIDHigh%, SteamIDLow% + Field eDenyReason%, pad0% +End Type -; SteamUserStats ---------------------------------------------------------------- +; client achievement info +Const BS_CALLBACK_GSClientAchievementStatus = BS_ECallback_SteamGameServerCallbacks + 6 +Type BS_GSClientAchievementStatus_t + Field SteamIDHigh%, SteamIDLow% + Field pchAchievement[31] ; 128 byte C-String Achievement + Field bUnlocked%, pad0% +End Type + +; received when the game server requests to be displayed as secure (VAC protected) +; m_bSecure is true if the game server should display itself as secure to users, false otherwise +Const BS_CALLBACK_GSPolicyResponse = BS_ECallback_SteamUserCallbacks + 15 +Type BS_GSPolicyResponse_t + Field m_bSecure%, pad0% +End Type + +; GS gameplay stats info +Const BS_CALLBACK_GSGameplayStats = BS_ECallback_SteamGameServerCallbacks + 7 +Type BS_GSGameplayStats_t + Field eResult%, pad0% ; Result of the call + Field nRank%, pad1% ; Overall rank of the server (0-based) + Field unTotalConnects%, pad2% ; Total number of clients who have ever connected to the server + Field unTotalMinutesPlayed%, pad3% ; Total number of minutes ever played on the server +End Type + +; send as a reply to RequestUserGroupStatus() +Const BS_CALLBACK_GSClientGroupStatus = BS_ECallback_SteamGameServerCallbacks + 8 +Type BS_GSClientGroupStatus_t + Field SteamIDUserHigh%, SteamIDUserLow% + Field SteamIDGroupHigh%, SteamIDGroupLow% + Field bMember%, pad0% + Field bOfficer%, pad1% +End Type + +; Sent as a reply to GetServerReputation() +Const BS_CALLBACK_GSReputation = BS_ECallback_SteamGameServerCallbacks + 9 +Type BS_GSReputation_t + Field eResult%, pad0% ; Result of the call + Field unReputationScore%, pad1% ; The reputation score for the game server + Field bBanned%, pad2% ; True if the server is banned from the Steam + ; master servers + + ; The following members are only filled out if m_bBanned is true. They will all + ; be set to zero otherwise. Master server bans are by IP so it is possible to be + ; banned even when the score is good high if there is a bad server on another port. + ; This information can be used to determine which server is bad. + Field unBannedIP%, pad3% ; The IP of the banned server + Field usBannedPort%, pad4% ; The port of the banned server + Field ulBannedGameIDHigh%, ulBannedGameIDLow% ; The game ID the banned server is serving + Field unBanExpires%, pad5% ; Time the ban expires, expressed in the Unix epoch (seconds since 1/1/1970) +End Type + +; Sent as a reply to AssociateWithClan() +Const BS_CALLBACK_AssociateWithClanResult = BS_ECallback_SteamGameServerCallbacks + 10 +Type BS_AssociateWithClanResult_t + Field eResult% ; Result of the call +End Type + +; Sent as a reply to ComputeNewPlayerCompatibility() +Const BS_CALLBACK_ComputeNewPlayerCompatibilityResult = BS_ECallback_SteamGameServerCallbacks + 11 +Type BS_ComputeNewPlayerCompatibilityResult_t + Field eResult%, pad0% ; Result of the call + Field cPlayersThatDontLikeCandidate%, pad1% + Field cPlayersThatCandidateDoesntLike%, pad2% + Field cClanPlayersThatDontLikeCandidate%, pad3% + Field SteamIDCandidateHigh%, SteamIDCandidateLow% +End Type + +;! Networking ------------------------------------------------------------------ + +Type BS_P2PSessionState_t + Field bConnectionActive%, pad0% + Field bConnecting%, pad1% + Field eP2PSessionError%, pad2% + Field bUsingRelay%, pad3% + Field nBytesQueuedForSend%, pad4% + Field nPacketsQueuedForSend%, pad5% + Field nRemoteIP%, pad6% + Field nRemotePort%, pad7% +End Type + +; 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 +Const BS_CALLBACK_P2PSessionRequest = BS_ECallback_SteamNetworkingCallbacks + 2 +Type BS_P2PSessionRequest_t + Field steamIDRemoteHigh%, steamIDRemoteLow% ; user who wants to talk to us +End Type + +; 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) +Const BS_CALLBACK_P2PSessionConnectFail = BS_ECallback_SteamNetworkingCallbacks + 3 +Type BS_P2PSessionConnectFail_t + Field steamIDRemoteHigh%, steamIDRemoteLow% ; user we were sending packets to + Field eP2PSessionError ; EP2PSessionError indicating why we're having trouble +End Type + +;! User ------------------------------------------------------------------------ + +;! UserStats ------------------------------------------------------------------- Const BS_cchStatNameMax = 128 Const BS_cchLeaderboardNameMax = 128 -Const BS_k_cLeaderboardDetailsMax = 64 - -Const BS_ELeaderboardDataRequest_Global = 0 -Const BS_ELeaderboardDataRequest_GlobalAroundUser = 1 -Const BS_ELeaderboardDataRequest_Friends = 2 -Const BS_ELeaderboardDataRequest_Users = 3 - -Const BS_ELeaderboardSortMethod_None = 0 -Const BS_ELeaderboardSortMethod_Ascending = 1 ; top-score is lowest number -Const BS_ELeaderboardSortMethod_Descending = 2 ; top-score is highest number - -Const BS_ELeaderboardDisplayType_None = 0 -Const BS_ELeaderboardDisplayType_Numeric = 1 ; simple numerical score -Const BS_ELeaderboardDisplayType_TimeSeconds = 2 ; the score represents a time, in seconds -Const BS_ELeaderboardDisplayType_TimeMilliSeconds = 3 ; the score represents a time, in milliseconds - -Const BS_ELeaderboardUploadScoreMethod_None = 0 -Const BS_ELeaderboardUploadScoreMethod_KeepBest = 1 ; Leaderboard will keep user's best score -Const BS_ELeaderboardUploadScoreMethod_ForceUpdate = 2 ; Leaderboard will always replace score with specified +Const BS_cLeaderboardDetailsMax = 64 Type BS_LeaderboardEntry Field SteamId_High%, SteamId_Low% @@ -309,8 +651,8 @@ End Type Const BS_CALLBACK_LeaderboardFindResult = BS_ECallback_SteamUserStatsCallbacks + 4 Type BS_LeaderboardFindResult - Field hSteamLeaderboard_High%, hSteamLeaderboard_Low% ; // handle to the leaderboard serarched for, 0 if no leaderboard found - Field bLeaderboardFound% ; // 0 if no leaderboard found + Field hSteamLeaderboard_High%, hSteamLeaderboard_Low% ; handle to the leaderboard serarched for, 0 if no leaderboard found + Field bLeaderboardFound% ; 0 if no leaderboard found End Type Const BS_CALLBACK_LeaderboardScoresDownloaded = BS_ECallback_SteamUserStatsCallbacks + 5 @@ -336,12 +678,12 @@ Type BS_NumberOfCurrentPlayers Field cPlayers ; Number of players currently playing End Type -Const BS_CALLBACK_UserStatsUnloaded = BS_ECallback_SteamUserStatsCallback + 8 +Const BS_CALLBACK_UserStatsUnloaded = BS_ECallback_SteamUserStatsCallbacks + 8 Type BS_UserStatsUnloaded Field steamIDUser_High, steamIDUser_Low ; User whose stats have been unloaded End Type -Const BS_CALLBACK_UserAchievementIconFetched = BS_ECallback_SteamUserStatsCallback + 9 +Const BS_CALLBACK_UserAchievementIconFetched = BS_ECallback_SteamUserStatsCallbacks + 9 Type BS_UserAchievementIconFetched Field nGameID_High, nGameID_Low ; Game this is for Field rgchAchievementName[BS_cchStatNameMax] ; name of the achievement @@ -349,20 +691,25 @@ Type BS_UserAchievementIconFetched Field nIconHandle ; Handle to the image, which can be used in SteamUtils()->GetImageRGBA(), 0 means no image is set for the achievement End Type -Const BS_CALLBACK_GlobalAchievementPercentagesReady = BS_ECallback_SteamUserStatsCallback + 10 +Const BS_CALLBACK_GlobalAchievementPercentagesReady = BS_ECallback_SteamUserStatsCallbacks + 10 Type BS_GlobalAchievementPercentagesReady Field nGameID_High, nGameID_Low ; Game this is for Field eResult ; Result of the operation End Type -Const BS_CALLBACK_LeaderboardUGCSet = BS_ECallback_SteamUserStatsCallback + 11 +Const BS_CALLBACK_LeaderboardUGCSet = BS_ECallback_SteamUserStatsCallbacks + 11 Type BS_LeaderboardUGCSet Field eResult ; The result of the operation Field hSteamLeaderboard_High, hSteamLeaderboard_Low ; the leaderboard handle that was End Type -Const BS_CALLBACK_GlobalStatsReceived = BS_ECallback_SteamUserStatsCallback + 12 +Const BS_CALLBACK_GlobalStatsReceived = BS_ECallback_SteamUserStatsCallbacks + 12 Type BS_GlobalStatsReceived Field nGameID_High, nGameId_Low ; Game global stats were requested for Field eResult ; The result of the request End Type + +;[End Block] +;~IDEal Editor Parameters: +;~F#196#1B9 +;~C#Blitz3D \ No newline at end of file diff --git a/Blitz/BlitzSteam.decls b/Blitz/BlitzSteam.decls index b1f391e..d04c3e4 100644 --- a/Blitz/BlitzSteam.decls +++ b/Blitz/BlitzSteam.decls @@ -15,85 +15,23 @@ ; along with this program. If not, see . .lib "BlitzSteam.dll" -; Helpers ----------------------------------------------------------------------- -; -- CSteamID -BS_CSteamID_New%() -BS_CSteamID_FromID%(unAccountID%, eUniverse%, eAccountType%) -BS_CSteamID_FromIDInstance%(unAccountID%, unInstance%, eUniverse%, eAccountType%) -BS_CSteamID_FromSteamID%(ulSteamID%) -BS_CSteamID_Copy%(pSteamID%) -BS_CSteamID_Destroy(pSteamID%) -BS_CSteamID_Set(pSteamID%, unAccountID%, eUniverse%, eAccountType%) -BS_CSteamID_InstancedSet(pSteamID%, unAccountID%, unInstance%, eUniverse%, eAccountType%) -BS_CSteamID_FullSet(pSteamID%, ulIdentifier%, eUniverse%, eAccountType%) -BS_CSteamID_SetFromUInt64(pSteamID%, ulSteamID%) -BS_CSteamID_Clear(pSteamID%) -BS_CSteamID_ConvertToUInt64%(pSteamID%) -BS_CSteamID_GetStaticAccountKey%(pSteamID%) -BS_CSteamID_CreateBlankAnonLogon(pSteamID%, eUniverse%) -BS_CSteamID_CreateBlankAnonUserLogon(pSteamID%, eUniverse%) -BS_CSteamID_BlankAnonAccount%(pSteamID%) -BS_CSteamID_GameServerAccount%(pSteamID%) -BS_CSteamID_PersistentGameServerAccount%(pSteamID%) -BS_CSteamID_AnonGameServerAccount%(pSteamID%) -BS_CSteamID_ContentServerAccount%(pSteamID%) -BS_CSteamID_ClanAccount%(pSteamID%) -BS_CSteamID_ChatAccount%(pSteamID%) -BS_CSteamID_IsLobby%(pSteamID%) -BS_CSteamID_IndividualAccount%(pSteamID%) -BS_CSteamID_AnonAccount%(pSteamID%) -BS_CSteamID_AnonUserAccount%(pSteamID%) -BS_CSteamID_ConsoleUserAccount%(pSteamID%) -BS_CSteamID_SetAccountID(pSteamID%, unAccountID%) -BS_CSteamID_SetAccountInstance(pSteamID, unInstance%) -BS_CSteamID_ClearIndividualInstance(pSteamID%) -BS_CSteamID_HasNoIndividualInstance%(pSteamID%) -BS_CSteamID_GetAccountID%(pSteamID%) -BS_CSteamID_GetAccountInstance%(pSteamID%) -BS_CSteamID_GetEAccountType%(pSteamID%) -BS_CSteamID_GetEUniverse%(pSteamID%) -BS_CSteamID_SetEUniverse(pSteamID%, eUniverse%) -BS_CSteamID_IsValid%(pSteamID%) -BS_CSteamID_Compare%(pSteamID%, pSteamIDOther%) -; Steam ------------------------------------------------------------------------- -BS_Init%() -BS_Shutdown() -BS_IsSteamRunning%() -BS_RestartAppIfNecessary%(unOwnAppID%) -BS_SetMiniDumpComment(pchMsg$) -BS_WriteMiniDump(uStructuredExceptionCode%, pvExceptionInfo*, uBuildID%) -BS_WriteMiniDumpEx(uStructuredExceptionCode%, pvExceptionInfo%, uBuildID%) : "BS_WriteMiniDump" -; -- Interfaces +; Steam ----------------------------------------------------------------------- +BS_Steam_Init%() +BS_Steam_Shutdown() +BS_Steam_IsSteamRunning%() +BS_Steam_RestartAppIfNecessary%(unOwnAppID%) +BS_Steam_SetMiniDumpComment(pchMsg$) +BS_Steam_WriteMiniDump(uStructuredExceptionCode%, pvExceptionInfo*, uBuildID%) +BS_Steam_WriteMiniDumpEx(uStructuredExceptionCode%, pvExceptionInfo%, uBuildID%) : "BS_WriteMiniDump" +BS_Steam_RunCallbacks() +BS_Steam_RegisterCallback(pCallback%, iCallback%) +BS_Steam_UnregisterCallback(pCallback%) +BS_Steam_RegisterCallResult(pCallback%, hAPICall_L%, hAPICall_R%) +BS_Steam_UnregisterCallResult(pCallback%, hAPICall_L%, hAPICall_R%) + +; AppList --------------------------------------------------------------------- BS_AppList%() -BS_Apps%() -BS_Client%() -BS_Controller%() -BS_Friends%() -BS_HTTP%() -BS_HTMLSurface%() -BS_Inventory%() -BS_Matchmaking%() -BS_MatchmakingServers%() -BS_Music%() -BS_MusicRemote%() -BS_Networking%() -BS_RemoteStorage%() -BS_Screenshots%() -BS_UGC%() -BS_UnifiedMessages%() -BS_User%() -BS_UserStats%() -BS_Utils%() -BS_Video%() -; -- Callbacks & Hooks -BS_RunCallbacks() -BS_RegisterCallback(pCallback%, iCallback%) -BS_UnregisterCallback(pCallback%) -BS_RegisterCallResult(pCallback%, hAPICall_L%, hAPICall_R%) -BS_UnregisterCallResult(pCallback%, hAPICall_L%, hAPICall_R%) - -; SteamAppList ------------------------------------------------------------------ BS_AppList_GetNumInstalledApps%(lpSteamAppList%) BS_AppList_GetInstalledApps%(lpSteamAppList%, pvecAppID*, unMaxIDs%) BS_AppList_GetInstalledAppsEx%(lpSteamAppList%, pvecAppID%, unMaxIDs%) : "BS_AppList_GetInstalledApps" @@ -103,7 +41,8 @@ BS_AppList_GetAppInstallDir%(lpSteamAppList%, nAppId%, pchDirectory*, cchDirecto BS_AppList_GetAppInstallDirEx%(lpSteamAppList%, nAppId%, pchDirectory%, cchDirectoryMax%) : "BS_AppList_GetAppInstallDir" BS_AppList_GetAppBuildId%(lpSteamAppList%, nAppId%) -; SteamApps --------------------------------------------------------------------- +; Apps ------------------------------------------------------------------------ +BS_Apps%() BS_Apps_IsSubscribed%(lpSteamApps%) BS_Apps_IsLowViolence%(lpSteamApps%) BS_Apps_IsCybercafe%(lpSteamApps%) @@ -134,7 +73,8 @@ BS_Apps_GetDlcDownloadProgress%(lpSteamApps%, nAppID%, punBytesDownloaded*, punB BS_Apps_GetDlcDownloadProgressEx%(lpSteamApps%, nAppID%, punBytesDownloaded%, punBytesTotal%) : "BS_Apps_GetDlcDownloadProgress" BS_Apps_GetAppBuildId%(lpSteamApps%) -; SteamClient ------------------------------------------------------------------- +; Client ---------------------------------------------------------------------- +BS_Client%() BS_Client_CreateSteamPipe%(lpSteamClient%) BS_Client_ReleaseSteamPipe%(lpSteamClient%, hSteamPipe%) BS_Client_ConnectToGlobalUser%(lpSteamClient%, hSteamPipe%) @@ -144,7 +84,6 @@ BS_Client_ReleaseUser(lpSteamClient%, hSteamPipe%, hSteamUser%) BS_Client_RunFrame(lpSteamClient%) BS_Client_GetIPCCallCount%(lpSteamClient%) BS_Client_ShutdownIfAllPipesClosed%(lpSteamClient%) -; -- Interfaces BS_Client_GetSteamAppList%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$) BS_Client_GetSteamApps%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$) BS_Client_GetSteamController%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$) @@ -167,13 +106,13 @@ BS_Client_GetSteamUser%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$) BS_Client_GetSteamUserStats%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$) BS_Client_GetSteamUtils%(lpSteamClient%, hSteamPipe%, pchVersion$) BS_Client_GetSteamVideo%(lpSteamClient%, hSteamUser%, hSteamPipe%, pchVersion$) -; -- Callbacks & Hooks BS_Client_SetWarningMessageHook(lpSteamClient%, fpFunction%) BS_Client_Set_SteamAPI_CPostAPIResultInProcess(lpSteamClient%, fpFunction%) BS_Client_Remove_SteamAPI_CPostAPIResultInProcess(lpSteamClient%, fpFunction%) BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess(lpSteamClient%, fpFunction%) -; SteamController --------------------------------------------------------------- +; Controller ------------------------------------------------------------------ +BS_Controller%() BS_Controller_Init%(lpSteamController%, pchAbsolutePathToControllerConfigVDF$) BS_Controller_Shutdown%(lpSteamController%) BS_Controller_RunFrame(lpSteamController%) @@ -182,7 +121,8 @@ BS_Controller_GetControllerState%(lpSteamController%, unControllerIndex%, pState BS_Controller_TriggerHapticPulse(lpSteamController%, unControllerIndex%, eTargetPad%, usDurationMicroSec%) BS_Controller_SetOverrideMode(lpSteamController%, pchMode$) -; SteamFriends ------------------------------------------------------------------ +; Friends --------------------------------------------------------------------- +BS_Friends%() BS_Friends_GetPersonaName$(lpSteamFriends%) BS_Friends_SetPersonaName%(lpSteamFriends%, pchPersonaName$) BS_Friends_GetPersonaState%(lpSteamFriends%) @@ -259,10 +199,97 @@ BS_Friends_GetFollowerCount%(lpSteamFriends%, steamID%) BS_Friends_IsFollowing%(lpSteamFriends%, steamID%) BS_Friends_EnumerateFollowingList%(lpSteamFriends%, unStartIndex%) -; SteamGameServer --------------------------------------------------------------- +; GameServer ------------------------------------------------------------------ +BS_GameServer%() +BS_GameServer_Init%(unIP%, usSteamPort%, usGamePort%, usQueryPort%, eServerMode%, pchVersionString%) +BS_GameServer_Shutdown() +BS_GameServer_RunCallbacks() +BS_GameServer_GetHSteamPipe%() +BS_GameServer_IsSecureC%() +BS_GameServer_GetSteamIDC%() +BS_GameServer_InitGameServer%(pSteamGameServer%, unIP%, usGamePort%, usQueryPort%, unFlags%, nGameAppId%, pchVersionString$) +BS_GameServer_SetProduct(pSteamGameServer%, pszProduct$) +BS_GameServer_SetGameDescription(pSteamGameServer%, pszGameDescription$) +BS_GameServer_SetModDir(pSteamGameServer%, pszModDir$) +BS_GameServer_SetDedicatedServer(pSteamGameServer%, bDedicated%) +BS_GameServer_LogOn(pSteamGameServer%, pszToken$) +BS_GameServer_LogOnAnonymous(pSteamGameServer%) +BS_GameServer_LogOff(pSteamGameServer%) +BS_GameServer_IsLoggedOn%(pSteamGameServer%) +BS_GameServer_IsSecure%(pSteamGameServer%) +BS_GameServer_GetSteamID%(pSteamGameServer%) +BS_GameServer_WasRestartRequested%(pSteamGameServer%) +BS_GameServer_SetMaxPlayerCount(pSteamGameServer%, cPlayersMax%) +BS_GameServer_SetBotPlayerCount(pSteamGameServer%, cBotPlayers%) +BS_GameServer_SetServerName(pSteamGameServer%, pszServerName$) +BS_GameServer_SetMapName(pSteamGameServer%, pszMapName$) +BS_GameServer_SetPasswordProtected(pSteamGameServer%, bPasswordProtected%) +BS_GameServer_SetSpectatorPort(pSteamGameServer%, unSpectatorPort%) +BS_GameServer_SetSpectatorServerName(pSteamGameServer%, pszSpectatorServerName$) +BS_GameServer_ClearAllKeyValues(pSteamGameServer%) +BS_GameServer_SetKeyValue(pSteamGameServer%, pKey$, pValue$) +BS_GameServer_SetGameTags(pSteamGameServer%, pchGameTags$) +BS_GameServer_SetGameData(pSteamGameServer%, pchGameData$) +BS_GameServer_SetRegion(pSteamGameServer%, pszRegion$) +BS_GameServer_SendUserConnectAndAuthenticate%(pSteamGameServer%, unIPClient%, pvAuthBlob*, cubAuthBlobSize%, pSteamIDUser%) +BS_GameServer_SendUserConnectAndAuthenticateEx%(pSteamGameServer%, unIPClient%, pvAuthBlob%, cubAuthBlobSize%, pSteamIDUser%) : "BS_GameServer_SendUserConnectAndAuthenticate" +BS_GameServer_CreateUnauthenticatedUserConnection%(pSteamGameServer%) +BS_GameServer_SendUserDisconnect(pSteamGameServer%, pSteamIDUser%) +BS_GameServer_UpdateUserData%(pSteamGameServer%, pSteamIDUser%, pchPlayerName$, uScore%) +BS_GameServer_GetAuthSessionTicket%(pSteamGameServer%, pTicket*, cbMaxTicket%, pcbTicket%) +BS_GameServer_GetAuthSessionTicketEx%(pSteamGameServer%, pTicket%, cbMaxTicket%, pcbTicket%) : "BS_GameServer_GetAuthSessionTicket" +BS_GameServer_BeginAuthSession%(pSteamGameServer%, pAuthTicker*, cbAuthTicket%, pSteamID%) +BS_GameServer_BeginAuthSessionEx%(pSteamGameServer%, pAuthTicker%, cbAuthTicket%, pSteamID%) : "BS_GameServer_BeginAuthSession" +BS_GameServer_EndAuthSession(pSteamGameServer%, pSteamID%) +BS_GameServer_CancelAuthTicket(pSteamGameServer%, hAuthTicket%) +BS_GameServer_UserHasLicenseForApp%(pSteamGameServer%, pSteamID%, appID%) +BS_GameServer_RequestUserGroupStatus%(pSteamGameServer%, pSteamIDUser%, pSteamIDGroup%) +BS_GameServer_GetGameplayStats(pSteamGameServer%) +BS_GameServer_GetServerReputation%(pSteamGameServer%) +BS_GameServer_GetPublicIP%(pSteamGameServer%) +BS_GameServer_HandleIncomingPacket%(pSteamGameServer%, pData*, cbData%, srvIP%, srvPort%) +BS_GameServer_HandleIncomingPacketEx%(pSteamGameServer%, pData%, cbData%, srvIP%, srvPort%) : "BS_GameServer_HandleIncomingPacket" +BS_GameServer_GetNextOutgoingPacket%(pSteamGameServer%, pOut*, cbMaxOut%, pNetAdr*, pPort*) +BS_GameServer_GetNextOutgoingPacketEx%(pSteamGameServer%, pOut%, cbMaxOut%, pNetAdr%, pPort%) : "BS_GameServer_GetNextOutgoingPacket" +BS_GameServer_EnableHeartbeats(pSteamGameServer%, bActive%) +BS_GameServer_SetHeartbeatInterval(pSteamGameServer%, iHeartbeatInterval%) +BS_GameServer_ForceHeartbeat(pSteamGameServer%) +BS_GameServer_AssociateWithClan%(pSteamGameServer%, pSteamIDClan%) +BS_GameServer_ComputeNewPlayerCompatibility%(pSteamGameServer%, pSteamIDNewPlayer%) +; GameServerStats ------------------------------------------------------------- +BS_GameServerStats%() +BS_GameServerStats_RequestUserStats%(pSteamGameServerStats%, steamIDUser%) +BS_GameServerStats_StoreUserStats%(pSteamGameServerStats%, steamIDUser%) +BS_GameServerStats_GetUserStat%(pSteamGameServerStats%, steamIDUser%, pchName$, pData*) +BS_GameServerStats_GetUserStatEx%(pSteamGameServerStats%, steamIDUser%, pchName$, pData%) : "BS_GameServerStats_GetUserStat" +BS_GameServerStats_GetUserStatF%(pSteamGameServerStats%, steamIDUser%, pchName$, pData*) +BS_GameServerStats_GetUserStatFEx%(pSteamGameServerStats%, steamIDUser%, pchName$, pData%) : "BS_GameServerStats_GetUserStatF" +BS_GameServerStats_GetUserAchievement%(pSteamGameServerStats%, steamIDUser%, pchName$, pbAchieved*) +BS_GameServerStats_GetUserAchievementEx%(pSteamGameServerStats%, steamIDUser%, pchName$, pbAchieved%) : "BS_GameServerStats_GetUserAchievement" +BS_GameServerStats_SetUserStat%(pSteamGameServerStats%, steamIDUser%, pchName%, nData%) +BS_GameServerStats_SetUserStatF%(pSteamGameServerStats%, steamIDUser%, pchName%, fData#) +BS_GameServerStats_UpdateUserAvgRateStat%(pSteamGameServerStats%, steamIDUser%, pchName$, flCountThisSession#, pdSessionLength%) +BS_GameServerStats_SetUserAchievement%(pSteamGameServerStats%, steamIDUser%, pchName$) +BS_GameServerStats_ClearUserAchievement%(pSteamGameServerStats%, steamIDUser%, pchName$) -; SteamUser --------------------------------------------------------------------- +; Networking ------------------------------------------------------------------ +BS_Networking%() +BS_GameServerNetworking%() +BS_Networking_SendP2PPacket%(pSteamNetworking%, pSteamIDRemote%, pubData*, cubData%, eP2PSendType%, nChannel%) +BS_Networking_SendP2PPacketEx%(pSteamNetworking%, pSteamIDRemote%, pubData%, cubData%, eP2PSendType%, nChannel%) : "BS_Networking_SendP2PPacket" +BS_Networking_IsP2PPacketAvailable%(pSteamNetworking%, pcubMsgSize*, nChannel%) +BS_Networking_IsP2PPacketAvailableEx%(pSteamNetworking%, pcubMsgSize*, nChannel%) : "BS_Networking_IsP2PPacketAvailable" +BS_Networking_ReadP2PPacket%(pSteamNetworking%, pubDest*, cubDest%, pcubMsgSize*, pSteamIDRemote%, nChannel%) +BS_Networking_ReadP2PPacketEx%(pSteamNetworking%, pubDest%, cubDest%, pcubMsgSize%, pSteamIDRemote%, nChannel%) : "BS_Networking_ReadP2PPacket" +BS_Networking_AcceptP2PSessionWithUser%(pSteamNetworking%, pSteamIDRemote%) +BS_Networking_CloseP2PSessionWithUser%(pSteamNetworking%, pSteamIDRemote%) +BS_Networking_CloseP2PChannelWithUser%(pSteamNetworking%, pSteamIDRemote%, nChannel%) +BS_Networking_GetP2PSessionState%(pSteamNetworking%, pSteamIDRemote%, pConnectionState*) +BS_Networking_AllowP2PPacketRelay%(pSteamNetworking%, bAllow%) + +; User ------------------------------------------------------------------------ +BS_User%() BS_User_GetHSteamUser%(lpSteamUser%) BS_User_IsLoggedOn%(lpSteamUser%) BS_User_GetSteamID%(lpSteamUser%) @@ -294,7 +321,8 @@ BS_User_GetGameBadgeLevel%(lpSteamUser%, nSeries%, bFoil%) BS_User_GetPlayerSteamLevel%(lpSteamUser%) BS_User_RequestStoreAuthURL%(lpSteamUser%, pchRedirectUrl$) -; SteamUserStats ---------------------------------------------------------------- +; UserStats ------------------------------------------------------------------- +BS_UserStats%() BS_UserStats_RequestCurrentStats%(lpSteamUserStats%) BS_UserStats_GetStat%(lpSteamUserStats%, pchName$, pData*) BS_UserStats_GetStatEx%(lpSteamUserStats%, pchName$, pData%) : "BS_UserStats_GetStat" @@ -353,4 +381,65 @@ BS_UserStats_GetGlobalStatD%(lpSteamUserStats, pchStatName$, pData%) BS_UserStats_GetGlobalStatHistoryLL%(lpSteamUserStats, pchStatName$, pData*, cubData%) BS_UserStats_GetGlobalStatHistoryLLEx%(lpSteamUserStats, pchStatName$, pData%, cubData%) : "BS_UserStats_GetGlobalStatHistoryLL" BS_UserStats_GetGlobalStatHistoryD%(lpSteamUserStats, pchStatName$, pData*, cubData%) -BS_UserStats_GetGlobalStatHistoryDEx%(lpSteamUserStats, pchStatName$, pData%, cubData%) : "BS_UserStats_GetGlobalStatHistoryD" \ No newline at end of file +BS_UserStats_GetGlobalStatHistoryDEx%(lpSteamUserStats, pchStatName$, pData%, cubData%) : "BS_UserStats_GetGlobalStatHistoryD" + +; Helpers --------------------------------------------------------------------- +BS_Helper_FormatUnixTime$(unixTime%, pchFormat$) +; -- CSteamID +BS_CSteamID_New%() +BS_CSteamID_FromID%(unAccountID%, eUniverse%, eAccountType%) +BS_CSteamID_FromIDInstance%(unAccountID%, unInstance%, eUniverse%, eAccountType%) +BS_CSteamID_FromSteamID%(ulSteamID%) +BS_CSteamID_Copy%(pSteamID%) +BS_CSteamID_Destroy(pSteamID%) +BS_CSteamID_Set(pSteamID%, unAccountID%, eUniverse%, eAccountType%) +BS_CSteamID_InstancedSet(pSteamID%, unAccountID%, unInstance%, eUniverse%, eAccountType%) +BS_CSteamID_FullSet(pSteamID%, ulIdentifier%, eUniverse%, eAccountType%) +BS_CSteamID_SetFromUInt64(pSteamID%, ulSteamID%) +BS_CSteamID_Clear(pSteamID%) +BS_CSteamID_ConvertToUInt64%(pSteamID%) +BS_CSteamID_GetStaticAccountKey%(pSteamID%) +BS_CSteamID_CreateBlankAnonLogon(pSteamID%, eUniverse%) +BS_CSteamID_CreateBlankAnonUserLogon(pSteamID%, eUniverse%) +BS_CSteamID_BlankAnonAccount%(pSteamID%) +BS_CSteamID_GameServerAccount%(pSteamID%) +BS_CSteamID_PersistentGameServerAccount%(pSteamID%) +BS_CSteamID_AnonGameServerAccount%(pSteamID%) +BS_CSteamID_ContentServerAccount%(pSteamID%) +BS_CSteamID_ClanAccount%(pSteamID%) +BS_CSteamID_ChatAccount%(pSteamID%) +BS_CSteamID_IsLobby%(pSteamID%) +BS_CSteamID_IndividualAccount%(pSteamID%) +BS_CSteamID_AnonAccount%(pSteamID%) +BS_CSteamID_AnonUserAccount%(pSteamID%) +BS_CSteamID_ConsoleUserAccount%(pSteamID%) +BS_CSteamID_SetAccountID(pSteamID%, unAccountID%) +BS_CSteamID_SetAccountInstance(pSteamID, unInstance%) +BS_CSteamID_ClearIndividualInstance(pSteamID%) +BS_CSteamID_HasNoIndividualInstance%(pSteamID%) +BS_CSteamID_GetAccountID%(pSteamID%) +BS_CSteamID_GetAccountInstance%(pSteamID%) +BS_CSteamID_GetEAccountType%(pSteamID%) +BS_CSteamID_GetEUniverse%(pSteamID%) +BS_CSteamID_SetEUniverse(pSteamID%, eUniverse%) +BS_CSteamID_IsValid%(pSteamID%) +BS_CSteamID_Compare%(pSteamID%, pSteamIDOther%) +; -- Callbacks +BS_Callback_Create%(pFunction%) +BS_Callback_Destroy%(pCallback%) + + +; -- Interfaces +BS_HTTP%() +BS_HTMLSurface%() +BS_Inventory%() +BS_Matchmaking%() +BS_MatchmakingServers%() +BS_Music%() +BS_MusicRemote%() +BS_RemoteStorage%() +BS_Screenshots%() +BS_UGC%() +BS_UnifiedMessages%() +BS_Utils%() +BS_Video%() \ No newline at end of file diff --git a/Blitz/BlitzSteamUtility.bb b/Blitz/BlitzSteamUtility.bb index 771051d..e663fa5 100644 --- a/Blitz/BlitzSteamUtility.bb +++ b/Blitz/BlitzSteamUtility.bb @@ -101,7 +101,7 @@ End Function ; Reads a C-String value from a Bank. ; Returns read C-String -Function BSU_PeekCString$(Bank%, Pos%) +Function BSU_PeekCString$(Bank%, Pos%, Len%=-1) If Bank Then Local BankSz = BankSize(Bank) @@ -115,7 +115,7 @@ Function BSU_PeekCString$(Bank%, Pos%) Local Value = PeekByte(Bank, Pos + BankPos) - If Value = 0 Then + If (Value = 0 And Len = -1) Or (Pos > Len) Then Exit Else OutStr=OutStr+Chr(Value) @@ -127,16 +127,16 @@ End Function ; -- Steam Function BSU_Init() - BSU_IsSteamRunning = BS_IsSteamRunning() + BSU_IsSteamRunning = BS_Steam_IsSteamRunning() If BSU_IsSteamRunning Then - BS_Init() + BS_Steam_Init() BSU_AppList = BS_AppList() - BSU_Apps = BS_Apps() + BSU_Apps = BS_Apps() BSU_Client = BS_Client() BSU_Controller = BS_Controller() BSU_Friends = BS_Friends() - BSU_HTTP = BS_HTTP() + BSU_HTTP = BS_HTTP() BSU_HTMLSurface = BS_HTMLSurface() BSU_Inventory = BS_Inventory() BSU_Matchmaking = BS_Matchmaking() @@ -148,7 +148,7 @@ Function BSU_Init() BSU_Screenshots = BS_Screenshots() BSU_UGC = BS_UGC() BSU_UnifiedMessages = BS_UnifiedMessages() - BSU_User = BS_User() + BSU_User = BS_User() BSU_UserStats = BS_UserStats() BSU_Utils = BS_Utils() BSU_Video = BS_Video() @@ -159,7 +159,7 @@ End Function Function BSU_Shutdown() If BSU_IsSteamRunning - BS_Shutdown() + BS_Steam_Shutdown() BSU_AppList=0 BSU_Apps=0 BSU_Client=0 @@ -186,7 +186,7 @@ Function BSU_Shutdown() EndIf End Function -; -- SteamAppList +; -- AppList Function BSU_AppList_GetInstalledApps(BankAppIdsStorage=0, BankAppNameStorage=0, BankAppInstallDirStorage=0) Local BankAppIds, BankAppIdsSz = BSU_APPID_COUNT Local BankAppName, BankAppNameSz = BSU_NAME_LENGTH @@ -552,5 +552,5 @@ Function BSU_Friends_GetFriends(iFriendFlags=BS_EFriendFlags_All) End Function ;~IDEal Editor Parameters: -;~F#52#67#80#9F#BD#FA#116#133#163#195#1B1#1D0 +;~F#52#67#BD#FA#116#133#163#195#1B1#1D0 ;~C#Blitz3D \ No newline at end of file diff --git a/dllmain.cpp b/BlitzSteam.cpp similarity index 97% rename from dllmain.cpp rename to BlitzSteam.cpp index 74f8b7b..00f46d5 100644 --- a/dllmain.cpp +++ b/BlitzSteam.cpp @@ -14,7 +14,7 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" +#include "BlitzSteam.h" uint32_t WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { switch (fdwReason) { diff --git a/BlitzSteam.h b/BlitzSteam.h new file mode 100644 index 0000000..e6f913f --- /dev/null +++ b/BlitzSteam.h @@ -0,0 +1,40 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#pragma once + +// Macros +#define DLL_FUNCTION(type) extern "C" type __stdcall +//#define DLL_FUNCTION(type) extern "C" __declspec(dllexport) type __stdcall + +// Standard Library +#include +#include +#include +#include + +// Platform specific: Windows +#include + +// Steam +#include "SteamworksSDK/public/steam/steam_api.h" +#include "SteamworksSDK/public/steam/steam_gameserver.h" + +// Steam Helper Classes and Functions +#include "Helpers/BlitzPointer.h" +#include "Helpers/Callbacks.h" +#include "Helpers/CSteamID.h" +#include "Helpers/Helper.h" diff --git a/BlitzSteam.vcxproj b/BlitzSteam.vcxproj index 45b97cd..f603864 100644 --- a/BlitzSteam.vcxproj +++ b/BlitzSteam.vcxproj @@ -13,6 +13,7 @@ {805CB1EB-82F0-405E-AC0B-03FBE82CC77D} BlitzSteam + 8.1 @@ -40,14 +41,14 @@ - $(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\ - $(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\ + $(SolutionDir)#Build\$(ProjectName)\$(Configuration)\ + $(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\ .dll true - $(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\ - $(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\ + $(SolutionDir)#Build\$(ProjectName)\$(Configuration)\ + $(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\ .dll false @@ -55,23 +56,21 @@ Level3 Disabled - - Neither MultiThreaded false $(ProjectDir);%(AdditionalIncludeDirectories) EditAndContinue false - Default + EnableFastChecks 4Bytes true false false true - false - false - false + true + true + true false @@ -80,13 +79,13 @@ Disabled false true - NoExtensions - false + NotSet + true true _CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) - true + Debug 1.0 $(ProjectDir)\SteamworksSDK\redistributable_bin steam_api.lib;%(AdditionalDependencies) @@ -108,10 +107,8 @@ Level3 Full - false + true true - - Speed MultiThreaded $(ProjectDir);%(AdditionalIncludeDirectories) @@ -129,12 +126,13 @@ Default false Cdecl - AnySuitable + Default true - NoExtensions - false + NotSet + true true _CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) + None false @@ -155,9 +153,10 @@ - + + @@ -184,18 +183,19 @@ - + + - LICENSE + BlitzSteam.LICENSE PreserveNewest - LICENSE.lesser + BlitzSteam.LICENSE.lesser PreserveNewest diff --git a/BlitzSteam.vcxproj.filters b/BlitzSteam.vcxproj.filters index 4ee4837..61149f6 100644 --- a/BlitzSteam.vcxproj.filters +++ b/BlitzSteam.vcxproj.filters @@ -20,9 +20,6 @@ - - Source Files - Source Files\Wrapper @@ -101,11 +98,14 @@ Source Files\Helpers + + Source Files + + + Source Files\Helpers + - - Source Files - Source Files\Helpers @@ -115,6 +115,12 @@ Source Files\Helpers + + Source Files + + + Source Files\Helpers + diff --git a/Helpers/BlitzPointer.h b/Helpers/BlitzPointer.h index 2900a06..29e5072 100644 --- a/Helpers/BlitzPointer.h +++ b/Helpers/BlitzPointer.h @@ -14,13 +14,13 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" +#pragma once -typedef uint32_t(__stdcall *BP_Function0_t)(); -typedef uint32_t(__stdcall *BP_Function1_t)(uint32_t); -typedef uint32_t(__stdcall *BP_Function2_t)(uint32_t, uint32_t); -typedef uint32_t(__stdcall *BP_Function3_t)(uint32_t, uint32_t, uint32_t); -typedef uint32_t(__stdcall *BP_Function4_t)(uint32_t, uint32_t, uint32_t, uint32_t); +typedef void*(__stdcall *BP_Function0_t)(); +typedef void*(__stdcall *BP_Function1_t)(uint32_t); +typedef void*(__stdcall *BP_Function2_t)(uint32_t, uint32_t); +typedef void*(__stdcall *BP_Function3_t)(uint32_t, uint32_t, uint32_t); +typedef void*(__stdcall *BP_Function4_t)(uint32_t, uint32_t, uint32_t, uint32_t); #define BP_CallFunction0(ptr) ((BP_Function0_t)ptr)() #define BP_CallFunction1(ptr, p1) ((BP_Function1_t)ptr)(p1) diff --git a/Helpers/CSteamID.cpp b/Helpers/CSteamID.cpp index 516eb41..21d99ec 100644 --- a/Helpers/CSteamID.cpp +++ b/Helpers/CSteamID.cpp @@ -14,198 +14,198 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" +#include "CSteamID.h" -DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_New() { +DLL_FUNCTION(CSteamID*) BS_CSteamID_New() { return new CSteamID(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_New=_BS_CSteamID_New@0") -DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromID(uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType) { +DLL_FUNCTION(CSteamID*) BS_CSteamID_FromID(uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType) { return new CSteamID(unAccountID, eUniverse, eAccountType); } #pragma comment(linker, "/EXPORT:BS_CSteamID_FromID=_BS_CSteamID_FromID@12") -DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromIDInstance(uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType) { +DLL_FUNCTION(CSteamID*) BS_CSteamID_FromIDInstance(uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType) { return new CSteamID(unAccountID, unInstance, eUniverse, eAccountType); } #pragma comment(linker, "/EXPORT:BS_CSteamID_FromIDInstance=_BS_CSteamID_FromIDInstance@16") -DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromSteamID(uint64_t* ulSteamID) { +DLL_FUNCTION(CSteamID*) BS_CSteamID_FromSteamID(uint64_t* ulSteamID) { return new CSteamID(*ulSteamID); } #pragma comment(linker, "/EXPORT:BS_CSteamID_FromSteamID=_BS_CSteamID_FromSteamID@4") -DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_Copy(CSteamID* pSteamID) { +DLL_FUNCTION(CSteamID*) BS_CSteamID_Copy(CSteamID* pSteamID) { return new CSteamID(*pSteamID); } #pragma comment(linker, "/EXPORT:BS_CSteamID_Copy=_BS_CSteamID_Copy@4") -DLL_EXPORT void DLL_CALL BS_CSteamID_Destroy(CSteamID* pSteamID) { +DLL_FUNCTION(void) BS_CSteamID_Destroy(CSteamID* pSteamID) { delete pSteamID; } #pragma comment(linker, "/EXPORT:BS_CSteamID_Destroy=_BS_CSteamID_Destroy@4") -DLL_EXPORT void DLL_CALL BS_CSteamID_Set(CSteamID* pSteamID, uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType) { +DLL_FUNCTION(void) BS_CSteamID_Set(CSteamID* pSteamID, uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType) { pSteamID->Set(unAccountID, eUniverse, eAccountType); } #pragma comment(linker, "/EXPORT:BS_CSteamID_Set=_BS_CSteamID_Set@16") -DLL_EXPORT void DLL_CALL BS_CSteamID_InstancedSet(CSteamID* pSteamID, uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType) { +DLL_FUNCTION(void) BS_CSteamID_InstancedSet(CSteamID* pSteamID, uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType) { pSteamID->InstancedSet(unAccountID, unInstance, eUniverse, eAccountType); } #pragma comment(linker, "/EXPORT:BS_CSteamID_InstancedSet=_BS_CSteamID_InstancedSet@20") -DLL_EXPORT void DLL_CALL BS_CSteamID_FullSet(CSteamID* pSteamID, uint64_t* ulIdentifier, EUniverse eUniverse, EAccountType eAccountType) { +DLL_FUNCTION(void) BS_CSteamID_FullSet(CSteamID* pSteamID, uint64_t* ulIdentifier, EUniverse eUniverse, EAccountType eAccountType) { pSteamID->FullSet(*ulIdentifier, eUniverse, eAccountType); } #pragma comment(linker, "/EXPORT:BS_CSteamID_FullSet=_BS_CSteamID_FullSet@16") -DLL_EXPORT void DLL_CALL BS_CSteamID_SetFromUInt64(CSteamID* pSteamID, uint64_t* ulSteamID) { +DLL_FUNCTION(void) BS_CSteamID_SetFromUInt64(CSteamID* pSteamID, uint64_t* ulSteamID) { pSteamID->SetFromUint64(*ulSteamID); } #pragma comment(linker, "/EXPORT:BS_CSteamID_SetFromUInt64=_BS_CSteamID_SetFromUInt64@8") -DLL_EXPORT void DLL_CALL BS_CSteamID_Clear(CSteamID* pSteamID) { +DLL_FUNCTION(void) BS_CSteamID_Clear(CSteamID* pSteamID) { pSteamID->Clear(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_Clear=_BS_CSteamID_Clear@4") -DLL_EXPORT uint64_t* DLL_CALL BS_CSteamID_ConvertToUInt64(CSteamID* pSteamID) { +DLL_FUNCTION(uint64_t*) BS_CSteamID_ConvertToUInt64(CSteamID* pSteamID) { uint64_t* val = new uint64_t; *val = pSteamID->ConvertToUint64(); return val; } #pragma comment(linker, "/EXPORT:BS_CSteamID_ConvertToUInt64=_BS_CSteamID_ConvertToUInt64@4") -DLL_EXPORT uint64_t* DLL_CALL BS_CSteamID_GetStaticAccountKey(CSteamID* pSteamID) { +DLL_FUNCTION(uint64_t*) BS_CSteamID_GetStaticAccountKey(CSteamID* pSteamID) { uint64_t* val = new uint64_t; *val = pSteamID->GetStaticAccountKey(); return val; } #pragma comment(linker, "/EXPORT:BS_CSteamID_GetStaticAccountKey=_BS_CSteamID_GetStaticAccountKey@4") -DLL_EXPORT void DLL_CALL BS_CSteamID_CreateBlankAnonLogon(CSteamID* pSteamID, EUniverse eUniverse) { +DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonLogon(CSteamID* pSteamID, EUniverse eUniverse) { pSteamID->CreateBlankAnonLogon(eUniverse); } #pragma comment(linker, "/EXPORT:BS_CSteamID_CreateBlankAnonLogon=_BS_CSteamID_CreateBlankAnonLogon@8") -DLL_EXPORT void DLL_CALL BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pSteamID, EUniverse eUniverse) { +DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pSteamID, EUniverse eUniverse) { pSteamID->CreateBlankAnonUserLogon(eUniverse); } #pragma comment(linker, "/EXPORT:BS_CSteamID_CreateBlankAnonUserLogon=_BS_CSteamID_CreateBlankAnonUserLogon@8") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_BlankAnonAccount(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_BlankAnonAccount(CSteamID* pSteamID) { return pSteamID->BBlankAnonAccount(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_BlankAnonAccount=_BS_CSteamID_BlankAnonAccount@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_GameServerAccount(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_GameServerAccount(CSteamID* pSteamID) { return pSteamID->BGameServerAccount(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_GameServerAccount=_BS_CSteamID_GameServerAccount@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_PersistentGameServerAccount(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_PersistentGameServerAccount(CSteamID* pSteamID) { return pSteamID->BPersistentGameServerAccount(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_PersistentGameServerAccount=_BS_CSteamID_PersistentGameServerAccount@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonGameServerAccount(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_AnonGameServerAccount(CSteamID* pSteamID) { return pSteamID->BAnonGameServerAccount(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_AnonGameServerAccount=_BS_CSteamID_AnonGameServerAccount@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ContentServerAccount(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_ContentServerAccount(CSteamID* pSteamID) { return pSteamID->BContentServerAccount(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_ContentServerAccount=_BS_CSteamID_ContentServerAccount@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ClanAccount(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_ClanAccount(CSteamID* pSteamID) { return pSteamID->BClanAccount(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_ClanAccount=_BS_CSteamID_ClanAccount@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ChatAccount(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_ChatAccount(CSteamID* pSteamID) { return pSteamID->BChatAccount(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_ChatAccount=_BS_CSteamID_ChatAccount@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IsLobby(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_IsLobby(CSteamID* pSteamID) { return pSteamID->IsLobby(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_IsLobby=_BS_CSteamID_IsLobby@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IndividualAccount(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_IndividualAccount(CSteamID* pSteamID) { return pSteamID->BIndividualAccount(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_IndividualAccount=_BS_CSteamID_IndividualAccount@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonAccount(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_AnonAccount(CSteamID* pSteamID) { return pSteamID->BAnonAccount(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_AnonAccount=_BS_CSteamID_AnonAccount@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonUserAccount(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_AnonUserAccount(CSteamID* pSteamID) { return pSteamID->BAnonUserAccount(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_AnonUserAccount=_BS_CSteamID_AnonUserAccount@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ConsoleUserAccount(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_ConsoleUserAccount(CSteamID* pSteamID) { return pSteamID->BConsoleUserAccount(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_ConsoleUserAccount=_BS_CSteamID_ConsoleUserAccount@4") -DLL_EXPORT void DLL_CALL BS_CSteamID_SetAccountID(CSteamID* pSteamID, AccountID_t unAccountID) { +DLL_FUNCTION(void) BS_CSteamID_SetAccountID(CSteamID* pSteamID, AccountID_t unAccountID) { pSteamID->SetAccountID(unAccountID); } #pragma comment(linker, "/EXPORT:BS_CSteamID_SetAccountID=_BS_CSteamID_SetAccountID@8") -DLL_EXPORT void DLL_CALL BS_CSteamID_SetAccountInstance(CSteamID* pSteamID, uint32_t unInstance) { +DLL_FUNCTION(void) BS_CSteamID_SetAccountInstance(CSteamID* pSteamID, uint32_t unInstance) { pSteamID->SetAccountInstance(unInstance); } #pragma comment(linker, "/EXPORT:BS_CSteamID_SetAccountInstance=_BS_CSteamID_SetAccountInstance@8") -DLL_EXPORT void DLL_CALL BS_CSteamID_ClearIndividualInstance(CSteamID* pSteamID) { +DLL_FUNCTION(void) BS_CSteamID_ClearIndividualInstance(CSteamID* pSteamID) { pSteamID->ClearIndividualInstance(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_ClearIndividualInstance=_BS_CSteamID_ClearIndividualInstance@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_HasNoIndividualInstance(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_HasNoIndividualInstance(CSteamID* pSteamID) { return pSteamID->HasNoIndividualInstance(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_HasNoIndividualInstance=_BS_CSteamID_HasNoIndividualInstance@4") -DLL_EXPORT AccountID_t DLL_CALL BS_CSteamID_GetAccountID(CSteamID* pSteamID) { +DLL_FUNCTION(AccountID_t) BS_CSteamID_GetAccountID(CSteamID* pSteamID) { return pSteamID->GetAccountID(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_GetAccountID=_BS_CSteamID_GetAccountID@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_GetAccountInstance(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_GetAccountInstance(CSteamID* pSteamID) { return pSteamID->GetUnAccountInstance(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_GetAccountInstance=_BS_CSteamID_GetAccountInstance@4") -DLL_EXPORT EAccountType DLL_CALL BS_CSteamID_GetEAccountType(CSteamID* pSteamID) { +DLL_FUNCTION(EAccountType) BS_CSteamID_GetEAccountType(CSteamID* pSteamID) { return pSteamID->GetEAccountType(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_GetEAccountType=_BS_CSteamID_GetEAccountType@4") -DLL_EXPORT EUniverse DLL_CALL BS_CSteamID_GetEUniverse(CSteamID* pSteamID) { +DLL_FUNCTION(EUniverse) BS_CSteamID_GetEUniverse(CSteamID* pSteamID) { return pSteamID->GetEUniverse(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_GetEUniverse=_BS_CSteamID_GetEUniverse@4") -DLL_EXPORT void DLL_CALL BS_CSteamID_SetEUniverse(CSteamID* pSteamID, EUniverse eUniverse) { +DLL_FUNCTION(void) BS_CSteamID_SetEUniverse(CSteamID* pSteamID, EUniverse eUniverse) { pSteamID->SetEUniverse(eUniverse); } #pragma comment(linker, "/EXPORT:BS_CSteamID_SetEUniverse=_BS_CSteamID_SetEUniverse@8") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IsValid(CSteamID* pSteamID) { +DLL_FUNCTION(uint32_t) BS_CSteamID_IsValid(CSteamID* pSteamID) { return pSteamID->IsValid(); } #pragma comment(linker, "/EXPORT:BS_CSteamID_IsValid=_BS_CSteamID_IsValid@4") -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_Compare(CSteamID* pSteamID, CSteamID* pSteamIDOther) { +DLL_FUNCTION(uint32_t) BS_CSteamID_Compare(CSteamID* pSteamID, CSteamID* pSteamIDOther) { return (pSteamID == pSteamIDOther ? 1 : 0) + (pSteamID < pSteamIDOther ? 2 : 0) + (pSteamID > pSteamIDOther ? 4 : 0); } #pragma comment(linker, "/EXPORT:BS_CSteamID_Compare=_BS_CSteamID_Compare@8") diff --git a/Helpers/CSteamID.h b/Helpers/CSteamID.h index 9d61503..ef98b56 100644 --- a/Helpers/CSteamID.h +++ b/Helpers/CSteamID.h @@ -14,43 +14,44 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" +#pragma once +#include "BlitzSteam.h" -DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_New(); -DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromID(uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType); -DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromIDInstance(uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType); -DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromSteamID(uint64_t* ulSteamID); -DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_Copy(CSteamID* pSteamID); -DLL_EXPORT void DLL_CALL BS_CSteamID_Destroy(CSteamID* pSteamID); -DLL_EXPORT void DLL_CALL BS_CSteamID_Set(CSteamID* pSteamID, uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType); -DLL_EXPORT void DLL_CALL BS_CSteamID_InstancedSet(CSteamID* pSteamID, uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType); -DLL_EXPORT void DLL_CALL BS_CSteamID_FullSet(CSteamID* pSteamID, uint64_t* ulIdentifier, EUniverse eUniverse, EAccountType eAccountType); -DLL_EXPORT void DLL_CALL BS_CSteamID_SetFromUInt64(CSteamID* pSteamID, uint64_t* ulSteamID); -DLL_EXPORT void DLL_CALL BS_CSteamID_Clear(CSteamID* pSteamID); -DLL_EXPORT uint64_t* DLL_CALL BS_CSteamID_ConvertToUInt64(CSteamID* pSteamID); -DLL_EXPORT uint64_t* DLL_CALL BS_CSteamID_GetStaticAccountKey(CSteamID* pSteamID); -DLL_EXPORT void DLL_CALL BS_CSteamID_CreateBlankAnonLogon(CSteamID* pSteamID, EUniverse eUniverse); -DLL_EXPORT void DLL_CALL BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pSteamID, EUniverse eUniverse); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_BlankAnonAccount(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_GameServerAccount(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_PersistentGameServerAccount(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonGameServerAccount(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ContentServerAccount(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ClanAccount(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ChatAccount(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IsLobby(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IndividualAccount(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonAccount(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonUserAccount(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ConsoleUserAccount(CSteamID* pSteamID); -DLL_EXPORT void DLL_CALL BS_CSteamID_SetAccountID(CSteamID* pSteamID, AccountID_t unAccountID); -DLL_EXPORT void DLL_CALL BS_CSteamID_SetAccountInstance(CSteamID* pSteamID, uint32_t unInstance); -DLL_EXPORT void DLL_CALL BS_CSteamID_ClearIndividualInstance(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_HasNoIndividualInstance(CSteamID* pSteamID); -DLL_EXPORT AccountID_t DLL_CALL BS_CSteamID_GetAccountID(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_GetAccountInstance(CSteamID* pSteamID); -DLL_EXPORT EAccountType DLL_CALL BS_CSteamID_GetEAccountType(CSteamID* pSteamID); -DLL_EXPORT EUniverse DLL_CALL BS_CSteamID_GetEUniverse(CSteamID* pSteamID); -DLL_EXPORT void DLL_CALL BS_CSteamID_SetEUniverse(CSteamID* pSteamID, EUniverse eUniverse); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IsValid(CSteamID* pSteamID); -DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_Compare(CSteamID* pSteamID, CSteamID* pSteamIDOther); \ No newline at end of file +DLL_FUNCTION(CSteamID*) BS_CSteamID_New(); +DLL_FUNCTION(CSteamID*) BS_CSteamID_FromID(uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType); +DLL_FUNCTION(CSteamID*) BS_CSteamID_FromIDInstance(uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType); +DLL_FUNCTION(CSteamID*) BS_CSteamID_FromSteamID(uint64_t* ulSteamID); +DLL_FUNCTION(CSteamID*) BS_CSteamID_Copy(CSteamID* pSteamID); +DLL_FUNCTION(void) BS_CSteamID_Destroy(CSteamID* pSteamID); +DLL_FUNCTION(void) BS_CSteamID_Set(CSteamID* pSteamID, uint32_t unAccountID, EUniverse eUniverse, EAccountType eAccountType); +DLL_FUNCTION(void) BS_CSteamID_InstancedSet(CSteamID* pSteamID, uint32_t unAccountID, uint32_t unInstance, EUniverse eUniverse, EAccountType eAccountType); +DLL_FUNCTION(void) BS_CSteamID_FullSet(CSteamID* pSteamID, uint64_t* ulIdentifier, EUniverse eUniverse, EAccountType eAccountType); +DLL_FUNCTION(void) BS_CSteamID_SetFromUInt64(CSteamID* pSteamID, uint64_t* ulSteamID); +DLL_FUNCTION(void) BS_CSteamID_Clear(CSteamID* pSteamID); +DLL_FUNCTION(uint64_t*) BS_CSteamID_ConvertToUInt64(CSteamID* pSteamID); +DLL_FUNCTION(uint64_t*) BS_CSteamID_GetStaticAccountKey(CSteamID* pSteamID); +DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonLogon(CSteamID* pSteamID, EUniverse eUniverse); +DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pSteamID, EUniverse eUniverse); +DLL_FUNCTION(uint32_t) BS_CSteamID_BlankAnonAccount(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_GameServerAccount(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_PersistentGameServerAccount(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_AnonGameServerAccount(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_ContentServerAccount(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_ClanAccount(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_ChatAccount(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_IsLobby(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_IndividualAccount(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_AnonAccount(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_AnonUserAccount(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_ConsoleUserAccount(CSteamID* pSteamID); +DLL_FUNCTION(void) BS_CSteamID_SetAccountID(CSteamID* pSteamID, AccountID_t unAccountID); +DLL_FUNCTION(void) BS_CSteamID_SetAccountInstance(CSteamID* pSteamID, uint32_t unInstance); +DLL_FUNCTION(void) BS_CSteamID_ClearIndividualInstance(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_HasNoIndividualInstance(CSteamID* pSteamID); +DLL_FUNCTION(AccountID_t) BS_CSteamID_GetAccountID(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_GetAccountInstance(CSteamID* pSteamID); +DLL_FUNCTION(EAccountType) BS_CSteamID_GetEAccountType(CSteamID* pSteamID); +DLL_FUNCTION(EUniverse) BS_CSteamID_GetEUniverse(CSteamID* pSteamID); +DLL_FUNCTION(void) BS_CSteamID_SetEUniverse(CSteamID* pSteamID, EUniverse eUniverse); +DLL_FUNCTION(uint32_t) BS_CSteamID_IsValid(CSteamID* pSteamID); +DLL_FUNCTION(uint32_t) BS_CSteamID_Compare(CSteamID* pSteamID, CSteamID* pSteamIDOther); diff --git a/Helpers/Callbacks.cpp b/Helpers/Callbacks.cpp index aa2ad1e..5fe1ab5 100644 --- a/Helpers/Callbacks.cpp +++ b/Helpers/Callbacks.cpp @@ -14,49 +14,32 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" -#include "Helpers/BlitzPointer.h" -#include +#include "Callbacks.h" // Callbacks -class BS_Callback : CCallbackBase { - public: - uint32_t blitzFunctionPointer; - - virtual void Run(void *pvParam) { - BP_CallFunction4((uint32_t)blitzFunctionPointer, (uint32_t)pvParam, 0, 0, 0); - } - - virtual void Run(void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall) { - BP_CallFunction4((uint32_t)blitzFunctionPointer, (uint32_t)pvParam, bIOFailure, (uint32_t)(hSteamAPICall & 0xFFFFFFFF), (uint32_t)(hSteamAPICall >> 32)); - } - - virtual int GetCallbackSizeBytes() { - return sizeof(BS_Callback); - } -}; - -DLL_EXPORT void* DLL_CALL BS_Helper_CreateCallback(uint32_t fpFunctionPointer) { - BS_Callback* lpBSCallback = new BS_Callback(); - lpBSCallback->blitzFunctionPointer = fpFunctionPointer; - return lpBSCallback; +void BS_Callback::Run(void *pvParam) { + BP_CallFunction3(bbRunFunction, reinterpret_cast(pvParam), 0, 0); } -#pragma comment(linker, "/EXPORT:BS_Helper_CreateCallback=_BS_Helper_CreateCallback@4") -DLL_EXPORT void DLL_CALL BS_Helper_DestroyCallback(uint32_t lpCallback) { - BS_Callback* lpBSCallback = (BS_Callback*)lpCallback; - if (lpBSCallback != nullptr) { - delete lpBSCallback; +void BS_Callback::Run(void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall) { + BP_CallFunction3(bbRunFunction, reinterpret_cast(pvParam), (uint32_t)bIOFailure, reinterpret_cast(&hSteamAPICall)); +} + +int BS_Callback::GetCallbackSizeBytes() { + return sizeof(BS_Callback); +} + +// DLL-Callables +DLL_FUNCTION(BS_Callback*) BS_Callback_Create(uint32_t fpFunctionPointer) { + BS_Callback* lpCallback = new BS_Callback(); + lpCallback->bbRunFunction = (void*)fpFunctionPointer; + return lpCallback; +} +#pragma comment(linker, "/EXPORT:BS_Callback_Create=_BS_Callback_Create@4") + +DLL_FUNCTION(void) BS_Callback_Destroy(BS_Callback* lpCallback) { + if (lpCallback != nullptr) { + delete lpCallback; } } -#pragma comment(linker, "/EXPORT:BS_Helper_DestroyCallback=_BS_Helper_DestroyCallback@4") - -DLL_EXPORT const char* DLL_CALL BS_Helper_FormatUnixTime(uint32_t unTime, const char* pchFormat) { - char* output = new char[strlen(pchFormat) * 4]; - time_t t = unTime; - struct tm *tm = localtime(&t); - strftime(output, sizeof(output), pchFormat, tm); - delete tm; - return output; -} -#pragma comment(linker, "/EXPORT:BS_Helper_FormatUnixTime=_BS_Helper_FormatUnixTime@8") +#pragma comment(linker, "/EXPORT:BS_Callback_Destroy=_BS_Callback_Destroy@4") \ No newline at end of file diff --git a/Helpers/Callbacks.h b/Helpers/Callbacks.h index e69de29..da20291 100644 --- a/Helpers/Callbacks.h +++ b/Helpers/Callbacks.h @@ -0,0 +1,29 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#pragma once +#include "BlitzSteam.h" + +class BS_Callback : CCallbackBase { + public: + void* bbRunFunction; + virtual void Run(void *pvParam); + virtual void Run(void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall); + virtual int GetCallbackSizeBytes(); +}; + +DLL_FUNCTION(BS_Callback*) BS_Callback_Create(uint32_t fpFunctionPointer); +DLL_FUNCTION(void) BS_Callback_Destroy(BS_Callback* lpCallback); \ No newline at end of file diff --git a/Helpers/Helper.cpp b/Helpers/Helper.cpp new file mode 100644 index 0000000..af2679e --- /dev/null +++ b/Helpers/Helper.cpp @@ -0,0 +1,27 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "Helper.h" + +DLL_FUNCTION(const char*) BS_Helper_FormatUnixTime(uint32_t unTime, const char* pchFormat) { + char* output = new char[strlen(pchFormat) * 4]; + time_t t = unTime; + struct tm *tm = localtime(&t); + strftime(output, sizeof(output), pchFormat, tm); + delete tm; + return output; +} +#pragma comment(linker, "/EXPORT:BS_Helper_FormatUnixTime=_BS_Helper_FormatUnixTime@8") diff --git a/dllmain.h b/Helpers/Helper.h similarity index 69% rename from dllmain.h rename to Helpers/Helper.h index 1af51ce..7aac1d5 100644 --- a/dllmain.h +++ b/Helpers/Helper.h @@ -14,20 +14,7 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -// STL Exceptions -#include -#include +#pragma once +#include "BlitzSteam.h" -// Memory Management -#include - -// Platform specific: Windows -#include - -// Macros -#define DLL_EXPORT extern "C" //__declspec(dllexport) -#define DLL_METHOD extern "C" -#define DLL_CALL __stdcall - -// Steam -#include "SteamworksSDK/public/steam/steam_api.h" \ No newline at end of file +DLL_FUNCTION(const char*) BS_Helper_FormatUnixTime(uint32_t unTime, const char* pchFormat); \ No newline at end of file diff --git a/Wrapper/Steam.cpp b/Wrapper/Steam.cpp index 3b757bd..b6ca1d1 100644 --- a/Wrapper/Steam.cpp +++ b/Wrapper/Steam.cpp @@ -14,166 +14,60 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" +#include "BlitzSteam.h" -DLL_EXPORT uint32_t DLL_CALL BS_Init() { +DLL_FUNCTION(uint32_t) BS_Steam_Init() { return SteamAPI_Init(); } -#pragma comment(linker, "/EXPORT:BS_Init=_BS_Init@0") +#pragma comment(linker, "/EXPORT:BS_Steam_Init=_BS_Steam_Init@0") -DLL_EXPORT void DLL_CALL BS_Shutdown() { +DLL_FUNCTION(void) BS_Steam_Shutdown() { SteamAPI_Shutdown(); } -#pragma comment(linker, "/EXPORT:BS_Shutdown=_BS_Shutdown@0") +#pragma comment(linker, "/EXPORT:BS_Steam_Shutdown=_BS_Steam_Shutdown@0") -DLL_EXPORT uint32_t DLL_CALL BS_IsSteamRunning() { +DLL_FUNCTION(uint32_t) BS_Steam_IsSteamRunning() { return SteamAPI_IsSteamRunning(); } -#pragma comment(linker, "/EXPORT:BS_IsSteamRunning=_BS_IsSteamRunning@0") +#pragma comment(linker, "/EXPORT:BS_Steam_IsSteamRunning=_BS_Steam_IsSteamRunning@0") -DLL_EXPORT uint32_t DLL_CALL BS_RestartAppIfNecessary(uint32 unOwnAppID) { +DLL_FUNCTION(uint32_t) BS_Steam_RestartAppIfNecessary(uint32_t unOwnAppID) { return SteamAPI_RestartAppIfNecessary(unOwnAppID); } -#pragma comment(linker, "/EXPORT:BS_RestartAppIfNecessary=_BS_RestartAppIfNecessary@4") +#pragma comment(linker, "/EXPORT:BS_Steam_RestartAppIfNecessary=_BS_Steam_RestartAppIfNecessary@4") -DLL_EXPORT void DLL_CALL BS_SetMiniDumpComment(const char* pchMsg) { +DLL_FUNCTION(void) BS_Steam_SetMiniDumpComment(const char* pchMsg) { SteamAPI_SetMiniDumpComment(pchMsg); } -#pragma comment(linker, "/EXPORT:BS_SetMiniDumpComment=_BS_SetMiniDumpComment@4") +#pragma comment(linker, "/EXPORT:BS_Steam_SetMiniDumpComment=_BS_Steam_SetMiniDumpComment@4") -DLL_EXPORT void DLL_CALL BS_WriteMiniDump(uint32_t uStructuredExceptionCode, void* pvExceptionInfo, uint32 uBuildID) { +DLL_FUNCTION(void) BS_Steam_WriteMiniDump(uint32_t uStructuredExceptionCode, void* pvExceptionInfo, uint32_t uBuildID) { SteamAPI_WriteMiniDump(uStructuredExceptionCode, pvExceptionInfo, uBuildID); } -#pragma comment(linker, "/EXPORT:BS_WriteMiniDump=_BS_WriteMiniDump@12") +#pragma comment(linker, "/EXPORT:BS_Steam_WriteMiniDump=_BS_Steam_WriteMiniDump@12") -// Interface Pointers, configured by SteamAPI_Init(). -DLL_EXPORT ISteamClient* DLL_CALL BS_Client() { - return SteamClient(); -} -#pragma comment(linker, "/EXPORT:BS_Client=_BS_Client@0") - -DLL_EXPORT ISteamUser* DLL_CALL BS_User() { - return SteamUser(); -} -#pragma comment(linker, "/EXPORT:BS_User=_BS_User@0") - -DLL_EXPORT ISteamFriends* DLL_CALL BS_Friends() { - return SteamFriends(); -} -#pragma comment(linker, "/EXPORT:BS_Friends=_BS_Friends@0") - -DLL_EXPORT ISteamUtils* DLL_CALL BS_Utils() { - return SteamUtils(); -} -#pragma comment(linker, "/EXPORT:BS_Utils=_BS_Utils@0") - -DLL_EXPORT ISteamMatchmaking* DLL_CALL BS_Matchmaking() { - return SteamMatchmaking(); -} -#pragma comment(linker, "/EXPORT:BS_Matchmaking=_BS_Matchmaking@0") - -DLL_EXPORT ISteamUserStats* DLL_CALL BS_UserStats() { - return SteamUserStats(); -} -#pragma comment(linker, "/EXPORT:BS_UserStats=_BS_UserStats@0") - -DLL_EXPORT ISteamApps* DLL_CALL BS_Apps() { - return SteamApps(); -} -#pragma comment(linker, "/EXPORT:BS_Apps=_BS_Apps@0") - -DLL_EXPORT ISteamNetworking* DLL_CALL BS_Networking() { - return SteamNetworking(); -} -#pragma comment(linker, "/EXPORT:BS_Networking=_BS_Networking@0") - -DLL_EXPORT ISteamMatchmakingServers* DLL_CALL BS_MatchmakingServers() { - return SteamMatchmakingServers(); -} -#pragma comment(linker, "/EXPORT:BS_MatchmakingServers=_BS_MatchmakingServers@0") - -DLL_EXPORT ISteamRemoteStorage* DLL_CALL BS_RemoteStorage() { - return SteamRemoteStorage(); -} -#pragma comment(linker, "/EXPORT:BS_RemoteStorage=_BS_RemoteStorage@0") - -DLL_EXPORT ISteamScreenshots* DLL_CALL BS_Screenshots() { - return SteamScreenshots(); -} -#pragma comment(linker, "/EXPORT:BS_Screenshots=_BS_Screenshots@0") - -DLL_EXPORT ISteamHTTP* DLL_CALL BS_HTTP() { - return SteamHTTP(); -} -#pragma comment(linker, "/EXPORT:BS_HTTP=_BS_HTTP@0") - -DLL_EXPORT ISteamUnifiedMessages* DLL_CALL BS_UnifiedMessages() { - return SteamUnifiedMessages(); -} -#pragma comment(linker, "/EXPORT:BS_UnifiedMessages=_BS_UnifiedMessages@0") - -DLL_EXPORT ISteamController* DLL_CALL BS_Controller() { - return SteamController(); -} -#pragma comment(linker, "/EXPORT:BS_Controller=_BS_Controller@0") - -DLL_EXPORT ISteamUGC* DLL_CALL BS_UGC() { - return SteamUGC(); -} -#pragma comment(linker, "/EXPORT:BS_UGC=_BS_UGC@0") - -DLL_EXPORT ISteamAppList* DLL_CALL BS_AppList() { - return SteamAppList(); -} -#pragma comment(linker, "/EXPORT:BS_AppList=_BS_AppList@0") - -DLL_EXPORT ISteamMusic* DLL_CALL BS_Music() { - return SteamMusic(); -} -#pragma comment(linker, "/EXPORT:BS_Music=_BS_Music@0") - -DLL_EXPORT ISteamMusicRemote* DLL_CALL BS_MusicRemote() { - return SteamMusicRemote(); -} -#pragma comment(linker, "/EXPORT:BS_MusicRemote=_BS_MusicRemote@0") - -DLL_EXPORT ISteamHTMLSurface* DLL_CALL BS_HTMLSurface() { - return SteamHTMLSurface(); -} -#pragma comment(linker, "/EXPORT:BS_HTMLSurface=_BS_HTMLSurface@0") - -DLL_EXPORT ISteamInventory* DLL_CALL BS_Inventory() { - return SteamInventory(); -} -#pragma comment(linker, "/EXPORT:BS_Inventory=_BS_Inventory@0") - -DLL_EXPORT ISteamVideo* DLL_CALL BS_Video() { - return SteamVideo(); -} -#pragma comment(linker, "/EXPORT:BS_Video=_BS_Video@0") - -// Callbacks & Hooks -DLL_EXPORT void DLL_CALL BS_RunCallbacks() { +// -- Callbacks +DLL_FUNCTION(void) BS_Steam_RunCallbacks() { SteamAPI_RunCallbacks(); } -#pragma comment(linker, "/EXPORT:BS_RunCallbacks=_BS_RunCallbacks@0") +#pragma comment(linker, "/EXPORT:BS_Steam_RunCallbacks=_BS_Steam_RunCallbacks@0") -DLL_EXPORT void DLL_CALL BS_RegisterCallback(class CCallbackBase *pCallback, int iCallback) { +DLL_FUNCTION(void) BS_Steam_RegisterCallback(class CCallbackBase *pCallback, uint32_t iCallback) { SteamAPI_RegisterCallback(pCallback, iCallback); } -#pragma comment(linker, "/EXPORT:BS_RegisterCallback=_BS_RegisterCallback@8") +#pragma comment(linker, "/EXPORT:BS_Steam_RegisterCallback=_BS_Steam_RegisterCallback@8") -DLL_EXPORT void DLL_CALL BS_UnregisterCallback(class CCallbackBase *pCallback) { +DLL_FUNCTION(void) BS_Steam_UnregisterCallback(class CCallbackBase *pCallback) { SteamAPI_UnregisterCallback(pCallback); } -#pragma comment(linker, "/EXPORT:BS_UnregisterCallback=_BS_UnregisterCallback@4") +#pragma comment(linker, "/EXPORT:BS_Steam_UnregisterCallback=_BS_Steam_UnregisterCallback@4") -DLL_EXPORT void DLL_CALL BS_RegisterCallResult(class CCallbackBase *pCallback, uint32_t hAPICall_L, uint32_t hAPICall_R) { - SteamAPI_RegisterCallResult(pCallback, ((uint64_t)hAPICall_L << 32) + (uint64_t)hAPICall_R); +DLL_FUNCTION(void) BS_Steam_RegisterCallResult(class CCallbackBase *pCallback, uint64_t* phAPICall) { + SteamAPI_RegisterCallResult(pCallback, *phAPICall); } -#pragma comment(linker, "/EXPORT:BS_RegisterCallResult=_BS_RegisterCallResult@12") +#pragma comment(linker, "/EXPORT:BS_Steam_RegisterCallResult=_BS_Steam_RegisterCallResult@8") -DLL_EXPORT void DLL_CALL BS_UnregisterCallResult(class CCallbackBase *pCallback, uint32_t hAPICall_L, uint32_t hAPICall_R) { - SteamAPI_UnregisterCallResult(pCallback, ((uint64_t)hAPICall_L << 32) + (uint64_t)hAPICall_R); +DLL_FUNCTION(void) BS_Steam_UnregisterCallResult(class CCallbackBase *pCallback, uint64_t* phAPICall) { + SteamAPI_UnregisterCallResult(pCallback, *phAPICall); } -#pragma comment(linker, "/EXPORT:BS_UnregisterCallResult=_BS_UnregisterCallResult@12") +#pragma comment(linker, "/EXPORT:BS_Steam_UnregisterCallResult=_BS_Steam_UnregisterCallResult@8") diff --git a/Wrapper/SteamAppList.cpp b/Wrapper/SteamAppList.cpp index 7425700..791f38f 100644 --- a/Wrapper/SteamAppList.cpp +++ b/Wrapper/SteamAppList.cpp @@ -14,29 +14,34 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" +#include "BlitzSteam.h" -DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetNumInstalledApps(ISteamAppList* lpSteamAppList) { +DLL_FUNCTION(ISteamAppList*) BS_AppList() { + return SteamAppList(); +} +#pragma comment(linker, "/EXPORT:BS_AppList=_BS_AppList@0") + +DLL_FUNCTION(uint32_t) BS_AppList_GetNumInstalledApps(ISteamAppList* lpSteamAppList) { return lpSteamAppList->GetNumInstalledApps(); } #pragma comment(linker, "/EXPORT:BS_AppList_GetNumInstalledApps=_BS_AppList_GetNumInstalledApps@4") -DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetInstalledApps(ISteamAppList* lpSteamAppList, AppId_t *pvecAppID, uint32 unMaxAppIDs) { +DLL_FUNCTION(uint32_t) BS_AppList_GetInstalledApps(ISteamAppList* lpSteamAppList, AppId_t *pvecAppID, uint32_t unMaxAppIDs) { return lpSteamAppList->GetInstalledApps(pvecAppID, unMaxAppIDs); } #pragma comment(linker, "/EXPORT:BS_AppList_GetInstalledApps=_BS_AppList_GetInstalledApps@12") -DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetAppName(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchName, uint32_t cchNameMax) { +DLL_FUNCTION(uint32_t) BS_AppList_GetAppName(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchName, uint32_t cchNameMax) { return lpSteamAppList->GetAppName(nAppID, pchName, cchNameMax); } #pragma comment(linker, "/EXPORT:BS_AppList_GetAppName=_BS_AppList_GetAppName@16") -DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetAppInstallDir(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchDirectory, uint32_t cchDirectoryMax) { +DLL_FUNCTION(uint32_t) BS_AppList_GetAppInstallDir(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchDirectory, uint32_t cchDirectoryMax) { return lpSteamAppList->GetAppInstallDir(nAppID, pchDirectory, cchDirectoryMax); } #pragma comment(linker, "/EXPORT:BS_AppList_GetAppInstallDir=_BS_AppList_GetAppInstallDir@16") -DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetAppBuildId(ISteamAppList* lpSteamAppList, AppId_t nAppID) { +DLL_FUNCTION(uint32_t) BS_AppList_GetAppBuildId(ISteamAppList* lpSteamAppList, AppId_t nAppID) { return lpSteamAppList->GetAppBuildId(nAppID); } #pragma comment(linker, "/EXPORT:BS_AppList_GetAppBuildId=_BS_AppList_GetAppBuildId@8") diff --git a/Wrapper/SteamApps.cpp b/Wrapper/SteamApps.cpp index 91860ba..75e27f1 100644 --- a/Wrapper/SteamApps.cpp +++ b/Wrapper/SteamApps.cpp @@ -14,126 +14,130 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" -#include "Helpers/CSteamID.h" +#include "BlitzSteam.h" -DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsSubscribed(ISteamApps* lpSteamApps) { +DLL_FUNCTION(ISteamApps*) BS_Apps() { + return SteamApps(); +} +#pragma comment(linker, "/EXPORT:BS_Apps=_BS_Apps@0") + +DLL_FUNCTION(uint32_t) BS_Apps_IsSubscribed(ISteamApps* lpSteamApps) { return lpSteamApps->BIsSubscribed(); } #pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribed=_BS_Apps_IsSubscribed@4") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsLowViolence(ISteamApps* lpSteamApps) { +DLL_FUNCTION(uint32_t) BS_Apps_IsLowViolence(ISteamApps* lpSteamApps) { return lpSteamApps->BIsLowViolence(); } #pragma comment(linker, "/EXPORT:BS_Apps_IsLowViolence=_BS_Apps_IsLowViolence@4") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsCybercafe(ISteamApps* lpSteamApps) { +DLL_FUNCTION(uint32_t) BS_Apps_IsCybercafe(ISteamApps* lpSteamApps) { return lpSteamApps->BIsCybercafe(); } #pragma comment(linker, "/EXPORT:BS_Apps_IsCybercafe=_BS_Apps_IsCybercafe@4") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsVACBanned(ISteamApps* lpSteamApps) { +DLL_FUNCTION(uint32_t) BS_Apps_IsVACBanned(ISteamApps* lpSteamApps) { return lpSteamApps->BIsVACBanned(); } #pragma comment(linker, "/EXPORT:BS_Apps_IsVACBanned=_BS_Apps_IsVACBanned@4") -DLL_EXPORT const char* DLL_CALL BS_Apps_GetCurrentGameLanguage(ISteamApps* lpSteamApps) { +DLL_FUNCTION(const char*) BS_Apps_GetCurrentGameLanguage(ISteamApps* lpSteamApps) { return lpSteamApps->GetCurrentGameLanguage(); } #pragma comment(linker, "/EXPORT:BS_Apps_GetCurrentGameLanguage=_BS_Apps_GetCurrentGameLanguage@4") -DLL_EXPORT const char* DLL_CALL BS_Apps_GetAvailableGameLanguages(ISteamApps* lpSteamApps) { +DLL_FUNCTION(const char*) BS_Apps_GetAvailableGameLanguages(ISteamApps* lpSteamApps) { return lpSteamApps->GetAvailableGameLanguages(); } #pragma comment(linker, "/EXPORT:BS_Apps_GetAvailableGameLanguages=_BS_Apps_GetAvailableGameLanguages@4") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsSubscribedApp(ISteamApps* lpSteamApps, AppId_t appID) { +DLL_FUNCTION(uint32_t) BS_Apps_IsSubscribedApp(ISteamApps* lpSteamApps, AppId_t appID) { return lpSteamApps->BIsSubscribedApp(appID); } #pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribedApp=_BS_Apps_IsSubscribedApp@8") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsDlcInstalled(ISteamApps* lpSteamApps, AppId_t appID) { +DLL_FUNCTION(uint32_t) BS_Apps_IsDlcInstalled(ISteamApps* lpSteamApps, AppId_t appID) { return lpSteamApps->BIsDlcInstalled(appID); } #pragma comment(linker, "/EXPORT:BS_Apps_IsDlcInstalled=_BS_Apps_IsDlcInstalled@8") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetEarliestPurchaseUnixTime(ISteamApps* lpSteamApps, AppId_t appID) { +DLL_FUNCTION(uint32_t) BS_Apps_GetEarliestPurchaseUnixTime(ISteamApps* lpSteamApps, AppId_t appID) { return lpSteamApps->GetEarliestPurchaseUnixTime(appID); } #pragma comment(linker, "/EXPORT:BS_Apps_GetEarliestPurchaseUnixTime=_BS_Apps_GetEarliestPurchaseUnixTime@8") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsSubscribedFromFreeWeekend(ISteamApps* lpSteamApps) { +DLL_FUNCTION(uint32_t) BS_Apps_IsSubscribedFromFreeWeekend(ISteamApps* lpSteamApps) { return lpSteamApps->BIsSubscribedFromFreeWeekend(); } #pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribedFromFreeWeekend=_BS_Apps_IsSubscribedFromFreeWeekend@4") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetDLCCount(ISteamApps* lpSteamApps) { +DLL_FUNCTION(uint32_t) BS_Apps_GetDLCCount(ISteamApps* lpSteamApps) { return lpSteamApps->GetDLCCount(); } #pragma comment(linker, "/EXPORT:BS_Apps_GetDLCCount=_BS_Apps_GetDLCCount@4") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetDLCDataByIndex(ISteamApps* lpSteamApps, uint32_t iDLC, AppId_t *pAppId, bool* pbAvailable, char *pchName, uint32_t cchNameBufferSize) { +DLL_FUNCTION(uint32_t) BS_Apps_GetDLCDataByIndex(ISteamApps* lpSteamApps, uint32_t iDLC, AppId_t *pAppId, bool* pbAvailable, char *pchName, uint32_t cchNameBufferSize) { return lpSteamApps->BGetDLCDataByIndex(iDLC, pAppId, (bool*)pbAvailable, pchName, cchNameBufferSize); } #pragma comment(linker, "/EXPORT:BS_Apps_GetDLCDataByIndex=_BS_Apps_GetDLCDataByIndex@24") -DLL_EXPORT void DLL_CALL BS_Apps_InstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) { +DLL_FUNCTION(void) BS_Apps_InstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) { lpSteamApps->InstallDLC(nAppID); } #pragma comment(linker, "/EXPORT:BS_Apps_InstallDLC=_BS_Apps_InstallDLC@8") -DLL_EXPORT void DLL_CALL BS_Apps_UninstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) { +DLL_FUNCTION(void) BS_Apps_UninstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) { lpSteamApps->UninstallDLC(nAppID); } #pragma comment(linker, "/EXPORT:BS_Apps_UninstallDLC=_BS_Apps_UninstallDLC@8") -DLL_EXPORT void DLL_CALL BS_Apps_RequestAppProofOfPurchaseKey(ISteamApps* lpSteamApps, AppId_t nAppID) { +DLL_FUNCTION(void) BS_Apps_RequestAppProofOfPurchaseKey(ISteamApps* lpSteamApps, AppId_t nAppID) { lpSteamApps->RequestAppProofOfPurchaseKey(nAppID); } #pragma comment(linker, "/EXPORT:BS_Apps_RequestAppProofOfPurchaseKey=_BS_Apps_RequestAppProofOfPurchaseKey@8") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetCurrentBetaName(ISteamApps* lpSteamApps, char *pchName, int cchNameBufferSize) { +DLL_FUNCTION(uint32_t) BS_Apps_GetCurrentBetaName(ISteamApps* lpSteamApps, char *pchName, int cchNameBufferSize) { return lpSteamApps->GetCurrentBetaName(pchName, cchNameBufferSize); } #pragma comment(linker, "/EXPORT:BS_Apps_GetCurrentBetaName=_BS_Apps_GetCurrentBetaName@12") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_MarkContentCorrupt(ISteamApps* lpSteamApps, uint32_t bMissingFilesOnly) { +DLL_FUNCTION(uint32_t) BS_Apps_MarkContentCorrupt(ISteamApps* lpSteamApps, uint32_t bMissingFilesOnly) { return lpSteamApps->MarkContentCorrupt(bMissingFilesOnly != 0); } #pragma comment(linker, "/EXPORT:BS_Apps_MarkContentCorrupt=_BS_Apps_MarkContentCorrupt@8") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetInstalledDepots(ISteamApps* lpSteamApps, AppId_t nAppID, DepotId_t *pvecDepots, uint32_t cMaxDepots) { +DLL_FUNCTION(uint32_t) BS_Apps_GetInstalledDepots(ISteamApps* lpSteamApps, AppId_t nAppID, DepotId_t *pvecDepots, uint32_t cMaxDepots) { return lpSteamApps->GetInstalledDepots(nAppID, pvecDepots, cMaxDepots); } #pragma comment(linker, "/EXPORT:BS_Apps_GetInstalledDepots=_BS_Apps_GetInstalledDepots@16") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetAppInstallDir(ISteamApps* lpSteamApps, AppId_t appID, char *pchFolder, uint32 cchFolderBufferSize) { +DLL_FUNCTION(uint32_t) BS_Apps_GetAppInstallDir(ISteamApps* lpSteamApps, AppId_t appID, char *pchFolder, uint32_t cchFolderBufferSize) { return lpSteamApps->GetAppInstallDir(appID, pchFolder, cchFolderBufferSize); } #pragma comment(linker, "/EXPORT:BS_Apps_GetAppInstallDir=_BS_Apps_GetAppInstallDir@16") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsAppInstalled(ISteamApps* lpSteamApps, AppId_t appID) { +DLL_FUNCTION(uint32_t) BS_Apps_IsAppInstalled(ISteamApps* lpSteamApps, AppId_t appID) { return lpSteamApps->BIsAppInstalled(appID); } #pragma comment(linker, "/EXPORT:BS_Apps_IsAppInstalled=_BS_Apps_IsAppInstalled@8") -DLL_EXPORT CSteamID* DLL_CALL BS_Apps_GetAppOwner(ISteamApps* lpSteamApps) { +DLL_FUNCTION(CSteamID*) BS_Apps_GetAppOwner(ISteamApps* lpSteamApps) { CSteamID* steamID = new CSteamID(lpSteamApps->GetAppOwner()); return BS_CSteamID_Copy(steamID); } #pragma comment(linker, "/EXPORT:BS_Apps_GetAppOwner=_BS_Apps_GetAppOwner@4") -DLL_EXPORT const char* DLL_CALL BS_Apps_GetLaunchQueryParam(ISteamApps* lpSteamApps, const char *pchKey) { +DLL_FUNCTION(const char*) BS_Apps_GetLaunchQueryParam(ISteamApps* lpSteamApps, const char *pchKey) { return lpSteamApps->GetLaunchQueryParam(pchKey); } #pragma comment(linker, "/EXPORT:BS_Apps_GetLaunchQueryParam=_BS_Apps_GetLaunchQueryParam@8") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetDlcDownloadProgress(ISteamApps* lpSteamApps, AppId_t nAppID, uint64_t* punBytesDownloaded, uint64_t* punBytesTotal) { +DLL_FUNCTION(uint32_t) BS_Apps_GetDlcDownloadProgress(ISteamApps* lpSteamApps, AppId_t nAppID, uint64_t* punBytesDownloaded, uint64_t* punBytesTotal) { return lpSteamApps->GetDlcDownloadProgress(nAppID, punBytesDownloaded, punBytesTotal); } #pragma comment(linker, "/EXPORT:BS_Apps_GetDlcDownloadProgress=_BS_Apps_GetDlcDownloadProgress@16") -DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetAppBuildId(ISteamApps* lpSteamApps) { +DLL_FUNCTION(uint32_t) BS_Apps_GetAppBuildId(ISteamApps* lpSteamApps) { return lpSteamApps->GetAppBuildId(); } #pragma comment(linker, "/EXPORT:BS_Apps_GetAppBuildId=_BS_Apps_GetAppBuildId@4") diff --git a/Wrapper/SteamClient.cpp b/Wrapper/SteamClient.cpp index ff5556e..4b4a5f0 100644 --- a/Wrapper/SteamClient.cpp +++ b/Wrapper/SteamClient.cpp @@ -14,180 +14,185 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" +#include "BlitzSteam.h" -DLL_EXPORT HSteamPipe DLL_CALL BS_Client_CreateSteamPipe(ISteamClient* lpSteamClient) { +DLL_FUNCTION(ISteamClient*) BS_Client() { + return SteamClient(); +} +#pragma comment(linker, "/EXPORT:BS_Client=_BS_Client@0") + +DLL_FUNCTION(HSteamPipe) BS_Client_CreateSteamPipe(ISteamClient* lpSteamClient) { return lpSteamClient->CreateSteamPipe(); } #pragma comment(linker, "/EXPORT:BS_Client_CreateSteamPipe=_BS_Client_CreateSteamPipe@4") -DLL_EXPORT uint32_t DLL_CALL BS_Client_ReleaseSteamPipe(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) { +DLL_FUNCTION(uint32_t) BS_Client_ReleaseSteamPipe(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) { return lpSteamClient->BReleaseSteamPipe(hSteamPipe); } #pragma comment(linker, "/EXPORT:BS_Client_ReleaseSteamPipe=_BS_Client_ReleaseSteamPipe@8") -DLL_EXPORT HSteamUser DLL_CALL BS_Client_ConnectToGlobalUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) { +DLL_FUNCTION(HSteamUser) BS_Client_ConnectToGlobalUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) { return lpSteamClient->ConnectToGlobalUser(hSteamPipe); } #pragma comment(linker, "/EXPORT:BS_Client_ConnectToGlobalUser=_BS_Client_ConnectToGlobalUser@8") -DLL_EXPORT void DLL_CALL BS_Client_SetLocalIPBinding(ISteamClient* lpSteamClient, uint32_t unIP, uint16 usPort) { +DLL_FUNCTION(void) BS_Client_SetLocalIPBinding(ISteamClient* lpSteamClient, uint32_t unIP, uint16 usPort) { return lpSteamClient->SetLocalIPBinding(unIP, usPort); } #pragma comment(linker, "/EXPORT:BS_Client_SetLocalIPBinding=_BS_Client_SetLocalIPBinding@12") -DLL_EXPORT HSteamUser DLL_CALL BS_Client_CreateLocalUser(ISteamClient* lpSteamClient, HSteamPipe* phSteamPipe, EAccountType eAccountType) { +DLL_FUNCTION(HSteamUser) BS_Client_CreateLocalUser(ISteamClient* lpSteamClient, HSteamPipe* phSteamPipe, EAccountType eAccountType) { return lpSteamClient->CreateLocalUser(phSteamPipe, eAccountType); } #pragma comment(linker, "/EXPORT:BS_Client_CreateLocalUser=_BS_Client_CreateLocalUser@12") -DLL_EXPORT void DLL_CALL BS_Client_ReleaseUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, HSteamUser hSteamUser) { +DLL_FUNCTION(void) BS_Client_ReleaseUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, HSteamUser hSteamUser) { return lpSteamClient->ReleaseUser(hSteamPipe, hSteamUser); } #pragma comment(linker, "/EXPORT:BS_Client_ReleaseUser=_BS_Client_ReleaseUser@12") -DLL_EXPORT void DLL_CALL BS_Client_RunFrame(ISteamClient* lpSteamClient) { +DLL_FUNCTION(void) BS_Client_RunFrame(ISteamClient* lpSteamClient) { lpSteamClient->RunFrame(); } #pragma comment(linker, "/EXPORT:BS_Client_RunFrame=_BS_Client_RunFrame@4") -DLL_EXPORT uint32_t DLL_CALL BS_Client_GetIPCCallCount(ISteamClient* lpSteamClient) { +DLL_FUNCTION(uint32_t) BS_Client_GetIPCCallCount(ISteamClient* lpSteamClient) { return lpSteamClient->GetIPCCallCount(); } #pragma comment(linker, "/EXPORT:BS_Client_GetIPCCallCount=_BS_Client_GetIPCCallCount@4") -DLL_EXPORT uint32_t DLL_CALL BS_Client_ShutdownIfAllPipesClosed(ISteamClient* lpSteamClient) { +DLL_FUNCTION(uint32_t) BS_Client_ShutdownIfAllPipesClosed(ISteamClient* lpSteamClient) { return lpSteamClient->BShutdownIfAllPipesClosed(); } // Interfaces -DLL_EXPORT ISteamAppList* DLL_CALL BS_Client_GetSteamAppList(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamAppList*) BS_Client_GetSteamAppList(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamAppList(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamAppList=_BS_Client_GetSteamAppList@16") -DLL_EXPORT ISteamApps* DLL_CALL BS_Client_GetSteamApps(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamApps*) BS_Client_GetSteamApps(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamApps(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamApps=_BS_Client_GetSteamApps@16") -DLL_EXPORT ISteamController* DLL_CALL BS_Client_GetSteamController(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamController*) BS_Client_GetSteamController(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamController(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamController=_BS_Client_GetSteamController@16") -DLL_EXPORT ISteamFriends* DLL_CALL BS_Client_GetSteamFriends(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamFriends*) BS_Client_GetSteamFriends(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamFriends(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamFriends=_BS_Client_GetSteamFriends@16") -DLL_EXPORT ISteamGameServer* DLL_CALL BS_Client_GetSteamGameServer(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamGameServer*) BS_Client_GetSteamGameServer(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamGameServer(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamGameServer=_BS_Client_GetSteamGameServer@16") -DLL_EXPORT ISteamGameServerStats* DLL_CALL BS_Client_GetSteamGameServerStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamGameServerStats*) BS_Client_GetSteamGameServerStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamGameServerStats(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamGameServerStats=_BS_Client_GetSteamGameServerStats@16") -DLL_EXPORT ISteamHTMLSurface* DLL_CALL BS_Client_GetSteamHTMLSurface(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamHTMLSurface*) BS_Client_GetSteamHTMLSurface(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamHTMLSurface(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamHTMLSurface=_BS_Client_GetSteamHTMLSurface@16") -DLL_EXPORT ISteamHTTP* DLL_CALL BS_Client_GetSteamHTTP(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamHTTP*) BS_Client_GetSteamHTTP(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamHTTP(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamHTTP=_BS_Client_GetSteamHTTP@16") -DLL_EXPORT ISteamInventory* DLL_CALL BS_Client_GetSteamInventory(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamInventory*) BS_Client_GetSteamInventory(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamInventory(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamInventory=_BS_Client_GetSteamInventory@16") -DLL_EXPORT ISteamMatchmaking* DLL_CALL BS_Client_GetSteamMatchmaking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamMatchmaking*) BS_Client_GetSteamMatchmaking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamMatchmaking(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamMatchmaking=_BS_Client_GetSteamMatchmaking@16") -DLL_EXPORT ISteamMatchmakingServers* DLL_CALL BS_Client_GetSteamMatchmakingServers(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamMatchmakingServers*) BS_Client_GetSteamMatchmakingServers(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamMatchmakingServers(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamMatchmakingServers=_BS_Client_GetSteamMatchmakingServers@16") -DLL_EXPORT ISteamMusic* DLL_CALL BS_Client_GetSteamMusic(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamMusic*) BS_Client_GetSteamMusic(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamMusic(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamMusic=_BS_Client_GetSteamMusic@16") -DLL_EXPORT ISteamMusicRemote* DLL_CALL BS_Client_GetSteamMusicRemote(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamMusicRemote*) BS_Client_GetSteamMusicRemote(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamMusicRemote(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamMusicRemote=_BS_Client_GetSteamMusicRemote@16") -DLL_EXPORT ISteamNetworking* DLL_CALL BS_Client_GetSteamNetworking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamNetworking*) BS_Client_GetSteamNetworking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamNetworking(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamNetworking=_BS_Client_GetSteamNetworking@16") -DLL_EXPORT ISteamRemoteStorage* DLL_CALL BS_Client_GetSteamRemoteStorage(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamRemoteStorage*) BS_Client_GetSteamRemoteStorage(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamRemoteStorage(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamRemoteStorage=_BS_Client_GetSteamRemoteStorage@16") -DLL_EXPORT ISteamScreenshots* DLL_CALL BS_Client_GetSteamScreenshots(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamScreenshots*) BS_Client_GetSteamScreenshots(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamScreenshots(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamScreenshots=_BS_Client_GetSteamScreenshots@16") -DLL_EXPORT ISteamUGC* DLL_CALL BS_Client_GetSteamUGC(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamUGC*) BS_Client_GetSteamUGC(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamUGC(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamUGC=_BS_Client_GetSteamUGC@16") -DLL_EXPORT ISteamUnifiedMessages* DLL_CALL BS_Client_GetSteamUnifiedMessages(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamUnifiedMessages*) BS_Client_GetSteamUnifiedMessages(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamUnifiedMessages(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamUnifiedMessages=_BS_Client_GetSteamUnifiedMessages@16") -DLL_EXPORT ISteamUser* DLL_CALL BS_Client_GetSteamUser(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamUser*) BS_Client_GetSteamUser(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamUser(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamUser=_BS_Client_GetSteamUser@16") -DLL_EXPORT ISteamUserStats* DLL_CALL BS_Client_GetSteamUserStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamUserStats*) BS_Client_GetSteamUserStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamUserStats(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamUserStats=_BS_Client_GetSteamUserStats@16") -DLL_EXPORT ISteamUtils* DLL_CALL BS_Client_GetSteamUtils(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamUtils*) BS_Client_GetSteamUtils(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamUtils(hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamUtils=_BS_Client_GetSteamUtils@12") -DLL_EXPORT ISteamVideo* DLL_CALL BS_Client_GetSteamVideo(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { +DLL_FUNCTION(ISteamVideo*) BS_Client_GetSteamVideo(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) { return lpSteamClient->GetISteamVideo(hSteamUser, hSteamPipe, pchVersion); } #pragma comment(linker, "/EXPORT:BS_Client_GetSteamVideo=_BS_Client_GetSteamVideo@16") // Callbacks & Hooks -DLL_EXPORT void DLL_CALL BS_Client_SetWarningMessageHook(ISteamClient* lpSteamClient, SteamAPIWarningMessageHook_t fpfunction) { +DLL_FUNCTION(void) BS_Client_SetWarningMessageHook(ISteamClient* lpSteamClient, SteamAPIWarningMessageHook_t fpfunction) { lpSteamClient->SetWarningMessageHook(fpfunction); } #pragma comment(linker, "/EXPORT:BS_Client_SetWarningMessageHook=_BS_Client_SetWarningMessageHook@8") -DLL_EXPORT void DLL_CALL BS_Client_Set_SteamAPI_CPostAPIResultInProcess(ISteamClient* lpSteamClient, SteamAPI_PostAPIResultInProcess_t fpFunction) { +DLL_FUNCTION(void) BS_Client_Set_SteamAPI_CPostAPIResultInProcess(ISteamClient* lpSteamClient, SteamAPI_PostAPIResultInProcess_t fpFunction) { lpSteamClient->Set_SteamAPI_CPostAPIResultInProcess(fpFunction); } #pragma comment(linker, "/EXPORT:BS_Client_Set_SteamAPI_CPostAPIResultInProcess=_BS_Client_Set_SteamAPI_CPostAPIResultInProcess@8") -DLL_EXPORT void DLL_CALL BS_Client_Remove_SteamAPI_CPostAPIResultInProcess(ISteamClient* lpSteamClient, SteamAPI_PostAPIResultInProcess_t fpFunction) { +DLL_FUNCTION(void) BS_Client_Remove_SteamAPI_CPostAPIResultInProcess(ISteamClient* lpSteamClient, SteamAPI_PostAPIResultInProcess_t fpFunction) { lpSteamClient->Remove_SteamAPI_CPostAPIResultInProcess(fpFunction); } #pragma comment(linker, "/EXPORT:BS_Client_Remove_SteamAPI_CPostAPIResultInProcess=_BS_Client_Remove_SteamAPI_CPostAPIResultInProcess@8") -DLL_EXPORT void DLL_CALL BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess(ISteamClient* lpSteamClient, SteamAPI_CheckCallbackRegistered_t fpFunction) { +DLL_FUNCTION(void) BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess(ISteamClient* lpSteamClient, SteamAPI_CheckCallbackRegistered_t fpFunction) { lpSteamClient->Set_SteamAPI_CCheckCallbackRegisteredInProcess(fpFunction); } #pragma comment(linker, "/EXPORT:BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess=_BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess@8") diff --git a/Wrapper/SteamController.cpp b/Wrapper/SteamController.cpp index d0776ac..421d84b 100644 --- a/Wrapper/SteamController.cpp +++ b/Wrapper/SteamController.cpp @@ -14,35 +14,40 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" +#include "BlitzSteam.h" -DLL_EXPORT uint32_t DLL_CALL BS_Controller_Init(ISteamController* lpSteamController) { +DLL_FUNCTION(ISteamController*) BS_Controller() { + return SteamController(); +} +#pragma comment(linker, "/EXPORT:BS_Controller=_BS_Controller@0") + +DLL_FUNCTION(uint32_t) BS_Controller_Init(ISteamController* lpSteamController) { return lpSteamController->Init(); } #pragma comment(linker, "/EXPORT:BS_Controller_Init=_BS_Controller_Init@4") -DLL_EXPORT uint32_t DLL_CALL BS_Controller_Shutdown(ISteamController* lpSteamController) { +DLL_FUNCTION(uint32_t) BS_Controller_Shutdown(ISteamController* lpSteamController) { return lpSteamController->Shutdown(); } #pragma comment(linker, "/EXPORT:BS_Controller_Shutdown=_BS_Controller_Shutdown@4") -DLL_EXPORT void DLL_CALL BS_Controller_RunFrame(ISteamController* lpSteamController) { +DLL_FUNCTION(void) BS_Controller_RunFrame(ISteamController* lpSteamController) { lpSteamController->RunFrame(); } #pragma comment(linker, "/EXPORT:BS_Controller_RunFrame=_BS_Controller_RunFrame@4") #if 0 -DLL_EXPORT uint32_t DLL_CALL BS_Controller_GetControllerState( ISteamController* lpSteamController, uint32_t unControllerIndex, SteamControllerState_t *pState ) { +DLL_FUNCTION(uint32_t) BS_Controller_GetControllerState( ISteamController* lpSteamController, uint32_t unControllerIndex, SteamControllerState_t *pState ) { return lpSteamController->GetControllerState( unControllerIndex, pState ); } #pragma comment(linker, "/EXPORT:BS_Controller_GetControllerState=_BS_Controller_GetControllerState@12") -DLL_EXPORT void DLL_CALL BS_Controller_TriggerHapticPulse( ISteamController* lpSteamController, uint32_t unControllerIndex, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec ) { +DLL_FUNCTION(void) BS_Controller_TriggerHapticPulse( ISteamController* lpSteamController, uint32_t unControllerIndex, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec ) { lpSteamController->TriggerHapticPulse( unControllerIndex, eTargetPad, usDurationMicroSec ); } #pragma comment(linker, "/EXPORT:BS_Controller_TriggerHapticPulse=_BS_Controller_TriggerHapticPulse@16") -DLL_EXPORT void DLL_CALL BS_Controller_SetOverrideMode( ISteamController* lpSteamController, const char *pchMode ) { +DLL_FUNCTION(void) BS_Controller_SetOverrideMode( ISteamController* lpSteamController, const char *pchMode ) { lpSteamController->SetOverrideMode( pchMode ); } #pragma comment(linker, "/EXPORT:BS_Controller_SetOverrideMode=_BS_Controller_SetOverrideMode@8") diff --git a/Wrapper/SteamFriends.cpp b/Wrapper/SteamFriends.cpp index eed5d3b..7118b37 100644 --- a/Wrapper/SteamFriends.cpp +++ b/Wrapper/SteamFriends.cpp @@ -14,65 +14,70 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" +#include "BlitzSteam.h" -DLL_EXPORT const char* DLL_CALL BS_Friends_GetPersonaName(ISteamFriends* lpSteamFriends) { +DLL_FUNCTION(ISteamFriends*) BS_Friends() { + return SteamFriends(); +} +#pragma comment(linker, "/EXPORT:BS_Friends=_BS_Friends@0") + +DLL_FUNCTION(const char*) BS_Friends_GetPersonaName(ISteamFriends* lpSteamFriends) { return lpSteamFriends->GetPersonaName(); } #pragma comment(linker, "/EXPORT:BS_Friends_GetPersonaName=_BS_Friends_GetPersonaName@4") -DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_SetPersonaName(ISteamFriends* lpSteamFriends, const char* pchPersonaName) { - return lpSteamFriends->SetPersonaName(pchPersonaName); +DLL_FUNCTION(SteamAPICall_t*) BS_Friends_SetPersonaName(ISteamFriends* lpSteamFriends, const char* pchPersonaName) { + return new uint64_t(lpSteamFriends->SetPersonaName(pchPersonaName)); } #pragma comment(linker, "/EXPORT:BS_Friends_SetPersonaName=_BS_Friends_SetPersonaName@8") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetPersonaState(ISteamFriends* lpSteamFriends) { +DLL_FUNCTION(int32_t) BS_Friends_GetPersonaState(ISteamFriends* lpSteamFriends) { return lpSteamFriends->GetPersonaState(); } #pragma comment(linker, "/EXPORT:BS_Friends_GetPersonaState=_BS_Friends_GetPersonaState@4") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendCount(ISteamFriends* lpSteamFriends, int32_t iFriendFlags) { +DLL_FUNCTION(int32_t) BS_Friends_GetFriendCount(ISteamFriends* lpSteamFriends, int32_t iFriendFlags) { return lpSteamFriends->GetFriendCount(iFriendFlags); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCount=_BS_Friends_GetFriendCount@8") -DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetFriendByIndex(ISteamFriends* lpSteamFriends, int32_t iFriend, int32_t iFriendFlags) { +DLL_FUNCTION(CSteamID*) BS_Friends_GetFriendByIndex(ISteamFriends* lpSteamFriends, int32_t iFriend, int32_t iFriendFlags) { CSteamID* pSteamID = new CSteamID(lpSteamFriends->GetFriendByIndex(iFriend, iFriendFlags)); return pSteamID; } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendByIndex=_BS_Friends_GetFriendByIndex@12") -DLL_EXPORT EFriendRelationship DLL_CALL BS_Friends_GetFriendRelationship(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { +DLL_FUNCTION(EFriendRelationship) BS_Friends_GetFriendRelationship(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { return lpSteamFriends->GetFriendRelationship(*steamIDFriend); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRelationship=_BS_Friends_GetFriendRelationship@8") -DLL_EXPORT EPersonaState DLL_CALL BS_Friends_GetFriendPersonaState(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { +DLL_FUNCTION(EPersonaState) BS_Friends_GetFriendPersonaState(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { return lpSteamFriends->GetFriendPersonaState(*steamIDFriend); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaState=_BS_Friends_GetFriendPersonaState@8") -DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendPersonaName(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { +DLL_FUNCTION(const char*) BS_Friends_GetFriendPersonaName(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { return lpSteamFriends->GetFriendPersonaName(*steamIDFriend); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaName=_BS_Friends_GetFriendPersonaName@8") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_GetFriendGamePlayed(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, FriendGameInfo_t *pFriendGameInfo) { +DLL_FUNCTION(uint32_t) BS_Friends_GetFriendGamePlayed(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, FriendGameInfo_t *pFriendGameInfo) { return lpSteamFriends->GetFriendGamePlayed(*steamIDFriend, pFriendGameInfo); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendGamePlayed=_BS_Friends_GetFriendGamePlayed@12") -DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendPersonaNameHistory(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iPersonaName) { +DLL_FUNCTION(const char*) BS_Friends_GetFriendPersonaNameHistory(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iPersonaName) { return lpSteamFriends->GetFriendPersonaNameHistory(*steamIDFriend, iPersonaName); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaNameHistory=_BS_Friends_GetFriendPersonaNameHistory@12") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendSteamLevel(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { +DLL_FUNCTION(int32_t) BS_Friends_GetFriendSteamLevel(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { return lpSteamFriends->GetFriendSteamLevel(*steamIDFriend); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendSteamLevel=_BS_Friends_GetFriendSteamLevel@8") -DLL_EXPORT const char* DLL_CALL BS_Friends_GetPlayerNickname(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriends) { +DLL_FUNCTION(const char*) BS_Friends_GetPlayerNickname(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriends) { const char* nickname = lpSteamFriends->GetPlayerNickname(*steamIDFriends); if (nickname == NULL) { nickname = ""; @@ -81,298 +86,296 @@ DLL_EXPORT const char* DLL_CALL BS_Friends_GetPlayerNickname(ISteamFriends* lpSt } #pragma comment(linker, "/EXPORT:BS_Friends_GetPlayerNickname=_BS_Friends_GetPlayerNickname@8") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendsGroupCount(ISteamFriends* lpSteamFriends) { +DLL_FUNCTION(int32_t) BS_Friends_GetFriendsGroupCount(ISteamFriends* lpSteamFriends) { return lpSteamFriends->GetFriendsGroupCount(); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupCount=_BS_Friends_GetFriendsGroupCount@4") -DLL_EXPORT FriendsGroupID_t DLL_CALL BS_Friends_GetFriendsGroupIDByIndex(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) { +DLL_FUNCTION(FriendsGroupID_t) BS_Friends_GetFriendsGroupIDByIndex(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) { return lpSteamFriends->GetFriendsGroupIDByIndex(friendsGroupID); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupIDByIndex=_BS_Friends_GetFriendsGroupIDByIndex@8") -DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendsGroupName(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) { +DLL_FUNCTION(const char*) BS_Friends_GetFriendsGroupName(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) { return lpSteamFriends->GetFriendsGroupName(friendsGroupID); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupName=_BS_Friends_GetFriendsGroupName@8") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendsGroupMembersCount(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) { +DLL_FUNCTION(int32_t) BS_Friends_GetFriendsGroupMembersCount(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) { return lpSteamFriends->GetFriendsGroupMembersCount(friendsGroupID); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupMembersCount=_BS_Friends_GetFriendsGroupMembersCount@8") -DLL_EXPORT void DLL_CALL BS_Friends_GetFriendsGroupMembersList(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID, CSteamID* pOutSteamIDMembers, int32_t nMembersCount) { +DLL_FUNCTION(void) BS_Friends_GetFriendsGroupMembersList(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID, CSteamID* pOutSteamIDMembers, int32_t nMembersCount) { lpSteamFriends->GetFriendsGroupMembersList(friendsGroupID, pOutSteamIDMembers, nMembersCount); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupMembersList=_BS_Friends_GetFriendsGroupMembersList@16") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_HasFriend(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iFriendsFlags) { +DLL_FUNCTION(uint32_t) BS_Friends_HasFriend(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iFriendsFlags) { return lpSteamFriends->HasFriend(*steamIDFriend, iFriendsFlags); } #pragma comment(linker, "/EXPORT:BS_Friends_HasFriends=_BS_Friends_HasFriend@12") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetClanCount(ISteamFriends* lpSteamFriends) { +DLL_FUNCTION(int32_t) BS_Friends_GetClanCount(ISteamFriends* lpSteamFriends) { return lpSteamFriends->GetClanCount(); } #pragma comment(linker, "/EXPORT:BS_Friends_GetClanCount=_BS_Friends_GetClanCount@4") -DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetClanByIndex(ISteamFriends* lpSteamFriends, int32_t iClan) { +DLL_FUNCTION(CSteamID*) BS_Friends_GetClanByIndex(ISteamFriends* lpSteamFriends, int32_t iClan) { CSteamID* steamID = new CSteamID(lpSteamFriends->GetClanByIndex(iClan)); return steamID; } #pragma comment(linker, "/EXPORT:BS_Friends_GetClanByIndex=_BS_Friends_GetClanByIndex@8") -DLL_EXPORT const char* DLL_CALL BS_Friends_GetClanName(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { +DLL_FUNCTION(const char*) BS_Friends_GetClanName(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { return lpSteamFriends->GetClanName(*steamIDClan); } #pragma comment(linker, "/EXPORT:BS_Friends_GetClanName=_BS_Friends_GetClanName@8") -DLL_EXPORT const char* DLL_CALL BS_Friends_GetClanTag(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { +DLL_FUNCTION(const char*) BS_Friends_GetClanTag(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { return lpSteamFriends->GetClanTag(*steamIDClan); } #pragma comment(linker, "/EXPORT:BS_Friends_GetClanTag=_BS_Friends_GetClanTag@8") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_GetClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t* pnOnline, int32_t* pnInGame, int32_t* pnChatting) { +DLL_FUNCTION(uint32_t) BS_Friends_GetClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t* pnOnline, int32_t* pnInGame, int32_t* pnChatting) { return lpSteamFriends->GetClanActivityCounts(*steamIDClan, pnOnline, pnInGame, pnChatting); } #pragma comment(linker, "/EXPORT:BS_Friends_GetClanActivityCounts=_BS_Friends_GetClanActivityCounts@20") -DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_DownloadClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* psteamIDClans, int32_t cClansToRequest) { - return lpSteamFriends->DownloadClanActivityCounts(psteamIDClans, cClansToRequest); +DLL_FUNCTION(SteamAPICall_t*) BS_Friends_DownloadClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* psteamIDClans, int32_t cClansToRequest) { + return new uint64_t(lpSteamFriends->DownloadClanActivityCounts(psteamIDClans, cClansToRequest)); } #pragma comment(linker, "/EXPORT:BS_Friends_DownloadClanActivityCounts=_BS_Friends_DownloadClanActivityCounts@12") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendCountFromSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource) { +DLL_FUNCTION(int32_t) BS_Friends_GetFriendCountFromSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource) { return lpSteamFriends->GetFriendCountFromSource(*steamIDSource); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCountFromSource=_BS_Friends_GetFriendCountFromSource@8") -DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetFriendFromSourceByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource, int32_t iFriend) { - CSteamID* steamID = new CSteamID(lpSteamFriends->GetFriendFromSourceByIndex(*steamIDSource, iFriend)); - return steamID; +DLL_FUNCTION(CSteamID*) BS_Friends_GetFriendFromSourceByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource, int32_t iFriend) { + return new CSteamID(lpSteamFriends->GetFriendFromSourceByIndex(*steamIDSource, iFriend)); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendFromSourceByIndex=_BS_Friends_GetFriendFromSourceByIndex@12") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_IsUserInSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, CSteamID* steamIDSource) { +DLL_FUNCTION(uint32_t) BS_Friends_IsUserInSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, CSteamID* steamIDSource) { return lpSteamFriends->IsUserInSource(*steamIDUser, *steamIDSource); } #pragma comment(linker, "/EXPORT:BS_Friends_IsUserInSource=_BS_Friends_IsUserInSource@12") -DLL_EXPORT void DLL_CALL BS_Friends_SetInGameVoiceSpeaking(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bSpeaking) { +DLL_FUNCTION(void) BS_Friends_SetInGameVoiceSpeaking(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bSpeaking) { lpSteamFriends->SetInGameVoiceSpeaking(*steamIDUser, bSpeaking != 0); } #pragma comment(linker, "/EXPORT:BS_Friends_SetInGameVoiceSpeaking=_BS_Friends_SetInGameVoiceSpeaking@12") -DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlay(ISteamFriends* lpSteamFriends, const char* pchDialog) { +DLL_FUNCTION(void) BS_Friends_ActivateGameOverlay(ISteamFriends* lpSteamFriends, const char* pchDialog) { lpSteamFriends->ActivateGameOverlay(pchDialog); } #pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlay=_BS_Friends_ActivateGameOverlay@8") -DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlayToUser(ISteamFriends* lpSteamFriends, const char* pchDialog, CSteamID* steamID) { +DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayToUser(ISteamFriends* lpSteamFriends, const char* pchDialog, CSteamID* steamID) { lpSteamFriends->ActivateGameOverlayToUser(pchDialog, *steamID); } #pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToUser=_BS_Friends_ActivateGameOverlayToUser@12") -DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlayToWebPage(ISteamFriends* lpSteamFriends, const char* pchURL) { +DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayToWebPage(ISteamFriends* lpSteamFriends, const char* pchURL) { lpSteamFriends->ActivateGameOverlayToWebPage(pchURL); } #pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToWebPage=_BS_Friends_ActivateGameOverlayToWebPage@8") -DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlayToStore(ISteamFriends* lpSteamFriends, AppId_t nAppID, EOverlayToStoreFlag eFlag) { +DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayToStore(ISteamFriends* lpSteamFriends, AppId_t nAppID, EOverlayToStoreFlag eFlag) { lpSteamFriends->ActivateGameOverlayToStore(nAppID, eFlag); } #pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToStore=_BS_Friends_ActivateGameOverlayToStore@12") -DLL_EXPORT void DLL_CALL BS_Friends_SetPlayedWith(ISteamFriends* lpSteamFriends, CSteamID* steamIDUserPlayedWith) { +DLL_FUNCTION(void) BS_Friends_SetPlayedWith(ISteamFriends* lpSteamFriends, CSteamID* steamIDUserPlayedWith) { lpSteamFriends->SetPlayedWith(*steamIDUserPlayedWith); } #pragma comment(linker, "/EXPORT:BS_Friends_SetPlayedWith=_BS_Friends_SetPlayedWith@8") -DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlayInviteDialog(ISteamFriends* lpSteamFriends, CSteamID* steamIDLobby) { +DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayInviteDialog(ISteamFriends* lpSteamFriends, CSteamID* steamIDLobby) { lpSteamFriends->ActivateGameOverlayInviteDialog(*steamIDLobby); } #pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayInviteDialog=_BS_Friends_ActivateGameOverlayInviteDialog@8") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetSmallFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { +DLL_FUNCTION(int32_t) BS_Friends_GetSmallFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { return lpSteamFriends->GetSmallFriendAvatar(*steamIDFriend); } #pragma comment(linker, "/EXPORT:BS_Friends_GetSmallFriendAvatar=_BS_Friends_GetSmallFriendAvatar@8") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetMediumFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { +DLL_FUNCTION(int32_t) BS_Friends_GetMediumFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { return lpSteamFriends->GetMediumFriendAvatar(*steamIDFriend); } #pragma comment(linker, "/EXPORT:BS_Friends_GetMediumFriendAvatar=_BS_Friends_GetMediumFriendAvatar@8") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetLargeFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { +DLL_FUNCTION(int32_t) BS_Friends_GetLargeFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { return lpSteamFriends->GetLargeFriendAvatar(*steamIDFriend); } #pragma comment(linker, "/EXPORT:BS_Friends_GetLargeFriendAvatar=_BS_Friends_GetLargeFriendAvatar@8") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_RequestUserInformation(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bRequireNameOnly) { +DLL_FUNCTION(uint32_t) BS_Friends_RequestUserInformation(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bRequireNameOnly) { return lpSteamFriends->RequestUserInformation(*steamIDUser, bRequireNameOnly != 0); } #pragma comment(linker, "/EXPORT:BS_Friends_RequestUserInformation=_BS_Friends_RequestUserInformation@12") -DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_RequestClanOfficerList(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { - return lpSteamFriends->RequestClanOfficerList(*steamIDClan); +DLL_FUNCTION(SteamAPICall_t*) BS_Friends_RequestClanOfficerList(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { + return new uint64_t(lpSteamFriends->RequestClanOfficerList(*steamIDClan)); } #pragma comment(linker, "/EXPORT:BS_Friends_RequestClanOfficerList=_BS_Friends_RequestClanOfficerList@8") -DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetClanOwner(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { - CSteamID* steamID = new CSteamID(lpSteamFriends->GetClanOwner(*steamIDClan)); - return steamID; +DLL_FUNCTION(CSteamID*) BS_Friends_GetClanOwner(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { + return new CSteamID(lpSteamFriends->GetClanOwner(*steamIDClan)); } #pragma comment(linker, "/EXPORT:BS_Friends_GetClanOwner=_BS_Friends_GetClanOwner@8") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetClanOfficerCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { +DLL_FUNCTION(int32_t) BS_Friends_GetClanOfficerCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { return lpSteamFriends->GetClanOfficerCount(*steamIDClan); } #pragma comment(linker, "/EXPORT:BS_Friends_GetClanOfficerCount=_BS_Friends_GetClanOfficerCount@8") -DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetClanOfficerByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iOfficer) { +DLL_FUNCTION(CSteamID*) BS_Friends_GetClanOfficerByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iOfficer) { CSteamID* steamID = new CSteamID(lpSteamFriends->GetClanOfficerByIndex(*steamIDClan, iOfficer)); return steamID; } #pragma comment(linker, "/EXPORT:BS_Friends_GetClanOfficerByIndex=_BS_Friends_GetClanOfficerByIndex@12") -DLL_EXPORT EUserRestriction DLL_CALL BS_Friends_GetUserRestrictions(ISteamFriends* lpSteamFriends) { +DLL_FUNCTION(EUserRestriction) BS_Friends_GetUserRestrictions(ISteamFriends* lpSteamFriends) { return (EUserRestriction)lpSteamFriends->GetUserRestrictions(); } #pragma comment(linker, "/EXPORT:BS_Friends_GetUserRestrictions=_BS_Friends_GetUserRestrictions@4") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_SetRichPresence(ISteamFriends* lpSteamFriends, const char* pchKey, const char* pchValue) { +DLL_FUNCTION(uint32_t) BS_Friends_SetRichPresence(ISteamFriends* lpSteamFriends, const char* pchKey, const char* pchValue) { return lpSteamFriends->SetRichPresence(pchKey, pchValue); } #pragma comment(linker, "/EXPORT:BS_Friends_SetRichPresence=_BS_Friends_SetRichPresence@12") -DLL_EXPORT void DLL_CALL BS_Friends_ClearRichPresence(ISteamFriends* lpSteamFriends) { +DLL_FUNCTION(void) BS_Friends_ClearRichPresence(ISteamFriends* lpSteamFriends) { lpSteamFriends->ClearRichPresence(); } #pragma comment(linker, "/EXPORT:BS_Friends_ClearRichPresence=_BS_Friends_ClearRichPresence@4") -DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchKey) { +DLL_FUNCTION(const char*) BS_Friends_GetFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchKey) { return lpSteamFriends->GetFriendRichPresence(*steamIDFriend, pchKey); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresence=_BS_Friends_GetFriendRichPresence@12") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendRichPresenceKeyCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { +DLL_FUNCTION(int32_t) BS_Friends_GetFriendRichPresenceKeyCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { return lpSteamFriends->GetFriendRichPresenceKeyCount(*steamIDFriend); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresenceKeyCount=_BS_Friends_GetFriendRichPresenceKeyCount@8") -DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendRichPresenceKeyByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iKey) { +DLL_FUNCTION(const char*) BS_Friends_GetFriendRichPresenceKeyByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iKey) { return lpSteamFriends->GetFriendRichPresenceKeyByIndex(*steamIDFriend, iKey); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresenceKeyByIndex=_BS_Friends_GetFriendRichPresenceKeyByIndex@12") -DLL_EXPORT void DLL_CALL BS_Friends_RequestFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { +DLL_FUNCTION(void) BS_Friends_RequestFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { lpSteamFriends->RequestFriendRichPresence(*steamIDFriend); } #pragma comment(linker, "/EXPORT:BS_Friends_RequestFriendRichPresence=_BS_Friends_RequestFriendRichPresence@8") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_InviteUserToGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char *pchConnectString) { +DLL_FUNCTION(uint32_t) BS_Friends_InviteUserToGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char *pchConnectString) { return lpSteamFriends->InviteUserToGame(*steamIDFriend, pchConnectString); } #pragma comment(linker, "/EXPORT:BS_Friends_InviteUserToGame=_BS_Friends_InviteUserToGame@12") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetCoplayFriendCount(ISteamFriends* lpSteamFriends) { +DLL_FUNCTION(int32_t) BS_Friends_GetCoplayFriendCount(ISteamFriends* lpSteamFriends) { return lpSteamFriends->GetCoplayFriendCount(); } #pragma comment(linker, "/EXPORT:BS_Friends_GetCoplayFriendCount=_BS_Friends_GetCoplayFriendCount@4") -DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetCoplayFriend(ISteamFriends* lpSteamFriends, int32_t iCoplayFriend) { +DLL_FUNCTION(CSteamID*) BS_Friends_GetCoplayFriend(ISteamFriends* lpSteamFriends, int32_t iCoplayFriend) { CSteamID* steamID = new CSteamID(lpSteamFriends->GetCoplayFriend(iCoplayFriend)); return steamID; } #pragma comment(linker, "/EXPORT:BS_Friends_GetCoplayFriend=_BS_Friends_GetCoplayFriend@8") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendCoplayTime(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { +DLL_FUNCTION(int32_t) BS_Friends_GetFriendCoplayTime(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { return lpSteamFriends->GetFriendCoplayTime(*steamIDFriend); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCoplayTime=_BS_Friends_GetFriendCoplayTime@8") -DLL_EXPORT AppId_t DLL_CALL BS_Friends_GetFriendCoplayGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { +DLL_FUNCTION(AppId_t) BS_Friends_GetFriendCoplayGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) { return lpSteamFriends->GetFriendCoplayGame(*steamIDFriend); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCoplayGame=_BS_Friends_GetFriendCoplayGame@8") -DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_JoinClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { - return lpSteamFriends->JoinClanChatRoom(*steamIDClan); +DLL_FUNCTION(SteamAPICall_t*) BS_Friends_JoinClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { + return new uint64_t(lpSteamFriends->JoinClanChatRoom(*steamIDClan)); } #pragma comment(linker, "/EXPORT:BS_Friends_JoinClanChatRoom=_BS_Friends_JoinClanChatRoom@8") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_LeaveClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { +DLL_FUNCTION(uint32_t) BS_Friends_LeaveClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { return lpSteamFriends->LeaveClanChatRoom(*steamIDClan); } #pragma comment(linker, "/EXPORT:BS_Friends_LeaveClanChatRoom=_BS_Friends_LeaveClanChatRoom@8") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetClanChatMemberCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { +DLL_FUNCTION(int32_t) BS_Friends_GetClanChatMemberCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) { return lpSteamFriends->GetClanChatMemberCount(*steamIDClan); } #pragma comment(linker, "/EXPORT:BS_Friends_GetClanChatMemberCount=_BS_Friends_GetClanChatMemberCount@8") -DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetChatMemberByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iUser) { +DLL_FUNCTION(CSteamID*) BS_Friends_GetChatMemberByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iUser) { CSteamID* steamID = new CSteamID(lpSteamFriends->GetChatMemberByIndex(*steamIDClan, iUser)); return steamID; } #pragma comment(linker, "/EXPORT:BS_Friends_GetChatMemberByIndex=_BS_Friends_GetChatMemberByIndex@12") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_SendClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, const char *pchText) { +DLL_FUNCTION(uint32_t) BS_Friends_SendClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, const char *pchText) { return lpSteamFriends->SendClanChatMessage(*steamIDClanChat, pchText); } #pragma comment(linker, "/EXPORT:BS_Friends_SendClanChatMessage=_BS_Friends_SendClanChatMessage@12") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, int32_t iMessage, void* prgchText, int32_t cchTextMax, EChatEntryType* peChatEntryType, CSteamID* psteamidChatter) { +DLL_FUNCTION(int32_t) BS_Friends_GetClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, int32_t iMessage, void* prgchText, int32_t cchTextMax, EChatEntryType* peChatEntryType, CSteamID* psteamidChatter) { return lpSteamFriends->GetClanChatMessage(*steamIDClanChat, iMessage, prgchText, cchTextMax, peChatEntryType, psteamidChatter); } #pragma comment(linker, "/EXPORT:BS_Friends_GetClanChatMessage=_BS_Friends_GetClanChatMessage@28") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_IsClanChatAdmin(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, CSteamID* steamIDUser) { +DLL_FUNCTION(uint32_t) BS_Friends_IsClanChatAdmin(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, CSteamID* steamIDUser) { return lpSteamFriends->IsClanChatAdmin(*steamIDClanChat, *steamIDUser); } #pragma comment(linker, "/EXPORT:BS_Friends_IsClanChatAdmin=_BS_Friends_IsClanChatAdmin@12") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_IsClanChatWindowOpenInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) { +DLL_FUNCTION(uint32_t) BS_Friends_IsClanChatWindowOpenInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) { return lpSteamFriends->IsClanChatWindowOpenInSteam(*steamIDClanChat); } #pragma comment(linker, "/EXPORT:BS_Friends_IsClanChatWindowOpenInSteam=_BS_Friends_IsClanChatWindowOpenInSteam@8") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_OpenClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) { +DLL_FUNCTION(uint32_t) BS_Friends_OpenClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) { return lpSteamFriends->OpenClanChatWindowInSteam(*steamIDClanChat); } #pragma comment(linker, "/EXPORT:BS_Friends_OpenClanChatWindowInSteam=_BS_Friends_OpenClanChatWindowInSteam@8") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_CloseClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) { +DLL_FUNCTION(uint32_t) BS_Friends_CloseClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) { return lpSteamFriends->CloseClanChatWindowInSteam(*steamIDClanChat); } #pragma comment(linker, "/EXPORT:BS_Friends_CloseClanChatWindowInSteam=_BS_Friends_CloseClanChatWindowInSteam@8") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_SetListenForFriendsMessages(ISteamFriends* lpSteamFriends, uint32_t bInterceptEnabled) { +DLL_FUNCTION(uint32_t) BS_Friends_SetListenForFriendsMessages(ISteamFriends* lpSteamFriends, uint32_t bInterceptEnabled) { return lpSteamFriends->SetListenForFriendsMessages(bInterceptEnabled != 0); } #pragma comment(linker, "/EXPORT:BS_Friends_SetListenForFriendsMessages=_BS_Friends_SetListenForFriendsMessages@8") -DLL_EXPORT uint32_t DLL_CALL BS_Friends_ReplyToFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchMsgToSend) { +DLL_FUNCTION(uint32_t) BS_Friends_ReplyToFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchMsgToSend) { return lpSteamFriends->ReplyToFriendMessage(*steamIDFriend, pchMsgToSend); } #pragma comment(linker, "/EXPORT:BS_Friends_ReplyToFriendMessage=_BS_Friends_ReplyToFriendMessage@12") -DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iMessageID, void* pvData, int32_t cubData, EChatEntryType* peChatEntryType) { +DLL_FUNCTION(int32_t) BS_Friends_GetFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iMessageID, void* pvData, int32_t cubData, EChatEntryType* peChatEntryType) { return lpSteamFriends->GetFriendMessage(*steamIDFriend, iMessageID, pvData, cubData, peChatEntryType); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendMessage=_BS_Friends_GetFriendMessage@24") -DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_GetFollowerCount(ISteamFriends* lpSteamFriends, CSteamID* steamID) { - return lpSteamFriends->GetFollowerCount(*steamID); +DLL_FUNCTION(SteamAPICall_t*) BS_Friends_GetFollowerCount(ISteamFriends* lpSteamFriends, CSteamID* steamID) { + return new uint64_t(lpSteamFriends->GetFollowerCount(*steamID)); } #pragma comment(linker, "/EXPORT:BS_Friends_GetFollowerCount=_BS_Friends_GetFollowerCount@8") -DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_IsFollowing(ISteamFriends* lpSteamFriends, CSteamID* steamID) { - return lpSteamFriends->IsFollowing(*steamID); +DLL_FUNCTION(SteamAPICall_t*) BS_Friends_IsFollowing(ISteamFriends* lpSteamFriends, CSteamID* steamID) { + return new uint64_t(lpSteamFriends->IsFollowing(*steamID)); } #pragma comment(linker, "/EXPORT:BS_Friends_IsFollowing=_BS_Friends_IsFollowing@8") -DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_EnumerateFollowingList(ISteamFriends* lpSteamFriends, uint32 unStartIndex) { - return lpSteamFriends->EnumerateFollowingList(unStartIndex); +DLL_FUNCTION(SteamAPICall_t*) BS_Friends_EnumerateFollowingList(ISteamFriends* lpSteamFriends, uint32_t unStartIndex) { + return new uint64_t(lpSteamFriends->EnumerateFollowingList(unStartIndex)); } #pragma comment(linker, "/EXPORT:BS_Friends_EnumerateFollowingList=_BS_Friends_EnumerateFollowingList@8") diff --git a/Wrapper/SteamGameServer.cpp b/Wrapper/SteamGameServer.cpp index 41f7082..a03f49e 100644 --- a/Wrapper/SteamGameServer.cpp +++ b/Wrapper/SteamGameServer.cpp @@ -14,55 +14,260 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" -#include "SteamworksSDK/public/steam/steam_gameserver.h" +#include "BlitzSteam.h" -DLL_EXPORT uint32_t DLL_CALL BS_GameServer_Init(uint32_t unIP, uint16_t usSteamPort, uint16_t usGamePort, uint16_t usQueryPort, EServerMode eServerMode, const char *pchVersionString) { - return SteamGameServer_Init(unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString); -} - -DLL_EXPORT void DLL_CALL BS_GameServer_Shutdown() { - SteamGameServer_Shutdown(); -} - -DLL_EXPORT void DLL_CALL BS_GameServer_RunCallbacks() { - SteamGameServer_RunCallbacks(); -} - -DLL_EXPORT uint32_t DLL_CALL BS_GameServer_Secure() { - return SteamGameServer_BSecure(); -} - -DLL_EXPORT uint64_t* DLL_CALL BS_GameServer_GetSteamID() { - uint64_t* val = new uint64_t(SteamGameServer_GetSteamID()); - return val; -} - -DLL_EXPORT HSteamPipe DLL_CALL BS_GameServer_GetHSteamPipe() { - return SteamGameServer_GetHSteamPipe(); -} - -// Interfaces -DLL_EXPORT ISteamGameServer* DLL_CALL BS_GameServer() { +DLL_FUNCTION(ISteamGameServer*) BS_GameServer() { +#pragma comment(linker, "/EXPORT:BS_GameServer=_BS_GameServer@0") return SteamGameServer(); } -DLL_EXPORT ISteamUtils* DLL_CALL BS_GameServerUtils() { - return SteamGameServerUtils(); +DLL_FUNCTION(uint32_t) BS_GameServer_Init(uint32_t unIP, uint16_t usSteamPort, uint16_t usGamePort, uint16_t usQueryPort, EServerMode eServerMode, const char *pchVersionString) { +#pragma comment(linker, "/EXPORT:BS_GameServer_Init=_BS_GameServer_Init@24") + return SteamGameServer_Init(unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString); } -DLL_EXPORT ISteamNetworking* DLL_CALL BS_GameServerNetworking() { - return SteamGameServerNetworking(); +DLL_FUNCTION(void) BS_GameServer_Shutdown() { +#pragma comment(linker, "/EXPORT:BS_GameServer_Shutdown=_BS_GameServer_Shutdown@0") + SteamGameServer_Shutdown(); } -DLL_EXPORT ISteamGameServerStats* DLL_CALL BS_GameServerStats() { - return SteamGameServerStats(); +DLL_FUNCTION(void) BS_GameServer_RunCallbacks() { +#pragma comment(linker, "/EXPORT:BS_GameServer_RunCallbacks=_BS_GameServer_RunCallbacks@0") + SteamGameServer_RunCallbacks(); } -DLL_EXPORT ISteamHTTP* DLL_CALL BS_GameServerHTTP() { - return SteamGameServerHTTP(); +DLL_FUNCTION(HSteamPipe) BS_GameServer_GetHSteamPipe() { +#pragma comment(linker, "/EXPORT:BS_GameServer_GetHSteamPipe=_BS_GameServer_GetHSteamPipe@0") + return SteamGameServer_GetHSteamPipe(); } -DLL_EXPORT ISteamInventory* DLL_CALL BS_GameServerInventory() { - return SteamGameServerInventory(); +DLL_FUNCTION(uint32_t) BS_GameServer_IsSecureC() { +#pragma comment(linker, "/EXPORT:BS_GameServer_IsSecureC=_BS_GameServer_IsSecureC@0") + return SteamGameServer_BSecure(); +} + +DLL_FUNCTION(CSteamID*) BS_GameServer_GetSteamIDC() { +#pragma comment(linker, "/EXPORT:BS_GameServer_GetSteamIDC=_BS_GameServer_GetSteamIDC@0") + return new CSteamID(SteamGameServer_GetSteamID()); +} + +// ISteamGameServer Stuff +DLL_FUNCTION(uint32_t) BS_GameServer_InitGameServer(ISteamGameServer* pSteamGameServer, uint32_t unIP, uint16_t usGamePort, uint16_t usQueryPort, uint32_t unFlags, AppId_t nGameAppId, const char *pchVersionString) { +#pragma comment(linker, "/EXPORT:BS_GameServer_InitGameServer=_BS_GameServer_InitGameServer@28") + return pSteamGameServer->InitGameServer(unIP, usGamePort, usQueryPort, unFlags, nGameAppId, pchVersionString); +} + +DLL_FUNCTION(void) BS_GameServer_SetProduct(ISteamGameServer* pSteamGameServer, const char *pszProduct) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetProduct=_BS_GameServer_SetProduct@8") + pSteamGameServer->SetProduct(pszProduct); +} + +DLL_FUNCTION(void) BS_GameServer_SetGameDescription(ISteamGameServer* pSteamGameServer, const char *pszGameDescription) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetGameDescription=_BS_GameServer_SetGameDescription@8") + pSteamGameServer->SetGameDescription(pszGameDescription); +} + +DLL_FUNCTION(void) BS_GameServer_SetModDir(ISteamGameServer* pSteamGameServer, const char *pszModDir) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetModDir=_BS_GameServer_SetModDir@8") + pSteamGameServer->SetModDir(pszModDir); +} + +DLL_FUNCTION(void) BS_GameServer_SetDedicatedServer(ISteamGameServer* pSteamGameServer, uint32_t bDedicated) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetDedicatedServer=_BS_GameServer_SetDedicatedServer@8") + pSteamGameServer->SetDedicatedServer(!!bDedicated); +} + +DLL_FUNCTION(void) BS_GameServer_LogOn(ISteamGameServer* pSteamGameServer, const char *pszToken) { +#pragma comment(linker, "/EXPORT:BS_GameServer_LogOn=_BS_GameServer_LogOn@8") + pSteamGameServer->LogOn(pszToken); +} + +DLL_FUNCTION(void) BS_GameServer_LogOnAnonymous(ISteamGameServer* pSteamGameServer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_LogOnAnonymous=_BS_GameServer_LogOnAnonymous@4") + pSteamGameServer->LogOnAnonymous(); +} + +DLL_FUNCTION(void) BS_GameServer_LogOff(ISteamGameServer* pSteamGameServer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_LogOff=_BS_GameServer_LogOff@4") + pSteamGameServer->LogOff(); +} + +DLL_FUNCTION(uint32_t) BS_GameServer_IsLoggedOn(ISteamGameServer* pSteamGameServer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_IsLoggedOn=_BS_GameServer_IsLoggedOn@4") + return pSteamGameServer->BLoggedOn(); +} + +DLL_FUNCTION(uint32_t) BS_GameServer_IsSecure(ISteamGameServer* pSteamGameServer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_IsSecure=_BS_GameServer_IsSecure@4") + return pSteamGameServer->BSecure(); +} + +DLL_FUNCTION(CSteamID*) BS_GameServer_GetSteamID(ISteamGameServer* pSteamGameServer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_GetSteamID=_BS_GameServer_GetSteamID@4") + return new CSteamID(pSteamGameServer->GetSteamID()); +} + +DLL_FUNCTION(uint32_t) BS_GameServer_WasRestartRequested(ISteamGameServer* pSteamGameServer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_WasRestartRequested=_BS_GameServer_WasRestartRequested@4") + return pSteamGameServer->WasRestartRequested(); +} + +DLL_FUNCTION(void) BS_GameServer_SetMaxPlayerCount(ISteamGameServer* pSteamGameServer, int32_t cPlayersMax) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetMaxPlayerCount=_BS_GameServer_SetMaxPlayerCount@8") + pSteamGameServer->SetMaxPlayerCount(cPlayersMax); +} + +DLL_FUNCTION(void) BS_GameServer_SetBotPlayerCount(ISteamGameServer* pSteamGameServer, int32_t cBotplayers) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetBotPlayerCount=_BS_GameServer_SetBotPlayerCount@8") + pSteamGameServer->SetBotPlayerCount(cBotplayers); +} + +DLL_FUNCTION(void) BS_GameServer_SetServerName(ISteamGameServer* pSteamGameServer, const char *pszServerName) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetServerName=_BS_GameServer_SetServerName@8") + pSteamGameServer->SetServerName(pszServerName); +} + +DLL_FUNCTION(void) BS_GameServer_SetMapName(ISteamGameServer* pSteamGameServer, const char *pszMapName) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetMapName=_BS_GameServer_SetMapName@8") + pSteamGameServer->SetMapName(pszMapName); +} + +DLL_FUNCTION(void) BS_GameServer_SetPasswordProtected(ISteamGameServer* pSteamGameServer, uint32_t bPasswordProtected) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetPasswordProtected=_BS_GameServer_SetPasswordProtected@8") + pSteamGameServer->SetPasswordProtected(!!bPasswordProtected); +} + +DLL_FUNCTION(void) BS_GameServer_SetSpectatorPort(ISteamGameServer* pSteamGameServer, uint16_t unSpectatorPort) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetSpectatorPort=_BS_GameServer_SetSpectatorPort@8") + pSteamGameServer->SetSpectatorPort(unSpectatorPort); +} + +DLL_FUNCTION(void) BS_GameServer_SetSpectatorServerName(ISteamGameServer* pSteamGameServer, const char *pszSpectatorServerName) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetSpectatorServerName=_BS_GameServer_SetSpectatorServerName@8") + pSteamGameServer->SetSpectatorServerName(pszSpectatorServerName); +} + +DLL_FUNCTION(void) BS_GameServer_ClearAllKeyValues(ISteamGameServer* pSteamGameServer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_ClearAllKeyValues=_BS_GameServer_ClearAllKeyValues@4") + pSteamGameServer->ClearAllKeyValues(); +} + +DLL_FUNCTION(void) BS_GameServer_SetKeyValue(ISteamGameServer* pSteamGameServer, const char *pKey, const char *pValue) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetKeyValue=_BS_GameServer_SetKeyValue@12") + pSteamGameServer->SetKeyValue(pKey, pValue); +} + +DLL_FUNCTION(void) BS_GameServer_SetGameTags(ISteamGameServer* pSteamGameServer, const char *pchGameTags) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetGameTags=_BS_GameServer_SetGameTags@8") + pSteamGameServer->SetGameTags(pchGameTags); +} + +DLL_FUNCTION(void) BS_GameServer_SetGameData(ISteamGameServer* pSteamGameServer, const char *pchGameData) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetGameData=_BS_GameServer_SetGameData@8") + pSteamGameServer->SetGameData(pchGameData); +} + +DLL_FUNCTION(void) BS_GameServer_SetRegion(ISteamGameServer* pSteamGameServer, const char *pszRegion) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetRegion=_BS_GameServer_SetRegion@8") + pSteamGameServer->SetRegion(pszRegion); +} + +DLL_FUNCTION(uint32_t) BS_GameServer_SendUserConnectAndAuthenticate(ISteamGameServer* pSteamGameServer, uint32_t unIPClient, const void *pvAuthBlob, uint32_t cubAuthBlobSize, CSteamID *pSteamIDUser) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SendUserConnectAndAuthenticate=_BS_GameServer_SendUserConnectAndAuthenticate@20") + return pSteamGameServer->SendUserConnectAndAuthenticate(unIPClient, pvAuthBlob, cubAuthBlobSize, pSteamIDUser); +} + +DLL_FUNCTION(CSteamID*) BS_GameServer_CreateUnauthenticatedUserConnection(ISteamGameServer* pSteamGameServer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_CreateUnauthenticatedUserConnection=_BS_GameServer_CreateUnauthenticatedUserConnection@4") + return new CSteamID(pSteamGameServer->CreateUnauthenticatedUserConnection()); +} + +DLL_FUNCTION(void) BS_GameServer_SendUserDisconnect(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SendUserDisconnect=_BS_GameServer_SendUserDisconnect@8") + pSteamGameServer->SendUserDisconnect(*pSteamIDUser); +} + +DLL_FUNCTION(uint32_t) BS_GameServer_UpdateUserData(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser, const char *pchPlayerName, uint32_t uScore) { +#pragma comment(linker, "/EXPORT:BS_GameServer_UpdateUserData=_BS_GameServer_UpdateUserData@16") + return pSteamGameServer->BUpdateUserData(*pSteamIDUser, pchPlayerName, uScore); +} + +DLL_FUNCTION(HAuthTicket) BS_GameServer_GetAuthSessionTicket(ISteamGameServer* pSteamGameServer, void *pTicket, int32_t cbMaxTicket, uint32_t *pcbTicket) { +#pragma comment(linker, "/EXPORT:BS_GameServer_GetAuthSessionTicket=_BS_GameServer_GetAuthSessionTicket@16") + return pSteamGameServer->GetAuthSessionTicket(pTicket, cbMaxTicket, pcbTicket); +} + +DLL_FUNCTION(EBeginAuthSessionResult) BS_GameServer_BeginAuthSession(ISteamGameServer* pSteamGameServer, const void *pAuthTicket, int32_t cbAuthTicket, CSteamID* pSteamID) { +#pragma comment(linker, "/EXPORT:BS_GameServer_BeginAuthSession=_BS_GameServer_BeginAuthSession@16") + return pSteamGameServer->BeginAuthSession(pAuthTicket, cbAuthTicket, *pSteamID); +} + +DLL_FUNCTION(void) BS_GameServer_EndAuthSession(ISteamGameServer* pSteamGameServer, CSteamID* pSteamID) { +#pragma comment(linker, "/EXPORT:BS_GameServer_EndAuthSession=_BS_GameServer_EndAuthSession@8") + pSteamGameServer->EndAuthSession(*pSteamID); +} + +DLL_FUNCTION(void) BS_GameServer_CancelAuthTicket(ISteamGameServer* pSteamGameServer, HAuthTicket hAuthTicket) { +#pragma comment(linker, "/EXPORT:BS_GameServer_CancelAuthTicket=_BS_GameServer_CancelAuthTicket@8") + pSteamGameServer->CancelAuthTicket(hAuthTicket); +} + +DLL_FUNCTION(EUserHasLicenseForAppResult) BS_GameServer_UserHasLicenseForApp(ISteamGameServer* pSteamGameServer, CSteamID* pSteamID, AppId_t appID) { +#pragma comment(linker, "/EXPORT:BS_GameServer_UserHasLicenseForApp=_BS_GameServer_UserHasLicenseForApp@12") + return pSteamGameServer->UserHasLicenseForApp(*pSteamID, appID); +} + +DLL_FUNCTION(uint32_t) BS_GameServer_RequestUserGroupStatus(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser, CSteamID* pSteamIDGroup) { +#pragma comment(linker, "/EXPORT:BS_GameServer_RequestUserGroupStatus=_BS_GameServer_RequestUserGroupStatus@12") + return pSteamGameServer->RequestUserGroupStatus(*pSteamIDUser, *pSteamIDGroup); +} + +DLL_FUNCTION(void) BS_GameServer_GetGameplayStats(ISteamGameServer* pSteamGameServer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_GetGameplayStats=_BS_GameServer_GetGameplayStats@4") + pSteamGameServer->GetGameplayStats(); +} + +DLL_FUNCTION(SteamAPICall_t*) BS_GameServer_GetServerReputation(ISteamGameServer* pSteamGameServer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_GetServerReputation=_BS_GameServer_GetServerReputation@4") + return new uint64_t(pSteamGameServer->GetServerReputation()); +} + +DLL_FUNCTION(uint32_t) BS_GameServer_GetPublicIP(ISteamGameServer* pSteamGameServer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_GetPublicIP=_BS_GameServer_GetPublicIP@4") + return pSteamGameServer->GetPublicIP(); +} + +DLL_FUNCTION(uint32_t) BS_GameServer_HandleIncomingPacket(ISteamGameServer* pSteamGameServer, const void *pData, int32_t cbData, uint32_t srcIP, uint16_t srcPort) { +#pragma comment(linker, "/EXPORT:BS_GameServer_HandleIncomingPacket=_BS_GameServer_HandleIncomingPacket@20") + return pSteamGameServer->HandleIncomingPacket(pData, cbData, srcIP, srcPort); +} + +DLL_FUNCTION(uint32_t) BS_GameServer_GetNextOutgoingPacket(ISteamGameServer* pSteamGameServer, void *pOut, int32_t cbMaxOut, uint32_t *pNetAdr, uint16_t *pPort) { +#pragma comment(linker, "/EXPORT:BS_GameServer_GetNextOutgoingPacket=_BS_GameServer_GetNextOutgoingPacket@20") + return pSteamGameServer->GetNextOutgoingPacket(pOut, cbMaxOut, pNetAdr, pPort); +} + +DLL_FUNCTION(void) BS_GameServer_EnableHeartbeats(ISteamGameServer* pSteamGameServer, uint32_t bActive) { +#pragma comment(linker, "/EXPORT:BS_GameServer_EnableHeartbeats=_BS_GameServer_EnableHeartbeats@8") + pSteamGameServer->EnableHeartbeats(!!bActive); +} + +DLL_FUNCTION(void) BS_GameServer_SetHeartbeatInterval(ISteamGameServer* pSteamGameServer, int32_t iHeartbeatInterval) { +#pragma comment(linker, "/EXPORT:BS_GameServer_SetHeartbeatInterval=_BS_GameServer_SetHeartbeatInterval@8") + pSteamGameServer->SetHeartbeatInterval(iHeartbeatInterval); +} + +DLL_FUNCTION(void) BS_GameServer_ForceHeartbeat(ISteamGameServer* pSteamGameServer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_ForceHeartbeat=_BS_GameServer_ForceHeartbeat@4") + pSteamGameServer->ForceHeartbeat(); +} + +DLL_FUNCTION(SteamAPICall_t*) BS_GameServer_AssociateWithClan(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDClan) { +#pragma comment(linker, "/EXPORT:BS_GameServer_AssociateWithClan=_BS_GameServer_AssociateWithClan@8") + return new uint64_t(pSteamGameServer->AssociateWithClan(*pSteamIDClan)); +} + +DLL_FUNCTION(SteamAPICall_t*) BS_GameServer_ComputeNewPlayerCompatibility(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDNewPlayer) { +#pragma comment(linker, "/EXPORT:BS_GameServer_ComputeNewPlayerCompatibility=_BS_GameServer_ComputeNewPlayerCompatibility@8") + return new uint64_t(pSteamGameServer->ComputeNewPlayerCompatibility(*pSteamIDNewPlayer)); } \ No newline at end of file diff --git a/Wrapper/SteamGameServerStats.cpp b/Wrapper/SteamGameServerStats.cpp index e69de29..bfa0799 100644 --- a/Wrapper/SteamGameServerStats.cpp +++ b/Wrapper/SteamGameServerStats.cpp @@ -0,0 +1,63 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamGameServerStats*) BS_GameServerStats() { +#pragma comment(linker, "/EXPORT:BS_GameServerStats=_BS_GameServerStats@0") + return SteamGameServerStats(); +} + +DLL_FUNCTION(SteamAPICall_t*) BS_GameServerStats_RequestUserStats(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser) { + return new uint64_t(pSteamGameServerStats->RequestUserStats(*steamIDUser)); +} + +DLL_FUNCTION(SteamAPICall_t*) BS_GameServerStats_StoreUserStats(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser) { + return new uint64_t(pSteamGameServerStats->StoreUserStats(*steamIDUser)); +} + +DLL_FUNCTION(uint32_t) BS_GameServerStats_GetUserStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pData) { + return pSteamGameServerStats->GetUserStat(*steamIDUser, pchName, (int32_t*)pData); +} + +DLL_FUNCTION(uint32_t) BS_GameServerStats_GetUserStatF(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, float_t* pData) { + return pSteamGameServerStats->GetUserStat(*steamIDUser, pchName, pData); +} + +DLL_FUNCTION(uint32_t) BS_GameServerStats_GetUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pbAchieved) { + return pSteamGameServerStats->GetUserAchievement(*steamIDUser, pchName, (bool*)pbAchieved); +} + +DLL_FUNCTION(uint32_t) BS_GameServerStats_SetUserStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t nData) { + return pSteamGameServerStats->SetUserStat(*steamIDUser, pchName, (int32_t)nData); +} + +DLL_FUNCTION(uint32_t) BS_GameServerStats_SetUserStatF(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, float_t fData) { + return pSteamGameServerStats->SetUserStat(*steamIDUser, pchName, fData); +} + +DLL_FUNCTION(uint32_t) BS_GameServerStats_UpdateUserAvgRateStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char *pchName, float flCountThisSession, double* pdSessionLength) { + return pSteamGameServerStats->UpdateUserAvgRateStat(*steamIDUser, pchName, flCountThisSession, *pdSessionLength); +} + +DLL_FUNCTION(uint32_t) BS_GameServerStats_SetUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName) { + return pSteamGameServerStats->SetUserAchievement(*steamIDUser, pchName); +} + +DLL_FUNCTION(uint32_t) BS_GameServerStats_ClearUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName) { + return pSteamGameServerStats->ClearUserAchievement(*steamIDUser, pchName); +} + diff --git a/Wrapper/SteamHTMLSurface.cpp b/Wrapper/SteamHTMLSurface.cpp index e69de29..756e8ef 100644 --- a/Wrapper/SteamHTMLSurface.cpp +++ b/Wrapper/SteamHTMLSurface.cpp @@ -0,0 +1,23 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamHTMLSurface*) BS_HTMLSurface() { + return SteamHTMLSurface(); +} +#pragma comment(linker, "/EXPORT:BS_HTMLSurface=_BS_HTMLSurface@0") + diff --git a/Wrapper/SteamHTTP.cpp b/Wrapper/SteamHTTP.cpp index e69de29..f6bea38 100644 --- a/Wrapper/SteamHTTP.cpp +++ b/Wrapper/SteamHTTP.cpp @@ -0,0 +1,28 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamHTTP*) BS_HTTP() { + return SteamHTTP(); +} +#pragma comment(linker, "/EXPORT:BS_HTTP=_BS_HTTP@0") + +DLL_FUNCTION(ISteamHTTP*) BS_GameServerHTTP() { +#pragma comment(linker, "/EXPORT:BS_GameServerHTTP=_BS_GameServerHTTP@0") + return SteamGameServerHTTP(); +} + diff --git a/Wrapper/SteamInventory.cpp b/Wrapper/SteamInventory.cpp index e69de29..0a46c99 100644 --- a/Wrapper/SteamInventory.cpp +++ b/Wrapper/SteamInventory.cpp @@ -0,0 +1,28 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamInventory*) BS_Inventory() { + return SteamInventory(); +} +#pragma comment(linker, "/EXPORT:BS_Inventory=_BS_Inventory@0") + +DLL_FUNCTION(ISteamInventory*) BS_GameServerInventory() { +#pragma comment(linker, "/EXPORT:BS_GameServerInventory=_BS_GameServerInventory@0") + return SteamGameServerInventory(); +} + diff --git a/Wrapper/SteamMatchmaking.cpp b/Wrapper/SteamMatchmaking.cpp index e69de29..1109dc5 100644 --- a/Wrapper/SteamMatchmaking.cpp +++ b/Wrapper/SteamMatchmaking.cpp @@ -0,0 +1,23 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamMatchmaking*) BS_Matchmaking() { + return SteamMatchmaking(); +} +#pragma comment(linker, "/EXPORT:BS_Matchmaking=_BS_Matchmaking@0") + diff --git a/Wrapper/SteamMatchmakingServer.cpp b/Wrapper/SteamMatchmakingServer.cpp index e69de29..a926027 100644 --- a/Wrapper/SteamMatchmakingServer.cpp +++ b/Wrapper/SteamMatchmakingServer.cpp @@ -0,0 +1,23 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamMatchmakingServers*) BS_MatchmakingServers() { + return SteamMatchmakingServers(); +} +#pragma comment(linker, "/EXPORT:BS_MatchmakingServers=_BS_MatchmakingServers@0") + diff --git a/Wrapper/SteamMusic.cpp b/Wrapper/SteamMusic.cpp index e69de29..70e65f7 100644 --- a/Wrapper/SteamMusic.cpp +++ b/Wrapper/SteamMusic.cpp @@ -0,0 +1,23 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamMusic*) BS_Music() { + return SteamMusic(); +} +#pragma comment(linker, "/EXPORT:BS_Music=_BS_Music@0") + diff --git a/Wrapper/SteamMusicRemote.cpp b/Wrapper/SteamMusicRemote.cpp index e69de29..b67875b 100644 --- a/Wrapper/SteamMusicRemote.cpp +++ b/Wrapper/SteamMusicRemote.cpp @@ -0,0 +1,23 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamMusicRemote*) BS_MusicRemote() { + return SteamMusicRemote(); +} +#pragma comment(linker, "/EXPORT:BS_MusicRemote=_BS_MusicRemote@0") + diff --git a/Wrapper/SteamNetworking.cpp b/Wrapper/SteamNetworking.cpp index e69de29..80f559f 100644 --- a/Wrapper/SteamNetworking.cpp +++ b/Wrapper/SteamNetworking.cpp @@ -0,0 +1,67 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamNetworking*) BS_Networking() { + return SteamNetworking(); +} +#pragma comment(linker, "/EXPORT:BS_Networking=_BS_Networking@0") + +DLL_FUNCTION(ISteamNetworking*) BS_GameServerNetworking() { +#pragma comment(linker, "/EXPORT:BS_GameServerNetworking=_BS_GameServerNetworking@0") + return SteamGameServerNetworking(); +} + +DLL_FUNCTION(uint32_t) BS_Networking_SendP2PPacket(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote, const void* pubData, uint32_t cubData, EP2PSend eP2PSendType, uint32_t nChannel) { +#pragma comment(linker, "/EXPORT:BS_Networking_SendP2PPacket=_BS_Networking_SendP2PPacket@24") + return pSteamNetworking->SendP2PPacket(*pSteamIDRemote, pubData, cubData, eP2PSendType, nChannel); +} + +DLL_FUNCTION(uint32_t) BS_Networking_IsP2PPacketAvailable(ISteamNetworking* pSteamNetworking, uint32_t* pcubMsgSize, uint32_t nChannel) { +#pragma comment(linker, "/EXPORT:BS_Networking_IsP2PPacketAvailable=_BS_Networking_IsP2PPacketAvailable@12") + return pSteamNetworking->IsP2PPacketAvailable(pcubMsgSize, nChannel); +} + +DLL_FUNCTION(uint32_t) BS_Networking_ReadP2PPacket(ISteamNetworking* pSteamNetworking, void* pubDest, uint32_t cubDest, uint32_t* pcubMsgSize, CSteamID* pSteamIDRemote, uint32_t nChannel) { +#pragma comment(linker, "/EXPORT:BS_Networking_ReadP2PPacket=_BS_Networking_ReadP2PPacket@24") + return pSteamNetworking->ReadP2PPacket(pubDest, cubDest, pcubMsgSize, pSteamIDRemote, nChannel); +} + +DLL_FUNCTION(uint32_t) BS_Networking_AcceptP2PSessionWithUser(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote) { +#pragma comment(linker, "/EXPORT:BS_Networking_AcceptP2PSessionWithUser=_BS_Networking_AcceptP2PSessionWithUser@8") + return pSteamNetworking->AcceptP2PSessionWithUser(*pSteamIDRemote); +} + +DLL_FUNCTION(uint32_t) BS_Networking_CloseP2PSessionWithUser(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote) { +#pragma comment(linker, "/EXPORT:BS_Networking_CloseP2PSessionWithUser=_BS_Networking_CloseP2PSessionWithUser@8") + return pSteamNetworking->CloseP2PSessionWithUser(*pSteamIDRemote); +} + +DLL_FUNCTION(uint32_t) BS_Networking_CloseP2PChannelWithUser(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote, uint32_t nChannel) { +#pragma comment(linker, "/EXPORT:BS_Networking_CloseP2PChannelWithUser=_BS_Networking_CloseP2PChannelWithUser@12") + return pSteamNetworking->CloseP2PChannelWithUser(*pSteamIDRemote, nChannel); +} + +DLL_FUNCTION(uint32_t) BS_Networking_GetP2PSessionState(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote, P2PSessionState_t* pConnectionState) { +#pragma comment(linker, "/EXPORT:BS_Networking_GetP2PSessionState=_BS_Networking_GetP2PSessionState@12") + return pSteamNetworking->GetP2PSessionState(*pSteamIDRemote, pConnectionState); +} + +DLL_FUNCTION(uint32_t) BS_Networking_AllowP2PPacketRelay(ISteamNetworking* pSteamNetworking, uint32_t bAllow) { +#pragma comment(linker, "/EXPORT:BS_Networking_AllowP2PPacketRelay=_BS_Networking_AllowP2PPacketRelay@8") + return pSteamNetworking->AllowP2PPacketRelay(!!bAllow); +} diff --git a/Wrapper/SteamRemoteStorage.cpp b/Wrapper/SteamRemoteStorage.cpp index e69de29..4e8453e 100644 --- a/Wrapper/SteamRemoteStorage.cpp +++ b/Wrapper/SteamRemoteStorage.cpp @@ -0,0 +1,23 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamRemoteStorage*) BS_RemoteStorage() { + return SteamRemoteStorage(); +} +#pragma comment(linker, "/EXPORT:BS_RemoteStorage=_BS_RemoteStorage@0") + diff --git a/Wrapper/SteamScreenshots.cpp b/Wrapper/SteamScreenshots.cpp index e69de29..c3e4887 100644 --- a/Wrapper/SteamScreenshots.cpp +++ b/Wrapper/SteamScreenshots.cpp @@ -0,0 +1,23 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamScreenshots*) BS_Screenshots() { + return SteamScreenshots(); +} +#pragma comment(linker, "/EXPORT:BS_Screenshots=_BS_Screenshots@0") + diff --git a/Wrapper/SteamUGC.cpp b/Wrapper/SteamUGC.cpp index e69de29..56adbe7 100644 --- a/Wrapper/SteamUGC.cpp +++ b/Wrapper/SteamUGC.cpp @@ -0,0 +1,28 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamUGC*) BS_UGC() { + return SteamUGC(); +} +#pragma comment(linker, "/EXPORT:BS_UGC=_BS_UGC@0") + +DLL_FUNCTION(ISteamUGC*) BS_GameServerUGC() { +#pragma comment(linker, "/EXPORT:BS_GameServerUGC=_BS_GameServerUGC@0") + return SteamGameServerUGC(); +} + diff --git a/Wrapper/SteamUnifiedMessages.cpp b/Wrapper/SteamUnifiedMessages.cpp index e69de29..e256e0e 100644 --- a/Wrapper/SteamUnifiedMessages.cpp +++ b/Wrapper/SteamUnifiedMessages.cpp @@ -0,0 +1,23 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamUnifiedMessages*) BS_UnifiedMessages() { + return SteamUnifiedMessages(); +} +#pragma comment(linker, "/EXPORT:BS_UnifiedMessages=_BS_UnifiedMessages@0") + diff --git a/Wrapper/SteamUser.cpp b/Wrapper/SteamUser.cpp index b5468a8..6bcf0a4 100644 --- a/Wrapper/SteamUser.cpp +++ b/Wrapper/SteamUser.cpp @@ -14,129 +14,134 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" +#include "BlitzSteam.h" -DLL_EXPORT HSteamUser DLL_CALL BS_User_GetHSteamUser( ISteamUser* lpSteamUser ) { +DLL_FUNCTION(ISteamUser*) BS_User() { + return SteamUser(); +} +#pragma comment(linker, "/EXPORT:BS_User=_BS_User@0") + +DLL_FUNCTION(HSteamUser) BS_User_GetHSteamUser( ISteamUser* lpSteamUser ) { return lpSteamUser->GetHSteamUser( ); } #pragma comment(linker, "/EXPORT:BS_User_GetHSteamUser=_BS_User_GetHSteamUser@4") -DLL_EXPORT uint32_t DLL_CALL BS_User_IsLoggedOn( ISteamUser* lpSteamUser ) { +DLL_FUNCTION(uint32_t) BS_User_IsLoggedOn( ISteamUser* lpSteamUser ) { return lpSteamUser->BLoggedOn( ); } #pragma comment(linker, "/EXPORT:BS_User_IsLoggedOn=_BS_User_IsLoggedOn@4") -DLL_EXPORT CSteamID* DLL_CALL BS_User_GetSteamID( ISteamUser* lpSteamUser ) { +DLL_FUNCTION(CSteamID*) BS_User_GetSteamID( ISteamUser* lpSteamUser ) { return &(lpSteamUser->GetSteamID( )); } #pragma comment(linker, "/EXPORT:BS_User_GetSteamID=_BS_User_GetSteamID@4") -DLL_EXPORT uint32_t DLL_CALL BS_User_InitiateGameConnection( ISteamUser* lpSteamUser, void* pAuthBlob, uint32_t cbMaxAuthBlob, CSteamID* SteamIDGameServer, uint32_t unIPServer, uint16_t usPortServer, uint32_t bSecure ) { +DLL_FUNCTION(uint32_t) BS_User_InitiateGameConnection( ISteamUser* lpSteamUser, void* pAuthBlob, uint32_t cbMaxAuthBlob, CSteamID* SteamIDGameServer, uint32_t unIPServer, uint16_t usPortServer, uint32_t bSecure ) { return lpSteamUser->InitiateGameConnection( pAuthBlob, cbMaxAuthBlob, *SteamIDGameServer, unIPServer, usPortServer, bSecure != 0 ); } #pragma comment(linker, "/EXPORT:BS_User_InitiateGameConnection=_BS_User_InitiateGameConnection@28") -DLL_EXPORT void DLL_CALL BS_User_TerminateGameConnection( ISteamUser* lpSteamUser, uint32_t unIPServer, uint16_t usPortServer ) { +DLL_FUNCTION(void) BS_User_TerminateGameConnection( ISteamUser* lpSteamUser, uint32_t unIPServer, uint16_t usPortServer ) { lpSteamUser->TerminateGameConnection( unIPServer, usPortServer ); } #pragma comment(linker, "/EXPORT:BS_User_TerminateGameConnection=_BS_User_TerminateGameConnection@12") -DLL_EXPORT void DLL_CALL BS_User_TrackAppUsageEvent( ISteamUser* lpSteamUser, CGameID* gameId, uint32_t eAppUsageEvent, const char* pchExtraInfo ) { +DLL_FUNCTION(void) BS_User_TrackAppUsageEvent( ISteamUser* lpSteamUser, CGameID* gameId, uint32_t eAppUsageEvent, const char* pchExtraInfo ) { lpSteamUser->TrackAppUsageEvent( *gameId, eAppUsageEvent, pchExtraInfo ); } #pragma comment(linker, "/EXPORT:BS_User_TrackAppUsageEvent=_BS_User_TrackAppUsageEvent@16") -DLL_EXPORT uint32_t DLL_CALL BS_User_GetUserDataFolder( ISteamUser* lpSteamUser, char* pchBuffer, uint32_t cubBuffer ) { +DLL_FUNCTION(uint32_t) BS_User_GetUserDataFolder( ISteamUser* lpSteamUser, char* pchBuffer, uint32_t cubBuffer ) { return lpSteamUser->GetUserDataFolder( pchBuffer, cubBuffer ); } #pragma comment(linker, "/EXPORT:BS_User_GetUserDataFolder=_BS_User_GetUserDataFolder@12") -DLL_EXPORT void DLL_CALL BS_User_StartVoiceRecording( ISteamUser* lpSteamUser ) { +DLL_FUNCTION(void) BS_User_StartVoiceRecording( ISteamUser* lpSteamUser ) { lpSteamUser->StartVoiceRecording( ); } #pragma comment(linker, "/EXPORT:BS_User_StartVoiceRecording=_BS_User_StartVoiceRecording@4") -DLL_EXPORT void DLL_CALL BS_User_StopVoiceRecording( ISteamUser* lpSteamUser ) { +DLL_FUNCTION(void) BS_User_StopVoiceRecording( ISteamUser* lpSteamUser ) { lpSteamUser->StopVoiceRecording( ); } #pragma comment(linker, "/EXPORT:BS_User_StopVoiceRecording=_BS_User_StopVoiceRecording@4") -DLL_EXPORT EVoiceResult DLL_CALL BS_User_GetAvailableVoice( ISteamUser* lpSteamUser, uint32_t* pcbCompressed, uint32_t* pcbUncompressed, uint32_t nUncompressedVoiceDesiredSampleRate ) { +DLL_FUNCTION(EVoiceResult) BS_User_GetAvailableVoice( ISteamUser* lpSteamUser, uint32_t* pcbCompressed, uint32_t* pcbUncompressed, uint32_t nUncompressedVoiceDesiredSampleRate ) { return lpSteamUser->GetAvailableVoice( pcbCompressed, pcbUncompressed, nUncompressedVoiceDesiredSampleRate ); } #pragma comment(linker, "/EXPORT:BS_User_GetAvailableVoice=_BS_User_GetAvailableVoice@16") -DLL_EXPORT EVoiceResult DLL_CALL BS_User_GetVoice( ISteamUser* lpSteamUser, uint32_t bWantCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t bWantUncompressed, void *pUncompressedDestBuffer, uint32_t cbUncompressedDestBufferSize, uint32_t *nUncompressBytesWritten, uint32_t nUncompressedVoiceDesiredSampleRate ) { +DLL_FUNCTION(EVoiceResult) BS_User_GetVoice( ISteamUser* lpSteamUser, uint32_t bWantCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t bWantUncompressed, void *pUncompressedDestBuffer, uint32_t cbUncompressedDestBufferSize, uint32_t *nUncompressBytesWritten, uint32_t nUncompressedVoiceDesiredSampleRate ) { return lpSteamUser->GetVoice( bWantCompressed != 0, pDestBuffer, cbDestBufferSize, nBytesWritten, bWantUncompressed != 0, pUncompressedDestBuffer, cbUncompressedDestBufferSize, nUncompressBytesWritten, nUncompressedVoiceDesiredSampleRate ); } #pragma comment(linker, "/EXPORT:BS_User_GetVoice=_BS_User_GetVoice@40") -DLL_EXPORT EVoiceResult DLL_CALL BS_User_DecompressVoice( ISteamUser* lpSteamUser, const void *pCompressed, uint32_t cbCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t nDesiredSampleRate ) { +DLL_FUNCTION(EVoiceResult) BS_User_DecompressVoice( ISteamUser* lpSteamUser, const void *pCompressed, uint32_t cbCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t nDesiredSampleRate ) { return lpSteamUser->DecompressVoice( pCompressed, cbCompressed, pDestBuffer, cbDestBufferSize, nBytesWritten, nDesiredSampleRate ); } #pragma comment(linker, "/EXPORT:BS_User_DecompressVoice=_BS_User_DecompressVoice@28") -DLL_EXPORT uint32_t DLL_CALL BS_User_GetVoiceOptimalSampleRate( ISteamUser* lpSteamUser ) { +DLL_FUNCTION(uint32_t) BS_User_GetVoiceOptimalSampleRate( ISteamUser* lpSteamUser ) { return lpSteamUser->GetVoiceOptimalSampleRate( ); } #pragma comment(linker, "/EXPORT:BS_User_GetVoiceOptimalSampleRate=_BS_User_GetVoiceOptimalSampleRate@4") -DLL_EXPORT HAuthTicket DLL_CALL BS_User_GetAuthSessionTicket( ISteamUser* lpSteamUser, void* pTicket, uint32_t cbMaxTicket, uint32_t* pcbTicket ) { +DLL_FUNCTION(HAuthTicket) BS_User_GetAuthSessionTicket( ISteamUser* lpSteamUser, void* pTicket, uint32_t cbMaxTicket, uint32_t* pcbTicket ) { return lpSteamUser->GetAuthSessionTicket( pTicket, cbMaxTicket, pcbTicket ); } #pragma comment(linker, "/EXPORT:BS_User_GetAuthSessionTicket=_BS_User_GetAuthSessionTicket@16") -DLL_EXPORT EBeginAuthSessionResult DLL_CALL BS_User_BeginAuthSession( ISteamUser* lpSteamUser, const void *pAuthTicket, uint32_t cbAuthTicket, CSteamID* steamID ) { +DLL_FUNCTION(EBeginAuthSessionResult) BS_User_BeginAuthSession( ISteamUser* lpSteamUser, const void *pAuthTicket, uint32_t cbAuthTicket, CSteamID* steamID ) { return lpSteamUser->BeginAuthSession( pAuthTicket, cbAuthTicket, *steamID ); } #pragma comment(linker, "/EXPORT:BS_User_BeginAuthSession=_BS_User_BeginAuthSession@16") -DLL_EXPORT void DLL_CALL BS_User_EndAuthSession( ISteamUser* lpSteamUser, CSteamID* steamID ) { +DLL_FUNCTION(void) BS_User_EndAuthSession( ISteamUser* lpSteamUser, CSteamID* steamID ) { lpSteamUser->EndAuthSession( *steamID ); } #pragma comment(linker, "/EXPORT:BS_User_EndAuthSession=_BS_User_EndAuthSession@8") -DLL_EXPORT void DLL_CALL BS_User_CancelAuthTicket( ISteamUser* lpSteamUser, HAuthTicket hAuthTicket ) { +DLL_FUNCTION(void) BS_User_CancelAuthTicket( ISteamUser* lpSteamUser, HAuthTicket hAuthTicket ) { lpSteamUser->CancelAuthTicket( hAuthTicket ); } #pragma comment(linker, "/EXPORT:BS_User_EndAuthSession=_BS_User_EndAuthSession@8") -DLL_EXPORT EUserHasLicenseForAppResult DLL_CALL BS_User_UserHasLicenseForApp( ISteamUser* lpSteamUser, CSteamID* steamID, AppId_t appID ) { +DLL_FUNCTION(EUserHasLicenseForAppResult) BS_User_UserHasLicenseForApp( ISteamUser* lpSteamUser, CSteamID* steamID, AppId_t appID ) { return lpSteamUser->UserHasLicenseForApp( *steamID, appID ); } #pragma comment(linker, "/EXPORT:BS_User_UserHasLicenseForApp=_BS_User_UserHasLicenseForApp@12") -DLL_EXPORT uint32_t DLL_CALL BS_User_IsBehindNAT( ISteamUser* lpSteamUser ) { +DLL_FUNCTION(uint32_t) BS_User_IsBehindNAT( ISteamUser* lpSteamUser ) { return lpSteamUser->BIsBehindNAT( ); } #pragma comment(linker, "/EXPORT:BS_User_IsBehindNAT=_BS_User_IsBehindNAT@4") -DLL_EXPORT void DLL_CALL BS_User_AdvertiseGame( ISteamUser* lpSteamUser, CSteamID* steamIDGameServer, uint32_t unIPServer, uint16_t usPortServer ) { +DLL_FUNCTION(void) BS_User_AdvertiseGame( ISteamUser* lpSteamUser, CSteamID* steamIDGameServer, uint32_t unIPServer, uint16_t usPortServer ) { lpSteamUser->AdvertiseGame( *steamIDGameServer, unIPServer, usPortServer ); } #pragma comment(linker, "/EXPORT:BS_User_AdvertiseGame=_BS_User_AdvertiseGame@16") -DLL_EXPORT SteamAPICall_t* DLL_CALL BS_User_RequestEncryptedAppTicket( ISteamUser* lpSteamUser, void* pDataToInclude, uint32_t cbDataToInclude ) { +DLL_FUNCTION(SteamAPICall_t*) BS_User_RequestEncryptedAppTicket( ISteamUser* lpSteamUser, void* pDataToInclude, uint32_t cbDataToInclude ) { return new uint64_t(lpSteamUser->RequestEncryptedAppTicket( pDataToInclude, cbDataToInclude )); } #pragma comment(linker, "/EXPORT:BS_User_RequestEncryptedAppTicket=_BS_User_RequestEncryptedAppTicket@12") -DLL_EXPORT uint32_t DLL_CALL BS_User_GetEncryptedAppTicket( ISteamUser* lpSteamUser, void *pTicket, uint32_t cbMaxTicket, uint32_t* pcbTicket ) { +DLL_FUNCTION(uint32_t) BS_User_GetEncryptedAppTicket( ISteamUser* lpSteamUser, void *pTicket, uint32_t cbMaxTicket, uint32_t* pcbTicket ) { return lpSteamUser->GetEncryptedAppTicket( pTicket, cbMaxTicket, pcbTicket ); } #pragma comment(linker, "/EXPORT:BS_User_GetEncryptedAppTicket=_BS_User_GetEncryptedAppTicket@16") -DLL_EXPORT uint32_t DLL_CALL BS_User_GetGameBadgeLevel( ISteamUser* lpSteamUser, uint32_t nSeries, uint32_t bFoil ) { +DLL_FUNCTION(uint32_t) BS_User_GetGameBadgeLevel( ISteamUser* lpSteamUser, uint32_t nSeries, uint32_t bFoil ) { return lpSteamUser->GetGameBadgeLevel( nSeries, bFoil != 0 ); } #pragma comment(linker, "/EXPORT:BS_User_GetGameBadgeLevel=_BS_User_GetGameBadgeLevel@12") -DLL_EXPORT uint32_t DLL_CALL BS_User_GetPlayerSteamLevel( ISteamUser* lpSteamUser ) { +DLL_FUNCTION(uint32_t) BS_User_GetPlayerSteamLevel( ISteamUser* lpSteamUser ) { return lpSteamUser->GetPlayerSteamLevel( ); } #pragma comment(linker, "/EXPORT:BS_User_GetPlayerSteamLevel=_BS_User_GetPlayerSteamLevel@4") -DLL_EXPORT SteamAPICall_t* DLL_CALL BS_User_RequestStoreAuthURL( ISteamUser* lpSteamUser, const char* pchRedirectURL ) { +DLL_FUNCTION(SteamAPICall_t*) BS_User_RequestStoreAuthURL( ISteamUser* lpSteamUser, const char* pchRedirectURL ) { return new uint64_t(lpSteamUser->RequestStoreAuthURL( pchRedirectURL )); } -#pragma comment(linker, "/EXPORT:BS_User_RequestStoreAuthURL=_BS_User_RequestStoreAuthURL@8") \ No newline at end of file +#pragma comment(linker, "/EXPORT:BS_User_RequestStoreAuthURL=_BS_User_RequestStoreAuthURL@8") diff --git a/Wrapper/SteamUserStats.cpp b/Wrapper/SteamUserStats.cpp index 6ea8eb3..8045100 100644 --- a/Wrapper/SteamUserStats.cpp +++ b/Wrapper/SteamUserStats.cpp @@ -14,219 +14,224 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" +#include "BlitzSteam.h" -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_RequestCurrentStats( ISteamUserStats* lpSteamUserStats ) { +DLL_FUNCTION(ISteamUserStats*) BS_UserStats() { + return SteamUserStats(); +} +#pragma comment(linker, "/EXPORT:BS_UserStats=_BS_UserStats@0") + +DLL_FUNCTION(uint32_t) BS_UserStats_RequestCurrentStats( ISteamUserStats* lpSteamUserStats ) { return lpSteamUserStats->RequestCurrentStats( ); } #pragma comment(linker, "/EXPORT:BS_UserStats_RequestCurrentStats=_BS_UserStats_RequestCurrentStats@4") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetStat( ISteamUserStats* lpSteamUserStats, const char* pchName, int32_t* pData ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetStat( ISteamUserStats* lpSteamUserStats, const char* pchName, int32_t* pData ) { return lpSteamUserStats->GetStat( pchName, pData ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetStat=_BS_UserStats_GetStat@12") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetStatF( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t* pData ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetStatF( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t* pData ) { return lpSteamUserStats->GetStat( pchName, pData ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetStatF=_BS_UserStats_GetStatF@12") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_SetStat( ISteamUserStats* lpSteamUserStats, const char* pchName, int32_t pData ) { +DLL_FUNCTION(uint32_t) BS_UserStats_SetStat( ISteamUserStats* lpSteamUserStats, const char* pchName, int32_t pData ) { return lpSteamUserStats->SetStat( pchName, pData ); } #pragma comment(linker, "/EXPORT:BS_UserStats_SetStat=_BS_UserStats_SetStat@12") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_SetStatF( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t pData ) { +DLL_FUNCTION(uint32_t) BS_UserStats_SetStatF( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t pData ) { return lpSteamUserStats->SetStat( pchName, pData ); } #pragma comment(linker, "/EXPORT:BS_UserStats_SetStatF=_BS_UserStats_SetStatF@12") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_UpdateAvgRateStat( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t flCountThisSession, double_t* dSessionLength ) { +DLL_FUNCTION(uint32_t) BS_UserStats_UpdateAvgRateStat( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t flCountThisSession, double_t* dSessionLength ) { return lpSteamUserStats->UpdateAvgRateStat( pchName, flCountThisSession, *dSessionLength ); } #pragma comment(linker, "/EXPORT:BS_UserStats_UpdateAvgRateStat=_BS_UserStats_UpdateAvgRateStat@16") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName, bool* pbAchieved ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName, bool* pbAchieved ) { return lpSteamUserStats->GetAchievement( pchName, (bool*)pbAchieved ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievement=_BS_UserStats_GetAchievement@12") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_SetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) { +DLL_FUNCTION(uint32_t) BS_UserStats_SetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) { return lpSteamUserStats->SetAchievement( pchName ); } #pragma comment(linker, "/EXPORT:BS_UserStats_SetAchievement=_BS_UserStats_SetAchievement@8") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_ClearAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) { +DLL_FUNCTION(uint32_t) BS_UserStats_ClearAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) { return lpSteamUserStats->ClearAchievement( pchName ); } #pragma comment(linker, "/EXPORT:BS_UserStats_ClearAchievement=_BS_UserStats_ClearAchievement@8") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetAchievementAndUnlockTime( ISteamUserStats* lpSteamUserStats, const char* pchName, bool* pbAchieved, uint32_t* punUnlockTime ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetAchievementAndUnlockTime( ISteamUserStats* lpSteamUserStats, const char* pchName, bool* pbAchieved, uint32_t* punUnlockTime ) { return lpSteamUserStats->GetAchievementAndUnlockTime( pchName, (bool*)pbAchieved, punUnlockTime ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementAndUnlockTime=_BS_UserStats_GetAchievementAndUnlockTime@16") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_StoreStats( ISteamUserStats* lpSteamUserStats ) { +DLL_FUNCTION(uint32_t) BS_UserStats_StoreStats( ISteamUserStats* lpSteamUserStats ) { return lpSteamUserStats->StoreStats( ); } #pragma comment(linker, "/EXPORT:BS_UserStats_StoreStats=_BS_UserStats_StoreStats@4") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetAchievementIcon( ISteamUserStats* lpSteamUserStats, const char* pchName ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetAchievementIcon( ISteamUserStats* lpSteamUserStats, const char* pchName ) { return lpSteamUserStats->GetAchievementIcon( pchName ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementIcon=_BS_UserStats_GetAchievementIcon@8") -DLL_EXPORT const char* DLL_CALL BS_UserStats_GetAchievementDisplayAttribute( ISteamUserStats* lpSteamUserStats, const char* pchName, const char* pchKey ) { +DLL_FUNCTION(const char*) BS_UserStats_GetAchievementDisplayAttribute( ISteamUserStats* lpSteamUserStats, const char* pchName, const char* pchKey ) { return lpSteamUserStats->GetAchievementDisplayAttribute( pchName, pchKey ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementDisplayAttribute=_BS_UserStats_GetAchievementDisplayAttribute@12") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_IndicateAchievementProgress( ISteamUserStats* lpSteamUserStats, const char* pchName, uint32_t nCurProgress, uint32_t nMaxProgress ) { +DLL_FUNCTION(uint32_t) BS_UserStats_IndicateAchievementProgress( ISteamUserStats* lpSteamUserStats, const char* pchName, uint32_t nCurProgress, uint32_t nMaxProgress ) { return lpSteamUserStats->IndicateAchievementProgress( pchName, nCurProgress, nMaxProgress ); } #pragma comment(linker, "/EXPORT:BS_UserStats_IndicateAchievementProgress=_BS_UserStats_IndicateAchievementProgress@16") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetNumAchievements( ISteamUserStats* lpSteamUserStats ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetNumAchievements( ISteamUserStats* lpSteamUserStats ) { return lpSteamUserStats->GetNumAchievements( ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetNumAchievements=_BS_UserStats_GetNumAchievements@4") -DLL_EXPORT const char* DLL_CALL BS_UserStats_GetAchievementName( ISteamUserStats* lpSteamUserStats, uint32 iAchievement ) { +DLL_FUNCTION(const char*) BS_UserStats_GetAchievementName( ISteamUserStats* lpSteamUserStats, uint32_t iAchievement ) { return lpSteamUserStats->GetAchievementName( iAchievement ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementName=_BS_UserStats_GetAchievementName@8") -DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_RequestUserStats( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser ) { +DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_RequestUserStats( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser ) { return new uint64_t( lpSteamUserStats->RequestUserStats( *steamIDUser ) ); } #pragma comment(linker, "/EXPORT:BS_UserStats_RequestUserStats=_BS_UserStats_RequestUserStats@8") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetUserStat( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pData ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetUserStat( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pData ) { return lpSteamUserStats->GetUserStat( *steamIDUser, pchName, (int32_t*)pData ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetUserStat=_BS_UserStats_GetUserStat@16") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetUserStatF( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, float_t* pData ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetUserStatF( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, float_t* pData ) { return lpSteamUserStats->GetUserStat( *steamIDUser, pchName, pData ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetUserStatF=_BS_UserStats_GetUserStatF@16") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetUserAchievement( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, bool* pbAchieved ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetUserAchievement( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, bool* pbAchieved ) { return lpSteamUserStats->GetUserAchievement( *steamIDUser, pchName, (bool*)pbAchieved ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetUserAchievement=_BS_UserStats_GetUserAchievement@16") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetUserAchievementAndUnlockTime( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, bool* pbAchieved, uint32_t* punUnlockTime ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetUserAchievementAndUnlockTime( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, bool* pbAchieved, uint32_t* punUnlockTime ) { return lpSteamUserStats->GetUserAchievementAndUnlockTime( *steamIDUser, pchName, (bool*)pbAchieved, punUnlockTime ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetUserAchievementAndUnlockTime=_BS_UserStats_GetUserAchievementAndUnlockTime@20") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_ResetAllStats( ISteamUserStats* lpSteamUserStats, uint32_t bAchievementsToo ) { +DLL_FUNCTION(uint32_t) BS_UserStats_ResetAllStats( ISteamUserStats* lpSteamUserStats, uint32_t bAchievementsToo ) { return lpSteamUserStats->ResetAllStats( bAchievementsToo != 0 ); } #pragma comment(linker, "/EXPORT:BS_UserStats_ResetAllStats=_BS_UserStats_ResetAllStats@8") -DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_FindOrCreateLeaderboard( ISteamUserStats* lpSteamUserStats, const char* pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ) { +DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_FindOrCreateLeaderboard( ISteamUserStats* lpSteamUserStats, const char* pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ) { return new uint64_t( lpSteamUserStats->FindOrCreateLeaderboard( pchLeaderboardName, eLeaderboardSortMethod, eLeaderboardDisplayType ) ); } #pragma comment(linker, "/EXPORT:BS_UserStats_FindOrCreateLeaderboard=_BS_UserStats_FindOrCreateLeaderboard@16") -DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_FindLeaderboard( ISteamUserStats* lpSteamUserStats, const char *pchLeaderboardName ) { +DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_FindLeaderboard( ISteamUserStats* lpSteamUserStats, const char *pchLeaderboardName ) { return new uint64_t( lpSteamUserStats->FindLeaderboard( pchLeaderboardName ) ); } #pragma comment(linker, "/EXPORT:BS_UserStats_FindLeaderboard=_BS_UserStats_FindLeaderboard@8") -DLL_EXPORT const char* DLL_CALL BS_UserStats_GetLeaderboardName( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) { +DLL_FUNCTION(const char*) BS_UserStats_GetLeaderboardName( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) { return lpSteamUserStats->GetLeaderboardName( *hSteamLeaderboard ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardName=_BS_UserStats_GetLeaderboardName@8") -DLL_EXPORT int DLL_CALL BS_UserStats_GetLeaderboardEntryCount( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) { +DLL_FUNCTION(int) BS_UserStats_GetLeaderboardEntryCount( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) { return lpSteamUserStats->GetLeaderboardEntryCount( *hSteamLeaderboard ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardEntryCount=_BS_UserStats_GetLeaderboardEntryCount@8") -DLL_EXPORT ELeaderboardSortMethod DLL_CALL BS_UserStats_GetLeaderboardSortMethod( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) { +DLL_FUNCTION(ELeaderboardSortMethod) BS_UserStats_GetLeaderboardSortMethod( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) { return lpSteamUserStats->GetLeaderboardSortMethod( *hSteamLeaderboard ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardSortMethod=_BS_UserStats_GetLeaderboardSortMethod@8") -DLL_EXPORT ELeaderboardDisplayType DLL_CALL BS_UserStats_GetLeaderboardDisplayType( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) { +DLL_FUNCTION(ELeaderboardDisplayType) BS_UserStats_GetLeaderboardDisplayType( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) { return lpSteamUserStats->GetLeaderboardDisplayType( *hSteamLeaderboard ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardDisplayType=_BS_UserStats_GetLeaderboardDisplayType@8") -DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_DownloadLeaderboardEntries( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) { +DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_DownloadLeaderboardEntries( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) { return new uint64_t( lpSteamUserStats->DownloadLeaderboardEntries( *hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd ) ); } #pragma comment(linker, "/EXPORT:BS_UserStats_DownloadLeaderboardEntries=_BS_UserStats_DownloadLeaderboardEntries@20") -DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_DownloadLeaderboardEntriesForUsers( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, CSteamID* prgUsers, int cUsers ) { +DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_DownloadLeaderboardEntriesForUsers( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, CSteamID* prgUsers, int cUsers ) { return new uint64_t( lpSteamUserStats->DownloadLeaderboardEntriesForUsers( *hSteamLeaderboard, prgUsers, cUsers ) ); } #pragma comment(linker, "/EXPORT:BS_UserStats_DownloadLeaderboardEntriesForUsers=_BS_UserStats_DownloadLeaderboardEntriesForUsers@16") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetDownloadedLeaderboardEntry( ISteamUserStats* lpSteamUserStats, SteamLeaderboardEntries_t* hSteamLeaderboardEntries, int index, LeaderboardEntry_t *pLeaderboardEntry, int32 *pDetails, int cDetailsMax ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetDownloadedLeaderboardEntry( ISteamUserStats* lpSteamUserStats, SteamLeaderboardEntries_t* hSteamLeaderboardEntries, int index, LeaderboardEntry_t *pLeaderboardEntry, int32 *pDetails, int cDetailsMax ) { return lpSteamUserStats->GetDownloadedLeaderboardEntry( *hSteamLeaderboardEntries, index, pLeaderboardEntry, pDetails, cDetailsMax ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetDownloadedLeaderboardEntry=_BS_UserStats_GetDownloadedLeaderboardEntry@24") -DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_UploadLeaderboardScore( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32_t* pScoreDetails, int cScoreDetailsCount ) { +DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_UploadLeaderboardScore( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32_t* pScoreDetails, int cScoreDetailsCount ) { return new uint64_t(lpSteamUserStats->UploadLeaderboardScore( *hSteamLeaderboard, eLeaderboardUploadScoreMethod, nScore, pScoreDetails, cScoreDetailsCount )); } #pragma comment(linker, "/EXPORT:BS_UserStats_UploadLeaderboardScore=_BS_UserStats_UploadLeaderboardScore@24") -DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_AttachLeaderboardUGC( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, UGCHandle_t* hUGC ) { +DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_AttachLeaderboardUGC( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, UGCHandle_t* hUGC ) { return new uint64_t( lpSteamUserStats->AttachLeaderboardUGC( *hSteamLeaderboard, *hUGC ) ); } #pragma comment(linker, "/EXPORT:BS_UserStats_AttachLeaderboardUGC=_BS_UserStats_AttachLeaderboardUGC@12") -DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_GetNumberOfCurrentPlayers( ISteamUserStats* lpSteamUserStats ) { +DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_GetNumberOfCurrentPlayers( ISteamUserStats* lpSteamUserStats ) { return new uint64_t( lpSteamUserStats->GetNumberOfCurrentPlayers( ) ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetNumberOfCurrentPlayers=_BS_UserStats_GetNumberOfCurrentPlayers@4") -DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_RequestGlobalAchievementPercentages( ISteamUserStats* lpSteamUserStats ) { +DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_RequestGlobalAchievementPercentages( ISteamUserStats* lpSteamUserStats ) { return new uint64_t( lpSteamUserStats->RequestGlobalAchievementPercentages( ) ); } #pragma comment(linker, "/EXPORT:BS_UserStats_RequestGlobalAchievementPercentages=_BS_UserStats_RequestGlobalAchievementPercentages@4") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetMostAchievedAchievementInfo( ISteamUserStats* lpSteamUserStats, char *pchName, uint32 unNameBufLen, float *pflPercent, bool* pbAchieved ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetMostAchievedAchievementInfo( ISteamUserStats* lpSteamUserStats, char *pchName, uint32_t unNameBufLen, float *pflPercent, bool* pbAchieved ) { return lpSteamUserStats->GetMostAchievedAchievementInfo( pchName, unNameBufLen, pflPercent, pbAchieved ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetMostAchievedAchievementInfo=_BS_UserStats_GetMostAchievedAchievementInfo@20") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetNextMostAchievedAchievementInfo( ISteamUserStats* lpSteamUserStats, int iIteratorPrevious, char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetNextMostAchievedAchievementInfo( ISteamUserStats* lpSteamUserStats, int iIteratorPrevious, char *pchName, uint32_t unNameBufLen, float *pflPercent, bool *pbAchieved ) { return lpSteamUserStats->GetNextMostAchievedAchievementInfo( iIteratorPrevious, pchName, unNameBufLen, pflPercent, pbAchieved ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetNextMostAchievedAchievementInfo=_BS_UserStats_GetNextMostAchievedAchievementInfo@24") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetAchievementAchievedPercent( ISteamUserStats* lpSteamUserStats, const char *pchName, float *pflPercent ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetAchievementAchievedPercent( ISteamUserStats* lpSteamUserStats, const char *pchName, float *pflPercent ) { return lpSteamUserStats->GetAchievementAchievedPercent( pchName, pflPercent ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementAchievedPercent=_BS_UserStats_GetAchievementAchievedPercent@12") -DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_RequestGlobalStats( ISteamUserStats* lpSteamUserStats, int nHistoryDays ) { +DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_RequestGlobalStats( ISteamUserStats* lpSteamUserStats, int nHistoryDays ) { return new uint64_t( lpSteamUserStats->RequestGlobalStats( nHistoryDays ) ); } #pragma comment(linker, "/EXPORT:BS_UserStats_RequestGlobalStats=_BS_UserStats_RequestGlobalStats@8") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetGlobalStatLL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64* pData ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetGlobalStatLL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64* pData ) { return lpSteamUserStats->GetGlobalStat( pchStatName, pData ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatLL=_BS_UserStats_GetGlobalStatLL@12") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetGlobalStatD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double* pData ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetGlobalStatD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double* pData ) { return lpSteamUserStats->GetGlobalStat( pchStatName, pData ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatD=_BS_UserStats_GetGlobalStatD@12") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetGlobalStatHistoryLL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64 *pData, uint32 cubData ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetGlobalStatHistoryLL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64 *pData, uint32_t cubData ) { return lpSteamUserStats->GetGlobalStatHistory( pchStatName, pData, cubData ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatHistoryLL=_BS_UserStats_GetGlobalStatHistoryLL@16") -DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetGlobalStatHistoryD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double *pData, uint32 cubData ) { +DLL_FUNCTION(uint32_t) BS_UserStats_GetGlobalStatHistoryD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double *pData, uint32_t cubData ) { return lpSteamUserStats->GetGlobalStatHistory( pchStatName, pData, cubData ); } #pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatHistoryD=_BS_UserStats_GetGlobalStatHistoryD@16") diff --git a/Wrapper/SteamUtils.cpp b/Wrapper/SteamUtils.cpp index e69de29..9fa8009 100644 --- a/Wrapper/SteamUtils.cpp +++ b/Wrapper/SteamUtils.cpp @@ -0,0 +1,23 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamUtils*) BS_Utils() { + return SteamUtils(); +} +#pragma comment(linker, "/EXPORT:BS_Utils=_BS_Utils@0") + diff --git a/Wrapper/SteamVideo.cpp b/Wrapper/SteamVideo.cpp index e69de29..96b9481 100644 --- a/Wrapper/SteamVideo.cpp +++ b/Wrapper/SteamVideo.cpp @@ -0,0 +1,23 @@ +// BlitzSteam - Steam wrapper for Blitz +// Copyright (C) 2015 Xaymar (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "BlitzSteam.h" + +DLL_FUNCTION(ISteamVideo*) BS_Video() { + return SteamVideo(); +} +#pragma comment(linker, "/EXPORT:BS_Video=_BS_Video@0") +