Update to sdk 1.51

dll/flat.cpp

@@ -757,6 +757,11 @@ STEAMAPI_API bool SteamAPI_ISteamFriends_RegisterProtocolInOverlayBrowser( IStea
     return (get_steam_client()->steam_friends)->RegisterProtocolInOverlayBrowser(pchProtocol);
 }
 
+STEAMAPI_API void SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialogConnectString( ISteamFriends* self, const char * pchConnectString )
+{
+    return (get_steam_client()->steam_friends)->ActivateGameOverlayInviteDialogConnectString(pchConnectString);
+}
+
 STEAMAPI_API ISteamUtils *SteamAPI_SteamUtils_v010()
 {
     return get_steam_client()->GetISteamUtils(flat_hsteampipe(), "SteamUtils010");
@@ -2884,6 +2889,11 @@ STEAMAPI_API ISteamInput *SteamAPI_SteamInput_v001()
     return get_steam_client()->GetISteamInput(flat_hsteamuser(), flat_hsteampipe(), "SteamInput001");
 }
 
+STEAMAPI_API ISteamInput *SteamAPI_SteamInput_v002()
+{
+    return get_steam_client()->GetISteamInput(flat_hsteamuser(), flat_hsteampipe(), "SteamInput002");
+}
+
 STEAMAPI_API bool SteamAPI_ISteamInput_Init( ISteamInput* self )
 {
     return (get_steam_client()->steam_controller)->Init();
@@ -3064,6 +3074,11 @@ STEAMAPI_API ISteamController *SteamAPI_SteamController_v007()
     return get_steam_client()->GetISteamController(flat_hsteamuser(), flat_hsteampipe(), "SteamController007");
 }
 
+STEAMAPI_API ISteamController *SteamAPI_SteamController_v008()
+{
+    return get_steam_client()->GetISteamController(flat_hsteamuser(), flat_hsteampipe(), "SteamController008");
+}
+
 STEAMAPI_API bool SteamAPI_ISteamController_Init( ISteamController* self )
 {
     return (get_steam_client()->steam_controller)->Init();
@@ -3239,11 +3254,21 @@ STEAMAPI_API ISteamUGC *SteamAPI_SteamUGC_v014()
     return get_steam_client()->GetISteamUGC(flat_hsteamuser(), flat_hsteampipe(), "STEAMUGC_INTERFACE_VERSION014");
 }
 
+STEAMAPI_API ISteamUGC *SteamAPI_SteamUGC_v015()
+{
+    return get_steam_client()->GetISteamUGC(flat_hsteamuser(), flat_hsteampipe(), "STEAMUGC_INTERFACE_VERSION015");
+}
+
 STEAMAPI_API ISteamUGC *SteamAPI_SteamGameServerUGC_v014()
 {
     return get_steam_client()->GetISteamUGC(flat_gs_hsteamuser(), flat_gs_hsteampipe(), "STEAMUGC_INTERFACE_VERSION014");
 }
 
+STEAMAPI_API ISteamUGC *SteamAPI_SteamGameServerUGC_v015()
+{
+    return get_steam_client()->GetISteamUGC(flat_gs_hsteamuser(), flat_gs_hsteampipe(), "STEAMUGC_INTERFACE_VERSION015");
+}
+
 STEAMAPI_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryUserUGCRequest( ISteamUGC* self, AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage )
 {
     int test1 = ((char *)self - (char*)get_steam_client()->steam_ugc);
@@ -3340,6 +3365,42 @@ STEAMAPI_API bool SteamAPI_ISteamUGC_GetQueryUGCResult( ISteamUGC* self, UGCQuer
     return (ptr)->GetQueryUGCResult(handle, index, pDetails);
 }
 
+STEAMAPI_API uint32 SteamAPI_ISteamUGC_GetQueryUGCNumTags( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index )
+{
+    int test1 = ((char *)self - (char*)get_steam_client()->steam_ugc);
+    int test2 = ((char *)self - (char*)get_steam_client()->steam_gameserver_ugc);
+    auto ptr = get_steam_client()->steam_gameserver_ugc;
+    if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
+        ptr = get_steam_client()->steam_ugc;
+    }
+
+    return (ptr)->GetQueryUGCNumTags(handle, index);
+}
+
+STEAMAPI_API bool SteamAPI_ISteamUGC_GetQueryUGCTag( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, uint32 indexTag, char * pchValue, uint32 cchValueSize )
+{
+    int test1 = ((char *)self - (char*)get_steam_client()->steam_ugc);
+    int test2 = ((char *)self - (char*)get_steam_client()->steam_gameserver_ugc);
+    auto ptr = get_steam_client()->steam_gameserver_ugc;
+    if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
+        ptr = get_steam_client()->steam_ugc;
+    }
+
+    return (ptr)->GetQueryUGCTag(handle, index, indexTag, pchValue, cchValueSize);
+}
+
+STEAMAPI_API bool SteamAPI_ISteamUGC_GetQueryUGCTagDisplayName( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, uint32 indexTag, char * pchValue, uint32 cchValueSize )
+{
+    int test1 = ((char *)self - (char*)get_steam_client()->steam_ugc);
+    int test2 = ((char *)self - (char*)get_steam_client()->steam_gameserver_ugc);
+    auto ptr = get_steam_client()->steam_gameserver_ugc;
+    if (test1 >= 0 && (test2 < 0 || test1 < test2)) {
+        ptr = get_steam_client()->steam_ugc;
+    }
+
+    return (ptr)->GetQueryUGCTagDisplayName(handle, index, indexTag, pchValue, cchValueSize);
+}
+
 STEAMAPI_API bool SteamAPI_ISteamUGC_GetQueryUGCPreviewURL( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, char * pchURL, uint32 cchURLSize )
 {
     int test1 = ((char *)self - (char*)get_steam_client()->steam_ugc);
@@ -5112,11 +5173,21 @@ STEAMAPI_API ISteamNetworkingMessages *SteamAPI_SteamNetworkingMessages_v002()
     return (ISteamNetworkingMessages *)get_steam_client()->GetISteamGenericInterface(flat_hsteamuser(), flat_hsteampipe(), "SteamNetworkingMessages002");
 }
 
+STEAMAPI_API ISteamNetworkingMessages *SteamAPI_SteamNetworkingMessages_SteamAPI_v002()
+{
+    return (ISteamNetworkingMessages *)get_steam_client()->GetISteamGenericInterface(flat_hsteamuser(), flat_hsteampipe(), "SteamNetworkingMessages002");
+}
+
 STEAMAPI_API ISteamNetworkingMessages *SteamAPI_SteamGameServerNetworkingMessages_v002()
 {
     return (ISteamNetworkingMessages *)get_steam_client()->GetISteamGenericInterface(flat_gs_hsteamuser(), flat_gs_hsteampipe(), "SteamNetworkingMessages002");
 }
 
+STEAMAPI_API ISteamNetworkingMessages *SteamAPI_SteamGameServerNetworkingMessages_SteamAPI_v002()
+{
+    return (ISteamNetworkingMessages *)get_steam_client()->GetISteamGenericInterface(flat_gs_hsteamuser(), flat_gs_hsteampipe(), "SteamNetworkingMessages002");
+}
+
 STEAMAPI_API EResult SteamAPI_ISteamNetworkingMessages_SendMessageToUser( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote, const void * pubData, uint32 cubData, int nSendFlags, int nRemoteChannel )
 {
     return self->SendMessageToUser(identityRemote, pubData, cubData, nSendFlags, nRemoteChannel);
@@ -5147,6 +5218,16 @@ STEAMAPI_API ESteamNetworkingConnectionState SteamAPI_ISteamNetworkingMessages_G
     return self->GetSessionConnectionInfo(identityRemote, pConnectionInfo, pQuickStatus);
 }
 
+STEAMAPI_API ISteamNetworkingSockets *SteamAPI_SteamNetworkingSockets_SteamAPI_v009()
+{
+    return (ISteamNetworkingSockets *)get_steam_client()->GetISteamGenericInterface(flat_hsteamuser(), flat_hsteampipe(), "SteamNetworkingSockets009");
+}
+
+STEAMAPI_API ISteamNetworkingSockets *SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v009()
+{
+    return (ISteamNetworkingSockets *)get_steam_client()->GetISteamGenericInterface(flat_gs_hsteamuser(), flat_gs_hsteampipe(), "SteamNetworkingSockets009");
+}
+
 STEAMAPI_API ISteamNetworkingSockets *SteamAPI_SteamNetworkingSockets_v009()
 {
     return (ISteamNetworkingSockets *)get_steam_client()->GetISteamGenericInterface(flat_hsteamuser(), flat_hsteampipe(), "SteamNetworkingSockets009");
@@ -5387,6 +5468,11 @@ STEAMAPI_API void SteamAPI_ISteamNetworkingCustomSignalingRecvContext_SendReject
     return self->SendRejectionSignal(identityPeer, pMsg, cbMsg);
 }
 
+STEAMAPI_API ISteamNetworkingUtils *SteamAPI_SteamNetworkingUtils_SteamAPI_v003()
+{
+    return (ISteamNetworkingUtils *)get_steam_client()->GetISteamGenericInterface(flat_hsteamuser(), flat_hsteampipe(), "SteamNetworkingUtils003");
+}
+
 STEAMAPI_API ISteamNetworkingUtils *SteamAPI_SteamNetworkingUtils_v003()
 {
     return (ISteamNetworkingUtils *)get_steam_client()->GetISteamGenericInterface(flat_hsteamuser(), flat_hsteampipe(), "SteamNetworkingUtils003");
@@ -6058,6 +6144,26 @@ STEAMAPI_API const char * SteamAPI_SteamNetworkingIdentity_GetXboxPairwiseID( St
     return "";//self->GetXboxPairwiseID();
 }
 
+STEAMAPI_API void SteamAPI_SteamNetworkingIdentity_SetPSNID( SteamNetworkingIdentity* self, uint64 id )
+{
+
+}
+
+STEAMAPI_API uint64 SteamAPI_SteamNetworkingIdentity_GetPSNID( SteamNetworkingIdentity* self )
+{
+    return 0;
+}
+
+STEAMAPI_API void SteamAPI_SteamNetworkingIdentity_SetStadiaID( SteamNetworkingIdentity* self, uint64 id )
+{
+
+}
+
+STEAMAPI_API uint64 SteamAPI_SteamNetworkingIdentity_GetStadiaID( SteamNetworkingIdentity* self )
+{
+    return 0;
+}
+
 STEAMAPI_API void SteamAPI_SteamNetworkingIdentity_SetIPAddr( SteamNetworkingIdentity* self, const SteamNetworkingIPAddr & addr )
 {
     return self->SetIPAddr(addr);

dll/steam_client.cpp

@@ -849,6 +849,8 @@ ISteamController *Steam_Client::GetISteamController( HSteamUser hSteamUser, HSte
         return (ISteamController *)(void *)(ISteamController005 *)steam_controller;
     } else if (strcmp(pchVersion, "SteamController006") == 0) {
         return (ISteamController *)(void *)(ISteamController006 *)steam_controller;
+    } else if (strcmp(pchVersion, "SteamController007") == 0) {
+        return (ISteamController *)(void *)(ISteamController007 *)steam_controller;
     } else if (strcmp(pchVersion, STEAMCONTROLLER_INTERFACE_VERSION) == 0) {
         return (ISteamController *)(void *)(ISteamController *)steam_controller;
     } else {
@@ -901,6 +903,8 @@ ISteamUGC *Steam_Client::GetISteamUGC( HSteamUser hSteamUser, HSteamPipe hSteamP
         return (ISteamUGC *)(void *)(ISteamUGC012 *)steam_ugc_temp;
     } else if (strcmp(pchVersion, "STEAMUGC_INTERFACE_VERSION013") == 0) {
         return (ISteamUGC *)(void *)(ISteamUGC013 *)steam_ugc_temp;
+    } else if (strcmp(pchVersion, "STEAMUGC_INTERFACE_VERSION014") == 0) {
+        return (ISteamUGC *)(void *)(ISteamUGC014 *)steam_ugc_temp;
     } else if (strcmp(pchVersion, STEAMUGC_INTERFACE_VERSION) == 0) {
         return (ISteamUGC *)(void *)(ISteamUGC *)steam_ugc_temp;
     } else {
@@ -1057,6 +1061,14 @@ ISteamInput *Steam_Client::GetISteamInput( HSteamUser hSteamUser, HSteamPipe hSt
     PRINT_DEBUG("GetISteamInput %s\n", pchVersion);
     if (!steam_pipes.count(hSteamPipe) || !hSteamUser) return NULL;
 
+    if (strcmp(pchVersion, "SteamInput001") == 0) {
+        return (ISteamInput *)(void *)(ISteamInput001 *)steam_controller;
+    } else if (strcmp(pchVersion, STEAMINPUT_INTERFACE_VERSION) == 0) {
+        return (ISteamInput *)(void *)(ISteamInput *)steam_controller;
+    } else {
+        return (ISteamInput *)(void *)(ISteamInput *)steam_controller;
+    }
+
     return steam_controller;
 }
 

dll/steam_controller.h

@@ -72,7 +72,9 @@ public ISteamController003,
 public ISteamController004,
 public ISteamController005,
 public ISteamController006,
+public ISteamController007,
 public ISteamController,
+public ISteamInput001,
 public ISteamInput
 {
     class Settings *settings;

dll/steam_friends.h

@@ -1008,6 +1008,12 @@ bool RegisterProtocolInOverlayBrowser( const char *pchProtocol )
     return false;
 }
 
+// Activates the game overlay to open an invite dialog that will send the provided Rich Presence connect string to selected friends
+void ActivateGameOverlayInviteDialogConnectString( const char *pchConnectString )
+{
+    PRINT_DEBUG("Steam_Friends::ActivateGameOverlayInviteDialogConnectString\n");
+}
+
 void RunCallbacks()
 {
 	PRINT_DEBUG("Steam_Friends::RunCallbacks\n");

dll/steam_networking_sockets.h

@@ -754,6 +754,7 @@ SteamNetworkingMessage_t *get_steam_message_connection(HSteamNetConnection hConn
     pMsg->m_identityPeer = connect_socket->second.remote_identity;
     pMsg->m_nConnUserData = connect_socket->second.user_data;
     pMsg->m_usecTimeReceived = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - created).count();
+    //TODO: check where messagenumber starts
     pMsg->m_nMessageNumber = connect_socket->second.packet_receive_counter;
     ++connect_socket->second.packet_receive_counter;
 

dll/steam_ugc.h

@@ -38,6 +38,7 @@ public ISteamUGC009,
 public ISteamUGC010,
 public ISteamUGC012,
 public ISteamUGC013,
+public ISteamUGC014,
 public ISteamUGC
 {
     class Settings *settings;
@@ -181,6 +182,23 @@ bool GetQueryUGCResult( UGCQueryHandle_t handle, uint32 index, SteamUGCDetails_t
     return true;
 }
 
+uint32 GetQueryUGCNumTags( UGCQueryHandle_t handle, uint32 index )
+{
+    PRINT_DEBUG("Steam_UGC::GetQueryUGCNumTags\n");
+    return 0;
+}
+
+bool GetQueryUGCTag( UGCQueryHandle_t handle, uint32 index, uint32 indexTag, STEAM_OUT_STRING_COUNT( cchValueSize ) char* pchValue, uint32 cchValueSize )
+{
+    PRINT_DEBUG("Steam_UGC::GetQueryUGCTag\n");
+    return false;
+}
+
+bool GetQueryUGCTagDisplayName( UGCQueryHandle_t handle, uint32 index, uint32 indexTag, STEAM_OUT_STRING_COUNT( cchValueSize ) char* pchValue, uint32 cchValueSize )
+{
+    PRINT_DEBUG("Steam_UGC::GetQueryUGCTagDisplayName\n");
+    return false;
+}
 
 bool GetQueryUGCPreviewURL( UGCQueryHandle_t handle, uint32 index, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchURL, uint32 cchURLSize )
 {

sdk_includes/isteamapplist.h

@@ -51,7 +51,7 @@ STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamAppList *, SteamAppList, STEAMAPPLIS
 //---------------------------------------------------------------------------------
 // Purpose: Sent when a new app is installed
 //---------------------------------------------------------------------------------
-STEAM_CALLBACK_BEGIN( SteamAppInstalled_t, k_iSteamAppListCallbacks + 1 );
+STEAM_CALLBACK_BEGIN( SteamAppInstalled_t, k_iSteamAppListCallbacks + 1 )
 	STEAM_CALLBACK_MEMBER( 0,	AppId_t,	m_nAppID )			// ID of the app that installs
 STEAM_CALLBACK_END(1)
 
@@ -59,7 +59,7 @@ STEAM_CALLBACK_END(1)
 //---------------------------------------------------------------------------------
 // Purpose: Sent when an app is uninstalled
 //---------------------------------------------------------------------------------
-STEAM_CALLBACK_BEGIN( SteamAppUninstalled_t, k_iSteamAppListCallbacks + 2 );
+STEAM_CALLBACK_BEGIN( SteamAppUninstalled_t, k_iSteamAppListCallbacks + 2 )
 	STEAM_CALLBACK_MEMBER( 0,	AppId_t,	m_nAppID )			// ID of the app that installs
 STEAM_CALLBACK_END(1)
 

sdk_includes/isteamcontroller.h

@@ -353,6 +353,64 @@ enum EControllerActionOrigin
 	k_EControllerActionOrigin_XBox360_DPad_Move,
 	k_EControllerActionOrigin_Switch_DPad_Move,
 
+	// Added in SDK 1.51
+	k_EControllerActionOrigin_PS5_X,
+	k_EControllerActionOrigin_PS5_Circle,
+	k_EControllerActionOrigin_PS5_Triangle,
+	k_EControllerActionOrigin_PS5_Square,
+	k_EControllerActionOrigin_PS5_LeftBumper,
+	k_EControllerActionOrigin_PS5_RightBumper,
+	k_EControllerActionOrigin_PS5_Option,  //Start
+	k_EControllerActionOrigin_PS5_Create,	//Back
+	k_EControllerActionOrigin_PS5_Mute,
+	k_EControllerActionOrigin_PS5_LeftPad_Touch,
+	k_EControllerActionOrigin_PS5_LeftPad_Swipe,
+	k_EControllerActionOrigin_PS5_LeftPad_Click,
+	k_EControllerActionOrigin_PS5_LeftPad_DPadNorth,
+	k_EControllerActionOrigin_PS5_LeftPad_DPadSouth,
+	k_EControllerActionOrigin_PS5_LeftPad_DPadWest,
+	k_EControllerActionOrigin_PS5_LeftPad_DPadEast,
+	k_EControllerActionOrigin_PS5_RightPad_Touch,
+	k_EControllerActionOrigin_PS5_RightPad_Swipe,
+	k_EControllerActionOrigin_PS5_RightPad_Click,
+	k_EControllerActionOrigin_PS5_RightPad_DPadNorth,
+	k_EControllerActionOrigin_PS5_RightPad_DPadSouth,
+	k_EControllerActionOrigin_PS5_RightPad_DPadWest,
+	k_EControllerActionOrigin_PS5_RightPad_DPadEast,
+	k_EControllerActionOrigin_PS5_CenterPad_Touch,
+	k_EControllerActionOrigin_PS5_CenterPad_Swipe,
+	k_EControllerActionOrigin_PS5_CenterPad_Click,
+	k_EControllerActionOrigin_PS5_CenterPad_DPadNorth,
+	k_EControllerActionOrigin_PS5_CenterPad_DPadSouth,
+	k_EControllerActionOrigin_PS5_CenterPad_DPadWest,
+	k_EControllerActionOrigin_PS5_CenterPad_DPadEast,
+	k_EControllerActionOrigin_PS5_LeftTrigger_Pull,
+	k_EControllerActionOrigin_PS5_LeftTrigger_Click,
+	k_EControllerActionOrigin_PS5_RightTrigger_Pull,
+	k_EControllerActionOrigin_PS5_RightTrigger_Click,
+	k_EControllerActionOrigin_PS5_LeftStick_Move,
+	k_EControllerActionOrigin_PS5_LeftStick_Click,
+	k_EControllerActionOrigin_PS5_LeftStick_DPadNorth,
+	k_EControllerActionOrigin_PS5_LeftStick_DPadSouth,
+	k_EControllerActionOrigin_PS5_LeftStick_DPadWest,
+	k_EControllerActionOrigin_PS5_LeftStick_DPadEast,
+	k_EControllerActionOrigin_PS5_RightStick_Move,
+	k_EControllerActionOrigin_PS5_RightStick_Click,
+	k_EControllerActionOrigin_PS5_RightStick_DPadNorth,
+	k_EControllerActionOrigin_PS5_RightStick_DPadSouth,
+	k_EControllerActionOrigin_PS5_RightStick_DPadWest,
+	k_EControllerActionOrigin_PS5_RightStick_DPadEast,
+	k_EControllerActionOrigin_PS5_DPad_Move,
+	k_EControllerActionOrigin_PS5_DPad_North,
+	k_EControllerActionOrigin_PS5_DPad_South,
+	k_EControllerActionOrigin_PS5_DPad_West,
+	k_EControllerActionOrigin_PS5_DPad_East,
+	k_EControllerActionOrigin_PS5_Gyro_Move,
+	k_EControllerActionOrigin_PS5_Gyro_Pitch,
+	k_EControllerActionOrigin_PS5_Gyro_Yaw,
+	k_EControllerActionOrigin_PS5_Gyro_Roll,
+
+
 	k_EControllerActionOrigin_Count, // If Steam has added support for new controllers origins will go here.
 	k_EControllerActionOrigin_MaximumPossibleValue = 32767, // Origins are currently a maximum of 16 bits.
 };
@@ -405,6 +463,7 @@ enum ESteamInputType
 	k_ESteamInputType_SwitchProController,
 	k_ESteamInputType_MobileTouch,			// Steam Link App On-screen Virtual Controller
 	k_ESteamInputType_PS3Controller,		// Currently uses PS4 Origins
+	k_ESteamInputType_PS5Controller,		// Added in SDK 151
 	k_ESteamInputType_Count,
 	k_ESteamInputType_MaximumPossibleValue = 255,
 };
@@ -583,7 +642,8 @@ public:
 	// If the user is not in Big Picture Mode it will open up the binding in a new window
 	virtual bool ShowBindingPanel( ControllerHandle_t controllerHandle ) = 0;
 
-	// Returns the input type for a particular handle
+	// Returns the input type for a particular handle - unlike EControllerActionOrigin which update with Steam and may return unrecognized values
+	// ESteamInputType will remain static and only return valid values from your SDK version 
 	virtual ESteamInputType GetInputTypeForHandle( ControllerHandle_t controllerHandle ) = 0;
 
 	// Returns the associated controller handle for the specified emulated gamepad - can be used with the above 2 functions
@@ -610,7 +670,7 @@ public:
 	virtual bool GetControllerBindingRevision( ControllerHandle_t controllerHandle, int *pMajor, int *pMinor ) = 0;
 };
 
-#define STEAMCONTROLLER_INTERFACE_VERSION "SteamController007"
+#define STEAMCONTROLLER_INTERFACE_VERSION "SteamController008"
 
 #ifndef STEAM_API_EXPORTS
 // Global interface accessor

sdk_includes/isteamcontroller007.h

@@ -0,0 +1,138 @@
+
+#ifndef ISTEAMCONTROLLER007_H
+#define ISTEAMCONTROLLER007_H
+#ifdef STEAM_WIN32
+#pragma once
+#endif
+
+class ISteamController007
+{
+public:
+	
+	// Init and Shutdown must be called when starting/ending use of this interface
+	virtual bool Init() = 0;
+	virtual bool Shutdown() = 0;
+	
+	// Synchronize API state with the latest Steam Controller inputs available. This
+	// is performed automatically by SteamAPI_RunCallbacks, but for the absolute lowest
+	// possible latency, you call this directly before reading controller state. This must
+	// be called from somewhere before GetConnectedControllers will return any handles
+	virtual void RunFrame() = 0;
+
+	// 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( STEAM_OUT_ARRAY_COUNT( STEAM_CONTROLLER_MAX_COUNT, Receives list of connected controllers ) ControllerHandle_t *handlesOut ) = 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;
+
+	// ACTION SET LAYERS
+	virtual void ActivateActionSetLayer( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle ) = 0;
+	virtual void DeactivateActionSetLayer( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetLayerHandle ) = 0;
+	virtual void DeactivateAllActionSetLayers( ControllerHandle_t controllerHandle ) = 0;
+	// Enumerate currently active layers
+	// handlesOut should point to a STEAM_CONTROLLER_MAX_ACTIVE_LAYERS sized array of ControllerActionSetHandle_t handles.
+	// Returns the number of handles written to handlesOut
+	virtual int GetActiveActionSetLayers( ControllerHandle_t controllerHandle, STEAM_OUT_ARRAY_COUNT( STEAM_CONTROLLER_MAX_ACTIVE_LAYERS, Receives list of active layers ) ControllerActionSetHandle_t *handlesOut ) = 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. The EControllerActionOrigin enum will get extended as support for new controller controllers gets added to
+	// the Steam client and will exceed the values from this header, please check bounds if you are using a look up table.
+	virtual int GetDigitalActionOrigins( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, STEAM_OUT_ARRAY_COUNT( STEAM_CONTROLLER_MAX_ORIGINS, Receives list of aciton origins ) 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. The EControllerActionOrigin enum will get extended as support for new controller controllers gets added to
+	// the Steam client and will exceed the values from this header, please check bounds if you are using a look up table.
+	virtual int GetAnalogActionOrigins( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, STEAM_OUT_ARRAY_COUNT( STEAM_CONTROLLER_MAX_ORIGINS, Receives list of action origins ) EControllerActionOrigin *originsOut ) = 0;
+	
+	// Get a local path to art for on-screen glyph for a particular origin - this call is cheap
+	virtual const char *GetGlyphForActionOrigin( EControllerActionOrigin eOrigin ) = 0;
+	
+	// Returns a localized string (from Steam's language setting) for the specified origin - this call is serialized
+	virtual const char *GetStringForActionOrigin( EControllerActionOrigin eOrigin ) = 0;
+
+	virtual void StopAnalogActionMomentum( ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction ) = 0;
+
+	// Returns raw motion data from the specified controller
+	virtual ControllerMotionData_t GetMotionData( ControllerHandle_t controllerHandle ) = 0;
+
+	//-----------------------------------------------------------------------------
+	// OUTPUTS
+	//-----------------------------------------------------------------------------
+
+	// Trigger a haptic pulse on a controller
+	virtual void TriggerHapticPulse( ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec ) = 0;
+
+	// Trigger a pulse with a duty cycle of usDurationMicroSec / usOffMicroSec, unRepeat times.
+	// nFlags is currently unused and reserved for future use.
+	virtual void TriggerRepeatedHapticPulse( ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec, unsigned short usOffMicroSec, unsigned short unRepeat, unsigned int nFlags ) = 0;
+	
+	// Trigger a vibration event on supported controllers.  
+	virtual void TriggerVibration( ControllerHandle_t controllerHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed ) = 0;
+
+	// Set the controller LED color on supported controllers.  
+	virtual void SetLEDColor( ControllerHandle_t controllerHandle, uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags ) = 0;
+
+	//-----------------------------------------------------------------------------
+	// Utility functions availible without using the rest of Steam Input API
+	//-----------------------------------------------------------------------------
+
+	// Invokes the Steam overlay and brings up the binding screen if the user is using Big Picture Mode
+	// If the user is not in Big Picture Mode it will open up the binding in a new window
+	virtual bool ShowBindingPanel( ControllerHandle_t controllerHandle ) = 0;
+
+	// Returns the input type for a particular handle
+	virtual ESteamInputType GetInputTypeForHandle( ControllerHandle_t controllerHandle ) = 0;
+
+	// Returns the associated controller handle for the specified emulated gamepad - can be used with the above 2 functions
+	// to identify controllers presented to your game over Xinput. Returns 0 if the Xinput index isn't associated with Steam Input
+	virtual ControllerHandle_t GetControllerForGamepadIndex( int nIndex ) = 0;
+
+	// Returns the associated gamepad index for the specified controller, if emulating a gamepad or -1 if not associated with an Xinput index
+	virtual int GetGamepadIndexForController( ControllerHandle_t ulControllerHandle ) = 0;
+	
+	// Returns a localized string (from Steam's language setting) for the specified Xbox controller origin.
+	virtual const char *GetStringForXboxOrigin( EXboxOrigin eOrigin ) = 0;
+
+	// Get a local path to art for on-screen glyph for a particular Xbox controller origin. 
+	virtual const char *GetGlyphForXboxOrigin( EXboxOrigin eOrigin ) = 0;
+
+	// Get the equivalent ActionOrigin for a given Xbox controller origin this can be chained with GetGlyphForActionOrigin to provide future proof glyphs for
+	// non-Steam Input API action games. Note - this only translates the buttons directly and doesn't take into account any remapping a user has made in their configuration
+	virtual EControllerActionOrigin GetActionOriginFromXboxOrigin_( ControllerHandle_t controllerHandle, EXboxOrigin eOrigin ) = 0;
+
+	// Convert an origin to another controller type - for inputs not present on the other controller type this will return k_EControllerActionOrigin_None
+	virtual EControllerActionOrigin TranslateActionOrigin( ESteamInputType eDestinationInputType, EControllerActionOrigin eSourceOrigin ) = 0;
+
+	// Get the binding revision for a given device. Returns false if the handle was not valid or if a mapping is not yet loaded for the device
+	virtual bool GetControllerBindingRevision( ControllerHandle_t controllerHandle, int *pMajor, int *pMinor ) = 0;
+};
+
+#endif //ISTEAMCONTROLLER007_H

sdk_includes/isteamfriends.h

@@ -369,7 +369,7 @@ public:
 
 	// Rich invite support.
 	// If the target accepts the invite, a GameRichPresenceJoinRequested_t callback is posted containing the connect string.
-	// (Or you can configure yout game so that it is passed on the command line instead.  This is a deprecated path; ask us if you really need this.)
+	// (Or you can configure your game so that it is passed on the command line instead.  This is a deprecated path; ask us if you really need this.)
 	virtual bool InviteUserToGame( CSteamID steamIDFriend, const char *pchConnectString ) = 0;
 
 	// recently-played-with friends iteration
@@ -430,6 +430,9 @@ public:
 	// to your specified protocol (scheme) uris and instead dispatch a OverlayBrowserProtocolNavigation_t callback to your game.
 	// ActivateGameOverlayToWebPage() must have been called with k_EActivateGameOverlayToWebPageMode_Modal
 	virtual bool RegisterProtocolInOverlayBrowser( const char *pchProtocol ) = 0;
+
+	// Activates the game overlay to open an invite dialog that will send the provided Rich Presence connect string to selected friends
+	virtual void ActivateGameOverlayInviteDialogConnectString( const char *pchConnectString ) = 0;
 };
 
 #define STEAMFRIENDS_INTERFACE_VERSION "SteamFriends017"

sdk_includes/isteamgameserver.h

@@ -12,8 +12,6 @@
 
 #include "steam_api_common.h"
 
-#define MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE	((uint16)-1)
-
 //-----------------------------------------------------------------------------
 // Purpose: Functions for authenticating users via Steam to play on a game server
 //-----------------------------------------------------------------------------

sdk_includes/isteaminput.h

@@ -352,6 +352,83 @@ enum EInputActionOrigin
 	k_EInputActionOrigin_Switch_Reserved19,
 	k_EInputActionOrigin_Switch_Reserved20,
 	
+	// Added in SDK 1.51
+	k_EInputActionOrigin_PS5_X,
+	k_EInputActionOrigin_PS5_Circle,
+	k_EInputActionOrigin_PS5_Triangle,
+	k_EInputActionOrigin_PS5_Square,
+	k_EInputActionOrigin_PS5_LeftBumper,
+	k_EInputActionOrigin_PS5_RightBumper,
+	k_EInputActionOrigin_PS5_Option,	//Start
+	k_EInputActionOrigin_PS5_Create,		//Back
+	k_EInputActionOrigin_PS5_Mute,
+	k_EInputActionOrigin_PS5_LeftPad_Touch,
+	k_EInputActionOrigin_PS5_LeftPad_Swipe,
+	k_EInputActionOrigin_PS5_LeftPad_Click,
+	k_EInputActionOrigin_PS5_LeftPad_DPadNorth,
+	k_EInputActionOrigin_PS5_LeftPad_DPadSouth,
+	k_EInputActionOrigin_PS5_LeftPad_DPadWest,
+	k_EInputActionOrigin_PS5_LeftPad_DPadEast,
+	k_EInputActionOrigin_PS5_RightPad_Touch,
+	k_EInputActionOrigin_PS5_RightPad_Swipe,
+	k_EInputActionOrigin_PS5_RightPad_Click,
+	k_EInputActionOrigin_PS5_RightPad_DPadNorth,
+	k_EInputActionOrigin_PS5_RightPad_DPadSouth,
+	k_EInputActionOrigin_PS5_RightPad_DPadWest,
+	k_EInputActionOrigin_PS5_RightPad_DPadEast,
+	k_EInputActionOrigin_PS5_CenterPad_Touch,
+	k_EInputActionOrigin_PS5_CenterPad_Swipe,
+	k_EInputActionOrigin_PS5_CenterPad_Click,
+	k_EInputActionOrigin_PS5_CenterPad_DPadNorth,
+	k_EInputActionOrigin_PS5_CenterPad_DPadSouth,
+	k_EInputActionOrigin_PS5_CenterPad_DPadWest,
+	k_EInputActionOrigin_PS5_CenterPad_DPadEast,
+	k_EInputActionOrigin_PS5_LeftTrigger_Pull,
+	k_EInputActionOrigin_PS5_LeftTrigger_Click,
+	k_EInputActionOrigin_PS5_RightTrigger_Pull,
+	k_EInputActionOrigin_PS5_RightTrigger_Click,
+	k_EInputActionOrigin_PS5_LeftStick_Move,
+	k_EInputActionOrigin_PS5_LeftStick_Click,
+	k_EInputActionOrigin_PS5_LeftStick_DPadNorth,
+	k_EInputActionOrigin_PS5_LeftStick_DPadSouth,
+	k_EInputActionOrigin_PS5_LeftStick_DPadWest,
+	k_EInputActionOrigin_PS5_LeftStick_DPadEast,
+	k_EInputActionOrigin_PS5_RightStick_Move,
+	k_EInputActionOrigin_PS5_RightStick_Click,
+	k_EInputActionOrigin_PS5_RightStick_DPadNorth,
+	k_EInputActionOrigin_PS5_RightStick_DPadSouth,
+	k_EInputActionOrigin_PS5_RightStick_DPadWest,
+	k_EInputActionOrigin_PS5_RightStick_DPadEast,
+	k_EInputActionOrigin_PS5_DPad_North,
+	k_EInputActionOrigin_PS5_DPad_South,
+	k_EInputActionOrigin_PS5_DPad_West,
+	k_EInputActionOrigin_PS5_DPad_East,
+	k_EInputActionOrigin_PS5_Gyro_Move,
+	k_EInputActionOrigin_PS5_Gyro_Pitch,
+	k_EInputActionOrigin_PS5_Gyro_Yaw,
+	k_EInputActionOrigin_PS5_Gyro_Roll,
+	k_EInputActionOrigin_PS5_DPad_Move,
+	k_EInputActionOrigin_PS5_Reserved1,
+	k_EInputActionOrigin_PS5_Reserved2,
+	k_EInputActionOrigin_PS5_Reserved3,
+	k_EInputActionOrigin_PS5_Reserved4,
+	k_EInputActionOrigin_PS5_Reserved5,
+	k_EInputActionOrigin_PS5_Reserved6,
+	k_EInputActionOrigin_PS5_Reserved7,
+	k_EInputActionOrigin_PS5_Reserved8,
+	k_EInputActionOrigin_PS5_Reserved9,
+	k_EInputActionOrigin_PS5_Reserved10,
+	k_EInputActionOrigin_PS5_Reserved11,
+	k_EInputActionOrigin_PS5_Reserved12,
+	k_EInputActionOrigin_PS5_Reserved13,
+	k_EInputActionOrigin_PS5_Reserved14,
+	k_EInputActionOrigin_PS5_Reserved15,
+	k_EInputActionOrigin_PS5_Reserved16,
+	k_EInputActionOrigin_PS5_Reserved17,
+	k_EInputActionOrigin_PS5_Reserved18,
+	k_EInputActionOrigin_PS5_Reserved19,
+	k_EInputActionOrigin_PS5_Reserved20,
+
 	k_EInputActionOrigin_Count, // If Steam has added support for new controllers origins will go here.
 	k_EInputActionOrigin_MaximumPossibleValue = 32767, // Origins are currently a maximum of 16 bits.
 };
@@ -410,6 +487,7 @@ enum ESteamInputType
 	k_ESteamInputType_SwitchProController,
 	k_ESteamInputType_MobileTouch,			// Steam Link App On-screen Virtual Controller
 	k_ESteamInputType_PS3Controller,		// Currently uses PS4 Origins
+	k_ESteamInputType_PS5Controller,		// Added in SDK 151
 	k_ESteamInputType_Count,
 	k_ESteamInputType_MaximumPossibleValue = 255,
 };
@@ -589,7 +667,8 @@ public:
 	// If the user is not in Big Picture Mode it will open up the binding in a new window
 	virtual bool ShowBindingPanel( InputHandle_t inputHandle ) = 0;
 
-	// Returns the input type for a particular handle
+	// Returns the input type for a particular handle - unlike EInputActionOrigin which update with Steam and may return unrecognized values
+	// ESteamInputType will remain static and only return valid values from your SDK version 
 	virtual ESteamInputType GetInputTypeForHandle( InputHandle_t inputHandle ) = 0;
 
 	// Returns the associated controller handle for the specified emulated gamepad - can be used with the above 2 functions
@@ -622,7 +701,7 @@ public:
 	virtual uint32 GetRemotePlaySessionID( InputHandle_t inputHandle ) = 0;
 };
 
-#define STEAMINPUT_INTERFACE_VERSION "SteamInput001"
+#define STEAMINPUT_INTERFACE_VERSION "SteamInput002"
 
 // Global interface accessor
 inline ISteamInput *SteamInput();

sdk_includes/isteaminput001.h

@@ -0,0 +1,148 @@
+
+#ifndef ISTEAMINPUT001_H
+#define ISTEAMINPUT001_H
+#ifdef STEAM_WIN32
+#pragma once
+#endif
+
+class ISteamInput001
+{
+public:
+	
+	// Init and Shutdown must be called when starting/ending use of this interface
+	virtual bool Init() = 0;
+	virtual bool Shutdown() = 0;
+	
+	// Synchronize API state with the latest Steam Controller inputs available. This
+	// is performed automatically by SteamAPI_RunCallbacks, but for the absolute lowest
+	// possible latency, you call this directly before reading controller state. This must
+	// be called from somewhere before GetConnectedControllers will return any handles
+	virtual void RunFrame() = 0;
+
+	// Enumerate currently connected Steam Input enabled devices - developers can opt in controller by type (ex: Xbox/Playstation/etc) via
+	// the Steam Input settings in the Steamworks site or users can opt-in in their controller settings in Steam.
+	// handlesOut should point to a STEAM_INPUT_MAX_COUNT sized array of InputHandle_t handles
+	// Returns the number of handles written to handlesOut
+	virtual int GetConnectedControllers( STEAM_OUT_ARRAY_COUNT( STEAM_INPUT_MAX_COUNT, Receives list of connected controllers ) InputHandle_t *handlesOut ) = 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 InputActionSetHandle_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( InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle ) = 0;
+	virtual InputActionSetHandle_t GetCurrentActionSet( InputHandle_t inputHandle ) = 0;
+
+	// ACTION SET LAYERS
+	virtual void ActivateActionSetLayer( InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle ) = 0;
+	virtual void DeactivateActionSetLayer( InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle ) = 0;
+	virtual void DeactivateAllActionSetLayers( InputHandle_t inputHandle ) = 0;
+	// Enumerate currently active layers.
+	// handlesOut should point to a STEAM_INPUT_MAX_ACTIVE_LAYERS sized array of ControllerActionSetHandle_t handles
+	// Returns the number of handles written to handlesOut
+	virtual int GetActiveActionSetLayers( InputHandle_t inputHandle, STEAM_OUT_ARRAY_COUNT( STEAM_INPUT_MAX_ACTIVE_LAYERS, Receives list of active layers ) InputActionSetHandle_t *handlesOut ) = 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 InputDigitalActionHandle_t GetDigitalActionHandle( const char *pszActionName ) = 0;
+	
+	// Returns the current state of the supplied digital game action
+	virtual InputDigitalActionData_t GetDigitalActionData( InputHandle_t inputHandle, InputDigitalActionHandle_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_INPUT_MAX_ORIGINS sized array of EInputActionOrigin handles. The EInputActionOrigin enum will get extended as support for new controller controllers gets added to
+	// the Steam client and will exceed the values from this header, please check bounds if you are using a look up table.
+	virtual int GetDigitalActionOrigins( InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputDigitalActionHandle_t digitalActionHandle, STEAM_OUT_ARRAY_COUNT( STEAM_INPUT_MAX_ORIGINS, Receives list of action origins ) EInputActionOrigin *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 InputAnalogActionHandle_t GetAnalogActionHandle( const char *pszActionName ) = 0;
+	
+	// Returns the current state of these supplied analog game action
+	virtual InputAnalogActionData_t GetAnalogActionData( InputHandle_t inputHandle, InputAnalogActionHandle_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_INPUT_MAX_ORIGINS sized array of EInputActionOrigin handles. The EInputActionOrigin enum will get extended as support for new controller controllers gets added to
+	// the Steam client and will exceed the values from this header, please check bounds if you are using a look up table.
+	virtual int GetAnalogActionOrigins( InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputAnalogActionHandle_t analogActionHandle, STEAM_OUT_ARRAY_COUNT( STEAM_INPUT_MAX_ORIGINS, Receives list of action origins ) EInputActionOrigin *originsOut ) = 0;
+	
+	// Get a local path to art for on-screen glyph for a particular origin
+	virtual const char *GetGlyphForActionOrigin( EInputActionOrigin eOrigin ) = 0;
+	
+	// Returns a localized string (from Steam's language setting) for the specified origin.
+	virtual const char *GetStringForActionOrigin( EInputActionOrigin eOrigin ) = 0;
+
+	// Stop analog momentum for the action if it is a mouse action in trackball mode
+	virtual void StopAnalogActionMomentum( InputHandle_t inputHandle, InputAnalogActionHandle_t eAction ) = 0;
+
+	// Returns raw motion data from the specified device
+	virtual InputMotionData_t GetMotionData( InputHandle_t inputHandle ) = 0;
+
+	//-----------------------------------------------------------------------------
+	// OUTPUTS
+	//-----------------------------------------------------------------------------
+
+	// Trigger a vibration event on supported controllers - Steam will translate these commands into haptic pulses for Steam Controllers
+	virtual void TriggerVibration( InputHandle_t inputHandle, unsigned short usLeftSpeed, unsigned short usRightSpeed ) = 0;
+
+	// Set the controller LED color on supported controllers. nFlags is a bitmask of values from ESteamInputLEDFlag - 0 will default to setting a color. Steam will handle
+	// the behavior on exit of your program so you don't need to try restore the default as you are shutting down
+	virtual void SetLEDColor( InputHandle_t inputHandle, uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags ) = 0;
+
+	// Trigger a haptic pulse on a Steam Controller - if you are approximating rumble you may want to use TriggerVibration instead.
+	// Good uses for Haptic pulses include chimes, noises, or directional gameplay feedback (taking damage, footstep locations, etc).
+	virtual void TriggerHapticPulse( InputHandle_t inputHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec ) = 0;
+
+	// Trigger a haptic pulse with a duty cycle of usDurationMicroSec / usOffMicroSec, unRepeat times. If you are approximating rumble you may want to use TriggerVibration instead.
+	// nFlags is currently unused and reserved for future use.
+	virtual void TriggerRepeatedHapticPulse( InputHandle_t inputHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec, unsigned short usOffMicroSec, unsigned short unRepeat, unsigned int nFlags ) = 0;
+
+	//-----------------------------------------------------------------------------
+	// Utility functions availible without using the rest of Steam Input API
+	//-----------------------------------------------------------------------------
+
+	// Invokes the Steam overlay and brings up the binding screen if the user is using Big Picture Mode
+	// If the user is not in Big Picture Mode it will open up the binding in a new window
+	virtual bool ShowBindingPanel( InputHandle_t inputHandle ) = 0;
+
+	// Returns the input type for a particular handle
+	virtual ESteamInputType GetInputTypeForHandle( InputHandle_t inputHandle ) = 0;
+
+	// Returns the associated controller handle for the specified emulated gamepad - can be used with the above 2 functions
+	// to identify controllers presented to your game over Xinput. Returns 0 if the Xinput index isn't associated with Steam Input
+	virtual InputHandle_t GetControllerForGamepadIndex( int nIndex ) = 0;
+
+	// Returns the associated gamepad index for the specified controller, if emulating a gamepad or -1 if not associated with an Xinput index
+	virtual int GetGamepadIndexForController( InputHandle_t ulinputHandle ) = 0;
+	
+	// Returns a localized string (from Steam's language setting) for the specified Xbox controller origin.
+	virtual const char *GetStringForXboxOrigin( EXboxOrigin eOrigin ) = 0;
+
+	// Get a local path to art for on-screen glyph for a particular Xbox controller origin
+	virtual const char *GetGlyphForXboxOrigin( EXboxOrigin eOrigin ) = 0;
+
+	// Get the equivalent ActionOrigin for a given Xbox controller origin this can be chained with GetGlyphForActionOrigin to provide future proof glyphs for
+	// non-Steam Input API action games. Note - this only translates the buttons directly and doesn't take into account any remapping a user has made in their configuration
+	virtual EInputActionOrigin GetActionOriginFromXboxOrigin( InputHandle_t inputHandle, EXboxOrigin eOrigin ) = 0;
+
+	// Convert an origin to another controller type - for inputs not present on the other controller type this will return k_EInputActionOrigin_None
+	// When a new input type is added you will be able to pass in k_ESteamInputType_Unknown and the closest origin that your version of the SDK recognized will be returned
+	// ex: if a Playstation 5 controller was released this function would return Playstation 4 origins.
+	virtual EInputActionOrigin TranslateActionOrigin( ESteamInputType eDestinationInputType, EInputActionOrigin eSourceOrigin ) = 0;
+
+	// Get the binding revision for a given device. Returns false if the handle was not valid or if a mapping is not yet loaded for the device
+	virtual bool GetDeviceBindingRevision( InputHandle_t inputHandle, int *pMajor, int *pMinor ) = 0;
+
+	// Get the Steam Remote Play session ID associated with a device, or 0 if there is no session associated with it
+	// See isteamremoteplay.h for more information on Steam Remote Play sessions
+	virtual uint32 GetRemotePlaySessionID( InputHandle_t inputHandle ) = 0;
+};
+
+#endif //ISTEAMINPUT001_H

sdk_includes/isteamnetworkingmessages.h

@@ -2,11 +2,10 @@
 
 #ifndef ISTEAMNETWORKINGMESSAGES
 #define ISTEAMNETWORKINGMESSAGES
-#ifdef STEAM_WIN32
 #pragma once
-#endif
 
 #include "steamnetworkingtypes.h"
+#include "steam_api_common.h"
 
 //-----------------------------------------------------------------------------
 /// The non-connection-oriented interface to send and receive messages
@@ -58,7 +57,7 @@ public:
 	///
 	/// It is guaranteed that reliable messages to the same host on the same channel
 	/// will be be received by the remote host (if they are received at all) exactly once,
-	/// and in the same order that they were send.
+	/// and in the same order that they were sent.
 	///
 	/// NO other order guarantees exist!  In particular, unreliable messages may be dropped,
 	/// received out of order with respect to each other and with respect to reliable data,
@@ -75,52 +74,55 @@ public:
 	/// Returns:
 	/// - k_EREsultOK on success.
 	/// - k_EResultNoConnection will be returned if the session has failed or was closed by the peer,
-	///   and k_nSteamNetworkingSend_AutoRestartBrokwnSession is not used.  (You can use
+	///   and k_nSteamNetworkingSend_AutoRestartBrokenSession is not used.  (You can use
 	///   GetSessionConnectionInfo to get the details.)  In order to acknowledge the broken session
 	///   and start a new one, you must call CloseSessionWithUser
-	/// - See SendMessageToConnection::SendMessageToConnection for more
+	/// - See ISteamNetworkingSockets::SendMessageToConnection for more possible return values
 	virtual EResult SendMessageToUser( const SteamNetworkingIdentity &identityRemote, const void *pubData, uint32 cubData, int nSendFlags, int nRemoteChannel ) = 0;
 
 	/// Reads the next message that has been sent from another user via SendMessageToUser() on the given channel.
 	/// Returns number of messages returned into your list.  (0 if no message are available on that channel.)
 	///
-	/// When you're done with the message object(s), make sure and call Release()!
+	/// When you're done with the message object(s), make sure and call SteamNetworkingMessage_t::Release()!
 	virtual int ReceiveMessagesOnChannel( int nLocalChannel, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0;
 
-	/// AcceptSessionWithUser() should only be called in response to a SteamP2PSessionRequest_t callback
+	/// Call this in response to a SteamNetworkingMessagesSessionRequest_t callback.
-	/// SteamP2PSessionRequest_t will be posted if another user tries to send you a message, and you haven't
+	/// SteamNetworkingMessagesSessionRequest_t are posted when a user tries to send you a message,
-	/// tried to talk to them.  If you don't want to talk to them, just ignore the request.
+	/// and you haven't tried to talk to them first.  If you don't want to talk to them, just ignore
-	/// If the user continues to send you messages, SteamP2PSessionRequest_t callbacks will continue to
+	/// the request.  If the user continues to send you messages, SteamNetworkingMessagesSessionRequest_t
-	/// be posted periodically.  This may be called multiple times for a single user.
+	/// callbacks will continue to be posted periodically.
 	///
-	/// Calling SendMessage() on the other user, this implicitly accepts any pending session request.
+	/// Returns false if there is no session with the user pending or otherwise.  If there is an
+	/// existing active session, this function will return true, even if it is not pending.
+	///
+	/// Calling SendMessageToUser() will implicitly accepts any pending session request to that user.
 	virtual bool AcceptSessionWithUser( const SteamNetworkingIdentity &identityRemote ) = 0;
 
 	/// Call this when you're done talking to a user to immediately free up resources under-the-hood.
-	/// If the remote user tries to send data to you again, another P2PSessionRequest_t callback will
+	/// If the remote user tries to send data to you again, another SteamNetworkingMessagesSessionRequest_t
-	/// be posted.
+	/// callback will be posted.
 	///
 	/// Note that sessions that go unused for a few minutes are automatically timed out.
 	virtual bool CloseSessionWithUser( const SteamNetworkingIdentity &identityRemote ) = 0;
 
 	/// Call this  when you're done talking to a user on a specific channel.  Once all
 	/// open channels to a user have been closed, the open session to the user will be
-	/// closed, and any new data from this user will trigger a SteamP2PSessionRequest_t
+	/// closed, and any new data from this user will trigger a
-	/// callback
+	/// SteamSteamNetworkingMessagesSessionRequest_t callback
 	virtual bool CloseChannelWithUser( const SteamNetworkingIdentity &identityRemote, int nLocalChannel ) = 0;
 
 	/// Returns information about the latest state of a connection, if any, with the given peer.
 	/// Primarily intended for debugging purposes, but can also be used to get more detailed
-	/// failure information.  (See SendMessageToUser and k_nSteamNetworkingSend_AutoRestartBrokwnSession.)
+	/// failure information.  (See SendMessageToUser and k_nSteamNetworkingSend_AutoRestartBrokenSession.)
 	///
 	/// Returns the value of SteamNetConnectionInfo_t::m_eState, or k_ESteamNetworkingConnectionState_None
 	/// if no connection exists with specified peer.  You may pass nullptr for either parameter if
 	/// you do not need the corresponding details.  Note that sessions time out after a while,
-	/// so if a connection fails, or SendMessageToUser returns SendMessageToUser, you cannot wait
+	/// so if a connection fails, or SendMessageToUser returns k_EResultNoConnection, you cannot wait
 	/// indefinitely to obtain the reason for failure.
 	virtual ESteamNetworkingConnectionState GetSessionConnectionInfo( const SteamNetworkingIdentity &identityRemote, SteamNetConnectionInfo_t *pConnectionInfo, SteamNetworkingQuickConnectionStatus *pQuickStatus ) = 0;
 };
-#define STEAMNETWORKINGMESSAGES_VERSION "SteamNetworkingMessages002"
+#define STEAMNETWORKINGMESSAGES_INTERFACE_VERSION "SteamNetworkingMessages002"
 
 //
 // Callbacks
@@ -141,7 +143,7 @@ struct SteamNetworkingMessagesSessionRequest_t
 /// SteamNetworkingMessages is primarily intended to make porting UDP code easy.)
 ///
 /// Remember: callbacks are asynchronous.   See notes on SendMessageToUser,
-/// and k_nSteamNetworkingSend_AutoRestartBrokwnSession in particular.
+/// and k_nSteamNetworkingSend_AutoRestartBrokenSession in particular.
 ///
 /// Also, if a session times out due to inactivity, no callbacks will be posted.  The only
 /// way to detect that this is happening is that querying the session state may return
@@ -150,37 +152,48 @@ struct SteamNetworkingMessagesSessionFailed_t
 { 
 	enum { k_iCallback = k_iSteamNetworkingMessagesCallbacks + 2 };
 
-	/// Detailed info about the connection.  This will include the
+	/// Detailed info about the session that failed.
+	/// SteamNetConnectionInfo_t::m_identityRemote indicates who this session
+	/// was with.
 	SteamNetConnectionInfo_t m_info;
 };
 
 #pragma pack(pop)
 
-//
+// Global accessors
-// Global accessor
+// Using standalone lib
-//
+#ifdef STEAMNETWORKINGSOCKETS_STANDALONELIB
 
-#if defined( STEAMNETWORKINGSOCKETS_PARTNER )
+	// Standalone lib.
+	static_assert( STEAMNETWORKINGMESSAGES_INTERFACE_VERSION[25] == '2', "Version mismatch" );
+	STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingMessages *SteamNetworkingMessages_LibV2();
+	inline ISteamNetworkingMessages *SteamNetworkingMessages_Lib() { return SteamNetworkingMessages_LibV2(); }
 
-	// Standalone lib.  Use different symbol name, so that we can dynamically switch between steamclient.dll
+	// If running in context of steam, we also define a gameserver instance.
-	// and the standalone lib
+	#ifdef STEAMNETWORKINGSOCKETS_STEAM
-	STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingMessages *SteamNetworkingMessages_Lib();
+		STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingMessages *SteamGameServerNetworkingMessages_LibV2();
-	STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingMessages *SteamGameServerNetworkingMessages_Lib();
+		inline ISteamNetworkingMessages *SteamGameServerNetworkingMessages_Lib() { return SteamGameServerNetworkingMessages_LibV2(); }
-	inline ISteamNetworkingMessages *SteamNetworkingMessages() { return SteamNetworkingMessages_Lib(); }
+	#endif
-	inline ISteamNetworkingMessages *SteamGameServerNetworkingMessages() { return SteamGameServerNetworkingMessages_Lib(); }
 
-#elif defined( STEAMNETWORKINGSOCKETS_OPENSOURCE )
+	#ifndef STEAMNETWORKINGSOCKETS_STEAMAPI
+		inline ISteamNetworkingMessages *SteamNetworkingMessages() { return SteamNetworkingMessages_LibV2(); }
+		#ifdef STEAMNETWORKINGSOCKETS_STEAM
+			inline ISteamNetworkingMessages *SteamGameServerNetworkingMessages() { return SteamGameServerNetworkingMessages_LibV2(); }
+		#endif
+	#endif
+#endif
 
-	// Opensource GameNetworkingSockets
+// Using Steamworks SDK
-	STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingMessages *SteamNetworkingMessages();
+#ifdef STEAMNETWORKINGSOCKETS_STEAMAPI
-
-#else
 
 	// Steamworks SDK
-	inline ISteamNetworkingMessages *SteamNetworkingMessages();
+	STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamNetworkingMessages *, SteamNetworkingMessages_SteamAPI, STEAMNETWORKINGMESSAGES_INTERFACE_VERSION );
-	STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamNetworkingMessages *, SteamNetworkingMessages, STEAMNETWORKINGMESSAGES_VERSION );
+	STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamNetworkingMessages *, SteamGameServerNetworkingMessages_SteamAPI, STEAMNETWORKINGMESSAGES_INTERFACE_VERSION );
-	inline ISteamNetworkingMessages *SteamGameServerNetworkingMessages();
+
-	STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamNetworkingMessages *, SteamGameServerNetworkingMessages, STEAMNETWORKINGMESSAGES_VERSION );
+	#ifndef STEAMNETWORKINGSOCKETS_STANDALONELIB
+		inline ISteamNetworkingMessages *SteamNetworkingMessages() { return SteamNetworkingMessages_SteamAPI(); }
+		inline ISteamNetworkingMessages *SteamGameServerNetworkingMessages() { return SteamGameServerNetworkingMessages_SteamAPI(); }
+	#endif
 #endif
 
 #endif // ISTEAMNETWORKINGMESSAGES

sdk_includes/isteamnetworkingsockets.h

@@ -2,16 +2,19 @@
 
 #ifndef ISTEAMNETWORKINGSOCKETS
 #define ISTEAMNETWORKINGSOCKETS
-#ifdef STEAM_WIN32
 #pragma once
-#endif
 
 #include "steamnetworkingtypes.h"
+#include "steam_api_common.h"
 
 struct SteamNetAuthenticationStatus_t;
+
 class ISteamNetworkingConnectionCustomSignaling;
 class ISteamNetworkingCustomSignalingRecvContext;
 
+class ISteamNetworkingConnectionSignaling;
+class ISteamNetworkingSignalingRecvContext;
+
 //-----------------------------------------------------------------------------
 /// Lower level networking API.
 ///
@@ -84,7 +87,7 @@ public:
 	/// setting the options "immediately" after creation.
 	virtual HSteamNetConnection ConnectByIPAddress( const SteamNetworkingIPAddr &address, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0;
 
-	/// Like CreateListenSocketIP, but clients will connect using ConnectP2P
+	/// Like CreateListenSocketIP, but clients will connect using ConnectP2P.
 	///
 	/// nLocalVirtualPort specifies how clients can connect to this socket using
 	/// ConnectP2P.  It's very common for applications to only have one listening socket;
@@ -93,7 +96,16 @@ public:
 	/// integer (<1000) unique to each listen socket you create.
 	///
 	/// If you use this, you probably want to call ISteamNetworkingUtils::InitRelayNetworkAccess()
-	/// when your app initializes
+	/// when your app initializes.
+	///
+	/// If you are listening on a dedicated servers in known data center,
+	/// then you can listen using this function instead of CreateHostedDedicatedServerListenSocket,
+	/// to allow clients to connect without a ticket.  Any user that owns
+	/// the app and is signed into Steam will be able to attempt to connect to
+	/// your server.  Also, a connection attempt may require the client to
+	/// be connected to Steam, which is one more moving part that may fail.  When
+	/// tickets are used, then once a ticket is obtained, a client can connect to
+	/// your server even if they got disconnected from Steam or Steam is offline.
 	///
 	/// If you need to set any initial config options, pass them here.  See
 	/// SteamNetworkingConfigValue_t for more about why this is preferable to
@@ -107,6 +119,10 @@ public:
 	/// If you need to set any initial config options, pass them here.  See
 	/// SteamNetworkingConfigValue_t for more about why this is preferable to
 	/// setting the options "immediately" after creation.
+	///
+	/// To use your own signaling service, see:
+	/// - ConnectP2PCustomSignaling
+	/// - k_ESteamNetworkingConfig_Callback_CreateConnectionSignaling
 	virtual HSteamNetConnection ConnectP2P( const SteamNetworkingIdentity &identityRemote, int nRemoteVirtualPort, int nOptions, const SteamNetworkingConfigValue_t *pOptions ) = 0;
 
 	/// Accept an incoming connection that has been received on a listen socket.
@@ -437,11 +453,11 @@ public:
 	/// other connections.)
 	virtual int ReceiveMessagesOnPollGroup( HSteamNetPollGroup hPollGroup, SteamNetworkingMessage_t **ppOutMessages, int nMaxMessages ) = 0; 
 
-#ifdef STEAMNETWORKINGSOCKETS_ENABLE_SDR
-
 	//
 	// Clients connecting to dedicated servers hosted in a data center,
-	// using central-authority-granted tickets.
+	// using tickets issued by your game coordinator.  If you are not
+	// issuing your own tickets to restrict who can attempt to connect
+	// to your server, then you won't use these functions.
 	//
 
 	/// Call this when you receive a ticket from your backend / matchmaking system.  Puts the
@@ -459,7 +475,10 @@ public:
 	virtual int FindRelayAuthTicketForServer( const SteamNetworkingIdentity &identityGameServer, int nRemoteVirtualPort, SteamDatagramRelayAuthTicket *pOutParsedTicket ) = 0;
 
 	/// Client call to connect to a server hosted in a Valve data center, on the specified virtual
-	/// port.  You must have placed a ticket for this server into the cache, or else this connect attempt will fail!
+	/// port.  You must have placed a ticket for this server into the cache, or else this connect
+	/// attempt will fail!  If you are not issuing your own tickets, then to connect to a dedicated
+	/// server via SDR in auto-ticket mode, use ConnectP2P.  (The server must be configured to allow
+	/// this type of connection by listening using CreateListenSocketP2P.)
 	///
 	/// You may wonder why tickets are stored in a cache, instead of simply being passed as an argument
 	/// here.  The reason is to make reconnection to a gameserver robust, even if the client computer loses
@@ -522,7 +541,11 @@ public:
 	/// will be determined by the SDR_LISTEN_PORT environment variable.  If a UDP port is not
 	/// configured, this call will fail.
 	///
-	/// Note that this call MUST be made through the SteamGameServerNetworkingSockets() interface
+	/// This call MUST be made through the SteamGameServerNetworkingSockets() interface.
+	/// 
+	/// This function should be used when you are using the ticket generator library
+	/// to issue your own tickets.  Clients connecting to the server on this virtual
+	/// port will need a ticket, and they must connect using ConnectToHostedDedicatedServer.
 	///
 	/// If you need to set any initial config options, pass them here.  See
 	/// SteamNetworkingConfigValue_t for more about why this is preferable to
@@ -560,7 +583,6 @@ public:
 	/// NOTE: The routing blob returned here is not encrypted.  Send it to your backend
 	///       and don't share it directly with clients.
 	virtual EResult GetGameCoordinatorServerLogin( SteamDatagramGameCoordinatorServerLogin *pLoginInfo, int *pcbSignedBlob, void *pBlob ) = 0;
-#endif // #ifndef STEAMNETWORKINGSOCKETS_ENABLE_SDR
 
 
 	//
@@ -585,10 +607,10 @@ public:
 	/// This function will immediately construct a connection in the "connecting"
 	/// state.  Soon after (perhaps before this function returns, perhaps in another thread),
 	/// the connection will begin sending signaling messages by calling
-	/// ISteamNetworkingConnectionCustomSignaling::SendSignal.
+	/// ISteamNetworkingConnectionSignaling::SendSignal.
 	///
 	/// When the remote peer accepts the connection (See
-	/// ISteamNetworkingCustomSignalingRecvContext::OnConnectRequest),
+	/// ISteamNetworkingSignalingRecvContext::OnConnectRequest),
 	/// it will begin sending signaling messages.  When these messages are received,
 	/// you can pass them to the connection using ReceivedP2PCustomSignal.
 	///
@@ -614,7 +636,7 @@ public:
 	///
 	/// - If the signal is associated with existing connection, it is dealt
 	///   with immediately.  If any replies need to be sent, they will be
-	///   dispatched using the ISteamNetworkingConnectionCustomSignaling
+	///   dispatched using the ISteamNetworkingConnectionSignaling
 	///   associated with the connection.
 	/// - If the message represents a connection request (and the request
 	///   is not redundant for an existing connection), a new connection
@@ -664,29 +686,40 @@ protected:
 };
 #define STEAMNETWORKINGSOCKETS_INTERFACE_VERSION "SteamNetworkingSockets009"
 
-// Global accessor.
+// Global accessors
-#if defined( STEAMNETWORKINGSOCKETS_PARTNER )
+// Using standalone lib
+#ifdef STEAMNETWORKINGSOCKETS_STANDALONELIB
 
-	// Standalone lib.  Use different symbol name, so that we can dynamically switch between steamclient.dll
+	// Standalone lib.
-	// and the standalone lib
+	static_assert( STEAMNETWORKINGSOCKETS_INTERFACE_VERSION[24] == '9', "Version mismatch" );
-	STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingSockets *SteamNetworkingSockets_Lib();
+	STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingSockets *SteamNetworkingSockets_LibV9();
-	STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingSockets *SteamGameServerNetworkingSockets_Lib();
+	inline ISteamNetworkingSockets *SteamNetworkingSockets_Lib() { return SteamNetworkingSockets_LibV9(); }
-	inline ISteamNetworkingSockets *SteamNetworkingSockets() { return SteamNetworkingSockets_Lib(); }
-	inline ISteamNetworkingSockets *SteamGameServerNetworkingSockets() { return SteamGameServerNetworkingSockets_Lib(); }
 
-#elif defined( STEAMNETWORKINGSOCKETS_OPENSOURCE ) || defined( STEAMNETWORKINGSOCKETS_STREAMINGCLIENT )
+	// If running in context of steam, we also define a gameserver instance.
+	#ifdef STEAMNETWORKINGSOCKETS_STEAM
+		STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingSockets *SteamGameServerNetworkingSockets_LibV9();
+		inline ISteamNetworkingSockets *SteamGameServerNetworkingSockets_Lib() { return SteamGameServerNetworkingSockets_LibV9(); }
+	#endif
 
-	// Opensource GameNetworkingSockets
+	#ifndef STEAMNETWORKINGSOCKETS_STEAMAPI
-	STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingSockets *SteamNetworkingSockets();
+		inline ISteamNetworkingSockets *SteamNetworkingSockets() { return SteamNetworkingSockets_LibV9(); }
-
+		#ifdef STEAMNETWORKINGSOCKETS_STEAM
-#else
+			inline ISteamNetworkingSockets *SteamGameServerNetworkingSockets() { return SteamGameServerNetworkingSockets_LibV9(); }
-#ifndef NETWORKSOCKETS_DLL
+		#endif
-	// Steamworks SDK
+	#endif
-	inline ISteamNetworkingSockets *SteamNetworkingSockets();
-	STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamNetworkingSockets *, SteamNetworkingSockets, STEAMNETWORKINGSOCKETS_INTERFACE_VERSION );
-	inline ISteamNetworkingSockets *SteamGameServerNetworkingSockets();
-	STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamNetworkingSockets *, SteamGameServerNetworkingSockets, STEAMNETWORKINGSOCKETS_INTERFACE_VERSION );
 #endif
+
+// Using Steamworks SDK
+#ifdef STEAMNETWORKINGSOCKETS_STEAMAPI
+
+	// Steamworks SDK
+	STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamNetworkingSockets *, SteamNetworkingSockets_SteamAPI, STEAMNETWORKINGSOCKETS_INTERFACE_VERSION );
+	STEAM_DEFINE_GAMESERVER_INTERFACE_ACCESSOR( ISteamNetworkingSockets *, SteamGameServerNetworkingSockets_SteamAPI, STEAMNETWORKINGSOCKETS_INTERFACE_VERSION );
+
+	#ifndef STEAMNETWORKINGSOCKETS_STANDALONELIB
+		inline ISteamNetworkingSockets *SteamNetworkingSockets() { return SteamNetworkingSockets_SteamAPI(); }
+		inline ISteamNetworkingSockets *SteamGameServerNetworkingSockets() { return SteamGameServerNetworkingSockets_SteamAPI(); }
+	#endif
 #endif
 
 /// Callback struct used to notify when a connection has changed state

sdk_includes/isteamnetworkingutils.h

@@ -6,13 +6,11 @@
 
 #ifndef ISTEAMNETWORKINGUTILS
 #define ISTEAMNETWORKINGUTILS
-#ifdef STEAM_WIN32
 #pragma once
-#endif
-
-#include <stdint.h>
 
 #include "steamnetworkingtypes.h"
+#include "steam_api_common.h"
+
 struct SteamDatagramRelayAuthTicket;
 struct SteamRelayNetworkStatus_t;
 
@@ -46,8 +44,6 @@ public:
 	// Access to Steam Datagram Relay (SDR) network
 	//
 
-#ifdef STEAMNETWORKINGSOCKETS_ENABLE_SDR
-
 	//
 	// Initialization and status check
 	//
@@ -196,7 +192,6 @@ public:
 	/// Get list of all POP IDs.  Returns the number of entries that were filled into
 	/// your list.
 	virtual int GetPOPList( SteamNetworkingPOPID *list, int nListSz ) = 0;
-#endif // #ifdef STEAMNETWORKINGSOCKETS_ENABLE_SDR
 
 	//
 	// Misc
@@ -324,20 +319,23 @@ protected:
 };
 #define STEAMNETWORKINGUTILS_INTERFACE_VERSION "SteamNetworkingUtils003"
 
-// Global accessor.
+// Global accessors
+// Using standalone lib
 #ifdef STEAMNETWORKINGSOCKETS_STANDALONELIB
 
 	// Standalone lib
-	STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingUtils *SteamNetworkingUtils_Lib();
+	static_assert( STEAMNETWORKINGUTILS_INTERFACE_VERSION[22] == '3', "Version mismatch" );
-	inline ISteamNetworkingUtils *SteamNetworkingUtils() { return SteamNetworkingUtils_Lib(); }
+	STEAMNETWORKINGSOCKETS_INTERFACE ISteamNetworkingUtils *SteamNetworkingUtils_LibV3();
+	inline ISteamNetworkingUtils *SteamNetworkingUtils_Lib() { return SteamNetworkingUtils_LibV3(); }
 
-#else
+	#ifndef STEAMNETWORKINGSOCKETS_STEAMAPI
-#ifdef NETWORKSOCKETS_DLL
+		inline ISteamNetworkingUtils *SteamNetworkingUtils() { return SteamNetworkingUtils_LibV3(); }
-#define SteamNetworkingUtils() SteamNetworkingUtilsX()
+	#endif
 #endif
-	// Steamworks SDK
+
-	inline ISteamNetworkingUtils *SteamNetworkingUtils();
+// Using Steamworks SDK
-	STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamNetworkingUtils *, SteamNetworkingUtils,
+#ifdef STEAMNETWORKINGSOCKETS_STEAMAPI
+	STEAM_DEFINE_INTERFACE_ACCESSOR( ISteamNetworkingUtils *, SteamNetworkingUtils_SteamAPI,
 		/* Prefer user version of the interface.  But if it isn't found, then use
 		gameserver one.  Yes, this is a completely terrible hack */
 		SteamInternal_FindOrCreateUserInterface( 0, STEAMNETWORKINGUTILS_INTERFACE_VERSION ) ?
@@ -346,6 +344,10 @@ protected:
 		"global",
 		STEAMNETWORKINGUTILS_INTERFACE_VERSION
 	)
+
+	#ifndef STEAMNETWORKINGSOCKETS_STANDALONELIB
+		inline ISteamNetworkingUtils *SteamNetworkingUtils() { return SteamNetworkingUtils_SteamAPI(); }
+	#endif
 #endif
 
 /// A struct used to describe our readiness to use the relay network.
@@ -406,10 +408,7 @@ private:
 //
 // Internal stuff
 
-#ifdef STEAMNETWORKINGSOCKETS_ENABLE_SDR
 inline void ISteamNetworkingUtils::InitRelayNetworkAccess() { CheckPingDataUpToDate( 1e10f ); }
-#endif
-
 inline bool ISteamNetworkingUtils::SetGlobalConfigValueInt32( ESteamNetworkingConfigValue eValue, int32 val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Global, 0, k_ESteamNetworkingConfig_Int32, &val ); }
 inline bool ISteamNetworkingUtils::SetGlobalConfigValueFloat( ESteamNetworkingConfigValue eValue, float val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Global, 0, k_ESteamNetworkingConfig_Float, &val ); }
 inline bool ISteamNetworkingUtils::SetGlobalConfigValueString( ESteamNetworkingConfigValue eValue, const char *val ) { return SetConfigValue( eValue, k_ESteamNetworkingConfig_Global, 0, k_ESteamNetworkingConfig_String, val ); }
@@ -433,15 +432,27 @@ inline bool ISteamNetworkingUtils::SetConfigValueStruct( const SteamNetworkingCo
 	return SetConfigValue( opt.m_eValue, eScopeType, scopeObj, opt.m_eDataType, pVal );
 }
 
-#if !defined( STEAMNETWORKINGSOCKETS_STATIC_LINK ) && defined( STEAMNETWORKINGSOCKETS_STEAMCLIENT )
+// How to get helper functions.
-inline void SteamNetworkingIPAddr::ToString( char *buf, size_t cbBuf, bool bWithPort ) const { SteamNetworkingUtils()->SteamNetworkingIPAddr_ToString( *this, buf, cbBuf, bWithPort ); }
+#if defined( STEAMNETWORKINGSOCKETS_STATIC_LINK ) || defined( STEAMNETWORKINGSOCKETS_STANDALONELIB )
-inline bool SteamNetworkingIPAddr::ParseString( const char *pszStr ) { return SteamNetworkingUtils()->SteamNetworkingIPAddr_ParseString( this, pszStr ); }
-inline void SteamNetworkingIdentity::ToString( char *buf, size_t cbBuf ) const { SteamNetworkingUtils()->SteamNetworkingIdentity_ToString( *this, buf, cbBuf ); }
-inline bool SteamNetworkingIdentity::ParseString( const char *pszStr ) { return SteamNetworkingUtils()->SteamNetworkingIdentity_ParseString( this, pszStr ); }
-#endif
 
-#ifdef NETWORKSOCKETS_DLL
+	// Call direct to static functions
-#undef SteamNetworkingUtils
+	STEAMNETWORKINGSOCKETS_INTERFACE void SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr *pAddr, char *buf, size_t cbBuf, bool bWithPort );
+	STEAMNETWORKINGSOCKETS_INTERFACE bool SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr );
+	STEAMNETWORKINGSOCKETS_INTERFACE void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity *pIdentity, char *buf, size_t cbBuf );
+	STEAMNETWORKINGSOCKETS_INTERFACE bool SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, size_t sizeofIdentity, const char *pszStr );
+	inline void SteamNetworkingIPAddr::ToString( char *buf, size_t cbBuf, bool bWithPort ) const { SteamNetworkingIPAddr_ToString( this, buf, cbBuf, bWithPort ); }
+	inline bool SteamNetworkingIPAddr::ParseString( const char *pszStr ) { return SteamNetworkingIPAddr_ParseString( this, pszStr ); }
+	inline void SteamNetworkingIdentity::ToString( char *buf, size_t cbBuf ) const { SteamNetworkingIdentity_ToString( this, buf, cbBuf ); }
+	inline bool SteamNetworkingIdentity::ParseString( const char *pszStr ) { return SteamNetworkingIdentity_ParseString( this, sizeof(*this), pszStr ); }
+
+#elif defined( STEAMNETWORKINGSOCKETS_STEAMAPI )
+	// Using steamworks SDK - go through SteamNetworkingUtils()
+	inline void SteamNetworkingIPAddr::ToString( char *buf, size_t cbBuf, bool bWithPort ) const { SteamNetworkingUtils()->SteamNetworkingIPAddr_ToString( *this, buf, cbBuf, bWithPort ); }
+	inline bool SteamNetworkingIPAddr::ParseString( const char *pszStr ) { return SteamNetworkingUtils()->SteamNetworkingIPAddr_ParseString( this, pszStr ); }
+	inline void SteamNetworkingIdentity::ToString( char *buf, size_t cbBuf ) const { SteamNetworkingUtils()->SteamNetworkingIdentity_ToString( *this, buf, cbBuf ); }
+	inline bool SteamNetworkingIdentity::ParseString( const char *pszStr ) { return SteamNetworkingUtils()->SteamNetworkingIdentity_ParseString( this, pszStr ); }
+#else
+	#error "Invalid config"
 #endif
 
 #endif // ISTEAMNETWORKINGUTILS

sdk_includes/isteamremotestorage.h

@@ -241,7 +241,7 @@ class ISteamRemoteStorage
 		// The following functions are only necessary on the Playstation 3. On PC & Mac, the Steam client will handle these operations for you
 		// On Playstation 3, the game controls which files are stored in the cloud, via FilePersist, FileFetch, and FileForget.
 			
-#if defined(_PS3) || defined(_SERVER)
+#if defined(_SERVER)
 		// Connect to Steam and get a list of files in the Cloud - results in a RemoteStorageAppSyncStatusCheck_t callback
 		virtual void GetFileListFromServer() = 0;
 		// Indicate this file should be downloaded in the next sync

sdk_includes/isteamugc.h

@@ -220,6 +220,9 @@ public:
 
 	// Retrieve an individual result after receiving the callback for querying UGC
 	virtual bool GetQueryUGCResult( UGCQueryHandle_t handle, uint32 index, SteamUGCDetails_t *pDetails ) = 0;
+	virtual uint32 GetQueryUGCNumTags( UGCQueryHandle_t handle, uint32 index ) = 0;
+	virtual bool GetQueryUGCTag( UGCQueryHandle_t handle, uint32 index, uint32 indexTag, STEAM_OUT_STRING_COUNT( cchValueSize ) char* pchValue, uint32 cchValueSize ) = 0;
+	virtual bool GetQueryUGCTagDisplayName( UGCQueryHandle_t handle, uint32 index, uint32 indexTag, STEAM_OUT_STRING_COUNT( cchValueSize ) char* pchValue, uint32 cchValueSize ) = 0;
 	virtual bool GetQueryUGCPreviewURL( UGCQueryHandle_t handle, uint32 index, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchURL, uint32 cchURLSize ) = 0;
 	virtual bool GetQueryUGCMetadata( UGCQueryHandle_t handle, uint32 index, STEAM_OUT_STRING_COUNT(cchMetadatasize) char *pchMetadata, uint32 cchMetadatasize ) = 0;
 	virtual bool GetQueryUGCChildren( UGCQueryHandle_t handle, uint32 index, PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries ) = 0;
@@ -227,7 +230,6 @@ public:
 	virtual uint32 GetQueryUGCNumAdditionalPreviews( UGCQueryHandle_t handle, uint32 index ) = 0;
 	virtual bool GetQueryUGCAdditionalPreview( UGCQueryHandle_t handle, uint32 index, uint32 previewIndex, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchURLOrVideoID, uint32 cchURLSize, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchOriginalFileName, uint32 cchOriginalFileNameSize, EItemPreviewType *pPreviewType ) = 0;
 	virtual uint32 GetQueryUGCNumKeyValueTags( UGCQueryHandle_t handle, uint32 index ) = 0;
-
 	virtual bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, STEAM_OUT_STRING_COUNT(cchKeySize) char *pchKey, uint32 cchKeySize, STEAM_OUT_STRING_COUNT(cchValueSize) char *pchValue, uint32 cchValueSize ) = 0;
 
 	// Return the first value matching the pchKey. Note that a key may map to multiple values.  Returns false if there was an error or no matching value was found.
@@ -360,7 +362,7 @@ public:
 	virtual SteamAPICall_t DeleteItem( PublishedFileId_t nPublishedFileID ) = 0;
 };
 
-#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION014"
+#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION015"
 
 #ifndef STEAM_API_EXPORTS
 // Global interface accessor

sdk_includes/isteamugc014.h

@@ -0,0 +1,172 @@
+
+#ifndef ISTEAMUGC014_H
+#define ISTEAMUGC014_H
+#ifdef STEAM_WIN32
+#pragma once
+#endif
+
+class ISteamUGC014
+{
+public:
+
+	// Query UGC associated with a user. Creator app id or consumer app id must be valid and be set to the current running app. unPage should start at 1.
+	virtual UGCQueryHandle_t CreateQueryUserUGCRequest( AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0;
+
+	// Query for all matching UGC. Creator app id or consumer app id must be valid and be set to the current running app. unPage should start at 1.
+	STEAM_FLAT_NAME( CreateQueryAllUGCRequestPage )
+	virtual UGCQueryHandle_t CreateQueryAllUGCRequest( EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage ) = 0;
+
+	// Query for all matching UGC using the new deep paging interface. Creator app id or consumer app id must be valid and be set to the current running app. pchCursor should be set to NULL or "*" to get the first result set.
+	STEAM_FLAT_NAME( CreateQueryAllUGCRequestCursor )
+	virtual UGCQueryHandle_t CreateQueryAllUGCRequest( EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char *pchCursor = NULL ) = 0;
+
+	// Query for the details of the given published file ids (the RequestUGCDetails call is deprecated and replaced with this)
+	virtual UGCQueryHandle_t CreateQueryUGCDetailsRequest( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0;
+
+	// Send the query to Steam
+	STEAM_CALL_RESULT( SteamUGCQueryCompleted_t )
+	virtual SteamAPICall_t SendQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
+
+	// Retrieve an individual result after receiving the callback for querying UGC
+	virtual bool GetQueryUGCResult( UGCQueryHandle_t handle, uint32 index, SteamUGCDetails_t *pDetails ) = 0;
+	virtual bool GetQueryUGCPreviewURL( UGCQueryHandle_t handle, uint32 index, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchURL, uint32 cchURLSize ) = 0;
+	virtual bool GetQueryUGCMetadata( UGCQueryHandle_t handle, uint32 index, STEAM_OUT_STRING_COUNT(cchMetadatasize) char *pchMetadata, uint32 cchMetadatasize ) = 0;
+	virtual bool GetQueryUGCChildren( UGCQueryHandle_t handle, uint32 index, PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries ) = 0;
+	virtual bool GetQueryUGCStatistic( UGCQueryHandle_t handle, uint32 index, EItemStatistic eStatType, uint64 *pStatValue ) = 0;
+	virtual uint32 GetQueryUGCNumAdditionalPreviews( UGCQueryHandle_t handle, uint32 index ) = 0;
+	virtual bool GetQueryUGCAdditionalPreview( UGCQueryHandle_t handle, uint32 index, uint32 previewIndex, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchURLOrVideoID, uint32 cchURLSize, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchOriginalFileName, uint32 cchOriginalFileNameSize, EItemPreviewType *pPreviewType ) = 0;
+	virtual uint32 GetQueryUGCNumKeyValueTags( UGCQueryHandle_t handle, uint32 index ) = 0;
+
+	virtual bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, uint32 keyValueTagIndex, STEAM_OUT_STRING_COUNT(cchKeySize) char *pchKey, uint32 cchKeySize, STEAM_OUT_STRING_COUNT(cchValueSize) char *pchValue, uint32 cchValueSize ) = 0;
+
+	// Return the first value matching the pchKey. Note that a key may map to multiple values.  Returns false if there was an error or no matching value was found.
+	STEAM_FLAT_NAME( GetQueryFirstUGCKeyValueTag )
+	virtual bool GetQueryUGCKeyValueTag( UGCQueryHandle_t handle, uint32 index, const char *pchKey, STEAM_OUT_STRING_COUNT(cchValueSize) char *pchValue, uint32 cchValueSize ) = 0;
+
+	// Release the request to free up memory, after retrieving results
+	virtual bool ReleaseQueryUGCRequest( UGCQueryHandle_t handle ) = 0;
+
+	// Options to set for querying UGC
+	virtual bool AddRequiredTag( UGCQueryHandle_t handle, const char *pTagName ) = 0;
+	virtual bool AddRequiredTagGroup( UGCQueryHandle_t handle, const SteamParamStringArray_t *pTagGroups ) = 0; // match any of the tags in this group
+	virtual bool AddExcludedTag( UGCQueryHandle_t handle, const char *pTagName ) = 0;
+	virtual bool SetReturnOnlyIDs( UGCQueryHandle_t handle, bool bReturnOnlyIDs ) = 0;
+	virtual bool SetReturnKeyValueTags( UGCQueryHandle_t handle, bool bReturnKeyValueTags ) = 0;
+	virtual bool SetReturnLongDescription( UGCQueryHandle_t handle, bool bReturnLongDescription ) = 0;
+	virtual bool SetReturnMetadata( UGCQueryHandle_t handle, bool bReturnMetadata ) = 0;
+	virtual bool SetReturnChildren( UGCQueryHandle_t handle, bool bReturnChildren ) = 0;
+	virtual bool SetReturnAdditionalPreviews( UGCQueryHandle_t handle, bool bReturnAdditionalPreviews ) = 0;
+	virtual bool SetReturnTotalOnly( UGCQueryHandle_t handle, bool bReturnTotalOnly ) = 0;
+	virtual bool SetReturnPlaytimeStats( UGCQueryHandle_t handle, uint32 unDays ) = 0;
+	virtual bool SetLanguage( UGCQueryHandle_t handle, const char *pchLanguage ) = 0;
+	virtual bool SetAllowCachedResponse( UGCQueryHandle_t handle, uint32 unMaxAgeSeconds ) = 0;
+
+	// Options only for querying user UGC
+	virtual bool SetCloudFileNameFilter( UGCQueryHandle_t handle, const char *pMatchCloudFileName ) = 0;
+
+	// Options only for querying all UGC
+	virtual bool SetMatchAnyTag( UGCQueryHandle_t handle, bool bMatchAnyTag ) = 0;
+	virtual bool SetSearchText( UGCQueryHandle_t handle, const char *pSearchText ) = 0;
+	virtual bool SetRankedByTrendDays( UGCQueryHandle_t handle, uint32 unDays ) = 0;
+	virtual bool AddRequiredKeyValueTag( UGCQueryHandle_t handle, const char *pKey, const char *pValue ) = 0;
+
+	// DEPRECATED - Use CreateQueryUGCDetailsRequest call above instead!
+	STEAM_CALL_RESULT( SteamUGCRequestUGCDetailsResult_t )
+	virtual SteamAPICall_t RequestUGCDetails( PublishedFileId_t nPublishedFileID, uint32 unMaxAgeSeconds ) = 0;
+
+	// Steam Workshop Creator API
+	STEAM_CALL_RESULT( CreateItemResult_t )
+	virtual SteamAPICall_t CreateItem( AppId_t nConsumerAppId, EWorkshopFileType eFileType ) = 0; // create new item for this app with no content attached yet
+
+	virtual UGCUpdateHandle_t StartItemUpdate( AppId_t nConsumerAppId, PublishedFileId_t nPublishedFileID ) = 0; // start an UGC item update. Set changed properties before commiting update with CommitItemUpdate()
+
+	virtual bool SetItemTitle( UGCUpdateHandle_t handle, const char *pchTitle ) = 0; // change the title of an UGC item
+	virtual bool SetItemDescription( UGCUpdateHandle_t handle, const char *pchDescription ) = 0; // change the description of an UGC item
+	virtual bool SetItemUpdateLanguage( UGCUpdateHandle_t handle, const char *pchLanguage ) = 0; // specify the language of the title or description that will be set
+	virtual bool SetItemMetadata( UGCUpdateHandle_t handle, const char *pchMetaData ) = 0; // change the metadata of an UGC item (max = k_cchDeveloperMetadataMax)
+	virtual bool SetItemVisibility( UGCUpdateHandle_t handle, ERemoteStoragePublishedFileVisibility eVisibility ) = 0; // change the visibility of an UGC item
+	virtual bool SetItemTags( UGCUpdateHandle_t updateHandle, const SteamParamStringArray_t *pTags ) = 0; // change the tags of an UGC item
+	virtual bool SetItemContent( UGCUpdateHandle_t handle, const char *pszContentFolder ) = 0; // update item content from this local folder
+	virtual bool SetItemPreview( UGCUpdateHandle_t handle, const char *pszPreviewFile ) = 0; //  change preview image file for this item. pszPreviewFile points to local image file, which must be under 1MB in size
+	virtual bool SetAllowLegacyUpload( UGCUpdateHandle_t handle, bool bAllowLegacyUpload ) = 0; //  use legacy upload for a single small file. The parameter to SetItemContent() should either be a directory with one file or the full path to the file.  The file must also be less than 10MB in size.
+	virtual bool RemoveAllItemKeyValueTags( UGCUpdateHandle_t handle ) = 0; // remove all existing key-value tags (you can add new ones via the AddItemKeyValueTag function)
+	virtual bool RemoveItemKeyValueTags( UGCUpdateHandle_t handle, const char *pchKey ) = 0; // remove any existing key-value tags with the specified key
+	virtual bool AddItemKeyValueTag( UGCUpdateHandle_t handle, const char *pchKey, const char *pchValue ) = 0; // add new key-value tags for the item. Note that there can be multiple values for a tag.
+	virtual bool AddItemPreviewFile( UGCUpdateHandle_t handle, const char *pszPreviewFile, EItemPreviewType type ) = 0; //  add preview file for this item. pszPreviewFile points to local file, which must be under 1MB in size
+	virtual bool AddItemPreviewVideo( UGCUpdateHandle_t handle, const char *pszVideoID ) = 0; //  add preview video for this item
+	virtual bool UpdateItemPreviewFile( UGCUpdateHandle_t handle, uint32 index, const char *pszPreviewFile ) = 0; //  updates an existing preview file for this item. pszPreviewFile points to local file, which must be under 1MB in size
+	virtual bool UpdateItemPreviewVideo( UGCUpdateHandle_t handle, uint32 index, const char *pszVideoID ) = 0; //  updates an existing preview video for this item
+	virtual bool RemoveItemPreview( UGCUpdateHandle_t handle, uint32 index ) = 0; // remove a preview by index starting at 0 (previews are sorted)
+
+	STEAM_CALL_RESULT( SubmitItemUpdateResult_t )
+	virtual SteamAPICall_t SubmitItemUpdate( UGCUpdateHandle_t handle, const char *pchChangeNote ) = 0; // commit update process started with StartItemUpdate()
+	virtual EItemUpdateStatus GetItemUpdateProgress( UGCUpdateHandle_t handle, uint64 *punBytesProcessed, uint64* punBytesTotal ) = 0;
+
+	// Steam Workshop Consumer API
+	STEAM_CALL_RESULT( SetUserItemVoteResult_t )
+	virtual SteamAPICall_t SetUserItemVote( PublishedFileId_t nPublishedFileID, bool bVoteUp ) = 0;
+	STEAM_CALL_RESULT( GetUserItemVoteResult_t )
+	virtual SteamAPICall_t GetUserItemVote( PublishedFileId_t nPublishedFileID ) = 0;
+	STEAM_CALL_RESULT( UserFavoriteItemsListChanged_t )
+	virtual SteamAPICall_t AddItemToFavorites( AppId_t nAppId, PublishedFileId_t nPublishedFileID ) = 0;
+	STEAM_CALL_RESULT( UserFavoriteItemsListChanged_t )
+	virtual SteamAPICall_t RemoveItemFromFavorites( AppId_t nAppId, PublishedFileId_t nPublishedFileID ) = 0;
+	STEAM_CALL_RESULT( RemoteStorageSubscribePublishedFileResult_t )
+	virtual SteamAPICall_t SubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // subscribe to this item, will be installed ASAP
+	STEAM_CALL_RESULT( RemoteStorageUnsubscribePublishedFileResult_t )
+	virtual SteamAPICall_t UnsubscribeItem( PublishedFileId_t nPublishedFileID ) = 0; // unsubscribe from this item, will be uninstalled after game quits
+	virtual uint32 GetNumSubscribedItems() = 0; // number of subscribed items 
+	virtual uint32 GetSubscribedItems( PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries ) = 0; // all subscribed item PublishFileIDs
+
+	// get EItemState flags about item on this client
+	virtual uint32 GetItemState( PublishedFileId_t nPublishedFileID ) = 0;
+
+	// get info about currently installed content on disc for items that have k_EItemStateInstalled set
+	// if k_EItemStateLegacyItem is set, pchFolder contains the path to the legacy file itself (not a folder)
+	virtual bool GetItemInstallInfo( PublishedFileId_t nPublishedFileID, uint64 *punSizeOnDisk, STEAM_OUT_STRING_COUNT( cchFolderSize ) char *pchFolder, uint32 cchFolderSize, uint32 *punTimeStamp ) = 0;
+
+	// get info about pending update for items that have k_EItemStateNeedsUpdate set. punBytesTotal will be valid after download started once
+	virtual bool GetItemDownloadInfo( PublishedFileId_t nPublishedFileID, uint64 *punBytesDownloaded, uint64 *punBytesTotal ) = 0;
+		
+	// download new or update already installed item. If function returns true, wait for DownloadItemResult_t. If the item is already installed,
+	// 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;
+
+	// usage tracking
+	STEAM_CALL_RESULT( StartPlaytimeTrackingResult_t )
+	virtual SteamAPICall_t StartPlaytimeTracking( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0;
+	STEAM_CALL_RESULT( StopPlaytimeTrackingResult_t )
+	virtual SteamAPICall_t StopPlaytimeTracking( PublishedFileId_t *pvecPublishedFileID, uint32 unNumPublishedFileIDs ) = 0;
+	STEAM_CALL_RESULT( StopPlaytimeTrackingResult_t )
+	virtual SteamAPICall_t StopPlaytimeTrackingForAllItems() = 0;
+
+	// parent-child relationship or dependency management
+	STEAM_CALL_RESULT( AddUGCDependencyResult_t )
+	virtual SteamAPICall_t AddDependency( PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID ) = 0;
+	STEAM_CALL_RESULT( RemoveUGCDependencyResult_t )
+	virtual SteamAPICall_t RemoveDependency( PublishedFileId_t nParentPublishedFileID, PublishedFileId_t nChildPublishedFileID ) = 0;
+
+	// add/remove app dependence/requirements (usually DLC)
+	STEAM_CALL_RESULT( AddAppDependencyResult_t )
+	virtual SteamAPICall_t AddAppDependency( PublishedFileId_t nPublishedFileID, AppId_t nAppID ) = 0;
+	STEAM_CALL_RESULT( RemoveAppDependencyResult_t )
+	virtual SteamAPICall_t RemoveAppDependency( PublishedFileId_t nPublishedFileID, AppId_t nAppID ) = 0;
+	// request app dependencies. note that whatever callback you register for GetAppDependenciesResult_t may be called multiple times
+	// until all app dependencies have been returned
+	STEAM_CALL_RESULT( GetAppDependenciesResult_t )
+	virtual SteamAPICall_t GetAppDependencies( PublishedFileId_t nPublishedFileID ) = 0;
+	
+	// delete the item without prompting the user
+	STEAM_CALL_RESULT( DeleteItemResult_t )
+	virtual SteamAPICall_t DeleteItem( PublishedFileId_t nPublishedFileID ) = 0;
+};
+
+#endif // ISTEAMUGC014_H

sdk_includes/isteamutils.h

@@ -183,9 +183,12 @@ public:
 	// Returns whether this steam client is a Steam China specific client, vs the global client.
 	virtual bool IsSteamChinaLauncher() = 0;
 
-	// Initializes text filtering.
+	// Initializes text filtering, loading dictionaries for the language the game is running in.
 	//   unFilterOptions are reserved for future use and should be set to 0
-	// Returns false if filtering is unavailable for the language the user is currently running in.
+	// Returns false if filtering is unavailable for the game's language, in which case FilterText() will act as a passthrough.
+	//
+	// Users can customize the text filter behavior in their Steam Account preferences:
+	// https://store.steampowered.com/account/preferences#CommunityContentPreferences
 	virtual bool InitFilterText( uint32 unFilterOptions = 0 ) = 0;
 
 	// Filters the provided input message and places the filtered result into pchOutFilteredText, using legally required filtering and additional filtering based on the context and user settings

sdk_includes/steam_api.h

@@ -134,6 +134,7 @@
 #include "isteamcontroller004.h"
 #include "isteamcontroller005.h"
 #include "isteamcontroller006.h"
+#include "isteamcontroller007.h"
 #include "isteamugc.h"
 #include "isteamugc001.h"
 #include "isteamugc002.h"
@@ -147,6 +148,7 @@
 #include "isteamugc010.h"
 #include "isteamugc012.h"
 #include "isteamugc013.h"
+#include "isteamugc014.h"
 #include "isteamapplist.h"
 #include "isteamhtmlsurface.h"
 #include "isteamhtmlsurface001.h"
@@ -162,6 +164,7 @@
 #include "isteammasterserverupdater.h"
 #include "isteamunifiedmessages.h"
 #include "isteaminput.h"
+#include "isteaminput001.h"
 #include "isteamremoteplay.h"
 #include "isteamnetworkingmessages.h"
 #include "isteamnetworkingsockets.h"

sdk_includes/steam_api_flat.h

@@ -168,6 +168,7 @@ STEAMAPI_API bool SteamAPI_ISteamFriends_IsClanOfficialGameGroup( ISteamFriends*
 STEAMAPI_API int SteamAPI_ISteamFriends_GetNumChatsWithUnreadPriorityMessages( ISteamFriends* self );
 STEAMAPI_API void SteamAPI_ISteamFriends_ActivateGameOverlayRemotePlayTogetherInviteDialog( ISteamFriends* self, uint64_steamid steamIDLobby );
 STEAMAPI_API bool SteamAPI_ISteamFriends_RegisterProtocolInOverlayBrowser( ISteamFriends* self, const char * pchProtocol );
+STEAMAPI_API void SteamAPI_ISteamFriends_ActivateGameOverlayInviteDialogConnectString( ISteamFriends* self, const char * pchConnectString );
 
 // ISteamUtils
 STEAMAPI_API ISteamUtils *SteamAPI_SteamUtils_v010();
@@ -576,6 +577,7 @@ STEAMAPI_API bool SteamAPI_ISteamHTTP_GetHTTPRequestWasTimedOut( ISteamHTTP* sel
 
 // ISteamInput
 STEAMAPI_API ISteamInput *SteamAPI_SteamInput_v001();
+STEAMAPI_API ISteamInput *SteamAPI_SteamInput_v002();
 STEAMAPI_API bool SteamAPI_ISteamInput_Init( ISteamInput* self );
 STEAMAPI_API bool SteamAPI_ISteamInput_Shutdown( ISteamInput* self );
 STEAMAPI_API void SteamAPI_ISteamInput_RunFrame( ISteamInput* self );
@@ -614,6 +616,7 @@ STEAMAPI_API uint32 SteamAPI_ISteamInput_GetRemotePlaySessionID( ISteamInput* se
 
 // ISteamController
 STEAMAPI_API ISteamController *SteamAPI_SteamController_v007();
+STEAMAPI_API ISteamController *SteamAPI_SteamController_v008();
 STEAMAPI_API bool SteamAPI_ISteamController_Init( ISteamController* self );
 STEAMAPI_API bool SteamAPI_ISteamController_Shutdown( ISteamController* self );
 STEAMAPI_API void SteamAPI_ISteamController_RunFrame( ISteamController* self );
@@ -651,13 +654,18 @@ STEAMAPI_API bool SteamAPI_ISteamController_GetControllerBindingRevision( ISteam
 
 // ISteamUGC
 STEAMAPI_API ISteamUGC *SteamAPI_SteamUGC_v014();
+STEAMAPI_API ISteamUGC *SteamAPI_SteamUGC_v015();
 STEAMAPI_API ISteamUGC *SteamAPI_SteamGameServerUGC_v014();
+STEAMAPI_API ISteamUGC *SteamAPI_SteamGameServerUGC_v015();
 STEAMAPI_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryUserUGCRequest( ISteamUGC* self, AccountID_t unAccountID, EUserUGCList eListType, EUGCMatchingUGCType eMatchingUGCType, EUserUGCListSortOrder eSortOrder, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage );
 STEAMAPI_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequestPage( ISteamUGC* self, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage );
 STEAMAPI_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequestCursor( ISteamUGC* self, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char * pchCursor );
 STEAMAPI_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryUGCDetailsRequest( ISteamUGC* self, PublishedFileId_t * pvecPublishedFileID, uint32 unNumPublishedFileIDs );
 STEAMAPI_API SteamAPICall_t SteamAPI_ISteamUGC_SendQueryUGCRequest( ISteamUGC* self, UGCQueryHandle_t handle );
 STEAMAPI_API bool SteamAPI_ISteamUGC_GetQueryUGCResult( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, SteamUGCDetails_t * pDetails );
+STEAMAPI_API uint32 SteamAPI_ISteamUGC_GetQueryUGCNumTags( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index );
+STEAMAPI_API bool SteamAPI_ISteamUGC_GetQueryUGCTag( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, uint32 indexTag, char * pchValue, uint32 cchValueSize );
+STEAMAPI_API bool SteamAPI_ISteamUGC_GetQueryUGCTagDisplayName( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, uint32 indexTag, char * pchValue, uint32 cchValueSize );
 STEAMAPI_API bool SteamAPI_ISteamUGC_GetQueryUGCPreviewURL( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, char * pchURL, uint32 cchURLSize );
 STEAMAPI_API bool SteamAPI_ISteamUGC_GetQueryUGCMetadata( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, char * pchMetadata, uint32 cchMetadatasize );
 STEAMAPI_API bool SteamAPI_ISteamUGC_GetQueryUGCChildren( ISteamUGC* self, UGCQueryHandle_t handle, uint32 index, PublishedFileId_t * pvecPublishedFileID, uint32 cMaxEntries );
@@ -860,7 +868,9 @@ STEAMAPI_API bool SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite( IStea
 
 // ISteamNetworkingMessages
 STEAMAPI_API ISteamNetworkingMessages *SteamAPI_SteamNetworkingMessages_v002();
+STEAMAPI_API ISteamNetworkingMessages *SteamAPI_SteamNetworkingMessages_SteamAPI_v002();
 STEAMAPI_API ISteamNetworkingMessages *SteamAPI_SteamGameServerNetworkingMessages_v002();
+STEAMAPI_API ISteamNetworkingMessages *SteamAPI_SteamGameServerNetworkingMessages_SteamAPI_v002();
 STEAMAPI_API EResult SteamAPI_ISteamNetworkingMessages_SendMessageToUser( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote, const void * pubData, uint32 cubData, int nSendFlags, int nRemoteChannel );
 STEAMAPI_API int SteamAPI_ISteamNetworkingMessages_ReceiveMessagesOnChannel( ISteamNetworkingMessages* self, int nLocalChannel, SteamNetworkingMessage_t ** ppOutMessages, int nMaxMessages );
 STEAMAPI_API bool SteamAPI_ISteamNetworkingMessages_AcceptSessionWithUser( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote );
@@ -869,6 +879,8 @@ STEAMAPI_API bool SteamAPI_ISteamNetworkingMessages_CloseChannelWithUser( ISteam
 STEAMAPI_API ESteamNetworkingConnectionState SteamAPI_ISteamNetworkingMessages_GetSessionConnectionInfo( ISteamNetworkingMessages* self, const SteamNetworkingIdentity & identityRemote, SteamNetConnectionInfo_t * pConnectionInfo, SteamNetworkingQuickConnectionStatus * pQuickStatus );
 
 // ISteamNetworkingSockets
+STEAMAPI_API ISteamNetworkingSockets *SteamAPI_SteamNetworkingSockets_SteamAPI_v009();
+STEAMAPI_API ISteamNetworkingSockets *SteamAPI_SteamGameServerNetworkingSockets_SteamAPI_v009();
 STEAMAPI_API ISteamNetworkingSockets *SteamAPI_SteamNetworkingSockets_v009();
 STEAMAPI_API ISteamNetworkingSockets *SteamAPI_SteamGameServerNetworkingSockets_v009();
 STEAMAPI_API ISteamNetworkingSockets *SteamAPI_SteamNetworkingSockets_v008();
@@ -923,6 +935,7 @@ STEAMAPI_API ISteamNetworkingConnectionCustomSignaling * SteamAPI_ISteamNetworki
 STEAMAPI_API void SteamAPI_ISteamNetworkingCustomSignalingRecvContext_SendRejectionSignal( ISteamNetworkingCustomSignalingRecvContext* self, const SteamNetworkingIdentity & identityPeer, const void * pMsg, int cbMsg );
 
 // ISteamNetworkingUtils
+STEAMAPI_API ISteamNetworkingUtils *SteamAPI_SteamNetworkingUtils_SteamAPI_v003();
 STEAMAPI_API ISteamNetworkingUtils *SteamAPI_SteamNetworkingUtils_v003();
 STEAMAPI_API SteamNetworkingMessage_t * SteamAPI_ISteamNetworkingUtils_AllocateMessage( ISteamNetworkingUtils* self, int cbAllocateBuffer );
 STEAMAPI_API void SteamAPI_ISteamNetworkingUtils_InitRelayNetworkAccess( ISteamNetworkingUtils* self );
@@ -1067,6 +1080,10 @@ STEAMAPI_API void SteamAPI_SteamNetworkingIdentity_SetSteamID64( SteamNetworking
 STEAMAPI_API uint64 SteamAPI_SteamNetworkingIdentity_GetSteamID64( SteamNetworkingIdentity* self );
 STEAMAPI_API bool SteamAPI_SteamNetworkingIdentity_SetXboxPairwiseID( SteamNetworkingIdentity* self, const char * pszString );
 STEAMAPI_API const char * SteamAPI_SteamNetworkingIdentity_GetXboxPairwiseID( SteamNetworkingIdentity* self );
+STEAMAPI_API void SteamAPI_SteamNetworkingIdentity_SetPSNID( SteamNetworkingIdentity* self, uint64 id );
+STEAMAPI_API uint64 SteamAPI_SteamNetworkingIdentity_GetPSNID( SteamNetworkingIdentity* self );
+STEAMAPI_API void SteamAPI_SteamNetworkingIdentity_SetStadiaID( SteamNetworkingIdentity* self, uint64 id );
+STEAMAPI_API uint64 SteamAPI_SteamNetworkingIdentity_GetStadiaID( SteamNetworkingIdentity* self );
 STEAMAPI_API void SteamAPI_SteamNetworkingIdentity_SetIPAddr( SteamNetworkingIdentity* self, const SteamNetworkingIPAddr & addr );
 STEAMAPI_API const SteamNetworkingIPAddr * SteamAPI_SteamNetworkingIdentity_GetIPAddr( SteamNetworkingIdentity* self );
 STEAMAPI_API void SteamAPI_SteamNetworkingIdentity_SetLocalHost( SteamNetworkingIdentity* self );

sdk_includes/steam_gameserver.h

@@ -28,6 +28,12 @@ enum EServerMode
 	eServerModeAuthenticationAndSecure = 3, // Authenticate users, list on the server list and VAC protect clients
 };													
 
+/// Pass to SteamGameServer_Init to indicate that the same UDP port will be used for game traffic
+/// UDP queries.  In this case, Steam will not open up a socket to handle server browser queries,
+/// and you must use ISteamGameServer::HandleIncomingPacket and ISteamGameServer::GetNextOutgoingPacket
+/// to handle packets related to server discovery on your socket.
+#define MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE	((uint16)-1)
+
 // Initialize SteamGameServer client and interface objects, and set server properties which may not be changed.
 //
 // After calling this function, you should set any additional server parameters, and then
@@ -39,12 +45,16 @@ enum EServerMode
 //         This protocol is TCP-based and thus always uses an ephemeral local port.
 //         Older steam client binaries used UDP to talk to Steam, and this argument was useful.
 //         A future version of the SDK will remove this argument.
-// - usGamePort is the port that clients will connect to for gameplay.
+// - unIP will usually be zero.  If you are on a machine with multiple IP addresses, you can pass a non-zero
+//   value here and the relevant sockets will be bound to that IP.  This can be used to ensure that
+//   the IP you desire is the one used in the server browser.
+// - usGamePort is the port that clients will connect to for gameplay.  You will usually open up your
+//   own socket bound to this port.
 // - usQueryPort is the port that will manage server browser related duties and info
 //		pings from clients.  If you pass MASTERSERVERUPDATERPORT_USEGAMESOCKETSHARE for usQueryPort, then it
 //		will use "GameSocketShare" mode, which means that the game is responsible for sending and receiving
 //		UDP packets for the master  server updater. See references to GameSocketShare in isteamgameserver.h.
-// - The version string is usually in the form x.x.x.x, and is used by the master server to detect when the
+// - The version string should be in the form x.x.x.x, and is used by the master server to detect when the
 //		server is out of date.  (Only servers with the latest version will be listed.)
 #ifndef STEAM_API_EXPORTS
 S_API bool SteamGameServer_Init( uint32 unIP, uint16 usSteamPort, uint16 usGamePort, uint16 usQueryPort, EServerMode eServerMode, const char *pchVersionString );

sdk_includes/steamclientpublic.h

@@ -142,6 +142,9 @@ enum EResult
 	k_EResultAccountDeleted = 114,				// account has been deleted
 	k_EResultExistingUserCancelledLicense = 115,	// A license for this already exists, but cancelled
 	k_EResultCommunityCooldown = 116,			// access is denied because of a community cooldown (probably from support profile data resets)
+	k_EResultNoLauncherSpecified = 117,			// No launcher was specified, but a launcher was needed to choose correct realm for operation.
+	k_EResultMustAgreeToSSA = 118,				// User must agree to china SSA or global SSA before login
+	k_EResultLauncherMigrated = 119,			// The specified launcher type is no longer supported; the user should be directed elsewhere
 };
 
 // Error codes for use with the voice functions
@@ -311,7 +314,7 @@ enum EAppType
 	k_EAppType_Beta					= 0x10000,	// this is a beta version of a game
 		
 	k_EAppType_Shortcut				= 0x40000000,	// just a shortcut, client side only
-	k_EAppType_DepotOnly			= 0x80000000,	// placeholder since depots and apps share the same namespace
+	k_EAppType_DepotOnly_DEPRECATED = 0x80000000,	// there shouldn't be any appinfo for depots
 };
 
 
@@ -556,6 +559,7 @@ enum EVRHMDType
 	k_eEVRHMDType_HP_Unknown = 80, // HP unknown HMD
 	k_eEVRHMDType_HP_WindowsMR = 81, // HP Windows MR headset
 	k_eEVRHMDType_HP_Reverb = 82, // HP Reverb Windows MR headset
+	k_eEVRHMDType_HP_ReverbG2 = 1463, // HP Reverb G2 Windows MR headset
 
 	k_eEVRHMDType_Samsung_Unknown = 90, // Samsung unknown HMD
 	k_eEVRHMDType_Samsung_Odyssey = 91, // Samsung Odyssey Windows MR headset

sdk_includes/steamnetworkingtypes.h

@@ -6,26 +6,40 @@
 
 #ifndef STEAMNETWORKINGTYPES
 #define STEAMNETWORKINGTYPES
-#ifdef STEAM_WIN32
 #pragma once
-#endif
 
 #include <string.h>
 #include <stdint.h>
+#include "steamtypes.h"
+#include "steamclientpublic.h"
 
-//----------------------------------------
+//-----------------------------------------------------------------------------
-// SteamNetworkingSockets library config
+// SteamNetworkingSockets config.
-// Compiling in Steam public branch.
+//#define STEAMNETWORKINGSOCKETS_STANDALONELIB // Comment this in to support compiling/linking with the standalone library / gamenetworkingsockets opensource
-#define STEAMNETWORKINGSOCKETS_STEAM
+#define STEAMNETWORKINGSOCKETS_STEAMAPI // Compiling/link with steam_api.h and Steamworks SDK
-#ifdef STEAMNETWORKINGSOCKETS_STATIC_LINK
+//-----------------------------------------------------------------------------
-	#define STEAMNETWORKINGSOCKETS_INTERFACE extern
+
+#if !defined( STEAMNETWORKINGSOCKETS_OPENSOURCE ) && !defined( STEAMNETWORKINGSOCKETS_STREAMINGCLIENT )
+	#define STEAMNETWORKINGSOCKETS_STEAM
+#endif
+#ifdef NN_NINTENDO_SDK // We always static link on Nintendo
+	#define STEAMNETWORKINGSOCKETS_STATIC_LINK
+#endif
+#if defined( STEAMNETWORKINGSOCKETS_STATIC_LINK )
+	#define STEAMNETWORKINGSOCKETS_INTERFACE extern "C"
+#elif defined( STEAMNETWORKINGSOCKETS_FOREXPORT )
+	#ifdef _WIN32
+		#define STEAMNETWORKINGSOCKETS_INTERFACE extern "C" __declspec( dllexport )
+	#else
+		#define STEAMNETWORKINGSOCKETS_INTERFACE extern "C" __attribute__((visibility("default")))
+	#endif
+#else
+	#ifdef _WIN32
+		#define STEAMNETWORKINGSOCKETS_INTERFACE extern "C" __declspec( dllimport )
+	#else
+		#define STEAMNETWORKINGSOCKETS_INTERFACE extern "C"
+	#endif
 #endif
-#define STEAMNETWORKINGSOCKETS_STEAMCLIENT
-#define STEAMNETWORKINGSOCKETS_ENABLE_SDR
-#include "steam_api_common.h"
-// 
-//----------------------------------------
-
 
 #if defined( VALVE_CALLBACK_PACK_SMALL )
 #pragma pack( push, 4 )
@@ -195,18 +209,18 @@ struct SteamNetworkingIPAddr
 	/// (This means that you cannot tell if a zero port was explicitly specified.)
 	inline bool ParseString( const char *pszStr );
 
-	union
+	/// RFC4038, section 4.2
-	{
+	struct IPv4MappedAddress {
-		uint8 m_ipv6[ 16 ];
-		#ifndef API_GEN // API generator doesn't understand this.  The bindings will just use the accessors
-		struct // IPv4 "mapped address" (rfc4038 section 4.2)
-		{
 		uint64 m_8zeros;
 		uint16 m_0000;
 		uint16 m_ffff;
 		uint8 m_ip[ 4 ]; // NOTE: As bytes, i.e. network byte order
-		} m_ipv4;
+	};
-		#endif
+
+	union
+	{
+		uint8 m_ipv6[ 16 ];
+		IPv4MappedAddress m_ipv4;
 	};
 	uint16 m_port; // Host byte order
 
@@ -659,6 +673,9 @@ struct SteamNetConnectionInfo_t
 	/// connection type (and peer information), and any name
 	/// given to the connection by the app.  This string is used in various
 	/// internal logging messages.
+	///
+	/// Note that the connection ID *usually* matches the HSteamNetConnection
+	/// handle, but in certain cases with symmetric connections it might not.
 	char m_szConnectionDescription[ k_cchSteamNetworkingMaxConnectionDescription ];
 
 	/// Internal stuff, room to change API easily
@@ -1297,6 +1314,12 @@ enum ESteamNetworkingConfigValue
 	/// See: ISteamNetworkingUtils::SetGlobalCallback_MessagesSessionFailed
 	k_ESteamNetworkingConfig_Callback_MessagesSessionFailed = 205,
 
+	/// [global FnSteamNetworkingSocketsCreateConnectionSignaling] Callback that will
+	/// be invoked when we need to create a signaling object for a connection
+	/// initiated locally.  See: ISteamNetworkingSockets::ConnectP2P,
+	/// ISteamNetworkingMessages.
+	k_ESteamNetworkingConfig_Callback_CreateConnectionSignaling = 206,
+
 	//
 	// P2P settings
 	//
@@ -1600,17 +1623,6 @@ inline const uint8 *SteamNetworkingIdentity::GetGenericBytes( int &cbLen ) const
 inline bool SteamNetworkingIdentity::operator==(const SteamNetworkingIdentity &x ) const { return m_eType == x.m_eType && m_cbSize == x.m_cbSize && memcmp( m_genericBytes, x.m_genericBytes, m_cbSize ) == 0; }
 inline void SteamNetworkingMessage_t::Release() { (*m_pfnRelease)( this ); }
 
-#if defined( STEAMNETWORKINGSOCKETS_STATIC_LINK ) || !defined( STEAMNETWORKINGSOCKETS_STEAMCLIENT )
-STEAMNETWORKINGSOCKETS_INTERFACE void SteamNetworkingIPAddr_ToString( const SteamNetworkingIPAddr *pAddr, char *buf, size_t cbBuf, bool bWithPort );
-STEAMNETWORKINGSOCKETS_INTERFACE bool SteamNetworkingIPAddr_ParseString( SteamNetworkingIPAddr *pAddr, const char *pszStr );
-STEAMNETWORKINGSOCKETS_INTERFACE void SteamNetworkingIdentity_ToString( const SteamNetworkingIdentity *pIdentity, char *buf, size_t cbBuf );
-STEAMNETWORKINGSOCKETS_INTERFACE bool SteamNetworkingIdentity_ParseString( SteamNetworkingIdentity *pIdentity, size_t sizeofIdentity, const char *pszStr );
-inline void SteamNetworkingIPAddr::ToString( char *buf, size_t cbBuf, bool bWithPort ) const { SteamNetworkingIPAddr_ToString( this, buf, cbBuf, bWithPort ); }
-inline bool SteamNetworkingIPAddr::ParseString( const char *pszStr ) { return SteamNetworkingIPAddr_ParseString( this, pszStr ); }
-inline void SteamNetworkingIdentity::ToString( char *buf, size_t cbBuf ) const { SteamNetworkingIdentity_ToString( this, buf, cbBuf ); }
-inline bool SteamNetworkingIdentity::ParseString( const char *pszStr ) { return SteamNetworkingIdentity_ParseString( this, sizeof(*this), pszStr ); }
-#endif
-
 #endif // #ifndef API_GEN
 
 #endif // #ifndef STEAMNETWORKINGTYPES