mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-22 06:06:50 +00:00
336 lines
7.7 KiB
C++
336 lines
7.7 KiB
C++
//========= 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();
|
|
} |