1726 lines
46 KiB
C++
1726 lines
46 KiB
C++
//========= Copyright 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/dmelight.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 | FATTRIB_HAS_ARRAY_CALLBACK );
|
|
}
|
|
|
|
void CDmeClip::OnDestruction()
|
|
{
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Inherited from IDmElement
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeClip::OnAttributeArrayElementAdded( CDmAttribute *pAttribute, int nFirstElem, int nLastElem )
|
|
{
|
|
BaseClass::OnAttributeArrayElementAdded( pAttribute, nFirstElem, nLastElem );
|
|
if ( pAttribute == m_TrackGroups.GetAttribute() )
|
|
{
|
|
for ( int i = nFirstElem; i <= nLastElem; ++i )
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = m_TrackGroups[ i ];
|
|
if ( pTrackGroup )
|
|
{
|
|
pTrackGroup->SetOwnerClip( this );
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CDmeClip::OnAttributeArrayElementRemoved( CDmAttribute *pAttribute, int nFirstElem, int nLastElem )
|
|
{
|
|
BaseClass::OnAttributeArrayElementRemoved( pAttribute, nFirstElem, nLastElem );
|
|
if ( pAttribute == m_TrackGroups.GetAttribute() )
|
|
{
|
|
for ( int i = nFirstElem; i <= nLastElem; ++i )
|
|
{
|
|
CDmeTrackGroup *pTrackGroup = m_TrackGroups[ i ];
|
|
if ( pTrackGroup )
|
|
{
|
|
pTrackGroup->SetOwnerClip( NULL );
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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::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( 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;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Clip stack
|
|
//-----------------------------------------------------------------------------
|
|
static bool BuildClipStack_R( DmeClipStack_t* pStack, CDmeClip *pMovie, CDmeClip *pShot, CDmeClip *pCurrent )
|
|
{
|
|
// Add this clip to the stack
|
|
int nIndex = pStack->AddToHead( CDmeHandle< CDmeClip >( 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( pStack, pMovie, pShot, ppParents[i] ) )
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// This clip didn't work out for us. Remove it.
|
|
pStack->Remove( nIndex );
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CDmeClip::BuildClipStack( DmeClipStack_t* pStack, CDmeClip *pMovie, CDmeClip *pShot )
|
|
{
|
|
// Walk through each shot in the movie and look for the subClip, if don't find it recurse into each shot
|
|
return BuildClipStack_R( pStack, pMovie, pShot, this );
|
|
}
|
|
|
|
DmeTime_t CDmeClip::ToChildMediaTime( const DmeClipStack_t& stack, DmeTime_t globalTime, bool bClamp /* = true */ )
|
|
{
|
|
DmeTime_t time = globalTime;
|
|
|
|
int nClips = stack.Count();
|
|
for ( int i = 0; i < nClips; ++i )
|
|
{
|
|
time = stack[ i ]->ToChildMediaTime( time, bClamp );
|
|
}
|
|
|
|
return time;
|
|
}
|
|
|
|
DmeTime_t CDmeClip::FromChildMediaTime( const DmeClipStack_t& stack, DmeTime_t localTime, bool bClamp /* = true */ )
|
|
{
|
|
DmeTime_t time = localTime;
|
|
|
|
int nClips = stack.Count();
|
|
for ( int i = nClips-1; i >= 0; --i )
|
|
{
|
|
time = stack[ i ]->FromChildMediaTime( time, bClamp );
|
|
}
|
|
|
|
return time;
|
|
}
|
|
|
|
DmeTime_t CDmeClip::ToChildMediaDuration( const DmeClipStack_t& stack, DmeTime_t globalDuration )
|
|
{
|
|
DmeTime_t duration = globalDuration;
|
|
|
|
int nClips = stack.Count();
|
|
for ( int i = 0; i < nClips; ++i )
|
|
{
|
|
duration = stack[ i ]->ToChildMediaDuration( duration );
|
|
}
|
|
|
|
return duration;
|
|
}
|
|
|
|
DmeTime_t CDmeClip::FromChildMediaDuration( const DmeClipStack_t& stack, DmeTime_t localDuration )
|
|
{
|
|
DmeTime_t duration = localDuration;
|
|
|
|
int nClips = stack.Count();
|
|
for ( int i = nClips-1; i >= 0; --i )
|
|
{
|
|
duration = stack[ i ]->FromChildMediaDuration( duration );
|
|
}
|
|
|
|
return duration;
|
|
}
|
|
|
|
|
|
void CDmeClip::ToChildMediaTime( DmeLog_TimeSelection_t ¶ms, const DmeClipStack_t& stack )
|
|
{
|
|
for ( int i = 0; i < TS_TIME_COUNT; ++i )
|
|
{
|
|
params.m_nTimes[i] = ToChildMediaTime( stack, params.m_nTimes[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 );
|
|
}
|
|
|
|
void CDmeSoundClip::OnDestruction()
|
|
{
|
|
}
|
|
|
|
void CDmeSoundClip::SetShowWave( bool state )
|
|
{
|
|
m_bShowWave = state;
|
|
}
|
|
|
|
bool CDmeSoundClip::ShouldShowWave( ) const
|
|
{
|
|
return m_bShowWave;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CDmeChannelsClip - timeframe view into a set of channels
|
|
//-----------------------------------------------------------------------------
|
|
IMPLEMENT_ELEMENT_FACTORY( DmeChannelsClip, CDmeChannelsClip );
|
|
|
|
void CDmeChannelsClip::OnConstruction()
|
|
{
|
|
m_Channels.Init( this, "channels" );
|
|
}
|
|
|
|
void CDmeChannelsClip::OnDestruction()
|
|
{
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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_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_Lights.Init( this, "lights" );
|
|
m_Scene.Init( this, "scene" );
|
|
m_AVIFile.Init( this, "aviFile" );
|
|
m_fadeInDuration .InitAndSet( this, "fadeIn", 0 );
|
|
m_fadeOutDuration.InitAndSet( this, "fadeOut", 0 );
|
|
|
|
m_Inputs.Init( this, "inputs" );
|
|
m_Operators.Init( this, "operators" );
|
|
m_bIsUsingCachedVersion.Init( this, "useAviFile" );
|
|
m_AnimationSets.Init( this, "animationSets" );
|
|
m_Bookmarks.Init( this, "bookmarks" );
|
|
m_FilmTrackGroup.Init( this, "subClipTrackGroup", FATTRIB_HAS_CALLBACK | FATTRIB_HAS_PRE_CALLBACK );
|
|
m_Volume.InitAndSet( this, "volume", 1.0);
|
|
|
|
m_pCachedVersion = NULL;
|
|
m_bIsUsingCachedVersion = false;
|
|
m_bReloadCachedVersion = false;
|
|
}
|
|
|
|
void CDmeFilmClip::OnDestruction()
|
|
{
|
|
if ( g_pVideo != NULL && m_pCachedVersion != NULL )
|
|
{
|
|
g_pVideo->DestroyVideoMaterial( m_pCachedVersion );
|
|
m_pCachedVersion = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 );
|
|
m_FilmTrackGroup->SetOwnerClip( this );
|
|
}
|
|
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::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();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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::PreAttributeChanged( CDmAttribute *pAttribute )
|
|
{
|
|
BaseClass::PreAttributeChanged( pAttribute );
|
|
if ( pAttribute == m_FilmTrackGroup.GetAttribute() )
|
|
{
|
|
if ( m_FilmTrackGroup.GetElement() )
|
|
{
|
|
m_FilmTrackGroup->SetOwnerClip( NULL );
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CDmeFilmClip::OnAttributeChanged( CDmAttribute *pAttribute )
|
|
{
|
|
BaseClass::OnAttributeChanged( pAttribute );
|
|
if ( pAttribute == m_FilmTrackGroup.GetAttribute() )
|
|
{
|
|
if ( m_FilmTrackGroup.GetElement() )
|
|
{
|
|
m_FilmTrackGroup->SetMaxTrackCount( 1 );
|
|
m_FilmTrackGroup->SetOwnerClip( this );
|
|
}
|
|
}
|
|
else if ( pAttribute->GetOwner() == m_TimeFrame.GetElement() )
|
|
{
|
|
InvokeOnAttributeChangedOnReferrers( GetHandle(), pAttribute );
|
|
}
|
|
}
|
|
|
|
void CDmeFilmClip::OnElementUnserialized( )
|
|
{
|
|
BaseClass::OnElementUnserialized();
|
|
|
|
CDmeTrackGroup *pFilmTrackGroup = m_FilmTrackGroup.GetElement();
|
|
if ( pFilmTrackGroup )
|
|
{
|
|
pFilmTrackGroup->SetMaxTrackCount( 1 );
|
|
if ( pFilmTrackGroup->GetTrackCount() == 0 )
|
|
{
|
|
pFilmTrackGroup->CreateFilmTrack();
|
|
}
|
|
}
|
|
|
|
// this conversion code went in on 10/31/2005
|
|
// I'm hoping we don't care about any files that old - if we ever hit this, we should move this code into an unserialization converter
|
|
Assert( !HasAttribute( "overlay" ) && !HasAttribute( "overlayalpha" ) );
|
|
if ( HasAttribute( "overlay" ) || HasAttribute( "overlayalpha" ) )
|
|
{
|
|
Warning( "CDmeFilmClip %s is an old version that has overlay and/or overlayalpha attributes!\n", GetName() );
|
|
|
|
// Backward compat conversion
|
|
// If this is an older file with an overlay attribute, strip it out into materialoverlay
|
|
CDmAttribute *pOverlayAttribute = GetAttribute( "overlay" );
|
|
if ( !pOverlayAttribute )
|
|
goto cleanUp;
|
|
|
|
const char *pName = pOverlayAttribute->GetValueString();
|
|
if ( !pName || !pName[0] )
|
|
goto cleanUp;
|
|
|
|
// If we don't yet have a material overlay, create one
|
|
if ( m_MaterialOverlayEffect.GetElement() == NULL )
|
|
{
|
|
m_MaterialOverlayEffect = CreateElement<CDmeMaterialOverlayFXClip>( "materialOverlay", GetFileId() );
|
|
}
|
|
|
|
m_MaterialOverlayEffect->SetOverlayEffect( pName );
|
|
|
|
// If this is an older file with an overlayalpha attribute, strip it out into materialoverlay
|
|
CDmAttribute *pOverlayAlphaAttribute = GetAttribute( "overlayalpha" );
|
|
if ( pOverlayAlphaAttribute )
|
|
{
|
|
float alpha = pOverlayAlphaAttribute->GetValue<float>();
|
|
m_MaterialOverlayEffect->SetAlpha( alpha );
|
|
}
|
|
|
|
cleanUp:
|
|
// Always strip out the old overlay attribute
|
|
RemoveAttribute( "overlay" );
|
|
RemoveAttribute( "overlayalpha" );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 );
|
|
}
|
|
|
|
DmeTime_t fadeIn( m_fadeInDuration );
|
|
DmeTime_t fadeOut( m_fadeOutDuration );
|
|
|
|
float fade = 1.0f;
|
|
if ( time < GetStartTime() + fadeIn )
|
|
{
|
|
fade = ( time - GetStartTime() ) / fadeIn;
|
|
}
|
|
if ( time > GetEndTime() - fadeOut )
|
|
{
|
|
fade = min( fade, ( GetEndTime() - time ) / fadeOut );
|
|
}
|
|
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.AdvanceVertex();
|
|
|
|
meshBuilder.Position3f( 0.0f, h, 0.0f );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3f( w, 0.0f, 0.0f );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
meshBuilder.Position3f( w, h, 0.0f );
|
|
meshBuilder.AdvanceVertex();
|
|
|
|
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;
|
|
}
|
|
|
|
IVideoMaterial *CDmeFilmClip::GetCachedVideoMaterial()
|
|
{
|
|
if ( m_bReloadCachedVersion )
|
|
{
|
|
if ( g_pVideo )
|
|
{
|
|
if ( m_pCachedVersion != NULL )
|
|
{
|
|
g_pVideo->DestroyVideoMaterial( m_pCachedVersion );
|
|
m_pCachedVersion = NULL;
|
|
}
|
|
if ( m_AVIFile[0] )
|
|
{
|
|
m_pCachedVersion = g_pVideo->CreateVideoMaterial( m_AVIFile, m_AVIFile, "MOD" );
|
|
}
|
|
|
|
}
|
|
m_bReloadCachedVersion = false;
|
|
}
|
|
return m_pCachedVersion;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Light helper methods
|
|
//-----------------------------------------------------------------------------
|
|
int CDmeFilmClip::GetLightCount()
|
|
{
|
|
return m_Lights.Count();
|
|
}
|
|
|
|
CDmeLight *CDmeFilmClip::GetLight( int nIndex )
|
|
{
|
|
if ( ( nIndex < 0 ) || ( nIndex >= m_Lights.Count() ) )
|
|
return NULL;
|
|
|
|
return m_Lights[ nIndex ];
|
|
}
|
|
|
|
void CDmeFilmClip::AddLight( CDmeLight *pLight )
|
|
{
|
|
m_Lights.AddToTail( pLight );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Scene / Dag helper methods
|
|
//-----------------------------------------------------------------------------
|
|
CDmeDag *CDmeFilmClip::GetScene()
|
|
{
|
|
return m_Scene.GetElement();
|
|
}
|
|
|
|
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::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() );
|
|
}
|
|
}
|
|
|
|
int CDmeFilmClip::GetAnimationSetCount()
|
|
{
|
|
// yes, this is nasty perf-wise, but since we only have a dozen or so animation sets,
|
|
// and we're about to rewrite the entire structure of animation sets vs. clips vs. scene
|
|
// it's not worth polluting the leaf code just to save a couple cycles short term
|
|
|
|
int nCount = 0;
|
|
|
|
int nElements = m_AnimationSets.Count();
|
|
for ( int i = 0; i < nElements; ++i )
|
|
{
|
|
CDmElement *pElement = m_AnimationSets.Get( i );
|
|
if ( !pElement )
|
|
continue;
|
|
|
|
CDmeAnimationSet *pAnimSet = CastElement< CDmeAnimationSet >( pElement );
|
|
if ( pAnimSet )
|
|
{
|
|
++nCount;
|
|
}
|
|
else
|
|
{
|
|
const CDmAttribute *pChildren = pElement->GetAttribute( "children", AT_ELEMENT_ARRAY );
|
|
if ( !pChildren )
|
|
continue;
|
|
|
|
CDmrElementArrayConst< CDmElement > array( pChildren );
|
|
nCount += array.Count();
|
|
}
|
|
}
|
|
|
|
return nCount;
|
|
}
|
|
|
|
CDmeAnimationSet *CDmeFilmClip::GetAnimationSet( int idx )
|
|
{
|
|
// yes, this is nasty perf-wise, but since we only have a dozen or so animation sets,
|
|
// and we're about to rewrite the entire structure of animation sets vs. clips vs. scene
|
|
// it's not worth polluting the leaf code just to save a couple cycles short term
|
|
|
|
int nElements = m_AnimationSets.Count();
|
|
for ( int i = 0; i < nElements; ++i )
|
|
{
|
|
CDmElement *pElement = m_AnimationSets.Get( i );
|
|
if ( !pElement )
|
|
continue;
|
|
|
|
CDmeAnimationSet *pAnimSet = CastElement< CDmeAnimationSet >( pElement );
|
|
if ( pAnimSet )
|
|
{
|
|
if ( idx == 0 )
|
|
return pAnimSet;
|
|
--idx;
|
|
}
|
|
else
|
|
{
|
|
const CDmAttribute *pChildren = pElement->GetAttribute( "children", AT_ELEMENT_ARRAY );
|
|
if ( !pChildren )
|
|
continue;
|
|
|
|
CDmrElementArrayConst< CDmElement > array( pChildren );
|
|
int nChildren = array.Count();
|
|
|
|
if ( idx < nChildren )
|
|
return CastElement< CDmeAnimationSet >( array[ idx ] );
|
|
idx -= nChildren;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void CDmeFilmClip::AddAnimationSet( CDmeAnimationSet *element )
|
|
{
|
|
m_AnimationSets.AddToTail( element );
|
|
}
|
|
|
|
void CDmeFilmClip::RemoveAllAnimationSets()
|
|
{
|
|
m_AnimationSets.RemoveAll();
|
|
}
|
|
|
|
CDmaElementArray< CDmElement > &CDmeFilmClip::GetAnimationSets()
|
|
{
|
|
return m_AnimationSets;
|
|
}
|
|
|
|
const CDmaElementArray< CDmElement > &CDmeFilmClip::GetAnimationSets() const
|
|
{
|
|
return m_AnimationSets;
|
|
}
|
|
|
|
|
|
const CDmaElementArray< CDmeBookmark > &CDmeFilmClip::GetBookmarks() const
|
|
{
|
|
return m_Bookmarks;
|
|
}
|
|
|
|
CDmaElementArray< CDmeBookmark > &CDmeFilmClip::GetBookmarks()
|
|
{
|
|
return m_Bookmarks;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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;
|
|
if ( pFilmClip )
|
|
{
|
|
association[nIndex].m_offset = pClip->GetStartTime() - pFilmClip->GetStartTime();
|
|
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_offset = DmeTime_t( 0 );
|
|
association[nIndex].m_nType = ClipAssociation_t::NO_MOVEMENT;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Rolls associated clips so they remain in the same relative time
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeFilmClip::RollAssociatedClips( CDmeClip *pClip, CUtlVector< ClipAssociation_t > &association, DmeTime_t dt )
|
|
{
|
|
int c = association.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
if ( association[i].m_nType != ClipAssociation_t::HAS_CLIP )
|
|
continue;
|
|
|
|
if ( association[i].m_hAssociation.Get() != pClip )
|
|
continue;
|
|
|
|
DmeTime_t newStartTime = association[i].m_hClip->GetStartTime() - dt;
|
|
association[i].m_hClip->SetStartTime( newStartTime );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Rolls associated clips so they remain in the same relative time
|
|
//-----------------------------------------------------------------------------
|
|
void CDmeFilmClip::ScaleAssociatedClips( CDmeClip *pClip, CUtlVector< ClipAssociation_t > &association, float ratio, DmeTime_t oldOffset )
|
|
{
|
|
int c = association.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
if ( association[i].m_nType != ClipAssociation_t::HAS_CLIP )
|
|
continue;
|
|
|
|
if ( association[i].m_hAssociation.Get() != pClip )
|
|
continue;
|
|
|
|
DmeTime_t clipStartTime = pClip->GetStartTime();
|
|
DmeTime_t oldStartTime = association[i].m_hClip->GetStartTime();
|
|
DmeTime_t newStartTime = ( oldStartTime - clipStartTime + oldOffset ) / ratio + clipStartTime - pClip->GetTimeOffset();
|
|
association[i].m_hClip->SetStartTime( newStartTime );
|
|
}
|
|
}
|
|
|
|
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->GetStartTime() + curr.m_offset );
|
|
}
|
|
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->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;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Finds a channel in a channel or film clip targetting a particular element
|
|
//-----------------------------------------------------------------------------
|
|
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 ];
|
|
CDmElement *toElement = pChannel->GetToElement();
|
|
if ( toElement != pElement )
|
|
continue;
|
|
|
|
if ( pAttributeName && ( Q_stricmp( pChannel->GetToAttribute()->GetName(), pAttributeName ) != 0 ) )
|
|
continue;
|
|
|
|
return pChannel;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
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;
|
|
}
|