Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

599 lines
19 KiB

//========= 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();
}