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