BlitzSteam update 06.02.2016

2016-02-06 00:17:29 +01:00
parent d6ef2b46f0
commit 0ebbd7e9a0
38 changed files with 1871 additions and 787 deletions
@@ -14,166 +14,60 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

-#include "dllmain.h"
+#include "BlitzSteam.h"

-DLL_EXPORT uint32_t DLL_CALL BS_Init() {
+DLL_FUNCTION(uint32_t) BS_Steam_Init() {
 	return SteamAPI_Init();
 }
-#pragma comment(linker, "/EXPORT:BS_Init=_BS_Init@0")
+#pragma comment(linker, "/EXPORT:BS_Steam_Init=_BS_Steam_Init@0")

-DLL_EXPORT void DLL_CALL BS_Shutdown() {
+DLL_FUNCTION(void) BS_Steam_Shutdown() {
 	SteamAPI_Shutdown();
 }
-#pragma comment(linker, "/EXPORT:BS_Shutdown=_BS_Shutdown@0")
+#pragma comment(linker, "/EXPORT:BS_Steam_Shutdown=_BS_Steam_Shutdown@0")

-DLL_EXPORT uint32_t DLL_CALL BS_IsSteamRunning() {
+DLL_FUNCTION(uint32_t) BS_Steam_IsSteamRunning() {
 	return SteamAPI_IsSteamRunning();
 }
-#pragma comment(linker, "/EXPORT:BS_IsSteamRunning=_BS_IsSteamRunning@0")
+#pragma comment(linker, "/EXPORT:BS_Steam_IsSteamRunning=_BS_Steam_IsSteamRunning@0")

-DLL_EXPORT uint32_t DLL_CALL BS_RestartAppIfNecessary(uint32 unOwnAppID) {
+DLL_FUNCTION(uint32_t) BS_Steam_RestartAppIfNecessary(uint32_t unOwnAppID) {
 	return SteamAPI_RestartAppIfNecessary(unOwnAppID);
 }
-#pragma comment(linker, "/EXPORT:BS_RestartAppIfNecessary=_BS_RestartAppIfNecessary@4")
+#pragma comment(linker, "/EXPORT:BS_Steam_RestartAppIfNecessary=_BS_Steam_RestartAppIfNecessary@4")

-DLL_EXPORT void DLL_CALL BS_SetMiniDumpComment(const char* pchMsg) {
+DLL_FUNCTION(void) BS_Steam_SetMiniDumpComment(const char* pchMsg) {
 	SteamAPI_SetMiniDumpComment(pchMsg);
 }
-#pragma comment(linker, "/EXPORT:BS_SetMiniDumpComment=_BS_SetMiniDumpComment@4")
+#pragma comment(linker, "/EXPORT:BS_Steam_SetMiniDumpComment=_BS_Steam_SetMiniDumpComment@4")

-DLL_EXPORT void DLL_CALL BS_WriteMiniDump(uint32_t uStructuredExceptionCode, void* pvExceptionInfo, uint32 uBuildID) {
+DLL_FUNCTION(void) BS_Steam_WriteMiniDump(uint32_t uStructuredExceptionCode, void* pvExceptionInfo, uint32_t uBuildID) {
 	SteamAPI_WriteMiniDump(uStructuredExceptionCode, pvExceptionInfo, uBuildID);
 }
-#pragma comment(linker, "/EXPORT:BS_WriteMiniDump=_BS_WriteMiniDump@12")
+#pragma comment(linker, "/EXPORT:BS_Steam_WriteMiniDump=_BS_Steam_WriteMiniDump@12")

-// Interface Pointers, configured by SteamAPI_Init().
-DLL_EXPORT ISteamClient* DLL_CALL BS_Client() {
-	return SteamClient();
-}
-#pragma comment(linker, "/EXPORT:BS_Client=_BS_Client@0")
-
-DLL_EXPORT ISteamUser* DLL_CALL BS_User() {
-	return SteamUser();
-}
-#pragma comment(linker, "/EXPORT:BS_User=_BS_User@0")
-
-DLL_EXPORT ISteamFriends* DLL_CALL BS_Friends() {
-	return SteamFriends();
-}
-#pragma comment(linker, "/EXPORT:BS_Friends=_BS_Friends@0")
-
-DLL_EXPORT ISteamUtils* DLL_CALL BS_Utils() {
-	return SteamUtils();
-}
-#pragma comment(linker, "/EXPORT:BS_Utils=_BS_Utils@0")
-
-DLL_EXPORT ISteamMatchmaking* DLL_CALL BS_Matchmaking() {
-	return SteamMatchmaking();
-}
-#pragma comment(linker, "/EXPORT:BS_Matchmaking=_BS_Matchmaking@0")
-
-DLL_EXPORT ISteamUserStats* DLL_CALL BS_UserStats() {
-	return SteamUserStats();
-}
-#pragma comment(linker, "/EXPORT:BS_UserStats=_BS_UserStats@0")
-
-DLL_EXPORT ISteamApps* DLL_CALL BS_Apps() {
-	return SteamApps();
-}
-#pragma comment(linker, "/EXPORT:BS_Apps=_BS_Apps@0")
-
-DLL_EXPORT ISteamNetworking* DLL_CALL BS_Networking() {
-	return SteamNetworking();
-}
-#pragma comment(linker, "/EXPORT:BS_Networking=_BS_Networking@0")
-
-DLL_EXPORT ISteamMatchmakingServers* DLL_CALL BS_MatchmakingServers() {
-	return SteamMatchmakingServers();
-}
-#pragma comment(linker, "/EXPORT:BS_MatchmakingServers=_BS_MatchmakingServers@0")
-
-DLL_EXPORT ISteamRemoteStorage* DLL_CALL BS_RemoteStorage() {
-	return SteamRemoteStorage();
-}
-#pragma comment(linker, "/EXPORT:BS_RemoteStorage=_BS_RemoteStorage@0")
-
-DLL_EXPORT ISteamScreenshots* DLL_CALL BS_Screenshots() {
-	return SteamScreenshots();
-}
-#pragma comment(linker, "/EXPORT:BS_Screenshots=_BS_Screenshots@0")
-
-DLL_EXPORT ISteamHTTP* DLL_CALL BS_HTTP() {
-	return SteamHTTP();
-}
-#pragma comment(linker, "/EXPORT:BS_HTTP=_BS_HTTP@0")
-
-DLL_EXPORT ISteamUnifiedMessages* DLL_CALL BS_UnifiedMessages() {
-	return SteamUnifiedMessages();
-}
-#pragma comment(linker, "/EXPORT:BS_UnifiedMessages=_BS_UnifiedMessages@0")
-
-DLL_EXPORT ISteamController* DLL_CALL BS_Controller() {
-	return SteamController();
-}
-#pragma comment(linker, "/EXPORT:BS_Controller=_BS_Controller@0")
-
-DLL_EXPORT ISteamUGC* DLL_CALL BS_UGC() {
-	return SteamUGC();
-}
-#pragma comment(linker, "/EXPORT:BS_UGC=_BS_UGC@0")
-
-DLL_EXPORT ISteamAppList* DLL_CALL BS_AppList() {
-	return SteamAppList();
-}
-#pragma comment(linker, "/EXPORT:BS_AppList=_BS_AppList@0")
-
-DLL_EXPORT ISteamMusic* DLL_CALL BS_Music() {
-	return SteamMusic();
-}
-#pragma comment(linker, "/EXPORT:BS_Music=_BS_Music@0")
-
-DLL_EXPORT ISteamMusicRemote* DLL_CALL BS_MusicRemote() {
-	return SteamMusicRemote();
-}
-#pragma comment(linker, "/EXPORT:BS_MusicRemote=_BS_MusicRemote@0")
-
-DLL_EXPORT ISteamHTMLSurface* DLL_CALL BS_HTMLSurface() {
-	return SteamHTMLSurface();
-}
-#pragma comment(linker, "/EXPORT:BS_HTMLSurface=_BS_HTMLSurface@0")
-
-DLL_EXPORT ISteamInventory* DLL_CALL BS_Inventory() {
-	return SteamInventory();
-}
-#pragma comment(linker, "/EXPORT:BS_Inventory=_BS_Inventory@0")
-
-DLL_EXPORT ISteamVideo* DLL_CALL BS_Video() {
-	return SteamVideo();
-}
-#pragma comment(linker, "/EXPORT:BS_Video=_BS_Video@0")
-
-// Callbacks & Hooks
-DLL_EXPORT void DLL_CALL BS_RunCallbacks() {
+// -- Callbacks
+DLL_FUNCTION(void) BS_Steam_RunCallbacks() {
 	SteamAPI_RunCallbacks();
 }
-#pragma comment(linker, "/EXPORT:BS_RunCallbacks=_BS_RunCallbacks@0")
+#pragma comment(linker, "/EXPORT:BS_Steam_RunCallbacks=_BS_Steam_RunCallbacks@0")

-DLL_EXPORT void DLL_CALL BS_RegisterCallback(class CCallbackBase *pCallback, int iCallback) {
+DLL_FUNCTION(void) BS_Steam_RegisterCallback(class CCallbackBase *pCallback, uint32_t iCallback) {
 	SteamAPI_RegisterCallback(pCallback, iCallback);
 }
-#pragma comment(linker, "/EXPORT:BS_RegisterCallback=_BS_RegisterCallback@8")
+#pragma comment(linker, "/EXPORT:BS_Steam_RegisterCallback=_BS_Steam_RegisterCallback@8")

-DLL_EXPORT void DLL_CALL BS_UnregisterCallback(class CCallbackBase *pCallback) {
+DLL_FUNCTION(void) BS_Steam_UnregisterCallback(class CCallbackBase *pCallback) {
 	SteamAPI_UnregisterCallback(pCallback);
 }
-#pragma comment(linker, "/EXPORT:BS_UnregisterCallback=_BS_UnregisterCallback@4")
+#pragma comment(linker, "/EXPORT:BS_Steam_UnregisterCallback=_BS_Steam_UnregisterCallback@4")

-DLL_EXPORT void DLL_CALL BS_RegisterCallResult(class CCallbackBase *pCallback, uint32_t hAPICall_L, uint32_t hAPICall_R) {
-	SteamAPI_RegisterCallResult(pCallback, ((uint64_t)hAPICall_L << 32) + (uint64_t)hAPICall_R);
+DLL_FUNCTION(void) BS_Steam_RegisterCallResult(class CCallbackBase *pCallback, uint64_t* phAPICall) {
+	SteamAPI_RegisterCallResult(pCallback, *phAPICall);
 }
-#pragma comment(linker, "/EXPORT:BS_RegisterCallResult=_BS_RegisterCallResult@12")
+#pragma comment(linker, "/EXPORT:BS_Steam_RegisterCallResult=_BS_Steam_RegisterCallResult@8")

-DLL_EXPORT void DLL_CALL BS_UnregisterCallResult(class CCallbackBase *pCallback, uint32_t hAPICall_L, uint32_t hAPICall_R) {
-	SteamAPI_UnregisterCallResult(pCallback, ((uint64_t)hAPICall_L << 32) + (uint64_t)hAPICall_R);
+DLL_FUNCTION(void) BS_Steam_UnregisterCallResult(class CCallbackBase *pCallback, uint64_t* phAPICall) {
+	SteamAPI_UnregisterCallResult(pCallback, *phAPICall);
 }
-#pragma comment(linker, "/EXPORT:BS_UnregisterCallResult=_BS_UnregisterCallResult@12")
+#pragma comment(linker, "/EXPORT:BS_Steam_UnregisterCallResult=_BS_Steam_UnregisterCallResult@8")
@@ -14,29 +14,34 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

-#include "dllmain.h"
+#include "BlitzSteam.h"

-DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetNumInstalledApps(ISteamAppList* lpSteamAppList) {
+DLL_FUNCTION(ISteamAppList*) BS_AppList() {
+	return SteamAppList();
+}
+#pragma comment(linker, "/EXPORT:BS_AppList=_BS_AppList@0")
+
+DLL_FUNCTION(uint32_t) BS_AppList_GetNumInstalledApps(ISteamAppList* lpSteamAppList) {
 	return lpSteamAppList->GetNumInstalledApps();
 }
 #pragma comment(linker, "/EXPORT:BS_AppList_GetNumInstalledApps=_BS_AppList_GetNumInstalledApps@4")

-DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetInstalledApps(ISteamAppList* lpSteamAppList, AppId_t *pvecAppID, uint32 unMaxAppIDs) {
+DLL_FUNCTION(uint32_t) BS_AppList_GetInstalledApps(ISteamAppList* lpSteamAppList, AppId_t *pvecAppID, uint32_t unMaxAppIDs) {
 	return lpSteamAppList->GetInstalledApps(pvecAppID, unMaxAppIDs);
 }
 #pragma comment(linker, "/EXPORT:BS_AppList_GetInstalledApps=_BS_AppList_GetInstalledApps@12")

-DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetAppName(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchName, uint32_t cchNameMax) {
+DLL_FUNCTION(uint32_t) BS_AppList_GetAppName(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchName, uint32_t cchNameMax) {
 	return lpSteamAppList->GetAppName(nAppID, pchName, cchNameMax);
 }
 #pragma comment(linker, "/EXPORT:BS_AppList_GetAppName=_BS_AppList_GetAppName@16")

-DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetAppInstallDir(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchDirectory, uint32_t cchDirectoryMax) {
+DLL_FUNCTION(uint32_t) BS_AppList_GetAppInstallDir(ISteamAppList* lpSteamAppList, AppId_t nAppID, char* pchDirectory, uint32_t cchDirectoryMax) {
 	return lpSteamAppList->GetAppInstallDir(nAppID, pchDirectory, cchDirectoryMax);
 }
 #pragma comment(linker, "/EXPORT:BS_AppList_GetAppInstallDir=_BS_AppList_GetAppInstallDir@16")

-DLL_EXPORT uint32_t DLL_CALL BS_AppList_GetAppBuildId(ISteamAppList* lpSteamAppList, AppId_t nAppID) {
+DLL_FUNCTION(uint32_t) BS_AppList_GetAppBuildId(ISteamAppList* lpSteamAppList, AppId_t nAppID) {
 	return lpSteamAppList->GetAppBuildId(nAppID);
 }
 #pragma comment(linker, "/EXPORT:BS_AppList_GetAppBuildId=_BS_AppList_GetAppBuildId@8")
@@ -14,126 +14,130 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

-#include "dllmain.h"
-#include "Helpers/CSteamID.h"
+#include "BlitzSteam.h"

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsSubscribed(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(ISteamApps*) BS_Apps() {
+	return SteamApps();
+}
+#pragma comment(linker, "/EXPORT:BS_Apps=_BS_Apps@0")
+
+DLL_FUNCTION(uint32_t) BS_Apps_IsSubscribed(ISteamApps* lpSteamApps) {
 	return lpSteamApps->BIsSubscribed();
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribed=_BS_Apps_IsSubscribed@4")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsLowViolence(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(uint32_t) BS_Apps_IsLowViolence(ISteamApps* lpSteamApps) {
 	return lpSteamApps->BIsLowViolence();
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_IsLowViolence=_BS_Apps_IsLowViolence@4")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsCybercafe(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(uint32_t) BS_Apps_IsCybercafe(ISteamApps* lpSteamApps) {
 	return lpSteamApps->BIsCybercafe();
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_IsCybercafe=_BS_Apps_IsCybercafe@4")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsVACBanned(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(uint32_t) BS_Apps_IsVACBanned(ISteamApps* lpSteamApps) {
 	return lpSteamApps->BIsVACBanned();
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_IsVACBanned=_BS_Apps_IsVACBanned@4")

-DLL_EXPORT const char* DLL_CALL BS_Apps_GetCurrentGameLanguage(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(const char*) BS_Apps_GetCurrentGameLanguage(ISteamApps* lpSteamApps) {
 	return lpSteamApps->GetCurrentGameLanguage();
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_GetCurrentGameLanguage=_BS_Apps_GetCurrentGameLanguage@4")

-DLL_EXPORT const char* DLL_CALL BS_Apps_GetAvailableGameLanguages(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(const char*) BS_Apps_GetAvailableGameLanguages(ISteamApps* lpSteamApps) {
 	return lpSteamApps->GetAvailableGameLanguages();
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_GetAvailableGameLanguages=_BS_Apps_GetAvailableGameLanguages@4")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsSubscribedApp(ISteamApps* lpSteamApps, AppId_t appID) {
+DLL_FUNCTION(uint32_t) BS_Apps_IsSubscribedApp(ISteamApps* lpSteamApps, AppId_t appID) {
 	return lpSteamApps->BIsSubscribedApp(appID);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribedApp=_BS_Apps_IsSubscribedApp@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsDlcInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
+DLL_FUNCTION(uint32_t) BS_Apps_IsDlcInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
 	return lpSteamApps->BIsDlcInstalled(appID);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_IsDlcInstalled=_BS_Apps_IsDlcInstalled@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetEarliestPurchaseUnixTime(ISteamApps* lpSteamApps, AppId_t appID) {
+DLL_FUNCTION(uint32_t) BS_Apps_GetEarliestPurchaseUnixTime(ISteamApps* lpSteamApps, AppId_t appID) {
 	return lpSteamApps->GetEarliestPurchaseUnixTime(appID);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_GetEarliestPurchaseUnixTime=_BS_Apps_GetEarliestPurchaseUnixTime@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsSubscribedFromFreeWeekend(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(uint32_t) BS_Apps_IsSubscribedFromFreeWeekend(ISteamApps* lpSteamApps) {
 	return lpSteamApps->BIsSubscribedFromFreeWeekend();
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_IsSubscribedFromFreeWeekend=_BS_Apps_IsSubscribedFromFreeWeekend@4")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetDLCCount(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(uint32_t) BS_Apps_GetDLCCount(ISteamApps* lpSteamApps) {
 	return lpSteamApps->GetDLCCount();
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_GetDLCCount=_BS_Apps_GetDLCCount@4")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetDLCDataByIndex(ISteamApps* lpSteamApps, uint32_t iDLC, AppId_t *pAppId, bool* pbAvailable, char *pchName, uint32_t cchNameBufferSize) {
+DLL_FUNCTION(uint32_t) BS_Apps_GetDLCDataByIndex(ISteamApps* lpSteamApps, uint32_t iDLC, AppId_t *pAppId, bool* pbAvailable, char *pchName, uint32_t cchNameBufferSize) {
 	return lpSteamApps->BGetDLCDataByIndex(iDLC, pAppId, (bool*)pbAvailable, pchName, cchNameBufferSize);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_GetDLCDataByIndex=_BS_Apps_GetDLCDataByIndex@24")

-DLL_EXPORT void DLL_CALL BS_Apps_InstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
+DLL_FUNCTION(void) BS_Apps_InstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
 	lpSteamApps->InstallDLC(nAppID);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_InstallDLC=_BS_Apps_InstallDLC@8")

-DLL_EXPORT void DLL_CALL BS_Apps_UninstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
+DLL_FUNCTION(void) BS_Apps_UninstallDLC(ISteamApps* lpSteamApps, AppId_t nAppID) {
 	lpSteamApps->UninstallDLC(nAppID);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_UninstallDLC=_BS_Apps_UninstallDLC@8")

-DLL_EXPORT void DLL_CALL BS_Apps_RequestAppProofOfPurchaseKey(ISteamApps* lpSteamApps, AppId_t nAppID) {
+DLL_FUNCTION(void) BS_Apps_RequestAppProofOfPurchaseKey(ISteamApps* lpSteamApps, AppId_t nAppID) {
 	lpSteamApps->RequestAppProofOfPurchaseKey(nAppID);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_RequestAppProofOfPurchaseKey=_BS_Apps_RequestAppProofOfPurchaseKey@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetCurrentBetaName(ISteamApps* lpSteamApps, char *pchName, int cchNameBufferSize) {
+DLL_FUNCTION(uint32_t) BS_Apps_GetCurrentBetaName(ISteamApps* lpSteamApps, char *pchName, int cchNameBufferSize) {
 	return lpSteamApps->GetCurrentBetaName(pchName, cchNameBufferSize);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_GetCurrentBetaName=_BS_Apps_GetCurrentBetaName@12")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_MarkContentCorrupt(ISteamApps* lpSteamApps, uint32_t bMissingFilesOnly) {
+DLL_FUNCTION(uint32_t) BS_Apps_MarkContentCorrupt(ISteamApps* lpSteamApps, uint32_t bMissingFilesOnly) {
 	return lpSteamApps->MarkContentCorrupt(bMissingFilesOnly != 0);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_MarkContentCorrupt=_BS_Apps_MarkContentCorrupt@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetInstalledDepots(ISteamApps* lpSteamApps, AppId_t nAppID, DepotId_t *pvecDepots, uint32_t cMaxDepots) {
+DLL_FUNCTION(uint32_t) BS_Apps_GetInstalledDepots(ISteamApps* lpSteamApps, AppId_t nAppID, DepotId_t *pvecDepots, uint32_t cMaxDepots) {
 	return lpSteamApps->GetInstalledDepots(nAppID, pvecDepots, cMaxDepots);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_GetInstalledDepots=_BS_Apps_GetInstalledDepots@16")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetAppInstallDir(ISteamApps* lpSteamApps, AppId_t appID, char *pchFolder, uint32 cchFolderBufferSize) {
+DLL_FUNCTION(uint32_t) BS_Apps_GetAppInstallDir(ISteamApps* lpSteamApps, AppId_t appID, char *pchFolder, uint32_t cchFolderBufferSize) {
 	return lpSteamApps->GetAppInstallDir(appID, pchFolder, cchFolderBufferSize);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_GetAppInstallDir=_BS_Apps_GetAppInstallDir@16")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_IsAppInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
+DLL_FUNCTION(uint32_t) BS_Apps_IsAppInstalled(ISteamApps* lpSteamApps, AppId_t appID) {
 	return lpSteamApps->BIsAppInstalled(appID);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_IsAppInstalled=_BS_Apps_IsAppInstalled@8")

-DLL_EXPORT CSteamID* DLL_CALL BS_Apps_GetAppOwner(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(CSteamID*) BS_Apps_GetAppOwner(ISteamApps* lpSteamApps) {
 	CSteamID* steamID = new CSteamID(lpSteamApps->GetAppOwner());
 	return BS_CSteamID_Copy(steamID);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_GetAppOwner=_BS_Apps_GetAppOwner@4")

-DLL_EXPORT const char* DLL_CALL BS_Apps_GetLaunchQueryParam(ISteamApps* lpSteamApps, const char *pchKey) {
+DLL_FUNCTION(const char*) BS_Apps_GetLaunchQueryParam(ISteamApps* lpSteamApps, const char *pchKey) {
 	return lpSteamApps->GetLaunchQueryParam(pchKey);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_GetLaunchQueryParam=_BS_Apps_GetLaunchQueryParam@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetDlcDownloadProgress(ISteamApps* lpSteamApps, AppId_t nAppID, uint64_t* punBytesDownloaded, uint64_t* punBytesTotal) {
+DLL_FUNCTION(uint32_t) BS_Apps_GetDlcDownloadProgress(ISteamApps* lpSteamApps, AppId_t nAppID, uint64_t* punBytesDownloaded, uint64_t* punBytesTotal) {
 	return lpSteamApps->GetDlcDownloadProgress(nAppID, punBytesDownloaded, punBytesTotal);
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_GetDlcDownloadProgress=_BS_Apps_GetDlcDownloadProgress@16")

-DLL_EXPORT uint32_t DLL_CALL BS_Apps_GetAppBuildId(ISteamApps* lpSteamApps) {
+DLL_FUNCTION(uint32_t) BS_Apps_GetAppBuildId(ISteamApps* lpSteamApps) {
 	return lpSteamApps->GetAppBuildId();
 }
 #pragma comment(linker, "/EXPORT:BS_Apps_GetAppBuildId=_BS_Apps_GetAppBuildId@4")
@@ -14,180 +14,185 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

-#include "dllmain.h"
+#include "BlitzSteam.h"

-DLL_EXPORT HSteamPipe DLL_CALL BS_Client_CreateSteamPipe(ISteamClient* lpSteamClient) {
+DLL_FUNCTION(ISteamClient*) BS_Client() {
+	return SteamClient();
+}
+#pragma comment(linker, "/EXPORT:BS_Client=_BS_Client@0")
+
+DLL_FUNCTION(HSteamPipe) BS_Client_CreateSteamPipe(ISteamClient* lpSteamClient) {
 	return lpSteamClient->CreateSteamPipe();
 }
 #pragma comment(linker, "/EXPORT:BS_Client_CreateSteamPipe=_BS_Client_CreateSteamPipe@4")

-DLL_EXPORT uint32_t DLL_CALL BS_Client_ReleaseSteamPipe(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
+DLL_FUNCTION(uint32_t) BS_Client_ReleaseSteamPipe(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
 	return lpSteamClient->BReleaseSteamPipe(hSteamPipe);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_ReleaseSteamPipe=_BS_Client_ReleaseSteamPipe@8")

-DLL_EXPORT HSteamUser DLL_CALL BS_Client_ConnectToGlobalUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
+DLL_FUNCTION(HSteamUser) BS_Client_ConnectToGlobalUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe) {
 	return lpSteamClient->ConnectToGlobalUser(hSteamPipe);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_ConnectToGlobalUser=_BS_Client_ConnectToGlobalUser@8")

-DLL_EXPORT void DLL_CALL BS_Client_SetLocalIPBinding(ISteamClient* lpSteamClient, uint32_t unIP, uint16 usPort) {
+DLL_FUNCTION(void) BS_Client_SetLocalIPBinding(ISteamClient* lpSteamClient, uint32_t unIP, uint16 usPort) {
 	return lpSteamClient->SetLocalIPBinding(unIP, usPort);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_SetLocalIPBinding=_BS_Client_SetLocalIPBinding@12")

-DLL_EXPORT HSteamUser DLL_CALL BS_Client_CreateLocalUser(ISteamClient* lpSteamClient, HSteamPipe* phSteamPipe, EAccountType eAccountType) {
+DLL_FUNCTION(HSteamUser) BS_Client_CreateLocalUser(ISteamClient* lpSteamClient, HSteamPipe* phSteamPipe, EAccountType eAccountType) {
 	return lpSteamClient->CreateLocalUser(phSteamPipe, eAccountType);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_CreateLocalUser=_BS_Client_CreateLocalUser@12")

-DLL_EXPORT void DLL_CALL BS_Client_ReleaseUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, HSteamUser hSteamUser) {
+DLL_FUNCTION(void) BS_Client_ReleaseUser(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, HSteamUser hSteamUser) {
 	return lpSteamClient->ReleaseUser(hSteamPipe, hSteamUser);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_ReleaseUser=_BS_Client_ReleaseUser@12")

-DLL_EXPORT void DLL_CALL BS_Client_RunFrame(ISteamClient* lpSteamClient) {
+DLL_FUNCTION(void) BS_Client_RunFrame(ISteamClient* lpSteamClient) {
 	lpSteamClient->RunFrame();
 }
 #pragma comment(linker, "/EXPORT:BS_Client_RunFrame=_BS_Client_RunFrame@4")

-DLL_EXPORT uint32_t DLL_CALL BS_Client_GetIPCCallCount(ISteamClient* lpSteamClient) {
+DLL_FUNCTION(uint32_t) BS_Client_GetIPCCallCount(ISteamClient* lpSteamClient) {
 	return lpSteamClient->GetIPCCallCount();
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetIPCCallCount=_BS_Client_GetIPCCallCount@4")

-DLL_EXPORT uint32_t DLL_CALL BS_Client_ShutdownIfAllPipesClosed(ISteamClient* lpSteamClient) {
+DLL_FUNCTION(uint32_t) BS_Client_ShutdownIfAllPipesClosed(ISteamClient* lpSteamClient) {
 	return lpSteamClient->BShutdownIfAllPipesClosed();
 }

 // Interfaces
-DLL_EXPORT ISteamAppList* DLL_CALL BS_Client_GetSteamAppList(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamAppList*) BS_Client_GetSteamAppList(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamAppList(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamAppList=_BS_Client_GetSteamAppList@16")

-DLL_EXPORT ISteamApps* DLL_CALL BS_Client_GetSteamApps(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamApps*) BS_Client_GetSteamApps(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamApps(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamApps=_BS_Client_GetSteamApps@16")

-DLL_EXPORT ISteamController* DLL_CALL BS_Client_GetSteamController(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamController*) BS_Client_GetSteamController(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamController(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamController=_BS_Client_GetSteamController@16")

-DLL_EXPORT ISteamFriends* DLL_CALL BS_Client_GetSteamFriends(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamFriends*) BS_Client_GetSteamFriends(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamFriends(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamFriends=_BS_Client_GetSteamFriends@16")

-DLL_EXPORT ISteamGameServer* DLL_CALL BS_Client_GetSteamGameServer(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamGameServer*) BS_Client_GetSteamGameServer(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamGameServer(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamGameServer=_BS_Client_GetSteamGameServer@16")

-DLL_EXPORT ISteamGameServerStats* DLL_CALL BS_Client_GetSteamGameServerStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamGameServerStats*) BS_Client_GetSteamGameServerStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamGameServerStats(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamGameServerStats=_BS_Client_GetSteamGameServerStats@16")

-DLL_EXPORT ISteamHTMLSurface* DLL_CALL BS_Client_GetSteamHTMLSurface(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamHTMLSurface*) BS_Client_GetSteamHTMLSurface(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamHTMLSurface(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamHTMLSurface=_BS_Client_GetSteamHTMLSurface@16")

-DLL_EXPORT ISteamHTTP* DLL_CALL BS_Client_GetSteamHTTP(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamHTTP*) BS_Client_GetSteamHTTP(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamHTTP(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamHTTP=_BS_Client_GetSteamHTTP@16")

-DLL_EXPORT ISteamInventory* DLL_CALL BS_Client_GetSteamInventory(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamInventory*) BS_Client_GetSteamInventory(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamInventory(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamInventory=_BS_Client_GetSteamInventory@16")

-DLL_EXPORT ISteamMatchmaking* DLL_CALL BS_Client_GetSteamMatchmaking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamMatchmaking*) BS_Client_GetSteamMatchmaking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamMatchmaking(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamMatchmaking=_BS_Client_GetSteamMatchmaking@16")

-DLL_EXPORT ISteamMatchmakingServers* DLL_CALL BS_Client_GetSteamMatchmakingServers(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamMatchmakingServers*) BS_Client_GetSteamMatchmakingServers(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamMatchmakingServers(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamMatchmakingServers=_BS_Client_GetSteamMatchmakingServers@16")

-DLL_EXPORT ISteamMusic* DLL_CALL BS_Client_GetSteamMusic(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamMusic*) BS_Client_GetSteamMusic(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamMusic(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamMusic=_BS_Client_GetSteamMusic@16")

-DLL_EXPORT ISteamMusicRemote* DLL_CALL BS_Client_GetSteamMusicRemote(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamMusicRemote*) BS_Client_GetSteamMusicRemote(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamMusicRemote(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamMusicRemote=_BS_Client_GetSteamMusicRemote@16")

-DLL_EXPORT ISteamNetworking* DLL_CALL BS_Client_GetSteamNetworking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamNetworking*) BS_Client_GetSteamNetworking(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamNetworking(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamNetworking=_BS_Client_GetSteamNetworking@16")

-DLL_EXPORT ISteamRemoteStorage* DLL_CALL BS_Client_GetSteamRemoteStorage(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamRemoteStorage*) BS_Client_GetSteamRemoteStorage(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamRemoteStorage(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamRemoteStorage=_BS_Client_GetSteamRemoteStorage@16")

-DLL_EXPORT ISteamScreenshots* DLL_CALL BS_Client_GetSteamScreenshots(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamScreenshots*) BS_Client_GetSteamScreenshots(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamScreenshots(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamScreenshots=_BS_Client_GetSteamScreenshots@16")

-DLL_EXPORT ISteamUGC* DLL_CALL BS_Client_GetSteamUGC(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamUGC*) BS_Client_GetSteamUGC(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamUGC(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamUGC=_BS_Client_GetSteamUGC@16")

-DLL_EXPORT ISteamUnifiedMessages* DLL_CALL BS_Client_GetSteamUnifiedMessages(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamUnifiedMessages*) BS_Client_GetSteamUnifiedMessages(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamUnifiedMessages(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamUnifiedMessages=_BS_Client_GetSteamUnifiedMessages@16")

-DLL_EXPORT ISteamUser* DLL_CALL BS_Client_GetSteamUser(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamUser*) BS_Client_GetSteamUser(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamUser(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamUser=_BS_Client_GetSteamUser@16")

-DLL_EXPORT ISteamUserStats* DLL_CALL BS_Client_GetSteamUserStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamUserStats*) BS_Client_GetSteamUserStats(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamUserStats(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamUserStats=_BS_Client_GetSteamUserStats@16")

-DLL_EXPORT ISteamUtils* DLL_CALL BS_Client_GetSteamUtils(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamUtils*) BS_Client_GetSteamUtils(ISteamClient* lpSteamClient, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamUtils(hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamUtils=_BS_Client_GetSteamUtils@12")

-DLL_EXPORT ISteamVideo* DLL_CALL BS_Client_GetSteamVideo(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
+DLL_FUNCTION(ISteamVideo*) BS_Client_GetSteamVideo(ISteamClient* lpSteamClient, HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char *pchVersion) {
 	return lpSteamClient->GetISteamVideo(hSteamUser, hSteamPipe, pchVersion);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_GetSteamVideo=_BS_Client_GetSteamVideo@16")

 // Callbacks & Hooks
-DLL_EXPORT void DLL_CALL BS_Client_SetWarningMessageHook(ISteamClient* lpSteamClient, SteamAPIWarningMessageHook_t fpfunction) {
+DLL_FUNCTION(void) BS_Client_SetWarningMessageHook(ISteamClient* lpSteamClient, SteamAPIWarningMessageHook_t fpfunction) {
 	lpSteamClient->SetWarningMessageHook(fpfunction);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_SetWarningMessageHook=_BS_Client_SetWarningMessageHook@8")

-DLL_EXPORT void DLL_CALL BS_Client_Set_SteamAPI_CPostAPIResultInProcess(ISteamClient* lpSteamClient, SteamAPI_PostAPIResultInProcess_t fpFunction) {
+DLL_FUNCTION(void) BS_Client_Set_SteamAPI_CPostAPIResultInProcess(ISteamClient* lpSteamClient, SteamAPI_PostAPIResultInProcess_t fpFunction) {
 	lpSteamClient->Set_SteamAPI_CPostAPIResultInProcess(fpFunction);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_Set_SteamAPI_CPostAPIResultInProcess=_BS_Client_Set_SteamAPI_CPostAPIResultInProcess@8")

-DLL_EXPORT void DLL_CALL BS_Client_Remove_SteamAPI_CPostAPIResultInProcess(ISteamClient* lpSteamClient, SteamAPI_PostAPIResultInProcess_t fpFunction) {
+DLL_FUNCTION(void) BS_Client_Remove_SteamAPI_CPostAPIResultInProcess(ISteamClient* lpSteamClient, SteamAPI_PostAPIResultInProcess_t fpFunction) {
 	lpSteamClient->Remove_SteamAPI_CPostAPIResultInProcess(fpFunction);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_Remove_SteamAPI_CPostAPIResultInProcess=_BS_Client_Remove_SteamAPI_CPostAPIResultInProcess@8")

-DLL_EXPORT void DLL_CALL BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess(ISteamClient* lpSteamClient, SteamAPI_CheckCallbackRegistered_t fpFunction) {
+DLL_FUNCTION(void) BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess(ISteamClient* lpSteamClient, SteamAPI_CheckCallbackRegistered_t fpFunction) {
 	lpSteamClient->Set_SteamAPI_CCheckCallbackRegisteredInProcess(fpFunction);
 }
 #pragma comment(linker, "/EXPORT:BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess=_BS_Client_Set_SteamAPI_CCheckCallbackRegisteredInProcess@8")
@@ -14,35 +14,40 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

-#include "dllmain.h"
+#include "BlitzSteam.h"

-DLL_EXPORT uint32_t DLL_CALL BS_Controller_Init(ISteamController* lpSteamController) {
+DLL_FUNCTION(ISteamController*) BS_Controller() {
+	return SteamController();
+}
+#pragma comment(linker, "/EXPORT:BS_Controller=_BS_Controller@0")
+
+DLL_FUNCTION(uint32_t) BS_Controller_Init(ISteamController* lpSteamController) {
 	return lpSteamController->Init();
 }
 #pragma comment(linker, "/EXPORT:BS_Controller_Init=_BS_Controller_Init@4")

-DLL_EXPORT uint32_t DLL_CALL BS_Controller_Shutdown(ISteamController* lpSteamController) {
+DLL_FUNCTION(uint32_t) BS_Controller_Shutdown(ISteamController* lpSteamController) {
 	return lpSteamController->Shutdown();
 }
 #pragma comment(linker, "/EXPORT:BS_Controller_Shutdown=_BS_Controller_Shutdown@4")

-DLL_EXPORT void DLL_CALL BS_Controller_RunFrame(ISteamController* lpSteamController) {
+DLL_FUNCTION(void) BS_Controller_RunFrame(ISteamController* lpSteamController) {
 	lpSteamController->RunFrame();
 }
 #pragma comment(linker, "/EXPORT:BS_Controller_RunFrame=_BS_Controller_RunFrame@4")

 #if 0
-DLL_EXPORT uint32_t DLL_CALL BS_Controller_GetControllerState( ISteamController* lpSteamController, uint32_t unControllerIndex, SteamControllerState_t *pState ) {
+DLL_FUNCTION(uint32_t) BS_Controller_GetControllerState( ISteamController* lpSteamController, uint32_t unControllerIndex, SteamControllerState_t *pState ) {
 	return lpSteamController->GetControllerState( unControllerIndex, pState );
 }
 #pragma comment(linker, "/EXPORT:BS_Controller_GetControllerState=_BS_Controller_GetControllerState@12")

-DLL_EXPORT void DLL_CALL BS_Controller_TriggerHapticPulse( ISteamController* lpSteamController, uint32_t unControllerIndex, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec ) {
+DLL_FUNCTION(void) BS_Controller_TriggerHapticPulse( ISteamController* lpSteamController, uint32_t unControllerIndex, ESteamControllerPad eTargetPad, uint32_t usDurationMicroSec ) {
 	lpSteamController->TriggerHapticPulse( unControllerIndex, eTargetPad, usDurationMicroSec );
 }
 #pragma comment(linker, "/EXPORT:BS_Controller_TriggerHapticPulse=_BS_Controller_TriggerHapticPulse@16")

-DLL_EXPORT void DLL_CALL BS_Controller_SetOverrideMode( ISteamController* lpSteamController, const char *pchMode ) {
+DLL_FUNCTION(void) BS_Controller_SetOverrideMode( ISteamController* lpSteamController, const char *pchMode ) {
 	lpSteamController->SetOverrideMode( pchMode );
 }
 #pragma comment(linker, "/EXPORT:BS_Controller_SetOverrideMode=_BS_Controller_SetOverrideMode@8")  
@@ -14,65 +14,70 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

-#include "dllmain.h"
+#include "BlitzSteam.h"

-DLL_EXPORT const char* DLL_CALL BS_Friends_GetPersonaName(ISteamFriends* lpSteamFriends) {
+DLL_FUNCTION(ISteamFriends*) BS_Friends() {
+	return SteamFriends();
+}
+#pragma comment(linker, "/EXPORT:BS_Friends=_BS_Friends@0")
+
+DLL_FUNCTION(const char*) BS_Friends_GetPersonaName(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetPersonaName();
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetPersonaName=_BS_Friends_GetPersonaName@4")

-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_SetPersonaName(ISteamFriends* lpSteamFriends, const char* pchPersonaName) {
-	return lpSteamFriends->SetPersonaName(pchPersonaName);
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_SetPersonaName(ISteamFriends* lpSteamFriends, const char* pchPersonaName) {
+	return new uint64_t(lpSteamFriends->SetPersonaName(pchPersonaName));
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_SetPersonaName=_BS_Friends_SetPersonaName@8")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetPersonaState(ISteamFriends* lpSteamFriends) {
+DLL_FUNCTION(int32_t) BS_Friends_GetPersonaState(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetPersonaState();
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetPersonaState=_BS_Friends_GetPersonaState@4")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendCount(ISteamFriends* lpSteamFriends, int32_t iFriendFlags) {
+DLL_FUNCTION(int32_t) BS_Friends_GetFriendCount(ISteamFriends* lpSteamFriends, int32_t iFriendFlags) {
 	return lpSteamFriends->GetFriendCount(iFriendFlags);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCount=_BS_Friends_GetFriendCount@8")

-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetFriendByIndex(ISteamFriends* lpSteamFriends, int32_t iFriend, int32_t iFriendFlags) {
+DLL_FUNCTION(CSteamID*) BS_Friends_GetFriendByIndex(ISteamFriends* lpSteamFriends, int32_t iFriend, int32_t iFriendFlags) {
 	CSteamID* pSteamID = new CSteamID(lpSteamFriends->GetFriendByIndex(iFriend, iFriendFlags));
 	return pSteamID;
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendByIndex=_BS_Friends_GetFriendByIndex@12")

-DLL_EXPORT EFriendRelationship DLL_CALL BS_Friends_GetFriendRelationship(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(EFriendRelationship) BS_Friends_GetFriendRelationship(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendRelationship(*steamIDFriend);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRelationship=_BS_Friends_GetFriendRelationship@8")

-DLL_EXPORT EPersonaState DLL_CALL BS_Friends_GetFriendPersonaState(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(EPersonaState) BS_Friends_GetFriendPersonaState(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendPersonaState(*steamIDFriend);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaState=_BS_Friends_GetFriendPersonaState@8")

-DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendPersonaName(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(const char*) BS_Friends_GetFriendPersonaName(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendPersonaName(*steamIDFriend);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaName=_BS_Friends_GetFriendPersonaName@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_GetFriendGamePlayed(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, FriendGameInfo_t *pFriendGameInfo) {
+DLL_FUNCTION(uint32_t) BS_Friends_GetFriendGamePlayed(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, FriendGameInfo_t *pFriendGameInfo) {
 	return lpSteamFriends->GetFriendGamePlayed(*steamIDFriend, pFriendGameInfo);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendGamePlayed=_BS_Friends_GetFriendGamePlayed@12")

-DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendPersonaNameHistory(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iPersonaName) {
+DLL_FUNCTION(const char*) BS_Friends_GetFriendPersonaNameHistory(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iPersonaName) {
 	return lpSteamFriends->GetFriendPersonaNameHistory(*steamIDFriend, iPersonaName);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendPersonaNameHistory=_BS_Friends_GetFriendPersonaNameHistory@12")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendSteamLevel(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(int32_t) BS_Friends_GetFriendSteamLevel(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendSteamLevel(*steamIDFriend);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendSteamLevel=_BS_Friends_GetFriendSteamLevel@8")

-DLL_EXPORT const char* DLL_CALL BS_Friends_GetPlayerNickname(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriends) {
+DLL_FUNCTION(const char*) BS_Friends_GetPlayerNickname(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriends) {
 	const char* nickname = lpSteamFriends->GetPlayerNickname(*steamIDFriends);
 	if (nickname == NULL) {
 		nickname = "";
@@ -81,298 +86,296 @@ DLL_EXPORT const char* DLL_CALL BS_Friends_GetPlayerNickname(ISteamFriends* lpSt
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetPlayerNickname=_BS_Friends_GetPlayerNickname@8")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendsGroupCount(ISteamFriends* lpSteamFriends) {
+DLL_FUNCTION(int32_t) BS_Friends_GetFriendsGroupCount(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetFriendsGroupCount();
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupCount=_BS_Friends_GetFriendsGroupCount@4")

-DLL_EXPORT FriendsGroupID_t DLL_CALL BS_Friends_GetFriendsGroupIDByIndex(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
+DLL_FUNCTION(FriendsGroupID_t) BS_Friends_GetFriendsGroupIDByIndex(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
 	return lpSteamFriends->GetFriendsGroupIDByIndex(friendsGroupID);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupIDByIndex=_BS_Friends_GetFriendsGroupIDByIndex@8")

-DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendsGroupName(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
+DLL_FUNCTION(const char*) BS_Friends_GetFriendsGroupName(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
 	return lpSteamFriends->GetFriendsGroupName(friendsGroupID);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupName=_BS_Friends_GetFriendsGroupName@8")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendsGroupMembersCount(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
+DLL_FUNCTION(int32_t) BS_Friends_GetFriendsGroupMembersCount(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID) {
 	return lpSteamFriends->GetFriendsGroupMembersCount(friendsGroupID);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupMembersCount=_BS_Friends_GetFriendsGroupMembersCount@8")

-DLL_EXPORT void DLL_CALL BS_Friends_GetFriendsGroupMembersList(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID, CSteamID* pOutSteamIDMembers, int32_t nMembersCount) {
+DLL_FUNCTION(void) BS_Friends_GetFriendsGroupMembersList(ISteamFriends* lpSteamFriends, FriendsGroupID_t friendsGroupID, CSteamID* pOutSteamIDMembers, int32_t nMembersCount) {
 	lpSteamFriends->GetFriendsGroupMembersList(friendsGroupID, pOutSteamIDMembers, nMembersCount);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendsGroupMembersList=_BS_Friends_GetFriendsGroupMembersList@16")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_HasFriend(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iFriendsFlags) {
+DLL_FUNCTION(uint32_t) BS_Friends_HasFriend(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iFriendsFlags) {
 	return lpSteamFriends->HasFriend(*steamIDFriend, iFriendsFlags);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_HasFriends=_BS_Friends_HasFriend@12")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetClanCount(ISteamFriends* lpSteamFriends) {
+DLL_FUNCTION(int32_t) BS_Friends_GetClanCount(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetClanCount();
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetClanCount=_BS_Friends_GetClanCount@4")

-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetClanByIndex(ISteamFriends* lpSteamFriends, int32_t iClan) {
+DLL_FUNCTION(CSteamID*) BS_Friends_GetClanByIndex(ISteamFriends* lpSteamFriends, int32_t iClan) {
 	CSteamID* steamID = new CSteamID(lpSteamFriends->GetClanByIndex(iClan));
 	return steamID;
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetClanByIndex=_BS_Friends_GetClanByIndex@8")

-DLL_EXPORT const char* DLL_CALL BS_Friends_GetClanName(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL_FUNCTION(const char*) BS_Friends_GetClanName(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return lpSteamFriends->GetClanName(*steamIDClan);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetClanName=_BS_Friends_GetClanName@8")

-DLL_EXPORT const char* DLL_CALL BS_Friends_GetClanTag(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL_FUNCTION(const char*) BS_Friends_GetClanTag(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return lpSteamFriends->GetClanTag(*steamIDClan);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetClanTag=_BS_Friends_GetClanTag@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_GetClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t* pnOnline, int32_t* pnInGame, int32_t* pnChatting) {
+DLL_FUNCTION(uint32_t) BS_Friends_GetClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t* pnOnline, int32_t* pnInGame, int32_t* pnChatting) {
 	return lpSteamFriends->GetClanActivityCounts(*steamIDClan, pnOnline, pnInGame, pnChatting);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetClanActivityCounts=_BS_Friends_GetClanActivityCounts@20")

-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_DownloadClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* psteamIDClans, int32_t cClansToRequest) {
-	return lpSteamFriends->DownloadClanActivityCounts(psteamIDClans, cClansToRequest);
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_DownloadClanActivityCounts(ISteamFriends* lpSteamFriends, CSteamID* psteamIDClans, int32_t cClansToRequest) {
+	return new uint64_t(lpSteamFriends->DownloadClanActivityCounts(psteamIDClans, cClansToRequest));
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_DownloadClanActivityCounts=_BS_Friends_DownloadClanActivityCounts@12")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendCountFromSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource) {
+DLL_FUNCTION(int32_t) BS_Friends_GetFriendCountFromSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource) {
 	return lpSteamFriends->GetFriendCountFromSource(*steamIDSource);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCountFromSource=_BS_Friends_GetFriendCountFromSource@8")

-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetFriendFromSourceByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource, int32_t iFriend) {
-	CSteamID* steamID = new CSteamID(lpSteamFriends->GetFriendFromSourceByIndex(*steamIDSource, iFriend));
-	return steamID;
+DLL_FUNCTION(CSteamID*) BS_Friends_GetFriendFromSourceByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDSource, int32_t iFriend) {
+	return new CSteamID(lpSteamFriends->GetFriendFromSourceByIndex(*steamIDSource, iFriend));
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendFromSourceByIndex=_BS_Friends_GetFriendFromSourceByIndex@12")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_IsUserInSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, CSteamID* steamIDSource) {
+DLL_FUNCTION(uint32_t) BS_Friends_IsUserInSource(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, CSteamID* steamIDSource) {
 	return lpSteamFriends->IsUserInSource(*steamIDUser, *steamIDSource);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_IsUserInSource=_BS_Friends_IsUserInSource@12")

-DLL_EXPORT void DLL_CALL BS_Friends_SetInGameVoiceSpeaking(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bSpeaking) {
+DLL_FUNCTION(void) BS_Friends_SetInGameVoiceSpeaking(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bSpeaking) {
 	lpSteamFriends->SetInGameVoiceSpeaking(*steamIDUser, bSpeaking != 0);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_SetInGameVoiceSpeaking=_BS_Friends_SetInGameVoiceSpeaking@12")

-DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlay(ISteamFriends* lpSteamFriends, const char* pchDialog) {
+DLL_FUNCTION(void) BS_Friends_ActivateGameOverlay(ISteamFriends* lpSteamFriends, const char* pchDialog) {
 	lpSteamFriends->ActivateGameOverlay(pchDialog);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlay=_BS_Friends_ActivateGameOverlay@8")

-DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlayToUser(ISteamFriends* lpSteamFriends, const char* pchDialog, CSteamID* steamID) {
+DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayToUser(ISteamFriends* lpSteamFriends, const char* pchDialog, CSteamID* steamID) {
 	lpSteamFriends->ActivateGameOverlayToUser(pchDialog, *steamID);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToUser=_BS_Friends_ActivateGameOverlayToUser@12")

-DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlayToWebPage(ISteamFriends* lpSteamFriends, const char* pchURL) {
+DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayToWebPage(ISteamFriends* lpSteamFriends, const char* pchURL) {
 	lpSteamFriends->ActivateGameOverlayToWebPage(pchURL);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToWebPage=_BS_Friends_ActivateGameOverlayToWebPage@8")

-DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlayToStore(ISteamFriends* lpSteamFriends, AppId_t nAppID, EOverlayToStoreFlag eFlag) {
+DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayToStore(ISteamFriends* lpSteamFriends, AppId_t nAppID, EOverlayToStoreFlag eFlag) {
 	lpSteamFriends->ActivateGameOverlayToStore(nAppID, eFlag);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayToStore=_BS_Friends_ActivateGameOverlayToStore@12")

-DLL_EXPORT void DLL_CALL BS_Friends_SetPlayedWith(ISteamFriends* lpSteamFriends, CSteamID* steamIDUserPlayedWith) {
+DLL_FUNCTION(void) BS_Friends_SetPlayedWith(ISteamFriends* lpSteamFriends, CSteamID* steamIDUserPlayedWith) {
 	lpSteamFriends->SetPlayedWith(*steamIDUserPlayedWith);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_SetPlayedWith=_BS_Friends_SetPlayedWith@8")

-DLL_EXPORT void DLL_CALL BS_Friends_ActivateGameOverlayInviteDialog(ISteamFriends* lpSteamFriends, CSteamID* steamIDLobby) {
+DLL_FUNCTION(void) BS_Friends_ActivateGameOverlayInviteDialog(ISteamFriends* lpSteamFriends, CSteamID* steamIDLobby) {
 	lpSteamFriends->ActivateGameOverlayInviteDialog(*steamIDLobby);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_ActivateGameOverlayInviteDialog=_BS_Friends_ActivateGameOverlayInviteDialog@8")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetSmallFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(int32_t) BS_Friends_GetSmallFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetSmallFriendAvatar(*steamIDFriend);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetSmallFriendAvatar=_BS_Friends_GetSmallFriendAvatar@8")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetMediumFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(int32_t) BS_Friends_GetMediumFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetMediumFriendAvatar(*steamIDFriend);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetMediumFriendAvatar=_BS_Friends_GetMediumFriendAvatar@8")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetLargeFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(int32_t) BS_Friends_GetLargeFriendAvatar(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetLargeFriendAvatar(*steamIDFriend);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetLargeFriendAvatar=_BS_Friends_GetLargeFriendAvatar@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_RequestUserInformation(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bRequireNameOnly) {
+DLL_FUNCTION(uint32_t) BS_Friends_RequestUserInformation(ISteamFriends* lpSteamFriends, CSteamID* steamIDUser, uint32_t bRequireNameOnly) {
 	return lpSteamFriends->RequestUserInformation(*steamIDUser, bRequireNameOnly != 0);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_RequestUserInformation=_BS_Friends_RequestUserInformation@12")

-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_RequestClanOfficerList(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
-	return lpSteamFriends->RequestClanOfficerList(*steamIDClan);
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_RequestClanOfficerList(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+	return new uint64_t(lpSteamFriends->RequestClanOfficerList(*steamIDClan));
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_RequestClanOfficerList=_BS_Friends_RequestClanOfficerList@8")

-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetClanOwner(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
-	CSteamID* steamID = new CSteamID(lpSteamFriends->GetClanOwner(*steamIDClan));
-	return steamID;
+DLL_FUNCTION(CSteamID*) BS_Friends_GetClanOwner(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+	return new CSteamID(lpSteamFriends->GetClanOwner(*steamIDClan));
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetClanOwner=_BS_Friends_GetClanOwner@8")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetClanOfficerCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL_FUNCTION(int32_t) BS_Friends_GetClanOfficerCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return lpSteamFriends->GetClanOfficerCount(*steamIDClan);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetClanOfficerCount=_BS_Friends_GetClanOfficerCount@8")

-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetClanOfficerByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iOfficer) {
+DLL_FUNCTION(CSteamID*) BS_Friends_GetClanOfficerByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iOfficer) {
 	CSteamID* steamID = new CSteamID(lpSteamFriends->GetClanOfficerByIndex(*steamIDClan, iOfficer));
 	return steamID;
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetClanOfficerByIndex=_BS_Friends_GetClanOfficerByIndex@12")

-DLL_EXPORT EUserRestriction DLL_CALL BS_Friends_GetUserRestrictions(ISteamFriends* lpSteamFriends) {
+DLL_FUNCTION(EUserRestriction) BS_Friends_GetUserRestrictions(ISteamFriends* lpSteamFriends) {
 	return (EUserRestriction)lpSteamFriends->GetUserRestrictions();
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetUserRestrictions=_BS_Friends_GetUserRestrictions@4")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_SetRichPresence(ISteamFriends* lpSteamFriends, const char* pchKey, const char* pchValue) {
+DLL_FUNCTION(uint32_t) BS_Friends_SetRichPresence(ISteamFriends* lpSteamFriends, const char* pchKey, const char* pchValue) {
 	return lpSteamFriends->SetRichPresence(pchKey, pchValue);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_SetRichPresence=_BS_Friends_SetRichPresence@12")

-DLL_EXPORT void DLL_CALL BS_Friends_ClearRichPresence(ISteamFriends* lpSteamFriends) {
+DLL_FUNCTION(void) BS_Friends_ClearRichPresence(ISteamFriends* lpSteamFriends) {
 	lpSteamFriends->ClearRichPresence();
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_ClearRichPresence=_BS_Friends_ClearRichPresence@4")

-DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchKey) {
+DLL_FUNCTION(const char*) BS_Friends_GetFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchKey) {
 	return lpSteamFriends->GetFriendRichPresence(*steamIDFriend, pchKey);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresence=_BS_Friends_GetFriendRichPresence@12")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendRichPresenceKeyCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(int32_t) BS_Friends_GetFriendRichPresenceKeyCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendRichPresenceKeyCount(*steamIDFriend);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresenceKeyCount=_BS_Friends_GetFriendRichPresenceKeyCount@8")

-DLL_EXPORT const char* DLL_CALL BS_Friends_GetFriendRichPresenceKeyByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iKey) {
+DLL_FUNCTION(const char*) BS_Friends_GetFriendRichPresenceKeyByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iKey) {
 	return lpSteamFriends->GetFriendRichPresenceKeyByIndex(*steamIDFriend, iKey);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendRichPresenceKeyByIndex=_BS_Friends_GetFriendRichPresenceKeyByIndex@12")

-DLL_EXPORT void DLL_CALL BS_Friends_RequestFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(void) BS_Friends_RequestFriendRichPresence(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	lpSteamFriends->RequestFriendRichPresence(*steamIDFriend);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_RequestFriendRichPresence=_BS_Friends_RequestFriendRichPresence@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_InviteUserToGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char *pchConnectString) {
+DLL_FUNCTION(uint32_t) BS_Friends_InviteUserToGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char *pchConnectString) {
 	return lpSteamFriends->InviteUserToGame(*steamIDFriend, pchConnectString);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_InviteUserToGame=_BS_Friends_InviteUserToGame@12")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetCoplayFriendCount(ISteamFriends* lpSteamFriends) {
+DLL_FUNCTION(int32_t) BS_Friends_GetCoplayFriendCount(ISteamFriends* lpSteamFriends) {
 	return lpSteamFriends->GetCoplayFriendCount();
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetCoplayFriendCount=_BS_Friends_GetCoplayFriendCount@4")

-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetCoplayFriend(ISteamFriends* lpSteamFriends, int32_t iCoplayFriend) {
+DLL_FUNCTION(CSteamID*) BS_Friends_GetCoplayFriend(ISteamFriends* lpSteamFriends, int32_t iCoplayFriend) {
 	CSteamID* steamID = new CSteamID(lpSteamFriends->GetCoplayFriend(iCoplayFriend));
 	return steamID;
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetCoplayFriend=_BS_Friends_GetCoplayFriend@8")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendCoplayTime(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(int32_t) BS_Friends_GetFriendCoplayTime(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendCoplayTime(*steamIDFriend);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCoplayTime=_BS_Friends_GetFriendCoplayTime@8")

-DLL_EXPORT AppId_t DLL_CALL BS_Friends_GetFriendCoplayGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
+DLL_FUNCTION(AppId_t) BS_Friends_GetFriendCoplayGame(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend) {
 	return lpSteamFriends->GetFriendCoplayGame(*steamIDFriend);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendCoplayGame=_BS_Friends_GetFriendCoplayGame@8")

-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_JoinClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
-	return lpSteamFriends->JoinClanChatRoom(*steamIDClan);
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_JoinClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+	return new uint64_t(lpSteamFriends->JoinClanChatRoom(*steamIDClan));
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_JoinClanChatRoom=_BS_Friends_JoinClanChatRoom@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_LeaveClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL_FUNCTION(uint32_t) BS_Friends_LeaveClanChatRoom(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return lpSteamFriends->LeaveClanChatRoom(*steamIDClan);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_LeaveClanChatRoom=_BS_Friends_LeaveClanChatRoom@8")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetClanChatMemberCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
+DLL_FUNCTION(int32_t) BS_Friends_GetClanChatMemberCount(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan) {
 	return lpSteamFriends->GetClanChatMemberCount(*steamIDClan);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetClanChatMemberCount=_BS_Friends_GetClanChatMemberCount@8")

-DLL_EXPORT CSteamID* DLL_CALL BS_Friends_GetChatMemberByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iUser) {
+DLL_FUNCTION(CSteamID*) BS_Friends_GetChatMemberByIndex(ISteamFriends* lpSteamFriends, CSteamID* steamIDClan, int32_t iUser) {
 	CSteamID* steamID = new CSteamID(lpSteamFriends->GetChatMemberByIndex(*steamIDClan, iUser));
 	return steamID;
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetChatMemberByIndex=_BS_Friends_GetChatMemberByIndex@12")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_SendClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, const char *pchText) {
+DLL_FUNCTION(uint32_t) BS_Friends_SendClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, const char *pchText) {
 	return lpSteamFriends->SendClanChatMessage(*steamIDClanChat, pchText);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_SendClanChatMessage=_BS_Friends_SendClanChatMessage@12")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, int32_t iMessage, void* prgchText, int32_t cchTextMax, EChatEntryType* peChatEntryType, CSteamID* psteamidChatter) {
+DLL_FUNCTION(int32_t) BS_Friends_GetClanChatMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, int32_t iMessage, void* prgchText, int32_t cchTextMax, EChatEntryType* peChatEntryType, CSteamID* psteamidChatter) {
 	return lpSteamFriends->GetClanChatMessage(*steamIDClanChat, iMessage, prgchText, cchTextMax, peChatEntryType, psteamidChatter);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetClanChatMessage=_BS_Friends_GetClanChatMessage@28")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_IsClanChatAdmin(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, CSteamID* steamIDUser) {
+DLL_FUNCTION(uint32_t) BS_Friends_IsClanChatAdmin(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat, CSteamID* steamIDUser) {
 	return lpSteamFriends->IsClanChatAdmin(*steamIDClanChat, *steamIDUser);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_IsClanChatAdmin=_BS_Friends_IsClanChatAdmin@12")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_IsClanChatWindowOpenInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
+DLL_FUNCTION(uint32_t) BS_Friends_IsClanChatWindowOpenInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
 	return lpSteamFriends->IsClanChatWindowOpenInSteam(*steamIDClanChat);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_IsClanChatWindowOpenInSteam=_BS_Friends_IsClanChatWindowOpenInSteam@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_OpenClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
+DLL_FUNCTION(uint32_t) BS_Friends_OpenClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
 	return lpSteamFriends->OpenClanChatWindowInSteam(*steamIDClanChat);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_OpenClanChatWindowInSteam=_BS_Friends_OpenClanChatWindowInSteam@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_CloseClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
+DLL_FUNCTION(uint32_t) BS_Friends_CloseClanChatWindowInSteam(ISteamFriends* lpSteamFriends, CSteamID* steamIDClanChat) {
 	return lpSteamFriends->CloseClanChatWindowInSteam(*steamIDClanChat);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_CloseClanChatWindowInSteam=_BS_Friends_CloseClanChatWindowInSteam@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_SetListenForFriendsMessages(ISteamFriends* lpSteamFriends, uint32_t bInterceptEnabled) {
+DLL_FUNCTION(uint32_t) BS_Friends_SetListenForFriendsMessages(ISteamFriends* lpSteamFriends, uint32_t bInterceptEnabled) {
 	return lpSteamFriends->SetListenForFriendsMessages(bInterceptEnabled != 0);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_SetListenForFriendsMessages=_BS_Friends_SetListenForFriendsMessages@8")

-DLL_EXPORT uint32_t DLL_CALL BS_Friends_ReplyToFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchMsgToSend) {
+DLL_FUNCTION(uint32_t) BS_Friends_ReplyToFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, const char* pchMsgToSend) {
 	return lpSteamFriends->ReplyToFriendMessage(*steamIDFriend, pchMsgToSend);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_ReplyToFriendMessage=_BS_Friends_ReplyToFriendMessage@12")

-DLL_EXPORT int32_t DLL_CALL BS_Friends_GetFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iMessageID, void* pvData, int32_t cubData, EChatEntryType* peChatEntryType) {
+DLL_FUNCTION(int32_t) BS_Friends_GetFriendMessage(ISteamFriends* lpSteamFriends, CSteamID* steamIDFriend, int32_t iMessageID, void* pvData, int32_t cubData, EChatEntryType* peChatEntryType) {
 	return lpSteamFriends->GetFriendMessage(*steamIDFriend, iMessageID, pvData, cubData, peChatEntryType);
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFriendMessage=_BS_Friends_GetFriendMessage@24")

-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_GetFollowerCount(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
-	return lpSteamFriends->GetFollowerCount(*steamID);
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_GetFollowerCount(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
+	return new uint64_t(lpSteamFriends->GetFollowerCount(*steamID));
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_GetFollowerCount=_BS_Friends_GetFollowerCount@8")

-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_IsFollowing(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
-	return lpSteamFriends->IsFollowing(*steamID);
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_IsFollowing(ISteamFriends* lpSteamFriends, CSteamID* steamID) {
+	return new uint64_t(lpSteamFriends->IsFollowing(*steamID));
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_IsFollowing=_BS_Friends_IsFollowing@8")

-DLL_EXPORT SteamAPICall_t DLL_CALL BS_Friends_EnumerateFollowingList(ISteamFriends* lpSteamFriends, uint32 unStartIndex) {
-	return lpSteamFriends->EnumerateFollowingList(unStartIndex);
+DLL_FUNCTION(SteamAPICall_t*) BS_Friends_EnumerateFollowingList(ISteamFriends* lpSteamFriends, uint32_t unStartIndex) {
+	return new uint64_t(lpSteamFriends->EnumerateFollowingList(unStartIndex));
 }
 #pragma comment(linker, "/EXPORT:BS_Friends_EnumerateFollowingList=_BS_Friends_EnumerateFollowingList@8")
@@ -14,55 +14,260 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

-#include "dllmain.h"
-#include "SteamworksSDK/public/steam/steam_gameserver.h"
+#include "BlitzSteam.h"

-DLL_EXPORT uint32_t DLL_CALL BS_GameServer_Init(uint32_t unIP, uint16_t usSteamPort, uint16_t usGamePort, uint16_t usQueryPort, EServerMode eServerMode, const char *pchVersionString) {
-	return SteamGameServer_Init(unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString);
-}
-
-DLL_EXPORT void DLL_CALL BS_GameServer_Shutdown() {
-	SteamGameServer_Shutdown();
-}
-
-DLL_EXPORT void DLL_CALL BS_GameServer_RunCallbacks() {
-	SteamGameServer_RunCallbacks();
-}
-
-DLL_EXPORT uint32_t DLL_CALL BS_GameServer_Secure() {
-	return SteamGameServer_BSecure();
-}
-
-DLL_EXPORT uint64_t* DLL_CALL BS_GameServer_GetSteamID() {
-	uint64_t* val = new uint64_t(SteamGameServer_GetSteamID());
-	return val;
-}
-
-DLL_EXPORT HSteamPipe DLL_CALL BS_GameServer_GetHSteamPipe() {
-	return SteamGameServer_GetHSteamPipe();
-}
-
-// Interfaces
-DLL_EXPORT ISteamGameServer* DLL_CALL BS_GameServer() {
+DLL_FUNCTION(ISteamGameServer*) BS_GameServer() {
+#pragma comment(linker, "/EXPORT:BS_GameServer=_BS_GameServer@0")
 	return SteamGameServer();
 }

-DLL_EXPORT ISteamUtils* DLL_CALL BS_GameServerUtils() {
-	return SteamGameServerUtils();
+DLL_FUNCTION(uint32_t) BS_GameServer_Init(uint32_t unIP, uint16_t usSteamPort, uint16_t usGamePort, uint16_t usQueryPort, EServerMode eServerMode, const char *pchVersionString) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_Init=_BS_GameServer_Init@24")
+	return SteamGameServer_Init(unIP, usSteamPort, usGamePort, usQueryPort, eServerMode, pchVersionString);
 }

-DLL_EXPORT ISteamNetworking* DLL_CALL BS_GameServerNetworking() {
-	return SteamGameServerNetworking();
+DLL_FUNCTION(void) BS_GameServer_Shutdown() {
+#pragma comment(linker, "/EXPORT:BS_GameServer_Shutdown=_BS_GameServer_Shutdown@0")
+	SteamGameServer_Shutdown();
 }

-DLL_EXPORT ISteamGameServerStats* DLL_CALL BS_GameServerStats() {
-	return SteamGameServerStats();
+DLL_FUNCTION(void) BS_GameServer_RunCallbacks() {
+#pragma comment(linker, "/EXPORT:BS_GameServer_RunCallbacks=_BS_GameServer_RunCallbacks@0")
+	SteamGameServer_RunCallbacks();
 }

-DLL_EXPORT ISteamHTTP* DLL_CALL BS_GameServerHTTP() {
-	return SteamGameServerHTTP();
+DLL_FUNCTION(HSteamPipe) BS_GameServer_GetHSteamPipe() {
+#pragma comment(linker, "/EXPORT:BS_GameServer_GetHSteamPipe=_BS_GameServer_GetHSteamPipe@0")
+	return SteamGameServer_GetHSteamPipe();
 }

-DLL_EXPORT ISteamInventory* DLL_CALL BS_GameServerInventory() {
-	return SteamGameServerInventory();
+DLL_FUNCTION(uint32_t) BS_GameServer_IsSecureC() {
+#pragma comment(linker, "/EXPORT:BS_GameServer_IsSecureC=_BS_GameServer_IsSecureC@0")
+	return SteamGameServer_BSecure();
+}
+
+DLL_FUNCTION(CSteamID*) BS_GameServer_GetSteamIDC() {
+#pragma comment(linker, "/EXPORT:BS_GameServer_GetSteamIDC=_BS_GameServer_GetSteamIDC@0")
+	return new CSteamID(SteamGameServer_GetSteamID());
+}
+
+// ISteamGameServer Stuff
+DLL_FUNCTION(uint32_t) BS_GameServer_InitGameServer(ISteamGameServer* pSteamGameServer, uint32_t unIP, uint16_t usGamePort, uint16_t usQueryPort, uint32_t unFlags, AppId_t nGameAppId, const char *pchVersionString) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_InitGameServer=_BS_GameServer_InitGameServer@28")
+	return pSteamGameServer->InitGameServer(unIP, usGamePort, usQueryPort, unFlags, nGameAppId, pchVersionString);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetProduct(ISteamGameServer* pSteamGameServer, const char *pszProduct) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetProduct=_BS_GameServer_SetProduct@8")
+	pSteamGameServer->SetProduct(pszProduct);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetGameDescription(ISteamGameServer* pSteamGameServer, const char *pszGameDescription) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetGameDescription=_BS_GameServer_SetGameDescription@8")
+	pSteamGameServer->SetGameDescription(pszGameDescription);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetModDir(ISteamGameServer* pSteamGameServer, const char *pszModDir) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetModDir=_BS_GameServer_SetModDir@8")
+	pSteamGameServer->SetModDir(pszModDir);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetDedicatedServer(ISteamGameServer* pSteamGameServer, uint32_t bDedicated) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetDedicatedServer=_BS_GameServer_SetDedicatedServer@8")
+	pSteamGameServer->SetDedicatedServer(!!bDedicated);
+}
+
+DLL_FUNCTION(void) BS_GameServer_LogOn(ISteamGameServer* pSteamGameServer, const char *pszToken) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_LogOn=_BS_GameServer_LogOn@8")
+	pSteamGameServer->LogOn(pszToken);
+}
+
+DLL_FUNCTION(void) BS_GameServer_LogOnAnonymous(ISteamGameServer* pSteamGameServer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_LogOnAnonymous=_BS_GameServer_LogOnAnonymous@4")
+	pSteamGameServer->LogOnAnonymous();
+}
+
+DLL_FUNCTION(void) BS_GameServer_LogOff(ISteamGameServer* pSteamGameServer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_LogOff=_BS_GameServer_LogOff@4")
+	pSteamGameServer->LogOff();
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServer_IsLoggedOn(ISteamGameServer* pSteamGameServer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_IsLoggedOn=_BS_GameServer_IsLoggedOn@4")
+	return pSteamGameServer->BLoggedOn();
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServer_IsSecure(ISteamGameServer* pSteamGameServer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_IsSecure=_BS_GameServer_IsSecure@4")
+	return pSteamGameServer->BSecure();
+}
+
+DLL_FUNCTION(CSteamID*) BS_GameServer_GetSteamID(ISteamGameServer* pSteamGameServer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_GetSteamID=_BS_GameServer_GetSteamID@4")
+	return new CSteamID(pSteamGameServer->GetSteamID());
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServer_WasRestartRequested(ISteamGameServer* pSteamGameServer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_WasRestartRequested=_BS_GameServer_WasRestartRequested@4")
+	return pSteamGameServer->WasRestartRequested();
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetMaxPlayerCount(ISteamGameServer* pSteamGameServer, int32_t cPlayersMax) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetMaxPlayerCount=_BS_GameServer_SetMaxPlayerCount@8")
+	pSteamGameServer->SetMaxPlayerCount(cPlayersMax);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetBotPlayerCount(ISteamGameServer* pSteamGameServer, int32_t cBotplayers) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetBotPlayerCount=_BS_GameServer_SetBotPlayerCount@8")
+	pSteamGameServer->SetBotPlayerCount(cBotplayers);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetServerName(ISteamGameServer* pSteamGameServer, const char *pszServerName) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetServerName=_BS_GameServer_SetServerName@8")
+	pSteamGameServer->SetServerName(pszServerName);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetMapName(ISteamGameServer* pSteamGameServer, const char *pszMapName) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetMapName=_BS_GameServer_SetMapName@8")
+	pSteamGameServer->SetMapName(pszMapName);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetPasswordProtected(ISteamGameServer* pSteamGameServer, uint32_t bPasswordProtected) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetPasswordProtected=_BS_GameServer_SetPasswordProtected@8")
+	pSteamGameServer->SetPasswordProtected(!!bPasswordProtected);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetSpectatorPort(ISteamGameServer* pSteamGameServer, uint16_t unSpectatorPort) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetSpectatorPort=_BS_GameServer_SetSpectatorPort@8")
+	pSteamGameServer->SetSpectatorPort(unSpectatorPort);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetSpectatorServerName(ISteamGameServer* pSteamGameServer, const char *pszSpectatorServerName) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetSpectatorServerName=_BS_GameServer_SetSpectatorServerName@8")
+	pSteamGameServer->SetSpectatorServerName(pszSpectatorServerName);
+}
+
+DLL_FUNCTION(void) BS_GameServer_ClearAllKeyValues(ISteamGameServer* pSteamGameServer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_ClearAllKeyValues=_BS_GameServer_ClearAllKeyValues@4")
+	pSteamGameServer->ClearAllKeyValues();
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetKeyValue(ISteamGameServer* pSteamGameServer, const char *pKey, const char *pValue) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetKeyValue=_BS_GameServer_SetKeyValue@12")
+	pSteamGameServer->SetKeyValue(pKey, pValue);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetGameTags(ISteamGameServer* pSteamGameServer, const char *pchGameTags) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetGameTags=_BS_GameServer_SetGameTags@8")
+	pSteamGameServer->SetGameTags(pchGameTags);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetGameData(ISteamGameServer* pSteamGameServer, const char *pchGameData) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetGameData=_BS_GameServer_SetGameData@8")
+	pSteamGameServer->SetGameData(pchGameData);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetRegion(ISteamGameServer* pSteamGameServer, const char *pszRegion) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetRegion=_BS_GameServer_SetRegion@8")
+	pSteamGameServer->SetRegion(pszRegion);
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServer_SendUserConnectAndAuthenticate(ISteamGameServer* pSteamGameServer, uint32_t unIPClient, const void *pvAuthBlob, uint32_t cubAuthBlobSize, CSteamID *pSteamIDUser) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SendUserConnectAndAuthenticate=_BS_GameServer_SendUserConnectAndAuthenticate@20")
+	return pSteamGameServer->SendUserConnectAndAuthenticate(unIPClient, pvAuthBlob, cubAuthBlobSize, pSteamIDUser);
+}
+
+DLL_FUNCTION(CSteamID*) BS_GameServer_CreateUnauthenticatedUserConnection(ISteamGameServer* pSteamGameServer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_CreateUnauthenticatedUserConnection=_BS_GameServer_CreateUnauthenticatedUserConnection@4")
+	return new CSteamID(pSteamGameServer->CreateUnauthenticatedUserConnection());
+}
+
+DLL_FUNCTION(void) BS_GameServer_SendUserDisconnect(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SendUserDisconnect=_BS_GameServer_SendUserDisconnect@8")
+	pSteamGameServer->SendUserDisconnect(*pSteamIDUser);
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServer_UpdateUserData(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser, const char *pchPlayerName, uint32_t uScore) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_UpdateUserData=_BS_GameServer_UpdateUserData@16")
+	return pSteamGameServer->BUpdateUserData(*pSteamIDUser, pchPlayerName, uScore);
+}
+
+DLL_FUNCTION(HAuthTicket) BS_GameServer_GetAuthSessionTicket(ISteamGameServer* pSteamGameServer, void *pTicket, int32_t cbMaxTicket, uint32_t *pcbTicket) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_GetAuthSessionTicket=_BS_GameServer_GetAuthSessionTicket@16")
+	return pSteamGameServer->GetAuthSessionTicket(pTicket, cbMaxTicket, pcbTicket);
+}
+
+DLL_FUNCTION(EBeginAuthSessionResult) BS_GameServer_BeginAuthSession(ISteamGameServer* pSteamGameServer, const void *pAuthTicket, int32_t cbAuthTicket, CSteamID* pSteamID) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_BeginAuthSession=_BS_GameServer_BeginAuthSession@16")
+	return pSteamGameServer->BeginAuthSession(pAuthTicket, cbAuthTicket, *pSteamID);
+}
+
+DLL_FUNCTION(void) BS_GameServer_EndAuthSession(ISteamGameServer* pSteamGameServer, CSteamID* pSteamID) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_EndAuthSession=_BS_GameServer_EndAuthSession@8")
+	pSteamGameServer->EndAuthSession(*pSteamID);
+}
+
+DLL_FUNCTION(void) BS_GameServer_CancelAuthTicket(ISteamGameServer* pSteamGameServer, HAuthTicket hAuthTicket) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_CancelAuthTicket=_BS_GameServer_CancelAuthTicket@8")
+	pSteamGameServer->CancelAuthTicket(hAuthTicket);
+}
+
+DLL_FUNCTION(EUserHasLicenseForAppResult) BS_GameServer_UserHasLicenseForApp(ISteamGameServer* pSteamGameServer, CSteamID* pSteamID, AppId_t appID) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_UserHasLicenseForApp=_BS_GameServer_UserHasLicenseForApp@12")
+	return pSteamGameServer->UserHasLicenseForApp(*pSteamID, appID);
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServer_RequestUserGroupStatus(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDUser, CSteamID* pSteamIDGroup) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_RequestUserGroupStatus=_BS_GameServer_RequestUserGroupStatus@12")
+	return pSteamGameServer->RequestUserGroupStatus(*pSteamIDUser, *pSteamIDGroup);
+}
+
+DLL_FUNCTION(void) BS_GameServer_GetGameplayStats(ISteamGameServer* pSteamGameServer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_GetGameplayStats=_BS_GameServer_GetGameplayStats@4")
+	pSteamGameServer->GetGameplayStats();
+}
+
+DLL_FUNCTION(SteamAPICall_t*) BS_GameServer_GetServerReputation(ISteamGameServer* pSteamGameServer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_GetServerReputation=_BS_GameServer_GetServerReputation@4")
+	return new uint64_t(pSteamGameServer->GetServerReputation());
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServer_GetPublicIP(ISteamGameServer* pSteamGameServer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_GetPublicIP=_BS_GameServer_GetPublicIP@4")
+	return pSteamGameServer->GetPublicIP();
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServer_HandleIncomingPacket(ISteamGameServer* pSteamGameServer, const void *pData, int32_t cbData, uint32_t srcIP, uint16_t srcPort) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_HandleIncomingPacket=_BS_GameServer_HandleIncomingPacket@20")
+	return pSteamGameServer->HandleIncomingPacket(pData, cbData, srcIP, srcPort);
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServer_GetNextOutgoingPacket(ISteamGameServer* pSteamGameServer, void *pOut, int32_t cbMaxOut, uint32_t *pNetAdr, uint16_t *pPort) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_GetNextOutgoingPacket=_BS_GameServer_GetNextOutgoingPacket@20")
+	return pSteamGameServer->GetNextOutgoingPacket(pOut, cbMaxOut, pNetAdr, pPort);
+}
+
+DLL_FUNCTION(void) BS_GameServer_EnableHeartbeats(ISteamGameServer* pSteamGameServer, uint32_t bActive) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_EnableHeartbeats=_BS_GameServer_EnableHeartbeats@8")
+	pSteamGameServer->EnableHeartbeats(!!bActive);
+}
+
+DLL_FUNCTION(void) BS_GameServer_SetHeartbeatInterval(ISteamGameServer* pSteamGameServer, int32_t iHeartbeatInterval) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_SetHeartbeatInterval=_BS_GameServer_SetHeartbeatInterval@8")
+	pSteamGameServer->SetHeartbeatInterval(iHeartbeatInterval);
+}
+
+DLL_FUNCTION(void) BS_GameServer_ForceHeartbeat(ISteamGameServer* pSteamGameServer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_ForceHeartbeat=_BS_GameServer_ForceHeartbeat@4")
+	pSteamGameServer->ForceHeartbeat();
+}
+
+DLL_FUNCTION(SteamAPICall_t*) BS_GameServer_AssociateWithClan(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDClan) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_AssociateWithClan=_BS_GameServer_AssociateWithClan@8")
+	return new uint64_t(pSteamGameServer->AssociateWithClan(*pSteamIDClan));
+}
+
+DLL_FUNCTION(SteamAPICall_t*) BS_GameServer_ComputeNewPlayerCompatibility(ISteamGameServer* pSteamGameServer, CSteamID* pSteamIDNewPlayer) {
+#pragma comment(linker, "/EXPORT:BS_GameServer_ComputeNewPlayerCompatibility=_BS_GameServer_ComputeNewPlayerCompatibility@8")
+	return new uint64_t(pSteamGameServer->ComputeNewPlayerCompatibility(*pSteamIDNewPlayer));
 }
@@ -0,0 +1,63 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamGameServerStats*) BS_GameServerStats() {
+#pragma comment(linker, "/EXPORT:BS_GameServerStats=_BS_GameServerStats@0")
+	return SteamGameServerStats();
+}
+
+DLL_FUNCTION(SteamAPICall_t*) BS_GameServerStats_RequestUserStats(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser) {
+	return new uint64_t(pSteamGameServerStats->RequestUserStats(*steamIDUser));
+}
+
+DLL_FUNCTION(SteamAPICall_t*) BS_GameServerStats_StoreUserStats(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser) {
+	return new uint64_t(pSteamGameServerStats->StoreUserStats(*steamIDUser));
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServerStats_GetUserStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pData) {
+	return pSteamGameServerStats->GetUserStat(*steamIDUser, pchName, (int32_t*)pData);
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServerStats_GetUserStatF(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, float_t* pData) {
+	return pSteamGameServerStats->GetUserStat(*steamIDUser, pchName, pData);
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServerStats_GetUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pbAchieved) {
+	return pSteamGameServerStats->GetUserAchievement(*steamIDUser, pchName, (bool*)pbAchieved);
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServerStats_SetUserStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, uint32_t nData) {
+	return pSteamGameServerStats->SetUserStat(*steamIDUser, pchName, (int32_t)nData);
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServerStats_SetUserStatF(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName, float_t fData) {
+	return pSteamGameServerStats->SetUserStat(*steamIDUser, pchName, fData);
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServerStats_UpdateUserAvgRateStat(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char *pchName, float flCountThisSession, double* pdSessionLength) {
+	return pSteamGameServerStats->UpdateUserAvgRateStat(*steamIDUser, pchName, flCountThisSession, *pdSessionLength);
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServerStats_SetUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName) {
+	return pSteamGameServerStats->SetUserAchievement(*steamIDUser, pchName);
+}
+
+DLL_FUNCTION(uint32_t) BS_GameServerStats_ClearUserAchievement(ISteamGameServerStats* pSteamGameServerStats, CSteamID* steamIDUser, const char* pchName) {
+	return pSteamGameServerStats->ClearUserAchievement(*steamIDUser, pchName);
+}
+
@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamHTMLSurface*) BS_HTMLSurface() {
+	return SteamHTMLSurface();
+}
+#pragma comment(linker, "/EXPORT:BS_HTMLSurface=_BS_HTMLSurface@0")
+
@@ -0,0 +1,28 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamHTTP*) BS_HTTP() {
+	return SteamHTTP();
+}
+#pragma comment(linker, "/EXPORT:BS_HTTP=_BS_HTTP@0")
+
+DLL_FUNCTION(ISteamHTTP*) BS_GameServerHTTP() {
+#pragma comment(linker, "/EXPORT:BS_GameServerHTTP=_BS_GameServerHTTP@0")
+	return SteamGameServerHTTP();
+}
+
@@ -0,0 +1,28 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamInventory*) BS_Inventory() {
+	return SteamInventory();
+}
+#pragma comment(linker, "/EXPORT:BS_Inventory=_BS_Inventory@0")
+
+DLL_FUNCTION(ISteamInventory*) BS_GameServerInventory() {
+#pragma comment(linker, "/EXPORT:BS_GameServerInventory=_BS_GameServerInventory@0")
+	return SteamGameServerInventory();
+}
+
@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamMatchmaking*) BS_Matchmaking() {
+	return SteamMatchmaking();
+}
+#pragma comment(linker, "/EXPORT:BS_Matchmaking=_BS_Matchmaking@0")
+
@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamMatchmakingServers*) BS_MatchmakingServers() {
+	return SteamMatchmakingServers();
+}
+#pragma comment(linker, "/EXPORT:BS_MatchmakingServers=_BS_MatchmakingServers@0")
+
@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamMusic*) BS_Music() {
+	return SteamMusic();
+}
+#pragma comment(linker, "/EXPORT:BS_Music=_BS_Music@0")
+
@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamMusicRemote*) BS_MusicRemote() {
+	return SteamMusicRemote();
+}
+#pragma comment(linker, "/EXPORT:BS_MusicRemote=_BS_MusicRemote@0")
+
@@ -0,0 +1,67 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamNetworking*) BS_Networking() {
+	return SteamNetworking();
+}
+#pragma comment(linker, "/EXPORT:BS_Networking=_BS_Networking@0")
+
+DLL_FUNCTION(ISteamNetworking*) BS_GameServerNetworking() {
+#pragma comment(linker, "/EXPORT:BS_GameServerNetworking=_BS_GameServerNetworking@0")
+	return SteamGameServerNetworking();
+}
+
+DLL_FUNCTION(uint32_t) BS_Networking_SendP2PPacket(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote, const void* pubData, uint32_t cubData, EP2PSend eP2PSendType, uint32_t nChannel) {
+#pragma comment(linker, "/EXPORT:BS_Networking_SendP2PPacket=_BS_Networking_SendP2PPacket@24")
+	return pSteamNetworking->SendP2PPacket(*pSteamIDRemote, pubData, cubData, eP2PSendType, nChannel);
+}
+
+DLL_FUNCTION(uint32_t) BS_Networking_IsP2PPacketAvailable(ISteamNetworking* pSteamNetworking, uint32_t* pcubMsgSize, uint32_t nChannel) {
+#pragma comment(linker, "/EXPORT:BS_Networking_IsP2PPacketAvailable=_BS_Networking_IsP2PPacketAvailable@12")
+	return pSteamNetworking->IsP2PPacketAvailable(pcubMsgSize, nChannel);
+}
+
+DLL_FUNCTION(uint32_t) BS_Networking_ReadP2PPacket(ISteamNetworking* pSteamNetworking, void* pubDest, uint32_t cubDest, uint32_t* pcubMsgSize, CSteamID* pSteamIDRemote, uint32_t nChannel) {
+#pragma comment(linker, "/EXPORT:BS_Networking_ReadP2PPacket=_BS_Networking_ReadP2PPacket@24")
+	return pSteamNetworking->ReadP2PPacket(pubDest, cubDest, pcubMsgSize, pSteamIDRemote, nChannel);
+}
+
+DLL_FUNCTION(uint32_t) BS_Networking_AcceptP2PSessionWithUser(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote) {
+#pragma comment(linker, "/EXPORT:BS_Networking_AcceptP2PSessionWithUser=_BS_Networking_AcceptP2PSessionWithUser@8")
+	return pSteamNetworking->AcceptP2PSessionWithUser(*pSteamIDRemote);
+}
+
+DLL_FUNCTION(uint32_t) BS_Networking_CloseP2PSessionWithUser(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote) {
+#pragma comment(linker, "/EXPORT:BS_Networking_CloseP2PSessionWithUser=_BS_Networking_CloseP2PSessionWithUser@8")
+	return pSteamNetworking->CloseP2PSessionWithUser(*pSteamIDRemote);
+}
+
+DLL_FUNCTION(uint32_t) BS_Networking_CloseP2PChannelWithUser(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote, uint32_t nChannel) {
+#pragma comment(linker, "/EXPORT:BS_Networking_CloseP2PChannelWithUser=_BS_Networking_CloseP2PChannelWithUser@12")
+	return pSteamNetworking->CloseP2PChannelWithUser(*pSteamIDRemote, nChannel);
+}
+
+DLL_FUNCTION(uint32_t) BS_Networking_GetP2PSessionState(ISteamNetworking* pSteamNetworking, CSteamID* pSteamIDRemote, P2PSessionState_t* pConnectionState) {
+#pragma comment(linker, "/EXPORT:BS_Networking_GetP2PSessionState=_BS_Networking_GetP2PSessionState@12")
+	return pSteamNetworking->GetP2PSessionState(*pSteamIDRemote, pConnectionState);
+}
+
+DLL_FUNCTION(uint32_t) BS_Networking_AllowP2PPacketRelay(ISteamNetworking* pSteamNetworking, uint32_t bAllow) {
+#pragma comment(linker, "/EXPORT:BS_Networking_AllowP2PPacketRelay=_BS_Networking_AllowP2PPacketRelay@8")
+	return pSteamNetworking->AllowP2PPacketRelay(!!bAllow);
+}
@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamRemoteStorage*) BS_RemoteStorage() {
+	return SteamRemoteStorage();
+}
+#pragma comment(linker, "/EXPORT:BS_RemoteStorage=_BS_RemoteStorage@0")
+
@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamScreenshots*) BS_Screenshots() {
+	return SteamScreenshots();
+}
+#pragma comment(linker, "/EXPORT:BS_Screenshots=_BS_Screenshots@0")
+
@@ -0,0 +1,28 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamUGC*) BS_UGC() {
+	return SteamUGC();
+}
+#pragma comment(linker, "/EXPORT:BS_UGC=_BS_UGC@0")
+
+DLL_FUNCTION(ISteamUGC*) BS_GameServerUGC() {
+#pragma comment(linker, "/EXPORT:BS_GameServerUGC=_BS_GameServerUGC@0")
+	return SteamGameServerUGC();
+}
+
@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamUnifiedMessages*) BS_UnifiedMessages() {
+	return SteamUnifiedMessages();
+}
+#pragma comment(linker, "/EXPORT:BS_UnifiedMessages=_BS_UnifiedMessages@0")
+
@@ -14,129 +14,134 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

-#include "dllmain.h"
+#include "BlitzSteam.h"

-DLL_EXPORT HSteamUser DLL_CALL BS_User_GetHSteamUser( ISteamUser* lpSteamUser ) {
+DLL_FUNCTION(ISteamUser*) BS_User() {
+	return SteamUser();
+}
+#pragma comment(linker, "/EXPORT:BS_User=_BS_User@0")
+
+DLL_FUNCTION(HSteamUser) BS_User_GetHSteamUser( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->GetHSteamUser( );
 }
 #pragma comment(linker, "/EXPORT:BS_User_GetHSteamUser=_BS_User_GetHSteamUser@4")

-DLL_EXPORT uint32_t DLL_CALL BS_User_IsLoggedOn( ISteamUser* lpSteamUser ) {
+DLL_FUNCTION(uint32_t) BS_User_IsLoggedOn( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->BLoggedOn( );
 }
 #pragma comment(linker, "/EXPORT:BS_User_IsLoggedOn=_BS_User_IsLoggedOn@4")

-DLL_EXPORT CSteamID* DLL_CALL BS_User_GetSteamID( ISteamUser* lpSteamUser ) {
+DLL_FUNCTION(CSteamID*) BS_User_GetSteamID( ISteamUser* lpSteamUser ) {
 	return &(lpSteamUser->GetSteamID( ));
 }
 #pragma comment(linker, "/EXPORT:BS_User_GetSteamID=_BS_User_GetSteamID@4")

-DLL_EXPORT uint32_t DLL_CALL BS_User_InitiateGameConnection( ISteamUser* lpSteamUser, void* pAuthBlob, uint32_t cbMaxAuthBlob, CSteamID* SteamIDGameServer, uint32_t unIPServer, uint16_t usPortServer, uint32_t bSecure ) {
+DLL_FUNCTION(uint32_t) BS_User_InitiateGameConnection( ISteamUser* lpSteamUser, void* pAuthBlob, uint32_t cbMaxAuthBlob, CSteamID* SteamIDGameServer, uint32_t unIPServer, uint16_t usPortServer, uint32_t bSecure ) {
 	return lpSteamUser->InitiateGameConnection( pAuthBlob, cbMaxAuthBlob, *SteamIDGameServer, unIPServer, usPortServer, bSecure != 0 );
 }
 #pragma comment(linker, "/EXPORT:BS_User_InitiateGameConnection=_BS_User_InitiateGameConnection@28")

-DLL_EXPORT void DLL_CALL BS_User_TerminateGameConnection( ISteamUser* lpSteamUser, uint32_t unIPServer, uint16_t usPortServer ) {
+DLL_FUNCTION(void) BS_User_TerminateGameConnection( ISteamUser* lpSteamUser, uint32_t unIPServer, uint16_t usPortServer ) {
 	lpSteamUser->TerminateGameConnection( unIPServer, usPortServer );
 }
 #pragma comment(linker, "/EXPORT:BS_User_TerminateGameConnection=_BS_User_TerminateGameConnection@12")

-DLL_EXPORT void DLL_CALL BS_User_TrackAppUsageEvent( ISteamUser* lpSteamUser, CGameID* gameId, uint32_t eAppUsageEvent, const char* pchExtraInfo ) {
+DLL_FUNCTION(void) BS_User_TrackAppUsageEvent( ISteamUser* lpSteamUser, CGameID* gameId, uint32_t eAppUsageEvent, const char* pchExtraInfo ) {
 	lpSteamUser->TrackAppUsageEvent( *gameId, eAppUsageEvent, pchExtraInfo );
 }
 #pragma comment(linker, "/EXPORT:BS_User_TrackAppUsageEvent=_BS_User_TrackAppUsageEvent@16")

-DLL_EXPORT uint32_t DLL_CALL BS_User_GetUserDataFolder( ISteamUser* lpSteamUser, char* pchBuffer, uint32_t cubBuffer ) {
+DLL_FUNCTION(uint32_t) BS_User_GetUserDataFolder( ISteamUser* lpSteamUser, char* pchBuffer, uint32_t cubBuffer ) {
 	return lpSteamUser->GetUserDataFolder( pchBuffer, cubBuffer );
 }
 #pragma comment(linker, "/EXPORT:BS_User_GetUserDataFolder=_BS_User_GetUserDataFolder@12")

-DLL_EXPORT void DLL_CALL BS_User_StartVoiceRecording( ISteamUser* lpSteamUser ) {
+DLL_FUNCTION(void) BS_User_StartVoiceRecording( ISteamUser* lpSteamUser ) {
 	lpSteamUser->StartVoiceRecording( );
 }
 #pragma comment(linker, "/EXPORT:BS_User_StartVoiceRecording=_BS_User_StartVoiceRecording@4")

-DLL_EXPORT void DLL_CALL BS_User_StopVoiceRecording( ISteamUser* lpSteamUser ) {
+DLL_FUNCTION(void) BS_User_StopVoiceRecording( ISteamUser* lpSteamUser ) {
 	lpSteamUser->StopVoiceRecording( );
 }
 #pragma comment(linker, "/EXPORT:BS_User_StopVoiceRecording=_BS_User_StopVoiceRecording@4")

-DLL_EXPORT EVoiceResult DLL_CALL BS_User_GetAvailableVoice( ISteamUser* lpSteamUser, uint32_t* pcbCompressed, uint32_t* pcbUncompressed, uint32_t nUncompressedVoiceDesiredSampleRate ) {
+DLL_FUNCTION(EVoiceResult) BS_User_GetAvailableVoice( ISteamUser* lpSteamUser, uint32_t* pcbCompressed, uint32_t* pcbUncompressed, uint32_t nUncompressedVoiceDesiredSampleRate ) {
 	return lpSteamUser->GetAvailableVoice( pcbCompressed, pcbUncompressed, nUncompressedVoiceDesiredSampleRate );
 }
 #pragma comment(linker, "/EXPORT:BS_User_GetAvailableVoice=_BS_User_GetAvailableVoice@16")

-DLL_EXPORT EVoiceResult DLL_CALL BS_User_GetVoice( ISteamUser* lpSteamUser, uint32_t bWantCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t bWantUncompressed, void *pUncompressedDestBuffer, uint32_t cbUncompressedDestBufferSize, uint32_t *nUncompressBytesWritten, uint32_t nUncompressedVoiceDesiredSampleRate ) {
+DLL_FUNCTION(EVoiceResult) BS_User_GetVoice( ISteamUser* lpSteamUser, uint32_t bWantCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t bWantUncompressed, void *pUncompressedDestBuffer, uint32_t cbUncompressedDestBufferSize, uint32_t *nUncompressBytesWritten, uint32_t nUncompressedVoiceDesiredSampleRate ) {
 	return lpSteamUser->GetVoice( bWantCompressed != 0, pDestBuffer, cbDestBufferSize, nBytesWritten, bWantUncompressed != 0, pUncompressedDestBuffer, cbUncompressedDestBufferSize, nUncompressBytesWritten, nUncompressedVoiceDesiredSampleRate );
 }
 #pragma comment(linker, "/EXPORT:BS_User_GetVoice=_BS_User_GetVoice@40")

-DLL_EXPORT EVoiceResult DLL_CALL BS_User_DecompressVoice( ISteamUser* lpSteamUser, const void *pCompressed, uint32_t cbCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t nDesiredSampleRate ) {
+DLL_FUNCTION(EVoiceResult) BS_User_DecompressVoice( ISteamUser* lpSteamUser, const void *pCompressed, uint32_t cbCompressed, void *pDestBuffer, uint32_t cbDestBufferSize, uint32_t *nBytesWritten, uint32_t nDesiredSampleRate ) {
 	return lpSteamUser->DecompressVoice( pCompressed, cbCompressed, pDestBuffer, cbDestBufferSize, nBytesWritten, nDesiredSampleRate );
 }
 #pragma comment(linker, "/EXPORT:BS_User_DecompressVoice=_BS_User_DecompressVoice@28")

-DLL_EXPORT uint32_t DLL_CALL BS_User_GetVoiceOptimalSampleRate( ISteamUser* lpSteamUser ) {
+DLL_FUNCTION(uint32_t) BS_User_GetVoiceOptimalSampleRate( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->GetVoiceOptimalSampleRate( );
 }
 #pragma comment(linker, "/EXPORT:BS_User_GetVoiceOptimalSampleRate=_BS_User_GetVoiceOptimalSampleRate@4")

-DLL_EXPORT HAuthTicket DLL_CALL BS_User_GetAuthSessionTicket( ISteamUser* lpSteamUser, void* pTicket, uint32_t cbMaxTicket, uint32_t* pcbTicket ) {
+DLL_FUNCTION(HAuthTicket) BS_User_GetAuthSessionTicket( ISteamUser* lpSteamUser, void* pTicket, uint32_t cbMaxTicket, uint32_t* pcbTicket ) {
 	return lpSteamUser->GetAuthSessionTicket( pTicket, cbMaxTicket, pcbTicket );
 }
 #pragma comment(linker, "/EXPORT:BS_User_GetAuthSessionTicket=_BS_User_GetAuthSessionTicket@16")

-DLL_EXPORT EBeginAuthSessionResult DLL_CALL BS_User_BeginAuthSession( ISteamUser* lpSteamUser, const void *pAuthTicket, uint32_t cbAuthTicket, CSteamID* steamID ) {
+DLL_FUNCTION(EBeginAuthSessionResult) BS_User_BeginAuthSession( ISteamUser* lpSteamUser, const void *pAuthTicket, uint32_t cbAuthTicket, CSteamID* steamID ) {
 	return lpSteamUser->BeginAuthSession( pAuthTicket, cbAuthTicket, *steamID );
 }
 #pragma comment(linker, "/EXPORT:BS_User_BeginAuthSession=_BS_User_BeginAuthSession@16")

-DLL_EXPORT void DLL_CALL BS_User_EndAuthSession( ISteamUser* lpSteamUser, CSteamID* steamID ) {
+DLL_FUNCTION(void) BS_User_EndAuthSession( ISteamUser* lpSteamUser, CSteamID* steamID ) {
 	lpSteamUser->EndAuthSession( *steamID );
 }
 #pragma comment(linker, "/EXPORT:BS_User_EndAuthSession=_BS_User_EndAuthSession@8")

-DLL_EXPORT void DLL_CALL BS_User_CancelAuthTicket( ISteamUser* lpSteamUser, HAuthTicket hAuthTicket ) {
+DLL_FUNCTION(void) BS_User_CancelAuthTicket( ISteamUser* lpSteamUser, HAuthTicket hAuthTicket ) {
 	lpSteamUser->CancelAuthTicket( hAuthTicket );
 }
 #pragma comment(linker, "/EXPORT:BS_User_EndAuthSession=_BS_User_EndAuthSession@8")

-DLL_EXPORT EUserHasLicenseForAppResult DLL_CALL BS_User_UserHasLicenseForApp( ISteamUser* lpSteamUser, CSteamID* steamID, AppId_t appID ) {
+DLL_FUNCTION(EUserHasLicenseForAppResult) BS_User_UserHasLicenseForApp( ISteamUser* lpSteamUser, CSteamID* steamID, AppId_t appID ) {
 	return lpSteamUser->UserHasLicenseForApp( *steamID, appID );
 }
 #pragma comment(linker, "/EXPORT:BS_User_UserHasLicenseForApp=_BS_User_UserHasLicenseForApp@12")

-DLL_EXPORT uint32_t DLL_CALL BS_User_IsBehindNAT( ISteamUser* lpSteamUser ) {
+DLL_FUNCTION(uint32_t) BS_User_IsBehindNAT( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->BIsBehindNAT( );
 }
 #pragma comment(linker, "/EXPORT:BS_User_IsBehindNAT=_BS_User_IsBehindNAT@4")

-DLL_EXPORT void DLL_CALL BS_User_AdvertiseGame( ISteamUser* lpSteamUser, CSteamID* steamIDGameServer, uint32_t unIPServer, uint16_t usPortServer ) {
+DLL_FUNCTION(void) BS_User_AdvertiseGame( ISteamUser* lpSteamUser, CSteamID* steamIDGameServer, uint32_t unIPServer, uint16_t usPortServer ) {
 	lpSteamUser->AdvertiseGame( *steamIDGameServer, unIPServer, usPortServer );
 }
 #pragma comment(linker, "/EXPORT:BS_User_AdvertiseGame=_BS_User_AdvertiseGame@16")

-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_User_RequestEncryptedAppTicket( ISteamUser* lpSteamUser, void* pDataToInclude, uint32_t cbDataToInclude ) {
+DLL_FUNCTION(SteamAPICall_t*) BS_User_RequestEncryptedAppTicket( ISteamUser* lpSteamUser, void* pDataToInclude, uint32_t cbDataToInclude ) {
 	return new uint64_t(lpSteamUser->RequestEncryptedAppTicket( pDataToInclude, cbDataToInclude ));
 }
 #pragma comment(linker, "/EXPORT:BS_User_RequestEncryptedAppTicket=_BS_User_RequestEncryptedAppTicket@12")

-DLL_EXPORT uint32_t DLL_CALL BS_User_GetEncryptedAppTicket( ISteamUser* lpSteamUser, void *pTicket, uint32_t cbMaxTicket, uint32_t* pcbTicket ) {
+DLL_FUNCTION(uint32_t) BS_User_GetEncryptedAppTicket( ISteamUser* lpSteamUser, void *pTicket, uint32_t cbMaxTicket, uint32_t* pcbTicket ) {
 	return lpSteamUser->GetEncryptedAppTicket( pTicket, cbMaxTicket, pcbTicket );
 }
 #pragma comment(linker, "/EXPORT:BS_User_GetEncryptedAppTicket=_BS_User_GetEncryptedAppTicket@16")

-DLL_EXPORT uint32_t DLL_CALL BS_User_GetGameBadgeLevel( ISteamUser* lpSteamUser, uint32_t nSeries, uint32_t bFoil ) {
+DLL_FUNCTION(uint32_t) BS_User_GetGameBadgeLevel( ISteamUser* lpSteamUser, uint32_t nSeries, uint32_t bFoil ) {
 	return lpSteamUser->GetGameBadgeLevel( nSeries, bFoil != 0 );
 }
 #pragma comment(linker, "/EXPORT:BS_User_GetGameBadgeLevel=_BS_User_GetGameBadgeLevel@12")

-DLL_EXPORT uint32_t DLL_CALL BS_User_GetPlayerSteamLevel( ISteamUser* lpSteamUser ) {
+DLL_FUNCTION(uint32_t) BS_User_GetPlayerSteamLevel( ISteamUser* lpSteamUser ) {
 	return lpSteamUser->GetPlayerSteamLevel( );
 }
 #pragma comment(linker, "/EXPORT:BS_User_GetPlayerSteamLevel=_BS_User_GetPlayerSteamLevel@4")

-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_User_RequestStoreAuthURL( ISteamUser* lpSteamUser, const char* pchRedirectURL ) {
+DLL_FUNCTION(SteamAPICall_t*) BS_User_RequestStoreAuthURL( ISteamUser* lpSteamUser, const char* pchRedirectURL ) {
 	return new uint64_t(lpSteamUser->RequestStoreAuthURL( pchRedirectURL ));
 }
-#pragma comment(linker, "/EXPORT:BS_User_RequestStoreAuthURL=_BS_User_RequestStoreAuthURL@8")
+#pragma comment(linker, "/EXPORT:BS_User_RequestStoreAuthURL=_BS_User_RequestStoreAuthURL@8")
@@ -14,219 +14,224 @@
 //	You should have received a copy of the GNU Lesser General Public License
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.

-#include "dllmain.h"
+#include "BlitzSteam.h"

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_RequestCurrentStats( ISteamUserStats* lpSteamUserStats ) {
+DLL_FUNCTION(ISteamUserStats*) BS_UserStats() {
+	return SteamUserStats();
+}
+#pragma comment(linker, "/EXPORT:BS_UserStats=_BS_UserStats@0")
+
+DLL_FUNCTION(uint32_t) BS_UserStats_RequestCurrentStats( ISteamUserStats* lpSteamUserStats ) {
 	return lpSteamUserStats->RequestCurrentStats( );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_RequestCurrentStats=_BS_UserStats_RequestCurrentStats@4")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetStat( ISteamUserStats* lpSteamUserStats, const char* pchName, int32_t* pData ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetStat( ISteamUserStats* lpSteamUserStats, const char* pchName, int32_t* pData ) {
 	return lpSteamUserStats->GetStat( pchName, pData );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetStat=_BS_UserStats_GetStat@12")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetStatF( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t* pData ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetStatF( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t* pData ) {
 	return lpSteamUserStats->GetStat( pchName, pData );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetStatF=_BS_UserStats_GetStatF@12")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_SetStat( ISteamUserStats* lpSteamUserStats, const char* pchName, int32_t pData ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_SetStat( ISteamUserStats* lpSteamUserStats, const char* pchName, int32_t pData ) {
 	return lpSteamUserStats->SetStat( pchName, pData );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_SetStat=_BS_UserStats_SetStat@12")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_SetStatF( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t pData ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_SetStatF( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t pData ) {
 	return lpSteamUserStats->SetStat( pchName, pData );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_SetStatF=_BS_UserStats_SetStatF@12")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_UpdateAvgRateStat( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t flCountThisSession, double_t* dSessionLength ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_UpdateAvgRateStat( ISteamUserStats* lpSteamUserStats, const char* pchName, float_t flCountThisSession, double_t* dSessionLength ) {
 	return lpSteamUserStats->UpdateAvgRateStat( pchName, flCountThisSession, *dSessionLength );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_UpdateAvgRateStat=_BS_UserStats_UpdateAvgRateStat@16")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName, bool* pbAchieved ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName, bool* pbAchieved ) {
 	return lpSteamUserStats->GetAchievement( pchName, (bool*)pbAchieved );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievement=_BS_UserStats_GetAchievement@12")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_SetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_SetAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
 	return lpSteamUserStats->SetAchievement( pchName );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_SetAchievement=_BS_UserStats_SetAchievement@8")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_ClearAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_ClearAchievement( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
 	return lpSteamUserStats->ClearAchievement( pchName );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_ClearAchievement=_BS_UserStats_ClearAchievement@8")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetAchievementAndUnlockTime( ISteamUserStats* lpSteamUserStats, const char* pchName, bool* pbAchieved, uint32_t* punUnlockTime ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetAchievementAndUnlockTime( ISteamUserStats* lpSteamUserStats, const char* pchName, bool* pbAchieved, uint32_t* punUnlockTime ) {
 	return lpSteamUserStats->GetAchievementAndUnlockTime( pchName, (bool*)pbAchieved, punUnlockTime );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementAndUnlockTime=_BS_UserStats_GetAchievementAndUnlockTime@16")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_StoreStats( ISteamUserStats* lpSteamUserStats ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_StoreStats( ISteamUserStats* lpSteamUserStats ) {
 	return lpSteamUserStats->StoreStats( );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_StoreStats=_BS_UserStats_StoreStats@4")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetAchievementIcon( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetAchievementIcon( ISteamUserStats* lpSteamUserStats, const char* pchName ) {
 	return lpSteamUserStats->GetAchievementIcon( pchName );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementIcon=_BS_UserStats_GetAchievementIcon@8")

-DLL_EXPORT const char* DLL_CALL BS_UserStats_GetAchievementDisplayAttribute( ISteamUserStats* lpSteamUserStats, const char* pchName, const char* pchKey ) {
+DLL_FUNCTION(const char*) BS_UserStats_GetAchievementDisplayAttribute( ISteamUserStats* lpSteamUserStats, const char* pchName, const char* pchKey ) {
 	return lpSteamUserStats->GetAchievementDisplayAttribute( pchName, pchKey );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementDisplayAttribute=_BS_UserStats_GetAchievementDisplayAttribute@12")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_IndicateAchievementProgress( ISteamUserStats* lpSteamUserStats, const char* pchName, uint32_t nCurProgress, uint32_t nMaxProgress ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_IndicateAchievementProgress( ISteamUserStats* lpSteamUserStats, const char* pchName, uint32_t nCurProgress, uint32_t nMaxProgress ) {
 	return lpSteamUserStats->IndicateAchievementProgress( pchName, nCurProgress, nMaxProgress );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_IndicateAchievementProgress=_BS_UserStats_IndicateAchievementProgress@16")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetNumAchievements( ISteamUserStats* lpSteamUserStats ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetNumAchievements( ISteamUserStats* lpSteamUserStats ) {
 	return lpSteamUserStats->GetNumAchievements( );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetNumAchievements=_BS_UserStats_GetNumAchievements@4")

-DLL_EXPORT const char* DLL_CALL BS_UserStats_GetAchievementName( ISteamUserStats* lpSteamUserStats, uint32 iAchievement ) {
+DLL_FUNCTION(const char*) BS_UserStats_GetAchievementName( ISteamUserStats* lpSteamUserStats, uint32_t iAchievement ) {
 	return lpSteamUserStats->GetAchievementName( iAchievement );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementName=_BS_UserStats_GetAchievementName@8")

-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_RequestUserStats( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser ) {
+DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_RequestUserStats( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser ) {
 	return new uint64_t( lpSteamUserStats->RequestUserStats( *steamIDUser ) );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_RequestUserStats=_BS_UserStats_RequestUserStats@8")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetUserStat( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pData ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetUserStat( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, uint32_t* pData ) {
 	return lpSteamUserStats->GetUserStat( *steamIDUser, pchName, (int32_t*)pData );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetUserStat=_BS_UserStats_GetUserStat@16")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetUserStatF( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, float_t* pData ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetUserStatF( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, float_t* pData ) {
 	return lpSteamUserStats->GetUserStat( *steamIDUser, pchName, pData );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetUserStatF=_BS_UserStats_GetUserStatF@16")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetUserAchievement( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, bool* pbAchieved ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetUserAchievement( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, bool* pbAchieved ) {
 	return lpSteamUserStats->GetUserAchievement( *steamIDUser, pchName, (bool*)pbAchieved );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetUserAchievement=_BS_UserStats_GetUserAchievement@16")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetUserAchievementAndUnlockTime( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, bool* pbAchieved, uint32_t* punUnlockTime ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetUserAchievementAndUnlockTime( ISteamUserStats* lpSteamUserStats, CSteamID* steamIDUser, const char* pchName, bool* pbAchieved, uint32_t* punUnlockTime ) {
 	return lpSteamUserStats->GetUserAchievementAndUnlockTime( *steamIDUser, pchName, (bool*)pbAchieved, punUnlockTime );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetUserAchievementAndUnlockTime=_BS_UserStats_GetUserAchievementAndUnlockTime@20")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_ResetAllStats( ISteamUserStats* lpSteamUserStats, uint32_t bAchievementsToo ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_ResetAllStats( ISteamUserStats* lpSteamUserStats, uint32_t bAchievementsToo ) {
 	return lpSteamUserStats->ResetAllStats( bAchievementsToo != 0 );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_ResetAllStats=_BS_UserStats_ResetAllStats@8")

-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_FindOrCreateLeaderboard( ISteamUserStats* lpSteamUserStats, const char* pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ) {
+DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_FindOrCreateLeaderboard( ISteamUserStats* lpSteamUserStats, const char* pchLeaderboardName, ELeaderboardSortMethod eLeaderboardSortMethod, ELeaderboardDisplayType eLeaderboardDisplayType ) {
 	return new uint64_t( lpSteamUserStats->FindOrCreateLeaderboard( pchLeaderboardName, eLeaderboardSortMethod, eLeaderboardDisplayType ) );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_FindOrCreateLeaderboard=_BS_UserStats_FindOrCreateLeaderboard@16")

-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_FindLeaderboard( ISteamUserStats* lpSteamUserStats, const char *pchLeaderboardName ) {
+DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_FindLeaderboard( ISteamUserStats* lpSteamUserStats, const char *pchLeaderboardName ) {
 	return new uint64_t( lpSteamUserStats->FindLeaderboard( pchLeaderboardName ) );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_FindLeaderboard=_BS_UserStats_FindLeaderboard@8")

-DLL_EXPORT const char* DLL_CALL BS_UserStats_GetLeaderboardName( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
+DLL_FUNCTION(const char*) BS_UserStats_GetLeaderboardName( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
 	return lpSteamUserStats->GetLeaderboardName( *hSteamLeaderboard );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardName=_BS_UserStats_GetLeaderboardName@8")

-DLL_EXPORT int DLL_CALL BS_UserStats_GetLeaderboardEntryCount( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
+DLL_FUNCTION(int) BS_UserStats_GetLeaderboardEntryCount( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
 	return lpSteamUserStats->GetLeaderboardEntryCount( *hSteamLeaderboard );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardEntryCount=_BS_UserStats_GetLeaderboardEntryCount@8")

-DLL_EXPORT ELeaderboardSortMethod DLL_CALL BS_UserStats_GetLeaderboardSortMethod( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
+DLL_FUNCTION(ELeaderboardSortMethod) BS_UserStats_GetLeaderboardSortMethod( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
 	return lpSteamUserStats->GetLeaderboardSortMethod( *hSteamLeaderboard );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardSortMethod=_BS_UserStats_GetLeaderboardSortMethod@8")

-DLL_EXPORT ELeaderboardDisplayType DLL_CALL BS_UserStats_GetLeaderboardDisplayType( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
+DLL_FUNCTION(ELeaderboardDisplayType) BS_UserStats_GetLeaderboardDisplayType( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard ) {
 	return lpSteamUserStats->GetLeaderboardDisplayType( *hSteamLeaderboard );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetLeaderboardDisplayType=_BS_UserStats_GetLeaderboardDisplayType@8")

-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_DownloadLeaderboardEntries( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) {
+DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_DownloadLeaderboardEntries( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, ELeaderboardDataRequest eLeaderboardDataRequest, int nRangeStart, int nRangeEnd ) {
 	return new uint64_t( lpSteamUserStats->DownloadLeaderboardEntries( *hSteamLeaderboard, eLeaderboardDataRequest, nRangeStart, nRangeEnd ) );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_DownloadLeaderboardEntries=_BS_UserStats_DownloadLeaderboardEntries@20")

-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_DownloadLeaderboardEntriesForUsers( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, CSteamID* prgUsers, int cUsers ) {
+DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_DownloadLeaderboardEntriesForUsers( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, CSteamID* prgUsers, int cUsers ) {
 	return new uint64_t( lpSteamUserStats->DownloadLeaderboardEntriesForUsers( *hSteamLeaderboard, prgUsers, cUsers ) );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_DownloadLeaderboardEntriesForUsers=_BS_UserStats_DownloadLeaderboardEntriesForUsers@16")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetDownloadedLeaderboardEntry( ISteamUserStats* lpSteamUserStats, SteamLeaderboardEntries_t* hSteamLeaderboardEntries, int index, LeaderboardEntry_t *pLeaderboardEntry, int32 *pDetails, int cDetailsMax ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetDownloadedLeaderboardEntry( ISteamUserStats* lpSteamUserStats, SteamLeaderboardEntries_t* hSteamLeaderboardEntries, int index, LeaderboardEntry_t *pLeaderboardEntry, int32 *pDetails, int cDetailsMax ) {
 	return lpSteamUserStats->GetDownloadedLeaderboardEntry( *hSteamLeaderboardEntries, index, pLeaderboardEntry, pDetails, cDetailsMax );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetDownloadedLeaderboardEntry=_BS_UserStats_GetDownloadedLeaderboardEntry@24")

-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_UploadLeaderboardScore( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32_t* pScoreDetails, int cScoreDetailsCount ) {
+DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_UploadLeaderboardScore( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, ELeaderboardUploadScoreMethod eLeaderboardUploadScoreMethod, int32 nScore, const int32_t* pScoreDetails, int cScoreDetailsCount ) {
 	return new uint64_t(lpSteamUserStats->UploadLeaderboardScore( *hSteamLeaderboard, eLeaderboardUploadScoreMethod, nScore, pScoreDetails, cScoreDetailsCount ));
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_UploadLeaderboardScore=_BS_UserStats_UploadLeaderboardScore@24")

-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_AttachLeaderboardUGC( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, UGCHandle_t* hUGC ) {
+DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_AttachLeaderboardUGC( ISteamUserStats* lpSteamUserStats, SteamLeaderboard_t* hSteamLeaderboard, UGCHandle_t* hUGC ) {
 	return new uint64_t( lpSteamUserStats->AttachLeaderboardUGC( *hSteamLeaderboard, *hUGC ) );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_AttachLeaderboardUGC=_BS_UserStats_AttachLeaderboardUGC@12")

-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_GetNumberOfCurrentPlayers( ISteamUserStats* lpSteamUserStats ) {
+DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_GetNumberOfCurrentPlayers( ISteamUserStats* lpSteamUserStats ) {
 	return new uint64_t( lpSteamUserStats->GetNumberOfCurrentPlayers( ) );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetNumberOfCurrentPlayers=_BS_UserStats_GetNumberOfCurrentPlayers@4")

-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_RequestGlobalAchievementPercentages( ISteamUserStats* lpSteamUserStats ) {
+DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_RequestGlobalAchievementPercentages( ISteamUserStats* lpSteamUserStats ) {
 	return new uint64_t( lpSteamUserStats->RequestGlobalAchievementPercentages( ) );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_RequestGlobalAchievementPercentages=_BS_UserStats_RequestGlobalAchievementPercentages@4")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetMostAchievedAchievementInfo( ISteamUserStats* lpSteamUserStats, char *pchName, uint32 unNameBufLen, float *pflPercent, bool* pbAchieved ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetMostAchievedAchievementInfo( ISteamUserStats* lpSteamUserStats, char *pchName, uint32_t unNameBufLen, float *pflPercent, bool* pbAchieved ) {
 	return lpSteamUserStats->GetMostAchievedAchievementInfo( pchName, unNameBufLen, pflPercent, pbAchieved );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetMostAchievedAchievementInfo=_BS_UserStats_GetMostAchievedAchievementInfo@20")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetNextMostAchievedAchievementInfo( ISteamUserStats* lpSteamUserStats, int iIteratorPrevious, char *pchName, uint32 unNameBufLen, float *pflPercent, bool *pbAchieved ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetNextMostAchievedAchievementInfo( ISteamUserStats* lpSteamUserStats, int iIteratorPrevious, char *pchName, uint32_t unNameBufLen, float *pflPercent, bool *pbAchieved ) {
 	return lpSteamUserStats->GetNextMostAchievedAchievementInfo( iIteratorPrevious, pchName, unNameBufLen, pflPercent, pbAchieved );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetNextMostAchievedAchievementInfo=_BS_UserStats_GetNextMostAchievedAchievementInfo@24")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetAchievementAchievedPercent( ISteamUserStats* lpSteamUserStats, const char *pchName, float *pflPercent ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetAchievementAchievedPercent( ISteamUserStats* lpSteamUserStats, const char *pchName, float *pflPercent ) {
 	return lpSteamUserStats->GetAchievementAchievedPercent( pchName, pflPercent );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetAchievementAchievedPercent=_BS_UserStats_GetAchievementAchievedPercent@12")

-DLL_EXPORT SteamAPICall_t* DLL_CALL BS_UserStats_RequestGlobalStats( ISteamUserStats* lpSteamUserStats, int nHistoryDays ) {
+DLL_FUNCTION(SteamAPICall_t*) BS_UserStats_RequestGlobalStats( ISteamUserStats* lpSteamUserStats, int nHistoryDays ) {
 	return new uint64_t( lpSteamUserStats->RequestGlobalStats( nHistoryDays ) );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_RequestGlobalStats=_BS_UserStats_RequestGlobalStats@8")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetGlobalStatLL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64* pData ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetGlobalStatLL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64* pData ) {
 	return lpSteamUserStats->GetGlobalStat( pchStatName, pData );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatLL=_BS_UserStats_GetGlobalStatLL@12")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetGlobalStatD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double* pData ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetGlobalStatD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double* pData ) {
 	return lpSteamUserStats->GetGlobalStat( pchStatName, pData );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatD=_BS_UserStats_GetGlobalStatD@12")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetGlobalStatHistoryLL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64 *pData, uint32 cubData ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetGlobalStatHistoryLL( ISteamUserStats* lpSteamUserStats, const char *pchStatName, int64 *pData, uint32_t cubData ) {
 	return lpSteamUserStats->GetGlobalStatHistory( pchStatName, pData, cubData );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatHistoryLL=_BS_UserStats_GetGlobalStatHistoryLL@16")

-DLL_EXPORT uint32_t DLL_CALL BS_UserStats_GetGlobalStatHistoryD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double *pData, uint32 cubData ) {
+DLL_FUNCTION(uint32_t) BS_UserStats_GetGlobalStatHistoryD( ISteamUserStats* lpSteamUserStats, const char *pchStatName, double *pData, uint32_t cubData ) {
 	return lpSteamUserStats->GetGlobalStatHistory( pchStatName, pData, cubData );
 }
 #pragma comment(linker, "/EXPORT:BS_UserStats_GetGlobalStatHistoryD=_BS_UserStats_GetGlobalStatHistoryD@16")
@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamUtils*) BS_Utils() {
+	return SteamUtils();
+}
+#pragma comment(linker, "/EXPORT:BS_Utils=_BS_Utils@0")
+
@@ -0,0 +1,23 @@
+//	BlitzSteam - Steam wrapper for Blitz
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "BlitzSteam.h"
+
+DLL_FUNCTION(ISteamVideo*) BS_Video() {
+	return SteamVideo();
+}
+#pragma comment(linker, "/EXPORT:BS_Video=_BS_Video@0")
+