1 files changed, 336 insertions, 0 deletions
diff --git a/movieobjects/dmetimeselection.cpp b/movieobjects/dmetimeselection.cpp
new file mode 100644
index 0000000..c1e4667
--- /dev/null
+++ b/movieobjects/dmetimeselection.cpp
@@ -0,0 +1,336 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+#include "movieobjects/dmetimeselection.h"
+#include "interpolatortypes.h"
+#include "datamodel/dmelementfactoryhelper.h"
+// #include "dme_controls/RecordingState.h"
+						   
+IMPLEMENT_ELEMENT_FACTORY( DmeTimeSelection, CDmeTimeSelection );
+
+void CDmeTimeSelection::OnConstruction()
+{
+	m_bEnabled.InitAndSet( this, "enabled", false );
+	m_bRelative.InitAndSet( this, "relative", false );
+
+	DmeTime_t one( 1.0f );
+
+	m_falloff[ 0 ].InitAndSet( this, "falloff_left", -one.GetTenthsOfMS() );
+	m_falloff[ 1 ].InitAndSet( this, "falloff_right", one.GetTenthsOfMS() );
+
+	m_hold[ 0 ].Init( this, "hold_left" );
+	m_hold[ 1 ].Init( this, "hold_right" );
+
+	m_nFalloffInterpolatorType[ 0 ].InitAndSet( this, "interpolator_left", INTERPOLATE_LINEAR_INTERP );
+	m_nFalloffInterpolatorType[ 1 ].InitAndSet( this, "interpolator_right", INTERPOLATE_LINEAR_INTERP );
+
+	m_threshold.InitAndSet( this, "threshold", 0.0005f );
+
+	m_nRecordingState.InitAndSet( this, "recordingstate", 3 /*AS_PLAYBACK :  HACK THIS SHOULD MOVE TO A PUBLIC HEADER*/ );
+}
+
+
+void CDmeTimeSelection::OnDestruction()
+{
+}
+
+static int g_InterpolatorTypes[] = 
+{
+	INTERPOLATE_LINEAR_INTERP,
+	INTERPOLATE_EASE_IN,
+	INTERPOLATE_EASE_OUT,								
+	INTERPOLATE_EASE_INOUT,		
+};
+
+float CDmeTimeSelection::AdjustFactorForInterpolatorType( float factor, int side )
+{
+	Vector points[ 4 ];
+	points[ 0 ].Init();
+	points[ 1 ].Init( 0.0, 0.0, 0.0f );
+	points[ 2 ].Init( 1.0f, 1.0f, 0.0f );
+	points[ 3 ].Init();
+
+	Vector out;
+	Interpolator_CurveInterpolate
+	( 
+		GetFalloffInterpolatorType( side ), 
+			points[ 0 ], // unused
+			points[ 1 ], 
+			points[ 2 ], 
+			points[ 3 ], // unused
+		factor, 
+		out 
+	);
+	return out.y; // clamp( out.y, 0.0f, 1.0f );
+}
+
+
+//-----------------------------------------------------------------------------
+// per-type averaging methods
+//-----------------------------------------------------------------------------
+float CDmeTimeSelection::GetAmountForTime( DmeTime_t t, DmeTime_t curtime )
+{
+	Assert( IsEnabled() );
+
+	float minfrac = 0.0f;
+
+	// FIXME, this is slow, we should cache this maybe?
+	DmeTime_t times[ 4 ];
+	times[ 0 ] = GetAbsFalloff( curtime, 0 );
+	times[ 1 ] = GetAbsHold( curtime, 0 );
+	times[ 2 ] = GetAbsHold( curtime, 1 );
+	times[ 3 ] = GetAbsFalloff( curtime, 1 );
+
+	Vector points[ 4 ];
+	points[ 0 ].Init();
+	points[ 1 ].Init( 0.0, 0.0, 0.0f );
+	points[ 2 ].Init( 1.0f, 1.0f, 0.0f );
+	points[ 3 ].Init();
+
+	if ( t >= times[ 0 ] && t < times[ 1 ] )
+	{
+		float f = GetFractionOfTimeBetween( t, times[ 0 ], times[ 1 ], true );
+
+		Vector out;
+
+		Interpolator_CurveInterpolate
+		( 
+			GetFalloffInterpolatorType( 0 ), 
+				points[ 0 ], // unused
+				points[ 1 ], 
+				points[ 2 ], 
+				points[ 3 ], // unused
+			f, 
+			out 
+		);
+		return clamp( out.y, minfrac, 1.0f );
+	}
+	
+	if ( t >= times[ 1 ] && t <= times[ 2 ] )
+	{
+		return 1.0f;
+	}
+
+	if ( t > times[ 2 ] && t <= times[ 3 ] )
+	{
+		float f = 1.0f - GetFractionOfTimeBetween( t, times[ 2 ], times[ 3 ], true );
+
+		Vector out;
+
+		Interpolator_CurveInterpolate
+		( 
+			GetFalloffInterpolatorType( 1 ), 
+				points[ 0 ], // unused
+				points[ 1 ], 
+				points[ 2 ], 
+				points[ 3 ], // unused
+			f, 
+			out 
+		);
+		return clamp( out.y, minfrac, 1.0f );
+	}
+	return minfrac;
+}
+
+void CDmeTimeSelection::GetAlphaForTime( DmeTime_t t, DmeTime_t curtime, byte& alpha )
+{
+	Assert( IsEnabled() );
+
+	byte minAlpha = 31;
+
+	// FIXME, this is slow, we should cache this maybe?
+	DmeTime_t times[ 4 ];
+	times[ 0 ] = GetAbsFalloff( curtime, 0 );
+	times[ 1 ] = GetAbsHold( curtime, 0 );
+	times[ 2 ] = GetAbsHold( curtime, 1 );
+	times[ 3 ] = GetAbsFalloff( curtime, 1 );
+
+	DmeTime_t dt1, dt2;
+	dt1 = times[ 1 ] - times[ 0 ];
+	dt2 = times[ 3 ] - times[ 2 ];
+
+	if ( dt1 > DmeTime_t( 0 ) &&
+		t >= times[ 0 ] && t < times[ 1 ] )
+	{
+		float frac = GetFractionOfTime( t - times[ 0 ], dt1, false );
+		alpha = clamp( alpha * frac, minAlpha, 255 );
+		return;
+	}
+	if ( dt2 > DmeTime_t( 0 ) &&
+		t > times[ 2 ] && t <= times[ 3 ] )
+	{
+		float frac = GetFractionOfTime( times[ 3 ] - t, dt2, false );
+		alpha = clamp( alpha * frac, minAlpha, 255 );
+		return;
+	}
+	if ( t < times[ 0 ] )
+		alpha = minAlpha;
+	else if ( t > times[ 3 ] )
+		alpha = minAlpha;
+}
+
+int CDmeTimeSelection::GetFalloffInterpolatorType( int side )
+{
+	return m_nFalloffInterpolatorType[ side ];
+}
+
+void CDmeTimeSelection::SetFalloffInterpolatorType( int side, int interpolatorType )
+{
+	m_nFalloffInterpolatorType[ side ] = interpolatorType;
+}
+
+bool CDmeTimeSelection::IsEnabled() const
+{
+	return m_bEnabled;
+}
+
+void CDmeTimeSelection::SetEnabled( bool state )
+{
+	m_bEnabled = state;
+}
+
+bool CDmeTimeSelection::IsRelative() const
+{
+	return m_bRelative;
+}
+
+void CDmeTimeSelection::SetRelative( DmeTime_t time, bool state )
+{
+	bool changed = m_bRelative != state;
+	m_bRelative = state;
+	if ( changed )
+	{
+		if ( state )
+			ConvertToRelative( time );
+		else 
+			ConvertToAbsolute( time );
+	}
+}
+
+DmeTime_t CDmeTimeSelection::GetAbsFalloff( DmeTime_t time, int side )
+{
+	if ( m_bRelative )
+	{
+		return DmeTime_t( m_falloff[ side ] ) + time;
+	}
+	return DmeTime_t( m_falloff[ side ] );
+}
+
+DmeTime_t CDmeTimeSelection::GetAbsHold( DmeTime_t time, int side )
+{
+	if ( m_bRelative )
+	{
+		return DmeTime_t( m_hold[ side ] ) + time;
+	}
+	return DmeTime_t( m_hold[ side ] );
+}
+
+DmeTime_t CDmeTimeSelection::GetRelativeFalloff( DmeTime_t time, int side )
+{
+	if ( m_bRelative )
+	{
+		return DmeTime_t( m_falloff[ side ] );
+	}
+	return DmeTime_t( m_falloff[ side ] ) - time;
+}
+
+DmeTime_t CDmeTimeSelection::GetRelativeHold( DmeTime_t time, int side )
+{
+	if ( m_bRelative )
+	{
+		return DmeTime_t( m_hold[ side ] );
+	}
+	return DmeTime_t( m_hold[ side ] ) - time;
+}
+
+void CDmeTimeSelection::ConvertToRelative( DmeTime_t time )
+{
+	m_falloff[ 0 ] -= time.GetTenthsOfMS();
+	m_falloff[ 1 ] -= time.GetTenthsOfMS();
+	m_hold[ 0 ] -= time.GetTenthsOfMS();
+	m_hold[ 1 ] -= time.GetTenthsOfMS();
+}
+
+void CDmeTimeSelection::ConvertToAbsolute( DmeTime_t time )
+{
+	m_falloff[ 0 ] += time.GetTenthsOfMS();
+	m_falloff[ 1 ] += time.GetTenthsOfMS();
+	m_hold[ 0 ] += time.GetTenthsOfMS();
+	m_hold[ 1 ] += time.GetTenthsOfMS();
+}
+
+void CDmeTimeSelection::SetAbsFalloff( DmeTime_t time, int side, DmeTime_t absfallofftime )
+{
+	DmeTime_t newTime;
+	if ( m_bRelative )
+	{
+		newTime = absfallofftime - time;
+	}
+	else
+	{
+		newTime = absfallofftime;
+	}
+
+	m_falloff[ side ] = newTime.GetTenthsOfMS();
+}
+
+void CDmeTimeSelection::SetAbsHold( DmeTime_t time, int side, DmeTime_t absholdtime )
+{
+	DmeTime_t newTime;
+	if ( m_bRelative )
+	{
+		newTime = absholdtime - time;
+	}
+	else
+	{
+		newTime = absholdtime;
+	}
+
+	m_hold[ side ] = newTime.GetTenthsOfMS();
+}
+
+void CDmeTimeSelection::CopyFrom( const CDmeTimeSelection& src )
+{
+	m_bEnabled = src.m_bEnabled;
+	m_bRelative = src.m_bRelative;
+	m_threshold = src.m_threshold;
+
+	for ( int i = 0 ; i < 2; ++i )
+	{
+		m_falloff[ i ] = src.m_falloff[ i ];
+		m_hold[ i ] = src.m_hold[ i ];
+		m_nFalloffInterpolatorType[ i ] = src.m_nFalloffInterpolatorType[ i ];
+	}
+
+	m_nRecordingState = src.m_nRecordingState;
+}
+
+void CDmeTimeSelection::GetCurrent( DmeTime_t pTimes[TS_TIME_COUNT] )
+{
+	pTimes[TS_LEFT_FALLOFF].SetTenthsOfMS( m_falloff[ 0 ] );
+	pTimes[TS_LEFT_HOLD].SetTenthsOfMS( m_hold[ 0 ] );
+	pTimes[TS_RIGHT_HOLD].SetTenthsOfMS( m_hold[ 1 ] );
+	pTimes[TS_RIGHT_FALLOFF].SetTenthsOfMS( m_falloff[ 1 ] );
+}
+
+void CDmeTimeSelection::SetCurrent( DmeTime_t* pTimes )
+{
+	m_falloff[ 0 ] = pTimes[ TS_LEFT_FALLOFF ].GetTenthsOfMS();
+	m_hold[ 0 ] = pTimes[ TS_LEFT_HOLD ].GetTenthsOfMS();
+	m_hold[ 1 ] = pTimes[ TS_RIGHT_HOLD ].GetTenthsOfMS();
+	m_falloff[ 1 ] = pTimes[ TS_RIGHT_FALLOFF ].GetTenthsOfMS();
+}
+
+float CDmeTimeSelection::GetThreshold()
+{
+	return m_threshold;
+}
+
+
+void CDmeTimeSelection::SetRecordingState( RecordingState_t state )
+{
+	m_nRecordingState = ( int )state;
+}
+
+RecordingState_t CDmeTimeSelection::GetRecordingState() const
+{
+	return ( RecordingState_t )m_nRecordingState.Get();
+}
+\ No newline at end of file