172 lines
4.5 KiB
Text
172 lines
4.5 KiB
Text
/**
|
|
* PANDA 3D SOFTWARE
|
|
* Copyright (c) Carnegie Mellon University. All rights reserved.
|
|
*
|
|
* All use of this software is subject to the terms of the revised BSD
|
|
* license. You should have received a copy of this license along
|
|
* with this source code in a file named "LICENSE."
|
|
*
|
|
* @file cMetaInterval.I
|
|
* @author drose
|
|
* @date 2002-08-27
|
|
*/
|
|
|
|
/**
|
|
* Indicates the precision with which time measurements are compared. For
|
|
* numerical accuracy, all floating-point time values are converted to integer
|
|
* values internally by scaling by the precision factor. The larger the
|
|
* number given here, the smaller the delta of time that can be
|
|
* differentiated; the limit is the maximum integer that can be represented in
|
|
* the system.
|
|
*/
|
|
INLINE void CMetaInterval::
|
|
set_precision(double precision) {
|
|
_precision = precision;
|
|
mark_dirty();
|
|
}
|
|
|
|
/**
|
|
* Returns the precision with which time measurements are compared. See
|
|
* set_precision().
|
|
*/
|
|
INLINE double CMetaInterval::
|
|
get_precision() const {
|
|
return _precision;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of interval and push/pop definitions that have been
|
|
* added to the meta interval.
|
|
*/
|
|
INLINE int CMetaInterval::
|
|
get_num_defs() const {
|
|
return (int)_defs.size();
|
|
}
|
|
|
|
/**
|
|
* Returns the type of the nth interval definition that has been added.
|
|
*/
|
|
INLINE CMetaInterval::DefType CMetaInterval::
|
|
get_def_type(int n) const {
|
|
nassertr(n >= 0 && n < (int)_defs.size(), DT_c_interval);
|
|
return _defs[n]._type;
|
|
}
|
|
|
|
/**
|
|
* Return the CInterval pointer associated with the nth interval definition.
|
|
* It is only valid to call this if get_def_type(n) returns DT_c_interval.
|
|
*/
|
|
INLINE CInterval *CMetaInterval::
|
|
get_c_interval(int n) const {
|
|
nassertr(n >= 0 && n < (int)_defs.size(), nullptr);
|
|
nassertr(_defs[n]._type == DT_c_interval, nullptr);
|
|
return _defs[n]._c_interval;
|
|
}
|
|
|
|
/**
|
|
* Return the external interval index number associated with the nth interval
|
|
* definition. It is only valid to call this if get_def_type(n) returns
|
|
* DT_ext_index.
|
|
*/
|
|
INLINE int CMetaInterval::
|
|
get_ext_index(int n) const {
|
|
nassertr(n >= 0 && n < (int)_defs.size(), -1);
|
|
nassertr(_defs[n]._type == DT_ext_index, -1);
|
|
return _defs[n]._ext_index;
|
|
}
|
|
|
|
/**
|
|
* Returns true if a recent call to priv_initialize(), priv_step(), or
|
|
* priv_finalize() has left some external intervals ready to play. If this
|
|
* returns true, call get_event_index(), get_event_t(), and pop_event() to
|
|
* retrieve the relevant information.
|
|
*/
|
|
INLINE bool CMetaInterval::
|
|
is_event_ready() {
|
|
return service_event_queue();
|
|
}
|
|
|
|
/**
|
|
* If a previous call to is_event_ready() returned true, this returns the
|
|
* index number (added via add_event_index()) of the external interval that
|
|
* needs to be played.
|
|
*/
|
|
INLINE int CMetaInterval::
|
|
get_event_index() const {
|
|
nassertr(!_event_queue.empty(), -1);
|
|
const EventQueueEntry &entry = _event_queue.front();
|
|
const IntervalDef &def = _defs[entry._n];
|
|
nassertr(def._type == DT_ext_index, -1);
|
|
return def._ext_index;
|
|
}
|
|
|
|
/**
|
|
* If a previous call to is_event_ready() returned true, this returns the t
|
|
* value that should be fed to the given interval.
|
|
*/
|
|
INLINE double CMetaInterval::
|
|
get_event_t() const {
|
|
nassertr(!_event_queue.empty(), 0.0f);
|
|
return int_to_double_time(_event_queue.front()._time);
|
|
}
|
|
|
|
/**
|
|
* If a previous call to is_event_ready() returned true, this returns the type
|
|
* of the event (initialize, step, finalize, etc.) for the given interval.
|
|
*/
|
|
INLINE CInterval::EventType CMetaInterval::
|
|
get_event_type() const {
|
|
nassertr(!_event_queue.empty(), ET_step);
|
|
return _event_queue.front()._event_type;
|
|
}
|
|
|
|
/**
|
|
* Converts from an external double time value or offset in seconds to an
|
|
* internal integer value or offset.
|
|
*/
|
|
INLINE int CMetaInterval::
|
|
double_to_int_time(double t) const {
|
|
// Use floor() just in case there are negative values involved.
|
|
return (int)floor(t * _precision + 0.5);
|
|
}
|
|
|
|
/**
|
|
* Converts from an internal integer time value or offset to an external
|
|
* double time value or offset in seconds.
|
|
*/
|
|
INLINE double CMetaInterval::
|
|
int_to_double_time(int time) const {
|
|
return (double)time / _precision;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE CMetaInterval::PlaybackEvent::
|
|
PlaybackEvent(int time, int n,
|
|
CMetaInterval::PlaybackEventType type) :
|
|
_time(time),
|
|
_n(n),
|
|
_type(type)
|
|
{
|
|
_begin_event = this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE bool CMetaInterval::PlaybackEvent::
|
|
operator < (const CMetaInterval::PlaybackEvent &other) const {
|
|
return _time < other._time;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE CMetaInterval::EventQueueEntry::
|
|
EventQueueEntry(int n, CInterval::EventType event_type, int time) :
|
|
_n(n),
|
|
_event_type(event_type),
|
|
_time(time)
|
|
{
|
|
}
|