*** empty log message ***

direct/src/interval/Interval.py

@@ -2,6 +2,10 @@
 
 from DirectObject import *
 
+PREVIOUS_END = 1
+PREVIOUS_START = 2
+TRACK_START = 3
+
 class Interval(DirectObject):
     """Interval class: Base class for timeline functionality"""
 
@@ -15,7 +19,7 @@ class Interval(DirectObject):
 
     # special methods
     
-    def __init__(self, name, duration, t0 = 0.0, type = PrevEndRelative):
+    def __init__(self, name, duration, t0=0.0, type=PREVIOUS_END):
         """__init__(name, duration, t0, type)
         """
 	self.name = name

direct/src/interval/IntervalGlobal.py

@@ -0,0 +1,12 @@
+"""IntervalGlobal module"""
+
+from DirectObject import *
+from Interval import *
+from LerpInterval import *
+from MopathInterval import *
+from PosHprInterval import *
+from SoundInterval import *
+from WaitInterval import *
+
+import Track
+import MultiTrack

direct/src/interval/IntervalTest.py

@@ -18,9 +18,11 @@ sound = loader.loadSound('phase_6/audio/sfx/SZ_DD_waterlap.mp3')
 mp = Mopath.Mopath()
 mp.loadFile(Filename('phase_6/paths/dd-e-w'))
 
+# Set up the boat
 boatMopath = MopathInterval('boatpath', mp, boat)
-
 boatTrack = Track.Track([boatMopath], 'boattrack')
+BOAT_START = boatTrack.getIntervalStartTime('boatpath')
+BOAT_END = boatTrack.getIntervalEndTime('boatpath')
 
 # Make the dock lerp up so that it's up when the boat reaches the end of
 # its mopath
@@ -29,14 +31,14 @@ hpr = Vec3(0, 0, 0)
 dockLerp = LerpPosHprInterval('lerp', dock, pos, hpr, 5.0)
 # We need the dock's state to be defined before the lerp
 dockPos = PosHprInterval('dockpos', dock, dock.getPos(), dock.getHpr(), 1.0)
-dockUpTime = boatTrack.getTrackRelativeEndTime('boatpath') - dockLerp.getDuration()
+dockUpTime = BOAT_END - dockLerp.getDuration()
-dockLerp.setStartTime(dockUpTime, Interval.Interval.TrackStartRelative)
+dockLerp.setStartTime(dockUpTime, TRACK_START)
 dockTrack = Track.Track([dockPos, dockLerp], 'docktrack')
 
 # Start the water sound 5 seconds after the boat starts moving
-waterStartTime = boatTrack.getTrackRelativeStartTime('boatpath') + 5.0
+waterStartTime = BOAT_START + 5.0
 waterSound = SoundInterval('watersound', sound, loop=1)
-waterSound.setStartTime(waterStartTime, Interval.Interval.TrackStartRelative)
+waterSound.setStartTime(waterStartTime, TRACK_START)
 soundTrack = Track.Track([waterSound], 'soundtrack')
 
 mtrack = MultiTrack.MultiTrack([boatTrack, dockTrack, soundTrack])

direct/src/interval/LerpInterval.py

@@ -9,7 +9,7 @@ class LerpInterval(Interval.Interval):
     # special methods
     
     def __init__(self, name, node, duration, t0=0.0, 
-				type=Interval.Interval.PrevEndRelative):
+					type=Interval.PREVIOUS_END):
         """__init__(name, node, duration, t0, type)
         """
 	self.name = name
@@ -21,8 +21,7 @@ class LerpInterval(Interval.Interval):
 class LerpPosHprInterval(LerpInterval):
 
     def __init__(self, name, node, pos, hpr, duration, t0=0.0, 
-		type=Interval.Interval.PrevEndRelative, other=None,
+		type=Interval.PREVIOUS_END, other=None, blendType='noBlend'):
-			blendType='noBlend'):
 	""" __init__(name, node, pos, hpr, duration, t0, type, other, 
 					blendType)
 	"""

direct/src/interval/MopathInterval.py

@@ -9,7 +9,7 @@ class MopathInterval(Interval.Interval):
     # special methods
     
     def __init__(self, name, mopath, node, t0=0.0, 
-				type=Interval.Interval.PrevEndRelative):
+				type=Interval.PREVIOUS_END):
         """__init__(name, mopath, node, t0, type)
         """
 	self.name = name

direct/src/interval/MultiTrack.py

@@ -20,7 +20,7 @@ class MultiTrack(Interval.Interval):
 	self.tlist = trackList
 	self.duration = self.getDuration()
 	self.startTime = 0.0
-	self.type = Interval.Interval.PrevEndRelative
+	self.type = Interval.PREVIOUS_END
 
     def getDuration(self):
 	""" getDuration()

direct/src/interval/PosHprInterval.py

@@ -9,7 +9,7 @@ class PosHprInterval(Interval.Interval):
     # special methods
     
     def __init__(self, name, node, pos, hpr, duration, t0=0.0,
-				type=Interval.Interval.PrevEndRelative):
+				type=Interval.PREVIOUS_END):
         """__init__(name, node, pos, hpr, duration, t0, type)
         """
 	self.name = name

direct/src/interval/SoundInterval.py

@@ -10,7 +10,7 @@ class SoundInterval(Interval.Interval):
     # special methods
     
     def __init__(self, name, sound, loop=0, t0=0.0, 
-				type=Interval.Interval.PrevEndRelative):
+				type=Interval.PREVIOUS_END):
         """__init__(name, sound, loop, t0, type)
         """
 	self.name = name

direct/src/interval/Track.py

@@ -21,7 +21,7 @@ class Track(Interval.Interval):
 	self.ilist = intervalList
 	self.duration = self.__computeDuration(len(self.ilist))
 	self.startTime = 0.0
-	self.type = Interval.Interval.PrevEndRelative
+	self.type = Interval.PREVIOUS_END
 
     def __computeDuration(self, length):
 	""" __computeDuration(length)
@@ -34,12 +34,12 @@ class Track(Interval.Interval):
 	    t0 = i.getStartTime()
 	    assert(t0 >= 0.0)
 	    fillTime = t0 
-	    if (type == Interval.Interval.PrevEndRelative):
+	    if (type == Interval.PREVIOUS_END):
 		pass
-	    elif (type == Interval.Interval.PrevStartRelative):
+	    elif (type == Interval.PREVIOUS_START):
 		if (prev != None):
 		    fillTime = t0 - prev.getDuration()
-	    elif (type == Interval.Interval.TrackStartRelative):
+	    elif (type == Interval.TRACK_START):
 		fillTime = t0 - duration
 	    else:
 		Interval.notify.error(
@@ -51,30 +51,30 @@ class Track(Interval.Interval):
 	    prev = i
 	return duration
 
-    def getTrackRelativeStartTime(self, name):
+    def getIntervalStartTime(self, name):
-	""" getTrackRelativeStartTime(name)
+	""" getIntervalStartTime(name)
 	"""
 	for i in range(len(self.ilist)):
 	    if (self.ilist[i].getName() == name):	
 		return self.__computeDuration(i+1) - self.ilist[i].getDuration()
 	Interval.notify.warning(
-		'Track.getRelativeStartTime(): no Interval named: %s' % name)
+		'Track.getIntervalStartTime(): no Interval named: %s' % name)
 	return 0.0
 
-    def __getTrackRelativeStartTime(self, interval):
+    def __getIntervalStartTime(self, interval):
-	""" __getTrackRelativeStartTime(interval)
+	""" __getIntervalStartTime(interval)
 	"""
 	return (self.__computeDuration(self.ilist.index(interval)+1) -
 			interval.getDuration())
 
-    def getTrackRelativeEndTime(self, name):
+    def getIntervalEndTime(self, name):
-	""" getTrackRelativeEndTime(name)
+	""" getIntervalEndTime(name)
 	"""
 	for i in range(len(self.ilist)):
 	    if (self.ilist[i].getName() == name):	
 		return self.__computeDuration(i+1)
 	Interval.notify.warning(
-		'Track.getRelativeEndTime(): no Interval named: %s' % name)
+		'Track.getIntervalEndTime(): no Interval named: %s' % name)
 	return 0.0
 
     def setT(self, t):
@@ -93,7 +93,7 @@ class Track(Interval.Interval):
 	    prev = None
 	    for i in self.ilist:
 		# Calculate the track relative start time for the interval
-		t0 = self.__getTrackRelativeStartTime(i)
+		t0 = self.__getIntervalStartTime(i)
 
 		# Determine if the Interval is applicable
 		if (t < t0):

direct/src/interval/WaitInterval.py

@@ -11,7 +11,7 @@ class Wait(Interval.Interval):
     # special methods
     
     def __init__(self, duration, name=None, t0=0.0,
-				type=Interval.Interval.PrevEndRelative):
+				type=Interval.PREVIOUS_END):
         """__init__(duration, name, t0, type)
         """
 	if (name == None):