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

manim/renderer/shader_wrapper.py

@@ -1,13 +1,19 @@
 from __future__ import annotations
 
 import copy
+import logging
 import re
+from collections.abc import Mapping, Sequence
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import moderngl
 import numpy as np
+import numpy.typing as npt
+from typing_extensions import Self, TypeAlias
 
-from .. import logger
+if TYPE_CHECKING:
+    from manim.typing import FloatRGBLike_Array
 
 # Mobjects that should be rendered with
 # the same shader will be organized and
@@ -15,6 +21,10 @@ from .. import logger
 # of a dict holding all the relevant information
 # to that shader
 
+__all__ = ["ShaderWrapper"]
+
+logger = logging.getLogger("manim")
+
 
 def get_shader_dir():
     return Path(__file__).parent / "shaders"
@@ -33,25 +43,31 @@ def find_file(file_name: Path, directories: list[Path]) -> Path:
     raise OSError(f"{file_name} not Found")
 
 
+_ShaderDType: TypeAlias = np.void
+_ShaderData: TypeAlias = npt.NDArray[_ShaderDType]
+
+
 class ShaderWrapper:
     def __init__(
         self,
-        vert_data=None,
-        vert_indices=None,
-        shader_folder=None,
-        uniforms=None,  # A dictionary mapping names of uniform variables
-        texture_paths=None,  # A dictionary mapping names to filepaths for textures.
-        depth_test=False,
-        render_primitive=moderngl.TRIANGLE_STRIP,
+        vert_data: _ShaderData = None,
+        vert_indices: Sequence[int] | None = None,
+        shader_folder: Path | str | None = None,
+        # A dictionary mapping names of uniform variables
+        uniforms: dict[str, float | tuple[float, ...]] | None = None,
+        # A dictionary mapping names to filepaths for textures.
+        texture_paths: Mapping[str, Path | str] | None = None,
+        depth_test: bool = False,
+        render_primitive: int | str = moderngl.TRIANGLE_STRIP,
     ):
-        self.vert_data = vert_data
-        self.vert_indices = vert_indices
-        self.vert_attributes = vert_data.dtype.names
-        self.shader_folder = Path(shader_folder or "")
-        self.uniforms = uniforms or {}
-        self.texture_paths = texture_paths or {}
-        self.depth_test = depth_test
-        self.render_primitive = str(render_primitive)
+        self.vert_data: _ShaderData = vert_data
+        self.vert_indices: Sequence[int] | None = vert_indices
+        self.vert_attributes: tuple[str, ...] | None = vert_data.dtype.names
+        self.shader_folder: Path = Path(shader_folder or "")
+        self.uniforms: dict[str, float | tuple[float, ...]] = uniforms or {}
+        self.texture_paths: Mapping[str, str | Path] = texture_paths or {}
+        self.depth_test: bool = depth_test
+        self.render_primitive: str = str(render_primitive)
         self.init_program_code()
         self.refresh_id()
 
@@ -66,7 +82,7 @@ class ShaderWrapper:
             result.texture_paths = dict(self.texture_paths)
         return result
 
-    def is_valid(self):
+    def is_valid(self) -> bool:
         return all(
             [
                 self.vert_data is not None,
@@ -75,10 +91,10 @@ class ShaderWrapper:
             ],
         )
 
-    def get_id(self):
+    def get_id(self) -> str:
         return self.id
 
-    def get_program_id(self):
+    def get_program_id(self) -> int:
         return self.program_id
 
     def create_id(self):
@@ -96,9 +112,9 @@ class ShaderWrapper:
             ),
         )
 
-    def refresh_id(self):
-        self.program_id = self.create_program_id()
-        self.id = self.create_id()
+    def refresh_id(self) -> None:
+        self.program_id: int = self.create_program_id()
+        self.id: str = self.create_id()
 
     def create_program_id(self):
         return hash(
@@ -114,7 +130,7 @@ class ShaderWrapper:
                 self.shader_folder / f"{name}.glsl",
             )
 
-        self.program_code = {
+        self.program_code: dict[str, str | None] = {
             "vertex_shader": get_code("vert"),
             "geometry_shader": get_code("geom"),
             "fragment_shader": get_code("frag"),
@@ -123,18 +139,18 @@ class ShaderWrapper:
     def get_program_code(self):
         return self.program_code
 
-    def replace_code(self, old, new):
+    def replace_code(self, old: str, new: str) -> None:
         code_map = self.program_code
-        for (name, _code) in code_map.items():
+        for name, _code in code_map.items():
             if code_map[name] is None:
                 continue
             code_map[name] = re.sub(old, new, code_map[name])
         self.refresh_id()
 
-    def combine_with(self, *shader_wrappers):
+    def combine_with(self, *shader_wrappers: "ShaderWrapper") -> Self:  # noqa: UP037
         # Assume they are of the same type
         if len(shader_wrappers) == 0:
-            return
+            return self
         if self.vert_indices is not None:
             num_verts = len(self.vert_data)
             indices_list = [self.vert_indices]
@@ -190,6 +206,6 @@ def get_shader_code_from_file(filename: Path) -> str | None:
     return result
 
 
-def get_colormap_code(rgb_list):
+def get_colormap_code(rgb_list: FloatRGBLike_Array) -> str:
     data = ",".join("vec3({}, {}, {})".format(*rgb) for rgb in rgb_list)
     return f"vec3[{len(rgb_list)}]({data})"

manim/renderer/vectorized_mobject_rendering.py

@@ -1,17 +1,33 @@
 from __future__ import annotations
 
-import collections
+from collections import defaultdict
+from collections.abc import Iterable, Sequence
+from typing import TYPE_CHECKING
 
 import numpy as np
 
+if TYPE_CHECKING:
+    from manim.renderer.opengl_renderer import (
+        OpenGLRenderer,
+        OpenGLVMobject,
+    )
+    from manim.typing import MatrixMN
+
 from ..utils import opengl
 from ..utils.space_ops import cross2d, earclip_triangulation
 from .shader import Shader
 
+__all__ = [
+    "render_opengl_vectorized_mobject_fill",
+    "render_opengl_vectorized_mobject_stroke",
+]
+
 
-def build_matrix_lists(mob):
+def build_matrix_lists(
+    mob: OpenGLVMobject,
+) -> defaultdict[tuple[float, ...], list[OpenGLVMobject]]:
     root_hierarchical_matrix = mob.hierarchical_model_matrix()
-    matrix_to_mobject_list = collections.defaultdict(list)
+    matrix_to_mobject_list = defaultdict(list)
     if mob.has_points():
         matrix_to_mobject_list[tuple(root_hierarchical_matrix.ravel())].append(mob)
     mobject_to_hierarchical_matrix = {mob: root_hierarchical_matrix}
@@ -31,7 +47,9 @@ def build_matrix_lists(mob):
     return matrix_to_mobject_list
 
 
-def render_opengl_vectorized_mobject_fill(renderer, mobject):
+def render_opengl_vectorized_mobject_fill(
+    renderer: OpenGLRenderer, mobject: OpenGLVMobject
+) -> None:
     matrix_to_mobject_list = build_matrix_lists(mobject)
 
     for matrix_tuple, mobject_list in matrix_to_mobject_list.items():
@@ -39,7 +57,11 @@ def render_opengl_vectorized_mobject_fill(renderer, mobject):
         render_mobject_fills_with_matrix(renderer, model_matrix, mobject_list)
 
 
-def render_mobject_fills_with_matrix(renderer, model_matrix, mobjects):
+def render_mobject_fills_with_matrix(
+    renderer: OpenGLRenderer,
+    model_matrix: MatrixMN,
+    mobjects: Iterable[OpenGLVMobject],
+) -> None:
     # Precompute the total number of vertices for which to reserve space.
     # Note that triangulate_mobject() will cache its results.
     total_size = 0
@@ -79,7 +101,7 @@ def render_mobject_fills_with_matrix(renderer, model_matrix, mobjects):
     )
     fill_shader.set_uniform(
         "u_projection_matrix",
-        renderer.scene.camera.projection_matrix,
+        renderer.camera.projection_matrix,
     )
 
     vbo = renderer.context.buffer(attributes.tobytes())
@@ -93,7 +115,7 @@ def render_mobject_fills_with_matrix(renderer, model_matrix, mobjects):
     vbo.release()
 
 
-def triangulate_mobject(mob):
+def triangulate_mobject(mob: OpenGLVMobject) -> np.ndarray:
     if not mob.needs_new_triangulation:
         return mob.triangulation
 
@@ -187,14 +209,20 @@ def triangulate_mobject(mob):
     return attributes
 
 
-def render_opengl_vectorized_mobject_stroke(renderer, mobject):
+def render_opengl_vectorized_mobject_stroke(
+    renderer: OpenGLRenderer, mobject: OpenGLVMobject
+) -> None:
     matrix_to_mobject_list = build_matrix_lists(mobject)
     for matrix_tuple, mobject_list in matrix_to_mobject_list.items():
         model_matrix = np.array(matrix_tuple).reshape((4, 4))
         render_mobject_strokes_with_matrix(renderer, model_matrix, mobject_list)
 
 
-def render_mobject_strokes_with_matrix(renderer, model_matrix, mobjects):
+def render_mobject_strokes_with_matrix(
+    renderer: OpenGLRenderer,
+    model_matrix: MatrixMN,
+    mobjects: Sequence[OpenGLVMobject],
+) -> None:
     # Precompute the total number of vertices for which to reserve space.
     total_size = 0
     for submob in mobjects:
@@ -274,7 +302,7 @@ def render_mobject_strokes_with_matrix(renderer, model_matrix, mobjects):
             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/moving_camera_scene.py

@@ -64,14 +64,37 @@ Examples
             self.play(Restore(self.camera.frame))
             self.wait()
 
+.. manim:: SlidingMultipleScenes
+
+    class SlidingMultipleScenes(MovingCameraScene):
+        def construct(self):
+            def create_scene(number):
+                frame = Rectangle(width=16,height=9)
+                circ = Circle().shift(LEFT)
+                text = Tex(f"This is Scene {str(number)}").next_to(circ, RIGHT)
+                frame.add(circ,text)
+                return frame
+
+            group = VGroup(*(create_scene(i) for i in range(4))).arrange_in_grid(buff=4)
+            self.add(group)
+            self.camera.auto_zoom(group[0], animate=False)
+            for scene in group:
+                self.play(self.camera.auto_zoom(scene))
+                self.wait()
+
+            self.play(self.camera.auto_zoom(group, margin=2))
 """
 
 from __future__ import annotations
 
 __all__ = ["MovingCameraScene"]
 
+from typing import Any
+
 from manim.animation.animation import Animation
+from manim.mobject.mobject import Mobject
 
+from ..camera.camera import Camera
 from ..camera.moving_camera import MovingCamera
 from ..scene.scene import Scene
 from ..utils.family import extract_mobject_family_members
@@ -83,15 +106,21 @@ class MovingCameraScene(Scene):
     This is a Scene, with special configurations and properties that
     make it suitable for cases where the camera must be moved around.
 
+    Note: Examples are included in the moving_camera_scene module
+    documentation, see below in the 'see also' section.
+
     .. SEEALSO::
 
+        :mod:`.moving_camera_scene`
         :class:`.MovingCamera`
     """
 
-    def __init__(self, camera_class=MovingCamera, **kwargs):
+    def __init__(
+        self, camera_class: type[Camera] = MovingCamera, **kwargs: Any
+    ) -> None:
         super().__init__(camera_class=camera_class, **kwargs)
 
-    def get_moving_mobjects(self, *animations: Animation):
+    def get_moving_mobjects(self, *animations: Animation) -> list[Mobject]:
         """
         This method returns a list of all of the Mobjects in the Scene that
         are moving, that are also in the animations passed.
@@ -103,7 +132,7 @@ class MovingCameraScene(Scene):
         """
         moving_mobjects = super().get_moving_mobjects(*animations)
         all_moving_mobjects = extract_mobject_family_members(moving_mobjects)
-        movement_indicators = self.renderer.camera.get_mobjects_indicating_movement()
+        movement_indicators = self.renderer.camera.get_mobjects_indicating_movement()  # type: ignore[union-attr]
         for movement_indicator in movement_indicators:
             if movement_indicator in all_moving_mobjects:
                 # When one of these is moving, the camera should