Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

336 lines
7.7 KiB

5 years ago
//========= 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();
}