Typing opengl_renderer_window.py (#4363)

Co-authored-by: Francisco Manríquez Novoa <[email protected]>
Co-authored-by: Francisco Manríquez <[email protected]>
Co-authored-by: Benjamin Hackl <[email protected]>

Author: 3 people

manim/_config/utils.py

@@ -1418,7 +1418,7 @@ def window_position(self, value: str) -> None:
 
     @property
     def window_size(self) -> str:
-        """The size of the opengl window. 'default' to automatically scale the window based on the display monitor."""
+        """The size of the opengl window as 'width,height' or 'default' to automatically scale the window based on the display monitor."""
         return self._d["window_size"]
 
     @window_size.setter

manim/renderer/opengl_renderer.py

@@ -45,6 +45,7 @@
     from manim.animation.animation import Animation
     from manim.mobject.mobject import Mobject
     from manim.scene.scene import Scene
+    from manim.typing import Point3D
 
 
 __all__ = ["OpenGLCamera", "OpenGLRenderer"]
@@ -248,45 +249,46 @@ def __init__(
         self.camera = OpenGLCamera()
         self.pressed_keys = set()
 
+        self.window = None
+
         # Initialize texture map.
         self.path_to_texture_id = {}
 
         self.background_color = config["background_color"]
 
-    def init_scene(self, scene):
+    def init_scene(self, scene: Scene) -> None:
         self.partial_movie_files = []
         self.file_writer: Any = self._file_writer_class(
             self,
             scene.__class__.__name__,
         )
         self.scene = scene
         self.background_color = config["background_color"]
-        if not hasattr(self, "window"):
-            if self.should_create_window():
-                from .opengl_renderer_window import Window
+        if self.should_create_window():
+            from .opengl_renderer_window import Window
 
-                self.window = Window(self)
-                self.context = self.window.ctx
-                self.frame_buffer_object = self.context.detect_framebuffer()
-            else:
-                self.window = None
-                try:
-                    self.context = moderngl.create_context(standalone=True)
-                except Exception:
-                    self.context = moderngl.create_context(
-                        standalone=True,
-                        backend="egl",
-                    )
-                self.frame_buffer_object = self.get_frame_buffer_object(self.context, 0)
-                self.frame_buffer_object.use()
-            self.context.enable(moderngl.BLEND)
-            self.context.wireframe = config["enable_wireframe"]
-            self.context.blend_func = (
-                moderngl.SRC_ALPHA,
-                moderngl.ONE_MINUS_SRC_ALPHA,
-                moderngl.ONE,
-                moderngl.ONE,
-            )
+            self.window = Window(self)
+            self.context = self.window.ctx
+            self.frame_buffer_object = self.context.detect_framebuffer()
+        else:
+            # self.window = None
+            try:
+                self.context = moderngl.create_context(standalone=True)
+            except Exception:
+                self.context = moderngl.create_context(
+                    standalone=True,
+                    backend="egl",
+                )
+            self.frame_buffer_object = self.get_frame_buffer_object(self.context, 0)
+            self.frame_buffer_object.use()
+        self.context.enable(moderngl.BLEND)
+        self.context.wireframe = config["enable_wireframe"]
+        self.context.blend_func = (
+            moderngl.SRC_ALPHA,
+            moderngl.ONE_MINUS_SRC_ALPHA,
+            moderngl.ONE,
+            moderngl.ONE,
+        )
 
     def should_create_window(self):
         if config["force_window"]:
@@ -585,7 +587,9 @@ def get_frame(self):
     # Returns offset from the bottom left corner in pixels.
     # top_left flag should be set to True when using a GUI framework
     # where the (0,0) is at the top left: e.g. PySide6
-    def pixel_coords_to_space_coords(self, px, py, relative=False, top_left=False):
+    def pixel_coords_to_space_coords(
+        self, px: float, py: float, relative: bool = False, top_left: bool = False
+    ) -> Point3D:
         pixel_shape = self.get_pixel_shape()
         if pixel_shape is None:
             return np.array([0, 0, 0])

manim/renderer/opengl_renderer_window.py

@@ -1,12 +1,17 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING, Any
+
 import moderngl_window as mglw
 from moderngl_window.context.pyglet.window import Window as PygletWindow
 from moderngl_window.timers.clock import Timer
-from screeninfo import get_monitors
+from screeninfo import Monitor, get_monitors
 
 from .. import __version__, config
 
+if TYPE_CHECKING:
+    from .opengl_renderer import OpenGLRenderer
+
 __all__ = ["Window"]
 
 
@@ -17,15 +22,19 @@ class Window(PygletWindow):
     vsync = True
     cursor = True
 
-    def __init__(self, renderer, size=config.window_size, **kwargs):
+    def __init__(
+        self,
+        renderer: OpenGLRenderer,
+        window_size: str = config.window_size,
+        **kwargs: Any,
+    ) -> None:
         monitors = get_monitors()
         mon_index = config.window_monitor
         monitor = monitors[min(mon_index, len(monitors) - 1)]
 
-        if size == "default":
+        if window_size == "default":
             # make window_width half the width of the monitor
             # but make it full screen if --fullscreen
-
             window_width = monitor.width
             if not config.fullscreen:
                 window_width //= 2
@@ -35,8 +44,13 @@ def __init__(self, renderer, size=config.window_size, **kwargs):
                 window_width * config.frame_height // config.frame_width,
             )
             size = (window_width, window_height)
+        elif len(window_size.split(",")) == 2:
+            (window_width, window_height) = tuple(map(int, window_size.split(",")))
+            size = (window_width, window_height)
         else:
-            size = tuple(size)
+            raise ValueError(
+                "Window_size must be specified as 'width,height' or 'default'.",
+            )
 
         super().__init__(size=size)
 
@@ -55,13 +69,13 @@ def __init__(self, renderer, size=config.window_size, **kwargs):
         self.position = initial_position
 
     # Delegate event handling to scene.
-    def on_mouse_motion(self, x, y, dx, dy):
+    def on_mouse_motion(self, x: int, y: int, dx: int, dy: int) -> None:
         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):
+    def on_mouse_scroll(self, x: int, y: int, x_offset: float, y_offset: float) -> None:
         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(
@@ -71,28 +85,32 @@ def on_mouse_scroll(self, x, y, x_offset: float, y_offset: float):
         )
         self.renderer.scene.on_mouse_scroll(point, offset)
 
-    def on_key_press(self, symbol, modifiers):
+    def on_key_press(self, symbol: int, modifiers: int) -> bool:
         self.renderer.pressed_keys.add(symbol)
-        super().on_key_press(symbol, modifiers)
+        event_handled: bool = super().on_key_press(symbol, modifiers)
         self.renderer.scene.on_key_press(symbol, modifiers)
+        return event_handled
 
-    def on_key_release(self, symbol, modifiers):
+    def on_key_release(self, symbol: int, modifiers: int) -> None:
         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):
+    def on_mouse_drag(
+        self, x: int, y: int, dx: int, dy: int, buttons: int, modifiers: int
+    ) -> None:
         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)
 
-    def find_initial_position(self, size, monitor):
+    def find_initial_position(
+        self, size: tuple[int, int], monitor: Monitor
+    ) -> tuple[int, int]:
         custom_position = config.window_position
         window_width, window_height = size
-        # Position might be specified with a string of the form
-        # x,y for integers x and y
+        # Position might be specified with a string of the form x,y for integers x and y
         if len(custom_position) == 1:
             raise ValueError(
                 "window_position must specify both Y and X positions (Y/X -> UR). Also accepts LEFT/RIGHT/ORIGIN/UP/DOWN.",
@@ -105,20 +123,21 @@ def find_initial_position(self, size, monitor):
         elif custom_position == "ORIGIN":
             custom_position = "O" * 2
         elif "," in custom_position:
-            return tuple(map(int, custom_position.split(",")))
+            pos_y, pos_x = tuple(map(int, custom_position.split(",")))
+            return (pos_x, pos_y)
 
         # Alternatively, it might be specified with a string like
         # UR, OO, DL, etc. specifying what corner it should go to
         char_to_n = {"L": 0, "U": 0, "O": 1, "R": 2, "D": 2}
-        width_diff = monitor.width - window_width
-        height_diff = monitor.height - window_height
+        width_diff: int = monitor.width - window_width
+        height_diff: int = monitor.height - window_height
 
         return (
             monitor.x + char_to_n[custom_position[1]] * width_diff // 2,
             -monitor.y + char_to_n[custom_position[0]] * height_diff // 2,
         )
 
-    def on_mouse_press(self, x, y, button, modifiers):
+    def on_mouse_press(self, x: int, y: int, button: int, modifiers: int) -> None:
         super().on_mouse_press(x, y, button, modifiers)
         point = self.renderer.pixel_coords_to_space_coords(x, y)
         mouse_button_map = {

manim/renderer/vectorized_mobject_rendering.py

@@ -101,7 +101,7 @@ def render_mobject_fills_with_matrix(
     )
     fill_shader.set_uniform(
         "u_projection_matrix",
-        renderer.scene.camera.projection_matrix,
+        renderer.camera.projection_matrix,
     )
 
     vbo = renderer.context.buffer(attributes.tobytes())
@@ -302,7 +302,7 @@ def render_mobject_strokes_with_matrix(
             renderer.camera.unformatted_view_matrix @ model_matrix,
         ),
     )
-    shader.set_uniform("u_projection_matrix", renderer.scene.camera.projection_matrix)
+    shader.set_uniform("u_projection_matrix", renderer.camera.projection_matrix)
     shader.set_uniform("manim_unit_normal", tuple(-mobjects[0].unit_normal[0]))
 
     vbo = renderer.context.buffer(stroke_data.tobytes())

manim/scene/scene.py

@@ -1489,7 +1489,10 @@ def interact(self, shell: Any, keyboard_thread: threading.Thread) -> None:
         assert self.queue.qsize() == 0
 
         last_time = time.time()
-        while not (self.renderer.window.is_closing or self.quit_interaction):
+        while not (
+            (self.renderer.window is not None and self.renderer.window.is_closing)
+            or self.quit_interaction
+        ):
             if not self.queue.empty():
                 action = self.queue.get_nowait()
                 if isinstance(action, SceneInteractRerun):
@@ -1550,7 +1553,7 @@ def interact(self, shell: Any, keyboard_thread: threading.Thread) -> None:
         if self.dearpygui_imported and config["enable_gui"]:
             dpg.stop_dearpygui()
 
-        if self.renderer.window.is_closing:
+        if self.renderer.window is not None and self.renderer.window.is_closing:
             self.renderer.window.destroy()
 
     def embed(self) -> None:
@@ -1924,6 +1927,6 @@ def mouse_drag_orbit_controls(
     def set_key_function(self, char: str, func: Callable[[], Any]) -> None:
         self.key_to_function_map[char] = func
 
-    def on_mouse_press(self, point: Point3D, button: int, modifiers: int) -> None:
+    def on_mouse_press(self, point: Point3D, button: str, modifiers: int) -> None:
         for func in self.mouse_press_callbacks:
             func()

mypy.ini

@@ -138,9 +138,6 @@ ignore_errors = True
 [mypy-manim.renderer.opengl_renderer]
 ignore_errors = True
 
-[mypy-manim.renderer.opengl_renderer_window]
-ignore_errors = True
-
 [mypy-manim.renderer.shader_wrapper]
 ignore_errors = True