diff --git a/direct/src/interval/MetaInterval.py b/direct/src/interval/MetaInterval.py index 063fe3ff4a..5533512066 100644 --- a/direct/src/interval/MetaInterval.py +++ b/direct/src/interval/MetaInterval.py @@ -169,16 +169,7 @@ class MetaInterval(CMetaInterval): def addInterval(self, ival, relTime, relTo): # Adds the given interval to the MetaInterval. - if isinstance(ival, MetaInterval): - # It's another MetaInterval, so copy in its intervals - # directly to this object. We could just store the - # MetaInterval itself, which would work, but we get a - # performance advantage by flattening out the deeply - # nested hierarchy into a linear list within the root - # CMetaInterval object. - ival.applyIvals(self, relTime, relTo) - - elif isinstance(ival, CInterval): + if isinstance(ival, CInterval): # It's a C++-style Interval, so add it directly. if getattr(ival, "inPython", 0): # Actually, it's been flagged to run in Python, even @@ -190,10 +181,20 @@ class MetaInterval(CMetaInterval): self.pythonIvals.append(ival) self.addExtIndex(index, ival.getName(), ival.getDuration(), ival.getOpenEnded(), relTime, relTo) + + elif isinstance(ival, MetaInterval): + # It's another MetaInterval, so copy in its intervals + # directly to this object. We could just store the + # MetaInterval itself, which would work, but we get a + # performance advantage by flattening out the deeply + # nested hierarchy into a linear list within the root + # CMetaInterval object. + ival.applyIvals(self, relTime, relTo) + else: # Nope, a perfectly ordinary C++ interval. Hooray! self.addCInterval(ival, relTime, relTo) - + elif isinstance(ival, Interval.Interval): # It's a Python-style Interval, so add it as an external. index = len(self.pythonIvals) @@ -315,6 +316,26 @@ class MetaInterval(CMetaInterval): CMetaInterval.setFinalT(self) self.__doPythonCallbacks() + def setIntervalStartTime(self, *args, **kw): + # This function overrides from the parent level to force it to + # update the interval list first, if necessary. + + self.__updateIvals() + # Once we have monkeyed with the interval timings, we'd better + # run the whole thing as a monolithic Python interval, since + # we can't extract the ivals list back out and append them + # into a parent MetaInterval. + self.inPython = 1 + return CMetaInterval.setIntervalStartTime(self, *args, **kw) + + def getIntervalStartTime(self, *args, **kw): + # This function overrides from the parent level to force it to + # update the interval list first, if necessary. + + self.__updateIvals() + return CMetaInterval.getIntervalStartTime(self, *args, **kw) + + def getDuration(self): # This function overrides from the parent level to force it to # update the interval list first, if necessary. diff --git a/direct/src/interval/cMetaInterval.cxx b/direct/src/interval/cMetaInterval.cxx index e143866651..0fac488c18 100644 --- a/direct/src/interval/cMetaInterval.cxx +++ b/direct/src/interval/cMetaInterval.cxx @@ -196,6 +196,130 @@ pop_level() { return (int)_defs.size() - 1; } +//////////////////////////////////////////////////////////////////// +// Function: CMetaInterval::set_interval_start_time +// Access: Published +// Description: Adjusts the start time of the child interval with the +// given name, if found. This may be either a C++ +// interval added via add_c_interval(), or an external +// interval added via add_ext_index(); the name must +// match exactly. +// +// If the interval is found, its start time is adjusted, +// and all subsequent intervals are adjusting +// accordingly, and true is returned. If a matching +// interval is not found, nothing is changed and false +// is returned. +//////////////////////////////////////////////////////////////////// +bool CMetaInterval:: +set_interval_start_time(const string &name, double rel_time, + CMetaInterval::RelativeStart rel_to) { + Defs::iterator di; + for (di = _defs.begin(); di != _defs.end(); ++di) { + IntervalDef &def = (*di); + + bool match = false; + switch (def._type) { + case DT_c_interval: + match = (def._c_interval->get_name() == name); + break; + + case DT_ext_index: + match = (def._ext_name == name); + break; + + default: + break; + } + if (match) { + // Here's the interval. + def._rel_time = rel_time; + def._rel_to = rel_to; + mark_dirty(); + return true; + } + } + + return false; +} + +//////////////////////////////////////////////////////////////////// +// Function: CMetaInterval::get_interval_start_time +// Access: Published +// Description: Returns the actual start time, relative to the +// beginning of the interval, of the child interval with +// the given name, if found, or -1 if the interval is +// not found. +//////////////////////////////////////////////////////////////////// +double CMetaInterval:: +get_interval_start_time(const string &name) const { + recompute(); + Defs::const_iterator di; + for (di = _defs.begin(); di != _defs.end(); ++di) { + const IntervalDef &def = (*di); + + bool match = false; + switch (def._type) { + case DT_c_interval: + match = (def._c_interval->get_name() == name); + break; + + case DT_ext_index: + match = (def._ext_name == name); + break; + + default: + break; + } + if (match) { + // Here's the interval. + return int_to_double_time(def._actual_begin_time); + } + } + + return -1.0; +} + +//////////////////////////////////////////////////////////////////// +// Function: CMetaInterval::get_interval_end_time +// Access: Published +// Description: Returns the actual end time, relative to the +// beginning of the interval, of the child interval with +// the given name, if found, or -1 if the interval is +// not found. +//////////////////////////////////////////////////////////////////// +double CMetaInterval:: +get_interval_end_time(const string &name) const { + recompute(); + Defs::const_iterator di; + for (di = _defs.begin(); di != _defs.end(); ++di) { + const IntervalDef &def = (*di); + + bool match = false; + double duration = 0.0; + switch (def._type) { + case DT_c_interval: + duration = def._c_interval->get_duration(); + match = (def._c_interval->get_name() == name); + break; + + case DT_ext_index: + duration = def._ext_duration; + match = (def._ext_name == name); + break; + + default: + break; + } + if (match) { + // Here's the interval. + return int_to_double_time(def._actual_begin_time) + duration; + } + } + + return -1.0; +} + //////////////////////////////////////////////////////////////////// // Function: CMetaInterval::initialize // Access: Published, Virtual diff --git a/direct/src/interval/cMetaInterval.h b/direct/src/interval/cMetaInterval.h index 21a11122ff..a3ef33a5e1 100644 --- a/direct/src/interval/cMetaInterval.h +++ b/direct/src/interval/cMetaInterval.h @@ -57,6 +57,11 @@ PUBLISHED: double rel_time, RelativeStart rel_to); int pop_level(); + bool set_interval_start_time(const string &name, double rel_time, + RelativeStart rel_to = RS_level_begin); + double get_interval_start_time(const string &name) const; + double get_interval_end_time(const string &name) const; + enum DefType { DT_c_interval, DT_ext_index,