1 files changed, 0 insertions, 394 deletions
diff --git a/lib/windows64/include/steam/steam_api.h b/lib/windows64/include/steam/steam_api.h
deleted file mode 100644
index e3a31ae..0000000
--- a/lib/windows64/include/steam/steam_api.h
+++ /dev/null
@@ -1,394 +0,0 @@
-//====== 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