AnimationTime.hpp

#pragma once
 
#include <Core/RaCore.hpp>
#include <algorithm>
#include <limits>
 
namespace Ra {
namespace Core {
namespace Asset {
 
class RA_CORE_API AnimationTime
{
  public:
    using Time = Scalar;
 
    AnimationTime( const Time& start = std::numeric_limits<Time>::max(),
                   const Time& end   = -std::numeric_limits<Time>::max() ) :
        m_start( start ), m_end( end ) {}
 
    AnimationTime( const AnimationTime& time ) = default;
 
    ~AnimationTime() {}
 
 
    inline Time getStart() const { return m_start; }
 
    inline void setStart( const Time& start ) { m_start = std::min( start, m_end ); }
 
    inline Time getEnd() const { return m_end; }
 
    inline void setEnd( const Time& end ) { m_end = std::max( end, m_start ); }
 
    inline void extends( const Time& t ) {
        setStart( t );
        setEnd( t );
    }
 
    inline void extends( const AnimationTime& time ) {
        m_start = std::min( m_start, time.m_start );
        m_end   = std::max( m_end, time.m_end );
    }
 
 
    inline bool isValid() const { return m_start < m_end; }
 
    inline Time duration() const { return isValid() ? m_end - m_start : 0; }
 
    inline bool contains( const Time& t ) const { return ( ( t >= m_start ) && ( t <= m_end ) ); }
 
    inline bool intersect( const AnimationTime& time ) const {
        return ( contains( time.m_start ) || contains( time.m_end ) || time.contains( m_start ) ||
                 time.contains( m_end ) );
    }
 
 
    inline bool operator==( const AnimationTime& time ) const {
        return ( ( m_start == time.m_start ) && ( m_end == time.m_end ) );
    }
 
    inline bool operator!=( const AnimationTime& time ) const { return !( *this == time ); }
 
    inline bool operator==( const Time& t ) const { return ( t == m_start ) && ( t == m_end ); }
 
    inline bool operator<( const Time& t ) const { return ( t < m_end ); }
 
    inline bool operator>( const Time& t ) const { return ( t > m_start ); }
 
  protected:
    Time m_start;
 
    Time m_end;
};
 
} // namespace Asset
} // namespace Core
} // namespace Ra