manim 0.17.0__py3-none-any.whl → 0.19.1__py3-none-any.whl

manim/renderer/opengl_renderer_window.py

@@ -1,12 +1,19 @@
 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"]
+
 
 class Window(PygletWindow):
     fullscreen = False
@@ -15,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
@@ -33,8 +44,13 @@ class Window(PygletWindow):
                 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)
 
@@ -53,13 +69,13 @@ class Window(PygletWindow):
         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(
@@ -69,28 +85,32 @@ class Window(PygletWindow):
         )
         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.",
@@ -103,20 +123,21 @@ class Window(PygletWindow):
         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/shader.py

@@ -1,19 +1,33 @@
 from __future__ import annotations
 
+import contextlib
+import inspect
 import re
 import textwrap
+from collections.abc import Callable, Iterator, Sequence
 from pathlib import Path
+from typing import TYPE_CHECKING, Any
 
 import moderngl
 import numpy as np
+import numpy.typing as npt
+from typing_extensions import Self, TypeAlias
+
+if TYPE_CHECKING:
+    from manim.renderer.opengl_renderer import OpenGLRenderer
+
+    MeshTimeBasedUpdater: TypeAlias = Callable[["Object3D", float], None]
+    MeshNonTimeBasedUpdater: TypeAlias = Callable[["Object3D"], None]
+    MeshUpdater: TypeAlias = MeshNonTimeBasedUpdater | MeshTimeBasedUpdater
+
+from manim.typing import MatrixMN, Point3D
 
 from .. import config
 from ..utils import opengl
-from ..utils.simple_functions import get_parameters
 
 SHADER_FOLDER = Path(__file__).parent / "shaders"
-shader_program_cache: dict = {}
-file_path_to_code_map: dict = {}
+shader_program_cache: dict[str, moderngl.Program] = {}
+file_path_to_code_map: dict[Path, str] = {}
 
 __all__ = [
     "Object3D",
@@ -42,7 +56,9 @@ def get_shader_code_from_file(file_path: Path) -> str:
     return source
 
 
-def filter_attributes(unfiltered_attributes, attributes):
+def filter_attributes(
+    unfiltered_attributes: npt.NDArray, attributes: Sequence[str]
+) -> npt.NDArray:
     # Construct attributes for only those needed by the shader.
     filtered_attributes_dtype = []
     for i, dtype_name in enumerate(unfiltered_attributes.dtype.names):
@@ -68,28 +84,28 @@ def filter_attributes(unfiltered_attributes, attributes):
 
 
 class Object3D:
-    def __init__(self, *children):
+    def __init__(self, *children: Object3D):
         self.model_matrix = np.eye(4)
         self.normal_matrix = np.eye(4)
-        self.children = []
-        self.parent = None
+        self.children: list[Object3D] = []
+        self.parent: Object3D | None = None
         self.add(*children)
         self.init_updaters()
 
     # TODO: Use path_func.
-    def interpolate(self, start, end, alpha, _):
+    def interpolate(self, start: Object3D, end: Object3D, alpha: float, _: Any) -> None:
         self.model_matrix = (1 - alpha) * start.model_matrix + alpha * end.model_matrix
         self.normal_matrix = (
             1 - alpha
         ) * start.normal_matrix + alpha * end.normal_matrix
 
-    def single_copy(self):
+    def single_copy(self) -> Object3D:
         copy = Object3D()
         copy.model_matrix = self.model_matrix.copy()
         copy.normal_matrix = self.normal_matrix.copy()
         return copy
 
-    def copy(self):
+    def copy(self) -> Object3D:
         node_to_copy = {}
 
         bfs = [self]
@@ -105,7 +121,7 @@ class Object3D:
                 node_to_copy[node.parent].add(node_copy)
         return node_to_copy[self]
 
-    def add(self, *children):
+    def add(self, *children: Object3D) -> None:
         for child in children:
             if child.parent is not None:
                 raise Exception(
@@ -116,7 +132,7 @@ class Object3D:
         for child in children:
             child.parent = self
 
-    def remove(self, *children, current_children_only=True):
+    def remove(self, *children: Object3D, current_children_only: bool = True) -> None:
         if current_children_only:
             for child in children:
                 if child.parent != self:
@@ -127,14 +143,14 @@ class Object3D:
         for child in children:
             child.parent = None
 
-    def get_position(self):
+    def get_position(self) -> Point3D:
         return self.model_matrix[:, 3][:3]
 
-    def set_position(self, position):
+    def set_position(self, position: Point3D) -> Self:
         self.model_matrix[:, 3][:3] = position
         return self
 
-    def get_meshes(self):
+    def get_meshes(self) -> Iterator[Mesh]:
         dfs = [self]
         while dfs:
             parent = dfs.pop()
@@ -142,17 +158,17 @@ class Object3D:
                 yield parent
             dfs.extend(parent.children)
 
-    def get_family(self):
+    def get_family(self) -> Iterator[Object3D]:
         dfs = [self]
         while dfs:
             parent = dfs.pop()
             yield parent
             dfs.extend(parent.children)
 
-    def align_data_and_family(self, _):
+    def align_data_and_family(self, _: Any) -> None:
         pass
 
-    def hierarchical_model_matrix(self):
+    def hierarchical_model_matrix(self) -> MatrixMN:
         if self.parent is None:
             return self.model_matrix
 
@@ -163,7 +179,7 @@ class Object3D:
             current_object = current_object.parent
         return np.linalg.multi_dot(list(reversed(model_matrices)))
 
-    def hierarchical_normal_matrix(self):
+    def hierarchical_normal_matrix(self) -> MatrixMN:
         if self.parent is None:
             return self.normal_matrix[:3, :3]
 
@@ -174,76 +190,93 @@ class Object3D:
             current_object = current_object.parent
         return np.linalg.multi_dot(list(reversed(normal_matrices)))[:3, :3]
 
-    def init_updaters(self):
-        self.time_based_updaters = []
-        self.non_time_updaters = []
+    def init_updaters(self) -> None:
+        self.time_based_updaters: list[MeshTimeBasedUpdater] = []
+        self.non_time_updaters: list[MeshNonTimeBasedUpdater] = []
         self.has_updaters = False
         self.updating_suspended = False
 
-    def update(self, dt=0):
+    def update(self, dt: float = 0) -> Self:
         if not self.has_updaters or self.updating_suspended:
             return self
-        for updater in self.time_based_updaters:
-            updater(self, dt)
-        for updater in self.non_time_updaters:
-            updater(self)
+        for time_based_updater in self.time_based_updaters:
+            time_based_updater(self, dt)
+        for non_time_based_updater in self.non_time_updaters:
+            non_time_based_updater(self)
         return self
 
-    def get_time_based_updaters(self):
+    def get_time_based_updaters(self) -> list[MeshTimeBasedUpdater]:
         return self.time_based_updaters
 
-    def has_time_based_updater(self):
+    def has_time_based_updater(self) -> bool:
         return len(self.time_based_updaters) > 0
 
-    def get_updaters(self):
+    def get_updaters(self) -> list[MeshUpdater]:
         return self.time_based_updaters + self.non_time_updaters
 
-    def add_updater(self, update_function, index=None, call_updater=True):
-        if "dt" in get_parameters(update_function):
-            updater_list = self.time_based_updaters
-        else:
-            updater_list = self.non_time_updaters
-
-        if index is None:
-            updater_list.append(update_function)
+    def add_updater(
+        self,
+        update_function: MeshUpdater,
+        index: int | None = None,
+        call_updater: bool = True,
+    ) -> Self:
+        if "dt" in inspect.signature(update_function).parameters:
+            self._add_time_based_updater(update_function, index)  # type: ignore[arg-type]
         else:
-            updater_list.insert(index, update_function)
+            self._add_non_time_updater(update_function, index)  # type: ignore[arg-type]
 
         self.refresh_has_updater_status()
         if call_updater:
             self.update()
         return self
 
-    def remove_updater(self, update_function):
-        for updater_list in [self.time_based_updaters, self.non_time_updaters]:
-            while update_function in updater_list:
-                updater_list.remove(update_function)
+    def _add_time_based_updater(
+        self, update_function: MeshTimeBasedUpdater, index: int | None = None
+    ) -> None:
+        if index is None:
+            self.time_based_updaters.append(update_function)
+        else:
+            self.time_based_updaters.insert(index, update_function)
+
+    def _add_non_time_updater(
+        self, update_function: MeshNonTimeBasedUpdater, index: int | None = None
+    ) -> None:
+        if index is None:
+            self.non_time_updaters.append(update_function)
+        else:
+            self.non_time_updaters.insert(index, update_function)
+
+    def remove_updater(self, update_function: MeshUpdater) -> Self:
+        while update_function in self.time_based_updaters:
+            self.time_based_updaters.remove(update_function)  # type: ignore[arg-type]
+        while update_function in self.non_time_updaters:
+            self.non_time_updaters.remove(update_function)  # type: ignore[arg-type]
         self.refresh_has_updater_status()
         return self
 
-    def clear_updaters(self):
+    def clear_updaters(self) -> Self:
         self.time_based_updaters = []
         self.non_time_updaters = []
         self.refresh_has_updater_status()
         return self
 
-    def match_updaters(self, mobject):
+    def match_updaters(self, mesh: Object3D) -> Self:
         self.clear_updaters()
-        for updater in mobject.get_updaters():
+        for updater in mesh.get_updaters():
             self.add_updater(updater)
         return self
 
-    def suspend_updating(self):
+    def suspend_updating(self) -> Self:
         self.updating_suspended = True
         return self
 
-    def resume_updating(self, call_updater=True):
+    def resume_updating(self, call_updater: bool = True) -> Self:
         self.updating_suspended = False
         if call_updater:
             self.update(dt=0)
         return self
 
-    def refresh_has_updater_status(self):
+    def refresh_has_updater_status(self) -> Self:
         self.has_updaters = len(self.get_updaters()) > 0
         return self
 
@@ -251,23 +284,23 @@ class Object3D:
 class Mesh(Object3D):
     def __init__(
         self,
-        shader=None,
-        attributes=None,
-        geometry=None,
-        material=None,
-        indices=None,
-        use_depth_test=True,
-        primitive=moderngl.TRIANGLES,
+        shader: Shader | None = None,
+        attributes: npt.NDArray | None = None,
+        geometry: Mesh | None = None,
+        material: Shader | None = None,
+        indices: npt.NDArray | None = None,
+        use_depth_test: bool = True,
+        primitive: int = moderngl.TRIANGLES,
     ):
         super().__init__()
         if shader is not None and attributes is not None:
-            self.shader = shader
+            self.shader: Shader = shader
             self.attributes = attributes
             self.indices = indices
         elif geometry is not None and material is not None:
             self.shader = material
             self.attributes = geometry.attributes
-            self.indices = geometry.index
+            self.indices = geometry.indices
         else:
             raise Exception(
                 "Mesh requires either attributes and a Shader or a Geometry and a "
@@ -275,10 +308,10 @@ class Mesh(Object3D):
             )
         self.use_depth_test = use_depth_test
         self.primitive = primitive
-        self.skip_render = False
+        self.skip_render: bool = False
         self.init_updaters()
 
-    def single_copy(self):
+    def single_copy(self) -> Mesh:
         copy = Mesh(
             attributes=self.attributes.copy(),
             shader=self.shader,
@@ -292,7 +325,7 @@ class Mesh(Object3D):
         # TODO: Copy updaters?
         return copy
 
-    def set_uniforms(self, renderer):
+    def set_uniforms(self, renderer: OpenGLRenderer) -> None:
         self.shader.set_uniform(
             "u_model_matrix",
             opengl.matrix_to_shader_input(self.model_matrix),
@@ -303,7 +336,7 @@ class Mesh(Object3D):
             renderer.camera.projection_matrix,
         )
 
-    def render(self):
+    def render(self) -> None:
         if self.skip_render:
             return
 
@@ -312,15 +345,17 @@ class Mesh(Object3D):
         else:
             self.shader.context.disable(moderngl.DEPTH_TEST)
 
-        from moderngl.program_members import Attribute
-
-        shader_attributes = []
-        for k, v in self.shader.shader_program._members.items():
-            if isinstance(v, Attribute):
-                shader_attributes.append(k)
-        shader_attributes = filter_attributes(self.attributes, shader_attributes)
+        shader_attribute_names: list[str] = []
+        for member_name, member in self.shader.shader_program._members.items():
+            if isinstance(member, moderngl.Attribute):
+                shader_attribute_names.append(member_name)
+        filtered_shader_attributes = filter_attributes(
+            self.attributes, shader_attribute_names
+        )
 
-        vertex_buffer_object = self.shader.context.buffer(shader_attributes.tobytes())
+        vertex_buffer_object = self.shader.context.buffer(
+            filtered_shader_attributes.tobytes()
+        )
         if self.indices is None:
             index_buffer_object = None
         else:
@@ -332,7 +367,7 @@ class Mesh(Object3D):
         vertex_array_object = self.shader.context.simple_vertex_array(
             self.shader.shader_program,
             vertex_buffer_object,
-            *shader_attributes.dtype.names,
+            *filtered_shader_attributes.dtype.names,
             index_buffer=index_buffer_object,
         )
         vertex_array_object.render(self.primitive)
@@ -345,13 +380,14 @@ class Mesh(Object3D):
 class Shader:
     def __init__(
         self,
-        context,
-        name=None,
-        source=None,
+        context: moderngl.Context,
+        name: str | None = None,
+        source: dict[str, Any] | None = None,
     ):
         global shader_program_cache
         self.context = context
         self.name = name
+        self.source = source
 
         # See if the program is cached.
         if (
@@ -359,10 +395,10 @@ class Shader:
             and shader_program_cache[self.name].ctx == self.context
         ):
             self.shader_program = shader_program_cache[self.name]
-        elif source is not None:
+        elif self.source is not None:
             # Generate the shader from inline code if it was passed.
-            self.shader_program = context.program(**source)
-        else:
+            self.shader_program = context.program(**self.source)
+        elif self.name is not None:
             # Search for a file containing the shader.
             source_dict = {}
             source_dict_key = {
@@ -370,30 +406,30 @@ class Shader:
                 "frag": "fragment_shader",
                 "geom": "geometry_shader",
             }
-            shader_folder = SHADER_FOLDER / name
+            shader_folder = SHADER_FOLDER / self.name
             for shader_file in shader_folder.iterdir():
                 shader_file_path = shader_folder / shader_file
                 shader_source = get_shader_code_from_file(shader_file_path)
                 source_dict[source_dict_key[shader_file_path.stem]] = shader_source
             self.shader_program = context.program(**source_dict)
+        else:
+            raise Exception("Must either pass shader name or shader source.")
 
         # Cache the shader.
-        if name is not None and name not in shader_program_cache:
+        if self.name is not None and self.name not in shader_program_cache:
             shader_program_cache[self.name] = self.shader_program
 
-    def set_uniform(self, name, value):
-        try:
+    def set_uniform(self, name: str, value: Any) -> None:
+        with contextlib.suppress(KeyError):
             self.shader_program[name] = value
-        except KeyError:
-            pass
 
 
 class FullScreenQuad(Mesh):
     def __init__(
         self,
-        context,
-        fragment_shader_source=None,
-        fragment_shader_name=None,
+        context: moderngl.Context,
+        fragment_shader_source: str | None = None,
+        fragment_shader_name: str | None = None,
     ):
         if fragment_shader_source is None and fragment_shader_name is None:
             raise Exception("Must either pass shader name or shader source.")
@@ -440,5 +476,5 @@ class FullScreenQuad(Mesh):
         )
         super().__init__(shader, attributes)
 
-    def render(self):
+    def render(self) -> None:
         super().render()