diff options
Diffstat (limited to 'lib/osx/include/steam/steam_api.h')
| -rw-r--r-- | lib/osx/include/steam/steam_api.h | 554 |
1 files changed, 267 insertions, 287 deletions
diff --git a/lib/osx/include/steam/steam_api.h b/lib/osx/include/steam/steam_api.h index e3a31ae..55d90e4 100644 --- a/lib/osx/include/steam/steam_api.h +++ b/lib/osx/include/steam/steam_api.h @@ -1,6 +1,13 @@ -//====== Copyright 1996-2008, Valve Corporation, All rights reserved. ======= +//====== Copyright Valve Corporation, All rights reserved. ==================== // -// Purpose: +// This header includes *all* of the interfaces and callback structures +// in the Steamworks SDK, and some high level functions to control the SDK +// (init, shutdown, etc) that you probably only need in one or two files. +// +// To save your compile times, we recommend that you not include this file +// in header files. Instead, include the specific headers for the interfaces +// and callback structures you need. The one file you might consider including +// in your precompiled header (e.g. stdafx.h) is steam_api_common.h // //============================================================================= @@ -10,6 +17,10 @@ #pragma once #endif +// Basic stuff +#include "steam_api_common.h" + +// All of the interfaces #include "isteamclient.h" #include "isteamuser.h" #include "isteamfriends.h" @@ -23,38 +34,19 @@ #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" +#include "isteamparentalsettings.h" +#include "isteaminput.h" +#include "isteamremoteplay.h" +#include "isteamnetworkingmessages.h" +#include "isteamnetworkingsockets.h" +#include "isteamnetworkingutils.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 // @@ -62,10 +54,54 @@ // //----------------------------------------------------------------------------------------------------------------------------------------------------------// +enum ESteamAPIInitResult +{ + k_ESteamAPIInitResult_OK = 0, + k_ESteamAPIInitResult_FailedGeneric = 1, // Some other failure + k_ESteamAPIInitResult_NoSteamClient = 2, // We cannot connect to Steam, steam probably isn't running + k_ESteamAPIInitResult_VersionMismatch = 3, // Steam client appears to be out of date +}; + +// Initializing the Steamworks SDK +// ----------------------------- +// +// There are three different methods you can use to initialize the Steamworks SDK, depending on +// your project's environment. You should only use one method in your project. +// +// If you are able to include this C++ header in your project, we recommend using the following +// initialization methods. They will ensure that all ISteam* interfaces defined in other +// C++ header files have versions that are supported by the user's Steam Client: +// - SteamAPI_InitEx() for new projects so you can show a detailed error message to the user +// - SteamAPI_Init() for existing projects that only display a generic error message +// +// If you are unable to include this C++ header in your project and are dynamically loading +// Steamworks SDK methods from dll/so, you can use the following method: +// - SteamAPI_InitFlat() + + +// See "Initializing the Steamworks SDK" above for how to choose an init method. +// On success k_ESteamAPIInitResult_OK is returned. Otherwise, returns a value that can be used +// to create a localized error message for the user. If pOutErrMsg is non-NULL, +// it will receive an example error message, in English, that explains the reason for the failure. +// +// Example usage: +// +// SteamErrMsg errMsg; +// if ( SteamAPI_Init(&errMsg) != k_ESteamAPIInitResult_OK ) +// FatalError( "Failed to init Steam. %s", errMsg ); +inline ESteamAPIInitResult SteamAPI_InitEx( SteamErrMsg *pOutErrMsg ); + +// See "Initializing the Steamworks SDK" above for how to choose an init method. +// Returns true on success +inline bool SteamAPI_Init() +{ + return SteamAPI_InitEx( NULL ) == k_ESteamAPIInitResult_OK; +} -// 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(); +// See "Initializing the Steamworks SDK" above for how to choose an init method. +// Same usage as SteamAPI_InitEx(), however does not verify ISteam* interfaces are +// supported by the user's client and is exported from the dll +S_API ESteamAPIInitResult S_CALLTYPE SteamAPI_InitFlat( SteamErrMsg *pOutErrMsg ); // SteamAPI_Shutdown should be called during process shutdown if possible. S_API void S_CALLTYPE SteamAPI_Shutdown(); @@ -93,302 +129,246 @@ S_API void S_CALLTYPE SteamAPI_ReleaseCurrentThreadMemory(); 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. +// 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 //----------------------------------------------------------------------------------------------------------------------------------------------------------// -#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; -}; +// SteamAPI_IsSteamRunning() returns true if Steam is currently running +S_API bool S_CALLTYPE SteamAPI_IsSteamRunning(); + +// 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(); + +// sets whether or not Steam_RunCallbacks() should do a try {} catch (...) {} around calls to issuing callbacks +// This is ignored if you are using the manual callback dispatch method +S_API void SteamAPI_SetTryCatchCallbacks( bool bTryCatchCallbacks ); + +#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 + +#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 //----------------------------------------------------------------------------------------------------------------------------------------------------------// -// 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. +// Manual callback loop // -// 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 )". +// An alternative method for dispatching callbacks. Similar to a windows message loop. // -// 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. +// If you use the manual callback dispatch, you must NOT use: // -// CCallback and CCallbackManual classes can be used instead of STEAM_CALLBACK -// macros if you require finer control over registration and unregistration. +// - SteamAPI_RunCallbacks or SteamGameServer_RunCallbacks +// - STEAM_CALLBACK, CCallResult, CCallback, or CCallbackManual // -// Callbacks and call-results are queued automatically and are only -// delivered/executed when your application calls SteamAPI_RunCallbacks(). +// Here is the basic template for replacing SteamAPI_RunCallbacks() with manual dispatch +/* + + HSteamPipe hSteamPipe = SteamAPI_GetHSteamPipe(); // See also SteamGameServer_GetHSteamPipe() + SteamAPI_ManualDispatch_RunFrame( hSteamPipe ) + CallbackMsg_t callback; + while ( SteamAPI_ManualDispatch_GetNextCallback( hSteamPipe, &callback ) ) + { + // Check for dispatching API call results + if ( callback.m_iCallback == SteamAPICallCompleted_t::k_iCallback ) + { + SteamAPICallCompleted_t *pCallCompleted = (SteamAPICallCompleted_t *)callback. + void *pTmpCallResult = malloc( pCallback->m_cubParam ); + bool bFailed; + if ( SteamAPI_ManualDispatch_GetAPICallResult( hSteamPipe, pCallCompleted->m_hAsyncCall, pTmpCallResult, pCallback->m_cubParam, pCallback->m_iCallback, &bFailed ) ) + { + // Dispatch the call result to the registered handler(s) for the + // call identified by pCallCompleted->m_hAsyncCall + } + free( pTmpCallResult ); + } + else + { + // Look at callback.m_iCallback to see what kind of callback it is, + // and dispatch to appropriate handler(s) + } + SteamAPI_ManualDispatch_FreeLastCallback( hSteamPipe ); + } + +*/ //----------------------------------------------------------------------------------------------------------------------------------------------------------// -// 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__ ) ) +/// Inform the API that you wish to use manual event dispatch. This must be called after SteamAPI_Init, but before +/// you use any of the other manual dispatch functions below. +S_API void S_CALLTYPE SteamAPI_ManualDispatch_Init(); -// 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 ) +/// Perform certain periodic actions that need to be performed. +S_API void S_CALLTYPE SteamAPI_ManualDispatch_RunFrame( HSteamPipe hSteamPipe ); +/// Fetch the next pending callback on the given pipe, if any. If a callback is available, true is returned +/// and the structure is populated. In this case, you MUST call SteamAPI_ManualDispatch_FreeLastCallback +/// (after dispatching the callback) before calling SteamAPI_ManualDispatch_GetNextCallback again. +S_API bool S_CALLTYPE SteamAPI_ManualDispatch_GetNextCallback( HSteamPipe hSteamPipe, CallbackMsg_t *pCallbackMsg ); -// 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 ); +/// You must call this after dispatching the callback, if SteamAPI_ManualDispatch_GetNextCallback returns true. +S_API void S_CALLTYPE SteamAPI_ManualDispatch_FreeLastCallback( HSteamPipe hSteamPipe ); +/// Return the call result for the specified call on the specified pipe. You really should +/// only call this in a handler for SteamAPICallCompleted_t callback. +S_API bool S_CALLTYPE SteamAPI_ManualDispatch_GetAPICallResult( HSteamPipe hSteamPipe, SteamAPICall_t hSteamAPICall, void *pCallback, int cubCallback, int iCallbackExpected, bool *pbFailed ); -//----------------------------------------------------------------------------- -// 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; } -}; +//----------------------------------------------------------------------------------------------------------------------------------------------------------// +// +// CSteamAPIContext +// +// Deprecated! This is not necessary any more. Please use the global accessors directly +// +//----------------------------------------------------------------------------------------------------------------------------------------------------------// +#ifndef STEAM_API_EXPORTS -//----------------------------------------------------------------------------- -// 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 +inline bool CSteamAPIContext::Init() { -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; -}; - + m_pSteamClient = ::SteamClient(); + if ( !m_pSteamClient ) + return false; + + m_pSteamUser = ::SteamUser(); + if ( !m_pSteamUser ) + return false; + + m_pSteamFriends = ::SteamFriends(); + if ( !m_pSteamFriends ) + return false; + + m_pSteamUtils = ::SteamUtils(); + if ( !m_pSteamUtils ) + return false; + + m_pSteamMatchmaking = ::SteamMatchmaking(); + if ( !m_pSteamMatchmaking ) + return false; + + m_pSteamGameSearch = ::SteamGameSearch(); + if ( !m_pSteamGameSearch ) + return false; + +#if !defined( IOSALL) // Not yet supported on iOS. + m_pSteamMatchmakingServers = ::SteamMatchmakingServers(); + if ( !m_pSteamMatchmakingServers ) + return false; +#endif + m_pSteamUserStats = ::SteamUserStats(); + if ( !m_pSteamUserStats ) + return false; -//----------------------------------------------------------------------------- -// 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*); + m_pSteamApps = ::SteamApps(); + if ( !m_pSteamApps ) + return false; - // 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_pSteamNetworking = ::SteamNetworking(); + if ( !m_pSteamNetworking ) + return false; - void Register( T *pObj, func_t func ); - void Unregister(); + m_pSteamRemoteStorage = ::SteamRemoteStorage(); + if ( !m_pSteamRemoteStorage ) + return false; -protected: - virtual void Run( void *pvParam ); - - T *m_pObj; - func_t m_Func; -}; + m_pSteamScreenshots = ::SteamScreenshots(); + if ( !m_pSteamScreenshots ) + return false; + m_pSteamHTTP = ::SteamHTTP(); + if ( !m_pSteamHTTP ) + return false; -//----------------------------------------------------------------------------- -// 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 ) {} + m_pController = ::SteamController(); + if ( !m_pController ) + return false; - // Inherits public Register and Unregister functions from base class -}; + m_pSteamUGC = ::SteamUGC(); + if ( !m_pSteamUGC ) + return false; + m_pSteamMusic = ::SteamMusic(); + if ( !m_pSteamMusic ) + return false; + m_pSteamMusicRemote = ::SteamMusicRemote(); + if ( !m_pSteamMusicRemote ) + return false; -#ifdef _WIN32 -// disable this warning; this pattern need for steam callback registration -#pragma warning( disable: 4355 ) // 'this' : used in base member initializer list +#if !defined( ANDROID ) && !defined( IOSALL) // Not yet supported on Android or ios. + m_pSteamHTMLSurface = ::SteamHTMLSurface(); + if ( !m_pSteamHTMLSurface ) + return false; #endif + m_pSteamInventory = ::SteamInventory(); + if ( !m_pSteamInventory ) + return false; -//----------------------------------------------------------------------------------------------------------------------------------------------------------// -// 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(); + m_pSteamVideo = ::SteamVideo(); + if ( !m_pSteamVideo ) + return false; -// sets whether or not Steam_RunCallbacks() should do a try {} catch (...) {} around calls to issuing callbacks -S_API void SteamAPI_SetTryCatchCallbacks( bool bTryCatchCallbacks ); + m_pSteamParentalSettings = ::SteamParentalSettings(); + if ( !m_pSteamParentalSettings ) + return false; -// backwards compat export, passes through to SteamAPI_ variants -S_API HSteamPipe GetHSteamPipe(); -S_API HSteamUser GetHSteamUser(); + m_pSteamInput = ::SteamInput(); + if ( !m_pSteamInput ) + return false; + return true; +} -#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" +// Internal implementation of SteamAPI_InitEx. This is done in a way that checks +// all of the versions of interfaces from headers being compiled into this code. +S_API ESteamAPIInitResult S_CALLTYPE SteamInternal_SteamAPI_Init( const char *pszInternalCheckInterfaceVersions, SteamErrMsg *pOutErrMsg ); +inline ESteamAPIInitResult SteamAPI_InitEx( SteamErrMsg *pOutErrMsg ) +{ + const char *pszInternalCheckInterfaceVersions = + STEAMUTILS_INTERFACE_VERSION "\0" + STEAMNETWORKINGUTILS_INTERFACE_VERSION "\0" + STEAMAPPS_INTERFACE_VERSION "\0" + STEAMCONTROLLER_INTERFACE_VERSION "\0" + STEAMFRIENDS_INTERFACE_VERSION "\0" + STEAMGAMESEARCH_INTERFACE_VERSION "\0" + STEAMHTMLSURFACE_INTERFACE_VERSION "\0" + STEAMHTTP_INTERFACE_VERSION "\0" + STEAMINPUT_INTERFACE_VERSION "\0" + STEAMINVENTORY_INTERFACE_VERSION "\0" + STEAMMATCHMAKINGSERVERS_INTERFACE_VERSION "\0" + STEAMMATCHMAKING_INTERFACE_VERSION "\0" + STEAMMUSICREMOTE_INTERFACE_VERSION "\0" + STEAMMUSIC_INTERFACE_VERSION "\0" + STEAMNETWORKINGMESSAGES_INTERFACE_VERSION "\0" + STEAMNETWORKINGSOCKETS_INTERFACE_VERSION "\0" + STEAMNETWORKING_INTERFACE_VERSION "\0" + STEAMPARENTALSETTINGS_INTERFACE_VERSION "\0" + STEAMPARTIES_INTERFACE_VERSION "\0" + STEAMREMOTEPLAY_INTERFACE_VERSION "\0" + STEAMREMOTESTORAGE_INTERFACE_VERSION "\0" + STEAMSCREENSHOTS_INTERFACE_VERSION "\0" + STEAMUGC_INTERFACE_VERSION "\0" + STEAMUSERSTATS_INTERFACE_VERSION "\0" + STEAMUSER_INTERFACE_VERSION "\0" + STEAMVIDEO_INTERFACE_VERSION "\0" + + "\0"; + + return SteamInternal_SteamAPI_Init( pszInternalCheckInterfaceVersions, pOutErrMsg ); +} #endif // STEAM_API_H |