A community-maintained Python framework for creating mathematical animations.
Add type annotations to `manim/renderer/shader.py` (#4350)
Henrik Skov Midtiby21fe73b5c2e7
diff --git a/manim/renderer/shader.py b/manim/renderer/shader.pyindex a098ed30c..0cdf62a2d 100644--- a/manim/renderer/shader.py+++ b/manim/renderer/shader.py@@ -4,17 +4,30 @@ import contextlibimport inspectimport reimport textwrap+from collections.abc import Callable, Iterator, Sequencefrom pathlib import Path+from typing import TYPE_CHECKING, Anyimport modernglimport 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, Point3Dfrom .. import configfrom ..utils import openglSHADER_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",@@ -43,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):@@ -69,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 = Noneself.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_matrixself.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]@@ -106,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(@@ -117,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:@@ -128,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] = positionreturn self- def get_meshes(self):+ def get_meshes(self) -> Iterator[Mesh]:dfs = [self]while dfs:parent = dfs.pop()@@ -143,17 +158,17 @@ class Object3D:yield parentdfs.extend(parent.children)- def get_family(self):+ def get_family(self) -> Iterator[Object3D]:dfs = [self]while dfs:parent = dfs.pop()yield parentdfs.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@@ -164,7 +179,7 @@ class Object3D:current_object = current_object.parentreturn 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]@@ -175,76 +190,93 @@ class Object3D:current_object = current_object.parentreturn 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 = Falseself.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):+ def add_updater(+ self,+ update_function: MeshUpdater,+ index: int | None = None,+ call_updater: bool = True,+ ) -> Self:if "dt" in inspect.signature(update_function).parameters:- updater_list = self.time_based_updaters+ self._add_time_based_updater(update_function, index) # type: ignore[arg-type]else:- updater_list = self.non_time_updaters-- if index is None:- updater_list.append(update_function)- 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 = Truereturn self- def resume_updating(self, call_updater=True):+ def resume_updating(self, call_updater: bool = True) -> Self:self.updating_suspended = Falseif 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()) > 0return self@@ -252,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 = shaderself.attributes = attributesself.indices = indiceselif geometry is not None and material is not None:self.shader = materialself.attributes = geometry.attributes- self.indices = geometry.index+ self.indices = geometry.indiceselse:raise Exception("Mesh requires either attributes and a Shader or a Geometry and a "@@ -276,10 +308,10 @@ class Mesh(Object3D):)self.use_depth_test = use_depth_testself.primitive = primitive- self.skip_render = False+ self.skip_render: bool = Falseself.init_updaters()- def single_copy(self):+ def single_copy(self) -> Mesh:copy = Mesh(attributes=self.attributes.copy(),shader=self.shader,@@ -293,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),@@ -304,7 +336,7 @@ class Mesh(Object3D):renderer.camera.projection_matrix,)- def render(self):+ def render(self) -> None:if self.skip_render:return@@ -313,15 +345,17 @@ class Mesh(Object3D):else:self.shader.context.disable(moderngl.DEPTH_TEST)- from moderngl 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 = Noneelse:@@ -333,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)@@ -346,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_cacheself.context = contextself.name = name+ self.source = source# See if the program is cached.if (@@ -360,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 = {@@ -371,18 +406,20 @@ class Shader:"frag": "fragment_shader","geom": "geometry_shader",}- shader_folder = SHADER_FOLDER / name+ shader_folder = SHADER_FOLDER / self.namefor shader_file in shader_folder.iterdir():shader_file_path = shader_folder / shader_fileshader_source = get_shader_code_from_file(shader_file_path)source_dict[source_dict_key[shader_file_path.stem]] = shader_sourceself.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):+ def set_uniform(self, name: str, value: Any) -> None:with contextlib.suppress(KeyError):self.shader_program[name] = value@@ -390,9 +427,9 @@ class Shader: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.")@@ -439,5 +476,5 @@ class FullScreenQuad(Mesh):)super().__init__(shader, attributes)- def render(self):+ def render(self) -> None:super().render()diff --git a/manim/scene/scene.py b/manim/scene/scene.pyindex ba162320f..94d8715d3 100644--- a/manim/scene/scene.py+++ b/manim/scene/scene.py@@ -383,7 +383,7 @@ class Scene:def update_meshes(self, dt: float) -> None:for obj in self.meshes:- for mesh in obj.get_family(): # type: ignore[no-untyped-call]+ for mesh in obj.get_family():mesh.update(dt)def update_self(self, dt: float) -> None:diff --git a/mypy.ini b/mypy.iniindex 11df145b9..f57503338 100644--- a/mypy.ini+++ b/mypy.ini@@ -180,9 +180,6 @@ ignore_errors = True[mypy-manim.renderer.opengl_renderer_window]ignore_errors = True-[mypy-manim.renderer.shader]-ignore_errors = True-[mypy-manim.renderer.shader_wrapper]ignore_errors = True