v1.35

public/steam/isteamcontroller.h

@@ -12,67 +12,19 @@
 
 #include "isteamclient.h"
 
-// callbacks
-#if defined( VALVE_CALLBACK_PACK_SMALL )
-#pragma pack( push, 4 )
-#elif defined( VALVE_CALLBACK_PACK_LARGE )
-#pragma pack( push, 8 )
-#else
-#error isteamclient.h must be included
-#endif 
+#define STEAM_CONTROLLER_MAX_COUNT 16
 
-#define MAX_STEAM_CONTROLLERS 16
+#define STEAM_CONTROLLER_MAX_ANALOG_ACTIONS 16
 
-#pragma pack( pop )
+#define STEAM_CONTROLLER_MAX_DIGITAL_ACTIONS 32
 
-#define STEAM_RIGHT_TRIGGER_MASK            0x0000001
-#define STEAM_LEFT_TRIGGER_MASK             0x0000002
-#define STEAM_RIGHT_BUMPER_MASK             0x0000004
-#define STEAM_LEFT_BUMPER_MASK              0x0000008
-#define STEAM_BUTTON_0_MASK                 0x0000010
-#define STEAM_BUTTON_1_MASK                 0x0000020
-#define STEAM_BUTTON_2_MASK                 0x0000040
-#define STEAM_BUTTON_3_MASK                 0x0000080
-#define STEAM_TOUCH_0_MASK                  0x0000100
-#define STEAM_TOUCH_1_MASK                  0x0000200
-#define STEAM_TOUCH_2_MASK                  0x0000400
-#define STEAM_TOUCH_3_MASK                  0x0000800
-#define STEAM_BUTTON_MENU_MASK              0x0001000
-#define STEAM_BUTTON_STEAM_MASK             0x0002000
-#define STEAM_BUTTON_ESCAPE_MASK            0x0004000
-#define STEAM_BUTTON_BACK_LEFT_MASK         0x0008000
-#define STEAM_BUTTON_BACK_RIGHT_MASK        0x0010000
-#define STEAM_BUTTON_LEFTPAD_CLICKED_MASK   0x0020000
-#define STEAM_BUTTON_RIGHTPAD_CLICKED_MASK  0x0040000
-#define STEAM_LEFTPAD_FINGERDOWN_MASK       0x0080000
-#define STEAM_RIGHTPAD_FINGERDOWN_MASK      0x0100000
-#define STEAM_JOYSTICK_BUTTON_MASK			0x0400000
+#define STEAM_CONTROLLER_MAX_ORIGINS 8
 
+// When sending an option to a specific controller handle, you can send to all controllers via this command
+#define STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS UINT64_MAX
 
-#pragma pack( push, 1 )
-
-struct SteamControllerState001_t
-{
-	// If packet num matches that on your prior call, then the controller state hasn't been changed since 
-	// your last call and there is no need to process it
-	uint32 unPacketNum;
-	
-	// bit flags for each of the buttons
-	uint64 ulButtons;
-	
-	// Left pad coordinates
-	short sLeftPadX;
-	short sLeftPadY;
-	
-	// Right pad coordinates
-	short sRightPadX;
-	short sRightPadY;
-	
-};
-
-#pragma pack( pop )
-
-#define SteamControllerState_t SteamControllerState001_t
+#define STEAM_CONTROLLER_MIN_ANALOG_ACTION_DATA -1.0f
+#define STEAM_CONTROLLER_MAX_ANALOG_ACTION_DATA 1.0f
 
 enum ESteamControllerPad
 {
@@ -80,59 +32,179 @@ enum ESteamControllerPad
 	k_ESteamControllerPad_Right
 };
 
+enum EControllerSource
+{
+	k_EControllerSource_None,
+	k_EControllerSource_LeftTrackpad,
+	k_EControllerSource_RightTrackpad,
+	k_EControllerSource_Joystick,
+	k_EControllerSource_ABXY,
+	k_EControllerSource_Switch,
+	k_EControllerSource_LeftTrigger,
+	k_EControllerSource_RightTrigger,
+	k_EControllerSource_Gyro
+};
+
+enum EControllerSourceMode
+{
+	k_EControllerSourceMode_None,
+	k_EControllerSourceMode_Dpad,
+	k_EControllerSourceMode_Buttons,
+	k_EControllerSourceMode_FourButtons,
+	k_EControllerSourceMode_AbsoluteMouse,
+	k_EControllerSourceMode_RelativeMouse,
+	k_EControllerSourceMode_JoystickMove,
+	k_EControllerSourceMode_JoystickCamera,
+	k_EControllerSourceMode_ScrollWheel,
+	k_EControllerSourceMode_Trigger,
+	k_EControllerSourceMode_TouchMenu
+};
+
+enum EControllerActionOrigin
+{
+	k_EControllerActionOrigin_None,
+	k_EControllerActionOrigin_A,
+	k_EControllerActionOrigin_B,
+	k_EControllerActionOrigin_X,
+	k_EControllerActionOrigin_Y,
+	k_EControllerActionOrigin_LeftBumper,
+	k_EControllerActionOrigin_RightBumper,
+	k_EControllerActionOrigin_LeftGrip,
+	k_EControllerActionOrigin_RightGrip,
+	k_EControllerActionOrigin_Start,
+	k_EControllerActionOrigin_Back,
+	k_EControllerActionOrigin_LeftPad_Touch,
+	k_EControllerActionOrigin_LeftPad_Swipe,
+	k_EControllerActionOrigin_LeftPad_Click,
+	k_EControllerActionOrigin_LeftPad_DPadNorth,
+	k_EControllerActionOrigin_LeftPad_DPadSouth,
+	k_EControllerActionOrigin_LeftPad_DPadWest,
+	k_EControllerActionOrigin_LeftPad_DPadEast,
+	k_EControllerActionOrigin_RightPad_Touch,
+	k_EControllerActionOrigin_RightPad_Swipe,
+	k_EControllerActionOrigin_RightPad_Click,
+	k_EControllerActionOrigin_RightPad_DPadNorth,
+	k_EControllerActionOrigin_RightPad_DPadSouth,
+	k_EControllerActionOrigin_RightPad_DPadWest,
+	k_EControllerActionOrigin_RightPad_DPadEast,
+	k_EControllerActionOrigin_LeftTrigger_Pull,
+	k_EControllerActionOrigin_LeftTrigger_Click,
+	k_EControllerActionOrigin_RightTrigger_Pull,
+	k_EControllerActionOrigin_RightTrigger_Click,
+	k_EControllerActionOrigin_LeftStick_Move,
+	k_EControllerActionOrigin_LeftStick_Click,
+	k_EControllerActionOrigin_LeftStick_DPadNorth,
+	k_EControllerActionOrigin_LeftStick_DPadSouth,
+	k_EControllerActionOrigin_LeftStick_DPadWest,
+	k_EControllerActionOrigin_LeftStick_DPadEast,
+	k_EControllerActionOrigin_Gyro_Move,
+	k_EControllerActionOrigin_Gyro_Pitch,
+	k_EControllerActionOrigin_Gyro_Yaw,
+	k_EControllerActionOrigin_Gyro_Roll,
+	
+	k_EControllerActionOrigin_Count
+};
+
+// ControllerHandle_t is used to refer to a specific controller.
+// This handle will consistently identify a controller, even if it is disconnected and re-connected
+typedef uint64 ControllerHandle_t;
+
+
+// These handles are used to refer to a specific in-game action or action set
+// All action handles should be queried during initialization for performance reasons
+typedef uint64 ControllerActionSetHandle_t;
+typedef uint64 ControllerDigitalActionHandle_t;
+typedef uint64 ControllerAnalogActionHandle_t;
+
+#pragma pack( push, 1 )
+
+struct ControllerAnalogActionData_t
+{
+	// Type of data coming from this action, this will match what got specified in the action set
+	EControllerSourceMode eMode;
+	
+	// The current state of this action; will be delta updates for mouse actions
+	float x, y;
+	
+	// Whether or not this action is currently available to be bound in the active action set
+	bool bActive;
+};
+
+struct ControllerDigitalActionData_t
+{
+	// The current state of this action; will be true if currently pressed
+	bool bState;
+	
+	// Whether or not this action is currently available to be bound in the active action set
+	bool bActive;
+};
+
+#pragma pack( pop )
+
+
 //-----------------------------------------------------------------------------
 // Purpose: Native Steam controller support API
 //-----------------------------------------------------------------------------
 class ISteamController
 {
 public:
-
-	//
-	// Native controller support API
-	//
-
-	// Must call init and shutdown when starting/ending use of the interface
-	virtual bool Init( const char *pchAbsolutePathToControllerConfigVDF ) = 0;
+	
+	// Init and Shutdown must be called when starting/ending use of this interface
+	virtual bool Init() = 0;
 	virtual bool Shutdown() = 0;
-
-	// Pump callback/callresult events, SteamAPI_RunCallbacks will do this for you, 
-	// normally never need to call directly.
+	
+	// Pump callback/callresult events
+	// Note: SteamAPI_RunCallbacks will do this for you, so you should never need to call this directly.
 	virtual void RunFrame() = 0;
 
-	// Get the state of the specified controller, returns false if that controller is not connected
-	virtual bool GetControllerState( uint32 unControllerIndex, SteamControllerState_t *pState ) = 0;
-
-	// Trigger a haptic pulse on the controller
-	virtual void TriggerHapticPulse( uint32 unControllerIndex, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec ) = 0;
-
-	// Set the override mode which is used to choose to use different base/legacy bindings from your config file
-	virtual void SetOverrideMode( const char *pchMode ) = 0;
-};
-
-#define STEAMCONTROLLER_INTERFACE_VERSION "STEAMCONTROLLER_INTERFACE_VERSION"
-
-// callbacks
-#if defined( VALVE_CALLBACK_PACK_SMALL )
-#pragma pack( push, 4 )
-#elif defined( VALVE_CALLBACK_PACK_LARGE )
-#pragma pack( push, 8 )
-#else
-#error isteamclient.h must be included
-#endif 
-
-//-----------------------------------------------------------------------------
-// Purpose: 
-//-----------------------------------------------------------------------------
-/*
-struct ControllerCallback_t
-{
-	enum { k_iCallback = k_iSteamControllerCallbacks + 1 };
+	// Enumerate currently connected controllers
+	// handlesOut should point to a STEAM_CONTROLLER_MAX_COUNT sized array of ControllerHandle_t handles
+	// Returns the number of handles written to handlesOut
+	virtual int GetConnectedControllers( ControllerHandle_t *handlesOut ) = 0;
 	
+	// Invokes the Steam overlay and brings up the binding screen
+	// Returns false is overlay is disabled / unavailable, or the user is not in Big Picture mode
+	virtual bool ShowBindingPanel( ControllerHandle_t controllerHandle ) = 0;
+	
+	// ACTION SETS
+	// Lookup the handle for an Action Set. Best to do this once on startup, and store the handles for all future API calls.
+	virtual ControllerActionSetHandle_t GetActionSetHandle( const char *pszActionSetName ) = 0;
+	
+	// Reconfigure the controller to use the specified action set (ie 'Menu', 'Walk' or 'Drive')
+	// This is cheap, and can be safely called repeatedly. It's often easier to repeatedly call it in
+	// your state loops, instead of trying to place it in all of your state transitions.
+	virtual void ActivateActionSet( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle ) = 0;
+	virtual ControllerActionSetHandle_t GetCurrentActionSet( ControllerHandle_t controllerHandle ) = 0;
+	
+	// ACTIONS
+	// Lookup the handle for a digital action. Best to do this once on startup, and store the handles for all future API calls.
+	virtual ControllerDigitalActionHandle_t GetDigitalActionHandle( const char *pszActionName ) = 0;
+	
+	// Returns the current state of the supplied digital game action
+	virtual ControllerDigitalActionData_t GetDigitalActionData( ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle ) = 0;
+	
+	// Get the origin(s) for a digital action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action.
+	// originsOut should point to a STEAM_CONTROLLER_MAX_ORIGINS sized array of EControllerActionOrigin handles
+	virtual int GetDigitalActionOrigins( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, EControllerActionOrigin *originsOut ) = 0;
+	
+	// Lookup the handle for an analog action. Best to do this once on startup, and store the handles for all future API calls.
+	virtual ControllerAnalogActionHandle_t GetAnalogActionHandle( const char *pszActionName ) = 0;
+	
+	// Returns the current state of these supplied analog game action
+	virtual ControllerAnalogActionData_t GetAnalogActionData( ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle ) = 0;
+
+	// Get the origin(s) for an analog action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action.
+	// originsOut should point to a STEAM_CONTROLLER_MAX_ORIGINS sized array of EControllerActionOrigin handles
+	virtual int GetAnalogActionOrigins( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, EControllerActionOrigin *originsOut ) = 0;
+	
+
+	
+	virtual void StopAnalogActionMomentum( ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction ) = 0;
+	
+	// Trigger a haptic pulse on a controller
+	virtual void TriggerHapticPulse( ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec ) = 0;
 };
-*/
-
-
-#pragma pack( pop )
 
+#define STEAMCONTROLLER_INTERFACE_VERSION "SteamController003"
 
 #endif // ISTEAMCONTROLLER_H

public/steam/isteamremotestorage.h

@@ -176,6 +176,12 @@ class ISteamRemoteStorage
 		// file operations
 		virtual bool	FileWrite( const char *pchFile, const void *pvData, int32 cubData ) = 0;
 		virtual int32	FileRead( const char *pchFile, void *pvData, int32 cubDataToRead ) = 0;
+		
+		virtual SteamAPICall_t FileWriteAsync( const char *pchFile, const void *pvData, uint32 cubData ) = 0;
+		
+		virtual SteamAPICall_t FileReadAsync( const char *pchFile, uint32 nOffset, uint32 cubToRead ) = 0;
+		virtual bool	FileReadAsyncComplete( SteamAPICall_t hReadCall, void *pvBuffer, uint32 cubToRead ) = 0;
+		
 		virtual bool	FileForget( const char *pchFile ) = 0;
 		virtual bool	FileDelete( const char *pchFile ) = 0;
 		virtual SteamAPICall_t FileShare( const char *pchFile ) = 0;
@@ -282,7 +288,7 @@ class ISteamRemoteStorage
 		virtual SteamAPICall_t UGCDownloadToLocation( UGCHandle_t hContent, const char *pchLocation, uint32 unPriority ) = 0;
 };
 
-#define STEAMREMOTESTORAGE_INTERFACE_VERSION "STEAMREMOTESTORAGE_INTERFACE_VERSION012"
+#define STEAMREMOTESTORAGE_INTERFACE_VERSION "STEAMREMOTESTORAGE_INTERFACE_VERSION013"
 
 
 // callbacks
@@ -642,7 +648,26 @@ struct RemoteStoragePublishedFileUpdated_t
 	UGCHandle_t m_hFile;					// The new content
 };
 
+//-----------------------------------------------------------------------------
+// Purpose: Called when a FileWriteAsync completes
+//-----------------------------------------------------------------------------
+struct RemoteStorageFileWriteAsyncComplete_t
+{
+	enum { k_iCallback = k_iClientRemoteStorageCallbacks + 31 };
+	EResult	m_eResult;						// result
+};
 
+//-----------------------------------------------------------------------------
+// Purpose: Called when a FileReadAsync completes
+//-----------------------------------------------------------------------------
+struct RemoteStorageFileReadAsyncComplete_t
+{
+	enum { k_iCallback = k_iClientRemoteStorageCallbacks + 32 };
+	SteamAPICall_t m_hFileReadAsync;		// call handle of the async read which was made
+	EResult	m_eResult;						// result
+	uint32 m_nOffset;						// offset in the file this read was at
+	uint32 m_cubRead;						// amount read - will the <= the amount requested
+};
 
 #pragma pack( pop )
 

public/steam/isteamugc.h

@@ -46,6 +46,7 @@ enum EUGCMatchingUGCType
 	k_EUGCMatchingUGCType_UsableInGame		 = 10,		// ready-to-use items and integrated guides
 	k_EUGCMatchingUGCType_ControllerBindings = 11,
 	k_EUGCMatchingUGCType_GameManagedItems	 = 12,		// game managed items (not managed by users)
+	k_EUGCMatchingUGCType_All				 = ~0,		// return everything
 };
 
 // Different lists of published UGC for a user.
@@ -263,6 +264,13 @@ public:
 	// then files on disk should not be used until callback received. If item is not subscribed to, it will be cached for some time.
 	// If bHighPriority is set, any other item download will be suspended and this item downloaded ASAP.
 	virtual bool DownloadItem( PublishedFileId_t nPublishedFileID, bool bHighPriority ) = 0;
+
+	// game servers can set a specific workshop folder before issuing any UGC commands.
+	// This is helpful if you want to support multiple game servers running out of the same install folder
+	virtual bool BInitWorkshopForGameServer( DepotId_t unWorkshopDepotID, const char *pszFolder ) = 0;
+
+	// SuspendDownloads( true ) will suspend all workshop downloads until SuspendDownloads( false ) is called or the game ends
+	virtual void SuspendDownloads( bool bSuspend ) = 0;
 };
 
 #define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION007"

public/steam/isteamuser.h

@@ -250,6 +250,7 @@ struct SteamServerConnectFailure_t
 {
 	enum { k_iCallback = k_iSteamUserCallbacks + 2 };
 	EResult m_eResult;
+	bool m_bStillRetrying;
 };
 
 

public/steam/steam_api.h

@@ -137,31 +137,56 @@ S_API ISteamPS3OverlayRender *S_CALLTYPE SteamPS3OverlayRender();
 #endif
 #endif // VERSION_SAFE_STEAM_API_INTERFACES
 
+
 //----------------------------------------------------------------------------------------------------------------------------------------------------------//
-//	steam callback helper functions
+//	steam callback and call-result helpers
 //
-//	The following classes/macros are used to be able to easily multiplex callbacks 
-//	from the Steam API into various objects in the app in a thread-safe manner
+//	The following macros and classes are used to register your application for
+//	callbacks and call-results, which are delivered in a predictable manner.
 //
-//	These functors are triggered via the SteamAPI_RunCallbacks() function, mapping the callback
-//  to as many functions/objects as are registered to it
+//	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();
 
 
 
-// functions used by the utility CCallback objects to receive callbacks
+// 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 );
-// functions used by the utility CCallResult objects to receive async call results
+// 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, 
-//			used only by CCallback, shouldn't be used directly
+// Purpose: base for callbacks and call results - internal implementation detail
 //-----------------------------------------------------------------------------
 class CCallbackBase
 {
@@ -178,6 +203,26 @@ protected:
 	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; }
 };
 
 
@@ -239,7 +284,7 @@ private:
 		m_hAPICall = k_uAPICallInvalid; // caller unregisters for us
 		(m_pObj->*m_Func)( (P *)pvParam, false );		
 	}
-	void Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall )
+	virtual void Run( void *pvParam, bool bIOFailure, SteamAPICall_t hSteamAPICall )
 	{
 		if ( hSteamAPICall == m_hAPICall )
 		{
@@ -247,7 +292,7 @@ private:
 			(m_pObj->*m_Func)( (P *)pvParam, bIOFailure );			
 		}
 	}
-	int GetCallbackSizeBytes()
+	virtual int GetCallbackSizeBytes()
 	{
 		return sizeof( P );
 	}
@@ -261,31 +306,24 @@ private:
 
 //-----------------------------------------------------------------------------
 // Purpose: maps a steam callback to a class member function
-//			template params: T = local class, P = parameter struct
+//			template params: T = local class, P = parameter struct,
+//			bGameserver = listen for gameserver callbacks instead of client callbacks
 //-----------------------------------------------------------------------------
-template< class T, class P, bool bGameServer >
-class CCallback : protected CCallbackBase
+template< class T, class P, bool bGameserver = false >
+class CCallback : public CCallbackImpl< sizeof( P ) >
 {
 public:
-	typedef void (T::*func_t)( P* );
+	typedef void (T::*func_t)(P*);
 
-	// If you can't support constructing a callback with the correct parameters
-	// then uncomment the empty constructor below and manually call
-	// ::Register() for your object
-	// Or, just call the regular constructor with (NULL, NULL)
-	// CCallback() {}
-	
-	// constructor for initializing this object in owner's constructor
-	CCallback( T *pObj, func_t func ) : m_pObj( pObj ), m_Func( func )
+	// 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 ( pObj && func )
-			Register( pObj, func );
-	}
-
-	~CCallback()
-	{
-		if ( m_nCallbackFlags & k_ECallbackFlagsRegistered )
-			Unregister();
+		if ( bGameserver )
+		{
+			this->SetGameserverFlag();
+		}
+		Register( pObj, func );
 	}
 
 	// manual registration of the callback
@@ -294,13 +332,9 @@ public:
 		if ( !pObj || !func )
 			return;
 
-		if ( m_nCallbackFlags & k_ECallbackFlagsRegistered )
+		if ( this->m_nCallbackFlags & CCallbackBase::k_ECallbackFlagsRegistered )
 			Unregister();
 
-		if ( bGameServer )
-		{
-			m_nCallbackFlags |= k_ECallbackFlagsGameServer;
-		}
 		m_pObj = pObj;
 		m_Func = func;
 		// SteamAPI_RegisterCallback sets k_ECallbackFlagsRegistered
@@ -313,38 +347,50 @@ public:
 		SteamAPI_UnregisterCallback( this );
 	}
 
-	void SetGameserverFlag() { m_nCallbackFlags |= k_ECallbackFlagsGameServer; }
 protected:
 	virtual void Run( void *pvParam )
 	{
 		(m_pObj->*m_Func)( (P *)pvParam );
 	}
-	virtual void Run( void *pvParam, bool, SteamAPICall_t )
-	{
-		(m_pObj->*m_Func)( (P *)pvParam );
-	}
-	int GetCallbackSizeBytes()
-	{
-		return sizeof( P );
-	}
 
 	T *m_pObj;
 	func_t m_Func;
 };
 
-// Allows you to defer registration of the callback
-template< class T, class P, bool bGameServer >
+
+//-----------------------------------------------------------------------------
+// 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
 };
 
-// utility macro for declaring the function and callback object together
-#define STEAM_CALLBACK( thisclass, func, param, var ) CCallback< thisclass, param, false > var; void func( param *pParam )
 
-// same as above, but lets you defer the callback binding by calling Register later
-#define STEAM_CALLBACK_MANUAL( thisclass, func, param, var ) CCallbackManual< thisclass, param, false > var; void func( param *pParam )
+
+//-----------------------------------------------------------------------------
+// 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

public/steam/steam_api.json

@@ -57,6 +57,10 @@
 ,{"typedef": "HTTPRequestHandle","type": "uint32"}
 ,{"typedef": "HTTPCookieContainerHandle","type": "uint32"}
 ,{"typedef": "ClientUnifiedMessageHandle","type": "uint64"}
+,{"typedef": "ControllerHandle_t","type": "uint64"}
+,{"typedef": "ControllerActionSetHandle_t","type": "uint64"}
+,{"typedef": "ControllerDigitalActionHandle_t","type": "uint64"}
+,{"typedef": "ControllerAnalogActionHandle_t","type": "uint64"}
 ,{"typedef": "UGCQueryHandle_t","type": "uint64"}
 ,{"typedef": "UGCUpdateHandle_t","type": "uint64"}
 ,{"typedef": "HHTMLBrowser","type": "uint32"}
@@ -175,6 +179,7 @@
 	,{"name": "k_EResultRefundToWallet","value": "98"}
 	,{"name": "k_EResultEmailSendFailure","value": "99"}
 	,{"name": "k_EResultNotSettled","value": "100"}
+	,{"name": "k_EResultNeedCaptcha","value": "101"}
 ]}
 ,	{"enumname": "EVoiceResult","values": [ 
 	{"name": "k_EVoiceResultOK","value": "0"}
@@ -269,6 +274,7 @@
 	,{"name": "k_EAppOwnershipFlags_LicenseRecurring","value": "4096"}
 	,{"name": "k_EAppOwnershipFlags_LicenseCanceled","value": "8192"}
 	,{"name": "k_EAppOwnershipFlags_AutoGrant","value": "16384"}
+	,{"name": "k_EAppOwnershipFlags_PendingGift","value": "32768"}
 ]}
 ,	{"enumname": "EAppType","values": [ 
 	{"name": "k_EAppType_Invalid","value": "0"}
@@ -360,6 +366,23 @@
 	,{"name": "k_EBroadcastUploadResultSettingsChanged","value": "10"}
 	,{"name": "k_EBroadcastUploadResultMissingAudio","value": "11"}
 	,{"name": "k_EBroadcastUploadResultTooFarBehind","value": "12"}
+	,{"name": "k_EBroadcastUploadResultTranscodeBehind","value": "13"}
+]}
+,	{"enumname": "ELaunchOptionType","values": [ 
+	{"name": "k_ELaunchOptionType_None","value": "0"}
+	,{"name": "k_ELaunchOptionType_Default","value": "1"}
+	,{"name": "k_ELaunchOptionType_SafeMode","value": "2"}
+	,{"name": "k_ELaunchOptionType_Multiplayer","value": "3"}
+	,{"name": "k_ELaunchOptionType_Config","value": "4"}
+	,{"name": "k_ELaunchOptionType_VR","value": "5"}
+	,{"name": "k_ELaunchOptionType_Server","value": "6"}
+	,{"name": "k_ELaunchOptionType_Editor","value": "7"}
+	,{"name": "k_ELaunchOptionType_Manual","value": "8"}
+	,{"name": "k_ELaunchOptionType_Benchmark","value": "9"}
+	,{"name": "k_ELaunchOptionType_Option1","value": "10"}
+	,{"name": "k_ELaunchOptionType_Option2","value": "11"}
+	,{"name": "k_ELaunchOptionType_Option3","value": "12"}
+	,{"name": "k_ELaunchOptionType_Dialog","value": "1000"}
 ]}
 ,	{"enumname": "CGameID::EGameIDType","values": [ 
 	{"name": "k_EGameIDTypeApp","value": "0"}
@@ -683,6 +706,72 @@
 	{"name": "k_ESteamControllerPad_Left","value": "0"}
 	,{"name": "k_ESteamControllerPad_Right","value": "1"}
 ]}
+,	{"enumname": "EControllerSource","values": [ 
+	{"name": "k_EControllerSource_None","value": "0"}
+	,{"name": "k_EControllerSource_LeftTrackpad","value": "1"}
+	,{"name": "k_EControllerSource_RightTrackpad","value": "2"}
+	,{"name": "k_EControllerSource_Joystick","value": "3"}
+	,{"name": "k_EControllerSource_ABXY","value": "4"}
+	,{"name": "k_EControllerSource_Switch","value": "5"}
+	,{"name": "k_EControllerSource_LeftTrigger","value": "6"}
+	,{"name": "k_EControllerSource_RightTrigger","value": "7"}
+	,{"name": "k_EControllerSource_Gyro","value": "8"}
+]}
+,	{"enumname": "EControllerSourceMode","values": [ 
+	{"name": "k_EControllerSourceMode_None","value": "0"}
+	,{"name": "k_EControllerSourceMode_Dpad","value": "1"}
+	,{"name": "k_EControllerSourceMode_Buttons","value": "2"}
+	,{"name": "k_EControllerSourceMode_FourButtons","value": "3"}
+	,{"name": "k_EControllerSourceMode_AbsoluteMouse","value": "4"}
+	,{"name": "k_EControllerSourceMode_RelativeMouse","value": "5"}
+	,{"name": "k_EControllerSourceMode_JoystickMove","value": "6"}
+	,{"name": "k_EControllerSourceMode_JoystickCamera","value": "7"}
+	,{"name": "k_EControllerSourceMode_ScrollWheel","value": "8"}
+	,{"name": "k_EControllerSourceMode_Trigger","value": "9"}
+	,{"name": "k_EControllerSourceMode_TouchMenu","value": "10"}
+]}
+,	{"enumname": "EControllerActionOrigin","values": [ 
+	{"name": "k_EControllerActionOrigin_None","value": "0"}
+	,{"name": "k_EControllerActionOrigin_A","value": "1"}
+	,{"name": "k_EControllerActionOrigin_B","value": "2"}
+	,{"name": "k_EControllerActionOrigin_X","value": "3"}
+	,{"name": "k_EControllerActionOrigin_Y","value": "4"}
+	,{"name": "k_EControllerActionOrigin_LeftBumper","value": "5"}
+	,{"name": "k_EControllerActionOrigin_RightBumper","value": "6"}
+	,{"name": "k_EControllerActionOrigin_LeftGrip","value": "7"}
+	,{"name": "k_EControllerActionOrigin_RightGrip","value": "8"}
+	,{"name": "k_EControllerActionOrigin_Start","value": "9"}
+	,{"name": "k_EControllerActionOrigin_Back","value": "10"}
+	,{"name": "k_EControllerActionOrigin_LeftPad_Touch","value": "11"}
+	,{"name": "k_EControllerActionOrigin_LeftPad_Swipe","value": "12"}
+	,{"name": "k_EControllerActionOrigin_LeftPad_Click","value": "13"}
+	,{"name": "k_EControllerActionOrigin_LeftPad_DPadNorth","value": "14"}
+	,{"name": "k_EControllerActionOrigin_LeftPad_DPadSouth","value": "15"}
+	,{"name": "k_EControllerActionOrigin_LeftPad_DPadWest","value": "16"}
+	,{"name": "k_EControllerActionOrigin_LeftPad_DPadEast","value": "17"}
+	,{"name": "k_EControllerActionOrigin_RightPad_Touch","value": "18"}
+	,{"name": "k_EControllerActionOrigin_RightPad_Swipe","value": "19"}
+	,{"name": "k_EControllerActionOrigin_RightPad_Click","value": "20"}
+	,{"name": "k_EControllerActionOrigin_RightPad_DPadNorth","value": "21"}
+	,{"name": "k_EControllerActionOrigin_RightPad_DPadSouth","value": "22"}
+	,{"name": "k_EControllerActionOrigin_RightPad_DPadWest","value": "23"}
+	,{"name": "k_EControllerActionOrigin_RightPad_DPadEast","value": "24"}
+	,{"name": "k_EControllerActionOrigin_LeftTrigger_Pull","value": "25"}
+	,{"name": "k_EControllerActionOrigin_LeftTrigger_Click","value": "26"}
+	,{"name": "k_EControllerActionOrigin_RightTrigger_Pull","value": "27"}
+	,{"name": "k_EControllerActionOrigin_RightTrigger_Click","value": "28"}
+	,{"name": "k_EControllerActionOrigin_LeftStick_Move","value": "29"}
+	,{"name": "k_EControllerActionOrigin_LeftStick_Click","value": "30"}
+	,{"name": "k_EControllerActionOrigin_LeftStick_DPadNorth","value": "31"}
+	,{"name": "k_EControllerActionOrigin_LeftStick_DPadSouth","value": "32"}
+	,{"name": "k_EControllerActionOrigin_LeftStick_DPadWest","value": "33"}
+	,{"name": "k_EControllerActionOrigin_LeftStick_DPadEast","value": "34"}
+	,{"name": "k_EControllerActionOrigin_Gyro_Move","value": "35"}
+	,{"name": "k_EControllerActionOrigin_Gyro_Pitch","value": "36"}
+	,{"name": "k_EControllerActionOrigin_Gyro_Yaw","value": "37"}
+	,{"name": "k_EControllerActionOrigin_Gyro_Roll","value": "38"}
+	,{"name": "k_EControllerActionOrigin_Count","value": "39"}
+]}
 ,	{"enumname": "EUGCMatchingUGCType","values": [ 
 	{"name": "k_EUGCMatchingUGCType_Items","value": "0"}
 	,{"name": "k_EUGCMatchingUGCType_Items_Mtx","value": "1"}
@@ -697,6 +786,7 @@
 	,{"name": "k_EUGCMatchingUGCType_UsableInGame","value": "10"}
 	,{"name": "k_EUGCMatchingUGCType_ControllerBindings","value": "11"}
 	,{"name": "k_EUGCMatchingUGCType_GameManagedItems","value": "12"}
+	,{"name": "k_EUGCMatchingUGCType_All","value": "-1"}
 ]}
 ,	{"enumname": "EUserUGCList","values": [ 
 	{"name": "k_EUserUGCList_Published","value": "0"}
@@ -966,7 +1056,8 @@
 { "fieldname": "m_pubParam", "fieldtype": "uint8 *"},
 { "fieldname": "m_cubParam", "fieldtype": "int"}]}
 ,{"struct": "SteamServerConnectFailure_t","fields": [
-{ "fieldname": "m_eResult", "fieldtype": "enum EResult"}]}
+{ "fieldname": "m_eResult", "fieldtype": "enum EResult"},
+{ "fieldname": "m_bStillRetrying", "fieldtype": "_Bool"}]}
 ,{"struct": "SteamServersDisconnected_t","fields": [
 { "fieldname": "m_eResult", "fieldtype": "enum EResult"}]}
 ,{"struct": "ClientGameServerDeny_t","fields": [
@@ -1287,6 +1378,13 @@
 { "fieldname": "m_nPublishedFileId", "fieldtype": "PublishedFileId_t"},
 { "fieldname": "m_nAppID", "fieldtype": "AppId_t"},
 { "fieldname": "m_hFile", "fieldtype": "UGCHandle_t"}]}
+,{"struct": "RemoteStorageFileWriteAsyncComplete_t","fields": [
+{ "fieldname": "m_eResult", "fieldtype": "enum EResult"}]}
+,{"struct": "RemoteStorageFileReadAsyncComplete_t","fields": [
+{ "fieldname": "m_hFileReadAsync", "fieldtype": "SteamAPICall_t"},
+{ "fieldname": "m_eResult", "fieldtype": "enum EResult"},
+{ "fieldname": "m_nOffset", "fieldtype": "uint32"},
+{ "fieldname": "m_cubRead", "fieldtype": "uint32"}]}
 ,{"struct": "LeaderboardEntry_t","fields": [
 { "fieldname": "m_steamIDUser", "fieldtype": "class CSteamID"},
 { "fieldname": "m_nGlobalRank", "fieldtype": "int32"},
@@ -1407,13 +1505,14 @@
 { "fieldname": "m_unContext", "fieldtype": "uint64"},
 { "fieldname": "m_eResult", "fieldtype": "enum EResult"},
 { "fieldname": "m_unResponseSize", "fieldtype": "uint32"}]}
-,{"struct": "SteamControllerState001_t","fields": [
-{ "fieldname": "unPacketNum", "fieldtype": "uint32"},
-{ "fieldname": "ulButtons", "fieldtype": "uint64"},
-{ "fieldname": "sLeftPadX", "fieldtype": "short"},
-{ "fieldname": "sLeftPadY", "fieldtype": "short"},
-{ "fieldname": "sRightPadX", "fieldtype": "short"},
-{ "fieldname": "sRightPadY", "fieldtype": "short"}]}
+,{"struct": "ControllerAnalogActionData_t","fields": [
+{ "fieldname": "eMode", "fieldtype": "enum EControllerSourceMode"},
+{ "fieldname": "x", "fieldtype": "float"},
+{ "fieldname": "y", "fieldtype": "float"},
+{ "fieldname": "bActive", "fieldtype": "_Bool"}]}
+,{"struct": "ControllerDigitalActionData_t","fields": [
+{ "fieldname": "bState", "fieldtype": "_Bool"},
+{ "fieldname": "bActive", "fieldtype": "_Bool"}]}
 ,{"struct": "SteamUGCDetails_t","fields": [
 { "fieldname": "m_nPublishedFileId", "fieldtype": "PublishedFileId_t"},
 { "fieldname": "m_eResult", "fieldtype": "enum EResult"},
@@ -3579,6 +3678,36 @@
 {	"paramname": "cubDataToRead" ,"paramtype": "int32"}
 	 ]
 }
+,{
+	"classname": "ISteamRemoteStorage",
+	"methodname": "FileWriteAsync",
+	"returntype": "SteamAPICall_t",
+	"params": [ 
+{	"paramname": "pchFile" ,"paramtype": "const char *"},
+{	"paramname": "pvData" ,"paramtype": "const void *"},
+{	"paramname": "cubData" ,"paramtype": "uint32"}
+	 ]
+}
+,{
+	"classname": "ISteamRemoteStorage",
+	"methodname": "FileReadAsync",
+	"returntype": "SteamAPICall_t",
+	"params": [ 
+{	"paramname": "pchFile" ,"paramtype": "const char *"},
+{	"paramname": "nOffset" ,"paramtype": "uint32"},
+{	"paramname": "cubToRead" ,"paramtype": "uint32"}
+	 ]
+}
+,{
+	"classname": "ISteamRemoteStorage",
+	"methodname": "FileReadAsyncComplete",
+	"returntype": "bool",
+	"params": [ 
+{	"paramname": "hReadCall" ,"paramtype": "SteamAPICall_t"},
+{	"paramname": "pvBuffer" ,"paramtype": "void *"},
+{	"paramname": "cubToRead" ,"paramtype": "uint32"}
+	 ]
+}
 ,{
 	"classname": "ISteamRemoteStorage",
 	"methodname": "FileForget",
@@ -5415,10 +5544,7 @@
 ,{
 	"classname": "ISteamController",
 	"methodname": "Init",
-	"returntype": "bool",
-	"params": [ 
-{	"paramname": "pchAbsolutePathToControllerConfigVDF" ,"paramtype": "const char *"}
-	 ]
+	"returntype": "bool"
 }
 ,{
 	"classname": "ISteamController",
@@ -5432,11 +5558,108 @@
 }
 ,{
 	"classname": "ISteamController",
-	"methodname": "GetControllerState",
+	"methodname": "GetConnectedControllers",
+	"returntype": "int",
+	"params": [ 
+{	"paramname": "handlesOut" ,"paramtype": "ControllerHandle_t *"}
+	 ]
+}
+,{
+	"classname": "ISteamController",
+	"methodname": "ShowBindingPanel",
 	"returntype": "bool",
 	"params": [ 
-{	"paramname": "unControllerIndex" ,"paramtype": "uint32"},
-{	"paramname": "pState" ,"paramtype": "struct SteamControllerState001_t *"}
+{	"paramname": "controllerHandle" ,"paramtype": "ControllerHandle_t"}
+	 ]
+}
+,{
+	"classname": "ISteamController",
+	"methodname": "GetActionSetHandle",
+	"returntype": "ControllerActionSetHandle_t",
+	"params": [ 
+{	"paramname": "pszActionSetName" ,"paramtype": "const char *"}
+	 ]
+}
+,{
+	"classname": "ISteamController",
+	"methodname": "ActivateActionSet",
+	"returntype": "void",
+	"params": [ 
+{	"paramname": "controllerHandle" ,"paramtype": "ControllerHandle_t"},
+{	"paramname": "actionSetHandle" ,"paramtype": "ControllerActionSetHandle_t"}
+	 ]
+}
+,{
+	"classname": "ISteamController",
+	"methodname": "GetCurrentActionSet",
+	"returntype": "ControllerActionSetHandle_t",
+	"params": [ 
+{	"paramname": "controllerHandle" ,"paramtype": "ControllerHandle_t"}
+	 ]
+}
+,{
+	"classname": "ISteamController",
+	"methodname": "GetDigitalActionHandle",
+	"returntype": "ControllerDigitalActionHandle_t",
+	"params": [ 
+{	"paramname": "pszActionName" ,"paramtype": "const char *"}
+	 ]
+}
+,{
+	"classname": "ISteamController",
+	"methodname": "GetDigitalActionData",
+	"returntype": "struct ControllerDigitalActionData_t",
+	"params": [ 
+{	"paramname": "controllerHandle" ,"paramtype": "ControllerHandle_t"},
+{	"paramname": "digitalActionHandle" ,"paramtype": "ControllerDigitalActionHandle_t"}
+	 ]
+}
+,{
+	"classname": "ISteamController",
+	"methodname": "GetDigitalActionOrigins",
+	"returntype": "int",
+	"params": [ 
+{	"paramname": "controllerHandle" ,"paramtype": "ControllerHandle_t"},
+{	"paramname": "actionSetHandle" ,"paramtype": "ControllerActionSetHandle_t"},
+{	"paramname": "digitalActionHandle" ,"paramtype": "ControllerDigitalActionHandle_t"},
+{	"paramname": "originsOut" ,"paramtype": "EControllerActionOrigin *"}
+	 ]
+}
+,{
+	"classname": "ISteamController",
+	"methodname": "GetAnalogActionHandle",
+	"returntype": "ControllerAnalogActionHandle_t",
+	"params": [ 
+{	"paramname": "pszActionName" ,"paramtype": "const char *"}
+	 ]
+}
+,{
+	"classname": "ISteamController",
+	"methodname": "GetAnalogActionData",
+	"returntype": "struct ControllerAnalogActionData_t",
+	"params": [ 
+{	"paramname": "controllerHandle" ,"paramtype": "ControllerHandle_t"},
+{	"paramname": "analogActionHandle" ,"paramtype": "ControllerAnalogActionHandle_t"}
+	 ]
+}
+,{
+	"classname": "ISteamController",
+	"methodname": "GetAnalogActionOrigins",
+	"returntype": "int",
+	"params": [ 
+{	"paramname": "controllerHandle" ,"paramtype": "ControllerHandle_t"},
+{	"paramname": "actionSetHandle" ,"paramtype": "ControllerActionSetHandle_t"},
+{	"paramname": "analogActionHandle" ,"paramtype": "ControllerAnalogActionHandle_t"},
+{	"paramname": "originsOut" ,"paramtype": "EControllerActionOrigin *"}
+	 ]
+}
+,{
+	"classname": "ISteamController",
+	"methodname": "StopAnalogActionMomentum",
+	"returntype": "void",
+	"params": [ 
+{	"paramname": "controllerHandle" ,"paramtype": "ControllerHandle_t"},
+{	"paramname": "eAction" ,"paramtype": "ControllerAnalogActionHandle_t"}
 	 ]
 }
 ,{
@@ -5444,19 +5667,11 @@
 	"methodname": "TriggerHapticPulse",
 	"returntype": "void",
 	"params": [ 
-{	"paramname": "unControllerIndex" ,"paramtype": "uint32"},
+{	"paramname": "controllerHandle" ,"paramtype": "ControllerHandle_t"},
 {	"paramname": "eTargetPad" ,"paramtype": "ESteamControllerPad"},
 {	"paramname": "usDurationMicroSec" ,"paramtype": "unsigned short"}
 	 ]
 }
-,{
-	"classname": "ISteamController",
-	"methodname": "SetOverrideMode",
-	"returntype": "void",
-	"params": [ 
-{	"paramname": "pchMode" ,"paramtype": "const char *"}
-	 ]
-}
 ,{
 	"classname": "ISteamUGC",
 	"methodname": "CreateQueryUserUGCRequest",
@@ -5984,6 +6199,23 @@
 {	"paramname": "bHighPriority" ,"paramtype": "bool"}
 	 ]
 }
+,{
+	"classname": "ISteamUGC",
+	"methodname": "BInitWorkshopForGameServer",
+	"returntype": "bool",
+	"params": [ 
+{	"paramname": "unWorkshopDepotID" ,"paramtype": "DepotId_t"},
+{	"paramname": "pszFolder" ,"paramtype": "const char *"}
+	 ]
+}
+,{
+	"classname": "ISteamUGC",
+	"methodname": "SuspendDownloads",
+	"returntype": "void",
+	"params": [ 
+{	"paramname": "bSuspend" ,"paramtype": "bool"}
+	 ]
+}
 ,{
 	"classname": "ISteamAppList",
 	"methodname": "GetNumInstalledApps",

public/steam/steam_api_flat.h

@@ -239,6 +239,9 @@ S_API HServerQuery SteamAPI_ISteamMatchmakingServers_ServerRules(intptr_t instan
 S_API void SteamAPI_ISteamMatchmakingServers_CancelServerQuery(intptr_t instancePtr, HServerQuery hServerQuery);
 S_API bool SteamAPI_ISteamRemoteStorage_FileWrite(intptr_t instancePtr, const char * pchFile, const void * pvData, int32 cubData);
 S_API int32 SteamAPI_ISteamRemoteStorage_FileRead(intptr_t instancePtr, const char * pchFile, void * pvData, int32 cubDataToRead);
+S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_FileWriteAsync(intptr_t instancePtr, const char * pchFile, const void * pvData, uint32 cubData);
+S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_FileReadAsync(intptr_t instancePtr, const char * pchFile, uint32 nOffset, uint32 cubToRead);
+S_API bool SteamAPI_ISteamRemoteStorage_FileReadAsyncComplete(intptr_t instancePtr, SteamAPICall_t hReadCall, void * pvBuffer, uint32 cubToRead);
 S_API bool SteamAPI_ISteamRemoteStorage_FileForget(intptr_t instancePtr, const char * pchFile);
 S_API bool SteamAPI_ISteamRemoteStorage_FileDelete(intptr_t instancePtr, const char * pchFile);
 S_API SteamAPICall_t SteamAPI_ISteamRemoteStorage_FileShare(intptr_t instancePtr, const char * pchFile);
@@ -456,12 +459,22 @@ S_API bool SteamAPI_ISteamUnifiedMessages_GetMethodResponseInfo(intptr_t instanc
 S_API bool SteamAPI_ISteamUnifiedMessages_GetMethodResponseData(intptr_t instancePtr, ClientUnifiedMessageHandle hHandle, void * pResponseBuffer, uint32 unResponseBufferSize, bool bAutoRelease);
 S_API bool SteamAPI_ISteamUnifiedMessages_ReleaseMethod(intptr_t instancePtr, ClientUnifiedMessageHandle hHandle);
 S_API bool SteamAPI_ISteamUnifiedMessages_SendNotification(intptr_t instancePtr, const char * pchServiceNotification, const void * pNotificationBuffer, uint32 unNotificationBufferSize);
-S_API bool SteamAPI_ISteamController_Init(intptr_t instancePtr, const char * pchAbsolutePathToControllerConfigVDF);
+S_API bool SteamAPI_ISteamController_Init(intptr_t instancePtr);
 S_API bool SteamAPI_ISteamController_Shutdown(intptr_t instancePtr);
 S_API void SteamAPI_ISteamController_RunFrame(intptr_t instancePtr);
-S_API bool SteamAPI_ISteamController_GetControllerState(intptr_t instancePtr, uint32 unControllerIndex, struct SteamControllerState001_t * pState);
-S_API void SteamAPI_ISteamController_TriggerHapticPulse(intptr_t instancePtr, uint32 unControllerIndex, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec);
-S_API void SteamAPI_ISteamController_SetOverrideMode(intptr_t instancePtr, const char * pchMode);
+S_API int SteamAPI_ISteamController_GetConnectedControllers(intptr_t instancePtr, ControllerHandle_t * handlesOut);
+S_API bool SteamAPI_ISteamController_ShowBindingPanel(intptr_t instancePtr, ControllerHandle_t controllerHandle);
+S_API ControllerActionSetHandle_t SteamAPI_ISteamController_GetActionSetHandle(intptr_t instancePtr, const char * pszActionSetName);
+S_API void SteamAPI_ISteamController_ActivateActionSet(intptr_t instancePtr, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle);
+S_API ControllerActionSetHandle_t SteamAPI_ISteamController_GetCurrentActionSet(intptr_t instancePtr, ControllerHandle_t controllerHandle);
+S_API ControllerDigitalActionHandle_t SteamAPI_ISteamController_GetDigitalActionHandle(intptr_t instancePtr, const char * pszActionName);
+S_API struct ControllerDigitalActionData_t SteamAPI_ISteamController_GetDigitalActionData(intptr_t instancePtr, ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle);
+S_API int SteamAPI_ISteamController_GetDigitalActionOrigins(intptr_t instancePtr, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, EControllerActionOrigin * originsOut);
+S_API ControllerAnalogActionHandle_t SteamAPI_ISteamController_GetAnalogActionHandle(intptr_t instancePtr, const char * pszActionName);
+S_API struct ControllerAnalogActionData_t SteamAPI_ISteamController_GetAnalogActionData(intptr_t instancePtr, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle);
+S_API int SteamAPI_ISteamController_GetAnalogActionOrigins(intptr_t instancePtr, ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, EControllerActionOrigin * originsOut);
+S_API void SteamAPI_ISteamController_StopAnalogActionMomentum(intptr_t instancePtr, ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction);
+S_API void SteamAPI_ISteamController_TriggerHapticPulse(intptr_t instancePtr, ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec);
 S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryUserUGCRequest(intptr_t instancePtr, AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage);
 S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequest(intptr_t instancePtr, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage);
 S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryUGCDetailsRequest(intptr_t instancePtr, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs);
@@ -518,6 +531,8 @@ S_API uint32 SteamAPI_ISteamUGC_GetItemState(intptr_t instancePtr, PublishedFile
 S_API bool SteamAPI_ISteamUGC_GetItemInstallInfo(intptr_t instancePtr, PublishedFileId_t nPublishedFileID, uint64 * punSizeOnDisk, char * pchFolder, uint32 cchFolderSize, uint32 * punTimeStamp);
 S_API bool SteamAPI_ISteamUGC_GetItemDownloadInfo(intptr_t instancePtr, PublishedFileId_t nPublishedFileID, uint64 * punBytesDownloaded, uint64 * punBytesTotal);
 S_API bool SteamAPI_ISteamUGC_DownloadItem(intptr_t instancePtr, PublishedFileId_t nPublishedFileID, bool bHighPriority);
+S_API bool SteamAPI_ISteamUGC_BInitWorkshopForGameServer(intptr_t instancePtr, DepotId_t unWorkshopDepotID, const char * pszFolder);
+S_API void SteamAPI_ISteamUGC_SuspendDownloads(intptr_t instancePtr, bool bSuspend);
 S_API uint32 SteamAPI_ISteamAppList_GetNumInstalledApps(intptr_t instancePtr);
 S_API uint32 SteamAPI_ISteamAppList_GetInstalledApps(intptr_t instancePtr, AppId_t * pvecAppID, uint32 unMaxAppIDs);
 S_API int SteamAPI_ISteamAppList_GetAppName(intptr_t instancePtr, AppId_t nAppID, char * pchName, int cchNameMax);

public/steam/steam_api_interop.cs

@@ -468,6 +468,12 @@ internal static extern void SteamAPI_ISteamMatchmakingServers_CancelServerQuery(
 internal static extern bool SteamAPI_ISteamRemoteStorage_FileWrite(IntPtr instancePtr, string pchFile, IntPtr pvData, int cubData);
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamRemoteStorage_FileRead")]
 internal static extern int SteamAPI_ISteamRemoteStorage_FileRead(IntPtr instancePtr, string pchFile, IntPtr pvData, int cubDataToRead);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamRemoteStorage_FileWriteAsync")]
+internal static extern ulong SteamAPI_ISteamRemoteStorage_FileWriteAsync(IntPtr instancePtr, string pchFile, IntPtr pvData, uint cubData);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamRemoteStorage_FileReadAsync")]
+internal static extern ulong SteamAPI_ISteamRemoteStorage_FileReadAsync(IntPtr instancePtr, string pchFile, uint nOffset, uint cubToRead);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamRemoteStorage_FileReadAsyncComplete")]
+internal static extern bool SteamAPI_ISteamRemoteStorage_FileReadAsyncComplete(IntPtr instancePtr, ulong hReadCall, IntPtr pvBuffer, uint cubToRead);
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamRemoteStorage_FileForget")]
 internal static extern bool SteamAPI_ISteamRemoteStorage_FileForget(IntPtr instancePtr, string pchFile);
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamRemoteStorage_FileDelete")]
@@ -903,17 +909,37 @@ internal static extern bool SteamAPI_ISteamUnifiedMessages_ReleaseMethod(IntPtr
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamUnifiedMessages_SendNotification")]
 internal static extern bool SteamAPI_ISteamUnifiedMessages_SendNotification(IntPtr instancePtr, string pchServiceNotification, IntPtr pNotificationBuffer, uint unNotificationBufferSize);
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_Init")]
-internal static extern bool SteamAPI_ISteamController_Init(IntPtr instancePtr, string pchAbsolutePathToControllerConfigVDF);
+internal static extern bool SteamAPI_ISteamController_Init(IntPtr instancePtr);
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_Shutdown")]
 internal static extern bool SteamAPI_ISteamController_Shutdown(IntPtr instancePtr);
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_RunFrame")]
 internal static extern void SteamAPI_ISteamController_RunFrame(IntPtr instancePtr);
-[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_GetControllerState")]
-internal static extern bool SteamAPI_ISteamController_GetControllerState(IntPtr instancePtr, uint unControllerIndex, ref SteamControllerState001_t pState);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_GetConnectedControllers")]
+internal static extern int SteamAPI_ISteamController_GetConnectedControllers(IntPtr instancePtr, ref ulong handlesOut);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_ShowBindingPanel")]
+internal static extern bool SteamAPI_ISteamController_ShowBindingPanel(IntPtr instancePtr, ulong controllerHandle);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_GetActionSetHandle")]
+internal static extern ulong SteamAPI_ISteamController_GetActionSetHandle(IntPtr instancePtr, string pszActionSetName);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_ActivateActionSet")]
+internal static extern void SteamAPI_ISteamController_ActivateActionSet(IntPtr instancePtr, ulong controllerHandle, ulong actionSetHandle);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_GetCurrentActionSet")]
+internal static extern ulong SteamAPI_ISteamController_GetCurrentActionSet(IntPtr instancePtr, ulong controllerHandle);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_GetDigitalActionHandle")]
+internal static extern ulong SteamAPI_ISteamController_GetDigitalActionHandle(IntPtr instancePtr, string pszActionName);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_GetDigitalActionData")]
+internal static extern ControllerDigitalActionData_t SteamAPI_ISteamController_GetDigitalActionData(IntPtr instancePtr, ulong controllerHandle, ulong digitalActionHandle);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_GetDigitalActionOrigins")]
+internal static extern int SteamAPI_ISteamController_GetDigitalActionOrigins(IntPtr instancePtr, ulong controllerHandle, ulong actionSetHandle, ulong digitalActionHandle, ref uint originsOut);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_GetAnalogActionHandle")]
+internal static extern ulong SteamAPI_ISteamController_GetAnalogActionHandle(IntPtr instancePtr, string pszActionName);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_GetAnalogActionData")]
+internal static extern ControllerAnalogActionData_t SteamAPI_ISteamController_GetAnalogActionData(IntPtr instancePtr, ulong controllerHandle, ulong analogActionHandle);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_GetAnalogActionOrigins")]
+internal static extern int SteamAPI_ISteamController_GetAnalogActionOrigins(IntPtr instancePtr, ulong controllerHandle, ulong actionSetHandle, ulong analogActionHandle, ref uint originsOut);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_StopAnalogActionMomentum")]
+internal static extern void SteamAPI_ISteamController_StopAnalogActionMomentum(IntPtr instancePtr, ulong controllerHandle, ulong eAction);
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_TriggerHapticPulse")]
-internal static extern void SteamAPI_ISteamController_TriggerHapticPulse(IntPtr instancePtr, uint unControllerIndex, uint eTargetPad, char usDurationMicroSec);
-[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamController_SetOverrideMode")]
-internal static extern void SteamAPI_ISteamController_SetOverrideMode(IntPtr instancePtr, string pchMode);
+internal static extern void SteamAPI_ISteamController_TriggerHapticPulse(IntPtr instancePtr, ulong controllerHandle, uint eTargetPad, char usDurationMicroSec);
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamUGC_CreateQueryUserUGCRequest")]
 internal static extern ulong SteamAPI_ISteamUGC_CreateQueryUserUGCRequest(IntPtr instancePtr, uint unAccountID, uint eListType, uint eMatchingUGCType, uint eSortOrder, uint nCreatorAppID, uint nConsumerAppID, uint unPage);
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamUGC_CreateQueryAllUGCRequest")]
@@ -1026,6 +1052,10 @@ internal static extern bool SteamAPI_ISteamUGC_GetItemInstallInfo(IntPtr instanc
 internal static extern bool SteamAPI_ISteamUGC_GetItemDownloadInfo(IntPtr instancePtr, ulong nPublishedFileID, ref ulong punBytesDownloaded, ref ulong punBytesTotal);
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamUGC_DownloadItem")]
 internal static extern bool SteamAPI_ISteamUGC_DownloadItem(IntPtr instancePtr, ulong nPublishedFileID, bool bHighPriority);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamUGC_BInitWorkshopForGameServer")]
+internal static extern bool SteamAPI_ISteamUGC_BInitWorkshopForGameServer(IntPtr instancePtr, uint unWorkshopDepotID, string pszFolder);
+[DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamUGC_SuspendDownloads")]
+internal static extern void SteamAPI_ISteamUGC_SuspendDownloads(IntPtr instancePtr, bool bSuspend);
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamAppList_GetNumInstalledApps")]
 internal static extern uint SteamAPI_ISteamAppList_GetNumInstalledApps(IntPtr instancePtr);
 [DllImportAttribute("Steam_api", EntryPoint = "SteamAPI_ISteamAppList_GetInstalledApps")]
@@ -1560,6 +1590,9 @@ namespace Valve.Steamworks
 		public abstract IntPtr GetIntPtr();
 		public abstract bool FileWrite(string pchFile,IntPtr pvData,int cubData);
 		public abstract int FileRead(string pchFile,IntPtr pvData,int cubDataToRead);
+		public abstract ulong FileWriteAsync(string pchFile,IntPtr pvData,uint cubData);
+		public abstract ulong FileReadAsync(string pchFile,uint nOffset,uint cubToRead);
+		public abstract bool FileReadAsyncComplete(ulong hReadCall,IntPtr pvBuffer,uint cubToRead);
 		public abstract bool FileForget(string pchFile);
 		public abstract bool FileDelete(string pchFile);
 		public abstract ulong FileShare(string pchFile);
@@ -1831,12 +1864,22 @@ namespace Valve.Steamworks
 	public abstract class ISteamController
 	{
 		public abstract IntPtr GetIntPtr();
-		public abstract bool Init(string pchAbsolutePathToControllerConfigVDF);
+		public abstract bool Init();
 		public abstract bool Shutdown();
 		public abstract void RunFrame();
-		public abstract bool GetControllerState(uint unControllerIndex,ref SteamControllerState001_t pState);
-		public abstract void TriggerHapticPulse(uint unControllerIndex,uint eTargetPad,char usDurationMicroSec);
-		public abstract void SetOverrideMode(string pchMode);
+		public abstract int GetConnectedControllers(ref ulong handlesOut);
+		public abstract bool ShowBindingPanel(ulong controllerHandle);
+		public abstract ulong GetActionSetHandle(string pszActionSetName);
+		public abstract void ActivateActionSet(ulong controllerHandle,ulong actionSetHandle);
+		public abstract ulong GetCurrentActionSet(ulong controllerHandle);
+		public abstract ulong GetDigitalActionHandle(string pszActionName);
+		public abstract ControllerDigitalActionData_t GetDigitalActionData(ulong controllerHandle,ulong digitalActionHandle);
+		public abstract int GetDigitalActionOrigins(ulong controllerHandle,ulong actionSetHandle,ulong digitalActionHandle,ref uint originsOut);
+		public abstract ulong GetAnalogActionHandle(string pszActionName);
+		public abstract ControllerAnalogActionData_t GetAnalogActionData(ulong controllerHandle,ulong analogActionHandle);
+		public abstract int GetAnalogActionOrigins(ulong controllerHandle,ulong actionSetHandle,ulong analogActionHandle,ref uint originsOut);
+		public abstract void StopAnalogActionMomentum(ulong controllerHandle,ulong eAction);
+		public abstract void TriggerHapticPulse(ulong controllerHandle,uint eTargetPad,char usDurationMicroSec);
 	}
 
 
@@ -1899,6 +1942,8 @@ namespace Valve.Steamworks
 		public abstract bool GetItemInstallInfo(ulong nPublishedFileID,ref ulong punSizeOnDisk,string pchFolder,uint cchFolderSize,ref uint punTimeStamp);
 		public abstract bool GetItemDownloadInfo(ulong nPublishedFileID,ref ulong punBytesDownloaded,ref ulong punBytesTotal);
 		public abstract bool DownloadItem(ulong nPublishedFileID,bool bHighPriority);
+		public abstract bool BInitWorkshopForGameServer(uint unWorkshopDepotID,string pszFolder);
+		public abstract void SuspendDownloads(bool bSuspend);
 	}
 
 
@@ -3604,6 +3649,24 @@ public override int FileRead(string pchFile,IntPtr pvData,int cubDataToRead)
 	int result = NativeEntrypoints.SteamAPI_ISteamRemoteStorage_FileRead(m_pSteamRemoteStorage,pchFile,pvData,cubDataToRead);
 	return result;
 }
+public override ulong FileWriteAsync(string pchFile,IntPtr pvData,uint cubData)
+{
+	CheckIfUsable();
+	ulong result = NativeEntrypoints.SteamAPI_ISteamRemoteStorage_FileWriteAsync(m_pSteamRemoteStorage,pchFile,pvData,cubData);
+	return result;
+}
+public override ulong FileReadAsync(string pchFile,uint nOffset,uint cubToRead)
+{
+	CheckIfUsable();
+	ulong result = NativeEntrypoints.SteamAPI_ISteamRemoteStorage_FileReadAsync(m_pSteamRemoteStorage,pchFile,nOffset,cubToRead);
+	return result;
+}
+public override bool FileReadAsyncComplete(ulong hReadCall,IntPtr pvBuffer,uint cubToRead)
+{
+	CheckIfUsable();
+	bool result = NativeEntrypoints.SteamAPI_ISteamRemoteStorage_FileReadAsyncComplete(m_pSteamRemoteStorage,hReadCall,pvBuffer,cubToRead);
+	return result;
+}
 public override bool FileForget(string pchFile)
 {
 	CheckIfUsable();
@@ -5129,10 +5192,10 @@ private void CheckIfUsable()
 		throw new Exception("Steam Pointer not configured");
 	}
 }
-public override bool Init(string pchAbsolutePathToControllerConfigVDF)
+public override bool Init()
 {
 	CheckIfUsable();
-	bool result = NativeEntrypoints.SteamAPI_ISteamController_Init(m_pSteamController,pchAbsolutePathToControllerConfigVDF);
+	bool result = NativeEntrypoints.SteamAPI_ISteamController_Init(m_pSteamController);
 	return result;
 }
 public override bool Shutdown()
@@ -5146,21 +5209,83 @@ public override void RunFrame()
 	CheckIfUsable();
 	NativeEntrypoints.SteamAPI_ISteamController_RunFrame(m_pSteamController);
 }
-public override bool GetControllerState(uint unControllerIndex,ref SteamControllerState001_t pState)
+public override int GetConnectedControllers(ref ulong handlesOut)
 {
 	CheckIfUsable();
-	bool result = NativeEntrypoints.SteamAPI_ISteamController_GetControllerState(m_pSteamController,unControllerIndex,ref pState);
+	handlesOut = 0;
+	int result = NativeEntrypoints.SteamAPI_ISteamController_GetConnectedControllers(m_pSteamController,ref handlesOut);
 	return result;
 }
-public override void TriggerHapticPulse(uint unControllerIndex,uint eTargetPad,char usDurationMicroSec)
+public override bool ShowBindingPanel(ulong controllerHandle)
 {
 	CheckIfUsable();
-	NativeEntrypoints.SteamAPI_ISteamController_TriggerHapticPulse(m_pSteamController,unControllerIndex,eTargetPad,usDurationMicroSec);
+	bool result = NativeEntrypoints.SteamAPI_ISteamController_ShowBindingPanel(m_pSteamController,controllerHandle);
+	return result;
 }
-public override void SetOverrideMode(string pchMode)
+public override ulong GetActionSetHandle(string pszActionSetName)
 {
 	CheckIfUsable();
-	NativeEntrypoints.SteamAPI_ISteamController_SetOverrideMode(m_pSteamController,pchMode);
+	ulong result = NativeEntrypoints.SteamAPI_ISteamController_GetActionSetHandle(m_pSteamController,pszActionSetName);
+	return result;
+}
+public override void ActivateActionSet(ulong controllerHandle,ulong actionSetHandle)
+{
+	CheckIfUsable();
+	NativeEntrypoints.SteamAPI_ISteamController_ActivateActionSet(m_pSteamController,controllerHandle,actionSetHandle);
+}
+public override ulong GetCurrentActionSet(ulong controllerHandle)
+{
+	CheckIfUsable();
+	ulong result = NativeEntrypoints.SteamAPI_ISteamController_GetCurrentActionSet(m_pSteamController,controllerHandle);
+	return result;
+}
+public override ulong GetDigitalActionHandle(string pszActionName)
+{
+	CheckIfUsable();
+	ulong result = NativeEntrypoints.SteamAPI_ISteamController_GetDigitalActionHandle(m_pSteamController,pszActionName);
+	return result;
+}
+public override ControllerDigitalActionData_t GetDigitalActionData(ulong controllerHandle,ulong digitalActionHandle)
+{
+	CheckIfUsable();
+	ControllerDigitalActionData_t result = NativeEntrypoints.SteamAPI_ISteamController_GetDigitalActionData(m_pSteamController,controllerHandle,digitalActionHandle);
+	return result;
+}
+public override int GetDigitalActionOrigins(ulong controllerHandle,ulong actionSetHandle,ulong digitalActionHandle,ref uint originsOut)
+{
+	CheckIfUsable();
+	originsOut = 0;
+	int result = NativeEntrypoints.SteamAPI_ISteamController_GetDigitalActionOrigins(m_pSteamController,controllerHandle,actionSetHandle,digitalActionHandle,ref originsOut);
+	return result;
+}
+public override ulong GetAnalogActionHandle(string pszActionName)
+{
+	CheckIfUsable();
+	ulong result = NativeEntrypoints.SteamAPI_ISteamController_GetAnalogActionHandle(m_pSteamController,pszActionName);
+	return result;
+}
+public override ControllerAnalogActionData_t GetAnalogActionData(ulong controllerHandle,ulong analogActionHandle)
+{
+	CheckIfUsable();
+	ControllerAnalogActionData_t result = NativeEntrypoints.SteamAPI_ISteamController_GetAnalogActionData(m_pSteamController,controllerHandle,analogActionHandle);
+	return result;
+}
+public override int GetAnalogActionOrigins(ulong controllerHandle,ulong actionSetHandle,ulong analogActionHandle,ref uint originsOut)
+{
+	CheckIfUsable();
+	originsOut = 0;
+	int result = NativeEntrypoints.SteamAPI_ISteamController_GetAnalogActionOrigins(m_pSteamController,controllerHandle,actionSetHandle,analogActionHandle,ref originsOut);
+	return result;
+}
+public override void StopAnalogActionMomentum(ulong controllerHandle,ulong eAction)
+{
+	CheckIfUsable();
+	NativeEntrypoints.SteamAPI_ISteamController_StopAnalogActionMomentum(m_pSteamController,controllerHandle,eAction);
+}
+public override void TriggerHapticPulse(ulong controllerHandle,uint eTargetPad,char usDurationMicroSec)
+{
+	CheckIfUsable();
+	NativeEntrypoints.SteamAPI_ISteamController_TriggerHapticPulse(m_pSteamController,controllerHandle,eTargetPad,usDurationMicroSec);
 }
 }
 
@@ -5529,6 +5654,17 @@ public override bool DownloadItem(ulong nPublishedFileID,bool bHighPriority)
 	bool result = NativeEntrypoints.SteamAPI_ISteamUGC_DownloadItem(m_pSteamUGC,nPublishedFileID,bHighPriority);
 	return result;
 }
+public override bool BInitWorkshopForGameServer(uint unWorkshopDepotID,string pszFolder)
+{
+	CheckIfUsable();
+	bool result = NativeEntrypoints.SteamAPI_ISteamUGC_BInitWorkshopForGameServer(m_pSteamUGC,unWorkshopDepotID,pszFolder);
+	return result;
+}
+public override void SuspendDownloads(bool bSuspend)
+{
+	CheckIfUsable();
+	NativeEntrypoints.SteamAPI_ISteamUGC_SuspendDownloads(m_pSteamUGC,bSuspend);
+}
 }
 
 
@@ -6515,6 +6651,7 @@ public enum EResult
 	k_EResultRefundToWallet = 98,
 	k_EResultEmailSendFailure = 99,
 	k_EResultNotSettled = 100,
+	k_EResultNeedCaptcha = 101,
 }
 public enum EVoiceResult
 {
@@ -6617,6 +6754,7 @@ public enum EAppOwnershipFlags
 	k_EAppOwnershipFlags_LicenseRecurring = 4096,
 	k_EAppOwnershipFlags_LicenseCanceled = 8192,
 	k_EAppOwnershipFlags_AutoGrant = 16384,
+	k_EAppOwnershipFlags_PendingGift = 32768,
 }
 public enum EAppType
 {
@@ -6716,6 +6854,24 @@ public enum EBroadcastUploadResult
 	k_EBroadcastUploadResultSettingsChanged = 10,
 	k_EBroadcastUploadResultMissingAudio = 11,
 	k_EBroadcastUploadResultTooFarBehind = 12,
+	k_EBroadcastUploadResultTranscodeBehind = 13,
+}
+public enum ELaunchOptionType
+{
+	k_ELaunchOptionType_None = 0,
+	k_ELaunchOptionType_Default = 1,
+	k_ELaunchOptionType_SafeMode = 2,
+	k_ELaunchOptionType_Multiplayer = 3,
+	k_ELaunchOptionType_Config = 4,
+	k_ELaunchOptionType_VR = 5,
+	k_ELaunchOptionType_Server = 6,
+	k_ELaunchOptionType_Editor = 7,
+	k_ELaunchOptionType_Manual = 8,
+	k_ELaunchOptionType_Benchmark = 9,
+	k_ELaunchOptionType_Option1 = 10,
+	k_ELaunchOptionType_Option2 = 11,
+	k_ELaunchOptionType_Option3 = 12,
+	k_ELaunchOptionType_Dialog = 1000,
 }
 public enum EFailureType
 {
@@ -7071,6 +7227,75 @@ public enum ESteamControllerPad
 	k_ESteamControllerPad_Left = 0,
 	k_ESteamControllerPad_Right = 1,
 }
+public enum EControllerSource
+{
+	k_EControllerSource_None = 0,
+	k_EControllerSource_LeftTrackpad = 1,
+	k_EControllerSource_RightTrackpad = 2,
+	k_EControllerSource_Joystick = 3,
+	k_EControllerSource_ABXY = 4,
+	k_EControllerSource_Switch = 5,
+	k_EControllerSource_LeftTrigger = 6,
+	k_EControllerSource_RightTrigger = 7,
+	k_EControllerSource_Gyro = 8,
+}
+public enum EControllerSourceMode
+{
+	k_EControllerSourceMode_None = 0,
+	k_EControllerSourceMode_Dpad = 1,
+	k_EControllerSourceMode_Buttons = 2,
+	k_EControllerSourceMode_FourButtons = 3,
+	k_EControllerSourceMode_AbsoluteMouse = 4,
+	k_EControllerSourceMode_RelativeMouse = 5,
+	k_EControllerSourceMode_JoystickMove = 6,
+	k_EControllerSourceMode_JoystickCamera = 7,
+	k_EControllerSourceMode_ScrollWheel = 8,
+	k_EControllerSourceMode_Trigger = 9,
+	k_EControllerSourceMode_TouchMenu = 10,
+}
+public enum EControllerActionOrigin
+{
+	k_EControllerActionOrigin_None = 0,
+	k_EControllerActionOrigin_A = 1,
+	k_EControllerActionOrigin_B = 2,
+	k_EControllerActionOrigin_X = 3,
+	k_EControllerActionOrigin_Y = 4,
+	k_EControllerActionOrigin_LeftBumper = 5,
+	k_EControllerActionOrigin_RightBumper = 6,
+	k_EControllerActionOrigin_LeftGrip = 7,
+	k_EControllerActionOrigin_RightGrip = 8,
+	k_EControllerActionOrigin_Start = 9,
+	k_EControllerActionOrigin_Back = 10,
+	k_EControllerActionOrigin_LeftPad_Touch = 11,
+	k_EControllerActionOrigin_LeftPad_Swipe = 12,
+	k_EControllerActionOrigin_LeftPad_Click = 13,
+	k_EControllerActionOrigin_LeftPad_DPadNorth = 14,
+	k_EControllerActionOrigin_LeftPad_DPadSouth = 15,
+	k_EControllerActionOrigin_LeftPad_DPadWest = 16,
+	k_EControllerActionOrigin_LeftPad_DPadEast = 17,
+	k_EControllerActionOrigin_RightPad_Touch = 18,
+	k_EControllerActionOrigin_RightPad_Swipe = 19,
+	k_EControllerActionOrigin_RightPad_Click = 20,
+	k_EControllerActionOrigin_RightPad_DPadNorth = 21,
+	k_EControllerActionOrigin_RightPad_DPadSouth = 22,
+	k_EControllerActionOrigin_RightPad_DPadWest = 23,
+	k_EControllerActionOrigin_RightPad_DPadEast = 24,
+	k_EControllerActionOrigin_LeftTrigger_Pull = 25,
+	k_EControllerActionOrigin_LeftTrigger_Click = 26,
+	k_EControllerActionOrigin_RightTrigger_Pull = 27,
+	k_EControllerActionOrigin_RightTrigger_Click = 28,
+	k_EControllerActionOrigin_LeftStick_Move = 29,
+	k_EControllerActionOrigin_LeftStick_Click = 30,
+	k_EControllerActionOrigin_LeftStick_DPadNorth = 31,
+	k_EControllerActionOrigin_LeftStick_DPadSouth = 32,
+	k_EControllerActionOrigin_LeftStick_DPadWest = 33,
+	k_EControllerActionOrigin_LeftStick_DPadEast = 34,
+	k_EControllerActionOrigin_Gyro_Move = 35,
+	k_EControllerActionOrigin_Gyro_Pitch = 36,
+	k_EControllerActionOrigin_Gyro_Yaw = 37,
+	k_EControllerActionOrigin_Gyro_Roll = 38,
+	k_EControllerActionOrigin_Count = 39,
+}
 public enum EUGCMatchingUGCType
 {
 	k_EUGCMatchingUGCType_Items = 0,
@@ -7086,6 +7311,7 @@ public enum EUGCMatchingUGCType
 	k_EUGCMatchingUGCType_UsableInGame = 10,
 	k_EUGCMatchingUGCType_ControllerBindings = 11,
 	k_EUGCMatchingUGCType_GameManagedItems = 12,
+	k_EUGCMatchingUGCType_All = -1,
 }
 public enum EUserUGCList
 {
@@ -7258,6 +7484,7 @@ public enum ESteamItemFlags
 [StructLayout(LayoutKind.Sequential)] public struct SteamServerConnectFailure_t
 {
 	public EResult m_eResult;
+	public bool m_bStillRetrying;
 }
 [StructLayout(LayoutKind.Sequential)] public struct SteamServersDisconnected_t
 {
@@ -7758,6 +7985,17 @@ public enum ESteamItemFlags
 	public uint m_nAppID;
 	public ulong m_hFile;
 }
+[StructLayout(LayoutKind.Sequential)] public struct RemoteStorageFileWriteAsyncComplete_t
+{
+	public EResult m_eResult;
+}
+[StructLayout(LayoutKind.Sequential)] public struct RemoteStorageFileReadAsyncComplete_t
+{
+	public ulong m_hFileReadAsync;
+	public EResult m_eResult;
+	public uint m_nOffset;
+	public uint m_cubRead;
+}
 [StructLayout(LayoutKind.Sequential)] public struct LeaderboardEntry_t
 {
 	public ulong m_steamIDUser;
@@ -7947,14 +8185,17 @@ public enum ESteamItemFlags
 	public EResult m_eResult;
 	public uint m_unResponseSize;
 }
-[StructLayout(LayoutKind.Sequential)] public struct SteamControllerState001_t
+[StructLayout(LayoutKind.Sequential)] public struct ControllerAnalogActionData_t
 {
-	public uint unPacketNum;
-	public ulong ulButtons;
-	public char sLeftPadX;
-	public char sLeftPadY;
-	public char sRightPadX;
-	public char sRightPadY;
+	public EControllerSourceMode eMode;
+	public float x;
+	public float y;
+	public bool bActive;
+}
+[StructLayout(LayoutKind.Sequential)] public struct ControllerDigitalActionData_t
+{
+	public bool bState;
+	public bool bActive;
 }
 [StructLayout(LayoutKind.Sequential)] public struct SteamUGCDetails_t
 {

public/steam/steam_gameserver.h

@@ -69,8 +69,20 @@ S_API void SteamGameServer_RunCallbacks();
 S_API bool SteamGameServer_BSecure();
 S_API uint64 SteamGameServer_GetSteamID();
 
-#define STEAM_GAMESERVER_CALLBACK( thisclass, func, param, var ) CCallback< thisclass, param, true > var; void func( param *pParam )
 
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+// These macros are similar to the STEAM_CALLBACK_* macros in steam_api.h, but only trigger for gameserver callbacks
+//----------------------------------------------------------------------------------------------------------------------------------------------------------//
+#define STEAM_GAMESERVER_CALLBACK( thisclass, func, /*callback_type, [deprecated] var*/... ) \
+	_STEAM_CALLBACK_SELECT( ( __VA_ARGS__, GS, 3 ), ( this->SetGameserverFlag();, thisclass, func, __VA_ARGS__ ) )
+
+#define STEAM_GAMESERVER_CALLBACK_MANUAL( thisclass, func, callback_type, var ) \
+	CCallbackManual< thisclass, callback_type, true > var; void func( callback_type *pParam )
+
+
+
+#define _STEAM_CALLBACK_GS( _, thisclass, func, param, var ) \
+	CCallback< thisclass, param, true > var; void func( param *pParam )
 
 //----------------------------------------------------------------------------------------------------------------------------------------------------------//
 //	steamclient.dll private wrapper functions

public/steam/steamclientpublic.h

@@ -125,6 +125,7 @@ enum EResult
 	k_EResultRefundToWallet = 98,				// Cannot refund to payment method, must use wallet
 	k_EResultEmailSendFailure = 99,				// Cannot send an email
 	k_EResultNotSettled = 100,					// Can't perform operation till payment has settled
+	k_EResultNeedCaptcha = 101,					// Needs to provide a valid captcha
 };
 
 // Error codes for use with the voice functions
@@ -258,6 +259,7 @@ enum EAppOwnershipFlags
 	k_EAppOwnershipFlags_LicenseRecurring	= 0x1000,	// Recurring license, user is charged periodically
 	k_EAppOwnershipFlags_LicenseCanceled	= 0x2000,	// Mark as canceled, but might be still active if recurring
 	k_EAppOwnershipFlags_AutoGrant			= 0x4000,	// Ownership is based on any kind of autogrant license
+	k_EAppOwnershipFlags_PendingGift		= 0x8000,	// user has pending gift to redeem
 };
 
 
@@ -427,6 +429,31 @@ enum EBroadcastUploadResult
 	k_EBroadcastUploadResultSettingsChanged = 10,	// the client changed broadcast settings 
 	k_EBroadcastUploadResultMissingAudio = 11,	// client failed to send audio data
 	k_EBroadcastUploadResultTooFarBehind = 12,	// clients was too slow uploading
+	k_EBroadcastUploadResultTranscodeBehind = 13,	// server failed to keep up with transcode
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: codes for well defined launch options
+//-----------------------------------------------------------------------------
+enum ELaunchOptionType
+{
+	k_ELaunchOptionType_None		= 0,	// unknown what launch option does
+	k_ELaunchOptionType_Default		= 1,	// runs the game, app, whatever in default mode
+	k_ELaunchOptionType_SafeMode	= 2,	// runs the game in safe mode
+	k_ELaunchOptionType_Multiplayer = 3,	// runs the game in multiplayer mode
+	k_ELaunchOptionType_Config		= 4,	// runs config tool for this game
+	k_ELaunchOptionType_VR			= 5,	// runs game in VR mode
+	k_ELaunchOptionType_Server		= 6,	// runs dedicated server for this game
+	k_ELaunchOptionType_Editor		= 7,	// runs game editor
+	k_ELaunchOptionType_Manual		= 8,	// shows game manual
+	k_ELaunchOptionType_Benchmark	= 9,	// runs game benchmark
+	k_ELaunchOptionType_Option1		= 10,	// generic run option, uses description field for game name
+	k_ELaunchOptionType_Option2		= 11,	// generic run option, uses description field for game name
+	k_ELaunchOptionType_Option3     = 12,	// generic run option, uses description field for game name
+	
+	
+	k_ELaunchOptionType_Dialog 		= 1000, // show launch options dialog
 };