395 lines
17 KiB
C++
Vendored
395 lines
17 KiB
C++
Vendored
//====== Copyright 1996-2008, Valve Corporation, All rights reserved. =======
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef STEAM_API_H
|
|
#define STEAM_API_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "isteamclient.h"
|
|
#include "isteamuser.h"
|
|
#include "isteamfriends.h"
|
|
#include "isteamutils.h"
|
|
#include "isteammatchmaking.h"
|
|
#include "isteamuserstats.h"
|
|
#include "isteamapps.h"
|
|
#include "isteamnetworking.h"
|
|
#include "isteamremotestorage.h"
|
|
#include "isteamscreenshots.h"
|
|
#include "isteammusic.h"
|
|
#include "isteammusicremote.h"
|
|
#include "isteamhttp.h"
|
|
#include "isteamunifiedmessages.h"
|
|
#include "isteamcontroller.h"
|
|
#include "isteamugc.h"
|
|
#include "isteamapplist.h"
|
|
#include "isteamhtmlsurface.h"
|
|
#include "isteaminventory.h"
|
|
#include "isteamvideo.h"
|
|
|
|
|
|
// 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
|
|
//
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
|
|
// SteamAPI_Init must be called before using any other API functions. If it fails, an
|
|
// error message will be output to the debugger (or stderr) with further information.
|
|
S_API bool S_CALLTYPE SteamAPI_Init();
|
|
|
|
// SteamAPI_Shutdown should be called during process shutdown if possible.
|
|
S_API void S_CALLTYPE SteamAPI_Shutdown();
|
|
|
|
// SteamAPI_RestartAppIfNecessary ensures that your executable was launched through Steam.
|
|
//
|
|
// Returns true if the current process should terminate. Steam is now re-launching your application.
|
|
//
|
|
// Returns false if no action needs to be taken. This means that 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 if false is returned.
|
|
//
|
|
// NOTE: If you use the Steam DRM wrapper on your primary executable file, this check is unnecessary
|
|
// since the DRM wrapper will ensure that your application was launched properly through Steam.
|
|
S_API bool S_CALLTYPE SteamAPI_RestartAppIfNecessary( uint32 unOwnAppID );
|
|
|
|
// Many Steam API functions allocate a small amount of thread-local memory for parameter storage.
|
|
// SteamAPI_ReleaseCurrentThreadMemory() will free API memory associated with the calling thread.
|
|
// This function is also called automatically by SteamAPI_RunCallbacks(), so a single-threaded
|
|
// program never needs to explicitly call this function.
|
|
S_API void S_CALLTYPE SteamAPI_ReleaseCurrentThreadMemory();
|
|
|
|
|
|
// 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 );
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
// Global accessors for Steamworks C++ APIs. See individual isteam*.h files for details.
|
|
// You should not cache the results of these accessors or pass the result pointers across
|
|
// modules! Different modules may be compiled against different SDK header versions, and
|
|
// the interface pointers could therefore be different across modules. Every line of code
|
|
// which calls into a Steamworks API should retrieve the interface from a global accessor.
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
#if !defined( STEAM_API_EXPORTS )
|
|
inline ISteamClient *SteamClient();
|
|
inline ISteamUser *SteamUser();
|
|
inline ISteamFriends *SteamFriends();
|
|
inline ISteamUtils *SteamUtils();
|
|
inline ISteamMatchmaking *SteamMatchmaking();
|
|
inline ISteamUserStats *SteamUserStats();
|
|
inline ISteamApps *SteamApps();
|
|
inline ISteamNetworking *SteamNetworking();
|
|
inline ISteamMatchmakingServers *SteamMatchmakingServers();
|
|
inline ISteamRemoteStorage *SteamRemoteStorage();
|
|
inline ISteamScreenshots *SteamScreenshots();
|
|
inline ISteamHTTP *SteamHTTP();
|
|
inline ISteamUnifiedMessages *SteamUnifiedMessages();
|
|
inline ISteamController *SteamController();
|
|
inline ISteamUGC *SteamUGC();
|
|
inline ISteamAppList *SteamAppList();
|
|
inline ISteamMusic *SteamMusic();
|
|
inline ISteamMusicRemote *SteamMusicRemote();
|
|
inline ISteamHTMLSurface *SteamHTMLSurface();
|
|
inline ISteamInventory *SteamInventory();
|
|
inline ISteamVideo *SteamVideo();
|
|
#endif // VERSION_SAFE_STEAM_API_INTERFACES
|
|
|
|
|
|
// CSteamAPIContext encapsulates the Steamworks API global accessors into
|
|
// a single object. This is DEPRECATED and only remains for compatibility.
|
|
class CSteamAPIContext
|
|
{
|
|
public:
|
|
// DEPRECATED - there is no benefit to using this over the global accessors
|
|
CSteamAPIContext() { Clear(); }
|
|
void Clear();
|
|
bool Init();
|
|
ISteamClient* SteamClient() const { return m_pSteamClient; }
|
|
ISteamUser* SteamUser() const { return m_pSteamUser; }
|
|
ISteamFriends* SteamFriends() const { return m_pSteamFriends; }
|
|
ISteamUtils* SteamUtils() const { return m_pSteamUtils; }
|
|
ISteamMatchmaking* SteamMatchmaking() const { return m_pSteamMatchmaking; }
|
|
ISteamUserStats* SteamUserStats() const { return m_pSteamUserStats; }
|
|
ISteamApps* SteamApps() const { return m_pSteamApps; }
|
|
ISteamMatchmakingServers* SteamMatchmakingServers() const { return m_pSteamMatchmakingServers; }
|
|
ISteamNetworking* SteamNetworking() const { return m_pSteamNetworking; }
|
|
ISteamRemoteStorage* SteamRemoteStorage() const { return m_pSteamRemoteStorage; }
|
|
ISteamScreenshots* SteamScreenshots() const { return m_pSteamScreenshots; }
|
|
ISteamHTTP* SteamHTTP() const { return m_pSteamHTTP; }
|
|
ISteamUnifiedMessages* SteamUnifiedMessages() const { return m_pSteamUnifiedMessages; }
|
|
ISteamController* SteamController() const { return m_pController; }
|
|
ISteamUGC* SteamUGC() const { return m_pSteamUGC; }
|
|
ISteamAppList* SteamAppList() const { return m_pSteamAppList; }
|
|
ISteamMusic* SteamMusic() const { return m_pSteamMusic; }
|
|
ISteamMusicRemote* SteamMusicRemote() const { return m_pSteamMusicRemote; }
|
|
ISteamHTMLSurface* SteamHTMLSurface() const { return m_pSteamHTMLSurface; }
|
|
ISteamInventory* SteamInventory() const { return m_pSteamInventory; }
|
|
ISteamVideo* SteamVideo() const { return m_pSteamVideo; }
|
|
// DEPRECATED - there is no benefit to using this over the global accessors
|
|
private:
|
|
ISteamClient *m_pSteamClient;
|
|
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;
|
|
ISteamInventory *m_pSteamInventory;
|
|
ISteamVideo *m_pSteamVideo;
|
|
};
|
|
|
|
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
// 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().
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
// SteamAPI_RunCallbacks is safe to call from multiple threads simultaneously,
|
|
// but if you choose to do this, callback code could be executed on any thread.
|
|
// One alternative is to call SteamAPI_RunCallbacks from the main thread only,
|
|
// and call SteamAPI_ReleaseCurrentThreadMemory regularly on other threads.
|
|
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();
|
|
~CCallResult();
|
|
|
|
void Set( SteamAPICall_t hAPICall, T *p, func_t func );
|
|
bool IsActive() const;
|
|
void Cancel();
|
|
|
|
void SetGameserverFlag() { m_nCallbackFlags |= k_ECallbackFlagsGameServer; }
|
|
private:
|
|
virtual void Run( void *pvParam );
|
|
virtual void Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall );
|
|
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 );
|
|
|
|
void Register( T *pObj, func_t func );
|
|
void Unregister();
|
|
|
|
protected:
|
|
virtual void Run( void *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
|
|
};
|
|
|
|
|
|
|
|
#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
|
|
//----------------------------------------------------------------------------------------------------------------------------------------------------------//
|
|
|
|
// SteamAPI_IsSteamRunning() returns true if Steam is currently running
|
|
S_API bool S_CALLTYPE SteamAPI_IsSteamRunning();
|
|
|
|
// Pumps out all the steam messages, calling registered callbacks.
|
|
// NOT THREADSAFE - do not call from multiple threads simultaneously.
|
|
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.
|
|
// DEPRECATED - implementation is Windows only, and the path returned is a UTF-8 string which must be converted to UTF-16 for use with Win32 APIs
|
|
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();
|
|
|
|
|
|
#if defined( VERSION_SAFE_STEAM_API_INTERFACES )
|
|
// exists only for backwards compat with code written against older SDKs
|
|
S_API bool S_CALLTYPE SteamAPI_InitSafe();
|
|
#endif
|
|
|
|
#include "steam_api_internal.h"
|
|
|
|
#endif // STEAM_API_H
|