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.
 
 
 
 
 
 

1149 lines
38 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Dialog used to edit properties of a particle system definition
//
//===========================================================================//
#include "dme_controls/ParticleSystemPropertiesPanel.h"
#include "tier1/KeyValues.h"
#include "tier1/utlbuffer.h"
#include "vgui/IVGui.h"
#include "vgui_controls/button.h"
#include "vgui_controls/listpanel.h"
#include "vgui_controls/splitter.h"
#include "vgui_controls/messagebox.h"
#include "vgui_controls/combobox.h"
#include "datamodel/dmelement.h"
#include "movieobjects/dmeparticlesystemdefinition.h"
#include "dme_controls/elementpropertiestree.h"
#include "matsys_controls/picker.h"
#include "dme_controls/dmecontrols_utils.h"
#include "dme_controls/particlesystempanel.h"
#include "dme_controls/dmepanel.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
using namespace vgui;
//-----------------------------------------------------------------------------
//
// Purpose: Picker for particle functions
//
//-----------------------------------------------------------------------------
class CParticleFunctionPickerFrame : public vgui::Frame
{
DECLARE_CLASS_SIMPLE( CParticleFunctionPickerFrame, vgui::Frame );
public:
CParticleFunctionPickerFrame( vgui::Panel *pParent, const char *pTitle );
~CParticleFunctionPickerFrame();
// Sets the current scene + animation list
void DoModal( CDmeParticleSystemDefinition *pParticleSystem, ParticleFunctionType_t type, KeyValues *pContextKeyValues );
// Inherited from Frame
virtual void OnCommand( const char *pCommand );
private:
// Refreshes the list of particle functions
void RefreshParticleFunctions( CDmeParticleSystemDefinition *pDefinition, ParticleFunctionType_t type );
void CleanUpMessage();
vgui::ListPanel *m_pFunctionList;
vgui::Button *m_pOpenButton;
vgui::Button *m_pCancelButton;
KeyValues *m_pContextKeyValues;
};
static int __cdecl ParticleFunctionNameSortFunc( vgui::ListPanel *pPanel, const vgui::ListPanelItem &item1, const vgui::ListPanelItem &item2 )
{
const char *string1 = item1.kv->GetString( "name" );
const char *string2 = item2.kv->GetString( "name" );
return Q_stricmp( string1, string2 );
}
CParticleFunctionPickerFrame::CParticleFunctionPickerFrame( vgui::Panel *pParent, const char *pTitle ) :
BaseClass( pParent, "ParticleFunctionPickerFrame" )
{
SetDeleteSelfOnClose( true );
m_pContextKeyValues = NULL;
m_pFunctionList = new vgui::ListPanel( this, "ParticleFunctionList" );
m_pFunctionList->AddColumnHeader( 0, "name", "Particle Function Name", 52, 0 );
m_pFunctionList->SetSelectIndividualCells( false );
m_pFunctionList->SetMultiselectEnabled( false );
m_pFunctionList->SetEmptyListText( "No particle functions" );
m_pFunctionList->AddActionSignalTarget( this );
m_pFunctionList->SetSortFunc( 0, ParticleFunctionNameSortFunc );
m_pFunctionList->SetSortColumn( 0 );
m_pOpenButton = new vgui::Button( this, "OkButton", "#MessageBox_OK", this, "Ok" );
m_pCancelButton = new vgui::Button( this, "CancelButton", "#MessageBox_Cancel", this, "Cancel" );
SetBlockDragChaining( true );
LoadControlSettingsAndUserConfig( "resource/particlefunctionpicker.res" );
SetTitle( pTitle, false );
}
CParticleFunctionPickerFrame::~CParticleFunctionPickerFrame()
{
CleanUpMessage();
}
//-----------------------------------------------------------------------------
// Refreshes the list of raw controls
//-----------------------------------------------------------------------------
void CParticleFunctionPickerFrame::RefreshParticleFunctions( CDmeParticleSystemDefinition *pParticleSystem, ParticleFunctionType_t type )
{
m_pFunctionList->RemoveAll();
if ( !pParticleSystem )
return;
CUtlVector< IParticleOperatorDefinition *> &list = g_pParticleSystemMgr->GetAvailableParticleOperatorList( type );
int nCount = list.Count();
// Build a list of used operator IDs
bool pUsedIDs[OPERATOR_ID_COUNT];
memset( pUsedIDs, 0, sizeof(pUsedIDs) );
int nFunctionCount = pParticleSystem->GetParticleFunctionCount( type );
for ( int i = 0; i < nFunctionCount; ++i )
{
const char *pFunctionName = pParticleSystem->GetParticleFunction( type, i )->GetName();
for ( int j = 0; j < nCount; ++j )
{
if ( Q_stricmp( pFunctionName, list[j]->GetName() ) )
continue;
if ( list[j]->GetId() >= 0 )
{
pUsedIDs[ list[j]->GetId() ] = true;
}
break;
}
}
for ( int i = 0; i < nCount; ++i )
{
const char *pFunctionName = list[i]->GetName();
// Look to see if this is in a special operator group
if ( list[i]->GetId() >= 0 )
{
// Don't display ones that are already in the particle system
if ( pUsedIDs[ list[i]->GetId() ] )
continue;
}
if ( list[i]->GetId() == OPERATOR_SINGLETON )
{
// Don't display ones that are already in the particle system
if ( pParticleSystem->FindFunction( type, pFunctionName ) >= 0 )
continue;
}
// Don't display obsolete operators
if ( list[i]->IsObsolete() )
continue;
KeyValues *kv = new KeyValues( "node", "name", pFunctionName );
m_pFunctionList->AddItem( kv, 0, false, false );
}
m_pFunctionList->SortList();
}
//-----------------------------------------------------------------------------
// Deletes the message
//-----------------------------------------------------------------------------
void CParticleFunctionPickerFrame::CleanUpMessage()
{
if ( m_pContextKeyValues )
{
m_pContextKeyValues->deleteThis();
m_pContextKeyValues = NULL;
}
}
//-----------------------------------------------------------------------------
// Sets the current scene + animation list
//-----------------------------------------------------------------------------
void CParticleFunctionPickerFrame::DoModal( CDmeParticleSystemDefinition *pParticleSystem, ParticleFunctionType_t type, KeyValues *pContextKeyValues )
{
CleanUpMessage();
RefreshParticleFunctions( pParticleSystem, type );
m_pContextKeyValues = pContextKeyValues;
BaseClass::DoModal();
}
//-----------------------------------------------------------------------------
// On command
//-----------------------------------------------------------------------------
void CParticleFunctionPickerFrame::OnCommand( const char *pCommand )
{
if ( !Q_stricmp( pCommand, "Ok" ) )
{
int nSelectedItemCount = m_pFunctionList->GetSelectedItemsCount();
if ( nSelectedItemCount == 0 )
return;
Assert( nSelectedItemCount == 1 );
int nItemID = m_pFunctionList->GetSelectedItem( 0 );
KeyValues *pKeyValues = m_pFunctionList->GetItem( nItemID );
KeyValues *pActionKeys = new KeyValues( "ParticleFunctionPicked" );
pActionKeys->SetString( "name", pKeyValues->GetString( "name" ) );
if ( m_pContextKeyValues )
{
pActionKeys->AddSubKey( m_pContextKeyValues );
// This prevents them from being deleted later
m_pContextKeyValues = NULL;
}
PostActionSignal( pActionKeys );
CloseModal();
return;
}
if ( !Q_stricmp( pCommand, "Cancel" ) )
{
CloseModal();
return;
}
BaseClass::OnCommand( pCommand );
}
//-----------------------------------------------------------------------------
//
// Purpose: Picker for child particle systems
//
//-----------------------------------------------------------------------------
class CParticleChildrenPickerFrame : public vgui::Frame
{
DECLARE_CLASS_SIMPLE( CParticleChildrenPickerFrame, vgui::Frame );
public:
CParticleChildrenPickerFrame( vgui::Panel *pParent, const char *pTitle, IParticleSystemPropertiesPanelQuery *pQuery );
~CParticleChildrenPickerFrame();
// Sets the current scene + animation list
void DoModal( CDmeParticleSystemDefinition *pParticleSystem, KeyValues *pContextKeyValues );
// Inherited from Frame
virtual void OnCommand( const char *pCommand );
private:
// Refreshes the list of children particle systems
void RefreshChildrenList( CDmeParticleSystemDefinition *pDefinition );
void CleanUpMessage();
IParticleSystemPropertiesPanelQuery *m_pQuery;
vgui::ListPanel *m_pChildrenList;
vgui::Button *m_pOpenButton;
vgui::Button *m_pCancelButton;
KeyValues *m_pContextKeyValues;
};
static int __cdecl ParticleChildrenNameSortFunc( vgui::ListPanel *pPanel, const vgui::ListPanelItem &item1, const vgui::ListPanelItem &item2 )
{
const char *string1 = item1.kv->GetString( "name" );
const char *string2 = item2.kv->GetString( "name" );
return Q_stricmp( string1, string2 );
}
CParticleChildrenPickerFrame::CParticleChildrenPickerFrame( vgui::Panel *pParent, const char *pTitle, IParticleSystemPropertiesPanelQuery *pQuery ) :
BaseClass( pParent, "ParticleChildrenPickerFrame" ), m_pQuery( pQuery )
{
SetDeleteSelfOnClose( true );
m_pContextKeyValues = NULL;
m_pChildrenList = new vgui::ListPanel( this, "ParticleChildrenList" );
m_pChildrenList->AddColumnHeader( 0, "name", "Particle System Name", 52, 0 );
m_pChildrenList->SetSelectIndividualCells( false );
m_pChildrenList->SetMultiselectEnabled( false );
m_pChildrenList->SetEmptyListText( "No particle systems" );
m_pChildrenList->AddActionSignalTarget( this );
m_pChildrenList->SetSortFunc( 0, ParticleChildrenNameSortFunc );
m_pChildrenList->SetSortColumn( 0 );
m_pOpenButton = new vgui::Button( this, "OkButton", "#MessageBox_OK", this, "Ok" );
m_pCancelButton = new vgui::Button( this, "CancelButton", "#MessageBox_Cancel", this, "Cancel" );
SetBlockDragChaining( true );
LoadControlSettingsAndUserConfig( "resource/particlechildrenpicker.res" );
SetTitle( pTitle, false );
}
CParticleChildrenPickerFrame::~CParticleChildrenPickerFrame()
{
CleanUpMessage();
}
//-----------------------------------------------------------------------------
// Refreshes the list of raw controls
//-----------------------------------------------------------------------------
void CParticleChildrenPickerFrame::RefreshChildrenList( CDmeParticleSystemDefinition *pCurrentParticleSystem )
{
m_pChildrenList->RemoveAll();
CUtlVector< CDmeParticleSystemDefinition* > definitions;
if ( m_pQuery )
{
m_pQuery->GetKnownParticleDefinitions( definitions );
}
int nCount = definitions.Count();
if ( nCount == 0 )
return;
for ( int i = 0; i < nCount; ++i )
{
CDmeParticleSystemDefinition *pParticleSystem = definitions[i];
if ( pParticleSystem == pCurrentParticleSystem )
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 );
m_pChildrenList->AddItem( kv, 0, false, false );
}
m_pChildrenList->SortList();
}
//-----------------------------------------------------------------------------
// Deletes the message
//-----------------------------------------------------------------------------
void CParticleChildrenPickerFrame::CleanUpMessage()
{
if ( m_pContextKeyValues )
{
m_pContextKeyValues->deleteThis();
m_pContextKeyValues = NULL;
}
}
//-----------------------------------------------------------------------------
// Sets the current scene + animation list
//-----------------------------------------------------------------------------
void CParticleChildrenPickerFrame::DoModal( CDmeParticleSystemDefinition *pParticleSystem, KeyValues *pContextKeyValues )
{
CleanUpMessage();
RefreshChildrenList( pParticleSystem );
m_pContextKeyValues = pContextKeyValues;
BaseClass::DoModal();
}
//-----------------------------------------------------------------------------
// On command
//-----------------------------------------------------------------------------
void CParticleChildrenPickerFrame::OnCommand( const char *pCommand )
{
if ( !Q_stricmp( pCommand, "Ok" ) )
{
int nSelectedItemCount = m_pChildrenList->GetSelectedItemsCount();
if ( nSelectedItemCount == 0 )
return;
Assert( nSelectedItemCount == 1 );
int nItemID = m_pChildrenList->GetSelectedItem( 0 );
KeyValues *pKeyValues = m_pChildrenList->GetItem( nItemID );
CDmeParticleSystemDefinition *pParticleSystem = GetElementKeyValue<CDmeParticleSystemDefinition>( pKeyValues, "particleSystem" );
KeyValues *pActionKeys = new KeyValues( "ParticleChildPicked" );
SetElementKeyValue( pActionKeys, "particleSystem", pParticleSystem );
if ( m_pContextKeyValues )
{
pActionKeys->AddSubKey( m_pContextKeyValues );
// This prevents them from being deleted later
m_pContextKeyValues = NULL;
}
PostActionSignal( pActionKeys );
CloseModal();
return;
}
if ( !Q_stricmp( pCommand, "Cancel" ) )
{
CloseModal();
return;
}
BaseClass::OnCommand( pCommand );
}
//-----------------------------------------------------------------------------
// Browser of various particle functions
//-----------------------------------------------------------------------------
class CParticleFunctionBrowser : public vgui::EditablePanel
{
DECLARE_CLASS_SIMPLE( CParticleFunctionBrowser, vgui::EditablePanel );
public:
// constructor, destructor
CParticleFunctionBrowser( vgui::Panel *pParent, const char *pName, ParticleFunctionType_t type, IParticleSystemPropertiesPanelQuery *pQuery );
virtual ~CParticleFunctionBrowser();
// Inherited from Panel
virtual void OnKeyCodeTyped( vgui::KeyCode code );
void SetParticleFunctionProperties( CDmeElementPanel *pPanel );
void SetParticleSystem( CDmeParticleSystemDefinition *pOp );
void RefreshParticleFunctionList();
void SelectDefaultFunction();
// Called when a list panel's selection changes
void RefreshParticleFunctionProperties( );
private:
MESSAGE_FUNC_PARAMS( OnOpenContextMenu, "OpenContextMenu", kv );
MESSAGE_FUNC_PARAMS( OnItemSelected, "ItemSelected", kv );
MESSAGE_FUNC_PARAMS( OnItemDeselected, "ItemDeselected", kv );
MESSAGE_FUNC( OnAdd, "Add" );
MESSAGE_FUNC( OnRemove, "Remove" );
MESSAGE_FUNC( OnRename, "Rename" );
MESSAGE_FUNC( OnMoveUp, "MoveUp" );
MESSAGE_FUNC( OnMoveDown, "MoveDown" );
MESSAGE_FUNC_PARAMS( OnInputCompleted, "InputCompleted", kv );
MESSAGE_FUNC_PARAMS( OnParticleFunctionPicked, "ParticleFunctionPicked", kv );
MESSAGE_FUNC_PARAMS( OnParticleChildPicked, "ParticleChildPicked", kv );
// Cleans up the context menu
void CleanupContextMenu();
// Returns the selected particle function
CDmeParticleFunction* GetSelectedFunction( );
// Returns the selected particle function
CDmeParticleFunction* GetSelectedFunction( int nIndex );
// Select a particular particle function
void SelectParticleFunction( CDmeParticleFunction *pFind );
IParticleSystemPropertiesPanelQuery *m_pQuery;
CDmeHandle< CDmeParticleSystemDefinition > m_hParticleSystem;
vgui::ListPanel *m_pFunctionList;
ParticleFunctionType_t m_FuncType;
vgui::DHANDLE< vgui::Menu > m_hContextMenu;
CDmeElementPanel *m_pParticleFunctionProperties;
};
//-----------------------------------------------------------------------------
// Sort functions for list panel
//-----------------------------------------------------------------------------
static int __cdecl ParticleFunctionSortFunc( vgui::ListPanel *pPanel, const vgui::ListPanelItem &item1, const vgui::ListPanelItem &item2 )
{
int i1 = item1.kv->GetInt( "index" );
int i2 = item2.kv->GetInt( "index" );
return i1 - i2;
}
//-----------------------------------------------------------------------------
// constructor, destructor
//-----------------------------------------------------------------------------
CParticleFunctionBrowser::CParticleFunctionBrowser( vgui::Panel *pParent, const char *pName, ParticleFunctionType_t type, IParticleSystemPropertiesPanelQuery *pQuery ) :
BaseClass( pParent, pName ), m_pQuery( pQuery )
{
SetKeyBoardInputEnabled( true );
m_FuncType = type;
m_pFunctionList = new vgui::ListPanel( this, "FunctionList" );
if ( m_FuncType != FUNCTION_CHILDREN )
{
m_pFunctionList->AddColumnHeader( 0, "name", "Function Name", 150, 0 );
m_pFunctionList->AddColumnHeader( 1, "type", "Function Type", 150, 0 );
m_pFunctionList->SetEmptyListText( "No particle functions" );
}
else
{
m_pFunctionList->AddColumnHeader( 0, "name", "Label", 150, 0 );
m_pFunctionList->AddColumnHeader( 1, "type", "Child Name", 150, 0 );
m_pFunctionList->SetEmptyListText( "No children" );
}
m_pFunctionList->SetSelectIndividualCells( false );
m_pFunctionList->SetMultiselectEnabled( true );
m_pFunctionList->AddActionSignalTarget( this );
m_pFunctionList->SetSortFunc( 0, ParticleFunctionSortFunc );
m_pFunctionList->SetSortColumn( 0 );
m_pFunctionList->AddActionSignalTarget( this );
LoadControlSettings( "resource/particlefunctionbrowser.res" );
}
CParticleFunctionBrowser::~CParticleFunctionBrowser()
{
CleanupContextMenu();
SaveUserConfig();
}
//-----------------------------------------------------------------------------
// Cleans up the context menu
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::CleanupContextMenu()
{
if ( m_hContextMenu.Get() )
{
m_hContextMenu->MarkForDeletion();
m_hContextMenu = NULL;
}
}
//-----------------------------------------------------------------------------
// Selects a particular function by default
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::SelectDefaultFunction()
{
if ( m_pFunctionList->GetSelectedItemsCount() == 0 && m_pFunctionList->GetItemCount() > 0 )
{
int nItemID = m_pFunctionList->GetItemIDFromRow( 0 );
m_pFunctionList->SetSingleSelectedItem( nItemID );
}
}
//-----------------------------------------------------------------------------
// Sets the particle system properties panel
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::SetParticleFunctionProperties( CDmeElementPanel *pPanel )
{
m_pParticleFunctionProperties = pPanel;
}
//-----------------------------------------------------------------------------
// Sets/gets the particle system
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::SetParticleSystem( CDmeParticleSystemDefinition *pParticleSystem )
{
if ( pParticleSystem != m_hParticleSystem.Get() )
{
m_hParticleSystem = pParticleSystem;
RefreshParticleFunctionList();
SelectDefaultFunction();
}
}
//-----------------------------------------------------------------------------
// Builds the particle function list for the particle system
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::RefreshParticleFunctionList()
{
if ( !m_hParticleSystem.Get() )
return;
// Maintain selection if possible
CUtlVector< CDmeParticleFunction* > selectedItems;
int nCount = m_pFunctionList->GetSelectedItemsCount();
for ( int i = 0; i < nCount; ++i )
{
selectedItems.AddToTail( GetSelectedFunction( i ) );
}
m_pFunctionList->RemoveAll();
int nSelectedCount = selectedItems.Count();
nCount = m_hParticleSystem->GetParticleFunctionCount( m_FuncType );
for ( int i = 0; i < nCount; ++i )
{
CDmeParticleFunction *pFunction = m_hParticleSystem->GetParticleFunction( m_FuncType, i );
KeyValues *kv = new KeyValues( "node", "name", pFunction->GetName() );
kv->SetString( "type", pFunction->GetFunctionType() );
kv->SetInt( "index", i );
SetElementKeyValue( kv, "particleFunction", pFunction );
int nItemID = m_pFunctionList->AddItem( kv, 0, false, false );
for ( int j = 0; j < nSelectedCount; ++j )
{
if ( selectedItems[j] == pFunction )
{
m_pFunctionList->AddSelectedItem( nItemID );
selectedItems.FastRemove( j );
--nSelectedCount;
break;
}
}
}
m_pFunctionList->SortList();
}
//-----------------------------------------------------------------------------
// Returns the selected particle function
//-----------------------------------------------------------------------------
CDmeParticleFunction* CParticleFunctionBrowser::GetSelectedFunction( int nIndex )
{
if ( !m_hParticleSystem.Get() )
return NULL;
int nSelectedItemCount = m_pFunctionList->GetSelectedItemsCount();
if ( nSelectedItemCount <= nIndex )
return NULL;
int nItemID = m_pFunctionList->GetSelectedItem( nIndex );
KeyValues *pKeyValues = m_pFunctionList->GetItem( nItemID );
return GetElementKeyValue<CDmeParticleFunction>( pKeyValues, "particleFunction" );
}
//-----------------------------------------------------------------------------
// Returns the selected particle function
//-----------------------------------------------------------------------------
CDmeParticleFunction* CParticleFunctionBrowser::GetSelectedFunction( )
{
if ( !m_hParticleSystem.Get() )
return NULL;
int nSelectedItemCount = m_pFunctionList->GetSelectedItemsCount();
if ( nSelectedItemCount != 1 )
return NULL;
int nItemID = m_pFunctionList->GetSelectedItem( 0 );
KeyValues *pKeyValues = m_pFunctionList->GetItem( nItemID );
return GetElementKeyValue<CDmeParticleFunction>( pKeyValues, "particleFunction" );
}
void CParticleFunctionBrowser::OnMoveUp( )
{
CDmeParticleFunction* pFunction = GetSelectedFunction( );
if ( !pFunction )
return;
{
CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Move Function Up", "Move Function Up" );
m_hParticleSystem->MoveFunctionUp( m_FuncType, pFunction );
}
PostActionSignal( new KeyValues( "ParticleSystemModified" ) );
}
void CParticleFunctionBrowser::OnMoveDown( )
{
CDmeParticleFunction* pFunction = GetSelectedFunction( );
if ( !pFunction )
return;
{
CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Move Function Down", "Move Function Down" );
m_hParticleSystem->MoveFunctionDown( m_FuncType, pFunction );
}
PostActionSignal( new KeyValues( "ParticleSystemModified" ) );
}
//-----------------------------------------------------------------------------
// Select a particular particle function
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::SelectParticleFunction( CDmeParticleFunction *pFind )
{
m_pFunctionList->ClearSelectedItems();
for ( int nItemID = m_pFunctionList->FirstItem(); nItemID != m_pFunctionList->InvalidItemID(); nItemID = m_pFunctionList->NextItem( nItemID ) )
{
KeyValues *kv = m_pFunctionList->GetItem( nItemID );
CDmeParticleFunction *pFunction = GetElementKeyValue<CDmeParticleFunction>( kv, "particleFunction" );
if ( pFunction == pFind )
{
m_pFunctionList->AddSelectedItem( nItemID );
break;
}
}
}
//-----------------------------------------------------------------------------
// Add/remove functions
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::OnParticleChildPicked( KeyValues *pKeyValues )
{
CDmeParticleSystemDefinition *pParticleSystem = GetElementKeyValue<CDmeParticleSystemDefinition>( pKeyValues, "particleSystem" );
if ( !pParticleSystem || ( m_FuncType != FUNCTION_CHILDREN ) )
return;
CDmeParticleFunction *pFunction;
{
CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Add Particle System Child", "Add Particle System Child" );
pFunction = m_hParticleSystem->AddChild( pParticleSystem );
}
PostActionSignal( new KeyValues( "ParticleSystemModified" ) );
SelectParticleFunction( pFunction );
}
void CParticleFunctionBrowser::OnParticleFunctionPicked( KeyValues *pKeyValues )
{
if ( m_FuncType == FUNCTION_CHILDREN )
return;
const char *pParticleFuncName = pKeyValues->GetString( "name" );
CDmeParticleFunction *pFunction;
{
CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Add Particle Function", "Add Particle Function" );
pFunction = m_hParticleSystem->AddOperator( m_FuncType, pParticleFuncName );
}
PostActionSignal( new KeyValues( "ParticleSystemModified" ) );
SelectParticleFunction( pFunction );
}
void CParticleFunctionBrowser::OnAdd( )
{
if ( m_FuncType != FUNCTION_CHILDREN )
{
CParticleFunctionPickerFrame *pPicker = new CParticleFunctionPickerFrame( this, "Select Particle Function" );
pPicker->DoModal( m_hParticleSystem, m_FuncType, NULL );
}
else
{
CParticleChildrenPickerFrame *pPicker = new CParticleChildrenPickerFrame( this, "Select Child Particle Systems", m_pQuery );
pPicker->DoModal( m_hParticleSystem, NULL );
}
}
void CParticleFunctionBrowser::OnRemove( )
{
int iSel = m_pFunctionList->GetSelectedItem( 0 );
int nRow = m_pFunctionList->GetItemCurrentRow( iSel ) - 1;
{
CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Remove Particle Function", "Remove Particle Function" );
//
// Build a list of objects to delete.
//
CUtlVector< CDmeParticleFunction* > itemsToDelete;
int nCount = m_pFunctionList->GetSelectedItemsCount();
for (int i = 0; i < nCount; i++)
{
CDmeParticleFunction *pParticleFunction = GetSelectedFunction( i );
if ( pParticleFunction )
{
itemsToDelete.AddToTail( pParticleFunction );
}
}
nCount = itemsToDelete.Count();
for ( int i = 0; i < nCount; ++i )
{
m_hParticleSystem->RemoveFunction( m_FuncType, itemsToDelete[i] );
}
}
PostActionSignal( new KeyValues( "ParticleSystemModified" ) );
// Update the list box selection.
if ( m_pFunctionList->GetItemCount() > 0 )
{
if ( nRow < 0 )
{
nRow = 0;
}
else if ( nRow >= m_pFunctionList->GetItemCount() )
{
nRow = m_pFunctionList->GetItemCount() - 1;
}
iSel = m_pFunctionList->GetItemIDFromRow( nRow );
m_pFunctionList->SetSingleSelectedItem( iSel );
}
else
{
m_pFunctionList->ClearSelectedItems();
}
}
//-----------------------------------------------------------------------------
// Rename a particle function
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::OnInputCompleted( KeyValues *pKeyValues )
{
const char *pName = pKeyValues->GetString( "text" );
CDmeParticleFunction *pFunction = GetSelectedFunction();
{
CUndoScopeGuard guard( 0, NOTIFY_SETDIRTYFLAG, "Rename Particle Function", "Rename Particle Function" );
pFunction->SetName( pName );
}
PostActionSignal( new KeyValues( "ParticleSystemModified" ) );
}
//-----------------------------------------------------------------------------
// Rename a particle function
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::OnRename()
{
int nSelectedItemCount = m_pFunctionList->GetSelectedItemsCount();
if ( nSelectedItemCount != 1 )
return;
vgui::InputDialog *pInput = new vgui::InputDialog( this, "Rename Particle Function", "Enter new name of particle function" );
pInput->SetMultiline( false );
pInput->DoModal( );
}
//-----------------------------------------------------------------------------
// Called when a list panel's selection changes
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::RefreshParticleFunctionProperties( )
{
if ( IsVisible() )
{
CDmeParticleFunction *pFunction = GetSelectedFunction();
if ( pFunction )
{
m_pParticleFunctionProperties->SetTypeDictionary( pFunction->GetEditorTypeDictionary() );
}
m_pParticleFunctionProperties->SetDmeElement( pFunction );
// Notify the outside world so we can get helpers to render correctly in the preview
KeyValues *pMessage = new KeyValues( "ParticleFunctionSelChanged" );
SetElementKeyValue( pMessage, "function", pFunction );
PostActionSignal( pMessage );
}
}
//-----------------------------------------------------------------------------
// Called when a list panel's selection changes
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::OnItemSelected( KeyValues *kv )
{
Panel *pPanel = (Panel *)kv->GetPtr( "panel", NULL );
if ( pPanel == m_pFunctionList )
{
RefreshParticleFunctionProperties();
return;
}
}
//-----------------------------------------------------------------------------
// Called when a list panel's selection changes
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::OnItemDeselected( KeyValues *kv )
{
Panel *pPanel = (Panel *)kv->GetPtr( "panel", NULL );
if ( pPanel == m_pFunctionList )
{
RefreshParticleFunctionProperties();
return;
}
}
//-----------------------------------------------------------------------------
// Called to open a context-sensitive menu for a particular menu item
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::OnOpenContextMenu( KeyValues *kv )
{
CleanupContextMenu();
if ( !m_hParticleSystem.Get() )
return;
Panel *pPanel = (Panel *)kv->GetPtr( "panel", NULL );
if ( pPanel != m_pFunctionList )
return;
int nSelectedItemCount = m_pFunctionList->GetSelectedItemsCount();
m_hContextMenu = new vgui::Menu( this, "ActionMenu" );
m_hContextMenu->AddMenuItem( "#ParticleFunctionBrowser_Add", new KeyValues( "Add" ), this );
if ( nSelectedItemCount >= 1 )
{
m_hContextMenu->AddMenuItem( "#ParticleFunctionBrowser_Remove", new KeyValues( "Remove" ), this );
}
if ( nSelectedItemCount == 1 )
{
m_hContextMenu->AddMenuItem( "#ParticleFunctionBrowser_Rename", new KeyValues( "Rename" ), this );
m_hContextMenu->AddSeparator();
m_hContextMenu->AddMenuItem( "#ParticleFunctionBrowser_MoveUp", new KeyValues( "MoveUp" ), this );
m_hContextMenu->AddMenuItem( "#ParticleFunctionBrowser_MoveDown", new KeyValues( "MoveDown" ), this );
}
vgui::Menu::PlaceContextMenu( this, m_hContextMenu.Get() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CParticleFunctionBrowser::OnKeyCodeTyped( vgui::KeyCode code )
{
if ( code == KEY_DELETE )
{
OnRemove();
}
else
{
BaseClass::OnKeyCodeTyped( code );
}
}
//-----------------------------------------------------------------------------
// Strings
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CParticleSystemPropertiesPanel::CParticleSystemPropertiesPanel( IParticleSystemPropertiesPanelQuery *pQuery, vgui::Panel* pParent )
: BaseClass( pParent, "ParticleSystemPropertiesPanel" ), m_pQuery( pQuery )
{
SetKeyBoardInputEnabled( true );
m_pSplitter = new vgui::Splitter( this, "Splitter", vgui::SPLITTER_MODE_VERTICAL, 1 );
vgui::Panel *pSplitterLeftSide = m_pSplitter->GetChild( 0 );
vgui::Panel *pSplitterRightSide = m_pSplitter->GetChild( 1 );
m_pFunctionBrowserArea = new vgui::EditablePanel( pSplitterLeftSide, "FunctionBrowserArea" );
m_pFunctionTypeCombo = new vgui::ComboBox( pSplitterLeftSide, "FunctionTypeCombo", PARTICLE_FUNCTION_COUNT+1, false );
m_pFunctionTypeCombo->AddItem( "Properties", new KeyValues( "choice", "index", -1 ) );
m_pFunctionTypeCombo->AddActionSignalTarget( this );
m_pParticleFunctionProperties = new CDmeElementPanel( pSplitterRightSide, "FunctionProperties" );
m_pParticleFunctionProperties->SetAutoResize( vgui::Panel::PIN_TOPLEFT, vgui::Panel::AUTORESIZE_DOWNANDRIGHT, 6, 6, -6, -6 );
m_pParticleFunctionProperties->AddActionSignalTarget( this );
for ( int i = 0; i < PARTICLE_FUNCTION_COUNT; ++i )
{
const char *pTypeName = GetParticleFunctionTypeName( (ParticleFunctionType_t)i );
m_pFunctionTypeCombo->AddItem( pTypeName, new KeyValues( "choice", "index", i ) );
m_pParticleFunctionBrowser[i] = new CParticleFunctionBrowser( m_pFunctionBrowserArea, "FunctionBrowser", (ParticleFunctionType_t)i, m_pQuery );
m_pParticleFunctionBrowser[i]->SetParticleFunctionProperties( m_pParticleFunctionProperties );
m_pParticleFunctionBrowser[i]->AddActionSignalTarget( this );
}
m_pFunctionTypeCombo->ActivateItemByRow( 0 );
LoadControlSettings( "resource/particlesystempropertiespanel.res" );
}
//-----------------------------------------------------------------------------
// Sets the particle system to look at
//-----------------------------------------------------------------------------
void CParticleSystemPropertiesPanel::SetParticleSystem( CDmeParticleSystemDefinition *pParticleSystem )
{
m_hParticleSystem = pParticleSystem;
for ( int i = 0; i < PARTICLE_FUNCTION_COUNT; ++i )
{
m_pParticleFunctionBrowser[i]->SetParticleSystem( pParticleSystem );
}
KeyValues *pKeyValues = m_pFunctionTypeCombo->GetActiveItemUserData();
int nPage = pKeyValues->GetInt( "index" );
if ( nPage < 0 )
{
if ( m_hParticleSystem.Get() )
{
m_pParticleFunctionProperties->SetTypeDictionary( m_hParticleSystem->GetEditorTypeDictionary() );
}
m_pParticleFunctionProperties->SetDmeElement( m_hParticleSystem );
}
}
//-----------------------------------------------------------------------------
// Called when something changes in the dmeelement panel
//-----------------------------------------------------------------------------
void CParticleSystemPropertiesPanel::OnDmeElementChanged( KeyValues *pKeyValues )
{
int nNotifyFlags = pKeyValues->GetInt( "notifyFlags" );
OnParticleSystemModified();
if ( nNotifyFlags & ( NOTIFY_CHANGE_TOPOLOGICAL | NOTIFY_CHANGE_ATTRIBUTE_ARRAY_SIZE ) )
{
for ( int i = 0; i < PARTICLE_FUNCTION_COUNT; ++i )
{
m_pParticleFunctionBrowser[i]->RefreshParticleFunctionList();
}
}
PostActionSignal( new KeyValues( "ParticleSystemModified" ) );
}
void CParticleSystemPropertiesPanel::OnParticleSystemModifiedInternal()
{
OnParticleSystemModified();
Refresh( false );
PostActionSignal( new KeyValues( "ParticleSystemModified" ) );
}
void CParticleSystemPropertiesPanel::OnParticleFunctionSelChanged( KeyValues *pParams )
{
// Notify the outside world so we can get helpers to render correctly in the preview
CDmeParticleFunction *pFunction = GetElementKeyValue<CDmeParticleFunction>( pParams, "function" );
KeyValues *pMessage = new KeyValues( "ParticleFunctionSelChanged" );
SetElementKeyValue( pMessage, "function", pFunction );
PostActionSignal( pMessage );
}
//-----------------------------------------------------------------------------
// Refreshes display
//-----------------------------------------------------------------------------
void CParticleSystemPropertiesPanel::Refresh( bool bValuesOnly )
{
for ( int i = 0; i < PARTICLE_FUNCTION_COUNT; ++i )
{
m_pParticleFunctionBrowser[i]->RefreshParticleFunctionList();
}
m_pParticleFunctionProperties->Refresh( bValuesOnly ? CElementPropertiesTreeInternal::REFRESH_VALUES_ONLY :
CElementPropertiesTreeInternal::REFRESH_TREE_VIEW );
}
//-----------------------------------------------------------------------------
// Purpose: Called when a page is shown
//-----------------------------------------------------------------------------
void CParticleSystemPropertiesPanel::OnTextChanged( )
{
for ( int i = 0; i < PARTICLE_FUNCTION_COUNT; ++i )
{
m_pParticleFunctionBrowser[i]->SetVisible( false );
}
KeyValues *pKeyValues = m_pFunctionTypeCombo->GetActiveItemUserData();
int nPage = pKeyValues->GetInt( "index" );
if ( nPage < 0 )
{
if ( m_hParticleSystem.Get() )
{
m_pParticleFunctionProperties->SetTypeDictionary( m_hParticleSystem->GetEditorTypeDictionary() );
}
m_pParticleFunctionProperties->SetDmeElement( m_hParticleSystem );
return;
}
m_pParticleFunctionBrowser[nPage]->SetVisible( true );
m_pParticleFunctionBrowser[nPage]->SelectDefaultFunction();
m_pParticleFunctionBrowser[nPage]->RefreshParticleFunctionProperties();
}
//-----------------------------------------------------------------------------
// A little panel used as a DmePanel for particle systems
//-----------------------------------------------------------------------------
class CParticleSystemDmePanel : public vgui::EditablePanel
{
DECLARE_CLASS_SIMPLE( CParticleSystemDmePanel, vgui::EditablePanel );
public:
// constructor, destructor
CParticleSystemDmePanel( vgui::Panel *pParent, const char *pName );
virtual ~CParticleSystemDmePanel();
// Set the material to draw
void SetDmeElement( CDmeParticleSystemDefinition *pDef );
private:
MESSAGE_FUNC_INT( OnElementChangedExternally, "ElementChangedExternally", valuesOnly );
MESSAGE_FUNC( OnParticleSystemModified, "ParticleSystemModified" );
MESSAGE_FUNC_PARAMS( OnParticleFunctionSelChanged, "ParticleFunctionSelChanged", params );
vgui::Splitter *m_Splitter;
CParticleSystemPropertiesPanel *m_pProperties;
CParticleSystemPreviewPanel *m_pPreview;
};
//-----------------------------------------------------------------------------
// Dme panel connection
//-----------------------------------------------------------------------------
IMPLEMENT_DMEPANEL_FACTORY( CParticleSystemDmePanel, DmeParticleSystemDefinition, "DmeParticleSystemDefinitionEditor", "Particle System Editor", true );
//-----------------------------------------------------------------------------
// constructor, destructor
//-----------------------------------------------------------------------------
CParticleSystemDmePanel::CParticleSystemDmePanel( vgui::Panel *pParent, const char *pName ) :
BaseClass( pParent, pName )
{
m_Splitter = new vgui::Splitter( this, "Splitter", SPLITTER_MODE_HORIZONTAL, 1 );
vgui::Panel *pSplitterTopSide = m_Splitter->GetChild( 0 );
vgui::Panel *pSplitterBottomSide = m_Splitter->GetChild( 1 );
m_Splitter->SetAutoResize( PIN_TOPLEFT, AUTORESIZE_DOWNANDRIGHT, 0, 0, 0, 0 );
m_pProperties = new CParticleSystemPropertiesPanel( NULL, pSplitterBottomSide );
m_pProperties->AddActionSignalTarget( this );
m_pProperties->SetAutoResize( PIN_TOPLEFT, AUTORESIZE_DOWNANDRIGHT, 0, 0, 0, 0 );
m_pPreview = new CParticleSystemPreviewPanel( pSplitterTopSide, "Preview" );
m_pPreview->SetAutoResize( PIN_TOPLEFT, AUTORESIZE_DOWNANDRIGHT, 0, 0, 0, 0 );
}
CParticleSystemDmePanel::~CParticleSystemDmePanel()
{
}
//-----------------------------------------------------------------------------
// Layout
//-----------------------------------------------------------------------------
void CParticleSystemDmePanel::SetDmeElement( CDmeParticleSystemDefinition *pDef )
{
m_pProperties->SetParticleSystem( pDef );
m_pPreview->SetParticleSystem( pDef );
}
//-----------------------------------------------------------------------------
// Particle system modified externally to the editor
//-----------------------------------------------------------------------------
void CParticleSystemDmePanel::OnElementChangedExternally( int valuesOnly )
{
m_pProperties->Refresh( valuesOnly != 0 );
}
//-----------------------------------------------------------------------------
// Called when the selected particle function changes
//-----------------------------------------------------------------------------
void CParticleSystemDmePanel::OnParticleFunctionSelChanged( KeyValues *pParams )
{
CDmeParticleFunction *pFunction = GetElementKeyValue<CDmeParticleFunction>( pParams, "function" );
m_pPreview->SetParticleFunction( pFunction );
}
//-----------------------------------------------------------------------------
// Communicate to the owning DmePanel
//-----------------------------------------------------------------------------
void CParticleSystemDmePanel::OnParticleSystemModified()
{
PostActionSignal( new KeyValues( "DmeElementChanged" ) );
}