//-----------------------------------------------------------------------------
// The application main loop
//-----------------------------------------------------------------------------
int CIHVTestApp::Main()
{
SpewOutputFunc( IHVTestSpewFunc );
if ( !SetupStudioRender() )
{
return 0;
}
if ( !InitMaterialSystem( m_hWnd ) )
{
return 0;
}
#if !defined( _X360 ) // X360TBD:
extern void Sys_InitFloatTime( void ); //garymcthack
Sys_InitFloatTime();
#endif
LoadModels();
#if USE_VTUNE
VTResume();
#endif
#ifdef USE_VPROF
g_VProfCurrentProfile.Start();
#endif
bool m_bExitMainLoop = false;
while (!m_bExitMainLoop && !g_BenchFinished)
{
AppPumpMessages();
RenderFrame();
}
#ifdef USE_VPROF
g_VProfCurrentProfile.Stop();
#endif
g_IHVTestFP = fopen( "ihvtest_vprof.txt", "w" );
#ifdef USE_VPROF
SpewOutputFunc( IHVTestVProfSpewFunc );
g_VProfCurrentProfile.OutputReport( VPRT_SUMMARY );
g_VProfCurrentProfile.OutputReport( VPRT_HIERARCHY_TIME_PER_FRAME_AND_COUNT_ONLY );
fclose( g_IHVTestFP );
SpewOutputFunc( IHVTestSpewFunc );
#endif
#if USE_VTUNE
VTPause();
#endif
return 0;
}
virtual void OnEnable() override
{
f = fopen("spewlog.txt", "w");
RealOutputFunc = GetSpewOutputFunc();
SpewOutputFunc(&MyOutputFunc);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : argc -
// argv[] -
// Output : int
//-----------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
SpewOutputFunc( SpewFunc );
Msg( "Valve Software - vcprojtomake.exe (%s)\n", __DATE__ );
Msg( "Modified for VS2010 Support by Killer Monkey\n" );
Msg( "<*****@*****.**>\n" );
CommandLine()->CreateCmdLine( argc, argv );
if ( CommandLine()->ParmCount() < 2)
{
printusage();
return 0;
}
CVCProjConvert proj;
if ( !proj.LoadProject( CommandLine()->GetParm( 1 )) )
{
Msg( "Failed to parse project\n" );
return -1;
}
OutputKeyValuesVersion(proj);
CMakefileCreator makefile;
makefile.CreateMakefiles( proj );
return 0;
}
//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
bool CDmxConvertApp::Create()
{
SpewOutputFunc( DMXConvertOutputFunc );
AddSystem( g_pDataModel, VDATAMODEL_INTERFACE_VERSION );
AddSystem( g_pDmSerializers, DMSERIALIZERS_INTERFACE_VERSION );
return true;
}
//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
bool CSFMGenApp::Create()
{
SpewOutputFunc( SpewStdout );
AppSystemInfo_t appSystems[] =
{
{ "vstdlib.dll", PROCESS_UTILS_INTERFACE_VERSION },
{ "materialsystem.dll", MATERIAL_SYSTEM_INTERFACE_VERSION },
{ "p4lib.dll", P4_INTERFACE_VERSION },
{ "datacache.dll", DATACACHE_INTERFACE_VERSION },
{ "datacache.dll", MDLCACHE_INTERFACE_VERSION },
{ "studiorender.dll", STUDIO_RENDER_INTERFACE_VERSION },
{ "vphysics.dll", VPHYSICS_INTERFACE_VERSION },
{ "soundemittersystem.dll", SOUNDEMITTERSYSTEM_INTERFACE_VERSION },
{ "", "" } // Required to terminate the list
};
AddSystems( appSystems );
IMaterialSystem *pMaterialSystem = reinterpret_cast< IMaterialSystem * >( FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION ) );
if ( !pMaterialSystem )
{
Error( "// ERROR: Unable to connect to material system interface!\n" );
return false;
}
pMaterialSystem->SetShaderAPI( "shaderapiempty.dll" );
SetupDefaultFlexController();
return true;
}
int Open(lua_State *L) {
ml_Lua = Lua();
OldSpew = GetSpewOutputFunc();
SpewOutputFunc(NewSpew);
ml_Lua->SetGlobal("SPEW_MESSAGE", (float)SPEW_MESSAGE);
ml_Lua->SetGlobal("SPEW_WARNING", (float)SPEW_WARNING);
ml_Lua->SetGlobal("SPEW_ASSERT", (float)SPEW_ASSERT);
ml_Lua->SetGlobal("SPEW_ERROR", (float)SPEW_ERROR);
ml_Lua->SetGlobal("SPEW_LOG", (float)SPEW_LOG);
ml_Lua->SetGlobal("SPEW_TYPE_COUNT", (float)SPEW_TYPE_COUNT);
ml_Lua->SetGlobal("SPEW_DEBUGGER", (float)SPEW_DEBUGGER);
ml_Lua->SetGlobal("SPEW_CONTINUE", (float)SPEW_CONTINUE);
ml_Lua->SetGlobal("SPEW_TYPE_COUNT", (float)SPEW_TYPE_COUNT);
ml_Lua->SetGlobal("SPEW_ABORT", (float)SPEW_ABORT);
ml_Lua->NewGlobalTable("simplespew");
ILuaObject* simplespew = ml_Lua->GetGlobal("simplespew");
simplespew->SetMember("Remove", RemoveSpew);
simplespew->UnReference();
AddRemoveHook("ShutDown");
AddRemoveHook("OnConfirmQuit"); //Extras
return 0;
}
void RunInDLL( const char *pFilename, CUtlVector<char*> &newArgv )
{
if ( g_pConnMgr )
g_pConnMgr->SetAppState( VMPI_SERVICE_STATE_BUSY );
bool bSuccess = false;
CSysModule *pModule = Sys_LoadModule( pFilename );
if ( pModule )
{
CreateInterfaceFn fn = Sys_GetFactory( pModule );
if ( fn )
{
ILaunchableDLL *pDLL = (ILaunchableDLL*)fn( LAUNCHABLE_DLL_INTERFACE_VERSION, NULL );
if( pDLL )
{
// Do this here because the executables we would have launched usually would do it.
CommandLine()->CreateCmdLine( newArgv.Count(), newArgv.Base() );
pDLL->main( newArgv.Count(), newArgv.Base() );
bSuccess = true;
SpewOutputFunc( MySpewOutputFunc );
}
}
Sys_UnloadModule( pModule );
}
if ( !bSuccess )
{
Msg( "Error running VRAD (or VVIS) out of DLL '%s'\n", pFilename );
}
if ( g_pConnMgr )
g_pConnMgr->SetAppState( VMPI_SERVICE_STATE_IDLE );
}
void InstallSpewFunction()
{
setvbuf( stdout, NULL, _IONBF, 0 );
setvbuf( stderr, NULL, _IONBF, 0 );
SpewOutputFunc( CmdLib_SpewOutputFunc );
GetInitialColors();
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
CommandLine()->CreateCmdLine( Plat_GetCommandLine() );
// TODO: Place code here.
SpewOutputFunc( D3DAppSpewFunc );
MathLib_Init( true, true, true, 2.2f, 2.2f, 0.0f, 2.0f );
MSG msg;
HACCEL hAccelTable;
// Initialize global strings
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
strcpy( szWindowClass, "d3dapp" );
MyRegisterClass(hInstance);
// Perform application initialization:
if (!InitInstance (hInstance, nCmdShow))
{
return FALSE;
}
hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_TERRAINBLEND);
InvalidateRect( g_hWnd, NULL, FALSE );
// Main message loop:
while(1)
{
while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
if(msg.message == WM_QUIT)
break;
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
if(msg.message == WM_QUIT)
break;
CallAppRender( false );
}
AppExit();
return msg.wParam;
}
//-----------------------------------------------------------------------------
// Create all singleton systems
//-----------------------------------------------------------------------------
bool CHLModelViewerApp::Create()
{
SpewOutputFunc( HLMVSpewFunc );
g_dxlevel = CommandLine()->ParmValue( "-dx", 0 );
g_bOldFileDialogs = ( CommandLine()->FindParm( "-olddialogs" ) != 0 );
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 },
{ "soundsystem.dll", SOUNDSYSTEM_INTERFACE_VERSION },
{ "", "" } // Required to terminate the list
};
if ( !AddSystems( appSystems ) )
return false;
g_pFileSystem = (IFileSystem*)FindSystem( FILESYSTEM_INTERFACE_VERSION );
g_pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION );
g_pMaterialSystemHardwareConfig = (IMaterialSystemHardwareConfig*)FindSystem( MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION );
g_pStudioRender = (IStudioRender*)FindSystem( STUDIO_RENDER_INTERFACE_VERSION );
g_pDataCache = (IDataCache*)FindSystem( DATACACHE_INTERFACE_VERSION );
g_pMDLCache = (IMDLCache*)FindSystem( MDLCACHE_INTERFACE_VERSION );
g_pStudioDataCache = (IStudioDataCache*)FindSystem( STUDIO_DATA_CACHE_INTERFACE_VERSION );
physcollision = (IPhysicsCollision *)FindSystem( VPHYSICS_COLLISION_INTERFACE_VERSION );
physprop = (IPhysicsSurfaceProps *)FindSystem( VPHYSICS_SURFACEPROPS_INTERFACE_VERSION );
g_pSoundEmitterBase = (ISoundEmitterSystemBase *)FindSystem( SOUNDEMITTERSYSTEM_INTERFACE_VERSION );
g_pSoundSystem = (ISoundSystem *)FindSystem( SOUNDSYSTEM_INTERFACE_VERSION );
if ( !g_pFileSystem || !physprop || !physcollision || !g_pMaterialSystem || !g_pStudioRender || !g_pMDLCache || !g_pDataCache )
{
Error("Unable to load required library interface!\n");
}
const char *pShaderDLL = CommandLine()->ParmValue("-shaderdll");
if(!pShaderDLL)
{
pShaderDLL = "shaderapidx9.dll";
}
g_pMaterialSystem->SetShaderAPI( pShaderDLL );
g_Factory = GetFactory();
return true;
}
//-----------------------------------------------------------------------------
// 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 );
}
//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
bool CPCFFixApp::Create()
{
SpewOutputFunc( SpewStdout );
AppSystemInfo_t appSystems[] =
{
{ "p4lib.dll", P4_INTERFACE_VERSION },
{ "", "" } // Required to terminate the list
};
AddSystems( appSystems );
return true;
}
//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
bool CUnitTestApp::Create()
{
// Install a special Spew handler that ignores all assertions and lets us
// run for as long as possible
SpewOutputFunc( UnitTestSpew );
// FIXME: This list of dlls should come from the unittests themselves
AppSystemInfo_t appSystems[] =
{
{ "vstdlib.dll", PROCESS_UTILS_INTERFACE_VERSION },
{ "", "" } // Required to terminate the list
};
if ( !AddSystems( appSystems ) )
return false;
// Very simple... just iterate over all .DLLs in the current directory
// see if they export UNITTEST_INTERFACE_VERSION. If not, then unload them
// just as quick.
// We may want to make this more sophisticated, giving it a search path,
// or giving test DLLs special extensions, or statically linking the test DLLs
// to this program.
WIN32_FIND_DATA findFileData;
HANDLE hFind= FindFirstFile("*.dll", &findFileData);
while (hFind != INVALID_HANDLE_VALUE)
{
CSysModule* hLib = Sys_LoadModule(findFileData.cFileName);
if ( hLib )
{
CreateInterfaceFn factory = Sys_GetFactory( hLib );
if ( factory && factory( UNITTEST_INTERFACE_VERSION, NULL ) )
{
AppModule_t module = LoadModule( factory );
AddSystem( module, UNITTEST_INTERFACE_VERSION );
}
else
{
Sys_UnloadModule( hLib );
}
}
if (!FindNextFile( hFind, &findFileData ))
break;
}
return true;
}
//-----------------------------------------------------------------------------
// Create all singleton systems
//-----------------------------------------------------------------------------
bool CInputTestApp::Create()
{
SpewOutputFunc( SpewFunc );
AppSystemInfo_t appSystems[] =
{
{ "inputsystem.dll", INPUTSYSTEM_INTERFACE_VERSION },
{ "", "" } // Required to terminate the list
};
if ( !AddSystems( appSystems ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Create all singleton systems
//-----------------------------------------------------------------------------
bool CMaterialSystemTestApp::Create()
{
SpewOutputFunc( SpewFunc );
AppSystemInfo_t appSystems[] =
{
{ "materialsystem.dll", MATERIAL_SYSTEM_INTERFACE_VERSION },
// Required to terminate the list
{ "", "" }
};
if ( !AddSystems( appSystems ) )
return false;
IMaterialSystem *pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION );
if ( !pMaterialSystem )
{
Warning( "CMaterialSystemTestApp::Create: Unable to connect to necessary interface!\n" );
return false;
}
bool bIsVistaOrHigher = false;
OSVERSIONINFO info;
info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if ( GetVersionEx( &info ) )
{
bIsVistaOrHigher = info.dwMajorVersion >= 6;
}
const char *pShaderDLL = CommandLine()->ParmValue( "-shaderdll" );
if ( !pShaderDLL )
{
pShaderDLL = "shaderapidx10.dll";
}
if ( !bIsVistaOrHigher && !Q_stricmp( pShaderDLL, "shaderapidx10.dll" ) )
{
pShaderDLL = "shaderapidx9.dll";
}
pMaterialSystem->SetShaderAPI( pShaderDLL );
return true;
}
//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
bool CVConfigApp::Create()
{
SpewOutputFunc( VConfig_SpewOutputFunc );
// If they pass in -game, just set the registry key to the value they asked for.
const char *pSetGame = CommandLine()->ParmValue( "-game" );
if ( pSetGame )
{
SetMayaScriptSettings( );
SetXSIScriptSettings( );
SetPathSettings( );
SetVConfigRegistrySetting( GAMEDIR_TOKEN, pSetGame );
return false;
}
AppSystemInfo_t appSystems[] =
{
{ "inputsystem.dll", INPUTSYSTEM_INTERFACE_VERSION },
{ "vgui2.dll", VGUI_IVGUI_INTERFACE_VERSION },
{ "", "" } // Required to terminate the list
};
return AddSystems( appSystems );
}
//-----------------------------------------------------------------------------
// The application object
//-----------------------------------------------------------------------------
bool CDmxEditApp::Create()
{
SpewOutputFunc( SpewStdout );
AppSystemInfo_t appSystems[] =
{
{ "vstdlib.dll", PROCESS_UTILS_INTERFACE_VERSION },
{ "materialsystem.dll", MATERIAL_SYSTEM_INTERFACE_VERSION },
{ "p4lib.dll", P4_INTERFACE_VERSION },
{ "", "" } // Required to terminate the list
};
AddSystems( appSystems );
IMaterialSystem *pMaterialSystem = reinterpret_cast< IMaterialSystem * >( FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION ) );
if ( !pMaterialSystem )
{
Error( "// ERROR: Unable to connect to material system interface!\n" );
return false;
}
pMaterialSystem->SetShaderAPI( "shaderapiempty.dll" );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : argc -
// argv[] -
// Output : int
//-----------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
SpewOutputFunc( SpewFunc );
SpewActivate( "demoinfo", 2 );
int i;
for ( i=1 ; i<argc ; i++)
{
if ( argv[ i ][ 0 ] == '-' )
{
switch( argv[ i ][ 1 ] )
{
case 'l':
uselogfile = true;
break;
case 'v':
verbose = true;
break;
case 'g':
++i;
break;
default:
printusage();
break;
}
}
}
if ( argc < 2 || ( i != argc ) )
{
PrintHeader();
printusage();
}
CheckLogFile();
PrintHeader();
vprint( 0, " Info for %s..\n", argv[ i - 1 ] );
char workingdir[ 256 ];
workingdir[0] = 0;
Q_getwd( workingdir, sizeof( workingdir ) );
if ( !FileSystem_Init( NULL, 0, FS_INIT_FULL ) )
return 1;
// Add this so relative filenames work.
g_pFullFileSystem->AddSearchPath( workingdir, "game", PATH_ADD_TO_HEAD );
// Load the demo
CSmoothingContext context;
LoadSmoothingInfo( argv[ i - 1 ], context );
// Note to tool makers:
// Do your work here!!!
//Performsmoothing( context );
// Save out updated .dem file
// UNCOMMENT THIS TO ENABLE OUTPUTTING NEW .DEM FILES!!!
// SaveSmoothingInfo( argv[ i - 1 ], context );
FileSystem_Term();
return 0;
}
virtual void OnDisable() override
{
SpewOutputFunc(RealOutputFunc);
fclose(f);
}
int main(int argc, char* argv[])
{
SpewOutputFunc( MySpewFunc );
// Figure out a random port to use.
CCycleCount cnt;
cnt.Sample();
CUniformRandomStream randomStream;
randomStream.SetSeed( cnt.GetMicroseconds() );
int iPort = randomStream.RandomInt( 20000, 30000 );
g_ClientPacketEvent.Init( false, false );
// Setup the "server".
CHandlerCreator_Server serverHandler;
CIPAddr addr( 127, 0, 0, 1, iPort );
ITCPConnectSocket *pListener = ThreadedTCP_CreateListener(
&serverHandler,
(unsigned short)iPort );
// Setup the "client".
CHandlerCreator_Client clientCreator;
ITCPConnectSocket *pConnector = ThreadedTCP_CreateConnector(
CIPAddr( 127, 0, 0, 1, iPort ),
CIPAddr(),
&clientCreator );
// Wait for them to connect.
while ( !g_pClientSocket )
{
if ( !pConnector->Update( &g_pClientSocket ) )
{
Error( "Error in client connector!\n" );
}
}
pConnector->Release();
while ( !g_pServerSocket )
{
if ( !pListener->Update( &g_pServerSocket ) )
Error( "Error in server connector!\n" );
}
pListener->Release();
// Send some data.
__int64 totalBytes = 0;
CCycleCount startTime;
int iPacket = 1;
startTime.Sample();
CUtlVector<char> buf;
while ( (GetAsyncKeyState( VK_SHIFT ) & 0x8000) == 0 )
{
int size = randomStream.RandomInt( 1024*0, 1024*320 );
if ( buf.Count() < size )
buf.SetSize( size );
if ( g_pClientSocket->Send( buf.Base(), size ) )
{
// Server receives the data and echoes it back. Verify that the data is good.
WaitForSingleObject( g_ClientPacketEvent.GetEventHandle(), INFINITE );
Assert( memcmp( g_ClientPacket.Base(), buf.Base(), size ) == 0 );
totalBytes += size;
CCycleCount curTime, elapsed;
curTime.Sample();
CCycleCount::Sub( curTime, startTime, elapsed );
double flSeconds = elapsed.GetSeconds();
Msg( "Packet %d, %d bytes, %dk/sec\n", iPacket++, size, (int)(((totalBytes+511)/1024) / flSeconds) );
}
}
g_pClientSocket->Release();
g_pServerSocket->Release();
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : argc -
// argv[] -
// Output : int
//-----------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
SpewOutputFunc( SpewFunc );
SpewActivate( "vcd_sound_check", 2 );
int i=1;
for ( i ; i<argc ; i++)
{
if ( argv[ i ][ 0 ] == '-' )
{
switch( argv[ i ][ 1 ] )
{
case 'l':
uselogfile = true;
break;
case 'v':
verbose = true;
break;
case 'm':
spewmoveto = true;
break;
case 'o':
vcdonly = true;
break;
default:
printusage();
break;
}
}
}
if ( argc < 3 || ( i != argc ) )
{
PrintHeader();
printusage();
}
CheckLogFile();
PrintHeader();
vprint( 0, " Looking for .wav files not referenced in .vcd files...\n" );
char sounddir[ 256 ];
char vcddir[ 256 ];
strcpy( sounddir, argv[ i - 2 ] );
strcpy( vcddir, argv[ i - 1 ] );
if ( !strstr( sounddir, "sound" ) )
{
vprint( 0, "Sound dir %s looks invalid (format: u:/tf2/hl2/sound/vo)\n", sounddir );
return 0;
}
if ( !strstr( vcddir, "scenes" ) )
{
vprint( 0, ".vcd dir %s looks invalid (format: u:/tf2/hl2/scenes)\n", vcddir );
return 0;
}
char workingdir[ 256 ];
workingdir[0] = 0;
Q_getwd( workingdir, sizeof( workingdir ) );
// If they didn't specify -game on the command line, use VPROJECT.
CmdLib_InitFileSystem( workingdir );
CSysModule *pSoundEmitterModule = g_pFullFileSystem->LoadModule( "soundemittersystem.dll" );
if ( !pSoundEmitterModule )
{
vprint( 0, "Sys_LoadModule( soundemittersystem.dll ) failed!\n" );
return 0;
}
CreateInterfaceFn hSoundEmitterFactory = Sys_GetFactory( pSoundEmitterModule );
if ( !hSoundEmitterFactory )
{
vprint( 0, "Sys_GetFactory on soundemittersystem.dll failed!\n" );
return 0;
}
soundemitter = ( ISoundEmitterSystemBase * )hSoundEmitterFactory( SOUNDEMITTERSYSTEM_INTERFACE_VERSION, NULL );
if ( !soundemitter )
{
vprint( 0, "Couldn't get interface %s from soundemittersystem.dll!\n", SOUNDEMITTERSYSTEM_INTERFACE_VERSION );
return 0;
}
filesystem = (IFileSystem *)(CmdLib_GetFileSystemFactory()( FILESYSTEM_INTERFACE_VERSION, NULL ));
if ( !filesystem )
{
AssertMsg( 0, "Failed to create/get IFileSystem" );
return 1;
}
Q_FixSlashes( gamedir );
Q_strlower( gamedir );
vprint( 0, "game dir %s\nsounds dir %s\nvcd dir %s\n\n",
gamedir,
sounddir,
vcddir );
Q_StripTrailingSlash( sounddir );
Q_StripTrailingSlash( vcddir );
filesystem->RemoveFile( "moveto.txt", "GAME" );
//
//ProcessMaterialsDirectory( vmtdir );
vprint( 0, "Initializing sound emitter system\n" );
soundemitter->Connect( FileSystem_GetFactory() );
soundemitter->Init();
vprint( 0, "Loaded %i sounds\n", soundemitter->GetSoundCount() );
vprint( 0, "Building list of .vcd files\n" );
CUtlVector< CUtlSymbol > vcdfiles;
BuildFileList( vcdfiles, vcddir, ".vcd" );
vprint( 0, "found %i .vcd files\n\n", vcdfiles.Count() );
vprint( 0, "Building list of known .wav files\n" );
CUtlVector< CUtlSymbol > wavfiles;
BuildFileList( wavfiles, sounddir, ".wav" );
vprint( 0, "found %i .wav files\n\n", wavfiles.Count() );
CorrelateWavsAndVCDs( vcdfiles, wavfiles );
soundemitter->Shutdown();
soundemitter = 0;
g_pFullFileSystem->UnloadModule( pSoundEmitterModule );
FileSystem_Term();
return 0;
}
int main( int argc, char **argv )
{
SpewOutputFunc( VTF2TGAOutputFunc );
CommandLine()->CreateCmdLine( argc, argv );
MathLib_Init( 2.2f, 2.2f, 0.0f, 1.0f, false, false, false, false );
InitDefaultFileSystem();
const char *pVTFFileName = CommandLine()->ParmValue( "-i" );
const char *pTGAFileName = CommandLine()->ParmValue( "-o" );
bool bGenerateMipLevels = CommandLine()->CheckParm( "-mip" ) != NULL;
if ( !pVTFFileName )
{
Usage();
}
if ( !pTGAFileName )
{
pTGAFileName = pVTFFileName;
}
char pCurrentDirectory[MAX_PATH];
if ( _getcwd( pCurrentDirectory, sizeof(pCurrentDirectory) ) == NULL )
{
fprintf( stderr, "Unable to get the current directory\n" );
return -1;
}
Q_StripTrailingSlash( pCurrentDirectory );
char pBuf[MAX_PATH];
if ( !Q_IsAbsolutePath( pTGAFileName ) )
{
Q_snprintf( pBuf, sizeof(pBuf), "%s\\%s", pCurrentDirectory, pTGAFileName );
}
else
{
Q_strncpy( pBuf, pTGAFileName, sizeof(pBuf) );
}
Q_FixSlashes( pBuf );
char pOutFileNameBase[MAX_PATH];
Q_StripExtension( pBuf, pOutFileNameBase, MAX_PATH );
char pActualVTFFileName[MAX_PATH];
Q_strncpy( pActualVTFFileName, pVTFFileName, MAX_PATH );
if ( !Q_strstr( pActualVTFFileName, ".vtf" ) )
{
Q_strcat( pActualVTFFileName, ".vtf", MAX_PATH );
}
FILE *vtfFp = fopen( pActualVTFFileName, "rb" );
if( !vtfFp )
{
Error( "Can't open %s\n", pActualVTFFileName );
exit( -1 );
}
fseek( vtfFp, 0, SEEK_END );
int srcVTFLength = ftell( vtfFp );
fseek( vtfFp, 0, SEEK_SET );
CUtlBuffer buf;
buf.EnsureCapacity( srcVTFLength );
int nBytesRead = fread( buf.Base(), 1, srcVTFLength, vtfFp );
fclose( vtfFp );
buf.SeekPut( CUtlBuffer::SEEK_HEAD, nBytesRead );
IVTFTexture *pTex = CreateVTFTexture();
if (!pTex->Unserialize( buf ))
{
Error( "*** Error reading in .VTF file %s\n", pActualVTFFileName );
exit(-1);
}
Msg( "vtf width: %d\n", pTex->Width() );
Msg( "vtf height: %d\n", pTex->Height() );
Msg( "vtf numFrames: %d\n", pTex->FrameCount() );
Msg( "TEXTUREFLAGS_POINTSAMPLE=%s\n", ( pTex->Flags() & TEXTUREFLAGS_POINTSAMPLE ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_TRILINEAR=%s\n", ( pTex->Flags() & TEXTUREFLAGS_TRILINEAR ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_CLAMPS=%s\n", ( pTex->Flags() & TEXTUREFLAGS_CLAMPS ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_CLAMPT=%s\n", ( pTex->Flags() & TEXTUREFLAGS_CLAMPT ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_CLAMPU=%s\n", ( pTex->Flags() & TEXTUREFLAGS_CLAMPU ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_BORDER=%s\n", ( pTex->Flags() & TEXTUREFLAGS_BORDER ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_ANISOTROPIC=%s\n", ( pTex->Flags() & TEXTUREFLAGS_ANISOTROPIC ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_HINT_DXT5=%s\n", ( pTex->Flags() & TEXTUREFLAGS_HINT_DXT5 ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_SRGB=%s\n", ( pTex->Flags() & TEXTUREFLAGS_SRGB ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_NORMAL=%s\n", ( pTex->Flags() & TEXTUREFLAGS_NORMAL ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_NOMIP=%s\n", ( pTex->Flags() & TEXTUREFLAGS_NOMIP ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_NOLOD=%s\n", ( pTex->Flags() & TEXTUREFLAGS_NOLOD ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_ALL_MIPS=%s\n", ( pTex->Flags() & TEXTUREFLAGS_ALL_MIPS ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_PROCEDURAL=%s\n", ( pTex->Flags() & TEXTUREFLAGS_PROCEDURAL ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_ONEBITALPHA=%s\n", ( pTex->Flags() & TEXTUREFLAGS_ONEBITALPHA ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_EIGHTBITALPHA=%s\n", ( pTex->Flags() & TEXTUREFLAGS_EIGHTBITALPHA ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_ENVMAP=%s\n", ( pTex->Flags() & TEXTUREFLAGS_ENVMAP ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_RENDERTARGET=%s\n", ( pTex->Flags() & TEXTUREFLAGS_RENDERTARGET ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_DEPTHRENDERTARGET=%s\n", ( pTex->Flags() & TEXTUREFLAGS_DEPTHRENDERTARGET ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_NODEBUGOVERRIDE=%s\n", ( pTex->Flags() & TEXTUREFLAGS_NODEBUGOVERRIDE ) ? "true" : "false" );
Msg( "TEXTUREFLAGS_SINGLECOPY=%s\n", ( pTex->Flags() & TEXTUREFLAGS_SINGLECOPY ) ? "true" : "false" );
Vector vecReflectivity = pTex->Reflectivity();
Msg( "vtf reflectivity: %f %f %f\n", vecReflectivity[0], vecReflectivity[1], vecReflectivity[2] );
Msg( "transparency: " );
if( pTex->Flags() & TEXTUREFLAGS_EIGHTBITALPHA )
{
Msg( "eightbitalpha\n" );
}
else if( pTex->Flags() & TEXTUREFLAGS_ONEBITALPHA )
{
Msg( "onebitalpha\n" );
}
else
{
Msg( "noalpha\n" );
}
ImageFormat srcFormat = pTex->Format();
Msg( "vtf format: %s\n", ImageLoader::GetName( srcFormat ) );
int iTGANameLen = Q_strlen( pOutFileNameBase );
int iFaceCount = pTex->FaceCount();
int nFrameCount = pTex->FrameCount();
bool bIsCubeMap = pTex->IsCubeMap();
int iLastMipLevel = bGenerateMipLevels ? pTex->MipCount() - 1 : 0;
for( int iFrame = 0; iFrame < nFrameCount; ++iFrame )
{
for ( int iMipLevel = 0; iMipLevel <= iLastMipLevel; ++iMipLevel )
{
int iWidth, iHeight, iDepth;
pTex->ComputeMipLevelDimensions( iMipLevel, &iWidth, &iHeight, &iDepth );
for (int iCubeFace = 0; iCubeFace < iFaceCount; ++iCubeFace)
{
for ( int z = 0; z < iDepth; ++z )
{
// Construct output filename
char *pTempNameBuf = (char *)stackalloc( iTGANameLen + 13 );
Q_strncpy( pTempNameBuf, pOutFileNameBase, iTGANameLen + 1 );
char *pExt = Q_strrchr( pTempNameBuf, '.' );
if ( pExt )
{
pExt = 0;
}
if ( bIsCubeMap )
{
Assert( pTex->Depth() == 1 ); // shouldn't this be 1 instead of 0?
static const char *pCubeFaceName[7] = { "rt", "lf", "bk", "ft", "up", "dn", "sph" };
Q_strcat( pTempNameBuf, pCubeFaceName[iCubeFace], iTGANameLen + 13 );
}
if ( nFrameCount > 1 )
{
char pTemp[4];
Q_snprintf( pTemp, 4, "%03d", iFrame );
Q_strcat( pTempNameBuf, pTemp, iTGANameLen + 13 );
}
if ( iLastMipLevel != 0 )
{
char pTemp[8];
Q_snprintf( pTemp, 8, "_mip%d", iMipLevel );
Q_strcat( pTempNameBuf, pTemp, iTGANameLen + 13 );
}
if ( pTex->Depth() > 1 )
{
char pTemp[6];
Q_snprintf( pTemp, 6, "_z%03d", z );
Q_strcat( pTempNameBuf, pTemp, iTGANameLen + 13 );
}
if( srcFormat == IMAGE_FORMAT_RGBA16161616F )
{
Q_strcat( pTempNameBuf, ".pfm", iTGANameLen + 13 );
}
else
{
Q_strcat( pTempNameBuf, ".tga", iTGANameLen + 13 );
}
unsigned char *pSrcImage = pTex->ImageData( iFrame, iCubeFace, iMipLevel, 0, 0, z );
ImageFormat dstFormat;
if( srcFormat == IMAGE_FORMAT_RGBA16161616F )
{
dstFormat = IMAGE_FORMAT_RGB323232F;
}
else
{
if( ImageLoader::IsTransparent( srcFormat ) || (srcFormat == IMAGE_FORMAT_ATI1N ) || (srcFormat == IMAGE_FORMAT_ATI2N ))
{
dstFormat = IMAGE_FORMAT_BGRA8888;
}
else
{
dstFormat = IMAGE_FORMAT_BGR888;
}
}
// dstFormat = IMAGE_FORMAT_RGBA8888;
// dstFormat = IMAGE_FORMAT_RGB888;
// dstFormat = IMAGE_FORMAT_BGRA8888;
// dstFormat = IMAGE_FORMAT_BGR888;
// dstFormat = IMAGE_FORMAT_BGRA5551;
// dstFormat = IMAGE_FORMAT_BGR565;
// dstFormat = IMAGE_FORMAT_BGRA4444;
// printf( "dstFormat: %s\n", ImageLoader::GetName( dstFormat ) );
unsigned char *pDstImage = new unsigned char[ImageLoader::GetMemRequired( iWidth, iHeight, 1, dstFormat, false )];
if( !ImageLoader::ConvertImageFormat( pSrcImage, srcFormat,
pDstImage, dstFormat, iWidth, iHeight, 0, 0 ) )
{
Error( "Error converting from %s to %s\n",
ImageLoader::GetName( srcFormat ), ImageLoader::GetName( dstFormat ) );
exit( -1 );
}
if( dstFormat != IMAGE_FORMAT_RGB323232F )
{
if( ImageLoader::IsTransparent( dstFormat ) && ( dstFormat != IMAGE_FORMAT_RGBA8888 ) )
{
unsigned char *tmpImage = pDstImage;
pDstImage = new unsigned char[ImageLoader::GetMemRequired( iWidth, iHeight, 1, IMAGE_FORMAT_RGBA8888, false )];
if( !ImageLoader::ConvertImageFormat( tmpImage, dstFormat, pDstImage, IMAGE_FORMAT_RGBA8888,
iWidth, iHeight, 0, 0 ) )
{
Error( "Error converting from %s to %s\n",
ImageLoader::GetName( dstFormat ), ImageLoader::GetName( IMAGE_FORMAT_RGBA8888 ) );
}
dstFormat = IMAGE_FORMAT_RGBA8888;
}
else if( !ImageLoader::IsTransparent( dstFormat ) && ( dstFormat != IMAGE_FORMAT_RGB888 ) )
{
unsigned char *tmpImage = pDstImage;
pDstImage = new unsigned char[ImageLoader::GetMemRequired( iWidth, iHeight, 1, IMAGE_FORMAT_RGB888, false )];
if( !ImageLoader::ConvertImageFormat( tmpImage, dstFormat, pDstImage, IMAGE_FORMAT_RGB888,
iWidth, iHeight, 0, 0 ) )
{
Error( "Error converting from %s to %s\n",
ImageLoader::GetName( dstFormat ), ImageLoader::GetName( IMAGE_FORMAT_RGB888 ) );
}
dstFormat = IMAGE_FORMAT_RGB888;
}
CUtlBuffer outBuffer;
TGAWriter::WriteToBuffer( pDstImage, outBuffer, iWidth, iHeight,
dstFormat, dstFormat );
if ( !g_pFullFileSystem->WriteFile( pTempNameBuf, NULL, outBuffer ) )
{
fprintf( stderr, "unable to write %s\n", pTempNameBuf );
}
}
else
{
PFMWrite( ( float * )pDstImage, pTempNameBuf, iWidth, iHeight );
}
}
}
}
}
// leak leak leak leak leak, leak leak, leak leak (Blue Danube)
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : argc -
// argv[] -
// Output : int
//-----------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
SpewOutputFunc( SpewFunc );
SpewActivate( "unusedcontent", 2 );
CommandLine()->CreateCmdLine( argc, argv );
int i=1;
for ( i ; i<argc ; i++)
{
if ( argv[ i ][ 0 ] == '-' )
{
switch( argv[ i ][ 1 ] )
{
case 'l':
uselogfile = true;
break;
case 'v':
verbose = true;
break;
case 'r':
showreferencedfiles = true;
break;
case 'd':
spewdeletions = true;
break;
case 'i':
immediatedelete = true;
break;
case 'w':
printwhitelist = true;
break;
case 'm':
showmapfileusage = true;
break;
case 'g':
// Just skip -game
Assert( !Q_stricmp( argv[ i ], "-game" ) );
++i;
break;
case 'f':
// grab reslists folder
{
++i;
Q_strncpy( g_szReslistDir, argv[ i ], sizeof( g_szReslistDir ) );
Q_strlower( g_szReslistDir );
Q_FixSlashes( g_szReslistDir );
Q_AppendSlash( g_szReslistDir, sizeof( g_szReslistDir ) );
}
break;
default:
printusage();
break;
}
}
}
if ( argc < 3 || ( i != argc ) )
{
PrintHeader();
printusage();
return 0;
}
CheckLogFile();
PrintHeader();
vprint( 0, " Using reslist dir '%s'\n", g_szReslistDir );
vprint( 0, " Looking for extraneous content...\n" );
char resfile[ 256 ];
strcpy( resfile, argv[ i - 1 ] );
vprint( 0, " Comparing results of resfile (%s) with files under current directory...\n", resfile );
char workingdir[ 256 ];
workingdir[0] = 0;
Q_getwd( workingdir, sizeof( workingdir ) );
// If they didn't specify -game on the command line, use VPROJECT.
CmdLib_InitFileSystem( workingdir );
filesystem = (IFileSystem *)(CmdLib_GetFileSystemFactory()( FILESYSTEM_INTERFACE_VERSION, NULL ));
if ( !filesystem )
{
AssertMsg( 0, "Failed to create/get IFileSystem" );
return 1;
}
g_pFullFileSystem->RemoveAllSearchPaths();
g_pFullFileSystem->AddSearchPath(gamedir, "GAME");
Q_strlower( gamedir );
Q_FixSlashes( gamedir );
//
//ProcessMaterialsDirectory( vmtdir );
// find out the mod dir name
Q_strncpy( modname, gamedir, sizeof(modname) );
modname[ strlen(modname) - 1] = 0;
if ( strrchr( modname, '\\' ) )
{
Q_strncpy( modname, strrchr( modname, '\\' ) + 1, sizeof(modname) );
}
else
{
Q_strncpy( modname, "", sizeof(modname) );
}
vprint( 1, "Mod Name:%s\n", modname);
BuildCheckdirList();
BuildWhiteList();
vprint( 0, "Building aggregate file list from resfile output\n" );
CUtlRBTree< ReferencedFile, int > referencedfiles( 0, 0, RefFileLessFunc );
CUtlVector< UnusedContent::CUtlSymbol > resfiles;
BuildReferencedFileList( resfiles, referencedfiles, resfile );
vprint( 0, "found %i files\n\n", referencedfiles.Count() );
vprint( 0, "Building list of all game content files\n" );
CUtlVector< FileEntry > contentfiles;
CUtlVector< FileEntry > otherfiles;
BuildFileList( 0, contentfiles, &otherfiles, "", 0 );
vprint( 0, "found %i files in content tree\n\n", contentfiles.Count() );
Correlate( referencedfiles, contentfiles, modname );
// now output the files not referenced in the whitelist or general reslists
filesystem->RemoveFile( CFmtStr( "%sunreferenced_files.lst", g_szReslistDir ), "GAME" );
int c = otherfiles.Count();
for ( i = 0; i < c; ++i )
{
FileEntry & entry = otherfiles[ i ];
char const *name = g_Analysis.symbols.String( entry.sym );
logprint( CFmtStr( "%sunreferenced_files.lst", g_szReslistDir ), "\"%s\\%s\"\n", modname, name );
}
// also include the files from deletions.bat, as we don't actually run that now
c = contentfiles.Count();
for ( i = 0; i < c; ++i )
{
FileEntry & entry = contentfiles[ i ];
if ( entry.referenced != REFERENCED_NO )
continue;
char const *fn = g_Analysis.symbols.String( entry.sym );
logprint( CFmtStr( "%sunreferenced_files.lst", g_szReslistDir ), "\"%s\\%s\"\n", modname, fn );
}
FileSystem_Term();
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : argc -
// argv[] -
// Output : int
//-----------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
SpewOutputFunc( SpewFunc );
int i = 1;
for (i ; i<argc ; i++)
{
if ( argv[ i ][ 0 ] == '-' )
{
switch( argv[ i ][ 1 ] )
{
case 'l':
uselogfile = true;
break;
case 'v':
verbose = true;
break;
case 'a':
checkani = true;
break;
default:
printusage();
break;
}
}
}
if ( argc < 3 || ( i != argc ) )
{
vprint( 0, "Valve Software - mdlcheck.exe (%s)\n", __DATE__ );
vprint( 0, "--- Source Model Consistency Checker ---\n" );
printusage();
}
CheckLogFile();
vprint( 0, "Valve Software - mdlcheck.exe (%s)\n", __DATE__ );
vprint( 0, "--- Source Model Consistency Checker ---\n" );
vprint( 0, " Looking for messed up .qc and .mdl files...\n" );
char modelsources[ 256 ];
strcpy( modelsources, argv[ i - 2 ] );
char modelsdir[ 256 ];
strcpy( modelsdir, argv[ i - 1 ] );
if ( !strstr( modelsdir, "models" ) )
{
vprint( 0, "Models dir %s looks invalid (format: u:/tf2/hl2/models)\n", modelsdir );
return 0;
}
Q_StripTrailingSlash( modelsources );
Q_StripTrailingSlash( modelsdir );
ProcessSourceDirectory( modelsources );
ProcessModelsDirectory( modelsdir );
CheckForUnbuiltModels( );
return 0;
}
main (int argc, char *argv[])
{
int i;
CommandLine()->CreateCmdLine( argc, argv );
SpewOutputFunc( HLFacePoserSpewFunc );
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
CoInitialize(NULL);
// make sure, we start in the right directory
char szName[256];
strcpy (szName, mx::getApplicationPath() );
mx::init (argc, argv);
sound->Init();
FileSystem_Init( true );
filesystem = (IFileSystem *)(FileSystem_GetFactory()( FILESYSTEM_INTERFACE_VERSION, NULL ));
if ( !filesystem )
{
AssertMsg( 0, "Failed to create/get IFileSystem" );
return 1;
}
char workingdir[ 256 ];
workingdir[0] = 0;
Q_getwd( workingdir );
// If they didn't specify -game on the command line, use VPROJECT.
CmdLib_InitFileSystem( workingdir, true );
IFacePoserToolWindow::EnableToolRedraw( false );
new MDLViewer ();
g_MDLViewer->setMenuBar (g_MDLViewer->getMenuBar ());
g_pStudioModel->Init();
bool modelloaded = false;
for ( i = 1; i < CommandLine()->ParmCount(); i++ )
{
if ( Q_stristr (CommandLine()->GetParm( i ), ".mdl") )
{
modelloaded = true;
g_MDLViewer->LoadModelFile( CommandLine()->GetParm( i ) );
break;
}
}
models->LoadModelList();
if ( models->Count() == 0 )
{
g_pFlexPanel->initFlexes( );
}
// Load expressions from last time
int files = workspacefiles->GetNumStoredFiles( IWorkspaceFiles::EXPRESSION );
for ( i = 0; i < files; i++ )
{
expressions->LoadClass( workspacefiles->GetStoredFile( IWorkspaceFiles::EXPRESSION, i ) );
}
IFacePoserToolWindow::EnableToolRedraw( true );
int retval = mx::run();
soundemitter->BaseShutdown();
if (g_pStudioModel)
{
g_pStudioModel->Shutdown();
g_pStudioModel = NULL;
}
if (g_pMaterialSystem)
{
g_pMaterialSystem->Shutdown();
g_pMaterialSystem = NULL;
}
FileSystem_Term();
CoUninitialize();
return retval;
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
// Hook spew output.
SpewOutputFunc( MySpewOutputFunc );
// Get access to the registry..
RegCreateKey( HKEY_LOCAL_MACHINE, VMPI_SERVICE_KEY, &g_hVMPIServiceKey );
// Setup our version string.
LoadString( hInstance, VMPI_SERVICE_IDS_VERSION_STRING, g_VersionString, sizeof( g_VersionString ) );
// Setup the base app path.
if ( !GetModuleFileName( GetModuleHandle( NULL ), g_BaseAppPath, sizeof( g_BaseAppPath ) ) )
{
Warning( "GetModuleFileName failed.\n" );
return false;
}
V_StripLastDir( g_BaseAppPath, sizeof( g_BaseAppPath ) );
// Setup the cache path.
V_ComposeFileName( g_BaseAppPath, "vmpi_service_cache", g_FileCachePath, sizeof( g_FileCachePath ) );
const char *pArg = FindArg( __argc, __argv, "-mpi_pw", NULL );
SetPassword( pArg );
if ( FindArg( __argc, __argv, "-console" ) )
{
g_RunMode = RUNMODE_CONSOLE;
}
else
{
g_RunMode = RUNMODE_SERVICE;
}
if ( FindArg( __argc, __argv, "-superdebug" ) )
g_bSuperDebugMode = true;
g_AppStartTime = GetTickCount();
g_bMinimized = FindArg( __argc, __argv, "-minimized" ) != NULL;
ServiceHelpers_Init();
g_hInstance = hInstance;
LoadStateFromRegistry();
// Install the service?
if ( g_RunMode == RUNMODE_CONSOLE )
{
RunAsNonServiceApp();
}
else
{
RunService();
}
return 0;
}
int main(int argc, char* argv[])
{
SpewOutputFunc( SceneManagerSpewFunc );
//
// make sure, we start in the right directory
//
char szName[256];
strcpy (szName, mx::getApplicationPath ());
if (argc > 1)
{
strcpy (cmdline, argv[1]);
for (int i = 2; i < argc; i++)
{
strcat (cmdline, " ");
strcat (cmdline, argv[i]);
}
}
mx::init (argc, argv);
FileSystem_Init( true );
filesystem = (IFileSystem *)(FileSystem_GetFactory()( FILESYSTEM_INTERFACE_VERSION, NULL ));
if ( !filesystem )
{
AssertMsg( 0, "Failed to create/get IFileSystem" );
return 1;
}
char workingdir[ 256 ];
workingdir[0] = 0;
Q_getwd( workingdir );
char *vproject = getenv("VPROJECT");
if ( !vproject )
{
mxMessageBox( NULL, "You must set VPROJECT to run scenemanager.exe", "SceneManager", MB_OK );
return -1;
}
// If they didn't specify -game on the command line, use VPROJECT.
CmdLib_InitFileSystem( workingdir, true );
sound->Init();
CWorkspaceManager *sm = new CWorkspaceManager();
bool workspace_loaded = false;
for ( int i = 1; i < argc; i++ )
{
if ( !workspace_loaded && strstr (argv[i], ".vsw") )
{
workspace_loaded = true;
// Strip game directory and slash
char workspace_name[ 512 ];
filesystem->FullPathToRelativePath( argv[ i ], workspace_name );
sm->AutoLoad( workspace_name );
}
}
if ( !workspace_loaded )
{
sm->AutoLoad( NULL );
}
int retval = mx::run ();
sound->Shutdown();
soundemitter->BaseShutdown();
FileSystem_Term();
return retval;
}
void SpewPerfStats( studiohdr_t *pStudioHdr, const char *pFilename, unsigned int flags )
{
char fileName[260];
vertexFileHeader_t *pNewVvdHdr;
vertexFileHeader_t *pVvdHdr = 0;
OptimizedModel::FileHeader_t *pVtxHdr = 0;
studiohwdata_t studioHWData;
int vvdSize = 0;
const char *prefix[] = {".dx80.vtx", ".dx90.vtx", ".sw.vtx"};
s_pSavedSpewFunc = NULL;
if( !( flags & SPEWPERFSTATS_SHOWSTUDIORENDERWARNINGS ) )
{
s_pSavedSpewFunc = GetSpewOutputFunc();
SpewOutputFunc( NullSpewOutputFunc );
}
// no stats on these
if (!pStudioHdr->numbodyparts)
return;
// Need to update the render config to spew perf stats.
UpdateStudioRenderConfig();
// persist the vvd data
Q_StripExtension( pFilename, fileName, sizeof( fileName ) );
strcat( fileName, ".vvd" );
if (FileExists( fileName ))
{
vvdSize = LoadFile( fileName, (void**)&pVvdHdr );
}
else
{
MdlError( "Could not open '%s'\n", fileName );
}
// validate header
if (pVvdHdr->id != MODEL_VERTEX_FILE_ID)
{
MdlError( "Bad id for '%s' (got %d expected %d)\n", fileName, pVvdHdr->id, MODEL_VERTEX_FILE_ID);
}
if (pVvdHdr->version != MODEL_VERTEX_FILE_VERSION)
{
MdlError( "Bad version for '%s' (got %d expected %d)\n", fileName, pVvdHdr->version, MODEL_VERTEX_FILE_VERSION);
}
if (pVvdHdr->checksum != pStudioHdr->checksum)
{
MdlError( "Bad checksum for '%s' (got %d expected %d)\n", fileName, pVvdHdr->checksum, pStudioHdr->checksum);
}
if (pVvdHdr->numFixups)
{
// need to perform mesh relocation fixups
// allocate a new copy
pNewVvdHdr = (vertexFileHeader_t *)malloc( vvdSize );
if (!pNewVvdHdr)
{
MdlError( "Error allocating %d bytes for Vertex File '%s'\n", vvdSize, fileName );
}
Studio_LoadVertexes( pVvdHdr, pNewVvdHdr, 0, true );
// discard original
free( pVvdHdr );
pVvdHdr = pNewVvdHdr;
}
// iterate all ???.vtx files
for (int j=0; j<sizeof(prefix)/sizeof(prefix[0]); j++)
{
// make vtx filename
Q_StripExtension( pFilename, fileName, sizeof( fileName ) );
strcat( fileName, prefix[j] );
// persist the vtx data
if (FileExists(fileName))
{
LoadFile( fileName, (void**)&pVtxHdr );
}
else
{
MdlError( "Could not open '%s'\n", fileName );
}
// validate header
if (pVtxHdr->version != OPTIMIZED_MODEL_FILE_VERSION)
{
MdlError( "Bad version for '%s' (got %d expected %d)\n", fileName, pVtxHdr->version, OPTIMIZED_MODEL_FILE_VERSION );
}
if (pVtxHdr->checkSum != pStudioHdr->checksum)
{
MdlError( "Bad checksum for '%s' (got %d expected %d)\n", fileName, pVtxHdr->checkSum, pStudioHdr->checksum );
}
// studio render will request these through cache interface
pStudioHdr->pVertexBase = (void *)pVvdHdr;
pStudioHdr->pIndexBase = (void *)pVtxHdr;
g_pStudioRender->LoadModel( pStudioHdr, pVtxHdr, &studioHWData );
if( flags & SPEWPERFSTATS_SHOWPERF )
{
if( flags & SPEWPERFSTATS_SPREADSHEET )
{
printf( "%s,%s,%d,", fileName, prefix[j], studioHWData.m_NumLODs - studioHWData.m_RootLOD );
}
else
{
printf( "\n" );
printf( "Performance Stats: %s\n", fileName );
printf( "------------------\n" );
}
}
int i;
if( flags & SPEWPERFSTATS_SHOWPERF )
{
for( i = studioHWData.m_RootLOD; i < studioHWData.m_NumLODs; i++ )
{
DrawModelInfo_t drawModelInfo;
drawModelInfo.m_Skin = 0;
drawModelInfo.m_Body = 0;
drawModelInfo.m_HitboxSet = 0;
drawModelInfo.m_pClientEntity = 0;
drawModelInfo.m_pColorMeshes = 0;
drawModelInfo.m_pStudioHdr = pStudioHdr;
drawModelInfo.m_pHardwareData = &studioHWData;
CUtlBuffer statsOutput( 0, 0, CUtlBuffer::TEXT_BUFFER );
if( !( flags & SPEWPERFSTATS_SPREADSHEET ) )
{
printf( "LOD:%d\n", i );
}
drawModelInfo.m_Lod = i;
DrawModelResults_t results;
g_pStudioRender->GetPerfStats( &results, drawModelInfo, &statsOutput );
if( flags & SPEWPERFSTATS_SPREADSHEET )
{
printf( "%d,%d,%d,", results.m_ActualTriCount, results.m_NumBatches, results.m_NumMaterials );
}
else
{
printf( " actual tris:%d\n", ( int )results.m_ActualTriCount );
printf( " texture memory bytes: %d (only valid in a rendering app)\n", ( int )results.m_TextureMemoryBytes );
printf( ( char * )statsOutput.Base() );
}
}
if( flags & SPEWPERFSTATS_SPREADSHEET )
{
printf( "\n" );
}
}
g_pStudioRender->UnloadModel( &studioHWData );
free(pVtxHdr);
}
if (pVvdHdr)
free(pVvdHdr);
if( !( flags & SPEWPERFSTATS_SHOWSTUDIORENDERWARNINGS ) )
{
SpewOutputFunc( s_pSavedSpewFunc );
}
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
g_hInstance = hInstance;
LogString( "vmpi_service_ui startup.\n" );
// Don't run multiple instances.
HANDLE hMutex = CreateMutex( NULL, FALSE, "vmpi_service_ui_mutex" );
if ( hMutex && GetLastError() == ERROR_ALREADY_EXISTS )
return 1;
// Hook spew output.
SpewOutputFunc( MySpewOutputFunc );
InitConsoleWindow();
LogString( "Setup console window.\n" );
LoadStateFromRegistry();
// Setup the popup menu.
if( !LoadPopupMenu() )
{
return false;
}
UpdatePopupMenuState();
// Setup the tray icon.
Msg( "Waiting for jobs...\n" );
if ( !g_ShellIconMgr.Init( &g_ShellIconMgrHelper, g_pIconTooltip, MYWM_NOTIFYICON, IDI_WAITING_ICON ) )
{
return false;
}
// Connect to the VMPI service.
g_ConnMgr.InitClient();
LogString( "Entering main loop.\n" );
while ( 1 )
{
MSG msg;
msg.message = !WM_QUIT; // So it doesn't accidentally exit.
while ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
if ( msg.message == WM_QUIT )
break;
TranslateMessage( &msg );
DispatchMessage( &msg );
}
if ( msg.message == WM_QUIT )
break;
g_ConnMgr.Update();
if ( !g_ConnMgr.IsConnected() )
{
g_ShellIconMgr.ChangeIcon( IDI_UNCONNECTED );
}
Sleep( 30 );
}
// Important that we call this instead of letting the destructor do it because it deletes its
// socket and it needs to cleanup some threads.
g_ConnMgr.Term();
g_ShellIconMgr.Term();
return 0;
}
//-----------------------------------------------------------------------------
// Create all singleton systems
//-----------------------------------------------------------------------------
bool CSceneViewerApp::Create()
{
if ( CommandLine()->FindParm( "-help" ) )
{
const bool newConsole( SetupWin32ConsoleIO() );
Msg( "\n\n Sceneviewer - Loads and views Valve DMX Assets\n\n" );
Msg( " Synopsis: sceneviewer [ vgui opts ] [ -help ] [ filename.[dmx|obj] ]\n" );
Msg(
"\n"
" Where:\n"
"\n"
" Sceneviewer Options:\n"
"\n"
" -help . . . . . . Prints this information\n"
" -nozoom . . . . . Stop sceneviewer zooming model viewer to occupy all client\n"
" space when a dmx is specified on the command line\n"
" -showasset . . . Stop sceneviewer from hiding the asset builder when a dmx\n"
" file is specified on the command line.\n"
" filename.dmx . . The name of a dmx file to load on start\n"
"\n"
" VGUI Options:\n"
"\n"
" -vproject <$> . . Override VPROJECT environment variable\n"
" -game <$> . . . . Override VPROJECT environment variable\n"
" -remote <$> . . . Add the remote share name\n"
" -host <$> . . . . Set the host name\n"
" -norfs . . . . . Do not use remote filesystem\n"
" -fullscreen . . . Run application fullscreen rather than in a window\n"
" -width <#> . . . Set the window width when running windowed\n"
" -height <#> . . . Set the window height when running windowed\n"
" -adapter <$> . . Set the adapter??\n"
" -ref . . . . . . Set MATERIAL_INIT_REFERENCE_RASTERIZER on adapter??\n"
" -resizing . . . . Allow the window to be resized\n"
" -mat_vsync . . . Wait for VSYNC\n"
" -mat_antialias . Turn on Anti-Aliasing\n"
" -mat_aaquality . Antialiasing quality (set to zero unless you know what you're doing)\n"
"\n"
);
if ( newConsole )
{
Msg( "\n\nPress Any Key Continue..." );
char tmpBuf[ 2 ];
DWORD cRead;
ReadConsole( GetStdHandle( STD_INPUT_HANDLE ), tmpBuf, 1, &cRead, NULL );
}
return false;
}
// FIXME: Enable vs30 shaders while NVidia driver bug exists
CommandLine()->AppendParm( "-box", NULL );
SpewOutputFunc( ModelBrowserSpewFunc );
SpewActivate( "console", 1 );
if ( !BaseClass::Create() )
return false;
AppSystemInfo_t appSystems[] =
{
{ "vstdlib.dll", PROCESS_UTILS_INTERFACE_VERSION },
{ "studiorender.dll", STUDIO_RENDER_INTERFACE_VERSION },
{ "vphysics.dll", VPHYSICS_INTERFACE_VERSION },
{ "datacache.dll", DATACACHE_INTERFACE_VERSION },
{ "datacache.dll", MDLCACHE_INTERFACE_VERSION },
{ "p4lib.dll", P4_INTERFACE_VERSION },
{ "", "" } // Required to terminate the list
};
AddSystem( g_pDataModel, VDATAMODEL_INTERFACE_VERSION );
AddSystem( g_pDmElementFramework, VDMELEMENTFRAMEWORK_VERSION );
AddSystem( g_pDmSerializers, DMSERIALIZERS_INTERFACE_VERSION );
AddSystem( GetDefaultDmeMakefileUtils(), DMEMAKEFILE_UTILS_INTERFACE_VERSION );
return AddSystems( appSystems );
}
