tf2/tf2_src/utils/xbox/AppChooser/main.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: X360 Application Chooser
//
//===========================================================================//

#if !defined( _X360 )
#include <windows.h>
#endif
#include "appframework/iappsystemgroup.h"
#include "appframework/appframework.h"
#include "tier0/dbg.h"
#include "tier1/interface.h"
#include "tier1/KeyValues.h"
#include "filesystem.h"
#include "vstdlib/cvar.h"
#include "filesystem_init.h"
#include "tier1/utlbuffer.h"
#include "icommandline.h"
#include "datacache/idatacache.h"
#include "datacache/imdlcache.h"
#include "studio.h"
#include "utlbuffer.h"
#include "tier2/utlstreambuffer.h"
#include "tier2/tier2.h"
#include "appframework/tier3app.h"
#include "mathlib/mathlib.h"
#include "inputsystem/iinputsystem.h"
#include "vphysics_interface.h"
#include "istudiorender.h"
#include "studio.h"
#include "vgui/IVGui.h"
#include "VGuiMatSurface/IMatSystemSurface.h"
#include "matsys_controls/matsyscontrols.h"
#include "vgui/ILocalize.h"
#include "vgui_controls/panel.h"
#include "vgui_controls/Label.h"
#include "vgui_controls/imagepanel.h"
#include "vgui_controls/AnimationController.h"
#include "materialsystem/imaterialsystem.h"
#include "materialsystem/imesh.h"
#include "materialsystem/materialsystem_config.h"
#include "materialsystem/MaterialSystemUtil.h"
#include "materialsystem/ishaderapi.h"
#include "materialsystem/itexture.h"
#include "filesystem/IQueuedLoader.h"
#include "xwvfile.h"
#if defined( _X360 )
#include "hl2orange.spa.h"
#include "xbox/xbox_console.h"
#include "xbox/xbox_win32stubs.h"
#include "xbox/xbox_launch.h"
#include <xaudio.h>
#include <xmedia.h>
#include <xmp.h>
#endif
#if !defined( _X360 )
#include "xbox/xboxstubs.h"
#endif
#include "tier0/memdbgon.h"

#define INACTIVITY_TIMEOUT	120

#define MOVIE_PATH			"d:\\movies"

bool g_bActive = true;

// user background music can force this to be zero
static float g_TargetMovieVolume = 1.0f;

extern SpewOutputFunc_t g_DefaultSpewFunc;

typedef void (*MovieEndCallback_t)();

struct game_t
{
	const wchar_t	*pName;
	const char		*pGameDir;
	bool			bEnabled;
};

game_t g_Games[] = 
{
	{ L"HALF-LIFE 2",					"hl2",		true },
	{ L"HALF-LIFE 2:\nEPISODE ONE",		"episodic",	true },
	{ L" HALF-LIFE 2:\nEPISODE TWO",	"ep2",		true },
	{ L"PORTAL",						"portal",	true },
	{ L"   TEAM\nFORTRESS 2",		    "tf",		true },
};

struct StartupMovie_t
{
	const char *pMovieName;
	bool		bUserCanSkip;
};

// played in order on initial startup
StartupMovie_t g_StartupMovies[] =
{
	{ "valve_legalese.wmv",	false },
};

const char *g_DemoMovies[] =
{
	"demo.wmv",
	"teaser_l4d.wmv",
};

class CImage : public vgui::Panel
{
	DECLARE_CLASS_SIMPLE( CImage, vgui::Panel );
public:
	CImage( vgui::Panel *pParent, const char *pName, const char *pImageName ) : BaseClass( pParent, pName ) 
	{
		m_imageID = vgui::surface()->CreateNewTextureID();
		vgui::surface()->DrawSetTextureFile( m_imageID, pImageName, false, false );	
		m_Color = Color( 255, 255, 255, 255 );
		SetPaintBackgroundEnabled( true );
		m_AspectRatio = 1.0f;
		m_bLetterbox = false;
	}

	CImage( vgui::Panel *pParent, const char *pName, IMaterial *pMaterial ) : BaseClass( pParent, pName ) 
	{
		m_imageID = vgui::surface()->CreateNewTextureID();
		g_pMatSystemSurface->DrawSetTextureMaterial( m_imageID, pMaterial );	
		m_Color = Color( 255, 255, 255, 255 );
		SetPaintBackgroundEnabled( true );
		m_AspectRatio = 1.0f;
		m_bLetterbox = false;
	}

	void SetAspectRatio( float aspectRatio, bool bLetterbox )
	{
		if ( aspectRatio > 1.0f )
		{
			m_AspectRatio = aspectRatio;
			m_bLetterbox = bLetterbox;
		}
	}

	void SetColor( int r, int g, int b )
	{
		// set rgb only
		m_Color.SetColor( r, g, b, m_Color.a() );
	}

	void SetAlpha( int alpha )
	{
		// set alpha only
		alpha = clamp( alpha, 0, 255 );
		m_Color.SetColor( m_Color.r(), m_Color.g(), m_Color.b(), alpha );
	}

	int GetAlpha() const
	{
		return m_Color.a();
	}

	virtual void PaintBackground( void )
	{
		if ( m_Color.a() != 0 )
		{
			int panelWidth, panelHeight;
			GetSize( panelWidth, panelHeight );
	
			float s0 = 0.0f;
			float s1 = 1.0f;
			int y = 0;
			if ( m_AspectRatio > 1.0f )
			{
				if ( m_bLetterbox )
				{
					// horizontal letterbox
					float adjustedHeight = (float)panelWidth / m_AspectRatio;
					float bandHeight = ( (float)panelHeight - adjustedHeight ) / 2;

					vgui::surface()->DrawSetColor( Color( 0, 0, 0, m_Color.a() ) );
					vgui::surface()->DrawFilledRect( 0, 0, panelWidth, bandHeight );
					vgui::surface()->DrawFilledRect( 0, panelHeight - bandHeight, panelWidth, panelHeight );

					y = bandHeight;
					panelHeight = adjustedHeight;
				}
				else
				{
					// hold the panel's height constant, determine the corresponding aspect corrected image width
					float imageWidth = (float)panelHeight * m_AspectRatio;
					// adjust the image width as a percentage of the panel's width
					// scale and center;
					s1 = (float)panelWidth / imageWidth;
					s0 = ( 1 - s1 ) / 2.0f;
					s1 = s0 + s1;
				}
			}

			vgui::surface()->DrawSetColor( m_Color );
			vgui::surface()->DrawSetTexture( m_imageID );
			vgui::surface()->DrawTexturedSubRect( 0, y, panelWidth, y+panelHeight, s0, 0.0f, s1, 1.0f );
		}
	}

	int		m_imageID;
	Color	m_Color;
	float	m_AspectRatio;
	bool	m_bLetterbox;
};

class CMovieImage : public vgui::Panel
{
	DECLARE_CLASS_SIMPLE( CMovieImage, vgui::Panel );
public:

	CMovieImage( vgui::Panel *pParent, const char *pName, const char *pUniqueName, int nDecodeWidth, int nDecodeHeight, float fadeDelay = 1.0f ) : BaseClass( pParent, pName ) 
	{
		// decoupled from actual panel bounds, can be decoded at any power of two resolution
		m_nDecodeWidth = nDecodeWidth;
		m_nDecodeHeight = nDecodeHeight;

		char materialName[MAX_PATH];
		V_snprintf( materialName, sizeof( materialName ), "MovieMaterial_%s.vmt", pUniqueName );
		char textureName[MAX_PATH];
		V_snprintf( textureName, sizeof( textureName ), "MovieFrame_%s", pUniqueName );

		// create a texture for use as movie frame grab
		m_pTexture = g_pMaterialSystem->CreateProceduralTexture( 
			textureName, 
			TEXTURE_GROUP_OTHER,
			m_nDecodeWidth,
			m_nDecodeHeight,
			g_pMaterialSystem->GetBackBufferFormat(),
			TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_SINGLECOPY );

		KeyValues *pVMTKeyValues = new KeyValues( "screenspace_general" );
		pVMTKeyValues->SetInt( "$ignorez", 1 );
		pVMTKeyValues->SetInt( "$linearread_basetexture", 1 );
		pVMTKeyValues->SetInt( "$X360APPCHOOSER", 1 );
		pVMTKeyValues->SetString( "$PIXSHADER", "appchooser360movie_ps20b" );
		pVMTKeyValues->SetString( "$basetexture", textureName );

		m_pMaterial = g_pMaterialSystem->CreateMaterial( materialName, pVMTKeyValues );

		m_imageID = vgui::surface()->CreateNewTextureID();
		g_pMatSystemSurface->DrawSetTextureMaterial( m_imageID, m_pMaterial );

		SetPaintBackgroundEnabled( true );

		// initially invisible
		m_Color = Color( 255, 255, 255, 0 );

		m_FadeDelay = fadeDelay;
		m_pXMVPlayer = NULL;
		m_bStopping = false;
		m_StartTime = 0;
		m_StopTime = 0;
		m_pMovieEndCallback = NULL;
		m_bLooped = false;
		m_AspectRatio = 1.0f;
		m_bLetterbox = false;
	}

	void SetAspectRatio( float aspectRatio, bool bLetterbox )
	{
		if ( aspectRatio > 1.0f )
		{
			m_AspectRatio = aspectRatio;
			m_bLetterbox = bLetterbox;
		}
	}

	void SetColor( int r, int g, int b )
	{
		// set rgb only
		m_Color.SetColor( r, g, b, m_Color.a() );
	}

	// -1 means never have any audio, otherwise set to current target
	void InitUserAudioMix( bool bAudio )
	{
		m_CurrentVolume = bAudio ? g_TargetMovieVolume : -1;
	}

	// fade in/out based on user interaction with dashboard music system
	void UpdateMovieVolume( bool bForce, float frametime = 1.0f )
	{
		// m_CurrentVolume < 0 means this movie never plays audio
		if ( !m_pXMVPlayer || m_CurrentVolume < 0 )
			return;

		// forced update or new volume, ramp & set
		if ( bForce || g_TargetMovieVolume != m_CurrentVolume )
		{
			if ( bForce )
			{
				frametime = 1.0f;
			}

			m_CurrentVolume = Approach( g_TargetMovieVolume, m_CurrentVolume, frametime * 0.5f );
			
			// UNDONE: Under what conditions can this fail?  If it fails it could cause audible pops
			IXAudioSourceVoice *pVoice = NULL;
			HRESULT hr = m_pXMVPlayer->GetSourceVoice( &pVoice );
			if ( !FAILED( hr ) && pVoice )
			{
				pVoice->SetVolume( m_CurrentVolume );
			}
		}
	}

	bool StartMovieFromMemory( const void *pBuffer, int bufferSize, bool bAudio, bool bLoop, MovieEndCallback_t pMovieEndCallback = NULL )
	{
		if ( m_pXMVPlayer || m_bStopping )
		{
			// already started or currently stopping
			return false;
		}

		if ( !pBuffer || !bufferSize )
		{
			return false;
		}

		XMEDIA_XMV_CREATE_PARAMETERS xmvParameters;
		V_memset( &xmvParameters, 0, sizeof( xmvParameters ) );

		xmvParameters.dwFlags = XMEDIA_CREATE_CPU_AFFINITY;
		if ( bLoop )
		{
			xmvParameters.dwFlags |= XMEDIA_CREATE_FOR_LOOP;
			m_bLooped = true;
		}
		if ( !bAudio )
		{
			xmvParameters.dwAudioStreamId = (DWORD)XMEDIA_STREAM_ID_DONT_USE;
		}
		InitUserAudioMix(bAudio);

		xmvParameters.dwVideoDecoderCpu = 2;
		xmvParameters.dwVideoRendererCpu = 2;
		xmvParameters.dwAudioDecoderCpu = 4;
		xmvParameters.dwAudioRendererCpu = 4;
		xmvParameters.createType = XMEDIA_CREATE_FROM_MEMORY;
		xmvParameters.createFromMemory.pvBuffer = (PVOID)pBuffer;
		xmvParameters.createFromMemory.dwBufferSize = bufferSize;

		IDirect3DDevice9 *pD3DDevice = (IDirect3DDevice9 *)g_pMaterialSystem->GetD3DDevice();
		HRESULT hr = XMediaCreateXmvPlayer( pD3DDevice, &xmvParameters, &m_pXMVPlayer );
		if ( FAILED( hr ) )
		{
			return false;
		}

		m_pMovieEndCallback = pMovieEndCallback;

		RECT rect;
		rect.left = 0;
		rect.top = 0;
		rect.right = m_nDecodeWidth;
		rect.bottom = m_nDecodeHeight;
		m_pXMVPlayer->SetRectangle( &rect );
		UpdateMovieVolume( true );

		SetAlpha( 0 );
		m_StartTime = Plat_FloatTime() + m_FadeDelay;
		m_StopTime = 0;

		return true;
	}

	bool StartMovieFromFile( const char *pMovieName, bool bAudio, bool bLoop, MovieEndCallback_t pMovieEndCallback = NULL )
	{
		if ( m_pXMVPlayer || m_bStopping )
		{
			// already started or currently stopping
			return false;
		}

		XMEDIA_XMV_CREATE_PARAMETERS xmvParameters;
		V_memset( &xmvParameters, 0, sizeof( xmvParameters ) );

		xmvParameters.dwFlags = XMEDIA_CREATE_CPU_AFFINITY;
		if ( bLoop )
		{
			xmvParameters.dwFlags |= XMEDIA_CREATE_FOR_LOOP;
			m_bLooped = true;
		}
		if ( !bAudio )
		{
			xmvParameters.dwAudioStreamId = (DWORD)XMEDIA_STREAM_ID_DONT_USE;
		}
		InitUserAudioMix( bAudio );

		char szFilename[MAX_PATH];
		V_ComposeFileName( MOVIE_PATH, pMovieName, szFilename, sizeof( szFilename ) );

		xmvParameters.dwVideoDecoderCpu = 2;
		xmvParameters.dwVideoRendererCpu = 2;
		xmvParameters.dwAudioDecoderCpu = 4;
		xmvParameters.dwAudioRendererCpu = 4;
		xmvParameters.createType = XMEDIA_CREATE_FROM_FILE;
		xmvParameters.createFromFile.szFileName = szFilename;

		IDirect3DDevice9 *pD3DDevice = (IDirect3DDevice9 *)g_pMaterialSystem->GetD3DDevice();
		HRESULT hr = XMediaCreateXmvPlayer( pD3DDevice, &xmvParameters, &m_pXMVPlayer );
		if ( FAILED( hr ) )
		{
			return false;
		}

		m_pMovieEndCallback = pMovieEndCallback;

		RECT rect;
		rect.left = 0;
		rect.top = 0;
		rect.right = m_nDecodeWidth;
		rect.bottom = m_nDecodeHeight;
		m_pXMVPlayer->SetRectangle( &rect );
		UpdateMovieVolume( true );

		SetAlpha( 0 );
		m_StartTime = Plat_FloatTime() + m_FadeDelay;
		m_StopTime = 0;

		return true;
	}

	void StopMovie()
	{
		if ( !m_pXMVPlayer || m_bStopping )
		{
			// already stopped or currently stopping
			return;
		}

		m_bLooped = false;
		m_bStopping = true;
		m_pXMVPlayer->Stop( XMEDIA_STOP_IMMEDIATE );

		SetAlpha( 255 );
		m_StartTime = 0;
		m_StopTime = Plat_FloatTime() + m_FadeDelay;
	}

	virtual void PaintBackground( void )
	{
		if ( m_StartTime )
		{
			// fade up goes from [0..1] and holds on 1
			float t = ( Plat_FloatTime() - m_StartTime ) * 2.0f;
			t = clamp( t, 0.0f, 1.0f );
			SetAlpha( t * 255.0f );
		}

		if ( m_StopTime )
		{
			// fade out goes from [1..0] and holds on 0
			float t = ( Plat_FloatTime() - m_StopTime ) * 2.0f;
			t = 1.0f - clamp( t, 0.0f, 1.0f );
			SetAlpha( t * 255.0f );
			if ( m_Color.a() == 0 )
			{
				if ( m_bStopping && m_pMovieEndCallback )
				{
					m_pMovieEndCallback();
				}
				m_bStopping = false;
			}
		}

		if ( m_Color.a() != 0 )
		{
			int panelWidth, panelHeight;
			GetSize( panelWidth, panelHeight );

			float s0 = 0.0f;
			float s1 = 1.0f;
			int y = 0;
			if ( m_AspectRatio > 1.0f )
			{
				if ( m_bLetterbox )
				{
					// horizontal letterbox
					float adjustedHeight = (float)panelWidth / m_AspectRatio;
					float bandHeight = ( (float)panelHeight - adjustedHeight ) / 2;
					
					vgui::surface()->DrawSetColor( Color( 0, 0, 0, m_Color.a() ) );
					vgui::surface()->DrawFilledRect( 0, 0, panelWidth, bandHeight );
					vgui::surface()->DrawFilledRect( 0, panelHeight - bandHeight, panelWidth, panelHeight );

					y = bandHeight;
					panelHeight = adjustedHeight;
				}
				else
				{
					// hold the panel's height constant, determine the corresponding aspect corrected image width
					float imageWidth = (float)panelHeight * m_AspectRatio;
					// adjust the image width as a percentage of the panel's width
					// scale and center;
					s1 = (float)panelWidth / imageWidth;
					s0 = ( 1 - s1 ) / 2.0f;
					s1 = s0 + s1;
				}
			}

			vgui::surface()->DrawSetColor( m_Color );
			vgui::surface()->DrawSetTexture( m_imageID );
			vgui::surface()->DrawTexturedSubRect( 0, y, panelWidth, y+panelHeight, s0, 0.0f, s1, 1.0f );
		}
	}

	bool IsFullyReleased()
	{
		// fully stopped and released when object no longer exists
		return ( m_pXMVPlayer == NULL ) && ( m_bStopping == false );
	}

	bool RenderVideoFrame()
	{
		if ( !m_pXMVPlayer )
		{
			return false;
		}

		// If RenderNextFrame does not return S_OK then the frame was not
		// rendered (perhaps because it was cancelled) so a regular frame
		// buffer should be rendered before calling present.
		bool bRenderedFrame = true;
		HRESULT hr = m_pXMVPlayer->RenderNextFrame( 0, NULL );
		if ( FAILED( hr ) || hr == XMEDIA_W_EOF )
		{
			bRenderedFrame = false;

			if ( !m_bLooped )
			{
				// Release the movie object
				m_pXMVPlayer->Release();
				m_pXMVPlayer = NULL;

				if ( !m_bStopping )
				{
					m_bStopping = true;
					SetAlpha( 255 );
					m_StartTime = 0;
					m_StopTime = Plat_FloatTime() + m_FadeDelay;
				}
			}
		}

		// UNDONE: Need a frametime here.  Assume it's 30fps.
		// NOTE: This is only used to time audio fades, so if it's wrong by 2X it's not
		// going to be noticeable.  Probably fine to ship this.
		UpdateMovieVolume( false, 1.0f / 30.0f );

		// Reset our cached view of what pixel and vertex shaders are set, because
		// it is no longer accurate, since XMV will have set their own shaders.
		// This avoids problems when the shader cache thinks it knows what shader
		// is set and it is wrong.
		IDirect3DDevice9 *pD3DDevice = (IDirect3DDevice9 *)g_pMaterialSystem->GetD3DDevice();
		pD3DDevice->SetVertexShader( NULL );
		pD3DDevice->SetPixelShader( NULL );
		pD3DDevice->SetVertexDeclaration( NULL );
		pD3DDevice->SetRenderState( D3DRS_VIEWPORTENABLE, TRUE );

		if ( bRenderedFrame )
		{
			CMatRenderContextPtr pRenderContext( g_pMaterialSystem );

			Rect_t rect;
			rect.x = 0;
			rect.y = 0;
			rect.width = m_nDecodeWidth;
			rect.height = m_nDecodeHeight;
			pRenderContext->CopyRenderTargetToTextureEx( m_pTexture, 0, &rect );
		}

		return bRenderedFrame;
	}

private:
	void SetAlpha( int alpha )
	{
		// set alpha only
		alpha = clamp( alpha, 0, 255 );
		m_Color.SetColor( m_Color.r(), m_Color.g(), m_Color.b(), alpha );
	}

	int					m_imageID;
	Color				m_Color;
	IXMediaXmvPlayer	*m_pXMVPlayer;
	ITexture			*m_pTexture;
	IMaterial			*m_pMaterial;
	bool				m_bStopping;
	bool				m_bLooped;
	float				m_StartTime;
	float				m_StopTime;
	int					m_nDecodeWidth;
	int					m_nDecodeHeight;
	float				m_FadeDelay;
	float				m_AspectRatio;
	float				m_CurrentVolume;
	bool				m_bLetterbox;
	MovieEndCallback_t	m_pMovieEndCallback;
};

class CShadowLabel : public vgui::Label
{
	DECLARE_CLASS_SIMPLE( CShadowLabel, vgui::Label );
public:
	CShadowLabel( vgui::Panel *pParent, const char *pName, const wchar_t *pText ) : BaseClass( pParent, pName, pText ) 
	{
	}

	virtual void Paint( void )
	{
		BaseClass::Paint();
		BaseClass::Paint();
		BaseClass::Paint();
		BaseClass::Paint();
		BaseClass::Paint();
	}
};

class CGamePanel : public vgui::Panel
{
	DECLARE_CLASS_SIMPLE( CGamePanel, vgui::Panel );
public:
	CGamePanel( vgui::Panel *pParent, const char *pName, game_t *pGame, bool bIsWidescreen, KeyValues *pKVSettings ) : BaseClass( pParent, pName ) 
	{
		m_bEnabled = pGame->bEnabled;

		vgui::HScheme hScheme = vgui::scheme()->GetScheme( "SourceScheme" );
		vgui::IScheme *pSourceScheme = vgui::scheme()->GetIScheme( hScheme );

		KeyValues *pKV = pKVSettings->FindKey( "GamePanel" );
		int panelWidth = pKV->GetInt( "wide" );
		int panelHeight = pKV->GetInt( "tall" );
		SetSize( panelWidth, panelHeight );

		// thumbnail static image
		char szFilename[MAX_PATH];
		V_snprintf( szFilename, sizeof( szFilename ), "vgui/appchooser/%s", pGame->pGameDir );
		pKV = pKVSettings->FindKey( "GameImage" );
		int y = pKV->GetInt( "ypos" );
		int w = pKV->GetInt( "wide" );
		int h = pKV->GetInt( "tall" );
		int x = ( panelWidth - w ) / 2;
		m_pThumbImage = new CImage( this, "GameImage", szFilename );
		SETUP_PANEL( m_pThumbImage );
		m_pThumbImage->SetBounds( x, y, w, h );
		m_pThumbImage->SetAspectRatio( bIsWidescreen ? 1.0f : 1.778f, false );
		m_pThumbImage->SetVisible( true );

		// thumbnail movie
		m_pMovieImage = new CMovieImage( this, "Movie", pGame->pGameDir, 256, 256, 0.2f );
		SETUP_PANEL( m_pMovieImage );
		m_pMovieImage->SetBounds( x, y, w, h );
		m_pMovieImage->SetVisible( true );
		V_snprintf( szFilename, sizeof( szFilename ), "%s\\thumb_%s.wmv", MOVIE_PATH, pGame->pGameDir );
		if ( !g_pFullFileSystem->ReadFile( szFilename, NULL, m_MovieBuffer ) )
		{
			m_MovieBuffer.Purge();
		}

		// game title shadow
		pKV = pKVSettings->FindKey( "GameTitle" );
		y = pKV->GetInt( "ypos" );
		m_pTitleShadow = new CShadowLabel( this, "GameTitle", pGame->pName );
		SETUP_PANEL( m_pTitleShadow );
		m_pTitleShadow->SetVisible( true );
		m_pTitleShadow->SetFont( pSourceScheme->GetFont( "AppChooserGameTitleFontBlur" ) );
		m_pTitleShadow->SizeToContents();
		m_pTitleShadow->SetPos( 0, y );
		m_pTitleShadow->SetWide( panelWidth );
		m_pTitleShadow->SetContentAlignment( vgui::Label::a_center );
		m_pTitleShadow->SetPaintBackgroundEnabled( false );
		m_pTitleShadow->SetFgColor( Color( 0, 0, 0, 255 ) );

		// game title
		m_pTitle = new vgui::Label( this, "GameTitle", pGame->pName );
		SETUP_PANEL( m_pTitle );
		m_pTitle->SetVisible( true );
		m_pTitle->SetFont( pSourceScheme->GetFont( "AppChooserGameTitleFont" ) );
		m_pTitle->SizeToContents();
		m_pTitle->SetPos( 0, y );
		m_pTitle->SetWide( panelWidth );
		m_pTitle->SetContentAlignment( vgui::Label::a_center );
		m_pTitle->SetPaintBackgroundEnabled( false );
		m_pTitle->SetFgColor( Color( 255, 255, 255, 255 ) );

		// button bounds
		vgui::HFont hFont = pSourceScheme->GetFont( "GameUIButtons" );
		pKV = pKVSettings->FindKey( "GameButton" );
		y = panelHeight - vgui::surface()->GetFontTall( hFont ) -  pKV->GetInt( "ypos" );
		m_pButtonText = new vgui::Label( this, "GameButton", g_pVGuiLocalize->Find( "#GameUI_Icons_A_BUTTON" ) );
		SETUP_PANEL( m_pButtonText );
		m_pButtonText->SetVisible( false );
		m_pButtonText->SetFont( hFont );
		m_pButtonText->SizeToContents();
		m_pButtonText->SetPos( 0, y );
		m_pButtonText->SetWide( panelWidth );
		m_pButtonText->SetContentAlignment( vgui::Label::a_center );
		m_pButtonText->SetPaintBackgroundEnabled( false );
		m_pButtonText->SetFgColor( Color( 255, 255, 255, 255 ) );
	}

	~CGamePanel( void )
	{
	}

	void SetSelected( bool bSelected )
	{
		m_pButtonText->SetVisible( m_bEnabled ? bSelected : false );
		if ( bSelected )
		{
			SetBgColor( Color( 190, 115, 0, 128 ) );
			m_pThumbImage->SetColor( 255, 255, 255 );
			m_pMovieImage->SetColor( 255, 255, 255 );
			m_pTitle->SetFgColor( Color( 255, 255, 255, 255 ) );
		}
		else
		{
			SetBgColor( Color( 160, 160, 160, 50 ) );
			m_pThumbImage->SetColor( 100, 100, 100 );
			m_pMovieImage->SetColor( 120, 120, 120 );
			m_pTitle->SetFgColor( Color( 140, 140, 140, 255 ) );
		}
	}

	void StartMovie()
	{
		m_pMovieImage->StartMovieFromMemory( m_MovieBuffer.Base(), m_MovieBuffer.TellMaxPut(), true, true );
	}

	void StopMovie()
	{
		m_pMovieImage->StopMovie();
	}

	CImage				*m_pThumbImage;
	CMovieImage			*m_pMovieImage;
	CShadowLabel		*m_pTitleShadow;
	vgui::Label			*m_pTitle;
	vgui::Label			*m_pButtonText;
	CUtlBuffer			m_MovieBuffer;
	bool				m_bEnabled;
	int					m_imageID;
};

//-----------------------------------------------------------------------------
// Simple XAudio wrapper to instance a sound. Provides lightweight audio feedback for ui.
// Instance this per sound.
//-----------------------------------------------------------------------------
class CXSound
{
public:
	CXSound()
	{
		for ( int i=0; i<ARRAYSIZE( m_pSourceVoices ); i++ )
		{
			m_pSourceVoices[i] = NULL;
		}
		m_pXMAData = NULL;
		m_nXMADataSize = 0;
		m_numVoices = 0;
	}

	~CXSound()
	{
		Stop();
		Release();
	}

	//-----------------------------------------------------------------------------
	// Setup the wave, caller can clamp the number of simultaneous playing instances
	// of this sound. Useful for ui clicks to keep up with rapid input.
	//-----------------------------------------------------------------------------
	bool SetupWave( const char *pFilename, int numSimultaneous = 1 )
	{
		CUtlBuffer buf;
		if ( !g_pFullFileSystem->ReadFile( pFilename, "GAME", buf ) )
		{
			Msg( "SetupWave: File '%s' not found\n", pFilename );
			return false;
		}

		// only supporting xwv format
		xwvHeader_t* pHeader = (xwvHeader_t *)buf.Base();
		if ( pHeader->id != XWV_ID || pHeader->version != XWV_VERSION || pHeader->format != XWV_FORMAT_XMA )
		{
			Msg( "SetupWave: File '%s' has bad format\n", pFilename );
			return false;
		}

		XAUDIOSOURCEVOICEINIT SourceVoiceInit = { 0 };
		SourceVoiceInit.Format.SampleType = XAUDIOSAMPLETYPE_XMA;
		SourceVoiceInit.Format.NumStreams = 1;
		SourceVoiceInit.MaxPacketCount = 1;
		SourceVoiceInit.Format.Stream[0].SampleRate = pHeader->GetSampleRate();
		SourceVoiceInit.Format.Stream[0].ChannelCount = pHeader->channels;

		// create enough source voices to support simultaneous play of this sound
		HRESULT hr;
		numSimultaneous = min( numSimultaneous, ARRAYSIZE( m_pSourceVoices ) );
		for ( int i=0; i<numSimultaneous; i++ )
		{
			// create the voice
			hr = XAudioCreateSourceVoice( &SourceVoiceInit, &m_pSourceVoices[i] );
			if ( FAILED( hr ) )
			{
				return false;
			}
		}
		m_numVoices = numSimultaneous;

		// get the xma data
		m_nXMADataSize = pHeader->dataSize;
		m_pXMAData = (unsigned char *)XPhysicalAlloc( m_nXMADataSize, MAXULONG_PTR, 0, PAGE_READWRITE );
		V_memcpy( m_pXMAData, (unsigned char *)buf.Base() + pHeader->dataOffset, m_nXMADataSize );

		return true;
	}

	bool IsPlaying()
	{
		XAUDIOSOURCESTATE SourceState;
		for ( int i=0; i<m_numVoices; i++ )
		{
			m_pSourceVoices[i]->GetVoiceState( &SourceState );
			if ( SourceState & XAUDIOSOURCESTATE_STARTED )
			{
				return true;
			}
		}
		return false;
	}

	void Play()
	{
		int numPlaying = 0;
		XAUDIOSOURCESTATE SourceState;
		for ( int i=0; i<m_numVoices; i++ )
		{
			m_pSourceVoices[i]->GetVoiceState( &SourceState );
			if ( SourceState & XAUDIOSOURCESTATE_STARTED )
			{
				numPlaying++;
			}
		}
		if ( numPlaying >= m_numVoices )
		{
			return;
		}

		// find a free voice
		IXAudioSourceVoice *pVoice = NULL;
		for ( int i=0; i<m_numVoices; i++ )
		{
			m_pSourceVoices[i]->GetVoiceState( &SourceState );
			if ( !( SourceState & XAUDIOSOURCESTATE_STARTED ) )
			{
				// use the free voice
				pVoice = m_pSourceVoices[i];
				break;
			}
		}
		if ( !pVoice )
		{
			// none free
			return;
		}

		// Set up packet
		XAUDIOPACKET Packet = { 0 };
		Packet.pBuffer = m_pXMAData;
		Packet.BufferSize = m_nXMADataSize;

		// Submit packet
		HRESULT hr = pVoice->SubmitPacket( &Packet, XAUDIOSUBMITPACKET_DISCONTINUITY );
		if ( !FAILED( hr ) )
		{
			pVoice->Start( 0 );
		}
	}

	void Stop()
	{
		for ( int i=0; i<m_numVoices; i++ )
		{
			m_pSourceVoices[i]->Stop( 0 );
		}
	}

	void Release()
	{
		for ( int i=0; i<ARRAYSIZE( m_pSourceVoices ); i++ )
		{
			if ( m_pSourceVoices[i] )
			{
				m_pSourceVoices[i]->Release();
				m_pSourceVoices[i] = NULL;
			}
		}
		if ( m_pXMAData )
		{
			XPhysicalFree( m_pXMAData );
			m_pXMAData = NULL;
		}
		m_nXMADataSize = 0;
		m_numVoices = 0;
	}

private:
	IXAudioSourceVoice	*m_pSourceVoices[4];
	unsigned char		*m_pXMAData;
	int					m_nXMADataSize;
	int					m_numVoices;
};

//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
class CAppChooser : public CVguiSteamApp
{
	typedef CVguiSteamApp BaseClass;

public:
	virtual bool	Create();
	virtual bool	PreInit();
	virtual int		Main();
	virtual void	Destroy();

	void			OnSelectionPrevious();
	void			OnSelectionNext();
	void			OnActivateGame();
	void			OnInactivityTimeout();
	void			OnStopDemoMovie();
	void			OnDemoMovieEnd();
	void			OnStopStartupMovie();
	void			Reset();
	void			ResetTimeout( float timeout );
	bool			IsInputEnabled() { return m_bInputEnabled; }
	bool			IsDemoMoviePlaying() { return m_bPlayingDemoMovie; }
	bool			IsStartupMoviePlaying() { return m_bPlayingStartupMovies; }
	void			HandleInvite( DWORD nUserId  );
 
private:
	const char		*GetAppName() { return "AppChooser"; }

	bool			CreateWindow( int width, int height, bool fullscreen );
	bool			InitMaterialSystem();
	bool			InitVGUI();
	void			ShutdownVGUI();
	bool			InitAudio();
	void			ShutdownAudio();
	void			FrameTick();
	void			RenderScene();
	void			ExitChooser();
	void			EnableInput( bool bEnable );
	void			StartExitingProcess();
	void			SetLoadingIconPosition( bool bIsMultiplayer );

	int				m_nScreenWidth;
	int				m_nScreenHeight;
	HWND			m_hWnd;
	float			m_FadeInTime;
	float			m_FadeOutTime;
	float			m_StartTime;
	float			m_Timeout;
	int				m_Selection;
	int				m_LastSelection;
	bool			m_bInputEnabled;
	int				m_ExitingFrameCount;
	float			m_GameMovieStartTime;
	float			m_BackgroundMovieStartTime;
	int				m_LastBackgroundMovie;
	int				m_StartupMovie;

	// various operating states
	bool			m_bPlayingStartupMovies;
	bool			m_bPlayingDemoMovie;
	bool			m_bExiting;
	
	// Live invite handling
	bool			m_bInviteAccepted;
	XNKID			m_InviteSessionID;
	DWORD			m_nInviteUserID;
	
	int				m_iImageID;
	vgui::Panel		*m_pRootPanel;
	CImage			*m_pPersistedImage;
	CImage			*m_pOverlay;
	CImage			*m_pFullBlack;
	CMovieImage		*m_pStartupMovieImage;
	CMovieImage		*m_pBackgroundMovie;
	CMovieImage		*m_pDemoMovieImage;
	CGamePanel		*m_pGames[ARRAYSIZE( g_Games )];
	CImage			*m_pProductTitle;
	CShadowLabel	*m_pInstructionsShadow;
	vgui::Label		*m_pInstructions;
	vgui::Label		*m_pLoading;
	CImage			*m_pLoadingIcon;
	CImage			*m_pProductBackgrounds[ARRAYSIZE( g_Games )];
	DWORD			m_iStorageDeviceID;
	DWORD			m_iUserIdx;
	KeyValues		*m_pKVSettings;
	int				m_DemoMovie;

	CXSound			m_Click;
	CXSound			m_Clack;
	CXSound			m_Deny;
};

CAppChooser g_AppChooserSystem;

//--------------------------------------------------------------------------------------
// InitMaterialSystem
//
//--------------------------------------------------------------------------------------
bool CAppChooser::InitMaterialSystem()
{
	RECT rect;
	
	MaterialSystem_Config_t config;
	config.SetFlag( MATSYS_VIDCFG_FLAGS_WINDOWED, IsPC() ? true : false );
	config.SetFlag( MATSYS_VIDCFG_FLAGS_NO_WAIT_FOR_VSYNC, 0 );

	config.m_VideoMode.m_Width = 0;
	config.m_VideoMode.m_Height = 0;
	config.m_VideoMode.m_Format = IMAGE_FORMAT_BGRX8888;
	config.m_VideoMode.m_RefreshRate = 0;
	config.dxSupportLevel = IsX360() ? 98 : 0;

	g_pMaterialSystem->ModInit();
	bool modeSet = g_pMaterialSystem->SetMode( m_hWnd, config );
	if ( !modeSet )
	{
		Error( "Failed to set mode\n" );
		return false;
	}

	g_pMaterialSystem->OverrideConfig( config, false );

	GetClientRect( m_hWnd, &rect );
	m_nScreenWidth = rect.right;
	m_nScreenHeight = rect.bottom;

	return true;
}

void CAppChooser::SetLoadingIconPosition( bool bIsMultiplayer )
{
	// matches config from matsys_interface.cpp::InitStartupScreen()
	float flNormalizedX;
	float flNormalizedY;
	float flNormalizedSize;
	if ( !bIsMultiplayer )
	{
		flNormalizedX = 0.5f;
		flNormalizedY = 0.86f;
		flNormalizedSize = 0.1f;
	}
	else
	{
		flNormalizedX = 0.5f;
		flNormalizedY = 0.9f;
		flNormalizedSize = 0.1f;
	}

	// matches calcs from CShaderDeviceDx8::RefreshFrontBufferNonInteractive()
	float flXPos = flNormalizedX;
	float flYPos = flNormalizedY;
	float flHeight = flNormalizedSize;
	int nSize = m_nScreenHeight * flHeight;
	int x = m_nScreenWidth * flXPos - nSize * 0.5f;
	int y = m_nScreenHeight * flYPos - nSize * 0.5f;
	int w = nSize;
	int h = nSize;
	m_pLoadingIcon->SetBounds( x, y, w, h );
}

//-----------------------------------------------------------------------------
// Setup all our VGUI info
//-----------------------------------------------------------------------------

bool CAppChooser::InitVGUI( void )
{
	int x, y, w, h, g;
	KeyValues *pKV;

	vgui::surface()->GetScreenSize( w, h );
	float aspectRatio = (float)w/(float)h;
	bool bIsWidescreen = ( aspectRatio >= 1.7f );
	bool bIsHiDef = h > 480;

	const char *pResolutionKey = "";
	if ( bIsWidescreen )
	{
		// 16:9 aspect
		if ( bIsHiDef )
		{
			pResolutionKey = "_hidef";
		}
		else
		{
			pResolutionKey = "_lodef_wide";
		}
	}
	else
	{
		// 4:3 apsect
		if ( bIsHiDef )
		{
			pResolutionKey = "_hidef_norm";
		}
		else
		{
			pResolutionKey = "_lodef";
		}
	}

	// Start vgui
	vgui::ivgui()->Start();
	vgui::ivgui()->SetSleep( false );

	// load the scheme
	vgui::scheme()->LoadSchemeFromFile( "resource/sourcescheme.res", NULL );
	vgui::HScheme hScheme = vgui::scheme()->GetScheme( "SourceScheme" );
	vgui::IScheme *pSourceScheme = vgui::scheme()->GetIScheme( hScheme );

	m_pKVSettings = new KeyValues( "AppChooser.res" );
	if ( m_pKVSettings->LoadFromFile( g_pFullFileSystem, "resource/UI/AppChooser.res", "GAME" ) )
	{
		m_pKVSettings->ProcessResolutionKeys( pResolutionKey );
	}
	else
	{
		return false;
	}

	// localization
	g_pVGuiLocalize->AddFile( "resource/gameui_%language%.txt" ,"GAME", true );

	// Init the root panel
	m_pRootPanel = new vgui::Panel( NULL, "RootPanel" );
	m_pRootPanel->SetBounds( 0, 0, m_nScreenWidth, m_nScreenHeight );
	m_pRootPanel->SetPaintBackgroundEnabled( true );
	m_pRootPanel->SetVisible( true );
	vgui::surface()->SetEmbeddedPanel( m_pRootPanel->GetVPanel() );

	// need a full pure opaque black before all panel drawing
	// this fixes the top of frame xmv video render work
	m_pFullBlack = new CImage( m_pRootPanel, "FullBlack", "vgui/black" );
	SETUP_PANEL( m_pFullBlack );
	m_pFullBlack->SetBounds( 0, 0, m_nScreenWidth, m_nScreenHeight );
	m_pFullBlack->SetVisible( true );

	// all the background movies were authored for widescreen
	m_pBackgroundMovie = new CMovieImage( m_pRootPanel, "Movie", "Background", m_nScreenWidth, m_nScreenHeight, 0.0f );
	SETUP_PANEL( m_pBackgroundMovie );
	m_pBackgroundMovie->SetBounds( 0, 0, m_nScreenWidth, m_nScreenHeight );
	m_pBackgroundMovie->SetAspectRatio( bIsWidescreen ? 1.0f : 1.778f, false );
	m_pBackgroundMovie->SetColor( 255, 255, 255 );
	m_pBackgroundMovie->SetVisible( true );

	pKV = m_pKVSettings->FindKey( "Logo" );
	y = pKV->GetInt( "ypos" );
	w = pKV->GetInt( "wide" );
	h = pKV->GetInt( "tall" );
	m_pProductTitle = new CImage( m_pRootPanel, "Logo", "vgui/appchooser/orangeboxlogo" );
	SETUP_PANEL( m_pProductTitle );
	m_pProductTitle->SetBounds( ( m_nScreenWidth - w )/2, y, w, h );
	m_pProductTitle->SetVisible( true );

	wchar_t *pString = g_pVGuiLocalize->Find( "#GameUI_AppChooser_SelectGame" );
	pKV = m_pKVSettings->FindKey( "SelectGame" );
	y = pKV->GetInt( "ypos" );
	m_pInstructionsShadow = new CShadowLabel( m_pRootPanel, "SelectGame", pString );
	SETUP_PANEL( m_pInstructionsShadow );
	m_pInstructionsShadow->SetFont( pSourceScheme->GetFont( "ChapterTitleBlur" ) );
	m_pInstructionsShadow->SizeToContents();
	m_pInstructionsShadow->SetWide( m_nScreenWidth );
	m_pInstructionsShadow->SetPos( 0, y );
	m_pInstructionsShadow->SetContentAlignment( vgui::Label::a_center );
	m_pInstructionsShadow->SetPaintBackgroundEnabled( false );
	m_pInstructionsShadow->SetFgColor( Color( 0, 0, 0, 255) );

	m_pInstructions = new vgui::Label( m_pRootPanel, "SelectGame", pString );
	SETUP_PANEL( m_pInstructions );
	m_pInstructions->SetFont( pSourceScheme->GetFont( "ChapterTitle" ) );
	m_pInstructions->SizeToContents();
	m_pInstructions->SetWide( m_nScreenWidth );
	m_pInstructions->SetPos( 0, y );
	m_pInstructions->SetContentAlignment( vgui::Label::a_center );
	m_pInstructions->SetPaintBackgroundEnabled( false );
	m_pInstructions->SetFgColor( Color( 255, 255, 255, 255) );

	pKV = m_pKVSettings->FindKey( "GamePanel" );
	w = pKV->GetInt( "wide" );
	g = pKV->GetInt( "gap" );
	x = ( m_nScreenWidth - ( (int)( ARRAYSIZE( g_Games ) ) * ( w + g ) - g ) ) / 2;
	y = pKV->GetInt( "ypos" );
	for ( int i=0; i<ARRAYSIZE( g_Games ); i++ )
	{
		m_pGames[i] = new CGamePanel( m_pRootPanel, "GamePanel", &g_Games[i], bIsWidescreen, m_pKVSettings );
		SETUP_PANEL( m_pGames[i] );
		m_pGames[i]->SetPos( x, y );
		m_pGames[i]->SetPaintBackgroundType( 2 );
		m_pGames[i]->SetSelected( false );
		x += w + g;
	}

	// the product backgrounds are topmost and used as fade out materials
	for ( int i=0; i<ARRAYSIZE( g_Games ); i++ )
	{
		char filename[MAX_PATH];
		V_snprintf( filename, sizeof( filename ), "vgui/appchooser/background_%s%s", g_Games[i].pGameDir, bIsWidescreen ? "_widescreen" : "" );
		m_pProductBackgrounds[i] = new CImage( m_pRootPanel, "Products", filename );
		SETUP_PANEL( m_pProductBackgrounds[i] );
		m_pProductBackgrounds[i]->SetBounds( 0, 0, m_nScreenWidth, m_nScreenHeight );
		m_pProductBackgrounds[i]->SetVisible( true );
		m_pProductBackgrounds[i]->SetAlpha( 0 );
	}

	pString = g_pVGuiLocalize->Find( "#GameUI_Loading" );
	y = m_nScreenHeight / 2;
	m_pLoading = new vgui::Label( m_pRootPanel, "Text", pString );
	SETUP_PANEL( m_pLoading );
	m_pLoading->SetFont( pSourceScheme->GetFont( "ChapterTitle" ) );
	m_pLoading->SizeToContents();
	m_pLoading->SetWide( m_nScreenWidth );
	m_pLoading->SetPos( 0, y );
	m_pLoading->SetContentAlignment( vgui::Label::a_center );
	m_pLoading->SetPaintBackgroundEnabled( false );
	m_pLoading->SetFgColor( Color( 255, 255, 255, 255) );
	m_pLoading->SetVisible( false );

	m_pLoadingIcon = new CImage( m_pRootPanel, "LoadingIcon", "vgui/appchooser/loading_icon" );
	SETUP_PANEL( m_pLoadingIcon );
	SetLoadingIconPosition( false );
	m_pLoadingIcon->SetVisible( false );
	m_pLoadingIcon->SetAlpha( 0 );

	// create back buffer cloned texture
	ITexture *pTexture = NULL;
	if ( XboxLaunch()->GetLaunchFlags() & LF_INTERNALLAUNCH )
	{
		pTexture = g_pMaterialSystem->CreateProceduralTexture( 
			"PersistedTexture", 
			TEXTURE_GROUP_OTHER,
			m_nScreenWidth,
			m_nScreenHeight,
			g_pMaterialSystem->GetBackBufferFormat(),
			TEXTUREFLAGS_NOMIP | TEXTUREFLAGS_SINGLECOPY );

		// the persisted texture is in the back buffer, get it
		CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
		pRenderContext->CopyRenderTargetToTexture( pTexture );
	}

	// create a material to bind the persisted texture
	// the fade-in material is topmost, fully opaque, and fades to transluscent on initial rendering
	KeyValues *pVMTKeyValues = new KeyValues( "UnlitGeneric" );
	pVMTKeyValues->SetInt( "$vertexcolor", 1 );
	pVMTKeyValues->SetInt( "$vertexalpha", 1 );
	pVMTKeyValues->SetInt( "$linearwrite", 1 );    // These 2 lines are needed so that we don't lose bits of precision in
	pVMTKeyValues->SetInt( "$gammacolorread", 1 ); // the dark colors due to the 360's lossy sRGB read hardware
	pVMTKeyValues->SetInt( "$ignorez", 1 );
	if ( pTexture )
	{
		pVMTKeyValues->SetString( "$basetexture", "PersistedTexture" );
	}
	else
	{
		// there is no persisted texture, fade in from black
		pVMTKeyValues->SetString( "$basetexture", "vgui/black" );
	}
	IMaterial *pFadeInMaterial = g_pMaterialSystem->CreateMaterial( "__FadeInMaterial.vmt", pVMTKeyValues );

	// the persisted image is either the image from the relaunch or black during first boot
	m_pPersistedImage = new CImage( m_pRootPanel, "FadeInOverlay", pFadeInMaterial );
	SETUP_PANEL( m_pPersistedImage );
	m_pPersistedImage->SetBounds( 0, 0, m_nScreenWidth, m_nScreenHeight );
	m_pPersistedImage->SetVisible( true );
	m_pPersistedImage->SetAlpha( 255 );
	m_pOverlay = m_pPersistedImage;

	// full screen demo movie, use letterboxing
	m_pDemoMovieImage = new CMovieImage( m_pRootPanel, "Movie", "Demo", m_nScreenWidth, m_nScreenHeight, 2.0f );
	SETUP_PANEL( m_pDemoMovieImage );
	m_pDemoMovieImage->SetBounds( 0, 0, m_nScreenWidth, m_nScreenHeight );
	m_pDemoMovieImage->SetAspectRatio( bIsWidescreen ? 1.0f : 1.778f, true );
	m_pDemoMovieImage->SetVisible( true );

	// full screen startup movies, use letterboxing, instant start
	m_pStartupMovieImage = new CMovieImage( m_pRootPanel, "Movie", "Startup", m_nScreenWidth, m_nScreenHeight, 0.0f );
	SETUP_PANEL( m_pStartupMovieImage );
	m_pStartupMovieImage->SetBounds( 0, 0, m_nScreenWidth, m_nScreenHeight );
	m_pStartupMovieImage->SetAspectRatio( bIsWidescreen ? 1.0f : 1.778f, true );
	m_pStartupMovieImage->SetVisible( true );

	return true;
}

//-----------------------------------------------------------------------------
// Stop VGUI
//-----------------------------------------------------------------------------
void CAppChooser::ShutdownVGUI( void )
{
	delete m_pRootPanel;
}

//-----------------------------------------------------------------------------
// Initialize Audio
//-----------------------------------------------------------------------------
bool CAppChooser::InitAudio()
{
	// Set up initialize parameters of XAudio Engine
	// Both threads on core 2
	XAUDIOENGINEINIT EngineInit = { 0 };
	EngineInit.pEffectTable = &XAudioDefaultEffectTable;
	EngineInit.ThreadUsage = XAUDIOTHREADUSAGE_THREAD4 | XAUDIOTHREADUSAGE_THREAD5;

	// Initialize the XAudio Engine
	HRESULT hr = XAudioInitialize( &EngineInit );
	if ( FAILED( hr ) )
	{
		Error( "Error calling XAudioInitialize\n" );
	}

	m_Click.SetupWave( "sound/ui/buttonclick.360.wav", 2 );
	m_Clack.SetupWave( "sound/ui/buttonclickrelease.360.wav", 2 );
	m_Deny.SetupWave( "sound/player/suit_denydevice.360.wav", 2 );

	return true;
}

void CAppChooser::ShutdownAudio()
{
	// Shut down and free XAudio resources
	XAudioShutDown();
}

//--------------------------------------------------------------------------------------
// Reset timeout
//--------------------------------------------------------------------------------------
void CAppChooser::ResetTimeout( float timeout )
{
	if ( timeout > 0 )
	{
		m_Timeout = Plat_FloatTime() + timeout;
	}
	else
	{
		m_Timeout = 0;
	}
}

//--------------------------------------------------------------------------------------
// Intialization Reset. Expected to be called once after inits.
//--------------------------------------------------------------------------------------
void CAppChooser::Reset()
{
	// set selection to previous game or default
	m_Selection = 0;
	m_LastSelection = 0;
	const char *pGameName = CommandLine()->ParmValue( "-game", "ep2" );
	for ( int i=0; i<ARRAYSIZE( g_Games ); i++ )
	{
		if ( V_stristr( pGameName, g_Games[i].pGameDir ) )
		{
			m_Selection = i;
			break;
		}
	}

	// get the storage device
	m_iStorageDeviceID = XboxLaunch()->GetStorageID();
	Msg( "Storage ID: %d", m_iStorageDeviceID );

	// Set the user index
	m_iUserIdx = XboxLaunch()->GetUserID();
	if ( g_pInputSystem )
	{
		g_pInputSystem->SetPrimaryUserId( m_iUserIdx );
	}
	XBX_SetPrimaryUserId( m_iUserIdx );
	Msg( "User ID: %d", m_iUserIdx );

	m_StartTime = Plat_FloatTime();
	m_FadeInTime = 0;
	m_FadeOutTime = 0;

	m_bExiting = false;
	m_ExitingFrameCount = 0;

	m_bPlayingDemoMovie = false;
	m_DemoMovie = 0;

	// background movie and selection startup in sync
	m_LastBackgroundMovie = m_Selection;
	m_BackgroundMovieStartTime = 0;
	m_GameMovieStartTime = 0;

	EnableInput( true );

	if ( !( XboxLaunch()->GetLaunchFlags() & LF_INTERNALLAUNCH ) )
	{
		// first time boot
		// startup movies play first, and never again
		ResetTimeout( 0 );

		m_StartupMovie = -1;	
		m_bPlayingStartupMovies = true;
	}
	else
	{
		// normal background startup
		ResetTimeout( INACTIVITY_TIMEOUT );

		// foreground movie starts a little staggered
		m_BackgroundMovieStartTime = Plat_FloatTime();
		m_GameMovieStartTime = m_BackgroundMovieStartTime + 1.0f;
	}

	// Init our invite data
	m_bInviteAccepted = false;
	m_nInviteUserID = XBX_INVALID_USER_ID;
	memset( (void *)&m_InviteSessionID, 0, sizeof( m_InviteSessionID ) );
}

//--------------------------------------------------------------------------------------
// Handle previous selection
//--------------------------------------------------------------------------------------
void CAppChooser::OnSelectionPrevious()
{
	// backward wraparound
	m_Selection = ( m_Selection + ARRAYSIZE( g_Games ) - 1 ) % ARRAYSIZE( g_Games );
	m_Click.Play();
}

//--------------------------------------------------------------------------------------
// Handle next selection
//--------------------------------------------------------------------------------------
void CAppChooser::OnSelectionNext()
{
	// forward wraparound
	m_Selection = ( m_Selection + ARRAYSIZE( g_Games ) + 1 ) % ARRAYSIZE( g_Games );
	m_Click.Play();
}

void CAppChooser::EnableInput( bool bEnable )
{
	m_bInputEnabled = bEnable;
}

//--------------------------------------------------------------------------------------
// Chooser exits
//--------------------------------------------------------------------------------------
void CAppChooser::ExitChooser()
{
	// reset stale arguments that encode prior game
	// launcher will establish correct arguments based on desired game
	CommandLine()->RemoveParm( "-game" );
	CommandLine()->AppendParm( "-game", g_Games[m_Selection].pGameDir );

	// Special command line parameter for tf. Command line args persist across
	// relaunches, so remove it first in case we came from tf and are going to another game.
	CommandLine()->RemoveParm( "-swapcores" );
	if ( !Q_stricmp( g_Games[m_Selection].pGameDir, "tf" ) )
	{
		CommandLine()->AppendParm( "-swapcores", NULL );
	}

	int fFlags = LF_EXITFROMCHOOSER;

	// allocate the full payload
	int nPayloadSize = XboxLaunch()->MaxPayloadSize();
	byte *pPayload = (byte *)stackalloc( nPayloadSize );
	V_memset( pPayload, 0, nPayloadSize );

	// payload is at least the command line
	// any user data needed must be placed AFTER the command line
	const char *pCmdLine = CommandLine()->GetCmdLine();
	int nCmdLineLength = (int)strlen( pCmdLine ) + 1;
	V_memcpy( pPayload, pCmdLine, min( nPayloadSize, nCmdLineLength ) );

	// add any other data here to payload, after the command line
	// ...

	XboxLaunch()->SetStorageID( m_iStorageDeviceID );
	
	m_iUserIdx = XBX_GetPrimaryUserId();
	if ( m_bInviteAccepted )
	{
		// A potentially different user was invited, so we need to connect them
		m_iUserIdx = m_nInviteUserID;
	}	
	XboxLaunch()->SetUserID( m_iUserIdx );

	if ( m_bInviteAccepted )
	{
		// In the case of an invitation acceptance, we need to pack extra data into the payload
		fFlags |= LF_INVITERESTART;
		XboxLaunch()->SetInviteSessionID( &m_InviteSessionID );
	}

	// Save out the data
	bool bLaunch = XboxLaunch()->SetLaunchData( (void *)pPayload, nPayloadSize, fFlags );
	if ( bLaunch )
	{
		COM_TimestampedLog( "Launching: \"%s\" Flags: 0x%8.8x", pCmdLine, XboxLaunch()->GetLaunchFlags() );

		g_pMaterialSystem->PersistDisplay();
		ShutdownVGUI();
		ShutdownAudio();
		XBX_DisconnectConsoleMonitor();

		XboxLaunch()->Launch();
	}
}

//--------------------------------------------------------------------------------------
// Handle game selection
//--------------------------------------------------------------------------------------
void CAppChooser::OnActivateGame()
{
	if ( !m_FadeInTime || Plat_FloatTime() <= m_FadeInTime + 1.0f )
	{
		// lockout user selection input until screen has stable rendering and completed its fade in
		// prevents button mashing doing an immediate game selection just as the startup movies end
		return;
	}

	if ( !g_Games[m_Selection].bEnabled )
	{
		m_Deny.Play();
		return;
	}

	m_Clack.Play();
	while ( m_Clack.IsPlaying() )
	{
		// let the audio complete
		Sleep( 1 );
	}

	StartExitingProcess();
}

void CAppChooser::OnDemoMovieEnd()
{
	g_AppChooserSystem.ResetTimeout( INACTIVITY_TIMEOUT );
	m_bPlayingDemoMovie = false;
}

void DemoMovieCallback()
{
	g_AppChooserSystem.OnDemoMovieEnd();
}

//--------------------------------------------------------------------------------------
// Handle inactivity event
//--------------------------------------------------------------------------------------
void CAppChooser::OnInactivityTimeout()
{
	// no further inactivity timeouts
	ResetTimeout( 0 );

	const char *pDemoMovieName = g_DemoMovies[m_DemoMovie];
	m_DemoMovie++;
	if ( m_DemoMovie >= ARRAYSIZE( g_DemoMovies ) )
	{
		// reset
		m_DemoMovie = 0;
	}

	m_bPlayingDemoMovie = m_pDemoMovieImage->StartMovieFromFile( pDemoMovieName, true, false, DemoMovieCallback );
	if ( !m_bPlayingDemoMovie )
	{
		// try again, later
		ResetTimeout( INACTIVITY_TIMEOUT );
	}
}

//--------------------------------------------------------------------------------------
// Handle demo stop request
//--------------------------------------------------------------------------------------
void CAppChooser::OnStopDemoMovie()
{
	m_pDemoMovieImage->StopMovie();
}

//--------------------------------------------------------------------------------------
// Handle startup stop request
//--------------------------------------------------------------------------------------
void CAppChooser::OnStopStartupMovie()
{
	if ( m_StartupMovie >= 0 && g_StartupMovies[m_StartupMovie].bUserCanSkip )
	{
		m_pStartupMovieImage->StopMovie();
	}
}

//--------------------------------------------------------------------------------------
// Setup the exiting context. Cannot be aborted.
//--------------------------------------------------------------------------------------
void CAppChooser::StartExitingProcess()
{
	bool bIsMultiplayer = V_stricmp( g_Games[m_Selection].pGameDir, "tf" ) == 0;

	// stable rendering, start the fade out
	m_pOverlay = m_pProductBackgrounds[m_Selection];

	m_pLoading->SetVisible( true );
	m_pLoading->SetAlpha( 0 );
	SetLoadingIconPosition( bIsMultiplayer );
	m_pLoadingIcon->SetVisible( true );
	m_pLoadingIcon->SetAlpha( 0 );

	m_FadeOutTime = Plat_FloatTime();

	m_bExiting = true;
	m_ExitingFrameCount = 0;

	// ensure that nothing can stop the exiting process
	// otherwise the player could rapidly select a game during the fade outs
	ResetTimeout( 0 );
	EnableInput( false );
}

//--------------------------------------------------------------------------------------
// Handle per frame update, prior to render
//--------------------------------------------------------------------------------------
void CAppChooser::FrameTick()
{
	if ( m_ExitingFrameCount )
	{
		return;
	}

	g_TargetMovieVolume = 1.0f;
	BOOL bControl;
	if ( ERROR_SUCCESS == XMPTitleHasPlaybackControl(&bControl) )
	{
		g_TargetMovieVolume = bControl ? 1.0f : 0.0f;
	}

	if ( m_FadeInTime )
	{
		// fade in overlay goes from [1..0] and holds on 0
		float t = ( Plat_FloatTime() - m_FadeInTime ) * 2.0f;
		t = 1.0f - clamp( t, 0.0f, 1.0f );
		m_pOverlay->SetAlpha ( t * 255.0f );
	}

	if ( m_FadeOutTime )
	{
		// fade out overlay goes from [0..1] and holds on 1
		float t = ( Plat_FloatTime() - m_FadeOutTime ) * 2.0f;
		t = clamp( t, 0.0f, 1.0f );
		m_pOverlay->SetAlpha ( t * 255.0f );
	}

	for ( int i=0; i<ARRAYSIZE( g_Games ); i++ )
	{
		m_pGames[i]->SetSelected( false );
	}
	m_pGames[m_Selection]->SetSelected( true );

	if ( m_bExiting )
	{
		m_pLoading->SetAlpha( m_pOverlay->GetAlpha() ); 
		m_pLoadingIcon->SetAlpha( m_pOverlay->GetAlpha() ); 
		if ( m_pOverlay->GetAlpha() == 255 )
		{
			// exiting needs to have fade overlay fully opaque before stopping background movie
			m_pBackgroundMovie->StopMovie();

			// exiting commences after all movies full release and enough frames have swapped to ensure stability
			// strict time (frame rate) cannot be trusted, must allow a non trivial amount of presents
			m_ExitingFrameCount = 30;
		}
	}

	if ( m_bPlayingStartupMovies )
	{
		if ( m_pStartupMovieImage->IsFullyReleased() )
		{
			m_StartupMovie++;
			if ( m_StartupMovie >= ARRAYSIZE( g_StartupMovies ) )
			{
				// end of cycle
				m_StartupMovie = -1;
				m_bPlayingStartupMovies = false;
			}
			else
			{
				m_bPlayingStartupMovies = m_pStartupMovieImage->StartMovieFromFile( g_StartupMovies[m_StartupMovie].pMovieName, true, false );
			}
		}
	
		if ( !m_bPlayingStartupMovies )
		{
			ResetTimeout( INACTIVITY_TIMEOUT );
			m_BackgroundMovieStartTime = Plat_FloatTime();
			m_GameMovieStartTime = m_BackgroundMovieStartTime + 1.0f;
		}
		else
		{
			return;
		}
	}

	if ( m_bInviteAccepted )
	{
		// stop attract mode
		if ( m_bPlayingDemoMovie )
		{
			// hint the demo movie to stop
			OnStopDemoMovie();
		}
	
		// attract movies must finish before allowing invite
		// background movies must finish before allowing invite
		// starts the exiting process ONCE
		if ( !m_bPlayingStartupMovies && !m_bPlayingDemoMovie && !m_bExiting )
		{
			for ( int i = 0; i < ARRAYSIZE( g_Games ); i++ )
			{
				if ( V_stristr( "tf", g_Games[i].pGameDir ) )
				{
					// EVIL! spoof a user slection to invite only TF
					m_Selection = i;
					StartExitingProcess();

					// must fixup state, invite could have happened very early, at any time, before the initial fade-in
					// ensure no movies start
					m_BackgroundMovieStartTime = 0;
					m_GameMovieStartTime = 0;
				
					// hack the fade times to match the expected state
					if ( !m_FadeInTime || m_FadeInTime >= Plat_FloatTime() )
					{
						// can't fade out, invite occured before fade-in
						// can only snap it because there is no background to fade from
						m_pPersistedImage->SetAlpha( 0 );
						m_FadeInTime = 0;
						m_FadeOutTime = 0;
						m_pOverlay->SetAlpha( 255 );
					}
					break;
				}
			}
		}
	}

	if ( m_bExiting || m_bPlayingDemoMovie || m_LastSelection != m_Selection )
	{		
		m_pGames[m_LastSelection]->StopMovie(); 
		m_LastSelection = m_Selection;

		// user can change selection very quickly
		// lag the movie starting until selection settles
		m_GameMovieStartTime = Plat_FloatTime() + 2.0f;
	}

	if ( !m_bExiting && !m_bPlayingDemoMovie && ( m_GameMovieStartTime != 0 ) && ( Plat_FloatTime() >= m_GameMovieStartTime ) )
	{
		// keep trying the current selection, it will eventually start
		m_pGames[m_Selection]->StartMovie(); 
		if ( m_LastBackgroundMovie != m_Selection )
		{
			m_pBackgroundMovie->StopMovie();
			m_LastBackgroundMovie = m_Selection;
			m_BackgroundMovieStartTime = Plat_FloatTime() + 2.0f;
		}
	}

	// update the background movie, lags far behind any user selection
	if ( !m_bExiting && !m_bPlayingDemoMovie && ( m_BackgroundMovieStartTime != 0 ) && ( Plat_FloatTime() >= m_BackgroundMovieStartTime ) )
	{
		char szFilename[MAX_PATH];
		V_snprintf( szFilename, sizeof( szFilename ), "background_%s.wmv", g_Games[m_Selection].pGameDir );

		// keep trying the current selection, it will eventually start
		bool bStarted = m_pBackgroundMovie->StartMovieFromFile( 
			szFilename,
			false,
			true );
		if ( bStarted )
		{
			m_LastBackgroundMovie = m_Selection;
		}
	}
}

//--------------------------------------------------------------------------------------
// Render the scene
//--------------------------------------------------------------------------------------
void CAppChooser::RenderScene()
{
	FrameTick();

	CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
	g_pMaterialSystem->BeginFrame( Plat_FloatTime() );

	pRenderContext->ClearColor3ub( 0, 0, 0 );
	pRenderContext->ClearBuffers( true, true );
	pRenderContext->Flush( true );

	// render all movies, XMV needs to hijack D3D
	bool bPreviousState = g_pMaterialSystem->OwnGPUResources( false );
	{
		m_pStartupMovieImage->RenderVideoFrame();
		m_pBackgroundMovie->RenderVideoFrame();
		m_pDemoMovieImage->RenderVideoFrame();
		for ( int i=0; i<ARRAYSIZE( m_pGames ); i++ )
		{
			m_pGames[i]->m_pMovieImage->RenderVideoFrame();
		}
	}
	g_pMaterialSystem->OwnGPUResources( bPreviousState );

	pRenderContext->Viewport( 0, 0, m_nScreenWidth, m_nScreenHeight );
	pRenderContext->MatrixMode( MATERIAL_PROJECTION );
	pRenderContext->LoadIdentity();
	pRenderContext->MatrixMode( MATERIAL_VIEW );
	pRenderContext->LoadIdentity();
	pRenderContext->MatrixMode( MATERIAL_MODEL );
	pRenderContext->LoadIdentity();
	pRenderContext->Flush( true );

	vgui::ivgui()->RunFrame();
	vgui::surface()->PaintTraverseEx( vgui::surface()->GetEmbeddedPanel() );

	g_pMaterialSystem->EndFrame();
	g_pMaterialSystem->SwapBuffers();

	if ( !m_FadeInTime && !m_bPlayingStartupMovies && !m_bExiting )
	{
		// stable rendering, start the fade in
		m_FadeInTime = Plat_FloatTime() + 1.0f;
	}

	// check for timeout
	if ( m_Timeout && ( Plat_FloatTime() >= m_Timeout ) )
	{
		m_Timeout = 0;
		OnInactivityTimeout();
	}
	
	if ( m_ExitingFrameCount > 1 && m_pBackgroundMovie->IsFullyReleased() && m_pGames[m_Selection]->m_pMovieImage->IsFullyReleased() )
	{
		// must wait for a few frames to settle to ensure frame buffer is stable
		m_ExitingFrameCount--;
		if ( m_ExitingFrameCount == 1 )
		{
			ExitChooser();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAppChooser::HandleInvite( DWORD nUserId )
{
	// invites are asynchronous and could happen at any time
	if ( m_bInviteAccepted )
	{
		// already accepted
		return;
	}

	// Collect our session data
	XINVITE_INFO inviteInfo;
	DWORD dwError = XInviteGetAcceptedInfo( nUserId, &inviteInfo );
	if ( dwError != ERROR_SUCCESS )
	{
		return;
	}

	// We only care if we're asked to join an Orange Box session
	if ( inviteInfo.dwTitleID != TITLEID_THE_ORANGE_BOX )
	{
		return;
	}

	// Store off the session ID and mark the invite as accepted internally
	m_bInviteAccepted = true;
	m_InviteSessionID = inviteInfo.hostInfo.sessionID;
	m_nInviteUserID = nUserId;
	
	// must wait for the startup movies or attract mode to end
	// FrameTick() will detect the invite and transition
	// the user has accpeted and cannot abort the invite
	EnableInput( false );
	ResetTimeout( 0 );
}

//--------------------------------------------------------------------------------------
// Window Proc
//--------------------------------------------------------------------------------------
LRESULT CALLBACK WndProc( HWND hWnd, UINT iMsg, WPARAM wParam, LPARAM lParam )
{
	switch ( iMsg )
	{
		case WM_CLOSE:
			g_bActive = false;
			break;
			
		case WM_DESTROY:
			PostQuitMessage( 0 );
			return 0L;

		case WM_LIVE_INVITE_ACCEPTED:
			g_AppChooserSystem.HandleInvite( LOWORD( lParam ) );
			break;

		case WM_XCONTROLLER_KEY:
			if ( !g_AppChooserSystem.IsInputEnabled() )
			{
				break;
			}

			if ( g_AppChooserSystem.IsStartupMoviePlaying() )
			{
				// some startup movies can be aborted
				switch ( wParam )
				{
				case KEY_XBUTTON_A:
				case KEY_XBUTTON_START:
					if ( LOWORD( lParam ) )
					{
						g_AppChooserSystem.OnStopStartupMovie();
					}
				}
				// no other input is allowed during this state
				break;
			}

			if ( g_AppChooserSystem.IsDemoMoviePlaying() )
			{
				// demo movies can be aborted
				switch ( wParam )
				{
				case KEY_XBUTTON_A:
				case KEY_XBUTTON_START:
					if ( LOWORD( lParam ) )
					{
						g_AppChooserSystem.OnStopDemoMovie();
					}
				}
			}
			else
			{
				if ( LOWORD( lParam ) )
				{
					g_AppChooserSystem.ResetTimeout( INACTIVITY_TIMEOUT );
				}

				switch ( wParam )
				{
				case KEY_XBUTTON_LEFT:
				case KEY_XSTICK1_LEFT:
					if ( LOWORD( lParam ) )
					{
						g_AppChooserSystem.OnSelectionPrevious();
					}
					break;

				case KEY_XBUTTON_RIGHT:
				case KEY_XSTICK1_RIGHT:
					if ( LOWORD( lParam ) )
					{
						g_AppChooserSystem.OnSelectionNext();
					}
					break;

				case KEY_XBUTTON_A:
				case KEY_XBUTTON_START:
					if ( LOWORD( lParam ) )
					{
						g_AppChooserSystem.OnActivateGame();
					}
					break;
				}
			}
			break;
	}
   
   return DefWindowProc( hWnd, iMsg, wParam, lParam );
}

//--------------------------------------------------------------------------------------
// CreateWindow
//
//--------------------------------------------------------------------------------------
bool CAppChooser::CreateWindow( int width, int height, bool bFullScreen )
{
   HWND        hWnd;
   WNDCLASSEX  wndClass;
   DWORD       dwStyle, dwExStyle;
   int         x, y, sx, sy;
   
   if ( ( hWnd = FindWindow( GetAppName(), GetAppName() ) ) != NULL )
   {
	   SetForegroundWindow( hWnd );
	   return true;
   }
   
   wndClass.cbSize = sizeof( wndClass );
   wndClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
   wndClass.lpfnWndProc = ::WndProc;
   wndClass.cbClsExtra = 0;
   wndClass.cbWndExtra = 0;
   wndClass.hInstance = (HINSTANCE)GetAppInstance();
   wndClass.hIcon = 0;
   wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
   wndClass.hbrBackground = (HBRUSH)COLOR_GRAYTEXT;
   wndClass.lpszMenuName = NULL;
   wndClass.lpszClassName = GetAppName();
   wndClass.hIconSm = 0;
   if ( !RegisterClassEx( &wndClass ) )
   {
	   Error( "Window class registration failed\n" );
	   return false;
   }
   
   if ( bFullScreen )
   {
	   dwExStyle = WS_EX_TOPMOST;
	   dwStyle = WS_POPUP | WS_VISIBLE;
   }
   else
   {
	   dwExStyle = 0;
	   dwStyle = WS_CAPTION | WS_SYSMENU;
   }
	
   x = y = 0;
   sx = width;
   sy = height;

   hWnd = CreateWindowEx(
			dwExStyle,
			GetAppName(),				// window class name
			GetAppName(),				// window caption
			dwStyle | WS_CLIPCHILDREN | WS_CLIPSIBLINGS, // window style
			x,							// initial x position
			y,							// initial y position
			sx,							// initial x size
			sy,							// initial y size
			NULL,						// parent window handle
			NULL,						// window menu handle
			(HINSTANCE)GetAppInstance(),// program instance handle
			NULL);						// creation parameter
	
	if ( hWnd == NULL )
	{
	   return false;
	}

	m_hWnd = hWnd;
   
	return true;
}

//-----------------------------------------------------------------------------
//	Create
//-----------------------------------------------------------------------------
bool CAppChooser::Create()
{
	AppSystemInfo_t appSystems[] = 
	{
		{ "filesystem_stdio.dll",	QUEUEDLOADER_INTERFACE_VERSION },
		{ "materialsystem.dll",		MATERIAL_SYSTEM_INTERFACE_VERSION },
		{ "inputsystem.dll",		INPUTSYSTEM_INTERFACE_VERSION },
		{ "vgui2.dll",				VGUI_IVGUI_INTERFACE_VERSION },
		{ "vguimatsurface.dll",		VGUI_SURFACE_INTERFACE_VERSION },
		{ "", "" }
	};

	MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );

	SpewOutputFunc( g_DefaultSpewFunc );

	// Add in the cvar factory
	AppModule_t cvarModule = LoadModule( VStdLib_GetICVarFactory() );
	AddSystem( cvarModule, CVAR_INTERFACE_VERSION );

	// vxconsole - true will block (legacy behavior)
	XBX_InitConsoleMonitor( false );

	if ( !AddSystems( appSystems ) ) 
		return false;

	IMaterialSystem* pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION );
	if ( !pMaterialSystem )
	{
		Error( "Failed to find %s\n", MATERIAL_SYSTEM_INTERFACE_VERSION );
		return false;
	}

	if ( IsX360() )
	{
		IFileSystem* pFileSystem = (IFileSystem*)FindSystem( FILESYSTEM_INTERFACE_VERSION );
		if ( !pFileSystem )
		{
			Error( "Failed to find %s\n", FILESYSTEM_INTERFACE_VERSION );
			return false;
		}
		pFileSystem->LoadModule( "shaderapidx9.dll" );
	}

	pMaterialSystem->SetShaderAPI( "shaderapidx9.dll" );

	return true;
}

//-----------------------------------------------------------------------------
// PreInit
//-----------------------------------------------------------------------------
bool CAppChooser::PreInit()
{
	if ( !BaseClass::PreInit() )
		return false;

	if ( !g_pFullFileSystem || !g_pMaterialSystem )
	{
		Warning( "Unable to find required interfaces!\n" );
		return false;
	}

	// Add paths...
	if ( !SetupSearchPaths( NULL, false, true ) )
	{
		Error( "Failed to setup search paths\n" );
		return false;
	}

	// Create the main program window and our viewport
	int w = 640;
	int h = 480;
	if ( IsX360() )
	{
		w = GetSystemMetrics( SM_CXSCREEN );
		h = GetSystemMetrics( SM_CYSCREEN );
	}

    if ( !CreateWindow( w, h, false ) )
	{
        ChangeDisplaySettings( 0, 0 );
        Error( "Unable to create main window\n" );
        return false;
	}

	ShowWindow( m_hWnd, SW_SHOWNORMAL );
	UpdateWindow( m_hWnd );
	SetForegroundWindow( m_hWnd );
	SetFocus( m_hWnd );

	XOnlineStartup();

	return true;
}


//-----------------------------------------------------------------------------
// Destroy
//-----------------------------------------------------------------------------
void CAppChooser::Destroy()
{
	XOnlineCleanup();
}

//-----------------------------------------------------------------------------
// Main
//-----------------------------------------------------------------------------
int CAppChooser::Main()
{   
	if ( !InitMaterialSystem() )
	{
		return 0;
	}

	if ( !InitVGUI() )
	{
		return 0;
	}

	if ( !InitAudio() )
	{
		return 0;
	}

	// post initialization reset
	Reset();

	// Setup a listener for invites
	XBX_NotifyCreateListener( XNOTIFY_LIVE );

	MSG msg;
    while ( g_bActive == TRUE )
	{
		// Pump the XBox notifications
		XBX_ProcessEvents();

		while ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
		{
            TranslateMessage( &msg );
            DispatchMessage( &msg );
		}

		g_pInputSystem->PollInputState();
		RenderScene();
	}

	ShutdownVGUI();
	ShutdownAudio();
	Destroy();

	return 0;
}

//-----------------------------------------------------------------------------
// The entry point for the application
//-----------------------------------------------------------------------------
extern "C" __declspec(dllexport) int AppChooserMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow )
{
	CommandLine()->CreateCmdLine( lpCmdLine );

	SetAppInstance( hInstance );

	CSteamApplication steamApplication( &g_AppChooserSystem );
	steamApplication.Run();

	return 0;
}