2278 lines
61 KiB
C++
2278 lines
61 KiB
C++
//====== Copyright © 1996-2004, Valve Corporation, All rights reserved. =======
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
#include "movieobjects/dmeclip.h"
|
|
|
|
#include "tier0/dbg.h"
|
|
#include "datamodel/dmelementfactoryhelper.h"
|
|
#include "datamodel/dmehandle.h"
|
|
|
|
#include "movieobjects/dmetimeframe.h"
|
|
#include "movieobjects/dmebookmark.h"
|
|
#include "movieobjects/dmesound.h"
|
|
#include "movieobjects/dmechannel.h"
|
|
#include "movieobjects/dmecamera.h"
|
|
#include "movieobjects/dmedag.h"
|
|
#include "movieobjects/dmeinput.h"
|
|
#include "movieobjects/dmeoperator.h"
|
|
#include "movieobjects/dmematerial.h"
|
|
#include "movieobjects/dmetrack.h"
|
|
#include "movieobjects/dmetrackgroup.h"
|
|
#include "movieobjects/dmematerialoverlayfxclip.h"
|
|
#include "movieobjects/dmeanimationset.h"
|
|
#include "movieobjects_interfaces.h"
|
|
|
|
#include "materialsystem/imaterialsystem.h"
|
|
#include "materialsystem/imaterial.h"
|
|
#include "materialsystem/imesh.h"
|
|
#include "tier3/tier3.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// String to clip type + back
|
|
//-----------------------------------------------------------------------------
|
|
static const char *s_pClipTypeNames[DMECLIP_TYPE_COUNT] =
|
|
{
|
|
"Channel",
|
|
"Audio",
|
|
"Effects",
|
|
"Film",
|
|
};
|
|
|
|
DmeClipType_t ClipTypeFromString( const char *pName )
|
|
{
|
|
for ( DmeClipType_t i = DMECLIP_FIRST; i <= DMECLIP_LAST; ++i )
|
|
{
|
|
if ( !Q_stricmp( pName, s_pClipTypeNames[i] ) )
|
|
return i;
|
|
}
|
|
return DMECLIP_UNKNOWN;
|
|
}
|
|
|
|
const char *ClipTypeToString( DmeClipType_t type )
|
|
{
|
|
if ( type >= DMECLIP_FIRST && type <= DMECLIP_LAST )
|
|
return s_pClipTypeNames[ type ];
|
|
return "Unknown";
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CDmeClip - common base class for filmclips, soundclips, and channelclips
|
|
//-----------------------------------------------------------------------------
|
|
IMPLEMENT_ELEMENT_FACTORY( DmeClip, CDmeClip );
|
|
|
|
void CDmeClip::OnConstruction()
|
|
{
|
|
m_TimeFrame.InitAndCreate( this, "timeFrame" );
|
|
m_ClipColor.InitAndSet( this, "color", Color( 0, 0, 0, 0 ) );
|
|
m_ClipText.Init( this, "text" );
|
|
m_bMute.Init( this, "mute" );
|
|
m_TrackGroups.Init( this, "trackGroups", FATTRIB_MUSTCOPY );
|
|
m_flDisplayScale.InitAndSet( this, "displayScale", 1.0f );
|
|
}
|
|
|
|
void CDmeClip::OnDestruction()
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Clip color
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeClip::SetClipColor( const Color& clr )
|
|
{
|
|
m_ClipColor.Set( clr );
|
|
}
|
|
|
|
Color CDmeClip::GetClipColor() const
|
|
{
|
|
return m_ClipColor.Get();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Clip text
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeClip::SetClipText( const char *pText )
|
|
{
|
|
m_ClipText = pText;
|
|
}
|
|
|
|
const char* CDmeClip::GetClipText() const
|
|
{
|
|
return m_ClipText;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the time frame
|
|
//-----------------------------------------------------------------------------
|
|
CDmeTimeFrame *CDmeClip::GetTimeFrame() const
|
|
{
|
|
return m_TimeFrame.GetElement();
|
|
}
|
|
|
|
DmeTime_t CDmeClip::ToChildMediaTime( DmeTime_t t, bool bClamp ) const
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
return tf ? tf->ToChildMediaTime( t, bClamp ) : DmeTime_t( 0 );
|
|
}
|
|
|
|
DmeTime_t CDmeClip::FromChildMediaTime( DmeTime_t t, bool bClamp ) const
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
return tf ? tf->FromChildMediaTime( t, bClamp ) : DmeTime_t( 0 );
|
|
}
|
|
|
|
DmeTime_t CDmeClip::ToChildMediaDuration( DmeTime_t dt ) const
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
return tf ? tf->ToChildMediaDuration( dt ) : DmeTime_t( 0 );
|
|
}
|
|
|
|
DmeTime_t CDmeClip::FromChildMediaDuration( DmeTime_t dt ) const
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
return tf ? tf->FromChildMediaDuration( dt ) : DmeTime_t( 0 );
|
|
}
|
|
|
|
DmeTime_t CDmeClip::GetTimeOffset() const
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
return tf ? tf->GetTimeOffset() : DmeTime_t( 0 );
|
|
}
|
|
|
|
float CDmeClip::GetTimeScale() const
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
return tf ? tf->GetTimeScale() : 0.0f;
|
|
}
|
|
|
|
DmeTime_t CDmeClip::GetStartTime() const
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
return tf ? tf->GetStartTime() : DmeTime_t( 0 );
|
|
}
|
|
|
|
DmeTime_t CDmeClip::GetEndTime() const
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
return tf ? tf->GetStartTime() + tf->GetDuration() : DmeTime_t( 0 );
|
|
}
|
|
|
|
DmeTime_t CDmeClip::GetDuration() const
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
return tf ? tf->GetDuration() : DmeTime_t( 0 );
|
|
}
|
|
|
|
DmeTime_t CDmeClip::GetStartInChildMediaTime() const
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
return tf ? tf->GetStartInChildMediaTime() : DmeTime_t( 0 );
|
|
}
|
|
|
|
DmeTime_t CDmeClip::GetEndInChildMediaTime() const
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
return tf ? tf->GetEndInChildMediaTime() : DmeTime_t( 0 );
|
|
}
|
|
|
|
void CDmeClip::SetTimeOffset( DmeTime_t t )
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
if ( tf )
|
|
{
|
|
tf->SetTimeOffset( t );
|
|
}
|
|
}
|
|
|
|
void CDmeClip::SetTimeScale( float s )
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
if ( tf )
|
|
{
|
|
tf->SetTimeScale( s );
|
|
}
|
|
}
|
|
|
|
void CDmeClip::SetStartTime( DmeTime_t t )
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
if ( tf )
|
|
{
|
|
tf->SetStartTime( t );
|
|
}
|
|
}
|
|
|
|
void CDmeClip::SetDuration( DmeTime_t t )
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
if ( tf )
|
|
{
|
|
tf->SetDuration( t );
|
|
}
|
|
}
|
|
|
|
|
|
void CDmeClip::BakeTimeScale( float scale /*= 1.0f*/ )
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
Assert( tf );
|
|
if ( !tf )
|
|
return;
|
|
|
|
float flNewScale = tf->GetTimeScale();
|
|
tf->SetTimeScale( 1.0f );
|
|
|
|
if ( scale != 1.0f )
|
|
{
|
|
tf->SetStartTime ( tf->GetStartTime () / scale );
|
|
tf->SetDuration ( tf->GetDuration () / scale );
|
|
tf->SetTimeOffset( tf->GetTimeOffset() / scale );
|
|
flNewScale *= scale;
|
|
}
|
|
|
|
int nTrackGroups = m_TrackGroups.Count();
|
|
for ( int gi = 0; gi < nTrackGroups; ++gi )
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = m_TrackGroups[ gi ];
|
|
if ( !pTrackGroup )
|
|
continue;
|
|
|
|
int nTracks = pTrackGroup->GetTrackCount();
|
|
for ( int ti = 0; ti < nTracks; ++ti )
|
|
{
|
|
CDmeTrack *pTrack = pTrackGroup->GetTrack( ti );
|
|
if ( !pTrack )
|
|
continue;
|
|
|
|
int nClips = pTrack->GetClipCount();
|
|
for ( int ci = 0; ci < nClips; ++ci )
|
|
{
|
|
CDmeClip *pClip = pTrack->GetClip( ci );
|
|
if ( !pClip )
|
|
continue;
|
|
|
|
pClip->BakeTimeScale( flNewScale );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Track iteration
|
|
//-----------------------------------------------------------------------------
|
|
const CUtlVector< DmElementHandle_t > &CDmeClip::GetTrackGroups( ) const
|
|
{
|
|
return m_TrackGroups.Get();
|
|
}
|
|
|
|
int CDmeClip::GetTrackGroupCount( ) const
|
|
{
|
|
// Make sure no invalid clip types have snuck in
|
|
return m_TrackGroups.Count();
|
|
}
|
|
|
|
CDmeTrackGroup *CDmeClip::GetTrackGroup( int nIndex ) const
|
|
{
|
|
if ( ( nIndex >= 0 ) && ( nIndex < m_TrackGroups.Count() ) )
|
|
return m_TrackGroups[ nIndex ];
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Is a track group valid to add?
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmeClip::IsTrackGroupValid( CDmeTrackGroup *pTrackGroup )
|
|
{
|
|
// FIXME: If track groups have allowed types, we can check for validity
|
|
for ( DmeClipType_t i = DMECLIP_FIRST; i <= DMECLIP_LAST; ++i )
|
|
{
|
|
if ( !IsSubClipTypeAllowed( i ) && pTrackGroup->IsSubClipTypeAllowed( i ) )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Track group addition/removal
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeClip::AddTrackGroup( CDmeTrackGroup *pTrackGroup )
|
|
{
|
|
if ( !IsTrackGroupValid( pTrackGroup ) )
|
|
return;
|
|
|
|
// FIXME: Should check if track with same name already exists???
|
|
if ( GetTrackGroupIndex( pTrackGroup ) < 0 )
|
|
{
|
|
m_TrackGroups.AddToTail( pTrackGroup );
|
|
}
|
|
}
|
|
|
|
void CDmeClip::AddTrackGroupBefore( CDmeTrackGroup *pTrackGroup, CDmeTrackGroup *pBefore )
|
|
{
|
|
if ( !IsTrackGroupValid( pTrackGroup ) )
|
|
return;
|
|
|
|
// FIXME: Should check if track with same name already exists???
|
|
if ( GetTrackGroupIndex( pTrackGroup ) < 0 )
|
|
{
|
|
int nBeforeIndex = pBefore ? GetTrackGroupIndex( pBefore ) : GetTrackGroupCount();
|
|
if ( nBeforeIndex >= 0 )
|
|
{
|
|
m_TrackGroups.InsertBefore( nBeforeIndex, pTrackGroup );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
CDmeTrackGroup *CDmeClip::AddTrackGroup( const char *pTrackGroupName )
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = CreateElement< CDmeTrackGroup >( pTrackGroupName, GetFileId() );
|
|
pTrackGroup->SetMinimized( false );
|
|
m_TrackGroups.AddToTail( pTrackGroup );
|
|
return pTrackGroup;
|
|
}
|
|
|
|
void CDmeClip::RemoveTrackGroup( int nIndex )
|
|
{
|
|
Assert( nIndex >= 0 && nIndex < m_TrackGroups.Count() );
|
|
|
|
m_TrackGroups.Remove( nIndex );
|
|
}
|
|
|
|
void CDmeClip::RemoveTrackGroup( CDmeTrackGroup *pTrackGroup )
|
|
{
|
|
int i = GetTrackGroupIndex( pTrackGroup );
|
|
if ( i < 0 )
|
|
return;
|
|
|
|
m_TrackGroups.Remove( i );
|
|
}
|
|
|
|
void CDmeClip::RemoveTrackGroup( const char *pTrackGroupName )
|
|
{
|
|
if ( !pTrackGroupName )
|
|
{
|
|
pTrackGroupName = DMETRACKGROUP_DEFAULT_NAME;
|
|
}
|
|
|
|
int c = m_TrackGroups.Count();
|
|
for ( int i = c; --i >= 0; )
|
|
{
|
|
if ( !Q_strcmp( m_TrackGroups[i]->GetName(), pTrackGroupName ) )
|
|
{
|
|
m_TrackGroups.Remove( i );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Swap track groups
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeClip::SwapOrder( CDmeTrackGroup *pTrackGroup1, CDmeTrackGroup *pTrackGroup2 )
|
|
{
|
|
if ( pTrackGroup1 == pTrackGroup2 )
|
|
return;
|
|
if ( pTrackGroup1->IsFilmTrackGroup() || pTrackGroup2->IsFilmTrackGroup() )
|
|
return;
|
|
|
|
int nIndex1 = -1, nIndex2 = -1;
|
|
int c = m_TrackGroups.Count();
|
|
for ( int i = c; --i >= 0; )
|
|
{
|
|
if ( m_TrackGroups[i] == pTrackGroup1 )
|
|
{
|
|
nIndex1 = i;
|
|
}
|
|
if ( m_TrackGroups[i] == pTrackGroup2 )
|
|
{
|
|
nIndex2 = i;
|
|
}
|
|
}
|
|
if ( ( nIndex1 < 0 ) || ( nIndex2 < 0 ) )
|
|
return;
|
|
|
|
m_TrackGroups.Swap( nIndex1, nIndex2 );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Track group finding
|
|
//-----------------------------------------------------------------------------
|
|
CDmeTrackGroup *CDmeClip::FindTrackGroup( const char *pTrackGroupName ) const
|
|
{
|
|
if ( !pTrackGroupName )
|
|
{
|
|
pTrackGroupName = DMETRACKGROUP_DEFAULT_NAME;
|
|
}
|
|
|
|
int c = m_TrackGroups.Count();
|
|
for ( int i = 0 ; i < c; ++i )
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = m_TrackGroups[i];
|
|
if ( !pTrackGroup )
|
|
continue;
|
|
|
|
if ( !Q_strcmp( pTrackGroup->GetName(), pTrackGroupName ) )
|
|
return pTrackGroup;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int CDmeClip::GetTrackGroupIndex( CDmeTrackGroup *pTrackGroup ) const
|
|
{
|
|
int nTrackGroups = m_TrackGroups.Count();
|
|
for ( int i = 0 ; i < nTrackGroups; ++i )
|
|
{
|
|
if ( pTrackGroup == m_TrackGroups[i] )
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Find or create a track group
|
|
//-----------------------------------------------------------------------------
|
|
CDmeTrackGroup *CDmeClip::FindOrAddTrackGroup( const char *pTrackGroupName )
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = FindTrackGroup( pTrackGroupName );
|
|
if ( !pTrackGroup )
|
|
{
|
|
pTrackGroup = AddTrackGroup( pTrackGroupName );
|
|
}
|
|
return pTrackGroup;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Finding clips in track groups
|
|
//-----------------------------------------------------------------------------
|
|
CDmeTrack *CDmeClip::FindTrackForClip( CDmeClip *pClip, CDmeTrackGroup **ppTrackGroup /*= NULL*/ ) const
|
|
{
|
|
// DmeClipType_t type = pClip->GetClipType();
|
|
int c = m_TrackGroups.Count();
|
|
for ( int i = 0 ; i < c; ++i )
|
|
{
|
|
// FIXME: If trackgroups have valid types, can early out here
|
|
CDmeTrack *pTrack = m_TrackGroups[i]->FindTrackForClip( pClip );
|
|
if ( pTrack )
|
|
{
|
|
if ( ppTrackGroup )
|
|
{
|
|
*ppTrackGroup = m_TrackGroups[i];
|
|
}
|
|
return pTrack;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool CDmeClip::FindMultiTrackGroupForClip( CDmeClip *pClip, int *pTrackGroupIndex, int *pTrackIndex, int *pClipIndex ) const
|
|
{
|
|
int nTrackGroups = m_TrackGroups.Count();
|
|
for ( int gi = 0 ; gi < nTrackGroups; ++gi )
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = m_TrackGroups[ gi ];
|
|
if ( !pTrackGroup )
|
|
continue;
|
|
|
|
if ( !pTrackGroup->FindTrackForClip( pClip, pTrackIndex, pClipIndex ) )
|
|
continue;
|
|
|
|
if ( pTrackGroupIndex )
|
|
{
|
|
*pTrackGroupIndex = gi;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Finding clips in tracks by time
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeClip::FindClipsAtTime( DmeClipType_t clipType, DmeTime_t time, DmeClipSkipFlag_t flags, CUtlVector< CDmeClip * >& clips ) const
|
|
{
|
|
if ( clipType == DMECLIP_FILM )
|
|
return;
|
|
|
|
int gc = GetTrackGroupCount();
|
|
for ( int i = 0; i < gc; ++i )
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = GetTrackGroup( i );
|
|
if ( !pTrackGroup )
|
|
continue;
|
|
|
|
pTrackGroup->FindClipsAtTime( clipType, time, flags, clips );
|
|
}
|
|
}
|
|
|
|
void CDmeClip::FindClipsIntersectingTime( DmeClipType_t clipType, DmeTime_t startTime, DmeTime_t endTime, DmeClipSkipFlag_t flags, CUtlVector< CDmeClip * >& clips ) const
|
|
{
|
|
if ( clipType == DMECLIP_FILM )
|
|
return;
|
|
|
|
int gc = GetTrackGroupCount();
|
|
for ( int i = 0; i < gc; ++i )
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = GetTrackGroup( i );
|
|
if ( !pTrackGroup )
|
|
continue;
|
|
|
|
pTrackGroup->FindClipsIntersectingTime( clipType, startTime, endTime, flags, clips );
|
|
}
|
|
}
|
|
|
|
void CDmeClip::FindClipsWithinTime( DmeClipType_t clipType, DmeTime_t startTime, DmeTime_t endTime, DmeClipSkipFlag_t flags, CUtlVector< CDmeClip * >& clips ) const
|
|
{
|
|
if ( clipType == DMECLIP_FILM )
|
|
return;
|
|
|
|
int gc = GetTrackGroupCount();
|
|
for ( int i = 0; i < gc; ++i )
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = GetTrackGroup( i );
|
|
if ( !pTrackGroup )
|
|
continue;
|
|
|
|
pTrackGroup->FindClipsWithinTime( clipType, startTime, endTime, flags, clips );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Build a list of all referring clips
|
|
//-----------------------------------------------------------------------------
|
|
static int BuildReferringClipList( const CDmeClip *pClip, CDmeClip** ppParents, int nMaxCount )
|
|
{
|
|
int nCount = 0;
|
|
|
|
DmAttributeReferenceIterator_t it, it2, it3;
|
|
for ( it = g_pDataModel->FirstAttributeReferencingElement( pClip->GetHandle() );
|
|
it != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID;
|
|
it = g_pDataModel->NextAttributeReferencingElement( it ) )
|
|
{
|
|
CDmAttribute *pAttribute = g_pDataModel->GetAttribute( it );
|
|
const char *pName = pAttribute->GetName();
|
|
CDmElement *pElement = pAttribute->GetOwner();
|
|
CDmeTrack *pTrack = CastElement< CDmeTrack >( pElement );
|
|
if ( !pTrack )
|
|
continue;
|
|
|
|
for ( it2 = g_pDataModel->FirstAttributeReferencingElement( pTrack->GetHandle() );
|
|
it2 != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID;
|
|
it2 = g_pDataModel->NextAttributeReferencingElement( it2 ) )
|
|
{
|
|
pAttribute = g_pDataModel->GetAttribute( it2 );
|
|
pName = pAttribute->GetName();
|
|
pElement = pAttribute->GetOwner();
|
|
CDmeTrackGroup *pTrackGroup = CastElement< CDmeTrackGroup >( pElement );
|
|
if ( !pTrackGroup )
|
|
continue;
|
|
|
|
for ( it3 = g_pDataModel->FirstAttributeReferencingElement( pTrackGroup->GetHandle() );
|
|
it3 != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID;
|
|
it3 = g_pDataModel->NextAttributeReferencingElement( it3 ) )
|
|
{
|
|
pAttribute = g_pDataModel->GetAttribute( it3 );
|
|
pName = pAttribute->GetName();
|
|
pElement = pAttribute->GetOwner();
|
|
CDmeClip *pParent = CastElement< CDmeClip >( pElement );
|
|
if ( !pParent )
|
|
continue;
|
|
|
|
Assert( nCount < nMaxCount );
|
|
if ( nCount >= nMaxCount )
|
|
return nCount;
|
|
ppParents[nCount++] = pParent;
|
|
}
|
|
}
|
|
}
|
|
return nCount;
|
|
}
|
|
|
|
bool CDmeClip::BuildClipStack( DmeClipStack_t* pStack, const CDmeClip *pMovie, CDmeClip *pShot /*=NULL*/ )
|
|
{
|
|
// Walk through each shot in the movie and look for the subClip, if don't find it recurse into each shot
|
|
return pStack->BuildClipStack( pMovie, pShot, this );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Clip stack
|
|
//-----------------------------------------------------------------------------
|
|
bool DmeClipStack_t::BuildClipStack_R( const CDmeClip *pMovie, const CDmeClip *pShot, const CDmeClip *pCurrent )
|
|
{
|
|
// Add this clip to the stack
|
|
int nIndex = AddClipToHead( pCurrent );
|
|
|
|
// Is this clip the shot? We don't need to look for it any more.
|
|
if ( pCurrent == pShot )
|
|
{
|
|
pShot = NULL;
|
|
}
|
|
|
|
// Is this clip the movie? We succeeded if we already found the shot!
|
|
if ( pCurrent == pMovie )
|
|
{
|
|
if ( !pShot )
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
// NOTE: This algorithm assumes a clip can never appear twice under another clip
|
|
// at a single level of hierarchy.
|
|
CDmeClip* ppParents[1024];
|
|
int nCount = BuildReferringClipList( pCurrent, ppParents, 1024 );
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
// Can we find a path to the root through the shot? We succeeded!
|
|
if ( BuildClipStack_R( pMovie, pShot, ppParents[i] ) )
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// This clip didn't work out for us. Remove it.
|
|
RemoveClip( nIndex );
|
|
|
|
return false;
|
|
}
|
|
|
|
bool DmeClipStack_t::BuildClipStack( const CDmeClip *pMovie, const CDmeClip *pShot, const CDmeClip *pClip )
|
|
{
|
|
// Walk through each shot in the movie and look for the subClip, if don't find it recurse into each shot
|
|
RemoveAll();
|
|
return BuildClipStack_R( pMovie, pShot, pClip );
|
|
}
|
|
|
|
int DmeClipStack_t::FindClip( const CDmeClip *pClip ) const
|
|
{
|
|
if ( !pClip )
|
|
return m_clips.InvalidIndex();
|
|
|
|
return m_clips.Find( pClip->GetHandle() );
|
|
}
|
|
|
|
int DmeClipStack_t::AddClipToHead( const CDmeClip *pClip )
|
|
{
|
|
if ( !pClip )
|
|
return m_clips.InvalidIndex();
|
|
|
|
m_bOptimized = false;
|
|
return m_clips.AddToHead( pClip->GetHandle() );
|
|
}
|
|
|
|
int DmeClipStack_t::AddClipToTail( const CDmeClip *pClip )
|
|
{
|
|
if ( !pClip )
|
|
return m_clips.InvalidIndex();
|
|
|
|
m_bOptimized = false;
|
|
return m_clips.AddToTail( pClip->GetHandle() );
|
|
}
|
|
|
|
//#define TEST_CLIP_STACK_OPTIMIZER
|
|
|
|
void DmeClipStack_t::Optimize() const
|
|
{
|
|
m_bOptimized = true;
|
|
|
|
int nClips = m_clips.Count();
|
|
if ( nClips == 0 )
|
|
{
|
|
m_tStart = m_tOffset = DMETIME_MINTIME + DMETIME_MAXTIME / 2; // HACK
|
|
m_tDuration = DMETIME_MAXTIME;
|
|
m_flScale = 1.0f;
|
|
return;
|
|
}
|
|
|
|
// 0 = global, n-1 = local
|
|
|
|
#ifdef TEST_CLIP_STACK_OPTIMIZER
|
|
DmeTime_t tOptimizedClamped0 = DMETIME_ZERO;
|
|
DmeTime_t tTimeFrameClamped0 = DMETIME_ZERO;
|
|
DmeTime_t tOptimizedUnclamped0 = DMETIME_ZERO;
|
|
DmeTime_t tTimeFrameUnclamped0 = DMETIME_ZERO;
|
|
DmeTime_t tOptimizedClamped1 = DmeTime_t( 10000 );
|
|
DmeTime_t tTimeFrameClamped1 = DmeTime_t( 10000 );
|
|
DmeTime_t tOptimizedUnclamped1 = DmeTime_t( 10000 );
|
|
DmeTime_t tTimeFrameUnclamped1 = DmeTime_t( 10000 );
|
|
#endif
|
|
|
|
const CDmeClip *pClip = m_clips[ nClips - 1 ];
|
|
m_tStart = pClip->GetStartTime();
|
|
m_tOffset = pClip->GetTimeOffset();
|
|
m_tDuration = pClip->GetDuration();
|
|
m_flScale = pClip->GetTimeScale();
|
|
|
|
#ifdef TEST_CLIP_STACK_OPTIMIZER
|
|
tOptimizedClamped0 = FromChildMediaTime( DMETIME_ZERO, true );
|
|
tTimeFrameClamped0 = pClip->FromChildMediaTime( tTimeFrameClamped0, true );
|
|
Assert( tOptimizedClamped0 == tTimeFrameClamped0 );
|
|
|
|
tOptimizedUnclamped0 = FromChildMediaTime( DMETIME_ZERO, false );
|
|
tTimeFrameUnclamped0 = pClip->FromChildMediaTime( tTimeFrameUnclamped0, false );
|
|
Assert( tOptimizedUnclamped0 == tTimeFrameUnclamped0 );
|
|
|
|
tOptimizedClamped1 = FromChildMediaTime( DmeTime_t( 10000 ), true );
|
|
tTimeFrameClamped1 = pClip->FromChildMediaTime( tTimeFrameClamped1, true );
|
|
Assert( tOptimizedClamped1 == tTimeFrameClamped1 );
|
|
|
|
tOptimizedUnclamped1 = FromChildMediaTime( DmeTime_t( 10000 ), false );
|
|
tTimeFrameUnclamped1 = pClip->FromChildMediaTime( tTimeFrameUnclamped1, false );
|
|
Assert( tOptimizedUnclamped1 == tTimeFrameUnclamped1 );
|
|
#endif
|
|
|
|
for ( int i = nClips - 2; i > 0; --i )
|
|
{
|
|
const CDmeClip *pClip = m_clips[ i ];
|
|
|
|
#ifdef TEST_CLIP_STACK_OPTIMIZER
|
|
DmeTime_t tOldStart = m_tStart;
|
|
DmeTime_t tOldOffset = m_tOffset;
|
|
DmeTime_t tOldDuration = m_tDuration;
|
|
float flOldScale = m_flScale;
|
|
|
|
DmeTime_t tClipStart = pClip->GetStartTime();
|
|
DmeTime_t tClipOffset = pClip->GetTimeOffset();
|
|
DmeTime_t tClipDuration = pClip->GetDuration();
|
|
float flClipSCale = pClip->GetTimeScale();
|
|
#endif
|
|
|
|
DmeTime_t tChildStartInParentTime = pClip->FromChildMediaTime( m_tStart, false );
|
|
DmeTime_t tChildOffsetInParentTime = pClip->FromChildMediaDuration( m_tOffset );
|
|
DmeTime_t tChildDurationInParentTime = pClip->FromChildMediaDuration( m_tDuration );
|
|
DmeTime_t tChildEndInParentTime = tChildStartInParentTime + tChildDurationInParentTime;
|
|
m_flScale = pClip->GetTimeScale() * m_flScale;
|
|
|
|
m_tStart = MAX( tChildStartInParentTime, pClip->GetStartTime() );
|
|
DmeTime_t tDiff = tChildStartInParentTime - m_tStart;
|
|
m_tOffset = tChildOffsetInParentTime - tDiff;
|
|
DmeTime_t tEnd = MIN( tChildEndInParentTime, pClip->GetEndTime() );
|
|
m_tDuration = MAX( DMETIME_ZERO, tEnd - m_tStart );
|
|
|
|
#ifdef TEST_CLIP_STACK_OPTIMIZER
|
|
tOptimizedClamped0 = FromChildMediaTime( DMETIME_ZERO, true );
|
|
tTimeFrameClamped0 = pClip->FromChildMediaTime( tTimeFrameClamped0, true );
|
|
Assert( tOptimizedClamped0 == tTimeFrameClamped0 );
|
|
|
|
tOptimizedUnclamped0 = FromChildMediaTime( DMETIME_ZERO, false );
|
|
tTimeFrameUnclamped0 = pClip->FromChildMediaTime( tTimeFrameUnclamped0, false );
|
|
Assert( tOptimizedUnclamped0 == tTimeFrameUnclamped0 );
|
|
|
|
tOptimizedClamped1 = FromChildMediaTime( DmeTime_t( 10000 ), true );
|
|
tTimeFrameClamped1 = pClip->FromChildMediaTime( tTimeFrameClamped1, true );
|
|
Assert( tOptimizedClamped1 == tTimeFrameClamped1 );
|
|
|
|
tOptimizedUnclamped1 = FromChildMediaTime( DmeTime_t( 10000 ), false );
|
|
tTimeFrameUnclamped1 = pClip->FromChildMediaTime( tTimeFrameUnclamped1, false );
|
|
Assert( tOptimizedUnclamped1 == tTimeFrameUnclamped1 );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
DmeTime_t DmeClipStack_t::ToChildMediaTime( DmeTime_t t, bool bClamp /*=true*/ ) const
|
|
{
|
|
if ( !m_bOptimized )
|
|
{
|
|
Optimize();
|
|
}
|
|
|
|
t -= m_tStart;
|
|
if ( bClamp )
|
|
{
|
|
t.Clamp( DMETIME_ZERO, m_tDuration );
|
|
}
|
|
return ( t + m_tOffset ) * m_flScale;
|
|
}
|
|
|
|
DmeTime_t DmeClipStack_t::FromChildMediaTime( DmeTime_t t, bool bClamp /*=true*/ ) const
|
|
{
|
|
if ( !m_bOptimized )
|
|
{
|
|
Optimize();
|
|
}
|
|
|
|
t = t / m_flScale - m_tOffset;
|
|
if ( bClamp )
|
|
{
|
|
t.Clamp( DMETIME_ZERO, m_tDuration );
|
|
}
|
|
return t + m_tStart;
|
|
}
|
|
|
|
DmeTime_t DmeClipStack_t::ToChildMediaDuration( DmeTime_t t ) const
|
|
{
|
|
if ( !m_bOptimized )
|
|
{
|
|
Optimize();
|
|
}
|
|
|
|
return t * m_flScale;
|
|
}
|
|
|
|
DmeTime_t DmeClipStack_t::FromChildMediaDuration( DmeTime_t t ) const
|
|
{
|
|
if ( !m_bOptimized )
|
|
{
|
|
Optimize();
|
|
}
|
|
|
|
return t / m_flScale;
|
|
}
|
|
|
|
void DmeClipStack_t::ToChildMediaTime( TimeSelection_t ¶ms ) const
|
|
{
|
|
for ( int i = 0; i < TS_TIME_COUNT; ++i )
|
|
{
|
|
params.m_Times[i] = ToChildMediaTime( params.m_Times[i], false );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// CDmeSoundClip - timeframe view into a dmesound
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
IMPLEMENT_ELEMENT_FACTORY( DmeSoundClip, CDmeSoundClip );
|
|
|
|
void CDmeSoundClip::OnConstruction()
|
|
{
|
|
m_Sound.Init( this, "sound" );
|
|
m_bShowWave.InitAndSet( this, "showwave", false );
|
|
m_fadeInDuration .InitAndSet( this, "fadeIn", DMETIME_ZERO );
|
|
m_fadeOutDuration.InitAndSet( this, "fadeOut", DMETIME_ZERO );
|
|
}
|
|
|
|
void CDmeSoundClip::OnDestruction()
|
|
{
|
|
}
|
|
|
|
void CDmeSoundClip::SetShowWave( bool state )
|
|
{
|
|
m_bShowWave = state;
|
|
}
|
|
|
|
bool CDmeSoundClip::ShouldShowWave( ) const
|
|
{
|
|
return m_bShowWave;
|
|
}
|
|
|
|
float CDmeSoundClip::GetVolumeFade( DmeTime_t tParent )
|
|
{
|
|
float fade = 1.0f;
|
|
if ( tParent < GetStartTime() + m_fadeInDuration )
|
|
{
|
|
fade = ( tParent - GetStartTime() ) / m_fadeInDuration;
|
|
}
|
|
if ( tParent > GetEndTime() - m_fadeOutDuration )
|
|
{
|
|
fade = MIN( fade, ( GetEndTime() - tParent ) / m_fadeOutDuration );
|
|
}
|
|
return fade;
|
|
}
|
|
|
|
void CDmeSoundClip::BakeTimeScale( float scale /*= 1.0f*/ )
|
|
{
|
|
float flNewScale = scale * GetTimeScale();
|
|
float flInvScale = 1.0f / flNewScale;
|
|
|
|
m_fadeInDuration *= flInvScale;
|
|
m_fadeOutDuration *= flInvScale;
|
|
|
|
BaseClass::BakeTimeScale( scale );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CDmeChannelsClip - timeframe view into a set of channels
|
|
//-----------------------------------------------------------------------------
|
|
IMPLEMENT_ELEMENT_FACTORY( DmeChannelsClip, CDmeChannelsClip );
|
|
|
|
void CDmeChannelsClip::OnConstruction()
|
|
{
|
|
m_Channels.Init( this, "channels" );
|
|
}
|
|
|
|
void CDmeChannelsClip::OnDestruction()
|
|
{
|
|
}
|
|
|
|
bool IsParticleSystemChannelsClip( CDmeChannelsClip *pChannelsClip )
|
|
{
|
|
int nChannels = pChannelsClip->m_Channels.Count();
|
|
for ( int i = 0; i < nChannels; ++i )
|
|
{
|
|
CDmeChannel *pChannel = pChannelsClip->m_Channels[ i ];
|
|
if ( !pChannel )
|
|
continue;
|
|
|
|
CDmElement *pToElement = pChannel->GetToElement();
|
|
if ( !pToElement )
|
|
continue;
|
|
|
|
if ( !V_stricmp( pToElement->GetTypeString(), "DmeGameParticleSystem" ) )
|
|
return true;
|
|
|
|
CDmeTransform *pTransform = CastElement< CDmeTransform >( pToElement );
|
|
if ( !pTransform )
|
|
continue;
|
|
|
|
CUtlVector< CDmeDag* > dags;
|
|
FindAncestorsReferencingElement( pTransform, dags );
|
|
int nDags = dags.Count();
|
|
for ( int i = 0; i < nDags; ++i )
|
|
{
|
|
if ( !V_stricmp( dags[ i ]->GetTypeString(), "DmeGameParticleSystem" ) )
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CDmeChannelsClip::BakeTimeScale( float scale /*= 1.0f*/ )
|
|
{
|
|
float flNewScale = scale * GetTimeScale();
|
|
|
|
// HACK - particle systems can't really be un-scaled in this way, for apparently two reasons:
|
|
// 1) we're storing time data in the dmegameparticlesystem (ie in the scene, rather than in clips/channels)
|
|
// 2) the game's particle systems appear to be semi-hardcoded in relation to time (so blinking materials don't blink at the scaled rate after baking)
|
|
if ( IsParticleSystemChannelsClip( this ) )
|
|
{
|
|
CDmeTimeFrame *tf = m_TimeFrame.GetElement();
|
|
tf->SetStartTime ( tf->GetStartTime () / scale );
|
|
tf->SetDuration ( tf->GetDuration () / scale );
|
|
tf->SetTimeOffset( tf->GetTimeOffset() / scale );
|
|
tf->SetTimeScale ( scale );
|
|
return; // skip particle system channels clips
|
|
}
|
|
|
|
int nChannels = m_Channels.Count();
|
|
for ( int i = 0; i < nChannels; ++i )
|
|
{
|
|
CDmeChannel *pChannel = m_Channels[ i ];
|
|
if ( !pChannel )
|
|
continue;
|
|
pChannel->ScaleSampleTimes( 1.0f / flNewScale );
|
|
}
|
|
|
|
BaseClass::BakeTimeScale( scale );
|
|
}
|
|
|
|
CDmeChannel *CDmeChannelsClip::CreatePassThruConnection( char const *passThruName,
|
|
CDmElement *pFrom, char const *pFromAttribute,
|
|
CDmElement *pTo, char const *pToAttribute, int index /*= 0*/ )
|
|
{
|
|
CDmeChannel *helper = CreateElement< CDmeChannel >( passThruName, GetFileId() );
|
|
Assert( helper );
|
|
|
|
helper->SetMode( CM_PASS );
|
|
helper->SetInput( pFrom, pFromAttribute );
|
|
helper->SetOutput( pTo, pToAttribute, index );
|
|
|
|
m_Channels.AddToTail( helper );
|
|
|
|
return helper;
|
|
}
|
|
|
|
void CDmeChannelsClip::RemoveChannel( CDmeChannel *pChannel )
|
|
{
|
|
int nCount = m_Channels.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
if ( pChannel == m_Channels[i] )
|
|
{
|
|
m_Channels.Remove( i );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set the mode of all of the channels in the clip
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeChannelsClip::SetChannelMode( const ChannelMode_t &mode )
|
|
{
|
|
int nCount = m_Channels.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
CDmeChannel *pChannel = m_Channels[ i ];
|
|
if ( pChannel )
|
|
{
|
|
pChannel->SetMode( mode );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Operate all of the channels in the clip
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeChannelsClip::OperateChannels()
|
|
{
|
|
int nCount = m_Channels.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
CDmeChannel *pChannel = m_Channels[ i ];
|
|
if ( pChannel )
|
|
{
|
|
pChannel->Operate();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Play all of the channels in the clip
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeChannelsClip::PlayChannels()
|
|
{
|
|
int nCount = m_Channels.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
CDmeChannel *pChannel = m_Channels[ i ];
|
|
if ( pChannel )
|
|
{
|
|
pChannel->Play();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CDmeFXClip - timeframe view into an effect
|
|
//-----------------------------------------------------------------------------
|
|
IMPLEMENT_ELEMENT_FACTORY( DmeFXClip, CDmeFXClip );
|
|
|
|
void CDmeFXClip::OnConstruction()
|
|
{
|
|
}
|
|
|
|
void CDmeFXClip::OnDestruction()
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Global list of FX clip types
|
|
//-----------------------------------------------------------------------------
|
|
const char *CDmeFXClip::s_pFXClipTypes[MAX_FXCLIP_TYPES];
|
|
const char *CDmeFXClip::s_pFXClipDescriptions[MAX_FXCLIP_TYPES];
|
|
int CDmeFXClip::s_nFXClipTypeCount = 0;
|
|
|
|
void CDmeFXClip::InstallFXClipType( const char *pElementType, const char *pDescription )
|
|
{
|
|
s_pFXClipTypes[s_nFXClipTypeCount] = pElementType;
|
|
s_pFXClipDescriptions[s_nFXClipTypeCount] = pDescription;
|
|
++s_nFXClipTypeCount;
|
|
}
|
|
|
|
int CDmeFXClip::FXClipTypeCount()
|
|
{
|
|
return s_nFXClipTypeCount;
|
|
}
|
|
|
|
const char *CDmeFXClip::FXClipType( int nIndex )
|
|
{
|
|
Assert( s_nFXClipTypeCount > nIndex );
|
|
return s_pFXClipTypes[nIndex];
|
|
}
|
|
|
|
const char *CDmeFXClip::FXClipDescription( int nIndex )
|
|
{
|
|
Assert( s_nFXClipTypeCount > nIndex );
|
|
return s_pFXClipDescriptions[nIndex];
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CDmeFilmClip - hierarchical clip (movie, sequence or shot) w/ scene info
|
|
//-----------------------------------------------------------------------------
|
|
IMPLEMENT_ELEMENT_FACTORY( DmeFilmClip, CDmeFilmClip );
|
|
|
|
void CDmeFilmClip::OnConstruction()
|
|
{
|
|
m_pRemoteVideoMaterial = NULL;
|
|
m_MaterialOverlayEffect.Init( this, "materialOverlay" );
|
|
|
|
m_MapName.Init( this, "mapname" );
|
|
m_Camera.Init( this, "camera" );
|
|
m_MonitorCameras.Init( this, "monitorCameras" );
|
|
m_nActiveMonitor.InitAndSet( this, "activeMonitor", -1 );
|
|
m_Scene.Init( this, "scene" );
|
|
m_AVIFile.Init( this, "aviFile", FATTRIB_HAS_CALLBACK );
|
|
m_fadeInDuration .InitAndSet( this, "fadeIn", DMETIME_ZERO );
|
|
m_fadeOutDuration.InitAndSet( this, "fadeOut", DMETIME_ZERO );
|
|
|
|
m_Inputs.Init( this, "inputs" );
|
|
m_Operators.Init( this, "operators" );
|
|
m_bIsUsingCachedVersion.Init( this, "useAviFile", FATTRIB_HAS_CALLBACK );
|
|
m_AnimationSets.Init( this, "animationSets" );
|
|
m_BookmarkSets.Init( this, "bookmarkSets" );
|
|
m_nActiveBookmarkSet.Init(this, "activeBookmarkSet", 0 );
|
|
m_FilmTrackGroup.Init( this, "subClipTrackGroup", FATTRIB_HAS_CALLBACK );
|
|
m_Volume.InitAndSet( this, "volume", 1.0);
|
|
m_ConCommands.Init( this, "concommands" );
|
|
m_ConVars.Init( this, "convars" );
|
|
|
|
m_hCachedVersion = AVIMATERIAL_INVALID;
|
|
m_bIsUsingCachedVersion = false;
|
|
m_bReloadCachedVersion = false;
|
|
|
|
m_CameraStack.Init( this, "camerastack" );
|
|
|
|
m_nCurrentStackCamera = 0;
|
|
}
|
|
|
|
void CDmeFilmClip::OnDestruction()
|
|
{
|
|
AssignRemoteVideoMaterial( NULL );
|
|
if ( m_hCachedVersion != AVIMATERIAL_INVALID )
|
|
{
|
|
g_pAVI->DestroyAVIMaterial( m_hCachedVersion );
|
|
m_hCachedVersion = AVIMATERIAL_INVALID;
|
|
}
|
|
|
|
PurgeCameraStack();
|
|
}
|
|
|
|
void CDmeFilmClip::BakeTimeScale( float scale /*= 1.0f*/ )
|
|
{
|
|
float flNewScale = scale * GetTimeScale();
|
|
float flInvScale = 1.0f / flNewScale;
|
|
|
|
int nBookmarkSets = m_BookmarkSets.Count();
|
|
for ( int i = 0; i < nBookmarkSets; ++i )
|
|
{
|
|
CDmeBookmarkSet *pBookmarkSet = m_BookmarkSets[ i ];
|
|
if ( !pBookmarkSet )
|
|
continue;
|
|
|
|
pBookmarkSet->ScaleBookmarkTimes( flInvScale );
|
|
}
|
|
|
|
m_fadeInDuration *= flInvScale;
|
|
m_fadeOutDuration *= flInvScale;
|
|
|
|
if ( CDmeTrack *pTrack = GetFilmTrack() )
|
|
{
|
|
int nClips = pTrack->GetClipCount();
|
|
for ( int i = 0; i < nClips; ++i )
|
|
{
|
|
CDmeClip *pClip = pTrack->GetClip( i );
|
|
if ( !pClip )
|
|
continue;
|
|
|
|
pClip->BakeTimeScale( flNewScale );
|
|
}
|
|
}
|
|
|
|
BaseClass::BakeTimeScale( scale );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the special film track group
|
|
//-----------------------------------------------------------------------------
|
|
CDmeTrackGroup *CDmeFilmClip::GetFilmTrackGroup() const
|
|
{
|
|
return m_FilmTrackGroup;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the special film track
|
|
//-----------------------------------------------------------------------------
|
|
CDmeTrack *CDmeFilmClip::GetFilmTrack() const
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = m_FilmTrackGroup.GetElement();
|
|
if ( pTrackGroup )
|
|
return pTrackGroup->GetFilmTrack();
|
|
return NULL;
|
|
}
|
|
|
|
CDmeTrackGroup *CDmeFilmClip::FindOrCreateFilmTrackGroup()
|
|
{
|
|
if ( !m_FilmTrackGroup )
|
|
{
|
|
m_FilmTrackGroup = CreateElement< CDmeTrackGroup >( "subClipTrackGroup", GetFileId() );
|
|
m_FilmTrackGroup->SetMinimized( false );
|
|
m_FilmTrackGroup->SetMaxTrackCount( 1 );
|
|
}
|
|
return m_FilmTrackGroup;
|
|
}
|
|
|
|
CDmeTrack *CDmeFilmClip::FindOrCreateFilmTrack()
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = FindOrCreateFilmTrackGroup();
|
|
CDmeTrack *pTrack = pTrackGroup->GetFilmTrack();
|
|
return pTrack ? pTrack : m_FilmTrackGroup->CreateFilmTrack();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Finding clips in track groups
|
|
//-----------------------------------------------------------------------------
|
|
CDmeTrack *CDmeFilmClip::FindTrackForClip( CDmeClip *pClip, CDmeTrackGroup **ppTrackGroup /*= NULL*/ ) const
|
|
{
|
|
if ( m_FilmTrackGroup.GetElement() )
|
|
{
|
|
CDmeTrack *pTrack = m_FilmTrackGroup->FindTrackForClip( pClip );
|
|
if ( pTrack )
|
|
{
|
|
if ( ppTrackGroup )
|
|
{
|
|
*ppTrackGroup = m_FilmTrackGroup;
|
|
}
|
|
return pTrack;
|
|
}
|
|
}
|
|
|
|
return CDmeClip::FindTrackForClip( pClip, ppTrackGroup );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Finding clips in tracks by time
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeFilmClip::FindClipsAtTime( DmeClipType_t clipType, DmeTime_t time, DmeClipSkipFlag_t flags, CUtlVector< CDmeClip * >& clips ) const
|
|
{
|
|
if ( ( clipType == DMECLIP_FILM ) || ( clipType == DMECLIP_UNKNOWN ) )
|
|
{
|
|
if ( m_FilmTrackGroup )
|
|
{
|
|
m_FilmTrackGroup->FindClipsAtTime( clipType, time, flags, clips );
|
|
}
|
|
}
|
|
|
|
CDmeClip::FindClipsAtTime( clipType, time, flags, clips );
|
|
}
|
|
|
|
void CDmeFilmClip::FindClipsIntersectingTime( DmeClipType_t clipType, DmeTime_t startTime, DmeTime_t endTime, DmeClipSkipFlag_t flags, CUtlVector< CDmeClip * >& clips ) const
|
|
{
|
|
if ( ( clipType == DMECLIP_FILM ) || ( clipType == DMECLIP_UNKNOWN ) )
|
|
{
|
|
if ( m_FilmTrackGroup )
|
|
{
|
|
m_FilmTrackGroup->FindClipsIntersectingTime( clipType, startTime, endTime, flags, clips );
|
|
}
|
|
}
|
|
|
|
CDmeClip::FindClipsIntersectingTime( clipType, startTime, endTime, flags, clips );
|
|
}
|
|
|
|
void CDmeFilmClip::FindClipsWithinTime( DmeClipType_t clipType, DmeTime_t startTime, DmeTime_t endTime, DmeClipSkipFlag_t flags, CUtlVector< CDmeClip * >& clips ) const
|
|
{
|
|
if ( ( clipType == DMECLIP_FILM ) || ( clipType == DMECLIP_UNKNOWN ) )
|
|
{
|
|
if ( m_FilmTrackGroup )
|
|
{
|
|
m_FilmTrackGroup->FindClipsWithinTime( clipType, startTime, endTime, flags, clips );
|
|
}
|
|
}
|
|
|
|
CDmeClip::FindClipsWithinTime( clipType, startTime, endTime, flags, clips );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Volume
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeFilmClip::SetVolume( float state )
|
|
{
|
|
m_Volume = state;
|
|
}
|
|
float CDmeFilmClip::GetVolume() const
|
|
{
|
|
return m_Volume.Get();
|
|
}
|
|
|
|
int CDmeFilmClip::GetConCommandCount() const
|
|
{
|
|
return m_ConCommands.Count();
|
|
}
|
|
|
|
const char *CDmeFilmClip::GetConCommand( int i ) const
|
|
{
|
|
return m_ConCommands[ i ];
|
|
}
|
|
|
|
int CDmeFilmClip::GetConVarCount() const
|
|
{
|
|
return m_ConVars.Count();
|
|
}
|
|
|
|
const char *CDmeFilmClip::GetConVar( int i ) const
|
|
{
|
|
return m_ConVars[ i ];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// mapname helper methods
|
|
//-----------------------------------------------------------------------------
|
|
const char *CDmeFilmClip::GetMapName()
|
|
{
|
|
return m_MapName.Get();
|
|
}
|
|
|
|
void CDmeFilmClip::SetMapName( const char *pMapName )
|
|
{
|
|
m_MapName.Set( pMapName );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Attribute changed
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeFilmClip::OnAttributeChanged( CDmAttribute *pAttribute )
|
|
{
|
|
BaseClass::OnAttributeChanged( pAttribute );
|
|
if ( pAttribute == m_FilmTrackGroup.GetAttribute() )
|
|
{
|
|
if ( m_FilmTrackGroup.GetElement() )
|
|
{
|
|
m_FilmTrackGroup->SetMaxTrackCount( 1 );
|
|
}
|
|
}
|
|
else if ( pAttribute->GetOwner() == m_TimeFrame.GetElement() )
|
|
{
|
|
InvokeOnAttributeChangedOnReferrers( GetHandle(), pAttribute );
|
|
}
|
|
else if( pAttribute == m_bIsUsingCachedVersion.GetAttribute() || pAttribute == m_AVIFile.GetAttribute() )
|
|
{
|
|
// video caching info has changed ...
|
|
UpdateRemoteVideoMaterialStatus();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// methods for dealing with remote cached video
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeFilmClip::AssignRemoteVideoMaterial( IRemoteVideoMaterial *theMaterial )
|
|
{
|
|
if ( theMaterial == m_pRemoteVideoMaterial ) return; // no change
|
|
|
|
// ok, release any previous material
|
|
if ( m_pRemoteVideoMaterial != NULL )
|
|
{
|
|
m_pRemoteVideoMaterial->Release();
|
|
}
|
|
|
|
// assign the new material
|
|
m_pRemoteVideoMaterial = theMaterial;
|
|
}
|
|
|
|
|
|
void CDmeFilmClip::UpdateRemoteVideoMaterialStatus()
|
|
{
|
|
// is the quicktime Video caching service available? If not, we don't do anything...
|
|
if ( m_pRemoteVideoMaterial == NULL || !m_pRemoteVideoMaterial->IsInitialized() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// are we selecting to not used cached video?
|
|
if ( m_bIsUsingCachedVersion == false )
|
|
{
|
|
// check to see if we've gone from using cached video for this clip to off
|
|
if ( m_pRemoteVideoMaterial->IsRemoteVideoAvailable() && m_pRemoteVideoMaterial->IsConnectedToRemoteVideo() )
|
|
{
|
|
// turn off video caching for the specified clip
|
|
m_pRemoteVideoMaterial->DisconnectFromRemoteVideo();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// ok, we've selected to use a remotely cached video. If the filename is setup correctly
|
|
// this should attempt to connect to the remote video
|
|
m_pRemoteVideoMaterial->ConnectToRemoteVideo( m_AVIFile.Get() );
|
|
|
|
}
|
|
|
|
bool CDmeFilmClip::HasRemoteVideo()
|
|
{
|
|
// if we don't have a working connection, say we don't have any video
|
|
return ( ( m_pRemoteVideoMaterial == NULL ) ? false : m_pRemoteVideoMaterial->IsRemoteVideoAvailable() );
|
|
}
|
|
|
|
bool CDmeFilmClip::GetCachedQTVideoFrameAt( float theTime )
|
|
{
|
|
if ( m_pRemoteVideoMaterial == NULL ) return false;
|
|
|
|
return m_pRemoteVideoMaterial->GetRemoteVideoFrame( theTime );
|
|
}
|
|
|
|
IMaterial* CDmeFilmClip::GetRemoteVideoMaterial()
|
|
{
|
|
return ( m_pRemoteVideoMaterial == NULL ) ? NULL : m_pRemoteVideoMaterial->GetRemoteVideoFrameMaterial();
|
|
}
|
|
|
|
void CDmeFilmClip::GetRemoteVideoMaterialTexCoordRange( float *u, float *v )
|
|
{
|
|
if ( m_pRemoteVideoMaterial == NULL )
|
|
{
|
|
*u = 0.0f;
|
|
*v = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
m_pRemoteVideoMaterial->GetRemoteVideoFrameTextureCoordRange( *u, *v );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CDmeFilmClip::OnElementUnserialized()
|
|
{
|
|
BaseClass::OnElementUnserialized();
|
|
|
|
CDmeTrackGroup *pFilmTrackGroup = m_FilmTrackGroup.GetElement();
|
|
if ( pFilmTrackGroup )
|
|
{
|
|
pFilmTrackGroup->SetMaxTrackCount( 1 );
|
|
if ( pFilmTrackGroup->GetTrackCount() == 0 )
|
|
{
|
|
pFilmTrackGroup->CreateFilmTrack();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Resolve
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeFilmClip::Resolve()
|
|
{
|
|
BaseClass::Resolve();
|
|
if ( m_AVIFile.IsDirty() )
|
|
{
|
|
m_bReloadCachedVersion = true;
|
|
m_AVIFile.GetAttribute()->RemoveFlag( FATTRIB_DIRTY );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helper for overlays
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeFilmClip::SetOverlay( const char *pMaterialName )
|
|
{
|
|
if ( pMaterialName && pMaterialName[0] )
|
|
{
|
|
if ( !m_MaterialOverlayEffect.GetElement() )
|
|
{
|
|
m_MaterialOverlayEffect = CreateElement<CDmeMaterialOverlayFXClip>( "materialOverlay", GetFileId() );
|
|
}
|
|
|
|
m_MaterialOverlayEffect->SetOverlayEffect( pMaterialName );
|
|
}
|
|
else
|
|
{
|
|
m_MaterialOverlayEffect.Set( NULL );
|
|
}
|
|
}
|
|
|
|
IMaterial *CDmeFilmClip::GetOverlayMaterial()
|
|
{
|
|
return m_MaterialOverlayEffect.GetElement() ? m_MaterialOverlayEffect->GetMaterial() : NULL;
|
|
}
|
|
|
|
float CDmeFilmClip::GetOverlayAlpha()
|
|
{
|
|
return m_MaterialOverlayEffect.GetElement() ? m_MaterialOverlayEffect->GetAlpha() : 0.0f;
|
|
}
|
|
|
|
void CDmeFilmClip::SetOverlayAlpha( float alpha )
|
|
{
|
|
if ( m_MaterialOverlayEffect.GetElement() )
|
|
{
|
|
m_MaterialOverlayEffect->SetAlpha( alpha );
|
|
}
|
|
}
|
|
|
|
bool CDmeFilmClip::HasOpaqueOverlay( void )
|
|
{
|
|
if ( m_MaterialOverlayEffect->GetMaterial()->IsTranslucent() ||
|
|
( m_MaterialOverlayEffect->GetAlpha() < 1.0f ) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CDmeFilmClip::DrawOverlay( DmeTime_t time, Rect_t ¤tRect, Rect_t &totalRect )
|
|
{
|
|
if ( m_MaterialOverlayEffect.GetElement() )
|
|
{
|
|
m_MaterialOverlayEffect->ApplyEffect( ToChildMediaTime( time ), currentRect, totalRect, NULL );
|
|
}
|
|
|
|
float fade = 1.0f;
|
|
if ( time < GetStartTime() + m_fadeInDuration )
|
|
{
|
|
fade = ( time - GetStartTime() ) / m_fadeInDuration;
|
|
}
|
|
if ( time > GetEndTime() - m_fadeOutDuration )
|
|
{
|
|
fade = MIN( fade, ( GetEndTime() - time ) / m_fadeOutDuration );
|
|
}
|
|
if ( fade < 1.0f )
|
|
{
|
|
if ( !m_FadeMaterial.IsValid() )
|
|
{
|
|
m_FadeMaterial.Init( "engine\\singlecolor.vmt", NULL, false );
|
|
}
|
|
|
|
float r, g, b;
|
|
m_FadeMaterial->GetColorModulation( &r, &g, &b );
|
|
float a = m_FadeMaterial->GetAlphaModulation();
|
|
|
|
m_FadeMaterial->ColorModulate( 0.0f, 0.0f, 0.0f );
|
|
m_FadeMaterial->AlphaModulate( 1.0f - fade );
|
|
|
|
CMatRenderContextPtr pRenderContext( materials );
|
|
pRenderContext->Bind( m_FadeMaterial );
|
|
|
|
float w = currentRect.width;
|
|
float h = currentRect.height;
|
|
|
|
IMesh *pMesh = pRenderContext->GetDynamicMesh();
|
|
CMeshBuilder meshBuilder;
|
|
meshBuilder.Begin( pMesh, MATERIAL_TRIANGLE_STRIP, 2 );
|
|
|
|
meshBuilder.Position3f( 0.0f, 0.0f, 0.0f );
|
|
meshBuilder.AdvanceVertexF<VTX_HAVEPOS, 0>();
|
|
|
|
meshBuilder.Position3f( 0.0f, h, 0.0f );
|
|
meshBuilder.AdvanceVertexF<VTX_HAVEPOS, 0>();
|
|
|
|
meshBuilder.Position3f( w, 0.0f, 0.0f );
|
|
meshBuilder.AdvanceVertexF<VTX_HAVEPOS, 0>();
|
|
|
|
meshBuilder.Position3f( w, h, 0.0f );
|
|
meshBuilder.AdvanceVertexF<VTX_HAVEPOS, 0>();
|
|
|
|
meshBuilder.End();
|
|
pMesh->Draw();
|
|
|
|
m_FadeMaterial->ColorModulate( r, g, b );
|
|
m_FadeMaterial->AlphaModulate( a );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// AVI tape out
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeFilmClip::UseCachedVersion( bool bUseCachedVersion )
|
|
{
|
|
m_bIsUsingCachedVersion = bUseCachedVersion;
|
|
}
|
|
|
|
bool CDmeFilmClip::IsUsingCachedVersion() const
|
|
{
|
|
return m_bIsUsingCachedVersion;
|
|
}
|
|
|
|
AVIMaterial_t CDmeFilmClip::GetCachedAVI()
|
|
{
|
|
if ( m_bReloadCachedVersion )
|
|
{
|
|
if ( g_pAVI )
|
|
{
|
|
if ( m_hCachedVersion != AVIMATERIAL_INVALID )
|
|
{
|
|
g_pAVI->DestroyAVIMaterial( m_hCachedVersion );
|
|
m_hCachedVersion = AVIMATERIAL_INVALID;
|
|
}
|
|
if ( m_AVIFile[0] )
|
|
{
|
|
m_hCachedVersion = g_pAVI->CreateAVIMaterial( m_AVIFile, m_AVIFile, "MOD" );
|
|
}
|
|
}
|
|
m_bReloadCachedVersion = false;
|
|
}
|
|
return m_hCachedVersion;
|
|
}
|
|
|
|
void CDmeFilmClip::SetCachedAVI( const char *pAVIFile )
|
|
{
|
|
m_AVIFile = pAVIFile;
|
|
m_bReloadCachedVersion = true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Camera helper methods
|
|
//-----------------------------------------------------------------------------
|
|
CDmeCamera *CDmeFilmClip::GetCamera()
|
|
{
|
|
return m_Camera;
|
|
}
|
|
|
|
void CDmeFilmClip::SetCamera( CDmeCamera *pCamera )
|
|
{
|
|
m_Camera = pCamera;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Returns the monitor camera associated with the clip (for now, only 1 supported)
|
|
//-----------------------------------------------------------------------------
|
|
CDmeCamera *CDmeFilmClip::GetMonitorCamera()
|
|
{
|
|
if ( m_nActiveMonitor < 0 )
|
|
return NULL;
|
|
return m_MonitorCameras[ m_nActiveMonitor ];
|
|
}
|
|
|
|
void CDmeFilmClip::AddMonitorCamera( CDmeCamera *pCamera )
|
|
{
|
|
m_MonitorCameras.AddToTail( pCamera );
|
|
}
|
|
|
|
int CDmeFilmClip::FindMonitorCamera( CDmeCamera *pCamera )
|
|
{
|
|
return m_MonitorCameras.Find( pCamera->GetHandle() );
|
|
}
|
|
|
|
void CDmeFilmClip::RemoveMonitorCamera( CDmeCamera *pCamera )
|
|
{
|
|
int i = m_MonitorCameras.Find( pCamera->GetHandle() );
|
|
if ( i >= 0 )
|
|
{
|
|
if ( m_nActiveMonitor == i )
|
|
{
|
|
m_nActiveMonitor = -1;
|
|
}
|
|
m_MonitorCameras.FastRemove( i );
|
|
}
|
|
}
|
|
|
|
void CDmeFilmClip::SelectMonitorCamera( CDmeCamera *pCamera )
|
|
{
|
|
m_nActiveMonitor = pCamera ? m_MonitorCameras.Find( pCamera->GetHandle() ) : -1;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Scene / Dag helper methods
|
|
//-----------------------------------------------------------------------------
|
|
CDmeDag *CDmeFilmClip::GetScene( bool bCreateIfNull /*= false*/ )
|
|
{
|
|
CDmeDag *pScene = m_Scene.GetElement();
|
|
if ( !pScene && bCreateIfNull )
|
|
{
|
|
pScene = CreateElement< CDmeDag >( "scene", GetFileId() );
|
|
m_Scene = pScene;
|
|
}
|
|
return pScene;
|
|
}
|
|
|
|
void CDmeFilmClip::SetScene( CDmeDag *pDag )
|
|
{
|
|
m_Scene.Set( pDag );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// helper for inputs and operators
|
|
//-----------------------------------------------------------------------------
|
|
int CDmeFilmClip::GetInputCount()
|
|
{
|
|
return m_Inputs.Count();
|
|
}
|
|
|
|
CDmeInput *CDmeFilmClip::GetInput( int nIndex )
|
|
{
|
|
if ( nIndex < 0 || nIndex >= m_Inputs.Count() )
|
|
return NULL;
|
|
|
|
return m_Inputs[ nIndex ];
|
|
}
|
|
|
|
void CDmeFilmClip::AddInput( CDmeInput *pInput )
|
|
{
|
|
m_Inputs.AddToTail( pInput );
|
|
}
|
|
|
|
void CDmeFilmClip::RemoveAllInputs()
|
|
{
|
|
m_Inputs.RemoveAll();
|
|
}
|
|
|
|
void CDmeFilmClip::AddOperator( CDmeOperator *pOperator )
|
|
{
|
|
m_Operators.AddToTail( pOperator );
|
|
}
|
|
|
|
void CDmeFilmClip::RemoveOperator( CDmeOperator *pOperator )
|
|
{
|
|
for ( int i = m_Operators.Count() - 1 ; i >= 0; --i )
|
|
{
|
|
if ( m_Operators[ i ] == pOperator )
|
|
{
|
|
m_Operators.Remove( i );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDmeFilmClip::CollectOperators( CUtlVector< DmElementHandle_t > &operators )
|
|
{
|
|
int numInputs = m_Inputs.Count();
|
|
for ( int i = 0; i < numInputs; ++i )
|
|
{
|
|
operators.AddToTail( m_Inputs[ i ]->GetHandle() );
|
|
}
|
|
|
|
int numOperators = m_Operators.Count();
|
|
for ( int i = 0; i < numOperators; ++i )
|
|
{
|
|
operators.AddToTail( m_Operators[ i ]->GetHandle() );
|
|
}
|
|
}
|
|
|
|
CDmaElementArray< CDmeOperator > &CDmeFilmClip::GetOperators()
|
|
{
|
|
return m_Operators;
|
|
}
|
|
|
|
CDmaElementArray< CDmeAnimationSet > &CDmeFilmClip::GetAnimationSets()
|
|
{
|
|
return m_AnimationSets;
|
|
}
|
|
|
|
const CDmaElementArray< CDmeAnimationSet > &CDmeFilmClip::GetAnimationSets() const
|
|
{
|
|
return m_AnimationSets;
|
|
}
|
|
|
|
CDmeAnimationSet *CDmeFilmClip::FindAnimationSet( const char *pAnimSetName ) const
|
|
{
|
|
int nAnimSets = m_AnimationSets.Count();
|
|
for ( int i = 0; i < nAnimSets; ++i )
|
|
{
|
|
CDmeAnimationSet *pAnimSet = m_AnimationSets[ i ];
|
|
if ( !pAnimSet )
|
|
continue;
|
|
|
|
if ( V_stricmp( pAnimSet->GetName(), pAnimSetName ) == 0 )
|
|
return pAnimSet;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const CDmaElementArray< CDmeBookmarkSet > &CDmeFilmClip::GetBookmarkSets() const
|
|
{
|
|
return m_BookmarkSets;
|
|
}
|
|
|
|
CDmaElementArray< CDmeBookmarkSet > &CDmeFilmClip::GetBookmarkSets()
|
|
{
|
|
return m_BookmarkSets;
|
|
}
|
|
|
|
int CDmeFilmClip::GetActiveBookmarkSetIndex() const
|
|
{
|
|
return m_nActiveBookmarkSet;
|
|
}
|
|
|
|
void CDmeFilmClip::SetActiveBookmarkSetIndex( int nActiveBookmarkSet )
|
|
{
|
|
m_nActiveBookmarkSet = nActiveBookmarkSet;
|
|
}
|
|
|
|
CDmeBookmarkSet *CDmeFilmClip::GetActiveBookmarkSet()
|
|
{
|
|
int nBookmarkSets = m_BookmarkSets.Count();
|
|
if ( m_nActiveBookmarkSet >= nBookmarkSets )
|
|
return NULL;
|
|
|
|
return m_BookmarkSets[ m_nActiveBookmarkSet ];
|
|
}
|
|
|
|
CDmeBookmarkSet *CDmeFilmClip::CreateBookmarkSet( const char *pName /*= "default set"*/ )
|
|
{
|
|
CDmeBookmarkSet *pBookmarkSet = CreateElement< CDmeBookmarkSet >( pName, GetFileId() );
|
|
m_BookmarkSets.AddToTail( pBookmarkSet );
|
|
return pBookmarkSet;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Used to move clips in non-film track groups with film clips
|
|
// Call BuildClipAssociations before modifying the film track,
|
|
// then UpdateAssociatedClips after modifying it.
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeFilmClip::BuildClipAssociations( CUtlVector< ClipAssociation_t > &association, bool bHandleGaps )
|
|
{
|
|
association.RemoveAll();
|
|
|
|
CDmeTrack *pFilmTrack = GetFilmTrack();
|
|
if ( !pFilmTrack )
|
|
return;
|
|
|
|
int c = pFilmTrack->GetClipCount();
|
|
int gc = GetTrackGroupCount();
|
|
if ( c == 0 || gc == 0 )
|
|
return;
|
|
|
|
DmeTime_t clipStartTime = GetStartInChildMediaTime();
|
|
DmeTime_t clipEndTime = GetEndInChildMediaTime();
|
|
|
|
// These slugs will be removed in UpdateAssociatedClips
|
|
if ( bHandleGaps )
|
|
{
|
|
pFilmTrack->FillAllGapsWithSlugs( "__tempSlug__", clipStartTime, clipEndTime );
|
|
}
|
|
|
|
for ( int i = 0; i < gc; ++i )
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = GetTrackGroup( i );
|
|
int tc = pTrackGroup->GetTrackCount();
|
|
for ( int j = 0; j < tc; ++j )
|
|
{
|
|
CDmeTrack *pTrack = pTrackGroup->GetTrack( j );
|
|
if ( !pTrack->IsSynched() )
|
|
continue;
|
|
|
|
// Only have visible tracks now
|
|
int cc = pTrack->GetClipCount();
|
|
association.EnsureCapacity( association.Count() + cc );
|
|
for ( int k = 0; k < cc; ++k )
|
|
{
|
|
CDmeClip *pClip = pTrack->GetClip( k );
|
|
CDmeClip *pFilmClip = pFilmTrack->FindFilmClipAtTime( pClip->GetStartTime() );
|
|
|
|
int nIndex = association.AddToTail();
|
|
association[nIndex].m_hClip = pClip;
|
|
association[nIndex].m_hAssociation = pFilmClip;
|
|
association[nIndex].m_startTimeInAssociatedClip = DMETIME_ZERO;
|
|
association[nIndex].m_offset = DMETIME_ZERO;
|
|
if ( pFilmClip )
|
|
{
|
|
association[nIndex].m_startTimeInAssociatedClip = pFilmClip->ToChildMediaTime( pClip->GetStartTime(), false );
|
|
association[nIndex].m_nType = ClipAssociation_t::HAS_CLIP;
|
|
continue;
|
|
}
|
|
|
|
// Handle edge cases
|
|
if ( pClip->GetStartTime() <= clipStartTime )
|
|
{
|
|
association[nIndex].m_offset = pClip->GetStartTime() - clipStartTime;
|
|
association[nIndex].m_nType = ClipAssociation_t::BEFORE_START;
|
|
continue;
|
|
}
|
|
|
|
if ( pClip->GetStartTime() >= clipEndTime )
|
|
{
|
|
association[nIndex].m_offset = pClip->GetStartTime() - clipEndTime;
|
|
association[nIndex].m_nType = ClipAssociation_t::AFTER_END;
|
|
continue;
|
|
}
|
|
|
|
association[nIndex].m_nType = ClipAssociation_t::NO_MOVEMENT;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CDmeFilmClip::UpdateAssociatedClips( CUtlVector< ClipAssociation_t > &association )
|
|
{
|
|
int i;
|
|
|
|
CDmeTrack *pFilmTrack = GetFilmTrack();
|
|
if ( !pFilmTrack )
|
|
return;
|
|
|
|
int c = association.Count();
|
|
if ( c > 0 )
|
|
{
|
|
DmeTime_t clipStartTime = GetStartInChildMediaTime();
|
|
DmeTime_t clipEndTime = GetEndInChildMediaTime();
|
|
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
ClipAssociation_t &curr = association[i];
|
|
if ( !curr.m_hClip.Get() )
|
|
continue;
|
|
|
|
switch( curr.m_nType )
|
|
{
|
|
case ClipAssociation_t::HAS_CLIP:
|
|
if ( curr.m_hAssociation.Get() )
|
|
{
|
|
curr.m_hClip->SetStartTime( curr.m_hAssociation->FromChildMediaTime( curr.m_startTimeInAssociatedClip, false ) );
|
|
}
|
|
break;
|
|
|
|
case ClipAssociation_t::BEFORE_START:
|
|
curr.m_hClip->SetStartTime( clipStartTime + curr.m_offset );
|
|
break;
|
|
|
|
case ClipAssociation_t::AFTER_END:
|
|
curr.m_hClip->SetStartTime( clipEndTime + curr.m_offset );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
c = pFilmTrack->GetClipCount();
|
|
for ( i = c; --i >= 0; )
|
|
{
|
|
CDmeClip *pClip = pFilmTrack->GetClip(i);
|
|
if ( !Q_strcmp( pClip->GetName(), "__tempSlug__" ) )
|
|
{
|
|
pFilmTrack->RemoveClip( i );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Creates a slug clip
|
|
//-----------------------------------------------------------------------------
|
|
CDmeFilmClip *CreateSlugClip( const char *pClipName, DmeTime_t startTime, DmeTime_t endTime, DmFileId_t fileid )
|
|
{
|
|
CDmeFilmClip *pSlugClip = CreateElement<CDmeFilmClip>( pClipName, fileid );
|
|
pSlugClip->CreateBookmarkSet();
|
|
pSlugClip->GetTimeFrame()->SetName( "timeframe" );
|
|
pSlugClip->SetStartTime( startTime );
|
|
pSlugClip->SetDuration( endTime - startTime );
|
|
pSlugClip->SetTimeOffset( DmeTime_t( 0 ) );
|
|
pSlugClip->SetTimeScale( 1.0f );
|
|
pSlugClip->SetClipColor( Color( 0, 0, 0, 128 ) );
|
|
pSlugClip->SetOverlay( "vgui/black" );
|
|
return pSlugClip;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// helper methods
|
|
//-----------------------------------------------------------------------------
|
|
CDmeTrack *GetParentTrack( CDmeClip *pClip )
|
|
{
|
|
DmAttributeReferenceIterator_t hAttr = g_pDataModel->FirstAttributeReferencingElement( pClip->GetHandle() );
|
|
for ( ; hAttr != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID; hAttr = g_pDataModel->NextAttributeReferencingElement( hAttr ) )
|
|
{
|
|
CDmAttribute *pAttr = g_pDataModel->GetAttribute( hAttr );
|
|
if ( !pAttr )
|
|
continue;
|
|
|
|
CDmeTrack *pTrack = CastElement< CDmeTrack >( pAttr->GetOwner() );
|
|
if ( pTrack )
|
|
return pTrack;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find the channel within targeting the specified element and
|
|
// attribute.
|
|
//-----------------------------------------------------------------------------
|
|
CDmeChannel *FindChannelTargetingElement( CDmElement *pElement, const char *pAttributeName )
|
|
{
|
|
CUtlVector< CDmeChannel* > channels( 0, 8 );
|
|
FindAncestorsReferencingElement( pElement, channels );
|
|
|
|
int nChannels = channels.Count();
|
|
for ( int i = 0; i < nChannels; ++i )
|
|
{
|
|
CDmeChannel *pChannel = channels[ i ];
|
|
if ( !pChannel )
|
|
continue;
|
|
|
|
CDmElement *toElement = pChannel->GetToElement();
|
|
if ( toElement != pElement )
|
|
continue;
|
|
|
|
if ( pAttributeName && ( Q_stricmp( pChannel->GetToAttribute()->GetName(), pAttributeName ) != 0 ) )
|
|
continue;
|
|
|
|
return pChannel;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find the channel within the specified channels clip targeting the
|
|
// specified element and attribute.
|
|
//-----------------------------------------------------------------------------
|
|
CDmeChannel *FindChannelTargetingElement( CDmeChannelsClip *pChannelsClip, CDmElement *pElement, const char *pAttributeName )
|
|
{
|
|
int nChannels = pChannelsClip->m_Channels.Count();
|
|
for ( int i = 0; i < nChannels; ++i )
|
|
{
|
|
CDmeChannel *pChannel = pChannelsClip->m_Channels[ i ];
|
|
if ( !pChannel )
|
|
continue;
|
|
|
|
CDmElement *toElement = pChannel->GetToElement();
|
|
if ( toElement != pElement )
|
|
continue;
|
|
|
|
if ( pAttributeName && ( Q_stricmp( pChannel->GetToAttribute()->GetName(), pAttributeName ) != 0 ) )
|
|
continue;
|
|
|
|
return pChannel;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find the channel within the specified film clip targeting the
|
|
// specified element and attribute.
|
|
//-----------------------------------------------------------------------------
|
|
CDmeChannel *FindChannelTargetingElement( CDmeFilmClip *pClip, CDmElement *pElement, const char *pAttributeName, CDmeChannelsClip **ppChannelsClip, CDmeTrack **ppTrack, CDmeTrackGroup **ppTrackGroup )
|
|
{
|
|
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 )
|
|
|
|
CDmeChannel *pChannel = FindChannelTargetingElement( pChannelsClip, pElement, pAttributeName );
|
|
if ( !pChannel )
|
|
continue;
|
|
|
|
if ( ppChannelsClip )
|
|
{
|
|
*ppChannelsClip = pChannelsClip;
|
|
}
|
|
if ( ppTrack )
|
|
{
|
|
*ppTrack = pTrack;
|
|
}
|
|
if ( ppTrackGroup )
|
|
{
|
|
*ppTrackGroup = pTrackGroup;
|
|
}
|
|
return pChannel;
|
|
|
|
DMETRACKGROUP_FOREACH_CLIP_TYPE_END()
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Construct a clip stack for each one of the channels in the provided
|
|
// list using the specified root movie and shot.
|
|
//-----------------------------------------------------------------------------
|
|
void BuildClipStackList( const CUtlVector< CDmeChannel* > &channelList, CUtlVector< DmeClipStack_t > &clipStackList, CUtlVector< DmeTime_t > &orginalTimeList, const CDmeClip *pMovie, CDmeClip *pShot )
|
|
{
|
|
int nChannels = channelList.Count();
|
|
clipStackList.Purge();
|
|
clipStackList.EnsureCount( nChannels );
|
|
orginalTimeList.Purge();
|
|
orginalTimeList.EnsureCount( nChannels );
|
|
|
|
for ( int iChannel = 0; iChannel < nChannels; ++iChannel )
|
|
{
|
|
CDmeChannel *pChannel = channelList[ iChannel ];
|
|
CDmeChannelsClip *pChannelsClip = FindAncestorReferencingElement< CDmeChannelsClip >( pChannel );
|
|
|
|
if ( pChannelsClip )
|
|
{
|
|
pChannelsClip->BuildClipStack( &clipStackList[ iChannel ], pMovie, pShot );
|
|
}
|
|
else
|
|
{
|
|
if ( pMovie )
|
|
{
|
|
clipStackList[ iChannel ].AddClipToTail( pMovie );
|
|
}
|
|
if ( pShot && ( pShot != pMovie ) )
|
|
{
|
|
clipStackList[ iChannel ].AddClipToTail( pShot );
|
|
}
|
|
}
|
|
|
|
orginalTimeList[ iChannel ] = pChannel->GetCurrentTime();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Play each of the channels in the provided list at the specified
|
|
// global time.
|
|
//-----------------------------------------------------------------------------
|
|
void PlayChannelsAtTime( DmeTime_t time, const CUtlVector< CDmeChannel* > &channelList, const CUtlVector< CDmeOperator* > &operatorList, const CUtlVector< DmeClipStack_t > &clipStackList, bool forcePlay )
|
|
{
|
|
int nCount = channelList.Count();
|
|
for ( int iChannel = 0; iChannel < nCount; ++iChannel )
|
|
{
|
|
CDmeChannel *pChannel = channelList[ iChannel ];
|
|
DmeTime_t localTime = clipStackList[ iChannel ].ToChildMediaTime( time, false );
|
|
pChannel->SetCurrentTime( localTime );
|
|
if ( forcePlay || ( pChannel->GetMode() == CM_RECORD ) )
|
|
{
|
|
pChannel->Play();
|
|
}
|
|
else
|
|
{
|
|
pChannel->Operate();
|
|
}
|
|
}
|
|
|
|
int nOperators = operatorList.Count();
|
|
for ( int iOpeator = 0; iOpeator < nOperators; ++iOpeator )
|
|
{
|
|
operatorList[ iOpeator ]->Operate();
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Play each of the channels in the provided list at the specified
|
|
// local time.
|
|
//-----------------------------------------------------------------------------
|
|
void PlayChannelsAtLocalTimes( const CUtlVector< DmeTime_t > &timeList, const CUtlVector< CDmeChannel* > &channelList, const CUtlVector< CDmeOperator* > &operatorList, bool forcePlay )
|
|
{
|
|
int nCount = channelList.Count();
|
|
|
|
Assert( timeList.Count() >= channelList.Count() );
|
|
if ( timeList.Count() < nCount )
|
|
return;
|
|
|
|
for ( int iChannel = 0; iChannel < nCount; ++iChannel )
|
|
{
|
|
CDmeChannel *pChannel = channelList[ iChannel ];
|
|
pChannel->SetCurrentTime( timeList[ iChannel ] );
|
|
if ( forcePlay || ( pChannel->GetMode() == CM_RECORD ) )
|
|
{
|
|
pChannel->Play();
|
|
}
|
|
else
|
|
{
|
|
pChannel->Operate();
|
|
}
|
|
}
|
|
|
|
int nOperators = operatorList.Count();
|
|
for ( int iOpeator = 0; iOpeator < nOperators; ++iOpeator )
|
|
{
|
|
operatorList[ iOpeator ]->Operate();
|
|
}
|
|
}
|
|
|
|
|
|
CDmeFilmClip *FindFilmClipContainingDag( CDmeDag *pDag )
|
|
{
|
|
CDmeFilmClip *pFilmClip = FindReferringElement< CDmeFilmClip >( pDag, "scene" );
|
|
if ( pFilmClip )
|
|
return pFilmClip;
|
|
|
|
for ( DmAttributeReferenceIterator_t it = g_pDataModel->FirstAttributeReferencingElement( pDag->GetHandle() );
|
|
it != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID;
|
|
it = g_pDataModel->NextAttributeReferencingElement( it ) )
|
|
{
|
|
CDmAttribute *pAttr = g_pDataModel->GetAttribute( it );
|
|
Assert( pAttr );
|
|
|
|
static const CUtlSymbolLarge symChildren = g_pDataModel->GetSymbol( "children" );
|
|
if ( pAttr->GetNameSymbol() != symChildren )
|
|
continue;
|
|
|
|
CDmeDag* pParent = CastElement< CDmeDag >( pAttr->GetOwner() );
|
|
if ( !pParent )
|
|
continue;
|
|
|
|
CDmeFilmClip *pFilmClip = FindFilmClipContainingDag( pParent );
|
|
if ( pFilmClip )
|
|
return pFilmClip;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static ConVar sfm_maxcamerastack( "sfm_maxcamerastack", "10", FCVAR_ARCHIVE, "Number of work cameras to store in camera stack." );
|
|
|
|
void CDmeFilmClip::LatchWorkCamera( CDmeCamera *pCamera )
|
|
{
|
|
// Wipe everything after current stack ptr
|
|
while ( ( m_CameraStack.Count() - 1 ) > m_nCurrentStackCamera )
|
|
{
|
|
m_CameraStack.Remove( m_CameraStack.Count() - 1 );
|
|
}
|
|
|
|
// Add to end
|
|
CDmeCamera *newEntry = CreateElement< CDmeCamera >( "camerastack", GetFileId() );
|
|
newEntry->FromCamera( pCamera );
|
|
|
|
m_CameraStack.AddToTail( newEntry );
|
|
|
|
m_nCurrentStackCamera = m_CameraStack.Count() - 1;
|
|
|
|
int maxStack = clamp( sfm_maxcamerastack.GetInt(), 4, 100 );
|
|
|
|
while ( m_CameraStack.Count() > maxStack )
|
|
{
|
|
m_CameraStack.Remove( 0 );
|
|
--m_nCurrentStackCamera;
|
|
}
|
|
}
|
|
|
|
void CDmeFilmClip::UpdateWorkCamera( CDmeCamera *pCamera )
|
|
{
|
|
m_nCurrentStackCamera = clamp( m_nCurrentStackCamera, 0, m_CameraStack.Count() - 1 );
|
|
if ( m_nCurrentStackCamera < 0 || m_nCurrentStackCamera >= m_CameraStack.Count() )
|
|
return;
|
|
|
|
m_CameraStack[ m_nCurrentStackCamera ]->FromCamera( pCamera );
|
|
}
|
|
|
|
|
|
void CDmeFilmClip::PreviousWorkCamera()
|
|
{
|
|
m_nCurrentStackCamera -= 1;
|
|
}
|
|
|
|
|
|
void CDmeFilmClip::NextWorkCamera()
|
|
{
|
|
m_nCurrentStackCamera += 1;
|
|
}
|
|
|
|
CDmeCamera *CDmeFilmClip::GetCurrentCameraStackEntry()
|
|
{
|
|
m_nCurrentStackCamera = clamp( m_nCurrentStackCamera, 0, m_CameraStack.Count() - 1 );
|
|
if ( m_nCurrentStackCamera < 0 || m_nCurrentStackCamera >= m_CameraStack.Count() )
|
|
return NULL;
|
|
|
|
CDmeCamera *entry = m_CameraStack[ m_nCurrentStackCamera ];
|
|
return entry;
|
|
}
|
|
|
|
void CDmeFilmClip::PurgeCameraStack()
|
|
{
|
|
m_nCurrentStackCamera = -1;
|
|
while ( m_CameraStack.Count() > 0 )
|
|
{
|
|
m_CameraStack.Remove( 0 );
|
|
}
|
|
} |