//========= Copyright Valve Corporation, All rights reserved. ============// // // Purpose: // // $NoKeywords: $ // //===========================================================================// // // Half-Life Model Viewer (c) 1999 by Mete Ciragan // // file: mdlviewer.cpp // last modified: Jun 03 1999, Mete Ciragan // copyright: The programs and associated files contained in this // distribution were developed by Mete Ciragan. The programs // are not in the public domain, but they are freely // distributable without licensing fees. These programs are // provided without guarantee or warrantee expressed or // implied. // // version: 1.2 // // email: mete@swissquake.ch // web: http://www.swissquake.ch/chumbalum-soft/ // #include #include #include #include #include #include #include "mdlviewer.h" #include "ViewerSettings.h" #include "MatSysWin.h" #include "ControlPanel.h" #include "StudioModel.h" #include "FileAssociation.h" #include "tier1/strtools.h" #include "tier0/icommandline.h" #include "filesystem.h" #include "ifilesystemopendialog.h" #include "appframework/appframework.h" #include "istudiorender.h" #include "materialsystem/imaterialsystem.h" #include "vphysics_interface.h" #include "Datacache/imdlcache.h" #include "datacache/idatacache.h" #include "filesystem_init.h" #include "materialsystem/imaterialsystemhardwareconfig.h" #include "SoundEmitterSystem/isoundemittersystembase.h" #include "soundsystem/isoundsystem.h" #include "tier1/tier1.h" #include "valve_ipc_win32.h" #include "threadtools.h" #include "vstdlib/IKeyValuesSystem.h" bool g_bOldFileDialogs = false; MDLViewer *g_MDLViewer = 0; char g_appTitle[] = "Half-Life Model Viewer v1.22"; static char recentFiles[8][256] = { "", "", "", "", "", "", "", "" }; extern int g_dxlevel; bool g_bInError = false; //----------------------------------------------------------------------------- // Singleton interfaces //----------------------------------------------------------------------------- IStudioRender *g_pStudioRender; IMDLCache *g_pMDLCache; IPhysicsSurfaceProps *physprop; IPhysicsCollision *physcollision; IFileSystem *g_pFileSystem; IMaterialSystem *g_pMaterialSystem; IMaterialSystemHardwareConfig *g_pMaterialSystemHardwareConfig; IStudioDataCache *g_pStudioDataCache; IDataCache *g_pDataCache; ISoundEmitterSystemBase *g_pSoundEmitterBase; ISoundSystem *g_pSoundSystem; CreateInterfaceFn g_Factory; // Filesystem dialog module wrappers. CSysModule *g_pFSDialogModule = 0; CreateInterfaceFn g_FSDialogFactory = 0; class CHlmvIpcServer : public CValveIpcServerUtl { public: CHlmvIpcServer() : CValveIpcServerUtl( "HLMV_IPC_SERVER" ) {} ~CHlmvIpcServer(); public: bool HasCommands(); void AppendCommand( char *pszCommand ); char *GetCommand(); void PopCommand(); protected: virtual BOOL ExecuteCommand( CUtlBuffer &cmd, CUtlBuffer &res ); protected: CThreadFastMutex m_mtx; CUtlVector< char * > m_lstCommands; } g_HlmvIpcServer; CValveIpcClientUtl g_HlmvIpcClient( "HLMV_IPC_SERVER" ); bool g_bHlmvMaster = false; // This hlmv is controlling a controlled hlmv instance bool g_bHlmvControlled = false; // This hlmv is being controlled by a master hlmv instance void LoadFileSystemDialogModule() { Assert( !g_pFSDialogModule ); // Load the module with the file system open dialog. const char *pDLLName = "FileSystemOpenDialog.dll"; g_pFSDialogModule = Sys_LoadModule( pDLLName ); if ( g_pFSDialogModule ) { g_FSDialogFactory = Sys_GetFactory( g_pFSDialogModule ); } if ( !g_pFSDialogModule || !g_FSDialogFactory ) { if ( g_pFSDialogModule ) { Sys_UnloadModule( g_pFSDialogModule ); g_pFSDialogModule = NULL; } } } void UnloadFileSystemDialogModule() { if ( g_pFSDialogModule ) { Sys_UnloadModule( g_pFSDialogModule ); g_pFSDialogModule = 0; } } void MDLViewer::initRecentFiles () { for (int i = 0; i < 8; i++) { if (strlen (recentFiles[i])) { mb->modify (IDC_FILE_RECENTMODELS1 + i, IDC_FILE_RECENTMODELS1 + i, recentFiles[i]); } else { mb->modify (IDC_FILE_RECENTMODELS1 + i, IDC_FILE_RECENTMODELS1 + i, "(empty)"); mb->setEnabled (IDC_FILE_RECENTMODELS1 + i, false); } } } void MDLViewer::loadRecentFiles () { char path[256]; strcpy (path, mx::getApplicationPath ()); strcat (path, "/hlmv.rf"); FILE *file = fopen (path, "rb"); if (file) { fread (recentFiles, sizeof recentFiles, 1, file); fclose (file); } } void MDLViewer::saveRecentFiles () { char path[256]; strcpy (path, mx::getApplicationPath ()); strcat (path, "/hlmv.rf"); FILE *file = fopen (path, "wb"); if (file) { fwrite (recentFiles, sizeof recentFiles, 1, file); fclose (file); } } struct AccelTableEntry_t { unsigned short key; unsigned short command; unsigned char flags; }; AccelTableEntry_t accelTable[] = {{VK_F1, IDC_FLUSH_SHADERS, mx::ACCEL_VIRTKEY}, {VK_F5, IDC_FILE_REFRESH, mx::ACCEL_VIRTKEY}, {'u', IDC_FILE_UNLOADALLMERGEDMODELS, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'U', IDC_FILE_UNLOADALLMERGEDMODELS, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'w', IDC_ACCEL_WIREFRAME, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'W', IDC_ACCEL_WIREFRAME, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'a', IDC_ACCEL_ATTACHMENTS, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'A', IDC_ACCEL_ATTACHMENTS, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'g', IDC_ACCEL_GROUND, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'G', IDC_ACCEL_GROUND, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'h', IDC_ACCEL_HITBOXES, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'H', IDC_ACCEL_HITBOXES, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'o', IDC_ACCEL_BONES, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'O', IDC_ACCEL_BONES, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'b', IDC_ACCEL_BACKGROUND, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'B', IDC_ACCEL_BACKGROUND, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'m', IDC_ACCEL_MOVEMENT, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'M', IDC_ACCEL_MOVEMENT, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'n', IDC_ACCEL_NORMALS, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'N', IDC_ACCEL_NORMALS, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'t', IDC_ACCEL_TANGENTS, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'T', IDC_ACCEL_TANGENTS, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'s', IDC_ACCEL_SHADOW, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}, {'S', IDC_ACCEL_SHADOW, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY}}; #define NUM_ACCELERATORS ARRAYSIZE( accelTable ) MDLViewer::MDLViewer () : mxWindow (0, 0, 0, 0, 0, g_appTitle, mxWindow::Normal) { d_MatSysWindow = 0; d_cpl = 0; // create menu stuff mb = new mxMenuBar (this); mxMenu *menuFile = new mxMenu (); menuOptions = new mxMenu (); menuView = new mxMenu (); mxMenu *menuHelp = new mxMenu (); mb->addMenu ("File", menuFile); mb->addMenu ("Options", menuOptions); mb->addMenu ("View", menuView); mb->addMenu ("Help", menuHelp); mxMenu *menuRecentModels = new mxMenu (); menuRecentModels->add ("(empty)", IDC_FILE_RECENTMODELS1); menuRecentModels->add ("(empty)", IDC_FILE_RECENTMODELS2); menuRecentModels->add ("(empty)", IDC_FILE_RECENTMODELS3); menuRecentModels->add ("(empty)", IDC_FILE_RECENTMODELS4); menuRecentModels->add ("(empty)", IDC_FILE_RECENTMODELS5); menuRecentModels->add ("(empty)", IDC_FILE_RECENTMODELS6); menuRecentModels->add ("(empty)", IDC_FILE_RECENTMODELS7); menuRecentModels->add ("(empty)", IDC_FILE_RECENTMODELS8); if ( g_bOldFileDialogs ) { menuFile->add ("Load Model...", IDC_FILE_LOADMODEL); menuFile->add ("(Steam) Load Model...", IDC_FILE_LOADMODEL_STEAM); } else { menuFile->add ("Load Model...", IDC_FILE_LOADMODEL_STEAM); } menuFile->add( "Refresh (F5)", IDC_FILE_REFRESH ); menuFile->addSeparator (); if ( g_bOldFileDialogs ) { menuFile->add ("Load Weapon...", IDC_FILE_LOADMERGEDMODEL); menuFile->add ("(Steam) Load Weapon...", IDC_FILE_LOADMERGEDMODEL_STEAM); } else { menuFile->add ("Load Weapon...", IDC_FILE_LOADMERGEDMODEL_STEAM); } mxMenu *menuUnloadWeapon = new mxMenu (); menuUnloadWeapon->add ("Unload All Merged Models (Ctrl-U)", IDC_FILE_UNLOADALLMERGEDMODELS); menuUnloadWeapon->add ("(empty)", IDC_FILE_UNLOADMERGEDMODEL1); menuUnloadWeapon->add ("(empty)", IDC_FILE_UNLOADMERGEDMODEL2); menuUnloadWeapon->add ("(empty)", IDC_FILE_UNLOADMERGEDMODEL3); menuUnloadWeapon->add ("(empty)", IDC_FILE_UNLOADMERGEDMODEL4); menuUnloadWeapon->add ("(empty)", IDC_FILE_UNLOADMERGEDMODEL5); menuUnloadWeapon->add ("(empty)", IDC_FILE_UNLOADMERGEDMODEL6); menuUnloadWeapon->add ("(empty)", IDC_FILE_UNLOADMERGEDMODEL7); menuUnloadWeapon->add ("(empty)", IDC_FILE_UNLOADMERGEDMODEL8); menuUnloadWeapon->add ("(empty)", IDC_FILE_UNLOADMERGEDMODEL9); menuUnloadWeapon->add ("(empty)", IDC_FILE_UNLOADMERGEDMODEL10); menuUnloadWeapon->add ("(empty)", IDC_FILE_UNLOADMERGEDMODEL11); menuUnloadWeapon->add ("(empty)", IDC_FILE_UNLOADMERGEDMODEL12); for ( int i = IDC_FILE_UNLOADMERGEDMODEL1; i <= IDC_FILE_UNLOADMERGEDMODEL12; i++ ) { menuUnloadWeapon->setEnabled( i, false ); } menuFile->addMenu ("Unload Weapon", menuUnloadWeapon); menuFile->addSeparator (); menuFile->add ("Load Background Texture...", IDC_FILE_LOADBACKGROUNDTEX); menuFile->add ("Load Ground Texture...", IDC_FILE_LOADGROUNDTEX); menuFile->addSeparator (); menuFile->add ("Unload Ground Texture", IDC_FILE_UNLOADGROUNDTEX); menuFile->addSeparator (); menuFile->addMenu ("Recent Models", menuRecentModels); menuFile->addSeparator (); menuFile->add ("Exit", IDC_FILE_EXIT); menuFile->setEnabled(IDC_FILE_LOADBACKGROUNDTEX, false); menuFile->setEnabled(IDC_FILE_LOADGROUNDTEX, false); menuFile->setEnabled(IDC_FILE_UNLOADGROUNDTEX, false); menuOptions->add ("Background Color...", IDC_OPTIONS_COLORBACKGROUND); menuOptions->add ("Ground Color...", IDC_OPTIONS_COLORGROUND); menuOptions->add ("Light Color...", IDC_OPTIONS_COLORLIGHT); menuOptions->add ("Ambient Color...", IDC_OPTIONS_COLORAMBIENT); menuOptions->addSeparator (); menuOptions->add ("Center View", IDC_OPTIONS_CENTERVIEW); menuOptions->add ("Viewmodel Mode", IDC_OPTIONS_VIEWMODEL); #ifdef WIN32 menuOptions->addSeparator (); menuOptions->add ("Make Screenshot...", IDC_OPTIONS_MAKESCREENSHOT); //menuOptions->add ("Dump Model Info", IDC_OPTIONS_DUMP); #endif menuView->add ("File Associations...", IDC_VIEW_FILEASSOCIATIONS); menuView->setEnabled( IDC_VIEW_FILEASSOCIATIONS, false ); menuView->addSeparator (); menuView->add ("Show Activities", IDC_VIEW_ACTIVITIES); menuView->add ("Show hidden", IDC_VIEW_HIDDEN ); #ifdef WIN32 menuHelp->add ("Goto Homepage...", IDC_HELP_GOTOHOMEPAGE); menuHelp->addSeparator (); #endif menuHelp->add ("About...", IDC_HELP_ABOUT); d_MatSysWindow = new MatSysWindow (this, 0, 0, 100, 100, "", mxWindow::Normal); #ifdef WIN32 // SetWindowLong ((HWND) d_MatSysWindow->getHandle (), GWL_EXSTYLE, WS_EX_CLIENTEDGE); #endif d_cpl = new ControlPanel (this); d_cpl->setMatSysWindow (d_MatSysWindow); g_MatSysWindow = d_MatSysWindow; g_FileAssociation = new FileAssociation (); loadRecentFiles (); initRecentFiles (); LoadViewerRootSettings( ); // FIXME: where do I actually find the domain size of the viewport, especially for multi-monitor // try to catch weird initialization error if (g_viewerSettings.xpos < -16384) g_viewerSettings.xpos = 20; if (g_viewerSettings.ypos < -16384) g_viewerSettings.ypos = 20; g_viewerSettings.ypos = max( 0, g_viewerSettings.ypos ); g_viewerSettings.width = max( 640, g_viewerSettings.width ); g_viewerSettings.height = max( 700, g_viewerSettings.height ); setBounds( g_viewerSettings.xpos, g_viewerSettings.ypos, g_viewerSettings.width, g_viewerSettings.height ); setVisible (true); setTimer( 200 ); CUtlVector< mx::Accel_t > accelerators; mx::Accel_t accel; for (int i=0; i < NUM_ACCELERATORS; i++) { accel.flags = accelTable[i].flags ; accel.key = accelTable[i].key; accel.command = accelTable[i].command; accelerators.AddToTail( accel ); } mx::createAccleratorTable( accelerators.Count(), accelerators.Base() ); g_HlmvIpcServer.EnsureRegisteredAndRunning(); if ( !g_HlmvIpcServer.IsRunning() ) { menuOptions->addSeparator(); menuOptions->add ( "Link HLMV", IDC_OPTIONS_LINKHLMV ); menuOptions->add ( "Unlink HLMV", IDC_OPTIONS_UNLINKHLMV ); menuOptions->setChecked( IDC_OPTIONS_UNLINKHLMV, true ); menuOptions->setEnabled( IDC_OPTIONS_UNLINKHLMV, false ); } } MDLViewer::~MDLViewer () { g_HlmvIpcServer.EnsureStoppedAndUnregistered(); saveRecentFiles (); SaveViewerSettings( g_pStudioModel->GetFileName(), g_pStudioModel ); SaveViewerRootSettings( ); #ifdef WIN32 DeleteFile ("hlmv.cfg"); DeleteFile ("midump.txt"); #endif } //----------------------------------------------------------------------------- // Purpose: Reloads the currently loaded model file. //----------------------------------------------------------------------------- void MDLViewer::Refresh( void ) { KeyValuesSystem()->InvalidateCache(); g_pStudioModel->ReleaseStudioModel(); g_pMDLCache->Flush(); if ( recentFiles[0][0] != '\0' ) { char szFile[MAX_PATH]; strcpy( szFile, recentFiles[0] ); g_pMaterialSystem->ReloadMaterials(); d_cpl->loadModel( szFile ); } } //----------------------------------------------------------------------------- // Purpose: Loads the file and updates the MRU list. // Input : pszFile - File to load. //----------------------------------------------------------------------------- void MDLViewer::LoadModelFile( const char *pszFile, int slot ) { // copy off name, pszFile may be point into recentFiles array char filename[1024]; strcpy( filename, pszFile ); LoadModelResult_t eLoaded = d_cpl->loadModel( filename, slot ); if ( eLoaded != LoadModel_Success ) { switch (eLoaded) { case LoadModel_LoadFail: { mxMessageBox (this, "Error loading model.", g_appTitle, MX_MB_ERROR | MX_MB_OK); break; } case LoadModel_PostLoadFail: { mxMessageBox (this, "Error post-loading model.", g_appTitle, MX_MB_ERROR | MX_MB_OK); break; } case LoadModel_NoModel: { mxMessageBox (this, "Error loading model. The model has no vertices.", g_appTitle, MX_MB_ERROR | MX_MB_OK); break; } } return; } if (slot == -1) { int i; for (i = 0; i < 8; i++) { if (!mx_strcasecmp( recentFiles[i], filename )) break; } // shift down existing recent files for (i = ((i > 7) ? 7 : i); i > 0; i--) { strcpy (recentFiles[i], recentFiles[i-1]); } strcpy( recentFiles[0], filename ); initRecentFiles (); setLabel( "%s", filename ); } else { mb->modify (IDC_FILE_UNLOADMERGEDMODEL1 + slot, IDC_FILE_UNLOADMERGEDMODEL1 + slot, pszFile); mb->setEnabled (IDC_FILE_UNLOADMERGEDMODEL1 + slot, true); } } //----------------------------------------------------------------------------- // Purpose: Takes a TGA screenshot of the given filename and exits. // Input : pszFile - File to load. //----------------------------------------------------------------------------- void MDLViewer::SaveScreenShot( const char *pszFile ) { char filename[1024]; strcpy( filename, pszFile ); LoadModelResult_t eLoaded = d_cpl->loadModel( filename ); // // Screenshot mode. Write a screenshot file and exit. // if ( eLoaded == LoadModel_Success ) { g_viewerSettings.bgColor[0] = 117.0f / 255.0f; g_viewerSettings.bgColor[1] = 196.0f / 255.0f; g_viewerSettings.bgColor[2] = 219.0f / 255.0f; // Build the name of the TGA to write. char szScreenShot[256]; strcpy(szScreenShot, filename); char *pchDot = strrchr(szScreenShot, '.'); if (pchDot) { strcpy(pchDot, ".tga"); } else { strcat(szScreenShot, ".tga"); } // Center the view and write the TGA. d_cpl->centerView(); d_MatSysWindow->dumpViewport(szScreenShot); } // Shut down. mx::quit(); return; } void MDLViewer::DumpText( const char *pszFile ) { char filename[1024]; strcpy( filename, pszFile ); LoadModelResult_t eLoaded = d_cpl->loadModel( filename ); // // Screenshot mode. Write a screenshot file and exit. // if ( eLoaded == LoadModel_Success ) { if ( g_pStudioModel->m_bIsTransparent ) { Msg("%s is transparent\n", filename ); } if ( g_pStudioModel->m_bHasProxy ) { Msg("%s has material proxies\n", filename ); } } // Shut down. mx::quit(); } const char* MDLViewer::SteamGetOpenFilename() { if ( !g_FSDialogFactory ) return NULL; static char filename[MAX_PATH]; IFileSystemOpenDialog *pDlg; pDlg = (IFileSystemOpenDialog*)g_FSDialogFactory( FILESYSTEMOPENDIALOG_VERSION, NULL ); if ( !pDlg ) { char str[512]; Q_snprintf( str, sizeof( str ), "Can't create %s interface.", FILESYSTEMOPENDIALOG_VERSION ); MessageBox( NULL, str, "Error", MB_OK ); return NULL; } pDlg->Init( g_Factory, NULL ); pDlg->AddFileMask( "*.jpg" ); pDlg->AddFileMask( "*.mdl" ); pDlg->SetInitialDir( "models", "game" ); pDlg->SetFilterMdlAndJpgFiles( true ); if (pDlg->DoModal() == IDOK) { pDlg->GetFilename( filename, sizeof( filename ) ); pDlg->Release(); return filename; } else { pDlg->Release(); return NULL; } } int MDLViewer::handleEvent (mxEvent *event) { MDLCACHE_CRITICAL_SECTION_( g_pMDLCache ); switch (event->event) { case mxEvent::Action: { switch (event->action) { case IDC_FILE_LOADMODEL: { const char *ptr = mxGetOpenFileName (this, 0, "*.mdl"); if (ptr) { LoadModelFile( ptr ); } } break; case IDC_FILE_LOADMODEL_STEAM: { const char *pFilename = SteamGetOpenFilename(); if ( pFilename ) { LoadModelFile( pFilename ); } } break; case IDC_FILE_LOADMERGEDMODEL: { const char *ptr = mxGetOpenFileName (this, 0, "*.mdl"); if (ptr) { // find the first free slot int iChosenSlot = 0; for ( int i = 0; i < HLMV_MAX_MERGED_MODELS; i++ ) { if ( g_viewerSettings.mergeModelFile[i][0] == 0 ) { iChosenSlot = i; break; } } strcpy( g_viewerSettings.mergeModelFile[iChosenSlot], ptr ); LoadModelFile( ptr, iChosenSlot ); } } break; case IDC_FILE_LOADMERGEDMODEL_STEAM: { const char *pFilename = SteamGetOpenFilename(); if ( pFilename ) { // find the first free slot int iChosenSlot = 0; for ( int i = 0; i < HLMV_MAX_MERGED_MODELS; i++ ) { if ( g_viewerSettings.mergeModelFile[i][0] == 0 ) { iChosenSlot = i; break; } } strcpy( g_viewerSettings.mergeModelFile[iChosenSlot], pFilename ); LoadModelFile( pFilename, iChosenSlot ); } } break; case IDC_FILE_UNLOADMERGEDMODEL1: case IDC_FILE_UNLOADMERGEDMODEL2: case IDC_FILE_UNLOADMERGEDMODEL3: case IDC_FILE_UNLOADMERGEDMODEL4: case IDC_FILE_UNLOADMERGEDMODEL5: case IDC_FILE_UNLOADMERGEDMODEL6: case IDC_FILE_UNLOADMERGEDMODEL7: case IDC_FILE_UNLOADMERGEDMODEL8: case IDC_FILE_UNLOADMERGEDMODEL9: case IDC_FILE_UNLOADMERGEDMODEL10: case IDC_FILE_UNLOADMERGEDMODEL11: case IDC_FILE_UNLOADMERGEDMODEL12: { int i = event->action - IDC_FILE_UNLOADMERGEDMODEL1; // FIXME: move to d_cpl if (g_pStudioExtraModel[i]) { V_strcpy_safe( g_viewerSettings.mergeModelFile[i], "" ); g_pStudioExtraModel[i]->FreeModel( false ); delete g_pStudioExtraModel[i]; g_pStudioExtraModel[i] = NULL; mb->modify (IDC_FILE_UNLOADMERGEDMODEL1 + i, IDC_FILE_UNLOADMERGEDMODEL1 + i, "(empty)"); mb->setEnabled (IDC_FILE_UNLOADMERGEDMODEL1 + i, false); } } break; case IDC_FILE_UNLOADALLMERGEDMODELS: d_cpl->UnloadAllMergedModels(); break; case IDC_FILE_REFRESH: { Refresh(); break; } case IDC_FLUSH_SHADERS: { CCommand args; args.Tokenize( "mat_flushshaders" ); ConCommandBase *pCommandBase = g_pCVar->FindCommandBase( args[0] ); if ( !pCommandBase ) { ConWarning( "Unknown command or convar '%s'!\n", args[0] ); break; } if ( pCommandBase->IsCommand() ) { ConCommand *pCommand = static_cast( pCommandBase ); pCommand->Dispatch( args ); } } break; case IDC_FILE_LOADBACKGROUNDTEX: case IDC_FILE_LOADGROUNDTEX: { const char *ptr = mxGetOpenFileName (this, 0, "*.*"); if (ptr) { if (0 /* d_MatSysWindow->loadTexture (ptr, event->action - IDC_FILE_LOADBACKGROUNDTEX) */) { if (event->action == IDC_FILE_LOADBACKGROUNDTEX) d_cpl->setShowBackground (true); else d_cpl->setShowGround (true); } else mxMessageBox (this, "Error loading texture.", g_appTitle, MX_MB_OK | MX_MB_ERROR); } } break; case IDC_FILE_UNLOADGROUNDTEX: { // d_MatSysWindow->loadTexture (0, 1); d_cpl->setShowGround (false); } break; case IDC_FILE_RECENTMODELS1: case IDC_FILE_RECENTMODELS2: case IDC_FILE_RECENTMODELS3: case IDC_FILE_RECENTMODELS4: case IDC_FILE_RECENTMODELS5: case IDC_FILE_RECENTMODELS6: case IDC_FILE_RECENTMODELS7: case IDC_FILE_RECENTMODELS8: { int i = event->action - IDC_FILE_RECENTMODELS1; LoadModelFile( recentFiles[i] ); } break; case IDC_FILE_EXIT: { redraw (); mx::quit (); } break; case IDC_OPTIONS_COLORBACKGROUND: case IDC_OPTIONS_COLORGROUND: case IDC_OPTIONS_COLORLIGHT: case IDC_OPTIONS_COLORAMBIENT: { float *cols[4] = { g_viewerSettings.bgColor, g_viewerSettings.gColor, g_viewerSettings.lColor, g_viewerSettings.aColor }; float *col = cols[event->action - IDC_OPTIONS_COLORBACKGROUND]; int r = (int) (col[0] * 255.0f); int g = (int) (col[1] * 255.0f); int b = (int) (col[2] * 255.0f); if (mxChooseColor (this, &r, &g, &b)) { col[0] = (float) r / 255.0f; col[1] = (float) g / 255.0f; col[2] = (float) b / 255.0f; } } break; case IDC_OPTIONS_CENTERVIEW: d_cpl->centerView (); if ( g_bHlmvMaster ) { SendModelTransformToLinkedHlmv(); } break; case IDC_OPTIONS_CENTERVERTS: //d_cpl->centerVerts( ); if ( g_bHlmvMaster ) { SendModelTransformToLinkedHlmv(); } break; case IDC_OPTIONS_VIEWMODEL: { d_cpl->viewmodelView(); if ( g_bHlmvMaster ) { SendModelTransformToLinkedHlmv(); } } break; case IDC_OPTIONS_MAKESCREENSHOT: { char *ptr = (char *) mxGetSaveFileName (this, "", "*.tga"); if (ptr) { if (!strstr (ptr, ".tga")) strcat (ptr, ".tga"); d_MatSysWindow->dumpViewport (ptr); } } break; case IDC_OPTIONS_DUMP: d_cpl->dumpModelInfo (); break; case IDC_OPTIONS_SYNCHLMVCAMERA: SendModelTransformToLinkedHlmv(); break; case IDC_OPTIONS_LINKHLMV: if ( !g_bHlmvMaster && !g_HlmvIpcServer.IsRunning() && g_HlmvIpcClient.Connect() ) { CUtlBuffer cmd; CUtlBuffer res; // Make connection to other hlmv cmd.PutString( "hlmvLink" ); cmd.PutChar( '\0' ); if ( g_HlmvIpcClient.ExecuteCommand( cmd, res ) ) { g_bHlmvMaster = true; } g_HlmvIpcClient.Disconnect(); SendModelTransformToLinkedHlmv(); SendLightRotToLinkedHlmv(); menuOptions->setChecked( IDC_OPTIONS_LINKHLMV, true ); menuOptions->setEnabled( IDC_OPTIONS_LINKHLMV, false ); menuOptions->setChecked( IDC_OPTIONS_UNLINKHLMV, false ); menuOptions->setEnabled( IDC_OPTIONS_UNLINKHLMV, true ); } break; case IDC_OPTIONS_UNLINKHLMV: if ( g_bHlmvMaster && g_HlmvIpcClient.Connect() ) { CUtlBuffer cmd; CUtlBuffer res; // Break connection to linked hlmv cmd.PutString( "hlmvUnlink" ); cmd.PutChar( '\0' ); g_HlmvIpcClient.ExecuteCommand( cmd, res ); g_bHlmvMaster = false; g_HlmvIpcClient.Disconnect(); menuOptions->setChecked( IDC_OPTIONS_LINKHLMV, false ); menuOptions->setEnabled( IDC_OPTIONS_LINKHLMV, true ); menuOptions->setChecked( IDC_OPTIONS_UNLINKHLMV, true ); menuOptions->setEnabled( IDC_OPTIONS_UNLINKHLMV, false ); } break; case IDC_VIEW_FILEASSOCIATIONS: g_FileAssociation->setAssociation (0); g_FileAssociation->setVisible (true); break; case IDC_VIEW_ACTIVITIES: g_viewerSettings.showActivities = !g_viewerSettings.showActivities; menuView->setChecked( event->action, g_viewerSettings.showActivities ); d_cpl->initSequenceChoices(); d_cpl->resetControlPanel(); break; case IDC_VIEW_HIDDEN: g_viewerSettings.showHidden = !g_viewerSettings.showHidden; menuView->setChecked( event->action, g_viewerSettings.showHidden ); d_cpl->initSequenceChoices(); d_cpl->resetControlPanel(); break; #ifdef WIN32 case IDC_HELP_GOTOHOMEPAGE: ShellExecute (0, "open", "http://www.swissquake.ch/chumbalum-soft/index.html", 0, 0, SW_SHOW); break; #endif case IDC_HELP_ABOUT: mxMessageBox (this, "Half-Life Model Viewer v2.0 (c) 2004 Valve Corp.\n" "Portions (c) 1999 by Mete Ciragan\n\n" "Left-drag inside circle to spin.\n" "Left-drag outside circle to rotate.\n" "Right-drag to zoom.\n" "Shift-left-drag to x-y-pan.\n" "Shift-right-drag to z-pan.\n" "Ctrl-left-drag to move light.\n\n" "Build:\t" __DATE__ ".\n" "Email:\tmete@swissquake.ch\n" "Web:\thttp://www.swissquake.ch/chumbalum-soft/", "About Half-Life Model Viewer", MX_MB_OK | MX_MB_INFORMATION); break; case IDC_ACCEL_WIREFRAME: d_cpl->setOverlayWireframe( !g_viewerSettings.overlayWireframe ); break; case IDC_ACCEL_ATTACHMENTS: d_cpl->setShowAttachments( !g_viewerSettings.showAttachments ); break; case IDC_ACCEL_GROUND: d_cpl->setShowGround( !g_viewerSettings.showGround ); break; case IDC_ACCEL_HITBOXES: d_cpl->setShowHitBoxes( !g_viewerSettings.showHitBoxes ); break; case IDC_ACCEL_BONES: d_cpl->setShowBones( !g_viewerSettings.showBones ); break; case IDC_ACCEL_BACKGROUND: d_cpl->setShowBackground( !g_viewerSettings.showBackground ); break; case IDC_ACCEL_MOVEMENT: d_cpl->setShowMovement( !g_viewerSettings.showMovement ); break; case IDC_ACCEL_NORMALS: d_cpl->setShowNormals( !g_viewerSettings.showNormals ); break; case IDC_ACCEL_TANGENTS: d_cpl->setShowTangentFrame( !g_viewerSettings.showTangentFrame ); break; case IDC_ACCEL_SHADOW: d_cpl->setShowShadow( !g_viewerSettings.showShadow ); break; } //switch (event->action) } // mxEvent::Action break; case mxEvent::Size: { g_viewerSettings.xpos = x(); g_viewerSettings.ypos = y(); g_viewerSettings.width = w(); g_viewerSettings.height = h(); int w = event->width; int h = event->height; int y = mb->getHeight (); #ifdef WIN32 #define HEIGHT 240 #else #define HEIGHT 140 h -= 40; #endif d_MatSysWindow->setBounds (0, y, w, h - HEIGHT); // !! d_cpl->setBounds (0, y + h - HEIGHT, w, HEIGHT); } break; case mxEvent::PosChanged: { g_viewerSettings.xpos = x(); g_viewerSettings.ypos = y(); } break; case KeyDown: d_MatSysWindow->handleEvent(event); d_cpl->handleEvent(event); break; case mxEvent::Activate: { if (event->action) { mx::setIdleWindow( getMatSysWindow() ); } else { mx::setIdleWindow( 0 ); } } break; case mxEvent::Timer: { if ( g_HlmvIpcServer.HasCommands() ) { // Execute next command at next msg pump, ~ 1/60th s (60Hz) if controlled, 0.1s if not if ( g_bHlmvControlled ) { // Clear up to 10 pending commands if controlled for ( int nCmdCount = 0; nCmdCount < 10 && g_HlmvIpcServer.HasCommands(); ++nCmdCount ) { handleIpcCommand( g_HlmvIpcServer.GetCommand() ); g_HlmvIpcServer.PopCommand(); } setTimer( 17 ); } else { handleIpcCommand( g_HlmvIpcServer.GetCommand() ); g_HlmvIpcServer.PopCommand(); setTimer( 100 ); } } else if ( !g_HlmvIpcServer.IsRunning() ) { // Keep trying to establish our server slot if another instance quits BOOL bIsRunning = g_HlmvIpcServer.IsRunning(); g_HlmvIpcServer.EnsureRegisteredAndRunning(); if ( !bIsRunning && g_HlmvIpcServer.IsRunning() ) { g_bHlmvMaster = false; menuOptions->setEnabled( IDC_OPTIONS_LINKHLMV, false ); menuOptions->setChecked( IDC_OPTIONS_LINKHLMV, false ); menuOptions->setEnabled( IDC_OPTIONS_UNLINKHLMV, false ); menuOptions->setChecked( IDC_OPTIONS_LINKHLMV, false ); } // Attempt every 1.0 s setTimer( 1000 ); } else { // Idling, poll command queue @ ~60Hz if controlled, 0.5s ( 2Hz ) otherwise if ( g_bHlmvControlled ) { setTimer( 17 ); } else { setTimer( 500 ); } } } break; } // event->event return 1; } void TranslateMayaToHLMVCoordinates( const Vector &vMayaPos, const QAngle &vMayaRot, Vector &vHLMVPos, QAngle &vHLMVAngles ) { vHLMVPos.Init( vMayaPos.z, vMayaPos.x, vMayaPos.y ); vHLMVAngles[PITCH] = -vMayaRot[0]; vHLMVAngles[YAW] = vMayaRot[1] + 180; vHLMVAngles[ROLL] = -vMayaRot[2]; } void MDLViewer::handleIpcCommand( char *szCommand ) { MDLCACHE_CRITICAL_SECTION_( g_pMDLCache ); if ( !strcmp( "reload", szCommand ) ) { Refresh(); if ( HWND hWnd = (HWND) getHandle() ) { if ( ::IsIconic( hWnd ) ) ::ShowWindow( hWnd, SW_RESTORE ); ::BringWindowToTop( hWnd ); ::SetForegroundWindow( hWnd ); ::SetFocus( hWnd ); } } else if ( V_strncasecmp( "cameraTo", szCommand, 8 ) == 0 ) { // Read the camera position and angles from Maya. Vector vMayaPos; QAngle vMayaRot; char szFirstPart[32]; sscanf( szCommand, "%s %f %f %f %f %f %f", szFirstPart, &vMayaPos.x, &vMayaPos.y, &vMayaPos.z, &vMayaRot.x, &vMayaRot.y, &vMayaRot.z ); // // Obviously, this could all be simplified, but it's nice to make it easy to see what it's doing here. // // Translate the camera position/angles from Maya space to model space. // In model space, +X=forward, +Y=left, and +Z=up // (i.e. the model faces forward along +X) Vector vCameraPos; QAngle vCameraAngles; TranslateMayaToHLMVCoordinates( vMayaPos, vMayaRot, vCameraPos, vCameraAngles ); // Now, build a matrix from model space to camera space. The way we're defining camera space, // the axes point the same way as in model space (+X=forward, +Y=left, +Z=up). // This is a standard put-stuff-in-camera-space matrix (backtranslate and then backrotate). matrix3x4_t mModelToCameraRot, mModelToCameraTrans, mModelToCameraFull; // Backtranslate.. SetIdentityMatrix( mModelToCameraTrans ); MatrixSetColumn( -vCameraPos, 3, mModelToCameraTrans ); // Backrotate.. AngleMatrix( vCameraAngles, mModelToCameraRot ); MatrixTranspose( mModelToCameraRot ); // Concatenate. MatrixMultiply( mModelToCameraRot, mModelToCameraTrans, mModelToCameraFull ); // Now we need to convert the camera space from above to HLMV's specific camera space. This just means negating // the X and Y axes because HLMV's camera space is (+X=back, +Y=left, +Z=up). matrix3x4_t mCameraToWorld( -1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0 ); // Blat all these matrices together. matrix3x4_t mFinal; MatrixMultiply( mCameraToWorld, mModelToCameraFull, mFinal ); // Tell HLMV our new fancy transform to use, and then we'll see the model from the same place Maya did. g_pStudioModel->SetModelTransform( mFinal ); // Redraw. d_MatSysWindow->redraw(); } else if ( StringHasPrefixCaseSensitive( szCommand, "hlmvModelTransform" ) ) { matrix3x4_t m; sscanf( szCommand, "%*s %f %f %f %f %f %f %f %f %f %f %f %f", &m.m_flMatVal[0][0], &m.m_flMatVal[0][1], &m.m_flMatVal[0][2], &m.m_flMatVal[0][3], &m.m_flMatVal[1][0], &m.m_flMatVal[1][1], &m.m_flMatVal[1][2], &m.m_flMatVal[1][3], &m.m_flMatVal[2][0], &m.m_flMatVal[2][1], &m.m_flMatVal[2][2], &m.m_flMatVal[2][3] ); // Tell HLMV our new fancy transform to use, and then we'll see the model from the same place Maya did. g_pStudioModel->SetModelTransform( m ); // Redraw. d_MatSysWindow->redraw(); } else if ( StringHasPrefixCaseSensitive( szCommand, "hlmvLightRot" ) ) { sscanf( szCommand, "%*s %f %f %f", &g_viewerSettings.lightrot[0], &g_viewerSettings.lightrot[1], &g_viewerSettings.lightrot[2] ); // Redraw. d_MatSysWindow->redraw(); } else if ( StringHasPrefixCaseSensitive( szCommand, "hlmvForceFrame" ) ) { float flFrame = 0.0f; sscanf( szCommand, "%*s %f", &flFrame ); d_cpl->SetFrameSlider( flFrame ); d_cpl->setFrame( flFrame ); d_cpl->setSpeedScale( 0 ); // Redraw. d_MatSysWindow->redraw(); } else if ( StringHasPrefixCaseSensitive( szCommand, "hlmvLink" ) ) { if ( !g_bHlmvControlled ) { g_bHlmvControlled = true; CUtlString label( "LINKED: " ); label += getLabel(); setLabel( label.Get() ); } } else if ( StringHasPrefixCaseSensitive( szCommand, "hlmvUnlink" ) ) { g_bHlmvControlled = false; const char *pszLabel = getLabel(); if ( StringHasPrefixCaseSensitive( pszLabel, "LINKED: " ) ) { setLabel( pszLabel + 8 ); // Skip past "LINKED: " } } } void MDLViewer::redraw () { /* mxEvent event; event.event = mxEvent::Size; event.width = w2 (); event.height = h2 (); handleEvent (&event); */ } //----------------------------------------------------------------------------- // Purpose: // Output : int //----------------------------------------------------------------------------- int MDLViewer::GetCurrentHitboxSet( void ) { return d_cpl ? d_cpl->GetCurrentHitboxSet() : 0; } //----------------------------------------------------------------------------- // Sends the model transform to the controlled hlmv instance //----------------------------------------------------------------------------- void MDLViewer::SendModelTransformToLinkedHlmv() { if ( g_bHlmvMaster && g_HlmvIpcClient.Connect() ) { matrix3x4_t m; g_pStudioModel->GetModelTransform( m ); CUtlBuffer cmd; CUtlBuffer res; cmd.Printf( "%s %f %f %f %f %f %f %f %f %f %f %f %f", "hlmvModelTransform", m.m_flMatVal[0][0], m.m_flMatVal[0][1], m.m_flMatVal[0][2], m.m_flMatVal[0][3], m.m_flMatVal[1][0], m.m_flMatVal[1][1], m.m_flMatVal[1][2], m.m_flMatVal[1][3], m.m_flMatVal[2][0], m.m_flMatVal[2][1], m.m_flMatVal[2][2], m.m_flMatVal[2][3] ); g_HlmvIpcClient.ExecuteCommand( cmd, res ); g_HlmvIpcClient.Disconnect(); } } //----------------------------------------------------------------------------- // Sends the light rotation to the controlled hlmv instance //----------------------------------------------------------------------------- void MDLViewer::SendLightRotToLinkedHlmv() { if ( g_bHlmvMaster && g_HlmvIpcClient.Connect() ) { CUtlBuffer cmdLightRot; CUtlBuffer resLightRot; cmdLightRot.Printf( "%s %f %f %f", "hlmvLightRot", g_viewerSettings.lightrot[0], g_viewerSettings.lightrot[1], g_viewerSettings.lightrot[2] ); g_HlmvIpcClient.ExecuteCommand( cmdLightRot, resLightRot ); g_HlmvIpcClient.Disconnect(); } } SpewRetval_t HLMVSpewFunc( SpewType_t spewType, char const *pMsg ) { g_bInError = true; switch (spewType) { case SPEW_ERROR: MessageBox(NULL, pMsg, "FATAL ERROR", MB_OK); g_bInError = false; return SPEW_ABORT; default: OutputDebugString(pMsg); g_bInError = false; #ifdef _DEBUG return spewType == SPEW_ASSERT ? SPEW_DEBUGGER : SPEW_CONTINUE; #else return SPEW_CONTINUE; #endif } } //----------------------------------------------------------------------------- // The application object //----------------------------------------------------------------------------- class CHLModelViewerApp : public CSteamAppSystemGroup { public: // Methods of IApplication virtual bool Create(); virtual bool PreInit(); virtual int Main(); virtual void PostShutdown(); virtual void Destroy(); }; //----------------------------------------------------------------------------- // 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"); const char *pArg; if ( CommandLine()->CheckParm( "-shaderapi", &pArg )) { pShaderDLL = pArg; } if(!pShaderDLL) { pShaderDLL = "shaderapidx9.dll"; } g_pMaterialSystem->SetShaderAPI( pShaderDLL ); g_Factory = GetFactory(); return true; } void CHLModelViewerApp::Destroy() { g_pFileSystem = NULL; g_pMaterialSystem = NULL; g_pMaterialSystemHardwareConfig = NULL; g_pStudioRender = NULL; g_pDataCache = NULL; g_pMDLCache = NULL; g_pStudioDataCache = NULL; physcollision = NULL; physprop = NULL; } //----------------------------------------------------------------------------- // 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 ); g_bOldFileDialogs = true; if ( CommandLine()->FindParm( "-NoSteamdDialog" ) ) g_bOldFileDialogs = false; LoadFileSystemDialogModule(); return true; } void CHLModelViewerApp::PostShutdown() { UnloadFileSystemDialogModule(); DisconnectTier1Libraries(); } //----------------------------------------------------------------------------- // main application //----------------------------------------------------------------------------- int CHLModelViewerApp::Main() { g_pMaterialSystem->ModInit(); g_pSoundEmitterBase->ModInit(); g_pDataCache->SetSize( 64 * 1024 * 1024 ); //mx::setDisplayMode (0, 0, 0); g_MDLViewer = new MDLViewer (); g_MDLViewer->setMenuBar (g_MDLViewer->getMenuBar ()); g_pStudioModel->Init(); g_pStudioModel->ModelInit(); g_pStudioModel->ClearLookTargets( ); // Load up the initial model const char *pMdlName = NULL; int nParmCount = CommandLine()->ParmCount(); if ( nParmCount > 1 ) { pMdlName = CommandLine()->GetParm( nParmCount - 1 ); } if ( pMdlName && Q_stristr( pMdlName, ".mdl" ) ) { char absPath[MAX_PATH]; Q_MakeAbsolutePath( absPath, sizeof( absPath ), pMdlName ); if ( CommandLine()->FindParm( "-screenshot" ) ) { g_MDLViewer->SaveScreenShot( absPath ); } else if ( CommandLine()->FindParm( "-dump" ) ) { g_MDLViewer->DumpText( absPath ); } else { g_MDLViewer->LoadModelFile( absPath ); } } int nRetVal = mx::run (); g_pStudioModel->Shutdown(); g_pMaterialSystem->ModShutdown(); return nRetVal; } static bool CHLModelViewerApp_SuggestGameInfoDirFn( CFSSteamSetupInfo const *pFsSteamSetupInfo, char *pchPathBuffer, int nBufferLength, bool *pbBubbleDirectories ) { const char *pMdlName = NULL; int nParmCount = CommandLine()->ParmCount(); if ( nParmCount > 1 ) { pMdlName = CommandLine()->GetParm( nParmCount - 1 ); } if ( pMdlName && Q_stristr( pMdlName, ".mdl" ) ) { Q_MakeAbsolutePath( pchPathBuffer, nBufferLength, pMdlName ); if ( pbBubbleDirectories ) *pbBubbleDirectories = true; return true; } return false; } //----------------------------------------------------------------------------- // Main entry point //----------------------------------------------------------------------------- int main (int argc, char *argv[]) { CommandLine()->CreateCmdLine( argc, argv ); mx::init( argc, argv ); // make sure we start in the right directory char szName[256]; strcpy( szName, mx::getApplicationPath() ); // mx_setcwd (szName); // Set game info directory suggestion callback SetSuggestGameInfoDirFn( CHLModelViewerApp_SuggestGameInfoDirFn ); CHLModelViewerApp hlmodelviewerApp; CSteamApplication steamApplication( &hlmodelviewerApp ); return steamApplication.Run(); } // // Implementation of IPC server // CHlmvIpcServer::~CHlmvIpcServer() { for ( int k = 0; k < m_lstCommands.Count(); ++ k ) { delete [] m_lstCommands[k]; } m_lstCommands.Purge(); } bool CHlmvIpcServer::HasCommands() { AUTO_LOCK( m_mtx ); return m_lstCommands.Count() > 0; } void CHlmvIpcServer::AppendCommand( char *pszCommand ) { AUTO_LOCK( m_mtx ); m_lstCommands.AddToTail( pszCommand ); } char * CHlmvIpcServer::GetCommand() { AUTO_LOCK( m_mtx ); return m_lstCommands.Count() ? m_lstCommands[0] : ""; } void CHlmvIpcServer::PopCommand() { AUTO_LOCK( m_mtx ); if ( m_lstCommands.Count() ) { delete [] m_lstCommands[0]; m_lstCommands.Remove( 0 ); } } BOOL CHlmvIpcServer::ExecuteCommand(CUtlBuffer &cmd, CUtlBuffer &res) { char *szCommand = ( char * ) cmd.Base(); int nLen = strlen( szCommand ); while ( nLen > 0 && V_isspace( szCommand[ nLen - 1 ] ) ) -- nLen; if ( nLen <= 0 ) return FALSE; char *pchCopy = new char[ nLen + 1 ]; memcpy( pchCopy, szCommand, nLen ); pchCopy[ nLen ] = 0; AppendCommand( pchCopy ); res.PutInt( 0 ); return TRUE; }