649 lines
26 KiB
C++
649 lines
26 KiB
C++
//====== Copyright 1996-2008, Valve Corporation, All rights reserved. =======
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef STEAM_API_H
|
|
#define STEAM_API_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "isteamapplist.h"
|
|
#include "isteamapps.h"
|
|
#include "isteamclient.h"
|
|
#include "isteamcontroller.h"
|
|
#include "isteamfriends.h"
|
|
#include "isteamhtmlsurface.h"
|
|
#include "isteamhttp.h"
|
|
#include "isteammatchmaking.h"
|
|
#include "isteammusic.h"
|
|
#include "isteammusicremote.h"
|
|
#include "isteamnetworking.h"
|
|
#include "isteamremotestorage.h"
|
|
#include "isteamscreenshots.h"
|
|
#include "isteamugc.h"
|
|
#include "isteamunifiedmessages.h"
|
|
#include "isteamuser.h"
|
|
#include "isteamuserstats.h"
|
|
#include "isteamutils.h"
|
|
|
|
#if defined(_PS3)
|
|
#include "steamps3params.h"
|
|
#endif
|
|
|
|
// Steam API export macro
|
|
#if defined(_WIN32) && !defined(_X360)
|
|
#if defined(STEAM_API_EXPORTS)
|
|
#define S_API extern "C" __declspec(dllexport)
|
|
#elif defined(STEAM_API_NODLL)
|
|
#define S_API extern "C"
|
|
#else
|
|
#define S_API extern "C" __declspec(dllimport)
|
|
#endif // STEAM_API_EXPORTS
|
|
#elif defined(GNUC)
|
|
#if defined(STEAM_API_EXPORTS)
|
|
#define S_API extern "C" __attribute__((visibility("default")))
|
|
#else
|
|
#define S_API extern "C"
|
|
#endif // STEAM_API_EXPORTS
|
|
#else // !WIN32
|
|
#if defined(STEAM_API_EXPORTS)
|
|
#define S_API extern "C"
|
|
#else
|
|
#define S_API extern "C"
|
|
#endif // STEAM_API_EXPORTS
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
// Steam API setup & shutdown
|
|
//
|
|
// These functions manage loading, initializing and shutdown of the
|
|
//steamclient.dll
|
|
//
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
// S_API void SteamAPI_Init(); (see below)
|
|
S_API void S_CALLTYPE SteamAPI_Shutdown();
|
|
|
|
// checks if a local Steam client is running
|
|
S_API bool S_CALLTYPE SteamAPI_IsSteamRunning();
|
|
|
|
// Detects if your executable was launched through the Steam client, and
|
|
// restarts your game through the client if necessary. The Steam client will be
|
|
// started if it is not running.
|
|
//
|
|
// Returns: true if your executable was NOT launched through the Steam client.
|
|
// This function will
|
|
// then start your application through the client. Your current process
|
|
// should exit.
|
|
//
|
|
// false if your executable was started through the Steam client or a
|
|
// steam_appid.txt file is present in your game's directory (for
|
|
// development). Your current process should continue.
|
|
//
|
|
// NOTE: This function should be used only if you are using CEG or not using
|
|
// Steam's DRM. Once applied
|
|
// to your executable, Steam's DRM will handle restarting through Steam if
|
|
// necessary.
|
|
S_API bool S_CALLTYPE SteamAPI_RestartAppIfNecessary(uint32 unOwnAppID);
|
|
|
|
// crash dump recording functions
|
|
S_API void S_CALLTYPE SteamAPI_WriteMiniDump(uint32 uStructuredExceptionCode,
|
|
void *pvExceptionInfo,
|
|
uint32 uBuildID);
|
|
S_API void S_CALLTYPE SteamAPI_SetMiniDumpComment(const char *pchMsg);
|
|
|
|
// interface pointers, configured by SteamAPI_Init()
|
|
S_API ISteamClient *S_CALLTYPE SteamClient();
|
|
|
|
//
|
|
// VERSION_SAFE_STEAM_API_INTERFACES is usually not necessary, but it provides
|
|
// safety against releasing new steam_api.dll's without recompiling/rereleasing
|
|
// modules that use it.
|
|
//
|
|
// If you use VERSION_SAFE_STEAM_API_INTERFACES, then you should call
|
|
// SteamAPI_InitSafe(). Also, to get the Steam interfaces, you must create and
|
|
// Init() a CSteamAPIContext (below) and use the interfaces in there.
|
|
//
|
|
// If you don't use VERSION_SAFE_STEAM_API_INTERFACES, then you can use
|
|
// SteamAPI_Init() and the SteamXXXX() functions below to get at the Steam
|
|
// interfaces.
|
|
//
|
|
#ifdef VERSION_SAFE_STEAM_API_INTERFACES
|
|
S_API bool S_CALLTYPE SteamAPI_InitSafe();
|
|
#else
|
|
|
|
#if defined(_PS3)
|
|
S_API bool S_CALLTYPE SteamAPI_Init(SteamPS3Params_t *pParams);
|
|
#else
|
|
S_API bool S_CALLTYPE SteamAPI_Init();
|
|
#endif
|
|
|
|
S_API ISteamUser *S_CALLTYPE SteamUser();
|
|
S_API ISteamFriends *S_CALLTYPE SteamFriends();
|
|
S_API ISteamUtils *S_CALLTYPE SteamUtils();
|
|
S_API ISteamMatchmaking *S_CALLTYPE SteamMatchmaking();
|
|
S_API ISteamUserStats *S_CALLTYPE SteamUserStats();
|
|
S_API ISteamApps *S_CALLTYPE SteamApps();
|
|
S_API ISteamNetworking *S_CALLTYPE SteamNetworking();
|
|
S_API ISteamMatchmakingServers *S_CALLTYPE SteamMatchmakingServers();
|
|
S_API ISteamRemoteStorage *S_CALLTYPE SteamRemoteStorage();
|
|
S_API ISteamScreenshots *S_CALLTYPE SteamScreenshots();
|
|
S_API ISteamHTTP *S_CALLTYPE SteamHTTP();
|
|
S_API ISteamUnifiedMessages *S_CALLTYPE SteamUnifiedMessages();
|
|
S_API ISteamController *S_CALLTYPE SteamController();
|
|
S_API ISteamUGC *S_CALLTYPE SteamUGC();
|
|
S_API ISteamAppList *S_CALLTYPE SteamAppList();
|
|
S_API ISteamMusic *S_CALLTYPE SteamMusic();
|
|
S_API ISteamMusicRemote *S_CALLTYPE SteamMusicRemote();
|
|
S_API ISteamHTMLSurface *S_CALLTYPE SteamHTMLSurface();
|
|
#ifdef _PS3
|
|
S_API ISteamPS3OverlayRender *S_CALLTYPE SteamPS3OverlayRender();
|
|
#endif
|
|
#endif // VERSION_SAFE_STEAM_API_INTERFACES
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
// steam callback and call-result helpers
|
|
//
|
|
// The following macros and classes are used to register your application
|
|
//for callbacks and call-results, which are delivered in a predictable manner.
|
|
//
|
|
// STEAM_CALLBACK macros are meant for use inside of a C++ class
|
|
//definition. They map a Steam notification callback directly to a class member
|
|
//function which is automatically prototyped as "void func( callback_type
|
|
//*pParam )".
|
|
//
|
|
// CCallResult is used with specific Steam APIs that return "result
|
|
//handles". The handle can be passed to a CCallResult object's Set function,
|
|
//along with an object pointer and member-function pointer. The member function
|
|
//will be executed once the results of the Steam API call are available.
|
|
//
|
|
// CCallback and CCallbackManual classes can be used instead of
|
|
//STEAM_CALLBACK macros if you require finer control over registration and
|
|
//unregistration.
|
|
//
|
|
// Callbacks and call-results are queued automatically and are only
|
|
// delivered/executed when your application calls SteamAPI_RunCallbacks().
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
S_API void S_CALLTYPE SteamAPI_RunCallbacks();
|
|
|
|
// Declares a callback member function plus a helper member variable which
|
|
// registers the callback on object creation and unregisters on destruction.
|
|
// The optional fourth 'var' param exists only for backwards-compatibility
|
|
// and can be ignored.
|
|
#define STEAM_CALLBACK(thisclass, func, \
|
|
... /*callback_type, [deprecated] var*/) \
|
|
_STEAM_CALLBACK_SELECT((__VA_ARGS__, 4, 3), \
|
|
(/**/, thisclass, func, __VA_ARGS__))
|
|
|
|
// Declares a callback function and a named CCallbackManual variable which
|
|
// has Register and Unregister functions instead of automatic registration.
|
|
#define STEAM_CALLBACK_MANUAL(thisclass, func, callback_type, var) \
|
|
CCallbackManual<thisclass, callback_type> var; \
|
|
void func(callback_type *pParam)
|
|
|
|
// Internal functions used by the utility CCallback objects to receive callbacks
|
|
S_API void S_CALLTYPE SteamAPI_RegisterCallback(class CCallbackBase *pCallback,
|
|
int iCallback);
|
|
S_API void S_CALLTYPE
|
|
SteamAPI_UnregisterCallback(class CCallbackBase *pCallback);
|
|
// Internal functions used by the utility CCallResult objects to receive async
|
|
// call results
|
|
S_API void S_CALLTYPE SteamAPI_RegisterCallResult(
|
|
class CCallbackBase *pCallback, SteamAPICall_t hAPICall);
|
|
S_API void S_CALLTYPE SteamAPI_UnregisterCallResult(
|
|
class CCallbackBase *pCallback, SteamAPICall_t hAPICall);
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: base for callbacks and call results - internal implementation detail
|
|
//-----------------------------------------------------------------------------
|
|
class CCallbackBase {
|
|
public:
|
|
CCallbackBase() {
|
|
m_nCallbackFlags = 0;
|
|
m_iCallback = 0;
|
|
}
|
|
// don't add a virtual destructor because we export this binary interface
|
|
// across dll's
|
|
virtual void Run(void *pvParam) = 0;
|
|
virtual void Run(void *pvParam, bool bIOFailure,
|
|
SteamAPICall_t hSteamAPICall) = 0;
|
|
int GetICallback() { return m_iCallback; }
|
|
virtual int GetCallbackSizeBytes() = 0;
|
|
|
|
protected:
|
|
enum {
|
|
k_ECallbackFlagsRegistered = 0x01,
|
|
k_ECallbackFlagsGameServer = 0x02
|
|
};
|
|
uint8 m_nCallbackFlags;
|
|
int m_iCallback;
|
|
friend class CCallbackMgr;
|
|
|
|
private:
|
|
CCallbackBase(const CCallbackBase &);
|
|
CCallbackBase &operator=(const CCallbackBase &);
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: templated base for callbacks - internal implementation detail
|
|
//-----------------------------------------------------------------------------
|
|
template <int sizeof_P>
|
|
class CCallbackImpl : protected CCallbackBase {
|
|
public:
|
|
~CCallbackImpl() {
|
|
if (m_nCallbackFlags & k_ECallbackFlagsRegistered)
|
|
SteamAPI_UnregisterCallback(this);
|
|
}
|
|
void SetGameserverFlag() { m_nCallbackFlags |= k_ECallbackFlagsGameServer; }
|
|
|
|
protected:
|
|
virtual void Run(void *pvParam) = 0;
|
|
virtual void Run(void *pvParam, bool /*bIOFailure*/,
|
|
SteamAPICall_t /*hSteamAPICall*/) {
|
|
Run(pvParam);
|
|
}
|
|
virtual int GetCallbackSizeBytes() { return sizeof_P; }
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: maps a steam async call result to a class member function
|
|
// template params: T = local class, P = parameter struct
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class P>
|
|
class CCallResult : private CCallbackBase {
|
|
public:
|
|
typedef void (T::*func_t)(P *, bool);
|
|
|
|
CCallResult() {
|
|
m_hAPICall = k_uAPICallInvalid;
|
|
m_pObj = NULL;
|
|
m_Func = NULL;
|
|
m_iCallback = P::k_iCallback;
|
|
}
|
|
|
|
void Set(SteamAPICall_t hAPICall, T *p, func_t func) {
|
|
if (m_hAPICall) SteamAPI_UnregisterCallResult(this, m_hAPICall);
|
|
|
|
m_hAPICall = hAPICall;
|
|
m_pObj = p;
|
|
m_Func = func;
|
|
|
|
if (hAPICall) SteamAPI_RegisterCallResult(this, hAPICall);
|
|
}
|
|
|
|
bool IsActive() const { return (m_hAPICall != k_uAPICallInvalid); }
|
|
|
|
void Cancel() {
|
|
if (m_hAPICall != k_uAPICallInvalid) {
|
|
SteamAPI_UnregisterCallResult(this, m_hAPICall);
|
|
m_hAPICall = k_uAPICallInvalid;
|
|
}
|
|
}
|
|
|
|
~CCallResult() { Cancel(); }
|
|
|
|
void SetGameserverFlag() { m_nCallbackFlags |= k_ECallbackFlagsGameServer; }
|
|
|
|
private:
|
|
virtual void Run(void *pvParam) {
|
|
m_hAPICall = k_uAPICallInvalid; // caller unregisters for us
|
|
(m_pObj->*m_Func)((P *)pvParam, false);
|
|
}
|
|
virtual void Run(void *pvParam, bool bIOFailure,
|
|
SteamAPICall_t hSteamAPICall) {
|
|
if (hSteamAPICall == m_hAPICall) {
|
|
m_hAPICall = k_uAPICallInvalid; // caller unregisters for us
|
|
(m_pObj->*m_Func)((P *)pvParam, bIOFailure);
|
|
}
|
|
}
|
|
virtual int GetCallbackSizeBytes() { return sizeof(P); }
|
|
|
|
SteamAPICall_t m_hAPICall;
|
|
T *m_pObj;
|
|
func_t m_Func;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: maps a steam callback to a class member function
|
|
// template params: T = local class, P = parameter struct,
|
|
// bGameserver = listen for gameserver callbacks instead of
|
|
//client callbacks
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class P, bool bGameserver = false>
|
|
class CCallback : public CCallbackImpl<sizeof(P)> {
|
|
public:
|
|
typedef void (T::*func_t)(P *);
|
|
|
|
// NOTE: If you can't provide the correct parameters at construction time,
|
|
// you should use the CCallbackManual callback object (STEAM_CALLBACK_MANUAL
|
|
// macro) instead.
|
|
CCallback(T *pObj, func_t func) : m_pObj(NULL), m_Func(NULL) {
|
|
if (bGameserver) {
|
|
this->SetGameserverFlag();
|
|
}
|
|
Register(pObj, func);
|
|
}
|
|
|
|
// manual registration of the callback
|
|
void Register(T *pObj, func_t func) {
|
|
if (!pObj || !func) return;
|
|
|
|
if (this->m_nCallbackFlags & CCallbackBase::k_ECallbackFlagsRegistered)
|
|
Unregister();
|
|
|
|
m_pObj = pObj;
|
|
m_Func = func;
|
|
// SteamAPI_RegisterCallback sets k_ECallbackFlagsRegistered
|
|
SteamAPI_RegisterCallback(this, P::k_iCallback);
|
|
}
|
|
|
|
void Unregister() {
|
|
// SteamAPI_UnregisterCallback removes k_ECallbackFlagsRegistered
|
|
SteamAPI_UnregisterCallback(this);
|
|
}
|
|
|
|
protected:
|
|
virtual void Run(void *pvParam) { (m_pObj->*m_Func)((P *)pvParam); }
|
|
|
|
T *m_pObj;
|
|
func_t m_Func;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: subclass of CCallback which allows default-construction in
|
|
// an unregistered state; you must call Register manually
|
|
//-----------------------------------------------------------------------------
|
|
template <class T, class P, bool bGameServer = false>
|
|
class CCallbackManual : public CCallback<T, P, bGameServer> {
|
|
public:
|
|
CCallbackManual() : CCallback<T, P, bGameServer>(NULL, NULL) {}
|
|
|
|
// Inherits public Register and Unregister functions from base class
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The following macros are implementation details, not intended for public use
|
|
//-----------------------------------------------------------------------------
|
|
#define _STEAM_CALLBACK_AUTO_HOOK(thisclass, func, param)
|
|
#define _STEAM_CALLBACK_HELPER(_1, _2, SELECTED, ...) _STEAM_CALLBACK_##SELECTED
|
|
#define _STEAM_CALLBACK_SELECT(X, Y) _STEAM_CALLBACK_HELPER X Y
|
|
#define _STEAM_CALLBACK_3(extra_code, thisclass, func, param) \
|
|
struct CCallbackInternal_##func : private CCallbackImpl<sizeof(param)> { \
|
|
CCallbackInternal_##func() { \
|
|
extra_code SteamAPI_RegisterCallback(this, param::k_iCallback); \
|
|
} \
|
|
CCallbackInternal_##func(const CCallbackInternal_##func &) { \
|
|
extra_code SteamAPI_RegisterCallback(this, param::k_iCallback); \
|
|
} \
|
|
CCallbackInternal_##func &operator=( \
|
|
const CCallbackInternal_##func &) { \
|
|
return *this; \
|
|
} \
|
|
\
|
|
private: \
|
|
virtual void Run(void *pvParam) { \
|
|
_STEAM_CALLBACK_AUTO_HOOK(thisclass, func, param) \
|
|
thisclass *pOuter = reinterpret_cast<thisclass *>( \
|
|
reinterpret_cast<char *>(this) - \
|
|
offsetof(thisclass, m_steamcallback_##func)); \
|
|
pOuter->func(reinterpret_cast<param *>(pvParam)); \
|
|
} \
|
|
} m_steamcallback_##func; \
|
|
void func(param *pParam)
|
|
#define _STEAM_CALLBACK_4(_, thisclass, func, param, var) \
|
|
CCallback<thisclass, param> var; \
|
|
void func(param *pParam)
|
|
|
|
#ifdef _WIN32
|
|
// disable this warning; this pattern need for steam callback registration
|
|
#pragma warning( \
|
|
disable : 4355) // 'this' : used in base member initializer list
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
// steamclient.dll private wrapper functions
|
|
//
|
|
// The following functions are part of abstracting API access to the
|
|
//steamclient.dll, but should only be used in very specific cases
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
// pumps out all the steam messages, calling the register callback
|
|
S_API void Steam_RunCallbacks(HSteamPipe hSteamPipe, bool bGameServerCallbacks);
|
|
|
|
// register the callback funcs to use to interact with the steam dll
|
|
S_API void Steam_RegisterInterfaceFuncs(void *hModule);
|
|
|
|
// returns the HSteamUser of the last user to dispatch a callback
|
|
S_API HSteamUser Steam_GetHSteamUserCurrent();
|
|
|
|
// returns the filename path of the current running Steam process, used if you
|
|
// need to load an explicit steam dll by name
|
|
S_API const char *SteamAPI_GetSteamInstallPath();
|
|
|
|
// returns the pipe we are communicating to Steam with
|
|
S_API HSteamPipe SteamAPI_GetHSteamPipe();
|
|
|
|
// sets whether or not Steam_RunCallbacks() should do a try {} catch (...) {}
|
|
// around calls to issuing callbacks
|
|
S_API void SteamAPI_SetTryCatchCallbacks(bool bTryCatchCallbacks);
|
|
|
|
// backwards compat export, passes through to SteamAPI_ variants
|
|
S_API HSteamPipe GetHSteamPipe();
|
|
S_API HSteamUser GetHSteamUser();
|
|
|
|
#ifdef VERSION_SAFE_STEAM_API_INTERFACES
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
// VERSION_SAFE_STEAM_API_INTERFACES uses CSteamAPIContext to provide interfaces
|
|
// to each module in a way that lets them each specify the interface versions
|
|
// they are compiled with.
|
|
//
|
|
// It's important that these stay inlined in the header so the calling module
|
|
// specifies the interface versions for whatever Steam API version it has.
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
S_API HSteamUser SteamAPI_GetHSteamUser();
|
|
|
|
class CSteamAPIContext {
|
|
public:
|
|
CSteamAPIContext();
|
|
void Clear();
|
|
|
|
bool Init();
|
|
|
|
ISteamUser *SteamUser() { return m_pSteamUser; }
|
|
ISteamFriends *SteamFriends() { return m_pSteamFriends; }
|
|
ISteamUtils *SteamUtils() { return m_pSteamUtils; }
|
|
ISteamMatchmaking *SteamMatchmaking() { return m_pSteamMatchmaking; }
|
|
ISteamUserStats *SteamUserStats() { return m_pSteamUserStats; }
|
|
ISteamApps *SteamApps() { return m_pSteamApps; }
|
|
ISteamMatchmakingServers *SteamMatchmakingServers() {
|
|
return m_pSteamMatchmakingServers;
|
|
}
|
|
ISteamNetworking *SteamNetworking() { return m_pSteamNetworking; }
|
|
ISteamRemoteStorage *SteamRemoteStorage() { return m_pSteamRemoteStorage; }
|
|
ISteamScreenshots *SteamScreenshots() { return m_pSteamScreenshots; }
|
|
ISteamHTTP *SteamHTTP() { return m_pSteamHTTP; }
|
|
ISteamUnifiedMessages *SteamUnifiedMessages() {
|
|
return m_pSteamUnifiedMessages;
|
|
}
|
|
ISteamController *SteamController() { return m_pController; }
|
|
ISteamUGC *SteamUGC() { return m_pSteamUGC; }
|
|
ISteamAppList *SteamAppList() { return m_pSteamAppList; }
|
|
ISteamMusic *SteamMusic() { return m_pSteamMusic; }
|
|
ISteamMusicRemote *SteamMusicRemote() { return m_pSteamMusicRemote; }
|
|
ISteamHTMLSurface *SteamHTMLSurface() { return m_pSteamHTMLSurface; }
|
|
#ifdef _PS3
|
|
ISteamPS3OverlayRender *SteamPS3OverlayRender() {
|
|
return m_pSteamPS3OverlayRender;
|
|
}
|
|
#endif
|
|
|
|
private:
|
|
ISteamUser *m_pSteamUser;
|
|
ISteamFriends *m_pSteamFriends;
|
|
ISteamUtils *m_pSteamUtils;
|
|
ISteamMatchmaking *m_pSteamMatchmaking;
|
|
ISteamUserStats *m_pSteamUserStats;
|
|
ISteamApps *m_pSteamApps;
|
|
ISteamMatchmakingServers *m_pSteamMatchmakingServers;
|
|
ISteamNetworking *m_pSteamNetworking;
|
|
ISteamRemoteStorage *m_pSteamRemoteStorage;
|
|
ISteamScreenshots *m_pSteamScreenshots;
|
|
ISteamHTTP *m_pSteamHTTP;
|
|
ISteamUnifiedMessages *m_pSteamUnifiedMessages;
|
|
ISteamController *m_pController;
|
|
ISteamUGC *m_pSteamUGC;
|
|
ISteamAppList *m_pSteamAppList;
|
|
ISteamMusic *m_pSteamMusic;
|
|
ISteamMusicRemote *m_pSteamMusicRemote;
|
|
ISteamHTMLSurface *m_pSteamHTMLSurface;
|
|
#ifdef _PS3
|
|
ISteamPS3OverlayRender *m_pSteamPS3OverlayRender;
|
|
#endif
|
|
};
|
|
|
|
inline CSteamAPIContext::CSteamAPIContext() { Clear(); }
|
|
|
|
inline void CSteamAPIContext::Clear() {
|
|
m_pSteamUser = NULL;
|
|
m_pSteamFriends = NULL;
|
|
m_pSteamUtils = NULL;
|
|
m_pSteamMatchmaking = NULL;
|
|
m_pSteamUserStats = NULL;
|
|
m_pSteamApps = NULL;
|
|
m_pSteamMatchmakingServers = NULL;
|
|
m_pSteamNetworking = NULL;
|
|
m_pSteamRemoteStorage = NULL;
|
|
m_pSteamHTTP = NULL;
|
|
m_pSteamScreenshots = NULL;
|
|
m_pSteamMusic = NULL;
|
|
m_pSteamUnifiedMessages = NULL;
|
|
m_pController = NULL;
|
|
m_pSteamUGC = NULL;
|
|
m_pSteamAppList = NULL;
|
|
m_pSteamMusic = NULL;
|
|
m_pSteamMusicRemote = NULL;
|
|
m_pSteamHTMLSurface = NULL;
|
|
#ifdef _PS3
|
|
m_pSteamPS3OverlayRender = NULL;
|
|
#endif
|
|
}
|
|
|
|
// This function must be inlined so the module using steam_api.dll gets the
|
|
// version names they want.
|
|
inline bool CSteamAPIContext::Init() {
|
|
if (!SteamClient()) return false;
|
|
|
|
HSteamUser hSteamUser = SteamAPI_GetHSteamUser();
|
|
HSteamPipe hSteamPipe = SteamAPI_GetHSteamPipe();
|
|
|
|
m_pSteamUser = SteamClient()->GetISteamUser(hSteamUser, hSteamPipe,
|
|
STEAMUSER_INTERFACE_VERSION);
|
|
if (!m_pSteamUser) return false;
|
|
|
|
m_pSteamFriends = SteamClient()->GetISteamFriends(
|
|
hSteamUser, hSteamPipe, STEAMFRIENDS_INTERFACE_VERSION);
|
|
if (!m_pSteamFriends) return false;
|
|
|
|
m_pSteamUtils =
|
|
SteamClient()->GetISteamUtils(hSteamPipe, STEAMUTILS_INTERFACE_VERSION);
|
|
if (!m_pSteamUtils) return false;
|
|
|
|
m_pSteamMatchmaking = SteamClient()->GetISteamMatchmaking(
|
|
hSteamUser, hSteamPipe, STEAMMATCHMAKING_INTERFACE_VERSION);
|
|
if (!m_pSteamMatchmaking) return false;
|
|
|
|
m_pSteamMatchmakingServers = SteamClient()->GetISteamMatchmakingServers(
|
|
hSteamUser, hSteamPipe, STEAMMATCHMAKINGSERVERS_INTERFACE_VERSION);
|
|
if (!m_pSteamMatchmakingServers) return false;
|
|
|
|
m_pSteamUserStats = SteamClient()->GetISteamUserStats(
|
|
hSteamUser, hSteamPipe, STEAMUSERSTATS_INTERFACE_VERSION);
|
|
if (!m_pSteamUserStats) return false;
|
|
|
|
m_pSteamApps = SteamClient()->GetISteamApps(hSteamUser, hSteamPipe,
|
|
STEAMAPPS_INTERFACE_VERSION);
|
|
if (!m_pSteamApps) return false;
|
|
|
|
m_pSteamNetworking = SteamClient()->GetISteamNetworking(
|
|
hSteamUser, hSteamPipe, STEAMNETWORKING_INTERFACE_VERSION);
|
|
if (!m_pSteamNetworking) return false;
|
|
|
|
m_pSteamRemoteStorage = SteamClient()->GetISteamRemoteStorage(
|
|
hSteamUser, hSteamPipe, STEAMREMOTESTORAGE_INTERFACE_VERSION);
|
|
if (!m_pSteamRemoteStorage) return false;
|
|
|
|
m_pSteamScreenshots = SteamClient()->GetISteamScreenshots(
|
|
hSteamUser, hSteamPipe, STEAMSCREENSHOTS_INTERFACE_VERSION);
|
|
if (!m_pSteamScreenshots) return false;
|
|
|
|
m_pSteamHTTP = SteamClient()->GetISteamHTTP(hSteamUser, hSteamPipe,
|
|
STEAMHTTP_INTERFACE_VERSION);
|
|
if (!m_pSteamHTTP) return false;
|
|
|
|
m_pSteamUnifiedMessages = SteamClient()->GetISteamUnifiedMessages(
|
|
hSteamUser, hSteamPipe, STEAMUNIFIEDMESSAGES_INTERFACE_VERSION);
|
|
if (!m_pSteamUnifiedMessages) return false;
|
|
|
|
m_pController = SteamClient()->GetISteamController(
|
|
hSteamUser, hSteamPipe, STEAMCONTROLLER_INTERFACE_VERSION);
|
|
if (!m_pController) return false;
|
|
|
|
m_pSteamUGC = SteamClient()->GetISteamUGC(hSteamUser, hSteamPipe,
|
|
STEAMUGC_INTERFACE_VERSION);
|
|
if (!m_pSteamUGC) return false;
|
|
|
|
m_pSteamAppList = SteamClient()->GetISteamAppList(
|
|
hSteamUser, hSteamPipe, STEAMAPPLIST_INTERFACE_VERSION);
|
|
if (!m_pSteamAppList) return false;
|
|
|
|
m_pSteamMusic = SteamClient()->GetISteamMusic(hSteamUser, hSteamPipe,
|
|
STEAMMUSIC_INTERFACE_VERSION);
|
|
if (!m_pSteamMusic) {
|
|
return false;
|
|
}
|
|
|
|
m_pSteamMusicRemote = SteamClient()->GetISteamMusicRemote(
|
|
hSteamUser, hSteamPipe, STEAMMUSICREMOTE_INTERFACE_VERSION);
|
|
if (!m_pSteamMusicRemote) {
|
|
return false;
|
|
}
|
|
|
|
m_pSteamHTMLSurface = SteamClient()->GetISteamHTMLSurface(
|
|
hSteamUser, hSteamPipe, STEAMHTMLSURFACE_INTERFACE_VERSION);
|
|
if (!m_pSteamHTMLSurface) {
|
|
return false;
|
|
}
|
|
|
|
#ifdef _PS3
|
|
m_pSteamPS3OverlayRender = SteamClient()->GetISteamPS3OverlayRender();
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
|
|
#endif // VERSION_SAFE_STEAM_API_INTERFACES
|
|
|
|
#if defined(USE_BREAKPAD_HANDLER) || defined(STEAM_API_EXPORTS)
|
|
// this should be called before the game initialized the steam APIs
|
|
// pchDate should be of the format "Mmm dd yyyy" (such as from the __DATE__
|
|
// macro ) pchTime should be of the format "hh:mm:ss" (such as from the __TIME__
|
|
// macro ) bFullMemoryDumps (Win32 only) -- writes out a uuid-full.dmp in the
|
|
// client/dumps folder pvContext-- can be NULL, will be the void * context
|
|
// passed into m_pfnPreMinidumpCallback PFNPreMinidumpCallback
|
|
// m_pfnPreMinidumpCallback -- optional callback which occurs just before a
|
|
// .dmp file is written during a crash. Applications can hook this to allow
|
|
// adding additional information into the .dmp comment stream.
|
|
S_API void S_CALLTYPE SteamAPI_UseBreakpadCrashHandler(
|
|
char const *pchVersion, char const *pchDate, char const *pchTime,
|
|
bool bFullMemoryDumps, void *pvContext,
|
|
PFNPreMinidumpCallback m_pfnPreMinidumpCallback);
|
|
S_API void S_CALLTYPE SteamAPI_SetBreakpadAppID(uint32 unAppID);
|
|
#endif
|
|
|
|
#endif // STEAM_API_H
|