You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2064 lines
55 KiB
2064 lines
55 KiB
//===== Copyright © 1996-2005, 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: [email protected]
|
|
// web: http://www.swissquake.ch/chumbalum-soft/
|
|
//
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <mxtk/mx.h>
|
|
#include <mxtk/mxTga.h>
|
|
#include <mxtk/mxEvent.h>
|
|
#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/tier3app.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 "tier2/tier2.h"
|
|
#include "tier3/tier3.h"
|
|
#include "p4lib/ip4.h"
|
|
#include "tier2/p4helpers.h"
|
|
#include "datamodel/idatamodel.h"
|
|
#include "dmserializers/idmserializers.h"
|
|
#include "utlvector.h"
|
|
#include "utlbuffer.h"
|
|
#include "valve_ipc_win32.h"
|
|
#include "threadtools.h"
|
|
#include "ConfigManager.h"
|
|
#include "materialsystem/imaterialvar.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
|
|
//-----------------------------------------------------------------------------
|
|
IPhysicsSurfaceProps *physprop;
|
|
IPhysicsCollision *physcollision;
|
|
IFileSystem *g_pFileSystem;
|
|
IStudioDataCache *g_pStudioDataCache;
|
|
ISoundEmitterSystemBase *g_pSoundEmitterBase;
|
|
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;
|
|
};
|
|
|
|
#define NUM_ACCELERATORS 25
|
|
AccelTableEntry_t accelTable[NUM_ACCELERATORS] = { {VK_F5, IDC_FILE_REFRESH, mx::ACCEL_VIRTKEY },
|
|
{VK_UP, IDC_ACCEL_TESSELLATION_INC, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY},
|
|
{VK_DOWN, IDC_ACCEL_TESSELLATION_DEC, 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},
|
|
{'d', IDC_ACCEL_DISPLACEMENT, mx::ACCEL_CONTROL | mx::ACCEL_VIRTKEY},
|
|
{'D', IDC_ACCEL_DISPLACEMENT, 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}};
|
|
|
|
|
|
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 ();
|
|
|
|
menuFile->add( "Recompile", IDC_FILE_RECOMPILE );
|
|
|
|
|
|
menuFile->addSeparator ();
|
|
menuFile->add ("Run .mvscript...", IDC_OPTIONS_RUNMVSCRIPT );
|
|
menuFile->add ("Save session as .mvscript...", IDC_OPTIONS_SAVEMVSCRIPT );
|
|
|
|
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->add ("Secondary Lights", IDC_OPTIONS_SECONDARYLIGHTS );
|
|
menuOptions->addSeparator ();
|
|
menuOptions->add ("Center View", IDC_OPTIONS_CENTERVIEW);
|
|
menuOptions->add ("Center Verts", IDC_OPTIONS_CENTERVERTS);
|
|
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 );
|
|
menuView->add( "Show sequence numbers", IDC_VIEW_SEQUENCE_INDICES );
|
|
menuView->add( "Sort sequences", IDC_VIEW_SORT_SEQUENCES );
|
|
menuView->add ("Show orbit circle", IDC_VIEW_ORBIT_CIRCLE );
|
|
menuView->setChecked( IDC_VIEW_ORBIT_CIRCLE, false );
|
|
menuView->add ("Enable orbit yaw", IDC_VIEW_ORBIT_YAW );
|
|
menuView->setChecked( IDC_VIEW_ORBIT_YAW, false );
|
|
|
|
// Don't show Dota mode in the SDK
|
|
if ( CGameConfigManager::IsSDKDeployment() == false )
|
|
{
|
|
menuView->addSeparator ();
|
|
menuView->add ("DotA View Mode", IDC_VIEW_DOTA);
|
|
}
|
|
|
|
#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_ACCEPTFILES );
|
|
#endif
|
|
|
|
d_cpl = new ControlPanel (this);
|
|
d_cpl->setMatSysWindow (d_MatSysWindow);
|
|
g_MatSysWindow = d_MatSysWindow;
|
|
|
|
g_FileAssociation = new FileAssociation ();
|
|
|
|
loadRecentFiles ();
|
|
initRecentFiles ();
|
|
|
|
LoadViewerRootSettings( );
|
|
|
|
LoadCompileQCPathSettings();
|
|
g_ControlPanel->UpdateQCPathPanel();
|
|
|
|
// 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 );
|
|
|
|
menuView->setChecked( IDC_VIEW_ACTIVITIES, g_viewerSettings.showActivities );
|
|
menuView->setChecked( IDC_VIEW_HIDDEN, g_viewerSettings.showHidden );
|
|
menuView->setChecked( IDC_VIEW_SEQUENCE_INDICES, g_viewerSettings.showSequenceIndices );
|
|
menuView->setChecked( IDC_VIEW_SORT_SEQUENCES, g_viewerSettings.sortSequences );
|
|
|
|
if ( CGameConfigManager::IsSDKDeployment() == false )
|
|
{
|
|
menuView->setChecked( IDC_VIEW_DOTA, g_viewerSettings.dotaMode );
|
|
}
|
|
|
|
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 )
|
|
{
|
|
g_pStudioModel->ReleaseStudioModel( );
|
|
g_pMDLCache->Flush( );
|
|
|
|
delete g_pWidgetControl;
|
|
g_pWidgetControl = NULL;
|
|
|
|
if ( recentFiles[0][0] != '\0' )
|
|
{
|
|
char szFile[MAX_PATH];
|
|
strcpy( szFile, recentFiles[0] );
|
|
g_pMaterialSystem->ReloadMaterials( );
|
|
d_cpl->loadModel( szFile );
|
|
}
|
|
|
|
// Also reload shaders (will only work if dynamic shader compile is enabled)
|
|
static ConVarRef mat_flushshaders_async( "mat_flushshaders_async" );
|
|
mat_flushshaders_async.SetValue( true );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 );
|
|
}
|
|
|
|
// Init the dota view if we have that checked
|
|
if ( g_viewerSettings.dotaMode )
|
|
d_cpl->dotaView();
|
|
|
|
|
|
d_cpl->UpdateSubmodelWindow();
|
|
|
|
}
|
|
|
|
static ConVar mat_tessellationlevel( "mat_tessellationlevel", "12", FCVAR_CHEAT );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Opens a script file and runs commands in sequence. Useful for batching automatic screenshots, etc
|
|
// Input : p_szScriptPath - script to parse and execute.
|
|
//-----------------------------------------------------------------------------
|
|
void MDLViewer::ExecuteMVScript( const char* p_szScriptPath )
|
|
{
|
|
KeyValues *pMvScriptKeyValues = new KeyValues("ModelViewerScript");
|
|
KeyValues::AutoDelete autodelete_pMvScriptKeyValues(pMvScriptKeyValues);
|
|
|
|
if (pMvScriptKeyValues->LoadFromFile(g_pFullFileSystem, p_szScriptPath))
|
|
{
|
|
Msg("Executing mvscript: %s\n", p_szScriptPath);
|
|
|
|
for (KeyValues *kvSub = pMvScriptKeyValues->GetFirstSubKey(); kvSub; kvSub = kvSub->GetNextKey())
|
|
{
|
|
|
|
// parse and execute each command in order
|
|
|
|
if (!Q_stricmp(kvSub->GetName(), "LoadModel"))
|
|
{
|
|
|
|
char const *szVal = kvSub->GetString();
|
|
Msg("mvscript command: LoadModel %s\n", szVal);
|
|
|
|
if ( Q_stristr( szVal, "models" ) )
|
|
szVal = Q_stristr( szVal, "models" );
|
|
|
|
g_MDLViewer->LoadModelFile(szVal);
|
|
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "SetAppWindowSize"))
|
|
{
|
|
|
|
char const *szVal = kvSub->GetString();
|
|
Msg("mvscript command: SetAppWindowSize %s\n", szVal);
|
|
|
|
int nWidth = g_viewerSettings.width;
|
|
int nHeight = g_viewerSettings.height;
|
|
sscanf(szVal, "%i %i", &nWidth, &nHeight);
|
|
|
|
g_MDLViewer->setBounds(g_viewerSettings.xpos, g_viewerSettings.ypos, max(128, nWidth), max(128, nHeight));
|
|
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "SetCameraOrigin"))
|
|
{
|
|
|
|
char const *szVal = kvSub->GetString();
|
|
Msg("mvscript command: SetCameraOrigin %s\n", szVal);
|
|
|
|
float flX = 0.0f;
|
|
float flY = 0.0f;
|
|
float flZ = 0.0f;
|
|
sscanf(szVal, "%f %f %f", &flX, &flY, &flZ);
|
|
|
|
d_cpl->setCameraOrigin(flX, flY, flZ);
|
|
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "SetCameraAngles"))
|
|
{
|
|
|
|
char const *szVal = kvSub->GetString();
|
|
Msg("mvscript command: SetCameraAngles %s\n", szVal);
|
|
|
|
float flX = 0.0f;
|
|
float flY = 0.0f;
|
|
float flZ = 0.0f;
|
|
sscanf(szVal, "%f %f %f", &flX, &flY, &flZ);
|
|
|
|
d_cpl->setCameraAngles(flX, flY, flZ);
|
|
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "SetLightAngles"))
|
|
{
|
|
|
|
char const *szVal = kvSub->GetString();
|
|
Msg("mvscript command: SetLightAngles %s\n", szVal);
|
|
|
|
float flX = 0.0f;
|
|
float flY = 0.0f;
|
|
float flZ = 0.0f;
|
|
sscanf(szVal, "%f %f %f", &flX, &flY, &flZ);
|
|
|
|
d_cpl->setLightAngles(flX, flY, flZ);
|
|
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "SetBGColor"))
|
|
{
|
|
|
|
char const *szVal = kvSub->GetString();
|
|
Msg("mvscript command: SetBGColor %s\n", szVal);
|
|
|
|
float flR = 63.0f;
|
|
float flG = 63.0f;
|
|
float flB = 63.0f;
|
|
sscanf(szVal, "%f %f %f", &flR, &flG, &flB);
|
|
|
|
g_viewerSettings.bgColor[0] = flR / 255.0f;
|
|
g_viewerSettings.bgColor[1] = flG / 255.0f;
|
|
g_viewerSettings.bgColor[2] = flB / 255.0f;
|
|
|
|
d_cpl->redrawMatSysWin();
|
|
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "SetLightColor"))
|
|
{
|
|
|
|
char const *szVal = kvSub->GetString();
|
|
Msg("mvscript command: SetLightColor %s\n", szVal);
|
|
|
|
float flR = 63.0f;
|
|
float flG = 63.0f;
|
|
float flB = 63.0f;
|
|
sscanf(szVal, "%f %f %f", &flR, &flG, &flB);
|
|
|
|
g_viewerSettings.lColor[0] = flR / 255.0f;
|
|
g_viewerSettings.lColor[1] = flG / 255.0f;
|
|
g_viewerSettings.lColor[2] = flB / 255.0f;
|
|
|
|
d_cpl->redrawMatSysWin();
|
|
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "SetAmbientColor"))
|
|
{
|
|
|
|
char const *szVal = kvSub->GetString();
|
|
Msg("mvscript command: SetAmbientColor %s\n", szVal);
|
|
|
|
float flR = 63.0f;
|
|
float flG = 63.0f;
|
|
float flB = 63.0f;
|
|
sscanf(szVal, "%f %f %f", &flR, &flG, &flB);
|
|
|
|
g_viewerSettings.aColor[0] = flR / 255.0f;
|
|
g_viewerSettings.aColor[1] = flG / 255.0f;
|
|
g_viewerSettings.aColor[2] = flB / 255.0f;
|
|
|
|
d_cpl->redrawMatSysWin();
|
|
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "Screenshot"))
|
|
{
|
|
|
|
char const *szVal = kvSub->GetString();
|
|
Msg("mvscript command: Screenshot %s\n", szVal);
|
|
d_MatSysWindow->dumpViewport( szVal );
|
|
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "SetMatVars"))
|
|
{
|
|
for (KeyValues *kvSubMatParamChanges = kvSub->GetFirstSubKey(); kvSubMatParamChanges; kvSubMatParamChanges = kvSubMatParamChanges->GetNextKey())
|
|
{
|
|
char const *szParam = kvSubMatParamChanges->GetName();
|
|
char const *szVal = kvSubMatParamChanges->GetString();
|
|
|
|
Msg("mvscript command: SetMatVar %s to %s\n", szParam, szVal);
|
|
|
|
d_cpl->setMaterialVar( szParam, szVal );
|
|
}
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "RunExternalCmd"))
|
|
{
|
|
|
|
char const *szVal = kvSub->GetString();
|
|
Msg("mvscript command: RunExternalCmd %s\n", szVal);
|
|
|
|
char absPath[MAX_PATH];
|
|
Q_MakeAbsolutePath(absPath, sizeof(absPath), szVal);
|
|
|
|
system( absPath );
|
|
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "LoadMergeModel"))
|
|
{
|
|
|
|
char const *szVal = kvSub->GetString();
|
|
Msg("mvscript command: LoadMergeModel %s\n", szVal);
|
|
|
|
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], szVal);
|
|
LoadModelFile(szVal, iChosenSlot);
|
|
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "ReplaceMaterials"))
|
|
{
|
|
|
|
studiohdr_t* pStudioR = g_pStudioModel->GetStudioRenderHdr();
|
|
if (!pStudioR)
|
|
continue;
|
|
|
|
for (KeyValues *kvSubReplaceMats = kvSub->GetFirstSubKey(); kvSubReplaceMats; kvSubReplaceMats = kvSubReplaceMats->GetNextKey())
|
|
{
|
|
char const *szParam = kvSubReplaceMats->GetName();
|
|
char const *szVal = kvSubReplaceMats->GetString();
|
|
|
|
if ( Q_stristr( szVal, "materials" ) )
|
|
szVal = Q_stristr( szVal, "materials" );
|
|
|
|
IMaterial *pMaterials[128];
|
|
int nNumMaterials = g_pStudioRender->GetMaterialList(pStudioR, ARRAYSIZE(pMaterials), &pMaterials[0]);
|
|
|
|
for ( int i=0; i<nNumMaterials; i++ )
|
|
{
|
|
IMaterial *pSelectedMaterial = pMaterials[i];
|
|
|
|
if ( pSelectedMaterial->IsErrorMaterial() )
|
|
continue;
|
|
|
|
Msg("Material name: %s\n", V_GetFileName(pSelectedMaterial->GetName()));
|
|
|
|
if ( !Q_stricmp( V_GetFileName(pSelectedMaterial->GetName()), szParam ) )
|
|
{
|
|
|
|
Msg("mvscript command: ReplaceMaterial %s to %s\n", szParam, szVal);
|
|
|
|
KeyValues *kvLoadedFromFile = new KeyValues(pSelectedMaterial->GetShaderName());
|
|
|
|
if (kvLoadedFromFile->LoadFromFile(g_pFullFileSystem, szVal))
|
|
{
|
|
KeyValues *kv = new KeyValues(pSelectedMaterial->GetShaderName());
|
|
IMaterialVar **pMatVars = pSelectedMaterial->GetShaderParams();
|
|
for (int n = 0; n < pSelectedMaterial->ShaderParamCount(); n++)
|
|
{
|
|
IMaterialVar *pThisVar = pMatVars[n];
|
|
if (pThisVar->IsDefined())
|
|
kv->SetString(pThisVar->GetName(), pThisVar->GetStringValue());
|
|
}
|
|
|
|
kv->MergeFrom(kvLoadedFromFile, KeyValues::MERGE_KV_UPDATE);
|
|
|
|
pSelectedMaterial->SetShaderAndParams(kv);
|
|
pSelectedMaterial->Refresh();
|
|
|
|
if (kv)
|
|
delete kv;
|
|
}
|
|
|
|
if (kvLoadedFromFile)
|
|
delete kvLoadedFromFile;
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "NormalMapping"))
|
|
{
|
|
g_viewerSettings.enableNormalMapping = kvSub->GetBool();
|
|
Msg("mvscript command: NormalMapping %s\n", g_viewerSettings.enableNormalMapping ? "enabled" : "disabled" );
|
|
}
|
|
else if (!Q_stricmp(kvSub->GetName(), "Close"))
|
|
{
|
|
Msg("mvscript command: Quit\n");
|
|
redraw();
|
|
mx::quit();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
autodelete_pMvScriptKeyValues.Detach();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 )
|
|
{
|
|
|
|
//unload all merged models
|
|
for (int i=0; i<HLMV_MAX_MERGED_MODELS; i++)
|
|
{
|
|
if (g_pStudioExtraModel[i])
|
|
{
|
|
strcpy( g_viewerSettings.mergeModelFile[i], "" );
|
|
g_pStudioExtraModel[i]->FreeModel( false );
|
|
delete g_pStudioExtraModel[i];
|
|
g_pStudioExtraModel[i] = NULL;
|
|
}
|
|
}
|
|
|
|
g_viewerSettings.bgColor[0] = 0.2353f; //117.0f / 255.0f;
|
|
g_viewerSettings.bgColor[1] = 0.2353f; //196.0f / 255.0f;
|
|
g_viewerSettings.bgColor[2] = 0.2353f; //219.0f / 255.0f;
|
|
|
|
// Build the name of the TGA to write.
|
|
char szScreenShot[1024];
|
|
V_ExtractFilePath( filename, szScreenShot, sizeof(szScreenShot) );
|
|
strcat(szScreenShot, "screenshots\\" );
|
|
|
|
if ( CreateDirectory(szScreenShot, NULL) || ERROR_ALREADY_EXISTS == GetLastError() )
|
|
{
|
|
strcat(szScreenShot, V_GetFileName(filename) );
|
|
char *pchDot = strrchr(szScreenShot, '.');
|
|
if (pchDot)
|
|
{
|
|
strcpy(pchDot, ".bmp");
|
|
}
|
|
else
|
|
{
|
|
strcat(szScreenShot, ".bmp");
|
|
}
|
|
|
|
d_cpl->setSequence( 0 );
|
|
g_pStudioModel->ClearAnimationLayers();
|
|
d_cpl->centerView();
|
|
|
|
d_cpl->cs_gunsidemodelView();
|
|
d_cpl->cs_gunsidemodelView();
|
|
|
|
bool bFoundPaintNameParam = false;
|
|
bool bFoundPaintStyleParam = false;
|
|
char szPaintName[256];
|
|
|
|
studiohdr_t* pStudioR = g_pStudioModel->GetStudioRenderHdr();
|
|
if ( pStudioR )
|
|
{
|
|
IMaterial *pMaterials[128];
|
|
int nMaterials = g_pStudioRender->GetMaterialList( pStudioR, ARRAYSIZE( pMaterials ), &pMaterials[0] );
|
|
|
|
for ( int i=0; i<nMaterials; i++ )
|
|
{
|
|
if ( !pMaterials[i]->IsErrorMaterial() )
|
|
{
|
|
|
|
IMaterialVar *pThisVar = pMaterials[i]->FindVar( "$paintname", &bFoundPaintNameParam, false );
|
|
|
|
if (bFoundPaintNameParam)
|
|
{
|
|
V_strcpy( szPaintName, pThisVar->GetStringValue() );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
pMaterials[i]->FindVar( "$paintstyle", &bFoundPaintStyleParam, false );
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( bFoundPaintNameParam )
|
|
{
|
|
//create a version of the paint name with underscores
|
|
char szPaintNameWithUnderscores[256];
|
|
V_StrSubst( szPaintName, " ", "_", szPaintNameWithUnderscores, sizeof(szPaintNameWithUnderscores) );
|
|
strcat(szPaintNameWithUnderscores, ".bmp");
|
|
|
|
//update the output path
|
|
char szNewOputputPath[1024];
|
|
V_StrSubst( szScreenShot, ".bmp", szPaintNameWithUnderscores, szNewOputputPath, sizeof(szNewOputputPath) );
|
|
|
|
d_MatSysWindow->dumpViewportWithLabel( szNewOputputPath, szPaintName );
|
|
}
|
|
else
|
|
{
|
|
if (bFoundPaintStyleParam)
|
|
mxMessageBox (this, "WARNING: Paint has no $paintname set, can't stamp unknown paint name on screenshot.", g_appTitle, MX_MB_ERROR | MX_MB_OK);
|
|
else
|
|
d_MatSysWindow->dumpViewport( szScreenShot );
|
|
}
|
|
|
|
}
|
|
|
|
// Shut down.
|
|
mx::quit();
|
|
}
|
|
else
|
|
{
|
|
mxMessageBox (this, "Error loading model for commandline screenshot.", g_appTitle, MX_MB_ERROR | MX_MB_OK);
|
|
}
|
|
|
|
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:
|
|
{
|
|
|
|
Msg("%2.2f %2.2f %2.2f\n", g_pStudioModel->m_angles[0], g_pStudioModel->m_angles[1], g_pStudioModel->m_angles[2]);
|
|
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_REFRESH:
|
|
{
|
|
Refresh();
|
|
break;
|
|
}
|
|
|
|
case IDC_FILE_RECOMPILE:
|
|
{
|
|
//g_pStudioModel->Key
|
|
CStudioHdr *pStudioHdr = g_pStudioModel->GetStudioHdr();
|
|
if ( pStudioHdr )
|
|
{
|
|
studiohdr_t* pStudioR = g_pStudioModel->GetStudioRenderHdr();
|
|
|
|
KeyValues *tempKeyValues = new KeyValues("qc_path");
|
|
if ( tempKeyValues->LoadFromBuffer( NULL, pStudioR->KeyValueText() ) )
|
|
{
|
|
KeyValues *qc_path = tempKeyValues->FindKey( "qc_path", false );
|
|
if (qc_path)
|
|
{
|
|
char szQCPath[1024];
|
|
V_sprintf_safe( szQCPath, "%s\\%s\\%s", getenv("VCONTENT"), getenv("VMOD"), qc_path->GetFirstValue()->GetString() );
|
|
g_ControlPanel->AddQCRecordPath( szQCPath, true );
|
|
|
|
}
|
|
else
|
|
{
|
|
mxMessageBox (this, "MDL has no qc_path defined, and needs to be compiled once manually to learn where its QC is. Then HLMV will be able to recompile it from that point on.", g_appTitle, MX_MB_OK | MX_MB_ERROR);
|
|
}
|
|
}
|
|
}
|
|
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_SECONDARYLIGHTS:
|
|
g_viewerSettings.secondaryLights = !g_viewerSettings.secondaryLights;
|
|
menuOptions->setChecked( IDC_OPTIONS_SECONDARYLIGHTS, g_viewerSettings.secondaryLights );
|
|
break;
|
|
|
|
case IDC_OPTIONS_CENTERVIEW:
|
|
if ( g_viewerSettings.dotaMode )
|
|
break;
|
|
|
|
d_cpl->centerView ();
|
|
if ( g_bHlmvMaster )
|
|
{
|
|
SendModelTransformToLinkedHlmv();
|
|
}
|
|
break;
|
|
case IDC_OPTIONS_CENTERVERTS:
|
|
if ( g_viewerSettings.dotaMode )
|
|
break;
|
|
|
|
d_cpl->centerVerts( );
|
|
if ( g_bHlmvMaster )
|
|
{
|
|
SendModelTransformToLinkedHlmv();
|
|
}
|
|
break;
|
|
case IDC_OPTIONS_VIEWMODEL:
|
|
{
|
|
if ( g_viewerSettings.dotaMode )
|
|
break;
|
|
|
|
d_cpl->viewmodelView();
|
|
if ( g_bHlmvMaster )
|
|
{
|
|
SendModelTransformToLinkedHlmv();
|
|
}
|
|
}
|
|
break;
|
|
case IDC_VIEW_DOTA:
|
|
{
|
|
g_viewerSettings.dotaMode = !g_viewerSettings.dotaMode;
|
|
menuView->setChecked( IDC_VIEW_DOTA, g_viewerSettings.dotaMode );
|
|
|
|
if ( g_viewerSettings.dotaMode )
|
|
{
|
|
d_cpl->dotaView();
|
|
}
|
|
|
|
if ( g_bHlmvMaster )
|
|
{
|
|
SendModelTransformToLinkedHlmv();
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_OPTIONS_MAKESCREENSHOT:
|
|
{
|
|
char *ptr = (char *) mxGetSaveFileName (this, "", "*.bmp");
|
|
if (ptr)
|
|
{
|
|
if (!strstr (ptr, ".bmp"))
|
|
strcat (ptr, ".bmp");
|
|
d_MatSysWindow->dumpViewport (ptr);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_OPTIONS_RUNMVSCRIPT:
|
|
{
|
|
char *ptr = (char *)mxGetOpenFileName(this, "", "*.mvscript");
|
|
if (ptr)
|
|
{
|
|
if (!strstr(ptr, ".mvscript"))
|
|
strcat(ptr, ".mvscript");
|
|
g_MDLViewer->ExecuteMVScript(ptr);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_OPTIONS_SAVEMVSCRIPT:
|
|
{
|
|
if ( !g_pStudioModel->GetStudioRenderHdr() )
|
|
{
|
|
mxMessageBox (this, "No model loaded!", g_appTitle, MX_MB_OK | MX_MB_ERROR);
|
|
break;
|
|
}
|
|
|
|
//save a mvscript with the current model, camera orientation and light positions
|
|
char *ptr = (char *)mxGetSaveFileName(this, "", "*.mvscript");
|
|
if (ptr)
|
|
{
|
|
if (!strstr(ptr, ".mvscript"))
|
|
strcat(ptr, ".mvscript");
|
|
|
|
KeyValues *kv = new KeyValues( "ModelViewerScript" );
|
|
|
|
const char *szModelPath = g_pStudioModel->GetFileName();
|
|
if ( Q_stristr( szModelPath, "models" ) )
|
|
szModelPath = Q_stristr( szModelPath, "models" );
|
|
|
|
kv->SetString( "LoadModel", szModelPath );
|
|
|
|
char szTemp[64];
|
|
V_snprintf( szTemp, 64, "%i %i", g_viewerSettings.width, g_viewerSettings.height );
|
|
kv->SetString( "SetAppWindowSize", szTemp );
|
|
|
|
V_snprintf( szTemp, 64, "%f %f %f", g_pStudioModel->m_origin[0], g_pStudioModel->m_origin[1], g_pStudioModel->m_origin[2] );
|
|
kv->SetString( "SetCameraOrigin", szTemp );
|
|
|
|
V_snprintf(szTemp, 64, "%f %f %f", g_pStudioModel->m_angles[0], g_pStudioModel->m_angles[1], g_pStudioModel->m_angles[2]);
|
|
kv->SetString("SetCameraAngles", szTemp);
|
|
|
|
V_snprintf(szTemp, 64, "%f %f %f", g_viewerSettings.lightrot[YAW], g_viewerSettings.lightrot[PITCH], g_viewerSettings.lightrot[ROLL]);
|
|
kv->SetString("SetLightAngles", szTemp);
|
|
|
|
if ( !kv->SaveToFile( g_pFullFileSystem, ptr ) )
|
|
{
|
|
mxMessageBox (this, "Error saving script file.", g_appTitle, MX_MB_OK | MX_MB_ERROR);
|
|
}
|
|
|
|
if ( kv )
|
|
delete kv;
|
|
}
|
|
}
|
|
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();
|
|
|
|
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:
|
|
d_cpl->SaveSelectedSequences();
|
|
g_viewerSettings.showActivities = !g_viewerSettings.showActivities;
|
|
menuView->setChecked( event->action, g_viewerSettings.showActivities );
|
|
d_cpl->initSequenceChoices();
|
|
d_cpl->resetControlPanel();
|
|
d_cpl->RestoreSelectedSequences();
|
|
break;
|
|
|
|
case IDC_VIEW_HIDDEN:
|
|
d_cpl->SaveSelectedSequences();
|
|
g_viewerSettings.showHidden = !g_viewerSettings.showHidden;
|
|
menuView->setChecked( event->action, g_viewerSettings.showHidden );
|
|
d_cpl->initSequenceChoices();
|
|
d_cpl->resetControlPanel();
|
|
d_cpl->RestoreSelectedSequences();
|
|
break;
|
|
|
|
case IDC_VIEW_SEQUENCE_INDICES:
|
|
d_cpl->SaveSelectedSequences();
|
|
g_viewerSettings.showSequenceIndices = !g_viewerSettings.showSequenceIndices;
|
|
menuView->setChecked( event->action, g_viewerSettings.showSequenceIndices );
|
|
d_cpl->initSequenceChoices();
|
|
d_cpl->resetControlPanel();
|
|
d_cpl->RestoreSelectedSequences();
|
|
break;
|
|
|
|
case IDC_VIEW_SORT_SEQUENCES:
|
|
d_cpl->SaveSelectedSequences();
|
|
g_viewerSettings.sortSequences = !g_viewerSettings.sortSequences;
|
|
menuView->setChecked( event->action, g_viewerSettings.sortSequences );
|
|
d_cpl->initSequenceChoices();
|
|
d_cpl->resetControlPanel();
|
|
d_cpl->RestoreSelectedSequences();
|
|
break;
|
|
|
|
case IDC_VIEW_ORBIT_CIRCLE:
|
|
g_viewerSettings.showOrbitCircle = !g_viewerSettings.showOrbitCircle;
|
|
menuView->setChecked( event->action, g_viewerSettings.showOrbitCircle );
|
|
break;
|
|
|
|
case IDC_VIEW_ORBIT_YAW:
|
|
g_viewerSettings.allowOrbitYaw = !g_viewerSettings.allowOrbitYaw;
|
|
menuView->setChecked( event->action, g_viewerSettings.allowOrbitYaw );
|
|
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:\t[email protected]\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_DISPLACEMENT:
|
|
d_cpl->setDisplacementMapping( !g_viewerSettings.enableDisplacementMapping );
|
|
break;
|
|
|
|
case IDC_ACCEL_TESSELLATION_INC:
|
|
mat_tessellationlevel.SetValue( mat_tessellationlevel.GetInt() + 1 );
|
|
break;
|
|
|
|
case IDC_ACCEL_TESSELLATION_DEC:
|
|
mat_tessellationlevel.SetValue( mat_tessellationlevel.GetInt() - 1 );
|
|
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 );
|
|
}
|
|
}
|
|
|
|
g_ControlPanel->CompileTimerUpdate();
|
|
|
|
g_ControlPanel->UpdateBoneWeightInspect();
|
|
}
|
|
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, "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_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();
|
|
}
|
|
}
|
|
|
|
|
|
static CSimpleWindowsLoggingListener s_SimpleWindowsLoggingListener;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The application object
|
|
//-----------------------------------------------------------------------------
|
|
class CHLModelViewerApp : public CTier3DmSteamApp
|
|
{
|
|
typedef CTier3DmSteamApp BaseClass;
|
|
|
|
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()
|
|
{
|
|
LoggingSystem_PushLoggingState();
|
|
LoggingSystem_RegisterLoggingListener( &s_SimpleWindowsLoggingListener );
|
|
|
|
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;
|
|
|
|
AddSystem( g_pDataModel, VDATAMODEL_INTERFACE_VERSION );
|
|
AddSystem( g_pDmSerializers, DMSERIALIZERS_INTERFACE_VERSION );
|
|
|
|
// Add the P4 module separately so that if it is absent
|
|
// (say in the SDK) then the other system will initialize properly
|
|
if ( CGameConfigManager::IsSDKDeployment() == false )
|
|
{
|
|
AppModule_t p4Module = LoadModule( "p4lib.dll" );
|
|
AddSystem( p4Module, P4_INTERFACE_VERSION );
|
|
}
|
|
|
|
g_pFileSystem = (IFileSystem*)FindSystem( FILESYSTEM_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 );
|
|
|
|
IMaterialSystem *pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION );
|
|
if ( !pMaterialSystem )
|
|
{
|
|
Error( "Unable to connect to necessary interface!\n" );
|
|
return false;
|
|
}
|
|
|
|
const char *pShaderDLL = CommandLine()->ParmValue("-shaderdll");
|
|
const char *pArg;
|
|
if ( CommandLine()->CheckParm( "-shaderapi", &pArg ))
|
|
{
|
|
pShaderDLL = pArg;
|
|
}
|
|
|
|
if(!pShaderDLL)
|
|
{
|
|
pShaderDLL = "shaderapidx9.dll";
|
|
}
|
|
|
|
pMaterialSystem->SetShaderAPI( pShaderDLL );
|
|
|
|
g_Factory = GetFactory();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void CHLModelViewerApp::Destroy()
|
|
{
|
|
LoggingSystem_PopLoggingState();
|
|
g_pFileSystem = NULL;
|
|
g_pStudioDataCache = NULL;
|
|
physcollision = NULL;
|
|
physprop = NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Init, shutdown
|
|
//-----------------------------------------------------------------------------
|
|
bool CHLModelViewerApp::PreInit( )
|
|
{
|
|
if ( !BaseClass::PreInit() )
|
|
return false;
|
|
|
|
if ( !g_pFileSystem || !physprop || !physcollision || !g_pMaterialSystem ||
|
|
!g_pStudioRender || !g_pMDLCache || !g_pDataCache )
|
|
{
|
|
Error("Unable to load required library interface!\n");
|
|
}
|
|
|
|
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 ( !CGameConfigManager::IsSDKDeployment() || CommandLine()->FindParm( "-OldDialogs" ) )
|
|
{
|
|
g_bOldFileDialogs = true;
|
|
}
|
|
|
|
LoadFileSystemDialogModule();
|
|
|
|
return true;
|
|
}
|
|
|
|
void CHLModelViewerApp::PostShutdown()
|
|
{
|
|
UnloadFileSystemDialogModule();
|
|
|
|
BaseClass::PostShutdown();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// main application
|
|
//-----------------------------------------------------------------------------
|
|
int CHLModelViewerApp::Main()
|
|
{
|
|
g_pMaterialSystem->ModInit();
|
|
|
|
g_pDataCache->SetSize( 64 * 1024 * 1024 );
|
|
|
|
// No p4 mode if specified on the command line or no p4lib.dll found
|
|
const bool bP4DLLExists = g_pFullFileSystem->FileExists( "p4lib.dll", "EXECUTABLE_PATH" );
|
|
if ( ( CommandLine()->FindParm( "-nop4" ) ) || ( !bP4DLLExists ) || CGameConfigManager::IsSDKDeployment() )
|
|
{
|
|
g_p4factory->SetDummyMode( true );
|
|
}
|
|
|
|
// Set the named changelist
|
|
g_p4factory->SetOpenFileChangeList( "HLMV Auto Checkout" );
|
|
|
|
//mx::setDisplayMode (0, 0, 0);
|
|
g_MDLViewer = new MDLViewer();
|
|
g_MDLViewer->setMenuBar (g_MDLViewer->getMenuBar ());
|
|
|
|
g_pStudioModel->Init();
|
|
g_pStudioModel->ModelInit();
|
|
g_pStudioModel->ClearLookTargets( );
|
|
g_pDataModel->SetUndoEnabled( false );
|
|
|
|
// 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 );
|
|
}
|
|
}
|
|
|
|
if ( pMdlName && Q_stristr( pMdlName, ".mvscript" ) )
|
|
{
|
|
char absPath[MAX_PATH];
|
|
Q_MakeAbsolutePath(absPath, sizeof(absPath), pMdlName);
|
|
|
|
#ifdef DEBUG
|
|
Q_StripExtension( absPath, absPath, sizeof(absPath) );
|
|
Q_strcat(absPath, ".mvscript", sizeof(absPath) );
|
|
//mxMessageBox (NULL, absPath, g_appTitle, MX_MB_OK | MX_MB_ERROR);
|
|
#endif
|
|
g_MDLViewer->ExecuteMVScript(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_FM( m_mtx );
|
|
return m_lstCommands.Count() > 0;
|
|
}
|
|
|
|
void CHlmvIpcServer::AppendCommand( char *pszCommand )
|
|
{
|
|
AUTO_LOCK_FM( m_mtx );
|
|
m_lstCommands.AddToTail( pszCommand );
|
|
}
|
|
|
|
char * CHlmvIpcServer::GetCommand()
|
|
{
|
|
AUTO_LOCK_FM( m_mtx );
|
|
return m_lstCommands.Count() ? m_lstCommands[0] : "";
|
|
}
|
|
|
|
void CHlmvIpcServer::PopCommand()
|
|
{
|
|
AUTO_LOCK_FM( 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;
|
|
}
|
|
|