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.
 
 
 
 
 
 

1011 lines
34 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
#include "vstdlib/random.h"
#include "dme_controls/dmedageditpanel.h"
#include "dme_controls/dmedagrenderpanel.h"
#include "dme_controls/dmepanel.h"
#include "vgui_controls/Button.h"
#include "vgui_controls/Splitter.h"
#include "vgui_controls/PropertySheet.h"
#include "vgui_controls/PropertyPage.h"
#include "vgui_controls/Label.h"
#include "vgui_controls/ScrollBar.h"
#include "vgui_controls/Slider.h"
#include "vgui_controls/ScrollableEditablePanel.h"
#include "vgui_controls/ListPanel.h"
#include "vgui_controls/Image.h"
#include "vgui_controls/TextImage.h"
#include "vgui/ISurface.h"
#include "vgui/ischeme.h"
#include "vgui/iinput.h"
#include "vgui/IVGui.h"
#include "vgui/cursor.h"
#include "movieobjects/dmemakefile.h"
#include "movieobjects/dmemdlmakefile.h"
#include "movieobjects/dmedccmakefile.h"
#include "movieobjects/dmedag.h"
#include "movieobjects/dmeclip.h"
#include "movieobjects/dmeanimationlist.h"
#include "movieobjects/dmecombinationoperator.h"
#include "movieobjects/dmeanimationset.h"
#include "tier1/KeyValues.h"
#include "materialsystem/imesh.h"
#include "dme_controls/BaseAnimationSetEditor.h"
#include "dme_controls/BaseAnimSetAttributeSliderPanel.h"
//-----------------------------------------------------------------------------
//
// Hook into the dme panel editor system
//
//-----------------------------------------------------------------------------
IMPLEMENT_DMEPANEL_FACTORY( CDmeDagEditPanel, DmeDag, "DmeDagPreview2", "DmeDag Previewer 2", false );
IMPLEMENT_DMEPANEL_FACTORY( CDmeDagEditPanel, DmeSourceSkin, "DmeSourceSkinPreview2", "MDL Skin Previewer 2", false );
IMPLEMENT_DMEPANEL_FACTORY( CDmeDagEditPanel, DmeSourceAnimation, "DmeSourceAnimationPreview2", "MDL Animation Previewer 2", false );
IMPLEMENT_DMEPANEL_FACTORY( CDmeDagEditPanel, DmeDCCMakefile, "DmeMakeFileOutputPreview2", "DCC MakeFile Output Previewer 2", false );
//-----------------------------------------------------------------------------
// Slider panel
//-----------------------------------------------------------------------------
class CDmeAnimationListPanel : public vgui::EditablePanel
{
DECLARE_CLASS_SIMPLE( CDmeAnimationListPanel, vgui::EditablePanel );
public:
// constructor, destructor
CDmeAnimationListPanel( vgui::Panel *pParent, const char *pName );
virtual ~CDmeAnimationListPanel();
void SetAnimationList( CDmeAnimationList *pList );
void RefreshAnimationList();
const char *GetSelectedAnimation() const;
private:
// Called when the selection changes moves
MESSAGE_FUNC( OnItemSelected, "ItemSelected" );
MESSAGE_FUNC( OnItemDeselected, "ItemDeselected" );
vgui::ListPanel *m_pAnimationList;
CDmeHandle< CDmeAnimationList > m_hAnimationList;
};
static int __cdecl AnimationNameSortFunc( 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 );
}
//-----------------------------------------------------------------------------
// constructor, destructor
//-----------------------------------------------------------------------------
CDmeAnimationListPanel::CDmeAnimationListPanel( vgui::Panel *pParent, const char *pName ) :
BaseClass( pParent, pName )
{
m_pAnimationList = new vgui::ListPanel( this, "AnimationList" );
m_pAnimationList->AddColumnHeader( 0, "name", "name", 100, 0 );
m_pAnimationList->AddActionSignalTarget( this );
m_pAnimationList->SetSortFunc( 0, AnimationNameSortFunc );
m_pAnimationList->SetSortColumn( 0 );
m_pAnimationList->SetEmptyListText("No animations");
m_pAnimationList->SetMultiselectEnabled( false );
LoadControlSettingsAndUserConfig( "resource/dmeanimationlistpanel.res" );
}
CDmeAnimationListPanel::~CDmeAnimationListPanel()
{
}
//-----------------------------------------------------------------------------
// Sets the combination operator
//-----------------------------------------------------------------------------
void CDmeAnimationListPanel::SetAnimationList( CDmeAnimationList *pList )
{
if ( pList != m_hAnimationList.Get() )
{
m_hAnimationList = pList;
RefreshAnimationList();
}
}
//-----------------------------------------------------------------------------
// Builds the list of animations
//-----------------------------------------------------------------------------
void CDmeAnimationListPanel::RefreshAnimationList()
{
m_pAnimationList->RemoveAll();
if ( !m_hAnimationList.Get() )
return;
int nCount = m_hAnimationList->GetAnimationCount();
for ( int i = 0; i < nCount; ++i )
{
CDmeChannelsClip *pAnimation = m_hAnimationList->GetAnimation( i );
KeyValues *pItemKeys = new KeyValues( "node", "name", pAnimation->GetName() );
m_pAnimationList->AddItem( pItemKeys, 0, false, false );
}
m_pAnimationList->SortList();
}
//-----------------------------------------------------------------------------
// Returns the selected animation
//-----------------------------------------------------------------------------
const char *CDmeAnimationListPanel::GetSelectedAnimation() const
{
if ( m_pAnimationList->GetSelectedItemsCount() == 0 )
return "";
int nIndex = m_pAnimationList->GetSelectedItem( 0 );
KeyValues *pItemKeyValues = m_pAnimationList->GetItem( nIndex );
return pItemKeyValues->GetString( "name" );
}
//-----------------------------------------------------------------------------
// Called when an animation is selected or deselected
//-----------------------------------------------------------------------------
void CDmeAnimationListPanel::OnItemSelected( )
{
const char *pAnimationName = GetSelectedAnimation();
PostActionSignal( new KeyValues( "AnimationSelected", "animationName", pAnimationName ) );
}
void CDmeAnimationListPanel::OnItemDeselected( )
{
PostActionSignal( new KeyValues( "AnimationDeselected" ) );
}
class CDmeCombinationOperatorPanel : public CBaseAnimationSetEditor
{
DECLARE_CLASS_SIMPLE( CDmeCombinationOperatorPanel, CBaseAnimationSetEditor );
public:
CDmeCombinationOperatorPanel( vgui::Panel *parent, const char *panelName );
virtual ~CDmeCombinationOperatorPanel();
virtual void OnTick();
void SetCombinationOperator( CDmeCombinationOperator *pOp );
void RefreshCombinationOperator();
private:
void CreateFakeAnimationSet( );
void DestroyFakeAnimationSet( );
// Adds new controls to the animation set
void AddNewAnimationSetControls();
// Removes a controls from all presets
void RemoveAnimationControlFromPresets( const char *pControlName );
// Removes a controls from all presets
void RemoveAnimationControlFromSelectionGroups( const char *pControlName );
// Removes controls from the animation set that aren't used
void RemoveUnusedAnimationSetControls();
// Modify controls in the presets which have had stereo or multilevel settings changed
void ModifyExistingAnimationSetControls();
// Modify controls in the presets which have had stereo or multilevel settings changed
void ModifyExistingAnimationSetPresets( CDmElement *pControlElement );
// Modify controls which have had stereo or multilevel settings changed
void ModifyExistingAnimationSetControl( CDmElement *pControlElement );
// Creates the procedural presets
void ComputeProceduralPresets();
void RefreshAnimationSet();
// Sort control names to match the combination controls
void SortAnimationSetControls();
// Sets preset values
void GenerateProceduralPresetValues( CDmElement *pPreset, CDmElement *pControl, bool bIdentity, float flForceValue );
void GenerateProceduralPresetValues( CDmElement *pPreset, const CDmrElementArray< CDmElement > &controls, bool bIdentity, float flForceValue = -1.0f );
CDmeHandle< CDmeCombinationOperator > m_hCombinationOperator;
};
//-----------------------------------------------------------------------------
// Constructor/destructor
//-----------------------------------------------------------------------------
CDmeCombinationOperatorPanel::CDmeCombinationOperatorPanel( vgui::Panel *parent, const char *panelName ) :
BaseClass( parent, panelName, false )
{
CreateFakeAnimationSet();
vgui::ivgui()->AddTickSignal( GetVPanel(), 0 );
}
CDmeCombinationOperatorPanel::~CDmeCombinationOperatorPanel()
{
DestroyFakeAnimationSet();
}
//-----------------------------------------------------------------------------
// Create, destroy fake animation sets
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::CreateFakeAnimationSet( )
{
m_AnimSet = CreateElement< CDmeAnimationSet >( "fakeSet", DMFILEID_INVALID );
m_AnimSet->SetValue( "gameModel", DMELEMENT_HANDLE_INVALID );
g_pDataModel->DontAutoDelete( m_AnimSet->GetHandle() );
}
void CDmeCombinationOperatorPanel::DestroyFakeAnimationSet( )
{
DestroyElement( m_AnimSet, TD_DEEP );
}
//-----------------------------------------------------------------------------
// Sets combination ops + animation sets
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::SetCombinationOperator( CDmeCombinationOperator *pOp )
{
// The Animation Set Editor Doesn't Handle Passing The Same Animation Set With
// Different Data In It Very Well
DestroyFakeAnimationSet();
CreateFakeAnimationSet();
if ( pOp != m_hCombinationOperator.Get() )
{
m_hCombinationOperator = pOp;
RefreshCombinationOperator();
}
}
//-----------------------------------------------------------------------------
// Sets preset values
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::GenerateProceduralPresetValues( CDmElement *pPreset, CDmElement *ctrl, bool bForceValue, float flForceValue )
{
bool combo = ctrl->GetValue< bool >( "combo" );
bool multi = ctrl->GetValue< bool >( "multi" );
float flValue, flBalance, flMultilevel;
if ( !bForceValue )
{
flValue = RandomFloat( 0.0f, 1.0f );
flBalance = RandomFloat( 0.25f, 0.75f );
flMultilevel = RandomFloat( 0.0f, 1.0f );
}
else
{
flValue = flBalance = flMultilevel = flForceValue;
}
pPreset->SetValue< float >( "value", flValue );
if ( combo )
{
pPreset->SetValue< float >( "balance", flBalance );
}
else
{
pPreset->RemoveAttribute( "balance" );
}
if ( multi )
{
pPreset->SetValue< float >( "multilevel", flMultilevel );
}
else
{
pPreset->RemoveAttribute( "multilevel" );
}
}
void CDmeCombinationOperatorPanel::GenerateProceduralPresetValues( CDmElement *pPreset, const CDmrElementArray< CDmElement > &controls, bool bIdentity, float flForceValue /*= -1.0f*/ )
{
CDmrElementArray<> values( pPreset, "controlValues" );
Assert( values.IsValid() );
values.RemoveAll();
int c = controls.Count();
for ( int i = 0; i < c ; ++i )
{
CDmElement *pControl = controls[ i ];
CDmElement *pControlValue = CreateElement< CDmElement >( pControl->GetName(), pPreset->GetFileId() );
GenerateProceduralPresetValues( pControlValue, pControl, bIdentity, flForceValue );
values.AddToTail( pControlValue );
}
}
//-----------------------------------------------------------------------------
// Removes a controls from all presets
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::RemoveAnimationControlFromPresets( const char *pControlName )
{
CDmeAnimationSet *pAnimationSet = m_AnimSet.Get();
CDmrElementArray< CDmePresetGroup > presetGroupList = pAnimationSet->GetPresetGroups();
int nPresetGroupCount = presetGroupList.Count();
for ( int i = 0; i < nPresetGroupCount; ++i )
{
CDmePresetGroup *pPresetGroup = presetGroupList[ i ];
CDmrElementArray< CDmePreset > presetList = pPresetGroup->GetPresets();
int nPresetCount = presetList.Count();
for ( int j = 0; j < nPresetCount; ++j )
{
CDmePreset *pPreset = presetList[ j ];
CDmrElementArray<> controlValues = pPreset->GetControlValues();
int nControlCount = controlValues.Count();
for ( int k = 0; k < nControlCount; ++k )
{
CDmElement *v = controlValues[ k ];
if ( !Q_stricmp( v->GetName(), pControlName ) )
{
controlValues.FastRemove( k );
break;
}
}
}
}
}
//-----------------------------------------------------------------------------
// Removes a controls from all presets
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::RemoveAnimationControlFromSelectionGroups( const char *pControlName )
{
CDmeAnimationSet *pAnimationSet = m_AnimSet.Get();
CDmrElementArray< > selectionGroupList = pAnimationSet->GetSelectionGroups();
int nGroupCount = selectionGroupList.Count();
for ( int i = 0; i < nGroupCount; ++i )
{
CDmElement *pSelectionGroup = selectionGroupList[ i ];
CDmrStringArray selectedControls( pSelectionGroup, "selectedControls" );
int nControlCount = selectedControls.Count();
for ( int j = 0; j < nControlCount; ++j )
{
if ( !Q_stricmp( selectedControls[ j ], pControlName ) )
{
selectedControls.FastRemove( j );
break;
}
}
}
}
//-----------------------------------------------------------------------------
// Removes controls from the animation set that aren't used
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::RemoveUnusedAnimationSetControls()
{
CDmeAnimationSet *pAnimationSet = m_AnimSet.Get();
CDmrElementArray< > controls = pAnimationSet->GetControls();
// Remove all controls in the animation set and in presets that don't exist in the combination system
int nAnimSetCount = controls.Count();
for ( int i = nAnimSetCount; --i >= 0; )
{
CDmElement *pControlElement = controls[i];
if ( !pControlElement )
continue;
// Don't do any of this work for transforms
if ( pControlElement->GetValue< bool >( "transform" ) )
continue;
const char *pControlName = pControlElement->GetName();
// Look for a match
if ( m_hCombinationOperator.Get() && m_hCombinationOperator->FindControlIndex( pControlName ) >= 0 )
continue;
// No match, blow the control away.
RemoveAnimationControlFromPresets( pControlName );
RemoveAnimationControlFromSelectionGroups( pControlName );
controls.FastRemove( i );
}
}
//-----------------------------------------------------------------------------
// Modify controls in the presets which have had stereo or multilevel settings changed
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::ModifyExistingAnimationSetControl( CDmElement *pControlElement )
{
const char *pControlName = pControlElement->GetName();
// Look for a match
int nControlIndex = m_hCombinationOperator->FindControlIndex( pControlName );
Assert( nControlIndex >= 0 );
bool bIsStereoControl = m_hCombinationOperator->IsStereoControl( nControlIndex );
bool bIsAnimControlStereo = pControlElement->GetValue< bool >( "combo" );
if ( bIsAnimControlStereo != bIsStereoControl )
{
pControlElement->SetValue< bool >( "combo", bIsStereoControl );
if ( !bIsStereoControl )
{
pControlElement->RemoveAttribute( "balance" );
}
else
{
const Vector2D &value = m_hCombinationOperator->GetStereoControlValue( nControlIndex );
pControlElement->SetValue< float >( "balance", value.y );
}
}
bool bIsMultiControl = m_hCombinationOperator->IsMultiControl( nControlIndex );
bool bIsAnimMultiControl = pControlElement->GetValue< bool >( "multi" );
if ( bIsAnimMultiControl != bIsMultiControl )
{
pControlElement->SetValue< bool >( "multi", bIsMultiControl );
if ( !bIsMultiControl )
{
pControlElement->RemoveAttribute( "multilevel" );
}
else
{
pControlElement->SetValue< float >( "multilevel", m_hCombinationOperator->GetMultiControlLevel( nControlIndex ) );
}
}
float flDefaultValue = m_hCombinationOperator->GetRawControlCount( nControlIndex ) == 2 ? 0.5f : 0.0f;
pControlElement->SetValue( "defaultValue", flDefaultValue );
pControlElement->SetValue( "defaultBalance", 0.5f );
pControlElement->SetValue( "defaultMultilevel", 0.5f );
}
//-----------------------------------------------------------------------------
// Modify controls in the presets which have had stereo or multilevel settings changed
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::ModifyExistingAnimationSetPresets( CDmElement *pControlElement )
{
const char *pControlName = pControlElement->GetName();
CDmeAnimationSet *pAnimationSet = m_AnimSet.Get();
const CDmrElementArray< CDmePresetGroup > &presetGroupList = pAnimationSet->GetPresetGroups();
int nPresetGroupCount = presetGroupList.Count();
for ( int g = 0; g < nPresetGroupCount; ++g )
{
CDmePresetGroup *pPresetGroup = presetGroupList[ g ];
const CDmrElementArray< CDmePreset > &presetList = pPresetGroup->GetPresets();
int nPresetCount = presetList.Count();
for ( int i = 0; i < nPresetCount; ++i )
{
CDmePreset *pPreset = presetList[ i ];
const CDmrElementArray< CDmElement > &controlValues = pPreset->GetControlValues( );
int nControlCount = controlValues.Count();
for ( int j = 0; j < nControlCount; ++j )
{
CDmElement *v = controlValues[ j ];
if ( Q_stricmp( v->GetName(), pControlName ) )
continue;
bool bIsAnimControlStereo = pControlElement->GetValue< bool >( "combo" );
if ( bIsAnimControlStereo )
{
if ( !v->HasAttribute( "balance" ) )
{
v->SetValue( "balance", 0.5f );
}
}
else
{
v->RemoveAttribute( "balance" );
}
bool bIsAnimMultiControl = pControlElement->GetValue< bool >( "multi" );
if ( bIsAnimMultiControl )
{
if ( !v->HasAttribute( "multilevel" ) )
{
v->SetValue( "multilevel", 0.5f );
}
}
else
{
v->RemoveAttribute( "multilevel" );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Modify controls which have had stereo or multilevel settings changed
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::ModifyExistingAnimationSetControls()
{
CDmeAnimationSet *pAnimationSet = m_AnimSet.Get();
const CDmrElementArray< CDmElement > &controls = pAnimationSet->GetControls();
// Update the main controls; update defaults and add or remove combo + multi data
int nAnimSetCount = controls.Count();
for ( int i = nAnimSetCount; --i >= 0; )
{
CDmElement *pControlElement = controls[i];
if ( !pControlElement )
continue;
// Don't do any of this work for transforms
if ( pControlElement->GetValue< bool >( "transform" ) )
continue;
ModifyExistingAnimationSetControl( pControlElement );
ModifyExistingAnimationSetPresets( pControlElement );
}
}
//-----------------------------------------------------------------------------
// Adds new controls to the animation set
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::AddNewAnimationSetControls()
{
if ( !m_hCombinationOperator.Get() )
return;
CDmeAnimationSet *pAnimationSet = m_AnimSet.Get();
CDmaElementArray< > &controls = pAnimationSet->GetControls();
// Remove all controls in the animation set and in presets that don't exist in the combination system
int nFirstControl = controls.Count();
int nCombinationControlCount = m_hCombinationOperator->GetControlCount();
for ( int i = 0; i < nCombinationControlCount; ++i )
{
const char *pControlName = m_hCombinationOperator->GetControlName( i );
if ( pAnimationSet->FindControl( pControlName ) )
continue;
bool bIsStereoControl = m_hCombinationOperator->IsStereoControl(i);
bool bIsMultiControl = m_hCombinationOperator->IsMultiControl(i);
float flDefaultValue = m_hCombinationOperator->GetRawControlCount(i) == 2 ? 0.5f : 0.0f;
// Add the control to the controls group
CDmElement *pControl = CreateElement< CDmElement >( pControlName, pAnimationSet->GetFileId() );
Assert( pControl );
controls.InsertBefore( i, pControl );
pControl->SetValue( "combo", bIsStereoControl );
pControl->SetValue( "multi", bIsMultiControl );
if ( bIsStereoControl )
{
const Vector2D &value = m_hCombinationOperator->GetStereoControlValue(i);
pControl->SetValue( "value", value.x );
pControl->SetValue( "balance", value.y );
}
else
{
pControl->SetValue( "value", m_hCombinationOperator->GetControlValue(i) );
}
if ( bIsMultiControl )
{
pControl->SetValue( "multilevel", m_hCombinationOperator->GetMultiControlLevel(i) );
}
pControl->SetValue( "defaultValue", flDefaultValue );
pControl->SetValue( "defaultBalance", 0.5f );
pControl->SetValue( "defaultMultilevel", 0.5f );
}
int nLastControl = controls.Count();
if ( nLastControl == nFirstControl )
return;
// Add new controls to the root group
CDmElement *pGroup = pAnimationSet->FindOrAddSelectionGroup( "Root" );
// Fill in members
CDmrStringArray groups( pGroup, "selectedControls" );
for ( int i = nFirstControl; i < nLastControl; ++i )
{
groups.AddToTail( controls[ i ]->GetName() );
}
}
//-----------------------------------------------------------------------------
// Creates the procedural presets
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::ComputeProceduralPresets()
{
CDmeAnimationSet *pAnimationSet = m_AnimSet.Get();
// Now create some presets
CDmePresetGroup* pPresetGroup = pAnimationSet->FindOrAddPresetGroup( "procedural" );
pPresetGroup->m_bIsReadOnly = true;
// NOTE: Default needs no values set into it since it's the default
CDmElement *pPreset = pPresetGroup->FindOrAddPreset( "Default" );
pPreset = pPresetGroup->FindOrAddPreset( "Zero" );
GenerateProceduralPresetValues( pPreset, pAnimationSet->GetControls(), true, 0.0f );
pPreset = pPresetGroup->FindOrAddPreset( "Half" );
GenerateProceduralPresetValues( pPreset, pAnimationSet->GetControls(), true, 0.5f );
pPreset = pPresetGroup->FindOrAddPreset( "One" );
GenerateProceduralPresetValues( pPreset, pAnimationSet->GetControls(), true, 1.0f );
pPreset = pPresetGroup->FindOrAddPreset( "Random" );
GenerateProceduralPresetValues( pPreset, pAnimationSet->GetControls(), false );
pAnimationSet->EnsureProceduralPresets();
}
//-----------------------------------------------------------------------------
// Sort control names to match the combination controls
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::SortAnimationSetControls()
{
CDmaElementArray<> &controls = m_AnimSet->GetControls();
int nControlCount = controls.Count();
if ( nControlCount == 0 )
return;
int nCombinationControlCount = m_hCombinationOperator->GetControlCount();
Assert( nControlCount == nCombinationControlCount );
DmElementHandle_t *pElements = (DmElementHandle_t*)_alloca( nControlCount * sizeof(DmElementHandle_t) );
for ( int i = 0; i < nCombinationControlCount; ++i )
{
const char *pControlName = m_hCombinationOperator->GetControlName( i );
CDmElement *pControl = m_AnimSet->FindControl( pControlName );
pElements[i] = pControl->GetHandle();
}
controls.SetMultiple( 0, nControlCount, pElements );
#ifdef _DEBUG
for ( int i = 0; i < nCombinationControlCount; ++i )
{
const char *pControlName = controls[i]->GetName();
const char *pComboName = m_hCombinationOperator->GetControlName( i );
Assert( !Q_stricmp( pControlName, pComboName ) );
}
#endif
}
//-----------------------------------------------------------------------------
// Called when the animation set has to be made to match the combination operator
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::RefreshAnimationSet()
{
if ( !m_AnimSet.Get() )
return;
CDisableUndoScopeGuard sg;
// Remove all controls in the animation set and in presets that don't exist in the combination system
RemoveUnusedAnimationSetControls();
// Modify controls in the presets which have had stereo or multilevel settings changed
ModifyExistingAnimationSetControls();
// Add all controls not in the animation set but which do exist in the combination system
AddNewAnimationSetControls();
// Resets the procedural presets
ComputeProceduralPresets();
// Sort control names to match the combination controls
SortAnimationSetControls();
// Set that as the current set
BaseClass::ChangeAnimationSet( m_AnimSet );
}
void CDmeCombinationOperatorPanel::RefreshCombinationOperator()
{
RefreshAnimationSet();
}
//-----------------------------------------------------------------------------
// Simulate
//-----------------------------------------------------------------------------
void CDmeCombinationOperatorPanel::OnTick()
{
BaseClass::OnTick();
if ( m_hCombinationOperator )
{
{
CDisableUndoScopeGuard sg;
int c = m_hCombinationOperator->GetControlCount();
for ( int i = 0; i < c; ++i )
{
AttributeValue_t value;
bool bVisible = GetAttributeSlider()->GetSliderValues( &value, i );
if ( !bVisible )
continue;
if ( m_hCombinationOperator->IsStereoControl( i ) )
{
m_hCombinationOperator->SetControlValue( i, value.m_pValue[ANIM_CONTROL_VALUE], value.m_pValue[ANIM_CONTROL_BALANCE] );
}
else
{
m_hCombinationOperator->SetControlValue( i, value.m_pValue[ANIM_CONTROL_VALUE] );
}
if ( m_hCombinationOperator->IsMultiControl( i ) )
{
m_hCombinationOperator->SetMultiControlLevel( i, value.m_pValue[ANIM_CONTROL_MULTILEVEL] );
}
}
}
// FIXME: Shouldn't this happen at the application level?
// run the machinery - apply, resolve, dependencies, operate, resolve
CUtlVector< IDmeOperator* > operators;
operators.AddToTail( m_hCombinationOperator );
CDisableUndoScopeGuard guard;
g_pDmElementFramework->SetOperators( operators );
g_pDmElementFramework->Operate( true );
}
// allow elements and attributes to be edited again
g_pDmElementFramework->BeginEdit();
}
//-----------------------------------------------------------------------------
// Constructor, destructor
//-----------------------------------------------------------------------------
CDmeDagEditPanel::CDmeDagEditPanel( vgui::Panel *pParent, const char *pName ) : BaseClass( pParent, pName )
{
m_pPropertiesSplitter = new vgui::Splitter( this, "PropertiesSplitter", vgui::SPLITTER_MODE_VERTICAL, 1 );
vgui::Panel *pSplitterLeftSide = m_pPropertiesSplitter->GetChild( 0 );
vgui::Panel *pSplitterRightSide = m_pPropertiesSplitter->GetChild( 1 );
m_pDagRenderPanel = new CDmeDagRenderPanel( pSplitterRightSide, "DagRenderPanel" );
m_pEditorSheet = new vgui::PropertySheet( pSplitterLeftSide, "EditorSheet" );
m_pEditorSheet->AddActionSignalTarget( this );
m_pAnimationPage = new vgui::PropertyPage( m_pEditorSheet, "AnimationPage" );
m_pCombinationPage = new vgui::PropertyPage( m_pEditorSheet, "AnimationSetEditor" );
m_pVertexAnimationPage = new vgui::PropertyPage( m_pEditorSheet, "VertexAnimationPage" );
m_pCombinationPanel = new CDmeCombinationOperatorPanel( m_pCombinationPage, "AnimationSetEditorPanel" );
m_pCombinationPanel->CreateToolsSubPanels();
m_pAnimationListPanel = new CDmeAnimationListPanel( m_pAnimationPage, "AnimationListPanel" );
m_pAnimationListPanel->AddActionSignalTarget( this );
m_pVertexAnimationListPanel = new CDmeAnimationListPanel( m_pVertexAnimationPage, "VertexAnimationListPanel" );
m_pVertexAnimationListPanel->AddActionSignalTarget( this );
m_pCombinationPage->LoadControlSettingsAndUserConfig( "resource/dmedageditpanel_animationseteditorpage.res" );
m_pAnimationPage->LoadControlSettingsAndUserConfig( "resource/dmedageditpanel_animationpage.res" );
m_pVertexAnimationPage->LoadControlSettingsAndUserConfig( "resource/dmedageditpanel_vertexanimationpage.res" );
// Load layout settings; has to happen before pinning occurs in code
LoadControlSettingsAndUserConfig( "resource/dmedageditpanel.res" );
// NOTE: Page adding happens *after* LoadControlSettingsAndUserConfig
// because the layout of the sheet is correct at this point.
m_pEditorSheet->AddPage( m_pAnimationPage, "Animation" );
m_pEditorSheet->AddPage( m_pCombinationPage, "Combination" );
m_pEditorSheet->AddPage( m_pVertexAnimationPage, "Vertex Animation" );
}
CDmeDagEditPanel::~CDmeDagEditPanel()
{
}
//-----------------------------------------------------------------------------
// Set the scene
//-----------------------------------------------------------------------------
void CDmeDagEditPanel::SetDmeElement( CDmeDag *pScene )
{
m_pDagRenderPanel->SetDmeElement( pScene );
}
//-----------------------------------------------------------------------------
// Sets up the various panels in the dag editor
//-----------------------------------------------------------------------------
void CDmeDagEditPanel::SetMakefileRootElement( CDmElement *pRoot )
{
CDmeAnimationList *pAnimationList = pRoot->GetValueElement< CDmeAnimationList >( "animationList" );
SetAnimationList( pAnimationList );
CDmeAnimationList *pVertexAnimationList = pRoot->GetValueElement< CDmeAnimationList >( "vertexAnimationList" );
SetVertexAnimationList( pVertexAnimationList );
CDmeCombinationOperator *pComboOp = pRoot->GetValueElement< CDmeCombinationOperator >( "combinationOperator" );
SetCombinationOperator( pComboOp );
}
//-----------------------------------------------------------------------------
// Other methods which hook into DmePanel
//-----------------------------------------------------------------------------
void CDmeDagEditPanel::SetDmeElement( CDmeSourceSkin *pSkin )
{
m_pDagRenderPanel->SetDmeElement( pSkin );
// First, try to grab the dependent makefile
CDmeMakefile *pSourceMakefile = pSkin->GetDependentMakefile();
if ( !pSourceMakefile )
return;
// Next, try to grab the output of that makefile
CDmElement *pOutput = pSourceMakefile->GetOutputElement( true );
if ( !pOutput )
return;
SetMakefileRootElement( pOutput );
}
void CDmeDagEditPanel::SetDmeElement( CDmeSourceAnimation *pAnimation )
{
m_pDagRenderPanel->SetDmeElement( pAnimation );
// First, try to grab the dependent makefile
CDmeMakefile *pSourceMakefile = pAnimation->GetDependentMakefile();
if ( !pSourceMakefile )
return;
// Next, try to grab the output of that makefile
CDmElement *pOutput = pSourceMakefile->GetOutputElement( true );
if ( !pOutput )
return;
SetMakefileRootElement( pOutput );
// if ( pAnimationList->FindAnimation( pAnimation->m_SourceAnimationName ) < 0 )
// return;
}
void CDmeDagEditPanel::SetDmeElement( CDmeDCCMakefile *pDCCMakefile )
{
m_pDagRenderPanel->SetDmeElement( pDCCMakefile );
// First, try to grab the dependent makefile
CDmElement *pOutput = pDCCMakefile->GetOutputElement( true );
if ( !pOutput )
return;
SetMakefileRootElement( pOutput );
}
CDmeDag *CDmeDagEditPanel::GetDmeElement()
{
return m_pDagRenderPanel->GetDmeElement();
}
//-----------------------------------------------------------------------------
// paint it!
//-----------------------------------------------------------------------------
void CDmeDagEditPanel::Paint()
{
BaseClass::Paint();
}
//-----------------------------------------------------------------------------
// Sets animation
//-----------------------------------------------------------------------------
void CDmeDagEditPanel::SetAnimationList( CDmeAnimationList *pAnimationList )
{
m_pDagRenderPanel->SetAnimationList( pAnimationList );
m_pDagRenderPanel->SelectAnimation( "" );
m_pAnimationListPanel->SetAnimationList( pAnimationList );
}
void CDmeDagEditPanel::SetVertexAnimationList( CDmeAnimationList *pAnimationList )
{
m_pDagRenderPanel->SetVertexAnimationList( pAnimationList );
m_pDagRenderPanel->SelectVertexAnimation( "" );
m_pVertexAnimationListPanel->SetAnimationList( pAnimationList );
}
void CDmeDagEditPanel::SetCombinationOperator( CDmeCombinationOperator *pComboOp )
{
m_pCombinationPanel->SetCombinationOperator( pComboOp );
}
void CDmeDagEditPanel::RefreshCombinationOperator()
{
m_pCombinationPanel->RefreshCombinationOperator();
}
//-----------------------------------------------------------------------------
// Called when the page changes
//-----------------------------------------------------------------------------
void CDmeDagEditPanel::OnPageChanged( )
{
if ( m_pEditorSheet->GetActivePage() == m_pCombinationPage )
{
m_pDagRenderPanel->SelectAnimation( "" );
m_pDagRenderPanel->SelectVertexAnimation( "" );
return;
}
if ( m_pEditorSheet->GetActivePage() == m_pAnimationPage )
{
m_pDagRenderPanel->SelectAnimation( m_pAnimationListPanel->GetSelectedAnimation() );
m_pDagRenderPanel->SelectVertexAnimation( "" );
return;
}
if ( m_pEditorSheet->GetActivePage() == m_pVertexAnimationPage )
{
m_pDagRenderPanel->SelectAnimation( "" );
m_pDagRenderPanel->SelectVertexAnimation( m_pVertexAnimationListPanel->GetSelectedAnimation() );
return;
}
}
//-----------------------------------------------------------------------------
// Called when new animations are selected
//-----------------------------------------------------------------------------
void CDmeDagEditPanel::OnAnimationSelected( KeyValues *pKeyValues )
{
vgui::Panel *pPanel = (vgui::Panel *)pKeyValues->GetPtr( "panel", NULL );
const char *pAnimationName = pKeyValues->GetString( "animationName", "" );
if ( pPanel == m_pAnimationListPanel )
{
m_pDagRenderPanel->SelectAnimation( pAnimationName );
return;
}
if ( pPanel == m_pVertexAnimationListPanel )
{
m_pDagRenderPanel->SelectVertexAnimation( pAnimationName );
return;
}
}
void CDmeDagEditPanel::OnAnimationDeselected( KeyValues *pKeyValues )
{
vgui::Panel *pPanel = (vgui::Panel *)pKeyValues->GetPtr( "panel", NULL );
if ( pPanel == m_pAnimationListPanel )
{
m_pDagRenderPanel->SelectAnimation( "" );
return;
}
if ( pPanel == m_pVertexAnimationListPanel )
{
m_pDagRenderPanel->SelectVertexAnimation( "" );
return;
}
}