BlitzSteam update 06.02.2016

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 <http:;www.gnu.org/licenses/>.
+;	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-; 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
@@ -77,20 +111,309 @@ Const BS_ECallback_ClientUtilsCallbacks						= 1600
 Const BS_ECallback_ClientVideoCallbacks						= 4600
 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
-
+;! Apps ------------------------------------------------------------------------
-
-; SteamApps ---------------------------------------------------------------------
 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 ------------------------------------------------------------------
+;! Friends ---------------------------------------------------------------------
-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
-
 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 ---------------------------------------------------------------
+;! GameServer ------------------------------------------------------------------
-Const BS_EServerMode_Invalid								= 0
-Const BS_EServerMode_NoAuthentication						= 1
-Const BS_EServerMode_Authentication							= 2
-Const BS_EServerMode_AuthenticationAndSecure				= 3
 
-; SteamUser ---------------------------------------------------------------------
+; client has been approved to connect to this game server
-Const BS_EVoiceResult_OK									= 0
+Const BS_CALLBACK_GSClientApprove							= BS_ECallback_SteamGameServerCallbacks + 1
-Const BS_EVoiceResult_NotInitialized						= 1
+Type BS_GSClientApprove_t
-Const BS_EVoiceResult_NotRecording							= 2
+	Field SteamIDHigh%, SteamIDLow%					; SteamID of approved player
-Const BS_EVoiceResult_NoData								= 3
+	Field OwnerSteamIDHigh%, OwnerSteamIDLow%		; SteamID of original owner for game license
-Const BS_EVoiceResult_BufferTooSmall						= 4
+End Type
-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
 
-Const BS_EBeginAuthSessionResult_OK							= 0	; Ticket is valid for this game and this steamID.
+; client has been denied to connection to this game server
-Const BS_EBeginAuthSessionResult_InvalidTicket				= 1	; Ticket is not valid.
+Const BS_CALLBACK_GSClientDeny								= BS_ECallback_SteamGameServerCallbacks + 2
-Const BS_EBeginAuthSessionResult_DuplicateRequest			= 2	; A ticket has already been submitted for this steamID
+Type BS_GSClientDeny_t
-Const BS_EBeginAuthSessionResult_InvalidVersion				= 3	; Ticket is from an incompatible interface version
+	Field SteamIDHigh%, SteamIDLow%
-Const BS_EBeginAuthSessionResult_GameMismatch				= 4	; Ticket is not for this game
+	Field eDenyReason%, pad0%
-Const BS_EBeginAuthSessionResult_ExpiredTicket				= 5	; Ticket has expired
+	Field rgchOptionalText%[31]						; 128 Bytes of Optional Text
+End Type
 
-Const BS_EUserHasLicenseResult_HasLicense					= 0 ; User has a license for specified app
+; request the game server should kick the user
-Const BS_EUserHasLicenseResult_DoesNotHaveLicense			= 1 ; User does not have a license for the specified app
+Const BS_CALLBACK_GSClientKick								= BS_ECallback_SteamGameServerCallbacks + 3
-Const BS_EUserHasLicenseResult_NoAuth						= 2 ; User has not been authenticated
+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_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
 
 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 hSteamLeaderboard_High%, hSteamLeaderboard_Low%	;	 handle to the leaderboard serarched for, 0 if no leaderboard found
-	Field bLeaderboardFound%								;				// 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

Blitz/BlitzSteam.decls

@@ -15,85 +15,23 @@
 ;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
 
 .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 -------------------------------------------------------------------------
+; Steam -----------------------------------------------------------------------
-BS_Init%()
+BS_Steam_Init%()
-BS_Shutdown()
+BS_Steam_Shutdown()
-BS_IsSteamRunning%()
+BS_Steam_IsSteamRunning%()
-BS_RestartAppIfNecessary%(unOwnAppID%)
+BS_Steam_RestartAppIfNecessary%(unOwnAppID%)
-BS_SetMiniDumpComment(pchMsg$)
+BS_Steam_SetMiniDumpComment(pchMsg$)
-BS_WriteMiniDump(uStructuredExceptionCode%, pvExceptionInfo*, uBuildID%)
+BS_Steam_WriteMiniDump(uStructuredExceptionCode%, pvExceptionInfo*, uBuildID%)
-BS_WriteMiniDumpEx(uStructuredExceptionCode%, pvExceptionInfo%, uBuildID%) : "BS_WriteMiniDump"
+BS_Steam_WriteMiniDumpEx(uStructuredExceptionCode%, pvExceptionInfo%, uBuildID%) : "BS_WriteMiniDump"
-; -- Interfaces
+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"
@@ -354,3 +382,64 @@ BS_UserStats_GetGlobalStatHistoryLL%(lpSteamUserStats, pchStatName$, pData*, cub
 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"
+
+; 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%()

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,9 +127,9 @@ 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()
@@ -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

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 <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
 
 uint32_t WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
 	switch (fdwReason) {

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 <http://www.gnu.org/licenses/>.
+
+#pragma once
+
+// Macros
+#define DLL_FUNCTION(type) extern "C" type __stdcall
+//#define DLL_FUNCTION(type) extern "C" __declspec(dllexport) type __stdcall
+
+// Standard Library
+#include <time.h>
+#include <exception>
+#include <stdexcept>
+#include <memory>
+
+// Platform specific: Windows
+#include <windows.h>
+
+// 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"

BlitzSteam.vcxproj

@@ -13,6 +13,7 @@
   <PropertyGroup Label="Globals">
     <ProjectGuid>{805CB1EB-82F0-405E-AC0B-03FBE82CC77D}</ProjectGuid>
     <RootNamespace>BlitzSteam</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
@@ -40,14 +41,14 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <OutDir>$(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\</OutDir>
+    <OutDir>$(SolutionDir)#Build\$(ProjectName)\$(Configuration)\</OutDir>
-    <IntDir>$(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
+    <IntDir>$(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
     <TargetExt>.dll</TargetExt>
     <LinkIncremental>true</LinkIncremental>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <OutDir>$(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\</OutDir>
+    <OutDir>$(SolutionDir)#Build\$(ProjectName)\$(Configuration)\</OutDir>
-    <IntDir>$(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
+    <IntDir>$(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
     <TargetExt>.dll</TargetExt>
     <LinkIncremental>false</LinkIncremental>
   </PropertyGroup>
@@ -55,23 +56,21 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <SDLCheck>
-      </SDLCheck>
       <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <WholeProgramOptimization>false</WholeProgramOptimization>
       <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
       <BufferSecurityCheck>false</BufferSecurityCheck>
-      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <StructMemberAlignment>4Bytes</StructMemberAlignment>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <CompileAsManaged>false</CompileAsManaged>
       <CompileAsWinRT>false</CompileAsWinRT>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <CreateHotpatchableImage>false</CreateHotpatchableImage>
+      <CreateHotpatchableImage>true</CreateHotpatchableImage>
-      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <OpenMPSupport>false</OpenMPSupport>
       <ForcedIncludeFiles>
       </ForcedIncludeFiles>
@@ -80,13 +79,13 @@
       <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
       <IntrinsicFunctions>false</IntrinsicFunctions>
       <StringPooling>true</StringPooling>
-      <EnableEnhancedInstructionSet>NoExtensions</EnableEnhancedInstructionSet>
+      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
-      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <FloatingPointExceptions>true</FloatingPointExceptions>
       <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
       <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
     </ClCompile>
     <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <GenerateDebugInformation>Debug</GenerateDebugInformation>
       <Version>1.0</Version>
       <AdditionalLibraryDirectories>$(ProjectDir)\SteamworksSDK\redistributable_bin</AdditionalLibraryDirectories>
       <AdditionalDependencies>steam_api.lib;%(AdditionalDependencies)</AdditionalDependencies>
@@ -108,10 +107,8 @@
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Full</Optimization>
-      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>
-      </SDLCheck>
       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
@@ -129,12 +126,13 @@
       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
       <MinimalRebuild>false</MinimalRebuild>
       <CallingConvention>Cdecl</CallingConvention>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <InlineFunctionExpansion>Default</InlineFunctionExpansion>
       <StringPooling>true</StringPooling>
-      <EnableEnhancedInstructionSet>NoExtensions</EnableEnhancedInstructionSet>
+      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
-      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <FloatingPointExceptions>true</FloatingPointExceptions>
       <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
       <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DebugInformationFormat>None</DebugInformationFormat>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>false</GenerateDebugInformation>
@@ -155,9 +153,10 @@
     </ProjectReference>
   </ItemDefinitionGroup>
   <ItemGroup>
-    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="BlitzSteam.cpp" />
     <ClCompile Include="Helpers\CSteamID.cpp" />
     <ClCompile Include="Helpers\Callbacks.cpp" />
+    <ClCompile Include="Helpers\Helper.cpp" />
     <ClCompile Include="Wrapper\Steam.cpp" />
     <ClCompile Include="Wrapper\SteamAppList.cpp" />
     <ClCompile Include="Wrapper\SteamApps.cpp" />
@@ -184,18 +183,19 @@
     <ClCompile Include="Wrapper\SteamVideo.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="dllmain.h" />
+    <ClInclude Include="BlitzSteam.h" />
     <ClInclude Include="Helpers\BlitzPointer.h" />
     <ClInclude Include="Helpers\Callbacks.h" />
     <ClInclude Include="Helpers\CSteamID.h" />
+    <ClInclude Include="Helpers\Helper.h" />
   </ItemGroup>
   <ItemGroup>
     <None Include="LICENSE">
-      <Link>LICENSE</Link>
+      <Link>BlitzSteam.LICENSE</Link>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
     <None Include="LICENSE.lesser">
-      <Link>LICENSE.lesser</Link>
+      <Link>BlitzSteam.LICENSE.lesser</Link>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
     <None Include="Blitz\BlitzSteam.bb">

BlitzSteam.vcxproj.filters

@@ -20,9 +20,6 @@
     </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="dllmain.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Wrapper\Steam.cpp">
       <Filter>Source Files\Wrapper</Filter>
     </ClCompile>
@@ -101,11 +98,14 @@
     <ClCompile Include="Helpers\Callbacks.cpp">
       <Filter>Source Files\Helpers</Filter>
     </ClCompile>
+    <ClCompile Include="BlitzSteam.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Helpers\Helper.cpp">
+      <Filter>Source Files\Helpers</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="dllmain.h">
-      <Filter>Source Files</Filter>
-    </ClInclude>
     <ClInclude Include="Helpers\Callbacks.h">
       <Filter>Source Files\Helpers</Filter>
     </ClInclude>
@@ -115,6 +115,12 @@
     <ClInclude Include="Helpers\BlitzPointer.h">
       <Filter>Source Files\Helpers</Filter>
     </ClInclude>
+    <ClInclude Include="BlitzSteam.h">
+      <Filter>Source Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Helpers\Helper.h">
+      <Filter>Source Files\Helpers</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="SteamworksSDK\redistributable_bin\steam_api.dll">

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 <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#pragma once
 
-typedef uint32_t(__stdcall *BP_Function0_t)();
+typedef void*(__stdcall *BP_Function0_t)();
-typedef uint32_t(__stdcall *BP_Function1_t)(uint32_t);
+typedef void*(__stdcall *BP_Function1_t)(uint32_t);
-typedef uint32_t(__stdcall *BP_Function2_t)(uint32_t, uint32_t);
+typedef void*(__stdcall *BP_Function2_t)(uint32_t, uint32_t);
-typedef uint32_t(__stdcall *BP_Function3_t)(uint32_t, uint32_t, uint32_t);
+typedef void*(__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_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)

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 <http://www.gnu.org/licenses/>.
 
-#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")

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 <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#pragma once
+#include "BlitzSteam.h"
 
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_New();
+DLL_FUNCTION(CSteamID*) BS_CSteamID_New();
-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);
-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);
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_FromSteamID(uint64_t* ulSteamID);
+DLL_FUNCTION(CSteamID*) BS_CSteamID_FromSteamID(uint64_t* ulSteamID);
-DLL_EXPORT CSteamID* DLL_CALL BS_CSteamID_Copy(CSteamID* pSteamID);
+DLL_FUNCTION(CSteamID*) BS_CSteamID_Copy(CSteamID* pSteamID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_Destroy(CSteamID* pSteamID);
+DLL_FUNCTION(void) BS_CSteamID_Destroy(CSteamID* pSteamID);
-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);
-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);
-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);
-DLL_EXPORT void DLL_CALL BS_CSteamID_SetFromUInt64(CSteamID* pSteamID, uint64_t* ulSteamID);
+DLL_FUNCTION(void) BS_CSteamID_SetFromUInt64(CSteamID* pSteamID, uint64_t* ulSteamID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_Clear(CSteamID* pSteamID);
+DLL_FUNCTION(void) BS_CSteamID_Clear(CSteamID* pSteamID);
-DLL_EXPORT uint64_t* DLL_CALL BS_CSteamID_ConvertToUInt64(CSteamID* pSteamID);
+DLL_FUNCTION(uint64_t*) BS_CSteamID_ConvertToUInt64(CSteamID* pSteamID);
-DLL_EXPORT uint64_t* DLL_CALL BS_CSteamID_GetStaticAccountKey(CSteamID* pSteamID);
+DLL_FUNCTION(uint64_t*) BS_CSteamID_GetStaticAccountKey(CSteamID* pSteamID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_CreateBlankAnonLogon(CSteamID* pSteamID, EUniverse eUniverse);
+DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonLogon(CSteamID* pSteamID, EUniverse eUniverse);
-DLL_EXPORT void DLL_CALL BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pSteamID, EUniverse eUniverse);
+DLL_FUNCTION(void) BS_CSteamID_CreateBlankAnonUserLogon(CSteamID* pSteamID, EUniverse eUniverse);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_BlankAnonAccount(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_BlankAnonAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_GameServerAccount(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_GameServerAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_PersistentGameServerAccount(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_PersistentGameServerAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonGameServerAccount(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_AnonGameServerAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ContentServerAccount(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_ContentServerAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ClanAccount(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_ClanAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ChatAccount(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_ChatAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IsLobby(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_IsLobby(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IndividualAccount(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_IndividualAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonAccount(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_AnonAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_AnonUserAccount(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_AnonUserAccount(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_ConsoleUserAccount(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_ConsoleUserAccount(CSteamID* pSteamID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_SetAccountID(CSteamID* pSteamID, AccountID_t unAccountID);
+DLL_FUNCTION(void) BS_CSteamID_SetAccountID(CSteamID* pSteamID, AccountID_t unAccountID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_SetAccountInstance(CSteamID* pSteamID, uint32_t unInstance);
+DLL_FUNCTION(void) BS_CSteamID_SetAccountInstance(CSteamID* pSteamID, uint32_t unInstance);
-DLL_EXPORT void DLL_CALL BS_CSteamID_ClearIndividualInstance(CSteamID* pSteamID);
+DLL_FUNCTION(void) BS_CSteamID_ClearIndividualInstance(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_HasNoIndividualInstance(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_HasNoIndividualInstance(CSteamID* pSteamID);
-DLL_EXPORT AccountID_t DLL_CALL BS_CSteamID_GetAccountID(CSteamID* pSteamID);
+DLL_FUNCTION(AccountID_t) BS_CSteamID_GetAccountID(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_GetAccountInstance(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_GetAccountInstance(CSteamID* pSteamID);
-DLL_EXPORT EAccountType DLL_CALL BS_CSteamID_GetEAccountType(CSteamID* pSteamID);
+DLL_FUNCTION(EAccountType) BS_CSteamID_GetEAccountType(CSteamID* pSteamID);
-DLL_EXPORT EUniverse DLL_CALL BS_CSteamID_GetEUniverse(CSteamID* pSteamID);
+DLL_FUNCTION(EUniverse) BS_CSteamID_GetEUniverse(CSteamID* pSteamID);
-DLL_EXPORT void DLL_CALL BS_CSteamID_SetEUniverse(CSteamID* pSteamID, EUniverse eUniverse);
+DLL_FUNCTION(void) BS_CSteamID_SetEUniverse(CSteamID* pSteamID, EUniverse eUniverse);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_IsValid(CSteamID* pSteamID);
+DLL_FUNCTION(uint32_t) BS_CSteamID_IsValid(CSteamID* pSteamID);
-DLL_EXPORT uint32_t DLL_CALL BS_CSteamID_Compare(CSteamID* pSteamID, CSteamID* pSteamIDOther);
+DLL_FUNCTION(uint32_t) BS_CSteamID_Compare(CSteamID* pSteamID, CSteamID* pSteamIDOther);

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 <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "Callbacks.h"
-#include "Helpers/BlitzPointer.h"
-#include <time.h>
 
 // Callbacks
-class BS_Callback : CCallbackBase {
+void BS_Callback::Run(void *pvParam) {
-	public:
+	BP_CallFunction3(bbRunFunction, reinterpret_cast<uint32_t>(pvParam), 0, 0);
-	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) {
+void BS_Callback::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));
+	BP_CallFunction3(bbRunFunction, reinterpret_cast<uint32_t>(pvParam), (uint32_t)bIOFailure, reinterpret_cast<uint32_t>(&hSteamAPICall));
 }
 
-	virtual int GetCallbackSizeBytes() {
+int BS_Callback::GetCallbackSizeBytes() {
 	return sizeof(BS_Callback);
 }
-};
 
-DLL_EXPORT void* DLL_CALL BS_Helper_CreateCallback(uint32_t fpFunctionPointer) {
+// DLL-Callables
-	BS_Callback* lpBSCallback = new BS_Callback();
+DLL_FUNCTION(BS_Callback*) BS_Callback_Create(uint32_t fpFunctionPointer) {
-	lpBSCallback->blitzFunctionPointer = fpFunctionPointer;
+	BS_Callback* lpCallback = new BS_Callback();
-	return lpBSCallback;
+	lpCallback->bbRunFunction = (void*)fpFunctionPointer;
+	return lpCallback;
 }
-#pragma comment(linker, "/EXPORT:BS_Helper_CreateCallback=_BS_Helper_CreateCallback@4")
+#pragma comment(linker, "/EXPORT:BS_Callback_Create=_BS_Callback_Create@4")
 
-DLL_EXPORT void DLL_CALL BS_Helper_DestroyCallback(uint32_t lpCallback) {
+DLL_FUNCTION(void) BS_Callback_Destroy(BS_Callback* lpCallback) {
-	BS_Callback* lpBSCallback = (BS_Callback*)lpCallback;
+	if (lpCallback != nullptr) {
-	if (lpBSCallback != nullptr) {
+		delete lpCallback;
-		delete lpBSCallback;
 	}
 }
-#pragma comment(linker, "/EXPORT:BS_Helper_DestroyCallback=_BS_Helper_DestroyCallback@4")
+#pragma comment(linker, "/EXPORT:BS_Callback_Destroy=_BS_Callback_Destroy@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")

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 <http://www.gnu.org/licenses/>.
+
+#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);

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 <http://www.gnu.org/licenses/>.
+
+#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")

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 <http://www.gnu.org/licenses/>.
 
-// STL Exceptions
+#pragma once
-#include <exception>
+#include "BlitzSteam.h"
-#include <stdexcept>
 
-// Memory Management
+DLL_FUNCTION(const char*) BS_Helper_FormatUnixTime(uint32_t unTime, const char* pchFormat);
-#include <memory>
-
-// Platform specific: Windows
-#include <windows.h>
-
-// 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"

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 <http://www.gnu.org/licenses/>.
 
-#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().
+// -- Callbacks
-DLL_EXPORT ISteamClient* DLL_CALL BS_Client() {
+DLL_FUNCTION(void) BS_Steam_RunCallbacks() {
-	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() {
 	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) {
+DLL_FUNCTION(void) BS_Steam_RegisterCallResult(class CCallbackBase *pCallback, uint64_t* phAPICall) {
-	SteamAPI_RegisterCallResult(pCallback, ((uint64_t)hAPICall_L << 32) + (uint64_t)hAPICall_R);
+	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) {
+DLL_FUNCTION(void) BS_Steam_UnregisterCallResult(class CCallbackBase *pCallback, uint64_t* phAPICall) {
-	SteamAPI_UnregisterCallResult(pCallback, ((uint64_t)hAPICall_L << 32) + (uint64_t)hAPICall_R);
+	SteamAPI_UnregisterCallResult(pCallback, *phAPICall);
 }
-#pragma comment(linker, "/EXPORT:BS_UnregisterCallResult=_BS_UnregisterCallResult@12")
+#pragma comment(linker, "/EXPORT:BS_Steam_UnregisterCallResult=_BS_Steam_UnregisterCallResult@8")

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 <http://www.gnu.org/licenses/>.
 
-#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")

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 <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
-#include "Helpers/CSteamID.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")

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 <http://www.gnu.org/licenses/>.
 
-#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")

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 <http://www.gnu.org/licenses/>.
 
-#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")  

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 <http://www.gnu.org/licenses/>.
 
-#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) {
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_SetPersonaName(ISteamFriends* lpSteamFriends, const char* pchPersonaName) {
-	return lpSteamFriends->SetPersonaName(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) {
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_DownloadClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* psteamIDClans, int32_t cClansToRequest) {
-	return lpSteamFriends->DownloadClanActivityCounts(psteamIDClans, 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) {
+DLL_FUNCTION(CSteamID*) BS_Friends_GetFriendFromSourceByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource, int32_t iFriend) {
-	CSteamID* steamID = new CSteamID(lpSteamFriends->GetFriendFromSourceByIndex(*steamIDSource, iFriend));
+	return new CSteamID(lpSteamFriends->GetFriendFromSourceByIndex(*steamIDSource, iFriend));
-	return steamID;
 }
 #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) {
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_RequestClanOfficerList(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
-	return lpSteamFriends->RequestClanOfficerList(*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) {
+DLL_FUNCTION(CSteamID*) BS_Friends_GetClanOwner(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
-	CSteamID* steamID = new CSteamID(lpSteamFriends->GetClanOwner(*steamIDClan));
+	return new CSteamID(lpSteamFriends->GetClanOwner(*steamIDClan));
-	return steamID;
 }
 #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) {
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_JoinClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
-	return lpSteamFriends->JoinClanChatRoom(*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) {
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_GetFollowerCount(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
-	return lpSteamFriends->GetFollowerCount(*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) {
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_IsFollowing(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
-	return lpSteamFriends->IsFollowing(*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) {
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_EnumerateFollowingList(ISteamFriends* lpSteamFriends, uint32_t unStartIndex) {
-	return lpSteamFriends->EnumerateFollowingList(unStartIndex);
+	return new uint64_t(lpSteamFriends->EnumerateFollowingList(unStartIndex));
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_EnumerateFollowingList=_BS_Friends_EnumerateFollowingList@8")

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 <http://www.gnu.org/licenses/>.
 
-#include "dllmain.h"
+#include "BlitzSteam.h"
-#include "SteamworksSDK/public/steam/steam_gameserver.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) {
+DLL_FUNCTION(ISteamGameServer*) BS_GameServer() {
-	return SteamGameServer_Init(unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString);
+#pragma comment(linker, "/EXPORT:BS_GameServer=_BS_GameServer@0")
-}
-
-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() {
 	return SteamGameServer();
 }
 
-DLL_EXPORT ISteamUtils* DLL_CALL BS_GameServerUtils() {
+DLL_FUNCTION(uint32_t) BS_GameServer_Init(uint32_t unIP, uint16_t usSteamPort, uint16_t usGamePort, uint16_t usQueryPort, EServerMode eServerMode, const char *pchVersionString) {
-	return SteamGameServerUtils();
+#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() {
+DLL_FUNCTION(void) BS_GameServer_Shutdown() {
-	return SteamGameServerNetworking();
+#pragma comment(linker, "/EXPORT:BS_GameServer_Shutdown=_BS_GameServer_Shutdown@0")
+	SteamGameServer_Shutdown();
 }
 
-DLL_EXPORT ISteamGameServerStats* DLL_CALL BS_GameServerStats() {
+DLL_FUNCTION(void) BS_GameServer_RunCallbacks() {
-	return SteamGameServerStats();
+#pragma comment(linker, "/EXPORT:BS_GameServer_RunCallbacks=_BS_GameServer_RunCallbacks@0")
+	SteamGameServer_RunCallbacks();
 }
 
-DLL_EXPORT ISteamHTTP* DLL_CALL BS_GameServerHTTP() {
+DLL_FUNCTION(HSteamPipe) BS_GameServer_GetHSteamPipe() {
-	return SteamGameServerHTTP();
+#pragma comment(linker, "/EXPORT:BS_GameServer_GetHSteamPipe=_BS_GameServer_GetHSteamPipe@0")
+	return SteamGameServer_GetHSteamPipe();
 }
 
-DLL_EXPORT ISteamInventory* DLL_CALL BS_GameServerInventory() {
+DLL_FUNCTION(uint32_t) BS_GameServer_IsSecureC() {
-	return SteamGameServerInventory();
+#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));
 }

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 <http://www.gnu.org/licenses/>.
+
+#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);
+}
+

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 <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamHTMLSurface*) BS_HTMLSurface() {
+	return SteamHTMLSurface();
+}
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface=_BS_HTMLSurface@0")
+

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 <http://www.gnu.org/licenses/>.
+
+#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();
+}
+

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 <http://www.gnu.org/licenses/>.
+
+#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();
+}
+

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 <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamMatchmaking*) BS_Matchmaking() {
+	return SteamMatchmaking();
+}
+#pragma comment(linker, "/EXPORT:BS_Matchmaking=_BS_Matchmaking@0")
+

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 <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamMatchmakingServers*) BS_MatchmakingServers() {
+	return SteamMatchmakingServers();
+}
+#pragma comment(linker, "/EXPORT:BS_MatchmakingServers=_BS_MatchmakingServers@0")
+

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 <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamMusic*) BS_Music() {
+	return SteamMusic();
+}
+#pragma comment(linker, "/EXPORT:BS_Music=_BS_Music@0")
+

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 <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamMusicRemote*) BS_MusicRemote() {
+	return SteamMusicRemote();
+}
+#pragma comment(linker, "/EXPORT:BS_MusicRemote=_BS_MusicRemote@0")
+

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 <http://www.gnu.org/licenses/>.
+
+#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);
+}

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 <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamRemoteStorage*) BS_RemoteStorage() {
+	return SteamRemoteStorage();
+}
+#pragma comment(linker, "/EXPORT:BS_RemoteStorage=_BS_RemoteStorage@0")
+

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 <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamScreenshots*) BS_Screenshots() {
+	return SteamScreenshots();
+}
+#pragma comment(linker, "/EXPORT:BS_Screenshots=_BS_Screenshots@0")
+

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 <http://www.gnu.org/licenses/>.
+
+#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();
+}
+

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 <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamUnifiedMessages*) BS_UnifiedMessages() {
+	return SteamUnifiedMessages();
+}
+#pragma comment(linker, "/EXPORT:BS_UnifiedMessages=_BS_UnifiedMessages@0")
+

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 <http://www.gnu.org/licenses/>.
 
-#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")

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 <http://www.gnu.org/licenses/>.
 
-#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")

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 <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamUtils*) BS_Utils() {
+	return SteamUtils();
+}
+#pragma comment(linker, "/EXPORT:BS_Utils=_BS_Utils@0")
+

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 <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamVideo*) BS_Video() {
+	return SteamVideo();
+}
+#pragma comment(linker, "/EXPORT:BS_Video=_BS_Video@0")
+