csgo/cstrike15_src/movieobjects/dmecombinationoperator.cpp

//====== Copyright © 1996-2004, Valve Corporation, All rights reserved. =======
//
// Purpose: 
//
//=============================================================================
#include "movieobjects/dmecombinationoperator.h"
#include "movieobjects_interfaces.h"
#include "datamodel/dmelementfactoryhelper.h"
#include "datamodel/dmattribute.h"
#include "movieobjects/dmechannel.h"
#include "movieobjects/dmemodel.h"
#include "movieobjects/dmeshape.h"
#include "movieobjects/dmedag.h"
#include "movieobjects/dmeclip.h"
#include "movieobjects/dmelog.h"
#include "movieobjects/dmevertexdata.h"
#include "movieobjects/dmemesh.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"


//-----------------------------------------------------------------------------
// Expose this class to the scene database 
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeCombinationInputControl, CDmeCombinationInputControl );


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDmeCombinationInputControl::OnConstruction()
{
	m_RawControlNames.Init( this, "rawControlNames" );
	m_bIsStereo.Init( this, "stereo" );
	m_bIsEyelid.InitAndSet( this, "eyelid", false );
	m_WrinkleScales.Init( this, "wrinkleScales" );
}

void CDmeCombinationInputControl::OnDestruction()
{
}


//-----------------------------------------------------------------------------
// Backward compat
//-----------------------------------------------------------------------------
void CDmeCombinationInputControl::OnElementUnserialized()
{
	BaseClass::OnElementUnserialized();

	int nWrinkleCount = m_WrinkleScales.Count();
	int nControlCount = m_RawControlNames.Count();
	if ( nWrinkleCount < nControlCount )
	{
		for ( int i = nWrinkleCount; i < nControlCount; ++i )
		{
			m_WrinkleScales.AddToTail( 0.0f );
		}
	}
	else if ( nWrinkleCount > nControlCount )
	{
		m_WrinkleScales.RemoveMultiple( nControlCount, nWrinkleCount - nControlCount );
	}
}


//-----------------------------------------------------------------------------
// Adds a control, returns the control index
//-----------------------------------------------------------------------------
bool CDmeCombinationInputControl::AddRawControl( const char *pRawControlName )
{
	Assert( !strchr( pRawControlName, '_' ) && !strchr( pRawControlName, ' ' ) );
	int nCount = m_RawControlNames.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		if ( !Q_stricmp( pRawControlName, m_RawControlNames[i] ) )
			return false;
	}

	m_RawControlNames.AddToTail( pRawControlName );
	m_WrinkleScales.AddToTail( 0.0f );
	return true;
}


//-----------------------------------------------------------------------------
// Finds a raw control by name
//-----------------------------------------------------------------------------
int CDmeCombinationInputControl::FindRawControl( const char *pRawControlName )
{
	Assert( !strchr( pRawControlName, '_' ) && !strchr( pRawControlName, ' ' ) );
	int nCount = m_RawControlNames.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		if ( !Q_stricmp( pRawControlName, m_RawControlNames[i] ) )
			return i;
	}
	return -1;
}


//-----------------------------------------------------------------------------
// Removes controls
//-----------------------------------------------------------------------------
bool CDmeCombinationInputControl::RemoveRawControl( const char *pRawControlName )
{
	int i = FindRawControl( pRawControlName );
	if ( i >= 0 )
	{
		m_RawControlNames.FastRemove( i );
		m_WrinkleScales.FastRemove( i );
		return true;
	}

	return false;
}

void CDmeCombinationInputControl::RemoveAllRawControls()
{
	m_RawControlNames.RemoveAll();
	m_WrinkleScales.RemoveAll( );
}


//-----------------------------------------------------------------------------
// Iterates remapped controls
//-----------------------------------------------------------------------------
int CDmeCombinationInputControl::RawControlCount() const
{
	return m_RawControlNames.Count();
}

const char *CDmeCombinationInputControl::RawControlName( int nIndex ) const
{
	return m_RawControlNames[ nIndex ];
}


//-----------------------------------------------------------------------------
// Is this control a stereo control?
//-----------------------------------------------------------------------------
bool CDmeCombinationInputControl::IsStereo() const
{
	return m_bIsStereo;
}

void CDmeCombinationInputControl::SetStereo( bool bStereo )
{
	m_bIsStereo = bStereo;
}


//-----------------------------------------------------------------------------
// Is this control an eyelid control?
//-----------------------------------------------------------------------------
bool CDmeCombinationInputControl::IsEyelid() const
{
	return m_bIsEyelid;
}

void CDmeCombinationInputControl::SetEyelid( bool bEyelid )
{
	m_bIsEyelid = bEyelid;
}


//-----------------------------------------------------------------------------
// Reordering controls
//-----------------------------------------------------------------------------
void CDmeCombinationInputControl::MoveRawControlUp( const char *pRawControlName )
{
	int nIndex = FindRawControl( pRawControlName );
	if ( nIndex > 0 )
	{
		m_RawControlNames.Swap( nIndex, nIndex - 1 );
		m_WrinkleScales.Swap( nIndex, nIndex - 1 );
	}
}

void CDmeCombinationInputControl::MoveRawControlDown( const char *pRawControlName )
{
	int nIndex = FindRawControl( pRawControlName );
	int nLastIndex = m_RawControlNames.Count() - 1;
	if ( nIndex >= 0 && nIndex < nLastIndex )
	{
		m_RawControlNames.Swap( nIndex, nIndex + 1 );
		m_WrinkleScales.Swap( nIndex, nIndex + 1 );
	}
}


//-----------------------------------------------------------------------------
// Returns the wrinkle scale for a particular control
//-----------------------------------------------------------------------------
float CDmeCombinationInputControl::WrinkleScale( const char *pRawControlName )
{
	int nIndex = FindRawControl( pRawControlName );
	return WrinkleScale( nIndex );
}

float CDmeCombinationInputControl::WrinkleScale( int nIndex )
{
	if ( nIndex < 0 || ( nIndex >= m_WrinkleScales.Count() ) )
		return 0.0f;
	return m_WrinkleScales[ nIndex ];
}

void CDmeCombinationInputControl::SetWrinkleScale( const char *pRawControlName, float flWrinkleScale )
{
	int nIndex = FindRawControl( pRawControlName );
	if ( nIndex < 0 || ( nIndex >= m_WrinkleScales.Count() ) )
		return;
	m_WrinkleScales.Set( nIndex, flWrinkleScale );
}


//-----------------------------------------------------------------------------
// The default value of an input control is the value the UI has by default
//-----------------------------------------------------------------------------
float CDmeCombinationInputControl::GetDefaultValue() const
{
	return RawControlCount() == 2 ? 0.5f : 0.0f;
}


//-----------------------------------------------------------------------------
// The base value of an input control will set the data to the base state
// i.e. The state upon which the deltas are relative.  Normally this is the
//      same as GetDefaultValue() except for EyeLid controls
//-----------------------------------------------------------------------------
float CDmeCombinationInputControl::GetBaseValue() const
{
	if ( IsEyelid() )
		return 0.0f;

	return GetDefaultValue();
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const char *CDmeCombinationInputControl::GetEyesUpDownFlexName() const
{
	const CDmAttribute *pEyesUpDownFlexAttr = GetAttribute( "eyesUpDownFlex", AT_STRING );

	if ( pEyesUpDownFlexAttr )
		return pEyesUpDownFlexAttr->GetValueString();

	return NULL;
}


//-----------------------------------------------------------------------------
// Expose this class to the scene database 
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeCombinationDominationRule, CDmeCombinationDominationRule );


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDmeCombinationDominationRule::OnConstruction()
{
	m_Dominators.Init( this, "dominators", FATTRIB_HAS_CALLBACK );
	m_Suppressed.Init( this, "suppressed", FATTRIB_HAS_CALLBACK );
}

void CDmeCombinationDominationRule::OnDestruction()
{
}


//-----------------------------------------------------------------------------
// Notify parent that one of our attributes has changed
//-----------------------------------------------------------------------------
void CDmeCombinationDominationRule::OnAttributeChanged( CDmAttribute *pAttribute )
{
	BaseClass::OnAttributeChanged( pAttribute );

	if ( pAttribute == m_Dominators.GetAttribute() || pAttribute == m_Suppressed.GetAttribute() )
	{
		InvokeOnAttributeChangedOnReferrers( GetHandle(), pAttribute );
	}
}


//-----------------------------------------------------------------------------
// Do we have this string already?
//-----------------------------------------------------------------------------
bool CDmeCombinationDominationRule::HasString( const char *pString, const CDmaStringArray& attr )
{
	int nCount = attr.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		if ( !Q_stricmp( pString, attr[i] ) )
			return true;
	}
	return false;
}


//-----------------------------------------------------------------------------
// Adds a dominating control
//-----------------------------------------------------------------------------
void CDmeCombinationDominationRule::AddDominator( const char *pDominatorControl )
{
	if ( HasString( pDominatorControl, m_Dominators ) )
	{
		Warning( "Domination rule already contains dominating control %s\n", pDominatorControl );
		return;
	}
	if ( HasString( pDominatorControl, m_Suppressed ) )
	{
		Warning( "Attempted to add a control as both dominator + suppressed %s\n", pDominatorControl );
		return;
	}
	m_Dominators.AddToTail( pDominatorControl );
}


//-----------------------------------------------------------------------------
// Add a suppressed control
//-----------------------------------------------------------------------------
void CDmeCombinationDominationRule::AddSuppressed( const char *pSuppressedControl )
{
	if ( HasString( pSuppressedControl, m_Suppressed ) )
	{
		Warning( "Domination rule already contains suppressed control %s\n", pSuppressedControl );
		return;
	}
	if ( HasString( pSuppressedControl, m_Dominators ) )
	{
		Warning( "Attempted to add a control as both dominator + suppressed %s\n", pSuppressedControl );
		return;
	}
	m_Suppressed.AddToTail( pSuppressedControl );
}


//-----------------------------------------------------------------------------
// Remove all dominatior + suppressed controls
//-----------------------------------------------------------------------------
void CDmeCombinationDominationRule::RemoveAllDominators()
{
	m_Dominators.RemoveAll();
}

void CDmeCombinationDominationRule::RemoveAllSuppressed()
{
	m_Suppressed.RemoveAll();
}


//-----------------------------------------------------------------------------
// Iteration
//-----------------------------------------------------------------------------
int CDmeCombinationDominationRule::DominatorCount() const
{
	return m_Dominators.Count();
}

const char *CDmeCombinationDominationRule::GetDominator( int i ) const
{
	return m_Dominators[i];
}

int CDmeCombinationDominationRule::SuppressedCount() const
{
	return m_Suppressed.Count();
}

const char *CDmeCombinationDominationRule::GetSuppressed( int i ) const
{
	return m_Suppressed[i];
}


//-----------------------------------------------------------------------------
// Search
//-----------------------------------------------------------------------------
bool CDmeCombinationDominationRule::HasDominatorControl( const char *pDominatorControl ) const
{
	int nCount = DominatorCount();
	for ( int i = 0; i < nCount; ++i )
	{
		if ( !Q_stricmp( GetDominator(i), pDominatorControl ) )
			return true;
	}
	return false;
}

bool CDmeCombinationDominationRule::HasSuppressedControl( const char *pSuppressedControl ) const
{
	int nCount = SuppressedCount();
	for ( int i = 0; i < nCount; ++i )
	{
		if ( !Q_stricmp( GetSuppressed(i), pSuppressedControl ) )
			return true;
	}
	return false;
}


//-----------------------------------------------------------------------------
// Expose this class to the scene database 
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeCombinationOperator, CDmeCombinationOperator );


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::OnConstruction()
{
	m_InputControls.Init( this, "controls" );
	m_ControlValues[COMBO_CONTROL_NORMAL].Init( this, "controlValues" );
	m_ControlValues[COMBO_CONTROL_LAGGED].Init( this, "controlValuesLagged" );
	m_bSpecifyingLaggedData.Init( this, "usesLaggedValues" );

	m_Dominators.Init( this, "dominators", FATTRIB_HAS_CALLBACK );

	m_Targets.Init( this, "targets" );
	m_flLastLaggedComputationTime = FLT_MIN;
}

void CDmeCombinationOperator::OnDestruction()
{
	m_RawControlInfo.RemoveAll();
	m_CombinationInfo.RemoveAll();
	m_DominatorInfo.RemoveAll();
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::OnAttributeChanged( CDmAttribute *pAttribute )
{
	m_Dominators.GetAttribute()->AddFlag( FATTRIB_DIRTY );
}


//-----------------------------------------------------------------------------
// Finds the index of the input control with the specified name (and creates one if necessary) 
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::OnElementUnserialized()
{
	BaseClass::OnElementUnserialized();

	// Mark all of the input as not being in their default state since we read it from a file
	int nCount = m_InputControls.Count();
	m_IsDefaultValue.SetCount( nCount );
	for ( int i = 0; i < nCount; ++i ) 
	{
		m_IsDefaultValue[i] = false;
	}
}


//-----------------------------------------------------------------------------
// Finds the index of the input control with the specified name (and creates one if necessary) 
//-----------------------------------------------------------------------------
ControlIndex_t CDmeCombinationOperator::FindOrCreateControl( const char *pControlName, bool bStereo, bool bAutoAddRawControl )
{
	Assert( !strchr( pControlName, '_' ) && !strchr( pControlName, ' ' ) );
	int nCount = m_InputControls.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		if ( !m_InputControls[i] )
			continue;

		if ( !Q_stricmp( pControlName, m_InputControls[i]->GetName() ) )
			return i;
	}

	// NOTE: the y coordinate of the control value is -1 if it's not a stereo control
	CDmeCombinationInputControl *pInputControl = CreateElement< CDmeCombinationInputControl >( pControlName, GetFileId() );
	pInputControl->SetStereo( bStereo );
	int nIndex = m_InputControls.AddToTail( pInputControl );
	m_ControlValues[COMBO_CONTROL_NORMAL].AddToTail( Vector( 0.0f, 0.0f, 0.5f ) );
	m_ControlValues[COMBO_CONTROL_LAGGED].AddToTail( Vector( 0.0f, 0.0f, 0.5f ) );
	m_IsDefaultValue.AddToTail( true );
	Assert( m_InputControls.Count() == m_ControlValues[COMBO_CONTROL_NORMAL].Count() );
	Assert( m_InputControls.Count() == m_ControlValues[COMBO_CONTROL_LAGGED].Count() );
	Assert( m_InputControls.Count() == m_IsDefaultValue.Count() );

	if ( bAutoAddRawControl )
	{
		AddRawControl( nIndex, pControlName );
	}

	return nIndex;
}


//-----------------------------------------------------------------------------
// Finds the index of the input control with the specified name
//-----------------------------------------------------------------------------
ControlIndex_t CDmeCombinationOperator::FindControlIndex( const char *pControlName )
{
	int nCount = m_InputControls.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		if ( !m_InputControls[i] )
			continue;

		if ( !Q_stricmp( pControlName, m_InputControls[i]->GetName() ) )
			return i;
	}
	return -1;
}


//-----------------------------------------------------------------------------
// Removes a control
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::RemoveControl( const char *pControlName )
{
	ControlIndex_t nIndex = FindControlIndex( pControlName );
	if ( nIndex >= 0 )
	{
		DestroyElement( m_InputControls[nIndex] );
		m_InputControls.FastRemove( nIndex );
		m_ControlValues[COMBO_CONTROL_NORMAL].FastRemove( nIndex );
		m_ControlValues[COMBO_CONTROL_LAGGED].FastRemove( nIndex );
		m_IsDefaultValue.FastRemove( nIndex );

		Assert( m_InputControls.Count() == m_ControlValues[COMBO_CONTROL_NORMAL].Count() );
		Assert( m_InputControls.Count() == m_ControlValues[COMBO_CONTROL_LAGGED].Count() );
		Assert( m_InputControls.Count() == m_IsDefaultValue.Count() );

		RebuildRawControlList();
	}
}

void CDmeCombinationOperator::RemoveAllControls()
{
	int nCount = m_InputControls.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		CDmeCombinationInputControl *pInputControl = m_InputControls[i];
		m_InputControls.Set( i, NULL );
		DestroyElement( pInputControl );
	}
	m_InputControls.RemoveAll();
	m_ControlValues[COMBO_CONTROL_NORMAL].RemoveAll( );
	m_ControlValues[COMBO_CONTROL_LAGGED].RemoveAll( );
	m_IsDefaultValue.RemoveAll( );

	RebuildRawControlList();
}


//-----------------------------------------------------------------------------
// Changes a control's name
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::SetControlName( ControlIndex_t nControl, const char *pControlName )
{
	ControlIndex_t nFoundIndex = FindControlIndex( pControlName );
	if ( nFoundIndex >= 0 && nFoundIndex != nControl )
	{
		Warning( "A control with name \"%s\" already exists!\n", pControlName );
		return;
	}
	m_InputControls[nControl]->SetName( pControlName );
}


//-----------------------------------------------------------------------------
// Updates the default value associated with a control
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::UpdateDefaultValue( ControlIndex_t nControlIndex )
{
	if ( m_IsDefaultValue[ nControlIndex ] )
	{
		float flDefaultValue = GetRawControlCount( nControlIndex ) == 2 ? 0.5f : 0.0f;
		const Vector& vec = m_ControlValues[COMBO_CONTROL_NORMAL][nControlIndex];
		m_ControlValues[COMBO_CONTROL_NORMAL].Set( nControlIndex, Vector( flDefaultValue, flDefaultValue, vec.z ) );
		const Vector& vec2 = m_ControlValues[COMBO_CONTROL_LAGGED][nControlIndex];
		m_ControlValues[COMBO_CONTROL_LAGGED].Set( nControlIndex, Vector( flDefaultValue, flDefaultValue, vec2.z ) );
	}
}


//-----------------------------------------------------------------------------
// Adds an output control to a input control
// If force is true, removes the raw control from any existing controls
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::AddRawControl( ControlIndex_t nControl, const char *pRawControlName )
{
	if ( FindRawControlIndex( pRawControlName, true ) >= 0 )
	{
		Warning( "Attempted to add the same remapped control \"%s\" twice!\n", pRawControlName );
		return;
	}

	CDmeCombinationInputControl *pInputControl = m_InputControls[nControl];
	Assert( pInputControl );
	if ( pInputControl->AddRawControl( pRawControlName ) )
	{
		UpdateDefaultValue( nControl );
		RebuildRawControlList();
	}
}


//-----------------------------------------------------------------------------
// Removes an output control from an input control
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::RemoveRawControl( ControlIndex_t nControl, const char *pRawControlName )
{
	CDmeCombinationInputControl *pInputControl = m_InputControls[nControl];
	Assert( pInputControl );
	if ( pInputControl->RemoveRawControl( pRawControlName ) )
	{
		UpdateDefaultValue( nControl );
		RebuildRawControlList();
	}
}

void CDmeCombinationOperator::RemoveAllRawControls( ControlIndex_t nControl )
{
	CDmeCombinationInputControl *pInputControl = m_InputControls[nControl];
	Assert( pInputControl );
	pInputControl->RemoveAllRawControls( );

	int nCount = m_InputControls.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		UpdateDefaultValue( i );
	}

	RebuildRawControlList();
}


//-----------------------------------------------------------------------------
// Iterates remapped controls
//-----------------------------------------------------------------------------
int CDmeCombinationOperator::GetRawControlCount( ControlIndex_t nControl ) const
{
	CDmeCombinationInputControl *pInputControl = m_InputControls[nControl];
	Assert( pInputControl );
	return pInputControl->RawControlCount();
}

const char *CDmeCombinationOperator::GetRawControlName( ControlIndex_t nControl, int nIndex ) const
{
	CDmeCombinationInputControl *pInputControl = m_InputControls[nControl];
	Assert( pInputControl );
	return pInputControl->RawControlName( nIndex );
}

float CDmeCombinationOperator::GetRawControlWrinkleScale( ControlIndex_t nControl, int nIndex ) const
{
	CDmeCombinationInputControl *pInputControl = m_InputControls[nControl];
	Assert( pInputControl );
	return pInputControl->WrinkleScale( nIndex );
}

float CDmeCombinationOperator::GetRawControlWrinkleScale( ControlIndex_t nControl, const char *pRawControlName ) const
{
	CDmeCombinationInputControl *pInputControl = m_InputControls[nControl];
	Assert( pInputControl );
	return pInputControl->WrinkleScale( pRawControlName );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
float CDmeCombinationOperator::GetControlDefaultValue( ControlIndex_t nControl ) const
{
	CDmeCombinationInputControl *pInputControl = m_InputControls[nControl];
	Assert( pInputControl );
	return pInputControl->GetDefaultValue();
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
float CDmeCombinationOperator::GetControlBaseValue( ControlIndex_t nControl ) const
{
	CDmeCombinationInputControl *pInputControl = m_InputControls[nControl];
	Assert( pInputControl );
	return pInputControl->GetBaseValue();
}


//-----------------------------------------------------------------------------
// Iterates a global list of output controls
//-----------------------------------------------------------------------------
int CDmeCombinationOperator::GetRawControlCount( ) const
{
	return m_RawControlInfo.Count();
}

const char *CDmeCombinationOperator::GetRawControlName( int nIndex ) const
{
	return m_RawControlInfo[nIndex].m_Name;
}

float CDmeCombinationOperator::GetRawControlWrinkleScale( int nIndex ) const
{
	return m_RawControlInfo[nIndex].m_flWrinkleScale;
}


//-----------------------------------------------------------------------------
// Sets the wrinkle scale for a particular raw control
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::SetWrinkleScale( ControlIndex_t nControl, const char *pRawControlName, float flWrinkleScale )
{
	CDmeCombinationInputControl *pInputControl = m_InputControls[nControl];
	Assert( pInputControl );
	const float flOldWrinkleScale = pInputControl->WrinkleScale( pRawControlName );
	pInputControl->SetWrinkleScale( pRawControlName, flWrinkleScale );

	for ( int nTargetIndex = 0; nTargetIndex < m_Targets.Count(); ++nTargetIndex )
	{
		CDmeMesh *pDmeMesh = CastElement< CDmeMesh >( m_Targets[ nTargetIndex ] );
		if ( !pDmeMesh )
			continue;

		CDmeVertexData *pDmeBindState = pDmeMesh->GetBindBaseState();
		if ( !pDmeBindState )
			continue;

		CDmeVertexDeltaData *pDmeDelta = pDmeMesh->FindDeltaState( pRawControlName );
		if ( !pDmeDelta )
			continue;

		pDmeDelta->UpdateWrinkleDelta( pDmeBindState, flOldWrinkleScale, flWrinkleScale );
	}

	RebuildRawControlList();
}


//-----------------------------------------------------------------------------
// Reordering controls
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::MoveControlUp( const char *pControlName )
{

	int nIndex = FindControlIndex( pControlName );
	if ( nIndex > 0 )
	{
		m_InputControls.Swap( nIndex, nIndex - 1 );
		for ( int i = 0; i < COMBO_CONTROL_TYPE_COUNT; ++i )
		{
			m_ControlValues[ i ].Swap( nIndex, nIndex - 1 );
		}
		RebuildRawControlList();
	}
}


//-----------------------------------------------------------------------------
// Reordering controls
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::MoveControlDown( const char *pControlName )
{
	int nIndex = FindControlIndex( pControlName );
	int nLastIndex = m_InputControls.Count() - 1;
	if ( nIndex >= 0 && nIndex < nLastIndex )
	{
		m_InputControls.Swap( nIndex, nIndex + 1 );
		for ( int i = 0; i < COMBO_CONTROL_TYPE_COUNT; ++i )
		{
			m_ControlValues[ i ].Swap( nIndex, nIndex + 1 );
		}
		RebuildRawControlList();
	}
}


//-----------------------------------------------------------------------------
// Reordering controls
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::MoveControlBefore( const char *pDragControlName, const char *pDropControlName )
{
	int pDragIndex( FindControlIndex( pDragControlName ) );
	int pDropIndex( FindControlIndex( pDropControlName ) );

	// Have to copy because InsertAfter may reallocate memory before doing the copy and therefore might be referencing garabage
	CDmeCombinationInputControl *inputControlCopy( m_InputControls[ pDragIndex ] );
	m_InputControls.InsertBefore( pDropIndex, inputControlCopy );
	if ( pDragIndex <= pDropIndex )
	{
		m_InputControls.Remove( pDragIndex );
		for ( int i = 0; i < COMBO_CONTROL_TYPE_COUNT; ++i )
		{
			const Vector controlValueCopy( m_ControlValues[ i ][ pDragIndex ] );
			m_ControlValues[ i ].InsertBefore( pDropIndex, controlValueCopy );
			m_ControlValues[ i ].Remove( pDragIndex );
		}
	}
	else
	{
		m_InputControls.Remove( pDragIndex + 1 );
		for ( int i = 0; i < COMBO_CONTROL_TYPE_COUNT; ++i )
		{
			const Vector controlValueCopy( m_ControlValues[ i ][ pDragIndex ] );
			m_ControlValues[ i ].InsertBefore( pDropIndex, controlValueCopy );
			m_ControlValues[ i ].Remove( pDragIndex + 1 );
		}
	}
}


//-----------------------------------------------------------------------------
// Reordering controls
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::MoveControlAfter( const char *pDragControlName, const char *pDropControlName )
{
	int nDragIndex = FindControlIndex( pDragControlName );
	int nDropIndex = FindControlIndex( pDropControlName );

	// Have to copy because InsertAfter may reallocate memory before doing the copy and therefore might be referencing garabage
	CDmeCombinationInputControl *inputControlCopy( m_InputControls[ nDragIndex ] );
	m_InputControls.InsertBefore( nDropIndex + 1, inputControlCopy );
	if ( nDragIndex < nDropIndex )
	{
		m_InputControls.Remove( nDragIndex );
		for ( int i = 0; i < COMBO_CONTROL_TYPE_COUNT; ++i )
		{
			const Vector controlValueCopy( m_ControlValues[ i ][ nDragIndex ] );
			m_ControlValues[ i ].InsertBefore( nDropIndex + 1, controlValueCopy );
			m_ControlValues[ i ].Remove( nDragIndex );
		}
	}
	else
	{
		m_InputControls.Remove( nDragIndex + 1 );
		for ( int i = 0; i < COMBO_CONTROL_TYPE_COUNT; ++i )
		{
			const Vector controlValueCopy( m_ControlValues[ i ][ nDragIndex ] );
			m_ControlValues[ i ].InsertBefore( nDropIndex + 1, controlValueCopy );
			m_ControlValues[ i ].Remove( nDragIndex + 1 );
		}
	}
}


//-----------------------------------------------------------------------------
// Reordering controls
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::MoveRawControlUp( ControlIndex_t nControlIndex, const char *pRawControlName )
{
	m_InputControls[nControlIndex]->MoveRawControlUp( pRawControlName );
}


//-----------------------------------------------------------------------------
// Reordering controls
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::MoveRawControlDown( ControlIndex_t nControlIndex, const char *pRawControlName )
{
	m_InputControls[nControlIndex]->MoveRawControlDown( pRawControlName );
}


//-----------------------------------------------------------------------------
// Returns true if a control is a stereo control
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::SetStereoControl( ControlIndex_t nControlIndex, bool bIsStereo )
{
	m_InputControls[nControlIndex]->SetStereo( bIsStereo );
}

bool CDmeCombinationOperator::IsStereoControl( ControlIndex_t nControlIndex ) const
{
	return m_InputControls[nControlIndex]->IsStereo();
}

bool CDmeCombinationOperator::IsStereoRawControl( int nIndex ) const
{
	return IsStereoControl( m_RawControlInfo[nIndex].m_InputControl );
}

void CDmeCombinationOperator::SetEyelidControl( ControlIndex_t nControlIndex, bool bIsEyelid )
{
	m_InputControls[nControlIndex]->SetEyelid( bIsEyelid );
}

bool CDmeCombinationOperator::IsEyelidControl( ControlIndex_t nControlIndex ) const
{
	return m_InputControls[nControlIndex]->IsEyelid();
}

bool CDmeCombinationOperator::IsEyelidRawControl( int nIndex ) const
{
	return IsEyelidControl( m_RawControlInfo[nIndex].m_InputControl );
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
const char *CDmeCombinationOperator::GetEyesUpDownFlexName( ControlIndex_t nControlIndex ) const
{
	return m_InputControls[ nControlIndex ]->GetEyesUpDownFlexName();
}


//-----------------------------------------------------------------------------
// Sets the value of a control
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::SetControlValue( ControlIndex_t nControlIndex, float flValue, CombinationControlType_t type )
{
	m_IsDefaultValue[ nControlIndex ] = false;
	float flMultiLevel = m_ControlValues[type][nControlIndex].z;
	m_ControlValues[type].Set( nControlIndex, Vector( flValue, flValue, flMultiLevel ) );
}

void CDmeCombinationOperator::SetControlValue( ControlIndex_t nControlIndex, float flLeftValue, float flRightValue, CombinationControlType_t type )
{
	Assert( IsStereoControl( nControlIndex ) );
	m_IsDefaultValue[ nControlIndex ] = false;
	float flMultiLevel = m_ControlValues[type][nControlIndex].z;
	m_ControlValues[type].Set( nControlIndex, Vector( flLeftValue, flRightValue, flMultiLevel ) );
}

void CDmeCombinationOperator::SetControlValue( ControlIndex_t nControlIndex, const Vector2D& vec, CombinationControlType_t type )
{
	Assert( IsStereoControl( nControlIndex ) );
	m_IsDefaultValue[ nControlIndex ] = false;
	float flMultiLevel = m_ControlValues[type][nControlIndex].z;
	m_ControlValues[type].Set( nControlIndex, Vector( vec.x, vec.y, flMultiLevel ) );
}


//-----------------------------------------------------------------------------
// Sets the value of a control
//-----------------------------------------------------------------------------
float CDmeCombinationOperator::GetControlValue( ControlIndex_t nControlIndex, CombinationControlType_t type )	const
{
	Assert( !IsStereoControl( nControlIndex ) );
	return m_ControlValues[type].Get( nControlIndex ).x;
}


//-----------------------------------------------------------------------------
// Sets the value of a control
//-----------------------------------------------------------------------------
const Vector2D& CDmeCombinationOperator::GetStereoControlValue( ControlIndex_t nControlIndex, CombinationControlType_t type ) const
{
	return m_ControlValues[type].Get( nControlIndex ).AsVector2D();
}


//-----------------------------------------------------------------------------
// Sets the level of a control (only used by controls w/ 3 or more remappings)
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::SetMultiControlLevel( ControlIndex_t nControlIndex, float flMultiLevel, CombinationControlType_t type )
{
	m_IsDefaultValue[ nControlIndex ] = false;
	const Vector2D &value = m_ControlValues[type][nControlIndex].AsVector2D();
	m_ControlValues[type].Set( nControlIndex, Vector( value.x, value.y, flMultiLevel ) );
}

float CDmeCombinationOperator::GetMultiControlLevel( ControlIndex_t nControlIndex, CombinationControlType_t type ) const
{
	Assert( IsMultiControl( nControlIndex ) );
	return m_ControlValues[type][nControlIndex].z;
}


//-----------------------------------------------------------------------------
// Returns true if a control is a multi control (a control w/ 3 or more remappings)
//-----------------------------------------------------------------------------
bool CDmeCombinationOperator::IsMultiControl( ControlIndex_t nControlIndex ) const
{
	return m_InputControls[nControlIndex]->RawControlCount() >= 3 || IsEyelidControl( nControlIndex );
}


//-----------------------------------------------------------------------------
// Iterates controls
//-----------------------------------------------------------------------------
int CDmeCombinationOperator::GetControlCount() const
{
	return m_InputControls.Count();
}

const char *CDmeCombinationOperator::GetControlName( ControlIndex_t i ) const
{
	return m_InputControls[i]->GetName();
}


//-----------------------------------------------------------------------------
// Do we have a raw control?
//-----------------------------------------------------------------------------
bool CDmeCombinationOperator::HasRawControl( const char *pRawControlName ) const
{
	return FindRawControlIndex( pRawControlName ) >= 0;
}


//-----------------------------------------------------------------------------
// Finds the index of the remapped control with the specified name
//-----------------------------------------------------------------------------
CDmeCombinationOperator::RawControlIndex_t CDmeCombinationOperator::FindRawControlIndex( const char *pControlName, bool bIgnoreDefaultControls ) const
{
	int nRawControlCount = m_RawControlInfo.Count();
	for ( int i = 0; i < nRawControlCount; ++i )
	{
		if ( bIgnoreDefaultControls && m_RawControlInfo[i].m_bIsDefaultControl )
			continue;

		if ( !Q_stricmp( pControlName, m_RawControlInfo[i].m_Name ) )
			return i;
	}
	return -1;
}


//-----------------------------------------------------------------------------
// Is a particular remapped control stereo?
//-----------------------------------------------------------------------------
bool CDmeCombinationOperator::IsRawControlStereo( const char *pRawControlName )
{
	RawControlIndex_t nIndex = FindRawControlIndex( pRawControlName );
	if ( nIndex < 0 )
		return false;

	CDmeCombinationInputControl *pInputControl = m_InputControls[ m_RawControlInfo[nIndex].m_InputControl ];
	return pInputControl->IsStereo();
}


//-----------------------------------------------------------------------------
// Would a particular delta state attached to this combination operator end up stereo?
//-----------------------------------------------------------------------------
bool CDmeCombinationOperator::IsDeltaStateStereo( const char *pDeltaStateName )
{
	int *pTemp = (int*)_alloca( m_RawControlInfo.Count() * sizeof(int) );
	int nCount = ParseDeltaName( pDeltaStateName, pTemp );
	for ( int i = 0; i < nCount; ++i )
	{
		CDmeCombinationInputControl *pInputControl = m_InputControls[ m_RawControlInfo[ pTemp[i] ].m_InputControl ];
		if ( pInputControl->IsStereo() )
			return true;
	}
	return false;
}


//-----------------------------------------------------------------------------
// Does one of the targets we refer to contain a particular delta state?
//-----------------------------------------------------------------------------
bool CDmeCombinationOperator::DoesTargetContainDeltaState( const char *pSearchName )
{
	int nTargetCount = m_Targets.Count();
	for ( int i = 0; i < nTargetCount; ++i )
	{
		const CDmrElementArray<> deltaArray( m_Targets[i], "deltaStates" );
		if ( !deltaArray.IsValid() )
			continue;

		int nDeltaCount = deltaArray.Count();
		for ( int j = 0; j < nDeltaCount; ++j )
		{
			if ( !deltaArray[j] )
				continue;

			char pBuf[512];
			Q_strncpy( pBuf, deltaArray[j]->GetName(), sizeof(pBuf) );

			char *pEnd;
			for ( char *pName = pBuf; *pName; pName = pEnd )
			{
				pEnd = strchr( pName, '_' );
				if ( !pEnd )
				{
					pEnd = pName + Q_strlen( pName );
				}
				else
				{
					// Null-terminate
					*pEnd = 0;
					++pEnd;
				}

				if ( !Q_stricmp( pSearchName, pName ) )
					return true;
			}
		}
	}
	return false;
}


//-----------------------------------------------------------------------------
// Computes list of all remapped controls
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::RebuildRawControlList()
{
	m_RawControlInfo.RemoveAll();

	int nControlCount = m_InputControls.Count();
	for ( int i = 0; i < nControlCount; ++i )
	{
		CDmeCombinationInputControl *pInputControl = m_InputControls[i];
		Assert( pInputControl );
		int nRemapCount = pInputControl->RawControlCount();

		const bool bIsEyelid = pInputControl->IsEyelid();

		float flStep = ( nRemapCount > 2 ) ? 1.0f / ( nRemapCount - 1 ) : 0.0f;
		for ( int j = 0; j < nRemapCount; ++j )
		{
			int k = m_RawControlInfo.AddToTail( );
			RawControlInfo_t &info = m_RawControlInfo[k];
			
			info.m_Name = pInputControl->RawControlName( j );
			info.m_InputControl = i;
			info.m_bIsDefaultControl = false;
			info.m_flWrinkleScale = pInputControl->WrinkleScale( j );
			info.m_bLowerEyelid = false;

			if ( bIsEyelid )
			{
				info.m_FilterRamp.Init( 0.0f, 1.0f, 10.0f, 11.0f );
				// TODO: Right now it's implicit that the lower eyelid is first...
				if ( j == 0 )
				{
					// Close Lower Lid
					info.m_bLowerEyelid = true;
				}
				continue;
			}

			switch( nRemapCount )
			{
			case 1:
				info.m_FilterRamp.Init( 0.0f, 1.0f, 10.0f, 11.0f );
				break;

			case 2:
				if ( j == 0 )
				{
					info.m_FilterRamp.Init( -11.0f, -10.0f, 0.0f, 0.5f );
				}
				else
				{
					info.m_FilterRamp.Init( 0.5f, 1.0f, 10.0f, 11.0f );
				}
				break;

			default:
				{
					if ( j == 0 )
					{
						info.m_FilterRamp.Init( -11.0f, -10.0f,	0, flStep );
					}
					else if ( j == nRemapCount-1 )
					{
						info.m_FilterRamp.Init( 1.0f - flStep, 1.0f, 10.0f, 11.0f );
					}
					else
					{
						float flPeak = j * flStep;
						info.m_FilterRamp.Init( flPeak - flStep, flPeak, flPeak, flPeak + flStep );
					}
				}
				break;
			}
		}
	}

	RebuildDominatorInfo();
}


//-----------------------------------------------------------------------------
// Computes lists of dominators and suppressors
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::RebuildDominatorInfo()
{
	m_DominatorInfo.RemoveAll();
	int nCount = m_Dominators.Count();
	int *pDominators = (int*)_alloca( m_RawControlInfo.Count() * sizeof(int) );
	int *pSuppressed = (int*)_alloca( m_RawControlInfo.Count() * sizeof(int) );
	for ( int i = 0; i < nCount; ++i )
	{
		CDmeCombinationDominationRule *pRule = m_Dominators[i];
		bool bRuleOk = true;

		int nDominatorCount = pRule->DominatorCount();
		int nSuppressedCount = pRule->SuppressedCount();
		if ( ( nDominatorCount == 0 ) || ( nSuppressedCount == 0 ) )
			continue;

		for ( int j = 0; j < nDominatorCount; ++j )
		{
			int nControlIndex = FindRawControlIndex( pRule->GetDominator(j) );
			if ( nControlIndex < 0 )
			{
				bRuleOk = false;
				break;
			}
			pDominators[j] = nControlIndex;
		}

		for ( int j = 0; j < nSuppressedCount; ++j )
		{
			int nControlIndex = FindRawControlIndex( pRule->GetSuppressed(j) );
			if ( nControlIndex < 0 )
			{
				bRuleOk = false;
				break;
			}
			pSuppressed[j] = nControlIndex;
		}

		if ( !bRuleOk )
			continue;

		int k = m_DominatorInfo.AddToTail();
		m_DominatorInfo[k].m_DominantIndices.AddMultipleToTail( nDominatorCount, pDominators );
		m_DominatorInfo[k].m_SuppressedIndices.AddMultipleToTail( nSuppressedCount, pSuppressed );
	}
}


//-----------------------------------------------------------------------------
// Adds a dominator. Dominators are specified using raw control names
//-----------------------------------------------------------------------------
CDmeCombinationDominationRule *CDmeCombinationOperator::AddDominationRule( )
{
	CDmeCombinationDominationRule *pDominationRule = CreateElement< CDmeCombinationDominationRule >( "rule", GetFileId() );
	m_Dominators.AddToTail( pDominationRule );
	return pDominationRule;
}


//-----------------------------------------------------------------------------
// Adds a dominator. Dominators are specified using raw control names
//-----------------------------------------------------------------------------
CDmeCombinationDominationRule *CDmeCombinationOperator::AddDominationRule( CDmeCombinationDominationRule *pSrcRule )
{
	CDmeCombinationDominationRule *pDestRule = pSrcRule->Copy( );
	pDestRule->SetFileId( GetFileId(), TD_DEEP );
	m_Dominators.AddToTail( pDestRule );
	return pDestRule;
}


//-----------------------------------------------------------------------------
// Adds a dominator. Dominators are specified using raw control names
//-----------------------------------------------------------------------------
CDmeCombinationDominationRule *CDmeCombinationOperator::AddDominationRule( int nDominatorCount, const char **ppDominatorControlNames, int nSuppressedCount, const char **ppSuppressedControlNames )
{
	CDmeCombinationDominationRule *pDominationRule = AddDominationRule();
	for ( int i = 0; i < nDominatorCount; ++i )
	{
		pDominationRule->AddDominator( ppDominatorControlNames[i] );
	}
	for ( int i = 0; i < nSuppressedCount; ++i )
	{
		pDominationRule->AddSuppressed( ppSuppressedControlNames[i] );
	}
	return pDominationRule;
}


//-----------------------------------------------------------------------------
// Adds a dominator. Dominators are specified using raw control names
//-----------------------------------------------------------------------------
CDmeCombinationDominationRule *CDmeCombinationOperator::AddDominationRule( const CUtlVector< const char * > dominators, const CUtlVector< const char * > suppressed )
{
	return AddDominationRule( dominators.Count(), (const char **)dominators.Base(), suppressed.Count(), (const char **)suppressed.Base() );
}


//-----------------------------------------------------------------------------
// Removes a domination rule
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::RemoveDominationRule( int nIndex )
{
	CDmeCombinationDominationRule *pRule = m_Dominators[nIndex];
	m_Dominators.Remove( nIndex );
	DestroyElement( pRule );
}

void CDmeCombinationOperator::RemoveDominationRule( CDmeCombinationDominationRule *pRule )
{
	int nCount = m_Dominators.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		if ( m_Dominators[i] == pRule )
		{
			RemoveDominationRule( i );
			break;
		}
	}
}

void CDmeCombinationOperator::RemoveAllDominationRules()
{
	int nCount = m_Dominators.Count();
	for ( int i = nCount; --i >= 0; )
	{
		RemoveDominationRule( i );
	}
}


//-----------------------------------------------------------------------------
// Iteration
//-----------------------------------------------------------------------------
int CDmeCombinationOperator::DominationRuleCount() const
{
	return m_Dominators.Count();
}

CDmeCombinationDominationRule *CDmeCombinationOperator::GetDominationRule( int i )
{
	return m_Dominators[i];
}


//-----------------------------------------------------------------------------
// Finds a domination rule
//-----------------------------------------------------------------------------
int CDmeCombinationOperator::FindDominationRule( CDmeCombinationDominationRule *pRule )
{
	int nCount = m_Dominators.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		if ( m_Dominators[i] == pRule )
			return i;
	}
	return -1;
}


//-----------------------------------------------------------------------------
// Rule reordering
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::MoveDominationRuleUp( CDmeCombinationDominationRule* pRule )
{
	int nIndex = FindDominationRule( pRule );
	if ( nIndex > 0 )
	{
		m_Dominators.Swap( nIndex, nIndex - 1 );
		return;
	}
}

void CDmeCombinationOperator::MoveDominationRuleDown( CDmeCombinationDominationRule* pRule )
{
	int nIndex = FindDominationRule( pRule );
	if ( nIndex >= 0 && nIndex < m_Dominators.Count() - 1 )
	{
		m_Dominators.Swap( nIndex, nIndex + 1 );
		return;
	}
}


//-----------------------------------------------------------------------------
// Attaches a channel to an input
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::AttachChannelToControlValue( ControlIndex_t nControlIndex, CombinationControlType_t type, CDmeChannel *pChannel )
{
	pChannel->SetOutput( m_ControlValues[type].GetAttribute(), nControlIndex );
}


//-----------------------------------------------------------------------------
// Determines the weighting of input controls based on the deltaState name
//-----------------------------------------------------------------------------
int CDmeCombinationOperator::FindDeltaStateIndex( CDmAttribute *pDeltaArray, const char *pDeltaStateName )
{
	const CDmrElementArray<> deltas( pDeltaArray );
	int nDeltaArrayCount = deltas.Count();
	for ( int i = 0; i < nDeltaArrayCount; ++i )
	{
		CDmElement *pDeltaElement = deltas[i];
		if ( pDeltaElement && !Q_stricmp( pDeltaElement->GetName(), pDeltaStateName ) )
			return i;
	}

	return -1;
}


//-----------------------------------------------------------------------------
// Determines which combination to use based on the deltaState name
//-----------------------------------------------------------------------------
int CDmeCombinationOperator::ParseDeltaName(const char *pDeltaStateName, int *pControlIndices )
{
	char pBuf[512];
	Q_strncpy( pBuf, pDeltaStateName, sizeof(pBuf) );

	int nComboCount = 0;
	char *pEnd;
	for ( char *pName = pBuf; *pName; pName = pEnd )
	{
		pEnd = strchr( pName, '_' );
		if ( !pEnd )
		{
			pEnd = pName + Q_strlen( pName );
		}
		else
		{
			// Null-terminate
			*pEnd = 0;
			++pEnd;
		}

		int nControlIndex = FindRawControlIndex( pName );
		if ( nControlIndex < 0 )
			return 0;

		pControlIndices[ nComboCount++ ] = nControlIndex;
	}

	return nComboCount;
}


//-----------------------------------------------------------------------------
// Finds dominators
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::FindDominators( CombinationOperation_t& op )
{
	// Dominators are sets of inputs, which, when set to 1, will 
	// supress another set of inputs. Only combinations which contain *all*
	// dominators will suppress any combinatation that contains *all* suppressors
	int nDominatorCount = m_DominatorInfo.Count();
	for ( int i = 0; i < nDominatorCount; ++i )
	{
		DominatorInfo_t &info = m_DominatorInfo[i];

		// Look for suppressor indices in the control indices list
		int nCount = info.m_SuppressedIndices.Count();
		int j;
		for ( j = 0; j < nCount; ++j )
		{
			if ( op.m_ControlIndices.Find( info.m_SuppressedIndices[j] ) < 0 )
				break;
		}
		if ( j != nCount )
			continue;

		op.m_DominatorIndices.AddToTail( i );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::ComputeCombinationInfo( int nIndex )
{
	CleanUpCombinationInfo( nIndex );

	int nCurrentCount = m_CombinationInfo.Count();
	while ( nIndex >= nCurrentCount )
	{
		int j = m_CombinationInfo.AddToTail();
		CombinationInfo_t &info = m_CombinationInfo[j];
		for ( int k = 0; k < COMBO_CONTROL_TYPE_COUNT; ++k )
		{
			info.m_hDestAttribute[k] = DMATTRIBUTE_HANDLE_INVALID;
		}
		++nCurrentCount;
	}

	CombinationInfo_t &info = m_CombinationInfo[nIndex];

	CDmElement *pSource = m_Targets[ nIndex ];
	if ( !pSource )
		return;

	CDmrElementArray<> deltas( pSource, "deltaStates" );
	if ( !deltas.IsValid() )
		return;

	CDmrArray<Vector2D> weights( pSource, "deltaStateWeights" );
	if ( !weights.IsValid() )
		return;

	CDmrArray<Vector2D> weightsLagged( pSource, "deltaStateWeightsLagged" );

	// This is an error state
	if ( deltas.Count() > weights.Count() )
		return;

	// This is an error state
	if ( weightsLagged.IsValid() && deltas.Count() > weightsLagged.Count() )
		return;

	info.m_hDestAttribute[COMBO_CONTROL_NORMAL] = weights.GetAttribute()->GetHandle();
	info.m_hDestAttribute[COMBO_CONTROL_LAGGED] = weightsLagged.IsValid() ? weightsLagged.GetAttribute()->GetHandle() : DMATTRIBUTE_HANDLE_INVALID;

	int *pTemp = (int*)_alloca( m_RawControlInfo.Count() * sizeof(int) );
	int nDeltaCount = deltas.Count();
	for ( int i = 0; i < nDeltaCount; ++i )
	{
		CDmElement *pDeltaElement = deltas[i];
		if ( !pDeltaElement )
			continue;

		int nControlCount = ParseDeltaName( pDeltaElement->GetName(), pTemp );
		if ( nControlCount == 0 )
			continue;

		int j = info.m_Outputs.AddToTail();
		CombinationOperation_t &op = info.m_Outputs[j];
		op.m_nDeltaStateIndex = i;
		op.m_ControlIndices.AddMultipleToTail( nControlCount, pTemp );

		// Find dominators
		FindDominators( op );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::ComputeCombinationInfo()
{
	int nTargetCount = m_Targets.Count();
	for ( int i = 0; i < nTargetCount; ++i )
	{
		ComputeCombinationInfo( i );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::CleanUpCombinationInfo( int nIndex )
{
	if ( nIndex >= m_CombinationInfo.Count() )
		return;

	CombinationInfo_t &info = m_CombinationInfo[ nIndex ];
	for ( int i = 0; i < COMBO_CONTROL_TYPE_COUNT; ++i )
	{
		info.m_hDestAttribute[i] = DMATTRIBUTE_HANDLE_INVALID;
	}
	info.m_Outputs.RemoveAll();
}


void CDmeCombinationOperator::CleanUpCombinationInfo( )
{
	int nCount = m_CombinationInfo.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		CleanUpCombinationInfo( i );
	}
	m_CombinationInfo.RemoveAll();
}


//-----------------------------------------------------------------------------
// helpers for finding corrector names
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::Resolve()
{
	BaseClass::Resolve();

	if ( m_InputControls.IsDirty() || m_Dominators.IsDirty() )
	{
		RebuildRawControlList();
		ComputeCombinationInfo();
	}
}


//-----------------------------------------------------------------------------
// Adds a target for the combination operator
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::AddTarget( CDmElement *pElement )
{
	if ( !pElement )
		return;

	int i = m_Targets.AddToTail( pElement );
	ComputeCombinationInfo( i );
}


//-----------------------------------------------------------------------------
// Sets targets
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::AddTarget( CDmeDag *pDag )
{
	if ( !pDag )
		return;

	CDmeShape *pShape = pDag->GetShape();
	AddTarget( pShape );
	
	int nChildCount = pDag->GetChildCount();
	for ( int i = 0; i < nChildCount; ++i )
	{
		CDmeDag *pChild = pDag->GetChild(i);

		// Do not traverse into models
		if ( CastElement< CDmeModel >( pChild ) )
			continue;

		AddTarget( pChild );
	}
}

float RemapValue( float flValue, const Vector4D &filterRamp )
{
	if ( flValue <= filterRamp.x || flValue >= filterRamp.w )
		return 0.0f;

	if ( flValue < filterRamp.y )
		return RemapVal( flValue, filterRamp.x, filterRamp.y, 0.0f, 1.0f );

	if ( flValue > filterRamp.z )
		return RemapVal( flValue, filterRamp.z, filterRamp.w, 1.0f, 0.0f );

	return 1.0f;
}

//-----------------------------------------------------------------------------
// Remaps non-stereo -> stereo, stereo ->left/right, also adds multilevel + filter
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::ComputeInternalControlValue( RawControlIndex_t nRawControlIndex, CombinationControlType_t type, Vector2D &value )
{
	const RawControlInfo_t &info = m_RawControlInfo[nRawControlIndex];
	const Vector &vecControlValue = m_ControlValues[ type ][ info.m_InputControl ];

	const bool bMultiControl = IsMultiControl( info.m_InputControl );

	if ( IsEyelidControl( info.m_InputControl ) )
	{
		float flMultiValue = RemapValue( vecControlValue.z, info.m_FilterRamp );
		if ( info.m_bLowerEyelid )
		{
			value.x = ( 1.0f - flMultiValue ) * vecControlValue.x;
			value.y = ( 1.0f - flMultiValue ) * vecControlValue.y;
		}
		else
		{
			value.x = flMultiValue * vecControlValue.x;
			value.y = flMultiValue * vecControlValue.y;
		}
	}
	else if ( bMultiControl )
	{
		float flMultiValue = RemapValue( vecControlValue.z, info.m_FilterRamp );
		value.x = flMultiValue * vecControlValue.x;
		value.y = flMultiValue * vecControlValue.y;
	}
	else
	{
		value.x = RemapValue( vecControlValue.x, info.m_FilterRamp );
		value.y = RemapValue( vecControlValue.y, info.m_FilterRamp );
	}
}


//-----------------------------------------------------------------------------
// Computes lagged input values from non-lagged input
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::ComputeLaggedInputValues()
{
	if ( !m_bSpecifyingLaggedData )
		return;

	float t = Plat_FloatTime();
	if ( m_flLastLaggedComputationTime == FLT_MIN )
	{
		m_flLastLaggedComputationTime = t;
	}

	float dt = t - m_flLastLaggedComputationTime;
	m_flLastLaggedComputationTime = t;
	float flFactor = ExponentialDecay( 0.8, 0.033, dt );

	int nCount = m_ControlValues[COMBO_CONTROL_NORMAL].Count();
	for ( int i = 0; i < nCount; ++i )
	{
		Vector vecLerp;
		VectorLerp( m_ControlValues[COMBO_CONTROL_NORMAL][i], m_ControlValues[COMBO_CONTROL_LAGGED][i], flFactor, vecLerp );
		m_ControlValues[COMBO_CONTROL_LAGGED].Set( i, vecLerp );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::Operate()
{
	ComputeLaggedInputValues();

	int nCount = m_CombinationInfo.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		CombinationInfo_t &info = m_CombinationInfo[i];

		for ( CombinationControlType_t type = COMBO_CONTROL_FIRST; type < COMBO_CONTROL_TYPE_COUNT; type = (CombinationControlType_t)(type+1) )
		{
			if ( ( info.m_hDestAttribute[type] == DMATTRIBUTE_HANDLE_INVALID ) || !g_pDataModel->IsAttributeHandleValid( info.m_hDestAttribute[type] ) )
				continue;

			CDmAttribute* pAttribute = g_pDataModel->GetAttribute( info.m_hDestAttribute[type] );
			if ( !pAttribute || pAttribute->GetType() != AT_VECTOR2_ARRAY )
				continue;

			CDmrArray< Vector2D > vec2D( pAttribute );

			CombinationControlType_t useType = m_bSpecifyingLaggedData ? type : COMBO_CONTROL_NORMAL;
			int nOutputCount = info.m_Outputs.Count();
			for ( int j = 0; j < nOutputCount; ++j )
			{
				CombinationOperation_t &op = info.m_Outputs[j];

				// Compute the core combination
				Vector2D vecValue( 1.0f, 1.0f );
				int nCombinationCount = op.m_ControlIndices.Count();
				for ( int k = 0; k < nCombinationCount; ++k )
				{
					Vector2D v;
					ComputeInternalControlValue( op.m_ControlIndices[k], useType, v );
					vecValue *= v;
				}


				// Compute the dominators
				int nDominatorCount = op.m_DominatorIndices.Count();
				for ( int k = 0; k < nDominatorCount; ++k )
				{
					const CUtlVector< int > &dominantIndices = m_DominatorInfo[ op.m_DominatorIndices[k] ].m_DominantIndices;
					int nDominantCount = dominantIndices.Count();

					Vector2D suppressor( -1.0f, -1.0f );
					for ( int l = 0; l < nDominantCount; ++l )
					{
						Vector2D v;
						ComputeInternalControlValue( dominantIndices[l], useType, v );
						suppressor *= v;
					}
					suppressor.x += 1.0f; suppressor.y += 1.0f;

					vecValue *= suppressor;
				}

				vec2D.Set( op.m_nDeltaStateIndex, vecValue );
			}
		}
	}
}

void CDmeCombinationOperator::GetInputAttributes( CUtlVector< CDmAttribute * > &attrs )
{
	for ( int i = 0; i < COMBO_CONTROL_TYPE_COUNT; ++i )
	{
		attrs.AddToTail( m_ControlValues[i].GetAttribute() );
	}
}

void CDmeCombinationOperator::GetOutputAttributes( CUtlVector< CDmAttribute * > &attrs )
{
	int nCount = m_CombinationInfo.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		CombinationInfo_t &info = m_CombinationInfo[i];
		for ( int j = 0; j < COMBO_CONTROL_TYPE_COUNT; ++j )
		{
			if ( ( info.m_hDestAttribute[j] == DMATTRIBUTE_HANDLE_INVALID ) || !g_pDataModel->IsAttributeHandleValid( info.m_hDestAttribute[j] ) )
				continue;

			CDmAttribute* pAttribute = g_pDataModel->GetAttribute( info.m_hDestAttribute[j] );
			if ( !pAttribute || pAttribute->GetType() != AT_VECTOR2_ARRAY )
				continue;

			attrs.AddToTail( pAttribute );
		}
	}
}


//-----------------------------------------------------------------------------
// Used by studiomdl to discover the various combination rules
//-----------------------------------------------------------------------------
int CDmeCombinationOperator::GetOperationTargetCount() const
{
	return m_Targets.Count();
}

CDmElement *CDmeCombinationOperator::GetOperationTarget( int nTargetIndex )
{
	return m_Targets[ nTargetIndex ];
}

int CDmeCombinationOperator::GetOperationCount( int nTargetIndex ) const
{
	return m_CombinationInfo[ nTargetIndex ].m_Outputs.Count();
}

CDmElement *CDmeCombinationOperator::GetOperationDeltaState( int nTargetIndex, int nOpIndex )
{
	CDmElement *pElement = GetOperationTarget( nTargetIndex );
	const CDmrElementArray<> deltaArray( pElement, "deltaStates" );
	if ( !deltaArray.IsValid() )
		return NULL;

	int nDeltaStateIndex = m_CombinationInfo[ nTargetIndex ].m_Outputs[ nOpIndex ].m_nDeltaStateIndex;
	return deltaArray[ nDeltaStateIndex ];
}

const CUtlVector< int > &CDmeCombinationOperator::GetOperationControls( int nTargetIndex, int nOpIndex ) const
{
	return m_CombinationInfo[ nTargetIndex ].m_Outputs[ nOpIndex ].m_ControlIndices;
}

int CDmeCombinationOperator::GetOperationDominatorCount( int nTargetIndex, int nOpIndex ) const
{
	return m_CombinationInfo[ nTargetIndex ].m_Outputs[ nOpIndex ].m_DominatorIndices.Count();
}

const CUtlVector< int > &CDmeCombinationOperator::GetOperationDominator( int nTargetIndex, int nOpIndex, int nDominatorIndex ) const
{
	int nIndex = m_CombinationInfo[ nTargetIndex ].m_Outputs[ nOpIndex ].m_DominatorIndices[ nDominatorIndex ];
	return m_DominatorInfo[ nIndex ].m_DominantIndices;
}

void CDmeCombinationOperator::CopyControls( CDmeCombinationOperator *pSrc )
{
	// Clean Me Out!
	RemoveAllControls();

	// Copy The Source Controls
	for ( int i = 0; i < pSrc->m_InputControls.Count(); ++i )
	{
		CDmeCombinationInputControl *pSrcInput = pSrc->m_InputControls[ i ];
		if ( pSrcInput )
		{
			CDmeCombinationInputControl *pDstInput = pSrcInput->Copy( );
			pDstInput->SetFileId( GetFileId(), TD_DEEP );
			m_InputControls.AddToTail( pDstInput );
		}
	}

	// Copy The Control Values
	m_ControlValues[ COMBO_CONTROL_NORMAL ].CopyArray(
		pSrc->m_ControlValues[ COMBO_CONTROL_NORMAL ].Base(),
		pSrc->m_ControlValues[ COMBO_CONTROL_NORMAL ].Count() );

	m_ControlValues[ COMBO_CONTROL_LAGGED ].CopyArray(
		pSrc->m_ControlValues[ COMBO_CONTROL_LAGGED ].Base(),
		pSrc->m_ControlValues[ COMBO_CONTROL_LAGGED ].Count() );

	RebuildRawControlList();

	m_Dominators.Purge();

	// Copy The Source Controls
	for ( int i = 0; i < pSrc->m_Dominators.Count(); ++i )
	{
		CDmeCombinationDominationRule *pSrcDom = pSrc->m_Dominators[ i ];
		if ( pSrcDom )
		{
			CDmeCombinationDominationRule *pDstDom = pSrcDom->Copy( );
			pDstDom->SetFileId( GetFileId(), TD_DEEP );
			m_Dominators.AddToTail( pDstDom );
		}
	}

	RebuildRawControlList();
}


//-----------------------------------------------------------------------------
// Generates wrinkle deltas for the uncorrected controls
// NOTE: This is only being used because we have no authoring path for wrinkle data yet
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::GenerateWrinkleDeltas(
	CDmeShape *pShape,
	bool bOverwrite,
	bool bUseNormalForSign /* = false */,
	float flScale /* = 1.0f */ )
{
	CDmeMesh* pMesh = CastElement< CDmeMesh >( pShape );
	CDmeVertexData *pBindState = pMesh ? pMesh->FindBaseState( "bind" ) : NULL;
	if ( pBindState )
	{
		int nRawControlCount = m_RawControlInfo.Count();
		for ( int i = 0; i < nRawControlCount; ++i )
		{
			CDmeVertexDeltaData* pDelta = pMesh->FindDeltaState( m_RawControlInfo[i].m_Name );
			if ( pDelta )
			{
				if ( bUseNormalForSign )
				{
					pDelta->GenerateWrinkleDelta( pBindState, flScale, bOverwrite, bUseNormalForSign );
				}
				else
				{
					pDelta->GenerateWrinkleDelta( pBindState, m_RawControlInfo[i].m_flWrinkleScale, bOverwrite, bUseNormalForSign );
				}
			}
		}
	}
}


void CDmeCombinationOperator::GenerateWrinkleDeltas( bool bOverwrite /* = true */, bool bUseNormalForSign /* = false */, float flScale /* = 1.0f */ )
{
	int nTargetCount = m_Targets.Count();
	for ( int i = 0; i < nTargetCount; ++i )
	{
		GenerateWrinkleDeltas( CastElement< CDmeShape >( m_Targets[i] ), bOverwrite, bUseNormalForSign, flScale );
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::RemoveAllTargets()
{
	m_Targets.RemoveAll();

	CleanUpCombinationInfo();
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::SetToDefault()
{
	const int nControlsCount = m_InputControls.Count();
	m_IsDefaultValue.SetCount( nControlsCount );
	for ( int i = 0; i < nControlsCount; ++i )
	{
		m_IsDefaultValue[ i ] = true;
		UpdateDefaultValue( i );
	}
}


//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::SetToBase()
{
	const int nControlsCount = m_InputControls.Count();
	for ( int i = 0; i < nControlsCount; ++i )
	{
		const float flBaseValue = GetControlBaseValue( i );
		for ( int j = 0; j < COMBO_CONTROL_TYPE_COUNT; ++j )
		{
			const Vector &v = m_ControlValues[ j ][ i ];
			m_ControlValues[ j ].Set( i, Vector( flBaseValue, flBaseValue, v.z ) );
		}
	}
}


//-----------------------------------------------------------------------------
// * Remove all controls which refer to raw controls which refer to delta
//   states which do not exist in any target
// * Remove all dominators which refer to states which no longer exist
//-----------------------------------------------------------------------------
void CDmeCombinationOperator::Purge()
{
	bool bDelete = true;

	const int nTargetCount = m_Targets.Count();
	for ( int i = 0; i < nTargetCount; ++i )
	{
		CDmElement *pSource = m_Targets[ i ];
		if ( !pSource )
			continue;

		CDmrElementArray<> deltas( pSource, "deltaStates" );
		if ( !deltas.IsValid() )
			continue;

		const int nDeltaCount = deltas.Count();

		do
		{
			bDelete = false;

			const int nControlCount = GetControlCount();
			for ( int j = 0; j < nControlCount; ++j )
			{
				bDelete = true;
				const int nRawControlCount = GetRawControlCount( j );
				for ( int k = 0; bDelete && k < nRawControlCount; ++k )
				{
					for ( int l = 0; l < nDeltaCount; ++l )
					{
						if ( !Q_strcmp( GetRawControlName( j, k ), deltas[ l ]->GetName() ) )
						{
							bDelete = false;
							break;
						}
					}
				}

				if ( bDelete )
				{
					RemoveControl( GetControlName( j ) );
					break;
				}
			}
		} while ( bDelete );
	}

	do 
	{
		bDelete = false;

		const int nDomCount = DominationRuleCount();
		for ( int i = 0; i < nDomCount; ++i )
		{
			bDelete = true;
			CDmeCombinationDominationRule *pDom = GetDominationRule( i );

			const int nDCount = pDom->DominatorCount();
			for ( int j = 0; j < nDCount; ++j )
			{
				if ( HasRawControl( pDom->GetDominator( j ) ) )
				{
					bDelete = false;
					break;
				}
			}

			if ( !bDelete )
			{
				const int nSCount = pDom->SuppressedCount();
				for ( int j = 0; j < nSCount; ++j )
				{
					if ( HasRawControl( pDom->GetSuppressed( j ) ) )
					{
						bDelete = false;
						break;
					}
				}
			}

			if ( bDelete )
			{
				RemoveDominationRule( i );
				break;
			}
		}
	} while ( bDelete );
}


//-----------------------------------------------------------------------------
// Creates lagged log data from an input log
//-----------------------------------------------------------------------------
static void CreateLaggedLog( CDmeVector2Log *pLog, CDmeVector2Log *pLaggedLog, int nSamplesPerSec )
{
}


//-----------------------------------------------------------------------------
// Helper method to create a lagged version of channel data from source data
//-----------------------------------------------------------------------------
void CreateLaggedVertexAnimation( CDmeChannelsClip *pClip, int nSamplesPerSec )
{
	if ( !pClip )
		return;

	CUtlVectorFixedGrowable< char, 256 > newChannelName;

	int nChannelCount = pClip->m_Channels.Count();
	for ( int i = 0; i < nChannelCount; ++i )
	{
		CDmeChannel *pChannel = pClip->m_Channels[i];
		CDmElement *pDest = pChannel->GetToElement();
		CDmAttribute *pDestAttr = pChannel->GetToAttribute();
		int nArrayIndex = pChannel->GetToArrayIndex();

		if ( pChannel->GetLog()->GetDataType() != AT_VECTOR2 )
			continue;

		if ( Q_stricmp( pDestAttr->GetName(), "controlValues" ) )
			continue;

		if ( !pDest->GetValue<bool>( "usesLaggedValues" ) )
			continue;

		CDmAttribute *pLaggedAttr = pDest->GetAttribute( "controlValuesLagged" );
		if ( !pLaggedAttr || pLaggedAttr->GetType() != AT_VECTOR2_ARRAY )
			continue;

		int nLen = Q_strlen( pChannel->GetName() );
		newChannelName.EnsureCount( nLen + 10 );
		memcpy( newChannelName.Base(), pChannel->GetName(), nLen+1 );
		Q_strncpy( &newChannelName[nLen], "_lagged", 10 );
		CDmeChannel *pNewChannel = CreateElement< CDmeChannel >( newChannelName.Base(), pClip->GetFileId() );
		pNewChannel->SetOutput( pLaggedAttr, nArrayIndex );
		CDmeVector2Log *pNewLog = pNewChannel->CreateLog< Vector2D >( );
		pClip->m_Channels.AddToTail( pNewChannel );

		CreateLaggedLog( static_cast<CDmeVector2Log*>( pChannel->GetLog() ), pNewLog, nSamplesPerSec );
	}
}


//-----------------------------------------------------------------------------
//
// A class used to edit combination operators in Maya.. doesn't connect to targets
//
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeMayaCombinationOperator, CDmeMayaCombinationOperator );


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CDmeMayaCombinationOperator::OnConstruction()
{
	m_DeltaStates.Init( this, "deltaStates" );
	m_DeltaStateWeights[COMBO_CONTROL_NORMAL].Init( this, "deltaStateWeights" );
	m_DeltaStateWeights[COMBO_CONTROL_LAGGED].Init( this, "deltaStateWeightsLagged" );
	AddTarget( this );
}

void CDmeMayaCombinationOperator::OnDestruction()
{
}


//-----------------------------------------------------------------------------
// Add, remove delta states
//-----------------------------------------------------------------------------
void CDmeMayaCombinationOperator::AddDeltaState( const char *pDeltaStateName )
{
	m_DeltaStates.AddToTail( CreateElement<CDmElement>( pDeltaStateName, DMFILEID_INVALID ) );
	for ( int i = 0; i < COMBO_CONTROL_TYPE_COUNT; ++i )
	{
		m_DeltaStateWeights[i].AddToTail( Vector2D( 1.0f, 1.0f ) );
	}
	ComputeCombinationInfo( 0 );
}

void CDmeMayaCombinationOperator::RemoveDeltaState( const char *pDeltaStateName )
{
	int nIndex = FindDeltaState( pDeltaStateName );
	if ( nIndex >= 0 )
	{
		m_DeltaStates.Remove( nIndex );
		for ( int i = 0; i < COMBO_CONTROL_TYPE_COUNT; ++i )
		{
			m_DeltaStateWeights[i].Remove( nIndex );
		}
	}
	ComputeCombinationInfo( 0 );
}

void CDmeMayaCombinationOperator::RemoveAllDeltaStates()
{
	m_DeltaStates.RemoveAll( );
	for ( int i = 0; i < COMBO_CONTROL_TYPE_COUNT; ++i )
	{
		m_DeltaStateWeights[i].RemoveAll();
	}
	ComputeCombinationInfo( 0 );
}

int CDmeMayaCombinationOperator::FindDeltaState( const char *pDeltaStateName )
{
	int nCount = m_DeltaStates.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		if ( !Q_stricmp( pDeltaStateName, m_DeltaStates[i]->GetName() ) )
			return i;
	}
	return -1;
}

int CDmeMayaCombinationOperator::DeltaStateCount() const
{
	return m_DeltaStates.Count();
}

const char *CDmeMayaCombinationOperator::GetDeltaState( int nIndex ) const
{
	return m_DeltaStates[nIndex]->GetName();
}

const Vector2D& CDmeMayaCombinationOperator::GetDeltaStateWeight( int nIndex, CombinationControlType_t type ) const
{
	return m_DeltaStateWeights[type][nIndex];
}