*** empty log message ***

direct/src/interval/AnimInterval.py

@@ -0,0 +1,46 @@
+"""AnimInterval module: contains the AnimInterval class"""
+
+from PandaModules import *
+from Interval import *
+
+class AnimInterval(Interval):
+
+    animNum = 1
+
+    # special methods
+    
+    def __init__(self, animControl, loop=0, name=None):
+        """__init__(name)
+        """
+	self.animControl = animControl
+	duration = (float(animControl.getNumFrames()) / 
+			animControl.getFrameRate())
+	self.loop = loop
+	if (name == None):
+	    n = 'Anim-%d' % self.animNum
+	    self.animNum = self.animNum + 1
+	else:
+	    n = name
+	Interval.__init__(self, n, duration)
+
+    def setT(self, t, entry=0):
+	""" setT(t, entry)
+	    Go to time t
+	"""
+	if (t < 0):
+	    return
+	elif (t > self.duration):
+	    if (self.isPlaying == 1):
+		self.isPlaying = 0
+		if (self.loop):
+		    self.animControl.stop()
+	    return
+	elif (entry == 1):
+	    self.isPlaying = 1
+	    # Determine the current frame
+	    frame = int(self.animControl.getFrameRate() * t)
+	    if (self.loop):
+		self.animControl.pos(frame)	
+		self.animControl.loop(0)
+	    else:
+		self.animControl.play(frame, self.animControl.getNumFrames())

direct/src/interval/EventInterval.py

@@ -0,0 +1,28 @@
+"""EventInterval module: contains the EventInterval class"""
+
+from PandaModules import *
+from Interval import *
+from MessengerGlobal import *
+
+class EventInterval(Interval):
+
+    # special methods
+    
+    def __init__(self, name):
+        """__init__(name)
+        """
+	duration = 0.0
+	self.prevt = 0.0
+	Interval.__init__(self, name, duration)
+
+    def setT(self, t, entry=0):
+	""" setT(t, entry)
+	    Go to time t
+	"""
+	if (t < 0):
+	    self.prevt = t
+	    return
+	elif (t == 0) or (self.prevt < 0):
+	    messenger.send(self.name)
+	    self.prevt = 0.0
+	    

direct/src/interval/Interval.py

@@ -20,6 +20,7 @@ class Interval(DirectObject):
 	self.name = name
 	self.duration = duration
 	self.clock = ClockObject.ClockObject.getGlobalClock()
+	self.prevt = 0.0
 
     def getName(self):
 	""" getName()
@@ -32,7 +33,7 @@ class Interval(DirectObject):
 	return self.duration
 
     def setT(self, t, entry=0):
-	""" setT(t)
+	""" setT(t, entry)
 	    Go to time t
 	"""
 	pass
@@ -65,9 +66,11 @@ class Interval(DirectObject):
         t = self.clock.getFrameTime()
         te = (t - self.startT) * self.scale
         if (te <= self.playDuration):
-            self.setT(te)
+            self.setT(te, self.prevt)
+	    self.prevt = te
             return Task.cont
         else:
+	    self.prevt = te
             return Task.done
 
     def printParams(self, indent=0):

direct/src/interval/IntervalGlobal.py

@@ -2,10 +2,13 @@
 
 from DirectObject import *
 from Interval import *
+from AnimInterval import *
+from EventInterval import *
 from LerpInterval import *
 from MopathInterval import *
 from PosHprInterval import *
 from SoundInterval import *
+from WaitInterval import *
 
 from Track import *
 from MultiTrack import *

direct/src/interval/IntervalTest.py

@@ -41,5 +41,16 @@ waterSound = SoundInterval(sound, name='watersound')
 soundTrack = Track([waterSound], 'soundtrack')
 soundTrack.setIntervalStartTime('watersound', waterStartTime)
 
-mtrack = MultiTrack([boatTrack, dockTrack, soundTrack])
+# Throw an event when the water track ends
+eventTime = soundTrack.getIntervalEndTime('watersound')
+waterDone = EventInterval('water-is-done')
+waterEventTrack = Track([waterDone])
+waterEventTrack.setIntervalStartTime('water-is-done', eventTime)
+
+mtrack = MultiTrack([boatTrack, dockTrack, soundTrack, waterEventTrack])
 mtrack.printParams()
+
+def handleWaterDone():
+    print 'water is done'
+
+messenger.accept('water-is-done', 1, handleWaterDone)

direct/src/interval/LerpInterval.py

@@ -16,15 +16,16 @@ class LerpInterval(Interval):
 	Interval.__init__(self, name, duration)
 
     def setT(self, t, entry=0):
-	""" setT(t)
+	""" setT(t, entry)
 	"""
-	assert(t >= 0.0)
+	if (t < 0):
-	if (entry == 1):
+	    return
+	elif (entry == 1):
 	    self.lerp = Lerp.Lerp(self.functorFunc(), self.duration, 
 						self.blendType)
 	if (entry == 1) and (t > self.duration):
 	    self.lerp.setT(self.duration)
-	else:
+	elif (t <= self.duration):
 	    self.lerp.setT(t)
 
     def __getBlend(self, blendType):

direct/src/interval/MopathInterval.py

@@ -24,11 +24,12 @@ class MopathInterval(Interval):
 	Interval.__init__(self, n, duration)
 
     def setT(self, t, entry=0):
-	""" setT(t)
+	""" setT(t, entry)
 	    Go to time t
 	"""
-	assert(t >= 0.0)
+	if (t < 0):
-	if (entry == 1) and (t > self.duration):
+	    return
+	elif (entry == 1) and (t > self.duration):
 	    self.mopath.goTo(self.node, self.duration)
 	else:
 	    self.mopath.goTo(self.node, t)

direct/src/interval/MultiTrack.py

@@ -33,7 +33,7 @@ class MultiTrack(Interval):
 	return duration
 
     def setT(self, t, entry=0):
-	""" setT(t)
+	""" setT(t, entry)
 	    Go to time t
 	"""
 	if (t > self.duration):

direct/src/interval/PosHprInterval.py

@@ -23,10 +23,12 @@ class PosHprInterval(Interval):
 	Interval.__init__(self, n, duration)
 
     def setT(self, t, entry=0):
-	""" setT(t)
+	""" setT(t, entry)
 	    Go to time t
 	"""
-	if (entry == 1):
+	if (t < 0):
+	    return
+	elif (entry == 1):
 	    self.node.setPosHpr(self.pos, self.hpr)
 
 class PosInterval(Interval):
@@ -48,10 +50,12 @@ class PosInterval(Interval):
 	Interval.__init__(n, duration)
 
     def setT(self, t, entry=0):
-	""" setT(t)
+	""" setT(t, entry)
 	    Go to time t
 	"""
-	if (entry == 1):
+	if (t < 0):
+	    return
+	elif (entry == 1):
 	    self.node.setPos(self.pos)
 
 class HprInterval(Interval):
@@ -73,8 +77,10 @@ class HprInterval(Interval):
 	Interval.__init__(n, duration)
 
     def setT(self, t, entry=0):
-	""" setT(t)
+	""" setT(t, entry)
 	    Go to time t
 	"""
-	if (entry == 1):
+	if (t < 0):
+	    return
+	elif (entry == 1):
 	    self.node.setHpr(self.hpr)

direct/src/interval/SoundInterval.py

@@ -25,20 +25,27 @@ class SoundInterval(Interval):
 	    self.soundNum = self.soundNum + 1
 	else:
 	    n = name
+	self.prevt = 0.0
 	Interval.__init__(self, n, duration)
 
     def setT(self, t, entry=0):
-	""" setT(t)
+	""" setT(t, entry)
 	    Go to time t
 	"""
-	if (t > self.duration):
+	if (t < 0):
+	    self.prevt = t
+	    return
+	elif (t > self.duration):
 	    if (self.isPlaying == 1):
 		AudioManager.stop(self.sound)
 		self.isPlaying = 0
 	    return
-	assert(t >= 0)
+	elif (entry == 1):
-	if (entry == 1):
 	    self.isPlaying = 1
-	    AudioManager.play(self.sound, t)
+	    if (self.prevt < 0.0):
+	    	AudioManager.play(self.sound)
+	    else:
+		#AudioManager.play(self.sound, t)
+		AudioManager.play(self.sound)
 	    if (self.loop):
 		AudioManager.setLoop(self.sound, 1)

direct/src/interval/Track.py

@@ -113,7 +113,9 @@ class Track(Interval):
 	""" setT(t, entry)
 	    Go to time t
 	"""
-	if (entry == 1):
+	if (t < 0):
+	    return
+	elif (entry == 1):
 	    self.currentInterval = None
 	if (len(self.ilist) == 0):
 	    Interval.notify.warning('Track.setT(): track has no intervals')
@@ -123,36 +125,22 @@ class Track(Interval):
 	    # final state of the last Interval on the track
 	    self.ilist[len(self.ilist)-1][0].setT(t, entry=1)
 	else:
-	    # Find out which Interval applies
-	    prev = None
 	    for i in self.ilist:
 		# Calculate the track relative start time for the interval
 		ival = i[0]
 		t0 = self.__getIntervalStartTime(ival)
 
-		# Determine if the Interval is applicable
+		# Calculate the interval-relative time value for t
-		if (t < t0):
+		tc = t - t0
-		    if (prev != None):
+
-			# Gaps between Intervals take the final state of
+		# There can only be one interval active at any given time
-			# the previous Interval
+		# per track, so see if we've crossed over
-			if (self.currentInterval != prev):
+		if ((t0 <= t) and (t <= t0 + ival.getDuration()) and
-			    prev.setT(t, entry=1)
+		    (self.currentInterval != ival)):
-			    self.currentInterval = prev
+		    ival.setT(tc, entry=1)
-			else:
+		    self.currentInterval = ival
-			    prev.setT(t)
+		else:
-			return
+		     ival.setT(tc)
-		    else:
-			#Interval.notify.warning(
-			#	'Track.setT(): state undefined at t: %f' % t)
-			return
-		elif (t0 <= t) and (t <= t0 + ival.getDuration()):
-		    if (self.currentInterval != ival):
-		        ival.setT(t - t0, entry=1)
-			self.currentInterval = ival
-		    else:
-		    	ival.setT(t - t0)
-		    return
-		prev = ival
 
     def printParams(self, indent=0):
 	""" printParams(indent)