source-engine/sfmobjects/flexcontrolbuilder.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// A class used to build flex animation controls for an animation set
//
//=============================================================================

#include "sfmobjects/flexcontrolbuilder.h"
#include "studio.h"
#include "movieobjects/dmeanimationset.h"
#include "movieobjects/dmeclip.h"
#include "movieobjects/dmetrackgroup.h"
#include "movieobjects/dmetrack.h"
#include "movieobjects/dmegamemodel.h"
#include "movieobjects/dmechannel.h"
#include "movieobjects/dmebalancetostereocalculatoroperator.h"
#include "tier1/utlsymbol.h"


// Names of attributes in controls we attach channels to
#define CONTROL_CHANNEL_ATTRIBUTE_COUNT 4
static const char *s_pChannelControls[CONTROL_CHANNEL_ATTRIBUTE_COUNT] =
{
	"channel", "valuechannel", "balancechannel", "multilevelchannel"
};


//-----------------------------------------------------------------------------
// Flex controller
//-----------------------------------------------------------------------------
class CDefaultGlobalFlexController : public IGlobalFlexController
{
public:
	CDefaultGlobalFlexController() : m_SymbolTable( 0, 32, true ) {}

	virtual int	FindGlobalFlexController( const char *name )
	{
		return m_SymbolTable.AddString( name );
	}

	virtual const char *GetGlobalFlexControllerName( int idx )
	{
		return m_SymbolTable.String( (CUtlSymbol)idx );
	}

private:
	CUtlSymbolTable m_SymbolTable;
};

static CDefaultGlobalFlexController s_GlobalFlexController;
extern IGlobalFlexController *g_pGlobalFlexController;


//-----------------------------------------------------------------------------
// This builds a list of the desired flex controllers we need to have controls for
// by the time we're all done with this enormous process.
//-----------------------------------------------------------------------------
void CFlexControlBuilder::BuildDesiredFlexControlList( CDmeGameModel *pGameModel )
{
	CStudioHdr cHdr( pGameModel->GetStudioHdr() );
	LocalFlexController_t nCount = cHdr.numflexcontrollers();

	m_FlexControllerInfo.EnsureCapacity( nCount );
	for ( LocalFlexController_t i = LocalFlexController_t(0); i < nCount; ++i )
	{
		int j = m_FlexControllerInfo.AddToTail();

		FlexControllerInfo_t& info = m_FlexControllerInfo[j];
		mstudioflexcontroller_t *pFlex = cHdr.pFlexcontroller( i );
		Q_strncpy( info.m_pFlexControlName, pFlex->pszName(), sizeof( info.m_pFlexControlName ) );
		info.m_nGlobalIndex = g_pGlobalFlexController->FindGlobalFlexController( pFlex->pszName() );
		info.m_flDefaultValue = 0.0f;
		if ( pFlex->max != pFlex->min )
		{
			// FIXME: Is this the correct default value?
			info.m_flDefaultValue = ( 0.0f - pFlex->min ) / ( pFlex->max - pFlex->min );
		}
	}
}


//-----------------------------------------------------------------------------
// This builds a list of the desired input controls we need to have controls for
// by the time we're all done with this enormous process.
//-----------------------------------------------------------------------------
void CFlexControlBuilder::BuildDesiredControlList( CDmeGameModel *pGameModel )
{
	int nCount = m_FlexControllerInfo.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		int j = m_ControlInfo.AddToTail();
		ControlInfo_t &controlInfo = m_ControlInfo[j];
		memset( &controlInfo, 0, sizeof(ControlInfo_t) );

		FlexControllerInfo_t& info = m_FlexControllerInfo[i];
		const char *pFlexName = info.m_pFlexControlName;

		// Deal with stereo/mono controls
		if ( !Q_strnicmp( "right_", pFlexName, 6 ) && ( i < nCount - 1 ) )
		{
			FlexControllerInfo_t& leftInfo = m_FlexControllerInfo[i+1];
			Assert( !Q_strnicmp( "left_", leftInfo.m_pFlexControlName, 5 ) );

			controlInfo.m_bIsStereo = true;
			controlInfo.m_pControllerIndex[ OUTPUT_RIGHT ] = i;
			controlInfo.m_pControllerIndex[ OUTPUT_LEFT ] = i+1;
			Q_strncpy( controlInfo.m_pControlName, pFlexName + 6, sizeof(controlInfo.m_pControlName) );

			// Convert default values into value/balance
			LeftRightToValueBalance( &controlInfo.m_pDefaultValue[ CONTROL_VALUE ], 
				&controlInfo.m_pDefaultValue[ CONTROL_BALANCE ],
				leftInfo.m_flDefaultValue, info.m_flDefaultValue );

			// Skip the 'left_' flex control
			++i;
		}
		else
		{
			controlInfo.m_bIsStereo = false;
			controlInfo.m_pControllerIndex[ OUTPUT_MONO ] = i;
			controlInfo.m_pControllerIndex[ OUTPUT_LEFT ] = -1;
			Q_strncpy( controlInfo.m_pControlName, pFlexName, sizeof(controlInfo.m_pControlName) );
			controlInfo.m_pDefaultValue[ CONTROL_VALUE ] = info.m_flDefaultValue;
			controlInfo.m_pDefaultValue[ CONTROL_BALANCE ] = 0.5f;
		}

		// Deal with multi controls
		controlInfo.m_bIsMulti = ( i+1 < nCount ) && !Q_strnicmp( "multi_", m_FlexControllerInfo[ i+1 ].m_pFlexControlName, 6 );
		if ( controlInfo.m_bIsMulti )
		{
			FlexControllerInfo_t& multiInfo = m_FlexControllerInfo[i+1];

			controlInfo.m_pControllerIndex[ OUTPUT_MULTILEVEL ] = i+1;
			controlInfo.m_pDefaultValue[ CONTROL_MULTILEVEL ] = multiInfo.m_flDefaultValue;

			// Skip the 'multi_' flex control
			++i;
		}
		else
		{
			controlInfo.m_pControllerIndex[ OUTPUT_MULTILEVEL ] = -1;
			controlInfo.m_pDefaultValue[ CONTROL_MULTILEVEL ] = 0.5f;
		}
	}
}


//-----------------------------------------------------------------------------
// Finds a desired flex controller index in the m_FlexControllerInfo array
//-----------------------------------------------------------------------------
int CFlexControlBuilder::FindDesiredFlexController( const char *pFlexControllerName ) const
{
	int nCount = m_FlexControllerInfo.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		if ( !Q_stricmp( pFlexControllerName, m_FlexControllerInfo[i].m_pFlexControlName ) )
			return i;
	}
	return -1;
}


//-----------------------------------------------------------------------------
// Removes a channel from the channels clip referring to it.
//-----------------------------------------------------------------------------
void CFlexControlBuilder::RemoveChannelFromClips( CDmeChannel *pChannel )
{
	// First, try to grab the channels referring to this op
	CUtlVector< CDmeChannelsClip* > channelsClips;
	FindAncestorsReferencingElement( pChannel, channelsClips );
	int nChannelsClips = channelsClips.Count();
	for ( int i = 0; i < nChannelsClips; ++i )
	{
		channelsClips[ i ]->RemoveChannel( pChannel );
	}

	// Next, remove the channel from values controls it may be attached to
	for ( int i = 0; i < CONTROL_CHANNEL_ATTRIBUTE_COUNT; ++i ) 
	{
		UtlSymId_t symChannelControl = g_pDataModel->GetSymbol( s_pChannelControls[i] );
		CDmElement *pControl = FindReferringElement< CDmElement >( pChannel, symChannelControl );
		if ( pControl )
		{
			pControl->RemoveAttribute( s_pChannelControls[i] );
		}
	}
}


//-----------------------------------------------------------------------------
// Removes a stereo operator from the animation set referring to it
//-----------------------------------------------------------------------------
void CFlexControlBuilder::RemoveStereoOpFromSet( CDmeBalanceToStereoCalculatorOperator *pSteroOp )
{
	// First, try to grab the channel referring to this op
	const static UtlSymId_t symOperators = g_pDataModel->GetSymbol( "operators" );
	CDmeAnimationSet *pAnimationSet = FindReferringElement< CDmeAnimationSet >( pSteroOp, symOperators );
	if ( pAnimationSet )
	{
		pAnimationSet->RemoveOperator( pSteroOp );
	}
}


//-----------------------------------------------------------------------------
// Blows away the various elements trying to control a flex controller op
//-----------------------------------------------------------------------------
void CFlexControlBuilder::CleanupExistingFlexController( CDmeGameModel *pGameModel, CDmeGlobalFlexControllerOperator *pOp )
{
	CDmeBalanceToStereoCalculatorOperator *pStereoOp;

	// First, try to grab the channel referring to this op
	const static UtlSymId_t symToElement = g_pDataModel->GetSymbol( "toElement" );
	CDmeChannel *pChannel = FindReferringElement< CDmeChannel >( pOp, symToElement );
	if ( !pChannel )
		goto destroyOp;

	// Sometimes a stereo op will be read from by this channel
	pStereoOp = CastElement< CDmeBalanceToStereoCalculatorOperator >( pChannel->GetFromElement() );
	RemoveChannelFromClips( pChannel );
	DestroyElement( pChannel );
	if ( !pStereoOp )
		goto destroyOp;

	RemoveStereoOpFromSet( pStereoOp );

	// If we have a stereo op, then blow away all channels targetting that stereo op
	DmAttributeReferenceIterator_t i = g_pDataModel->FirstAttributeReferencingElement( pStereoOp->GetHandle() );
	DmAttributeReferenceIterator_t next;
	for ( ; i != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID; i = next )
	{
		next = g_pDataModel->NextAttributeReferencingElement( i );

		CDmAttribute *pAttribute = g_pDataModel->GetAttribute( i );
		pChannel = CastElement<CDmeChannel>( pAttribute->GetOwner() );
		if ( pChannel && pAttribute->GetNameSymbol() == symToElement )
		{
			RemoveChannelFromClips( pChannel );
			DestroyElement( pChannel );
		}
	}

	DestroyElement( pStereoOp );

destroyOp:
	pGameModel->RemoveGlobalFlexController( pOp );
	DestroyElement( pOp );
}

bool RemoveChannelIfUnused( CDmeChannel *pChannel, CDmeChannelsClip *pChannelsClip )
{
	if ( !pChannel )
		return false;
	if ( pChannel->GetToElement() != NULL )
		return false;

	pChannelsClip->RemoveChannel( pChannel );
	DestroyElement( pChannel );
	return true;
}

// finds controls whose channels don't point to anything anymore, and deletes both the channels and the control
void CFlexControlBuilder::RemoveUnusedControlsAndChannels( CDmeAnimationSet *pAnimationSet, CDmeChannelsClip *pChannelsClip )
{
	CDmrElementArray<> controls = pAnimationSet->GetControls();
	int nControls = controls.Count();
	for ( int i = nControls - 1; i >= 0 ; --i )
	{
		CDmElement *pControl = controls[ i ];
		if ( pControl )
		{
			bool bRemoved =        RemoveChannelIfUnused( pControl->GetValueElement< CDmeChannel >( "channel" ), pChannelsClip );
			bRemoved = bRemoved || RemoveChannelIfUnused( pControl->GetValueElement< CDmeChannel >( "valuechannel" ), pChannelsClip );
			bRemoved = bRemoved || RemoveChannelIfUnused( pControl->GetValueElement< CDmeChannel >( "balancechannel" ), pChannelsClip );
			bRemoved = bRemoved || RemoveChannelIfUnused( pControl->GetValueElement< CDmeChannel >( "multilevelchannel" ), pChannelsClip );

			if ( !bRemoved )
				continue;

			DestroyElement( pControl );
		}

		controls.Remove( i );
	}
}

//-----------------------------------------------------------------------------
// This removes existing controls on the animationset that aren't in the desired state
//-----------------------------------------------------------------------------
void CFlexControlBuilder::RemoveUnusedExistingFlexControllers( CDmeGameModel *pGameModel )
{
	// These are the current flex controllers
	// NOTE: Name of these controllers should match the names of the flex controllers
	int nCount = pGameModel->NumGlobalFlexControllers();
	for ( int i = nCount; --i >= 0; )
	{
		CDmeGlobalFlexControllerOperator *pOp = pGameModel->GetGlobalFlexController( i );
		Assert( pOp );
		if ( pOp && FindDesiredFlexController( pOp->GetName() ) < 0 )
		{
			Msg( "removing flex controller %s\n", pOp->GetName() );

			CleanupExistingFlexController( pGameModel, pOp );
		}
	}
}


//-----------------------------------------------------------------------------
// Returns an existing mono log
//-----------------------------------------------------------------------------
void CFlexControlBuilder::GetExistingMonoLog( ExistingLogInfo_t *pExistingLog, 
											 CDmeFilmClip *pClip, CDmeGlobalFlexControllerOperator *pMonoOp )
{
	pExistingLog->m_pLog = NULL;

	const static UtlSymId_t symToElement = g_pDataModel->GetSymbol( "toElement" );
	CDmeChannel *pMonoChannel = FindReferringElement< CDmeChannel >( pMonoOp, symToElement );
	if ( !pMonoChannel )
		return;

	// First, try to grab the channel referring to this op
	CDmeFloatLog *pLog = CastElement< CDmeFloatLog >( pMonoChannel->GetLog() );
	if ( !pLog )
		return;

	if ( ComputeChannelTimeTransform( &pExistingLog->m_GlobalOffset, &pExistingLog->m_flGlobalScale, pClip, pMonoChannel ) )
	{
		pExistingLog->m_pLog = pLog;
	}
}


//-----------------------------------------------------------------------------
// Finds a channels clip containing a particular channel
//-----------------------------------------------------------------------------
CDmeChannelsClip* CFlexControlBuilder::FindChannelsClipContainingChannel( CDmeFilmClip *pClip, CDmeChannel *pSearch )
{
	int gc = pClip->GetTrackGroupCount();
	for ( int i = 0; i < gc; ++i )
	{
		CDmeTrackGroup *pTrackGroup = pClip->GetTrackGroup( i );
		DMETRACKGROUP_FOREACH_CLIP_TYPE_START( CDmeChannelsClip, pTrackGroup, pTrack, pChannelsClip )

			int nChannels = pChannelsClip->m_Channels.Count();
		for ( int j = 0; j < nChannels; ++j )
		{
			CDmeChannel *pChannel = pChannelsClip->m_Channels[ j ];
			if ( pChannel == pSearch )
				return pChannelsClip;
		}

		DMETRACKGROUP_FOREACH_CLIP_TYPE_END()
	}
	return NULL;
}


//-----------------------------------------------------------------------------
// Computes a global offset and scale to convert from log time to global time
//-----------------------------------------------------------------------------
void CFlexControlBuilder::ComputeChannelTimeTransform( DmeTime_t *pOffset, double *pScale, CDmeChannelsClip *pChannelsClip )
{
	// Determine the global time of the start + end of the log
	DmeClipStack_t srcStack;
	pChannelsClip->BuildClipStack( &srcStack, m_pMovie, NULL );

	*pOffset = CDmeClip::FromChildMediaTime( srcStack, DMETIME_ZERO, false );
	DmeTime_t duration = CDmeClip::FromChildMediaTime( srcStack, DmeTime_t( 10000 ), false );
	duration -= *pOffset;
	*pScale = duration.GetSeconds();
}

bool CFlexControlBuilder::ComputeChannelTimeTransform( DmeTime_t *pOffset, double *pScale, CDmeFilmClip* pClip, CDmeChannel* pChannel )
{
	CDmeChannelsClip *pChannelsClip = FindChannelsClipContainingChannel( pClip, pChannel );
	if ( !pChannelsClip )
		return false;

	ComputeChannelTimeTransform( pOffset, pScale, pChannelsClip );
	return true;
}


//-----------------------------------------------------------------------------
// Returns an existing value/balance log
//-----------------------------------------------------------------------------
void CFlexControlBuilder::GetExistingVBLog( ExistingLogInfo_t *pLogs, CDmeFilmClip *pClip, CDmeBalanceToStereoCalculatorOperator *pStereoOp )
{
	// Stereo operators always have value/balance logs attached
	DmAttributeReferenceIterator_t i = g_pDataModel->FirstAttributeReferencingElement( pStereoOp->GetHandle() );
	for ( ; i != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID; i = g_pDataModel->NextAttributeReferencingElement( i ) )
	{
		CDmAttribute *pAttribute = g_pDataModel->GetAttribute( i );
		CDmeChannel *pChannel = CastElement< CDmeChannel >( pAttribute->GetOwner() );
		const static UtlSymId_t symToElement = g_pDataModel->GetSymbol( "toElement" );
		if ( !pChannel || pAttribute->GetNameSymbol() != symToElement )
			continue;

		const char *pToAttributeName = pChannel->GetToAttribute()->GetName();
		int nLogIndex = -1;
		if ( !Q_stricmp( pToAttributeName, "value" ) )
		{
			nLogIndex = CONTROL_VALUE;
		}
		else if ( !Q_stricmp( pToAttributeName, "balance" ) )
		{
			nLogIndex = CONTROL_BALANCE;
		}
		else
		{
			continue;
		}

		CDmeFloatLog *pLog = CastElement< CDmeFloatLog >( pChannel->GetLog() );
		if ( !pLog )
			continue;

		// Compute a scale and offset transforming log time into global time
		if ( !ComputeChannelTimeTransform( &pLogs[nLogIndex].m_GlobalOffset, &pLogs[nLogIndex].m_flGlobalScale, pClip, pChannel ) )
			continue;

		// Detach the  
		pLogs[nLogIndex].m_pLog = pLog;
		pChannel->SetLog( NULL );	// Detach
	}
}


static void AddKeyToLogs( CDmeTypedLog< float > *valueLog, CDmeTypedLog< float > *balanceLog, const DmeTime_t& keyTime, float lval, float rval )
{
	// Convert left right into value, balance
	float value, balance;
	LeftRightToValueBalance( &value, &balance, lval, rval );

	//	Msg( "%.5f setting l/r %f %f to value %f balance %f\n",
	//		keyTime.GetSeconds(), lval, rval, value, balance );

	valueLog->SetKey( keyTime, value );
	balanceLog->SetKey( keyTime, balance );
}

static void ConvertLRToVBLog( CDmeFloatLog *pValueLog, CDmeFloatLog *pBalanceLog, CDmeFloatLog *pLeftLog, CDmeFloatLog *pRightLog, DmeTime_t rightOffset, double flRightScale )
{
	int lc = pLeftLog->GetKeyCount();
	int rc = pRightLog->GetKeyCount();

	int nLeft = 0, nRight = 0;
	while ( nLeft < lc || nRight < rc )
	{
		bool bUseLeft = ( nLeft < lc );
		bool bUseRight = ( nRight < rc );

		DmeTime_t leftKeyTime = bUseLeft ? pLeftLog->GetKeyTime( nLeft ) : DMETIME_MAXTIME;
		DmeTime_t rightKeyTime = bUseRight ? pRightLog->GetKeyTime( nRight ) : DMETIME_MAXTIME;

		// Transform rightKeyTime into leftKeyTime space
		if ( bUseRight )
		{
			rightKeyTime.SetSeconds( rightKeyTime.GetSeconds() * flRightScale );
			rightKeyTime += rightOffset;
		}

		if ( leftKeyTime == rightKeyTime )
		{
			float lval = pLeftLog->GetKeyValue( nLeft++ );
			float rval = pRightLog->GetKeyValue( nRight++ );
			AddKeyToLogs( pValueLog, pBalanceLog, leftKeyTime, lval, rval );
			continue;
		}

		if ( leftKeyTime < rightKeyTime )
		{
			// pull a value from the right log at the leftKeyTime 
			// and advance to the next sample on the left side
			float lval = pLeftLog->GetKeyValue( nLeft++ );
			float rval = pRightLog->GetValue( leftKeyTime );
			AddKeyToLogs( pValueLog, pBalanceLog, leftKeyTime, lval, rval );
			continue;
		}

		// Pull a value from the left log at the rightKeyTime 
		// and advance to the next sample on the right side
		float lval = pLeftLog->GetValue( rightKeyTime );
		float rval = pRightLog->GetKeyValue( nRight++ );
		AddKeyToLogs( pValueLog, pBalanceLog, rightKeyTime, lval, rval );
	}
}

//-----------------------------------------------------------------------------
// Converts an existing value/balance log
//-----------------------------------------------------------------------------
void CFlexControlBuilder::ConvertExistingLRLogs( ExistingLogInfo_t *pLogs, 
												CDmeFilmClip *pClip, CDmeChannel *pLeftChannel, CDmeChannel *pRightChannel )
{
	CDmeFloatLog *pRightLog = CastElement< CDmeFloatLog >( pRightChannel->GetLog() );
	CDmeFloatLog *pLeftLog = CastElement< CDmeFloatLog >( pLeftChannel->GetLog() );
	if ( !pRightLog || !pLeftLog )
		return;

	// Compute a scale + offset to transform the right log to get it in the same space as the left log
	DmeTime_t leftOffset, rightOffset;
	double flLeftScale, flRightScale;
	if ( !ComputeChannelTimeTransform( &leftOffset, &flLeftScale, pClip, pLeftChannel ) )
		return;
	if ( !ComputeChannelTimeTransform( &rightOffset, &flRightScale, pClip, pRightChannel ) )
		return;

	flRightScale = ( flRightScale != 0.0f ) ? flLeftScale / flRightScale : 1.0;
	rightOffset = leftOffset - DmeTime_t( rightOffset.GetSeconds() * flRightScale );

	pLogs[CONTROL_VALUE].m_pLog = CreateElement< CDmeFloatLog >( "value" );
	pLogs[CONTROL_VALUE].m_GlobalOffset = leftOffset;
	pLogs[CONTROL_VALUE].m_flGlobalScale = flLeftScale;

	pLogs[CONTROL_BALANCE].m_pLog = CreateElement< CDmeFloatLog >( "balance" );
	pLogs[CONTROL_BALANCE].m_GlobalOffset = leftOffset; // NOTE: This is correct! All logs are transformed into left channel time
	pLogs[CONTROL_BALANCE].m_flGlobalScale = flLeftScale;

	ConvertLRToVBLog( pLogs[CONTROL_VALUE].m_pLog, pLogs[CONTROL_BALANCE].m_pLog,
		pLeftLog, pRightLog, rightOffset, flRightScale );

	//	DestroyElement( pLeftLog );
	//	DestroyElement( pRightLog );
}


//-----------------------------------------------------------------------------
// Returns an existing stereo log, performing conversion if necessary
//-----------------------------------------------------------------------------
void CFlexControlBuilder::GetExistingStereoLog( ExistingLogInfo_t *pLogs, CDmeFilmClip *pClip,
											   CDmeGlobalFlexControllerOperator *pRightOp, CDmeGlobalFlexControllerOperator *pLeftOp )
{
	pLogs[CONTROL_VALUE].m_pLog = NULL;
	pLogs[CONTROL_BALANCE].m_pLog = NULL;

	// First, try to grab the channel referring to this op
	const static UtlSymId_t symToElement = g_pDataModel->GetSymbol( "toElement" );
	CDmeChannel *pChannel = FindReferringElement< CDmeChannel >( pRightOp, symToElement );
	if ( !pChannel )
		return;

	// Sometimes a stereo op will be read from by this channel
	CDmeBalanceToStereoCalculatorOperator *pStereoOp = CastElement< CDmeBalanceToStereoCalculatorOperator >( pChannel->GetFromElement() );
	if ( pStereoOp )
	{
		GetExistingVBLog( pLogs, pClip, pStereoOp );
		return;
	}

	// In this case, we recorded game data and we have left/right logs
	CDmeChannel *pLeftChannel = FindReferringElement< CDmeChannel >( pLeftOp, symToElement );
	if ( !pLeftChannel )
		return;
	ConvertExistingLRLogs( pLogs, pClip, pLeftChannel, pChannel );
}


//-----------------------------------------------------------------------------
// Fixup list of existing flex controller logs
// - reattach flex controls that were removed from the gamemodel's list
//-----------------------------------------------------------------------------
void CFlexControlBuilder::FixupExistingFlexControlLogList( CDmeFilmClip *pCurrentClip, CDmeGameModel *pGameModel )
{
	int nTrackGroups = pCurrentClip->GetTrackGroupCount();
	for ( int gi = 0; gi < nTrackGroups; ++gi )
	{
		CDmeTrackGroup *pTrackGroup = pCurrentClip->GetTrackGroup( gi );
		if ( !pTrackGroup )
			continue;

		DMETRACKGROUP_FOREACH_CLIP_TYPE_START( CDmeChannelsClip, pTrackGroup, pTrack, pChannelsClip )
			int nChannels = pChannelsClip->m_Channels.Count();
			for ( int ci = 0; ci < nChannels; ++ci )
			{
				CDmeChannel *pChannel = pChannelsClip->m_Channels[ ci ];
				if ( !pChannel )
					continue;

				CDmeGlobalFlexControllerOperator *pOp = CastElement< CDmeGlobalFlexControllerOperator >( pChannel->GetToElement() );
				if ( !pOp )
					continue;

				if ( pOp->m_gameModel != pGameModel->GetHandle() )
					continue;

				int nGlobalIndex = pOp->GetGlobalIndex();
				CDmeGlobalFlexControllerOperator *pFoundOp = pGameModel->FindGlobalFlexController( nGlobalIndex );
				if ( pFoundOp == pOp )
					continue;

				if ( !pFoundOp )
				{
					Msg( "adding missing flex controller %d %s\n", nGlobalIndex, pOp->GetName() );
					pFoundOp = pGameModel->AddGlobalFlexController( pOp->GetName(), nGlobalIndex );
				}
				pChannel->SetOutput( pFoundOp, pChannel->GetToAttribute()->GetName() );
				if ( pChannel->GetFromElement() == pOp )
				{
					pChannel->SetInput( pFoundOp, pChannel->GetFromAttribute()->GetName() );
				}
				Msg( "removing duplicate flex controller %d %s\n", nGlobalIndex, pOp->GetName() );
				RemoveElementFromRefereringAttributes( pOp );
				DestroyElement( pOp	);
			}
		DMETRACKGROUP_FOREACH_CLIP_TYPE_END();
	}
}

//-----------------------------------------------------------------------------
// Build list of existing flex controller logs
//-----------------------------------------------------------------------------
void CFlexControlBuilder::BuildExistingFlexControlLogList( CDmeFilmClip *pCurrentClip, CDmeGameModel *pGameModel )
{
	// These are the current flex controllers that also exist in the desired list
	// NOTE: Name of these controllers should match the names of the flex controllers
	int nCount = m_ControlInfo.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		ControlInfo_t &info = m_ControlInfo[i];

		if ( info.m_bIsStereo )
		{
			int nRightFlex = info.m_pControllerIndex[ OUTPUT_RIGHT ];
			int nLeftFlex = info.m_pControllerIndex[ OUTPUT_LEFT ];
			FlexControllerInfo_t *pRightInfo = &m_FlexControllerInfo[nRightFlex];
			FlexControllerInfo_t *pLeftInfo = &m_FlexControllerInfo[nLeftFlex];

			CDmeGlobalFlexControllerOperator *pRightOp = pGameModel->FindGlobalFlexController( pRightInfo->m_nGlobalIndex );
			CDmeGlobalFlexControllerOperator *pLeftOp = pGameModel->FindGlobalFlexController( pLeftInfo->m_nGlobalIndex );
			if ( pRightOp && pLeftOp )
			{
				Msg( "replacing stereo flex controllers %s and %s\n", pRightOp->GetName(), pRightOp->GetName() );

				GetExistingStereoLog( info.m_pExistingLog, pCurrentClip, pRightOp, pLeftOp );
				CleanupExistingFlexController( pGameModel, pRightOp );
				CleanupExistingFlexController( pGameModel, pLeftOp );
			}
		}
		else
		{
			int nFlex = info.m_pControllerIndex[ OUTPUT_MONO ];
			FlexControllerInfo_t *pInfo = &m_FlexControllerInfo[nFlex];

			CDmeGlobalFlexControllerOperator *pMonoOp = pGameModel->FindGlobalFlexController( pInfo->m_nGlobalIndex );
			if ( pMonoOp )
			{
				Msg( "replacing mono flex controller %s\n", pMonoOp->GetName() );

				GetExistingMonoLog( &info.m_pExistingLog[CONTROL_VALUE], pCurrentClip, pMonoOp );
				CleanupExistingFlexController( pGameModel, pMonoOp );
			}
		}

		if ( info.m_bIsMulti )
		{
			int nFlex = info.m_pControllerIndex[ OUTPUT_MULTILEVEL ];
			FlexControllerInfo_t *pMultiInfo = &m_FlexControllerInfo[ nFlex ];
			CDmeGlobalFlexControllerOperator *pMultiOp = pGameModel->FindGlobalFlexController( pMultiInfo->m_nGlobalIndex );
			if ( pMultiOp )
			{
				Msg( "replacing multi flex controller %s\n", pMultiOp->GetName() );

				GetExistingMonoLog( &info.m_pExistingLog[CONTROL_MULTILEVEL], pCurrentClip, pMultiOp );
				CleanupExistingFlexController( pGameModel, pMultiOp );
			}
		}
	}
}


//-----------------------------------------------------------------------------
// Creates a flex controller and a channel connecting it to a control
//-----------------------------------------------------------------------------
struct FlexOpInfo_t
{
	const char *m_pControlAttributeName;
	const char *m_pControlLinkAttributeName;
};

static FlexOpInfo_t s_pFlexOpInfo[2] = 
{
	{ "value",		"" },
	{ "multilevel", "multilevel" },
};

void CFlexControlBuilder::BuildFlexControllerOps( CDmeGameModel *pGameModel, CDmeChannelsClip *pChannelsClip, ControlInfo_t &info, ControlField_t field )
{
	const FlexOpInfo_t& flexInfo = s_pFlexOpInfo[ ( field == CONTROL_VALUE ) ? 0 : 1 ];

	// Get the global flex controller name and index
	const FlexControllerInfo_t& fcInfo = m_FlexControllerInfo[ info.m_pControllerIndex[field] ];

	// Create operator which drives facial flex setting
	CDmeGlobalFlexControllerOperator *pFlexControllerOp = pGameModel->AddGlobalFlexController( 
		fcInfo.m_pFlexControlName, fcInfo.m_nGlobalIndex );

	// Create a channel which passes from the control value to the global flex controller
	char pName[ 256 ];
	Q_snprintf( pName, sizeof( pName ), "%s_flex_channel", fcInfo.m_pFlexControlName );
	info.m_ppControlChannel[field] = pChannelsClip->CreatePassThruConnection( pName, 
		info.m_pControl, flexInfo.m_pControlAttributeName, pFlexControllerOp, "flexWeight" );

	// NOTE: The animation set slider panel looks for these custom attributes
	Q_snprintf( pName, sizeof(pName), "%schannel", flexInfo.m_pControlLinkAttributeName );
	info.m_pControl->SetValue( pName, info.m_ppControlChannel[field] );

	// Switch the channel into play mode by default
	info.m_ppControlChannel[field]->SetMode( CM_PLAY );
}


//-----------------------------------------------------------------------------
// Creates a flex controller and a channel connecting it to stereo controls
//-----------------------------------------------------------------------------
static const char *s_pStereoOutputPrefix[2] = 
{
	"right",
	"left",
};

static const char *s_pStereoInputPrefix[2] = 
{
	"value",
	"balance",
};

void CFlexControlBuilder::BuildStereoFlexControllerOps( CDmeAnimationSet *pAnimationSet, 
													   CDmeGameModel *pGameModel, CDmeChannelsClip *pChannelsClip, ControlInfo_t &info )
{
	// Create an operator which converts value/balance to left/right
	CDmrElementArray< CDmeOperator > operators = pAnimationSet->GetOperators();
	CDmeBalanceToStereoCalculatorOperator *pStereoCalcOp = 
		CreateElement< CDmeBalanceToStereoCalculatorOperator >( info.m_pControlName, pAnimationSet->GetFileId() );
	operators.AddToTail( pStereoCalcOp->GetHandle() );

	pStereoCalcOp->SetValue< float >( "value", info.m_pDefaultValue[CONTROL_VALUE] );
	pStereoCalcOp->SetValue< float >( "balance", info.m_pDefaultValue[CONTROL_BALANCE] );

	// Connect channels from animation set controls to balance operator to flex controller operators
	char pChannelName[ 256 ];
	char pResultName[ 256 ];
	for ( int i = 0; i < 2; ++i )
	{
		// Get the global flex controller name and index
		const FlexControllerInfo_t& fcInfo = m_FlexControllerInfo[ info.m_pControllerIndex[i] ];

		// Create an operator which drives facial flex setting
		CDmeGlobalFlexControllerOperator *pFlexControllerOp = pGameModel->AddGlobalFlexController(
			fcInfo.m_pFlexControlName, fcInfo.m_nGlobalIndex );

		// Now create a channel which connects the output of the stereo op to the flex controller op
		Q_snprintf( pResultName, sizeof( pResultName ), "result_%s", s_pStereoOutputPrefix[ i ] );
		Q_snprintf( pChannelName, sizeof( pChannelName ), "%s_flex_channel", fcInfo.m_pFlexControlName );
		pChannelsClip->CreatePassThruConnection( pChannelName, pStereoCalcOp, 
			pResultName, pFlexControllerOp, "flexWeight" );

		// Create a channel which connects the control to the input of the stereo op
		Q_snprintf( pChannelName, sizeof( pChannelName ), "%s_%s_channel", info.m_pControlName, s_pStereoInputPrefix[ i ] );
		info.m_ppControlChannel[i] = pChannelsClip->CreatePassThruConnection( pChannelName, 
			info.m_pControl, s_pStereoInputPrefix[ i ], pStereoCalcOp, s_pStereoInputPrefix[ i ] );

		// NOTE: The animation set slider panel looks for these custom attributes
		Q_snprintf( pChannelName, sizeof(pChannelName), "%schannel", s_pStereoInputPrefix[ i ] );
		info.m_pControl->SetValue( pChannelName, info.m_ppControlChannel[i] );

		// Switch the channel into play mode by default
		info.m_ppControlChannel[i]->SetMode( CM_PLAY );
	}
}


//-----------------------------------------------------------------------------
// Build the infrastructure of the ops that connect that control to the dmegamemodel
//-----------------------------------------------------------------------------
void CFlexControlBuilder::AttachControlsToGameModel( CDmeAnimationSet *pAnimationSet,
													CDmeGameModel *pGameModel, CDmeChannelsClip *pChannelsClip )
{
	// Build the infrastructure of the ops that connect that control to the dmegamemodel
	int c = m_ControlInfo.Count();
	for ( int i = 0; i < c; ++i )
	{
		ControlInfo_t &info = m_ControlInfo[i];
		if ( info.m_bIsStereo )
		{
			BuildStereoFlexControllerOps( pAnimationSet, pGameModel, pChannelsClip, info );
		}
		else
		{
			BuildFlexControllerOps( pGameModel, pChannelsClip, info, CONTROL_VALUE );
		}

		if ( info.m_bIsMulti )
		{
			BuildFlexControllerOps( pGameModel, pChannelsClip, info, CONTROL_MULTILEVEL );
		}
	}
}


//-----------------------------------------------------------------------------
// Initializes the fields of a flex control
//-----------------------------------------------------------------------------
void CFlexControlBuilder::InitializeFlexControl( ControlInfo_t &info )
{
	CDmElement *pControl = info.m_pControl;

	// Remove these, if they exist...
	for ( int i = 0; i < CONTROL_CHANNEL_ATTRIBUTE_COUNT; ++i )
	{
		pControl->RemoveAttribute( s_pChannelControls[i] );
	}

	// Force these to always be up-to-date
	pControl->SetValue< bool >( "combo", info.m_bIsStereo );
	pControl->SetValue< bool >( "multi", info.m_bIsMulti );
	pControl->SetValue< float >( "defaultValue", info.m_pDefaultValue[CONTROL_VALUE] );
	pControl->SetValue< float >( "defaultBalance", info.m_pDefaultValue[CONTROL_BALANCE] );
	pControl->SetValue< float >( "defaultMultilevel", info.m_pDefaultValue[CONTROL_MULTILEVEL] );

	// These can keep their value if they already exist
	pControl->InitValue< float >( "value", info.m_pDefaultValue[CONTROL_VALUE] );
	if ( info.m_bIsStereo )
	{
		pControl->InitValue< float >( "balance", info.m_pDefaultValue[CONTROL_BALANCE] );
	}
	else
	{
		pControl->RemoveAttribute( "balance" );
	}
	if ( info.m_bIsMulti )
	{
		pControl->InitValue< float >( "multilevel", info.m_pDefaultValue[CONTROL_MULTILEVEL] );
	}
	else
	{
		pControl->RemoveAttribute( "multilevel" );
	}
}


//-----------------------------------------------------------------------------
// Creates all controls for flexes
//-----------------------------------------------------------------------------
void CFlexControlBuilder::CreateFlexControls( CDmeAnimationSet *pAnimationSet )
{
	// Create a facial control for all input controls
	int c = m_ControlInfo.Count();
	for ( int i = 0; i < c; ++i )
	{
		ControlInfo_t &info = m_ControlInfo[i];

		// Check to see if the animation set already has the control
		info.m_pControl = pAnimationSet->FindOrAddControl( info.m_pControlName );

		// Now initialize the fields of the flex control
		InitializeFlexControl( info );
	}
}


//-----------------------------------------------------------------------------
// Attaches existing logs and sets default values for logs
//-----------------------------------------------------------------------------
void CFlexControlBuilder::SetupLogs( CDmeChannelsClip *pChannelsClip, bool bUseExistingLogs )
{
	DmeTime_t targetOffset;
	double flTargetScale;
	ComputeChannelTimeTransform( &targetOffset, &flTargetScale, pChannelsClip );
	double flOOTargetScale = ( flTargetScale != 0.0 ) ? 1.0 / flTargetScale : 1.0;

	// Build the infrastructure of the ops that connect that control to the dmegamemodel
	int c = m_ControlInfo.Count();
	for ( int i = 0; i < c; ++i )
	{
		ControlInfo_t &info = m_ControlInfo[i];
		for ( int j = 0; j < CONTROL_FIELD_COUNT; ++j )
		{
			// Can happen for non-multi or non-stereo controls
			if ( !info.m_ppControlChannel[j] )
				continue;

			// Replace the existing log if we need to
			CDmeFloatLog *pFloatLog = CastElement< CDmeFloatLog >( info.m_ppControlChannel[j]->GetLog() );
			if ( bUseExistingLogs && info.m_pExistingLog[j].m_pLog )
			{
				info.m_ppControlChannel[j]->SetLog( info.m_pExistingLog[j].m_pLog );
				DestroyElement( pFloatLog );
				pFloatLog = info.m_pExistingLog[j].m_pLog;

				// Apply transform to get the log into the space of the current channel
				double flTotalScale = info.m_pExistingLog[j].m_flGlobalScale * flOOTargetScale;
				DmeTime_t totalOffset = info.m_pExistingLog[j].m_GlobalOffset - targetOffset;
				totalOffset.SetSeconds( totalOffset.GetSeconds() * flOOTargetScale );
				pFloatLog->ScaleBiasKeyTimes( flTotalScale, totalOffset );
			}

			// Set the default value for this log
			pFloatLog->SetDefaultValue( info.m_pDefaultValue[j] );
		}
	}
}


//-----------------------------------------------------------------------------
// Main entry point for creating flex animation set controls
//-----------------------------------------------------------------------------
void CFlexControlBuilder::CreateAnimationSetControls( CDmeFilmClip *pMovie, CDmeAnimationSet *pAnimationSet, 
	CDmeGameModel *pGameModel, CDmeFilmClip *pSourceClip, CDmeChannelsClip *pDestClip, bool bUseExistingLogs )
{
	m_pMovie = pMovie;

	FixupExistingFlexControlLogList( pSourceClip, pGameModel );

	// First, look at the current mdl and determine what are its low-level flexcontrollers
	// [these are the outputs eventually driven by the animation set controls]
	BuildDesiredFlexControlList( pGameModel );

	// Next, based on the list of low-level flexcontrollers, determine a high-level set of input controls
	BuildDesiredControlList( pGameModel );

	// Next look at what the animation set currently thinks are the input controls + low-level flexcontrollers
	// and remove the unused ones
	RemoveUnusedExistingFlexControllers( pGameModel );

	RemoveUnusedControlsAndChannels( pAnimationSet, pDestClip );

	if ( bUseExistingLogs )
	{
		// Look at the current input controls + low-level flexcontrollers
		// and grab logs that drive them so we can apply them to the new controls
		BuildExistingFlexControlLogList( pSourceClip, pGameModel );
	}

	// Create the input controls we decided we needed in BuildDesiredControlList
	CreateFlexControls( pAnimationSet );

	// Build channels + control logis attaching the input controls to the low level flex controls
	AttachControlsToGameModel( pAnimationSet, pGameModel, pDestClip );

	// Attach existing logs to the new input controls created in CreateFlexControls
	SetupLogs( pDestClip, bUseExistingLogs );
}


//-----------------------------------------------------------------------------
// Initialize default global flex controller
//-----------------------------------------------------------------------------
void SetupDefaultFlexController()
{
	g_pGlobalFlexController = &s_GlobalFlexController;
}