v1.62

2026-10-10 09:33:04 +08:00 · 2025-03-30 19:29:09 -07:00
parent 1b9765621f
commit 34d9338aa8
47 changed files with 728 additions and 1072 deletions
@@ -9,6 +9,27 @@ Welcome to the Steamworks SDK.  For documentation please see our partner
 website at: http://partner.steamgames.com


+----------------------------------------------------------------
+v1.62 14th March 2025
+----------------------------------------------------------------
+
+ISteamFriends:
+* Removed SetPersonaName() and GetUserRestrictions().
+
+ISteamHTMLSurface:
+* Renamed EMouseCursor to EHTMLMouseCursor, and renamed values to match.
+
+ISteamRemotePlay:
+* Removed BStartRemotePlayTogether() since it's always available when a supported game launches.
+* Added ShowRemotePlayTogetherUI() to show the Remote Play Together UI in the game overlay.
+* Added functions to get remote keyboard and mouse input directly instead of simulating local input: BEnableRemotePlayTogetherDirectInput(), DisableRemotePlayTogetherDirectInput(), GetInput(), SetMouseVisibility(), SetMousePosition(), CreateMouseCursor(), SetMouseCursor().
+
+ISteamUGC:
+* Added SetSubscriptionsLoadOrder() to allow changing the load order.
+* Added SetItemsDisabledLocally() set an item as locally disabled or not.
+* GetNumSubscribedItems() and GetSubscribedItems() also takes an optional boolean to return locally disabled items as well.
+
+
 ----------------------------------------------------------------
 v1.61 8th November 2024
 ----------------------------------------------------------------
@@ -166,11 +166,8 @@ void RunGameLoop( IGameEngine *pGameEngine, const char *pchServerAddress, const
 //-----------------------------------------------------------------------------
 // Purpose: Real main entry point for the program
 //-----------------------------------------------------------------------------
-#ifndef _PS3
-
 static int RealMain( const char *pchCmdLine, HINSTANCE hInstance, int nCmdShow )
-{
-	
+{	
 	if ( SteamAPI_RestartAppIfNecessary( k_uAppIdInvalid ) )
 	{
 		// if Steam is not running or the game wasn't started through Steam, SteamAPI_RestartAppIfNecessary starts the 
@@ -180,8 +177,7 @@ static int RealMain( const char *pchCmdLine, HINSTANCE hInstance, int nCmdShow )
 		// removed steam_appid.txt from the game depot.

 		return EXIT_FAILURE;
-	}
-	
+	}	

 	// Init Steam CEG
 	if ( !Steamworks_InitCEGLibrary() )
@@ -290,7 +286,7 @@ static int RealMain( const char *pchCmdLine, HINSTANCE hInstance, int nCmdShow )
 	// exit
 	return EXIT_SUCCESS;	
 }
-#endif
+

 //-----------------------------------------------------------------------------
 // Purpose: Main entry point for the program -- win32
@@ -7,9 +7,10 @@

 #include "stdafx.h"
 #include "RemoteStorage.h"
-#include "remotestoragesync.h"
+#include "BaseMenu.h"
 #include <assert.h>

+
 #define CLOUDDISP_FONT_HEIGHT 20
 #define CLOUDDISP_COLUMN_WIDTH 600
 #define CLOUDDISP_TEXT_HEIGHT 20
@@ -17,6 +18,7 @@

 #define MESSAGE_FILE_NAME "message.dat"

+extern uint64 g_ulLastReturnKeyTick;

 //-----------------------------------------------------------------------------
 // NOTE
@@ -31,21 +33,12 @@
 //
 //-----------------------------------------------------------------------------

-
-//-----------------------------------------------------------------------------
-// Purpose: CRemoteStorage implementation
-//-----------------------------------------------------------------------------
-
 //-----------------------------------------------------------------------------
 // Purpose: Constructor
 //-----------------------------------------------------------------------------
-CRemoteStorage::CRemoteStorage( IGameEngine *pGameEngine ) : m_pGameEngine( pGameEngine ), m_pRemoteStorageSync(NULL)
+CRemoteStorage::CRemoteStorage( IGameEngine *pGameEngine ) : m_pGameEngine( pGameEngine )
 {
 	m_pRemoteStorageScreen = new CRemoteStorageScreen( pGameEngine );
-
-#ifdef _PS3
-	m_pRemoteStorageSync = new CRemoteStorageSync( pGameEngine );
-#endif
 }


@@ -54,12 +47,6 @@ CRemoteStorage::CRemoteStorage( IGameEngine *pGameEngine ) : m_pGameEngine( pGam
 //-----------------------------------------------------------------------------
 CRemoteStorage::~CRemoteStorage()
 {
-	if ( m_pRemoteStorageSync )
-	{
-		assert( m_pRemoteStorageSync->BFinished() );
-		delete m_pRemoteStorageSync;
-	}
-
 	delete m_pRemoteStorageScreen;
 }

@@ -69,61 +56,7 @@ CRemoteStorage::~CRemoteStorage()
 //-----------------------------------------------------------------------------
 void CRemoteStorage::Show()
 {
-	m_eState = k_ERemoteStorageStateIdle;
-	CheckState();
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Check's if we have finished our current step and should advance to the next
-//
-// NOTE:	These steps are not necessary for platforms where the Steam client is running. On those platforms,
-//			the Steam client will take care of synchronization and m_pRemoteStorageSync will be NULL
-//-----------------------------------------------------------------------------
-void CRemoteStorage::CheckState()
-{
-	switch( m_eState )
-	{
-	default:
-	case k_ERemoteStorageStateIdle:
-		if ( m_pRemoteStorageSync )
-			m_pRemoteStorageSync->SynchronizeToClient();
-
-		// advance to next state
-		m_eState = k_ERemoteStorageStateSyncToClient;
-
-		// fall through
-
-	case k_ERemoteStorageStateSyncToClient:
-		if ( m_pRemoteStorageSync && !m_pRemoteStorageSync->BFinished() )
-			break;
-
-		// advance to next state
-		m_eState = k_ERemoteStorageStateDisplayMessage;
-		m_pRemoteStorageScreen->Show();
-		break;
-
-	case k_ERemoteStorageStateDisplayMessage:
-		if ( !m_pRemoteStorageScreen->BFinished() )
-			break;
-
-		// advance to next state
-		m_eState = k_ERemoteStorageStateSyncToServer;
-		if ( m_pRemoteStorageSync )
-			m_pRemoteStorageSync->SynchronizeToServer();
-
-		// fall through
-
-	case k_ERemoteStorageStateSyncToServer:
-		if ( m_pRemoteStorageSync && !m_pRemoteStorageSync->BFinished() )
-			break;
-
-		// complete. Return to the main menu
-		m_eState = k_ERemoteStorageStateIdle;
-		SpaceWarClient()->SetGameState( k_EClientGameMenu );
-
-		break;
-	}
+	m_pRemoteStorageScreen->Show();
 }


@@ -132,13 +65,9 @@ void CRemoteStorage::CheckState()
 //-----------------------------------------------------------------------------
 void CRemoteStorage::Render()
 {
-	if ( m_pRemoteStorageSync && (m_eState == k_ERemoteStorageStateSyncToClient || m_eState == k_ERemoteStorageStateSyncToServer) )
-		m_pRemoteStorageSync->Render();
-
-	if ( m_eState == k_ERemoteStorageStateDisplayMessage )
-		m_pRemoteStorageScreen->Render();
-
-	CheckState();
+	m_pRemoteStorageScreen->Render();
+	if ( m_pRemoteStorageScreen->BFinished() )
+		SpaceWarClient()->SetGameState( k_EClientGameMenu );
 }


@@ -147,8 +76,6 @@ void CRemoteStorage::Render()
 //-----------------------------------------------------------------------------
 void CRemoteStorage::OnMenuSelection( ERemoteStorageSyncMenuCommand selection )
 {
-	if ( m_pRemoteStorageSync )
-		m_pRemoteStorageSync->OnMenuSelection( selection );
 }


@@ -44,19 +44,7 @@ public:
 	void OnMenuSelection( ERemoteStorageSyncMenuCommand selection );

 private:
-	void CheckState();
-
-	enum ERemoteStorageState
-	{
-		k_ERemoteStorageStateIdle,
-		k_ERemoteStorageStateSyncToClient,
-		k_ERemoteStorageStateDisplayMessage,
-		k_ERemoteStorageStateSyncToServer,
-	};
-
 	IGameEngine *m_pGameEngine;
-	ERemoteStorageState m_eState;
-	IRemoteStorageSync *m_pRemoteStorageSync;
 	CRemoteStorageScreen *m_pRemoteStorageScreen;
 };

@@ -116,8 +116,6 @@ inline T QWordSwap( T dw )
 	return *((T*)&temp);
 }

-#ifndef _PS3
-
 #define LittleInt16( val )	( val )
 #define LittleWord( val )	( val )
 #define LittleInt32( val )	( val )
@@ -125,18 +123,6 @@ inline T QWordSwap( T dw )
 #define LittleQWord( val )	( val )
 #define LittleFloat( val )	( val )

-#else
-
-#define LittleInt16( val )	WordSwap( val )
-#define LittleWord( val )	WordSwap( val )
-#define LittleInt32( val )	DWordSwap( val )
-#define LittleDWord( val )	DWordSwap( val )
-#define LittleQWord( val )	QWordSwap( val )
-#define LittleFloat( val )	DWordSwap( val )
-
-#endif
-
-
 // Leaderboard names
 #define LEADERBOARD_QUICKEST_WIN "Quickest Win"
 #define LEADERBOARD_FEET_TRAVELED "Feet Traveled"
@@ -177,10 +163,6 @@ enum EClientGameState
 	k_EClientLeaderboards,
 	k_EClientFriendsList,
 	k_EClientMinidump,
-	k_EClientConnectingToSteam,
-	k_EClientLinkSteamAccount,
-	k_EClientAutoCreateAccount,
-	k_EClientRetrySteamConnection,
 	k_EClientClanChatRoom,
 	k_EClientWebCallback,
 	k_EClientMusic,
@@ -461,4 +443,4 @@ private:

 #pragma pack( pop )

-#endif // SPACEWAR_H
+#endif // SPACEWAR_H
@@ -8,7 +8,6 @@
 #include "stdafx.h"
 #include "SpaceWarClient.h"
 #include "SpaceWarServer.h"
-#include "connectingmenu.h"
 #include "MainMenu.h"
 #include "QuitMenu.h"
 #include "stdlib.h"
@@ -82,22 +81,8 @@ CSpaceWarClient::CSpaceWarClient( IGameEngine *pGameEngine )
 //-----------------------------------------------------------------------------
 void CSpaceWarClient::Init( IGameEngine *pGameEngine )
 {
-	// On PC/OSX we always know the user has a SteamID and is logged in already,
-	// as Steam enforces this before game launch.  On PS3 however the game must
-	// initiate the logon and we need to check the state here and block the user
-	// while Steam connects.
-	if ( SteamUser()->BLoggedOn() )
-	{
-		m_SteamIDLocalUser = SteamUser()->GetSteamID();
-		m_eGameState = k_EClientGameMenu;
-	}
-#ifdef _PS3
-	else
-	{
-		m_eGameState = k_EClientConnectingToSteam;
-		SteamUser()->LogOn( true );
-	}
-#endif
+	m_SteamIDLocalUser = SteamUser()->GetSteamID();
+	m_eGameState = k_EClientGameMenu;

 	g_pSpaceWarClient = this;
 	m_pGameEngine = pGameEngine;
@@ -149,9 +134,6 @@ void CSpaceWarClient::Init( IGameEngine *pGameEngine )
 	// Initialize main menu
 	m_pMainMenu = new CMainMenu( pGameEngine );

-	// Initialize connecting menu
-	m_pConnectingMenu = new CConnectingMenu( pGameEngine );
-
 	// Initialize pause menu
 	m_pQuitMenu = new CQuitMenu( pGameEngine );

@@ -229,9 +211,6 @@ CSpaceWarClient::~CSpaceWarClient()
 	if ( m_pMainMenu )
 		delete m_pMainMenu;

-	if ( m_pConnectingMenu )
-		delete m_pConnectingMenu;
-
 	if ( m_pQuitMenu ) 
 		delete m_pQuitMenu;

@@ -1383,31 +1362,6 @@ void CSpaceWarClient::OnSteamShutdown( SteamShutdown_t *callback )
 }


-//-----------------------------------------------------------------------------
-// Purpose: Handles notification that we are now connected to Steam
-//-----------------------------------------------------------------------------
-void CSpaceWarClient::OnSteamServersConnected( SteamServersConnected_t *callback )
-{
-	if ( SteamUser()->BLoggedOn() )
-		m_eGameState = k_EClientGameMenu;
-	else
-	{
-		OutputDebugString( "Got SteamServersConnected_t, but not logged on?\n" );
-	}
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Handles notification that we are now connected to Steam
-//-----------------------------------------------------------------------------
-void CSpaceWarClient::OnSteamServersDisconnected( SteamServersDisconnected_t *callback )
-{
-	SetGameState( k_EClientConnectingToSteam );
-	m_pConnectingMenu->OnConnectFailure();
-	OutputDebugString( "Got SteamServersDisconnected_t\n" );
-}
-
-
 //-----------------------------------------------------------------------------
 // Purpose: Handles notification that the Steam overlay is shown/hidden, note, this
 // doesn't mean the overlay will or will not draw, it may still draw when not active.
@@ -1436,18 +1390,6 @@ void CSpaceWarClient::OnGameWebCallback( GameWebCallback_t *callback )
 }


-//-----------------------------------------------------------------------------
-// Purpose: Handles notification that we are failed to connected to Steam
-//-----------------------------------------------------------------------------
-void CSpaceWarClient::OnSteamServerConnectFailure( SteamServerConnectFailure_t *callback )
-{
-	char rgchString[256];
-	sprintf_safe( rgchString, "SteamServerConnectFailure_t: %d\n", callback->m_eResult );
-
-	m_pConnectingMenu->OnConnectFailure();
-}
-
-
 //-----------------------------------------------------------------------------
 // Purpose: Do work that doesn't need to happen every frame
 //-----------------------------------------------------------------------------
@@ -1523,42 +1465,6 @@ void CSpaceWarClient::RunFrame()
 	// Update state for everything
 	switch ( m_eGameState )
 	{
-	case k_EClientConnectingToSteam:
-		m_pStarField->Render();
-		m_pConnectingMenu->RunFrame();
-		// Make sure the Steam Controller is in the correct mode.
-		m_pGameEngine->SetSteamControllerActionSet( eControllerActionSet_MenuControls );
-		break;
-	case k_EClientRetrySteamConnection:
-#ifdef _PS3
-		m_pStarField->Render();
-		SteamUser()->LogOn( true );
-		m_pConnectingMenu->Reset();
-		SetGameState( k_EClientConnectingToSteam );
-#else
-		OutputDebugString( "Invalidate state k_EClientRetrySteamConnection hit on non-PS3 platform" );
-#endif
-		break;
-	case k_EClientLinkSteamAccount:
-#ifdef _PS3
-		m_pStarField->Render();
-		SteamUser()->LogOnAndLinkSteamAccountToPSN( true, "jmccaskeybeta", "test123" );
-		m_pConnectingMenu->Reset();
-		SetGameState( k_EClientConnectingToSteam );
-#else
-		OutputDebugString( "Invalidate state k_EClientLinkSteamAccount hit on non-PS3 platform" );
-#endif
-		break;
-	case k_EClientAutoCreateAccount:
-#ifdef _PS3
-		m_pStarField->Render();
-		m_pConnectingMenu->Reset();
-		SteamUser()->LogOnAndCreateNewSteamAccountIfNeeded( true );
-		SetGameState( k_EClientConnectingToSteam );
-#else
-		OutputDebugString( "Invalidate state k_EClientAutoCreateAccount hit on non-PS3 platform" );
-#endif
-		break;
 	case k_EClientGameMenu:
 		m_pStarField->Render();
 		m_pMainMenu->RunFrame();
@@ -1816,7 +1722,7 @@ void CSpaceWarClient::RunFrame()
 		if ( !m_bSentWebOpen )
 		{
 			m_bSentWebOpen = true;
-#ifndef _PS3
+
 			char szCurDir[MAX_PATH];
 			if ( !_getcwd( szCurDir, sizeof(szCurDir) ) )
            {
@@ -1827,7 +1733,6 @@ void CSpaceWarClient::RunFrame()
 			// load the test html page, it just has a steam://gamewebcallback link in it
 			SteamFriends()->ActivateGameOverlayToWebPage( szURL );
 			SetGameState( k_EClientGameMenu );
-#endif
 		}

 		break;
@@ -1983,16 +1888,8 @@ void CSpaceWarClient::RenderTimer()
 void CSpaceWarClient::DrawHUDText()
 {
 	// Padding from the edge of the screen for hud elements
-#ifdef _PS3
-	// Larger padding on PS3, since many of our test HDTVs truncate 
-	// edges of the screen and can't be calibrated properly.
-	const int32 nHudPaddingVertical = 20;
-	const int32 nHudPaddingHorizontal = 35;
-#else
 	const int32 nHudPaddingVertical = 15;
 	const int32 nHudPaddingHorizontal = 15;
-#endif
-

 	const int32 width = m_pGameEngine->GetViewportWidth();
 	const int32 height = m_pGameEngine->GetViewportHeight();
@@ -2157,14 +2054,8 @@ void CSpaceWarClient::DrawInstructions()
 	rect.right = width;

 	char rgchBuffer[256];
-#ifdef _PS3
-	sprintf_safe( rgchBuffer, "Turn Ship Left: 'Left'\nTurn Ship Right: 'Right'\nForward Thrusters: 'R2'\nReverse Thrusters: 'L2'\nFire Photon Beams: 'Cross'" );
-#else
 	sprintf_safe( rgchBuffer, "Turn Ship Left: 'A'\nTurn Ship Right: 'D'\nForward Thrusters: 'W'\nReverse Thrusters: 'S'\nFire Photon Beams: 'Space'" );
-#endif
-
 	m_pGameEngine->BDrawString( m_hInstructionsFont, rect, D3DCOLOR_ARGB( 255, 25, 200, 25 ), TEXTPOS_CENTER|TEXTPOS_VCENTER, rgchBuffer );
-
 	
 	rect.left = 0;
 	rect.right = width;
@@ -497,11 +497,6 @@ private:
 	STEAM_CALLBACK( CSpaceWarClient, OnGameJoinRequested, GameRichPresenceJoinRequested_t );
 	STEAM_CALLBACK( CSpaceWarClient, OnAvatarImageLoaded, AvatarImageLoaded_t );
 	STEAM_CALLBACK( CSpaceWarClient, OnNewUrlLaunchParameters, NewUrlLaunchParameters_t );
-
-	// callbacks for Steam connection state
-	STEAM_CALLBACK( CSpaceWarClient, OnSteamServersConnected, SteamServersConnected_t );
-	STEAM_CALLBACK( CSpaceWarClient, OnSteamServersDisconnected, SteamServersDisconnected_t );
-	STEAM_CALLBACK( CSpaceWarClient, OnSteamServerConnectFailure, SteamServerConnectFailure_t );
 	STEAM_CALLBACK( CSpaceWarClient, OnGameOverlayActivated, GameOverlayActivated_t );
 	
 	// callback when getting the results of a web call
@@ -527,7 +522,7 @@ private:
 			OnDurationControl( pParam );
 		}
 	}
-	CCallResult<CSpaceWarClient, DurationControl_t> m_SteamCallResultDurationControl;
+	CCallResult< CSpaceWarClient, DurationControl_t > m_SteamCallResultDurationControl;

 	// lobby browser menu
 	CLobbyBrowser *m_pLobbyBrowser;
@@ -43,8 +43,7 @@ CStatsAndAchievements::CStatsAndAchievements( IGameEngine *pGameEngine )
 	m_pSteamUserStats( NULL ),
 	m_GameID( SteamUtils()->GetAppID() ),
 	m_CallbackUserStatsStored( this, &CStatsAndAchievements::OnUserStatsStored ),
-	m_CallbackAchievementStored( this, &CStatsAndAchievements::OnAchievementStored ),
-	m_CallbackPS3TrophiesInstalled( this, &CStatsAndAchievements::OnPS3TrophiesInstalled )
+	m_CallbackAchievementStored( this, &CStatsAndAchievements::OnAchievementStored )
 {
 	m_pSteamUser = SteamUser();
 	m_pSteamUserStats = SteamUserStats();
@@ -65,9 +64,6 @@ CStatsAndAchievements::CStatsAndAchievements( IGameEngine *pGameEngine )
 	m_hDisplayFont = pGameEngine->HCreateFont( ACHDISP_FONT_HEIGHT, FW_MEDIUM, false, "Arial" );
 	if ( !m_hDisplayFont )
 		OutputDebugString( "Stats font was not created properly, text won't draw\n" );
-
-	m_bInstalledPS3Trophies = false;
-	m_bStartedPS3TrophyInstall = false;
 }
 #pragma warning( pop )

@@ -77,30 +73,6 @@ CStatsAndAchievements::CStatsAndAchievements( IGameEngine *pGameEngine )
 //-----------------------------------------------------------------------------
 void CStatsAndAchievements::RunFrame()
 {
-	// On PS3, must first install trophies before using the stats system
-	if ( !m_bInstalledPS3Trophies )
-	{
-#ifdef _PS3
-		// PS3 trophies should be installed before writing to disk. Check PS3TrophiesInstalled_t to determine
-		// if trophy installation failed because the machine is out of free HD space.
-		if ( !m_bStartedPS3TrophyInstall )
-		{
-			if ( !m_pSteamUserStats->InstallPS3Trophies() )
-			{
-				OutputDebugString( "Failed to install PS3 trophies. This is a fatal error\n" );
-				exit( 1 );
-			}
-
-			m_bStartedPS3TrophyInstall = true;
-		}
-
-		// wait for PS3TrophiesInstalled_t
-#else
-		m_bInstalledPS3Trophies = true;
-		m_bStartedPS3TrophyInstall = true;
-#endif
-	}
-
 	if ( !m_bStatsValid )
 		LoadUserStats();

@@ -305,7 +277,6 @@ void CStatsAndAchievements::OnUserStatsStored( UserStatsStored_t *pCallback )
 		if ( k_EResultOK == pCallback->m_eResult )
 		{
 			OutputDebugString( "StoreStats - success\n" );
-			SaveUserStatsOnPS3();
 		}
 		else if ( k_EResultInvalidParam == pCallback->m_eResult )
 		{
@@ -351,34 +322,6 @@ void CStatsAndAchievements::OnAchievementStored( UserAchievementStored_t *pCallb
 }


-//-----------------------------------------------------------------------------
-// Purpose: An achievement was stored
-//-----------------------------------------------------------------------------
-void CStatsAndAchievements::OnPS3TrophiesInstalled( PS3TrophiesInstalled_t *pCallback )
-{
-	// we may get callbacks for other games' stats arriving, ignore them	 
-	if ( m_GameID.ToUint64() == pCallback->m_nGameID )
-	{
-		if ( pCallback->m_eResult != k_EResultOK )
-		{
-			// this is a fatal error. Usually the PS3 would have already displayed a fatal error to the user and forced the game to exit. If the system
-			// could not display that error, you should display the appropriate message to the user then exit.
-			char buffer[256];
-			if ( pCallback->m_eResult == k_EResultDiskFull )
-				sprintf_safe( buffer, "Failed to install PS3 trophies because the HD is full (required space=%llu)\n", pCallback->m_ulRequiredDiskSpace );
-			else
-				sprintf_safe( buffer, "Failed to install PS3 trophies (%d)", pCallback->m_eResult );
-
-			buffer[ sizeof(buffer) - 1 ] = 0;
-			OutputDebugString( buffer );
-			exit( 1 );
-		}
-
-		m_bInstalledPS3Trophies = true;
-	}
-}
-
-
 //-----------------------------------------------------------------------------
 // Purpose: Display the user's stats and achievements
 //-----------------------------------------------------------------------------
@@ -585,70 +528,3 @@ void CStatsAndAchievements::DrawInventory( RECT &rect, SteamItemInstanceID_t ite
 	sprintf_safe( rgchBuffer, "%s", pItem->GetLocalizedName().c_str() );
 	m_pGameEngine->BDrawString( m_hDisplayFont, rect, D3DCOLOR_ARGB( 255, 25, 200, 25 ), TEXTPOS_LEFT|TEXTPOS_VCENTER, rgchBuffer );
 }
-
-bool CStatsAndAchievements::LoadUserStatsOnPS3()
-{
-#ifdef _PS3
-	// On PS3, we need to load the user's stats & achievement information from the save container. In this example, we are simply
-	// reading the data from a known location on disk
-	FILE *file = fopen( GetUserSaveDataPath(), "rb" );
-	if ( !file )
-	{
-		// we need to tell Steam that there is no data
-		SteamUserStats()->SetUserStatsData( NULL, 0 );
-		return true;
-	}
-
-	fseek( file, 0, SEEK_END );
-	long nSize = ftell( file );
-	fseek( file, 0, SEEK_SET );
-
-	byte *buffer = new byte[nSize];
-	fread( buffer, 1, nSize, file );
-	fclose( file );
-
-	bool bRet = SteamUserStats()->SetUserStatsData( buffer, nSize );
-	delete [] buffer;
-
-	return bRet;
-#else
-	return true;
-#endif
-}
-
-bool CStatsAndAchievements::SaveUserStatsOnPS3()
-{
-#ifdef _PS3
-	// On PS3, we need to save the user's stats & achievement information into the save container. In this example, we are simply
-	// saving the data to a known location on disk
-
-	// get required buffer size
-	uint32 unSize = 0;
-	if ( !SteamUserStats()->GetUserStatsData( NULL, 0, &unSize ) && unSize == 0 )
-		return false;
-
-	// get data
-	byte *buffer = new byte[unSize];
-	uint32 unWritten = 0;
-	bool bRet = SteamUserStats()->GetUserStatsData( buffer, unSize, &unWritten );
-	if ( bRet )
-	{
-		FILE *file = fopen( GetUserSaveDataPath(), "wb" );
-		if ( file )
-		{
-			bRet = (fwrite( buffer, 1, unWritten, file ) == unWritten);
-			fclose( file );
-		}
-		else
-		{
-			bRet = false;
-		}
-	}
-
-	delete [] buffer;
-
-	return bRet;
-#else
-	return true;
-#endif
-}
@@ -58,7 +58,6 @@ public:

 	STEAM_CALLBACK( CStatsAndAchievements, OnUserStatsStored, UserStatsStored_t, m_CallbackUserStatsStored );
 	STEAM_CALLBACK( CStatsAndAchievements, OnAchievementStored, UserAchievementStored_t, m_CallbackAchievementStored );
-	STEAM_CALLBACK( CStatsAndAchievements, OnPS3TrophiesInstalled, PS3TrophiesInstalled_t, m_CallbackPS3TrophiesInstalled );
 	
 private:

@@ -76,10 +75,6 @@ private:
 	void DrawStatInfo( RECT &rect, const char *pchName, float flValue );
 	void DrawInventory( RECT &rect, SteamItemInstanceID_t itemid );

-	// PS3 specific
-	bool LoadUserStatsOnPS3();
-	bool SaveUserStatsOnPS3();
-
 	// our GameID
 	CGameID m_GameID;

@@ -113,10 +108,6 @@ private:
 	float m_flTotalFeetTraveled;
 	float m_flMaxFeetTraveled;
 	float m_flAverageSpeed;
-
-	// PS3 specific
-	bool m_bStartedPS3TrophyInstall;
-	bool m_bInstalledPS3Trophies;
 };

 #endif // STATS_AND_ACHIEVEMENTS_H
@@ -552,7 +552,6 @@
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
    </ClCompile>
    <ClCompile Include="clanchatroom.cpp" />
-    <ClCompile Include="connectingmenu.cpp" />
    <ClCompile Include="..\glmgr\dx9asmtogl2.cpp">
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
@@ -603,7 +602,6 @@
    <ClCompile Include="QuitMenu.cpp" />
    <ClCompile Include="RemotePlay.cpp" />
    <ClCompile Include="RemoteStorage.cpp" />
-    <ClCompile Include="remotestoragesync.cpp" />
    <ClCompile Include="ServerBrowser.cpp" />
    <ClCompile Include="Ship.cpp" />
    <ClCompile Include="SimpleProtobuf.cpp" />
@@ -208,9 +208,6 @@
    <ClCompile Include="clanchatroom.cpp">
      <Filter>Source Files\Game</Filter>
    </ClCompile>
-    <ClCompile Include="connectingmenu.cpp">
-      <Filter>Source Files\Game</Filter>
-    </ClCompile>
    <ClCompile Include="..\glmgr\dx9asmtogl2.cpp">
      <Filter>Source Files\Game</Filter>
    </ClCompile>
@@ -271,9 +268,6 @@
    <ClCompile Include="RemoteStorage.cpp">
      <Filter>Source Files\Game</Filter>
    </ClCompile>
-    <ClCompile Include="remotestoragesync.cpp">
-      <Filter>Source Files\Game</Filter>
-    </ClCompile>
    <ClCompile Include="ServerBrowser.cpp">
      <Filter>Source Files\Game</Filter>
    </ClCompile>
@@ -85,15 +85,9 @@ typedef unsigned __int64 uint64;
 #include <sys/socket.h>
 #include <netinet/in.h>

-	#if defined(_PS3)
-
-	#include "stdafx_ps3.h"
-
-	#elif defined(OSX)
-	
+#if defined(OSX)	
 	#include <OpenGL/OpenGL.h>
-
-	#endif
+#endif

 #define ARRAYSIZE(A) ( sizeof(A)/sizeof(A[0]) )
 // Need to define some types on POSIX
@@ -2690,7 +2690,7 @@ static int g_translationCounter = 0;
 int D3DToGL::TranslateShader( uint32* code, CUtlBuffer *pBufDisassembledCode, bool *bVertexShader, uint32 options, int32 nShadowDepthSampler, uint32 nCentroidMask, char *debugLabel )
 {
 	CUtlString sLine, sParamName;
-	uint32 i, dwToken, nInstruction, nNumTokensToSkip;
+	uint32 dwToken, nInstruction, nNumTokensToSkip;
 	char buff[256];

 	// obey options
@@ -2728,7 +2728,7 @@ int D3DToGL::TranslateShader( uint32* code, CUtlBuffer *pBufDisassembledCode, bo
 	((char*)m_pBufALUCode->Base())[0] = 0;


-	for ( i=0; i<MAX_SHADER_CONSTANTS; i++ )
+	for ( int i = 0; i < MAX_SHADER_CONSTANTS; i++ )
 	{
 		m_bConstantRegisterDefined[i] = false;
 	}
@@ -2760,11 +2760,11 @@ int D3DToGL::TranslateShader( uint32* code, CUtlBuffer *pBufDisassembledCode, bo
 	m_nHighestRegister = 0;

 	m_bUsedAtomicTempVar = false;
-	for ( int i=0; i < ARRAYSIZE( m_dwSamplerTypes ); i++ )
+	for ( int i = 0; i < ARRAYSIZE( m_dwSamplerTypes ); i++ )
 	{
 		m_dwSamplerTypes[i] = SAMPLER_TYPE_UNUSED;
 	}
-	for ( int i=0; i < ARRAYSIZE( m_DeclaredOutputs ); i++ )
+	for ( int i = 0; i < ARRAYSIZE( m_DeclaredOutputs ); i++ )
 	{
 		m_DeclaredOutputs[i] = UNDECLARED_OUTPUT;
 	}
@@ -4821,14 +4821,14 @@ HRESULT IDirect3DDevice9::FlushSamplers( uint mask )
 	uint samplerHitMask = gl.m_samplerDirtyMask & mask;
 	for( int index = 0; (index < 16) && (samplerHitMask !=0); index++)
 	{
-		uint mask = 1<<index;
-		
+		uint bitMask = 1<<index;
+
 		// only push a sampler to GLM if the sampler is dirty *and* there is a live texture on that TMU
 		// else the values will sit quietly in the d3d sampler side until conditions permit pushing them
-		if ( (samplerHitMask & mask) && (m_textures[index] != NULL) )
+		if ( (samplerHitMask & bitMask) && (m_textures[index] != NULL) )
 		{
 			// clear that dirty bit before you forget...
-			gl.m_samplerDirtyMask &= (~mask);
+			gl.m_samplerDirtyMask &= (~bitMask);
 			
 			// translate from D3D sampler desc
 			D3DSamplerDesc			*dxsamp = &m_samplers[ index ];
@@ -2885,7 +2885,6 @@ void	GLMContext::FlushDrawStates( bool shadersOn )	// shadersOn = true for draw
 	
 	// if drawing FBO has any MSAA attachments, mark them dirty
 	{
-		CGLMTex *tex;
 		for( int att=kAttColor0; att<kAttCount; att++)
 		{
 			if (m_drawingFBO->m_attach[ att ].m_tex)
@@ -958,7 +958,7 @@ void	GLMDisplayDB::PopulateRenderers( void )
 					// decide if this renderer goes in the table.
 					// only insert renderers with at least one active display.
 					
-					bool	selected = !problems;
+					selected = !problems;
 					
 					if (selected)
 					{
@@ -1098,8 +1098,8 @@ void	GLMDisplayDB::PopulateRenderers( void )
 												
 												if (this_vendorIDBytes && this_deviceIDBytes)	// null check...
 												{
-													unsigned short this_vendorIDValue = *this_vendorIDBytes;
-													unsigned short this_deviceIDValue = *this_deviceIDBytes;
+													this_vendorIDValue = *this_vendorIDBytes;
+													this_deviceIDValue = *this_deviceIDBytes;
 													
 													if ( (fields.m_pciVendorID == this_vendorIDValue) && (fields.m_pciDeviceID == this_deviceIDValue) )
 													{
@@ -1484,15 +1484,15 @@ bool	GLMDisplayDB::GetModeInfo( int rendererIndex, int displayIndex, int modeInd
 		GLMDisplayInfo		*dispinfo = (*rendInfo ->m_displays)[displayIndex];	
 		CGDirectDisplayID	cgid = dispinfo->m_info.m_cgDisplayID;
 		
-		CGDisplayModeRef		mode = CGDisplayCopyDisplayMode( cgid );
+		CGDisplayModeRef		cgMode = CGDisplayCopyDisplayMode( cgid );

 		// get the mode number from the mode dict (using system mode numbering, not our sorted numbering)
-		if (mode)
+		if (cgMode)
 		{
 			// grab the width and height, I am unclear on whether this is the displayed FB width or the display device width.
-			int screenWidth=CGDisplayModeGetWidth( mode );
-			int screenHeight=CGDisplayModeGetHeight( mode );
-			int refreshHz=CGDisplayModeGetRefreshRate( mode );
+			int screenWidth=CGDisplayModeGetWidth( cgMode );
+			int screenHeight=CGDisplayModeGetHeight( cgMode );
+			int refreshHz=CGDisplayModeGetRefreshRate( cgMode );
 			
 			GLMPRINTF(( "-D- GLMDisplayDB::GetModeInfo sees mode-index=%d, width=%d, height=%d on CGID %08x (display index %d on rendererindex %d)", 
 				modeIndex,
@@ -39,7 +39,7 @@ public:

 	// Checks if the user is subscribed to the current app through a free weekend
 	// This function will return false for users who have a retail or other type of license
-	// Before using, please ask your Valve technical contact how to package and secure your free weekened
+	// Before using, please ask your Valve technical contact how to package and secure your free weekend
 	virtual bool BIsSubscribedFromFreeWeekend() = 0;

 	// Returns the number of DLC pieces for the running app
@@ -116,21 +116,6 @@ enum
 	k_cwchPersonaNameMax = 32,
 };

-//-----------------------------------------------------------------------------
-// Purpose: user restriction flags
-//-----------------------------------------------------------------------------
-enum EUserRestriction
-{
-	k_nUserRestrictionNone		= 0,	// no known chat/content restriction
-	k_nUserRestrictionUnknown	= 1,	// we don't know yet (user offline)
-	k_nUserRestrictionAnyChat	= 2,	// user is not allowed to (or can't) send/recv any chat
-	k_nUserRestrictionVoiceChat	= 4,	// user is not allowed to (or can't) send/recv voice chat
-	k_nUserRestrictionGroupChat	= 8,	// user is not allowed to (or can't) send/recv group chat
-	k_nUserRestrictionRating	= 16,	// user is too young according to rating in current region
-	k_nUserRestrictionGameInvites	= 32,	// user cannot send or recv game invites (e.g. mobile)
-	k_nUserRestrictionTrading	= 64,	// user cannot participate in trading (console, mobile)
-};
-
 // size limit on chat room or member metadata
 const uint32 k_cubChatMetadataMax = 8192;

@@ -202,16 +187,6 @@ public:
 	// off; it will eventually be free'd or re-allocated
 	virtual const char *GetPersonaName() = 0;

-	// Sets the player name, stores it on the server and publishes the changes to all friends who are online.
-	// Changes take place locally immediately, and a PersonaStateChange_t is posted, presuming success.
-	//
-	// The final results are available through the return value SteamAPICall_t, using SetPersonaNameResponse_t.
-	//
-	// If the name change fails to happen on the server, then an additional global PersonaStateChange_t will be posted
-	// to change the name back, in addition to the SetPersonaNameResponse_t callback.
-	STEAM_CALL_RESULT( SetPersonaNameResponse_t )
-	virtual SteamAPICall_t SetPersonaName( const char *pchPersonaName ) = 0;
-
 	// gets the status of the current user
 	virtual EPersonaState GetPersonaState() = 0;

@@ -357,10 +332,6 @@ public:
 	virtual int GetClanOfficerCount( CSteamID steamIDClan ) = 0;
 	// returns the steamID of a clan officer, by index, of range [0,GetClanOfficerCount)
 	virtual CSteamID GetClanOfficerByIndex( CSteamID steamIDClan, int iOfficer ) = 0;
-	// if current user is chat restricted, he can't send or receive any text/voice chat messages.
-	// the user can't see custom avatars. But the user can be online and send/recv game invites.
-	// a chat restricted user can't add friends or join any groups.
-	virtual uint32 GetUserRestrictions() = 0;

 	// Rich Presence data is automatically shared between friends who are in the same game
 	// Each user has a set of Key/Value pairs
@@ -462,7 +433,7 @@ public:
 	virtual uint32 GetProfileItemPropertyUint( CSteamID steamID, ECommunityProfileItemType itemType, ECommunityProfileItemProperty prop ) = 0;
 };

-#define STEAMFRIENDS_INTERFACE_VERSION "SteamFriends017"
+#define STEAMFRIENDS_INTERFACE_VERSION "SteamFriends018"

 // Global interface accessor
 inline ISteamFriends *SteamFriends();
@@ -547,10 +518,6 @@ struct GameLobbyJoinRequested_t
 	CSteamID m_steamIDLobby;

 	// The friend they did the join via (will be invalid if not directly via a friend)
-	//
-	// On PS3, the friend will be invalid if this was triggered by a PSN invite via the XMB, but
-	// the account type will be console user so you can tell at least that this was from a PSN friend
-	// rather than a Steam friend.
 	CSteamID m_steamIDFriend;		
 };

@@ -698,17 +665,6 @@ struct FriendsEnumerateFollowingList_t
 	int32 m_nTotalResultCount;
 };

-//-----------------------------------------------------------------------------
-// Purpose: reports the result of an attempt to change the user's persona name
-//-----------------------------------------------------------------------------
-struct SetPersonaNameResponse_t
-{
-	enum { k_iCallback = k_iSteamFriendsCallbacks + 47 };
-
-	bool m_bSuccess; // true if name change succeeded completely.
-	bool m_bLocalSuccess; // true if name change was retained locally.  (We might not have been able to communicate with Steam)
-	EResult m_result; // detailed result code
-};

 //-----------------------------------------------------------------------------
 // Purpose: Invoked when the status of unread messages changes
@@ -82,51 +82,53 @@ public:
 	// nDelta is pixels of scroll
 	virtual void MouseWheel( HHTMLBrowser unBrowserHandle, int32 nDelta ) = 0;

-	enum EMouseCursor
+	enum EHTMLMouseCursor
 	{
-		dc_user = 0,
-		dc_none,
-		dc_arrow,
-		dc_ibeam,
-		dc_hourglass,
-		dc_waitarrow,
-		dc_crosshair,
-		dc_up,
-		dc_sizenw,
-		dc_sizese,
-		dc_sizene,
-		dc_sizesw,
-		dc_sizew,
-		dc_sizee,
-		dc_sizen,
-		dc_sizes,
-		dc_sizewe,
-		dc_sizens,
-		dc_sizeall,
-		dc_no,
-		dc_hand,
-		dc_blank, // don't show any custom cursor, just use your default
-		dc_middle_pan,
-		dc_north_pan,
-		dc_north_east_pan,
-		dc_east_pan,
-		dc_south_east_pan,
-		dc_south_pan,
-		dc_south_west_pan,
-		dc_west_pan,
-		dc_north_west_pan,
-		dc_alias,
-		dc_cell,
-		dc_colresize,
-		dc_copycur,
-		dc_verticaltext,
-		dc_rowresize,
-		dc_zoomin,
-		dc_zoomout,
-		dc_help,
-		dc_custom,
+		k_EHTMLMouseCursor_User = 0,
+		k_EHTMLMouseCursor_None,
+		k_EHTMLMouseCursor_Arrow,
+		k_EHTMLMouseCursor_IBeam,
+		k_EHTMLMouseCursor_Hourglass,
+		k_EHTMLMouseCursor_WaitArrow,
+		k_EHTMLMouseCursor_Crosshair,
+		k_EHTMLMouseCursor_Up,
+		k_EHTMLMouseCursor_SizeNW,
+		k_EHTMLMouseCursor_SizeSE,
+		k_EHTMLMouseCursor_SizeNE,
+		k_EHTMLMouseCursor_SizeSW,
+		k_EHTMLMouseCursor_SizeW,
+		k_EHTMLMouseCursor_SizeE,
+		k_EHTMLMouseCursor_SizeN,
+		k_EHTMLMouseCursor_SizeS,
+		k_EHTMLMouseCursor_SizeWE,
+		k_EHTMLMouseCursor_SizeNS,
+		k_EHTMLMouseCursor_SizeAll,
+		k_EHTMLMouseCursor_No,
+		k_EHTMLMouseCursor_Hand,
+		k_EHTMLMouseCursor_Blank, // don't show any custom cursor, just use your default
+		k_EHTMLMouseCursor_MiddlePan,
+		k_EHTMLMouseCursor_NorthPan,
+		k_EHTMLMouseCursor_NorthEastPan,
+		k_EHTMLMouseCursor_EastPan,
+		k_EHTMLMouseCursor_SouthEastPan,
+		k_EHTMLMouseCursor_SouthPan,
+		k_EHTMLMouseCursor_SouthWestPan,
+		k_EHTMLMouseCursor_WestPan,
+		k_EHTMLMouseCursor_NorthWestPan,
+		k_EHTMLMouseCursor_Alias,
+		k_EHTMLMouseCursor_Cell,
+		k_EHTMLMouseCursor_ColResize,
+		k_EHTMLMouseCursor_CopyCur,
+		k_EHTMLMouseCursor_VerticalText,
+		k_EHTMLMouseCursor_RowResize,
+		k_EHTMLMouseCursor_ZoomIn,
+		k_EHTMLMouseCursor_ZoomOut,
+		k_EHTMLMouseCursor_Help,
+		k_EHTMLMouseCursor_Custom,
+		k_EHTMLMouseCursor_SizeNWSE,
+		k_EHTMLMouseCursor_SizeNESW,

-		dc_last, // custom cursors start from this value and up
+		k_EHTMLMouseCursor_last, // custom cursors start from this value and up
 	};

 	enum EHTMLKeyModifiers
@@ -425,7 +427,7 @@ STEAM_CALLBACK_END(7)
 //-----------------------------------------------------------------------------
 STEAM_CALLBACK_BEGIN( HTML_SetCursor_t, k_iSteamHTMLSurfaceCallbacks + 22 )
 STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface 
-STEAM_CALLBACK_MEMBER( 1, uint32, eMouseCursor ) // the EMouseCursor to display
+STEAM_CALLBACK_MEMBER( 1, uint32, eMouseCursor ) // the EHTMLMouseCursor to display
 STEAM_CALLBACK_END(2)


@@ -434,7 +436,7 @@ STEAM_CALLBACK_END(2)
 //-----------------------------------------------------------------------------
 STEAM_CALLBACK_BEGIN( HTML_StatusText_t, k_iSteamHTMLSurfaceCallbacks + 23 )
 STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface 
-STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the EMouseCursor to display
+STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the message text
 STEAM_CALLBACK_END(2)


@@ -443,7 +445,7 @@ STEAM_CALLBACK_END(2)
 //-----------------------------------------------------------------------------
 STEAM_CALLBACK_BEGIN( HTML_ShowToolTip_t, k_iSteamHTMLSurfaceCallbacks + 24 )
 STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface 
-STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the EMouseCursor to display
+STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the tooltip text
 STEAM_CALLBACK_END(2)


@@ -452,7 +454,7 @@ STEAM_CALLBACK_END(2)
 //-----------------------------------------------------------------------------
 STEAM_CALLBACK_BEGIN( HTML_UpdateToolTip_t, k_iSteamHTMLSurfaceCallbacks + 25 )
 STEAM_CALLBACK_MEMBER( 0, HHTMLBrowser, unBrowserHandle ) // the handle of the surface 
-STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the EMouseCursor to display
+STEAM_CALLBACK_MEMBER( 1, const char *, pchMsg ) // the new tooltip text
 STEAM_CALLBACK_END(2)


@@ -249,13 +249,6 @@ public:
 	// link two lobbies for the purposes of checking player compatibility
 	// you must be the lobby owner of both lobbies
 	virtual bool SetLinkedLobby( CSteamID steamIDLobby, CSteamID steamIDLobbyDependent ) = 0;
-
-#ifdef _PS3
-	// changes who the lobby owner is
-	// you must be the lobby owner for this to succeed, and steamIDNewOwner must be in the lobby
-	// after completion, the local user will no longer be the owner
-	virtual void CheckForPSNGameBootInvite( unsigned int iGameBootAttributes  ) = 0;
-#endif
 };
 #define STEAMMATCHMAKING_INTERFACE_VERSION "SteamMatchMaking009"

@@ -887,21 +880,8 @@ struct LobbyCreated_t
 // used by now obsolete RequestFriendsLobbiesResponse_t
 // enum { k_iCallback = k_iSteamMatchmakingCallbacks + 14 };

-
-//-----------------------------------------------------------------------------
-// Purpose: Result of CheckForPSNGameBootInvite
-//			m_eResult == k_EResultOK on success
-//			at this point, the local user may not have finishing joining this lobby;
-//			game code should wait until the subsequent LobbyEnter_t callback is received
-//-----------------------------------------------------------------------------
-struct PSNGameBootInviteResult_t
-{
-	enum { k_iCallback = k_iSteamMatchmakingCallbacks + 15 };
-
-	bool m_bGameBootInviteExists;
-	CSteamID m_steamIDLobby;		// Should be valid if m_bGameBootInviteExists == true
-};
-
+// used by now obsolete PSNGameBootInviteResult_t
+// enum { k_iCallback = k_iSteamMatchmakingCallbacks + 15 };

 //-----------------------------------------------------------------------------
 // Purpose: Result of our request to create a Lobby
@@ -22,10 +22,237 @@ enum ESteamDeviceFormFactor
 	k_ESteamDeviceFormFactorVRHeadset	= 5,
 };

+
 // Steam Remote Play session ID
 typedef uint32 RemotePlaySessionID_t;


+// Steam Remote Play mouse cursor ID
+typedef uint32 RemotePlayCursorID_t;
+
+
+//-----------------------------------------------------------------------------
+// Purpose: The type of input in ERemotePlayInput_t
+//-----------------------------------------------------------------------------
+enum ERemotePlayInputType
+{
+	k_ERemotePlayInputUnknown,
+	k_ERemotePlayInputMouseMotion,
+	k_ERemotePlayInputMouseButtonDown,
+	k_ERemotePlayInputMouseButtonUp,
+	k_ERemotePlayInputMouseWheel,
+	k_ERemotePlayInputKeyDown,
+	k_ERemotePlayInputKeyUp
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Mouse buttons in ERemotePlayInput_t
+//-----------------------------------------------------------------------------
+enum ERemotePlayMouseButton
+{
+	k_ERemotePlayMouseButtonLeft = 0x0001,
+	k_ERemotePlayMouseButtonRight = 0x0002,
+	k_ERemotePlayMouseButtonMiddle = 0x0010,
+	k_ERemotePlayMouseButtonX1 = 0x0020,
+	k_ERemotePlayMouseButtonX2 = 0x0040,
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Mouse wheel direction in ERemotePlayInput_t
+//-----------------------------------------------------------------------------
+enum ERemotePlayMouseWheelDirection
+{
+	k_ERemotePlayMouseWheelUp = 1,
+	k_ERemotePlayMouseWheelDown = 2,
+	k_ERemotePlayMouseWheelLeft = 3,
+	k_ERemotePlayMouseWheelRight = 4,
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Key scancode in ERemotePlayInput_t
+//
+// This is a USB scancode value as defined for the Keyboard/Keypad Page (0x07)
+// This enumeration isn't a complete list, just the most commonly used keys.
+//-----------------------------------------------------------------------------
+enum ERemotePlayScancode
+{
+	k_ERemotePlayScancodeUnknown = 0,
+
+	k_ERemotePlayScancodeA = 4,
+	k_ERemotePlayScancodeB = 5,
+	k_ERemotePlayScancodeC = 6,
+	k_ERemotePlayScancodeD = 7,
+	k_ERemotePlayScancodeE = 8,
+	k_ERemotePlayScancodeF = 9,
+	k_ERemotePlayScancodeG = 10,
+	k_ERemotePlayScancodeH = 11,
+	k_ERemotePlayScancodeI = 12,
+	k_ERemotePlayScancodeJ = 13,
+	k_ERemotePlayScancodeK = 14,
+	k_ERemotePlayScancodeL = 15,
+	k_ERemotePlayScancodeM = 16,
+	k_ERemotePlayScancodeN = 17,
+	k_ERemotePlayScancodeO = 18,
+	k_ERemotePlayScancodeP = 19,
+	k_ERemotePlayScancodeQ = 20,
+	k_ERemotePlayScancodeR = 21,
+	k_ERemotePlayScancodeS = 22,
+	k_ERemotePlayScancodeT = 23,
+	k_ERemotePlayScancodeU = 24,
+	k_ERemotePlayScancodeV = 25,
+	k_ERemotePlayScancodeW = 26,
+	k_ERemotePlayScancodeX = 27,
+	k_ERemotePlayScancodeY = 28,
+	k_ERemotePlayScancodeZ = 29,
+
+	k_ERemotePlayScancode1 = 30,
+	k_ERemotePlayScancode2 = 31,
+	k_ERemotePlayScancode3 = 32,
+	k_ERemotePlayScancode4 = 33,
+	k_ERemotePlayScancode5 = 34,
+	k_ERemotePlayScancode6 = 35,
+	k_ERemotePlayScancode7 = 36,
+	k_ERemotePlayScancode8 = 37,
+	k_ERemotePlayScancode9 = 38,
+	k_ERemotePlayScancode0 = 39,
+
+	k_ERemotePlayScancodeReturn = 40,
+	k_ERemotePlayScancodeEscape = 41,
+	k_ERemotePlayScancodeBackspace = 42,
+	k_ERemotePlayScancodeTab = 43,
+	k_ERemotePlayScancodeSpace = 44,
+	k_ERemotePlayScancodeMinus = 45,
+	k_ERemotePlayScancodeEquals = 46,
+	k_ERemotePlayScancodeLeftBracket = 47,
+	k_ERemotePlayScancodeRightBracket = 48,
+	k_ERemotePlayScancodeBackslash = 49,
+	k_ERemotePlayScancodeSemicolon = 51,
+	k_ERemotePlayScancodeApostrophe = 52,
+	k_ERemotePlayScancodeGrave = 53,
+	k_ERemotePlayScancodeComma = 54,
+	k_ERemotePlayScancodePeriod = 55,
+	k_ERemotePlayScancodeSlash = 56,
+	k_ERemotePlayScancodeCapsLock = 57,
+
+	k_ERemotePlayScancodeF1 = 58,
+	k_ERemotePlayScancodeF2 = 59,
+	k_ERemotePlayScancodeF3 = 60,
+	k_ERemotePlayScancodeF4 = 61,
+	k_ERemotePlayScancodeF5 = 62,
+	k_ERemotePlayScancodeF6 = 63,
+	k_ERemotePlayScancodeF7 = 64,
+	k_ERemotePlayScancodeF8 = 65,
+	k_ERemotePlayScancodeF9 = 66,
+	k_ERemotePlayScancodeF10 = 67,
+	k_ERemotePlayScancodeF11 = 68,
+	k_ERemotePlayScancodeF12 = 69,
+
+	k_ERemotePlayScancodeInsert = 73,
+	k_ERemotePlayScancodeHome = 74,
+	k_ERemotePlayScancodePageUp = 75,
+	k_ERemotePlayScancodeDelete = 76,
+	k_ERemotePlayScancodeEnd = 77,
+	k_ERemotePlayScancodePageDown = 78,
+	k_ERemotePlayScancodeRight = 79,
+	k_ERemotePlayScancodeLeft = 80,
+	k_ERemotePlayScancodeDown = 81,
+	k_ERemotePlayScancodeUp = 82,
+
+	k_ERemotePlayScancodeLeftControl = 224,
+	k_ERemotePlayScancodeLeftShift = 225,
+	k_ERemotePlayScancodeLeftAlt = 226,
+	k_ERemotePlayScancodeLeftGUI = 227, // windows, command (apple), meta
+	k_ERemotePlayScancodeRightControl = 228,
+	k_ERemotePlayScancodeRightShift = 229,
+	k_ERemotePlayScancodeRightALT = 230,
+	k_ERemotePlayScancodeRightGUI = 231, // windows, command (apple), meta
+};
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Key modifier in ERemotePlayInput_t
+//-----------------------------------------------------------------------------
+enum ERemotePlayKeyModifier
+{
+	k_ERemotePlayKeyModifierNone			= 0x0000,
+	k_ERemotePlayKeyModifierLeftShift		= 0x0001,
+	k_ERemotePlayKeyModifierRightShift		= 0x0002,
+	k_ERemotePlayKeyModifierLeftControl		= 0x0040,
+	k_ERemotePlayKeyModifierRightControl	= 0x0080,
+	k_ERemotePlayKeyModifierLeftAlt			= 0x0100,
+	k_ERemotePlayKeyModifierRightAlt		= 0x0200,
+	k_ERemotePlayKeyModifierLeftGUI			= 0x0400,
+	k_ERemotePlayKeyModifierRightGUI		= 0x0800,
+	k_ERemotePlayKeyModifierNumLock			= 0x1000,
+	k_ERemotePlayKeyModifierCapsLock		= 0x2000,
+	k_ERemotePlayKeyModifierMask			= 0xFFFF,
+};
+
+
+#if defined( VALVE_CALLBACK_PACK_SMALL )
+#pragma pack( push, 4 )
+#elif defined( VALVE_CALLBACK_PACK_LARGE )
+#pragma pack( push, 8 )
+#else
+#error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
+#endif
+
+// Mouse motion event data, valid when m_eType is k_ERemotePlayInputMouseMotion
+struct RemotePlayInputMouseMotion_t
+{
+	bool m_bAbsolute;		// True if this is absolute mouse motion and m_flNormalizedX and m_flNormalizedY are valid
+	float m_flNormalizedX;	// The absolute X position of the mouse, normalized to the display, if m_bAbsolute is true
+	float m_flNormalizedY;	// The absolute Y position of the mouse, normalized to the display, if m_bAbsolute is true
+	int m_nDeltaX;			// Relative mouse motion in the X direction
+	int m_nDeltaY;			// Relative mouse motion in the Y direction
+};
+
+// Mouse wheel event data, valid when m_eType is k_ERemotePlayInputMouseWheel
+struct RemotePlayInputMouseWheel_t
+{
+	ERemotePlayMouseWheelDirection m_eDirection;
+	float m_flAmount;		// 1.0f is a single click of the wheel, 120 units on Windows
+};
+
+// Key event data, valid when m_eType is k_ERemotePlayInputKeyDown or k_ERemotePlayInputKeyUp
+struct RemotePlayInputKey_t
+{
+	int m_eScancode;		// Keyboard scancode, common values are defined in ERemotePlayScancode
+	uint32 m_unModifiers;	// Mask of ERemotePlayKeyModifier active for this key event
+	uint32 m_unKeycode;		// UCS-4 character generated by the keypress, or 0 if it wasn't a character key, e.g. Delete or Left Arrow
+};
+
+struct RemotePlayInput_t
+{
+	RemotePlaySessionID_t m_unSessionID;
+	ERemotePlayInputType m_eType;
+
+	union
+	{
+		// Mouse motion event data, valid when m_eType is k_ERemotePlayInputMouseMotion
+		RemotePlayInputMouseMotion_t m_MouseMotion;
+
+		// Mouse button event data, valid when m_eType is k_ERemotePlayInputMouseButtonDown or k_ERemotePlayInputMouseButtonUp
+		ERemotePlayMouseButton m_eMouseButton;
+
+		// Mouse wheel event data, valid when m_eType is k_ERemotePlayInputMouseWheel
+		RemotePlayInputMouseWheel_t m_MouseWheel;
+
+		// Key event data, valid when m_eType is k_ERemotePlayInputKeyDown or k_ERemotePlayInputKeyUp
+		RemotePlayInputKey_t m_Key;
+
+		// Unused space for future use
+		char padding[ 64 - ( sizeof( m_unSessionID ) + sizeof( m_eType ) ) ];
+	};
+};
+//COMPILE_TIME_ASSERT( sizeof( RemotePlayInput_t ) == 64 );
+
+#pragma pack( pop )
+
+
 //-----------------------------------------------------------------------------
 // Purpose: Functions to provide information about Steam Remote Play sessions
 //-----------------------------------------------------------------------------
@@ -52,17 +279,60 @@ public:
 	// This is set to 0x0 if the resolution is not available
 	virtual bool BGetSessionClientResolution( RemotePlaySessionID_t unSessionID, int *pnResolutionX, int *pnResolutionY ) = 0;

-	// Start Remote Play Together and optionally show the UI in the overlay
-	// This returns false if Remote Play Together can't be started or your game is not configured for Remote Play Together
-	virtual bool BStartRemotePlayTogether( bool bShowOverlay = true ) = 0;
+	// Show the Remote Play Together UI in the game overlay
+	// This returns false if your game is not configured for Remote Play Together
+	virtual bool ShowRemotePlayTogetherUI() = 0;

 	// Invite a friend to Remote Play Together, or create a guest invite if steamIDFriend is empty
 	// This will automatically start Remote Play Together if it hasn't already been started
 	// This returns false if the invite can't be sent or your game is not configured for Remote Play Together
 	virtual bool BSendRemotePlayTogetherInvite( CSteamID steamIDFriend ) = 0;
+
+	// Make mouse and keyboard input for Remote Play Together sessions available via GetInput() instead of being merged with local input
+	virtual bool BEnableRemotePlayTogetherDirectInput() = 0;
+
+	// Merge Remote Play Together mouse and keyboard input with local input
+	virtual void DisableRemotePlayTogetherDirectInput() = 0;
+
+	// Get input events from Remote Play Together sessions
+	// This is available after calling BEnableRemotePlayTogetherDirectInput()
+	//
+	// pInput is an array of input events that will be filled in by this function, up to unMaxEvents.
+	// This returns the number of events copied to pInput, or the number of events available if pInput is nullptr.
+	virtual uint32 GetInput( RemotePlayInput_t *pInput, uint32 unMaxEvents ) = 0;
+
+	// Set the mouse cursor visibility for a remote player
+	// This is available after calling BEnableRemotePlayTogetherDirectInput()
+	virtual void SetMouseVisibility( RemotePlaySessionID_t unSessionID, bool bVisible ) = 0;
+
+	// Set the mouse cursor position for a remote player
+	// This is available after calling BEnableRemotePlayTogetherDirectInput()
+	//
+	// This is used to warp the cursor to a specific location and isn't needed during normal event processing.
+	//
+	// The position is normalized relative to the window, where 0,0 is the upper left, and 1,1 is the lower right.
+	virtual void SetMousePosition( RemotePlaySessionID_t unSessionID, float flNormalizedX, float flNormalizedY ) = 0;
+
+	// Create a cursor that can be used with SetMouseCursor()
+	// This is available after calling BEnableRemotePlayTogetherDirectInput()
+	//
+	// Parameters:
+	// nWidth - The width of the cursor, in pixels
+	// nHeight - The height of the cursor, in pixels
+	// nHotX - The X coordinate of the cursor hot spot in pixels, offset from the left of the cursor
+	// nHotY - The Y coordinate of the cursor hot spot in pixels, offset from the top of the cursor
+	// pBGRA - A pointer to the cursor pixels, with the color channels in red, green, blue, alpha order
+	// nPitch - The distance between pixel rows in bytes, defaults to nWidth * 4 
+	virtual RemotePlayCursorID_t CreateMouseCursor( int nWidth, int nHeight, int nHotX, int nHotY, const void *pBGRA, int nPitch = 0 ) = 0;
+
+	// Set the mouse cursor for a remote player
+	// This is available after calling BEnableRemotePlayTogetherDirectInput()
+	//
+	// The cursor ID is a value returned by CreateMouseCursor()
+	virtual void SetMouseCursor( RemotePlaySessionID_t unSessionID, RemotePlayCursorID_t unCursorID ) = 0;
 };

-#define STEAMREMOTEPLAY_INTERFACE_VERSION "STEAMREMOTEPLAY_INTERFACE_VERSION002"
+#define STEAMREMOTEPLAY_INTERFACE_VERSION "STEAMREMOTEPLAY_INTERFACE_VERSION003"

 // Global interface accessor
 inline ISteamRemotePlay *SteamRemotePlay();
@@ -75,7 +345,7 @@ STEAM_DEFINE_USER_INTERFACE_ACCESSOR( ISteamRemotePlay *, SteamRemotePlay, STEAM
 #pragma pack( push, 8 )
 #else
 #error steam_api_common.h should define VALVE_CALLBACK_PACK_xxx
-#endif 
+#endif


 STEAM_CALLBACK_BEGIN( SteamRemotePlaySessionConnected_t, k_iSteamRemotePlayCallbacks + 1 )
@@ -241,7 +241,7 @@ public:
 	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 bool GetQueryUGCAdditionalPreview( UGCQueryHandle_t handle, uint32 index, uint32 previewIndex, STEAM_OUT_STRING_COUNT(cchURLSize) char *pchURLOrVideoID, uint32 cchURLSize, STEAM_OUT_STRING_COUNT(cchOriginalFileNameSize) 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;

@@ -333,8 +333,8 @@ public:
 	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
+	virtual uint32 GetNumSubscribedItems( bool bIncludeLocallyDisabled = false ) = 0; // number of subscribed items 
+	virtual uint32 GetSubscribedItems( PublishedFileId_t* pvecPublishedFileID, uint32 cMaxEntries, bool bIncludeLocallyDisabled = false ) = 0; // all subscribed item PublishFileIDs

 	// get EItemState flags about item on this client
 	virtual uint32 GetItemState( PublishedFileId_t nPublishedFileID ) = 0;
@@ -394,9 +394,15 @@ public:

 	// Return the user's community content descriptor preferences
 	virtual uint32 GetUserContentDescriptorPreferences( EUGCContentDescriptorID *pvecDescriptors, uint32 cMaxEntries ) = 0;
+
+	// Sets whether the item should be disabled locally or not. This means that it will not be returned in GetSubscribedItems() by default.
+	virtual bool SetItemsDisabledLocally( PublishedFileId_t *pvecPublishedFileIDs, uint32 unNumPublishedFileIDs, bool bDisabledLocally ) = 0;
+
+	// Set the local load order for these items. If there are any items not in the given list, they will sort by the time subscribed.
+	virtual bool SetSubscriptionsLoadOrder( PublishedFileId_t *pvecPublishedFileIDs, uint32 unNumPublishedFileIDs ) = 0;
 };

-#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION020"
+#define STEAMUGC_INTERFACE_VERSION "STEAMUGC_INTERFACE_VERSION021"

 // Global interface accessor
 inline ISteamUGC *SteamUGC();
@@ -459,19 +459,6 @@ struct LeaderboardUGCSet_t
 };


-//-----------------------------------------------------------------------------
-// Purpose: callback indicating that PS3 trophies have been installed
-//-----------------------------------------------------------------------------
-struct PS3TrophiesInstalled_t
-{
-	enum { k_iCallback = k_iSteamUserStatsCallbacks + 12 };
-	uint64	m_nGameID;				// Game these stats are for
-	EResult m_eResult;				// The result of the operation
-	uint64 m_ulRequiredDiskSpace;	// If m_eResult is k_EResultDiskFull, will contain the amount of space needed to install trophies
-
-};
-
-
 //-----------------------------------------------------------------------------
 // Purpose: callback indicating global stats have been received.
 //	Returned as a result of RequestGlobalStats()
@@ -282,15 +282,6 @@
      ],
      "struct": "FriendsEnumerateFollowingList_t"
    },
-    {
-      "callback_id": 347,
-      "fields": [
-        { "fieldname":"m_bSuccess", "fieldtype":"bool" },
-        { "fieldname":"m_bLocalSuccess", "fieldtype":"bool" },
-        { "fieldname":"m_result", "fieldtype":"EResult" }
-      ],
-      "struct": "SetPersonaNameResponse_t"
-    },
    {
      "callback_id": 348,
      "fields": [],
@@ -478,14 +469,6 @@
      ],
      "struct": "LobbyCreated_t"
    },
-    {
-      "callback_id": 515,
-      "fields": [
-        { "fieldname":"m_bGameBootInviteExists", "fieldtype":"bool" },
-        { "fieldname":"m_steamIDLobby", "fieldtype":"CSteamID" }
-      ],
-      "struct": "PSNGameBootInviteResult_t"
-    },
    {
      "callback_id": 516,
      "fields": [
@@ -966,15 +949,6 @@
      ],
      "struct": "LeaderboardUGCSet_t"
    },
-    {
-      "callback_id": 1112,
-      "fields": [
-        { "fieldname":"m_nGameID", "fieldtype":"uint64" },
-        { "fieldname":"m_eResult", "fieldtype":"EResult" },
-        { "fieldname":"m_ulRequiredDiskSpace", "fieldtype":"uint64" }
-      ],
-      "struct": "PS3TrophiesInstalled_t"
-    },
    {
      "callback_id": 1112,
      "fields": [
@@ -2486,19 +2460,6 @@
        { "name":"k_EFriendFlagAll", "value":"65535" }
      ]
    },
-    {
-      "enumname": "EUserRestriction",
-      "values": [
-        { "name":"k_nUserRestrictionNone", "value":"0" },
-        { "name":"k_nUserRestrictionUnknown", "value":"1" },
-        { "name":"k_nUserRestrictionAnyChat", "value":"2" },
-        { "name":"k_nUserRestrictionVoiceChat", "value":"4" },
-        { "name":"k_nUserRestrictionGroupChat", "value":"8" },
-        { "name":"k_nUserRestrictionRating", "value":"16" },
-        { "name":"k_nUserRestrictionGameInvites", "value":"32" },
-        { "name":"k_nUserRestrictionTrading", "value":"64" }
-      ]
-    },
    {
      "enumname": "EOverlayToStoreFlag",
      "values": [
@@ -4107,6 +4068,143 @@
        { "name":"k_ESteamDeviceFormFactorVRHeadset", "value":"5" }
      ]
    },
+    {
+      "enumname": "ERemotePlayInputType",
+      "values": [
+        { "name":"k_ERemotePlayInputUnknown", "value":"0" },
+        { "name":"k_ERemotePlayInputMouseMotion", "value":"1" },
+        { "name":"k_ERemotePlayInputMouseButtonDown", "value":"2" },
+        { "name":"k_ERemotePlayInputMouseButtonUp", "value":"3" },
+        { "name":"k_ERemotePlayInputMouseWheel", "value":"4" },
+        { "name":"k_ERemotePlayInputKeyDown", "value":"5" },
+        { "name":"k_ERemotePlayInputKeyUp", "value":"6" }
+      ]
+    },
+    {
+      "enumname": "ERemotePlayMouseButton",
+      "values": [
+        { "name":"k_ERemotePlayMouseButtonLeft", "value":"1" },
+        { "name":"k_ERemotePlayMouseButtonRight", "value":"2" },
+        { "name":"k_ERemotePlayMouseButtonMiddle", "value":"16" },
+        { "name":"k_ERemotePlayMouseButtonX1", "value":"32" },
+        { "name":"k_ERemotePlayMouseButtonX2", "value":"64" }
+      ]
+    },
+    {
+      "enumname": "ERemotePlayMouseWheelDirection",
+      "values": [
+        { "name":"k_ERemotePlayMouseWheelUp", "value":"1" },
+        { "name":"k_ERemotePlayMouseWheelDown", "value":"2" },
+        { "name":"k_ERemotePlayMouseWheelLeft", "value":"3" },
+        { "name":"k_ERemotePlayMouseWheelRight", "value":"4" }
+      ]
+    },
+    {
+      "enumname": "ERemotePlayScancode",
+      "values": [
+        { "name":"k_ERemotePlayScancodeUnknown", "value":"0" },
+        { "name":"k_ERemotePlayScancodeA", "value":"4" },
+        { "name":"k_ERemotePlayScancodeB", "value":"5" },
+        { "name":"k_ERemotePlayScancodeC", "value":"6" },
+        { "name":"k_ERemotePlayScancodeD", "value":"7" },
+        { "name":"k_ERemotePlayScancodeE", "value":"8" },
+        { "name":"k_ERemotePlayScancodeF", "value":"9" },
+        { "name":"k_ERemotePlayScancodeG", "value":"10" },
+        { "name":"k_ERemotePlayScancodeH", "value":"11" },
+        { "name":"k_ERemotePlayScancodeI", "value":"12" },
+        { "name":"k_ERemotePlayScancodeJ", "value":"13" },
+        { "name":"k_ERemotePlayScancodeK", "value":"14" },
+        { "name":"k_ERemotePlayScancodeL", "value":"15" },
+        { "name":"k_ERemotePlayScancodeM", "value":"16" },
+        { "name":"k_ERemotePlayScancodeN", "value":"17" },
+        { "name":"k_ERemotePlayScancodeO", "value":"18" },
+        { "name":"k_ERemotePlayScancodeP", "value":"19" },
+        { "name":"k_ERemotePlayScancodeQ", "value":"20" },
+        { "name":"k_ERemotePlayScancodeR", "value":"21" },
+        { "name":"k_ERemotePlayScancodeS", "value":"22" },
+        { "name":"k_ERemotePlayScancodeT", "value":"23" },
+        { "name":"k_ERemotePlayScancodeU", "value":"24" },
+        { "name":"k_ERemotePlayScancodeV", "value":"25" },
+        { "name":"k_ERemotePlayScancodeW", "value":"26" },
+        { "name":"k_ERemotePlayScancodeX", "value":"27" },
+        { "name":"k_ERemotePlayScancodeY", "value":"28" },
+        { "name":"k_ERemotePlayScancodeZ", "value":"29" },
+        { "name":"k_ERemotePlayScancode1", "value":"30" },
+        { "name":"k_ERemotePlayScancode2", "value":"31" },
+        { "name":"k_ERemotePlayScancode3", "value":"32" },
+        { "name":"k_ERemotePlayScancode4", "value":"33" },
+        { "name":"k_ERemotePlayScancode5", "value":"34" },
+        { "name":"k_ERemotePlayScancode6", "value":"35" },
+        { "name":"k_ERemotePlayScancode7", "value":"36" },
+        { "name":"k_ERemotePlayScancode8", "value":"37" },
+        { "name":"k_ERemotePlayScancode9", "value":"38" },
+        { "name":"k_ERemotePlayScancode0", "value":"39" },
+        { "name":"k_ERemotePlayScancodeReturn", "value":"40" },
+        { "name":"k_ERemotePlayScancodeEscape", "value":"41" },
+        { "name":"k_ERemotePlayScancodeBackspace", "value":"42" },
+        { "name":"k_ERemotePlayScancodeTab", "value":"43" },
+        { "name":"k_ERemotePlayScancodeSpace", "value":"44" },
+        { "name":"k_ERemotePlayScancodeMinus", "value":"45" },
+        { "name":"k_ERemotePlayScancodeEquals", "value":"46" },
+        { "name":"k_ERemotePlayScancodeLeftBracket", "value":"47" },
+        { "name":"k_ERemotePlayScancodeRightBracket", "value":"48" },
+        { "name":"k_ERemotePlayScancodeBackslash", "value":"49" },
+        { "name":"k_ERemotePlayScancodeSemicolon", "value":"51" },
+        { "name":"k_ERemotePlayScancodeApostrophe", "value":"52" },
+        { "name":"k_ERemotePlayScancodeGrave", "value":"53" },
+        { "name":"k_ERemotePlayScancodeComma", "value":"54" },
+        { "name":"k_ERemotePlayScancodePeriod", "value":"55" },
+        { "name":"k_ERemotePlayScancodeSlash", "value":"56" },
+        { "name":"k_ERemotePlayScancodeCapsLock", "value":"57" },
+        { "name":"k_ERemotePlayScancodeF1", "value":"58" },
+        { "name":"k_ERemotePlayScancodeF2", "value":"59" },
+        { "name":"k_ERemotePlayScancodeF3", "value":"60" },
+        { "name":"k_ERemotePlayScancodeF4", "value":"61" },
+        { "name":"k_ERemotePlayScancodeF5", "value":"62" },
+        { "name":"k_ERemotePlayScancodeF6", "value":"63" },
+        { "name":"k_ERemotePlayScancodeF7", "value":"64" },
+        { "name":"k_ERemotePlayScancodeF8", "value":"65" },
+        { "name":"k_ERemotePlayScancodeF9", "value":"66" },
+        { "name":"k_ERemotePlayScancodeF10", "value":"67" },
+        { "name":"k_ERemotePlayScancodeF11", "value":"68" },
+        { "name":"k_ERemotePlayScancodeF12", "value":"69" },
+        { "name":"k_ERemotePlayScancodeInsert", "value":"73" },
+        { "name":"k_ERemotePlayScancodeHome", "value":"74" },
+        { "name":"k_ERemotePlayScancodePageUp", "value":"75" },
+        { "name":"k_ERemotePlayScancodeDelete", "value":"76" },
+        { "name":"k_ERemotePlayScancodeEnd", "value":"77" },
+        { "name":"k_ERemotePlayScancodePageDown", "value":"78" },
+        { "name":"k_ERemotePlayScancodeRight", "value":"79" },
+        { "name":"k_ERemotePlayScancodeLeft", "value":"80" },
+        { "name":"k_ERemotePlayScancodeDown", "value":"81" },
+        { "name":"k_ERemotePlayScancodeUp", "value":"82" },
+        { "name":"k_ERemotePlayScancodeLeftControl", "value":"224" },
+        { "name":"k_ERemotePlayScancodeLeftShift", "value":"225" },
+        { "name":"k_ERemotePlayScancodeLeftAlt", "value":"226" },
+        { "name":"k_ERemotePlayScancodeLeftGUI", "value":"227" },
+        { "name":"k_ERemotePlayScancodeRightControl", "value":"228" },
+        { "name":"k_ERemotePlayScancodeRightShift", "value":"229" },
+        { "name":"k_ERemotePlayScancodeRightALT", "value":"230" },
+        { "name":"k_ERemotePlayScancodeRightGUI", "value":"231" }
+      ]
+    },
+    {
+      "enumname": "ERemotePlayKeyModifier",
+      "values": [
+        { "name":"k_ERemotePlayKeyModifierNone", "value":"0" },
+        { "name":"k_ERemotePlayKeyModifierLeftShift", "value":"1" },
+        { "name":"k_ERemotePlayKeyModifierRightShift", "value":"2" },
+        { "name":"k_ERemotePlayKeyModifierLeftControl", "value":"64" },
+        { "name":"k_ERemotePlayKeyModifierRightControl", "value":"128" },
+        { "name":"k_ERemotePlayKeyModifierLeftAlt", "value":"256" },
+        { "name":"k_ERemotePlayKeyModifierRightAlt", "value":"512" },
+        { "name":"k_ERemotePlayKeyModifierLeftGUI", "value":"1024" },
+        { "name":"k_ERemotePlayKeyModifierRightGUI", "value":"2048" },
+        { "name":"k_ERemotePlayKeyModifierNumLock", "value":"4096" },
+        { "name":"k_ERemotePlayKeyModifierCapsLock", "value":"8192" },
+        { "name":"k_ERemotePlayKeyModifierMask", "value":"65535" }
+      ]
+    },
    {
      "enumname": "ESteamNetworkingAvailability",
      "values": [
@@ -4978,7 +5076,7 @@
        {
          "kind": "user",
          "name": "SteamFriends",
-          "name_flat": "SteamAPI_SteamFriends_v017"
+          "name_flat": "SteamAPI_SteamFriends_v018"
        }
      ],
      "classname": "ISteamFriends",
@@ -4990,15 +5088,6 @@
          "params": [],
          "returntype": "const char *"
        },
-        {
-          "callresult": "SetPersonaNameResponse_t",
-          "methodname": "SetPersonaName",
-          "methodname_flat": "SteamAPI_ISteamFriends_SetPersonaName",
-          "params": [
-            { "paramname":"pchPersonaName", "paramtype":"const char *" }
-          ],
-          "returntype": "SteamAPICall_t"
-        },
        {
          "methodname": "GetPersonaState",
          "methodname_flat": "SteamAPI_ISteamFriends_GetPersonaState",
@@ -5350,12 +5439,6 @@
          "returntype": "CSteamID",
          "returntype_flat": "uint64_steamid"
        },
-        {
-          "methodname": "GetUserRestrictions",
-          "methodname_flat": "SteamAPI_ISteamFriends_GetUserRestrictions",
-          "params": [],
-          "returntype": "uint32"
-        },
        {
          "methodname": "SetRichPresence",
          "methodname_flat": "SteamAPI_ISteamFriends_SetRichPresence",
@@ -5680,7 +5763,7 @@
          "returntype": "uint32"
        }
      ],
-      "version_string": "SteamFriends017"
+      "version_string": "SteamFriends018"
    },
    {
      "accessors": [
@@ -9905,12 +9988,12 @@
        {
          "kind": "user",
          "name": "SteamUGC",
-          "name_flat": "SteamAPI_SteamUGC_v020"
+          "name_flat": "SteamAPI_SteamUGC_v021"
        },
        {
          "kind": "gameserver",
          "name": "SteamGameServerUGC",
-          "name_flat": "SteamAPI_SteamGameServerUGC_v020"
+          "name_flat": "SteamAPI_SteamGameServerUGC_v021"
        }
      ],
      "classname": "ISteamUGC",
@@ -10098,7 +10181,7 @@
            },
            { "paramname":"cchURLSize", "paramtype":"uint32" },
            {
-              "out_string_count": "cchURLSize",
+              "out_string_count": "cchOriginalFileNameSize",
              "paramname": "pchOriginalFileName",
              "paramtype": "char *"
            },
@@ -10689,7 +10772,9 @@
        {
          "methodname": "GetNumSubscribedItems",
          "methodname_flat": "SteamAPI_ISteamUGC_GetNumSubscribedItems",
-          "params": [],
+          "params": [
+            { "paramname":"bIncludeLocallyDisabled", "paramtype":"bool" }
+          ],
          "returntype": "uint32"
        },
        {
@@ -10697,7 +10782,8 @@
          "methodname_flat": "SteamAPI_ISteamUGC_GetSubscribedItems",
          "params": [
            { "paramname":"pvecPublishedFileID", "paramtype":"PublishedFileId_t *" },
-            { "paramname":"cMaxEntries", "paramtype":"uint32" }
+            { "paramname":"cMaxEntries", "paramtype":"uint32" },
+            { "paramname":"bIncludeLocallyDisabled", "paramtype":"bool" }
          ],
          "returntype": "uint32"
        },
@@ -10867,9 +10953,28 @@
            { "paramname":"cMaxEntries", "paramtype":"uint32" }
          ],
          "returntype": "uint32"
+        },
+        {
+          "methodname": "SetItemsDisabledLocally",
+          "methodname_flat": "SteamAPI_ISteamUGC_SetItemsDisabledLocally",
+          "params": [
+            { "paramname":"pvecPublishedFileIDs", "paramtype":"PublishedFileId_t *" },
+            { "paramname":"unNumPublishedFileIDs", "paramtype":"uint32" },
+            { "paramname":"bDisabledLocally", "paramtype":"bool" }
+          ],
+          "returntype": "bool"
+        },
+        {
+          "methodname": "SetSubscriptionsLoadOrder",
+          "methodname_flat": "SteamAPI_ISteamUGC_SetSubscriptionsLoadOrder",
+          "params": [
+            { "paramname":"pvecPublishedFileIDs", "paramtype":"PublishedFileId_t *" },
+            { "paramname":"unNumPublishedFileIDs", "paramtype":"uint32" }
+          ],
+          "returntype": "bool"
        }
      ],
-      "version_string": "STEAMUGC_INTERFACE_VERSION020"
+      "version_string": "STEAMUGC_INTERFACE_VERSION021"
    },
    {
      "accessors": [
@@ -10891,51 +10996,53 @@
          ]
        },
        {
-          "enumname": "EMouseCursor",
-          "fqname": "ISteamHTMLSurface::EMouseCursor",
+          "enumname": "EHTMLMouseCursor",
+          "fqname": "ISteamHTMLSurface::EHTMLMouseCursor",
          "values": [
-            { "name":"dc_user", "value":"0" },
-            { "name":"dc_none", "value":"1" },
-            { "name":"dc_arrow", "value":"2" },
-            { "name":"dc_ibeam", "value":"3" },
-            { "name":"dc_hourglass", "value":"4" },
-            { "name":"dc_waitarrow", "value":"5" },
-            { "name":"dc_crosshair", "value":"6" },
-            { "name":"dc_up", "value":"7" },
-            { "name":"dc_sizenw", "value":"8" },
-            { "name":"dc_sizese", "value":"9" },
-            { "name":"dc_sizene", "value":"10" },
-            { "name":"dc_sizesw", "value":"11" },
-            { "name":"dc_sizew", "value":"12" },
-            { "name":"dc_sizee", "value":"13" },
-            { "name":"dc_sizen", "value":"14" },
-            { "name":"dc_sizes", "value":"15" },
-            { "name":"dc_sizewe", "value":"16" },
-            { "name":"dc_sizens", "value":"17" },
-            { "name":"dc_sizeall", "value":"18" },
-            { "name":"dc_no", "value":"19" },
-            { "name":"dc_hand", "value":"20" },
-            { "name":"dc_blank", "value":"21" },
-            { "name":"dc_middle_pan", "value":"22" },
-            { "name":"dc_north_pan", "value":"23" },
-            { "name":"dc_north_east_pan", "value":"24" },
-            { "name":"dc_east_pan", "value":"25" },
-            { "name":"dc_south_east_pan", "value":"26" },
-            { "name":"dc_south_pan", "value":"27" },
-            { "name":"dc_south_west_pan", "value":"28" },
-            { "name":"dc_west_pan", "value":"29" },
-            { "name":"dc_north_west_pan", "value":"30" },
-            { "name":"dc_alias", "value":"31" },
-            { "name":"dc_cell", "value":"32" },
-            { "name":"dc_colresize", "value":"33" },
-            { "name":"dc_copycur", "value":"34" },
-            { "name":"dc_verticaltext", "value":"35" },
-            { "name":"dc_rowresize", "value":"36" },
-            { "name":"dc_zoomin", "value":"37" },
-            { "name":"dc_zoomout", "value":"38" },
-            { "name":"dc_help", "value":"39" },
-            { "name":"dc_custom", "value":"40" },
-            { "name":"dc_last", "value":"41" }
+            { "name":"k_EHTMLMouseCursor_User", "value":"0" },
+            { "name":"k_EHTMLMouseCursor_None", "value":"1" },
+            { "name":"k_EHTMLMouseCursor_Arrow", "value":"2" },
+            { "name":"k_EHTMLMouseCursor_IBeam", "value":"3" },
+            { "name":"k_EHTMLMouseCursor_Hourglass", "value":"4" },
+            { "name":"k_EHTMLMouseCursor_WaitArrow", "value":"5" },
+            { "name":"k_EHTMLMouseCursor_Crosshair", "value":"6" },
+            { "name":"k_EHTMLMouseCursor_Up", "value":"7" },
+            { "name":"k_EHTMLMouseCursor_SizeNW", "value":"8" },
+            { "name":"k_EHTMLMouseCursor_SizeSE", "value":"9" },
+            { "name":"k_EHTMLMouseCursor_SizeNE", "value":"10" },
+            { "name":"k_EHTMLMouseCursor_SizeSW", "value":"11" },
+            { "name":"k_EHTMLMouseCursor_SizeW", "value":"12" },
+            { "name":"k_EHTMLMouseCursor_SizeE", "value":"13" },
+            { "name":"k_EHTMLMouseCursor_SizeN", "value":"14" },
+            { "name":"k_EHTMLMouseCursor_SizeS", "value":"15" },
+            { "name":"k_EHTMLMouseCursor_SizeWE", "value":"16" },
+            { "name":"k_EHTMLMouseCursor_SizeNS", "value":"17" },
+            { "name":"k_EHTMLMouseCursor_SizeAll", "value":"18" },
+            { "name":"k_EHTMLMouseCursor_No", "value":"19" },
+            { "name":"k_EHTMLMouseCursor_Hand", "value":"20" },
+            { "name":"k_EHTMLMouseCursor_Blank", "value":"21" },
+            { "name":"k_EHTMLMouseCursor_MiddlePan", "value":"22" },
+            { "name":"k_EHTMLMouseCursor_NorthPan", "value":"23" },
+            { "name":"k_EHTMLMouseCursor_NorthEastPan", "value":"24" },
+            { "name":"k_EHTMLMouseCursor_EastPan", "value":"25" },
+            { "name":"k_EHTMLMouseCursor_SouthEastPan", "value":"26" },
+            { "name":"k_EHTMLMouseCursor_SouthPan", "value":"27" },
+            { "name":"k_EHTMLMouseCursor_SouthWestPan", "value":"28" },
+            { "name":"k_EHTMLMouseCursor_WestPan", "value":"29" },
+            { "name":"k_EHTMLMouseCursor_NorthWestPan", "value":"30" },
+            { "name":"k_EHTMLMouseCursor_Alias", "value":"31" },
+            { "name":"k_EHTMLMouseCursor_Cell", "value":"32" },
+            { "name":"k_EHTMLMouseCursor_ColResize", "value":"33" },
+            { "name":"k_EHTMLMouseCursor_CopyCur", "value":"34" },
+            { "name":"k_EHTMLMouseCursor_VerticalText", "value":"35" },
+            { "name":"k_EHTMLMouseCursor_RowResize", "value":"36" },
+            { "name":"k_EHTMLMouseCursor_ZoomIn", "value":"37" },
+            { "name":"k_EHTMLMouseCursor_ZoomOut", "value":"38" },
+            { "name":"k_EHTMLMouseCursor_Help", "value":"39" },
+            { "name":"k_EHTMLMouseCursor_Custom", "value":"40" },
+            { "name":"k_EHTMLMouseCursor_SizeNWSE", "value":"41" },
+            { "name":"k_EHTMLMouseCursor_SizeNESW", "value":"42" },
+            { "name":"k_EHTMLMouseCursor_last", "value":"43" }
          ]
        },
        {
@@ -12083,7 +12190,7 @@
        {
          "kind": "user",
          "name": "SteamRemotePlay",
-          "name_flat": "SteamAPI_SteamRemotePlay_v002"
+          "name_flat": "SteamAPI_SteamRemotePlay_v003"
        }
      ],
      "classname": "ISteamRemotePlay",
@@ -12139,11 +12246,9 @@
          "returntype": "bool"
        },
        {
-          "methodname": "BStartRemotePlayTogether",
-          "methodname_flat": "SteamAPI_ISteamRemotePlay_BStartRemotePlayTogether",
-          "params": [
-            { "paramname":"bShowOverlay", "paramtype":"bool" }
-          ],
+          "methodname": "ShowRemotePlayTogetherUI",
+          "methodname_flat": "SteamAPI_ISteamRemotePlay_ShowRemotePlayTogetherUI",
+          "params": [],
          "returntype": "bool"
        },
        {
@@ -12153,9 +12258,71 @@
            { "paramname":"steamIDFriend", "paramtype":"CSteamID", "paramtype_flat":"uint64_steamid" }
          ],
          "returntype": "bool"
+        },
+        {
+          "methodname": "BEnableRemotePlayTogetherDirectInput",
+          "methodname_flat": "SteamAPI_ISteamRemotePlay_BEnableRemotePlayTogetherDirectInput",
+          "params": [],
+          "returntype": "bool"
+        },
+        {
+          "methodname": "DisableRemotePlayTogetherDirectInput",
+          "methodname_flat": "SteamAPI_ISteamRemotePlay_DisableRemotePlayTogetherDirectInput",
+          "params": [],
+          "returntype": "void"
+        },
+        {
+          "methodname": "GetInput",
+          "methodname_flat": "SteamAPI_ISteamRemotePlay_GetInput",
+          "params": [
+            { "paramname":"pInput", "paramtype":"RemotePlayInput_t *" },
+            { "paramname":"unMaxEvents", "paramtype":"uint32" }
+          ],
+          "returntype": "uint32"
+        },
+        {
+          "methodname": "SetMouseVisibility",
+          "methodname_flat": "SteamAPI_ISteamRemotePlay_SetMouseVisibility",
+          "params": [
+            { "paramname":"unSessionID", "paramtype":"RemotePlaySessionID_t" },
+            { "paramname":"bVisible", "paramtype":"bool" }
+          ],
+          "returntype": "void"
+        },
+        {
+          "methodname": "SetMousePosition",
+          "methodname_flat": "SteamAPI_ISteamRemotePlay_SetMousePosition",
+          "params": [
+            { "paramname":"unSessionID", "paramtype":"RemotePlaySessionID_t" },
+            { "paramname":"flNormalizedX", "paramtype":"float" },
+            { "paramname":"flNormalizedY", "paramtype":"float" }
+          ],
+          "returntype": "void"
+        },
+        {
+          "methodname": "CreateMouseCursor",
+          "methodname_flat": "SteamAPI_ISteamRemotePlay_CreateMouseCursor",
+          "params": [
+            { "paramname":"nWidth", "paramtype":"int" },
+            { "paramname":"nHeight", "paramtype":"int" },
+            { "paramname":"nHotX", "paramtype":"int" },
+            { "paramname":"nHotY", "paramtype":"int" },
+            { "paramname":"pBGRA", "paramtype":"const void *" },
+            { "paramname":"nPitch", "paramtype":"int" }
+          ],
+          "returntype": "RemotePlayCursorID_t"
+        },
+        {
+          "methodname": "SetMouseCursor",
+          "methodname_flat": "SteamAPI_ISteamRemotePlay_SetMouseCursor",
+          "params": [
+            { "paramname":"unSessionID", "paramtype":"RemotePlaySessionID_t" },
+            { "paramname":"unCursorID", "paramtype":"RemotePlayCursorID_t" }
+          ],
+          "returntype": "void"
        }
      ],
-      "version_string": "STEAMREMOTEPLAY_INTERFACE_VERSION002"
+      "version_string": "STEAMREMOTEPLAY_INTERFACE_VERSION003"
    },
    {
      "accessors": [
@@ -13870,6 +14037,39 @@
      ],
      "struct": "SteamItemDetails_t"
    },
+    {
+      "fields": [
+        { "fieldname":"m_bAbsolute", "fieldtype":"bool" },
+        { "fieldname":"m_flNormalizedX", "fieldtype":"float" },
+        { "fieldname":"m_flNormalizedY", "fieldtype":"float" },
+        { "fieldname":"m_nDeltaX", "fieldtype":"int" },
+        { "fieldname":"m_nDeltaY", "fieldtype":"int" }
+      ],
+      "struct": "RemotePlayInputMouseMotion_t"
+    },
+    {
+      "fields": [
+        { "fieldname":"m_eDirection", "fieldtype":"ERemotePlayMouseWheelDirection" },
+        { "fieldname":"m_flAmount", "fieldtype":"float" }
+      ],
+      "struct": "RemotePlayInputMouseWheel_t"
+    },
+    {
+      "fields": [
+        { "fieldname":"m_eScancode", "fieldtype":"int" },
+        { "fieldname":"m_unModifiers", "fieldtype":"uint32" },
+        { "fieldname":"m_unKeycode", "fieldtype":"uint32" }
+      ],
+      "struct": "RemotePlayInputKey_t"
+    },
+    {
+      "fields": [
+        { "fieldname":"m_unSessionID", "fieldtype":"RemotePlaySessionID_t" },
+        { "fieldname":"m_eType", "fieldtype":"ERemotePlayInputType" },
+        { "fieldname":"padding", "fieldtype":"char [56]" }
+      ],
+      "struct": "RemotePlayInput_t"
+    },
    {
      "consts": [
        { "constname":"k_cchMaxString", "consttype":"int", "constval":"48" }
@@ -14405,6 +14605,7 @@
    { "typedef":"SteamInventoryUpdateHandle_t", "type":"unsigned long long" },
    { "typedef":"TimelineEventHandle_t", "type":"unsigned long long" },
    { "typedef":"RemotePlaySessionID_t", "type":"unsigned int" },
+    { "typedef":"RemotePlayCursorID_t", "type":"unsigned int" },
    { "typedef":"FnSteamNetConnectionStatusChanged", "type":"void (*)(SteamNetConnectionStatusChangedCallback_t *)" },
    { "typedef":"FnSteamNetAuthenticationStatusChanged", "type":"void (*)(SteamNetAuthenticationStatus_t *)" },
    { "typedef":"FnSteamRelayNetworkStatusChanged", "type":"void (*)(SteamRelayNetworkStatus_t *)" },
@@ -97,11 +97,10 @@ S_API bool SteamAPI_ISteamUser_BSetDurationControlOnlineState( ISteamUser* self,
 // ISteamFriends

 // A versioned accessor is exported by the library
-S_API ISteamFriends *SteamAPI_SteamFriends_v017();
+S_API ISteamFriends *SteamAPI_SteamFriends_v018();
 // Inline, unversioned accessor to get the current version.  Essentially the same as SteamFriends(), but using this ensures that you are using a matching library.
-inline ISteamFriends *SteamAPI_SteamFriends() { return SteamAPI_SteamFriends_v017(); }
+inline ISteamFriends *SteamAPI_SteamFriends() { return SteamAPI_SteamFriends_v018(); }
 S_API const char * SteamAPI_ISteamFriends_GetPersonaName( ISteamFriends* self );
-S_API SteamAPICall_t SteamAPI_ISteamFriends_SetPersonaName( ISteamFriends* self, const char * pchPersonaName );
 S_API EPersonaState SteamAPI_ISteamFriends_GetPersonaState( ISteamFriends* self );
 S_API int SteamAPI_ISteamFriends_GetFriendCount( ISteamFriends* self, int iFriendFlags );
 S_API uint64_steamid SteamAPI_ISteamFriends_GetFriendByIndex( ISteamFriends* self, int iFriend, int iFriendFlags );
@@ -142,7 +141,6 @@ S_API SteamAPICall_t SteamAPI_ISteamFriends_RequestClanOfficerList( ISteamFriend
 S_API uint64_steamid SteamAPI_ISteamFriends_GetClanOwner( ISteamFriends* self, uint64_steamid steamIDClan );
 S_API int SteamAPI_ISteamFriends_GetClanOfficerCount( ISteamFriends* self, uint64_steamid steamIDClan );
 S_API uint64_steamid SteamAPI_ISteamFriends_GetClanOfficerByIndex( ISteamFriends* self, uint64_steamid steamIDClan, int iOfficer );
-S_API uint32 SteamAPI_ISteamFriends_GetUserRestrictions( ISteamFriends* self );
 S_API bool SteamAPI_ISteamFriends_SetRichPresence( ISteamFriends* self, const char * pchKey, const char * pchValue );
 S_API void SteamAPI_ISteamFriends_ClearRichPresence( ISteamFriends* self );
 S_API const char * SteamAPI_ISteamFriends_GetFriendRichPresence( ISteamFriends* self, uint64_steamid steamIDFriend, const char * pchKey );
@@ -756,14 +754,14 @@ S_API bool SteamAPI_ISteamController_GetControllerBindingRevision( ISteamControl
 // ISteamUGC

 // A versioned accessor is exported by the library
-S_API ISteamUGC *SteamAPI_SteamUGC_v020();
+S_API ISteamUGC *SteamAPI_SteamUGC_v021();
 // Inline, unversioned accessor to get the current version.  Essentially the same as SteamUGC(), but using this ensures that you are using a matching library.
-inline ISteamUGC *SteamAPI_SteamUGC() { return SteamAPI_SteamUGC_v020(); }
+inline ISteamUGC *SteamAPI_SteamUGC() { return SteamAPI_SteamUGC_v021(); }

 // A versioned accessor is exported by the library
-S_API ISteamUGC *SteamAPI_SteamGameServerUGC_v020();
+S_API ISteamUGC *SteamAPI_SteamGameServerUGC_v021();
 // Inline, unversioned accessor to get the current version.  Essentially the same as SteamGameServerUGC(), but using this ensures that you are using a matching library.
-inline ISteamUGC *SteamAPI_SteamGameServerUGC() { return SteamAPI_SteamGameServerUGC_v020(); }
+inline ISteamUGC *SteamAPI_SteamGameServerUGC() { return SteamAPI_SteamGameServerUGC_v021(); }
 S_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 );
 S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequestPage( ISteamUGC* self, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, uint32 unPage );
 S_API UGCQueryHandle_t SteamAPI_ISteamUGC_CreateQueryAllUGCRequestCursor( ISteamUGC* self, EUGCQuery eQueryType, EUGCMatchingUGCType eMatchingeMatchingUGCTypeFileType, AppId_t nCreatorAppID, AppId_t nConsumerAppID, const char * pchCursor );
@@ -838,8 +836,8 @@ S_API SteamAPICall_t SteamAPI_ISteamUGC_AddItemToFavorites( ISteamUGC* self, App
 S_API SteamAPICall_t SteamAPI_ISteamUGC_RemoveItemFromFavorites( ISteamUGC* self, AppId_t nAppId, PublishedFileId_t nPublishedFileID );
 S_API SteamAPICall_t SteamAPI_ISteamUGC_SubscribeItem( ISteamUGC* self, PublishedFileId_t nPublishedFileID );
 S_API SteamAPICall_t SteamAPI_ISteamUGC_UnsubscribeItem( ISteamUGC* self, PublishedFileId_t nPublishedFileID );
-S_API uint32 SteamAPI_ISteamUGC_GetNumSubscribedItems( ISteamUGC* self );
-S_API uint32 SteamAPI_ISteamUGC_GetSubscribedItems( ISteamUGC* self, PublishedFileId_t * pvecPublishedFileID, uint32 cMaxEntries );
+S_API uint32 SteamAPI_ISteamUGC_GetNumSubscribedItems( ISteamUGC* self, bool bIncludeLocallyDisabled );
+S_API uint32 SteamAPI_ISteamUGC_GetSubscribedItems( ISteamUGC* self, PublishedFileId_t * pvecPublishedFileID, uint32 cMaxEntries, bool bIncludeLocallyDisabled );
 S_API uint32 SteamAPI_ISteamUGC_GetItemState( ISteamUGC* self, PublishedFileId_t nPublishedFileID );
 S_API bool SteamAPI_ISteamUGC_GetItemInstallInfo( ISteamUGC* self, PublishedFileId_t nPublishedFileID, uint64 * punSizeOnDisk, char * pchFolder, uint32 cchFolderSize, uint32 * punTimeStamp );
 S_API bool SteamAPI_ISteamUGC_GetItemDownloadInfo( ISteamUGC* self, PublishedFileId_t nPublishedFileID, uint64 * punBytesDownloaded, uint64 * punBytesTotal );
@@ -858,6 +856,8 @@ S_API SteamAPICall_t SteamAPI_ISteamUGC_DeleteItem( ISteamUGC* self, PublishedFi
 S_API bool SteamAPI_ISteamUGC_ShowWorkshopEULA( ISteamUGC* self );
 S_API SteamAPICall_t SteamAPI_ISteamUGC_GetWorkshopEULAStatus( ISteamUGC* self );
 S_API uint32 SteamAPI_ISteamUGC_GetUserContentDescriptorPreferences( ISteamUGC* self, EUGCContentDescriptorID * pvecDescriptors, uint32 cMaxEntries );
+S_API bool SteamAPI_ISteamUGC_SetItemsDisabledLocally( ISteamUGC* self, PublishedFileId_t * pvecPublishedFileIDs, uint32 unNumPublishedFileIDs, bool bDisabledLocally );
+S_API bool SteamAPI_ISteamUGC_SetSubscriptionsLoadOrder( ISteamUGC* self, PublishedFileId_t * pvecPublishedFileIDs, uint32 unNumPublishedFileIDs );

 // ISteamHTMLSurface

@@ -1005,17 +1005,24 @@ S_API bool SteamAPI_ISteamParentalSettings_BIsFeatureInBlockList( ISteamParental
 // ISteamRemotePlay

 // A versioned accessor is exported by the library
-S_API ISteamRemotePlay *SteamAPI_SteamRemotePlay_v002();
+S_API ISteamRemotePlay *SteamAPI_SteamRemotePlay_v003();
 // Inline, unversioned accessor to get the current version.  Essentially the same as SteamRemotePlay(), but using this ensures that you are using a matching library.
-inline ISteamRemotePlay *SteamAPI_SteamRemotePlay() { return SteamAPI_SteamRemotePlay_v002(); }
+inline ISteamRemotePlay *SteamAPI_SteamRemotePlay() { return SteamAPI_SteamRemotePlay_v003(); }
 S_API uint32 SteamAPI_ISteamRemotePlay_GetSessionCount( ISteamRemotePlay* self );
 S_API RemotePlaySessionID_t SteamAPI_ISteamRemotePlay_GetSessionID( ISteamRemotePlay* self, int iSessionIndex );
 S_API uint64_steamid SteamAPI_ISteamRemotePlay_GetSessionSteamID( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID );
 S_API const char * SteamAPI_ISteamRemotePlay_GetSessionClientName( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID );
 S_API ESteamDeviceFormFactor SteamAPI_ISteamRemotePlay_GetSessionClientFormFactor( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID );
 S_API bool SteamAPI_ISteamRemotePlay_BGetSessionClientResolution( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID, int * pnResolutionX, int * pnResolutionY );
-S_API bool SteamAPI_ISteamRemotePlay_BStartRemotePlayTogether( ISteamRemotePlay* self, bool bShowOverlay );
+S_API bool SteamAPI_ISteamRemotePlay_ShowRemotePlayTogetherUI( ISteamRemotePlay* self );
 S_API bool SteamAPI_ISteamRemotePlay_BSendRemotePlayTogetherInvite( ISteamRemotePlay* self, uint64_steamid steamIDFriend );
+S_API bool SteamAPI_ISteamRemotePlay_BEnableRemotePlayTogetherDirectInput( ISteamRemotePlay* self );
+S_API void SteamAPI_ISteamRemotePlay_DisableRemotePlayTogetherDirectInput( ISteamRemotePlay* self );
+S_API uint32 SteamAPI_ISteamRemotePlay_GetInput( ISteamRemotePlay* self, RemotePlayInput_t * pInput, uint32 unMaxEvents );
+S_API void SteamAPI_ISteamRemotePlay_SetMouseVisibility( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID, bool bVisible );
+S_API void SteamAPI_ISteamRemotePlay_SetMousePosition( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID, float flNormalizedX, float flNormalizedY );
+S_API RemotePlayCursorID_t SteamAPI_ISteamRemotePlay_CreateMouseCursor( ISteamRemotePlay* self, int nWidth, int nHeight, int nHotX, int nHotY, const void * pBGRA, int nPitch );
+S_API void SteamAPI_ISteamRemotePlay_SetMouseCursor( ISteamRemotePlay* self, RemotePlaySessionID_t unSessionID, RemotePlayCursorID_t unCursorID );

 // ISteamNetworkingMessages

@@ -225,7 +225,6 @@ class ISteamScreenshots;
 class ISteamMusic;
 class ISteamMusicRemote;
 class ISteamGameServerStats;
-class ISteamPS3OverlayRender;
 class ISteamHTTP;
 class ISteamController;
 class ISteamUGC;
@@ -22,10 +22,6 @@ typedef unsigned char uint8;
 #endif

 #if !defined(VALVE_BIG_ENDIAN)
-#if defined(_PS3)
-// Make sure VALVE_BIG_ENDIAN gets set on PS3, may already be set previously in Valve internal code.
-#define VALVE_BIG_ENDIAN 1
-#endif
 #if defined( __GNUC__ ) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 #define VALVE_BIG_ENDIAN 1
 #endif
@@ -24,12 +24,10 @@ SOURCEFILES := \
 	timeline.cpp \
 	VectorEntity.cpp \
 	clanchatroom.cpp \
-	connectingmenu.cpp \
 	gameenginesdl.cpp \
 	htmlsurface.cpp \
 	musicplayer.cpp \
 	p2pauth.cpp \
-	remotestoragesync.cpp \
 	stdafx.cpp \
 	voicechat.cpp \
 	glew.c
@@ -1,38 +0,0 @@
-//========= Copyright © 1996-2008, Valve LLC, All rights reserved. ============
-//
-// Purpose: Class to define the connecting game menu
-//
-// $NoKeywords: $
-//=============================================================================
-
-
-#include "stdafx.h"
-#include "connectingmenu.h"
-#include "SpaceWar.h"
-
-//-----------------------------------------------------------------------------
-// Purpose: Constructor
-//-----------------------------------------------------------------------------
-CConnectingMenu::CConnectingMenu( IGameEngine *pGameEngine ) : CBaseMenu<EClientGameState>( pGameEngine )
-{
-	m_bInitialLogonFailed = false;
-	AddMenuItem( MenuItem_t( "Connecting...", k_EClientConnectingToSteam ) );
-}
-
-void CConnectingMenu::Reset()
-{
-	m_bInitialLogonFailed = false;
-	ClearMenuItems();
-	AddMenuItem( MenuItem_t( "Connecting...", k_EClientConnectingToSteam ) );
-}
-
-void CConnectingMenu::OnConnectFailure()
-{
-	m_bInitialLogonFailed = true;
-
-	ClearMenuItems();
-
-	AddMenuItem( MenuItem_t( "Retry Connecting", k_EClientRetrySteamConnection ) );
-	AddMenuItem( MenuItem_t( "Link Existing Account", k_EClientLinkSteamAccount ) );
-	AddMenuItem( MenuItem_t( "Autocreate Account", k_EClientAutoCreateAccount ) );
-}
@@ -1,31 +0,0 @@
-//========= Copyright © 1996-2008, Valve LLC, All rights reserved. ============
-//
-// Purpose: Class to define the main game menu
-//
-// $NoKeywords: $
-//=============================================================================
-
-#ifndef CONNECTINGMENU_H
-#define CONNECTINGMENU_H
-
-#include <string>
-#include <vector>
-#include "GameEngine.h"
-#include "SpaceWar.h"
-#include "BaseMenu.h"
-#include "SpaceWarClient.h"
-
-class CConnectingMenu : public CBaseMenu<EClientGameState>
-{
-public:
-	// Constructor
-	CConnectingMenu( IGameEngine *pGameEngine );
-
-	void Reset();
-	void OnConnectFailure();
-
-private:
-	bool m_bInitialLogonFailed;
-};
-
-#endif // CONNECTINGMENU_H
@@ -1,228 +0,0 @@
-//========= Copyright © 1996-2008, Valve LLC, All rights reserved. ============
-//
-// Purpose: Class for tracking stats and achievements
-//
-// $NoKeywords: $
-//=============================================================================
-
-#include "stdafx.h"
-#include "remotestoragesync.h"
-#include "BaseMenu.h"
-
-//-----------------------------------------------------------------------------
-// NOTE
-//
-// The following code is for synchronizing files while the game is running
-// This is only necessary when on the Playstation 3, as the Steam client handles
-// these operations when on PC/Mac.
-//
-//-----------------------------------------------------------------------------
-
-#ifdef _PS3
-//-----------------------------------------------------------------------------
-// Purpose: Constructor
-//-----------------------------------------------------------------------------
-CRemoteStorageSyncMenu::CRemoteStorageSyncMenu( IGameEngine *pGameEngine ) : CBaseMenu<ERemoteStorageSyncMenuCommand>( pGameEngine )
-{		
-}
-
-//-----------------------------------------------------------------------------
-// Purpose: Shows the synchronization progress menu
-//-----------------------------------------------------------------------------
-void CRemoteStorageSyncMenu::ShowSyncProgress( ESyncOperation eSyncOperation, double dPercentComplete )
-{
-	if ( eSyncOperation == k_ESyncOperationIdle )
-		return;
-
-	PushSelectedItem();
-	ClearMenuItems();
-
-	// Create progress text
-	char buffer[260];
-	const char *pchFormat = (eSyncOperation == k_ESyncOperationToClient ) ? "Syncing to client (%d%%)" : "Syncing to server(%d%%)";
-	sprintf( buffer, pchFormat, (int)dPercentComplete );
-	AddMenuItem( CRemoteStorageSyncMenu::MenuItem_t( buffer, k_EMenuCommandProgress ) );
-
-	PopSelectedItem();
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Shows the synchronization progress menu
-//-----------------------------------------------------------------------------
-void CRemoteStorageSyncMenu::ShowSyncComplete( ESyncOperation eSyncOperation, bool bSuccess )
-{
-	if ( eSyncOperation == k_ESyncOperationIdle )
-		return;
-
-	PushSelectedItem();
-	ClearMenuItems();
-
-	// Create progress text
-	char buffer[260];
-	const char *pchResult = bSuccess ? "complete" : "failed";
-	const char *pchFormat = (eSyncOperation == k_ESyncOperationToClient ) ? "Sync to client %s.. press X" : "Sync to server %s.. press X";	
-	sprintf( buffer, pchFormat, pchResult );
-	AddMenuItem( CRemoteStorageSyncMenu::MenuItem_t( buffer, k_EMenuCommandSyncComplete ) );
-
-	PopSelectedItem();
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Shows the conflict menu
-//-----------------------------------------------------------------------------
-void CRemoteStorageSyncMenu::ShowConflict()
-{
-	PushSelectedItem();
-	ClearMenuItems();
-
-	// Description
-	AddMenuItem( CRemoteStorageSyncMenu::MenuItem_t( "There is a conflict between the local & server versions of your files:", k_EMenuCommandNone ) );
-
-	PopSelectedItem();
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Constructor
-//-----------------------------------------------------------------------------
-CRemoteStorageSync::CRemoteStorageSync( IGameEngine *pGameEngine ) : 
-	m_eSyncOperation( k_ESyncOperationIdle ),
-	m_menu( pGameEngine ),
-	m_callbackAppSyncClientComplete( this, &CRemoteStorageSync::OnAppSyncClientComplete ),
-	m_callbackAppSyncServerComplete( this, &CRemoteStorageSync::OnAppSyncServerComplete ),
-	m_callbackAppSyncProgress( this, &CRemoteStorageSync::OnAppSyncProgress )
-{
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Start synchronizing files to the client
-//-----------------------------------------------------------------------------
-void CRemoteStorageSync::SynchronizeToClient()
-{
-	if ( m_eSyncOperation != k_ESyncOperationIdle )
-		return;
-
-	if ( !SteamRemoteStorage()->SynchronizeToClient() )
-		return;
-
-	m_eSyncOperation = k_ESyncOperationToClient;
-	m_menu.ShowSyncProgress( m_eSyncOperation, 0.0 );
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Start synchronizing files to the server
-//-----------------------------------------------------------------------------
-void CRemoteStorageSync::SynchronizeToServer()
-{
-	if ( m_eSyncOperation != k_ESyncOperationIdle )
-		return;
-
-	if ( !SteamRemoteStorage()->SynchronizeToServer() )
-		return;
-
-	m_eSyncOperation = k_ESyncOperationToServer;
-	m_menu.ShowSyncProgress( m_eSyncOperation, 0.0 );
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Called each frame. Draw's menu
-//-----------------------------------------------------------------------------
-void CRemoteStorageSync::Render()
-{
-	m_menu.RunFrame();
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Returns true if we are done synchronizing
-//-----------------------------------------------------------------------------
-bool CRemoteStorageSync::BFinished()
-{
-	return m_eSyncOperation == k_ESyncOperationIdle;
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Called periodically by Steam when a synchronization is in progress
-//-----------------------------------------------------------------------------
-void CRemoteStorageSync::OnAppSyncProgress( RemoteStorageAppSyncProgress_t *pParam )
-{
-	// make sure the update is for us
-	if ( pParam->m_nAppID != SteamUtils()->GetAppID() )
-		return;
-
-	// make sure the update is in the direction we expect
-	if ( m_eSyncOperation == k_ESyncOperationIdle || (pParam->m_bUploading && m_eSyncOperation != k_ESyncOperationToServer) )
-		return;
-
-	m_menu.ShowSyncProgress( m_eSyncOperation, pParam->m_dAppPercentComplete );
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Called by Steam when a synchronization to the client is complete
-//-----------------------------------------------------------------------------
-void CRemoteStorageSync::OnAppSyncClientComplete( RemoteStorageAppSyncedClient_t *pParam )
-{
-	// make sure the update is for us
-	if ( pParam->m_nAppID != SteamUtils()->GetAppID() )
-		return;
-
-	// make sure the update is in the direction we expect
-	if ( m_eSyncOperation != k_ESyncOperationToClient )
-		return;
-
-	// check for errors
-	if ( pParam->m_eResult == k_EResultRemoteFileConflict )
-	{
-		m_menu.ShowConflict();
-		return;
-	}
-	
-	m_menu.ShowSyncComplete( m_eSyncOperation, pParam->m_eResult == k_EResultOK );
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Called by Steam when a synchronization to the server is complete
-//-----------------------------------------------------------------------------
-void CRemoteStorageSync::OnAppSyncServerComplete( RemoteStorageAppSyncedServer_t *pParam )
-{
-	// make sure the update is for us
-	if ( pParam->m_nAppID != SteamUtils()->GetAppID() )
-		return;
-
-	// make sure the update is in the direction we expect
-	if ( m_eSyncOperation != k_ESyncOperationToServer )
-		return;
-
-	// check for errors
-	if ( pParam->m_eResult == k_EResultRemoteFileConflict )
-	{
-		m_menu.ShowConflict();
-		return;
-	}
-	
-	m_menu.ShowSyncComplete( m_eSyncOperation, pParam->m_eResult == k_EResultOK );
-}
-
-
-//-----------------------------------------------------------------------------
-// Purpose: A sync menu item has been selected
-//-----------------------------------------------------------------------------
-void CRemoteStorageSync::OnMenuSelection( ERemoteStorageSyncMenuCommand selection )
-{
-	switch( selection )
-	{
-	case k_EMenuCommandSyncComplete:
-		m_eSyncOperation = k_ESyncOperationIdle;
-		break;
-	}
-}
-
-#endif
@@ -1,89 +0,0 @@
-//========= Copyright � 1996-2008, Valve LLC, All rights reserved. ============
-//
-// Purpose: Class for tracking stats and achievements
-//
-// $NoKeywords: $
-//=============================================================================
-
-#ifndef REMOTE_STORAGE_SYNC_H
-#define REMOTE_STORAGE_SYNC_H
-
-#include "SpaceWar.h"
-#include "GameEngine.h"
-#include "BaseMenu.h"
-
-//-----------------------------------------------------------------------------
-// NOTE
-//
-// The following code is for synchronizing files while the game is running
-// This is only necessary when on the Playstation 3, as the Steam client handles
-// these operations when on PC/Mac.
-//
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-// Purpose: Interface for sync screen
-//-----------------------------------------------------------------------------
-class IRemoteStorageSync
-{
-public:
-	virtual ~IRemoteStorageSync() {}
-
-	virtual void SynchronizeToClient() = 0;
-	virtual void SynchronizeToServer() = 0;
-	virtual void Render() = 0;
-	virtual bool BFinished() = 0;
-	virtual void OnMenuSelection( ERemoteStorageSyncMenuCommand selection ) = 0;
-};
-
-#ifdef _PS3
-enum ESyncOperation
-{
-	k_ESyncOperationIdle,
-	k_ESyncOperationToClient,
-	k_ESyncOperationToServer
-};
-
-//-----------------------------------------------------------------------------
-// Purpose: Menu shown for synchronization progress and prompting user to resolve a conflict
-//-----------------------------------------------------------------------------
-class CRemoteStorageSyncMenu : public CBaseMenu< ERemoteStorageSyncMenuCommand >
-{
-public:
-	CRemoteStorageSyncMenu( IGameEngine *pGameEngine );
-	void ShowSyncProgress( ESyncOperation eSyncOperation, double dPercentComplete );
-	void ShowSyncComplete( ESyncOperation eSyncOperation, bool bSuccess );
-	void ShowConflict();	
-};
-
-
-//-----------------------------------------------------------------------------
-// Purpose: Synchronizes files with Steam
-//-----------------------------------------------------------------------------
-class CRemoteStorageSync : public IRemoteStorageSync
-{
-public:
-
-	// Constructor
-	CRemoteStorageSync( IGameEngine *pGameEngine );
-
-	// IRemoteStorageSync implementations
-	virtual void SynchronizeToClient();
-	virtual void SynchronizeToServer();
-	virtual void Render();
-	virtual bool BFinished();
-	virtual void OnMenuSelection( ERemoteStorageSyncMenuCommand selection );
-
-private:
-	// synchronization updates
-	STEAM_CALLBACK( CRemoteStorageSync, OnAppSyncClientComplete, RemoteStorageAppSyncedClient_t, m_callbackAppSyncClientComplete );
-	STEAM_CALLBACK( CRemoteStorageSync, OnAppSyncServerComplete, RemoteStorageAppSyncedServer_t, m_callbackAppSyncServerComplete );
-	STEAM_CALLBACK( CRemoteStorageSync, OnAppSyncProgress, RemoteStorageAppSyncProgress_t, m_callbackAppSyncProgress );
-	STEAM_CALLBACK( CRemoteStorageSync, OnConflictResolution, RemoteStorageConflictResolution_t, m_callbackConflictResolution );
-
-	CRemoteStorageSyncMenu m_menu;
-	ESyncOperation m_eSyncOperation;
-};
-#endif // !_PS3
-
-#endif
@@ -9,7 +9,6 @@
 /* Begin PBXBuildFile section */
 		503C6CB61268F34200B66E3B /* Cocoa.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 503C6CB51268F34200B66E3B /* Cocoa.framework */; };
 		503C6D0F1268F49F00B66E3B /* BaseMenu.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 503C6CD91268F49F00B66E3B /* BaseMenu.cpp */; };
-		503C6D101268F49F00B66E3B /* connectingmenu.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 503C6CDB1268F49F00B66E3B /* connectingmenu.cpp */; };
 		503C6D121268F49F00B66E3B /* gameengineosx.mm in Sources */ = {isa = PBXBuildFile; fileRef = 503C6CE01268F49F00B66E3B /* gameengineosx.mm */; };
 		503C6D131268F49F00B66E3B /* glstringosx.mm in Sources */ = {isa = PBXBuildFile; fileRef = 503C6CE21268F49F00B66E3B /* glstringosx.mm */; };
 		503C6D141268F49F00B66E3B /* Leaderboards.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 503C6CE31268F49F00B66E3B /* Leaderboards.cpp */; };
@@ -54,7 +53,6 @@
 		975820DB2765BE3900093F91 /* ItemStore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 975820DA2765BE3900093F91 /* ItemStore.cpp */; };
 		97919DA62C22281400272343 /* timeline.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97919DA52C22281400272343 /* timeline.cpp */; };
 		A4B5A0FD24906974000E9151 /* RemotePlay.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A4B5A0FC24906974000E9151 /* RemotePlay.cpp */; };
-		A4B5A101249069C9000E9151 /* remotestoragesync.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A4B5A0FF249069C9000E9151 /* remotestoragesync.cpp */; };
 		A4B5A10424906A0E000E9151 /* SimpleProtobuf.cpp in Sources */ = {isa = PBXBuildFile; fileRef = A4B5A10324906A0E000E9151 /* SimpleProtobuf.cpp */; };
 		BA60B6B81A82EDD200F4AC4F /* Friends.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BA60B6B41A82EDD200F4AC4F /* Friends.cpp */; };
 		BA60B6B91A82EDD200F4AC4F /* Inventory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BA60B6B61A82EDD200F4AC4F /* Inventory.cpp */; };
@@ -81,8 +79,6 @@
 		503C6CB51268F34200B66E3B /* Cocoa.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Cocoa.framework; path = System/Library/Frameworks/Cocoa.framework; sourceTree = SDKROOT; };
 		503C6CD91268F49F00B66E3B /* BaseMenu.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BaseMenu.cpp; sourceTree = "<group>"; };
 		503C6CDA1268F49F00B66E3B /* BaseMenu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BaseMenu.h; sourceTree = "<group>"; };
-		503C6CDB1268F49F00B66E3B /* connectingmenu.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = connectingmenu.cpp; sourceTree = "<group>"; };
-		503C6CDC1268F49F00B66E3B /* connectingmenu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = connectingmenu.h; sourceTree = "<group>"; };
 		503C6CDD1268F49F00B66E3B /* GameEngine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GameEngine.h; sourceTree = "<group>"; };
 		503C6CDF1268F49F00B66E3B /* gameengineosx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gameengineosx.h; sourceTree = "<group>"; };
 		503C6CE01268F49F00B66E3B /* gameengineosx.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = gameengineosx.mm; sourceTree = "<group>"; };
@@ -172,8 +168,6 @@
 		A46ECF6D26BE389800985AA7 /* steamworksexample.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; name = steamworksexample.entitlements; path = osx/steamworksexample.entitlements; sourceTree = "<group>"; };
 		A4B5A0FC24906974000E9151 /* RemotePlay.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RemotePlay.cpp; sourceTree = "<group>"; };
 		A4B5A0FE2490698A000E9151 /* RemotePlay.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RemotePlay.h; sourceTree = "<group>"; };
-		A4B5A0FF249069C9000E9151 /* remotestoragesync.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = remotestoragesync.cpp; sourceTree = "<group>"; };
-		A4B5A100249069C9000E9151 /* remotestoragesync.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = remotestoragesync.h; sourceTree = "<group>"; };
 		A4B5A10224906A0E000E9151 /* SimpleProtobuf.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SimpleProtobuf.h; sourceTree = "<group>"; };
 		A4B5A10324906A0E000E9151 /* SimpleProtobuf.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SimpleProtobuf.cpp; sourceTree = "<group>"; };
 		BA60B6B41A82EDD200F4AC4F /* Friends.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Friends.cpp; sourceTree = "<group>"; };
@@ -219,7 +213,6 @@
 				50E77DCF136218F5000FC072 /* glmgr */,
 				503C6CD91268F49F00B66E3B /* BaseMenu.cpp */,
 				50D642851461EF3200A5739B /* clanchatroom.cpp */,
-				503C6CDB1268F49F00B66E3B /* connectingmenu.cpp */,
 				BA60B6B41A82EDD200F4AC4F /* Friends.cpp */,
 				503C6CE01268F49F00B66E3B /* gameengineosx.mm */,
 				503C6CE21268F49F00B66E3B /* glstringosx.mm */,
@@ -237,7 +230,6 @@
 				503C6CF11268F49F00B66E3B /* QuitMenu.cpp */,
 				A4B5A0FC24906974000E9151 /* RemotePlay.cpp */,
 				503C6CF31268F49F00B66E3B /* RemoteStorage.cpp */,
-				A4B5A0FF249069C9000E9151 /* remotestoragesync.cpp */,
 				503C6CF51268F49F00B66E3B /* ServerBrowser.cpp */,
 				503C6CF81268F49F00B66E3B /* Ship.cpp */,
 				A4B5A10324906A0E000E9151 /* SimpleProtobuf.cpp */,
@@ -290,7 +282,6 @@
 			children = (
 				503C6CDA1268F49F00B66E3B /* BaseMenu.h */,
 				50D642861461EF3200A5739B /* clanchatroom.h */,
-				503C6CDC1268F49F00B66E3B /* connectingmenu.h */,
 				BA60B6B51A82EDD200F4AC4F /* Friends.h */,
 				503C6CDD1268F49F00B66E3B /* GameEngine.h */,
 				503C6CDF1268F49F00B66E3B /* gameengineosx.h */,
@@ -309,7 +300,6 @@
 				503C6CF21268F49F00B66E3B /* QuitMenu.h */,
 				A4B5A0FE2490698A000E9151 /* RemotePlay.h */,
 				503C6CF41268F49F00B66E3B /* RemoteStorage.h */,
-				A4B5A100249069C9000E9151 /* remotestoragesync.h */,
 				503C6CF61268F49F00B66E3B /* ServerBrowser.h */,
 				503C6CF71268F49F00B66E3B /* ServerBrowserMenu.h */,
 				503C6CF91268F49F00B66E3B /* Ship.h */,
@@ -426,7 +416,6 @@
 			files = (
 				840B387019BB91C50084B9F1 /* htmlsurface.cpp in Sources */,
 				503C6D0F1268F49F00B66E3B /* BaseMenu.cpp in Sources */,
-				503C6D101268F49F00B66E3B /* connectingmenu.cpp in Sources */,
 				F803305119087F9200344590 /* musicplayer.cpp in Sources */,
 				503C6D121268F49F00B66E3B /* gameengineosx.mm in Sources */,
 				503C6D131268F49F00B66E3B /* glstringosx.mm in Sources */,
@@ -465,7 +454,6 @@
 				50E77DF31362190C000FC072 /* glmgrbasics.cpp in Sources */,
 				50E77DF41362190C000FC072 /* glmgrcocoa.mm in Sources */,
 				50E77DF51362190C000FC072 /* glmgrext.cpp in Sources */,
-				A4B5A101249069C9000E9151 /* remotestoragesync.cpp in Sources */,
 				97919DA62C22281400272343 /* timeline.cpp in Sources */,
 				BA60B6B81A82EDD200F4AC4F /* Friends.cpp in Sources */,
 				50E77DF61362190C000FC072 /* mathlite.cpp in Sources */,