source-engine/vgui2/matsys_controls/QCGenerator.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================

#if defined(WIN32) && !defined( _X360 )
#include <windows.h>
#endif
#include "filesystem.h"
#include "filesystem_init.h"
#include "appframework/IAppSystemGroup.h"
#include "appframework/IAppSystem.h"
#include "appframework/AppFramework.h"
#include "filesystem_helpers.h"

#include "matsys_controls/QCGenerator.h"
#include "tier1/KeyValues.h"
#include "tier2/vconfig.h"
#include "vgui_controls/ListPanel.h"
#include "vgui_controls/TextEntry.h"
#include "vgui_controls/Button.h"
#include "vgui_controls/FileOpenDialog.h"
#include "vgui_controls/DirectorySelectDialog.h"
#include "vgui_controls/ComboBox.h"
#include "vgui_controls/CheckButton.h"
#include "vgui_controls/MessageBox.h"
#include "vgui/ISurface.h"
#include "vgui/IInput.h"
#include "vgui/Cursor.h"
#include "vgui_controls/KeyBoardEditorDialog.h"

#if defined( _X360 )
#include "xbox/xbox_win32stubs.h"
#endif

using namespace vgui;

#define MAX_KEYVALUE	1024


//-----------------------------------------------------------------------------
// Purpose: returns a pointer to the 'count' occurence of a character from the end of a string
//			returns 0 of there aren't 'count' number of the character in the string
//-----------------------------------------------------------------------------
char *strrchrcount(char *string, int character, int count )
{
	int j = count;
	int numChars = strlen( string );
	for( int i = numChars; i > 0; i-- )
	{
		if( string[i-1] == character )
		{
			j--;
		}
		if( j == 0 )
		{
			return string + i-1;
		}
	}
	return 0;
}



class CModalPreserveMessageBox : public vgui::MessageBox
{
public:
	CModalPreserveMessageBox(const char *title, const char *text, vgui::Panel *parent)
		: vgui::MessageBox( title, text, parent )
	{
		m_PrevAppFocusPanel = vgui::input()->GetAppModalSurface();
	}

	~CModalPreserveMessageBox()
	{
		vgui::input()->SetAppModalSurface( m_PrevAppFocusPanel );
	}


public:
	vgui::VPANEL	m_PrevAppFocusPanel;
};

void VGUIMessageBox( vgui::Panel *pParent, const char *pTitle, const char *pMsg, ... )
{
	char msg[4096];
	va_list marker;
	va_start( marker, pMsg );
	Q_vsnprintf( msg, sizeof( msg ), pMsg, marker );
	va_end( marker );

	vgui::MessageBox *dlg = new CModalPreserveMessageBox( pTitle, msg, pParent );
	dlg->DoModal();
	dlg->Activate();
	dlg->RequestFocus();
}


//-----------------------------------------------------------------------------
// Purpose: Places all the info from the vgui controls into the QCInfo struct
//-----------------------------------------------------------------------------
void QCInfo::SyncFromControls()
{
	char tempText[MAX_PATH];
	
	vgui::Panel *pTargetField = pQCGenerator->FindChildByName( "staticPropCheck" );
	bStaticProp = ((CheckButton *)pTargetField)->IsSelected();
	 
	pTargetField = pQCGenerator->FindChildByName( "mostlyOpaqueCheck" );
	bMostlyOpaque = ((CheckButton *)pTargetField)->IsSelected();

	pTargetField = pQCGenerator->FindChildByName( "disableCollisionsCheck" );
	bDisableCollision = ((CheckButton *)pTargetField)->IsSelected();

	pTargetField = pQCGenerator->FindChildByName( "referencePhysicsCheck" );
	bReferenceAsPhys = ((CheckButton *)pTargetField)->IsSelected();

	pTargetField = pQCGenerator->FindChildByName( "concaveCheck" );
	bConcave = ((CheckButton *)pTargetField)->IsSelected();

	pTargetField = pQCGenerator->FindChildByName( "automassCheck" );
	bAutomass = ((CheckButton *)pTargetField)->IsSelected();

	pTargetField = pQCGenerator->FindChildByName( "massField" );
	((TextEntry *)pTargetField)->GetText(tempText, MAX_PATH);
	fMass = atof(tempText);

	pTargetField = pQCGenerator->FindChildByName( "scaleField" );
	((TextEntry *)pTargetField)->GetText(tempText, MAX_PATH);
	fScale = atof(tempText);

    pTargetField = pQCGenerator->FindChildByName( "collisionSMDField" );
	((TextEntry *)pTargetField)->GetText( tempText, MAX_PATH );	
	V_strcpy_safe( pszCollisionPath, tempText );

	pTargetField = pQCGenerator->FindChildByName( "surfacePropertyDropDown" );
	((ComboBox *)pTargetField)->GetText( tempText, MAX_PATH );
    V_strcpy_safe( pszSurfaceProperty, tempText );

	pTargetField = pQCGenerator->FindChildByName( "materialsField" );
	((TextEntry *)pTargetField)->GetText( tempText, MAX_PATH );
	V_strcpy_safe( pszMaterialPath, tempText );

	LODs.RemoveAll();
	pTargetField = pQCGenerator->FindChildByName( "LODList" );
	int numLOD = ((ListPanel *)pTargetField)->GetItemCount();
	for ( int i = 0; i < numLOD; i++ )
	{
		KeyValues *key = ((ListPanel *)pTargetField)->GetItem( i );
		LODInfo newLOD;

		V_strcpy_safe( newLOD.pszFilename, key->GetString( "SMD" ) );
		newLOD.iLOD = key->GetInt( "LOD" );		
        LODs.AddToTail( newLOD );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Called during intialization to setup the initial state of the VGUI controls
//-----------------------------------------------------------------------------
void QCInfo::SyncToControls()
{
	char tempText[MAX_PATH];
	
	vgui::Panel *pTargetField = pQCGenerator->FindChildByName( "staticPropCheck" );
	((CheckButton *)pTargetField)->SetSelected( bStaticProp );
	 
	pTargetField = pQCGenerator->FindChildByName( "mostlyOpaqueCheck" );
	((CheckButton *)pTargetField)->SetSelected( bMostlyOpaque );

	pTargetField = pQCGenerator->FindChildByName( "disableCollisionsCheck" );
	((CheckButton *)pTargetField)->SetSelected( bDisableCollision );

	pTargetField = pQCGenerator->FindChildByName( "referencePhysicsCheck" );
	((CheckButton *)pTargetField)->SetSelected( bReferenceAsPhys );

	pTargetField = pQCGenerator->FindChildByName( "concaveCheck" );
	((CheckButton *)pTargetField)->SetSelected( bConcave );

	pTargetField = pQCGenerator->FindChildByName( "automassCheck" );
	((CheckButton *)pTargetField)->SetSelected( bAutomass );

	Q_snprintf( tempText, 10, "%d", (int)fMass );
	pTargetField = pQCGenerator->FindChildByName( "massField" );
	((TextEntry *)pTargetField)->SetText( tempText );

	Q_snprintf( tempText, 10, "%d", (int)fScale );
	pTargetField = pQCGenerator->FindChildByName( "scaleField" );
	((TextEntry *)pTargetField)->SetText( tempText );

	pTargetField = pQCGenerator->FindChildByName( "collisionSMDField" );
	((TextEntry *)pTargetField)->SetText( pszCollisionPath );

	pTargetField = pQCGenerator->FindChildByName( "materialsField" );
	((TextEntry *)pTargetField)->SetText( pszMaterialPath );

	pTargetField = pQCGenerator->FindChildByName( "surfacePropertyDropDown" );
	int numItems = ((ComboBox *)pTargetField)->GetItemCount();
	for( int i = 0; i < numItems; i++ )
	{
		((ComboBox *)pTargetField)->GetItemText( i, tempText, MAX_PATH );
		if ( !Q_strcmp( tempText, pszSurfaceProperty ) )
		{
			((ComboBox *)pTargetField)->SetItemEnabled( i, true );
			((ComboBox *)pTargetField)->SetText( tempText );
			break;
		}
	}   
}

CBrowseButton::CBrowseButton( vgui::Panel *pParent ) : BaseClass( pParent, "Browse Button", "...", pParent, "browse" )
{	
	SetParent( pParent );
	pszStartingDirectory = NULL;
	pszFileFilter = NULL;
	pszTargetField = NULL;
}

CBrowseButton::~CBrowseButton()
{
}

void CBrowseButton::SetCharVar( char **pVar, const char *pszNewText )
{
	if ( *pVar && pszNewText && !Q_strcmp( *pVar, pszNewText ) )
	{
		return;
	}

    if ( *pVar )
	{
		delete [] *pVar;
		*pVar = NULL;
	}

	if ( pszNewText )
	{
		int len = Q_strlen( pszNewText ) + 1;
		*pVar = new char[ len ];
		Q_strncpy( *pVar, pszNewText, len );
	}
}

void CBrowseButton::InitBrowseInfo( int x, int y, const char *pszName, const char *pszDir, const char *pszFilter, const char *pszField )
{
	SetSize( 24, 24 );
	SetPos( x, y );
	SetName( pszName );
	SetCharVar( GetStartingDirectory(), pszDir );
	SetCharVar( GetFileFilter(), pszFilter );
	SetCharVar( GetTargetField(), pszField );
	SetActionMessage();	
}

void CBrowseButton::SetActionMessage()
{
	KeyValues *newActionMessage = new KeyValues( "browse", "directory", pszStartingDirectory, "filter", pszFileFilter);
	newActionMessage->SetString( "targetField", pszTargetField );
	SetCommand( newActionMessage );
}

const char *ParseKeyvalue( const char *pBuffer, char *key, char *value )
{
	char com_token[1024];

	pBuffer = (const char *)ParseFile( pBuffer, com_token, NULL );
	if ( Q_strlen( com_token ) < MAX_KEYVALUE )
	{
		Q_strncpy( key, com_token, MAX_KEYVALUE );
		Q_strlower( key );
	}
	// no value on a close brace
	if ( !Q_strcmp( key, "}" ) )
	{
		value[0] = 0;
		return pBuffer;
	}

	pBuffer = (const char *)ParseFile( pBuffer, com_token, NULL );
	if ( Q_strlen( com_token ) < MAX_KEYVALUE )
	{
		Q_strncpy( value, com_token, MAX_KEYVALUE );
		Q_strlower( value );
	}

	return pBuffer;
}

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CQCGenerator::CQCGenerator( vgui::Panel *pParent, const char *pszPath, const char *pszScene ) : BaseClass( pParent, "QCGenerator" )
{	
	m_QCInfo_t.Init( this );

	SetMinimumSize(846, 770);

	m_pLODPanel = new ListPanel(this, "LODList");
	m_pLODPanel->SetSelectIndividualCells( true );
	m_pLODPanel->AddColumnHeader(0, "SMD", "LOD SMD", 450, 0);	
	m_pLODPanel->AddColumnHeader(1, "LOD", "LOD Distance", 50, 0);		
	m_pLODPanel->AddActionSignalTarget( this );
	m_pLODPanel->SetMouseInputEnabled( true );

	LoadControlSettings( "QCGenerator.res" );	

	m_pCollisionBrowseButton = new CBrowseButton( this );
	m_pCollisionBrowseButton->InitBrowseInfo( 808, 158, "collisionBrowseButton", pszPath, "*.smd", "collisionSMDField" );

	char szTerminatedPath[1024] = "\0";
	sprintf( szTerminatedPath, "%s\\", pszPath );
	
	InitializeSMDPaths( szTerminatedPath, pszScene );

	char *pszMaterialsStart = strrchrcount( szTerminatedPath, '\\', 3 ) + 1;
	char *pszMaterialsEnd = strrchr( szTerminatedPath, '\\');
	Q_strncpy( m_QCInfo_t.pszMaterialPath, pszMaterialsStart, pszMaterialsEnd - pszMaterialsStart + 1 );

	SetParent( pParent );

	char szGamePath[1024] = "\0";
	char szSearchPath[1024] = "\0";

	// Get the currently set game configuration
	GetVConfigRegistrySetting( GAMEDIR_TOKEN, szGamePath, sizeof( szGamePath ) );	
	static const char *pSurfacePropFilename = "\\scripts\\surfaceproperties.txt";

	sprintf( szSearchPath, "%s%s", szGamePath, pSurfacePropFilename );

	FileHandle_t fp = g_pFullFileSystem->Open( szSearchPath, "rb" );	 

	if ( !fp )
	{
		//the set game configuration didn't have a surfaceproperties file; we are grabbing it from hl2
		//TODO:  This only works if they are in a subdirectory that is a peer to an hl2 directory 
		//		that contains the file.  It potentially needs to search the entire drive or prompt for the location
		char *pszEndGamePath = Q_strrchr( szGamePath, '\\' );
		pszEndGamePath[0] = 0;
		V_strcat_safe( szGamePath, "\\hl2" );
		sprintf( szSearchPath, "%s%s", szGamePath, pSurfacePropFilename );
		fp = g_pFullFileSystem->Open( szSearchPath, "rb" );	
	}

	int len = g_pFullFileSystem->Size( fp );

	const char *szSurfacePropContents = new char[len+1];
	g_pFullFileSystem->Read( (void *)szSurfacePropContents, len, fp );

	char key[MAX_KEYVALUE], value[MAX_KEYVALUE];

	vgui::Panel *pSurfacePropDropDown = FindChildByName( "surfacePropertyDropDown" );		

	//filling up the surface property dropdown
	while ( szSurfacePropContents )
	{
		szSurfacePropContents = ParseKeyvalue( szSurfacePropContents, key, value );
		((ComboBox *)pSurfacePropDropDown)->AddItem( key, NULL );							
		while ( szSurfacePropContents )
		{
			szSurfacePropContents = ParseKeyvalue( szSurfacePropContents, key, value );
			if (!stricmp( key, "}" ) )
			{
				break;
			}
		}
	}	
    m_QCInfo_t.SyncToControls();

	m_pLODEdit = 0;
}

//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CQCGenerator::~CQCGenerator()
{
}

void CQCGenerator::OnCommand( const char *command )
{	
	if ( Q_stricmp( command, "createQC" ) == 0 )
	{
		m_QCInfo_t.SyncFromControls();
		GenerateQCFile();
	}
	if ( Q_stricmp( command, "deleteSeq" ) == 0 )
	{
		//delete it
		DeleteLOD();
	}
	if ( Q_stricmp( command, "editSeq" ) == 0 )
	{
		//edit
		EditLOD();
	}
	
	BaseClass::OnCommand( command );
}


void CQCGenerator::OnKeyCodeTyped( KeyCode code )
{
	switch ( code )
	{
	case KEY_ENTER:
			EditLOD();
	}
}
	

void CQCGenerator::OnBrowse( KeyValues *data )
{
    V_strcpy_safe( m_szTargetField, data->GetString( "targetField" ) );
	const char *filter = data->GetString( "filter" );
	
	if ( Q_strlen( filter ) == 0 )
	{
//		BrowseDirectory( data );
	}
	else
	{
		BrowseFile( data );	
	}
}

/*
//This function is no longer used in the current version of the program.
void CQCGenerator::BrowseDirectory( KeyValues *data )
{
	DirectorySelectDialog *pDialog = new DirectorySelectDialog( this, "Select Directory" );
	pDialog->AddActionSignalTarget( this );
	pDialog->DoModal();
	pDialog->SetStartDirectory( data->GetString( "directory" ) );	
}
*/

void CQCGenerator::BrowseFile( KeyValues *data )
{	    
	const char *filter = data->GetString( "filter" );

	FileOpenDialog *pDialog = new FileOpenDialog( this, "Select File", true );
	pDialog->AddFilter( filter, filter, true );
	pDialog->AddActionSignalTarget(this);
	pDialog->SetStartDirectory( data->GetString( "directory" ) );	
	pDialog->DoModal( true );
}

void CQCGenerator::OnFileSelected( KeyValues *data ) 
{
	if ( m_szTargetField )
	{
		vgui::Panel *pTargetField = FindChildByName( m_szTargetField );
		((TextEntry *)pTargetField)->SetText( data->GetString( "fullpath" ) );
		Repaint();
	}
}

void CQCGenerator::OnDirectorySelected( KeyValues *data ) 
{
	if ( m_szTargetField )
	{
		vgui::Panel *pTargetField = FindChildByName( m_szTargetField );
		((TextEntry *)pTargetField)->SetText( data->GetString( "dir" ) );
		Repaint();
	}
}

bool CQCGenerator::GenerateQCFile()
{
	//TODO: clean this up.  Consider creating a datatype that includes the string to write out when the QC file is created
	char *nameBegin = strrchr( m_QCInfo_t.pszSMDPath, '\\' );

	char szPath[MAX_PATH];
	char szName[MAX_PATH];
	Q_strncpy( szPath, m_QCInfo_t.pszSMDPath, nameBegin - m_QCInfo_t.pszSMDPath + 2 );
	V_strcpy_safe( szName, szPath);
	V_strcat_safe( szName, m_QCInfo_t.pszSceneName);
	V_strcat_safe( szName, ".qc" );
	FileHandle_t pSaveFile = g_pFullFileSystem->Open( szName, "wt" );
	if (!pSaveFile)
	{
		char szSaveError[1024] = "";
		Q_snprintf( szSaveError, 1024, "Save failed: invalid file name '%s'\n\nDirectory '%s' must exist.", szName, szPath );	
		VGUIMessageBox( this, "QC Generator error", szSaveError );
		return 0;
	}	
		
	//write qc header
	g_pFullFileSystem->FPrintf( pSaveFile, "//\n// .qc file version 1.0\n\n");
	//write out modelname info
	char szModelName[MAX_PATH];
	char *modelStart = strrchrcount( szName, '\\', 2) + 1;
	char *modelEnd = strrchr( szName, '.' );
	Q_strncpy( szModelName, modelStart, modelEnd - modelStart + 1 );
	V_strcat_safe( szModelName, ".mdl" );
	g_pFullFileSystem->FPrintf( pSaveFile, "$modelname %s\n\n", szModelName );
	//write out scale info
	g_pFullFileSystem->FPrintf( pSaveFile, "$scale %f\n", m_QCInfo_t.fScale );
	//write out body info
	g_pFullFileSystem->FPrintf( pSaveFile, "$body \"Body\" \"%s\"\n", strrchr( m_QCInfo_t.pszSMDPath, '\\' ) + 1 );

	if ( m_QCInfo_t.bStaticProp == true )
	{
		g_pFullFileSystem->FPrintf( pSaveFile, "$staticprop\n" );
	}

	if ( m_QCInfo_t.bMostlyOpaque == true )
	{
		g_pFullFileSystem->FPrintf( pSaveFile, "$mostlyopaque\n" );
	}

	//write out surfaceprop info
	g_pFullFileSystem->FPrintf( pSaveFile, "$surfaceprop \"%s\"\n\n", m_QCInfo_t.pszSurfaceProperty );
	//write materials

	g_pFullFileSystem->FPrintf( pSaveFile, "$cdmaterials %s\n\n", m_QCInfo_t.pszMaterialPath);

	if ( m_QCInfo_t.bStaticProp || m_QCInfo_t.bNoAnimation )
	{
		g_pFullFileSystem->FPrintf( pSaveFile, "// --------- Animation sequences -------\n");
		g_pFullFileSystem->FPrintf( pSaveFile, "$sequence  \"idle\" \"%s\" fps 30\n\n", strrchr(m_QCInfo_t.pszSMDPath, '\\')+1);
	}

	//write out lod info
	for( int i = 0; i < m_QCInfo_t.LODs.Count(); i++ )
	{
		LODInfo thisLOD = m_QCInfo_t.LODs.Element( i );
		g_pFullFileSystem->FPrintf( pSaveFile, "$lod %d\n{\n\treplacemodel \"%s\" \"%s\"\n}\n\n", thisLOD.iLOD, strrchr(m_QCInfo_t.pszSMDPath, '\\')+1, thisLOD.pszFilename );		
	}

	if ( m_QCInfo_t.bDisableCollision != true )
	{
		//write out collision header
		g_pFullFileSystem->FPrintf( pSaveFile, "\n" );
		//write out collision info
		if ( m_QCInfo_t.bReferenceAsPhys == true )
		{
			g_pFullFileSystem->FPrintf( pSaveFile, "$collisionmodel \"%s\"", strrchr( m_QCInfo_t.pszSMDPath, '\\' ) + 1 );
		}
		else 
		{
			if( Q_strcmp( m_QCInfo_t.pszCollisionPath, "" ) )
			{
				g_pFullFileSystem->FPrintf( pSaveFile, "$collisionmodel \"%s\"", strrchr( m_QCInfo_t.pszCollisionPath, '\\' ) + 1 );
			}
		}

		g_pFullFileSystem->FPrintf( pSaveFile, " {\n\t// Mass in kilograms\n ");

		if ( m_QCInfo_t.bAutomass == true )
		{
			g_pFullFileSystem->FPrintf( pSaveFile, "\t$automass\n" );
		}
		else
		{
			g_pFullFileSystem->FPrintf( pSaveFile, "\t$mass %f\n", m_QCInfo_t.fMass );
		}
		
		if ( m_QCInfo_t.bConcave == true )
		{
			g_pFullFileSystem->FPrintf( pSaveFile, "\t$concave\n" );
		}
		g_pFullFileSystem->FPrintf( pSaveFile, "}\n\n");
	}
	    	
	g_pFullFileSystem->Close( pSaveFile );

	char szCommand[MAX_PATH];
	char szGamePath[MAX_PATH];
	
	char studiomdlPath[512];
	g_pFullFileSystem->RelativePathToFullPath( "studiomdl.bat", NULL, studiomdlPath, sizeof( studiomdlPath ));

	GetVConfigRegistrySetting( GAMEDIR_TOKEN, szGamePath, sizeof( szGamePath ) );	

#ifdef WIN32
	STARTUPINFO startup; 
	PROCESS_INFORMATION process; 


	memset(&startup, 0, sizeof(startup)); 
	startup.cb = sizeof(startup); 

	
	sprintf( szCommand, "%s -game %s %s", studiomdlPath, szGamePath, szName);
	bool bReturn = CreateProcess( NULL, szCommand, NULL, NULL, TRUE, CREATE_NEW_CONSOLE, NULL, NULL, &startup, &process);
#else
	Assert( !"Implement me, why aren't we using a thread tool abstraction?" );
	bool bReturn = false;
#endif
	return bReturn;
}

void CQCGenerator::InitializeSMDPaths( const char *pszPath, const char *pszScene )
{
	V_strcpy_safe( m_QCInfo_t.pszSceneName, pszScene );

	FileFindHandle_t *pFileHandle = new FileFindHandle_t();

	g_pFullFileSystem->AddSearchPath( pszPath, "SMD_DIR" );
	
	const char *filename = g_pFullFileSystem->FindFirst( "*.smd", pFileHandle );	

	bool bFoundReference = false;
	bool bFoundCollision = false;
	bool bFoundLOD = false;

	//iterate through .smd files
  	const char *startName = pszScene;

	int nSearchLength = Q_strlen( pszScene );

	int currentLOD = 1;
	
	while( filename )
	{        
		if ( !strncmp( startName, filename, nSearchLength ) )
		{
			const char *filenameEnd = filename + nSearchLength;
			if ( !strncmp( filenameEnd, "_ref", 4 ) || !strncmp( filenameEnd, ".smd", 4 ) )
			{
				bFoundReference = true;
				//we have found the reference smd.
				V_strcpy_safe( m_QCInfo_t.pszSMDPath, pszPath );
				V_strcat_safe( m_QCInfo_t.pszSMDPath, filename );
			}
			if ( !strncmp( filenameEnd, "_phy", 4) || !strncmp( filenameEnd, "_col", 4 ) )
			{
				bFoundCollision = true;
				//we have found the collision smd.
				V_strcpy_safe( m_QCInfo_t.pszCollisionPath, pszPath );
				V_strcat_safe( m_QCInfo_t.pszCollisionPath, filename );
			}
			if ( !strncmp( filenameEnd, "_lod", 4) )
			{
				bFoundLOD = true;
				//we found an LOD smd.
				char lodName[255];
				Q_snprintf( lodName, Q_strlen( lodName ), "lod%d", currentLOD );
				//we found an LOD
				KeyValues *newKv = new KeyValues( lodName, "SMD", filename, "LOD", "10" );
				m_pLODPanel->AddItem( newKv, currentLOD, false, false );
				currentLOD++;
			}
		}
		filename = g_pFullFileSystem->FindNext( *pFileHandle );
	}
	char pszMessage[2048] = "";
	char pszRefMessage[1024] = "";
	char pszColMessage[1024] = "";
	if (!bFoundReference )
	{
		V_strcat_safe( m_QCInfo_t.pszSMDPath, pszPath );
		V_strcat_safe( m_QCInfo_t.pszSMDPath, pszScene );		
		V_strcat_safe( m_QCInfo_t.pszSMDPath, ".smd" );
		Q_snprintf( pszRefMessage, 1024, "Reference SMD not found.\n\nValid default reference SMDs are %s%s_ref*.smd and %s%s.smd\nUsing default of %s. Model will not compile.\n\n", pszPath, pszScene, pszPath, pszScene, m_QCInfo_t.pszSMDPath );		
	}
	if ( !bFoundCollision )
	{
		Q_snprintf( pszColMessage, 1024, "Collision SMD not found.\n\nThe valid default collision SMD is %s%s_phy*.smd.\nUsing reference SMD as default.\n", pszPath, pszScene );
		V_strcpy_safe( m_QCInfo_t.pszCollisionPath, m_QCInfo_t.pszSMDPath );
		m_QCInfo_t.bReferenceAsPhys = true;
	}
	if ( !bFoundReference || !bFoundCollision)
	{
		V_strcpy_safe( pszMessage, pszRefMessage );
		V_strcat_safe( pszMessage, pszColMessage );
		VGUIMessageBox( this, "Error Initializing Paths", pszMessage );
	}
}


void CQCGenerator::DeleteLOD()
{
	int numSelected = m_pLODPanel->GetSelectedItemsCount();
	int selected;
	for ( int i = numSelected-1; i >= 0; i-- )
	{
		selected = m_pLODPanel->GetSelectedItem( i );
		m_pLODPanel->RemoveItem( selected );
	}
}

void CQCGenerator::EditLOD()
{
	int numSelected = m_pLODPanel->GetSelectedItemsCount();
	if ( numSelected == 1 && !m_pLODPanel->IsInEditMode() )
	{
		if ( m_pLODEdit )
		{
			m_pLODEdit->MarkForDeletion();
			m_pLODEdit = NULL;
		}
		m_pLODEdit = new vgui::TextEntry( this, "Edit" );
		m_pLODEdit->SendNewLine( true );
		m_nSelectedSequence = m_pLODPanel->GetSelectedItem( 0 );
		m_nSelectedColumn = m_pLODPanel->GetSelectedColumn();
		m_pLODPanel->EnterEditMode( m_nSelectedSequence, m_nSelectedColumn, m_pLODEdit );
	}
}

void CQCGenerator::OnNewLODText()
{		
	KeyValues *pEditItem = m_pLODPanel->GetItem( m_nSelectedSequence );
	KeyValues *pListItem = pEditItem;
	wchar_t szEditText[MAX_PATH];

	pEditItem = pEditItem->GetFirstValue();
	const char *name = pEditItem->GetName();
	for( int i = 0; i < m_nSelectedColumn; i++ )
	{
		pEditItem = pEditItem->GetNextValue();
		name = pEditItem->GetName();
	}
	m_pLODEdit->GetText( szEditText, MAX_PATH );

	pListItem->SetWString( name, szEditText );

	m_pLODPanel->LeaveEditMode();
	m_pLODPanel->InvalidateLayout();
	return;
}