Merge pull request #1113 from eulertour/moderngl-interaction

Add interaction to the OpenGL renderer

Author: eulertour

manim/constants.py

@@ -177,3 +177,5 @@
 
 DEFAULT_QUALITY: str = "high_quality"
 DEFAULT_QUALITY_SHORT = QUALITIES[DEFAULT_QUALITY]["flag"]
+SHIFT_VALUE = 65505
+CTRL_VALUE = 65507

manim/renderer/opengl_renderer.py

@@ -91,12 +91,10 @@ def refresh_rotation_matrix(self):
             quaternion_from_angle_axis(phi, RIGHT, axis_normalized=True),
             quaternion_from_angle_axis(gamma, OUT, axis_normalized=True),
         )
-        self.inverse_camera_rotation_matrix = rotation_matrix_transpose_from_quaternion(
-            quat
-        )
+        self.inverse_rotation_matrix = rotation_matrix_transpose_from_quaternion(quat)
 
     def rotate(self, angle, axis=OUT, **kwargs):
-        curr_rot_T = self.inverse_camera_rotation_matrix
+        curr_rot_T = self.inverse_rotation_matrix
         added_rot_T = rotation_matrix_transpose(angle, axis)
         new_rot_T = np.dot(curr_rot_T, added_rot_T)
         Fz = new_rot_T[2]
@@ -182,22 +180,33 @@ class OpenGLRenderer:
     def __init__(self):
         # Measured in pixel widths, used for vector graphics
         self.anti_alias_width = 1.5
-
         self.num_plays = 0
         self.skip_animations = False
-
         self.camera = OpenGLCamera()
+        self.pressed_keys = set()
+
+        # Initialize shader map.
+        self.id_to_shader_program = {}
+
+        # Initialize texture map.
+        self.path_to_texture_id = {}
 
+    def init_scene(self, scene):
+        self.partial_movie_files = []
+        self.file_writer = SceneFileWriter(
+            self,
+            scene.__class__.__name__,
+        )
+        self.scene = scene
         if config["preview"]:
-            self.window = Window()
+            self.window = Window(self)
             self.context = self.window.ctx
             self.frame_buffer_object = self.context.detect_framebuffer()
         else:
             self.window = None
             self.context = moderngl.create_standalone_context()
             self.frame_buffer_object = self.get_frame_buffer_object(self.context, 0)
             self.frame_buffer_object.use()
-
         self.context.enable(moderngl.BLEND)
         self.context.blend_func = (
             moderngl.SRC_ALPHA,
@@ -206,14 +215,6 @@ def __init__(self):
             moderngl.ONE,
         )
 
-        # Initialize shader map.
-        self.id_to_shader_program = {}
-
-        # Initialize texture map.
-        self.path_to_texture_id = {}
-
-        self.partial_movie_files = []
-
     def update_depth_test(self, context, shader_wrapper):
         if shader_wrapper.depth_test:
             self.context.enable(moderngl.DEPTH_TEST)
@@ -223,24 +224,24 @@ def update_depth_test(self, context, shader_wrapper):
     def get_pixel_shape(self):
         return self.frame_buffer_object.viewport[2:4]
 
-    def refresh_perspective_uniforms(self, camera_frame):
+    def refresh_perspective_uniforms(self, camera):
         pw, ph = self.get_pixel_shape()
-        fw, fh = camera_frame.get_shape()
+        fw, fh = camera.get_shape()
         # TODO, this should probably be a mobject uniform, with
         # the camera taking care of the conversion factor
         anti_alias_width = self.anti_alias_width / (ph / fh)
         # Orient light
-        rotation = camera_frame.inverse_camera_rotation_matrix
-        light_pos = camera_frame.light_source.get_location()
+        rotation = camera.inverse_rotation_matrix
+        light_pos = camera.light_source.get_location()
         light_pos = np.dot(rotation, light_pos)
 
         self.perspective_uniforms = {
-            "frame_shape": camera_frame.get_shape(),
+            "frame_shape": camera.get_shape(),
             "anti_alias_width": anti_alias_width,
-            "camera_center": tuple(camera_frame.get_center()),
+            "camera_center": tuple(camera.get_center()),
             "camera_rotation": tuple(np.array(rotation).T.flatten()),
             "light_source_position": tuple(light_pos),
-            "focal_distance": camera_frame.get_focal_distance(),
+            "focal_distance": camera.get_focal_distance(),
         }
 
     def render_mobjects(self, mobs):
@@ -347,12 +348,6 @@ def set_shader_uniforms(self, shader, shader_wrapper):
             except KeyError:
                 pass
 
-    def init_scene(self, scene):
-        self.file_writer = SceneFileWriter(
-            self,
-            scene.__class__.__name__,
-        )
-
     def play(self, scene, *args, **kwargs):
         if len(args) == 0:
             logger.warning("Called Scene.play with no animations")
@@ -389,7 +384,6 @@ def update_frame():
         if self.window is not None:
             self.window.swap_buffers()
             while self.animation_elapsed_time < frame_offset:
-                # TODO: Just sleep?
                 update_frame()
                 self.window.swap_buffers()
 
@@ -429,3 +423,15 @@ def get_raw_frame_buffer_object_data(self, dtype="f1"):
             dtype=dtype,
         )
         return ret
+
+    # Returns offset from the bottom left corner in pixels.
+    def pixel_coords_to_space_coords(self, px, py, relative=False):
+        pw, ph = config["pixel_width"], config["pixel_height"]
+        fw, fh = config["frame_width"], config["frame_height"]
+        fc = self.camera.get_center()
+        if relative:
+            return 2 * np.array([px / pw, py / ph, 0])
+        else:
+            # Only scale wrt one axis
+            scale = fh / ph
+            return fc + scale * np.array([(px - pw / 2), (py - ph / 2), 0])

manim/renderer/opengl_renderer_window.py

@@ -11,19 +11,50 @@ class Window(PygletWindow):
     vsync = True
     cursor = True
 
-    def __init__(self, size=None, **kwargs):
+    def __init__(self, renderer, size=None, **kwargs):
         if size is None:
             size = (config["pixel_width"], config["pixel_height"])
         super().__init__(size=size)
 
-        self.pressed_keys = set()
-
         self.title = f"Manim Community {__version__}"
         self.size = size
+        self.renderer = renderer
 
         mglw.activate_context(window=self)
         self.timer = Timer()
         self.config = mglw.WindowConfig(ctx=self.ctx, wnd=self, timer=self.timer)
         self.timer.start()
 
         self.swap_buffers()
+
+    # Delegate event handling to scene.
+    def on_mouse_motion(self, x, y, dx, dy):
+        super().on_mouse_motion(x, y, dx, dy)
+        point = self.renderer.pixel_coords_to_space_coords(x, y)
+        d_point = self.renderer.pixel_coords_to_space_coords(dx, dy, relative=True)
+        self.renderer.scene.on_mouse_motion(point, d_point)
+
+    def on_mouse_scroll(self, x, y, x_offset: float, y_offset: float):
+        super().on_mouse_scroll(x, y, x_offset, y_offset)
+        point = self.renderer.pixel_coords_to_space_coords(x, y)
+        offset = self.renderer.pixel_coords_to_space_coords(
+            x_offset, y_offset, relative=True
+        )
+        self.renderer.scene.on_mouse_scroll(point, offset)
+
+    def on_key_press(self, symbol, modifiers):
+        self.renderer.pressed_keys.add(symbol)
+        super().on_key_press(symbol, modifiers)
+        self.renderer.scene.on_key_press(symbol, modifiers)
+
+    def on_key_release(self, symbol, modifiers):
+        if symbol in self.renderer.pressed_keys:
+            self.renderer.pressed_keys.remove(symbol)
+        super().on_key_release(symbol, modifiers)
+        self.renderer.scene.on_key_release(symbol, modifiers)
+
+    def on_mouse_drag(self, x, y, dx, dy, buttons, modifiers):
+        super().on_mouse_drag(x, y, dx, dy, buttons, modifiers)
+        point = self.renderer.pixel_coords_to_space_coords(x, y)
+        d_point = self.renderer.pixel_coords_to_space_coords(dx, dy, relative=True)
+        self.renderer.scene.on_mouse_drag(point, d_point, buttons, modifiers)

manim/scene/scene.py

@@ -22,11 +22,13 @@
 from ..constants import *
 from ..container import Container
 from ..mobject.mobject import Mobject, _AnimationBuilder
+from ..mobject.opengl_mobject import OpenGLPoint
 from ..utils.iterables import list_update, list_difference_update
 from ..utils.family import extract_mobject_family_members
 from ..renderer.cairo_renderer import CairoRenderer
 from ..utils.exceptions import EndSceneEarlyException
 from ..utils.family_ops import restructure_list_to_exclude_certain_family_members
+from ..utils.space_ops import rotate_vector
 
 
 class Scene(Container):
@@ -81,6 +83,11 @@ def __init__(
         self.duration = None
         self.last_t = None
 
+        if config["use_opengl_renderer"]:
+            # Items associated with interaction
+            self.mouse_point = OpenGLPoint()
+            self.mouse_drag_point = OpenGLPoint()
+
         if renderer is None:
             self.renderer = CairoRenderer(
                 camera_class=self.camera_class,
@@ -873,6 +880,16 @@ def play_internal(self, skip_rendering=False):
             self.update_mobjects(0)
         self.renderer.static_image = None
 
+    def interact(self):
+        self.quit_interaction = False
+        while not (self.renderer.window.is_closing or self.quit_interaction):
+            self.renderer.animation_start_time = 0
+            dt = 1 / config["frame_rate"]
+            self.renderer.render(self, dt, self.moving_mobjects)
+            self.update_mobjects(dt)
+        if self.renderer.window.is_closing:
+            self.renderer.window.destroy()
+
     def embed(self):
         if not config["preview"]:
             logger.warning("Called embed() while no preview window is available.")
@@ -903,6 +920,7 @@ def embed(self):
             "wait",
             "add",
             "remove",
+            "interact",
             # "clear",
             # "save_state",
             # "restore",
@@ -950,3 +968,45 @@ def add_sound(self, sound_file, time_offset=0, gain=None, **kwargs):
             return
         time = self.renderer.time + time_offset
         self.renderer.file_writer.add_sound(sound_file, time, gain, **kwargs)
+
+    def on_mouse_motion(self, point, d_point):
+        self.mouse_point.move_to(point)
+        if SHIFT_VALUE in self.renderer.pressed_keys:
+            shift = -d_point
+            shift[0] *= self.camera.get_width() / 2
+            shift[1] *= self.camera.get_height() / 2
+            transform = self.camera.inverse_rotation_matrix
+            shift = np.dot(np.transpose(transform), shift)
+            self.camera.shift(shift)
+
+    def on_mouse_scroll(self, point, offset):
+        if CTRL_VALUE in self.renderer.pressed_keys:
+            factor = 1 + np.arctan(-20 * offset[1])
+            self.camera.scale(factor, about_point=point)
+
+        transform = self.camera.inverse_rotation_matrix
+        shift = np.dot(np.transpose(transform), offset)
+        if SHIFT_VALUE in self.renderer.pressed_keys:
+            self.camera.shift(20.0 * np.array(rotate_vector(shift, PI / 2)))
+        else:
+            self.camera.shift(20.0 * shift)
+
+    def on_key_press(self, symbol, modifiers):
+        try:
+            char = chr(symbol)
+        except OverflowError:
+            logger.warning("The value of the pressed key is too large.")
+            return
+
+        if char == "r":
+            self.camera.to_default_state()
+        elif char == "q":
+            self.quit_interaction = True
+
+    def on_key_release(self, symbol, modifiers):
+        pass
+
+    def on_mouse_drag(self, point, d_point, buttons, modifiers):
+        self.mouse_drag_point.move_to(point)
+        self.camera.increment_theta(-d_point[0])
+        self.camera.increment_phi(d_point[1])