Panda3D

Loading...
Searching...
No Matches
cMetaInterval.h
Go to the documentation of this file.
1/**
2 * PANDA 3D SOFTWARE
3 * Copyright (c) Carnegie Mellon University. All rights reserved.
4 *
5 * All use of this software is subject to the terms of the revised BSD
6 * license. You should have received a copy of this license along
7 * with this source code in a file named "LICENSE."
8 *
9 * @file cMetaInterval.h
10 * @author drose
11 * @date 2002-08-27
12 */
13
14#ifndef CMETAINTERVAL_H
15#define CMETAINTERVAL_H
16
17#include "directbase.h"
18#include "cInterval.h"
19#include "pointerTo.h"
20
21#include "pdeque.h"
22#include "pvector.h"
23#include "plist.h"
24#include "pset.h"
25#include <math.h>
26
27/**
28 * This interval contains a list of nested intervals, each of which has its
29 * own begin and end times. Some of them may overlap and some of them may
30 * not.
31 */
32 class EXPCL_DIRECT_INTERVAL CMetaInterval : public CInterval {
33PUBLISHED:
34 explicit CMetaInterval(const std::string &name);
35 virtual ~CMetaInterval();
36
37 enum RelativeStart {
38 RS_previous_end,
39 RS_previous_begin,
40 RS_level_begin,
41 };
42
43 INLINE void set_precision(double precision);
44 INLINE double get_precision() const;
45
46 void clear_intervals();
47 int push_level(const std::string &name,
48 double rel_time, RelativeStart rel_to);
49 int add_c_interval(CInterval *c_interval,
50 double rel_time = 0.0f,
51 RelativeStart rel_to = RS_previous_end);
52 int add_ext_index(int ext_index, const std::string &name,
53 double duration, bool open_ended,
54 double rel_time, RelativeStart rel_to);
55 int pop_level(double duration = -1.0);
56
57 bool set_interval_start_time(const std::string &name, double rel_time,
58 RelativeStart rel_to = RS_level_begin);
59 double get_interval_start_time(const std::string &name) const;
60 double get_interval_end_time(const std::string &name) const;
61
62 enum DefType {
63 DT_c_interval,
64 DT_ext_index,
65 DT_push_level,
66 DT_pop_level
67 };
68
69 INLINE int get_num_defs() const;
70 INLINE DefType get_def_type(int n) const;
71 INLINE CInterval *get_c_interval(int n) const;
72 INLINE int get_ext_index(int n) const;
73
74 virtual void priv_initialize(double t);
75 virtual void priv_instant();
76 virtual void priv_step(double t);
77 virtual void priv_finalize();
78 virtual void priv_reverse_initialize(double t);
79 virtual void priv_reverse_instant();
80 virtual void priv_reverse_finalize();
81 virtual void priv_interrupt();
82
83 INLINE bool is_event_ready();
84 INLINE int get_event_index() const;
85 INLINE double get_event_t() const;
86 INLINE EventType get_event_type() const;
87 void pop_event();
88
89 virtual void write(std::ostream &out, int indent_level) const;
90 void timeline(std::ostream &out) const;
91
92 protected:
93 virtual void do_recompute();
94
95 private:
96 class IntervalDef {
97 public:
98 DefType _type;
99 PT(CInterval) _c_interval;
100 int _ext_index;
101 std::string _ext_name;
102 double _ext_duration;
103 bool _ext_open_ended;
104 double _rel_time;
105 RelativeStart _rel_to;
106 int _actual_begin_time;
107 };
108
109 enum PlaybackEventType {
110 PET_begin,
111 PET_end,
112 PET_instant
113 };
114
115 class PlaybackEvent {
116 public:
117 INLINE PlaybackEvent(int time, int n, PlaybackEventType type);
118 INLINE bool operator < (const PlaybackEvent &other) const;
119 int _time;
120 int _n;
121 PlaybackEventType _type;
122 PlaybackEvent *_begin_event;
123 };
124
125 class EventQueueEntry {
126 public:
127 INLINE EventQueueEntry(int n, EventType event_type, int time);
128 int _n;
129 EventType _event_type;
130 int _time;
131 };
132
133 typedef pvector<IntervalDef> Defs;
134 typedef pvector<PlaybackEvent *> PlaybackEvents;
135 // ActiveEvents must be either a list or a vector--something that preserves
136 // order--so we can call priv_step() on the currently active intervals in
137 // the order they were encountered.
138 typedef plist<PlaybackEvent *> ActiveEvents;
139 typedef pdeque<EventQueueEntry> EventQueue;
140
141 INLINE int double_to_int_time(double t) const;
142 INLINE double int_to_double_time(int time) const;
143
144 void clear_events();
145 void do_event_forward(PlaybackEvent *event, ActiveEvents &new_active,
146 bool is_initial);
147 void finish_events_forward(int now, ActiveEvents &new_active);
148 void do_event_reverse(PlaybackEvent *event, ActiveEvents &new_active,
149 bool is_initial);
150 void finish_events_reverse(int now, ActiveEvents &new_active);
151
152 void enqueue_event(int n, CInterval::EventType event_type, bool is_initial,
153 int time = 0);
154 void enqueue_self_event(CInterval::EventType event_type, double t = 0.0);
155 void enqueue_done_event();
156 bool service_event_queue();
157
158 int recompute_level(int n, int level_begin, int &level_end);
159 int get_begin_time(const IntervalDef &def, int level_begin,
160 int previous_begin, int previous_end);
161
162 void write_event_desc(std::ostream &out, const IntervalDef &def,
163 int &extra_indent_level) const;
164
165
166 double _precision;
167 Defs _defs;
168 int _current_nesting_level;
169
170 PlaybackEvents _events;
171 ActiveEvents _active;
172 int _end_time;
173
174 size_t _next_event_index;
175 bool _processing_events;
176
177 // This is the queue of events that have occurred due to a recent
178 // priv_initialize(), priv_step(), etc., but have not yet been serviced, due
179 // to an embedded external (e.g. Python) interval that the scripting
180 // language must service. This queue should be considered precious, and
181 // should never be arbitrarily flushed without servicing all of its events.
182 EventQueue _event_queue;
183
184 public:
185 static TypeHandle get_class_type() {
186 return _type_handle;
187 }
188 static void init_type() {
189 CInterval::init_type();
190 register_type(_type_handle, "CMetaInterval",
191 CInterval::get_class_type());
192 }
193 virtual TypeHandle get_type() const {
194 return get_class_type();
195 }
196 virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
197
198 private:
199 static TypeHandle _type_handle;
200};
201
202#include "cMetaInterval.I"
203
204#endif
cInterval.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
cMetaInterval.I
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
CInterval::priv_reverse_finalize
virtual void priv_reverse_finalize()
Called generally following a priv_reverse_initialize(), this indicates the interval should set itself...
Definition cInterval.cxx:410
CInterval::priv_step
virtual void priv_step(double t)
Advances the time on the interval.
Definition cInterval.cxx:357
CInterval::priv_initialize
virtual void priv_initialize(double t)
This replaces the first call to priv_step(), and indicates that the interval has just begun.
Definition cInterval.cxx:329
CInterval::priv_reverse_initialize
virtual void priv_reverse_initialize(double t)
Similar to priv_initialize(), but this is called when the interval is being played backwards; it indi...
Definition cInterval.cxx:383
CInterval::priv_finalize
virtual void priv_finalize()
This is called to stop an interval, forcing it to whatever state it would be after it played all the ...
Definition cInterval.cxx:369
CInterval::priv_reverse_instant
virtual void priv_reverse_instant()
This is called in lieu of priv_reverse_initialize() .
Definition cInterval.cxx:397
CInterval::priv_interrupt
virtual void priv_interrupt()
This is called while the interval is playing to indicate that it is about to be interrupted; that is,...
Definition cInterval.cxx:427
CInterval::priv_instant
virtual void priv_instant()
This is called in lieu of priv_initialize() .
Definition cInterval.cxx:342
CMetaInterval::get_interval_start_time
double get_interval_start_time(const std::string &name) const
Returns the actual start time, relative to the beginning of the interval, of the child interval with ...
Definition cMetaInterval.cxx:249
CMetaInterval::get_event_type
EventType get_event_type() const
If a previous call to is_event_ready() returned true, this returns the type of the event (initialize,...
Definition cMetaInterval.I:118
CMetaInterval::set_interval_start_time
bool set_interval_start_time(const std::string &name, double rel_time, RelativeStart rel_to=RS_level_begin)
Adjusts the start time of the child interval with the given name, if found.
Definition cMetaInterval.cxx:211
CMetaInterval::get_num_defs
int get_num_defs() const
Returns the number of interval and push/pop definitions that have been added to the meta interval.
Definition cMetaInterval.I:42
CMetaInterval::get_event_t
double get_event_t() const
If a previous call to is_event_ready() returned true, this returns the t value that should be fed to ...
Definition cMetaInterval.I:108
CMetaInterval::get_ext_index
int get_ext_index(int n) const
Return the external interval index number associated with the nth interval definition.
Definition cMetaInterval.I:72
CMetaInterval::pop_event
void pop_event()
Acknowledges that the external interval on the top of the queue has been extracted,...
Definition cMetaInterval.cxx:660
CMetaInterval::get_def_type
DefType get_def_type(int n) const
Returns the type of the nth interval definition that has been added.
Definition cMetaInterval.I:50
CMetaInterval::is_event_ready
bool is_event_ready()
Returns true if a recent call to priv_initialize(), priv_step(), or priv_finalize() has left some ext...
Definition cMetaInterval.I:85
CMetaInterval::add_c_interval
int add_c_interval(CInterval *c_interval, double rel_time=0.0f, RelativeStart rel_to=RS_previous_end)
Adds a new CInterval to the list.
Definition cMetaInterval.cxx:124
CMetaInterval::get_c_interval
CInterval * get_c_interval(int n) const
Return the CInterval pointer associated with the nth interval definition.
Definition cMetaInterval.I:60
CMetaInterval::pop_level
int pop_level(double duration=-1.0)
Finishes a level marked by a previous call to push_level(), and returns to the previous level.
Definition cMetaInterval.cxx:187
CMetaInterval::get_interval_end_time
double get_interval_end_time(const std::string &name) const
Returns the actual end time, relative to the beginning of the interval, of the child interval with th...
Definition cMetaInterval.cxx:283
CMetaInterval::push_level
int push_level(const std::string &name, double rel_time, RelativeStart rel_to)
Marks the beginning of a nested level of child intervals.
Definition cMetaInterval.cxx:101
CMetaInterval::timeline
void timeline(std::ostream &out) const
Outputs a list of all events in the order in which they occur.
Definition cMetaInterval.cxx:703
CMetaInterval::clear_intervals
void clear_intervals()
Resets the list of intervals and prepares for receiving a new list.
Definition cMetaInterval.cxx:53
CMetaInterval::get_precision
double get_precision() const
Returns the precision with which time measurements are compared.
Definition cMetaInterval.I:33
CMetaInterval::get_event_index
int get_event_index() const
If a previous call to is_event_ready() returned true, this returns the index number (added via add_ev...
Definition cMetaInterval.I:95
CMetaInterval::set_precision
void set_precision(double precision)
Indicates the precision with which time measurements are compared.
Definition cMetaInterval.I:23
CMetaInterval::add_ext_index
int add_ext_index(int ext_index, const std::string &name, double duration, bool open_ended, double rel_time, RelativeStart rel_to)
Adds a new external interval to the list.
Definition cMetaInterval.cxx:159
TypeHandle
TypeHandle is the identifier used to differentiate C++ class types.
Definition typeHandle.h:81
pdeque
This is our own Panda specialization on the default STL deque.
Definition pdeque.h:36
plist
This is our own Panda specialization on the default STL list.
Definition plist.h:35
directbase.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
pdeque.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
plist.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
pointerTo.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
pset.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
pvector.h
PANDA 3D SOFTWARE Copyright (c) Carnegie Mellon University.
register_type
void register_type(TypeHandle &type_handle, const std::string &name)
This inline function is just a convenient way to call TypeRegistry::register_type(),...
Definition register_type.I:22