* Fix BlitzSteam.h including uneccessary headers.

* Rename Callback class to BlitzCallback and add state-aware functionality (Register, RegisterResult, automatic unregistering).
* Add functionality to delete Long pointers.
* Add functionality to create and delete Doubles.
* Add memory management functionality.
* Reimplement SteamController Wrapper.
* Implement SteamHTMLSurface Wrapper.
* Fix up Declaration File and make it more descriptive.
* Add Blitz Examples and Project.

Blitz/BlitzSteam.decls

@@ -27,8 +27,8 @@ BS_Steam_WriteMiniDumpEx(uStructuredExceptionCode%, pvExceptionInfo%, uBuildID%)
 BS_Steam_RunCallbacks()
 BS_Steam_RegisterCallback(pCallback%, iCallback%)
 BS_Steam_UnregisterCallback(pCallback%)
-BS_Steam_RegisterCallResult(pCallback%, hAPICall_L%, hAPICall_R%)
+BS_Steam_RegisterCallResult(pCallback%, hAPICall%)
-BS_Steam_UnregisterCallResult(pCallback%, hAPICall_L%, hAPICall_R%)
+BS_Steam_UnregisterCallResult(pCallback%, hAPICall%)
 
 ; AppList ---------------------------------------------------------------------
 BS_AppList%()
@@ -37,8 +37,8 @@ BS_AppList_GetInstalledApps%(lpSteamAppList%, pvecAppID*, unMaxIDs%)
 BS_AppList_GetInstalledAppsEx%(lpSteamAppList%, pvecAppID%, unMaxIDs%) : "BS_AppList_GetInstalledApps"
 BS_AppList_GetAppNameEx%(lpSteamAppList%, nAppId%, pchName%, cchNameMax%) : "BS_AppList_GetAppName"
 BS_AppList_GetAppName%(lpSteamAppList%, nAppId%, pchName*, cchNameMax%)
-BS_AppList_GetAppInstallDir%(lpSteamAppList%, nAppId%, pchDirectory*, cchDirectoryMax%)
+BS_AppList_GetAppInstallDir%(lpSteamAppList%, nAppId%, pchDirectoryBuffer*, cchDirectoryMax%)
-BS_AppList_GetAppInstallDirEx%(lpSteamAppList%, nAppId%, pchDirectory%, cchDirectoryMax%) : "BS_AppList_GetAppInstallDir"
+BS_AppList_GetAppInstallDirEx%(lpSteamAppList%, nAppId%, pchDirectoryBuffer%, cchDirectoryMax%) : "BS_AppList_GetAppInstallDir"
 BS_AppList_GetAppBuildId%(lpSteamAppList%, nAppId%)
 
 ; Apps ------------------------------------------------------------------------
@@ -54,23 +54,23 @@ BS_Apps_IsDlcInstalled%(lpSteamApps%, appID%)
 BS_Apps_GetEarliestPurchaseUnixTime%(lpSteamApps%, appID%)
 BS_Apps_IsSubscribedFromFreeWeekend%(lpSteamApps%)
 BS_Apps_GetDLCCount%(lpSteamApps%)
-BS_Apps_GetDLCDataByIndex%(lpSteamApps%, iDLC%, pAppId*, pbAvailable*, pchName*, cchNameBufferSize%)
+BS_Apps_GetDLCDataByIndex%(lpSteamApps%, iDLC%, pAppIdBuffer*, pbAvailableBuffer*, pchNameBuffer*, cchNameBufferSize%)
-BS_Apps_GetDLCDataByIndexEx%(lpSteamApps%, iDLC%, pAppId%, pbAvailable%, pchName%, cchNameBufferSize%) : "BS_Apps_GetDLCDataByIndex"
+BS_Apps_GetDLCDataByIndexEx%(lpSteamApps%, iDLC%, pAppIdBuffer%, pbAvailableBuffer%, pchNameBuffer%, cchNameBufferSize%) : "BS_Apps_GetDLCDataByIndex"
 BS_Apps_InstallDLC(lpSteamApps%, nAppID%)
 BS_Apps_UninstallDLC(lpSteamApps%, nAppID%)
 BS_Apps_RequestAppProofOfPurchaseKey(lpSteamApps%, nAppID%)
-BS_Apps_GetCurrentBetaName%(lpSteamApps%, pchName*, cchNameBufferSize%)
+BS_Apps_GetCurrentBetaName%(lpSteamApps%, pchNameBuffer*, cchNameBufferSize%)
-BS_Apps_GetCurrentBetaNameEx%(lpSteamApps%, pchName%, cchNameBufferSize%) : "BS_Apps_GetCurrentBetaName"
+BS_Apps_GetCurrentBetaNameEx%(lpSteamApps%, pchNameBuffer%, cchNameBufferSize%) : "BS_Apps_GetCurrentBetaName"
 BS_Apps_MarkContentCorrupt%(lpSteamApps%, bMissingFilesOnly%)
-BS_Apps_GetInstalledDepots%(lpSteamApps%, nAppID%, pvecDepots*, cMaxDepots%)
+BS_Apps_GetInstalledDepots%(lpSteamApps%, nAppID%, pDepotsBuffer*, cMaxDepots%)
-BS_Apps_GetInstalledDepotsEx%(lpSteamApps%, nAppID%, pvecDepots%, cMaxDepots%) : "BS_Apps_GetInstalledDepots"
+BS_Apps_GetInstalledDepotsEx%(lpSteamApps%, nAppID%, pDepotsBuffer%, cMaxDepots%) : "BS_Apps_GetInstalledDepots"
-BS_Apps_GetAppInstallDir%(lpSteamApps%, nAppID%, pchFolder*, cchFolderBufferSize%)
+BS_Apps_GetAppInstallDir%(lpSteamApps%, nAppID%, pchFolderBuffer*, cchFolderBufferSize%)
-BS_Apps_GetAppInstallDirEx%(lpSteamApps%, nAppID%, pchFolder%, cchFolderBufferSize%) : "BS_Apps_GetAppInstallDir"
+BS_Apps_GetAppInstallDirEx%(lpSteamApps%, nAppID%, pchFolderBuffer%, cchFolderBufferSize%) : "BS_Apps_GetAppInstallDir"
 BS_Apps_IsAppInstalled%(lpSteamApps%, nAppID%)
 BS_Apps_GetAppOwner%(lpSteamApps%)
 BS_Apps_GetLaunchQueryParam$(lpSteamApps%, pchKey$)
-BS_Apps_GetDlcDownloadProgress%(lpSteamApps%, nAppID%, punBytesDownloaded*, punBytesTotal*)
+BS_Apps_GetDlcDownloadProgress%(lpSteamApps%, nAppID%, pLLBytesDownloaded*, pLLBytesTotal*)
-BS_Apps_GetDlcDownloadProgressEx%(lpSteamApps%, nAppID%, punBytesDownloaded%, punBytesTotal%) : "BS_Apps_GetDlcDownloadProgress"
+BS_Apps_GetDlcDownloadProgressEx%(lpSteamApps%, nAppID%, pLLBytesDownloaded%, pLLBytesTotal%) : "BS_Apps_GetDlcDownloadProgress"
 BS_Apps_GetAppBuildId%(lpSteamApps%)
 
 ; Client ----------------------------------------------------------------------
@@ -116,18 +116,40 @@ BS_Controller%()
 BS_Controller_Init%(lpSteamController%, pchAbsolutePathToControllerConfigVDF$)
 BS_Controller_Shutdown%(lpSteamController%)
 BS_Controller_RunFrame(lpSteamController%)
-BS_Controller_GetControllerStateEx%(lpSteamController%, unControllerIndex%, pState%) : "BS_Controller_GetControllerState"
+BS_Controller_GetConnectedControllersEx%(lpSteamController%, pHandlesOut*)
-BS_Controller_GetControllerState%(lpSteamController%, unControllerIndex%, pState*)
+BS_Controller_GetConnectedControllersExEx%(lpSteamController%, pHandlesOut%) : "BS_Controller_GetConnectedControllersEx"
-BS_Controller_TriggerHapticPulse(lpSteamController%, unControllerIndex%, eTargetPad%, usDurationMicroSec%)
+BS_Controller_GetConnectedControllers%(lpSteamController%)
-BS_Controller_SetOverrideMode(lpSteamController%, pchMode$)
+BS_Controller_GetConnectedControllers_Index%(index%)
+BS_Controller_ShowBindingPanel%(lpSteamController%, pControllerHandle%)
+BS_Controller_GetActionSetHandle%(lpSteamController%, pszActionSetName$)
+;! Function above returns a ControllerActionSetHandle_t*, clean it up afterwards!
+BS_Controller_ActivateActionSet(lpSteamController%, pControllerHandle%, pActionSetHandle%)
+BS_Controller_GetCurrentActionSet%(lpSteamController%, )
+;! Function above returns a ControllerActionSetHandle_t*, clean it up afterwards!
+BS_Controller_GetDigitalActionHandle%(lpSteamController%, pszActionName$)
+;! Function above returns a ControllerDigitalActionHandle_t*, clean it up afterwards!
+BS_Controller_GetDigitalActionData%(lpSteamController%, pControllerHandle%, pDigitalActionHandle%)
+;! Function above returns a ControllerDigitalActionData_t*, clean it up afterwards?
+BS_Controller_GetDigitalActionOrigins%(lpSteamController%, pControllerHandle%, pActionSetHandle%, pDigitalActionHandle%, pEControllerActionOrigin*)
+BS_Controller_GetDigitalActionOriginsEx%(lpSteamController%, pControllerHandle%, pActionSetHandle%, pDigitalActionHandle%, pEControllerActionOrigin%) : "BS_Controller_GetDigitalActionOrigins"
+BS_Controller_GetAnalogActionHandle%(lpSteamController%, pszActionName$)
+;! Function above returns a ControllerAnalogActionHandle_t*, clean it up afterwards!
+BS_Controller_GetAnalogActionData%(lpSteamController%, pControllerHandle%, pAnalogActionHandle%)
+;! Function above returns a ControllerAnalogActionData_t*, clean it up afterwards?
+BS_Controller_GetAnalogActionOrigins%(lpSteamController%, pControllerHandle%, pActionSetHandle%, pAnalogActionHandle%, pEControllerActionOrigin*)
+BS_Controller_GetAnalogActionOriginsEx%(lpSteamController%, pControllerHandle%, pActionSetHandle%, pAnalogActionHandle%, pEControllerActionOrigin*) : "BS_Controller_GetAnalogActionOrigins"
+BS_Controller_StopAnalogActionMomentum(lpSteamController%, pControllerHandle%, pAnalogActionHandle%)
+BS_Controller_TriggerHapticPulse(lpSteamController%, pControllerHandle%, ESteamControllerPad%, usDurationMicroSec%)
 
 ; Friends ---------------------------------------------------------------------
 BS_Friends%()
 BS_Friends_GetPersonaName$(lpSteamFriends%)
 BS_Friends_SetPersonaName%(lpSteamFriends%, pchPersonaName$)
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
 BS_Friends_GetPersonaState%(lpSteamFriends%)
 BS_Friends_GetFriendCount%(lpSteamFriends%, iFriendFlags%)
 BS_Friends_GetFriendByIndex%(lpSteamFriends%, iFriend%, iFriendFlags%)
+;! Function above returns a CSteamID*, clean it up afterwards!
 BS_Friends_GetFriendRelationship%(lpSteamFriends%, steamIDFriend%)
 BS_Friends_GetFriendPersonaState%(lpSteamFriends%, steamIDFriend%)
 BS_Friends_GetFriendPersonaName$(lpSteamFriends%, steamIDFriend%)
@@ -168,6 +190,7 @@ BS_Friends_RequestClanOfficerList%(lpSteamFriends%, steamIDClan%)
 BS_Friends_GetClanOwner%(lpSteamFriends%, steamIDClan%)
 BS_Friends_GetClanOfficerCount%(lpSteamFriends%, steamIDClan%)
 BS_Friends_GetClanOfficerByIndex%(lpSteamFriends%, steamIDClan%, iOfficer%)
+;! Function above returns a CSteamID*, clean it up afterwards!
 BS_Friends_GetUserRestrictions%(lpSteamFriends%)
 BS_Friends_SetRichPresence%(lpSteamFriends%, pchKey$, pchValue$)
 BS_Friends_ClearRichPresence(lpSteamFriends%)
@@ -178,12 +201,15 @@ BS_Friends_RequestFriendRichPresence(lpSteamFriends%, steamIDFriend%)
 BS_Friends_InviteUserToGame%(lpSteamFriends%, steamIDFriend%, pchConnectString%)
 BS_Friends_GetCoplayFriendCount%(lpSteamFriends%)
 BS_Friends_GetCoplayFriend%(lpSteamFriends%, iCoplayFriend%)
+;! Function above returns a CSteamID*, clean it up afterwards!
 BS_Friends_GetFriendCoplayTime%(lpSteamFriends%, steamIDFriend%)
 BS_Friends_GetFriendCoplayGame%(lpSteamFriends%, steamIDFriend%)
 BS_Friends_JoinClanChatRoom%(lpSteamFriends%, steamIDClan%)
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
 BS_Friends_LeaveClanChatRoom%(lpSteamFriends%, steamIDClan%)
 BS_Friends_GetClanChatMemberCount%(lpSteamFriends%, steamIDClan%)
 BS_Friends_GetChatMemberByIndex%(lpSteamFriends%, steamIDClan%, iUser%)
+;! Function above returns a CSteamID*, clean it up afterwards!
 BS_Friends_SendClanChatMessage%(lpSteamFriends%, steamIDClanChat%, pchText$)
 BS_Friends_GetClanChatMessage%(lpSteamFriends%, steamIDClanChat%, iMessage%, prgchText*, cchTextMax%, peChatEntryType*, psteamidChatter*)
 BS_Friends_GetClanChatMessageEx%(lpSteamFriends%, steamIDClanChat%, iMessage%, prgchText%, cchTextMax%, peChatEntryType%, psteamidChatter%) : "BS_Friends_GetClanChatMessage"
@@ -196,17 +222,21 @@ BS_Friends_ReplyToFriendMessage%(lpSteamFriends%, steamIDFriend%, pchMsgToSend$)
 BS_Friends_GetFriendMessage%(lpSteamFriends%, steamIDFriend%, iMessageID%, pvData*, cubData%, peChatEntryType*)
 BS_Friends_GetFriendMessageEx%(lpSteamFriends%, steamIDFriend%, iMessageID%, pvData%, cubData%, peChatEntryType%) : "BS_Friends_GetFriendMessage"
 BS_Friends_GetFollowerCount%(lpSteamFriends%, steamID%)
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
 BS_Friends_IsFollowing%(lpSteamFriends%, steamID%)
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
 BS_Friends_EnumerateFollowingList%(lpSteamFriends%, unStartIndex%)
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
 
 ; GameServer ------------------------------------------------------------------
+BS_SteamGameServer_Init%(unIP%, usSteamPort%, usGamePort%, usQueryPort%, eServerMode%, pchVersionString$)
+BS_SteamGameServer_Shutdown()
+BS_SteamGameServer_RunCallbacks()
+BS_SteamGameServer_GetHSteamPipe%()
+BS_SteamGameServer_IsSecure%()
+BS_SteamGameServer_GetSteamID%()
+;! Function above returns a CSteamID*, clean it up afterwards!
 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$)
@@ -234,6 +264,7 @@ 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%)
+;! Function above returns a CSteamID*, clean it up afterwards!
 BS_GameServer_SendUserDisconnect(pSteamGameServer%, pSteamIDUser%)
 BS_GameServer_UpdateUserData%(pSteamGameServer%, pSteamIDUser%, pchPlayerName$, uScore%)
 BS_GameServer_GetAuthSessionTicket%(pSteamGameServer%, pTicket*, cbMaxTicket%, pcbTicket%)
@@ -246,6 +277,7 @@ BS_GameServer_UserHasLicenseForApp%(pSteamGameServer%, pSteamID%, appID%)
 BS_GameServer_RequestUserGroupStatus%(pSteamGameServer%, pSteamIDUser%, pSteamIDGroup%)
 BS_GameServer_GetGameplayStats(pSteamGameServer%)
 BS_GameServer_GetServerReputation%(pSteamGameServer%)
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
 BS_GameServer_GetPublicIP%(pSteamGameServer%)
 BS_GameServer_HandleIncomingPacket%(pSteamGameServer%, pData*, cbData%, srvIP%, srvPort%)
 BS_GameServer_HandleIncomingPacketEx%(pSteamGameServer%, pData%, cbData%, srvIP%, srvPort%) : "BS_GameServer_HandleIncomingPacket"
@@ -255,12 +287,16 @@ BS_GameServer_EnableHeartbeats(pSteamGameServer%, bActive%)
 BS_GameServer_SetHeartbeatInterval(pSteamGameServer%, iHeartbeatInterval%)
 BS_GameServer_ForceHeartbeat(pSteamGameServer%)
 BS_GameServer_AssociateWithClan%(pSteamGameServer%, pSteamIDClan%)
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
 BS_GameServer_ComputeNewPlayerCompatibility%(pSteamGameServer%, pSteamIDNewPlayer%)
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
 
 ; GameServerStats -------------------------------------------------------------
 BS_GameServerStats%()
 BS_GameServerStats_RequestUserStats%(pSteamGameServerStats%, steamIDUser%)
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
 BS_GameServerStats_StoreUserStats%(pSteamGameServerStats%, steamIDUser%)
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
 BS_GameServerStats_GetUserStat%(pSteamGameServerStats%, steamIDUser%, pchName$, pData*)
 BS_GameServerStats_GetUserStatEx%(pSteamGameServerStats%, steamIDUser%, pchName$, pData%) : "BS_GameServerStats_GetUserStat"
 BS_GameServerStats_GetUserStatF%(pSteamGameServerStats%, steamIDUser%, pchName$, pData*)
@@ -270,9 +306,49 @@ BS_GameServerStats_GetUserAchievementEx%(pSteamGameServerStats%, steamIDUser%, p
 BS_GameServerStats_SetUserStat%(pSteamGameServerStats%, steamIDUser%, pchName%, nData%)
 BS_GameServerStats_SetUserStatF%(pSteamGameServerStats%, steamIDUser%, pchName%, fData#)
 BS_GameServerStats_UpdateUserAvgRateStat%(pSteamGameServerStats%, steamIDUser%, pchName$, flCountThisSession#, pdSessionLength%)
+;! Function above takes a Double* as last parameter.
 BS_GameServerStats_SetUserAchievement%(pSteamGameServerStats%, steamIDUser%, pchName$)
 BS_GameServerStats_ClearUserAchievement%(pSteamGameServerStats%, steamIDUser%, pchName$)
 
+; HTMLSurface -----------------------------------------------------------------
+BS_HTMLSurface%()
+BS_HTMLSurface_Init%(pSteamHTMLSurface%)
+BS_HTMLSurface_Shutdown%(pSteamHTMLSurface%)
+BS_HTMLSurface_CreateBrowser%(pSteamHTMLSurface%, pchUserAgent$, pchUserCSS$)
+;! Function above returns a SteamAPICall_t*, clean it up afterwards!
+BS_HTMLSurface_RemoveBrowser(pSteamHTMLSurface%, unBrowserHandle%)
+BS_HTMLSurface_LoadURL(pSteamHTMLSurface%, unBrowserHandle%, pchURL$, pchPostData$)
+BS_HTMLSurface_SetSize(pSteamHTMLSurface%, unBrowserHandle%, unWidth%, unHeight%)
+BS_HTMLSurface_StopLoad(pSteamHTMLSurface%, unBrowserHandle%)
+BS_HTMLSurface_Reload(pSteamHTMLSurface%, unBrowserHandle%)
+BS_HTMLSurface_GoBack(pSteamHTMLSurface%, unBrowserHandle%)
+BS_HTMLSurface_GoForward(pSteamHTMLSurface%, unBrowserHandle%)
+BS_HTMLSurface_AddHeader(pSteamHTMLSurface%, unBrowserHandle%, pchKey$, pchValue$)
+BS_HTMLSurface_ExecuteJavascript(pSteamHTMLSurface%, unBrowserHandle%, pchScript$)
+BS_HTMLSurface_MouseUp(pSteamHTMLSurface%, unBrowserHandle%, EMouseButton%)
+BS_HTMLSurface_MouseDown(pSteamHTMLSurface%, unBrowserHandle%, EMouseButton%)
+BS_HTMLSurface_MouseDoubleClick(pSteamHTMLSurface%, unBrowserHandle%, EMouseButton%)
+BS_HTMLSurface_MouseMove(pSteamHTMLSurface%, unBrowserHandle%, X%, Y%)
+BS_HTMLSurface_MouseWheel(pSteamHTMLSurface%, unBrowserHandle%, nDelta%)
+BS_HTMLSurface_KeyDown(pSteamHTMLSurface%, unBrowserHandle%, nNativeKeyCode%, EHTMLKeyModifiers%)
+BS_HTMLSurface_KeyUp(pSteamHTMLSurface%, unBrowserHandle%, nNativeKeyCode%, EHTMLKeyModifiers%)
+BS_HTMLSurface_KeyChar(pSteamHTMLSurface%, unBrowserHandle%, cUnicodeChar%, EHTMLKeyModifiers%)
+BS_HTMLSurface_SetHorizontalScroll(pSteamHTMLSurface%, unBrowserHandle%, nAbsolutePixelScroll%)
+BS_HTMLSurface_SetVerticalScroll(pSteamHTMLSurface%, unBrowserHandle%, nAbsolutePixelScroll%)
+BS_HTMLSurface_SetKeyFocus(pSteamHTMLSurface%, unBrowserHandle%, bHasKeyFocus%)
+BS_HTMLSurface_ViewSource(pSteamHTMLSurface%, unBrowserHandle%)
+BS_HTMLSurface_CopyToClipboard(pSteamHTMLSurface%, unBrowserHandle%)
+BS_HTMLSurface_PasteFromClipboard(pSteamHTMLSurface%, unBrowserHandle%)
+BS_HTMLSurface_Find(pSteamHTMLSurface%, unBrowserHandle%, pchSearchStr$, bCurrentlyInFind%, bReverse%)
+BS_HTMLSurface_StopFind(pSteamHTMLSurface%, unBrowserHandle%)
+BS_HTMLSurface_GetLinkAtPosition(pSteamHTMLSurface%, unBrowserHandle%, X%, Y%)
+BS_HTMLSurface_SetCookie(pSteamHTMLSurface%, unBrowserHandle%, pchHostname$, pchKey$, pchValue$, pchPath$, nExpires%, bSecure%, bHTTPOnly%)
+BS_HTMLSurface_SetPageScaleFactor(pSteamHTMLSurface%, unBrowserHandle%, flZoom#, nPointX%, nPointY%)
+BS_HTMLSurface_SetBackgroundMode(pSteamHTMLSurface%, unBrowserHandle%, bBackgroundMode%)
+BS_HTMLSurface_AllowStartRequest(pSteamHTMLSurface%, unBrowserHandle%, bAllowed%)
+BS_HTMLSurface_JSDialogResponse(pSteamHTMLSurface%, unBrowserHandle%, bResult%)
+BS_HTMLSurface_FileLoadDialogResponse(pSteamHTMLSurface%, unBrowserHandle%, pchSelectedFiles%)
+
 ; Networking ------------------------------------------------------------------
 BS_Networking%()
 BS_GameServerNetworking%()
@@ -383,8 +459,30 @@ BS_UserStats_GetGlobalStatHistoryLLEx%(lpSteamUserStats, pchStatName$, pData%, c
 BS_UserStats_GetGlobalStatHistoryD%(lpSteamUserStats, pchStatName$, pData*, cubData%)
 BS_UserStats_GetGlobalStatHistoryDEx%(lpSteamUserStats, pchStatName$, pData%, cubData%) : "BS_UserStats_GetGlobalStatHistoryD"
 
+; -- Interfaces
+BS_HTTP%()
+BS_GameServerHTTP%()
+BS_Inventory%()
+BS_GameServerInventory%()
+BS_Matchmaking%()
+BS_MatchmakingServers%()
+BS_Music%()
+BS_MusicRemote%()
+BS_RemoteStorage%()
+BS_Screenshots%()
+BS_UGC%()
+BS_GameServerUGC%()
+BS_UnifiedMessages%()
+BS_Utils%()
+BS_GameServerUtils%()
+BS_Video%()
+
 ; Helpers ---------------------------------------------------------------------
+; -- Generic
 BS_Helper_FormatUnixTime$(unixTime%, pchFormat$)
+BS_Helper_DeleteLong(longlong%)
+BS_Helper_CreateDouble%(value#)
+BS_Helper_DeleteDouble(pDouble%)
 ; -- CSteamID
 BS_CSteamID_New%()
 BS_CSteamID_FromID%(unAccountID%, eUniverse%, eAccountType%)
@@ -425,21 +523,24 @@ BS_CSteamID_SetEUniverse(pSteamID%, eUniverse%)
 BS_CSteamID_IsValid%(pSteamID%)
 BS_CSteamID_Compare%(pSteamID%, pSteamIDOther%)
 ; -- Callbacks
-BS_Callback_Create%(pFunction%)
+BS_Callback_Create%(pFunctionPointer%)
 BS_Callback_Destroy%(pCallback%)
-
+BS_Callback_IsRegistered%(pCallback%)
-
+BS_Callback_IsGameServer%(pCallback%)
-; -- Interfaces
+BS_Callback_SetGameServerFlag%(pCallback%, bIsGameServer%)
-BS_HTTP%()
+BS_Callback_Register(pCallback%, iCallback%)
-BS_HTMLSurface%()
+BS_Callback_Unregister(pCallback%)
-BS_Inventory%()
+BS_Callback_RegisterResult(pCallback%, pSteamAPICall%)
-BS_Matchmaking%()
+BS_Callback_UnregisterResult(pCallback%)
-BS_MatchmakingServers%()
+; -- Memory
-BS_Music%()
+BS_Memory_Alloc%(iSize%)
-BS_MusicRemote%()
+BS_Memory_ReAlloc%(pMemory%, iSize%)
-BS_RemoteStorage%()
+BS_Memory_Free(pMemory%)
-BS_Screenshots%()
+BS_Memory_PeekByte%(pMemory%, offset%)
-BS_UGC%()
+BS_Memory_PeekShort%(pMemory%, offset%)
-BS_UnifiedMessages%()
+BS_Memory_PeekInt%(pMemory%, offset%)
-BS_Utils%()
+BS_Memory_PeekFloat#(pMemory%, offset%)
-BS_Video%()
+BS_Memory_PokeByte(pMemory%, offset%, value%)
+BS_Memory_PokeShort(pMemory%, offset%, value%)
+BS_Memory_PokeInt(pMemory%, offset%, value%)
+BS_Memory_PokeFloat(pMemory%, offset%, value#)

Blitz/BlitzSteam.ipf

@@ -0,0 +1,17 @@
+[IDEal Project file]
+<Settings>
+ Version="1"
+ Expanded="True"
+ Icon=""
+ MainFile="HTMLSurface_Example.bb"
+ Compiler="Blitz3D"
+ CommandLine=""
+</Settings>
+<Folders>
+ AbsPath="\Examples" Expanded="True"
+</Folders>
+<Files>
+ AbsPath="\BlitzSteam.bb" PrjFolder="" Line="0" Column="0" Tip="0" Visible="False"
+ AbsPath="\BlitzSteamUtility.bb" PrjFolder="" Line="0" Column="0" Tip="0" Visible="False"
+ AbsPath="\HTMLSurface_Example.bb" PrjFolder="\Examples" Line="0" Column="0" Tip="0" Visible="False"
+</Files>

Blitz/BlitzSteamUtility.bb

@@ -14,130 +14,61 @@
 ;	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/>.
 
-;----------------------------------------------------------------
+;------------------------------------------------------------------------------
-; -- Constants
+;! Constants
-;----------------------------------------------------------------
+;------------------------------------------------------------------------------
 Const BSU_NAME_LENGTH					= 4096
 Const BSU_INSTALLDIR_LENGTH				= 4096
 Const BSU_APPID_COUNT					= 4096
 Const BSU_INSTALLEDDEPOTS_COUNT			= 4096
 
-;----------------------------------------------------------------
+;------------------------------------------------------------------------------
-; -- Globals
+;! Globals
-;----------------------------------------------------------------
+;------------------------------------------------------------------------------
 Global BSU_Initialized = False
 Global BSU_IsSteamRunning% = False
 ; -- Interfaces
-Global BSU_AppList%, BSU_Apps%, BSU_Client%, BSU_Controller%
+Global BSU_AppList%
-Global BSU_Friends%, BSU_HTTP%, BSU_HTMLSurface%, BSU_Inventory%
+Global BSU_Apps%
-Global BSU_Matchmaking%, BSU_MatchmakingServers%, BSU_Music%
+Global BSU_Client%
-Global BSU_MusicRemote%, BSU_Networking%, BSU_RemoteStorage%
+Global BSU_Controller%
-Global BSU_Screenshots%, BSU_UGC%, BSU_UnifiedMessages%, BSU_User%
+Global BSU_Friends%
-Global BSU_UserStats%, BSU_Utils%, BSU_Video%
+Global BSU_GameServer%
+Global BSU_GameServerStats%
+Global BSU_HTMLSurface%
+Global BSU_HTTP%
+Global BSU_Inventory%
+Global BSU_Matchmaking%
+Global BSU_MatchmakingServers%
+Global BSU_Music%
+Global BSU_MusicRemote%
+Global BSU_Networking%
+Global BSU_RemoteStorage%
+Global BSU_Screenshots%
+Global BSU_UGC%
+Global BSU_UnifiedMessages%
+Global BSU_User%
+Global BSU_UserStats%
+Global BSU_Utils%
+Global BSU_Video%
 
-;----------------------------------------------------------------
+;[Block] API: Steam
-; -- Types
+;------------------------------------------------------------------------------
-;----------------------------------------------------------------
+;! API: Steam
-Type BSU_App
+;------------------------------------------------------------------------------
-	Field AppId%
-	Field Name$
-	Field InstallDir$
-End Type
-
-Type BSU_DLC
-	Field AppId%
-	Field Available%
-	Field Name$
-End Type
-
-Type BSU_Depot
-	Field DepotId%
-End Type
-
-Type BSU_Friend
-	Field SteamID_L, SteamID_R
-	
-	Field Name$
-	Field NickName$
-	
-	Field Index%
-	Field Relationship%
-	Field State%
-	Field SteamLevel%
-End Type
-
-;----------------------------------------------------------------
-; -- Globals
-;----------------------------------------------------------------
-Global BSU_AppCount
-Global BSU_DLCCount
-Global BSU_DepotCount
-Global BSU_FriendCount
-
-;----------------------------------------------------------------
-; -- Functions
-;----------------------------------------------------------------
-; -- Utility
-; Writes a C-String value to a Bank.
-; Returns amount of bytes written.
-Function BSU_PokeCString%(Bank%, Pos%, Value$)
-	If Bank Then
-		Local BankSz = BankSize(Bank)
-		
-		If Pos < 0 Then Pos = 0
-		If Pos >= BankSz Then Pos = BankSz - 1
-		
-		Local ValuePos, ValueLen = Len(Value)
-		For ValuePos = 1 To ValueLen
-			; Don't write over the edge, we still need space for the 0-byte
-			If (Pos + ValuePos) >= (BankSz - 1) Then Exit
-			
-			PokeByte Bank, Pos + ValuePos, Asc(Mid(Value, ValuePos, 1))
-		Next
-		PokeByte Bank, Pos + ValuePos, 0
-		Return ValuePos
-	EndIf
-End Function
-
-; Reads a C-String value from a Bank.
-; Returns read C-String
-Function BSU_PeekCString$(Bank%, Pos%, Len%=-1)
-	If Bank Then
-		Local BankSz = BankSize(Bank)
-		
-		If Pos < 0 Then Pos = 0
-		If Pos >= BankSz Then Pos = BankSz - 1
-		
-		Local OutStr$, OutLen = (BankSz - Pos)
-		Local BankPos
-		For BankPos = 0 To OutLen
-			If (Pos + BankPos) >= BankSz Then Exit
-			
-			Local Value = PeekByte(Bank, Pos + BankPos)
-			
-			If (Value = 0 And Len = -1) Or (Pos > Len) Then
-				Exit
-			Else
-				OutStr=OutStr+Chr(Value)
-			EndIf
-		Next
-		Return OutStr
-	EndIf
-End Function
-
-; -- Steam
 Function BSU_Init()
 	BSU_IsSteamRunning = BS_Steam_IsSteamRunning()
-	If BSU_IsSteamRunning Then
+	If BSU_IsSteamRunning And BS_Steam_Init() Then
-		BS_Steam_Init()
 		
 		BSU_AppList				= BS_AppList()
 		BSU_Apps				= BS_Apps()
 		BSU_Client				= BS_Client()
 		BSU_Controller			= BS_Controller()
 		BSU_Friends				= BS_Friends()
-		BSU_HTTP				= BS_HTTP()
+		BSU_GameServer			= BS_GameServer()
+		BSU_GameServerStats		= BS_GameServerStats()
 		BSU_HTMLSurface			= BS_HTMLSurface()
+		BSU_HTTP				= BS_HTTP()
 		BSU_Inventory			= BS_Inventory()
 		BSU_Matchmaking			= BS_Matchmaking()
 		BSU_MatchmakingServers	= BS_MatchmakingServers()
@@ -159,15 +90,18 @@ End Function
 
 Function BSU_Shutdown()
 	If BSU_IsSteamRunning
+		BS_GameServer_Shutdown()
 		BS_Steam_Shutdown()
+		
 		BSU_AppList=0
 		BSU_Apps=0
 		BSU_Client=0
 		BSU_Controller=0
 		BSU_Friends=0
+		BSU_GameServer=0
+		BSU_GameServerStats=0
 		BSU_HTTP=0
 		BSU_HTMLSurface=0
-		BSU_Initialized=0
 		BSU_Matchmaking=0
 		BSU_MatchmakingServers=0
 		BSU_Music=0
@@ -185,8 +119,19 @@ Function BSU_Shutdown()
 		BSU_Initialized = False
 	EndIf
 End Function
+;[End Block]
+
+;[Block] API: AppList
+;------------------------------------------------------------------------------
+;! API: AppList
+;------------------------------------------------------------------------------
+Type BSU_App
+	Field AppId%
+	Field Name$
+	Field InstallDir$
+End Type
+Global BSU_AppCount = 0
 
-; -- AppList
 Function BSU_AppList_GetInstalledApps(BankAppIdsStorage=0, BankAppNameStorage=0, BankAppInstallDirStorage=0)
 	Local BankAppIds, BankAppIdsSz = BSU_APPID_COUNT
 	Local BankAppName, BankAppNameSz = BSU_NAME_LENGTH
@@ -240,11 +185,11 @@ Function BSU_AppList_GetInstalledApps(BankAppIdsStorage=0, BankAppNameStorage=0,
 			
 			; Free temporary storage for name and installdir.
 			If BankAppInstallDirStorage = 0 Then FreeBank BankAppInstallDir
-			If BankAppNameStorage = 0 FreeBank BankAppName
+			If BankAppNameStorage = 0 Then FreeBank BankAppName
 		EndIf
 			
 		; Free temporary storage for AppIds.
-		If BankAppIdsStorage = 0 FreeBank BankAppIds
+		If BankAppIdsStorage = 0 Then FreeBank BankAppIds
 	EndIf
 End Function
 
@@ -303,8 +248,24 @@ Function BSU_AppList_GetInstallDir$(AppID%, BankStorage=0)
 	; Return name read.
 	Return AppInstallDir
 End Function
+;[End Block]
+
+;[Block] API: Apps
+;------------------------------------------------------------------------------
+;! API: Apps
+;------------------------------------------------------------------------------
+Type BSU_DLC
+	Field AppId%
+	Field Available%
+	Field Name$
+End Type
+Global BSU_DLCCount
+
+Type BSU_Depot
+	Field DepotId%
+End Type
+Global BSU_DepotCount
 
-; -- SteamApps
 Function BSU_Apps_GetDLCData(BankAppIdStorage=0, BankAvailableStorage=0, BankNameStorage=0)
 	Local BankAppId%, BankAvailable%
 	Local BankName%, BankNameSz% = BSU_NAME_LENGTH
@@ -516,9 +477,26 @@ Function BSU_Apps_GetDLCDownloadProgress#(nAppID%)
 	EndIf
 	Return Progress
 End Function
+;[End Block]
 
-; -- SteamFriends
+;[Block] API: Apps
-Function BSU_Friends_GetFriends(iFriendFlags=BS_EFriendFlags_All)
+;------------------------------------------------------------------------------
+;! API: Friends
+;------------------------------------------------------------------------------
+Type BSU_Friend
+	Field SteamID_L, SteamID_R
+	
+	Field Name$
+	Field NickName$
+	
+	Field Index%
+	Field Relationship%
+	Field State%
+	Field SteamLevel%
+End Type
+Global BSU_FriendCount
+
+Function BSU_Friends_GetFriends(iFriendFlags = BS_EFriendFlags_All)
 	If BSU_Initialized Then
 		Delete Each BSU_Friend
 		
@@ -551,6 +529,100 @@ Function BSU_Friends_GetFriends(iFriendFlags=BS_EFriendFlags_All)
 	EndIf
 End Function
 
+;[Block] API: GameServer
+;------------------------------------------------------------------------------
+;! API: GameServer
+;------------------------------------------------------------------------------
+Function BSU_GameServer_Init(IPv4%=0, Port%=27015, SteamPort%=27016, QueryPort=27017, ServerMode=BS_EServerMode_AuthenticationAndSecure, Version$="1.0.0.0")
+	If BS_GameServer_Init(IPv4, SteamPort, Port, QueryPort, ServerMode, Version) Then
+		BSU_GameServer = BS_GameServer()
+		BSU_GameServerStats = BS_GameServerStats()
+		BSU_HTTP = BS_GameServerHTTP()
+		BSU_Inventory = BS_GameServerInventory()
+		BSU_Networking = BS_GameServerNetworking()
+		BSU_UGC = BS_GameServerUGC()
+		BSU_Utils = BS_GameServerUtils()
+		
+		BSU_Initialized = True
+	EndIf
+End Function
+
+Function BSU_GameServer_Shutdown()
+	If BSU_Initialized = True
+		BS_GameServer_Shutdown()
+		
+		BSU_GameServer=0
+		BSU_GameServerStats=0
+		BSU_HTTP=0
+		BSU_Inventory=0
+		BSU_Networking=0
+		BSU_UGC=0
+		BSU_Utils=0
+		
+		BSU_Initialized = False
+	EndIf
+End Function
+;[End Block]
+
+;------------------------------------------------------------------------------
+;! API: GameServerStats
+;------------------------------------------------------------------------------
+
+
+
+;[Block] Blitz Stuff
+;----------------------------------------------------------------
+;! Blitz Stuff
+;----------------------------------------------------------------
+; -- Utility
+; Writes a C-String value to a Bank.
+; Returns amount of bytes written.
+Function BSU_PokeCString%(Bank%, Pos%, Value$)
+	If Bank Then
+		Local BankSz = BankSize(Bank)
+		
+		If Pos < 0 Then Pos = 0
+		If Pos >= BankSz Then Pos = BankSz - 1
+		
+		Local ValuePos, ValueLen = Len(Value)
+		For ValuePos = 1 To ValueLen
+			; Don't write over the edge, we still need space for the 0-byte
+			If (Pos + ValuePos) >= (BankSz - 1) Then Exit
+			
+			PokeByte Bank, Pos + ValuePos, Asc(Mid(Value, ValuePos, 1))
+		Next
+		PokeByte Bank, Pos + ValuePos, 0
+		Return ValuePos
+	EndIf
+End Function
+
+; Reads a C-String value from a Bank.
+; Returns read C-String
+Function BSU_PeekCString$(Bank%, Pos%, Len%=-1)
+	If Bank Then
+		Local BankSz = BankSize(Bank)
+		
+		If Pos < 0 Then Pos = 0
+		If Pos >= BankSz Then Pos = BankSz - 1
+		
+		Local OutStr$, OutLen = (BankSz - Pos)
+		Local BankPos
+		For BankPos = 0 To OutLen
+			If (Pos + BankPos) >= BankSz Then Exit
+			
+			Local Value = PeekByte(Bank, Pos + BankPos)
+			
+			If (Value = 0 And Len = -1) Or (Pos > Len) Then
+				Exit
+			Else
+				OutStr=OutStr+Chr(Value)
+			EndIf
+		Next
+		Return OutStr
+	EndIf
+End Function
+;[End Block]
+
 ;~IDEal Editor Parameters:
-;~F#52#67#BD#FA#116#133#163#195#1B1#1D0
+;~F#3A#5A#7F#86#C3#DF#100#107#10C#13C#16E#18A#1A9#1C4
 ;~C#Blitz3D

Blitz/HTMLSurface_Example.bb

@@ -0,0 +1,268 @@
+Include "BlitzSteam.bb"
+
+;----------------------------------------------------------------
+;! Steam Stuff
+;----------------------------------------------------------------
+
+; SteamClient: WarningMessageHook
+Global Steam_WarningMessageHook_Callback = 0
+Function Steam_WarningMessageHook(bIsWarning%, pchMessageBuffer%)
+	If Steam_WarningMessageHook_Callback = 0 Then
+		Steam_WarningMessageHook_Callback = BP_GetFunctionPointer()
+		Return
+	EndIf
+	
+	; Read Message from buffer
+	Local msg$ = ""
+	If bIsWarning = 1 Then
+		msg = "[Warning]"
+	Else
+		msg = "[Info]"
+	EndIf
+	msg = msg + PeekMemoryStringC(pchMessageBuffer)
+	
+	DebugLog "[Steam]" + msg$
+End Function:Steam_WarningMessageHook(0, 0)
+Function PeekMemoryStringC(Memory%, Length%=-1)
+	Local Ptr = Memory
+	Local iChar = 0, tiChar = 0
+	Local sOut$ = ""
+	
+	Repeat
+		tiChar = PeekMemoryByte(Ptr)
+		
+		; Advance memory, decrease Length
+		Ptr = Ptr + 1
+		Length = Length - 1
+		
+		If (tiChar = 0) Then
+			Length = 0
+		Else
+			sOut = sOut + Chr(tiChar)
+		EndIf
+	Until Length = 0
+	
+	Return sOut
+End Function
+
+;----------------------------------------------------------------
+;! Blitz Browser Wrapper (Image based)
+;----------------------------------------------------------------
+Type Browser
+	Field Id%
+	
+	Field ImageHandle%, ImageSize[2]
+	
+	; Internal Steam
+	Field z_llSteamAPICall%
+End Type
+
+Global Browser_HTMLSurface_BrowserReady_p = 0, Browser_HTMLSurface_BrowserReady_c = 0
+Function Browser_HTMLSurface_BrowserReady(pvParam%, bIOFailure, llSteamAPICall)
+	If (Browser_HTMLSurface_BrowserReady_p = 0) Then
+		Browser_HTMLSurface_BrowserReady_p = BP_GetFunctionPointer()
+		Browser_HTMLSurface_BrowserReady_c = BS_Callback_Create(Browser_HTMLSurface_BrowserReady_p)
+		Return 
+	EndIf
+	
+	DebugLog "HTMLSurface_BrowserReady"
+	
+	Local Browser.Browser = Browser_FindBySteamAPICall(llSteamAPICall)
+	Browser\Id = PeekMemoryInt(pvParam)
+	Browser_LoadURL(Browser, "http://google.com/")
+	Browser_SetSize(Browser, Browser\ImageSize[0], Browser\ImageSize[1])
+	
+	; Cleanup
+	BS_Helper_DeleteLong(Browser\z_llSteamAPICall):Browser\z_llSteamAPICall = 0
+	BS_Callback_UnregisterResult Browser_HTMLSurface_BrowserReady_c ; Caller does this too.
+End Function:Browser_HTMLSurface_BrowserReady(0, 0, 0)
+
+Global Browser_HTMLSurface_NeedsPaint_p = 0, Browser_HTMLSurface_NeedsPaint_c = 0
+Function Browser_HTMLSurface_NeedsPaint(pvParam%)
+	If (Browser_HTMLSurface_NeedsPaint_p = 0) Then
+		Browser_HTMLSurface_NeedsPaint_p = BP_GetFunctionPointer()
+		Browser_HTMLSurface_NeedsPaint_c = BS_Callback_Create(Browser_HTMLSurface_NeedsPaint_p)
+		Return 
+	EndIf
+	
+	DebugLog "HTMLSurface_NeedsPaint"
+	
+	Local Browser.Browser = Browser_FindById(PeekMemoryInt(pvParam))
+	
+	; Paint logic
+	;CALLBACK_MEMBER(0, HHTMLBrowser, unBrowserHandle) // the browser that needs the paint
+	;CALLBACK_MEMBER(1, const char *, pBGRA ) // a pointer to the B8G8R8A8 data for this surface, valid until SteamAPI_RunCallbacks is next called
+	;CALLBACK_MEMBER(2, uint32, unWide) // the total width of the pBGRA texture
+	;CALLBACK_MEMBER(3, uint32, unTall) // the total height of the pBGRA texture
+	;CALLBACK_MEMBER(4, uint32, unUpdateX) // the offset in X for the damage rect for this update
+	;CALLBACK_MEMBER(5, uint32, unUpdateY) // the offset in Y for the damage rect for this update
+	;CALLBACK_MEMBER(6, uint32, unUpdateWide) // the width of the damage rect for this update
+	;CALLBACK_MEMBER(7, uint32, unUpdateTall) // the height of the damage rect for this update
+	;CALLBACK_MEMBER(8, uint32, unScrollX) // the page scroll the browser was at when this texture was rendered
+	;CALLBACK_MEMBER(9, uint32, unScrollY) // the page scroll the browser was at when this texture was rendered
+	;CALLBACK_MEMBER(10, float, flPageScale) // the page scale factor on this page when rendered
+	;CALLBACK_MEMBER(11, uint32, unPageSerial) // incremented on each new page load, you can use this to reject draws while navigating to new pages
+	
+End Function:Browser_HTMLSurface_NeedsPaint(0)
+
+Global Browser_HTMLSurface_StartRequest_p = 0, Browser_HTMLSurface_StartRequest_c = 0
+Function Browser_HTMLSurface_StartRequest(pvParam%)
+	If (Browser_HTMLSurface_StartRequest_p = 0) Then
+		Browser_HTMLSurface_StartRequest_p = BP_GetFunctionPointer()
+		Browser_HTMLSurface_StartRequest_c = BS_Callback_Create(Browser_HTMLSurface_StartRequest_p)
+		Return 
+	EndIf
+	
+	DebugLog "HTMLSurface_StartRequest"
+	
+	; Default to allow all requests. (Why not? For an Example, this is good enough.)
+	BS_HTMLSurface_AllowStartRequest BS_HTMLSurface(), PeekMemoryInt(pvParam), True
+End Function:Browser_HTMLSurface_StartRequest(0)
+
+
+Function Browser_Create.Browser(Width%, Height, UserAgent$="BlitzSteam", UserCSS$="")
+	DebugLog "[Browser::Create] Creating with UserAgent '"+UserAgent+"' and CSS '"+UserCSS+"'."
+	
+	; Register Callbacks (Can do this in an Init function too)
+	BS_Callback_Register Browser_HTMLSurface_BrowserReady_c, BS_HTMLSurface_BrowserReady
+	BS_Callback_Register Browser_HTMLSurface_NeedsPaint_c, BS_HTMLSurface_NeedsPaint
+	BS_Callback_Register Browser_HTMLSurface_StartRequest_c, BS_HTMLSurface_StartRequest
+	
+	; Create Browser Object
+	Local Browser.Browser = New Browser
+	Browser\z_llSteamAPICall = BS_HTMLSurface_CreateBrowser(BS_HTMLSurface(), UserAgent, UserCSS)
+	Browser\ImageSize[0] = Width
+	Browser\ImageSize[1] = Height
+	
+	; Register CallResult
+	BS_Callback_RegisterResult Browser_HTMLSurface_BrowserReady_c, Browser\z_llSteamAPICall 
+	
+	Return Browser
+End Function
+
+Function Browser_IsReady(Browser.Browser)
+	If Browser = Null Then Return False
+	
+	DebugLog "[Browser::IsReady] Checking if '"+Browser\Id+"'/'"+Browser\z_llSteamAPICall+"' is ready."
+	
+	Return (Browser\Id <> 0)
+End Function
+
+Function Browser_FindById.Browser(Id%)
+	If Id = 0 Then Return Null ; 0 is not a valid Browser Handle.
+	
+	DebugLog "[Browser::FindById] Finding by Id '"+Id+"."
+	
+	Local Browser.Browser
+	For Browser = Each Browser
+		If Browser\Id = Id Then Return Browser
+	Next
+	
+	Return Null
+End Function
+
+Function Browser_FindBySteamAPICall.Browser(llSteamAPICall%)
+	If llSteamAPICall = 0 Then Return Null ; 0 is not a valid SteamAPICall.
+	
+	DebugLog "[Browser::FindBySteamAPICall] Finding by SteamAPICall '"+llSteamAPICall+"."
+	
+	Local Browser.Browser
+	For Browser = Each Browser
+		If Browser\z_llSteamAPICall = llSteamAPICall Then Return Browser
+	Next
+	
+	Return Null
+End Function
+
+Function Browser_Destroy.Browser(Browser.Browser)
+	If Browser = Null Then Return Null
+	
+	DebugLog "[Browser::Destroy] Destroying '"+Browser\Id+"'."
+	
+	BS_HTMLSurface_RemoveBrowser BS_HTMLSurface(), Browser\Id
+	Delete Browser:Return Null
+End Function
+
+Function Browser_SetSize(Browser.Browser, Width%, Height%)
+	If Browser = Null Then Return
+	
+	DebugLog "[Browser::SetSize] Resizing '"+Browser\Id+"' to "+Width+"x"+Height+"."
+	
+	; Free old Image
+	If (Browser\ImageHandle <> 0) Then
+		FreeImage(Browser\ImageHandle)
+	EndIf
+	
+	; Create new Image
+	Browser\ImageHandle = CreateImage(Width%, Height%)
+	Browser\ImageSize[0] = Width
+	Browser\ImageSize[1] = Height
+	
+	BS_HTMLSurface_SetSize BS_HTMLSurface(), Browser\Id, Width, Height
+End Function
+
+Function Browser_GetHandle(Browser.Browser)
+	Return Browser\ImageHandle
+End Function
+
+Function Browser_LoadURL(Browser.Browser, URL$, PostData$="")
+	If Browser = Null Then Return
+	
+	DebugLog "[Browser::SetSize] Browser '"+Browser\Id+"' is loading URL '"+URL+"'."
+	
+	BS_HTMLSurface_LoadURL BS_HTMLSurface(), Browser\Id, URL, PostData
+End Function
+
+;----------------------------------------------------------------
+;! Example Code
+;----------------------------------------------------------------
+If BS_Steam_Init() = 0 Then RuntimeError "Steam failed to initialize."
+
+; Steam: Hooks, Callbacks, CallResults
+BS_Client_SetWarningMessageHook BS_Client(), Steam_WarningMessageHook_Callback
+
+; Steam: HTMLSurface API
+If BS_HTMLSurface() = 0 Then RuntimeError "Steam: HTMLSurface API is not available."
+If BS_HTMLSurface_Init(BS_HTMLSurface()) = 0 Then RuntimeError "Steam: HTMLSurface API did not want to be initialized?!"
+BS_HTMLSurface_SetSize BS_HTMLSurface(), 0, GraphicsWidth(), GraphicsHeight()
+
+; Scene Setup
+Graphics3D 1024, 768, 32, 2:SetBuffer BackBuffer()
+
+; Create a Browser
+Local myBrowser.Browser = Browser_Create(512, 512)
+
+While Not Browser_IsReady(myBrowser)
+	BS_Steam_RunCallbacks()
+	Delay 100
+Wend
+
+While Not KeyHit(1)
+	Cls
+	
+	; Steam: Run any Callbacks
+	; Q: Why before RenderWorld/Flip?
+	; A: If we did any changes, having them available before Rendering helps responsiveness.
+	;    A one-frame Delay is noticeable, even to people claiming the eye only sees 30 fps.
+	;    Please read a Biology book if you are one of those, it doesn't work like that.
+	BS_Steam_RunCallbacks()
+	
+	RenderWorld
+	
+	DrawImage Browser_GetHandle(myBrowser), 0, 0, 0
+	
+	Flip
+Wend
+
+; Destroy existing Browser
+myBrowser = Browser_Destroy(myBrowser)
+
+; Steam: HTMLSurface API
+BS_HTMLSurface_Shutdown(BS_HTMLSurface())
+
+EndGraphics
+End
+
+;~IDEal Editor Parameters:
+;~F#8#19#3C#50
+;~C#Blitz3D

Blitz/steam_appid.txt

@@ -0,0 +1 @@
+368720

BlitzSteam.h

@@ -32,9 +32,3 @@
 // 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

@@ -135,7 +135,7 @@
       <DebugInformationFormat>None</DebugInformationFormat>
     </ClCompile>
     <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <GenerateDebugInformation>No</GenerateDebugInformation>
       <EnableCOMDATFolding>false</EnableCOMDATFolding>
       <OptimizeReferences>
       </OptimizeReferences>
@@ -155,8 +155,9 @@
   <ItemGroup>
     <ClCompile Include="BlitzSteam.cpp" />
     <ClCompile Include="Helpers\CSteamID.cpp" />
-    <ClCompile Include="Helpers\Callbacks.cpp" />
+    <ClCompile Include="Helpers\BlitzCallback.cpp" />
     <ClCompile Include="Helpers\Helper.cpp" />
+    <ClCompile Include="Helpers\Memory.cpp" />
     <ClCompile Include="Wrapper\Steam.cpp" />
     <ClCompile Include="Wrapper\SteamAppList.cpp" />
     <ClCompile Include="Wrapper\SteamApps.cpp" />
@@ -169,7 +170,7 @@
     <ClCompile Include="Wrapper\SteamHTTP.cpp" />
     <ClCompile Include="Wrapper\SteamInventory.cpp" />
     <ClCompile Include="Wrapper\SteamMatchmaking.cpp" />
-    <ClCompile Include="Wrapper\SteamMatchmakingServer.cpp" />
+    <ClCompile Include="Wrapper\SteamMatchmakingServers.cpp" />
     <ClCompile Include="Wrapper\SteamMusic.cpp" />
     <ClCompile Include="Wrapper\SteamMusicRemote.cpp" />
     <ClCompile Include="Wrapper\SteamNetworking.cpp" />
@@ -185,9 +186,10 @@
   <ItemGroup>
     <ClInclude Include="BlitzSteam.h" />
     <ClInclude Include="Helpers\BlitzPointer.h" />
-    <ClInclude Include="Helpers\Callbacks.h" />
+    <ClInclude Include="Helpers\BlitzCallback.h" />
     <ClInclude Include="Helpers\CSteamID.h" />
     <ClInclude Include="Helpers\Helper.h" />
+    <ClInclude Include="Helpers\Memory.h" />
   </ItemGroup>
   <ItemGroup>
     <None Include="LICENSE">

BlitzSteam.vcxproj.filters

@@ -50,9 +50,6 @@
     <ClCompile Include="Wrapper\SteamMatchmaking.cpp">
       <Filter>Source Files\Wrapper</Filter>
     </ClCompile>
-    <ClCompile Include="Wrapper\SteamMatchmakingServer.cpp">
-      <Filter>Source Files\Wrapper</Filter>
-    </ClCompile>
     <ClCompile Include="Wrapper\SteamUserStats.cpp">
       <Filter>Source Files\Wrapper</Filter>
     </ClCompile>
@@ -95,20 +92,23 @@
     <ClCompile Include="Helpers\CSteamID.cpp">
       <Filter>Source Files\Helpers</Filter>
     </ClCompile>
-    <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>
+    <ClCompile Include="Wrapper\SteamMatchmakingServers.cpp">
+      <Filter>Source Files\Wrapper</Filter>
+    </ClCompile>
+    <ClCompile Include="Helpers\Memory.cpp">
+      <Filter>Source Files\Helpers</Filter>
+    </ClCompile>
+    <ClCompile Include="Helpers\BlitzCallback.cpp">
+      <Filter>Source Files\Helpers</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="Helpers\Callbacks.h">
-      <Filter>Source Files\Helpers</Filter>
-    </ClInclude>
     <ClInclude Include="Helpers\CSteamID.h">
       <Filter>Source Files\Helpers</Filter>
     </ClInclude>
@@ -121,6 +121,12 @@
     <ClInclude Include="Helpers\Helper.h">
       <Filter>Source Files\Helpers</Filter>
     </ClInclude>
+    <ClInclude Include="Helpers\Memory.h">
+      <Filter>Source Files\Helpers</Filter>
+    </ClInclude>
+    <ClInclude Include="Helpers\BlitzCallback.h">
+      <Filter>Source Files\Helpers</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="SteamworksSDK\redistributable_bin\steam_api.dll">
@@ -129,13 +135,13 @@
     <None Include="Blitz\BlitzSteam.bb">
       <Filter>Blitz Files</Filter>
     </None>
-    <None Include="Blitz\BlitzSteam.decls">
-      <Filter>Blitz Files</Filter>
-    </None>
     <None Include="Blitz\BlitzSteamUtility.bb">
       <Filter>Blitz Files</Filter>
     </None>
     <None Include="LICENSE" />
     <None Include="LICENSE.lesser" />
+    <None Include="Blitz\BlitzSteam.decls">
+      <Filter>Blitz Files</Filter>
+    </None>
   </ItemGroup>
 </Project>

Helpers/BlitzCallback.cpp

@@ -0,0 +1,131 @@
+//	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 "BlitzCallback.h"
+
+BlitzCallback::BlitzCallback(BP_Function3_t pFunctionPointer) {
+	this->m_pFunctionPointer = pFunctionPointer;
+}
+
+BlitzCallback::~BlitzCallback() {
+	this->Unregister();
+	this->UnregisterResult();
+}
+
+int BlitzCallback::GetCallbackSizeBytes() {
+	return sizeof(BlitzCallback);
+}
+
+void BlitzCallback::Run(void *pvParam) {
+	if (this->m_hSteamAPICall != 0)
+		this->m_hSteamAPICall = 0; // Caller unregisters for us.
+
+	BP_CallFunction3(m_pFunctionPointer, reinterpret_cast<uint32_t>(pvParam), 0, 0);
+}
+
+void BlitzCallback::Run(void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall) {
+	if (this->m_hSteamAPICall != 0)
+		this->m_hSteamAPICall = 0; // Caller unregisters for us.
+
+	BP_CallFunction3(m_pFunctionPointer, reinterpret_cast<uint32_t>(pvParam), (uint32_t)bIOFailure, (uint32_t)&hSteamAPICall);
+}
+
+bool BlitzCallback::IsRegistered() {
+	return (this->m_nCallbackFlags & this->k_ECallbackFlagsRegistered) != 0;
+}
+
+void BlitzCallback::Register(uint32_t iCallback) {
+	if (!this->IsRegistered())
+		SteamAPI_RegisterCallback(this, iCallback);
+}
+
+void BlitzCallback::Unregister() {
+	if (this->IsRegistered())
+		SteamAPI_UnregisterCallback(this);
+}
+
+void BlitzCallback::RegisterResult(SteamAPICall_t hSteamAPICall) {
+	if (this->m_hSteamAPICall == 0) {
+		SteamAPI_RegisterCallResult(this, hSteamAPICall);
+		this->m_hSteamAPICall = hSteamAPICall;
+	}
+}
+
+void BlitzCallback::UnregisterResult()
+{
+	if (this->m_hSteamAPICall != 0) {
+		SteamAPI_UnregisterCallResult(this, this->m_hSteamAPICall);
+		this->m_hSteamAPICall = 0;
+	}
+}
+
+bool BlitzCallback::IsGameServer() {
+	return (this->m_nCallbackFlags & this->k_ECallbackFlagsGameServer) != 0;
+}
+
+void BlitzCallback::SetGameServer(bool bIsGameServer) {
+	this->m_nCallbackFlags &= ~k_ECallbackFlagsGameServer;
+	if (bIsGameServer)
+		this->m_nCallbackFlags |= k_ECallbackFlagsGameServer;
+}
+
+// DLL-Callables
+DLL_FUNCTION(BlitzCallback*) BS_Callback_Create(BP_Function3_t pFunctionPointer) {
+#pragma comment(linker, "/EXPORT:BS_Callback_Create=_BS_Callback_Create@4")
+	return new BlitzCallback(pFunctionPointer);
+}
+
+DLL_FUNCTION(void) BS_Callback_Destroy(BlitzCallback* pCallback) {
+#pragma comment(linker, "/EXPORT:BS_Callback_Destroy=_BS_Callback_Destroy@4")
+	delete pCallback;
+}
+
+DLL_FUNCTION(int32_t) BS_Callback_IsRegistered(BlitzCallback* pCallback) {
+#pragma comment(linker, "/EXPORT:BS_Callback_IsRegistered=_BS_Callback_IsRegistered@4")
+	return pCallback->IsRegistered();
+}
+
+DLL_FUNCTION(int32_t) BS_Callback_IsGameServer(BlitzCallback* pCallback) {
+#pragma comment(linker, "/EXPORT:BS_Callback_IsGameServer=_BS_Callback_IsGameServer@4")
+	return pCallback->IsGameServer();
+}
+
+DLL_FUNCTION(int32_t) BS_Callback_SetGameServerFlag(BlitzCallback* pCallback, int32_t bIsGameServer) {
+#pragma comment(linker, "/EXPORT:BS_Callback_SetGameServerFlag=_BS_Callback_SetGameServerFlag@8")
+	bool isGameServer = pCallback->IsGameServer();
+	pCallback->SetGameServer(!!bIsGameServer);
+	return isGameServer;
+}
+
+DLL_FUNCTION(void) BS_Callback_Register(BlitzCallback* pCallback, uint32_t iCallback) {
+#pragma comment(linker, "/EXPORT:BS_Callback_Register=_BS_Callback_Register@8")
+	pCallback->Register(iCallback);
+}
+
+DLL_FUNCTION(void) BS_Callback_Unregister(BlitzCallback* pCallback) {
+#pragma comment(linker, "/EXPORT:BS_Callback_Unregister=_BS_Callback_Unregister@4")
+	pCallback->Unregister();
+}
+
+DLL_FUNCTION(void) BS_Callback_RegisterResult(BlitzCallback* pCallback, SteamAPICall_t* pSteamAPICall) {
+#pragma comment(linker, "/EXPORT:BS_Callback_RegisterResult=_BS_Callback_RegisterResult@8")
+	pCallback->RegisterResult(*pSteamAPICall);
+}
+
+DLL_FUNCTION(void) BS_Callback_UnregisterResult(BlitzCallback* pCallback) {
+#pragma comment(linker, "/EXPORT:BS_Callback_UnregisterResult=_BS_Callback_UnregisterResult@4")
+	pCallback->UnregisterResult();
+}

Helpers/BlitzCallback.h

@@ -0,0 +1,55 @@
+//	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"
+#include "BlitzPointer.h"
+
+class BlitzCallback : public CCallbackBase {
+	public:
+	BlitzCallback(BP_Function3_t pFunctionPointer);
+	~BlitzCallback();
+
+	virtual void Run(void *pvParam);
+	virtual void Run(void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall);
+	virtual int GetCallbackSizeBytes();
+
+	bool IsRegistered();
+	bool IsGameServer();
+	void SetGameServer(bool bIsGameServer);
+
+	void Register(uint32_t iCallback);
+	void Unregister();
+
+	void RegisterResult(SteamAPICall_t hSteamAPICall);
+	void UnregisterResult();
+
+	private:
+	BP_Function3_t m_pFunctionPointer;
+	SteamAPICall_t m_hSteamAPICall;
+};
+
+DLL_FUNCTION(BlitzCallback*) BS_Callback_Create(BP_Function3_t pFunctionPointer);
+DLL_FUNCTION(void) BS_Callback_Destroy(BlitzCallback* pCallback);
+
+DLL_FUNCTION(int32_t) BS_Callback_IsRegistered(BlitzCallback* pCallback);
+DLL_FUNCTION(int32_t) BS_Callback_IsGameServer(BlitzCallback* pCallback);
+DLL_FUNCTION(int32_t) BS_Callback_SetGameServerFlag(BlitzCallback* pCallback, int32_t isGameServer);
+
+DLL_FUNCTION(void) BS_Callback_Register(BlitzCallback* pCallback, uint32_t iCallback);
+DLL_FUNCTION(void) BS_Callback_Unregister(BlitzCallback* pCallback);
+DLL_FUNCTION(void) BS_Callback_RegisterResult(BlitzCallback* pCallback, SteamAPICall_t* pSteamAPICall);
+DLL_FUNCTION(void) BS_Callback_UnregisterResult(BlitzCallback* pCallback);

Helpers/Callbacks.cpp

@@ -1,45 +0,0 @@
-//	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 "Callbacks.h"
-
-// Callbacks
-void BS_Callback::Run(void *pvParam) {
-	BP_CallFunction3(bbRunFunction, reinterpret_cast<uint32_t>(pvParam), 0, 0);
-}
-
-void BS_Callback::Run(void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall) {
-	BP_CallFunction3(bbRunFunction, reinterpret_cast<uint32_t>(pvParam), (uint32_t)bIOFailure, reinterpret_cast<uint32_t>(&hSteamAPICall));
-}
-
-int BS_Callback::GetCallbackSizeBytes() {
-	return sizeof(BS_Callback);
-}
-
-// DLL-Callables
-DLL_FUNCTION(BS_Callback*) BS_Callback_Create(uint32_t fpFunctionPointer) {
-	BS_Callback* lpCallback = new BS_Callback();
-	lpCallback->bbRunFunction = (void*)fpFunctionPointer;
-	return lpCallback;
-}
-#pragma comment(linker, "/EXPORT:BS_Callback_Create=_BS_Callback_Create@4")
-
-DLL_FUNCTION(void) BS_Callback_Destroy(BS_Callback* lpCallback) {
-	if (lpCallback != nullptr) {
-		delete lpCallback;
-	}
-}
-#pragma comment(linker, "/EXPORT:BS_Callback_Destroy=_BS_Callback_Destroy@4")

Helpers/Callbacks.h

@@ -1,29 +0,0 @@
-//	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

@@ -17,6 +17,7 @@
 #include "Helper.h"
 
 DLL_FUNCTION(const char*) BS_Helper_FormatUnixTime(uint32_t unTime, const char* pchFormat) {
+#pragma comment(linker, "/EXPORT:BS_Helper_FormatUnixTime=_BS_Helper_FormatUnixTime@8")
 	char* output = new char[strlen(pchFormat) * 4];
 	time_t t = unTime;
 	struct tm *tm = localtime(&t);
@@ -24,4 +25,18 @@ DLL_FUNCTION(const char*) BS_Helper_FormatUnixTime(uint32_t unTime, const char*
 	delete tm;
 	return output;
 }
-#pragma comment(linker, "/EXPORT:BS_Helper_FormatUnixTime=_BS_Helper_FormatUnixTime@8")
+
+DLL_FUNCTION(void) BS_Helper_DeleteLong(uint64_t* pLong) {
+#pragma comment(linker, "/EXPORT:BS_Helper_DeleteLong=_BS_Helper_DeleteLong@4")
+	delete pLong;
+}
+
+DLL_FUNCTION(double_t*) BS_Helper_CreateDouble(float_t value) {
+#pragma comment(linker, "/EXPORT:BS_Helper_CreateDouble=_BS_Helper_CreateDouble@4")
+	return new double_t(value);
+}
+
+DLL_FUNCTION(void) BS_Helper_DeleteDouble(double_t* pDouble) {
+#pragma comment(linker, "/EXPORT:BS_Helper_DeleteDouble=_BS_Helper_DeleteDouble@4")
+	delete pDouble;
+}

Helpers/Memory.cpp

@@ -0,0 +1,72 @@
+//	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 "Memory.h"
+
+DLL_FUNCTION(void*) BS_Memory_Alloc(uint32_t iSize) {
+#pragma comment(linker, "/EXPORT:BS_Memory_Alloc=_BS_Memory_Alloc@4")
+	return malloc(iSize);
+}
+
+DLL_FUNCTION(void*) BS_Memory_ReAlloc(void* pMemory, uint32_t iNewSize) {
+#pragma comment(linker, "/EXPORT:BS_Memory_ReAlloc=_BS_Memory_ReAlloc@8")
+	return realloc(pMemory, iNewSize);
+}
+
+DLL_FUNCTION(void) BS_Memory_Free(void* pMemory) {
+#pragma comment(linker, "/EXPORT:BS_Memory_Free=_BS_Memory_Free@4")
+	free(pMemory);
+}
+
+DLL_FUNCTION(uint8_t) BS_Memory_PeekByte(void* pMemory, uint32_t offset) {
+#pragma comment(linker, "/EXPORT:BS_Memory_PeekByte=_BS_Memory_PeekByte@8")
+	return *(reinterpret_cast<uint8_t*>(pMemory) + offset);
+}
+
+DLL_FUNCTION(uint16_t) BS_Memory_PeekShort(void* pMemory, uint32_t offset) {
+#pragma comment(linker, "/EXPORT:BS_Memory_PeekShort=_BS_Memory_PeekShort@8")
+	return *(uint16_t*)(reinterpret_cast<uint8_t*>(pMemory) + offset);
+}
+
+DLL_FUNCTION(uint32_t) BS_Memory_PeekInt(void* pMemory, uint32_t offset) {
+#pragma comment(linker, "/EXPORT:BS_Memory_PeekInt=_BS_Memory_PeekInt@8")
+	return *(uint32_t*)(reinterpret_cast<uint8_t*>(pMemory) + offset);
+}
+
+DLL_FUNCTION(float_t) BS_Memory_PeekFloat(void* pMemory, uint32_t offset) {
+#pragma comment(linker, "/EXPORT:BS_Memory_PeekFloat=_BS_Memory_PeekFloat@8")
+	return *(float_t*)(reinterpret_cast<uint8_t*>(pMemory) + offset);
+}
+
+DLL_FUNCTION(void) BS_Memory_PokeByte(void* pMemory, uint32_t offset, uint8_t value) {
+#pragma comment(linker, "/EXPORT:BS_Memory_PokeByte=_BS_Memory_PokeByte@12")
+	*((reinterpret_cast<uint8_t*>(pMemory) + offset)) = value;
+}
+
+DLL_FUNCTION(void) BS_Memory_PokeShort(void* pMemory, uint32_t offset, uint16_t value) {
+#pragma comment(linker, "/EXPORT:BS_Memory_PokeShort=_BS_Memory_PokeShort@12")
+	*(reinterpret_cast<uint16_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)) = value;
+}
+
+DLL_FUNCTION(void) BS_Memory_PokeInt(void* pMemory, uint32_t offset, uint32_t value) {
+#pragma comment(linker, "/EXPORT:BS_Memory_PokeInt=_BS_Memory_PokeInt@12")
+	*(reinterpret_cast<uint32_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)) = value;
+}
+
+DLL_FUNCTION(void) BS_Memory_PokeFloat(void* pMemory, uint32_t offset, float_t value) {
+#pragma comment(linker, "/EXPORT:BS_Memory_PokeFloat=_BS_Memory_PokeFloat@12")
+	*(reinterpret_cast<float_t*>(reinterpret_cast<uint8_t*>(pMemory) + offset)) = value;
+}

Helpers/Memory.h

@@ -0,0 +1,30 @@
+//	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"
+
+DLL_FUNCTION(void*) BS_Memory_Alloc(uint32_t iSize);
+DLL_FUNCTION(void*) BS_Memory_ReAlloc(void* pMemory, uint32_t iNewSize);
+DLL_FUNCTION(void) BS_Memory_Free(void* pMemory);
+DLL_FUNCTION(uint8_t) BS_Memory_PeekByte(void* pMemory, uint32_t offset);
+DLL_FUNCTION(uint16_t) BS_Memory_PeekShort(void* pMemory, uint32_t offset);
+DLL_FUNCTION(uint32_t) BS_Memory_PeekInt(void* pMemory, uint32_t offset);
+DLL_FUNCTION(float_t) BS_Memory_PeekFloat(void* pMemory, uint32_t offset);
+DLL_FUNCTION(void) BS_Memory_PokeByte(void* pMemory, uint32_t offset, uint8_t value);
+DLL_FUNCTION(void) BS_Memory_PokeShort(void* pMemory, uint32_t offset, uint16_t value);
+DLL_FUNCTION(void) BS_Memory_PokeInt(void* pMemory, uint32_t offset, uint32_t value);
+DLL_FUNCTION(void) BS_Memory_PokeFloat(void* pMemory, uint32_t offset, float_t value);

Wrapper/Steam.cpp

@@ -17,57 +17,57 @@
 #include "BlitzSteam.h"
 
 DLL_FUNCTION(uint32_t) BS_Steam_Init() {
+#pragma comment(linker, "/EXPORT:BS_Steam_Init=_BS_Steam_Init@0")
 	return SteamAPI_Init();
 }
-#pragma comment(linker, "/EXPORT:BS_Steam_Init=_BS_Steam_Init@0")
 
 DLL_FUNCTION(void) BS_Steam_Shutdown() {
+#pragma comment(linker, "/EXPORT:BS_Steam_Shutdown=_BS_Steam_Shutdown@0")
 	SteamAPI_Shutdown();
 }
-#pragma comment(linker, "/EXPORT:BS_Steam_Shutdown=_BS_Steam_Shutdown@0")
 
 DLL_FUNCTION(uint32_t) BS_Steam_IsSteamRunning() {
+#pragma comment(linker, "/EXPORT:BS_Steam_IsSteamRunning=_BS_Steam_IsSteamRunning@0")
 	return SteamAPI_IsSteamRunning();
 }
-#pragma comment(linker, "/EXPORT:BS_Steam_IsSteamRunning=_BS_Steam_IsSteamRunning@0")
 
 DLL_FUNCTION(uint32_t) BS_Steam_RestartAppIfNecessary(uint32_t unOwnAppID) {
+#pragma comment(linker, "/EXPORT:BS_Steam_RestartAppIfNecessary=_BS_Steam_RestartAppIfNecessary@4")
 	return SteamAPI_RestartAppIfNecessary(unOwnAppID);
 }
-#pragma comment(linker, "/EXPORT:BS_Steam_RestartAppIfNecessary=_BS_Steam_RestartAppIfNecessary@4")
 
 DLL_FUNCTION(void) BS_Steam_SetMiniDumpComment(const char* pchMsg) {
+#pragma comment(linker, "/EXPORT:BS_Steam_SetMiniDumpComment=_BS_Steam_SetMiniDumpComment@4")
 	SteamAPI_SetMiniDumpComment(pchMsg);
 }
-#pragma comment(linker, "/EXPORT:BS_Steam_SetMiniDumpComment=_BS_Steam_SetMiniDumpComment@4")
 
 DLL_FUNCTION(void) BS_Steam_WriteMiniDump(uint32_t uStructuredExceptionCode, void* pvExceptionInfo, uint32_t uBuildID) {
+#pragma comment(linker, "/EXPORT:BS_Steam_WriteMiniDump=_BS_Steam_WriteMiniDump@12")
 	SteamAPI_WriteMiniDump(uStructuredExceptionCode, pvExceptionInfo, uBuildID);
 }
-#pragma comment(linker, "/EXPORT:BS_Steam_WriteMiniDump=_BS_Steam_WriteMiniDump@12")
 
 // -- Callbacks
 DLL_FUNCTION(void) BS_Steam_RunCallbacks() {
+#pragma comment(linker, "/EXPORT:BS_Steam_RunCallbacks=_BS_Steam_RunCallbacks@0")
 	SteamAPI_RunCallbacks();
 }
-#pragma comment(linker, "/EXPORT:BS_Steam_RunCallbacks=_BS_Steam_RunCallbacks@0")
 
 DLL_FUNCTION(void) BS_Steam_RegisterCallback(class CCallbackBase *pCallback, uint32_t iCallback) {
+#pragma comment(linker, "/EXPORT:BS_Steam_RegisterCallback=_BS_Steam_RegisterCallback@8")
 	SteamAPI_RegisterCallback(pCallback, iCallback);
 }
-#pragma comment(linker, "/EXPORT:BS_Steam_RegisterCallback=_BS_Steam_RegisterCallback@8")
 
 DLL_FUNCTION(void) BS_Steam_UnregisterCallback(class CCallbackBase *pCallback) {
+#pragma comment(linker, "/EXPORT:BS_Steam_UnregisterCallback=_BS_Steam_UnregisterCallback@4")
 	SteamAPI_UnregisterCallback(pCallback);
 }
-#pragma comment(linker, "/EXPORT:BS_Steam_UnregisterCallback=_BS_Steam_UnregisterCallback@4")
 
 DLL_FUNCTION(void) BS_Steam_RegisterCallResult(class CCallbackBase *pCallback, uint64_t* phAPICall) {
+#pragma comment(linker, "/EXPORT:BS_Steam_RegisterCallResult=_BS_Steam_RegisterCallResult@8")
 	SteamAPI_RegisterCallResult(pCallback, *phAPICall);
 }
-#pragma comment(linker, "/EXPORT:BS_Steam_RegisterCallResult=_BS_Steam_RegisterCallResult@8")
 
 DLL_FUNCTION(void) BS_Steam_UnregisterCallResult(class CCallbackBase *pCallback, uint64_t* phAPICall) {
+#pragma comment(linker, "/EXPORT:BS_Steam_UnregisterCallResult=_BS_Steam_UnregisterCallResult@8")
 	SteamAPI_UnregisterCallResult(pCallback, *phAPICall);
 }
-#pragma comment(linker, "/EXPORT:BS_Steam_UnregisterCallResult=_BS_Steam_UnregisterCallResult@8")

Wrapper/SteamAppList.cpp

@@ -17,31 +17,31 @@
 #include "BlitzSteam.h"
 
 DLL_FUNCTION(ISteamAppList*) BS_AppList() {
+#pragma comment(linker, "/EXPORT:BS_AppList=_BS_AppList@0")
 	return SteamAppList();
 }
-#pragma comment(linker, "/EXPORT:BS_AppList=_BS_AppList@0")
 
 DLL_FUNCTION(uint32_t) BS_AppList_GetNumInstalledApps(ISteamAppList* lpSteamAppList) {
+#pragma comment(linker, "/EXPORT:BS_AppList_GetNumInstalledApps=_BS_AppList_GetNumInstalledApps@4")
 	return lpSteamAppList->GetNumInstalledApps();
 }
-#pragma comment(linker, "/EXPORT:BS_AppList_GetNumInstalledApps=_BS_AppList_GetNumInstalledApps@4")
 
 DLL_FUNCTION(uint32_t) BS_AppList_GetInstalledApps(ISteamAppList* lpSteamAppList, AppId_t *pvecAppID, uint32_t unMaxAppIDs) {
+#pragma comment(linker, "/EXPORT:BS_AppList_GetInstalledApps=_BS_AppList_GetInstalledApps@12")
 	return lpSteamAppList->GetInstalledApps(pvecAppID, unMaxAppIDs);
 }
-#pragma comment(linker, "/EXPORT:BS_AppList_GetInstalledApps=_BS_AppList_GetInstalledApps@12")
 
-DLL_FUNCTION(uint32_t) 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, const char* pchName, uint32_t cchNameMax) {
-	return lpSteamAppList->GetAppName(nAppID, pchName, cchNameMax);
-}
 #pragma comment(linker, "/EXPORT:BS_AppList_GetAppName=_BS_AppList_GetAppName@16")
-
+	return lpSteamAppList->GetAppName(nAppID, (char*)pchName, cchNameMax);
-DLL_FUNCTION(uint32_t) BS_AppList_GetAppInstallDir(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchDirectory, uint32_t cchDirectoryMax) {
-	return lpSteamAppList->GetAppInstallDir(nAppID, pchDirectory, cchDirectoryMax);
 }
+
+DLL_FUNCTION(uint32_t) BS_AppList_GetAppInstallDir(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchDirectoryBuffer, uint32_t cchDirectoryMax) {
 #pragma comment(linker, "/EXPORT:BS_AppList_GetAppInstallDir=_BS_AppList_GetAppInstallDir@16")
+	return lpSteamAppList->GetAppInstallDir(nAppID, pchDirectoryBuffer, cchDirectoryMax);
+}
 
 DLL_FUNCTION(uint32_t) BS_AppList_GetAppBuildId(ISteamAppList* lpSteamAppList, AppId_t nAppID) {
+#pragma comment(linker, "/EXPORT:BS_AppList_GetAppBuildId=_BS_AppList_GetAppBuildId@8")
 	return lpSteamAppList->GetAppBuildId(nAppID);
 }
-#pragma comment(linker, "/EXPORT:BS_AppList_GetAppBuildId=_BS_AppList_GetAppBuildId@8")

Wrapper/SteamApps.cpp

@@ -17,127 +17,126 @@
 #include "BlitzSteam.h"
 
 DLL_FUNCTION(ISteamApps*) BS_Apps() {
+#pragma comment(linker, "/EXPORT:BS_Apps=_BS_Apps@0")
 	return SteamApps();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps=_BS_Apps@0")
 
 DLL_FUNCTION(uint32_t) BS_Apps_IsSubscribed(ISteamApps* lpSteamApps) {
+#pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribed=_BS_Apps_IsSubscribed@4")
 	return lpSteamApps->BIsSubscribed();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribed=_BS_Apps_IsSubscribed@4")
 
 DLL_FUNCTION(uint32_t) BS_Apps_IsLowViolence(ISteamApps* lpSteamApps) {
+#pragma comment(linker, "/EXPORT:BS_Apps_IsLowViolence=_BS_Apps_IsLowViolence@4")
 	return lpSteamApps->BIsLowViolence();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsLowViolence=_BS_Apps_IsLowViolence@4")
 
 DLL_FUNCTION(uint32_t) BS_Apps_IsCybercafe(ISteamApps* lpSteamApps) {
+#pragma comment(linker, "/EXPORT:BS_Apps_IsCybercafe=_BS_Apps_IsCybercafe@4")
 	return lpSteamApps->BIsCybercafe();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsCybercafe=_BS_Apps_IsCybercafe@4")
 
 DLL_FUNCTION(uint32_t) BS_Apps_IsVACBanned(ISteamApps* lpSteamApps) {
+#pragma comment(linker, "/EXPORT:BS_Apps_IsVACBanned=_BS_Apps_IsVACBanned@4")
 	return lpSteamApps->BIsVACBanned();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsVACBanned=_BS_Apps_IsVACBanned@4")
 
 DLL_FUNCTION(const char*) BS_Apps_GetCurrentGameLanguage(ISteamApps* lpSteamApps) {
+#pragma comment(linker, "/EXPORT:BS_Apps_GetCurrentGameLanguage=_BS_Apps_GetCurrentGameLanguage@4")
 	return lpSteamApps->GetCurrentGameLanguage();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetCurrentGameLanguage=_BS_Apps_GetCurrentGameLanguage@4")
 
 DLL_FUNCTION(const char*) BS_Apps_GetAvailableGameLanguages(ISteamApps* lpSteamApps) {
+#pragma comment(linker, "/EXPORT:BS_Apps_GetAvailableGameLanguages=_BS_Apps_GetAvailableGameLanguages@4")
 	return lpSteamApps->GetAvailableGameLanguages();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetAvailableGameLanguages=_BS_Apps_GetAvailableGameLanguages@4")
 
 DLL_FUNCTION(uint32_t) BS_Apps_IsSubscribedApp(ISteamApps* lpSteamApps, AppId_t appID) {
+#pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribedApp=_BS_Apps_IsSubscribedApp@8")
 	return lpSteamApps->BIsSubscribedApp(appID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribedApp=_BS_Apps_IsSubscribedApp@8")
 
 DLL_FUNCTION(uint32_t) BS_Apps_IsDlcInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
+#pragma comment(linker, "/EXPORT:BS_Apps_IsDlcInstalled=_BS_Apps_IsDlcInstalled@8")
 	return lpSteamApps->BIsDlcInstalled(appID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsDlcInstalled=_BS_Apps_IsDlcInstalled@8")
 
 DLL_FUNCTION(uint32_t) BS_Apps_GetEarliestPurchaseUnixTime(ISteamApps* lpSteamApps, AppId_t appID) {
+#pragma comment(linker, "/EXPORT:BS_Apps_GetEarliestPurchaseUnixTime=_BS_Apps_GetEarliestPurchaseUnixTime@8")
 	return lpSteamApps->GetEarliestPurchaseUnixTime(appID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetEarliestPurchaseUnixTime=_BS_Apps_GetEarliestPurchaseUnixTime@8")
 
 DLL_FUNCTION(uint32_t) BS_Apps_IsSubscribedFromFreeWeekend(ISteamApps* lpSteamApps) {
+#pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribedFromFreeWeekend=_BS_Apps_IsSubscribedFromFreeWeekend@4")
 	return lpSteamApps->BIsSubscribedFromFreeWeekend();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribedFromFreeWeekend=_BS_Apps_IsSubscribedFromFreeWeekend@4")
 
 DLL_FUNCTION(uint32_t) BS_Apps_GetDLCCount(ISteamApps* lpSteamApps) {
+#pragma comment(linker, "/EXPORT:BS_Apps_GetDLCCount=_BS_Apps_GetDLCCount@4")
 	return lpSteamApps->GetDLCCount();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetDLCCount=_BS_Apps_GetDLCCount@4")
 
-DLL_FUNCTION(uint32_t) 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 *pAppIdBuffer, bool* pbAvailableBuffer, char *pchNameBuffer, uint32_t cchNameBufferSize) {
-	return lpSteamApps->BGetDLCDataByIndex(iDLC, pAppId, (bool*)pbAvailable, pchName, cchNameBufferSize);
-}
 #pragma comment(linker, "/EXPORT:BS_Apps_GetDLCDataByIndex=_BS_Apps_GetDLCDataByIndex@24")
+	return lpSteamApps->BGetDLCDataByIndex(iDLC, pAppIdBuffer, (bool*)pbAvailableBuffer, pchNameBuffer, cchNameBufferSize);
+}
 
 DLL_FUNCTION(void) BS_Apps_InstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
+#pragma comment(linker, "/EXPORT:BS_Apps_InstallDLC=_BS_Apps_InstallDLC@8")
 	lpSteamApps->InstallDLC(nAppID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_InstallDLC=_BS_Apps_InstallDLC@8")
 
 DLL_FUNCTION(void) BS_Apps_UninstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
+#pragma comment(linker, "/EXPORT:BS_Apps_UninstallDLC=_BS_Apps_UninstallDLC@8")
 	lpSteamApps->UninstallDLC(nAppID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_UninstallDLC=_BS_Apps_UninstallDLC@8")
 
 DLL_FUNCTION(void) BS_Apps_RequestAppProofOfPurchaseKey(ISteamApps* lpSteamApps, AppId_t nAppID) {
+#pragma comment(linker, "/EXPORT:BS_Apps_RequestAppProofOfPurchaseKey=_BS_Apps_RequestAppProofOfPurchaseKey@8")
 	lpSteamApps->RequestAppProofOfPurchaseKey(nAppID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_RequestAppProofOfPurchaseKey=_BS_Apps_RequestAppProofOfPurchaseKey@8")
 
-DLL_FUNCTION(uint32_t) BS_Apps_GetCurrentBetaName(ISteamApps* lpSteamApps, char *pchName, int cchNameBufferSize) {
+DLL_FUNCTION(uint32_t) BS_Apps_GetCurrentBetaName(ISteamApps* lpSteamApps, char* pchNameBuffer, int cchNameBufferSize) {
-	return lpSteamApps->GetCurrentBetaName(pchName, cchNameBufferSize);
-}
 #pragma comment(linker, "/EXPORT:BS_Apps_GetCurrentBetaName=_BS_Apps_GetCurrentBetaName@12")
+	return lpSteamApps->GetCurrentBetaName(pchNameBuffer, cchNameBufferSize);
+}
 
 DLL_FUNCTION(uint32_t) BS_Apps_MarkContentCorrupt(ISteamApps* lpSteamApps, uint32_t bMissingFilesOnly) {
+#pragma comment(linker, "/EXPORT:BS_Apps_MarkContentCorrupt=_BS_Apps_MarkContentCorrupt@8")
 	return lpSteamApps->MarkContentCorrupt(bMissingFilesOnly != 0);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_MarkContentCorrupt=_BS_Apps_MarkContentCorrupt@8")
 
-DLL_FUNCTION(uint32_t) 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 *pDepotsBuffer, uint32_t cMaxDepots) {
-	return lpSteamApps->GetInstalledDepots(nAppID, pvecDepots, cMaxDepots);
-}
 #pragma comment(linker, "/EXPORT:BS_Apps_GetInstalledDepots=_BS_Apps_GetInstalledDepots@16")
-
+	return lpSteamApps->GetInstalledDepots(nAppID, pDepotsBuffer, cMaxDepots);
-DLL_FUNCTION(uint32_t) BS_Apps_GetAppInstallDir(ISteamApps* lpSteamApps, AppId_t appID, char *pchFolder, uint32_t cchFolderBufferSize) {
-	return lpSteamApps->GetAppInstallDir(appID, pchFolder, cchFolderBufferSize);
 }
+
+DLL_FUNCTION(uint32_t) BS_Apps_GetAppInstallDir(ISteamApps* lpSteamApps, AppId_t appID, char *pchFolderBuffer, uint32_t cchFolderBufferSize) {
 #pragma comment(linker, "/EXPORT:BS_Apps_GetAppInstallDir=_BS_Apps_GetAppInstallDir@16")
+	return lpSteamApps->GetAppInstallDir(appID, pchFolderBuffer, cchFolderBufferSize);
+}
 
 DLL_FUNCTION(uint32_t) BS_Apps_IsAppInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
+#pragma comment(linker, "/EXPORT:BS_Apps_IsAppInstalled=_BS_Apps_IsAppInstalled@8")
 	return lpSteamApps->BIsAppInstalled(appID);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_IsAppInstalled=_BS_Apps_IsAppInstalled@8")
 
 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")
+	return new CSteamID(lpSteamApps->GetAppOwner());
+}
 
 DLL_FUNCTION(const char*) BS_Apps_GetLaunchQueryParam(ISteamApps* lpSteamApps, const char *pchKey) {
+#pragma comment(linker, "/EXPORT:BS_Apps_GetLaunchQueryParam=_BS_Apps_GetLaunchQueryParam@8")
 	return lpSteamApps->GetLaunchQueryParam(pchKey);
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetLaunchQueryParam=_BS_Apps_GetLaunchQueryParam@8")
 
-DLL_FUNCTION(uint32_t) 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* pLLBytesDownloaded, uint64_t* pLLBytesTotal) {
-	return lpSteamApps->GetDlcDownloadProgress(nAppID, punBytesDownloaded, punBytesTotal);
-}
 #pragma comment(linker, "/EXPORT:BS_Apps_GetDlcDownloadProgress=_BS_Apps_GetDlcDownloadProgress@16")
+	return lpSteamApps->GetDlcDownloadProgress(nAppID, pLLBytesDownloaded, pLLBytesTotal);
+}
 
 DLL_FUNCTION(uint32_t) BS_Apps_GetAppBuildId(ISteamApps* lpSteamApps) {
+#pragma comment(linker, "/EXPORT:BS_Apps_GetAppBuildId=_BS_Apps_GetAppBuildId@4")
 	return lpSteamApps->GetAppBuildId();
 }
-#pragma comment(linker, "/EXPORT:BS_Apps_GetAppBuildId=_BS_Apps_GetAppBuildId@4")

Wrapper/SteamClient.cpp

@@ -17,182 +17,183 @@
 #include "BlitzSteam.h"
 
 DLL_FUNCTION(ISteamClient*) BS_Client() {
+#pragma comment(linker, "/EXPORT:BS_Client=_BS_Client@0")
 	return SteamClient();
 }
-#pragma comment(linker, "/EXPORT:BS_Client=_BS_Client@0")
 
 DLL_FUNCTION(HSteamPipe) BS_Client_CreateSteamPipe(ISteamClient* lpSteamClient) {
+#pragma comment(linker, "/EXPORT:BS_Client_CreateSteamPipe=_BS_Client_CreateSteamPipe@4")
 	return lpSteamClient->CreateSteamPipe();
 }
-#pragma comment(linker, "/EXPORT:BS_Client_CreateSteamPipe=_BS_Client_CreateSteamPipe@4")
 
 DLL_FUNCTION(uint32_t) BS_Client_ReleaseSteamPipe(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
+#pragma comment(linker, "/EXPORT:BS_Client_ReleaseSteamPipe=_BS_Client_ReleaseSteamPipe@8")
 	return lpSteamClient->BReleaseSteamPipe(hSteamPipe);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_ReleaseSteamPipe=_BS_Client_ReleaseSteamPipe@8")
 
 DLL_FUNCTION(HSteamUser) BS_Client_ConnectToGlobalUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
+#pragma comment(linker, "/EXPORT:BS_Client_ConnectToGlobalUser=_BS_Client_ConnectToGlobalUser@8")
 	return lpSteamClient->ConnectToGlobalUser(hSteamPipe);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_ConnectToGlobalUser=_BS_Client_ConnectToGlobalUser@8")
 
 DLL_FUNCTION(void) BS_Client_SetLocalIPBinding(ISteamClient* lpSteamClient, uint32_t unIP, uint16 usPort) {
+#pragma comment(linker, "/EXPORT:BS_Client_SetLocalIPBinding=_BS_Client_SetLocalIPBinding@12")
 	return lpSteamClient->SetLocalIPBinding(unIP, usPort);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_SetLocalIPBinding=_BS_Client_SetLocalIPBinding@12")
 
 DLL_FUNCTION(HSteamUser) BS_Client_CreateLocalUser(ISteamClient* lpSteamClient, HSteamPipe* phSteamPipe, EAccountType eAccountType) {
+#pragma comment(linker, "/EXPORT:BS_Client_CreateLocalUser=_BS_Client_CreateLocalUser@12")
 	return lpSteamClient->CreateLocalUser(phSteamPipe, eAccountType);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_CreateLocalUser=_BS_Client_CreateLocalUser@12")
 
 DLL_FUNCTION(void) BS_Client_ReleaseUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, HSteamUser hSteamUser) {
+#pragma comment(linker, "/EXPORT:BS_Client_ReleaseUser=_BS_Client_ReleaseUser@12")
 	return lpSteamClient->ReleaseUser(hSteamPipe, hSteamUser);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_ReleaseUser=_BS_Client_ReleaseUser@12")
 
 DLL_FUNCTION(void) BS_Client_RunFrame(ISteamClient* lpSteamClient) {
+#pragma comment(linker, "/EXPORT:BS_Client_RunFrame=_BS_Client_RunFrame@4")
 	lpSteamClient->RunFrame();
 }
-#pragma comment(linker, "/EXPORT:BS_Client_RunFrame=_BS_Client_RunFrame@4")
 
 DLL_FUNCTION(uint32_t) BS_Client_GetIPCCallCount(ISteamClient* lpSteamClient) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetIPCCallCount=_BS_Client_GetIPCCallCount@4")
 	return lpSteamClient->GetIPCCallCount();
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetIPCCallCount=_BS_Client_GetIPCCallCount@4")
 
 DLL_FUNCTION(uint32_t) BS_Client_ShutdownIfAllPipesClosed(ISteamClient* lpSteamClient) {
+#pragma comment(linker, "/EXPORT:BS_Client_ShutdownIfAllPipesClosed=_BS_Client_ShutdownIfAllPipesClosed@4")
 	return lpSteamClient->BShutdownIfAllPipesClosed();
 }
 
 // Interfaces
 DLL_FUNCTION(ISteamAppList*) BS_Client_GetSteamAppList(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamAppList=_BS_Client_GetSteamAppList@16")
 	return lpSteamClient->GetISteamAppList(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamAppList=_BS_Client_GetSteamAppList@16")
 
 DLL_FUNCTION(ISteamApps*) BS_Client_GetSteamApps(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamApps=_BS_Client_GetSteamApps@16")
 	return lpSteamClient->GetISteamApps(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamApps=_BS_Client_GetSteamApps@16")
 
 DLL_FUNCTION(ISteamController*) BS_Client_GetSteamController(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamController=_BS_Client_GetSteamController@16")
 	return lpSteamClient->GetISteamController(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamController=_BS_Client_GetSteamController@16")
 
 DLL_FUNCTION(ISteamFriends*) BS_Client_GetSteamFriends(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamFriends=_BS_Client_GetSteamFriends@16")
 	return lpSteamClient->GetISteamFriends(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamFriends=_BS_Client_GetSteamFriends@16")
 
 DLL_FUNCTION(ISteamGameServer*) BS_Client_GetSteamGameServer(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamGameServer=_BS_Client_GetSteamGameServer@16")
 	return lpSteamClient->GetISteamGameServer(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamGameServer=_BS_Client_GetSteamGameServer@16")
 
 DLL_FUNCTION(ISteamGameServerStats*) BS_Client_GetSteamGameServerStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamGameServerStats=_BS_Client_GetSteamGameServerStats@16")
 	return lpSteamClient->GetISteamGameServerStats(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamGameServerStats=_BS_Client_GetSteamGameServerStats@16")
 
 DLL_FUNCTION(ISteamHTMLSurface*) BS_Client_GetSteamHTMLSurface(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamHTMLSurface=_BS_Client_GetSteamHTMLSurface@16")
 	return lpSteamClient->GetISteamHTMLSurface(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamHTMLSurface=_BS_Client_GetSteamHTMLSurface@16")
 
 DLL_FUNCTION(ISteamHTTP*) BS_Client_GetSteamHTTP(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamHTTP=_BS_Client_GetSteamHTTP@16")
 	return lpSteamClient->GetISteamHTTP(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamHTTP=_BS_Client_GetSteamHTTP@16")
 
 DLL_FUNCTION(ISteamInventory*) BS_Client_GetSteamInventory(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamInventory=_BS_Client_GetSteamInventory@16")
 	return lpSteamClient->GetISteamInventory(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamInventory=_BS_Client_GetSteamInventory@16")
 
 DLL_FUNCTION(ISteamMatchmaking*) BS_Client_GetSteamMatchmaking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMatchmaking=_BS_Client_GetSteamMatchmaking@16")
 	return lpSteamClient->GetISteamMatchmaking(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMatchmaking=_BS_Client_GetSteamMatchmaking@16")
 
 DLL_FUNCTION(ISteamMatchmakingServers*) BS_Client_GetSteamMatchmakingServers(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMatchmakingServers=_BS_Client_GetSteamMatchmakingServers@16")
 	return lpSteamClient->GetISteamMatchmakingServers(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMatchmakingServers=_BS_Client_GetSteamMatchmakingServers@16")
 
 DLL_FUNCTION(ISteamMusic*) BS_Client_GetSteamMusic(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMusic=_BS_Client_GetSteamMusic@16")
 	return lpSteamClient->GetISteamMusic(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMusic=_BS_Client_GetSteamMusic@16")
 
 DLL_FUNCTION(ISteamMusicRemote*) BS_Client_GetSteamMusicRemote(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMusicRemote=_BS_Client_GetSteamMusicRemote@16")
 	return lpSteamClient->GetISteamMusicRemote(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamMusicRemote=_BS_Client_GetSteamMusicRemote@16")
 
 DLL_FUNCTION(ISteamNetworking*) BS_Client_GetSteamNetworking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamNetworking=_BS_Client_GetSteamNetworking@16")
 	return lpSteamClient->GetISteamNetworking(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamNetworking=_BS_Client_GetSteamNetworking@16")
 
 DLL_FUNCTION(ISteamRemoteStorage*) BS_Client_GetSteamRemoteStorage(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamRemoteStorage=_BS_Client_GetSteamRemoteStorage@16")
 	return lpSteamClient->GetISteamRemoteStorage(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamRemoteStorage=_BS_Client_GetSteamRemoteStorage@16")
 
 DLL_FUNCTION(ISteamScreenshots*) BS_Client_GetSteamScreenshots(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamScreenshots=_BS_Client_GetSteamScreenshots@16")
 	return lpSteamClient->GetISteamScreenshots(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamScreenshots=_BS_Client_GetSteamScreenshots@16")
 
 DLL_FUNCTION(ISteamUGC*) BS_Client_GetSteamUGC(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUGC=_BS_Client_GetSteamUGC@16")
 	return lpSteamClient->GetISteamUGC(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUGC=_BS_Client_GetSteamUGC@16")
 
 DLL_FUNCTION(ISteamUnifiedMessages*) BS_Client_GetSteamUnifiedMessages(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUnifiedMessages=_BS_Client_GetSteamUnifiedMessages@16")
 	return lpSteamClient->GetISteamUnifiedMessages(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUnifiedMessages=_BS_Client_GetSteamUnifiedMessages@16")
 
 DLL_FUNCTION(ISteamUser*) BS_Client_GetSteamUser(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUser=_BS_Client_GetSteamUser@16")
 	return lpSteamClient->GetISteamUser(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUser=_BS_Client_GetSteamUser@16")
 
 DLL_FUNCTION(ISteamUserStats*) BS_Client_GetSteamUserStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUserStats=_BS_Client_GetSteamUserStats@16")
 	return lpSteamClient->GetISteamUserStats(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUserStats=_BS_Client_GetSteamUserStats@16")
 
 DLL_FUNCTION(ISteamUtils*) BS_Client_GetSteamUtils(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUtils=_BS_Client_GetSteamUtils@12")
 	return lpSteamClient->GetISteamUtils(hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamUtils=_BS_Client_GetSteamUtils@12")
 
 DLL_FUNCTION(ISteamVideo*) BS_Client_GetSteamVideo(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+#pragma comment(linker, "/EXPORT:BS_Client_GetSteamVideo=_BS_Client_GetSteamVideo@16")
 	return lpSteamClient->GetISteamVideo(hSteamUser, hSteamPipe, pchVersion);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_GetSteamVideo=_BS_Client_GetSteamVideo@16")
 
 // Callbacks & Hooks
 DLL_FUNCTION(void) BS_Client_SetWarningMessageHook(ISteamClient* lpSteamClient, SteamAPIWarningMessageHook_t fpfunction) {
+#pragma comment(linker, "/EXPORT:BS_Client_SetWarningMessageHook=_BS_Client_SetWarningMessageHook@8")
 	lpSteamClient->SetWarningMessageHook(fpfunction);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_SetWarningMessageHook=_BS_Client_SetWarningMessageHook@8")
 
 DLL_FUNCTION(void) BS_Client_Set_SteamAPI_CPostAPIResultInProcess(ISteamClient* lpSteamClient, SteamAPI_PostAPIResultInProcess_t fpFunction) {
+#pragma comment(linker, "/EXPORT:BS_Client_Set_SteamAPI_CPostAPIResultInProcess=_BS_Client_Set_SteamAPI_CPostAPIResultInProcess@8")
 	lpSteamClient->Set_SteamAPI_CPostAPIResultInProcess(fpFunction);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_Set_SteamAPI_CPostAPIResultInProcess=_BS_Client_Set_SteamAPI_CPostAPIResultInProcess@8")
 
 DLL_FUNCTION(void) BS_Client_Remove_SteamAPI_CPostAPIResultInProcess(ISteamClient* lpSteamClient, SteamAPI_PostAPIResultInProcess_t fpFunction) {
+#pragma comment(linker, "/EXPORT:BS_Client_Remove_SteamAPI_CPostAPIResultInProcess=_BS_Client_Remove_SteamAPI_CPostAPIResultInProcess@8")
 	lpSteamClient->Remove_SteamAPI_CPostAPIResultInProcess(fpFunction);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_Remove_SteamAPI_CPostAPIResultInProcess=_BS_Client_Remove_SteamAPI_CPostAPIResultInProcess@8")
 
 DLL_FUNCTION(void) BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess(ISteamClient* lpSteamClient, SteamAPI_CheckCallbackRegistered_t fpFunction) {
+#pragma comment(linker, "/EXPORT:BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess=_BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess@8")
 	lpSteamClient->Set_SteamAPI_CCheckCallbackRegisteredInProcess(fpFunction);
 }
-#pragma comment(linker, "/EXPORT:BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess=_BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess@8")

Wrapper/SteamController.cpp

@@ -17,38 +17,123 @@
 #include "BlitzSteam.h"
 
 DLL_FUNCTION(ISteamController*) BS_Controller() {
+#pragma comment(linker, "/EXPORT:BS_Controller=_BS_Controller@0")
 	return SteamController();
 }
-#pragma comment(linker, "/EXPORT:BS_Controller=_BS_Controller@0")
 
+// Init and Shutdown must be called when starting/ending use of this interface
 DLL_FUNCTION(uint32_t) BS_Controller_Init(ISteamController* lpSteamController) {
+#pragma comment(linker, "/EXPORT:BS_Controller_Init=_BS_Controller_Init@4")
 	return lpSteamController->Init();
 }
-#pragma comment(linker, "/EXPORT:BS_Controller_Init=_BS_Controller_Init@4")
 
+// Init and Shutdown must be called when starting/ending use of this interface
 DLL_FUNCTION(uint32_t) BS_Controller_Shutdown(ISteamController* lpSteamController) {
+#pragma comment(linker, "/EXPORT:BS_Controller_Shutdown=_BS_Controller_Shutdown@4")
 	return lpSteamController->Shutdown();
 }
-#pragma comment(linker, "/EXPORT:BS_Controller_Shutdown=_BS_Controller_Shutdown@4")
 
+// Pump callback/callresult events
+// Note: SteamAPI_RunCallbacks will do this for you, so you should never need to call this directly.
 DLL_FUNCTION(void) BS_Controller_RunFrame(ISteamController* lpSteamController) {
+#pragma comment(linker, "/EXPORT:BS_Controller_RunFrame=_BS_Controller_RunFrame@4")
 	lpSteamController->RunFrame();
 }
-#pragma comment(linker, "/EXPORT:BS_Controller_RunFrame=_BS_Controller_RunFrame@4")
 
-#if 0
+// Enumerate currently connected controllers
-DLL_FUNCTION(uint32_t) BS_Controller_GetControllerState( ISteamController* lpSteamController, uint32_t unControllerIndex, SteamControllerState_t *pState ) {
+// handlesOut should point to a STEAM_CONTROLLER_MAX_COUNT sized array of ControllerHandle_t handles
-	return lpSteamController->GetControllerState( unControllerIndex, pState );
+// Returns the number of handles written to handlesOut
+DLL_FUNCTION(uint32_t) BS_Controller_GetConnectedControllersEx(ISteamController* lpSteamController, ControllerHandle_t* pHandlesOut) {
+#pragma comment(linker, "/EXPORT:BS_Controller_GetConnectedControllersEx=_BS_Controller_GetConnectedControllersEx@8")
+	return lpSteamController->GetConnectedControllers(pHandlesOut);
 }
-#pragma comment(linker, "/EXPORT:BS_Controller_GetControllerState=_BS_Controller_GetControllerState@12")
 
-DLL_FUNCTION(void) BS_Controller_TriggerHapticPulse( ISteamController* lpSteamController, uint32_t unControllerIndex, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec ) {
+ControllerHandle_t* pControllerHandles = new ControllerHandle_t[STEAM_CONTROLLER_MAX_COUNT];
-	lpSteamController->TriggerHapticPulse( unControllerIndex, eTargetPad, usDurationMicroSec );
+DLL_FUNCTION(uint32_t) BS_Controller_GetConnectedControllers(ISteamController* lpSteamController) {
+#pragma comment(linker, "/EXPORT:BS_Controller_GetConnectedControllers=_BS_Controller_GetConnectedControllers@4")
+	return lpSteamController->GetConnectedControllers(pControllerHandles);
 }
+
+DLL_FUNCTION(ControllerHandle_t*) BS_Controller_GetConnectedControllers_Index(uint32_t index) {
+#pragma comment(linker, "/EXPORT:BS_Controller_GetConnectedControllers_Index=_BS_Controller_GetConnectedControllers_Index@4")
+	if (index >= STEAM_CONTROLLER_MAX_COUNT)
+		index = STEAM_CONTROLLER_MAX_COUNT - 1;
+	return &(pControllerHandles[index]);
+}
+
+// Invokes the Steam overlay and brings up the binding screen
+// Returns false is overlay is disabled / unavailable, or the user is not in Big Picture mode
+DLL_FUNCTION(uint32_t) BS_Controller_ShowBindingPanel(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle) {
+#pragma comment(linker, "/EXPORT:BS_Controller_ShowBindingPanel=_BS_Controller_ShowBindingPanel@8")
+	return lpSteamController->ShowBindingPanel(*pControllerHandle);
+}
+
+// ACTION SETS
+// Lookup the handle for an Action Set. Best to do this once on startup, and store the handles for all future API calls.
+DLL_FUNCTION(ControllerActionSetHandle_t*) BS_Controller_GetActionSetHandle(ISteamController* lpSteamController, const char* pszActionSetName) {
+#pragma comment(linker, "/EXPORT:BS_Controller_GetActionSetHandle=_BS_Controller_GetActionSetHandle@8")
+	return new ControllerActionSetHandle_t(lpSteamController->GetActionSetHandle(pszActionSetName));
+}
+
+// Reconfigure the controller to use the specified action set (ie 'Menu', 'Walk' or 'Drive')
+// This is cheap, and can be safely called repeatedly. It's often easier to repeatedly call it in
+// your state loops, instead of trying to place it in all of your state transitions.
+DLL_FUNCTION(void) BS_Controller_ActivateActionSet(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle) {
+#pragma comment(linker, "/EXPORT:BS_Controller_ActivateActionSet=_BS_Controller_ActivateActionSet@12")
+	lpSteamController->ActivateActionSet(*pControllerHandle, *pActionSetHandle);
+}
+
+DLL_FUNCTION(ControllerActionSetHandle_t*) BS_Controller_GetCurrentActionSet(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle) {
+#pragma comment(linker, "/EXPORT:BS_Controller_GetCurrentActionSet=_BS_Controller_GetCurrentActionSet@8")
+	return new ControllerActionSetHandle_t(lpSteamController->GetCurrentActionSet(*pControllerHandle));
+}
+
+// Lookup the handle for a digital action. Best to do this once on startup, and store the handles for all future API calls.
+DLL_FUNCTION(ControllerDigitalActionHandle_t*) BS_Controller_GetDigitalActionHandle(ISteamController* lpSteamController, const char* pszActionName) {
+#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionHandle=_BS_Controller_GetDigitalActionHandle@8")
+	return new ControllerDigitalActionHandle_t(lpSteamController->GetDigitalActionHandle(pszActionName));
+}
+
+// Returns the current state of the supplied digital game action
+DLL_FUNCTION(ControllerDigitalActionData_t*) BS_Controller_GetDigitalActionData(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerDigitalActionHandle_t* pDigitalActionHandle) {
+#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionData=_BS_Controller_GetDigitalActionData@12")
+	return &lpSteamController->GetDigitalActionData(*pControllerHandle, *pDigitalActionHandle);
+}
+
+// Get the origin(s) for a digital action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action.
+// originsOut should point to a STEAM_CONTROLLER_MAX_ORIGINS sized array of EControllerActionOrigin handles
+DLL_FUNCTION(int32_t) BS_Controller_GetDigitalActionOrigins(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle, ControllerDigitalActionHandle_t* pDigitalActionHandle, EControllerActionOrigin *pEControllerActionOrigin) {
+#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionOrigins=_BS_Controller_GetDigitalActionOrigins@20")
+	return lpSteamController->GetDigitalActionOrigins(*pControllerHandle, *pActionSetHandle, *pDigitalActionHandle, pEControllerActionOrigin);
+}
+
+// Lookup the handle for an analog action. Best to do this once on startup, and store the handles for all future API calls.
+DLL_FUNCTION(ControllerAnalogActionHandle_t*) BS_Controller_GetAnalogActionHandle(ISteamController* lpSteamController, const char *pszActionName) {
+#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionOrigins=_BS_Controller_GetDigitalActionOrigins@20")
+	return new ControllerAnalogActionHandle_t(lpSteamController->GetAnalogActionHandle(pszActionName));
+	//BlitzSteam: Cleanup using BS_Helper_DeleteLongLong
+}
+
+// Returns the current state of these supplied analog game action
+DLL_FUNCTION(ControllerAnalogActionData_t*) BS_Controller_GetAnalogActionData(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle) {
+#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionOrigins=_BS_Controller_GetDigitalActionOrigins@20")
+	return &lpSteamController->GetAnalogActionData(*pControllerHandle, *pAnalogActionHandle);
+}
+
+// Get the origin(s) for an analog action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action.
+// originsOut should point to a STEAM_CONTROLLER_MAX_ORIGINS sized array of EControllerActionOrigin handles
+DLL_FUNCTION(uint32_t) BS_Controller_GetAnalogActionOrigins(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerActionSetHandle_t* pActionSetHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle, EControllerActionOrigin *pEControllerActionOrigin) {
+#pragma comment(linker, "/EXPORT:BS_Controller_GetDigitalActionOrigins=_BS_Controller_GetDigitalActionOrigins@20")
+	return lpSteamController->GetAnalogActionOrigins(*pControllerHandle, *pActionSetHandle, *pAnalogActionHandle, pEControllerActionOrigin);
+}
+
+DLL_FUNCTION(void) BS_Controller_StopAnalogActionMomentum(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ControllerAnalogActionHandle_t* pAnalogActionHandle) {
+#pragma comment(linker, "/EXPORT:BS_Controller_StopAnalogActionMomentum=_BS_Controller_StopAnalogActionMomentum@12")
+	lpSteamController->StopAnalogActionMomentum(*pControllerHandle, *pAnalogActionHandle);
+}
+
+// Trigger a haptic pulse on a controller
+DLL_FUNCTION(void) BS_Controller_TriggerHapticPulse(ISteamController* lpSteamController, ControllerHandle_t* pControllerHandle, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec) {
 #pragma comment(linker, "/EXPORT:BS_Controller_TriggerHapticPulse=_BS_Controller_TriggerHapticPulse@16")
-
+	lpSteamController->TriggerHapticPulse(*pControllerHandle, eTargetPad, (uint16_t)usDurationMicroSec);
-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")  
-#endif // 0

Wrapper/SteamFriends.cpp

@@ -17,365 +17,361 @@
 #include "BlitzSteam.h"
 
 DLL_FUNCTION(ISteamFriends*) BS_Friends() {
+#pragma comment(linker, "/EXPORT:BS_Friends=_BS_Friends@0")
 	return SteamFriends();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends=_BS_Friends@0")
 
 DLL_FUNCTION(const char*) BS_Friends_GetPersonaName(ISteamFriends* lpSteamFriends) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetPersonaName=_BS_Friends_GetPersonaName@4")
 	return lpSteamFriends->GetPersonaName();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetPersonaName=_BS_Friends_GetPersonaName@4")
 
 DLL_FUNCTION(SteamAPICall_t*) BS_Friends_SetPersonaName(ISteamFriends* lpSteamFriends, const char* pchPersonaName) {
+#pragma comment(linker, "/EXPORT:BS_Friends_SetPersonaName=_BS_Friends_SetPersonaName@8")
 	return new uint64_t(lpSteamFriends->SetPersonaName(pchPersonaName));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_SetPersonaName=_BS_Friends_SetPersonaName@8")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetPersonaState(ISteamFriends* lpSteamFriends) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetPersonaState=_BS_Friends_GetPersonaState@4")
 	return lpSteamFriends->GetPersonaState();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetPersonaState=_BS_Friends_GetPersonaState@4")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetFriendCount(ISteamFriends* lpSteamFriends, int32_t iFriendFlags) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCount=_BS_Friends_GetFriendCount@8")
 	return lpSteamFriends->GetFriendCount(iFriendFlags);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCount=_BS_Friends_GetFriendCount@8")
 
 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")
+	return new CSteamID(lpSteamFriends->GetFriendByIndex(iFriend, iFriendFlags));
+}
 
 DLL_FUNCTION(EFriendRelationship) BS_Friends_GetFriendRelationship(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRelationship=_BS_Friends_GetFriendRelationship@8")
 	return lpSteamFriends->GetFriendRelationship(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRelationship=_BS_Friends_GetFriendRelationship@8")
 
 DLL_FUNCTION(EPersonaState) BS_Friends_GetFriendPersonaState(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaState=_BS_Friends_GetFriendPersonaState@8")
 	return lpSteamFriends->GetFriendPersonaState(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaState=_BS_Friends_GetFriendPersonaState@8")
 
 DLL_FUNCTION(const char*) BS_Friends_GetFriendPersonaName(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaName=_BS_Friends_GetFriendPersonaName@8")
 	return lpSteamFriends->GetFriendPersonaName(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaName=_BS_Friends_GetFriendPersonaName@8")
 
 DLL_FUNCTION(uint32_t) BS_Friends_GetFriendGamePlayed(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, FriendGameInfo_t *pFriendGameInfo) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendGamePlayed=_BS_Friends_GetFriendGamePlayed@12")
 	return lpSteamFriends->GetFriendGamePlayed(*steamIDFriend, pFriendGameInfo);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendGamePlayed=_BS_Friends_GetFriendGamePlayed@12")
 
 DLL_FUNCTION(const char*) BS_Friends_GetFriendPersonaNameHistory(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iPersonaName) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaNameHistory=_BS_Friends_GetFriendPersonaNameHistory@12")
 	return lpSteamFriends->GetFriendPersonaNameHistory(*steamIDFriend, iPersonaName);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaNameHistory=_BS_Friends_GetFriendPersonaNameHistory@12")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetFriendSteamLevel(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendSteamLevel=_BS_Friends_GetFriendSteamLevel@8")
 	return lpSteamFriends->GetFriendSteamLevel(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendSteamLevel=_BS_Friends_GetFriendSteamLevel@8")
 
 DLL_FUNCTION(const char*) BS_Friends_GetPlayerNickname(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriends) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetPlayerNickname=_BS_Friends_GetPlayerNickname@8")
 	const char* nickname = lpSteamFriends->GetPlayerNickname(*steamIDFriends);
 	if (nickname == NULL) {
 		nickname = "";
 	}
 	return nickname;
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetPlayerNickname=_BS_Friends_GetPlayerNickname@8")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetFriendsGroupCount(ISteamFriends* lpSteamFriends) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupCount=_BS_Friends_GetFriendsGroupCount@4")
 	return lpSteamFriends->GetFriendsGroupCount();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupCount=_BS_Friends_GetFriendsGroupCount@4")
 
 DLL_FUNCTION(FriendsGroupID_t) BS_Friends_GetFriendsGroupIDByIndex(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupIDByIndex=_BS_Friends_GetFriendsGroupIDByIndex@8")
 	return lpSteamFriends->GetFriendsGroupIDByIndex(friendsGroupID);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupIDByIndex=_BS_Friends_GetFriendsGroupIDByIndex@8")
 
 DLL_FUNCTION(const char*) BS_Friends_GetFriendsGroupName(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupName=_BS_Friends_GetFriendsGroupName@8")
 	return lpSteamFriends->GetFriendsGroupName(friendsGroupID);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupName=_BS_Friends_GetFriendsGroupName@8")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetFriendsGroupMembersCount(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupMembersCount=_BS_Friends_GetFriendsGroupMembersCount@8")
 	return lpSteamFriends->GetFriendsGroupMembersCount(friendsGroupID);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupMembersCount=_BS_Friends_GetFriendsGroupMembersCount@8")
 
 DLL_FUNCTION(void) BS_Friends_GetFriendsGroupMembersList(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID, CSteamID* pOutSteamIDMembers, int32_t nMembersCount) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupMembersList=_BS_Friends_GetFriendsGroupMembersList@16")
 	lpSteamFriends->GetFriendsGroupMembersList(friendsGroupID, pOutSteamIDMembers, nMembersCount);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupMembersList=_BS_Friends_GetFriendsGroupMembersList@16")
 
 DLL_FUNCTION(uint32_t) BS_Friends_HasFriend(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iFriendsFlags) {
+#pragma comment(linker, "/EXPORT:BS_Friends_HasFriends=_BS_Friends_HasFriend@12")
 	return lpSteamFriends->HasFriend(*steamIDFriend, iFriendsFlags);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_HasFriends=_BS_Friends_HasFriend@12")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetClanCount(ISteamFriends* lpSteamFriends) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetClanCount=_BS_Friends_GetClanCount@4")
 	return lpSteamFriends->GetClanCount();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanCount=_BS_Friends_GetClanCount@4")
 
 DLL_FUNCTION(CSteamID*) BS_Friends_GetClanByIndex(ISteamFriends* lpSteamFriends, int32_t iClan) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetClanByIndex=_BS_Friends_GetClanByIndex@8")
 	CSteamID* steamID = new CSteamID(lpSteamFriends->GetClanByIndex(iClan));
 	return steamID;
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanByIndex=_BS_Friends_GetClanByIndex@8")
 
 DLL_FUNCTION(const char*) BS_Friends_GetClanName(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetClanName=_BS_Friends_GetClanName@8")
 	return lpSteamFriends->GetClanName(*steamIDClan);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanName=_BS_Friends_GetClanName@8")
 
 DLL_FUNCTION(const char*) BS_Friends_GetClanTag(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetClanTag=_BS_Friends_GetClanTag@8")
 	return lpSteamFriends->GetClanTag(*steamIDClan);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanTag=_BS_Friends_GetClanTag@8")
 
 DLL_FUNCTION(uint32_t) BS_Friends_GetClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t* pnOnline, int32_t* pnInGame, int32_t* pnChatting) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetClanActivityCounts=_BS_Friends_GetClanActivityCounts@20")
 	return lpSteamFriends->GetClanActivityCounts(*steamIDClan, pnOnline, pnInGame, pnChatting);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanActivityCounts=_BS_Friends_GetClanActivityCounts@20")
 
 DLL_FUNCTION(SteamAPICall_t*) BS_Friends_DownloadClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* psteamIDClans, int32_t cClansToRequest) {
+#pragma comment(linker, "/EXPORT:BS_Friends_DownloadClanActivityCounts=_BS_Friends_DownloadClanActivityCounts@12")
 	return new uint64_t(lpSteamFriends->DownloadClanActivityCounts(psteamIDClans, cClansToRequest));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_DownloadClanActivityCounts=_BS_Friends_DownloadClanActivityCounts@12")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetFriendCountFromSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCountFromSource=_BS_Friends_GetFriendCountFromSource@8")
 	return lpSteamFriends->GetFriendCountFromSource(*steamIDSource);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCountFromSource=_BS_Friends_GetFriendCountFromSource@8")
 
 DLL_FUNCTION(CSteamID*) BS_Friends_GetFriendFromSourceByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource, int32_t iFriend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendFromSourceByIndex=_BS_Friends_GetFriendFromSourceByIndex@12")
 	return new CSteamID(lpSteamFriends->GetFriendFromSourceByIndex(*steamIDSource, iFriend));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendFromSourceByIndex=_BS_Friends_GetFriendFromSourceByIndex@12")
 
 DLL_FUNCTION(uint32_t) BS_Friends_IsUserInSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, CSteamID* steamIDSource) {
+#pragma comment(linker, "/EXPORT:BS_Friends_IsUserInSource=_BS_Friends_IsUserInSource@12")
 	return lpSteamFriends->IsUserInSource(*steamIDUser, *steamIDSource);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_IsUserInSource=_BS_Friends_IsUserInSource@12")
 
 DLL_FUNCTION(void) BS_Friends_SetInGameVoiceSpeaking(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bSpeaking) {
+#pragma comment(linker, "/EXPORT:BS_Friends_SetInGameVoiceSpeaking=_BS_Friends_SetInGameVoiceSpeaking@12")
 	lpSteamFriends->SetInGameVoiceSpeaking(*steamIDUser, bSpeaking != 0);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_SetInGameVoiceSpeaking=_BS_Friends_SetInGameVoiceSpeaking@12")
 
 DLL_FUNCTION(void) BS_Friends_ActivateGameOverlay(ISteamFriends* lpSteamFriends, const char* pchDialog) {
+#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlay=_BS_Friends_ActivateGameOverlay@8")
 	lpSteamFriends->ActivateGameOverlay(pchDialog);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlay=_BS_Friends_ActivateGameOverlay@8")
 
 DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayToUser(ISteamFriends* lpSteamFriends, const char* pchDialog, CSteamID* steamID) {
+#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToUser=_BS_Friends_ActivateGameOverlayToUser@12")
 	lpSteamFriends->ActivateGameOverlayToUser(pchDialog, *steamID);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToUser=_BS_Friends_ActivateGameOverlayToUser@12")
 
 DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayToWebPage(ISteamFriends* lpSteamFriends, const char* pchURL) {
+#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToWebPage=_BS_Friends_ActivateGameOverlayToWebPage@8")
 	lpSteamFriends->ActivateGameOverlayToWebPage(pchURL);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToWebPage=_BS_Friends_ActivateGameOverlayToWebPage@8")
 
 DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayToStore(ISteamFriends* lpSteamFriends, AppId_t nAppID, EOverlayToStoreFlag eFlag) {
+#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToStore=_BS_Friends_ActivateGameOverlayToStore@12")
 	lpSteamFriends->ActivateGameOverlayToStore(nAppID, eFlag);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToStore=_BS_Friends_ActivateGameOverlayToStore@12")
 
 DLL_FUNCTION(void) BS_Friends_SetPlayedWith(ISteamFriends* lpSteamFriends, CSteamID* steamIDUserPlayedWith) {
+#pragma comment(linker, "/EXPORT:BS_Friends_SetPlayedWith=_BS_Friends_SetPlayedWith@8")
 	lpSteamFriends->SetPlayedWith(*steamIDUserPlayedWith);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_SetPlayedWith=_BS_Friends_SetPlayedWith@8")
 
 DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayInviteDialog(ISteamFriends* lpSteamFriends, CSteamID* steamIDLobby) {
+#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayInviteDialog=_BS_Friends_ActivateGameOverlayInviteDialog@8")
 	lpSteamFriends->ActivateGameOverlayInviteDialog(*steamIDLobby);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayInviteDialog=_BS_Friends_ActivateGameOverlayInviteDialog@8")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetSmallFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetSmallFriendAvatar=_BS_Friends_GetSmallFriendAvatar@8")
 	return lpSteamFriends->GetSmallFriendAvatar(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetSmallFriendAvatar=_BS_Friends_GetSmallFriendAvatar@8")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetMediumFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetMediumFriendAvatar=_BS_Friends_GetMediumFriendAvatar@8")
 	return lpSteamFriends->GetMediumFriendAvatar(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetMediumFriendAvatar=_BS_Friends_GetMediumFriendAvatar@8")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetLargeFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetLargeFriendAvatar=_BS_Friends_GetLargeFriendAvatar@8")
 	return lpSteamFriends->GetLargeFriendAvatar(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetLargeFriendAvatar=_BS_Friends_GetLargeFriendAvatar@8")
 
 DLL_FUNCTION(uint32_t) BS_Friends_RequestUserInformation(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bRequireNameOnly) {
+#pragma comment(linker, "/EXPORT:BS_Friends_RequestUserInformation=_BS_Friends_RequestUserInformation@12")
 	return lpSteamFriends->RequestUserInformation(*steamIDUser, bRequireNameOnly != 0);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_RequestUserInformation=_BS_Friends_RequestUserInformation@12")
 
 DLL_FUNCTION(SteamAPICall_t*) BS_Friends_RequestClanOfficerList(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+#pragma comment(linker, "/EXPORT:BS_Friends_RequestClanOfficerList=_BS_Friends_RequestClanOfficerList@8")
 	return new uint64_t(lpSteamFriends->RequestClanOfficerList(*steamIDClan));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_RequestClanOfficerList=_BS_Friends_RequestClanOfficerList@8")
 
 DLL_FUNCTION(CSteamID*) BS_Friends_GetClanOwner(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetClanOwner=_BS_Friends_GetClanOwner@8")
 	return new CSteamID(lpSteamFriends->GetClanOwner(*steamIDClan));
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanOwner=_BS_Friends_GetClanOwner@8")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetClanOfficerCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetClanOfficerCount=_BS_Friends_GetClanOfficerCount@8")
 	return lpSteamFriends->GetClanOfficerCount(*steamIDClan);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanOfficerCount=_BS_Friends_GetClanOfficerCount@8")
 
 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")
+	return new CSteamID(lpSteamFriends->GetClanOfficerByIndex(*steamIDClan, iOfficer));
+}
 
 DLL_FUNCTION(EUserRestriction) BS_Friends_GetUserRestrictions(ISteamFriends* lpSteamFriends) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetUserRestrictions=_BS_Friends_GetUserRestrictions@4")
 	return (EUserRestriction)lpSteamFriends->GetUserRestrictions();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetUserRestrictions=_BS_Friends_GetUserRestrictions@4")
 
 DLL_FUNCTION(uint32_t) BS_Friends_SetRichPresence(ISteamFriends* lpSteamFriends, const char* pchKey, const char* pchValue) {
+#pragma comment(linker, "/EXPORT:BS_Friends_SetRichPresence=_BS_Friends_SetRichPresence@12")
 	return lpSteamFriends->SetRichPresence(pchKey, pchValue);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_SetRichPresence=_BS_Friends_SetRichPresence@12")
 
 DLL_FUNCTION(void) BS_Friends_ClearRichPresence(ISteamFriends* lpSteamFriends) {
+#pragma comment(linker, "/EXPORT:BS_Friends_ClearRichPresence=_BS_Friends_ClearRichPresence@4")
 	lpSteamFriends->ClearRichPresence();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ClearRichPresence=_BS_Friends_ClearRichPresence@4")
 
 DLL_FUNCTION(const char*) BS_Friends_GetFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchKey) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresence=_BS_Friends_GetFriendRichPresence@12")
 	return lpSteamFriends->GetFriendRichPresence(*steamIDFriend, pchKey);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresence=_BS_Friends_GetFriendRichPresence@12")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetFriendRichPresenceKeyCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresenceKeyCount=_BS_Friends_GetFriendRichPresenceKeyCount@8")
 	return lpSteamFriends->GetFriendRichPresenceKeyCount(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresenceKeyCount=_BS_Friends_GetFriendRichPresenceKeyCount@8")
 
 DLL_FUNCTION(const char*) BS_Friends_GetFriendRichPresenceKeyByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iKey) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresenceKeyByIndex=_BS_Friends_GetFriendRichPresenceKeyByIndex@12")
 	return lpSteamFriends->GetFriendRichPresenceKeyByIndex(*steamIDFriend, iKey);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresenceKeyByIndex=_BS_Friends_GetFriendRichPresenceKeyByIndex@12")
 
 DLL_FUNCTION(void) BS_Friends_RequestFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_RequestFriendRichPresence=_BS_Friends_RequestFriendRichPresence@8")
 	lpSteamFriends->RequestFriendRichPresence(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_RequestFriendRichPresence=_BS_Friends_RequestFriendRichPresence@8")
 
 DLL_FUNCTION(uint32_t) BS_Friends_InviteUserToGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char *pchConnectString) {
+#pragma comment(linker, "/EXPORT:BS_Friends_InviteUserToGame=_BS_Friends_InviteUserToGame@12")
 	return lpSteamFriends->InviteUserToGame(*steamIDFriend, pchConnectString);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_InviteUserToGame=_BS_Friends_InviteUserToGame@12")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetCoplayFriendCount(ISteamFriends* lpSteamFriends) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetCoplayFriendCount=_BS_Friends_GetCoplayFriendCount@4")
 	return lpSteamFriends->GetCoplayFriendCount();
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetCoplayFriendCount=_BS_Friends_GetCoplayFriendCount@4")
 
 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")
+	return new CSteamID(lpSteamFriends->GetCoplayFriend(iCoplayFriend));
+}
 
 DLL_FUNCTION(int32_t) BS_Friends_GetFriendCoplayTime(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCoplayTime=_BS_Friends_GetFriendCoplayTime@8")
 	return lpSteamFriends->GetFriendCoplayTime(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCoplayTime=_BS_Friends_GetFriendCoplayTime@8")
 
 DLL_FUNCTION(AppId_t) BS_Friends_GetFriendCoplayGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCoplayGame=_BS_Friends_GetFriendCoplayGame@8")
 	return lpSteamFriends->GetFriendCoplayGame(*steamIDFriend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCoplayGame=_BS_Friends_GetFriendCoplayGame@8")
 
 DLL_FUNCTION(SteamAPICall_t*) BS_Friends_JoinClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
-	return new uint64_t(lpSteamFriends->JoinClanChatRoom(*steamIDClan));
-}
 #pragma comment(linker, "/EXPORT:BS_Friends_JoinClanChatRoom=_BS_Friends_JoinClanChatRoom@8")
+	return new SteamAPICall_t(lpSteamFriends->JoinClanChatRoom(*steamIDClan));
+}
 
 DLL_FUNCTION(uint32_t) BS_Friends_LeaveClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+#pragma comment(linker, "/EXPORT:BS_Friends_LeaveClanChatRoom=_BS_Friends_LeaveClanChatRoom@8")
 	return lpSteamFriends->LeaveClanChatRoom(*steamIDClan);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_LeaveClanChatRoom=_BS_Friends_LeaveClanChatRoom@8")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetClanChatMemberCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetClanChatMemberCount=_BS_Friends_GetClanChatMemberCount@8")
 	return lpSteamFriends->GetClanChatMemberCount(*steamIDClan);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanChatMemberCount=_BS_Friends_GetClanChatMemberCount@8")
 
 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")
+	return new CSteamID(lpSteamFriends->GetChatMemberByIndex(*steamIDClan, iUser));
+}
 
 DLL_FUNCTION(uint32_t) BS_Friends_SendClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, const char *pchText) {
+#pragma comment(linker, "/EXPORT:BS_Friends_SendClanChatMessage=_BS_Friends_SendClanChatMessage@12")
 	return lpSteamFriends->SendClanChatMessage(*steamIDClanChat, pchText);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_SendClanChatMessage=_BS_Friends_SendClanChatMessage@12")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, int32_t iMessage, void* prgchText, int32_t cchTextMax, EChatEntryType* peChatEntryType, CSteamID* psteamidChatter) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetClanChatMessage=_BS_Friends_GetClanChatMessage@28")
 	return lpSteamFriends->GetClanChatMessage(*steamIDClanChat, iMessage, prgchText, cchTextMax, peChatEntryType, psteamidChatter);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetClanChatMessage=_BS_Friends_GetClanChatMessage@28")
 
 DLL_FUNCTION(uint32_t) BS_Friends_IsClanChatAdmin(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, CSteamID* steamIDUser) {
+#pragma comment(linker, "/EXPORT:BS_Friends_IsClanChatAdmin=_BS_Friends_IsClanChatAdmin@12")
 	return lpSteamFriends->IsClanChatAdmin(*steamIDClanChat, *steamIDUser);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_IsClanChatAdmin=_BS_Friends_IsClanChatAdmin@12")
 
 DLL_FUNCTION(uint32_t) BS_Friends_IsClanChatWindowOpenInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
+#pragma comment(linker, "/EXPORT:BS_Friends_IsClanChatWindowOpenInSteam=_BS_Friends_IsClanChatWindowOpenInSteam@8")
 	return lpSteamFriends->IsClanChatWindowOpenInSteam(*steamIDClanChat);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_IsClanChatWindowOpenInSteam=_BS_Friends_IsClanChatWindowOpenInSteam@8")
 
 DLL_FUNCTION(uint32_t) BS_Friends_OpenClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
+#pragma comment(linker, "/EXPORT:BS_Friends_OpenClanChatWindowInSteam=_BS_Friends_OpenClanChatWindowInSteam@8")
 	return lpSteamFriends->OpenClanChatWindowInSteam(*steamIDClanChat);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_OpenClanChatWindowInSteam=_BS_Friends_OpenClanChatWindowInSteam@8")
 
 DLL_FUNCTION(uint32_t) BS_Friends_CloseClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
+#pragma comment(linker, "/EXPORT:BS_Friends_CloseClanChatWindowInSteam=_BS_Friends_CloseClanChatWindowInSteam@8")
 	return lpSteamFriends->CloseClanChatWindowInSteam(*steamIDClanChat);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_CloseClanChatWindowInSteam=_BS_Friends_CloseClanChatWindowInSteam@8")
 
 DLL_FUNCTION(uint32_t) BS_Friends_SetListenForFriendsMessages(ISteamFriends* lpSteamFriends, uint32_t bInterceptEnabled) {
+#pragma comment(linker, "/EXPORT:BS_Friends_SetListenForFriendsMessages=_BS_Friends_SetListenForFriendsMessages@8")
 	return lpSteamFriends->SetListenForFriendsMessages(bInterceptEnabled != 0);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_SetListenForFriendsMessages=_BS_Friends_SetListenForFriendsMessages@8")
 
 DLL_FUNCTION(uint32_t) BS_Friends_ReplyToFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchMsgToSend) {
+#pragma comment(linker, "/EXPORT:BS_Friends_ReplyToFriendMessage=_BS_Friends_ReplyToFriendMessage@12")
 	return lpSteamFriends->ReplyToFriendMessage(*steamIDFriend, pchMsgToSend);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_ReplyToFriendMessage=_BS_Friends_ReplyToFriendMessage@12")
 
 DLL_FUNCTION(int32_t) BS_Friends_GetFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iMessageID, void* pvData, int32_t cubData, EChatEntryType* peChatEntryType) {
+#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendMessage=_BS_Friends_GetFriendMessage@24")
 	return lpSteamFriends->GetFriendMessage(*steamIDFriend, iMessageID, pvData, cubData, peChatEntryType);
 }
-#pragma comment(linker, "/EXPORT:BS_Friends_GetFriendMessage=_BS_Friends_GetFriendMessage@24")
 
 DLL_FUNCTION(SteamAPICall_t*) BS_Friends_GetFollowerCount(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
-	return new uint64_t(lpSteamFriends->GetFollowerCount(*steamID));
-}
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFollowerCount=_BS_Friends_GetFollowerCount@8")
+	return new SteamAPICall_t(lpSteamFriends->GetFollowerCount(*steamID));
+}
 
 DLL_FUNCTION(SteamAPICall_t*) BS_Friends_IsFollowing(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
-	return new uint64_t(lpSteamFriends->IsFollowing(*steamID));
-}
 #pragma comment(linker, "/EXPORT:BS_Friends_IsFollowing=_BS_Friends_IsFollowing@8")
+	return new SteamAPICall_t(lpSteamFriends->IsFollowing(*steamID));
+}
 
 DLL_FUNCTION(SteamAPICall_t*) BS_Friends_EnumerateFollowingList(ISteamFriends* lpSteamFriends, uint32_t unStartIndex) {
-	return new uint64_t(lpSteamFriends->EnumerateFollowingList(unStartIndex));
-}
 #pragma comment(linker, "/EXPORT:BS_Friends_EnumerateFollowingList=_BS_Friends_EnumerateFollowingList@8")
+	return new SteamAPICall_t(lpSteamFriends->EnumerateFollowingList(unStartIndex));
+}

Wrapper/SteamGameServer.cpp

@@ -16,42 +16,42 @@
 
 #include "BlitzSteam.h"
 
+DLL_FUNCTION(uint32_t) BS_SteamGameServer_Init(uint32_t unIP, uint16_t usSteamPort, uint16_t usGamePort, uint16_t usQueryPort, EServerMode eServerMode, const char *pchVersionString) {
+#pragma comment(linker, "/EXPORT:BS_SteamGameServer_Init=_BS_SteamGameServer_Init@24")
+	return SteamGameServer_Init(unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString);
+}
+
+DLL_FUNCTION(void) BS_SteamGameServer_Shutdown() {
+#pragma comment(linker, "/EXPORT:BS_SteamGameServer_Shutdown=_BS_SteamGameServer_Shutdown@0")
+	SteamGameServer_Shutdown();
+}
+
+DLL_FUNCTION(void) BS_SteamGameServer_RunCallbacks() {
+#pragma comment(linker, "/EXPORT:BS_SteamGameServer_RunCallbacks=_BS_SteamGameServer_RunCallbacks@0")
+	SteamGameServer_RunCallbacks();
+}
+
+DLL_FUNCTION(HSteamPipe) BS_SteamGameServer_GetHSteamPipe() {
+#pragma comment(linker, "/EXPORT:BS_SteamGameServer_GetHSteamPipe=_BS_SteamGameServer_GetHSteamPipe@0")
+	return SteamGameServer_GetHSteamPipe();
+}
+
+DLL_FUNCTION(uint32_t) BS_SteamGameServer_IsSecure() {
+#pragma comment(linker, "/EXPORT:BS_SteamGameServer_IsSecure=_BS_SteamGameServer_IsSecure@0")
+	return SteamGameServer_BSecure();
+}
+
+DLL_FUNCTION(CSteamID*) BS_SteamGameServer_GetSteamID() {
+#pragma comment(linker, "/EXPORT:BS_SteamGameServer_GetSteamID=_BS_SteamGameServer_GetSteamID@0")
+	return new CSteamID(SteamGameServer_GetSteamID());
+}
+
+// ISteamGameServer Stuff
 DLL_FUNCTION(ISteamGameServer*) BS_GameServer() {
 #pragma comment(linker, "/EXPORT:BS_GameServer=_BS_GameServer@0")
 	return SteamGameServer();
 }
 
-DLL_FUNCTION(uint32_t) BS_GameServer_Init(uint32_t unIP, uint16_t usSteamPort, uint16_t usGamePort, uint16_t usQueryPort, EServerMode eServerMode, const char *pchVersionString) {
-#pragma comment(linker, "/EXPORT:BS_GameServer_Init=_BS_GameServer_Init@24")
-	return SteamGameServer_Init(unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString);
-}
-
-DLL_FUNCTION(void) BS_GameServer_Shutdown() {
-#pragma comment(linker, "/EXPORT:BS_GameServer_Shutdown=_BS_GameServer_Shutdown@0")
-	SteamGameServer_Shutdown();
-}
-
-DLL_FUNCTION(void) BS_GameServer_RunCallbacks() {
-#pragma comment(linker, "/EXPORT:BS_GameServer_RunCallbacks=_BS_GameServer_RunCallbacks@0")
-	SteamGameServer_RunCallbacks();
-}
-
-DLL_FUNCTION(HSteamPipe) BS_GameServer_GetHSteamPipe() {
-#pragma comment(linker, "/EXPORT:BS_GameServer_GetHSteamPipe=_BS_GameServer_GetHSteamPipe@0")
-	return SteamGameServer_GetHSteamPipe();
-}
-
-DLL_FUNCTION(uint32_t) BS_GameServer_IsSecureC() {
-#pragma comment(linker, "/EXPORT:BS_GameServer_IsSecureC=_BS_GameServer_IsSecureC@0")
-	return SteamGameServer_BSecure();
-}
-
-DLL_FUNCTION(CSteamID*) BS_GameServer_GetSteamIDC() {
-#pragma comment(linker, "/EXPORT:BS_GameServer_GetSteamIDC=_BS_GameServer_GetSteamIDC@0")
-	return new CSteamID(SteamGameServer_GetSteamID());
-}
-
-// ISteamGameServer Stuff
 DLL_FUNCTION(uint32_t) BS_GameServer_InitGameServer(ISteamGameServer* pSteamGameServer, uint32_t unIP, uint16_t usGamePort, uint16_t usQueryPort, uint32_t unFlags, AppId_t nGameAppId, const char *pchVersionString) {
 #pragma comment(linker, "/EXPORT:BS_GameServer_InitGameServer=_BS_GameServer_InitGameServer@28")
 	return pSteamGameServer->InitGameServer(unIP, usGamePort, usQueryPort, unFlags, nGameAppId, pchVersionString);
@@ -264,10 +264,10 @@ DLL_FUNCTION(void) BS_GameServer_ForceHeartbeat(ISteamGameServer* pSteamGameServ
 
 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));
+	return new SteamAPICall_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));
+	return new SteamAPICall_t(pSteamGameServer->ComputeNewPlayerCompatibility(*pSteamIDNewPlayer));
 }

Wrapper/SteamGameServerStats.cpp

@@ -22,42 +22,52 @@ DLL_FUNCTION(ISteamGameServerStats*) BS_GameServerStats() {
 }
 
 DLL_FUNCTION(SteamAPICall_t*) BS_GameServerStats_RequestUserStats(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser) {
-	return new uint64_t(pSteamGameServerStats->RequestUserStats(*steamIDUser));
+#pragma comment(linker, "/EXPORT:BS_GameServerStats_RequestUserStats=_BS_GameServerStats_RequestUserStats@8")
+	return new SteamAPICall_t(pSteamGameServerStats->RequestUserStats(*steamIDUser));
 }
 
 DLL_FUNCTION(SteamAPICall_t*) BS_GameServerStats_StoreUserStats(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser) {
-	return new uint64_t(pSteamGameServerStats->StoreUserStats(*steamIDUser));
+#pragma comment(linker, "/EXPORT:BS_GameServerStats_StoreUserStats=_BS_GameServerStats_StoreUserStats@8")
+	return new SteamAPICall_t(pSteamGameServerStats->StoreUserStats(*steamIDUser));
 }
 
 DLL_FUNCTION(uint32_t) BS_GameServerStats_GetUserStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pData) {
+#pragma comment(linker, "/EXPORT:BS_GameServerStats_GetUserStat=_BS_GameServerStats_GetUserStat@16")
 	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) {
+#pragma comment(linker, "/EXPORT:BS_GameServerStats_GetUserStatF=_BS_GameServerStats_GetUserStatF@16")
 	return pSteamGameServerStats->GetUserStat(*steamIDUser, pchName, pData);
 }
 
 DLL_FUNCTION(uint32_t) BS_GameServerStats_GetUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pbAchieved) {
+#pragma comment(linker, "/EXPORT:BS_GameServerStats_GetUserAchievement=_BS_GameServerStats_GetUserAchievement@16")
 	return pSteamGameServerStats->GetUserAchievement(*steamIDUser, pchName, (bool*)pbAchieved);
 }
 
 DLL_FUNCTION(uint32_t) BS_GameServerStats_SetUserStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t nData) {
+#pragma comment(linker, "/EXPORT:BS_GameServerStats_SetUserStat=_BS_GameServerStats_SetUserStat@16")
 	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) {
+#pragma comment(linker, "/EXPORT:BS_GameServerStats_SetUserStatF=_BS_GameServerStats_SetUserStatF@16")
 	return pSteamGameServerStats->SetUserStat(*steamIDUser, pchName, fData);
 }
 
 DLL_FUNCTION(uint32_t) BS_GameServerStats_UpdateUserAvgRateStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char *pchName, float flCountThisSession, double* pdSessionLength) {
+#pragma comment(linker, "/EXPORT:BS_GameServerStats_UpdateUserAvgRateStat=_BS_GameServerStats_UpdateUserAvgRateStat@20")
 	return pSteamGameServerStats->UpdateUserAvgRateStat(*steamIDUser, pchName, flCountThisSession, *pdSessionLength);
 }
 
 DLL_FUNCTION(uint32_t) BS_GameServerStats_SetUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName) {
+#pragma comment(linker, "/EXPORT:BS_GameServerStats_SetUserAchievement=_BS_GameServerStats_SetUserAchievement@12")
 	return pSteamGameServerStats->SetUserAchievement(*steamIDUser, pchName);
 }
 
 DLL_FUNCTION(uint32_t) BS_GameServerStats_ClearUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName) {
+#pragma comment(linker, "/EXPORT:BS_GameServerStats_ClearUserAchievement=_BS_GameServerStats_ClearUserAchievement@12")
 	return pSteamGameServerStats->ClearUserAchievement(*steamIDUser, pchName);
 }
 

Wrapper/SteamHTMLSurface.cpp

@@ -15,9 +15,231 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "BlitzSteam.h"
+#include "SteamworksSDK/public/steam/isteamhtmlsurface.h"
 
 DLL_FUNCTION(ISteamHTMLSurface*) BS_HTMLSurface() {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface=_BS_HTMLSurface@0")
 	return SteamHTMLSurface();
 }
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface=_BS_HTMLSurface@0")
 
+// Must call init and shutdown when starting/ending use of the interface
+DLL_FUNCTION(uint32_t) BS_HTMLSurface_Init(ISteamHTMLSurface* pSteamHTMLSurface) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_Init=_BS_HTMLSurface_Init@4")
+	return pSteamHTMLSurface->Init();
+}
+
+DLL_FUNCTION(uint32_t) BS_HTMLSurface_Shutdown(ISteamHTMLSurface* pSteamHTMLSurface) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_Shutdown=_BS_HTMLSurface_Shutdown@4")
+	return pSteamHTMLSurface->Shutdown();
+}
+
+// Create a browser object for display of a html page, when creation is complete the call handle
+// will return a HTML_BrowserReady_t callback for the HHTMLBrowser of your new browser.
+//   The user agent string is a substring to be added to the general user agent string so you can
+// identify your client on web servers.
+//   The userCSS string lets you apply a CSS style sheet to every displayed page, leave null if
+// you do not require this functionality.
+DLL_FUNCTION(SteamAPICall_t*) BS_HTMLSurface_CreateBrowser(ISteamHTMLSurface* pSteamHTMLSurface, const char* pchUserAgent, const char* pchUserCSS) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_CreateBrowser=_BS_HTMLSurface_CreateBrowser@12")
+	return new SteamAPICall_t(pSteamHTMLSurface->CreateBrowser(pchUserAgent, pchUserCSS));
+}
+
+// Call this when you are done with a html surface, this lets us free the resources being used by it
+DLL_FUNCTION(void) BS_HTMLSurface_RemoveBrowser(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_RemoveBrowser=_BS_HTMLSurface_RemoveBrowser@8")
+	pSteamHTMLSurface->RemoveBrowser(unBrowserHandle);
+}
+
+// Navigate to this URL, results in a HTML_StartRequest_t as the request commences 
+DLL_FUNCTION(void) BS_HTMLSurface_LoadURL(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char* pchURL, const char* pchPostData) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_LoadURL=_BS_HTMLSurface_LoadURL@16")
+	pSteamHTMLSurface->LoadURL(unBrowserHandle, pchURL, pchPostData);
+}
+
+// Tells the surface the size in pixels to display the surface
+DLL_FUNCTION(void) BS_HTMLSurface_SetSize(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32_t unWidth, uint32_t unHeight) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetSize=_BS_HTMLSurface_SetSize@16")
+	pSteamHTMLSurface->SetSize(unBrowserHandle, unWidth, unHeight);
+}
+
+// Stop the load of the current html page
+DLL_FUNCTION(void) BS_HTMLSurface_StopLoad(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_StopLoad=_BS_HTMLSurface_StopLoad@8")
+	pSteamHTMLSurface->StopLoad(unBrowserHandle);
+}
+
+// Reload (most likely from local cache) the current page
+DLL_FUNCTION(void) BS_HTMLSurface_Reload(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_Reload=_BS_HTMLSurface_Reload@8")
+	pSteamHTMLSurface->Reload(unBrowserHandle);
+}
+
+// navigate back in the page history
+DLL_FUNCTION(void) BS_HTMLSurface_GoBack(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_GoBack=_BS_HTMLSurface_GoBack@8")
+	pSteamHTMLSurface->GoBack(unBrowserHandle);
+}
+
+// navigate forward in the page history
+DLL_FUNCTION(void) BS_HTMLSurface_GoForward(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_GoForward=_BS_HTMLSurface_GoForward@8")
+	pSteamHTMLSurface->GoForward(unBrowserHandle);
+}
+
+// add this header to any url requests from this browser
+DLL_FUNCTION(void) BS_HTMLSurface_AddHeader(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char* pchKey, const char* pchValue) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_AddHeader=_BS_HTMLSurface_AddHeader@16")
+	pSteamHTMLSurface->AddHeader(unBrowserHandle, pchKey, pchValue);
+}
+
+// run this javascript script in the currently loaded page
+DLL_FUNCTION(void) BS_HTMLSurface_ExecuteJavascript(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char* pchScript) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_ExecuteJavascript=_BS_HTMLSurface_ExecuteJavascript@12")
+	pSteamHTMLSurface->ExecuteJavascript(unBrowserHandle, pchScript);
+}
+
+// Mouse click and mouse movement commands
+DLL_FUNCTION(void) BS_HTMLSurface_MouseUp(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_MouseUp=_BS_HTMLSurface_MouseUp@12")
+	pSteamHTMLSurface->MouseUp(unBrowserHandle, eMouseButton);
+}
+
+DLL_FUNCTION(void) BS_HTMLSurface_MouseDown(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_MouseDown=_BS_HTMLSurface_MouseDown@12")
+	pSteamHTMLSurface->MouseDown(unBrowserHandle, eMouseButton);
+}
+
+DLL_FUNCTION(void) BS_HTMLSurface_MouseDoubleClick(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, ISteamHTMLSurface::EHTMLMouseButton eMouseButton) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_MouseDoubleClick=_BS_HTMLSurface_MouseDoubleClick@12")
+	pSteamHTMLSurface->MouseDoubleClick(unBrowserHandle, eMouseButton);
+}
+
+// x and y are relative to the HTML bounds
+DLL_FUNCTION(void) BS_HTMLSurface_MouseMove(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, int32_t x, int32_t y) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_MouseMove=_BS_HTMLSurface_MouseMove@16")
+	pSteamHTMLSurface->MouseMove(unBrowserHandle, x, y);
+}
+
+// nDelta is pixels of scroll
+DLL_FUNCTION(void) BS_HTMLSurface_MouseWheel(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, int32_t nDelta) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_MouseWheel=_BS_HTMLSurface_MouseWheel@12")
+	pSteamHTMLSurface->MouseWheel(unBrowserHandle, nDelta);
+}
+
+// keyboard interactions, native keycode is the virtual key code value from your OS
+DLL_FUNCTION(void) BS_HTMLSurface_KeyDown(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_KeyDown=_BS_HTMLSurface_KeyDown@16")
+	pSteamHTMLSurface->KeyDown(unBrowserHandle, nNativeKeyCode, eHTMLKeyModifiers);
+}
+
+DLL_FUNCTION(void) BS_HTMLSurface_KeyUp(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nNativeKeyCode, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_KeyUp=_BS_HTMLSurface_KeyUp@16")
+	pSteamHTMLSurface->KeyUp(unBrowserHandle, nNativeKeyCode, eHTMLKeyModifiers);
+}
+
+// cUnicodeChar is the unicode character point for this keypress (and potentially multiple chars per press)
+DLL_FUNCTION(void) BS_HTMLSurface_KeyChar(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 cUnicodeChar, ISteamHTMLSurface::EHTMLKeyModifiers eHTMLKeyModifiers) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_KeyChar=_BS_HTMLSurface_KeyChar@16")
+	pSteamHTMLSurface->KeyChar(unBrowserHandle, cUnicodeChar, eHTMLKeyModifiers);
+}
+
+// programmatically scroll this many pixels on the page
+DLL_FUNCTION(void) BS_HTMLSurface_SetHorizontalScroll(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetHorizontalScroll=_BS_HTMLSurface_SetHorizontalScroll@12")
+	pSteamHTMLSurface->SetHorizontalScroll(unBrowserHandle, nAbsolutePixelScroll);
+}
+
+DLL_FUNCTION(void) BS_HTMLSurface_SetVerticalScroll(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, uint32 nAbsolutePixelScroll) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetVerticalScroll=_BS_HTMLSurface_SetVerticalScroll@12")
+	pSteamHTMLSurface->SetVerticalScroll(unBrowserHandle, nAbsolutePixelScroll);
+}
+
+// tell the html control if it has key focus currently, controls showing the I-beam cursor in text controls amongst other things
+DLL_FUNCTION(void) BS_HTMLSurface_SetKeyFocus(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bHasKeyFocus) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetKeyFocus=_BS_HTMLSurface_SetKeyFocus@12")
+	pSteamHTMLSurface->SetKeyFocus(unBrowserHandle, bHasKeyFocus);
+}
+
+// open the current pages html code in the local editor of choice, used for debugging
+DLL_FUNCTION(void) BS_HTMLSurface_ViewSource(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_ViewSource=_BS_HTMLSurface_ViewSource@8")
+	pSteamHTMLSurface->ViewSource(unBrowserHandle);
+}
+
+// copy the currently selected text on the html page to the local clipboard
+DLL_FUNCTION(void) BS_HTMLSurface_CopyToClipboard(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_CopyToClipboard=_BS_HTMLSurface_CopyToClipboard@8")
+	pSteamHTMLSurface->CopyToClipboard(unBrowserHandle);
+}
+
+// paste from the local clipboard to the current html page
+DLL_FUNCTION(void) BS_HTMLSurface_PasteFromClipboard(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_PasteFromClipboard=_BS_HTMLSurface_PasteFromClipboard@8")
+	pSteamHTMLSurface->PasteFromClipboard(unBrowserHandle);
+}
+
+// find this string in the browser, if bCurrentlyInFind is true then instead cycle to the next matching element
+DLL_FUNCTION(void) BS_HTMLSurface_Find(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char *pchSearchStr, bool bCurrentlyInFind, bool bReverse) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_Find=_BS_HTMLSurface_Find@20")
+	pSteamHTMLSurface->Find(unBrowserHandle, pchSearchStr, bCurrentlyInFind, bReverse);
+}
+
+// cancel a currently running find
+DLL_FUNCTION(void) BS_HTMLSurface_StopFind(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_StopFind=_BS_HTMLSurface_StopFind@8")
+	pSteamHTMLSurface->StopFind(unBrowserHandle);
+}
+
+// return details about the link at position x,y on the current page
+DLL_FUNCTION(void) BS_HTMLSurface_GetLinkAtPosition(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, int x, int y) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_GetLinkAtPosition=_BS_HTMLSurface_GetLinkAtPosition@16")
+	pSteamHTMLSurface->GetLinkAtPosition(unBrowserHandle, x, y);
+}
+
+// set a webcookie for the hostname in question
+DLL_FUNCTION(void) BS_HTMLSurface_SetCookie(ISteamHTMLSurface* pSteamHTMLSurface, const char *pchHostname, const char *pchKey, const char *pchValue, const char *pchPath, RTime32 nExpires, bool bSecure, bool bHTTPOnly) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetCookie=_BS_HTMLSurface_SetCookie@32")
+	pSteamHTMLSurface->SetCookie(pchHostname, pchKey, pchValue, pchPath, nExpires, bSecure, bHTTPOnly);
+}
+
+// Zoom the current page by flZoom ( from 0.0 to 2.0, so to zoom to 120% use 1.2 ), zooming around point X,Y in the page (use 0,0 if you don't care)
+DLL_FUNCTION(void) BS_HTMLSurface_SetPageScaleFactor(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, float flZoom, int nPointX, int nPointY) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetPageScaleFactor=_BS_HTMLSurface_SetPageScaleFactor@20")
+	pSteamHTMLSurface->SetPageScaleFactor(unBrowserHandle, flZoom, nPointX, nPointY);
+}
+
+// Enable/disable low-resource background mode, where javascript and repaint timers are throttled, resources are
+// more aggressively purged from memory, and audio/video elements are paused. When background mode is enabled,
+// all HTML5 video and audio objects will execute ".pause()" and gain the property "._steam_background_paused = 1".
+// When background mode is disabled, any video or audio objects with that property will resume with ".play()".
+DLL_FUNCTION(void) BS_HTMLSurface_SetBackgroundMode(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bBackgroundMode) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_SetBackgroundMode=_BS_HTMLSurface_SetBackgroundMode@12")
+	pSteamHTMLSurface->SetBackgroundMode(unBrowserHandle, bBackgroundMode);
+}
+
+// CALLBACKS
+//
+//  These set of functions are used as responses to callback requests
+//
+
+// You MUST call this in response to a HTML_StartRequest_t callback
+//  Set bAllowed to true to allow this navigation, false to cancel it and stay 
+// on the current page. You can use this feature to limit the valid pages
+// allowed in your HTML surface.
+DLL_FUNCTION(void) BS_HTMLSurface_AllowStartRequest(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bAllowed) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_AllowStartRequest=_BS_HTMLSurface_AllowStartRequest@12")
+	pSteamHTMLSurface->AllowStartRequest(unBrowserHandle, bAllowed);
+}
+
+// You MUST call this in response to a HTML_JSAlert_t or HTML_JSConfirm_t callback
+//  Set bResult to true for the OK option of a confirm, use false otherwise
+DLL_FUNCTION(void) BS_HTMLSurface_JSDialogResponse(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, bool bResult) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_JSDialogResponse=_BS_HTMLSurface_JSDialogResponse@12")
+	pSteamHTMLSurface->JSDialogResponse(unBrowserHandle, bResult);
+}
+
+// You MUST call this in response to a HTML_FileOpenDialog_t callback
+DLL_FUNCTION(void) BS_HTMLSurface_FileLoadDialogResponse(ISteamHTMLSurface* pSteamHTMLSurface, HHTMLBrowser unBrowserHandle, const char **pchSelectedFiles) {
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface_FileLoadDialogResponse=_BS_HTMLSurface_FileLoadDialogResponse@12")
+	pSteamHTMLSurface->FileLoadDialogResponse(unBrowserHandle, pchSelectedFiles);
+}

Wrapper/SteamMatchmakingServer.cpp

@@ -1,23 +0,0 @@
-//	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/SteamMatchmakingServers.cpp

@@ -0,0 +1,95 @@
+//	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() {
+#pragma comment(linker, "/EXPORT:BS_MatchmakingServers=_BS_MatchmakingServers@0")
+	return SteamMatchmakingServers();
+}
+
+DLL_FUNCTION(HServerListRequest) BS_MathmakingServers_RequestInternetServerList(AppId_t iApp, MatchMakingKeyValuePair_t** ppkvFilter, uint32_t nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) {
+	return SteamMatchmakingServers()->RequestInternetServerList(iApp, ppkvFilter, nFilters, pRequestServersResponse);
+}
+/*DLL_FUNCTION(HServerListRequest) BS_MathmakingServers_RequestLANServerList(AppId_t iApp, const char** ppchFilters, uint32_t nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) {
+	//return SteamMatchmakingServers()->RequestLANServerList(iApp);
+}
+DLL_FUNCTION(HServerListRequest) BS_MathmakingServers_RequestFriendsServerList(AppId_t iApp, const char** ppchFilters, uint32_t nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) {
+
+}
+DLL_FUNCTION(HServerListRequest) BS_MathmakingServers_RequestFavoritesServerList(AppId_t iApp, const char** ppchFilters, uint32_t nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) {
+
+}
+DLL_FUNCTION(HServerListRequest) BS_MathmakingServers_RequestHistoryServerList(AppId_t iApp, const char** ppchFilters, uint32_t nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) {
+
+}
+DLL_FUNCTION(HServerListRequest) BS_MathmakingServers_RequestSpectatorServerList(AppId_t iApp, const char** ppchFilters, uint32_t nFilters, ISteamMatchmakingServerListResponse *pRequestServersResponse) {
+
+}*/
+
+//
+//
+//// Releases the asynchronous request object and cancels any pending query on it if there's a pending query in progress.
+//// RefreshComplete callback is not posted when request is released.
+//virtual void ReleaseRequest( HServerListRequest hServerListRequest ) = 0;
+//
+//// Get details on a given server in the list, you can get the valid range of index
+//// values by calling GetServerCount().  You will also receive index values in 
+//// ISteamMatchmakingServerListResponse::ServerResponded() callbacks
+//virtual gameserveritem_t *GetServerDetails( HServerListRequest hRequest, int iServer ) = 0; 
+//
+//// Cancel an request which is operation on the given list type.  You should call this to cancel
+//// any in-progress requests before destructing a callback object that may have been passed 
+//// to one of the above list request calls.  Not doing so may result in a crash when a callback
+//// occurs on the destructed object.
+//// Canceling a query does not release the allocated request handle.
+//// The request handle must be released using ReleaseRequest( hRequest )
+//virtual void CancelQuery( HServerListRequest hRequest ) = 0; 
+//
+//// Ping every server in your list again but don't update the list of servers
+//// Query callback installed when the server list was requested will be used
+//// again to post notifications and RefreshComplete, so the callback must remain
+//// valid until another RefreshComplete is called on it or the request
+//// is released with ReleaseRequest( hRequest )
+//virtual void RefreshQuery( HServerListRequest hRequest ) = 0; 
+//
+//// Returns true if the list is currently refreshing its server list
+//virtual bool IsRefreshing( HServerListRequest hRequest ) = 0; 
+//
+//// How many servers in the given list, GetServerDetails above takes 0... GetServerCount() - 1
+//virtual int GetServerCount( HServerListRequest hRequest ) = 0; 
+//
+//// Refresh a single server inside of a query (rather than all the servers )
+//virtual void RefreshServer( HServerListRequest hRequest, int iServer ) = 0; 
+//
+//
+////-----------------------------------------------------------------------------
+//// Queries to individual servers directly via IP/Port
+////-----------------------------------------------------------------------------
+//
+//// Request updated ping time and other details from a single server
+//virtual HServerQuery PingServer( uint32 unIP, uint16 usPort, ISteamMatchmakingPingResponse *pRequestServersResponse ) = 0; 
+//
+//// Request the list of players currently playing on a server
+//virtual HServerQuery PlayerDetails( uint32 unIP, uint16 usPort, ISteamMatchmakingPlayersResponse *pRequestServersResponse ) = 0;
+//
+//// Request the list of rules that the server is running (See ISteamGameServer::SetKeyValue() to set the rules server side)
+//virtual HServerQuery ServerRules( uint32 unIP, uint16 usPort, ISteamMatchmakingRulesResponse *pRequestServersResponse ) = 0; 
+//
+//// Cancel an outstanding Ping/Players/Rules query from above.  You should call this to cancel
+//// any in-progress requests before destructing a callback object that may have been passed 
+//// to one of the above calls to avoid crashing when callbacks occur.
+//virtual void CancelServerQuery( HServerQuery hServerQuery ) = 0;