diff options
Diffstat (limited to 'utils/xbox')
136 files changed, 44953 insertions, 0 deletions
diff --git a/utils/xbox/AppChooser/AppChooser.vpc b/utils/xbox/AppChooser/AppChooser.vpc new file mode 100644 index 0000000..e960987 --- /dev/null +++ b/utils/xbox/AppChooser/AppChooser.vpc @@ -0,0 +1,47 @@ +//----------------------------------------------------------------------------- +// AppChooser.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" + +$Include "$SRCDIR\vpc_scripts\source_dll_base.vpc" + +$Configuration "Debug" +{ + $Linker [$X360] + { + $AdditionalDependencies "$BASE xaudiod.lib xmediad.lib xnet.lib xonline.lib xmp.lib" + } +} + +$Configuration "Release" +{ + $Linker [$X360] + { + $AdditionalDependencies "$BASE xaudio.lib xmedia.lib xnet.lib xonline.lib xmp.lib" + } +} + +$Project "AppChooser" +{ + $Folder "Source Files" + { + $file "main.cpp" + $file "$SRCDIR\public\vgui_controls\vgui_controls.cpp" + } + + $Folder "Link Libraries" + { + $Lib appframework + $Lib mathlib + $Lib tier2 + $Lib tier3 + $Lib vtf + $Lib bitmap + $Lib vgui_controls + $Lib vgui_surfacelib + } +} diff --git a/utils/xbox/AppChooser/main.cpp b/utils/xbox/AppChooser/main.cpp new file mode 100644 index 0000000..3310ee5 --- /dev/null +++ b/utils/xbox/AppChooser/main.cpp @@ -0,0 +1,2239 @@ +//========= 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; +} diff --git a/utils/xbox/AppChooser/xbox/xbox.def b/utils/xbox/AppChooser/xbox/xbox.def new file mode 100644 index 0000000..66245f5 --- /dev/null +++ b/utils/xbox/AppChooser/xbox/xbox.def @@ -0,0 +1,3 @@ +LIBRARY AppChooser_360.dll +EXPORTS + AppChooserMain @1
\ No newline at end of file diff --git a/utils/xbox/FontMaker/fontmaker.cpp b/utils/xbox/FontMaker/fontmaker.cpp new file mode 100644 index 0000000..a2552af --- /dev/null +++ b/utils/xbox/FontMaker/fontmaker.cpp @@ -0,0 +1,1119 @@ +//----------------------------------------------------------------------------- +// Name: FontMaker.cpp +// +// Desc: Defines the class behaviors for the application. +// +// Hist: 09.06.02 - Revised Fontmaker sample +// +// Copyright (c) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#include "stdafx.h" +#include "FontMaker.h" +#include "Glyphs.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + + +CTextureFont g_Font; +extern BOOL g_bIsGlyphSelected; +extern int g_iSelectedGlyphNum; +extern GLYPH_ATTR* g_pSelectedGylph; +extern WCHAR g_cSelectedGlyph; + + + + + +//----------------------------------------------------------------------------- +// CFontMakerApp +//----------------------------------------------------------------------------- + +BEGIN_MESSAGE_MAP(CFontMakerApp, CWinApp) + //{{AFX_MSG_MAP(CFontMakerApp) + ON_COMMAND(IDM_FILE_NEWFONT, OnNewFontButton) + ON_BN_CLICKED(IDC_EFFECTSOUTLINED_CHECK, OnEffectsCheck) + ON_BN_CLICKED(IDC_EFFECTSSHADOWED_CHECK, OnEffectsCheck) + ON_BN_CLICKED(IDC_EFFECTSBLURRED_CHECK, OnEffectsCheck) + ON_BN_CLICKED(IDC_EFFECTSSCANLINES_CHECK, OnEffectsCheck) + ON_BN_CLICKED(IDC_EFFECTSANTIALIAS_CHECK, OnEffectsCheck) + ON_BN_CLICKED(IDC_GLYPHSFROMRANGE_RADIO, OnGlyphsFromRangeRadio) + ON_EN_CHANGE(IDC_GLYPHSRANGEFROM_EDIT, OnChangeGlpyhsRangeEdit) + ON_BN_CLICKED(IDC_GLYPHSFROMFILE_RADIO, OnGlyphsFromFileRadio) + ON_EN_KILLFOCUS(IDC_GLYPHSFILE_EDIT, OnChangeGlyphsFileEdit) + ON_BN_CLICKED(IDC_GLYPHSFILESELECTOR_BUTTON, OnGlyphsFileSelectorButton) + ON_BN_CLICKED(IDC_GLYPHSCUSTOM_RADIO, OnGlyphsCustom) + ON_BN_CLICKED(IDC_TEXTURESIZE_BUTTON, OnTextureSizeButton) + ON_BN_CLICKED(IDC_MAGNIFY_BUTTON, OnMagnifyButton) + ON_BN_CLICKED(IDC_GLYPH_SPECIAL, OnGlyphSpecial) + ON_UPDATE_COMMAND_UI(IDC_MAGNIFY_BUTTON, OnUpdateButton) + ON_COMMAND(IDM_FILE_LOADFONTFILE, OnLoadButton) + ON_COMMAND(IDM_FILE_SAVEFONTFILES, OnSaveButton) + ON_COMMAND(IDM_FILE_LOADFONTLAYOUT, OnLoadCustomFontButton) + ON_COMMAND(IDM_FILE_EXIT, OnExit) + ON_COMMAND(ID_APP_ABOUT, OnAbout) + ON_COMMAND(ID_HELP, OnHelp) + ON_EN_CHANGE(IDC_GLYPHSRANGETO_EDIT, OnChangeGlpyhsRangeEdit) + ON_UPDATE_COMMAND_UI(IDC_TEXTURESIZE_BUTTON, OnUpdateButton) + ON_UPDATE_COMMAND_UI(IDC_GLYPHSFILESELECTOR_BUTTON, OnUpdateButton) + ON_UPDATE_COMMAND_UI(IDM_FILE_NEWFONT, OnUpdateButton) + ON_UPDATE_COMMAND_UI(IDM_FILE_LOADFONTFILE, OnUpdateButton) + ON_UPDATE_COMMAND_UI(IDM_FILE_LOADFONTLAYOUT, OnUpdateButton) + ON_UPDATE_COMMAND_UI(IDM_FILE_SAVEFONTFILES, OnUpdateButton) + ON_UPDATE_COMMAND_UI(IDM_FILE_EXIT, OnUpdateButton) + ON_UPDATE_COMMAND_UI(ID_APP_ABOUT, OnUpdateButton) + ON_UPDATE_COMMAND_UI(ID_HELP, OnUpdateButton) + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + + + + +//----------------------------------------------------------------------------- +// The one and only CFontMakerApp object +//----------------------------------------------------------------------------- +CFontMakerApp theApp; + + + + +//----------------------------------------------------------------------------- +// Name: InitInstance() +// Desc: App initialization +//----------------------------------------------------------------------------- +BOOL CFontMakerApp::InitInstance() +{ + // Create the main frame window for the app + CFontMakerFrameWnd* pFrameWnd = new CFontMakerFrameWnd; + m_pMainWnd = pFrameWnd; + + // Associate the view with the frame + CCreateContext context; + context.m_pCurrentFrame = NULL; + context.m_pCurrentDoc = NULL; + context.m_pNewViewClass = RUNTIME_CLASS(CFontMakerView); + context.m_pNewDocTemplate = NULL; + + // Create the frame and load resources (menu, accelerator, etc.) + pFrameWnd->LoadFrame( IDR_MAINFRAME, WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, + NULL, &context ); + + // Call OnInitialUpdate() to be called for the view + pFrameWnd->InitialUpdateFrame( NULL, TRUE ); + + // The one and only window has been initialized, so show and update it. + m_pMainWnd->ShowWindow( SW_SHOW ); + m_pMainWnd->UpdateWindow(); + + // Load the hourglass cursor + m_hWaitCursor = LoadCursor( IDC_WAIT ); + + // Get access the the dialog controls and the view + m_pDialogBar = pFrameWnd->GetDialogBar(); + m_pView = (CFontMakerView*)pFrameWnd->GetActiveView(); + + // Initially, no font is selected + m_pDialogBar->GetDlgItem( IDC_FONTNAME_STATIC )->SetWindowText( _T("<Choose font>") ); + m_pDialogBar->GetDlgItem( IDC_FONTSTYLE_STATIC )->SetWindowText( _T("") ); + m_pDialogBar->GetDlgItem( IDC_FONTSIZE_STATIC )->SetWindowText( _T("") ); + + return TRUE; +} + + + + +//----------------------------------------------------------------------------- +// Name: OnUpdateButton() +// Desc: This function is needed to override some internal mucking with button +// states. Without it, button and menu enabling will make you crazy. +//----------------------------------------------------------------------------- +void CFontMakerApp::OnUpdateButton( CCmdUI* pCmdUI ) +{ + BOOL bEnable; + + switch( pCmdUI->m_nID ) + { + // Controls which are active all the time + case IDM_FILE_NEWFONT: + case IDM_FILE_LOADFONTLAYOUT: + case IDM_FILE_LOADFONTFILE: + case IDM_FILE_EXIT: + case ID_APP_ABOUT: + case ID_HELP: + bEnable = TRUE; + break; + + case IDC_TEXTURESIZE_BUTTON: + case IDM_FILE_SAVEFONTFILES: + case IDC_MAGNIFY_BUTTON: + bEnable = g_Font.m_hFont ? TRUE : FALSE; + if ( !bEnable ) + bEnable = g_Font.m_pCustomFilename ? TRUE : FALSE; + break; + + // Controls which are active only when a font is available + default: + bEnable = g_Font.m_hFont ? TRUE : FALSE; + break; + } + + pCmdUI->Enable( bEnable ); +} + +BOOL g_bFirstTime = TRUE; + +//----------------------------------------------------------------------------- +// Name: OnNewFontButton() +// Desc: Called when the user hits the "New Font" button, this loads the font +// and enables all the other windows controls. +//----------------------------------------------------------------------------- +void CFontMakerApp::OnNewFontButton() +{ + // Initialize the LOGFONT structure. It's static so it's state is remembered + if ( g_Font.m_LogFont.lfHeight == 0 ) + { + // first time init + strcpy( g_Font.m_LogFont.lfFaceName, "Arial" ); // Arial font for a default + g_Font.m_LogFont.lfHeight = 16; // 16 height font for a default + g_Font.m_LogFont.lfWeight = 400; // 400 = normal, 700 = bold, etc. + g_Font.m_LogFont.lfItalic = 0; // 0 = normal, 255 = italic + g_Font.m_LogFont.lfQuality = ANTIALIASED_QUALITY; + } + + // convert to point size for dialog purposes + HDC hDC = GetDC( m_pMainWnd->m_hWnd ); + // Current point size unit=1/10 pts + INT iPointSize = g_Font.m_LogFont.lfHeight * 10; + g_Font.m_LogFont.lfHeight= -MulDiv( iPointSize, GetDeviceCaps( hDC, LOGPIXELSY ), 720 ); + ReleaseDC( m_pMainWnd->m_hWnd, hDC ); + + // Create the CHOOSEFONT structure + static CHOOSEFONT cf = {0}; + cf.lStructSize = sizeof(CHOOSEFONT); + cf.lpLogFont = &g_Font.m_LogFont; + cf.Flags = CF_INITTOLOGFONTSTRUCT | CF_SCREENFONTS; + cf.nFontType = SCREEN_FONTTYPE; + + if ( 0 == ChooseFont( &cf ) ) + return; + + g_Font.m_pCustomFilename = NULL; + + // NOT using point sizes, but cell heights + g_Font.m_LogFont.lfHeight = cf.iPointSize/10; + + // Reset the selected glpyh + UpdateSelectedGlyph( FALSE ); + + if( FAILED( CalculateAndRenderGlyphs() ) ) + { + // Could not create new font + MessageBox( m_pMainWnd->m_hWnd, "Could not create the requested font!", "Error", MB_ICONERROR|MB_OK ); + return; + } + + char tempName[256]; + sprintf( tempName, "%s_%d", g_Font.m_LogFont.lfFaceName, cf.iPointSize/10 ); + + // remove any spaces in the font name + for (unsigned int i=0,j=0; i<strlen( tempName )+1; i++) + { + if ( tempName[i] != ' ' ) + { + g_Font.m_strFontName[j++] = tempName[i]; + } + } + + if ( g_bFirstTime ) + { + CString str; + + // Set font properties + m_pDialogBar->GetDlgItem( IDC_FONT_GROUPBOX )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_FONTNAME_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_FONTSTYLE_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_FONTSIZE_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_FONTNAME_STATIC )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_FONTSTYLE_STATIC )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_FONTSIZE_STATIC )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_EFFECTSOUTLINED_CHECK )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_EFFECTSSHADOWED_CHECK )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_EFFECTSBLURRED_CHECK )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_EFFECTSSCANLINES_CHECK )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_EFFECTSANTIALIAS_CHECK )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_BLUR_EDIT )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_SCANLINES_EDIT )->EnableWindow( TRUE ); + + if ( g_Font.m_bAntialiasEffect ) + { + ((CButton*)m_pDialogBar->GetDlgItem( IDC_EFFECTSANTIALIAS_CHECK ))->SetCheck( TRUE ); + } + else + { + ((CButton*)m_pDialogBar->GetDlgItem( IDC_EFFECTSANTIALIAS_CHECK ))->SetCheck( FALSE ); + } + + str.Format( "%d", g_Font.m_nBlur ); + m_pDialogBar->GetDlgItem( IDC_BLUR_EDIT )->SetWindowText( str ); + + str.Format( "%d", g_Font.m_nScanlines ); + m_pDialogBar->GetDlgItem( IDC_SCANLINES_EDIT )->SetWindowText( str ); + + str.Format( "%s", g_Font.m_LogFont.lfFaceName ); + m_pDialogBar->GetDlgItem( IDC_FONTNAME_STATIC )->SetWindowText( str ); + if( g_Font.m_LogFont.lfItalic ) + str.Format( "Italic", g_Font.m_LogFont.lfWeight < 550 ? "" : "Bold " ); + else + str.Format( "%s", g_Font.m_LogFont.lfWeight < 550 ? "Regular" : "Bold" ); + m_pDialogBar->GetDlgItem( IDC_FONTSTYLE_STATIC )->SetWindowText( str ); + str.Format( "%ld", cf.iPointSize/10 ); + m_pDialogBar->GetDlgItem( IDC_FONTSIZE_STATIC )->SetWindowText( str ); + + // Set texture properties + m_pDialogBar->GetDlgItem( IDC_TEXTURE_GROUPBOX )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_TEXTUREWIDTH_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_TEXTUREHEIGHT_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_TEXTUREWIDTH_STATIC )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_TEXTUREHEIGHT_STATIC )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_TEXTURESIZE_BUTTON )->EnableWindow( TRUE ); + + SetTextureSize( g_Font.m_dwTextureWidth, g_Font.m_dwTextureHeight ); + + // Set glyph range properties + m_pDialogBar->GetDlgItem( IDC_GLYPHS_GROUPBOX )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMRANGE_RADIO )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMFILE_RADIO )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGEFROM_EDIT )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGETO_EDIT )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGEFROM_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGETO_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSFILE_EDIT )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSFILESELECTOR_BUTTON )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSCUSTOM_RADIO )->EnableWindow( TRUE ); + + // Set a default range of glyphs to use + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMRANGE_RADIO ))->SetCheck( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGEFROM_EDIT )->SetWindowText( "32" ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGETO_EDIT )->SetWindowText( "127" ); + g_Font.ExtractValidGlyphsFromRange( 32, 127 ); + + m_pDialogBar->GetDlgItem( IDC_INSERTGLYPH_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_INSERTGLYPH_EDIT )->EnableWindow( TRUE ); + } + else + { + CString str; + + str.Format( "%s", g_Font.m_LogFont.lfFaceName ); + m_pDialogBar->GetDlgItem( IDC_FONTNAME_STATIC )->SetWindowText( str ); + if ( g_Font.m_LogFont.lfItalic ) + str.Format( "Italic", g_Font.m_LogFont.lfWeight < 550 ? "" : "Bold " ); + else + str.Format( "%s", g_Font.m_LogFont.lfWeight < 550 ? "Regular" : "Bold" ); + m_pDialogBar->GetDlgItem( IDC_FONTSTYLE_STATIC )->SetWindowText( str ); + str.Format( "%ld", cf.iPointSize/10 ); + m_pDialogBar->GetDlgItem( IDC_FONTSIZE_STATIC )->SetWindowText( str ); + } + + g_bFirstTime = FALSE; +} + + + + +//----------------------------------------------------------------------------- +// Name: OnGlyphsFromRangeRadio() +// Desc: User will be specifying a glyph range manually +//----------------------------------------------------------------------------- +void CFontMakerApp::OnGlyphsFromRangeRadio() +{ + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGEFROM_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGETO_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGEFROM_EDIT )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGETO_EDIT )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSFILE_EDIT )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSFILESELECTOR_BUTTON )->EnableWindow( FALSE ); + + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMFILE_RADIO ))->SetCheck( false ); + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMRANGE_RADIO ))->SetCheck( true ); + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSCUSTOM_RADIO ))->SetCheck( false ); + + OnChangeGlpyhsRangeEdit(); +} + + + + +//----------------------------------------------------------------------------- +// Name: OnChangeGlpyhsRangeEdit() +// Desc: User changed the range of glpyhs +//----------------------------------------------------------------------------- +void CFontMakerApp::OnChangeGlpyhsRangeEdit() +{ + if( NULL == g_Font.m_hFont ) + return; + + CEdit* pGlyphRangeFromEdit = (CEdit*)m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGEFROM_EDIT ); + CEdit* pGlyphRangeToEdit = (CEdit*)m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGETO_EDIT ); + + CString strFrom; + CString strTo; + pGlyphRangeFromEdit->GetWindowText( strFrom ); + pGlyphRangeToEdit->GetWindowText( strTo ); + + WORD wFrom = (WORD)max( 0, atoi( strFrom ) ); + WORD wTo = (WORD)min( 65535, atoi( strTo ) ); + g_Font.ExtractValidGlyphsFromRange( wFrom, wTo ); + + // Draw the new font glyphs + CalculateAndRenderGlyphs(); +} + + +void CFontMakerApp::OnGlyphsCustom() +{ + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMFILE_RADIO ))->SetCheck( false ); + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMRANGE_RADIO ))->SetCheck( false ); + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSCUSTOM_RADIO ))->SetCheck( true ); +} + + +//----------------------------------------------------------------------------- +// Name: OnGlyphsFromFileRadio() +// Desc: User want to extract glyphs that are used in a text file +//----------------------------------------------------------------------------- +void CFontMakerApp::OnGlyphsFromFileRadio() +{ + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGEFROM_LABEL )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGETO_LABEL )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGEFROM_EDIT )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGETO_EDIT )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSFILE_EDIT )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSFILESELECTOR_BUTTON )->EnableWindow( TRUE ); + + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMFILE_RADIO ))->SetCheck( true ); + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMRANGE_RADIO ))->SetCheck( false ); + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSCUSTOM_RADIO ))->SetCheck( false ); + + OnChangeGlyphsFileEdit(); +} + + + + +//----------------------------------------------------------------------------- +// Name: OnChangeGlyphsFileEdit() +// Desc: Handle change in name of file to extract glyphs from +//----------------------------------------------------------------------------- +void CFontMakerApp::OnChangeGlyphsFileEdit() +{ + CEdit* pGlyphFileNameEdit = (CEdit*)m_pDialogBar->GetDlgItem( IDC_GLYPHSFILE_EDIT ); + + CString strFileName; + pGlyphFileNameEdit->GetWindowText( strFileName ); + + if( strFileName.IsEmpty() ) + return; + + g_Font.ExtractValidGlyphsFromFile( (const TCHAR*)strFileName ); + + // Draw the new font glyphs + CalculateAndRenderGlyphs(); +} + + + + +//----------------------------------------------------------------------------- +// Name: OnGlyphsFileSelectorButton() +// Desc: Handle change in name of file to extract glyphs from +//----------------------------------------------------------------------------- +void CFontMakerApp::OnGlyphsFileSelectorButton() +{ + static TCHAR strFileName[MAX_PATH] = _T(""); + static TCHAR strFileName2[MAX_PATH] = _T(""); + static TCHAR strInitialDir[MAX_PATH] = _T("c:\\"); + + // Display the OpenFileName dialog. Then, try to load the specified file + OPENFILENAME ofn = { sizeof(OPENFILENAME), NULL, NULL, + _T("Text files (.txt)\0*.txt\0\0"), + NULL, 0, 1, strFileName, MAX_PATH, strFileName2, MAX_PATH, + strInitialDir, _T("Open Text File"), + OFN_FILEMUSTEXIST, 0, 1, NULL, 0, NULL, NULL }; + + if( TRUE == GetOpenFileName( &ofn ) ) + { + m_pDialogBar->GetDlgItem( IDC_GLYPHSFILE_EDIT )->SetWindowText( ofn.lpstrFile); + OnChangeGlyphsFileEdit(); + } +} + + + + +//----------------------------------------------------------------------------- +// Name: OnEffectsCheck() +// Desc: User changed font rendering options +//----------------------------------------------------------------------------- +void CFontMakerApp::OnEffectsCheck() +{ + g_Font.m_bOutlineEffect = ((CButton*)m_pDialogBar->GetDlgItem( IDC_EFFECTSOUTLINED_CHECK ))->GetCheck(); + g_Font.m_bShadowEffect = ((CButton*)m_pDialogBar->GetDlgItem( IDC_EFFECTSSHADOWED_CHECK ))->GetCheck(); + g_Font.m_bAntialiasEffect = ((CButton*)m_pDialogBar->GetDlgItem( IDC_EFFECTSANTIALIAS_CHECK ))->GetCheck(); + + bool bValveEffects = false; + if ( g_Font.m_bOutlineEffect || g_Font.m_bShadowEffect ) + { + m_pDialogBar->GetDlgItem( IDC_EFFECTSBLURRED_CHECK )->EnableWindow( false ); + m_pDialogBar->GetDlgItem( IDC_EFFECTSSCANLINES_CHECK )->EnableWindow( false ); + ((CButton*)m_pDialogBar->GetDlgItem( IDC_EFFECTSBLURRED_CHECK ))->SetCheck( false ); + ((CButton*)m_pDialogBar->GetDlgItem( IDC_EFFECTSSCANLINES_CHECK ))->SetCheck( false ); + } + else + { + m_pDialogBar->GetDlgItem( IDC_EFFECTSBLURRED_CHECK )->EnableWindow( true ); + m_pDialogBar->GetDlgItem( IDC_EFFECTSSCANLINES_CHECK )->EnableWindow( true ); + bValveEffects = true; + } + + if ( bValveEffects && ((CButton*)m_pDialogBar->GetDlgItem( IDC_EFFECTSBLURRED_CHECK ))->GetCheck() ) + { + CEdit* pBlurEdit = (CEdit*)m_pDialogBar->GetDlgItem( IDC_BLUR_EDIT ); + + CString strBlur; + pBlurEdit->GetWindowText( strBlur ); + + g_Font.m_nBlur = max( 2, atoi( strBlur ) ); + + strBlur.Format( "%d", g_Font.m_nBlur ); + pBlurEdit->SetWindowText( strBlur ); + } + else + { + g_Font.m_nBlur = 0; + } + + if ( bValveEffects && ((CButton*)m_pDialogBar->GetDlgItem( IDC_EFFECTSSCANLINES_CHECK ))->GetCheck() ) + { + CEdit* pScanlineEdit = (CEdit*)m_pDialogBar->GetDlgItem( IDC_SCANLINES_EDIT ); + + CString strScanlines; + pScanlineEdit->GetWindowText( strScanlines ); + + g_Font.m_nScanlines = max( 2, atoi( strScanlines ) ); + + strScanlines.Format( "%d", g_Font.m_nScanlines ); + pScanlineEdit->SetWindowText( strScanlines ); + } + else + { + g_Font.m_nScanlines = 0; + } + + // Draw the new font glyphs + CalculateAndRenderGlyphs(); +} + + + + +//----------------------------------------------------------------------------- +// Name: OnMagnifyButton() +// Desc: User wants to run the Windows "magnify" tool +//----------------------------------------------------------------------------- +void CFontMakerApp::OnMagnifyButton() +{ + // Run the Windows "magnify" tool + WinExec( "magnify.exe", TRUE ); +} + + + + +//----------------------------------------------------------------------------- +// Name: class CTextureSizeDlg +// Desc: Simple dialog to change the font texture size +//----------------------------------------------------------------------------- +class CTextureSizeDlg : public CDialog +{ +public: + CTextureSizeDlg(); + +// Dialog Data + //{{AFX_DATA(CTextureSizeDlg) + enum { IDD = IDD_TEXTURESIZE }; + //}}AFX_DATA + + // ClassWizard generated virtual function overrides + //{{AFX_VIRTUAL(CTextureSizeDlg) + protected: + virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support + //}}AFX_VIRTUAL + +// Implementation +protected: + //{{AFX_MSG(CTextureSizeDlg) + // No message handlers + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + +CTextureSizeDlg::CTextureSizeDlg() : CDialog(CTextureSizeDlg::IDD) +{ + //{{AFX_DATA_INIT(CTextureSizeDlg) + //}}AFX_DATA_INIT +} + +void CTextureSizeDlg::DoDataExchange(CDataExchange* pDX) +{ + CDialog::DoDataExchange(pDX); + + //{{AFX_DATA_MAP(CTextureSizeDlg) + DDX_Text( pDX, IDC_WIDTH, g_Font.m_dwTextureWidth ); + DDV_MinMaxInt( pDX, g_Font.m_dwTextureWidth, 16, 2048 ); + + DDX_Text( pDX, IDC_HEIGHT, g_Font.m_dwTextureHeight ); + DDV_MinMaxInt( pDX, g_Font.m_dwTextureHeight, 16, 2048 ); + //}}AFX_DATA_MAP +} + +BEGIN_MESSAGE_MAP(CTextureSizeDlg, CDialog) + //{{AFX_MSG_MAP(CTextureSizeDlg) + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + + +void CFontMakerApp::SetTextureSize( int width, int height ) +{ + g_Font.m_dwTextureWidth = width; + g_Font.m_dwTextureHeight = height; + + CString str; + str.Format( "%ld", g_Font.m_dwTextureWidth ); + m_pDialogBar->GetDlgItem( IDC_TEXTUREWIDTH_STATIC )->SetWindowText( str ); + str.Format( "%ld", g_Font.m_dwTextureHeight ); + m_pDialogBar->GetDlgItem( IDC_TEXTUREHEIGHT_STATIC )->SetWindowText( str ); +} + +//----------------------------------------------------------------------------- +// Name: OnTextureSizeButton() +// Desc: User wants to change the font texture size +//----------------------------------------------------------------------------- +void CFontMakerApp::OnTextureSizeButton() +{ + if ( !g_Font.m_hFont && !g_Font.m_pCustomFilename ) + return; + + CTextureSizeDlg dlgTextureSize; + dlgTextureSize.DoModal(); + + SetTextureSize( g_Font.m_dwTextureWidth, g_Font.m_dwTextureHeight ); + + // Draw the new font glyphs + CalculateAndRenderGlyphs(); +} + +void CFontMakerApp::InsertGlyph() +{ + CEdit* pGlyphInsert = (CEdit*)m_pDialogBar->GetDlgItem( IDC_INSERTGLYPH_EDIT ); + + CString strInsert; + pGlyphInsert->GetWindowText( strInsert ); + + WORD wGlyph = atoi( strInsert ); + if ( wGlyph < 0 ) + wGlyph = 0; + else if ( wGlyph > 65535 ) + wGlyph = 65535; + + g_Font.InsertGlyph( wGlyph ); +} + +//----------------------------------------------------------------------------- +// Name: UpdateSelectedGlyph() +// Desc: User changed (via mouse or keyboard) which glyph is selected +//----------------------------------------------------------------------------- +void CFontMakerApp::UpdateSelectedGlyph( BOOL bGlyphSelected, int iSelectedGlyph ) +{ + // Handle case where no glyph is selected + g_bIsGlyphSelected = FALSE; + g_iSelectedGlyphNum = 0; + g_pSelectedGylph = NULL; + g_cSelectedGlyph = L'\0'; + + if ( bGlyphSelected ) + { + for ( DWORD i=0; i<=g_Font.m_cMaxGlyph; i++ ) + { + if ( g_Font.m_TranslatorTable[i] == iSelectedGlyph ) + { + g_bIsGlyphSelected = TRUE; + g_iSelectedGlyphNum = iSelectedGlyph; + g_pSelectedGylph = &g_Font.m_pGlyphs[iSelectedGlyph]; + g_cSelectedGlyph = (WCHAR)i; + break; + } + } + } + + // Enable/disable/set-text-of the appropriate controls + if ( g_bIsGlyphSelected ) + { + CString str; + str.Format( "%d", g_cSelectedGlyph ); m_pDialogBar->GetDlgItem( IDC_GLYPH_VALUE_STATIC )->SetWindowText( str ); + str.Format( "%d", g_pSelectedGylph->x ); m_pDialogBar->GetDlgItem( IDC_GLYPH_X_STATIC )->SetWindowText( str ); + str.Format( "%d", g_pSelectedGylph->y ); m_pDialogBar->GetDlgItem( IDC_GLYPH_Y_STATIC )->SetWindowText( str ); + str.Format( "%d", g_pSelectedGylph->w ); m_pDialogBar->GetDlgItem( IDC_GLYPH_W_STATIC )->SetWindowText( str ); + str.Format( "%d", g_pSelectedGylph->h ); m_pDialogBar->GetDlgItem( IDC_GLYPH_H_STATIC )->SetWindowText( str ); + str.Format( "%d", g_pSelectedGylph->a ); m_pDialogBar->GetDlgItem( IDC_GLYPH_A_STATIC )->SetWindowText( str ); + str.Format( "%d", g_pSelectedGylph->b ); m_pDialogBar->GetDlgItem( IDC_GLYPH_B_STATIC )->SetWindowText( str ); + str.Format( "%d", g_pSelectedGylph->c ); m_pDialogBar->GetDlgItem( IDC_GLYPH_C_STATIC )->SetWindowText( str ); + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPH_SPECIAL ))->SetCheck( g_Font.m_ValidGlyphs[g_cSelectedGlyph] == 2 ); + } + else + { + CString str(""); + m_pDialogBar->GetDlgItem( IDC_GLYPH_VALUE_STATIC )->SetWindowText( str ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_X_STATIC )->SetWindowText( str ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_Y_STATIC )->SetWindowText( str ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_W_STATIC )->SetWindowText( str ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_H_STATIC )->SetWindowText( str ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_A_STATIC )->SetWindowText( str ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_B_STATIC )->SetWindowText( str ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_C_STATIC )->SetWindowText( str ); + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPH_SPECIAL ))->SetCheck( FALSE ); + } + + m_pDialogBar->GetDlgItem( IDC_SELECTEDGLYPH_GROUPBOX )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_VALUE_LABEL )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_X_LABEL )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_Y_LABEL )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_W_LABEL )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_H_LABEL )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_A_LABEL )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_B_LABEL )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_C_LABEL )->EnableWindow( g_bIsGlyphSelected ); + + m_pDialogBar->GetDlgItem( IDC_GLYPH_VALUE_STATIC )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_X_STATIC )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_Y_STATIC )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_W_STATIC )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_H_STATIC )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_A_STATIC )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_B_STATIC )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_C_STATIC )->EnableWindow( g_bIsGlyphSelected ); + m_pDialogBar->GetDlgItem( IDC_GLYPH_SPECIAL )->EnableWindow( g_bIsGlyphSelected ); +} + + + + +//----------------------------------------------------------------------------- +// Name: OnGlyphSpecial() +// Desc: User changed the status of the selected glyph +//----------------------------------------------------------------------------- +void CFontMakerApp::OnGlyphSpecial() +{ + if( g_bIsGlyphSelected ) + { + if( ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPH_SPECIAL ))->GetCheck() ) + g_Font.m_ValidGlyphs[g_cSelectedGlyph] = 2; + else + g_Font.m_ValidGlyphs[g_cSelectedGlyph] = 1; + + // Draw the font glyphs, which may have changed layout + CalculateAndRenderGlyphs(); + } +} + +//----------------------------------------------------------------------------- +// Name: OnLoadButton() +// Desc: User wants to load a font file +//----------------------------------------------------------------------------- +void CFontMakerApp::OnLoadButton() +{ + CHAR strVBFFileName[MAX_PATH]; + sprintf( strVBFFileName, "%s.vbf", g_Font.m_strFontName ); + + OPENFILENAME ofnVBF; // common dialog box structure + ZeroMemory( &ofnVBF, sizeof(OPENFILENAME) ); + ofnVBF.lStructSize = sizeof(OPENFILENAME); + ofnVBF.hwndOwner = m_pMainWnd->m_hWnd; + ofnVBF.lpstrFilter = "Font files (*.vbf)\0*.vbf\0\0"; + ofnVBF.nFilterIndex = 1; + ofnVBF.lpstrFile = strVBFFileName; + ofnVBF.nMaxFile = sizeof(strVBFFileName); + ofnVBF.lpstrFileTitle = NULL; + ofnVBF.nMaxFileTitle = 0; + ofnVBF.lpstrInitialDir = NULL; + ofnVBF.lpstrTitle = "Load Font (VBF) File..."; + ofnVBF.Flags = OFN_PATHMUSTEXIST | OFN_EXPLORER | OFN_READONLY; + + // Display the Load dialog box for the VBF file + if ( FALSE == GetOpenFileName( &ofnVBF ) ) + return; + + if ( FAILED( g_Font.ReadFontInfoFile( strVBFFileName ) ) ) + { + m_pMainWnd->MessageBox( "Could not load the Valve bitmap font info file.", + "Error", MB_ICONERROR|MB_OK ); + return; + } +} + +//----------------------------------------------------------------------------- +// OnLoadCustomFontButton +//----------------------------------------------------------------------------- +void CFontMakerApp::OnLoadCustomFontButton() +{ + CHAR strVCFFileName[MAX_PATH]; + strVCFFileName[0] = '\0'; + + OPENFILENAME ofnVCF; // common dialog box structure + ZeroMemory( &ofnVCF, sizeof(OPENFILENAME) ); + ofnVCF.lStructSize = sizeof(OPENFILENAME); + ofnVCF.hwndOwner = m_pMainWnd->m_hWnd; + ofnVCF.lpstrFilter = "Custom Font files (*.vcf)\0*.vcf\0\0"; + ofnVCF.nFilterIndex = 1; + ofnVCF.lpstrFile = strVCFFileName; + ofnVCF.nMaxFile = sizeof(strVCFFileName); + ofnVCF.lpstrFileTitle = NULL; + ofnVCF.nMaxFileTitle = 0; + ofnVCF.lpstrInitialDir = NULL; + ofnVCF.lpstrTitle = "Load Custom Font (VCF) File..."; + ofnVCF.Flags = OFN_PATHMUSTEXIST | OFN_EXPLORER | OFN_READONLY; + + // Display the Load dialog box for the VBF file + if ( FALSE == GetOpenFileName( &ofnVCF ) ) + return; + + if ( FAILED( g_Font.ReadCustomFontFile( strVCFFileName ) ) ) + { + m_pMainWnd->MessageBox( "Could not load the Valve bitmap custom font file.", + "Error", MB_ICONERROR|MB_OK ); + return; + } + + // Reset the selected glpyh + UpdateSelectedGlyph( FALSE ); + + if ( FAILED( CalculateAndRenderGlyphs() ) ) + { + // Could not create new font + MessageBox( m_pMainWnd->m_hWnd, "Could not create the requested font!", "Error", MB_ICONERROR|MB_OK ); + return; + } + + m_pDialogBar->GetDlgItem( IDC_FONT_GROUPBOX )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_FONTNAME_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_FONTSTYLE_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_FONTSIZE_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_FONTNAME_STATIC )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_FONTSTYLE_STATIC )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_FONTSIZE_STATIC )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_EFFECTSOUTLINED_CHECK )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_EFFECTSSHADOWED_CHECK )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_EFFECTSBLURRED_CHECK )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_EFFECTSSCANLINES_CHECK )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_EFFECTSANTIALIAS_CHECK )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_BLUR_EDIT )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_SCANLINES_EDIT )->EnableWindow( FALSE ); + + CString str; + str.Format( "%s", g_Font.m_strFontName ); + m_pDialogBar->GetDlgItem( IDC_FONTNAME_STATIC )->SetWindowText( str ); + + str.Format( "%d", g_Font.m_maxCustomCharHeight ); + m_pDialogBar->GetDlgItem( IDC_FONTSIZE_STATIC )->SetWindowText( str ); + + // Set texture properties + m_pDialogBar->GetDlgItem( IDC_TEXTURE_GROUPBOX )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_TEXTUREWIDTH_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_TEXTUREHEIGHT_LABEL )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_TEXTUREWIDTH_STATIC )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_TEXTUREHEIGHT_STATIC )->EnableWindow( TRUE ); + m_pDialogBar->GetDlgItem( IDC_TEXTURESIZE_BUTTON )->EnableWindow( TRUE ); + + SetTextureSize( g_Font.m_dwTextureWidth, g_Font.m_dwTextureHeight ); + + // Set glyph range properties + m_pDialogBar->GetDlgItem( IDC_GLYPHS_GROUPBOX )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMRANGE_RADIO )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMFILE_RADIO )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGEFROM_EDIT )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGETO_EDIT )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGEFROM_LABEL )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSRANGETO_LABEL )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSFILE_EDIT )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSFILESELECTOR_BUTTON )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_GLYPHSCUSTOM_RADIO )->EnableWindow( TRUE ); + + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMRANGE_RADIO ))->SetCheck( FALSE ); + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSFROMFILE_RADIO ))->SetCheck( FALSE ); + ((CButton*)m_pDialogBar->GetDlgItem( IDC_GLYPHSCUSTOM_RADIO ))->SetCheck( TRUE ); + + m_pDialogBar->GetDlgItem( IDC_INSERTGLYPH_LABEL )->EnableWindow( FALSE ); + m_pDialogBar->GetDlgItem( IDC_INSERTGLYPH_EDIT )->EnableWindow( FALSE ); +} + +//----------------------------------------------------------------------------- +// Name: OnSaveButton() +// Desc: User wants to save the font files +//----------------------------------------------------------------------------- +void CFontMakerApp::OnSaveButton() +{ + CHAR strTGAFileName[MAX_PATH]; + CHAR strVBFFileName[MAX_PATH]; + + if ( !g_Font.m_hFont && !g_Font.m_pCustomFilename ) + return; + + sprintf( strTGAFileName, "%s.tga", g_Font.m_strFontName ); + + OPENFILENAME ofnTGA; // common dialog box structure + ZeroMemory( &ofnTGA, sizeof(OPENFILENAME) ); + ofnTGA.lStructSize = sizeof(OPENFILENAME); + ofnTGA.hwndOwner = m_pMainWnd->m_hWnd; + ofnTGA.lpstrFilter = "Targa files (*.tga)\0*.tga\0\0"; + ofnTGA.nFilterIndex = 1; + ofnTGA.lpstrFile = strTGAFileName; + ofnTGA.nMaxFile = sizeof(strTGAFileName); + ofnTGA.lpstrFileTitle = NULL; + ofnTGA.nMaxFileTitle = 0; + ofnTGA.lpstrInitialDir = NULL; + ofnTGA.lpstrTitle = "Save Font Texture Image (TGA) File..."; + ofnTGA.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT | OFN_EXPLORER; + + // Display the Save As dialog box for the TGA file + if ( FALSE == GetSaveFileName( &ofnTGA ) ) + return; + + // use the tga name, but replace the extension + CHAR *ptr; + CHAR temp[MAX_PATH]; + int len; + strcpy( temp, strTGAFileName ); + len = strlen( temp ); + if ( len > 4 && temp[len-4] == '.' ) + { + temp[len-3] = 'v'; + temp[len-2] = 'b'; + temp[len-1] = 'f'; + + // strip the path + ptr = strrchr( temp, '\\' ); + if ( ptr ) + { + strcpy( strVBFFileName, ptr+1 ); + } + else + { + strcpy( strVBFFileName, temp ); + } + } + else + { + sprintf( strVBFFileName, "%s.vbf", g_Font.m_strFontName ); + } + + // place the VBF files in the materials directory + CHAR materialsDir[MAX_PATH]; + strcpy( materialsDir, strTGAFileName ); + strlwr( materialsDir ); + ptr = strstr( materialsDir, "\\content\\hl2x\\materialsrc\\" ); + if ( ptr ) + { + // need the final dirs, skip past + CHAR *ptr2 = ptr + strlen( "\\content\\hl2x\\materialsrc\\" ); + strcpy( temp, ptr2 ); + + *ptr = '\0'; + strcat( materialsDir, "\\game\\hl2x\\materials\\" ); + strcat( materialsDir, temp ); + + // strip terminal filename + ptr = materialsDir + strlen( materialsDir ) - 1; + while ( ptr > materialsDir ) + { + if ( *ptr == '\\' ) + { + *ptr = '\0'; + break; + } + ptr--; + } + } + else + { + materialsDir[0] = '\0'; + } + + // Initialize OPENFILENAME + OPENFILENAME ofnVBF; // common dialog box structure + ZeroMemory( &ofnVBF, sizeof(OPENFILENAME) ); + ofnVBF.lStructSize = sizeof(OPENFILENAME); + ofnVBF.hwndOwner = m_pMainWnd->m_hWnd; + ofnVBF.lpstrFilter = "Font files (*.vbf)\0*.vbf\0\0"; + ofnVBF.nFilterIndex = 1; + ofnVBF.lpstrFile = strVBFFileName; + ofnVBF.nMaxFile = sizeof(strVBFFileName); + ofnVBF.lpstrFileTitle = NULL; + ofnVBF.nMaxFileTitle = 0; + ofnVBF.lpstrInitialDir = materialsDir[0] ? materialsDir : NULL; + ofnVBF.lpstrTitle = "Save Valve Bitmap Font (VBF) File..."; + ofnVBF.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT | OFN_EXPLORER; + + // Display the Save As dialog box for the ABC file + if ( FALSE == GetSaveFileName( &ofnVBF ) ) + return; + + // Make sure the names are valid + if ( !lstrcmp( strVBFFileName, strTGAFileName ) ) + { + m_pMainWnd->MessageBox( "Cannot have VBF and TGA filenames be the same!\nFiles not saved.", + "Error", MB_ICONERROR|MB_OK ); + return; + } + + // Add an extension, if there was not one + if ( 0 == ofnVBF.nFileExtension ) + lstrcat( strVBFFileName, ".vbf" ); + if ( 0 == ofnTGA.nFileExtension ) + lstrcat( strTGAFileName, ".tga" ); + + // Save the valve bitmap font info file (.vbf) + if ( FAILED( g_Font.WriteFontInfoFile( strVBFFileName ) ) ) + { + m_pMainWnd->MessageBox( "Could not write the Valve bitmap font info file.", + "Error", MB_ICONERROR|MB_OK ); + return; + } + + // blur or scanline effects require special processing to ensure + // they can be used in additive mode + bool bAdditiveMode = ( g_Font.m_nBlur || g_Font.m_nScanlines ); + + // a custom font requires special processing + bool bCustomFont = g_Font.m_pCustomFilename != NULL; + + // Save the font image file (.tga) + if ( FAILED( g_Font.WriteFontImageFile( strTGAFileName, bAdditiveMode, bCustomFont ) ) ) + { + m_pMainWnd->MessageBox( "Could not write the font texture image file.", + "Error", MB_ICONERROR|MB_OK ); + } +} + + + + +//----------------------------------------------------------------------------- +// Name: OnAbout() +// Desc: Display about box +//----------------------------------------------------------------------------- +void CFontMakerApp::OnAbout() +{ + CDialog dlg(IDD_ABOUT); + dlg.DoModal(); +} + + + + +//----------------------------------------------------------------------------- +// Name: OnHelp() +// Desc: Display app help +//----------------------------------------------------------------------------- +void CFontMakerApp::OnHelp() +{ + HKEY hRegKey; + + if( ERROR_SUCCESS == RegOpenKeyEx( HKEY_LOCAL_MACHINE, + _T("SOFTWARE\\Microsoft\\XboxSDK"), + 0, KEY_QUERY_VALUE, &hRegKey ) ) + { + DWORD dwSize = MAX_PATH; + CHAR InstallPath[MAX_PATH]; + + if( ERROR_SUCCESS == RegQueryValueEx( hRegKey, _T("InstallPath"), NULL, + NULL, (unsigned char *)InstallPath, &dwSize ) ) + { + CString path = InstallPath; + path += _T("\\doc\\xboxsdk.chm::/xbox_jbh_tool_fontmaker.htm"); + + ::HtmlHelp( m_pMainWnd->GetSafeHwnd(), path, HH_DISPLAY_TOPIC, NULL ); + RegCloseKey( hRegKey ); + return; + } + RegCloseKey( hRegKey ); + } + + MessageBox( m_pMainWnd->GetSafeHwnd(), + "Unable to find the Xbox SDK Help file xboxsdk.chm.", + "Help file error", MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL ); +} + + + + +//----------------------------------------------------------------------------- +// Name: OnExit() +// Desc: User chose to exit the app +//----------------------------------------------------------------------------- +void CFontMakerApp::OnExit() +{ + // Send a close message to the main window + m_pMainWnd->SendMessage( WM_CLOSE ); +} + + + + +//----------------------------------------------------------------------------- +// Name: ExitInstance() +// Desc: Do some cleanup before exitting the app +//----------------------------------------------------------------------------- +int CFontMakerApp::ExitInstance() +{ + DestroyCursor( m_hWaitCursor ); + + return CWinApp::ExitInstance(); +} + + + +//----------------------------------------------------------------------------- +// Name: CalculateAndRenderGlyphs() +// Desc: User changed the status of the selected glyph +//----------------------------------------------------------------------------- +HRESULT CFontMakerApp::CalculateAndRenderGlyphs() +{ + HRESULT hr; + + // This may take some time, so display a wait cursor + HCURSOR hOldCursor = GetCursor(); + SetCursor( m_hWaitCursor ); + + // Draw the font glyphs, which may have changed layout + if( FAILED( hr = g_Font.CalculateAndRenderGlyphs() ) ) + return hr; + + // Re-select the current glyph since the font data may have changed + theApp.UpdateSelectedGlyph( g_bIsGlyphSelected, g_iSelectedGlyphNum ); + + // Inform the view of the new font glyphs + m_pView->OnNewFontGlyphs(); + + // Restore the cursor + SetCursor( hOldCursor ); + + return S_OK; +} + + + + diff --git a/utils/xbox/FontMaker/fontmaker.doc b/utils/xbox/FontMaker/fontmaker.doc Binary files differnew file mode 100644 index 0000000..f739de0 --- /dev/null +++ b/utils/xbox/FontMaker/fontmaker.doc diff --git a/utils/xbox/FontMaker/fontmaker.h b/utils/xbox/FontMaker/fontmaker.h new file mode 100644 index 0000000..43526ad --- /dev/null +++ b/utils/xbox/FontMaker/fontmaker.h @@ -0,0 +1,145 @@ +//----------------------------------------------------------------------------- +// Name: FontMaker.h +// +// Desc: Defines the class behaviors for the application. +// +// Hist: 09.06.02 - Revised Fontmaker sample +// +// Copyright (c) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#ifndef FONTMAKER_H +#define FONTMAKER_H + +#include "resource.h" +#include "BitmapFontFile.h" +#include <math.h> +#include "..\toollib\toollib.h" +#include "..\toollib\scriplib.h" +#include "..\toollib\piclib.h" + +//----------------------------------------------------------------------------- +// Name: class CFontMakerView +// Desc: The scroll view class for viewing the font texture image +//----------------------------------------------------------------------------- +class CFontMakerView : public CScrollView +{ +protected: + CFontMakerView() {} + DECLARE_DYNCREATE(CFontMakerView) + + CDC m_memDC; + +public: + VOID OnNewFontGlyphs(); + + virtual ~CFontMakerView(); + +public: + + // Overridden functions + //{{AFX_VIRTUAL(CFontMakerView) + public: + virtual void OnDraw(CDC* pDC); + virtual void OnInitialUpdate(); + protected: + //}}AFX_VIRTUAL + +protected: + // Message map functions + //{{AFX_MSG(CFontMakerView) + afx_msg void OnLButtonDown(UINT nFlags, CPoint point); + afx_msg BOOL OnEraseBkgnd(CDC* pDC); + afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags); + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + + + + +//----------------------------------------------------------------------------- +// Name: class CFontMakerFrameWnd +// Desc: The main frame window class for the app, which contains the dialog bar +// full of controls and the scroll view to view the font texture image. +//----------------------------------------------------------------------------- +class CFontMakerFrameWnd : public CFrameWnd +{ +public: + CFontMakerFrameWnd() {} + virtual ~CFontMakerFrameWnd() {} + + CDialogBar m_wndDialogBar; + CDialogBar* GetDialogBar() { return &m_wndDialogBar; } + +protected: + DECLARE_DYNCREATE(CFontMakerFrameWnd) + + // Message map functions + //{{AFX_MSG(CFontMakerFrameWnd) + afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct); + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + + + + +//----------------------------------------------------------------------------- +// Name: class CFontMakerApp +// Desc: The main app class +//----------------------------------------------------------------------------- +class CFontMakerApp : public CWinApp +{ + CDialogBar* m_pDialogBar; + CFontMakerView* m_pView; + HCURSOR m_hWaitCursor; + +public: + CFontMakerApp() {} + ~CFontMakerApp() {} + + VOID UpdateSelectedGlyph( BOOL bGlyphSelected, int iSelectedGlyph = 0 ); + HRESULT CalculateAndRenderGlyphs(); + VOID InsertGlyph(); + + void SetTextureSize( int width, int height ); + + // Overrides + //{{AFX_VIRTUAL(CFontMakerApp) + public: + virtual BOOL InitInstance(); + virtual int ExitInstance(); + //}}AFX_VIRTUAL + + // Implementation + //{{AFX_MSG(CFontMakerApp) + afx_msg void OnNewFontButton(); + afx_msg void OnEffectsCheck(); + afx_msg void OnGlyphsFromRangeRadio(); + afx_msg void OnChangeGlpyhsRangeEdit(); + afx_msg void OnGlyphsFromFileRadio(); + afx_msg void OnChangeGlyphsFileEdit(); + afx_msg void OnGlyphsFileSelectorButton(); + afx_msg void OnTextureSizeButton(); + afx_msg void OnMagnifyButton(); + afx_msg void OnGlyphSpecial(); + afx_msg void OnUpdateButton( CCmdUI* pCmdUI ); + afx_msg void OnSaveButton(); + afx_msg void OnExit(); + afx_msg void OnAbout(); + afx_msg void OnHelp(); + afx_msg void OnGlyphsCustom(); + afx_msg void OnLoadButton(); + afx_msg void OnLoadCustomFontButton(); + //}}AFX_MSG + DECLARE_MESSAGE_MAP() +}; + + + +// External reference to the unique application instance +extern CFontMakerApp theApp; + + + +#endif // FONTMAKER_H diff --git a/utils/xbox/FontMaker/fontmaker.ico b/utils/xbox/FontMaker/fontmaker.ico Binary files differnew file mode 100644 index 0000000..8046b8c --- /dev/null +++ b/utils/xbox/FontMaker/fontmaker.ico diff --git a/utils/xbox/FontMaker/fontmaker.rc b/utils/xbox/FontMaker/fontmaker.rc new file mode 100644 index 0000000..9f95362 --- /dev/null +++ b/utils/xbox/FontMaker/fontmaker.rc @@ -0,0 +1,314 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "#define _AFX_NO_SPLITTER_RESOURCES\r\n" + "#define _AFX_NO_OLE_RESOURCES\r\n" + "#define _AFX_NO_TRACKER_RESOURCES\r\n" + "#define _AFX_NO_PROPERTY_RESOURCES\r\n" + "\r\n" + "#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)\r\n" + "#ifdef _WIN32\r\n" + "LANGUAGE 9, 1\r\n" + "#pragma code_page(1252)\r\n" + "#endif //_WIN32\r\n" + "#include ""afxres.rc"" // Standard components\r\n" + "#endif\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDR_MAINFRAME ICON "FontMaker.ico" + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_DIALOGBAR DIALOGEX 0, 0, 142, 418 +STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD +FONT 8, "MS Shell Dlg", 0, 0, 0x1 +BEGIN + GROUPBOX "Font",IDC_FONT_GROUPBOX,5,5,130,142,WS_DISABLED + LTEXT "Name",IDC_FONTNAME_LABEL,10,15,24,15,SS_CENTERIMAGE | + WS_DISABLED + LTEXT "",IDC_FONTNAME_STATIC,35,15,90,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + LTEXT "Style",IDC_FONTSTYLE_LABEL,10,30,20,15,SS_CENTERIMAGE | + WS_DISABLED + LTEXT "",IDC_FONTSTYLE_STATIC,35,30,90,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + LTEXT "Size",IDC_FONTSIZE_LABEL,10,45,20,15,SS_CENTERIMAGE | + WS_DISABLED + LTEXT "",IDC_FONTSIZE_STATIC,35,45,30,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + CONTROL "Outlined",IDC_EFFECTSOUTLINED_CHECK,"Button", + BS_AUTOCHECKBOX | WS_DISABLED | WS_TABSTOP,10,65,42,10 + CONTROL "Shadowed",IDC_EFFECTSSHADOWED_CHECK,"Button", + BS_AUTOCHECKBOX | WS_DISABLED | WS_TABSTOP,10,80,50,10 + PUSHBUTTON "Magnify...",IDC_MAGNIFY_BUTTON,75,70,50,14,WS_DISABLED + GROUPBOX "Texture properties",IDC_TEXTURE_GROUPBOX,5,149,130,40, + WS_DISABLED + LTEXT "Insert Glyph:",IDC_INSERTGLYPH_LABEL,10,375,63,10, + SS_CENTERIMAGE | WS_DISABLED + CTEXT "",IDC_TEXTUREWIDTH_STATIC,9,170,30,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + CTEXT "Height",IDC_TEXTUREHEIGHT_LABEL,45,159,30,10, + SS_CENTERIMAGE | WS_DISABLED + CTEXT "",IDC_TEXTUREHEIGHT_STATIC,45,170,30,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + PUSHBUTTON "Size...",IDC_TEXTURESIZE_BUTTON,80,165,50,14, + WS_DISABLED + GROUPBOX "Glyphs",IDC_GLYPHS_GROUPBOX,5,189,130,95,WS_DISABLED + CONTROL "From range:",IDC_GLYPHSFROMRANGE_RADIO,"Button", + BS_AUTORADIOBUTTON | WS_DISABLED | WS_GROUP,10,199,53,10 + RTEXT "From:",IDC_GLYPHSRANGEFROM_LABEL,25,215,20,15, + SS_CENTERIMAGE | WS_DISABLED + EDITTEXT IDC_GLYPHSRANGEFROM_EDIT,50,215,25,12,ES_CENTER | + ES_AUTOHSCROLL | WS_DISABLED + RTEXT "To:",IDC_GLYPHSRANGETO_LABEL,85,215,15,15, + SS_CENTERIMAGE | WS_DISABLED + EDITTEXT IDC_GLYPHSRANGETO_EDIT,105,215,25,12,ES_CENTER | + ES_AUTOHSCROLL | WS_DISABLED + CONTROL "From file:",IDC_GLYPHSFROMFILE_RADIO,"Button", + BS_AUTORADIOBUTTON | WS_DISABLED,10,233,44,10 + EDITTEXT IDC_GLYPHSFILE_EDIT,23,245,90,12,ES_AUTOHSCROLL | + WS_DISABLED + PUSHBUTTON "...",IDC_GLYPHSFILESELECTOR_BUTTON,117,245,15,12, + WS_DISABLED + GROUPBOX "Selected Glyph",IDC_SELECTEDGLYPH_GROUPBOX,5,289,130, + 121,WS_DISABLED + CTEXT "Value",IDC_GLYPH_VALUE_LABEL,10,300,35,10, + SS_CENTERIMAGE | WS_DISABLED + CTEXT "",IDC_GLYPH_VALUE_STATIC,10,310,35,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + CTEXT "A",IDC_GLYPH_A_LABEL,60,300,20,10,SS_CENTERIMAGE | + WS_DISABLED + CTEXT "x",IDC_GLYPH_X_LABEL,9,324,20,10,SS_CENTERIMAGE | + WS_DISABLED + CTEXT "y",IDC_GLYPH_Y_LABEL,35,324,20,10,SS_CENTERIMAGE | + WS_DISABLED + CTEXT "w",IDC_GLYPH_W_LABEL,65,324,20,10,SS_CENTERIMAGE | + WS_DISABLED + CTEXT "h",IDC_GLYPH_H_LABEL,89,324,20,10,SS_CENTERIMAGE | + WS_DISABLED + CTEXT "B",IDC_GLYPH_B_LABEL,85,300,20,10,SS_CENTERIMAGE | + WS_DISABLED + CTEXT "C",IDC_GLYPH_C_LABEL,110,300,20,10,SS_CENTERIMAGE | + WS_DISABLED + CONTROL "Reserved for custom bitmap",IDC_GLYPH_SPECIAL,"Button", + BS_AUTOCHECKBOX | WS_DISABLED | WS_TABSTOP,10,356,104,10 + CTEXT "",IDC_GLYPH_X_STATIC,10,334,20,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + CTEXT "",IDC_GLYPH_Y_STATIC,35,334,20,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + CTEXT "",IDC_GLYPH_W_STATIC,65,334,20,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + CTEXT "",IDC_GLYPH_H_STATIC,90,334,20,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + CTEXT "",IDC_GLYPH_A_STATIC,60,310,20,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + CTEXT "",IDC_GLYPH_B_STATIC,85,310,20,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + CTEXT "",IDC_GLYPH_C_STATIC,110,310,20,12,SS_CENTERIMAGE | + WS_DISABLED,WS_EX_CLIENTEDGE + CONTROL "Blurred",IDC_EFFECTSBLURRED_CHECK,"Button", + BS_AUTOCHECKBOX | WS_DISABLED | WS_TABSTOP,10,97,50,10 + CONTROL "ScanLines",IDC_EFFECTSSCANLINES_CHECK,"Button", + BS_AUTOCHECKBOX | WS_DISABLED | WS_TABSTOP,10,114,50,10 + EDITTEXT IDC_BLUR_EDIT,65,95,25,12,ES_CENTER | ES_AUTOHSCROLL | + WS_DISABLED + EDITTEXT IDC_SCANLINES_EDIT,65,114,25,12,ES_CENTER | + ES_AUTOHSCROLL | WS_DISABLED + CONTROL "Antialias",IDC_EFFECTSANTIALIAS_CHECK,"Button", + BS_AUTOCHECKBOX | WS_DISABLED | WS_TABSTOP,10,130,50,10 + CONTROL "Custom",IDC_GLYPHSCUSTOM_RADIO,"Button", + BS_AUTORADIOBUTTON | WS_DISABLED | WS_GROUP,10,265,53,10 + EDITTEXT IDC_INSERTGLYPH_EDIT,10,387,35,12,ES_CENTER | + ES_AUTOHSCROLL | WS_DISABLED + CTEXT "Width",IDC_TEXTUREWIDTH_LABEL,9,159,30,10, + SS_CENTERIMAGE | WS_DISABLED +END + +IDD_TEXTURESIZE DIALOG 0, 0, 167, 49 +STYLE DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Texture Size" +FONT 8, "MS Shell Dlg" +BEGIN + LTEXT "Width",IDC_STATIC,5,5,19,15,SS_CENTERIMAGE + EDITTEXT IDC_WIDTH,35,5,40,15,ES_AUTOHSCROLL + LTEXT "Height",IDC_STATIC,5,25,25,15,SS_CENTERIMAGE + EDITTEXT IDC_HEIGHT,35,25,40,15,ES_AUTOHSCROLL + DEFPUSHBUTTON "OK",IDOK,115,5,50,14 + PUSHBUTTON "Cancel",IDCANCEL,115,25,50,14 +END + +IDD_ABOUT DIALOGEX 0, 0, 262, 123 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | + WS_SYSMENU +CAPTION "About FontMaker" +FONT 8, "MS Shell Dlg", 0, 0, 0x0 +BEGIN + ICON IDR_MAINFRAME,IDC_STATIC,5,20,21,20 + LTEXT "Xbox Font Maker tool - Modified for Valve Software", + IDC_STATIC,36,10,222,8 + LTEXT "Version 2.0.0000.1 - Valve",IDC_STATIC,36,25,222,8 + LTEXT "Copyright(c) 2000-2003 Microsoft Corporation. All rights reserved.", + IDC_STATIC,36,40,222,8 + LTEXT "Warning: This computer program is protected by copyright law and", + IDC_STATIC,36,55,222,8 + LTEXT "international treaties. Unauthorized reproduction or distribution of", + IDC_STATIC,36,65,222,8 + LTEXT "this program, or any portion of it, may result in severe civil and", + IDC_STATIC,36,75,222,8 + LTEXT "criminal penalties, and will be prosecuted to the maximum extent", + IDC_STATIC,36,85,222,8 + LTEXT "possible under the law.",IDC_STATIC,36,95,222,8 + DEFPUSHBUTTON "OK",IDOK,204,102,50,14 +END + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN + IDD_DIALOGBAR, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 135 + TOPMARGIN, 7 + BOTTOMMARGIN, 411 + END + + IDD_TEXTURESIZE, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 160 + TOPMARGIN, 7 + BOTTOMMARGIN, 42 + END + + IDD_ABOUT, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 255 + TOPMARGIN, 7 + BOTTOMMARGIN, 68 + END +END +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Menu +// + +IDR_MAINFRAME MENU +BEGIN + POPUP "&File" + BEGIN + MENUITEM "Load TTF Font...", IDM_FILE_NEWFONT + MENUITEM "Load Custom Font...", IDM_FILE_LOADFONTLAYOUT + MENUITEM "Load Compiled Font File...", IDM_FILE_LOADFONTFILE + MENUITEM SEPARATOR + MENUITEM "&Save Compiled Font...", IDM_FILE_SAVEFONTFILES + MENUITEM SEPARATOR + MENUITEM "E&xit", IDM_FILE_EXIT + END + POPUP "&Help" + BEGIN + MENUITEM "FontMaker &Help\tF1", ID_HELP + MENUITEM SEPARATOR + MENUITEM "&About FontMaker...", ID_APP_ABOUT + END +END + + +///////////////////////////////////////////////////////////////////////////// +// +// String Table +// + +STRINGTABLE +BEGIN + IDR_MAINFRAME "FontMaker\n\nFontMa\n\n\nFontMaker.Document\nFontMa Document" +END + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// +#define _AFX_NO_SPLITTER_RESOURCES +#define _AFX_NO_OLE_RESOURCES +#define _AFX_NO_TRACKER_RESOURCES +#define _AFX_NO_PROPERTY_RESOURCES + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE 9, 1 +#pragma code_page(1252) +#endif //_WIN32 +#include "afxres.rc" // Standard components +#endif + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/utils/xbox/FontMaker/fontmaker.vpc b/utils/xbox/FontMaker/fontmaker.vpc new file mode 100644 index 0000000..8774386 --- /dev/null +++ b/utils/xbox/FontMaker/fontmaker.vpc @@ -0,0 +1,68 @@ +//----------------------------------------------------------------------------- +// FONTMAKER.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\devtools\bin" + +$Include "$SRCDIR\vpc_scripts\source_exe_win_win32_base.vpc" + +$Configuration +{ + $Compiler + { + $EnableC++Exceptions "Yes (/EHsc)" + } + + $Linker + { + $AdditionalDependencies "htmlhelp.lib" + } +} + + +$Project "FontMaker" +{ + $Folder "Source Files" + { + -$File "$SRCDIR\public\tier0\memoverride.cpp" + + $File "FontMaker.cpp" + $File "FontMakerWnd.cpp" + $File "Glyphs.cpp" + $File "..\toollib\piclib.cpp" + $File "..\toollib\scriplib.cpp" + $File "Stdafx.cpp" + { + $Configuration + { + $Compiler + { + $Create/UsePrecompiledHeader "Create Precompiled Header (/Yc)" + } + } + } + + $File "..\toollib\toollib.cpp" + } + + $Folder "Resource Files" + { + $File "FontMaker.ico" + $File "FontMaker.rc" + $File "resource.h" + } + + $Folder "Header Files" + { + $File "..\..\..\public\BitmapFontFile.h" + $File "FontMaker.h" + $File "Glyphs.h" + $File "..\toollib\piclib.h" + $File "..\toollib\scriplib.h" + $File "Stdafx.h" + $File "..\toollib\toollib.h" + } +} diff --git a/utils/xbox/FontMaker/fontmakerwnd.cpp b/utils/xbox/FontMaker/fontmakerwnd.cpp new file mode 100644 index 0000000..a81a24e --- /dev/null +++ b/utils/xbox/FontMaker/fontmakerwnd.cpp @@ -0,0 +1,396 @@ +//----------------------------------------------------------------------------- +// Name: FontMakerWnd.cpp +// +// Desc: The window and scroll view class for the fontmaker app +// +// Hist: 09.06.02 - Revised Fontmaker sample +// +// Copyright (c) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#include "stdafx.h" +#include "FontMaker.h" +#include "Glyphs.h" + +#ifdef _DEBUG +#define new DEBUG_NEW +#undef THIS_FILE +static char THIS_FILE[] = __FILE__; +#endif + +extern CTextureFont g_Font; +BOOL g_bIsGlyphSelected = FALSE; +int g_iSelectedGlyphNum = 0; +WCHAR g_cSelectedGlyph = '\0'; +GLYPH_ATTR* g_pSelectedGylph = NULL; + +// Colors +#define COLOR_WHITE ( RGB(255,255,255) ) +#define COLOR_BLACK ( RGB( 0, 0, 0) ) +#define COLOR_BLUE ( RGB( 0, 0,255) ) +#define COLOR_RED ( RGB(255, 0, 0) ) +#define COLOR_DARKRED ( RGB(128, 0, 0) ) + +//----------------------------------------------------------------------------- +// CFontMakerFrameWnd +//----------------------------------------------------------------------------- + +IMPLEMENT_DYNCREATE(CFontMakerFrameWnd, CFrameWnd) + +BEGIN_MESSAGE_MAP(CFontMakerFrameWnd, CFrameWnd) + //{{AFX_MSG_MAP(CFontMakerFrameWnd) + ON_WM_CREATE() + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +int CFontMakerFrameWnd::OnCreate( LPCREATESTRUCT pCreateStruct ) +{ + if( CFrameWnd::OnCreate( pCreateStruct ) == -1 ) + return -1; + + // Create a docked dialog bar + EnableDocking( CBRS_ALIGN_ANY ); + if( !m_wndDialogBar.Create( this, IDD_DIALOGBAR, + CBRS_LEFT, IDD_DIALOGBAR ) ) + { + TRACE0("Failed to create DlgBar\n"); + return -1; + } + + return 0; +} + +//----------------------------------------------------------------------------- +// CFontMakerView +//----------------------------------------------------------------------------- + +IMPLEMENT_DYNCREATE(CFontMakerView, CScrollView) + +BEGIN_MESSAGE_MAP(CFontMakerView, CScrollView) + //{{AFX_MSG_MAP(CFontMakerView) + ON_WM_LBUTTONDOWN() + ON_WM_ERASEBKGND() + ON_WM_KEYDOWN() + //}}AFX_MSG_MAP +END_MESSAGE_MAP() + +//----------------------------------------------------------------------------- +// Name: ~CFontMakerView() +// Desc: Destructor with special cleanup +//----------------------------------------------------------------------------- +CFontMakerView::~CFontMakerView() +{ + // Cleanup before exitting + m_memDC.DeleteDC(); +} + +//----------------------------------------------------------------------------- +// Name: OnInitialUpdate() +// Desc: Called when the view is created. +//----------------------------------------------------------------------------- +void CFontMakerView::OnInitialUpdate() +{ + // Set the scroll bars + CScrollView::OnInitialUpdate(); + CSize szTotal( g_Font.m_dwTextureWidth, g_Font.m_dwTextureHeight ); + SetScrollSizes( MM_TEXT, szTotal ); + CPoint ptCenter( 0, 0 ); + CenterOnPoint( ptCenter ); + + // Create a secondary DC, used for drawing + m_memDC.CreateCompatibleDC( GetDC() ); +} + +//----------------------------------------------------------------------------- +// Name: OnEraseBkgnd() +// Desc: Overridden function to prevent the view from flickering during resizes +// and redraws +//----------------------------------------------------------------------------- +BOOL CFontMakerView::OnEraseBkgnd( CDC* pDC ) +{ + return TRUE; +} + +//----------------------------------------------------------------------------- +// Name: RenderSelectedGlyph() +// Desc: Highlight the selected glyph +//----------------------------------------------------------------------------- +VOID RenderSelectedGlyph( CDC* pDC ) +{ + // If no glyph is selected, return + if( FALSE == g_bIsGlyphSelected ) + return; + + HRGN rgn = CreateRectRgn( 0, 0, g_Font.m_dwTextureWidth, g_Font.m_dwTextureHeight ); + SelectClipRgn( pDC->m_hDC, rgn ); + + // Draw a higlighted background for the selected glyph + { + int x = g_pSelectedGylph->x; + int y = g_pSelectedGylph->y; + int w = g_pSelectedGylph->w; + int h = g_pSelectedGylph->h; + pDC->FillSolidRect( x, y, w, h, COLOR_DARKRED ); + } + + // Setup the DC for drawing text + pDC->SetTextColor( COLOR_WHITE ); + pDC->SelectObject( g_Font.m_hFont ); + pDC->SetTextAlign( TA_LEFT|TA_TOP ); + pDC->SetMapMode( MM_TEXT ); + pDC->SetBkMode( TRANSPARENT ); + pDC->SetBkColor( COLOR_BLUE ); + + CPen pen( PS_SOLID, 1, COLOR_RED ); + pDC->SelectObject( &pen ); + + // Render the selected glyph + GLYPH_ATTR* pGlyph = g_pSelectedGylph; + { + WCHAR c = g_cSelectedGlyph; + WCHAR str[2] = L"A"; + str[0] = c ? c : 0xffff; + + if ( g_Font.m_ValidGlyphs[c] == 2 ) + { + // Draw a square box for a placeholder for custom glyph graphics + pDC->FillSolidRect( pGlyph->x, pGlyph->y, pGlyph->w, pGlyph->h, COLOR_BLACK ); + } + else + { + int sx = pGlyph->x; + int sy = pGlyph->y; + + // Adjust ccordinates to account for the leading edge + if ( str[0] > 0x1000 ) + { + } + else + { + sx -= pGlyph->a; + + if ( g_Font.m_bOutlineEffect ) + sx -= 1; + } + + if ( g_Font.m_bOutlineEffect ) + { + sx++; + sy++; + + pDC->SetTextColor( COLOR_BLACK ); + ExtTextOutW( pDC->m_hDC, sx-1, sy-1, ETO_OPAQUE, NULL, str, 1, NULL ); + ExtTextOutW( pDC->m_hDC, sx+0, sy-1, ETO_OPAQUE, NULL, str, 1, NULL ); + ExtTextOutW( pDC->m_hDC, sx+1, sy-1, ETO_OPAQUE, NULL, str, 1, NULL ); + ExtTextOutW( pDC->m_hDC, sx-1, sy+0, ETO_OPAQUE, NULL, str, 1, NULL ); + ExtTextOutW( pDC->m_hDC, sx+1, sy+0, ETO_OPAQUE, NULL, str, 1, NULL ); + ExtTextOutW( pDC->m_hDC, sx-1, sy+1, ETO_OPAQUE, NULL, str, 1, NULL ); + ExtTextOutW( pDC->m_hDC, sx+0, sy+1, ETO_OPAQUE, NULL, str, 1, NULL ); + ExtTextOutW( pDC->m_hDC, sx+1, sy+1, ETO_OPAQUE, NULL, str, 1, NULL ); + } + + if ( g_Font.m_bShadowEffect ) + { + pDC->SetTextColor( COLOR_BLACK ); + ExtTextOutW( pDC->m_hDC, sx+2, sy+2, ETO_OPAQUE, NULL, str, 1, NULL ); + } + + // Output the letter + pDC->SetTextColor( COLOR_WHITE ); + ExtTextOutW( pDC->m_hDC, sx, sy, ETO_OPAQUE, NULL, str, 1, NULL ); + } + } + + // Draw a red outline around the selected glyph + { + // Create a red pen + CPen pen( PS_SOLID, 1, COLOR_RED ); + pDC->SelectObject( &pen ); + + // Draw the outline + int x1 = pGlyph->x - 1; + int y1 = pGlyph->y - 1; + int x2 = pGlyph->x + pGlyph->w; + int y2 = pGlyph->y + pGlyph->h; + + pDC->MoveTo( x1, y1 ); + pDC->LineTo( x2, y1 ); + pDC->LineTo( x2, y2 ); + pDC->LineTo( x1, y2 ); + pDC->LineTo( x1, y1 ); + } + + SelectClipRgn( pDC->m_hDC, NULL ); + DeleteObject( rgn ); +} + +//----------------------------------------------------------------------------- +// Name: OnDraw() +// Desc: Overridden draw function. Draws the font glyphs if a font is loaded, +// else just a black background. +//----------------------------------------------------------------------------- +VOID CFontMakerView::OnNewFontGlyphs() +{ + // Select the resulting bits into our memory DC + static CBitmap Bitmap; + Bitmap.DeleteObject(); + Bitmap.CreateBitmap( g_Font.m_dwTextureWidth, g_Font.m_dwTextureHeight, 1, 32, g_Font.m_pBits ); + m_memDC.SelectObject( &Bitmap ); + + // Trigger the view to be re-drawn + OnUpdate(0,0,0); +} + +//----------------------------------------------------------------------------- +// Name: OnDraw() +// Desc: Overridden draw function. Draws the font glyphs if a font is loaded, +// else just a black background. +//----------------------------------------------------------------------------- +VOID CFontMakerView::OnDraw( CDC* pDC ) +{ + RECT rc; + GetClientRect( &rc ); + + // Draw the view + if ( g_Font.m_hFont == NULL && !g_Font.m_pCustomFilename ) + { + // Don't display any scroll bars + CSize sizeTotal( 0, 0 ); + SetScrollSizes( MM_TEXT, sizeTotal ); + + // Draw a black background + pDC->FillSolidRect( 0, 0, rc.right, rc.bottom, COLOR_BLACK ); + } + else + { + // Set the scroll sizes for the view + CSize sizeTotal( g_Font.m_dwTextureWidth, g_Font.m_dwTextureHeight ); + SetScrollSizes( MM_TEXT, sizeTotal ); + + // Draw the view's black areas + pDC->FillSolidRect( g_Font.m_dwTextureWidth, 0, max( (int)g_Font.m_dwTextureWidth, rc.right), g_Font.m_dwTextureHeight, COLOR_BLACK ); + pDC->FillSolidRect( 0, g_Font.m_dwTextureHeight, max( (int)g_Font.m_dwTextureWidth, rc.right), max( (int)g_Font.m_dwTextureHeight, rc.bottom), COLOR_BLACK ); + + // Display the bitmap of all the rendered glyphs + pDC->BitBlt( 0, 0, g_Font.m_dwTextureWidth, g_Font.m_dwTextureHeight, &m_memDC, 0, 0, SRCCOPY ); + + // Draw the selected glyph, if any + RenderSelectedGlyph( pDC ); + } +} + +//----------------------------------------------------------------------------- +// Name: OnLButtonDown() +// Desc: Overridden function to select a glyph when the user clicks the mouse. +//----------------------------------------------------------------------------- +void CFontMakerView::OnLButtonDown( UINT nFlags, CPoint point ) +{ + if ( !g_Font.m_hFont ) + return; + + // Correct the mouseclick point to account for the scroll position + point += GetScrollPosition(); + + // Find out which glyph, if any, is selected by the mouse click + theApp.UpdateSelectedGlyph( FALSE ); + + for( DWORD i=0; i<g_Font.m_dwNumGlyphs && g_Font.m_pGlyphs; i++ ) + { + GLYPH_ATTR* pGlyph = &g_Font.m_pGlyphs[i]; + + if ( point.x >= pGlyph->x-2 && point.x <= pGlyph->x + pGlyph->w ) + { + if ( point.y >= pGlyph->y-2 && point.y <= pGlyph->y + pGlyph->h ) + { + theApp.UpdateSelectedGlyph( TRUE, i ); + break; + } + } + } + + // Redraw the view to show the newly selected glyph + Invalidate( TRUE ); + + // Call the base class' handler + CScrollView::OnLButtonDown( nFlags, point ); +} + +//----------------------------------------------------------------------------- +// Name: OnKeyDown() +// Desc: Overridden function to select a glyph with the keyboard. +//----------------------------------------------------------------------------- +void CFontMakerView::OnKeyDown( UINT nChar, UINT nRepCnt, UINT nFlags ) +{ + if ( !g_Font.m_hFont ) + return; + + if( g_Font.m_dwNumGlyphs > 0 ) + { + if( FALSE == g_bIsGlyphSelected ) + { + if( nChar == 37 || nChar == 38 || nChar == 39 || nChar == 40 ) // Left, right, up or down + { + // Select the first glyph + theApp.UpdateSelectedGlyph( TRUE, 0 ); + } + } + else + { + if( nChar == 37 ) // Left + theApp.UpdateSelectedGlyph( TRUE, max( 0, g_iSelectedGlyphNum-1 ) ); + else if( nChar == 39 ) // Right + theApp.UpdateSelectedGlyph( TRUE, min( (int)g_Font.m_dwNumGlyphs-1, g_iSelectedGlyphNum+1 ) ); + else if( nChar == 38 || nChar == 40 ) // Up or down + { + // Find the closest glyph above or below to move to + int x = g_pSelectedGylph->x + g_pSelectedGylph->w/2; + int y = g_pSelectedGylph->y + g_pSelectedGylph->h/2; + + if( nChar == 38 ) y -= g_pSelectedGylph->h; + if( nChar == 40 ) y += g_pSelectedGylph->h; + + for( DWORD i=0; i<g_Font.m_dwNumGlyphs; i++ ) + { + GLYPH_ATTR* pGlyph = &g_Font.m_pGlyphs[i]; + + if( x >= pGlyph->x-2 && x <= pGlyph->x + pGlyph->w ) + { + if( y >= pGlyph->y-2 && y <= pGlyph->y + pGlyph->h ) + { + theApp.UpdateSelectedGlyph( TRUE, i ); + break; + } + } + } + } + else if ( nChar == 46 ) + { + // delete a glyph + theApp.OnGlyphsCustom(); + + // mark glyph as invalid + g_Font.DeleteGlyph( g_cSelectedGlyph ); + + // reset to the first glyph + theApp.UpdateSelectedGlyph( FALSE ); + } + else if ( nChar == 45 ) + { + // insert a glyph + theApp.OnGlyphsCustom(); + + // reset to the first glyph + theApp.UpdateSelectedGlyph( FALSE ); + + theApp.InsertGlyph(); + } + } + + // Redraw the view to show the newly selected glyph + Invalidate( TRUE ); + } + + CScrollView::OnKeyDown( nChar, nRepCnt, nFlags ); +} + + + diff --git a/utils/xbox/FontMaker/glyphs.cpp b/utils/xbox/FontMaker/glyphs.cpp new file mode 100644 index 0000000..c2328ac --- /dev/null +++ b/utils/xbox/FontMaker/glyphs.cpp @@ -0,0 +1,1484 @@ +//----------------------------------------------------------------------------- +// Name: Glyphs.cpp +// +// Desc: Functions and global variables for keeping track of font glyphs +// +// Hist: 09.06.02 - Revised Fontmaker sample +// +// Copyright (c) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#include "stdafx.h" +#include "Glyphs.h" +#include "FontMaker.h" + +const COLORREF COLOR_WHITE = RGB(255,255,255); +const COLORREF COLOR_BLACK = RGB( 0, 0, 0); +const COLORREF COLOR_BLUE = RGB( 0, 0,255); + +//----------------------------------------------------------------------------- +// Name: CTextureFont() +// Desc: Constructor +//----------------------------------------------------------------------------- +CTextureFont::CTextureFont() +{ + ZeroMemory( this, sizeof( *this ) ); + + m_bIncludeNullCharacter = TRUE; + m_bAntialiasEffect = TRUE; + + // Texture info + m_dwTextureWidth = 256; + m_dwTextureHeight = 256; + + // Default glyph range + WORD wStartGlyph = 32; + WORD wEndGlyph = 255; + ExtractValidGlyphsFromRange( wStartGlyph, wEndGlyph ); +} + +//----------------------------------------------------------------------------- +// Name: ~CTextureFont() +// Desc: Destructor +//----------------------------------------------------------------------------- +CTextureFont::~CTextureFont() +{ + DestroyObjects(); + + if ( m_hFont ) + DeleteObject( m_hFont ); + + if ( m_pBits ) + delete[] m_pBits; + + m_pBits = NULL; + m_hFont = NULL; +} + +//----------------------------------------------------------------------------- +// ClearFont +//----------------------------------------------------------------------------- +void CTextureFont::ClearFont() +{ + DestroyObjects(); + + ZeroMemory( &m_LogFont, sizeof(LOGFONT) ); + + m_strFontName[0] = '\0'; + + m_hFont = NULL; + + m_dwTextureWidth = 256; + m_dwTextureHeight = 256; + + m_bAntialiasEffect = FALSE; + m_bShadowEffect = FALSE; + m_bOutlineEffect = FALSE; + m_nBlur = 0; + m_nScanlines = 0; +} + +//----------------------------------------------------------------------------- +// Name: DestroyObjects() +// Desc: Cleans up all allocated resources for the class +//----------------------------------------------------------------------------- +VOID CTextureFont::DestroyObjects() +{ + if ( m_pGlyphs ) + delete[] m_pGlyphs; + if ( m_ValidGlyphs ) + delete[] m_ValidGlyphs; + if ( m_TranslatorTable ) + delete[] m_TranslatorTable; + + if ( m_pCustomFilename ) + { + TL_Free( (void*)m_pCustomFilename ); + m_pCustomFilename = NULL; + + for (DWORD i=0; i<m_dwNumGlyphs; i++) + { + if ( m_pCustomGlyphFiles[i] ) + { + TL_Free( m_pCustomGlyphFiles[i] ); + m_pCustomGlyphFiles[i] = NULL; + } + } + } + + m_cMaxGlyph = 0; + m_dwNumGlyphs = 0; + m_pGlyphs = NULL; + m_ValidGlyphs = NULL; + m_TranslatorTable = NULL; +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +HRESULT CTextureFont::InsertGlyph( WORD wGlyph ) +{ + m_cMaxGlyph = 0; + m_dwNumGlyphs = 0; + + m_ValidGlyphs[wGlyph] = 1; + + for ( DWORD c=0; c<=65535; c++ ) + { + if ( m_ValidGlyphs[c] ) + { + m_dwNumGlyphs++; + m_cMaxGlyph = (WCHAR)c; + } + } + + BuildTranslatorTable(); + theApp.CalculateAndRenderGlyphs(); + + return S_OK; +} + +//----------------------------------------------------------------------------- +//----------------------------------------------------------------------------- +HRESULT CTextureFont::DeleteGlyph( WORD wGlyph ) +{ + m_cMaxGlyph = 0; + m_dwNumGlyphs = 0; + + m_ValidGlyphs[wGlyph] = 0; + + for ( DWORD c=0; c<=65535; c++ ) + { + if ( m_ValidGlyphs[c] ) + { + m_dwNumGlyphs++; + m_cMaxGlyph = (WCHAR)c; + } + } + + BuildTranslatorTable(); + theApp.CalculateAndRenderGlyphs(); + + return S_OK; +} + +//----------------------------------------------------------------------------- +// Name: ExtractValidGlyphsFromRange() +// Desc: Set global variables to indicate we will be drawing all glyphs in the +// range specified. +//----------------------------------------------------------------------------- +HRESULT CTextureFont::ExtractValidGlyphsFromRange( WORD wStartGlyph, WORD wEndGlyph ) +{ + // Cleanup any previous entries + if( m_ValidGlyphs ) + delete[] m_ValidGlyphs; + + m_cMaxGlyph = 0; + m_dwNumGlyphs = 0; + m_ValidGlyphs = NULL; + + // Allocate memory for the array of vaild glyphs + m_ValidGlyphs = new BYTE[65536]; + ZeroMemory( m_ValidGlyphs, 65536 ); + + for( DWORD c=(DWORD)wStartGlyph; c<=(DWORD)wEndGlyph; c++ ) + { + m_ValidGlyphs[c] = 1; + m_dwNumGlyphs++; + } + + m_cMaxGlyph = wEndGlyph; + + BuildTranslatorTable(); + + return S_OK; +} + +//----------------------------------------------------------------------------- +// Name: ExtractValidGlyphsFromRange() +// Desc: Set global variables to indicate we will be drawing all glyphs that +// are present in the specified text file. +//----------------------------------------------------------------------------- +HRESULT CTextureFont::ExtractValidGlyphsFromFile( const CHAR* strFileName ) +{ + // Open the file + FILE* file = fopen( strFileName, "rb" ); + if( NULL == file ) + return E_FAIL; + + // Cleanup any previous entries + if( m_ValidGlyphs ) + delete[] m_ValidGlyphs; + + m_cMaxGlyph = 0; + m_dwNumGlyphs = 0; + m_ValidGlyphs = NULL; + + // Allocate memory for the array of vaild glyphs + m_ValidGlyphs = new BYTE[65536]; + ZeroMemory( m_ValidGlyphs, 65536 ); + + // Skip the unicode marker + BOOL bIsUnicode = (fgetwc(file) == 0xfeff) ? TRUE : FALSE; + + if( bIsUnicode == FALSE ) + rewind( file ); + + // Record which glyphs are valid + WCHAR c; + while( (WCHAR)EOF != ( c = bIsUnicode ? fgetwc(file) : fgetc(file) ) ) + { + while( c == L'\\' ) + { + c = bIsUnicode ? fgetwc(file) : fgetc(file); + + // Handle octal-coded characters + if( isdigit(c) ) + { + int code = (c - L'0'); + c = bIsUnicode ? fgetwc(file) : fgetc(file); + + if( isdigit(c) ) + { + code = code*8 + (c - L'0'); + c = bIsUnicode ? fgetwc(file) : fgetc(file); + + if( isdigit(c) ) + { + code = code*8 + (c - L'0'); + c = bIsUnicode ? fgetwc(file) : fgetc(file); + } + } + + if( m_ValidGlyphs[code] == 0 ) + { + if( code > m_cMaxGlyph ) + m_cMaxGlyph = (WCHAR)code; + + m_dwNumGlyphs++; + m_ValidGlyphs[code] = 2; + } + } + else + { + // Add the backslash character + if( L'\\' > m_cMaxGlyph ) + m_cMaxGlyph = L'\\'; + + if( m_ValidGlyphs[L'\\'] == 0 ) + { + m_dwNumGlyphs++; + m_ValidGlyphs[L'\\'] = 1; + } + } + } + + if( m_ValidGlyphs[c] == 0 ) + { + // If the character is a printable one, add it + if( c != L'\n' && c != L'\r' && c != 0xffff ) + { + m_dwNumGlyphs++; + m_ValidGlyphs[c] = 1; + + if( c > m_cMaxGlyph ) + m_cMaxGlyph = c; + } + } + } + + // Done with the file + fclose( file ); + + BuildTranslatorTable(); + + return S_OK; +} + +//----------------------------------------------------------------------------- +// Name: BuildTranslatorTable() +// Desc: Builds a table to translate from a WCHAR to a glyph index. +//----------------------------------------------------------------------------- +HRESULT CTextureFont::BuildTranslatorTable() +{ + if ( m_TranslatorTable ) + delete[] m_TranslatorTable; + + // Insure the \0 is there + if ( m_bIncludeNullCharacter && 0 == m_ValidGlyphs[0] ) + { + m_dwNumGlyphs++; + m_ValidGlyphs[0] = 1; + } + + // Fill the string of all valid glyphs and build the translator table + m_TranslatorTable = new WORD[m_cMaxGlyph+1]; + ZeroMemory( m_TranslatorTable, sizeof(WORD)*(m_cMaxGlyph+1) ); + + if ( !m_pCustomFilename ) + { + // ttf has glyphs that are sequential + DWORD dwGlyph = 0; + for ( DWORD i=0; i<65536; i++ ) + { + if ( m_ValidGlyphs[i] ) + { + m_TranslatorTable[i] = (WORD)dwGlyph; + dwGlyph++; + } + } + } + else + { + // custom font has glyphs that are scattered + DWORD dwGlyph = 0; + for ( DWORD i=0; i<m_dwNumGlyphs; i++ ) + { + if ( !i && m_bIncludeNullCharacter ) + { + m_TranslatorTable[0] = 0; + dwGlyph++; + continue; + } + + m_TranslatorTable[m_customGlyphs[i-1]] = (WORD)dwGlyph; + dwGlyph++; + } + } + + return S_OK; +} + +void StripQuotedToken( char *pToken ) +{ + int len = strlen( pToken ); + if ( !len ) + return; + + if ( pToken[0] == '\"' && pToken[len-1] == '\"' ) + { + memcpy( pToken, pToken+1, len-1 ); + pToken[len-2] = '\0'; + } +} + + + +//----------------------------------------------------------------------------- +// ReadCustomFontFile +//----------------------------------------------------------------------------- +HRESULT CTextureFont::ReadCustomFontFile( CHAR* strFileName ) +{ + char *pToken; + char fontName[128]; + bool bSuccess; + unsigned char glyphs[256]; + char *glyphFiles[512]; + char basePath[MAX_PATH]; + int numGlyphs; + char filename[MAX_PATH]; + + bSuccess = false; + numGlyphs = 0; + + ClearFont(); + + TL_LoadScriptFile( strFileName ); + + strcpy( basePath, strFileName ); + TL_StripFilename( basePath ); + TL_AddSeperatorToPath( basePath, basePath ); + + fontName[0] = '\0'; + while ( 1 ) + { + pToken = TL_GetToken( true ); + if ( !pToken || !pToken[0] ) + break; + StripQuotedToken( pToken ); + + // get font name + if ( !stricmp( pToken, "fontName" ) ) + { + pToken = TL_GetToken( true ); + if ( !pToken || !pToken[0] ) + goto cleanUp; + StripQuotedToken( pToken ); + strcpy( fontName, pToken ); + continue; + } + + // get glyph + if ( strlen( pToken ) != 1 ) + goto cleanUp; + glyphs[numGlyphs] = pToken[0]; + + // get glyph file + pToken = TL_GetToken( true ); + if ( !pToken || !pToken[0] ) + goto cleanUp; + StripQuotedToken( pToken ); + sprintf( filename, "%s%s", basePath, pToken ); + glyphFiles[numGlyphs] = TL_CopyString( filename ); + + numGlyphs++; + if ( numGlyphs >= 256 ) + break; + } + + if ( numGlyphs == 0 ) + goto cleanUp; + + m_pCustomFilename = TL_CopyString( strFileName ); + strcpy ( m_strFontName, fontName ); + + m_dwTextureWidth = 256; + m_dwTextureHeight = 256; + + m_ValidGlyphs = new BYTE[65536]; + ZeroMemory( m_ValidGlyphs, 65536 ); + + m_dwNumGlyphs = numGlyphs; + m_cMaxGlyph = 0; + for (int i=0; i<numGlyphs; i++) + { + m_ValidGlyphs[glyphs[i]] = 1; + + if ( m_cMaxGlyph < glyphs[i] ) + m_cMaxGlyph = glyphs[i]; + + m_customGlyphs[i] = glyphs[i]; + m_pCustomGlyphFiles[i] = glyphFiles[i]; + } + + BuildTranslatorTable(); + + bSuccess = true; + +cleanUp: + TL_FreeScriptFile(); + return bSuccess ? S_OK : E_FAIL; +} + +//----------------------------------------------------------------------------- +// Name: ReadFontInfoFile() +// Desc: Loads the font's glyph info from a file +//----------------------------------------------------------------------------- +HRESULT CTextureFont::ReadFontInfoFile( CHAR* strFileName ) +{ + BitmapFont_t bitmapFont; + + // open the info file + FILE* file = fopen( strFileName, "rb" ); + if ( NULL == file ) + return E_FAIL; + + memset( &bitmapFont, 0, sizeof( BitmapFont_t ) ); + fread( &bitmapFont, 1, sizeof( BitmapFont_t ), file ); + + if ( bitmapFont.m_id != BITMAPFONT_ID || bitmapFont.m_Version != BITMAPFONT_VERSION ) + { + return E_FAIL; + } + + theApp.SetTextureSize( bitmapFont.m_PageWidth, bitmapFont.m_PageHeight ); + + ZeroMemory( m_ValidGlyphs, 65536 ); + + m_dwNumGlyphs = 0; + m_cMaxGlyph = 0; + for (int i=0; i<256; i++) + { + if ( bitmapFont.m_TranslateTable[i] ) + { + m_ValidGlyphs[i] = 1; + m_cMaxGlyph = i; + m_dwNumGlyphs++; + } + } + BuildTranslatorTable(); + + // success + fclose( file ); + + theApp.OnGlyphsCustom(); + theApp.CalculateAndRenderGlyphs(); + + return S_OK; +} + +//----------------------------------------------------------------------------- +// Name: WriteFontInfoFile() +// Desc: Writes the font's glyph info to a file +//----------------------------------------------------------------------------- +HRESULT CTextureFont::WriteFontInfoFile( CHAR* strFileName ) +{ + BitmapFont_t bitmapFont; + BitmapGlyph_t bitmapGlyph; + + // Create the info file + FILE* file = fopen( strFileName, "wb" ); + if ( NULL == file ) + return E_FAIL; + + bitmapFont.m_id = BITMAPFONT_ID; + bitmapFont.m_Version = BITMAPFONT_VERSION; + bitmapFont.m_PageWidth = (short)m_dwTextureWidth; + bitmapFont.m_PageHeight = (short)m_dwTextureHeight; + bitmapFont.m_Ascent = 0; + bitmapFont.m_NumGlyphs = (short)m_dwNumGlyphs; + + // generate flags + bitmapFont.m_Flags = 0; + if ( m_bAntialiasEffect ) + { + bitmapFont.m_Flags |= BF_ANTIALIASED; + } + if ( m_bShadowEffect ) + { + bitmapFont.m_Flags |= BF_DROPSHADOW; + } + if ( m_bOutlineEffect ) + { + bitmapFont.m_Flags |= BF_OUTLINED; + } + if ( m_nBlur ) + { + bitmapFont.m_Flags |= BF_BLURRED; + } + if ( m_nScanlines ) + { + bitmapFont.m_Flags |= BF_SCANLINES; + } + if ( m_LogFont.lfItalic ) + { + bitmapFont.m_Flags |= BF_ITALIC; + } + if ( m_LogFont.lfWeight > 400 ) + { + bitmapFont.m_Flags |= BF_BOLD; + } + if ( m_pCustomFilename ) + { + bitmapFont.m_Flags |= BF_CUSTOM; + } + + // determine max char width from all glyphs + bitmapFont.m_MaxCharWidth = 0; + for (unsigned int i=0; i<m_dwNumGlyphs; i++ ) + { + if ( bitmapFont.m_MaxCharWidth < m_pGlyphs[i].w ) + { + bitmapFont.m_MaxCharWidth = m_pGlyphs[i].w; + } + } + + bitmapFont.m_MaxCharHeight = 0; + for (unsigned int i=0; i<m_dwNumGlyphs; i++ ) + { + if ( bitmapFont.m_MaxCharHeight < m_pGlyphs[i].h ) + { + bitmapFont.m_MaxCharHeight = m_pGlyphs[i].h; + } + } + + // maps a char index to its actual glyph + for (int i=0; i<256; i++) + { + if ( i <= m_cMaxGlyph ) + { + bitmapFont.m_TranslateTable[i] = (unsigned char)m_TranslatorTable[i]; + } + else + { + bitmapFont.m_TranslateTable[i] = 0; + } + } + + // write out the header + fwrite( &bitmapFont, sizeof( BitmapFont_t ), 1, file ); + + // Write out the vertical padding caused by effects +// FLOAT fTopPadding = ( m_bOutlineEffect ? 1.0f : 0.0f ); +// FLOAT fBottomPadding = ( m_bOutlineEffect ? ( m_bShadowEffect ? 2.0f : 1.0f ) : ( m_bShadowEffect ? 2.0f : 0.0f ) ); +// FLOAT fFontYAdvance = fFontHeight - fTopPadding - fBottomPadding; + + // Write the glyph attributes to the file + for (unsigned int i=0; i<m_dwNumGlyphs; i++ ) + { + bitmapGlyph.x = m_pGlyphs[i].x; + bitmapGlyph.y = m_pGlyphs[i].y; + bitmapGlyph.w = m_pGlyphs[i].w; + bitmapGlyph.h = m_pGlyphs[i].h; + bitmapGlyph.a = m_pGlyphs[i].a; + bitmapGlyph.b = m_pGlyphs[i].b; + bitmapGlyph.c = m_pGlyphs[i].c; + + fwrite( &bitmapGlyph, sizeof( BitmapGlyph_t ), 1, file ); + } + + // success + fclose( file ); + return S_OK; +} + +//----------------------------------------------------------------------------- +// Name: WriteTargaFile() +// Desc: Writes 32-bit RGBA data to a .tga file +//----------------------------------------------------------------------------- +HRESULT WriteTargaFile( CHAR* strFileName, DWORD dwWidth, DWORD dwHeight, + DWORD* pRGBAData ) +{ + struct TargaHeader + { + BYTE IDLength; + BYTE ColormapType; + BYTE ImageType; + BYTE ColormapSpecification[5]; + WORD XOrigin; + WORD YOrigin; + WORD ImageWidth; + WORD ImageHeight; + BYTE PixelDepth; + BYTE ImageDescriptor; + } tga; + + // Create the file + FILE* file = fopen( strFileName, "wb" ); + if( NULL == file ) + return E_FAIL; + + // Write the TGA header + ZeroMemory( &tga, sizeof(tga) ); + tga.IDLength = 0; + tga.ImageType = 2; + tga.ImageWidth = (WORD)dwWidth; + tga.ImageHeight = (WORD)dwHeight; + tga.PixelDepth = 32; + tga.ImageDescriptor = 0x28; + fwrite( &tga, sizeof(TargaHeader), 1, file ); + + // Write the pixels + fwrite( pRGBAData, sizeof(DWORD), dwHeight*dwWidth, file ); + + // Close the file and return okay + fclose( file ); + + return S_OK; +} + +//----------------------------------------------------------------------------- +// Name: WriteFontImageFile() +// Desc: Writes 32-bit RGBA data to a .tga file +//----------------------------------------------------------------------------- +HRESULT CTextureFont::WriteFontImageFile( CHAR* strFileName, bool bAdditiveMode, bool bCustomFont ) +{ + // Convert the bits to have an alpha channel + DWORD* pRGBAData = new DWORD[m_dwTextureWidth*m_dwTextureHeight]; + + FLOAT l; + for ( DWORD i=0; i<m_dwTextureWidth*m_dwTextureHeight; i++ ) + { + FLOAT a = ( ( 0xff000000 & m_pBits[i] ) >> 24L ) / 255.0f; + FLOAT r = ( ( 0x00ff0000 & m_pBits[i] ) >> 16L ) / 255.0f; + FLOAT g = ( ( 0x0000ff00 & m_pBits[i] ) >> 8L ) / 255.0f; + FLOAT b = ( ( 0x000000ff & m_pBits[i] ) >> 0L ) / 255.0f; + + if ( bCustomFont ) + { + if ( a == 0.0f && b == 1.0f ) + { + // pure transluscent + a = 0; + r = g = b = 0.0f; + } + + int red = (int)(r * 255.0f); + int green = (int)(g * 255.0f); + int blue = (int)(b * 255.0f); + int alpha = (int)(a * 255.0f); + + pRGBAData[i] = (alpha<<24L) | (red<<16L) | (green<<8L) | (blue<<0L); + } + else + { + if ( bAdditiveMode ) + { + // all channels should be same + if (( r != g ) || ( r != b )) + { + } + + l = r; + a = 1.0f; + } + else + { + a = r + (1-b); + if ( a ) + l = r / a; + else + l = 1; + } + + DWORD alpha = (DWORD)( a * 255.0f ); + DWORD lum = (DWORD)( l * 255.0f ); + + pRGBAData[i] = (alpha<<24L) | (lum<<16L) | (lum<<8L) | (lum<<0L); + } + } + + // Write the file + HRESULT hr = WriteTargaFile( strFileName, m_dwTextureWidth, + m_dwTextureHeight, pRGBAData ); + + // Cleanup and return + delete[] pRGBAData; + return hr; +} + +void GetBitmapBits2( HBITMAP hBitmap, int width, int height, void *pBits ) +{ + memset( pBits, 0, width*height*4 ); + + HDC hDC = CreateCompatibleDC( NULL ); + BITMAPINFO bitmapInfo = {0}; + bitmapInfo.bmiHeader.biSize = sizeof( bitmapInfo.bmiHeader ); + bitmapInfo.bmiHeader.biWidth = width; + bitmapInfo.bmiHeader.biHeight = -height; + bitmapInfo.bmiHeader.biPlanes = 1; + bitmapInfo.bmiHeader.biBitCount = 32; + bitmapInfo.bmiHeader.biCompression = BI_RGB; + GetDIBits( hDC, hBitmap, 0, height, pBits, &bitmapInfo ,DIB_RGB_COLORS ); + DeleteDC( hDC ); +} + +void SetBitmapBits2( HBITMAP hBitmap, int width, int height, void *pBits ) +{ + HDC hDC = CreateCompatibleDC( NULL ); + BITMAPINFO bitmapInfo = {0}; + bitmapInfo.bmiHeader.biSize = sizeof( bitmapInfo.bmiHeader ); + bitmapInfo.bmiHeader.biWidth = width; + bitmapInfo.bmiHeader.biHeight = -height; + bitmapInfo.bmiHeader.biPlanes = 1; + bitmapInfo.bmiHeader.biBitCount = 32; + bitmapInfo.bmiHeader.biCompression = BI_RGB; + SetDIBits( hDC, hBitmap, 0, height, pBits, &bitmapInfo ,DIB_RGB_COLORS ); + DeleteDC( hDC ); +} + +//----------------------------------------------------------------------------- +// SetTextureBits +// +// Blit the rect back into the bitmap +//----------------------------------------------------------------------------- +void SetTextureBits( HBITMAP hBitmap, int bitmapWidth, int bitmapHeight, int x, int y, int w, int h, unsigned char *pRGBA ) +{ + // get the enitre bitmap + unsigned char *pBitmapBits = (unsigned char *)malloc( bitmapWidth * bitmapHeight * 4); + GetBitmapBits2( hBitmap, bitmapWidth, bitmapHeight, pBitmapBits ); + + // copy into bitmap bits + unsigned char *pSrc = pRGBA; + for (int yy=y; yy<y+h; yy++) + { + if ( yy >= bitmapHeight ) + { + // past end of bitmap + break; + } + + unsigned char *pDst = pBitmapBits + (yy*bitmapWidth + x)*4; + for (int xx=0; xx<w; xx++) + { + if ( xx+x < bitmapWidth ) + { + pDst[0] = pSrc[0]; + pDst[1] = pSrc[1]; + pDst[2] = pSrc[2]; + pDst[3] = pSrc[3]; + } + pSrc += 4; + pDst += 4; + } + } + + SetBitmapBits2( hBitmap, bitmapWidth, bitmapHeight, pBitmapBits ); + + free( pBitmapBits ); +} + +//----------------------------------------------------------------------------- +// GetTextureBits +// +// Blit the rect out of the bitmap +//----------------------------------------------------------------------------- +unsigned char *GetTextureBits( HBITMAP hBitmap, int bitmapWidth, int bitmapHeight, int x, int y, int w, int h ) +{ + // get the enitre bitmap + unsigned char *pBitmapBits = new unsigned char[bitmapWidth * bitmapHeight * 4]; + GetBitmapBits2( hBitmap, bitmapWidth, bitmapHeight, pBitmapBits ); + + unsigned char *pRGBA = new unsigned char[w * h * 4]; + memset( pRGBA, 0, w*h*4 ); + + // copy out bits + unsigned char *pDst = pRGBA; + for (int yy=y; yy<y+h; yy++) + { + if ( yy >= bitmapHeight ) + { + // past last row of bitmap + break; + } + + unsigned char *pSrc = pBitmapBits + (yy*bitmapWidth + x)*4; + for (int xx=0; xx<w; xx++) + { + if ( xx + x < bitmapWidth ) + { + pDst[0] = pSrc[0]; + pDst[1] = pSrc[1]; + pDst[2] = pSrc[2]; + pDst[3] = pSrc[3]; + } + pSrc += 4; + pDst += 4; + } + } + + delete [] pBitmapBits; + return pRGBA; +} + + +int g_blur; +float *g_pGaussianDistribution; + +//----------------------------------------------------------------------------- +// Purpose: Gets the blur value for a single pixel +//----------------------------------------------------------------------------- +void GetBlurValueForPixel(unsigned char *src, int blur, float *gaussianDistribution, int srcX, int srcY, int srcWide, int srcTall, unsigned char *dest) +{ + int r = 0, g = 0, b = 0, a = 0; + + float accum = 0.0f; + + // scan the positive x direction + int maxX = min(srcX + blur, srcWide); + int minX = max(srcX - blur, 0); + for (int x = minX; x <= maxX; x++) + { + int maxY = min(srcY + blur, srcTall - 1); + int minY = max(srcY - blur, 0); + for (int y = minY; y <= maxY; y++) + { + unsigned char *srcPos = src + ((x + (y * srcWide)) * 4); + + unsigned char red = srcPos[2]; + unsigned char green = srcPos[1]; + unsigned char blue = srcPos[0]; + + // muliply by the value matrix + float weight = gaussianDistribution[x - srcX + blur]; + float weight2 = gaussianDistribution[y - srcY + blur]; + accum += (red * (weight * weight2)); + } + } + + // blurring decreased the range, for xbox kick some back + accum *= 1.30f; + + // all the values are the same for fonts, just use the calculated alpha + r = g = b = (int)accum; + + dest[0] = min(b, 255); + dest[1] = min(g, 255); + dest[2] = min(r, 255); +} + +//----------------------------------------------------------------------------- +// ApplyGaussianBlurToTexture +//----------------------------------------------------------------------------- +void ApplyGaussianBlurToTexture( int blur, int rgbaX, int rgbaY, int rgbaWide, int rgbaTall, unsigned char *rgba) +{ + // calculate our gaussian distribution for if we're blurred + if ( blur > 1 && blur != g_blur ) + { + g_blur = blur; + g_pGaussianDistribution = new float[blur * 2 + 1]; + double sigma = 0.683f * blur; + for (int x = 0; x <= (blur * 2); x++) + { + int val = x - blur; + g_pGaussianDistribution[x] = (float)((1.0 / sqrt(2.0 * 3.14 * sigma * sigma)) * pow(2.7, -1.0 * (val * val) / (2.0 * sigma * sigma))); + + // brightening factor + g_pGaussianDistribution[x] *= 1; + } + } + + // alloc a new buffer + unsigned char *src = (unsigned char *)_alloca(rgbaWide * rgbaTall * 4); + memcpy(src, rgba, rgbaWide * rgbaTall * 4); + + unsigned char *dest = rgba; + for (int y = 0; y < rgbaTall; y++) + { + for (int x = 0; x < rgbaWide; x++) + { + // scan the source pixel + GetBlurValueForPixel(src, blur, g_pGaussianDistribution, x, y, rgbaWide, rgbaTall, dest); + + // move to the next + dest += 4; + } + } +} + +//----------------------------------------------------------------------------- +// ApplyScanlineEffectToTexture +//----------------------------------------------------------------------------- +void ApplyScanlineEffectToTexture( int scanLines, int rgbaX, int rgbaY, int rgbaWide, int rgbaTall, unsigned char *rgba) +{ + if (scanLines < 2) + return; + + float scale; + scale = 0; + + // darken all the areas except the scanlines + for (int y = 0; y < rgbaTall; y++) + { + // skip the scan lines + if (y % scanLines == 0) + continue; + + DWORD *pBits = (DWORD*)&rgba[(rgbaX + ((y + rgbaY) * rgbaWide)) * 4]; + + // darken the other lines + for (int x = 0; x < rgbaWide; x++, pBits++) + { + FLOAT r = ( ( 0x00ff0000 & pBits[0] ) >> 16L ) / 255.0f; + FLOAT g = ( ( 0x0000ff00 & pBits[0] ) >> 8L ) / 255.0f; + FLOAT b = ( ( 0x000000ff & pBits[0] ) >> 0L ) / 255.0f; + + r *= scale; + g *= scale; + b *= scale; + + pBits[0] = (((int)(r * 255.0f))<<16) | (((int)(g * 255.0f))<<8) | ((int)(b * 255.0f)); + pBits[0] |= 0xFF000000; + } + } +} + + +//----------------------------------------------------------------------------- +// Name: RenderTTFGlyphs() +// Desc: Draws the list of font glyphs in the scroll view +//----------------------------------------------------------------------------- +GLYPH_ATTR* CTextureFont::RenderTTFGlyphs( HFONT hFont, HBITMAP hBitmap, + DWORD dwTextureWidth, DWORD dwTextureHeight, + BOOL bOutlineEffect, BOOL bShadowEffect, + int nScanlineEffect, int nBlurEffect, + BOOL bAntialias, + BYTE* ValidGlyphs, DWORD dwNumGlyphs ) +{ + // Create a DC + HDC hDC = CreateCompatibleDC( NULL ); + + // Associate the drawing surface + SelectObject( hDC, hBitmap ); + + // Create a clip region + HRGN rgn = CreateRectRgn( 0, 0, dwTextureWidth, dwTextureHeight ); + SelectClipRgn( hDC, rgn ); + + // Setup the DC for the font + SetTextColor( hDC, COLOR_WHITE ); + SelectObject( hDC, hFont ); + SetTextAlign( hDC, TA_LEFT|TA_TOP|TA_UPDATECP ); + SetMapMode( hDC, MM_TEXT ); + SetBkMode( hDC, TRANSPARENT ); + + if ( nScanlineEffect || nBlurEffect ) + { + SetBkColor( hDC, COLOR_BLACK ); + + if ( nBlurEffect < 2 ) + nBlurEffect = 2; + if ( nScanlineEffect < 2 ) + nScanlineEffect = 2; + } + else + { + SetBkColor( hDC, COLOR_BLUE ); + } + + // Fill the background in blue + RECT rect; + SetRect( &rect, 0, 0, dwTextureWidth, dwTextureHeight ); + ExtTextOut( hDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL ); + + // Get the effective font height + WCHAR str[2] = L"A"; + SIZE size; + GetTextExtentPoint32W( hDC, str, 1, &size ); + + DWORD dwLeftOrigin = 1; + DWORD dwTopOrigin = 1; + + GLYPH_ATTR* pGlyphs = new GLYPH_ATTR[dwNumGlyphs]; + memset( pGlyphs, 0, dwNumGlyphs*sizeof( GLYPH_ATTR ) ); + + // Loop through all printable character and output them to the bitmap.. + // Meanwhile, keep track of the corresponding tex coords for each character. + DWORD x = dwLeftOrigin; + DWORD y = dwTopOrigin; + int sx; + int sy; + + int numGlyphs = 0; + + for( DWORD i=0; i<65536; i++ ) + { + if ( 0 == ValidGlyphs[i]) + continue; + + str[0] = (WCHAR)i; + + if ( i==0 && ValidGlyphs[i] == 1 ) + { + // account for unprintable, but don't render it + numGlyphs++; + continue; + } + + GetTextExtentPoint32W( hDC, str, 1, &size ); + + // Get char width a different way + int charwidth; + GetCharWidth32( hDC, str[0], str[0], &charwidth ); + + // Get the ABC widths for the letter + ABC abc; + if ( FALSE == GetCharABCWidthsW( hDC, str[0], str[0], &abc ) ) + { + abc.abcA = 0; + abc.abcB = size.cx; + abc.abcC = 0; + } + + int w = abc.abcB; + int h = size.cy; + + // Determine padding for effects + int left_padding = 0; + int right_padding = 0; + int top_padding = 0; + int bottom_padding = 0; + if ( bOutlineEffect || bShadowEffect ) + { + if ( bOutlineEffect ) + left_padding = 1; + + if ( bOutlineEffect ) + { + if ( bShadowEffect ) + right_padding = 2; + else + right_padding = 1; + } + else + { + if ( bShadowEffect ) + right_padding = 2; + else + right_padding = 0; + } + + if ( bOutlineEffect ) + top_padding = 1; + + if ( bOutlineEffect ) + { + if ( bShadowEffect ) + bottom_padding = 2; + else + bottom_padding = 1; + } + else + { + if ( bShadowEffect ) + bottom_padding = 2; + else + bottom_padding = 0; + } + } + else if ( nBlurEffect ) + { + left_padding = nBlurEffect; + right_padding = nBlurEffect; + } + + if ( ValidGlyphs[i] == 2 ) + { + // Handle special characters + // Advance to the next line, if necessary + if ( x + h + left_padding + right_padding >= (int)dwTextureWidth ) + { + x = dwLeftOrigin; + y += h + top_padding + bottom_padding + 1; + } + + sx = x; + sy = y; + + // Draw a square box for a placeholder for custom glyph graphics + w = h + left_padding + right_padding; + h = h + top_padding + bottom_padding; + + abc.abcA = 0; + abc.abcB = w; + abc.abcC = 0; + + RECT rect; + SetRect( &rect, x, y, x+w, y+h ); + SetBkColor( hDC, COLOR_BLACK ); + ExtTextOut( hDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL ); + } + else + { + // Hack to adjust for Kanji + if ( str[0] > 0x1000 ) + { + w = h; + } + + // Advance to the next line, if necessary + if ( x + w + left_padding + right_padding + 1 >= (int)dwTextureWidth ) + { + x = dwLeftOrigin; + y += h + top_padding + bottom_padding + 1; + } + + sx = x; + sy = y; + + // Adjust ccordinates to account for the leading edge + if ( abc.abcA >= 0 ) + x += abc.abcA; + else + sx -= abc.abcA; + + // Hack to adjust for Kanji + if ( str[0] > 0x1000 ) + { + sx += abc.abcA; + } + + // Add padding to the width and height + w += left_padding + right_padding; + h += top_padding + bottom_padding; + abc.abcA -= left_padding; + abc.abcB += left_padding + right_padding; + abc.abcC -= right_padding; + + if ( bOutlineEffect || bShadowEffect ) + { + if ( bOutlineEffect ) + { + SetTextColor( hDC, COLOR_BLACK ); + MoveToEx( hDC, sx+0, sy+0, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL ); + MoveToEx( hDC, sx+1, sy+0, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL ); + MoveToEx( hDC, sx+2, sy+0, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL ); + MoveToEx( hDC, sx+0, sy+1, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL ); + MoveToEx( hDC, sx+2, sy+1, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL ); + MoveToEx( hDC, sx+0, sy+2, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL ); + MoveToEx( hDC, sx+1, sy+2, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL ); + MoveToEx( hDC, sx+2, sy+2, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL ); + + if ( bShadowEffect ) + { + MoveToEx( hDC, sx+3, sy+3, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL ); + } + + // Output the letter + SetTextColor( hDC, COLOR_WHITE ); + MoveToEx( hDC, sx+1, sy+1, NULL ); ExtTextOutW( hDC, sx, sy, ETO_OPAQUE, NULL, str, 1, NULL ); + } + else + { + if ( bShadowEffect ) + { + SetTextColor( hDC, COLOR_BLACK ); + MoveToEx( hDC, sx+2, sy+2, NULL ); ExtTextOutW( hDC, 0, 0, ETO_OPAQUE, NULL, str, 1, NULL ); + } + + // Output the letter + SetTextColor( hDC, COLOR_WHITE ); + MoveToEx( hDC, sx, sy, NULL ); ExtTextOutW( hDC, sx, sy, ETO_OPAQUE, NULL, str, 1, NULL ); + } + } + else if ( nBlurEffect ) + { + // blur effect + SetTextColor( hDC, COLOR_WHITE ); + MoveToEx( hDC, sx + nBlurEffect, sy, NULL ); + ExtTextOutW( hDC, sx, sy, ETO_OPAQUE, NULL, str, 1, NULL ); + + // apply blur effect + unsigned char *pBGRA = GetTextureBits( hBitmap, dwTextureWidth, dwTextureHeight, x, y, w, h ); + if ( pBGRA ) + { + ApplyGaussianBlurToTexture( nBlurEffect, 0, 0, w, h, pBGRA ); + SetTextureBits( hBitmap, dwTextureWidth, dwTextureHeight, x, y, w, h, pBGRA ); + delete [] pBGRA; + } + } + else + { + // normal, no effect + // Output the letter + SetTextColor( hDC, COLOR_WHITE ); + MoveToEx( hDC, sx, sy, NULL ); + ExtTextOutW( hDC, sx, sy, ETO_OPAQUE, NULL, str, 1, NULL ); + } + + // apply scanline effect + if ( nScanlineEffect ) + { + unsigned char *pBGRA = GetTextureBits( hBitmap, dwTextureWidth, dwTextureHeight, x, y, w, h ); + if ( pBGRA ) + { + ApplyScanlineEffectToTexture( nScanlineEffect, 0, 0, w, h, pBGRA ); + SetTextureBits( hBitmap, dwTextureWidth, dwTextureHeight, x, y, w, h, pBGRA ); + delete [] pBGRA; + } + } + + // Hack for extended characters (like Kanji) that don't seem to report + // correct ABC widths. In this case, use the width calculated from + // drawing the glyph. + if( str[0] > 0x1000 ) + { + POINT pos; + GetCurrentPositionEx( hDC, &pos ); + abc.abcB = pos.x - sx; + + if( abc.abcC < 0 ) + abc.abcB -= abc.abcC; + + w = abc.abcB; + } + } + + // Store the glyph attributes + pGlyphs[numGlyphs].x = x; + pGlyphs[numGlyphs].y = y; + pGlyphs[numGlyphs].w = w; + pGlyphs[numGlyphs].h = h; + pGlyphs[numGlyphs].a = abc.abcA; + pGlyphs[numGlyphs].b = abc.abcB; + pGlyphs[numGlyphs].c = abc.abcC; + pGlyphs[numGlyphs].fLeft = ((FLOAT)(x+0)) / dwTextureWidth; + pGlyphs[numGlyphs].fTop = ((FLOAT)(y+0)) / dwTextureHeight; + pGlyphs[numGlyphs].fRight = ((FLOAT)(x+w)) / dwTextureWidth; + pGlyphs[numGlyphs].fBottom = ((FLOAT)(y+h)) / dwTextureHeight; + numGlyphs++; + + // Advance the cursor to the next position + x += w + 1; + } + + SelectClipRgn( hDC, NULL ); + DeleteObject( rgn ); + DeleteDC( hDC ); + + return pGlyphs; +} + +//----------------------------------------------------------------------------- +// Name: RenderCustomGlyphs() +// Desc: Draws the list of font glyphs in the scroll view +//----------------------------------------------------------------------------- +GLYPH_ATTR* CTextureFont::RenderCustomGlyphs( HBITMAP hBitmap ) +{ + int i; + int w; + int h; + byte_t *pTGAPixels; + + m_maxCustomCharHeight = 0; + + // Create a DC + HDC hDC = CreateCompatibleDC( NULL ); + + // Associate the drawing surface + SelectObject( hDC, hBitmap ); + + // Create a clip region + HRGN rgn = CreateRectRgn( 0, 0, m_dwTextureWidth, m_dwTextureHeight ); + SelectClipRgn( hDC, rgn ); + + // clear the background + unsigned char *pBGRA = GetTextureBits( hBitmap, m_dwTextureWidth, m_dwTextureHeight, 0, 0, m_dwTextureWidth, m_dwTextureHeight ); + for (i=0; i<(int)(m_dwTextureHeight*m_dwTextureWidth); i++) + { + pBGRA[i*4+0] = 0xFF; + pBGRA[i*4+1] = 0x00; + pBGRA[i*4+2] = 0x00; + pBGRA[i*4+3] = 0x00; + } + SetTextureBits( hBitmap, m_dwTextureWidth, m_dwTextureHeight, 0, 0, m_dwTextureWidth, m_dwTextureHeight, pBGRA ); + + // build the glyph table + GLYPH_ATTR* pGlyphs = new GLYPH_ATTR[m_dwNumGlyphs]; + memset( pGlyphs, 0, m_dwNumGlyphs*sizeof( GLYPH_ATTR ) ); + + int x = 0; + int y = 0; + int maxHeight = 0; + + for( DWORD i=0; i<m_dwNumGlyphs; i++ ) + { + if ( !i ) + { + // account for null + continue; + } + else if ( TL_Exists( m_pCustomGlyphFiles[i-1] ) ) + { + TL_LoadTGA( m_pCustomGlyphFiles[i-1], &pTGAPixels, &w, &h ); + + // convert to expected order + for (int j=0; j<h*w; j++) + { + int r = pTGAPixels[j*4+0]; + int g = pTGAPixels[j*4+1]; + int b = pTGAPixels[j*4+2]; + + pTGAPixels[j*4+0] = b; + pTGAPixels[j*4+1] = g; + pTGAPixels[j*4+2] = r; + } + } + else + { + // build a "bad" symbol + pTGAPixels = (byte_t*)TL_Malloc( 32*32*4 ); + w = 32; + h = 32; + for (int j=0; j<32*32; j++) + { + pTGAPixels[j*4+0] = 0x00; + pTGAPixels[j*4+1] = 0x00; + pTGAPixels[j*4+2] = 0xFF; + pTGAPixels[j*4+3] = 0xFF; + } + } + + if ( m_maxCustomCharHeight < h ) + { + m_maxCustomCharHeight = h; + } + + if ( maxHeight < h ) + { + maxHeight = h; + } + + if ( x + w > (int)m_dwTextureWidth ) + { + // skip to new row + y += maxHeight; + x = 0; + maxHeight = h; + } + + SetTextureBits( hBitmap, m_dwTextureWidth, m_dwTextureHeight, x, y, w, h, pTGAPixels ); + TL_Free( pTGAPixels ); + + // Store the glyph attributes + pGlyphs[i].x = x; + pGlyphs[i].y = y; + pGlyphs[i].w = w; + pGlyphs[i].h = h; + pGlyphs[i].a = 0; + pGlyphs[i].b = w; + pGlyphs[i].c = 0; + pGlyphs[i].fLeft = ((FLOAT)(x+0)) / m_dwTextureWidth; + pGlyphs[i].fTop = ((FLOAT)(y+0)) / m_dwTextureHeight; + pGlyphs[i].fRight = ((FLOAT)(x+w)) / m_dwTextureWidth; + pGlyphs[i].fBottom = ((FLOAT)(y+h)) / m_dwTextureHeight; + + x += w; + } + + SelectClipRgn( hDC, NULL ); + DeleteObject( rgn ); + DeleteDC( hDC ); + delete [] pBGRA; + + return pGlyphs; +} + +//----------------------------------------------------------------------------- +// Name: CalculateAndRenderGlyphs() +// Desc: Draws the list of font glyphs +//----------------------------------------------------------------------------- +HRESULT CTextureFont::CalculateAndRenderGlyphs() +{ + // Create a bitmap + HBITMAP hBitmap = CreateBitmap( m_dwTextureWidth, m_dwTextureHeight, 1, 32, NULL ); + + if ( m_pGlyphs ) + delete[] m_pGlyphs; + + if ( m_pCustomFilename ) + { + m_pGlyphs = RenderCustomGlyphs( hBitmap ); + } + else + { + // Create a font + if ( m_hFont ) + { + DeleteObject( m_hFont ); + } + + if ( m_bAntialiasEffect ) + { + m_LogFont.lfQuality = ANTIALIASED_QUALITY; + } + else + { + m_LogFont.lfQuality = NONANTIALIASED_QUALITY; + } + + m_hFont = CreateFontIndirect( &m_LogFont ); + + m_pGlyphs = RenderTTFGlyphs( + m_hFont, + hBitmap, + m_dwTextureWidth, + m_dwTextureHeight, + m_bOutlineEffect, + m_bShadowEffect, + m_nScanlines, + m_nBlur, + m_bAntialiasEffect, + m_ValidGlyphs, + m_dwNumGlyphs ); + } + + // Store the resulting bits + if ( m_pBits ) + delete[] m_pBits; + m_pBits = new DWORD[ m_dwTextureWidth * m_dwTextureHeight ]; + + GetBitmapBits2( hBitmap, m_dwTextureWidth, m_dwTextureHeight, m_pBits ); + + DeleteObject( hBitmap ); + + return S_OK; +} diff --git a/utils/xbox/FontMaker/glyphs.h b/utils/xbox/FontMaker/glyphs.h new file mode 100644 index 0000000..7aaa117 --- /dev/null +++ b/utils/xbox/FontMaker/glyphs.h @@ -0,0 +1,104 @@ +//----------------------------------------------------------------------------- +// Name: Glyphs.cpp +// +// Desc: Functions and global variables for keeping track of font glyphs +// +// Hist: 09.06.02 - Revised Fontmaker sample +// +// Copyright (c) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- +#ifndef GLYPHS_H +#define GLYPHS_H + +//----------------------------------------------------------------------------- +// Name: struct GLYPH_ATTR +// Desc: A structure to hold attributes for one glpyh. The left, right, etc. +// values are texture coordinate offsets into the resulting texture image +// (which ends up in the .tga file). The offset, width, etc. values are +// spacing information, used when rendering the font. +//----------------------------------------------------------------------------- +struct FILE_GLYPH_ATTR +{ + FLOAT fLeft, fTop, fRight, fBottom; +}; + +struct GLYPH_ATTR : public FILE_GLYPH_ATTR +{ + int a, b, c; + int x, y, w, h; +}; + + + + +//----------------------------------------------------------------------------- +// Name: class CTextureFont +// Desc: A class to hold all information about a texture-based font +//----------------------------------------------------------------------------- +class CTextureFont +{ +public: + // current ttf font + LOGFONT m_LogFont; + HFONT m_hFont; + + BOOL m_bAntialiasEffect; + BOOL m_bShadowEffect; + BOOL m_bOutlineEffect; + int m_nBlur; + int m_nScanlines; + + // Glyph info + BYTE* m_ValidGlyphs; + WCHAR m_cMaxGlyph; + WORD* m_TranslatorTable; + BOOL m_bIncludeNullCharacter; + DWORD m_dwNumGlyphs; + GLYPH_ATTR* m_pGlyphs; + + // Texture info + DWORD m_dwTextureWidth; + DWORD m_dwTextureHeight; + DWORD* m_pBits; + + CHAR m_strFontName[MAX_PATH]; + + // current custom font + const char *m_pCustomFilename; + unsigned char m_customGlyphs[256]; + char *m_pCustomGlyphFiles[256]; + int m_maxCustomCharHeight; + +public: + HRESULT DeleteGlyph( WORD wGlyph ); + HRESULT InsertGlyph( WORD wGlyph ); + HRESULT ExtractValidGlyphsFromRange( WORD wStartGlyph, WORD wEndGlyph ); + HRESULT ExtractValidGlyphsFromFile( const CHAR* strFileName ); + HRESULT BuildTranslatorTable(); + HRESULT CalculateAndRenderGlyphs(); + HRESULT ReadCustomFontFile( CHAR* strFileName ); + HRESULT ReadFontInfoFile( CHAR* strFileName ); + HRESULT WriteFontInfoFile( CHAR* strFileName ); + HRESULT WriteFontImageFile( CHAR* strFileName, bool bAdditiveMode, bool bCustomFont ); + + VOID ClearFont(); + VOID DestroyObjects(); + + CTextureFont(); + ~CTextureFont(); + +private: + GLYPH_ATTR* RenderCustomGlyphs( HBITMAP hBitmap ); + + GLYPH_ATTR* RenderTTFGlyphs( HFONT hFont, HBITMAP hBitmap, + DWORD dwTextureWidth, DWORD dwTextureHeight, + BOOL bOutlineEffect, BOOL bShadowEffect, + int nScanlineEffect, int nBlurEffect, + BOOL bAntialias, + BYTE* ValidGlyphs, DWORD dwNumGlyphs ); +}; + + + + +#endif // GLYPHS_H diff --git a/utils/xbox/FontMaker/resource.h b/utils/xbox/FontMaker/resource.h new file mode 100644 index 0000000..d8b7060 --- /dev/null +++ b/utils/xbox/FontMaker/resource.h @@ -0,0 +1,80 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by fontmaker.rc +// +#define IDD_DIALOGBAR 103 +#define IDD_TEXTURESIZE 104 +#define IDR_MAINFRAME 128 +#define IDD_ABOUT 132 +#define IDC_GLYPHSFROMRANGE_RADIO 1007 +#define IDC_GLYPHSFROMFILE_RADIO 1008 +#define IDC_GLYPHSFILE_EDIT 1009 +#define IDC_GLYPHSFILESELECTOR_BUTTON 1010 +#define IDC_GLYPHSRANGEFROM_EDIT 1011 +#define IDC_GLYPHSRANGETO_EDIT 1012 +#define IDC_EFFECTSOUTLINED_CHECK 1013 +#define IDC_EFFECTSSHADOWED_CHECK 1014 +#define IDC_EFFECTSBLURRED_CHECK 1015 +#define IDC_EFFECTSSCANLINES_CHECK 1016 +#define IDC_BLUR_EDIT 1017 +#define IDC_SCANLINES_EDIT 1018 +#define IDC_EFFECTSANTIALIAS_CHECK 1019 +#define IDC_GLYPHSCUSTOM_RADIO 1020 +#define IDC_INSERTGLYPH_EDIT 1021 +#define IDC_GLYPH_SPECIAL 1024 +#define IDC_TEXTURESIZE_BUTTON 1026 +#define IDC_FONTNAME_STATIC 1030 +#define IDC_FONT_GROUPBOX 1031 +#define IDC_GLYPHS_GROUPBOX 1032 +#define IDC_FONTSTYLE_STATIC 1033 +#define IDC_FONTSIZE_STATIC 1034 +#define IDC_TEXTUREWIDTH_STATIC 1035 +#define IDC_TEXTURE_GROUPBOX 1036 +#define IDC_SELECTEDGLYPH_GROUPBOX 1037 +#define IDC_FONTNAME_LABEL 1038 +#define IDC_FONTSTYLE_LABEL 1039 +#define IDC_FONTSIZE_LABEL 1040 +#define IDC_INSERTGLYPH_LABEL 1041 +#define IDC_TEXTUREHEIGHT_LABEL 1042 +#define IDC_TEXTUREHEIGHT_STATIC 1043 +#define IDC_GLYPHSRANGEFROM_LABEL 1044 +#define IDC_GLYPHSRANGETO_LABEL 1045 +#define IDC_WIDTH 1046 +#define IDC_GLYPH_X_STATIC 1046 +#define IDC_TEXTUREWIDTH_LABEL 1047 +#define IDC_HEIGHT 1048 +#define IDC_GLYPH_X_LABEL 1048 +#define IDC_GLYPH_Y_LABEL 1049 +#define IDC_GLYPH_W_LABEL 1050 +#define IDC_GLYPH_H_LABEL 1051 +#define IDC_GLYPH_A_LABEL 1052 +#define IDC_GLYPH_B_LABEL 1053 +#define IDC_GLYPH_C_LABEL 1054 +#define IDC_MAGNIFY_BUTTON 1055 +#define IDC_GLYPH_VALUE_LABEL 1056 +#define IDC_USENTSCSAFECOLORS_CHECK 1057 +#define IDC_GLYPH_Y_STATIC 1061 +#define IDC_GLYPH_W_STATIC 1062 +#define IDC_GLYPH_H_STATIC 1063 +#define IDC_GLYPH_A_STATIC 1064 +#define IDC_GLYPH_B_STATIC 1065 +#define IDC_GLYPH_C_STATIC 1066 +#define IDC_GLYPH_VALUE_STATIC 1067 +#define IDM_FILE_EXIT 32778 +#define IDM_FILE_NEWFONT 32782 +#define IDM_FILE_SAVEFONTFILES 32784 +#define ID_FILE_LOADFONTFILE 32788 +#define IDM_FILE_LOADFONTFILE 32790 +#define IDM_FILE_LOADFONTLAYOUT 32792 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_3D_CONTROLS 1 +#define _APS_NEXT_RESOURCE_VALUE 133 +#define _APS_NEXT_COMMAND_VALUE 32793 +#define _APS_NEXT_CONTROL_VALUE 1058 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/utils/xbox/FontMaker/stdafx.cpp b/utils/xbox/FontMaker/stdafx.cpp new file mode 100644 index 0000000..0087258 --- /dev/null +++ b/utils/xbox/FontMaker/stdafx.cpp @@ -0,0 +1,8 @@ +// stdafx.cpp : source file that includes just the standard includes +// FontMaker.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + + + diff --git a/utils/xbox/FontMaker/stdafx.h b/utils/xbox/FontMaker/stdafx.h new file mode 100644 index 0000000..b57f9d4 --- /dev/null +++ b/utils/xbox/FontMaker/stdafx.h @@ -0,0 +1,27 @@ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#if !defined(AFX_STDAFX_H__797D2B31_3C16_4BE2_8C81_8C3E74DC9138__INCLUDED_) +#define AFX_STDAFX_H__797D2B31_3C16_4BE2_8C81_8C3E74DC9138__INCLUDED_ + +#if _MSC_VER > 1000 +#pragma once +#endif // _MSC_VER > 1000 + +#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers + +#include "tier0\wchartypes.h" +#include <afxwin.h> // MFC core and standard components +#include <afxext.h> // MFC extensions +#include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls +#ifndef _AFX_NO_AFXCMN_SUPPORT +#include <afxcmn.h> // MFC support for Windows Common Controls +#endif // _AFX_NO_AFXCMN_SUPPORT + + +//{{AFX_INSERT_LOCATION}} +// Microsoft Visual C++ will insert additional declarations immediately before the previous line. + +#endif // !defined(AFX_STDAFX_H__797D2B31_3C16_4BE2_8C81_8C3E74DC9138__INCLUDED_) diff --git a/utils/xbox/MakeGameData/MakeGameData.cpp b/utils/xbox/MakeGameData/MakeGameData.cpp new file mode 100644 index 0000000..91857b1 --- /dev/null +++ b/utils/xbox/MakeGameData/MakeGameData.cpp @@ -0,0 +1,1174 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Generates a file list based on command line wildcard spec and drives +// conversion routines based on file extension. The conversion routines should be +// !!!elsewhere!!! in libraries that the game also uses at runtime to convert data. +// This tool as spec'd should just be file iteration. +// +//=====================================================================================// + +#include "MakeGameData.h" + +// MAKESCENESIMAGE is defined for the external tool. In general, it only +// supports the -pcscenes option. This gets built into MakeScenesImage.exe. + +//----------------------------------------------------------------------------- +// The application object +//----------------------------------------------------------------------------- +class MakeGameDataApp : public CDefaultAppSystemGroup< CSteamAppSystemGroup > +{ +public: + // Methods of IApplication + virtual bool Create(); + virtual bool PreInit( ); + virtual int Main(); + virtual void PostShutdown(); +}; + +DEFINE_CONSOLE_STEAM_APPLICATION_OBJECT( MakeGameDataApp ); + +char g_szSourcePath[MAX_PATH]; +char g_targetPath[MAX_PATH]; +char g_zipPath[MAX_PATH]; +bool g_bForce; +bool g_bTest; +bool g_bMakeZip; +CXZipTool g_MasterXZip; +DiskWriteMode_t g_WriteModeForConversions; +char g_szGamePath[MAX_PATH]; +char g_szModPath[MAX_PATH]; +bool g_bModPathIsValid; +bool g_bQuiet; +bool g_bMakeScenes; +bool g_bMakeScenesPC; +bool g_bIsPlatformZip; +bool g_bUseMapList; + +IPhysicsCollision *g_pPhysicsCollision; +CSysModule *g_pPhysicsModule; + +CUtlVector< CUtlString > g_ValidMapList; +CUtlVector< errorList_t > g_errorList; + +const char *g_GameNames[] = +{ + "ep2", + "episodic", + "hl2", + "portal", + "platform", + "tf", + NULL +}; + +// all known languages +const char *g_pLanguageSuffixes[] = +{ + "_dannish", + "_dutch", + "_english", + "_finnish", + "_french", + "_german", + "_italian", + "_japanese", + "_korean", + "_koreana", + "_norwegian", + "_polish", + "_portuguese", + "_russian", + "_russion_buka", + "_schinese", + "_spanish", + "_swedish", + "_tchinese", + "_thai", +}; + +// 360 is shipping with support for only these languages +const char *g_pTargetLanguageSuffixes[] = +{ + "_english.", + "_french.", + "_german.", +}; + +// Master list of files that can go into the zip +static char *s_AllowedExtensionsInZip[] = +{ + // Explicitly lacking from this list, thus excluded from the zip + // .ain - AINs are external to the zip + // .bsp - BSPs are external to the zip + // .mp3 - MP3s aren't supported + + // Extensions with conversions + // Purposely using .360 encoding to ensure pc versions don't leak in + ".360.wav", + ".360.vtf", + ".360.mdl", + ".360.ani", + ".dx90.360.vtx", + ".360.vvd", + ".360.phy", + ".360.dat", + ".360.lst", + ".360.vcs", + ".360.image", + ".360.pcf", + + // Extensions without conversions (taken as is) + ".rc", + ".txt", + ".cfg", + ".res", + ".vfe", + ".vbf", + ".vmt", + ".raw", + ".lst", + ".bns", +}; + + + +//----------------------------------------------------------------------------- +// Determine game path +//----------------------------------------------------------------------------- +void GetGamePath() +{ + GetCurrentDirectory( sizeof( g_szGamePath ), g_szGamePath ); + + char szFullPath[MAX_PATH]; + if ( _fullpath( szFullPath, g_szGamePath, sizeof( szFullPath ) ) ) + { + strcpy( g_szGamePath, szFullPath ); + } + V_AppendSlash( g_szGamePath, sizeof( g_szGamePath ) ); + + char *pGameDir = V_stristr( g_szGamePath, "game\\" ); + if ( !pGameDir ) + { + Msg( "ERROR: Failed to determine game directory from current path. Expecting 'game' in current path." ); + exit( 1 ); + } + + // kill any trailing dirs + pGameDir[4] = '\0'; +} + +//----------------------------------------------------------------------------- +// Determine mod path +//----------------------------------------------------------------------------- +bool GetModPath() +{ + char szDirectory[MAX_PATH]; + char szLastDirectory[MAX_PATH]; + + // non destructively determine the mod directory + bool bFound = false; + szLastDirectory[0] = '\0'; + GetCurrentDirectory( sizeof( szDirectory ), szDirectory ); + while ( 1 ) + { + V_ComposeFileName( szDirectory, "gameinfo.txt", g_szModPath, sizeof( g_szModPath ) ); + struct _stat statBuf; + if ( _stat( g_szModPath, &statBuf ) != -1 ) + { + bFound = true; + V_strncpy( g_szModPath, szDirectory, sizeof( g_szModPath ) ); + break; + } + + // previous dir + V_ComposeFileName( szDirectory, "..", g_szModPath, sizeof( g_szModPath ) ); + + char fullPath[MAX_PATH]; + if ( _fullpath( fullPath, g_szModPath, sizeof( fullPath ) ) ) + { + strcpy( szDirectory, fullPath ); + } + + if ( !V_stricmp( szDirectory, szLastDirectory ) ) + { + // can back up no further + break; + } + strcpy( szLastDirectory, szDirectory ); + } + + if ( !bFound ) + { + // use current directory instead + GetCurrentDirectory( sizeof( g_szModPath ), g_szModPath ); + } + + return bFound; +} + +//----------------------------------------------------------------------------- +// Setup File system and search paths +//----------------------------------------------------------------------------- +bool SetupFileSystem() +{ + if ( g_bModPathIsValid ) + { + CFSSteamSetupInfo steamInfo; + steamInfo.m_pDirectoryName = g_szModPath; + steamInfo.m_bOnlyUseDirectoryName = true; + steamInfo.m_bToolsMode = true; + steamInfo.m_bSetSteamDLLPath = true; + steamInfo.m_bSteam = false; + if ( FileSystem_SetupSteamEnvironment( steamInfo ) != FS_OK ) + return false; + + CFSMountContentInfo fsInfo; + fsInfo.m_pFileSystem = g_pFullFileSystem; + fsInfo.m_bToolsMode = true; + fsInfo.m_pDirectoryName = steamInfo.m_GameInfoPath; + if ( FileSystem_MountContent( fsInfo ) != FS_OK ) + return false; + + // Finally, load the search paths for the "GAME" path. + CFSSearchPathsInit searchPathsInit; + searchPathsInit.m_pDirectoryName = steamInfo.m_GameInfoPath; + searchPathsInit.m_pFileSystem = fsInfo.m_pFileSystem; + if ( FileSystem_LoadSearchPaths( searchPathsInit ) != FS_OK ) + return false; + + char platform[MAX_PATH]; + Q_strncpy( platform, steamInfo.m_GameInfoPath, MAX_PATH ); + Q_StripTrailingSlash( platform ); + Q_strncat( platform, "/../platform", MAX_PATH, MAX_PATH ); + fsInfo.m_pFileSystem->AddSearchPath( platform, "PLATFORM" ); + } + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Helper utility, read file into buffer +//----------------------------------------------------------------------------- +bool ReadFileToBuffer( const char *pSourceName, CUtlBuffer &buffer, bool bText, bool bNoOpenFailureWarning ) +{ + return scriptlib->ReadFileToBuffer( pSourceName, buffer, bText, bNoOpenFailureWarning ); +} + +//----------------------------------------------------------------------------- +// Purpose: Helper utility, Write buffer to file +//----------------------------------------------------------------------------- +bool WriteBufferToFile( const char *pTargetName, CUtlBuffer &buffer, bool bWriteToZip, DiskWriteMode_t writeMode ) +{ + if ( g_bTest ) + return true; + + bool bSuccess = scriptlib->WriteBufferToFile( pTargetName, buffer, writeMode ); + bool bZipSuccess = true; + + if ( bSuccess && g_bMakeZip && !g_bTest && bWriteToZip ) + { + if ( !g_MasterXZip.AddBuffer( pTargetName, buffer, true ) ) + { + Msg( "WriteBufferToFile(): Error adding file %s\n", pTargetName ); + bZipSuccess = false; + } + } + + return bSuccess && bZipSuccess; +} + +//----------------------------------------------------------------------------- +// Compress data +//----------------------------------------------------------------------------- +bool CompressCallback( CUtlBuffer &inputBuffer, CUtlBuffer &outputBuffer ) +{ + if ( !inputBuffer.TellPut() ) + { + // nothing to do + return false; + } + + unsigned int compressedSize; + unsigned char *pCompressedOutput = LZMA_OpportunisticCompress( (unsigned char *)inputBuffer.Base() + inputBuffer.TellGet(), inputBuffer.TellPut() - inputBuffer.TellGet(), &compressedSize ); + if ( pCompressedOutput ) + { + outputBuffer.EnsureCapacity( compressedSize ); + outputBuffer.Put( pCompressedOutput, compressedSize ); + free( pCompressedOutput ); + return true; + } + + return false; +} + + + +//----------------------------------------------------------------------------- +// Some converters need to run a final pass. +//----------------------------------------------------------------------------- +void DoPostProcessingFunctions( bool bWriteToZip ) +{ + if ( g_bMakeScenes || g_bMakeScenesPC ) + { + // scenes are converted and aggregated into one image + CreateSceneImageFile( g_szModPath, bWriteToZip, g_bMakeScenesPC, g_bQuiet, g_WriteModeForConversions ); + } + + ProcessDXSupportConfig( bWriteToZip ); +} + +//----------------------------------------------------------------------------- +// Startup any conversion modules. +//----------------------------------------------------------------------------- +bool InitConversionModules() +{ + return true; +} + +//----------------------------------------------------------------------------- +// Shutdown and cleanup any conversion modules. +//----------------------------------------------------------------------------- +void ShutdownConversionModules() +{ +} + +//----------------------------------------------------------------------------- +// Purpose: Distribute to worker function +//----------------------------------------------------------------------------- +bool CreateTargetFile( const char *pSourceName, const char *pTargetName, fileType_e fileType, bool bWriteToZip ) +{ + // resolve relative source to absolute path + // same workers use subdir name to determine conversion parameters + char fullSourcePath[MAX_PATH]; + if ( _fullpath( fullSourcePath, pSourceName, sizeof( fullSourcePath ) ) ) + { + pSourceName = fullSourcePath; + } + + // distribute to actual worker + // workers can expect exact final decorated filenames + bool bSuccess = false; + switch ( fileType ) + { + case FILETYPE_UNKNOWN: + break; + + case FILETYPE_VTF: + bSuccess = CreateTargetFile_VTF( pSourceName, pTargetName, bWriteToZip ); + break; + + case FILETYPE_WAV: + bSuccess = CreateTargetFile_WAV( pSourceName, pTargetName, bWriteToZip ); + break; + + case FILETYPE_MDL: + case FILETYPE_ANI: + case FILETYPE_VTX: + case FILETYPE_VVD: + case FILETYPE_PHY: + bSuccess = CreateTargetFile_Model( pSourceName, pTargetName, bWriteToZip ); + break; + + case FILETYPE_BSP: + bSuccess = CreateTargetFile_BSP( pSourceName, pTargetName, bWriteToZip ); + break; + + case FILETYPE_AIN: + bSuccess = CreateTargetFile_AIN( pSourceName, pTargetName, bWriteToZip ); + break; + + case FILETYPE_CCDAT: + bSuccess = CreateTargetFile_CCDAT( pSourceName, pTargetName, bWriteToZip ); + break; + + case FILETYPE_MP3: + bSuccess = CreateTargetFile_MP3( pSourceName, pTargetName, bWriteToZip ); + break; + + case FILETYPE_RESLST: + bSuccess = CreateTargetFile_RESLST( pSourceName, pTargetName, bWriteToZip ); + break; + + case FILETYPE_PCF: + bSuccess = CreateTargetFile_PCF( pSourceName, pTargetName, bWriteToZip ); + break; + + // others... + } + + return bSuccess; +} + +//----------------------------------------------------------------------------- +// Purpose: Determine file type based on source extension. Generate .360.xxx +// target name. +//----------------------------------------------------------------------------- +fileType_e ResolveFileType( const char *pSourceName, char *pTargetName, int targetNameSize ) +{ + char szFullSourcePath[MAX_PATH]; + _fullpath( szFullSourcePath, pSourceName, sizeof( szFullSourcePath ) ); + + char sourceExtension[MAX_PATH]; + V_ExtractFileExtension( pSourceName, sourceExtension, sizeof( sourceExtension ) ); + + // default unrecognized + fileType_e fileType = FILETYPE_UNKNOWN; + + if ( !V_stricmp( sourceExtension, "wav" ) ) + { + fileType = FILETYPE_WAV; + } + else if ( !V_stricmp( sourceExtension, "vtf" ) ) + { + fileType = FILETYPE_VTF; + } + else if ( !V_stricmp( sourceExtension, "mdl" ) ) + { + fileType = FILETYPE_MDL; + } + else if ( !V_stricmp( sourceExtension, "ani" ) ) + { + fileType = FILETYPE_ANI; + } + else if ( !V_stricmp( sourceExtension, "vvd" ) ) + { + fileType = FILETYPE_VVD; + } + else if ( !V_stricmp( sourceExtension, "phy" ) ) + { + fileType = FILETYPE_PHY; + } + else if ( !V_stricmp( sourceExtension, "bsp" ) ) + { + fileType = FILETYPE_BSP; + } + else if ( !V_stricmp( sourceExtension, "ain" ) ) + { + fileType = FILETYPE_AIN; + } + else if ( !V_stricmp( sourceExtension, "dat" ) ) + { + if ( V_stristr( pSourceName, "closecaption_" ) ) + { + // only want closecaption dat files, ignore all others + fileType = FILETYPE_CCDAT; + } + } + else if ( !V_stricmp( sourceExtension, "vtx" ) ) + { + if ( V_stristr( pSourceName, ".dx90" ) ) + { + // only want dx90 version, ignore all others + fileType = FILETYPE_VTX; + } + } + else if ( !V_stricmp( sourceExtension, "mp3" ) ) + { + // mp3's are already pre-converted into .360.wav + // slam the expected name here to simplify the external logic which will do the right thing + V_StripExtension( pSourceName, pTargetName, targetNameSize ); + V_strcat( pTargetName, ".360.wav", targetNameSize ); + return FILETYPE_MP3; + } + else if ( !V_stricmp( sourceExtension, "lst" ) ) + { + if ( V_stristr( szFullSourcePath, "reslists_xbox\\" ) ) + { + // only want reslists map versions, due to special processing, ignore all others + fileType = FILETYPE_RESLST; + } + } + else if ( !V_stricmp( sourceExtension, "pcf" ) ) + { + fileType = FILETYPE_PCF; + } + else if ( !V_stricmp( sourceExtension, "image" ) ) + { + if ( V_stristr( szFullSourcePath, "scenes\\" ) ) + { + // only want scene image, ignore all others + fileType = FILETYPE_SCENEIMAGE; + } + } + + if ( fileType != FILETYPE_UNKNOWN && !V_stristr( pSourceName, ".360." ) ) + { + char targetExtension[MAX_PATH]; + sprintf( targetExtension, ".360.%s", sourceExtension ); + + V_StripExtension( pSourceName, pTargetName, targetNameSize ); + V_strcat( pTargetName, targetExtension, targetNameSize ); + } + else + { + // unknown or already converted, target is same as input + V_strncpy( pTargetName, pSourceName, targetNameSize ); + } + + return fileType; +} + +//----------------------------------------------------------------------------- +// Purpose: Returns TRUE if file is a known localized file. +//----------------------------------------------------------------------------- +bool IsLocalizedFile( const char *pFileName ) +{ + for ( int i = 0; i<ARRAYSIZE( g_pLanguageSuffixes ); i++ ) + { + if ( V_stristr( pFileName, g_pLanguageSuffixes[i] ) ) + { + // a localized file + return true; + } + } + + // not a known localized file + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Returns TRUE if file is a supported localization. +//----------------------------------------------------------------------------- +bool IsLocalizedFileValid( const char *pFileName, const char *pLanguageSuffix ) +{ + // file is a localized version + if ( pLanguageSuffix ) + { + if ( V_stristr( pFileName, pLanguageSuffix ) ) + { + // allow it + return true; + } + + return false; + } + + // must match the target supported languages + for ( int i = 0; i < ARRAYSIZE( g_pTargetLanguageSuffixes ); i++ ) + { + if ( V_stristr( pFileName, g_pTargetLanguageSuffixes[i] ) ) + { + // allow it + return true; + } + } + + // does not match a target language, not allowed + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Check against a list of allowed filetypes for inclusion in the zip +//----------------------------------------------------------------------------- +bool IncludeInZip( const char *pSourceName ) +{ + if ( g_bIsPlatformZip ) + { + // only allow known valid platform directories + if ( !V_stristr( pSourceName, "materials\\" ) && + !V_stristr( pSourceName, "resource\\" ) && + !V_stristr( pSourceName, "vgui\\" ) ) + { + // exclude it + return false; + } + } + + for ( int i = 0; i < ARRAYSIZE( s_AllowedExtensionsInZip ); ++i ) + { + const char *pAllowedExtension = s_AllowedExtensionsInZip[i]; + if ( !V_stristr( pSourceName, pAllowedExtension ) ) + { + continue; + } + + if ( !V_stricmp( pAllowedExtension, ".lst" ) ) + { + // only want ???_exclude.lst files + if ( V_stristr( pSourceName, "_exclude.lst" ) ) + { + return true; + } + return false; + } + + if ( !V_stricmp( pAllowedExtension, ".txt" ) || !V_stricmp( pAllowedExtension, ".360.dat" ) ) + { + if ( IsLocalizedFile( pSourceName ) && !IsLocalizedFileValid( pSourceName ) ) + { + // exclude unsupported languages + return false; + } + + if ( !V_stricmp( pAllowedExtension, ".txt" ) && V_stristr( pSourceName, "closecaption_" ) ) + { + // exclude all the closecaption_<language>.txt files + return false; + } + } + + return true; + } + + // exclude it + return false; +} + +//----------------------------------------------------------------------------- +// Returns true if map is in list, otherwise false +//----------------------------------------------------------------------------- +bool IsMapNameInList( const char *pMapName, CUtlVector< CUtlString > &mapList ) +{ + char szBaseName[MAX_PATH]; + + V_FileBase( pMapName, szBaseName, sizeof( szBaseName ) ); + V_strlower( szBaseName ); + + if ( mapList.Find( szBaseName ) != mapList.InvalidIndex() ) + { + // found + return true; + } + + // not found + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Get the list of valid BSPs +//----------------------------------------------------------------------------- +void BuildValidMapList( CUtlVector< CUtlString > &mapList ) +{ + char szFilename[MAX_PATH]; + V_ComposeFileName( g_szModPath, "maplist.txt", szFilename, sizeof( szFilename ) ); + + CUtlBuffer buffer; + if ( !ReadFileToBuffer( szFilename, buffer, true, true ) ) + { + return; + } + + characterset_t breakSet; + CharacterSetBuild( &breakSet, "" ); + + char szToken[MAX_PATH]; + char szMapName[MAX_PATH]; + for ( ;; ) + { + int nTokenSize = buffer.ParseToken( &breakSet, szToken, sizeof( szToken ) ); + if ( nTokenSize <= 0 ) + { + break; + } + + // reslists are pc built, filenames can be sloppy + V_FileBase( szToken, szMapName, sizeof( szMapName ) ); + V_strlower( szMapName ); + + mapList.AddToTail( szMapName ); + } +} + +#define DO_UPDATE 0x01 +#define DO_ZIP 0x02 + +//----------------------------------------------------------------------------- +// Purpose: drive the file creation +//----------------------------------------------------------------------------- +void GenerateTargetFiles( CUtlVector<fileList_t> &fileList ) +{ + char sourcePath[MAX_PATH]; + char sourceFile[MAX_PATH]; + char targetFile[MAX_PATH]; + struct _stat sourceStatBuf; + struct _stat targetStatBuf; + + strcpy( sourcePath, g_szSourcePath ); + V_StripFilename( sourcePath ); + if ( !sourcePath[0] ) + strcpy( sourcePath, "." ); + V_AppendSlash( sourcePath, sizeof( sourcePath ) ); + + // default is to update and zip + CUtlVector< int > updateList; + updateList.AddMultipleToTail( fileList.Count() ); + for ( int i=0; i<fileList.Count(); i++ ) + { + updateList[i] = DO_UPDATE|DO_ZIP; + } + int numMatches = 0; + + // build update list + for ( int i=0; i<fileList.Count(); i++ ) + { + if ( fileList[i].fileName.IsEmpty() ) + { + // ignore entries that have been culled + updateList[i] = 0; + continue; + } + + const char *ptr = fileList[i].fileName.String(); + if ( !strnicmp( ptr, ".\\", 2 ) ) + ptr += 2; + else if ( !strnicmp( ptr, sourcePath, strlen( sourcePath ) ) ) + ptr += strlen( sourcePath ); + + strcpy( sourceFile, sourcePath ); + strcat( sourceFile, ptr ); + strcpy( targetFile, g_targetPath ); + strcat( targetFile, ptr ); + + fileType_e fileType = ResolveFileType( sourceFile, targetFile, sizeof( targetFile ) ); + + // check the target name for inclusion due to extension modifications + if ( !IncludeInZip( targetFile ) ) + { + // exclude from zip + updateList[i] &= ~DO_ZIP; + } + + if ( fileType == FILETYPE_UNKNOWN ) + { + // No conversion function, can't do anything + updateList[i] &= ~DO_UPDATE; + continue; + } + else + { + // known filetype, which has a conversion + // the wildcard match may catch existing converted files, which need to be rejected + // cull exisiting conversions from the work list + // the non-converted filename is part of the same wildcard match, gets caught and resolved + // the non-converted filename will then go through the proper conversion path + if ( V_stristr( sourceFile, ".360." ) ) + { + // cull completely + updateList[i] = 0; + continue; + } + } + + if ( fileType == FILETYPE_BSP || fileType == FILETYPE_AIN || fileType == FILETYPE_RESLST ) + { + if ( g_ValidMapList.Count() && !IsMapNameInList( sourceFile, g_ValidMapList ) ) + { + // cull completely + updateList[i] = 0; + continue; + } + } + + int retVal = _stat( sourceFile, &sourceStatBuf ); + if ( retVal != 0 ) + { + // couldn't get source, skip update or zip + updateList[i] = 0; + continue; + } + + retVal = _stat( targetFile, &targetStatBuf ); + if ( retVal != 0 ) + { + // target doesn't exit, update is required + continue; + } + + // track valid candidates + numMatches++; + + if ( fileType == FILETYPE_MDL || fileType == FILETYPE_ANI || fileType == FILETYPE_VTX || fileType == FILETYPE_VVD || fileType == FILETYPE_PHY ) + { + // models are converted in a pre-pass + // let the update logic run and catch the conversions for zipping + continue; + } + + if ( !g_bForce ) + { + if ( difftime( sourceStatBuf.st_mtime, targetStatBuf.st_mtime ) <= 0 ) + { + // target is same or older, no update + updateList[i] &= ~DO_UPDATE; + } + } + } + + // cleanse and determine totals, makes succeeding logic simpler + int numWorkItems = 0; + int numFilesToUpdate = 0; + int numFilesToZip = 0; + for ( int i=0; i<fileList.Count(); i++ ) + { + if ( updateList[i] & DO_UPDATE ) + { + numFilesToUpdate++; + } + if ( g_bMakeZip && ( updateList[i] & DO_ZIP ) ) + { + numFilesToZip++; + } + else + { + updateList[i] &= ~DO_ZIP; + } + if ( updateList[i] ) + { + numWorkItems++; + } + } + + Msg( "\n" ); + Msg( "Matched %d/%d files.\n", numMatches, fileList.Count() ); + Msg( "Creating or Updating %d files.\n", numFilesToUpdate ); + if ( g_bMakeZip ) + { + Msg( "Zipping %d files.\n", numFilesToZip ); + } + + InitConversionModules(); + + if ( numFilesToZip && !g_bTest ) + { + Msg( "Creating Zip: %s\n", g_zipPath ); + if ( !g_MasterXZip.Begin( g_zipPath, XBOX_DVD_SECTORSIZE ) ) + { + Msg( "ERROR: Failed to open \"%s\" for writing.\n", g_zipPath ); + return; + } + else + { + SetupCriticalPreloadScript( g_szModPath ); + } + } + + // iterate work list + int progress = 0; + for ( int i=0; i<fileList.Count(); i++ ) + { + if ( !updateList[i] ) + { + // no update or zip needed, skip + continue; + } + + const char *ptr = fileList[i].fileName.String(); + if ( !strnicmp( ptr, ".\\", 2 ) ) + ptr += 2; + else if ( !strnicmp( ptr, sourcePath, strlen( sourcePath ) ) ) + ptr += strlen( sourcePath ); + + strcpy( sourceFile, sourcePath ); + strcat( sourceFile, ptr ); + strcpy( targetFile, g_targetPath ); + strcat( targetFile, ptr ); + + fileType_e fileType = ResolveFileType( sourceFile, targetFile, sizeof( targetFile ) ); + + if ( !g_bQuiet ) + { + Msg( "%d/%d:%s -> %s\n", progress+1, numWorkItems, sourceFile, targetFile ); + } + + bool bSuccess = true; + if ( updateList[i] & DO_UPDATE ) + { + // generate target file (and optionally zip output) + bSuccess = CreateTargetFile( sourceFile, targetFile, fileType, (updateList[i] & DO_ZIP) != 0 ); + if ( !bSuccess ) + { + // add to error list + int error = g_errorList.AddToTail(); + g_errorList[error].result = false; + g_errorList[error].fileName.Set( sourceFile ); + } + } + else if ( updateList[i] & DO_ZIP ) + { + // existing target file is zipped + CUtlBuffer targetBuffer; + bSuccess = scriptlib->ReadFileToBuffer( targetFile, targetBuffer ); + if ( bSuccess ) + { + if ( !g_bTest ) + { + bSuccess = g_MasterXZip.AddBuffer( targetFile, targetBuffer, true ); + } + } + if ( !bSuccess ) + { + // add to error list + int error = g_errorList.AddToTail(); + g_errorList[error].result = false; + g_errorList[error].fileName.Set( targetFile ); + } + } + + progress++; + } + + DoPostProcessingFunctions( !g_bTest ); + + ShutdownConversionModules(); + + if ( numFilesToZip && !g_bTest ) + { + g_MasterXZip.End(); + } + + // iterate error list + Msg( "\n" ); + for ( int i = 0; i < g_errorList.Count(); i++ ) + { + Msg( "ERROR: could not process %s\n", g_errorList[i].fileName.String() ); + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Spew Usage +//----------------------------------------------------------------------------- +void Usage() +{ + Msg( "usage: MakeGameData [filemask] [options]\n" ); + Msg( "options:\n" ); + Msg( "[-v] Version\n" ); + Msg( "[-q] Quiet (critical spew only)\n" ); + Msg( "[-h] [-help] [-?] Help\n" ); + Msg( "[-t targetPath] Alternate output path, will generate output at target\n" ); + Msg( "[-r] [-recurse] Recurse into source directory\n" ); + Msg( "[-f] [-force] Force update, otherwise checks timestamps\n" ); + Msg( "[-test] Skip writing to disk\n" ); + Msg( "[-z <zipname>] Generate zip file AND create or update stale conversions\n" ); + Msg( "[-zo <zipname>] Generate zip file ONLY (existing stale conversions get updated, no new conversions are written)\n" ); + Msg( "[-preloadinfo] Spew contents of preload section in zip\n" ); + Msg( "[-xmaquality <quality>] XMA Encoding quality override, [0-100]\n" ); + Msg( "[-scenes] Make 360 scene image cache.\n" ); + Msg( "[-pcscenes] Make PC scene image cache.\n" ); + Msg( "[-usemaplist] For BSP related conversions, restricts to maplist.txt.\n" ); + + exit( 1 ); +} + +//----------------------------------------------------------------------------- +// Purpose: default output func +//----------------------------------------------------------------------------- +SpewRetval_t OutputFunc( SpewType_t spewType, char const *pMsg ) +{ + printf( pMsg ); + + if ( spewType == SPEW_ERROR ) + { + return SPEW_ABORT; + } + return ( spewType == SPEW_ASSERT ) ? SPEW_DEBUGGER : SPEW_CONTINUE; +} + +//----------------------------------------------------------------------------- +// The application object +//----------------------------------------------------------------------------- +bool MakeGameDataApp::Create() +{ + SpewOutputFunc( OutputFunc ); + + AppSystemInfo_t appSystems[] = + { + { "mdllib.dll", MDLLIB_INTERFACE_VERSION }, + { "", "" } // Required to terminate the list + }; + + AddSystem( g_pDataModel, VDATAMODEL_INTERFACE_VERSION ); + AddSystem( g_pDmSerializers, DMSERIALIZERS_INTERFACE_VERSION ); + + // Load vphysics.dll + if ( !Sys_LoadInterface( "vphysics.dll", VPHYSICS_COLLISION_INTERFACE_VERSION, &g_pPhysicsModule, (void**)&g_pPhysicsCollision ) ) + { + Msg( "Failed to load vphysics interface\n" ); + return false; + } + + bool bOk = AddSystems( appSystems ); + if ( !bOk ) + return false; + + return true; +} + +bool MakeGameDataApp::PreInit() +{ + CreateInterfaceFn factory = GetFactory(); + + ConnectTier1Libraries( &factory, 1 ); + ConnectTier2Libraries( &factory, 1 ); + + if ( !g_pFullFileSystem || !g_pDataModel || !g_pPhysicsCollision || !mdllib ) + { + Warning( "MakeGameData is missing a required interface!\n" ); + return false; + } + + return true; +} + +void MakeGameDataApp::PostShutdown() +{ + if ( g_pPhysicsModule ) + { + Sys_UnloadModule( g_pPhysicsModule ); + g_pPhysicsModule = NULL; + g_pPhysicsCollision = NULL; + } + + DisconnectTier2Libraries(); + DisconnectTier1Libraries(); +} + +//----------------------------------------------------------------------------- +// main +// +//----------------------------------------------------------------------------- +int MakeGameDataApp::Main() +{ + int argnum; + + // set the valve library printer + SpewOutputFunc( OutputFunc ); + + Msg( "\nMAKEGAMEDATA - Valve Xbox 360 Game Data Compiler (Build: %s %s)\n", __DATE__, __TIME__ ); + Msg( "(C) Copyright 1996-2006, Valve Corporation, All rights reserved.\n\n" ); + + if ( CommandLine()->FindParm( "-v" ) || CommandLine()->FindParm( "-version" ) ) + { + // spew just the version, used by batches for logging + return 0; + } + +#ifndef MAKESCENESIMAGE + if ( CommandLine()->ParmCount() < 2 || CommandLine()->FindParm( "?" ) || CommandLine()->FindParm( "-h" ) || CommandLine()->FindParm( "-help" ) ) + { + Usage(); + } +#endif // MAKESCENESIMAGE + + bool bHasFileMask = false; + + const char *pFirstArg = CommandLine()->GetParm( 1 ); + if ( pFirstArg[0] == '-' ) + { + // first arg is an option, assume *.* + strcpy( g_szSourcePath, "*.*" ); + } + else + { + strcpy( g_szSourcePath, pFirstArg ); + bHasFileMask = true; + } + + bool bRecurse = false; +#ifndef MAKESCENESIMAGE + bRecurse = CommandLine()->FindParm( "-recurse" ) || CommandLine()->FindParm( "-r" ); + g_bForce = CommandLine()->FindParm( "-force" ) || CommandLine()->FindParm( "-f" ); + g_bTest = CommandLine()->FindParm( "-test" ) != 0; + g_bQuiet = CommandLine()->FindParm( "-quiet" ) || CommandLine()->FindParm( "-q" ); + g_bMakeScenes = CommandLine()->FindParm( "-scenes" ) != 0; + g_bMakeScenesPC = CommandLine()->FindParm( "-pcscenes" ) != 0; +#else + g_bMakeScenesPC = true; +#endif // MAKESCENESIMAGE + +#ifndef MAKESCENESIMAGE + g_bUseMapList = CommandLine()->FindParm( "-usemaplist" ) != 0; +#endif // MAKESCENESIMAGE + + // Set up zip file options + g_WriteModeForConversions = WRITE_TO_DISK_ALWAYS; + argnum = CommandLine()->FindParm( "-z" ); + if ( argnum ) + { + strcpy( g_szSourcePath, "*.*" ); + g_bMakeZip = true; + g_bMakeScenes = true; + bRecurse = true; + } + else + { + argnum = CommandLine()->FindParm( "-zo" ); + if ( argnum ) + { + strcpy( g_szSourcePath, "*.*" ); + g_bMakeZip = true; + g_bMakeScenes = true; + g_WriteModeForConversions = WRITE_TO_DISK_UPDATE; + bRecurse = true; + } + } + if ( g_bMakeZip ) + { + strcat( g_zipPath, CommandLine()->GetParm( argnum + 1 ) ); + } + + // default target path is source + strcpy( g_targetPath, g_szSourcePath ); + V_StripFilename( g_targetPath ); + if ( !g_targetPath[0] ) + { + strcpy( g_targetPath, "." ); + } + + // override via command line + argnum = CommandLine()->FindParm( "-t" ); + if ( argnum ) + { + V_strcpy_safe( g_targetPath, CommandLine()->GetParm( argnum + 1 ) ); + } + V_AppendSlash( g_targetPath, sizeof( g_targetPath ) ); + + if ( CommandLine()->FindParm( "-preloadinfo" ) ) + { + g_MasterXZip.SpewPreloadInfo( g_szSourcePath ); + return 0; + } + +#ifndef MAKESCENESIMAGE + GetGamePath(); +#endif // MAKESCENESIMAGE + + g_bModPathIsValid = GetModPath(); + if ( !SetupFileSystem() ) + { + Msg( "ERROR: Failed to setup file system.\n" ); + exit( 1 ); + } + + // data model initialization + g_pDataModel->SetUndoEnabled( false ); + g_pDataModel->OnlyCreateUntypedElements( true ); + g_pDataModel->SetDefaultElementFactory( NULL ); + + g_bIsPlatformZip = g_bMakeZip && ( V_stristr( g_szModPath, "\\platform" ) != NULL ); + + // cleanup any zombie temp files left from a possible prior abort or error + scriptlib->DeleteTemporaryFiles( "mgd_*.tmp" ); + + if ( g_bMakeZip || g_bUseMapList ) + { + // zips use the map list to narrow the bsp conversion to actual shipping maps + BuildValidMapList( g_ValidMapList ); + } + + CUtlVector<fileList_t> fileList; + if ( bHasFileMask || g_bMakeZip ) + { + scriptlib->FindFiles( g_szSourcePath, bRecurse, fileList ); + } + + // model conversions require seperate pre-processing to achieve grouping + if ( !PreprocessModelFiles( fileList ) ) + { + return 0; + } + + GenerateTargetFiles( fileList ); + + return 0; +} diff --git a/utils/xbox/MakeGameData/MakeGameData.h b/utils/xbox/MakeGameData/MakeGameData.h new file mode 100644 index 0000000..c2f2004 --- /dev/null +++ b/utils/xbox/MakeGameData/MakeGameData.h @@ -0,0 +1,165 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=====================================================================================// + +#pragma once + +#include <windows.h> +#include <mmreg.h> +#include <stdio.h> +#include <stdlib.h> +#include <direct.h> +#include <io.h> +#include <time.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/utime.h> +#include "tier0/dbg.h" +#include "tier0/icommandline.h" +#include "appframework/appframework.h" +#include "characterset.h" +#include "tier1/strtools.h" +#include "tier1/UtlVector.h" +#include "tier1/UtlBuffer.h" +#include "tier1/UtlString.h" +#include "tier1/UtlRBTree.h" +#include "tier1/UtlDict.h" +#include "tier1/UtlSortVector.h" +#include "tier1/UtlStringMap.h" +#include "tier1/UtlSymbol.h" +#include "tier1/KeyValues.h" +#include "tier1/lzss.h" +#include "lzma/lzma.h" +#include "datamap.h" +#include "XZipTool.h" +#include "../../common/scriplib.h" +#include "../../common/cmdlib.h" +#include "tier2/tier2.h" +#include "dmserializers/idmserializers.h" +#include "datamodel/dmattribute.h" +#include "datamodel/dmelement.h" +#include "studiobyteswap.h" +#include "studio.h" +#include "vphysics_interface.h" +#include "materialsystem/IMaterial.h" +#include "materialsystem/hardwareverts.h" +#include "optimize.h" +#include "soundchars.h" +#include "mdllib/mdllib.h" + +enum fileType_e +{ + FILETYPE_UNKNOWN = 0, + FILETYPE_WAV, + FILETYPE_VTF, + FILETYPE_MDL, + FILETYPE_ANI, + FILETYPE_VTX, + FILETYPE_VVD, + FILETYPE_PHY, + FILETYPE_BSP, + FILETYPE_AIN, + FILETYPE_CCDAT, + FILETYPE_MP3, + FILETYPE_RESLST, + FILETYPE_PCF, + FILETYPE_SCENEIMAGE +}; + +typedef struct +{ + int result; + CUtlString fileName; +} errorList_t; + +//----------------------------------------------------------------------------- +// MakeGameData.cpp +//----------------------------------------------------------------------------- + + +bool IsLocalizedFile( const char *pFileName ); +bool IsLocalizedFileValid( const char *pFileName, const char *pLanguageSuffix = NULL ); +bool CompressCallback( CUtlBuffer &inputBuffer, CUtlBuffer &outputBuffer ); +bool ReadFileToBuffer( const char *pSourceName, CUtlBuffer &buffer, bool bText, bool bNoOpenFailureWarning ); +bool WriteBufferToFile( const char *pTargetName, CUtlBuffer &buffer, bool bWriteToZip, DiskWriteMode_t writeMode ); +fileType_e ResolveFileType( const char *pSourceName, char *pTargetName, int targetNameSize ); + +extern DiskWriteMode_t g_WriteModeForConversions; +extern CXZipTool g_MasterXZip; +extern char g_szGamePath[]; +extern char g_szModPath[]; +extern bool g_bModPathIsValid; +extern const char *g_GameNames[]; +extern bool g_bForce; +extern bool g_bQuiet; +extern bool g_bMakeZip; +extern bool g_bIsPlatformZip; +extern IPhysicsCollision *g_pPhysicsCollision; +extern char g_szSourcePath[]; +extern CUtlVector< errorList_t > g_errorList; + +//----------------------------------------------------------------------------- +// MakeTextures.cpp +//----------------------------------------------------------------------------- +bool CreateTargetFile_VTF( const char *pSourceName, const char *pTargetName, bool bWriteToZip ); +bool GetPreloadData_VTF( const char *pFilename, CUtlBuffer &fileBufferIn, CUtlBuffer &preloadBufferOut ); + +//----------------------------------------------------------------------------- +// MakeScenes.cpp +//----------------------------------------------------------------------------- +bool CreateSceneImageFile( char const *pchModPath, bool bWriteToZip, bool bLittleEndian, bool bQuiet, DiskWriteMode_t eWriteModeForConversions ); + +//----------------------------------------------------------------------------- +// MakeSounds.cpp +//----------------------------------------------------------------------------- +bool CreateTargetFile_WAV( const char *pSourceName, const char *pTargetName, bool bWriteToZip ); +bool CreateTargetFile_MP3( const char *pSourceName, const char *pTargetName, bool bWriteToZip ); +bool GetPreloadData_WAV( const char *pFilename, CUtlBuffer &fileBufferIn, CUtlBuffer &preloadBufferOut ); + +//----------------------------------------------------------------------------- +// MakeMaps.cpp +//----------------------------------------------------------------------------- +bool CreateTargetFile_BSP( const char *pSourceName, const char *pTargetName, bool bWriteToZip ); +bool CreateTargetFile_AIN( const char *pSourceName, const char *pTargetName, bool bWriteToZip ); +bool GetDependants_BSP( const char *pBspName, CUtlVector< CUtlString > *pList ); + +//----------------------------------------------------------------------------- +// MakeResources.cpp +//----------------------------------------------------------------------------- +bool CreateTargetFile_CCDAT( const char *pSourceName, const char *pTargetName, bool bWriteToZip ); +bool CreateTargetFile_RESLST( const char *pSourceName, const char *pTargetName, bool bWriteToZip ); + +//----------------------------------------------------------------------------- +// MakeModels.cpp +//----------------------------------------------------------------------------- +bool InitStudioByteSwap( void ); +void ShutdownStudioByteSwap( void ); +bool CreateTargetFile_Model( const char *pSourceName, const char *pTargetName, bool bWriteToZip ); +bool GetDependants_MDL( const char *pModelName, CUtlVector< CUtlString > *pList ); +bool GetPreloadData_VHV( const char *pFilename, CUtlBuffer &fileBufferIn, CUtlBuffer &preloadBufferOut ); +bool GetPreloadData_VTX( const char *pFilename, CUtlBuffer &fileBufferIn, CUtlBuffer &preloadBufferOut ); +bool GetPreloadData_VVD( const char *pFilename, CUtlBuffer &fileBufferIn, CUtlBuffer &preloadBufferOut ); +bool PreprocessModelFiles( CUtlVector<fileList_t> &fileList ); + +//----------------------------------------------------------------------------- +// MakeShaders.cpp +//----------------------------------------------------------------------------- +bool GetPreloadData_VCS( const char *pFilename, CUtlBuffer &fileBufferIn, CUtlBuffer &preloadBufferOut ); + +//----------------------------------------------------------------------------- +// MakeMisc.cpp +//----------------------------------------------------------------------------- +bool ProcessDXSupportConfig( bool bWriteToZip ); + +//----------------------------------------------------------------------------- +// MakeResources.cpp +//----------------------------------------------------------------------------- +bool CreateTargetFile_PCF( const char *pSourceName, const char *pTargetName, bool bWriteToZip ); + +//----------------------------------------------------------------------------- +// MakeZip.cpp +//----------------------------------------------------------------------------- +void SetupCriticalPreloadScript( const char *pModPath ); diff --git a/utils/xbox/MakeGameData/MakeGameData.vpc b/utils/xbox/MakeGameData/MakeGameData.vpc new file mode 100644 index 0000000..315333c --- /dev/null +++ b/utils/xbox/MakeGameData/MakeGameData.vpc @@ -0,0 +1,111 @@ +//----------------------------------------------------------------------------- +// MAKEGAMEDATA.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" + +$Include "$SRCDIR\vpc_scripts\source_exe_con_base.vpc" + +$Configuration +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE;$SRCDIR\x360xdk\include\win32\vs2005;$SRCDIR\game\shared" + $PreprocessorDefinitions "$BASE;NO_X360_XDK" [$VS2015] + } + + $Linker + { + $AdditionalDependencies "$BASE xgraphics.lib d3d9.lib legacy_stdio_definitions.lib" + $AdditionalDependencies "$BASE xmaencoder.lib" [!$VS2015] + $AdditionalLibraryDirectories "$BASE;$SRCDIR\x360xdk\lib\win32\vs2005" + } +} + +$Project "MakeGameData" +{ + $Folder "Source Files" + { + $File "MakeGameData.cpp" + $File "MakeMaps.cpp" + $File "MakeMisc.cpp" + $File "MakeModels.cpp" + $File "MakeParticles.cpp" + $File "MakeResources.cpp" + $File "MakeScenes.cpp" + $File "MakeShaders.cpp" + $File "MakeSounds.cpp" + $File "MakeTextures.cpp" + $File "MakeZip.cpp" + + $Folder "Audio" + { + $File "imaadpcm.cpp" + $File "sound_io.cpp" + $File "resample.cpp" + } + + $Folder "Public Modules" + { + $File "$SRCDIR\common\compiledcaptionswap.cpp" + $file "$SRCDIR\common\studiobyteswap.cpp" + $File "$SRCDIR\utils\common\scriplib.cpp" + $File "$SRCDIR\public\zip_utils.cpp" + $File "$SRCDIR\public\sentence.cpp" + $File "$SRCDIR\utils\common\cmdlib.cpp" + $File "$SRCDIR\public\filesystem_helpers.cpp" + $File "$SRCDIR\public\filesystem_init.cpp" + $File "$SRCDIR\utils\common\filesystem_tools.cpp" + $File "$SRCDIR\public\interpolatortypes.cpp" + } + } + + $Folder "Header Files" + { + $File "MakeGameData.h" + $File "XZipTool.h" + $File "imaadpcm.h" + $File "resample.h" + $File "$SRCDIR\public\captioncompiler.h" + $File "$SRCDIR\common\studiobyteswap.h" + $File "$SRCDIR\utils\common\scriplib.h" + $File "$SRCDIR\public\filesystem.h" + $File "$SRCDIR\public\ibsppack.h" + $File "$SRCDIR\public\sentence.h" + $File "$SRCDIR\public\studio.h" + $File "$SRCDIR\public\tier1\utlbuffer.h" + $File "$SRCDIR\public\tier1\strtools.h" + $File "$SRCDIR\public\vphysics_interface.h" + $File "$SRCDIR\public\vstdlib\vstdlib.h" + $File "$SRCDIR\public\xwvfile.h" + $File "$SRCDIR\public\zip_utils.h" + $File "$SRCDIR\game\shared\choreoscene.h" + $File "$SRCDIR\game\shared\choreoactor.h" + $File "$SRCDIR\public\filesystem_helpers.h" + $File "$SRCDIR\public\filesystem_init.h" + $File "$SRCDIR\utils\common\filesystem_tools.h" + $File "$SRCDIR\public\interpolatortypes.h" + $File "$SRCDIR\utils\common\cmdlib.h" + $File "$SRCDIR\game\shared\choreochannel.h" + $File "$SRCDIR\game\shared\choreoevent.h" + $File "$SRCDIR\public\tier1\checksum_crc.h" + $File "$SRCDIR\public\tier2\tier2.h" + $File "$SRCDIR\common\lzma\lzma.h" + } + + $Folder "Link Libraries" + { + $Lib appframework + $Lib mathlib + $Lib vtf + $Lib tier2 + $Lib choreoobjects + $Lib bitmap + $Lib datamodel + $Lib dmserializers + $Lib $LIBCOMMON\lzma + } +} diff --git a/utils/xbox/MakeGameData/MakeMaps.cpp b/utils/xbox/MakeGameData/MakeMaps.cpp new file mode 100644 index 0000000..618e5f6 --- /dev/null +++ b/utils/xbox/MakeGameData/MakeMaps.cpp @@ -0,0 +1,383 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: .360 Creation for all studiomdl generated files (mdl, vvd, vtx, ani, phy) +// +//=====================================================================================// + +#include "MakeGameData.h" +#include "filesystem.h" +#include "../../common/bsplib.h" +#include "ibsppack.h" +#include "vtf/vtf.h" +#include "../../game/server/ai_hull.h" +#include "zip_utils.h" + +#define AINET_VERSION_NUMBER 37 +#define MAX_NODES 1500 + +bool ReadBSPHeader( const char *pFilename, dheader_t *pHeader ) +{ + V_memset( pHeader, 0, sizeof( dheader_t ) ); + + int handle = _open( pFilename, _O_RDONLY|_O_BINARY ); + if ( handle == -1 ) + { + return false; + } + + _read( handle, pHeader, sizeof( dheader_t ) ); + close( handle ); + + return true; +} + +//----------------------------------------------------------------------------- +// Run possible lod culling fixup +//----------------------------------------------------------------------------- +bool ConvertVHV( const char *pVhvFilename, const char *pModelName, CUtlBuffer &sourceBuffer, CUtlBuffer &targetBuffer ) +{ + // find strip info from model + char vsiFilename[MAX_PATH]; + V_strncpy( vsiFilename, pModelName, sizeof( vsiFilename ) ); + V_SetExtension( vsiFilename, ".vsi", sizeof( vsiFilename ) ); + + CUtlBuffer vsiBuffer; + if ( !g_pFullFileSystem->ReadFile( vsiFilename, NULL, vsiBuffer ) ) + { + // cannot convert bsp's without model converions + Msg( "Error! Missing expected model conversion file '%s'. Cannot perform VHV fixup.\n", vsiFilename ); + return false; + } + + IMdlStripInfo *pMdlStripInfo = NULL; + if ( !mdllib->CreateNewStripInfo( &pMdlStripInfo ) ) + { + Msg( "Error! Failed to allocate strip info object\n" ); + return false; + } + + if ( !pMdlStripInfo->UnSerialize( vsiBuffer ) ) + { + Msg( "Error! Failed to unserialize strip info object '%s'\n", vsiFilename ); + pMdlStripInfo->DeleteThis(); + return false; + } + + long originalChecksum = 0; + long newChecksum = 0; + if ( !pMdlStripInfo->GetCheckSum( &originalChecksum, &newChecksum ) ) + { + Msg( "Error! Failed to get checksums from '%s'\n", vsiFilename ); + pMdlStripInfo->DeleteThis(); + return false; + } + + HardwareVerts::FileHeader_t *pVHVhdr = (HardwareVerts::FileHeader_t*)sourceBuffer.Base(); + if ( pVHVhdr->m_nChecksum != originalChecksum ) + { + // vhv file should have matching original checksums + Msg( "Error! Mismatched checksums from '%s' and '%s'\n", vsiFilename, pVhvFilename ); + pMdlStripInfo->DeleteThis(); + return false; + } + + targetBuffer.EnsureCapacity( sourceBuffer.TellMaxPut() ); + targetBuffer.Put( sourceBuffer.Base(), sourceBuffer.TellMaxPut() ); + if ( !pMdlStripInfo->StripHardwareVertsBuffer( targetBuffer ) ) + { + pMdlStripInfo->DeleteThis(); + return false; + } + + // success + pMdlStripInfo->DeleteThis(); + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Generate .360 bsp +//----------------------------------------------------------------------------- +bool CreateTargetFile_BSP( const char *pSourceName, const char *pTargetName, bool bWriteToZip ) +{ + CUtlBuffer targetBuffer; + CUtlBuffer zipBuffer; + CUtlBuffer fileBuffer; + CUtlBuffer tempBuffer; + char tempZipName[MAX_PATH]; + char tempSwapName[MAX_PATH]; + + tempZipName[0] = '\0'; + tempSwapName[0] = '\0'; + void *pPakData = NULL; + int pakSize = 0; + CXZipTool *pNewXZip = NULL; + + if ( !g_bModPathIsValid ) + { + Msg( "Indeterminate mod path, Cannot perform BSP conversion\n" ); + return false; + } + + // Load bsppack.dll + void *pBSPPack; + CSysModule *pBSPModule; + if ( !Sys_LoadInterface( "bsppack.dll", IBSPPACK_VERSION_STRING, &pBSPModule, &pBSPPack ) ) + { + Msg( "Failed to load bsppack interface\n" ); + return false; + } + + scriptlib->MakeTemporaryFilename( g_szModPath, tempSwapName, sizeof( tempSwapName ) ); + + // Swaps the bsp directly to disk + bool bOK = ((IBSPPack*)pBSPPack)->SwapBSPFile( g_pFullFileSystem, pSourceName, tempSwapName, false, ConvertVTFTo360Format, ConvertVHV, CompressCallback ); + if ( !bOK ) + { + goto cleanUp; + } + + // get the pak file from the swapped bsp + bOK = ((IBSPPack*)pBSPPack)->GetPakFileLump( g_pFullFileSystem, tempSwapName, &pPakData, &pakSize ); + if ( !bOK ) + { + goto cleanUp; + } + + // build an xzip version of the pak file + if ( pPakData && pakSize ) + { + // mount current pak file + IZip *pOldZip = IZip::CreateZip( false, true ); + pOldZip->ParseFromBuffer( pPakData, pakSize ); + + // start a new xzip version + scriptlib->MakeTemporaryFilename( g_szModPath, tempZipName, sizeof( tempZipName ) ); + + pNewXZip = new CXZipTool; + pNewXZip->Begin( tempZipName, XBOX_DVD_SECTORSIZE ); + + // iterate each file in existing zip, add to new zip + int zipIndex = -1; + for ( ;; ) + { + char filename[MAX_PATH]; + filename[0] = '\0'; + int fileSize = 0; + zipIndex = pOldZip->GetNextFilename( zipIndex, filename, sizeof( filename ), fileSize ); + if ( zipIndex == -1 ) + { + break; + } + + fileBuffer.Purge(); + bOK = pOldZip->ReadFileFromZip( filename, false, fileBuffer ); + if ( !bOK ) + { + goto cleanUp; + } + + bOK = pNewXZip->AddBuffer( filename, fileBuffer, true ); + if ( !bOK ) + { + goto cleanUp; + } + } + + IZip::ReleaseZip( pOldZip ); + pNewXZip->End(); + + // read the new zip into memory + bOK = scriptlib->ReadFileToBuffer( tempZipName, zipBuffer ); + if ( !bOK ) + { + goto cleanUp; + } + + // replace old pak lump with new zip + bOK = ((IBSPPack*)pBSPPack)->SetPakFileLump( g_pFullFileSystem, tempSwapName, tempSwapName, zipBuffer.Base(), zipBuffer.TellMaxPut() ); + if ( !bOK ) + { + goto cleanUp; + } + } + + bOK = scriptlib->ReadFileToBuffer( tempSwapName, targetBuffer ); + if ( !bOK ) + { + goto cleanUp; + } + + // never zip, always write local file + bOK = WriteBufferToFile( pTargetName, targetBuffer, false, WRITE_TO_DISK_ALWAYS ); + +cleanUp: + if ( tempZipName[0] ) + { + _unlink( tempZipName ); + } + if ( tempSwapName[0] ) + { + _unlink( tempSwapName ); + } + + Sys_UnloadModule( pBSPModule ); + + if ( pPakData ) + { + free( pPakData ); + } + + delete pNewXZip; + + return bOK; +} + + +//----------------------------------------------------------------------------- +// Purpose: Generate .360 node graphs +//----------------------------------------------------------------------------- +bool CreateTargetFile_AIN( const char *pSourceName, const char *pTargetName, bool bWriteToZip ) +{ + CUtlBuffer sourceBuf; + if ( !scriptlib->ReadFileToBuffer( pSourceName, sourceBuf ) ) + { + return false; + } + + // the pc ain is tied to the pc bsp and should have been generated after the bsp + char szBspName[MAX_PATH]; + char szBspPath[MAX_PATH]; + V_FileBase( pSourceName, szBspName, sizeof( szBspName ) ); + V_ExtractFilePath( pSourceName, szBspPath, sizeof( szBspPath ) ); + V_AppendSlash( szBspPath, sizeof( szBspPath ) ); + V_strncat( szBspPath, "..\\", sizeof( szBspPath ) ); + V_strncat( szBspPath, szBspName, sizeof( szBspPath ) ); + V_strncat( szBspPath, ".bsp", sizeof( szBspPath ) ); + if ( scriptlib->CompareFileTime( pSourceName, szBspPath ) < 0 ) + { + // ain has a smaller filetime, thus older than bsp + Msg( "%s: Need to regenerate PC nodegraph (stale)\n", pSourceName ); + if ( !g_bForce ) + { + return false; + } + } + + // Check the version + if ( sourceBuf.GetChar() == 'V' && sourceBuf.GetChar() == 'e' && sourceBuf.GetChar() == 'r' ) + { + Msg( "%s: Need to regenerate PC nodegraph (bad format)\n", pSourceName ); + return false; + } + + // reset + sourceBuf.SeekGet( CUtlBuffer::SEEK_HEAD, 0 ); + + // Version number + int version = sourceBuf.GetInt(); + if ( version != AINET_VERSION_NUMBER ) + { + Msg( "%s: Need to regenerate PC nodegraph (got version '%d', expected '%d')\n", pSourceName, version, AINET_VERSION_NUMBER ); + return false; + } + + // check the map revision + int mapVersion = sourceBuf.GetInt(); + dheader_t bspHeader; + if ( ReadBSPHeader( szBspPath, &bspHeader ) ) + { + if ( mapVersion != bspHeader.mapRevision ) + { + Msg( "%s: Need to regenerate PC nodegraph (ai revision '%d' does not match bsp revision '%d')\n", pSourceName, mapVersion, bspHeader.mapRevision ); + return false; + } + } + else + { + Msg( "%s: Could not find expected bsp '%s'\n", pSourceName, szBspPath ); + } + + // Nodes + int nodeCt = sourceBuf.GetInt(); + if ( nodeCt > MAX_NODES || nodeCt < 0 ) + { + Msg( "%s: Need to regenerate PC nodegraph (corrupt)\n", pSourceName ); + return false; + } + + CUtlBuffer targetBuf; + targetBuf.ActivateByteSwapping( true ); + + CByteswap swap; + swap.ActivateByteSwapping( true ); + + targetBuf.PutInt( version ); + targetBuf.PutInt( mapVersion ); + targetBuf.PutInt( nodeCt ); + + int numFloats = NUM_HULLS + 4; + for ( int node = 0; node < nodeCt; ++node ) + { + targetBuf.EnsureCapacity( targetBuf.TellPut() + numFloats * sizeof( float ) ); + swap.SwapBufferToTargetEndian<float>( (float*)targetBuf.PeekPut(), (float*)sourceBuf.PeekGet(), numFloats ); + sourceBuf.SeekGet( CUtlBuffer::SEEK_CURRENT, numFloats * sizeof( float ) ); + targetBuf.SeekPut( CUtlBuffer::SEEK_CURRENT, numFloats * sizeof( float ) ); + + targetBuf.PutChar( sourceBuf.GetChar() ); + + // Align the remaining data + targetBuf.SeekPut( CUtlBuffer::SEEK_CURRENT, 3 ); + + targetBuf.PutUnsignedShort( sourceBuf.GetUnsignedShort() ); + targetBuf.PutShort( sourceBuf.GetShort() ); + } + + // Node links + int totalNumLinks = sourceBuf.GetInt(); + targetBuf.PutInt( totalNumLinks ); + + for ( int link = 0; link < totalNumLinks; ++link ) + { + targetBuf.PutShort( sourceBuf.GetShort() ); + targetBuf.PutShort( sourceBuf.GetShort() ); + targetBuf.Put( sourceBuf.PeekGet(), NUM_HULLS ); + sourceBuf.SeekGet( CUtlBuffer::SEEK_CURRENT, NUM_HULLS ); + } + + // WC lookup table + targetBuf.EnsureCapacity( targetBuf.TellPut() + nodeCt * sizeof( int ) ); + swap.SwapBufferToTargetEndian<int>( (int*)targetBuf.PeekPut(), (int*)sourceBuf.PeekGet(), nodeCt ); + targetBuf.SeekPut( CUtlBuffer::SEEK_CURRENT, nodeCt * sizeof( int ) ); + + // Write the file out + return WriteBufferToFile( pTargetName, targetBuf, bWriteToZip, WRITE_TO_DISK_ALWAYS ); +} + +bool GetDependants_BSP( const char *pBspName, CUtlVector< CUtlString > *pList ) +{ + if ( !g_bModPathIsValid ) + { + Msg( "Indeterminate mod path, Cannot perform BSP conversion\n" ); + return false; + } + + // Load bsppack.dll + void *pBSPPack; + CSysModule *pBSPModule; + if ( !Sys_LoadInterface( "bsppack.dll", IBSPPACK_VERSION_STRING, &pBSPModule, &pBSPPack ) ) + { + Msg( "Failed to load bsppack interface\n" ); + return false; + } + + // 360 builds a more complete reslist that includes bsp internal files + // build full path to bsp file + char szBspFilename[MAX_PATH]; + V_ComposeFileName( g_szGamePath, pBspName, szBspFilename, sizeof( szBspFilename ) ); + + bool bOK = ((IBSPPack*)pBSPPack)->GetBSPDependants( g_pFullFileSystem, szBspFilename, pList ); + + Sys_UnloadModule( pBSPModule ); + + return bOK; +} diff --git a/utils/xbox/MakeGameData/MakeMisc.cpp b/utils/xbox/MakeGameData/MakeMisc.cpp new file mode 100644 index 0000000..d5e88de --- /dev/null +++ b/utils/xbox/MakeGameData/MakeMisc.cpp @@ -0,0 +1,86 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Conversion for general wierd files. +// +//=====================================================================================// + +#include "MakeGameData.h" + +//----------------------------------------------------------------------------- +// The DX Support file is a very fat expensive KV file, causes a run-time startup slowdown. +// Becauase it normally lives in the game\bin directory, it can't be in the zip or preloaded. +// Thus, it gets reprocessed into just the trivial 360 portion and placed into the platform.zip +// Yes, it's evil. +//----------------------------------------------------------------------------- +bool ProcessDXSupportConfig( bool bWriteToZip ) +{ + if ( !g_bIsPlatformZip ) + { + // only relevant when building platform zip, otherwise no-op + return false; + } + + const char *pConfigName = "dxsupport.cfg"; + char szTempPath[MAX_PATH]; + char szSourcePath[MAX_PATH]; + V_ComposeFileName( g_szModPath, "../bin", szTempPath, sizeof( szTempPath ) ); + V_ComposeFileName( szTempPath, pConfigName, szSourcePath, sizeof( szSourcePath ) ); + + CUtlBuffer sourceBuf( 0, 0, CUtlBuffer::TEXT_BUFFER ); + if ( !g_pFullFileSystem->ReadFile( szSourcePath, NULL, sourceBuf ) ) + { + Msg( "Error! Couldn't open file '%s'!\n", pConfigName ); + return false; + } + + KeyValues *pKV = new KeyValues( "" ); + if ( !pKV->LoadFromBuffer( "dxsupport.cfg", sourceBuf ) ) + { + Msg( "Error! Couldn't parse config file '%s'!\n", pConfigName ); + pKV->deleteThis(); + return false; + } + + // only care about the xbox specific dxlevel 98 block + KeyValues *pXboxSubKey = NULL; + for ( KeyValues *pSubKey = pKV->GetFirstSubKey(); pSubKey != NULL && pXboxSubKey == NULL; pSubKey = pSubKey->GetNextKey() ) + { + // descend each sub block + for ( KeyValues *pKey = pSubKey->GetFirstSubKey(); pKey != NULL && pXboxSubKey == NULL; pKey = pKey->GetNextKey() ) + { + if ( !V_stricmp( pKey->GetName(), "name" ) && pKey->GetInt( (const char *)NULL ) == 98 ) + { + pXboxSubKey = pSubKey; + } + } + } + + if ( !pXboxSubKey ) + { + Msg( "Error! Couldn't find expected dxlevel 98 in config file '%s'!\n", pConfigName ); + pKV->deleteThis(); + return false; + } + + CUtlBuffer kvBuffer( 0, 0, CUtlBuffer::TEXT_BUFFER ); + kvBuffer.Printf( "\"dxsupport\"\n" ); + kvBuffer.Printf( "{\n" ); + kvBuffer.Printf( "\t\"0\"\n" ); + kvBuffer.Printf( "\t{\n" ); + for ( KeyValues *pKey = pXboxSubKey->GetFirstSubKey(); pKey != NULL; pKey = pKey->GetNextKey() ) + { + kvBuffer.Printf( "\t\t\"%s\" \"%s\"\n", pKey->GetName(), pKey->GetString( (const char *)NULL ) ); + } + kvBuffer.Printf( "\t}\n" ); + kvBuffer.Printf( "}\n" ); + + CUtlBuffer targetBuf( 0, 0, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::CONTAINS_CRLF ); + kvBuffer.ConvertCRLF( targetBuf ); + + // only appears in zip file + bool bSuccess = WriteBufferToFile( pConfigName, targetBuf, bWriteToZip, WRITE_TO_DISK_NEVER ); + + pKV->deleteThis(); + + return bSuccess; +}
\ No newline at end of file diff --git a/utils/xbox/MakeGameData/MakeModels.cpp b/utils/xbox/MakeGameData/MakeModels.cpp new file mode 100644 index 0000000..21a14dc --- /dev/null +++ b/utils/xbox/MakeGameData/MakeModels.cpp @@ -0,0 +1,614 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: .360 Creation for all studiomdl generated files (mdl, vvd, vtx, ani, phy) +// +//=====================================================================================// + +#include "MakeGameData.h" +#include "studiobyteswap.h" +#include "studio.h" +#include "vphysics_interface.h" +#include "materialsystem/IMaterial.h" +#include "materialsystem/hardwareverts.h" +#include "optimize.h" + +//----------------------------------------------------------------------------- +// Models are already converted in a pre-pass. +//----------------------------------------------------------------------------- +bool CreateTargetFile_Model( const char *pSourceName, const char *pTargetName, bool bWriteToZip ) +{ + // model component should be present + CUtlBuffer targetBuffer; + if ( !scriptlib->ReadFileToBuffer( pTargetName, targetBuffer ) ) + { + return false; + } + + // no conversion to write, but possibly zipped + bool bSuccess = WriteBufferToFile( pTargetName, targetBuffer, bWriteToZip, WRITE_TO_DISK_NEVER ); + return bSuccess; +} + +//----------------------------------------------------------------------------- +// Load necessary dlls +//----------------------------------------------------------------------------- +bool InitStudioByteSwap( void ) +{ + StudioByteSwap::SetVerbose( false ); + StudioByteSwap::ActivateByteSwapping( true ); + StudioByteSwap::SetCollisionInterface( g_pPhysicsCollision ); + + return true; +} + +//---------------------------------------------------------------------- +// Get list of files that a model requires. +//---------------------------------------------------------------------- +bool GetDependants_MDL( const char *pModelName, CUtlVector< CUtlString > *pList ) +{ + if ( !g_bModPathIsValid ) + { + Msg( "Indeterminate mod path, Cannot perform BSP conversion\n" ); + return false; + } + + CUtlBuffer sourceBuf; + if ( !g_pFullFileSystem->ReadFile( pModelName, "GAME", sourceBuf ) ) + { + Msg( "Error! Couldn't open file '%s'!\n", pModelName ); + return false; + } + + studiohdr_t *pStudioHdr = (studiohdr_t *)sourceBuf.Base(); + Studio_ConvertStudioHdrToNewVersion( pStudioHdr ); + if ( pStudioHdr->version != STUDIO_VERSION ) + { + Msg( "Error! Bad Model '%s', Expecting Version (%d), got (%d)\n", pModelName, STUDIO_VERSION, pStudioHdr->version ); + return false; + } + + char szOutName[MAX_PATH]; + if ( pStudioHdr->flags & STUDIOHDR_FLAGS_OBSOLETE ) + { + V_strncpy( szOutName, "materials/sprites/obsolete.vmt", sizeof( szOutName ) ); + V_FixSlashes( szOutName ); + pList->AddToTail( szOutName ); + } + else if ( pStudioHdr->textureindex != 0 ) + { + // iterate each texture + int i; + int j; + for ( i = 0; i < pStudioHdr->numtextures; i++ ) + { + // iterate through all directories until a valid material is found + bool bFound = false; + for ( j = 0; j < pStudioHdr->numcdtextures; j++ ) + { + char szPath[MAX_PATH]; + V_ComposeFileName( "materials", pStudioHdr->pCdtexture( j ), szPath, sizeof( szPath ) ); + + // should have been fixed in studiomdl + // some mdls are ending up with double slashes, borking loads + int len = strlen( szPath ); + if ( len > 2 && szPath[len-2] == '\\' && szPath[len-1] == '\\' ) + { + szPath[len-1] = '\0'; + } + + V_ComposeFileName( szPath, pStudioHdr->pTexture( i )->pszName(), szOutName, sizeof( szOutName ) ); + V_SetExtension( szOutName, ".vmt", sizeof( szOutName ) ); + + if ( g_pFullFileSystem->FileExists( szOutName, "GAME" ) ) + { + bFound = true; + break; + } + } + + if ( bFound ) + { + pList->AddToTail( szOutName ); + } + } + } + + return true; +} + +//----------------------------------------------------------------------------- +// Get the preload data for a vhv file +//----------------------------------------------------------------------------- +bool GetPreloadData_VHV( const char *pFilename, CUtlBuffer &fileBufferIn, CUtlBuffer &preloadBufferOut ) +{ + HardwareVerts::FileHeader_t *pHeader = (HardwareVerts::FileHeader_t *)fileBufferIn.Base(); + + unsigned int version = BigLong( pHeader->m_nVersion ); + + // ensure caller's buffer is clean + // caller determines preload size, via TellMaxPut() + preloadBufferOut.Purge(); + + if ( version != VHV_VERSION ) + { + // bad version + Msg( "Can't preload: '%s', expecting version %d got version %d\n", pFilename, VHV_VERSION, version ); + return false; + } + + unsigned int nPreloadSize = sizeof( HardwareVerts::FileHeader_t ); + + preloadBufferOut.Put( fileBufferIn.Base(), nPreloadSize ); + + return true; +} + +//----------------------------------------------------------------------------- +// Get the preload data for a vtx file +//----------------------------------------------------------------------------- +bool GetPreloadData_VTX( const char *pFilename, CUtlBuffer &fileBufferIn, CUtlBuffer &preloadBufferOut ) +{ + OptimizedModel::FileHeader_t *pHeader = (OptimizedModel::FileHeader_t *)fileBufferIn.Base(); + + unsigned int version = BigLong( pHeader->version ); + + // ensure caller's buffer is clean + // caller determines preload size, via TellMaxPut() + preloadBufferOut.Purge(); + + if ( version != OPTIMIZED_MODEL_FILE_VERSION ) + { + // bad version + Msg( "Can't preload: '%s', expecting version %d got version %d\n", pFilename, OPTIMIZED_MODEL_FILE_VERSION, version ); + return false; + } + + unsigned int nPreloadSize = sizeof( OptimizedModel::FileHeader_t ); + + preloadBufferOut.Put( fileBufferIn.Base(), nPreloadSize ); + + return true; +} + +//----------------------------------------------------------------------------- +// Get the preload data for a vvd file +//----------------------------------------------------------------------------- +bool GetPreloadData_VVD( const char *pFilename, CUtlBuffer &fileBufferIn, CUtlBuffer &preloadBufferOut ) +{ + vertexFileHeader_t *pHeader = (vertexFileHeader_t *)fileBufferIn.Base(); + + unsigned int id = BigLong( pHeader->id ); + unsigned int version = BigLong( pHeader->version ); + + // ensure caller's buffer is clean + // caller determines preload size, via TellMaxPut() + preloadBufferOut.Purge(); + + if ( id != MODEL_VERTEX_FILE_ID ) + { + // bad version + Msg( "Can't preload: '%s', expecting id %d got id %d\n", pFilename, MODEL_VERTEX_FILE_ID, id ); + return false; + } + + if ( version != MODEL_VERTEX_FILE_VERSION ) + { + // bad version + Msg( "Can't preload: '%s', expecting version %d got version %d\n", pFilename, MODEL_VERTEX_FILE_VERSION, version ); + return false; + } + + unsigned int nPreloadSize = sizeof( vertexFileHeader_t ); + + preloadBufferOut.Put( fileBufferIn.Base(), nPreloadSize ); + + return true; +} + +bool CompressFunc( const void *pInput, int inputSize, void **pOutput, int *pOutputSize ) +{ + *pOutput = NULL; + *pOutputSize = 0; + + if ( !inputSize ) + { + // nothing to do + return false; + } + + unsigned int compressedSize; + unsigned char *pCompressedOutput = LZMA_OpportunisticCompress( (unsigned char *)pInput, inputSize, &compressedSize ); + if ( pCompressedOutput ) + { + *pOutput = pCompressedOutput; + *pOutputSize = compressedSize; + return true; + } + + return false; + +} + +//----------------------------------------------------------------------------- +// Rebuilds all of a MDL's components. +//----------------------------------------------------------------------------- +static bool GenerateModelFiles( const char *pMdlFilename ) +{ + CUtlBuffer tempBuffer; + int fileSize; + int paddedSize; + int swappedSize; + + // .mdl + CUtlBuffer mdlBuffer; + if ( !scriptlib->ReadFileToBuffer( pMdlFilename, mdlBuffer ) ) + { + return false; + } + if ( !Studio_ConvertStudioHdrToNewVersion( (studiohdr_t *)mdlBuffer.Base() )) + { + Msg("%s needs to be recompiled\n", pMdlFilename ); + } + + // .vtx + char szVtxFilename[MAX_PATH]; + V_StripExtension( pMdlFilename, szVtxFilename, sizeof( szVtxFilename ) ); + V_strncat( szVtxFilename, ".dx90.vtx", sizeof( szVtxFilename ) ); + CUtlBuffer vtxBuffer; + bool bHasVtx = ReadFileToBuffer( szVtxFilename, vtxBuffer, false, true ); + + // .vvd + char szVvdFilename[MAX_PATH]; + V_StripExtension( pMdlFilename, szVvdFilename, sizeof( szVvdFilename ) ); + V_strncat( szVvdFilename, ".vvd", sizeof( szVvdFilename ) ); + CUtlBuffer vvdBuffer; + bool bHasVvd = ReadFileToBuffer( szVvdFilename, vvdBuffer, false, true ); + + if ( bHasVtx != bHasVvd ) + { + // paired resources, either mandates the other + return false; + } + + // a .mdl file that has .vtx/.vvd gets re-processed to cull lod data + if ( bHasVtx && bHasVvd ) + { + // cull lod if needed + IMdlStripInfo *pStripInfo = NULL; + bool bResult = mdllib->StripModelBuffers( mdlBuffer, vvdBuffer, vtxBuffer, &pStripInfo ); + if ( !bResult ) + { + return false; + } + if ( pStripInfo ) + { + // .vsi + CUtlBuffer vsiBuffer; + pStripInfo->Serialize( vsiBuffer ); + pStripInfo->DeleteThis(); + + // save strip info for later processing + char szVsiFilename[MAX_PATH]; + V_StripExtension( pMdlFilename, szVsiFilename, sizeof( szVsiFilename ) ); + V_strncat( szVsiFilename, ".vsi", sizeof( szVsiFilename ) ); + WriteBufferToFile( szVsiFilename, vsiBuffer, false, WRITE_TO_DISK_ALWAYS ); + } + } + + // .ani processing may further update .mdl buffer + char szAniFilename[MAX_PATH]; + V_StripExtension( pMdlFilename, szAniFilename, sizeof( szAniFilename ) ); + V_strncat( szAniFilename, ".ani", sizeof( szAniFilename ) ); + CUtlBuffer aniBuffer; + bool bHasAni = ReadFileToBuffer( szAniFilename, aniBuffer, false, true ); + if ( bHasAni ) + { + // Some vestigal .ani files exist in the tree, only process valid .ani + if ( ((studiohdr_t*)mdlBuffer.Base())->numanimblocks != 0 ) + { + // .ani processing modifies .mdl buffer + fileSize = aniBuffer.TellPut(); + paddedSize = fileSize + BYTESWAP_ALIGNMENT_PADDING; + aniBuffer.EnsureCapacity( paddedSize ); + tempBuffer.EnsureCapacity( paddedSize ); + V_StripExtension( pMdlFilename, szAniFilename, sizeof( szAniFilename ) ); + V_strncat( szAniFilename, ".360.ani", sizeof( szAniFilename ) ); + swappedSize = StudioByteSwap::ByteswapStudioFile( szAniFilename, tempBuffer.Base(), aniBuffer.PeekGet(), fileSize, (studiohdr_t*)mdlBuffer.Base(), CompressFunc ); + if ( swappedSize > 0 ) + { + // .ani buffer is replaced with swapped data + aniBuffer.Purge(); + aniBuffer.Put( tempBuffer.Base(), swappedSize ); + WriteBufferToFile( szAniFilename, aniBuffer, false, WRITE_TO_DISK_ALWAYS ); + } + else + { + return false; + } + } + } + + // .phy + char szPhyFilename[MAX_PATH]; + V_StripExtension( pMdlFilename, szPhyFilename, sizeof( szPhyFilename ) ); + V_strncat( szPhyFilename, ".phy", sizeof( szPhyFilename ) ); + CUtlBuffer phyBuffer; + bool bHasPhy = ReadFileToBuffer( szPhyFilename, phyBuffer, false, true ); + if ( bHasPhy ) + { + fileSize = phyBuffer.TellPut(); + paddedSize = fileSize + BYTESWAP_ALIGNMENT_PADDING; + phyBuffer.EnsureCapacity( paddedSize ); + tempBuffer.EnsureCapacity( paddedSize ); + V_StripExtension( pMdlFilename, szPhyFilename, sizeof( szPhyFilename ) ); + V_strncat( szPhyFilename, ".360.phy", sizeof( szPhyFilename ) ); + swappedSize = StudioByteSwap::ByteswapStudioFile( szPhyFilename, tempBuffer.Base(), phyBuffer.PeekGet(), fileSize, (studiohdr_t*)mdlBuffer.Base(), CompressFunc ); + if ( swappedSize > 0 ) + { + // .phy buffer is replaced with swapped data + phyBuffer.Purge(); + phyBuffer.Put( tempBuffer.Base(), swappedSize ); + WriteBufferToFile( szPhyFilename, phyBuffer, false, WRITE_TO_DISK_ALWAYS ); + } + else + { + return false; + } + } + + if ( bHasVtx ) + { + fileSize = vtxBuffer.TellPut(); + paddedSize = fileSize + BYTESWAP_ALIGNMENT_PADDING; + vtxBuffer.EnsureCapacity( paddedSize ); + tempBuffer.EnsureCapacity( paddedSize ); + V_StripExtension( pMdlFilename, szVtxFilename, sizeof( szVtxFilename ) ); + V_strncat( szVtxFilename, ".dx90.360.vtx", sizeof( szVtxFilename ) ); + swappedSize = StudioByteSwap::ByteswapStudioFile( szVtxFilename, tempBuffer.Base(), vtxBuffer.PeekGet(), fileSize, (studiohdr_t*)mdlBuffer.Base(), CompressFunc ); + if ( swappedSize > 0 ) + { + // .vtx buffer is replaced with swapped data + vtxBuffer.Purge(); + vtxBuffer.Put( tempBuffer.Base(), swappedSize ); + WriteBufferToFile( szVtxFilename, vtxBuffer, false, WRITE_TO_DISK_ALWAYS ); + } + else + { + return false; + } + } + + if ( bHasVvd ) + { + fileSize = vvdBuffer.TellPut(); + paddedSize = fileSize + BYTESWAP_ALIGNMENT_PADDING; + vvdBuffer.EnsureCapacity( paddedSize ); + tempBuffer.EnsureCapacity( paddedSize ); + V_StripExtension( pMdlFilename, szVvdFilename, sizeof( szVvdFilename ) ); + V_strncat( szVvdFilename, ".360.vvd", sizeof( szVvdFilename ) ); + swappedSize = StudioByteSwap::ByteswapStudioFile( szVvdFilename, tempBuffer.Base(), vvdBuffer.PeekGet(), fileSize, (studiohdr_t*)mdlBuffer.Base(), CompressFunc ); + if ( swappedSize > 0 ) + { + // .vvd buffer is replaced with swapped data + vvdBuffer.Purge(); + vvdBuffer.Put( tempBuffer.Base(), swappedSize ); + WriteBufferToFile( szVvdFilename, vvdBuffer, false, WRITE_TO_DISK_ALWAYS ); + } + else + { + return false; + } + } + + // swap and write final .mdl + fileSize = mdlBuffer.TellPut(); + paddedSize = fileSize + BYTESWAP_ALIGNMENT_PADDING; + mdlBuffer.EnsureCapacity( paddedSize ); + tempBuffer.EnsureCapacity( paddedSize ); + char szMdlFilename[MAX_PATH]; + V_StripExtension( pMdlFilename, szMdlFilename, sizeof( szMdlFilename ) ); + V_strncat( szMdlFilename, ".360.mdl", sizeof( szMdlFilename ) ); + swappedSize = StudioByteSwap::ByteswapStudioFile( szMdlFilename, tempBuffer.Base(), mdlBuffer.PeekGet(), fileSize, NULL, CompressFunc ); + if ( swappedSize > 0 ) + { + // .mdl buffer is replaced with swapped data + mdlBuffer.Purge(); + mdlBuffer.Put( tempBuffer.Base(), swappedSize ); + WriteBufferToFile( szMdlFilename, mdlBuffer, false, WRITE_TO_DISK_ALWAYS ); + } + else + { + return false; + } + + return true; +} + +//----------------------------------------------------------------------------- +// Returns true if specified model path has a dirty sub-component, and requires +// update. +//----------------------------------------------------------------------------- +static bool ModelNeedsUpdate( const char *pMdlSourcePath ) +{ + struct ModelExtensions_t + { + const char *pSourceExtension; + const char *pTargetExtension; + bool bSourceMustExist; // if source exists, so must target + }; + ModelExtensions_t pExtensions[] = + { + { ".mdl", ".360.mdl", true }, + { ".dx90.vtx", ".dx90.360.vtx", false }, + { ".vvd", ".360.vvd", false }, + { ".phy", ".360.phy", false }, + { ".ani", ".360.ani", false }, + // vtx/vvd generate a vsi, vsi must be fresher to be valid + { ".dx90.vtx", ".vsi", false }, + { ".vvd", ".vsi", false }, + }; + + if ( g_bForce ) + { + return true; + } + + for ( int i = 0; i < ARRAYSIZE( pExtensions ); i++ ) + { + char szSourcePath[MAX_PATH]; + struct _stat sourceStatBuf; + V_strncpy( szSourcePath, pMdlSourcePath, sizeof( szSourcePath ) ); + V_SetExtension( szSourcePath, pExtensions[i].pSourceExtension, sizeof( szSourcePath ) ); + int retVal = _stat( szSourcePath, &sourceStatBuf ); + if ( retVal != 0 ) + { + // couldn't get source + if ( pExtensions[i].bSourceMustExist ) + { + return true; + } + else + { + // source is optional + continue; + } + } + + char szTargetPath[MAX_PATH]; + struct _stat targetStatBuf; + V_strncpy( szTargetPath, pMdlSourcePath, sizeof( szTargetPath ) ); + V_SetExtension( szTargetPath, pExtensions[i].pTargetExtension, sizeof( szTargetPath ) ); + if ( _stat( szTargetPath, &targetStatBuf ) != 0 ) + { + // target doesn't exist + return true; + } + + if ( difftime( sourceStatBuf.st_mtime, targetStatBuf.st_mtime ) > 0 ) + { + // source is older (thus newer), update required + return true; + } + } + + return false; +} + +static bool ModelNamesLessFunc( CUtlString const &pLHS, CUtlString const &pRHS ) +{ + return CaselessStringLessThan( pLHS.Get(), pRHS.Get() ); +} + +//----------------------------------------------------------------------------- +// Models require specialized group handling to generate intermediate lod culled +// versions that are then used as the the source for target conversion. +//----------------------------------------------------------------------------- +bool PreprocessModelFiles( CUtlVector<fileList_t> &fileList ) +{ + if ( !InitStudioByteSwap() ) + { + return false; + } + + CUtlVector< CUtlString > updateList; + CUtlRBTree< CUtlString, int > visitedModels( 0, 0, ModelNamesLessFunc ); + + char szSourcePath[MAX_PATH]; + strcpy( szSourcePath, g_szSourcePath ); + V_StripFilename( szSourcePath ); + if ( !szSourcePath[0] ) + strcpy( szSourcePath, "." ); + V_AppendSlash( szSourcePath, sizeof( szSourcePath ) ); + + char szModelName[MAX_PATH]; + for ( int i=0; i<fileList.Count(); i++ ) + { + V_strncpy( szModelName, fileList[i].fileName.String(), sizeof( szModelName ) ); + + if ( V_stristr( szModelName, ".360." ) ) + { + // must ignore any target files + continue; + } + + // want only model related files + char *pExtension = V_stristr( szModelName, ".mdl" ); + if ( !pExtension ) + { + pExtension = V_stristr( szModelName, ".dx90.vtx" ); + if ( !pExtension ) + { + pExtension = V_stristr( szModelName, ".vvd" ); + if ( !pExtension ) + { + pExtension = V_stristr( szModelName, ".ani" ); + if ( !pExtension ) + { + pExtension = V_stristr( szModelName, ".phy" ); + if ( !pExtension ) + { + pExtension = V_stristr( szModelName, ".vsi" ); + if ( !pExtension ) + { + continue; + } + } + } + } + } + } + + *pExtension = '\0'; + V_strncat( szModelName, ".mdl", sizeof( szModelName ) ); + + if ( visitedModels.Find( szModelName ) != visitedModels.InvalidIndex() ) + { + // already processed + continue; + } + visitedModels.Insert( szModelName ); + + // resolve to full source path + const char *ptr = szModelName; + if ( !strnicmp( ptr, ".\\", 2 ) ) + ptr += 2; + else if ( !strnicmp( ptr, szSourcePath, strlen( szSourcePath ) ) ) + ptr += strlen( szSourcePath ); + char szCleanName[MAX_PATH]; + strcpy( szCleanName, szSourcePath ); + strcat( szCleanName, ptr ); + char szFullSourcePath[MAX_PATH]; + _fullpath( szFullSourcePath, szCleanName, sizeof( szFullSourcePath ) ); + + // any one dirty component generates the set of all expected files + if ( ModelNeedsUpdate( szFullSourcePath ) ) + { + int index = updateList.AddToTail(); + updateList[index].Set( szFullSourcePath ); + } + } + + Msg( "\n" ); + Msg( "Model Pre Pass: Updating %d Models.\n", updateList.Count() ); + for ( int i = 0; i < updateList.Count(); i++ ) + { + if ( !GenerateModelFiles( updateList[i].String() ) ) + { + int error = g_errorList.AddToTail(); + g_errorList[error].result = false; + g_errorList[error].fileName.Set( updateList[i].String() ); + } + } + + // iterate error list + if ( g_errorList.Count() ) + { + Msg( "\n" ); + for ( int i = 0; i < g_errorList.Count(); i++ ) + { + Msg( "ERROR: could not pre-process model: %s\n", g_errorList[i].fileName.String() ); + } + } + + return true; +} diff --git a/utils/xbox/MakeGameData/MakeParticles.cpp b/utils/xbox/MakeGameData/MakeParticles.cpp new file mode 100644 index 0000000..7e6a5f1 --- /dev/null +++ b/utils/xbox/MakeGameData/MakeParticles.cpp @@ -0,0 +1,37 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: .360 file creation of PCF files +// +//=====================================================================================// + +#include "MakeGameData.h" + +bool CreateTargetFile_PCF( const char *pSourceName, const char *pTargetName, bool bWriteToZip ) +{ + DmxHeader_t header; + CDmElement *pRoot; + if ( g_pDataModel->RestoreFromFile( pSourceName, NULL, NULL, &pRoot, CR_DELETE_NEW, &header ) == DMFILEID_INVALID ) + { + Msg( "CreateTargetFile_PCF: Error reading file \"%s\"!\n", pSourceName ); + return false; + } + + const char *pOutFormat = header.formatName; + if ( !g_pDataModel->FindFormatUpdater( pOutFormat ) ) + { + pOutFormat = "dmx"; + } + + CUtlBuffer binaryBuffer; + if ( !g_pDataModel->Serialize( binaryBuffer, "binary", pOutFormat, pRoot->GetHandle() ) ) + { + Msg( "CreateTargetFile_PCF: Error writing buffer\n" ); + return false; + } + + g_pDataModel->RemoveFileId( pRoot->GetFileId() ); + + WriteBufferToFile( pTargetName, binaryBuffer, bWriteToZip, g_WriteModeForConversions ); + + return true; +} diff --git a/utils/xbox/MakeGameData/MakeResources.cpp b/utils/xbox/MakeGameData/MakeResources.cpp new file mode 100644 index 0000000..3a411c3 --- /dev/null +++ b/utils/xbox/MakeGameData/MakeResources.cpp @@ -0,0 +1,343 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: .360 file creation of miscellaneous resource and data files +// +//=====================================================================================// + +#include "MakeGameData.h" +#include "captioncompiler.h" + +//----------------------------------------------------------------------------- +// Purpose: Generate .360 compiled caption files +//----------------------------------------------------------------------------- +bool CreateTargetFile_CCDAT( const char *pSourceName, const char *pTargetName, bool bWriteToZip ) +{ + CUtlBuffer targetBuffer; + bool bOk = false; + + if ( !scriptlib->ReadFileToBuffer( pSourceName, targetBuffer ) ) + { + return false; + } + + if ( SwapClosecaptionFile( targetBuffer.Base() ) ) + { + bOk = WriteBufferToFile( pTargetName, targetBuffer, bWriteToZip, g_WriteModeForConversions ); + } + + return bOk; +} + +static bool ReslistLessFunc( CUtlString const &pLHS, CUtlString const &pRHS ) +{ + return CaselessStringLessThan( pLHS.Get(), pRHS.Get() ); +} + +//----------------------------------------------------------------------------- +// Find or Add, prevents duplicates. Returns TRUE if found. +//----------------------------------------------------------------------------- +bool FindOrAddFileToResourceList( const char *pFilename, CUtlRBTree< CUtlString, int > *pTree, bool bAdd = true ) +{ + char szOutName[MAX_PATH]; + char *pOutName; + V_strncpy( szOutName, pFilename, sizeof( szOutName ) ); + V_FixSlashes( szOutName ); + V_RemoveDotSlashes( szOutName ); + V_strlower( szOutName ); + pOutName = szOutName; + + // strip any prefixed game name + for ( int i = 0; g_GameNames[i] != NULL; i++ ) + { + size_t len = strlen( g_GameNames[i] ); + if ( !V_strnicmp( pOutName, g_GameNames[i], len ) && pOutName[len] == '\\' ) + { + // skip past game name and slash + pOutName += len+1; + break; + } + } + + if ( pTree->Find( pOutName ) != pTree->InvalidIndex() ) + { + // found + return true; + } + + if ( bAdd ) + { + pTree->Insert( pOutName ); + } + + return false; +} + +//----------------------------------------------------------------------------- +// Remove entry from dictionary, Returns TRUE if removed. +//----------------------------------------------------------------------------- +bool RemoveFileFromResourceList( const char *pFilename, CUtlRBTree< CUtlString, int > *pTree ) +{ + char szOutName[MAX_PATH]; + char *pOutName; + V_strncpy( szOutName, pFilename, sizeof( szOutName ) ); + V_FixSlashes( szOutName ); + V_RemoveDotSlashes( szOutName ); + V_strlower( szOutName ); + pOutName = szOutName; + + // strip any prefixed game name + for ( int i = 0; g_GameNames[i] != NULL; i++ ) + { + size_t len = strlen( g_GameNames[i] ); + if ( !V_strnicmp( pOutName, g_GameNames[i], len ) && pOutName[len] == '\\' ) + { + // skip past game name and slash + pOutName += len+1; + break; + } + } + + if ( pTree->Find( pOutName ) != pTree->InvalidIndex() ) + { + pTree->Remove( pOutName ); + return true; + } + + return false; +} + +//----------------------------------------------------------------------------- +// Generate a tree containing files from a reslist. Returns TRUE if successful. +//----------------------------------------------------------------------------- +bool LoadReslist( const char *pReslistName, CUtlRBTree< CUtlString, int > *pTree ) +{ + CUtlBuffer buffer; + if ( !scriptlib->ReadFileToBuffer( pReslistName, buffer, true ) ) + { + return false; + } + + char szBasename[MAX_PATH]; + V_FileBase( pReslistName, szBasename, sizeof( szBasename ) ); + + characterset_t breakSet; + CharacterSetBuild( &breakSet, "" ); + + // parse reslist + char szToken[MAX_PATH]; + char szBspName[MAX_PATH]; + szBspName[0] = '\0'; + for ( ;; ) + { + int nTokenSize = buffer.ParseToken( &breakSet, szToken, sizeof( szToken ) ); + if ( nTokenSize <= 0 ) + { + break; + } + + // reslists are pc built, filenames can be sloppy + V_strlower( szToken ); + V_FixSlashes( szToken ); + V_RemoveDotSlashes( szToken ); + + // can safely cull filetypes that are ignored by queued loader at runtime + bool bKeep = false; + const char *pExt = V_GetFileExtension( szToken ); + if ( !pExt ) + { + // unknown + continue; + } + else if ( !V_stricmp( pExt, "vmt" ) || + !V_stricmp( pExt, "vhv" ) || + !V_stricmp( pExt, "mdl" ) || + !V_stricmp( pExt, "raw" ) || + !V_stricmp( pExt, "wav" ) ) + { + bKeep = true; + } + else if ( !V_stricmp( pExt, "mp3" ) ) + { + // change to .wav + V_SetExtension( szToken, ".wav", sizeof( szToken ) ); + bKeep = true; + } + else if ( !V_stricmp( pExt, "bsp" ) ) + { + // reslists erroneously have multiple bsps + if ( !V_stristr( szToken, szBasename ) ) + { + // wrong one, cull it + continue; + } + else + { + // right one, save it + strcpy( szBspName, szToken ); + bKeep = true; + } + } + + if ( bKeep ) + { + FindOrAddFileToResourceList( szToken, pTree ); + } + } + + if ( !szBspName[0] ) + { + // reslist is not bsp derived, nothing more to do + return true; + } + + CUtlVector< CUtlString > bspList; + bool bOK = GetDependants_BSP( szBspName, &bspList ); + if ( !bOK ) + { + return false; + } + + // add all the bsp dependants to the resource list + for ( int i=0; i<bspList.Count(); i++ ) + { + FindOrAddFileToResourceList( bspList[i].String(), pTree ); + } + + // iterate all the models in the resource list, get all their dependents + CUtlVector< CUtlString > modelList; + for ( int i = pTree->FirstInorder(); i != pTree->InvalidIndex(); i = pTree->NextInorder( i ) ) + { + const char *pExt = V_GetFileExtension( pTree->Element( i ).String() ); + if ( !pExt || V_stricmp( pExt, "mdl" ) ) + { + continue; + } + + if ( !GetDependants_MDL( pTree->Element( i ).String(), &modelList ) ) + { + return false; + } + } + + // add all the model dependents to the resource list + for ( int i=0; i<modelList.Count(); i++ ) + { + FindOrAddFileToResourceList( modelList[i].String(), pTree ); + } + + // check for optional commentary, include wav dependencies + char szCommentaryName[MAX_PATH]; + V_ComposeFileName( g_szGamePath, szBspName, szCommentaryName, sizeof( szCommentaryName ) ); + V_StripExtension( szCommentaryName, szCommentaryName, sizeof( szCommentaryName ) ); + V_strncat( szCommentaryName, "_commentary.txt", sizeof( szCommentaryName ) ); + CUtlBuffer commentaryBuffer; + if ( ReadFileToBuffer( szCommentaryName, commentaryBuffer, true, true ) ) + { + // any single token may be quite large to due to text + char szCommentaryToken[8192]; + for ( ;; ) + { + int nTokenSize = commentaryBuffer.ParseToken( &breakSet, szCommentaryToken, sizeof( szCommentaryToken ) ); + if ( nTokenSize < 0 ) + { + break; + } + if ( nTokenSize > 0 && !V_stricmp( szCommentaryToken, "commentaryfile" ) ) + { + // get the commentary file + nTokenSize = commentaryBuffer.ParseToken( &breakSet, szCommentaryToken, sizeof( szCommentaryToken ) ); + if ( nTokenSize > 0 ) + { + // skip past sound chars + char *pName = szCommentaryToken; + while ( *pName && IsSoundChar( *pName ) ) + { + pName++; + } + char szWavFile[MAX_PATH]; + V_snprintf( szWavFile, sizeof( szWavFile ), "sound/%s", pName ); + FindOrAddFileToResourceList( szWavFile, pTree ); + } + } + } + } + + // check for optional blacklist + char szBlacklist[MAX_PATH]; + V_ComposeFileName( g_szGamePath, "reslistfixes_xbox.xsc", szBlacklist, sizeof( szBlacklist ) ); + CUtlBuffer blacklistBuffer; + if ( ReadFileToBuffer( szBlacklist, blacklistBuffer, true, true ) ) + { + for ( ;; ) + { + int nTokenSize = blacklistBuffer.ParseToken( &breakSet, szToken, sizeof( szToken ) ); + if ( nTokenSize <= 0 ) + { + break; + } + + bool bAdd; + if ( !V_stricmp( szToken, "-" ) ) + { + bAdd = false; + } + else if ( !V_stricmp( szToken, "+" ) ) + { + bAdd = true; + } + else + { + // bad syntax, skip line + Msg( "Bad Syntax, expecting '+' or '-' as first token in reslist fixup file '%s'.\n", szBlacklist ); + continue; + } + + // get entry + nTokenSize = blacklistBuffer.ParseToken( &breakSet, szToken, sizeof( szToken ) ); + if ( nTokenSize <= 0 ) + { + break; + } + + if ( bAdd ) + { + FindOrAddFileToResourceList( szToken, pTree ); + } + else + { + RemoveFileFromResourceList( szToken, pTree ); + } + } + } + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Generate .360 compiled reslist files +// Reslist files are processed for the unique consumption of Queued Loading. +//----------------------------------------------------------------------------- +bool CreateTargetFile_RESLST( const char *pSourceName, const char *pTargetName, bool bWriteToZip ) +{ + bool bOK = false; + + // parse reslist + CUtlRBTree< CUtlString, int > rbTree( 0, 0, ReslistLessFunc ); + if ( !LoadReslist( pSourceName, &rbTree ) ) + { + return false; + } + + CUtlBuffer targetBuffer( 0, 0, CUtlBuffer::TEXT_BUFFER ); + for ( int iIndex = rbTree.FirstInorder(); iIndex != rbTree.InvalidIndex(); iIndex = rbTree.NextInorder( iIndex ) ) + { + targetBuffer.PutChar( '\"' ); + targetBuffer.PutString( rbTree[iIndex].String() ); + targetBuffer.PutChar( '\"' ); + targetBuffer.PutString( "\n" ); + } + + bOK = WriteBufferToFile( pTargetName, targetBuffer, bWriteToZip, g_WriteModeForConversions ); + + return bOK; +}
\ No newline at end of file diff --git a/utils/xbox/MakeGameData/MakeScenes.cpp b/utils/xbox/MakeGameData/MakeScenes.cpp new file mode 100644 index 0000000..4077978 --- /dev/null +++ b/utils/xbox/MakeGameData/MakeScenes.cpp @@ -0,0 +1,40 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: .360 file creation of Choreo VCD files +// +//=====================================================================================// + +#include "MakeGameData.h" +#include "sceneimage.h" + +// memdbgon must be the last include file in a .cpp file!!! +#include "tier0/memdbgon.h" + +class CDefaultStatus : public ISceneCompileStatus +{ +public: + virtual void UpdateStatus( char const *pchSceneName, bool bQuiet, int nIndex, int nCount ) + { + if ( !bQuiet ) + { + Msg( "Scenes: Compiling: %s\n", pchSceneName ); + } + } +}; + +bool CreateSceneImageFile( char const *pchModPath, bool bWriteToZip, bool bLittleEndian, bool bQuiet, DiskWriteMode_t eWriteModeForConversions ) +{ + CUtlBuffer targetBuffer; + + const char *pFilename = bLittleEndian ? "scenes/scenes.image" : "scenes/scenes.360.image"; + + CDefaultStatus statusHelper; + + bool bSuccess = g_pSceneImage->CreateSceneImageFile( targetBuffer, pchModPath, bLittleEndian, bQuiet, &statusHelper ); + if ( bSuccess ) + { + bSuccess = WriteBufferToFile( pFilename, targetBuffer, bWriteToZip, eWriteModeForConversions ); + } + + return bSuccess; +}
\ No newline at end of file diff --git a/utils/xbox/MakeGameData/MakeScenesImage.vpc b/utils/xbox/MakeGameData/MakeScenesImage.vpc new file mode 100644 index 0000000..0361be6 --- /dev/null +++ b/utils/xbox/MakeGameData/MakeScenesImage.vpc @@ -0,0 +1,133 @@ +//----------------------------------------------------------------------------- +// MAKESCENESIMAGE.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" + +$Include "$SRCDIR\vpc_scripts\source_exe_con_base.vpc" + +$Macro GAMENAME "MakeScenesImage" + +$Configuration "Debug" +{ + $General + { + $OutputDirectory ".\Debug_$GAMENAME" + $IntermediateDirectory ".\Debug_$GAMENAME" + } +} + +$Configuration "Release" +{ + $General + { + $OutputDirectory ".\Release_$GAMENAME" + $IntermediateDirectory ".\Release_$GAMENAME" + } +} + +$Configuration +{ + $Compiler + { + $PreprocessorDefinitions "$BASE;MAKESCENESIMAGE" + $PreprocessorDefinitions "$BASE;NO_X360_XDK" [$VS2015] + $AdditionalIncludeDirectories "$BASE;$SRCDIR\x360xdk\include\win32\vs2005;$SRCDIR\game\shared" + } + + $Linker + { + $AdditionalDependencies "$BASE xgraphics.lib d3d9.lib legacy_stdio_definitions.lib" + $AdditionalDependencies "$BASE xmaencoder.lib" [!$VS2015] + $AdditionalLibraryDirectories "$BASE;$SRCDIR\x360xdk\lib\win32\vs2005" + } +} + +$Project "MakeScenesImage" +{ + $Folder "Source Files" + { + -$File "$SRCDIR\public\tier0\memoverride.cpp" + $File "MakeGameData.cpp" + $File "MakeMaps.cpp" + $File "MakeMisc.cpp" + $File "MakeModels.cpp" + $File "MakeParticles.cpp" + $File "MakeResources.cpp" + $File "MakeScenes.cpp" + $File "MakeShaders.cpp" + $File "MakeSounds.cpp" + $File "MakeTextures.cpp" + $File "MakeZip.cpp" + + $Folder "Audio" + { + $File "imaadpcm.cpp" + $File "sound_io.cpp" + $File "resample.cpp" + } + + $Folder "Public Modules" + { + $File "$SRCDIR\common\compiledcaptionswap.cpp" + $file "$SRCDIR\common\studiobyteswap.cpp" + $File "$SRCDIR\utils\common\scriplib.cpp" + $File "$SRCDIR\public\zip_utils.cpp" + $File "$SRCDIR\public\sentence.cpp" + $File "$SRCDIR\utils\common\cmdlib.cpp" + $File "$SRCDIR\public\filesystem_helpers.cpp" + $File "$SRCDIR\public\filesystem_init.cpp" + $File "$SRCDIR\utils\common\filesystem_tools.cpp" + $File "$SRCDIR\public\interpolatortypes.cpp" + } + } + + $Folder "Header Files" + { + $File "MakeGameData.h" + $File "XZipTool.h" + $File "imaadpcm.h" + $File "resample.h" + $File "$SRCDIR\public\captioncompiler.h" + $File "$SRCDIR\common\studiobyteswap.h" + $File "$SRCDIR\utils\common\scriplib.h" + $File "$SRCDIR\public\filesystem.h" + $File "$SRCDIR\public\ibsppack.h" + $File "$SRCDIR\public\sentence.h" + $File "$SRCDIR\public\studio.h" + $File "$SRCDIR\public\tier1\utlbuffer.h" + $File "$SRCDIR\public\tier1\strtools.h" + $File "$SRCDIR\public\vphysics_interface.h" + $File "$SRCDIR\public\vstdlib\vstdlib.h" + $File "$SRCDIR\public\xwvfile.h" + $File "$SRCDIR\public\zip_utils.h" + $File "$SRCDIR\game\shared\choreoscene.h" + $File "$SRCDIR\game\shared\choreoactor.h" + $File "$SRCDIR\public\filesystem_helpers.h" + $File "$SRCDIR\public\filesystem_init.h" + $File "$SRCDIR\utils\common\filesystem_tools.h" + $File "$SRCDIR\public\interpolatortypes.h" + $File "$SRCDIR\utils\common\cmdlib.h" + $File "$SRCDIR\game\shared\choreochannel.h" + $File "$SRCDIR\game\shared\choreoevent.h" + $File "$SRCDIR\public\tier1\checksum_crc.h" + $File "$SRCDIR\public\tier2\tier2.h" + $File "$SRCDIR\common\lzma\lzma.h" + } + + $Folder "Link Libraries" + { + $Lib appframework + $Lib mathlib + $Lib vtf + $Lib tier2 + $Lib choreoobjects + $Lib bitmap + $Lib datamodel + $Lib dmserializers + $Lib $LIBCOMMON\lzma + } +} diff --git a/utils/xbox/MakeGameData/MakeShaders.cpp b/utils/xbox/MakeGameData/MakeShaders.cpp new file mode 100644 index 0000000..25f51b4 --- /dev/null +++ b/utils/xbox/MakeGameData/MakeShaders.cpp @@ -0,0 +1,52 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: .360 file creation of shaders +// +//=====================================================================================// + +#include "MakeGameData.h" +#include "materialsystem/shader_vcs_version.h" + +#define SHADER_FILE_THRESHOLD 32*1024 + +//----------------------------------------------------------------------------- +// Get the preload data for a vcs file +//----------------------------------------------------------------------------- +bool GetPreloadData_VCS( const char *pFilename, CUtlBuffer &fileBufferIn, CUtlBuffer &preloadBufferOut ) +{ + ShaderHeader_t *pHeader = (ShaderHeader_t *)fileBufferIn.Base(); + + unsigned int version = BigLong( pHeader->m_nVersion ); + + // ensure caller's buffer is clean + // caller determines preload size, via TellMaxPut() + preloadBufferOut.Purge(); + + unsigned int nPreloadSize; + if ( fileBufferIn.TellMaxPut() <= SHADER_FILE_THRESHOLD ) + { + // include the whole file + nPreloadSize = fileBufferIn.TellMaxPut(); + } + else + { + if ( version < SHADER_VCS_VERSION_NUMBER ) + { + // not supporting old versions + return false; + } + + if ( version != SHADER_VCS_VERSION_NUMBER ) + { + // bad version + Msg( "Can't preload: '%s', expecting version %d got version %d\n", pFilename, SHADER_VCS_VERSION_NUMBER, version ); + return false; + } + + nPreloadSize = sizeof( ShaderHeader_t ) + BigLong( pHeader->m_nNumStaticCombos ) * sizeof( StaticComboRecord_t ); + } + + preloadBufferOut.Put( fileBufferIn.Base(), nPreloadSize ); + + return true; +}
\ No newline at end of file diff --git a/utils/xbox/MakeGameData/MakeSounds.cpp b/utils/xbox/MakeGameData/MakeSounds.cpp new file mode 100644 index 0000000..f0913ce --- /dev/null +++ b/utils/xbox/MakeGameData/MakeSounds.cpp @@ -0,0 +1,968 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: .360.WAV Creation +// +//=====================================================================================// + +#include "MakeGameData.h" +#ifndef NO_X360_XDK +#include <XMAEncoder.h> +#endif +#include "datamap.h" +#include "sentence.h" +#include "tier2/riff.h" +#include "resample.h" +#include "xwvfile.h" + +// all files are built for streaming compliance +// allows for fastest runtime loading path +// actual streaming or static state is determined by engine +#define XBOX_DVD_SECTORSIZE 2048 +#define XMA_BLOCK_SIZE 2048 // must be aligned to 1024 +#define MAX_CHUNKS 256 + +// [0,100] +#define XMA_HIGH_QUALITY 90 +#define XMA_DEFAULT_QUALITY 75 +#define XMA_MEDIUM_QUALITY 50 +#define XMA_LOW_QUALITY 25 + +typedef struct +{ + unsigned int id; + int size; + byte *pData; +} chunk_t; + +struct conversion_t +{ + const char *pSubDir; + int quality; + bool bForceTo22K; +}; + +// default conversion rules +conversion_t g_defaultConversionRules[] = +{ + // subdir quality 22Khz + { "", XMA_DEFAULT_QUALITY, false }, // default settings + { "weapons", XMA_DEFAULT_QUALITY, false }, + { "music", XMA_DEFAULT_QUALITY, false }, + { "vo", XMA_MEDIUM_QUALITY, false }, + { "npc", XMA_MEDIUM_QUALITY, false }, + { "ambient", XMA_DEFAULT_QUALITY, false }, + { "commentary", XMA_LOW_QUALITY, true }, + { NULL }, +}; + +// portal conversion rules +conversion_t g_portalConversionRules[] = +{ + // subdir quality 22Khz + { "", XMA_DEFAULT_QUALITY, false }, // default settings + { "commentary", XMA_LOW_QUALITY, true }, + { NULL }, +}; + +chunk_t g_chunks[MAX_CHUNKS]; +int g_numChunks; + +extern IFileReadBinary *g_pSndIO; + +//----------------------------------------------------------------------------- +// Purpose: chunk printer +//----------------------------------------------------------------------------- +void PrintChunk( unsigned int chunkName, int size ) +{ + char c[4]; + + for ( int i=0; i<4; i++ ) + { + c[i] = ( chunkName >> i*8 ) & 0xFF; + if ( !c[i] ) + c[i] = ' '; + } + + Msg( "%c%c%c%c: %d bytes\n", c[0], c[1], c[2], c[3], size ); +} + +//----------------------------------------------------------------------------- +// Purpose: which chunks are supported, false to ignore +//----------------------------------------------------------------------------- +bool IsValidChunk( unsigned int chunkName ) +{ + switch ( chunkName ) + { + case WAVE_DATA: + case WAVE_CUE: + case WAVE_SAMPLER: + case WAVE_VALVEDATA: + case WAVE_FMT: + return true; + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: align buffer +//----------------------------------------------------------------------------- +int AlignToBoundary( CUtlBuffer &buf, int alignment ) +{ + int curPosition; + int newPosition; + byte padByte = 0; + + buf.SeekPut( CUtlBuffer::SEEK_TAIL, 0 ); + curPosition = buf.TellPut(); + + if ( alignment <= 1 ) + return curPosition; + + // advance to aligned position + newPosition = AlignValue( curPosition, alignment ); + buf.EnsureCapacity( newPosition ); + + // write empty + for ( int i=0; i<newPosition-curPosition; i++ ) + { + buf.Put( &padByte, 1 ); + } + + return newPosition; +} + +//-------------------------------------------------------------------------------------- +// SampleToXMABlockOffset +// +// Description: converts from a sample index to a block index + the number of samples +// to offset from the beginning of the block. +// +// Parameters: +// dwSampleIndex: sample index to convert +// pdwSeekTable: pointer to the file's XMA2 seek table +// nEntries: number of DWORD entries in the seek table +// out_pBlockIndex: index of block where the desired sample lives +// out_pOffset: number of samples in the block before the desired sample +//-------------------------------------------------------------------------------------- +bool SampleToXMABlockOffset( DWORD dwSampleIndex, const DWORD *pdwSeekTable, DWORD nEntries, DWORD *out_pBlockIndex, DWORD *out_pOffset ) +{ + // Run through the seek table to find the block closest to the desired sample. + // Each seek table entry is the index (counting from the beginning of the file) + // of the first sample in the corresponding block, but there's no entry for the + // first block (since the index would always be zero). + bool bFound = false; + for ( DWORD i = 0; !bFound && i < nEntries; ++i ) + { + if ( dwSampleIndex < BigLong( pdwSeekTable[i] ) ) + { + *out_pBlockIndex = i; + bFound = true; + } + } + + // Calculate the sample offset by figuring out what the sample index of the first sample + // in the block is, then subtracting that from dwSampleIndex. + if ( bFound ) + { + DWORD dwStartOfBlock = (*out_pBlockIndex == 0) ? 0 : BigLong( pdwSeekTable[*out_pBlockIndex - 1] ); + *out_pOffset = dwSampleIndex - dwStartOfBlock; + } + + return bFound; +} + +//----------------------------------------------------------------------------- +// Compile and compress vdat +//----------------------------------------------------------------------------- +bool CompressVDAT( chunk_t *pChunk ) +{ + CSentence *pSentence; + + CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER ); + + buf.EnsureCapacity( pChunk->size ); + memcpy( buf.Base(), pChunk->pData, pChunk->size ); + buf.SeekPut( CUtlBuffer::SEEK_HEAD, pChunk->size ); + + pSentence = new CSentence(); + + // Make binary version of VDAT + // Throws all phonemes into one word, discards sentence memory, etc. + pSentence->InitFromDataChunk( buf.Base(), buf.TellPut() ); + pSentence->MakeRuntimeOnly(); + CUtlBuffer binaryBuffer( 0, 0, 0 ); + binaryBuffer.SetBigEndian( true ); + pSentence->CacheSaveToBuffer( binaryBuffer, CACHED_SENTENCE_VERSION_ALIGNED ); + delete pSentence; + + unsigned int compressedSize = 0; + unsigned char *pCompressedOutput = LZMA_OpportunisticCompress( (unsigned char *)binaryBuffer.Base(), + binaryBuffer.TellPut(), &compressedSize ); + if ( pCompressedOutput ) + { + if ( !g_bQuiet ) + { + Msg( "CompressVDAT: Compressed %d to %d\n", binaryBuffer.TellPut(), compressedSize ); + } + + free( pChunk->pData ); + pChunk->size = compressedSize; + pChunk->pData = pCompressedOutput; + } + else + { + // save binary VDAT as-is + free( pChunk->pData ); + pChunk->size = binaryBuffer.TellPut(); + pChunk->pData = (byte *)malloc( pChunk->size ); + memcpy( pChunk->pData, binaryBuffer.Base(), pChunk->size ); + } + + // success + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: read chunks into provided array +//----------------------------------------------------------------------------- +bool ReadChunks( const char *pFileName, int &numChunks, chunk_t chunks[MAX_CHUNKS] ) +{ + numChunks = 0; + + InFileRIFF riff( pFileName, *g_pSndIO ); + if ( riff.RIFFName() != RIFF_WAVE ) + { + return false; + } + + IterateRIFF walk( riff, riff.RIFFSize() ); + + while ( walk.ChunkAvailable() ) + { + chunks[numChunks].id = walk.ChunkName(); + chunks[numChunks].size = walk.ChunkSize(); + + int size = chunks[numChunks].size; + if ( walk.ChunkName() == WAVE_FMT && size < sizeof( WAVEFORMATEXTENSIBLE ) ) + { + // format chunks are variable and cast to different structures + // ensure the data footprint is at least the structure we want to manipulate + size = sizeof( WAVEFORMATEXTENSIBLE ); + } + + chunks[numChunks].pData = (byte *)malloc( size ); + memset( chunks[numChunks].pData, 0, size ); + + walk.ChunkRead( chunks[numChunks].pData ); + + numChunks++; + if ( numChunks >= MAX_CHUNKS ) + return false; + + walk.ChunkNext(); + } + + // success + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: promote pcm 8 bit to 16 bit pcm +//----------------------------------------------------------------------------- +void ConvertPCMDataChunk8To16( chunk_t *pFormatChunk, chunk_t *pDataChunk ) +{ + WAVEFORMATEX *pFormat = (WAVEFORMATEX*)pFormatChunk->pData; + + int sampleSize = ( pFormat->nChannels * pFormat->wBitsPerSample ) >> 3; + int sampleCount = pDataChunk->size / sampleSize; + int outputSize = sizeof( short ) * ( sampleCount * pFormat->nChannels ); + short *pOut = (short *)malloc( outputSize ); + + // in-place convert data from 8-bits to 16-bits + Convert8To16( pDataChunk->pData, pOut, sampleCount, pFormat->nChannels ); + + free( pDataChunk->pData ); + pDataChunk->pData = (byte *)pOut; + pDataChunk->size = outputSize; + + pFormat->wFormatTag = WAVE_FORMAT_PCM; + pFormat->nBlockAlign = 2 * pFormat->nChannels; + pFormat->wBitsPerSample = 16; + pFormat->nAvgBytesPerSec = 2 * pFormat->nSamplesPerSec * pFormat->nChannels; +} + +//----------------------------------------------------------------------------- +// Purpose: convert adpcm to 16 bit pcm +//----------------------------------------------------------------------------- +void ConvertADPCMDataChunkTo16( chunk_t *pFormatChunk, chunk_t *pDataChunk ) +{ + WAVEFORMATEX *pFormat = (WAVEFORMATEX*)pFormatChunk->pData; + + int sampleCount = ADPCMSampleCount( (byte *)pFormat, pDataChunk->pData, pDataChunk->size ); + int outputSize = sizeof( short ) * sampleCount * pFormat->nChannels; + short *pOut = (short *)malloc( outputSize ); + + // convert to PCM 16bit format + DecompressADPCMSamples( (byte*)pFormat, (byte*)pDataChunk->pData, pDataChunk->size, pOut ); + + free( pDataChunk->pData ); + pDataChunk->pData = (byte *)pOut; + pDataChunk->size = outputSize; + + pFormat->wFormatTag = WAVE_FORMAT_PCM; + pFormat->nBlockAlign = 2 * pFormat->nChannels; + pFormat->wBitsPerSample = 16; + pFormat->nAvgBytesPerSec = 2 * pFormat->nSamplesPerSec * pFormat->nChannels; + + pFormatChunk->size = 16; +} + +//----------------------------------------------------------------------------- +// Purpose: Decimate to 22K +//----------------------------------------------------------------------------- +void ConvertPCMDataChunk16To22K( chunk_t *pFormatChunk, chunk_t *pDataChunk ) +{ + WAVEFORMATEX *pFormat = (WAVEFORMATEX*)pFormatChunk->pData; + + if ( pFormat->nSamplesPerSec != 44100 || pFormat->wBitsPerSample != 16 || pFormat->wFormatTag != WAVE_FORMAT_PCM ) + { + // not in expected format + return; + } + + int sampleSize = ( pFormat->nChannels * pFormat->wBitsPerSample ) >> 3; + int sampleCount = pDataChunk->size / sampleSize; + short *pOut = (short *)malloc( sizeof( short ) * ( sampleCount * pFormat->nChannels ) ); + + DecimateSampleRateBy2_16( (short *)pDataChunk->pData, pOut, sampleCount, pFormat->nChannels ); + + free( pDataChunk->pData ); + pDataChunk->pData = (byte *)pOut; + pDataChunk->size = sizeof( short ) * ( sampleCount/2 * pFormat->nChannels ); + + pFormat->nSamplesPerSec = 22050; + pFormat->nBlockAlign = 2 * pFormat->nChannels; + pFormat->nAvgBytesPerSec = 2 * pFormat->nSamplesPerSec * pFormat->nChannels; +} + +//----------------------------------------------------------------------------- +// Purpose: determine loop start +//----------------------------------------------------------------------------- +int FindLoopStart( int samplerChunk, int cueChunk ) +{ + int loopStartFromCue = -1; + int loopStartFromSampler = -1; + + if ( cueChunk != -1 ) + { + struct cuechunk_t + { + unsigned int dwName; + unsigned int dwPosition; + unsigned int fccChunk; + unsigned int dwChunkStart; + unsigned int dwBlockStart; + unsigned int dwSampleOffset; + }; + struct cueRIFF_t + { + int cueCount; + cuechunk_t cues[1]; + }; + + cueRIFF_t *pCue = (cueRIFF_t *)g_chunks[cueChunk].pData; + if ( pCue->cueCount > 0 ) + { + loopStartFromCue = pCue->cues[0].dwSampleOffset; + } + } + + if ( samplerChunk != -1 ) + { + struct SampleLoop + { + unsigned int dwIdentifier; + unsigned int dwType; + unsigned int dwStart; + unsigned int dwEnd; + unsigned int dwFraction; + unsigned int dwPlayCount; + }; + + struct samplerchunk_t + { + unsigned int dwManufacturer; + unsigned int dwProduct; + unsigned int dwSamplePeriod; + unsigned int dwMIDIUnityNote; + unsigned int dwMIDIPitchFraction; + unsigned int dwSMPTEFormat; + unsigned int dwSMPTEOffset; + unsigned int cSampleLoops; + unsigned int cbSamplerData; + struct SampleLoop Loops[1]; + }; + + // assume that the loop end is the sample end + // assume that only the first loop is relevant + samplerchunk_t *pSampler = (samplerchunk_t *)g_chunks[samplerChunk].pData; + if ( pSampler->cSampleLoops > 0 ) + { + // only support normal forward loops + if ( pSampler->Loops[0].dwType == 0 ) + { + loopStartFromSampler = pSampler->Loops[0].dwStart; + } + } + } + + return ( max( loopStartFromCue, loopStartFromSampler ) ); +} + +//----------------------------------------------------------------------------- +// Purpose: returns chunk, -1 if not found +//----------------------------------------------------------------------------- +int FindChunk( unsigned int id ) +{ + int i; + for ( i=0; i<g_numChunks; i++ ) + { + if ( g_chunks[i].id == id ) + { + return i; + } + } + + // not found + return - 1; +} + +bool EncodeAsXMA( const char *pDebugName, CUtlBuffer &targetBuff, int quality, bool bIsVoiceOver ) +{ +#ifdef NO_X360_XDK + return false; +#else + int formatChunk = FindChunk( WAVE_FMT ); + int dataChunk = FindChunk( WAVE_DATA ); + if ( formatChunk == -1 || dataChunk == -1 ) + { + // huh? these should have been pre-validated + return false; + } + + int vdatSize = 0; + int vdatChunk = FindChunk( WAVE_VALVEDATA ); + if ( vdatChunk != -1 ) + { + vdatSize = g_chunks[vdatChunk].size; + } + + int loopStart = FindLoopStart( FindChunk( WAVE_SAMPLER ), FindChunk( WAVE_CUE ) ); + + // format structure must be expected 16 bit PCM, otherwise encoder crashes + WAVEFORMATEX *pFormat = (WAVEFORMATEX *)g_chunks[formatChunk].pData; + pFormat->nAvgBytesPerSec = pFormat->nSamplesPerSec * pFormat->nChannels * 2; + pFormat->nBlockAlign = 2 * pFormat->nChannels; + pFormat->cbSize = 0; + + XMAENCODERSTREAM inputStream = { 0 }; + + WAVEFORMATEXTENSIBLE wfx; + Assert( g_chunks[formatChunk].size <= sizeof( WAVEFORMATEXTENSIBLE ) ); + memcpy( &wfx, g_chunks[formatChunk].pData, g_chunks[formatChunk].size ); + if ( g_chunks[formatChunk].size < sizeof( WAVEFORMATEXTENSIBLE ) ) + { + memset( (unsigned char*)&wfx + g_chunks[formatChunk].size, 0, sizeof( WAVEFORMATEXTENSIBLE ) - g_chunks[formatChunk].size ); + } + + memcpy( &inputStream.Format, &wfx, sizeof( WAVEFORMATEX ) ); + inputStream.pBuffer = g_chunks[dataChunk].pData; + inputStream.BufferSize = g_chunks[dataChunk].size; + if ( loopStart != -1 ) + { + // can only support a single loop point until end of file + inputStream.LoopStart = loopStart; + inputStream.LoopLength = inputStream.BufferSize / ( pFormat->nChannels * sizeof( short ) ) - loopStart; + } + + void *pXMAData = NULL; + DWORD XMADataSize = 0; + XMA2WAVEFORMAT *pXMA2Format = NULL; + DWORD XMA2FormatSize = 0; + DWORD *pXMASeekTable = NULL; + DWORD XMASeekTableSize = 0; + HRESULT hr = S_OK; + + DWORD xmaFlags = XMAENCODER_NOFILTER; + if ( loopStart != -1 ) + { + xmaFlags |= XMAENCODER_LOOP; + } + + int numAttempts = 1; + while ( numAttempts < 10 ) + { + hr = XMA2InMemoryEncoder( 1, &inputStream, quality, xmaFlags, XMA_BLOCK_SIZE/1024, &pXMAData, &XMADataSize, &pXMA2Format, &XMA2FormatSize, &pXMASeekTable, &XMASeekTableSize ); + if ( !FAILED( hr ) ) + break; + + // make small jumps + quality += 5; + if ( quality > 100 ) + quality = 100; + if ( !g_bQuiet ) + { + Msg( "XMA Encoding Error on '%s', Attempting increasing quality to %d\n", pDebugName, quality ); + } + + numAttempts++; + + pXMAData = NULL; + XMADataSize = 0; + pXMA2Format = NULL; + XMA2FormatSize = 0; + pXMASeekTable = NULL; + XMASeekTableSize = 0; + } + + if ( FAILED( hr ) ) + { + // unrecoverable + return false; + } + else if ( numAttempts > 1 ) + { + if ( !g_bQuiet ) + { + Msg( "XMA Encoding Success on '%s' at quality %d\n", pDebugName, quality ); + } + } + + DWORD loopBlock = 0; + DWORD numLeadingSamples = 0; + DWORD numTrailingSamples = 0; + + if ( loopStart != -1 ) + { + // calculate start block/offset + DWORD loopBlockStartIndex = 0; + DWORD loopBlockStartOffset = 0; + + if ( !SampleToXMABlockOffset( BigLong( pXMA2Format->LoopBegin ), pXMASeekTable, XMASeekTableSize/sizeof( DWORD ), &loopBlockStartIndex, &loopBlockStartOffset ) ) + { + // could not determine loop point, out of range of encoded samples + Msg( "XMA Loop Encoding Error on '%s', loop %d\n", pDebugName, loopStart ); + return false; + } + + loopBlock = loopBlockStartIndex; + numLeadingSamples = loopBlockStartOffset; + + if ( BigLong( pXMA2Format->LoopEnd ) < BigLong( pXMA2Format->SamplesEncoded ) ) + { + // calculate end block/offset + DWORD loopBlockEndIndex = 0; + DWORD loopBlockEndOffset = 0; + + if ( !SampleToXMABlockOffset( BigLong( pXMA2Format->LoopEnd ), pXMASeekTable, XMASeekTableSize/sizeof( DWORD ), &loopBlockEndIndex, &loopBlockEndOffset ) ) + { + // could not determine loop point, out of range of encoded samples + Msg( "XMA Loop Encoding Error on '%s', loop %d\n", pDebugName, loopStart ); + return false; + } + + if ( loopBlockEndIndex != BigLong( pXMA2Format->BlockCount ) - 1 ) + { + // end block MUST be last block + Msg( "XMA Loop Encoding Error on '%s', block end is %d/%d\n", pDebugName, loopBlockEndOffset, BigLong( pXMA2Format->BlockCount ) ); + return false; + } + + numTrailingSamples = BigLong( pXMA2Format->SamplesEncoded ) - BigLong( pXMA2Format->LoopEnd ); + } + + // check for proper encoding range + if ( loopBlock > 32767 ) + { + Msg( "XMA Loop Encoding Error on '%s', loop block exceeds 16 bits %d\n", pDebugName, loopBlock ); + return false; + } + if ( numLeadingSamples > 32767 ) + { + Msg( "XMA Loop Encoding Error on '%s', leading samples exceeds 16 bits %d\n", pDebugName, numLeadingSamples ); + return false; + } + if ( numTrailingSamples > 32767 ) + { + Msg( "XMA Loop Encoding Error on '%s', trailing samples exceeds 16 bits %d\n", pDebugName, numTrailingSamples ); + return false; + } + } + + xwvHeader_t header; + memset( &header, 0, sizeof( xwvHeader_t ) ); + + int seekTableSize = 0; + if ( vdatSize || bIsVoiceOver ) + { + // save the optional seek table only for vdat or vo + // the seek table size is expected to be derived by this calculation + seekTableSize = ( XMADataSize / XMA_BYTES_PER_PACKET ) * sizeof( int ); + if ( seekTableSize != XMASeekTableSize ) + { + Msg( "XMA Error: Unexpected seek table calculation in '%s'!", pDebugName ); + return false; + } + } + + if ( loopStart != -1 && ( vdatSize || bIsVoiceOver ) ) + { + Msg( "XMA Warning: Unexpected loop in vo data '%s'!", pDebugName ); + + // do not write the seek table for looping sounds + seekTableSize = 0; + } + + header.id = BigLong( XWV_ID ); + header.version = BigLong( XWV_VERSION ); + header.headerSize = BigLong( sizeof( xwvHeader_t ) ); + header.staticDataSize = BigLong( seekTableSize + vdatSize ); + header.dataOffset = BigLong( AlignValue( sizeof( xwvHeader_t) + seekTableSize + vdatSize, XBOX_DVD_SECTORSIZE ) ); + header.dataSize = BigLong( XMADataSize ); + + // track the XMA number of samples that will get decoded + // which is NOT the same as what the source actually encoded + header.numDecodedSamples = pXMA2Format->SamplesEncoded; + + if ( loopStart != -1 ) + { + // the loop start is in source space (now meaningless), need the loop in XMA decoding sample space + header.loopStart = pXMA2Format->LoopBegin; + } + else + { + header.loopStart = BigLong( -1 ); + } + header.loopBlock = BigShort( (unsigned short)loopBlock ); + header.numLeadingSamples = BigShort( (unsigned short)numLeadingSamples ); + header.numTrailingSamples = BigShort( (unsigned short)numTrailingSamples ); + + header.vdatSize = BigShort( (short)vdatSize ); + header.format = XWV_FORMAT_XMA; + header.bitsPerSample = 16; + header.SetSampleRate( pFormat->nSamplesPerSec ); + header.SetChannels( pFormat->nChannels ); + header.quality = quality; + header.bHasSeekTable = ( seekTableSize != 0 ); + + // output header + targetBuff.Put( &header, sizeof( xwvHeader_t ) ); + + // output optional seek table + if ( seekTableSize ) + { + // seek table is already in big-endian format + targetBuff.Put( pXMASeekTable, seekTableSize ); + } + + // output vdat + if ( vdatSize ) + { + targetBuff.Put( g_chunks[vdatChunk].pData, g_chunks[vdatChunk].size ); + } + + AlignToBoundary( targetBuff, XBOX_DVD_SECTORSIZE ); + + // write data + targetBuff.Put( pXMAData, XMADataSize ); + + // pad to EOF + AlignToBoundary( targetBuff, XBOX_DVD_SECTORSIZE ); + + free( pXMAData ); + free( pXMA2Format ); + free( pXMASeekTable ); + + // xma encoder leaves its temporary files, we'll delete + scriptlib->DeleteTemporaryFiles( "LoopStrm*" ); + scriptlib->DeleteTemporaryFiles( "EncStrm*" ); + + return true; +#endif +} + +bool EncodeAsPCM( const char *pTargetName, CUtlBuffer &targetBuff ) +{ + int formatChunk = FindChunk( WAVE_FMT ); + int dataChunk = FindChunk( WAVE_DATA ); + if ( formatChunk == -1 || dataChunk == -1 ) + { + // huh? these should have been pre-validated + return false; + } + + WAVEFORMATEX *pFormat = (WAVEFORMATEX *)g_chunks[formatChunk].pData; + if ( pFormat->wBitsPerSample != 16 ) + { + // huh? the input is expeted to be 16 bit PCM + return false; + } + + int vdatSize = 0; + int vdatChunk = FindChunk( WAVE_VALVEDATA ); + if ( vdatChunk != -1 ) + { + vdatSize = g_chunks[vdatChunk].size; + } + + chunk_t *pDataChunk = &g_chunks[dataChunk]; + + xwvHeader_t header; + memset( &header, 0, sizeof( xwvHeader_t ) ); + + int sampleSize = pFormat->nChannels * sizeof( short ); + int sampleCount = pDataChunk->size / sampleSize; + + header.id = BigLong( XWV_ID ); + header.version = BigLong( XWV_VERSION ); + header.headerSize = BigLong( sizeof( xwvHeader_t ) ); + header.staticDataSize = BigLong( vdatSize ); + header.dataOffset = BigLong( AlignValue( sizeof( xwvHeader_t) + vdatSize, XBOX_DVD_SECTORSIZE ) ); + header.dataSize = BigLong( pDataChunk->size ); + header.numDecodedSamples = BigLong( sampleCount ); + header.loopStart = BigLong( -1 ); + header.loopBlock = 0; + header.numLeadingSamples = 0; + header.numTrailingSamples = 0; + header.vdatSize = BigShort( (short)vdatSize ); + header.format = XWV_FORMAT_PCM; + header.bitsPerSample = 16; + header.SetSampleRate( pFormat->nSamplesPerSec ); + header.SetChannels( pFormat->nChannels ); + header.quality = 100; + + // output header + targetBuff.Put( &header, sizeof( xwvHeader_t ) ); + + // output vdat + if ( vdatSize ) + { + targetBuff.Put( g_chunks[vdatChunk].pData, g_chunks[vdatChunk].size ); + } + + AlignToBoundary( targetBuff, XBOX_DVD_SECTORSIZE ); + + for ( int i = 0; i < sampleCount * pFormat->nChannels; i++ ) + { + ((short *)pDataChunk->pData)[i] = BigShort( ((short *)pDataChunk->pData)[i] ); + } + + // write data + targetBuff.Put( pDataChunk->pData, pDataChunk->size ); + + // pad to EOF + AlignToBoundary( targetBuff, XBOX_DVD_SECTORSIZE ); + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: read source, do work, and write to target +//----------------------------------------------------------------------------- +bool CreateTargetFile_WAV( const char *pSourceName, const char *pTargetName, bool bWriteToZip ) +{ + g_numChunks = 0; + + // resolve relative source to absolute path + char fullSourcePath[MAX_PATH]; + if ( _fullpath( fullSourcePath, pSourceName, sizeof( fullSourcePath ) ) ) + { + pSourceName = fullSourcePath; + } + + if ( !ReadChunks( pSourceName, g_numChunks, g_chunks ) ) + { + Msg( "No RIFF Chunks on '%s'\n", pSourceName ); + return false; + } + + int formatChunk = FindChunk( WAVE_FMT ); + if ( formatChunk == -1 ) + { + Msg( "RIFF Format Chunk not found on '%s'\n", pSourceName ); + return false; + } + + int dataChunk = FindChunk( WAVE_DATA ); + if ( dataChunk == -1 ) + { + Msg( "RIFF Data Chunk not found on '%s'\n", pSourceName ); + return false; + } + + // get the conversion rules + conversion_t *pConversion = g_defaultConversionRules; + if ( V_stristr( g_szModPath, "\\portal" ) ) + { + pConversion = g_portalConversionRules; + } + + // conversion rules are based on matching subdir + for ( int i=1; ;i++ ) + { + char subString[MAX_PATH]; + if ( !pConversion[i].pSubDir ) + { + // end of list + break; + } + + sprintf( subString, "\\%s\\", pConversion[i].pSubDir ); + if ( V_stristr( pSourceName, subString ) ) + { + // use matched conversion rules + pConversion = &pConversion[i]; + break; + } + } + + bool bForceTo22K = pConversion->bForceTo22K; + int quality = pConversion->quality; + + // cannot trust the localization depots to have matched their sources + // cannot allow 44K + if ( IsLocalizedFile( pSourceName ) ) + { + bForceTo22K = true; + } + + // classify strict vo from /sound/vo only + bool bIsVoiceOver = V_stristr( pSourceName, "\\sound\\vo\\" ) != NULL; + + // can override default settings + quality = CommandLine()->ParmValue( "-xmaquality", quality ); + if ( quality < 0 ) + quality = 0; + else if ( quality > 100 ) + quality = 100; + if ( !g_bQuiet ) + { + Msg( "Encoding quality: %d on '%s'\n", quality, pSourceName ); + } + + int vdatSize = 0; + int vdatChunk = FindChunk( WAVE_VALVEDATA ); + if ( vdatChunk != -1 ) + { + // compile to optimal block + if ( !CompressVDAT( &g_chunks[vdatChunk] ) ) + { + Msg( "Compress VDAT Error on '%s'\n", pSourceName ); + return false; + } + vdatSize = g_chunks[vdatChunk].size; + } + + // for safety (not trusting their decoding) and simplicity convert all data to 16 bit PCM before encoding + WAVEFORMATEX *pFormat = (WAVEFORMATEX *)g_chunks[formatChunk].pData; + if ( ( pFormat->wFormatTag == WAVE_FORMAT_PCM ) ) + { + if ( pFormat->wBitsPerSample == 8 ) + { + ConvertPCMDataChunk8To16( &g_chunks[formatChunk], &g_chunks[dataChunk] ); + } + } + else if ( pFormat->wFormatTag == WAVE_FORMAT_ADPCM ) + { + ConvertADPCMDataChunkTo16( &g_chunks[formatChunk], &g_chunks[dataChunk] ); + } + else + { + Msg( "Unknown RIFF Format on '%s'\n", pSourceName ); + return false; + } + + // optionally decimate to 22K + if ( pFormat->nSamplesPerSec == 44100 && bForceTo22K ) + { + if ( !g_bQuiet ) + { + Msg( "Converting to 22K '%s'\n", pSourceName ); + } + ConvertPCMDataChunk16To22K( &g_chunks[formatChunk], &g_chunks[dataChunk] ); + } + + CUtlBuffer targetBuff; + bool bSuccess; + + bSuccess = EncodeAsXMA( pSourceName, targetBuff, quality, bIsVoiceOver ); + if ( bSuccess ) + { + WriteBufferToFile( pTargetName, targetBuff, bWriteToZip, g_WriteModeForConversions ); + } + + // release data + for ( int i = 0; i < g_numChunks; i++ ) + { + free( g_chunks[i].pData ); + } + + return bSuccess; +} + +//----------------------------------------------------------------------------- +// Purpose: MP3's are already pre-converted into .360.wav +//----------------------------------------------------------------------------- +bool CreateTargetFile_MP3( const char *pSourceName, const char *pTargetName, bool bWriteToZip ) +{ + CUtlBuffer targetBuffer; + + // ignore the .mp3 source, the .360.wav target should have been pre-converted, checked in, and exist + // use the expected target as the source + if ( !scriptlib->ReadFileToBuffer( pTargetName, targetBuffer ) ) + { + // the .360.wav target does not exist + // try again using a .wav version and convert from that + char wavFilename[MAX_PATH]; + V_StripExtension( pSourceName, wavFilename, sizeof( wavFilename ) ); + V_SetExtension( wavFilename, ".wav", sizeof( wavFilename ) ); + if ( scriptlib->DoesFileExist( wavFilename ) ) + { + if ( CreateTargetFile_WAV( wavFilename, pTargetName, bWriteToZip ) ) + { + return true; + } + } + + return false; + } + + // no conversion to write, but possibly zipped + bool bSuccess = WriteBufferToFile( pTargetName, targetBuffer, bWriteToZip, WRITE_TO_DISK_NEVER ); + return bSuccess; +} + +//----------------------------------------------------------------------------- +// Get the preload data for a wav file +//----------------------------------------------------------------------------- +bool GetPreloadData_WAV( const char *pFilename, CUtlBuffer &fileBufferIn, CUtlBuffer &preloadBufferOut ) +{ + xwvHeader_t *pHeader = ( xwvHeader_t * )fileBufferIn.Base(); + if ( pHeader->id != ( unsigned int )BigLong( XWV_ID ) || + pHeader->version != ( unsigned int )BigLong( XWV_VERSION ) || + pHeader->headerSize != BigLong( sizeof( xwvHeader_t ) ) ) + { + // bad version + Msg( "Can't preload: '%s', has bad version\n", pFilename ); + return false; + } + + // ensure caller's buffer is clean + // caller determines preload size, via TellMaxPut() + preloadBufferOut.Purge(); + unsigned int preloadSize = BigLong( pHeader->headerSize ) + BigLong( pHeader->staticDataSize ); + preloadBufferOut.Put( fileBufferIn.Base(), preloadSize ); + + return true; +} diff --git a/utils/xbox/MakeGameData/MakeTextures.cpp b/utils/xbox/MakeGameData/MakeTextures.cpp new file mode 100644 index 0000000..f267367 --- /dev/null +++ b/utils/xbox/MakeGameData/MakeTextures.cpp @@ -0,0 +1,45 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: .360.VTF Creation +// +//=====================================================================================// + +#include "MakeGameData.h" +#include "vtf/vtf.h" + +//----------------------------------------------------------------------------- +// Purpose: Create the 360 VTF, use the library! +//----------------------------------------------------------------------------- +bool CreateTargetFile_VTF( const char *pSourceName, const char *pTargetName, bool bWriteToZip ) +{ + CUtlBuffer sourceBuffer; + CUtlBuffer targetBuffer; + + if ( !scriptlib->ReadFileToBuffer( pSourceName, sourceBuffer ) ) + { + return false; + } + + // using library conversion routine + bool bSuccess = ConvertVTFTo360Format( pSourceName, sourceBuffer, targetBuffer, CompressCallback ); + if ( bSuccess ) + { + bSuccess = WriteBufferToFile( pTargetName, targetBuffer, bWriteToZip, g_WriteModeForConversions ); + } + + return bSuccess; +} + +//----------------------------------------------------------------------------- +// Get the preload data for a vtf file +//----------------------------------------------------------------------------- +bool GetPreloadData_VTF( const char *pFilename, CUtlBuffer &fileBufferIn, CUtlBuffer &preloadBufferOut ) +{ + if ( !GetVTFPreload360Data( pFilename, fileBufferIn, preloadBufferOut ) ) + { + Msg( "Can't preload: '%s', has bad version\n", pFilename ); + return false; + } + + return true; +}
\ No newline at end of file diff --git a/utils/xbox/MakeGameData/MakeZip.cpp b/utils/xbox/MakeGameData/MakeZip.cpp new file mode 100644 index 0000000..69950b0 --- /dev/null +++ b/utils/xbox/MakeGameData/MakeZip.cpp @@ -0,0 +1,593 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#include "MakeGameData.h" + +static CUtlSymbolTable g_CriticalPreloadTable( 0, 32, true ); + +//----------------------------------------------------------------------------- +// Purpose: Compute preload data by file type. Calls into appropriate libraries +// to get the preload info. Libraries would use filename to generate +// the preload if there is a compilation step, otherwise the file buffer +// is a buffer loaded filename. +//----------------------------------------------------------------------------- +static bool GetPreloadBuffer( const char *pFilename, CUtlBuffer &fileBuffer, CUtlBuffer &preloadBuffer ) +{ + char fileExtension[MAX_PATH]; + Q_ExtractFileExtension( pFilename, fileExtension, sizeof( fileExtension ) ); + + // adding an entire file IS ONLY for files that are expected to be read by the game as a single read + // NOT for files that have any seek pattern + bool bAddEntireFile = false; + + // trivial small files, always add + if ( !Q_stricmp( fileExtension, "txt" ) || + !Q_stricmp( fileExtension, "dat" ) || + !Q_stricmp( fileExtension, "lst" ) || + !Q_stricmp( fileExtension, "res" ) || + !Q_stricmp( fileExtension, "vmt" ) || + !Q_stricmp( fileExtension, "cfg" ) || + !Q_stricmp( fileExtension, "bnf" ) || + !Q_stricmp( fileExtension, "rc" ) || + !Q_stricmp( fileExtension, "vbf" ) || + !Q_stricmp( fileExtension, "vfe" ) || + !Q_stricmp( fileExtension, "pcf" ) || + !Q_stricmp( fileExtension, "inf" ) ) + { + bAddEntireFile = true; + } + + // critical resources get blindly added to the preload + if ( !bAddEntireFile && ( g_CriticalPreloadTable.Find( pFilename ) != UTL_INVAL_SYMBOL ) ) + { + bAddEntireFile = true; + } + + if ( bAddEntireFile && LZMA_IsCompressed( (unsigned char *)fileBuffer.Base() ) ) + { + // sorry, not allowed to add entirely to preload if already compressed + // breaks the run-time filesystem due to inability to deliver file as-is + bAddEntireFile = false; + } + + if ( bAddEntireFile ) + { + if ( fileBuffer.TellMaxPut() >= 1*1024 ) + { + // only compress preload files of reasonable size + unsigned int compressedSize = 0; + unsigned char *pCompressedOutput = LZMA_OpportunisticCompress( (unsigned char *)fileBuffer.Base(), + fileBuffer.TellMaxPut(), &compressedSize ); + if ( pCompressedOutput ) + { + // add as compressed + preloadBuffer.EnsureCapacity( compressedSize ); + preloadBuffer.Put( pCompressedOutput, compressedSize ); + free( pCompressedOutput ); + return true; + } + } + + // add entire file to preload section + preloadBuffer.EnsureCapacity( fileBuffer.TellMaxPut() ); + preloadBuffer.Put( fileBuffer.Base(), fileBuffer.TellMaxPut() ); + return true; + } + + // Each library will fetch the optional preload data into caller's buffer + if ( !Q_stricmp( fileExtension, "wav" ) ) + { + return GetPreloadData_WAV( pFilename, fileBuffer, preloadBuffer ); + } + else if ( !Q_stricmp( fileExtension, "vtf" ) ) + { + return GetPreloadData_VTF( pFilename, fileBuffer, preloadBuffer ); + } + else if ( !Q_stricmp( fileExtension, "vcs" ) ) + { + return GetPreloadData_VCS( pFilename, fileBuffer, preloadBuffer ); + } + else if ( !Q_stricmp( fileExtension, "vhv" ) ) + { + return GetPreloadData_VHV( pFilename, fileBuffer, preloadBuffer ); + } + else if ( !Q_stricmp( fileExtension, "vtx" ) ) + { + return GetPreloadData_VTX( pFilename, fileBuffer, preloadBuffer ); + } + else if ( !Q_stricmp( fileExtension, "vvd" ) ) + { + return GetPreloadData_VVD( pFilename, fileBuffer, preloadBuffer ); + } + + // others... + return false; +} + +void SetupCriticalPreloadScript( const char *pModPath ) +{ + characterset_t breakSet; + CharacterSetBuild( &breakSet, "" ); + + // purge any prior entries + g_CriticalPreloadTable.RemoveAll(); + + // populate table + char szCriticaList[MAX_PATH]; + char szToken[MAX_PATH]; + V_ComposeFileName( pModPath, "scripts\\preload_xbox.xsc", szCriticaList, sizeof( szCriticaList ) ); + CUtlBuffer criticalListBuffer; + if ( ReadFileToBuffer( szCriticaList, criticalListBuffer, true, true ) ) + { + for ( ;; ) + { + int nTokenSize = criticalListBuffer.ParseToken( &breakSet, szToken, sizeof( szToken ) ); + if ( nTokenSize <= 0 ) + { + break; + } + + V_strlower( szToken ); + V_FixSlashes( szToken, CORRECT_PATH_SEPARATOR ); + if ( UTL_INVAL_SYMBOL == g_CriticalPreloadTable.Find( szToken ) ) + { + g_CriticalPreloadTable.AddString( szToken ); + } + } + } +} + +CXZipTool::CXZipTool() +{ + m_pZip = NULL; + m_hPreloadFile = INVALID_HANDLE_VALUE; + m_hOutputZipFile = INVALID_HANDLE_VALUE; + m_PreloadFilename[0] = '\0'; +} + +CXZipTool::~CXZipTool() +{ + Reset(); +} + +void CXZipTool::Reset() +{ + if ( m_hOutputZipFile != INVALID_HANDLE_VALUE ) + { + CloseHandle( m_hOutputZipFile ); + m_hOutputZipFile = INVALID_HANDLE_VALUE; + } + + if ( m_hPreloadFile != INVALID_HANDLE_VALUE ) + { + CloseHandle( m_hPreloadFile ); + m_hPreloadFile = INVALID_HANDLE_VALUE; + } + + if ( m_PreloadFilename[0] ) + { + DeleteFile( m_PreloadFilename ); + m_PreloadFilename[0] = '\0'; + } + + if ( m_pZip ) + { + IZip::ReleaseZip( m_pZip ); + m_pZip = NULL; + } + + m_ZipPreloadDirectoryEntries.Purge(); + m_ZipCRCList.Purge(); + m_ZipPreloadRemapEntries.Purge(); +} + +//----------------------------------------------------------------------------- +// Purpose: Add a file buffer to the zip +//----------------------------------------------------------------------------- +bool CXZipTool::AddBuffer( const char *pFilename, CUtlBuffer &fileBuffer, bool bDoPreload ) +{ + if ( !m_pZip ) + { + return false; + } + + // safely strip unecessary prefix, otherise pollutes CRC + if ( !strnicmp( pFilename, ".\\", 2 ) ) + { + pFilename += 2; + } + + // scan for CRC collision now, not at runtime + CRCEntry_t crcEntry; + crcEntry.fileNameCRC = HashStringCaselessConventional( pFilename ); + crcEntry.filename = pFilename; + int idx = m_ZipCRCList.Find( crcEntry ); + if ( -1 != idx ) + { + if ( !V_stricmp( pFilename, m_ZipCRCList[idx].filename.String() ) ) + { + // file has already been added, ignore as succesful + return true; + } + + Msg( "ERROR: CRC Collision: '%s' with '%s'\n", pFilename, m_ZipCRCList[idx].filename.String() ); + return false; + } + else + { + // add unique entry to lists + // must track filenames in a non-sort manner + m_ZipCRCList.Insert( crcEntry ); + } + + // default, no preload entry + unsigned short preloadDir = INVALID_PRELOAD_ENTRY; + + if ( bDoPreload ) + { + CUtlBuffer preloadBuffer; + bool bHasPreload = GetPreloadBuffer( pFilename, fileBuffer, preloadBuffer ); + int preloadSize = preloadBuffer.TellMaxPut(); + if ( bHasPreload && preloadSize > 0 ) + { + if ( m_ZipPreloadDirectoryEntries.Count() >= 65534 ) + { + Msg( "ERROR: Preload section FULL!, skipping %s\n", pFilename ); + return FALSE; + } + + // Initialize the entry header + ZIP_PreloadDirectoryEntry entry; + memset( &entry, 0, sizeof( entry ) ); + + entry.Length = preloadSize; + entry.DataOffset = SetFilePointer( m_hPreloadFile, 0, NULL, FILE_CURRENT ); + + // Add the directory entry to the preload table + preloadDir = m_ZipPreloadDirectoryEntries.AddToTail( entry ); + + // Append the preload data to the preload file + DWORD numBytesWritten; + BOOL bOK = WriteFile( m_hPreloadFile, preloadBuffer.Base(), preloadSize, &numBytesWritten, NULL ); + if ( !bOK || preloadSize != numBytesWritten ) + { + Msg( "ERROR: writing %d preload bytes of '%s'\n", preloadSize, pFilename ); + return false; + } + + if ( !g_bQuiet ) + { + // Spew it + if ( LZMA_IsCompressed( (unsigned char *)preloadBuffer.Base() ) ) + { + unsigned int actualSize = LZMA_GetActualSize( (unsigned char *)preloadBuffer.Base() ); + Msg( "Preload: '%s': Compressed:%u Actual:%u\n", pFilename, preloadSize, actualSize ); + } + else + { + Msg( "Preload: '%s': Length:%u\n", pFilename, preloadSize ); + } + } + } + } + + unsigned int fileSize = fileBuffer.TellMaxPut(); + if ( fileSize > 0 ) + { + // order in zip is sorted, not sequential + m_pZip->AddBufferToZip( pFilename, fileBuffer.Base(), fileSize, false ); + + // track the file in the zip directory to it's preload entry + // order in preload is sequential as buffers are added + preloadRemap_t remap; + remap.filename = pFilename; + remap.preloadDirIndex = preloadDir; + m_ZipPreloadRemapEntries.AddToTail( remap ); + + if ( !g_bQuiet ) + { + Msg( "File: '%s': Length:%u\n", pFilename, fileSize ); + } + } + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Load a file and add it to the zip +//----------------------------------------------------------------------------- +bool CXZipTool::AddFile( const char *pFilename, bool bDoPreload ) +{ + if ( !m_pZip ) + { + return false; + } + + FILE* pFile = fopen( pFilename, "rb" ); + if( !pFile ) + { + Msg( "ERROR: failed to open file: '%s'\n", pFilename ); + return false; + } + + // Get the length of the file + fseek( pFile, 0, SEEK_END ); + unsigned fileSize = ftell( pFile ); + fseek( pFile, 0, SEEK_SET); + + // read file to buffer + CUtlBuffer fileBuffer; + fileBuffer.EnsureCapacity( fileSize ); + fread( fileBuffer.Base(), fileSize, 1, pFile ); + fclose( pFile ); + fileBuffer.SeekPut( CUtlBuffer::SEEK_HEAD, fileSize ); + + return AddBuffer( pFilename, fileBuffer, bDoPreload ); +} + +//----------------------------------------------------------------------------- +// Purpose: Add the preload section and save out the zip file +//----------------------------------------------------------------------------- +bool CXZipTool::End() +{ + if ( !m_pZip ) + { + return false; + } + + // Add the preload section to the zip + if ( m_ZipPreloadDirectoryEntries.Count() ) + { + CUtlBuffer sectionBuffer; + CByteswap byteSwap; + + // pc tools write 360 native data + byteSwap.ActivateByteSwapping( IsPC() ); + + // determine the preload data footprint + unsigned int preloadDataSize = SetFilePointer( m_hPreloadFile, 0, NULL, FILE_CURRENT ); + + // finalize header + m_ZipPreloadHeader.DirectoryEntries = m_ZipPreloadRemapEntries.Count(); + m_ZipPreloadHeader.PreloadDirectoryEntries = m_ZipPreloadDirectoryEntries.Count(); + + // determine the total section size ( treated as a single file inside zip ) + unsigned int sectionSize = sizeof( ZIP_PreloadHeader ) + + m_ZipPreloadHeader.PreloadDirectoryEntries * sizeof( ZIP_PreloadDirectoryEntry ) + + m_ZipPreloadHeader.DirectoryEntries * sizeof( unsigned short ) + + preloadDataSize; + sectionSize = AlignValue( sectionSize, m_ZipPreloadHeader.Alignment ); + sectionBuffer.EnsureCapacity( sectionSize ); + + // save data in order + // save the header + byteSwap.SwapFieldsToTargetEndian( &m_ZipPreloadHeader ); + sectionBuffer.Put( &m_ZipPreloadHeader, sizeof( ZIP_PreloadHeader ) ); + + // fixup and save the preload directory + for ( int i=0; i<m_ZipPreloadDirectoryEntries.Count(); i++ ) + { + ZIP_PreloadDirectoryEntry entry = m_ZipPreloadDirectoryEntries[i]; + byteSwap.SwapFieldsToTargetEndian( &entry ); + sectionBuffer.Put( &entry, sizeof( ZIP_PreloadDirectoryEntry ) ); + } + + // generate remap table + char fileName[MAX_PATH]; + int fileSize; + int zipIndex = -1; + unsigned short *pRemapTable = (unsigned short *)malloc( m_ZipPreloadRemapEntries.Count() * sizeof( unsigned short ) ); + for ( int i=0; i<m_ZipPreloadRemapEntries.Count(); i++ ) + { + // zip files get iterated in the same order they are serialized to disk + fileName[0] = '\0'; + fileSize = 0; + zipIndex = m_pZip->GetNextFilename( zipIndex, fileName, sizeof( fileName ), fileSize ); + + // find the file in the preload remap table + bool bFound = false; + int j; + for ( j=0; j<m_ZipPreloadRemapEntries.Count(); j++ ) + { + if ( !Q_stricmp( fileName, m_ZipPreloadRemapEntries[j].filename.String() ) ) + { + bFound = true; + break; + } + } + if ( !bFound ) + { + // shouldn't happen, every file in the zip has a matching preload remap entry, that is valid or marked invalid + Msg( "ERROR: file '%s' was expected to have an entry in preload table\n", fileName ); + } + + // the remap table is used to go find a file's preload data (if available) + pRemapTable[i] = m_ZipPreloadRemapEntries[j].preloadDirIndex; + } + for ( int i=0; i<m_ZipPreloadRemapEntries.Count(); i++ ) + { + unsigned short s = pRemapTable[i]; + sectionBuffer.PutShort( BigShort( s ) ); + } + free( pRemapTable ); + + // get and save preload data + void *pPreloadData = malloc( preloadDataSize ); + SetFilePointer( m_hPreloadFile, 0, NULL, FILE_BEGIN ); + DWORD numBytesRead; + BOOL bOK = ReadFile( m_hPreloadFile, pPreloadData, preloadDataSize, &numBytesRead, NULL ); + if ( !bOK || numBytesRead != preloadDataSize ) + { + Msg( "ERROR: failed to read %d bytes from temporary preload file\n", preloadDataSize ); + } + CloseHandle( m_hPreloadFile ); + m_hPreloadFile = INVALID_HANDLE_VALUE; + + sectionBuffer.Put( pPreloadData, preloadDataSize ); + free( pPreloadData ); + + // cannot have written more than was pre-calced, unless code was broken + Assert( (unsigned int)sectionBuffer.TellMaxPut() <= sectionSize ); + while( (unsigned int)sectionBuffer.TellMaxPut() < sectionSize ) + { + // pad to final alignment + sectionBuffer.PutChar( 0 ); + } + + m_pZip->AddBufferToZip( PRELOAD_SECTION_NAME, sectionBuffer.Base(), sectionBuffer.TellMaxPut(), false ); + } + else + { + // Clear the preload section placeholder + m_pZip->RemoveFileFromZip( PRELOAD_SECTION_NAME ); + } + + m_pZip->SaveToDisk( m_hOutputZipFile ); + + Reset(); + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Create the zip file +//----------------------------------------------------------------------------- +bool CXZipTool::Begin( const char *pZipFileName, unsigned int alignment ) +{ + // get the volume of the target zip + char drivePath[MAX_PATH]; + _splitpath( pZipFileName, drivePath, NULL, NULL, NULL ); + + m_pZip = IZip::CreateZip( drivePath, true ); + + if ( alignment ) + { + // making an aligned zip that uses an optimized (but incompatible) format + m_pZip->ForceAlignment( true, false, alignment ); + } + + // Open the output file + m_hOutputZipFile = CreateFile( pZipFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); + if ( m_hOutputZipFile == INVALID_HANDLE_VALUE ) + { + Msg( "ERROR: failed to create zip file '%s'\n", pZipFileName ); + return false; + } + + // Create a temporary file for storing the preloaded data + scriptlib->MakeTemporaryFilename( g_szModPath, m_PreloadFilename, sizeof( m_PreloadFilename ) ); + m_hPreloadFile = CreateFile( m_PreloadFilename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); + if ( m_hPreloadFile == INVALID_HANDLE_VALUE ) + { + Msg( "ERROR: failed to create temporary file '%s' for preload data\n", m_PreloadFilename ); + CloseHandle( m_hOutputZipFile ); + m_hOutputZipFile = INVALID_HANDLE_VALUE; + return false; + } + memset( &m_ZipPreloadHeader, 0, sizeof( ZIP_PreloadHeader ) ); + + m_ZipPreloadHeader.Version = PRELOAD_HDR_VERSION; + m_ZipPreloadHeader.Alignment = alignment; + + // Add a placeholder for the preload section + m_pZip->AddBufferToZip( PRELOAD_SECTION_NAME, NULL, 0, false ); + preloadRemap_t remap; + remap.filename = PRELOAD_SECTION_NAME; + remap.preloadDirIndex = INVALID_PRELOAD_ENTRY; + m_ZipPreloadRemapEntries.AddToTail( remap ); + + return true; +} + +//----------------------------------------------------------------------------- +// Purpose: Dump the preload contents +//----------------------------------------------------------------------------- +void CXZipTool::SpewPreloadInfo( const char *pZipName ) +{ + IZip *pZip = IZip::CreateZip( NULL, true ); + + HANDLE hZipFile = pZip->ParseFromDisk( pZipName ); + if ( !hZipFile ) + { + Msg( "Bad or missing zip file, failed to open '%s'\n", pZipName ); + return; + } + + CUtlBuffer preloadBuffer; + if ( !pZip->ReadFileFromZip( hZipFile, PRELOAD_SECTION_NAME, false, preloadBuffer ) ) + { + Msg( "No preload info for '%s'\n", pZipName ); + return; + } + + preloadBuffer.ActivateByteSwapping( IsPC() ); + + ZIP_PreloadHeader header; + preloadBuffer.GetObjects( &header ); + + // get the dir table + ZIP_PreloadDirectoryEntry *pDir = (ZIP_PreloadDirectoryEntry *)malloc( header.PreloadDirectoryEntries * sizeof( ZIP_PreloadDirectoryEntry ) ); + preloadBuffer.GetObjects( pDir, header.PreloadDirectoryEntries ); + + // get the remap table + unsigned short *pRemap = (unsigned short *)malloc( header.DirectoryEntries * sizeof( unsigned short ) ); + for ( unsigned int i = 0; i < header.DirectoryEntries; i++ ) + { + pRemap[i] = preloadBuffer.GetShort(); + } + + int zipIndex = -1; + int fileSize; + char fileName[MAX_PATH]; + + // iterate preload entries sequentially + CUtlDict< unsigned int, int > sizes( true ); + for ( unsigned int i = 0; i < header.DirectoryEntries; i++ ) + { + fileName[0] = '\0'; + fileSize = 0; + zipIndex = pZip->GetNextFilename( zipIndex, fileName, sizeof( fileName ), fileSize ); + + unsigned short zipPreloadDirIndex = pRemap[i]; + if ( zipPreloadDirIndex == INVALID_PRELOAD_ENTRY ) + { + continue; + } + + Msg( "Offset: 0x%8.8x Length: %5d %s (%d)\n", pDir[zipPreloadDirIndex].DataOffset, pDir[zipPreloadDirIndex].Length, fileName, fileSize ); + + // total preload sizes by extension + const char *pExt = V_GetFileExtension( fileName ); + if ( !pExt ) + { + pExt = "???"; + } + int iIndex = sizes.Find( pExt ); + if ( iIndex == sizes.InvalidIndex() ) + { + iIndex = sizes.Insert( pExt ); + sizes[iIndex] = 0; + } + sizes[iIndex] += pDir[zipPreloadDirIndex].Length; + } + + Msg( "\n" ); + Msg( "Preload Size: %.2f MB\n", (float)preloadBuffer.TellMaxPut()/(1024.0f * 1024.0f) ); + Msg( "Zip Entries: %d\n", header.DirectoryEntries ); + Msg( "Preload Entries: %d\n", header.PreloadDirectoryEntries ); + + // dump each extension's total size, necessary for debugging who is the largest contributor + for ( int i = 0; i < sizes.Count(); i++ ) + { + Msg( "Extension: '%3s' %d bytes (%.2f%s)\n", sizes.GetElementName( i ), sizes[i], (float)sizes[i]/(float)preloadBuffer.TellMaxPut() * 100.0f, "%%" ); + } + Msg( "\n" ); + + free( pRemap ); + free( pDir ); + + IZip::ReleaseZip( pZip ); +} diff --git a/utils/xbox/MakeGameData/XZipTool.h b/utils/xbox/MakeGameData/XZipTool.h new file mode 100644 index 0000000..41713cf --- /dev/null +++ b/utils/xbox/MakeGameData/XZipTool.h @@ -0,0 +1,61 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=====================================================================================// + +#pragma once + +#include <stdio.h> +#include "utlbuffer.h" +#include "zip_uncompressed.h" +#include "generichash.h" +#include "zip_utils.h" +#include "byteswap.h" +#include "tier1/UtlVector.h" +#include "UtlSortVector.h" + +struct CRCEntry_t +{ + unsigned int fileNameCRC; + CUtlString filename; +}; + +struct preloadRemap_t +{ + CUtlString filename; + unsigned short preloadDirIndex; +}; + +class CZipCRCLessFunc +{ +public: + bool Less( CRCEntry_t const& src1, CRCEntry_t const& src2, void *pCtx ) + { + return ( src1.fileNameCRC < src2.fileNameCRC ); + } +}; + +class CXZipTool +{ +public: + CXZipTool(); + ~CXZipTool(); + + void Reset(); + bool Begin( const char* pFileName, unsigned int alignment = 0 ); + bool End(); + bool AddBuffer( const char* pFileName, CUtlBuffer &buffer, bool bPreload = true ); + bool AddFile( const char* pFileName, bool bPreload = true ); + void SpewPreloadInfo( const char *pZipName ); + +private: + IZip *m_pZip; + char m_PreloadFilename[MAX_PATH]; + HANDLE m_hPreloadFile; + HANDLE m_hOutputZipFile; + ZIP_PreloadHeader m_ZipPreloadHeader; + CUtlVector< ZIP_PreloadDirectoryEntry > m_ZipPreloadDirectoryEntries; + CUtlSortVector< CRCEntry_t, CZipCRCLessFunc > m_ZipCRCList; + CUtlVector< preloadRemap_t > m_ZipPreloadRemapEntries; +};
\ No newline at end of file diff --git a/utils/xbox/MakeGameData/imaadpcm.cpp b/utils/xbox/MakeGameData/imaadpcm.cpp new file mode 100644 index 0000000..6648669 --- /dev/null +++ b/utils/xbox/MakeGameData/imaadpcm.cpp @@ -0,0 +1,1531 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +/*************************************************************************** + * + * Copyright (C) 2001 Microsoft Corporation. All Rights Reserved. + * + * File: imaadpcm.cpp + * Content: IMA ADPCM CODEC. + * History: + * Date By Reason + * ==== == ====== + * 04/29/01 dereks Created. + * 06/12/01 jharding Adapted for command-line encode + * + ****************************************************************************/ + +#include <stdio.h> +#include <wtypes.h> +#include <assert.h> +#include "imaadpcm.h" + +// 1/2 the range of the searchable step indices +// for a particular block when optimizing on a +// per-block basis. Widening or narrowing this +// range may produce better/worse encodings. +// Experimentation may be necessary. Higher values +// cause each block to be encoded better, but may +// produce popping in particularly fast attacks across +// blocks, while smaller values limit the number +// of encodings you consider +#define STEPINDEXSEARCHRANGE (24) + +/**************************************************************************** + * + * CImaAdpcmCodec + * + * Description: + * Object constructor. + * + * Arguments: + * (void) + * + * Returns: + * (void) + * + ****************************************************************************/ + +// +// This array is used by NextStepIndex to determine the next step index to use. +// The step index is an index to the m_asStep[] array, below. +// + +const short CImaAdpcmCodec::m_asNextStep[16] = +{ + -1, -1, -1, -1, 2, 4, 6, 8, + -1, -1, -1, -1, 2, 4, 6, 8 +}; + +// +// This array contains the array of step sizes used to encode the ADPCM +// samples. The step index in each ADPCM block is an index to this array. +// + +const short CImaAdpcmCodec::m_asStep[89] = +{ + 7, 8, 9, 10, 11, 12, 13, + 14, 16, 17, 19, 21, 23, 25, + 28, 31, 34, 37, 41, 45, 50, + 55, 60, 66, 73, 80, 88, 97, + 107, 118, 130, 143, 157, 173, 190, + 209, 230, 253, 279, 307, 337, 371, + 408, 449, 494, 544, 598, 658, 724, + 796, 876, 963, 1060, 1166, 1282, 1411, + 1552, 1707, 1878, 2066, 2272, 2499, 2749, + 3024, 3327, 3660, 4026, 4428, 4871, 5358, + 5894, 6484, 7132, 7845, 8630, 9493, 10442, + 11487, 12635, 13899, 15289, 16818, 18500, 20350, + 22385, 24623, 27086, 29794, 32767 +}; + +CImaAdpcmCodec::CImaAdpcmCodec +( + void +) +{ +} + + +/**************************************************************************** + * + * ~CImaAdpcmCodec + * + * Description: + * Object destructor. + * + * Arguments: + * (void) + * + * Returns: + * (void) + * + ****************************************************************************/ + +CImaAdpcmCodec::~CImaAdpcmCodec +( + void +) +{ +} + + +/**************************************************************************** + * + * Initialize + * + * Description: + * Initializes the object. + * + * Arguments: + * LPCIMAADPCMWAVEFORMAT [in]: encoded data format. + * BOOL [in]: TRUE to initialize the object as an encoder. + * + * Returns: + * BOOL: TRUE on success. + * + ****************************************************************************/ + +BOOL +CImaAdpcmCodec::Initialize +( + LPCIMAADPCMWAVEFORMAT pwfxEncode, + CODEC_MODE cmCodecMode +) +{ + static const LPFNIMAADPCMCONVERT apfnConvert[2][2] = + { + { + DecodeM16, + DecodeS16 + }, + { + EncodeM16, + EncodeS16 + } + }; + + if(!IsValidImaAdpcmFormat(pwfxEncode)) + { + return FALSE; + } + + // + // Save the format data + // + + m_wfxEncode = *pwfxEncode; + m_cmCodecMode = cmCodecMode; + + // + // Set up the conversion function + // + + m_pfnConvert = apfnConvert[!(m_cmCodecMode == CODEC_MODE_DECODE)][m_wfxEncode.wfx.nChannels - 1]; + + // + // Initialize the stepping indices + // + + m_nStepIndexL = m_nStepIndexR = 0; + + return TRUE; +} + + +/**************************************************************************** + * + * Convert + * + * Description: + * Converts data from the source to destination format. + * + * Arguments: + * LPCVOID [in]: source buffer. + * LPVOID [out]: destination buffer. + * UINT [in]: block count. + * + * Returns: + * BOOL: TRUE on success. + * + ****************************************************************************/ + +BOOL +CImaAdpcmCodec::Convert +( + LPCVOID pvSrc, + LPVOID pvDst, + UINT cBlocks +) +{ + // Array of decoders + static const LPFNIMAADPCMCONVERT apfnDecoders[2] = + { + DecodeM16, + DecodeS16 + }; + + // Both destination and source block sizes + DWORD dwSrcBlockSize = m_wfxEncode.wfx.nChannels * m_wfxEncode.wSamplesPerBlock * sizeof(short); + DWORD dwDstBlockSize = m_wfxEncode.wfx.nBlockAlign; + + // Zero out the output + ZeroMemory( pvDst, cBlocks * dwDstBlockSize ); + + switch( m_cmCodecMode ) + { + case CODEC_MODE_DECODE: + // If we are decoding, just do it + return m_pfnConvert( (LPBYTE)pvSrc, (LPBYTE)pvDst, cBlocks, m_wfxEncode.wfx.nBlockAlign, m_wfxEncode.wSamplesPerBlock, &m_nStepIndexL, &m_nStepIndexR ); + + case CODEC_MODE_ENCODE_NORMAL: + // Normal encode + // We have some output right now, so this becomes a separate case. + // Otherwise, it would be the same as CODEC_MODE_DECODE + { + printf("Using normal encoding...\n"); + + // Allocate temporary buffers + LPBYTE pvDecoded = new BYTE[cBlocks * dwSrcBlockSize]; + if( !pvDecoded ) + return FALSE; + + // Find the decoder + LPFNIMAADPCMCONVERT pfnOppConvert; + pfnOppConvert = apfnDecoders[m_wfxEncode.wfx.nChannels - 1]; + + // Encode the stream + if( !m_pfnConvert( (LPBYTE)pvSrc, (LPBYTE)pvDst, cBlocks, m_wfxEncode.wfx.nBlockAlign, m_wfxEncode.wSamplesPerBlock, &m_nStepIndexL, &m_nStepIndexR ) ) + { + delete[] pvDecoded; + return FALSE; + } + + // Decode it back + if( !pfnOppConvert( (LPBYTE)pvDst, pvDecoded, cBlocks, m_wfxEncode.wfx.nBlockAlign, XBOX_ADPCM_SAMPLES_PER_BLOCK, &m_nStepIndexL, &m_nStepIndexR ) ) + { + delete[] pvDecoded; + return FALSE; + } + + // Report the normal difference + printf( "Difference between original and decoded streams: 0x%I64x\n", + CalcDifference( (LPBYTE)pvSrc, pvDecoded, cBlocks, cBlocks, dwSrcBlockSize ) ); + + delete[] pvDecoded; + } + break; + + case CODEC_MODE_ENCODE_OPTIMIZE_WHOLE_FILE: + // Optimize whole file encode + // Encode the file with each possible starting step index + // and pick the best one + { + printf("Using whole file encoding...\n"); + + // Allocate temporary buffers + LPBYTE pvTempDst = new BYTE[cBlocks * dwDstBlockSize]; + if(!pvTempDst) + return FALSE; + + LPBYTE pvDecoded = new BYTE[cBlocks * dwSrcBlockSize]; + if(!pvDecoded) + { + delete[] pvTempDst; + return FALSE; + } + + // Find the decoder + LPFNIMAADPCMCONVERT pfnOppConvert; + pfnOppConvert = apfnDecoders[m_wfxEncode.wfx.nChannels - 1]; + + // Keep track of the best encoding, as well as the chosen step index + ULONGLONG ullLeastDiff = (ULONGLONG)-1; + UINT uChosen = (UINT)-1; + + // Encode the entire stream with each step index and choose the best one + for( UINT i = 0; i < ARRAYSIZE(m_asStep); ++i ) + { + ZeroMemory( pvTempDst, cBlocks * dwDstBlockSize ); + ZeroMemory( pvDecoded, cBlocks * dwSrcBlockSize ); + + // Encode + m_nStepIndexL = m_nStepIndexR = i; + if( !m_pfnConvert( (LPBYTE)pvSrc, pvTempDst, cBlocks, m_wfxEncode.wfx.nBlockAlign, m_wfxEncode.wSamplesPerBlock, &m_nStepIndexL, &m_nStepIndexR ) ) + continue; + + // Decode + if( !pfnOppConvert( pvTempDst, pvDecoded, cBlocks, m_wfxEncode.wfx.nBlockAlign, XBOX_ADPCM_SAMPLES_PER_BLOCK, &m_nStepIndexL, &m_nStepIndexR ) ) + continue; + + // Diff + ULONGLONG ullDiff = CalcDifference( (LPBYTE)pvSrc, pvDecoded, cBlocks, cBlocks, dwSrcBlockSize ); + if( ullDiff < ullLeastDiff ) + { + ullLeastDiff = ullDiff; + uChosen = i; + CopyMemory( (LPBYTE)pvDst, pvTempDst, cBlocks * dwDstBlockSize ); + } + } + + // Report the optimized difference + printf( "Difference between original and decoded streams: 0x%I64x\n", ullLeastDiff ); + printf( "Step index chosen: %d\n", uChosen ); + + delete[] pvTempDst; + delete[] pvDecoded; + } + break; + + case CODEC_MODE_ENCODE_OPTIMIZE_EACH_BLOCK: + // Optimize per block encode + // Encode each block within the file with each + // possible starting step index and pick the + // best one for each block + { + printf("Using per-block encoding\n\n"); + + // Allocate temporary buffers + LPBYTE pvTempDst = new BYTE[dwDstBlockSize]; + if( !pvTempDst ) + return FALSE; + + LPBYTE pvDecoded = new BYTE[dwSrcBlockSize]; + if( !pvDecoded ) + { + delete[] pvTempDst; + return FALSE; + } + + // Find the decoder + LPFNIMAADPCMCONVERT pfnOppConvert; + pfnOppConvert = apfnDecoders[m_wfxEncode.wfx.nChannels - 1]; + + // We keep track of the best step index of the previous block + // This enables us to search a small range of values close to + // this value (the size of 2*STEPINDEXSEARCHRANGE) + // To begin, the previous block's best step index was -1. + INT iPreviousBestStepIndex = -1; + + for( UINT c = 0; c < cBlocks; ++c ) + { + ULONGLONG ullLeastDiff = (ULONGLONG)-1; + INT iThisBestStepIndex = -1; + INT iStartIndex, iStopIndex; + + // Setup the start/stop indices properly + if( iPreviousBestStepIndex == -1 ) + { + // If the previous best step index is -1, + // then we haven't yet encoded a block. Search + // through the entire range of step indices, + // rather than just in a limited range + iStartIndex = 0; + iStopIndex = ARRAYSIZE( m_asStep ); + } + else + { + // Keep the range of indices to search limited + // to around the previously chosen step index + iStartIndex = iPreviousBestStepIndex - STEPINDEXSEARCHRANGE; + iStopIndex = iPreviousBestStepIndex + STEPINDEXSEARCHRANGE + 1; + } + + // Try each step index in the searchable range and choose the best one + // for this block + for( INT i = iStartIndex; i < iStopIndex; ++i ) + { + // Don't consider anything out of range + if( i < 0 || i >= ARRAYSIZE( m_asStep ) ) + continue; + + // Zero out the temporary buffers + ZeroMemory( pvTempDst, dwDstBlockSize ); + ZeroMemory( pvDecoded, dwSrcBlockSize ); + + // Encode + m_nStepIndexL = m_nStepIndexR = i; + if( !m_pfnConvert( (LPBYTE)pvSrc + c*dwSrcBlockSize, pvTempDst, 1, m_wfxEncode.wfx.nBlockAlign, m_wfxEncode.wSamplesPerBlock, &m_nStepIndexL, &m_nStepIndexR ) ) + continue; + + // Decode + if( !pfnOppConvert( pvTempDst, pvDecoded, 1, m_wfxEncode.wfx.nBlockAlign, XBOX_ADPCM_SAMPLES_PER_BLOCK, &m_nStepIndexL, &m_nStepIndexR ) ) + continue; + + // Diff + ULONGLONG ullDiff = CalcDifference( (LPBYTE)pvSrc + c*dwSrcBlockSize, pvDecoded, 1, cBlocks, dwSrcBlockSize ); + if( ullDiff < ullLeastDiff ) + { + ullLeastDiff = ullDiff; + iThisBestStepIndex = i; + CopyMemory( (LPBYTE)pvDst + c*dwDstBlockSize, (LPBYTE)pvTempDst, dwDstBlockSize ); + } + } + + // Save the best step index for this block + iPreviousBestStepIndex = iThisBestStepIndex; + } + + delete[] pvTempDst; + delete[] pvDecoded; + + // Report on the optimized difference + pvDecoded = new BYTE[cBlocks * dwSrcBlockSize]; + pfnOppConvert( (LPBYTE)pvDst, pvDecoded, cBlocks, m_wfxEncode.wfx.nBlockAlign, XBOX_ADPCM_SAMPLES_PER_BLOCK, &m_nStepIndexL, &m_nStepIndexR ); + printf( "Difference between original and decoded streams: 0x%I64x\n", CalcDifference( (LPBYTE)pvSrc, pvDecoded, cBlocks, cBlocks, dwSrcBlockSize ) ); + + delete[] pvDecoded; + } + break; + } + + return TRUE; +} + + +/**************************************************************************** + * + * Reset + * + * Description: + * Resets the conversion operation. + * + * Arguments: + * (void) + * + * Returns: + * (void) + * + ****************************************************************************/ + +void +CImaAdpcmCodec::Reset +( + void +) +{ + // + // Reset the stepping indices + // + + m_nStepIndexL = m_nStepIndexR = 0; +} + + +/**************************************************************************** + * + * GetEncodeAlignment + * + * Description: + * Gets the alignment of an encoded buffer. + * + * Arguments: + * (void) + * + * Returns: + * WORD: alignment, in bytes. + * + ****************************************************************************/ + +WORD +CImaAdpcmCodec::GetEncodeAlignment +( + void +) +{ + return m_wfxEncode.wfx.nBlockAlign; +} + + +/**************************************************************************** + * + * GetDecodeAlignment + * + * Description: + * Gets the alignment of a decoded buffer. + * + * Arguments: + * (void) + * + * Returns: + * DWORD: alignment, in bytes. + * + ****************************************************************************/ + +WORD +CImaAdpcmCodec::GetDecodeAlignment +( + void +) +{ + return m_wfxEncode.wSamplesPerBlock * m_wfxEncode.wfx.nChannels * IMAADPCM_PCM_BITS_PER_SAMPLE / 8; +} + + +/**************************************************************************** + * + * CalculateEncodeAlignment + * + * Description: + * Calculates an encoded data block alignment based on a PCM sample + * count and an alignment multiplier. + * + * Arguments: + * WORD [in]: channel count. + * WORD [in]: PCM samples per block. + * + * Returns: + * WORD: alignment, in bytes. + * + ****************************************************************************/ + +WORD +CImaAdpcmCodec::CalculateEncodeAlignment +( + WORD nChannels, + WORD nSamplesPerBlock +) +{ + const WORD nEncodedSampleBits = nChannels * IMAADPCM_BITS_PER_SAMPLE; + const WORD nHeaderBytes = nChannels * IMAADPCM_HEADER_LENGTH; + INT nBlockAlign; + + // + // Calculate the raw block alignment that nSamplesPerBlock dictates. This + // value may include a partial encoded sample, so be sure to round up. + // + // Start with the samples-per-block, minus 1. The first sample is actually + // stored in the header. + // + + nBlockAlign = nSamplesPerBlock - 1; + + // + // Convert to encoded sample size + // + + nBlockAlign *= nEncodedSampleBits; + nBlockAlign += 7; + nBlockAlign /= 8; + + // + // The stereo encoder requires that there be at least two DWORDs to process + // + + nBlockAlign += 7; + nBlockAlign /= 8; + nBlockAlign *= 8; + + // + // Add the header + // + + nBlockAlign += nHeaderBytes; + + // We used an INT temporarily, but the final result should fit into a WORD + assert( nBlockAlign < 0xFFFF ); + return (WORD)nBlockAlign; +} + + +/**************************************************************************** + * + * CreatePcmFormat + * + * Description: + * Creates a PCM format descriptor. + * + * Arguments: + * WORD [in]: channel count. + * DWORD [in]: sampling rate. + * LPWAVEFORMATEX [out]: format descriptor. + * + * Returns: + * (void) + * + ****************************************************************************/ + +void +CImaAdpcmCodec::CreatePcmFormat +( + WORD nChannels, + DWORD nSamplesPerSec, + LPWAVEFORMATEX pwfx +) +{ + pwfx->wFormatTag = WAVE_FORMAT_PCM; + pwfx->nChannels = nChannels; + pwfx->nSamplesPerSec = nSamplesPerSec; + pwfx->nBlockAlign = nChannels * IMAADPCM_PCM_BITS_PER_SAMPLE / 8; + pwfx->nAvgBytesPerSec = pwfx->nBlockAlign * pwfx->nSamplesPerSec; + pwfx->wBitsPerSample = IMAADPCM_PCM_BITS_PER_SAMPLE; +} + + +/**************************************************************************** + * + * CreateImaAdpcmFormat + * + * Description: + * Creates an IMA ADPCM format descriptor. + * + * Arguments: + * WORD [in]: channel count. + * DWORD [in]: sampling rate. + * LPIMAADPCMWAVEFORMAT [out]: format descriptor. + * + * Returns: + * (void) + * + ****************************************************************************/ + +void +CImaAdpcmCodec::CreateImaAdpcmFormat +( + WORD nChannels, + DWORD nSamplesPerSec, + WORD nSamplesPerBlock, + LPIMAADPCMWAVEFORMAT pwfx +) +{ + pwfx->wfx.wFormatTag = WAVE_FORMAT_XBOX_ADPCM; + pwfx->wfx.nChannels = nChannels; + pwfx->wfx.nSamplesPerSec = nSamplesPerSec; + pwfx->wfx.nBlockAlign = CalculateEncodeAlignment(nChannels, nSamplesPerBlock); + pwfx->wfx.nAvgBytesPerSec = nSamplesPerSec * pwfx->wfx.nBlockAlign / nSamplesPerBlock; + pwfx->wfx.wBitsPerSample = IMAADPCM_BITS_PER_SAMPLE; + pwfx->wfx.cbSize = sizeof(*pwfx) - sizeof(pwfx->wfx); + pwfx->wSamplesPerBlock = nSamplesPerBlock; +} + + +/**************************************************************************** + * + * IsValidPcmFormat + * + * Description: + * Validates a format structure. + * + * Arguments: + * LPCWAVEFORMATEX [in]: format. + * + * Returns: + * BOOL: TRUE on success. + * + ****************************************************************************/ + +BOOL +CImaAdpcmCodec::IsValidPcmFormat +( + LPCWAVEFORMATEX pwfx +) +{ + if(WAVE_FORMAT_PCM != pwfx->wFormatTag) + { + return FALSE; + } + + if((pwfx->nChannels < 1) || (pwfx->nChannels > IMAADPCM_MAX_CHANNELS)) + { + return FALSE; + } + + if(IMAADPCM_PCM_BITS_PER_SAMPLE != pwfx->wBitsPerSample) + { + return FALSE; + } + + if(pwfx->nChannels * pwfx->wBitsPerSample / 8 != pwfx->nBlockAlign) + { + return FALSE; + } + + if(pwfx->nBlockAlign * pwfx->nSamplesPerSec != pwfx->nAvgBytesPerSec) + { + return FALSE; + } + + return TRUE; +} + + +/**************************************************************************** + * + * IsValidXboxAdpcmFormat + * + * Description: + * Validates a format structure. + * + * Arguments: + * LPCIMAADPCMWAVEFORMAT [in]: format. + * + * Returns: + * BOOL: TRUE on success. + * + ****************************************************************************/ + +BOOL +CImaAdpcmCodec::IsValidImaAdpcmFormat +( + LPCIMAADPCMWAVEFORMAT pwfx +) +{ + if(WAVE_FORMAT_XBOX_ADPCM != pwfx->wfx.wFormatTag) + { + return FALSE; + } + + if(sizeof(*pwfx) - sizeof(pwfx->wfx) != pwfx->wfx.cbSize) + { + return FALSE; + } + + if((pwfx->wfx.nChannels < 1) || (pwfx->wfx.nChannels > IMAADPCM_MAX_CHANNELS)) + { + return FALSE; + } + + if(IMAADPCM_BITS_PER_SAMPLE != pwfx->wfx.wBitsPerSample) + { + return FALSE; + } + + if(CalculateEncodeAlignment(pwfx->wfx.nChannels, pwfx->wSamplesPerBlock) != pwfx->wfx.nBlockAlign) + { + return FALSE; + } + + return TRUE; +} + + +/**************************************************************************** + * + * CalcDifference + * + * Description: + * Calculates the error between two audio buffers. The error is clamped + * at (ULONGLONG)-1. Also, the error of a block acts as a percentage of + * the maximum possible contribution of a block. + * + * Arguments: + * LPBYTE [in]: First buffer + * LPBYTE [in]: Second buffer + * UINT [in]: Number of blocks-worth to compare + * UINT [in]: Total number of blocks being converted + * DWORD [in]: Size of a single block in bytes + * + * Returns: + * ULONGLONG: Difference of the two buffers + * + ****************************************************************************/ +ULONGLONG CImaAdpcmCodec::CalcDifference(LPBYTE pvBuffer1, LPBYTE pvBuffer2, UINT cBlocks, UINT cTotalBlocks, DWORD dwBlockSize) +{ + ULONGLONG ullDiff = 0; + + // Each block worth of error can contribute a maximum of this value + const ULONGLONG ullMaxBlockContribution = ( (ULONGLONG)-1 / cTotalBlocks ); + + // The maximum error in a block is + // (2^16)^2 * m_wfxEncode.wSamplesPerBlock + // = ( 1 << 32 ) * m_wfxEncode.wSamplesPerBlock + const ULONGLONG ullMaxBlockDiff = ( (ULONGLONG)1 << 32 ) * m_wfxEncode.wSamplesPerBlock; + + // Now we go through the buffers sample by sample and find the difference + // on a block-by-block basis. The factored difference of a block is + // ullBlockDiff / ullMaxBlockDiff * ullMaxBlockContribution + for( UINT i = 0; i < cBlocks; ++i ) + { + PSHORT pSamples1 = (PSHORT)(pvBuffer1 + i * dwBlockSize); + PSHORT pSamples2 = (PSHORT)(pvBuffer2 + i * dwBlockSize); + ULONGLONG ullBlockDiff = 0; + + // Find the block difference + for( UINT j = 0; j < m_wfxEncode.wSamplesPerBlock; ++j ) + { + ULONGLONG ullSampleDiff = (ULONGLONG)(pSamples2[j]) - (ULONGLONG)(pSamples1[j]); + ullBlockDiff += ( ullSampleDiff * ullSampleDiff ); + } + + // Assert that we didn't go over the maximum possible + assert( ullBlockDiff <= ullMaxBlockDiff ); + + // Add the contribution of this block to the error + ullDiff += (ULONGLONG)( ( (DOUBLE)ullBlockDiff / (DOUBLE)ullMaxBlockDiff ) * ullMaxBlockContribution ); + } + + assert( ullDiff <= cBlocks * ullMaxBlockContribution ); + + return ullDiff; +} + + +/**************************************************************************** + * + * EncodeSample + * + * Description: + * Encodes a sample. + * + * Arguments: + * int [in]: the sample to be encoded. + * LPINT [in/out]: the predicted value of the sample. + * int [in]: the quantization step size used to encode the sample. + * + * Returns: + * int: the encoded ADPCM sample. + * + ****************************************************************************/ + +int +CImaAdpcmCodec::EncodeSample +( + int nInputSample, + LPINT pnPredictedSample, + int nStepSize +) +{ + int nPredictedSample; + LONG lDifference; + int nEncodedSample; + + nPredictedSample = *pnPredictedSample; + + lDifference = nInputSample - nPredictedSample; + nEncodedSample = 0; + + if(lDifference < 0) + { + nEncodedSample = 8; + lDifference = -lDifference; + } + + if(lDifference >= nStepSize) + { + nEncodedSample |= 4; + lDifference -= nStepSize; + } + + nStepSize >>= 1; + + if(lDifference >= nStepSize) + { + nEncodedSample |= 2; + lDifference -= nStepSize; + } + + nStepSize >>= 1; + + if(lDifference >= nStepSize) + { + nEncodedSample |= 1; + lDifference -= nStepSize; + } + + if(nEncodedSample & 8) + { + nPredictedSample = nInputSample + lDifference - (nStepSize >> 1); + } + else + { + nPredictedSample = nInputSample - lDifference + (nStepSize >> 1); + } + + if(nPredictedSample > 32767) + { + nPredictedSample = 32767; + } + else if(nPredictedSample < -32768) + { + nPredictedSample = -32768; + } + + *pnPredictedSample = nPredictedSample; + + return nEncodedSample; +} + + +/**************************************************************************** + * + * DecodeSample + * + * Description: + * Decodes an encoded sample. + * + * Arguments: + * int [in]: the sample to be decoded. + * int [in]: the predicted value of the sample. + * int [i]: the quantization step size used to encode the sample. + * + * Returns: + * int: the decoded PCM sample. + * + ****************************************************************************/ + +int +CImaAdpcmCodec::DecodeSample +( + int nEncodedSample, + int nPredictedSample, + int nStepSize +) +{ + LONG lDifference; + LONG lNewSample; + + lDifference = nStepSize >> 3; + + if(nEncodedSample & 4) + { + lDifference += nStepSize; + } + + if(nEncodedSample & 2) + { + lDifference += nStepSize >> 1; + } + + if(nEncodedSample & 1) + { + lDifference += nStepSize >> 2; + } + + if(nEncodedSample & 8) + { + lDifference = -lDifference; + } + + lNewSample = nPredictedSample + lDifference; + + if((LONG)(short)lNewSample != lNewSample) + { + if(lNewSample < -32768) + { + lNewSample = -32768; + } + else + { + lNewSample = 32767; + } + } + + return (int)lNewSample; +} + + +/**************************************************************************** + * + * Conversion Routines + * + * Description: + * Converts a PCM buffer to ADPCM, or the reverse. + * + * Arguments: + * LPBYTE [in]: source buffer. + * LPBYTE [out]: destination buffer. + * UINT [in]: block count. + * UINT [in]: block alignment of the ADPCM data, in bytes. + * UINT [in]: the number of samples in each ADPCM block (not used in + * decoding). + * LPINT [in/out]: left-channel stepping index. + * LPINT [in/out]: right-channel stepping index. + * + * Returns: + * BOOL: TRUE on success. + * + ****************************************************************************/ + +BOOL +CImaAdpcmCodec::EncodeM16 +( + LPBYTE pbSrc, + LPBYTE pbDst, + UINT cBlocks, + UINT nBlockAlignment, + UINT cSamplesPerBlock, + LPINT pnStepIndexL, + LPINT +) +{ + LPBYTE pbBlock; + UINT cSamples; + int nSample; + int nStepSize; + int nEncSample1; + int nEncSample2; + int nPredSample; + int nStepIndex; + + // + // Save a local copy of the step index so we're not constantly + // dereferencing a pointer. + // + + nStepIndex = *pnStepIndexL; + + // + // Enter the main loop + // + + while(cBlocks--) + { + pbBlock = pbDst; + cSamples = cSamplesPerBlock - 1; + + // + // Block header + // + + nPredSample = *(short *)pbSrc; + pbSrc += sizeof(short); + + *(LONG *)pbBlock = MAKELONG(nPredSample, nStepIndex); + pbBlock += sizeof(LONG); + + // + // We have written the header for this block--now write the data + // chunk (which consists of a bunch of encoded nibbles). Note + // that if we don't have enough data to fill a complete byte, then + // we add a 0 nibble on the end. + // + + while(cSamples) + { + // + // Sample 1 + // + + nSample = *(short *)pbSrc; + pbSrc += sizeof(short); + cSamples--; + + nStepSize = m_asStep[nStepIndex]; + nEncSample1 = EncodeSample(nSample, &nPredSample, nStepSize); + nStepIndex = NextStepIndex(nEncSample1, nStepIndex); + + // + // Sample 2 + // + + if(cSamples) + { + nSample = *(short *)pbSrc; + pbSrc += sizeof(short); + cSamples--; + + nStepSize = m_asStep[nStepIndex]; + nEncSample2 = EncodeSample(nSample, &nPredSample, nStepSize); + nStepIndex = NextStepIndex(nEncSample2, nStepIndex); + } + else + { + nEncSample2 = 0; + } + + // + // Write out encoded byte. + // + + *pbBlock++ = (BYTE)(nEncSample1 | (nEncSample2 << 4)); + } + + // + // Skip padding + // + + pbDst += nBlockAlignment; + } + + // + // Restore the value of the step index to be used on the next buffer. + // + + *pnStepIndexL = nStepIndex; + + return TRUE; +} + + +BOOL +CImaAdpcmCodec::EncodeS16 +( + LPBYTE pbSrc, + LPBYTE pbDst, + UINT cBlocks, + UINT nBlockAlignment, + UINT cSamplesPerBlock, + LPINT pnStepIndexL, + LPINT pnStepIndexR +) +{ + LPBYTE pbBlock; + UINT cSamples; + UINT cSubSamples; + int nSample; + int nStepSize; + DWORD dwLeft; + DWORD dwRight; + int nEncSampleL; + int nPredSampleL; + int nStepIndexL; + int nEncSampleR; + int nPredSampleR; + int nStepIndexR; + UINT i; + + // + // Save a local copy of the step indices so we're not constantly + // dereferencing a pointer. + // + + nStepIndexL = *pnStepIndexL; + nStepIndexR = *pnStepIndexR; + + // + // Enter the main loop + // + + while(cBlocks--) + { + pbBlock = pbDst; + cSamples = cSamplesPerBlock - 1; + + // + // LEFT channel block header + // + + nPredSampleL = *(short *)pbSrc; + pbSrc += sizeof(short); + + *(LONG *)pbBlock = MAKELONG(nPredSampleL, nStepIndexL); + pbBlock += sizeof(LONG); + + // + // RIGHT channel block header + // + + nPredSampleR = *(short *)pbSrc; + pbSrc += sizeof(short); + + *(LONG *)pbBlock = MAKELONG(nPredSampleR, nStepIndexR); + pbBlock += sizeof(LONG); + + // + // We have written the header for this block--now write the data + // chunk. This consists of 8 left samples (one DWORD of output) + // followed by 8 right samples (also one DWORD). Since the input + // samples are interleaved, we create the left and right DWORDs + // sample by sample, and then write them both out. + // + + while(cSamples) + { + dwLeft = 0; + dwRight = 0; + + cSubSamples = min(cSamples, 8); + + for(i = 0; i < cSubSamples; i++) + { + // + // LEFT channel + // + + nSample = *(short *)pbSrc; + pbSrc += sizeof(short); + + nStepSize = m_asStep[nStepIndexL]; + + nEncSampleL = EncodeSample(nSample, &nPredSampleL, nStepSize); + + nStepIndexL = NextStepIndex(nEncSampleL, nStepIndexL); + dwLeft |= (DWORD)nEncSampleL << (4 * i); + + // + // RIGHT channel + // + + nSample = *(short *)pbSrc; + pbSrc += sizeof(short); + + nStepSize = m_asStep[nStepIndexR]; + + nEncSampleR = EncodeSample(nSample, &nPredSampleR, nStepSize); + + nStepIndexR = NextStepIndex(nEncSampleR, nStepIndexR); + dwRight |= (DWORD)nEncSampleR << (4 * i); + } + + // + // Write out encoded DWORDs. + // + + *(LPDWORD)pbBlock = dwLeft; + pbBlock += sizeof(DWORD); + + *(LPDWORD)pbBlock = dwRight; + pbBlock += sizeof(DWORD); + + cSamples -= cSubSamples; + } + + // + // Skip padding + // + + pbDst += nBlockAlignment; + } + + // + // Restore the value of the step index to be used on the next buffer. + // + + *pnStepIndexL = nStepIndexL; + *pnStepIndexR = nStepIndexR; + + return TRUE; + +} + + +BOOL +CImaAdpcmCodec::DecodeM16 +( + LPBYTE pbSrc, + LPBYTE pbDst, + UINT cBlocks, + UINT nBlockAlignment, + UINT cSamplesPerBlock, + LPINT, + LPINT +) +{ + BOOL fSuccess = TRUE; + LPBYTE pbBlock; + UINT cSamples; + BYTE bSample; + int nStepSize; + int nEncSample; + int nPredSample; + int nStepIndex; + DWORD dwHeader; + + // + // Enter the main loop + // + + while(cBlocks--) + { + pbBlock = pbSrc; + cSamples = cSamplesPerBlock - 1; + + // + // Block header + // + + dwHeader = *(LPDWORD)pbBlock; + pbBlock += sizeof(DWORD); + + nPredSample = (int)(short)LOWORD(dwHeader); + nStepIndex = (int)(BYTE)HIWORD(dwHeader); + + if(!ValidStepIndex(nStepIndex)) + { + // + // The step index is out of range - this is considered a fatal + // error as the input stream is corrupted. We fail by returning + // zero bytes converted. + // + + fSuccess = FALSE; + break; + } + + // + // Write out first sample + // + + *(short *)pbDst = (short)nPredSample; + pbDst += sizeof(short); + + // + // Enter the block loop + // + + while(cSamples) + { + bSample = *pbBlock++; + + // + // Sample 1 + // + + nEncSample = (bSample & (BYTE)0x0F); + nStepSize = m_asStep[nStepIndex]; + nPredSample = DecodeSample(nEncSample, nPredSample, nStepSize); + nStepIndex = NextStepIndex(nEncSample, nStepIndex); + + *(short *)pbDst = (short)nPredSample; + pbDst += sizeof(short); + + cSamples--; + + // + // Sample 2 + // + + if(cSamples) + { + nEncSample = (bSample >> 4); + nStepSize = m_asStep[nStepIndex]; + nPredSample = DecodeSample(nEncSample, nPredSample, nStepSize); + nStepIndex = NextStepIndex(nEncSample, nStepIndex); + + *(short *)pbDst = (short)nPredSample; + pbDst += sizeof(short); + + cSamples--; + } + } + + // + // Skip padding + // + + pbSrc += nBlockAlignment; + } + + return fSuccess; +} + + +BOOL +CImaAdpcmCodec::DecodeS16 +( + LPBYTE pbSrc, + LPBYTE pbDst, + UINT cBlocks, + UINT nBlockAlignment, + UINT cSamplesPerBlock, + LPINT, + LPINT +) +{ + BOOL fSuccess = TRUE; + LPBYTE pbBlock; + UINT cSamples; + UINT cSubSamples; + int nStepSize; + DWORD dwHeader; + DWORD dwLeft; + DWORD dwRight; + int nEncSampleL; + int nPredSampleL; + int nStepIndexL; + int nEncSampleR; + int nPredSampleR; + int nStepIndexR; + UINT i; + + // + // Enter the main loop + // + + while(cBlocks--) + { + pbBlock = pbSrc; + cSamples = cSamplesPerBlock - 1; + + // + // LEFT channel header + // + + dwHeader = *(LPDWORD)pbBlock; + pbBlock += sizeof(DWORD); + + nPredSampleL = (int)(short)LOWORD(dwHeader); + nStepIndexL = (int)(BYTE)HIWORD(dwHeader); + + if(!ValidStepIndex(nStepIndexL)) + { + // + // The step index is out of range - this is considered a fatal + // error as the input stream is corrupted. We fail by returning + // zero bytes converted. + // + + fSuccess = FALSE; + break; + } + + // + // RIGHT channel header + // + + dwHeader = *(LPDWORD)pbBlock; + pbBlock += sizeof(DWORD); + + nPredSampleR = (int)(short)LOWORD(dwHeader); + nStepIndexR = (int)(BYTE)HIWORD(dwHeader); + + if(!ValidStepIndex(nStepIndexR)) + { + // + // The step index is out of range - this is considered a fatal + // error as the input stream is corrupted. We fail by returning + // zero bytes converted. + // + + fSuccess = FALSE; + break; + } + + // + // Write out first sample + // + + *(LPDWORD)pbDst = MAKELONG(nPredSampleL, nPredSampleR); + pbDst += sizeof(DWORD); + + // + // The first DWORD contains 4 left samples, the second DWORD + // contains 4 right samples. We process the source in 8-byte + // chunks to make it easy to interleave the output correctly. + // + + while(cSamples) + { + dwLeft = *(LPDWORD)pbBlock; + pbBlock += sizeof(DWORD); + dwRight = *(LPDWORD)pbBlock; + pbBlock += sizeof(DWORD); + + cSubSamples = min(cSamples, 8); + + for(i = 0; i < cSubSamples; i++) + { + // + // LEFT channel + // + + nEncSampleL = (dwLeft & 0x0F); + nStepSize = m_asStep[nStepIndexL]; + nPredSampleL = DecodeSample(nEncSampleL, nPredSampleL, nStepSize); + nStepIndexL = NextStepIndex(nEncSampleL, nStepIndexL); + + // + // RIGHT channel + // + + nEncSampleR = (dwRight & 0x0F); + nStepSize = m_asStep[nStepIndexR]; + nPredSampleR = DecodeSample(nEncSampleR, nPredSampleR, nStepSize); + nStepIndexR = NextStepIndex(nEncSampleR, nStepIndexR); + + // + // Write out sample + // + + *(LPDWORD)pbDst = MAKELONG(nPredSampleL, nPredSampleR); + pbDst += sizeof(DWORD); + + // + // Shift the next input sample into the low-order 4 bits. + // + + dwLeft >>= 4; + dwRight >>= 4; + } + + cSamples -= cSubSamples; + } + + // + // Skip padding + // + + pbSrc += nBlockAlignment; + } + + return fSuccess; +} + + +int XboxADPCMSize( int sampleCount, int channelCount, int sampleRate ) +{ + CImaAdpcmCodec codec; + IMAADPCMWAVEFORMAT wfxEncode; + + // Create an APDCM format structure based off the source format + codec.CreateImaAdpcmFormat( (WORD)channelCount, sampleRate, XBOX_ADPCM_SAMPLES_PER_BLOCK, &wfxEncode ); + + // Calculate number of ADPCM blocks and length of ADPCM data + DWORD dwDestBlocks = sampleCount / XBOX_ADPCM_SAMPLES_PER_BLOCK; + DWORD dwDestLength = dwDestBlocks * wfxEncode.wfx.nBlockAlign; + + return dwDestLength; +} + +void Convert16ToXboxADPCM( const short *pInputBuffer, byte *pOutputBuffer, byte *pOutFormat, int sampleCount, int channelCount, int sampleRate ) +{ + CImaAdpcmCodec codec; + IMAADPCMWAVEFORMAT wfxEncode; + + // Create an APDCM format structure based off the source format + codec.CreateImaAdpcmFormat( (WORD)channelCount, sampleRate, XBOX_ADPCM_SAMPLES_PER_BLOCK, &wfxEncode ); + if ( pOutFormat ) + { + memcpy( pOutFormat, &wfxEncode, sizeof(wfxEncode) ); + } + + // Initialize the codec + if ( FALSE == codec.Initialize( &wfxEncode, CODEC_MODE_ENCODE_OPTIMIZE_EACH_BLOCK ) ) + { + printf( "Couldn't initialize codec.\n" ); + return; + } + + // Convert the data + DWORD dwDestBlocks = sampleCount / XBOX_ADPCM_SAMPLES_PER_BLOCK; + if ( FALSE == codec.Convert( (const byte *)pInputBuffer, pOutputBuffer, dwDestBlocks ) ) + return; +} diff --git a/utils/xbox/MakeGameData/imaadpcm.h b/utils/xbox/MakeGameData/imaadpcm.h new file mode 100644 index 0000000..a9fdd08 --- /dev/null +++ b/utils/xbox/MakeGameData/imaadpcm.h @@ -0,0 +1,153 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +/*************************************************************************** + * + * Copyright (C) 2001 Microsoft Corporation. All Rights Reserved. + * + * File: imaadpcm.h + * Content: IMA ADPCM CODEC. + * History: + * Date By Reason + * ==== == ====== + * 04/29/01 dereks Created. + * + ****************************************************************************/ + +#ifndef __IMAADPCM_H__ +#define __IMAADPCM_H__ + +#include <windows.h> +#include <windowsx.h> +#include <mmsystem.h> +#include <ctype.h> +#include <mmreg.h> +#include <msacm.h> + +#define XBOX_ADPCM_SAMPLES_PER_BLOCK 64 + +#define WAVE_FORMAT_XBOX_ADPCM 0x0069 + +#define IMAADPCM_BITS_PER_SAMPLE 4 +#define IMAADPCM_HEADER_LENGTH 4 + +#define IMAADPCM_MAX_CHANNELS 2 +#define IMAADPCM_PCM_BITS_PER_SAMPLE 16 + +#define NUMELMS(a) (sizeof(a) / sizeof(a[0])) + +typedef const WAVEFORMATEX *LPCWAVEFORMATEX; +typedef const IMAADPCMWAVEFORMAT *LPCIMAADPCMWAVEFORMAT; + +#ifdef __cplusplus + +// +// IMA ADPCM encoder function prototype +// + +typedef BOOL (*LPFNIMAADPCMCONVERT)(LPBYTE pbSrc, LPBYTE pbDst, UINT cBlocks, UINT nBlockAlignment, UINT cSamplesPerBlock, LPINT pnStepIndexL, LPINT pnStepIndexR); + +// +// Codec mode +// + +enum CODEC_MODE +{ + CODEC_MODE_DECODE, + CODEC_MODE_ENCODE_NORMAL, + CODEC_MODE_ENCODE_OPTIMIZE_WHOLE_FILE, + CODEC_MODE_ENCODE_OPTIMIZE_EACH_BLOCK, +}; + +// +// IMA ADPCM CODEC +// + +class CImaAdpcmCodec +{ +private: + static const short m_asNextStep[16]; // Step increment array + static const short m_asStep[89]; // Step value array + IMAADPCMWAVEFORMAT m_wfxEncode; // Encoded format description + CODEC_MODE m_cmCodecMode; // Codec mode + int m_nStepIndexL; // Left-channel stepping index + int m_nStepIndexR; // Right-channel stepping index + LPFNIMAADPCMCONVERT m_pfnConvert; // Conversion function + +public: + CImaAdpcmCodec(void); + ~CImaAdpcmCodec(void); + +public: + // Initialization + BOOL Initialize(LPCIMAADPCMWAVEFORMAT pwfxEncode, CODEC_MODE cmCodecMode); + + // Size conversions + WORD GetEncodeAlignment(void); + WORD GetDecodeAlignment(void); + WORD GetSourceAlignment(void); + WORD GetDestinationAlignment(void); + + // Data conversions + BOOL Convert(LPCVOID pvSrc, LPVOID pvDst, UINT cBlocks); + void Reset(void); + + // Format descriptions + static void CreatePcmFormat(WORD nChannels, DWORD nSamplesPerSec, LPWAVEFORMATEX pwfxFormat); + static void CreateImaAdpcmFormat(WORD nChannels, DWORD nSamplesPerSec, WORD nSamplesPerBlock, LPIMAADPCMWAVEFORMAT pwfxFormat); + + static BOOL IsValidPcmFormat(LPCWAVEFORMATEX pwfxFormat); + static BOOL IsValidImaAdpcmFormat(LPCIMAADPCMWAVEFORMAT pwfxFormat); + +private: + // En/decoded data alignment + static WORD CalculateEncodeAlignment(WORD nSamplesPerBlock, WORD nChannels); + + // Data conversion functions + static BOOL EncodeM16(LPBYTE pbSrc, LPBYTE pbDst, UINT cBlocks, UINT nBlockAlignment, UINT cSamplesPerBlock, LPINT pnStepIndexL, LPINT pnStepIndexR); + static BOOL EncodeS16(LPBYTE pbSrc, LPBYTE pbDst, UINT cBlocks, UINT nBlockAlignment, UINT cSamplesPerBlock, LPINT pnStepIndexL, LPINT pnStepIndexR); + static BOOL DecodeM16(LPBYTE pbSrc, LPBYTE pbDst, UINT cBlocks, UINT nBlockAlignment, UINT cSamplesPerBlock, LPINT pnStepIndexL, LPINT pnStepIndexR); + static BOOL DecodeS16(LPBYTE pbSrc, LPBYTE pbDst, UINT cBlocks, UINT nBlockAlignment, UINT cSamplesPerBlock, LPINT pnStepIndexL, LPINT pnStepIndexR); + + static int EncodeSample(int nInputSample, int *nPredictedSample, int nStepSize); + static int DecodeSample(int nInputSample, int nPredictedSample, int nStepSize); + + static int NextStepIndex(int nEncodedSample, int nStepIndex); + static BOOL ValidStepIndex(int nStepIndex); + + /*static ULONGLONG CalcDifference(LPDWORD pvBuffer1, LPDWORD pvBuffer2, DWORD dwLength);*/ + ULONGLONG CalcDifference(LPBYTE pvBuffer1, LPBYTE pvBuffer2, UINT cBlocks, UINT cTotalBlocks, DWORD dwBlockSize); +}; + +__inline WORD CImaAdpcmCodec::GetSourceAlignment(void) +{ + return ( m_cmCodecMode == CODEC_MODE_DECODE ) ? GetEncodeAlignment() : GetDecodeAlignment(); +} + +__inline WORD CImaAdpcmCodec::GetDestinationAlignment(void) +{ + return ( m_cmCodecMode == CODEC_MODE_DECODE ) ? GetDecodeAlignment() : GetEncodeAlignment(); +} + +__inline int CImaAdpcmCodec::NextStepIndex(int nEncodedSample, int nStepIndex) +{ + nStepIndex += m_asNextStep[nEncodedSample]; + + if(nStepIndex < 0) + { + nStepIndex = 0; + } + else if(nStepIndex >= NUMELMS(m_asStep)) + { + nStepIndex = NUMELMS(m_asStep) - 1; + } + + return nStepIndex; +} + +__inline BOOL CImaAdpcmCodec::ValidStepIndex(int nStepIndex) +{ + return (nStepIndex >= 0) && (nStepIndex < NUMELMS(m_asStep)); +} + +#endif // __cplusplus + +#endif // __IMAADPCM_H__ diff --git a/utils/xbox/MakeGameData/resample.cpp b/utils/xbox/MakeGameData/resample.cpp new file mode 100644 index 0000000..a0ce0a7 --- /dev/null +++ b/utils/xbox/MakeGameData/resample.cpp @@ -0,0 +1,381 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// + +#include <windows.h> +#include <mmreg.h> +#include "../toollib/toollib.h" +#include "tier1/strtools.h" +#include "resample.h" + +#define clamp(a,b,c) ( (a) > (c) ? (c) : ( (a) < (b) ? (b) : (a) ) ) + +const int NUM_COEFFS = 7; +static const float g_ResampleCoefficients[NUM_COEFFS] = +{ + 0.0457281f, 0.168088f, 0.332501f, 0.504486f, 0.663202f, 0.803781f, 0.933856f +}; + + +// generates 1 output sample for 2 input samples +inline float DecimateSamplePair(float input0, float input1, const float pCoefficients[7], float xState[2], float yState[7] ) +{ + float tmp_0 = xState[0]; + float tmp_1 = xState[1]; + + xState[0] = input0; + xState[1] = input1; + + input0 = (input0 - yState[0]) * pCoefficients[0] + tmp_0; + input1 = (input1 - yState[1]) * pCoefficients[1] + tmp_1; + tmp_0 = yState[0]; + tmp_1 = yState[1]; + yState[0] = input0; + yState[1] = input1; + + input0 = (input0 - yState[2]) * pCoefficients[2] + tmp_0; + input1 = (input1 - yState[3]) * pCoefficients[3] + tmp_1; + tmp_0 = yState[2]; + tmp_1 = yState[3]; + yState[2] = input0; + yState[3] = input1; + + input0 = (input0 - yState[4]) * pCoefficients[4] + tmp_0; + input1 = (input1 - yState[5]) * pCoefficients[5] + tmp_1; + tmp_0 = yState[4]; + yState[4] = input0; + yState[5] = input1; + + input0 = (input0 - yState[6]) * pCoefficients[6] + tmp_0; + yState[6] = input0; + + return (input0 + input1); +} + +static void ExtractFloatSamples( float *pOut, const short *pInputBuffer, int sampleCount, int stride ) +{ + for ( int i = 0; i < sampleCount; i++ ) + { + pOut[i] = pInputBuffer[0] * 1.0f / 32768.0f; + pInputBuffer += stride; + } +} + +static void ExtractShortSamples( short *pOut, const float *pInputBuffer, float scale, int sampleCount, int stride ) +{ + for ( int i = 0; i < sampleCount; i++ ) + { + int sampleOut = (int)(pInputBuffer[i] * scale); + sampleOut = clamp( sampleOut, -32768, 32767 ); + + pOut[0] = (short)(sampleOut); + pOut += stride; + } +} + +struct decimatestate_t +{ + float xState[2]; + float yState[7]; +}; +void DecimateSampleBlock( float *pInOut, int sampleCount ) +{ + decimatestate_t block; + int outCount = sampleCount >> 1; + int pos = 0; + memset( &block, 0, sizeof(block) ); + do + { + float input0 = pInOut[pos*2+0]; + float input1 = pInOut[pos*2+1]; + pInOut[pos] = DecimateSamplePair( input0, input1, g_ResampleCoefficients, block.xState, block.yState ); + pos++; + } while( pos < outCount ); +} + +void DecimateSampleRateBy2_16( const short *pInputBuffer, short *pOutputBuffer, int sampleCount, int channelCount ) +{ + float *pTmpBuf = new float[sampleCount]; + for ( int i = 0; i < channelCount; i++ ) + { + ExtractFloatSamples( pTmpBuf, pInputBuffer+i, sampleCount, channelCount ); + DecimateSampleBlock( pTmpBuf, sampleCount ); + ExtractShortSamples( pOutputBuffer+i, pTmpBuf, 0.5f * 32768.0f, sampleCount>>1, channelCount ); + } + delete [] pTmpBuf; +} + + +struct adpcmstate_t +{ + const ADPCMWAVEFORMAT *pFormat; + const ADPCMCOEFSET *pCoefficients; + int blockSize; +}; + +static int error_sign_lut[] = { 0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1 }; +static int error_coefficients_lut[] = { 230, 230, 230, 230, 307, 409, 512, 614, 768, 614, 512, 409, 307, 230, 230, 230 }; + +void ParseADPCM( adpcmstate_t &out, const byte *pFormatChunk ) +{ + out.pFormat = (const ADPCMWAVEFORMAT *)pFormatChunk; + if ( out.pFormat ) + { + out.pCoefficients = out.pFormat->aCoef; + + // number of bytes for samples + out.blockSize = ((out.pFormat->wSamplesPerBlock - 2) * out.pFormat->wfx.nChannels ) / 2; + // size of channel header + out.blockSize += 7 * out.pFormat->wfx.nChannels; + } +} + +void DecompressBlockMono( const adpcmstate_t &state, short *pOut, const char *pIn, int count ) +{ + int pred = *pIn++; + int co1 = state.pCoefficients[pred].iCoef1; + int co2 = state.pCoefficients[pred].iCoef2; + + // read initial delta + int delta = *((short *)pIn); + pIn += 2; + + // read initial samples for prediction + int samp1 = *((short *)pIn); + pIn += 2; + + int samp2 = *((short *)pIn); + pIn += 2; + + // write out the initial samples (stored in reverse order) + *pOut++ = (short)samp2; + *pOut++ = (short)samp1; + + // subtract the 2 samples in the header + count -= 2; + + // this is a toggle to read nibbles, first nibble is high + int high = 1; + + int error, sample=0; + + // now process the block + while ( count ) + { + // read the error nibble from the input stream + if ( high ) + { + sample = (unsigned char) (*pIn++); + // high nibble + error = sample >> 4; + // cache low nibble for next read + sample = sample & 0xf; + // Next read is from cache, not stream + high = 0; + } + else + { + // stored in previous read (low nibble) + error = sample; + // next read is from stream + high = 1; + } + // convert to signed with LUT + int errorSign = error_sign_lut[error]; + + // interpolate the new sample + int predSample = (samp1 * co1) + (samp2 * co2); + // coefficients are fixed point 8-bit, so shift back to 16-bit integer + predSample >>= 8; + + // Add in current error estimate + predSample += (errorSign * delta); + + // Correct error estimate + delta = (delta * error_coefficients_lut[error]) >> 8; + // Clamp error estimate + if ( delta < 16 ) + delta = 16; + + // clamp + if ( predSample > 32767L ) + predSample = 32767L; + else if ( predSample < -32768L ) + predSample = -32768L; + + // output + *pOut++ = (short)predSample; + // move samples over + samp2 = samp1; + samp1 = predSample; + + count--; + } +} + + +//----------------------------------------------------------------------------- +// Purpose: Decode a single block of stereo ADPCM audio +// Input : *pOut - 16-bit output buffer +// *pIn - ADPCM encoded block data +// count - number of sample pairs to decode +//----------------------------------------------------------------------------- +void DecompressBlockStereo( const adpcmstate_t &state, short *pOut, const char *pIn, int count ) +{ + int pred[2], co1[2], co2[2]; + int i; + + for ( i = 0; i < 2; i++ ) + { + pred[i] = *pIn++; + co1[i] = state.pCoefficients[pred[i]].iCoef1; + co2[i] = state.pCoefficients[pred[i]].iCoef2; + } + + int delta[2], samp1[2], samp2[2]; + + for ( i = 0; i < 2; i++, pIn += 2 ) + { + // read initial delta + delta[i] = *((short *)pIn); + } + + // read initial samples for prediction + for ( i = 0; i < 2; i++, pIn += 2 ) + { + samp1[i] = *((short *)pIn); + } + for ( i = 0; i < 2; i++, pIn += 2 ) + { + samp2[i] = *((short *)pIn); + } + + // write out the initial samples (stored in reverse order) + *pOut++ = (short)samp2[0]; // left + *pOut++ = (short)samp2[1]; // right + *pOut++ = (short)samp1[0]; // left + *pOut++ = (short)samp1[1]; // right + + // subtract the 2 samples in the header + count -= 2; + + // this is a toggle to read nibbles, first nibble is high + int high = 1; + + int error, sample=0; + + // now process the block + while ( count ) + { + for ( i = 0; i < 2; i++ ) + { + // read the error nibble from the input stream + if ( high ) + { + sample = (unsigned char) (*pIn++); + // high nibble + error = sample >> 4; + // cache low nibble for next read + sample = sample & 0xf; + // Next read is from cache, not stream + high = 0; + } + else + { + // stored in previous read (low nibble) + error = sample; + // next read is from stream + high = 1; + } + // convert to signed with LUT + int errorSign = error_sign_lut[error]; + + // interpolate the new sample + int predSample = (samp1[i] * co1[i]) + (samp2[i] * co2[i]); + // coefficients are fixed point 8-bit, so shift back to 16-bit integer + predSample >>= 8; + + // Add in current error estimate + predSample += (errorSign * delta[i]); + + // Correct error estimate + delta[i] = (delta[i] * error_coefficients_lut[error]) >> 8; + // Clamp error estimate + if ( delta[i] < 16 ) + delta[i] = 16; + + // clamp + if ( predSample > 32767L ) + predSample = 32767L; + else if ( predSample < -32768L ) + predSample = -32768L; + + // output + *pOut++ = (short)predSample; + // move samples over + samp2[i] = samp1[i]; + samp1[i] = predSample; + } + count--; + } +} + +int ADPCMSampleCountShortBlock( const adpcmstate_t &state, int shortBlockSize ) +{ + if ( shortBlockSize < 8 ) + return 0; + + int sampleCount = state.pFormat->wSamplesPerBlock; + + // short block?, fixup sample count (2 samples per byte, divided by number of channels per sample set) + sampleCount -= ((state.blockSize - shortBlockSize) * 2) / state.pFormat->wfx.nChannels; + return sampleCount; +} + +int ADPCMSampleCount( const byte *pFormatChunk, const byte *pDataChunk, int dataSize ) +{ + adpcmstate_t state; + ParseADPCM( state, pFormatChunk ); + int numBlocks = dataSize / state.blockSize; + int mod = dataSize % state.blockSize; + return numBlocks * state.pFormat->wSamplesPerBlock + ADPCMSampleCountShortBlock(state, mod); +} + +void DecompressADPCMSamples( const byte *pFormatChunk, const byte *pDataChunk, int dataSize, short *pOutputBuffer ) +{ + adpcmstate_t state; + ParseADPCM( state, pFormatChunk ); + + while ( dataSize > 0 ) + { + int block = dataSize; + int sampleCount = state.pFormat->wSamplesPerBlock; + if ( block > state.blockSize ) + { + block = state.blockSize; + } + else + { + sampleCount = ADPCMSampleCountShortBlock( state, block ); + } + if ( state.pFormat->wfx.nChannels == 1 ) + { + DecompressBlockMono( state, pOutputBuffer, (const char *)pDataChunk, sampleCount ); + } + else + { + DecompressBlockStereo( state, pOutputBuffer, (const char *)pDataChunk, sampleCount ); + } + pOutputBuffer += sampleCount * state.pFormat->wfx.nChannels; + dataSize -= block; + pDataChunk += block; + } +} + +void Convert8To16( const byte *pInputBuffer, short *pOutputBuffer, int sampleCount, int channelCount ) +{ + for ( int i = 0; i < sampleCount*channelCount; i++ ) + { + unsigned short signedSample = (byte)((int)((unsigned)pInputBuffer[i]) - 128); + pOutputBuffer[i] = (short) (signedSample | (signedSample<<8)); + } +} + diff --git a/utils/xbox/MakeGameData/resample.h b/utils/xbox/MakeGameData/resample.h new file mode 100644 index 0000000..8382d7d --- /dev/null +++ b/utils/xbox/MakeGameData/resample.h @@ -0,0 +1,18 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#ifndef RESAMPLE_H +#define RESAMPLE_H +#ifdef _WIN32 +#pragma once +#endif + +void DecimateSampleRateBy2_16( const short *pInputBuffer, short *pOutputBuffer, int sampleCount, int channelCount ); +void DecompressADPCMSamples( const byte *pFormatChunk, const byte *pDataChunk, int dataSize, short *pOutputBuffer ); +int ADPCMSampleCount( const byte *pFormatChunk, const byte *pDataChunk, int dataSize ); +void Convert8To16( const byte *pInputBuffer, short *pOutputBuffer, int sampleCount, int channelCount ); + +#endif // RESAMPLE_H diff --git a/utils/xbox/MakeGameData/sound_io.cpp b/utils/xbox/MakeGameData/sound_io.cpp new file mode 100644 index 0000000..44e0323 --- /dev/null +++ b/utils/xbox/MakeGameData/sound_io.cpp @@ -0,0 +1,68 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +/***************************************************************************** + SOUND_IO.CPP + + IO class for RIFF +*****************************************************************************/ +#include "../toollib/toollib.h" +#include "tier2/riff.h" + +//----------------------------------------------------------------------------- +// Purpose: Implements Audio IO on the engine's COMMON filesystem +//----------------------------------------------------------------------------- +class COM_IOReadBinary : public IFileReadBinary +{ +public: + int open( const char *pFileName ); + int read( void *pOutput, int size, int file ); + void seek( int file, int pos ); + unsigned int tell( int file ); + unsigned int size( int file ); + void close( int file ); +}; + + +int COM_IOReadBinary::open( const char *pFileName ) +{ + int hFile = -1; + + _sopen_s( &hFile, pFileName, _O_RDONLY|_O_BINARY, _SH_DENYWR, _S_IREAD ); + + return hFile; +} + +int COM_IOReadBinary::read( void *pOutput, int size, int file ) +{ + return _read( file, pOutput, size ); +} + +void COM_IOReadBinary::seek( int file, int pos ) +{ + _lseek( file, pos, SEEK_SET ); +} + +unsigned int COM_IOReadBinary::tell( int file ) +{ + return _lseek( file, 0, SEEK_CUR ); +} + +unsigned int COM_IOReadBinary::size( int file ) +{ + long pos; + long length; + + pos = _lseek( file, 0, SEEK_CUR ); + length = _lseek( file, 0, SEEK_END ); + _lseek( file, pos, SEEK_SET ); + + return length; +} + +void COM_IOReadBinary::close( int file ) +{ + _close( file ); +} + +static COM_IOReadBinary io; +IFileReadBinary *g_pSndIO = &io; + diff --git a/utils/xbox/Test360/TriangleASM.cpp b/utils/xbox/Test360/TriangleASM.cpp new file mode 100644 index 0000000..7610661 --- /dev/null +++ b/utils/xbox/Test360/TriangleASM.cpp @@ -0,0 +1,981 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +//-------------------------------------------------------------------------------------- +// TriangleASM.cpp +// +// Hijacked from samples, assimilated into valve app. +//-------------------------------------------------------------------------------------- + +#include "tier0\platform.h" +#if !defined( _X360 ) +#include <windows.h> +#endif +#include "appframework\iappsystemgroup.h" +#include "appframework\appframework.h" +#include "tier0\dbg.h" +#include "tier1\interface.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 "tier3\tier3.h" +#include "mathlib/mathlib.h" +#include "inputsystem\iinputsystem.h" +#include "vphysics_interface.h" +#include "istudiorender.h" +#include "studio.h" +#include "tier1\KeyValues.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" +#if defined( _X360 ) +#include "xbox\xbox_console.h" +#include "xbox\xbox_win32stubs.h" +#endif +#include "materialsystem\imaterialsystem.h" +#include "materialsystem\imesh.h" +#include "materialsystem\materialsystem_config.h" +#include "materialsystem\MaterialSystemUtil.h" +#include "materialsystem\ishaderapi.h" +#if !defined( _X360 ) +#include "xbox\xboxstubs.h" +#endif +#include "bone_setup.h" +#include "tier0\memdbgon.h" + +bool g_bActive = true; + +extern SpewOutputFunc_t g_DefaultSpewFunc; + +// These must be turned on in order.... +#define USE_FILESYSTEM +#define USE_MATERIALSYSTEM +#define USE_VPHYSICS + +// Note: VPHYSICS is just used via the datacache to load a model's physics collision mesh + +// These can be turned on in any order +#define USE_INPUTSYSTEM +#define USE_VGUI +#define USE_STUDIORENDER + +#pragma warning(disable:4189) // local variable is initialized but not referenced + +//----------------------------------------------------------------------------- +// The application object +//----------------------------------------------------------------------------- +class CTest360App : public CDefaultAppSystemGroup<CSteamAppSystemGroup> +{ +public: + virtual bool Create(); + virtual bool PreInit(); + virtual int Main(); + virtual void Destroy(); + +private: + const char *GetAppName() { return "TEST360"; } + void RenderScene(); + bool CreateMainWindow( int width, int height, bool fullscreen ); + +#if defined( USE_MATERIALSYSTEM ) + bool SetupMaterialSystem(); +#endif + +#if defined( USE_STUDIORENDER ) + bool SetupStudioRender(); + bool LoadModel( const char *pModelName ); + matrix3x4_t* SetUpBones( studiohdr_t *pStudioHdr, const matrix3x4_t &modelMatrix ); +#endif + +#if defined( USE_VGUI ) + int InitializeVGUI( void ); + void ShutdownVGUI( void ); +#endif + + IPhysicsCollision *m_pCollision; + IMaterialSystem *m_pMaterialSystem; + IFileSystem *m_pFileSystem; + int m_nWidth; + int m_nHeight; + float m_fAspect; + float m_NearClip; + float m_FarClip; + float m_fov; + HWND m_hWnd; + studiohdr_t *m_pStudioHdr; + studiohwdata_t *m_pStudioHWData; + int m_nLod; + float m_flTime; + float m_flPlaybackRate; + vgui::Panel *m_pMainPanel; +}; + + +static float g_yaw; +static float g_horizontalPan; +static float g_verticalPan; +static float g_zoom; +static int g_sequence; +static bool g_bWireframe; + +DEFINE_WINDOWED_STEAM_APPLICATION_OBJECT( CTest360App ); + +#if defined( USE_MATERIALSYSTEM ) +static void MaterialSystem_Warning( const char *fmt, ... ) +{ + va_list argptr; + char msg[2048]; + + va_start( argptr, fmt ); + Q_vsnprintf( msg, sizeof ( msg ), fmt, argptr ); + va_end( argptr ); + + OutputDebugString( msg ); +} +#endif + +#if defined( USE_MATERIALSYSTEM ) +static void MaterialSystem_Warning( char *fmt, ... ) +{ + va_list argptr; + char msg[2048]; + + va_start( argptr, fmt ); + Q_vsnprintf( msg, sizeof( msg ), fmt, argptr ); + va_end( argptr ); + + OutputDebugString( msg ); +} +#endif + +virtualmodel_t *studiohdr_t::GetVirtualModel( void ) const +{ + if ( numincludemodels == 0 ) + return NULL; + return g_pMDLCache->GetVirtualModelFast( this, (MDLHandle_t)virtualModel ); +} +byte *studiohdr_t::GetAnimBlock( int i ) const +{ + return g_pMDLCache->GetAnimBlock( (MDLHandle_t)virtualModel, i ); +} +int studiohdr_t::GetAutoplayList( unsigned short **pOut ) const +{ + return g_pMDLCache->GetAutoplayList( (MDLHandle_t)virtualModel, pOut ); +} +const studiohdr_t *virtualgroup_t::GetStudioHdr( void ) const +{ + return g_pMDLCache->GetStudioHdr( (MDLHandle_t)cache ); +} + +#if defined( USE_STUDIORENDER ) +matrix3x4_t* CTest360App::SetUpBones( studiohdr_t *pStudioHdr, const matrix3x4_t &shapeToWorld ) +{ + // Default to middle of the pose parameter range + float pPoseParameter[MAXSTUDIOPOSEPARAM]; + for ( int i = 0; i < MAXSTUDIOPOSEPARAM; ++i ) + { + pPoseParameter[i] = 0.5f; + } + + CStudioHdr studioHdr( pStudioHdr, g_pMDLCache ); + + int nFrameCount = Studio_MaxFrame( &studioHdr, g_sequence, pPoseParameter ); + if ( nFrameCount == 0 ) + { + nFrameCount = 1; + } + float flCycle = ( m_flTime * m_flPlaybackRate ) / nFrameCount; + + // FIXME: We're always wrapping; may want to determing if we should clamp + flCycle -= (int)(flCycle); + + int boneMask = BONE_USED_BY_VERTEX_AT_LOD( m_nLod ); + + Vector pos[MAXSTUDIOBONES]; + Quaternion q[MAXSTUDIOBONES]; + + IBoneSetup boneSetup( &studioHdr, boneMask, pPoseParameter ); + boneSetup.InitPose( pos, q ); + boneSetup.AccumulatePose( pos, q, g_sequence, flCycle, 1.0f, m_flTime, NULL ); + + // FIXME: Try enabling this? +// CalcAutoplaySequences( pStudioHdr, NULL, pos, q, pPoseParameter, BoneMask( ), flTime ); + + // Root transform + matrix3x4_t rootToWorld, temp; + + MatrixCopy( shapeToWorld, rootToWorld ); + + matrix3x4_t *pBoneToWorld = g_pStudioRender->LockBoneMatrices( studioHdr.numbones() ); + for ( int i = 0; i < studioHdr.numbones(); i++ ) + { + // If it's not being used, fill with NAN for errors + if ( !(studioHdr.pBone( i )->flags & boneMask) ) + { + int j, k; + for (j = 0; j < 3; j++) + { + for (k = 0; k < 4; k++) + { + pBoneToWorld[i][j][k] = VEC_T_NAN; + } + } + continue; + } + + matrix3x4_t boneMatrix; + QuaternionMatrix( q[i], boneMatrix ); + MatrixSetColumn( pos[i], 3, boneMatrix ); + + if (studioHdr.pBone(i)->parent == -1) + { + ConcatTransforms (rootToWorld, boneMatrix, pBoneToWorld[i]); + } + else + { + ConcatTransforms (pBoneToWorld[ studioHdr.pBone(i)->parent ], boneMatrix, pBoneToWorld[i] ); + } + } + return pBoneToWorld; +} +#endif + +//-------------------------------------------------------------------------------------- +// LoadModel +// +//-------------------------------------------------------------------------------------- +#if defined( USE_STUDIORENDER ) +bool CTest360App::LoadModel( const char* pModelName ) +{ + MDLHandle_t hMdl = g_pMDLCache->FindMDL( pModelName ); + + m_pStudioHdr = g_pMDLCache->GetStudioHdr( hMdl ); + + g_pMDLCache->GetVertexData( hMdl ); + g_pMDLCache->FinishPendingLoads(); + + g_pMDLCache->GetHardwareData( hMdl ); + g_pMDLCache->FinishPendingLoads(); + + m_pStudioHWData = g_pMDLCache->GetHardwareData( hMdl ); + + g_sequence = 0; + m_nLod = 0; + m_flPlaybackRate = 30.0; + g_yaw = 0; + g_zoom = -100; + g_horizontalPan = 0; + g_verticalPan = -30; + + return true; +} +#endif + +//-------------------------------------------------------------------------------------- +// SetupMaterialSystem +// +//-------------------------------------------------------------------------------------- +#if defined( USE_MATERIALSYSTEM ) +bool CTest360App::SetupMaterialSystem() +{ + 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; + + bool modeSet = m_pMaterialSystem->SetMode( m_hWnd, config ); + if ( !modeSet ) + { + Error( "Failed to set mode\n" ); + return false; + } + + m_pMaterialSystem->OverrideConfig( config, false ); + + GetClientRect( m_hWnd, &rect ); + m_nWidth = rect.right; + m_nHeight = rect.bottom; + m_fAspect = (float)m_nWidth/(float)m_nHeight; + + m_NearClip = 8.0f; + m_FarClip = 28400.0f; + m_fov = 90; + + return true; +} +#endif + +//-------------------------------------------------------------------------------------- +// SetupStudioRender +// +//-------------------------------------------------------------------------------------- +#if defined( USE_STUDIORENDER ) +bool CTest360App::SetupStudioRender() +{ + StudioRenderConfig_t config; + memset( &config, 0, sizeof(config) ); + + config.bEyeMove = false; + config.bTeeth = true; + config.bEyes = true; + config.bFlex = true; + + config.fEyeShiftX = 0.0f; + config.fEyeShiftY = 0.0f; + config.fEyeShiftZ = 0.0f; + config.fEyeSize = 0.0f; + + config.bNoHardware = false; + config.bNoSoftware = false; + + config.bSoftwareSkin = false; + config.bSoftwareLighting = false; + + config.drawEntities = true; + config.bWireframe = false; + config.SetNormals( false ); + config.SetTangentFrame( false ); + config.skin = 0; + + config.fullbright = 0; + config.pConDPrintf = MaterialSystem_Warning; + config.pConPrintf = MaterialSystem_Warning; + + config.bShowEnvCubemapOnly = false; + + g_pStudioRender->UpdateConfig( config ); + + return true; +} +#endif + +//-------------------------------------------------------------------------------------- +// Render a model using the MaterialSystem +//-------------------------------------------------------------------------------------- +void CTest360App::RenderScene() +{ + m_flTime = Plat_FloatTime(); + +#if defined( USE_MATERIALSYSTEM ) + CMatRenderContextPtr pRenderContext( m_pMaterialSystem ); + m_pMaterialSystem->BeginFrame(); +#endif + +#if defined( USE_STUDIORENDER ) + g_pStudioRender->BeginFrame(); +#endif + +#if defined( USE_MATERIALSYSTEM ) + pRenderContext->ClearColor3ub( 0, 0, 0 ); + pRenderContext->ClearBuffers( true, true ); +#endif + +#if defined( USE_STUDIORENDER ) + pRenderContext->Viewport( 0, 0, m_nWidth, m_nHeight ); + pRenderContext->MatrixMode( MATERIAL_PROJECTION ); + pRenderContext->LoadIdentity(); + pRenderContext->PerspectiveX( m_fov, m_fAspect, m_NearClip, m_FarClip ); + + pRenderContext->MatrixMode( MATERIAL_VIEW ); + pRenderContext->LoadIdentity(); + pRenderContext->Translate( g_horizontalPan, g_verticalPan, g_zoom ); + + pRenderContext->MatrixMode( MATERIAL_MODEL ); + pRenderContext->LoadIdentity(); + + g_pStudioRender->SetLocalLights( 0, NULL ); + pRenderContext->SetAmbientLight( 1.0, 1.0, 1.0 ); + + QAngle angles; + angles[YAW] = 0; + angles[PITCH] = -90 + g_yaw; + angles[ROLL] = -90; + + matrix3x4_t cameraMatrix; + AngleMatrix( angles, cameraMatrix ); + + static Vector white[6] = + { + Vector( 1.0, 1.0, 1.0 ), + Vector( 1.0, 1.0, 1.0 ), + Vector( 1.0, 1.0, 1.0 ), + Vector( 1.0, 1.0, 1.0 ), + Vector( 1.0, 1.0, 1.0 ), + Vector( 1.0, 1.0, 1.0 ), + }; + g_pStudioRender->SetAmbientLightColors( white ); + + matrix3x4_t *pBoneToWorld = SetUpBones( m_pStudioHdr, cameraMatrix ); + + Vector modelOrigin( 0, 0, 0 ); + + pRenderContext->MatrixMode( MATERIAL_MODEL ); + pRenderContext->PushMatrix(); + + DrawModelInfo_t modelInfo; + memset( &modelInfo, 0, sizeof( modelInfo ) ); + modelInfo.m_pStudioHdr = m_pStudioHdr; + modelInfo.m_pHardwareData = m_pStudioHWData; + modelInfo.m_Decals = STUDIORENDER_DECAL_INVALID; + modelInfo.m_Skin = 0; + modelInfo.m_Body = 0; + modelInfo.m_HitboxSet = 0; + modelInfo.m_pClientEntity = NULL; + modelInfo.m_Lod = 0; + modelInfo.m_ppColorMeshes = NULL; + + int drawFlags = 0; + if ( g_bWireframe ) + { + drawFlags |= STUDIORENDER_DRAW_WIREFRAME; + } + + g_pStudioRender->DrawModel( NULL, modelInfo, pBoneToWorld, modelOrigin, drawFlags ); + + pRenderContext->MatrixMode( MATERIAL_MODEL ); + pRenderContext->PopMatrix(); +#endif + +#if defined( USE_MATERIALSYSTEM ) + pRenderContext->Flush( true ); +#endif + +#if defined( USE_VGUI ) + vgui::ivgui()->RunFrame(); + vgui::surface()->PaintTraverseEx( vgui::surface()->GetEmbeddedPanel() ); +#endif + +#if defined( USE_STUDIORENDER ) + g_pStudioRender->EndFrame(); +#endif + +#if defined( USE_MATERIALSYSTEM ) + m_pMaterialSystem->EndFrame(); + m_pMaterialSystem->SwapBuffers(); +#endif +} + +//-------------------------------------------------------------------------------------- +// 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_XCONTROLLER_INSERTED: + Msg( "Port %d: Gamepad Activated\n", wParam ); + break; + + case WM_XCONTROLLER_UNPLUGGED: + Msg( "Port %d: Gamepad Unplugged\n", wParam ); + break; + + case WM_XCONTROLLER_KEY: + // wParam == key + // HIWORD( lParam ) = port + // LOWWORD( lParam ) = sample + Msg( "Port %d: Button %d %s\n", HIWORD( lParam ), wParam, LOWORD( lParam ) ? "Pressed" : "Released" ); + switch ( wParam ) + { + case XK_BUTTON_RTRIGGER: + if ( LOWORD( lParam ) ) + { + g_zoom++; + } + break; + + case XK_BUTTON_LTRIGGER: + if ( LOWORD( lParam ) ) + { + g_zoom--; + } + break; + + case XK_BUTTON_DOWN: + if ( LOWORD( lParam ) ) + { + g_verticalPan += 2; + } + break; + + case XK_BUTTON_UP: + if ( LOWORD( lParam ) ) + { + g_verticalPan -= 2; + } + break; + + case XK_BUTTON_LEFT: + if ( LOWORD( lParam ) ) + { + g_horizontalPan += 2; + } + break; + + case XK_BUTTON_RIGHT: + if ( LOWORD( lParam ) ) + { + g_horizontalPan -= 2; + } + break; + + case XK_STICK2_LEFT: + if ( LOWORD( lParam ) ) + { + g_yaw += 5; + } + break; + + case XK_STICK2_RIGHT: + if ( LOWORD( lParam ) ) + { + g_yaw -= 5; + } + break; + + case XK_BUTTON_A: + if ( LOWORD( lParam ) ) + { + g_sequence++; + } + break; + + case XK_BUTTON_B: + if ( LOWORD( lParam ) ) + { + g_sequence--; + if ( g_sequence < 0 ) + g_sequence = 0; + } + break; + + case XK_BUTTON_Y: + if ( LOWORD( lParam ) ) + { + g_bWireframe ^= 1; + } + break; + } + break; + + case WM_KEYDOWN: + switch ( wParam ) + { + case 'O': + g_zoom++; + break; + + case 'P': + g_zoom--; + break; + + case 'W': + g_verticalPan += 2; + break; + + case 'S': + g_verticalPan -= 2; + break; + + case 'A': + g_horizontalPan += 2; + break; + + case 'D': + g_horizontalPan -= 2; + break; + + case 'N': + g_sequence--; + if ( g_sequence < 0 ) + g_sequence = 0; + break; + + case 'M': + g_sequence++; + break; + } + break; + } + + return DefWindowProc( hWnd, iMsg, wParam, lParam ); +} + +//-------------------------------------------------------------------------------------- +// CreateMainWindow +// +//-------------------------------------------------------------------------------------- +bool CTest360App::CreateMainWindow( int width, int height, bool fullscreen ) +{ + 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 ( fullscreen ) + { + 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 ) + { + ChangeDisplaySettings( 0, 0 ); + Error( "Window creation failed\n" ); + return false; + } + + m_hWnd = hwnd; + + return true; +} + +//----------------------------------------------------------------------------- +// Create +//----------------------------------------------------------------------------- +bool CTest360App::Create() +{ + AppSystemInfo_t appSystems[] = + { +#if defined( USE_STUDIORENDER ) + { "datacache.dll", DATACACHE_INTERFACE_VERSION }, + { "datacache.dll", MDLCACHE_INTERFACE_VERSION }, +#endif +#if defined( USE_MATERIALSYSTEM ) + { "materialsystem.dll", MATERIAL_SYSTEM_INTERFACE_VERSION }, +#endif +#if defined( USE_STUDIORENDER ) + { "studiorender.dll", STUDIO_RENDER_INTERFACE_VERSION }, +#endif +#if defined( USE_INPUTSYSTEM ) + { "inputsystem.dll", INPUTSYSTEM_INTERFACE_VERSION }, +#endif +#if defined( USE_VGUI ) + { "vgui2.dll", VGUI_IVGUI_INTERFACE_VERSION }, + { "vguimatsurface.dll", VGUI_SURFACE_INTERFACE_VERSION }, +#endif +#if defined( USE_STUDIORENDER ) + { "vphysics.dll", VPHYSICS_INTERFACE_VERSION }, +#endif + { "", "" } + }; + + MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f ); + + SpewOutputFunc( g_DefaultSpewFunc ); + +#if defined( USE_FILESYSTEM ) + // Add in the cvar factory + AppModule_t cvarModule = LoadModule( VStdLib_GetICVarFactory() ); + AddSystem( cvarModule, VENGINE_CVAR_INTERFACE_VERSION ); +#endif + +#if defined( _X360 ) + // vxconsole - true will block (legacy behavior) + XBX_InitConsoleMonitor( false ); +#endif + + if ( !AddSystems( appSystems ) ) + return false; + +#if defined( USE_FILESYSTEM ) + m_pFileSystem = (IFileSystem*)FindSystem( FILESYSTEM_INTERFACE_VERSION ); + if ( !m_pFileSystem ) + { + Error( "Failed to find %s\n", FILESYSTEM_INTERFACE_VERSION ); + return false; + } +#endif + +#if defined( USE_VPHYSICS ) + m_pCollision = (IPhysicsCollision*)FindSystem( VPHYSICS_COLLISION_INTERFACE_VERSION ); + if ( !m_pCollision ) + { + Error( "Failed to find %s\n", VPHYSICS_COLLISION_INTERFACE_VERSION ); + return false; + } +#endif + +#if defined( USE_MATERIALSYSTEM ) + m_pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION ); + if ( !m_pMaterialSystem ) + { + Error( "Failed to find %s\n", MATERIAL_SYSTEM_INTERFACE_VERSION ); + return false; + } +#if defined( _X360 ) + m_pFileSystem->LoadModule( "shaderapidx9.dll" ); +#endif + m_pMaterialSystem->SetShaderAPI( "shaderapidx9.dll" ); +#endif + + return true; +} + +//----------------------------------------------------------------------------- +// PreInit +//----------------------------------------------------------------------------- +bool CTest360App::PreInit() +{ +#if defined( USE_FILESYSTEM ) + // Add paths... + if ( !SetupSearchPaths( NULL, false, true ) ) + { + Error( "Failed to setup search paths\n" ); + return false; + } +#endif + + CreateInterfaceFn factory = GetFactory(); + ConnectTier1Libraries( &factory, 1 ); + ConnectTier2Libraries( &factory, 1 ); + ConnectTier3Libraries( &factory, 1 ); + + // 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 ( !CreateMainWindow( 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 ); + + return true; +} + +//----------------------------------------------------------------------------- +// Destroy +//----------------------------------------------------------------------------- +void CTest360App::Destroy() +{ +} + +//----------------------------------------------------------------------------- +// Purpose: Setup all our VGUI info +//----------------------------------------------------------------------------- +#if defined( USE_VGUI ) + +static CreateInterfaceFn s_pFactoryList[3]; + +void *VGuiFactory( const char *pName, int *pReturnCode ) +{ + for ( int i = 0; i < ARRAYSIZE( s_pFactoryList ); ++i ) + { + void *pInterface = s_pFactoryList[i]( pName, pReturnCode ); + if ( pInterface ) + return pInterface; + } + return NULL; +} + +int CTest360App::InitializeVGUI( void ) +{ + s_pFactoryList[0] = Sys_GetFactory( m_pFileSystem->LoadModule( "filesystem_stdio" ) ); + s_pFactoryList[1] = Sys_GetFactory( m_pFileSystem->LoadModule( "vguimatsurface" ) ); + s_pFactoryList[2] = Sys_GetFactory( m_pFileSystem->LoadModule( "vgui2" ) ); + int factorycount = ARRAYSIZE( s_pFactoryList ); + + if ( !vgui::VGui_InitInterfacesList( "test360", s_pFactoryList, factorycount ) ) + return 3; + + vgui::ivgui()->Connect( VGuiFactory ); + vgui::ivgui()->Init(); + + vgui::ivgui()->SetSleep(false); + + // Init the surface + vgui::Panel *pPanel = new vgui::Panel( NULL, "TopPanel" ); + pPanel->SetBounds( 0, 0, m_nWidth, m_nHeight ); + pPanel->SetPaintBackgroundEnabled( false ); + pPanel->SetVisible(true); + + vgui::surface()->SetEmbeddedPanel(pPanel->GetVPanel()); + + // load the scheme + vgui::scheme()->LoadSchemeFromFile( "resource/clientscheme.res", NULL ); + + // localization + //vgui::localize()->AddFile( "resource/vgui_%language%.txt" ); + + // Start vgui + vgui::ivgui()->Start(); + + // add a panel + m_pMainPanel = new vgui::Panel( pPanel, "MainPanel" ); + SETUP_PANEL( m_pMainPanel ); + m_pMainPanel->SetBounds( 30, 30, 200, 100 ); + m_pMainPanel->SetBgColor( Color(255,255,0,255) ); + + // add text + vgui::Label *pLabel = new vgui::Label( m_pMainPanel, "Text", L"" ); + SETUP_PANEL( pLabel ); + + vgui::HScheme scheme = vgui::scheme()->GetScheme( "ClientScheme" ); +// vgui::HFont hFont = vgui::scheme()->GetIScheme(scheme)->GetFont( "BudgetLabel" ); +// pLabel->SetFont( hFont ); + pLabel->SetText( L"This is text" ); + + pLabel->SetFgColor( Color(0,0,0,255) ); + + return 0; +} +#endif + +//----------------------------------------------------------------------------- +// Purpose: Stop VGUI +//----------------------------------------------------------------------------- +#if defined( USE_VGUI ) +void CTest360App::ShutdownVGUI( void ) +{ + delete m_pMainPanel; + + // Shutdown + vgui::surface()->Shutdown(); +} +#endif + +//----------------------------------------------------------------------------- +// Main +//----------------------------------------------------------------------------- +int CTest360App::Main() +{ +#if defined( USE_MATERIALSYSTEM ) + if ( !SetupMaterialSystem() ) + { + return 0; + } +#endif + +#if defined( USE_STUDIORENDER ) + if ( !SetupStudioRender() ) + { + return 0; + } +#endif + +#if defined( USE_VGUI ) + int ret = InitializeVGUI(); + if ( ret != 0 ) + return ret; +#endif + + const char *pArgVal; + const char* pModelName = "models\\alyx.mdl"; + if ( CommandLine()->CheckParm( "-model", &pArgVal ) ) + { + pModelName = pArgVal; + } + +#if defined( USE_STUDIORENDER ) + // the easiest model to load - no anims + //const char* pModelName = "models\\items\\item_item_crate.mdl"; + if ( !LoadModel( pModelName ) ) + { + return 0; + } +#endif + + MSG msg; + while ( g_bActive == TRUE ) + { + while ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) ) + { + TranslateMessage( &msg ); + DispatchMessage( &msg ); + } + +#if defined( USE_INPUTSYSTEM ) + g_pInputSystem->PollInputState(); +#endif + RenderScene(); + } + +#if defined( USE_VGUI ) + ShutdownVGUI(); +#endif + + return 0; +} diff --git a/utils/xbox/dumpobj/dumpobj.cpp b/utils/xbox/dumpobj/dumpobj.cpp new file mode 100644 index 0000000..e074d25 --- /dev/null +++ b/utils/xbox/dumpobj/dumpobj.cpp @@ -0,0 +1,407 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +/***************************************************************************** + DUMPOBJ.CPP + +*****************************************************************************/ +#include "..\toollib\toollib.h" + +typedef struct section_s +{ + int size; + char* name; + section_s* nextPtr; +} section_t; + +typedef struct obj_s +{ + char* filename; + section_t* sectionPtr; + obj_s* nextPtr; +} obj_t; + +obj_t* g_obj_head; +char g_sectionName[128]; +bool g_bVerbose; + +typedef struct +{ + char* filename; + int size; +} entry_t; + +/*********************************************************** + _SortCallback + +***********************************************************/ +int _SortCallback(const void *a, const void *b) +{ + entry_t* aPtr; + entry_t* bPtr; + + aPtr = (entry_t*)a; + bPtr = (entry_t*)b; + + return (aPtr->size-bPtr->size); +} + +/*********************************************************** + FreeInfo + +***********************************************************/ +void FreeInfo() +{ + obj_t* objPtr; + obj_t* nextObjPtr; + section_t* sectionPtr; + section_t* nextSectionPtr; + + objPtr = g_obj_head; + while (objPtr) + { + nextObjPtr = objPtr->nextPtr; + sectionPtr = objPtr->sectionPtr; + while (sectionPtr) + { + nextSectionPtr = sectionPtr->nextPtr; + + TL_Free(sectionPtr->name); + TL_Free(sectionPtr); + + sectionPtr = nextSectionPtr; + } + + TL_Free(objPtr->filename); + TL_Free(objPtr); + + objPtr = nextObjPtr; + } +} + +/*********************************************************** + AnalyzeData + +***********************************************************/ +void AnalyzeData() +{ + obj_t* objPtr; + section_t* sectionPtr; + char* sections[128]; + int totals[128]; + int numSections; + int i; + int index; + int numEntries; + entry_t* entries; + int total; + + printf("\n"); + + memset(totals, 0, sizeof(totals)); + + // determine unique sections + numSections = 0; + objPtr = g_obj_head; + while (objPtr) + { + sectionPtr = objPtr->sectionPtr; + while (sectionPtr) + { + for (i=0; i<numSections; i++) + { + if (!stricmp(sections[i],sectionPtr->name)) + break; + } + if (i >= numSections) + { + // add it + sections[numSections] = sectionPtr->name; + numSections++; + assert(numSections < 128); + + index = numSections-1; + } + else + index = i; + + totals[index] += sectionPtr->size; + + sectionPtr = sectionPtr->nextPtr; + } + objPtr = objPtr->nextPtr; + } + + if (g_sectionName[0]) + { + // dump only matching section + printf("Section: %s\n", g_sectionName); + printf("-------------------------\n"); + + // tally entries + numEntries = 0; + objPtr = g_obj_head; + while (objPtr) + { + sectionPtr = objPtr->sectionPtr; + while (sectionPtr) + { + if (!stricmp(g_sectionName, sectionPtr->name)) + numEntries++; + sectionPtr = sectionPtr->nextPtr; + } + objPtr = objPtr->nextPtr; + } + + // fill entries + if (numEntries) + { + entries = (entry_t*)TL_Malloc(numEntries*sizeof(entry_t)); + numEntries = 0; + objPtr = g_obj_head; + while (objPtr) + { + sectionPtr = objPtr->sectionPtr; + while (sectionPtr) + { + if (!stricmp(g_sectionName, sectionPtr->name)) + { + entries[numEntries].size = sectionPtr->size; + entries[numEntries].filename = objPtr->filename; + numEntries++; + } + sectionPtr = sectionPtr->nextPtr; + } + objPtr = objPtr->nextPtr; + } + + // sort + qsort(entries, numEntries, sizeof(entry_t), _SortCallback); + + // display results + int total = 0; + for (i=0; i<numEntries; i++) + { + printf("%8d %s\n", entries[i].size, entries[i].filename); + total += entries[i].size; + } + printf("-------------------------\n"); + printf("%8d Total\n", total); + + TL_Free(entries); + } + } + else + { + // dump all sections + printf("Sections:\n"); + printf("---------\n"); + total = 0; + for (i=0; i<numSections; i++) + { + printf("%8d %s\n", totals[i], sections[i]); + total += totals[i]; + } + printf("---------\n"); + printf("%8d\n", total); + } +} + + +/*********************************************************** + LocalExec + +***********************************************************/ +int LocalExec(const char* batfilename, const char* arg1) +{ + intptr_t pid; + int errcode; + const char* args[8]; + + args[0] = batfilename; + args[1] = arg1; + args[2] = NULL; + + pid = _spawnvp(P_NOWAIT, batfilename, args); + _cwait(&errcode, pid, 0); + + return (errcode); +} + +/***************************************************************************** + GetInfo + +*****************************************************************************/ +void GetInfo(char* objFilename, char* batFilename, char* logFilename) +{ + char buff[TL_MAXPATH]; + int size; + char name[128]; + char* ptr; + int errcode; + char* token; + obj_t* objPtr; + section_t* sectionPtr; + + if (g_bVerbose) + printf("%s\n", objFilename); + + ptr = objFilename; + if (!strnicmp(objFilename,".\\",2)) + { + ptr += 2; + + getcwd(buff, sizeof(buff)); + TL_AddSeperatorToPath(buff, buff); + + strcat(buff, ptr); + } + else + strcpy(buff, objFilename); + + // exec the batch file with the obj file + errcode = LocalExec(batFilename, buff); + if (errcode) + { + printf("Failed on %s\n", buff); + return; + } + + // add new object node + objPtr = (obj_t*)TL_Malloc(sizeof(obj_t)); + objPtr->filename = (char*)TL_Malloc((int)strlen(objFilename)+1); + strcpy(objPtr->filename, objFilename); + + // link it in + objPtr->nextPtr = g_obj_head; + g_obj_head = objPtr; + + // read the results + TL_LoadScriptFile(logFilename); + + while (1) + { + token = TL_GetToken(true); + if (!token || !token[0]) + break; + + if (!stricmp(token, "summary")) + break; + else + TL_SkipRestOfLine(); + } + + while (1) + { + token = TL_GetToken(true); + if (!token || !token[0]) + break; + sscanf(token, "%x", &size); + + token = TL_GetToken(true); + if (!token || !token[0]) + break; + strcpy(name, token); + + // add new section node + sectionPtr = (section_t*)TL_Malloc(sizeof(section_t)); + sectionPtr->name = (char*)TL_Malloc((int)strlen(name)+1); + strcpy(sectionPtr->name, name); + sectionPtr->size = size; + + // link it in + sectionPtr->nextPtr = objPtr->sectionPtr; + objPtr->sectionPtr = sectionPtr; + } + + TL_FreeScriptFile(); +} + +/***************************************************************************** + Usage + +*****************************************************************************/ +void Usage(void) +{ + printf("usage: dumpobj <*.obj> [-s section] [-r] [-v]\n"); + exit(-1); +} + +/***************************************************************************** + main + +*****************************************************************************/ +int main(int argc, char* argv[]) +{ + tlfile_t** filelist; + int filecount; + int i; + int recurse; + int section; + FILE* fp; + char* vcvarsPath; + char batFilename[TL_MAXPATH]; + char txtFilename[TL_MAXPATH]; + + batFilename[0] = '\0'; + txtFilename[0] = '\0'; + + TL_Setup("DUMPOBJ",argc,argv); + + // find critical path to vcvars32.bat + vcvarsPath = "c:\\Program Files\\Microsoft Visual Studio .Net 2003\\Vc7\\bin\\vcvars32.bat"; + if (!TL_Exists(vcvarsPath)) + TL_Error("Cannot find: %s\n", vcvarsPath); + + if (argc < 2) + Usage(); + + recurse = TL_CheckParm("r"); + filecount = TL_FindFiles2(argv[1], recurse != 0, &filelist); + + g_bVerbose = TL_CheckParm("v") != 0; + + section = TL_CheckParm("s"); + if (section && section+1 < argc) + strcpy(g_sectionName, argv[section+1]); + else + g_sectionName[0] = '\0'; + + strcpy(batFilename,"c:\\"); + TL_TempFilename(batFilename); + TL_ReplaceDosExtension(batFilename, ".bat"); + + strcpy(txtFilename,"c:\\"); + TL_TempFilename(txtFilename); + TL_ReplaceDosExtension(txtFilename, ".txt"); + + if (filecount) + { + // create bat file + fp = fopen(batFilename, "wt+"); + if (!fp) + TL_Error("Could not open bat file '%s'", batFilename); + + fprintf(fp, "@echo off\n"); + fprintf(fp, "@call \"%s\" > nul: \n", vcvarsPath); + fprintf(fp, "@dumpbin %%1 > %s\n", txtFilename); + fclose(fp); + } + + for (i=0; i<filecount; i++) + GetInfo(filelist[i]->filename, batFilename, txtFilename); + + if (filecount) + AnalyzeData(); + + if (filecount) + { + FreeInfo(); + unlink(batFilename); + unlink(txtFilename); + } + + TL_FreeFileList(filecount,filelist); + + TL_End(false); + + return (0); +}
\ No newline at end of file diff --git a/utils/xbox/dumpobj/dumpobj.vcproj b/utils/xbox/dumpobj/dumpobj.vcproj new file mode 100644 index 0000000..2227140 --- /dev/null +++ b/utils/xbox/dumpobj/dumpobj.vcproj @@ -0,0 +1,156 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="7.10" + Name="dumpobj" + ProjectGUID="{620FC3E4-31D4-49F4-A66C-089A543FB140}" + Keyword="Win32Proj"> + <Platforms> + <Platform + Name="Win32"/> + </Platforms> + <Configurations> + <Configuration + Name="Debug|Win32" + OutputDirectory="Debug" + IntermediateDirectory="Debug" + ConfigurationType="1" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE" + MinimalRebuild="TRUE" + BasicRuntimeChecks="3" + RuntimeLibrary="5" + UsePrecompiledHeader="0" + WarningLevel="3" + Detect64BitPortabilityProblems="FALSE" + DebugInformationFormat="4"/> + <Tool + Name="VCCustomBuildTool" + CommandLine="if exist $(TargetPath) copy $(TargetPath) c:\bin_utils\$(TargetFileName)" + Outputs="c:\bin_utils\$(TargetFileName)"/> + <Tool + Name="VCLinkerTool" + OutputFile="$(OutDir)/dumpobj.exe" + LinkIncremental="2" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile="$(OutDir)/dumpobj.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool"/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + <Configuration + Name="Release|Win32" + OutputDirectory="Release" + IntermediateDirectory="Release" + ConfigurationType="1" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE" + RuntimeLibrary="4" + UsePrecompiledHeader="0" + WarningLevel="3" + Detect64BitPortabilityProblems="FALSE" + DebugInformationFormat="3"/> + <Tool + Name="VCCustomBuildTool" + CommandLine="if exist ..\..\..\..\game\bin\"$(TargetName)".exe attrib -r ..\..\..\..\game\bin\"$(TargetName)".exe +if exist "$(TargetPath)" copy "$(TargetPath)" ..\..\..\..\game\bin +" + Outputs="..\..\..\..\game\bin\$(TargetName).exe"/> + <Tool + Name="VCLinkerTool" + OutputFile="$(OutDir)/dumpobj.exe" + LinkIncremental="1" + GenerateDebugInformation="TRUE" + SubSystem="1" + OptimizeReferences="2" + EnableCOMDATFolding="2" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool"/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" + UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> + <File + RelativePath=".\dumpobj.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\toollib\scriplib.cpp"> + </File> + <File + RelativePath="..\toollib\toollib.cpp"> + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl;inc;xsd" + UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> + <File + RelativePath="..\toollib\scriplib.h"> + </File> + <File + RelativePath="..\toollib\toollib.h"> + </File> + </Filter> + <Filter + Name="Resource Files" + Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx" + UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"> + </Filter> + </Files> + <Globals> + </Globals> +</VisualStudioProject> diff --git a/utils/xbox/makephx/makephx.cpp b/utils/xbox/makephx/makephx.cpp new file mode 100644 index 0000000..8473005 --- /dev/null +++ b/utils/xbox/makephx/makephx.cpp @@ -0,0 +1,359 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +#include "stdafx.h" +#include "physdll.h" +#include "vphysics/constraints.h" +#include "tier0/icommandline.h" +#include "filesystem_tools.h" +#include "simplify.h" +#include "keyvalues.h" +#include "studio.h" + +IPhysicsCollision *physcollision = NULL; +IPhysicsSurfaceProps *physprops = NULL; + +int g_TotalOut = 0; +int g_TotalCompress = 0; +bool g_bRecursive = false; +bool g_bQuiet = false; + +KeyValues *g_pModelConfig = NULL; + +void InitFilesystem( const char *pPath ) +{ + CmdLib_InitFileSystem( pPath ); + // This bit of hackery allows us to access files on the harddrive + g_pFullFileSystem->AddSearchPath( "", "LOCAL", PATH_ADD_TO_HEAD ); +} + +static bool LoadSurfaceProps( const char *pMaterialFilename ) +{ + if ( !physprops ) + return false; + + FileHandle_t fp = g_pFileSystem->Open( pMaterialFilename, "rb", TOOLS_READ_PATH_ID ); + if ( fp == FILESYSTEM_INVALID_HANDLE ) + return false; + + int len = g_pFileSystem->Size( fp ); + char *pText = new char[len+1]; + g_pFileSystem->Read( pText, len, fp ); + g_pFileSystem->Close( fp ); + + pText[len]=0; + + physprops->ParseSurfaceData( pMaterialFilename, pText ); + + delete[] pText; + + return true; +} + +void LoadSurfacePropsAll() +{ + // already loaded + if ( physprops->SurfacePropCount() ) + return; + + const char *SURFACEPROP_MANIFEST_FILE = "scripts/surfaceproperties_manifest.txt"; + KeyValues *manifest = new KeyValues( SURFACEPROP_MANIFEST_FILE ); + if ( manifest->LoadFromFile( g_pFileSystem, SURFACEPROP_MANIFEST_FILE, "GAME" ) ) + { + for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() ) + { + if ( !Q_stricmp( sub->GetName(), "file" ) ) + { + // Add + LoadSurfaceProps( sub->GetString() ); + continue; + } + } + } + + manifest->deleteThis(); +} +void InitVPhysics() +{ + CreateInterfaceFn physicsFactory = GetPhysicsFactory(); + physcollision = (IPhysicsCollision *)physicsFactory( VPHYSICS_COLLISION_INTERFACE_VERSION, NULL ); + physprops = (IPhysicsSurfaceProps *)physicsFactory( VPHYSICS_SURFACEPROPS_INTERFACE_VERSION, NULL ); + LoadSurfacePropsAll(); +} + +struct phyfile_t +{ + phyheader_t header; + vcollide_t collide; + int fileSize; +}; + +void LoadPHYFile(phyfile_t *pOut, const char *name) +{ + memset( pOut, 0, sizeof(*pOut) ); + FileHandle_t file = g_pFullFileSystem->Open( name, "rb" ); + if ( !file ) + return; + + g_pFullFileSystem->Read( &pOut->header, sizeof(pOut->header), file ); + if ( pOut->header.size != sizeof(pOut->header) || pOut->header.solidCount <= 0 ) + return; + + pOut->fileSize = g_pFullFileSystem->Size( file ); + + char *buf = (char *)_alloca( pOut->fileSize ); + g_pFullFileSystem->Read( buf, pOut->fileSize, file ); + g_pFullFileSystem->Close( file ); + + physcollision->VCollideLoad( &pOut->collide, pOut->header.solidCount, (const char *)buf, pOut->fileSize ); +} + + +void OverrideDefaultsForModel( const char *keyname, simplifyparams_t ¶ms ) +{ + KeyValues *pKeys = g_pModelConfig; + while ( pKeys ) + { + if ( !Q_stricmp( pKeys->GetName(), keyname ) ) + { + for ( KeyValues *pData = pKeys->GetFirstSubKey(); pData; pData = pData->GetNextKey() ) + { + if ( !Q_stricmp( pData->GetName(), "tolerance" ) ) + { + params.tolerance = pData->GetFloat(); + if (!g_bQuiet) + { + Msg("%s: tolerance set to %.2f\n", keyname, params.tolerance ); + } + } + else if ( !Q_stricmp( pData->GetName(), "addAABB" ) ) + { + params.addAABBToSimplifiedHull = pData->GetInt() ? true : false; + if (!g_bQuiet) + { + Msg("%s: AABB %s\n", keyname, params.addAABBToSimplifiedHull ? "on" : "off" ); + } + } + else if ( !Q_stricmp( pData->GetName(), "singleconvex" ) ) + { + params.forceSingleConvex = pData->GetInt() ? true : false; + if (!g_bQuiet) + { + Msg("%s: Forced to single convex\n", keyname ); + } + } + else if ( !Q_stricmp( pData->GetName(), "mergeconvex" ) ) + { + params.mergeConvexTolerance = pData->GetFloat(); + params.mergeConvexElements = params.mergeConvexTolerance > 0 ? true : false; + if (!g_bQuiet) + { + Msg("%s: Merge convex %.2f\n", keyname, params.mergeConvexTolerance ); + } + } + } + return; + } + pKeys = pKeys->GetNextKey(); + } +} + +bool HasMultipleBones( const char *pFilename ) +{ + char outName[1024]; + studiohdr_t hdr; + Q_strncpy( outName, pFilename, sizeof(outName) ); + Q_SetExtension( outName, ".mdl", sizeof(outName) ); + FileHandle_t fp = g_pFileSystem->Open( outName, "rb", TOOLS_READ_PATH_ID ); + if ( fp == FILESYSTEM_INVALID_HANDLE ) + return false; + + g_pFileSystem->Read( &hdr, sizeof(hdr), fp ); + g_pFileSystem->Close( fp ); + if ( hdr.numbones > 1 ) + return true; + return false; +} + +void WritePHXFile( const char *pName, const phyfile_t &file ) +{ + if ( file.header.size != sizeof(file.header) || file.collide.solidCount <= 0 ) + return; + + CUtlBuffer out; + + char outName[1024]; + Q_snprintf( outName, sizeof(outName), "%s", pName ); + Q_SetExtension( outName, ".phx", sizeof(outName) ); + + simplifyparams_t params; + params.Defaults(); + params.tolerance = (file.collide.solidCount > 1) ? 4.0f : 2.0f; + // single solids constraint to AABB for placement help + params.addAABBToSimplifiedHull = (file.collide.solidCount == 1) ? true : false; + params.mergeConvexElements = true; + params.mergeConvexTolerance = 0.025f; + Q_FixSlashes(outName); + Q_strlower(outName); + char *pSearch = Q_strstr( outName,"models\\" ); + if ( pSearch ) + { + char keyname[1024]; + pSearch += strlen("models\\"); + Q_StripExtension( pSearch, keyname, sizeof(keyname) ); + OverrideDefaultsForModel( keyname, params ); + } + out.Put( &file.header, sizeof(file.header) ); + int outSize = 0; + bool bStoreSolidNames = file.collide.solidCount > 1 ? true : false; + bStoreSolidNames = bStoreSolidNames || HasMultipleBones(outName); + + vcollide_t *pNewCollide = ConvertVCollideToPHX( &file.collide, params, &outSize, false, bStoreSolidNames); + g_TotalOut += file.fileSize; + for ( int i = 0; i < pNewCollide->solidCount; i++ ) + { + int collideSize = physcollision->CollideSize( pNewCollide->solids[i] ); + out.PutInt( collideSize ); + char *pMem = new char[collideSize]; + physcollision->CollideWrite( pMem, pNewCollide->solids[i] ); + out.Put( pMem, collideSize ); + delete[] pMem; + } + + if (!g_bQuiet) + { + Msg("%s Compressed %d (%d text) to %d (%d text)\n", outName, file.fileSize, file.collide.descSize, out.TellPut(), pNewCollide->descSize ); + } + out.Put( pNewCollide->pKeyValues, pNewCollide->descSize ); + g_TotalCompress += out.TellPut(); + +#if 0 + //Msg("OLD:\n-----------------------------------\n%s\n", file.collide.pKeyValues ); + CPackedPhysicsDescription *pPacked = physcollision->CreatePackedDesc( pNewCollide->pKeyValues, pNewCollide->descSize ); + Msg("NEW:\n-----------------------------------\n" ); + for ( int i = 0; i < pPacked->m_solidCount; i++ ) + { + solid_t solid; + pPacked->GetSolid( &solid, i ); + Msg("index %d\n", solid.index ); + Msg("name %s\n", solid.name ); + Msg("mass %.2f\n", solid.params.mass ); + Msg("surfaceprop %s\n", solid.surfaceprop); + Msg("damping %.2f\n", solid.params.damping ); + Msg("rotdamping %.2f\n", solid.params.rotdamping ); + Msg("drag %.2f\n", solid.params.dragCoefficient ); + Msg("inertia %.2f\n", solid.params.inertia ); + Msg("volume %.2f\n", solid.params.volume ); + } +#endif + DestroyPHX( pNewCollide ); + if ( !g_pFullFileSystem->WriteFile( outName, NULL, out ) ) + Warning("Can't write file: %s\n", outName ); +} + +void UnloadPHYFile( phyfile_t *pFile ) +{ + physcollision->VCollideUnload( &pFile->collide ); + pFile->header.size = 0; +} + +void MakeFilename( char *pDest, int destSize, const char *pPathname, const char *pFilenameExt ) +{ + Q_strncpy(pDest, pPathname, destSize); + Q_AppendSlash(pDest, destSize); + Q_strncat(pDest, pFilenameExt, destSize); +} + +void MakeDirname( char *pDest, int destSize, const char *pPathname, const char *pSubdir ) +{ + MakeFilename(pDest, destSize , pPathname, pSubdir); +} + +int main( int argc, char *argv[] ) +{ + if ( argc < 2 ) + { + Msg("Usage:\nmakephx [options] <FILESPEC>\ne.g. makephx [-r] *.phy\n"); + return 0; + } + + CommandLine()->CreateCmdLine( argc, argv ); + g_bRecursive = CommandLine()->FindParm("-r") > 0 ? true : false; + g_bQuiet = CommandLine()->FindParm("-quiet") > 0 ? true : false; + InitFilesystem( "*.*" ); + InitVPhysics(); + // disable automatic packing, we want to do this ourselves. + physcollision->SetPackOnLoad( false ); + MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false ); + InstallSpewFunction(); + + g_pModelConfig = new KeyValues("config"); + g_pModelConfig->LoadFromFile( g_pFullFileSystem, "phx.cfg", "GAME" ); + g_TotalOut = 0; + g_TotalCompress = 0; + FileFindHandle_t handle; + char fullpath[1024], currentFile[1024], dirName[1024], nameext[256]; + strcpy( fullpath, argv[argc-1] ); + strcpy( fullpath, ExpandPath( fullpath ) ); + strcpy( fullpath, ExpandArg( fullpath ) ); + Q_strncpy(dirName, fullpath, sizeof(dirName)); + Q_StripFilename(dirName); + Q_strncpy(nameext, fullpath + strlen(dirName)+1, sizeof(nameext)); + CUtlVector< const char * > directoryList; + directoryList.AddToTail( strdup(dirName) ); + int current = 0; + int count = 0; + do + { + if ( g_bRecursive ) + { + MakeFilename( currentFile, sizeof(currentFile), directoryList[current], "*.*" ); + const char *pFilename = g_pFullFileSystem->FindFirst( currentFile, &handle ); + while ( pFilename ) + { + if ( pFilename[0] != '.' && g_pFullFileSystem->FindIsDirectory( handle ) ) + { + MakeDirname( currentFile, sizeof(currentFile), directoryList[current], pFilename ); + directoryList.AddToTail(strdup(currentFile)); + } + pFilename = g_pFullFileSystem->FindNext( handle ); + } + g_pFullFileSystem->FindClose( handle ); + } + + MakeFilename(currentFile, sizeof(currentFile), directoryList[current], nameext); + const char *pFilename = g_pFullFileSystem->FindFirst( currentFile, &handle ); + while ( pFilename ) + { + phyfile_t phy; + MakeFilename(currentFile, sizeof(currentFile), directoryList[current], pFilename); + LoadPHYFile( &phy, currentFile ); + if ( phy.collide.isPacked || phy.collide.solidCount < 1 ) + { + Msg("%s is not a valid PHY file\n", currentFile ); + } + else + { + WritePHXFile( currentFile, phy ); + count++; + } + UnloadPHYFile( &phy ); + pFilename = g_pFullFileSystem->FindNext( handle ); + } + g_pFullFileSystem->FindClose( handle ); + current++; + } while( current < directoryList.Count() ); + + if ( count ) + { + if (!g_bQuiet) + { + Msg("\n------\nTotal %s, %s\nSaved %s\n", Q_pretifymem( g_TotalOut ), Q_pretifymem( g_TotalCompress ), Q_pretifymem( g_TotalOut - g_TotalCompress ) ); + Msg("%.2f%% savings\n", ((float)(g_TotalOut-g_TotalCompress) / (float)g_TotalOut) * 100.0f ); + } + } + else + { + Msg("No files found in %s!\n", directoryList[current] ); + } + + return 0; +} diff --git a/utils/xbox/makephx/makephx.vcproj b/utils/xbox/makephx/makephx.vcproj new file mode 100644 index 0000000..90df4a1 --- /dev/null +++ b/utils/xbox/makephx/makephx.vcproj @@ -0,0 +1,300 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="7.10" + Name="makephx" + ProjectGUID="{FD9038D2-A941-4B5E-8E35-4205E650F120}" + Keyword="Win32Proj"> + <Platforms> + <Platform + Name="Win32"/> + </Platforms> + <Configurations> + <Configuration + Name="Debug|Win32" + OutputDirectory="..\..\..\..\game\bin\" + IntermediateDirectory="Debug" + ConfigurationType="1" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + AdditionalIncludeDirectories="..\..\..\public;..\..\common;..\..\..\public\tier1" + PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE" + MinimalRebuild="TRUE" + BasicRuntimeChecks="3" + RuntimeLibrary="5" + UsePrecompiledHeader="3" + WarningLevel="3" + Detect64BitPortabilityProblems="TRUE" + DebugInformationFormat="4"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + OutputFile="$(OutDir)/makephx.exe" + LinkIncremental="2" + IgnoreDefaultLibraryNames="LIBC,LIBCD" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile="$(OutDir)/makephx.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool"/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool" + Description="Write enable target file" + CommandLine="attrib -r ..\..\..\..\game\bin\makephx.exe"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + <Configuration + Name="Release|Win32" + OutputDirectory=".\Release" + IntermediateDirectory="Release" + ConfigurationType="1" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + AdditionalIncludeDirectories="..\..\..\public;..\..\common;..\..\..\public\tier1" + PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE" + RuntimeLibrary="4" + UsePrecompiledHeader="3" + WarningLevel="3" + Detect64BitPortabilityProblems="TRUE" + DebugInformationFormat="3"/> + <Tool + Name="VCCustomBuildTool" + CommandLine="if exist ..\..\..\..\game\bin\"$(TargetName)".exe attrib -r ..\..\..\..\game\bin\"$(TargetName)".exe +if exist "$(TargetPath)" copy "$(TargetPath)" ..\..\..\..\game\bin" + Outputs="..\..\..\..\game\bin\$(TargetName).exe"/> + <Tool + Name="VCLinkerTool" + OutputFile="$(OutDir)/makephx.exe" + LinkIncremental="1" + IgnoreDefaultLibraryNames="LIBC,LIBCD" + GenerateDebugInformation="TRUE" + SubSystem="1" + OptimizeReferences="2" + EnableCOMDATFolding="2" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool"/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool" + Description="Write enable target file" + CommandLine="attrib -r ..\..\..\..\game\bin\makephx.exe"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" + UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> + <File + RelativePath=".\makephx.cpp"> + </File> + <File + RelativePath=".\phxfile.cpp"> + </File> + <File + RelativePath=".\simplify.cpp"> + </File> + <File + RelativePath=".\stdafx.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="1"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="1"/> + </FileConfiguration> + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl;inc;xsd" + UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> + <File + RelativePath="..\..\..\public\vphysics\constraints.h"> + </File> + <File + RelativePath="..\..\..\public\filesystem.h"> + </File> + <File + RelativePath="..\..\..\public\filesystem_helpers.h"> + </File> + <File + RelativePath="..\..\..\public\filesystem_init.h"> + </File> + <File + RelativePath="..\..\..\public\vstdlib\ICommandLine.h"> + </File> + <File + RelativePath="..\..\..\public\tier1\KeyValues.h"> + </File> + <File + RelativePath="..\..\..\public\mathlib\mathlib.h"> + </File> + <File + RelativePath=".\phxfile.h"> + </File> + <File + RelativePath=".\stdafx.h"> + </File> + <File + RelativePath="..\..\..\public\vstdlib\strtools.h"> + </File> + <File + RelativePath="..\..\..\public\vcollide.h"> + </File> + <File + RelativePath="..\..\..\public\vcollide_parse.h"> + </File> + <File + RelativePath="..\..\..\public\vphysics_interface.h"> + </File> + </Filter> + <Filter + Name="Resource Files" + Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx" + UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"> + </Filter> + <Filter + Name="common" + Filter=""> + <File + RelativePath="..\..\common\cmdlib.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\public\filesystem_helpers.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\public\filesystem_init.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\common\filesystem_tools.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\common\physdll.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + </Filter> + <File + RelativePath="..\..\..\lib\public\mathlib.lib"> + </File> + <File + RelativePath=".\ReadMe.txt"> + </File> + <File + RelativePath="..\..\..\lib\public\tier0.lib"> + </File> + <File + RelativePath="..\..\..\lib\public\tier1.lib"> + </File> + <File + RelativePath="..\..\..\lib\public\tier2.lib"> + </File> + <File + RelativePath="..\..\..\lib\public\vstdlib.lib"> + </File> + </Files> + <Globals> + </Globals> +</VisualStudioProject> diff --git a/utils/xbox/makephx/phx.cpp b/utils/xbox/makephx/phx.cpp new file mode 100644 index 0000000..5a292b2 --- /dev/null +++ b/utils/xbox/makephx/phx.cpp @@ -0,0 +1,215 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +#include "cmdlib.h" +#include "mathlib/mathlib.h" +#include "tier1/strtools.h" +#include "physdll.h" +#include "phyfile.h" +#include "phxfile.h" +#include "utlvector.h" +#include "utlbuffer.h" +#include "vphysics_interface.h" +#include "vcollide_parse.h" +#include "vphysics/constraints.h" +#include "tier0/icommandline.h" +#include "filesystem_tools.h" +#include "simplify.h" +#include "mathlib/compressed_vector.h" +#include "keyvalues.h" + +IPhysicsCollision *physcollision = NULL; +IPhysicsSurfaceProps *physprops = NULL; + +int g_TotalOut = 0; +int g_TotalCompress = 0; + +void InitFilesystem( const char *pPath ) +{ + CmdLib_InitFileSystem( pPath ); + //FileSystem_Init( ".", 0, FS_INIT_COMPATIBILITY_MODE ); + // This bit of hackery allows us to access files on the harddrive + g_pFullFileSystem->AddSearchPath( "", "LOCAL", PATH_ADD_TO_HEAD ); +} + +static bool LoadSurfaceProps( const char *pMaterialFilename ) +{ + if ( !physprops ) + return false; + + // already loaded + if ( physprops->SurfacePropCount() ) + return false; + + FileHandle_t fp = g_pFileSystem->Open( pMaterialFilename, "rb", TOOLS_READ_PATH_ID ); + if ( fp == FILESYSTEM_INVALID_HANDLE ) + return false; + + int len = g_pFileSystem->Size( fp ); + char *pText = new char[len+1]; + g_pFileSystem->Read( pText, len, fp ); + g_pFileSystem->Close( fp ); + + pText[len]=0; + + physprops->ParseSurfaceData( pMaterialFilename, pText ); + + delete[] pText; + + return true; +} + +void LoadSurfacePropsAll() +{ + const char *SURFACEPROP_MANIFEST_FILE = "scripts/surfaceproperties_manifest.txt"; + KeyValues *manifest = new KeyValues( SURFACEPROP_MANIFEST_FILE ); + if ( manifest->LoadFromFile( g_pFileSystem, SURFACEPROP_MANIFEST_FILE, "GAME" ) ) + { + for ( KeyValues *sub = manifest->GetFirstSubKey(); sub != NULL; sub = sub->GetNextKey() ) + { + if ( !Q_stricmp( sub->GetName(), "file" ) ) + { + // Add + LoadSurfaceProps( sub->GetString() ); + continue; + } + } + } + + manifest->deleteThis(); +} +void InitVPhysics() +{ + CreateInterfaceFn physicsFactory = GetPhysicsFactory(); + physcollision = (IPhysicsCollision *)physicsFactory( VPHYSICS_COLLISION_INTERFACE_VERSION, NULL ); + physprops = (IPhysicsSurfaceProps *)physicsFactory( VPHYSICS_SURFACEPROPS_INTERFACE_VERSION, NULL ); + LoadSurfacePropsAll(); +} + +struct phyfile_t +{ + phyheader_t header; + vcollide_t collide; + int fileSize; +}; + +void LoadPHYFile(phyfile_t *pOut, const char *name) +{ + memset( pOut, 0, sizeof(*pOut) ); + FileHandle_t file = g_pFullFileSystem->Open( name, "rb" ); + if ( !file ) + return; + + g_pFullFileSystem->Read( &pOut->header, sizeof(pOut->header), file ); + if ( pOut->header.size != sizeof(pOut->header) || pOut->header.solidCount <= 0 ) + return; + + pOut->fileSize = g_pFullFileSystem->Size( file ); + + char *buf = (char *)_alloca( pOut->fileSize ); + g_pFullFileSystem->Read( buf, pOut->fileSize, file ); + g_pFullFileSystem->Close( file ); + + physcollision->VCollideLoad( &pOut->collide, pOut->header.solidCount, (const char *)buf, pOut->fileSize ); +} + + + +void WritePHXFile( const char *pName, const phyfile_t &file ) +{ + if ( file.header.size != sizeof(file.header) || file.collide.solidCount <= 0 ) + return; + + CUtlBuffer out; + + char outName[1024]; + Q_snprintf( outName, sizeof(outName), "%s", pName ); + Q_SetExtension( outName, ".phx", sizeof(outName) ); + + out.Put( &file.header, sizeof(file.header) ); + int outSize = 0; + float tolerance = (file.collide.solidCount > 1) ? 3.0f : 7.0f; + + vcollide_t *pNewCollide = ConvertVCollideToPHX( &file.collide, tolerance, &outSize, false ); + g_TotalOut += file.fileSize; + for ( int i = 0; i < pNewCollide->solidCount; i++ ) + { + int collideSize = physcollision->CollideSize( pNewCollide->solids[i] ); + out.PutInt( collideSize ); + char *pMem = new char[collideSize]; + physcollision->CollideWrite( pMem, pNewCollide->solids[i] ); + out.Put( pMem, collideSize ); + delete[] pMem; + } + + Msg("%s Compressed %d (%d text) to %d (%d text)\n", outName, file.fileSize, file.collide.descSize, out.TellPut(), pNewCollide->descSize ); + out.Put( pNewCollide->pKeyValues, pNewCollide->descSize ); + g_TotalCompress += out.TellPut(); + + Msg("OLD:\n-----------------------------------\n%s\n", file.collide.pKeyValues ); + CPackedPhysicsDescription *pPacked = physcollision->CreatePackedDesc( pNewCollide->pKeyValues, pNewCollide->descSize ); + Msg("NEW:\n-----------------------------------\n" ); + for ( int i = 0; i < pPacked->m_solidCount; i++ ) + { + solid_t solid; + pPacked->GetSolid( &solid, i ); + Msg("index %d\n", solid.index ); + Msg("name %s\n", solid.name ); + Msg("mass %.2f\n", solid.params.mass ); + Msg("surfaceprop %s\n", solid.surfaceprop); + Msg("damping %.2f\n", solid.params.damping ); + Msg("rotdamping %.2f\n", solid.params.rotdamping ); + Msg("drag %.2f\n", solid.params.dragCoefficient ); + Msg("inertia %.2f\n", solid.params.inertia ); + Msg("volume %.2f\n", solid.params.volume ); + } + + if ( !g_pFullFileSystem->WriteFile( outName, NULL, out ) ) + Error("Error writing %s\n", outName ); +} + +void UnloadPHYFile( phyfile_t *pFile ) +{ + physcollision->VCollideUnload( &pFile->collide ); + pFile->header.size = 0; +} + +int main( int argc, char *argv[] ) +{ + CommandLine()->CreateCmdLine( argc, argv ); + InstallSpewFunction(); + InitFilesystem( argv[argc-1] ); + InitVPhysics(); + MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false ); + + g_TotalOut = 0; + g_TotalCompress = 0; + FileFindHandle_t handle; + char fullpath[1024], filebase[1024]; + strcpy( fullpath, argv[argc-1] ); + strcpy( fullpath, ExpandPath( fullpath ) ); + strcpy( fullpath, ExpandArg( fullpath ) ); + Q_FileBase(fullpath, filebase, sizeof(filebase)); + + const char *pFilename = g_pFullFileSystem->FindFirst( argv[argc-1], &handle ); + while ( pFilename ) + { +#if 0 + if ( g_pFullFileSystem->FindIsDirectory( handle ) ) + { + } +#endif + g_pFullFileSystem->RelativePathToFullPath( pFilename, NULL, filebase, sizeof( filebase ) ); + + phyfile_t phy; + strcpy( filebase, ExpandPath( filebase ) ); + strcpy( filebase, ExpandArg( filebase ) ); + LoadPHYFile( &phy, filebase ); + WritePHXFile( filebase, phy ); + UnloadPHYFile( &phy ); + pFilename = g_pFullFileSystem->FindNext( handle ); + } + g_pFullFileSystem->FindClose( handle ); + Msg("Total %s, %s\nSaved %s\n", Q_pretifymem( g_TotalOut ), Q_pretifymem( g_TotalCompress ), Q_pretifymem( g_TotalOut - g_TotalCompress ) ); + Msg("%.2f%% savings\n", ((float)(g_TotalOut-g_TotalCompress) / (float)g_TotalOut) * 100.0f ); + + return 0; +} diff --git a/utils/xbox/makephx/phxfile.cpp b/utils/xbox/makephx/phxfile.cpp new file mode 100644 index 0000000..304e87e --- /dev/null +++ b/utils/xbox/makephx/phxfile.cpp @@ -0,0 +1,42 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +#include "stdafx.h" +#include "simplify.h" + +extern IPhysicsCollision *physcollision; + +vcollide_t *ConvertVCollideToPHX( const vcollide_t *pCollideIn, const simplifyparams_t ¶ms, int *pSize, bool bStoreSurfaceprops, bool bStoreSolidNames ) +{ + Assert( !pCollideIn->isPacked ); + vcollide_t *pCollideOut = new vcollide_t; + pCollideOut->solids = new CPhysCollide *[pCollideIn->solidCount]; + pCollideOut->solidCount = pCollideIn->solidCount; + *pSize = 0; + + for ( int i = 0; i < pCollideIn->solidCount; i++ ) + { + Assert( pCollideIn->solids[i] ); + pCollideOut->solids[i] = SimplifyCollide( pCollideIn->solids[i], i, params ); + Assert( pCollideOut->solids[i] ); + int collideSize = physcollision->CollideSize( pCollideOut->solids[i] ); + *pSize += collideSize; + } + int packedTextSize; + pCollideOut->pKeyValues = (char *)physcollision->PackVCollideText( pCollideIn->pKeyValues, &packedTextSize, bStoreSolidNames, bStoreSurfaceprops ); + pCollideOut->isPacked = true; + pCollideOut->descSize = packedTextSize; + *pSize += packedTextSize; + + return pCollideOut; +} + + +void DestroyPHX( vcollide_t *pCollide ) +{ + for ( int i = 0; i < pCollide->solidCount; i++ ) + { + physcollision->DestroyCollide( pCollide->solids[i] ); + } + delete[] pCollide->solids; + physcollision->DestroyVCollideText( pCollide->pKeyValues ); + delete pCollide; +} diff --git a/utils/xbox/makephx/phxfile.h b/utils/xbox/makephx/phxfile.h new file mode 100644 index 0000000..cb4f2dc --- /dev/null +++ b/utils/xbox/makephx/phxfile.h @@ -0,0 +1,18 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#ifndef PHXFILE_H +#define PHXFILE_H +#ifdef _WIN32 +#pragma once +#endif + +#include "simplify.h" +// convert a vcollide to packed/simplified format +vcollide_t *ConvertVCollideToPHX( const vcollide_t *pCollideIn, const simplifyparams_t ¶ms, int *pSize, bool bStoreSurfaceprops, bool bStoreSolidNames ); +void DestroyPHX( vcollide_t *pCollide ); + +#endif // PHXFILE_H diff --git a/utils/xbox/makephx/simplify.cpp b/utils/xbox/makephx/simplify.cpp new file mode 100644 index 0000000..897fccf --- /dev/null +++ b/utils/xbox/makephx/simplify.cpp @@ -0,0 +1,453 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +#include "stdafx.h" +#include "simplify.h" +extern IPhysicsCollision *physcollision; + +extern bool g_bQuiet; + +const float DIST_EPSILON = 1.0f / 32.0f; +// this is the list of candidate planes that will be added one by one to the convex hull +// until none of the surface lies outside the tolerance +struct planetest_t +{ + Vector normal; + float dist; + int inUse; + float bestDist; + void Init( int axis, float sign, float _dist, bool _inUse = false ) + { + memset( this, 0, sizeof(*this) ); + normal[axis] = sign; + dist = sign*_dist; + inUse = _inUse; + bestDist = -1; + } + void Init( const Vector &a, const Vector &b, const Vector &c, bool _inUse = false ) + { + Vector e0 = b-a; + Vector e1 = c-a; + normal = CrossProduct( e1, e0 ); + VectorNormalize( normal ); + dist = DotProduct( normal, a ); + inUse = _inUse; + bestDist = -1; + } +}; + +CPhysConvex *ConvertPlaneListToConvex( CUtlVector<planetest_t> &list ) +{ + float temp[4 * 2048]; + struct listplane_t + { + float plane[4]; + }; + + int planeCount = 0; + listplane_t *pList = (listplane_t *)temp; + for ( int i = 0; i < list.Count(); i++ ) + { + if ( list[i].inUse ) + { + list[i].normal.CopyToArray( pList[planeCount].plane ); + pList[planeCount].plane[3] = list[i].dist; + planeCount++; + } + } + + return physcollision->ConvexFromPlanes( temp, planeCount, 0.25f ); +} + +Vector BoxSupport( const Vector &dir, const Vector &mins, const Vector &maxs ) +{ + Vector out; + for ( int i = 0; i < 3; i++ ) + { + out[i] = (dir[i] >= 0) ? maxs[i] : mins[i]; + } + return out; +} + +struct convexoptimize_t +{ + CUtlVector<planetest_t> list; + float targetTolerance; + + void InitPlanes( CPhysCollide *pCollide, bool addAABBToSimplifiedHull ) + { + Vector mins, maxs; + physcollision->CollideGetAABB( &mins, &maxs, pCollide, vec3_origin, vec3_angle ); + if ( !addAABBToSimplifiedHull ) + { + mins -= Vector(targetTolerance,targetTolerance,targetTolerance); + maxs += Vector(targetTolerance,targetTolerance,targetTolerance); + } + int i; + for ( i = 0; i < 3; i++ ) + { + planetest_t &elem = list[list.AddToTail()]; + elem.Init( i, 1.0f, maxs[i], true ); + planetest_t &elem2 = list[list.AddToTail()]; + elem2.Init( i, -1.0f, mins[i], true ); + } + ICollisionQuery *pQuery = physcollision->CreateQueryModel( pCollide ); + Vector triVerts[3]; + for ( i = 0; i < pQuery->TriangleCount(0); i++ ) + { + pQuery->GetTriangleVerts( 0, i, triVerts ); + planetest_t &elem = list[list.AddToTail()]; + elem.Init( triVerts[0], triVerts[1], triVerts[2], false ); + elem.bestDist = DotProduct( elem.normal, BoxSupport(elem.normal, mins, maxs) ) - elem.dist; + } + physcollision->DestroyQueryModel( pQuery ); + } + + CPhysConvex *ConvertToConvex() + { + return ::ConvertPlaneListToConvex( list ); + } + + int FindBestPlane( float dist ) + { + int best = -1; + for ( int i = 6; i < list.Count(); i++ ) + { + if ( list[i].inUse ) + continue; + if ( dist >= list[i].bestDist ) + continue; + dist = list[i].bestDist; + best = i; + } + return best; + } + + bool AddBestPlane() + { + convertconvexparams_t params; + params.Defaults(); + CPhysConvex *pConvex = ConvertPlaneListToConvex( list ); + CPhysCollide *pCurrentCollide = physcollision->ConvertConvexToCollideParams( &pConvex, 1, params ); + int bestIndex = -1; + float bestDist = 0; + while ( true ) + { + if ( bestIndex >= 0 ) + { + list[bestIndex].inUse = true; + } + int test = FindBestPlane( bestDist ); + if ( test < 0 ) + break; + if ( bestIndex >= 0 ) + { + list[bestIndex].inUse = false; + } + Vector dir = list[test].normal; + Vector point = physcollision->CollideGetExtent( pCurrentCollide, vec3_origin, vec3_angle, dir ); + float before = DotProduct( dir, point ); + list[test].inUse = true; + pConvex = ConvertToConvex(); + list[test].inUse = false; + CPhysCollide *pCollide = physcollision->ConvertConvexToCollideParams( &pConvex, 1, params ); + Vector p2 = physcollision->CollideGetExtent( pCollide, vec3_origin, vec3_angle, dir ); + physcollision->DestroyCollide( pCollide ); + float after = DotProduct( dir, p2 ); + list[test].bestDist = fabs(before-after); + if ( list[test].bestDist > bestDist ) + { + bestDist = list[test].bestDist; + bestIndex = test; + } + } + physcollision->DestroyCollide( pCurrentCollide ); + + if ( bestIndex >= 0 && bestDist >= targetTolerance ) + { + list[bestIndex].inUse = true; + return true; + } + + return false; + } +}; + +CPhysConvex *SimplifyConvexFromVerts( Vector **verts, int vertCount, bool addAABBToSimplifiedHull, float tolerance, int index ) +{ + CPhysConvex *pConvex = physcollision->ConvexFromVerts( verts, vertCount ); + float targetVolume = physcollision->ConvexVolume( pConvex ); + // can't simplify this polyhedron + if ( vertCount <= 8 ) + return pConvex; + + convexoptimize_t opt; + memset( &opt, 0, sizeof(opt)); + opt.targetTolerance = tolerance; + convertconvexparams_t params; + params.Defaults(); + CPhysCollide *pRef = physcollision->ConvertConvexToCollideParams( &pConvex, 1, params ); + opt.InitPlanes( pRef, addAABBToSimplifiedHull ); + physcollision->DestroyCollide( pRef ); + + // Simplify until you hit the tolerance + int i; + for ( i = 0; i < vertCount; i++ ) + { + if ( !opt.AddBestPlane() ) + break; + } + + // Create the output shape + pConvex = opt.ConvertToConvex(); + float currentVolume = physcollision->ConvexVolume( pConvex ); + //Msg("%d iterations, for convex %d\n", i, index ); + + return pConvex; +} + +inline int AddVert( Vector **ppVerts, int vertCount, const Vector &newVert ) +{ + for ( int i = 0; i < vertCount; i++ ) + { + if ( fabs(ppVerts[i]->x - newVert.x) < DIST_EPSILON && + fabs(ppVerts[i]->y - newVert.y) < DIST_EPSILON && + fabs(ppVerts[i]->z - newVert.z) < DIST_EPSILON ) + return vertCount; + } + *ppVerts[vertCount] = newVert; + return vertCount+1; +} + +void BuildSingleConvex( CPhysConvex **convexListOut, ICollisionQuery *pQuery, Vector **ppVerts, const simplifyparams_t ¶ms ) +{ + int vertCount = 0; + for ( int i = 0; i < pQuery->ConvexCount(); i++ ) + { + Vector v[3]; + for ( int j = 0; j < pQuery->TriangleCount(i); j++ ) + { + pQuery->GetTriangleVerts( i, j, v ); + vertCount = AddVert( ppVerts, vertCount, v[0] ); + vertCount = AddVert( ppVerts, vertCount, v[1] ); + vertCount = AddVert( ppVerts, vertCount, v[2] ); + } + } + convexListOut[0] = SimplifyConvexFromVerts( ppVerts, vertCount, params.addAABBToSimplifiedHull, params.tolerance, 0 ); + physcollision->SetConvexGameData( convexListOut[0], pQuery->GetGameData( 0 ) ); +} + +void SimplifyConvexElements( CPhysConvex **convexListOut, ICollisionQuery *pQuery, Vector **ppVerts, const simplifyparams_t ¶ms ) +{ + for ( int i = 0; i < pQuery->ConvexCount(); i++ ) + { + int vertCount = 0; + Vector v[3]; + for ( int j = 0; j < pQuery->TriangleCount(i); j++ ) + { + pQuery->GetTriangleVerts( i, j, v ); + vertCount = AddVert( ppVerts, vertCount, v[0] ); + vertCount = AddVert( ppVerts, vertCount, v[1] ); + vertCount = AddVert( ppVerts, vertCount, v[2] ); + } + convexListOut[i] = SimplifyConvexFromVerts( ppVerts, vertCount, params.addAABBToSimplifiedHull, params.tolerance, i ); + physcollision->SetConvexGameData( convexListOut[i], pQuery->GetGameData( i ) ); + } +} + +struct mergeconvex_t +{ + byte mergeCount; + byte list[255]; +}; + +void MergeElems( CUtlVector<mergeconvex_t> &elems, int index0, int index1 ) +{ + Assert( index0 < index1 ); + for (int i = 0; i < elems[index1].mergeCount; i++) + { + elems[index0].list[i+elems[index0].mergeCount] = elems[index1].list[i]; + } + elems[index0].mergeCount += elems[index1].mergeCount; + elems.FastRemove(index1); +} + +int VertsForElem( ICollisionQuery *pQuery, Vector **ppVerts, const mergeconvex_t &elems0, int vertCount ) +{ + for ( int i = 0; i < elems0.mergeCount; i++ ) + { + int convexId = elems0.list[i]; + Vector v[3]; + for ( int j = 0; j < pQuery->TriangleCount(convexId); j++ ) + { + pQuery->GetTriangleVerts( convexId, j, v ); + vertCount = AddVert( ppVerts, vertCount, v[0] ); + vertCount = AddVert( ppVerts, vertCount, v[1] ); + vertCount = AddVert( ppVerts, vertCount, v[2] ); + } + } + return vertCount; +} + +void PlanesForElem( ICollisionQuery *pQuery, CUtlVector<float> &planes, const mergeconvex_t &elem0 ) +{ + for ( int i = 0; i < elem0.mergeCount; i++ ) + { + int convexId = elem0.list[i]; + Vector v[3]; + for ( int j = 0; j < pQuery->TriangleCount(convexId); j++ ) + { + pQuery->GetTriangleVerts( convexId, j, v ); + Vector e0 = v[1]-v[0]; + Vector e1 = v[2]-v[0]; + Vector normal = CrossProduct( e1, e0 ); + VectorNormalize( normal ); + float dist = DotProduct( normal, v[0] ); + planes.AddToTail( normal.x ); + planes.AddToTail( normal.y ); + planes.AddToTail( normal.z ); + planes.AddToTail( dist ); + } + } +} + +float ConvexVolumeFromPlanes( CUtlVector<float> &planes ) +{ + CPhysConvex *pConvex = planes.Count() ? physcollision->ConvexFromPlanes( planes.Base(), planes.Count()/4, DIST_EPSILON ) : NULL; + float volume = 0; + if ( pConvex ) + { + volume = physcollision->ConvexVolume(pConvex); + physcollision->ConvexFree(pConvex); + } + return volume; +} + +float MergedDeltaVolume( ICollisionQuery *pQuery, Vector **ppVerts, const mergeconvex_t &elem0, const mergeconvex_t &elem1 ) +{ + // build vert list + int vertCount = VertsForElem( pQuery, ppVerts, elem0, 0 ); + // merge in next element + vertCount = VertsForElem( pQuery, ppVerts, elem1, vertCount); + CPhysConvex *pConvex = physcollision->ConvexFromVerts( ppVerts, vertCount ); + float finalVolume = physcollision->ConvexVolume(pConvex); + physcollision->ConvexFree(pConvex); + + CUtlVector<float> planes; + PlanesForElem( pQuery, planes, elem0 ); + float vol0 = ConvexVolumeFromPlanes( planes ); + planes.RemoveAll(); + PlanesForElem( pQuery, planes, elem1 ); + float vol1 = ConvexVolumeFromPlanes( planes ); + PlanesForElem( pQuery, planes, elem0 ); + + float volInt = ConvexVolumeFromPlanes( planes ); + + return finalVolume - (vol0+vol1-volInt); +} + +int MergeAndSimplifyConvexElements( CPhysConvex **convexListOut, const CPhysCollide *pCollideIn, ICollisionQuery *pQuery, Vector **ppVerts, const simplifyparams_t ¶ms ) +{ + Assert( pQuery->ConvexCount() < 256 ); + if ( pQuery->ConvexCount() > 256 ) + { + SimplifyConvexElements(convexListOut, pQuery, ppVerts, params); + return pQuery->ConvexCount(); + } + + CUtlVector<mergeconvex_t> elems; + int i; + elems.EnsureCount(pQuery->ConvexCount()); + float totalVolume = physcollision->CollideVolume( (CPhysCollide *)pCollideIn ); + for ( i = 0; i < pQuery->ConvexCount(); i++ ) + { + elems[i].mergeCount = 1; + elems[i].list[0] = i; + } +loop: + for ( i = 0; i < elems.Count(); i++ ) + { + for ( int j = i+1; j < elems.Count(); j++ ) + { + float volume = fabs(MergedDeltaVolume( pQuery, ppVerts, elems[i], elems[j] )); + volume /= totalVolume; + if ( volume < params.mergeConvexTolerance ) + { + MergeElems( elems, i, j ); + goto loop; + } + } + } + + for ( i = 0; i < elems.Count(); i++ ) + { + int vertCount = VertsForElem( pQuery, ppVerts, elems[i], 0 ); + convexListOut[i] = SimplifyConvexFromVerts( ppVerts, vertCount, params.addAABBToSimplifiedHull, params.tolerance, i ); + physcollision->SetConvexGameData( convexListOut[i], pQuery->GetGameData( elems[i].list[0] ) ); + } + return elems.Count(); +} + +CPhysCollide *SimplifyCollide( CPhysCollide *pCollideIn, int indexIn, const simplifyparams_t ¶ms ) +{ + int sizeIn = physcollision->CollideSize( pCollideIn ); + ICollisionQuery *pQuery = physcollision->CreateQueryModel( pCollideIn ); + int maxVertCount = 0; + int i; + for ( i = pQuery->ConvexCount(); --i >= 0; ) + { + int vertCount = pQuery->TriangleCount(i)*3; + maxVertCount += vertCount; + } + + Vector **ppVerts = new Vector *[maxVertCount]; + Vector *verts = new Vector[maxVertCount]; + for ( i = 0; i < maxVertCount; i++ ) + { + ppVerts[i] = &verts[i]; + } + + int outputConvexCount = params.forceSingleConvex ? 1 : pQuery->ConvexCount(); + CPhysConvex **convexList = new CPhysConvex *[outputConvexCount]; + if ( params.forceSingleConvex ) + { + BuildSingleConvex( convexList, pQuery, ppVerts, params ); + } + else if ( params.mergeConvexElements && pQuery->ConvexCount() > 1 ) + { + outputConvexCount = MergeAndSimplifyConvexElements( convexList, pCollideIn, pQuery, ppVerts, params ); + if ( !g_bQuiet && pQuery->ConvexCount() != outputConvexCount) + { + Msg("Simplified %d to %d elements\n", pQuery->ConvexCount(), outputConvexCount ); + } + } + else + { + SimplifyConvexElements( convexList, pQuery, ppVerts, params ); + } + convertconvexparams_t params; + params.Defaults(); + params.buildOuterConvexHull = true; + params.buildDragAxisAreas = false; + + CPhysCollide *pCollideOut = physcollision->ConvertConvexToCollideParams( convexList, outputConvexCount, params ); + + // copy the drag axis areas from the source + Vector dragAxisAreas = physcollision->CollideGetOrthographicAreas( pCollideIn ); + physcollision->CollideSetOrthographicAreas( pCollideOut, dragAxisAreas ); + + physcollision->DestroyQueryModel( pQuery ); + delete[] convexList; + delete[] verts; + delete[] ppVerts; + + if ( physcollision->CollideSize(pCollideOut) >= sizeIn ) + { + // make a copy of the input collide + physcollision->DestroyCollide(pCollideOut); + char *pBuf = new char[sizeIn]; + physcollision->CollideWrite( pBuf, pCollideIn ); + pCollideOut = physcollision->UnserializeCollide( pBuf, sizeIn, indexIn ); + delete[] pBuf; + } + return pCollideOut; +} + diff --git a/utils/xbox/makephx/simplify.h b/utils/xbox/makephx/simplify.h new file mode 100644 index 0000000..acf2625 --- /dev/null +++ b/utils/xbox/makephx/simplify.h @@ -0,0 +1,38 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $Workfile: $ +// $Date: $ +// +//----------------------------------------------------------------------------- +// $Log: $ +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef SIMPLIFY_H +#define SIMPLIFY_H +#pragma once + +struct simplifyparams_t +{ + float tolerance; + bool addAABBToSimplifiedHull; + bool forceSingleConvex; + bool mergeConvexElements; + float mergeConvexTolerance; + + void Defaults() + { + tolerance = 1.0f; + addAABBToSimplifiedHull = false; + forceSingleConvex = false; + mergeConvexElements = false; + mergeConvexTolerance = 0.f; + } +}; + +extern CPhysCollide *SimplifyCollide( CPhysCollide *pCollideIn, int index, const simplifyparams_t ¶ms ); + +#endif // SIMPLIFY_H diff --git a/utils/xbox/makephx/stdafx.cpp b/utils/xbox/makephx/stdafx.cpp new file mode 100644 index 0000000..c4c1f62 --- /dev/null +++ b/utils/xbox/makephx/stdafx.cpp @@ -0,0 +1,9 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// stdafx.cpp : source file that includes just the standard includes +// makephx.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" + +// TODO: reference any additional headers you need in STDAFX.H +// and not in this file diff --git a/utils/xbox/makephx/stdafx.h b/utils/xbox/makephx/stdafx.h new file mode 100644 index 0000000..db4423e --- /dev/null +++ b/utils/xbox/makephx/stdafx.h @@ -0,0 +1,20 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#pragma once + + +#include "cmdlib.h" +#include "mathlib/mathlib.h" +#include "vphysics_interface.h" +#include "tier1/strtools.h" +#include "phyfile.h" +#include "phxfile.h" +#include "utlvector.h" +#include "utlbuffer.h" +#include "vcollide_parse.h" + +// TODO: reference additional headers your program requires here diff --git a/utils/xbox/makephx/util.cpp b/utils/xbox/makephx/util.cpp new file mode 100644 index 0000000..cb5e879 --- /dev/null +++ b/utils/xbox/makephx/util.cpp @@ -0,0 +1,41 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +#include "mathlib/mathlib.h" +#include "util.h" +#include "tier1/strtools.h" + +void UTIL_StringToFloatArray( float *pVector, int count, const char *pString ) +{ + char *pstr, *pfront, tempString[128]; + int j; + + Q_strncpy( tempString, pString, sizeof(tempString) ); + pstr = pfront = tempString; + + for ( j = 0; j < count; j++ ) // lifted from pr_edict.c + { + pVector[j] = atof( pfront ); + + // skip any leading whitespace + while ( *pstr && *pstr <= ' ' ) + pstr++; + + // skip to next whitespace + while ( *pstr && *pstr > ' ' ) + pstr++; + + if (!*pstr) + break; + + pstr++; + pfront = pstr; + } + for ( j++; j < count; j++ ) + { + pVector[j] = 0; + } +} + +void UTIL_StringToVector( float *pVector, const char *pString ) +{ + UTIL_StringToFloatArray( pVector, 3, pString ); +} diff --git a/utils/xbox/makephx/util.h b/utils/xbox/makephx/util.h new file mode 100644 index 0000000..8d389a3 --- /dev/null +++ b/utils/xbox/makephx/util.h @@ -0,0 +1,16 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#ifndef UTIL_H +#define UTIL_H +#ifdef _WIN32 +#pragma once +#endif + +extern void UTIL_StringToFloatArray( float *pVector, int count, const char *pString ); +extern void UTIL_StringToVector( float *pVector, const char *pString ); + +#endif // UTIL_H diff --git a/utils/xbox/makexvcd/cbase.h b/utils/xbox/makexvcd/cbase.h new file mode 100644 index 0000000..d374bb7 --- /dev/null +++ b/utils/xbox/makexvcd/cbase.h @@ -0,0 +1,19 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//============================================================================= + +#ifndef CBASE_H +#define CBASE_H +#ifdef _WIN32 +#pragma once +#endif + +#include "basetypes.h" + +// This is just a dummy file to make this tool compile +#include "ai_activity.h" +#include "UtlVector.h" + +#endif // CBASE_H diff --git a/utils/xbox/makexvcd/makexvcd.cpp b/utils/xbox/makexvcd/makexvcd.cpp new file mode 100644 index 0000000..fcb1459 --- /dev/null +++ b/utils/xbox/makexvcd/makexvcd.cpp @@ -0,0 +1,933 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: vcd_sound_check.cpp : Defines the entry point for the console application. +// +//=============================================================================// +#include <stdio.h> +#include <windows.h> +#include "tier0/dbg.h" +#include "tier1/utldict.h" +#include "filesystem.h" +#include "FileSystem_Tools.h" +#include "tier1/KeyValues.h" +#include "cmdlib.h" +#include "scriplib.h" +#include "vstdlib/random.h" +#include "choreoscene.h" +#include "choreoevent.h" +#include "iscenetokenprocessor.h" +#include "tier1/utlbuffer.h" +#include "tier1/checksum_crc.h" +#include "pacifier.h" +#include "SceneCache.h" +#include "SoundEmitterSystem/isoundemittersystembase.h" +#include "ModelSoundsCache.h" +#include "Datacache/imdlcache.h" +#include "datacache/idatacache.h" +#include "studio.h" +#include "appframework/appframework.h" +#include "tier0/icommandline.h" +#include "istudiorender.h" +#include "materialsystem/imaterialsystem.h" +#include "vphysics_interface.h" +#include "icvar.h" +#include "vstdlib/cvar.h" +#include "eventlist.h" + +// #define TESTING 1 + + +bool uselogfile = false; +bool modelsoundscache = false; +bool scenecache = false; +bool virtualmodel = false; +bool buildxcds = false; + +struct AnalysisData +{ + CUtlSymbolTable symbols; +}; + +static AnalysisData g_Analysis; + +static char g_szCurrentGameDir[ 512 ]; + +IFileSystem *filesystem = NULL; +IMDLCache *g_pMDLCache = NULL; +ISoundEmitterSystemBase *soundemitterbase = NULL; + +static CUniformRandomStream g_Random; +IUniformRandomStream *random = &g_Random; + +static bool spewed = false; + +static CUtlCachedFileData< CSceneCache > g_SceneCache( "scene.cache", SCENECACHE_VERSION, 0, UTL_CACHED_FILE_USE_FILESIZE ); +static CUtlCachedFileData< CModelSoundsCache > g_ModelSoundsCache( "modelsounds.cache", MODELSOUNDSCACHE_VERSION, 0, UTL_CACHED_FILE_USE_FILESIZE ); + +//----------------------------------------------------------------------------- +// FIXME: This trashy glue code is really not acceptable. Figure out a way of making it unnecessary. +//----------------------------------------------------------------------------- +const studiohdr_t *studiohdr_t::FindModel( void **cache, char const *pModelName ) const +{ + MDLHandle_t handle = g_pMDLCache->FindMDL( pModelName ); + *cache = (void*)handle; + return g_pMDLCache->GetStudioHdr( handle ); +} + +virtualmodel_t *studiohdr_t::GetVirtualModel( void ) const +{ + return g_pMDLCache->GetVirtualModel( (MDLHandle_t)virtualModel ); +} + +byte *studiohdr_t::GetAnimBlock( int i ) const +{ + return g_pMDLCache->GetAnimBlock( (MDLHandle_t)virtualModel, i ); +} + +int studiohdr_t::GetAutoplayList( unsigned short **pOut ) const +{ + return g_pMDLCache->GetAutoplayList( (MDLHandle_t)virtualModel, pOut ); +} + +const studiohdr_t *virtualgroup_t::GetStudioHdr( void ) const +{ + return g_pMDLCache->GetStudioHdr( (MDLHandle_t)cache ); +} + + +//----------------------------------------------------------------------------- +// Purpose: Helper for parsing scene data file +//----------------------------------------------------------------------------- +class CSceneTokenProcessor : public ISceneTokenProcessor +{ +public: + const char *CurrentToken( void ); + bool GetToken( bool crossline ); + bool TokenAvailable( void ); + void Error( const char *fmt, ... ); +}; + +//----------------------------------------------------------------------------- +// Purpose: +// Output : const char +//----------------------------------------------------------------------------- +const char *CSceneTokenProcessor::CurrentToken( void ) +{ + return token; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : crossline - +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool CSceneTokenProcessor::GetToken( bool crossline ) +{ + return ::GetToken( crossline ) ? true : false; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Output : Returns true on success, false on failure. +//----------------------------------------------------------------------------- +bool CSceneTokenProcessor::TokenAvailable( void ) +{ + return ::TokenAvailable() ? true : false; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : *fmt - +// ... - +//----------------------------------------------------------------------------- +void CSceneTokenProcessor::Error( const char *fmt, ... ) +{ + char string[ 2048 ]; + va_list argptr; + va_start( argptr, fmt ); + Q_vsnprintf( string, sizeof(string), fmt, argptr ); + va_end( argptr ); + + Warning( "%s", string ); + Assert(0); +} + +static CSceneTokenProcessor g_TokenProcessor; + +SpewRetval_t SpewFunc( SpewType_t type, char const *pMsg ) +{ + spewed = true; + + printf( "%s", pMsg ); + OutputDebugString( pMsg ); + + if ( type == SPEW_ERROR ) + { + printf( "\n" ); + OutputDebugString( "\n" ); + } + + return SPEW_CONTINUE; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : depth - +// *fmt - +// ... - +//----------------------------------------------------------------------------- +void vprint( int depth, const char *fmt, ... ) +{ + char string[ 8192 ]; + va_list va; + va_start( va, fmt ); + vsprintf( string, fmt, va ); + va_end( va ); + + FILE *fp = NULL; + + if ( uselogfile ) + { + fp = fopen( "log.txt", "ab" ); + } + + while ( depth-- > 0 ) + { + printf( " " ); + OutputDebugString( " " ); + if ( fp ) + { + fprintf( fp, " " ); + } + } + + ::printf( "%s", string ); + OutputDebugString( string ); + + if ( fp ) + { + char *p = string; + while ( *p ) + { + if ( *p == '\n' ) + { + fputc( '\r', fp ); + } + fputc( *p, fp ); + p++; + } + fclose( fp ); + } +} + +void logprint( char const *logfile, const char *fmt, ... ) +{ + char string[ 8192 ]; + va_list va; + va_start( va, fmt ); + vsprintf( string, fmt, va ); + va_end( va ); + + FILE *fp = NULL; + static bool first = true; + if ( first ) + { + first = false; + fp = fopen( logfile, "wb" ); + } + else + { + fp = fopen( logfile, "ab" ); + } + if ( fp ) + { + char *p = string; + while ( *p ) + { + if ( *p == '\n' ) + { + fputc( '\r', fp ); + } + fputc( *p, fp ); + p++; + } + fclose( fp ); + } +} + + +void Con_Printf( const char *fmt, ... ) +{ + va_list args; + static char output[1024]; + + va_start( args, fmt ); + vprintf( fmt, args ); + vsprintf( output, fmt, args ); + + vprint( 0, output ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void printusage( void ) +{ + vprint( 0, "usage: makexvcd [options] -game gamedir\n\ + \t-v = verbose output\n\ + \t-m = rebuild modelsounds.cache\n\ + \t-x = rebuild .xcd files\n\ + \t-s = rebuild scene.cache\n\ + \t-z = rebuild virtualmodel.cache (xbox only)\n\ + \t-l = log to file log.txt\n\ + \ne.g.: makexvcd -s -m -game episodic\n" ); + + // Exit app + exit( 1 ); +} + +void BuildFileList_R( CUtlVector< CUtlSymbol >& files, char const *dir, char const *extension ) +{ + WIN32_FIND_DATA wfd; + + char directory[ 256 ]; + char filename[ 256 ]; + HANDLE ff; + + Q_snprintf( directory, sizeof( directory ), "%s\\*.*", dir ); + +#if defined( TESTING ) + if ( files.Count() > 100 ) + return; +#endif + + if ( ( ff = FindFirstFile( directory, &wfd ) ) == INVALID_HANDLE_VALUE ) + return; + + int extlen = strlen( extension ); + + do + { +#if defined( TESTING ) + if ( files.Count() > 100 ) + return; +#endif + if ( wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) + { + + if ( wfd.cFileName[ 0 ] == '.' ) + continue; + + // Recurse down directory + Q_snprintf( filename, sizeof( filename ), "%s\\%s", dir, wfd.cFileName ); + BuildFileList_R( files, filename, extension ); + } + else + { + int len = strlen( wfd.cFileName ); + if ( len > extlen ) + { + if ( !stricmp( &wfd.cFileName[ len - extlen ], extension ) ) + { + char filename[ MAX_PATH ]; + Q_snprintf( filename, sizeof( filename ), "%s\\%s", dir, wfd.cFileName ); + _strlwr( filename ); + + Q_FixSlashes( filename ); + + CUtlSymbol sym = g_Analysis.symbols.AddString( filename ); + files.AddToTail( sym ); + + if ( !( files.Count() % 3000 ) ) + { + vprint( 0, "...found %i .%s files\n", files.Count(), extension ); + } + } + } + } + } while ( FindNextFile( ff, &wfd ) ); +} + +void BuildFileList( char const *basedir, CUtlVector< CUtlSymbol >& files, char const *rootdir, char const *extension ) +{ + files.RemoveAll(); + char root[ 512 ]; + Q_snprintf( root, sizeof( root ), "%s\\%s", basedir, rootdir ); + BuildFileList_R( files, root, extension ); +} + +//----------------------------------------------------------------------------- +// Purpose: +//----------------------------------------------------------------------------- +void CheckLogFile( void ) +{ + if ( uselogfile ) + { + _unlink( "log.txt" ); + vprint( 0, " Outputting to log.txt\n" ); + } +} + +void PrintHeader() +{ + vprint( 0, "Valve Software - CompileVCD.exe (%s)\n", __DATE__ ); + vprint( 0, "--- Binary .vcd compiler ---\n" ); +} + +//----------------------------------------------------------------------------- +// Purpose: For each .wav file in the list, see if any vcd file in the list references it +// First build an index of .wav to .vcd mappings, then search wav list and print results +// Input : vcdfiles - +// wavfiles - +//----------------------------------------------------------------------------- + +struct VCDList +{ + VCDList() + { + } + + VCDList( const VCDList& src ) + { + int c = src.vcds.Count(); + for ( int i = 0 ; i < c; i++ ) + { + vcds.AddToTail( src.vcds[ i ] ); + } + } + + VCDList& operator =( const VCDList& src ) + { + if ( this == &src ) + return *this; + + int c = src.vcds.Count(); + for ( int i = 0 ; i < c; i++ ) + { + vcds.AddToTail( src.vcds[ i ] ); + } + + return *this; + } + + CUtlVector< CUtlSymbol > vcds; +}; + +void AppendDisposition( CUtlVector< CUtlSymbol >& disposition, char const *fmt, ... ) +{ + char string[ 2048 ]; + va_list argptr; + va_start( argptr, fmt ); + _vsnprintf( string, sizeof( string ), fmt, argptr ); + va_end( argptr ); + + CUtlSymbol sym; + sym = string; + disposition.AddToTail( sym ); +} + +CChoreoScene *BlockingLoadScene( char const *vcdname ) +{ + // Load the .vcd + char scenefile[ MAX_PATH ]; + Q_snprintf( scenefile, sizeof( scenefile ), "%s\\%s", g_szCurrentGameDir, vcdname ); + + LoadScriptFile( scenefile ); + + CChoreoScene *scene = ChoreoLoadScene( scenefile, NULL, &g_TokenProcessor, Con_Printf ); + return scene; +} + +void ProcessVCD( char const *vcdname, CUtlVector< CUtlSymbol >& disposition ) +{ + if ( verbose ) + { + vprint( 0, "Processing '%s'\n", vcdname ); + } + + bool rebuild = false; + + FileHandle_t fh = filesystem->Open( vcdname, "rb", "GAME" ); + if ( fh == FILESYSTEM_INVALID_HANDLE ) + { + Error( "Couldn't open '%s' for reading.", vcdname ); + return; + } + + size_t bufSize = filesystem->Size( fh ); + char *buffer = new char[ bufSize + 1 ]; + filesystem->Read( buffer, bufSize, fh ); + filesystem->Close( fh ); + buffer[ bufSize ] = 0; + + CRC32_t crc; + CRC32_Init( &crc ); + CRC32_ProcessBuffer( &crc, buffer, bufSize ); + CRC32_Final( &crc ); + + delete[] buffer; + + // Now load the file as a binary if it exists... + char binfile[ 512 ]; + Q_strncpy( binfile, vcdname, sizeof( binfile ) ); + Q_SetExtension( binfile, ".xcd", sizeof( binfile ) ); + + if ( buildxcds ) + { + fh = filesystem->Open( binfile, "rb", "GAME" ); + if ( fh == FILESYSTEM_INVALID_HANDLE ) + { + AppendDisposition( disposition, "Built '%s'\n", binfile ); + rebuild = true; + } + else + { + // Read the first bit of data and check + char crcdata[ 12 ]; + filesystem->Read( crcdata, sizeof( crcdata ), fh ); + filesystem->Close( fh ); + + CUtlBuffer buf; + buf.Put( crcdata, sizeof( crcdata ) ); + + CRC32_t fileCRC = 0; + if ( !CChoreoScene::GetCRCFromBuffer( buf, (unsigned int &)fileCRC ) ) + { + AppendDisposition( disposition, "Rebuilt '%s' due to version change\n", binfile ); + rebuild = true; + } + else + { + if ( fileCRC != crc ) + { + AppendDisposition( disposition, "Rebuilt '%s' due to crc change\n", binfile ); + rebuild = true; + } + } + } + } + + // Validate the scene cache + g_SceneCache.RebuildItem( vcdname + strlen( g_szCurrentGameDir ) + 1 ); + + if ( !rebuild ) + return; + + // Remove current binary + if ( filesystem->FileExists( binfile, "GAME" ) ) + { + _unlink( binfile ); + } + + // Load the .vcd + LoadScriptFile( (char *)vcdname ); + + CChoreoScene *scene = ChoreoLoadScene( vcdname, NULL, &g_TokenProcessor, Con_Printf ); + if ( scene ) + { + scene->SaveBinary( binfile, NULL, crc ); + + delete scene; + } +} + +void CompileVCDs( CUtlVector< CUtlSymbol >& vcds ) +{ + CUtlVector< CUtlSymbol > disposition; + + StartPacifier( "CompileVCDs" ); + int i; + int c = vcds.Count(); + for ( i = 0 ; i < c; ++i ) + { + UpdatePacifier( (float)i / (float)c ); + ProcessVCD( g_Analysis.symbols.String( vcds[ i ] ), disposition ); + } + EndPacifier(); + + if ( verbose ) + { + c = disposition.Count(); + for ( i = 0; i < c; ++i ) + { + Warning( "%s", disposition[ i ].String() ); + } + } +} + +static CUtlMap< CStudioHdr *, MDLHandle_t > g_ModelMap( 0, 0, DefLessFunc( CStudioHdr * ) ); + +CStudioHdr *ModelSoundsCache_LoadModel( char const *filename ) +{ + MDLHandle_t handle = g_pMDLCache->FindMDL( filename ); + + CStudioHdr *studioHdr = new CStudioHdr( g_pMDLCache->GetStudioHdr( handle ), g_pMDLCache ); + + g_ModelMap.Insert( studioHdr, handle ); + + if ( studioHdr->IsValid() ) + return studioHdr; + return NULL; +} + +void ModelSoundsCache_FinishModel( CStudioHdr *hdr ) +{ + int idx = g_ModelMap.Find( hdr ); + if ( idx != g_ModelMap.InvalidIndex() ) + { + g_pMDLCache->Release( g_ModelMap[ idx ] ); + g_ModelMap.RemoveAt( idx ); + } + delete hdr; +} + +void ModelSoundsCache_PrecacheScriptSound( const char *soundname ) +{ +} + +void ProcessMDL( char const *mdlname, CUtlVector< CUtlSymbol >& disposition ) +{ + if ( verbose ) + { + vprint( 0, "Processing '%s'\n", mdlname ); + } + + if ( Q_stristr( mdlname, "ghostanim" ) ) + { + int n =3 ; + } + // Validate the model sounds cache + g_ModelSoundsCache.RebuildItem( mdlname + strlen( g_szCurrentGameDir ) + 1 ); +} + +void CompileMDLs( CUtlVector< CUtlSymbol >& mdls ) +{ + CUtlVector< CUtlSymbol > disposition; + + StartPacifier( "CompileMDLs" ); + int i; + int c = mdls.Count(); + for ( i = 0 ; i < c; ++i ) + { + UpdatePacifier( (float)i / (float)c ); + ProcessMDL( g_Analysis.symbols.String( mdls[ i ] ), disposition ); + } + EndPacifier(); + + c = disposition.Count(); + for ( i = 0; i < c; ++i ) + { + Warning( "%s", disposition[ i ].String() ); + } +} + + +//----------------------------------------------------------------------------- +// The application object +//----------------------------------------------------------------------------- +class CMakeCachesApp : public CSteamAppSystemGroup +{ +public: + // Methods of IApplication + virtual bool Create(); + virtual bool PreInit(); + virtual int Main(); + virtual void PostShutdown(); + virtual void Destroy(); + +private: + // Sets up the search paths + bool SetupSearchPaths(); +}; + +bool CMakeCachesApp::Create() +{ + SpewOutputFunc( SpewFunc ); + SpewActivate( "makexvcd", 2 ); + + // Add in the cvar factory + AppModule_t cvarModule = LoadModule( VStdLib_GetICVarFactory() ); + AddSystem( cvarModule, VENGINE_CVAR_INTERFACE_VERSION ); + + AppSystemInfo_t appSystems[] = + { + { "materialsystem.dll", MATERIAL_SYSTEM_INTERFACE_VERSION }, + { "studiorender.dll", STUDIO_RENDER_INTERFACE_VERSION }, + { "vphysics.dll", VPHYSICS_INTERFACE_VERSION }, + { "datacache.dll", DATACACHE_INTERFACE_VERSION }, + { "datacache.dll", MDLCACHE_INTERFACE_VERSION }, + { "datacache.dll", STUDIO_DATA_CACHE_INTERFACE_VERSION }, + { "soundemittersystem.dll", SOUNDEMITTERSYSTEM_INTERFACE_VERSION }, + + { "", "" } // Required to terminate the list + }; + + if ( !AddSystems( appSystems ) ) + return false; + + g_pFileSystem = filesystem = (IFileSystem*)FindSystem( FILESYSTEM_INTERFACE_VERSION ); + g_pMDLCache = (IMDLCache*)FindSystem( MDLCACHE_INTERFACE_VERSION ); + soundemitterbase = (ISoundEmitterSystemBase*)FindSystem(SOUNDEMITTERSYSTEM_INTERFACE_VERSION); + g_pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION ); + + if ( !soundemitterbase || !g_pMDLCache || !filesystem || !g_pMaterialSystem ) + { + Error("Unable to load required library interface!\n"); + } + + g_pMaterialSystem->SetShaderAPI( "shaderapiempty.dll" ); + + return true; +} + +void CMakeCachesApp::Destroy() +{ + g_pFileSystem = filesystem = NULL; + soundemitterbase = NULL; + g_pMDLCache = NULL; +} + +//----------------------------------------------------------------------------- +// Sets up the game path +//----------------------------------------------------------------------------- +bool CMakeCachesApp::SetupSearchPaths() +{ + CFSSteamSetupInfo steamInfo; + steamInfo.m_pDirectoryName = NULL; + steamInfo.m_bOnlyUseDirectoryName = false; + steamInfo.m_bToolsMode = true; + steamInfo.m_bSetSteamDLLPath = true; + steamInfo.m_bSteam = filesystem->IsSteam(); + if ( FileSystem_SetupSteamEnvironment( steamInfo ) != FS_OK ) + return false; + + CFSMountContentInfo fsInfo; + fsInfo.m_pFileSystem = filesystem; + fsInfo.m_bToolsMode = true; + fsInfo.m_pDirectoryName = steamInfo.m_GameInfoPath; + + if ( FileSystem_MountContent( fsInfo ) != FS_OK ) + return false; + + // Finally, load the search paths for the "GAME" path. + CFSSearchPathsInit searchPathsInit; + searchPathsInit.m_pDirectoryName = steamInfo.m_GameInfoPath; + searchPathsInit.m_pFileSystem = fsInfo.m_pFileSystem; + if ( FileSystem_LoadSearchPaths( searchPathsInit ) != FS_OK ) + return false; + + char platform[MAX_PATH]; + Q_strncpy( platform, steamInfo.m_GameInfoPath, MAX_PATH ); + Q_StripTrailingSlash( platform ); + Q_strncat( platform, "/../platform", MAX_PATH, MAX_PATH ); + + fsInfo.m_pFileSystem->AddSearchPath( platform, "PLATFORM" ); + + // Set gamedir. + Q_MakeAbsolutePath( gamedir, sizeof( gamedir ), steamInfo.m_GameInfoPath ); + Q_AppendSlash( gamedir, sizeof( gamedir ) ); + + return true; +} + + +//----------------------------------------------------------------------------- +// Init, shutdown +//----------------------------------------------------------------------------- +bool CMakeCachesApp::PreInit( ) +{ + MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false ); + filesystem->SetWarningFunc( Warning ); + + // Add paths... + if ( !SetupSearchPaths() ) + return false; + + return true; +} + +void CMakeCachesApp::PostShutdown() +{ +} + +//----------------------------------------------------------------------------- +// main application +//----------------------------------------------------------------------------- +int CMakeCachesApp::Main() +{ + for ( int i=1 ; i<CommandLine()->ParmCount() ; i++) + { + if ( CommandLine()->GetParm( i )[ 0 ] == '-' ) + { + switch( CommandLine()->GetParm( i )[ 1 ] ) + { + case 'l': + uselogfile = true; + break; + case 'v': + verbose = true; + break; + case 'g': // -game + ++i; + break; + case 'm': + modelsoundscache = true; + break; + case 's': + scenecache = true; + break; + case 'x': + buildxcds = true; + break; + case 'z': + virtualmodel = true; + break; + default: + printusage(); + break; + } + } + } + + if ( CommandLine()->ParmCount() < 2 || ( i != CommandLine()->ParmCount() ) ) + { + PrintHeader(); + printusage(); + } + + CheckLogFile(); + + PrintHeader(); + + vprint( 0, " Compiling binary .vcd files to .xvcd ...\n" ); + + char vcddir[ 256 ]; + char modelsdir[ 256 ]; + Q_snprintf( vcddir, sizeof( vcddir ), "scenes", CommandLine()->GetParm( i - 1 ) ); + Q_snprintf( modelsdir, sizeof( modelsdir ), "models", CommandLine()->GetParm( i - 1 ) ); + if ( !strstr( vcddir, "scenes" ) ) + { + vprint( 0, ".vcd dir %s looks invalid (format: u:/game/hl2/scenes)\n", vcddir ); + return 0; + } + if ( !strstr( modelsdir, "models" ) ) + { + vprint( 0, ".mdl dir %s looks invalid (format: u:/game/hl2/models)\n", modelsdir ); + return 0; + } + + char binaries[MAX_PATH]; + Q_strncpy( binaries, gamedir, MAX_PATH ); + Q_StripTrailingSlash( binaries ); + Q_strncat( binaries, "/../bin", MAX_PATH, MAX_PATH ); + + filesystem->AddSearchPath( binaries, "EXECUTABLE_PATH"); + + soundemitterbase->ModInit(); + + // Delete the scene cache file + if ( scenecache ) filesystem->RemoveFile( "scene.cache", "MOD" ); + if ( modelsoundscache ) filesystem->RemoveFile( "modelsounds.cache", "MOD" ); + if ( virtualmodel ) filesystem->RemoveFile( "virtualmodel.cache", "MOD" ); + + CUtlSymbolTable pathStrings; + CUtlVector< CUtlSymbol > searchList; + char searchPaths[ 512 ]; + filesystem->GetSearchPath( "GAME", true, searchPaths, sizeof( searchPaths ) ); + + // We want to walk them in reverse order so newer files are "overrides" for older ones, so we add them to a list in reverse order + for ( char *path = strtok( searchPaths, ";" ); path; path = strtok( NULL, ";" ) ) + { + char dir[ 512 ]; + Q_strncpy( dir, path, sizeof( dir ) ); + Q_FixSlashes( dir ); + Q_strlower( dir ); + Q_StripTrailingSlash( dir ); + + CUtlSymbol sym = pathStrings.AddString( dir ); + // Push them on head so we can walk them in reverse order + searchList.AddToHead( sym ); + } + + if ( scenecache ) + { + g_SceneCache.Init(); + } + if ( modelsoundscache ) + { + g_ModelSoundsCache.Init(); + + g_pMDLCache->InitPreloadData( true ); + } + + EventList_RegisterSharedEvents(); + + for ( int sp = 0; sp < searchList.Count(); ++sp ) + { + char const *basedir = pathStrings.String( searchList[ sp ] ); + Q_strncpy( g_szCurrentGameDir, basedir, sizeof( g_szCurrentGameDir ) ); + + vprint( 0, "Processing gamedir %s\n", basedir ); + + if ( scenecache ) + { + vprint( 1, "Building list of .vcd files\n" ); + CUtlVector< CUtlSymbol > vcdfiles; + BuildFileList( basedir, vcdfiles, vcddir, ".vcd" ); + vprint( 1, "found %i .vcd files\n", vcdfiles.Count() ); + + CompileVCDs( vcdfiles ); + } + + if ( modelsoundscache ) + { + vprint( 1, "Building list of .mdl files\n" ); + CUtlVector< CUtlSymbol > mdlfiles; + BuildFileList( basedir, mdlfiles, modelsdir, ".mdl" ); + vprint( 1, "found %i .mdl files\n", mdlfiles.Count() ); + + CompileMDLs( mdlfiles ); + } + } + + if ( scenecache ) + { + if ( g_SceneCache.IsDirty() ) + { + g_SceneCache.Save(); + } + g_SceneCache.Shutdown(); + } + + if ( modelsoundscache ) + { + if ( g_ModelSoundsCache.IsDirty() ) + { + g_ModelSoundsCache.Save(); + } + g_ModelSoundsCache.Shutdown(); + + g_pMDLCache->ShutdownPreloadData(); + } + + soundemitterbase->ModShutdown(); + + return 0; +} + +//----------------------------------------------------------------------------- +// Purpose: +// Input : argc - +// argv[] - +// Output : int +//----------------------------------------------------------------------------- +int main( int argc, char* argv[] ) +{ + CommandLine()->CreateCmdLine( argc, argv ); + + CMakeCachesApp sceneManagerApp; + CSteamApplication steamApplication( &sceneManagerApp ); + int nRetVal = steamApplication.Run(); + + return nRetVal; +}
\ No newline at end of file diff --git a/utils/xbox/makexvcd/makexvcd.vcproj b/utils/xbox/makexvcd/makexvcd.vcproj new file mode 100644 index 0000000..c90784c --- /dev/null +++ b/utils/xbox/makexvcd/makexvcd.vcproj @@ -0,0 +1,497 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="7.10" + Name="makexvcd" + ProjectGUID="{36C1181C-9B10-48CB-956A-059A284C9F8B}" + RootNamespace="makexvcd" + Keyword="Win32Proj"> + <Platforms> + <Platform + Name="Win32"/> + </Platforms> + <Configurations> + <Configuration + Name="Debug|Win32" + OutputDirectory="Debug" + IntermediateDirectory="Debug" + ConfigurationType="1" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + AdditionalIncludeDirectories="../../../public;../../../public/tier1;../../common;../../../game_shared;./" + PreprocessorDefinitions="MAKEXVCD" + MinimalRebuild="TRUE" + BasicRuntimeChecks="3" + RuntimeLibrary="5" + UsePrecompiledHeader="0" + WarningLevel="3" + Detect64BitPortabilityProblems="TRUE" + DebugInformationFormat="4"/> + <Tool + Name="VCCustomBuildTool" + CommandLine="if exist ..\..\..\..\game\bin\"$(TargetName)".exe attrib -r ..\..\..\..\game\bin\"$(TargetName)".exe +if exist "$(TargetPath)" copy "$(TargetPath)" ..\..\..\..\game\bin +" + Outputs="..\..\..\..\game\bin\$(TargetName).exe"/> + <Tool + Name="VCLinkerTool" + OutputFile="$(OutDir)/makexvcd.exe" + LinkIncremental="2" + IgnoreDefaultLibraryNames="LIBCMT,LIBCMTD" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile="$(OutDir)/makexvcd.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool"/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + <Configuration + Name="Release|Win32" + OutputDirectory="Release" + IntermediateDirectory="Release" + ConfigurationType="1" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + AdditionalIncludeDirectories="../../../public;../../../public/tier1;../../common;../../../game_shared;./" + PreprocessorDefinitions="MAKEXVCD" + RuntimeLibrary="4" + UsePrecompiledHeader="0" + WarningLevel="3" + Detect64BitPortabilityProblems="TRUE" + DebugInformationFormat="3"/> + <Tool + Name="VCCustomBuildTool" + CommandLine="if exist ..\..\..\..\game\bin\"$(TargetName)".exe attrib -r ..\..\..\..\game\bin\"$(TargetName)".exe +if exist "$(TargetPath)" copy "$(TargetPath)" ..\..\..\..\game\bin +" + Outputs="..\..\..\..\game\bin\$(TargetName).exe"/> + <Tool + Name="VCLinkerTool" + OutputFile="$(OutDir)/makexvcd.exe" + LinkIncremental="1" + IgnoreDefaultLibraryNames="LIBCMT,LIBCMTD" + GenerateDebugInformation="TRUE" + SubSystem="1" + OptimizeReferences="2" + EnableCOMDATFolding="2" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool"/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx" + UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> + <File + RelativePath=".\makexvcd.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl;inc;xsd" + UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> + <File + RelativePath=".\cbase.h"> + </File> + </Filter> + <Filter + Name="Resource Files" + Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx" + UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"> + </Filter> + <Filter + Name="Shared Code" + Filter=""> + <File + RelativePath="..\..\..\game_shared\activitylist.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\game_shared\activitylist.h"> + </File> + <File + RelativePath="..\..\..\game_shared\animation.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\game_shared\animation.h"> + </File> + <File + RelativePath="..\..\..\public\tier1\checksum_crc.h"> + </File> + <File + RelativePath="..\..\..\game_shared\choreoactor.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\game_shared\choreoactor.h"> + </File> + <File + RelativePath="..\..\..\game_shared\choreochannel.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\game_shared\choreochannel.h"> + </File> + <File + RelativePath="..\..\..\game_shared\choreoevent.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\game_shared\choreoevent.h"> + </File> + <File + RelativePath="..\..\..\game_shared\choreoscene.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\game_shared\choreoscene.h"> + </File> + <File + RelativePath="..\..\common\cmdlib.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\common\cmdlib.h"> + </File> + <File + RelativePath="..\..\..\game_shared\eventlist.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\game_shared\eventlist.h"> + </File> + <File + RelativePath="..\..\..\public\filesystem_helpers.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\public\filesystem_helpers.h"> + </File> + <File + RelativePath="..\..\..\public\filesystem_init.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\public\filesystem_init.h"> + </File> + <File + RelativePath="..\..\common\filesystem_tools.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\common\filesystem_tools.h"> + </File> + <File + RelativePath="..\..\..\public\interpolatortypes.cpp"> + </File> + <File + RelativePath="..\..\..\public\interpolatortypes.h"> + </File> + <File + RelativePath="..\..\..\public\mathlib\mathlib.h"> + </File> + <File + RelativePath="..\..\..\game_shared\ModelSoundsCache.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\game_shared\ModelSoundsCache.h"> + </File> + <File + RelativePath="..\..\common\pacifier.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\common\pacifier.h"> + </File> + <File + RelativePath="..\..\..\game_shared\SceneCache.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\game_shared\SceneCache.h"> + </File> + <File + RelativePath="..\..\common\scriplib.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\common\scriplib.h"> + </File> + <File + RelativePath="..\..\..\public\stringregistry.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + <File + RelativePath="..\..\..\public\stringregistry.h"> + </File> + <File + RelativePath="..\..\..\public\studio.cpp"> + <FileConfiguration + Name="Debug|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + <FileConfiguration + Name="Release|Win32"> + <Tool + Name="VCCLCompilerTool" + UsePrecompiledHeader="0"/> + </FileConfiguration> + </File> + </Filter> + <File + RelativePath="..\..\..\lib\public\appframework.lib"> + </File> + <File + RelativePath="..\..\..\lib\public\mathlib.lib"> + </File> + <File + RelativePath="..\..\..\lib\public\tier0.lib"> + </File> + <File + RelativePath="..\..\..\lib\public\tier1.lib"> + </File> + <File + RelativePath="..\..\..\lib\public\tier2.lib"> + </File> + <File + RelativePath="..\..\..\lib\public\vstdlib.lib"> + </File> + </Files> + <Globals> + </Globals> +</VisualStudioProject> diff --git a/utils/xbox/toollib/piclib.cpp b/utils/xbox/toollib/piclib.cpp new file mode 100644 index 0000000..fc0101a --- /dev/null +++ b/utils/xbox/toollib/piclib.cpp @@ -0,0 +1,557 @@ +#include "toollib.h" +#include "piclib.h" + +byte_t* g_tgabuffer; +byte_t* g_tgabuffptr; + +/***************************************************************************** + TL_LoadPCX + +*****************************************************************************/ +void TL_LoadPCX(char* filename, byte_t** pic, byte_t** palette, int* width, int* height) +{ + byte_t* raw; + pcx_t* pcx; + int x; + int y; + int len; + int databyte; + int runlength; + byte_t* out; + byte_t* pix; + + // load the file + len = TL_LoadFile(filename,(void **)&raw); + + // parse the PCX file + pcx = (pcx_t*)raw; + raw = &pcx->data; + + pcx->xmin = TL_LittleShort(pcx->xmin); + pcx->ymin = TL_LittleShort(pcx->ymin); + pcx->xmax = TL_LittleShort(pcx->xmax); + pcx->ymax = TL_LittleShort(pcx->ymax); + pcx->hres = TL_LittleShort(pcx->hres); + pcx->vres = TL_LittleShort(pcx->vres); + pcx->bytes_per_line = TL_LittleShort(pcx->bytes_per_line); + pcx->palette_type = TL_LittleShort(pcx->palette_type); + + if (pcx->manufacturer != 0x0a || + pcx->version != 5 || + pcx->encoding != 1 || + pcx->bits_per_pixel != 8 || + pcx->xmax >= 640 || + pcx->ymax >= 480) + TL_Error("Bad pcx file %s",filename); + + if (palette) + { + *palette = (byte_t*)TL_Malloc(768); + memcpy(*palette,(byte_t*)pcx + len - 768,768); + } + + if (width) + *width = pcx->xmax+1; + + if (height) + *height = pcx->ymax+1; + + if (!pic) + return; + + out = (byte_t*)TL_Malloc((pcx->ymax+1)*(pcx->xmax+1)); + *pic = out; + pix = out; + + for (y=0; y<=pcx->ymax; y++, pix += pcx->xmax+1) + { + for (x=0; x<=pcx->xmax; ) + { + databyte = *raw++; + + if((databyte & 0xC0) == 0xC0) + { + runlength = databyte & 0x3F; + databyte = *raw++; + } + else + runlength = 1; + + while (runlength-- > 0) + pix[x++] = databyte; + } + } + + if (raw - (byte_t *)pcx > len) + TL_Error("PCX file %s was malformed",filename); + + TL_Free(pcx); +} + +/***************************************************************************** + TL_SavePCX + +*****************************************************************************/ +void TL_SavePCX(char* filename, byte_t* data, int width, int height, byte_t* palette) +{ + int i; + int j; + int length; + pcx_t* pcx; + byte_t* pack; + + pcx = (pcx_t*)TL_Malloc(width*height*2+1000); + + pcx->manufacturer = 0x0A; // PCX id + pcx->version = 5; // 256 color + pcx->encoding = 1; // uncompressed + pcx->bits_per_pixel = 8; // 256 color + pcx->xmin = 0; + pcx->ymin = 0; + pcx->xmax = TL_LittleShort((short)(width-1)); + pcx->ymax = TL_LittleShort((short)(height-1)); + pcx->hres = TL_LittleShort((short)width); + pcx->vres = TL_LittleShort((short)height); + pcx->color_planes = 1; // chunky image + pcx->bytes_per_line = TL_LittleShort((short)width); + pcx->palette_type = TL_LittleShort(2); // not a grey scale + + // pack the image + pack = &pcx->data; + + for (i=0; i<height; i++) + { + for (j=0; j<width; j++) + { + if ((*data & 0xc0) != 0xC0) + *pack++ = *data++; + else + { + *pack++ = 0xC1; + *pack++ = *data++; + } + } + } + + // write the palette + *pack++ = 0x0C; + for (i=0; i<768; i++) + *pack++ = *palette++; + + // write output file + length = pack - (byte_t*)pcx; + TL_SaveFile(filename,pcx,length); + + TL_Free(pcx); +} + +/***************************************************************************** + TGA_GetByte + +*****************************************************************************/ +byte_t TGA_GetByte(void) +{ + return (*g_tgabuffptr++); +} + +/***************************************************************************** + TGA_GetShort + +*****************************************************************************/ +short TGA_GetShort(void) +{ + byte_t msb; + byte_t lsb; + + lsb = g_tgabuffptr[0]; + msb = g_tgabuffptr[1]; + + g_tgabuffptr += 2; + + return ((msb<<8)|lsb); +} + +/***************************************************************************** + TL_LoadTGA + +*****************************************************************************/ +void TL_LoadTGA(char* name, byte_t** pixels, int* width, int* height) +{ + int columns; + int rows; + int numPixels; + byte_t* pixbuf; + int row; + int column; + byte_t* targa_rgba; + tga_t targa_header; + byte_t red; + byte_t green; + byte_t blue; + byte_t alphabyte; + byte_t packetHeader; + byte_t packetSize; + byte_t j; + + TL_LoadFile(name,(void**)&g_tgabuffer); + g_tgabuffptr = g_tgabuffer; + + /* load unaligned tga data */ + targa_header.id_length = TGA_GetByte(); + targa_header.colormap_type = TGA_GetByte(); + targa_header.image_type = TGA_GetByte(); + targa_header.colormap_index = TGA_GetShort(); + targa_header.colormap_length = TGA_GetShort(); + targa_header.colormap_size = TGA_GetByte(); + targa_header.x_origin = TGA_GetShort(); + targa_header.y_origin = TGA_GetShort(); + targa_header.width = TGA_GetShort(); + targa_header.height = TGA_GetShort(); + targa_header.pixel_size = TGA_GetByte(); + targa_header.attributes = TGA_GetByte(); + + if (targa_header.image_type != 2 && targa_header.image_type != 10) + TL_Error("TL_LoadTGA: %s - Only type 2 and 10 targa RGB images supported",name); + + if ((targa_header.colormap_type != 0) || (targa_header.pixel_size != 32 && targa_header.pixel_size != 24)) + TL_Error("TL_LoadTGA: %s - Only 32 or 24 bit images supported (no colormaps)",name); + + columns = targa_header.width; + rows = targa_header.height; + numPixels = columns * rows; + + if (width) + *width = columns; + if (height) + *height = rows; + + targa_rgba = (byte_t*)TL_Malloc(numPixels*4); + *pixels = targa_rgba; + + if (targa_header.id_length != 0) + { + // skip TARGA image comment + g_tgabuffptr += targa_header.id_length; + } + + if (targa_header.image_type==2) + { + // Uncompressed, RGB images + for (row=rows-1; row>=0; row--) + { + pixbuf = targa_rgba + row*columns*4; + for(column=0; column<columns; column++) + { + switch (targa_header.pixel_size) + { + case 24: + blue = TGA_GetByte(); + green = TGA_GetByte(); + red = TGA_GetByte(); + alphabyte = 255; + break; + + case 32: + blue = TGA_GetByte(); + green = TGA_GetByte(); + red = TGA_GetByte(); + alphabyte = TGA_GetByte(); + break; + } + + *pixbuf++ = red; + *pixbuf++ = green; + *pixbuf++ = blue; + *pixbuf++ = alphabyte; + + } + } + } + else if (targa_header.image_type==10) + { + // Runlength encoded RGB images + for (row=rows-1; row>=0; row--) + { + pixbuf = targa_rgba + row*columns*4; + for(column=0; column<columns; ) + { + packetHeader = TGA_GetByte(); + packetSize = 1 + (packetHeader & 0x7f); + if (packetHeader & 0x80) + { + // run-length packet + switch (targa_header.pixel_size) + { + case 24: + blue = TGA_GetByte(); + green = TGA_GetByte(); + red = TGA_GetByte(); + alphabyte = 255; + break; + + case 32: + blue = TGA_GetByte(); + green = TGA_GetByte(); + red = TGA_GetByte(); + alphabyte = TGA_GetByte(); + break; + } + + for(j=0; j<packetSize; j++) + { + *pixbuf++ = red; + *pixbuf++ = green; + *pixbuf++ = blue; + *pixbuf++ = alphabyte; + column++; + + if (column==columns) + { + // run spans across rows + column=0; + if (row>0) + row--; + else + goto breakOut; + pixbuf = targa_rgba + row*columns*4; + } + } + } + else + { + // non run-length packet + for(j=0; j<packetSize; j++) + { + switch (targa_header.pixel_size) + { + case 24: + blue = TGA_GetByte(); + green = TGA_GetByte(); + red = TGA_GetByte(); + alphabyte = 255; + break; + + case 32: + blue = TGA_GetByte(); + green = TGA_GetByte(); + red = TGA_GetByte(); + alphabyte = TGA_GetByte(); + break; + } + + *pixbuf++ = red; + *pixbuf++ = green; + *pixbuf++ = blue; + *pixbuf++ = alphabyte; + column++; + + if (column == columns) + { + // pixel packet run spans across rows + column=0; + if (row>0) + row--; + else + goto breakOut; + pixbuf = targa_rgba + row*columns*4; + } + } + } + } +breakOut:; + } + } + + TL_Free(g_tgabuffer); +} + +/***************************************************************************** + TL_SaveTGA + + Saves TGA. Supports r/w 16/24/32 bpp. +*****************************************************************************/ +void TL_SaveTGA(char* filename, byte_t* pixels, int width, int height, int sbpp, int tbpp) +{ + int handle; + tga_t tga; + unsigned short rgba5551; + unsigned long rgba8888; + int r; + int g; + int b; + int x; + int y; + int a; + byte_t* tgabuffer; + byte_t* tgabufferptr; + byte_t* rawbufferptr; + byte_t* tempbuffer; + byte_t* tempbufferptr; + int bytesperpixel; + + // all source is upsampled into easy 32 bit rgba8888 + // and downsampled into tga buffer + tempbuffer = (byte_t*)TL_Malloc(width*height*4); + + if (sbpp == 16) + { + /* source is 16 bit rgba */ + rawbufferptr = pixels; + for (y=0; y<height; y++) + { + tempbufferptr = tempbuffer + y*width*4; + for (x=0; x<width; x++) + { + rgba5551 = *(unsigned short*)rawbufferptr; + r = (rgba5551 & 0xF800)>>11; + g = (rgba5551 & 0x07C0)>>6; + b = (rgba5551 & 0x003E)>>1; + a = (rgba5551 & 0x01); + tempbufferptr[0] = (byte_t)(b * (255.0/31.0)); + tempbufferptr[1] = (byte_t)(g * (255.0/31.0)); + tempbufferptr[2] = (byte_t)(r * (255.0/31.0)); + tempbufferptr[3] = (byte_t)(a * 255.0); + + rawbufferptr += sizeof(unsigned short); + tempbufferptr += 4; + } + } + } + else if (sbpp == 24) + { + /* source is 24 bit rgba */ + rawbufferptr = pixels; + for (y=0; y<height; y++) + { + tempbufferptr = tempbuffer + y*width*4; + for (x=0; x<width; x++) + { + tempbufferptr[0] = rawbufferptr[0]; + tempbufferptr[1] = rawbufferptr[1]; + tempbufferptr[2] = rawbufferptr[2]; + tempbufferptr[3] = 255; + + rawbufferptr += 3; + tempbufferptr += 4; + } + } + } + else if (sbpp == 32) + { + /* source is 32 bit rgba */ + memcpy(tempbuffer,pixels,width*height*4); + } + else + TL_Error("TL_SaveTGA: cannot handle source %d bits per pixel",sbpp); + + if (tbpp == 16) + bytesperpixel = 2; + else if (tbpp == 24) + bytesperpixel = 3; + else if (tbpp == 32) + bytesperpixel = 4; + else + TL_Error("TL_SaveTGA: cannot handle target %d bits per pixel",tbpp); + + handle = TL_SafeOpenWrite(filename); + + /* write the targa header */ + tga.id_length = 0; + tga.colormap_type = 0; + tga.image_type = 2; + tga.colormap_index = 0; + tga.colormap_length = 0; + tga.colormap_size = 0; + tga.x_origin = 0; + tga.y_origin = 0; + tga.width = width; + tga.height = height; + tga.pixel_size = tbpp; + tga.attributes = 0; + + TL_SafeWrite(handle,&tga.id_length,sizeof(tga.id_length)); + TL_SafeWrite(handle,&tga.colormap_type,sizeof(tga.colormap_type)); + TL_SafeWrite(handle,&tga.image_type,sizeof(tga.image_type)); + TL_SafeWrite(handle,&tga.colormap_index,sizeof(tga.colormap_index)); + TL_SafeWrite(handle,&tga.colormap_length,sizeof(tga.colormap_length)); + TL_SafeWrite(handle,&tga.colormap_size,sizeof(tga.colormap_size)); + TL_SafeWrite(handle,&tga.x_origin,sizeof(tga.x_origin)); + TL_SafeWrite(handle,&tga.y_origin,sizeof(tga.y_origin)); + TL_SafeWrite(handle,&tga.width,sizeof(tga.width)); + TL_SafeWrite(handle,&tga.height,sizeof(tga.height)); + TL_SafeWrite(handle,&tga.pixel_size,sizeof(tga.pixel_size)); + TL_SafeWrite(handle,&tga.attributes,sizeof(tga.attributes)); + + /* tga images are upside down left to right - !@#$% */ + tgabuffer = (byte_t*)TL_Malloc(width*height*bytesperpixel); + + /* source is 32 bit rgba */ + rawbufferptr = tempbuffer; + for (y=height-1; y>=0; y--) + { + tgabufferptr = tgabuffer + y*width*bytesperpixel; + for (x=0; x<width; x++) + { + switch (bytesperpixel) + { + case 2: + break; + + case 3: + rgba8888 = TL_BigLong(*(unsigned long*)rawbufferptr); + r = (rgba8888 & 0xFF000000)>>24; + g = (rgba8888 & 0x00FF0000)>>16; + b = (rgba8888 & 0x0000FF00)>>8; + + tgabufferptr[0] = b; + tgabufferptr[1] = g; + tgabufferptr[2] = r; + break; + + case 4: + rgba8888 = TL_BigLong(*(unsigned long*)rawbufferptr); + r = (rgba8888 & 0xFF000000)>>24; + g = (rgba8888 & 0x00FF0000)>>16; + b = (rgba8888 & 0x0000FF00)>>8; + a = rgba8888 & 0xFF; + + tgabufferptr[0] = b; + tgabufferptr[1] = g; + tgabufferptr[2] = r; + tgabufferptr[3] = a; + break; + } + + rawbufferptr += 4; + tgabufferptr += bytesperpixel; + } + } + + TL_SafeWrite(handle,tgabuffer,width*height*bytesperpixel); + close(handle); + + TL_Free(tempbuffer); + TL_Free(tgabuffer); +} + +/***************************************************************************** + TL_LoadImage + + Loads an image based on extension. +*****************************************************************************/ +void TL_LoadImage(char* name, byte_t** pixels, byte_t** palette, int* width, int* height) +{ + char ext[16]; + + TL_GetExtension(name,ext); + if (!stricmp(ext,"pcx")) + TL_LoadPCX(name,pixels,palette,width,height); + else if (!stricmp(ext,"tga")) + { + TL_LoadTGA(name,pixels,width,height); + *palette = NULL; + } + else + TL_Error("TL_LoadImage: unknown image extension %s",ext); +} + diff --git a/utils/xbox/toollib/piclib.h b/utils/xbox/toollib/piclib.h new file mode 100644 index 0000000..346d94c --- /dev/null +++ b/utils/xbox/toollib/piclib.h @@ -0,0 +1,61 @@ +#ifndef _PICLIB_H_ +#define _PICLIB_H_ + +typedef enum +{ + ms_none, + ms_mask, + ms_transcolor, + ms_lasso +} +mask_t; + +typedef enum +{ + cm_none, + cm_rle1 +} +compress_t; + +typedef struct +{ + char manufacturer; + char version; + char encoding; + char bits_per_pixel; + unsigned short xmin,ymin,xmax,ymax; + unsigned short hres,vres; + unsigned char palette[48]; + char reserved; + char color_planes; + unsigned short bytes_per_line; + unsigned short palette_type; + char filler[58]; + unsigned char data; +} pcx_t; + +typedef struct +{ + unsigned char id_length; + unsigned char colormap_type; + unsigned char image_type; + unsigned char pad1; // not in file + unsigned short colormap_index; + unsigned short colormap_length; + unsigned char colormap_size; + unsigned char pad2; // not in file + unsigned short x_origin; + unsigned short y_origin; + unsigned short width; + unsigned short height; + unsigned char pixel_size; + unsigned char attributes; +} tga_t; + +extern void TL_LoadPCX(char* filename, byte_t** picture, byte_t** palette, int* width, int* height); +extern void TL_SavePCX(char* filename, byte_t* data, int width, int height, byte_t* palette); +extern void TL_LoadTGA(char* name, byte_t** pixels, int* width, int* height); +extern void TL_SaveTGA(char* filename, byte_t* pixels, int width, int height, int sbpp, int tbpp); +extern void TL_LoadImage(char* name, byte_t** pixels, byte_t** palette, int* width, int* height); + +#endif diff --git a/utils/xbox/toollib/scriplib.cpp b/utils/xbox/toollib/scriplib.cpp new file mode 100644 index 0000000..e674673 --- /dev/null +++ b/utils/xbox/toollib/scriplib.cpp @@ -0,0 +1,264 @@ +#include "toollib.h" + +char g_tl_token[MAXTOKEN]; +char* g_tl_scriptbuff; +char* g_tl_scriptptr; +char* g_tl_scriptendptr; +int g_tl_scriptsize; +int g_tl_scriptline; +bool g_tl_endofscript; +bool g_tl_tokenready; +int g_tl_oldscriptline; +char* g_tl_oldscriptptr; + +/***************************************************************************** + TL_FreeScriptFile + +*****************************************************************************/ +void TL_FreeScriptFile(void) +{ + if (g_tl_scriptbuff) + { + TL_Free(g_tl_scriptbuff); + g_tl_scriptbuff = NULL; + } +} + +/***************************************************************************** + TL_LoadScriptFile + +*****************************************************************************/ +void TL_LoadScriptFile(const char* filename) +{ + g_tl_scriptsize = TL_LoadFile(filename,(void **)&g_tl_scriptbuff); + + TL_ResetParser(); +} + +/***************************************************************************** + TL_SetScriptData + +*****************************************************************************/ +void TL_SetScriptData(char* data, int length) +{ + g_tl_scriptbuff = data; + g_tl_scriptsize = length; + + TL_ResetParser(); +} + +/***************************************************************************** + TL_UnGetToken + +*****************************************************************************/ +void TL_UnGetToken(void) +{ + g_tl_tokenready = true; +} + +/***************************************************************************** + TL_GetToken + +*****************************************************************************/ +char* TL_GetToken(bool crossline) +{ + char* tokenptr; + + if (g_tl_tokenready) + { + g_tl_tokenready = false; + return (g_tl_token); + } + + g_tl_token[0] = '\0'; + + if (g_tl_scriptptr >= g_tl_scriptendptr) + { + if (!crossline) + TL_Error("TL_GetToken: Line %d is incomplete",g_tl_scriptline); + + g_tl_endofscript = true; + return (NULL); + } + +skipspace: + while (*g_tl_scriptptr <= ' ') + { + if (g_tl_scriptptr >= g_tl_scriptendptr) + { + if (!crossline) + TL_Error("GetToken: Line %i is incomplete",g_tl_scriptline); + + g_tl_endofscript = true; + return (NULL); + } + + if (*g_tl_scriptptr++ == '\n') + { + if (!crossline) + TL_Error("GetToken: Line %i is incomplete",g_tl_scriptline); + + g_tl_scriptline++; + } + } + + if (g_tl_scriptptr >= g_tl_scriptendptr) + { + if (!crossline) + TL_Error("GetToken: Line %i is incomplete",g_tl_scriptline); + + g_tl_endofscript = true; + return (NULL); + } + + // skip commented line + if ((g_tl_scriptptr[0] == ';') || (g_tl_scriptptr[0] == '/' && g_tl_scriptptr[1] == '/')) + { + if (!crossline) + TL_Error("GetToken: Line %i is incomplete",g_tl_scriptline); + + while (*g_tl_scriptptr++ != '\n') + { + if (g_tl_scriptptr >= g_tl_scriptendptr) + { + g_tl_endofscript = true; + return (NULL); + } + } + + g_tl_scriptline++; + goto skipspace; + } + + tokenptr = g_tl_token; + if (g_tl_scriptptr[0] == '\"' && g_tl_scriptptr[1]) + { + // copy quoted token + do + { + *tokenptr++ = *g_tl_scriptptr++; + if (g_tl_scriptptr == g_tl_scriptendptr) + break; + + if (tokenptr == &g_tl_token[MAXTOKEN]) + TL_Error("GetToken: Token too large on line %i",g_tl_scriptline); + } + while (*g_tl_scriptptr >= ' ' && *g_tl_scriptptr != '\"'); + + if (g_tl_scriptptr[0] == '\"') + *tokenptr++ = *g_tl_scriptptr++; + } + else + { + // copy token + while (*g_tl_scriptptr > ' ' && *g_tl_scriptptr != ';' && *g_tl_scriptptr != '\"') + { + *tokenptr++ = *g_tl_scriptptr++; + if (g_tl_scriptptr == g_tl_scriptendptr) + break; + + if (tokenptr == &g_tl_token[MAXTOKEN]) + TL_Error("GetToken: Token too large on line %i",g_tl_scriptline); + } + } + + *tokenptr = '\0'; + + return (g_tl_token); +} + +/***************************************************************************** + TL_SkipRestOfLine + +*****************************************************************************/ +void TL_SkipRestOfLine(void) +{ + while (*g_tl_scriptptr++ != '\n') + { + if (g_tl_scriptptr >= g_tl_scriptendptr) + { + break; + } + } + + g_tl_scriptline++; +} + +/***************************************************************************** + TL_TokenAvailable + + Returns (TRUE) if token available on line. +*****************************************************************************/ +bool TL_TokenAvailable (void) +{ + char* ptr; + + ptr = g_tl_scriptptr; + while (*ptr <= ' ') + { + if (ptr >= g_tl_scriptendptr) + { + g_tl_endofscript = true; + return (false); + } + + if (*ptr++ == '\n') + return (false); + } + + return (true); +} + + +/***************************************************************************** + TL_EndOfScript + + Returns (TRUE) at end of script +*****************************************************************************/ +bool TL_EndOfScript(void) +{ + if (g_tl_scriptptr >= g_tl_scriptendptr) + { + g_tl_endofscript = true; + return (true); + } + + return (false); +} + +/***************************************************************************** + TL_ResetParser + +*****************************************************************************/ +void TL_ResetParser(void) +{ + g_tl_scriptptr = g_tl_scriptbuff; + g_tl_scriptendptr = g_tl_scriptptr + g_tl_scriptsize; + g_tl_scriptline = 1; + g_tl_endofscript = false; + g_tl_tokenready = false; +} + +/***************************************************************************** + TL_SaveParser + +*****************************************************************************/ +void TL_SaveParser(void) +{ + g_tl_oldscriptline = g_tl_scriptline; + g_tl_oldscriptptr = g_tl_scriptptr; +} + +/***************************************************************************** + TL_RestoreParser + +*****************************************************************************/ +void TL_RestoreParser(void) +{ + g_tl_scriptline = g_tl_oldscriptline; + g_tl_scriptptr = g_tl_oldscriptptr; +} + + + + diff --git a/utils/xbox/toollib/scriplib.h b/utils/xbox/toollib/scriplib.h new file mode 100644 index 0000000..292a16c --- /dev/null +++ b/utils/xbox/toollib/scriplib.h @@ -0,0 +1,28 @@ +#ifndef _SCRIPLIB_H_ +#define _SCRIPLIB_H_ + +#define MAXTOKEN 128 + +extern void TL_LoadScriptFile(const char* filename); +extern void TL_SetScriptData(char* data, int length); +extern void TL_FreeScriptFile(void); +extern char* TL_GetToken(bool crossline); +extern char* TL_GetQuotedToken(bool crossline); +extern void TL_UnGetToken(void); +extern bool TL_TokenAvailable(void); +extern void TL_SaveParser(void); +extern void TL_RestoreParser(void); +extern void TL_ResetParser(void); +extern void TL_SkipRestOfLine(void); +extern bool TL_EndOfScript(void); +extern char* TL_GetRawToken(void); + +extern char g_tl_token[MAXTOKEN]; +extern char* g_tl_scriptbuffer; +extern char* g_tl_scriptptr; +extern char* g_tl_scriptendptr; +extern int g_tl_scriptsize; // ydnar +extern int g_tl_scriptline; +extern bool g_tl_endofscript; + +#endif diff --git a/utils/xbox/toollib/toollib.cpp b/utils/xbox/toollib/toollib.cpp new file mode 100644 index 0000000..998bf91 --- /dev/null +++ b/utils/xbox/toollib/toollib.cpp @@ -0,0 +1,1322 @@ +#include "toollib.h" + +#ifdef _DEBUG +#define HEAP_CHECK +#endif + +int g_tl_argc; +char** g_tl_argv; +int g_tl_byteorder; +int g_tl_dircount; +char** g_tl_dirlist; +int g_tl_start; +int g_tl_abort; +bool g_tl_quiet; + +#pragma warning(disable:4311) +#pragma warning(disable:4267) + +/***************************************************************************** + TL_Setup + +*****************************************************************************/ +void TL_Setup(char* appname, int argc, char** argv) +{ + const char* buildStr; + + g_tl_argc = argc; + g_tl_argv = argv; + + g_tl_quiet = (TL_CheckParm("q") > 0) || (TL_CheckParm("quiet") > 0) || (TL_CheckParm("noheader") > 0); + + if (appname) + { + TL_printf("\n%s \n",appname); +#ifdef _DEBUG + buildStr = "Debug Build"; +#else + buildStr = "Release Build"; +#endif + TL_printf("%s - %s %s\n\n", buildStr, __DATE__, __TIME__); + } + + g_tl_abort = TL_CheckParm("abort"); + g_tl_start = TL_CPUCount(); +} + +/***************************************************************************** + TL_End + +*****************************************************************************/ +void TL_End(bool showtime) +{ + int end; + + if (showtime && !g_tl_quiet) + { + end = TL_CPUCount(); + TL_printf("\n%f seconds.\n",TL_CPUTime(g_tl_start,end)); + } +} + +/***************************************************************************** + TL_Error + +*****************************************************************************/ +void TL_Error(char* error, ...) +{ + va_list argptr; + + va_start(argptr,error); + vprintf(error,argptr); + va_end(argptr); + + printf("\n"); + +#if !defined( _X360 ) + __asm + { + int 3; + } +#endif + + if (g_tl_abort) + abort(); + + exit(-1); +} + +/***************************************************************************** + TL_CheckParm + + Returns the argument number (1 to argc-1) or 0 if not present +*****************************************************************************/ +int TL_CheckParm(char* check) +{ + int i; + char* parm; + + for (i=1; i<g_tl_argc; i++) + { + parm = g_tl_argv[i]; + + if (!isalpha(*parm)) + if (!*++parm) + continue; + + if (!stricmp(check,parm)) + return (i); + } + + return (0); +} + +/***************************************************************************** + TL_SafeRead + +*****************************************************************************/ +void TL_SafeRead(int handle, void* buffer, long count) +{ + if (_read(handle,buffer,count) != count) + TL_Error("SafeRead(): read failure"); +} + +/***************************************************************************** + TL_SafeOpenRead + +*****************************************************************************/ +int TL_SafeOpenRead(const char* filename) +{ + int handle; + + handle = _open(filename,_O_RDONLY|_O_BINARY); + if (handle == -1) + TL_Error("TL_SafeOpenRead(): Error opening %s: %s",filename,strerror(errno)); + + return (handle); +} + +/***************************************************************************** + TL_SafeOpenWrite + +*****************************************************************************/ +int TL_SafeOpenWrite(const char* filename) +{ + int handle; + + handle = _open(filename,_O_RDWR|_O_BINARY|_O_CREAT|_O_TRUNC,0666); + if (handle == -1) + TL_Error("TL_SafeOpenWrite(): Error opening %s: %s",filename,strerror(errno)); + + return (handle); +} + +/***************************************************************************** + TL_SafeWrite + +*****************************************************************************/ +void TL_SafeWrite(int handle, void* buffer, long count) +{ + int status; + + status = _write(handle,buffer,count); + if (status != count) + TL_Error("TL_SafeWrite(): write failure %d, errno=%d",status,errno); +} + +/***************************************************************************** + TL_SafeClose + +*****************************************************************************/ +void TL_SafeClose(int handle, int touch) +{ + // ensure date and time of modification get set + if (touch) + _futime(handle,NULL); + + close(handle); +} + +/***************************************************************************** + TL_Malloc + +*****************************************************************************/ +void* TL_Malloc(int size) +{ + void* ptr; + int newsize; + + newsize = size + sizeof(tlmem_t); + newsize = (newsize + 3) & ~3; + + ptr = malloc(newsize); + if (!ptr) + TL_Error("TL_Malloc(): failure for %lu bytes",size); + + memset(ptr,0,newsize); + + ((tlmem_t*)ptr)->id = TL_MEMID; + ((tlmem_t*)ptr)->size = size; + + return ((byte_t*)ptr + sizeof(tlmem_t)); +} + +/***************************************************************************** + TL_Free + +*****************************************************************************/ +void TL_Free(void* ptr) +{ + tlmem_t* memptr; + + if (!ptr) + TL_Error("TL_Free(): null pointer"); + + memptr = (tlmem_t*)((byte_t*)ptr - sizeof(tlmem_t)); + + if (((u32)memptr) & 3) + TL_Error("TL_Free(): bad pointer %8.8x",ptr); + + if (memptr->id != TL_MEMID) + TL_Error("TL_Free(): corrupted pointer %8.8x",ptr); + + memptr->id = 0; + memptr->size = 0; + + free(memptr); + +#ifdef HEAP_CHECK + if (_heapchk() != _HEAPOK) + TL_Error("TL_Free(): heap corrupted"); +#endif +} + +bool TL_Check(void* ptr) +{ + tlmem_t* memptr; + + if (!ptr) + return false; + + memptr = (tlmem_t*)((byte_t*)ptr - sizeof(tlmem_t)); + + if (((u32)memptr) & 3) + return false; + + if (memptr->id != TL_MEMID) + return false; + + return true; +} + +/***************************************************************************** + TL_Realloc + +*****************************************************************************/ +void* TL_Realloc(void* ptr, int newsize) +{ + int len; + tlmem_t* oldmemptr; + void* newptr; + + if (!ptr) + { + newptr = TL_Malloc(newsize); + return (newptr); + } + + oldmemptr = (tlmem_t*)((byte_t*)ptr - sizeof(tlmem_t)); + + if ((u32)oldmemptr & 3) + TL_Error("TL_Realloc(): bad pointer %8.8x",ptr); + + if (oldmemptr->id != TL_MEMID) + TL_Error("TL_Realloc(): corrupted pointer %8.8x",ptr); + + newptr = TL_Malloc(newsize); + + len = TL_min(newsize,oldmemptr->size); + + memcpy(newptr,ptr,len); + + TL_Free(ptr); + + return (newptr); +} + +/***************************************************************************** + TL_strncpyz + + Copy up to (N) bytes including appending null. +*****************************************************************************/ +void TL_strncpyz(char* dst, char* src, int n) +{ + if (n <= 0) + return; + + if (n > 1) + strncpy(dst,src,n-1); + + dst[n-1] = '\0'; +} + +/***************************************************************************** + TL_strncatz + + Concatenate up to dstsize bytes including appending null. +*****************************************************************************/ +void TL_strncatz(char* dst, char* src, int dstsize) +{ + int len; + + if (dstsize <= 0) + return; + + len = (int)strlen(dst); + + TL_strncpyz(dst+len,src,dstsize-len); +} + +/***************************************************************************** + TL_LoadFile + +*****************************************************************************/ +long TL_LoadFile(const char* filename, void** bufferptr) +{ + int handle; + long length; + char* buffer; + + handle = TL_SafeOpenRead(filename); + length = TL_FileLength(handle); + buffer = (char*)TL_Malloc(length+1); + TL_SafeRead(handle,buffer,length); + close(handle); + + // for parsing + buffer[length] = '\0'; + + *bufferptr = (void*)buffer; + + return (length); +} + +/***************************************************************************** + TL_TouchFile + +*****************************************************************************/ +void TL_TouchFile(char* filename) +{ + int h; + + h = _open(filename,_O_RDWR|_O_BINARY,0666); + if (h < 0) + return; + + _futime(h,NULL); + _close(h); +} + +/***************************************************************************** + TL_SaveFile + +*****************************************************************************/ +void TL_SaveFile(char* filename, void* buffer, long count) +{ + int handle; + + handle = TL_SafeOpenWrite(filename); + TL_SafeWrite(handle,buffer,count); + + TL_SafeClose(handle,true); +} + +/***************************************************************************** + TL_FileLength + +*****************************************************************************/ +long TL_FileLength(int handle) +{ + long pos; + long length; + + pos = lseek(handle,0,SEEK_CUR); + length = lseek(handle,0,SEEK_END); + lseek(handle,pos,SEEK_SET); + + return (length); +} + +/***************************************************************************** + TL_StripFilename + + Removes filename from path. +*****************************************************************************/ +void TL_StripFilename(char* path) +{ + int length; + + length = (int)strlen(path)-1; + while ((length > 0) && (path[length] != '\\') && (path[length] != '/') && (path[length] != ':')) + length--; + + /* leave possible seperator */ + if (!length) + path[0] = '\0'; + else + path[length+1] = '\0'; +} + +/***************************************************************************** + TL_StripExtension + + Removes extension from path. +*****************************************************************************/ +void TL_StripExtension(char* path) +{ + int length; + + length = (int)strlen(path)-1; + while (length > 0 && path[length] != '.') + length--; + + if (length && path[length] == '.') + path[length] = 0; +} + +/***************************************************************************** + TL_StripPath + + Removes path from full path. +*****************************************************************************/ +void TL_StripPath(char* path, char* dest) +{ + char* src; + + src = path + strlen(path); + while ((src != path) && (*(src-1) != '\\') && (*(src-1) != '/') && (*(src-1) != ':')) + src--; + + strcpy(dest,src); +} + +/***************************************************************************** + TL_GetExtension + + Gets any extension from the full path. +*****************************************************************************/ +void TL_GetExtension(char* path, char* dest) +{ + char* src; + + src = path + strlen(path) - 1; + + // back up until a . or the start + while (src != path && *(src-1) != '.') + src--; + + if (src == path) + { + *dest = '\0'; // no extension + return; + } + + strcpy(dest,src); +} + +/***************************************************************************** + TL_DefaultPath + + Adds basepath to head of path. +*****************************************************************************/ +void TL_DefaultPath(char* path, char* basepath) +{ + char temp[TL_MAXPATH]; + char* ptr; + char ch; + + if (path[0] == '\\') + { + // path is absolute + return; + } + + ptr = path; + while (1) + { + ch = *ptr++; + if (!ch) + break; + + if (ch == ':') + { + // path has a device - must be absolute + return; + } + } + + // place basepath at head of path + // do intermediate copy to preserve any arg wierdness + strcpy(temp,path); + strcpy(path,basepath); + strcat(path,temp); +} + +/***************************************************************************** + TL_AddSeperatorToPath + +*****************************************************************************/ +void TL_AddSeperatorToPath(char* inpath, char* outpath) +{ + int len; + + strcpy(outpath,inpath); + + len = (int)strlen(outpath); + if (outpath[len-1] != '\\') + { + outpath[len] = '\\'; + outpath[len+1] = '\0'; + } +} + +/***************************************************************************** + TL_DefaultExtension + + Adds extension a path that has no extension. +*****************************************************************************/ +void TL_DefaultExtension(char* path, char* extension, bool bForce) +{ + char* src; + + if ( !bForce && path[0] ) + { + src = path + strlen(path) - 1; + while ((src != path) && (*src != '\\') && (*src != '/')) + { + if (*src == '.') + return; + src--; + } + } + + strcat(path,extension); +} + +/***************************************************************************** + TL_ReplaceDosExtension + + Handles files of the form xxxx.xxxxxxx.xxxxx.zzz +*****************************************************************************/ +void TL_ReplaceDosExtension(char* path, char* extension) +{ + int len; + + len = (int)strlen(path); + if (!len) + return; + + if (path[len-1] == '.') + { + path[len-1] = '\0'; + strcat(path,extension); + return; + } + + if (len-4 > 0 && path[len-4] == '.') + path[len-4] = '\0'; + + strcat(path,extension); +} + +/***************************************************************************** + TL_ReplaceExtension + + Replaces any extension found after '.' +*****************************************************************************/ +void TL_ReplaceExtension(const char* inPath, const char* extension, char* outPath) +{ + int len; + char* src; + + if (outPath != inPath) + strcpy(outPath, inPath); + + len = (int)strlen(outPath); + if (!len) + return; + + if (outPath[len-1] == '.') + { + outPath[len-1] = '\0'; + strcat(outPath, extension); + return; + } + + src = outPath + len - 1; + while ((src != outPath) && (*src != '\\') && (*src != '/')) + { + if (*src == '.') + { + *src = '\0'; + break; + } + src--; + } + + strcat(outPath, extension); +} + +/***************************************************************************** + TL_TempFilename + + Builds a temporary filename at specified path. +*****************************************************************************/ +void TL_TempFilename(char* path) +{ + int len; + + len = (int)strlen(path); + if (len) + { + /* tack on appending seperator */ + if (path[len-1] != '\\') + { + path[len] = '\\'; + path[len+1] = '\0'; + } + } + + strcat(path,tmpnam(NULL)); +} + +/***************************************************************************** + TL_AlignFile + + TL_Aligns data in file to any boundary. +*****************************************************************************/ +int TL_AlignFile(int handle, int align) +{ + int i; + int pos; + int empty; + int count; + + empty = 0; + pos = lseek(handle,0,SEEK_CUR); + count = ((pos+align-1)/align)*align - pos; + + for (i=0; i<count; i++) + TL_SafeWrite(handle,&empty,1); + + return (pos+count); +} + +/***************************************************************************** + TL_GetByteOrder + + Gets byte ordering, true is bigendian. +*****************************************************************************/ +int TL_GetByteOrder(void) +{ + return (g_tl_byteorder); +} + +/***************************************************************************** + TL_SetByteOrder + + Sets byte ordering, true is bigendian. +*****************************************************************************/ +void TL_SetByteOrder(int flag) +{ + g_tl_byteorder = flag; +} + +/***************************************************************************** + TL_LongSwap + + Swap according to set state. +*****************************************************************************/ +long TL_LongSwap(long l) +{ + if (!g_tl_byteorder) + return (l); + + return (TL_BigLong(l)); +} + +/***************************************************************************** + TL_ShortSwap + + Swap according to set state. +*****************************************************************************/ +short TL_ShortSwap(short s) +{ + if (!g_tl_byteorder) + return (s); + + return (TL_BigShort(s)); +} + +/***************************************************************************** + TL_BigShort + + Converts native short to big endian +*****************************************************************************/ +short TL_BigShort(short l) +{ + byte_t b1; + byte_t b2; + + b1 = l&255; + b2 = (l>>8)&255; + + return (b1<<8) + b2; +} + +/***************************************************************************** + TL_LittleShort + + Converts native short to little endian +*****************************************************************************/ +short TL_LittleShort(short l) +{ + return (l); +} + +/***************************************************************************** + TL_BigLong + + Converts native long to big endian +*****************************************************************************/ +long TL_BigLong(long l) +{ + byte_t b1; + byte_t b2; + byte_t b3; + byte_t b4; + + b1 = (byte_t)(l&255); + b2 = (byte_t)((l>>8)&255); + b3 = (byte_t)((l>>16)&255); + b4 = (byte_t)((l>>24)&255); + + return ((long)b1<<24) + ((long)b2<<16) + ((long)b3<<8) + b4; +} + +/***************************************************************************** + TL_LittleLong + + Converts native long to little endian +*****************************************************************************/ +long TL_LittleLong(long l) +{ + return (l); +} + +/***************************************************************************** + TL_BigFloat + + Converts native float to big endian +*****************************************************************************/ +float TL_BigFloat(float f) +{ + union + { + float f; + byte_t b[4]; + } dat1,dat2; + + dat1.f = f; + dat2.b[0] = dat1.b[3]; + dat2.b[1] = dat1.b[2]; + dat2.b[2] = dat1.b[1]; + dat2.b[3] = dat1.b[0]; + + return (dat2.f); +} + +/***************************************************************************** + TL_Exists + + Returns TRUE if file exists. +*****************************************************************************/ +bool TL_Exists(const char* filename) +{ + FILE* test; + + if (!filename || !filename[0]) + return (false); + + if ((test = fopen(filename,"rb")) == NULL) + return (false); + + fclose(test); + + return (true); +} + +/***************************************************************************** + TL_FileTime + + Returns a file's time and data word. +*****************************************************************************/ +u32 TL_FileTime(char* filename) +{ + struct _finddata_t finddata; + intptr_t h; + + h = _findfirst(filename, &finddata); + if (h == -1) + return (0); + + _findclose(h); + + return (finddata.time_write); +} + +/***************************************************************************** + TL_SortNames + +*****************************************************************************/ +int TL_SortNames(const void *a, const void *b) +{ + return (strcmp(*((char **)a), *((char **)b))); +} + +/***************************************************************************** + TL_FindFiles + +*****************************************************************************/ +int TL_FindFiles(char* filemask, char*** filenames) +{ + struct _finddata_t finddata; + intptr_t h; + char sourcepath[TL_MAXPATH]; + int count; + int len; + char** names = NULL; + char* ptr; + + h = _findfirst(filemask,&finddata); + if (h == -1) + return (0); + + TL_strncpyz(sourcepath,filemask,TL_MAXPATH); + TL_StripFilename(sourcepath); + if (!sourcepath[0]) + strcpy(sourcepath,".\\"); + else + { + len = (int)strlen(sourcepath); + if (sourcepath[len-1] != '\\') + TL_strncatz(sourcepath,"\\",TL_MAXPATH); + } + + count = 0; + do + { + if (finddata.attrib & _A_SUBDIR) + continue; + + if (!count) + names = (char**)TL_Malloc(sizeof(char*)); + else + names = (char**)TL_Realloc(names,(count+1)*sizeof(char*)); + + ptr = (char*)TL_Malloc(TL_MAXPATH); + + names[count] = ptr; + TL_strncpyz(names[count],sourcepath,TL_MAXPATH); + TL_strncatz(names[count],finddata.name,TL_MAXPATH); + + count++; + } + while (!_findnext(h,&finddata)); + + _findclose(h); + + // ascending sort the names + qsort(names,count,sizeof(char*),TL_SortNames); + + *filenames = names; + return (count); +} + +/***************************************************************************** + TL_GetFileList + +*****************************************************************************/ +int TL_GetFileList(char* dirpath, char* pattern, tlfile_t*** filelist) +{ + struct _finddata_t finddata; + char sourcepath[TL_MAXPATH]; + char fullpath[TL_MAXPATH]; + char* filename; + intptr_t h; + int filecount; + int finddirs; + int len; + + filecount = 0; + + strcpy(sourcepath,dirpath); + len = (int)strlen(sourcepath); + + if (!len) + strcpy(sourcepath,".\\"); + else if (sourcepath[len-1] != '\\') + { + sourcepath[len] = '\\'; + sourcepath[len+1] = '\0'; + } + + strcpy(fullpath,sourcepath); + + if (pattern[0] == '\\' && pattern[1] == '\0') + { + // find directories + finddirs = true; + strcat(fullpath,"*"); + } + else + { + finddirs = false; + strcat(fullpath,pattern); + } + + h = _findfirst(fullpath,&finddata); + if (h == -1) + return (0); + + do + { + // dos attribute complexities i.e. _A_NORMAL is 0 + if (finddirs) + { + // skip non dirs + if (!(finddata.attrib & _A_SUBDIR)) + continue; + } + else + { + // skip dirs + if (finddata.attrib & _A_SUBDIR) + continue; + } + + if (!stricmp(finddata.name,".")) + continue; + + if (!stricmp(finddata.name,"..")) + continue; + + if (!filecount) + *filelist = (tlfile_t**)TL_Malloc(sizeof(tlfile_t*)); + else + *filelist = (tlfile_t**)TL_Realloc(*filelist,(filecount+1)*sizeof(tlfile_t*)); + + (*filelist)[filecount] = (tlfile_t*)TL_Malloc(sizeof(tlfile_t)); + + len = (int)strlen(sourcepath) + (int)strlen(finddata.name) + 1; + filename = (char*)TL_Malloc(len); + + strcpy(filename,sourcepath); + strcat(filename,finddata.name); + + (*filelist)[filecount]->filename = filename; + (*filelist)[filecount]->time_write = finddata.time_write; + + filecount++; + } + while (!_findnext(h,&finddata)); + + _findclose(h); + + return (filecount); +} + +/***************************************************************************** + _RecurseFileTree + +*****************************************************************************/ +void _RecurseFileTree(char* dirpath, int depth) +{ + tlfile_t** filelist; + int numfiles; + int i; + int len; + + // recurse from source directory + numfiles = TL_GetFileList(dirpath,"\\",&filelist); + if (!numfiles) + { + // add directory name to search tree + if (!g_tl_dircount) + g_tl_dirlist = (char**)TL_Malloc(sizeof(char*)); + else + g_tl_dirlist = (char**)TL_Realloc(g_tl_dirlist,(g_tl_dircount+1)*sizeof(char*)); + + len = (int)strlen(dirpath); + g_tl_dirlist[g_tl_dircount] = (char*)TL_Malloc(len+1); + strcpy(g_tl_dirlist[g_tl_dircount],dirpath); + + g_tl_dircount++; + return; + } + + for (i=0; i<numfiles; i++) + { + // form new path name + _RecurseFileTree(filelist[i]->filename,depth+1); + } + + g_tl_dirlist = (char**)TL_Realloc(g_tl_dirlist,(g_tl_dircount+1)*sizeof(char*)); + + len = (int)strlen(dirpath); + g_tl_dirlist[g_tl_dircount] = (char*)TL_Malloc(len+1); + strcpy(g_tl_dirlist[g_tl_dircount],dirpath); + + g_tl_dircount++; +} + +/***************************************************************************** + TL_BuildFileTree + +*****************************************************************************/ +int TL_BuildFileTree(char* dirpath, char*** dirlist) +{ + g_tl_dircount = 0; + g_tl_dirlist = NULL; + + _RecurseFileTree(dirpath,0); + + *dirlist = g_tl_dirlist; + return (g_tl_dircount); +} + +/***************************************************************************** + TL_FindFiles2 + +*****************************************************************************/ +int TL_FindFiles2(char* filemask, bool recurse, tlfile_t*** filelist) +{ + char dirpath[TL_MAXPATH]; + char pattern[TL_MAXPATH]; + char** dirlist; + tlfile_t*** templists; + tlfile_t** list; + int* numfiles; + int numoutfiles; + int count; + int numdirs; + int i; + int j; + int k; + + // get path only + strcpy(dirpath,filemask); + TL_StripFilename(dirpath); + + // get pattern only + TL_StripPath(filemask,pattern); + + numoutfiles = 0; + + if (recurse) + { + // get the tree + numdirs = TL_BuildFileTree(dirpath,&dirlist); + if (numdirs) + { + templists = (tlfile_t***)TL_Malloc(numdirs * sizeof(tlfile_t**)); + numfiles = (int*)TL_Malloc(numdirs * sizeof(int)); + + // iterate each directory found + for (i=0; i<numdirs; i++) + numfiles[i] = TL_GetFileList(dirlist[i],pattern,&templists[i]); + + // count all the files + numoutfiles = 0; + for (i=0; i<numdirs; i++) + numoutfiles += numfiles[i]; + + // allocate single list + if (numoutfiles) + { + *filelist = (tlfile_t**)TL_Malloc(numoutfiles*sizeof(tlfile_t*)); + + k = 0; + for (i=0; i<numdirs; i++) + { + count = numfiles[i]; + list = templists[i]; + for (j=0; j<count; j++,k++) + { + (*filelist)[k] = list[j]; + } + } + } + + // free the directory lists + for (i=0; i<numdirs; i++) + { + TL_Free(dirlist[i]); + + if (numfiles[i]) + TL_Free(templists[i]); + } + + TL_Free(dirlist); + TL_Free(templists); + TL_Free(numfiles); + } + } + else + { + numoutfiles = TL_GetFileList(dirpath,pattern,filelist); + } + + return (numoutfiles); +} + +/***************************************************************************** + TL_FreeFileList + +*****************************************************************************/ +void TL_FreeFileList(int count, tlfile_t** filelist) +{ + int i; + + for (i=0; i<count; i++) + { + TL_Free(filelist[i]->filename); + TL_Free(filelist[i]); + } + + if (count) + TL_Free(filelist); +} + +/***************************************************************************** + TL_CPUCount + +*****************************************************************************/ +int TL_CPUCount(void) +{ + int time; + + time = clock(); + + return (time); +} + +/***************************************************************************** + TL_CPUTime + +*****************************************************************************/ +double TL_CPUTime(int start, int stop) +{ + double duration; + + duration = (double)(stop - start)/CLOCKS_PER_SEC; + + return (duration); +} + +/***************************************************************************** + TL_CreatePath + +*****************************************************************************/ +void TL_CreatePath(const char* inPath) +{ + char* ptr; + char dirPath[TL_MAXPATH]; + + // prime and skip to first seperator + strcpy(dirPath, inPath); + ptr = strchr(dirPath, '\\'); + while (ptr) + { + ptr = strchr(ptr+1, '\\'); + if (ptr) + { + *ptr = '\0'; + mkdir(dirPath); + *ptr = '\\'; + } + } +} + +/***************************************************************************** + TL_Warning + +*****************************************************************************/ +void TL_Warning(const char* format, ...) +{ + char msg[4096]; + va_list argptr; + + if (g_tl_quiet) + return; + + va_start(argptr, format); + vsprintf(msg, format, argptr); + va_end(argptr); + + printf("WARNING: %s", msg); +} + +/***************************************************************************** + TL_printf + +*****************************************************************************/ +void TL_printf(const char* format, ...) +{ + char msg[4096]; + va_list argptr; + + if (g_tl_quiet) + return; + + va_start(argptr, format); + vsprintf(msg, format, argptr); + va_end(argptr); + + printf(msg); +} + +//----------------------------------------------------------------------------- +// TL_IsWildcardMatch +// +// See if a string matches a wildcard specification that uses * or ? +//----------------------------------------------------------------------------- +bool TL_IsWildcardMatch( const char *wildcardString, const char *stringToCheck, bool caseSensitive ) +{ + char wcChar; + char strChar; + + // use the starMatchesZero variable to determine whether an asterisk + // matches zero or more characters ( TRUE ) or one or more characters + // ( FALSE ) + bool starMatchesZero = true; + + while ( ( strChar = *stringToCheck ) && ( wcChar = *wildcardString ) ) + { + // we only want to advance the pointers if we successfully assigned + // both of our char variables, so we'll do it here rather than in the + // loop condition itself + *stringToCheck++; + *wildcardString++; + + // if this isn't a case-sensitive match, make both chars uppercase + // ( thanks to David John Fielder ( Konan ) at http://innuendo.ev.ca + // for pointing out an error here in the original code ) + if ( !caseSensitive ) + { + wcChar = toupper( wcChar ); + strChar = toupper( strChar ); + } + + // check the wcChar against our wildcard list + switch ( wcChar ) + { + // an asterisk matches zero or more characters + case '*' : + // do a recursive call against the rest of the string, + // until we've either found a match or the string has + // ended + if ( starMatchesZero ) + *stringToCheck--; + + while ( *stringToCheck ) + { + if ( TL_IsWildcardMatch( wildcardString, stringToCheck++, caseSensitive ) ) + return true; + } + + break; + + // a question mark matches any single character + case '?' : + break; + + // if we fell through, we want an exact match + default : + if ( wcChar != strChar ) + return false; + break; + } + } + + // if we have any asterisks left at the end of the wildcard string, we can + // advance past them if starMatchesZero is TRUE ( so "blah*" will match "blah" ) + while ( ( *wildcardString ) && ( starMatchesZero ) ) + { + if ( *wildcardString == '*' ) + wildcardString++; + else + break; + } + + // if we got to the end but there's still stuff left in either of our strings, + // return false; otherwise, we have a match + if ( ( *stringToCheck ) || ( *wildcardString ) ) + return false; + else + return true; +} + +//----------------------------------------------------------------------------- +// TL_CopyString +// +//----------------------------------------------------------------------------- +char *TL_CopyString( const char* pString ) +{ + int size = strlen( pString ) + 1; + char *pNewString = (char *)TL_Malloc( size ); + memcpy( pNewString, pString, size ); + + return pNewString; +} + diff --git a/utils/xbox/toollib/toollib.h b/utils/xbox/toollib/toollib.h new file mode 100644 index 0000000..c62886a --- /dev/null +++ b/utils/xbox/toollib/toollib.h @@ -0,0 +1,114 @@ +#ifndef _TOOLLIB_H_ +#define _TOOLLIB_H_ + +#include <ctype.h> +#include <stdlib.h> +#include <stdio.h> +#include <stdarg.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/utime.h> +#include <string.h> +#include <io.h> +#include <direct.h> +#include <process.h> +#include <dos.h> +#include <stdarg.h> +#include <conio.h> +#include <math.h> +#include <limits.h> +#include <malloc.h> +#include <errno.h> +#include <time.h> +#include <assert.h> +#include <share.h> + +#define TL_MAXPATH 128 +#define TL_MEMID 0x44434241 + +typedef unsigned char byte_t; +typedef unsigned int rgba_t; +typedef unsigned int abgr_t; +typedef unsigned char u8; +typedef signed char s8; +typedef unsigned short u16; +typedef signed short s16; +typedef unsigned long u32; +typedef signed long s32; + +typedef struct +{ + int id; + int size; +} tlmem_t; + +typedef struct +{ + char* filename; + time_t time_write; +} tlfile_t; + +#include "scriplib.h" + +#define TL_max(a,b) ((a) > (b) ? (a) : (b)) +#define TL_min(a,b) ((a) < (b) ? (a) : (b)) + +extern void TL_Setup(char* appname, int argc, char** argv); +extern void TL_End(bool showtime); +extern void TL_Error(char* error, ...); +extern int TL_CheckParm(char* check); +extern void TL_strncpyz(char* dst, char* src, int n); +extern void TL_strncatz(char* dst, char* src, int dstsize); +extern void* TL_Malloc(int size); +extern void* TL_Realloc(void* ptr, int newsize); +extern void TL_Free(void* ptr); +extern int TL_SafeOpenRead(const char* filename); +extern int TL_SafeOpenWrite(const char* filename); +extern void TL_SafeRead(int handle, void* buffer, long count); +extern void TL_SafeWrite(int handle, void* buffer, long count); +extern void TL_SafeClose(int handle, int touch); +extern long TL_LoadFile(const char* filename, void** bufferptr); +extern void TL_SaveFile(char* filename, void* buffer, long count); +extern void TL_TouchFile(char* filename); +extern long TL_FileLength(int handle); +extern void TL_StripPath(char* path, char* dest); +extern void TL_StripExtension(char* path); +extern void TL_StripFilename(char* path); +extern void TL_GetExtension(char* path, char* dest); +extern void TL_DefaultPath(char* path, char* basepath); +extern void TL_AddSeperatorToPath(char* inpath, char* outpath); +extern void TL_DefaultExtension(char* path, char* extension, bool bForce = false); +extern void TL_TempFilename(char* path); +extern int TL_AlignFile(int handle, int align); +extern int TL_GetByteOrder(void); +extern void TL_SetByteOrder(int flag); +extern long TL_LongSwap(long l); +extern short TL_ShortSwap(short s); +extern short TL_LittleShort(short l); +extern short TL_BigShort(short l); +extern long TL_LittleLong(long l); +extern long TL_BigLong(long l); +extern float TL_BigFloat(float f); +extern bool TL_Exists(const char* filename); +extern u32 TL_FileTime(char* filename); +extern void TL_ReplaceDosExtension(char* path, char* extension); +extern void TL_ReplaceExtension(const char* inPath, const char* extension, char* outPath); +extern int TL_CPUCount(void); +extern double TL_CPUTime(int start, int stop); +extern int TL_BuildFileTree(char* dirpath, char*** dirlist); +extern int TL_GetFileList(char* dirpath, char* pattern, tlfile_t*** filelist); +extern int TL_FindFiles(char* filemask, char*** filenames); +extern int TL_FindFiles2(char* filemask, bool recurse, tlfile_t*** filelist); +extern void TL_FreeFileList(int count, tlfile_t** filelist); +extern void TL_CreatePath(const char* inPath); +extern void TL_printf(const char* format, ...); +extern void TL_Warning(const char* format, ...); +extern bool TL_IsWildcardMatch( const char *wildcardString, const char *stringToCheck, bool caseSensitive ); +extern char *TL_CopyString( const char* pString ); +extern bool TL_Check(void* ptr); + +extern int g_argc; +extern char** g_argv; + +#endif diff --git a/utils/xbox/vxbdm/console.cpp b/utils/xbox/vxbdm/console.cpp new file mode 100644 index 0000000..8ff746a --- /dev/null +++ b/utils/xbox/vxbdm/console.cpp @@ -0,0 +1,763 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Xbox console link +// +//=====================================================================================// + +#include "xbox/xbox_console.h" +#include "xbox/xbox_vxconsole.h" +#include "tier0/threadtools.h" +#include "tier0/tslist.h" +#include "tier0/ICommandLine.h" +#include "tier0/memdbgon.h" + +// all redirecting funneled here, stop redirecting in this module only +#undef OutputDebugStringA + +#pragma comment( lib, "xbdm.lib" ) + +struct DebugString_t +{ + unsigned int color; + char *pString; +}; + +#define XBX_DBGCOMMANDPREFIX "XCMD" +#define XBX_DBGRESPONSEPREFIX "XACK" +#define XBX_DBGPRINTPREFIX "XPRT" +#define XBX_DBGCOLORPREFIX "XCLR" + +#define XBX_MAX_RCMDLENGTH 256 +#define XBX_MAX_MESSAGE 2048 + +CThreadFastMutex g_xbx_dbgChannelMutex; +CThreadFastMutex g_xbx_dbgCommandHandlerMutex; +static char g_xbx_dbgRemoteBuf[XBX_MAX_RCMDLENGTH]; +static HANDLE g_xbx_dbgValidEvent; +static HANDLE g_xbx_dbgCmdCompleteEvent; +bool g_xbx_bUseVXConsoleOutput = true; +bool g_xbx_bDoSyncOutput; +static ThreadHandle_t g_xbx_hDebugThread; +CTSQueue<DebugString_t> g_xbx_DebugStringQueue; +extern CInterlockedInt g_xbx_numProfileCounters; +extern unsigned int g_xbx_profileCounters[]; +extern char g_xbx_profileName[]; +int g_xbx_freeMemory; + +_inline bool XBX_NoXBDM() { return false; } + +static CXboxConsole XboxConsole; + +DLL_EXPORT IXboxConsole *GetConsoleInterface() +{ + return &XboxConsole; +} + +//----------------------------------------------------------------------------- +// Low level string output. +// Input string should be stack based, can get clobbered. +//----------------------------------------------------------------------------- +static void OutputStringToDevice( unsigned int color, char *pString, bool bRemoteValid ) +{ + if ( !bRemoteValid ) + { + // local debug only + OutputDebugStringA( pString ); + return; + } + + // remote debug valid + // non pure colors don't translate well - find closest pure hue + unsigned int bestColor = color; + int r = ( bestColor & 0xFF ); + int g = ( bestColor >> 8 ) & 0xFF; + int b = ( bestColor >> 16 ) & 0xFF; + if ( ( r && r != 255 ) || ( g && g != 255 ) || ( b && b != 255 ) ) + { + int r0, g0, b0; + unsigned int minDist = 0xFFFFFFFF; + for ( int i=0; i<8; i++ ) + { + r0 = g0 = b0 = 0; + if ( i&4 ) + r0 = 255; + if ( i&2 ) + g0 = 255; + if ( i&1 ) + b0 = 255; + unsigned int d = ( r-r0 )*( r-r0 ) + ( g-g0 )*( g-g0 ) + ( b-b0 )*( b-b0 ); + if ( minDist > d ) + { + minDist = d; + bestColor = XMAKECOLOR( r0, g0, b0 ); + } + } + } + + // create color string + char colorString[16]; + sprintf( colorString, XBX_DBGCOLORPREFIX "[%8.8x]", bestColor ); + + // chunk line out, for each cr + char strBuffer[XBX_MAX_RCMDLENGTH]; + char *pStart = pString; + char *pEnd = pStart + strlen( pStart ); + char *pNext; + while ( pStart < pEnd ) + { + pNext = strchr( pStart, '\n' ); + if ( !pNext ) + pNext = pEnd; + else + *pNext = '\0'; + + int length = _snprintf( strBuffer, XBX_MAX_RCMDLENGTH, "%s!%s%s", XBX_DBGPRINTPREFIX, colorString, pStart ); + if ( length == -1 ) + { + strBuffer[sizeof( strBuffer )-1] = '\0'; + } + // Send the string + DmSendNotificationString( strBuffer ); + + // advance past cr + pStart = pNext+1; + } +} + +//----------------------------------------------------------------------------- +// XBX_IsConsoleConnected +// +//----------------------------------------------------------------------------- +bool CXboxConsole::IsConsoleConnected() +{ + bool bConnected; + + if ( g_xbx_dbgValidEvent == NULL ) + { + // init was never called + return false; + } + + AUTO_LOCK_FM( g_xbx_dbgChannelMutex ); + + bConnected = ( WaitForSingleObject( g_xbx_dbgValidEvent, 0 ) == WAIT_OBJECT_0 ); + + return bConnected; +} + +//----------------------------------------------------------------------------- +// Output string to listening console. Queues output for slave thread. +// Needs to be lightweight. +//----------------------------------------------------------------------------- +void CXboxConsole::DebugString( unsigned int color, const char* pFormat, ... ) +{ + if ( XBX_NoXBDM() ) + return; + + va_list args; + char szStringBuffer[XBX_MAX_MESSAGE]; + int length; + + // resolve string + va_start( args, pFormat ); + length = _vsnprintf( szStringBuffer, sizeof( szStringBuffer ), pFormat, args ); + if ( length == -1 ) + { + szStringBuffer[sizeof( szStringBuffer ) - 1] = '\0'; + } + va_end( args ); + + if ( !g_xbx_bDoSyncOutput ) + { + // queue string for delayed output + DebugString_t debugString; + debugString.color = color; + debugString.pString = strdup( szStringBuffer ); + g_xbx_DebugStringQueue.PushItem( debugString ); + } + else + { + bool bRemoteValid = g_xbx_bUseVXConsoleOutput && XBX_IsConsoleConnected(); + OutputStringToDevice( color, szStringBuffer, bRemoteValid ); + } +} + +//----------------------------------------------------------------------------- +// Waits for debug queue to drain. +//----------------------------------------------------------------------------- +void CXboxConsole::FlushDebugOutput() +{ + while ( g_xbx_DebugStringQueue.Count() != 0 ) + { + Sleep( 1 ); + } +} + +//----------------------------------------------------------------------------- +// _xdbg_strlen +// +// Critical section safe. +//----------------------------------------------------------------------------- +int _xdbg_strlen( const CHAR* str ) +{ + const CHAR* strEnd = str; + + while( *strEnd ) + strEnd++; + + return strEnd - str; +} + +//----------------------------------------------------------------------------- +// _xdbg_tolower +// +// Critical section safe. +//----------------------------------------------------------------------------- +inline CHAR _xdbg_tolower( CHAR ch ) +{ + if( ch >= 'A' && ch <= 'Z' ) + return ch - ( 'A' - 'a' ); + else + return ch; +} + +//----------------------------------------------------------------------------- +// _xdbg_strnicmp +// +// Critical section safe. +//----------------------------------------------------------------------------- +BOOL _xdbg_strnicmp( const CHAR* str1, const CHAR* str2, int n ) +{ + while ( ( _xdbg_tolower( *str1 ) == _xdbg_tolower( *str2 ) ) && *str1 && n > 0 ) + { + --n; + ++str1; + ++str2; + } + return ( !n || _xdbg_tolower( *str1 ) == _xdbg_tolower( *str2 ) ); +} + +//----------------------------------------------------------------------------- +// _xdbg_strcpy +// +// Critical section safe. +//----------------------------------------------------------------------------- +VOID _xdbg_strcpy( CHAR* strDest, const CHAR* strSrc ) +{ + while ( ( *strDest++ = *strSrc++ ) != 0 ); +} + +//----------------------------------------------------------------------------- +// _xdbg_strcpyn +// +// Critical section safe. +//----------------------------------------------------------------------------- +VOID _xdbg_strcpyn( CHAR* strDest, const CHAR* strSrc, int numChars ) +{ + while ( numChars>0 && ( *strDest++ = *strSrc++ ) != 0 ) + numChars--; +} + +//----------------------------------------------------------------------------- +// _xdbg_gettoken +// +// Critical section safe. +//----------------------------------------------------------------------------- +void _xdbg_gettoken( CHAR** tokenStream, CHAR* token, int tokenSize ) +{ + int c; + int len; + CHAR* data; + + len = 0; + + // skip prefix whitespace + data = *tokenStream; + while ( ( c = *data ) <= ' ' ) + { + if ( !c ) + goto cleanUp; + data++; + } + + // parse a token + do + { + if ( len < tokenSize ) + token[len++] = c; + + data++; + c = *data; + } while ( c > ' ' ); + + if ( len >= tokenSize ) + len = 0; + +cleanUp: + token[len] = '\0'; + *tokenStream = data; +} + +//----------------------------------------------------------------------------- +// _xdbg_tokenize +// +// Critical section safe. +//----------------------------------------------------------------------------- +int _xdbg_tokenize( CHAR* tokenStream, CHAR** tokens, int maxTokens ) +{ + char token[64]; + + // tokenize stream into seperate tokens + int numTokens = 0; + while ( 1 ) + { + tokens[numTokens++] = tokenStream; + if ( numTokens >= maxTokens ) + break; + + _xdbg_gettoken( &tokenStream, token, sizeof( token ) ); + if ( !tokenStream[0] || !token[0] ) + break; + + *tokenStream = '\0'; + tokenStream++; + } + return ( numTokens ); +} + +//----------------------------------------------------------------------------- +// _xdbg_findtoken +// +// Critical section safe. Returns -1 if not found +//----------------------------------------------------------------------------- +int _xdbg_findtoken( CHAR** tokens, int numTokens, CHAR* token ) +{ + int i; + int len; + + len = _xdbg_strlen( token ); + for ( i=0; i<numTokens; i++ ) + { + if ( _xdbg_strnicmp( tokens[i], token, len ) ) + return i; + } + + // not found + return -1; +} + +//----------------------------------------------------------------------------- +// _DebugCommandHandler +// +//----------------------------------------------------------------------------- +HRESULT __stdcall _DebugCommandHandler( const CHAR* strCommand, CHAR* strResponse, DWORD dwResponseLen, PDM_CMDCONT pdmcc ) +{ + CHAR buff[256]; + CHAR* args[8]; + int numArgs; + + AUTO_LOCK_FM( g_xbx_dbgCommandHandlerMutex ); + + // skip over the command prefix and the exclamation mark + strCommand += _xdbg_strlen( XBX_DBGCOMMANDPREFIX ) + 1; + + if ( strCommand[0] == '\0' ) + { + // just a ping + goto cleanUp; + } + + // get command and optional arguments + _xdbg_strcpyn( buff, strCommand, sizeof( buff ) ); + numArgs = _xdbg_tokenize( buff, args, sizeof( args )/sizeof( CHAR* ) ); + + if ( _xdbg_strnicmp( args[0], "__connect__", 11 ) ) + { + if ( numArgs > 1 && atoi( args[1] ) == VXCONSOLE_PROTOCOL_VERSION ) + { + // initial connect - respond that we're connected + _xdbg_strcpyn( strResponse, XBX_DBGRESPONSEPREFIX "Connected To Application.", dwResponseLen ); + SetEvent( g_xbx_dbgValidEvent ); + + // notify convar system to send its commands + // allows vxconsole to re-connect during game + _xdbg_strcpy( g_xbx_dbgRemoteBuf, "getcvars" ); + XBX_QueueEvent( XEV_REMOTECMD, ( int )g_xbx_dbgRemoteBuf, 0, 0 ); + } + else + { + _xdbg_strcpyn( strResponse, XBX_DBGRESPONSEPREFIX "Rejecting Connection: Wrong Protocol Version.", dwResponseLen ); + } + goto cleanUp; + } + + if ( _xdbg_strnicmp( args[0], "__disconnect__", 14 ) ) + { + // respond that we're disconnected + _xdbg_strcpyn( strResponse, XBX_DBGRESPONSEPREFIX "Disconnected.", dwResponseLen ); + ResetEvent( g_xbx_dbgValidEvent ); + goto cleanUp; + } + + if ( _xdbg_strnicmp( args[0], "__complete__", 12 ) ) + { + // remote server has finished command - respond to acknowledge + _xdbg_strcpyn( strResponse, XBX_DBGRESPONSEPREFIX "OK", dwResponseLen ); + + // set the complete event - allows expected synchronous calling mechanism + SetEvent( g_xbx_dbgCmdCompleteEvent ); + goto cleanUp; + } + + if ( _xdbg_strnicmp( args[0], "__memory__", 10 ) ) + { + // get a current stat of available memory + MEMORYSTATUS stat; + GlobalMemoryStatus( &stat ); + g_xbx_freeMemory = stat.dwAvailPhys; + + if ( _xdbg_findtoken( args, numArgs, "quiet" ) > 0 ) + { + _xdbg_strcpyn( strResponse, XBX_DBGRESPONSEPREFIX "OK", dwResponseLen ); + } + else + { + // 32 MB is reserved and fixed by OS, so not reporting + _snprintf( strResponse, dwResponseLen, XBX_DBGRESPONSEPREFIX "Available: %.2f MB, Used: %.2f MB, Free: %.2f MB", + stat.dwTotalPhys/( 1024.0f*1024.0f ) - 32.0f, + ( stat.dwTotalPhys - stat.dwAvailPhys )/( 1024.0f*1024.0f ) - 32.0f, + stat.dwAvailPhys/( 1024.0f*1024.0f ) ); + } + goto cleanUp; + } + + if ( g_xbx_dbgRemoteBuf[0] ) + { + // previous command still pending + _xdbg_strcpyn( strResponse, XBX_DBGRESPONSEPREFIX "Cannot execute: Previous command still pending", dwResponseLen ); + } + else + { + // add the command to the event queue to be processed by main app + _xdbg_strcpy( g_xbx_dbgRemoteBuf, strCommand ); + XBX_QueueEvent( XEV_REMOTECMD, ( int )g_xbx_dbgRemoteBuf, 0, 0 ); + _xdbg_strcpyn( strResponse, XBX_DBGRESPONSEPREFIX "OK", dwResponseLen ); + } + +cleanUp: + return XBDM_NOERR; +} + +//----------------------------------------------------------------------------- +// XBX_SendRemoteCommand +// +//----------------------------------------------------------------------------- +void CXboxConsole::SendRemoteCommand( const char *pCommand, bool async ) +{ + char cmdString[XBX_MAX_RCMDLENGTH]; + + if ( XBX_NoXBDM() || !IsConsoleConnected() ) + return; + + AUTO_LOCK_FM( g_xbx_dbgChannelMutex ); + + _snprintf( cmdString, sizeof( cmdString ), "%s!%s", XBX_DBGCOMMANDPREFIX, pCommand ); + HRESULT hr = DmSendNotificationString( cmdString ); + if ( FAILED( hr ) ) + { + XBX_Error( "XBX_SendRemoteCommand: failed on %s", cmdString ); + } + + // wait for command completion + if ( !async ) + { + DWORD timeout; + if ( !strnicmp( pCommand, "Assert()", 8 ) ) + { + // the assert is waiting for user to make selection + timeout = INFINITE; + } + else + { + // no vxconsole operation should take this long + timeout = 15000; + } + + if ( WaitForSingleObject( g_xbx_dbgCmdCompleteEvent, timeout ) == WAIT_TIMEOUT ) + { + // we have no choice but to dump core + DmCrashDump( false ); + } + } +} + +//----------------------------------------------------------------------------- +// Handle delayed VXConsole transactions +// +//----------------------------------------------------------------------------- +static unsigned _DebugThreadFunc( void *pParam ) +{ + while ( 1 ) + { + Sleep( 10 ); + + if ( !g_xbx_DebugStringQueue.Count() && !g_xbx_numProfileCounters && !g_xbx_freeMemory ) + { + continue; + } + + if ( g_xbx_numProfileCounters ) + { + // build and send asynchronously + char dbgCommand[XBX_MAX_RCMDLENGTH]; + _snprintf( dbgCommand, sizeof( dbgCommand ), "SetProfileData() %s 0x%8.8x", g_xbx_profileName, g_xbx_profileCounters ); + XBX_SendRemoteCommand( dbgCommand, true ); + + // mark as sent + g_xbx_numProfileCounters = 0; + } + + if ( g_xbx_freeMemory ) + { + // build and send asynchronously + char dbgCommand[XBX_MAX_RCMDLENGTH]; + _snprintf( dbgCommand, sizeof( dbgCommand ), "FreeMemory() 0x%8.8x", g_xbx_freeMemory ); + XBX_SendRemoteCommand( dbgCommand, true ); + + // mark as sent + g_xbx_freeMemory = 0; + } + + bool bRemoteValid = g_xbx_bUseVXConsoleOutput && XBX_IsConsoleConnected(); + while ( 1 ) + { + DebugString_t debugString; + if ( !g_xbx_DebugStringQueue.PopItem( &debugString ) ) + { + break; + } + + OutputStringToDevice( debugString.color, debugString.pString, bRemoteValid ); + free( debugString.pString ); + } + } + + return 0; +} + +//----------------------------------------------------------------------------- +// XBX_InitConsoleMonitor +// +//----------------------------------------------------------------------------- +void CXboxConsole::InitConsoleMonitor( bool bWaitForConnect ) +{ + if ( XBX_NoXBDM() ) + return; + + // create our events + g_xbx_dbgValidEvent = CreateEvent( XBOX_DONTCARE, TRUE, FALSE, NULL ); + g_xbx_dbgCmdCompleteEvent = CreateEvent( XBOX_DONTCARE, FALSE, FALSE, NULL ); + + // register our command handler with the debug monitor + HRESULT hr = DmRegisterCommandProcessor( XBX_DBGCOMMANDPREFIX, _DebugCommandHandler ); + if ( FAILED( hr ) ) + { + XBX_Error( "XBX_InitConsoleMonitor: failed to register command processor" ); + } + + // user can have output bypass slave thread + g_xbx_bDoSyncOutput = CommandLine()->FindParm( "-syncoutput" ) != 0; + + // create a slave thread to do delayed VXConsole transactions + ThreadId_t threadID; + g_xbx_hDebugThread = CreateSimpleThread( _DebugThreadFunc, NULL, &threadID, 16*1024 ); + ThreadSetDebugName( threadID, "DebugThread" ); + ThreadSetAffinity( g_xbx_hDebugThread, XBOX_PROCESSOR_5 ); + + if ( bWaitForConnect ) + { + XBX_DebugString( XBX_CLR_DEFAULT, "Waiting For VXConsole Connection...\n" ); + WaitForSingleObject( g_xbx_dbgValidEvent, INFINITE ); + } +} + +//----------------------------------------------------------------------------- +// Sends a disconnect signal to possibly attached VXConsole. +//----------------------------------------------------------------------------- +void CXboxConsole::DisconnectConsoleMonitor() +{ + if ( XBX_NoXBDM() ) + return; + + // caller is trying to safely stop vxconsole traffic, disconnect must be synchronous + XBX_SendRemoteCommand( "Disconnect()", false ); +} + +bool CXboxConsole::GetXboxName( char *pName, unsigned *pLength ) +{ + return ( DmGetXboxName( pName, (DWORD *)pLength ) == XBDM_NOERR ); +} + +void CXboxConsole::CrashDump( bool b ) +{ + DmCrashDump(b); +} + +//----------------------------------------------------------------------------- +// Walk to a specific module and dump size info +//----------------------------------------------------------------------------- +int CXboxConsole::DumpModuleSize( const char *pName ) +{ + HRESULT error; + PDM_WALK_MODULES pWalkMod = NULL; + DMN_MODLOAD modLoad; + int size = 0; + + // iterate and find match + do + { + error = DmWalkLoadedModules( &pWalkMod, &modLoad ); + if ( XBDM_NOERR == error && !stricmp( modLoad.Name, pName ) ) + { + Msg( "0x%8.8x, %5.2f MB, %s\n", modLoad.BaseAddress, modLoad.Size/( 1024.0f*1024.0f ), modLoad.Name ); + size = modLoad.Size; + error = XBDM_ENDOFLIST; + } + } + while ( XBDM_NOERR == error ); + DmCloseLoadedModules( pWalkMod ); + + if ( error != XBDM_ENDOFLIST ) + { + Warning( "DmWalkLoadedModules() failed.\n" ); + } + + return size; +} + +//----------------------------------------------------------------------------- +// 360 spew sizes of dll modules +//----------------------------------------------------------------------------- +char const* HACK_stristr( char const* pStr, char const* pSearch ) // hack because moved code from above vstdlib +{ + AssertValidStringPtr(pStr); + AssertValidStringPtr(pSearch); + + if (!pStr || !pSearch) + return 0; + + char const* pLetter = pStr; + + // Check the entire string + while (*pLetter != 0) + { + // Skip over non-matches + if (tolower((unsigned char)*pLetter) == tolower((unsigned char)*pSearch)) + { + // Check for match + char const* pMatch = pLetter + 1; + char const* pTest = pSearch + 1; + while (*pTest != 0) + { + // We've run off the end; don't bother. + if (*pMatch == 0) + return 0; + + if (tolower((unsigned char)*pMatch) != tolower((unsigned char)*pTest)) + break; + + ++pMatch; + ++pTest; + } + + // Found a match! + if (*pTest == 0) + return pLetter; + } + + ++pLetter; + } + + return 0; +} + +void CXboxConsole::DumpDllInfo( const char *pBasePath ) +{ + // Directories containing dlls + static char *dllDirs[] = + { + "bin", + "hl2\\bin", + "tf\\bin", + "portal\\bin", + "episodic\\bin" + }; + + char binPath[MAX_PATH]; + char dllPath[MAX_PATH]; + char searchPath[MAX_PATH]; + + HMODULE hModule; + WIN32_FIND_DATA wfd; + HANDLE hFind; + + Msg( "Dumping Module Sizes...\n" ); + + for ( int i = 0; i < ARRAYSIZE( dllDirs ); ++i ) + { + int totalSize = 0; + + _snprintf( binPath, sizeof( binPath ), "%s\\%s", pBasePath, dllDirs[i] ); + _snprintf( searchPath, sizeof( binPath ), "%s\\*.dll", binPath ); + + // show the directory we're searching + Msg( "\nDirectory: %s\n\n", binPath ); + + // Start the find and check for failure. + hFind = FindFirstFile( searchPath, &wfd ); + if ( INVALID_HANDLE_VALUE == hFind ) + { + Warning( "No Files Found.\n" ); + } + else + { + // Load and unload each dll individually. + do + { + if ( !HACK_stristr( wfd.cFileName, "_360.dll" ) ) + { + // exclude explicit pc dlls + // FindFirstFile does not support a spec mask of *_360.dll on the Xbox HDD + continue; + } + + _snprintf( dllPath, sizeof( dllPath ), "%s\\%s", binPath, wfd.cFileName ); + hModule = LoadLibrary( dllPath ); + if ( hModule ) + { + totalSize += DumpModuleSize( wfd.cFileName ); + FreeLibrary( hModule ); + } + else + { + Warning( "Failed to load: %s\n", dllPath ); + } + } + while( FindNextFile( hFind, &wfd ) ); + + FindClose( hFind ); + + Msg( "Total Size: %.2f MB\n", totalSize/( 1024.0f*1024.0f ) ); + } + } +} + +void CXboxConsole::OutputDebugString( const char *p ) +{ + ::OutputDebugStringA( p ); +} + +bool CXboxConsole::IsDebuggerPresent() +{ + return ( DmIsDebuggerPresent() != 0 ); +} diff --git a/utils/xbox/vxbdm/rcommands.cpp b/utils/xbox/vxbdm/rcommands.cpp new file mode 100644 index 0000000..83b9cea --- /dev/null +++ b/utils/xbox/vxbdm/rcommands.cpp @@ -0,0 +1,320 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Xbox Remote Commands +// +//=====================================================================================// + +#include "xbox/xbox_console.h" +#include "xbox/xbox_vxconsole.h" +#include "tier0/tslist.h" +#include "tier0/memdbgon.h" + +CInterlockedInt g_xbx_numProfileCounters; +unsigned int g_xbx_profileCounters[XBX_MAX_PROFILE_COUNTERS]; +char g_xbx_profileName[32]; + +//----------------------------------------------------------------------------- +// XBX_rSetProfileAttributes +// +// Expose profile counters attributes to the console. +//----------------------------------------------------------------------------- +int CXboxConsole::SetProfileAttributes( const char *pProfileName, int numCounters, const char *names[], unsigned int colors[] ) +{ + char dbgCommand[XBX_MAX_RCMDLENGTH]; + int retVal; + xrProfile_t* profileList; + + if ( numCounters > XBX_MAX_PROFILE_COUNTERS ) + { + numCounters = XBX_MAX_PROFILE_COUNTERS; + } + + profileList = new xrProfile_t[numCounters]; + memset( profileList, 0, numCounters*sizeof( xrProfile_t ) ); + + for ( int i=0; i<numCounters; i++ ) + { + strncpy( profileList[i].labelString, names[i], sizeof( profileList[i].labelString ) ); + profileList[i].labelString[sizeof( profileList[i].labelString ) - 1] = '\0'; + + profileList[i].color = colors[i]; + } + + _snprintf( dbgCommand, sizeof( dbgCommand ), "SetProfile() %s 0x%8.8x 0x%8.8x 0x%8.8x", pProfileName, numCounters, profileList, &retVal ); + XBX_SendRemoteCommand( dbgCommand, false ); + + delete[] profileList; + + return ( retVal ); +} + +//----------------------------------------------------------------------------- +// XBX_rSetProfileData +// +// Expose profile counters to the console. Expected to be called once per game frame. +//----------------------------------------------------------------------------- +void CXboxConsole::SetProfileData( const char *pProfileName, int numCounters, unsigned int *pCounters ) +{ + static unsigned int lastTime = 0; + unsigned int time; + + // not faster than 10Hz + time = GetTickCount(); + if ( time - lastTime < 100 ) + { + return; + } + + if ( g_xbx_numProfileCounters == 0 ) + { + _snprintf( g_xbx_profileName, sizeof( g_xbx_profileName ), pProfileName ); + + if ( numCounters > XBX_MAX_PROFILE_COUNTERS ) + { + numCounters = XBX_MAX_PROFILE_COUNTERS; + } + memcpy( g_xbx_profileCounters, pCounters, numCounters * sizeof( unsigned int ) ); + + // mark for sending + g_xbx_numProfileCounters = numCounters; + + lastTime = time; + } +} + +//----------------------------------------------------------------------------- +// XBX_rMemDump +// +// Send signal to remote console to read mempry dump in specified filename. +//----------------------------------------------------------------------------- +int CXboxConsole::MemDump( const char *pDumpFileName ) +{ + char dbgCommand[XBX_MAX_RCMDLENGTH]; + + _snprintf( dbgCommand, sizeof( dbgCommand ), "MemDump() %s", pDumpFileName ); + XBX_SendRemoteCommand( dbgCommand, true ); + + return 0; +} + +//----------------------------------------------------------------------------- +// XBX_rTimeStampLog +// +// Send time stamp to remote console +//----------------------------------------------------------------------------- +int CXboxConsole::TimeStampLog( float time, const char *pString ) +{ + char dbgCommand[XBX_MAX_RCMDLENGTH]; + int retVal; + xrTimeStamp_t timeStamp; + MEMORYSTATUS stat; + static int lastMemoryStamp = 0; + static float lastTimeStamp = 0; + + // get current available memory + GlobalMemoryStatus( &stat ); + + if ( !lastTimeStamp || time < lastTimeStamp ) + { + // first entry or restart, reset stamps + lastMemoryStamp = stat.dwAvailPhys; + lastTimeStamp = time; + } + + timeStamp.time = time; + timeStamp.deltaTime = time - lastTimeStamp; + timeStamp.memory = stat.dwAvailPhys; + timeStamp.deltaMemory = stat.dwAvailPhys - lastMemoryStamp; + + strncpy( timeStamp.messageString, pString, sizeof( timeStamp.messageString ) ); + timeStamp.messageString[sizeof( timeStamp.messageString ) - 1] = '\0'; + + _snprintf( dbgCommand, sizeof( dbgCommand ), "TimeStampLog() 0x%8.8x 0x%8.8x", &timeStamp, &retVal ); + XBX_SendRemoteCommand( dbgCommand, false ); + + lastTimeStamp = time; + lastMemoryStamp = stat.dwAvailPhys; + + return retVal; +} + +//----------------------------------------------------------------------------- +// XBX_rMaterialList +// +// Send material list to remote console +//----------------------------------------------------------------------------- +int CXboxConsole::MaterialList( int nMaterials, const xMaterialList_t* pXMaterialList ) +{ + char dbgCommand[XBX_MAX_RCMDLENGTH]; + int retVal; + xrMaterial_t* pRemoteList; + + pRemoteList = new xrMaterial_t[nMaterials]; + memset( pRemoteList, 0, nMaterials*sizeof( xrMaterial_t ) ); + + for ( int i=0; i<nMaterials; i++ ) + { + strncpy( pRemoteList[i].nameString, pXMaterialList[i].pName, sizeof( pRemoteList[i].nameString ) ); + pRemoteList[i].nameString[sizeof( pRemoteList[i].nameString ) - 1] = '\0'; + + strncpy( pRemoteList[i].shaderString, pXMaterialList[i].pShaderName, sizeof( pRemoteList[i].shaderString ) ); + pRemoteList[i].shaderString[sizeof( pRemoteList[i].shaderString ) - 1] = '\0'; + + pRemoteList[i].refCount = pXMaterialList[i].refCount; + } + + _snprintf( dbgCommand, sizeof( dbgCommand ), "MaterialList() 0x%8.8x 0x%8.8x 0x%8.8x", nMaterials, pRemoteList, &retVal ); + XBX_SendRemoteCommand( dbgCommand, false ); + + delete [] pRemoteList; + + return retVal; +} + +//----------------------------------------------------------------------------- +// XBX_rTextureList +// +// Send texture list to remote console +//----------------------------------------------------------------------------- +int CXboxConsole::TextureList( int nTextures, const xTextureList_t* pXTextureList ) +{ + char dbgCommand[XBX_MAX_RCMDLENGTH]; + int retVal; + xrTexture_t* pRemoteList; + + pRemoteList = new xrTexture_t[nTextures]; + memset( pRemoteList, 0, nTextures*sizeof( xrTexture_t ) ); + + for ( int i=0; i<nTextures; i++ ) + { + strncpy( pRemoteList[i].nameString, pXTextureList[i].pName, sizeof( pRemoteList[i].nameString ) ); + pRemoteList[i].nameString[sizeof( pRemoteList[i].nameString ) - 1] = '\0'; + + strncpy( pRemoteList[i].groupString, pXTextureList[i].pGroupName, sizeof( pRemoteList[i].groupString ) ); + pRemoteList[i].groupString[sizeof( pRemoteList[i].groupString ) - 1] = '\0'; + + strncpy( pRemoteList[i].formatString, pXTextureList[i].pFormatName, sizeof( pRemoteList[i].formatString ) ); + pRemoteList[i].formatString[sizeof( pRemoteList[i].formatString ) - 1] = '\0'; + + pRemoteList[i].size = pXTextureList[i].size; + pRemoteList[i].width = pXTextureList[i].width; + pRemoteList[i].height = pXTextureList[i].height; + pRemoteList[i].depth = pXTextureList[i].depth; + pRemoteList[i].numLevels = pXTextureList[i].numLevels; + pRemoteList[i].binds = pXTextureList[i].binds; + pRemoteList[i].refCount = pXTextureList[i].refCount; + pRemoteList[i].sRGB = pXTextureList[i].sRGB; + pRemoteList[i].edram = pXTextureList[i].edram; + pRemoteList[i].procedural = pXTextureList[i].procedural; + pRemoteList[i].fallback = pXTextureList[i].fallback; + pRemoteList[i].final = pXTextureList[i].final; + pRemoteList[i].failed = pXTextureList[i].failed; + } + + _snprintf( dbgCommand, sizeof( dbgCommand ), "TextureList() 0x%8.8x 0x%8.8x 0x%8.8x", nTextures, pRemoteList, &retVal ); + XBX_SendRemoteCommand( dbgCommand, false ); + + delete [] pRemoteList; + + return ( retVal ); +} + +//----------------------------------------------------------------------------- +// XBX_rSoundList +// +// Send sound list to remote console +//----------------------------------------------------------------------------- +int CXboxConsole::SoundList( int nSounds, const xSoundList_t* pXSoundList ) +{ + char dbgCommand[XBX_MAX_RCMDLENGTH]; + int retVal; + xrSound_t* pRemoteList; + + pRemoteList = new xrSound_t[nSounds]; + memset( pRemoteList, 0, nSounds*sizeof( xrSound_t ) ); + + for ( int i=0; i<nSounds; i++ ) + { + strncpy( pRemoteList[i].nameString, pXSoundList[i].name, sizeof( pRemoteList[i].nameString ) ); + pRemoteList[i].nameString[sizeof( pRemoteList[i].nameString ) - 1] = '\0'; + + strncpy( pRemoteList[i].formatString, pXSoundList[i].formatName, sizeof( pRemoteList[i].formatString ) ); + pRemoteList[i].formatString[sizeof( pRemoteList[i].formatString ) - 1] = '\0'; + + pRemoteList[i].rate = pXSoundList[i].rate; + pRemoteList[i].bits = pXSoundList[i].bits; + pRemoteList[i].channels = pXSoundList[i].channels; + pRemoteList[i].looped = pXSoundList[i].looped; + pRemoteList[i].dataSize = pXSoundList[i].dataSize; + pRemoteList[i].numSamples = pXSoundList[i].numSamples; + pRemoteList[i].streamed = pXSoundList[i].streamed; + } + + _snprintf( dbgCommand, sizeof( dbgCommand ), "SoundList() 0x%8.8x 0x%8.8x 0x%8.8x", nSounds, pRemoteList, &retVal ); + XBX_SendRemoteCommand( dbgCommand, false ); + + delete [] pRemoteList; + + return ( retVal ); +} + +//----------------------------------------------------------------------------- +// XBX_rMapInfo +// +// Send signal to remote console with various info +//----------------------------------------------------------------------------- +int CXboxConsole::MapInfo( const xMapInfo_t *pXMapInfo ) +{ + char dbgCommand[XBX_MAX_RCMDLENGTH]; + int retVal; + xrMapInfo_t xrMapInfo; + + memcpy( xrMapInfo.position, pXMapInfo->position, 3 * sizeof( float ) ); + memcpy( xrMapInfo.angle, pXMapInfo->angle, 3 * sizeof( float ) ); + + strncpy( xrMapInfo.mapPath, pXMapInfo->mapPath, sizeof( xrMapInfo.mapPath ) ); + xrMapInfo.mapPath[sizeof( xrMapInfo.mapPath ) - 1] = '\0'; + + strncpy( xrMapInfo.savePath, pXMapInfo->savePath, sizeof( xrMapInfo.savePath ) ); + xrMapInfo.savePath[sizeof( xrMapInfo.savePath ) - 1] = '\0'; + + xrMapInfo.build = pXMapInfo->build; + xrMapInfo.skill = pXMapInfo->skill; + + _snprintf( dbgCommand, sizeof( dbgCommand ), "MapInfo() 0x%8.8x 0x%8.8x", &xrMapInfo, &retVal ); + XBX_SendRemoteCommand( dbgCommand, false ); + + return retVal; +} + +//----------------------------------------------------------------------------- +// XBX_rAddCommands +// +// Expose commands to remote console +//----------------------------------------------------------------------------- +int CXboxConsole::AddCommands( int numCommands, const char* commands[], const char* help[] ) +{ + char dbgCommand[XBX_MAX_RCMDLENGTH]; + int retVal; + xrCommand_t* cmdList; + + cmdList = new xrCommand_t[numCommands]; + memset( cmdList, 0, numCommands*sizeof( xrCommand_t ) ); + + for ( int i=0; i<numCommands; i++ ) + { + strncpy( cmdList[i].nameString, commands[i], sizeof( cmdList[i].nameString ) ); + cmdList[i].nameString[sizeof( cmdList[i].nameString ) - 1] = '\0'; + + strncpy( cmdList[i].helpString, help[i], sizeof( cmdList[i].helpString ) ); + cmdList[i].helpString[sizeof( cmdList[i].helpString ) - 1] = '\0'; + } + + _snprintf( dbgCommand, sizeof( dbgCommand ), "AddCommands() 0x%8.8x 0x%8.8x 0x%8.8x", numCommands, cmdList, &retVal ); + XBX_SendRemoteCommand( dbgCommand, false ); + + delete [] cmdList; + + return ( retVal ); +} + diff --git a/utils/xbox/vxbdm/vxbdm.vpc b/utils/xbox/vxbdm/vxbdm.vpc new file mode 100644 index 0000000..65c74e7 --- /dev/null +++ b/utils/xbox/vxbdm/vxbdm.vpc @@ -0,0 +1,37 @@ +//----------------------------------------------------------------------------- +// vxbdm.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" + +$Include "$SRCDIR\vpc_scripts\source_dll_x360_base.vpc" + +$Configuration +{ + $Xbox360ImageConversion + { + // General + $ExportByName "Yes" + } +} + +$Project +{ + $Folder "Link Libraries" + { + -$File "$SRCDIR\lib\public\tier1_360.lib" + -$File "$SRCDIR\lib\public\vstdlib_360.lib" + } +} + +$Project "vxbdm" +{ + $Folder "Source Files" + { + $file "console.cpp" + $File "rcommands.cpp" + } +} diff --git a/utils/xbox/vxbdm/xbox/xbox.def b/utils/xbox/vxbdm/xbox/xbox.def new file mode 100644 index 0000000..3c64bf8 --- /dev/null +++ b/utils/xbox/vxbdm/xbox/xbox.def @@ -0,0 +1,3 @@ +LIBRARY vxbdm_360.dll +EXPORTS + GetConsoleInterface @1
\ No newline at end of file diff --git a/utils/xbox/vxconsole/assert_dialog.cpp b/utils/xbox/vxconsole/assert_dialog.cpp new file mode 100644 index 0000000..9abcd35 --- /dev/null +++ b/utils/xbox/vxconsole/assert_dialog.cpp @@ -0,0 +1,155 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// ASSERT_DIALOG.CPP +// +// Handle Remote Assert(). +//=====================================================================================// +#include "vxconsole.h" + +AssertAction_t g_AssertAction = ASSERT_ACTION_BREAK; +static const char * g_AssertInfo = "Assert Info Not Available."; +bool g_AssertDialogActive = false; + +//----------------------------------------------------------------------------- +// AssertDialogProc +// +//----------------------------------------------------------------------------- +int CALLBACK AssertDialogProc( HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam ) +{ + switch( uMsg ) + { + case WM_INITDIALOG: + { + SetWindowText( hDlg, "Xbox 360 Assert!" ); + SetDlgItemText( hDlg, IDC_FILENAME_CONTROL, g_AssertInfo ); + + // Center the dialog. + RECT rcDlg, rcDesktop; + GetWindowRect( hDlg, &rcDlg ); + GetWindowRect( GetDesktopWindow(), &rcDesktop ); + SetWindowPos( + hDlg, + HWND_TOP, + ((rcDesktop.right-rcDesktop.left) - (rcDlg.right-rcDlg.left)) / 2, + ((rcDesktop.bottom-rcDesktop.top) - (rcDlg.bottom-rcDlg.top)) / 2, + 0, + 0, + SWP_NOSIZE ); + } + return true; + + case WM_COMMAND: + { + switch( LOWORD( wParam ) ) + { + // Ignore Asserts in this file from now on. + case IDC_IGNORE_FILE: + { + g_AssertAction = ASSERT_ACTION_IGNORE_FILE; + EndDialog( hDlg, 0 ); + return true; + } + + // Ignore this Assert once. + case IDC_IGNORE_THIS: + { + g_AssertAction = ASSERT_ACTION_IGNORE_THIS; + EndDialog( hDlg, 0 ); + return true; + } + + // Always ignore this Assert. + case IDC_IGNORE_ALWAYS: + { + g_AssertAction = ASSERT_ACTION_IGNORE_ALWAYS; + EndDialog( hDlg, 0 ); + return true; + } + + // Ignore all Asserts from now on. + case IDC_IGNORE_ALL: + { + g_AssertAction = ASSERT_ACTION_IGNORE_ALL; + EndDialog( hDlg, 0 ); + return true; + } + + case IDC_BREAK: + { + g_AssertAction = ASSERT_ACTION_BREAK; + EndDialog( hDlg, 0 ); + return true; + } + } + + case WM_KEYDOWN: + { + // Escape? + if ( wParam == 2 ) + { + // Ignore this Assert. + g_AssertAction = ASSERT_ACTION_IGNORE_THIS; + EndDialog( hDlg, 0 ); + return true; + } + } + } + return true; + } + + return FALSE; +} + +//----------------------------------------------------------------------------- +// rc_Assert +// +// Sent from application on hitting an Assert +//----------------------------------------------------------------------------- +int rc_Assert( char* commandPtr ) +{ + char* cmdToken; + int retAddr; + int errCode = -1; + + // Flash the taskbar icon (otherwise users may not realise the app has stalled on an Assert, esp. during loading) + FLASHWINFO flashWInfo = { sizeof(FLASHWINFO), g_hDlgMain, FLASHW_ALL|FLASHW_TIMERNOFG, 0, 1000 }; + FlashWindowEx( &flashWInfo ); + + // get retAddr + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + if (1 != sscanf( cmdToken, "%x", &retAddr )) + goto cleanUp; + + // skip whitespace + while ( commandPtr[0] == ' ' ) + { + commandPtr++; + } + + // Display file/line/expression info from the message in the Assert dialog + // (convert '\t' to '\n'; way simpler than tokenizing a general assert expression) + g_AssertInfo = commandPtr; + char *tab = commandPtr; + while( ( tab = strchr( tab, '\t' ) ) != NULL ) + { + tab[0] = '\n'; + } + + // Open the Assert dialog, to determine the desired action + g_AssertAction = ASSERT_ACTION_BREAK; + g_AssertDialogActive = true; + DialogBox( g_hInstance, MAKEINTRESOURCE( IDD_ASSERT_DIALOG ), g_hDlgMain, ( DLGPROC )AssertDialogProc ); + g_AssertDialogActive = false; + + // Write the (endian-converted) result directly back into the application's memory: + int xboxRetVal = BigDWord( g_AssertAction ); + DmSetMemory( ( void* )retAddr, sizeof( int ), &xboxRetVal, NULL ); + + // success + errCode = 0; + +cleanUp: + return errCode; +} diff --git a/utils/xbox/vxconsole/assert_dialog.rc b/utils/xbox/vxconsole/assert_dialog.rc new file mode 100644 index 0000000..0d19bd2 --- /dev/null +++ b/utils/xbox/vxconsole/assert_dialog.rc @@ -0,0 +1,107 @@ +// Microsoft Visual C++ generated resource script. +// +#include "assert_resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "afxres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "assert_resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_ASSERT_DIALOG DIALOGEX 0, 0, 268, 158 +STYLE DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Assert" +FONT 8, "MS Sans Serif", 0, 0, 0x0 +BEGIN + LTEXT "c:/hl2/src/blah.cpp",IDC_FILENAME_CONTROL,7,7,246,34 + DEFPUSHBUTTON "&Break in Debugger",IDC_BREAK,7,49,98,14 + PUSHBUTTON "&Ignore This Assert",IDC_IGNORE_THIS,7,66,98,14 + EDITTEXT IDC_IGNORE_NUMTIMES,110,66,24,14,ES_AUTOHSCROLL | ES_NUMBER | WS_DISABLED + LTEXT "time(s).",IDC_NOID,138,69,23,8 + PUSHBUTTON "Always Ignore &This Assert",IDC_IGNORE_ALWAYS,7,83,98,14 + PUSHBUTTON "Ignore &Nearby Asserts",IDC_IGNORE_NEARBY,7,100,98,14,WS_DISABLED + LTEXT "within",IDC_NOID,109,103,19,8 + EDITTEXT IDC_IGNORE_NUMLINES,131,100,40,14,ES_AUTOHSCROLL | ES_NUMBER | WS_DISABLED + LTEXT "lines.",IDC_NOID,175,103,17,8 + PUSHBUTTON "Ignore Asserts in This &File",IDC_IGNORE_FILE,7,117,98,14 + PUSHBUTTON "Ignore &All Asserts",IDC_IGNORE_ALL,7,134,98,14 +END + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN + IDD_ASSERT_DIALOG, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 261 + TOPMARGIN, 7 + BOTTOMMARGIN, 151 + END +END +#endif // APSTUDIO_INVOKED + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/utils/xbox/vxconsole/assert_resource.h b/utils/xbox/vxconsole/assert_resource.h new file mode 100644 index 0000000..b23c645 --- /dev/null +++ b/utils/xbox/vxconsole/assert_resource.h @@ -0,0 +1,29 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by assert_dialog.rc +// +#define IDD_ASSERT_DIALOG 101 +#define IDC_FILENAME_CONTROL 1000 +#define IDC_LINE_CONTROL 1001 +#define IDC_IGNORE_FILE 1002 +#define IDC_IGNORE_NEARBY 1003 +#define IDC_IGNORE_NUMLINES 1004 +#define IDC_IGNORE_THIS 1005 +#define IDC_BREAK 1006 +#define IDC_IGNORE_ALL 1008 +#define IDC_IGNORE_ALWAYS 1009 +#define IDC_IGNORE_NUMTIMES 1010 +#define IDC_ASSERT_MSG_CTRL 1011 +#define IDC_NOID -1 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 103 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1005 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/utils/xbox/vxconsole/bindings.cpp b/utils/xbox/vxconsole/bindings.cpp new file mode 100644 index 0000000..67bce48 --- /dev/null +++ b/utils/xbox/vxconsole/bindings.cpp @@ -0,0 +1,591 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// BINDINGS.CPP +// +// Keyboard Shortcuts +//=====================================================================================// +#include "vxconsole.h" + +#define ID_BINDINGS_LISTVIEW 100 + +// column id +#define ID_BIND_KEYCODE 0 +#define ID_BIND_MENUNAME 1 +#define ID_BIND_COMMAND 2 + +typedef struct +{ const CHAR* name; + int width; + int subItemIndex; +} label_t; + +typedef struct +{ + int keyCode; + const char *pKeyString; + char *pMenuName; + char *pCommandString; +} bind_t; + +// {VK_F1, "F1", "WireFrame", "incrementvar mat_wireframe 0 2 1"}, +// {VK_F2, "F2", "FullBright", "incrementvar mat_fullbright 0 2 1"}, +// {VK_F3, "F3", "Impulse 101", "impulse 101"}, +// {VK_F4, "F4", "Screenshot", "*screenshot"}, + + +bind_t g_bindings[MAX_BINDINGS] = +{ + {VK_F1, "F1", NULL, NULL}, + {VK_F2, "F2", NULL, NULL}, + {VK_F3, "F3", NULL, NULL}, + {VK_F4, "F4", NULL, NULL}, + {VK_F5, "F5", NULL, NULL}, + {VK_F6, "F6", NULL, NULL}, + {VK_F7, "F7", NULL, NULL}, + {VK_F8, "F8", NULL, NULL}, + {VK_F9, "F9", NULL, NULL}, + {VK_F10, "F10", NULL, NULL}, + {VK_F11, "F11", NULL, NULL}, + {VK_F12, "F12", NULL, NULL}, +}; + +label_t g_bindings_labels[] = +{ + {"Key", 80, ID_BIND_KEYCODE}, + {"Menu Name", 150, ID_BIND_MENUNAME}, + {"Command", 400, ID_BIND_COMMAND}, +}; + +HWND g_bindings_hWnd; +HWND g_bindings_hWndListView; +RECT g_bindings_windowRect; +char g_bindingsModify_menuName[256]; +char g_bindingsModify_command[256]; +char g_bindingsModify_keyCode[256]; + +//----------------------------------------------------------------------------- +// Bindings_ModifyEntry +// +//----------------------------------------------------------------------------- +void Bindings_ModifyEntry( int i, const char *pMenuName, const char *pCommandString ) +{ + if ( g_bindings[i].pMenuName && g_bindings[i].pMenuName[0] ) + Sys_Free( g_bindings[i].pMenuName ); + g_bindings[i].pMenuName = Sys_CopyString( pMenuName ); + + if ( g_bindings[i].pCommandString && g_bindings[i].pCommandString[0] ) + Sys_Free( g_bindings[i].pCommandString ); + g_bindings[i].pCommandString = Sys_CopyString( pCommandString ); +} + +//----------------------------------------------------------------------------- +// Bindings_GetSelectedItem +// +//----------------------------------------------------------------------------- +int Bindings_GetSelectedItem() +{ + int i; + int selection = -1; + int state; + + for ( i=0; i<MAX_BINDINGS; i++ ) + { + state = ListView_GetItemState( g_bindings_hWndListView, i, LVIS_SELECTED ); + if ( state == LVIS_SELECTED ) + { + selection = i; + break; + } + } + + return selection; +} + +//----------------------------------------------------------------------------- +// Bindings_TranslateKey +// +//----------------------------------------------------------------------------- +bool Bindings_TranslateKey( int vkKeyCode ) +{ + int i; + + for ( i=0; i<MAX_BINDINGS; i++ ) + { + if ( !g_bindings[i].pCommandString || !g_bindings[i].pCommandString[0] ) + continue; + + if ( vkKeyCode == g_bindings[i].keyCode ) + { + ProcessCommand( g_bindings[i].pCommandString ); + return true; + } + } + + return false; +} + +//----------------------------------------------------------------------------- +// Bindings_MenuSelection +// +//----------------------------------------------------------------------------- +bool Bindings_MenuSelection( int wID ) +{ + int index; + + index = wID - IDM_BINDINGS_BIND1; + if ( index < 0 || index > MAX_BINDINGS-1 ) + return false; + + // as if the key were pressed... + return ( Bindings_TranslateKey( g_bindings[index].keyCode ) ); +} + +//----------------------------------------------------------------------------- +// Bindings_UpdateMenu +// +// Builds the dynamic menu +//----------------------------------------------------------------------------- +void Bindings_UpdateMenu() +{ + HMENU hMenu; + HMENU hNewMenu; + MENUITEMINFO menuItemInfo; + int i; + int numAdded; + char menuBuff[64]; + + hMenu = GetMenu( g_hDlgMain ); + if ( !hMenu ) + return; + + memset( &menuItemInfo, 0, sizeof( menuItemInfo ) ); + menuItemInfo.cbSize = sizeof( MENUITEMINFO ); + + numAdded = 0; + hNewMenu = CreatePopupMenu(); + menuItemInfo.fMask = MIIM_ID|MIIM_FTYPE|MIIM_STRING; + menuItemInfo.fType = MFT_STRING; + for ( i=MAX_BINDINGS-1; i>=0; i-- ) + { + if ( !g_bindings[i].pCommandString || !g_bindings[i].pCommandString[0] ) + continue; + + menuItemInfo.wID = IDM_BINDINGS_BIND1+i; + sprintf( menuBuff, "%s\tF%d", g_bindings[i].pMenuName, g_bindings[i].keyCode-VK_F1+1 ); + menuItemInfo.dwTypeData = ( LPSTR )menuBuff; + InsertMenuItem( hNewMenu, 0, true, &menuItemInfo ); + + numAdded++; + } + + if ( numAdded ) + { + // add seperator + menuItemInfo.fMask = MIIM_FTYPE; + menuItemInfo.fType = MFT_SEPARATOR; + InsertMenuItem( hNewMenu, 0, true, &menuItemInfo ); + } + + menuItemInfo.fMask = MIIM_ID|MIIM_FTYPE|MIIM_STRING; + menuItemInfo.fType = MFT_STRING; + menuItemInfo.wID = IDM_BINDINGS_EDIT; + menuItemInfo.dwTypeData = "Edit..."; + InsertMenuItem( hNewMenu, 0, true, &menuItemInfo ); + + // delete the previous menu + menuItemInfo.fMask = MIIM_SUBMENU; + GetMenuItemInfo( hMenu, IDM_BINDINGS, false, &menuItemInfo ); + if ( menuItemInfo.hSubMenu ) + DestroyMenu( menuItemInfo.hSubMenu ); + else + { + // add a new menu at the tail of the app menu + AppendMenu( hMenu, MF_STRING, ( UINT_PTR )IDM_BINDINGS, "Bindings" ); + } + + // add the new menu to bar + menuItemInfo.fMask = MIIM_SUBMENU; + menuItemInfo.hSubMenu = hNewMenu; + SetMenuItemInfo( hMenu, IDM_BINDINGS, false, &menuItemInfo ); + + DrawMenuBar( g_hDlgMain ); +} + +//----------------------------------------------------------------------------- +// BindingsModifyDlg_Proc +// +//----------------------------------------------------------------------------- +BOOL CALLBACK BindingsModifyDlg_Proc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + switch ( message ) + { + case WM_INITDIALOG: + SetDlgItemText( hWnd, IDC_MODIFYBIND_KEYCODE, g_bindingsModify_keyCode ); + SetDlgItemText( hWnd, IDC_MODIFYBIND_MENUNAME, g_bindingsModify_menuName ); + SetDlgItemText( hWnd, IDC_MODIFYBIND_COMMAND, g_bindingsModify_command ); + return ( TRUE ); + + case WM_COMMAND: + switch ( LOWORD( wParam ) ) + { + case IDC_OK: + GetDlgItemText( hWnd, IDC_MODIFYBIND_MENUNAME, g_bindingsModify_menuName, sizeof( g_bindingsModify_menuName ) ); + GetDlgItemText( hWnd, IDC_MODIFYBIND_COMMAND, g_bindingsModify_command, sizeof( g_bindingsModify_command ) ); + case IDCANCEL: + case IDC_CANCEL: + EndDialog( hWnd, wParam ); + return ( TRUE ); + } + break; + } + return ( FALSE ); +} + +//----------------------------------------------------------------------------- +// BindingsModifyDlg_Open +// +//----------------------------------------------------------------------------- +void BindingsModifyDlg_Open( int selection ) +{ + int result; + + sprintf( g_bindingsModify_keyCode, "F%d", selection+1 ); + strcpy( g_bindingsModify_menuName, g_bindings[selection].pMenuName ); + strcpy( g_bindingsModify_command, g_bindings[selection].pCommandString ); + + result = DialogBox( g_hInstance, MAKEINTRESOURCE( IDD_MODIFYBIND ), g_hDlgMain, ( DLGPROC )BindingsModifyDlg_Proc ); + if ( LOWORD( result ) != IDC_OK ) + return; + + // accept changes and update + Bindings_ModifyEntry( selection, g_bindingsModify_menuName, g_bindingsModify_command ); + ListView_RedrawItems( g_bindings_hWndListView, 0, MAX_BINDINGS-1 ); + UpdateWindow( g_bindings_hWndListView ); + Bindings_UpdateMenu(); +} + +//----------------------------------------------------------------------------- +// Bindings_LoadConfig +// +//----------------------------------------------------------------------------- +void Bindings_LoadConfig() +{ + char valueBuff[256]; + char keyBuff[32]; + char menuName[256]; + char commandString[256]; + char *ptr; + char *token; + int keyCode; + int i; + int numArgs; + char buff[256]; + + for ( i=0; i<MAX_BINDINGS; i++ ) + { + menuName[0] = '\0'; + commandString[0] = '\0'; + + sprintf( keyBuff, "bind%d", i ); + Sys_GetRegistryString( keyBuff, valueBuff, "", sizeof( valueBuff ) ); + + // parse and populate valid values + ptr = valueBuff; + token = Sys_GetToken( &ptr, false, NULL ); + if ( token[0] ) + keyCode = atoi( token ); + + token = Sys_GetToken( &ptr, false, NULL ); + if ( token[0] ) + strcpy( menuName, token ); + + token = Sys_GetToken( &ptr, false, NULL ); + if ( token[0] ) + strcpy( commandString, token ); + + Bindings_ModifyEntry( i, menuName, commandString ); + } + + Sys_GetRegistryString( "bindingsWindowRect", buff, "", sizeof( buff ) ); + numArgs = sscanf( buff, "%d %d %d %d", &g_bindings_windowRect.left, &g_bindings_windowRect.top, &g_bindings_windowRect.right, &g_bindings_windowRect.bottom ); + if ( numArgs != 4 ) + memset( &g_bindings_windowRect, 0, sizeof( g_bindings_windowRect ) ); +} + +//----------------------------------------------------------------------------- +// Bindings_SaveConfig +// +//----------------------------------------------------------------------------- +void Bindings_SaveConfig() +{ + char valueBuff[256]; + char buff[256]; + char keyBuff[32]; + char *pMenuName; + char *pCommandString; + int len; + int i; + WINDOWPLACEMENT wp; + + if ( g_bindings_hWnd ) + { + memset( &wp, 0, sizeof( wp ) ); + wp.length = sizeof( WINDOWPLACEMENT ); + GetWindowPlacement( g_bindings_hWnd, &wp ); + g_bindings_windowRect = wp.rcNormalPosition; + sprintf( buff, "%d %d %d %d", wp.rcNormalPosition.left, wp.rcNormalPosition.top, wp.rcNormalPosition.right, wp.rcNormalPosition.bottom ); + Sys_SetRegistryString( "bindingsWindowRect", buff ); + } + + for ( i=0; i<MAX_BINDINGS; i++ ) + { + sprintf( keyBuff, "bind%d", i ); + + pMenuName = g_bindings[i].pMenuName; + if ( !pMenuName ) + pMenuName = ""; + + pCommandString = g_bindings[i].pCommandString; + if ( !pCommandString ) + pCommandString = ""; + + len = _snprintf( valueBuff, sizeof( valueBuff ), "%d \"%s\" \"%s\"", g_bindings[i].keyCode, pMenuName, pCommandString ); + if ( len == -1 ) + { + // kill it + valueBuff[0] = '\0'; + } + + Sys_SetRegistryString( keyBuff, valueBuff ); + } +} + +//----------------------------------------------------------------------------- +// Bindings_SizeWindow +// +//----------------------------------------------------------------------------- +void Bindings_SizeWindow( HWND hwnd, int cx, int cy ) +{ + if ( cx==0 || cy==0 ) + { + RECT rcClient; + GetClientRect( hwnd, &rcClient ); + cx = rcClient.right; + cy = rcClient.bottom; + } + + // position the ListView + SetWindowPos( g_bindings_hWndListView, NULL, 0, 0, cx, cy, SWP_NOZORDER ); +} + +//----------------------------------------------------------------------------- +// Bindings_WndProc +// +//----------------------------------------------------------------------------- +LRESULT CALLBACK Bindings_WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + WORD wID = LOWORD( wParam ); + bind_t* pBind; + int selection; + + switch ( message ) + { + case WM_CREATE: + return 0L; + + case WM_DESTROY: + Bindings_SaveConfig(); + Bindings_UpdateMenu(); + + g_bindings_hWnd = NULL; + return 0L; + + case WM_SIZE: + Bindings_SizeWindow( hwnd, LOWORD( lParam ), HIWORD( lParam ) ); + return 0L; + + case WM_NOTIFY: + switch ( ( ( LPNMHDR )lParam )->code ) + { + case LVN_GETDISPINFO: + NMLVDISPINFO* plvdi; + plvdi = ( NMLVDISPINFO* )lParam; + pBind = ( bind_t* )plvdi->item.lParam; + switch ( plvdi->item.iSubItem ) + { + case ID_BIND_KEYCODE: + plvdi->item.pszText = ( LPSTR )pBind->pKeyString; + return 0L; + + case ID_BIND_MENUNAME: + plvdi->item.pszText = pBind->pMenuName; + return 0L; + + case ID_BIND_COMMAND: + plvdi->item.pszText = pBind->pCommandString; + return 0L; + + default: + break; + } + break; + + case NM_DBLCLK: + NMITEMACTIVATE *pnmitem; + pnmitem = ( LPNMITEMACTIVATE )lParam; + BindingsModifyDlg_Open( pnmitem->iItem ); + break; + } + break; + + case WM_COMMAND: + switch ( wID ) + { + case IDM_BINDOPTIONS_MODIFY: + selection = Bindings_GetSelectedItem(); + if ( selection >= 0 ) + BindingsModifyDlg_Open( selection ); + return 0L; + + case IDM_BINDOPTIONS_DELETE: + selection = Bindings_GetSelectedItem(); + if ( selection >= 0 ) + { + Bindings_ModifyEntry( selection, "", "" ); + ListView_RedrawItems( g_bindings_hWndListView, 0, MAX_BINDINGS-1 ); + UpdateWindow( g_bindings_hWndListView ); + Bindings_UpdateMenu(); + } + return 0L; + } + break; + } + + return ( DefWindowProc( hwnd, message, wParam, lParam ) ); +} + +//----------------------------------------------------------------------------- +// Bindings_Open +// +//----------------------------------------------------------------------------- +void Bindings_Open() +{ + RECT clientRect; + HWND hWnd; + int i; + LVITEM lvi; + + if ( g_bindings_hWnd ) + { + // only one instance + if ( IsIconic( g_bindings_hWnd ) ) + ShowWindow( g_bindings_hWnd, SW_RESTORE ); + SetForegroundWindow( g_bindings_hWnd ); + return; + } + + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + "BINDINGSCLASS", + "Edit Bindings", + WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX, + 0, + 0, + 600, + 300, + g_hDlgMain, + NULL, + g_hInstance, + NULL ); + g_bindings_hWnd = hWnd; + + GetClientRect( g_bindings_hWnd, &clientRect ); + hWnd = CreateWindow( + WC_LISTVIEW, + "", + WS_VISIBLE|WS_CHILD|LVS_REPORT|LVS_SHOWSELALWAYS|LVS_SINGLESEL|LVS_NOSORTHEADER, + 0, + 0, + clientRect.right-clientRect.left, + clientRect.bottom-clientRect.top, + g_bindings_hWnd, + ( HMENU )ID_BINDINGS_LISTVIEW, + g_hInstance, + NULL ); + g_bindings_hWndListView = hWnd; + + // init list view columns + for ( i=0; i<sizeof( g_bindings_labels )/sizeof( g_bindings_labels[0] ); i++ ) + { + LVCOLUMN lvc; + memset( &lvc, 0, sizeof( lvc ) ); + + lvc.mask = LVCF_FMT|LVCF_WIDTH|LVCF_TEXT|LVCF_SUBITEM; + lvc.iSubItem = 0; + lvc.cx = g_bindings_labels[i].width; + lvc.fmt = LVCFMT_LEFT; + lvc.pszText = ( LPSTR )g_bindings_labels[i].name; + + ListView_InsertColumn( g_bindings_hWndListView, i, &lvc ); + } + + ListView_SetBkColor( g_bindings_hWndListView, g_backgroundColor ); + ListView_SetTextBkColor( g_bindings_hWndListView, g_backgroundColor ); + + DWORD style = LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES|LVS_EX_HEADERDRAGDROP; + ListView_SetExtendedListViewStyleEx( g_bindings_hWndListView, style, style ); + + // populate list view + for ( i=0; i<MAX_BINDINGS; i++ ) + { + int itemCount = ListView_GetItemCount( g_bindings_hWndListView ); + + // setup and insert at end of list + memset( &lvi, 0, sizeof( lvi ) ); + lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE; + lvi.iItem = itemCount; + lvi.iSubItem = 0; + lvi.state = 0; + lvi.stateMask = 0; + lvi.pszText = LPSTR_TEXTCALLBACK; + lvi.lParam = ( LPARAM )&g_bindings[i]; + + ListView_InsertItem( g_bindings_hWndListView, &lvi ); + } + + // set the first item selected + ListView_SetItemState( g_bindings_hWndListView, 0, LVIS_SELECTED, LVIS_SELECTED ); + SetFocus( g_bindings_hWndListView ); + + if ( g_bindings_windowRect.right && g_bindings_windowRect.bottom ) + MoveWindow( g_bindings_hWnd, g_bindings_windowRect.left, g_bindings_windowRect.top, g_bindings_windowRect.right-g_bindings_windowRect.left, g_bindings_windowRect.bottom-g_bindings_windowRect.top, FALSE ); + ShowWindow( g_bindings_hWnd, SHOW_OPENWINDOW ); +} + +//----------------------------------------------------------------------------- +// Bindings_Init +// +//----------------------------------------------------------------------------- +bool Bindings_Init() +{ + // set up our window class + WNDCLASS wndclass; + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = Bindings_WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = 0; + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_APPLICATION]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = MAKEINTRESOURCE( MENU_BINDOPTIONS ); + wndclass.lpszClassName = "BINDINGSCLASS"; + if ( !RegisterClass( &wndclass ) ) + return false; + + Bindings_LoadConfig(); + Bindings_UpdateMenu(); + + return true; +}
\ No newline at end of file diff --git a/utils/xbox/vxconsole/bug.cpp b/utils/xbox/vxconsole/bug.cpp new file mode 100644 index 0000000..1d288eb --- /dev/null +++ b/utils/xbox/vxconsole/bug.cpp @@ -0,0 +1,1576 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// BUG.CPP +// +// Tracker bridge +//=====================================================================================// +#include "vxconsole.h" + +// two bug systems, certain games are tied to a specific system +#define BUG_REPORTER_DLLNAME_1 "bugreporter.dll" +#define BUG_REPORTER_DLLNAME_2 "bugreporter_filequeue.dll" + +#define BUG_REPOSITORY_URL "\\\\fileserver\\bugs" +#define REPOSITORY_VALIDATION_FILE "info.txt" +#define BUG_ERRORTITLE "Bug Error" +#define BUG_COLOR ( RGB( 0,255,255 ) ) + +HWND g_bug_hWnd; +HMODULE g_bug_hBugReporter1; +HMODULE g_bug_hBugReporter2; +IBugReporter *g_bug_pReporter1; +IBugReporter *g_bug_pReporter2; +IBugReporter *g_bug_pReporter; +char g_bug_szTitle[512]; +char g_bug_szDescription[1024]; +char g_bug_szOwner[128]; +char g_bug_szSeverity[128]; +char g_bug_szReportType[128]; +char g_bug_szPriority[128]; +char g_bug_szArea[128]; +char g_bug_szMapNumber[128]; +int g_bug_GameType; +bool g_bug_bActive; +char g_bug_szScreenshot[MAX_PATH]; +char g_bug_szSavegame[MAX_PATH]; +char g_bug_szBSPName[MAX_PATH]; +xrMapInfo_t g_bug_mapInfo; +bool g_bug_bCompressScreenshot; +bool g_bug_bFirstCommand; + +struct GameSystem_t +{ + const char *pFriendlyName; + const char *pGameName; + bool bUsesSystem1; +}; + +GameSystem_t g_Games[] = +{ + { "Half Life 2", "hl2", true }, + { "Episode 1", "episodic", true }, + { "Episode 2", "ep2", true }, + { "Portal", "portal", false }, + { "Team Fortress 2", "tf", false }, +}; + +static const char *GetRepositoryURL( void ) +{ + const char *pURL = g_bug_pReporter->GetRepositoryURL(); + if ( pURL ) + { + return pURL; + } + + return BUG_REPOSITORY_URL; +} + +const char *GetSubmissionURL( int bugid ) +{ + const char *pURL = g_bug_pReporter->GetSubmissionURL(); + if ( pURL ) + { + return pURL; + } + + static char url[MAX_PATH]; + Q_snprintf( url, sizeof(url), "%s/%i", GetRepositoryURL(), bugid ); + + return url; +} + +//----------------------------------------------------------------------------- +// BugReporter_SelectReporter +// +//----------------------------------------------------------------------------- +bool BugReporter_SelectReporter( const char *pGameName ) +{ + int system = -1; + for ( int i = 0; i < ARRAYSIZE( g_Games ); i++ ) + { + if ( pGameName && !V_stricmp( g_Games[i].pGameName, pGameName ) ) + { + system = i; + break; + } + } + + if ( system == -1 ) + { + // not found, slam to first + system = 0; + } + + // games uses different systems + int oldGameType = g_bug_GameType; + g_bug_GameType = system; + if ( g_Games[system].bUsesSystem1 ) + { + g_bug_pReporter = g_bug_pReporter1; + } + else + { + g_bug_pReporter = g_bug_pReporter2; + } + + // force the game area + if ( g_Games[g_bug_GameType].bUsesSystem1 ) + { + strcpy( g_bug_szArea, "XBOX 360" ); + } + else + { + strcpy( g_bug_szArea, g_Games[g_bug_GameType].pFriendlyName ); + } + + bool bChanged = ( oldGameType != g_bug_GameType ); + return bChanged; +} + +//----------------------------------------------------------------------------- +// BugReporter_LoadDLL +// +//----------------------------------------------------------------------------- +IBugReporter *BugReporter_LoadDLL( const char *pDLLName, HMODULE *phModule ) +{ + HMODULE hModule; + IBugReporter *pBugReporter; + + *phModule = NULL; + + hModule = LoadLibrary( pDLLName ); + if ( !hModule ) + { + Sys_MessageBox( BUG_ERRORTITLE, "Could not open '%s'\n", pDLLName ); + return NULL; + } + + FARPROC pCreateInterface = GetProcAddress( hModule, CREATEINTERFACE_PROCNAME ); + if ( !pCreateInterface ) + { + Sys_MessageBox( BUG_ERRORTITLE, "Missing '%s' interface for '%s'\n", CREATEINTERFACE_PROCNAME, pDLLName ); + return NULL; + } + + pBugReporter = (IBugReporter *)((CreateInterfaceFn)pCreateInterface)( INTERFACEVERSION_BUGREPORTER, NULL ); + if ( !pBugReporter ) + { + Sys_MessageBox( BUG_ERRORTITLE, "Missing interface '%s' for '%s'\n", INTERFACEVERSION_BUGREPORTER, pDLLName ); + return NULL; + } + + bool bSuccess = pBugReporter->Init( NULL ); + if ( !bSuccess ) + { + return NULL; + } + + *phModule = hModule; + return pBugReporter; +} + +//----------------------------------------------------------------------------- +// BugReporter_GetInterfaces +// +//----------------------------------------------------------------------------- +bool BugReporter_GetInterfaces() +{ + if ( !g_bug_pReporter1 ) + { + g_bug_pReporter1 = BugReporter_LoadDLL( BUG_REPORTER_DLLNAME_1, &g_bug_hBugReporter1 ); + if ( !g_bug_pReporter1 ) + { + Sys_MessageBox( BUG_ERRORTITLE, "PVCS intialization failed!\n" ); + } + } + + if ( !g_bug_pReporter2 ) + { + g_bug_pReporter2 = BugReporter_LoadDLL( BUG_REPORTER_DLLNAME_2, &g_bug_hBugReporter2 ); + if ( !g_bug_pReporter2 ) + { + Sys_MessageBox( BUG_ERRORTITLE, "BugBait intialization failed!\n" ); + } + } + + if ( g_bug_pReporter1 ) + { + // determine submitter name + ConsoleWindowPrintf( BUG_COLOR, "Bug Reporter: PVCS Username: '%s' Display As: '%s'\n", g_bug_pReporter1->GetUserName(), g_bug_pReporter1->GetUserName_Display() ); + } + if ( g_bug_pReporter2 ) + { + // determine submitter name + ConsoleWindowPrintf( BUG_COLOR, "Bug Reporter: BugBait Username: '%s' Display As: '%s'\n", g_bug_pReporter2->GetUserName(), g_bug_pReporter2->GetUserName_Display() ); + } + + BugReporter_SelectReporter( NULL ); + + // See if we can see the bug repository right now + char fn[MAX_PATH]; + V_snprintf( fn, sizeof( fn ), "%s/%s", GetRepositoryURL(), REPOSITORY_VALIDATION_FILE ); + Sys_NormalizePath( fn, false ); + + FILE *fp = fopen( fn, "rb" ); + if ( fp ) + { + ConsoleWindowPrintf( BUG_COLOR, "PVCS Repository '%s'\n", GetRepositoryURL() ); + fclose( fp ); + } + else + { + Sys_MessageBox( BUG_ERRORTITLE, "Unable to see '%s', check permissions and network connectivity.\n", fn ); + return false; + } + + // success + return true; +} + +//----------------------------------------------------------------------------- +// BugReporter_FreeInterfaces +// +//----------------------------------------------------------------------------- +void BugReporter_FreeInterfaces() +{ + if ( g_bug_pReporter1 ) + { + g_bug_pReporter1->Shutdown(); + g_bug_pReporter1 = NULL; + FreeLibrary( g_bug_hBugReporter1 ); + g_bug_hBugReporter1 = NULL; + } + + if ( g_bug_pReporter2 ) + { + g_bug_pReporter2->Shutdown(); + g_bug_pReporter2 = NULL; + FreeLibrary( g_bug_hBugReporter2 ); + g_bug_hBugReporter2 = NULL; + } +} + +//----------------------------------------------------------------------------- +// Purpose: Expanded data destination object for CUtlBuffer output +//----------------------------------------------------------------------------- +struct JPEGDestinationManager_t +{ + struct jpeg_destination_mgr pub; // public fields + + CUtlBuffer *pBuffer; // target/final buffer + byte *buffer; // start of temp buffer +}; + +// choose an efficiently bufferaable size +#define OUTPUT_BUF_SIZE 4096 + +//----------------------------------------------------------------------------- +// Purpose: Initialize destination --- called by jpeg_start_compress +// before any data is actually written. +//----------------------------------------------------------------------------- +void init_destination( j_compress_ptr cinfo ) +{ + JPEGDestinationManager_t *dest = ( JPEGDestinationManager_t *) cinfo->dest; + + // Allocate the output buffer --- it will be released when done with image + dest->buffer = (byte *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_IMAGE, + OUTPUT_BUF_SIZE * sizeof(byte)); + + dest->pub.next_output_byte = dest->buffer; + dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; +} + +//----------------------------------------------------------------------------- +// Purpose: Empty the output buffer --- called whenever buffer fills up. +// Input : boolean - +//----------------------------------------------------------------------------- +boolean empty_output_buffer( j_compress_ptr cinfo ) +{ + JPEGDestinationManager_t *dest = ( JPEGDestinationManager_t * ) cinfo->dest; + + CUtlBuffer *buf = dest->pBuffer; + + // Add some data + buf->Put( dest->buffer, OUTPUT_BUF_SIZE ); + + dest->pub.next_output_byte = dest->buffer; + dest->pub.free_in_buffer = OUTPUT_BUF_SIZE; + + return TRUE; +} + +//----------------------------------------------------------------------------- +// Purpose: Terminate destination --- called by jpeg_finish_compress +// after all data has been written. Usually needs to flush buffer. +// +// NB: *not* called by jpeg_abort or jpeg_destroy; surrounding +// application must deal with any cleanup that should happen even +// for error exit. +//----------------------------------------------------------------------------- +void term_destination( j_compress_ptr cinfo ) +{ + JPEGDestinationManager_t *dest = (JPEGDestinationManager_t *) cinfo->dest; + size_t datacount = OUTPUT_BUF_SIZE - dest->pub.free_in_buffer; + + CUtlBuffer *buf = dest->pBuffer; + + /* Write any data remaining in the buffer */ + if (datacount > 0) + { + buf->Put( dest->buffer, datacount ); + } +} + +//----------------------------------------------------------------------------- +// Purpose: Set up functions for writing data to a CUtlBuffer instead of FILE * +//----------------------------------------------------------------------------- +void jpeg_UtlBuffer_dest( j_compress_ptr cinfo, CUtlBuffer *pBuffer ) +{ + JPEGDestinationManager_t *dest; + + /* The destination object is made permanent so that multiple JPEG images + * can be written to the same file without re-executing jpeg_stdio_dest. + * This makes it dangerous to use this manager and a different destination + * manager serially with the same JPEG object, because their private object + * sizes may be different. Caveat programmer. + */ + if (cinfo->dest == NULL) { /* first time for this JPEG object? */ + cinfo->dest = (struct jpeg_destination_mgr *) + (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, + sizeof(JPEGDestinationManager_t)); + } + + dest = ( JPEGDestinationManager_t * ) cinfo->dest; + + dest->pub.init_destination = init_destination; + dest->pub.empty_output_buffer = empty_output_buffer; + dest->pub.term_destination = term_destination; + dest->pBuffer = pBuffer; +} + +//----------------------------------------------------------------------------- +// BugDlg_CompressScreenshot +// +// Compress .BMP to .JPG, Delete .BMP +//----------------------------------------------------------------------------- +bool BugDlg_CompressScreenshot() +{ + if ( !g_bug_szScreenshot[0] ) + { + return false; + } + + bool bSuccess = false; + HBITMAP hBitmap = NULL; + HDC hDC = NULL; + char *pBMPBits = NULL; + + CUtlBuffer buf( 0, 0 ); + + hBitmap = (HBITMAP)LoadImage( NULL, g_bug_szScreenshot, IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION | LR_DEFAULTSIZE | LR_LOADFROMFILE ); + if ( !hBitmap ) + goto cleanUp; + + hDC = CreateCompatibleDC( NULL ); + if ( !hDC ) + goto cleanUp; + + BITMAPINFO bitmapInfo; + ZeroMemory( &bitmapInfo, sizeof( BITMAPINFO ) ); + bitmapInfo.bmiHeader.biSize = sizeof( BITMAPINFOHEADER ); + + // populate the bmp info + if ( !GetDIBits( hDC, hBitmap, 0, 0, NULL, &bitmapInfo, DIB_RGB_COLORS ) ) + goto cleanUp; + + pBMPBits = (char *)Sys_Alloc( bitmapInfo.bmiHeader.biSizeImage ); + if ( !pBMPBits ) + goto cleanUp; + + // could be bottom-up or top-down + int nHeight = abs( bitmapInfo.bmiHeader.biHeight ); + + if ( bitmapInfo.bmiHeader.biBitCount != 32 ) + { + // unexpected format + goto cleanUp; + } + + if ( bitmapInfo.bmiHeader.biCompression != BI_RGB && bitmapInfo.bmiHeader.biCompression != BI_BITFIELDS ) + { + // unexpected format + goto cleanUp; + } + + // don't want color masks + bitmapInfo.bmiHeader.biCompression = BI_RGB; + + // get the raw bits + if ( !GetDIBits( hDC, hBitmap, 0, nHeight, pBMPBits, &bitmapInfo, DIB_RGB_COLORS ) ) + goto cleanUp; + + JSAMPROW row_pointer[1]; + + // compression data structure + struct jpeg_compress_struct cinfo; + ZeroMemory( &cinfo, sizeof( jpeg_compress_struct ) ); + + // point at stderr + struct jpeg_error_mgr jerr; + cinfo.err = jpeg_std_error( &jerr ); + + // create compressor + jpeg_create_compress( &cinfo ); + + // Hook CUtlBuffer to compression + jpeg_UtlBuffer_dest( &cinfo, &buf ); + + // image width and height, in pixels + cinfo.image_width = bitmapInfo.bmiHeader.biWidth; + cinfo.image_height = nHeight; + cinfo.input_components = 3; + cinfo.in_color_space = JCS_RGB; + + // Apply settings + jpeg_set_defaults( &cinfo ); + jpeg_set_quality( &cinfo, 50, TRUE ); + + // Start compressor + jpeg_start_compress( &cinfo, TRUE); + + char *pRowBuffer = (char*)_alloca( bitmapInfo.bmiHeader.biWidth * 3 ); + row_pointer[0] = (JSAMPROW)pRowBuffer; + + // Write scanlines + while ( cinfo.next_scanline < cinfo.image_height ) + { + char *pSrc; + if ( bitmapInfo.bmiHeader.biHeight < 0 ) + { + // top down + pSrc = &pBMPBits[cinfo.next_scanline * bitmapInfo.bmiHeader.biWidth * 4]; + } + else + { + // bottom up + pSrc = &pBMPBits[(nHeight-1 - cinfo.next_scanline) * bitmapInfo.bmiHeader.biWidth * 4]; + } + + // convert to BGR to RGB + char *pDst = pRowBuffer; + for ( int i=0; i<bitmapInfo.bmiHeader.biWidth; i++ ) + { + pDst[0] = pSrc[2]; + pDst[1] = pSrc[1]; + pDst[2] = pSrc[0]; + pSrc += 4; + pDst += 3; + } + jpeg_write_scanlines( &cinfo, row_pointer, 1 ); + } + + // Finalize image + jpeg_finish_compress( &cinfo ); + + char jpgFilename[MAX_PATH]; + Sys_StripExtension( g_bug_szScreenshot, jpgFilename, sizeof( jpgFilename ) ); + Sys_AddExtension( ".jpg", jpgFilename, sizeof( jpgFilename ) ); + if ( !Sys_SaveFile( jpgFilename, buf.Base(), buf.TellMaxPut() ) ) + goto cleanUp; + + // remove the uncompressed version + unlink( g_bug_szScreenshot ); + strcpy( g_bug_szScreenshot, jpgFilename ); + + bSuccess = true; + +cleanUp: + if ( hBitmap ) + DeleteObject( hBitmap ); + if ( hDC ) + DeleteDC( hDC ); + if ( pBMPBits ) + Sys_Free( pBMPBits ); + + return bSuccess; +} + + +//----------------------------------------------------------------------------- +// BugDlg_GetAppData +// +//----------------------------------------------------------------------------- +void BugDlg_GetAppData( HWND hWnd ) +{ + // clear stale data from previous query + memset( &g_bug_mapInfo, 0, sizeof( g_bug_mapInfo ) ); + + SetDlgItemText( hWnd, IDC_BUG_POSITION_LABEL, "" ); + SetDlgItemText( hWnd, IDC_BUG_ORIENTATION_LABEL, "" ); + SetDlgItemText( hWnd, IDC_BUG_MAP_LABEL, "" ); + SetDlgItemText( hWnd, IDC_BUG_BUILD_LABEL, "" ); + + EnableWindow( GetDlgItem( hWnd, IDC_BUG_SAVEGAME ), false ); + EnableWindow( GetDlgItem( hWnd, IDC_BUG_INCLUDEBSP ), false ); + + if ( g_connectedToApp ) + { + // send to app, responds with position info + if ( !g_bug_bFirstCommand ) + { + // first command must send pause and status to be processed correctly + g_bug_bFirstCommand = true; + ProcessCommand( "pause ; status" ); + } + else + { + ProcessCommand( "status" ); + } + } +} + +//----------------------------------------------------------------------------- +// BugDlg_GetDataFileBase +// +//----------------------------------------------------------------------------- +void BugDlg_GetDataFileBase( char const *suffix, bool bLocalPath, char *buf, int bufsize ) +{ + char filepath[MAX_PATH]; + char filename[MAX_PATH]; + + struct tm t; + + time_t ltime; + time( <ime ); + tm *pTime = localtime( <ime ); + memcpy( &t, pTime, sizeof( t ) ); + + char who[128]; + strncpy( who, suffix, sizeof( who ) ); + _strlwr( who ); + + if ( bLocalPath ) + { + // add a qualified local path + // used as a gathering store before uploading to server + strcpy( filepath, g_localPath ); + Sys_AddFileSeperator( filepath, sizeof( filepath ) ); + strcat( filepath, "bug/" ); + Sys_NormalizePath( filepath, false ); + Sys_CreatePath( filepath ); + } + else + { + filepath[0] = '\0'; + } + + sprintf( filename, "%i_%02i_%02i_%s", t.tm_year + 1900, t.tm_mon + 1, t.tm_mday, who ); + V_snprintf( buf, bufsize, "%s%s", filepath, filename ); +} + +//----------------------------------------------------------------------------- +// BugDlg_CheckSubmit +// +//----------------------------------------------------------------------------- +bool BugDlg_CheckSubmit( HWND hWnd ) +{ + bool bEnableSubmit = false; + + if ( g_Games[g_bug_GameType].bUsesSystem1 ) + { + if ( g_bug_szTitle[0] && + g_bug_szDescription[0] && + g_bug_szSeverity[0] && + g_bug_szOwner[0] && + g_bug_szReportType[0] && + g_bug_szPriority[0] && + g_bug_szArea[0] ) + { + bEnableSubmit = true; + } + } + else + { + if ( g_bug_szTitle[0] && + g_bug_szDescription[0] && + g_bug_szSeverity[0] && + g_bug_szOwner[0] && + g_bug_szArea[0] && + g_bug_szMapNumber[0] ) + { + bEnableSubmit = true; + } + } + + EnableWindow( GetDlgItem( hWnd, IDC_BUG_SUBMIT ), bEnableSubmit ); + + return bEnableSubmit; +} + +//----------------------------------------------------------------------------- +// BugDlg_GetChanges +// +//----------------------------------------------------------------------------- +bool BugDlg_GetChanges( HWND hWnd ) +{ + int curSel; + + // title + GetDlgItemText( hWnd, IDC_BUG_TITLE, g_bug_szTitle, sizeof( g_bug_szTitle ) ); + + // description + GetDlgItemText( hWnd, IDC_BUG_DESCRIPTION, g_bug_szDescription, sizeof( g_bug_szDescription ) ); + + // owner + curSel = SendDlgItemMessage( hWnd, IDC_BUG_OWNER, CB_GETCURSEL, 0, 0 ); + if ( curSel == CB_ERR ) + { + g_bug_szOwner[0] = '\0'; + } + else + { + strncpy( g_bug_szOwner, g_bug_pReporter->GetDisplayName( curSel ), sizeof( g_bug_szOwner ) ); + g_bug_szOwner[sizeof( g_bug_szOwner )-1] = '\0'; + + if ( V_stristr( g_bug_szOwner, "unassigned" ) ) + { + g_bug_szOwner[0] = '\0'; + } + } + + // severity + curSel = SendDlgItemMessage( hWnd, IDC_BUG_SEVERITY, CB_GETCURSEL, 0, 0 ); + if ( curSel == CB_ERR ) + { + g_bug_szSeverity[0] = '\0'; + } + else + { + V_strncpy( g_bug_szSeverity, g_bug_pReporter->GetSeverity( curSel ), sizeof( g_bug_szSeverity ) ); + } + + // report type + curSel = SendDlgItemMessage( hWnd, IDC_BUG_REPORTTYPE, CB_GETCURSEL, 0, 0 ); + if ( curSel == CB_ERR ) + { + g_bug_szReportType[0] = '\0'; + } + else + { + V_strncpy( g_bug_szReportType, g_bug_pReporter->GetReportType( curSel ), sizeof( g_bug_szReportType ) ); + } + + // priority + curSel = SendDlgItemMessage( hWnd, IDC_BUG_PRIORITY, CB_GETCURSEL, 0, 0 ); + if ( curSel == CB_ERR ) + { + g_bug_szPriority[0] = '\0'; + } + else + { + V_strncpy( g_bug_szPriority, g_bug_pReporter->GetPriority( curSel ), sizeof( g_bug_szPriority ) ); + } + + // area + curSel = SendDlgItemMessage( hWnd, IDC_BUG_AREA, CB_GETCURSEL, 0, 0 ); + int areaIndex = 0; + if ( curSel == CB_ERR ) + { + g_bug_szArea[0] = '\0'; + } + else + { + V_strncpy( g_bug_szArea, g_bug_pReporter->GetArea( curSel ), sizeof( g_bug_szArea ) ); + areaIndex = curSel; + } + + if ( !g_Games[g_bug_GameType].bUsesSystem1 ) + { + // map number + curSel = SendDlgItemMessage( hWnd, IDC_BUG_MAPNUMBER, CB_GETCURSEL, 0, 0 ); + if ( curSel == CB_ERR ) + { + g_bug_szMapNumber[0] = '\0'; + } + else + { + V_strncpy( g_bug_szMapNumber, g_bug_pReporter->GetLevel( areaIndex, curSel ), sizeof( g_bug_szMapNumber ) ); + } + } + + g_bug_bCompressScreenshot = ( IsDlgButtonChecked( hWnd, IDC_BUG_COMPRESS_SCREENSHOT ) != 0 ); + + BugDlg_CheckSubmit( hWnd ); + + // success + return true; +} + +//----------------------------------------------------------------------------- +// BugDlg_UpdateReporter +// +//----------------------------------------------------------------------------- +bool BugDlg_UpdateReporter( HWND hWnd ) +{ + // game + int newGameType; + int curSel = SendDlgItemMessage( hWnd, IDC_BUG_GAME, CB_GETCURSEL, 0, 0 ); + if ( curSel == CB_ERR ) + { + newGameType = 0; + } + else + { + newGameType = curSel; + } + + return BugReporter_SelectReporter( g_Games[newGameType].pGameName ); +} + +//----------------------------------------------------------------------------- +// BugDlg_Populate +// +//----------------------------------------------------------------------------- +void BugDlg_Populate( HWND hWnd ) +{ + int i; + int count; + int curSel; + + g_bug_bActive = false; + + // title + SendDlgItemMessage( hWnd, IDC_BUG_TITLE, EM_LIMITTEXT, sizeof( g_bug_szTitle )-1, 0 ); + SetDlgItemText( hWnd, IDC_BUG_TITLE, g_bug_szTitle ); + + // description + SendDlgItemMessage( hWnd, IDC_BUG_DESCRIPTION, EM_LIMITTEXT, sizeof( g_bug_szDescription )-1, 0 ); + SetDlgItemText( hWnd, IDC_BUG_DESCRIPTION, g_bug_szDescription ); + + // submitter + SetDlgItemText( hWnd, IDC_BUG_SUBMITTER_LABEL, g_bug_pReporter->GetUserName_Display() ); + + // owner + SendDlgItemMessage( hWnd, IDC_BUG_OWNER, CB_RESETCONTENT, 0, 0 ); + count = g_bug_pReporter->GetDisplayNameCount(); + for ( i = 0; i < count; i++ ) + { + SendDlgItemMessage( hWnd, IDC_BUG_OWNER, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_bug_pReporter->GetDisplayName( i ) ); + } + if ( count ) + { + curSel = SendDlgItemMessage( hWnd, IDC_BUG_OWNER, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szOwner ); + if ( curSel != CB_ERR ) + { + SendDlgItemMessage( hWnd, IDC_BUG_OWNER, CB_SETCURSEL, curSel, 0 ); + } + } + + // severity + SendDlgItemMessage( hWnd, IDC_BUG_SEVERITY, CB_RESETCONTENT, 0, 0 ); + count = g_bug_pReporter->GetSeverityCount(); + for ( i = 0; i < count; i++ ) + { + SendDlgItemMessage( hWnd, IDC_BUG_SEVERITY, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_bug_pReporter->GetSeverity( i ) ); + } + if ( count ) + { + curSel = SendDlgItemMessage( hWnd, IDC_BUG_SEVERITY, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szSeverity ); + if ( curSel != CB_ERR ) + { + SendDlgItemMessage( hWnd, IDC_BUG_SEVERITY, CB_SETCURSEL, curSel, 0 ); + } + } + + // report type + SendDlgItemMessage( hWnd, IDC_BUG_REPORTTYPE, CB_RESETCONTENT, 0, 0 ); + EnableWindow( GetDlgItem( hWnd, IDC_BUG_REPORTTYPE ), g_Games[g_bug_GameType].bUsesSystem1 ); + if ( g_Games[g_bug_GameType].bUsesSystem1 ) + { + count = g_bug_pReporter->GetReportTypeCount(); + for ( i = 0; i < count; i++ ) + { + SendDlgItemMessage( hWnd, IDC_BUG_REPORTTYPE, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_bug_pReporter->GetReportType( i ) ); + } + if ( count ) + { + curSel = SendDlgItemMessage( hWnd, IDC_BUG_REPORTTYPE, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szReportType ); + if ( curSel != CB_ERR ) + { + SendDlgItemMessage( hWnd, IDC_BUG_REPORTTYPE, CB_SETCURSEL, curSel, 0 ); + } + } + } + + // priority + SendDlgItemMessage( hWnd, IDC_BUG_PRIORITY, CB_RESETCONTENT, 0, 0 ); + EnableWindow( GetDlgItem( hWnd, IDC_BUG_PRIORITY ), g_Games[g_bug_GameType].bUsesSystem1 ); + if ( g_Games[g_bug_GameType].bUsesSystem1 ) + { + count = g_bug_pReporter->GetPriorityCount(); + for ( i = 0; i < count; i++ ) + { + SendDlgItemMessage( hWnd, IDC_BUG_PRIORITY, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_bug_pReporter->GetPriority( i ) ); + } + if ( count ) + { + curSel = SendDlgItemMessage( hWnd, IDC_BUG_PRIORITY, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szPriority ); + if ( curSel != CB_ERR ) + { + SendDlgItemMessage( hWnd, IDC_BUG_PRIORITY, CB_SETCURSEL, curSel, 0 ); + } + } + } + + // area + SendDlgItemMessage( hWnd, IDC_BUG_AREA, CB_RESETCONTENT, 0, 0 ); + count = g_bug_pReporter->GetAreaCount(); + int areaIndex = 0; + for ( i = 0; i < count; i++ ) + { + SendDlgItemMessage( hWnd, IDC_BUG_AREA, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_bug_pReporter->GetArea( i ) ); + } + if ( count ) + { + curSel = SendDlgItemMessage( hWnd, IDC_BUG_AREA, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szArea ); + if ( curSel != CB_ERR ) + { + SendDlgItemMessage( hWnd, IDC_BUG_AREA, CB_SETCURSEL, curSel, 0 ); + areaIndex = curSel; + } + } + + // map name or number + SendDlgItemMessage( hWnd, IDC_BUG_MAPNUMBER, CB_RESETCONTENT, 0, 0 ); + EnableWindow( GetDlgItem( hWnd, IDC_BUG_MAPNUMBER ), g_Games[g_bug_GameType].bUsesSystem1 == false ); + if ( !g_Games[g_bug_GameType].bUsesSystem1 ) + { + // new system has map names + count = g_bug_pReporter->GetLevelCount( areaIndex ); + for ( i = 0; i < count; i++ ) + { + SendDlgItemMessage( hWnd, IDC_BUG_MAPNUMBER, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_bug_pReporter->GetLevel( areaIndex, i ) ); + } + } + if ( count ) + { + curSel = SendDlgItemMessage( hWnd, IDC_BUG_MAPNUMBER, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szMapNumber ); + if ( curSel != CB_ERR ) + { + SendDlgItemMessage( hWnd, IDC_BUG_MAPNUMBER, CB_SETCURSEL, curSel, 0 ); + } + } + + // game + SendDlgItemMessage( hWnd, IDC_BUG_GAME, CB_RESETCONTENT, 0, 0 ); + count = ARRAYSIZE( g_Games ); + for ( i = 0; i < count; i++ ) + { + SendDlgItemMessage( hWnd, IDC_BUG_GAME, CB_ADDSTRING, 0, (LPARAM)(LPCSTR)g_Games[i].pFriendlyName ); + } + if ( count ) + { + curSel = SendDlgItemMessage( hWnd, IDC_BUG_GAME, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_Games[g_bug_GameType].pFriendlyName ); + if ( curSel != CB_ERR ) + { + SendDlgItemMessage( hWnd, IDC_BUG_GAME, CB_SETCURSEL, curSel, 0 ); + } + } + + CheckDlgButton( hWnd, IDC_BUG_COMPRESS_SCREENSHOT, g_bug_bCompressScreenshot ? BST_CHECKED : BST_UNCHECKED ); + + SetDlgItemText( hWnd, IDC_BUG_TAKESHOT_LABEL, g_bug_szScreenshot ); + SetDlgItemText( hWnd, IDC_BUG_SAVEGAME_LABEL, g_bug_szSavegame ); + SetDlgItemText( hWnd, IDC_BUG_INCLUDEBSP_LABEL, g_bug_szBSPName ); + SetDlgItemText( hWnd, IDC_BUG_INCLUDEVMF_LABEL, "" ); + + EnableWindow( GetDlgItem( hWnd, IDC_BUG_TAKESHOT ), g_connectedToApp ); + EnableWindow( GetDlgItem( hWnd, IDC_BUG_INCLUDEVMF ), false ); + EnableWindow( GetDlgItem( hWnd, IDC_BUG_UPDATE ), g_connectedToApp ); + + BugDlg_GetAppData( hWnd ); + + BugDlg_CheckSubmit( hWnd ); + + g_bug_bActive = true; +} + +//----------------------------------------------------------------------------- +// BugDlg_TakeScreenshot +// +//----------------------------------------------------------------------------- +void BugDlg_TakeScreenshot( HWND hWnd ) +{ + char buff[1024]; + + SetDlgItemText( hWnd, IDC_BUG_TAKESHOT_LABEL, "Working..." ); + + BugDlg_GetDataFileBase( g_bug_pReporter->GetUserName(), true, g_bug_szScreenshot, sizeof( g_bug_szScreenshot ) ); + strcat( g_bug_szScreenshot, ".bmp" ); + + // remove local version + unlink( g_bug_szScreenshot ); + + sprintf( buff, "*screenshot \"%s\"", g_bug_szScreenshot ); + if ( !ProcessCommand( buff ) ) + { + g_bug_szScreenshot[0] = '\0'; + } + + SetDlgItemText( hWnd, IDC_BUG_TAKESHOT_LABEL, g_bug_szScreenshot ); +} + +//----------------------------------------------------------------------------- +// BugDlg_SaveGame +// +//----------------------------------------------------------------------------- +void BugDlg_SaveGame( HWND hWnd ) +{ + char buff[1024]; + char savename[MAX_PATH]; + char remoteFile[MAX_PATH]; + + if ( !g_bug_mapInfo.savePath[0] ) + { + return; + } + + SetDlgItemText( hWnd, IDC_BUG_SAVEGAME_LABEL, "Working..." ); + + BugDlg_GetDataFileBase( g_bug_pReporter->GetUserName(), true, g_bug_szSavegame, sizeof( g_bug_szSavegame ) ); + Sys_StripPath( g_bug_szSavegame, savename, sizeof( savename ) ); + strcat( g_bug_szSavegame, ".360.sav" ); + + sprintf( remoteFile, "%s\\%s.360.sav", g_bug_mapInfo.savePath, savename ); + + // delete file locally + unlink( g_bug_szSavegame ); + + // delete file remotely + DmDeleteFile( remoteFile, false ); + + // save, and wait to ensure async completes + sprintf( buff, "save \"%s\" notmostrecent wait", savename ); + if ( !ProcessCommand( buff ) ) + { + // failed + g_bug_szSavegame[0] = '\0'; + } + else + { + DM_FILE_ATTRIBUTES fileAttributes; + for (int i=0; i<5; i++) + { + // wait for the save file to appear + HRESULT hr = DmGetFileAttributes( remoteFile, &fileAttributes ); + if ( hr == XBDM_NOERR ) + break; + + // wait for it + Sleep( 1000 ); + } + + HRESULT hr = DmReceiveFile( g_bug_szSavegame, remoteFile ); + if ( hr != XBDM_NOERR ) + { + // failed + g_bug_szSavegame[0] = '\0'; + } + } + + SetDlgItemText( hWnd, IDC_BUG_SAVEGAME_LABEL, g_bug_szSavegame ); +} + +//----------------------------------------------------------------------------- +// BugDlg_IncludeBSP +// +//----------------------------------------------------------------------------- +void BugDlg_IncludeBSP( HWND hWnd ) +{ + if ( !g_bug_mapInfo.mapPath[0] ) + { + return; + } + + SetDlgItemText( hWnd, IDC_BUG_INCLUDEBSP_LABEL, "Working..." ); + + BugDlg_GetDataFileBase( g_bug_pReporter->GetUserName(), true, g_bug_szBSPName, sizeof( g_bug_szBSPName ) ); + strcat( g_bug_szBSPName, ".360.bsp" ); + + // remove local version + unlink( g_bug_szBSPName ); + + // get the file locally + HRESULT hr = DmReceiveFile( g_bug_szBSPName, g_bug_mapInfo.mapPath ); + if ( hr != XBDM_NOERR ) + { + // failed + g_bug_szBSPName[0] = '\0'; + } + + SetDlgItemText( hWnd, IDC_BUG_INCLUDEBSP_LABEL, g_bug_szBSPName ); +} + +//----------------------------------------------------------------------------- +// BugDlg_ResetAndPopulate +// +//----------------------------------------------------------------------------- +void BugDlg_ResetAndPopulate( HWND hWnd, bool bFullReset = true ) +{ + // reset all fields + if ( bFullReset ) + { + g_bug_szTitle[0] = '\0'; + g_bug_szDescription[0] = '\0'; + } + g_bug_szOwner[0] = '\0'; + g_bug_szSeverity[0] = '\0'; + g_bug_szReportType[0] = '\0'; + g_bug_szPriority[0] = '\0'; + g_bug_szMapNumber[0] = '\0'; + + if ( bFullReset ) + { + g_bug_szScreenshot[0] = '\0'; + g_bug_szSavegame[0] = '\0'; + g_bug_szBSPName[0] = '\0'; + } + + g_bug_bCompressScreenshot = true; + + memset( &g_bug_mapInfo, 0, sizeof( g_bug_mapInfo ) ); + + // populate with reset fields + BugDlg_Populate( hWnd ); +} + +//----------------------------------------------------------------------------- +// BugDlg_Setup +// +//----------------------------------------------------------------------------- +void BugDlg_Setup( HWND hWnd ) +{ + g_bug_hWnd = hWnd; + + // clear stale data from app + g_bug_bFirstCommand = false; + memset( &g_bug_mapInfo, 0, sizeof( g_bug_mapInfo ) ); + + // always reset these fields + g_bug_szTitle[0] = '\0'; + g_bug_szDescription[0] = '\0'; + g_bug_szScreenshot[0] = '\0'; + g_bug_szSavegame[0] = '\0'; + g_bug_szBSPName[0] = '\0'; + + g_bug_bCompressScreenshot = true; + + memset( &g_bug_mapInfo, 0, sizeof( g_bug_mapInfo ) ); + + BugDlg_Populate( hWnd ); +} + +//----------------------------------------------------------------------------- +// BugDlg_UploadFile +// +//----------------------------------------------------------------------------- +bool BugDlg_UploadFile( char const *pLocalName, char const *pRemoteName, bool bDeleteLocal ) +{ + FILE *fp; + int len; + void *pLocalData; + + ConsoleWindowPrintf( BUG_COLOR, "Uploading %s to %s\n", pLocalName, pRemoteName ); + + len = Sys_LoadFile( pLocalName, &pLocalData ); + if ( !pLocalData || !len ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "UploadFile: Unable to open local path '%s'\n", pLocalName ); + return false; + } + + Sys_CreatePath( pRemoteName ); + + fp = fopen( pRemoteName, "wb" ); + if ( !fp ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "UploadFile: Unable to open remote path '%s'\n", pRemoteName ); + Sys_Free( pLocalData ); + return false; + } + + fwrite( pLocalData, len, 1, fp ); + + fclose( fp ); + Sys_Free( pLocalData ); + + if ( bDeleteLocal ) + { + unlink( pLocalName ); + } + + return true; +} + +//----------------------------------------------------------------------------- +// BugDlg_UploadBugSubmission +// +// Expects fully qualified source paths +//----------------------------------------------------------------------------- +bool BugDlg_UploadBugSubmission( int bugID, char const *pSavefile, char const *pScreenshot, char const *pBspFile, char const *pVmfFile ) +{ + char szFilename[MAX_PATH]; + char szLocalfile[MAX_PATH]; + char szRemotefile[MAX_PATH]; + bool bSuccess = true; + + if ( pSavefile && pSavefile[0] ) + { + V_snprintf( szLocalfile, sizeof( szLocalfile ), "%s", pSavefile ); + Sys_StripPath( pSavefile, szFilename, sizeof( szFilename ) ); + V_snprintf( szRemotefile, sizeof( szRemotefile ), "%s/%s", GetSubmissionURL( bugID ), szFilename ); + Sys_NormalizePath( szLocalfile, false ); + Sys_NormalizePath( szRemotefile, false ); + + if ( !BugDlg_UploadFile( szLocalfile, szRemotefile, false ) ) + { + bSuccess = false; + } + } + + if ( pScreenshot && pScreenshot[0] ) + { + V_snprintf( szLocalfile, sizeof( szLocalfile ), "%s", pScreenshot ); + Sys_StripPath( pScreenshot, szFilename, sizeof( szFilename ) ); + V_snprintf( szRemotefile, sizeof( szRemotefile ), "%s/%s", GetSubmissionURL( bugID ), szFilename ); + Sys_NormalizePath( szLocalfile, false ); + Sys_NormalizePath( szRemotefile, false ); + + if ( !BugDlg_UploadFile( szLocalfile, szRemotefile, true ) ) + { + bSuccess = false; + } + } + + if ( pBspFile && pBspFile[0] ) + { + V_snprintf( szLocalfile, sizeof( szLocalfile ), "%s", pBspFile ); + Sys_StripPath( pBspFile, szFilename, sizeof( szFilename ) ); + V_snprintf( szRemotefile, sizeof( szRemotefile ), "%s/%s", GetSubmissionURL( bugID ), szFilename ); + Sys_NormalizePath( szLocalfile, false ); + Sys_NormalizePath( szRemotefile, false ); + + if ( !BugDlg_UploadFile( szLocalfile, szRemotefile, true ) ) + { + bSuccess = false; + } + } + + return bSuccess; +} + +//----------------------------------------------------------------------------- +// BugDlg_Submit +// +//----------------------------------------------------------------------------- +bool BugDlg_Submit( HWND hWnd ) +{ + char title[1024]; + char miscInfo[1024]; + char basename[MAX_PATH]; + char filename[MAX_PATH]; + char positionName[MAX_PATH]; + char orientationName[MAX_PATH]; + char buildName[MAX_PATH]; + char mapName[MAX_PATH]; + bool bSuccess = false; + + sprintf( positionName, "%f %f %f", g_bug_mapInfo.position[0], g_bug_mapInfo.position[1], g_bug_mapInfo.position[2] ); + SetDlgItemText( g_bug_hWnd, IDC_BUG_POSITION_LABEL, positionName ); + + sprintf( orientationName, "%f %f %f", g_bug_mapInfo.angle[0], g_bug_mapInfo.angle[1], g_bug_mapInfo.angle[2] ); + SetDlgItemText( g_bug_hWnd, IDC_BUG_ORIENTATION_LABEL, orientationName ); + + sprintf( buildName, "%d", g_bug_mapInfo.build ); + SetDlgItemText( g_bug_hWnd, IDC_BUG_BUILD_LABEL, buildName ); + + V_FileBase( g_bug_mapInfo.mapPath, mapName, sizeof( mapName ) ); + char *pExtension = V_stristr( mapName, ".bsp" ); + if ( pExtension ) + { + *pExtension = '\0'; + } + pExtension = V_stristr( mapName, ".360" ); + if ( pExtension ) + { + *pExtension = '\0'; + } + + V_snprintf( miscInfo, sizeof( miscInfo ), "skill %d", g_bug_mapInfo.skill ); + + // Stuff bug data files up to server + g_bug_pReporter->StartNewBugReport(); + + g_bug_pReporter->SetOwner( g_bug_pReporter->GetUserNameForDisplayName( g_bug_szOwner ) ); + g_bug_pReporter->SetSubmitter( NULL ); + + if ( mapName[0] ) + V_snprintf( title, sizeof( title ), "%s: %s", mapName, g_bug_szTitle ); + else + V_snprintf( title, sizeof( title ), "%s", g_bug_szTitle ); + g_bug_pReporter->SetTitle( title ); + + g_bug_pReporter->SetDescription( g_bug_szDescription ); + g_bug_pReporter->SetLevel( mapName ); + g_bug_pReporter->SetPosition( positionName ); + g_bug_pReporter->SetOrientation( orientationName ); + g_bug_pReporter->SetBuildNumber( buildName ); + + g_bug_pReporter->SetSeverity( g_bug_szSeverity ); + g_bug_pReporter->SetPriority( g_bug_szPriority ); + g_bug_pReporter->SetArea( g_bug_szArea ); + g_bug_pReporter->SetMapNumber( g_bug_szMapNumber ); + g_bug_pReporter->SetReportType( g_bug_szReportType ); + g_bug_pReporter->SetMiscInfo( miscInfo ); + + g_bug_pReporter->SetDriverInfo( "" ); + g_bug_pReporter->SetExeName( "" ); + g_bug_pReporter->SetGameDirectory( "" ); + g_bug_pReporter->SetRAM( 0 ); + g_bug_pReporter->SetCPU( 0 ); + g_bug_pReporter->SetProcessor( "" ); + g_bug_pReporter->SetDXVersion( 0, 0, 0, 0 ); + g_bug_pReporter->SetOSVersion( "" ); + g_bug_pReporter->ResetIncludedFiles(); + g_bug_pReporter->SetZipAttachmentName( "" ); + + if ( g_bug_szScreenshot[0] ) + { + if ( g_bug_bCompressScreenshot ) + { + BugDlg_CompressScreenshot(); + } + + // strip the fully qualified path into filename only + Sys_StripPath( g_bug_szScreenshot, basename, sizeof( basename ) ); + V_snprintf( filename, sizeof( filename ), "%s/BugId/%s", GetRepositoryURL(), basename ); + Sys_NormalizePath( filename, false ); + g_bug_pReporter->SetScreenShot( filename ); + } + + if ( g_bug_szSavegame[0] ) + { + // strip the fully qualified path into filename only + Sys_StripPath( g_bug_szSavegame, basename, sizeof( basename ) ); + V_snprintf( filename, sizeof( filename ), "%s/BugId/%s", GetRepositoryURL(), basename ); + Sys_NormalizePath( filename, false ); + g_bug_pReporter->SetSaveGame( filename ); + } + + if ( g_bug_szBSPName[0] ) + { + // strip the fully qualified path into filename only + Sys_StripPath( g_bug_szBSPName, basename, sizeof( basename ) ); + V_snprintf( filename, sizeof( filename ), "%s/BugId/%s", GetRepositoryURL(), basename ); + Sys_NormalizePath( filename, false ); + g_bug_pReporter->SetBSPName( filename ); + } + + int bugID = -1; + + bSuccess = g_bug_pReporter->CommitBugReport( bugID ); + if ( bSuccess ) + { + if ( !BugDlg_UploadBugSubmission( bugID, g_bug_szSavegame, g_bug_szScreenshot, g_bug_szBSPName, NULL ) ) + { + Sys_MessageBox( BUG_ERRORTITLE, "Unable to upload files to bug repository!\n" ); + bSuccess = false; + } + } + else + { + Sys_MessageBox( BUG_ERRORTITLE, "Unable to post bug report to database!\n" ); + } + + if ( bSuccess ) + { + if ( g_Games[g_bug_GameType].bUsesSystem1 ) + { + ConsoleWindowPrintf( BUG_COLOR, "Bug Reporter: PVCS submission succeeded for bug! (%d)\n", bugID ); + } + else + { + ConsoleWindowPrintf( BUG_COLOR, "Bug Reporter: BugBait submission succeeded for bug!\n" ); + } + } + else + { + ConsoleWindowPrintf( XBX_CLR_RED, "Bug Reporter: Submission failed\n" ); + } + + return bSuccess; +} + +//----------------------------------------------------------------------------- +// BugDlg_Proc +// +//----------------------------------------------------------------------------- +BOOL CALLBACK BugDlg_Proc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + switch ( message ) + { + case WM_INITDIALOG: + BugDlg_Setup( hwnd ); + return ( TRUE ); + + case WM_COMMAND: + switch ( LOWORD( wParam ) ) + { + case IDC_BUG_TAKESHOT: + BugDlg_TakeScreenshot( hwnd ); + break; + + case IDC_BUG_SAVEGAME: + BugDlg_SaveGame( hwnd ); + break; + + case IDC_BUG_INCLUDEBSP: + BugDlg_IncludeBSP( hwnd ); + break; + + case IDC_BUG_INCLUDEVMF: + // not implemented, no reason to + break; + + case IDC_BUG_CLEARFORM: + BugDlg_ResetAndPopulate( hwnd ); + return TRUE; + + case IDC_BUG_UPDATE: + BugDlg_GetAppData( hwnd ); + return TRUE; + + case IDC_BUG_OWNER: + case IDC_BUG_SEVERITY: + case IDC_BUG_REPORTTYPE: + case IDC_BUG_PRIORITY: + case IDC_BUG_AREA: + case IDC_BUG_MAPNUMBER: + if ( g_bug_bActive && HIWORD( wParam ) == CBN_CLOSEUP ) + { + BugDlg_GetChanges( hwnd ); + return TRUE; + } + break; + + case IDC_BUG_GAME: + if ( HIWORD( wParam ) == CBN_CLOSEUP ) + { + if ( BugDlg_UpdateReporter( hwnd ) ) + { + // reporter changed, clear critical parts of form + BugDlg_ResetAndPopulate( hwnd, false ); + } + return TRUE; + } + break; + + case IDC_BUG_TITLE: + case IDC_BUG_DESCRIPTION: + if ( g_bug_bActive && HIWORD( wParam ) == EN_CHANGE ) + { + BugDlg_GetChanges( hwnd ); + return TRUE; + } + break; + + case IDC_BUG_COMPRESS_SCREENSHOT: + BugDlg_GetChanges( hwnd ); + return TRUE; + + case IDC_BUG_SUBMIT: + if ( !BugDlg_Submit( hwnd ) ) + break; + // fall through + case IDCANCEL: + case IDC_CANCEL: + if ( g_connectedToApp && g_bug_bFirstCommand ) + { + ProcessCommand( "unpause" ); + } + EndDialog( hwnd, wParam ); + return ( TRUE ); + } + break; + } + return ( FALSE ); +} + +//----------------------------------------------------------------------------- +// BugDlg_SaveConfig +// +//----------------------------------------------------------------------------- +void BugDlg_SaveConfig() +{ + Sys_SetRegistryString( "bug_owner", g_bug_szOwner ); + Sys_SetRegistryString( "bug_severity", g_bug_szSeverity ); + Sys_SetRegistryString( "bug_reporttype", g_bug_szReportType ); + Sys_SetRegistryString( "bug_priority", g_bug_szPriority ); + Sys_SetRegistryInteger( "bug_gametype", g_bug_GameType ); +} + +//----------------------------------------------------------------------------- +// BugDlg_LoadConfig +// +//----------------------------------------------------------------------------- +void BugDlg_LoadConfig() +{ + // get our config + Sys_GetRegistryString( "bug_owner", g_bug_szOwner, "", sizeof( g_bug_szOwner ) ); + Sys_GetRegistryString( "bug_severity", g_bug_szSeverity, "", sizeof( g_bug_szSeverity ) ); + Sys_GetRegistryString( "bug_reporttype", g_bug_szReportType, "", sizeof( g_bug_szReportType ) ); + Sys_GetRegistryString( "bug_priority", g_bug_szPriority, "", sizeof( g_bug_szPriority ) ); + Sys_GetRegistryInteger( "bug_gametype", 0, g_bug_GameType ); + + // start with expected reporter + BugReporter_SelectReporter( g_Games[g_bug_GameType].pGameName ); +} + +//----------------------------------------------------------------------------- +// BugDlg_Open +// +//----------------------------------------------------------------------------- +void BugDlg_Open( void ) +{ + int result; + + // need access to bug databases via DLLs + if ( !BugReporter_GetInterfaces() ) + { + return; + } + + BugDlg_LoadConfig(); + + result = DialogBox( g_hInstance, MAKEINTRESOURCE( IDD_BUG ), g_hDlgMain, ( DLGPROC )BugDlg_Proc ); + if ( LOWORD( result ) == IDC_BUG_SUBMIT ) + { + BugDlg_SaveConfig(); + } + + g_bug_hWnd = NULL; +} + +//----------------------------------------------------------------------------- +// BugDlg_Init +// +//----------------------------------------------------------------------------- +bool BugDlg_Init() +{ + return true; +} + +//----------------------------------------------------------------------------- +// rc_MapInfo +// +// Sent from application with bug dialog info +//----------------------------------------------------------------------------- +int rc_MapInfo( char* commandPtr ) +{ + char* cmdToken; + int errCode; + int infoAddr; + int retVal; + int retAddr; + char buff[128]; + + // success + errCode = 0; + + // get address of data + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &infoAddr ); + + // get retAddr + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &retAddr ); + + // get the caller's info data + DmGetMemory( ( void* )infoAddr, sizeof( xrMapInfo_t ), &g_bug_mapInfo, NULL ); + + // swap the structure + BigFloat( &g_bug_mapInfo.position[0], &g_bug_mapInfo.position[0] ); + BigFloat( &g_bug_mapInfo.position[1], &g_bug_mapInfo.position[1] ); + BigFloat( &g_bug_mapInfo.position[2], &g_bug_mapInfo.position[2] ); + BigFloat( &g_bug_mapInfo.angle[0], &g_bug_mapInfo.angle[0] ); + BigFloat( &g_bug_mapInfo.angle[1], &g_bug_mapInfo.angle[1] ); + BigFloat( &g_bug_mapInfo.angle[2], &g_bug_mapInfo.angle[2] ); + g_bug_mapInfo.build = BigDWord( g_bug_mapInfo.build ); + g_bug_mapInfo.skill = BigDWord( g_bug_mapInfo.skill ); + + Sys_NormalizePath( g_bug_mapInfo.savePath, false ); + Sys_NormalizePath( g_bug_mapInfo.mapPath, false ); + + if ( g_bug_hWnd ) + { + if ( g_bug_mapInfo.mapPath[0] ) + { + Sys_StripPath( g_bug_mapInfo.mapPath, buff, sizeof( buff ) ); + SetDlgItemText( g_bug_hWnd, IDC_BUG_MAP_LABEL, buff ); + + if ( !g_Games[g_bug_GameType].bUsesSystem1 ) + { + char *pExtension = V_stristr( buff, ".bsp" ); + if ( pExtension ) + { + *pExtension = '\0'; + } + pExtension = V_stristr( buff, ".360" ); + if ( pExtension ) + { + *pExtension = '\0'; + } + V_strncpy( g_bug_szMapNumber, buff, sizeof( g_bug_szMapNumber ) ); + + int curSel = SendDlgItemMessage( g_bug_hWnd, IDC_BUG_MAPNUMBER, CB_FINDSTRINGEXACT, (WPARAM)-1, (LPARAM)(LPCSTR)g_bug_szMapNumber ); + if ( curSel == CB_ERR ) + curSel = 0; + SendDlgItemMessage( g_bug_hWnd, IDC_BUG_MAPNUMBER, CB_SETCURSEL, curSel, 0 ); + } + + sprintf( buff, "%.2f %.2f %.2f", g_bug_mapInfo.position[0], g_bug_mapInfo.position[1], g_bug_mapInfo.position[2] ); + SetDlgItemText( g_bug_hWnd, IDC_BUG_POSITION_LABEL, buff ); + + sprintf( buff, "%.2f %.2f %.2f", g_bug_mapInfo.angle[0], g_bug_mapInfo.angle[1], g_bug_mapInfo.angle[2] ); + SetDlgItemText( g_bug_hWnd, IDC_BUG_ORIENTATION_LABEL, buff ); + } + else + { + SetDlgItemText( g_bug_hWnd, IDC_BUG_MAP_LABEL, "" ); + SetDlgItemText( g_bug_hWnd, IDC_BUG_POSITION_LABEL, "" ); + SetDlgItemText( g_bug_hWnd, IDC_BUG_ORIENTATION_LABEL, "" ); + } + + sprintf( buff, "%d", g_bug_mapInfo.build ); + SetDlgItemText( g_bug_hWnd, IDC_BUG_BUILD_LABEL, buff ); + + EnableWindow( GetDlgItem( g_bug_hWnd, IDC_BUG_SAVEGAME ), g_bug_mapInfo.savePath[0] != '\0' && g_bug_mapInfo.mapPath[0] != '\0' ); + EnableWindow( GetDlgItem( g_bug_hWnd, IDC_BUG_INCLUDEBSP ), g_bug_mapInfo.mapPath[0] != '\0' ); + } + + // return the result + retVal = 0; + int xboxRetVal = BigDWord( retVal ); + DmSetMemory( ( void* )retAddr, sizeof( int ), &xboxRetVal, NULL ); + + DebugCommand( "0x%8.8x = MapInfo( 0x%8.8x )\n", retVal, infoAddr ); + +cleanUp: + return errCode; +} + diff --git a/utils/xbox/vxconsole/common.cpp b/utils/xbox/vxconsole/common.cpp new file mode 100644 index 0000000..1b8418c --- /dev/null +++ b/utils/xbox/vxconsole/common.cpp @@ -0,0 +1,73 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// COMMON.CPP +// +// Common/Misc specialized support routines not uniquely owned. +//=====================================================================================// +#include "vxconsole.h" + +vprofState_e g_vprof_state = VPROF_OFF; + +//----------------------------------------------------------------------------- +// NotImplementedYet +// +//----------------------------------------------------------------------------- +void NotImplementedYet() +{ + Sys_MessageBox( "Attention!", "Sorry, Not Implemented Yet." ); +} + +//----------------------------------------------------------------------------- +// VProf_GetState +// +//----------------------------------------------------------------------------- +vprofState_e VProf_GetState() +{ + return g_vprof_state; +} + +//----------------------------------------------------------------------------- +// VProf_Enable +// +// Coordinates multiple vprof commands for proper exclusion +//----------------------------------------------------------------------------- +void VProf_Enable( vprofState_e state ) +{ + char commandString[256]; + + switch ( state ) + { + case VPROF_CPU: + strcpy( commandString, "vprof_off ; vprof_on ; vprof_update cpu" ); + break; + + case VPROF_TEXTURE: + strcpy( commandString, "vprof_off ; vprof_on ; vprof_update texture" ); + break; + + case VPROF_TEXTUREFRAME: + strcpy( commandString, "vprof_off ; vprof_on ; vprof_update texture_frame" ); + break; + + default: + state = VPROF_OFF; + strcpy( commandString, "vprof_off" ); + break; + + } + + // track state + if ( g_vprof_state != state ) + { + g_vprof_state = state; + + // do command + ProcessCommand( commandString ); + + // update all the dependant titles + CpuProfile_SetTitle(); + TexProfile_SetTitle(); + } +} + + diff --git a/utils/xbox/vxconsole/config.cpp b/utils/xbox/vxconsole/config.cpp new file mode 100644 index 0000000..85558d7 --- /dev/null +++ b/utils/xbox/vxconsole/config.cpp @@ -0,0 +1,217 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// CONFIG.CPP +// +// Configuration Dialog +//=====================================================================================// +#include "vxconsole.h" + +CHAR g_xboxTargetName[MAX_XBOXNAMELEN]; +char g_localPath[MAX_PATH]; +char g_targetPath[MAX_PATH]; +BOOL g_clsOnConnect; +BOOL g_loadSymbolsOnConnect; +char g_xexTargetPath[MAX_PATH]; +BOOL g_alwaysAutoConnect; +BOOL g_startMinimized; +char g_installPath[MAX_PATH]; +BOOL g_captureDebugSpew_StartupState; + +//----------------------------------------------------------------------------- +// ConfigDlg_LoadConfig +// +//----------------------------------------------------------------------------- +void ConfigDlg_LoadConfig() +{ + // get our config + Sys_GetRegistryString( "xboxName", g_xboxTargetName, "", sizeof( g_xboxTargetName ) ); + Sys_GetRegistryString( "localPath", g_localPath, "u:\\dev\\game", sizeof( g_localPath ) ); + Sys_GetRegistryString( "targetPath", g_targetPath, "e:\\valve", sizeof( g_targetPath ) ); + Sys_GetRegistryString( "installPath", g_installPath, "\\\\fileserver\\user\\xbox\\xbox_orange", sizeof( g_installPath ) ); + Sys_GetRegistryInteger( "clearOnConnect", true, g_clsOnConnect ); + Sys_GetRegistryInteger( "loadSymbolsOnConnect", false, g_loadSymbolsOnConnect ); + Sys_GetRegistryInteger( "alwaysAutoConnect", false, g_alwaysAutoConnect ); + Sys_GetRegistryInteger( "startMinimized", false, g_startMinimized ); + Sys_GetRegistryInteger( "captureDebugSpew", true, g_captureDebugSpew_StartupState ); +} + +//----------------------------------------------------------------------------- +// ConfigDlg_SaveConfig +// +//----------------------------------------------------------------------------- +void ConfigDlg_SaveConfig() +{ + // save config + Sys_SetRegistryString( "xboxName", g_xboxTargetName ); + Sys_SetRegistryString( "localPath", g_localPath ); + Sys_SetRegistryString( "targetPath", g_targetPath ); + Sys_SetRegistryString( "installPath", g_installPath ); + Sys_SetRegistryInteger( "clearOnConnect", g_clsOnConnect ); + Sys_SetRegistryInteger( "loadSymbolsOnConnect", g_loadSymbolsOnConnect ); + Sys_SetRegistryInteger( "alwaysAutoConnect", g_alwaysAutoConnect ); + Sys_SetRegistryInteger( "startMinimized", g_startMinimized ); + Sys_SetRegistryInteger( "captureDebugSpew", g_captureDebugSpew_StartupState ); + + // update + SetMainWindowTitle(); +} + +//----------------------------------------------------------------------------- +// ConfigDlg_Setup +// +//----------------------------------------------------------------------------- +void ConfigDlg_Setup( HWND hWnd ) +{ + SetDlgItemText( hWnd,IDC_CONFIG_XBOXNAME, g_xboxTargetName ); + SetDlgItemText( hWnd,IDC_CONFIG_LOCALPATH, g_localPath ); + SetDlgItemText( hWnd,IDC_CONFIG_TARGETPATH, g_targetPath ); + SetDlgItemText( hWnd,IDC_CONFIG_INSTALLPATH, g_installPath ); + + EnableWindow( GetDlgItem( hWnd, IDC_CONFIG_PING ), strlen( g_xboxTargetName ) > 0 ); + + CheckDlgButton( hWnd, IDC_CONFIG_CLEARONCONNECT, g_clsOnConnect ? BST_CHECKED : BST_UNCHECKED ); + CheckDlgButton( hWnd, IDC_CONFIG_ALWAYSAUTOCONNECT, g_alwaysAutoConnect ? BST_CHECKED : BST_UNCHECKED ); + CheckDlgButton( hWnd, IDC_CONFIG_STARTMINIMIZED, g_startMinimized ? BST_CHECKED : BST_UNCHECKED ); + CheckDlgButton( hWnd, IDC_CONFIG_CAPTUREDEBUGSPEW, g_captureDebugSpew_StartupState ? BST_CHECKED : BST_UNCHECKED ); +} + +//----------------------------------------------------------------------------- +// ConfigDlg_Ping +// +//----------------------------------------------------------------------------- +BOOL ConfigDlg_Ping( HWND hwnd ) +{ + char xboxName[MAX_XBOXNAMELEN]; + BOOL canConnect; + char* args[1]; + + xboxName[0] = '\0'; + GetDlgItemText( hwnd, IDC_CONFIG_XBOXNAME, xboxName, MAX_XBOXNAMELEN ); + + // ignore ping to current connection + if ( !stricmp( g_xboxName, xboxName ) ) + { + if ( g_connectedToXBox ) + { + Sys_MessageBox( "Ping", "Already Connected To: '%s'", xboxName ); + return true; + } + } + + // terminate any current connection + lc_disconnect( 0, NULL ); + + // trial connect + args[0] = xboxName; + canConnect = lc_connect( 1, args ); + + if ( !canConnect ) + Sys_MessageBox( "Ping FAILURE", "Could Not Connect To: %s", xboxName ); + else + Sys_MessageBox( "Ping SUCCESS", "Connection Valid To: %s", g_xboxName ); + + if ( canConnect ) + lc_disconnect( 0, NULL ); + + return canConnect; +} + +//----------------------------------------------------------------------------- +// ConfigDlg_GetChanges +// +//----------------------------------------------------------------------------- +bool ConfigDlg_GetChanges( HWND hwnd ) +{ + char remotePath[MAX_PATH]; + char localPath[MAX_PATH]; + char targetPath[MAX_PATH]; + char installPath[MAX_PATH]; + char xboxName[MAX_XBOXNAMELEN]; + char xexLocalPath[MAX_PATH]; + char xexTargetPath[MAX_PATH]; + + xboxName[0] = '\0'; + remotePath[0] = '\0'; + localPath[0] = '\0'; + targetPath[0] = '\0'; + xexLocalPath[0] = '\0'; + xexTargetPath[0] = '\0'; + + GetDlgItemText( hwnd, IDC_CONFIG_XBOXNAME, xboxName, MAX_XBOXNAMELEN ); + GetDlgItemText( hwnd, IDC_CONFIG_LOCALPATH, localPath, MAX_PATH ); + GetDlgItemText( hwnd, IDC_CONFIG_TARGETPATH, targetPath, MAX_PATH ); + GetDlgItemText( hwnd, IDC_CONFIG_INSTALLPATH, installPath, MAX_PATH ); + + strcpy( g_localPath, localPath ); + Sys_NormalizePath( g_localPath, true ); + + strcpy( g_targetPath, targetPath ); + Sys_NormalizePath( g_targetPath, true ); + + strcpy( g_installPath, installPath ); + Sys_NormalizePath( g_installPath, true ); + + strcpy( g_xboxTargetName, xboxName ); + + g_clsOnConnect = IsDlgButtonChecked( hwnd, IDC_CONFIG_CLEARONCONNECT ); + g_loadSymbolsOnConnect = IsDlgButtonChecked( hwnd, IDC_CONFIG_LOADSYMBOLS ); + g_alwaysAutoConnect = IsDlgButtonChecked( hwnd, IDC_CONFIG_ALWAYSAUTOCONNECT ); + g_startMinimized = IsDlgButtonChecked( hwnd, IDC_CONFIG_STARTMINIMIZED ); + g_captureDebugSpew_StartupState = IsDlgButtonChecked( hwnd, IDC_CONFIG_CAPTUREDEBUGSPEW ); + + // success + return ( true ); +} + +//----------------------------------------------------------------------------- +// ConfigDlg_Proc +// +//----------------------------------------------------------------------------- +BOOL CALLBACK ConfigDlg_Proc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + switch ( message ) + { + case WM_INITDIALOG: + ConfigDlg_Setup( hwnd ); + return ( TRUE ); + + case WM_COMMAND: + switch ( LOWORD( wParam ) ) + { + case IDC_CONFIG_PING: + ConfigDlg_Ping( hwnd ); + break; + + case IDC_CONFIG_XBOXNAME: + CHAR buff[MAX_XBOXNAMELEN]; + GetDlgItemText( hwnd, IDC_CONFIG_XBOXNAME, buff, sizeof( buff ) ); + EnableWindow( GetDlgItem( hwnd, IDC_CONFIG_PING ), strlen( buff ) > 0 ); + break; + + case IDC_OK: + if ( !ConfigDlg_GetChanges( hwnd ) ) + break; + case IDCANCEL: + case IDC_CANCEL: + EndDialog( hwnd, wParam ); + return ( TRUE ); + } + break; + } + return ( FALSE ); +} + +//----------------------------------------------------------------------------- +// ConfigDlg_Open +// +//----------------------------------------------------------------------------- +void ConfigDlg_Open( void ) +{ + int result; + + result = DialogBox( g_hInstance, MAKEINTRESOURCE( IDD_CONFIG ), g_hDlgMain, ( DLGPROC )ConfigDlg_Proc ); + if ( LOWORD( result ) != IDC_OK ) + return; + + ConfigDlg_SaveConfig(); +} diff --git a/utils/xbox/vxconsole/cpu_profile.cpp b/utils/xbox/vxconsole/cpu_profile.cpp new file mode 100644 index 0000000..57571e4 --- /dev/null +++ b/utils/xbox/vxconsole/cpu_profile.cpp @@ -0,0 +1,983 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// CPU_PROFILE.CPP +// +// Cpu Profiling Display +//=====================================================================================// +#include "vxconsole.h" + +#define PROFILE_MAXCOUNTERS 64 +#define PROFILE_MAXSAMPLES 512 + +#define PROFILE_HISTORY_TIMINGHEIGHT 100 +#define PROFILE_HISTORY_NUMMINORTICKS 3 +#define PROFILE_HISTORY_LABELWIDTH 50 +#define PROFILE_HISTORY_SCALESTEPS 5 +#define PROFILE_HISTORY_MINSCALE 0.3f +#define PROFILE_HISTORY_MAXSCALE 3.0f + +#define PROFILE_SAMPLES_ITEMHEIGHT 15 +#define PROFILE_SAMPLES_BARHEIGHT 10 +#define PROFILE_SAMPLES_TIMINGWIDTH 200 +#define PROFILE_SAMPLES_LABELWIDTH 150 +#define PROFILE_SAMPLES_LABELGAP 5 +#define PROFILE_SAMPLES_NUMMINORTICKS 3 +#define PROFILE_SAMPLES_PEAKHOLDTIME 3000 +#define PROFILE_SAMPLES_SCALESTEPS 10 +#define PROFILE_SAMPLES_MINSCALE 0.3f +#define PROFILE_SAMPLES_MAXSCALE 3.0f + +#define ID_CPUPROFILE_SAMPLES 1 +#define ID_CPUPROFILE_HISTORY 2 + +typedef struct +{ + unsigned int samples[PROFILE_MAXSAMPLES]; + unsigned int peakSample; + char label[64]; + COLORREF color; +} profileCounter_t; + +HWND g_cpuProfile_hWndSamples; +HWND g_cpuProfile_hWndHistory; +int g_cpuProfile_numCounters; +profileCounter_t g_cpuProfile_counters[PROFILE_MAXCOUNTERS]; +RECT g_cpuProfile_samplesWindowRect; +RECT g_cpuProfile_historyWindowRect; +DWORD g_cpuProfile_lastPeakTime; +bool g_cpuProfile_history_tickMarks = true; +bool g_cpuProfile_history_colors = true; +int g_cpuProfile_history_scale; +bool g_cpuProfile_samples_tickMarks = true; +bool g_cpuProfile_samples_colors = true; +int g_cpuProfile_samples_scale; +int g_cpuProfile_numSamples; +int g_cpuProfile_fpsLabels; + +//----------------------------------------------------------------------------- +// CpuProfile_SaveConfig +// +//----------------------------------------------------------------------------- +void CpuProfile_SaveConfig() +{ + char buff[256]; + WINDOWPLACEMENT wp; + + // profile samples + if ( g_cpuProfile_hWndSamples ) + { + memset( &wp, 0, sizeof( wp ) ); + wp.length = sizeof( WINDOWPLACEMENT ); + GetWindowPlacement( g_cpuProfile_hWndSamples, &wp ); + g_cpuProfile_samplesWindowRect = wp.rcNormalPosition; + sprintf( buff, "%d %d %d %d", wp.rcNormalPosition.left, wp.rcNormalPosition.top, wp.rcNormalPosition.right, wp.rcNormalPosition.bottom ); + Sys_SetRegistryString( "profileSamplesWindowRect", buff ); + } + Sys_SetRegistryInteger( "profileSamplesScale", g_cpuProfile_samples_scale ); + + // profile history + if ( g_cpuProfile_hWndHistory ) + { + memset( &wp, 0, sizeof( wp ) ); + wp.length = sizeof( WINDOWPLACEMENT ); + GetWindowPlacement( g_cpuProfile_hWndHistory, &wp ); + g_cpuProfile_historyWindowRect = wp.rcNormalPosition; + sprintf( buff, "%d %d %d %d", wp.rcNormalPosition.left, wp.rcNormalPosition.top, wp.rcNormalPosition.right, wp.rcNormalPosition.bottom ); + Sys_SetRegistryString( "profileHistoryWindowRect", buff ); + } + Sys_SetRegistryInteger( "profileHistoryScale", g_cpuProfile_history_scale ); + + Sys_SetRegistryInteger( "cpuProfileFpsLabels", g_cpuProfile_fpsLabels ); +} + +//----------------------------------------------------------------------------- +// CpuProfile_LoadConfig +// +//----------------------------------------------------------------------------- +void CpuProfile_LoadConfig() +{ + int numArgs; + char buff[256]; + + // profile samples + Sys_GetRegistryString( "profileSamplesWindowRect", buff, "", sizeof( buff ) ); + numArgs = sscanf( buff, "%d %d %d %d", &g_cpuProfile_samplesWindowRect.left, &g_cpuProfile_samplesWindowRect.top, &g_cpuProfile_samplesWindowRect.right, &g_cpuProfile_samplesWindowRect.bottom ); + if ( numArgs != 4 ) + memset( &g_cpuProfile_samplesWindowRect, 0, sizeof( g_cpuProfile_samplesWindowRect ) ); + Sys_GetRegistryInteger( "profileSamplesScale", 0, g_cpuProfile_samples_scale ); + if ( g_cpuProfile_samples_scale < -PROFILE_SAMPLES_SCALESTEPS || g_cpuProfile_samples_scale > PROFILE_SAMPLES_SCALESTEPS ) + g_cpuProfile_samples_scale = 0; + + // profile history + Sys_GetRegistryString( "profileHistoryWindowRect", buff, "", sizeof( buff ) ); + numArgs = sscanf( buff, "%d %d %d %d", &g_cpuProfile_historyWindowRect.left, &g_cpuProfile_historyWindowRect.top, &g_cpuProfile_historyWindowRect.right, &g_cpuProfile_historyWindowRect.bottom ); + if ( numArgs != 4 ) + memset( &g_cpuProfile_historyWindowRect, 0, sizeof( g_cpuProfile_historyWindowRect ) ); + Sys_GetRegistryInteger( "profileHistoryScale", 0, g_cpuProfile_history_scale ); + if ( g_cpuProfile_history_scale < -PROFILE_HISTORY_SCALESTEPS || g_cpuProfile_history_scale > PROFILE_HISTORY_SCALESTEPS ) + g_cpuProfile_history_scale = 0; + + Sys_GetRegistryInteger( "cpuProfileFpsLabels", 0, g_cpuProfile_fpsLabels ); +} + +//----------------------------------------------------------------------------- +// CpuProfile_SetTitle +// +//----------------------------------------------------------------------------- +void CpuProfile_SetTitle() +{ + char titleBuff[128]; + + if ( g_cpuProfile_hWndSamples ) + { + strcpy( titleBuff, "CPU Usage Snapshot" ); + if ( VProf_GetState() == VPROF_CPU ) + strcat( titleBuff, " [ON]" ); + + SetWindowText( g_cpuProfile_hWndSamples, titleBuff ); + } + + if ( g_cpuProfile_hWndHistory ) + { + strcpy( titleBuff, "CPU Usage History" ); + if ( VProf_GetState() == VPROF_CPU ) + strcat( titleBuff, " [ON]" ); + + SetWindowText( g_cpuProfile_hWndHistory, titleBuff ); + } +} + +//----------------------------------------------------------------------------- +// CpuProfile_UpdateWindow +// +//----------------------------------------------------------------------------- +void CpuProfile_UpdateWindow() +{ + if ( g_cpuProfile_hWndSamples && !IsIconic( g_cpuProfile_hWndSamples ) ) + { + // visible - force a client repaint + InvalidateRect( g_cpuProfile_hWndSamples, NULL, true ); + } + + if ( g_cpuProfile_hWndHistory && !IsIconic( g_cpuProfile_hWndHistory ) ) + { + // visible - force a client repaint + InvalidateRect( g_cpuProfile_hWndHistory, NULL, true ); + } +} + +//----------------------------------------------------------------------------- +// rc_SetCpuProfile +// +//----------------------------------------------------------------------------- +int rc_SetCpuProfile( char* commandPtr ) +{ + int i; + char* cmdToken; + int retAddr; + int errCode = -1; + xrProfile_t* localList; + int profileList; + int numProfiles; + int retVal; + + // get numProfiles + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken,"%x",&numProfiles ); + + // get profile attributes + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &profileList ); + + // get retAddr + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken,"%x",&retAddr ); + + localList = new xrProfile_t[numProfiles]; + memset( localList, 0, numProfiles*sizeof( xrProfile_t ) ); + + // get the caller's profile list + DmGetMemory( ( void* )profileList, numProfiles*sizeof( xrProfile_t ), localList, NULL ); + + g_cpuProfile_numCounters = numProfiles; + if ( g_cpuProfile_numCounters > PROFILE_MAXCOUNTERS-1 ) + g_cpuProfile_numCounters = PROFILE_MAXCOUNTERS-1; + + for ( i=0; i<g_cpuProfile_numCounters; i++ ) + { + // swap the structure + localList[i].color = BigDWord( localList[i].color ); + + // clear the old counter + memset( &g_cpuProfile_counters[i], 0, sizeof( profileCounter_t ) ); + + V_strncpy( g_cpuProfile_counters[i].label, localList[i].labelString, sizeof( g_cpuProfile_counters[i].label ) ); + g_cpuProfile_counters[i].color = localList[i].color; + } + + // build out the reserved last counter as total count + memset( &g_cpuProfile_counters[g_cpuProfile_numCounters], 0, sizeof( profileCounter_t ) ); + strcpy( g_cpuProfile_counters[g_cpuProfile_numCounters].label, "Total" ); + g_cpuProfile_counters[i].color = RGB( 255,255,255 ); + g_cpuProfile_numCounters++; + + // set the return code + retVal = g_cpuProfile_numCounters-1; + int xboxRetVal = BigDWord( retVal ); + DmSetMemory( ( void* )retAddr, sizeof( int ), &xboxRetVal, NULL ); + + DebugCommand( "0x%8.8x = SetCpuProfile( 0x%8.8x, 0x%8.8x )\n", retVal, numProfiles, profileList ); + + delete [] localList; + + // success + errCode = 0; + +cleanUp: + return ( errCode ); +} + +//----------------------------------------------------------------------------- +// rc_SetCpuProfileData +// +//----------------------------------------------------------------------------- +int rc_SetCpuProfileData( char* commandPtr ) +{ + int i; + int total; + char* cmdToken; + int errCode = -1; + int counters; + int currentSample; + bool newPeaks; + unsigned int localCounters[PROFILE_MAXCOUNTERS]; + DWORD newTime; + + // get profiles + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + { + goto cleanUp; + } + sscanf( cmdToken, "%x", &counters ); + + // get the caller's profile list + if ( g_cpuProfile_numCounters ) + { + DmGetMemory( ( void* )counters, ( g_cpuProfile_numCounters-1 )*sizeof( int ), localCounters, NULL ); + } + + // timeout peaks + newTime = Sys_GetSystemTime(); + if ( newTime - g_cpuProfile_lastPeakTime > PROFILE_SAMPLES_PEAKHOLDTIME ) + { + g_cpuProfile_lastPeakTime = newTime; + newPeaks = true; + } + else + { + newPeaks = false; + } + + // next sample + currentSample = g_cpuProfile_numSamples % PROFILE_MAXSAMPLES; + g_cpuProfile_numSamples++; + + total = 0; + for ( i=0; i<g_cpuProfile_numCounters; i++ ) + { + // swap + localCounters[i] = BigDWord( localCounters[i] ); + + if ( i != g_cpuProfile_numCounters-1 ) + { + g_cpuProfile_counters[i].samples[currentSample] = localCounters[i]; + total += localCounters[i]; + } + else + { + // reserved total counter + g_cpuProfile_counters[i].samples[currentSample] = total; + } + + if ( newPeaks || g_cpuProfile_counters[i].peakSample < g_cpuProfile_counters[i].samples[currentSample] ) + { + g_cpuProfile_counters[i].peakSample = g_cpuProfile_counters[i].samples[currentSample]; + } + } + + DebugCommand( "SetCpuProfileData( 0x%8.8x )\n", counters ); + + CpuProfile_UpdateWindow(); + + // success + errCode = 0; + +cleanUp: + return ( errCode ); +} + +//----------------------------------------------------------------------------- +// CpuProfile_ZoomIn +// +//----------------------------------------------------------------------------- +void CpuProfile_ZoomIn( int& scale, int numSteps ) +{ + scale++; + if ( scale > numSteps ) + { + scale = numSteps; + return; + } + CpuProfile_UpdateWindow(); +} + +//----------------------------------------------------------------------------- +// CpuProfile_ZoomOut +// +//----------------------------------------------------------------------------- +void CpuProfile_ZoomOut( int& scale, int numSteps ) +{ + scale--; + if ( scale < -numSteps ) + { + scale = -numSteps; + return; + } + CpuProfile_UpdateWindow(); +} + +//----------------------------------------------------------------------------- +// CpuProfile_CalcScale +// +//----------------------------------------------------------------------------- +float CpuProfile_CalcScale( int scale, int numSteps, float min, float max ) +{ + float t; + + // from integral scale [-numSteps..numSteps] to float scale [min..max] + t = ( float )( scale + numSteps )/( float )( 2*numSteps ); + t = min + t*( max-min ); + + return t; +} + +//----------------------------------------------------------------------------- +// ProfileSamples_Draw +// +//----------------------------------------------------------------------------- +void ProfileSamples_Draw( HDC hdc, RECT* clientRect ) +{ + int i; + int j; + int x; + int y; + int x0; + int y0; + int w; + float t; + float scale; + float sampleTime; + char labelBuff[128]; + HPEN hBlackPen; + HPEN hPenOld; + HPEN hGreyPen; + HBRUSH hColoredBrush; + HBRUSH hbrushOld; + HFONT hFontOld; + RECT rect; + int currentSample; + int numTicks; + int timingWidth; + int windowWidth; + int windowHeight; + + hBlackPen = CreatePen( PS_SOLID, 1, RGB( 0,0,0 ) ); + hGreyPen = CreatePen( PS_SOLID, 1, Sys_ColorScale( g_backgroundColor, 0.85f ) ); + hPenOld = ( HPEN )SelectObject( hdc, hBlackPen ); + hFontOld = SelectFont( hdc, g_hProportionalFont ); + + SetBkColor( hdc, g_backgroundColor ); + + // zoom + scale = CpuProfile_CalcScale( g_cpuProfile_samples_scale, PROFILE_SAMPLES_SCALESTEPS, PROFILE_SAMPLES_MINSCALE, PROFILE_SAMPLES_MAXSCALE ); + timingWidth = ( int )( PROFILE_SAMPLES_TIMINGWIDTH*scale ); + windowWidth = clientRect->right-clientRect->left; + windowHeight = clientRect->bottom-clientRect->top; + + numTicks = ( windowWidth-PROFILE_SAMPLES_LABELWIDTH )/timingWidth + 1; + if ( numTicks < 0 ) + numTicks = 1; + + rect.left = 0; + rect.right = PROFILE_SAMPLES_LABELWIDTH; + rect.top = 0; + rect.bottom = PROFILE_SAMPLES_ITEMHEIGHT; + DrawText( hdc, "Name", -1, &rect, DT_LEFT ); + + // draw timing ticks + x = PROFILE_SAMPLES_LABELWIDTH; + y = 0; + for ( i=0; i<numTicks; i++ ) + { + // tick labels + rect.left = x-40; + rect.right = x+40; + rect.top = y; + rect.bottom = y+PROFILE_SAMPLES_ITEMHEIGHT; + if ( !g_cpuProfile_fpsLabels ) + sprintf( labelBuff, "%.2fms", i*( 1000.0f/60.0f ) ); + else + sprintf( labelBuff, "%.2ffps", i == 0 ? 0 : 60.0f/i ); + DrawText( hdc, labelBuff, -1, &rect, DT_CENTER ); + + // major ticks + x0 = x; + y0 = y + PROFILE_SAMPLES_ITEMHEIGHT; + SelectObject( hdc, hBlackPen ); + MoveToEx( hdc, x0, y0, NULL ); + LineTo( hdc, x0, y0+windowHeight ); + + if ( g_cpuProfile_samples_tickMarks && g_cpuProfile_samples_scale > -PROFILE_SAMPLES_SCALESTEPS ) + { + // minor ticks + x0 = x; + y0 = y + PROFILE_SAMPLES_ITEMHEIGHT; + SelectObject( hdc, hGreyPen ); + for ( j=0; j<PROFILE_SAMPLES_NUMMINORTICKS; j++ ) + { + x0 += timingWidth/( PROFILE_SAMPLES_NUMMINORTICKS+1 ); + + MoveToEx( hdc, x0, y0, NULL ); + LineTo( hdc, x0, y0+windowHeight ); + } + } + x += timingWidth; + } + + // seperator + SelectObject( hdc, hBlackPen ); + MoveToEx( hdc, 0, PROFILE_SAMPLES_ITEMHEIGHT, NULL ); + LineTo( hdc, windowWidth, PROFILE_SAMPLES_ITEMHEIGHT ); + + // draw labels + x = 0; + y = PROFILE_SAMPLES_ITEMHEIGHT; + for ( i=0; i<g_cpuProfile_numCounters; i++ ) + { + if ( !g_cpuProfile_counters[i].label ) + continue; + + rect.left = x; + rect.right = x+PROFILE_SAMPLES_LABELWIDTH-PROFILE_SAMPLES_LABELGAP; + rect.top = y; + rect.bottom = y+PROFILE_SAMPLES_ITEMHEIGHT; + DrawText( hdc, g_cpuProfile_counters[i].label, -1, &rect, DT_VCENTER|DT_RIGHT|DT_SINGLELINE|DT_END_ELLIPSIS|DT_MODIFYSTRING ); + + // draw the under line + MoveToEx( hdc, x, y+PROFILE_SAMPLES_ITEMHEIGHT, NULL ); + LineTo( hdc, x+PROFILE_SAMPLES_LABELWIDTH, y+PROFILE_SAMPLES_ITEMHEIGHT ); + + y += PROFILE_SAMPLES_ITEMHEIGHT; + } + + // draw bars + SelectObject( hdc, hBlackPen ); + x = PROFILE_SAMPLES_LABELWIDTH; + y = PROFILE_SAMPLES_ITEMHEIGHT; + currentSample = g_cpuProfile_numSamples-1; + if ( currentSample < 0 ) + currentSample = 0; + else + currentSample %= PROFILE_MAXSAMPLES; + for ( i=0; i<g_cpuProfile_numCounters; i++ ) + { + if ( !g_cpuProfile_counters[i].label ) + continue; + + hColoredBrush = CreateSolidBrush( g_cpuProfile_samples_colors ? g_cpuProfile_counters[i].color : g_backgroundColor ); + hbrushOld = ( HBRUSH )SelectObject( hdc, hColoredBrush ); + + // bar - count is in us i.e. 1 major tick = 16667us + t = ( float )g_cpuProfile_counters[i].samples[currentSample]/( 1000000.0f/60.0f ); + w = ( int )( t * ( float )timingWidth ); + if ( w > windowWidth ) + w = windowWidth; + x0 = x; + y0 = y + ( PROFILE_SAMPLES_ITEMHEIGHT-PROFILE_SAMPLES_BARHEIGHT )/2 + 1; + Rectangle( hdc, x0, y0, x0 + w, y0 + PROFILE_SAMPLES_BARHEIGHT ); + + // peak + t = ( float )g_cpuProfile_counters[i].peakSample/( 1000000.0f/60.0f ); + w = ( int )( t * ( float )timingWidth ); + if ( w > windowWidth ) + w = windowWidth; + x0 = x + w; + y0 = y + PROFILE_SAMPLES_ITEMHEIGHT/2 + 1; + + POINT points[4]; + points[0].x = x0; + points[0].y = y0-4; + points[1].x = x0+4; + points[1].y = y0; + points[2].x = x0; + points[2].y = y0+4; + points[3].x = x0-4; + points[3].y = y0; + Polygon( hdc, points, 4 ); + + SelectObject( hdc, hbrushOld ); + DeleteObject( hColoredBrush ); + + // draw peak times + sampleTime = ( float )g_cpuProfile_counters[i].peakSample/1000.0f; + if ( sampleTime >= 0.01F ) + { + sprintf( labelBuff, "%.2f", sampleTime ); + rect.left = x0 + 8; + rect.right = x0 + 8 + 100; + rect.top = y; + rect.bottom = y + PROFILE_SAMPLES_ITEMHEIGHT; + DrawText( hdc, labelBuff, -1, &rect, DT_VCENTER|DT_LEFT|DT_SINGLELINE ); + } + + y += PROFILE_SAMPLES_ITEMHEIGHT; + } + + SelectObject( hdc, hFontOld ); + SelectObject( hdc, hPenOld ); + DeleteObject( hBlackPen ); + DeleteObject( hGreyPen ); +} + +//----------------------------------------------------------------------------- +// ProfileHistory_Draw +// +//----------------------------------------------------------------------------- +void ProfileHistory_Draw( HDC hdc, RECT* clientRect ) +{ + char labelBuff[128]; + HPEN hBlackPen; + HPEN hPenOld; + HPEN hNullPen; + HPEN hGreyPen; + HBRUSH hColoredBrush; + HBRUSH hBrushOld; + HFONT hFontOld; + int currentSample; + int numTicks; + int timingHeight; + int windowWidth; + int windowHeight; + int x; + int y; + int y0; + int i; + int j; + int h; + int numbars; + RECT rect; + float t; + float scale; + + hBlackPen = CreatePen( PS_SOLID, 1, RGB( 0,0,0 ) ); + hGreyPen = CreatePen( PS_SOLID, 1, Sys_ColorScale( g_backgroundColor, 0.85f ) ); + hNullPen = CreatePen( PS_NULL, 0, RGB( 0,0,0 ) ); + hPenOld = ( HPEN )SelectObject( hdc, hBlackPen ); + hFontOld = SelectFont( hdc, g_hProportionalFont ); + + // zoom + scale = CpuProfile_CalcScale( g_cpuProfile_history_scale, PROFILE_HISTORY_SCALESTEPS, PROFILE_HISTORY_MINSCALE, PROFILE_HISTORY_MAXSCALE ); + timingHeight = ( int )( PROFILE_HISTORY_TIMINGHEIGHT*scale ); + windowWidth = clientRect->right-clientRect->left; + windowHeight = clientRect->bottom-clientRect->top; + + numTicks = windowHeight/timingHeight + 2; + if ( numTicks < 0 ) + numTicks = 1; + + SetBkColor( hdc, g_backgroundColor ); + + x = 0; + y = windowHeight; + for ( i=0; i<numTicks; i++ ) + { + // major ticks + SelectObject( hdc, hBlackPen ); + MoveToEx( hdc, 0, y, NULL ); + LineTo( hdc, windowWidth, y ); + + if ( g_cpuProfile_history_tickMarks && g_cpuProfile_history_scale > -PROFILE_HISTORY_SCALESTEPS ) + { + // minor ticks + y0 = y; + SelectObject( hdc, hGreyPen ); + for ( j=0; j<PROFILE_HISTORY_NUMMINORTICKS; j++ ) + { + y0 += timingHeight/( PROFILE_SAMPLES_NUMMINORTICKS+1 ); + MoveToEx( hdc, 0, y0, NULL ); + LineTo( hdc, windowWidth, y0 ); + } + } + + // tick labels + if ( i ) + { + rect.left = windowWidth-50; + rect.right = windowWidth; + rect.top = y-20; + rect.bottom = y; + if ( !g_cpuProfile_fpsLabels ) + sprintf( labelBuff, "%.2fms", i*( 1000.0f/60.0f ) ); + else + sprintf( labelBuff, "%.2ffps", 60.0f/i ); + DrawText( hdc, labelBuff, -1, &rect, DT_RIGHT|DT_SINGLELINE|DT_BOTTOM ); + } + + y -= timingHeight; + } + + // vertical bars + if ( g_cpuProfile_numSamples ) + { + SelectObject( hdc, hNullPen ); + + numbars = windowWidth-PROFILE_HISTORY_LABELWIDTH; + currentSample = g_cpuProfile_numSamples-1; + for ( x=numbars-1; x>=0; x-=4 ) + { + // all the counters at this sample + y = windowHeight; + for ( j=0; j<g_cpuProfile_numCounters-1; j++ ) + { + if ( !g_cpuProfile_counters[j].label ) + continue; + + t = ( float )g_cpuProfile_counters[j].samples[currentSample % PROFILE_MAXSAMPLES]/( 1000000.0f/60.0f ); + h = ( int )( t * ( float )timingHeight ); + if ( h ) + { + if ( h > windowHeight ) + h = windowHeight; + + hColoredBrush = CreateSolidBrush( g_cpuProfile_history_colors ? g_cpuProfile_counters[j].color : RGB( 80,80,80 ) ); + hBrushOld = ( HBRUSH )SelectObject( hdc, hColoredBrush ); + + Rectangle( hdc, x-4, y-h, x, y+1 ); + y -= h; + + SelectObject( hdc, hBrushOld ); + DeleteObject( hColoredBrush ); + } + } + currentSample--; + if ( currentSample < 0 ) + { + // no data + break; + } + } + } + + SelectObject( hdc, hFontOld ); + SelectObject( hdc, hPenOld ); + DeleteObject( hBlackPen ); + DeleteObject( hGreyPen ); +} + +//----------------------------------------------------------------------------- +// CpuProfile_WndProc +// +//----------------------------------------------------------------------------- +LRESULT CALLBACK CpuProfile_WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + WORD wID = LOWORD( wParam ); + HDC hdc; + PAINTSTRUCT ps; + RECT rect; + int id; + bool bIsSamples; + bool bIsHistory; + CREATESTRUCT *createStructPtr; + + // identify window + id = ( int )GetWindowLong( hwnd, GWL_USERDATA+0 ); + bIsSamples = ( id == ID_CPUPROFILE_SAMPLES ); + bIsHistory = ( id == ID_CPUPROFILE_HISTORY ); + + switch ( message ) + { + case WM_CREATE: + // set the window identifier + createStructPtr = ( CREATESTRUCT* )lParam; + SetWindowLong( hwnd, GWL_USERDATA+0, ( LONG )createStructPtr->lpCreateParams ); + + // reset peaks + g_cpuProfile_lastPeakTime = 0; + return 0L; + + case WM_DESTROY: + CpuProfile_SaveConfig(); + + if ( bIsSamples ) + g_cpuProfile_hWndSamples = NULL; + else if ( bIsHistory ) + g_cpuProfile_hWndHistory = NULL; + + if ( VProf_GetState() == VPROF_CPU ) + { + VProf_Enable( VPROF_OFF ); + } + return 0L; + + case WM_INITMENU: + if ( bIsSamples ) + { + CheckMenuItem( ( HMENU )wParam, IDM_CPUPROFILE_TICKMARKS, MF_BYCOMMAND | ( g_cpuProfile_samples_tickMarks ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_CPUPROFILE_COLORS, MF_BYCOMMAND | ( g_cpuProfile_samples_colors ? MF_CHECKED : MF_UNCHECKED ) ); + } + else if ( bIsHistory ) + { + CheckMenuItem( ( HMENU )wParam, IDM_CPUPROFILE_TICKMARKS, MF_BYCOMMAND | ( g_cpuProfile_history_tickMarks ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_CPUPROFILE_COLORS, MF_BYCOMMAND | ( g_cpuProfile_history_colors ? MF_CHECKED : MF_UNCHECKED ) ); + } + CheckMenuItem( ( HMENU )wParam, IDM_CPUPROFILE_FPSLABELS, MF_BYCOMMAND | ( g_cpuProfile_fpsLabels ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_CPUPROFILE_ENABLE, MF_BYCOMMAND | ( VProf_GetState() == VPROF_CPU ? MF_CHECKED : MF_UNCHECKED ) ); + return 0L; + + case WM_PAINT: + GetClientRect( hwnd, &rect ); + hdc = BeginPaint( hwnd, &ps ); + if ( bIsSamples ) + ProfileSamples_Draw( hdc, &rect ); + else if ( bIsHistory ) + ProfileHistory_Draw( hdc, &rect ); + EndPaint( hwnd, &ps ); + return 0L; + + case WM_SIZE: + // force a redraw + CpuProfile_UpdateWindow(); + return 0L; + + case WM_KEYDOWN: + switch ( wParam ) + { + case VK_INSERT: + if ( bIsSamples ) + CpuProfile_ZoomIn( g_cpuProfile_samples_scale, PROFILE_SAMPLES_SCALESTEPS ); + else if ( bIsHistory ) + CpuProfile_ZoomIn( g_cpuProfile_history_scale, PROFILE_HISTORY_SCALESTEPS ); + return 0L; + + case VK_DELETE: + if ( bIsSamples ) + CpuProfile_ZoomOut( g_cpuProfile_samples_scale, PROFILE_SAMPLES_SCALESTEPS ); + else if ( bIsHistory ) + CpuProfile_ZoomOut( g_cpuProfile_history_scale, PROFILE_HISTORY_SCALESTEPS ); + return 0L; + } + break; + + case WM_COMMAND: + switch ( wID ) + { + case IDM_CPUPROFILE_TICKMARKS: + if ( bIsSamples ) + g_cpuProfile_samples_tickMarks ^= 1; + else if ( bIsHistory ) + g_cpuProfile_history_tickMarks ^= 1; + CpuProfile_UpdateWindow(); + return 0L; + + case IDM_CPUPROFILE_COLORS: + if ( bIsSamples ) + g_cpuProfile_samples_colors ^= 1; + else if ( bIsHistory ) + g_cpuProfile_history_colors ^= 1; + CpuProfile_UpdateWindow(); + return 0L; + + case IDM_CPUPROFILE_FPSLABELS: + g_cpuProfile_fpsLabels ^= 1; + CpuProfile_UpdateWindow(); + return 0L; + + case IDM_CPUPROFILE_ZOOMIN: + if ( bIsSamples ) + CpuProfile_ZoomIn( g_cpuProfile_samples_scale, PROFILE_SAMPLES_SCALESTEPS ); + else if ( bIsHistory ) + CpuProfile_ZoomIn( g_cpuProfile_history_scale, PROFILE_HISTORY_SCALESTEPS ); + return 0L; + + case IDM_CPUPROFILE_ZOOMOUT: + if ( bIsSamples ) + CpuProfile_ZoomOut( g_cpuProfile_samples_scale, PROFILE_SAMPLES_SCALESTEPS ); + else if ( bIsHistory ) + CpuProfile_ZoomOut( g_cpuProfile_history_scale, PROFILE_HISTORY_SCALESTEPS ); + return 0L; + + case IDM_CPUPROFILE_ENABLE: + bool bEnable = ( VProf_GetState() == VPROF_CPU ); + bEnable ^= 1; + if ( !bEnable ) + VProf_Enable( VPROF_OFF ); + else + VProf_Enable( VPROF_CPU ); + CpuProfile_SetTitle(); + return 0L; + } + break; + } + return ( DefWindowProc( hwnd, message, wParam, lParam ) ); +} + +//----------------------------------------------------------------------------- +// CpuProfileHistory_Open +// +//----------------------------------------------------------------------------- +void CpuProfileHistory_Open() +{ + HWND hWnd; + + if ( g_cpuProfile_hWndHistory ) + { + // only one profile instance + if ( IsIconic( g_cpuProfile_hWndHistory ) ) + ShowWindow( g_cpuProfile_hWndHistory, SW_RESTORE ); + SetForegroundWindow( g_cpuProfile_hWndHistory ); + return; + } + + if ( VProf_GetState() == VPROF_OFF ) + { + VProf_Enable( VPROF_CPU ); + } + + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + "CPUPROFILEHISTORYCLASS", + "", + WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX, + 0, + 0, + 600, + 500, + g_hDlgMain, + NULL, + g_hInstance, + ( void* )ID_CPUPROFILE_HISTORY ); + g_cpuProfile_hWndHistory = hWnd; + + CpuProfile_SetTitle(); + + if ( g_cpuProfile_historyWindowRect.right && g_cpuProfile_historyWindowRect.bottom ) + MoveWindow( g_cpuProfile_hWndHistory, g_cpuProfile_historyWindowRect.left, g_cpuProfile_historyWindowRect.top, g_cpuProfile_historyWindowRect.right-g_cpuProfile_historyWindowRect.left, g_cpuProfile_historyWindowRect.bottom-g_cpuProfile_historyWindowRect.top, FALSE ); + ShowWindow( g_cpuProfile_hWndHistory, SHOW_OPENWINDOW ); +} + +//----------------------------------------------------------------------------- +// CpuProfileSamples_Open +// +//----------------------------------------------------------------------------- +void CpuProfileSamples_Open() +{ + HWND hWnd; + + if ( g_cpuProfile_hWndSamples ) + { + // only one profile instance + if ( IsIconic( g_cpuProfile_hWndSamples ) ) + ShowWindow( g_cpuProfile_hWndSamples, SW_RESTORE ); + SetForegroundWindow( g_cpuProfile_hWndSamples ); + return; + } + + if ( VProf_GetState() == VPROF_OFF ) + { + VProf_Enable( VPROF_CPU ); + } + + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + "CPUPROFILESAMPLESCLASS", + "", + WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX, + 0, + 0, + 600, + 500, + g_hDlgMain, + NULL, + g_hInstance, + ( void* )ID_CPUPROFILE_SAMPLES ); + g_cpuProfile_hWndSamples = hWnd; + + CpuProfile_SetTitle(); + + if ( g_cpuProfile_samplesWindowRect.right && g_cpuProfile_samplesWindowRect.bottom ) + MoveWindow( g_cpuProfile_hWndSamples, g_cpuProfile_samplesWindowRect.left, g_cpuProfile_samplesWindowRect.top, g_cpuProfile_samplesWindowRect.right-g_cpuProfile_samplesWindowRect.left, g_cpuProfile_samplesWindowRect.bottom-g_cpuProfile_samplesWindowRect.top, FALSE ); + ShowWindow( g_cpuProfile_hWndSamples, SHOW_OPENWINDOW ); +} + +//----------------------------------------------------------------------------- +// CpuProfile_Clear +// +//----------------------------------------------------------------------------- +void CpuProfile_Clear() +{ + // clear counters and history + g_cpuProfile_numCounters = 0; + g_cpuProfile_numSamples = 0; + + CpuProfile_UpdateWindow(); +} + +//----------------------------------------------------------------------------- +// CpuProfile_Init +// +//----------------------------------------------------------------------------- +bool CpuProfile_Init() +{ + WNDCLASS wndclass; + + // set up our window class + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = CpuProfile_WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = 0; + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_APPLICATION]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = MAKEINTRESOURCE( MENU_CPUPROFILE ); + wndclass.lpszClassName = "CPUPROFILESAMPLESCLASS"; + if ( !RegisterClass( &wndclass ) ) + return false; + + // set up our window class + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = CpuProfile_WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = 0; + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_APPLICATION]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = MAKEINTRESOURCE( MENU_CPUPROFILE ); + wndclass.lpszClassName = "CPUPROFILEHISTORYCLASS"; + if ( !RegisterClass( &wndclass ) ) + return false; + + CpuProfile_LoadConfig(); + + return true; +} diff --git a/utils/xbox/vxconsole/exclude_paths.cpp b/utils/xbox/vxconsole/exclude_paths.cpp new file mode 100644 index 0000000..668a835 --- /dev/null +++ b/utils/xbox/vxconsole/exclude_paths.cpp @@ -0,0 +1,1134 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// EXCLUDE_PATHS.CPP +// +// DVD Exclude paths. +//=====================================================================================// +#include "vxconsole.h" + +#define UM_CHECKSTATECHANGE (WM_USER + 100) +#define UM_FIRSTTIMEPOPULATE (WM_USER + 101) + +#define MAX_TREE_DEPTH 32 +#define ROOT_NAME "Xbox:\\" +#define EXCLUDEPATHS_FILE "xbox_exclude_paths.txt" + +// known shipping 360 gamedirs +struct GameName_t +{ + const char *pName; + bool bIsModPath; +}; + +struct GamePath_t +{ + CUtlString pathName; + bool bIsModPath; +}; + +GameName_t g_GameNames[] = +{ + { "bin", false }, + { "platform", false }, + { "tf", true }, + { "portal", true }, + { "hl2", true }, + { "episodic", true }, + { "ep2", true } +}; + +CUtlVector< CUtlString > g_ExcludePaths; +BOOL g_bLinkGameDirs; + +inline bool PathLessThan( GamePath_t const &lhs, GamePath_t const &rhs ) +{ + if ( lhs.bIsModPath != rhs.bIsModPath ) + { + // sort mod paths to the bottom + return ( lhs.bIsModPath == false ); + } + + return ( stricmp( lhs.pathName.String(), rhs.pathName.String() ) < 0 ); +} +CUtlRBTree< GamePath_t > g_PathTable( 0, 0, PathLessThan ); + +//----------------------------------------------------------------------------- +// Add string to TreeView at specified level. Assumes an inorder insert. +// A node (at specified depth) must be inserted before it's children. +//----------------------------------------------------------------------------- +static HTREEITEM AddItemToTree( HWND hWndTree, LPSTR lpszItem, int nLevel, bool bIsModPath ) +{ + TVITEM tvi = { 0 }; + TVINSERTSTRUCT tvins = { 0 }; + static HTREEITEM s_hPrevItems[MAX_TREE_DEPTH]; + + if ( nLevel < 0 || nLevel >= MAX_TREE_DEPTH ) + { + Assert( 0 ); + return NULL; + } + + HTREEITEM hParent; + HTREEITEM hPrev; + if ( !nLevel ) + { + // one root item only, reset + for ( int i = 0; i < ARRAYSIZE( s_hPrevItems ); i++ ) + { + s_hPrevItems[i] = NULL; + } + hParent = TVI_ROOT; + hPrev = (HTREEITEM)TVI_FIRST; + } + else + { + hParent = s_hPrevItems[nLevel-1]; + hPrev = s_hPrevItems[nLevel]; + if ( !hParent ) + { + // parent should have been setup + Assert( 0 ); + return NULL; + } + if ( !hPrev ) + { + hPrev = TVI_FIRST; + } + } + + tvi.mask = TVIF_TEXT | TVIF_PARAM; + tvi.pszText = lpszItem; + tvi.cchTextMax = sizeof(tvi.pszText)/sizeof(tvi.pszText[0]); + tvi.lParam = (LPARAM)MAKELONG( nLevel, bIsModPath ); + + tvins.item = tvi; + tvins.hParent = hParent; + tvins.hInsertAfter = hPrev; + + // Add the item to the tree-view control. + hPrev = TreeView_InsertItem( hWndTree, &tvins ); + s_hPrevItems[nLevel] = hPrev; + + if ( nLevel > 0 ) + { + // set a back link to its parent + tvi.mask = TVIF_HANDLE; + tvi.hItem = TreeView_GetParent( hWndTree, hPrev ); + TreeView_SetItem( hWndTree, &tvi ); + } + + return hPrev; +} + +//----------------------------------------------------------------------------- +// Purpose: Get list of files from current path that match pattern +//----------------------------------------------------------------------------- +static int GetFileList( const char* pDirPath, const char* pPattern, CUtlVector< CUtlString > &fileList ) +{ + char sourcePath[MAX_PATH]; + char fullPath[MAX_PATH]; + bool bFindDirs; + + fileList.Purge(); + + strcpy( sourcePath, pDirPath ); + int len = (int)strlen( sourcePath ); + if ( !len ) + { + strcpy( sourcePath, ".\\" ); + } + else if ( sourcePath[len-1] != '\\' ) + { + sourcePath[len] = '\\'; + sourcePath[len+1] = '\0'; + } + + strcpy( fullPath, sourcePath ); + if ( pPattern[0] == '\\' && pPattern[1] == '\0' ) + { + // find directories only + bFindDirs = true; + strcat( fullPath, "*" ); + } + else + { + // find files, use provided pattern + bFindDirs = false; + strcat( fullPath, pPattern ); + } + + struct _finddata_t findData; + intptr_t h = _findfirst( fullPath, &findData ); + if ( h == -1 ) + { + return 0; + } + + do + { + // dos attribute complexities i.e. _A_NORMAL is 0 + if ( bFindDirs ) + { + // skip non dirs + if ( !( findData.attrib & _A_SUBDIR ) ) + continue; + } + else + { + // skip dirs + if ( findData.attrib & _A_SUBDIR ) + continue; + } + + if ( !stricmp( findData.name, "." ) ) + continue; + + if ( !stricmp( findData.name, ".." ) ) + continue; + + char fileName[MAX_PATH]; + strcpy( fileName, sourcePath ); + strcat( fileName, findData.name ); + + int j = fileList.AddToTail(); + fileList[j].Set( fileName ); + } + while ( !_findnext( h, &findData ) ); + + _findclose( h ); + + return fileList.Count(); +} + +//----------------------------------------------------------------------------- +// Purpose: Recursively determine directory tree +//----------------------------------------------------------------------------- +static void RecurseFileTree_r( const char *pBasePath, const char *pDirPath, int depth, CUtlVector< CUtlString > &dirList, bool bIsModPath ) +{ + if ( depth >= 2 ) + { + // too much unecessary detail + return; + } + + // ignore path roots, only interested in subdirs + const char *pSubName = pDirPath + strlen( pBasePath ); + if ( pSubName[0] ) + { + GamePath_t gamePath; + gamePath.pathName = pSubName; + gamePath.bIsModPath = bIsModPath; + + int iIndex = g_PathTable.Find( gamePath ); + if ( iIndex == g_PathTable.InvalidIndex() ) + { + g_PathTable.Insert( gamePath ); + } + } + + // recurse from source directory, get directories only + CUtlVector< CUtlString > fileList; + int dirCount = GetFileList( pDirPath, "\\", fileList ); + if ( !dirCount ) + { + // add directory name to search tree + int j = dirList.AddToTail(); + dirList[j].Set( pDirPath ); + return; + } + + for ( int i=0; i<dirCount; i++ ) + { + // form new path name, recurse into + RecurseFileTree_r( pBasePath, fileList[i].String(), depth+1, dirList, bIsModPath ); + } + + int j = dirList.AddToTail(); + dirList[j].Set( pDirPath ); +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_SetCheckState_r +// +// Propogate the check state to all children +//----------------------------------------------------------------------------- +void ExcludePathsDlg_SetCheckState_r( HWND hWndTree, HTREEITEM hTree, int depth, int checkState ) +{ + if ( !hTree ) + { + return; + } + + TreeView_SetCheckState( hWndTree, hTree, ( checkState == 1 ) ); + + TVITEM tvi = { 0 }; + tvi.mask = TVIF_HANDLE | TVIF_CHILDREN; + tvi.hItem = hTree; + if ( TreeView_GetItem( hWndTree, &tvi ) ) + { + if ( tvi.cChildren ) + { + HTREEITEM hChild = TreeView_GetChild( hWndTree, hTree ); + if ( hChild ) + { + ExcludePathsDlg_SetCheckState_r( hWndTree, hChild, depth+1, checkState ); + } + } + } + else + { + return; + } + + if ( !depth ) + { + // only iterate siblings of the parent's child + return; + } + + HTREEITEM hSibling = hTree; + while ( 1 ) + { + hSibling = TreeView_GetNextSibling( hWndTree, hSibling ); + if ( !hSibling ) + { + return; + } + + TreeView_SetCheckState( hWndTree, hSibling, ( checkState == 1 ) ); + + tvi.hItem = hSibling; + if ( TreeView_GetItem( hWndTree, &tvi ) ) + { + if ( tvi.cChildren ) + { + HTREEITEM hChild = TreeView_GetChild( hWndTree, hSibling ); + if ( hChild ) + { + ExcludePathsDlg_SetCheckState_r( hWndTree, hChild, depth+1, checkState ); + } + } + } + } +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_SetCheckStateLinked_r +// +// Propogate the check state to all "mod path" children that match the specified name. +// A NULL name matches all. +//----------------------------------------------------------------------------- +void ExcludePathsDlg_SetCheckStateLinked_r( HWND hWndTree, HTREEITEM hTree, int depth, int checkState, const char *pName ) +{ + if ( !hTree ) + { + return; + } + + char szNodeName[MAX_PATH]; + TVITEM tvi = { 0 }; + tvi.mask = TVIF_HANDLE | TVIF_CHILDREN | TVIF_TEXT | TVIF_PARAM; + tvi.hItem = hTree; + tvi.pszText = szNodeName; + tvi.cchTextMax = sizeof( szNodeName ); + if ( TreeView_GetItem( hWndTree, &tvi ) ) + { + bool bIsModPath = HIWORD( tvi.lParam ) != 0; + if ( bIsModPath && ( !pName || !V_stricmp( szNodeName, pName ) ) ) + { + TreeView_SetCheckState( hWndTree, hTree, ( checkState == 1 ) ); + } + + if ( tvi.cChildren ) + { + HTREEITEM hChild = TreeView_GetChild( hWndTree, hTree ); + if ( hChild ) + { + ExcludePathsDlg_SetCheckStateLinked_r( hWndTree, hChild, depth+1, checkState, pName ); + } + } + } + else + { + return; + } + + if ( !depth ) + { + // only iterate siblings of the parent's child + return; + } + + HTREEITEM hSibling = hTree; + while ( 1 ) + { + hSibling = TreeView_GetNextSibling( hWndTree, hSibling ); + if ( !hSibling ) + { + return; + } + + tvi.hItem = hSibling; + if ( TreeView_GetItem( hWndTree, &tvi ) ) + { + bool bIsModPath = HIWORD( tvi.lParam ) != 0; + if ( bIsModPath && ( !pName || !V_stricmp( szNodeName, pName ) ) ) + { + TreeView_SetCheckState( hWndTree, hSibling, ( checkState == 1 ) ); + } + + if ( tvi.cChildren ) + { + HTREEITEM hChild = TreeView_GetChild( hWndTree, hSibling ); + if ( hChild ) + { + ExcludePathsDlg_SetCheckStateLinked_r( hWndTree, hChild, depth+1, checkState, pName ); + } + } + } + } +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_GetCheckState_r +// +// Caller invokes at node. Returns with state set. +// State 0: unchecked, 1: checked, -1:unknown. +// Returns true if All children match, false otherwise. +//----------------------------------------------------------------------------- +bool ExcludePathsDlg_GetCheckState_r( HWND hWndTree, HTREEITEM hTree, int depth, int *pCheckState ) +{ + int checkState; + + checkState = TreeView_GetCheckState( hWndTree, hTree ); + if ( *pCheckState == -1 ) + { + *pCheckState = checkState; + } + else if ( *pCheckState != checkState ) + { + // disparate state, no need to recurse + return false; + } + + TVITEM tvi = { 0 }; + tvi.mask = TVIF_HANDLE | TVIF_CHILDREN; + tvi.hItem = hTree; + if ( TreeView_GetItem( hWndTree, &tvi ) ) + { + if ( tvi.cChildren ) + { + HTREEITEM hChild = TreeView_GetChild( hWndTree, hTree ); + if ( hChild ) + { + if ( !ExcludePathsDlg_GetCheckState_r( hWndTree, hChild, depth+1, pCheckState ) ) + { + return false; + } + } + } + } + else + { + return false; + } + + if ( !depth ) + { + // only iterate siblings of the parent's child + return true; + } + + HTREEITEM hSibling = hTree; + while ( 1 ) + { + hSibling = TreeView_GetNextSibling( hWndTree, hSibling ); + if ( !hSibling ) + { + break; + } + + checkState = TreeView_GetCheckState( hWndTree, hSibling ); + if ( *pCheckState != checkState ) + { + // disparate state, no need to recurse + return false; + } + + tvi.hItem = hSibling; + if ( TreeView_GetItem( hWndTree, &tvi ) ) + { + if ( tvi.cChildren ) + { + HTREEITEM hChild = TreeView_GetChild( hWndTree, hSibling ); + if ( hChild ) + { + if ( !ExcludePathsDlg_GetCheckState_r( hWndTree, hChild, depth+1, pCheckState ) ) + { + return false; + } + } + } + } + } + + return true; +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_Expand_r +// +// MaxDepth >= 0, Expand/Collapse up to specified depth. +//----------------------------------------------------------------------------- +void ExcludePathsDlg_Expand_r( HWND hWndTree, HTREEITEM hTree, int depth, int maxDepth, bool bExpand ) +{ + if ( !hTree ) + { + return; + } + + if ( maxDepth >= 0 && depth >= maxDepth ) + { + return; + } + + int flags; + if ( bExpand ) + flags = TVE_EXPAND; + else + flags = TVE_COLLAPSE; + + TVITEM tvi = { 0 }; + tvi.mask = TVIF_HANDLE | TVIF_CHILDREN; + tvi.hItem = hTree; + if ( TreeView_GetItem( hWndTree, &tvi ) ) + { + if ( tvi.cChildren ) + { + TreeView_Expand( hWndTree, hTree, flags ); + HTREEITEM hChild = TreeView_GetChild( hWndTree, hTree ); + if ( hChild ) + { + ExcludePathsDlg_Expand_r( hWndTree, hChild, depth+1, maxDepth, bExpand ); + } + } + } + else + { + return; + } + + if ( !depth ) + { + // only iterate siblings of the parent's child + return; + } + + HTREEITEM hSibling = hTree; + while ( 1 ) + { + hSibling = TreeView_GetNextSibling( hWndTree, hSibling ); + if ( !hSibling ) + { + return; + } + + tvi.hItem = hSibling; + if ( TreeView_GetItem( hWndTree, &tvi ) ) + { + if ( tvi.cChildren ) + { + TreeView_Expand( hWndTree, hSibling, flags ); + HTREEITEM hChild = TreeView_GetChild( hWndTree, hSibling ); + if ( hChild ) + { + ExcludePathsDlg_Expand_r( hWndTree, hChild, depth+1, maxDepth, bExpand ); + } + } + } + } +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_ExpandToShowState_r +// +//----------------------------------------------------------------------------- +void ExcludePathsDlg_ExpandToShowState_r( HWND hWndTree, HTREEITEM hTree, int depth ) +{ + if ( !hTree ) + { + return; + } + + TVITEM tvi = { 0 }; + tvi.mask = TVIF_HANDLE | TVIF_CHILDREN; + tvi.hItem = hTree; + if ( TreeView_GetItem( hWndTree, &tvi ) ) + { + int checkState = -1; + bool bStateIsSame = ExcludePathsDlg_GetCheckState_r( hWndTree, hTree, 0, &checkState ); + + if ( tvi.cChildren && !bStateIsSame ) + { + TreeView_Expand( hWndTree, hTree, TVE_EXPAND ); + HTREEITEM hChild = TreeView_GetChild( hWndTree, hTree ); + if ( hChild ) + { + ExcludePathsDlg_ExpandToShowState_r( hWndTree, hChild, depth+1 ); + } + } + } + else + { + return; + } + + if ( !depth ) + { + // only iterate siblings of the parent's child + return; + } + + HTREEITEM hSibling = hTree; + while ( 1 ) + { + hSibling = TreeView_GetNextSibling( hWndTree, hSibling ); + if ( !hSibling ) + { + return; + } + + tvi.hItem = hSibling; + if ( TreeView_GetItem( hWndTree, &tvi ) ) + { + int checkState = -1; + bool bStateIsSame = ExcludePathsDlg_GetCheckState_r( hWndTree, hSibling, 0, &checkState ); + + if ( tvi.cChildren && !bStateIsSame ) + { + TreeView_Expand( hWndTree, hSibling, TVE_EXPAND ); + HTREEITEM hChild = TreeView_GetChild( hWndTree, hSibling ); + if ( hChild ) + { + ExcludePathsDlg_ExpandToShowState_r( hWndTree, hChild, depth+1 ); + } + } + } + } +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_Find_r +// +//----------------------------------------------------------------------------- +HTREEITEM ExcludePathsDlg_Find_r( HWND hWndTree, HTREEITEM hTree, int depth, const char *pBasePath, const char *pFindPath ) +{ + TVITEM tvi = { 0 }; + char szName[MAX_PATH]; + tvi.mask = TVIF_HANDLE | TVIF_CHILDREN | TVIF_TEXT; + tvi.hItem = hTree; + tvi.pszText = szName; + tvi.cchTextMax = sizeof( szName ); + if ( !TreeView_GetItem( hWndTree, &tvi ) ) + { + return NULL; + } + + char szPath[MAX_PATH]; + V_ComposeFileName( pBasePath, szName, szPath, sizeof( szPath ) ); + if ( !stricmp( szPath, pFindPath ) ) + { + return hTree; + } + + if ( tvi.cChildren ) + { + HTREEITEM hChild = TreeView_GetChild( hWndTree, hTree ); + if ( hChild ) + { + HTREEITEM hFindTree = ExcludePathsDlg_Find_r( hWndTree, hChild, depth+1, szPath, pFindPath ); + if ( hFindTree ) + { + return hFindTree; + } + } + } + + if ( !depth ) + { + // only iterate siblings of the parent's child + return NULL; + } + + // iterate siblings + HTREEITEM hSibling = hTree; + while ( 1 ) + { + hSibling = TreeView_GetNextSibling( hWndTree, hSibling ); + if ( !hSibling ) + { + break; + } + + tvi.hItem = hSibling; + if ( !TreeView_GetItem( hWndTree, &tvi ) ) + { + break; + } + + V_ComposeFileName( pBasePath, szName, szPath, sizeof( szPath ) ); + if ( !stricmp( szPath, pFindPath ) ) + { + return hSibling; + } + + if ( tvi.cChildren ) + { + HTREEITEM hChild = TreeView_GetChild( hWndTree, hSibling ); + if ( hChild ) + { + HTREEITEM hFindTree = ExcludePathsDlg_Find_r( hWndTree, hChild, depth+1, szPath, pFindPath ); + if ( hFindTree ) + { + return hFindTree; + } + } + } + } + + return NULL; +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_BuildExcludeList_r +// +// An exclude path represents the path head, and thus does not need to iterate its children +// if they are deemed to the same exclusion state. +//----------------------------------------------------------------------------- +void ExcludePathsDlg_BuildExcludeList_r( HWND hWndTree, HTREEITEM hTree, int depth, const char *pPath ) +{ + int checkState = -1; + bool bStateIsSame = ExcludePathsDlg_GetCheckState_r( hWndTree, hTree, 0, &checkState ); + if ( checkState == -1 ) + { + return; + } + + TVITEM tvi = { 0 }; + char szName[MAX_PATH]; + tvi.mask = TVIF_HANDLE | TVIF_CHILDREN | TVIF_TEXT; + tvi.hItem = hTree; + tvi.pszText = szName; + tvi.cchTextMax = sizeof( szName ); + if ( !TreeView_GetItem( hWndTree, &tvi ) ) + { + return; + } + + char szPath[MAX_PATH]; + V_ComposeFileName( pPath, szName, szPath, sizeof( szPath ) ); + + if ( checkState == 1 && ( bStateIsSame || !tvi.cChildren ) ) + { + // add to exclude list + g_ExcludePaths.AddToTail( szPath ); + } + + if ( !bStateIsSame && tvi.cChildren ) + { + // mixed states, must recurse to resolve + HTREEITEM hChild = TreeView_GetChild( hWndTree, hTree ); + if ( hChild ) + { + ExcludePathsDlg_BuildExcludeList_r( hWndTree, hChild, depth+1, szPath ); + } + } + + if ( !depth ) + { + // only iterate siblings of the parent's child + return; + } + + // iterate siblings + HTREEITEM hSibling = hTree; + while ( 1 ) + { + hSibling = TreeView_GetNextSibling( hWndTree, hSibling ); + if ( !hSibling ) + { + break; + } + + checkState = -1; + bStateIsSame = ExcludePathsDlg_GetCheckState_r( hWndTree, hSibling, 0, &checkState ); + if ( checkState == -1 ) + { + break; + } + + tvi.hItem = hSibling; + if ( !TreeView_GetItem( hWndTree, &tvi ) ) + { + break; + } + + V_ComposeFileName( pPath, szName, szPath, sizeof( szPath ) ); + + if ( checkState == 1 && ( bStateIsSame || !tvi.cChildren ) ) + { + // add to exclude list + g_ExcludePaths.AddToTail( szPath ); + } + + if ( !bStateIsSame && tvi.cChildren ) + { + HTREEITEM hChild = TreeView_GetChild( hWndTree, hSibling ); + if ( hChild ) + { + ExcludePathsDlg_BuildExcludeList_r( hWndTree, hChild, depth+1, szPath ); + } + } + } +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_SaveChanges +// +//----------------------------------------------------------------------------- +void ExcludePathsDlg_SaveChanges( HWND hWnd ) +{ + g_ExcludePaths.Purge(); + HWND hWndTree = GetDlgItem( hWnd, IDC_PATHS_TREE ); + ExcludePathsDlg_BuildExcludeList_r( hWndTree, TreeView_GetRoot( hWndTree ), 0, "" ); + + char szPath[MAX_PATH]; + V_ComposeFileName( g_localPath, EXCLUDEPATHS_FILE, szPath, sizeof( szPath ) ); + + if ( !g_ExcludePaths.Count() ) + { + // no exclude paths + unlink( szPath ); + } + else + { + FILE *fp = fopen( szPath, "wt" ); + if ( !fp ) + { + Sys_MessageBox( "Error", "Could not open '%s' for writing\n", szPath ); + return; + } + + fprintf( fp, "// Auto-Generated by VXConsole - DO NOT MODIFY!\n" ); + for ( int i = 0; i < g_ExcludePaths.Count(); i++ ) + { + // strip expected root path + const char *pPath = g_ExcludePaths[i].String(); + pPath += strlen( ROOT_NAME ); + if ( !pPath[0] ) + { + // special code for root + fprintf( fp, "*\n" ); + break; + } + fprintf( fp, "\"\\%s\"\n", pPath ); + } + fclose( fp ); + } +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_Populate +// +// Generate a path table. +//----------------------------------------------------------------------------- +void ExcludePathsDlg_Populate( HWND hWnd, bool bRefresh ) +{ + struct GamePath_t + { + CUtlString pathName; + bool bIsModPath; + }; + + CUtlVector< GamePath_t > gamePaths; + + // can skip the time consuming directory scan, unless forced + if ( bRefresh || !g_PathTable.Count() ) + { + g_PathTable.Purge(); + + for ( int i = 0; i < ARRAYSIZE( g_GameNames ); i++ ) + { + char szTargetPath[MAX_PATH]; + V_strncpy( szTargetPath, g_localPath, sizeof( szTargetPath ) ); + V_AppendSlash( szTargetPath, sizeof( szTargetPath ) ); + V_strncat( szTargetPath, g_GameNames[i].pName, sizeof( szTargetPath ) ); + + GamePath_t gamePath; + gamePath.pathName = szTargetPath; + gamePath.bIsModPath = g_GameNames[i].bIsModPath; + gamePaths.AddToTail( gamePath ); + } + + // iterate all game paths + for ( int i = 0; i < gamePaths.Count(); i++ ) + { + CUtlVector< CUtlString > dirList; + RecurseFileTree_r( g_localPath, gamePaths[i].pathName.String(), 0, dirList, gamePaths[i].bIsModPath ); + } + } + + // reset the tree + HWND hWndTree = GetDlgItem( hWnd, IDC_PATHS_TREE ); + TreeView_DeleteAllItems( hWndTree ); + + // reset and add root + // only the root is at depth 0 + AddItemToTree( hWndTree, ROOT_NAME, 0, false ); + + // build the tree view + for ( int iIndex = g_PathTable.FirstInorder(); iIndex != g_PathTable.InvalidIndex(); iIndex = g_PathTable.NextInorder( iIndex ) ) + { + // due to sorting, number of slashes is depth + const char *pString = g_PathTable[iIndex].pathName.String(); + int depth = 0; + for ( int j = 0; j < (int)strlen( pString ); j++ ) + { + if ( pString[j] == '\\' ) + { + depth++; + } + } + if ( !depth ) + { + depth = 1; + } + + char szPath[MAX_PATH]; + V_FileBase( pString, szPath, sizeof( szPath ) ); + AddItemToTree( hWndTree, szPath, depth, g_PathTable[iIndex].bIsModPath ); + } + + HTREEITEM hTreeRoot = TreeView_GetRoot( hWndTree ); + for ( int i = 0; i < g_ExcludePaths.Count(); i++ ) + { + HTREEITEM hTree = ExcludePathsDlg_Find_r( hWndTree, hTreeRoot, 0, "", g_ExcludePaths[i].String() ); + if ( hTree ) + { + ExcludePathsDlg_SetCheckState_r( hWndTree, hTree, 0, true ); + } + } + + // expand the root node to show state + ExcludePathsDlg_ExpandToShowState_r( hWndTree, hTreeRoot, 0 ); +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_Setup +// +//----------------------------------------------------------------------------- +void ExcludePathsDlg_Setup( HWND hWnd ) +{ + TreeView_SetBkColor( GetDlgItem( hWnd, IDC_PATHS_TREE ), g_backgroundColor ); + + CheckDlgButton( hWnd, IDC_PATHS_LINKGAMEDIRS, g_bLinkGameDirs ? BST_CHECKED : BST_UNCHECKED ); + + // read the exisiting exclude paths + g_ExcludePaths.Purge(); + char szFilename[MAX_PATH]; + V_ComposeFileName( g_localPath, EXCLUDEPATHS_FILE, szFilename, sizeof( szFilename ) ); + if ( Sys_Exists( szFilename ) ) + { + Sys_LoadScriptFile( szFilename ); + while ( 1 ) + { + char *pToken = Sys_GetToken( true ); + if ( !pToken || !pToken[0] ) + { + break; + } + Sys_StripQuotesFromToken( pToken ); + if ( !stricmp( pToken, "*" ) ) + { + pToken = ""; + } + else if ( pToken[0] == '\\' ) + { + pToken++; + } + + char szPath[MAX_PATH]; + V_ComposeFileName( ROOT_NAME, pToken, szPath, sizeof( szPath ) ); + V_FixSlashes( szPath ); + + g_ExcludePaths.AddToTail( szPath ); + } + } +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_Proc +// +//----------------------------------------------------------------------------- +BOOL CALLBACK ExcludePathsDlg_Proc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + HWND hWndTree; + LPNMHDR lpnmh; + HTREEITEM hTree; + HTREEITEM hTreeRoot; + int checkState; + static bool s_bAllowPopulate = 0; + + switch ( message ) + { + case WM_INITDIALOG: + ExcludePathsDlg_Setup( hWnd ); + s_bAllowPopulate = true; + return TRUE; + + case WM_NOTIFY: + lpnmh = (LPNMHDR)lParam; + if ( ( lpnmh->code == NM_CLICK ) && ( lpnmh->idFrom == IDC_PATHS_TREE ) ) + { + TVHITTESTINFO ht = {0}; + DWORD dwpos = GetMessagePos(); + ht.pt.x = GET_X_LPARAM( dwpos ); + ht.pt.y = GET_Y_LPARAM( dwpos ); + MapWindowPoints( HWND_DESKTOP, lpnmh->hwndFrom, &ht.pt, 1 ); + TreeView_HitTest( lpnmh->hwndFrom, &ht ); + if ( ht.flags & TVHT_ONITEMSTATEICON ) + { + PostMessage( hWnd, UM_CHECKSTATECHANGE, 0, (LPARAM)ht.hItem ); + } + } + break; + + case UM_CHECKSTATECHANGE: + hWndTree = GetDlgItem( hWnd, IDC_PATHS_TREE ); + hTreeRoot = TreeView_GetRoot( hWndTree ); + hTree = (HTREEITEM)lParam; + checkState = TreeView_GetCheckState( hWndTree, hTree ); + if ( checkState != -1 ) + { + TVITEM tvi = { 0 }; + char szName[MAX_PATH]; + tvi.mask = TVIF_HANDLE | TVIF_PARAM | TVIF_TEXT; + tvi.hItem = hTree; + tvi.pszText = szName; + tvi.cchTextMax = sizeof( szName ); + if ( !TreeView_GetItem( hWndTree, &tvi ) ) + { + break; + } + int nDepth = LOWORD( tvi.lParam ); + bool bIsModPath = HIWORD( tvi.lParam ) != 0; + + if ( g_bLinkGameDirs && bIsModPath ) + { + // a mod path root is at depth 1 + // a child of a mod path (depth > 1), will match all other children in mod paths + // a mod path (depth = 1) will match all other modpaths + ExcludePathsDlg_SetCheckStateLinked_r( hWndTree, hTreeRoot, 0, checkState, nDepth == 1 ? NULL : szName ); + } + else + { + ExcludePathsDlg_SetCheckState_r( hWndTree, hTree, 0, checkState ); + } + } + break; + + case WM_PAINT: + if ( s_bAllowPopulate ) + { + // unfortunate, but tree view needs to paint first before its state can be set + // related to checkbox style which doesn't manifest until after WM_INITDIALOG + // stall the initial population until after the first paint + s_bAllowPopulate = false; + PostMessage( hWnd, UM_FIRSTTIMEPOPULATE, 0, 0 ); + } + break; + + case UM_FIRSTTIMEPOPULATE: + ExcludePathsDlg_Populate( hWnd, false ); + break; + + case WM_COMMAND: + switch ( LOWORD( wParam ) ) + { + case IDC_OK: + ExcludePathsDlg_SaveChanges( hWnd ); + EndDialog( hWnd, wParam ); + return TRUE; + + case IDC_PATHS_RESCAN: + ExcludePathsDlg_Populate( hWnd, true ); + return TRUE; + + case IDC_PATHS_EXPAND: + // expand from root + hWndTree = GetDlgItem( hWnd, IDC_PATHS_TREE ); + ExcludePathsDlg_Expand_r( hWndTree, TreeView_GetRoot( hWndTree ), 0, -1, true ); + return TRUE; + + case IDC_PATHS_COLLAPSE: + // collapse from root + hWndTree = GetDlgItem( hWnd, IDC_PATHS_TREE ); + ExcludePathsDlg_Expand_r( hWndTree, TreeView_GetRoot( hWndTree ), 0, -1, false ); + return TRUE; + + case IDC_PATHS_LINKGAMEDIRS: + g_bLinkGameDirs = IsDlgButtonChecked( hWnd, IDC_PATHS_LINKGAMEDIRS ); + return TRUE; + + case IDCANCEL: + case IDC_CANCEL: + EndDialog( hWnd, wParam ); + return TRUE; + } + break; + } + return FALSE; +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_LoadConfig +// +//----------------------------------------------------------------------------- +void ExcludePathsDlg_LoadConfig() +{ + // get our config + Sys_GetRegistryInteger( "ExcludePaths_LinkGameDirs", true, g_bLinkGameDirs ); +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_SaveConfig +// +//----------------------------------------------------------------------------- +void ExcludePathsDlg_SaveConfig() +{ + Sys_SetRegistryInteger( "ExcludePaths_LinkGameDirs", g_bLinkGameDirs ); +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_Init +// +//----------------------------------------------------------------------------- +bool ExcludePathsDlg_Init() +{ + return true; +} + +//----------------------------------------------------------------------------- +// ExcludePathsDlg_Open +// +//----------------------------------------------------------------------------- +void ExcludePathsDlg_Open() +{ + ExcludePathsDlg_LoadConfig(); + + int result = DialogBox( g_hInstance, MAKEINTRESOURCE( IDD_EXCLUDEPATHS ), g_hDlgMain, ( DLGPROC )ExcludePathsDlg_Proc ); + if ( LOWORD( result ) != IDC_OK ) + return; + + ExcludePathsDlg_SaveConfig(); +} diff --git a/utils/xbox/vxconsole/fileio.cpp b/utils/xbox/vxconsole/fileio.cpp new file mode 100644 index 0000000..9b9ca25 --- /dev/null +++ b/utils/xbox/vxconsole/fileio.cpp @@ -0,0 +1,416 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// FILEIO.CPP +// +// File I/O Service Routines +//=====================================================================================// +#include "vxconsole.h" + +//----------------------------------------------------------------------------- +// SystemTimeToString +// +// mm/dd/yyyy hh:mm:ss am +//----------------------------------------------------------------------------- +char *SystemTimeToString( SYSTEMTIME *systemTime, char *buffer, int bufferSize ) +{ + char timeString[256]; + char dateString[256]; + int length; + + GetDateFormat( LOCALE_SYSTEM_DEFAULT, 0, systemTime, "MM'/'dd'/'yyyy", dateString, sizeof( dateString ) ); + GetTimeFormat( LOCALE_SYSTEM_DEFAULT, 0, systemTime, "hh':'mm':'ss tt", timeString, sizeof( timeString ) ); + length = _snprintf( buffer, bufferSize, "%s %s", dateString, timeString ); + if ( length == -1 ) + buffer[bufferSize-1] = '\0'; + + return buffer; +} + +//----------------------------------------------------------------------------- +// CompareFileTimes_NTFStoFATX +// +//----------------------------------------------------------------------------- +int CompareFileTimes_NTFStoFATX( FILETIME* ntfsFileTime, char *ntfsTimeString, int ntfsStringSize, FILETIME* fatxFileTime, char *fatxTimeString, int fatxStringSize ) +{ + SYSTEMTIME ntfsSystemTime; + SYSTEMTIME fatxSystemTime; + int diff; + int ntfsSeconds; + int fatxSeconds; + + TIME_ZONE_INFORMATION tzInfo; + GetTimeZoneInformation( &tzInfo ); + + // cannot compare UTC file times directly + // disjoint filesystems - xbox has a +/- 2s error + // daylight savings time handling on each file system may cause problems + FileTimeToSystemTime( ntfsFileTime, &ntfsSystemTime ); + FileTimeToSystemTime( fatxFileTime, &fatxSystemTime ); + + // operate on local times, assumes xbox and pc are both set for same time zone and daylight saving + SYSTEMTIME ntfsLocalTime; + SYSTEMTIME fatxLocalTime; + SystemTimeToTzSpecificLocalTime( &tzInfo, &ntfsSystemTime, &ntfsLocalTime ); + SystemTimeToTzSpecificLocalTime( &tzInfo, &fatxSystemTime, &fatxLocalTime ); + + if ( ntfsTimeString ) + { + SystemTimeToString( &ntfsLocalTime, ntfsTimeString, ntfsStringSize ); + } + + if ( fatxTimeString ) + { + SystemTimeToString( &fatxLocalTime, fatxTimeString, fatxStringSize ); + } + + diff = ntfsLocalTime.wYear-fatxLocalTime.wYear; + if ( diff ) + return diff; + + diff = ntfsLocalTime.wMonth-fatxLocalTime.wMonth; + if ( diff ) + return diff; + + diff = ntfsLocalTime.wDay-fatxLocalTime.wDay; + if ( diff ) + return diff; + + diff = ntfsLocalTime.wHour-fatxLocalTime.wHour; + if ( diff ) + return diff; + + // allow for +/- 3s error + ntfsSeconds = ntfsLocalTime.wHour*60*60 + ntfsLocalTime.wMinute*60 + ntfsLocalTime.wSecond; + fatxSeconds = fatxLocalTime.wHour*60*60 + fatxLocalTime.wMinute*60 + fatxLocalTime.wSecond; + + diff = ntfsSeconds-fatxSeconds; + if ( diff > 3 || diff < -3 ) + return diff; + + // times are considered equal + return 0; +} + +//----------------------------------------------------------------------------- +// FreeTargetFileList +// +//----------------------------------------------------------------------------- +void FreeTargetFileList( fileNode_t* pFileList ) +{ + fileNode_t *nodePtr; + fileNode_t *nextPtr; + + if ( !pFileList ) + return; + + nodePtr = pFileList; + while ( nodePtr ) + { + nextPtr = nodePtr->nextPtr; + + Sys_Free( nodePtr->filename ); + Sys_Free( nodePtr ); + + nodePtr = nextPtr; + } +} + +//----------------------------------------------------------------------------- +// GetTargetFileList_r +// +//----------------------------------------------------------------------------- +bool GetTargetFileList_r( char* targetPath, bool recurse, int attributes, int level, fileNode_t** pFileList ) +{ + HRESULT hr; + PDM_WALK_DIR pWalkDir = NULL; + DM_FILE_ATTRIBUTES fileAttr; + bool valid; + char filename[MAX_PATH]; + fileNode_t* nodePtr; + bool bGetNormal; + int fixedAttributes; + + if ( !level ) + *pFileList = NULL; + + fixedAttributes = attributes; + if ( fixedAttributes & FILE_ATTRIBUTE_NORMAL ) + { + fixedAttributes &= ~FILE_ATTRIBUTE_NORMAL; + bGetNormal = true; + } + else + bGetNormal = false; + + while ( 1 ) + { + hr = DmWalkDir( &pWalkDir, targetPath, &fileAttr ); + if ( hr != XBDM_NOERR ) + break; + + strcpy( filename, targetPath ); + Sys_AddFileSeperator( filename, sizeof( filename ) ); + strcat( filename, fileAttr.Name ); + + // restrict to desired attributes + if ( ( bGetNormal && !fileAttr.Attributes ) || ( fileAttr.Attributes & fixedAttributes ) ) + { + Sys_NormalizePath( filename, false ); + + // create a new file node + nodePtr = ( fileNode_t* )Sys_Alloc( sizeof( fileNode_t ) ); + + // link it in + nodePtr->filename = Sys_CopyString( filename ); + nodePtr->changeTime = fileAttr.ChangeTime; + nodePtr->creationTime = fileAttr.CreationTime; + nodePtr->sizeHigh = fileAttr.SizeHigh; + nodePtr->sizeLow = fileAttr.SizeLow; + nodePtr->attributes = fileAttr.Attributes; + nodePtr->level = level; + nodePtr->nextPtr = *pFileList; + *pFileList = nodePtr; + } + + if ( fileAttr.Attributes & FILE_ATTRIBUTE_DIRECTORY ) + { + if ( recurse ) + { + // descend into directory + valid = GetTargetFileList_r( filename, recurse, attributes, level+1, pFileList ); + if ( !valid ) + return false; + } + } + } + DmCloseDir( pWalkDir ); + + if ( hr != XBDM_ENDOFLIST ) + { + // failure + return false; + } + + // ok + return true; +} + +//----------------------------------------------------------------------------- +// FileSyncEx +// +// -1: failure, 0: nothing, 1: synced +//----------------------------------------------------------------------------- +int FileSyncEx( const char* localFilename, const char* targetFilename, int fileSyncMode, bool bVerbose, bool bNoWrite ) +{ + bool copy; + bool pathExist; + WIN32_FILE_ATTRIBUTE_DATA localAttributes; + DM_FILE_ATTRIBUTES targetAttributes; + HRESULT hr; + int errCode; + int deltaTime; + char localTimeString[256]; + char targetTimeString[256]; + + if ( ( fileSyncMode & FSYNC_TYPEMASK ) == FSYNC_OFF ) + { + return 0; + } + + if ( !GetFileAttributesEx( localFilename, GetFileExInfoStandard, &localAttributes ) ) + { + // failed to get the local file's attributes + if ( bVerbose ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "Sync Failure: Local file %s not available\n", localFilename ); + } + return -1; + } + + if ( localAttributes.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) + { + // ignore directory + return 0; + } + + if ( fileSyncMode & FSYNC_ANDEXISTSONTARGET ) + { + hr = DmGetFileAttributes( targetFilename, &targetAttributes ); + if ( hr != XBDM_NOERR ) + { + // target doesn't exist, no sync operation should commence + if ( bVerbose ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "No Update, Target file %s not available\n", targetFilename ); + } + return 0; + } + } + + // default success, no operation + errCode = 0; + + // default, create path and copy + copy = true; + pathExist = false; + + if ( ( fileSyncMode & FSYNC_TYPEMASK ) == FSYNC_IFNEWER ) + { + hr = DmGetFileAttributes( targetFilename, &targetAttributes ); + if ( hr == XBDM_NOERR ) + { + // target path to file exists + pathExist = true; + + // compare times + deltaTime = CompareFileTimes_NTFStoFATX( &localAttributes.ftLastWriteTime, localTimeString, sizeof( localTimeString), &targetAttributes.ChangeTime, targetTimeString, sizeof( targetTimeString ) ); + if ( deltaTime < 0 ) + { + // ntfs is older, fatx is newer, no update + if ( bVerbose ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "No Update, %s [%s] is newer than %s [%s]\n", targetFilename, targetTimeString, localFilename, localTimeString ); + } + copy = false; + } + else if ( !deltaTime ) + { + // equal times, compare sizes + if ( localAttributes.nFileSizeLow == targetAttributes.SizeLow && + localAttributes.nFileSizeHigh == targetAttributes.SizeHigh ) + { + // file appears synced + copy = false; + } + if ( bVerbose ) + { + if ( copy ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Update, %s [%s] [%d] has different size than %s [%s] [%d]\n", targetFilename, targetTimeString, targetAttributes.SizeLow, localFilename, localTimeString, localAttributes.nFileSizeLow ); + } + else + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "No Update, %s [%s] [%d] has same time and file size as %s [%s] [%d]\n", targetFilename, targetTimeString, targetAttributes.SizeLow, localFilename, localTimeString, localAttributes.nFileSizeLow ); + } + } + } + else + { + // ntfs is newer, fatx is older, update + if ( bVerbose ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Update, %s [%s] is older than %s [%s]\n", targetFilename, targetTimeString, localFilename, localTimeString ); + } + } + } + } + else if ( ( fileSyncMode & FSYNC_TYPEMASK ) == FSYNC_ALWAYS ) + { + if ( bVerbose ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Force Update, %s\n", targetFilename ); + } + } + + if ( copy && !bNoWrite ) + { + if ( !pathExist ) + { + CreateTargetPath( targetFilename ); + } + + hr = DmSendFile( localFilename, targetFilename ); + if ( hr == XBDM_NOERR ) + { + // force the target to match the local attributes + // to ensure sync + memset( &targetAttributes, 0, sizeof( targetAttributes ) ); + targetAttributes.SizeHigh = localAttributes.nFileSizeHigh; + targetAttributes.SizeLow = localAttributes.nFileSizeLow; + targetAttributes.CreationTime = localAttributes.ftCreationTime; + targetAttributes.ChangeTime = localAttributes.ftLastWriteTime; + DmSetFileAttributes( targetFilename, &targetAttributes ); + + // success, file copied + errCode = 1; + } + else + { + // failure + if ( bVerbose ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "Sync Failed!\n" ); + } + errCode = -1; + } + + DebugCommand( "0x%8.8x = FileSyncEx( %s, %s )\n", hr, localFilename, targetFilename ); + } + + return errCode; +} + +//----------------------------------------------------------------------------- +// LoadTargetFile +// +//----------------------------------------------------------------------------- +bool LoadTargetFile( const char *pTargetPath, int *pFileSize, void **pData ) +{ + DM_FILE_ATTRIBUTES fileAttributes; + HRESULT hr; + DWORD bytesRead; + char *pBuffer; + + *pFileSize = 0; + *pData = (void *)NULL; + + hr = DmGetFileAttributes( pTargetPath, &fileAttributes ); + if ( hr != XBDM_NOERR || !fileAttributes.SizeLow ) + return false; + + // allocate for size and terminating null + pBuffer = (char *)Sys_Alloc( fileAttributes.SizeLow+1 ); + + hr = DmReadFilePartial( pTargetPath, 0, (LPBYTE)pBuffer, fileAttributes.SizeLow, &bytesRead ); + if ( hr != XBDM_NOERR || ( bytesRead != fileAttributes.SizeLow ) ) + { + Sys_Free( pBuffer ); + return false; + } + + // add a terminating null + pBuffer[fileAttributes.SizeLow] = '\0'; + + *pFileSize = fileAttributes.SizeLow; + *pData = pBuffer; + + // success + return true; +} + +//----------------------------------------------------------------------------- +// CreateTargetPath +// +//----------------------------------------------------------------------------- +bool CreateTargetPath( const char *pTargetFilename ) +{ + // create path chain + char *pPath; + char dirPath[MAX_PATH]; + + // prime and skip to first seperator + strcpy( dirPath, pTargetFilename ); + pPath = strchr( dirPath, '\\' ); + while ( pPath ) + { + pPath = strchr( pPath+1, '\\' ); + if ( pPath ) + { + *pPath = '\0'; + DmMkdir( dirPath ); + *pPath = '\\'; + } + } + + return true; +} diff --git a/utils/xbox/vxconsole/icon_connect1.ico b/utils/xbox/vxconsole/icon_connect1.ico Binary files differnew file mode 100644 index 0000000..dd373b0 --- /dev/null +++ b/utils/xbox/vxconsole/icon_connect1.ico diff --git a/utils/xbox/vxconsole/icon_connect2.ico b/utils/xbox/vxconsole/icon_connect2.ico Binary files differnew file mode 100644 index 0000000..638dd28 --- /dev/null +++ b/utils/xbox/vxconsole/icon_connect2.ico diff --git a/utils/xbox/vxconsole/icon_connect2a.ico b/utils/xbox/vxconsole/icon_connect2a.ico Binary files differnew file mode 100644 index 0000000..61473ea --- /dev/null +++ b/utils/xbox/vxconsole/icon_connect2a.ico diff --git a/utils/xbox/vxconsole/icon_disconnect.ico b/utils/xbox/vxconsole/icon_disconnect.ico Binary files differnew file mode 100644 index 0000000..2146fe3 --- /dev/null +++ b/utils/xbox/vxconsole/icon_disconnect.ico diff --git a/utils/xbox/vxconsole/local_cmds.cpp b/utils/xbox/vxconsole/local_cmds.cpp new file mode 100644 index 0000000..05e5cdb --- /dev/null +++ b/utils/xbox/vxconsole/local_cmds.cpp @@ -0,0 +1,1307 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// LOCAL_CMDS.CPP +// +// Local commands ( *xxxx ) executed by this application. +//=====================================================================================// +#include "vxconsole.h" + +localCommand_t g_localCommands[] = +{ + // Command name, Flags Handler Help string + // console commands + { "*cls", FN_CONSOLE, lc_cls, ": Clear the screen" }, + { "*connect", FN_CONSOLE, lc_autoConnect, ": Connect and listen until successful" }, + { "*disconnect", FN_CONSOLE, lc_disconnect, ": Terminate Debug Console session" }, + { "*help", FN_CONSOLE, lc_help, "[command] : List commands/usage" }, + { "*quit", FN_CONSOLE, lc_quit, ": Terminate console" }, + { "*run", FN_XBOX, lc_run, "[app.xex] : Run application or Reboot" }, + { "*reset", FN_XBOX, lc_reset, "Reboot" }, + { "*screenshot", FN_XBOX, lc_screenshot, "<file.bmp> : Copy the screen to file.bmp" }, + { "*memory", FN_APP, lc_memory, ": Dump Memory Stats" }, + { "*dir", FN_XBOX, lc_dir, "<filepath> [/s]: Directory listing" }, + { "*del", FN_XBOX, lc_del, "<filepath> [/s] [/q]: Delete file" }, + { "*modules", FN_XBOX, lc_modules, ": Lists currently loaded modules" }, + { "*sections", FN_XBOX, lc_sections, "<module> : Lists the sections in the module" }, + { "*bug", FN_CONSOLE, lc_bug, ": Open bug submission form" }, + { "*clearconfigs", FN_XBOX, lc_ClearConfigs, ": Erase all game configs" }, + + // xcommands + { "*break", FN_XBOX, NULL, " addr=<address> | 'Write'/'Read'/'Execute'=<address> size=<DataSize> ['clear']: Sets/Clears a breakpoint" }, +// { "*bye", FN_XBOX, NULL, ": Closes connection" }, + { "*continue", FN_XBOX, NULL, " thread=<threadid>: Resumes execution of a thread which has been stopped" }, +// { "*delete", FN_XBOX, NULL, " name=<remotefile>: Deletes a file on the Xbox" }, +// { "*dirlist", FN_XBOX, NULL, " name=<remotedir>: Lists the items in the directory" }, + { "*getcontext", FN_XBOX, NULL, " thread=<threadid> 'Control' | 'Int' | 'FP' | 'Full': Gets the context of the thread" }, + { "*getfileattributes", FN_XBOX, NULL, " name=<remotefile>: Gets attributes of a file" }, + { "*getmem", FN_XBOX, NULL, " addr=<address> length=<len>: Reads memory from the Xbox" }, + { "*go", FN_XBOX, NULL, ": Resumes suspended title threads" }, + { "*halt", FN_XBOX, NULL, " thread=<threadid> Breaks a thread" }, + { "*isstopped", FN_XBOX, NULL, " thread=<threadid>: Determines if a thread is stopped and why" }, + { "*mkdir", FN_XBOX, NULL, " name=<remotedir>: Creates a new directory on the Xbox" }, + { "*modlong", FN_XBOX, NULL, " name=<module>: Lists the long name of the module" }, +// { "*reboot", FN_XBOX, NULL, " [warm] [wait]: Reboots the xbox" }, + { "*rename", FN_XBOX, NULL, " name=<remotefile> newname=<newname>: Renames a file on the Xbox" }, + { "*resume", FN_XBOX, NULL, " thread=<threadid>: Resumes thread execution" }, + { "*setcontext", FN_XBOX, NULL, " thread=<threadid>: Sets the context of the thread." }, + { "*setfileattributes", FN_XBOX, NULL, " <remotefile> <attrs>: Sets attributes of a file" }, + { "*setmem", FN_XBOX, NULL, " addr=<address> data=<rawdata>: Sets memory on the Xbox" }, + { "*stop", FN_XBOX, NULL, ": Stops the process" }, + { "*suspend", FN_XBOX, NULL, " thread=<threadid>: Suspends the thread" }, + { "*systime", FN_XBOX, NULL, ": Gets the system time of the xbox" }, + { "*threadinfo", FN_XBOX, NULL, " thread=<threadid>: Gets thread info" }, + { "*threads", FN_XBOX, lc_threads, ": Gets the thread list" }, +// { "*title", FN_XBOX, NULL, " dir=<remotedir> name=<remotexex> [cmdline=<cmdline>]: Sets title to run" }, + { "*xexinfo", FN_XBOX, NULL, " name=<remotexex | 'running'>: Gets info on an xex" }, + { "*crash", FN_XBOX, lc_crashdump, " crash the console, emitting a dump" }, +}; +const int g_numLocalCommands = sizeof( g_localCommands )/sizeof( g_localCommands[0] ); + +static BOOL g_bAutoConnectQuiet; +static int g_bAutoConnectWait; + +//----------------------------------------------------------------------------- +// MatchCommands +// +//----------------------------------------------------------------------------- +int MatchLocalCommands( char* cmdStr, const char* cmdList[], int maxCmds ) +{ + int numCommands = 0; + + // look in local + int matchLen = strlen( cmdStr ); + for ( int i=0; i<g_numLocalCommands; i++ ) + { + if ( !strnicmp( cmdStr, g_localCommands[i].strCommand, matchLen ) ) + { + cmdList[numCommands++] = g_localCommands[i].strCommand; + if ( numCommands >= maxCmds ) + break; + } + } + + return ( numCommands ); +} + +//----------------------------------------------------------------------------- +// DecodeRebootArgs +// +//----------------------------------------------------------------------------- +void DecodeRebootArgs( int argc, char** argv, char* xexPath, char* xexName, char* xexArgs ) +{ + char drive[MAX_PATH]; + char dir[MAX_PATH]; + char filename[MAX_PATH]; + char extension[MAX_PATH]; + + xexPath[0] = '\0'; + xexName[0] = '\0'; + xexArgs[0] = '\0'; + + if ( !argc ) + return; + + _splitpath( argv[0], drive, dir, filename, extension ); + + sprintf( xexPath, "%s%s", drive, dir ); + sprintf( xexName, "%s%s", filename, extension ); + + for ( int i=1; i<argc; i++ ) + { + strcat( xexArgs, argv[i] ); + if ( i < argc-1 ) + strcat( xexArgs, " " ); + } +} + +//----------------------------------------------------------------------------- +// Helper function. Causes a disconnect, has optional re-connect time. +// A non-zero wait will delay before attempting re-connect. +//----------------------------------------------------------------------------- +void DoDisconnect( BOOL bKeepConnection, int waitTime ) +{ + // save state, user gates auto-connect ability + int autoConnect = g_autoConnect; + + // full disconnect, disables autoconnect + lc_disconnect( 0, NULL ); + + if ( autoConnect && bKeepConnection && waitTime > 0 ) + { + // restore autoconnect status + lc_autoConnect( 0, NULL ); + + // lets the system settle a little between contexts + g_bAutoConnectWait = waitTime; + g_bAutoConnectQuiet = FALSE; + } +} + +//----------------------------------------------------------------------------- +// lc_bug +// +//----------------------------------------------------------------------------- +BOOL lc_bug( int argc, char* argv[] ) +{ + if ( argc != 1 ) + { + char* args[2] = {"*help", argv[0]}; + lc_help( 1, args ); + goto cleanUp; + } + + BugDlg_Open(); + + return TRUE; + +cleanUp: + return FALSE; +} + +//----------------------------------------------------------------------------- +// lc_dir +// +//----------------------------------------------------------------------------- +BOOL lc_dir( int argc, char* argv[] ) +{ + fileNode_t *nodePtr; + fileNode_t *pFileList; + int numFiles; + int numDirs; + __int64 totalBytes; + bool recurse; + char dateTimeString[256]; + char sizeString[64]; + char filePath[MAX_PATH]; + char fileName[MAX_PATH]; + char targetName[MAX_PATH]; + char newPath[MAX_PATH]; + SYSTEMTIME systemTime; + SYSTEMTIME localTime; + const char *dirString; + BOOL errCode; + int nPass; + TIME_ZONE_INFORMATION tzInfo; + + pFileList = NULL; + errCode = FALSE; + + if ( argc < 2 ) + { + char* args[2] = {"*dir", argv[0]}; + lc_help( 2, args ); + goto cleanUp; + } + + strcpy( newPath, argv[1] ); + + // seperate components + Sys_StripFilename( newPath, filePath, sizeof( filePath ) ); + Sys_StripPath( newPath, fileName, sizeof( fileName ) ); + + if ( fileName[0] ) + { + if ( !strstr( fileName,"*" ) && !strstr( fileName,"?" ) ) + { + // assume filename was a directory name + strcat( newPath, "\\" ); + Sys_StripFilename( newPath, filePath, sizeof( filePath ) ); + Sys_StripPath( newPath, fileName, sizeof( fileName ) ); + } + } + + recurse = false; + if ( argc >= 3 ) + { + if ( !stricmp( argv[2], "/s" ) ) + recurse = true; + } + + if ( !GetTargetFileList_r( filePath, recurse, FA_NORMAL|FA_DIRECTORY|FA_READONLY, 0, &pFileList ) ) + { + ConsoleWindowPrintf( RGB( 255,0,0 ), "Bad Target Path '%s'\n", filePath ); + goto cleanUp; + } + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "\nDirectory of %s\n\n", argv[1] ); + + GetTimeZoneInformation( &tzInfo ); + + numFiles = 0; + numDirs = 0; + totalBytes = 0; + for ( nPass=0; nPass<2; nPass++ ) + { + for ( nodePtr=pFileList; nodePtr; nodePtr=nodePtr->nextPtr ) + { + if ( !nPass && !( nodePtr->attributes & FA_DIRECTORY ) ) + { + // first pass, dirs only + continue; + } + else if ( nPass && ( nodePtr->attributes & FA_DIRECTORY ) ) + { + // second pass, files only + continue; + } + + Sys_StripPath( nodePtr->filename, targetName, sizeof( targetName ) ); + + if ( fileName[0] && !Sys_IsWildcardMatch( fileName, targetName, false ) ) + continue; + + FileTimeToSystemTime( &nodePtr->changeTime, &systemTime ); + SystemTimeToTzSpecificLocalTime( &tzInfo, &systemTime, &localTime ); + SystemTimeToString( &localTime, dateTimeString, sizeof( dateTimeString ) ); + + __int64 fullSize = MAKEINT64( nodePtr->sizeHigh, nodePtr->sizeLow ); + + if ( nodePtr->attributes & FA_DIRECTORY ) + { + numDirs++; + dirString = "<DIR>"; + sprintf( sizeString, "%s", " " ); + } + else + { + numFiles++; + dirString = " "; + Sys_NumberToCommaString( fullSize, sizeString, sizeof( sizeString ) ); + totalBytes += fullSize; + } + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "%s %s %12s %s\n", dateTimeString, dirString, sizeString, targetName ); + } + } + + Sys_NumberToCommaString( totalBytes, sizeString, sizeof( sizeString ) ); + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "%9s %d File(s) %s bytes\n", " ", numFiles, sizeString ); + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "%9s %d Dir(s)\n", " ", numDirs ); + + // success + errCode = TRUE; + +cleanUp: + if ( pFileList ) + FreeTargetFileList( pFileList ); + + return errCode; +} + +//----------------------------------------------------------------------------- +// lc_del +// +//----------------------------------------------------------------------------- +BOOL lc_del( int argc, char* argv[] ) +{ + HRESULT hr; + fileNode_t *nodePtr; + fileNode_t *pFileList; + int numDeleted; + int numErrors; + bool recurse; + char filePath[MAX_PATH]; + char fileName[MAX_PATH]; + char targetName[MAX_PATH]; + BOOL errCode; + + pFileList = NULL; + errCode = FALSE; + + if ( argc < 2 ) + { + char* args[2] = {"*del", argv[0]}; + lc_help( 2, args ); + goto cleanUp; + } + + // seperate components + Sys_StripFilename( argv[1], filePath, sizeof( filePath ) ); + Sys_StripPath( argv[1], fileName, sizeof( fileName ) ); + + bool bQuiet = false; + recurse = false; + if ( argc >= 3 ) + { + for ( int i = 2; i < argc; i++ ) + { + if ( !V_stricmp( argv[i], "/s" ) ) + { + recurse = true; + } + else if ( !V_stricmp( argv[i], "/q" ) ) + { + // silence errors + bQuiet = true; + } + } + } + + if ( !GetTargetFileList_r( filePath, recurse, FA_NORMAL|FA_READONLY|FA_DIRECTORY, 0, &pFileList ) ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "Bad Target Path '%s'\n", filePath ); + goto cleanUp; + } + + numErrors = 0; + numDeleted = 0; + for ( nodePtr=pFileList; nodePtr; nodePtr=nodePtr->nextPtr ) + { + Sys_StripPath( nodePtr->filename, targetName, sizeof( targetName ) ); + + if ( fileName[0] && !Sys_IsWildcardMatch( fileName, targetName, false ) ) + continue; + + hr = DmDeleteFile( nodePtr->filename, ( nodePtr->attributes & FA_DIRECTORY ) != 0 ); + if ( hr != XBDM_NOERR ) + { + if ( !bQuiet ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "Error Deleting '%s'\n", nodePtr->filename ); + } + numErrors++; + } + else + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Deleted '%s'\n", nodePtr->filename ); + numDeleted++; + } + } + + if ( !numDeleted && !numErrors ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "No Files found for '%s'\n", argv[1] ); + } + else + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "%d files deleted.\n", numDeleted ); + } + + // success + errCode = TRUE; + +cleanUp: + if ( pFileList ) + FreeTargetFileList( pFileList ); + + return errCode; +} + +//----------------------------------------------------------------------------- +// lc_memory +// +//----------------------------------------------------------------------------- +BOOL lc_memory( int argc, char* argv[] ) +{ + HRESULT hr; + + hr = DmAPI_SendCommand( VXCONSOLE_COMMAND_PREFIX "!" "__memory__", true ); + if ( FAILED( hr ) ) + return FALSE; + + // success + return TRUE; +} + +//----------------------------------------------------------------------------- +// lc_screenshot +// +//----------------------------------------------------------------------------- +BOOL lc_screenshot( int argc, char* argv[] ) +{ + char filename[MAX_PATH]; + char filepath[MAX_PATH]; + static int shot = 0; + struct _stat dummyStat; + + if ( argc <= 1 ) + { + strcpy( filepath, g_localPath ); + Sys_AddFileSeperator( filepath, sizeof( filepath ) ); + + // spin up to available file + while ( 1 ) + { + sprintf( filename, "%sscreenshot_%4.4d.bmp", filepath, shot ); + if ( _stat( filename, &dummyStat ) == -1 ) + { + // filename not in use + break; + } + shot++; + } + } + else if ( argc == 2 ) + { + strcpy( filename, argv[1] ); + Sys_AddExtension( ".bmp", filename, sizeof( filename ) ); + } + else if ( argc > 2 ) + { + char* args[2] = {"*help", argv[0]}; + lc_help( 2, args ); + goto cleanUp; + } + + HRESULT hr = DmScreenShot( filename ); + if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "lc_screenshot(): DmScreenShot() failure", hr ); + goto cleanUp; + } + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Screenshot saved to %s\n", filename ); + + // advance the shot + shot++; + + // success + return TRUE; + +cleanUp: + return FALSE; +} + +//----------------------------------------------------------------------------- +// lc_modules +// +//----------------------------------------------------------------------------- +BOOL lc_modules( int argc, char* argv[] ) +{ + HRESULT hr; + PDM_WALK_MODULES pWalkMod = NULL; + CUtlVector< DMN_MODLOAD > list; + + // add a fake module at 0xFFFFFFFF to make sorting simple + DMN_MODLOAD modLoad = { 0 }; + modLoad.BaseAddress = (VOID*)0xFFFFFFFF; + list.AddToTail( modLoad ); + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Modules:\n" ); + while ( 1 ) + { + hr = DmWalkLoadedModules( &pWalkMod, &modLoad ); + if ( hr == XBDM_ENDOFLIST ) + { + hr = XBDM_NOERR; + break; + } + else if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "lc_modules(): DmWalkLoadedModules() failure", hr ); + break; + } + + // add in ascending address order + for ( int i = 0; i < list.Count(); i++ ) + { + if ( modLoad.BaseAddress <= list[i].BaseAddress ) + { + list.InsertBefore( i, modLoad ); + break; + } + } + } + + unsigned int total = 0; + for ( int i = 0; i < list.Count()-1; i++ ) + { + DMN_MODLOAD *pModule = &list[i]; + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Base: 0x%8.8x, Size: %5.2f MB, [%s]\n", pModule->BaseAddress, pModule->Size/( 1024.0f*1024.0f ), pModule->Name ); + + total += pModule->Size; + } + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Total: %.2f MB\n\n", total/( 1024.0f*1024.0f ) ); + + if ( pWalkMod ) + { + DmCloseLoadedModules( pWalkMod ); + } + + if ( !FAILED( hr ) ) + { + // success + return TRUE; + } + + return FALSE; +} + +//----------------------------------------------------------------------------- +// lc_sections +// +//----------------------------------------------------------------------------- +BOOL lc_sections( int argc, char* argv[] ) +{ + char moduleName[MAX_PATH]; + HRESULT hr; + PDM_WALK_MODSECT pWalkModSect = NULL; + DMN_SECTIONLOAD sectLoad; + + if ( argc != 2 ) + { + char* args[2] = {"*help", argv[0]}; + lc_help( 2, args ); + goto cleanUp; + } + + strcpy( moduleName, argv[1] ); + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Sections:\n" ); + while ( 1 ) + { + hr = DmWalkModuleSections( &pWalkModSect, moduleName, §Load ); + if ( hr == XBDM_ENDOFLIST ) + { + hr = XBDM_NOERR; + break; + } + else if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "lc_sections(): DmWalkModuleSections() failure", hr ); + break; + } + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "[%s]:\n", sectLoad.Name ); + ConsoleWindowPrintf( XBX_CLR_DEFAULT, " Base: 0x%8.8x\n", sectLoad.BaseAddress ); + ConsoleWindowPrintf( XBX_CLR_DEFAULT, " Size: %.2f MB ( %d bytes )\n", sectLoad.Size/( 1024.0f*1024.0f ), sectLoad.Size ); + ConsoleWindowPrintf( XBX_CLR_DEFAULT, " Index: %d\n", sectLoad.Index ); + } + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "End.\n\n" ); + + if ( pWalkModSect ) + DmCloseModuleSections( pWalkModSect ); + + if ( !FAILED( hr ) ) + { + // success + return TRUE; + } + +cleanUp: + return FALSE; +} + +//----------------------------------------------------------------------------- +// lc_threads +// +//----------------------------------------------------------------------------- +BOOL lc_threads( int argc, char* argv[] ) +{ + char nameBuff[256]; + char suspendBuff[32]; + + DWORD threadList[256]; + DWORD numThreads = 256; + memset( &threadList, 0, sizeof( threadList ) ); + HRESULT hr = DmGetThreadList( threadList, &numThreads ); + if ( FAILED( hr ) ) + return FALSE; + + // enumerate threads and display sorted by processor + DM_THREADINFOEX threadInfoEx; + for ( int core = 0; core < 3; core++ ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "\n--- CORE %d ---\n", core ); + + for ( int unit = 0; unit < 2; unit++ ) + { + for ( int i = 0; i < (int)numThreads; i++ ) + { + threadInfoEx.Size = sizeof( DM_THREADINFOEX ); + hr = DmGetThreadInfoEx( threadList[i], &threadInfoEx ); + if ( FAILED( hr ) ) + return FALSE; + + if ( threadInfoEx.CurrentProcessor != core*2 + unit ) + { + continue; + } + + nameBuff[0] = '\0'; + DmGetMemory( threadInfoEx.ThreadNameAddress, threadInfoEx.ThreadNameLength, nameBuff, NULL ); + if ( !nameBuff[0] ) + { + strcpy( nameBuff, "???" ); + } + + suspendBuff[0] = '\0'; + if ( threadInfoEx.SuspendCount ) + { + sprintf( suspendBuff, "(Suspend: %d)", threadInfoEx.SuspendCount ); + } + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, " Id: 0x%8.8x Pri: %2d Proc: %1d Stack: %7.2f KB [%s] %s\n", + threadList[i], + threadInfoEx.Priority, + threadInfoEx.CurrentProcessor, + (float)( (unsigned int)threadInfoEx.StackBase - (unsigned int)threadInfoEx.StackLimit )/1024.0f, + nameBuff, + suspendBuff ); + } + } + } + + return TRUE; +} + +//----------------------------------------------------------------------------- +// lc_run +// +//----------------------------------------------------------------------------- +BOOL lc_run( int argc, char* argv[] ) +{ + HRESULT hr; + char xexDrive[MAX_PATH]; + char xexPath[MAX_PATH]; + char xexName[MAX_PATH]; + char xexArgs[MAX_PATH]; + + if ( !argc ) + { + char* args[2] = {"*help", argv[0]}; + lc_help( 2, args ); + goto cleanUp; + } + + // copy args + g_rebootArgc = argc-1; + for ( int i=1; i<argc; i++ ) + { + if ( i==1 ) + { + strcpy( xexPath, argv[i] ); + Sys_AddExtension( ".xex", xexPath, sizeof( xexPath ) ); + _splitpath( xexPath, xexDrive, NULL, NULL, NULL ); + if ( !xexDrive[0] ) + { + char szTempPath[MAX_PATH]; + V_strncpy( szTempPath, "e:\\", sizeof( szTempPath ) ); + V_strncat( szTempPath, xexPath, sizeof( szTempPath ) ); + V_strncpy( xexPath, szTempPath, sizeof( xexPath ) ); + } + + g_rebootArgv[i-1] = Sys_CopyString( xexPath ); + } + else + { + g_rebootArgv[i-1] = Sys_CopyString( argv[i] ); + } + } + + if ( !g_rebootArgc ) + { + // reboot + hr = DmReboot( DMBOOT_COLD ); + } + else + { + DecodeRebootArgs( g_rebootArgc, g_rebootArgv, xexPath, xexName, xexArgs ); + + // trial set title - ensure title is present + hr = DmSetTitle( xexPath, xexName, xexArgs ); + if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "lc_Run(): DmSetTitle() failure", hr ); + goto cleanUp; + } + + // reboot - wait for 15s to connect and run title + hr = DmReboot( DMBOOT_WAIT ); + } + if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "lc_Run(): DmReboot() failure", hr ); + goto cleanUp; + } + + // set reboot state + g_reboot = true; + + return TRUE; + +cleanUp: + // free args + for ( int i=0; i<g_rebootArgc; i++ ) + Sys_Free( g_rebootArgv[i] ); + g_rebootArgc = 0; + + return FALSE; +} + +//----------------------------------------------------------------------------- +// lc_reset +// +//----------------------------------------------------------------------------- +BOOL lc_reset( int argc, char* argv[] ) +{ + if ( !argc ) + { + char* args[2] = {"*help", argv[0]}; + lc_help( 2, args ); + return FALSE; + } + + HRESULT hr = DmReboot( DMBOOT_COLD ); + + if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "lc_Run(): DmReboot() failure", hr ); + return FALSE; + } + + // set reboot state + g_reboot = true; + + return TRUE; +} + +//----------------------------------------------------------------------------- +// lc_help +// +// Handles the "help" command. If no args, prints a list of built-in +// and remote commands ( remote only if connected ). If a command +// is specified, prints detailed help for that command +//----------------------------------------------------------------------------- +BOOL lc_help( int argc, char* argv[] ) +{ + if ( argc <= 1 ) + { + // no arguments - print out our list of commands + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "\n" ); + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Console Commands:\n" ); + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "---------------\n" ); + for ( int i = 0; i < g_numLocalCommands; i++ ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "%s\n", g_localCommands[i].strCommand ); + } + + if ( g_connectedToApp ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Remote Commands: ( %d )\n", g_numRemoteCommands ); + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "----------------\n" ); + if ( !g_numRemoteCommands ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "( None )\n" ); + } + else + { + for ( int i=0; i<g_numRemoteCommands; i++ ) + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "%s\n", g_remoteCommands[i]->strCommand ); + } + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "\n" ); + } + } + else + { + // match as many as possible + int cch = lstrlenA( argv[1] ); + + // print help description for all local matches + for ( int i=0; i<g_numLocalCommands; i++ ) + { + if ( !_strnicmp( g_localCommands[i].strCommand, argv[1], cch ) && g_localCommands[i].strHelp ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "%s %s\n", g_localCommands[i].strCommand, g_localCommands[i].strHelp ); + } + } + + // print help description for all remote matches + if ( g_connectedToApp ) + { + for ( int i=0; i<g_numRemoteCommands; i++ ) + { + if ( !_strnicmp( g_remoteCommands[i]->strCommand, argv[1], cch ) && g_remoteCommands[i]->strHelp ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "%s %s\n", g_remoteCommands[i]->strCommand, g_remoteCommands[i]->strHelp ); + } + } + } + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "\n" ); + } + + return TRUE; + } + +//----------------------------------------------------------------------------- +// lc_cls +//----------------------------------------------------------------------------- +BOOL lc_cls( int argc, char* argv[] ) +{ + SetWindowText( g_hwndOutputWindow, "" ); + + // non't let the compiler complain about unused parameters + ( VOID )argc; + ( VOID )argv; + + return TRUE; +} + +//----------------------------------------------------------------------------- +// lc_connect +// +// Connect to XBox +//----------------------------------------------------------------------------- +BOOL lc_connect( int argc, char* argv[] ) +{ + HRESULT hr; + BOOL connected = FALSE; + + if ( g_connectedToXBox ) + { + if ( !lc_disconnect( 0, NULL ) ) + return FALSE; + } + + if ( argc >= 1 && argv[0][0] ) + { + hr = DmSetXboxName( argv[0] ); + if ( FAILED( hr ) ) + { + char message[255]; + sprintf( message, "ConnectToXBox(): DmSetXboxName( %s ) failure", argv[0] ); + DmAPI_DisplayError( message, hr ); + goto cleanUp; + } + } + + // open connection + hr = DmOpenConnection( &g_pdmConnection ); + if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "ConnectToXBox(): DmOpenConnection() failure", hr ); + goto cleanUp; + } + connected = TRUE; + + DWORD namelen = MAX_XBOXNAMELEN; + hr = DmGetXboxName( g_xboxName, &namelen ); + if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "ConnectToXBox(): DmGetXboxName() failure", hr ); + goto cleanUp; + } + hr = DmResolveXboxName( &g_xboxAddress ); + if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "ConnectToXBox(): DmResolveXboxName() failure", hr ); + goto cleanUp; + } + + // success + g_connectedToXBox = TRUE; + g_connectFailure = 0; + + if ( !g_connectCount ) + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Connected To: '%s'(%d.%d.%d.%d)\n", g_xboxName, ( ( byte* )&g_xboxAddress )[3], ( ( byte* )&g_xboxAddress )[2], ( ( byte* )&g_xboxAddress )[1], ( ( byte* )&g_xboxAddress )[0] ); + g_connectCount++; + + SetConnectionIcon( ICON_CONNECTED_XBOX ); + + if ( g_connectCount == 1 ) + { + // inital connect + } + + return TRUE; + +cleanUp: + if ( connected ) + DmCloseConnection( g_pdmConnection ); + + return FALSE; +} + +//----------------------------------------------------------------------------- +// lc_listen +// +// Open listen session with App +//----------------------------------------------------------------------------- +BOOL lc_listen( int argc, char* argv[] ) +{ + HRESULT hr; + BOOL success; + BOOL sessionStarted; + BOOL sessionValid; + char *args[1]; + char cmdStr[256]; + + if ( g_connectedToXBox || g_connectedToApp ) + { + if ( !lc_disconnect( 0, NULL ) ) + return ( FALSE ); + } + + if ( !g_connectedToXBox ) + { + // connect to xbox + args[0] = g_xboxTargetName; + if ( !lc_connect( 1, args ) ) + return FALSE; + } + + // until otherwise + success = FALSE; + sessionStarted = FALSE; + sessionValid = FALSE; + + // init session + hr = DmOpenNotificationSession( 0, &g_pdmnSession ); + if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "lc_session(): DmOpenNotificationSession() failure", hr ); + goto cleanUp; + } + sessionStarted = TRUE; + + // get notifications of app debugging output + hr = DmNotify( g_pdmnSession, DM_DEBUGSTR, Remote_NotifyDebugString ); + if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "lc_session(): DmNotify() failure", hr ); + goto cleanUp; + } + + // get command notifications + hr = DmRegisterNotificationProcessor( g_pdmnSession, VXCONSOLE_COMMAND_PREFIX, Remote_NotifyCommandFunc ); + if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "lc_session(): DmRegisterNotificationProcessor() failure", hr ); + goto cleanUp; + } + + // get print notifications + hr = DmRegisterNotificationProcessor( g_pdmnSession, VXCONSOLE_PRINT_PREFIX, Remote_NotifyPrintFunc ); + if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "lc_session(): DmRegisterNotificationProcessor() failure", hr ); + goto cleanUp; + } + sessionValid = TRUE; + + // Send initial connect command to the External Command Processor so it knows we're here + sprintf( cmdStr, "%s %d", VXCONSOLE_COMMAND_PREFIX "!" "__connect__", VXCONSOLE_PROTOCOL_VERSION ); + hr = DmAPI_SendCommand( cmdStr, true ); + if ( FAILED( hr ) ) + { + if ( !g_autoConnect ) + ConsoleWindowPrintf( RGB( 255,0,0 ), "Couldn't Find Application\n" ); + goto cleanUp; + } + else + { + // connected + success = TRUE; + g_connectedToApp = TRUE; + g_connectedTime = Sys_GetSystemTime(); + SetConnectionIcon( ICON_CONNECTED_APP1 ); + + if ( g_clsOnConnect ) + { + if ( g_bPlayTestMode ) + { + // demarcate the log + ConsoleWindowPrintf( CLR_DEFAULT, "\n******** CONNECTION ********\n" ); + } + + lc_cls( 0, NULL ); + CpuProfile_Clear(); + TimeStampLog_Clear(); + } + + goto cleanUp; + } + +cleanUp: + if ( !success ) + { + if ( sessionValid ) + DmNotify( g_pdmnSession, DM_NONE, NULL ); + + if ( sessionStarted ) + DmCloseNotificationSession( g_pdmnSession ); + } + + return ( success ); +} + +//----------------------------------------------------------------------------- +// AutoConnectTimerProc +// +//----------------------------------------------------------------------------- +void AutoConnectTimerProc( HWND hwnd, UINT_PTR idEvent ) +{ + static BOOL busy; + int icon; + char* cmdStr; + BOOL bKeepConnection = TRUE; + + // blink the connection icon + if ( g_connectedToApp && (! g_bSuppressBlink ) ) + { + if ( g_currentIcon == ICON_CONNECTED_APP0 ) + icon = ICON_CONNECTED_APP1; + else + icon = ICON_CONNECTED_APP0; + SetConnectionIcon( icon ); + } + + if ( busy ) + { + // not ready for new tick + return; + } + + if ( g_bAutoConnectWait > 0 ) + { + if ( g_bAutoConnectWait && !g_bAutoConnectQuiet ) + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Waiting... %d seconds remaining\n", g_bAutoConnectWait ); + g_bAutoConnectWait--; + return; + } + + // no more ticks until ready + busy = TRUE; + + if ( !g_connectedToApp ) + { + // looking for application - must force re-connect every time + if ( g_connectedToXBox ) + { + // temporary "partial" disconnect + DmCloseConnection( g_pdmConnection ); + g_connectedToXBox = FALSE; + } + + // attempt to start or re-establish connection and session + lc_listen( 0, NULL ); + + if ( !g_connectedToXBox ) + { + SetConnectionIcon( ICON_DISCONNECTED ); + g_connectFailure++; + } + + if ( g_reboot && g_connectedToXBox ) + { + char xexPath[MAX_PATH]; + char xexName[MAX_PATH]; + char xexArgs[MAX_PATH]; + + DecodeRebootArgs( g_rebootArgc, g_rebootArgv, xexPath, xexName, xexArgs ); + + if ( g_rebootArgc ) + { + // free args + for ( int i=0; i<g_rebootArgc; i++ ) + Sys_Free( g_rebootArgv[i] ); + g_rebootArgc = 0; + + HRESULT hr = DmSetTitle( xexPath, xexName, xexArgs ); + if ( FAILED( hr ) ) + DmAPI_DisplayError( "Reboot: DmSetTitle() failure", hr ); + else + { + hr = DmGo(); + if ( FAILED( hr ) ) + DmAPI_DisplayError( "Reboot: DmGo() failure", hr ); + } + } + + g_reboot = false; + } + + if ( !g_connectFailure ) + { + // quietly attempt re-connection or ping every 3 seconds + g_bAutoConnectWait = 3; + g_bAutoConnectQuiet = TRUE; + busy = FALSE; + } + else + { + if ( g_connectFailure == 1 ) + { + // console may be rebooting, allow sufficient dvd boot up delay, then attempt re-connection + // 5 seconds barely covers the xbox splash + g_bAutoConnectWait = 15; + g_bAutoConnectQuiet = FALSE; + busy = FALSE; + } + else + { + // a sustained connection failure means the xbox is just not there + // re-trying is too cpu intensive and causes pc to appear locked + // warn and stop auto connecting, user must fix + bKeepConnection = FALSE; + goto disconnect; + } + } + return; + } + else + { + // try to send ping across open connection at an idle interval + cmdStr = VXCONSOLE_COMMAND_PREFIX "!"; + HRESULT hr = DmAPI_SendCommand( cmdStr, false ); + if ( FAILED( hr ) && hr != XBDM_UNDEFINED ) + goto disconnect; + + // quietly ping + g_bAutoConnectWait = 3; + g_bAutoConnectQuiet = TRUE; + busy = FALSE; + return; + } + +disconnect: + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Connection To Xbox Lost.\n" ); + + DoDisconnect( bKeepConnection, 3 ); + + busy = FALSE; +} + +//----------------------------------------------------------------------------- +// lc_autoConnect +//----------------------------------------------------------------------------- +BOOL lc_autoConnect( int argc, char* argv[] ) +{ + if ( !g_autoConnect ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Enabling Auto Connect.\n" ); + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Looking for Connection...\n" ); + g_autoConnect = TRUE; + } + else + { + // already enabled + return ( TRUE ); + } + + if ( !g_autoConnectTimer ) + { + UINT_PTR timer = TIMERID_AUTOCONNECT; + g_autoConnectTimer = SetTimer( g_hDlgMain, timer, 1000, NULL ); + } + + return ( TRUE ); +} + +//----------------------------------------------------------------------------- +// lc_disconnect +//----------------------------------------------------------------------------- +BOOL lc_disconnect( int argc, char* argv[] ) +{ + if ( g_autoConnect ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Disabling Auto Connect.\n" ); + if ( g_autoConnectTimer ) + { + UINT_PTR timer = TIMERID_AUTOCONNECT; + KillTimer( g_hDlgMain, timer ); + } + g_autoConnectTimer = 0; + g_autoConnect = FALSE; + } + + if ( g_connectedToApp ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Closing Session.\n" ); + + DmAPI_SendCommand( VXCONSOLE_COMMAND_PREFIX "!" "__disconnect__", false ); + + // close session + DmNotify( g_pdmnSession, DM_NONE, NULL ); + DmCloseNotificationSession( g_pdmnSession ); + + g_connectedToApp = FALSE; + } + + if ( g_connectedToXBox ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Closing Connection.\n" ); + + // close connection + DmCloseConnection( g_pdmConnection ); + + // set the command ready mutex + SetEvent( g_hCommandReadyEvent ); + + g_connectedToXBox = FALSE; + g_xboxName[0] = '\0'; + g_xboxAddress = 0; + } + + SetConnectionIcon( ICON_DISCONNECTED ); + + g_connectCount = 0; + + // free remote commands + Remote_DeleteCommands(); + + // Don't let the compiler complain about unused parameters + ( VOID )argc; + ( VOID )argv; + + return TRUE; +} + +//----------------------------------------------------------------------------- +// lc_crashdump +//----------------------------------------------------------------------------- +BOOL lc_crashdump( int argc, char* argv[] ) +{ + DmCrashDump(); + + // Don't let the compiler complain about unused parameters + ( VOID )argc; + ( VOID )argv; + + return TRUE; +} + +//----------------------------------------------------------------------------- +// lc_quit +//----------------------------------------------------------------------------- +BOOL lc_quit( int argc, char* argv[] ) +{ + PostMessage( g_hDlgMain, WM_CLOSE, 0, 0 ); + + // don't let the compiler complain about unused parameters + ( VOID )argc; + ( VOID )argv; + + return TRUE; +} + +//----------------------------------------------------------------------------- +// lc_ClearConfigs +// +//----------------------------------------------------------------------------- +BOOL lc_ClearConfigs( int argc, char* argv[] ) +{ + if ( argc != 1 ) + { + char* args[2] = {"*help", argv[0]}; + lc_help( 1, args ); + goto cleanUp; + } + + // delete any configurations (ignore errors) + char szTempFilename[MAX_PATH]; + V_ComposeFileName( "HDD:\\Content", "*.*", szTempFilename, sizeof( szTempFilename ) ); + char *pArgs[4]; + pArgs[0] = "*del"; + pArgs[1] = szTempFilename; + pArgs[2] = "/s"; + pArgs[3] = "/q"; + lc_del( 4, pArgs ); + + return TRUE; + +cleanUp: + return FALSE; +} diff --git a/utils/xbox/vxconsole/mem_profile.cpp b/utils/xbox/vxconsole/mem_profile.cpp new file mode 100644 index 0000000..d15aee3 --- /dev/null +++ b/utils/xbox/vxconsole/mem_profile.cpp @@ -0,0 +1,561 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// MEM_PROFILE.CPP +// +// Memory Profiling Display +//=====================================================================================// +#include "vxconsole.h" + +#define PROFILE_MAXSAMPLES 512 +#define PROFILE_MEMORYHEIGHT 100 +#define PROFILE_NUMMINORTICKS 3 +#define PROFILE_LABELWIDTH 50 +#define PROFILE_SCALESTEPS 8 +#define PROFILE_MINSCALE 0.2f +#define PROFILE_MAXSCALE 3.0f +#define PROFILE_NUMMINORTICKS 3 +#define PROFILE_MAJORTICKMB 16 +#define PROFILE_WARNINGMB 10 +#define PROFILE_SEVEREMB 5 + +#define ID_MEMPROFILE 1 + +HWND g_memProfile_hWnd; +RECT g_memProfile_WindowRect; +int g_memProfile_tickMarks; +int g_memProfile_colors; +int g_memProfile_scale; +UINT_PTR g_memProfile_Timer; +int g_memProfile_numSamples; +int g_memProfile_samples[PROFILE_MAXSAMPLES]; + +//----------------------------------------------------------------------------- +// MemProfile_SaveConfig +// +//----------------------------------------------------------------------------- +void MemProfile_SaveConfig() +{ + char buff[256]; + WINDOWPLACEMENT wp; + + // profile history + if ( g_memProfile_hWnd ) + { + memset( &wp, 0, sizeof( wp ) ); + wp.length = sizeof( WINDOWPLACEMENT ); + GetWindowPlacement( g_memProfile_hWnd, &wp ); + g_memProfile_WindowRect = wp.rcNormalPosition; + sprintf( buff, "%d %d %d %d", wp.rcNormalPosition.left, wp.rcNormalPosition.top, wp.rcNormalPosition.right, wp.rcNormalPosition.bottom ); + Sys_SetRegistryString( "MemProfileWindowRect", buff ); + } + + Sys_SetRegistryInteger( "MemProfileScale", g_memProfile_scale ); + Sys_SetRegistryInteger( "MemProfileTickMarks", g_memProfile_tickMarks ); + Sys_SetRegistryInteger( "MemProfileColors", g_memProfile_colors ); +} + +//----------------------------------------------------------------------------- +// MemProfile_LoadConfig +// +//----------------------------------------------------------------------------- +void MemProfile_LoadConfig() +{ + int numArgs; + char buff[256]; + + // profile history + Sys_GetRegistryString( "MemProfileWindowRect", buff, "", sizeof( buff ) ); + numArgs = sscanf( buff, "%d %d %d %d", &g_memProfile_WindowRect.left, &g_memProfile_WindowRect.top, &g_memProfile_WindowRect.right, &g_memProfile_WindowRect.bottom ); + if ( numArgs != 4 ) + { + memset( &g_memProfile_WindowRect, 0, sizeof( g_memProfile_WindowRect ) ); + } + + Sys_GetRegistryInteger( "MemProfileScale", 0, g_memProfile_scale ); + if ( g_memProfile_scale < -PROFILE_SCALESTEPS || g_memProfile_scale > PROFILE_SCALESTEPS ) + { + g_memProfile_scale = 0; + } + + Sys_GetRegistryInteger( "MemProfileTickMarks", 1, g_memProfile_tickMarks ); + Sys_GetRegistryInteger( "MemProfileColors", 1, g_memProfile_colors ); +} + +//----------------------------------------------------------------------------- +// MemProfile_SetTitle +// +//----------------------------------------------------------------------------- +void MemProfile_SetTitle() +{ + char titleBuff[128]; + + if ( g_memProfile_hWnd ) + { + strcpy( titleBuff, "Free Memory Available" ); + if ( g_memProfile_Timer ) + { + strcat( titleBuff, " [ON]" ); + } + + SetWindowText( g_memProfile_hWnd, titleBuff ); + } +} + +//----------------------------------------------------------------------------- +// MemProfile_EnableProfiling +// +//----------------------------------------------------------------------------- +void MemProfile_EnableProfiling( bool bEnable ) +{ + if ( !g_memProfile_hWnd ) + { + return; + } + + UINT_PTR timer = TIMERID_MEMPROFILE; + if ( bEnable && !g_memProfile_Timer ) + { + // run at 10Hz + g_memProfile_Timer = SetTimer( g_memProfile_hWnd, timer, 100, NULL ); + } + else if ( !bEnable && g_memProfile_Timer ) + { + KillTimer( g_memProfile_hWnd, timer ); + g_memProfile_Timer = NULL; + } +} + +//----------------------------------------------------------------------------- +// MemProfile_UpdateWindow +// +//----------------------------------------------------------------------------- +void MemProfile_UpdateWindow() +{ + if ( g_memProfile_hWnd && !IsIconic( g_memProfile_hWnd ) ) + { + // visible - force a client repaint + InvalidateRect( g_memProfile_hWnd, NULL, true ); + } +} + +//----------------------------------------------------------------------------- +// rc_FreeMemory +// +//----------------------------------------------------------------------------- +int rc_FreeMemory( char* commandPtr ) +{ + int errCode = -1; + int freeMemory; + + char *cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + { + goto cleanUp; + } + sscanf( cmdToken, "%x", &freeMemory ); + + g_memProfile_samples[g_memProfile_numSamples % PROFILE_MAXSAMPLES] = freeMemory; + g_memProfile_numSamples++; + + DebugCommand( "FreeMemory( 0x%8.8x )\n", freeMemory ); + + MemProfile_UpdateWindow(); + + // success + errCode = 0; + +cleanUp: + return ( errCode ); +} + +//----------------------------------------------------------------------------- +// MemProfile_ZoomIn +// +//----------------------------------------------------------------------------- +void MemProfile_ZoomIn( int& scale, int numSteps ) +{ + scale++; + if ( scale > numSteps ) + { + scale = numSteps; + return; + } + MemProfile_UpdateWindow(); +} + +//----------------------------------------------------------------------------- +// MemProfile_ZoomOut +// +//----------------------------------------------------------------------------- +void MemProfile_ZoomOut( int& scale, int numSteps ) +{ + scale--; + if ( scale < -numSteps ) + { + scale = -numSteps; + return; + } + MemProfile_UpdateWindow(); +} + +//----------------------------------------------------------------------------- +// MemProfile_CalcScale +// +//----------------------------------------------------------------------------- +float MemProfile_CalcScale( int scale, int numSteps, float min, float max ) +{ + float t; + + // from integral scale [-numSteps..numSteps] to float scale [min..max] + t = ( float )( scale + numSteps )/( float )( 2*numSteps ); + t = min + t*( max-min ); + + return t; +} + +//----------------------------------------------------------------------------- +// MemProfile_Draw +// +//----------------------------------------------------------------------------- +void MemProfile_Draw( HDC hdc, RECT* clientRect ) +{ + char labelBuff[128]; + HPEN hBlackPen; + HPEN hPenOld; + HPEN hNullPen; + HPEN hGreyPen; + HBRUSH hColoredBrush; + HBRUSH hBrushOld; + HFONT hFontOld; + int currentSample; + int numTicks; + int memoryHeight; + int windowWidth; + int windowHeight; + int x; + int y; + int y0; + int i; + int j; + int h; + int numbars; + RECT rect; + float t; + float scale; + + hBlackPen = CreatePen( PS_SOLID, 1, RGB( 0,0,0 ) ); + hGreyPen = CreatePen( PS_SOLID, 1, Sys_ColorScale( g_backgroundColor, 0.85f ) ); + hNullPen = CreatePen( PS_NULL, 0, RGB( 0,0,0 ) ); + hPenOld = ( HPEN )SelectObject( hdc, hBlackPen ); + hFontOld = SelectFont( hdc, g_hProportionalFont ); + + // zoom + scale = MemProfile_CalcScale( g_memProfile_scale, PROFILE_SCALESTEPS, PROFILE_MINSCALE, PROFILE_MAXSCALE ); + memoryHeight = ( int )( PROFILE_MEMORYHEIGHT*scale ); + windowWidth = clientRect->right-clientRect->left; + windowHeight = clientRect->bottom-clientRect->top; + + numTicks = windowHeight/memoryHeight + 2; + if ( numTicks < 0 ) + { + numTicks = 1; + } + else if ( numTicks > 512/PROFILE_MAJORTICKMB + 1 ) + { + numTicks = 512/PROFILE_MAJORTICKMB + 1; + } + + SetBkColor( hdc, g_backgroundColor ); + + x = 0; + y = windowHeight; + for ( i=0; i<numTicks; i++ ) + { + // major ticks + SelectObject( hdc, hBlackPen ); + MoveToEx( hdc, 0, y, NULL ); + LineTo( hdc, windowWidth, y ); + + if ( g_memProfile_tickMarks ) + { + // could be very zoomed out, gap must be enough for label, otherwise don't draw + int gapY = memoryHeight/( PROFILE_NUMMINORTICKS+1 ); + if ( gapY >= 10 ) + { + // minor ticks + y0 = y; + SelectObject( hdc, hGreyPen ); + for ( j=0; j<PROFILE_NUMMINORTICKS; j++ ) + { + y0 += gapY; + MoveToEx( hdc, 0, y0, NULL ); + LineTo( hdc, windowWidth, y0 ); + } + } + } + + // tick labels + if ( i ) + { + rect.left = windowWidth - 50; + rect.right = windowWidth; + rect.top = y - 20; + rect.bottom = y; + sprintf( labelBuff, "%d MB", i*PROFILE_MAJORTICKMB ); + DrawText( hdc, labelBuff, -1, &rect, DT_RIGHT|DT_SINGLELINE|DT_BOTTOM ); + } + + y -= memoryHeight; + } + + // vertical bars + if ( g_memProfile_numSamples ) + { + SelectObject( hdc, hNullPen ); + + numbars = windowWidth-PROFILE_LABELWIDTH; + currentSample = g_memProfile_numSamples-1; + for ( x=numbars-1; x>=0; x-=4 ) + { + float sample = g_memProfile_samples[currentSample % PROFILE_MAXSAMPLES]/( 1024.0f * 1024.0f ); + + y = windowHeight; + t = sample/(float)PROFILE_MAJORTICKMB; + h = ( int )( t * ( float )memoryHeight ); + if ( h ) + { + if ( h > windowHeight ) + h = windowHeight; + + COLORREF barColor; + if ( sample >= PROFILE_WARNINGMB ) + { + barColor = RGB( 100, 255, 100 ); + } + else if ( sample >= PROFILE_SEVEREMB ) + { + barColor = RGB( 255, 255, 100 ); + } + else + { + barColor = RGB( 255, 0, 0 ); + } + + hColoredBrush = CreateSolidBrush( g_memProfile_colors ? barColor : RGB( 80, 80, 80 ) ); + hBrushOld = ( HBRUSH )SelectObject( hdc, hColoredBrush ); + + Rectangle( hdc, x-4, y-h, x, y+1 ); + y -= h; + + SelectObject( hdc, hBrushOld ); + DeleteObject( hColoredBrush ); + } + + currentSample--; + if ( currentSample < 0 ) + { + // no data + break; + } + } + } + + SelectObject( hdc, hFontOld ); + SelectObject( hdc, hPenOld ); + DeleteObject( hBlackPen ); + DeleteObject( hGreyPen ); +} + +//----------------------------------------------------------------------------- +// MemProfile_TimerProc +// +//----------------------------------------------------------------------------- +void MemProfile_TimerProc( HWND hwnd, UINT_PTR idEvent ) +{ + static bool busy = false; + + if ( busy ) + { + return; + } + + busy = true; + + if ( g_connectedToApp ) + { + // send as async + DmAPI_SendCommand( VXCONSOLE_COMMAND_PREFIX "!" "__memory__ quiet", false ); + } + + busy = false; +} + +//----------------------------------------------------------------------------- +// MemProfile_WndProc +// +//----------------------------------------------------------------------------- +LRESULT CALLBACK MemProfile_WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + WORD wID = LOWORD( wParam ); + HDC hdc; + PAINTSTRUCT ps; + RECT rect; + CREATESTRUCT *createStructPtr; + + switch ( message ) + { + case WM_CREATE: + // set the window identifier + createStructPtr = ( CREATESTRUCT* )lParam; + SetWindowLong( hwnd, GWL_USERDATA+0, ( LONG )createStructPtr->lpCreateParams ); + + // clear samples + g_memProfile_numSamples = 0; + memset( g_memProfile_samples, 0, sizeof( g_memProfile_samples ) ); + return 0L; + + case WM_DESTROY: + MemProfile_SaveConfig(); + MemProfile_EnableProfiling( false ); + g_memProfile_hWnd = NULL; + return 0L; + + case WM_INITMENU: + CheckMenuItem( ( HMENU )wParam, IDM_MEMPROFILE_TICKMARKS, MF_BYCOMMAND | ( g_memProfile_tickMarks ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_MEMPROFILE_COLORS, MF_BYCOMMAND | ( g_memProfile_colors ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_MEMPROFILE_ENABLE, MF_BYCOMMAND | ( g_memProfile_Timer != NULL ? MF_CHECKED : MF_UNCHECKED ) ); + return 0L; + + case WM_PAINT: + GetClientRect( hwnd, &rect ); + hdc = BeginPaint( hwnd, &ps ); + MemProfile_Draw( hdc, &rect ); + EndPaint( hwnd, &ps ); + return 0L; + + case WM_SIZE: + // force a redraw + MemProfile_UpdateWindow(); + return 0L; + + case WM_TIMER: + if ( wID == TIMERID_MEMPROFILE ) + { + MemProfile_TimerProc( hwnd, TIMERID_MEMPROFILE ); + return 0L; + } + break; + + case WM_KEYDOWN: + switch ( wParam ) + { + case VK_INSERT: + MemProfile_ZoomIn( g_memProfile_scale, PROFILE_SCALESTEPS ); + return 0L; + + case VK_DELETE: + MemProfile_ZoomOut( g_memProfile_scale, PROFILE_SCALESTEPS ); + return 0L; + } + break; + + case WM_COMMAND: + switch ( wID ) + { + case IDM_MEMPROFILE_TICKMARKS: + g_memProfile_tickMarks ^= 1; + MemProfile_UpdateWindow(); + return 0L; + + case IDM_MEMPROFILE_COLORS: + g_memProfile_colors ^= 1; + MemProfile_UpdateWindow(); + return 0L; + + case IDM_MEMPROFILE_ZOOMIN: + MemProfile_ZoomIn( g_memProfile_scale, PROFILE_SCALESTEPS ); + return 0L; + + case IDM_MEMPROFILE_ZOOMOUT: + MemProfile_ZoomOut( g_memProfile_scale, PROFILE_SCALESTEPS ); + return 0L; + + case IDM_MEMPROFILE_ENABLE: + bool bEnable = ( g_memProfile_Timer != NULL ); + bEnable ^= 1; + MemProfile_EnableProfiling( bEnable ); + MemProfile_SetTitle(); + return 0L; + } + break; + } + return ( DefWindowProc( hwnd, message, wParam, lParam ) ); +} + +//----------------------------------------------------------------------------- +// MemProfile_Open +// +//----------------------------------------------------------------------------- +void MemProfile_Open() +{ + HWND hWnd; + + if ( g_memProfile_hWnd ) + { + // only one profile instance + if ( IsIconic( g_memProfile_hWnd ) ) + ShowWindow( g_memProfile_hWnd, SW_RESTORE ); + SetForegroundWindow( g_memProfile_hWnd ); + return; + } + + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + "MEMPROFILECLASS", + "", + WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX, + 0, + 0, + 600, + 500, + g_hDlgMain, + NULL, + g_hInstance, + ( void* )ID_MEMPROFILE ); + g_memProfile_hWnd = hWnd; + + MemProfile_EnableProfiling( true ); + MemProfile_SetTitle(); + + if ( g_memProfile_WindowRect.right && g_memProfile_WindowRect.bottom ) + MoveWindow( g_memProfile_hWnd, g_memProfile_WindowRect.left, g_memProfile_WindowRect.top, g_memProfile_WindowRect.right-g_memProfile_WindowRect.left, g_memProfile_WindowRect.bottom-g_memProfile_WindowRect.top, FALSE ); + ShowWindow( g_memProfile_hWnd, SHOW_OPENWINDOW ); +} + +//----------------------------------------------------------------------------- +// MemProfile_Init +// +//----------------------------------------------------------------------------- +bool MemProfile_Init() +{ + WNDCLASS wndclass; + + // set up our window class + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = MemProfile_WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = 0; + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_APPLICATION]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = MAKEINTRESOURCE( MENU_MEMPROFILE ); + wndclass.lpszClassName = "MEMPROFILECLASS"; + if ( !RegisterClass( &wndclass ) ) + return false; + + MemProfile_LoadConfig(); + + return true; +} diff --git a/utils/xbox/vxconsole/progress.cpp b/utils/xbox/vxconsole/progress.cpp new file mode 100644 index 0000000..50d90f4 --- /dev/null +++ b/utils/xbox/vxconsole/progress.cpp @@ -0,0 +1,359 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// PROGRESS.CPP +// +// Progress Metering Utility. +//=====================================================================================// +#include "vxconsole.h" + +#define PROGRESS_WIDTH 425 +#define PROGRESS_HEIGHT 170 + +#define ID_PROGRESS_STATUS1 100 +#define ID_PROGRESS_STATUS2 101 +#define ID_PROGRESS_STATUS3 102 +#define ID_PROGRESS_PERCENT 103 +#define ID_PROGRESS_METER 104 +#define ID_PROGRESS_CANCEL 105 + +//----------------------------------------------------------------------------- +// CProgress_WndProc +// +//----------------------------------------------------------------------------- +LRESULT CALLBACK Progress_WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + CProgress *pProgress; + CREATESTRUCT *createStructPtr; + + switch ( message ) + { + case WM_CREATE: + createStructPtr = ( CREATESTRUCT* )lParam; + SetWindowLong( hwnd, GWL_USERDATA+0, ( LONG )createStructPtr->lpCreateParams ); + return 0L; + + case WM_DESTROY: + pProgress = ( CProgress* )GetWindowLong( hwnd, GWL_USERDATA+0 ); + if ( pProgress ) + pProgress->m_hWnd = NULL; + return 0L; + + case WM_CTLCOLORSTATIC: + SetBkColor( ( HDC )wParam, g_backgroundColor ); + return ( BOOL )g_hBackgroundBrush; + + case WM_COMMAND: + switch ( LOWORD( wParam ) ) + { + case ID_PROGRESS_CANCEL: + pProgress = ( CProgress* )GetWindowLong( hwnd, GWL_USERDATA+0 ); + if ( pProgress ) + pProgress->m_bCancelPressed = true; + return ( TRUE ); + } + break; + } + + return ( DefWindowProc( hwnd, message, wParam, lParam ) ); +} + +//----------------------------------------------------------------------------- +// CProgress::Update +// +// Pump the message loop +//----------------------------------------------------------------------------- +void CProgress::Update() +{ + MSG msg; + + while ( PeekMessage( &msg, NULL, 0, 0, PM_NOYIELD|PM_REMOVE ) ) + { + if ( !TranslateAccelerator( g_hDlgMain, g_hAccel, &msg ) ) + { + TranslateMessage( &msg ); + DispatchMessage( &msg ); + } + } +} + +//----------------------------------------------------------------------------- +// CProgress::IsCancel +// +//----------------------------------------------------------------------------- +bool CProgress::IsCancel() +{ + return m_bCancelPressed; +} + +//----------------------------------------------------------------------------- +// CProgress::SetMeter +// +//----------------------------------------------------------------------------- +void CProgress::SetMeter( int currentPos, int range ) +{ + char buff[16]; + int percent; + + if ( !m_hWnd || !m_hWndPercent || !m_hWndMeter ) + return; + + if ( range >= 0 ) + { + SendMessage( m_hWndMeter, PBM_SETRANGE, 0, MAKELPARAM( 0, range ) ); + m_range = range; + } + SendMessage( m_hWndMeter, PBM_SETPOS, currentPos, 0 ); + + if ( m_range > 0 ) + { + percent = ( int )( 100.0f*currentPos/m_range ); + if ( percent > 100 ) + percent = 100; + } + else + percent = 0; + sprintf( buff, "%d%%", percent ); + SetWindowText( m_hWndPercent, buff ); + + Update(); +} + +//----------------------------------------------------------------------------- +// CProgress::SetStatus +// +//----------------------------------------------------------------------------- +void CProgress::SetStatus( const char *line1, const char *line2, const char *line3 ) +{ + if ( !m_hWnd ) + return; + + if ( line1 ) + SetWindowText( m_hWndStatus1, line1 ); + if ( line2 ) + SetWindowText( m_hWndStatus2, line2 ); + if ( line3 ) + SetWindowText( m_hWndStatus3, line3 ); + + Update(); +} + +//----------------------------------------------------------------------------- +// CProgress::Open +// +//----------------------------------------------------------------------------- +void CProgress::Open( const char* title, bool canCancel, bool bHasMeter ) +{ + HWND hWnd; + RECT clientRect; + RECT parentRect; + int cx; + int cy; + int cw; + int ch; + int y; + int dialogHeight; + + dialogHeight = PROGRESS_HEIGHT; + if ( !canCancel ) + dialogHeight -= 25; + if ( !bHasMeter ) + dialogHeight -= GetSystemMetrics( SM_CYVSCROLL ); + + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + "PROGRESSCLASS", + title, + WS_POPUP|WS_CAPTION, + 0, + 0, + PROGRESS_WIDTH, + dialogHeight, + g_hDlgMain, + NULL, + g_hInstance, + ( void* )this ); + m_hWnd = hWnd; + if ( !m_hWnd ) + return; + + // status text line #1 + GetClientRect( m_hWnd, &clientRect ); + y = 10; + hWnd = CreateWindowEx( + 0, + WC_STATIC, + "", + WS_VISIBLE|WS_CHILD|SS_WORDELLIPSIS, + 8, + 10, + clientRect.right-clientRect.left-2*8 - 50, + 20, + m_hWnd, + ( HMENU )ID_PROGRESS_STATUS1, + g_hInstance, + NULL ); + m_hWndStatus1 = hWnd; + y += 20; + + // status text line #2 + hWnd = CreateWindowEx( + 0, + WC_STATIC, + "", + WS_VISIBLE|WS_CHILD|SS_PATHELLIPSIS, + 8, + y, + clientRect.right-clientRect.left-2*8 -50, + 20, + m_hWnd, + ( HMENU )ID_PROGRESS_STATUS2, + g_hInstance, + NULL ); + m_hWndStatus2 = hWnd; + y += 20; + + // status text line #3 + hWnd = CreateWindowEx( + 0, + WC_STATIC, + "", + WS_VISIBLE|WS_CHILD|SS_PATHELLIPSIS, + 8, + y, + clientRect.right-clientRect.left-2*8 -50, + 20, + m_hWnd, + ( HMENU )ID_PROGRESS_STATUS3, + g_hInstance, + NULL ); + m_hWndStatus3 = hWnd; + y += 20; + + // set font + SendMessage( m_hWndStatus1, WM_SETFONT, ( WPARAM )g_hProportionalFont, TRUE ); + SendMessage( m_hWndStatus2, WM_SETFONT, ( WPARAM )g_hProportionalFont, TRUE ); + SendMessage( m_hWndStatus3, WM_SETFONT, ( WPARAM )g_hProportionalFont, TRUE ); + + if ( bHasMeter ) + { + // percent + hWnd = CreateWindowEx( + 0, + WC_STATIC, + "0%", + WS_VISIBLE|WS_CHILD|SS_RIGHT, + ( clientRect.right-clientRect.left ) - 2*8 - 50, + y - 20, + 50, + 20, + m_hWnd, + ( HMENU )ID_PROGRESS_PERCENT, + g_hInstance, + NULL ); + m_hWndPercent = hWnd; + SendMessage( m_hWndPercent, WM_SETFONT, ( WPARAM )g_hProportionalFont, TRUE ); + + // progress meter + ch = GetSystemMetrics( SM_CYVSCROLL ); + cw = ( clientRect.right-clientRect.left ) - 2*8; + cx = ( clientRect.left + clientRect.right )/2 - cw/2; + cy = y; + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + PROGRESS_CLASS, + NULL, + WS_VISIBLE|WS_CHILD, + cx, + cy, + cw, + ch, + m_hWnd, + ( HMENU )ID_PROGRESS_METER, + g_hInstance, + NULL ); + m_hWndMeter = hWnd; + y = cy+ch; + + // ensure bar is reset + SendMessage( m_hWndMeter, PBM_SETRANGE, 0, 0 ); + SendMessage( m_hWndMeter, PBM_SETPOS, 0, 0 ); + } + else + { + m_hWndPercent = NULL; + m_hWndMeter = NULL; + } + + m_bCancelPressed = false; + if ( canCancel ) + { + ch = 25; + cw = 80; + cx = ( clientRect.left + clientRect.right )/2 - cw/2; + cy = clientRect.bottom - 8 - ch; + + // cancel button + hWnd = CreateWindowEx( + 0, + WC_BUTTON, + "Cancel", + WS_VISIBLE|WS_CHILD|BS_PUSHBUTTON, + cx, + cy, + cw, + ch, + m_hWnd, + ( HMENU )ID_PROGRESS_CANCEL, + g_hInstance, + NULL ); + m_hWndCancel = hWnd; + + SendMessage( m_hWndCancel, WM_SETFONT, ( WPARAM )g_hProportionalFont, TRUE ); + } + + // get parent rectangle + GetWindowRect( g_hDlgMain, &parentRect ); + cx = ( parentRect.left + parentRect.right )/2 - PROGRESS_WIDTH/2; + cy = ( parentRect.top + parentRect.bottom )/2 - dialogHeight/2; + + MoveWindow( m_hWnd, cx, cy, PROGRESS_WIDTH, dialogHeight, FALSE ); + ShowWindow( m_hWnd, SHOW_OPENWINDOW ); +} + +//----------------------------------------------------------------------------- +// CProgress::~CProgress +// +//----------------------------------------------------------------------------- +CProgress::~CProgress() +{ + if ( !m_hWnd ) + return; + + DestroyWindow( m_hWnd ); + m_hWnd = NULL; +} + +//----------------------------------------------------------------------------- +// CProgress::CProgress +// +//----------------------------------------------------------------------------- +CProgress::CProgress() +{ + // set up our window class + WNDCLASS wndclass; + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = Progress_WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = sizeof( CProgress* ); + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_APPLICATION]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = NULL; + wndclass.lpszClassName = "PROGRESSCLASS"; + RegisterClass( &wndclass ); + + m_hWnd = 0; + m_bCancelPressed = false; +} diff --git a/utils/xbox/vxconsole/remote_cmds.cpp b/utils/xbox/vxconsole/remote_cmds.cpp new file mode 100644 index 0000000..f74bda0 --- /dev/null +++ b/utils/xbox/vxconsole/remote_cmds.cpp @@ -0,0 +1,484 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// REMOTE_CMDS.CPP +// +// Remote commands received by an external application and dispatched. +//=====================================================================================// +#include "vxconsole.h" + +remoteCommand_t *g_remoteCommands[MAX_RCMDS]; +int g_numRemoteCommands; + +//----------------------------------------------------------------------------- +// MatchRemoteCommands +// +//----------------------------------------------------------------------------- +int MatchRemoteCommands( char *pCmdStr, const char *cmdList[], int maxCmds ) +{ + int numCommands = 0; + + // look in local + int matchLen = strlen( pCmdStr ); + for ( int i=0; i<g_numRemoteCommands; i++ ) + { + if ( !strnicmp( pCmdStr, g_remoteCommands[i]->strCommand, matchLen ) ) + { + cmdList[numCommands++] = g_remoteCommands[i]->strCommand; + if ( numCommands >= maxCmds ) + break; + } + } + + return ( numCommands ); +} + +//----------------------------------------------------------------------------- +// GetToken +// +//----------------------------------------------------------------------------- +char *GetToken( char **ppTokenStream ) +{ + static char token[MAX_TOKENCHARS]; + int len; + char c; + char *pData; + + len = 0; + token[0] = 0; + + if ( !ppTokenStream ) + return NULL; + + pData = *ppTokenStream; + + // skip whitespace +skipwhite: + while ( ( c = *pData ) <= ' ' ) + { + if ( !c ) + goto cleanup; + pData++; + } + + // skip // comments + if ( c=='/' && pData[1] == '/' ) + { + while ( *pData && *pData != '\n' ) + pData++; + goto skipwhite; + } + + // handle quoted strings specially + if ( c == '\"' ) + { + pData++; + while ( 1 ) + { + c = *pData++; + if ( c=='\"' || !c ) + goto cleanup; + + token[len] = c; + len++; + if ( len > MAX_TOKENCHARS-1 ) + goto cleanup; + } + } + + // parse a regular word + do + { + token[len] = c; + pData++; + len++; + if ( len > MAX_TOKENCHARS-1 ) + break; + c = *pData; + } + while ( c > ' ' && c <= '~' ); + +cleanup: + token[len] = 0; + *ppTokenStream = pData; + return ( token ); +} + +//----------------------------------------------------------------------------- +// CommandCompleted +// +//----------------------------------------------------------------------------- +void CommandCompleted( int errCode ) +{ + char cmdString[MAX_PATH]; + + // send command complete + sprintf( cmdString, "%s!__complete__%d", VXCONSOLE_COMMAND_PREFIX, errCode ); + DmAPI_SendCommand( cmdString, true ); +} + +//----------------------------------------------------------------------------- +// DebugCommand +//----------------------------------------------------------------------------- +void DebugCommand( const char *pStrFormat, ... ) +{ + char buffer[MAX_QUEUEDSTRINGLEN]; + va_list arglist; + + if ( !g_debugCommands ) + return; + + va_start( arglist, pStrFormat ); + _vsnprintf( buffer, MAX_QUEUEDSTRINGLEN, pStrFormat, arglist ); + va_end( arglist ); + + PrintToQueue( RGB( 0,128,0 ), "[CMD]: %s", buffer ); +} + +//----------------------------------------------------------------------------- +// Remote_NotifyPrintFunc +// +//----------------------------------------------------------------------------- +DWORD __stdcall Remote_NotifyPrintFunc( const CHAR *pStrNotification ) +{ + int color; + + if ( !strnicmp( pStrNotification, VXCONSOLE_PRINT_PREFIX, strlen( VXCONSOLE_PRINT_PREFIX ) ) ) + { + // skip past prefix! + pStrNotification += strlen( VXCONSOLE_PRINT_PREFIX )+1; + } + + color = XBX_CLR_DEFAULT; + + if ( !strnicmp( pStrNotification, VXCONSOLE_COLOR_PREFIX, strlen( VXCONSOLE_COLOR_PREFIX ) ) ) + { + // skip past prefix[12345678] + char buff[16]; + pStrNotification += strlen( VXCONSOLE_COLOR_PREFIX ); + memcpy( buff, pStrNotification, 10 ); + if ( buff[0] == '[' && buff[9] == ']' ) + { + buff[0] = ' '; + buff[9] = ' '; + buff[10] = '\0'; + + sscanf( buff, "%x", &color ); + pStrNotification += 10; + } + } + + PrintToQueue( color, "%s\n", pStrNotification ); + return S_OK; +} + +//----------------------------------------------------------------------------- +// Remote_NotifyDebugString +// +// Print as [DBG]:xxxx +//----------------------------------------------------------------------------- +DWORD __stdcall Remote_NotifyDebugString( ULONG dwNotification, DWORD dwParam ) +{ + if ( g_captureDebugSpew ) + { + PDMN_DEBUGSTR p = ( PDMN_DEBUGSTR )dwParam; + int len; + + // strip all terminating cr + len = p->Length-1; + while ( len > 0 ) + { + if ( p->String[len] != '\n' ) + { + len++; + break; + } + len--; + } + + // for safety, terminate + CHAR* strTemp = new CHAR[len+1]; + memcpy( strTemp, p->String, len*sizeof( CHAR ) ); + strTemp[len] = '\0'; + + PrintToQueue( RGB( 0,0,255 ), "[DBG]: %s\n", strTemp ); + + delete[] strTemp; + } + + // Don't let the compiler complain about unused parameters + ( VOID )dwNotification; + + return 0; +} + +//----------------------------------------------------------------------------- +// Remote_CompareCommands +// +//----------------------------------------------------------------------------- +int Remote_CompareCommands( const void *pElem1, const void *pElem2 ) +{ + remoteCommand_t *pCmd1; + remoteCommand_t *pCmd2; + + pCmd1 = *( remoteCommand_t** )( pElem1 ); + pCmd2 = *( remoteCommand_t** )( pElem2 ); + + return ( strcmp( pCmd1->strCommand, pCmd2->strCommand ) ); +} + +//----------------------------------------------------------------------------- +// Remote_DeleteCommands +// +//----------------------------------------------------------------------------- +void Remote_DeleteCommands() +{ + if ( !g_numRemoteCommands ) + return; + + for ( int i=0; i<g_numRemoteCommands; i++ ) + { + delete [] g_remoteCommands[i]->strCommand; + delete [] g_remoteCommands[i]->strHelp; + delete g_remoteCommands[i]; + + g_remoteCommands[i] = NULL; + } + + g_numRemoteCommands = 0; +} + +//----------------------------------------------------------------------------- +// Remote_AddCommand +// +//----------------------------------------------------------------------------- +bool Remote_AddCommand( char *command, char *helptext ) +{ + if ( g_numRemoteCommands == MAX_RCMDS ) + { + // full + return false; + } + + // look for duplicate + int i; + for ( i = 0; i < g_numRemoteCommands; i++ ) + { + if ( !stricmp( command, g_remoteCommands[i]->strCommand ) ) + break; + } + if ( i < g_numRemoteCommands ) + { + // already in list, skip - not an error + return true; + } + + // add new command to list + g_remoteCommands[g_numRemoteCommands] = new remoteCommand_t; + g_remoteCommands[g_numRemoteCommands]->strCommand = new char[strlen( command )+1]; + strcpy( g_remoteCommands[g_numRemoteCommands]->strCommand, command ); + + g_remoteCommands[g_numRemoteCommands]->strHelp = new char[strlen( helptext )+1]; + strcpy( g_remoteCommands[g_numRemoteCommands]->strHelp, helptext ); + + g_numRemoteCommands++; + + // success + return true; +} + +//----------------------------------------------------------------------------- +// rc_AddCommands +// +// Exposes an app's list of remote commands +//----------------------------------------------------------------------------- +int rc_AddCommands( char *commandPtr ) +{ + char* cmdToken; + int numCommands; + int cmdList; + int retAddr; + int retVal; + int errCode; + xrCommand_t* locallist; + + errCode = -1; + + // pacifier for lengthy operation + ConsoleWindowPrintf( RGB( 0, 0, 0 ), "Receiving Console Commands From Game..." ); + + // get number of commands + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &numCommands ); + + // get command list + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &cmdList ); + + // get retAddr + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &retAddr ); + + locallist = new xrCommand_t[numCommands]; + memset( locallist, 0, numCommands*sizeof( xrCommand_t ) ); + + // get the caller's command list + DmGetMemory( ( void* )cmdList, numCommands*sizeof( xrCommand_t ), locallist, NULL ); + + int numAdded = 0; + for ( int i=0; i<numCommands; i++ ) + { + if ( Remote_AddCommand( locallist[i].nameString, locallist[i].helpString ) ) + numAdded++; + } + + // sort the list + qsort( g_remoteCommands, g_numRemoteCommands, sizeof( remoteCommand_t* ), Remote_CompareCommands ); + + ConsoleWindowPrintf( RGB( 0, 0, 0 ), "Completed.\n" ); + + // return the result + retVal = numAdded; + int xboxRetVal = BigDWord( retVal ); + DmSetMemory( ( void* )retAddr, sizeof( int ), &xboxRetVal, NULL ); + + DebugCommand( "0x%8.8x = AddCommands( 0x%8.8x, 0x%8.8x )\n", retVal, numCommands, cmdList ); + + delete [] locallist; + + // success + errCode = 0; + + if ( g_bPlayTestMode ) + { + if ( g_connectedToApp ) + { + // send the developer command + ProcessCommand( "developer 1" ); + } + } + +cleanUp: + return ( errCode ); +} + +//----------------------------------------------------------------------------- +// Remote_NotifyCommandFunc +// +//----------------------------------------------------------------------------- +DWORD __stdcall Remote_NotifyCommandFunc( const CHAR *strNotification ) +{ + CHAR* commandPtr; + CHAR* cmdToken; + int errCode; + bool async; + + // skip over the command prefix and the exclamation mark + strNotification += strlen( VXCONSOLE_COMMAND_PREFIX ) + 1; + commandPtr = ( CHAR* )strNotification; + + // failure until otherwise + errCode = -1; + + // default synchronous + async = false; + + cmdToken = GetToken( &commandPtr ); + + if ( cmdToken && !stricmp( cmdToken, "AddCommands()" ) ) + { + errCode = rc_AddCommands( commandPtr ); + goto cleanUp; + } + else if ( cmdToken && !stricmp( cmdToken, "SetProfile()" ) ) + { + // first arg dictates routing + cmdToken = GetToken( &commandPtr ); + if ( cmdToken && !stricmp( cmdToken, "cpu" ) ) + errCode = rc_SetCpuProfile( commandPtr ); + else if ( cmdToken && !stricmp( cmdToken, "texture" ) ) + errCode = rc_SetTexProfile( commandPtr ); + + goto cleanUp; + } + else if ( cmdToken && !stricmp( cmdToken, "SetProfileData()" ) ) + { + // first arg dictates routing + cmdToken = GetToken( &commandPtr ); + if ( cmdToken && !stricmp( cmdToken, "cpu" ) ) + errCode = rc_SetCpuProfileData( commandPtr ); + else if ( cmdToken && !stricmp( cmdToken, "texture" ) ) + errCode = rc_SetTexProfileData( commandPtr ); + + async = true; + goto cleanUp; + } + else if ( cmdToken && !stricmp( cmdToken, "TextureList()" ) ) + { + errCode = rc_TextureList( commandPtr ); + goto cleanUp; + } + else if ( cmdToken && !stricmp( cmdToken, "MaterialList()" ) ) + { + errCode = rc_MaterialList( commandPtr ); + goto cleanUp; + } + else if ( cmdToken && !stricmp( cmdToken, "SoundList()" ) ) + { + errCode = rc_SoundList( commandPtr ); + goto cleanUp; + } + else if ( cmdToken && !stricmp( cmdToken, "TimeStampLog()" ) ) + { + errCode = rc_TimeStampLog( commandPtr ); + goto cleanUp; + } + else if ( cmdToken && !stricmp( cmdToken, "MemDump()" ) ) + { + errCode = rc_MemDump( commandPtr ); + async = true; + goto cleanUp; + } + else if ( cmdToken && !stricmp( cmdToken, "MapInfo()" ) ) + { + errCode = rc_MapInfo( commandPtr ); + goto cleanUp; + } + else if ( cmdToken && !stricmp( cmdToken, "Assert()" ) ) + { + errCode = rc_Assert( commandPtr ); + goto cleanUp; + } + else if ( cmdToken && !stricmp( cmdToken, "FreeMemory()" ) ) + { + errCode = rc_FreeMemory( commandPtr ); + async = true; + goto cleanUp; + } + else if ( cmdToken && !stricmp( cmdToken, "Disconnect()" ) ) + { + // disconnect requires specialized processing + // send command status first while connection valid, then do actual disconnect + // disconnect is always assumed to be valid, can't be denied + CommandCompleted( 0 ); + DoDisconnect( TRUE ); + return S_OK; + } + else + { + // unknown command + PrintToQueue( RGB( 255,0,0 ), "Unknown Command: %s\n", strNotification ); + goto cleanUp; + } + +cleanUp: + if ( !async ) + CommandCompleted( errCode ); + + return ( S_OK ); +} diff --git a/utils/xbox/vxconsole/resource.h b/utils/xbox/vxconsole/resource.h new file mode 100644 index 0000000..ed5c602 --- /dev/null +++ b/utils/xbox/vxconsole/resource.h @@ -0,0 +1,241 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by vxconsole.rc +// +#define MENU_PROFILE 4 +#define MENU_CPUPROFILE 4 +#define MENU_VXCONSOLE 100 +#define IDD_VXCONSOLE 104 +#define IDD_CONFIG 111 +#define IDC_LABEL 113 +#define IDD_SYNCFILES 116 +#define MENU_SHOWTEXTURES 118 +#define MENU_TEXPROFILE 120 +#define MENU_BINDOPTIONS 122 +#define IDD_MODIFYBIND 123 +#define MENU_SHOWMATERIALS 124 +#define MENU_SHOWSOUNDS 125 +#define MENU_SHOWMEMORYDUMP 127 +#define IDD_BUG 128 +#define MENU_TIMESTAMPLOG 129 +#define IDD_EXCLUDEPATHS 131 +#define IDD_INSTALL 132 +#define MENU_MEMPROFILE 133 +#define IDI_VXCONSOLE 200 +#define IDI_DISCONNECTED 201 +#define IDI_CONNECT1_ON 202 +#define IDI_CONNECT2_ON 203 +#define IDI_CONNECT2_OFF 204 +#define IDC_COMMAND 1000 +#define IDC_OUTPUT 1010 +#define IDC_CONFIG_XBOXNAME 1015 +#define IDC_CONFIG_REMOTEPATH 1016 +#define IDC_CONFIG_LOCALPATH 1017 +#define IDC_CONFIG_PING 1018 +#define IDC_OK 1019 +#define IDC_CANCEL 1020 +#define IDC_CONFIG_CLEARONCONNECT 1021 +#define IDC_CONFIG_TARGETPATH 1022 +#define IDC_CONFIG_XBELOCALPATH 1023 +#define IDC_CONFIG_XEXLOCALPATH 1023 +#define IDC_CONFIG_XBETARGETPATH 1024 +#define IDC_CONFIG_XEXTARGETPATH 1024 +#define IDC_CONFIG_INSTALLPATH 1025 +#define IDC_CONFIG_LOADSYMBOLS 1028 +#define IDC_SYNCFILES_LOCALPATH 1029 +#define IDC_SYNCFILES_TARGETPATH 1030 +#define IDC_SYNCFILES_FORCESYNC 1035 +#define IDC_SYNCFILES_NOWRITE 1036 +#define IDC_SYNCFILES_DELETEORPHANS 1037 +#define IDC_CONFIG_SAMPLEFILE 1038 +#define IDC_SYNCFILES_VERBOSE 1038 +#define IDC_CONFIG_SAMPLELOCAL 1039 +#define IDC_SYNCFILES_ANDEXISTSONXBOX 1039 +#define IDC_CONFIG_SAMPLETARGET 1040 +#define IDC_CONFIG_XBEFORCESYNC 1045 +#define IDC_CONFIG_XEXFORCESYNC 1045 +#define IDC_CONFIG_XBESYNCONCONNECT 1046 +#define IDC_CONFIG_XEXSYNCONCONNECT 1046 +#define IDC_MODIFYBIND_MENUNAME 1050 +#define IDC_MODIFYBIND_COMMAND 1051 +#define IDC_MODIFYBIND_KEYCODE 1052 +#define IDC_CONFIG_ALWAYSAUTOCONNECT 1053 +#define IDC_CONFIG_STARTMINIMIZED 1054 +#define IDC_CONFIG_CAPTUREDEBUGSPEW 1055 +#define IDC_BUG_CLEARFORM 1056 +#define IDC_BUG_TITLE 1057 +#define IDC_BUG_DESCRIPTION 1058 +#define IDC_BUG_CLEARFORM2 1059 +#define IDC_BUG_UPDATE 1059 +#define IDC_BUG_INCLUDEBSP 1060 +#define IDC_BUG_SAVEGAME 1061 +#define IDC_BUG_INCLUDEVMF 1062 +#define IDC_BUG_TAKESHOT 1063 +#define IDC_BUG_SEVERITY 1065 +#define IDC_BUG_REPORTTYPE 1066 +#define IDC_BUG_PRIORITY 1067 +#define IDC_BUG_AREA 1068 +#define IDC_BUG_TAKESHOT_LABEL 1069 +#define IDC_BUG_SAVEGAME_LABEL 1070 +#define IDC_BUG_INCLUDEBSP_LABEL 1071 +#define IDC_BUG_INCLUDEVMF_LABEL 1072 +#define IDC_BUG_POSITION_LABEL 1073 +#define IDC_BUG_ORIENTATION_LABEL 1074 +#define IDC_BUG_MAP_LABEL 1075 +#define IDC_BUG_BUILD_LABEL 1076 +#define IDC_BUG_SUBMITTER_LABEL 1077 +#define IDC_BUG_MAPNUMBER 1078 +#define IDC_BUG_SUBMIT 1079 +#define IDC_BUG_SEVERITY2 1080 +#define IDC_BUG_OWNER 1080 +#define IDC_BUG_GAME 1082 +#define IDC_CHECK1 1083 +#define IDC_BUG_COMPRESS_SCREENSHOT 1083 +#define IDC_PATHS_LINKGAMEDIRS 1083 +#define IDC_INSTALL_FORCESYNC 1083 +#define IDC_PATHS_TREE 1085 +#define IDC_PATHS_RESCAN 1086 +#define IDC_PATHS_EXPAND 1087 +#define IDC_PATHS_COLLAPSE 1088 +#define IDC_INSTALL_LIST 1088 +#define IDC_INSTALL_REFRESH 1089 +#define IDC_CHECK2 1091 +#define IDC_INSTALL_CLEANTARGET 1091 +#define IDR_MAIN_ACCEL 3000 +#define IDM_CONNECT 40002 +#define IDM_DEBUGMONITOR 40004 +#define IDM_DEBUGCOMMANDS 40008 +#define IDM_AUTOCONNECT 40009 +#define IDM_DISCONNECT 40013 +#define IDM_EXIT 40017 +#define IDM_CONFIG 40018 +#define IDM_DEBUGMEMORY 40019 +#define IDM_FILELOG 40021 +#define IDM_CLEARLOG 40026 +#define IDM_ENABLELOG 40027 +#define IDM_REFRESHLOG 40031 +#define ID_LOG_SUMMARY 40032 +#define IDM_SUMMARYLOG 40035 +#define ID_Menu 40048 +#define IDM_PROFILESAMPLES 40064 +#define IDM_PROFILEHISTORY 40066 +#define IDM_SYNCTARGET 40073 +#define IDM_SYNCIFNEWER 40074 +#define IDM_ENABLEFILESERVING 40075 +#define ID_CONNECTION_FILESERVING 40076 +#define IDM_FILESERVING_LOCALONLY 40080 +#define IDM_FILESERVING_REMOTEONLY 40081 +#define IDM_FILESERVING_LOCALFIRST 40083 +#define IDM_FILESYNC_OFF 40088 +#define IDM_FILESYNC_ALWAYS 40089 +#define IDM_FILESYNC_IFNEWER 40090 +#define IDM_EXPORTLOG 40092 +#define ID_Menu40094 40094 +#define IDM_SYMBOLS_ADDRESS 40106 +#define IDM_SYMBOLS_FUNCTIONNAME 40110 +#define IDM_SYMBOLS_MODULEANDLINE 40112 +#define IDM_SYMBOLS_FILEPATHANDLINE 40114 +#define IDM_SYMBOLS_LOAD 40116 +#define IDM_SYNCFILES 40117 +#define IDM_SYMBOLS_DETAILS 40119 +#define IDM_OPTIONS_TREEVIEW 40121 +#define ID_Menu40123 40123 +#define IDM_SHOWMATERIALS 40124 +#define IDM_REFRESH 40127 +#define IDM_SHOWRESOURCES_TEXTURES 40130 +#define IDM_OPTIONS_CURRENTFRAME 40132 +#define IDM_OPTIONS_SUMMARY 40135 +#define IDM_OPTIONS_REFRESH 40136 +#define IDM_OPTIONS_EXPORT 40137 +#define IDM_OPTIONS_FULLPATH 40139 +#define ID_CONNECTION_PROFILING 40140 +#define ID_PROFILING_CPU 40141 +#define ID_PROFILING_TEXTURE 40142 +#define ID_CONNECTION_TEXTUREPROFILING 40147 +#define IDM_CPU_SAMPLES 40148 +#define IDM_CPU_HISTORY 40149 +#define IDM_SHOWRESOURCES_MATERIALS 40154 +#define IDM_SHOWRESOURCES_MODELS 40155 +#define ID_CONNECTION_EE 40157 +#define IDM_CPUPROFILE_TICKMARKS 40160 +#define IDM_CPUPROFILE_COLORS 40161 +#define IDM_CPUPROFILE_ZOOMIN 40162 +#define IDM_CPUPROFILE_ZOOMOUT 40163 +#define IDM_CPUPROFILE_ENABLE 40164 +#define IDM_TEXPROFILE_TICKMARKS 40166 +#define IDM_TEXPROFILE_COLORS 40168 +#define IDM_TEXPROFILE_ZOOMIN 40172 +#define IDM_TEXPROFILE_ZOOMOUT 40173 +#define IDM_TEXPROFILE_ENABLE 40174 +#define IDM_TEXPROFILE_CURRENTFRAME 40176 +#define ID_Menu40177 40177 +#define ID_VPROFILING_SHOWTEXTURE 40178 +#define ID_Menu40189 40189 +#define IDM_BINDOPTIONS_MODIFY 40192 +#define IDM_BINDOPTIONS_DELETE 40193 +#define IDM_TIMESTAMPLOG 50502 +#define IDM_CPUPROFILE_FPSLABELS 50505 +#define IDM_SHOWRESOURCES_SOUNDS 50509 +#define IDM_OPTIONS_PLAYSOUND 50513 +#define IDM_D3D_SAMPLES 50516 +#define IDM_D3D_HISTORY 50517 +#define IDM_MEMORYDUMP 50520 +#define IDM_OPTIONS_BYTES 50527 +#define IDM_OPTIONS_KILOBYTES 50530 +#define IDM_OPTIONS_MEGABYTES 50531 +#define IDM_OPTIONS_COLLAPSEOUTPUT 50533 +#define IDM_SYNCINSTALL 50535 +#define ID_Menu50536 50536 +#define IDM_FILESYNC_ANDEXISTSONTARGET 50539 +#define ID_CONNECTION_SEARCHPATHS 50540 +#define ID_SEARCHPATHS_NOZIPS 50541 +#define ID_SEARCHPATHS_PAKFILESFIRST 50542 +#define ID_SEARCHPATHS_PAKFILES 50543 +#define ID_Menu50546 50546 +#define IDM_SYNCINSTALL_TODVD 50547 +#define IDM_SYNCINSTALL_TOHDD 50548 +#define IDM_SHOWRESOURCES_BUG 50550 +#define IDM_BUG 50552 +#define IDM_SYNCXEX 50553 +#define IDM_DEBUGSPEW 50557 +#define IDM_CAPTUREGAMESPEW 50560 +#define IDM_CAPTUREDEBUGSPEW 50561 +#define ID_CONNECTION_DVDEXCLUDEPATHS 50562 +#define IDM_DVDEXCLUDEPATHS 50563 +#define IDM_EXCLUDEPATHS 50564 +#define ID_OPTIONS_SHOWTEXTURE 50565 +#define IDM_OPTIONS_SHOWTEXTURE 50566 +#define IDM_OPTIONS_DRAWTEXTURE 50567 +#define ID_OPTIONS_HIDETEXTURE 50568 +#define IDM_OPTIONS_HIDETEXTURE 50569 +#define ID_PROFILING_SHOWMEMORYUSAGE 50570 +#define IDM_SHOWMEMORYUSAGE 50571 +#define IDM_SHOWFREEMEMORY 50572 +#define ID_OPTIONS_TICKMARKS 50573 +#define ID_OPTIONS_ZOOMIN 50574 +#define ID_OPTIONS_ZOOMOUT 50575 +#define ID_OPTIONS_ENABLE 50576 +#define IDM_MEMPROFILE_TICKMARKS 50577 +#define IDM_MEMPROFILE_ZOOMIN 50578 +#define IDM_MEMPROFILE_ZOOMOUT 50579 +#define IDM_MEMPROFILE_ENABLE 50580 +#define ID_OPTIONS_COLORS 50581 +#define IDM_MEMPROFILE_COLORS 50582 +#define ID_OPTIONS_CLEAR 50583 +#define IDM_OPTIONS_CLEAR 50584 +#define ID_PROFILING_TESTINGMODE 50585 +#define IDM_PLAYTESTMODE 50586 +#define IDC_STATIC -1 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NO_MFC 1 +#define _APS_NEXT_RESOURCE_VALUE 134 +#define _APS_NEXT_COMMAND_VALUE 50587 +#define _APS_NEXT_CONTROL_VALUE 1092 +#define _APS_NEXT_SYMED_VALUE 110 +#endif +#endif diff --git a/utils/xbox/vxconsole/show_materials.cpp b/utils/xbox/vxconsole/show_materials.cpp new file mode 100644 index 0000000..f57f5f9 --- /dev/null +++ b/utils/xbox/vxconsole/show_materials.cpp @@ -0,0 +1,575 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// SHOW_MATERIALS.CPP +// +// Show Materials Display. +//=====================================================================================// +#include "vxconsole.h" + +#define ID_SHOWMATERIALS_LISTVIEW 100 + +// column id +#define ID_SM_NAME 0 +#define ID_SM_SHADER 1 +#define ID_SM_REFCOUNT 2 + +typedef struct +{ + int listIndex; + char *pName; + char *pShaderName; + int refCount; + char refCountBuff[16]; +} material_t; + +typedef struct +{ const CHAR* name; + int width; + int subItemIndex; + CHAR nameBuff[32]; +} label_t; + +HWND g_showMaterials_hWnd; +HWND g_showMaterials_hWndListView; +RECT g_showMaterials_windowRect; +int g_showMaterials_sortColumn; +int g_showMaterials_sortDescending; +material_t *g_showMaterials_pMaterials; +int g_showMaterials_numMaterials; +int g_showMaterials_currentFrame; + +label_t g_showMaterials_Labels[] = +{ + {"Name", 300, ID_SM_NAME}, + {"Shader", 150, ID_SM_SHADER}, + {"RefCount", 80, ID_SM_REFCOUNT}, +}; + +//----------------------------------------------------------------------------- +// ShowMaterials_SaveConfig +// +//----------------------------------------------------------------------------- +void ShowMaterials_SaveConfig() +{ + char buff[256]; + + Sys_SetRegistryInteger( "showMaterialsCurrentFrame", g_showMaterials_currentFrame ); + Sys_SetRegistryInteger( "showMaterialsSortColumn", g_showMaterials_sortColumn ); + Sys_SetRegistryInteger( "showMaterialsSortDescending", g_showMaterials_sortDescending ); + + WINDOWPLACEMENT wp; + memset( &wp, 0, sizeof( wp ) ); + wp.length = sizeof( WINDOWPLACEMENT ); + GetWindowPlacement( g_showMaterials_hWnd, &wp ); + g_showMaterials_windowRect = wp.rcNormalPosition; + + sprintf( buff, "%d %d %d %d", g_showMaterials_windowRect.left, g_showMaterials_windowRect.top, g_showMaterials_windowRect.right, g_showMaterials_windowRect.bottom ); + Sys_SetRegistryString( "showMaterialsWindowRect", buff ); +} + +//----------------------------------------------------------------------------- +// ShowMaterials_LoadConfig +// +//----------------------------------------------------------------------------- +void ShowMaterials_LoadConfig() +{ + int numArgs; + char buff[256]; + + Sys_GetRegistryInteger( "showMaterialsCurrentFrame", false, g_showMaterials_currentFrame ); + Sys_GetRegistryInteger( "showMaterialsSortColumn", ID_SM_NAME, g_showMaterials_sortColumn ); + Sys_GetRegistryInteger( "showMaterialsSortDescending", false, g_showMaterials_sortDescending ); + + Sys_GetRegistryString( "showMaterialsWindowRect", buff, "", sizeof( buff ) ); + numArgs = sscanf( buff, "%d %d %d %d", &g_showMaterials_windowRect.left, &g_showMaterials_windowRect.top, &g_showMaterials_windowRect.right, &g_showMaterials_windowRect.bottom ); + if ( numArgs != 4 || g_showMaterials_windowRect.left < 0 || g_showMaterials_windowRect.top < 0 || g_showMaterials_windowRect.right < 0 || g_showMaterials_windowRect.bottom < 0 ) + memset( &g_showMaterials_windowRect, 0, sizeof( g_showMaterials_windowRect ) ); +} + +//----------------------------------------------------------------------------- +// ShowMaterials_Clear +// +//----------------------------------------------------------------------------- +void ShowMaterials_Clear() +{ + // delete all the list view entries + if ( g_showMaterials_hWnd ) + ListView_DeleteAllItems( g_showMaterials_hWndListView ); + + if ( !g_showMaterials_pMaterials ) + return; + + for ( int i=0; i<g_showMaterials_numMaterials; i++ ) + { + free( g_showMaterials_pMaterials[i].pName ); + free( g_showMaterials_pMaterials[i].pShaderName ); + } + + g_showMaterials_pMaterials = NULL; + g_showMaterials_numMaterials = 0; +} + +//----------------------------------------------------------------------------- +// ShowMaterials_Export +// +//----------------------------------------------------------------------------- +void ShowMaterials_Export() +{ +} + +//----------------------------------------------------------------------------- +// ShowMaterials_SetTitle +// +//----------------------------------------------------------------------------- +void ShowMaterials_SetTitle() +{ + char titleBuff[128]; + + if ( g_showMaterials_hWnd ) + { + strcpy( titleBuff, "Materials " ); + if ( g_showMaterials_currentFrame ) + strcat( titleBuff, " [FRAME]" ); + + SetWindowText( g_showMaterials_hWnd, titleBuff ); + } +} + +//----------------------------------------------------------------------------- +// ShowMaterials_CompareFunc +// +//----------------------------------------------------------------------------- +int CALLBACK ShowMaterials_CompareFunc( LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort ) +{ + material_t* pMaterialA = ( material_t* )lParam1; + material_t* pMaterialB = ( material_t* )lParam2; + + int sort = 0; + switch ( g_showMaterials_sortColumn ) + { + case ID_SM_NAME: + sort = stricmp( pMaterialA->pName, pMaterialB->pName ); + break; + + case ID_SM_SHADER: + sort = stricmp( pMaterialA->pShaderName, pMaterialB->pShaderName ); + break; + + case ID_SM_REFCOUNT: + sort = pMaterialA->refCount - pMaterialB->refCount; + break; + } + + // flip the sort order + if ( g_showMaterials_sortDescending ) + sort *= -1; + + return ( sort ); +} + +//----------------------------------------------------------------------------- +// ShowMaterials_SortItems +// +//----------------------------------------------------------------------------- +void ShowMaterials_SortItems() +{ + LVITEM lvitem; + material_t *pMaterial; + int i; + + if ( !g_showMaterials_hWnd ) + { + // only sort if window is visible + return; + } + + ListView_SortItems( g_showMaterials_hWndListView, ShowMaterials_CompareFunc, 0 ); + + memset( &lvitem, 0, sizeof( lvitem ) ); + lvitem.mask = LVIF_PARAM; + + // get each item and reset its list index + int itemCount = ListView_GetItemCount( g_showMaterials_hWndListView ); + for ( i=0; i<itemCount; i++ ) + { + lvitem.iItem = i; + ListView_GetItem( g_showMaterials_hWndListView, &lvitem ); + + pMaterial = ( material_t* )lvitem.lParam; + pMaterial->listIndex = i; + } + + // update list view columns with sort key + for ( i=0; i<sizeof( g_showMaterials_Labels )/sizeof( g_showMaterials_Labels[0] ); i++ ) + { + char symbol; + LVCOLUMN lvc; + + if ( i == g_showMaterials_sortColumn ) + symbol = g_showMaterials_sortDescending ? '<' : '>'; + else + symbol = ' '; + sprintf( g_showMaterials_Labels[i].nameBuff, "%s %c", g_showMaterials_Labels[i].name, symbol ); + + memset( &lvc, 0, sizeof( lvc ) ); + lvc.mask = LVCF_TEXT; + lvc.pszText = ( LPSTR )g_showMaterials_Labels[i].nameBuff; + + ListView_SetColumn( g_showMaterials_hWndListView, i, &lvc ); + } +} + +//----------------------------------------------------------------------------- +// ShowMaterials_AddViewItem +// +//----------------------------------------------------------------------------- +void ShowMaterials_AddViewItem( material_t* pMaterial ) +{ + LVITEM lvi; + + if ( !g_showMaterials_hWnd ) + { + // only valid if log window is visible + return; + } + + // update the text callback buffers + sprintf( pMaterial->refCountBuff, "%d", pMaterial->refCount ); + + int itemCount = ListView_GetItemCount( g_showMaterials_hWndListView ); + + // setup and insert at end of list + memset( &lvi, 0, sizeof( lvi ) ); + lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE; + lvi.iItem = itemCount; + lvi.iSubItem = 0; + lvi.state = 0; + lvi.stateMask = 0; + lvi.pszText = LPSTR_TEXTCALLBACK; + lvi.lParam = ( LPARAM )pMaterial; + + // insert and set the real index + pMaterial->listIndex = ListView_InsertItem( g_showMaterials_hWndListView, &lvi ); +} + +//----------------------------------------------------------------------------- +// ShowMaterials_Refresh +// +//----------------------------------------------------------------------------- +void ShowMaterials_Refresh() +{ + char command[256]; + + strcpy( command, "mat_material_list" ); + +// if ( !g_showMaterials_currentFrame ) +// strcat( command, " all" ); + + // send the command to application which replies with list data + if ( g_connectedToApp ) + ProcessCommand( command ); +} + +//----------------------------------------------------------------------------- +// ShowMaterials_SizeWindow +// +//----------------------------------------------------------------------------- +void ShowMaterials_SizeWindow( HWND hwnd, int cx, int cy ) +{ + if ( cx==0 || cy==0 ) + { + RECT rcClient; + GetClientRect( hwnd, &rcClient ); + cx = rcClient.right; + cy = rcClient.bottom; + } + + // position the ListView + SetWindowPos( g_showMaterials_hWndListView, NULL, 0, 0, cx, cy, SWP_NOZORDER ); +} + +//----------------------------------------------------------------------------- +// ShowMaterials_WndProc +// +//----------------------------------------------------------------------------- +LRESULT CALLBACK ShowMaterials_WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + WORD wID = LOWORD( wParam ); + material_t* pMaterial; + + switch ( message ) + { + case WM_CREATE: + return 0L; + + case WM_DESTROY: + ShowMaterials_SaveConfig(); + g_showMaterials_hWnd = NULL; + return 0L; + + case WM_INITMENU: + CheckMenuItem( ( HMENU )wParam, IDM_OPTIONS_CURRENTFRAME, MF_BYCOMMAND | ( g_showMaterials_currentFrame ? MF_CHECKED : MF_UNCHECKED ) ); + return 0L; + + case WM_SIZE: + ShowMaterials_SizeWindow( hwnd, LOWORD( lParam ), HIWORD( lParam ) ); + return 0L; + + case WM_NOTIFY: + switch ( ( ( LPNMHDR )lParam )->code ) + { + case LVN_COLUMNCLICK: + NMLISTVIEW* pnmlv; + pnmlv = ( NMLISTVIEW* )lParam; + if ( g_showMaterials_sortColumn == pnmlv->iSubItem ) + { + // user has clicked on same column - flip the sort + g_showMaterials_sortDescending ^= 1; + } + else + { + // sort by new column + g_showMaterials_sortColumn = pnmlv->iSubItem; + } + ShowMaterials_SortItems(); + return 0L; + + case LVN_GETDISPINFO: + NMLVDISPINFO* plvdi; + plvdi = ( NMLVDISPINFO* )lParam; + pMaterial = ( material_t* )plvdi->item.lParam; + switch ( plvdi->item.iSubItem ) + { + case ID_SM_NAME: + plvdi->item.pszText = pMaterial->pName; + return 0L; + + case ID_SM_SHADER: + plvdi->item.pszText = pMaterial->pShaderName; + return 0L; + + case ID_SM_REFCOUNT: + plvdi->item.pszText = pMaterial->refCountBuff; + return 0L; + + default: + break; + } + break; + } + break; + + case WM_COMMAND: + switch ( wID ) + { + case IDM_OPTIONS_REFRESH: + ShowMaterials_Refresh(); + return 0L; + + case IDM_OPTIONS_EXPORT: + ShowMaterials_Export(); + return 0L; + + case IDM_OPTIONS_CURRENTFRAME: + g_showMaterials_currentFrame ^= 1; + ShowMaterials_SetTitle(); + ShowMaterials_Refresh(); + return 0L; + } + break; + } + + return ( DefWindowProc( hwnd, message, wParam, lParam ) ); +} + +//----------------------------------------------------------------------------- +// ShowMaterials_Init +// +//----------------------------------------------------------------------------- +bool ShowMaterials_Init() +{ + // set up our window class + WNDCLASS wndclass; + + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = ShowMaterials_WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = 0; + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_APPLICATION]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = MAKEINTRESOURCE( MENU_SHOWMATERIALS ); + wndclass.lpszClassName = "SHOWMATERIALSCLASS"; + if ( !RegisterClass( &wndclass ) ) + return false; + + ShowMaterials_LoadConfig(); + + return true; +} + +//----------------------------------------------------------------------------- +// ShowMaterials_Open +// +//----------------------------------------------------------------------------- +void ShowMaterials_Open() +{ + RECT clientRect; + HWND hWnd; + int i; + + if ( g_showMaterials_hWnd ) + { + // only one instance + if ( IsIconic( g_showMaterials_hWnd ) ) + ShowWindow( g_showMaterials_hWnd, SW_RESTORE ); + SetForegroundWindow( g_showMaterials_hWnd ); + return; + } + + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + "SHOWMATERIALSCLASS", + "", + WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX, + 0, + 0, + 700, + 400, + g_hDlgMain, + NULL, + g_hInstance, + NULL ); + g_showMaterials_hWnd = hWnd; + + GetClientRect( g_showMaterials_hWnd, &clientRect ); + hWnd = CreateWindow( + WC_LISTVIEW, + "", + WS_VISIBLE|WS_CHILD|LVS_REPORT, + 0, + 0, + clientRect.right-clientRect.left, + clientRect.bottom-clientRect.top, + g_showMaterials_hWnd, + ( HMENU )ID_SHOWMATERIALS_LISTVIEW, + g_hInstance, + NULL ); + g_showMaterials_hWndListView = hWnd; + + // init list view columns + for ( i=0; i<sizeof( g_showMaterials_Labels )/sizeof( g_showMaterials_Labels[0] ); i++ ) + { + LVCOLUMN lvc; + memset( &lvc, 0, sizeof( lvc ) ); + + lvc.mask = LVCF_FMT|LVCF_WIDTH|LVCF_TEXT|LVCF_SUBITEM; + lvc.iSubItem = 0; + lvc.cx = g_showMaterials_Labels[i].width; + lvc.fmt = LVCFMT_LEFT; + lvc.pszText = ( LPSTR )g_showMaterials_Labels[i].name; + + ListView_InsertColumn( g_showMaterials_hWndListView, i, &lvc ); + } + + ListView_SetBkColor( g_showMaterials_hWndListView, g_backgroundColor ); + ListView_SetTextBkColor( g_showMaterials_hWndListView, g_backgroundColor ); + + DWORD style = LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES|LVS_EX_HEADERDRAGDROP; + ListView_SetExtendedListViewStyleEx( g_showMaterials_hWndListView, style, style ); + + // populate list view + for ( i=0; i<g_showMaterials_numMaterials; i++ ) + ShowMaterials_AddViewItem( &g_showMaterials_pMaterials[i] ); + ShowMaterials_SortItems(); + + ShowMaterials_SetTitle(); + + if ( g_showMaterials_windowRect.right && g_showMaterials_windowRect.bottom ) + MoveWindow( g_showMaterials_hWnd, g_showMaterials_windowRect.left, g_showMaterials_windowRect.top, g_showMaterials_windowRect.right-g_showMaterials_windowRect.left, g_showMaterials_windowRect.bottom-g_showMaterials_windowRect.top, FALSE ); + ShowWindow( g_showMaterials_hWnd, SHOW_OPENWINDOW ); + + // get data from application + ShowMaterials_Refresh(); +} + +//----------------------------------------------------------------------------- +// rc_MaterialList +// +// Sent from application with material list +//----------------------------------------------------------------------------- +int rc_MaterialList( char* commandPtr ) +{ + char* cmdToken; + int numMaterials; + int materialList; + int retAddr; + int retVal; + int errCode = -1; + xrMaterial_t* pLocalList; + + // remove old entries + ShowMaterials_Clear(); + + // get number of materials + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &numMaterials ); + + // get material list + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &materialList ); + + // get retAddr + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &retAddr ); + + pLocalList = new xrMaterial_t[numMaterials]; + memset( pLocalList, 0, numMaterials*sizeof( xrMaterial_t ) ); + + g_showMaterials_numMaterials = numMaterials; + g_showMaterials_pMaterials = new material_t[numMaterials]; + memset( g_showMaterials_pMaterials, 0, numMaterials*sizeof( material_t ) ); + + // get the caller's command list + DmGetMemory( ( void* )materialList, numMaterials*sizeof( xrMaterial_t ), pLocalList, NULL ); + + // build out the resident list + for ( int i=0; i<numMaterials; i++ ) + { + // swap the structure + pLocalList[i].refCount = BigDWord( pLocalList[i].refCount ); + + g_showMaterials_pMaterials[i].pName = strdup( pLocalList[i].nameString ); + g_showMaterials_pMaterials[i].pShaderName = strdup( pLocalList[i].shaderString ); + g_showMaterials_pMaterials[i].refCount = pLocalList[i].refCount; + + // add to list view + ShowMaterials_AddViewItem( &g_showMaterials_pMaterials[i] ); + } + + // return the result + retVal = numMaterials; + int xboxRetVal = BigDWord( retVal ); + DmSetMemory( ( void* )retAddr, sizeof( int ), &xboxRetVal, NULL ); + + DebugCommand( "0x%8.8x = MaterialList( 0x%8.8x, 0x%8.8x )\n", retVal, numMaterials, materialList ); + + delete [] pLocalList; + + // update + ShowMaterials_SortItems(); + + // success + errCode = 0; + +cleanUp: + return ( errCode ); +} diff --git a/utils/xbox/vxconsole/show_memdump.cpp b/utils/xbox/vxconsole/show_memdump.cpp new file mode 100644 index 0000000..fc86833 --- /dev/null +++ b/utils/xbox/vxconsole/show_memdump.cpp @@ -0,0 +1,1440 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// SHOW_MEMDUMP.CPP +// +// Show Mem Dump Display. +//=====================================================================================// +#include "vxconsole.h" + +#define ID_SHOWMEMDUMP_LISTVIEW 100 + +// column id, pool mode +#define ID_DUMPPOOL_POOL 0 +#define ID_DUMPPOOL_SIZE 1 +#define ID_DUMPPOOL_ALLOCATED 2 +#define ID_DUMPPOOL_FREE 3 +#define ID_DUMPPOOL_COMMITTED 4 +#define ID_DUMPPOOL_COMMITTEDSIZE 5 + +// column id, detailed mode +#define ID_DUMPDETAIL_ALLOCATION 0 +#define ID_DUMPDETAIL_CURRENTSIZE 1 +#define ID_DUMPDETAIL_PEAKSIZE 2 +#define ID_DUMPDETAIL_TOTALSIZE 3 +#define ID_DUMPDETAIL_OVERHEAD 4 +#define ID_DUMPDETAIL_PEAKOVERHEAD 5 +#define ID_DUMPDETAIL_TIME 6 +#define ID_DUMPDETAIL_CURRENTCOUNT 7 +#define ID_DUMPDETAIL_PEAKCOUNT 8 +#define ID_DUMPDETAIL_TOTALCOUNT 9 +#define ID_DUMPDETAIL_LTE16 10 +#define ID_DUMPDETAIL_LTE32 11 +#define ID_DUMPDETAIL_LTE128 12 +#define ID_DUMPDETAIL_LTE1024 13 +#define ID_DUMPDETAIL_GT1024 14 + +#define SHOW_BYTES 0 +#define SHOW_KILOBYTES 1 +#define SHOW_MEGABYTES 2 + +#define FORMAT_POOLS 0 +#define FORMAT_DETAILS 1 + +struct MemoryPool_t +{ + int pool; + char poolBuff[32]; + int size; + char sizeBuff[32]; + int allocated; + char allocatedBuff[32]; + int free; + char freeBuff[32]; + int committed; + char committedBuff[32]; + int committedSize; + char committedSizeBuff[32]; +}; + +struct MemoryDetail_t +{ + char *pAllocationName; + int currentSize; + char currentSizeBuff[32]; + int peakSize; + char peakSizeBuff[32]; + int totalSize; + char totalSizeBuff[32]; + int overheadSize; + char overheadSizeBuff[32]; + int peakOverheadSize; + char peakOverheadSizeBuff[32]; + int time; + char timeBuff[32]; + int currentCount; + char currentCountBuff[32]; + int peakCount; + char peakCountBuff[32]; + int totalCount; + char totalCountBuff[32]; + int lte16; + char lte16Buff[32]; + int lte32; + char lte32Buff[32]; + int lte128; + char lte128Buff[32]; + int lte1024; + char lte1024Buff[32]; + int gt1024; + char gt1024Buff[32]; +}; + +struct memory_t +{ + int listIndex; + MemoryPool_t pool; + MemoryDetail_t detail; +}; + +struct label_t +{ + const CHAR* name; + int width; + int subItemIndex; + CHAR nameBuff[64]; +}; + +HWND g_showMemDump_hWnd; +HWND g_showMemDump_hWndListView; +RECT g_showMemDump_windowRect; +int g_showMemDump_sortColumn; +int g_showMemDump_sortDescending; +memory_t *g_showMemDump_pMemory; +int g_showMemDump_numMemory; +int g_showMemDump_showBytes; +bool g_showMemDump_bCollapseOutput; +char g_showMemDump_currentFilename[MAX_PATH]; +int g_showMemDump_format; + +void ShowMemDump_Parse( const char *pBuffer, int fileSize ); + +label_t g_showMemDump_PoolLabels[] = +{ + {"Pool", 120, ID_DUMPPOOL_POOL}, + {"Size", 120, ID_DUMPPOOL_SIZE}, + {"Allocated Count", 120, ID_DUMPPOOL_ALLOCATED}, + {"Free Count", 120, ID_DUMPPOOL_FREE}, + {"Committed Count", 120, ID_DUMPPOOL_COMMITTED}, + {"Committed Size", 120, ID_DUMPPOOL_COMMITTEDSIZE}, +}; + +label_t g_showMemDump_DetailLabels[] = +{ + {"Allocation", 200, ID_DUMPDETAIL_ALLOCATION}, + {"Current Size", 120, ID_DUMPDETAIL_CURRENTSIZE}, + {"Peak Size", 120, ID_DUMPDETAIL_PEAKSIZE}, + {"Total Allocations", 120, ID_DUMPDETAIL_TOTALSIZE}, + {"Overhead Size", 120, ID_DUMPDETAIL_OVERHEAD}, + {"Peak Overhead Size", 120, ID_DUMPDETAIL_PEAKOVERHEAD}, + {"Time (ms)", 120, ID_DUMPDETAIL_TIME}, + {"Current Count", 120, ID_DUMPDETAIL_CURRENTCOUNT}, + {"Peak Count", 120, ID_DUMPDETAIL_PEAKCOUNT}, + {"Total Count", 120, ID_DUMPDETAIL_TOTALCOUNT}, + {"<=16 bytes", 100, ID_DUMPDETAIL_LTE16}, + {"17-32 bytes", 100, ID_DUMPDETAIL_LTE32}, + {"33-128 bytes", 100, ID_DUMPDETAIL_LTE128}, + {"129-1024 bytes", 100, ID_DUMPDETAIL_LTE1024}, + {"> 1024 bytes", 100, ID_DUMPDETAIL_GT1024}, +}; + +//----------------------------------------------------------------------------- +// ShowMemDump_FormatSize +// +//----------------------------------------------------------------------------- +char *ShowMemDump_FormatSize( int size, char *pBuff, bool bUnits ) +{ + switch ( g_showMemDump_showBytes ) + { + case SHOW_BYTES: + sprintf( pBuff, "%d", size ); + break; + + case SHOW_KILOBYTES: + sprintf( pBuff, "%.2f", (float)size/1024.0f ); + if ( bUnits ) + strcat( pBuff, " K"); + break; + + case SHOW_MEGABYTES: + sprintf( pBuff, "%.2f", (float)size/(1024.0f*1024.0f) ); + if ( bUnits ) + strcat( pBuff, " MB"); + break; + } + + return pBuff; +} + + +//----------------------------------------------------------------------------- +// ShowMemDump_SaveConfig +// +//----------------------------------------------------------------------------- +void ShowMemDump_SaveConfig() +{ + char buff[256]; + + Sys_SetRegistryInteger( "showMemDumpSortColumn", g_showMemDump_sortColumn ); + Sys_SetRegistryInteger( "showMemDumpSortDescending", g_showMemDump_sortDescending ); + Sys_SetRegistryInteger( "showMemDumpShowBytes", g_showMemDump_showBytes ); + + WINDOWPLACEMENT wp; + memset( &wp, 0, sizeof( wp ) ); + wp.length = sizeof( WINDOWPLACEMENT ); + GetWindowPlacement( g_showMemDump_hWnd, &wp ); + g_showMemDump_windowRect = wp.rcNormalPosition; + + sprintf( buff, "%d %d %d %d", g_showMemDump_windowRect.left, g_showMemDump_windowRect.top, g_showMemDump_windowRect.right, g_showMemDump_windowRect.bottom ); + Sys_SetRegistryString( "showMemDumpWindowRect", buff ); +} + +//----------------------------------------------------------------------------- +// ShowMemDump_LoadConfig +// +//----------------------------------------------------------------------------- +void ShowMemDump_LoadConfig() +{ + int numArgs; + char buff[256]; + + Sys_GetRegistryInteger( "showMemDumpSortColumn", 0, g_showMemDump_sortColumn ); + Sys_GetRegistryInteger( "showMemDumpSortDescending", false, g_showMemDump_sortDescending ); + Sys_GetRegistryInteger( "showMemDumpShowBytes", SHOW_KILOBYTES, g_showMemDump_showBytes ); + + Sys_GetRegistryString( "showMemDumpWindowRect", buff, "", sizeof( buff ) ); + numArgs = sscanf( buff, "%d %d %d %d", &g_showMemDump_windowRect.left, &g_showMemDump_windowRect.top, &g_showMemDump_windowRect.right, &g_showMemDump_windowRect.bottom ); + if ( numArgs != 4 || g_showMemDump_windowRect.left < 0 || g_showMemDump_windowRect.top < 0 || g_showMemDump_windowRect.right < 0 || g_showMemDump_windowRect.bottom < 0 ) + memset( &g_showMemDump_windowRect, 0, sizeof( g_showMemDump_windowRect ) ); +} + +//----------------------------------------------------------------------------- +// ShowMemDump_Clear +// +//----------------------------------------------------------------------------- +void ShowMemDump_Clear() +{ + // delete all the list view entries + if ( g_showMemDump_hWnd ) + { + ListView_DeleteAllItems( g_showMemDump_hWndListView ); + } + + if ( !g_showMemDump_pMemory ) + return; + + for ( int i=0; i<g_showMemDump_numMemory; i++ ) + { + delete [] g_showMemDump_pMemory[i].detail.pAllocationName; + } + + Sys_Free( g_showMemDump_pMemory ); + + g_showMemDump_pMemory = NULL; + g_showMemDump_numMemory = 0; +} + +//----------------------------------------------------------------------------- +// ShowMemDump_Export +// +//----------------------------------------------------------------------------- +void ShowMemDump_Export() +{ + OPENFILENAME ofn; + char logFilename[MAX_PATH]; + int retval; + FILE* fp; + int i; + char buff[64]; + + if ( g_showMemDump_format != FORMAT_DETAILS ) + { + return; + } + + memset( &ofn, 0, sizeof( ofn ) ); + ofn.lStructSize = sizeof( ofn ); + ofn.hwndOwner = g_showMemDump_hWnd; + ofn.lpstrFile = logFilename; + ofn.lpstrFile[0] = '\0'; + ofn.nMaxFile = sizeof( logFilename ); + ofn.lpstrFilter = "Excel CSV\0*.CSV\0All Files\0*.*\0"; + ofn.nFilterIndex = 1; + ofn.lpstrFileTitle = NULL; + ofn.nMaxFileTitle = 0; + ofn.lpstrInitialDir = "c:\\"; + ofn.Flags = OFN_PATHMUSTEXIST; + + // display the Open dialog box. + retval = GetOpenFileName( &ofn ); + if ( !retval ) + return; + + Sys_AddExtension( ".csv", logFilename, sizeof( logFilename ) ); + + fp = fopen( logFilename, "wt+" ); + if ( !fp ) + return; + + // labels + fprintf( fp, "Allocation Type" ); + fprintf( fp, ",Current Size" ); + fprintf( fp, ",Peak Size" ); + fprintf( fp, ",Total Allocations" ); + fprintf( fp, ",Overhead Size" ); + fprintf( fp, ",Peak Overhead Size" ); + fprintf( fp, ",Time(ms)" ); + fprintf( fp, ",Current Count" ); + fprintf( fp, ",Peak Count" ); + fprintf( fp, ",Total Count" ); + fprintf( fp, ",<=16 Byte Allocations" ); + fprintf( fp, ",17-32 Byte Allocations" ); + fprintf( fp, ",33-128 Byte Allocations" ); + fprintf( fp, ",129-1024 Byte Allocations" ); + fprintf( fp, ",>1024 Byte Allocations" ); + fprintf( fp, "\n" ); + + // dump to the log + for ( i=0; i<g_showMemDump_numMemory; i++ ) + { + fprintf( fp, "\"%s\"", g_showMemDump_pMemory[i].detail.pAllocationName ); + fprintf( fp, ",%s", ShowMemDump_FormatSize( g_showMemDump_pMemory[i].detail.currentSize, buff, false ) ); + fprintf( fp, ",%s", ShowMemDump_FormatSize( g_showMemDump_pMemory[i].detail.peakSize, buff, false ) ); + fprintf( fp, ",%s", ShowMemDump_FormatSize( g_showMemDump_pMemory[i].detail.totalSize, buff, false ) ); + fprintf( fp, ",%s", ShowMemDump_FormatSize( g_showMemDump_pMemory[i].detail.overheadSize, buff, false ) ); + fprintf( fp, ",%s", ShowMemDump_FormatSize( g_showMemDump_pMemory[i].detail.peakOverheadSize, buff, false ) ); + fprintf( fp, ",%d", g_showMemDump_pMemory[i].detail.time ); + fprintf( fp, ",%d", g_showMemDump_pMemory[i].detail.currentCount ); + fprintf( fp, ",%d", g_showMemDump_pMemory[i].detail.peakCount ); + fprintf( fp, ",%d", g_showMemDump_pMemory[i].detail.totalCount ); + fprintf( fp, ",%d", g_showMemDump_pMemory[i].detail.lte16 ); + fprintf( fp, ",%d", g_showMemDump_pMemory[i].detail.lte32 ); + fprintf( fp, ",%d", g_showMemDump_pMemory[i].detail.lte128 ); + fprintf( fp, ",%d", g_showMemDump_pMemory[i].detail.lte1024 ); + fprintf( fp, ",%d", g_showMemDump_pMemory[i].detail.gt1024 ); + fprintf( fp, "\n" ); + } + + fclose( fp ); +} + +//----------------------------------------------------------------------------- +// ShowMemDump_Summary +// +//----------------------------------------------------------------------------- +void ShowMemDump_Summary() +{ + char buff[1024]; + int i; + + if ( g_showMemDump_format != FORMAT_DETAILS ) + { + return; + } + + int currentSize = 0; + int peakSize = 0; + int totalSize = 0; + int overheadSize = 0; + int peakOverheadSize = 0; + int time = 0; + int currentCount = 0; + int peakCount = 0; + int totalCount = 0; + int lte16 = 0; + int lte32 = 0; + int lte128 = 0; + int lte1024 = 0; + int gt1024 = 0; + + // tally the totals + for (i=0; i<g_showMemDump_numMemory; i++) + { + if ( !strnicmp( g_showMemDump_pMemory[i].detail.pAllocationName, "Totals,", 7 ) ) + continue; + + currentSize += g_showMemDump_pMemory[i].detail.currentSize; + peakSize += g_showMemDump_pMemory[i].detail.peakSize; + totalSize += g_showMemDump_pMemory[i].detail.totalSize; + overheadSize += g_showMemDump_pMemory[i].detail.overheadSize; + peakOverheadSize += g_showMemDump_pMemory[i].detail.peakOverheadSize; + time += g_showMemDump_pMemory[i].detail.time; + currentCount += g_showMemDump_pMemory[i].detail.currentCount; + peakCount += g_showMemDump_pMemory[i].detail.peakCount; + totalCount += g_showMemDump_pMemory[i].detail.totalCount; + lte16 += g_showMemDump_pMemory[i].detail.lte16; + lte32 += g_showMemDump_pMemory[i].detail.lte32; + lte128 += g_showMemDump_pMemory[i].detail.lte128; + lte1024 += g_showMemDump_pMemory[i].detail.lte1024; + gt1024 += g_showMemDump_pMemory[i].detail.gt1024; + } + + sprintf( + buff, + "Entries:\t\t\t%d\n" + "Current Size:\t\t%.2f MB\n" + "Peak Size:\t\t%.2f MB\n" + "Total Size:\t\t%.2f MB\n" + "Overhead Size:\t\t%d\n" + "Peak Overhead Size:\t%d\n" + "Time:\t\t\t%d\n" + "Current Count:\t\t%d\n" + "Peak Count:\t\t%d\n" + "Total Count:\t\t%d\n" + "<= 16:\t\t\t%d\n" + "17-32:\t\t\t%d\n" + "33-128:\t\t\t%d\n" + "129-1024:\t\t%d\n" + "> 1024:\t\t\t%d\n", + g_showMemDump_numMemory, + (float)currentSize/( 1024.0F*1024.0F ), + (float)peakSize/( 1024.0F*1024.0F ), + (float)totalSize/( 1024.0F*1024.0F ), + overheadSize, + peakOverheadSize, + time, + currentCount, + peakCount, + totalCount, + lte16, + lte32, + lte128, + lte1024, + gt1024 ); + + MessageBox( g_showMemDump_hWnd, buff, "Memory Dump Summary", MB_OK|MB_APPLMODAL ); +} + +//----------------------------------------------------------------------------- +// ShowMemDump_SetTitle +// +//----------------------------------------------------------------------------- +void ShowMemDump_SetTitle() +{ + if ( g_showMemDump_hWnd ) + { + SetWindowText( g_showMemDump_hWnd, "Memory Dump" ); + } +} + +//----------------------------------------------------------------------------- +// ShowMemDump_CompareFunc +// +//----------------------------------------------------------------------------- +int CALLBACK ShowMemDump_CompareFunc( LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort ) +{ + memory_t* pMemoryA = (memory_t*)lParam1; + memory_t* pMemoryB = (memory_t*)lParam2; + + int sort = 0; + + if ( g_showMemDump_format == FORMAT_POOLS ) + { + switch ( g_showMemDump_sortColumn ) + { + case ID_DUMPPOOL_POOL: + sort = pMemoryA->pool.pool - pMemoryB->pool.pool; + break; + + case ID_DUMPPOOL_SIZE: + sort = pMemoryA->pool.size - pMemoryB->pool.size; + break; + + case ID_DUMPPOOL_ALLOCATED: + sort = pMemoryA->pool.allocated - pMemoryB->pool.allocated; + break; + + case ID_DUMPPOOL_FREE: + sort = pMemoryA->pool.free - pMemoryB->pool.free; + break; + + case ID_DUMPPOOL_COMMITTED: + sort = pMemoryA->pool.committed - pMemoryB->pool.committed; + break; + + case ID_DUMPPOOL_COMMITTEDSIZE: + sort = pMemoryA->pool.committedSize - pMemoryB->pool.committedSize; + break; + } + } + else + { + switch ( g_showMemDump_sortColumn ) + { + case ID_DUMPDETAIL_ALLOCATION: + sort = stricmp( pMemoryA->detail.pAllocationName, pMemoryB->detail.pAllocationName ); + break; + + case ID_DUMPDETAIL_CURRENTSIZE: + sort = pMemoryA->detail.currentSize - pMemoryB->detail.currentSize; + break; + + case ID_DUMPDETAIL_PEAKSIZE: + sort = pMemoryA->detail.peakSize - pMemoryB->detail.peakSize; + break; + + case ID_DUMPDETAIL_TOTALSIZE: + sort = pMemoryA->detail.totalSize - pMemoryB->detail.totalSize; + break; + + case ID_DUMPDETAIL_OVERHEAD: + sort = pMemoryA->detail.overheadSize - pMemoryB->detail.overheadSize; + break; + + case ID_DUMPDETAIL_PEAKOVERHEAD: + sort = pMemoryA->detail.peakOverheadSize - pMemoryB->detail.peakOverheadSize; + break; + + case ID_DUMPDETAIL_TIME: + sort = pMemoryA->detail.time - pMemoryB->detail.time; + break; + + case ID_DUMPDETAIL_CURRENTCOUNT: + sort = pMemoryA->detail.currentCount - pMemoryB->detail.currentCount; + break; + + case ID_DUMPDETAIL_PEAKCOUNT: + sort = pMemoryA->detail.peakCount - pMemoryB->detail.peakCount; + break; + + case ID_DUMPDETAIL_TOTALCOUNT: + sort = pMemoryA->detail.totalCount - pMemoryB->detail.totalCount; + break; + + case ID_DUMPDETAIL_LTE16: + sort = pMemoryA->detail.lte16 - pMemoryB->detail.lte16; + break; + + case ID_DUMPDETAIL_LTE32: + sort = pMemoryA->detail.lte32 - pMemoryB->detail.lte32; + break; + + case ID_DUMPDETAIL_LTE128: + sort = pMemoryA->detail.lte128 - pMemoryB->detail.lte128; + break; + + case ID_DUMPDETAIL_LTE1024: + sort = pMemoryA->detail.lte1024 - pMemoryB->detail.lte1024; + break; + + case ID_DUMPDETAIL_GT1024: + sort = pMemoryA->detail.gt1024 - pMemoryB->detail.gt1024; + break; + } + } + + // flip the sort order + if ( g_showMemDump_sortDescending ) + { + sort *= -1; + } + + return ( sort ); +} + +//----------------------------------------------------------------------------- +// ShowMemDump_SortItems +// +//----------------------------------------------------------------------------- +void ShowMemDump_SortItems() +{ + LVITEM lvitem; + memory_t *pMemory; + int i; + + if ( !g_showMemDump_hWnd ) + { + // only sort if window is visible + return; + } + + ListView_SortItems( g_showMemDump_hWndListView, ShowMemDump_CompareFunc, 0 ); + + memset( &lvitem, 0, sizeof( lvitem ) ); + lvitem.mask = LVIF_PARAM; + + // get each item and reset its list index + int itemCount = ListView_GetItemCount( g_showMemDump_hWndListView ); + for ( i=0; i<itemCount; i++ ) + { + lvitem.iItem = i; + ListView_GetItem( g_showMemDump_hWndListView, &lvitem ); + + pMemory = (memory_t*)lvitem.lParam; + pMemory->listIndex = i; + } + + int count; + label_t* pLabels; + if ( g_showMemDump_format == FORMAT_POOLS ) + { + count = sizeof( g_showMemDump_PoolLabels )/sizeof( g_showMemDump_PoolLabels[0] ); + pLabels = g_showMemDump_PoolLabels; + } + else + { + count = sizeof( g_showMemDump_DetailLabels )/sizeof( g_showMemDump_DetailLabels[0] ); + pLabels = g_showMemDump_DetailLabels; + } + + // update list view columns with sort key + for ( i = 0; i < count; i++ ) + { + char symbol; + LVCOLUMN lvc; + + if ( i == g_showMemDump_sortColumn ) + symbol = g_showMemDump_sortDescending ? '<' : '>'; + else + symbol = ' '; + sprintf( pLabels[i].nameBuff, "%s %c", pLabels[i].name, symbol ); + + memset( &lvc, 0, sizeof( lvc ) ); + lvc.mask = LVCF_TEXT; + lvc.pszText = (LPSTR)pLabels[i].nameBuff; + + ListView_SetColumn( g_showMemDump_hWndListView, i, &lvc ); + } +} + +//----------------------------------------------------------------------------- +// ShowMemDump_FormatItems +// +//----------------------------------------------------------------------------- +void ShowMemDump_FormatItems() +{ + if ( g_showMemDump_format == FORMAT_POOLS ) + { + for ( int i = 0; i < g_showMemDump_numMemory; i++ ) + { + sprintf( g_showMemDump_pMemory[i].pool.sizeBuff, "%d", g_showMemDump_pMemory[i].pool.size ); + ShowMemDump_FormatSize( g_showMemDump_pMemory[i].pool.committedSize, g_showMemDump_pMemory[i].pool.committedSizeBuff, true ); + } + } + else + { + for ( int i = 0; i < g_showMemDump_numMemory; i++ ) + { + ShowMemDump_FormatSize( g_showMemDump_pMemory[i].detail.currentSize, g_showMemDump_pMemory[i].detail.currentSizeBuff, true ); + ShowMemDump_FormatSize( g_showMemDump_pMemory[i].detail.peakSize, g_showMemDump_pMemory[i].detail.peakSizeBuff, true ); + ShowMemDump_FormatSize( g_showMemDump_pMemory[i].detail.totalSize, g_showMemDump_pMemory[i].detail.totalSizeBuff, true ); + ShowMemDump_FormatSize( g_showMemDump_pMemory[i].detail.overheadSize, g_showMemDump_pMemory[i].detail.overheadSizeBuff, true ); + ShowMemDump_FormatSize( g_showMemDump_pMemory[i].detail.peakOverheadSize, g_showMemDump_pMemory[i].detail.peakOverheadSizeBuff, true ); + } + } + + ShowMemDump_SortItems(); +} + +//----------------------------------------------------------------------------- +// ShowMemDump_AddViewItem +// +//----------------------------------------------------------------------------- +void ShowMemDump_AddViewItem( memory_t* pMemory ) +{ + LVITEM lvi; + + if ( !g_showMemDump_hWnd ) + { + // only valid if log window is visible + return; + } + + // update the text callback buffers + if ( g_showMemDump_format == FORMAT_POOLS ) + { + sprintf( pMemory->pool.sizeBuff, "%d", pMemory->pool.size ); + sprintf( pMemory->pool.poolBuff, "%d", pMemory->pool.pool ); + sprintf( pMemory->pool.allocatedBuff, "%d", pMemory->pool.allocated ); + sprintf( pMemory->pool.freeBuff, "%d", pMemory->pool.free ); + sprintf( pMemory->pool.committedBuff, "%d", pMemory->pool.committed ); + ShowMemDump_FormatSize( pMemory->pool.committedSize, pMemory->pool.committedSizeBuff, true ); + } + else + { + ShowMemDump_FormatSize( pMemory->detail.currentSize, pMemory->detail.currentSizeBuff, true ); + ShowMemDump_FormatSize( pMemory->detail.peakSize, pMemory->detail.peakSizeBuff, true ); + ShowMemDump_FormatSize( pMemory->detail.totalSize, pMemory->detail.totalSizeBuff, true ); + ShowMemDump_FormatSize( pMemory->detail.overheadSize, pMemory->detail.overheadSizeBuff, true ); + ShowMemDump_FormatSize( pMemory->detail.peakOverheadSize, pMemory->detail.peakOverheadSizeBuff, true ); + sprintf( pMemory->detail.timeBuff, "%d", pMemory->detail.time ); + sprintf( pMemory->detail.currentCountBuff, "%d", pMemory->detail.currentCount ); + sprintf( pMemory->detail.peakCountBuff, "%d", pMemory->detail.peakCount ); + sprintf( pMemory->detail.totalCountBuff, "%d", pMemory->detail.totalCount ); + sprintf( pMemory->detail.lte16Buff, "%d", pMemory->detail.lte16 ); + sprintf( pMemory->detail.lte32Buff, "%d", pMemory->detail.lte32 ); + sprintf( pMemory->detail.lte128Buff, "%d", pMemory->detail.lte128 ); + sprintf( pMemory->detail.lte1024Buff, "%d", pMemory->detail.lte1024 ); + sprintf( pMemory->detail.gt1024Buff, "%d", pMemory->detail.gt1024 ); + } + + int itemCount = ListView_GetItemCount( g_showMemDump_hWndListView ); + + // setup and insert at end of list + memset( &lvi, 0, sizeof( lvi ) ); + lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE; + lvi.iItem = itemCount; + lvi.iSubItem = 0; + lvi.state = 0; + lvi.stateMask = 0; + lvi.pszText = LPSTR_TEXTCALLBACK; + lvi.lParam = (LPARAM)pMemory; + + // insert and set the real index + pMemory->listIndex = ListView_InsertItem( g_showMemDump_hWndListView, &lvi ); +} + +//----------------------------------------------------------------------------- +// ShowMemDump_Refresh +// +//----------------------------------------------------------------------------- +void ShowMemDump_Refresh() +{ + // send the command to application which replies with list data + if ( g_connectedToApp ) + { + ProcessCommand( "mem_dump" ); + } +} + +//----------------------------------------------------------------------------- +// ShowMemDump_RefreshView +// +//----------------------------------------------------------------------------- +void ShowMemDump_RefreshView() +{ + if ( strlen( g_showMemDump_currentFilename ) == 0 ) + { + // first time + ShowMemDump_Refresh(); + return; + } + + // get current file + int fileSize; + char *pBuffer; + bool bSuccess = LoadTargetFile( g_showMemDump_currentFilename, &fileSize, (void **)&pBuffer ); + if ( !bSuccess ) + { + // stale, try again + ShowMemDump_Refresh(); + return; + } + + // parse and update view + ShowMemDump_Parse( pBuffer, fileSize ); + + Sys_Free( pBuffer ); +} + +//----------------------------------------------------------------------------- +// ShowMemDump_PopulateList +// +//----------------------------------------------------------------------------- +void ShowMemDump_PopulateList() +{ + // delete previous labels + while ( 1 ) + { + if ( !ListView_DeleteColumn( g_showMemDump_hWndListView, 0 ) ) + { + break; + } + } + + int count; + label_t* pLabels; + if ( g_showMemDump_format == FORMAT_POOLS ) + { + count = sizeof( g_showMemDump_PoolLabels )/sizeof( g_showMemDump_PoolLabels[0] ); + pLabels = g_showMemDump_PoolLabels; + } + else + { + count = sizeof( g_showMemDump_DetailLabels )/sizeof( g_showMemDump_DetailLabels[0] ); + pLabels = g_showMemDump_DetailLabels; + } + + // init list view columns + for ( int i = 0; i < count; i++ ) + { + LVCOLUMN lvc; + memset( &lvc, 0, sizeof( lvc ) ); + + lvc.mask = LVCF_FMT|LVCF_WIDTH|LVCF_TEXT|LVCF_SUBITEM; + lvc.iSubItem = 0; + lvc.cx = pLabels[i].width; + lvc.fmt = LVCFMT_LEFT; + lvc.pszText = ( LPSTR )pLabels[i].name; + + ListView_InsertColumn( g_showMemDump_hWndListView, i, &lvc ); + } + + // populate list view + for ( int i = 0; i < g_showMemDump_numMemory; i++ ) + { + ShowMemDump_AddViewItem( &g_showMemDump_pMemory[i] ); + } + + ShowMemDump_SortItems(); +} + +//----------------------------------------------------------------------------- +// ShowMemDump_SizeWindow +// +//----------------------------------------------------------------------------- +void ShowMemDump_SizeWindow( HWND hwnd, int cx, int cy ) +{ + if ( cx==0 || cy==0 ) + { + RECT rcClient; + GetClientRect( hwnd, &rcClient ); + cx = rcClient.right; + cy = rcClient.bottom; + } + + // position the ListView + SetWindowPos( g_showMemDump_hWndListView, NULL, 0, 0, cx, cy, SWP_NOZORDER ); +} + +//----------------------------------------------------------------------------- +// ShowMemDump_WndProc +// +//----------------------------------------------------------------------------- +LRESULT CALLBACK ShowMemDump_WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + WORD wID = LOWORD( wParam ); + memory_t* pMemory; + + switch ( message ) + { + case WM_CREATE: + return 0L; + + case WM_DESTROY: + ShowMemDump_SaveConfig(); + + g_showMemDump_hWnd = NULL; + return 0L; + + case WM_INITMENU: + CheckMenuItem( (HMENU)wParam, IDM_OPTIONS_BYTES, MF_BYCOMMAND | ( g_showMemDump_showBytes == SHOW_BYTES ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( (HMENU)wParam, IDM_OPTIONS_KILOBYTES, MF_BYCOMMAND | ( g_showMemDump_showBytes == SHOW_KILOBYTES ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( (HMENU)wParam, IDM_OPTIONS_MEGABYTES, MF_BYCOMMAND | ( g_showMemDump_showBytes == SHOW_MEGABYTES ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( (HMENU)wParam, IDM_OPTIONS_COLLAPSEOUTPUT, MF_BYCOMMAND | ( g_showMemDump_bCollapseOutput ? MF_CHECKED : MF_UNCHECKED ) ); + return 0L; + + case WM_SIZE: + ShowMemDump_SizeWindow( hwnd, LOWORD( lParam ), HIWORD( lParam ) ); + return 0L; + + case WM_NOTIFY: + switch ( ( ( LPNMHDR )lParam )->code ) + { + case LVN_COLUMNCLICK: + NMLISTVIEW* pnmlv; + pnmlv = ( NMLISTVIEW* )lParam; + if ( g_showMemDump_sortColumn == pnmlv->iSubItem ) + { + // user has clicked on same column - flip the sort + g_showMemDump_sortDescending ^= 1; + } + else + { + // sort by new column + g_showMemDump_sortColumn = pnmlv->iSubItem; + } + ShowMemDump_SortItems(); + return 0L; + + case LVN_GETDISPINFO: + NMLVDISPINFO* plvdi; + plvdi = (NMLVDISPINFO*)lParam; + pMemory = (memory_t*)plvdi->item.lParam; + + if ( g_showMemDump_format == FORMAT_POOLS ) + { + switch ( plvdi->item.iSubItem ) + { + case ID_DUMPPOOL_POOL: + plvdi->item.pszText = pMemory->pool.poolBuff; + return 0L; + + case ID_DUMPPOOL_SIZE: + plvdi->item.pszText = pMemory->pool.sizeBuff; + return 0L; + + case ID_DUMPPOOL_ALLOCATED: + plvdi->item.pszText = pMemory->pool.allocatedBuff; + return 0L; + + case ID_DUMPPOOL_FREE: + plvdi->item.pszText = pMemory->pool.freeBuff; + return 0L; + + case ID_DUMPPOOL_COMMITTED: + plvdi->item.pszText = pMemory->pool.committedBuff; + return 0L; + + case ID_DUMPPOOL_COMMITTEDSIZE: + plvdi->item.pszText = pMemory->pool.committedSizeBuff; + return 0L; + } + } + else + { + switch ( plvdi->item.iSubItem ) + { + case ID_DUMPDETAIL_ALLOCATION: + plvdi->item.pszText = pMemory->detail.pAllocationName; + return 0L; + + case ID_DUMPDETAIL_CURRENTSIZE: + plvdi->item.pszText = pMemory->detail.currentSizeBuff; + return 0L; + + case ID_DUMPDETAIL_PEAKSIZE: + plvdi->item.pszText = pMemory->detail.peakSizeBuff; + return 0L; + + case ID_DUMPDETAIL_TOTALSIZE: + plvdi->item.pszText = pMemory->detail.totalSizeBuff; + return 0L; + + case ID_DUMPDETAIL_OVERHEAD: + plvdi->item.pszText = pMemory->detail.overheadSizeBuff; + return 0L; + + case ID_DUMPDETAIL_PEAKOVERHEAD: + plvdi->item.pszText = pMemory->detail.peakOverheadSizeBuff; + return 0L; + + case ID_DUMPDETAIL_TIME: + plvdi->item.pszText = pMemory->detail.timeBuff; + return 0L; + + case ID_DUMPDETAIL_CURRENTCOUNT: + plvdi->item.pszText = pMemory->detail.currentCountBuff; + return 0L; + + case ID_DUMPDETAIL_PEAKCOUNT: + plvdi->item.pszText = pMemory->detail.peakCountBuff; + return 0L; + + case ID_DUMPDETAIL_TOTALCOUNT: + plvdi->item.pszText = pMemory->detail.totalCountBuff; + return 0L; + + case ID_DUMPDETAIL_LTE16: + plvdi->item.pszText = pMemory->detail.lte16Buff; + return 0L; + + case ID_DUMPDETAIL_LTE32: + plvdi->item.pszText = pMemory->detail.lte32Buff; + return 0L; + + case ID_DUMPDETAIL_LTE128: + plvdi->item.pszText = pMemory->detail.lte128Buff; + return 0L; + + case ID_DUMPDETAIL_LTE1024: + plvdi->item.pszText = pMemory->detail.lte1024Buff; + return 0L; + + case ID_DUMPDETAIL_GT1024: + plvdi->item.pszText = pMemory->detail.gt1024Buff; + return 0L; + + default: + break; + } + } + break; + } + break; + + case WM_COMMAND: + switch ( wID ) + { + case IDM_OPTIONS_REFRESH: + ShowMemDump_Refresh(); + return 0L; + + case IDM_OPTIONS_EXPORT: + ShowMemDump_Export(); + return 0L; + + case IDM_OPTIONS_SUMMARY: + ShowMemDump_Summary(); + return 0L; + + case IDM_OPTIONS_BYTES: + g_showMemDump_showBytes = SHOW_BYTES; + ShowMemDump_FormatItems(); + return 0L; + + case IDM_OPTIONS_KILOBYTES: + g_showMemDump_showBytes = SHOW_KILOBYTES; + ShowMemDump_FormatItems(); + return 0L; + + case IDM_OPTIONS_MEGABYTES: + g_showMemDump_showBytes = SHOW_MEGABYTES; + ShowMemDump_FormatItems(); + return 0L; + + case IDM_OPTIONS_COLLAPSEOUTPUT: + g_showMemDump_bCollapseOutput = !g_showMemDump_bCollapseOutput; + ShowMemDump_RefreshView(); + return 0L; + } + break; + } + + return ( DefWindowProc( hwnd, message, wParam, lParam ) ); +} + +//----------------------------------------------------------------------------- +// ShowMemDump_Init +// +//----------------------------------------------------------------------------- +bool ShowMemDump_Init() +{ + // set up our window class + WNDCLASS wndclass; + + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = ShowMemDump_WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = 0; + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_APPLICATION]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = MAKEINTRESOURCE( MENU_SHOWMEMORYDUMP ); + wndclass.lpszClassName = "SHOWMEMDUMPCLASS"; + if ( !RegisterClass( &wndclass ) ) + return false; + + ShowMemDump_LoadConfig(); + + return true; +} + +//----------------------------------------------------------------------------- +// ShowMemDump_Open +// +//----------------------------------------------------------------------------- +void ShowMemDump_Open() +{ + RECT clientRect; + HWND hWnd; + + if ( g_showMemDump_hWnd ) + { + // only one instance + if ( IsIconic( g_showMemDump_hWnd ) ) + ShowWindow( g_showMemDump_hWnd, SW_RESTORE ); + SetForegroundWindow( g_showMemDump_hWnd ); + return; + } + + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + "SHOWMEMDUMPCLASS", + "", + WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX, + 0, + 0, + 700, + 400, + g_hDlgMain, + NULL, + g_hInstance, + NULL ); + g_showMemDump_hWnd = hWnd; + + GetClientRect( g_showMemDump_hWnd, &clientRect ); + hWnd = CreateWindow( + WC_LISTVIEW, + "", + WS_VISIBLE|WS_CHILD|LVS_REPORT, + 0, + 0, + clientRect.right-clientRect.left, + clientRect.bottom-clientRect.top, + g_showMemDump_hWnd, + ( HMENU )ID_SHOWMEMDUMP_LISTVIEW, + g_hInstance, + NULL ); + g_showMemDump_hWndListView = hWnd; + + ListView_SetBkColor( g_showMemDump_hWndListView, g_backgroundColor ); + ListView_SetTextBkColor( g_showMemDump_hWndListView, g_backgroundColor ); + + DWORD style = LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES|LVS_EX_HEADERDRAGDROP; + ListView_SetExtendedListViewStyleEx( g_showMemDump_hWndListView, style, style ); + + ShowMemDump_PopulateList(); + + ShowMemDump_SetTitle(); + + if ( g_showMemDump_windowRect.right && g_showMemDump_windowRect.bottom ) + MoveWindow( g_showMemDump_hWnd, g_showMemDump_windowRect.left, g_showMemDump_windowRect.top, g_showMemDump_windowRect.right-g_showMemDump_windowRect.left, g_showMemDump_windowRect.bottom-g_showMemDump_windowRect.top, FALSE ); + ShowWindow( g_showMemDump_hWnd, SHOW_OPENWINDOW ); + + // get data from application + ShowMemDump_Refresh(); +} + +//----------------------------------------------------------------------------- +// MatchAllocationName +// +//----------------------------------------------------------------------------- +void MatchAllocationName( memory_t *&pMemory ) +{ + memory_t *curEntry = g_showMemDump_pMemory; + for ( int i=0; i<g_showMemDump_numMemory; ++i ) + { + if ( !strcmp( curEntry->detail.pAllocationName, pMemory->detail.pAllocationName ) ) + { + pMemory = curEntry; + return; + } + ++curEntry; + } +} + +//----------------------------------------------------------------------------- +// ShowMemDump_Parse +// +//----------------------------------------------------------------------------- +void ShowMemDump_Parse( const char *pBuffer, int fileSize ) +{ + char *ptr; + char *pToken; + char *pLineStart; + int numLines; + int size; + memory_t *pMemory; + + // remove old entries + ShowMemDump_Clear(); + + if ( !pBuffer || !fileSize ) + { + // no valid data + return; + } + + Sys_SetScriptData( pBuffer, fileSize ); + + // skip first line, column headers + Sys_SkipRestOfLine(); + + Sys_SaveParser(); + + // count lines + numLines = 0; + while ( 1 ) + { + pToken = Sys_GetToken( true ); + if ( !pToken || !pToken[0] ) + break; + numLines++; + Sys_SkipRestOfLine(); + } + + // each line represents one complete entry + g_showMemDump_pMemory = (memory_t *)Sys_Alloc( numLines * sizeof( memory_t ) ); + + Sys_RestoreParser(); + + pMemory = g_showMemDump_pMemory; + + int format = 0; + if ( !V_strnicmp( g_sys_scriptptr, "pool ", 5 ) ) + { + // parse as pool stats + format = FORMAT_POOLS; + + while ( 1 ) + { + // find start of relevant data + bool bFound = false; + while ( 1 ) + { + pToken = Sys_GetToken( true ); + if ( !pToken || !pToken[0] ) + break; + if ( !V_stricmp( pToken, "size:" ) ) + { + bFound = true; + break; + } + } + if ( !bFound ) + { + break; + } + + memset( pMemory, 0, sizeof( memory_t ) ); + + pMemory->pool.pool = g_showMemDump_numMemory; + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->pool.size = atoi( pToken ); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + if ( !V_stricmp( pToken, "allocated:" ) ) + { + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->pool.allocated = atoi( pToken ); + } + else + { + break; + } + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + if ( !V_stricmp( pToken, "free:" ) ) + { + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->pool.free = atoi( pToken ); + } + else + { + break; + } + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + if ( !V_stricmp( pToken, "committed:" ) ) + { + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->pool.committed = atoi( pToken ); + } + else + { + break; + } + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + if ( !V_stricmp( pToken, "committedsize:" ) ) + { + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->pool.committedSize = atoi( pToken ); + } + else + { + break; + } + + pMemory++; + g_showMemDump_numMemory++; + if ( g_showMemDump_numMemory >= numLines ) + break; + } + } + else + { + // parse as detail stats + format = FORMAT_DETAILS; + + while ( 1 ) + { + pLineStart = g_sys_scriptptr; + + // can't tokenize, find start of parsable data + ptr = V_stristr( g_sys_scriptptr, ", line " ); + if ( !ptr ) + break; + g_sys_scriptptr = ptr + strlen( ", line " ); + + // advance past the expected line number + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + + if ( !g_showMemDump_bCollapseOutput ) + { + size = g_sys_scriptptr-pLineStart; + } + else + { + size = ptr-pLineStart; + } + + memset( pMemory, 0, sizeof(memory_t) ); + memory_t *pCurRecordStart = pMemory; + + pMemory->detail.pAllocationName = new char[size+1]; + memcpy( pMemory->detail.pAllocationName, pLineStart, size ); + pMemory->detail.pAllocationName[size] = '\0'; + Sys_NormalizePath( pMemory->detail.pAllocationName, false ); + + if ( g_showMemDump_bCollapseOutput ) + { + MatchAllocationName( pMemory ); + } + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.currentSize += (int)(1024.0f*atof( pToken )); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.peakSize += (int)(1024.0f*atof( pToken )); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.totalSize += (int)(1024.0f*atof( pToken )); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.overheadSize += (int)(1024.0f*atof( pToken )); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.peakOverheadSize += (int)(1024.0f*atof( pToken )); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.time += atoi( pToken ); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.currentCount += atoi( pToken ); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.peakCount += atoi( pToken ); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.totalCount += atoi( pToken ); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.lte16 += atoi( pToken ); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.lte32 += atoi( pToken ); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.lte128 += atoi( pToken ); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.lte1024 += atoi( pToken ); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + break; + pMemory->detail.gt1024 += atoi( pToken ); + + Sys_SkipRestOfLine(); + + if( pMemory == pCurRecordStart ) + { + pMemory++; + g_showMemDump_numMemory++; + } + else + { + pMemory = pCurRecordStart; + } + + if ( g_showMemDump_numMemory >= numLines ) + break; + } + } + + if ( g_showMemDump_format != format ) + { + // format change will cause list view change + g_showMemDump_format = format; + g_showMemDump_sortColumn = 0; + g_showMemDump_sortDescending = 0; + } + + ShowMemDump_PopulateList(); +} + +//----------------------------------------------------------------------------- +// rc_MemDump +// +// Sent from application with memory dump file +//----------------------------------------------------------------------------- +int rc_MemDump( char *pCommand ) +{ + char* pToken; + int retVal; + int errCode = -1; + int fileSize; + char *pBuffer; + + // get name of file + pToken = GetToken( &pCommand ); + if ( !pToken[0] ) + goto cleanUp; + + // get file + strcpy( g_showMemDump_currentFilename, pToken ); + retVal = LoadTargetFile( g_showMemDump_currentFilename, &fileSize, (void **)&pBuffer ); + + DebugCommand( "0x%8.8x = MemDump( %s )\n", retVal, g_showMemDump_currentFilename ); + + // parse and update view + ShowMemDump_Parse( pBuffer, fileSize ); + + Sys_Free( pBuffer ); + + // success + errCode = 0; + +cleanUp: + return ( errCode ); +} diff --git a/utils/xbox/vxconsole/show_sounds.cpp b/utils/xbox/vxconsole/show_sounds.cpp new file mode 100644 index 0000000..f54be8d --- /dev/null +++ b/utils/xbox/vxconsole/show_sounds.cpp @@ -0,0 +1,778 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// SHOW_SOUNDS.CPP +// +// Show Sounds Display. +//=====================================================================================// +#include "vxconsole.h" + +#define ID_SHOWSOUNDS_LISTVIEW 100 + +// column id +#define ID_SS_NAME 0 +#define ID_SS_PREFIX 1 +#define ID_SS_FORMAT 2 +#define ID_SS_RATE 3 +#define ID_SS_BITS 4 +#define ID_SS_CHANNELS 5 +#define ID_SS_SIZE 6 +#define ID_SS_STREAMED 7 +#define ID_SS_LOOPED 8 +#define ID_SS_LENGTH 9 + +typedef struct +{ + int listIndex; + char *pName; + char *pPrefix; + char *pFormat; + int rate; + char rateBuff[16]; + int bits; + char bitsBuff[16]; + int channels; + char channelsBuff[16]; + int numSamples; + int dataSize; + char dataSizeBuff[16]; + int streamed; + char streamedBuff[16]; + int looped; + char loopedBuff[16]; + float length; + char lengthBuff[16]; +} sound_t; + +typedef struct +{ const CHAR* name; + int width; + int subItemIndex; + CHAR nameBuff[32]; +} label_t; + +HWND g_showSounds_hWnd; +HWND g_showSounds_hWndListView; +RECT g_showSounds_windowRect; +int g_showSounds_sortColumn; +int g_showSounds_sortDescending; +sound_t *g_showSounds_pSounds; +int g_showSounds_numSounds; +int g_showSounds_currentFrame; + +label_t g_showSounds_Labels[] = +{ + {"Name", 300, ID_SS_NAME}, + {"Prefix", 80, ID_SS_PREFIX}, + {"Format", 80, ID_SS_FORMAT}, + {"Rate", 80, ID_SS_RATE}, + {"Bits", 80, ID_SS_BITS}, + {"Channels", 80, ID_SS_CHANNELS}, + {"Size", 80, ID_SS_SIZE}, + {"Streamed", 80, ID_SS_STREAMED}, + {"Looped", 80, ID_SS_LOOPED}, + {"Length", 80, ID_SS_LENGTH}, +}; + +//----------------------------------------------------------------------------- +// ShowSounds_SaveConfig +// +//----------------------------------------------------------------------------- +void ShowSounds_SaveConfig() +{ + char buff[256]; + + Sys_SetRegistryInteger( "showSoundsSortColumn", g_showSounds_sortColumn ); + Sys_SetRegistryInteger( "showSoundsSortDescending", g_showSounds_sortDescending ); + + WINDOWPLACEMENT wp; + memset( &wp, 0, sizeof( wp ) ); + wp.length = sizeof( WINDOWPLACEMENT ); + GetWindowPlacement( g_showSounds_hWnd, &wp ); + g_showSounds_windowRect = wp.rcNormalPosition; + + sprintf( buff, "%d %d %d %d", g_showSounds_windowRect.left, g_showSounds_windowRect.top, g_showSounds_windowRect.right, g_showSounds_windowRect.bottom ); + Sys_SetRegistryString( "showSoundsWindowRect", buff ); +} + +//----------------------------------------------------------------------------- +// ShowSounds_LoadConfig +// +//----------------------------------------------------------------------------- +void ShowSounds_LoadConfig() +{ + int numArgs; + char buff[256]; + + Sys_GetRegistryInteger( "showSoundsSortColumn", ID_SS_NAME, g_showSounds_sortColumn ); + Sys_GetRegistryInteger( "showSoundsSortDescending", false, g_showSounds_sortDescending ); + + Sys_GetRegistryString( "showSoundsWindowRect", buff, "", sizeof( buff ) ); + numArgs = sscanf( buff, "%d %d %d %d", &g_showSounds_windowRect.left, &g_showSounds_windowRect.top, &g_showSounds_windowRect.right, &g_showSounds_windowRect.bottom ); + if ( numArgs != 4 || g_showSounds_windowRect.left < 0 || g_showSounds_windowRect.top < 0 || g_showSounds_windowRect.right < 0 || g_showSounds_windowRect.bottom < 0 ) + memset( &g_showSounds_windowRect, 0, sizeof( g_showSounds_windowRect ) ); +} + +//----------------------------------------------------------------------------- +// ShowSounds_Clear +// +//----------------------------------------------------------------------------- +void ShowSounds_Clear() +{ + // delete all the list view entries + if ( g_showSounds_hWnd ) + ListView_DeleteAllItems( g_showSounds_hWndListView ); + + if ( !g_showSounds_pSounds ) + return; + + for ( int i=0; i<g_showSounds_numSounds; i++ ) + { + free( g_showSounds_pSounds[i].pName ); + free( g_showSounds_pSounds[i].pPrefix ); + free( g_showSounds_pSounds[i].pFormat ); + } + + g_showSounds_pSounds = NULL; + g_showSounds_numSounds = 0; +} + +//----------------------------------------------------------------------------- +// ShowSounds_Export +// +//----------------------------------------------------------------------------- +void ShowSounds_Export() +{ +} + +//----------------------------------------------------------------------------- +// ShowSounds_Summary +// +//----------------------------------------------------------------------------- +void ShowSounds_Summary() +{ + char buff[1024]; + + // tally the totals + int totalStreamed = 0; + int totalStatic = 0; + for ( int i=0; i<g_showSounds_numSounds; i++ ) + { + if ( g_showSounds_pSounds[i].streamed ) + { + totalStreamed += g_showSounds_pSounds[i].dataSize; + } + else + { + totalStatic += g_showSounds_pSounds[i].dataSize; + } + } + + sprintf( + buff, + "Entries:\t\t\t%d\n" + "Static Memory:\t\t%.2f MB\n" + "Streamed Memory:\t\t%.2f MB\n", + g_showSounds_numSounds, + ( float )totalStatic/( 1024.0F*1024.0F ), + ( float )totalStreamed/( 1024.0F*1024.0F ) ); + + MessageBox( g_showSounds_hWnd, buff, "Sound Summary", MB_OK|MB_APPLMODAL ); +} + +//----------------------------------------------------------------------------- +// ShowSounds_Play +// +//----------------------------------------------------------------------------- +void ShowSounds_Play() +{ + char command[256]; + sound_t* pSound; + int selection; + LVITEM lvitem; + + if ( !g_connectedToApp ) + return; + + selection = ListView_GetSelectionMark( g_showSounds_hWndListView ); + if ( selection == -1 ) + return; + + memset( &lvitem, 0, sizeof( lvitem ) ); + lvitem.mask = LVIF_PARAM; + lvitem.iItem = selection; + ListView_GetItem( g_showSounds_hWndListView, &lvitem ); + + pSound = ( sound_t* )lvitem.lParam; + + sprintf( command, "play %s%s", pSound->pPrefix, pSound->pName ); + + // send the command to application + ProcessCommand( command ); +} + +//----------------------------------------------------------------------------- +// ShowSounds_CompareFunc +// +//----------------------------------------------------------------------------- +int CALLBACK ShowSounds_CompareFunc( LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort ) +{ + sound_t* pSoundA = ( sound_t* )lParam1; + sound_t* pSoundB = ( sound_t* )lParam2; + + int sort = 0; + switch ( g_showSounds_sortColumn ) + { + case ID_SS_NAME: + sort = stricmp( pSoundA->pName, pSoundB->pName ); + break; + + case ID_SS_PREFIX: + sort = stricmp( pSoundA->pPrefix, pSoundB->pPrefix ); + break; + + case ID_SS_FORMAT: + sort = stricmp( pSoundA->pFormat, pSoundB->pFormat ); + break; + + case ID_SS_RATE: + sort = pSoundA->rate - pSoundB->rate; + break; + + case ID_SS_BITS: + sort = pSoundA->bits - pSoundB->bits; + break; + + case ID_SS_CHANNELS: + sort = stricmp( pSoundA->channelsBuff, pSoundB->channelsBuff ); + break; + + case ID_SS_SIZE: + sort = pSoundA->dataSize - pSoundB->dataSize; + break; + + case ID_SS_STREAMED: + sort = stricmp( pSoundA->streamedBuff, pSoundB->streamedBuff ); + break; + + case ID_SS_LOOPED: + sort = stricmp( pSoundA->loopedBuff, pSoundB->loopedBuff ); + break; + + case ID_SS_LENGTH: + if ( pSoundA->length < pSoundB->length ) + sort = -1; + else if ( pSoundA->length == pSoundB->length ) + sort = 0; + else + sort = 1; + break; + } + + // flip the sort order + if ( g_showSounds_sortDescending ) + sort *= -1; + + return ( sort ); +} + +//----------------------------------------------------------------------------- +// ShowSounds_SortItems +// +//----------------------------------------------------------------------------- +void ShowSounds_SortItems() +{ + LVITEM lvitem; + sound_t *pSound; + int i; + + if ( !g_showSounds_hWnd ) + { + // only sort if window is visible + return; + } + + ListView_SortItems( g_showSounds_hWndListView, ShowSounds_CompareFunc, 0 ); + + memset( &lvitem, 0, sizeof( lvitem ) ); + lvitem.mask = LVIF_PARAM; + + // get each item and reset its list index + int itemCount = ListView_GetItemCount( g_showSounds_hWndListView ); + for ( i=0; i<itemCount; i++ ) + { + lvitem.iItem = i; + ListView_GetItem( g_showSounds_hWndListView, &lvitem ); + + pSound = ( sound_t* )lvitem.lParam; + pSound->listIndex = i; + } + + // update list view columns with sort key + for ( i=0; i<sizeof( g_showSounds_Labels )/sizeof( g_showSounds_Labels[0] ); i++ ) + { + char symbol; + LVCOLUMN lvc; + + if ( i == g_showSounds_sortColumn ) + symbol = g_showSounds_sortDescending ? '<' : '>'; + else + symbol = ' '; + sprintf( g_showSounds_Labels[i].nameBuff, "%s %c", g_showSounds_Labels[i].name, symbol ); + + memset( &lvc, 0, sizeof( lvc ) ); + lvc.mask = LVCF_TEXT; + lvc.pszText = ( LPSTR )g_showSounds_Labels[i].nameBuff; + + ListView_SetColumn( g_showSounds_hWndListView, i, &lvc ); + } +} + +//----------------------------------------------------------------------------- +// ShowSounds_AddViewItem +// +//----------------------------------------------------------------------------- +void ShowSounds_AddViewItem( sound_t* pSound ) +{ + LVITEM lvi; + + if ( !g_showSounds_hWnd ) + { + // only valid if log window is visible + return; + } + + // update the text callback buffers + if ( pSound->rate >= 0 ) + sprintf( pSound->rateBuff, "%5.2f KHz", ( float )pSound->rate/1000.0f ); + else + strcpy( pSound->rateBuff, "???" ); + + if ( pSound->bits >= 0 ) + sprintf( pSound->bitsBuff, "%d", pSound->bits ); + else + strcpy( pSound->bitsBuff, "???" ); + + if ( pSound->channels >= 1 ) + strcpy( pSound->channelsBuff, pSound->channels == 2 ? "Stereo" : "Mono" ); + else + strcpy( pSound->channelsBuff, "???" ); + + if ( pSound->dataSize >= 0 ) + sprintf( pSound->dataSizeBuff, "%d", pSound->dataSize ); + else + strcpy( pSound->dataSizeBuff, "???" ); + + if ( pSound->streamed >= 0 ) + strcpy( pSound->streamedBuff, pSound->streamed ? "Stream" : "Static" ); + else + strcpy( pSound->streamedBuff, "???" ); + + if ( pSound->looped >= 0 ) + strcpy( pSound->loopedBuff, pSound->looped ? "Looped" : "One-Shot" ); + else + strcpy( pSound->loopedBuff, "???" ); + + sprintf( pSound->lengthBuff, "%2.2d:%2.2d:%3.3d", ( int )pSound->length/60, ( int )pSound->length%60, ( int )( 1000*( pSound->length-( int )pSound->length ) )%1000 ); + + int itemCount = ListView_GetItemCount( g_showSounds_hWndListView ); + + // setup and insert at end of list + memset( &lvi, 0, sizeof( lvi ) ); + lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE; + lvi.iItem = itemCount; + lvi.iSubItem = 0; + lvi.state = 0; + lvi.stateMask = 0; + lvi.pszText = LPSTR_TEXTCALLBACK; + lvi.lParam = ( LPARAM )pSound; + + // insert and set the real index + pSound->listIndex = ListView_InsertItem( g_showSounds_hWndListView, &lvi ); +} + +//----------------------------------------------------------------------------- +// ShowSounds_Refresh +// +//----------------------------------------------------------------------------- +void ShowSounds_Refresh() +{ + char command[256]; + + strcpy( command, "vx_soundlist" ); + + // send the command to application which replies with list data + if ( g_connectedToApp ) + ProcessCommand( command ); +} + +//----------------------------------------------------------------------------- +// ShowSounds_SizeWindow +// +//----------------------------------------------------------------------------- +void ShowSounds_SizeWindow( HWND hwnd, int cx, int cy ) +{ + if ( cx==0 || cy==0 ) + { + RECT rcClient; + GetClientRect( hwnd, &rcClient ); + cx = rcClient.right; + cy = rcClient.bottom; + } + + // position the ListView + SetWindowPos( g_showSounds_hWndListView, NULL, 0, 0, cx, cy, SWP_NOZORDER ); +} + +//----------------------------------------------------------------------------- +// ShowSounds_WndProc +// +//----------------------------------------------------------------------------- +LRESULT CALLBACK ShowSounds_WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + WORD wID = LOWORD( wParam ); + sound_t* pSound; + + switch ( message ) + { + case WM_CREATE: + return 0L; + + case WM_DESTROY: + ShowSounds_SaveConfig(); + g_showSounds_hWnd = NULL; + return 0L; + + case WM_INITMENU: + return 0L; + + case WM_SIZE: + ShowSounds_SizeWindow( hwnd, LOWORD( lParam ), HIWORD( lParam ) ); + return 0L; + + case WM_NOTIFY: + switch ( ( ( LPNMHDR )lParam )->code ) + { + case LVN_COLUMNCLICK: + NMLISTVIEW* pnmlv; + pnmlv = ( NMLISTVIEW* )lParam; + if ( g_showSounds_sortColumn == pnmlv->iSubItem ) + { + // user has clicked on same column - flip the sort + g_showSounds_sortDescending ^= 1; + } + else + { + // sort by new column + g_showSounds_sortColumn = pnmlv->iSubItem; + } + ShowSounds_SortItems(); + return 0L; + + case LVN_GETDISPINFO: + NMLVDISPINFO* plvdi; + plvdi = ( NMLVDISPINFO* )lParam; + pSound = ( sound_t* )plvdi->item.lParam; + switch ( plvdi->item.iSubItem ) + { + case ID_SS_NAME: + plvdi->item.pszText = pSound->pName; + return 0L; + + case ID_SS_PREFIX: + plvdi->item.pszText = pSound->pPrefix; + return 0L; + + case ID_SS_FORMAT: + plvdi->item.pszText = pSound->pFormat; + return 0L; + + case ID_SS_RATE: + plvdi->item.pszText = pSound->rateBuff; + return 0L; + + case ID_SS_BITS: + plvdi->item.pszText = pSound->bitsBuff; + return 0L; + + case ID_SS_CHANNELS: + plvdi->item.pszText = pSound->channelsBuff; + return 0L; + + case ID_SS_SIZE: + plvdi->item.pszText = pSound->dataSizeBuff; + return 0L; + + case ID_SS_STREAMED: + plvdi->item.pszText = pSound->streamedBuff; + return 0L; + + case ID_SS_LOOPED: + plvdi->item.pszText = pSound->loopedBuff; + return 0L; + + case ID_SS_LENGTH: + plvdi->item.pszText = pSound->lengthBuff; + return 0L; + + default: + break; + } + break; + } + break; + + case WM_COMMAND: + switch ( wID ) + { + case IDM_OPTIONS_SUMMARY: + ShowSounds_Summary(); + return 0L; + + case IDM_OPTIONS_REFRESH: + ShowSounds_Refresh(); + return 0L; + + case IDM_OPTIONS_EXPORT: + ShowSounds_Export(); + return 0L; + + case IDM_OPTIONS_PLAYSOUND: + ShowSounds_Play(); + return 0L; + } + break; + } + + return ( DefWindowProc( hwnd, message, wParam, lParam ) ); +} + +//----------------------------------------------------------------------------- +// ShowSounds_Init +// +//----------------------------------------------------------------------------- +bool ShowSounds_Init() +{ + // set up our window class + WNDCLASS wndclass; + + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = ShowSounds_WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = 0; + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_APPLICATION]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = MAKEINTRESOURCE( MENU_SHOWSOUNDS ); + wndclass.lpszClassName = "SHOWSOUNDSCLASS"; + if ( !RegisterClass( &wndclass ) ) + return false; + + ShowSounds_LoadConfig(); + + return true; +} + +//----------------------------------------------------------------------------- +// ShowSounds_Open +// +//----------------------------------------------------------------------------- +void ShowSounds_Open() +{ + RECT clientRect; + HWND hWnd; + int i; + + if ( g_showSounds_hWnd ) + { + // only one instance + if ( IsIconic( g_showSounds_hWnd ) ) + ShowWindow( g_showSounds_hWnd, SW_RESTORE ); + SetForegroundWindow( g_showSounds_hWnd ); + return; + } + + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + "SHOWSOUNDSCLASS", + "Sounds", + WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX, + 0, + 0, + 700, + 400, + g_hDlgMain, + NULL, + g_hInstance, + NULL ); + g_showSounds_hWnd = hWnd; + + GetClientRect( g_showSounds_hWnd, &clientRect ); + hWnd = CreateWindow( + WC_LISTVIEW, + "", + WS_VISIBLE|WS_CHILD|LVS_REPORT|LVS_SHOWSELALWAYS|LVS_SINGLESEL, + 0, + 0, + clientRect.right-clientRect.left, + clientRect.bottom-clientRect.top, + g_showSounds_hWnd, + ( HMENU )ID_SHOWSOUNDS_LISTVIEW, + g_hInstance, + NULL ); + g_showSounds_hWndListView = hWnd; + + // init list view columns + for ( i=0; i<sizeof( g_showSounds_Labels )/sizeof( g_showSounds_Labels[0] ); i++ ) + { + LVCOLUMN lvc; + memset( &lvc, 0, sizeof( lvc ) ); + + lvc.mask = LVCF_FMT|LVCF_WIDTH|LVCF_TEXT|LVCF_SUBITEM; + lvc.iSubItem = 0; + lvc.cx = g_showSounds_Labels[i].width; + lvc.fmt = LVCFMT_LEFT; + lvc.pszText = ( LPSTR )g_showSounds_Labels[i].name; + + ListView_InsertColumn( g_showSounds_hWndListView, i, &lvc ); + } + + ListView_SetBkColor( g_showSounds_hWndListView, g_backgroundColor ); + ListView_SetTextBkColor( g_showSounds_hWndListView, g_backgroundColor ); + + DWORD style = LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES|LVS_EX_HEADERDRAGDROP; + ListView_SetExtendedListViewStyleEx( g_showSounds_hWndListView, style, style ); + + // populate list view + for ( i=0; i<g_showSounds_numSounds; i++ ) + ShowSounds_AddViewItem( &g_showSounds_pSounds[i] ); + ShowSounds_SortItems(); + + if ( g_showSounds_windowRect.right && g_showSounds_windowRect.bottom ) + MoveWindow( g_showSounds_hWnd, g_showSounds_windowRect.left, g_showSounds_windowRect.top, g_showSounds_windowRect.right-g_showSounds_windowRect.left, g_showSounds_windowRect.bottom-g_showSounds_windowRect.top, FALSE ); + ShowWindow( g_showSounds_hWnd, SHOW_OPENWINDOW ); + + // get data from application + ShowSounds_Refresh(); +} + +//----------------------------------------------------------------------------- +// rc_SoundList +// +// Sent from application with sound list +//----------------------------------------------------------------------------- +int rc_SoundList( char* commandPtr ) +{ + char* cmdToken; + int numSounds; + int soundList; + int retAddr; + int retVal; + int errCode = -1; + xrSound_t* pLocalList; + int prefixLen; + char *pStr; + + // remove old entries + ShowSounds_Clear(); + + // get number of sounds + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &numSounds ); + + // get sound list + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &soundList ); + + // get retAddr + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &retAddr ); + + pLocalList = new xrSound_t[numSounds]; + memset( pLocalList, 0, numSounds*sizeof( xrSound_t ) ); + + g_showSounds_numSounds = numSounds; + g_showSounds_pSounds = new sound_t[numSounds]; + memset( g_showSounds_pSounds, 0, numSounds*sizeof( sound_t ) ); + + // get the caller's command list + DmGetMemory( ( void* )soundList, numSounds*sizeof( xrSound_t ), pLocalList, NULL ); + + // build out the resident list + for ( int i=0; i<numSounds; i++ ) + { + // swap the structure + pLocalList[i].rate = BigDWord( pLocalList[i].rate ); + pLocalList[i].bits = BigDWord( pLocalList[i].bits ); + pLocalList[i].channels = BigDWord( pLocalList[i].channels ); + pLocalList[i].looped = BigDWord( pLocalList[i].looped ); + pLocalList[i].dataSize = BigDWord( pLocalList[i].dataSize ); + pLocalList[i].numSamples = BigDWord( pLocalList[i].numSamples ); + pLocalList[i].streamed = BigDWord( pLocalList[i].streamed ); + + // strip the prefix + pStr = pLocalList[i].nameString; + while ( *pStr ) + { + if ( __iscsym( *pStr ) ) + { + // first non-preifx character + break; + } + pStr++; + } + g_showSounds_pSounds[i].pName = strdup( pStr ); + + char prefixString[256]; + prefixLen = pStr - pLocalList[i].nameString; + memcpy( prefixString, pLocalList[i].nameString, prefixLen ); + prefixString[prefixLen] = '\0'; + g_showSounds_pSounds[i].pPrefix = strdup( prefixString ); + + // get the format name + g_showSounds_pSounds[i].pFormat = strdup( pLocalList[i].formatString ); + + g_showSounds_pSounds[i].rate = pLocalList[i].rate; + g_showSounds_pSounds[i].bits = pLocalList[i].bits; + g_showSounds_pSounds[i].channels = pLocalList[i].channels; + g_showSounds_pSounds[i].dataSize = pLocalList[i].dataSize; + g_showSounds_pSounds[i].numSamples = pLocalList[i].numSamples; + g_showSounds_pSounds[i].streamed = pLocalList[i].streamed; + g_showSounds_pSounds[i].looped = pLocalList[i].looped; + + // determine duration + // must use sample count due to compression + if ( g_showSounds_pSounds[i].rate > 0 ) + g_showSounds_pSounds[i].length = ( float )g_showSounds_pSounds[i].numSamples/( float )g_showSounds_pSounds[i].rate; + else + g_showSounds_pSounds[i].length = 0; + + // add to list view + ShowSounds_AddViewItem( &g_showSounds_pSounds[i] ); + } + + // return the result + retVal = numSounds; + int xboxRetVal = BigDWord( retVal ); + DmSetMemory( ( void* )retAddr, sizeof( int ), &xboxRetVal, NULL ); + + DebugCommand( "0x%8.8x = SoundList( 0x%8.8x, 0x%8.8x )\n", retVal, numSounds, soundList ); + + delete [] pLocalList; + + // update + ShowSounds_SortItems(); + + // success + errCode = 0; + +cleanUp: + return ( errCode ); +} diff --git a/utils/xbox/vxconsole/show_textures.cpp b/utils/xbox/vxconsole/show_textures.cpp new file mode 100644 index 0000000..e8e9cbb --- /dev/null +++ b/utils/xbox/vxconsole/show_textures.cpp @@ -0,0 +1,971 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// SHOW_TEXTURES.CPP +// +// Show Textures Display. +//=====================================================================================// +#include "vxconsole.h" + +#define ID_SHOWTEXTURES_LISTVIEW 100 + +// column id +#define ID_ST_NAME 0 +#define ID_ST_SIZE 1 +#define ID_ST_GROUP 2 +#define ID_ST_FORMAT 3 +#define ID_ST_WIDTH 4 +#define ID_ST_HEIGHT 5 +#define ID_ST_DEPTH 6 +#define ID_ST_NUMLEVELS 7 +#define ID_ST_BINDS 8 +#define ID_ST_REFCOUNT 9 +#define ID_ST_LOAD 10 + +typedef enum +{ + LS_STATIC, // surface + LS_PROCEDURAL, // lacks disk based bits + LS_SYNCHRONOUS, // loaded synchronously + LS_FALLBACK, // fallback version, queued hires + LS_HIRES, // finalized at hires + LS_FAILED, // failed to load + LS_MAX +} loadState_e; + +typedef struct +{ + int listIndex; + char *pLongName; + char *pShortName; + char *pGroupName; + char *pFormatName; + int size; + char sizeBuff[16]; + int width; + char widthBuff[16]; + int height; + char heightBuff[16]; + int depth; + char depthBuff[16]; + int numLevels; + char numLevelsBuff[16]; + int binds; + char bindsBuff[16]; + int refCount; + char refCountBuff[16]; + int loadState; + int edram; +} texture_t; + +typedef struct +{ + const CHAR* name; + int width; + int subItemIndex; + CHAR nameBuff[32]; +} label_t; + +HWND g_showTextures_hWnd; +HWND g_showTextures_hWndListView; +RECT g_showTextures_windowRect; +int g_showTextures_sortColumn; +int g_showTextures_sortDescending; +texture_t *g_showTextures_pTextures; +int g_showTextures_numTextures; +int g_showTextures_currentFrame; +int g_showTextures_fullPath; +char g_showTextures_drawTextureName[MAX_PATH]; + +char *g_showTextures_loadStrings[LS_MAX] = +{ + "Static", + "Procedural", + "Synchronous", + "Fallback", + "", + "Failed", +}; + +label_t g_showTextures_Labels[] = +{ + {"Name", 150, ID_ST_NAME}, + {"D3D Size", 80, ID_ST_SIZE}, + {"Group", 150, ID_ST_GROUP}, + {"Format", 120, ID_ST_FORMAT}, + {"Width", 80, ID_ST_WIDTH}, + {"Height", 80, ID_ST_HEIGHT}, + {"Depth", 80, ID_ST_DEPTH}, + {"NumLevels", 80, ID_ST_NUMLEVELS}, + {"Binds", 80, ID_ST_BINDS}, + {"RefCount", 80, ID_ST_REFCOUNT}, + {"Load State", 120, ID_ST_LOAD}, +}; + +//----------------------------------------------------------------------------- +// ShowTextures_SaveConfig +// +//----------------------------------------------------------------------------- +void ShowTextures_SaveConfig() +{ + char buff[256]; + + Sys_SetRegistryInteger( "showTexturesFullPath", g_showTextures_fullPath ); + Sys_SetRegistryInteger( "showTexturesCurrentFrame", g_showTextures_currentFrame ); + Sys_SetRegistryInteger( "showTexturesSortColumn", g_showTextures_sortColumn ); + Sys_SetRegistryInteger( "showTexturesSortDescending", g_showTextures_sortDescending ); + + WINDOWPLACEMENT wp; + memset( &wp, 0, sizeof( wp ) ); + wp.length = sizeof( WINDOWPLACEMENT ); + GetWindowPlacement( g_showTextures_hWnd, &wp ); + g_showTextures_windowRect = wp.rcNormalPosition; + + sprintf( buff, "%d %d %d %d", g_showTextures_windowRect.left, g_showTextures_windowRect.top, g_showTextures_windowRect.right, g_showTextures_windowRect.bottom ); + Sys_SetRegistryString( "showTexturesWindowRect", buff ); +} + +//----------------------------------------------------------------------------- +// ShowTextures_LoadConfig +// +//----------------------------------------------------------------------------- +void ShowTextures_LoadConfig() +{ + int numArgs; + char buff[256]; + + Sys_GetRegistryInteger( "showTexturesFullPath", true, g_showTextures_fullPath ); + Sys_GetRegistryInteger( "showTexturesCurrentFrame", false, g_showTextures_currentFrame ); + Sys_GetRegistryInteger( "showTexturesSortColumn", ID_ST_NAME, g_showTextures_sortColumn ); + Sys_GetRegistryInteger( "showTexturesSortDescending", false, g_showTextures_sortDescending ); + + Sys_GetRegistryString( "showTexturesWindowRect", buff, "", sizeof( buff ) ); + numArgs = sscanf( buff, "%d %d %d %d", &g_showTextures_windowRect.left, &g_showTextures_windowRect.top, &g_showTextures_windowRect.right, &g_showTextures_windowRect.bottom ); + if ( numArgs != 4 || g_showTextures_windowRect.left < 0 || g_showTextures_windowRect.top < 0 || g_showTextures_windowRect.right < 0 || g_showTextures_windowRect.bottom < 0 ) + { + memset( &g_showTextures_windowRect, 0, sizeof( g_showTextures_windowRect ) ); + } +} + +//----------------------------------------------------------------------------- +// ShowTextures_Clear +// +//----------------------------------------------------------------------------- +void ShowTextures_Clear() +{ + // delete all the list view entries + if ( g_showTextures_hWnd ) + { + ListView_DeleteAllItems( g_showTextures_hWndListView ); + } + + if ( !g_showTextures_pTextures ) + { + return; + } + + for ( int i=0; i<g_showTextures_numTextures; i++ ) + { + free( g_showTextures_pTextures[i].pLongName ); + free( g_showTextures_pTextures[i].pShortName ); + free( g_showTextures_pTextures[i].pGroupName ); + free( g_showTextures_pTextures[i].pFormatName ); + } + + g_showTextures_pTextures = NULL; + g_showTextures_numTextures = 0; +} + +//----------------------------------------------------------------------------- +// ShowTextures_Export +// +//----------------------------------------------------------------------------- +void ShowTextures_Export() +{ + OPENFILENAME ofn; + char logFilename[MAX_PATH]; + int retval; + FILE* fp; + int i; + int count; + + memset( &ofn, 0, sizeof( ofn ) ); + ofn.lStructSize = sizeof( ofn ); + ofn.hwndOwner = g_showTextures_hWnd; + ofn.lpstrFile = logFilename; + ofn.lpstrFile[0] = '\0'; + ofn.nMaxFile = sizeof( logFilename ); + ofn.lpstrFilter = "Excel CSV\0*.CSV\0All Files\0*.*\0"; + ofn.nFilterIndex = 1; + ofn.lpstrFileTitle = NULL; + ofn.nMaxFileTitle = 0; + ofn.lpstrInitialDir = "c:\\"; + ofn.Flags = OFN_PATHMUSTEXIST; + + // display the Open dialog box. + retval = GetOpenFileName( &ofn ); + if ( !retval ) + { + return; + } + + Sys_AddExtension( ".csv", logFilename, sizeof( logFilename ) ); + + fp = fopen( logFilename, "wt+" ); + if ( !fp ) + { + return; + } + + // labels + count = sizeof( g_showTextures_Labels )/sizeof( g_showTextures_Labels[0] ); + for ( i=0; i<count; i++ ) + { + fprintf( fp, "\"%s\"", g_showTextures_Labels[i].name ); + if ( i != count-1 ) + { + fprintf( fp, "," ); + } + } + fprintf( fp, "\n" ); + + // dump to the log + for ( i=0; i<g_showTextures_numTextures; i++ ) + { + if ( g_showTextures_fullPath ) + { + fprintf( fp, "\"%s\"", g_showTextures_pTextures[i].pLongName ); + } + else + { + fprintf( fp, "\"%s\"", g_showTextures_pTextures[i].pShortName ); + } + fprintf( fp, ",\"%s\"", g_showTextures_pTextures[i].sizeBuff ); + fprintf( fp, ",\"%s\"", g_showTextures_pTextures[i].pGroupName ); + fprintf( fp, ",\"%s\"", g_showTextures_pTextures[i].pFormatName ); + fprintf( fp, ",\"%s\"", g_showTextures_pTextures[i].widthBuff ); + fprintf( fp, ",\"%s\"", g_showTextures_pTextures[i].heightBuff ); + fprintf( fp, ",\"%s\"", g_showTextures_pTextures[i].depthBuff ); + fprintf( fp, ",\"%s\"", g_showTextures_pTextures[i].numLevelsBuff ); + fprintf( fp, ",\"%s\"", g_showTextures_pTextures[i].bindsBuff ); + fprintf( fp, ",\"%s\"", g_showTextures_pTextures[i].refCountBuff ); + fprintf( fp, ",\"%s\"", g_showTextures_loadStrings[g_showTextures_pTextures[i].loadState] ); + fprintf( fp, "\n" ); + } + + fclose( fp ); +} + +//----------------------------------------------------------------------------- +// ShowTextures_Summary +// +//----------------------------------------------------------------------------- +void ShowTextures_Summary() +{ + char buff[1024]; + + // tally the totals + int total = 0; + for ( int i=0; i<g_showTextures_numTextures; i++ ) + { + if ( g_showTextures_pTextures[i].edram ) + { + // edram is does not affect system memory total + continue; + } + total += g_showTextures_pTextures[i].size; + } + + sprintf( + buff, + "Entries:\t\t\t%d\n" + "System D3D Memory:\t%.2f MB\n", + g_showTextures_numTextures, + ( float )total/( 1024.0F*1024.0F ) ); + + MessageBox( g_showTextures_hWnd, buff, "Texture Summary", MB_OK|MB_APPLMODAL ); +} + +//----------------------------------------------------------------------------- +// ShowTextures_DrawTexture +// +//----------------------------------------------------------------------------- +void ShowTextures_DrawTexture() +{ + char command[256]; + texture_t* pTexture; + int selection; + LVITEM lvitem; + + if ( !g_connectedToApp ) + return; + + selection = ListView_GetSelectionMark( g_showTextures_hWndListView ); + if ( selection == -1 ) + return; + + memset( &lvitem, 0, sizeof( lvitem ) ); + lvitem.mask = LVIF_PARAM; + lvitem.iItem = selection; + ListView_GetItem( g_showTextures_hWndListView, &lvitem ); + + pTexture = ( texture_t* )lvitem.lParam; + + if ( !V_stricmp( g_showTextures_drawTextureName, pTexture->pLongName ) ) + { + // hide + sprintf( command, "mat_drawTexture \"\"" ); + g_showTextures_drawTextureName[0] = '\0'; + } + else + { + // show + sprintf( command, "mat_drawTexture %s", pTexture->pLongName ); + V_strncpy( g_showTextures_drawTextureName, pTexture->pLongName, sizeof( g_showTextures_drawTextureName ) ); + } + + // send the command to application + ProcessCommand( command ); +} + +//----------------------------------------------------------------------------- +// ShowTextures_SetTitle +// +//----------------------------------------------------------------------------- +void ShowTextures_SetTitle() +{ + char titleBuff[128]; + + if ( g_showTextures_hWnd ) + { + strcpy( titleBuff, "Textures " ); + if ( g_showTextures_currentFrame ) + { + strcat( titleBuff, " [FRAME]" ); + } + if ( g_showTextures_fullPath ) + { + strcat( titleBuff, " [FULL PATH]" ); + } + + SetWindowText( g_showTextures_hWnd, titleBuff ); + } +} + +//----------------------------------------------------------------------------- +// ShowTextures_CompareFunc +// +//----------------------------------------------------------------------------- +int CALLBACK ShowTextures_CompareFunc( LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort ) +{ + texture_t* pTextureA = ( texture_t* )lParam1; + texture_t* pTextureB = ( texture_t* )lParam2; + + int sort = 0; + switch ( g_showTextures_sortColumn ) + { + case ID_ST_NAME: + if ( g_showTextures_fullPath ) + { + sort = stricmp( pTextureA->pLongName, pTextureB->pLongName ); + } + else + { + sort = stricmp( pTextureA->pShortName, pTextureB->pShortName ); + } + break; + + case ID_ST_GROUP: + sort = stricmp( pTextureA->pGroupName, pTextureB->pGroupName ); + break; + + case ID_ST_FORMAT: + sort = stricmp( pTextureA->pFormatName, pTextureB->pFormatName ); + break; + + case ID_ST_SIZE: + sort = pTextureA->size - pTextureB->size; + break; + + case ID_ST_WIDTH: + sort = pTextureA->width - pTextureB->width; + break; + + case ID_ST_HEIGHT: + sort = pTextureA->height - pTextureB->height; + break; + + case ID_ST_DEPTH: + sort = pTextureA->depth - pTextureB->depth; + break; + + case ID_ST_NUMLEVELS: + sort = pTextureA->numLevels - pTextureB->numLevels; + break; + + case ID_ST_BINDS: + sort = pTextureA->binds - pTextureB->binds; + break; + + case ID_ST_REFCOUNT: + sort = pTextureA->refCount - pTextureB->refCount; + break; + + case ID_ST_LOAD: + sort = stricmp( g_showTextures_loadStrings[pTextureA->loadState], g_showTextures_loadStrings[pTextureB->loadState] ); + break; + } + + // flip the sort order + if ( g_showTextures_sortDescending ) + { + sort *= -1; + } + + return ( sort ); +} + +//----------------------------------------------------------------------------- +// ShowTextures_SortItems +// +//----------------------------------------------------------------------------- +void ShowTextures_SortItems() +{ + LVITEM lvitem; + texture_t *pTexture; + int i; + + if ( !g_showTextures_hWnd ) + { + // only sort if window is visible + return; + } + + ListView_SortItems( g_showTextures_hWndListView, ShowTextures_CompareFunc, 0 ); + + memset( &lvitem, 0, sizeof( lvitem ) ); + lvitem.mask = LVIF_PARAM; + + // get each item and reset its list index + int itemCount = ListView_GetItemCount( g_showTextures_hWndListView ); + for ( i=0; i<itemCount; i++ ) + { + lvitem.iItem = i; + ListView_GetItem( g_showTextures_hWndListView, &lvitem ); + + pTexture = ( texture_t* )lvitem.lParam; + pTexture->listIndex = i; + } + + // update list view columns with sort key + for ( i=0; i<sizeof( g_showTextures_Labels )/sizeof( g_showTextures_Labels[0] ); i++ ) + { + char symbol; + LVCOLUMN lvc; + + if ( i == g_showTextures_sortColumn ) + { + symbol = g_showTextures_sortDescending ? '<' : '>'; + } + else + { + symbol = ' '; + } + sprintf( g_showTextures_Labels[i].nameBuff, "%s %c", g_showTextures_Labels[i].name, symbol ); + + memset( &lvc, 0, sizeof( lvc ) ); + lvc.mask = LVCF_TEXT; + lvc.pszText = ( LPSTR )g_showTextures_Labels[i].nameBuff; + + ListView_SetColumn( g_showTextures_hWndListView, i, &lvc ); + } +} + +//----------------------------------------------------------------------------- +// ShowTextures_AddViewItem +// +//----------------------------------------------------------------------------- +void ShowTextures_AddViewItem( texture_t* pTexture ) +{ + LVITEM lvi; + + if ( !g_showTextures_hWnd ) + { + // only valid if log window is visible + return; + } + + // update the text callback buffers + sprintf( pTexture->sizeBuff, "%d", pTexture->size ); + sprintf( pTexture->widthBuff, "%d", pTexture->width ); + sprintf( pTexture->heightBuff, "%d", pTexture->height ); + sprintf( pTexture->depthBuff, "%d", pTexture->depth ); + sprintf( pTexture->numLevelsBuff, "%d", pTexture->numLevels ); + sprintf( pTexture->bindsBuff, "%d", pTexture->binds ); + sprintf( pTexture->refCountBuff, "%d", pTexture->refCount ); + + int itemCount = ListView_GetItemCount( g_showTextures_hWndListView ); + + // setup and insert at end of list + memset( &lvi, 0, sizeof( lvi ) ); + lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE; + lvi.iItem = itemCount; + lvi.iSubItem = 0; + lvi.state = 0; + lvi.stateMask = 0; + lvi.pszText = LPSTR_TEXTCALLBACK; + lvi.lParam = ( LPARAM )pTexture; + + // insert and set the real index + pTexture->listIndex = ListView_InsertItem( g_showTextures_hWndListView, &lvi ); +} + +//----------------------------------------------------------------------------- +// ShowTextures_Refresh +// +//----------------------------------------------------------------------------- +void ShowTextures_Refresh() +{ + char command[256]; + + strcpy( command, "mat_get_textures" ); + + if ( !g_showTextures_currentFrame ) + { + strcat( command, " all" ); + } + + // send the command to application which replies with list data + if ( g_connectedToApp ) + { + ProcessCommand( command ); + } +} + +//----------------------------------------------------------------------------- +// ShowTextures_SizeWindow +// +//----------------------------------------------------------------------------- +void ShowTextures_SizeWindow( HWND hwnd, int cx, int cy ) +{ + if ( cx==0 || cy==0 ) + { + RECT rcClient; + GetClientRect( hwnd, &rcClient ); + cx = rcClient.right; + cy = rcClient.bottom; + } + + // position the ListView + SetWindowPos( g_showTextures_hWndListView, NULL, 0, 0, cx, cy, SWP_NOZORDER ); +} + +//----------------------------------------------------------------------------- +// ShowTextures_WndProc +// +//----------------------------------------------------------------------------- +LRESULT CALLBACK ShowTextures_WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + WORD wID = LOWORD( wParam ); + texture_t* pTexture; + + switch ( message ) + { + case WM_CREATE: + return 0L; + + case WM_DESTROY: + ShowTextures_SaveConfig(); + g_showTextures_hWnd = NULL; + return 0L; + + case WM_INITMENU: + CheckMenuItem( ( HMENU )wParam, IDM_OPTIONS_CURRENTFRAME, MF_BYCOMMAND | ( g_showTextures_currentFrame ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_OPTIONS_FULLPATH, MF_BYCOMMAND | ( g_showTextures_fullPath ? MF_CHECKED : MF_UNCHECKED ) ); + return 0L; + + case WM_SIZE: + ShowTextures_SizeWindow( hwnd, LOWORD( lParam ), HIWORD( lParam ) ); + return 0L; + + case WM_NOTIFY: + switch ( ( ( LPNMHDR )lParam )->code ) + { + case LVN_COLUMNCLICK: + NMLISTVIEW* pnmlv; + pnmlv = ( NMLISTVIEW* )lParam; + if ( g_showTextures_sortColumn == pnmlv->iSubItem ) + { + // user has clicked on same column - flip the sort + g_showTextures_sortDescending ^= 1; + } + else + { + // sort by new column + g_showTextures_sortColumn = pnmlv->iSubItem; + } + ShowTextures_SortItems(); + return 0L; + + case LVN_GETDISPINFO: + NMLVDISPINFO* plvdi; + plvdi = ( NMLVDISPINFO* )lParam; + pTexture = ( texture_t* )plvdi->item.lParam; + switch ( plvdi->item.iSubItem ) + { + case ID_ST_NAME: + if ( g_showTextures_fullPath ) + plvdi->item.pszText = pTexture->pLongName; + else + plvdi->item.pszText = pTexture->pShortName; + return 0L; + + case ID_ST_GROUP: + plvdi->item.pszText = pTexture->pGroupName; + return 0L; + + case ID_ST_FORMAT: + plvdi->item.pszText = pTexture->pFormatName; + return 0L; + + case ID_ST_SIZE: + plvdi->item.pszText = pTexture->sizeBuff; + return 0L; + + case ID_ST_WIDTH: + plvdi->item.pszText = pTexture->widthBuff; + return 0L; + + case ID_ST_HEIGHT: + plvdi->item.pszText = pTexture->heightBuff; + return 0L; + + case ID_ST_DEPTH: + plvdi->item.pszText = pTexture->depthBuff; + return 0L; + + case ID_ST_NUMLEVELS: + plvdi->item.pszText = pTexture->numLevelsBuff; + return 0L; + + case ID_ST_BINDS: + plvdi->item.pszText = pTexture->bindsBuff; + return 0L; + + case ID_ST_LOAD: + plvdi->item.pszText = g_showTextures_loadStrings[pTexture->loadState]; + return 0L; + + case ID_ST_REFCOUNT: + plvdi->item.pszText = pTexture->refCountBuff; + return 0L; + + default: + break; + } + break; + } + break; + + case WM_COMMAND: + switch ( wID ) + { + case IDM_OPTIONS_SUMMARY: + ShowTextures_Summary(); + return 0L; + + case IDM_OPTIONS_REFRESH: + ShowTextures_Refresh(); + return 0L; + + case IDM_OPTIONS_EXPORT: + ShowTextures_Export(); + return 0L; + + case IDM_OPTIONS_CURRENTFRAME: + g_showTextures_currentFrame ^= 1; + ShowTextures_SetTitle(); + ShowTextures_Refresh(); + return 0L; + + case IDM_OPTIONS_FULLPATH: + g_showTextures_fullPath ^= 1; + ShowTextures_SetTitle(); + ShowTextures_SortItems(); + return 0L; + + case IDM_OPTIONS_DRAWTEXTURE: + ShowTextures_DrawTexture(); + return 0L; + } + break; + } + + return ( DefWindowProc( hwnd, message, wParam, lParam ) ); +} + +//----------------------------------------------------------------------------- +// ShowTextures_Init +// +//----------------------------------------------------------------------------- +bool ShowTextures_Init() +{ + // set up our window class + WNDCLASS wndclass; + + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = ShowTextures_WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = 0; + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_APPLICATION]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = MAKEINTRESOURCE( MENU_SHOWTEXTURES ); + wndclass.lpszClassName = "SHOWTEXTURESCLASS"; + if ( !RegisterClass( &wndclass ) ) + return false; + + ShowTextures_LoadConfig(); + + return true; +} + +//----------------------------------------------------------------------------- +// ShowTextures_Open +// +//----------------------------------------------------------------------------- +void ShowTextures_Open() +{ + RECT clientRect; + HWND hWnd; + int i; + + if ( g_showTextures_hWnd ) + { + // only one instance + if ( IsIconic( g_showTextures_hWnd ) ) + { + ShowWindow( g_showTextures_hWnd, SW_RESTORE ); + } + SetForegroundWindow( g_showTextures_hWnd ); + return; + } + + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + "SHOWTEXTURESCLASS", + "", + WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX, + 0, + 0, + 700, + 400, + g_hDlgMain, + NULL, + g_hInstance, + NULL ); + g_showTextures_hWnd = hWnd; + + GetClientRect( g_showTextures_hWnd, &clientRect ); + hWnd = CreateWindow( + WC_LISTVIEW, + "", + WS_VISIBLE|WS_CHILD|LVS_REPORT, + 0, + 0, + clientRect.right-clientRect.left, + clientRect.bottom-clientRect.top, + g_showTextures_hWnd, + ( HMENU )ID_SHOWTEXTURES_LISTVIEW, + g_hInstance, + NULL ); + g_showTextures_hWndListView = hWnd; + + // init list view columns + for ( i=0; i<sizeof( g_showTextures_Labels )/sizeof( g_showTextures_Labels[0] ); i++ ) + { + LVCOLUMN lvc; + memset( &lvc, 0, sizeof( lvc ) ); + + lvc.mask = LVCF_FMT|LVCF_WIDTH|LVCF_TEXT|LVCF_SUBITEM; + lvc.iSubItem = 0; + lvc.cx = g_showTextures_Labels[i].width; + lvc.fmt = LVCFMT_LEFT; + lvc.pszText = ( LPSTR )g_showTextures_Labels[i].name; + ListView_InsertColumn( g_showTextures_hWndListView, i, &lvc ); + } + + ListView_SetBkColor( g_showTextures_hWndListView, g_backgroundColor ); + ListView_SetTextBkColor( g_showTextures_hWndListView, g_backgroundColor ); + + DWORD style = LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES|LVS_EX_HEADERDRAGDROP; + ListView_SetExtendedListViewStyleEx( g_showTextures_hWndListView, style, style ); + + // populate list view + for ( i=0; i<g_showTextures_numTextures; i++ ) + { + ShowTextures_AddViewItem( &g_showTextures_pTextures[i] ); + } + ShowTextures_SortItems(); + + ShowTextures_SetTitle(); + + if ( g_showTextures_windowRect.right && g_showTextures_windowRect.bottom ) + { + MoveWindow( g_showTextures_hWnd, g_showTextures_windowRect.left, g_showTextures_windowRect.top, g_showTextures_windowRect.right-g_showTextures_windowRect.left, g_showTextures_windowRect.bottom-g_showTextures_windowRect.top, FALSE ); + } + ShowWindow( g_showTextures_hWnd, SHOW_OPENWINDOW ); + + // get data from application + ShowTextures_Refresh(); +} + +//----------------------------------------------------------------------------- +// rc_TextureList +// +// Sent from application with texture list +//----------------------------------------------------------------------------- +int rc_TextureList( char* commandPtr ) +{ + int errCode = -1; + char* cmdToken; + int numTextures; + int textureList; + int retAddr; + int retVal; + xrTexture_t* pLocalList; + + // remove old entries + ShowTextures_Clear(); + + // get number of textures + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &numTextures ); + + // get texture list + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &textureList ); + + // get retAddr + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &retAddr ); + + pLocalList = new xrTexture_t[numTextures]; + memset( pLocalList, 0, numTextures*sizeof( xrTexture_t ) ); + + g_showTextures_numTextures = numTextures; + g_showTextures_pTextures = new texture_t[numTextures]; + memset( g_showTextures_pTextures, 0, numTextures*sizeof( texture_t ) ); + + // get the caller's command list + DmGetMemory( ( void* )textureList, numTextures*sizeof( xrTexture_t ), pLocalList, NULL ); + + // build out the resident list + for ( int i=0; i<numTextures; i++ ) + { + // swap the structure + pLocalList[i].size = BigDWord( pLocalList[i].size ); + pLocalList[i].width = BigDWord( pLocalList[i].width ); + pLocalList[i].height = BigDWord( pLocalList[i].height ); + pLocalList[i].depth = BigDWord( pLocalList[i].depth ); + pLocalList[i].numLevels = BigDWord( pLocalList[i].numLevels ); + pLocalList[i].binds = BigDWord( pLocalList[i].binds ); + pLocalList[i].refCount = BigDWord( pLocalList[i].refCount ); + pLocalList[i].sRGB = BigDWord( pLocalList[i].sRGB ); + pLocalList[i].edram = BigDWord( pLocalList[i].edram ); + pLocalList[i].procedural = BigDWord( pLocalList[i].procedural ); + pLocalList[i].fallback = BigDWord( pLocalList[i].fallback ); + pLocalList[i].final = BigDWord( pLocalList[i].final ); + pLocalList[i].failed = BigDWord( pLocalList[i].failed ); + + // get the name + g_showTextures_pTextures[i].pLongName = strdup( pLocalList[i].nameString ); + + CHAR shortName[MAX_PATH]; + Sys_StripPath( g_showTextures_pTextures[i].pLongName, shortName, sizeof( shortName ) ); + g_showTextures_pTextures[i].pShortName = strdup( shortName ); + + // get the group name + g_showTextures_pTextures[i].pGroupName = strdup( pLocalList[i].groupString ); + + // get the format name + const char *pFormatName = pLocalList[i].formatString; + if ( !strnicmp( pFormatName, "D3DFMT_", 7 ) ) + { + // strip D3DFMT_ + pFormatName += 7; + } + char tempName[MAX_PATH]; + if ( pLocalList[i].sRGB ) + { + strcpy( tempName, pFormatName ); + strcat( tempName, " (SRGB)" ); + pFormatName = tempName; + } + g_showTextures_pTextures[i].pFormatName = strdup( pFormatName ); + + g_showTextures_pTextures[i].size = pLocalList[i].size; + g_showTextures_pTextures[i].width = pLocalList[i].width; + g_showTextures_pTextures[i].height = pLocalList[i].height; + g_showTextures_pTextures[i].depth = pLocalList[i].depth; + g_showTextures_pTextures[i].numLevels = pLocalList[i].numLevels; + g_showTextures_pTextures[i].binds = pLocalList[i].binds; + g_showTextures_pTextures[i].refCount = pLocalList[i].refCount; + g_showTextures_pTextures[i].edram = pLocalList[i].edram; + + loadState_e loadState; + if ( pLocalList[i].edram || V_stristr( g_showTextures_pTextures[i].pGroupName, "RenderTarget" ) ) + { + loadState = LS_STATIC; + } + else if ( pLocalList[i].procedural ) + { + loadState = LS_PROCEDURAL; + } + else if ( pLocalList[i].final ) + { + loadState = LS_HIRES; + } + else if ( pLocalList[i].failed ) + { + loadState = LS_FAILED; + } + else if ( pLocalList[i].fallback ) + { + loadState = LS_FALLBACK; + } + else + { + loadState = LS_SYNCHRONOUS; + } + g_showTextures_pTextures[i].loadState = loadState; + + // add to list view + ShowTextures_AddViewItem( &g_showTextures_pTextures[i] ); + } + + // return the result + retVal = numTextures; + int xboxRetVal = BigDWord( retVal ); + DmSetMemory( ( void* )retAddr, sizeof( int ), &xboxRetVal, NULL ); + + DebugCommand( "0x%8.8x = TextureList( 0x%8.8x, 0x%8.8x )\n", retVal, numTextures, textureList ); + + delete [] pLocalList; + + // update + ShowTextures_SortItems(); + + // success + errCode = 0; + +cleanUp: + return errCode; +} diff --git a/utils/xbox/vxconsole/sync_files.cpp b/utils/xbox/vxconsole/sync_files.cpp new file mode 100644 index 0000000..facb395 --- /dev/null +++ b/utils/xbox/vxconsole/sync_files.cpp @@ -0,0 +1,942 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// SYNC_FILES.CPP +// +// Sync Files Routines. +//=====================================================================================// +#include "vxconsole.h" + +char g_syncfiles_localPath[MAX_PATH]; +char g_syncfiles_targetPath[MAX_PATH]; +fileNode_t *g_syncfiles_targetFiles; +int g_syncfiles_numTargetFiles; +CProgress *g_syncFiles_progress; +BOOL g_syncFiles_noWrite; +BOOL g_syncFiles_force; +BOOL g_syncFiles_verbose; + +struct dvdimage_t +{ + char szString[MAX_PATH]; + CUtlString installPath; + CUtlString versionDetailString; +}; +CUtlVector< dvdimage_t> g_install_dvdImages; +int g_install_Selection; +bool g_install_bForceSync; +bool g_install_bCleanTarget; + +//----------------------------------------------------------------------------- +// SyncFilesDlg_Validate +// +//----------------------------------------------------------------------------- +bool SyncFilesDlg_Validate() +{ + if ( !g_connectedToXBox ) + { + Sys_MessageBox( "Sync Error", "Cannot sync until connected to XBox." ); + return false; + } + + return true; +} + +//----------------------------------------------------------------------------- +// SyncFilesDlg_Setup +// +//----------------------------------------------------------------------------- +void SyncFilesDlg_Setup( HWND hWnd ) +{ + SetDlgItemText( hWnd, IDC_SYNCFILES_LOCALPATH, g_syncfiles_localPath ); + SetDlgItemText( hWnd, IDC_SYNCFILES_TARGETPATH, g_syncfiles_targetPath ); + + CheckDlgButton( hWnd, IDC_SYNCFILES_FORCESYNC, g_syncFiles_force ? BST_CHECKED : BST_UNCHECKED ); + CheckDlgButton( hWnd, IDC_SYNCFILES_NOWRITE, g_syncFiles_noWrite ? BST_CHECKED : BST_UNCHECKED ); + CheckDlgButton( hWnd, IDC_SYNCFILES_VERBOSE, g_syncFiles_verbose ? BST_CHECKED : BST_UNCHECKED ); +} + +//----------------------------------------------------------------------------- +// SyncFilesDlg_GetChanges +// +//----------------------------------------------------------------------------- +bool SyncFilesDlg_GetChanges( HWND hwnd ) +{ + char localPath[MAX_PATH]; + char targetPath[MAX_PATH]; + + localPath[0] = '\0'; + targetPath[0] = '\0'; + + GetDlgItemText( hwnd, IDC_SYNCFILES_LOCALPATH, localPath, MAX_PATH ); + GetDlgItemText( hwnd, IDC_SYNCFILES_TARGETPATH, targetPath, MAX_PATH ); + + strcpy( g_syncfiles_localPath, localPath ); + Sys_NormalizePath( g_syncfiles_localPath, true ); + + strcpy( g_syncfiles_targetPath, targetPath ); + Sys_NormalizePath( g_syncfiles_targetPath, true ); + + g_syncFiles_force = IsDlgButtonChecked( hwnd, IDC_SYNCFILES_FORCESYNC ) != 0; + g_syncFiles_noWrite = IsDlgButtonChecked( hwnd, IDC_SYNCFILES_NOWRITE ) != 0; + g_syncFiles_verbose = IsDlgButtonChecked( hwnd, IDC_SYNCFILES_VERBOSE ) != 0; + + // success + return ( true ); +} + +//----------------------------------------------------------------------------- +// SyncFilesDlg_Proc +// +//----------------------------------------------------------------------------- +BOOL CALLBACK SyncFilesDlg_Proc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + switch ( message ) + { + case WM_INITDIALOG: + SyncFilesDlg_Setup( hwnd ); + return ( TRUE ); + + case WM_COMMAND: + switch ( LOWORD( wParam ) ) + { + case IDC_OK: + if ( !SyncFilesDlg_GetChanges( hwnd ) ) + break; + EndDialog( hwnd, wParam ); + return ( TRUE ); + + case IDCANCEL: + case IDC_CANCEL: + EndDialog( hwnd, wParam ); + return ( TRUE ); + } + break; + } + return ( FALSE ); +} + +//----------------------------------------------------------------------------- +// SyncFiles_FreeTargetList +// +//----------------------------------------------------------------------------- +void SyncFiles_FreeTargetList() +{ + g_syncfiles_numTargetFiles = 0; + + FreeTargetFileList( g_syncfiles_targetFiles ); + g_syncfiles_targetFiles = NULL; +} + +//----------------------------------------------------------------------------- +// SyncFiles_DoUpdates +// +//----------------------------------------------------------------------------- +bool SyncFiles_DoUpdates() +{ + WIN32_FILE_ATTRIBUTE_DATA localAttributes; + fileNode_t *nodePtr; + char sourceFilename[MAX_PATH]; + char statusBuff1[MAX_PATH]; + char statusBuff2[MAX_PATH]; + int targetPathLen; + char *ptr; + int progress; + int fileSyncMode; + int numSynced; + int retVal; + + g_syncFiles_progress->SetStatus( "Syncing Target Files...", "", "" ); + g_syncFiles_progress->SetMeter( 0, g_syncfiles_numTargetFiles ); + + fileSyncMode = FSYNC_ANDEXISTSONTARGET; + if ( g_syncFiles_force ) + fileSyncMode |= FSYNC_ALWAYS; + else + fileSyncMode |= FSYNC_IFNEWER; + + targetPathLen = strlen( g_syncfiles_targetPath ); + + numSynced = 0; + progress = 0; + nodePtr = g_syncfiles_targetFiles; + while ( nodePtr ) + { + ptr = nodePtr->filename+targetPathLen; + if ( *ptr == '\\' ) + ptr++; + + // replace with source path head + strcpy( sourceFilename, g_syncfiles_localPath ); + Sys_AddFileSeperator( sourceFilename, sizeof( sourceFilename ) ); + strcat( sourceFilename, ptr ); + + float sourceFileSize = 0; + if ( GetFileAttributesEx( sourceFilename, GetFileExInfoStandard, &localAttributes ) ) + { + sourceFileSize = (float)localAttributes.nFileSizeLow / (1024.0f * 1024.0f); + } + + _snprintf( statusBuff1, sizeof( statusBuff1 ), "Local File: %s (%.2f MB)", sourceFilename, sourceFileSize ); + statusBuff1[sizeof( statusBuff1 ) - 1] = '\0'; + _snprintf( statusBuff2, sizeof( statusBuff2 ), "Target File: %s", nodePtr->filename ); + statusBuff1[sizeof( statusBuff2 ) - 1] = '\0'; + g_syncFiles_progress->SetStatus( NULL, statusBuff1, statusBuff2 ); + + retVal = FileSyncEx( sourceFilename, nodePtr->filename, fileSyncMode, g_syncFiles_verbose != FALSE, g_syncFiles_noWrite != FALSE); + if ( retVal == 1 ) + { + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Sync: %s -> %s\n", sourceFilename, nodePtr->filename ); + numSynced++; + } + + progress++; + g_syncFiles_progress->SetMeter( progress, -1 ); + if ( g_syncFiles_progress->IsCancel() ) + { + return false; + } + + nodePtr = nodePtr->nextPtr; + } + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Synced %d/%d Files.\n", numSynced, g_syncfiles_numTargetFiles ); + + return true; +} + +//----------------------------------------------------------------------------- +// SyncFiles_GetTargetList +// +//----------------------------------------------------------------------------- +bool SyncFiles_GetTargetList( char* pTargetPath ) +{ + g_syncFiles_progress->SetStatus( "Getting Target Files...", "", "" ); + g_syncFiles_progress->SetMeter( 0, 100 ); + + if ( !GetTargetFileList_r( pTargetPath, true, FA_NORMAL|FA_READONLY, 0, &g_syncfiles_targetFiles ) ) + { + ConsoleWindowPrintf( RGB( 255,0,0 ), "Bad Target Path '%s'\n", pTargetPath ); + return false; + } + + fileNode_t* pFileNode; + for ( pFileNode = g_syncfiles_targetFiles; pFileNode; pFileNode = pFileNode->nextPtr ) + { + g_syncfiles_numTargetFiles++; + } + + // success + return true; +} + +//----------------------------------------------------------------------------- +// SyncFilesDlg_SaveConfig +// +//----------------------------------------------------------------------------- +void SyncFilesDlg_SaveConfig() +{ + Sys_SetRegistryString( "syncfiles_localPath", g_syncfiles_localPath ); + Sys_SetRegistryString( "syncfiles_targetPath", g_syncfiles_targetPath ); + Sys_SetRegistryInteger( "syncfiles_force", g_syncFiles_force ); + Sys_SetRegistryInteger( "syncfiles_noWrite", g_syncFiles_noWrite ); + Sys_SetRegistryInteger( "syncfiles_verbose", g_syncFiles_verbose ); +} + +//----------------------------------------------------------------------------- +// SyncFilesDlg_Open +// +//----------------------------------------------------------------------------- +void SyncFilesDlg_Open( void ) +{ + int result; + bool bError; + bool bValid; + + result = DialogBox( g_hInstance, MAKEINTRESOURCE( IDD_SYNCFILES ), g_hDlgMain, ( DLGPROC )SyncFilesDlg_Proc ); + if ( LOWORD( result ) != IDC_OK ) + return; + + SyncFilesDlg_SaveConfig(); + + if ( !SyncFilesDlg_Validate() ) + return; + + g_syncFiles_progress = new CProgress; + g_syncFiles_progress->Open( "Sync Files...", true, true ); + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "\nSyncing Files From '%s' to '%s'\n", g_syncfiles_localPath, g_syncfiles_targetPath ); + + bError = true; + + // get a file listing from target + bValid = SyncFiles_GetTargetList( g_syncfiles_targetPath ); + if ( !bValid ) + goto cleanUp; + + // mark all files needing update + bValid = SyncFiles_DoUpdates(); + if ( !bValid ) + goto cleanUp; + + bError = false; + +cleanUp: + delete g_syncFiles_progress; + g_syncFiles_progress = NULL; + + if ( bError ) + ConsoleWindowPrintf( XBX_CLR_RED, "Aborted.\n" ); + else + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Finished.\n" ); + + SyncFiles_FreeTargetList(); +} + +//----------------------------------------------------------------------------- +// SyncFilesDlg_LoadConfig +// +//----------------------------------------------------------------------------- +void SyncFilesDlg_LoadConfig() +{ + // get our config + Sys_GetRegistryString( "syncfiles_localPath", g_syncfiles_localPath, g_localPath, sizeof( g_syncfiles_localPath ) ); + Sys_GetRegistryString( "syncfiles_targetPath", g_syncfiles_targetPath, g_targetPath, sizeof( g_syncfiles_targetPath ) ); + Sys_GetRegistryInteger( "syncfiles_force", false, g_syncFiles_force ); + Sys_GetRegistryInteger( "syncfiles_noWrite", false, g_syncFiles_noWrite ); + Sys_GetRegistryInteger( "syncfiles_verbose", false, g_syncFiles_verbose ); +} + +//----------------------------------------------------------------------------- +// SyncFilesDlg_Init +// +//----------------------------------------------------------------------------- +bool SyncFilesDlg_Init() +{ + SyncFilesDlg_LoadConfig(); + return true; +} + +//----------------------------------------------------------------------------- +// InstallDlg_InstallImage +// +//----------------------------------------------------------------------------- +void InstallDlg_InstallImage( const char *pInstallPath, bool bForce, bool bCleanTarget ) +{ + int errCode; + char *pToken; + char arg1[MAXTOKEN]; + char arg2[MAXTOKEN]; + char sourceFilename[MAX_PATH]; + char sourcePath[MAX_PATH]; + char targetFilename[MAX_PATH]; + char filename[MAX_PATH]; + WIN32_FIND_DATA findData; + HANDLE h; + + if ( !pInstallPath[0] ) + { + return; + } + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "\nSyncing From Install Depot: %s\n", pInstallPath ); + + // get the install script + char szScriptPath[MAX_PATH]; + V_ComposeFileName( pInstallPath, "../dvd_install.txt", szScriptPath, sizeof( szScriptPath ) ); + if ( !Sys_Exists( szScriptPath ) ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "Failed to open: %s\n", szScriptPath ); + return; + } + + // sanity check + // DVD image auto-build failure prevents the presence of the default.xex + char szTempFilename[MAX_PATH]; + V_ComposeFileName( pInstallPath, "default.xex", szTempFilename, sizeof( szTempFilename ) ); + if ( !Sys_Exists( szTempFilename ) ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "Cancelled Installation! DVD Image Auto-Build Process Failed - Missing default.xex!\n" ); + return; + } + + // get the version detail + char szVersionPath[MAX_PATH]; + char *pVersionDetailString = NULL; + V_ComposeFileName( pInstallPath, "version.txt", szVersionPath, sizeof( szVersionPath ) ); + if ( Sys_LoadFile( szVersionPath, (void**)&pVersionDetailString ) <= 0 ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "Cancelled Installation! DVD Image Auto-Build Process Failed! - Missing version.txt\n" ); + return; + } + + Sys_LoadScriptFile( szScriptPath ); + + CProgress* pProgress = new CProgress; + pProgress->Open( "Installing DVD Image...", true, false ); + + int numFailed = 0; + int numSkipped = 0; + int numUpdated = 0; + int version = 0; + + bool bFailed = true; + bool bSyntaxError = false; + bool bCancelled = false; + while ( 1 ) + { + pToken = Sys_GetToken( true ); + if ( !pToken || !pToken[0] ) + break; + + if ( pProgress->IsCancel() ) + { + bCancelled = true; + break; + } + + if ( !stricmp( pToken, "$version" ) ) + { + // version <num> <targetroot> + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + { + bSyntaxError = true; + break; + } + version = atoi( pToken ); + if ( version < 0 ) + { + version = 0; + } + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + { + bSyntaxError = true; + break; + } + Sys_StripQuotesFromToken( pToken ); + V_FixSlashes( pToken ); + if ( pToken[0] == CORRECT_PATH_SEPARATOR ) + { + // remove initial slash + memcpy( pToken, pToken+1, strlen( pToken ) ); + } + + char szRootPath[MAX_PATH]; + V_ComposeFileName( g_targetPath, pToken, szRootPath, sizeof( szRootPath ) ); + + if ( bCleanTarget ) + { + // delete any exisiting files at target + DM_FILE_ATTRIBUTES fileAttributes; + HRESULT hr = DmGetFileAttributes( szRootPath, &fileAttributes ); + if ( hr == XBDM_NOERR ) + { + // delete all files at valid target + V_ComposeFileName( szRootPath, "*.*", szTempFilename, sizeof( szTempFilename ) ); + char *pArgs[3]; + pArgs[0] = "*del"; + pArgs[1] = szTempFilename; + pArgs[2] = "/s"; + if ( !lc_del( 3, pArgs ) ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "Failed To Delete Files At '%s'.\n", szRootPath ); + break; + } + } + } + + char szTargetVersionPath[MAX_PATH]; + V_ComposeFileName( szRootPath, "version.txt", szTargetVersionPath, sizeof( szTargetVersionPath ) ); + + if ( !bForce ) + { + int fileSize; + char *pTargetVersionDetailString; + if ( !LoadTargetFile( szTargetVersionPath, &fileSize, (void**)&pTargetVersionDetailString ) ) + { + // expected version does not exist + // force full install + bForce = true; + } + else if ( strcmp( pVersionDetailString, pTargetVersionDetailString ) != 0 ) + { + // different versions + bForce = true; + } + Sys_Free( pTargetVersionDetailString ); + } + + if ( bForce && !FileSyncEx( szVersionPath, szTargetVersionPath, FSYNC_ALWAYS, true, false ) ) + { + numFailed++; + break; + } + } + else if ( !stricmp( pToken, "$print" ) ) + { + // print <string> + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + { + bSyntaxError = true; + break; + } + Sys_StripQuotesFromToken( pToken ); + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "%s\n", pToken ); + } + else if ( !stricmp( pToken, "$copy" ) ) + { + // copy <source> <target> + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + { + bSyntaxError = true; + break; + } + Sys_StripQuotesFromToken( pToken ); + V_FixSlashes( pToken ); + if ( !V_strnicmp( pToken, "DVD\\", 4 ) ) + { + // skip past DVD, used as a placeholder + pToken += 4; + } + V_ComposeFileName( pInstallPath, pToken, arg1, sizeof( arg1 ) ); + + pToken = Sys_GetToken( false ); + if ( !pToken || !pToken[0] ) + { + bSyntaxError = true; + break; + } + Sys_StripQuotesFromToken( pToken ); + V_FixSlashes( pToken ); + if ( pToken[0] == CORRECT_PATH_SEPARATOR ) + { + // remove initial slash + memcpy( pToken, pToken+1, strlen( pToken ) ); + } + V_ComposeFileName( g_targetPath, pToken, arg2, sizeof( arg2 ) ); + + Sys_StripFilename( arg1, sourcePath, sizeof( sourcePath ) ); + + h = FindFirstFile( arg1, &findData ); + if ( h != INVALID_HANDLE_VALUE ) + { + do + { + if ( pProgress->IsCancel() ) + { + bCancelled = true; + break; + } + + if ( !stricmp( findData.cFileName, "." ) || !stricmp( findData.cFileName, ".." ) ) + { + continue; + } + if ( findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) + { + continue; + } + + strcpy( sourceFilename, sourcePath ); + Sys_AddFileSeperator( sourceFilename, sizeof( sourceFilename ) ); + strcat( sourceFilename, findData.cFileName ); + Sys_NormalizePath( sourceFilename, false ); + + Sys_StripPath( arg2, filename, sizeof( filename ) ); + if ( filename[0] ) + { + // target filename is specified + strcpy( targetFilename, arg2 ); + } + else + { + // target filename is path + strcpy( targetFilename, arg2 ); + Sys_AddFileSeperator( targetFilename, sizeof( targetFilename ) ); + strcat( targetFilename, findData.cFileName ); + Sys_NormalizePath( targetFilename, false ); + } + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "\nCopying: %s -> %s\n", sourceFilename, targetFilename ); + + WIN32_FILE_ATTRIBUTE_DATA localAttributes; + float sourceFileSize = 0; + if ( GetFileAttributesEx( sourceFilename, GetFileExInfoStandard, &localAttributes ) ) + { + sourceFileSize = (float)localAttributes.nFileSizeLow / (1024.0f * 1024.0f); + } + + char statusBuff1[MAX_PATH]; + V_snprintf( statusBuff1, sizeof( statusBuff1 ), "Copying (%.2f MB) ... Please Wait", sourceFileSize ); + pProgress->SetStatus( statusBuff1, sourceFilename, targetFilename ); + + int fileSyncMode = bForce ? FSYNC_ALWAYS : FSYNC_IFNEWER; + errCode = FileSyncEx( sourceFilename, targetFilename, fileSyncMode, true, false ); + if ( errCode < 0 ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "Sync Failure!\n" ); + numFailed++; + } + else if ( errCode == 0 ) + { + ConsoleWindowPrintf( XBX_CLR_BLUE, "Sync Skipped!\n" ); + numSkipped++; + } + else if ( errCode == 1 ) + { + ConsoleWindowPrintf( XBX_CLR_GREEN, "Sync Completed!\n" ); + numUpdated++; + } + } + while ( FindNextFile( h, &findData ) ); + + FindClose( h ); + } + } + else if ( !stricmp( pToken, "$end" ) ) + { + bFailed = false; + break; + } + else + { + ConsoleWindowPrintf( XBX_CLR_RED, "Unknown token: '%s' in '%s'\n", pToken, szScriptPath ); + bSyntaxError = true; + break; + } + } + + if ( bSyntaxError ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "Syntax Error in '%s'.\n", szScriptPath ); + } + + if ( bCancelled ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "Cancelled Installation!\n" ); + } + else if ( bFailed ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "Failed Installation!\n" ); + } + else + { + char *pCRLF = V_stristr( pVersionDetailString, "\r\n" ); + if ( pCRLF ) + { + *pCRLF = '\0'; + } + + // spew stats + ConsoleWindowPrintf( XBX_CLR_BLACK, "\n" ); + ConsoleWindowPrintf( XBX_CLR_BLACK, "Installation Completed.\n" ); + ConsoleWindowPrintf( XBX_CLR_BLACK, "-----------------------\n" ); + ConsoleWindowPrintf( XBX_CLR_BLACK, "Version: %s\n", pVersionDetailString ? pVersionDetailString : "???" ); + + if ( numFailed ) + { + ConsoleWindowPrintf( XBX_CLR_RED, "%d Failures.\n", numFailed ); + } + ConsoleWindowPrintf( XBX_CLR_BLACK, "%d Files In Sync.\n", numSkipped ); + ConsoleWindowPrintf( XBX_CLR_BLACK, "%d Files Updated.\n", numUpdated ); + } + + delete pProgress; + Sys_Free( pVersionDetailString ); + Sys_FreeScriptFile(); +} + +//----------------------------------------------------------------------------- +// InstallDlg_GetChanges +// +//----------------------------------------------------------------------------- +bool InstallDlg_GetChanges( HWND hWnd ) +{ + g_install_bForceSync = IsDlgButtonChecked( hWnd, IDC_INSTALL_FORCESYNC ) != 0; + g_install_bCleanTarget = IsDlgButtonChecked( hWnd, IDC_INSTALL_CLEANTARGET ) != 0; + + g_install_Selection = -1; + for ( int i = 0; i < g_install_dvdImages.Count(); i++ ) + { + int state = ListView_GetItemState( GetDlgItem( hWnd, IDC_INSTALL_LIST ), i, LVIS_FOCUSED|LVIS_SELECTED ); + if ( state == ( LVIS_FOCUSED|LVIS_SELECTED ) ) + { + g_install_Selection = i; + break; + } + } + + return true; +} + +//----------------------------------------------------------------------------- +// SortDVDImages +// +//----------------------------------------------------------------------------- +int SortDVDImages( const dvdimage_t *pA, const dvdimage_t *pB ) +{ + char szStringA[256]; + char szStringB[256]; + + V_strncpy( szStringA, pA->szString, sizeof( szStringA ) ); + V_strncpy( szStringB, pB->szString, sizeof( szStringB ) ); + + // sort staging first + char *pCommentA = V_stristr( szStringA, " (" ); + char *pCommentB = V_stristr( szStringB, " (" ); + if ( pCommentA ) + { + *pCommentA = '\0'; + } + if ( pCommentB ) + { + *pCommentB = '\0'; + } + + return stricmp( szStringB, szStringA ); +} + +//----------------------------------------------------------------------------- +// InstallDlg_Populate +// +//----------------------------------------------------------------------------- +void InstallDlg_Populate( HWND hWnd ) +{ + HWND hWndListView = GetDlgItem( hWnd, IDC_INSTALL_LIST ); + + ListView_DeleteAllItems( hWndListView ); + g_install_dvdImages.Purge(); + + // get list of DVD images + char szPath[MAX_PATH]; + V_ComposeFileName( g_installPath, "DVD_*", szPath, sizeof( szPath ) ); + WIN32_FIND_DATA findData; + HANDLE h = FindFirstFile( szPath, &findData ); + if ( h != INVALID_HANDLE_VALUE ) + { + do + { + if ( !stricmp( findData.cFileName, "." ) || !stricmp( findData.cFileName, ".." ) ) + { + continue; + } + if ( !( findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) ) + { + // skip files + continue; + } + + char szInstallPath[MAX_PATH]; + V_strncpy( szInstallPath, g_installPath, sizeof( szInstallPath ) ); + V_AppendSlash( szInstallPath, sizeof( szInstallPath ) ); + V_strncat( szInstallPath, findData.cFileName, sizeof( szInstallPath ) ); + + // qualify dvd dirs that are images + char szBooterPath[MAX_PATH]; + V_ComposeFileName( szInstallPath, "default.xex", szBooterPath, sizeof( szBooterPath ) ); + if ( !Sys_Exists( szBooterPath ) ) + { + continue; + } + char szVersionPath[MAX_PATH]; + V_ComposeFileName( szInstallPath, "version.txt", szVersionPath, sizeof( szVersionPath ) ); + char *pVersionDetailString = NULL; + if ( Sys_LoadFile( szVersionPath, (void**)&pVersionDetailString ) == -1 ) + { + continue; + } + + char *pCRLF = V_stristr( pVersionDetailString, "\r\n" ); + if ( pCRLF ) + { + *pCRLF = '\0'; + } + + dvdimage_t image; + + int year = 0; + int month = 0; + int day = 0; + int hour = 0; + int minute = 0; + char timeOfDay[256]; + sscanf( findData.cFileName, "DVD_%d_%d_%d_%d_%d_%s", &year, &month, &day, &hour, &minute, timeOfDay ); + + const char *pInfoString = timeOfDay; + if ( !V_strnicmp( timeOfDay, "PM", 2 ) ) + { + if ( hour != 12 ) + { + // 24 hour time for correct sorting + hour += 12; + } + pInfoString += 2; + } + else if ( !V_strnicmp( timeOfDay, "AM", 2 ) ) + { + if ( hour == 12 ) + { + // 24 hour time for correct sorting + hour = 0; + } + pInfoString += 2; + } + + char szCommentBuff[128]; + if ( pInfoString[0] == '_' ) + { + // optional info after AM/PM + pInfoString++; + V_snprintf( szCommentBuff, sizeof( szCommentBuff ), " (%s)", pInfoString ); + } + else + { + szCommentBuff[0] = '\0'; + } + + V_snprintf( image.szString, sizeof( image.szString ), "%2.2d/%2.2d/%4.4d %2.2d:%2.2d%s", month, day, year, hour, minute, szCommentBuff ); + + image.installPath = szInstallPath; + image.versionDetailString = pVersionDetailString; + g_install_dvdImages.AddToTail( image ); + Sys_Free( pVersionDetailString ); + } + while ( FindNextFile( h, &findData ) ); + FindClose( h ); + } + + // current image will be at head + g_install_dvdImages.Sort( SortDVDImages ); + + for ( int i = 0; i < g_install_dvdImages.Count(); i++ ) + { + // setup and insert at end of list + LVITEM lvi; + memset( &lvi, 0, sizeof( lvi ) ); + lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE; + lvi.iItem = i; + lvi.iSubItem = 0; + lvi.state = 0; + lvi.stateMask = 0; + lvi.pszText = LPSTR_TEXTCALLBACK; + lvi.lParam = (LPARAM)i; + + ListView_InsertItem( hWndListView, &lvi ); + } + + if ( g_install_dvdImages.Count() ) + { + ListView_SetItemState( hWndListView, 0, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED ); + } +} + +//----------------------------------------------------------------------------- +// InstallDlg_Setup +// +//----------------------------------------------------------------------------- +void InstallDlg_Setup( HWND hWnd ) +{ + g_install_Selection = -1; + g_install_bForceSync = false; + g_install_bCleanTarget = false; + + HWND hWndListView = GetDlgItem( hWnd, IDC_INSTALL_LIST ); + + // initialize columns + LVCOLUMN lvc; + memset( &lvc, 0, sizeof( lvc ) ); + lvc.mask = LVCF_FMT|LVCF_WIDTH|LVCF_TEXT|LVCF_SUBITEM; + lvc.iSubItem = 0; + lvc.fmt = LVCFMT_LEFT; + lvc.cx = 200; + lvc.pszText = ( LPSTR )"Date Built:"; + ListView_InsertColumn( hWndListView, 0, &lvc ); + lvc.iSubItem = 0; + lvc.fmt = LVCFMT_LEFT; + lvc.cx = 500; + lvc.pszText = ( LPSTR )"Perforce Changelist:"; + ListView_InsertColumn( hWndListView, 1, &lvc ); + + ListView_SetBkColor( hWndListView, g_backgroundColor ); + ListView_SetTextBkColor( hWndListView, g_backgroundColor ); + + DWORD style = LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES; + ListView_SetExtendedListViewStyleEx( hWndListView, style, style ); + + InstallDlg_Populate( hWnd ); +} + +//----------------------------------------------------------------------------- +// InstallDlg_Proc +// +//----------------------------------------------------------------------------- +BOOL CALLBACK InstallDlg_Proc( HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + switch ( message ) + { + case WM_INITDIALOG: + InstallDlg_Setup( hWnd ); + return ( TRUE ); + + case WM_NOTIFY: + switch ( ( ( LPNMHDR )lParam )->code ) + { + case LVN_GETDISPINFO: + NMLVDISPINFO* plvdi; + plvdi = (NMLVDISPINFO*)lParam; + int item = (int)plvdi->item.lParam; + switch ( plvdi->item.iSubItem ) + { + case 0: + plvdi->item.pszText = g_install_dvdImages[item].szString; + return TRUE; + case 1: + plvdi->item.pszText = (LPSTR)g_install_dvdImages[item].versionDetailString.String(); + return TRUE; + } + } + break; + + case WM_COMMAND: + switch ( LOWORD( wParam ) ) + { + case IDC_OK: + InstallDlg_GetChanges( hWnd ); + EndDialog( hWnd, wParam ); + return ( TRUE ); + + case IDC_INSTALL_REFRESH: + InstallDlg_Populate( hWnd ); + return TRUE; + + case IDCANCEL: + case IDC_CANCEL: + EndDialog( hWnd, wParam ); + return ( TRUE ); + } + break; + } + return ( FALSE ); +} + +//----------------------------------------------------------------------------- +// InstallDlg_Open +// +//----------------------------------------------------------------------------- +void InstallDlg_Open( void ) +{ + int result = DialogBox( g_hInstance, MAKEINTRESOURCE( IDD_INSTALL ), g_hDlgMain, ( DLGPROC )InstallDlg_Proc ); + if ( LOWORD( result ) == IDC_OK && g_install_Selection != -1 ) + { + InstallDlg_InstallImage( + g_install_dvdImages[g_install_Selection].installPath.String(), + g_install_bForceSync, + g_install_bCleanTarget ); + } + + g_install_dvdImages.Purge(); +} diff --git a/utils/xbox/vxconsole/sys_scriptlib.cpp b/utils/xbox/vxconsole/sys_scriptlib.cpp new file mode 100644 index 0000000..e52729c --- /dev/null +++ b/utils/xbox/vxconsole/sys_scriptlib.cpp @@ -0,0 +1,292 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// SYS_SCRIPTLIB.CPP +// +// +//=====================================================================================// +#include "vxconsole.h" + +char g_sys_token[MAXTOKEN]; +char* g_sys_scriptbuff; +char* g_sys_scriptptr; +char* g_sys_scriptendptr; +int g_sys_scriptsize; +int g_sys_scriptline; +bool g_sys_endofscript; +bool g_sys_tokenready; +int g_sys_oldscriptline; +char* g_sys_oldscriptptr; + +//----------------------------------------------------------------------------- +// Sys_FreeScriptFile +// +//----------------------------------------------------------------------------- +void Sys_FreeScriptFile(void) +{ + if (g_sys_scriptbuff) + { + Sys_Free(g_sys_scriptbuff); + g_sys_scriptbuff = NULL; + } +} + +//----------------------------------------------------------------------------- +// Sys_LoadScriptFile +// +//----------------------------------------------------------------------------- +void Sys_LoadScriptFile(const char* filename) +{ + g_sys_scriptsize = Sys_LoadFile(filename,(void **)&g_sys_scriptbuff); + + Sys_ResetParser(); +} + +//----------------------------------------------------------------------------- +// Sys_SetScriptData +// +//----------------------------------------------------------------------------- +void Sys_SetScriptData(const char* data, int length) +{ + g_sys_scriptbuff = (char *)data; + g_sys_scriptsize = length; + + Sys_ResetParser(); +} + +//----------------------------------------------------------------------------- +// Sys_UnGetToken +// +//----------------------------------------------------------------------------- +void Sys_UnGetToken(void) +{ + g_sys_tokenready = true; +} + +//----------------------------------------------------------------------------- +// Sys_GetToken +// +//----------------------------------------------------------------------------- +char* Sys_GetToken(bool crossline) +{ + char* tokenptr; + + if (g_sys_tokenready) + { + g_sys_tokenready = false; + return (g_sys_token); + } + + g_sys_token[0] = '\0'; + + if (g_sys_scriptptr >= g_sys_scriptendptr) + { + g_sys_endofscript = true; + return (NULL); + } + +skipspace: + while (*g_sys_scriptptr <= ' ') + { + if (g_sys_scriptptr >= g_sys_scriptendptr) + { + g_sys_endofscript = true; + return (NULL); + } + + if (*g_sys_scriptptr++ == '\n') + { + if (!crossline) + { + // unexpected newline at g_sys_scriptline + return (NULL); + } + + g_sys_scriptline++; + } + } + + if (g_sys_scriptptr >= g_sys_scriptendptr) + { + g_sys_endofscript = true; + return (NULL); + } + + // skip commented line + if ((g_sys_scriptptr[0] == ';') || (g_sys_scriptptr[0] == '/' && g_sys_scriptptr[1] == '/')) + { + if (!crossline) + { + // unexpected newline at g_sys_scriptline + return (NULL); + } + + while (*g_sys_scriptptr++ != '\n') + { + if (g_sys_scriptptr >= g_sys_scriptendptr) + { + g_sys_endofscript = true; + return (NULL); + } + } + + g_sys_scriptline++; + goto skipspace; + } + + tokenptr = g_sys_token; + if (g_sys_scriptptr[0] == '\"' && g_sys_scriptptr[1]) + { + // copy quoted token + do + { + *tokenptr++ = *g_sys_scriptptr++; + if (g_sys_scriptptr == g_sys_scriptendptr) + break; + + if (tokenptr == &g_sys_token[MAXTOKEN]) + { + // token too large + return NULL; + } + } + while (*g_sys_scriptptr >= ' ' && *g_sys_scriptptr != '\"'); + + if (g_sys_scriptptr[0] == '\"') + *tokenptr++ = *g_sys_scriptptr++; + } + else + { + // copy token + while (*g_sys_scriptptr > ' ' && *g_sys_scriptptr != ';' && *g_sys_scriptptr != '\"') + { + *tokenptr++ = *g_sys_scriptptr++; + if (g_sys_scriptptr == g_sys_scriptendptr) + break; + + if (tokenptr == &g_sys_token[MAXTOKEN]) + { + // token too large + return NULL; + } + } + } + + *tokenptr = '\0'; + + return (g_sys_token); +} + +//----------------------------------------------------------------------------- +// Sys_SkipRestOfLine +// +//----------------------------------------------------------------------------- +void Sys_SkipRestOfLine(void) +{ + while (*g_sys_scriptptr++ != '\n') + { + if (g_sys_scriptptr >= g_sys_scriptendptr) + { + break; + } + } + + g_sys_scriptline++; + + // flush any queued token + g_sys_tokenready = false; +} + +//----------------------------------------------------------------------------- +// Sys_TokenAvailable +// +// Returns (TRUE) if token available on line. +//----------------------------------------------------------------------------- +bool Sys_TokenAvailable (void) +{ + char* ptr; + + ptr = g_sys_scriptptr; + while (*ptr <= ' ') + { + if (ptr >= g_sys_scriptendptr) + { + g_sys_endofscript = true; + return (false); + } + + if (*ptr++ == '\n') + return (false); + } + + return (true); +} + + +//----------------------------------------------------------------------------- +// Sys_EndOfScript +// +// Returns (TRUE) at end of script +//----------------------------------------------------------------------------- +bool Sys_EndOfScript(void) +{ + if (g_sys_scriptptr >= g_sys_scriptendptr) + { + g_sys_endofscript = true; + return (true); + } + + return (false); +} + +//----------------------------------------------------------------------------- +// Sys_ResetParser +// +//----------------------------------------------------------------------------- +void Sys_ResetParser(void) +{ + g_sys_scriptptr = g_sys_scriptbuff; + g_sys_scriptendptr = g_sys_scriptptr + g_sys_scriptsize; + g_sys_scriptline = 1; + g_sys_endofscript = false; + g_sys_tokenready = false; +} + +//----------------------------------------------------------------------------- +// Sys_SaveParser +// +//----------------------------------------------------------------------------- +void Sys_SaveParser(void) +{ + g_sys_oldscriptline = g_sys_scriptline; + g_sys_oldscriptptr = g_sys_scriptptr; +} + +//----------------------------------------------------------------------------- +// Sys_RestoreParser +// +//----------------------------------------------------------------------------- +void Sys_RestoreParser(void) +{ + g_sys_scriptline = g_sys_oldscriptline; + g_sys_scriptptr = g_sys_oldscriptptr; + g_sys_tokenready = false; +} + +//----------------------------------------------------------------------------- +// Sys_StripQuotesFromToken +// +//----------------------------------------------------------------------------- +void Sys_StripQuotesFromToken( char *pToken ) +{ + int len; + + len = strlen( pToken ); + if ( len >= 2 && pToken[0] == '\"' ) + { + memcpy( pToken, pToken+1, len-1 ); + pToken[len-2] = '\0'; + } +} + + + diff --git a/utils/xbox/vxconsole/sys_scriptlib.h b/utils/xbox/vxconsole/sys_scriptlib.h new file mode 100644 index 0000000..a019f83 --- /dev/null +++ b/utils/xbox/vxconsole/sys_scriptlib.h @@ -0,0 +1,34 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// SYS_SCRIPTLIB.H +// +// System Utilities. +//=====================================================================================// +#pragma once + +#include "vxconsole.h" + +#define MAXTOKEN 128 + +extern void Sys_LoadScriptFile(const char* filename); +extern void Sys_SetScriptData(const char* data, int length); +extern void Sys_FreeScriptFile(void); +extern char* Sys_GetToken(bool crossline); +extern char* Sys_GetQuotedToken(bool crossline); +extern void Sys_UnGetToken(void); +extern bool Sys_TokenAvailable(void); +extern void Sys_SaveParser(void); +extern void Sys_RestoreParser(void); +extern void Sys_ResetParser(void); +extern void Sys_SkipRestOfLine(void); +extern bool Sys_EndOfScript(void); +extern char* Sys_GetRawToken(void); +extern void Sys_StripQuotesFromToken( char *pToken ); + +extern char g_sys_token[MAXTOKEN]; +extern char* g_sys_scriptbuffer; +extern char* g_sys_scriptptr; +extern char* g_sys_scriptendptr; +extern int g_sys_scriptsize; +extern int g_sys_scriptline; +extern bool g_sys_endofscript; diff --git a/utils/xbox/vxconsole/sys_utils.cpp b/utils/xbox/vxconsole/sys_utils.cpp new file mode 100644 index 0000000..d8bf23c --- /dev/null +++ b/utils/xbox/vxconsole/sys_utils.cpp @@ -0,0 +1,1090 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// SYS_UTILS.C +// +//=====================================================================================// +#include "vxconsole.h" + +CHAR g_szRegistryPrefix[256]; + +//----------------------------------------------------------------------------- +// Sys_SetRegistryPrefix +// +//----------------------------------------------------------------------------- +void Sys_SetRegistryPrefix( const CHAR *pPrefix ) +{ + _snprintf_s( g_szRegistryPrefix, sizeof( g_szRegistryPrefix ), _TRUNCATE, pPrefix ); +} + +//----------------------------------------------------------------------------- +// Sys_SplitRegistryKey +// +//----------------------------------------------------------------------------- +static BOOL Sys_SplitRegistryKey( const CHAR *key, CHAR *key0, int key0Len, CHAR *key1, int key1Len ) +{ + if ( !key ) + { + return false; + } + + int len = (int)strlen( key ); + if ( !len ) + { + return false; + } + + int Start = -1; + for ( int i=len-1; i>=0; i-- ) + { + if ( key[i] == '\\' ) + break; + else + Start=i; + } + + if ( Start == -1 ) + return false; + + _snprintf_s( key0, Start, _TRUNCATE, key ); + _snprintf_s( key1, ( len-Start )+1, _TRUNCATE, key+Start ); + + return true; +} + +//----------------------------------------------------------------------------- +// Sys_SetRegistryString +// +//----------------------------------------------------------------------------- +BOOL Sys_SetRegistryString( const CHAR *keyName, const CHAR *value ) +{ + HKEY hKey; + CHAR key0[256]; + CHAR key1[256]; + CHAR keyBuff[256]; + CHAR *key; + + strcpy_s( keyBuff, sizeof( keyBuff ), g_szRegistryPrefix ); + strcat_s( keyBuff, sizeof( keyBuff ), keyName ); + key = keyBuff; + + HKEY hSlot = HKEY_CURRENT_USER; + if ( !strncmp( key, "HKEY_LOCAL_MACHINE", 18 ) ) + { + hSlot = HKEY_LOCAL_MACHINE; + key += 19; + } + else if ( !strncmp( key, "HKEY_CURRENT_USER", 17 ) ) + { + hSlot = HKEY_CURRENT_USER; + key += 18; + } + + if ( !Sys_SplitRegistryKey( key, key0, sizeof( key0 ), key1, sizeof( key1 ) ) ) + return false; + + if ( RegCreateKeyEx( hSlot,key0,NULL,NULL,REG_OPTION_NON_VOLATILE, value ? KEY_WRITE : KEY_ALL_ACCESS,NULL,&hKey,NULL )!=ERROR_SUCCESS ) + return false; + + if ( RegSetValueEx( hKey, key1, NULL, REG_SZ, ( UCHAR* )value, (int)strlen( value ) + 1 ) != ERROR_SUCCESS ) + { + RegCloseKey( hKey ); + return false; + } + + // success + RegCloseKey( hKey ); + return true; +} + +//----------------------------------------------------------------------------- +// Sys_GetRegistryString +// +//----------------------------------------------------------------------------- +BOOL Sys_GetRegistryString( const CHAR *keyName, CHAR *value, const CHAR* defValue, int valueLen ) +{ + HKEY hKey; + CHAR key0[256]; + CHAR key1[256]; + CHAR keyBuff[256]; + CHAR *key; + + strcpy_s( keyBuff, sizeof( keyBuff ), g_szRegistryPrefix ); + strcat_s( keyBuff, sizeof( keyBuff ), keyName ); + key = keyBuff; + + if ( defValue ) + { + _snprintf_s( value, valueLen, _TRUNCATE, defValue ); + } + + HKEY hSlot = HKEY_CURRENT_USER; + if ( !strncmp( key, "HKEY_LOCAL_MACHINE", 18 ) ) + { + hSlot = HKEY_LOCAL_MACHINE; + key += 19; + } + else if ( !strncmp( key, "HKEY_CURRENT_USER", 17 ) ) + { + hSlot = HKEY_CURRENT_USER; + key += 18; + } + + if ( !Sys_SplitRegistryKey( key,key0,256,key1,256 ) ) + return false; + + if ( RegOpenKeyEx( hSlot,key0,NULL,KEY_READ,&hKey )!=ERROR_SUCCESS ) + return false; + + unsigned long len=valueLen; + if ( RegQueryValueEx( hKey,key1,NULL,NULL,( UCHAR* )value,&len )!=ERROR_SUCCESS ) + { + RegCloseKey( hKey ); + return false; + } + + // success + RegCloseKey( hKey ); + return true; +} + +//----------------------------------------------------------------------------- +// Sys_SetRegistryInteger +// +//----------------------------------------------------------------------------- +BOOL Sys_SetRegistryInteger( const CHAR *keyName, int value ) +{ + HKEY hKey; + CHAR key0[256]; + CHAR key1[256]; + CHAR keyBuff[256]; + CHAR *key; + + strcpy_s( keyBuff, sizeof( keyBuff ), g_szRegistryPrefix ); + strcat_s( keyBuff, sizeof( keyBuff ), keyName ); + key = keyBuff; + + HKEY hSlot = HKEY_CURRENT_USER; + if ( !strncmp( key, "HKEY_LOCAL_MACHINE", 18 ) ) + { + hSlot = HKEY_LOCAL_MACHINE; + key += 19; + } + else if ( !strncmp( key, "HKEY_CURRENT_USER", 17 ) ) + { + hSlot = HKEY_CURRENT_USER; + key += 18; + } + + if ( !Sys_SplitRegistryKey( key,key0,256,key1,256 ) ) + return false; + + if ( RegCreateKeyEx( hSlot, key0, NULL, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL )!=ERROR_SUCCESS ) + return false; + + if ( RegSetValueEx( hKey, key1, NULL, REG_DWORD, ( UCHAR* )&value, 4 )!=ERROR_SUCCESS ) + { + RegCloseKey( hKey ); + return false; + } + + // success + RegCloseKey( hKey ); + return true; +} + +//----------------------------------------------------------------------------- +// Sys_GetRegistryInteger +// +//----------------------------------------------------------------------------- +BOOL Sys_GetRegistryInteger( const CHAR *keyName, int defValue, int &value ) +{ + HKEY hKey; + CHAR key0[256]; + CHAR key1[256]; + CHAR keyBuff[256]; + CHAR *key; + + strcpy_s( keyBuff, sizeof( keyBuff ), g_szRegistryPrefix ); + strcat_s( keyBuff, sizeof( keyBuff ), keyName ); + key = keyBuff; + + value = defValue; + + HKEY hSlot = HKEY_CURRENT_USER; + if ( !strncmp( key, "HKEY_LOCAL_MACHINE", 18 ) ) + { + hSlot = HKEY_LOCAL_MACHINE; + key += 19; + } + else if ( !strncmp( key, "HKEY_CURRENT_USER", 17 ) ) + { + hSlot = HKEY_CURRENT_USER; + key += 18; + } + + if ( !Sys_SplitRegistryKey( key, key0, 256, key1, 256 ) ) + return false; + + if ( RegOpenKeyEx( hSlot, key0, NULL, KEY_READ, &hKey ) != ERROR_SUCCESS ) + return false; + + unsigned long len=4; + if ( RegQueryValueEx( hKey, key1, NULL, NULL, ( UCHAR* )&value, &len ) != ERROR_SUCCESS ) + { + RegCloseKey( hKey ); + return false; + } + + // success + RegCloseKey( hKey ); + return true; +} + +//----------------------------------------------------------------------------- +// Sys_MessageBox +// +//----------------------------------------------------------------------------- +void Sys_MessageBox( const CHAR* title, const CHAR* format, ... ) +{ + CHAR msg[2048]; + va_list argptr; + + va_start( argptr, format ); + vsprintf_s( msg, sizeof( msg ), format, argptr ); + va_end( argptr ); + + MessageBox( NULL, msg, title, MB_OK|MB_TASKMODAL|MB_TOPMOST ); +} + +//----------------------------------------------------------------------------- +// Sys_CopyString +// +//----------------------------------------------------------------------------- +CHAR* Sys_CopyString( const CHAR* str ) +{ + int len = (int)strlen( str ); + CHAR *ptr = ( CHAR* )Sys_Alloc( len+1 ); + memcpy( ptr,str,len+1 ); + + return ( ptr ); +} + +//----------------------------------------------------------------------------- +// Sys_Alloc +// +//----------------------------------------------------------------------------- +void* Sys_Alloc( int size ) +{ + int* ptr; + + if ( !size ) + { + Sys_Error( "Sys_Alloc(): zero size" ); + } + + size = AlignValue( size, 4 ); + + // allocate fixed zero init block + ptr = ( int* )malloc( size ); + if ( !ptr ) + { + Sys_Error( "Sys_Alloc(): %d bytes not available",size ); + } + + V_memset( ptr, 0, size ); + + return ptr; +} + +//----------------------------------------------------------------------------- +// Sys_Free +// +//----------------------------------------------------------------------------- +void Sys_Free( void* ptr ) +{ + if ( !ptr ) + { + // already freed - easier for me, not really an error + return; + } + + free( ptr ); +} + +//----------------------------------------------------------------------------- +// Sys_Error +// +//----------------------------------------------------------------------------- +void Sys_Error( const CHAR* format, ... ) +{ + va_list argptr; + CHAR msg[MAX_SYSPRINTMSG]; + + va_start( argptr, format ); + vsprintf_s( msg, sizeof( msg ), format, argptr ); + va_end( argptr ); + + MessageBox( NULL, msg, "FATAL ERROR", MB_OK|MB_ICONHAND ); +} + +//----------------------------------------------------------------------------- +// Sys_LoadFile +// +//----------------------------------------------------------------------------- +int Sys_LoadFile( const CHAR* filename, void** bufferptr, bool bText ) +{ + int handle; + long length; + CHAR* buffer; + + *bufferptr = NULL; + + if ( !Sys_Exists( filename ) ) + { + return ( -1 ); + } + + int openFlags = bText ? _O_TEXT : _O_BINARY; + _sopen_s( &handle, filename, _O_RDONLY|openFlags, _SH_DENYWR, _S_IREAD ); + if ( handle == -1 ) + { + char szError[MAX_PATH]; + strerror_s( szError, sizeof( szError ), errno ); + Sys_Error( "Sys_LoadFile(): Error opening %s: %s", filename, szError ); + } + + // allocate a buffer with an auto null terminator + length = Sys_FileLength( handle ); + buffer = ( CHAR* )Sys_Alloc( length+1 ); + + int numBytesRead = _read( handle, buffer, length ); + _close( handle ); + + if ( bText ) + { + length = numBytesRead; + } + else if ( length != numBytesRead ) + { + Sys_Error( "Sys_LoadFile(): read failure" ); + } + + // for parsing + buffer[length] = '\0'; + + *bufferptr = ( void* )buffer; + + return ( length ); +} + +//----------------------------------------------------------------------------- +// Sys_SaveFile +// +//----------------------------------------------------------------------------- +bool Sys_SaveFile( const CHAR* filename, void* buffer, long count, bool bText ) +{ + int handle; + int status; + + int openFlags = bText ? _O_TEXT : _O_BINARY; + _sopen_s( &handle, filename, _O_RDWR|_O_CREAT|_O_TRUNC|openFlags, _SH_DENYNO, _S_IREAD|_S_IWRITE ); + if ( handle == -1 ) + { + char szError[MAX_PATH]; + strerror_s( szError, sizeof( szError ), errno ); + Sys_Error( "Sys_SaveFile(): Error opening %s: %s", filename, szError ); + return false; + } + + status = _write( handle, buffer, count ); + if ( status != count ) + { + Sys_Error( "Sys_SaveFile(): write failure %d, errno=%d", status, errno ); + return false; + } + + _close( handle ); + return true; +} + +//----------------------------------------------------------------------------- +// Sys_FileLength +// +//----------------------------------------------------------------------------- +long Sys_FileLength( const CHAR* filename, bool bText ) +{ + long length; + + if ( filename ) + { + int handle; + int openFlags = bText ? _O_TEXT : _O_BINARY; + _sopen_s( &handle, filename, _O_RDONLY|openFlags, _SH_DENYWR, _S_IREAD ); + if ( handle == -1 ) + { + // file does not exist + return -1; + } + + length = _lseek( handle, 0, SEEK_END ); + _close( handle ); + } + else + { + return -1; + } + + return length; +} + +//----------------------------------------------------------------------------- +// Sys_FileLength +// +//----------------------------------------------------------------------------- +long Sys_FileLength( int handle ) +{ + long pos; + long length; + + if ( handle != -1 ) + { + pos = _lseek( handle, 0, SEEK_CUR ); + length = _lseek( handle, 0, SEEK_END ); + _lseek( handle, pos, SEEK_SET ); + } + else + { + return -1; + } + + return length; +} + +//----------------------------------------------------------------------------- +// Sys_NormalizePath +// +//----------------------------------------------------------------------------- +void Sys_NormalizePath( CHAR* path, bool forceToLower ) +{ + int i; + int srclen; + + srclen = (int)strlen( path ); + for ( i=0; i<srclen; i++ ) + { + if ( path[i] == '/' ) + path[i] = '\\'; + else if ( forceToLower && ( path[i] >= 'A' && path[i] <= 'Z' ) ) + path[i] = path[i] - 'A' + 'a'; + } +} + +//----------------------------------------------------------------------------- +// Sys_AddFileSeperator +// +//----------------------------------------------------------------------------- +void Sys_AddFileSeperator( CHAR* path, int pathLen ) +{ + int srclen; + + if ( !path[0] ) + { + strcpy_s( path, pathLen, ".\\" ); + return; + } + + srclen = (int)strlen( path ); + if ( path[srclen-1] == '\\' ) + { + return; + } + + strcat_s( path, pathLen, "\\" ); +} + +//----------------------------------------------------------------------------- +// Sys_StripFilename +// +// Removes filename from path. +//----------------------------------------------------------------------------- +void Sys_StripFilename( const CHAR* inpath, CHAR* outpath, int outPathLen ) +{ + int length; + + strcpy_s( outpath, outPathLen, inpath ); + + length = (int)strlen( outpath )-1; + while ( ( length > 0 ) && ( outpath[length] != '\\' ) && ( outpath[length] != '/' ) && ( outpath[length] != ':' ) ) + length--; + + // leave possible seperator + if ( !length ) + outpath[0] = '\0'; + else + outpath[length+1] = '\0'; +} + +//----------------------------------------------------------------------------- +// Sys_StripExtension +// +// Removes extension from path. +//----------------------------------------------------------------------------- +void Sys_StripExtension( const CHAR* inpath, CHAR* outpath, int outPathLen ) +{ + int length; + + strcpy_s( outpath, outPathLen, inpath ); + + length = (int)strlen( outpath )-1; + while ( length > 0 && outpath[length] != '.' ) + { + length--; + } + + if ( length && outpath[length] == '.' ) + { + outpath[length] = '\0'; + } +} + +//----------------------------------------------------------------------------- +// Sys_StripPath +// +// Removes path from full path. +//----------------------------------------------------------------------------- +void Sys_StripPath( const CHAR* inpath, CHAR* outpath, int outPathLen ) +{ + const CHAR* src; + + src = inpath + strlen( inpath ); + while ( ( src != inpath ) && ( *( src-1 ) != '\\' ) && ( *( src-1 ) != '/' ) && ( *( src-1 ) != ':' ) ) + { + src--; + } + + strcpy_s( outpath, outPathLen, src ); +} + +//----------------------------------------------------------------------------- +// Sys_GetExtension +// +// Gets any extension from the full path. +//----------------------------------------------------------------------------- +void Sys_GetExtension( const CHAR* inpath, CHAR* outpath, int outPathLen ) +{ + const CHAR* src; + + src = inpath + strlen( inpath ) - 1; + + // back up until a . or the start + while ( src != inpath && *( src-1 ) != '.' ) + { + src--; + } + + if ( src == inpath ) + { + *outpath = '\0'; // no extension + return; + } + + strcpy_s( outpath, outPathLen, src ); +} + +//----------------------------------------------------------------------------- +// Sys_AddExtension +// +// Adds extension to end of path. +//----------------------------------------------------------------------------- +void Sys_AddExtension( const CHAR* extension, CHAR* outpath, int outPathLen ) +{ + CHAR* src; + + if ( outpath[0] ) + { + src = outpath + strlen( outpath ) - 1; + while ( ( src != outpath ) && ( *src != '\\' ) && ( *src != '/' ) ) + { + if ( *src == '.' ) + return; + src--; + } + } + + strcat_s( outpath, outPathLen, extension ); +} + +//----------------------------------------------------------------------------- +// Sys_TempFilename +// +// Make a temporary filename at specified path. +//----------------------------------------------------------------------------- +void Sys_TempFilename( CHAR* temppath, int tempPathLen ) +{ + CHAR* ptr; + + ptr = _tempnam( "c:\\", "tmp" ); + strcpy_s( temppath, tempPathLen, ptr ); + free( ptr ); +} + +//----------------------------------------------------------------------------- +// Sys_Exists +// +// Returns TRUE if file exists. +//----------------------------------------------------------------------------- +BOOL Sys_Exists( const CHAR* filename ) +{ + FILE* test; + + fopen_s( &test, filename, "rb" ); + if ( test == NULL ) + { + return false; + } + + fclose( test ); + + return true; +} + +//----------------------------------------------------------------------------- +// Sys_SkipWhitespace +// +//----------------------------------------------------------------------------- +CHAR* Sys_SkipWhitespace( CHAR *data, BOOL *hasNewLines, int* numlines ) +{ + int c; + + while( ( c = *data ) <= ' ' ) + { + if ( c == '\n' ) + { + if ( numlines ) + ( *numlines )++; + + if ( hasNewLines ) + *hasNewLines = true; + } + else if ( !c ) + return ( NULL ); + + data++; + } + + return ( data ); +} + +//----------------------------------------------------------------------------- +// Sys_GetToken +// +//----------------------------------------------------------------------------- +CHAR* Sys_GetToken( CHAR** dataptr, BOOL allowLineBreaks, int* numlines ) +{ + CHAR c; + int len; + BOOL hasNewLines; + CHAR* data; + static CHAR token[MAX_SYSTOKENCHARS]; + + if ( numlines ) + *numlines = 0; + + c = 0; + data = *dataptr; + len = 0; + token[0] = 0; + hasNewLines = false; + + // make sure incoming data is valid + if ( !data ) + { + *dataptr = NULL; + return ( token ); + } + + for ( ;; ) + { + // skip whitespace + data = Sys_SkipWhitespace( data,&hasNewLines,numlines ); + if ( !data ) + { + *dataptr = NULL; + return ( token ); + } + + if ( hasNewLines && !allowLineBreaks ) + { + *dataptr = data; + return ( token ); + } + + c = *data; + + // skip double slash comments + if ( c == '/' && data[1] == '/' ) + { + data += 2; + while ( *data && *data != '\n' ) + data++; + } + // skip /* */ comments + else if ( c =='/' && data[1] == '*' ) + { + data += 2; + while ( *data && ( *data != '*' || data[1] != '/' ) ) + data++; + + if ( *data ) + data += 2; + } + else + break; + } + + // handle quoted strings + if ( c == '\"' ) + { + data++; + for ( ;; ) + { + c = *data++; + if ( c == '\"' || !c ) + { + token[len] = 0; + *dataptr = ( CHAR* )data; + return ( token ); + } + if ( len < MAX_SYSTOKENCHARS ) + token[len++] = c; + } + } + + // parse a regular word + do + { + if ( len < MAX_SYSTOKENCHARS ) + token[len++] = c; + + data++; + c = *data; + if ( c == '\n' && numlines ) + ( *numlines )++; + } while ( c > ' ' ); + + if ( len >= MAX_SYSTOKENCHARS ) + len = 0; + + token[len] = '\0'; + *dataptr = ( CHAR* ) data; + + return ( token ); +} + +//----------------------------------------------------------------------------- +// Sys_SkipBracedSection +// +// The next token should be an open brace. +// Skips until a matching close brace is found. +// Internal brace depths are properly skipped. +//----------------------------------------------------------------------------- +void Sys_SkipBracedSection( CHAR** dataptr, int* numlines ) +{ + CHAR* token; + int depth; + + depth = 0; + do + { + token = Sys_GetToken( dataptr, true, numlines ); + if ( token[1] == '\0' ) + { + if ( token[0] == '{' ) + depth++; + else if ( token[0] == '}' ) + depth--; + } + } + while( depth && *dataptr ); +} + +//----------------------------------------------------------------------------- +// Sys_SkipRestOfLine +// +//----------------------------------------------------------------------------- +void Sys_SkipRestOfLine( CHAR** dataptr, int* numlines ) +{ + CHAR* p; + int c; + + p = *dataptr; + while ( ( c = *p++ ) != '\0' ) + { + if ( c == '\n' ) + { + if ( numlines ) + ( *numlines )++; + break; + } + } + *dataptr = p; +} + +//----------------------------------------------------------------------------- +// Sys_FileTime +// +// Returns a file's last write time +//----------------------------------------------------------------------------- +BOOL Sys_FileTime( CHAR* filename, FILETIME* time ) +{ + HANDLE hFile; + + hFile = CreateFile( + filename, + GENERIC_READ, + FILE_SHARE_READ, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL ); + + if ( hFile == INVALID_HANDLE_VALUE ) + return ( false ); + + // Retrieve the file times for the file. + if ( !GetFileTime( hFile, NULL, NULL, time ) ) + { + CloseHandle( hFile ); + return ( false ); + } + + CloseHandle( hFile ); + return ( true ); +} + +//----------------------------------------------------------------------------- +// Sys_GetSystemTime +// +// Current time marker in milliseconds +//----------------------------------------------------------------------------- +DWORD Sys_GetSystemTime( void ) +{ + LARGE_INTEGER qwTime; + LARGE_INTEGER qwTicksPerSec; + float msecsPerTick; + + // Get the frequency of the timer + QueryPerformanceFrequency( &qwTicksPerSec ); + msecsPerTick = 1000.0f/( FLOAT )qwTicksPerSec.QuadPart; + + QueryPerformanceCounter( &qwTime ); + return ( ( DWORD )( msecsPerTick * ( FLOAT )qwTime.QuadPart ) ); +} + +//----------------------------------------------------------------------------- +// Sys_ColorScale +// +//----------------------------------------------------------------------------- +COLORREF Sys_ColorScale( COLORREF color, float scale ) +{ + int r; + int g; + int b; + + r = color & 0xFF; + g = ( color >> 8 ) & 0xFF; + b = ( color >> 16 ) & 0xFF; + + r = ( int )( ( float )r * scale ); + g = ( int )( ( float )g * scale ); + b = ( int )( ( float )b * scale ); + + if ( r > 255 ) + r = 255; + if ( g > 255 ) + g = 255; + if ( b > 255 ) + b = 255; + + color = RGB( r, g, b ); + return ( color ); +} + +//----------------------------------------------------------------------------- +// Sys_IsWildcardMatch +// +// See if a string matches a wildcard specification that uses * or ? +//----------------------------------------------------------------------------- +bool Sys_IsWildcardMatch( const CHAR *wildcardString, const CHAR *stringToCheck, bool caseSensitive ) +{ + CHAR wcChar; + CHAR strChar; + + if ( !_stricmp( wildcardString, "*.*" ) || !_stricmp( wildcardString, "*" ) ) + { + // matches everything + return true; + } + + // use the starMatchesZero variable to determine whether an asterisk + // matches zero or more characters ( TRUE ) or one or more characters + // ( FALSE ) + bool starMatchesZero = true; + + for ( ;; ) + { + strChar = *stringToCheck; + if ( !strChar ) + { + break; + } + + wcChar = *wildcardString; + if ( !wcChar ) + { + break; + } + + // we only want to advance the pointers if we successfully assigned + // both of our char variables, so we'll do it here rather than in the + // loop condition itself + *stringToCheck++; + *wildcardString++; + + // if this isn't a case-sensitive match, make both chars uppercase + // ( thanks to David John Fielder ( Konan ) at http://innuendo.ev.ca + // for pointing out an error here in the original code ) + if ( !caseSensitive ) + { + wcChar = (CHAR)toupper( wcChar ); + strChar = (CHAR)toupper( strChar ); + } + + // check the wcChar against our wildcard list + switch ( wcChar ) + { + // an asterisk matches zero or more characters + case '*' : + // do a recursive call against the rest of the string, + // until we've either found a match or the string has + // ended + if ( starMatchesZero ) + *stringToCheck--; + + while ( *stringToCheck ) + { + if ( Sys_IsWildcardMatch( wildcardString, stringToCheck++, caseSensitive ) ) + return true; + } + + break; + + // a question mark matches any single character + case '?' : + break; + + // if we fell through, we want an exact match + default : + if ( wcChar != strChar ) + return false; + break; + } + } + + // if we have any asterisks left at the end of the wildcard string, we can + // advance past them if starMatchesZero is TRUE ( so "blah*" will match "blah" ) + while ( ( *wildcardString ) && ( starMatchesZero ) ) + { + if ( *wildcardString == '*' ) + wildcardString++; + else + break; + } + + // if we got to the end but there's still stuff left in either of our strings, + // return false; otherwise, we have a match + if ( ( *stringToCheck ) || ( *wildcardString ) ) + return false; + else + return true; +} + +//----------------------------------------------------------------------------- +// Sys_NumberToCommaString +// +// Add commas to number +//----------------------------------------------------------------------------- +char *Sys_NumberToCommaString( __int64 number, char *buffer, int bufferSize ) +{ + char temp[256]; + char temp2[256]; + int inLen; + char *inPtr; + char *outPtr; + int i; + + sprintf_s( temp, sizeof( temp ), "%I64d", number ); + + // build string backwards + inLen = (int)strlen( temp ); + inPtr = temp+inLen-1; + outPtr = temp2; + while ( inLen > 0 ) + { + for ( i=0; i<3 && inLen > 0; i++, inLen-- ) + { + *outPtr++ = *inPtr--; + } + if ( inLen > 0 ) + *outPtr++ = ','; + } + *outPtr++ = '\0'; + + // reverse string + inLen = (int)strlen( temp2 ); + inPtr = temp2; + outPtr = temp; + for ( i=inLen-1; i>=0; i-- ) + { + *outPtr++ = inPtr[i]; + } + *outPtr++ = '\0'; + + _snprintf_s( buffer, bufferSize, _TRUNCATE, temp ); + + return buffer; +} + +//----------------------------------------------------------------------------- +// Sys_CreatePath +// +//----------------------------------------------------------------------------- +void Sys_CreatePath( const char* pInPath ) +{ + char* ptr; + char dirPath[MAX_PATH]; + + // prime and skip to first seperator + strcpy_s( dirPath, sizeof( dirPath ), pInPath ); + + if ( dirPath[0] == '\\' && dirPath[1] == '\\' ) + { + ptr = strchr( dirPath+1, '\\' ); + } + else + { + ptr = strchr( dirPath, '\\' ); + } + + while ( ptr ) + { + ptr = strchr( ptr+1, '\\' ); + if ( ptr ) + { + *ptr = '\0'; + CreateDirectory( dirPath, NULL ); + *ptr = '\\'; + } + } +} + diff --git a/utils/xbox/vxconsole/sys_utils.h b/utils/xbox/vxconsole/sys_utils.h new file mode 100644 index 0000000..a91c208 --- /dev/null +++ b/utils/xbox/vxconsole/sys_utils.h @@ -0,0 +1,65 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// SYS_UTILS.H +// +// System Utilities. +//=====================================================================================// +#pragma once + +#include "vxconsole.h" + +#pragma warning(disable : 4100) // warning C4100: unreferenced formal parameter + +#define MAX_SYSPRINTMSG 1024 +#define MAX_SYSTOKENCHARS 1024 + +#define MAKEINT64( hiword, loword ) ( ( __int64 )( ( ( ( __int64 )( hiword ) ) << 32 ) | ( __int64 )( loword ) ) ) + +extern void Sys_MessageBox( const CHAR *title, const CHAR *format, ... ); +extern void Sys_Error( const CHAR *format, ... ); + +extern void *Sys_Alloc( int size ); +extern void Sys_Free( void *ptr ); +extern CHAR *Sys_CopyString( const CHAR *str ); + +extern int Sys_LoadFile( const CHAR *filename, void **bufferptr, bool bText = false ); +extern bool Sys_SaveFile( const CHAR *filename, void *buffer, long count, bool bText = false ); +extern long Sys_FileLength( const CHAR *filename, bool bText = false ); +extern long Sys_FileLength( int handle ); +extern BOOL Sys_FileTime( CHAR *filename, FILETIME *time ); +extern void Sys_CreatePath( const char* pInPath ); + +extern void Sys_AddFileSeperator( CHAR *path, int outPathLen ); +extern void Sys_NormalizePath( CHAR *path, bool forceToLower ); +extern void Sys_StripFilename( const CHAR *path, CHAR *outpath, int outPathLen ); +extern void Sys_StripExtension( const CHAR *path, CHAR *outpath, int outPathLen ); +extern void Sys_StripPath( const CHAR *path, CHAR *outpath, int outPathLen ); +extern void Sys_GetExtension( const CHAR *path, CHAR *outpath, int outPathLen ); +extern void Sys_AddExtension( const CHAR *extension, CHAR *outpath, int outPathLen ); +extern void Sys_TempFilename( CHAR *outpath, int outPathLen ); +extern BOOL Sys_Exists( const CHAR *filename ); + +extern CHAR *Sys_GetToken( CHAR **dataptr, BOOL crossline, int *numlines ); +extern CHAR *Sys_SkipWhitespace( CHAR *data, BOOL *hasNewLines, int *numlines ); +extern void Sys_SkipBracedSection( CHAR **dataptr, int *numlines ); +extern void Sys_SkipRestOfLine( CHAR **dataptr, int *numlines ); + +extern void Sys_SetRegistryPrefix( const CHAR *pPrefix ); +extern BOOL Sys_SetRegistryString( const CHAR *key, const CHAR *value ); +extern BOOL Sys_GetRegistryString( const CHAR *key, CHAR *value, const CHAR *defValue, int valueLen ); +extern BOOL Sys_SetRegistryInteger( const CHAR *key, int value ); +extern BOOL Sys_GetRegistryInteger( const CHAR *key, int defValue, int &value ); + +extern DWORD Sys_GetSystemTime( void ); +extern COLORREF Sys_ColorScale( COLORREF color, float scale ); +extern bool Sys_IsWildcardMatch( const CHAR *wildcardString, const CHAR *stringToCheck, bool caseSensitive ); +extern char *Sys_NumberToCommaString( __int64 number, char *buffer, int bufferSize ); + + + + + + + + + diff --git a/utils/xbox/vxconsole/tex_profile.cpp b/utils/xbox/vxconsole/tex_profile.cpp new file mode 100644 index 0000000..8c3ddf1 --- /dev/null +++ b/utils/xbox/vxconsole/tex_profile.cpp @@ -0,0 +1,993 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// TEX_PROFILE.CPP +// +// Texture Profiling Display. +//=====================================================================================// +#include "vxconsole.h" + +#define TEXPROFILE_MAXCOUNTERS 64 +#define TEXPROFILE_MAXSAMPLES 512 + +#define TEXPROFILE_MAJORTICKSIZE 4 +#define TEXPROFILE_MAJORTICKBYTES ( TEXPROFILE_MAJORTICKSIZE*1024.0f*1024.0f ) + +#define TEXPROFILE_HISTORY_MAJORTICKHEIGHT 100 +#define TEXPROFILE_HISTORY_NUMMINORTICKS 3 +#define TEXPROFILE_HISTORY_LABELWIDTH 50 +#define TEXPROFILE_HISTORY_SCALESTEPS 5 +#define TEXPROFILE_HISTORY_MINSCALE 0.3f +#define TEXPROFILE_HISTORY_MAXSCALE 3.0f + +#define TEXPROFILE_SAMPLES_ITEMHEIGHT 15 +#define TEXPROFILE_SAMPLES_BARHEIGHT 10 +#define TEXPROFILE_SAMPLES_MAJORTICKWIDTH 200 +#define TEXPROFILE_SAMPLES_LABELWIDTH 150 +#define TEXPROFILE_SAMPLES_LABELGAP 5 +#define TEXPROFILE_SAMPLES_NUMMINORTICKS 3 +#define TEXPROFILE_SAMPLES_PEAKHOLDTIME 3000 +#define TEXPROFILE_SAMPLES_SCALESTEPS 10 +#define TEXPROFILE_SAMPLES_MINSCALE 0.3f +#define TEXPROFILE_SAMPLES_MAXSCALE 3.0f + +#define ID_TEXPROFILE_SAMPLES 1 +#define ID_TEXPROFILE_HISTORY 2 + +typedef struct +{ + unsigned int samples[TEXPROFILE_MAXSAMPLES]; + unsigned int peakSample; + char label[64]; + COLORREF color; +} profileCounter_t; + +HWND g_texProfile_hWndSamples; +HWND g_texProfile_hWndHistory; +int g_texProfile_numCounters; +profileCounter_t g_texProfile_counters[TEXPROFILE_MAXCOUNTERS]; +RECT g_texProfile_samplesWindowRect; +RECT g_texProfile_historyWindowRect; +DWORD g_texProfile_lastPeakTime; +bool g_texProfile_history_tickMarks = true; +bool g_texProfile_history_colors = true; +int g_texProfile_history_scale; +bool g_texProfile_samples_tickMarks = true; +bool g_texProfile_samples_colors = true; +int g_texProfile_samples_scale; +int g_texProfile_numSamples; +int g_texProfile_currentFrame; + +//----------------------------------------------------------------------------- +// TexProfile_LoadConfig +// +//----------------------------------------------------------------------------- +void TexProfile_LoadConfig() +{ + int numArgs; + char buff[256]; + + // profile samples + Sys_GetRegistryString( "texProfileSamplesWindowRect", buff, "", sizeof( buff ) ); + numArgs = sscanf( buff, "%d %d %d %d", &g_texProfile_samplesWindowRect.left, &g_texProfile_samplesWindowRect.top, &g_texProfile_samplesWindowRect.right, &g_texProfile_samplesWindowRect.bottom ); + if ( numArgs != 4 || g_texProfile_samplesWindowRect.left < 0 || g_texProfile_samplesWindowRect.top < 0 || g_texProfile_samplesWindowRect.right < 0 || g_texProfile_samplesWindowRect.bottom < 0 ) + memset( &g_texProfile_samplesWindowRect, 0, sizeof( g_texProfile_samplesWindowRect ) ); + Sys_GetRegistryInteger( "texProfileSamplesScale", 0, g_texProfile_samples_scale ); + if ( g_texProfile_samples_scale < -TEXPROFILE_SAMPLES_SCALESTEPS || g_texProfile_samples_scale > TEXPROFILE_SAMPLES_SCALESTEPS ) + g_texProfile_samples_scale = 0; + + // profile history + Sys_GetRegistryString( "texProfileHistoryWindowRect", buff, "", sizeof( buff ) ); + numArgs = sscanf( buff, "%d %d %d %d", &g_texProfile_historyWindowRect.left, &g_texProfile_historyWindowRect.top, &g_texProfile_historyWindowRect.right, &g_texProfile_historyWindowRect.bottom ); + if ( numArgs != 4 || g_texProfile_historyWindowRect.left < 0 || g_texProfile_historyWindowRect.top < 0 || g_texProfile_historyWindowRect.right < 0 || g_texProfile_historyWindowRect.bottom < 0 ) + memset( &g_texProfile_historyWindowRect, 0, sizeof( g_texProfile_historyWindowRect ) ); + Sys_GetRegistryInteger( "texProfileHistoryScale", 0, g_texProfile_history_scale ); + if ( g_texProfile_history_scale < -TEXPROFILE_HISTORY_SCALESTEPS || g_texProfile_history_scale > TEXPROFILE_HISTORY_SCALESTEPS ) + g_texProfile_history_scale = 0; + + Sys_GetRegistryInteger( "texProfileCurrentFrame", 0, g_texProfile_currentFrame ); +} + +//----------------------------------------------------------------------------- +// TexProfile_SaveConfig +// +//----------------------------------------------------------------------------- +void TexProfile_SaveConfig() +{ + char buff[256]; + WINDOWPLACEMENT wp; + + // profile samples + if ( g_texProfile_hWndSamples ) + { + memset( &wp, 0, sizeof( wp ) ); + wp.length = sizeof( WINDOWPLACEMENT ); + GetWindowPlacement( g_texProfile_hWndSamples, &wp ); + g_texProfile_samplesWindowRect = wp.rcNormalPosition; + sprintf( buff, "%d %d %d %d", wp.rcNormalPosition.left, wp.rcNormalPosition.top, wp.rcNormalPosition.right, wp.rcNormalPosition.bottom ); + Sys_SetRegistryString( "texProfileSamplesWindowRect", buff ); + } + Sys_SetRegistryInteger( "texProfileSamplesScale", g_texProfile_samples_scale ); + + // profile history + if ( g_texProfile_hWndHistory ) + { + memset( &wp, 0, sizeof( wp ) ); + wp.length = sizeof( WINDOWPLACEMENT ); + GetWindowPlacement( g_texProfile_hWndHistory, &wp ); + g_texProfile_historyWindowRect = wp.rcNormalPosition; + sprintf( buff, "%d %d %d %d", wp.rcNormalPosition.left, wp.rcNormalPosition.top, wp.rcNormalPosition.right, wp.rcNormalPosition.bottom ); + Sys_SetRegistryString( "texProfileHistoryWindowRect", buff ); + } + Sys_SetRegistryInteger( "texProfileHistoryScale", g_texProfile_history_scale ); + + Sys_SetRegistryInteger( "texProfileCurrentFrame", g_texProfile_currentFrame ); +} + +//----------------------------------------------------------------------------- +// TexProfile_SetTitle +// +//----------------------------------------------------------------------------- +void TexProfile_SetTitle() +{ + char titleBuff[128]; + + if ( g_texProfile_hWndSamples ) + { + strcpy( titleBuff, "D3D Usage Snapshot" ); + if ( VProf_GetState() == VPROF_TEXTURE || VProf_GetState() == VPROF_TEXTUREFRAME ) + strcat( titleBuff, " [ON]" ); + if ( g_texProfile_currentFrame ) + strcat( titleBuff, " [FRAME]" ); + + SetWindowText( g_texProfile_hWndSamples, titleBuff ); + } + + if ( g_texProfile_hWndHistory ) + { + strcpy( titleBuff, "D3D Usage History" ); + if ( VProf_GetState() == VPROF_TEXTURE || VProf_GetState() == VPROF_TEXTUREFRAME ) + strcat( titleBuff, " [ON]" ); + if ( g_texProfile_currentFrame ) + strcat( titleBuff, " [FRAME]" ); + + SetWindowText( g_texProfile_hWndHistory, titleBuff ); + } +} + +//----------------------------------------------------------------------------- +// TexProfile_UpdateWindow +// +//----------------------------------------------------------------------------- +void TexProfile_UpdateWindow() +{ + if ( g_texProfile_hWndSamples && !IsIconic( g_texProfile_hWndSamples ) ) + { + // visible - force a client repaint + InvalidateRect( g_texProfile_hWndSamples, NULL, true ); + } + + if ( g_texProfile_hWndHistory && !IsIconic( g_texProfile_hWndHistory ) ) + { + // visible - force a client repaint + InvalidateRect( g_texProfile_hWndHistory, NULL, true ); + } +} + +//----------------------------------------------------------------------------- +// rc_SetTexProfile +// +//----------------------------------------------------------------------------- +int rc_SetTexProfile( char* commandPtr ) +{ + int i; + char* cmdToken; + int retAddr; + int retVal; + int errCode = -1; + xrProfile_t* localList; + int profileList; + int numProfiles; + + // get numProfiles + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken,"%x",&numProfiles ); + + // get profile attributes + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &profileList ); + + // get retAddr + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken,"%x",&retAddr ); + + localList = new xrProfile_t[numProfiles]; + memset( localList, 0, numProfiles*sizeof( xrProfile_t ) ); + + // get the caller's profile list + DmGetMemory( ( void* )profileList, numProfiles*sizeof( xrProfile_t ), localList, NULL ); + + g_texProfile_numCounters = numProfiles; + if ( g_texProfile_numCounters > TEXPROFILE_MAXCOUNTERS-1 ) + g_texProfile_numCounters = TEXPROFILE_MAXCOUNTERS-1; + + for ( i=0; i<g_texProfile_numCounters; i++ ) + { + // swap the structure + localList[i].color = BigDWord( localList[i].color ); + + // clear the old counter + memset( &g_texProfile_counters[i], 0, sizeof( profileCounter_t ) ); + + V_strncpy( g_texProfile_counters[i].label, localList[i].labelString, sizeof( g_texProfile_counters[i].label ) ); + g_texProfile_counters[i].color = localList[i].color; + } + + // build out the reserved last counter as total count + memset( &g_texProfile_counters[g_texProfile_numCounters], 0, sizeof( profileCounter_t ) ); + strcpy( g_texProfile_counters[g_texProfile_numCounters].label, "Total" ); + g_texProfile_counters[i].color = RGB( 255,255,255 ); + g_texProfile_numCounters++; + + // set the return code + retVal = g_texProfile_numCounters-1; + int xboxRetVal = BigDWord( retVal ); + DmSetMemory( ( void* )retAddr, sizeof( int ), &xboxRetVal, NULL ); + + DebugCommand( "0x%8.8x = SetTexProfile( 0x%8.8x, 0x%8.8x )\n", retVal, numProfiles, profileList ); + + delete [] localList; + + // success + errCode = 0; + +cleanUp: + return ( errCode ); +} + +//----------------------------------------------------------------------------- +// rc_SetTexProfileData +// +//----------------------------------------------------------------------------- +int rc_SetTexProfileData( char* commandPtr ) +{ + int i; + char* cmdToken; + int errCode = -1; + int counters; + int currentSample; + int total; + bool newPeaks; + unsigned int localCounters[TEXPROFILE_MAXCOUNTERS]; + DWORD newTime; + + // get profiles + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &counters ); + + // get the caller's profile list + if ( g_texProfile_numCounters ) + DmGetMemory( ( void* )counters, ( g_texProfile_numCounters-1 )*sizeof( int ), localCounters, NULL ); + + // timeout peaks + newTime = Sys_GetSystemTime(); + if ( newTime - g_texProfile_lastPeakTime > TEXPROFILE_SAMPLES_PEAKHOLDTIME ) + { + g_texProfile_lastPeakTime = newTime; + newPeaks = true; + } + else + newPeaks = false; + + // next sample + currentSample = g_texProfile_numSamples % TEXPROFILE_MAXSAMPLES; + g_texProfile_numSamples++; + + total = 0; + for ( i=0; i<g_texProfile_numCounters; i++ ) + { + if ( i != g_texProfile_numCounters-1 ) + { + g_texProfile_counters[i].samples[currentSample] = localCounters[i]; + total += localCounters[i]; + } + else + { + // reserved total counter + g_texProfile_counters[i].samples[currentSample] = total; + } + + if ( newPeaks || g_texProfile_counters[i].peakSample < g_texProfile_counters[i].samples[currentSample] ) + g_texProfile_counters[i].peakSample = g_texProfile_counters[i].samples[currentSample]; + } + + DebugCommand( "SetTexProfileData( 0x%8.8x )\n", counters ); + + TexProfile_UpdateWindow(); + + // success + errCode = 0; + +cleanUp: + return ( errCode ); +} + +//----------------------------------------------------------------------------- +// TexProfile_ZoomIn +// +//----------------------------------------------------------------------------- +void TexProfile_ZoomIn( int& scale, int numSteps ) +{ + scale++; + if ( scale > numSteps ) + { + scale = numSteps; + return; + } + TexProfile_UpdateWindow(); +} + +//----------------------------------------------------------------------------- +// TexProfile_ZoomOut +// +//----------------------------------------------------------------------------- +void TexProfile_ZoomOut( int& scale, int numSteps ) +{ + scale--; + if ( scale < -numSteps ) + { + scale = -numSteps; + return; + } + TexProfile_UpdateWindow(); +} + +//----------------------------------------------------------------------------- +// TexProfile_CalcScale +// +//----------------------------------------------------------------------------- +float TexProfile_CalcScale( int scale, int numSteps, float min, float max ) +{ + float t; + + // from integral scale [-numSteps..numSteps] to float scale [min..max] + t = ( float )( scale + numSteps )/( float )( 2*numSteps ); + t = min + t*( max-min ); + + return t; +} + +//----------------------------------------------------------------------------- +// TexProfileSamples_Draw +// +//----------------------------------------------------------------------------- +void TexProfileSamples_Draw( HDC hdc, RECT* clientRect ) +{ + int i; + int j; + int x; + int y; + int x0; + int y0; + int w; + float t; + float scale; + float sample; + char labelBuff[128]; + HPEN hBlackPen; + HPEN hPenOld; + HPEN hGreyPen; + HBRUSH hColoredBrush; + HBRUSH hbrushOld; + HFONT hFontOld; + RECT rect; + int currentSample; + int numTicks; + int tickWidth; + int windowWidth; + int windowHeight; + + hBlackPen = CreatePen( PS_SOLID, 1, RGB( 0,0,0 ) ); + hGreyPen = CreatePen( PS_SOLID, 1, Sys_ColorScale( g_backgroundColor, 0.85f ) ); + hPenOld = ( HPEN )SelectObject( hdc, hBlackPen ); + hFontOld = SelectFont( hdc, g_hProportionalFont ); + + SetBkColor( hdc, g_backgroundColor ); + + // zoom + scale = TexProfile_CalcScale( g_texProfile_samples_scale, TEXPROFILE_SAMPLES_SCALESTEPS, TEXPROFILE_SAMPLES_MINSCALE, TEXPROFILE_SAMPLES_MAXSCALE ); + tickWidth = ( int )( TEXPROFILE_SAMPLES_MAJORTICKWIDTH*scale ); + windowWidth = clientRect->right-clientRect->left; + windowHeight = clientRect->bottom-clientRect->top; + + numTicks = ( windowWidth-TEXPROFILE_SAMPLES_LABELWIDTH )/tickWidth + 1; + if ( numTicks < 0 ) + numTicks = 1; + + rect.left = 0; + rect.right = TEXPROFILE_SAMPLES_LABELWIDTH; + rect.top = 0; + rect.bottom = TEXPROFILE_SAMPLES_ITEMHEIGHT; + DrawText( hdc, "Name", -1, &rect, DT_LEFT ); + + // draw size ticks + x = TEXPROFILE_SAMPLES_LABELWIDTH; + y = 0; + for ( i=0; i<numTicks; i++ ) + { + // tick labels + rect.left = x-40; + rect.right = x+40; + rect.top = y; + rect.bottom = y+TEXPROFILE_SAMPLES_ITEMHEIGHT; + sprintf( labelBuff, "%dMB", i*TEXPROFILE_MAJORTICKSIZE ); + DrawText( hdc, labelBuff, -1, &rect, DT_CENTER ); + + // major ticks + x0 = x; + y0 = y + TEXPROFILE_SAMPLES_ITEMHEIGHT; + SelectObject( hdc, hBlackPen ); + MoveToEx( hdc, x0, y0, NULL ); + LineTo( hdc, x0, y0+windowHeight ); + + if ( g_texProfile_samples_tickMarks && g_texProfile_samples_scale > -TEXPROFILE_SAMPLES_SCALESTEPS ) + { + // minor ticks + x0 = x; + y0 = y + TEXPROFILE_SAMPLES_ITEMHEIGHT; + SelectObject( hdc, hGreyPen ); + for ( j=0; j<TEXPROFILE_SAMPLES_NUMMINORTICKS; j++ ) + { + x0 += tickWidth/( TEXPROFILE_SAMPLES_NUMMINORTICKS+1 ); + + MoveToEx( hdc, x0, y0, NULL ); + LineTo( hdc, x0, y0+windowHeight ); + } + } + x += tickWidth; + } + + // seperator + SelectObject( hdc, hBlackPen ); + MoveToEx( hdc, 0, TEXPROFILE_SAMPLES_ITEMHEIGHT, NULL ); + LineTo( hdc, windowWidth, TEXPROFILE_SAMPLES_ITEMHEIGHT ); + + // draw labels + x = 0; + y = TEXPROFILE_SAMPLES_ITEMHEIGHT; + for ( i=0; i<g_texProfile_numCounters; i++ ) + { + if ( !g_texProfile_counters[i].label ) + continue; + + rect.left = x; + rect.right = x+TEXPROFILE_SAMPLES_LABELWIDTH-TEXPROFILE_SAMPLES_LABELGAP; + rect.top = y; + rect.bottom = y+TEXPROFILE_SAMPLES_ITEMHEIGHT; + DrawText( hdc, g_texProfile_counters[i].label, -1, &rect, DT_VCENTER|DT_RIGHT|DT_SINGLELINE|DT_END_ELLIPSIS|DT_MODIFYSTRING ); + + // draw the under line + MoveToEx( hdc, x, y+TEXPROFILE_SAMPLES_ITEMHEIGHT, NULL ); + LineTo( hdc, x+TEXPROFILE_SAMPLES_LABELWIDTH, y+TEXPROFILE_SAMPLES_ITEMHEIGHT ); + + y += TEXPROFILE_SAMPLES_ITEMHEIGHT; + } + + // draw bars + SelectObject( hdc, hBlackPen ); + x = TEXPROFILE_SAMPLES_LABELWIDTH; + y = TEXPROFILE_SAMPLES_ITEMHEIGHT; + currentSample = g_texProfile_numSamples-1; + if ( currentSample < 0 ) + currentSample = 0; + else + currentSample %= TEXPROFILE_MAXSAMPLES; + for ( i=0; i<g_texProfile_numCounters; i++ ) + { + if ( !g_texProfile_counters[i].label ) + continue; + + hColoredBrush = CreateSolidBrush( g_texProfile_samples_colors ? g_texProfile_counters[i].color : g_backgroundColor ); + hbrushOld = ( HBRUSH )SelectObject( hdc, hColoredBrush ); + + // bar - count is in bytes, scale to major tick + t = ( float )g_texProfile_counters[i].samples[currentSample]/TEXPROFILE_MAJORTICKBYTES; + w = ( int )( t * ( float )tickWidth ); + if ( w > windowWidth ) + w = windowWidth; + x0 = x; + y0 = y + ( TEXPROFILE_SAMPLES_ITEMHEIGHT-TEXPROFILE_SAMPLES_BARHEIGHT )/2 + 1; + Rectangle( hdc, x0, y0, x0 + w, y0 + TEXPROFILE_SAMPLES_BARHEIGHT ); + + // peak + t = ( float )g_texProfile_counters[i].peakSample/TEXPROFILE_MAJORTICKBYTES; + w = ( int )( t * ( float )tickWidth ); + if ( w > windowWidth ) + w = windowWidth; + x0 = x + w; + y0 = y + TEXPROFILE_SAMPLES_ITEMHEIGHT/2 + 1; + + POINT points[4]; + points[0].x = x0; + points[0].y = y0-4; + points[1].x = x0+4; + points[1].y = y0; + points[2].x = x0; + points[2].y = y0+4; + points[3].x = x0-4; + points[3].y = y0; + Polygon( hdc, points, 4 ); + + SelectObject( hdc, hbrushOld ); + DeleteObject( hColoredBrush ); + + // draw peak sizes + sample = ( float )g_texProfile_counters[i].peakSample/1024.0f; + if ( sample >= 0.01F ) + { + sprintf( labelBuff, "%.2f MB", sample/1024.0f ); + rect.left = x0 + 8; + rect.right = x0 + 8 + 100; + rect.top = y; + rect.bottom = y + TEXPROFILE_SAMPLES_ITEMHEIGHT; + DrawText( hdc, labelBuff, -1, &rect, DT_VCENTER|DT_LEFT|DT_SINGLELINE ); + } + + y += TEXPROFILE_SAMPLES_ITEMHEIGHT; + } + + SelectObject( hdc, hFontOld ); + SelectObject( hdc, hPenOld ); + DeleteObject( hBlackPen ); + DeleteObject( hGreyPen ); +} + +//----------------------------------------------------------------------------- +// TexProfileHistory_Draw +// +//----------------------------------------------------------------------------- +void TexProfileHistory_Draw( HDC hdc, RECT* clientRect ) +{ + char labelBuff[128]; + HPEN hBlackPen; + HPEN hPenOld; + HPEN hNullPen; + HPEN hGreyPen; + HBRUSH hColoredBrush; + HBRUSH hBrushOld; + HFONT hFontOld; + int currentSample; + int numTicks; + int tickHeight; + int windowWidth; + int windowHeight; + int x; + int y; + int y0; + int i; + int j; + int h; + int numbars; + RECT rect; + float t; + float scale; + + hBlackPen = CreatePen( PS_SOLID, 1, RGB( 0,0,0 ) ); + hGreyPen = CreatePen( PS_SOLID, 1, Sys_ColorScale( g_backgroundColor, 0.85f ) ); + hNullPen = CreatePen( PS_NULL, 0, RGB( 0,0,0 ) ); + hPenOld = ( HPEN )SelectObject( hdc, hBlackPen ); + hFontOld = SelectFont( hdc, g_hProportionalFont ); + + // zoom + scale = TexProfile_CalcScale( g_texProfile_history_scale, TEXPROFILE_HISTORY_SCALESTEPS, TEXPROFILE_HISTORY_MINSCALE, TEXPROFILE_HISTORY_MAXSCALE ); + tickHeight = ( int )( TEXPROFILE_HISTORY_MAJORTICKHEIGHT*scale ); + windowWidth = clientRect->right-clientRect->left; + windowHeight = clientRect->bottom-clientRect->top; + + numTicks = windowHeight/tickHeight + 2; + if ( numTicks < 0 ) + numTicks = 1; + + SetBkColor( hdc, g_backgroundColor ); + + x = 0; + y = windowHeight; + for ( i=0; i<numTicks; i++ ) + { + // major ticks + SelectObject( hdc, hBlackPen ); + MoveToEx( hdc, 0, y, NULL ); + LineTo( hdc, windowWidth, y ); + + if ( g_texProfile_history_tickMarks && g_texProfile_history_scale > -TEXPROFILE_HISTORY_SCALESTEPS ) + { + // minor ticks + y0 = y; + SelectObject( hdc, hGreyPen ); + for ( j=0; j<TEXPROFILE_HISTORY_NUMMINORTICKS; j++ ) + { + y0 += tickHeight/( TEXPROFILE_SAMPLES_NUMMINORTICKS+1 ); + MoveToEx( hdc, 0, y0, NULL ); + LineTo( hdc, windowWidth, y0 ); + } + } + + // tick labels + if ( i ) + { + rect.left = windowWidth-50; + rect.right = windowWidth; + rect.top = y-20; + rect.bottom = y; + sprintf( labelBuff, "%dMB", i*TEXPROFILE_MAJORTICKSIZE ); + DrawText( hdc, labelBuff, -1, &rect, DT_RIGHT|DT_SINGLELINE|DT_BOTTOM ); + } + + y -= tickHeight; + } + + // vertical bars + if ( g_texProfile_numSamples ) + { + SelectObject( hdc, hNullPen ); + + numbars = windowWidth-TEXPROFILE_HISTORY_LABELWIDTH; + currentSample = g_texProfile_numSamples-1; + for ( x=numbars-1; x>=0; x-=4 ) + { + // all the counters at this sample + y = windowHeight; + for ( j=0; j<g_texProfile_numCounters-1; j++ ) + { + if ( !g_texProfile_counters[j].label ) + continue; + + t = ( float )g_texProfile_counters[j].samples[currentSample % TEXPROFILE_MAXSAMPLES]/TEXPROFILE_MAJORTICKBYTES; + h = ( int )( t * ( float )tickHeight ); + if ( h ) + { + if ( h > windowHeight ) + h = windowHeight; + + hColoredBrush = CreateSolidBrush( g_texProfile_history_colors ? g_texProfile_counters[j].color : RGB( 80,80,80 ) ); + hBrushOld = ( HBRUSH )SelectObject( hdc, hColoredBrush ); + + Rectangle( hdc, x-4, y-h, x, y+1 ); + y -= h; + + SelectObject( hdc, hBrushOld ); + DeleteObject( hColoredBrush ); + } + } + currentSample--; + if ( currentSample < 0 ) + { + // no data + break; + } + } + } + + SelectObject( hdc, hFontOld ); + SelectObject( hdc, hPenOld ); + DeleteObject( hBlackPen ); + DeleteObject( hGreyPen ); +} + +//----------------------------------------------------------------------------- +// TexProfile_WndProc +// +//----------------------------------------------------------------------------- +LRESULT CALLBACK TexProfile_WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + WORD wID = LOWORD( wParam ); + HDC hdc; + PAINTSTRUCT ps; + RECT rect; + int id; + bool bIsSamples; + bool bIsHistory; + CREATESTRUCT *createStructPtr; + bool bIsEnabled; + + // identify window + id = ( int )GetWindowLong( hwnd, GWL_USERDATA+0 ); + bIsSamples = ( id == ID_TEXPROFILE_SAMPLES ); + bIsHistory = ( id == ID_TEXPROFILE_HISTORY ); + + switch ( message ) + { + case WM_CREATE: + // set the window identifier + createStructPtr = ( CREATESTRUCT* )lParam; + SetWindowLong( hwnd, GWL_USERDATA+0, ( LONG )createStructPtr->lpCreateParams ); + + // reset peaks + g_texProfile_lastPeakTime = 0; + return 0L; + + case WM_DESTROY: + TexProfile_SaveConfig(); + + if ( bIsSamples ) + g_texProfile_hWndSamples = NULL; + else if ( bIsHistory ) + g_texProfile_hWndHistory = NULL; + + if ( VProf_GetState() == VPROF_TEXTURE || VProf_GetState() == VPROF_TEXTUREFRAME ) + { + VProf_Enable( VPROF_OFF ); + } + return 0L; + + case WM_INITMENU: + if ( bIsSamples ) + { + CheckMenuItem( ( HMENU )wParam, IDM_TEXPROFILE_TICKMARKS, MF_BYCOMMAND | ( g_texProfile_samples_tickMarks ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_TEXPROFILE_COLORS, MF_BYCOMMAND | ( g_texProfile_samples_colors ? MF_CHECKED : MF_UNCHECKED ) ); + } + else if ( bIsHistory ) + { + CheckMenuItem( ( HMENU )wParam, IDM_TEXPROFILE_TICKMARKS, MF_BYCOMMAND | ( g_texProfile_history_tickMarks ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_TEXPROFILE_COLORS, MF_BYCOMMAND | ( g_texProfile_history_colors ? MF_CHECKED : MF_UNCHECKED ) ); + } + CheckMenuItem( ( HMENU )wParam, IDM_TEXPROFILE_ENABLE, MF_BYCOMMAND | ( ( VProf_GetState() == VPROF_TEXTURE || VProf_GetState() == VPROF_TEXTUREFRAME ) ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_TEXPROFILE_CURRENTFRAME, MF_BYCOMMAND | ( g_texProfile_currentFrame ? MF_CHECKED : MF_UNCHECKED ) ); + return 0L; + + case WM_PAINT: + GetClientRect( hwnd, &rect ); + hdc = BeginPaint( hwnd, &ps ); + if ( bIsSamples ) + TexProfileSamples_Draw( hdc, &rect ); + else if ( bIsHistory ) + TexProfileHistory_Draw( hdc, &rect ); + EndPaint( hwnd, &ps ); + return 0L; + + case WM_SIZE: + // force a redraw + TexProfile_UpdateWindow(); + return 0L; + + case WM_KEYDOWN: + switch ( wParam ) + { + case VK_INSERT: + if ( bIsSamples ) + TexProfile_ZoomIn( g_texProfile_samples_scale, TEXPROFILE_SAMPLES_SCALESTEPS ); + else if ( bIsHistory ) + TexProfile_ZoomIn( g_texProfile_history_scale, TEXPROFILE_HISTORY_SCALESTEPS ); + return 0L; + + case VK_DELETE: + if ( bIsSamples ) + TexProfile_ZoomOut( g_texProfile_samples_scale, TEXPROFILE_SAMPLES_SCALESTEPS ); + else if ( bIsHistory ) + TexProfile_ZoomOut( g_texProfile_history_scale, TEXPROFILE_HISTORY_SCALESTEPS ); + return 0L; + } + break; + + case WM_COMMAND: + switch ( wID ) + { + case IDM_TEXPROFILE_TICKMARKS: + if ( bIsSamples ) + g_texProfile_samples_tickMarks ^= 1; + else if ( bIsHistory ) + g_texProfile_history_tickMarks ^= 1; + TexProfile_UpdateWindow(); + return 0L; + + case IDM_TEXPROFILE_COLORS: + if ( bIsSamples ) + g_texProfile_samples_colors ^= 1; + else if ( bIsHistory ) + g_texProfile_history_colors ^= 1; + TexProfile_UpdateWindow(); + return 0L; + + case IDM_TEXPROFILE_ZOOMIN: + if ( bIsSamples ) + TexProfile_ZoomIn( g_texProfile_samples_scale, TEXPROFILE_SAMPLES_SCALESTEPS ); + else if ( bIsHistory ) + TexProfile_ZoomIn( g_texProfile_history_scale, TEXPROFILE_HISTORY_SCALESTEPS ); + return 0L; + + case IDM_TEXPROFILE_ZOOMOUT: + if ( bIsSamples ) + TexProfile_ZoomOut( g_texProfile_samples_scale, TEXPROFILE_SAMPLES_SCALESTEPS ); + else if ( bIsHistory ) + TexProfile_ZoomOut( g_texProfile_history_scale, TEXPROFILE_HISTORY_SCALESTEPS ); + return 0L; + + case IDM_TEXPROFILE_ENABLE: + bIsEnabled = ( VProf_GetState() == VPROF_TEXTURE || VProf_GetState() == VPROF_TEXTUREFRAME ); + bIsEnabled ^= 1; + if ( !bIsEnabled ) + VProf_Enable( VPROF_OFF ); + else + { + if ( !g_texProfile_currentFrame ) + VProf_Enable( VPROF_TEXTURE ); + else + VProf_Enable( VPROF_TEXTUREFRAME ); + } + TexProfile_SetTitle(); + return 0L; + + case IDM_TEXPROFILE_CURRENTFRAME: + bIsEnabled = ( VProf_GetState() == VPROF_TEXTURE || VProf_GetState() == VPROF_TEXTUREFRAME ); + g_texProfile_currentFrame ^= 1; + if ( bIsEnabled ) + { + if ( !g_texProfile_currentFrame ) + VProf_Enable( VPROF_TEXTURE ); + else + VProf_Enable( VPROF_TEXTUREFRAME ); + } + TexProfile_SetTitle(); + return 0L; + } + break; + } + return ( DefWindowProc( hwnd, message, wParam, lParam ) ); +} + +//----------------------------------------------------------------------------- +// TexProfileHistory_Open +// +//----------------------------------------------------------------------------- +void TexProfileHistory_Open() +{ + HWND hWnd; + + if ( g_texProfile_hWndHistory ) + { + // only one profile instance + if ( IsIconic( g_texProfile_hWndHistory ) ) + ShowWindow( g_texProfile_hWndHistory, SW_RESTORE ); + SetForegroundWindow( g_texProfile_hWndHistory ); + return; + } + + if ( VProf_GetState() == VPROF_OFF ) + { + if ( !g_texProfile_currentFrame ) + VProf_Enable( VPROF_TEXTURE ); + else + VProf_Enable( VPROF_TEXTUREFRAME ); + } + + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + "TEXPROFILEHISTORYCLASS", + "", + WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX, + 0, + 0, + 600, + 500, + g_hDlgMain, + NULL, + g_hInstance, + ( void* )ID_TEXPROFILE_HISTORY ); + g_texProfile_hWndHistory = hWnd; + + TexProfile_SetTitle(); + + if ( g_texProfile_historyWindowRect.right && g_texProfile_historyWindowRect.bottom ) + MoveWindow( g_texProfile_hWndHistory, g_texProfile_historyWindowRect.left, g_texProfile_historyWindowRect.top, g_texProfile_historyWindowRect.right-g_texProfile_historyWindowRect.left, g_texProfile_historyWindowRect.bottom-g_texProfile_historyWindowRect.top, FALSE ); + ShowWindow( g_texProfile_hWndHistory, SHOW_OPENWINDOW ); +} + +//----------------------------------------------------------------------------- +// TexProfileSamples_Open +// +//----------------------------------------------------------------------------- +void TexProfileSamples_Open() +{ + HWND hWnd; + + if ( g_texProfile_hWndSamples ) + { + // only one profile instance + if ( IsIconic( g_texProfile_hWndSamples ) ) + ShowWindow( g_texProfile_hWndSamples, SW_RESTORE ); + SetForegroundWindow( g_texProfile_hWndSamples ); + return; + } + + if ( VProf_GetState() == VPROF_OFF ) + { + if ( !g_texProfile_currentFrame ) + VProf_Enable( VPROF_TEXTURE ); + else + VProf_Enable( VPROF_TEXTUREFRAME ); + } + + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + "TEXPROFILESAMPLESCLASS", + "", + WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX, + 0, + 0, + 600, + 500, + g_hDlgMain, + NULL, + g_hInstance, + ( void* )ID_TEXPROFILE_SAMPLES ); + g_texProfile_hWndSamples = hWnd; + + TexProfile_SetTitle(); + + if ( g_texProfile_samplesWindowRect.right && g_texProfile_samplesWindowRect.bottom ) + MoveWindow( g_texProfile_hWndSamples, g_texProfile_samplesWindowRect.left, g_texProfile_samplesWindowRect.top, g_texProfile_samplesWindowRect.right-g_texProfile_samplesWindowRect.left, g_texProfile_samplesWindowRect.bottom-g_texProfile_samplesWindowRect.top, FALSE ); + ShowWindow( g_texProfile_hWndSamples, SHOW_OPENWINDOW ); +} + +//----------------------------------------------------------------------------- +// TexProfile_Clear +// +//----------------------------------------------------------------------------- +void TexProfile_Clear() +{ + // clear counters and history + g_texProfile_numCounters = 0; + g_texProfile_numSamples = 0; + + TexProfile_UpdateWindow(); +} + +//----------------------------------------------------------------------------- +// TexProfile_Init +// +//----------------------------------------------------------------------------- +bool TexProfile_Init() +{ + WNDCLASS wndclass; + + // set up our window class + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = TexProfile_WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = 0; + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_APPLICATION]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = MAKEINTRESOURCE( MENU_TEXPROFILE ); + wndclass.lpszClassName = "TEXPROFILESAMPLESCLASS"; + if ( !RegisterClass( &wndclass ) ) + return false; + + // set up our window class + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = TexProfile_WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = 0; + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_APPLICATION]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = MAKEINTRESOURCE( MENU_TEXPROFILE ); + wndclass.lpszClassName = "TEXPROFILEHISTORYCLASS"; + if ( !RegisterClass( &wndclass ) ) + return false; + + TexProfile_LoadConfig(); + + return true; +}
\ No newline at end of file diff --git a/utils/xbox/vxconsole/timestamp_log.cpp b/utils/xbox/vxconsole/timestamp_log.cpp new file mode 100644 index 0000000..1cc45ef --- /dev/null +++ b/utils/xbox/vxconsole/timestamp_log.cpp @@ -0,0 +1,623 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// TIMESTAMP_LOG.CPP +// +// TimeStamp Log Display. +//=====================================================================================// +#include "vxconsole.h" + +#define ID_TIMESTAMPLOG_LISTVIEW 100 + +// column id +#define ID_TSL_TIME 0 +#define ID_TSL_DELTATIME 1 +#define ID_TSL_MEMORY 2 +#define ID_TSL_DELTAMEMORY 3 +#define ID_TSL_MESSAGE 4 + +typedef struct +{ const CHAR* name; + int width; + int subItemIndex; + CHAR nameBuff[32]; +} label_t; + +struct timeStampLogNode_t +{ + int index; + float time; + float deltaTime; + int memory; + int deltaMemory; + char timeBuff[32]; + char deltaTimeBuff[32]; + char memoryBuff[32]; + char deltaMemoryBuff[32]; + char *pMessage; + timeStampLogNode_t *pNext; +}; + +HWND g_timeStampLog_hWnd; +HWND g_timeStampLog_hWndListView; +RECT g_timeStampLog_windowRect; +timeStampLogNode_t *g_timeStampLog_pNodes; +int g_timeStampLog_sortColumn; +int g_timeStampLog_sortDescending; + +label_t g_timeStampLog_Labels[] = +{ + {"Time", 100, ID_TSL_TIME}, + {"Delta Time", 100, ID_TSL_DELTATIME}, + {"Memory", 100, ID_TSL_MEMORY}, + {"Delta Memory", 100, ID_TSL_DELTAMEMORY}, + {"Message", 400, ID_TSL_MESSAGE}, +}; + +//----------------------------------------------------------------------------- +// TimeStampLog_CompareFunc +// +//----------------------------------------------------------------------------- +int CALLBACK TimeStampLog_CompareFunc( LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort ) +{ + timeStampLogNode_t* pNodeA = ( timeStampLogNode_t* )lParam1; + timeStampLogNode_t* pNodeB = ( timeStampLogNode_t* )lParam2; + + int sort = 0; + switch ( g_timeStampLog_sortColumn ) + { + case ID_TSL_TIME: + sort = ( int )( 1000.0f*pNodeA->time - 1000.0f*pNodeB->time ); + break; + + case ID_TSL_DELTATIME: + sort = ( int )( 1000.0f*pNodeA->deltaTime - 1000.0f*pNodeB->deltaTime ); + break; + + case ID_TSL_MEMORY: + sort = pNodeA->memory - pNodeB->memory; + break; + + case ID_TSL_DELTAMEMORY: + sort = pNodeA->deltaMemory - pNodeB->deltaMemory; + break; + + case ID_TSL_MESSAGE: + sort = stricmp( pNodeA->pMessage, pNodeB->pMessage ); + break; + } + + // flip the sort order + if ( g_timeStampLog_sortDescending ) + sort *= -1; + + return ( sort ); +} + +//----------------------------------------------------------------------------- +// TimeStampLog_SortItems +// +//----------------------------------------------------------------------------- +void TimeStampLog_SortItems() +{ + LVITEM lvitem; + timeStampLogNode_t *pNode; + int i; + + if ( !g_timeStampLog_hWnd ) + { + // only sort if window is visible + return; + } + + ListView_SortItems( g_timeStampLog_hWndListView, TimeStampLog_CompareFunc, 0 ); + + memset( &lvitem, 0, sizeof( lvitem ) ); + lvitem.mask = LVIF_PARAM; + + // get each item and reset its list index + int itemCount = ListView_GetItemCount( g_timeStampLog_hWndListView ); + for ( i=0; i<itemCount; i++ ) + { + lvitem.iItem = i; + ListView_GetItem( g_timeStampLog_hWndListView, &lvitem ); + + pNode = ( timeStampLogNode_t* )lvitem.lParam; + pNode->index = i; + } + + // update list view columns with sort key + for ( i=0; i<sizeof( g_timeStampLog_Labels )/sizeof( g_timeStampLog_Labels[0] ); i++ ) + { + char symbol; + LVCOLUMN lvc; + + if ( i == g_timeStampLog_sortColumn ) + symbol = g_timeStampLog_sortDescending ? '<' : '>'; + else + symbol = ' '; + sprintf( g_timeStampLog_Labels[i].nameBuff, "%s %c", g_timeStampLog_Labels[i].name, symbol ); + + memset( &lvc, 0, sizeof( lvc ) ); + lvc.mask = LVCF_TEXT; + lvc.pszText = ( LPSTR )g_timeStampLog_Labels[i].nameBuff; + + ListView_SetColumn( g_timeStampLog_hWndListView, i, &lvc ); + } +} + +//----------------------------------------------------------------------------- +// TimeStampLog_AddViewItem +// +//----------------------------------------------------------------------------- +void TimeStampLog_AddViewItem( timeStampLogNode_t* pNode ) +{ + LVITEM lvi; + + if ( !g_timeStampLog_hWnd ) + { + // only valid if log window is visible + return; + } + + // update the text callback buffers + sprintf( pNode->timeBuff, "%2.2d:%2.2d:%2.2d:%3.3d", ( int )pNode->time/3600, ( ( int )pNode->time/60 )%60, ( int )pNode->time%60, ( int )( 1000*( pNode->time-( int )pNode->time ) )%1000 ); + sprintf( pNode->deltaTimeBuff, "%.3f", pNode->deltaTime ); + sprintf( pNode->memoryBuff, "%.2f MB", pNode->memory/( 1024.0f*1024.0f ) ); + sprintf( pNode->deltaMemoryBuff, "%d", pNode->deltaMemory ); + + int itemCount = ListView_GetItemCount( g_timeStampLog_hWndListView ); + + // setup and insert at end of list + memset( &lvi, 0, sizeof( lvi ) ); + lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_STATE; + lvi.iItem = itemCount; + lvi.iSubItem = 0; + lvi.state = 0; + lvi.stateMask = 0; + lvi.pszText = LPSTR_TEXTCALLBACK; + lvi.lParam = ( LPARAM )pNode; + + // insert + pNode->index = ListView_InsertItem( g_timeStampLog_hWndListView, &lvi ); +} + +//----------------------------------------------------------------------------- +// TimeStampLog_AddItem +// +//----------------------------------------------------------------------------- +void TimeStampLog_AddItem( float time, float deltaTime, int memory, int deltaMemory, const char* pMessage ) +{ + timeStampLogNode_t* pNode; + + // create and init + pNode = new timeStampLogNode_t; + memset( pNode, 0, sizeof( timeStampLogNode_t ) ); + + pNode->time = time; + pNode->deltaTime = deltaTime; + pNode->memory = memory; + pNode->deltaMemory = deltaMemory; + pNode->pMessage = Sys_CopyString( pMessage ? pMessage : "" ); + + // link in + pNode->pNext = g_timeStampLog_pNodes; + g_timeStampLog_pNodes = pNode; + + TimeStampLog_AddViewItem( pNode ); +} + +//----------------------------------------------------------------------------- +// TimeStampLog_Clear +// +//----------------------------------------------------------------------------- +void TimeStampLog_Clear() +{ + timeStampLogNode_t* pNode; + timeStampLogNode_t* pNextNode; + + // delete all the list view entries + if ( g_timeStampLog_hWnd ) + ListView_DeleteAllItems( g_timeStampLog_hWndListView ); + + // delete nodes in chain + pNode = g_timeStampLog_pNodes; + while ( pNode ) + { + pNextNode = pNode->pNext; + + Sys_Free( pNode->pMessage ); + delete pNode; + + pNode = pNextNode; + } + g_timeStampLog_pNodes = NULL; +} + +//----------------------------------------------------------------------------- +// TimeStampLog_SaveConfig +// +//----------------------------------------------------------------------------- +void TimeStampLog_SaveConfig() +{ + char buff[256]; + + Sys_SetRegistryInteger( "timeStampLogSortColumn", g_timeStampLog_sortColumn ); + Sys_SetRegistryInteger( "timeStampLogSortDescending", g_timeStampLog_sortDescending ); + + WINDOWPLACEMENT wp; + memset( &wp, 0, sizeof( wp ) ); + wp.length = sizeof( WINDOWPLACEMENT ); + GetWindowPlacement( g_timeStampLog_hWnd, &wp ); + g_timeStampLog_windowRect = wp.rcNormalPosition; + + sprintf( buff, "%d %d %d %d", g_timeStampLog_windowRect.left, g_timeStampLog_windowRect.top, g_timeStampLog_windowRect.right, g_timeStampLog_windowRect.bottom ); + Sys_SetRegistryString( "timeStampLogWindowRect", buff ); +} + +//----------------------------------------------------------------------------- +// TimeStampLog_LoadConfig +// +//----------------------------------------------------------------------------- +void TimeStampLog_LoadConfig() +{ + int numArgs; + char buff[256]; + + Sys_GetRegistryInteger( "timeStampLogSortColumn", ID_TSL_TIME, g_timeStampLog_sortColumn ); + Sys_GetRegistryInteger( "timeStampLogSortDescending", false, g_timeStampLog_sortDescending ); + + Sys_GetRegistryString( "timeStampLogWindowRect", buff, "", sizeof( buff ) ); + numArgs = sscanf( buff, "%d %d %d %d", &g_timeStampLog_windowRect.left, &g_timeStampLog_windowRect.top, &g_timeStampLog_windowRect.right, &g_timeStampLog_windowRect.bottom ); + if ( numArgs != 4 || g_timeStampLog_windowRect.left < 0 || g_timeStampLog_windowRect.top < 0 || g_timeStampLog_windowRect.right < 0 || g_timeStampLog_windowRect.bottom < 0 ) + memset( &g_timeStampLog_windowRect, 0, sizeof( g_timeStampLog_windowRect ) ); +} + +//----------------------------------------------------------------------------- +// TimeStampLog_SizeWindow +// +//----------------------------------------------------------------------------- +void TimeStampLog_SizeWindow( HWND hwnd, int width, int height ) +{ + if ( width==0 || height==0 ) + { + RECT rcClient; + GetClientRect( hwnd, &rcClient ); + width = rcClient.right; + height = rcClient.bottom; + } + + // position the ListView + SetWindowPos( g_timeStampLog_hWndListView, NULL, 0, 0, width, height, SWP_NOZORDER ); +} + +//----------------------------------------------------------------------------- +// TimeStampLog_Export +// +//----------------------------------------------------------------------------- +void TimeStampLog_Export() +{ + OPENFILENAME ofn; + char logFilename[MAX_PATH]; + int retval; + FILE* fp; + int i; + int count; + + memset( &ofn, 0, sizeof( ofn ) ); + ofn.lStructSize = sizeof( ofn ); + ofn.hwndOwner = g_timeStampLog_hWnd; + ofn.lpstrFile = logFilename; + ofn.lpstrFile[0] = '\0'; + ofn.nMaxFile = sizeof( logFilename ); + ofn.lpstrFilter = "Excel CSV\0*.CSV\0All Files\0*.*\0"; + ofn.nFilterIndex = 1; + ofn.lpstrFileTitle = NULL; + ofn.nMaxFileTitle = 0; + ofn.lpstrInitialDir = "c:\\"; + ofn.Flags = OFN_PATHMUSTEXIST; + + // display the open dialog box + retval = GetOpenFileName( &ofn ); + if ( !retval ) + return; + + Sys_AddExtension( ".csv", logFilename, sizeof( logFilename ) ); + + fp = fopen( logFilename, "wt+" ); + if ( !fp ) + return; + + // labels + count = ARRAYSIZE( g_timeStampLog_Labels ); + for ( i=0; i<count; i++ ) + { + fprintf( fp, "\"%s\"", g_timeStampLog_Labels[i].name ); + if ( i != count-1 ) + fprintf( fp, "," ); + } + fprintf( fp, "\n" ); + + // build a list for easy reverse traversal + CUtlVector< timeStampLogNode_t* > nodeList; + timeStampLogNode_t *pNode; + pNode = g_timeStampLog_pNodes; + while ( pNode ) + { + nodeList.AddToTail( pNode ); + pNode = pNode->pNext; + } + + // dump to the log + for ( int i=nodeList.Count()-1; i>=0; i-- ) + { + pNode = nodeList[i]; + + fprintf( fp, "\"%s\"", pNode->timeBuff ); + fprintf( fp, ",\"%s\"", pNode->deltaTimeBuff ); + fprintf( fp, ",\"%s\"", pNode->memoryBuff ); + fprintf( fp, ",\"%s\"", pNode->deltaMemoryBuff ); + fprintf( fp, ",\"%s\"", pNode->pMessage ); + fprintf( fp, "\n" ); + } + + fclose( fp ); +} + +//----------------------------------------------------------------------------- +// TimeStampLog_WndProc +// +//----------------------------------------------------------------------------- +LRESULT CALLBACK TimeStampLog_WndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam ) +{ + WORD wID = LOWORD( wParam ); + timeStampLogNode_t *pNode; + + switch ( message ) + { + case WM_CREATE: + return 0L; + + case WM_DESTROY: + TimeStampLog_SaveConfig(); + g_timeStampLog_hWnd = NULL; + return 0L; + + case WM_SIZE: + TimeStampLog_SizeWindow( hwnd, LOWORD( lParam ), HIWORD( lParam ) ); + return 0L; + + case WM_NOTIFY: + switch ( ( ( LPNMHDR )lParam )->code ) + { + case LVN_COLUMNCLICK: + NMLISTVIEW* pnmlv; + pnmlv = ( NMLISTVIEW* )lParam; + if ( g_timeStampLog_sortColumn == pnmlv->iSubItem ) + { + // user has clicked on same column - flip the sort + g_timeStampLog_sortDescending ^= 1; + } + else + { + // sort by new column + g_timeStampLog_sortColumn = pnmlv->iSubItem; + } + TimeStampLog_SortItems(); + return 0L; + + case LVN_GETDISPINFO: + NMLVDISPINFO* plvdi; + plvdi = ( NMLVDISPINFO* )lParam; + pNode = ( timeStampLogNode_t * )plvdi->item.lParam; + switch ( plvdi->item.iSubItem ) + { + case ID_TSL_TIME: + plvdi->item.pszText = pNode->timeBuff; + return 0L; + + case ID_TSL_DELTATIME: + plvdi->item.pszText = pNode->deltaTimeBuff; + return 0L; + + case ID_TSL_MEMORY: + plvdi->item.pszText = pNode->memoryBuff; + return 0L; + + case ID_TSL_DELTAMEMORY: + plvdi->item.pszText = pNode->deltaMemoryBuff; + return 0L; + + case ID_TSL_MESSAGE: + plvdi->item.pszText = pNode->pMessage; + return 0L; + + default: + break; + } + break; + } + break; + + case WM_COMMAND: + switch ( wID ) + { + case IDM_OPTIONS_CLEAR: + TimeStampLog_Clear(); + return 0L; + + case IDM_OPTIONS_EXPORT: + TimeStampLog_Export(); + return 0L; + } + break; + } + + return ( DefWindowProc( hwnd, message, wParam, lParam ) ); +} + +//----------------------------------------------------------------------------- +// TimeStampLog_Init +// +//----------------------------------------------------------------------------- +bool TimeStampLog_Init() +{ + // set up our window class + WNDCLASS wndclass; + + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = TimeStampLog_WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = 0; + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_APPLICATION]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = MAKEINTRESOURCE( MENU_TIMESTAMPLOG ); + wndclass.lpszClassName = "TIMESTAMPLOGCLASS"; + if ( !RegisterClass( &wndclass ) ) + return false; + + TimeStampLog_LoadConfig(); + + return true; +} + +//----------------------------------------------------------------------------- +// TimeStampLog_Open +// +//----------------------------------------------------------------------------- +void TimeStampLog_Open() +{ + RECT clientRect; + HWND hWnd; + int i; + timeStampLogNode_t *pNode; + + if ( g_timeStampLog_hWnd ) + { + // only one file log instance + if ( IsIconic( g_timeStampLog_hWnd ) ) + ShowWindow( g_timeStampLog_hWnd, SW_RESTORE ); + SetForegroundWindow( g_timeStampLog_hWnd ); + return; + } + + hWnd = CreateWindowEx( + WS_EX_CLIENTEDGE, + "TIMESTAMPLOGCLASS", + "TimeStamp Log", + WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_SIZEBOX|WS_MINIMIZEBOX|WS_MAXIMIZEBOX, + 0, + 0, + 600, + 300, + g_hDlgMain, + NULL, + g_hInstance, + NULL ); + g_timeStampLog_hWnd = hWnd; + + GetClientRect( g_timeStampLog_hWnd, &clientRect ); + hWnd = CreateWindow( + WC_LISTVIEW, + "", + WS_VISIBLE|WS_CHILD|LVS_REPORT, + 0, + 0, + clientRect.right-clientRect.left, + clientRect.bottom-clientRect.top, + g_timeStampLog_hWnd, + ( HMENU )ID_TIMESTAMPLOG_LISTVIEW, + g_hInstance, + NULL ); + g_timeStampLog_hWndListView = hWnd; + + // init list view columns + for ( i=0; i<sizeof( g_timeStampLog_Labels )/sizeof( g_timeStampLog_Labels[0] ); i++ ) + { + LVCOLUMN lvc; + memset( &lvc, 0, sizeof( lvc ) ); + + lvc.mask = LVCF_FMT|LVCF_WIDTH|LVCF_TEXT|LVCF_SUBITEM; + lvc.iSubItem = 0; + lvc.cx = g_timeStampLog_Labels[i].width; + lvc.fmt = LVCFMT_LEFT; + lvc.pszText = ( LPSTR )g_timeStampLog_Labels[i].name; + + ListView_InsertColumn( g_timeStampLog_hWndListView, i, &lvc ); + } + + ListView_SetBkColor( g_timeStampLog_hWndListView, g_backgroundColor ); + ListView_SetTextBkColor( g_timeStampLog_hWndListView, g_backgroundColor ); + + DWORD style = LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES|LVS_EX_HEADERDRAGDROP; + ListView_SetExtendedListViewStyleEx( g_timeStampLog_hWndListView, style, style ); + + // populate list view + pNode = g_timeStampLog_pNodes; + while ( pNode ) + { + TimeStampLog_AddViewItem( pNode ); + pNode = pNode->pNext; + } + TimeStampLog_SortItems(); + + if ( g_timeStampLog_windowRect.right && g_timeStampLog_windowRect.bottom ) + MoveWindow( g_timeStampLog_hWnd, g_timeStampLog_windowRect.left, g_timeStampLog_windowRect.top, g_timeStampLog_windowRect.right-g_timeStampLog_windowRect.left, g_timeStampLog_windowRect.bottom-g_timeStampLog_windowRect.top, FALSE ); + ShowWindow( g_timeStampLog_hWnd, SHOW_OPENWINDOW ); +} + + +//----------------------------------------------------------------------------- +// rc_TimeStampLog +// +// Sent from application with time stamp log +//----------------------------------------------------------------------------- +int rc_TimeStampLog( char* commandPtr ) +{ + char *cmdToken; + int timeStampAddr; + int retAddr; + int retVal; + int errCode = -1; + xrTimeStamp_t timeStamp; + + // get data + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &timeStampAddr ); + + // get retAddr + cmdToken = GetToken( &commandPtr ); + if ( !cmdToken[0] ) + goto cleanUp; + sscanf( cmdToken, "%x", &retAddr ); + + // get the caller's data + DmGetMemory( ( void* )timeStampAddr, sizeof( xrTimeStamp_t ), &timeStamp, NULL ); + + // swap the structure + BigFloat( &timeStamp.time, &timeStamp.time ); + BigFloat( &timeStamp.deltaTime, &timeStamp.deltaTime ); + timeStamp.memory = BigDWord( timeStamp.memory ); + timeStamp.deltaMemory = BigDWord( timeStamp.deltaMemory ); + + // add to log + TimeStampLog_AddItem( timeStamp.time, timeStamp.deltaTime, timeStamp.memory, timeStamp.deltaMemory, timeStamp.messageString ); + TimeStampLog_SortItems(); + + // return the result + retVal = 0; + int xboxRetVal = BigDWord( retVal ); + DmSetMemory( ( void* )retAddr, sizeof( int ), &xboxRetVal, NULL ); + + DebugCommand( "0x%8.8x = TimeStampLog( 0x%8.8x )\n", retVal, timeStampAddr ); + + // success + errCode = 0; + +cleanUp: + return ( errCode ); +} diff --git a/utils/xbox/vxconsole/vxconsole.cpp b/utils/xbox/vxconsole/vxconsole.cpp new file mode 100644 index 0000000..976f3da --- /dev/null +++ b/utils/xbox/vxconsole/vxconsole.cpp @@ -0,0 +1,1528 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// VXCONSOLE.CPP +// +// Valve XBox Console. +//=====================================================================================// +#include "vxconsole.h" + +HWND g_hDlgMain; +HWND g_hwndCommandCombo; +HWND g_hwndOutputWindow; +HWND g_hwndCommandHint; +WNDPROC g_hwndCommandSubclassed; +BOOL g_connectedToXBox; +BOOL g_connectedToApp; +PDMN_SESSION g_pdmnSession; +PDM_CONNECTION g_pdmConnection; +printQueue_t g_PrintQueue; +UINT_PTR g_autoConnectTimer; +BOOL g_autoConnect; +BOOL g_debugCommands; +BOOL g_captureDebugSpew; +BOOL g_captureGameSpew = TRUE; +CHAR g_xboxName[MAX_XBOXNAMELEN]; +DWORD g_xboxAddress; +HINSTANCE g_hInstance; +HICON g_hIcons[MAX_ICONS]; +HBRUSH g_hBackgroundBrush; +HFONT g_hFixedFont; +BOOL g_reboot; +char* g_rebootArgv[MAX_ARGVELEMS]; +int g_rebootArgc; +COLORREF g_backgroundColor; +TEXTMETRIC g_fixedFontMetrics; +int g_connectCount; +int g_currentIcon = -1; +HACCEL g_hAccel; +HMODULE g_hRichEdit; +DWORD g_connectedTime; +RECT g_mainWindowRect; +HFONT g_hProportionalFont; +HANDLE g_hCommandReadyEvent; +int g_currentCommandSelection; +int g_connectFailure; +int g_configID; +bool g_bSuppressBlink = false; +BOOL g_bPlayTestMode = TRUE; + +LRESULT CALLBACK Main_DlgProc( HWND, UINT, WPARAM, LPARAM ); +LRESULT CALLBACK CommandWindow_SubclassedProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam ); + +bool ParseCommandLineArg( const char *pCmdLine, const char *pKey, char *pValueBuff, int valueBuffSize ) +{ + const char* pArg = V_stristr( (char*)pCmdLine, pKey ); + if ( !pArg ) + { + return false; + } + + if ( pValueBuff ) + { + // caller wants next token + pArg += strlen( pKey ); + + int i; + for ( i=0; i<valueBuffSize; i++ ) + { + pValueBuff[i] = *pArg; + if ( *pArg == '\0' || *pArg == ' ' ) + { + break; + } + pArg++; + } + pValueBuff[i] = '\0'; + } + + return true; +} + +void MakeConfigString( const char *pString, int configID, char *pOutBuff, int outBuffSize ) +{ + if ( configID <= 0 ) + { + // as-is, undecorated + V_snprintf( pOutBuff, outBuffSize, "%s", pString ); + return; + } + + int len = strlen( pString ); + bool bAddTerminalSlash = ( len > 1 && pString[len-1] == '\\' ); + + V_snprintf( pOutBuff, outBuffSize, "%s_%d", pString, configID ); + + if ( bAddTerminalSlash ) + { + V_strncat( pOutBuff, "\\", outBuffSize ); + } +} + +//----------------------------------------------------------------------------- +// LoadConfig +// +//----------------------------------------------------------------------------- +void LoadConfig() +{ + char buff[256]; + int numArgs; + + ConfigDlg_LoadConfig(); + + // initial menu state is from persisted config + g_captureDebugSpew = g_captureDebugSpew_StartupState; + + Sys_GetRegistryString( "mainWindowRect", buff, "", sizeof( buff ) ); + numArgs = sscanf( buff, "%d %d %d %d", &g_mainWindowRect.left, &g_mainWindowRect.top, &g_mainWindowRect.right, &g_mainWindowRect.bottom ); + if ( numArgs != 4 || g_mainWindowRect.left < 0 || g_mainWindowRect.top < 0 || g_mainWindowRect.right < 0 || g_mainWindowRect.bottom < 0 ) + memset( &g_mainWindowRect, 0, sizeof( g_mainWindowRect ) ); +} + +//----------------------------------------------------------------------------- +// SaveConfig +// +//----------------------------------------------------------------------------- +void SaveConfig() +{ + char buff[256]; + + // get window placement + WINDOWPLACEMENT wp; + memset( &wp, 0, sizeof( wp ) ); + wp.length = sizeof( WINDOWPLACEMENT ); + GetWindowPlacement( g_hDlgMain, &wp ); + g_mainWindowRect = wp.rcNormalPosition; + + sprintf( buff, "%d %d %d %d", g_mainWindowRect.left, g_mainWindowRect.top, g_mainWindowRect.right, g_mainWindowRect.bottom ); + Sys_SetRegistryString( "mainWindowRect", buff ); +} + +//----------------------------------------------------------------------------- +// SetConnectionIcon +// +//----------------------------------------------------------------------------- +void SetConnectionIcon( int icon ) +{ + if ( g_currentIcon == icon ) + return; + + g_currentIcon = icon; + SetClassLongPtr( g_hDlgMain, GCLP_HICON, ( LONG_PTR )g_hIcons[icon] ); +} + +//----------------------------------------------------------------------------- +// SetMainWindowTitle +// +//----------------------------------------------------------------------------- +void SetMainWindowTitle() +{ + if ( !g_hDlgMain ) + { + return; + } + + char titleBuff[128]; + if ( !g_xboxTargetName[0] ) + { + strcpy( titleBuff, VXCONSOLE_TITLE ); + } + else + { + sprintf( titleBuff, "%s: %s", VXCONSOLE_TITLE, g_xboxTargetName ); + if ( g_configID ) + { + char configBuff[32]; + sprintf( configBuff, " (%d)", g_configID ); + V_strncat( titleBuff, configBuff, sizeof( titleBuff ) ); + } + } + SetWindowText( g_hDlgMain, titleBuff ); +} + +//----------------------------------------------------------------------------- +// DmAPI_DisplayError +// +//----------------------------------------------------------------------------- +VOID DmAPI_DisplayError( const CHAR* message, HRESULT hr ) +{ + CHAR strError[128]; + + ConsoleWindowPrintf( RGB( 255,0,0 ), "%s\n", message ); + + HRESULT hrError = DmTranslateError( hr, strError, sizeof( strError ) ); + if ( !FAILED( hrError ) && strError[0] ) + ConsoleWindowPrintf( RGB( 255,0,0 ), "Reason: '%s'\n", strError ); + else + ConsoleWindowPrintf( RGB( 255,0,0 ), "Reason: 0x%08lx\n", hr ); +} + +//----------------------------------------------------------------------------- +// DmAPI_SendCommand +// +// Send the specified string across the debugger channel to the application +//----------------------------------------------------------------------------- +HRESULT DmAPI_SendCommand( const char* strCommand, bool wait ) +{ + DWORD dwResponseLen; + CHAR strResponse[MAX_PATH]; + int retval; + bool bIgnorePingResponse; + char* ptr; + + retval = WaitForSingleObject( g_hCommandReadyEvent, wait ? INFINITE : 0 ); + if ( retval != WAIT_OBJECT_0 ) + { + // cannot send command + // some other previous command has not responded and signaled the release + // testing has shown DmSendCommand() is not re-entrant and callers get + // their responses out of sync + return XBDM_UNDEFINED; + } + + // clear the event mutex until ready + ResetEvent( g_hCommandReadyEvent ); + + bIgnorePingResponse = false; + dwResponseLen = sizeof( strResponse ); + strResponse[0] = '\0'; + + if ( strCommand[0] == '*' ) + { + // skip past internal command identifier + strCommand++; + } + else if ( !stricmp( strCommand, VXCONSOLE_COMMAND_PREFIX "!" ) ) + { + // empty ping command + // must be done as a synchronous command with a response because there + // is no way to bind an asynch response to the owner + bIgnorePingResponse = true; + } + + HRESULT hr = DmSendCommand( g_pdmConnection, strCommand, strResponse, &dwResponseLen ); + if ( !FAILED( hr ) ) + { + // success + switch ( hr ) + { + case XBDM_NOERR: + if ( !bIgnorePingResponse ) + { + // skip past possible ack prefix + ptr = strstr( strResponse, VXCONSOLE_COMMAND_ACK ); + if ( ptr ) + { + ptr += strlen( VXCONSOLE_COMMAND_ACK ); + + // ignore remote acknowledge response + if ( !stricmp( ptr, "OK" ) ) + break; + } + else + { + ptr = strResponse; + } + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "%s\n", ptr ); + } + break; + + case XBDM_MULTIRESPONSE: + // multi-line response - loop, looking for end of response + while ( 1 ) + { + dwResponseLen = sizeof( strResponse ); + + hr = DmReceiveSocketLine( g_pdmConnection, strResponse, &dwResponseLen ); + if ( FAILED( hr ) || strResponse[0] == '.' ) + break; + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "%s\n", strResponse ); + } + break; + + case XBDM_BINRESPONSE: + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Binary response - not implemented\n" ); + break; + + case XBDM_READYFORBIN: + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "Ready for binary - not implemented\n" ); + break; + + default: + ConsoleWindowPrintf( XBX_CLR_RED, "Unknown Response: ( %s ).\n", strResponse ); + break; + } + } + + SetEvent( g_hCommandReadyEvent ); + return hr; +} + +//----------------------------------------------------------------------------- +// PrintToQueue +// +// Formats the string and adds it to the print queue +//----------------------------------------------------------------------------- +void PrintToQueue( COLORREF rgb, LPCTSTR strFormat, ... ) +{ + char buffer[MAX_QUEUEDSTRINGLEN]; + + // enter critical section so we don't try to process the list + EnterCriticalSection( &g_PrintQueue.CriticalSection ); + + assert( g_PrintQueue.numMessages <= MAX_QUEUEDSTRINGS ); + + // when the queue is full, the main thread is probably blocked and not dequeing + if ( !g_captureGameSpew || g_PrintQueue.numMessages == MAX_QUEUEDSTRINGS ) + { + LeaveCriticalSection( &g_PrintQueue.CriticalSection ); + return; + } + + va_list arglist; + va_start( arglist, strFormat ); + int len = _vsnprintf( buffer, MAX_QUEUEDSTRINGLEN, strFormat, arglist ); + if ( len == -1 ) + { + buffer[sizeof(buffer)-1] = '\0'; + } + va_end( arglist ); + + // queue the message into the next slot + g_PrintQueue.pMessages[g_PrintQueue.numMessages] = Sys_CopyString( buffer ); + g_PrintQueue.aColors[g_PrintQueue.numMessages++] = rgb; + + // ensure we post a message to process the print queue + if ( g_PrintQueue.numMessages == 1 ) + PostMessage( g_hDlgMain, WM_USER, 0, 0 ); + + // the main thread can now safely process the list + LeaveCriticalSection( &g_PrintQueue.CriticalSection ); +} + +//----------------------------------------------------------------------------- +// ProcessPrintQueue +// +//----------------------------------------------------------------------------- +void ProcessPrintQueue() +{ + // enter critical section so we don't try to add anything while we're processing + EnterCriticalSection( &g_PrintQueue.CriticalSection ); + + // dequeue all entries + for ( int i = 0; i < g_PrintQueue.numMessages; i++ ) + { + ConsoleWindowPrintf( g_PrintQueue.aColors[i], "%s", g_PrintQueue.pMessages[i] ); + Sys_Free( g_PrintQueue.pMessages[i] ); + } + + g_PrintQueue.numMessages = 0; + + // now we can safely add to the list + LeaveCriticalSection( &g_PrintQueue.CriticalSection ); +} + +//----------------------------------------------------------------------------- +// ConsoleWindowPrintf +// +// Writes out a string directly to the console window +//----------------------------------------------------------------------------- +int ConsoleWindowPrintf( COLORREF rgb, LPCTSTR strFormat, ... ) +{ + int dwStrLen; + char strTemp[512]; + va_list arglist; + CHARRANGE cr = { -1, -2 }; + + if ( rgb != XBX_CLR_DEFAULT ) + { + // set whatever colors, etc. they want + CHARFORMAT cf = {0}; + cf.cbSize = sizeof( cf ); + cf.dwMask = CFM_COLOR; + cf.dwEffects = 0; + cf.crTextColor = rgb; + SendDlgItemMessage( g_hDlgMain, IDC_OUTPUT, EM_SETCHARFORMAT, SCF_SELECTION, ( LPARAM )&cf ); + } + + // Get our string to print + va_start( arglist, strFormat ); + dwStrLen = _vsnprintf( strTemp, sizeof( strTemp ), strFormat, arglist ); + va_end( arglist ); + + // Move the selection to the end + SendDlgItemMessage( g_hDlgMain, IDC_OUTPUT, EM_EXSETSEL, 0, ( LPARAM )&cr ); + + // Add the text and scroll it into view + SendDlgItemMessage( g_hDlgMain, IDC_OUTPUT, EM_REPLACESEL, 0, ( LONG )( LPSTR )strTemp ); + SendDlgItemMessage( g_hDlgMain, IDC_OUTPUT, EM_SCROLLCARET, 0, 0L ); + + if ( g_bPlayTestMode ) + { + char szLogPath[MAX_PATH]; + char szLogName[MAX_PATH]; + V_snprintf( szLogName, sizeof( szLogName ), "vxconsole_%s.log", g_xboxTargetName ); + V_ComposeFileName( g_localPath, szLogName, szLogPath, sizeof( szLogPath ) ); + FILE *fp = fopen( szLogPath, "at+" ); + if ( fp ) + { + fprintf( fp, strTemp ); + fclose( fp ); + } + } + + return dwStrLen; +} + +//----------------------------------------------------------------------------- +// ProcessCommand +// +//----------------------------------------------------------------------------- +bool ProcessCommand( const char* strCmdIn ) +{ + char strRemoteCmd[MAX_PATH + 10]; + TCHAR strCmdBak[MAX_PATH]; + char strCmd[MAX_PATH]; + char* argv[MAX_ARGVELEMS]; + BOOL isXCommand = FALSE; + BOOL isLocal = FALSE; + BOOL isRemote = FALSE; + int iIndex; + + // local copy for destructive purposes + strcpy( strCmd, strCmdIn ); + + // copy of the original command string + lstrcpyA( strCmdBak, strCmdIn ); + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "] %s\n", strCmd ); + + // parse argstring into components + int argc = CmdToArgv( strCmd, argv, MAX_ARGVELEMS ); + if ( !argc ) + { + // empty command + return true; + } + + if ( ( iIndex = ComboBox_GetCount( g_hwndCommandCombo ) ) >= MAX_COMMANDHISTORY ) + { + // Limit the history of items, purge oldest + ComboBox_DeleteString( g_hwndCommandCombo, 0 ); + } + + // add to end of list + iIndex = ComboBox_InsertItemData( g_hwndCommandCombo, -1, strCmdBak ); + ComboBox_SetCurSel( g_hwndCommandCombo, -1 ); + + // find command in local list + for ( int i=0; i<g_numLocalCommands; i++ ) + { + if ( lstrcmpiA( g_localCommands[i].strCommand, argv[0] ) ) + { + // no match + continue; + } + + isLocal = TRUE; + if ( !g_localCommands[i].pfnHandler ) + { + // no handler, remote xcommand + isXCommand = TRUE; + } + + if ( ( g_localCommands[i].flags & FN_XBOX ) && !g_connectedToXBox ) + { + // not allowed yet + ConsoleWindowPrintf( RGB( 255,0,0 ), "'%s' is not available until connected to XBox.\n", argv[0] ); + return true; + } + else if ( ( g_localCommands[i].flags & FN_APP ) && !g_connectedToApp ) + { + // not allowed yet + ConsoleWindowPrintf( RGB( 255,0,0 ), "'%s' is not available until connected to Application.\n", argv[0] ); + return true; + } + + if ( isXCommand ) + break; + + // do local command + g_localCommands[i].pfnHandler( argc, argv ); + return true; + } + + // find command in remote list + if ( !isLocal && !isXCommand && g_connectedToApp ) + { + for ( int i=0; i<g_numRemoteCommands; i++ ) + { + if ( lstrcmpiA( g_remoteCommands[i]->strCommand, argv[0] ) ) + { + // no match + continue; + } + + isRemote = TRUE; + + if ( !g_connectedToApp ) + { + // not allowed yet + ConsoleWindowPrintf( RGB( 255,0,0 ), "'%s' is not available until connected to Application.\n", argv[0] ); + return true; + } + break; + } + } + + if ( !isLocal && !isXCommand && !isRemote ) + { + if ( !g_connectedToApp || g_numRemoteCommands != 0 ) + { + // unrecognized + ConsoleWindowPrintf( RGB( 255,0,0 ), "'%s' is not a recognized command.\n", argv[0] ); + return true; + } + } + + if ( isXCommand ) + { + // send the xcommand directly + lstrcpyA( strRemoteCmd, strCmdBak ); + } + else + { + // add remote command prefix + lstrcpyA( strRemoteCmd, VXCONSOLE_COMMAND_PREFIX "!" ); + lstrcatA( strRemoteCmd, strCmdBak ); + } + + // send the command to the Xbox + HRESULT hr = DmAPI_SendCommand( strRemoteCmd, true ); + if ( FAILED( hr ) ) + { + DmAPI_DisplayError( "DmSendCommand", hr ); + return false; + } + + return TRUE; +} + +//----------------------------------------------------------------------------- +// CommandWindow_HandleKey +// +// Handle a WM_KEYDOWN in our RTF cmd window +//----------------------------------------------------------------------------- +BOOL CommandWindow_HandleKey( WPARAM wParam ) +{ + BOOL bHandled = FALSE; + int curSel; + int numItems; + + if ( wParam >= VK_F1 && wParam <= VK_F12 ) + { + if ( Bindings_TranslateKey( wParam ) ) + { + // handled + return true; + } + } + + switch ( wParam ) + { + case VK_TAB: + case VK_UP: + case VK_DOWN: + if ( IsWindowVisible( g_hwndCommandHint ) ) + { + // hint window open + char hintCmd[MAX_PATH]; + char userCmd[MAX_PATH]; + + // scroll through the hint selections + curSel = SendMessage( g_hwndCommandHint, (UINT)LB_GETCURSEL, NULL, NULL ); + SendMessage( g_hwndCommandHint, (UINT)LB_GETTEXT, (WPARAM)curSel, (LPARAM)hintCmd ); + + numItems = SendMessage( g_hwndCommandHint, (UINT)LB_GETCOUNT, NULL, NULL ); + if ( numItems < 0 ) + numItems = 0; + + if ( wParam == VK_TAB ) + { + // get command typed so far + ComboBox_GetText( g_hwndCommandCombo, userCmd, MAX_PATH ); + + // strip the auto-space off the end + int len = Q_strlen(userCmd); + if ( userCmd[len-1] == ' ' ) + { + userCmd[len-1] = '\0'; + } + + if ( !stricmp( userCmd, hintCmd ) ) + { + // cycle to next or prev command with tab or shift-tab + if ( GetKeyState(VK_SHIFT) < 0 ) + { + wParam = VK_UP; + } + else + { + wParam = VK_DOWN; + } + } + } + + // move the selection + if ( wParam == VK_UP ) + curSel--; + else if ( wParam == VK_DOWN ) + curSel++; + if ( curSel < 0 ) + curSel = numItems - 1; + else if ( curSel > numItems-1 ) + curSel = 0; + if ( curSel < 0 ) + curSel = 0; + + // set the selection and get highlighted command + SendMessage( g_hwndCommandHint, (UINT)LB_SETCURSEL, (WPARAM)curSel, NULL ); + SendMessage( g_hwndCommandHint, (UINT)LB_GETTEXT, (WPARAM)curSel, (LPARAM)hintCmd ); + + // add a space to the end for easier parameter setting + Q_strncat( hintCmd, " ", sizeof(hintCmd), 1 ); + + // replace command string + ComboBox_SetText( g_hwndCommandCombo, hintCmd ); + + // set cursor to end of command + SendMessage( g_hwndCommandCombo, (UINT)CB_SETEDITSEL, (WPARAM)0, MAKELONG( MAX_PATH,MAX_PATH ) ); + + bHandled = TRUE; + } + else + { + curSel = SendMessage( g_hwndCommandCombo, (UINT)CB_GETCURSEL, NULL, NULL ); + if ( curSel < 0 ) + { + // combo box has no selection + // override combo box behavior and set selection + numItems = SendMessage( g_hwndCommandCombo, (UINT)CB_GETCOUNT, NULL, NULL ); + if ( numItems > 0 ) + { + if ( wParam == VK_UP ) + { + // set to bottom of list + curSel = numItems-1; + } + else if ( wParam == VK_DOWN ) + { + // set to top of list + curSel = 0; + } + + SendMessage( g_hwndCommandCombo, (UINT)CB_SETCURSEL, (WPARAM)curSel, NULL ); + bHandled = TRUE; + } + } + } + break; + + case VK_RETURN: + // user hit return in the combo box + if ( ComboBox_GetDroppedState( g_hwndCommandCombo ) ) + { + ComboBox_ShowDropdown( g_hwndCommandCombo, FALSE ); + } + else + { + PostMessage( g_hDlgMain, WM_APP, 0, 0 ); + bHandled = TRUE; + } + break; + } + + return bHandled; +} + +//----------------------------------------------------------------------------- +// CommandWindow_SubclassedProc +// +//----------------------------------------------------------------------------- +LRESULT CALLBACK CommandWindow_SubclassedProc( HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam ) +{ + switch ( msg ) + { + case WM_SYSKEYDOWN: + case WM_KEYDOWN: + if ( CommandWindow_HandleKey( wParam ) ) + return 0; + break; + + case WM_CHAR: + if ( wParam == VK_RETURN ) + return 0; + break; + } + + return CallWindowProc( g_hwndCommandSubclassed, hDlg, msg, wParam, lParam ); +} + +//----------------------------------------------------------------------------- +// Main_SizeWindow +// +// Handles a WM_SIZE message by resizing all our child windows to match the main window +//----------------------------------------------------------------------------- +void Main_SizeWindow( HWND hDlg, UINT wParam, int cx, int cy ) +{ + if ( cx==0 || cy==0 ) + { + RECT rcClient; + GetClientRect( hDlg, &rcClient ); + cx = rcClient.right; + cy = rcClient.bottom; + } + + // if we're big enough, position our child windows + if ( g_hwndCommandCombo && cx > 64 && cy > 64 ) + { + RECT rcCmd; + RECT rcHint; + RECT rcOut; + + // fit the "command" combo box into our window + GetWindowRect( g_hwndCommandCombo, &rcCmd ); + ScreenToClient( hDlg, ( LPPOINT )&rcCmd ); + ScreenToClient( hDlg, ( LPPOINT )&rcCmd + 1 ); + int x = rcCmd.left; + int dx = cx - 8 - x; + int dy = rcCmd.bottom - rcCmd.top; + int y = cy - 8 - dy; + SetWindowPos( + g_hwndCommandCombo, + NULL, + x, + y, + dx, + dy, + SWP_NOZORDER ); + + // position the "hint popup" window above the "command" window + GetWindowRect( g_hwndCommandHint, &rcHint ); + ScreenToClient( g_hDlgMain, ( LPPOINT )&rcHint ); + ScreenToClient( g_hDlgMain, ( LPPOINT )&rcHint + 1 ); + SetWindowPos( + g_hwndCommandHint, + NULL, + rcCmd.left, + ( rcCmd.top - 4 ) - ( rcHint.bottom - rcHint.top + 1 ), + 0, + 0, + SWP_NOSIZE | SWP_NOZORDER ); + + // position the "Cmd" label + RECT rcStaticCmd; + HWND hStaticCmd = GetDlgItem( g_hDlgMain, IDC_LABEL ); + GetWindowRect( hStaticCmd, &rcStaticCmd ); + ScreenToClient( hDlg, ( LPPOINT )&rcStaticCmd ); + ScreenToClient( hDlg, ( LPPOINT )&rcStaticCmd + 1 ); + SetWindowPos( + hStaticCmd, + NULL, + 8, + y + ( dy - ( rcStaticCmd.bottom - rcStaticCmd.top ) ) / 2 - 1, + 0, + 0, + SWP_NOSIZE | SWP_NOZORDER ); + + // position the "output" window + GetWindowRect( g_hwndOutputWindow, &rcOut ); + ScreenToClient( hDlg, ( LPPOINT )&rcOut ); + int dwWidth = cx - rcOut.left - 8; + int dwHeight = y - rcOut.top - 8; + SetWindowPos( g_hwndOutputWindow, NULL, 0, 0, dwWidth, dwHeight, SWP_NOMOVE | SWP_NOZORDER ); + } +} + +//----------------------------------------------------------------------------- +// _SortCommands +// +//----------------------------------------------------------------------------- +int _SortCommands( const void* a, const void* b ) +{ + const char* strA = *( const char** )a; + const char* strB = *( const char** )b; + + return ( stricmp( strA, strB ) ); +} + +//----------------------------------------------------------------------------- +// EnableCommandHint +// +// Open/Close the command hint popup +//----------------------------------------------------------------------------- +void EnableCommandHint( bool enable ) +{ + int w = 0; + int h = 0; + int itemHeight; + int i; + int maxLen; + int len; + const char* cmds[256]; + int numLocalCommands; + int numRemoteCommands; + int curSel; + + if ( !enable ) + goto cleanUp; + + // get the current command + char strCmd[MAX_PATH]; + ComboBox_GetText( g_hwndCommandCombo, strCmd, MAX_PATH ); + if ( !strCmd[0] ) + { + // user has typed nothing + enable = false; + goto cleanUp; + } + + SendMessage( g_hwndCommandHint, ( UINT )LB_RESETCONTENT, NULL, NULL ); + + // get a list of possible matches + maxLen = 0; + numLocalCommands = MatchLocalCommands( strCmd, cmds, 256 ); + numRemoteCommands = MatchRemoteCommands( strCmd, cmds+numLocalCommands, 256-numLocalCommands ); + for ( i=0; i<numLocalCommands+numRemoteCommands; i++ ) + { + len = strlen( cmds[i] ); + if ( maxLen < len ) + maxLen = len; + } + if ( !maxLen ) + { + // no matches + enable = false; + goto cleanUp; + } + + // sort the list ( eschew listbox's autosorting ) + qsort( cmds, numLocalCommands+numRemoteCommands, sizeof( const char* ), _SortCommands ); + + curSel = -1; + len = strlen( strCmd ); + for ( i=0; i<numLocalCommands+numRemoteCommands; i++ ) + { + // populate the listbox + SendMessage( g_hwndCommandHint, ( UINT )LB_ADDSTRING, 0, ( LPARAM )cmds[i] ); + + // determine first best match + if ( curSel == -1 && !strnicmp( strCmd, cmds[i], len ) ) + curSel = i; + } + + if ( curSel != -1 ) + { + // set the selection to the first best string + // ensure the top string is shown ( avoids odd auto-vscroll choices ) + SendMessage( g_hwndCommandHint, ( UINT )LB_SETCURSEL, ( WPARAM )curSel, NULL ); + if ( !curSel ) + SendMessage( g_hwndCommandHint, ( UINT )LB_SETTOPINDEX, 0, NULL ); + } + + RECT rcCmd; + GetWindowRect( g_hwndCommandCombo, &rcCmd ); + ScreenToClient( g_hDlgMain, ( LPPOINT )&rcCmd ); + ScreenToClient( g_hDlgMain, ( LPPOINT )&rcCmd + 1 ); + + // clamp listbox height to client space + itemHeight = SendMessage( g_hwndCommandHint, ( UINT )LB_GETITEMHEIGHT, 0, NULL ); + if ( itemHeight <= 0 ) + { + // oops, shouldn't happen + enable = false; + goto cleanUp; + } + + h = ( numLocalCommands + numRemoteCommands )*itemHeight + 2; + if ( h > rcCmd.top - 8) + { + h = rcCmd.top - 8; + } + + // clamp listbox width + w = ( maxLen + 5 ) * g_fixedFontMetrics.tmMaxCharWidth; + + // position the "hint popup" window above the "command" window + SetWindowPos( + g_hwndCommandHint, + NULL, + rcCmd.left, + ( rcCmd.top - 4 ) - h, + w, + h, + SWP_NOZORDER ); + +cleanUp: + BOOL isVisible = IsWindowVisible( g_hwndCommandHint ); + if ( !enable && isVisible ) + ShowWindow( g_hwndCommandHint, SW_HIDE ); + else if ( enable && !isVisible ) + ShowWindow( g_hwndCommandHint, SW_SHOWNA ); +} + +//----------------------------------------------------------------------------- +// Main_DlgProc +// +//----------------------------------------------------------------------------- +LRESULT CALLBACK Main_DlgProc( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam ) +{ + WORD wID = LOWORD( wParam ); + BOOL isConnect; + + switch ( message ) + { + case WM_APP: + // user has pressed enter + // take the string from the command window and process it + // extra room for \r\n + char strCmd[MAX_PATH + 3]; + ComboBox_GetText( g_hwndCommandCombo, strCmd, MAX_PATH ); + ProcessCommand( strCmd ); + ComboBox_SetText( g_hwndCommandCombo, "" ); + EnableCommandHint( false ); + break; + + case WM_USER: + ProcessPrintQueue(); + break; + + case WM_TIMER: + // Don't do auto-connect stuff while the Assert dialog is up + // (it uses a synchronous command, so calling 'Dm' funcs here can cause a lockup) + if ( !g_AssertDialogActive ) + { + if ( wID == TIMERID_AUTOCONNECT ) + { + AutoConnectTimerProc( hDlg, TIMERID_AUTOCONNECT ); + return 0L; + } + } + break; + + case WM_CTLCOLORLISTBOX: + case WM_CTLCOLOREDIT: + SetBkColor( ( HDC )wParam,g_backgroundColor ); + return ( BOOL )g_hBackgroundBrush; + + case WM_SIZE: + Main_SizeWindow( hDlg, wParam, LOWORD( lParam ), HIWORD( lParam ) ); + break; + + case WM_SYSCOMMAND: + if ( wID == SC_CLOSE ) + { + PostMessage( hDlg, WM_CLOSE, 0, 0 ); + return 0L; + } + break; + + case WM_CLOSE: + // disconnect before closing + lc_disconnect( 0, NULL ); + + SaveConfig(); + DestroyWindow( hDlg ); + break; + + case WM_DESTROY: + SubclassWindow( g_hwndCommandCombo, g_hwndCommandSubclassed ); + PostQuitMessage( 0 ); + return 0L; + + case WM_INITMENU: + isConnect = g_connectedToXBox || g_connectedToApp; + CheckMenuItem( ( HMENU )wParam, IDM_AUTOCONNECT, MF_BYCOMMAND | ( g_autoConnect ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_CAPTUREGAMESPEW, MF_BYCOMMAND | ( g_captureGameSpew ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_CAPTUREDEBUGSPEW, MF_BYCOMMAND | ( g_captureDebugSpew ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_DEBUGCOMMANDS, MF_BYCOMMAND | ( g_debugCommands ? MF_CHECKED : MF_UNCHECKED ) ); + CheckMenuItem( ( HMENU )wParam, IDM_PLAYTESTMODE, MF_BYCOMMAND | ( g_bPlayTestMode ? MF_CHECKED : MF_UNCHECKED ) ); + EnableMenuItem( ( HMENU )wParam, IDM_SYNCFILES, MF_BYCOMMAND | ( g_connectedToXBox ? MF_ENABLED : MF_GRAYED ) ); + EnableMenuItem( ( HMENU )wParam, IDM_SYNCINSTALL, MF_BYCOMMAND | ( g_connectedToXBox ? MF_ENABLED : MF_GRAYED ) ); + return 0L; + + case WM_COMMAND: + switch ( wID ) + { + case IDC_COMMAND: + switch ( HIWORD( wParam ) ) + { + case CBN_EDITCHANGE: + case CBN_SETFOCUS: + EnableCommandHint( true ); + break; + + case CBN_KILLFOCUS: + EnableCommandHint( false ); + break; + } + break; + + case IDM_CONFIG: + ConfigDlg_Open(); + return 0L; + + case IDM_CAPTUREGAMESPEW: + g_captureGameSpew ^= 1; + return 0L; + + case IDM_CAPTUREDEBUGSPEW: + g_captureDebugSpew ^= 1; + return 0L; + + case IDM_DEBUGCOMMANDS: + g_debugCommands ^= 1; + return 0L; + + case IDM_BUG: + BugDlg_Open(); + return 0L; + + case IDM_MEMORYDUMP: + ShowMemDump_Open(); + return 0L; + + case IDM_TIMESTAMPLOG: + TimeStampLog_Open(); + return 0L; + + case IDM_SYNCFILES: + SyncFilesDlg_Open(); + return 0L; + + case IDM_SYNCINSTALL: + InstallDlg_Open(); + return 0L; + + case IDM_EXCLUDEPATHS: + ExcludePathsDlg_Open(); + return 0L; + + case IDM_CPU_SAMPLES: + CpuProfileSamples_Open(); + return 0L; + + case IDM_CPU_HISTORY: + CpuProfileHistory_Open(); + return 0L; + + case IDM_D3D_SAMPLES: + TexProfileSamples_Open(); + return 0L; + + case IDM_D3D_HISTORY: + TexProfileHistory_Open(); + return 0L; + + case IDM_SHOWMEMORYUSAGE: + MemProfile_Open(); + return 0L; + + case IDM_PLAYTESTMODE: + g_bPlayTestMode ^= 1; + return 0L; + + case IDM_SHOWRESOURCES_TEXTURES: + ShowTextures_Open(); + return 0L; + + case IDM_SHOWRESOURCES_MATERIALS: + ShowMaterials_Open(); + return 0L; + + case IDM_SHOWRESOURCES_SOUNDS: + ShowSounds_Open(); + return 0L; + + case IDM_SHOWRESOURCES_MODELS: + NotImplementedYet(); + return 0L; + + case IDM_AUTOCONNECT: + if ( g_connectedToXBox || g_connectedToApp || g_autoConnect ) + lc_disconnect( 0, NULL ); + else + lc_autoConnect( 0, NULL ); + return 0L; + + case IDM_BINDINGS_EDIT: + Bindings_Open(); + return 0L; + + case IDM_BINDINGS_BIND1: + case IDM_BINDINGS_BIND2: + case IDM_BINDINGS_BIND3: + case IDM_BINDINGS_BIND4: + case IDM_BINDINGS_BIND5: + case IDM_BINDINGS_BIND6: + case IDM_BINDINGS_BIND7: + case IDM_BINDINGS_BIND8: + case IDM_BINDINGS_BIND9: + case IDM_BINDINGS_BIND10: + case IDM_BINDINGS_BIND11: + case IDM_BINDINGS_BIND12: + Bindings_MenuSelection( wID ); + return 0L; + + case IDM_EXIT: + PostMessage( hDlg, WM_CLOSE, 0, 0 ); + return 0L; + } + break; + } + + return ( DefDlgProc( hDlg, message, wParam, lParam ) ); +} + +//----------------------------------------------------------------------------- +// CmdToArgv +// +// Parses a string into argv and return # of args. +//----------------------------------------------------------------------------- +int CmdToArgv( char* str, char* argv[], int maxargs ) +{ + int argc = 0; + int argcT = 0; + char* strNil = str + lstrlenA( str ); + + while ( argcT < maxargs ) + { + // Eat whitespace + while ( *str && ( *str==' ' ) ) + str++; + + if ( !*str ) + { + argv[argcT++] = strNil; + } + else + { + // Find the end of this arg + char chEnd = ( *str == '"' || *str == '\'' ) ? *str++ : ' '; + char* strArgEnd = str; + while ( *strArgEnd && ( *strArgEnd != chEnd ) ) + strArgEnd++; + + // Record this argument + argv[argcT++] = str; + argc = argcT; + + // Move strArg to the next argument ( or not, if we hit the end ) + str = *strArgEnd ? strArgEnd + 1 : strArgEnd; + *strArgEnd = 0; + } + } + + return argc; +} + +//----------------------------------------------------------------------------- +// CreateCommandHint +// +//----------------------------------------------------------------------------- +void CreateCommandHint() +{ + // create the "hint" popup + g_hwndCommandHint = CreateWindowEx( + WS_EX_NOPARENTNOTIFY, + "LISTBOX", + "", + WS_BORDER|WS_CHILD|LBS_HASSTRINGS|WS_VSCROLL, + 0, 0, 100, 0, + g_hDlgMain, + ( HMENU )IDC_COMMANDHINT, + g_hInstance, + NULL ); + + // force the popup to head of z-order + // to draw over all other children + BringWindowToTop( g_hwndCommandHint ); + + // set font + SendDlgItemMessage( g_hDlgMain, IDC_COMMANDHINT, WM_SETFONT, ( WPARAM )g_hFixedFont, TRUE ); +} + +//----------------------------------------------------------------------------- +// CreateResources +// +//----------------------------------------------------------------------------- +bool CreateResources() +{ + LOGFONT lf; + HFONT hFontOld; + HDC hDC; + int i; + + // pull in common controls + INITCOMMONCONTROLSEX initCommon; + initCommon.dwSize = sizeof( INITCOMMONCONTROLSEX ); + initCommon.dwICC = ICC_LISTVIEW_CLASSES|ICC_USEREX_CLASSES; + if ( !InitCommonControlsEx( &initCommon ) ) + return false; + + // pull in rich edit controls + g_hRichEdit = LoadLibrary( "Riched32.dll" ); + if ( !g_hRichEdit ) + return false; + + g_backgroundColor = XBX_CLR_LTGREY; + g_hBackgroundBrush = CreateSolidBrush( g_backgroundColor ); + + // get icons + g_hIcons[ICON_APPLICATION] = LoadIcon( g_hInstance, MAKEINTRESOURCE( IDI_VXCONSOLE ) ); + g_hIcons[ICON_DISCONNECTED] = LoadIcon( g_hInstance, MAKEINTRESOURCE( IDI_DISCONNECTED ) ); + g_hIcons[ICON_CONNECTED_XBOX] = LoadIcon( g_hInstance, MAKEINTRESOURCE( IDI_CONNECT1_ON ) ); + g_hIcons[ICON_CONNECTED_APP0] = LoadIcon( g_hInstance, MAKEINTRESOURCE( IDI_CONNECT2_OFF ) ); + g_hIcons[ICON_CONNECTED_APP1] = LoadIcon( g_hInstance, MAKEINTRESOURCE( IDI_CONNECT2_ON ) ); + for ( i=0; i<MAX_ICONS; i++ ) + { + if ( !g_hIcons[i] ) + return false; + } + + // get the font feight + hDC = GetWindowDC( NULL ); + int nHeight = -MulDiv( VXCONSOLE_FONTSIZE, GetDeviceCaps( hDC, LOGPIXELSY ), 72 ); + ReleaseDC( NULL, hDC ); + + // create fixed font + memset( &lf, 0, sizeof( LOGFONT ) ); + lf.lfHeight = nHeight; + lf.lfWeight = 400; + strcpy( lf.lfFaceName, VXCONSOLE_FONT ); + g_hFixedFont = CreateFontIndirect( &lf ); + if ( !g_hFixedFont ) + return false; + + // create proportional font + memset( &lf, 0, sizeof( LOGFONT ) ); + lf.lfHeight = -11; + lf.lfWeight = 400; + strcpy( lf.lfFaceName, "Tahoma" ); + g_hProportionalFont = CreateFontIndirect( &lf ); + if ( !g_hProportionalFont ) + return false; + + // get the font metrics + hDC = GetWindowDC( NULL ); + hFontOld = ( HFONT )SelectObject( hDC, g_hFixedFont ); + GetTextMetrics( hDC, &g_fixedFontMetrics ); + SelectObject( hDC, hFontOld ); + ReleaseDC( NULL, hDC ); + + return true; +} + +//----------------------------------------------------------------------------- +// Shutdown +// +// Free all resources +//----------------------------------------------------------------------------- +void Shutdown() +{ + BugReporter_FreeInterfaces(); + + if ( g_PrintQueue.bInit ) + { + DeleteCriticalSection( &g_PrintQueue.CriticalSection ); + g_PrintQueue.bInit = false; + } + + if ( g_hCommandReadyEvent ) + { + CloseHandle( g_hCommandReadyEvent ); + g_hCommandReadyEvent = 0; + } + + if ( g_hRichEdit ) + { + FreeLibrary( g_hRichEdit ); + g_hRichEdit = 0; + } + + if ( g_hBackgroundBrush ) + { + DeleteObject( g_hBackgroundBrush ); + g_hBackgroundBrush = 0; + } + + if ( g_hFixedFont ) + { + DeleteObject( g_hFixedFont ); + g_hFixedFont = 0; + } + + if ( g_hProportionalFont ) + { + DeleteObject( g_hProportionalFont ); + g_hProportionalFont = 0; + } +} + +//----------------------------------------------------------------------------- +// Startup +// +//----------------------------------------------------------------------------- +bool Startup() +{ + // Load the xenon debugging dll (xbdm.dll) manually due to its absence from system path + const char *pPath = getenv( "path" ); + const char *pXEDKDir = getenv( "xedk" ); + if ( !pXEDKDir ) + pXEDKDir = ""; + + int len = strlen( pPath ) + strlen( pXEDKDir ) + 256; + char *pNewPath = (char*)_alloca( len ); + sprintf( pNewPath, "path=%s;%s\\bin\\win32", pPath, pXEDKDir ); + _putenv( pNewPath ); + + HMODULE hXBDM = LoadLibrary( TEXT( "xbdm.dll" ) ); + if ( !hXBDM ) + { + if ( pXEDKDir[0] ) + Sys_Error( "Couldn't load xbdm.dll" ); + else + Sys_Error( "Couldn't load xbdm.dll\nXEDK environment variable not set." ); + } + + LoadConfig(); + + if ( !CreateResources() ) + return false; + + // set up our print queue + InitializeCriticalSection( &g_PrintQueue.CriticalSection ); + g_PrintQueue.bInit = true; + + // manual reset, initially signaled + g_hCommandReadyEvent = CreateEvent( NULL, TRUE, TRUE, NULL ); + + // set up our window class + WNDCLASS wndclass; + memset( &wndclass, 0, sizeof( wndclass ) ); + wndclass.style = 0; + wndclass.lpfnWndProc = Main_DlgProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = VXCONSOLE_WINDOWBYTES; + wndclass.hInstance = g_hInstance; + wndclass.hIcon = g_hIcons[ICON_DISCONNECTED]; + wndclass.hCursor = LoadCursor( NULL, IDC_ARROW ); + wndclass.hbrBackground = g_hBackgroundBrush; + wndclass.lpszMenuName = MAKEINTRESOURCE( MENU_VXCONSOLE ); + wndclass.lpszClassName = VXCONSOLE_CLASSNAME; + if ( !RegisterClass( &wndclass ) ) + return false; + + g_hAccel = LoadAccelerators( g_hInstance, MAKEINTRESOURCE( IDR_MAIN_ACCEL ) ); + if ( !g_hAccel ) + return false; + + // Create our main dialog + g_hDlgMain = CreateDialog( g_hInstance, MAKEINTRESOURCE( IDD_VXCONSOLE ), 0, NULL ); + if ( !g_hDlgMain ) + return false; + SetWindowLong( g_hDlgMain, VXCONSOLE_CONFIGID, g_configID ); + + if ( !BugDlg_Init() ) + return false; + + if ( !CpuProfile_Init() ) + return false; + + if ( !TexProfile_Init() ) + return false; + + if ( !MemProfile_Init() ) + return false; + + if ( !Bindings_Init() ) + return false; + + if ( !SyncFilesDlg_Init() ) + return false; + + if ( !ShowMaterials_Init() ) + return false; + + if ( !ShowTextures_Init() ) + return false; + + if ( !ShowSounds_Init() ) + return false; + + if ( !ShowMemDump_Init() ) + return false; + + if ( !TimeStampLog_Init() ) + return false; + + if ( !ExcludePathsDlg_Init() ) + return false; + + g_hwndOutputWindow = GetDlgItem( g_hDlgMain, IDC_OUTPUT ); + g_hwndCommandCombo = GetDlgItem( g_hDlgMain, IDC_COMMAND ); + + CreateCommandHint(); + + // subclass our dropdown command listbox to handle return key + g_hwndCommandSubclassed = SubclassWindow( GetWindow( g_hwndCommandCombo, GW_CHILD ), CommandWindow_SubclassedProc ); + + // Change the font type of the output window to courier + CHARFORMAT cf; + cf.cbSize = sizeof( CHARFORMAT ); + SendMessage( g_hwndOutputWindow, EM_GETCHARFORMAT, 0, ( LPARAM )&cf ); + cf.dwMask &= ~CFM_COLOR; + cf.yHeight = VXCONSOLE_FONTSIZE*20; + lstrcpyA( cf.szFaceName, VXCONSOLE_FONT ); + SendMessage( g_hwndOutputWindow, EM_SETCHARFORMAT, SCF_ALL, ( LPARAM )&cf ); + SendMessage( g_hwndOutputWindow, EM_SETBKGNDCOLOR, 0, g_backgroundColor ); + + // ensure the output window adheres to its z ordering + LONG style = GetWindowLong( g_hwndOutputWindow, GWL_STYLE ); + style |= WS_CLIPSIBLINGS; + SetWindowLong( g_hwndOutputWindow, GWL_STYLE, style ); + + // change the font of the command and its hint window to courier + SendDlgItemMessage( g_hDlgMain, IDC_COMMAND, WM_SETFONT, ( WPARAM )g_hFixedFont, TRUE ); + + // set the window title + SetMainWindowTitle(); + + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "VXConsole %s [%s Build: %s %s] [Protocol: %d]\n", VXCONSOLE_VERSION, VXCONSOLE_BUILDTYPE, __DATE__, __TIME__, VXCONSOLE_PROTOCOL_VERSION ); + ConsoleWindowPrintf( XBX_CLR_DEFAULT, "type '*help' for list of commands...\n\n" ); + + g_currentIcon = -1; + SetConnectionIcon( ICON_DISCONNECTED ); + + if ( g_alwaysAutoConnect) + { + // user wants to auto-connect at startup + lc_autoConnect( 0, NULL ); + } + + if ( g_mainWindowRect.right && g_mainWindowRect.bottom ) + MoveWindow( g_hDlgMain, g_mainWindowRect.left, g_mainWindowRect.top, g_mainWindowRect.right-g_mainWindowRect.left, g_mainWindowRect.bottom-g_mainWindowRect.top, FALSE ); + + // ready for display + int cmdShow = SW_SHOWNORMAL; + if ( g_startMinimized ) + cmdShow = SW_SHOWMINIMIZED; + ShowWindow( g_hDlgMain, cmdShow ); + + // success + return true; +} + +//----------------------------------------------------------------------------- +// WinMain +// +// Entry point for program +//----------------------------------------------------------------------------- +int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR pCmdLine, int nCmdShow ) +{ + bool error = true; + MSG msg = {0}; + + g_hInstance = hInstance; + + g_bSuppressBlink = ParseCommandLineArg( pCmdLine, "-noblink", NULL, 0 ); + + // optional -config <ID> can specify a specific configuration + char buff[128]; + buff[0] = '\0'; + ParseCommandLineArg( pCmdLine, "-config ", buff, sizeof( buff ) ); + g_configID = atoi( buff ); + + MakeConfigString( VXCONSOLE_REGISTRY, g_configID, buff, sizeof( buff ) ); + Sys_SetRegistryPrefix( buff ); + + HWND hwnd = FindWindow( VXCONSOLE_CLASSNAME, NULL ); + if ( hwnd && GetWindowLong( hwnd, VXCONSOLE_CONFIGID ) == g_configID ) + { + // single instance only + // bring other version to foreground + if ( IsIconic( hwnd ) ) + ShowWindow( hwnd, SW_RESTORE ); + SetForegroundWindow( hwnd ); + return ( FALSE ); + } + + if ( !Startup() ) + goto cleanUp; + + // message pump + while ( GetMessage( &msg, NULL, 0, 0 ) ) + { + if ( !TranslateAccelerator( g_hDlgMain, g_hAccel, &msg ) ) + { + TranslateMessage( &msg ); + DispatchMessage( &msg ); + } + } + + // no-error, end of app + error = false; + +cleanUp: + if ( error ) + { + char str[255]; + FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), 0, str, 255, NULL ); + MessageBox( NULL, str, NULL, MB_OK ); + } + + Shutdown(); + + return ( msg.wParam ); +} + + diff --git a/utils/xbox/vxconsole/vxconsole.h b/utils/xbox/vxconsole/vxconsole.h new file mode 100644 index 0000000..6ff1afc --- /dev/null +++ b/utils/xbox/vxconsole/vxconsole.h @@ -0,0 +1,479 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// VXCONSOLE.H +// +// Master Header. +//=====================================================================================// +#pragma once + +#include "tier0/platform.h" + +#include <winsock2.h> +#include <windows.h> +#include <windowsx.h> +#include <commctrl.h> +#include <stdio.h> +#include <stdarg.h> +#include <io.h> +#include <fcntl.h> +#include <string.h> +#include <share.h> +#include <richedit.h> +#include <assert.h> +#include <xbdm.h> +#include <time.h> +#include <sys/stat.h> + +#include "resource.h" +#include "assert_resource.h" +#include "sys_utils.h" +#include "sys_scriptlib.h" +#include "bugreporter/bugreporter.h" +#include "jpeglib/jpeglib.h" +#include "UtlBuffer.h" +#include "strtools.h" +#include "xbox/xbox_vxconsole.h" +#include "UtlRBTree.h" +#include "UtlSymbol.h" +#include "UtlVector.h" +#include "UtlString.h" + +#define VXCONSOLE_VERSION "1.2" +#define VXCONSOLE_CLASSNAME "VXConsole" +#define VXCONSOLE_TITLE "VXConsole" +#define VXCONSOLE_FONT "Courier" +#define VXCONSOLE_FONTSIZE 10 +#define VXCONSOLE_MAGIC "3\\" +#define VXCONSOLE_REGISTRY "HKEY_CURRENT_USER\\Software\\VXConsole\\" VXCONSOLE_MAGIC +#ifdef _DEBUG +#define VXCONSOLE_BUILDTYPE "Debug" +#else +#define VXCONSOLE_BUILDTYPE "Release" +#endif + +#define VXCONSOLE_WINDOWBYTES ( DLGWINDOWEXTRA + 4 ) +#define VXCONSOLE_CONFIGID ( VXCONSOLE_WINDOWBYTES - 4 ) + +#define MAX_QUEUEDSTRINGS 4096 +#define MAX_QUEUEDSTRINGLEN 512 +#define MAX_RCMDNAMELEN 32 +#define MAX_RCMDS 4096 +#define MAX_TOKENCHARS 256 +#define MAX_XBOXNAMELEN 64 +#define MAX_ARGVELEMS 20 +#define MAX_COMMANDHISTORY 25 + +#define TIMERID_AUTOCONNECT 0x1000 +#define TIMERID_MEMPROFILE 0x1001 + +#define IDC_COMMANDHINT 666 + +#define XBX_CLR_RED ( RGB( 255,0,0 ) ) +#define XBX_CLR_GREEN ( RGB( 0,255,0 ) ) +#define XBX_CLR_WHITE ( RGB( 255,255,255 ) ) +#define XBX_CLR_BLACK ( RGB( 0,0,0 ) ) +#define XBX_CLR_BLUE ( RGB( 0,0,255 ) ) +#define XBX_CLR_YELLOW ( RGB( 255,255,0 ) ) +#define XBX_CLR_LTGREY ( RGB( 180,180,180 ) ) +#define XBX_CLR_DEFAULT XBX_CLR_BLACK + +// The command prefix that is prepended to all communication between the Xbox +// app and the debug console app +#define VXCONSOLE_PRINT_PREFIX "XPRT" +#define VXCONSOLE_COMMAND_PREFIX "XCMD" +#define VXCONSOLE_COMMAND_ACK "XACK" +#define VXCONSOLE_COLOR_PREFIX "XCLR" + +#define ICON_APPLICATION 0 +#define ICON_DISCONNECTED 1 +#define ICON_CONNECTED_XBOX 2 +#define ICON_CONNECTED_APP0 3 +#define ICON_CONNECTED_APP1 4 +#define MAX_ICONS 5 + +typedef BOOL ( *cmdHandler_t )( int argc, char* argv[] ); + +#define IDM_BINDINGS 50000 +#define IDM_BINDINGS_EDIT ( IDM_BINDINGS+1 ) +#define IDM_BINDINGS_BIND1 ( IDM_BINDINGS+2 ) +#define IDM_BINDINGS_BIND2 ( IDM_BINDINGS+3 ) +#define IDM_BINDINGS_BIND3 ( IDM_BINDINGS+4 ) +#define IDM_BINDINGS_BIND4 ( IDM_BINDINGS+5 ) +#define IDM_BINDINGS_BIND5 ( IDM_BINDINGS+6 ) +#define IDM_BINDINGS_BIND6 ( IDM_BINDINGS+7 ) +#define IDM_BINDINGS_BIND7 ( IDM_BINDINGS+8 ) +#define IDM_BINDINGS_BIND8 ( IDM_BINDINGS+9 ) +#define IDM_BINDINGS_BIND9 ( IDM_BINDINGS+10 ) +#define IDM_BINDINGS_BIND10 ( IDM_BINDINGS+11 ) +#define IDM_BINDINGS_BIND11 ( IDM_BINDINGS+12 ) +#define IDM_BINDINGS_BIND12 ( IDM_BINDINGS+13 ) +#define MAX_BINDINGS ( VK_F12-VK_F1+1 ) + +// file serving +#define FSERVE_LOCALONLY 0 +#define FSERVE_REMOTEONLY 1 +#define FSERVE_LOCALFIRST 2 + +// file sync +#define FSYNC_OFF 0x00000000 +#define FSYNC_ALWAYS 0x00000001 +#define FSYNC_IFNEWER 0x00000002 +#define FSYNC_TYPEMASK 0x0000000F +#define FSYNC_ANDEXISTSONTARGET 0x80000000 + +// track function invocations +typedef enum +{ + FL_INVALID, + FL_STAT, + FL_FOPEN, + FL_FSEEK, + FL_FTELL, + FL_FREAD, + FL_FWRITE, + FL_FCLOSE, + FL_FEOF, + FL_FERROR, + FL_FFLUSH, + FL_FGETS, + FL_MAXFUNCTIONCOUNTS, +} fileLogFunctions_e; + +typedef enum +{ + VPROF_OFF = 0, + VPROF_CPU, + VPROF_TEXTURE, + VPROF_TEXTUREFRAME, +} vprofState_e; + +// funtion command types +#define FN_CONSOLE 0x00 // command runs at console +#define FN_XBOX 0x01 // command requires xbox +#define FN_APP 0x02 // command requires application + +// shorthand +#define FA_NORMAL FILE_ATTRIBUTE_NORMAL +#define FA_DIRECTORY FILE_ATTRIBUTE_DIRECTORY +#define FA_READONLY FILE_ATTRIBUTE_READONLY + +typedef struct +{ + const CHAR* strCommand; + int flags; + cmdHandler_t pfnHandler; + const CHAR* strHelp; +} localCommand_t; + +typedef struct +{ + char* strCommand; + char* strHelp; +} remoteCommand_t; + +typedef struct +{ + CRITICAL_SECTION CriticalSection; + int numMessages; + bool bInit; + COLORREF aColors[MAX_QUEUEDSTRINGS]; + CHAR *pMessages[MAX_QUEUEDSTRINGS]; +} printQueue_t; + +class CProgress +{ +public: + CProgress(); + ~CProgress(); + void Open( const char* title, bool canCancel, bool bHasMeter ); + void SetStatus( const char *line1, const char *line2, const char *line3 ); + void SetMeter( int currentPos, int range ); + bool IsCancel(); + HWND m_hWnd; + HWND m_hWndStatus1; + HWND m_hWndStatus2; + HWND m_hWndStatus3; + HWND m_hWndPercent; + HWND m_hWndMeter; + HWND m_hWndCancel; + bool m_bCancelPressed; + int m_range; + +private: + void Update(); +}; + +typedef struct fileNode_s +{ + char *filename; + FILETIME creationTime; + FILETIME changeTime; + DWORD sizeHigh; + DWORD sizeLow; + DWORD attributes; + int level; + struct fileNode_s *nextPtr; + bool needsUpdate; +} +fileNode_t; + +//----------------------------------------------------------------------------- +// FILEIO.CPP +//----------------------------------------------------------------------------- +extern void RemoteToLocalFilename( const char* inFilename, char* outFilename, int outSize ); +extern void RemoteToTargetFilename( const char* inFilename, char* outFilename, int outSize ); +extern void FreeTargetFileList( fileNode_t* pFileList ); +extern bool GetTargetFileList_r( char* targetPath, bool recurse, int attributes, int level, fileNode_t** pFileList ); +extern char *SystemTimeToString( SYSTEMTIME *systemTime, char *buffer, int bufferSize ); +extern bool CreateTargetPath( const char *pTargetFilename ); + +//----------------------------------------------------------------------------- +// BINDINGS.CPP +//----------------------------------------------------------------------------- +extern bool Bindings_TranslateKey( int vkKeyCode ); +extern bool Bindings_MenuSelection( int wID ); +extern void Bindings_LoadConfig(); +extern void Bindings_SaveConfig(); +extern void Bindings_Open(); +extern bool Bindings_Init(); + +//----------------------------------------------------------------------------- +// COMMON.CPP +//----------------------------------------------------------------------------- + +//----------------------------------------------------------------------------- +// VXCONSOLE.CPP +//----------------------------------------------------------------------------- +extern void SetConnectionIcon( int icon ); +extern void PrintToQueue( COLORREF color, const CHAR* strFormat, ... ); +extern void ProcessPrintQueue(); +extern void DmAPI_DisplayError( const char* strApiName, HRESULT hr ); +extern int ConsoleWindowPrintf( COLORREF rgb, LPCTSTR lpFmt, ... ); +extern int CmdToArgv( char* str, char* argv[], int maxargs ); +extern char* GetToken( char** tokenStreamPtr ); +extern void DebugCommand( const char* strFormat, ... ); +extern bool ProcessCommand( const char* strCmd ); +extern HRESULT DmAPI_SendCommand( const char* strCommand, bool wait ); +extern void NotImplementedYet(); +extern void SetMainWindowTitle(); +extern HWND g_hDlgMain; +extern HWND g_hwndOutputWindow; +extern UINT_PTR g_autoConnectTimer; +extern BOOL g_autoConnect; +extern CHAR g_xboxName[]; +extern DWORD g_xboxAddress; +extern CHAR g_remotePath[]; +extern CHAR g_localPath[]; +extern CHAR g_targetPath[]; +extern CHAR g_installPath[]; +extern CHAR g_xboxTargetName[]; +extern BOOL g_connectedToApp; +extern BOOL g_connectedToXBox; +extern PDMN_SESSION g_pdmnSession; +extern PDM_CONNECTION g_pdmConnection; +extern BOOL g_debugCommands; +extern BOOL g_captureDebugSpew; +extern HINSTANCE g_hInstance; +extern HICON g_hIcons[]; +extern BOOL g_reboot; +extern int g_rebootArgc; +extern char* g_rebootArgv[]; +extern int g_connectCount; +extern int g_currentIcon; +extern BOOL g_clsOnConnect; +extern DWORD g_connectedTime; +extern HBRUSH g_hBackgroundBrush; +extern COLORREF g_backgroundColor; +extern HFONT g_hFixedFont; +extern HFONT g_hProportionalFont; +extern HANDLE g_hCommandReadyEvent; +extern BOOL g_loadSymbolsOnConnect; +extern HACCEL g_hAccel; +extern BOOL g_alwaysAutoConnect; +extern BOOL g_startMinimized; +extern int g_connectFailure; +extern BOOL g_captureDebugSpew_StartupState; +extern bool g_bSuppressBlink; +extern BOOL g_bPlayTestMode; + +//----------------------------------------------------------------------------- +// LOCAL_CMDS.CPP +//----------------------------------------------------------------------------- +extern BOOL lc_bug( int argc, char* argv[] ); +extern BOOL lc_dir( int argc, char* argv[] ); +extern BOOL lc_del( int argc, char* argv[] ); +extern BOOL lc_memory( int argc, char* argv[] ); +extern BOOL lc_screenshot( int argc, char* argv[] ); +extern BOOL lc_help( int argc, char* argv[] ); +extern BOOL lc_cls( int argc, char* argv[] ); +extern BOOL lc_connect( int argc, char* argv[] ); +extern BOOL lc_autoConnect( int argc, char* argv[] ); +extern BOOL lc_disconnect( int argc, char* argv[] ); +extern BOOL lc_quit( int argc, char* argv[] ); +extern BOOL lc_crashdump( int argc, char* argv[] ); +extern BOOL lc_listen( int argc, char* argv[] ); +extern BOOL lc_run( int argc, char* argv[] ); +extern BOOL lc_reset( int argc, char* argv[] ); +extern BOOL lc_modules( int argc, char* argv[] ); +extern BOOL lc_sections( int argc, char* argv[] ); +extern BOOL lc_threads( int argc, char* argv[] ); +extern BOOL lc_ClearConfigs( int argc, char* argv[] ); +extern void AutoConnectTimerProc( HWND hwnd, UINT_PTR idEvent ); +extern int MatchLocalCommands( char* cmdStr, const char* cmdList[], int maxCmds ); +extern void DoDisconnect( BOOL bKeepConnection, int waitTime = 15 ); +extern localCommand_t g_localCommands[]; +extern const int g_numLocalCommands; + +//----------------------------------------------------------------------------- +// REMOTE_CMDS.CPP +//----------------------------------------------------------------------------- +extern int rc_AddCommands( char* commandPtr ); +extern void Remote_DeleteCommands(); +extern DWORD __stdcall Remote_NotifyDebugString( ULONG dwNotification, DWORD dwParam ); +extern DWORD __stdcall Remote_NotifyPrintFunc( const CHAR* strNotification ); +extern DWORD __stdcall Remote_NotifyCommandFunc( const CHAR* strNotification ); +extern int MatchRemoteCommands( char* cmdStr, const char* cmdList[], int maxCmds ); +extern remoteCommand_t* g_remoteCommands[]; +extern int g_numRemoteCommands; + +//----------------------------------------------------------------------------- +// BUG.CPP +//----------------------------------------------------------------------------- +extern bool BugDlg_Init( void ); +extern void BugDlg_Open( void ); +extern void BugReporter_FreeInterfaces(); +extern int rc_MapInfo( char* commandPtr ); + +//----------------------------------------------------------------------------- +// CONFIG.CPP +//----------------------------------------------------------------------------- +extern void ConfigDlg_Open( void ); +extern void ConfigDlg_LoadConfig(); + +//----------------------------------------------------------------------------- +// FILELOG.CPP +//----------------------------------------------------------------------------- +extern void FileLog_Open(); +extern bool FileLog_Init(); +extern void FileLog_Clear(); +extern unsigned int FileLog_AddItem( const char* filename, unsigned int fp ); +extern void FileLog_UpdateItem( unsigned int log, unsigned int fp, fileLogFunctions_e functionId, int value ); +extern void FileLog_SaveConfig(); +extern void FileLog_LoadConfig(); +extern bool g_fileLogEnable; + +//----------------------------------------------------------------------------- +// CPU_PROFILE.CPP +//----------------------------------------------------------------------------- +extern void CpuProfileSamples_Open(); +extern void CpuProfileHistory_Open(); +extern void CpuProfile_SetTitle(); +extern bool CpuProfile_Init(); +extern void CpuProfile_Clear(); +extern int rc_SetCpuProfile( char* commandPtr ); +extern int rc_SetCpuProfileData( char* commandPtr ); + +//----------------------------------------------------------------------------- +// TEX_PROFILE.CPP +//----------------------------------------------------------------------------- +extern void TexProfile_SetTitle(); +extern void TexProfileSamples_Open(); +extern void TexProfileHistory_Open(); +extern bool TexProfile_Init(); +extern int rc_SetTexProfile( char* commandPtr ); +extern int rc_SetTexProfileData( char* commandPtr ); + +//----------------------------------------------------------------------------- +// MEM_PROFILE.CPP +//----------------------------------------------------------------------------- +extern void MemProfile_Open(); +extern void MemProfile_SetTitle(); +extern bool MemProfile_Init(); +extern void MemProfile_Clear(); +extern int rc_FreeMemory( char* commandPtr ); + +//----------------------------------------------------------------------------- +// MEMLOG.CPP +//----------------------------------------------------------------------------- +extern void MemoryLog_Open(); +extern bool MemoryLog_Init(); +extern void MemoryLog_Clear(); +extern void MemoryLog_SaveConfig(); +extern void MemoryLog_LoadConfig(); +extern void MemoryLog_TreeView( bool enable ); +extern void MemoryLog_RefreshItems(); +extern int rc_MemoryLog( char* commandPtr ); +extern bool g_memoryLog_enable; + +//----------------------------------------------------------------------------- +// SYNC_FILES.CPP +//----------------------------------------------------------------------------- +extern int FileSyncEx( const char* localFilename, const char* remoteFilename, int fileSyncMode, bool bVerbose, bool bNoWrite ); +extern bool SyncFilesDlg_Init( void ); +extern void SyncFilesDlg_Open( void ); +extern void InstallDlg_Open( void ); + +//----------------------------------------------------------------------------- +// FILEIO.CPP +//----------------------------------------------------------------------------- +extern int CompareFileTimes_NTFStoFATX( FILETIME* ntfsFileTime, char *ntfsTimeString, int ntfsStringSize, FILETIME* fatxFileTime, char *fatxTimeString, int fatxStringSize ); +extern bool LoadTargetFile( const char *pTargetPath, int *pFileSize, void **pData ); + +//----------------------------------------------------------------------------- +// PROGRESS.CPP +//----------------------------------------------------------------------------- +extern bool Progress_Init(); + +//----------------------------------------------------------------------------- +// SHOW_TEXTURES.CPP +//----------------------------------------------------------------------------- +extern void ShowTextures_Open(); +extern bool ShowTextures_Init(); +extern int rc_TextureList( char* commandPtr ); + +//----------------------------------------------------------------------------- +// TIMESTAMP_LOG.CPP +//----------------------------------------------------------------------------- +extern void TimeStampLog_Open(); +extern bool TimeStampLog_Init(); +extern void TimeStampLog_Clear(); +extern int rc_TimeStampLog( char* commandPtr ); + +//----------------------------------------------------------------------------- +// COMMON.CPP +//----------------------------------------------------------------------------- +extern vprofState_e VProf_GetState(); +extern void VProf_Enable( vprofState_e state ); + +//----------------------------------------------------------------------------- +// SHOW_MATERIALS.CPP +//----------------------------------------------------------------------------- +extern void ShowMaterials_Open(); +extern bool ShowMaterials_Init(); +extern int rc_MaterialList( char* commandPtr ); + +//----------------------------------------------------------------------------- +// SHOW_SOUNDS.CPP +//----------------------------------------------------------------------------- +extern void ShowSounds_Open(); +extern bool ShowSounds_Init(); +extern int rc_SoundList( char* commandPtr ); + +//----------------------------------------------------------------------------- +// SHOW_MEMDUMP.CPP +//----------------------------------------------------------------------------- +extern void ShowMemDump_Open(); +extern bool ShowMemDump_Init(); +extern int rc_MemDump( char* commandPtr ); + +//----------------------------------------------------------------------------- +// EXCLUDE_PATHS.CPP +//----------------------------------------------------------------------------- +extern bool ExcludePathsDlg_Init( void ); +extern void ExcludePathsDlg_Open( void ); + +//----------------------------------------------------------------------------- +// ASSERT_DIALOG.CPP +//----------------------------------------------------------------------------- +extern bool g_AssertDialogActive; +int rc_Assert( char *commandPtr ); diff --git a/utils/xbox/vxconsole/vxconsole.ico b/utils/xbox/vxconsole/vxconsole.ico Binary files differnew file mode 100644 index 0000000..48c0d4c --- /dev/null +++ b/utils/xbox/vxconsole/vxconsole.ico diff --git a/utils/xbox/vxconsole/vxconsole.rc b/utils/xbox/vxconsole/vxconsole.rc new file mode 100644 index 0000000..2e62120 --- /dev/null +++ b/utils/xbox/vxconsole/vxconsole.rc @@ -0,0 +1,557 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#define APSTUDIO_HIDDEN_SYMBOLS +#include "windows.h" +#undef APSTUDIO_HIDDEN_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDI_VXCONSOLE ICON "VXConsole.ico" +IDI_CONNECT1_ON ICON "icon_connect1.ico" +IDI_DISCONNECTED ICON "icon_disconnect.ico" +IDI_CONNECT2_OFF ICON "icon_connect2.ico" +IDI_CONNECT2_ON ICON "icon_connect2a.ico" + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_VXCONSOLE DIALOGEX 7, 18, 416, 203 +STYLE DS_SETFONT | DS_3DLOOK | DS_FIXEDSYS | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME +EXSTYLE WS_EX_CLIENTEDGE +MENU MENU_VXCONSOLE +CLASS "VXConsole" +FONT 8, "MS Shell Dlg", 0, 0, 0x1 +BEGIN + COMBOBOX IDC_COMMAND,26,182,386,130,CBS_DROPDOWN | CBS_AUTOHSCROLL | WS_VSCROLL | WS_TABSTOP + LTEXT "&Cmd:",IDC_LABEL,5,184,17,8,SS_CENTERIMAGE + CONTROL "",IDC_OUTPUT,"RichEdit20A",ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL | ES_NOHIDESEL | ES_READONLY | WS_BORDER | WS_VSCROLL | WS_HSCROLL,5,7,404,170 +END + +IDD_CONFIG DIALOGEX 0, 0, 412, 151 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Dialog" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + DEFPUSHBUTTON "OK",IDC_OK,355,130,50,14 + PUSHBUTTON "Cancel",IDC_CANCEL,296,130,50,14 + LTEXT "Target XBox Name:",IDC_STATIC,7,7,126,9 + EDITTEXT IDC_CONFIG_XBOXNAME,7,18,148,13,ES_AUTOHSCROLL + PUSHBUTTON "Ping",IDC_CONFIG_PING,163,18,43,13 + CONTROL "Clear Log On Connect",IDC_CONFIG_CLEARONCONNECT,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,223,17,149,12 + CONTROL "Always Auto-Connect At Startup",IDC_CONFIG_ALWAYSAUTOCONNECT, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,223,33,149,12 + CONTROL "Start Minimized",IDC_CONFIG_STARTMINIMIZED,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,223,49,149,12 + EDITTEXT IDC_CONFIG_INSTALLPATH,7,117,199,13,ES_AUTOHSCROLL + LTEXT "PC Local Game Path: (Example: u:\\dev\\game)",IDC_STATIC,7,37,199,9 + EDITTEXT IDC_CONFIG_LOCALPATH,7,49,199,13,ES_AUTOHSCROLL + LTEXT "XBox Target HDD Path: (Example: e:\\valve)",IDC_STATIC,7,70,199,9 + EDITTEXT IDC_CONFIG_TARGETPATH,7,81,199,13,ES_AUTOHSCROLL + LTEXT "Installation Depot:",IDC_STATIC,7,105,116,9 + CONTROL "Enable Capture Debug Spew At Startup",IDC_CONFIG_CAPTUREDEBUGSPEW, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,223,65,149,12 +END + +IDD_SYNCFILES DIALOGEX 0, 0, 227, 154 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Sync Files" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + DEFPUSHBUTTON "Sync",IDC_OK,170,132,50,14 + PUSHBUTTON "Cancel",IDC_CANCEL,111,132,50,14 + LTEXT "XBox Target Path (To):",IDC_STATIC,7,39,116,9 + EDITTEXT IDC_SYNCFILES_TARGETPATH,7,51,213,13,ES_AUTOHSCROLL + LTEXT "PC Source Path (From):",IDC_STATIC,7,7,142,9 + EDITTEXT IDC_SYNCFILES_LOCALPATH,7,19,213,13,ES_AUTOHSCROLL + CONTROL "Force Sync",IDC_SYNCFILES_FORCESYNC,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,7,89,116,10 + CONTROL "Skip Writing Files (Test Mode)",IDC_SYNCFILES_NOWRITE, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,7,105,116,10 + CONTROL "Verbose",IDC_SYNCFILES_VERBOSE,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,7,73,116,10 +END + +IDD_MODIFYBIND DIALOGEX 0, 0, 260, 106 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Dialog" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + DEFPUSHBUTTON "OK",IDC_OK,202,86,50,14 + PUSHBUTTON "Cancel",IDCANCEL,144,86,50,14 + LTEXT "Key:",IDC_STATIC,7,7,16,8 + LTEXT "Static",IDC_MODIFYBIND_KEYCODE,28,7,51,8 + LTEXT "Menu Name:",IDC_STATIC,7,21,41,8 + EDITTEXT IDC_MODIFYBIND_MENUNAME,7,31,245,14,ES_AUTOHSCROLL + LTEXT "Command:",IDC_STATIC,7,50,35,8 + EDITTEXT IDC_MODIFYBIND_COMMAND,7,60,243,14,ES_AUTOHSCROLL +END + +IDD_BUG DIALOGEX 0, 0, 441, 375 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Bug Reporter" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + EDITTEXT IDC_BUG_TITLE,70,7,361,14,ES_AUTOHSCROLL + EDITTEXT IDC_BUG_DESCRIPTION,70,26,361,90,ES_MULTILINE | ES_WANTRETURN | WS_VSCROLL + PUSHBUTTON "Take Shot",IDC_BUG_TAKESHOT,7,122,56,14 + PUSHBUTTON "Save Game",IDC_BUG_SAVEGAME,7,141,56,14 + PUSHBUTTON "Include .bsp",IDC_BUG_INCLUDEBSP,7,159,56,14 + PUSHBUTTON "Include .vmf",IDC_BUG_INCLUDEVMF,7,178,56,14 + CONTROL "Compress Screenshot",IDC_BUG_COMPRESS_SCREENSHOT,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,70,298,104,10 + COMBOBOX IDC_BUG_OWNER,282,202,152,195,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP + COMBOBOX IDC_BUG_SEVERITY,282,221,152,77,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP + COMBOBOX IDC_BUG_REPORTTYPE,282,240,152,76,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP + COMBOBOX IDC_BUG_PRIORITY,282,259,152,76,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP + COMBOBOX IDC_BUG_GAME,282,278,152,195,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP + COMBOBOX IDC_BUG_AREA,282,297,152,125,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP + COMBOBOX IDC_BUG_MAPNUMBER,282,316,152,84,CBS_DROPDOWNLIST | WS_VSCROLL | WS_TABSTOP + PUSHBUTTON "Clear Form",IDC_BUG_CLEARFORM,7,354,50,14 + PUSHBUTTON "Update",IDC_BUG_UPDATE,67,354,50,14 + PUSHBUTTON "Cancel",IDC_CANCEL,321,354,50,14 + DEFPUSHBUTTON "Submit",IDC_BUG_SUBMIT,384,354,50,14 + LTEXT "Title:",IDC_STATIC,7,7,45,8 + LTEXT "Description:",IDC_STATIC,7,26,45,8 + LTEXT "Position:",IDC_STATIC,7,204,44,8 + LTEXT "Orientation:",IDC_STATIC,7,223,44,8 + LTEXT "Map:",IDC_STATIC,7,242,44,8 + LTEXT "Build:",IDC_STATIC,7,261,44,8 + LTEXT "Submitter:",IDC_STATIC,7,280,40,8 + LTEXT "",IDC_BUG_POSITION_LABEL,70,201,152,14,SS_SUNKEN + LTEXT "",IDC_BUG_ORIENTATION_LABEL,70,220,152,14,SS_SUNKEN + LTEXT "",IDC_BUG_MAP_LABEL,70,239,152,14,SS_SUNKEN + LTEXT "",IDC_BUG_BUILD_LABEL,70,258,152,14,SS_SUNKEN + LTEXT "",IDC_BUG_SUBMITTER_LABEL,70,277,152,14,SS_SUNKEN + LTEXT "Owner:",IDC_STATIC,232,204,40,8 + LTEXT "Severity:",IDC_STATIC,232,223,40,8 + LTEXT "Report Type:",IDC_STATIC,232,242,44,8 + LTEXT "Priority:",IDC_STATIC,232,261,26,8 + LTEXT "Game:",IDC_STATIC,231,280,40,8 + LTEXT "Area:",IDC_STATIC,232,299,19,8 + LTEXT "Map Number:",IDC_STATIC,232,318,44,8 + LTEXT "",IDC_BUG_TAKESHOT_LABEL,70,122,364,14,SS_SUNKEN | SS_PATHELLIPSIS + LTEXT "",IDC_BUG_SAVEGAME_LABEL,70,141,364,14,SS_SUNKEN | SS_PATHELLIPSIS + LTEXT "",IDC_BUG_INCLUDEBSP_LABEL,70,159,364,14,SS_SUNKEN | SS_PATHELLIPSIS + LTEXT "",IDC_BUG_INCLUDEVMF_LABEL,70,178,364,14,SS_SUNKEN | SS_PATHELLIPSIS +END + +IDD_EXCLUDEPATHS DIALOGEX 0, 0, 412, 313 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Exclude Xbox HDD Paths" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + CONTROL "",IDC_PATHS_TREE,"SysTreeView32",TVS_HASBUTTONS | TVS_HASLINES | TVS_LINESATROOT | TVS_DISABLEDRAGDROP | TVS_CHECKBOXES | WS_BORDER | WS_TABSTOP,7,7,398,276,WS_EX_CLIENTEDGE + PUSHBUTTON "Re-Scan",IDC_PATHS_RESCAN,7,292,50,14 + PUSHBUTTON "Expand All",IDC_PATHS_EXPAND,64,292,50,14 + PUSHBUTTON "Collapse All",IDC_PATHS_COLLAPSE,122,292,50,14 + PUSHBUTTON "Cancel",IDC_CANCEL,294,292,50,14 + DEFPUSHBUTTON "OK",IDC_OK,355,292,50,14 + CONTROL "Link Game Directories",IDC_PATHS_LINKGAMEDIRS,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,188,294,91,10 +END + +IDD_INSTALL DIALOGEX 0, 0, 492, 261 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Sync to DVD Image" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN + CONTROL "",IDC_INSTALL_LIST,"SysListView32",LVS_REPORT | LVS_SINGLESEL | LVS_SHOWSELALWAYS | LVS_ALIGNLEFT | WS_BORDER | WS_TABSTOP,7,7,477,215 + PUSHBUTTON "Refresh",IDC_INSTALL_REFRESH,7,234,50,14 + CONTROL "Force Sync",IDC_INSTALL_FORCESYNC,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,122,236,51,10 + CONTROL "Exact Image (Deletes Unrelated Files)",IDC_INSTALL_CLEANTARGET, + "Button",BS_AUTOCHECKBOX | WS_TABSTOP,185,236,137,10 + PUSHBUTTON "Cancel",IDC_CANCEL,373,234,50,14 + DEFPUSHBUTTON "OK",IDC_OK,434,234,50,14 +END + + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#define APSTUDIO_HIDDEN_SYMBOLS\r\n" + "#include ""windows.h""\r\n" + "#undef APSTUDIO_HIDDEN_SYMBOLS\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Accelerator +// + +IDR_MAIN_ACCEL ACCELERATORS +BEGIN + "X", IDM_AUTOCONNECT, VIRTKEY, CONTROL, NOINVERT + "H", IDM_PROFILEHISTORY, VIRTKEY, CONTROL, NOINVERT + "S", IDM_PROFILESAMPLES, VIRTKEY, CONTROL, NOINVERT +END + + +///////////////////////////////////////////////////////////////////////////// +// +// Menu +// + +MENU_VXCONSOLE MENU +BEGIN + POPUP "Main" + BEGIN + MENUITEM "Configuration..", IDM_CONFIG + MENUITEM SEPARATOR + MENUITEM "Exit", IDM_EXIT + END + POPUP "Connection" + BEGIN + MENUITEM "Capture Game Spew", IDM_CAPTUREGAMESPEW + MENUITEM "Capture Debug Spew", IDM_CAPTUREDEBUGSPEW + MENUITEM "Show Remote Command Traffic", IDM_DEBUGCOMMANDS + MENUITEM SEPARATOR + MENUITEM "Bug Reporter...", IDM_BUG + MENUITEM SEPARATOR + MENUITEM "Sync Xbox HDD Files...", IDM_SYNCFILES + MENUITEM "Sync Xbox HDD To DVD Image...", IDM_SYNCINSTALL + MENUITEM SEPARATOR + MENUITEM "Exclude Xbox HDD Paths...", IDM_EXCLUDEPATHS + MENUITEM SEPARATOR + MENUITEM "&Auto Connect\tCtrl+X", IDM_AUTOCONNECT + END + POPUP "Profiling" + BEGIN + MENUITEM "TimeStamp Log", IDM_TIMESTAMPLOG + MENUITEM "Memory Dump", IDM_MEMORYDUMP + MENUITEM SEPARATOR + POPUP "Show CPU Usage" + BEGIN + MENUITEM "Snapshot", IDM_CPU_SAMPLES + MENUITEM " History", IDM_CPU_HISTORY + END + POPUP "Show D3D Usage" + BEGIN + MENUITEM "Snapshot", IDM_D3D_SAMPLES + MENUITEM "History", IDM_D3D_HISTORY + END + MENUITEM "Show Memory Usage", IDM_SHOWMEMORYUSAGE + MENUITEM SEPARATOR + MENUITEM "Playtest Mode", IDM_PLAYTESTMODE + END + POPUP "Resources" + BEGIN + MENUITEM "List Materials", IDM_SHOWRESOURCES_MATERIALS + MENUITEM "List Models", IDM_SHOWRESOURCES_MODELS + MENUITEM "List Textures", IDM_SHOWRESOURCES_TEXTURES + MENUITEM "List Sounds", IDM_SHOWRESOURCES_SOUNDS + END +END + +MENU_CPUPROFILE MENU +BEGIN + POPUP "Options" + BEGIN + MENUITEM "Tick Marks", IDM_CPUPROFILE_TICKMARKS + MENUITEM "Colors", IDM_CPUPROFILE_COLORS + MENUITEM "FPS", IDM_CPUPROFILE_FPSLABELS + MENUITEM SEPARATOR + MENUITEM "Zoom In\tINS", IDM_CPUPROFILE_ZOOMIN + MENUITEM "Zoom Out\tDEL", IDM_CPUPROFILE_ZOOMOUT + MENUITEM SEPARATOR + MENUITEM "Enable", IDM_CPUPROFILE_ENABLE + END +END + +MENU_SHOWTEXTURES MENU +BEGIN + POPUP "Options" + BEGIN + MENUITEM "Summary...", IDM_OPTIONS_SUMMARY + MENUITEM "Refresh", IDM_OPTIONS_REFRESH + MENUITEM "Export...", IDM_OPTIONS_EXPORT + MENUITEM SEPARATOR + MENUITEM "Current Frame", IDM_OPTIONS_CURRENTFRAME + MENUITEM "Full Path", IDM_OPTIONS_FULLPATH + MENUITEM SEPARATOR + MENUITEM "Draw Texture", IDM_OPTIONS_DRAWTEXTURE + END +END + +MENU_TEXPROFILE MENU +BEGIN + POPUP "Options" + BEGIN + MENUITEM "Tick Marks", IDM_TEXPROFILE_TICKMARKS + MENUITEM "Colors", IDM_TEXPROFILE_COLORS + MENUITEM SEPARATOR + MENUITEM "Zoom In\tINS", IDM_TEXPROFILE_ZOOMIN + MENUITEM "Zoom Out\tDEL", IDM_TEXPROFILE_ZOOMOUT + MENUITEM SEPARATOR + MENUITEM "Current Frame", IDM_TEXPROFILE_CURRENTFRAME + MENUITEM "Enable", IDM_TEXPROFILE_ENABLE + END +END + +MENU_BINDOPTIONS MENU +BEGIN + POPUP "Options" + BEGIN + MENUITEM "Modify...", IDM_BINDOPTIONS_MODIFY + MENUITEM "Delete", IDM_BINDOPTIONS_DELETE + END +END + +MENU_SHOWMATERIALS MENU +BEGIN + POPUP "Options" + BEGIN + MENUITEM "Refresh", IDM_OPTIONS_REFRESH + MENUITEM "Export", IDM_OPTIONS_EXPORT + MENUITEM SEPARATOR + MENUITEM "Current Frame", IDM_OPTIONS_CURRENTFRAME + END +END + +MENU_SHOWSOUNDS MENU +BEGIN + POPUP "Options" + BEGIN + MENUITEM "Summary...", IDM_OPTIONS_SUMMARY + MENUITEM "Refresh", IDM_OPTIONS_REFRESH + MENUITEM "Export...", IDM_OPTIONS_EXPORT + MENUITEM SEPARATOR + MENUITEM "Play", IDM_OPTIONS_PLAYSOUND + END +END + +MENU_SHOWMEMORYDUMP MENU +BEGIN + POPUP "Options" + BEGIN + MENUITEM "Refresh", IDM_OPTIONS_REFRESH + MENUITEM "Export...", IDM_OPTIONS_EXPORT + MENUITEM "Summary...", IDM_OPTIONS_SUMMARY + MENUITEM SEPARATOR + MENUITEM "Size as Bytes", IDM_OPTIONS_BYTES + MENUITEM "Size as KB", IDM_OPTIONS_KILOBYTES + MENUITEM "Size as MB", IDM_OPTIONS_MEGABYTES + MENUITEM "Collapse Output", IDM_OPTIONS_COLLAPSEOUTPUT + END +END + +MENU_TIMESTAMPLOG MENU +BEGIN + POPUP "Options" + BEGIN + MENUITEM "Clear", IDM_OPTIONS_CLEAR + MENUITEM "Export", IDM_OPTIONS_EXPORT + END +END + +MENU_MEMPROFILE MENU +BEGIN + POPUP "Options" + BEGIN + MENUITEM "Tick Marks", IDM_MEMPROFILE_TICKMARKS + MENUITEM "Colors", IDM_MEMPROFILE_COLORS + MENUITEM SEPARATOR + MENUITEM "Zoom In\tINS", IDM_MEMPROFILE_ZOOMIN + MENUITEM "Zoom Out\t INS", IDM_MEMPROFILE_ZOOMOUT + MENUITEM SEPARATOR + MENUITEM "Enable", IDM_MEMPROFILE_ENABLE + END +END + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN + IDD_CONFIG, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 405 + TOPMARGIN, 7 + BOTTOMMARGIN, 144 + END + + IDD_SYNCFILES, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 220 + TOPMARGIN, 7 + BOTTOMMARGIN, 146 + END + + IDD_MODIFYBIND, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 252 + TOPMARGIN, 7 + BOTTOMMARGIN, 99 + END + + IDD_BUG, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 434 + TOPMARGIN, 7 + BOTTOMMARGIN, 368 + END + + IDD_EXCLUDEPATHS, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 405 + TOPMARGIN, 7 + BOTTOMMARGIN, 306 + END + + IDD_INSTALL, DIALOG + BEGIN + LEFTMARGIN, 7 + RIGHTMARGIN, 485 + TOPMARGIN, 7 + BOTTOMMARGIN, 254 + END +END +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// String Table +// + +STRINGTABLE +BEGIN + 10004 "Interrupted system call." + 10009 "Bad file number." + 10013 "Permission denied." + 10014 "Bad address." +END + +STRINGTABLE +BEGIN + 10022 "Invalid argument." + 10024 "Too many open files." +END + +STRINGTABLE +BEGIN + 10035 "Operation would block." + 10036 "Operation now in progress." + 10037 "Operation already in progress." + 10038 "Socket operation on nonsocket." + 10039 "Destination address required." + 10040 "Message too long." + 10041 "Protocol wrong type for socket." + 10042 "Protocol not available." + 10043 "Protocol not supported." + 10044 "Socket type not supported." + 10045 "Operation not supported on socket." + 10046 "Protocol family not supported." + 10047 "Address family not supported by protocol family." +END + +STRINGTABLE +BEGIN + 10048 "Address already in use." + 10049 "Cannot assign requested address." + 10050 "Network is down." + 10051 "Network is unreachable." + 10052 "Network dropped connection on reset." + 10053 "Software caused connection abort." + 10054 "Connection reset by peer." + 10055 "No buffer space available." + 10056 "Socket is already connected." + 10057 "Socket is not connected." + 10058 "Cannot send after socket shutdown." + 10059 "Too many references: cannot splice." + 10060 "Connection timed out." + 10061 "Connection refused." + 10062 "Too many levels of symbolic links." + 10063 "File name too long." +END + +STRINGTABLE +BEGIN + 10064 "Host is down." + 10065 "No route to host." +END + +STRINGTABLE +BEGIN + 10091 "The network subsystem is unusable." + 10092 "The Windows Sockets DLL cannot support this application." + 10093 "Winsock not initialized." +END + +STRINGTABLE +BEGIN + 10101 "Disconnect." +END + +STRINGTABLE +BEGIN + 11001 "Host not found." + 11002 "Nonauthoritative host not found. Name service maybe not be functioning." + 11003 "Nonrecoverable error. Name service maybe not be functioning." + 11004 "Valid name, no data record of requested type." +END + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED + diff --git a/utils/xbox/vxconsole/vxconsole.vpc b/utils/xbox/vxconsole/vxconsole.vpc new file mode 100644 index 0000000..5e9424c --- /dev/null +++ b/utils/xbox/vxconsole/vxconsole.vpc @@ -0,0 +1,85 @@ +//----------------------------------------------------------------------------- +// VXCONSOLE.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\..\game\bin" + +$Include "$SRCDIR\vpc_scripts\source_exe_win_win32_base.vpc" + +$Configuration +{ + $Compiler + { + $AdditionalIncludeDirectories "$BASE;$SRCDIR\x360xdk\include\win32\vs2005" + } + + $Linker + { + $AdditionalDependencies "wsock32.lib comctl32.lib odbc32.lib odbccp32.lib xbdm.lib" + $AdditionalLibraryDirectories "$SRCDIR\x360xdk\lib\win32\vs2005" + $DelayLoadedDLLs "xbdm.dll" + } +} + +$Project "VXConsole" +{ + $Folder "Source Files" + { + $File "bindings.cpp" + $File "bug.cpp" + $File "common.cpp" + $File "config.cpp" + $File "cpu_profile.cpp" + $File "exclude_paths.cpp" + $File "fileio.cpp" + $File "local_cmds.cpp" + $File "progress.cpp" + $File "remote_cmds.cpp" + $File "show_materials.cpp" + $File "show_memdump.cpp" + $File "show_sounds.cpp" + $File "show_textures.cpp" + $File "sync_files.cpp" + $File "sys_scriptlib.cpp" + $File "sys_utils.cpp" + $File "tex_profile.cpp" + $File "timestamp_log.cpp" + $File "vxconsole.cpp" + $File "assert_dialog.cpp" + $File "mem_profile.cpp" + } + + $Folder "Header Files" + { + $File "$SRCDIR\common\bugreporter\bugreporter.h" + $File "$SRCDIR\common\xbox\xbox_vxconsole.h" + $File "$SRCDIR\public\tier1\interface.h" + $File "$SRCDIR\public\jpeglib\jpeglib.h" + $File "$SRCDIR\public\tier0\platform.h" + $File "$SRCDIR\public\tier1\strtools.h" + $File "resource.h" + $File "assert_resource.h" + $File "sys_scriptlib.h" + $File "sys_utils.h" + $File "vxconsole.h" + } + + $Folder "Resource Files" + { + $File "icon_connect1.ico" + $File "icon_connect2.ico" + $File "icon_connect2a.ico" + $File "icon_disconnect.ico" + $File "vxconsole.ico" + $File "vxconsole.rc" + $File "assert_dialog.rc" + } + + $Folder "Link Libraries" + { + $DynamicFile "$SRCDIR\lib\common\jpeglib.lib" + } +} diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_english.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_english.tga Binary files differnew file mode 100644 index 0000000..5c61f95 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_english.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_french.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_french.tga Binary files differnew file mode 100644 index 0000000..0116d18 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_french.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_german.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_german.tga Binary files differnew file mode 100644 index 0000000..629524e --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_german.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_italian.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_italian.tga Binary files differnew file mode 100644 index 0000000..c37b3a2 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_italian.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_spanish.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_spanish.tga Binary files differnew file mode 100644 index 0000000..a935072 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/LegalScreen_spanish.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/LoadingIcon.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/LoadingIcon.tga Binary files differnew file mode 100644 index 0000000..ae2134d --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/LoadingIcon.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/SourceScreen.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/SourceScreen.tga Binary files differnew file mode 100644 index 0000000..4acd064 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/SourceScreen.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/Tahoma_16.abc b/utils/xbox/xbox_loader/LoaderMedia_Source/Tahoma_16.abc Binary files differnew file mode 100644 index 0000000..bcbc925 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/Tahoma_16.abc diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/Tahoma_16.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/Tahoma_16.tga Binary files differnew file mode 100644 index 0000000..103fb95 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/Tahoma_16.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/footer.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/footer.tga Binary files differnew file mode 100644 index 0000000..340f4a5 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/footer.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/loader_icon.bmp b/utils/xbox/xbox_loader/LoaderMedia_Source/loader_icon.bmp Binary files differnew file mode 100644 index 0000000..29e905e --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/loader_icon.bmp diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/loader_icon.rdf b/utils/xbox/xbox_loader/LoaderMedia_Source/loader_icon.rdf new file mode 100644 index 0000000..e31fa3a --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/loader_icon.rdf @@ -0,0 +1,7 @@ +Texture MyTex +{ + Source loader_icon.bmp + Format D3DFMT_DXT1 + Width 128 + Height 128 +} diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_english.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_english.tga Binary files differnew file mode 100644 index 0000000..b45b3a1 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_english.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_french.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_french.tga Binary files differnew file mode 100644 index 0000000..2963e36 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_french.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_german.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_german.tga Binary files differnew file mode 100644 index 0000000..2636bec --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_german.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_italian.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_italian.tga Binary files differnew file mode 100644 index 0000000..a09efae --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_italian.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_spanish.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_spanish.tga Binary files differnew file mode 100644 index 0000000..ade8343 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow1_spanish.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow2.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow2.tga Binary files differnew file mode 100644 index 0000000..52e952b --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow2.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow3.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow3.tga Binary files differnew file mode 100644 index 0000000..76b3700 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow3.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow4.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow4.tga Binary files differnew file mode 100644 index 0000000..1bc591d --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow4.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow5.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow5.tga Binary files differnew file mode 100644 index 0000000..040a8ac --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow5.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow6.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow6.tga Binary files differnew file mode 100644 index 0000000..1edbb6e --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow6.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow7.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow7.tga Binary files differnew file mode 100644 index 0000000..4f47769 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow7.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow8.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow8.tga Binary files differnew file mode 100644 index 0000000..30dabe8 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow8.tga diff --git a/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow9.tga b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow9.tga Binary files differnew file mode 100644 index 0000000..a9cfb82 --- /dev/null +++ b/utils/xbox/xbox_loader/LoaderMedia_Source/slideshow9.tga diff --git a/utils/xbox/xbox_loader/loader.rdf b/utils/xbox/xbox_loader/loader.rdf new file mode 100644 index 0000000..33e7552 --- /dev/null +++ b/utils/xbox/xbox_loader/loader.rdf @@ -0,0 +1,173 @@ +// List of resources to bundle. +// +// The output will be a header file (.h) used at compile time, +// and a packed resource file (.xpr) used at runtime. + +out_packedresource LoaderMedia\loader.xpr +out_error loader.err + +Texture Font +{ + Source LoaderMedia_Source\Tahoma_16.tga + Format D3DFMT_A4R4G4B4 + Levels 1 +} + +UserData FontData +{ + DataFile LoaderMedia_Source\Tahoma_16.abc +} + +Texture Footer +{ + Source LoaderMedia_Source\Footer.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture MainLegal_english +{ + Source LoaderMedia_Source\LegalScreen_english.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture MainLegal_french +{ + Source LoaderMedia_Source\LegalScreen_french.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture MainLegal_italian +{ + Source LoaderMedia_Source\LegalScreen_italian.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture MainLegal_german +{ + Source LoaderMedia_Source\LegalScreen_german.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture MainLegal_spanish +{ + Source LoaderMedia_Source\LegalScreen_spanish.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SourceLegal +{ + Source LoaderMedia_Source\SourceScreen.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture LoadingIcon +{ + Source LoaderMedia_Source\LoadingIcon.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow1_english +{ + Source LoaderMedia_Source\SlideShow1_english.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow1_french +{ + Source LoaderMedia_Source\SlideShow1_french.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow1_italian +{ + Source LoaderMedia_Source\SlideShow1_italian.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow1_german +{ + Source LoaderMedia_Source\SlideShow1_german.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow1_spanish +{ + Source LoaderMedia_Source\SlideShow1_spanish.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow2 +{ + Source LoaderMedia_Source\SlideShow2.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow3 +{ + Source LoaderMedia_Source\SlideShow3.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow4 +{ + Source LoaderMedia_Source\SlideShow4.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow5 +{ + Source LoaderMedia_Source\SlideShow5.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow6 +{ + Source LoaderMedia_Source\SlideShow6.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow7 +{ + Source LoaderMedia_Source\SlideShow7.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow8 +{ + Source LoaderMedia_Source\SlideShow8.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + +Texture SlideShow9 +{ + Source LoaderMedia_Source\SlideShow9.tga + Format D3DFMT_LIN_A8R8G8B8 + Levels 1 +} + + + + + + + diff --git a/utils/xbox/xbox_loader/xbox_fileCopy.cpp b/utils/xbox/xbox_loader/xbox_fileCopy.cpp new file mode 100644 index 0000000..39d0c65 --- /dev/null +++ b/utils/xbox/xbox_loader/xbox_fileCopy.cpp @@ -0,0 +1,595 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Copies a file using overlapped async IO. +// +// Stub executeable +//=====================================================================================// +#include "xbox_loader.h" + +#define BUFFER_SIZE (1*1024*1024) +#define NUM_BUFFERS 4 +#define ALIGN(x,y) (((x)+(y)-1) & ~((y)-1)) + +struct CopyFile_t +{ + // source file + HANDLE m_hSrcFile; + DWORD m_srcFileSize; + int m_readBufferSize; + unsigned int m_numReadCycles; + + // target file + HANDLE m_hDstFile; + DWORD m_dstFileSize; + + // source file gets decompressed + bool m_bInflate; + unsigned char *m_pInflateBuffer; + int m_inflateBufferSize; + + bool m_bCopyError; + CopyStats_t *m_pCopyStats; +}; + +struct Buffer_t +{ + unsigned char *pData; + DWORD dwSize; + Buffer_t* pNext; + int id; +}; + +Buffer_t *g_pReadBuffers = NULL; +Buffer_t *g_pWriteBuffers = NULL; + +CRITICAL_SECTION g_criticalSection; +HANDLE g_hReadEvent; +HANDLE g_hWriteEvent; +DWORD *g_pNumReadBuffers; +DWORD *g_pNumWriteBuffers; + +//----------------------------------------------------------------------------- +// CreateFilePath +// +// Create full path to specified file. +//----------------------------------------------------------------------------- +bool CreateFilePath( const char *inPath ) +{ + char* ptr; + char dirPath[MAX_PATH]; + BOOL bSuccess; + + // prime and skip to first seperator after the drive path + strcpy( dirPath, inPath ); + ptr = strchr( dirPath, '\\' ); + while ( ptr ) + { + ptr = strchr( ptr+1, '\\' ); + if ( ptr ) + { + *ptr = '\0'; + bSuccess = ::CreateDirectory( dirPath, NULL ); + *ptr = '\\'; + } + } + + // ensure read-only is cleared + SetFileAttributes( inPath, FILE_ATTRIBUTE_NORMAL ); + + return true; +} + +//----------------------------------------------------------------------------- +// LockBufferForRead +// +//----------------------------------------------------------------------------- +Buffer_t *LockBufferForRead() +{ + if ( !g_pReadBuffers ) + { + // out of data, wait for it + WaitForSingleObject( g_hReadEvent, INFINITE ); + } + else + { + ResetEvent( g_hReadEvent ); + } + + EnterCriticalSection( &g_criticalSection ); + + Buffer_t *pBuffer = g_pReadBuffers; + g_pReadBuffers = pBuffer->pNext; + + (*g_pNumReadBuffers)--; + + LeaveCriticalSection( &g_criticalSection ); + + return pBuffer; +} + +//----------------------------------------------------------------------------- +// LockBufferForWrite +// +//----------------------------------------------------------------------------- +Buffer_t* LockBufferForWrite() +{ + if ( !g_pWriteBuffers ) + { + // out of data, wait for more + WaitForSingleObject( g_hWriteEvent, INFINITE ); + } + else + { + ResetEvent( g_hWriteEvent ); + } + + EnterCriticalSection( &g_criticalSection ); + + Buffer_t *pBuffer = g_pWriteBuffers; + g_pWriteBuffers = pBuffer->pNext; + + (*g_pNumWriteBuffers)--; + + LeaveCriticalSection( &g_criticalSection ); + + return pBuffer; +} + +//----------------------------------------------------------------------------- +// AddBufferForRead +// +//----------------------------------------------------------------------------- +void AddBufferForRead( Buffer_t *pBuffer ) +{ + EnterCriticalSection( &g_criticalSection ); + + // add to end of list + Buffer_t *pCurrent = g_pReadBuffers; + while ( pCurrent && pCurrent->pNext ) + { + pCurrent = pCurrent->pNext; + } + if ( pCurrent ) + { + pBuffer->pNext = pCurrent->pNext; + pCurrent->pNext = pBuffer; + } + else + { + pBuffer->pNext = NULL; + g_pReadBuffers = pBuffer; + } + + (*g_pNumReadBuffers)++; + + LeaveCriticalSection( &g_criticalSection ); + + SetEvent( g_hReadEvent ); +} + +//----------------------------------------------------------------------------- +// AddBufferForWrite +// +//----------------------------------------------------------------------------- +void AddBufferForWrite( Buffer_t *pBuffer ) +{ + EnterCriticalSection( &g_criticalSection ); + + // add to end of list + Buffer_t* pCurrent = g_pWriteBuffers; + while ( pCurrent && pCurrent->pNext ) + { + pCurrent = pCurrent->pNext; + } + if ( pCurrent ) + { + pBuffer->pNext = pCurrent->pNext; + pCurrent->pNext = pBuffer; + } + else + { + pBuffer->pNext = NULL; + g_pWriteBuffers = pBuffer; + } + + (*g_pNumWriteBuffers)++; + + LeaveCriticalSection( &g_criticalSection ); + + SetEvent( g_hWriteEvent ); +} + +//----------------------------------------------------------------------------- +// ReadFileThread +// +//----------------------------------------------------------------------------- +DWORD WINAPI ReadFileThread( LPVOID lParam ) +{ + CopyFile_t *pCopyFile; + OVERLAPPED overlappedRead = {0}; + DWORD startTime; + DWORD dwBytesRead; + DWORD dwError; + BOOL bResult; + Buffer_t *pBuffer; + + pCopyFile = (CopyFile_t*)lParam; + + // Copy from the buffer to the Hard Drive + for ( unsigned int readCycle = 0; readCycle < pCopyFile->m_numReadCycles; ++readCycle ) + { + pBuffer = LockBufferForRead(); + + startTime = GetTickCount(); + dwBytesRead = 0; + + int numAttempts = 0; +retry: + // read file from DVD + bResult = ReadFile( pCopyFile->m_hSrcFile, pBuffer->pData, pCopyFile->m_readBufferSize, NULL, &overlappedRead ); + dwError = GetLastError(); + if ( !bResult && dwError != ERROR_IO_PENDING ) + { + if ( dwError == ERROR_HANDLE_EOF ) + { + // nothing more to read + break; + } + + numAttempts++; + if ( numAttempts == 3 ) + { + // error + pCopyFile->m_bCopyError = true; + break; + } + else + { + goto retry; + } + } + else + { + // Wait for the operation to finish + GetOverlappedResult( pCopyFile->m_hSrcFile, &overlappedRead, &dwBytesRead, TRUE ); + overlappedRead.Offset += dwBytesRead; + } + + if ( !dwBytesRead ) + { + pCopyFile->m_bCopyError = true; + break; + } + + pCopyFile->m_pCopyStats->m_bufferReadSize = dwBytesRead; + pCopyFile->m_pCopyStats->m_bufferReadTime = GetTickCount() - startTime; + pCopyFile->m_pCopyStats->m_totalReadSize += pCopyFile->m_pCopyStats->m_bufferReadSize; + pCopyFile->m_pCopyStats->m_totalReadTime += pCopyFile->m_pCopyStats->m_bufferReadTime; + + pBuffer->dwSize = dwBytesRead; + AddBufferForWrite( pBuffer ); + } + + return 0; +} + +//----------------------------------------------------------------------------- +// WriteFileThread +// +//----------------------------------------------------------------------------- +DWORD WINAPI WriteFileThread( LPVOID lParam ) +{ + CopyFile_t *pCopyFile; + OVERLAPPED overlappedWrite = {0}; + DWORD startTime; + DWORD dwBytesWrite; + DWORD dwWriteSize; + DWORD dwError; + BOOL bResult; + Buffer_t *pBuffer; + unsigned char *pWriteBuffer; + + pCopyFile = (CopyFile_t*)lParam; + + while ( overlappedWrite.Offset < pCopyFile->m_dstFileSize ) + { + // wait for wake-up event + pBuffer = LockBufferForWrite(); + + if ( pCopyFile->m_bInflate ) + { + startTime = GetTickCount(); + + DWORD dwSkip = overlappedWrite.Offset ? 0 : sizeof( xCompressHeader ); + dwWriteSize = JCALG1_Decompress_Formatted_Buffer( pBuffer->dwSize - dwSkip, pBuffer->pData + dwSkip, pCopyFile->m_inflateBufferSize, pCopyFile->m_pInflateBuffer ); + if ( dwWriteSize == (DWORD)-1 ) + { + pCopyFile->m_bCopyError = true; + break; + } + + pCopyFile->m_pCopyStats->m_inflateSize = dwWriteSize; + pCopyFile->m_pCopyStats->m_inflateTime = GetTickCount() - startTime; + + pWriteBuffer = pCopyFile->m_pInflateBuffer; + } + else + { + // straight copy + dwWriteSize = pBuffer->dwSize; + pWriteBuffer = pBuffer->pData; + } + + if ( overlappedWrite.Offset + dwWriteSize >= pCopyFile->m_dstFileSize ) + { + // last buffer, ensure all data is written + dwWriteSize = ALIGN( dwWriteSize, 512 ); + } + + startTime = GetTickCount(); + dwBytesWrite = 0; + + int numAttempts = 0; +retry: + // write file to HDD + bResult = WriteFile( pCopyFile->m_hDstFile, pWriteBuffer, (dwWriteSize/512) * 512, NULL, &overlappedWrite ); + dwError = GetLastError(); + if ( !bResult && dwError != ERROR_IO_PENDING ) + { + numAttempts++; + if ( numAttempts == 3 ) + { + // error + pCopyFile->m_bCopyError = true; + break; + } + else + { + goto retry; + } + } + else + { + // Wait for the operation to finish + GetOverlappedResult( pCopyFile->m_hDstFile, &overlappedWrite, &dwBytesWrite, TRUE ); + overlappedWrite.Offset += dwBytesWrite; + } + + if ( dwBytesWrite ) + { + // track expected size + pCopyFile->m_pCopyStats->m_bytesCopied += dwBytesWrite; + pCopyFile->m_pCopyStats->m_writeSize += dwBytesWrite; + } + else + { + pCopyFile->m_bCopyError = true; + break; + } + + pCopyFile->m_pCopyStats->m_bufferWriteSize = dwBytesWrite; + pCopyFile->m_pCopyStats->m_bufferWriteTime = GetTickCount() - startTime; + pCopyFile->m_pCopyStats->m_totalWriteSize += pCopyFile->m_pCopyStats->m_bufferWriteSize; + pCopyFile->m_pCopyStats->m_totalWriteTime += pCopyFile->m_pCopyStats->m_bufferWriteTime; + + AddBufferForRead( pBuffer ); + } + + return 0; +} + +//----------------------------------------------------------------------------- +// CopyFileInit +// +//----------------------------------------------------------------------------- +void CopyFileInit() +{ + static bool init = false; + if ( !init ) + { + InitializeCriticalSection( &g_criticalSection ); + g_hReadEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); + g_hWriteEvent = CreateEvent( NULL, FALSE, FALSE, NULL ); + init = true; + } + else + { + // expected startup state + ResetEvent( g_hReadEvent ); + ResetEvent( g_hWriteEvent ); + + g_pReadBuffers = NULL; + g_pWriteBuffers = NULL; + } +} + +//----------------------------------------------------------------------------- +// CopyFileOverlapped +// +//----------------------------------------------------------------------------- +bool CopyFileOverlapped( const char *pSrcFilename, const char *pDstFilename, xCompressHeader *pxcHeader, CopyStats_t *pCopyStats ) +{ + CopyFile_t copyFile = {0}; + Buffer_t buffers[NUM_BUFFERS] = {0}; + HANDLE hReadThread = NULL; + HANDLE hWriteThread = NULL; + bool bSuccess = false; + DWORD startCopyTime; + DWORD dwResult; + int i; + + startCopyTime = GetTickCount(); + + CopyFileInit(); + + g_pNumReadBuffers = &pCopyStats->m_numReadBuffers; + g_pNumWriteBuffers = &pCopyStats->m_numWriteBuffers; + + strcpy( pCopyStats->m_srcFilename, pSrcFilename ); + strcpy( pCopyStats->m_dstFilename, pDstFilename ); + + copyFile.m_hSrcFile = INVALID_HANDLE_VALUE; + copyFile.m_hDstFile = INVALID_HANDLE_VALUE; + copyFile.m_pCopyStats = pCopyStats; + copyFile.m_bCopyError = false; + + // validate the source file + copyFile.m_hSrcFile = CreateFile( pSrcFilename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED|FILE_FLAG_NO_BUFFERING, NULL ); + if ( copyFile.m_hSrcFile == INVALID_HANDLE_VALUE ) + { + // failure + goto cleanUp; + } + + copyFile.m_srcFileSize = GetFileSize( copyFile.m_hSrcFile, NULL ); + if ( copyFile.m_srcFileSize == (DWORD)-1 ) + { + // failure + goto cleanUp; + } + + // ensure the target file path exists + CreateFilePath( pDstFilename ); + + // validate the target file + copyFile.m_hDstFile = CreateFile( pDstFilename, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_OVERLAPPED|FILE_FLAG_NO_BUFFERING, NULL ); + if ( copyFile.m_hDstFile == INVALID_HANDLE_VALUE ) + { + // failure + goto cleanUp; + } + + pCopyStats->m_readSize = copyFile.m_srcFileSize; + pCopyStats->m_writeSize = 0; + + if ( pxcHeader ) + { + // read in chunks of compressed blocks + copyFile.m_readBufferSize = pxcHeader->nReadBlockSize; + copyFile.m_dstFileSize = pxcHeader->nUncompressedFileSize; + } + else + { + // setup for copy + copyFile.m_readBufferSize = BUFFER_SIZE; + copyFile.m_dstFileSize = copyFile.m_srcFileSize; + } + + // setup read buffers + for ( i=0; i<NUM_BUFFERS; i++) + { + buffers[i].pData = new unsigned char[copyFile.m_readBufferSize]; + buffers[i].dwSize = 0; + buffers[i].pNext = NULL; + AddBufferForRead( &buffers[i] ); + } + copyFile.m_numReadCycles = (copyFile.m_srcFileSize + copyFile.m_readBufferSize - 1)/copyFile.m_readBufferSize; + + // setup write buffer + if ( pxcHeader ) + { + copyFile.m_pInflateBuffer = new unsigned char[pxcHeader->nDecompressionBufferSize]; + copyFile.m_inflateBufferSize = pxcHeader->nDecompressionBufferSize; + copyFile.m_bInflate = true; + } + else + { + copyFile.m_bInflate = false; + } + + // pre-size the target file in aligned buffers + DWORD dwAligned = ALIGN( copyFile.m_dstFileSize, 512 ); + dwResult = SetFilePointer( copyFile.m_hDstFile, dwAligned, NULL, FILE_BEGIN ); + if ( dwResult == INVALID_SET_FILE_POINTER ) + { + // failure + goto cleanUp; + } + SetEndOfFile( copyFile.m_hDstFile ); + + // start the read thread + hReadThread = CreateThread( 0, 0, &ReadFileThread, ©File, 0, 0 ); + if ( !hReadThread ) + { + // failure + goto cleanUp; + } + + // wait for buffers to populate + + // start the write thread + hWriteThread = CreateThread( 0, 0, &WriteFileThread, ©File, 0, 0 ); + if ( !hWriteThread ) + { + // failure + goto cleanUp; + } + + // wait for write thread to finish + WaitForSingleObject( hWriteThread, INFINITE ); + WaitForSingleObject( hReadThread, INFINITE ); + + if ( copyFile.m_bCopyError ) + { + goto cleanUp; + } + + // Fixup the file size + CloseHandle( copyFile.m_hDstFile ); + copyFile.m_hDstFile = INVALID_HANDLE_VALUE; + + if ( copyFile.m_dstFileSize % 512 ) + { + // re-open file as non-buffered to adjust to correct file size + HANDLE hFile = CreateFile( pDstFilename, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); + SetFilePointer( hFile, copyFile.m_dstFileSize, NULL, FILE_BEGIN ); + SetEndOfFile( hFile ); + CloseHandle( hFile ); + } + + // finished + bSuccess = true; + +cleanUp: + if ( copyFile.m_hSrcFile != INVALID_HANDLE_VALUE ) + { + CloseHandle( copyFile.m_hSrcFile ); + } + + if ( copyFile.m_hDstFile != INVALID_HANDLE_VALUE ) + { + CloseHandle( copyFile.m_hDstFile ); + } + + if ( hReadThread ) + { + CloseHandle( hReadThread ); + } + + if ( hWriteThread ) + { + CloseHandle( hWriteThread ); + } + + for ( i=0; i<NUM_BUFFERS; i++ ) + { + if ( buffers[i].pData ) + { + delete [] buffers[i].pData; + } + } + + if ( copyFile.m_pInflateBuffer ) + { + delete [] copyFile.m_pInflateBuffer; + } + + if ( !bSuccess ) + { + pCopyStats->m_copyErrors++; + } + + pCopyStats->m_copyTime = GetTickCount() - startCopyTime; + + return bSuccess; +} diff --git a/utils/xbox/xbox_loader/xbox_loader.cpp b/utils/xbox/xbox_loader/xbox_loader.cpp new file mode 100644 index 0000000..7cbeb77 --- /dev/null +++ b/utils/xbox/xbox_loader/xbox_loader.cpp @@ -0,0 +1,2019 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// APPLOADER.CPP +// +// Stub executeable +//=====================================================================================// +#include "xbox_loader.h" + +struct installData_t +{ + char **m_ppSrcFiles; + char **m_ppDstFiles; + DWORD *m_pDstFileSizes; + int m_numFiles; + DWORD m_totalSize; + xCompressHeader **m_ppxcHeaders; +}; + +DWORD g_installStartTime; +DWORD g_installElapsedTime; +installData_t g_installData; +CopyStats_t g_copyStats; +int g_activeDevice; +__int64 g_loaderStartTime; + + +//----------------------------------------------------------------------------- +// GetLocalizedLoadingString +//----------------------------------------------------------------------------- +const wchar_t *GetLocalizedLoadingString() +{ + switch( XGetLanguage() ) + { + case XC_LANGUAGE_FRENCH: + return L"CHARGEMENT..."; + case XC_LANGUAGE_ITALIAN: + return L"CARICAMENTO..."; + case XC_LANGUAGE_GERMAN: + return L"L�DT..."; + case XC_LANGUAGE_SPANISH: + return L"CARGANDO..."; + } + return L"LOADING..."; +} + +//----------------------------------------------------------------------------- +// GetNextLangauge +// Start at -1 +//----------------------------------------------------------------------------- +int GetNextLanguage( int languageID ) +{ + if ( languageID < 0 ) + return XC_LANGUAGE_ENGLISH; + + // cycle to end + switch ( languageID ) + { + case XC_LANGUAGE_ENGLISH: + return XC_LANGUAGE_FRENCH; + case XC_LANGUAGE_FRENCH: + return XC_LANGUAGE_ITALIAN; + case XC_LANGUAGE_ITALIAN: + return XC_LANGUAGE_GERMAN; + case XC_LANGUAGE_GERMAN: + return XC_LANGUAGE_SPANISH; + case XC_LANGUAGE_SPANISH: + return -1; + } + + return -1; +} + +//----------------------------------------------------------------------------- +// GetLanguageString +//----------------------------------------------------------------------------- +const char *GetLanguageString( int languageID ) +{ + switch( languageID ) + { + case XC_LANGUAGE_FRENCH: + return "french"; + case XC_LANGUAGE_ITALIAN: + return "italian"; + case XC_LANGUAGE_GERMAN: + return "german"; + case XC_LANGUAGE_SPANISH: + return "spanish"; + } + return "english"; +} + +//----------------------------------------------------------------------------- +// FixupNamespaceFilename +//----------------------------------------------------------------------------- +bool FixupNamespaceFilename( const char *pFilename, char *pOutFilename, int languageID ) +{ + char newFilename[MAX_PATH]; + + bool bFixup = false; + int dstLen = 0; + int srcLen = strlen( pFilename ); + for ( int i=0; i<srcLen+1; i++ ) + { + // replace every occurrence of % with language + if ( pFilename[i] == '%' ) + { + int len = strlen( GetLanguageString( languageID ) ); + memcpy( newFilename + dstLen, GetLanguageString( languageID ), len ); + dstLen += len; + bFixup = true; + } + else + { + newFilename[dstLen] = pFilename[i]; + dstLen++; + } + } + + strcpy( pOutFilename, newFilename ); + return bFixup; +} + +//----------------------------------------------------------------------------- +// DeleteOtherLocalizedFiles +//----------------------------------------------------------------------------- +void DeleteOtherLocalizedFiles( const char *pFilename, int languageIDToKeep ) +{ + char newFilename[MAX_PATH]; + char mrkFilename[MAX_PATH]; + bool bFixup; + + int languageID = -1; + while ( 1 ) + { + languageID = GetNextLanguage( languageID ); + if ( languageID == -1 ) + { + // cycled through + break; + } + + if ( languageID == languageIDToKeep ) + { + // skip + continue; + } + + bFixup = FixupNamespaceFilename( pFilename, newFilename, languageID ); + if ( !bFixup ) + { + // nothing to do + continue; + } + + SetFileAttributes( newFilename, FILE_ATTRIBUTE_NORMAL ); + DeleteFile( newFilename ); + + // delete marker + strcpy( mrkFilename, newFilename ); + strcat( mrkFilename, ".mrk" ); + SetFileAttributes( mrkFilename, FILE_ATTRIBUTE_NORMAL ); + DeleteFile( mrkFilename ); + } +} + +//----------------------------------------------------------------------------- +// LerpColor +//----------------------------------------------------------------------------- +unsigned int LerpColor( unsigned int c0, unsigned int c1, float t ) +{ + int i; + float a; + float b; + unsigned char* c; + unsigned int newcolor; + + if ( t <= 0.0f ) + return c0; + else if ( t >= 1.0f ) + return c1; + + // lerp each component + c = (unsigned char*)&newcolor; + for ( i=0; i<4; i++ ) + { + a = (float)(c0 & 0xFF); + b = (float)(c1 & 0xFF); + *c++ = (unsigned char)(a + t*(b-a)); + + // next color component + c0 >>= 8; + c1 >>= 8; + } + + return newcolor; +} + +//----------------------------------------------------------------------------- +// ConvertToWideString +//----------------------------------------------------------------------------- +void ConvertToWideString( wchar_t *pDst, const char *pSrc ) +{ + int len = strlen( pSrc )+1; + for (int i=0; i<len; i++) + { + pDst[i] = pSrc[i]; + } +} + +//----------------------------------------------------------------------------- +// CopyString +//----------------------------------------------------------------------------- +char *CopyString( const char *pString ) +{ + char *pNewString = (char *)malloc( strlen( pString ) + 1 ); + strcpy( pNewString, pString ); + + return pNewString; +} + +//----------------------------------------------------------------------------- +// FixFilename +//----------------------------------------------------------------------------- +void FixFilename( char *pPath ) +{ + int len = strlen( pPath ); + for (int i=0; i<len; ++i) + { + if ( pPath[i] == '/') + pPath[i] = '\\'; + } +} + +//----------------------------------------------------------------------------- +// StripQuotes +//----------------------------------------------------------------------------- +void StripQuotes( char *pToken ) +{ + int len = strlen( pToken ); + if ( pToken[0] == '"' && pToken[len-1] == '"' ) + { + memcpy( pToken, pToken+1, len-2 ); + pToken[len-2] = '\0'; + } +} + +//----------------------------------------------------------------------------- +// DoesFileExist +//----------------------------------------------------------------------------- +bool DoesFileExist( const char *pFilename, DWORD *pSize ) +{ + HANDLE hFile = CreateFile( pFilename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); + if ( hFile != INVALID_HANDLE_VALUE ) + { + if ( pSize ) + { + *pSize = GetFileSize( hFile, NULL ); + if ( *pSize == (DWORD)-1 ) + { + *pSize = 0; + } + } + + // exists + CloseHandle( hFile ); + return true; + } + + // not present + return false; +} + +//----------------------------------------------------------------------------- +// NormalizePath +// +//----------------------------------------------------------------------------- +void NormalizePath( char* path, bool forceToLower ) +{ + int i; + int srclen; + + srclen = strlen( path ); + for ( i=0; i<srclen; i++ ) + { + if ( path[i] == '/' ) + path[i] = '\\'; + else if ( forceToLower && ( path[i] >= 'A' && path[i] <= 'Z' ) ) + path[i] = path[i] - 'A' + 'a'; + } +} + +//----------------------------------------------------------------------------- +// DeleteAllFiles +// +//----------------------------------------------------------------------------- +void DeleteAllFiles( const char* pDirectory, int level, bool bRecurse ) +{ + HANDLE hFind; + WIN32_FIND_DATA findData; + char basepath[MAX_PATH]; + char searchpath[MAX_PATH]; + char filename[MAX_PATH]; + + TL_AddSeperatorToPath( (char*)pDirectory, basepath ); + strcpy( searchpath, basepath ); + strcat( searchpath, "*.*" ); + + hFind = FindFirstFile( searchpath, &findData ); + if ( hFind != INVALID_HANDLE_VALUE ) + { + do + { + if ( !stricmp( findData.cFileName, "." ) || !stricmp( findData.cFileName, ".." ) ) + { + continue; + } + + strcpy( filename, basepath ); + strcat( filename, findData.cFileName ); + NormalizePath( filename, false ); + + if ( findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) + { + if ( bRecurse ) + { + DeleteAllFiles( filename, level+1, true ); + RemoveDirectory( filename ); + continue; + } + } + + SetFileAttributes( filename, FILE_ATTRIBUTE_NORMAL ); + DeleteFile( filename ); + } + while ( FindNextFile( hFind, &findData ) ); + FindClose( hFind ); + } +} + +//----------------------------------------------------------------------------- +// GetXCompressedHeader +//----------------------------------------------------------------------------- +bool GetXCompressedHeader( const char *pFilename, xCompressHeader *pHeader ) +{ + HANDLE hFile = CreateFile( pFilename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL ); + if ( hFile != INVALID_HANDLE_VALUE ) + { + DWORD dwBytesRead = 0; + ReadFile( hFile, pHeader, sizeof( xCompressHeader ), &dwBytesRead, NULL ); + CloseHandle( hFile ); + if ( pHeader->nMagic == xCompressHeader::MAGIC && pHeader->nVersion == xCompressHeader::VERSION ) + { + // valid + return true; + } + } + + // invalid + return false; +} + +//----------------------------------------------------------------------------- +// IsTargetFileValid +// +// Optional non-zero expected source file size must matcg +//----------------------------------------------------------------------------- +bool IsTargetFileValid( const char *pFilename, DWORD dwSrcFileSize ) +{ + char mrkFilename[MAX_PATH]; + DWORD dwTargetFileSize = 0; + DWORD dwSize = 0; + DWORD dwAttributes; + + // all valid target files are non-zero + if ( !DoesFileExist( pFilename, &dwTargetFileSize ) || !dwTargetFileSize ) + { + return false; + } + + dwAttributes = GetFileAttributes( pFilename ); + if ( dwAttributes != (DWORD)-1 && ( dwAttributes & FILE_ATTRIBUTE_READONLY ) ) + { + // target files marked read only don't get overwritten + return true; + } + + // all valid target files must have marker file + // presence ensures file was successfully copied + strcpy( mrkFilename, pFilename ); + strcat( mrkFilename, ".mrk" ); + if ( !DoesFileExist( mrkFilename, NULL ) ) + { + // cannot rely on contents, regardless of size match + DeleteFile( pFilename ); + return false; + } + + if ( dwSrcFileSize && dwSrcFileSize != dwTargetFileSize ) + { + DeleteFile( pFilename ); + return false; + } + + // assume valid + return true; +} + +//----------------------------------------------------------------------------- +// Constructor for CXBoxLoader class +//----------------------------------------------------------------------------- +CXBoxLoader::CXBoxLoader() : CXBApplication() +{ + // need a persistent time base, use the RTC + // all other tick counters reset across relaunch + FILETIME fileTime; + GetSystemTimeAsFileTime( &fileTime ); + g_loaderStartTime = ((ULARGE_INTEGER*)&fileTime)->QuadPart; + + m_contextCode = 0; + m_pLastMovieFrame = NULL; + m_pVB = NULL; + m_bAllowAttractAbort = false; + m_numFiles = 0; + m_bLaunch = false; + m_dwLoading = 0; + m_bDrawLegal = false; + m_LegalTime = 0; + m_installThread = NULL; + m_State = 0; + m_bDrawLoading = false; + m_bDrawProgress = false; + m_bInstallComplete = false; + m_FrameCounter = 0; + m_MovieCount = 0; + m_bMovieErrorIsFatal = false; + m_bDrawDebug = false; + m_LoadingBarStartTime = 0; + m_LoadingBarEndTime = 0; + m_LegalStartTime = 0; + m_bCaptureLastMovieFrame = 0; + m_bDrawSlideShow = false; + m_SlideShowStartTime = 0; + m_pLogData = NULL; + m_pDefaultTrueTypeFont = NULL; +} + +//----------------------------------------------------------------------------- +// FatalMediaError +//----------------------------------------------------------------------------- +void CXBoxLoader::FatalMediaError() +{ + m_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 0x00000000, 1.0f, 0L ); + + LPDIRECT3DSURFACE8 pBackBuffer; + m_pd3dDevice->GetBackBuffer( 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer ); + + LPCWSTR pLine1; + LPCWSTR pLine2; + switch( XGetLanguage() ) + { + case XC_LANGUAGE_FRENCH: + pLine1 = L"Le disque utilis� pr�sente une anomalie."; + pLine2 = L"Il est peut-�tre sale ou endommag�."; + break; + case XC_LANGUAGE_ITALIAN: + pLine1 = L"Il disco in uso ha qualche problema."; + pLine2 = L"Potrebbe essere sporco o danneggiato."; + break; + case XC_LANGUAGE_GERMAN: + pLine1 = L"Bei der benutzten CD ist ein Problem aufgetreten."; + pLine2 = L"M�glicherweise ist sie verschmutzt oder besch�digt."; + break; + case XC_LANGUAGE_SPANISH: + pLine1 = L"Hay un problema con el disco que est� usando."; + pLine2 = L"Puede estar sucio o da�ado."; + break; + default: + pLine1 = L"There is a problem with the disc you are using."; + pLine2 = L"It may be dirty or damaged."; + break; + } + + if ( m_pDefaultTrueTypeFont ) + { + m_pDefaultTrueTypeFont->SetTextAlignment( XFONT_CENTER|XFONT_TOP ); + m_pDefaultTrueTypeFont->TextOut( pBackBuffer, pLine1, (unsigned)-1, 320, 240-15 ); + m_pDefaultTrueTypeFont->TextOut( pBackBuffer, pLine2, (unsigned)-1, 320, 240+15 ); + } + + // Present the scene + m_pd3dDevice->Present( NULL, NULL, NULL, NULL ); + + pBackBuffer->Release(); + + // forever + while (1); +} + +//----------------------------------------------------------------------------- +// LoadTexture +//----------------------------------------------------------------------------- +D3DTexture *CXBoxLoader::LoadTexture( int resourceID ) +{ + // Get access to the texture + return ( m_xprResource.GetTexture( resourceID ) ); +} + +//----------------------------------------------------------------------------- +// LoadFont +//----------------------------------------------------------------------------- +HRESULT CXBoxLoader::LoadFont( CXBFont *pFont, int resourceID ) +{ + return pFont->Create( m_xprResource.GetTexture( resourceID ), + m_xprResource.GetData( resourceID + sizeof(D3DTexture) ) ); +} + +//----------------------------------------------------------------------------- +// DrawRect +//----------------------------------------------------------------------------- +void CXBoxLoader::DrawRect( int x, int y, int w, int h, DWORD color ) +{ + // Set states + D3DDevice::SetTexture( 0, NULL ); + D3DDevice::SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_DISABLE ); + D3DDevice::SetRenderState( D3DRS_ZENABLE, FALSE ); + D3DDevice::SetRenderState( D3DRS_FOGENABLE, FALSE ); + D3DDevice::SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE ); + D3DDevice::SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID ); + D3DDevice::SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE ); + D3DDevice::SetRenderState( D3DRS_ALPHATESTENABLE, FALSE ); + D3DDevice::SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA ); + D3DDevice::SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA ); + D3DDevice::SetVertexShader( D3DFVF_XYZRHW|D3DFVF_DIFFUSE ); + + FLOAT fX1 = x; + FLOAT fY1 = y; + FLOAT fX2 = x + w - 1; + FLOAT fY2 = y + h - 1; + + D3DDevice::Begin( D3DPT_QUADLIST ); + D3DDevice::SetVertexDataColor( D3DVSDE_DIFFUSE, color ); + D3DDevice::SetVertexData4f( D3DVSDE_VERTEX, fX1, fY1, 1.0f, 1.0f ); + D3DDevice::SetVertexData4f( D3DVSDE_VERTEX, fX2, fY1, 1.0f, 1.0f ); + D3DDevice::SetVertexData4f( D3DVSDE_VERTEX, fX2, fY2, 1.0f, 1.0f ); + D3DDevice::SetVertexData4f( D3DVSDE_VERTEX, fX1, fY2, 1.0f, 1.0f ); + D3DDevice::End(); +} + + +//----------------------------------------------------------------------------- +// DrawTexture +//----------------------------------------------------------------------------- +void CXBoxLoader::DrawTexture( D3DTexture *pD3DTexture, int x, int y, int w, int h, int color ) +{ + struct VERTEX { D3DXVECTOR4 p; D3DCOLOR c; FLOAT tu, tv; }; + if ( !m_pVB ) + { + // Create a vertex buffer for rendering the help screen + D3DDevice::CreateVertexBuffer( 4*sizeof(VERTEX), D3DUSAGE_WRITEONLY, 0L, D3DPOOL_DEFAULT, &m_pVB ); + } + + VERTEX* v; + m_pVB->Lock( 0, 0, (BYTE**)&v, 0L ); + + // Calculate vertex positions + FLOAT fLeft = x + 0.5f; + FLOAT fTop = y + 0.5f; + FLOAT fRight = x+w - 0.5f; + FLOAT fBottom = y+h - 0.5f; + + // position + v[0].p = D3DXVECTOR4( fLeft, fTop, 0, 0 ); + v[1].p = D3DXVECTOR4( fRight, fTop, 0, 0 ); + v[2].p = D3DXVECTOR4( fRight, fBottom, 0, 0 ); + v[3].p = D3DXVECTOR4( fLeft, fBottom, 0, 0 ); + + // color + v[0].c = color; + v[1].c = color; + v[2].c = color; + v[3].c = color; + + D3DSURFACE_DESC desc; + pD3DTexture->GetLevelDesc( 0, &desc ); + + // linear texcoords + v[0].tu = 0; + v[0].tv = 0; + v[1].tu = desc.Width; + v[1].tv = 0; + v[2].tu = desc.Width; + v[2].tv = desc.Height; + v[3].tu = 0; + v[3].tv = desc.Height; + + m_pVB->Unlock(); + + // Set state to render the image + D3DDevice::SetTexture( 0, pD3DTexture ); + D3DDevice::SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE ); + D3DDevice::SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE ); + D3DDevice::SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE ); + D3DDevice::SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE ); + D3DDevice::SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE ); + D3DDevice::SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE ); + D3DDevice::SetTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP ); + D3DDevice::SetTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP ); + D3DDevice::SetTextureStageState( 0, D3DTSS_ADDRESSW, D3DTADDRESS_CLAMP ); + D3DDevice::SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR ); + D3DDevice::SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR ); + D3DDevice::SetRenderState( D3DRS_ZENABLE, FALSE ); + D3DDevice::SetRenderState( D3DRS_ZWRITEENABLE, FALSE ); + D3DDevice::SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_ALWAYS ); + D3DDevice::SetRenderState( D3DRS_FOGENABLE, FALSE ); + D3DDevice::SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_NONE ); + D3DDevice::SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID ); + D3DDevice::SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW ); + D3DDevice::SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE ); + D3DDevice::SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA ); + D3DDevice::SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA ); + D3DDevice::SetRenderState( D3DRS_ALPHATESTENABLE, FALSE ); + D3DDevice::SetVertexShader( D3DFVF_XYZRHW|D3DFVF_DIFFUSE|D3DFVF_TEX1 ); + + // Render the image + D3DDevice::SetStreamSource( 0, m_pVB, sizeof(VERTEX) ); + D3DDevice::DrawPrimitive( D3DPT_QUADLIST, 0, 1 ); +} + +//----------------------------------------------------------------------------- +// StartVideo +// +// May take a few ms. +//----------------------------------------------------------------------------- +HRESULT CXBoxLoader::StartVideo( const CHAR* strFilename, bool bFromMemory, bool bFatalOnError ) +{ + HRESULT hr; + if ( bFromMemory ) + { + // play from memory, so as no to interfere with disc access + hr = m_player.OpenMovieFromMemory( strFilename, D3DFMT_LIN_A8R8G8B8, m_pd3dDevice, TRUE ); + } + else + { + // play from disc + hr = m_player.OpenFile( strFilename, D3DFMT_LIN_A8R8G8B8, m_pd3dDevice, TRUE ); + } + + // can fail anytime + m_bMovieErrorIsFatal = bFatalOnError; + + m_MovieCount++; + + if ( FAILED( hr ) ) + { + OUTPUT_DEBUG_STRING( "Video playback failed!\n" ); + + if ( bFatalOnError ) + { + FatalMediaError(); + } + } + + return hr; +} + +//----------------------------------------------------------------------------- +// StopVideo +// +// May take a few ms. +//----------------------------------------------------------------------------- +void CXBoxLoader::StopVideo() +{ + m_player.TerminatePlayback(); +} + +//----------------------------------------------------------------------------- +// LoadInstallScript +// +// Parse filenames to be copied +//----------------------------------------------------------------------------- +bool CXBoxLoader::LoadInstallScript() +{ + void *pFileData = NULL; + DWORD fileSize = 0; + DWORD dwSrcSize; + HRESULT hr; + char srcFile[MAX_PATH]; + char dstFile[MAX_PATH]; + char localizedFile[MAX_PATH]; + HANDLE hFind; + char sourceFilename[MAX_PATH]; + char sourcePath[MAX_PATH]; + char targetFilename[MAX_PATH]; + char filename[MAX_PATH]; + WIN32_FIND_DATA findData; + bool bCompressed; + xCompressHeader xcHeader; + char *pVersion; + bool bTargetIsLocalized; + int languageID; + + memset( &g_installData, 0, sizeof( installData_t ) ); + + hr = XBUtil_LoadFile( "D:\\LoaderMedia\\install.txt", &pFileData, &fileSize ); + if ( hr != S_OK || !fileSize ) + { + return false; + } + + languageID = XGetLanguage(); + + // full re-install + bool bForce = true; + + // scan + TL_SetScriptData( (char*)pFileData, fileSize ); + while ( 1 ) + { + char *pToken = TL_GetToken( true ); + if ( !pToken || !pToken[0] ) + break; + StripQuotes( pToken ); + strcpy( srcFile, pToken); + + pToken = TL_GetToken( true ); + if ( !pToken || !pToken[0] ) + break; + StripQuotes( pToken ); + strcpy( dstFile, pToken); + + // replace with language token + FixupNamespaceFilename( srcFile, srcFile, languageID ); + bTargetIsLocalized = FixupNamespaceFilename( dstFile, localizedFile, languageID ); + + if ( bTargetIsLocalized ) + { + // localized files are allowed to change without requiring a full re-install + bool bDeleteMapCache = false; + if ( !IsTargetFileValid( localizedFile, 0 ) ) + { + // must delete map cache to ensure localized files have enough room + bDeleteMapCache = true; + } + + // only allowing one localized file of this type, delete all others + DeleteOtherLocalizedFiles( dstFile, languageID ); + strcpy( dstFile, localizedFile ); + + if ( bDeleteMapCache ) + { + char mapPath[MAX_PATH]; + strcpy( mapPath, localizedFile ); + TL_StripFilename( mapPath ); + TL_AddSeperatorToPath( mapPath, mapPath ); + strcat( mapPath, "maps\\" ); + DeleteAllFiles( mapPath, 0, false ); + } + } + + pVersion = strstr( dstFile, "version_" ); + if ( pVersion ) + { + if ( m_numFiles ) + { + // version statement out of sequence + return false; + } + + m_Version = atoi( pVersion + strlen( "version_" ) ); + + if ( IsTargetFileValid( dstFile, 0 ) ) + { + // version file exists, files should be same + bForce = false; + } + + if ( bForce ) + { + // delete all files at the specified directory + strcpy( targetFilename, dstFile ); + TL_StripFilename( targetFilename ); + DeleteAllFiles( targetFilename, 0, true ); + } + } + + // source file could be wildcard, get path only + strcpy( sourcePath, srcFile ); + TL_StripFilename( sourcePath ); + + hFind = FindFirstFile( srcFile, &findData ); + if ( hFind != INVALID_HANDLE_VALUE ) + { + do + { + if ( !stricmp( findData.cFileName, "." ) || !stricmp( findData.cFileName, ".." ) ) + { + continue; + } + if ( findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) + { + continue; + } + + TL_AddSeperatorToPath( sourcePath, sourceFilename ); + strcat( sourceFilename, findData.cFileName ); + NormalizePath( sourceFilename, false ); + + // target filename may be path or absolute file + strcpy( targetFilename, dstFile ); + + TL_StripPath( dstFile, filename ); + if ( !filename[0] ) + { + // target filename is path only + TL_AddSeperatorToPath( dstFile, targetFilename ); + strcat( targetFilename, findData.cFileName ); + NormalizePath( targetFilename, false ); + } + + if ( !DoesFileExist( sourceFilename, &dwSrcSize ) ) + { + // can't validate source + return false; + } + + if ( strstr( sourceFilename, ".xz_" ) && strstr( targetFilename, ".xzp" ) ) + { + bCompressed = true; + if ( GetXCompressedHeader( sourceFilename, &xcHeader ) ) + { + g_installData.m_totalSize += xcHeader.nUncompressedFileSize; + + if ( !bForce && IsTargetFileValid( targetFilename, xcHeader.nUncompressedFileSize ) ) + { + // target already exists, no need to recopy + g_copyStats.m_bytesCopied += xcHeader.nUncompressedFileSize; + continue; + } + } + else + { + // invalid + return false; + } + } + else + { + g_installData.m_totalSize += dwSrcSize; + + bCompressed = false; + if ( !bForce && IsTargetFileValid( targetFilename, dwSrcSize ) ) + { + // target already exists, no need to recopy + g_copyStats.m_bytesCopied += dwSrcSize; + continue; + } + } + + if ( m_numFiles < MAX_FILES ) + { + m_fileSrc[m_numFiles] = CopyString( sourceFilename ); + m_fileDest[m_numFiles] = CopyString( targetFilename ); + + if ( bCompressed ) + { + xCompressHeader *pxcHeader = new xCompressHeader; + memcpy( pxcHeader, &xcHeader, sizeof( xCompressHeader ) ); + m_fileCompressionHeaders[m_numFiles] = pxcHeader; + m_fileDestSizes[m_numFiles] = pxcHeader->nUncompressedFileSize; + } + else + { + m_fileCompressionHeaders[m_numFiles] = NULL; + m_fileDestSizes[m_numFiles] = dwSrcSize; + } + + m_numFiles++; + } + } + while ( FindNextFile( hFind, &findData ) ); + FindClose( hFind ); + } + else + { + // source file not found, invalid + return false; + } + } + + // finsihed with install script + free( pFileData ); + + g_installData.m_ppSrcFiles = m_fileSrc; + g_installData.m_ppDstFiles = m_fileDest; + g_installData.m_ppxcHeaders = m_fileCompressionHeaders; + g_installData.m_pDstFileSizes = m_fileDestSizes; + g_installData.m_numFiles = m_numFiles; + + return true; +} + +//----------------------------------------------------------------------------- +// Copies all install files to the hard drive +//----------------------------------------------------------------------------- +DWORD WINAPI InstallThreadFunc( LPVOID lpParam ) +{ + char mrkFilename[MAX_PATH]; + bool bSuccess; + HANDLE hFile; + + g_installStartTime = GetTickCount(); + + // started loading + *(DWORD*)lpParam = 1; + + for ( int i = 0; i < g_installData.m_numFiles; ++i ) + { + DWORD bytesCopied = g_copyStats.m_bytesCopied; + + // install has already validated, if it's in the list, copy it + bSuccess = CopyFileOverlapped( g_installData.m_ppSrcFiles[i], g_installData.m_ppDstFiles[i], g_installData.m_ppxcHeaders[i], &g_copyStats ); + + strcpy( mrkFilename, g_installData.m_ppDstFiles[i] ); + strcat( mrkFilename, ".mrk" ); + + SetFileAttributes( mrkFilename, FILE_ATTRIBUTE_NORMAL ); + if ( bSuccess ) + { + // add marker + hFile = CreateFile( mrkFilename, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); + if ( hFile != INVALID_HANDLE_VALUE ) + { + CloseHandle( hFile ); + } + } + else + { + // remove marker + DeleteFile( mrkFilename ); + DeleteFile( g_installData.m_ppDstFiles[i] ); + + // errors can't stop install + // snap progress to expected completion + g_copyStats.m_bytesCopied = bytesCopied + g_installData.m_pDstFileSizes[i]; + } + } + + g_installElapsedTime = GetTickCount() - g_installStartTime; + + // finished loading + *(DWORD*)lpParam = 0; + + return 0; +} + +//----------------------------------------------------------------------------- +// Verify disk space +//----------------------------------------------------------------------------- +bool CXBoxLoader::VerifyInstall( void ) +{ + memset( &g_copyStats, 0, sizeof( CopyStats_t ) ); + + LoadLogFile(); + + if ( !LoadInstallScript() ) + { + return false; + } + + return true; +} + +//----------------------------------------------------------------------------- +// Look for possible forensic log file +//----------------------------------------------------------------------------- +void CXBoxLoader::LoadLogFile( void ) +{ +#if defined( XBOX_FORENSIC_LOG ) + HRESULT hr; + char *pFileData = NULL; + DWORD fileSize = 0; + + hr = XBUtil_LoadFile( "Z:\\hl2fatal.log", (void**)&pFileData, &fileSize ); + if ( hr != S_OK || !fileSize ) + { + return; + } + + // copy and null terminate + m_pLogData = (char *)malloc( fileSize+1 ); + + int j = 0; + for (int i=0; i<(int)fileSize; i++) + { + if ( pFileData[i] == 0x0D ) + continue; + m_pLogData[j++] = pFileData[i]; + } + m_pLogData[j] = '\0'; + + free( pFileData ); +#endif +} + +//----------------------------------------------------------------------------- +// Starts installation to disk +//----------------------------------------------------------------------------- +bool CXBoxLoader::StartInstall( void ) +{ + // Start the install thread + m_installThread = CreateThread( NULL, 0, &InstallThreadFunc, &m_dwLoading, 0, 0 ); + if ( !m_installThread ) + { + // failed + return false; + } + + // success + return true; +} + +//----------------------------------------------------------------------------- +// Shows the legal text +//----------------------------------------------------------------------------- +void CXBoxLoader::StartLegalScreen( int legal ) +{ + m_bDrawLegal = true; + m_LegalTime = GetTickCount(); + m_LegalStartTime = 0; + + switch ( legal ) + { + case LEGAL_MAIN: + m_pLegalTexture = m_pMainLegalTexture; + break; + case LEGAL_SOURCE: + m_pLegalTexture = m_pSourceLegalTexture; + break; + } +} + +//----------------------------------------------------------------------------- +// DrawLegals +//----------------------------------------------------------------------------- +void CXBoxLoader::DrawLegals() +{ + unsigned int color; + float t; + + if ( !m_bDrawLegal ) + return; + + if ( !m_LegalStartTime ) + { + m_LegalStartTime = GetTickCount(); + } + + // fade legals + t = (float)(GetTickCount() - m_LegalStartTime)/LEGAL_DISPLAY_TIME; + if ( t < 0.1f ) + { + // fade up + color = LerpColor( 0xFF000000, 0xFFFFFFFF, t*10.0f ); + } + else if ( t < 0.9f ) + { + // hold + color = 0xFFFFFFFF; + } + else + { + // fade out + color = LerpColor( 0xFFFFFFFF, 0xFF000000, (t-0.9f)*10.0f ); + } + + DrawTexture( m_pLegalTexture, 0, 0, 640, 480, color ); +} + +//----------------------------------------------------------------------------- +// DrawSlideshow +//----------------------------------------------------------------------------- +void CXBoxLoader::DrawSlideshow() +{ + float t; + + if ( !m_bDrawSlideShow ) + return; + + if ( !m_SlideShowStartTime ) + { + m_SlideShowStartTime = GetTickCount(); + m_SlideShowCount = -1; + m_bFinalSlide = false; + } + + if ( !m_bInstallComplete && ( GetTickCount() - m_SlideShowStartTime > SLIDESHOW_SLIDETIME ) ) + { + // next slide + m_SlideShowCount++; + m_SlideShowStartTime = GetTickCount(); + } + + t = ( GetTickCount() - m_SlideShowStartTime )/(float)SLIDESHOW_FLIPTIME; + if ( t >= 1.0f ) + t = 1.0f; + + if ( m_bInstallComplete && !m_bFinalSlide && t >= 1.0f ) + { + // wait for current slide to complete + // final slide must transition back to transition screen + m_SlideShowStartTime = GetTickCount(); + m_bFinalSlide = true; + t = 0; + } + + if ( !m_bFinalSlide ) + { + // fade next slide in + unsigned int fadeInColor = LerpColor( 0x00FFFFFF, 0xFFFFFFFF, t ); + if ( fadeInColor != 0xFFFFFFFF && m_SlideShowCount != -1 ) + DrawTexture( m_pSlideShowTextures[m_SlideShowCount % MAX_SLIDESHOW_TEXTURES], 0, 0, 640, 480, 0xFFFFFFFF ); + DrawTexture( m_pSlideShowTextures[(m_SlideShowCount + 1) % MAX_SLIDESHOW_TEXTURES], 0, 0, 640, 480, fadeInColor ); + } + else + { + // fade last slide out + unsigned int fadeInColor = LerpColor( 0xFFFFFFFF, 0x00FFFFFF, t ); + DrawTexture( m_pSlideShowTextures[(m_SlideShowCount + 1) % MAX_SLIDESHOW_TEXTURES], 0, 0, 640, 480, fadeInColor ); + } + + if ( m_bInstallComplete && m_bFinalSlide && t >= 1.0f ) + { + // end of slideshow + m_bDrawSlideShow = false; + } +} + +//----------------------------------------------------------------------------- +// DrawDebug +//----------------------------------------------------------------------------- +void CXBoxLoader::DrawDebug() +{ +#ifndef _RETAIL + if ( !m_bDrawDebug ) + return; + + DrawRect( 0, 0, 640, 480, 0xC0000000 ); + + m_Font.Begin(); + m_Font.SetScaleFactors( 0.8f, 0.8f ); + + int xPos = SCREEN_WIDTH/2; + int yPos = SCREEN_HEIGHT/4; + float rate; + + wchar_t textBuffer[256]; + swprintf( textBuffer, L"Version: %d", m_Version ); + m_Font.DrawText( 40, 40, 0xffffffff, textBuffer, 0 ); + + wchar_t srcFilename[MAX_PATH]; + wchar_t dstFilename[MAX_PATH]; + ConvertToWideString( srcFilename, g_copyStats.m_srcFilename ); + ConvertToWideString( dstFilename, g_copyStats.m_dstFilename ); + swprintf( textBuffer, L"From: %s (%.2f MB)", srcFilename, (float)g_copyStats.m_readSize/(1024.0f*1024.0f) ); + m_Font.DrawText( xPos, yPos + 20, 0xffffffff, textBuffer, XBFONT_CENTER_X ); + swprintf( textBuffer, L"To: %s (%.2f MB)", dstFilename, (float)g_copyStats.m_writeSize/(1024.0f*1024.0f) ); + m_Font.DrawText( xPos, yPos + 40, 0xffffffff, textBuffer, XBFONT_CENTER_X ); + + if ( g_copyStats.m_bufferReadTime && m_dwLoading ) + rate = ( g_copyStats.m_bufferReadSize/(1024.0f*1024.0f) ) / ( g_copyStats.m_bufferReadTime * 0.001f ); + else + rate = 0; + swprintf( textBuffer, L"Buffer Read: %.2f MB (%.2f MB/s) (%d)", g_copyStats.m_bufferReadSize/(1024.0f*1024.0f), rate, g_copyStats.m_numReadBuffers ); + m_Font.DrawText( xPos, yPos + 80, 0xffffffff, textBuffer, XBFONT_CENTER_X ); + + rate = g_copyStats.m_inflateTime && m_dwLoading ? (float)g_copyStats.m_inflateSize/(g_copyStats.m_inflateTime * 0.001f) : 0; + swprintf( textBuffer, L"Inflate: %.2f MB (%.2f MB/s)", g_copyStats.m_inflateSize/(1024.0f*1024.0f), rate/(1024.0f*1024.0f) ); + m_Font.DrawText( xPos, yPos + 100, 0xffffffff, textBuffer, XBFONT_CENTER_X ); + + if ( g_copyStats.m_bufferWriteTime && m_dwLoading ) + rate = ( g_copyStats.m_bufferWriteSize/(1024.0f*1024.0f) ) / ( g_copyStats.m_bufferWriteTime * 0.001f ); + else + rate = 0; + swprintf( textBuffer, L"Buffer Write: %.2f MB (%.2f MB/s) (%d)", g_copyStats.m_bufferWriteSize/(1024.0f*1024.0f), rate, g_copyStats.m_numWriteBuffers ); + m_Font.DrawText( xPos, yPos + 120, 0xffffffff, textBuffer, XBFONT_CENTER_X ); + + rate = g_copyStats.m_totalReadTime && m_dwLoading ? (float)g_copyStats.m_totalReadSize/(g_copyStats.m_totalReadTime * 0.001f) : 0; + swprintf( textBuffer, L"Total Read: %d MB (%.2f MB/s)", g_copyStats.m_totalReadSize/(1024*1024), rate/(1024.0f*1024.0f) ); + m_Font.DrawText( xPos, yPos + 160, 0xffffffff, textBuffer, XBFONT_CENTER_X ); + + rate = g_copyStats.m_totalWriteTime && m_dwLoading ? (float)g_copyStats.m_totalWriteSize/(g_copyStats.m_totalWriteTime * 0.001f) : 0; + swprintf( textBuffer, L"Total Write: %d MB (%.2f MB/s)", g_copyStats.m_totalWriteSize/(1024*1024), rate/(1024.0f*1024.0f) ); + m_Font.DrawText( xPos, yPos + 180, 0xffffffff, textBuffer, XBFONT_CENTER_X ); + + float elapsed = (float)(GetTickCount() - g_installStartTime) * 0.001f; + if ( m_dwLoading ) + { + if ( elapsed ) + rate = g_copyStats.m_totalWriteSize/elapsed; + else + rate = 0; + } + else + { + if ( g_installElapsedTime ) + rate = g_copyStats.m_totalWriteSize/(g_installElapsedTime * 0.001f); + else + rate = 0; + } + swprintf( textBuffer, L"Progress: %d/%d MB Elapsed: %d secs (%.2f MB/s)", g_copyStats.m_bytesCopied/(1024*1024), g_installData.m_totalSize/(1024*1024), (int)elapsed, rate/(1024.0f*1024.0f) ); + m_Font.DrawText( xPos, yPos + 220, 0xffffffff, textBuffer, XBFONT_CENTER_X ); + + swprintf( textBuffer, L"Errors: %d", g_copyStats.m_copyErrors ); + m_Font.DrawText( xPos, yPos + 240, 0xffffffff, textBuffer, XBFONT_CENTER_X ); + + m_Font.End(); +#endif +} + +void CXBoxLoader::DrawLog() +{ +#if defined( XBOX_FORENSIC_LOG ) + wchar_t textBuffer[1024]; + int numChars; + + if ( !m_pLogData ) + return; + + DrawRect( 0, 0, 640, 480, 0xC0000000 ); + + m_Font.Begin(); + m_Font.SetScaleFactors( 0.8f, 0.8f ); + + char *pStart = m_pLogData; + char *pEnd = pStart; + int yPos = 40; + for (int i=0; i<20; i++) + { + pEnd = strstr( pStart, "\n" ); + if ( !pEnd ) + numChars = strlen( pStart ); + else + numChars = pEnd-pStart; + + if ( numChars ) + { + for (int j=0; j<numChars; j++) + { + textBuffer[j] = pStart[j]; + } + textBuffer[j] = 0; + m_Font.DrawText( 40, yPos, 0xffffffff, textBuffer, 0 ); + } + + if ( !pEnd ) + break; + + // next line + pStart = pEnd+1; + yPos += 10; + } + + m_Font.End(); +#endif +} + +//----------------------------------------------------------------------------- +// DrawLoadingMarquee +//----------------------------------------------------------------------------- +void CXBoxLoader::DrawLoadingMarquee() +{ + if ( !m_bDrawLoading ) + return; + + int y = 0.80f*480; + DrawTexture( m_pLoadingIconTexture, (640-64)/2, y-64, 64, 64, 0xFFFFFFFF ); + + // draw loading text + m_Font.Begin(); + m_Font.SetScaleFactors( 0.8f, 0.8f ); + m_Font.DrawText( 320, y, PROGRESS_TEXT_COLOR, GetLocalizedLoadingString(), XBFONT_CENTER_X ); + m_Font.End(); +} + +//----------------------------------------------------------------------------- +// DrawProgressBar +//----------------------------------------------------------------------------- +void CXBoxLoader::DrawProgressBar() +{ + if ( !m_bDrawProgress ) + return; + + if ( !m_LoadingBarStartTime ) + { + m_LoadingBarStartTime = GetTickCount(); + } + + // slide the loading bar up + float tUp = (float)(GetTickCount() - m_LoadingBarStartTime)/LOADINGBAR_UPTIME; + if ( tUp > 1.0f) + tUp = 1.0f; + float y = 480.0f + tUp*((float)PROGRESS_Y - 480.0f); + + float t0 = 0; + float t1 = 0; + int numSegments = 0; + if ( tUp == 1.0f ) + { + // loading bar is up + // don't snap, animate progress to current level of completion + t0 = (float)g_copyStats.m_bytesCopied/(float)g_installData.m_totalSize; + if ( t0 > 1.0f ) + t0 = 1.0f; + t1 = (float)(GetTickCount() - m_LoadingBarStartTime - LOADINGBAR_WAITTIME)/LOADINGBAR_SLIDETIME; + if ( t1 < 0.0f ) + t1 = 0.0f; + else if ( t1 > 1.0f) + t1 = 1.0f; + numSegments = t0 * t1 * (float)SEGMENT_COUNT; + } + +#if 0 + float tDown = 0; + if ( t0 == 1.0f && t1 == 1.0f && !m_dwLoading ) + { + // loading anim and copying of data are finished + // slide the loading bar down + if ( !m_LoadingBarEndTime ) + { + m_LoadingBarEndTime = GetTickCount(); + } + tDown = (float)(GetTickCount() - m_LoadingBarEndTime - LOADINGBAR_WAITTIME)/LOADINGBAR_UPTIME; + if ( tDown < 0.0f ) + tDown = 0.0f; + else if ( tDown > 1.0f) + tDown = 1.0f; + y = PROGRESS_Y + tDown*(480.0f - (float)PROGRESS_Y); + } + + if ( tDown == 1.0f ) + { + // loading bar is offscreen + m_bInstallComplete = true; + } +#else + if ( t0 == 1.0f && t1 == 1.0f && !m_dwLoading ) + { + m_bInstallComplete = true; + } +#endif + + int x = (640-FOOTER_W)/2; + DrawTexture( m_pFooterTexture, x, y, FOOTER_W, 480 - PROGRESS_Y, PROGRESS_FOOTER_COLOR ); + x += FOOTER_W - 35; + + // draw left justified loading text + m_Font.Begin(); + m_Font.SetScaleFactors( 0.8f, 0.8f ); + int textWidth = m_Font.GetTextWidth( GetLocalizedLoadingString() ); + x -= SEGMENT_W + textWidth; + m_Font.DrawText( x, y+20, PROGRESS_TEXT_COLOR, GetLocalizedLoadingString(), XBFONT_LEFT ); + m_Font.End(); + + // draw progess bar + x -= SEGMENT_W + PROGRESS_W; + DrawRect( x, y+25, PROGRESS_W, PROGRESS_H, PROGRESS_INSET_COLOR ); + for ( int i =0; i<numSegments; i++ ) + { + DrawRect( x, y+25+2, SEGMENT_W, PROGRESS_H-4, PROGRESS_SEGMENT_COLOR ); + x += SEGMENT_W+SEGMENT_GAP; + } + +} + +//----------------------------------------------------------------------------- +// Name: PlayVideoFrame() +// Desc: Plays one frame of video if a movie is currently open and if there is +// a frame available. This function is safe to call at any time. +//----------------------------------------------------------------------------- +BOOL CXBoxLoader::PlayVideoFrame() +{ + if ( !m_player.IsPlaying() ) + return FALSE; + + const FLOAT fMovieWidth = FLOAT( m_player.GetWidth() ); + const FLOAT fMovieHeight = FLOAT( m_player.GetHeight() ); + + // Move to the next frame. + LPDIRECT3DTEXTURE8 pTexture = 0; + pTexture = m_player.AdvanceFrameForTexturing( m_pd3dDevice ); + + // See if the movie is over now. + if ( !m_player.IsPlaying() ) + { + if ( m_bCaptureLastMovieFrame ) + { + m_bCaptureLastMovieFrame = false; + + // Copy Texture + if ( m_pLastMovieFrame ) + { + m_pLastMovieFrame->Release(); + m_pLastMovieFrame = NULL; + } + + if ( pTexture ) + { + // copy the last frame + D3DSURFACE_DESC d3dSurfaceDesc; + D3DLOCKED_RECT srcRect; + D3DLOCKED_RECT dstRect; + pTexture->GetLevelDesc( 0, &d3dSurfaceDesc ); + m_pd3dDevice->CreateTexture( d3dSurfaceDesc.Width, d3dSurfaceDesc.Height, 0, 0, d3dSurfaceDesc.Format, 0, &m_pLastMovieFrame ); + pTexture->LockRect( 0, &srcRect, NULL, D3DLOCK_READONLY | D3DLOCK_NOOVERWRITE ); + m_pLastMovieFrame->LockRect( 0, &dstRect, NULL, D3DLOCK_READONLY | D3DLOCK_NOOVERWRITE ); + memcpy( dstRect.pBits, srcRect.pBits, srcRect.Pitch*d3dSurfaceDesc.Height ); + } + } + + // Clean up the movie, then return. + m_player.Destroy(); + return FALSE; + } + + // If no texture is ready, return TRUE to indicate that a movie is playing, + // but don't render anything yet. + if ( !pTexture ) + return TRUE; + + const FLOAT fSizeY = 480.0f; + const FLOAT fOriginX = 320.0f - ( fSizeY * .5f * fMovieWidth / fMovieHeight ); + const FLOAT fOriginY = 240.0f - fSizeY * .5f; + + // Draw the texture. + m_pd3dDevice->SetRenderState( D3DRS_FILLMODE, D3DFILL_SOLID ); + m_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_CCW ); + m_pd3dDevice->SetRenderState( D3DRS_ZENABLE, FALSE ); + + // Draw the texture as a quad. + m_pd3dDevice->SetTexture( 0, pTexture ); + m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1 ); + m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE ); + + // Wrapping isn't allowed on linear textures. + m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP ); + m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ADDRESSV, D3DTADDRESS_CLAMP ); + + FLOAT fLeft = fOriginX + 0.5f; + FLOAT fRight = fOriginX + ( fSizeY * fMovieWidth) / fMovieHeight - 0.5f; + FLOAT fTop = fOriginY + 0.5f; + FLOAT fBottom = fOriginY + fSizeY - 0.5f; + + // On linear textures the texture coordinate range is from 0,0 to width,height, instead + // of 0,0 to 1,1. + m_pd3dDevice->SetVertexShader( D3DFVF_XYZRHW|D3DFVF_TEX1 ); + m_pd3dDevice->Begin( D3DPT_QUADLIST ); + m_pd3dDevice->SetVertexData2f( D3DVSDE_TEXCOORD0, 0, fMovieHeight ); + m_pd3dDevice->SetVertexData4f( D3DVSDE_VERTEX, fLeft, fBottom, 0.0f, 1.0f ); + m_pd3dDevice->SetVertexData2f( D3DVSDE_TEXCOORD0, 0, 0 ); + m_pd3dDevice->SetVertexData4f( D3DVSDE_VERTEX, fLeft, fTop, 0.0f, 1.0f ); + m_pd3dDevice->SetVertexData2f( D3DVSDE_TEXCOORD0, fMovieWidth, 0 ); + m_pd3dDevice->SetVertexData4f( D3DVSDE_VERTEX, fRight, fTop, 0.0f, 1.0f ); + m_pd3dDevice->SetVertexData2f( D3DVSDE_TEXCOORD0, fMovieWidth, fMovieHeight ); + m_pd3dDevice->SetVertexData4f( D3DVSDE_VERTEX, fRight, fBottom, 0.0f, 1.0f ); + m_pd3dDevice->End(); + + return TRUE; +} + +//----------------------------------------------------------------------------- +// LaunchHL2 +//----------------------------------------------------------------------------- +void CXBoxLoader::LaunchHL2( unsigned int contextCode ) +{ + LAUNCH_DATA launchData; + RelaunchHeader_t *pRelaunch; + const char *pHL2Name; + + memset( &launchData, 0, sizeof( LAUNCH_DATA ) ); + + // build the relaunch structure that HL2 uses + pRelaunch = GetRelaunchHeader( launchData.Data ); + + pRelaunch->magicNumber = RELAUNCH_MAGIC_NUMBER; + pRelaunch->nBytesRelaunchData = 0; + + if ( ( contextCode & CONTEXTCODE_MAGICMASK ) == CONTEXTCODE_HL2MAGIC ) + { + // ok to re-establish persistent data + pRelaunch->bRetail = (contextCode & CONTEXTCODE_RETAIL_MODE) > 0; + pRelaunch->bInDebugger = (contextCode & CONTEXTCODE_INDEBUGGER) > 0; + } + else + { + // ensure we launch under retail conditions + contextCode = CONTEXTCODE_NO_XBDM; + g_activeDevice = -1; + pRelaunch->bRetail = true; + pRelaunch->bInDebugger = false; + } + + pRelaunch->contextCode = contextCode; + pRelaunch->activeDevice = g_activeDevice; + pRelaunch->startTime = g_loaderStartTime; + + // launch the xbe that is expected + if ( contextCode & CONTEXTCODE_DEBUG_XBE ) + { + // debug xbe + pHL2Name = "D:\\hl2d_xbox.xbe"; + } + else if ( contextCode & CONTEXTCODE_RELEASE_XBE ) + { + // release xbe + pHL2Name = "D:\\hl2r_xbox.xbe"; + } + else + { + // default launch to retail xbe + pHL2Name = "D:\\hl2_xbox.xbe"; + } + + XLaunchNewImage( pHL2Name, &launchData ); + + // failed + FatalMediaError(); +} + +//----------------------------------------------------------------------------- +// Performs initialization +//----------------------------------------------------------------------------- +HRESULT CXBoxLoader::Initialize() +{ + DWORD launchType; + LAUNCH_DATA launchData; + + // no active device until set + g_activeDevice = -1; + + // get launch info and command line params needed for early setting of systems + LPSTR pCmdLine = ""; + DWORD retVal = XGetLaunchInfo( &launchType, &launchData ); + if ( retVal == ERROR_SUCCESS ) + { + if ( launchType == LDT_FROM_DASHBOARD ) + { + // launched from dashboard + LD_FROM_DASHBOARD *pLaunchFromDashboard = (LD_FROM_DASHBOARD *)(&launchData); + m_contextCode = pLaunchFromDashboard->dwContext; + } + else if ( launchType == LDT_TITLE ) + { + // launched directly from HL2 to do something + LAUNCH_DATA* pLaunchData = (LAUNCH_DATA *)(&launchData); + pCmdLine = (char *)pLaunchData->Data; + + RelaunchHeader_t *pHeader = GetRelaunchHeader( pLaunchData->Data ); + if ( pHeader->magicNumber == RELAUNCH_MAGIC_NUMBER ) + { + m_contextCode = pHeader->contextCode; + g_activeDevice = pHeader->activeDevice; + } + } + else if ( launchType == LDT_FROM_DEBUGGER_CMDLINE ) + { + // launched from the debugger + LAUNCH_DATA* pLaunchData = (LAUNCH_DATA *)(&launchData); + pCmdLine = (char *)pLaunchData->Data; + strlwr( pCmdLine ); + + // assume retail mode + m_contextCode |= CONTEXTCODE_HL2MAGIC; + m_contextCode |= CONTEXTCODE_RETAIL_MODE; + + if ( strstr( pCmdLine, "-indebugger" ) ) + { + m_contextCode |= CONTEXTCODE_INDEBUGGER; + } +#ifndef _RETAIL + if ( DmIsDebuggerPresent() ) + { + m_contextCode |= CONTEXTCODE_INDEBUGGER; + } +#endif + if ( strstr( pCmdLine, "-debug" ) ) + { + // launch to debug xbe + m_contextCode |= CONTEXTCODE_DEBUG_XBE; + } + else if ( strstr( pCmdLine, "-release" ) ) + { + // launch to release xbe + m_contextCode |= CONTEXTCODE_RELEASE_XBE; + } + else + { + // default launch to retail xbe + m_contextCode |= CONTEXTCODE_RETAIL_XBE|CONTEXTCODE_NO_XBDM; + if ( strstr( pCmdLine, "-dev" ) ) + { + // force dev link + m_contextCode &= ~CONTEXTCODE_NO_XBDM; + } + } + + if ( strstr( pCmdLine, "-attract" ) ) + { + // running the attract sequence + m_contextCode |= CONTEXTCODE_ATTRACT; + } + } + } + + if ( ( m_contextCode & CONTEXTCODE_MAGICMASK ) != CONTEXTCODE_HL2MAGIC ) + { + // unknown, run the install normally + // 0 is a special indicator, due to lack of valid magic + m_contextCode = 0; + } + else + { + if ( m_contextCode & CONTEXTCODE_DASHBOARD ) + { + // coming from dashboard, back to HL2 - immediately! + LaunchHL2( m_contextCode ); + return S_OK; + } + } + + if ( FAILED( XFONT_OpenDefaultFont( &m_pDefaultTrueTypeFont ) ) ) + { + return XBAPPERR_MEDIANOTFOUND; + } + + // load install resources for context + // Load resource file + if ( FAILED( m_xprResource.Create( "D:\\LoaderMedia\\loader.xpr" ) ) ) + { + return XBAPPERR_MEDIANOTFOUND; + } + + if ( FAILED( LoadFont( &m_Font, loader_Font_OFFSET ) ) ) + { + return XBAPPERR_MEDIANOTFOUND; + } + + if ( !( m_contextCode & CONTEXTCODE_ATTRACT ) ) + { + m_pFooterTexture = LoadTexture( loader_Footer_OFFSET ); + if ( !m_pFooterTexture ) + { + return XBAPPERR_MEDIANOTFOUND; + } + + switch( XGetLanguage() ) + { + case XC_LANGUAGE_FRENCH: + m_pMainLegalTexture = LoadTexture( loader_MainLegal_french_OFFSET ); + break; + case XC_LANGUAGE_ITALIAN: + m_pMainLegalTexture = LoadTexture( loader_MainLegal_italian_OFFSET ); + break; + case XC_LANGUAGE_GERMAN: + m_pMainLegalTexture = LoadTexture( loader_MainLegal_german_OFFSET ); + break; + case XC_LANGUAGE_SPANISH: + m_pMainLegalTexture = LoadTexture( loader_MainLegal_spanish_OFFSET ); + break; + default: + m_pMainLegalTexture = LoadTexture( loader_MainLegal_english_OFFSET ); + break; + } + if ( !m_pMainLegalTexture ) + { + return XBAPPERR_MEDIANOTFOUND; + } + + m_pSourceLegalTexture = LoadTexture( loader_SourceLegal_OFFSET ); + if ( !m_pSourceLegalTexture ) + { + return XBAPPERR_MEDIANOTFOUND; + } + + switch( XGetLanguage() ) + { + case XC_LANGUAGE_FRENCH: + m_pSlideShowTextures[0] = LoadTexture( loader_SlideShow1_french_OFFSET ); + break; + case XC_LANGUAGE_ITALIAN: + m_pSlideShowTextures[0] = LoadTexture( loader_SlideShow1_italian_OFFSET ); + break; + case XC_LANGUAGE_GERMAN: + m_pSlideShowTextures[0] = LoadTexture( loader_SlideShow1_german_OFFSET ); + break; + case XC_LANGUAGE_SPANISH: + m_pSlideShowTextures[0] = LoadTexture( loader_SlideShow1_spanish_OFFSET ); + break; + default: + m_pSlideShowTextures[0] = LoadTexture( loader_SlideShow1_english_OFFSET ); + break; + } + m_pSlideShowTextures[1] = LoadTexture( loader_SlideShow2_OFFSET ); + m_pSlideShowTextures[2] = LoadTexture( loader_SlideShow3_OFFSET ); + m_pSlideShowTextures[3] = LoadTexture( loader_SlideShow4_OFFSET ); + m_pSlideShowTextures[4] = LoadTexture( loader_SlideShow5_OFFSET ); + m_pSlideShowTextures[5] = LoadTexture( loader_SlideShow6_OFFSET ); + m_pSlideShowTextures[6] = LoadTexture( loader_SlideShow7_OFFSET ); + m_pSlideShowTextures[7] = LoadTexture( loader_SlideShow8_OFFSET ); + m_pSlideShowTextures[8] = LoadTexture( loader_SlideShow9_OFFSET ); + for ( int i=0; i<MAX_SLIDESHOW_TEXTURES; i++ ) + { + if ( !m_pSlideShowTextures ) + return XBAPPERR_MEDIANOTFOUND; + } + + if ( !VerifyInstall() ) + { + OUTPUT_DEBUG_STRING( "Install failed!\n" ); + return -1; + } + } + + m_pLoadingIconTexture = LoadTexture( loader_LoadingIcon_OFFSET ); + if ( !m_pLoadingIconTexture ) + { + return XBAPPERR_MEDIANOTFOUND; + } + + return S_OK; +} + +//----------------------------------------------------------------------------- +// Performs per-frame video checks +//----------------------------------------------------------------------------- +void CXBoxLoader::TickVideo() +{ + if ( m_bMovieErrorIsFatal && m_player.IsFailed() ) + { + FatalMediaError(); + } +} + +//----------------------------------------------------------------------------- +// Performs per-frame updates +//----------------------------------------------------------------------------- +HRESULT CXBoxLoader::FrameMove() +{ + bool bFailed = false; + + TickVideo(); + + if ( m_State >= 10 && g_copyStats.m_copyErrors ) + { + FatalMediaError(); + } + + if ( m_State >= 10 && ( m_DefaultGamepad.wPressedButtons & XINPUT_GAMEPAD_START ) ) + { + m_bDrawDebug ^= 1; + } + + if ( m_bAllowAttractAbort && ( m_DefaultGamepad.bPressedAnalogButtons[XINPUT_GAMEPAD_A] || ( m_DefaultGamepad.wPressedButtons & XINPUT_GAMEPAD_START ) ) ) + { + StopVideo(); + + // allow only once, until reset + m_bAllowAttractAbort = false; + } + + switch ( m_State ) + { + case 0: + if ( m_contextCode & CONTEXTCODE_ATTRACT ) + { + // play attract mode + m_State = 1; + } + else + { + // normal installation + m_State = 9; + } + break; + + case 1: + // Play the attract video + if ( FAILED( StartVideo( "D:\\LoaderMedia\\Demo_Attract.xmv", false, false ) ) ) + { + // jump to finish + m_State = 4; + } + else + { + m_State = 2; + } + break; + + case 2: + if ( m_player.IsPlaying() || m_player.IsFailed() ) + { + // attract is playing, wait for finish + m_State = 3; + m_bAllowAttractAbort = true; + } + break; + + case 3: + if ( !m_player.IsPlaying() || m_player.IsFailed() ) + { + // attract is over or aborted + m_State = 4; + } + break; + + case 4: + // place loading + m_bDrawLoading = true; + m_FrameCounter = 0; + m_State = 5; + break; + + case 5: + // wait for two frames to pass to ensure loading is rendered + if ( m_FrameCounter > 2 ) + { + m_bLaunch = true; + m_State = 6; + } + break; + + case 6: + // idle + m_State = 6; + break; + + case 9: + // Play the opening Valve video + StartVideo( "D:\\LoaderMedia\\Valve_Leader.xmv", true, true ); + + // Start the async installation process + if ( !StartInstall() ) + { + OUTPUT_DEBUG_STRING( "Install failed!\n" ); + bFailed = true; + break; + } + m_State = 10; + break; + + case 10: + if ( m_player.IsPlaying() ) + { + // intro is playing, wait for finish + m_State = 15; + } + break; + + case 15: + if ( !m_player.IsPlaying() ) + { + // intro is over + m_State = 20; + } + break; + + case 20: + // start legals + StartLegalScreen( LEGAL_SOURCE ); + m_State = 25; + break; + + case 25: + if ( m_bDrawLegal && GetTickCount() - m_LegalTime > LEGAL_DISPLAY_TIME ) + { + // advance to next legal + StartLegalScreen( LEGAL_MAIN ); + m_State = 30; + } + break; + + case 30: + if ( m_bDrawLegal && GetTickCount() - m_LegalTime > LEGAL_DISPLAY_TIME ) + { + // end of all legals + if ( IsTargetFileValid( "Z:\\LoaderMedia\\Title_Load.xmv", 0 ) ) + { + m_bDrawLegal = false; + m_State = 40; + } + } + break; + + case 40: + // play the gordon/alyx hl2 game movie + m_bCaptureLastMovieFrame = true; + StartVideo( "Z:\\LoaderMedia\\Title_Load.xmv", true, true ); + m_State = 50; + break; + + case 50: + if ( m_player.IsPlaying() ) + { + // title movie is playing, wait for finish + m_State = 60; + } + break; + + case 60: + if ( m_player.GetElapsedTime() >= 8000 && !m_bDrawProgress ) + { + // wait for known audio click, then put up progress bar + // start the loading bar animation + m_bDrawProgress = true; + } + + if ( m_bInstallComplete && m_bDrawProgress ) + { + // install has completed + if ( m_player.IsPlaying() ) + { + // force the movie to end + m_player.TerminatePlayback(); + } + m_State = 70; + } + else if ( !m_bInstallComplete && !m_player.IsPlaying() ) + { + // intro movie has finished, but install is still running + // start up slideshow cycler + m_bDrawSlideShow = true; + m_State = 70; + } + break; + + case 70: + // wait for movie or slideshow to stop + if ( !m_player.IsPlaying() && !m_bDrawSlideShow ) + { + m_bLaunch = true; + m_State = 80; + } + break; + + case 80: + // idle + break; + } + + + if ( bFailed ) + { + FatalMediaError(); + } + + return S_OK; +} + +//----------------------------------------------------------------------------- +// Renders the scene +//----------------------------------------------------------------------------- +HRESULT CXBoxLoader::Render() +{ + m_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 0x00000000, 1.0f, 0L ); + + // Play a frame from a video. + BOOL bPlayedFrame = PlayVideoFrame(); + + // hold the last frame of the title movie + if ( m_State >= 60 && !bPlayedFrame ) + { + DrawTexture( m_pLastMovieFrame, 0, 0, 640, 480, 0xFFFFFFFF ); + } + + DrawSlideshow(); + DrawLoadingMarquee(); + DrawProgressBar(); + DrawLegals(); + DrawDebug(); + DrawLog(); + + if ( m_bLaunch ) + { + // The installation has finished + // Persist the image before launching hl2 + m_pd3dDevice->Present( NULL, NULL, NULL, NULL ); + m_pd3dDevice->PersistDisplay(); + + // Make sure the installation thread has completely exited + if ( m_installThread ) + { + WaitForSingleObject( m_installThread, INFINITE ); + CloseHandle( m_installThread ); + } + + LaunchHL2( m_contextCode ); + return S_OK; + } + + // Present the scene + m_pd3dDevice->Present( NULL, NULL, NULL, NULL ); + + m_FrameCounter++; + + return S_OK; +} + +//----------------------------------------------------------------------------- +// Entry point to the program. +//----------------------------------------------------------------------------- +VOID __cdecl main() +{ + CXBoxLoader xbApp; + if ( FAILED( xbApp.Create() ) ) + { + xbApp.FatalMediaError(); + } + xbApp.Run(); +} + diff --git a/utils/xbox/xbox_loader/xbox_loader.h b/utils/xbox/xbox_loader/xbox_loader.h new file mode 100644 index 0000000..b37b2d5 --- /dev/null +++ b/utils/xbox/xbox_loader/xbox_loader.h @@ -0,0 +1,171 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// XBOX_LOADER.H +// +// Master Include +//=====================================================================================// + +#pragma once + +#include <xtl.h> +#include <XBApp.h> +#include <XBFont.h> +#include <XBHelp.h> +#include <xgraphics.h> +#include <xfont.h> +#include <xmv.h> +#include <xbdm.h> +#include <math.h> +#include "XBResource.h" +#include "xmvhelper.h" +#include "toollib.h" +#include "scriplib.h" +#include "loader.h" +#include "jcalg1.h" +#include "xbox/xbox_launch.h" + +#define XBOX_FORENSIC_LOG + +#define SCREEN_WIDTH 640 +#define SCREEN_HEIGHT 480 +#define MAX_FILES 500 +#define MAX_SLIDESHOW_TEXTURES 9 + +#define LEGAL_DISPLAY_TIME 6000 +#define LOADINGBAR_UPTIME 500.0f // slid up or down +#define LOADINGBAR_SLIDETIME 1500.0f // progress speed +#define LOADINGBAR_WAITTIME 500.0f // delay after up to begin slide +#define SLIDESHOW_SLIDETIME 7000 +#define SLIDESHOW_FLIPTIME 1000 + +#define LEGAL_MAIN 0 +#define LEGAL_SOURCE 1 + +#define FOOTER_W 512 + +#define SEGMENT_W 10 +#define SEGMENT_GAP 1 +#define SEGMENT_COUNT 26 + +#define PROGRESS_Y 405 +#define PROGRESS_W (SEGMENT_COUNT*(SEGMENT_W+SEGMENT_GAP)) +#define PROGRESS_H 15 +#define PROGRESS_X 124 + +#define PROGRESS_FOOTER_COLOR 0x88FFFFFF +#define PROGRESS_INSET_COLOR 0xFF222222 +#define PROGRESS_SEGMENT_COLOR 0xFFCC6C00 +#define PROGRESS_TEXT_COLOR 0xFFFFFFFF + +//----------------------------------------------------------------------------- +// Main class to run this application. Most functionality is inherited +// from the CXBApplication base class. +//----------------------------------------------------------------------------- +class CXBoxLoader : public CXBApplication +{ +public: + CXBoxLoader(); + + virtual HRESULT Initialize( void ); + virtual HRESULT Render( void ); + virtual HRESULT FrameMove( void ); + + void DrawRect( int x, int y, int w, int h, DWORD color ); + void DrawLegals(); + void DrawDebug(); + BOOL PlayVideoFrame(); + HRESULT StartVideo( const CHAR* strFilename, bool bFromMemory, bool bFatalOnError ); + void StopVideo(); + bool StartInstall( void ); + bool LoadInstallScript( void ); + D3DTexture *LoadTexture( int resourceID ); + HRESULT LoadFont( CXBFont *pFont, int resourceID ); + void DrawTexture( D3DTexture *pD3DTexture, int x, int y, int w, int h, int color ); + void StartLegalScreen( int legal ); + void DrawProgressBar(); + void DrawLoadingMarquee(); + void DrawSlideshow(); + bool VerifyInstall(); + void StartDashboard( bool bGotoMemory ); + void LoadLogFile(); + void DrawLog(); + void FatalMediaError(); + void LaunchHL2( unsigned int contextCode ); + void TickVideo(); + +private: + IDirect3DTexture8 *m_pLastMovieFrame; + D3DTexture *m_pFooterTexture; + D3DTexture *m_pLoadingIconTexture; + D3DTexture *m_pMainLegalTexture; + D3DTexture *m_pSourceLegalTexture; + D3DTexture *m_pLegalTexture; + D3DTexture *m_pSlideShowTextures[MAX_SLIDESHOW_TEXTURES]; + + CXMVPlayer m_player; + + D3DVertexBuffer *m_pVB; + CXBPackedResource m_xprResource; + + CXBFont m_Font; + + int m_contextCode; + + char *m_fileSrc[MAX_FILES]; + char *m_fileDest[MAX_FILES]; + xCompressHeader *m_fileCompressionHeaders[MAX_FILES]; + DWORD m_fileDestSizes[MAX_FILES]; + int m_numFiles; + + bool m_bAllowAttractAbort; + bool m_bDrawLoading; + bool m_bDrawProgress; + bool m_bDrawDebug; + bool m_bLaunch; + DWORD m_dwLoading; + bool m_bDrawLegal; + HANDLE m_installThread; + DWORD m_LegalTime; + int m_State; + DWORD m_LoadingBarStartTime; + DWORD m_LoadingBarEndTime; + DWORD m_LegalStartTime; + bool m_bInstallComplete; + int m_Version; + int m_FrameCounter; + int m_MovieCount; + bool m_bMovieErrorIsFatal; + bool m_bCaptureLastMovieFrame; + DWORD m_SlideShowStartTime; + bool m_bDrawSlideShow; + int m_SlideShowCount; + bool m_bFinalSlide; + char *m_pLogData; + XFONT* m_pDefaultTrueTypeFont; +}; + +struct CopyStats_t +{ + char m_srcFilename[MAX_PATH]; + char m_dstFilename[MAX_PATH]; + DWORD m_readSize; + DWORD m_writeSize; + DWORD m_bytesCopied; + DWORD m_totalReadTime; + DWORD m_totalWriteTime; + DWORD m_totalReadSize; + DWORD m_totalWriteSize; + DWORD m_bufferReadSize; + DWORD m_bufferWriteSize; + DWORD m_bufferReadTime; + DWORD m_bufferWriteTime; + DWORD m_inflateSize; + DWORD m_inflateTime; + DWORD m_copyTime; + DWORD m_copyErrors; + DWORD m_numReadBuffers; + DWORD m_numWriteBuffers; +}; + +extern bool CopyFileOverlapped( const char *pSrc, const char *pDest, xCompressHeader *pxcHeader, CopyStats_t *pCopyStats ); +extern bool CreateFilePath( const char *inPath ); diff --git a/utils/xbox/xbox_loader/xbox_loader.sln b/utils/xbox/xbox_loader/xbox_loader.sln new file mode 100644 index 0000000..e702a04 --- /dev/null +++ b/utils/xbox/xbox_loader/xbox_loader.sln @@ -0,0 +1,24 @@ +Microsoft Visual Studio Solution File, Format Version 8.00 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "xbox_loader", "xbox_loader.vcproj", "{652C7D60-BC02-4E09-96DD-9300FFFF3403}" + ProjectSection(ProjectDependencies) = postProject + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfiguration) = preSolution + Debug_XBox = Debug_XBox + Release_XBox = Release_XBox + Retail_XBox = Retail_XBox + EndGlobalSection + GlobalSection(ProjectConfiguration) = postSolution + {652C7D60-BC02-4E09-96DD-9300FFFF3403}.Debug_XBox.ActiveCfg = Debug_XBox|Xbox + {652C7D60-BC02-4E09-96DD-9300FFFF3403}.Debug_XBox.Build.0 = Debug_XBox|Xbox + {652C7D60-BC02-4E09-96DD-9300FFFF3403}.Release_XBox.ActiveCfg = Release_XBox|Xbox + {652C7D60-BC02-4E09-96DD-9300FFFF3403}.Release_XBox.Build.0 = Release_XBox|Xbox + {652C7D60-BC02-4E09-96DD-9300FFFF3403}.Retail_XBox.ActiveCfg = Retail_XBox|Xbox + {652C7D60-BC02-4E09-96DD-9300FFFF3403}.Retail_XBox.Build.0 = Retail_XBox|Xbox + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + EndGlobalSection + GlobalSection(ExtensibilityAddIns) = postSolution + EndGlobalSection +EndGlobal diff --git a/utils/xbox/xbox_loader/xbox_loader.vcproj b/utils/xbox/xbox_loader/xbox_loader.vcproj new file mode 100644 index 0000000..f4a3fef --- /dev/null +++ b/utils/xbox/xbox_loader/xbox_loader.vcproj @@ -0,0 +1,366 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="7.10" + Name="xbox_loader" + ProjectGUID="{652C7D60-BC02-4E09-96DD-9300FFFF3403}" + RootNamespace="xbox_loader" + SccProjectName="" + SccLocalPath=""> + <Platforms> + <Platform + Name="Xbox"/> + </Platforms> + <Configurations> + <Configuration + Name="Debug_XBox|Xbox" + OutputDirectory=".\Debug_XBox" + IntermediateDirectory=".\Debug_XBox" + ConfigurationType="1" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="FALSE"> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + OptimizeForProcessor="2" + AdditionalIncludeDirectories="..\..\..\public;..\..\..\common;..\Common\include;..\toollib" + PreprocessorDefinitions="_USE_XGMATH,_XBOX,XBOX_SAMPLE,_DEBUG," + ExceptionHandling="FALSE" + RuntimeLibrary="1" + EnableEnhancedInstructionSet="1" + UsePrecompiledHeader="0" + PrecompiledHeaderThrough="xtl.h" + PrecompiledHeaderFile="$(IntDir)/apploader.pch" + AssemblerListingLocation="$(IntDir)/" + ObjectFile="$(IntDir)/" + ProgramDataBaseFileName="$(IntDir)/" + WarningLevel="3" + SuppressStartupBanner="TRUE" + DebugInformationFormat="4" + CompileAs="0" + DisableSpecificWarnings="4244"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + AdditionalOptions="/MACHINE:I386 /FIXED:NO" + AdditionalDependencies="xperf.lib xbdm.lib xapilibd.lib d3d8d.lib d3dx8d.lib xmv.lib xgraphicsd.lib dsoundd.lib xboxkrnl.lib" + OutputFile="$(OutDir)/xbox_loader.exe" + LinkIncremental="2" + SuppressStartupBanner="TRUE" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile="$(OutDir)/xbox_loader.pdb" + GenerateMapFile="TRUE"/> + <Tool + Name="VCPostBuildEventTool" + Description="Copying LoaderMedia to \\Fileserver" + CommandLine="copy LoaderMedia\*.* \\FileServer\user\XBox\DVD\LoaderMedia + +"/> + <Tool + Name="VCPreBuildEventTool" + CommandLine="bundler LoaderMedia_Source\loader_icon.rdf -o LoaderMedia_Source\loader_icon.xbx"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="XboxDeploymentTool" + RemotePath="xe:\hl2\default.xbe" + AdditionalFiles=""/> + <Tool + Name="XboxImageTool" + StackSize="0x10000" + IncludeDebugInfo="TRUE" + LimitAvailableMemoryTo64MB="TRUE" + SuppressStartupBanner="TRUE" + NoLibWarn="TRUE" + TitleID="0x45410091" + TitleName="Half - Life 2 (Debug Build)" + TitleImage="LoaderMedia_Source\loader_icon.xbx" + XBEVersion="4096"/> + </Configuration> + <Configuration + Name="Release_XBox|Xbox" + OutputDirectory="$(ConfigurationName)" + IntermediateDirectory="$(ConfigurationName)" + ConfigurationType="1" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="FALSE"> + <Tool + Name="VCCLCompilerTool" + OmitFramePointers="TRUE" + OptimizeForProcessor="2" + AdditionalIncludeDirectories="..\..\..\public;..\..\..\common;..\Common\include;..\toollib" + PreprocessorDefinitions="_USE_XGMATH;_XBOX;NDEBUG" + StringPooling="TRUE" + ExceptionHandling="FALSE" + RuntimeLibrary="0" + EnableFunctionLevelLinking="TRUE" + EnableEnhancedInstructionSet="1" + UsePrecompiledHeader="0" + PrecompiledHeaderThrough="" + PrecompiledHeaderFile="" + AssemblerListingLocation="$(IntDir)/" + ObjectFile="$(IntDir)/" + ProgramDataBaseFileName="$(IntDir)/" + WarningLevel="3" + SuppressStartupBanner="TRUE" + DisableSpecificWarnings="4244"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + AdditionalOptions="/MACHINE:I386 /FIXED:NO" + AdditionalDependencies="xapilib.lib d3d8.lib d3dx8.lib xgraphics.lib dsound.lib xmv.lib xboxkrnl.lib" + OutputFile="$(OutDir)/xbox_loader.exe" + SuppressStartupBanner="TRUE" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile="$(OutDir)/xbox_loader.pdb" + GenerateMapFile="TRUE" + MapExports="TRUE" + MapLines="TRUE" + OptimizeReferences="2" + EnableCOMDATFolding="2" + SetChecksum="TRUE"/> + <Tool + Name="VCPostBuildEventTool" + Description="Copying LoaderMedia to \\Fileserver" + CommandLine="copy LoaderMedia\*.* \\FileServer\user\XBox\DVD\LoaderMedia +copy $(TargetDir)$(TargetName).xbe \\FileServer\user\XBox\DVD\default.xbe +"/> + <Tool + Name="VCPreBuildEventTool" + CommandLine="bundler LoaderMedia_Source\loader_icon.rdf -o LoaderMedia_Source\loader_icon.xbx"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="XboxDeploymentTool" + RemotePath="xe:\hl2\default.xbe" + AdditionalFiles=""/> + <Tool + Name="XboxImageTool" + StackSize="0x10000" + LimitAvailableMemoryTo64MB="TRUE" + SuppressStartupBanner="TRUE" + TitleID="0x45410091" + TitleName="Half - Life 2 (Release Build)" + TitleImage="LoaderMedia_Source\loader_icon.xbx" + XBEVersion="4096"/> + </Configuration> + <Configuration + Name="Retail_XBox|Xbox" + OutputDirectory="$(ConfigurationName)" + IntermediateDirectory="$(ConfigurationName)" + ConfigurationType="1" + UseOfMFC="0" + ATLMinimizesCRunTimeLibraryUsage="FALSE"> + <Tool + Name="VCCLCompilerTool" + OmitFramePointers="TRUE" + OptimizeForProcessor="2" + AdditionalIncludeDirectories="..\..\..\public;..\..\..\common;..\Common\include;..\toollib" + PreprocessorDefinitions="_USE_XGMATH;_XBOX;NDEBUG;_RETAIL" + StringPooling="TRUE" + ExceptionHandling="FALSE" + RuntimeLibrary="0" + EnableFunctionLevelLinking="TRUE" + EnableEnhancedInstructionSet="1" + UsePrecompiledHeader="0" + PrecompiledHeaderThrough="xtl.h" + PrecompiledHeaderFile="$(IntDir)/apploader.pch" + AssemblerListingLocation="$(IntDir)/" + ObjectFile="$(IntDir)/" + ProgramDataBaseFileName="$(IntDir)/" + WarningLevel="3" + SuppressStartupBanner="TRUE" + DisableSpecificWarnings="4244"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + AdditionalOptions="/MACHINE:I386 /FIXED:NO" + AdditionalDependencies="xapilib.lib d3d8.lib d3dx8.lib xgraphics.lib dsound.lib xmv.lib xboxkrnl.lib" + OutputFile="$(OutDir)/xbox_loader.exe" + SuppressStartupBanner="TRUE" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile="$(OutDir)/xbox_loader.pdb" + GenerateMapFile="TRUE" + MapExports="TRUE" + MapLines="TRUE" + OptimizeReferences="2" + EnableCOMDATFolding="2" + SetChecksum="TRUE"/> + <Tool + Name="VCPostBuildEventTool" + Description="Copying LoaderMedia to \\Fileserver" + CommandLine="copy LoaderMedia\*.* \\FileServer\user\XBox\DVD\LoaderMedia +copy $(TargetDir)$(TargetName).xbe \\FileServer\user\XBox\DVD\default.xbe +"/> + <Tool + Name="VCPreBuildEventTool" + CommandLine="bundler LoaderMedia_Source\loader_icon.rdf -o LoaderMedia_Source\loader_icon.xbx"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="XboxDeploymentTool" + RemotePath="xe:\hl2\default.xbe" + AdditionalFiles=""/> + <Tool + Name="XboxImageTool" + StackSize="0x10000" + LimitAvailableMemoryTo64MB="TRUE" + SuppressStartupBanner="TRUE" + TitleID="0x45410091" + TitleName="Half - Life 2" + TitleImage="LoaderMedia_Source\loader_icon.xbx" + XBEVersion="4096"/> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm"> + <File + RelativePath=".\xbox_fileCopy.cpp"> + </File> + <File + RelativePath=".\xbox_loader.cpp"> + </File> + <File + RelativePath=".\xmvhelper.cpp"> + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl;inc"> + <File + RelativePath=".\font.h"> + </File> + <File + RelativePath="..\..\..\public\jcalg1.h"> + </File> + <File + RelativePath=".\loader.h"> + </File> + <File + RelativePath="..\..\..\common\xbox\xbox_launch.h"> + </File> + <File + RelativePath=".\xbox_loader.h"> + </File> + <File + RelativePath=".\xmvhelper.h"> + </File> + </Filter> + <Filter + Name="Common Files" + Filter=""> + <Filter + Name="Source Files" + Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm"> + <File + RelativePath="..\toollib\scriplib.cpp"> + </File> + <File + RelativePath="..\toollib\scriplib.h"> + </File> + <File + RelativePath="..\toollib\toollib.cpp"> + </File> + <File + RelativePath="..\toollib\toollib.h"> + </File> + <File + RelativePath="..\Common\src\XBApp.cpp"> + </File> + <File + RelativePath="..\Common\src\XBFont.cpp"> + </File> + <File + RelativePath="..\Common\src\XBInput.cpp"> + </File> + <File + RelativePath="..\Common\src\XBMesh.cpp"> + </File> + <File + RelativePath="..\Common\src\XBResource.cpp"> + </File> + <File + RelativePath="..\Common\src\XBUtil.cpp"> + </File> + </Filter> + <Filter + Name="Header Files" + Filter="h;hpp;hxx;hm;inl;inc"> + <File + RelativePath="..\Common\include\XBApp.h"> + </File> + <File + RelativePath="..\Common\include\XBFont.h"> + </File> + <File + RelativePath="..\Common\include\XBHelp.h"> + </File> + <File + RelativePath="..\Common\include\XBInput.h"> + </File> + <File + RelativePath="..\Common\include\XBMesh.h"> + </File> + <File + RelativePath="..\Common\include\XBProfiling.h"> + </File> + <File + RelativePath="..\Common\include\XBResource.h"> + </File> + <File + RelativePath="..\Common\include\XBUtil.h"> + </File> + </Filter> + </Filter> + <Filter + Name="Resources" + Filter="*.rdf"> + <File + RelativePath=".\loader.rdf"> + <FileConfiguration + Name="Debug_XBox|Xbox"> + <Tool + Name="VCCustomBuildTool" + Description="bundler "$(InputPath)"" + CommandLine="bundler "$(InputPath)"" + Outputs="$(ProjectDir)Media\$(InputName).xpr;$(ProjectDir)$(InputName).h"/> + </FileConfiguration> + <FileConfiguration + Name="Release_XBox|Xbox"> + <Tool + Name="VCCustomBuildTool" + Description="bundler "$(InputPath)"" + CommandLine="bundler "$(InputPath)"" + Outputs="$(ProjectDir)Media\$(InputName).xpr;$(ProjectDir)$(InputName).h"/> + </FileConfiguration> + <FileConfiguration + Name="Retail_XBox|Xbox"> + <Tool + Name="VCCustomBuildTool" + Description="bundler "$(InputPath)"" + CommandLine="bundler "$(InputPath)"" + Outputs="$(ProjectDir)Media\$(InputName).xpr;$(ProjectDir)$(InputName).h"/> + </FileConfiguration> + </File> + <File + RelativePath=".\LoaderMedia_Source\loader_icon.rdf"> + </File> + </Filter> + <Filter + Name="Libraries" + Filter=""> + <File + RelativePath="..\..\..\lib\public\jcalg1_static.lib"> + </File> + </Filter> + </Files> + <Globals> + </Globals> +</VisualStudioProject> diff --git a/utils/xbox/xbox_loader/xmvhelper.cpp b/utils/xbox/xbox_loader/xmvhelper.cpp new file mode 100644 index 0000000..74060de --- /dev/null +++ b/utils/xbox/xbox_loader/xmvhelper.cpp @@ -0,0 +1,788 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +//----------------------------------------------------------------------------- +// File: WMVPlayer.cpp +// +// Desc: This helper class provides simple WMV decoding and playback +// functionality. It will be expanded as new playback methods are +// exposed +// +// Hist: 2.7.03 - Created, based on work by Jeff Sullivan +// +// Copyright (c) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- + +#include "xbox_loader.h" +#include <xtl.h> +#include "XMVHelper.h" +#include "XBUtil.h" +#include <stdio.h> + + +// Funtion Prototypes for packet loading functions for loading from a file. +HRESULT CALLBACK GetNextPacket( DWORD dwContext, + void **ppPacket, + DWORD* pOffsetToNextPacket ); + +HRESULT CALLBACK ReleasePreviousPacket( DWORD dwContext, + LONGLONG llNextReadByteOffset, + DWORD dwNextPacketSize ); + +// Funtion Prototypes for packet loading functions for loading from a block of memory. +HRESULT CALLBACK GetNextMemoryPacket( DWORD dwContext, + void **ppPacket, + DWORD* pOffsetToNextPacket ); + +HRESULT CALLBACK ReleasePreviousMemoryPacket( DWORD dwContext, + LONGLONG llNextReadByteOffset, + DWORD dwNextPacketSize ); + + + + +//----------------------------------------------------------------------------- +// Name: CXMVPlayer() +// Desc: Constructor for CXMVPlayer +//----------------------------------------------------------------------------- +CXMVPlayer::CXMVPlayer() +{ + m_pXMVDecoder = NULL; + ZeroMemory( &m_VideoDesc, sizeof( m_VideoDesc ) ); + ZeroMemory( &m_AudioDesc, sizeof( m_AudioDesc ) ); + for ( UINT i=0; i<XMVPLAYER_NUMTEXTURES; i++ ) + { + m_pTextures[i] = NULL; + } + + m_dwCurrentFrame = -1; // Will be zero after we decode the first frame. + + m_bPlaying = FALSE; + m_bOverlaysEnabled = FALSE; + + m_loadContext.hFile = INVALID_HANDLE_VALUE; + m_loadContext.pInputBuffer = 0; + m_physicalBuffer = 0; + m_bError = FALSE; +} + + + + +//----------------------------------------------------------------------------- +// Name: ~CXMVPlayer() +// Desc: Destructor for CXMVPlayer +//----------------------------------------------------------------------------- +CXMVPlayer::~CXMVPlayer() +{ + Destroy(); +} + + + + +//----------------------------------------------------------------------------- +// Name: Destroy() +// Desc: Free all resources and clear are resource pointers and handles. +//----------------------------------------------------------------------------- +HRESULT CXMVPlayer::Destroy() +{ + // Disable overlays if we were using them. + if ( m_bOverlaysEnabled ) + { + m_pDevice->EnableOverlay( FALSE ); + m_bOverlaysEnabled = FALSE; + } + + // Free the XMV decoder. + if ( NULL != m_pXMVDecoder ) + { + m_pXMVDecoder->CloseDecoder(); + m_pXMVDecoder = NULL; + } + + ZeroMemory( &m_VideoDesc, sizeof( m_VideoDesc ) ); + ZeroMemory( &m_AudioDesc, sizeof( m_AudioDesc ) ); + + // Release our textures. + for ( UINT i=0; i<XMVPLAYER_NUMTEXTURES; i++ ) + { + if ( m_pTextures[i] ) + m_pTextures[i]->Release(); + m_pTextures[i] = 0; + } + + m_dwCurrentFrame = -1; + m_dwStartTime = 0; + + m_bPlaying = FALSE; + + // Release any file handles we were using. + if( INVALID_HANDLE_VALUE != m_loadContext.hFile ) + { + CloseHandle( m_loadContext.hFile ); + m_loadContext.hFile = INVALID_HANDLE_VALUE; + } + + // Free up memory used for playing a movie from memory. + if ( m_loadContext.pInputBuffer ) + { + free( m_loadContext.pInputBuffer ); + m_loadContext.pInputBuffer = 0; + } + + // Be sure to release the physical memory last! + if( m_physicalBuffer ) + { + XPhysicalFree( m_physicalBuffer ); + m_physicalBuffer = 0; + } + + return S_OK; +} + + + + +//----------------------------------------------------------------------------- +// Name: FinishOpeningFile() +// Desc: Helper function for the three Open functions. Enables the audio streams, +// initializes the video descriptor, and allocates textures if needed. +//----------------------------------------------------------------------------- +HRESULT CXMVPlayer::FinishOpeningFile( D3DFORMAT format, LPDIRECT3DDEVICE8 pDevice, BOOL bAllocateTextures ) +{ + assert( format == D3DFMT_YUY2 || format == D3DFMT_LIN_A8R8G8B8 ); + assert( XMVPLAYER_NUMTEXTURES >= 2); + + HRESULT hr = S_OK; + + m_pXMVDecoder->GetVideoDescriptor( &m_VideoDesc ); + + // Enable the audio streams + for ( unsigned i=0; i < m_VideoDesc.AudioStreamCount; i++ ) + { + m_pXMVDecoder->GetAudioDescriptor( i, &m_AudioDesc ); + hr = m_pXMVDecoder->EnableAudioStream( i, 0, NULL, NULL); + if ( FAILED( hr ) ) + { + XBUtil_DebugPrint( "Unable to enable audio stream 0 (error %x)\n", hr ); + Destroy(); + return hr; + } + } + + for ( int i = 0; i < XMVPLAYER_NUMTEXTURES; i++ ) + { + m_pTextures[i] = 0; + if ( bAllocateTextures ) + { + hr = pDevice->CreateTexture( m_VideoDesc.Width, m_VideoDesc.Height, 1, 0, format, 0, &m_pTextures[i] ); + if ( FAILED( hr ) ) + { + XBUtil_DebugPrint( "Unable to create texture %d (error %x)\n", i, hr ); + Destroy(); + return hr; + } + } + } + + // Initialize what texture we are decoding to, if decoding for texture mapping. + m_nDecodeTextureIndex = 0; + + // Initialize the various texture pointers for use when decoding for overlays. + pShowingTexture = m_pTextures[0]; + pDecodingTexture = m_pTextures[1]; + pSubmittedTexture = 0; + + m_bPlaying = TRUE; + m_dwStartTime = GetTickCount(); + + return hr; +} + + + + +//----------------------------------------------------------------------------- +// Name: OpenFile() +// Desc: Create an XMV decoder object that reads from a file. +//----------------------------------------------------------------------------- +HRESULT CXMVPlayer::OpenFile( const CHAR* lpFilename, D3DFORMAT format, LPDIRECT3DDEVICE8 pDevice, BOOL bAllocateTextures ) +{ + HRESULT hr = S_OK; + + m_bError = FALSE; + + if ( NULL == lpFilename || NULL == pDevice ) + { + XBUtil_DebugPrint( "Bad parameter to OpenFile()\n" ); + m_bError = TRUE; + return E_FAIL; + } + + hr = XMVDecoder_CreateDecoderForFile( XMVFLAG_SYNC_ON_NEXT_VBLANK, ( CHAR* )lpFilename, &m_pXMVDecoder ); + if ( FAILED( hr ) ) + { + XBUtil_DebugPrint( "Unable to create XMV Decoder for %s (error: %x)\n", lpFilename, hr ); + m_bError = TRUE; + return hr; + } + + hr = FinishOpeningFile( format, pDevice, bAllocateTextures ); + + if ( FAILED( hr ) ) + { + m_bError = TRUE; + } + + return hr; +} + + + + +//----------------------------------------------------------------------------- +// Name: OpenFileForPackets() +// Desc: Create an XMV decoder object that uses the packet reading interface. +// Currently this just reads from a file, but it can be altered to read from +// custom formats, start partway through a file, etc. +//----------------------------------------------------------------------------- +HRESULT CXMVPlayer::OpenFileForPackets( const CHAR* lpFilename, D3DFORMAT format, LPDIRECT3DDEVICE8 pDevice, BOOL bAllocateTextures ) +{ + HRESULT hr = S_OK; + + // We need to read in the first 4K of data for the XMV player to initialize + // itself from. This is most conveniently read as an array of DWORDS. + DWORD first4Kbytes[4096 / sizeof( DWORD )]; + + // Clear entire context struct to zero + ZeroMemory( &m_loadContext, sizeof( m_loadContext ) ); + + // Open the input file. + m_loadContext.hFile = CreateFile( lpFilename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED | FILE_FLAG_NO_BUFFERING, + NULL ); + + if( m_loadContext.hFile == INVALID_HANDLE_VALUE ) + { + Destroy(); + return E_INVALIDARG; + } + + // Read the first page from the file. We opened it for + // overlapped IO so we do a pair of reads. + m_loadContext.Overlapped.Offset = 0; + m_loadContext.Overlapped.OffsetHigh = 0; + + // Start the read. + if( 0 == ReadFile( m_loadContext.hFile, first4Kbytes, sizeof( first4Kbytes ), NULL, &m_loadContext.Overlapped ) ) + { + if( GetLastError() != ERROR_IO_PENDING ) + { + Destroy(); + return E_FAIL; + } + } + + // Wait for the read to finish. + DWORD dwBytesRead; + if( !GetOverlappedResult( m_loadContext.hFile, &m_loadContext.Overlapped, &dwBytesRead, TRUE ) ) + { + Destroy(); + return E_FAIL; + } + + // Check size to make sure input is a valid XMV file. + if( dwBytesRead != 4096 ) + { + Destroy(); + return E_FAIL; + } + + // Create an XMV decoder + hr = XMVDecoder_CreateDecoderForPackets( XMVFLAG_SYNC_ON_NEXT_VBLANK, first4Kbytes, ( DWORD )&m_loadContext, + GetNextPacket, ReleasePreviousPacket, &m_pXMVDecoder ); + if( FAILED( hr ) ) + { + Destroy(); + return E_FAIL; + } + + // The size of the first packet and the minimum size of the two packet buffers are stored in the + // second and third DWORDS of the file. From xmv.h: + // * DWORD NextPacketSize // The size of the next packet + // * DWORD ThisPacketSize // The size of this packet + // * DWORD MaxPacketSize // The size of the largest packet in the file + DWORD dwThisPacketSize = first4Kbytes[1]; + DWORD dwRequiredPacketSize = first4Kbytes[2]; + + // Check for illegal parameters. + if( dwThisPacketSize > dwRequiredPacketSize ) + { + Destroy(); + return E_FAIL; + } + + // XPhysicalAlloc is used so that 5.1 or compressed audio streams can be played. + m_physicalBuffer = ( BYTE* )XPhysicalAlloc( dwRequiredPacketSize * 2, MAXULONG_PTR, 0, PAGE_READWRITE ); + + // Save our information. + m_loadContext.dwPacketSize = dwRequiredPacketSize; + m_loadContext.pLoadingPacket = m_physicalBuffer; + m_loadContext.pDecodingPacket = m_physicalBuffer + dwRequiredPacketSize; + + // Read the first packet. We wind up re-reading the first 4096 + // bytes but it makes the logic for figuring out how much we read + // a little bit easier... + m_loadContext.Overlapped.Offset = 0; + m_loadContext.Overlapped.OffsetHigh = 0; + + if( 0 == ReadFile( m_loadContext.hFile, m_physicalBuffer, dwThisPacketSize, NULL, + &m_loadContext.Overlapped ) ) + { + if( GetLastError() != ERROR_IO_PENDING ) + { + Destroy(); + return E_FAIL; + } + } + + // Note - at this point the preceding read has *not* necessarily completed. + // Don't try reading anything from that buffer until GetNextPacket has been + // successfully called. + + hr = FinishOpeningFile( format, pDevice, bAllocateTextures ); + + return hr; +} + + + + +//----------------------------------------------------------------------------- +// Name: OpenMovieFromMemory() +// Desc: Create an XMV decoder object that uses the packet reading interface to +// read from a block of memory. To simplify the memory management this function +// also allocates this block of memory and initializes it from a file. +//----------------------------------------------------------------------------- +HRESULT CXMVPlayer::OpenMovieFromMemory( const CHAR* lpFilename, D3DFORMAT format, LPDIRECT3DDEVICE8 pDevice, BOOL bAllocateTextures ) +{ + HRESULT hr = S_OK; + + m_bError = FALSE; + + // Read the entire file into memory. + void* data; + hr = XBUtil_LoadFile( lpFilename, &data, &m_loadContext.inputSize ); + if ( FAILED( hr ) ) + { + m_bError = TRUE; + return hr; + } + + m_loadContext.pInputBuffer = ( BYTE* )data; + + // Check size to make sure input is a valid XMV file. + if( m_loadContext.inputSize < 4096 ) + { + Destroy(); + m_bError = TRUE; + return E_FAIL; + } + + // Get a DWORD pointer to the first 4K - needed by CreateDecoderForPackets + DWORD* first4Kbytes = ( DWORD* )data; + + // Create an XMV decoder + hr = XMVDecoder_CreateDecoderForPackets( XMVFLAG_SYNC_ON_NEXT_VBLANK, first4Kbytes, ( DWORD )&m_loadContext, GetNextMemoryPacket, + ReleasePreviousMemoryPacket, &m_pXMVDecoder ); + if ( FAILED( hr ) ) + { + Destroy(); + m_bError = TRUE; + return E_FAIL; + } + + // The size of the first packet and the minimum size of the two packet buffers are stored in the + // second and third DWORDS of the file. From xmv.h: + // * DWORD NextPacketSize // The size of the next packet + // * DWORD ThisPacketSize // The size of this packet + // * DWORD MaxPacketSize // The size of the largest packet in the file + DWORD dwThisPacketSize = first4Kbytes[1]; + DWORD dwRequiredPacketSize = first4Kbytes[2]; + + // Check for illegal parameters. + if( dwThisPacketSize > dwRequiredPacketSize ) + { + Destroy(); + m_bError = TRUE; + return E_FAIL; + } + + // XPhysicalAlloc is used so that 5.1 or compressed audio streams can be played. + m_physicalBuffer = ( BYTE* )XPhysicalAlloc( dwRequiredPacketSize * 2, MAXULONG_PTR, 0, PAGE_READWRITE ); + + // Save our information for the callback functions. + // The size of our two memory blocks. + m_loadContext.dwPacketSize = dwRequiredPacketSize; + // The addresses of our two memory blocks. + m_loadContext.pLoadingPacket = m_physicalBuffer; + m_loadContext.pDecodingPacket = m_physicalBuffer + dwRequiredPacketSize; + + // Information about the block of memory the movie is stored in. + m_loadContext.pInputBuffer = ( BYTE* )data; + m_loadContext.inputSize = m_loadContext.inputSize; + m_loadContext.readOffset = 0; + m_loadContext.currentPacketSize = dwThisPacketSize; + + hr = FinishOpeningFile( format, pDevice, bAllocateTextures ); + + if ( FAILED( hr ) ) + { + m_bError = TRUE; + } + + return hr; +} + + + + +//----------------------------------------------------------------------------- +// Name: AdvanceFrameForTexturing() +// Desc: Unpack the appropriate frames of data for use as textures. +//----------------------------------------------------------------------------- +LPDIRECT3DTEXTURE8 CXMVPlayer::AdvanceFrameForTexturing( LPDIRECT3DDEVICE8 pDevice ) +{ + // You must pass bAllocateTextures==TRUE to Open if you're going to use GetTexture/AdvanceFrame. + assert( m_pTextures[0] ); + + LPDIRECT3DSURFACE8 pSurface; + pDecodingTexture->GetSurfaceLevel( 0, &pSurface ); + + // Decode some information to the current draw texture. + XMVRESULT xr = XMV_NOFRAME; + m_pXMVDecoder->GetNextFrame( pSurface, &xr, NULL ); + + switch ( xr ) + { + case XMV_NOFRAME: + // Do nothing - we didn't get a frame. + break; + + case XMV_NEWFRAME: + ++m_dwCurrentFrame; + // GetNextFrame produced a new frame. So, the texture we were decoding + // to becomes available for drawing as a texture. + pShowingTexture = pDecodingTexture; + + // Setup for decoding to the next texture. + m_nDecodeTextureIndex = ( m_nDecodeTextureIndex + 1 ) % XMVPLAYER_NUMTEXTURES; + pDecodingTexture = m_pTextures[ m_nDecodeTextureIndex ]; + break; + + case XMV_ENDOFFILE: + m_bPlaying = FALSE; + break; + + case XMV_FAIL: + // Data corruption or file read error. We'll treat that the same as + // end of file. + m_bPlaying = FALSE; + m_bError = TRUE; + break; + } + + SAFE_RELEASE( pSurface ); + + // If we haven't decoded the first frame then return zero. + if ( m_dwCurrentFrame < 0 ) + return 0; + + return pShowingTexture; +} + + + + +//----------------------------------------------------------------------------- +// Name: AdvanceFrameForOverlays() +// Desc: Unpack the appropriate frames of data for use as an overlay. +//----------------------------------------------------------------------------- +LPDIRECT3DTEXTURE8 CXMVPlayer::AdvanceFrameForOverlays( LPDIRECT3DDEVICE8 pDevice ) +{ + // You must pass bAllocateTextures==TRUE to Open if you're going to use GetTexture/AdvanceFrame. + assert( m_pTextures[0] ); + + // You have to call CXMVPlayer::EnableOverlays() if you are going to use overlays. + assert( m_bOverlaysEnabled ); + + // If a texture has been submitted to be used as an overlay then we have to + // wait for GetUpdateOverlayState() to return TRUE before we can assume that + // the previous texture has *stopped* being displayed. Once GetUpdateOverlayState() + // returns TRUE then we know that pSubmittedTexture is being displayed, which + // means that, pShowingTexture is available as a decoding target. + if ( pSubmittedTexture ) + { + // If GetOverlayUpdateStatus() returns FALSE then we can still proceed and + // call GetNextFrame(), but we will pass NULL for the surface parameter. + // Some work will still be done, but none of the surfaces will be altered. + if ( pDevice->GetOverlayUpdateStatus() ) + { + // The call to UpdateOverlay() with pSubmittedTexture must have taken + // effect now, so pShowingTexture is available as a decoding target. + assert( !pDecodingTexture ); + pDecodingTexture = pShowingTexture; + pShowingTexture = pSubmittedTexture; + pSubmittedTexture = NULL; + } + } + + LPDIRECT3DSURFACE8 pSurface = NULL; + if ( pDecodingTexture ) + pDecodingTexture->GetSurfaceLevel( 0, &pSurface ); + + // Decode some information to the current draw texture, which may be NULL. + // pDecodingTexture will be NULL if one texture has been submitted as a new + // overlay but the other one is still being displayed as an overlay. + // If pSurface is NULL GetNextFrame() will still do some work. + XMVRESULT xr = XMV_NOFRAME; + m_pXMVDecoder->GetNextFrame( pSurface, &xr, NULL ); + + switch ( xr ) + { + case XMV_NOFRAME: + // Do nothing - we didn't get a frame. + break; + + case XMV_NEWFRAME: + ++m_dwCurrentFrame; + // GetNextFrame produced a new frame. So, the texture we were decoding + // to becomes available for displaying as an overlay. + + // The other texture is not ready to be a decoding target. It is still + // being displayed as an overlay. So, we assign the newly decoded + // texture to pSubmittedTexture for the program to submit as an overlay, + // but we don't yet move the previously submitted texture from pShowing + // to pDecoding. That happens on a subsequent call to this function, after + // GetOverlayUpdateStatus() returns TRUE to tell us that there are no + // overlay swaps pending. + assert( pDecodingTexture ); + assert( !pSubmittedTexture ); + pSubmittedTexture = pDecodingTexture; + pDecodingTexture = NULL; + break; + + case XMV_ENDOFFILE: + m_bPlaying = FALSE; + break; + + case XMV_FAIL: + // Data corruption or file read error. We'll treat that the same as + // end of file. + m_bPlaying = FALSE; + m_bError = TRUE; + break; + } + + SAFE_RELEASE( pSurface ); + + // If we just unpacked a new frame then we return that texture + // and the program must call UpdateOverlay() with the surface + // from that texture. + // If we didn't unpack a frame then the program should do nothing - + // the previous overlay will continue to be displayed. + if ( XMV_NEWFRAME == xr ) + return pSubmittedTexture; + + // No new frame to display. + return 0; +} + + + + +//----------------------------------------------------------------------------- +// Name: TerminatePlayback() +// Desc: Calls XMVDecoder::TerminatePlayback() +//----------------------------------------------------------------------------- +void CXMVPlayer::TerminatePlayback() +{ + m_pXMVDecoder->TerminatePlayback(); +} + + + + +//----------------------------------------------------------------------------- +// Name: Play() +// Desc: Calls XMVDecoder::Play() to play the entire movie. +//----------------------------------------------------------------------------- +HRESULT CXMVPlayer::Play( DWORD Flags, RECT* pRect ) +{ + // You have to call Open before calling Play. + assert( m_pXMVDecoder ); + + // Don't pass bAllocateTextures==TRUE to Open if you're going to use Play. + assert( !m_pTextures[0] ); + + return m_pXMVDecoder->Play( Flags, pRect ); +} + + + + +//----------------------------------------------------------------------------- +// Name: EnableOverlays() +// Desc: Enable the overlay planes for playing the movie in them, and record +// that the overlays should be disabled when Destroy() is called. +//----------------------------------------------------------------------------- +void CXMVPlayer::EnableOverlays( LPDIRECT3DDEVICE8 pDevice ) +{ + m_pDevice = pDevice; + pDevice->EnableOverlay( TRUE ); + m_bOverlaysEnabled = TRUE; +} + + + + +//----------------------------------------------------------------------------- +// Name: GetNextPacket() +// Desc: Callback function to get next packet from a file +//----------------------------------------------------------------------------- +static HRESULT CALLBACK GetNextPacket( DWORD dwContext, VOID** ppPacket, + DWORD* pOffsetToNextPacket ) +{ + LOAD_CONTEXT* pContext = ( LOAD_CONTEXT* )dwContext; + if( NULL == pContext ) + return E_FAIL; + + // If the next packet is fully loaded then return it, + // otherwise return NULL. + DWORD dwBytesRead; + if( GetOverlappedResult( pContext->hFile, &pContext->Overlapped, + &dwBytesRead, FALSE ) ) + { + // Make the old decoding packet pending. + pContext->pPendingReleasePacket = pContext->pDecodingPacket; + pContext->pDecodingPacket = pContext->pLoadingPacket; + pContext->pLoadingPacket = NULL; + + // Offset to the next packet. + *pOffsetToNextPacket = dwBytesRead; + + // Set *ppPacket to the data we just loaded. + *ppPacket = pContext->pDecodingPacket; + } + else + { + DWORD dwError = GetLastError(); + + // If we're waiting on the IO to finish, just do nothing. + if( dwError != ERROR_IO_INCOMPLETE ) + return HRESULT_FROM_WIN32( dwError ); + + *ppPacket = NULL; + *pOffsetToNextPacket = 0; + } + + return S_OK; +} + + + + +//----------------------------------------------------------------------------- +// Name: ReleasePreviousPacket() +// Desc: Callback function to release previous packet from a file +//----------------------------------------------------------------------------- +static HRESULT CALLBACK ReleasePreviousPacket( DWORD dwContext, LONGLONG llNextReadByteOffset, + DWORD dwNextPacketSize ) +{ + LOAD_CONTEXT* pContext = ( LOAD_CONTEXT* )dwContext; + if( NULL == pContext ) + return E_FAIL; + + if( dwNextPacketSize != 0 ) + { + // Start the next load. + pContext->Overlapped.Offset = ( DWORD )( llNextReadByteOffset & 0xFFFFFFFF ); + pContext->Overlapped.OffsetHigh = ( DWORD )( llNextReadByteOffset >> 32 ); + + // Check for bad input file - buffer overrun + if( dwNextPacketSize > pContext->dwPacketSize ) + return E_FAIL; + + pContext->pLoadingPacket = pContext->pPendingReleasePacket; + pContext->pPendingReleasePacket = NULL; + + if( 0 == ReadFile( pContext->hFile, pContext->pLoadingPacket, + dwNextPacketSize, NULL, &pContext->Overlapped ) ) + { + if( GetLastError() != ERROR_IO_PENDING ) + return HRESULT_FROM_WIN32( GetLastError() ); + } + } + + return S_OK; +} + + + + +//----------------------------------------------------------------------------- +// Name: GetNextMemoryPacket() +// Desc: Callback function to get next packet from a file, +// and setup for the next packet. +//----------------------------------------------------------------------------- +static HRESULT CALLBACK GetNextMemoryPacket( DWORD dwContext, VOID** ppPacket, + DWORD* pOffsetToNextPacket ) +{ + LOAD_CONTEXT* pContext = ( LOAD_CONTEXT* )dwContext; + if( NULL == pContext ) + return E_FAIL; + + DWORD dwBytesRead = pContext->inputSize - pContext->readOffset; + if ( pContext->currentPacketSize < dwBytesRead ) + dwBytesRead = pContext->currentPacketSize; + + memcpy( pContext->pLoadingPacket, pContext->pInputBuffer + pContext->readOffset , dwBytesRead ); + pContext->readOffset +=dwBytesRead; + + // Swap pointers so that next time we load it goes into the other packet block. + BYTE* temp = pContext->pLoadingPacket; + pContext->pLoadingPacket = pContext->pDecodingPacket; + pContext->pDecodingPacket = temp; + + // Offset to the next packet. + *pOffsetToNextPacket = dwBytesRead; + + // Set *ppPacket to the data we just loaded. + *ppPacket = pContext->pDecodingPacket; + + return S_OK; +} + + + + +//----------------------------------------------------------------------------- +// Name: ReleasePreviousMemoryPacket() +// Desc: Callback function to release previous packet from a block of memory, +// and setup for the next packet. +//----------------------------------------------------------------------------- +static HRESULT CALLBACK ReleasePreviousMemoryPacket( DWORD dwContext, LONGLONG llNextReadByteOffset, + DWORD dwNextPacketSize ) +{ + LOAD_CONTEXT* pContext = ( LOAD_CONTEXT* )dwContext; + if( NULL == pContext ) + return E_FAIL; + + // Check for bad input file - buffer overrun + if( dwNextPacketSize > pContext->dwPacketSize ) + return E_FAIL; + + // Record the size of the next packet we are supposed to read, for GetNextMemoryPacket. + pContext->currentPacketSize = dwNextPacketSize; + + return S_OK; +} diff --git a/utils/xbox/xbox_loader/xmvhelper.h b/utils/xbox/xbox_loader/xmvhelper.h new file mode 100644 index 0000000..59dd390 --- /dev/null +++ b/utils/xbox/xbox_loader/xmvhelper.h @@ -0,0 +1,177 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +//----------------------------------------------------------------------------- +// File: XMVHelper.h +// +// Desc: Definition of XMV playback helper class for playing XMVs in a number +// of different ways. +// +// Hist: 2.7.03 - Created, based on work by Jeff Sullivan +// +// Copyright (c) Microsoft Corporation. All rights reserved. +//----------------------------------------------------------------------------- + +#ifndef _XMVHELPER_H_ +#define _XMVHELPER_H_ + +#include <xtl.h> +#include <xmv.h> + +// Number of textures to allocate for decoding. A larger number may help to +// smooth out any frame rate variations if you are decoding to a texture. +// When decoding to overlays two textures are always used. +const DWORD XMVPLAYER_NUMTEXTURES = 2; + + + + +//----------------------------------------------------------------------------- +// Name: LOAD_CONTEXT +// Desc: This structure is used to hold information used by the packet callbacks. +//----------------------------------------------------------------------------- +struct LOAD_CONTEXT +{ + // Memory available for loading packets - maximum packet size. + DWORD dwPacketSize; + + // Packet that XMV was decoding out of, and might still be, that + // we want to load into as soon as we can. + BYTE* pPendingReleasePacket; + // Packet that XMV is decoding out of. + BYTE* pDecodingPacket; + // Packet we are currently loading into. + BYTE* pLoadingPacket; + + + // Information for when reading packets out of a file. + // Handle to the file we are reading from. + HANDLE hFile; + + // Overlapped structure to control asynchronous reading. + OVERLAPPED Overlapped; + + + // Information for when copying packets out of a memory buffer. + // The size and location of the buffer we are reading from if we are + // playing a movie from memory. + BYTE* pInputBuffer; + DWORD inputSize; + // The offset in the memory buffer that we are currently reading from. + DWORD readOffset; + // The size of the packet that we have 'queued up' for reading. This + // is a packet that we have warned about via ReleasePreviousMemoryPacket + // but have not yet been asked to load. + DWORD currentPacketSize; +}; + + + + +class CXMVPlayer +{ +public: + CXMVPlayer(); + ~CXMVPlayer(); + + // Open a .wmv file and prepare it for playing. + // The format parameter specifies what type of texture it should be unpacked into ( if allocateTextures + // is TRUE ). Only YUY2, LIN_X8R8G8B8 and LIN_A8R8G8B8 are supported as formats. + // If you plan to play the movie with Play() or otherwise use overlays then format must be D3DFMT_YUY2 + // pDevice is needed in order to create textures. + // allocateTextures should be TRUE if you plan to play the movie manually with AdvanceFrame. + // It should be FALSE if you plan to play the movie with Play(). + // IsPlaying() will return TRUE if the movie opened successfully. + HRESULT OpenFile( const CHAR* lpFilename, D3DFORMAT format, LPDIRECT3DDEVICE8 pDevice, BOOL bAllocateTextures ); + + // Open a file using the packet interface. This method of opening a .wmv file can be easily + // customized to read the data from game specific file formats. The GetNextPacket and + // ReleasePreviousPacket functions from XMVHelper.cpp are used to read the packets. See above for + // information about the other parameters. + HRESULT OpenFileForPackets( const CHAR* lpFilename, D3DFORMAT format, LPDIRECT3DDEVICE8 pDevice, BOOL bAllocateTextures ); + + // Open a block of memory for playing using the packet interface. This method of opening a .wmv file can be easily + // customized to read the data from game specific file formats, or to retain the block of data in memory. + // The GetNextMemoryPacket and ReleasePreviousMemoryPacket functions from XMVHelper.cpp are used to read + // the packets. See above for information about the other parameters. + HRESULT OpenMovieFromMemory( const CHAR* lpFilename, D3DFORMAT format, LPDIRECT3DDEVICE8 pDevice, BOOL bAllocateTextures ); + + // Destroy frees up all the movie resources. IsPlaying() will return FALSE afterwards. Destroy() + // can be called during movie playback, but is not thread safe. + HRESULT Destroy(); + + // The AdvanceFrame functions move to the next frame if it is time for that. Call this + // function frequently - typically 30-60 times per second. + + // AdvanceFrameForTexturing returns the most recent frame decoded, for texturing. + // It will return zero if the first frame has not been decoded, but otherwise + // will always return a texture. + LPDIRECT3DTEXTURE8 AdvanceFrameForTexturing( LPDIRECT3DDEVICE8 pDevice ); + + // AdvanceFrameForOverlays returns newly decoded frames, for use as an overlays. + // You MUST call UpdateOverlay() with the texture's surface. + // It will return zero if there is not a *new* frame available. + LPDIRECT3DTEXTURE8 AdvanceFrameForOverlays( LPDIRECT3DDEVICE8 pDevice ); + + // Get information about the movie playing. + DWORD GetWidth() const { return m_VideoDesc.Width; } + DWORD GetHeight() const { return m_VideoDesc.Height; } + DWORD GetCurrentFrame() const { return m_dwCurrentFrame; } + DWORD GetElapsedTime() const { return m_bPlaying ? GetTickCount() - m_dwStartTime : 0; } + + // IsPlaying returns TRUE if a movie has been opened but has not ended or been destroyed. + BOOL IsPlaying() const { return m_bPlaying; } + BOOL IsFailed() const { return m_bError; } + + // Call TerminatePlayback on the decoder. It may take a few hundred ms before the movie stops. + // This function is thread safe, as long as you ensure that you don't call Destroy() in another + // thread simultaneously. + void TerminatePlayback(); + HRESULT Play( DWORD Flags, RECT* pRect ); + + // Call this to enable overlays if you will be playing the movie in an overlay using + // AdvanceFrame. The overlays will be disabled when Destroy() is called. + void EnableOverlays( LPDIRECT3DDEVICE8 pDevice ); + +private: + XMVDecoder* m_pXMVDecoder; // Pointer to the XMV decoder object. + XMVVIDEO_DESC m_VideoDesc; // Description of the .xmv files video data. + XMVAUDIO_DESC m_AudioDesc; // Description of the .xmv files audio data. + LPDIRECT3DTEXTURE8 m_pTextures[XMVPLAYER_NUMTEXTURES]; // Textures to cycle through. + DWORD m_nDecodeTextureIndex; // Index of the current texture to decode to. + + // These texture pointers are copies of the values in m_pTextures. They are used to track + // the decode/display/pending status. + // When displaying using textures pShowingTexture points to the texture to display, + // pDecodingTexture points to the texture to decode into, and pSubmittedTexture is always + // zero. + // When displaying using overlays pShowingTexture points to the texture that the hardware + // is currently displaying, pDecodingTexture points to the texture to decode into, and + // pSubmittedTexture is a surface that has been submitted to the overlay system, but not + // necessarily displayed yet. At any given time one of these is always zero. When + // pDecodingTexture is zero that means that pShowingTexture might be being displayed, or + // the hardware might have switched to pSubmittedTexture, we don't know yet. + LPDIRECT3DTEXTURE8 pShowingTexture; + LPDIRECT3DTEXTURE8 pDecodingTexture; + LPDIRECT3DTEXTURE8 pSubmittedTexture; + + int m_dwCurrentFrame; // Current frame number - minus one if not yet started. + DWORD m_dwStartTime; + + BOOL m_bPlaying; // Is a movie currently playing? + BOOL m_bOverlaysEnabled; // Are overlays enabled? For disabling them on destroy. + LPDIRECT3DDEVICE8 m_pDevice; // For use by Destroy to disable overlays. + BOOL m_bError; + + LOAD_CONTEXT m_loadContext; // Data for communicating with packet callback functions. + + BYTE* m_physicalBuffer; // Pointer to block of physical memory used for loading packets. + + // Helper function for opening files. + HRESULT FinishOpeningFile( D3DFORMAT Format, LPDIRECT3DDEVICE8 pDevice, BOOL bAllocateTextures ); + + // Copy constructor and assignment operator are private and unimplemented + // to prevent unintentional, unsupported, and disastrous copying. + CXMVPlayer( const CXMVPlayer& source ); + CXMVPlayer& operator=( const CXMVPlayer& source ); +}; + +#endif //#ifndef _XMVPLAYER_H_ diff --git a/utils/xbox/xbspinfo/xbspinfo.cpp b/utils/xbox/xbspinfo/xbspinfo.cpp new file mode 100644 index 0000000..8a968ff --- /dev/null +++ b/utils/xbox/xbspinfo/xbspinfo.cpp @@ -0,0 +1,430 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Spews BSP Info +// +//=====================================================================================// + +#include "xbspinfo.h" + +BEGIN_BYTESWAP_DATADESC( dheader_t ) + DEFINE_FIELD( ident, FIELD_INTEGER ), + DEFINE_FIELD( version, FIELD_INTEGER ), + DEFINE_EMBEDDED_ARRAY( lumps, HEADER_LUMPS ), + DEFINE_FIELD( mapRevision, FIELD_INTEGER ), +END_BYTESWAP_DATADESC() + +BEGIN_BYTESWAP_DATADESC( lump_t ) + DEFINE_FIELD( fileofs, FIELD_INTEGER ), + DEFINE_FIELD( filelen, FIELD_INTEGER ), + DEFINE_FIELD( version, FIELD_INTEGER ), + DEFINE_ARRAY( fourCC, FIELD_CHARACTER, 4 ), +END_BYTESWAP_DATADESC() + +typedef struct +{ + const char *pFriendlyName; + const char *pName; + int lumpNum; +} lumpName_t; + +lumpName_t g_lumpNames[] = +{ + {"Entities", "LUMP_ENTITIES", LUMP_ENTITIES}, + {"Planes", "LUMP_PLANES", LUMP_PLANES}, + {"TexData", "LUMP_TEXDATA", LUMP_TEXDATA}, + {"Vertexes", "LUMP_VERTEXES", LUMP_VERTEXES}, + {"Visibility", "LUMP_VISIBILITY", LUMP_VISIBILITY}, + {"Nodes", "LUMP_NODES", LUMP_NODES}, + {"TexInfo", "LUMP_TEXINFO", LUMP_TEXINFO}, + {"Faces", "LUMP_FACES", LUMP_FACES}, + {"Face IDs", "LUMP_FACEIDS", LUMP_FACEIDS}, + {"Lighting", "LUMP_LIGHTING", LUMP_LIGHTING}, + {"Occlusion", "LUMP_OCCLUSION", LUMP_OCCLUSION}, + {"Leafs", "LUMP_LEAFS", LUMP_LEAFS}, + {"Edges", "LUMP_EDGES", LUMP_EDGES}, + {"Surf Edges", "LUMP_SURFEDGES", LUMP_SURFEDGES}, + {"Models", "LUMP_MODELS", LUMP_MODELS}, + {"World Lights", "LUMP_WORLDLIGHTS", LUMP_WORLDLIGHTS}, + {"Leaf Faces", "LUMP_LEAFFACES", LUMP_LEAFFACES}, + {"Leaf Brushes", "LUMP_LEAFBRUSHES", LUMP_LEAFBRUSHES}, + {"Brushes", "LUMP_BRUSHES", LUMP_BRUSHES}, + {"Brush Sides", "LUMP_BRUSHSIDES", LUMP_BRUSHSIDES}, + {"Areas", "LUMP_AREAS", LUMP_AREAS}, + {"Area Portals", "LUMP_AREAPORTALS", LUMP_AREAPORTALS}, + {"Disp Info", "LUMP_DISPINFO", LUMP_DISPINFO}, + {"Original Faces", "LUMP_ORIGINALFACES", LUMP_ORIGINALFACES}, + {"Phys Disp", "LUMP_PHYSDISP", LUMP_PHYSDISP}, + {"Phys Collide", "LUMP_PHYSCOLLIDE", LUMP_PHYSCOLLIDE}, + {"Vert Normals", "LUMP_VERTNORMALS", LUMP_VERTNORMALS}, + {"Vert Normal Indices", "LUMP_VERTNORMALINDICES", LUMP_VERTNORMALINDICES}, + {"Disp Lightmap Alphas", "LUMP_DISP_LIGHTMAP_ALPHAS", LUMP_DISP_LIGHTMAP_ALPHAS}, + {"Disp Verts", "LUMP_DISP_VERTS", LUMP_DISP_VERTS}, + {"Disp Lightmap Sample Positions", "LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS", LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS}, + {"Game Lump", "LUMP_GAME_LUMP", LUMP_GAME_LUMP}, + {"Leaf Water Data", "LUMP_LEAFWATERDATA", LUMP_LEAFWATERDATA}, + {"Primitives", "LUMP_PRIMITIVES", LUMP_PRIMITIVES}, + {"Prim Verts", "LUMP_PRIMVERTS", LUMP_PRIMVERTS}, + {"Prim Indices", "LUMP_PRIMINDICES", LUMP_PRIMINDICES}, + {"Pak File", "LUMP_PAKFILE", LUMP_PAKFILE}, + {"Clip Portal Verts", "LUMP_CLIPPORTALVERTS", LUMP_CLIPPORTALVERTS}, + {"Cube Maps", "LUMP_CUBEMAPS", LUMP_CUBEMAPS}, + {"Tex Data String Data", "LUMP_TEXDATA_STRING_DATA", LUMP_TEXDATA_STRING_DATA}, + {"Tex Data String Table", "LUMP_TEXDATA_STRING_TABLE", LUMP_TEXDATA_STRING_TABLE}, + {"Overlays", "LUMP_OVERLAYS", LUMP_OVERLAYS}, + {"Leaf Min Dist To Water", "LUMP_LEAFMINDISTTOWATER", LUMP_LEAFMINDISTTOWATER}, + {"Face Macro Texture Info", "LUMP_FACE_MACRO_TEXTURE_INFO", LUMP_FACE_MACRO_TEXTURE_INFO}, + {"Disp Tris", "LUMP_DISP_TRIS", LUMP_DISP_TRIS}, + {"Phys Collide Surface", "LUMP_PHYSCOLLIDESURFACE", LUMP_PHYSCOLLIDESURFACE}, + {"Water Overlays", "LUMP_WATEROVERLAYS", LUMP_WATEROVERLAYS}, + {"Leaf Ambient index HDR", "LUMP_LEAF_AMBIENT_INDEX_HDR", LUMP_LEAF_AMBIENT_INDEX_HDR}, + {"Leaf Ambient index", "LUMP_LEAF_AMBIENT_INDEX", LUMP_LEAF_AMBIENT_INDEX}, + {"Lighting (HDR)", "LUMP_LIGHTING_HDR", LUMP_LIGHTING_HDR}, + {"World Lights (HDR)", "LUMP_WORLDLIGHTS_HDR", LUMP_WORLDLIGHTS_HDR}, + {"Leaf Ambient Lighting (HDR)", "LUMP_LEAF_AMBIENT_LIGHTING_HDR", LUMP_LEAF_AMBIENT_LIGHTING_HDR}, + {"Leaf Ambient Lighting", "LUMP_LEAF_AMBIENT_LIGHTING", LUMP_LEAF_AMBIENT_LIGHTING}, + {"*** DEAD ***", "LUMP_XZIPPAKFILE", LUMP_XZIPPAKFILE}, + {"Faces (HDR)", "LUMP_FACES_HDR", LUMP_FACES_HDR}, + {"Flags", "LUMP_MAP_FLAGS", LUMP_MAP_FLAGS}, + {"Fade Overlays", "LUMP_OVERLAY_FADES", LUMP_OVERLAY_FADES}, +}; + +bool g_bQuiet; +bool g_bAsPercent; +bool g_bAsBytes; +bool g_bSortByOffset; +bool g_bSortBySize; +bool g_bFriendlyNames; + +//----------------------------------------------------------------------------- +// Convert lump ID to descriptive Name +//----------------------------------------------------------------------------- +const char *BSP_LumpNumToName( int lumpNum ) +{ + int i; + + for ( i=0; i<ARRAYSIZE( g_lumpNames ); ++i ) + { + if ( g_lumpNames[i].lumpNum == lumpNum ) + { + if ( g_bFriendlyNames ) + { + return g_lumpNames[i].pFriendlyName; + } + else + { + return g_lumpNames[i].pName; + } + } + } + + return "???"; +} + +//----------------------------------------------------------------------------- +// Extract Lump Pak +//----------------------------------------------------------------------------- +void ExtractZip( const char *pFilename, void *pBSPFile ) +{ + dheader_t *pBSPHeader = (dheader_t *)pBSPFile; + + if ( pBSPHeader->lumps[LUMP_PAKFILE].filelen ) + { + Msg( "Extracting Zip to %s\n", pFilename ); + + FILE *fp = fopen( pFilename, "wb" ); + if ( !fp ) + { + Warning( "Failed to create %s\n", pFilename ); + return; + } + + fwrite( (unsigned char *)pBSPFile + pBSPHeader->lumps[LUMP_PAKFILE].fileofs, pBSPHeader->lumps[LUMP_PAKFILE].filelen, 1, fp ); + fclose( fp ); + } + else + { + Msg( "Nothing to do!\n" ); + } +} + +// compare function for qsort below +static dheader_t *g_pSortBSPHeader; +static int LumpCompare( const void *pElem1, const void *pElem2 ) +{ + int lump1 = *(byte *)pElem1; + int lump2 = *(byte *)pElem2; + + int fileOffset1 = g_pSortBSPHeader->lumps[lump1].fileofs; + int fileOffset2 = g_pSortBSPHeader->lumps[lump2].fileofs; + + int fileSize1 = g_pSortBSPHeader->lumps[lump1].filelen; + int fileSize2 = g_pSortBSPHeader->lumps[lump2].filelen; + + if ( g_bSortByOffset ) + { + // invalid or empty lumps will get sorted together + if ( !fileSize1 ) + { + fileOffset1 = 0; + } + + if ( !fileSize2 ) + { + fileOffset2 = 0; + } + + // compare by offset + if ( fileOffset1 < fileOffset2 ) + { + return -1; + } + else if ( fileOffset1 > fileOffset2 ) + { + return 1; + } + } + else if ( g_bSortBySize ) + { + if ( fileSize1 < fileSize2 ) + { + return -1; + } + else if ( fileSize1 > fileSize2 ) + { + return 1; + } + } + + return 0; +} + +//----------------------------------------------------------------------------- +// Spew Info +//----------------------------------------------------------------------------- +void DumpInfo( const char *pFilename, void *pBSPFile, int bspSize ) +{ + const char *pName; + dheader_t *pBSPHeader; + + pBSPHeader = (dheader_t *)pBSPFile; + + Msg( "\n" ); + Msg( "%s\n", pFilename ); + + // sort by offset order + int readOrder[HEADER_LUMPS]; + for ( int i=0; i<HEADER_LUMPS; i++ ) + { + readOrder[i] = i; + } + + if ( g_bSortByOffset || g_bSortBySize ) + { + g_pSortBSPHeader = pBSPHeader; + qsort( readOrder, HEADER_LUMPS, sizeof( int ), LumpCompare ); + } + + for ( int i=0; i<HEADER_LUMPS; ++i ) + { + int lump = readOrder[i]; + pName = BSP_LumpNumToName( lump ); + if ( !pName ) + continue; + + if ( g_bSortByOffset ) + { + Msg( "[Offset: 0x%8.8x] ", pBSPHeader->lumps[lump].fileofs ); + } + + if ( g_bAsPercent ) + { + Msg( "%5.2f%s (%2d) %s\n", 100.0f*pBSPHeader->lumps[lump].filelen/( float )bspSize, "%%", lump, pName ); + } + else if ( g_bAsBytes ) + { + Msg( "%8d: (%2d) %s\n", pBSPHeader->lumps[lump].filelen, lump, pName ); + } + else + { + Msg( "%5.2f MB: (%2d) %s\n", pBSPHeader->lumps[lump].filelen/( 1024.0f*1024.0f ), lump, pName ); + } + } + + Msg( "-------\n" ); + if ( g_bAsBytes ) + { + Msg( "%8d: %s\n", bspSize, "Total Bytes" ); + } + else + { + Msg( "%6.2f MB %s\n", bspSize/( 1024.0f*1024.0f ), "Total" ); + } +} + +//----------------------------------------------------------------------------- +// Load the bsp file +//----------------------------------------------------------------------------- +bool LoadBSPFile( const char* pFilename, void **ppBSPBuffer, int *pBSPSize ) +{ + CByteswap byteSwap; + + *ppBSPBuffer = NULL; + *pBSPSize = 0; + + FILE *fp = fopen( pFilename, "rb" ); + if ( fp ) + { + fseek( fp, 0, SEEK_END ); + int size = ftell( fp ); + fseek( fp, 0, SEEK_SET ); + + *ppBSPBuffer = malloc( size ); + if ( !*ppBSPBuffer ) + { + Warning( "Failed to alloc %d bytes\n", size ); + goto cleanUp; + } + + *pBSPSize = size; + fread( *ppBSPBuffer, size, 1, fp ); + fclose( fp ); + } + else + { + if ( !g_bQuiet ) + { + Warning( "Missing %s\n", pFilename ); + } + goto cleanUp; + } + + dheader_t *pBSPHeader = (dheader_t *)*ppBSPBuffer; + + if ( pBSPHeader->ident != IDBSPHEADER ) + { + if ( pBSPHeader->ident != BigLong( IDBSPHEADER ) ) + { + if ( !g_bQuiet ) + { + Warning( "BSP %s has bad id: got %d, expected %d\n", pFilename, pBSPHeader->ident, IDBSPHEADER ); + } + goto cleanUp; + } + else + { + // bsp is for 360, swap the header + byteSwap.ActivateByteSwapping( true ); + byteSwap.SwapFieldsToTargetEndian( pBSPHeader ); + } + } + + if ( pBSPHeader->version < MINBSPVERSION || pBSPHeader->version > BSPVERSION ) + { + if ( !g_bQuiet ) + { + Warning( "BSP %s has bad version: got %d, expected %d\n", pFilename, pBSPHeader->version, BSPVERSION ); + } + goto cleanUp; + } + + // sucess + return true; + +cleanUp: + if ( *ppBSPBuffer ) + { + free( *ppBSPBuffer ); + *ppBSPBuffer = NULL; + } + + return false; +} + +//----------------------------------------------------------------------------- +// Purpose: Usage +//----------------------------------------------------------------------------- +void Usage( void ) +{ + Msg( "usage: bspinfo <bspfile> [options]\n" ); + Msg( "options:\n" ); + Msg( "-percent, -p: Show as percentages\n" ); + Msg( "-bytes, -b: Show as bytes\n" ); + Msg( "-q: Quiet, no header, no errors\n" ); + Msg( "-names: Show friendly lump names\n" ); + Msg( "-so: Sort by offset\n" ); + Msg( "-ss: Sort by size\n" ); + Msg( "-extract <zipname>: Extract pak file\n" ); + + exit( -1 ); +} + +//----------------------------------------------------------------------------- +// Purpose: default output func +//----------------------------------------------------------------------------- +SpewRetval_t OutputFunc( SpewType_t spewType, char const *pMsg ) +{ + printf( pMsg ); + + if ( spewType == SPEW_ERROR ) + { + return SPEW_ABORT; + } + return ( spewType == SPEW_ASSERT ) ? SPEW_DEBUGGER : SPEW_CONTINUE; +} + +//----------------------------------------------------------------------------- +// main +// +//----------------------------------------------------------------------------- +int main( int argc, char* argv[] ) +{ + char bspPath[MAX_PATH]; + + // set the valve library printer + SpewOutputFunc( OutputFunc ); + + CommandLine()->CreateCmdLine( argc, argv ); + + Msg( "\nXBSPINFO - Valve Xbox 360 BSP Info ( Build: %s %s )\n", __DATE__, __TIME__ ); + Msg( "( C ) Copyright 1996-2006, Valve Corporation, All rights reserved.\n\n" ); + + if ( argc < 2 || CommandLine()->FindParm( "?" ) || CommandLine()->FindParm( "-h" ) || CommandLine()->FindParm( "-help" ) ) + { + Usage(); + } + + if ( argc >= 2 && argv[1][0] != '-' ) + { + strcpy( bspPath, argv[1] ); + } + else + { + Usage(); + } + + g_bQuiet = CommandLine()->FindParm( "-q" ) != 0; + g_bAsPercent = CommandLine()->FindParm( "-p" ) != 0 || CommandLine()->FindParm( "-percent" ) != 0; + g_bAsBytes = CommandLine()->FindParm( "-b" ) != 0 || CommandLine()->FindParm( "-bytes" ) != 0; + g_bSortByOffset = CommandLine()->FindParm( "-so" ) != 0; + g_bSortBySize = CommandLine()->FindParm( "-ss" ) != 0; + g_bFriendlyNames = CommandLine()->FindParm( "-names" ) != 0; + + void *pBSPBuffer; + int bspSize; + if ( LoadBSPFile( bspPath, &pBSPBuffer, &bspSize ) ) + { + const char *pZipName = CommandLine()->ParmValue( "-extract", "" ); + if ( pZipName && pZipName[0] ) + { + ExtractZip( pZipName, pBSPBuffer ); + } + else + { + DumpInfo( bspPath, pBSPBuffer, bspSize ); + } + + free( pBSPBuffer ); + } + + return ( 0 ); +}
\ No newline at end of file diff --git a/utils/xbox/xbspinfo/xbspinfo.h b/utils/xbox/xbspinfo/xbspinfo.h new file mode 100644 index 0000000..45a31a3 --- /dev/null +++ b/utils/xbox/xbspinfo/xbspinfo.h @@ -0,0 +1,27 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +//=====================================================================================// + +#pragma once + +#include <windows.h> +#include <stdio.h> +#include <stdlib.h> +#include <direct.h> +#include <io.h> +#include <time.h> +#include <fcntl.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <sys/utime.h> +#include "icommandline.h" +#include "tier1/strtools.h" +#include "tier1/utlvector.h" +#include "tier1/utlbuffer.h" +#include "tier1/utlstring.h" +#include "datamap.h" +#include "byteswap.h" +#include "../../common/bsplib.h" + diff --git a/utils/xbox/xbspinfo/xbspinfo.vpc b/utils/xbox/xbspinfo/xbspinfo.vpc new file mode 100644 index 0000000..3b36ea8 --- /dev/null +++ b/utils/xbox/xbspinfo/xbspinfo.vpc @@ -0,0 +1,23 @@ +//----------------------------------------------------------------------------- +// XBSPINFO.VPC +// +// Project Script +//----------------------------------------------------------------------------- + +$Macro SRCDIR "..\..\.." +$Macro OUTBINDIR "$SRCDIR\devtools\bin" + +$Include "$SRCDIR\vpc_scripts\source_exe_con_win32_base.vpc" + +$Project "xbspinfo" +{ + $Folder "Source Files" + { + $File "xbspinfo.cpp" + } + + $Folder "Header Files" + { + $File "xbspinfo.h" + } +} diff --git a/utils/xbox/xcompress/xcompress.cpp b/utils/xbox/xcompress/xcompress.cpp new file mode 100644 index 0000000..df87f00 --- /dev/null +++ b/utils/xbox/xcompress/xcompress.cpp @@ -0,0 +1,357 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +#include <windows.h> +#include <stdlib.h> +#include <stdio.h> +#include <conio.h> +#include <assert.h> +#include "../../../public/jcalg1.h" + +#define DEFAULT_BLOCK_READ_SIZE (512*1024) +#define BLOCK_SIZE (16*1024) +#define WINDOW_SIZE (16*1024) + +static unsigned g_BlockReadSize = DEFAULT_BLOCK_READ_SIZE; + + +static void * __stdcall jcalgAlloc(DWORD size) +{ + return malloc(size); +} + +static bool __stdcall jcalgDealloc(void* pointer) +{ + free(pointer); + return true; +} + +void decompress( char* filenameIn, char* filenameOut ) +{ + FILE* hIn = fopen( filenameIn, "rb" ); + if( !hIn ) + { + printf("Failed to open input file: %s\n",filenameIn); + return; + } + + FILE* hOut = fopen( filenameOut, "wb+" ); + if( !hIn ) + { + printf("Failed to open output file: %s\n",filenameOut); + fclose(hIn); + return; + } + + char* inputBuffer = (char*)malloc( g_BlockReadSize ); + + xCompressHeader header; + fread(&header,1,sizeof(header), hIn ); + fseek(hIn, 0, SEEK_SET); + + char* outputBuffer = (char *)malloc( header.nDecompressionBufferSize ); + + + for(;;) + { + + // Read in a buffer full of compressed data. + unsigned bytesRead = (unsigned)fread(inputBuffer,1,g_BlockReadSize, hIn ); + if( !bytesRead ) + break; + + unsigned outputBufferLength; + + xCompressHeader* header = (xCompressHeader*)inputBuffer; + if( header->nMagic == xCompressHeader::MAGIC + && header->VERSION == xCompressHeader::VERSION ) + { + + printf("Found header:\n" + "\t%i Version\n" + "\t%i Uncompressed Size\n" + "\t%i ReadBlockSize\n" + "\t%i DecompressionBufferSize\n",header->nVersion, header->nUncompressedFileSize,header->nReadBlockSize,header->nDecompressionBufferSize ); + + outputBufferLength = JCALG1_Decompress_Formatted_Buffer( bytesRead - sizeof(*header), inputBuffer + sizeof(*header), g_BlockReadSize * 8, outputBuffer ); + + } + else + { + outputBufferLength = JCALG1_Decompress_Formatted_Buffer( bytesRead, inputBuffer, g_BlockReadSize * 8, outputBuffer ); + } + + assert(0xFFFFFFFF != outputBufferLength ); + fwrite( outputBuffer,1,outputBufferLength, hOut); + + printf("block:%u\n", outputBufferLength); + } + + free(inputBuffer); + free(outputBuffer); + + fclose(hIn); + fclose(hOut); +} + +void compressSimple(char* filenameIn, char* filenameOut ) +{ + FILE* hIn = fopen( filenameIn, "rb" ); + if( !hIn ) + { + printf("Failed to open input file: %s\n",filenameIn); + return; + } + + fseek(hIn, 0, SEEK_END); + unsigned uncompressedSize = ftell(hIn); + fseek(hIn, 0, SEEK_SET); + + char* uncompressedData = (char*)malloc( uncompressedSize ); + fread( uncompressedData,1,uncompressedSize, hIn ); + fclose(hIn); + + char* compressedData = (char*)malloc( uncompressedSize * 4 + sizeof( xCompressSimpleHeader )); + int compressedSize = JCALG1_Compress( + uncompressedData, + uncompressedSize, + compressedData + sizeof( xCompressSimpleHeader ), + uncompressedSize, + jcalgAlloc, + jcalgDealloc, + NULL, + true); + + xCompressSimpleHeader* header = (xCompressSimpleHeader*)compressedData; + header->nMagic = xCompressSimpleHeader::MAGIC; + header->nUncompressedSize = uncompressedSize; + compressedSize += sizeof( xCompressSimpleHeader ); + + + printf("uncompressed size: %uk, compressedSize = %uk\n",uncompressedSize/1024, compressedSize / 1024); + + FILE* hOut = fopen( filenameOut, "wb+" ); + if( !hIn ) + { + printf("Failed to open output file: %s\n",filenameOut); + fclose(hIn); + return; + } + fwrite( compressedData, 1, compressedSize, hOut ); + fclose( hOut ); +} + +void decompressSimple(char* filenameIn, char* filenameOut ) +{ + FILE* hIn = fopen( filenameIn, "rb" ); + if( !hIn ) + { + printf("Failed to open input file: %s\n",filenameIn); + return; + } + + fseek(hIn, 0, SEEK_END); + unsigned compressedSize = ftell(hIn); + fseek(hIn, 0, SEEK_SET); + + char* compressedData = (char*)malloc( compressedSize ); + fread( compressedData,1,compressedSize, hIn ); + fclose(hIn); + + char* decompressedData = (char*)malloc( ((xCompressSimpleHeader*)compressedData)->nUncompressedSize ); + + unsigned decompressedSize = JCALG1_Decompress_Simple_Buffer( compressedData, decompressedData ); + FILE* hOut = fopen( filenameOut, "wb+" ); + if( !hIn ) + { + printf("Failed to open output file: %s\n",filenameOut); + fclose(hIn); + return; + } + fwrite( decompressedData, 1, decompressedSize, hOut ); + fclose( hOut ); +} + + +int main( int argc, char* argv[] ) +{ + if( argc < 4 || argc > 5) + { + puts("USAGE: xcompress [c|d|cs|ds] <inputfile> <outputfile> [readsizekb]"); + puts("\nIf cs is specified, a 'simple' archive is created. (unaligned and decompresses the entire thing to a buffer)"); + return EXIT_FAILURE; + } + + if( !strcmpi(argv[1],"d") ) + { + decompress( argv[2], argv[3] ); + return EXIT_SUCCESS; + + } + + if( !strcmpi(argv[1],"cs") ) + { + compressSimple(argv[2], argv[3]); + return EXIT_SUCCESS; + } + + if( !strcmpi(argv[1],"ds") ) + { + decompressSimple(argv[2], argv[3]); + return EXIT_SUCCESS; + } + + + FILE* hIn = fopen( argv[2], "rb" ); + if( !hIn ) + { + printf("Failed to open input file: %s\n",argv[2]); + return EXIT_FAILURE; + } + fseek( hIn, 0, SEEK_END ); + unsigned nInputLength = ftell( hIn ); + fseek( hIn, 0, SEEK_SET ); + + // Grab + if( argc >= 5 ) + { + g_BlockReadSize = atoi(argv[4]) * 1024; + if( g_BlockReadSize <= 0 ) + { + printf("Invalid block read size! %s\n", argv[4]); + return EXIT_FAILURE; + } + } + + printf("\nOptimized for read block size: %u\n",g_BlockReadSize); + + FILE* hOut = fopen( argv[3], "wb+" ); + if( !hIn ) + { + printf("Failed to open output file: %s\n",argv[3]); + fclose(hIn); + return EXIT_FAILURE; + } + + unsigned char inputBuffer[BLOCK_SIZE]; + unsigned char outputBuffer[BLOCK_SIZE * 2]; + unsigned bytesThisBlock = 0, // Total output bytes this block + inputBytesThisBlock = 0, // Total input bytes this block + totalBytes = 0, + inputBytes = 0; + + // Set up and write out the header; + xCompressHeader header; + header.nMagic = xCompressHeader::MAGIC; + header.nVersion = xCompressHeader::VERSION; + header.nUncompressedFileSize = nInputLength; + header.nReadBlockSize = g_BlockReadSize; + header.nDecompressionBufferSize = 0; + header.nWindowSize = WINDOW_SIZE; + + totalBytes = bytesThisBlock = inputBytesThisBlock = sizeof(header); + fwrite(&header,1,sizeof(header),hOut); + + + + + while(1) + { + // Read an input buffer full of data: + size_t bytesRead = fread(inputBuffer,1,sizeof(inputBuffer),hIn); + if( !bytesRead ) + break; + + inputBytes += (unsigned)bytesRead; + + unsigned compressedSize = JCALG1_Compress( + inputBuffer, + (unsigned)bytesRead, + outputBuffer + sizeof(short), + 16384, + jcalgAlloc, + jcalgDealloc, + NULL, + true); + + unsigned outputBufferSize; + + // If we couldn't compress this block, just write it out: + if( compressedSize == 0 ) + { + outputBufferSize = (unsigned)(bytesRead + sizeof(unsigned short)); + *((unsigned short*)outputBuffer) = ((unsigned short)bytesRead) | 0x8000; + memcpy(outputBuffer+2,inputBuffer,bytesRead); + } + // Tag the compression header onto this block: + else + { + outputBufferSize = compressedSize + sizeof(unsigned short); + *((unsigned short*)outputBuffer) = compressedSize; + } + + // Do we have enough room in this chunk to fit this buffer? + if( bytesThisBlock + outputBufferSize > g_BlockReadSize ) + { + // no, first align it: + while( bytesThisBlock < g_BlockReadSize ) + { + char b = 0; + fwrite( &b, 1, sizeof(b), hOut ); + bytesThisBlock++; + totalBytes++; + } + + // Compute the minimum size of the decompression buffer: + if( inputBytesThisBlock > header.nDecompressionBufferSize ) + { + header.nDecompressionBufferSize = inputBytesThisBlock; + } + + // Start a new block: + bytesThisBlock = 0; + inputBytesThisBlock = 0; + } + + // Write the chunk out: + fwrite(outputBuffer,1, outputBufferSize, hOut); + inputBytesThisBlock += bytesRead; + bytesThisBlock+=outputBufferSize; + totalBytes+=outputBufferSize; + + static int counter =0; + counter++; + + if( counter % 4 == 0 ) + { + printf("\r \rInput:%uk Output:%uk (%0.1f%%)",inputBytes / 1024,totalBytes / 1024, ( (double)totalBytes / (double)inputBytes ) * 100); + fflush(stdout); + } + } + + // Grab the last block (may be the only block)Compute the minimum size of the decompression buffer: + if( inputBytesThisBlock > header.nDecompressionBufferSize ) + { + header.nDecompressionBufferSize = inputBytesThisBlock; + inputBytesThisBlock = 0; + } + + unsigned short terminator = 0; + fwrite(&terminator, 1, sizeof(terminator), hOut ); + + // Align the file to a 2k boundary. + while( ( ftell(hOut) % 2048 ) != 0) + { + fwrite(&terminator,1,1,hOut); + } + + // Write the header out again, this time with ideal decompression size: + header.nDecompressionBufferSize += 128; + + fseek( hOut, 0, SEEK_SET ); + fwrite(&header,1,sizeof(header),hOut); + + + printf("\n"); + fclose(hIn); + fclose(hOut); + +}
\ No newline at end of file diff --git a/utils/xbox/xcompress/xcompress.sln b/utils/xbox/xcompress/xcompress.sln new file mode 100644 index 0000000..4a59466 --- /dev/null +++ b/utils/xbox/xcompress/xcompress.sln @@ -0,0 +1,21 @@ +Microsoft Visual Studio Solution File, Format Version 8.00 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "xcompress", "xcompress.vcproj", "{14872A1D-B112-4092-9ABD-BFF782B80E43}" + ProjectSection(ProjectDependencies) = postProject + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfiguration) = preSolution + Debug = Debug + Release = Release + EndGlobalSection + GlobalSection(ProjectConfiguration) = postSolution + {14872A1D-B112-4092-9ABD-BFF782B80E43}.Debug.ActiveCfg = Debug|Win32 + {14872A1D-B112-4092-9ABD-BFF782B80E43}.Debug.Build.0 = Debug|Win32 + {14872A1D-B112-4092-9ABD-BFF782B80E43}.Release.ActiveCfg = Release|Win32 + {14872A1D-B112-4092-9ABD-BFF782B80E43}.Release.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + EndGlobalSection + GlobalSection(ExtensibilityAddIns) = postSolution + EndGlobalSection +EndGlobal diff --git a/utils/xbox/xcompress/xcompress.vcproj b/utils/xbox/xcompress/xcompress.vcproj new file mode 100644 index 0000000..f9c43cc --- /dev/null +++ b/utils/xbox/xcompress/xcompress.vcproj @@ -0,0 +1,127 @@ +<?xml version="1.0" encoding="Windows-1252"?> +<VisualStudioProject + ProjectType="Visual C++" + Version="7.10" + Name="xcompress" + ProjectGUID="{14872A1D-B112-4092-9ABD-BFF782B80E43}" + Keyword="Win32Proj"> + <Platforms> + <Platform + Name="Win32"/> + </Platforms> + <Configurations> + <Configuration + Name="Debug|Win32" + OutputDirectory="..\..\..\..\game\bin" + IntermediateDirectory="Debug" + ConfigurationType="1" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + Optimization="0" + PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE" + MinimalRebuild="TRUE" + BasicRuntimeChecks="3" + RuntimeLibrary="5" + UsePrecompiledHeader="0" + WarningLevel="3" + Detect64BitPortabilityProblems="TRUE" + DebugInformationFormat="4"/> + <Tool + Name="VCCustomBuildTool"/> + <Tool + Name="VCLinkerTool" + OutputFile="$(OutDir)/xcompress.exe" + LinkIncremental="2" + GenerateDebugInformation="TRUE" + ProgramDatabaseFile="$(OutDir)/xcompress.pdb" + SubSystem="1" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool"/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + <Configuration + Name="Release|Win32" + OutputDirectory="Release" + IntermediateDirectory="Release" + ConfigurationType="1" + CharacterSet="2"> + <Tool + Name="VCCLCompilerTool" + PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE" + RuntimeLibrary="4" + UsePrecompiledHeader="0" + WarningLevel="3" + Detect64BitPortabilityProblems="TRUE" + DebugInformationFormat="3"/> + <Tool + Name="VCCustomBuildTool" + CommandLine="if exist ..\..\..\..\game\bin\"$(TargetName)".exe attrib -r ..\..\..\..\game\bin\"$(TargetName)".exe +if exist "$(TargetPath)" copy "$(TargetPath)" ..\..\..\..\game\bin +" + Outputs="..\..\..\..\game\bin\$(TargetName).exe"/> + <Tool + Name="VCLinkerTool" + OutputFile="$(OutDir)/xcompress.exe" + LinkIncremental="1" + GenerateDebugInformation="TRUE" + SubSystem="1" + OptimizeReferences="2" + EnableCOMDATFolding="2" + TargetMachine="1"/> + <Tool + Name="VCMIDLTool"/> + <Tool + Name="VCPostBuildEventTool"/> + <Tool + Name="VCPreBuildEventTool"/> + <Tool + Name="VCPreLinkEventTool"/> + <Tool + Name="VCResourceCompilerTool"/> + <Tool + Name="VCWebServiceProxyGeneratorTool"/> + <Tool + Name="VCXMLDataGeneratorTool"/> + <Tool + Name="VCWebDeploymentTool"/> + <Tool + Name="VCManagedWrapperGeneratorTool"/> + <Tool + Name="VCAuxiliaryManagedWrapperGeneratorTool"/> + </Configuration> + </Configurations> + <References> + </References> + <Files> + <File + RelativePath="..\..\..\public\jcalg1.h"> + </File> + <File + RelativePath="..\..\..\lib\public\jcalg1_static.lib"> + </File> + <File + RelativePath=".\xcompress.cpp"> + </File> + </Files> + <Globals> + </Globals> +</VisualStudioProject> |
