600 lines
19 KiB
C++
600 lines
19 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Singleton dialog that generates and presents the entity report.
|
|
//
|
|
//===========================================================================//
|
|
|
|
#include "particlesystemdefinitionbrowser.h"
|
|
#include "tier1/KeyValues.h"
|
|
#include "tier1/utlbuffer.h"
|
|
#include "iregistry.h"
|
|
#include "vgui/ivgui.h"
|
|
#include "vgui_controls/listpanel.h"
|
|
#include "vgui_controls/inputdialog.h"
|
|
#include "vgui_controls/messagebox.h"
|
|
#include "petdoc.h"
|
|
#include "pettool.h"
|
|
#include "datamodel/dmelement.h"
|
|
#include "vgui/keycode.h"
|
|
#include "dme_controls/dmecontrols_utils.h"
|
|
#include "dme_controls/particlesystempanel.h"
|
|
#include "filesystem.h"
|
|
#include "vgui_controls/FileOpenDialog.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include <tier0/memdbgon.h>
|
|
|
|
|
|
|
|
using namespace vgui;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Sort by particle system definition name
|
|
//-----------------------------------------------------------------------------
|
|
static int __cdecl ParticleSystemNameSortFunc( vgui::ListPanel *pPanel, const ListPanelItem &item1, const ListPanelItem &item2 )
|
|
{
|
|
const char *string1 = item1.kv->GetString("name");
|
|
const char *string2 = item2.kv->GetString("name");
|
|
return Q_stricmp( string1, string2 );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor
|
|
//-----------------------------------------------------------------------------
|
|
CParticleSystemDefinitionBrowser::CParticleSystemDefinitionBrowser( CPetDoc *pDoc, vgui::Panel* pParent, const char *pName )
|
|
: BaseClass( pParent, pName ), m_pDoc( pDoc )
|
|
{
|
|
SetKeyBoardInputEnabled( true );
|
|
SetPaintBackgroundEnabled( true );
|
|
|
|
m_pParticleSystemsDefinitions = new vgui::ListPanel( this, "ParticleSystems" );
|
|
m_pParticleSystemsDefinitions->AddColumnHeader( 0, "name", "Name", 52, ListPanel::COLUMN_RESIZEWITHWINDOW );
|
|
m_pParticleSystemsDefinitions->SetColumnSortable( 0, true );
|
|
m_pParticleSystemsDefinitions->SetEmptyListText( "No Particle System Definitions" );
|
|
m_pParticleSystemsDefinitions->AddActionSignalTarget( this );
|
|
m_pParticleSystemsDefinitions->SetSortFunc( 0, ParticleSystemNameSortFunc );
|
|
m_pParticleSystemsDefinitions->SetSortColumn( 0 );
|
|
|
|
LoadControlSettingsAndUserConfig( "resource/particlesystemdefinitionbrowser.res" );
|
|
|
|
UpdateParticleSystemList();
|
|
}
|
|
|
|
CParticleSystemDefinitionBrowser::~CParticleSystemDefinitionBrowser()
|
|
{
|
|
SaveUserConfig();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Gets the ith selected particle system
|
|
//-----------------------------------------------------------------------------
|
|
CDmeParticleSystemDefinition* CParticleSystemDefinitionBrowser::GetSelectedParticleSystem( int i )
|
|
{
|
|
int iSel = m_pParticleSystemsDefinitions->GetSelectedItem( i );
|
|
KeyValues *kv = m_pParticleSystemsDefinitions->GetItem( iSel );
|
|
return GetElementKeyValue< CDmeParticleSystemDefinition >( kv, "particleSystem" );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Deletes the marked objects.
|
|
//-----------------------------------------------------------------------------
|
|
void CParticleSystemDefinitionBrowser::DeleteParticleSystems()
|
|
{
|
|
int iSel = m_pParticleSystemsDefinitions->GetSelectedItem( 0 );
|
|
int nRow = m_pParticleSystemsDefinitions->GetItemCurrentRow( iSel ) - 1;
|
|
{
|
|
// This is undoable
|
|
CAppUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Delete Particle Systems", "Delete Particle Systems" );
|
|
|
|
//
|
|
// Build a list of objects to delete.
|
|
//
|
|
CUtlVector< CDmeParticleSystemDefinition* > itemsToDelete;
|
|
int nCount = m_pParticleSystemsDefinitions->GetSelectedItemsCount();
|
|
for (int i = 0; i < nCount; i++)
|
|
{
|
|
CDmeParticleSystemDefinition *pParticleSystem = GetSelectedParticleSystem( i );
|
|
if ( pParticleSystem )
|
|
{
|
|
itemsToDelete.AddToTail( pParticleSystem );
|
|
}
|
|
}
|
|
|
|
nCount = itemsToDelete.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
m_pDoc->DeleteParticleSystemDefinition( itemsToDelete[i] );
|
|
}
|
|
}
|
|
|
|
// Update the list box selection.
|
|
if ( m_pParticleSystemsDefinitions->GetItemCount() > 0 )
|
|
{
|
|
if ( nRow < 0 )
|
|
{
|
|
nRow = 0;
|
|
}
|
|
else if ( nRow >= m_pParticleSystemsDefinitions->GetItemCount() )
|
|
{
|
|
nRow = m_pParticleSystemsDefinitions->GetItemCount() - 1;
|
|
}
|
|
|
|
iSel = m_pParticleSystemsDefinitions->GetItemIDFromRow( nRow );
|
|
m_pParticleSystemsDefinitions->SetSingleSelectedItem( iSel );
|
|
}
|
|
else
|
|
{
|
|
m_pParticleSystemsDefinitions->ClearSelectedItems();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CParticleSystemDefinitionBrowser::LoadKVSection( CDmeParticleSystemDefinition *pNew, KeyValues *pOverridesKv, ParticleFunctionType_t eType )
|
|
{
|
|
// Operator KV
|
|
KeyValues *pOperator = pOverridesKv->FindKey( GetParticleFunctionTypeName(eType), NULL );
|
|
if ( !pOperator )
|
|
return;
|
|
|
|
// Function
|
|
FOR_EACH_TRUE_SUBKEY( pOperator, pFunctionBlock )
|
|
{
|
|
int iFunction = pNew->FindFunction( eType, pFunctionBlock->GetName() );
|
|
if ( iFunction >= 0 )
|
|
{
|
|
CDmeParticleFunction *pDmeFunction = pNew->GetParticleFunction( eType, iFunction );
|
|
// Elements
|
|
FOR_EACH_SUBKEY( pFunctionBlock, pAttributeItem )
|
|
{
|
|
CDmAttribute *pAttribute = pDmeFunction->GetAttribute( pAttributeItem->GetName() );
|
|
if ( !pAttribute )
|
|
{
|
|
Warning( "Unable to Find Attribute [%s] in Function [%s] in Operator [%s] for Definition [%s]\n", pAttributeItem->GetName(), pFunctionBlock->GetName(), GetParticleFunctionTypeName(eType), pNew->GetName() );
|
|
}
|
|
else
|
|
{
|
|
pAttribute->SetValueFromString( pAttributeItem->GetString() );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Warning( "Function [%s] not found under Operator [%s] for Definition [%s]\n", pFunctionBlock->GetName(), GetParticleFunctionTypeName(eType), pNew->GetName() );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Given a KV, create, add and return an effect
|
|
//-----------------------------------------------------------------------------
|
|
CDmeParticleSystemDefinition* CParticleSystemDefinitionBrowser::CreateParticleFromKV( KeyValues *pKeyValue )
|
|
{
|
|
CDmeParticleSystemDefinition* pBaseParticleDef = NULL;
|
|
|
|
// Get the Base Particle Effect Def
|
|
const char* pBaseParticleName = pKeyValue->GetString( "base_effect", "" );
|
|
for ( int i = 0; i < m_pParticleSystemsDefinitions->GetItemCount(); ++i )
|
|
{
|
|
KeyValues *kv = m_pParticleSystemsDefinitions->GetItem( i );
|
|
if ( !V_strcmp( kv->GetString( "name", "" ), pBaseParticleName ) )
|
|
{
|
|
//
|
|
pBaseParticleDef = GetElementKeyValue< CDmeParticleSystemDefinition >( kv, "particleSystem" );
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Base Particle could not be found, end;
|
|
if ( !pBaseParticleDef )
|
|
{
|
|
Warning( "Unable to to find base particle system [%s]", pBaseParticleName );
|
|
return NULL;
|
|
}
|
|
|
|
// Create a Copy of the Base Effect
|
|
const char *pszNewParticleName = pKeyValue->GetName();
|
|
//CAppUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Copy Particle System", "Copy Particle System" );
|
|
CDmeParticleSystemDefinition *pNew = CastElement<CDmeParticleSystemDefinition>( pBaseParticleDef->Copy() );
|
|
pNew->SetName( pszNewParticleName );
|
|
|
|
// Overrides
|
|
//
|
|
//"properties"
|
|
KeyValues *pProperties = pKeyValue->FindKey( "Properties", NULL );
|
|
if ( pProperties )
|
|
{
|
|
FOR_EACH_SUBKEY( pProperties, pProperty )
|
|
{
|
|
CDmAttribute *pAttribute = pNew->GetAttribute( pProperty->GetName() );
|
|
if ( !pAttribute )
|
|
{
|
|
Warning( "Unable to Find Attribute [%s] in Function [%s]\n", pProperty->GetName(), "Properties" );
|
|
}
|
|
else
|
|
{
|
|
pAttribute->SetValueFromString( pProperty->GetString() );
|
|
}
|
|
}
|
|
}
|
|
|
|
LoadKVSection( pNew, pKeyValue, FUNCTION_RENDERER );
|
|
LoadKVSection( pNew, pKeyValue, FUNCTION_OPERATOR );
|
|
LoadKVSection( pNew, pKeyValue, FUNCTION_INITIALIZER );
|
|
LoadKVSection( pNew, pKeyValue, FUNCTION_EMITTER );
|
|
LoadKVSection( pNew, pKeyValue, FUNCTION_FORCEGENERATOR );
|
|
LoadKVSection( pNew, pKeyValue, FUNCTION_CONSTRAINT );
|
|
|
|
// Remove copied children
|
|
int iChildrenCount = pNew->GetParticleFunctionCount( FUNCTION_CHILDREN );
|
|
for ( int i = iChildrenCount - 1; i >= 0; i-- )
|
|
{
|
|
pNew->RemoveFunction( FUNCTION_CHILDREN, i );
|
|
}
|
|
|
|
// Search Children
|
|
KeyValues *pChildren = pKeyValue->FindKey( "Children", NULL );
|
|
if ( pChildren )
|
|
{
|
|
FOR_EACH_TRUE_SUBKEY( pChildren, pChild )
|
|
{
|
|
// each Child is its own effect so we need to add it and return it
|
|
CDmeParticleSystemDefinition* pChildEffect = CreateParticleFromKV( pChild );
|
|
if ( pChildEffect )
|
|
{
|
|
pNew->AddChild( pChildEffect );
|
|
}
|
|
}
|
|
}
|
|
|
|
m_pDoc->ReplaceParticleSystemDefinition( pNew );
|
|
m_pDoc->UpdateAllParticleSystems();
|
|
return pNew;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Create from KV
|
|
void CParticleSystemDefinitionBrowser::CreateParticleSystemsFromKV( const char *pFileName )
|
|
{
|
|
//
|
|
//const char * pFileName = "particles\\_weapon_prefab_override_kv.txt";
|
|
|
|
CUtlBuffer bufRawData;
|
|
bool bReadFileOK = g_pFullFileSystem->ReadFile( pFileName, "MOD", bufRawData );
|
|
if ( !bReadFileOK )
|
|
{
|
|
Warning( "Unable to Open KV file [%s]\n", pFileName );
|
|
return;
|
|
}
|
|
|
|
// Wrap it with a text buffer reader
|
|
CUtlBuffer bufText( bufRawData.Base(), bufRawData.TellPut(), CUtlBuffer::READ_ONLY | CUtlBuffer::TEXT_BUFFER );
|
|
|
|
KeyValues *pBaseKeyValue = NULL;
|
|
pBaseKeyValue = new KeyValues( "CCreateParticlesFromKV" );
|
|
|
|
if ( !pBaseKeyValue->LoadFromBuffer( NULL, bufText ) )
|
|
{
|
|
Warning( "Unable to Read KV file [%s]\n", pFileName );
|
|
pBaseKeyValue->deleteThis();
|
|
return;
|
|
}
|
|
|
|
FOR_EACH_TRUE_SUBKEY( pBaseKeyValue, pKVOver )
|
|
{
|
|
CreateParticleFromKV( pKVOver );
|
|
}
|
|
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CParticleSystemDefinitionBrowser::OnKeyCodeTyped( vgui::KeyCode code )
|
|
{
|
|
if ( code == KEY_DELETE )
|
|
{
|
|
DeleteParticleSystems();
|
|
}
|
|
else
|
|
{
|
|
BaseClass::OnKeyCodeTyped( code );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CParticleSystemDefinitionBrowser::OnFileSelected(const char *fullpath)
|
|
{
|
|
CreateParticleSystemsFromKV( fullpath );
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
// Called when the selection changes
|
|
//-----------------------------------------------------------------------------
|
|
void CParticleSystemDefinitionBrowser::UpdateParticleSystemSelection()
|
|
{
|
|
if ( m_pParticleSystemsDefinitions->GetSelectedItemsCount() == 1 )
|
|
{
|
|
CDmeParticleSystemDefinition *pParticleSystem = GetSelectedParticleSystem( 0 );
|
|
g_pPetTool->SetCurrentParticleSystem( pParticleSystem, false );
|
|
}
|
|
else
|
|
{
|
|
g_pPetTool->SetCurrentParticleSystem( NULL, false );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Item selection/deselection
|
|
//-----------------------------------------------------------------------------
|
|
void CParticleSystemDefinitionBrowser::OnItemSelected( void )
|
|
{
|
|
UpdateParticleSystemSelection();
|
|
}
|
|
|
|
void CParticleSystemDefinitionBrowser::OnItemDeselected( void )
|
|
{
|
|
UpdateParticleSystemSelection();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Select a particular node
|
|
//-----------------------------------------------------------------------------
|
|
void CParticleSystemDefinitionBrowser::SelectParticleSystem( CDmeParticleSystemDefinition *pFind )
|
|
{
|
|
m_pParticleSystemsDefinitions->ClearSelectedItems();
|
|
for ( int nItemID = m_pParticleSystemsDefinitions->FirstItem(); nItemID != m_pParticleSystemsDefinitions->InvalidItemID(); nItemID = m_pParticleSystemsDefinitions->NextItem( nItemID ) )
|
|
{
|
|
KeyValues *kv = m_pParticleSystemsDefinitions->GetItem( nItemID );
|
|
CDmeParticleSystemDefinition *pParticleSystem = GetElementKeyValue<CDmeParticleSystemDefinition>( kv, "particleSystem" );
|
|
if ( pParticleSystem == pFind )
|
|
{
|
|
m_pParticleSystemsDefinitions->AddSelectedItem( nItemID );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when buttons are clicked
|
|
//-----------------------------------------------------------------------------
|
|
void CParticleSystemDefinitionBrowser::OnInputCompleted( KeyValues *pKeyValues )
|
|
{
|
|
const char *pText = pKeyValues->GetString( "text", NULL );
|
|
if ( m_pDoc->IsParticleSystemDefined( pText ) )
|
|
{
|
|
char pBuf[1024];
|
|
Q_snprintf( pBuf, sizeof(pBuf), "Particle System \"%s\" already exists!\n", pText );
|
|
vgui::MessageBox *pMessageBox = new vgui::MessageBox( "Duplicate Particle System Name!\n", pBuf, g_pPetTool->GetRootPanel() );
|
|
pMessageBox->DoModal( );
|
|
return;
|
|
}
|
|
|
|
if ( pKeyValues->FindKey( "create" ) )
|
|
{
|
|
CDmeParticleSystemDefinition *pParticleSystem = m_pDoc->AddNewParticleSystemDefinition( pText );
|
|
g_pPetTool->SetCurrentParticleSystem( pParticleSystem );
|
|
}
|
|
else if ( pKeyValues->FindKey( "copy" ) )
|
|
{
|
|
int nCount = m_pParticleSystemsDefinitions->GetSelectedItemsCount();
|
|
if ( nCount )
|
|
{
|
|
CDmeParticleSystemDefinition *pParticleSystem = GetSelectedParticleSystem( 0 );
|
|
CAppUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Copy Particle System",
|
|
"Copy Particle System" );
|
|
CDmeParticleSystemDefinition * pNew =
|
|
CastElement<CDmeParticleSystemDefinition>( pParticleSystem->Copy( ) );
|
|
pNew->SetName( pText );
|
|
m_pDoc->AddNewParticleSystemDefinition( pNew, guard );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Copy to clipboard
|
|
//-----------------------------------------------------------------------------
|
|
void CParticleSystemDefinitionBrowser::CopyToClipboard( )
|
|
{
|
|
int nCount = m_pParticleSystemsDefinitions->GetSelectedItemsCount();
|
|
|
|
CUtlVector< KeyValues * > list;
|
|
CUtlRBTree< CDmeParticleSystemDefinition* > defs( 0, 0, DefLessFunc( CDmeParticleSystemDefinition* ) );
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
CDmeParticleSystemDefinition *pParticleSystem = GetSelectedParticleSystem( i );
|
|
|
|
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
|
|
if ( g_pDataModel->Serialize( buf, "keyvalues2", "pcf", pParticleSystem->GetHandle() ) )
|
|
{
|
|
KeyValues *pData = new KeyValues( "Clipboard" );
|
|
pData->SetString( "pcf", (char*)buf.Base() );
|
|
list.AddToTail( pData );
|
|
}
|
|
}
|
|
|
|
if ( list.Count() )
|
|
{
|
|
g_pDataModel->SetClipboardData( list );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Paste from clipboard
|
|
//-----------------------------------------------------------------------------
|
|
void CParticleSystemDefinitionBrowser::ReplaceDef_r( CUndoScopeGuard& guard, CDmeParticleSystemDefinition *pDef )
|
|
{
|
|
if ( !pDef )
|
|
return;
|
|
|
|
m_pDoc->ReplaceParticleSystemDefinition( pDef );
|
|
int nChildCount = pDef->GetParticleFunctionCount( FUNCTION_CHILDREN );
|
|
for ( int i = 0; i < nChildCount; ++i )
|
|
{
|
|
CDmeParticleChild *pChildFunction = static_cast< CDmeParticleChild* >( pDef->GetParticleFunction( FUNCTION_CHILDREN, i ) );
|
|
CDmeParticleSystemDefinition* pChild = pChildFunction->m_Child;
|
|
ReplaceDef_r( guard, pChild );
|
|
}
|
|
}
|
|
|
|
void CParticleSystemDefinitionBrowser::PasteFromClipboard( )
|
|
{
|
|
// This is undoable
|
|
CAppUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "Paste From Clipboard", "Paste From Clipboard" );
|
|
|
|
bool bRefreshAll = false;
|
|
CUtlVector< KeyValues * > list;
|
|
g_pDataModel->GetClipboardData( list );
|
|
int nItems = list.Count();
|
|
for ( int i = 0; i < nItems; ++i )
|
|
{
|
|
const char *pData = list[i]->GetString( "pcf" );
|
|
if ( !pData )
|
|
continue;
|
|
|
|
int nLen = Q_strlen( pData );
|
|
CUtlBuffer buf( pData, nLen, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY );
|
|
|
|
DmElementHandle_t hRoot;
|
|
if ( !g_pDataModel->Unserialize( buf, "keyvalues2", "pcf", NULL, "paste", CR_FORCE_COPY, hRoot ) )
|
|
continue;
|
|
|
|
CDmeParticleSystemDefinition *pDef = GetElement<CDmeParticleSystemDefinition>( hRoot );
|
|
if ( !pDef )
|
|
continue;
|
|
|
|
ReplaceDef_r( guard, pDef );
|
|
bRefreshAll = true;
|
|
}
|
|
|
|
guard.Release();
|
|
|
|
if ( bRefreshAll )
|
|
{
|
|
m_pDoc->UpdateAllParticleSystems();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Called when buttons are clicked
|
|
//-----------------------------------------------------------------------------
|
|
void CParticleSystemDefinitionBrowser::OnCommand( const char *pCommand )
|
|
{
|
|
if ( !Q_stricmp( pCommand, "create" ) )
|
|
{
|
|
vgui::InputDialog *pInputDialog = new vgui::InputDialog( g_pPetTool->GetRootPanel(), "Enter Particle System Name", "Name:", "" );
|
|
pInputDialog->SetSmallCaption( true );
|
|
pInputDialog->SetMultiline( false );
|
|
pInputDialog->AddActionSignalTarget( this );
|
|
pInputDialog->DoModal( new KeyValues("create") );
|
|
return;
|
|
}
|
|
if ( !Q_stricmp( pCommand, "copy" ) )
|
|
{
|
|
vgui::InputDialog *pInputDialog = new vgui::InputDialog( g_pPetTool->GetRootPanel(), "Enter Particle System Name", "Name:", "" );
|
|
pInputDialog->SetSmallCaption( true );
|
|
pInputDialog->SetMultiline( false );
|
|
pInputDialog->AddActionSignalTarget( this );
|
|
pInputDialog->DoModal( new KeyValues("copy") );
|
|
return;
|
|
}
|
|
if ( !Q_stricmp( pCommand, "Create From KeyValue" ) )
|
|
{
|
|
vgui::FileOpenDialog *pDialog = new vgui::FileOpenDialog( g_pPetTool->GetRootPanel(), "Select KV File", vgui::FOD_OPEN );
|
|
pDialog->SetTitle( "Choose KeyValue File", true );
|
|
pDialog->AddFilter( "*.txt", "KeyValue File (*.txt)", true );
|
|
pDialog->AddActionSignalTarget( this );
|
|
|
|
char szParticlesDir[MAX_PATH];
|
|
pDialog->SetStartDirectory( g_pFullFileSystem->RelativePathToFullPath( "particles", "MOD", szParticlesDir, sizeof(szParticlesDir) ) );
|
|
pDialog->DoModal( new KeyValues( "Create From KeyValue" ) );
|
|
|
|
return;
|
|
}
|
|
|
|
if ( !Q_stricmp( pCommand, "delete" ) )
|
|
{
|
|
DeleteParticleSystems();
|
|
return;
|
|
}
|
|
|
|
if ( !Q_stricmp( pCommand, "Save" ) )
|
|
{
|
|
g_pPetTool->Save();
|
|
return;
|
|
}
|
|
|
|
if ( !Q_stricmp( pCommand, "SaveAndTest" ) )
|
|
{
|
|
g_pPetTool->SaveAndTest();
|
|
return;
|
|
}
|
|
|
|
BaseClass::OnCommand( pCommand );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CParticleSystemDefinitionBrowser::UpdateParticleSystemList(void)
|
|
{
|
|
const CDmrParticleSystemList particleSystemList = m_pDoc->GetParticleSystemDefinitionList();
|
|
if ( !particleSystemList.IsValid() )
|
|
return;
|
|
|
|
// Maintain selection if possible
|
|
CUtlVector< CUtlString > selectedItems;
|
|
int nCount = m_pParticleSystemsDefinitions->GetSelectedItemsCount();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
CDmeParticleSystemDefinition *pParticleSystem = GetSelectedParticleSystem( i );
|
|
if ( pParticleSystem )
|
|
{
|
|
selectedItems.AddToTail( pParticleSystem->GetName() );
|
|
}
|
|
}
|
|
|
|
m_pParticleSystemsDefinitions->RemoveAll();
|
|
int nSelectedItemCount = selectedItems.Count();
|
|
nCount = particleSystemList.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
CDmeParticleSystemDefinition *pParticleSystem = particleSystemList[i];
|
|
if ( !pParticleSystem )
|
|
continue;
|
|
|
|
const char *pName = pParticleSystem->GetName();
|
|
if ( !pName || !pName[0] )
|
|
{
|
|
pName = "<no name>";
|
|
}
|
|
|
|
KeyValues *kv = new KeyValues( "node" );
|
|
kv->SetString( "name", pName );
|
|
SetElementKeyValue( kv, "particleSystem", pParticleSystem );
|
|
|
|
int nItemID = m_pParticleSystemsDefinitions->AddItem( kv, 0, false, false );
|
|
|
|
for ( int j = 0; j < nSelectedItemCount; ++j )
|
|
{
|
|
if ( Q_stricmp( selectedItems[j], pName ) )
|
|
continue;
|
|
|
|
m_pParticleSystemsDefinitions->AddSelectedItem( nItemID );
|
|
selectedItems.FastRemove(j);
|
|
--nSelectedItemCount;
|
|
break;
|
|
}
|
|
}
|
|
m_pParticleSystemsDefinitions->SortList();
|
|
}
|
|
|