//---------------------------------------------------------------------------------
// Purpose: called when the plugin is loaded, load the interface we need from the engine
//---------------------------------------------------------------------------------
bool CEmptyServerPlugin::Load( CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerFactory )
{
playerinfomanager = (IPlayerInfoManager *)gameServerFactory(INTERFACEVERSION_PLAYERINFOMANAGER,NULL);
if ( !playerinfomanager )
{
Warning( "Unable to load playerinfomanager, ignoring\n" ); // this isn't fatal, we just won't be able to access specific player data
}
botmanager = (IBotManager *)gameServerFactory(INTERFACEVERSION_PLAYERBOTMANAGER, NULL);
if ( !botmanager )
{
Warning( "Unable to load botcontroller, ignoring\n" ); // this isn't fatal, we just won't be able to access specific bot functions
}
// get the interfaces we want to use
if( !(engine = (IVEngineServer*)interfaceFactory(INTERFACEVERSION_VENGINESERVER, NULL)) ||
!(gameeventmanager = (IGameEventManager *)interfaceFactory(INTERFACEVERSION_GAMEEVENTSMANAGER,NULL)) ||
!(filesystem = (IFileSystem*)interfaceFactory(FILESYSTEM_INTERFACE_VERSION, NULL)) ||
!(helpers = (IServerPluginHelpers*)interfaceFactory(INTERFACEVERSION_ISERVERPLUGINHELPERS, NULL)) ||
!(enginetrace = (IEngineTrace *)interfaceFactory(INTERFACEVERSION_ENGINETRACE_SERVER,NULL)) ||
!(randomStr = (IUniformRandomStream *)interfaceFactory(VENGINE_SERVER_RANDOM_INTERFACE_VERSION, NULL))
)
{
return false; // we require all these interface to function
}
if ( playerinfomanager )
{
gpGlobals = playerinfomanager->GetGlobalVars();
}
InitCVars( interfaceFactory ); // register any cvars we have defined
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
return true;
}
void InitCommandLineProgram( int argc, char **argv )
{
MathLib_Init( 1,1,1,0,false,true,true,true);
CommandLine()->CreateCmdLine( argc, argv );
InitDefaultFileSystem();
InstallProgressReportHandler( PrintFReportHandler );
}
//-----------------------------------------------------------------------------
// Init, shutdown
//-----------------------------------------------------------------------------
bool CHLModelViewerApp::PreInit( )
{
CreateInterfaceFn factory = GetFactory();
ConnectTier1Libraries( &factory, 1 );
ConVar_Register( 0 );
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
// Add paths...
if ( !SetupSearchPaths( NULL, false, true ) )
return false;
// Get the adapter from the command line....
const char *pAdapterString;
int nAdapter = 0;
if (CommandLine()->CheckParm( "-adapter", &pAdapterString ))
{
nAdapter = atoi( pAdapterString );
}
int nAdapterFlags = 0;
if ( CommandLine()->CheckParm( "-ref" ) )
{
nAdapterFlags |= MATERIAL_INIT_REFERENCE_RASTERIZER;
}
g_pMaterialSystem->SetAdapter( nAdapter, nAdapterFlags );
if ( !g_pFileSystem->IsSteam() || CommandLine()->FindParm( "-OldDialogs" ) )
g_bOldFileDialogs = true;
LoadFileSystemDialogModule();
return true;
}
virtual InitReturnVal_t Init()
{
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
InitReturnVal_t nRetVal = BaseClass::Init();
if ( nRetVal != INIT_OK )
return nRetVal;
return INIT_OK;
}
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;
}
EXPORT MStatus initializePlugin( MObject mObject )
{
MStatus retVal;
MStatus regStat;
MFnPlugin pluginFn( mObject, "Valve", "1.0", "Any" );
// For CVstAimNode
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
return CVsMayaMPxFactoryBase::RegisterEverything( pluginFn );
}
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
if ( fdwReason == DLL_PROCESS_ATTACH )
{
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
// store out module handle
gPhysicsDLLHandle = (HMODULE)hinstDLL;
}
else if ( fdwReason == DLL_PROCESS_DETACH )
{
}
return TRUE;
}
//-----------------------------------------------------------------------------
// Create the application object
//-----------------------------------------------------------------------------
bool CIHVTestApp::Create()
{
AppSystemInfo_t appSystems[] =
{
{ "materialsystem.dll", MATERIAL_SYSTEM_INTERFACE_VERSION },
{ "datacache.dll", DATACACHE_INTERFACE_VERSION },
{ "studiorender.dll", STUDIO_RENDER_INTERFACE_VERSION },
{ "datacache.dll", MDLCACHE_INTERFACE_VERSION },
{ "vphysics.dll", VPHYSICS_INTERFACE_VERSION },
{ "", "" } // Required to terminate the list
};
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
if ( !AddSystems( appSystems ) )
return false;
g_pFileSystem = ( IFileSystem * )FindSystem( FILESYSTEM_INTERFACE_VERSION );
g_pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION );
g_pStudioRender = (IStudioRender*)FindSystem( STUDIO_RENDER_INTERFACE_VERSION );
g_pMDLCache = (IMDLCache*)FindSystem( MDLCACHE_INTERFACE_VERSION );
if ( !g_pFileSystem || !g_pMaterialSystem || !g_pStudioRender || !g_pMDLCache )
{
DisplayError( "Unable to load required library interfaces!" );
return false;
}
#if defined( _X360 )
// vxconsole - true will block (legacy behavior)
XBX_InitConsoleMonitor( false );
#endif
const char* pDLLName;
if ( CommandLine()->CheckParm( "-null" ) )
{
g_bUseEmptyShader = true;
pDLLName = "shaderapiempty.dll";
}
else
{
pDLLName = "shaderapidx9.dll";
}
#if defined( _X360 )
g_pFileSystem->LoadModule( pDLLName );
#endif
g_pMaterialSystem->SetShaderAPI( pDLLName );
return true;
}
//---------------------------------------------------------------------------------
// Purpose: called when the plugin is loaded, load the interface we need from the engine
//---------------------------------------------------------------------------------
bool CEmptyServerPlugin::Load( CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerFactory )
{
ConnectTier1Libraries( &interfaceFactory, 1 );
ConnectTier2Libraries( &interfaceFactory, 1 );
entityinfomanager = (IEntityInfoManager *)gameServerFactory(INTERFACEVERSION_ENTITYINFOMANAGER,NULL);
if ( !entityinfomanager )
{
Warning( "Unable to load entityinfomanager, ignoring\n" ); // this isn't fatal, we just won't be able to access entity data
}
playerinfomanager = (IPlayerInfoManager *)gameServerFactory(INTERFACEVERSION_PLAYERINFOMANAGER,NULL);
if ( !playerinfomanager )
{
Warning( "Unable to load playerinfomanager, ignoring\n" ); // this isn't fatal, we just won't be able to access specific player data
}
botmanager = (IBotManager *)gameServerFactory(INTERFACEVERSION_PLAYERBOTMANAGER, NULL);
if ( !botmanager )
{
Warning( "Unable to load botcontroller, ignoring\n" ); // this isn't fatal, we just won't be able to access specific bot functions
}
gameinfomanager = (IGameInfoManager *)gameServerFactory(INTERFACEVERSION_GAMEINFOMANAGER, NULL);
if (!gameinfomanager)
{
Warning( "Unable to load gameinfomanager, ignoring\n" );
}
engine = (IVEngineServer*)interfaceFactory(INTERFACEVERSION_VENGINESERVER, NULL);
gameeventmanager = (IGameEventManager *)interfaceFactory(INTERFACEVERSION_GAMEEVENTSMANAGER,NULL);
helpers = (IServerPluginHelpers*)interfaceFactory(INTERFACEVERSION_ISERVERPLUGINHELPERS, NULL);
enginetrace = (IEngineTrace *)interfaceFactory(INTERFACEVERSION_ENGINETRACE_SERVER,NULL);
randomStr = (IUniformRandomStream *)interfaceFactory(VENGINE_SERVER_RANDOM_INTERFACE_VERSION, NULL);
// get the interfaces we want to use
if( ! ( engine && gameeventmanager && g_pFullFileSystem && helpers && enginetrace && randomStr ) )
{
return false; // we require all these interface to function
}
if ( playerinfomanager )
{
gpGlobals = playerinfomanager->GetGlobalVars();
}
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
ConVar_Register( 0 );
return true;
}
//-----------------------------------------------------------------------------
// Init, shutdown
//-----------------------------------------------------------------------------
bool CSceneViewerApp::PreInit( )
{
if ( !BaseClass::PreInit() )
return false;
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
if ( !g_pFullFileSystem || !g_pMaterialSystem || !g_pDataModel || !g_pDmElementFramework || !g_pStudioRender || !g_pDataCache || !g_pMDLCache || !g_pVGuiSurface || !g_pVGui )
{
Warning( "CSceneViewerApp::PreInit: Unable to connect to necessary interface!\n" );
return false;
}
// initialize interfaces
CreateInterfaceFn appFactory = GetFactory();
return vgui::VGui_InitDmeInterfacesList( "SceneViewer", &appFactory, 1 );
}
void main( int argc, char **argv )
{
CommandLine()->CreateCmdLine( argc, argv );
if( CommandLine()->ParmCount()!=2 )
{
printf( "usage : sptconvert <SPT file name>\n" );
exit(0);
}
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
CmdLib_InitFileSystem( CommandLine()->GetParm(1) );
CSpeedTreeRT speedTree;
char treeName[MAX_PATH];
_splitpath( argv[1], NULL, NULL, treeName, NULL );
char smdFileName[MAX_PATH];
sprintf( smdFileName, "%s.smd", treeName );
char qcFileName[MAX_PATH];
sprintf( qcFileName, "%s.qc", treeName );
OutputQCFile( treeName );
if( speedTree.LoadTree( argv[1] ) )
{
if( speedTree.Compute( NULL, 1, false ) )
{
CSpeedTreeRT::SGeometry sGeom;
speedTree.GetGeometry( sGeom, SpeedTree_AllGeometry );
OutputTreeGeometry( speedTree, sGeom, smdFileName );
}
else
{
// Trouble with compute
}
}
else
{
// Trouble with load
}
}
/*
===========
main
===========
*/
int main (int argc, char **argv)
{
CommandLine()->CreateCmdLine( argc, argv );
MathLib_Init( 2.2f, 2.2f, 0.0f, 1.0f, false, false, false, false );
InstallAllocationFunctions();
InstallSpewFunction();
VVIS_SetupMPI( argc, argv );
// Install an exception handler.
if ( g_bUseMPI && !g_bMPIMaster )
SetupToolsMinidumpHandler( VMPI_ExceptionFilter );
else
SetupDefaultToolsMinidumpHandler();
return RunVVis( argc, argv );
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CSFMGenApp::PreInit( )
{
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
if ( !BaseClass::PreInit() )
return false;
if ( !g_pFullFileSystem || !g_pDataModel )
{
Error( "// ERROR: sfmgen is missing a required interface!\n" );
return false;
}
// Add paths...
if ( !SetupSearchPaths( NULL, false, true ) )
return false;
return true;
}
EXPORT MStatus initializePlugin( MObject mObject )
{
MFnPlugin pluginFn( mObject, "Valve", "1.0", "Any" );
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
MStatus retVal( CVsMayaMPxFactoryBase::RegisterEverything( pluginFn ) );
if ( retVal )
{
MGlobal::executeCommand( "source vsSkinner.mel" );
if ( MFnPlugin::findPlugin( "decomposeMatrix" ) == MObject::kNullObj )
{
MGlobal::executeCommand( "catchQuiet( loadPlugin( \"-qt\", \"decomposeMatrix\" ) );" );
}
}
return retVal;
}
//-----------------------------------------------------------------------------
// Purpose: called when the plugin is loaded, load the interface we need from the engine
//-----------------------------------------------------------------------------
bool CSourcePython::Load( CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerFactory )
{
// This seems to be new with
#ifdef ENGINE_CSGO
ConnectInterfaces(&interfaceFactory, 1);
#else
ConnectTier1Libraries( &interfaceFactory, 1 );
ConnectTier2Libraries( &interfaceFactory, 2 );
#endif
// Get all engine interfaces.
if( !GetInterfaces(gEngineInterfaces, interfaceFactory) ) {
return false;
}
// Get all game interfaces.
if( !GetInterfaces(gGameInterfaces, gameServerFactory) ) {
return false;
}
gpGlobals = playerinfomanager->GetGlobalVars();
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
InitCommands();
// Initialize game paths.
if( !g_GamePaths.Initialize() ) {
DevMsg(0, "Could not initialize game paths.");
return false;
}
// Initialize python
if( !g_PythonManager.Initialize() ) {
DevMsg(0, "Could not initialize python.");
return false;
}
return true;
}
bool CSSServerPlugin::Load( CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerFactory )
{
Msg("Loading..\n");
ConnectTier1Libraries( &interfaceFactory, 1 );
engine = (IVEngineServer*)interfaceFactory(INTERFACEVERSION_VENGINESERVER, NULL);
helpers = (IServerPluginHelpers*)interfaceFactory(INTERFACEVERSION_ISERVERPLUGINHELPERS, NULL);
playerinfomanager = (IPlayerInfoManager *)gameServerFactory(INTERFACEVERSION_PLAYERINFOMANAGER,NULL);
if( ! ( engine && helpers && playerinfomanager ) )
return false;
gpGlobals = playerinfomanager->GetGlobalVars();
MathLib_Init( 2.2f, 2.2f, 0.0f, 2 );
ConVar_Register( 0 );
NetFilter_Load();
FileFilter_Load();
return true;
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
bool CDmxEditApp::PreInit( )
{
CreateInterfaceFn factory = GetFactory();
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
ConnectTier1Libraries( &factory, 1 );
ConnectTier2Libraries( &factory, 1 );
ConnectTier3Libraries( &factory, 1 );
if ( !ConnectDataModel( factory ) )
return false;
if ( InitDataModel( ) != INIT_OK )
return false;
if ( !g_pFullFileSystem || !g_pDataModel )
{
Error( "// ERROR: dmxedit is missing a required interface!\n" );
return false;
}
return true;
}
//-----------------------------------------------------------------------------
//
// Purpose: Valve entry point called after the Valve DLLs are loaded
// Input : CreateInterfaceFn factory
// Output : true is everything is good, false otherwise
//
//-----------------------------------------------------------------------------
DLL_EXPORT bool VsMayaConnect( CreateInterfaceFn factory )
{
ConnectTier1Libraries( &factory, 1 );
ConnectTier2Libraries( &factory, 1 );
ConnectTier3Libraries( &factory, 1 );
if ( !ConnectDataModel( factory ) )
return false;
if ( InitDataModel( ) != INIT_OK )
return false;
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
if ( !g_pFullFileSystem || !g_pDataModel )
{
Warning( "vsDmxIO is missing a required interface!\n" );
return false;
}
// Can't unload this plugin until the libraries have been disconnected
g_okToUnload = false;
return true;
}
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;
}
//-----------------------------------------------------------------------------
// Purpose: called when the plugin is loaded, load the interface we need from the engine
//-----------------------------------------------------------------------------
bool CSourcePython::Load( CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerFactory )
{
// This seems to be new with
#ifdef ENGINE_CSGO
DevMsg(1, MSG_PREFIX "Connecting interfaces...\n");
ConnectInterfaces(&interfaceFactory, 1);
#else
DevMsg(1, MSG_PREFIX "Connecting tier1 libraries...\n");
ConnectTier1Libraries( &interfaceFactory, 1 );
DevMsg(1, MSG_PREFIX "Connecting tier2 libraries...\n");
ConnectTier2Libraries( &interfaceFactory, 2 );
#endif
// Get all engine interfaces.
DevMsg(1, MSG_PREFIX "Retrieving engine interfaces...\n");
if( !GetInterfaces(gEngineInterfaces, interfaceFactory) ) {
return false;
}
// Get all game interfaces.
DevMsg(1, MSG_PREFIX "Retrieving game interfaces...\n");
if( !GetInterfaces(gGameInterfaces, gameServerFactory) ) {
return false;
}
DevMsg(1, MSG_PREFIX "Retrieving global variables...\n");
gpGlobals = playerinfomanager->GetGlobalVars();
if (!gpGlobals) {
Msg(MSG_PREFIX "Could retrieve global variables.\n");
return false;
}
DevMsg(1, MSG_PREFIX "Initializing mathlib...\n");
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
DevMsg(1, MSG_PREFIX "Initializing server and say commands...\n");
InitCommands();
// Initialize python
DevMsg(1, MSG_PREFIX "Initializing python...\n");
if( !g_PythonManager.Initialize() ) {
Msg(MSG_PREFIX "Could not initialize python.\n");
return false;
}
// TODO: Don't hardcode the 64 bytes offset
#ifdef ENGINE_LEFT4DEAD2
#define CACHE_NOTIFY_OFFSET 68
#else
#define CACHE_NOTIFY_OFFSET 64
#endif
DevMsg(1, MSG_PREFIX "Retrieving the current cache notifier...\n");
m_pOldMDLCacheNotifier = *(IMDLCacheNotify **)(((unsigned long) modelcache) + CACHE_NOTIFY_OFFSET);
DevMsg(1, MSG_PREFIX "Setting the new cache notifier...\n");
modelcache->SetCacheNotify(this);
Msg(MSG_PREFIX "Loaded successfully.\n");
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Called when the DLL is first loaded.
// Input : engineFactory -
// Output : int
//-----------------------------------------------------------------------------
int CHLClient::Init( CreateInterfaceFn appSystemFactory, CreateInterfaceFn physicsFactory, CGlobalVarsBase *pGlobals )
{
InitCRTMemDebug();
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
// Hook up global variables
gpGlobals = pGlobals;
// We aren't happy unless we get all of our interfaces.
if(
!(engine = (IVEngineClient *)appSystemFactory( VENGINE_CLIENT_INTERFACE_VERSION, NULL )) ||
!(modelrender = (IVModelRender *)appSystemFactory( VENGINE_HUDMODEL_INTERFACE_VERSION, NULL )) ||
!(effects = (IVEfx *)appSystemFactory( VENGINE_EFFECTS_INTERFACE_VERSION, NULL )) ||
!(cvar = (ICvar *)appSystemFactory( VENGINE_CVAR_INTERFACE_VERSION, NULL )) ||
!(enginetrace = (IEngineTrace *)appSystemFactory( INTERFACEVERSION_ENGINETRACE_CLIENT, NULL )) ||
!(render = (IVRenderView *)appSystemFactory( VENGINE_RENDERVIEW_INTERFACE_VERSION, NULL )) ||
!(debugoverlay = (IVDebugOverlay *)appSystemFactory( VDEBUG_OVERLAY_INTERFACE_VERSION, NULL )) ||
!(materials = (IMaterialSystem *)appSystemFactory( MATERIAL_SYSTEM_INTERFACE_VERSION, NULL )) ||
!(engineCache = (IVEngineCache*)appSystemFactory(VENGINE_CACHE_INTERFACE_VERSION, NULL )) ||
!(modelinfo = (IVModelInfo *)appSystemFactory(VMODELINFO_CLIENT_INTERFACE_VERSION, NULL )) ||
!(netgraph = (INetGraph *)appSystemFactory(VNETGRAPH_INTERFACE_VERSION, NULL )) ||
!(enginevgui = (IEngineVGui *)appSystemFactory(VENGINE_VGUI_VERSION, NULL )) ||
!(networkstringtable = (INetworkStringTableClient *)appSystemFactory(INTERFACENAME_NETWORKSTRINGTABLECLIENT,NULL)) ||
!(partition = (ISpatialPartition *)appSystemFactory(INTERFACEVERSION_SPATIALPARTITION, NULL)) ||
!(shadowmgr = (IShadowMgr *)appSystemFactory(ENGINE_SHADOWMGR_INTERFACE_VERSION, NULL)) ||
!(staticpropmgr = (IStaticPropMgrClient *)appSystemFactory(INTERFACEVERSION_STATICPROPMGR_CLIENT, NULL)) ||
!(enginesound = (IEngineSound *)appSystemFactory(IENGINESOUND_CLIENT_INTERFACE_VERSION, NULL)) ||
!(filesystem = (IFileSystem *)appSystemFactory(FILESYSTEM_INTERFACE_VERSION, NULL)) ||
!(random = (IUniformRandomStream *)appSystemFactory(VENGINE_CLIENT_RANDOM_INTERFACE_VERSION, NULL)) ||
!(gameuifuncs = (IGameUIFuncs * )appSystemFactory( VENGINE_GAMEUIFUNCS_VERSION, NULL )) ||
!(gameeventmanager = (IGameEventManager *)appSystemFactory(INTERFACEVERSION_GAMEEVENTSMANAGER,NULL))
)
{
return false;
}
g_pMaterialSystemHardwareConfig = materials->GetHardwareConfig( MATERIALSYSTEM_HARDWARECONFIG_INTERFACE_VERSION, NULL );
if( !g_pMaterialSystemHardwareConfig )
{
return false;
}
SetScreenSize();
// Hook up the gaussian random number generator
s_GaussianRandomStream.AttachToStream( random );
// Initialize the console variables.
ConCommandBaseMgr::OneTimeInit(&g_ConVarAccessor);
if(!Initializer::InitializeAllObjects())
return false;
if(!g_ParticleMgr.Init(8192, materials))
return false;
// load used game events
gameeventmanager->LoadEventsFromFile("resource/gameevents.res");
if(!VGui_Startup( appSystemFactory ))
return false;
g_pMatSystemSurface = (IMatSystemSurface*)vgui::surface()->QueryInterface( MAT_SYSTEM_SURFACE_INTERFACE_VERSION );
if (!g_pMatSystemSurface)
return false;
// Add the client systems.
// Client Leaf System has to be initialized first, since DetailObjectSystem uses it
IGameSystem::Add( GameStringSystem() );
IGameSystem::Add( ClientLeafSystem() );
IGameSystem::Add( DetailObjectSystem() );
IGameSystem::Add( ViewportClientSystem() );
IGameSystem::Add( ClientEffectPrecacheSystem() );
IGameSystem::Add( g_pClientShadowMgr );
IGameSystem::Add( ClientThinkList() );
IGameSystem::Add( ClientSoundscapeSystem() );
#if defined( CLIENT_DLL ) && defined( COPY_CHECK_STRESSTEST )
IGameSystem::Add( GetPredictionCopyTester() );
#endif
modemanager->Init( );
gHUD.Init();
g_pClientMode->Init();
if( !IGameSystem::InitAllSystems() )
return false;
g_pClientMode->Enable();
view->Init();
vieweffects->Init();
C_BaseTempEntity::PrecacheTempEnts();
input->Init_All();
VGui_CreateGlobalPanels();
InitSmokeFogOverlay();
C_TerrainMod_Init();
// Register user messages..
CUserMessageRegister::RegisterAll();
ClientVoiceMgr_Init();
// Embed voice status icons inside chat element
{
CHudChat *chatElement = GET_HUDELEMENT( CHudChat );
vgui::VPANEL parent = enginevgui->GetPanel( PANEL_CLIENTDLL );
if ( chatElement )
{
parent = chatElement->GetVoiceArea()->GetVPanel();
}
GetClientVoiceMgr()->Init( &g_VoiceStatusHelper, parent );
}
if ( !PhysicsDLLInit( physicsFactory ) )
return false;
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetEntitiySaveRestoreBlockHandler() );
g_pGameSaveRestoreBlockSet->AddBlockHandler( GetPhysSaveRestoreBlockHandler() );
return true;
}
//---------------------------------------------------------------------------------
// Purpose: called when the plugin is loaded, load the interface we need from the engine
//---------------------------------------------------------------------------------
bool CEmptyServerPlugin::Load( CreateInterfaceFn interfaceFactory, CreateInterfaceFn gameServerFactory )
{
//bool bSucess = true;
ConnectTier1Libraries( &interfaceFactory, 1 );
ConnectTier2Libraries( &interfaceFactory, 1 );
//g_pFullFileSystem = GetInterface<IFileSystem>( "bin/filesystem_steam.dll", FILESYSTEM_INTERFACE_VERSION );
g_pFullFileSystem = (IFileSystem *)interfaceFactory(FILESYSTEM_INTERFACE_VERSION, NULL);
//#ifdef WIN32
// pServerDLL = GetInterface<IServerGameDLL>( "tf/bin/server.dll", INTERFACEVERSION_SERVERGAMEDLL );
//#else
// pServerDLL = GetInterface<IServerGameDLL>( "tf/bin/server.so", INTERFACEVERSION_SERVERGAMEDLL );
//#endif
//CSysModule *pClientModule = g_pFullFileSystem->LoadModule("bin/client.dll", "MOD", false);
//if(!pClientModule)
//{
// Warning("Unable to find client DLL module (are you on a dedicated server?)\n");
// return false;
//}
//CreateInterfaceFn pfnClientFactory = Sys_GetFactory(pClientModule);
//if(!interfaceFactory)
//{
// Warning("Unable to retrieve client factory\n");
// return false;
//}
playerinfomanager = (IPlayerInfoManager *)gameServerFactory(INTERFACEVERSION_PLAYERINFOMANAGER,NULL);
//if ( !playerinfomanager )
//{
// Warning( "Unable to load playerinfomanager, ignoring\n" ); // this isn't fatal, we just won't be able to access specific player data
//}
//botmanager = (IBotManager *)gameServerFactory(INTERFACEVERSION_PLAYERBOTMANAGER, NULL);
//if ( !botmanager )
//{
// Warning( "Unable to load botcontroller, ignoring\n" ); // this isn't fatal, we just won't be able to access specific bot functions
//}
pEngine = (IVEngineServer*)interfaceFactory(INTERFACEVERSION_VENGINESERVER, NULL);
gameeventmanager = (IGameEventManager2*)interfaceFactory(INTERFACEVERSION_GAMEEVENTSMANAGER2, NULL);
helpers = (IServerPluginHelpers*)interfaceFactory(INTERFACEVERSION_ISERVERPLUGINHELPERS, NULL);
enginetrace = (IEngineTrace *)interfaceFactory(INTERFACEVERSION_ENGINETRACE_SERVER,NULL);
randomStr = (IUniformRandomStream *)interfaceFactory(VENGINE_SERVER_RANDOM_INTERFACE_VERSION, NULL);
pServerEnts = (IServerGameEnts *)gameServerFactory(INTERFACEVERSION_SERVERGAMEENTS, NULL);
pServerDLL = (IServerGameDLL *)gameServerFactory(INTERFACEVERSION_SERVERGAMEDLL, NULL);
#ifndef SERVER_BUILD
pEngineClient = (IVEngineClient *)interfaceFactory(VENGINE_CLIENT_INTERFACE_VERSION, NULL);
//pEngineClient = UTIL_LoadInterface<IVEngineClient>(interfaceFactory, VENGINE_CLIENT_INTERFACE_VERSION, bSucess);
//pBaseClientDLL = UTIL_LoadInterface<IBaseClientDLL>(pfnClientFactory, CLIENT_DLL_INTERFACE_VERSION, bSucess);
pBaseClientDLL = GetInterface<IBaseClientDLL>( "tf/bin/client.dll", CLIENT_DLL_INTERFACE_VERSION );
#endif
// get the interfaces we want to use
//if( ! ( pEngine && gameeventmanager && g_pFullFileSystem && helpers && enginetrace && randomStr ) )
//{
// Warning( "Unable to load one of these: engine && gameeventmanager && g_pFullFileSystem && helpers && enginetrace && randomStr\n" );
// return false; // we require all these interface to function
//}
if ( !ConfirmInterfaces() ){
return false;
}
//if ( playerinfomanager ){
gpGlobals = playerinfomanager->GetGlobalVars();
//}
//GetMessageInts();
plugin_context_init_t init;
init.pEngine = pEngine;
init.pPlayerInfoManager = playerinfomanager;
init.pHelpers = helpers;
init.pGameEventManager = gameeventmanager;
init.pServerGameDLL = pServerDLL;
m_plugin_context.Initialize(init);
gameeventmanager->AddListener( this, "teamplay_round_stalemate", true );
gameeventmanager->AddListener( this, "teamplay_round_active", true ); //9:54
gameeventmanager->AddListener( this, "teamplay_round_win", true ); //end round
gameeventmanager->AddListener( this, "teamplay_point_captured", true );
gameeventmanager->AddListener( this, "arena_win_panel", true );
gameeventmanager->AddListener( this, "teamplay_win_panel", true ); //fix for incorrect round points
gameeventmanager->AddListener( this, "player_say", true );
gameeventmanager->AddListener( this, "teamplay_game_over", true );
gameeventmanager->AddListener( this, "player_changename", true );
gameeventmanager->AddListener( this, "player_team", true );
gameeventmanager->AddListener( this, "tf_game_over", true );
//gameeventmanager->AddListener( this, "teamplay_broadcast_audio", true );
m_SizzlingMatches.Load(m_plugin_context);
m_SizzlingMatches.SM_GetPropOffsets();
m_SizzlingMatches.SM_SetEventUpdateInterval( 3.0f );
m_SizzlingMatches.SM_LoadCurrentPlayers();
//pEngine->ServerCommand( "con_logfile sizzmatches.txt\n" );
//Name: player_changename
//Structure:
//short userid user ID on server
//string oldname players old (current) name
//string newname players new name
//Name: player_chat // doesn't work
//Structure:
//bool teamonly true if team only chat
//short userid chatting player
//string text chat text
//Name: player_say
//Structure:
//short userid chatting player
//string text chat text
MathLib_Init( 2.2f, 2.2f, 0.0f, 2 );
ConVar_Register( 0 );
return true;
}
int main( int argc, char **argv )
{
if( argc != 4 )
{
Usage();
}
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
InitDefaultFileSystem();
char pCurrentDirectory[MAX_PATH];
if ( _getcwd( pCurrentDirectory, sizeof(pCurrentDirectory) ) == NULL )
{
fprintf( stderr, "Unable to get the current directory\n" );
return -1;
}
Q_FixSlashes( pCurrentDirectory );
Q_StripTrailingSlash( pCurrentDirectory );
char pBuf[3][MAX_PATH];
const char *pFileName[3];
for ( int i = 0; i < 3; ++i )
{
if ( !Q_IsAbsolutePath( argv[i+1] ) )
{
Q_snprintf( pBuf[i], sizeof(pBuf[i]), "%s\\%s", pCurrentDirectory, argv[i+1] );
pFileName[i] = pBuf[i];
}
else
{
pFileName[i] = argv[i+1];
}
}
int width1, height1;
ImageFormat imageFormat1;
float gamma1;
CUtlBuffer buf1;
if ( !g_pFullFileSystem->ReadFile( pFileName[0], NULL, buf1 ) )
{
fprintf( stderr, "%s not found\n", pFileName[0] );
return -1;
}
if( !TGALoader::GetInfo( buf1, &width1, &height1, &imageFormat1, &gamma1 ) )
{
printf( "error loading %s\n", pFileName[0] );
exit( -1 );
}
int width2, height2;
ImageFormat imageFormat2;
float gamma2;
CUtlBuffer buf2;
if ( !g_pFullFileSystem->ReadFile( pFileName[1], NULL, buf2 ) )
{
fprintf( stderr, "%s not found\n", pFileName[1] );
return -1;
}
if( !TGALoader::GetInfo( buf2, &width2, &height2, &imageFormat2, &gamma2 ) )
{
printf( "error loading %s\n", pFileName[1] );
exit( -1 );
}
if( width1 != width2 || height1 != height2 )
{
printf( "image dimensions different (%dx%d!=%dx%d): can't do diff for %s\n",
width1, height1, width2, height2, pFileName[2] );
exit( -1 );
}
#if 0
// have to allow for different formats for now due to *.txt file screwup.
if( imageFormat1 != imageFormat2 )
{
printf( "image format different (%s!=%s). . can't do diff for %s\n",
ImageLoader::GetName( imageFormat1 ), ImageLoader::GetName( imageFormat2 ), pFileName[2] );
exit( -1 );
}
#endif
if( gamma1 != gamma2 )
{
printf( "image gamma different (%f!=%f). . can't do diff for %s\n", gamma1, gamma2, pFileName[2] );
exit( -1 );
}
unsigned char *pImage1Tmp = new unsigned char[ImageLoader::GetMemRequired( width1, height1, 1, imageFormat1, false )];
unsigned char *pImage2Tmp = new unsigned char[ImageLoader::GetMemRequired( width2, height2, 1, imageFormat2, false )];
buf1.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
if( !TGALoader::Load( pImage1Tmp, buf1, width1, height1, imageFormat1, 2.2f, false ) )
{
printf( "error loading %s\n", pFileName[0] );
exit( -1 );
}
buf2.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );
if( !TGALoader::Load( pImage2Tmp, buf2, width2, height2, imageFormat2, 2.2f, false ) )
{
printf( "error loading %s\n", pFileName[1] );
exit( -1 );
}
unsigned char *pImage1 = new unsigned char[ImageLoader::GetMemRequired( width1, height1, 1, IMAGE_FORMAT_ABGR8888, false )];
unsigned char *pImage2 = new unsigned char[ImageLoader::GetMemRequired( width2, height2, 1, IMAGE_FORMAT_ABGR8888, false )];
unsigned char *pDiff = new unsigned char[ImageLoader::GetMemRequired( width2, height2, 1, IMAGE_FORMAT_ABGR8888, false )];
ImageLoader::ConvertImageFormat( pImage1Tmp, imageFormat1, pImage1, IMAGE_FORMAT_ABGR8888, width1, height1, 0, 0 );
ImageLoader::ConvertImageFormat( pImage2Tmp, imageFormat2, pImage2, IMAGE_FORMAT_ABGR8888, width2, height2, 0, 0 );
int sizeInBytes = ImageLoader::SizeInBytes( IMAGE_FORMAT_ABGR8888 );
bool isDifferent = false;
for( int i = 0; i < width1 * height1 * sizeInBytes; i++ )
{
int d;
d = pImage2[i] - pImage1[i];
pDiff[i] = d > 0 ? d : -d;
if( d != 0 )
{
isDifferent = true;
}
}
if( !isDifferent )
{
printf( "Files are the same %s %s : not generating %s\n", pFileName[0], pFileName[1], pFileName[2] );
exit( -1 );
}
else
{
printf( "Generating diff: %s!\n", pFileName[2] );
}
ImageFormat dstImageFormat;
// get rid of this until we get the formats matching
// if( sizeInBytes == 3 )
// {
// dstImageFormat = IMAGE_FORMAT_RGB888;
// }
// else
{
dstImageFormat = IMAGE_FORMAT_RGBA8888;
}
CUtlBuffer outBuffer;
if ( !TGAWriter::WriteToBuffer( pDiff, outBuffer, width1, height1, dstImageFormat, dstImageFormat ) )
{
printf( "error writing %s to buffer\n", pFileName[2] );
exit( -1 );
}
if ( !g_pFullFileSystem->WriteFile( pFileName[2], NULL, outBuffer ) )
{
fprintf( stderr, "unable to write %s\n", pFileName[2] );
return -1;
}
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;
}
int main( int argc, char **argv )
{
if( argc < 2 )
{
Usage();
}
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
InitDefaultFileSystem();
int i = 1;
while( i < argc )
{
if( stricmp( argv[i], "-quiet" ) == 0 )
{
i++;
g_Quiet = true;
g_NoPause = true; // no point in pausing if we aren't going to print anything out.
}
if( stricmp( argv[i], "-nopause" ) == 0 )
{
i++;
g_NoPause = true;
}
else
{
break;
}
}
char pCurrentDirectory[MAX_PATH];
if ( _getcwd( pCurrentDirectory, sizeof(pCurrentDirectory) ) == NULL )
{
fprintf( stderr, "Unable to get the current directory\n" );
return -1;
}
Q_FixSlashes( pCurrentDirectory );
Q_StripTrailingSlash( pCurrentDirectory );
for( ; i < argc; i++ )
{
static char normalFileNameWithoutExtension[1024];
char *pFileName;
if ( !Q_IsAbsolutePath( argv[i] ) )
{
Q_snprintf( normalFileNameWithoutExtension, sizeof(normalFileNameWithoutExtension), "%s\\%s", pCurrentDirectory, argv[i] );
pFileName = normalFileNameWithoutExtension;
}
else
{
pFileName = argv[i];
}
if( !g_Quiet )
{
printf( "file: %s\n", pFileName );
}
float bumpScale = -1.0f;
int startFrame = -1;
int endFrame = -1;
LoadConfigFile( pFileName, &bumpScale, &startFrame, &endFrame );
if( bumpScale == -1.0f )
{
fprintf( stderr, "Must specify \"bumpscale\" in config file\n" );
Pause();
continue;
}
if( ( startFrame == -1 && endFrame != -1 ) ||
( startFrame != -1 && endFrame == -1 ) )
{
fprintf( stderr, "ERROR: If you use startframe, you must use endframe, and vice versa.\n" );
Pause();
continue;
}
if( !g_Quiet )
{
printf( "\tbumpscale: %f\n", bumpScale );
}
Q_StripExtension( pFileName, normalFileNameWithoutExtension, sizeof( normalFileNameWithoutExtension ) );
ProcessFiles( normalFileNameWithoutExtension,
startFrame, endFrame,
bumpScale );
}
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;
}
//-----------------------------------------------------------------------------
// Connect, disconnect...
//-----------------------------------------------------------------------------
CShaderDLL::CShaderDLL()
{
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
}
bool SDKTools::SDK_OnLoad(char *error, size_t maxlength, bool late)
{
HandleError err;
if (!gameconfs->LoadGameConfigFile("sdktools.games", &g_pGameConf, error, maxlength))
{
return false;
}
sharesys->AddDependency(myself, "bintools.ext", true, true);
sharesys->AddNatives(myself, g_CallNatives);
sharesys->AddNatives(myself, g_Natives);
sharesys->AddNatives(myself, g_TENatives);
sharesys->AddNatives(myself, g_SoundNatives);
sharesys->AddNatives(myself, g_TRNatives);
sharesys->AddNatives(myself, g_StringTableNatives);
sharesys->AddNatives(myself, g_VoiceNatives);
sharesys->AddNatives(myself, g_EntInputNatives);
sharesys->AddNatives(myself, g_TeamNatives);
sharesys->AddNatives(myself, g_EntOutputNatives);
sharesys->AddNatives(myself, g_GameRulesNatives);
sharesys->AddNatives(myself, g_ClientNatives);
SM_GET_IFACE(GAMEHELPERS, g_pGameHelpers);
playerhelpers->AddClientListener(&g_SdkTools);
g_CallHandle = handlesys->CreateType("ValveCall", this, 0, NULL, NULL, myself->GetIdentity(), &err);
if (g_CallHandle == 0)
{
snprintf(error, maxlength, "Could not create call handle type (err: %d)", err);
return false;
}
TypeAccess TraceAccess;
handlesys->InitAccessDefaults(&TraceAccess, NULL);
TraceAccess.ident = myself->GetIdentity();
TraceAccess.access[HTypeAccess_Create] = true;
TraceAccess.access[HTypeAccess_Inherit] = true;
g_TraceHandle = handlesys->CreateType("TraceRay", this, 0, &TraceAccess, NULL, myself->GetIdentity(), &err);
if (g_TraceHandle == 0)
{
handlesys->RemoveType(g_CallHandle, myself->GetIdentity());
g_CallHandle = 0;
snprintf(error, maxlength, "Could not create traceray handle type (err: %d)", err);
return false;
}
#if SOURCE_ENGINE >= SE_ORANGEBOX
g_pCVar = icvar;
#endif
CONVAR_REGISTER(this);
SH_ADD_HOOK(IServerGameDLL, LevelInit, gamedll, SH_MEMBER(this, &SDKTools::LevelInit), true);
playerhelpers->RegisterCommandTargetProcessor(this);
MathLib_Init(2.2f, 2.2f, 0.0f, 2);
spengine = g_pSM->GetScriptingEngine();
plsys->AddPluginsListener(&g_OutputManager);
CDetourManager::Init(g_pSM->GetScriptingEngine(), g_pGameConf);
g_OutputManager.Init();
VoiceInit();
GetIServer();
GameRulesNativesInit();
InitSDKToolsAPI();
return true;
}
int RunVBSP( int argc, char **argv )
{
int i;
double start, end;
char path[1024];
CommandLine()->CreateCmdLine( argc, argv );
MathLib_Init( 2.2f, 2.2f, 0.0f, OVERBRIGHT, false, false, false, false );
InstallSpewFunction();
SpewActivate( "developer", 1 );
CmdLib_InitFileSystem( argv[ argc-1 ] );
Q_StripExtension( ExpandArg( argv[ argc-1 ] ), source, sizeof( source ) );
Q_FileBase( source, mapbase, sizeof( mapbase ) );
strlwr( mapbase );
LoadCmdLineFromFile( argc, argv, mapbase, "vbsp" );
Msg( "Valve Software - vbsp.exe (%s)\n", __DATE__ );
for (i=1 ; i<argc ; i++)
{
if (!stricmp(argv[i],"-threads"))
{
numthreads = atoi (argv[i+1]);
i++;
}
else if (!Q_stricmp(argv[i],"-glview"))
{
glview = true;
}
else if ( !Q_stricmp(argv[i], "-v") || !Q_stricmp(argv[i], "-verbose") )
{
Msg("verbose = true\n");
verbose = true;
}
else if (!Q_stricmp(argv[i], "-noweld"))
{
Msg ("noweld = true\n");
noweld = true;
}
else if (!Q_stricmp(argv[i], "-nocsg"))
{
Msg ("nocsg = true\n");
nocsg = true;
}
else if (!Q_stricmp(argv[i], "-noshare"))
{
Msg ("noshare = true\n");
noshare = true;
}
else if (!Q_stricmp(argv[i], "-notjunc"))
{
Msg ("notjunc = true\n");
notjunc = true;
}
else if (!Q_stricmp(argv[i], "-nowater"))
{
Msg ("nowater = true\n");
nowater = true;
}
else if (!Q_stricmp(argv[i], "-noopt"))
{
Msg ("noopt = true\n");
noopt = true;
}
else if (!Q_stricmp(argv[i], "-noprune"))
{
Msg ("noprune = true\n");
noprune = true;
}
else if (!Q_stricmp(argv[i], "-nomerge"))
{
Msg ("nomerge = true\n");
nomerge = true;
}
else if (!Q_stricmp(argv[i], "-nomergewater"))
{
Msg ("nomergewater = true\n");
nomergewater = true;
}
else if (!Q_stricmp(argv[i], "-nosubdiv"))
{
Msg ("nosubdiv = true\n");
nosubdiv = true;
}
else if (!Q_stricmp(argv[i], "-nodetail"))
{
Msg ("nodetail = true\n");
nodetail = true;
}
else if (!Q_stricmp(argv[i], "-fulldetail"))
{
Msg ("fulldetail = true\n");
fulldetail = true;
}
else if (!Q_stricmp(argv[i], "-onlyents"))
{
Msg ("onlyents = true\n");
onlyents = true;
}
else if (!Q_stricmp(argv[i], "-onlyprops"))
{
Msg ("onlyprops = true\n");
onlyprops = true;
}
else if (!Q_stricmp(argv[i], "-micro"))
{
microvolume = atof(argv[i+1]);
Msg ("microvolume = %f\n", microvolume);
i++;
}
else if (!Q_stricmp(argv[i], "-leaktest"))
{
Msg ("leaktest = true\n");
leaktest = true;
}
else if (!Q_stricmp(argv[i], "-verboseentities"))
{
Msg ("verboseentities = true\n");
verboseentities = true;
}
else if (!Q_stricmp(argv[i], "-snapaxial"))
{
Msg ("snap axial = true\n");
g_snapAxialPlanes = true;
}
#if 0
else if (!Q_stricmp(argv[i], "-maxlightmapdim"))
{
g_maxLightmapDimension = atof(argv[i+1]);
Msg ("g_maxLightmapDimension = %f\n", g_maxLightmapDimension);
i++;
}
#endif
else if (!Q_stricmp(argv[i], "-block"))
{
block_xl = block_xh = atoi(argv[i+1]);
block_yl = block_yh = atoi(argv[i+2]);
Msg ("block: %i,%i\n", block_xl, block_yl);
i+=2;
}
else if (!Q_stricmp(argv[i], "-blocks"))
{
block_xl = atoi(argv[i+1]);
block_yl = atoi(argv[i+2]);
block_xh = atoi(argv[i+3]);
block_yh = atoi(argv[i+4]);
Msg ("blocks: %i,%i to %i,%i\n",
block_xl, block_yl, block_xh, block_yh);
i+=4;
}
else if ( !Q_stricmp( argv[i], "-dumpcollide" ) )
{
Msg("Dumping collision models to collideXXX.txt\n" );
dumpcollide = true;
}
else if ( !Q_stricmp( argv[i], "-dumpstaticprop" ) )
{
Msg("Dumping static props to staticpropXXX.txt\n" );
g_DumpStaticProps = true;
}
else if ( !Q_stricmp( argv[i], "-forceskyvis" ) )
{
Msg("Enabled vis in 3d skybox\n" );
g_bSkyVis = true;
}
else if (!Q_stricmp (argv[i],"-tmpout"))
{
strcpy (outbase, "/tmp");
}
#if 0
else if( !Q_stricmp( argv[i], "-defaultluxelsize" ) )
{
g_defaultLuxelSize = atof( argv[i+1] );
i++;
}
#endif
else if( !Q_stricmp( argv[i], "-luxelscale" ) )
{
g_luxelScale = atof( argv[i+1] );
i++;
}
else if( !strcmp( argv[i], "-minluxelscale" ) )
{
g_minLuxelScale = atof( argv[i+1] );
if (g_minLuxelScale < 1)
g_minLuxelScale = 1;
i++;
}
else if( !Q_stricmp( argv[i], "-dxlevel" ) )
{
g_nDXLevel = atoi( argv[i+1] );
Msg( "DXLevel = %d\n", g_nDXLevel );
i++;
}
else if( !Q_stricmp( argv[i], "-bumpall" ) )
{
g_BumpAll = true;
}
else if( !Q_stricmp( argv[i], "-low" ) )
{
g_bLowPriority = true;
}
else if( !Q_stricmp( argv[i], "-lightifmissing" ) )
{
g_bLightIfMissing = true;
}
else if ( !Q_stricmp( argv[i], CMDLINEOPTION_NOVCONFIG ) )
{
}
else if ( !Q_stricmp( argv[i], "-allowdebug" ) || !Q_stricmp( argv[i], "-steam" ) )
{
// nothing to do here, but don't bail on this option
}
else if ( !Q_stricmp( argv[i], "-vproject" ) || !Q_stricmp( argv[i], "-game" ) )
{
++i;
}
else if ( !Q_stricmp( argv[i], "-keepstalezip" ) )
{
g_bKeepStaleZip = true;
}
else if ( !Q_stricmp( argv[i], "-xbox" ) )
{
// enable mandatory xbox extensions
g_NodrawTriggers = true;
g_DisableWaterLighting = true;
}
else if ( !Q_stricmp( argv[i], "-allowdetailcracks"))
{
g_bAllowDetailCracks = true;
}
else if ( !Q_stricmp( argv[i], "-novirtualmesh"))
{
g_bNoVirtualMesh = true;
}
else if ( !Q_stricmp( argv[i], "-replacematerials" ) )
{
g_ReplaceMaterials = true;
}
else if ( !Q_stricmp(argv[i], "-nodrawtriggers") )
{
g_NodrawTriggers = true;
}
else if ( !Q_stricmp( argv[i], "-FullMinidumps" ) )
{
EnableFullMinidumps( true );
}
else if (argv[i][0] == '-')
{
Warning("VBSP: Unknown option \"%s\"\n\n", argv[i]);
i = 100000; // force it to print the usage
break;
}
else
break;
}
if (i != argc - 1)
{
PrintCommandLine( argc, argv );
Warning(
"usage : vbsp [options...] mapfile\n"
"example: vbsp -onlyents c:\\hl2\\hl2\\maps\\test\n"
"\n"
"Common options (use -v to see all options):\n"
"\n"
" -v (or -verbose): Turn on verbose output (also shows more command\n"
" line options).\n"
"\n"
" -onlyents : This option causes vbsp only import the entities from the .vmf\n"
" file. -onlyents won't reimport brush models.\n"
" -onlyprops : Only update the static props and detail props.\n"
" -glview : Writes .gl files in the current directory that can be viewed\n"
" with glview.exe. If you use -tmpout, it will write the files\n"
" into the \\tmp folder.\n"
" -nodetail : Get rid of all detail geometry. The geometry left over is\n"
" what affects visibility.\n"
" -nowater : Get rid of water brushes.\n"
" -low : Run as an idle-priority process.\n"
"\n"
" -vproject <directory> : Override the VPROJECT environment variable.\n"
" -game <directory> : Same as -vproject.\n"
"\n" );
if ( verbose )
{
Warning(
"Other options :\n"
" -novconfig : Don't bring up graphical UI on vproject errors.\n"
" -threads : Control the number of threads vbsp uses (defaults to the # of\n"
" processors on your machine).\n"
" -verboseentities: If -v is on, this disables verbose output for submodels.\n"
" -noweld : Don't join face vertices together.\n"
" -nocsg : Don't chop out intersecting brush areas.\n"
" -noshare : Emit unique face edges instead of sharing them.\n"
" -notjunc : Don't fixup t-junctions.\n"
" -noopt : By default, vbsp removes the 'outer shell' of the map, which\n"
" are all the faces you can't see because you can never get\n"
" outside the map. -noopt disables this behaviour.\n"
" -noprune : Don't prune neighboring solid nodes.\n"
" -nomerge : Don't merge together chopped faces on nodes.\n"
" -nomergewater: Don't merge together chopped faces on water.\n"
" -nosubdiv : Don't subdivide faces for lightmapping.\n"
" -micro <#> : vbsp will warn when brushes are output with a volume less\n"
" than this number (default: 1.0).\n"
" -fulldetail : Mark all detail geometry as normal geometry (so all detail\n"
" geometry will affect visibility).\n"
" -leaktest : Stop processing the map if a leak is detected. Whether or not\n"
" this flag is set, a leak file will be written out at\n"
" <vmf filename>.lin, and it can be imported into Hammer.\n"
" -bumpall : Force all surfaces to be bump mapped.\n"
" -snapaxial : Snap axial planes to integer coordinates.\n"
" -block # # : Control the grid size mins that vbsp chops the level on.\n"
" -blocks # # # # : Enter the mins and maxs for the grid size vbsp uses.\n"
" -dumpstaticprops: Dump static props to staticprop*.txt\n"
" -dumpcollide : Write files with collision info.\n"
" -forceskyvis : Enable vis calculations in 3d skybox leaves\n"
" -luxelscale # : Scale all lightmaps by this amount (default: 1.0).\n"
" -minluxelscale #: No luxel scale will be lower than this amount (default: 1.0).\n"
" -lightifmissing : Force lightmaps to be generated for all surfaces even if\n"
" they don't need lightmaps.\n"
" -keepstalezip : Keep the BSP's zip files intact but regenerate everything\n"
" else.\n"
" -virtualdispphysics : Use virtual (not precomputed) displacement collision models\n"
" -xbox : Enable mandatory xbox options\n"
" -x360 : Generate Xbox360 version of vsp\n"
" -nox360 : Disable generation Xbox360 version of vsp (default)\n"
" -replacematerials : Substitute materials according to materialsub.txt in content\\maps\n"
" -FullMinidumps : Write large minidumps on crash.\n"
);
}
DeleteCmdLine( argc, argv );
CmdLib_Cleanup();
CmdLib_Exit( 1 );
}
start = Plat_FloatTime();
// Run in the background?
if( g_bLowPriority )
{
SetLowPriority();
}
if( ( g_nDXLevel != 0 ) && ( g_nDXLevel < 80 ) )
{
g_BumpAll = false;
}
if( g_luxelScale == 1.0f )
{
if ( g_nDXLevel == 70 )
{
g_luxelScale = 4.0f;
}
}
ThreadSetDefault ();
numthreads = 1; // multiple threads aren't helping...
// Setup the logfile.
char logFile[512];
_snprintf( logFile, sizeof(logFile), "%s.log", source );
SetSpewFunctionLogFile( logFile );
LoadPhysicsDLL();
LoadSurfaceProperties();
#if 0
Msg( "qdir: %s This is the the path of the initial source file \n", qdir );
Msg( "gamedir: %s This is the base engine + mod-specific game dir (e.g. d:/tf2/mytfmod/) \n", gamedir );
Msg( "basegamedir: %s This is the base engine + base game directory (e.g. e:/hl2/hl2/, or d:/tf2/tf2/ )\n", basegamedir );
#endif
sprintf( materialPath, "%smaterials", gamedir );
InitMaterialSystem( materialPath, CmdLib_GetFileSystemFactory() );
Msg( "materialPath: %s\n", materialPath );
// delete portal and line files
sprintf (path, "%s.prt", source);
remove (path);
sprintf (path, "%s.lin", source);
remove (path);
strcpy (name, ExpandArg (argv[i]));
const char *pszExtension = V_GetFileExtension( name );
if ( !pszExtension )
{
V_SetExtension( name, ".vmm", sizeof( name ) );
if ( !FileExists( name ) )
{
V_SetExtension( name, ".vmf", sizeof( name ) );
}
}
char platformBSPFileName[1024];
GetPlatformMapPath( source, platformBSPFileName, g_nDXLevel, 1024 );
// if we're combining materials, load the script file
if ( g_ReplaceMaterials )
{
LoadMaterialReplacementKeys( gamedir, mapbase );
}
//
// if onlyents, just grab the entites and resave
//
if (onlyents)
{
LoadBSPFile (platformBSPFileName);
num_entities = 0;
// Clear out the cubemap samples since they will be reparsed even with -onlyents
g_nCubemapSamples = 0;
// Mark as stale since the lighting could be screwed with new ents.
AddBufferToPak( GetPakFile(), "stale.txt", "stale", strlen( "stale" ) + 1, false );
LoadMapFile (name);
SetModelNumbers ();
SetLightStyles ();
// NOTE: If we ever precompute lighting for static props in
// vrad, EmitStaticProps should be removed here
// Emit static props found in the .vmf file
EmitStaticProps();
// NOTE: Don't deal with detail props here, it blows away lighting
// Recompute the skybox
ComputeBoundsNoSkybox();
// Make sure that we have a water lod control eneity if we have water in the map.
EnsurePresenceOfWaterLODControlEntity();
// Make sure the func_occluders have the appropriate data set
FixupOnlyEntsOccluderEntities();
// Doing this here because stuff abov may filter out entities
UnparseEntities ();
WriteBSPFile (platformBSPFileName);
}
else if (onlyprops)
{
// In the only props case, deal with static + detail props only
LoadBSPFile (platformBSPFileName);
LoadMapFile(name);
SetModelNumbers();
SetLightStyles();
// Emit static props found in the .vmf file
EmitStaticProps();
// Place detail props found in .vmf and based on material properties
LoadEmitDetailObjectDictionary( gamedir );
EmitDetailObjects();
WriteBSPFile (platformBSPFileName);
}
else
{
//
// start from scratch
//
// Load just the file system from the bsp
if( g_bKeepStaleZip && FileExists( platformBSPFileName ) )
{
LoadBSPFile_FileSystemOnly (platformBSPFileName);
// Mark as stale since the lighting could be screwed with new ents.
AddBufferToPak( GetPakFile(), "stale.txt", "stale", strlen( "stale" ) + 1, false );
}
LoadMapFile (name);
WorldVertexTransitionFixup();
if( ( g_nDXLevel == 0 ) || ( g_nDXLevel >= 70 ) )
{
Cubemap_FixupBrushSidesMaterials();
Cubemap_AttachDefaultCubemapToSpecularSides();
Cubemap_AddUnreferencedCubemaps();
}
SetModelNumbers ();
SetLightStyles ();
LoadEmitDetailObjectDictionary( gamedir );
ProcessModels ();
}
end = Plat_FloatTime();
char str[512];
GetHourMinuteSecondsString( (int)( end - start ), str, sizeof( str ) );
Msg( "%s elapsed\n", str );
DeleteCmdLine( argc, argv );
ReleasePakFileLumps();
DeleteMaterialReplacementKeys();
ShutdownMaterialSystem();
CmdLib_Cleanup();
return 0;
}
virtual InitReturnVal_t Init()
{
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f );
return BaseClass::Init();
}
