light9 Changeset - 41c0ec6cd10a

Changeset - 41c0ec6cd10a

Parent rev.

Child rev.

[Not reviewed]

default

0 1 0

dmcc - 22 years ago 2003-06-13 15:46:53

bugfixes, tableau demo

1 file changed with 36 insertions and 12 deletions:

flax/Timeline.py

0 comments (0 inline, 0 general)

flax/Timeline.py

➞

Show inline comments

@@ @@ -38,12 +38,14 @@ class TimedEvent: @@
             return cmp(self.time, other.time)
     def __repr__(self):
         return "<TimedEvent %s at %.2f, time=%.2f, next blender=%s>" % \
             (self.frame, self.level, self.time, self.next_blender)
     def get_level(self):
         return self.level
     def __hash__(self):
         return id(self.time) ^ id(self.frame) ^ id(self.next_blender)
 class Blender:
     """Blenders are functions that merge the effects of two LevelFrames."""
     def __init__(self):
         pass
     def __call__(self, startframe, endframe, blendtime):
@@ @@ -69,35 +71,46 @@ class Blender: @@
         """Utility function to help you produce linear combinations of two
         blends.  blendtime is the percent/100 that the blend should
         completed.  In other words, 0.25 means it should be 0.75 * startframe +
 .25 * endframe.  This function is included since many blenders are
         just functions on the percentage and still combine start and end frames
         in this way."""
         return {startframe : (1.0 - blendtime), endframe : blendtime}
         # print "linear_blend", startframe, endframe, blendtime
         if startframe.frame == endframe.frame:
             # print "same frames"
             startlevel = startframe.level * (1.0 - blendtime)
             endlevel = endframe.level * blendtime
             levels = {startframe.frame : max(startlevel, endlevel)}
         else:
             # print "diff frames"
             levels = {startframe.frame : (1.0 - blendtime) * startframe.level,
                 endframe.frame : blendtime * endframe.level}
         # print "return", levels
         return levels
 class InstantEnd(Blender):
     """Instant change from startframe to endframe at the end.  In other words,
     the value returned will be the startframe all the way until the very end
     of the blend."""
     def __call__(self, startframe, endframe, blendtime):
         # "What!?" you say, "Why don't you care about blendtime?"
         # This is because Blenders never be asked for blenders at the endpoints
         # (after all, they wouldn't be blenders if they were). Please see
         # 'Very important note' in Blender.__doc__
-        return {startframe : 1.0}
+        return {startframe.frame : startframe.level}
 class InstantStart(Blender):
     """Instant change from startframe to endframe at the beginning.  In other
     words, the value returned will be the startframe at the very beginning
     and then be endframe at all times afterwards."""
     def __call__(self, startframe, endframe, blendtime):
         # "What!?" you say, "Why don't you care about blendtime?"
         # This is because Blenders never be asked for blenders at the endpoints
         # (after all, they wouldn't be blenders if they were). Please see
         # 'Very important note' in Blender.__doc__
-        return {endframe : 1.0}
+        return {endframe.frame : endframe.level}
 class LinearBlender(Blender):
     """Linear fade from one frame to another"""
     def __call__(self, startframe, endframe, blendtime):
         return self.linear_blend(startframe, endframe, blendtime)
@@ @@ -182,21 +195,21 @@ class TimelineTrack: @@
         return self.get(time, direction=BACKWARD), \
                self.get(time, direction=FORWARD)
     def get_levels_at_time(self, time):
         """Returns a LevelFrame with the levels of this track at that time."""
         before, after = self.get_surrounding_frames(time)
         if before == after:
             return {before.frame : 1.0}
         if not after or before == after:
             return {before.frame : before.level}
         else: # we have a blended value
             diff = after.time - before.time
             elapsed = time - before.time
             percent = elapsed / diff
             if not before.next_blender:
                 raise MissingBlender, before
-            return before.next_blender(before.frame, after.frame, percent)
             return before.next_blender(before, after, percent)
 class Timeline:
     def __init__(self, tracks, rate=1, direction=FORWARD):
         """
         Most/all of this is old:
@@ @@ -280,19 +293,30 @@ if __name__ == '__main__': @@
     linear = LinearBlender()
     quad = ExponentialBlender(2)
     invquad = ExponentialBlender(0.5)
     smoove = SmoothBlender()
     track1 = TimelineTrack('lights',
         T(0, 'red', blender=linear),
         T(5, 'blue', blender=quad),
         T(10, 'red', blender=smoove),
         T(15, 'blue')) # last TimedEvent doesn't need a blender
     track1 = TimelineTrack('red track',
         T(0, 'red', blender=linear, level=0),
         T(4, 'red', blender=quad, level=0.5),
         T(12, 'red', blender=smoove, level=0.7),
         T(15, 'red', level=0.0)) # last TimedEvent doesn't need a blender
     track2 = TimelineTrack('green track',
         T(0, 'green', blender=invquad, level=0.2),
         T(5, 'green', blender=smoove, level=1),
         T(10, 'green', blender=linear, level=0.8),
         T(15, 'green', blender=linear, level=0.6),
         T(20, 'green', level=0.0)) # last TimedEvent doesn't need a blender
     track3 = TimelineTrack('tableau demo',
         T(0, 'blue', level=0.0, blender=linear),
         T(2, 'blue', level=1.0, blender=InstantEnd()),
         T(18, 'blue', level=1.0, blender=linear),
         T(20, 'blue', level=0.0, blender=linear))
     tl = Timeline([track1])
+    tl = Timeline([track1, track2, track3])
     tl.play()
     import Tix
     root = Tix.Tk()
     colorscalesframe = Tix.Frame(root)

0 comments (0 inline, 0 general)