[WIP] Adding shader support for doing the animations

docs/tutorials/05_animation/viz_keyframe_bezier_interpolator.py → docs/tutorials/05_animation/viz_bezier_interpolator.py

@@ -1,14 +1,14 @@
 """
-=====================
-Keyframe animation
-=====================
+===================
+Bezier Interpolator
+===================
 
 Keyframe animation using cubic Bezier interpolator.
 
 """
 import numpy as np
 from fury import actor, window
-from fury.animation.timeline import Timeline
+from fury.animation import Animation, Timeline
 from fury.animation.interpolator import cubic_bezier_interpolator
 
 ###############################################################################
@@ -64,10 +64,10 @@
                          colors=np.array([0, 1, 0]))
 
 ###############################################################################
-# Initializing a ``Timeline`` and adding sphere actor to it.
-timeline = Timeline(playback_panel=True)
+# Initializing an ``Animation`` and adding sphere actor to it.
+animation = Animation()
 sphere = actor.sphere(np.array([[0, 0, 0]]), (1, 0, 1))
-timeline.add_actor(sphere)
+animation.add_actor(sphere)
 
 ###############################################################################
 # Setting Cubic Bezier keyframes
@@ -82,31 +82,22 @@
 # Note: If a control point is not provided or set `None`, this control point
 # will be the same as the position itself.
 
-timeline.set_position(0, np.array(keyframe_1.get('value')),
-                      out_cp=np.array(keyframe_1.get('out_cp')))
-timeline.set_position(5, np.array(keyframe_2.get('value')),
-                      in_cp=np.array(keyframe_2.get('in_cp')))
+animation.set_position(0.0, np.array(keyframe_1.get('value')),
+                       out_cp=np.array(keyframe_1.get('out_cp')))
+animation.set_position(5.0, np.array(keyframe_2.get('value')),
+                       in_cp=np.array(keyframe_2.get('in_cp')))
 
 ###############################################################################
-# changing position interpolation into cubic bezier interpolation
-timeline.set_position_interpolator(cubic_bezier_interpolator)
+# Changing position interpolation into cubic bezier interpolation
+animation.set_position_interpolator(cubic_bezier_interpolator)
 
 ###############################################################################
-# adding the timeline and the static actors to the scene.
+# Adding the visualization actors to the scene.
 scene.add(pts_actor, cps_actor, cline_actor)
-scene.add(timeline)
-
-
-###############################################################################
-# making a function to update the animation
-def timer_callback(_obj, _event):
-    timeline.update_animation()
-    showm.render()
-
 
 ###############################################################################
-# Adding the callback function that updates the animation
-showm.add_timer_callback(True, 10, timer_callback)
+# Adding the animation to the ``ShowManager``
+showm.add_animation(animation)
 
 interactive = False
 
@@ -138,18 +129,20 @@ def timer_callback(_obj, _event):
 }
 
 ###############################################################################
-# Initializing the timeline
-timeline = Timeline(playback_panel=True)
+# Creat the sphere actor.
 sphere = actor.sphere(np.array([[0, 0, 0]]), (1, 0, 1))
-timeline.add_actor(sphere)
+
+###############################################################################
+# Creat an ``Animation`` and adding the sphere actor to it.
+animation = Animation(sphere)
 
 ###############################################################################
 # Setting Cubic Bezier keyframes
-timeline.set_position_keyframes(keyframes)
+animation.set_position_keyframes(keyframes)
 
 ###############################################################################
 # changing position interpolation into cubic bezier interpolation
-timeline.set_position_interpolator(cubic_bezier_interpolator)
+animation.set_position_interpolator(cubic_bezier_interpolator)
 
 ###########################################################################
 # visualizing the points and control points (only for demonstration)
@@ -174,21 +167,16 @@ def timer_callback(_obj, _event):
             scene.add(vis_cps, cline_actor)
 
 ###############################################################################
-# adding actors to the scene
-scene.add(timeline)
-
+# Initializing the timeline to be able to control the playback of the
+# animation.
+timeline = Timeline(animation, playback_panel=True)
 
 ###############################################################################
-# making a function to update the animation
-def timer_callback(_obj, _event):
-    timeline.update_animation()
-    show_manager.render()
-
+# We only need to add the ``Timeline`` to the ``ShowManager``
+show_manager.add_animation(timeline)
 
 ###############################################################################
-# Adding the callback function that updates the animation
-show_manager.add_timer_callback(True, 10, timer_callback)
-
+# Start the animation
 if interactive:
     show_manager.start()
 

docs/tutorials/05_animation/viz_keyframe_camera_animation.py → docs/tutorials/05_animation/viz_camera.py

@@ -8,7 +8,7 @@
 
 import numpy as np
 from fury import actor, window
-from fury.animation.timeline import Timeline
+from fury.animation import Timeline, Animation, CameraAnimation
 from fury.animation.interpolator import cubic_spline_interpolator
 
 ###############################################################################
@@ -29,20 +29,21 @@
 # Creating the main ``Timeline`` and adding static actors to it
 # =============================================================
 #
-# Here we create a ``Timeline``. which we will call ``main_timeline`` so that
-# we can use it as a controller for the other 50 Timelines.
-# So, Instead of updating and adding 50 timelines to the ``scene``, we only
-# need to update the main ``Timeline``. Also, a playback panel can be assigned
-# to this main Timeline.
-# But, why we need 50 ``Timelines``, you may ask.
-# -> A single ``Timeline`` can handle each property once at a time. So we need
-# 50 ``Timelines`` to translate and scale our 50 spheres.
+# Here we create a ``Timeline``. so that we can use it as a controller for the
+# 50 animations we will create.
+# So, Instead of updating and adding 50 Animations to the ``ShowManager``,
+# we only need to update the main ``Timeline``. Also, a playback panel can be
+# assigned to this main Timeline.
+#
+# But, why we need 50 ``Animations``, you may ask.
+# -> A single ``Animation`` can handle each property once at a time. So we need
+# 50 ``Animations`` to translate and scale our 50 spheres.
 
 ###############################################################################
 # ``playback_panel=True`` assigns a playback panel that can control the
-# playback of this ``main_timeline`` and all of its children ``Timelines``
+# playback of its ``Animations``
 
-main_timeline = Timeline(playback_panel=True)
+timeline = Timeline(playback_panel=True)
 
 ###############################################################################
 # Creating two actors for visualization, and to detect camera's animations.
@@ -51,13 +52,6 @@
 plan = actor.box(np.array([[0, 0, 0]]), colors=np.array([[1, 1, 1]]),
                  scales=np.array([[20, 0.2, 20]]))
 
-###############################################################################
-# adding static actors to the timeline.
-# Note: adding actors as static actors just ensures that they get added to the
-# scene along with the Timeline and will not be controlled nor animated by the
-# timeline.
-main_timeline.add_static_actor([arrow, plan])
-
 ###############################################################################
 # Creating "FURY" text
 # ====================
@@ -66,18 +60,18 @@
                               scale=(2, 2, 2))
 
 ###############################################################################
-# Creating a ``Timeline`` to animate the opacity of ``fury_text``
-text_timeline = Timeline(fury_text)
+# Creating an ``Animation`` to animate the opacity of ``fury_text``
+text_anim = Animation(fury_text, loop=False)
 
 ###############################################################################
 # opacity is set to 0 at time 28 and set to one at time 31.
 # Linear interpolator is always used by default.
-text_timeline.set_opacity(29, 0)
-text_timeline.set_opacity(35, 1)
+text_anim.set_opacity(29, 0)
+text_anim.set_opacity(35, 1)
 
 ###############################################################################
-# ``text_timeline`` contains the text actor is added to the main Timeline.
-main_timeline.add_child_timeline(text_timeline)
+# ``text_anim`` contains the text actor is added to the Timeline.
+timeline.add_animation(text_anim)
 
 ###############################################################################
 # Creating and animating 50 Spheres
@@ -95,37 +89,41 @@
     ###########################################################################
     # create a timeline to animate this actor (single actor or list of actors)
     # Actors can be added later using `Timeline.add_actor(actor)`
-    timeline = Timeline(actors)
+    animation = Animation(actors)
 
     # We generate random position and scale values from time=0 to time=49 each
     # two seconds.
     for t in range(0, 50, 2):
         #######################################################################
         # Position and scale are set to a random value at the timestamps
         # mentioned above.
-        timeline.set_position(t,
-                              np.random.random(3) * 30 - np.array([15, 0, 15]))
-        timeline.set_scale(t, np.repeat(np.random.random(1), 3))
+        animation.set_position(t,
+                               np.random.random(3) * 30 - np.array(
+                                   [15, 0, 15]))
+        animation.set_scale(t, np.repeat(np.random.random(1), 3))
 
     ###########################################################################
     # change the position interpolator to cubic spline interpolator.
-    timeline.set_position_interpolator(cubic_spline_interpolator)
+    animation.set_position_interpolator(cubic_spline_interpolator)
 
     ###########################################################################
-    # Finally, the ``Timeline`` is added to the ``main_timeline``.
-    main_timeline.add_child_timeline(timeline)
+    # Finally, the ``Animation`` is added to the ``Timeline``.
+    timeline.add_animation(animation)
 
 ###############################################################################
 # Animating the camera
 # ====================
 #
 # Since, only one camera is needed, camera animations are preferably done using
-# the main `Timeline`. Three properties can control the camera's animation:
+# a seperate ``Animation``.
+# Three properties can control the camera's animation:
 # Position, focal position (referred to by `focal`), and up-view.
 
+camera_anim = CameraAnimation(loop=False)
+timeline.add_animation(camera_anim)
+
 ###############################################################################
 # Multiple keyframes can be set at once as follows.
-
 # camera focal positions
 camera_positions = {
     # time: camera position
@@ -151,35 +149,24 @@
 ###############################################################################
 # ``set_camera_focal`` can only set one keyframeB , but
 # ``set_camera_focal_keyframes`` can set a dictionary of keyframes.
-main_timeline.set_camera_focal_keyframes(camera_focal_positions)
-main_timeline.set_camera_position_keyframes(camera_positions)
+camera_anim.set_focal_keyframes(camera_focal_positions)
+camera_anim.set_position_keyframes(camera_positions)
 
 ###############################################################################
 # Change camera position and focal interpolators
-main_timeline.set_camera_position_interpolator(cubic_spline_interpolator)
-main_timeline.set_camera_focal_interpolator(cubic_spline_interpolator)
+camera_anim.set_position_interpolator(cubic_spline_interpolator)
+camera_anim.set_focal_interpolator(cubic_spline_interpolator)
 
 ###############################################################################
-# Only the main Timeline is added to the scene.
-scene.add(main_timeline)
-
+# Adding non-animatable actors to the scene.
+scene.add(arrow, plan)
 
 ###############################################################################
-# making a function to update the animation
-def timer_callback(_obj, _event):
-    ###########################################################################
-    # Only the main timeline is needed to be updated, and it would update all
-    # children ``Timelines``.
-    main_timeline.update_animation()
-
-    ###########################################################################
-    # The scene is rendered after the animations are updated.
-    showm.render()
-
+# Adding the timeline to the ShowManager.
+showm.add_animation(timeline)
 
 ###############################################################################
-# Adding the callback function that updates the animation
-showm.add_timer_callback(True, 10, timer_callback)
+# The ShowManager must go on!
 
 interactive = False