142 lines
3.2 KiB
C++
142 lines
3.2 KiB
C++
#include "externals.hh"
|
|
#include "sync.hh"
|
|
|
|
|
|
const T_SyncVariable T_SyncData::MissingVariable_{ };
|
|
|
|
T_SyncData::T_SyncData( )
|
|
: T_SyncData( 60 * 60 , 1. / 60 )
|
|
{ }
|
|
|
|
T_SyncData::T_SyncData(
|
|
__rd__ const uint32_t duration ,
|
|
__rd__ const float units ) noexcept
|
|
: duration_( duration ) , units_( units )
|
|
{ }
|
|
|
|
|
|
T_SyncData::T_VarHelper_::T_VarHelper_(
|
|
__rw__ T_SyncVariable&& v ,
|
|
__rd__ const uint32_t duration ,
|
|
__rd__ const uint32_t position ) noexcept
|
|
: variable( std::move( v ) ) , position( position )
|
|
{
|
|
const auto n( variable.size( ) );
|
|
uint32_t s = 0;
|
|
for ( auto i = 0u ; i < n ; i ++ ) {
|
|
auto const& v( variable[ i ] );
|
|
assert( v.nPoints >= 2 );
|
|
assert( v.durations.size( ) == v.nPoints - 1 );
|
|
|
|
const auto nd( v.nPoints - 1 );
|
|
for ( auto j = 0u ; j < nd ; j ++ ) {
|
|
segStarts.push_back( s );
|
|
segRefs.push_back( std::make_pair( i , j ) );
|
|
s += v.durations[ j ];
|
|
if ( s > duration ) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
float T_SyncData::T_VarHelper_::valueAt(
|
|
__rd__ const float position ,
|
|
__rd__ const float units ) const noexcept
|
|
{
|
|
// Find segment
|
|
const auto tu( uint32_t( floor( position / units ) ) );
|
|
uint32_t s( 0 );
|
|
for ( auto ss : segStarts ) {
|
|
if ( ss > tu ) {
|
|
break;
|
|
}
|
|
s ++;
|
|
}
|
|
assert( s > 0 );
|
|
s --;
|
|
const auto sid( segRefs[ s ].first );
|
|
auto const& seg( variable[ sid ] );
|
|
const auto pid( segRefs[ s ].second );
|
|
|
|
// Interpolation factor
|
|
const float st( segStarts[ s ] * units );
|
|
const float et( ( segStarts[ s ] + seg.durations[ pid ] ) * units );
|
|
const float v0 = ( position - st ) / ( et - st );
|
|
float v = v0;
|
|
if ( seg.type != T_SyncSegment::LINEAR ) {
|
|
v *= v0;
|
|
if ( seg.type == T_SyncSegment::SMOOTH ) {
|
|
v *= 3 - 2 * v0;
|
|
}
|
|
}
|
|
|
|
const float sv( seg.values[ pid ] );
|
|
const float ev( seg.values[ pid + 1 ] );
|
|
return v * ( ev - sv ) + sv;
|
|
}
|
|
|
|
|
|
void T_SyncData::setSyncVariable(
|
|
__rd__ std::string const& name ,
|
|
__rw__ T_SyncVariable&& variable ) noexcept
|
|
{
|
|
variables_.erase( name );
|
|
if ( !variable.empty( ) ) {
|
|
variables_.emplace( name , T_VarHelper_{
|
|
std::move( variable ) , duration_ ,
|
|
uint32_t( variables_.size( ) )
|
|
} );
|
|
}
|
|
}
|
|
|
|
|
|
T_SyncVariable const& T_SyncData::variable(
|
|
__rd__ std::string const& name ) const noexcept
|
|
{
|
|
auto pos( variables_.find( name ) );
|
|
if ( pos == variables_.end( ) ) {
|
|
return MissingVariable_;
|
|
}
|
|
return pos->second.variable;
|
|
}
|
|
|
|
uint32_t T_SyncData::offsetOf(
|
|
__rd__ std::string const& name ) const noexcept
|
|
{
|
|
auto pos( variables_.find( name ) );
|
|
if ( pos == variables_.end( ) ) {
|
|
return 0xffffffff;
|
|
}
|
|
return pos->second.position;
|
|
}
|
|
|
|
|
|
float T_SyncData::valueOf(
|
|
__rd__ std::string const& name ,
|
|
__rd__ const float time ) const noexcept
|
|
{
|
|
assert( time >= 0 );
|
|
|
|
auto pos( variables_.find( name ) );
|
|
if ( pos == variables_.end( ) ) {
|
|
return 0;
|
|
}
|
|
return pos->second.valueAt( std::min( duration_ * units_ , time ) , units_ );
|
|
}
|
|
|
|
|
|
void T_SyncData::computeValues(
|
|
__rd__ const float time ,
|
|
__wr__ std::vector< float >& values ) const noexcept
|
|
{
|
|
assert( time >= 0 );
|
|
values.resize( variables_.size( ) );
|
|
auto vit( values.begin( ) );
|
|
const float t( std::min( duration_ * units_ , time ) );
|
|
for ( auto const& var : variables_ ) {
|
|
*vit = var.second.valueAt( t , units_ );
|
|
vit ++;
|
|
}
|
|
}
|