mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-23 06:36:54 +00:00
2753 lines
64 KiB
C++
2753 lines
64 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
//
|
||
// Purpose:
|
||
//
|
||
//===========================================================================//
|
||
#include "cbase.h"
|
||
#include <direct.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <errno.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 "FlexPanel.h"
|
||
#include "StudioModel.h"
|
||
#include "mxExpressionTray.h"
|
||
#include "mxStatusWindow.h"
|
||
#include "ChoreoView.h"
|
||
#include "ifaceposersound.h"
|
||
#include "ifaceposerworkspace.h"
|
||
#include "expclass.h"
|
||
#include "PhonemeEditor.h"
|
||
#include "filesystem.h"
|
||
#include "ExpressionTool.h"
|
||
#include "ControlPanel.h"
|
||
#include "choreowidgetdrawhelper.h"
|
||
#include "choreoviewcolors.h"
|
||
#include "tabwindow.h"
|
||
#include "faceposer_models.h"
|
||
#include "choiceproperties.h"
|
||
#include "choreoscene.h"
|
||
#include "choreoactor.h"
|
||
#include "tier1/strtools.h"
|
||
#include "InputProperties.h"
|
||
#include "GestureTool.h"
|
||
#include "SoundEmitterSystem/isoundemittersystembase.h"
|
||
#include "inputsystem/iinputsystem.h"
|
||
#include "RampTool.h"
|
||
#include "SceneRampTool.h"
|
||
#include "tier0/icommandline.h"
|
||
#include "phonemeextractor/PhonemeExtractor.h"
|
||
#include "animationbrowser.h"
|
||
#include "CloseCaptionTool.h"
|
||
#include "wavebrowser.h"
|
||
#include "vcdbrowser.h"
|
||
#include "ifilesystemopendialog.h"
|
||
#include <vgui/ILocalize.h>
|
||
#include <vgui/IVGui.h>
|
||
#include "appframework/appframework.h"
|
||
#include "icvar.h"
|
||
#include "vstdlib/cvar.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 "tier1/strtools.h"
|
||
#include "appframework/tier3app.h"
|
||
#include "faceposer_vgui.h"
|
||
#include "vguiwnd.h"
|
||
#include "vgui_controls/Frame.h"
|
||
#include "vgui/ISurface.h"
|
||
#include "p4lib/ip4.h"
|
||
#include "tier2/p4helpers.h"
|
||
#include "ProgressDialog.h"
|
||
#include "scriplib.h"
|
||
|
||
#define WINDOW_TAB_OFFSET 24
|
||
|
||
MDLViewer *g_MDLViewer = 0;
|
||
char g_appTitle[] = "Half-Life Face Poser";
|
||
static char recentFiles[8][256] = { "", "", "", "", "", "", "", "" };
|
||
|
||
using namespace vgui;
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Singleton interfaces
|
||
//-----------------------------------------------------------------------------
|
||
IPhysicsSurfaceProps *physprop;
|
||
IPhysicsCollision *physcollision;
|
||
IStudioDataCache *g_pStudioDataCache;
|
||
vgui::ILocalize *g_pLocalize = NULL;
|
||
ISoundEmitterSystemBase *soundemitter = NULL;
|
||
CreateInterfaceFn g_Factory;
|
||
IFileSystem *g_pFileSystem = NULL;
|
||
|
||
bool g_bInError = false;
|
||
|
||
static char gamedir[MAX_PATH]; // full path to gamedir U:\main\game\ep2
|
||
static char gamedirsimple[MAX_PATH]; // just short name: ep2
|
||
|
||
// Filesystem dialog module wrappers.
|
||
CSysModule *g_pFSDialogModule = 0;
|
||
CreateInterfaceFn g_FSDialogFactory = 0;
|
||
|
||
#include "vgui_controls/TextEntry.h"
|
||
#include "vgui_controls/Button.h"
|
||
#include "vgui_controls/Label.h"
|
||
#include "vgui_controls/ComboBox.h"
|
||
#include "tier1/fmtstr.h"
|
||
|
||
class CFacePoserVguiFrame : public Frame
|
||
{
|
||
DECLARE_CLASS_SIMPLE( CFacePoserVguiFrame, Frame );
|
||
|
||
public:
|
||
CFacePoserVguiFrame( Panel *parent, const char *panelName ) :
|
||
BaseClass( parent, panelName )
|
||
{
|
||
SetTitle( panelName, true );
|
||
|
||
SetTitleBarVisible( false );
|
||
|
||
SetSizeable( false );
|
||
SetMoveable( false );
|
||
|
||
SetPaintBackgroundEnabled( true );
|
||
SetCloseButtonVisible( false );
|
||
m_pEntry = new TextEntry( this, "textentry" );
|
||
m_pEntry->AddActionSignalTarget( this );
|
||
m_pButton = new Button( this, "button", "Button1", this );
|
||
m_pButton->SetCommand( new KeyValues( "OnButtonPressed" ) );
|
||
m_pLabel = new Label( this, "label", "..." );
|
||
|
||
m_pCombo = new ComboBox( this, "combo", 5, true );
|
||
for ( int i = 0; i < 10; ++i )
|
||
{
|
||
m_pCombo->AddItem( CFmtStr( "item%02d", i + 1 ), NULL );
|
||
}
|
||
}
|
||
|
||
MESSAGE_FUNC( OnButtonPressed, "OnButtonPressed" )
|
||
{
|
||
Msg( "OnButtonPressed\n" );
|
||
}
|
||
|
||
MESSAGE_FUNC_PARAMS( OnTextChanged, "TextChanged", str )
|
||
{
|
||
char sz[ 256 ];
|
||
m_pEntry->GetText( sz, sizeof( sz ) );
|
||
m_pLabel->SetText( sz );
|
||
|
||
m_pCombo->GetText( sz, sizeof( sz ) );
|
||
Msg( "Combo %s\n", sz );
|
||
}
|
||
|
||
virtual void PerformLayout()
|
||
{
|
||
BaseClass::PerformLayout();
|
||
|
||
int w, h;
|
||
GetSize( w, h );
|
||
|
||
int y = 30;
|
||
int skip = 20;
|
||
m_pEntry->SetBounds( 5, y, w, skip - 2 );
|
||
y += skip;
|
||
m_pButton->SetBounds( 5, y, w, skip - 2 );
|
||
y += skip;
|
||
m_pCombo->SetBounds( 5, y, w, skip - 2 );
|
||
y += skip;
|
||
m_pLabel->SetBounds( 5, y, w, skip - 2 );
|
||
y += skip;
|
||
|
||
}
|
||
|
||
private:
|
||
|
||
TextEntry *m_pEntry;
|
||
Button *m_pButton;
|
||
Label *m_pLabel;
|
||
ComboBox *m_pCombo;
|
||
};
|
||
|
||
class TestWindow : public CVGuiPanelWnd, public IFacePoserToolWindow
|
||
{
|
||
typedef CVGuiPanelWnd BaseClass;
|
||
|
||
public:
|
||
|
||
TestWindow( mxWindow *parent, int x, int y, int w, int h) :
|
||
BaseClass(parent, x, y, w, h ),
|
||
IFacePoserToolWindow( "FacePoser Frame", "FacePoser Frame" )
|
||
{
|
||
CFacePoserVguiFrame *f = new CFacePoserVguiFrame( NULL, "FacePoser Frame" );
|
||
|
||
SetParentWindow( this );
|
||
SetMainPanel( f );
|
||
f->SetVisible( true );
|
||
f->SetPaintBackgroundEnabled( true );
|
||
|
||
FacePoser_MakeToolWindow( this, true );
|
||
}
|
||
|
||
virtual int handleEvent( mxEvent *event )
|
||
{
|
||
if ( HandleToolEvent( event ) )
|
||
return 1;
|
||
return BaseClass::handleEvent( event );
|
||
}
|
||
};
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// FIXME: Remove this crap (from cmdlib.cpp)
|
||
// We can't include cmdlib owing to appframework incompatibilities
|
||
//-----------------------------------------------------------------------------
|
||
void Q_mkdir( const char *path )
|
||
{
|
||
#if defined( _WIN32 ) || defined( WIN32 )
|
||
if (_mkdir (path) != -1)
|
||
return;
|
||
#else
|
||
if (mkdir (path, 0777) != -1)
|
||
return;
|
||
#endif
|
||
if (errno != EEXIST)
|
||
{
|
||
Error ("mkdir %s: %s",path, strerror(errno));
|
||
}
|
||
}
|
||
|
||
void CreatePath( const char *relative )
|
||
{
|
||
char fullpath[ 512 ];
|
||
Q_snprintf( fullpath, sizeof( fullpath ), "%s%s", GetGameDirectory(), relative );
|
||
|
||
char *path = fullpath;
|
||
|
||
char *ofs, c;
|
||
|
||
if (path[1] == ':')
|
||
{
|
||
path += 2;
|
||
}
|
||
|
||
for (ofs = const_cast<char*>(path+1); *ofs ; ofs++)
|
||
{
|
||
c = *ofs;
|
||
if (c == '/' || c == '\\')
|
||
{
|
||
// create the directory, but not if it's actually a filename with a dot in it!!!
|
||
*ofs = 0;
|
||
if ( !Q_stristr( path, "." ) )
|
||
{
|
||
Q_mkdir (path);
|
||
}
|
||
*ofs = c;
|
||
}
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// LoadFile
|
||
//-----------------------------------------------------------------------------
|
||
int LoadFile (const char *filename, void **bufferptr)
|
||
{
|
||
FileHandle_t f = filesystem->Open( filename, "rb" );
|
||
int length = filesystem->Size( f );
|
||
void *buffer = malloc (length+1);
|
||
((char *)buffer)[length] = 0;
|
||
if ( filesystem->Read (buffer, length, f) != (int)length )
|
||
{
|
||
Error ("File read failure");
|
||
}
|
||
filesystem->Close (f);
|
||
|
||
*bufferptr = buffer;
|
||
return length;
|
||
}
|
||
|
||
char *ExpandPath(char *path)
|
||
{
|
||
static char full[1024];
|
||
if (path[0] == '/' || path[0] == '\\' || path[1] == ':')
|
||
return path;
|
||
|
||
V_sprintf_safe( full, "%s%s", gamedir, path );
|
||
return full;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// This is here because scriplib.cpp is included in this project but cmdlib.cpp
|
||
// is not, but scriplib.cpp uses some stuff from cmdlib.cpp, same with
|
||
// LoadFile and ExpandPath above. The only thing that currently uses this
|
||
// is $include in scriptlib, if this function returns 0, $include will
|
||
// behave the way it did before this change
|
||
//-----------------------------------------------------------------------------
|
||
int CmdLib_ExpandWithBasePaths( CUtlVector< CUtlString > &expandedPathList, const char *pszPath )
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// FIXME: Move into appsystem framework
|
||
//-----------------------------------------------------------------------------
|
||
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_RECENTFILES1 + i, IDC_FILE_RECENTFILES1 + i, recentFiles[i]);
|
||
}
|
||
else
|
||
{
|
||
mb->modify (IDC_FILE_RECENTFILES1 + i, IDC_FILE_RECENTFILES1 + i, "(empty)");
|
||
mb->setEnabled (IDC_FILE_RECENTFILES1 + i, false);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
#define RECENTFILESPATH "/hlfaceposer.rf"
|
||
void
|
||
MDLViewer::loadRecentFiles ()
|
||
{
|
||
char path[256];
|
||
strcpy (path, mx::getApplicationPath ());
|
||
strcat (path, RECENTFILESPATH);
|
||
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, RECENTFILESPATH);
|
||
|
||
FILE *file = fopen (path, "wb");
|
||
if (file)
|
||
{
|
||
fwrite (recentFiles, sizeof recentFiles, 1, file);
|
||
fclose (file);
|
||
}
|
||
}
|
||
|
||
bool MDLViewer::AreSoundScriptsDirty()
|
||
{
|
||
// Save any changed sound script files
|
||
int c = soundemitter->GetNumSoundScripts();
|
||
for ( int i = 0; i < c; i++ )
|
||
{
|
||
if ( soundemitter->IsSoundScriptDirty( i ) )
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
bool MDLViewer::CanClose()
|
||
{
|
||
Con_Printf( "Checking for vcd changes...\n" );
|
||
|
||
if ( m_bVCDSaved )
|
||
{
|
||
int retval = mxMessageBox( NULL, "Rebuild scenes.image?", g_appTitle, MX_MB_YESNOCANCEL );
|
||
if ( retval == 2 )
|
||
{
|
||
return false;
|
||
}
|
||
|
||
m_bVCDSaved = false;
|
||
if ( retval == 0 ) // YES
|
||
{
|
||
OnRebuildScenesImage();
|
||
}
|
||
}
|
||
|
||
Con_Printf( "Checking for sound script changes...\n" );
|
||
|
||
// Save any changed sound script files
|
||
int c = soundemitter->GetNumSoundScripts();
|
||
for ( int i = 0; i < c; i++ )
|
||
{
|
||
if ( !soundemitter->IsSoundScriptDirty( i ) )
|
||
continue;
|
||
|
||
char const *scriptname = soundemitter->GetSoundScriptName( i );
|
||
if ( !scriptname )
|
||
continue;
|
||
|
||
if ( !filesystem->FileExists( scriptname ) ||
|
||
!filesystem->IsFileWritable( scriptname ) )
|
||
{
|
||
continue;
|
||
}
|
||
|
||
int retval = mxMessageBox( NULL, va( "Save changes to sound script '%s'?", scriptname ), g_appTitle, MX_MB_YESNOCANCEL );
|
||
if ( retval == 2 )
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if ( retval == 0 )
|
||
{
|
||
soundemitter->SaveChangesToSoundScript( i );
|
||
}
|
||
}
|
||
|
||
SaveWindowPositions();
|
||
|
||
models->SaveModelList();
|
||
models->CloseAllModels();
|
||
|
||
return true;
|
||
}
|
||
|
||
bool MDLViewer::Closing( void )
|
||
{
|
||
return true;
|
||
}
|
||
|
||
#define IDC_GRIDSETTINGS_FPS 1001
|
||
#define IDC_GRIDSETTINGS_SNAP 1002
|
||
|
||
class CFlatButton : public mxButton
|
||
{
|
||
public:
|
||
CFlatButton( mxWindow *parent, int id )
|
||
: mxButton( parent, 0, 0, 0, 0, "", id )
|
||
{
|
||
HWND wnd = (HWND)getHandle();
|
||
DWORD exstyle = GetWindowLong( wnd, GWL_EXSTYLE );
|
||
exstyle |= WS_EX_CLIENTEDGE;
|
||
SetWindowLong( wnd, GWL_EXSTYLE, exstyle );
|
||
|
||
DWORD style = GetWindowLong( wnd, GWL_STYLE );
|
||
style &= ~WS_BORDER;
|
||
SetWindowLong( wnd, GWL_STYLE, style );
|
||
|
||
}
|
||
};
|
||
|
||
class CMDLViewerGridSettings : public mxWindow
|
||
{
|
||
public:
|
||
typedef mxWindow BaseClass;
|
||
|
||
CMDLViewerGridSettings( mxWindow *parent, int x, int y, int w, int h ) :
|
||
mxWindow( parent, x, y, w, h )
|
||
{
|
||
FacePoser_AddWindowStyle( this, WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS );
|
||
m_btnFPS = new CFlatButton( this, IDC_GRIDSETTINGS_FPS );
|
||
m_btnGridSnap = new CFlatButton( this, IDC_GRIDSETTINGS_SNAP );
|
||
|
||
}
|
||
|
||
void Init( void )
|
||
{
|
||
if ( g_pChoreoView )
|
||
{
|
||
CChoreoScene *scene = g_pChoreoView->GetScene();
|
||
if ( scene )
|
||
{
|
||
char sz[ 256 ];
|
||
Q_snprintf( sz, sizeof( sz ), "%i fps", scene->GetSceneFPS() );
|
||
m_btnFPS->setLabel( sz );
|
||
|
||
Q_snprintf( sz, sizeof( sz ), "snap: %s", scene->IsUsingFrameSnap() ? "on" : "off" );
|
||
m_btnGridSnap->setLabel( sz );
|
||
|
||
m_btnFPS->setVisible( true );
|
||
m_btnGridSnap->setVisible( true );
|
||
return;
|
||
}
|
||
}
|
||
|
||
m_btnFPS->setVisible( false );
|
||
m_btnGridSnap->setVisible( false );
|
||
}
|
||
|
||
virtual int handleEvent( mxEvent *event )
|
||
{
|
||
int iret = 0;
|
||
switch ( event->event )
|
||
{
|
||
default:
|
||
break;
|
||
case mxEvent::Size:
|
||
{
|
||
int leftedge = w2() * 0.45f;
|
||
m_btnFPS->setBounds( 0, 0, leftedge, h2() );
|
||
m_btnGridSnap->setBounds( leftedge, 0, w2() - leftedge, h2() );
|
||
iret = 1;
|
||
}
|
||
break;
|
||
case mxEvent::Action:
|
||
{
|
||
iret = 1;
|
||
switch ( event->action )
|
||
{
|
||
default:
|
||
iret = 0;
|
||
break;
|
||
case IDC_GRIDSETTINGS_FPS:
|
||
{
|
||
if ( g_pChoreoView )
|
||
{
|
||
CChoreoScene *scene = g_pChoreoView->GetScene();
|
||
if ( scene )
|
||
{
|
||
int currentFPS = scene->GetSceneFPS();
|
||
|
||
CInputParams params;
|
||
memset( ¶ms, 0, sizeof( params ) );
|
||
|
||
strcpy( params.m_szDialogTitle, "Change FPS" );
|
||
|
||
Q_snprintf( params.m_szInputText, sizeof( params.m_szInputText ),
|
||
"%i", currentFPS );
|
||
|
||
strcpy( params.m_szPrompt, "Current FPS:" );
|
||
|
||
if ( InputProperties( ¶ms ) )
|
||
{
|
||
int newFPS = atoi( params.m_szInputText );
|
||
|
||
if ( ( newFPS > 0 ) && ( newFPS != currentFPS ) )
|
||
{
|
||
g_pChoreoView->SetDirty( true );
|
||
g_pChoreoView->PushUndo( "Change Scene FPS" );
|
||
scene->SetSceneFPS( newFPS );
|
||
g_pChoreoView->PushRedo( "Change Scene FPS" );
|
||
Init();
|
||
|
||
Con_Printf( "FPS changed to %i\n", newFPS );
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case IDC_GRIDSETTINGS_SNAP:
|
||
{
|
||
if ( g_pChoreoView )
|
||
{
|
||
CChoreoScene *scene = g_pChoreoView->GetScene();
|
||
if ( scene )
|
||
{
|
||
g_pChoreoView->SetDirty( true );
|
||
g_pChoreoView->PushUndo( "Change Snap Frame" );
|
||
|
||
scene->SetUsingFrameSnap( !scene->IsUsingFrameSnap() );
|
||
|
||
g_pChoreoView->PushRedo( "Change Snap Frame" );
|
||
|
||
Init();
|
||
|
||
Con_Printf( "Time frame snapping: %s\n",
|
||
scene->IsUsingFrameSnap() ? "on" : "off" );
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return iret;
|
||
}
|
||
|
||
bool PaintBackground( void )
|
||
{
|
||
CChoreoWidgetDrawHelper drawHelper( this );
|
||
RECT rc;
|
||
drawHelper.GetClientRect( rc );
|
||
drawHelper.DrawFilledRect( GetSysColor( COLOR_BTNFACE ), rc );
|
||
return false;
|
||
}
|
||
|
||
private:
|
||
|
||
CFlatButton *m_btnFPS;
|
||
CFlatButton *m_btnGridSnap;
|
||
};
|
||
|
||
|
||
#define IDC_MODELTAB_LOAD 1000
|
||
#define IDC_MODELTAB_CLOSE 1001
|
||
#define IDC_MODELTAB_CLOSEALL 1002
|
||
#define IDC_MODELTAB_CENTERONFACE 1003
|
||
#define IDC_MODELTAB_ASSOCIATEACTOR 1004
|
||
#define IDC_MODELTAB_TOGGLE3DVIEW 1005
|
||
#define IDC_MODELTAB_SHOWALL 1006
|
||
#define IDC_MODELTAB_HIDEALL 1007
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
class CMDLViewerModelTab : public CTabWindow
|
||
{
|
||
public:
|
||
typedef CTabWindow BaseClass;
|
||
|
||
CMDLViewerModelTab( mxWindow *parent, int x, int y, int w, int h, int id = 0, int style = 0 ) :
|
||
CTabWindow( parent, x, y, w, h, id, style )
|
||
{
|
||
SetInverted( true );
|
||
}
|
||
|
||
virtual void ShowRightClickMenu( int mx, int my )
|
||
{
|
||
mxPopupMenu *pop = new mxPopupMenu();
|
||
Assert( pop );
|
||
|
||
char const *current = "";
|
||
char const *filename = "";
|
||
int idx = getSelectedIndex();
|
||
if ( idx >= 0 )
|
||
{
|
||
current = models->GetModelName( idx );
|
||
filename = models->GetModelFileName( idx );
|
||
}
|
||
|
||
if ( models->Count() < MAX_FP_MODELS )
|
||
{
|
||
pop->add( "Load Model...", IDC_MODELTAB_LOAD );
|
||
}
|
||
if ( idx >= 0 )
|
||
{
|
||
pop->add( va( "Close '%s'", current ), IDC_MODELTAB_CLOSE );
|
||
}
|
||
if ( models->Count() > 0 )
|
||
{
|
||
pop->add( "Close All", IDC_MODELTAB_CLOSEALL );
|
||
}
|
||
if ( idx >= 0 )
|
||
{
|
||
pop->addSeparator();
|
||
pop->add( va( "Center %s's face", current ), IDC_MODELTAB_CENTERONFACE );
|
||
|
||
CChoreoScene *scene = g_pChoreoView->GetScene();
|
||
if ( scene )
|
||
{
|
||
// See if there is already an actor with this model associated
|
||
int c = scene->GetNumActors();
|
||
bool hasassoc = false;
|
||
for ( int i = 0; i < c; i++ )
|
||
{
|
||
CChoreoActor *a = scene->GetActor( i );
|
||
Assert( a );
|
||
|
||
if ( stricmp( a->GetFacePoserModelName(), filename ) )
|
||
continue;
|
||
hasassoc = true;
|
||
break;
|
||
}
|
||
|
||
if ( hasassoc )
|
||
{
|
||
pop->add( va( "Change associated actor for %s", current ), IDC_MODELTAB_ASSOCIATEACTOR );
|
||
}
|
||
else
|
||
{
|
||
pop->add( va( "Associate actor to %s", current ), IDC_MODELTAB_ASSOCIATEACTOR );
|
||
}
|
||
}
|
||
|
||
pop->addSeparator();
|
||
|
||
bool visible = models->IsModelShownIn3DView( idx );
|
||
if ( visible )
|
||
{
|
||
pop->add( va( "Remove %s from 3D View", current ), IDC_MODELTAB_TOGGLE3DVIEW );
|
||
}
|
||
else
|
||
{
|
||
pop->add( va( "Show %s in 3D View", current ), IDC_MODELTAB_TOGGLE3DVIEW );
|
||
}
|
||
}
|
||
if ( models->Count() > 0 )
|
||
{
|
||
pop->addSeparator();
|
||
pop->add( "Show All", IDC_MODELTAB_SHOWALL );
|
||
pop->add( "Hide All", IDC_MODELTAB_HIDEALL );
|
||
}
|
||
|
||
// Convert click position
|
||
POINT pt;
|
||
pt.x = mx;
|
||
pt.y = my;
|
||
|
||
// Convert coordinate space
|
||
pop->popup( this, pt.x, pt.y );
|
||
}
|
||
|
||
virtual int handleEvent( mxEvent *event )
|
||
{
|
||
int iret = 0;
|
||
switch ( event->event )
|
||
{
|
||
default:
|
||
break;
|
||
case mxEvent::Action:
|
||
{
|
||
iret = 1;
|
||
switch ( event->action )
|
||
{
|
||
default:
|
||
iret = 0;
|
||
break;
|
||
case IDC_MODELTAB_SHOWALL:
|
||
case IDC_MODELTAB_HIDEALL:
|
||
{
|
||
bool show = ( event->action == IDC_MODELTAB_SHOWALL ) ? true : false;
|
||
int c = models->Count();
|
||
for ( int i = 0; i < c ; i++ )
|
||
{
|
||
models->ShowModelIn3DView( i, show );
|
||
}
|
||
}
|
||
break;
|
||
case IDC_MODELTAB_LOAD:
|
||
{
|
||
if ( ! CommandLine()->FindParm( "-NoSteamDialog" ) )
|
||
{
|
||
g_MDLViewer->LoadModel_Steam();
|
||
}
|
||
else
|
||
{
|
||
char modelfile[ 512 ];
|
||
if ( FacePoser_ShowOpenFileNameDialog( modelfile, sizeof( modelfile ), "models", "*.mdl" ) )
|
||
{
|
||
g_MDLViewer->LoadModelFile( modelfile );
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case IDC_MODELTAB_CLOSE:
|
||
{
|
||
int idx = getSelectedIndex();
|
||
if ( idx >= 0 )
|
||
{
|
||
models->FreeModel( idx );
|
||
}
|
||
}
|
||
break;
|
||
case IDC_MODELTAB_CLOSEALL:
|
||
{
|
||
models->CloseAllModels();
|
||
}
|
||
break;
|
||
case IDC_MODELTAB_CENTERONFACE:
|
||
{
|
||
g_pControlPanel->CenterOnFace();
|
||
}
|
||
break;
|
||
case IDC_MODELTAB_TOGGLE3DVIEW:
|
||
{
|
||
int idx = getSelectedIndex();
|
||
if ( idx >= 0 )
|
||
{
|
||
bool visible = models->IsModelShownIn3DView( idx );
|
||
models->ShowModelIn3DView( idx, !visible );
|
||
}
|
||
}
|
||
break;
|
||
case IDC_MODELTAB_ASSOCIATEACTOR:
|
||
{
|
||
int idx = getSelectedIndex();
|
||
if ( idx >= 0 )
|
||
{
|
||
char const *modelname = models->GetModelFileName( idx );
|
||
|
||
CChoreoScene *scene = g_pChoreoView->GetScene();
|
||
if ( scene )
|
||
{
|
||
CChoiceParams params;
|
||
strcpy( params.m_szDialogTitle, "Associate Actor" );
|
||
|
||
params.m_bPositionDialog = false;
|
||
params.m_nLeft = 0;
|
||
params.m_nTop = 0;
|
||
strcpy( params.m_szPrompt, "Choose actor:" );
|
||
|
||
params.m_Choices.RemoveAll();
|
||
|
||
params.m_nSelected = -1;
|
||
int oldsel = -1;
|
||
|
||
int c = scene->GetNumActors();
|
||
ChoiceText text;
|
||
for ( int i = 0; i < c; i++ )
|
||
{
|
||
CChoreoActor *a = scene->GetActor( i );
|
||
Assert( a );
|
||
|
||
|
||
strcpy( text.choice, a->GetName() );
|
||
|
||
if ( !stricmp( a->GetFacePoserModelName(), modelname ) )
|
||
{
|
||
params.m_nSelected = i;
|
||
oldsel = -1;
|
||
}
|
||
|
||
params.m_Choices.AddToTail( text );
|
||
}
|
||
|
||
if ( ChoiceProperties( ¶ms ) &&
|
||
params.m_nSelected != oldsel )
|
||
{
|
||
|
||
// Chose something new...
|
||
CChoreoActor *a = scene->GetActor( params.m_nSelected );
|
||
|
||
g_pChoreoView->AssociateModelToActor( a, idx );
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
if ( iret )
|
||
return iret;
|
||
return BaseClass::handleEvent( event );
|
||
}
|
||
|
||
|
||
void HandleModelSelect( void )
|
||
{
|
||
int idx = getSelectedIndex();
|
||
if ( idx < 0 )
|
||
return;
|
||
|
||
// FIXME: Do any necessary window resetting here!!!
|
||
g_pControlPanel->ChangeModel( models->GetModelFileName( idx ) );
|
||
}
|
||
|
||
void Init( void )
|
||
{
|
||
removeAll();
|
||
|
||
int c = models->Count();
|
||
int i;
|
||
for ( i = 0; i < c ; i++ )
|
||
{
|
||
char const *name = models->GetModelName( i );
|
||
|
||
// Strip it down to the base name
|
||
char cleanname[ 256 ];
|
||
Q_FileBase( name, cleanname, sizeof( cleanname ) );
|
||
|
||
add( cleanname );
|
||
}
|
||
}
|
||
};
|
||
|
||
#define IDC_TOOL_TOGGLEVISIBILITY 1000
|
||
#define IDC_TOOL_TOGGLELOCK 1001
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
class CMDLViewerWindowTab : public CTabWindow
|
||
{
|
||
public:
|
||
typedef CTabWindow BaseClass;
|
||
|
||
CMDLViewerWindowTab( mxWindow *parent, int x, int y, int w, int h, int id = 0, int style = 0 ) :
|
||
CTabWindow( parent, x, y, w, h, id, style )
|
||
{
|
||
SetInverted( true );
|
||
|
||
m_nLastSelected = -1;
|
||
m_flLastSelectedTime = -1;
|
||
}
|
||
|
||
virtual void ShowRightClickMenu( int mx, int my )
|
||
{
|
||
IFacePoserToolWindow *tool = GetSelectedTool();
|
||
if ( !tool )
|
||
return;
|
||
|
||
mxWindow *toolw = tool->GetMxWindow();
|
||
if ( !toolw )
|
||
return;
|
||
|
||
mxPopupMenu *pop = new mxPopupMenu();
|
||
Assert( pop );
|
||
|
||
bool isVisible = toolw->isVisible();
|
||
bool isLocked = tool->IsLocked();
|
||
|
||
pop->add( isVisible ? "Hide" : "Show", IDC_TOOL_TOGGLEVISIBILITY );
|
||
pop->add( isLocked ? "Unlock" : "Lock", IDC_TOOL_TOGGLELOCK );
|
||
|
||
// Convert click position
|
||
POINT pt;
|
||
pt.x = mx;
|
||
pt.y = my;
|
||
|
||
/*
|
||
ClientToScreen( (HWND)getHandle(), &pt );
|
||
ScreenToClient( (HWND)g_MDLViewer->getHandle(), &pt );
|
||
*/
|
||
|
||
// Convert coordinate space
|
||
pop->popup( this, pt.x, pt.y );
|
||
}
|
||
|
||
virtual int handleEvent( mxEvent *event )
|
||
{
|
||
int iret = 0;
|
||
switch ( event->event )
|
||
{
|
||
case mxEvent::Action:
|
||
{
|
||
iret = 1;
|
||
switch ( event->action )
|
||
{
|
||
default:
|
||
iret = 0;
|
||
break;
|
||
case IDC_TOOL_TOGGLEVISIBILITY:
|
||
{
|
||
IFacePoserToolWindow *tool = GetSelectedTool();
|
||
if ( tool )
|
||
{
|
||
mxWindow *toolw = tool->GetMxWindow();
|
||
if ( toolw )
|
||
{
|
||
toolw->setVisible( !toolw->isVisible() );
|
||
g_MDLViewer->UpdateWindowMenu();
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case IDC_TOOL_TOGGLELOCK:
|
||
{
|
||
IFacePoserToolWindow *tool = GetSelectedTool();
|
||
if ( tool )
|
||
{
|
||
tool->ToggleLockedState();
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
if ( iret )
|
||
return iret;
|
||
return BaseClass::handleEvent( event );
|
||
}
|
||
|
||
void Init( void )
|
||
{
|
||
int c = IFacePoserToolWindow::GetToolCount();
|
||
int i;
|
||
for ( i = 0; i < c ; i++ )
|
||
{
|
||
IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
|
||
add( tool->GetDisplayNameRoot() );
|
||
}
|
||
}
|
||
|
||
#define WINDOW_DOUBLECLICK_TIME 0.4
|
||
|
||
void HandleWindowSelect( void )
|
||
{
|
||
extern double realtime;
|
||
IFacePoserToolWindow *tool = GetSelectedTool();
|
||
if ( !tool )
|
||
return;
|
||
|
||
bool doubleclicked = false;
|
||
|
||
double curtime = realtime;
|
||
int clickedItem = getSelectedIndex();
|
||
|
||
if ( clickedItem == m_nLastSelected )
|
||
{
|
||
if ( curtime < m_flLastSelectedTime + WINDOW_DOUBLECLICK_TIME )
|
||
{
|
||
doubleclicked = true;
|
||
}
|
||
}
|
||
|
||
m_flLastSelectedTime = curtime;
|
||
m_nLastSelected = clickedItem;
|
||
|
||
mxWindow *toolw = tool->GetMxWindow();
|
||
if ( !toolw )
|
||
return;
|
||
|
||
if ( doubleclicked )
|
||
{
|
||
toolw->setVisible( !toolw->isVisible() );
|
||
m_flLastSelectedTime = -1;
|
||
}
|
||
|
||
if ( !toolw->isVisible() )
|
||
{
|
||
return;
|
||
}
|
||
|
||
// Move window to front
|
||
HWND wnd = (HWND)tool->GetMxWindow()->getHandle();
|
||
SetFocus( wnd );
|
||
SetWindowPos( wnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
|
||
}
|
||
|
||
private:
|
||
|
||
IFacePoserToolWindow *GetSelectedTool()
|
||
{
|
||
int idx = getSelectedIndex();
|
||
int c = IFacePoserToolWindow::GetToolCount();
|
||
|
||
if ( idx < 0 || idx >= c )
|
||
return NULL;
|
||
|
||
IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( idx );
|
||
return tool;
|
||
}
|
||
|
||
// HACKY double click handler
|
||
int m_nLastSelected;
|
||
double m_flLastSelectedTime;
|
||
};
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: The workspace is the parent of all of the tool windows
|
||
//-----------------------------------------------------------------------------
|
||
class CMDLViewerWorkspace : public mxWindow
|
||
{
|
||
public:
|
||
CMDLViewerWorkspace( mxWindow *parent, int x, int y, int w, int h, const char *label = 0, int style = 0)
|
||
: mxWindow( parent, x, y, w, h, label, style )
|
||
{
|
||
FacePoser_AddWindowStyle( this, WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Output : Returns true on success, false on failure.
|
||
//-----------------------------------------------------------------------------
|
||
bool PaintBackground( void )
|
||
{
|
||
CChoreoWidgetDrawHelper drawHelper( this );
|
||
RECT rc;
|
||
drawHelper.GetClientRect( rc );
|
||
drawHelper.DrawFilledRect( GetSysColor( COLOR_APPWORKSPACE ), rc );
|
||
return false;
|
||
}
|
||
};
|
||
|
||
void MDLViewer::LoadPosition( void )
|
||
{
|
||
bool visible;
|
||
bool locked;
|
||
bool zoomed;
|
||
int x, y, w, h;
|
||
|
||
FacePoser_LoadWindowPositions( "MDLViewer", visible, x, y, w, h, locked, zoomed );
|
||
|
||
if ( w == 0 || h == 0 )
|
||
{
|
||
zoomed = true;
|
||
visible = true;
|
||
}
|
||
|
||
setBounds( x, y, w, h );
|
||
if ( zoomed )
|
||
{
|
||
ShowWindow( (HWND)getHandle(), SW_SHOWMAXIMIZED );
|
||
}
|
||
else
|
||
{
|
||
setVisible( visible );
|
||
}
|
||
}
|
||
|
||
void MDLViewer::SavePosition( void )
|
||
{
|
||
bool visible;
|
||
int xpos, ypos, width, height;
|
||
|
||
visible = isVisible();
|
||
xpos = x();
|
||
ypos = y();
|
||
width = w();
|
||
height = h();
|
||
|
||
// xpos and ypos are screen space
|
||
POINT pt;
|
||
pt.x = xpos;
|
||
pt.y = ypos;
|
||
|
||
// Convert from screen space to relative to client area of parent window so
|
||
// the setBounds == MoveWindow call will offset to the same location
|
||
if ( getParent() )
|
||
{
|
||
ScreenToClient( (HWND)getParent()->getHandle(), &pt );
|
||
xpos = (short)pt.x;
|
||
ypos = (short)pt.y;
|
||
}
|
||
|
||
bool zoomed = IsZoomed( (HWND)getHandle() ) ? true : false;
|
||
|
||
bool iconic = IsIconic( (HWND)getHandle() ) ? true : false;
|
||
|
||
// Don't reset values if it's minimized during shutdown
|
||
if ( iconic )
|
||
return;
|
||
|
||
FacePoser_SaveWindowPositions( "MDLViewer", visible, xpos, ypos, width, height, false, zoomed );
|
||
}
|
||
|
||
MDLViewer::MDLViewer () :
|
||
mxWindow (0, 0, 0, 0, 0, g_appTitle, mxWindow::Normal),
|
||
menuCloseCaptionLanguages(0),
|
||
m_bOldSoundScriptsDirty( -1 ),
|
||
m_bVCDSaved( false )
|
||
{
|
||
int i;
|
||
|
||
g_MDLViewer = this;
|
||
|
||
FacePoser_MakeToolWindow( this, false );
|
||
|
||
workspace = new CMDLViewerWorkspace( this, 0, 0, 500, 500, "" );
|
||
windowtab = new CMDLViewerWindowTab( this, 0, 500, 500, 20, IDC_WINDOW_TAB );
|
||
modeltab = new CMDLViewerModelTab( this, 500, 500, 200, 20, IDC_MODEL_TAB );
|
||
gridsettings = new CMDLViewerGridSettings( this, 0, 500, 500, 20 );
|
||
modeltab->SetRightJustify( true );
|
||
|
||
g_pStatusWindow = new mxStatusWindow( workspace, 0, 0, 1024, 150, "" );
|
||
g_pStatusWindow->setVisible( true );
|
||
|
||
InitViewerSettings( "faceposer" );
|
||
g_viewerSettings.speechapiindex = SPEECH_API_LIPSINC;
|
||
g_viewerSettings.m_iEditAttachment = -1;
|
||
|
||
LoadViewerRootSettings( );
|
||
|
||
LoadPosition();
|
||
// ShowWindow( (HWND)getHandle(), SW_SHOWMAXIMIZED );
|
||
|
||
g_pStatusWindow->setBounds( 0, h2() - 150, w2(), 150 );
|
||
|
||
Con_Printf( "MDLViewer started\n" );
|
||
|
||
Con_Printf( "Creating menu bar\n" );
|
||
|
||
// create menu stuff
|
||
mb = new mxMenuBar (this);
|
||
menuFile = new mxMenu ();
|
||
menuOptions = new mxMenu ();
|
||
menuWindow = new mxMenu ();
|
||
menuHelp = new mxMenu ();
|
||
menuEdit = new mxMenu ();
|
||
menuExpressions = new mxMenu();
|
||
menuChoreography = new mxMenu();
|
||
|
||
mb->addMenu ("File", menuFile);
|
||
//mb->addMenu( "Edit", menuEdit );
|
||
mb->addMenu ("Options", menuOptions);
|
||
mb->addMenu ( "Expression", menuExpressions );
|
||
mb->addMenu ( "Choreography", menuChoreography );
|
||
mb->addMenu ("Window", menuWindow);
|
||
mb->addMenu ("Help", menuHelp);
|
||
|
||
mxMenu *menuRecentFiles = new mxMenu ();
|
||
menuRecentFiles->add ("(empty)", IDC_FILE_RECENTFILES1);
|
||
menuRecentFiles->add ("(empty)", IDC_FILE_RECENTFILES2);
|
||
menuRecentFiles->add ("(empty)", IDC_FILE_RECENTFILES3);
|
||
menuRecentFiles->add ("(empty)", IDC_FILE_RECENTFILES4);
|
||
|
||
menuFile->add ("Load Model...", IDC_FILE_LOADMODEL);
|
||
menuFile->add( "Refresh\tF5", IDC_FILE_REFRESH );
|
||
|
||
menuFile->addSeparator();
|
||
menuFile->add ("Save Sound Changes...", IDC_FILE_SAVESOUNDSCRIPTCHANGES );
|
||
menuFile->add( "Rebuild scenes.image...", IDC_FILE_REBUILDSCENESIMAGE );
|
||
|
||
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 Files", menuRecentFiles);
|
||
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);
|
||
menuFile->setEnabled(IDC_FILE_SAVESOUNDSCRIPTCHANGES, false);
|
||
|
||
menuOptions->add ("Background Color...", IDC_OPTIONS_COLORBACKGROUND);
|
||
menuOptions->add ("Ground Color...", IDC_OPTIONS_COLORGROUND);
|
||
menuOptions->add ("Light Color...", IDC_OPTIONS_COLORLIGHT);
|
||
|
||
{
|
||
menuCloseCaptionLanguages = new mxMenu();
|
||
|
||
for ( int i = 0; i < CC_NUM_LANGUAGES; i++ )
|
||
{
|
||
int id = IDC_OPTIONS_LANGUAGESTART + i;
|
||
menuCloseCaptionLanguages->add( CSentence::NameForLanguage( i ), id );
|
||
}
|
||
|
||
menuOptions->addSeparator();
|
||
menuOptions->addMenu( "CC Language", menuCloseCaptionLanguages );
|
||
}
|
||
|
||
menuOptions->addSeparator ();
|
||
menuOptions->add ("Center View", IDC_OPTIONS_CENTERVIEW);
|
||
menuOptions->add ("Center on Face", IDC_OPTIONS_CENTERONFACE );
|
||
#ifdef WIN32
|
||
menuOptions->addSeparator ();
|
||
menuOptions->add ("Make Screenshot...", IDC_OPTIONS_MAKESCREENSHOT);
|
||
//menuOptions->add ("Dump Model Info", IDC_OPTIONS_DUMP);
|
||
menuOptions->addSeparator ();
|
||
menuOptions->add ("Clear model sounds.", IDC_OPTIONS_CLEARMODELSOUNDS );
|
||
|
||
#endif
|
||
|
||
menuExpressions->add( "New...", IDC_EXPRESSIONS_NEW );
|
||
menuExpressions->addSeparator ();
|
||
menuExpressions->add( "Load...", IDC_EXPRESSIONS_LOAD );
|
||
menuExpressions->add( "Save", IDC_EXPRESSIONS_SAVE );
|
||
menuExpressions->addSeparator ();
|
||
menuExpressions->add( "Export to VFE", IDC_EXPRESSIONS_EXPORT );
|
||
menuExpressions->addSeparator ();
|
||
menuExpressions->add( "Close class", IDC_EXPRESSIONS_CLOSE );
|
||
menuExpressions->add( "Close all classes", IDC_EXPRESSIONS_CLOSEALL );
|
||
menuExpressions->addSeparator();
|
||
menuExpressions->add( "Recreate all bitmaps", IDC_EXPRESSIONS_REDOBITMAPS );
|
||
|
||
menuChoreography->add( "New...", IDC_CHOREOSCENE_NEW );
|
||
menuChoreography->addSeparator();
|
||
menuChoreography->add( "Load...", IDC_CHOREOSCENE_LOAD );
|
||
menuChoreography->add( "Save", IDC_CHOREOSCENE_SAVE );
|
||
menuChoreography->add( "Save As...", IDC_CHOREOSCENE_SAVEAS );
|
||
menuChoreography->addSeparator();
|
||
menuChoreography->add( "Close", IDC_CHOREOSCENE_CLOSE );
|
||
menuChoreography->addSeparator();
|
||
menuChoreography->add( "Add Actor...", IDC_CHOREOSCENE_ADDACTOR );
|
||
menuChoreography->addSeparator();
|
||
menuChoreography->add( "Load Next", IDC_CHOREOSCENE_LOADNEXT );
|
||
|
||
#ifdef WIN32
|
||
menuHelp->add ("Goto Homepage...", IDC_HELP_GOTOHOMEPAGE);
|
||
menuHelp->addSeparator ();
|
||
#endif
|
||
menuHelp->add ("About...", IDC_HELP_ABOUT);
|
||
|
||
// create the Material System window
|
||
Con_Printf( "Creating 3D View\n" );
|
||
g_pMatSysWindow = new MatSysWindow (workspace, 0, 0, 100, 100, "", mxWindow::Normal);
|
||
|
||
Con_Printf( "Creating Close Caption tool" );
|
||
g_pCloseCaptionTool = new CloseCaptionTool( workspace );
|
||
|
||
Con_Printf( "Creating control panel\n" );
|
||
g_pControlPanel = new ControlPanel (workspace);
|
||
|
||
Con_Printf( "Creating phoneme editor\n" );
|
||
g_pPhonemeEditor = new PhonemeEditor( workspace );
|
||
|
||
Con_Printf( "Creating expression tool\n" );
|
||
g_pExpressionTool = new ExpressionTool( workspace );
|
||
|
||
Con_Printf( "Creating gesture tool\n" );
|
||
g_pGestureTool = new GestureTool( workspace );
|
||
|
||
Con_Printf( "Creating ramp tool\n" );
|
||
g_pRampTool = new RampTool( workspace );
|
||
|
||
Con_Printf( "Creating scene ramp tool\n" );
|
||
g_pSceneRampTool = new SceneRampTool( workspace );
|
||
|
||
Con_Printf( "Creating expression tray\n" );
|
||
g_pExpressionTrayTool = new mxExpressionTray( workspace, IDC_EXPRESSIONTRAY );
|
||
|
||
Con_Printf( "Creating animation browser\n" );
|
||
g_pAnimationBrowserTool = new AnimationBrowser( workspace, IDC_ANIMATIONBROWSER );
|
||
|
||
Con_Printf( "Creating flex slider window\n" );
|
||
g_pFlexPanel = new FlexPanel( workspace );
|
||
|
||
Con_Printf( "Creating wave browser\n" );
|
||
g_pWaveBrowser = new CWaveBrowser( workspace );
|
||
|
||
Con_Printf( "Creating VCD browser\n" );
|
||
g_pVCDBrowser = new CVCDBrowser( workspace );
|
||
|
||
Con_Printf( "Creating choreography view\n" );
|
||
g_pChoreoView = new CChoreoView( workspace, 200, 200, 400, 300, 0 );
|
||
// Choreo scene file drives main window title name
|
||
g_pChoreoView->SetUseForMainWindowTitle( true );
|
||
#if 0
|
||
new TestWindow( workspace, 100, 100, 256, 256 );
|
||
#endif
|
||
|
||
Con_Printf( "IFacePoserToolWindow::Init\n" );
|
||
|
||
IFacePoserToolWindow::InitTools();
|
||
|
||
Con_Printf( "windowtab->Init\n" );
|
||
|
||
windowtab->Init();
|
||
|
||
Con_Printf( "loadRecentFiles\n" );
|
||
|
||
loadRecentFiles ();
|
||
initRecentFiles ();
|
||
|
||
Con_Printf( "RestoreThumbnailSize\n" );
|
||
|
||
g_pExpressionTrayTool->RestoreThumbnailSize();
|
||
g_pAnimationBrowserTool->RestoreThumbnailSize();
|
||
|
||
Con_Printf( "Add Tool Windows\n" );
|
||
|
||
int c = IFacePoserToolWindow::GetToolCount();
|
||
for ( i = 0; i < c ; i++ )
|
||
{
|
||
IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
|
||
menuWindow->add( tool->GetToolName(), IDC_WINDOW_FIRSTTOOL + i );
|
||
}
|
||
|
||
menuWindow->addSeparator();
|
||
menuWindow->add( "Cascade", IDC_WINDOW_CASCADE );
|
||
menuWindow->addSeparator();
|
||
menuWindow->add( "Tile", IDC_WINDOW_TILE );
|
||
menuWindow->add( "Tile Horizontally", IDC_WINDOW_TILE_HORIZ );
|
||
menuWindow->add( "Tile Vertically", IDC_WINDOW_TILE_VERT );
|
||
menuWindow->addSeparator();
|
||
menuWindow->add( "Hide All", IDC_WINDOW_HIDEALL );
|
||
menuWindow->add( "Show All", IDC_WINDOW_SHOWALL );
|
||
|
||
Con_Printf( "UpdateWindowMenu\n" );
|
||
|
||
UpdateWindowMenu();
|
||
// Check the default item
|
||
UpdateLanguageMenu( g_viewerSettings.cclanguageid );
|
||
|
||
m_nCurrentFrame = 0;
|
||
|
||
Con_Printf( "gridsettings->Init()\n" );
|
||
|
||
gridsettings->Init();
|
||
|
||
Con_Printf( "LoadWindowPositions\n" );
|
||
|
||
LoadWindowPositions();
|
||
|
||
Con_Printf( "Model viewer created\n" );
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void MDLViewer::UpdateWindowMenu( void )
|
||
{
|
||
int c = IFacePoserToolWindow::GetToolCount();
|
||
for ( int i = 0; i < c ; i++ )
|
||
{
|
||
IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
|
||
menuWindow->setChecked( IDC_WINDOW_FIRSTTOOL + i, tool->GetMxWindow()->isVisible() );
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : currentLanguageId -
|
||
//-----------------------------------------------------------------------------
|
||
void MDLViewer::UpdateLanguageMenu( int currentLanguageId )
|
||
{
|
||
if ( !menuCloseCaptionLanguages )
|
||
return;
|
||
|
||
for ( int i = 0; i < CC_NUM_LANGUAGES; i++ )
|
||
{
|
||
int id = IDC_OPTIONS_LANGUAGESTART + i;
|
||
menuCloseCaptionLanguages->setChecked( id, i == currentLanguageId ? true : false );
|
||
}
|
||
}
|
||
|
||
void MDLViewer::OnDelete()
|
||
{
|
||
saveRecentFiles ();
|
||
SaveViewerRootSettings( );
|
||
|
||
#ifdef WIN32
|
||
DeleteFile ("hlmv.cfg");
|
||
DeleteFile ("midump.txt");
|
||
#endif
|
||
|
||
IFacePoserToolWindow::ShutdownTools();
|
||
|
||
g_MDLViewer = NULL;
|
||
}
|
||
|
||
MDLViewer::~MDLViewer ()
|
||
{
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void MDLViewer::InitModelTab( void )
|
||
{
|
||
modeltab->Init();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
//-----------------------------------------------------------------------------
|
||
void MDLViewer::InitGridSettings( void )
|
||
{
|
||
gridsettings->Init();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Output : int
|
||
//-----------------------------------------------------------------------------
|
||
int MDLViewer::GetActiveModelTab( void )
|
||
{
|
||
return modeltab->getSelectedIndex();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : modelindex -
|
||
//-----------------------------------------------------------------------------
|
||
void MDLViewer::SetActiveModelTab( int modelindex )
|
||
{
|
||
modeltab->select( modelindex );
|
||
modeltab->HandleModelSelect();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Reloads the currently loaded model file.
|
||
//-----------------------------------------------------------------------------
|
||
void MDLViewer::Refresh( void )
|
||
{
|
||
Con_ColorPrintf( RGB( 0, 125, 255 ), "Refreshing...\n" );
|
||
|
||
bool reinit_soundemitter = true;
|
||
|
||
// Save any changed sound script files
|
||
int c = soundemitter->GetNumSoundScripts();
|
||
for ( int i = 0; i < c; i++ )
|
||
{
|
||
if ( !soundemitter->IsSoundScriptDirty( i ) )
|
||
continue;
|
||
|
||
char const *scriptname = soundemitter->GetSoundScriptName( i );
|
||
if ( !scriptname )
|
||
continue;
|
||
|
||
if ( !filesystem->FileExists( scriptname ) ||
|
||
!filesystem->IsFileWritable( scriptname ) )
|
||
{
|
||
continue;
|
||
}
|
||
|
||
int retval = mxMessageBox( NULL, va( "Save changes to sound script '%s'?", scriptname ), g_appTitle, MX_MB_YESNOCANCEL );
|
||
if ( retval != 0 )
|
||
{
|
||
reinit_soundemitter = false;
|
||
continue;
|
||
}
|
||
|
||
if ( retval == 0 )
|
||
{
|
||
soundemitter->SaveChangesToSoundScript( i );
|
||
Con_ColorPrintf( RGB( 50, 255, 100 ), " saving changes to script file '%s'\n", scriptname );
|
||
}
|
||
}
|
||
|
||
// kill the soundemitter system
|
||
if ( reinit_soundemitter )
|
||
{
|
||
soundemitter->Shutdown();
|
||
}
|
||
|
||
|
||
Con_ColorPrintf( RGB( 50, 255, 100 ), " reloading textures\n" );
|
||
g_pMaterialSystem->ReloadTextures();
|
||
|
||
models->ReleaseModels();
|
||
|
||
Con_ColorPrintf( RGB( 50, 255, 100 ), " reloading models\n" );
|
||
models->RestoreModels();
|
||
|
||
// restart the soundemitter system
|
||
if ( reinit_soundemitter )
|
||
{
|
||
Con_ColorPrintf( RGB( 50, 255, 100 ), " reloading sound emitter system\n" );
|
||
soundemitter->Init();
|
||
}
|
||
else
|
||
{
|
||
Con_ColorPrintf( RGB( 250, 50, 50 ), " NOT reloading sound emitter system\n" );
|
||
}
|
||
|
||
Con_ColorPrintf( RGB( 0, 125, 255 ), "done.\n" );
|
||
}
|
||
|
||
void MDLViewer::OnFileLoaded( char const *pszFile )
|
||
{
|
||
int i;
|
||
for (i = 0; i < 8; i++)
|
||
{
|
||
if (!Q_stricmp( recentFiles[i], pszFile ))
|
||
break;
|
||
}
|
||
|
||
// swap existing recent file
|
||
if (i < 8)
|
||
{
|
||
char tmp[256];
|
||
strcpy (tmp, recentFiles[0]);
|
||
strcpy (recentFiles[0], recentFiles[i]);
|
||
strcpy (recentFiles[i], tmp);
|
||
}
|
||
|
||
// insert recent file
|
||
else
|
||
{
|
||
for (i = 7; i > 0; i--)
|
||
strcpy (recentFiles[i], recentFiles[i - 1]);
|
||
|
||
strcpy( recentFiles[0], pszFile );
|
||
}
|
||
|
||
initRecentFiles ();
|
||
|
||
if ( g_pVCDBrowser )
|
||
{
|
||
g_pVCDBrowser->SetCurrent( pszFile );
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Loads the file and updates the MRU list.
|
||
// Input : pszFile - File to load.
|
||
//-----------------------------------------------------------------------------
|
||
void MDLViewer::LoadModelFile( const char *pszFile )
|
||
{
|
||
models->LoadModel( pszFile );
|
||
|
||
OnFileLoaded( pszFile );
|
||
|
||
g_pControlPanel->CenterOnFace();
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Input : *wnd -
|
||
// x -
|
||
// y -
|
||
// Output : static bool
|
||
//-----------------------------------------------------------------------------
|
||
static bool WindowContainsPoint( mxWindow *wnd, int x, int y )
|
||
{
|
||
POINT pt;
|
||
pt.x = (short)x;
|
||
pt.y = (short)y;
|
||
|
||
HWND window = (HWND)wnd->getHandle();
|
||
if ( !window )
|
||
return false;
|
||
|
||
ScreenToClient( window, &pt );
|
||
|
||
if ( pt.x < 0 )
|
||
return false;
|
||
if ( pt.y < 0 )
|
||
return false;
|
||
if ( pt.x > wnd->w() )
|
||
return false;
|
||
if ( pt.y > wnd->h() )
|
||
return false;
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
void MDLViewer::LoadModel_Steam()
|
||
{
|
||
if ( !g_FSDialogFactory )
|
||
return;
|
||
|
||
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;
|
||
}
|
||
pDlg->Init( g_Factory, NULL );
|
||
pDlg->AddFileMask( "*.jpg" );
|
||
pDlg->AddFileMask( "*.mdl" );
|
||
pDlg->SetInitialDir( "models", "game" );
|
||
pDlg->SetFilterMdlAndJpgFiles( true );
|
||
|
||
if (pDlg->DoModal() == IDOK)
|
||
{
|
||
char filename[MAX_PATH];
|
||
pDlg->GetFilename( filename, sizeof( filename ) );
|
||
LoadModelFile( filename );
|
||
}
|
||
|
||
pDlg->Release();
|
||
}
|
||
|
||
|
||
|
||
int MDLViewer::handleEvent (mxEvent *event)
|
||
{
|
||
MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
|
||
|
||
int iret = 0;
|
||
|
||
switch (event->event)
|
||
{
|
||
case mxEvent::Size:
|
||
{
|
||
int width = w2();
|
||
int height = h2();
|
||
|
||
windowtab->SetRowHeight( WINDOW_TAB_OFFSET - 2 );
|
||
modeltab->SetRowHeight( WINDOW_TAB_OFFSET - 2 );
|
||
|
||
int gridsettingswide = 100;
|
||
int gridstart = width - gridsettingswide - 5;
|
||
|
||
int modelwide = gridstart / 3;
|
||
int windowwide = gridstart - modelwide;
|
||
|
||
int rowheight = max( windowtab->GetBestHeight( windowwide ), modeltab->GetBestHeight( modelwide ) );
|
||
|
||
workspace->setBounds( 0, 0, width, height - rowheight );
|
||
|
||
gridsettings->setBounds( gridstart, height - rowheight + 1, gridsettingswide, WINDOW_TAB_OFFSET - 2 );
|
||
|
||
windowtab->setBounds( 0, height - rowheight, windowwide, rowheight );
|
||
modeltab->setBounds( windowwide, height - rowheight, modelwide, rowheight );
|
||
|
||
iret = 1;
|
||
}
|
||
break;
|
||
case mxEvent::Action:
|
||
{
|
||
iret = 1;
|
||
switch (event->action)
|
||
{
|
||
case IDC_WINDOW_TAB:
|
||
{
|
||
windowtab->HandleWindowSelect();
|
||
}
|
||
break;
|
||
case IDC_MODEL_TAB:
|
||
{
|
||
modeltab->HandleModelSelect();
|
||
}
|
||
break;
|
||
|
||
case IDC_FILE_LOADMODEL:
|
||
{
|
||
if ( ! CommandLine()->FindParm( "-NoSteamDialog" ) )
|
||
{
|
||
g_MDLViewer->LoadModel_Steam();
|
||
}
|
||
else
|
||
{
|
||
char modelfile[ 512 ];
|
||
if ( FacePoser_ShowOpenFileNameDialog( modelfile, sizeof( modelfile ), "models", "*.mdl" ) )
|
||
{
|
||
LoadModelFile( modelfile );
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
|
||
case IDC_FILE_REFRESH:
|
||
{
|
||
Refresh();
|
||
break;
|
||
}
|
||
|
||
case IDC_FILE_SAVESOUNDSCRIPTCHANGES:
|
||
{
|
||
OnSaveSoundScriptChanges();
|
||
}
|
||
break;
|
||
case IDC_FILE_REBUILDSCENESIMAGE:
|
||
{
|
||
OnRebuildScenesImage();
|
||
}
|
||
break;
|
||
|
||
case IDC_FILE_LOADBACKGROUNDTEX:
|
||
case IDC_FILE_LOADGROUNDTEX:
|
||
{
|
||
const char *ptr = mxGetOpenFileName (this, 0, "*.*");
|
||
if (ptr)
|
||
{
|
||
if (0 /* g_pMatSysWindow->loadTexture (ptr, event->action - IDC_FILE_LOADBACKGROUNDTEX) */)
|
||
{
|
||
if (event->action == IDC_FILE_LOADBACKGROUNDTEX)
|
||
g_pControlPanel->setShowBackground (true);
|
||
else
|
||
g_pControlPanel->setShowGround (true);
|
||
|
||
}
|
||
else
|
||
mxMessageBox (this, "Error loading texture.", g_appTitle, MX_MB_OK | MX_MB_ERROR);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case IDC_FILE_UNLOADGROUNDTEX:
|
||
{
|
||
// g_pMatSysWindow->loadTexture (0, 1);
|
||
g_pControlPanel->setShowGround (false);
|
||
}
|
||
break;
|
||
|
||
case IDC_FILE_RECENTFILES1:
|
||
case IDC_FILE_RECENTFILES2:
|
||
case IDC_FILE_RECENTFILES3:
|
||
case IDC_FILE_RECENTFILES4:
|
||
case IDC_FILE_RECENTFILES5:
|
||
case IDC_FILE_RECENTFILES6:
|
||
case IDC_FILE_RECENTFILES7:
|
||
case IDC_FILE_RECENTFILES8:
|
||
{
|
||
int i = event->action - IDC_FILE_RECENTFILES1;
|
||
|
||
if ( recentFiles[ i ] && recentFiles[ i ][ 0 ] )
|
||
{
|
||
char ext[ 4 ];
|
||
Q_ExtractFileExtension( recentFiles[ i ], ext, sizeof( ext ) );
|
||
bool valid = false;
|
||
if ( !Q_stricmp( ext, "mdl" ) )
|
||
{
|
||
// Check extension
|
||
LoadModelFile( recentFiles[ i ] );
|
||
valid = true;
|
||
}
|
||
else if ( !Q_stricmp( ext, "vcd" ) )
|
||
{
|
||
g_pChoreoView->LoadSceneFromFile( recentFiles[ i ] );
|
||
valid = true;
|
||
}
|
||
|
||
if ( valid )
|
||
{
|
||
char tmp[256];
|
||
strcpy (tmp, recentFiles[0]);
|
||
strcpy (recentFiles[0], recentFiles[i]);
|
||
strcpy (recentFiles[i], tmp);
|
||
|
||
initRecentFiles ();
|
||
}
|
||
}
|
||
|
||
redraw ();
|
||
}
|
||
break;
|
||
|
||
case IDC_FILE_EXIT:
|
||
{
|
||
redraw ();
|
||
mx::quit ();
|
||
}
|
||
break;
|
||
|
||
case IDC_OPTIONS_COLORBACKGROUND:
|
||
case IDC_OPTIONS_COLORGROUND:
|
||
case IDC_OPTIONS_COLORLIGHT:
|
||
{
|
||
float *cols[3] = { g_viewerSettings.bgColor, g_viewerSettings.gColor, g_viewerSettings.lColor };
|
||
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:
|
||
g_pControlPanel->centerView ();
|
||
break;
|
||
|
||
case IDC_OPTIONS_CENTERONFACE:
|
||
g_pControlPanel->CenterOnFace();
|
||
break;
|
||
|
||
case IDC_OPTIONS_CLEARMODELSOUNDS:
|
||
{
|
||
sound->StopAll();
|
||
Con_ColorPrintf( RGB( 0, 100, 255 ), "Resetting model sound channels\n" );
|
||
}
|
||
break;
|
||
|
||
case IDC_OPTIONS_MAKESCREENSHOT:
|
||
{
|
||
char *ptr = (char *) mxGetSaveFileName (this, "", "*.tga");
|
||
if (ptr)
|
||
{
|
||
char fn[ 512 ];
|
||
Q_strncpy( fn, ptr, sizeof( fn ) );
|
||
Q_SetExtension( fn, ".tga", sizeof( fn ) );
|
||
g_pMatSysWindow->TakeScreenShot( fn );
|
||
}
|
||
}
|
||
break;
|
||
|
||
case IDC_OPTIONS_DUMP:
|
||
g_pControlPanel->dumpModelInfo ();
|
||
break;
|
||
|
||
#ifdef WIN32
|
||
case IDC_HELP_GOTOHOMEPAGE:
|
||
ShellExecute (0, "open", "http://developer.valvesoftware.com/wiki/Category:Choreography", 0, 0, SW_SHOW);
|
||
break;
|
||
#endif
|
||
|
||
case IDC_HELP_ABOUT:
|
||
mxMessageBox (this,
|
||
"v1.0 Copyright <20> 1996-2007, Valve Corporation. All rights reserved.\r\nBuild Date: " __DATE__ "",
|
||
"Valve Face Poser",
|
||
MX_MB_OK | MX_MB_INFORMATION);
|
||
break;
|
||
|
||
case IDC_EXPRESSIONS_REDOBITMAPS:
|
||
{
|
||
CExpClass *active = expressions->GetActiveClass();
|
||
if ( active )
|
||
{
|
||
g_pProgressDialog->Start( "Rebuild Bitmaps", "", true );
|
||
|
||
g_pMatSysWindow->EnableStickySnapshotMode( );
|
||
for ( int i = 0; i < active->GetNumExpressions() ; i++ )
|
||
{
|
||
CExpression *exp = active->GetExpression( i );
|
||
if ( !exp )
|
||
continue;
|
||
|
||
g_pProgressDialog->UpdateText( exp->name );
|
||
g_pProgressDialog->Update( (float)i / (float)active->GetNumExpressions() );
|
||
if ( g_pProgressDialog->IsCancelled() )
|
||
{
|
||
Msg( "Cancelled\n" );
|
||
break;
|
||
}
|
||
|
||
exp->CreateNewBitmap( models->GetActiveModelIndex() );
|
||
|
||
if ( ! ( i % 5 ) )
|
||
{
|
||
g_pExpressionTrayTool->redraw();
|
||
}
|
||
}
|
||
g_pMatSysWindow->DisableStickySnapshotMode( );
|
||
|
||
g_pProgressDialog->Finish();
|
||
|
||
active->SelectExpression( 0 );
|
||
}
|
||
}
|
||
break;
|
||
case IDC_EXPRESSIONS_NEW:
|
||
{
|
||
char classfile[ 512 ];
|
||
if ( FacePoser_ShowSaveFileNameDialog( classfile, sizeof( classfile ), "expressions", "*.txt" ) )
|
||
{
|
||
Q_DefaultExtension( classfile, ".txt", sizeof( classfile ) );
|
||
expressions->CreateNewClass( classfile );
|
||
}
|
||
}
|
||
break;
|
||
case IDC_EXPRESSIONS_LOAD:
|
||
{
|
||
char classfile[ 512 ];
|
||
if ( FacePoser_ShowOpenFileNameDialog( classfile, sizeof( classfile ), "expressions", "*.txt" ) )
|
||
{
|
||
expressions->LoadClass( classfile );
|
||
}
|
||
}
|
||
break;
|
||
|
||
case IDC_EXPRESSIONS_SAVE:
|
||
{
|
||
CExpClass *active = expressions->GetActiveClass();
|
||
if ( active )
|
||
{
|
||
active->Save();
|
||
active->Export();
|
||
}
|
||
}
|
||
break;
|
||
case IDC_EXPRESSIONS_EXPORT:
|
||
{
|
||
CExpClass *active = expressions->GetActiveClass();
|
||
if ( active )
|
||
{
|
||
active->Export();
|
||
}
|
||
}
|
||
break;
|
||
case IDC_EXPRESSIONS_CLOSE:
|
||
g_pControlPanel->Close();
|
||
break;
|
||
case IDC_EXPRESSIONS_CLOSEALL:
|
||
g_pControlPanel->Closeall();
|
||
break;
|
||
case IDC_CHOREOSCENE_NEW:
|
||
g_pChoreoView->New();
|
||
break;
|
||
case IDC_CHOREOSCENE_LOAD:
|
||
g_pChoreoView->Load();
|
||
break;
|
||
case IDC_CHOREOSCENE_LOADNEXT:
|
||
g_pChoreoView->LoadNext();
|
||
break;
|
||
case IDC_CHOREOSCENE_SAVE:
|
||
g_pChoreoView->Save();
|
||
break;
|
||
case IDC_CHOREOSCENE_SAVEAS:
|
||
g_pChoreoView->SaveAs();
|
||
break;
|
||
case IDC_CHOREOSCENE_CLOSE:
|
||
g_pChoreoView->Close();
|
||
break;
|
||
case IDC_CHOREOSCENE_ADDACTOR:
|
||
g_pChoreoView->NewActor();
|
||
break;
|
||
case IDC_WINDOW_TILE:
|
||
{
|
||
OnTile();
|
||
}
|
||
break;
|
||
case IDC_WINDOW_TILE_HORIZ:
|
||
{
|
||
OnTileHorizontally();
|
||
}
|
||
break;
|
||
case IDC_WINDOW_TILE_VERT:
|
||
{
|
||
OnTileVertically();
|
||
}
|
||
break;
|
||
case IDC_WINDOW_CASCADE:
|
||
{
|
||
OnCascade();
|
||
}
|
||
break;
|
||
case IDC_WINDOW_HIDEALL:
|
||
{
|
||
OnHideAll();
|
||
}
|
||
break;
|
||
case IDC_WINDOW_SHOWALL:
|
||
{
|
||
OnShowAll();
|
||
}
|
||
break;
|
||
default:
|
||
{
|
||
iret = 0;
|
||
int tool_number = event->action - IDC_WINDOW_FIRSTTOOL;
|
||
int max_tools = IDC_WINDOW_LASTTOOL - IDC_WINDOW_FIRSTTOOL;
|
||
|
||
if ( tool_number >= 0 &&
|
||
tool_number <= max_tools &&
|
||
tool_number < IFacePoserToolWindow::GetToolCount() )
|
||
{
|
||
iret = 1;
|
||
IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( tool_number );
|
||
if ( tool )
|
||
{
|
||
mxWindow *toolw = tool->GetMxWindow();
|
||
|
||
bool wasvisible = toolw->isVisible();
|
||
toolw->setVisible( !wasvisible );
|
||
|
||
g_MDLViewer->UpdateWindowMenu();
|
||
|
||
}
|
||
}
|
||
|
||
int lang_number = event->action - IDC_OPTIONS_LANGUAGESTART;
|
||
if ( lang_number >= 0 &&
|
||
lang_number < CC_NUM_LANGUAGES )
|
||
{
|
||
iret = 1;
|
||
SetCloseCaptionLanguageId( lang_number );
|
||
}
|
||
}
|
||
break;
|
||
} //switch (event->action)
|
||
} // mxEvent::Action
|
||
break;
|
||
case KeyDown:
|
||
{
|
||
//g_pMatSysWindow->handleEvent(event);
|
||
// Send it to the active tool
|
||
IFacePoserToolWindow *active = IFacePoserToolWindow::GetActiveTool();
|
||
if ( active )
|
||
{
|
||
mxWindow *w = active->GetMxWindow();
|
||
if ( w )
|
||
{
|
||
w->handleEvent( event );
|
||
}
|
||
}
|
||
else
|
||
{
|
||
g_pMatSysWindow->handleEvent(event);
|
||
}
|
||
iret = 1;
|
||
}
|
||
break;
|
||
case mxEvent::Activate:
|
||
{
|
||
if (event->action)
|
||
{
|
||
mx::setIdleWindow( g_pMatSysWindow );
|
||
// Force reload of localization data
|
||
SetCloseCaptionLanguageId( GetCloseCaptionLanguageId(), true );
|
||
}
|
||
else
|
||
{
|
||
mx::setIdleWindow( 0 );
|
||
}
|
||
iret = 1;
|
||
}
|
||
break;
|
||
} // event->event
|
||
|
||
return iret;
|
||
}
|
||
|
||
void MDLViewer::SaveWindowPositions( void )
|
||
{
|
||
// Save the model viewer position
|
||
SavePosition();
|
||
|
||
int c = IFacePoserToolWindow::GetToolCount();
|
||
for ( int i = 0; i < c; i++ )
|
||
{
|
||
IFacePoserToolWindow *w = IFacePoserToolWindow::GetTool( i );
|
||
w->SavePosition();
|
||
}
|
||
}
|
||
|
||
void MDLViewer::LoadWindowPositions( void )
|
||
{
|
||
// NOTE: Don't do this here, we do the mdlviewer position earlier in startup
|
||
// LoadPosition();
|
||
|
||
int w = this->w();
|
||
int h = this->h();
|
||
|
||
g_viewerSettings.width = w;
|
||
g_viewerSettings.height = h;
|
||
|
||
int c = IFacePoserToolWindow::GetToolCount();
|
||
for ( int i = 0; i < c; i++ )
|
||
{
|
||
IFacePoserToolWindow *w = IFacePoserToolWindow::GetTool( i );
|
||
w->LoadPosition();
|
||
}
|
||
}
|
||
|
||
void
|
||
MDLViewer::redraw ()
|
||
{
|
||
}
|
||
|
||
int MDLViewer::GetCurrentFrame( void )
|
||
{
|
||
return m_nCurrentFrame;
|
||
}
|
||
|
||
void MDLViewer::Think( float dt )
|
||
{
|
||
++m_nCurrentFrame;
|
||
|
||
// Iterate across tools
|
||
IFacePoserToolWindow::ToolThink( dt );
|
||
|
||
sound->Update( dt );
|
||
|
||
bool soundscriptsdirty = AreSoundScriptsDirty();
|
||
if ( soundscriptsdirty != m_bOldSoundScriptsDirty )
|
||
{
|
||
// Update the menu item when this changes
|
||
menuFile->setEnabled(IDC_FILE_SAVESOUNDSCRIPTCHANGES, soundscriptsdirty );
|
||
}
|
||
|
||
m_bOldSoundScriptsDirty = soundscriptsdirty;
|
||
}
|
||
|
||
static int CountVisibleTools( void )
|
||
{
|
||
int i;
|
||
int c = IFacePoserToolWindow::GetToolCount();
|
||
int viscount = 0;
|
||
|
||
for ( i = 0; i < c; i++ )
|
||
{
|
||
IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
|
||
mxWindow *w = tool->GetMxWindow();
|
||
if ( !w->isVisible() )
|
||
continue;
|
||
|
||
viscount++;
|
||
}
|
||
|
||
return viscount;
|
||
}
|
||
|
||
void MDLViewer::OnCascade()
|
||
{
|
||
int i;
|
||
int c = IFacePoserToolWindow::GetToolCount();
|
||
int viscount = CountVisibleTools();
|
||
|
||
int x = 0, y = 0;
|
||
|
||
int offset = 20;
|
||
|
||
int wide = workspace->w2() - viscount * offset;
|
||
int tall = ( workspace->h2() - viscount * offset ) / 2;
|
||
|
||
for ( i = 0; i < c; i++ )
|
||
{
|
||
IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
|
||
mxWindow *w = tool->GetMxWindow();
|
||
if ( !w->isVisible() )
|
||
continue;
|
||
|
||
w->setBounds( x, y, wide, tall );
|
||
x += offset;
|
||
y += offset;
|
||
}
|
||
}
|
||
|
||
void MDLViewer::OnTile()
|
||
{
|
||
int c = CountVisibleTools();
|
||
|
||
int rows = (int)sqrt( ( float )c );
|
||
rows = clamp( rows, 1, rows );
|
||
|
||
int cols = 1;
|
||
while ( rows * cols < c )
|
||
{
|
||
cols++;
|
||
}
|
||
|
||
DoTile( rows, cols );
|
||
}
|
||
|
||
void MDLViewer::OnTileHorizontally()
|
||
{
|
||
int c = CountVisibleTools();
|
||
|
||
DoTile( c, 1 );
|
||
}
|
||
|
||
void MDLViewer::OnTileVertically()
|
||
{
|
||
int c = CountVisibleTools();
|
||
|
||
DoTile( 1, c );
|
||
}
|
||
|
||
void MDLViewer::OnHideAll()
|
||
{
|
||
int c = IFacePoserToolWindow::GetToolCount();
|
||
for ( int i = 0; i < c; i++ )
|
||
{
|
||
IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
|
||
mxWindow *w = tool->GetMxWindow();
|
||
|
||
w->setVisible( false );
|
||
}
|
||
|
||
UpdateWindowMenu();
|
||
}
|
||
|
||
void MDLViewer::OnShowAll()
|
||
{
|
||
int c = IFacePoserToolWindow::GetToolCount();
|
||
for ( int i = 0; i < c; i++ )
|
||
{
|
||
IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( i );
|
||
mxWindow *w = tool->GetMxWindow();
|
||
|
||
w->setVisible( true );
|
||
}
|
||
|
||
UpdateWindowMenu();
|
||
}
|
||
|
||
void MDLViewer::DoTile( int x, int y )
|
||
{
|
||
int c = IFacePoserToolWindow::GetToolCount();
|
||
|
||
if ( x < 1 )
|
||
x = 1;
|
||
if ( y < 1 )
|
||
y = 1;
|
||
|
||
int wide = workspace->w2() / y;
|
||
int tall = workspace->h2() / x;
|
||
|
||
int obj = 0;
|
||
|
||
for ( int row = 0 ; row < x ; row++ )
|
||
{
|
||
for ( int col = 0; col < y; col++ )
|
||
{
|
||
bool found = false;
|
||
while ( 1 )
|
||
{
|
||
if ( obj >= c )
|
||
break;
|
||
|
||
IFacePoserToolWindow *tool = IFacePoserToolWindow::GetTool( obj++ );
|
||
mxWindow *w = tool->GetMxWindow();
|
||
if ( w->isVisible() )
|
||
{
|
||
w->setBounds( col * wide, row * tall, wide, tall );
|
||
|
||
found = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if ( !found )
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose: Not used by faceposer
|
||
// Output : int
|
||
//-----------------------------------------------------------------------------
|
||
int MDLViewer::GetCurrentHitboxSet(void)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Purpose:
|
||
// Output : Returns true on success, false on failure.
|
||
//-----------------------------------------------------------------------------
|
||
bool MDLViewer::PaintBackground( void )
|
||
{
|
||
CChoreoWidgetDrawHelper drawHelper( this );
|
||
|
||
RECT rc;
|
||
drawHelper.GetClientRect( rc );
|
||
|
||
drawHelper.DrawFilledRect( COLOR_CHOREO_BACKGROUND, rc );
|
||
return false;
|
||
}
|
||
|
||
void MDLViewer::OnRebuildScenesImage()
|
||
{
|
||
g_pProgressDialog->Start( "Rebuilding scenes.image", "", false );
|
||
|
||
CUtlBuffer targetBuffer;
|
||
|
||
bool bLittleEndian = true;
|
||
|
||
const char *pFilename = bLittleEndian ? "scenes/scenes.image" : "scenes/scenes.360.image";
|
||
|
||
CP4AutoEditAddFile checkout( CFmtStr( "%s%s", gamedir, pFilename ) );
|
||
|
||
bool bSuccess = g_pSceneImage->CreateSceneImageFile( targetBuffer, gamedir, bLittleEndian, false, this );
|
||
if ( bSuccess )
|
||
{
|
||
scriptlib->WriteBufferToFile( pFilename, targetBuffer, WRITE_TO_DISK_ALWAYS );
|
||
}
|
||
|
||
g_pProgressDialog->Finish();
|
||
m_bVCDSaved = false;
|
||
}
|
||
|
||
void MDLViewer::UpdateStatus( char const *pchSceneName, bool bQuiet, int nIndex, int nCount )
|
||
{
|
||
g_pProgressDialog->UpdateText( pchSceneName );
|
||
g_pProgressDialog->Update( (float)nIndex / (float)nCount );
|
||
}
|
||
|
||
void MDLViewer::OnVCDSaved()
|
||
{
|
||
m_bVCDSaved = true;
|
||
}
|
||
|
||
SpewRetval_t HLFacePoserSpewFunc( 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;
|
||
|
||
case SPEW_LOG:
|
||
g_bInError = false;
|
||
return SPEW_CONTINUE;
|
||
|
||
case SPEW_WARNING:
|
||
Con_ErrorPrintf( pMsg );
|
||
g_bInError = false;
|
||
return SPEW_CONTINUE;
|
||
|
||
default:
|
||
Con_Printf(pMsg);
|
||
g_bInError = false;
|
||
#ifdef _DEBUG
|
||
return spewType == SPEW_ASSERT ? SPEW_DEBUGGER : SPEW_CONTINUE;
|
||
#else
|
||
return SPEW_CONTINUE;
|
||
#endif
|
||
}
|
||
}
|
||
|
||
void MDLViewer::OnSaveSoundScriptChanges()
|
||
{
|
||
if ( !AreSoundScriptsDirty() )
|
||
{
|
||
return;
|
||
}
|
||
|
||
// Save any changed sound script files
|
||
int c = soundemitter->GetNumSoundScripts();
|
||
for ( int i = 0; i < c; i++ )
|
||
{
|
||
if ( !soundemitter->IsSoundScriptDirty( i ) )
|
||
continue;
|
||
|
||
char const *scriptname = soundemitter->GetSoundScriptName( i );
|
||
if ( !scriptname )
|
||
continue;
|
||
|
||
if ( !filesystem->FileExists( scriptname ) )
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if ( !filesystem->IsFileWritable( scriptname ) )
|
||
{
|
||
mxMessageBox( NULL, va( "Can't save changes to sound script '%s', file is READ-ONLY?", scriptname ), g_appTitle, MX_MB_OK );
|
||
continue;
|
||
}
|
||
|
||
int retval = mxMessageBox( NULL, va( "Save changes to sound script '%s'?", scriptname ), g_appTitle, MX_MB_YESNOCANCEL );
|
||
if ( retval == 2 )
|
||
{
|
||
return;
|
||
}
|
||
|
||
if ( retval == 0 )
|
||
{
|
||
soundemitter->SaveChangesToSoundScript( i );
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// The application object
|
||
//-----------------------------------------------------------------------------
|
||
class CHLFacePoserApp : public CTier3SteamApp
|
||
{
|
||
typedef CTier3SteamApp BaseClass;
|
||
|
||
public:
|
||
// Methods of IApplication
|
||
virtual bool Create();
|
||
virtual bool PreInit();
|
||
virtual int Main();
|
||
virtual void PostShutdown();
|
||
virtual void Destroy();
|
||
|
||
private:
|
||
// Sets up the search paths
|
||
bool SetupSearchPaths();
|
||
};
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Create all singleton systems
|
||
//-----------------------------------------------------------------------------
|
||
bool CHLFacePoserApp::Create()
|
||
{
|
||
// Save some memory so engine/hammer isn't so painful
|
||
CommandLine()->AppendParm( "-disallowhwmorph", NULL );
|
||
|
||
SpewOutputFunc( HLFacePoserSpewFunc );
|
||
|
||
AppSystemInfo_t appSystems[] =
|
||
{
|
||
{ "inputsystem.dll", INPUTSYSTEM_INTERFACE_VERSION },
|
||
{ "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 },
|
||
{ "vguimatsurface.dll", VGUI_SURFACE_INTERFACE_VERSION },
|
||
{ "vgui2.dll", VGUI_IVGUI_INTERFACE_VERSION },
|
||
{ "soundemittersystem.dll", SOUNDEMITTERSYSTEM_INTERFACE_VERSION },
|
||
{ "", "" } // Required to terminate the list
|
||
};
|
||
|
||
if ( !AddSystems( appSystems ) )
|
||
return false;
|
||
|
||
// Add the P4 module separately so that if it is absent (say in the SDK) then the other system will initialize properly
|
||
AppModule_t p4Module = LoadModule( "p4lib.dll" );
|
||
if ( p4Module != APP_MODULE_INVALID )
|
||
{
|
||
AddSystem( p4Module, P4_INTERFACE_VERSION );
|
||
}
|
||
|
||
g_Factory = GetFactory();
|
||
|
||
IMaterialSystem* pMaterialSystem = (IMaterialSystem*)FindSystem( MATERIAL_SYSTEM_INTERFACE_VERSION );
|
||
if ( !pMaterialSystem )
|
||
{
|
||
Warning( "Material System interface could not be found!\n" );
|
||
return false;
|
||
}
|
||
|
||
const char *pShaderDLL = CommandLine()->ParmValue("-shaderdll");
|
||
if(!pShaderDLL)
|
||
{
|
||
pShaderDLL = "shaderapidx9.dll";
|
||
}
|
||
pMaterialSystem->SetShaderAPI( pShaderDLL );
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
void CHLFacePoserApp::Destroy()
|
||
{
|
||
}
|
||
|
||
|
||
const char *GetGameDirectory()
|
||
{
|
||
// TODO: get rid of this and ONLY use the filesystem, so hlfaceposer works nicely for
|
||
// mods that get the base game resources from the Steam filesystem.
|
||
return gamedir;
|
||
}
|
||
|
||
char const *GetGameDirectorySimple()
|
||
{
|
||
return gamedirsimple;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Sets up the game path
|
||
//-----------------------------------------------------------------------------
|
||
bool CHLFacePoserApp::SetupSearchPaths()
|
||
{
|
||
// Add paths...
|
||
if ( !BaseClass::SetupSearchPaths( NULL, false, true ) )
|
||
return false;
|
||
|
||
// Set gamedir.
|
||
Q_MakeAbsolutePath( gamedir, sizeof( gamedir ), GetGameInfoPath() );
|
||
|
||
Q_FileBase( gamedir, gamedirsimple, sizeof( gamedirsimple ) );
|
||
|
||
Q_AppendSlash( gamedir, sizeof( gamedir ) );
|
||
|
||
workspacefiles->Init( GetGameDirectorySimple() );
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// Init, shutdown
|
||
//-----------------------------------------------------------------------------
|
||
bool CHLFacePoserApp::PreInit( )
|
||
{
|
||
if ( !BaseClass::PreInit() )
|
||
return false;
|
||
|
||
g_pFileSystem = filesystem = g_pFullFileSystem;
|
||
g_pStudioDataCache = (IStudioDataCache*)FindSystem( STUDIO_DATA_CACHE_INTERFACE_VERSION );
|
||
physcollision = (IPhysicsCollision *)FindSystem( VPHYSICS_COLLISION_INTERFACE_VERSION );
|
||
physprop = (IPhysicsSurfaceProps *)FindSystem( VPHYSICS_SURFACEPROPS_INTERFACE_VERSION );
|
||
g_pLocalize = (vgui::ILocalize *)FindSystem(VGUI_LOCALIZE_INTERFACE_VERSION );
|
||
soundemitter = (ISoundEmitterSystemBase*)FindSystem(SOUNDEMITTERSYSTEM_INTERFACE_VERSION);
|
||
|
||
if ( !soundemitter || !g_pLocalize || !filesystem || !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 );
|
||
filesystem->SetWarningFunc( Warning );
|
||
|
||
// Add paths...
|
||
if ( !SetupSearchPaths() )
|
||
return false;
|
||
|
||
// Get the adapter from the command line....
|
||
const char *pAdapterString;
|
||
int nAdapter = 0;
|
||
if (CommandLine()->CheckParm( "-adapter", &pAdapterString ))
|
||
{
|
||
nAdapter = atoi( pAdapterString );
|
||
}
|
||
|
||
int adapterFlags = MATERIAL_INIT_ALLOCATE_FULLSCREEN_TEXTURE;
|
||
if ( CommandLine()->CheckParm( "-ref" ) )
|
||
{
|
||
adapterFlags |= MATERIAL_INIT_REFERENCE_RASTERIZER;
|
||
}
|
||
|
||
g_pMaterialSystem->SetAdapter( nAdapter, adapterFlags );
|
||
|
||
LoadFileSystemDialogModule();
|
||
|
||
return true;
|
||
}
|
||
|
||
void CHLFacePoserApp::PostShutdown()
|
||
{
|
||
UnloadFileSystemDialogModule();
|
||
|
||
g_pFileSystem = filesystem = NULL;
|
||
g_pStudioDataCache = NULL;
|
||
physcollision = NULL;
|
||
physprop = NULL;
|
||
|
||
BaseClass::PostShutdown();
|
||
|
||
g_Factory = NULL;
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------
|
||
// main application
|
||
//-----------------------------------------------------------------------------
|
||
int CHLFacePoserApp::Main()
|
||
{
|
||
// Do Perforce Stuff
|
||
g_p4factory->SetDummyMode( false );
|
||
if ( CommandLine()->FindParm( "-nop4" ) || !p4 )
|
||
{
|
||
g_p4factory->SetDummyMode( true );
|
||
}
|
||
|
||
g_p4factory->SetOpenFileChangeList( "FacePoser Auto Checkout" );
|
||
|
||
soundemitter->ModInit();
|
||
g_pMaterialSystem->ModInit();
|
||
|
||
g_pDataCache->SetSize( 64 * 1024 * 1024 );
|
||
|
||
// Always start with english
|
||
g_pLocalize->AddFile( "resource/closecaption_english.txt", "GAME", true );
|
||
|
||
sound->Init();
|
||
|
||
IFacePoserToolWindow::EnableToolRedraw( false );
|
||
|
||
g_MDLViewer = new MDLViewer ();
|
||
g_MDLViewer->setMenuBar (g_MDLViewer->getMenuBar ());
|
||
|
||
FaceposerVGui()->Init( (HWND)g_MDLViewer->getHandle() );
|
||
|
||
// Force reload of close captioning data file!!!
|
||
SetCloseCaptionLanguageId( g_viewerSettings.cclanguageid, true );
|
||
|
||
g_pStudioModel->Init();
|
||
|
||
int i;
|
||
bool modelloaded = false;
|
||
for ( i = 1; i < CommandLine()->ParmCount(); i++ )
|
||
{
|
||
if ( Q_stristr (CommandLine()->GetParm( i ), ".mdl") )
|
||
{
|
||
modelloaded = true;
|
||
g_MDLViewer->LoadModelFile( CommandLine()->GetParm( i ) );
|
||
break;
|
||
}
|
||
}
|
||
|
||
models->LoadModelList();
|
||
g_pPhonemeEditor->ValidateSpeechAPIIndex();
|
||
|
||
if ( models->Count() == 0 )
|
||
{
|
||
g_pFlexPanel->initFlexes( );
|
||
}
|
||
|
||
// Load expressions from last time
|
||
int files = workspacefiles->GetNumStoredFiles( IWorkspaceFiles::EXPRESSION );
|
||
for ( i = 0; i < files; i++ )
|
||
{
|
||
expressions->LoadClass( workspacefiles->GetStoredFile( IWorkspaceFiles::EXPRESSION, i ) );
|
||
}
|
||
|
||
IFacePoserToolWindow::EnableToolRedraw( true );
|
||
|
||
int nRetVal = mx::run ();
|
||
|
||
if (g_pStudioModel)
|
||
{
|
||
g_pStudioModel->Shutdown();
|
||
g_pStudioModel = NULL;
|
||
}
|
||
|
||
g_pMaterialSystem->ModShutdown();
|
||
soundemitter->ModShutdown();
|
||
g_pMaterialSystem->ModShutdown();
|
||
|
||
FaceposerVGui()->Shutdown();
|
||
|
||
return nRetVal;
|
||
}
|
||
|
||
static bool CHLFacePoserApp_SuggestGameInfoDirFn( CFSSteamSetupInfo const *pFsSteamSetupInfo, char *pchPathBuffer, int nBufferLength, bool *pbBubbleDirectories )
|
||
{
|
||
if ( pbBubbleDirectories )
|
||
*pbBubbleDirectories = true;
|
||
|
||
for ( int i = 1; i < CommandLine()->ParmCount(); i++ )
|
||
{
|
||
if ( Q_stristr( CommandLine()->GetParm( i ), ".mdl" ) )
|
||
{
|
||
Q_MakeAbsolutePath( pchPathBuffer, nBufferLength, CommandLine()->GetParm( i ) );
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
int main (int argc, char *argv[])
|
||
{
|
||
CommandLine()->CreateCmdLine( argc, argv );
|
||
CoInitialize(NULL);
|
||
|
||
// make sure, we start in the right directory
|
||
char szName[256];
|
||
strcpy (szName, mx::getApplicationPath() );
|
||
mx::init (argc, argv);
|
||
|
||
char workingdir[ 256 ];
|
||
workingdir[0] = 0;
|
||
Q_getwd( workingdir, sizeof( workingdir ) );
|
||
|
||
// Set game info directory suggestion callback
|
||
SetSuggestGameInfoDirFn( CHLFacePoserApp_SuggestGameInfoDirFn );
|
||
|
||
CHLFacePoserApp hlFacePoserApp;
|
||
CSteamApplication steamApplication( &hlFacePoserApp );
|
||
int nRetVal = steamApplication.Run();
|
||
|
||
CoUninitialize();
|
||
|
||
return nRetVal;
|
||
}
|
||
|