951 lines
36 KiB
C++
951 lines
36 KiB
C++
//========= 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;
|
|
} |