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

manim/mobject/opengl/opengl_mobject.py

@@ -1,22 +1,46 @@
 from __future__ import annotations
 
 import copy
+import inspect
 import itertools as it
 import random
 import sys
+import types
+from collections.abc import Callable, Iterable, Iterator, Sequence
 from functools import partialmethod, wraps
 from math import ceil
-from typing import Iterable, Sequence
+from typing import TYPE_CHECKING, Any, ClassVar, Protocol, TypeVar, cast
 
 import moderngl
 import numpy as np
-from colour import Color
+import numpy.typing as npt
+from typing_extensions import (
+    Never,
+    Self,
+    TypeAlias,
+    overload,
+    override,
+)
 
 from manim import config, logger
 from manim.constants import *
+from manim.data_structures import MethodWithArgs
+from manim.renderer.shader_wrapper import get_colormap_code
+from manim.typing import (
+    Point3D,
+    Point3D_Array,
+    Point3DLike,
+    Point3DLike_Array,
+)
 from manim.utils.bezier import integer_interpolate, interpolate
-from manim.utils.color import *
-from manim.utils.color import Colors
+from manim.utils.color import (
+    WHITE,
+    ManimColor,
+    ParsableManimColor,
+    color_gradient,
+    color_to_rgb,
+    rgb_to_hex,
+)
 from manim.utils.config_ops import _Data, _Uniforms
 
 # from ..utils.iterables import batch_by_property
@@ -31,17 +55,40 @@ from manim.utils.iterables import (
     uniq_chain,
 )
 from manim.utils.paths import straight_path
-from manim.utils.simple_functions import get_parameters
 from manim.utils.space_ops import (
     angle_between_vectors,
     normalize,
     rotation_matrix_transpose,
 )
 
-
-def affects_shader_info_id(func):
+if TYPE_CHECKING:
+    from manim.animation.animation import Animation
+    from manim.renderer.shader_wrapper import ShaderWrapper
+    from manim.typing import (
+        FloatRGB_Array,
+        FloatRGBA_Array,
+        ManimFloat,
+        MappingFunction,
+        MatrixMN,
+        MultiMappingFunction,
+        PathFuncType,
+        Vector3D,
+        Vector3DLike,
+    )
+
+    _TimeBasedUpdater: TypeAlias = Callable[["OpenGLMobject", float], object]
+    _NonTimeBasedUpdater: TypeAlias = Callable[["OpenGLMobject"], object]
+    _Updater: TypeAlias = _NonTimeBasedUpdater | _TimeBasedUpdater
+
+    _T = TypeVar("_T")
+    _T_np = TypeVar("_T_np", bound=np.generic)
+
+
+def affects_shader_info_id(
+    func: Callable[[OpenGLMobject], OpenGLMobject],
+) -> Callable[[OpenGLMobject], OpenGLMobject]:
     @wraps(func)
-    def wrapper(self):
+    def wrapper(self: OpenGLMobject) -> OpenGLMobject:
         for mob in self.get_family():
             func(mob)
             mob.refresh_shader_wrapper_id()
@@ -50,6 +97,14 @@ def affects_shader_info_id(func):
     return wrapper
 
 
+__all__ = ["OpenGLMobject", "OpenGLGroup", "OpenGLPoint", "_AnimationBuilder"]
+
+
+_ShaderDType: TypeAlias = np.void
+"""The dtype for NumPy arrays representing shader data. It's a structured dtype with signature `(point, np.float32, (3,))`."""
+_ShaderData: TypeAlias = npt.NDArray[_ShaderDType]
+
+
 class OpenGLMobject:
     """Mathematical Object: base class for objects that can be displayed on screen.
 
@@ -66,79 +121,85 @@ class OpenGLMobject:
 
     """
 
-    shader_dtype = [
+    _original__init__: ClassVar[Callable[..., None]]
+
+    shader_dtype: ClassVar[Sequence[tuple[str, type[np.generic], tuple[int, ...]]]] = [
         ("point", np.float32, (3,)),
     ]
-    shader_folder = ""
+    shader_folder: ClassVar[str] = ""
 
     # _Data and _Uniforms are set as class variables to tell manim how to handle setting/getting these attributes later.
-    points = _Data()
-    bounding_box = _Data()
-    rgbas = _Data()
-
-    is_fixed_in_frame = _Uniforms()
-    is_fixed_orientation = _Uniforms()
-    fixed_orientation_center = _Uniforms()  # for fixed orientation reference
-    gloss = _Uniforms()
-    shadow = _Uniforms()
+    points: _Data[Point3D_Array] = _Data()
+    bounding_box: _Data[Point3D_Array] = _Data()
+    rgbas: _Data[FloatRGBA_Array] = _Data()
+
+    is_fixed_in_frame: _Uniforms = _Uniforms()
+    is_fixed_orientation: _Uniforms = _Uniforms()
+    fixed_orientation_center: _Uniforms[tuple[float, float, float]] = (
+        _Uniforms()
+    )  # for fixed orientation reference
+    gloss: _Uniforms = _Uniforms()
+    shadow: _Uniforms = _Uniforms()
 
     def __init__(
         self,
-        color=WHITE,
-        opacity=1,
-        dim=3,  # TODO, get rid of this
+        color: ParsableManimColor | Sequence[ParsableManimColor] = WHITE,
+        opacity: float = 1,
+        dim: int = 3,  # TODO, get rid of this
         # Lighting parameters
         # Positive gloss up to 1 makes it reflect the light.
-        gloss=0.0,
+        gloss: float = 0.0,
         # Positive shadow up to 1 makes a side opposite the light darker
-        shadow=0.0,
+        shadow: float = 0.0,
         # For shaders
-        render_primitive=moderngl.TRIANGLES,
-        texture_paths=None,
-        depth_test=False,
+        render_primitive: int = moderngl.TRIANGLES,
+        texture_paths: dict[str, str] | None = None,
+        depth_test: bool = False,
         # If true, the mobject will not get rotated according to camera position
-        is_fixed_in_frame=False,
-        is_fixed_orientation=False,
+        is_fixed_in_frame: bool = False,
+        is_fixed_orientation: bool = False,
         # Must match in attributes of vert shader
         # Event listener
-        listen_to_events=False,
-        model_matrix=None,
-        should_render=True,
+        listen_to_events: bool = False,
+        model_matrix: MatrixMN | None = None,
+        should_render: bool = True,
         name: str | None = None,
-        **kwargs,
+        **kwargs: Any,
     ):
-        self.name = self.__class__.__name__ if name is None else name
+        self.name: str = self.__class__.__name__ if name is None else name
         # getattr in case data/uniforms are already defined in parent classes.
-        self.data = getattr(self, "data", {})
-        self.uniforms = getattr(self, "uniforms", {})
+        self.data: dict[str, npt.NDArray[Any]] = getattr(self, "data", {})
+        self.uniforms: dict[str, float | tuple[float, ...]] = getattr(
+            self, "uniforms", {}
+        )
 
-        self.opacity = opacity
-        self.dim = dim  # TODO, get rid of this
+        self.opacity: float | Iterable[float] = opacity
+        self.dim: int = dim  # TODO, get rid of this
         # Lighting parameters
         # Positive gloss up to 1 makes it reflect the light.
         self.gloss = gloss
         # Positive shadow up to 1 makes a side opposite the light darker
         self.shadow = shadow
         # For shaders
-        self.render_primitive = render_primitive
-        self.texture_paths = texture_paths
-        self.depth_test = depth_test
+        self.render_primitive: int = render_primitive
+        self.texture_paths: dict[str, str] | None = texture_paths
+        self.depth_test: bool = depth_test
         # If true, the mobject will not get rotated according to camera position
         self.is_fixed_in_frame = float(is_fixed_in_frame)
         self.is_fixed_orientation = float(is_fixed_orientation)
         self.fixed_orientation_center = (0, 0, 0)
         # Must match in attributes of vert shader
         # Event listener
-        self.listen_to_events = listen_to_events
-
-        self._submobjects = []
-        self.parents = []
-        self.parent = None
-        self.family = [self]
-        self.locked_data_keys = set()
-        self.needs_new_bounding_box = True
+        self.listen_to_events: bool = listen_to_events
+
+        self._submobjects: list[OpenGLMobject] = []
+        self.parents: list[OpenGLMobject] = []
+        self.parent: OpenGLMobject | None = None
+        self.family: list[OpenGLMobject] = [self]
+        self.locked_data_keys: set[str] = set()
+        self.needs_new_bounding_box: bool = True
         if model_matrix is None:
-            self.model_matrix = np.eye(4)
+            self.model_matrix: MatrixMN = np.eye(4)
         else:
             self.model_matrix = model_matrix
 
@@ -146,41 +207,101 @@ class OpenGLMobject:
         self.init_updaters()
         # self.init_event_listners()
         self.init_points()
-        self.color = Color(color) if color else None
+        self.color: ManimColor | list[ManimColor] = ManimColor.parse(color)
         self.init_colors()
 
-        self.shader_indices = None
+        self.shader_indices: Sequence[int] | None = None
 
         if self.depth_test:
             self.apply_depth_test()
 
-        self.should_render = should_render
+        self.should_render: bool = should_render
+
+    def _assert_valid_submobjects(self, submobjects: Iterable[OpenGLMobject]) -> Self:
+        """Check that all submobjects are actually instances of
+        :class:`OpenGLMobject`, and that none of them is
+        ``self`` (an :class:`OpenGLMobject` cannot contain itself).
+
+        This is an auxiliary function called when adding OpenGLMobjects to the
+        :attr:`submobjects` list.
+
+        This function is intended to be overridden by subclasses such as
+        :class:`OpenGLVMobject`, which should assert that only other
+        OpenGLVMobjects may be added into it.
+
+        Parameters
+        ----------
+        submobjects
+            The list containing values to validate.
+
+        Returns
+        -------
+        :class:`OpenGLMobject`
+            The OpenGLMobject itself.
+
+        Raises
+        ------
+        TypeError
+            If any of the values in `submobjects` is not an
+            :class:`OpenGLMobject`.
+        ValueError
+            If there was an attempt to add an :class:`OpenGLMobject` as its own
+            submobject.
+        """
+        return self._assert_valid_submobjects_internal(submobjects, OpenGLMobject)
+
+    def _assert_valid_submobjects_internal(
+        self, submobjects: Iterable[OpenGLMobject], mob_class: type[OpenGLMobject]
+    ) -> Self:
+        for i, submob in enumerate(submobjects):
+            if not isinstance(submob, mob_class):
+                error_message = (
+                    f"Only values of type {mob_class.__name__} can be added "
+                    f"as submobjects of {type(self).__name__}, but the value "
+                    f"{submob} (at index {i}) is of type "
+                    f"{type(submob).__name__}."
+                )
+                # Intended for subclasses such as OpenGLVMobject, which
+                # cannot have regular OpenGLMobjects as submobjects
+                if isinstance(submob, OpenGLMobject):
+                    error_message += (
+                        " You can try adding this value into a Group instead."
+                    )
+                raise TypeError(error_message)
+            if submob is self:
+                raise ValueError(
+                    f"Cannot add {type(self).__name__} as a submobject of "
+                    f"itself (at index {i})."
+                )
+        return self
 
     @classmethod
-    def __init_subclass__(cls, **kwargs):
+    def __init_subclass__(cls, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
         cls._original__init__ = cls.__init__
 
-    def __str__(self):
+    @override
+    def __str__(self) -> str:
         return self.__class__.__name__
 
-    def __repr__(self):
+    @override
+    def __repr__(self) -> str:
         return str(self.name)
 
-    def __sub__(self, other):
+    def __sub__(self, other: Never) -> object:
         return NotImplemented
 
-    def __isub__(self, other):
+    def __isub__(self, other: Never) -> object:
         return NotImplemented
 
-    def __add__(self, mobject):
+    def __add__(self, mobject: Never) -> object:
         return NotImplemented
 
-    def __iadd__(self, mobject):
+    def __iadd__(self, mobject: Never) -> object:
         return NotImplemented
 
     @classmethod
-    def set_default(cls, **kwargs):
+    def set_default(cls, **kwargs: Any) -> None:
         """Sets the default values of keyword arguments.
 
         If this method is called without any additional keyword
@@ -203,10 +324,10 @@ class OpenGLMobject:
             >>> from manim import Square, GREEN
             >>> Square.set_default(color=GREEN, fill_opacity=0.25)
             >>> s = Square(); s.color, s.fill_opacity
-            (<Color #83c167>, 0.25)
+            (ManimColor('#83C167'), 0.25)
             >>> Square.set_default()
             >>> s = Square(); s.color, s.fill_opacity
-            (<Color white>, 0.0)
+            (ManimColor('#FFFFFF'), 0.0)
 
         .. manim:: ChangedDefaultTextcolor
             :save_last_frame:
@@ -223,32 +344,37 @@ class OpenGLMobject:
 
         """
         if kwargs:
-            cls.__init__ = partialmethod(cls.__init__, **kwargs)
+            # Apparently mypy does not correctly understand `partialmethod`:
+            #   see https://github.com/python/mypy/issues/8619
+            cls.__init__ = partialmethod(cls.__init__, **kwargs)  # type: ignore[assignment]
         else:
             cls.__init__ = cls._original__init__
 
-    def init_data(self):
+    def init_data(self) -> None:
         """Initializes the ``points``, ``bounding_box`` and ``rgbas`` attributes and groups them into self.data.
-        Subclasses can inherit and overwrite this method to extend `self.data`."""
+        Subclasses can inherit and overwrite this method to extend `self.data`.
+        """
         self.points = np.zeros((0, 3))
         self.bounding_box = np.zeros((3, 3))
         self.rgbas = np.zeros((1, 4))
 
-    def init_colors(self):
+    def init_colors(self) -> None:
         """Initializes the colors.
 
-        Gets called upon creation"""
+        Gets called upon creation
+        """
         self.set_color(self.color, self.opacity)
 
-    def init_points(self):
+    def init_points(self) -> None:
         """Initializes :attr:`points` and therefore the shape.
 
         Gets called upon creation. This is an empty method that can be implemented by
-        subclasses."""
+        subclasses.
+        """
         # Typically implemented in subclass, unless purposefully left blank
         pass
 
-    def set(self, **kwargs) -> OpenGLMobject:
+    def set(self, **kwargs: object) -> Self:
         """Sets attributes.
 
         Mainly to be used along with :attr:`animate` to
@@ -276,24 +402,23 @@ class OpenGLMobject:
 
 
         """
-
         for attr, value in kwargs.items():
             setattr(self, attr, value)
 
         return self
 
-    def set_data(self, data):
+    def set_data(self, data: dict[str, Any]) -> Self:
         for key in data:
             self.data[key] = data[key].copy()
         return self
 
-    def set_uniforms(self, uniforms):
+    def set_uniforms(self, uniforms: dict[str, Any]) -> Self:
         for key in uniforms:
             self.uniforms[key] = uniforms[key]  # Copy?
         return self
 
     @property
-    def animate(self):
+    def animate(self) -> _AnimationBuilder | Self:
         """Used to animate the application of a method.
 
         .. warning::
@@ -304,7 +429,9 @@ class OpenGLMobject:
 
             ::
 
-                self.play(my_mobject.animate.shift(RIGHT), my_mobject.animate.rotate(PI))
+                self.play(
+                    my_mobject.animate.shift(RIGHT), my_mobject.animate.rotate(PI)
+                )
 
             make use of method chaining for ``animate``, meaning::
 
@@ -381,7 +508,7 @@ class OpenGLMobject:
         return _AnimationBuilder(self)
 
     @property
-    def width(self):
+    def width(self) -> float:
         """The width of the mobject.
 
         Returns
@@ -409,17 +536,16 @@ class OpenGLMobject:
         :meth:`length_over_dim`
 
         """
-
         # Get the length across the X dimension
         return self.length_over_dim(0)
 
     # Only these methods should directly affect points
     @width.setter
-    def width(self, value):
+    def width(self, value: float) -> None:
         self.rescale_to_fit(value, 0, stretch=False)
 
     @property
-    def height(self):
+    def height(self) -> float:
         """The height of the mobject.
 
         Returns
@@ -447,16 +573,15 @@ class OpenGLMobject:
         :meth:`length_over_dim`
 
         """
-
         # Get the length across the Y dimension
         return self.length_over_dim(1)
 
     @height.setter
-    def height(self, value):
+    def height(self, value: float) -> None:
         self.rescale_to_fit(value, 1, stretch=False)
 
     @property
-    def depth(self):
+    def depth(self) -> float:
         """The depth of the mobject.
 
         Returns
@@ -468,21 +593,24 @@ class OpenGLMobject:
         :meth:`length_over_dim`
 
         """
-
         # Get the length across the Z dimension
         return self.length_over_dim(2)
 
     @depth.setter
-    def depth(self, value):
+    def depth(self, value: float) -> None:
         self.rescale_to_fit(value, 2, stretch=False)
 
-    def resize_points(self, new_length, resize_func=resize_array):
+    def resize_points(
+        self,
+        new_length: int,
+        resize_func: Callable[[Point3D_Array, int], Point3D_Array] = resize_array,
+    ) -> Self:
         if new_length != len(self.points):
             self.points = resize_func(self.points, new_length)
         self.refresh_bounding_box()
         return self
 
-    def set_points(self, points):
+    def set_points(self, points: Point3DLike_Array) -> Self:
         if len(points) == len(self.points):
             self.points[:] = points
         elif isinstance(points, np.ndarray):
@@ -492,23 +620,28 @@ class OpenGLMobject:
         self.refresh_bounding_box()
         return self
 
-    def apply_over_attr_arrays(self, func):
+    def apply_over_attr_arrays(
+        self, func: Callable[[npt.NDArray[_T_np]], npt.NDArray[_T_np]]
+    ) -> Self:
         for attr in self.get_array_attrs():
             setattr(self, attr, func(getattr(self, attr)))
         return self
 
-    def append_points(self, new_points):
+    def get_array_attrs(self) -> Iterable[str]:
+        return ["points"]
+
+    def append_points(self, new_points: Point3DLike_Array) -> Self:
         self.points = np.vstack([self.points, new_points])
         self.refresh_bounding_box()
         return self
 
-    def reverse_points(self):
+    def reverse_points(self) -> Self:
         for mob in self.get_family():
             for key in mob.data:
                 mob.data[key] = mob.data[key][::-1]
         return self
 
-    def get_midpoint(self) -> np.ndarray:
+    def get_midpoint(self) -> Point3D:
         """Get coordinates of the middle of the path that forms the  :class:`~.OpenGLMobject`.
 
         Examples
@@ -531,18 +664,19 @@ class OpenGLMobject:
         """
         return self.point_from_proportion(0.5)
 
+    # TODO: name is inconsistent with Mobject.apply_points_function_about_point()
     def apply_points_function(
         self,
-        func,
-        about_point=None,
-        about_edge=ORIGIN,
-        works_on_bounding_box=False,
-    ):
+        func: MultiMappingFunction,
+        about_point: Point3DLike | None = None,
+        about_edge: Vector3DLike | None = ORIGIN,
+        works_on_bounding_box: bool = False,
+    ) -> Self:
         if about_point is None and about_edge is not None:
             about_point = self.get_bounding_box_point(about_edge)
 
         for mob in self.get_family():
-            arrs = []
+            arrs: list[Point3D_Array] = []
             if mob.has_points():
                 arrs.append(mob.points)
             if works_on_bounding_box:
@@ -563,7 +697,7 @@ class OpenGLMobject:
 
     # Others related to points
 
-    def match_points(self, mobject):
+    def match_points(self, mobject: OpenGLMobject) -> Self:
         """Edit points, positions, and submobjects to be identical
         to another :class:`~.OpenGLMobject`, while keeping the style unchanged.
 
@@ -581,29 +715,31 @@ class OpenGLMobject:
                     self.wait(0.5)
         """
         self.set_points(mobject.points)
+        return self
 
-    def clear_points(self):
-        self.resize_points(0)
+    def clear_points(self) -> Self:
+        self.points = np.empty((0, 3))
+        return self
 
-    def get_num_points(self):
+    def get_num_points(self) -> int:
         return len(self.points)
 
-    def get_all_points(self):
+    def get_all_points(self) -> Point3D_Array:
         if self.submobjects:
             return np.vstack([sm.points for sm in self.get_family()])
         else:
             return self.points
 
-    def has_points(self):
+    def has_points(self) -> bool:
         return self.get_num_points() > 0
 
-    def get_bounding_box(self):
+    def get_bounding_box(self) -> Point3D_Array:
         if self.needs_new_bounding_box:
             self.bounding_box = self.compute_bounding_box()
             self.needs_new_bounding_box = False
         return self.bounding_box
 
-    def compute_bounding_box(self):
+    def compute_bounding_box(self) -> Point3D_Array:
         all_points = np.vstack(
             [
                 self.points,
@@ -623,7 +759,9 @@ class OpenGLMobject:
             mids = (mins + maxs) / 2
             return np.array([mins, mids, maxs])
 
-    def refresh_bounding_box(self, recurse_down=False, recurse_up=True):
+    def refresh_bounding_box(
+        self, recurse_down: bool = False, recurse_up: bool = True
+    ) -> Self:
         for mob in self.get_family(recurse_down):
             mob.needs_new_bounding_box = True
         if recurse_up:
@@ -631,30 +769,33 @@ class OpenGLMobject:
                 parent.refresh_bounding_box()
         return self
 
-    def is_point_touching(self, point, buff=MED_SMALL_BUFF):
+    def is_point_touching(
+        self, point: Point3DLike, buff: float = MED_SMALL_BUFF
+    ) -> bool:
         bb = self.get_bounding_box()
         mins = bb[0] - buff
         maxs = bb[2] + buff
-        return (point >= mins).all() and (point <= maxs).all()
+        rv: bool = (point >= mins).all() and (point <= maxs).all()
+        return rv
 
     # Family matters
 
-    def __getitem__(self, value):
+    def __getitem__(self, value: int | slice) -> OpenGLMobject:
         if isinstance(value, slice):
             GroupClass = self.get_group_class()
             return GroupClass(*self.split().__getitem__(value))
         return self.split().__getitem__(value)
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[OpenGLMobject]:
         return iter(self.split())
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.split())
 
-    def split(self):
+    def split(self) -> Sequence[OpenGLMobject]:
         return self.submobjects
 
-    def assemble_family(self):
+    def assemble_family(self) -> Self:
         sub_families = (sm.get_family() for sm in self.submobjects)
         self.family = [self, *uniq_chain(*sub_families)]
         self.refresh_has_updater_status()
@@ -663,18 +804,16 @@ class OpenGLMobject:
             parent.assemble_family()
         return self
 
-    def get_family(self, recurse=True):
+    def get_family(self, recurse: bool = True) -> Sequence[OpenGLMobject]:
         if recurse and hasattr(self, "family"):
             return self.family
         else:
             return [self]
 
-    def family_members_with_points(self):
+    def family_members_with_points(self) -> Sequence[OpenGLMobject]:
         return [m for m in self.get_family() if m.has_points()]
 
-    def add(
-        self, *mobjects: OpenGLMobject, update_parent: bool = False
-    ) -> OpenGLMobject:
+    def add(self, *mobjects: OpenGLMobject, update_parent: bool = False) -> Self:
         """Add mobjects as submobjects.
 
         The mobjects are added to :attr:`submobjects`.
@@ -725,28 +864,33 @@ class OpenGLMobject:
             >>> len(outer.submobjects)
             1
 
+        Only OpenGLMobjects can be added::
+
+            >>> outer.add(3)
+            Traceback (most recent call last):
+            ...
+            TypeError: Only values of type OpenGLMobject can be added as submobjects of OpenGLMobject, but the value 3 (at index 0) is of type int.
+
         Adding an object to itself raises an error::
 
             >>> outer.add(outer)
             Traceback (most recent call last):
             ...
-            ValueError: OpenGLMobject cannot contain self
+            ValueError: Cannot add OpenGLMobject as a submobject of itself (at index 0).
 
         """
         if update_parent:
             assert len(mobjects) == 1, "Can't set multiple parents."
             mobjects[0].parent = self
 
-        if self in mobjects:
-            raise ValueError("OpenGLMobject cannot contain self")
+        self._assert_valid_submobjects(mobjects)
+
         if any(mobjects.count(elem) > 1 for elem in mobjects):
             logger.warning(
                 "Attempted adding some Mobject as a child more than once, "
                 "this is not possible. Repetitions are ignored.",
             )
         for mobject in mobjects:
-            if not isinstance(mobject, OpenGLMobject):
-                raise TypeError("All submobjects must be of type OpenGLMobject")
             if mobject not in self.submobjects:
                 self.submobjects.append(mobject)
             if self not in mobject.parents:
@@ -754,7 +898,9 @@ class OpenGLMobject:
         self.assemble_family()
         return self
 
-    def insert(self, index: int, mobject: OpenGLMobject, update_parent: bool = False):
+    def insert(
+        self, index: int, mobject: OpenGLMobject, update_parent: bool = False
+    ) -> Self:
         """Inserts a mobject at a specific position into self.submobjects
 
         Effectively just calls  ``self.submobjects.insert(index, mobject)``,
@@ -771,15 +917,10 @@ class OpenGLMobject:
         update_parent
             Whether or not to set ``mobject.parent`` to ``self``.
         """
-
         if update_parent:
             mobject.parent = self
 
-        if mobject is self:
-            raise ValueError("OpenGLMobject cannot contain self")
-
-        if not isinstance(mobject, OpenGLMobject):
-            raise TypeError("All submobjects must be of type OpenGLMobject")
+        self._assert_valid_submobjects([mobject])
 
         if mobject not in self.submobjects:
             self.submobjects.insert(index, mobject)
@@ -790,9 +931,7 @@ class OpenGLMobject:
         self.assemble_family()
         return self
 
-    def remove(
-        self, *mobjects: OpenGLMobject, update_parent: bool = False
-    ) -> OpenGLMobject:
+    def remove(self, *mobjects: OpenGLMobject, update_parent: bool = False) -> Self:
         """Remove :attr:`submobjects`.
 
         The mobjects are removed from :attr:`submobjects`, if they exist.
@@ -826,7 +965,7 @@ class OpenGLMobject:
         self.assemble_family()
         return self
 
-    def add_to_back(self, *mobjects: OpenGLMobject) -> OpenGLMobject:
+    def add_to_back(self, *mobjects: OpenGLMobject) -> Self:
         # NOTE: is the note true OpenGLMobjects?
         """Add all passed mobjects to the back of the submobjects.
 
@@ -871,10 +1010,12 @@ class OpenGLMobject:
         :meth:`add`
 
         """
+        self._assert_valid_submobjects(mobjects)
         self.submobjects = list_update(mobjects, self.submobjects)
         return self
 
-    def replace_submobject(self, index, new_submob):
+    def replace_submobject(self, index: int, new_submob: OpenGLMobject) -> Self:
+        self._assert_valid_submobjects([new_submob])
         old_submob = self.submobjects[index]
         if self in old_submob.parents:
             old_submob.parents.remove(self)
@@ -882,36 +1023,14 @@ class OpenGLMobject:
         self.assemble_family()
         return self
 
-    def invert(self, recursive=False):
-        """Inverts the list of :attr:`submobjects`.
-
-        Parameters
-        ----------
-        recursive
-            If ``True``, all submobject lists of this mobject's family are inverted.
-
-        Examples
-        --------
-
-        .. manim:: InvertSumobjectsExample
-
-            class InvertSumobjectsExample(Scene):
-                def construct(self):
-                    s = VGroup(*[Dot().shift(i*0.1*RIGHT) for i in range(-20,20)])
-                    s2 = s.copy()
-                    s2.invert()
-                    s2.shift(DOWN)
-                    self.play(Write(s), Write(s2))
-        """
-        if recursive:
-            for submob in self.submobjects:
-                submob.invert(recursive=True)
-        list.reverse(self.submobjects)
-        self.assemble_family()
-
     # Submobject organization
 
-    def arrange(self, direction=RIGHT, center=True, **kwargs):
+    def arrange(
+        self,
+        direction: Vector3DLike = RIGHT,
+        center: bool = True,
+        **kwargs: Any,
+    ) -> Self:
         """Sorts :class:`~.OpenGLMobject` next to each other on screen.
 
         Examples
@@ -940,14 +1059,14 @@ class OpenGLMobject:
         rows: int | None = None,
         cols: int | None = None,
         buff: float | tuple[float, float] = MED_SMALL_BUFF,
-        cell_alignment: np.ndarray = ORIGIN,
+        cell_alignment: Vector3DLike = ORIGIN,
         row_alignments: str | None = None,  # "ucd"
         col_alignments: str | None = None,  # "lcr"
-        row_heights: Iterable[float | None] | None = None,
-        col_widths: Iterable[float | None] | None = None,
+        row_heights: Sequence[float | None] | None = None,
+        col_widths: Sequence[float | None] | None = None,
         flow_order: str = "rd",
-        **kwargs,
-    ) -> OpenGLMobject:
+        **kwargs: Any,
+    ) -> Self:
         """Arrange submobjects in a grid.
 
         Parameters
@@ -1043,16 +1162,27 @@ class OpenGLMobject:
         start_pos = self.get_center()
 
         # get cols / rows values if given (implicitly)
-        def init_size(num, alignments, sizes):
+        def init_size(
+            num: int | None,
+            alignments: str | None,
+            sizes: Sequence[float | None] | None,
+            name: str,
+        ) -> int:
             if num is not None:
                 return num
             if alignments is not None:
                 return len(alignments)
             if sizes is not None:
                 return len(sizes)
+            raise ValueError(
+                f"At least one of the following parameters: '{name}s', "
+                f"'{name}_alignments' or "
+                f"'{name}_{'widths' if name == 'col' else 'heights'}', "
+                "must not be None"
+            )
 
-        cols = init_size(cols, col_alignments, col_widths)
-        rows = init_size(rows, row_alignments, row_heights)
+        cols = init_size(cols, col_alignments, col_widths, "col")
+        rows = init_size(rows, row_alignments, row_heights, "row")
 
         # calculate rows cols
         if rows is None and cols is None:
@@ -1076,34 +1206,37 @@ class OpenGLMobject:
             buff_x = buff_y = buff
 
         # Initialize alignments correctly
-        def init_alignments(alignments, num, mapping, name, dir):
-            if alignments is None:
+        def init_alignments(
+            str_alignments: str | None,
+            num: int,
+            mapping: dict[str, Vector3D],
+            name: str,
+            direction: Vector3D,
+        ) -> Sequence[Vector3D]:
+            if str_alignments is None:
                 # Use cell_alignment as fallback
-                return [cell_alignment * dir] * num
-            if len(alignments) != num:
+                return [cast(Vector3D, cell_alignment * direction)] * num
+            if len(str_alignments) != num:
                 raise ValueError(f"{name}_alignments has a mismatching size.")
-            alignments = list(alignments)
-            for i in range(num):
-                alignments[i] = mapping[alignments[i]]
-            return alignments
+            return [mapping[letter] for letter in str_alignments]
 
-        row_alignments = init_alignments(
+        row_alignments_seq: Sequence[Vector3D] = init_alignments(
             row_alignments,
             rows,
             {"u": UP, "c": ORIGIN, "d": DOWN},
             "row",
             RIGHT,
         )
-        col_alignments = init_alignments(
+        col_alignments_seq: Sequence[Vector3D] = init_alignments(
             col_alignments,
             cols,
             {"l": LEFT, "c": ORIGIN, "r": RIGHT},
             "col",
             UP,
         )
-        # Now row_alignment[r] + col_alignment[c] is the alignment in cell [r][c]
+        # Now row_alignments_seq[r] + col_alignment_seq[c] is the alignment in cell [r][c]
 
-        mapper = {
+        mapper: dict[str, Callable[[int, int], int]] = {
             "dr": lambda r, c: (rows - r - 1) + c * rows,
             "dl": lambda r, c: (rows - r - 1) + (cols - c - 1) * rows,
             "ur": lambda r, c: r + c * rows,
@@ -1114,20 +1247,31 @@ class OpenGLMobject:
             "lu": lambda r, c: r * cols + (cols - c - 1),
         }
         if flow_order not in mapper:
+            valid_flow_orders = ",".join([f'"{key}"' for key in mapper])
             raise ValueError(
-                'flow_order must be one of the following values: "dr", "rd", "ld" "dl", "ru", "ur", "lu", "ul".',
+                f"flow_order must be one of the following values: {valid_flow_orders}.",
             )
-        flow_order = mapper[flow_order]
+        flow_order_func = mapper[flow_order]
 
         # Reverse row_alignments and row_heights. Necessary since the
         # grid filling is handled bottom up for simplicity reasons.
-        def reverse(maybe_list):
+        if TYPE_CHECKING:
+
+            @overload
+            def reverse(maybe_list: None) -> None: ...
+            @overload
+            def reverse(maybe_list: Sequence[_T]) -> list[_T]: ...
+            @overload
+            def reverse(maybe_list: Sequence[_T] | None) -> list[_T] | None: ...
+
+        def reverse(maybe_list: Sequence[_T] | None) -> list[_T] | None:
             if maybe_list is not None:
                 maybe_list = list(maybe_list)
                 maybe_list.reverse()
                 return maybe_list
+            return None
 
-        row_alignments = reverse(row_alignments)
+        row_alignments_seq = reverse(row_alignments_seq)
         row_heights = reverse(row_heights)
 
         placeholder = OpenGLMobject()
@@ -1136,7 +1280,7 @@ class OpenGLMobject:
         # properties of 0.
 
         mobs.extend([placeholder] * (rows * cols - len(mobs)))
-        grid = [[mobs[flow_order(r, c)] for c in range(cols)] for r in range(rows)]
+        grid = [[mobs[flow_order_func(r, c)] for c in range(cols)] for r in range(rows)]
 
         measured_heigths = [
             max(grid[r][c].height for c in range(cols)) for r in range(rows)
@@ -1146,24 +1290,30 @@ class OpenGLMobject:
         ]
 
         # Initialize row_heights / col_widths correctly using measurements as fallback
-        def init_sizes(sizes, num, measures, name):
+        def init_sizes(
+            sizes: Sequence[float | None] | None,
+            num: int,
+            measures: Sequence[float],
+            name: str,
+        ) -> Sequence[float]:
             if sizes is None:
                 sizes = [None] * num
             if len(sizes) != num:
                 raise ValueError(f"{name} has a mismatching size.")
             return [
-                sizes[i] if sizes[i] is not None else measures[i] for i in range(num)
+                size if (size := sizes[i]) is not None else measures[i]
+                for i in range(num)
             ]
 
         heights = init_sizes(row_heights, rows, measured_heigths, "row_heights")
         widths = init_sizes(col_widths, cols, measured_widths, "col_widths")
 
-        x, y = 0, 0
+        x, y = 0.0, 0.0
         for r in range(rows):
-            x = 0
+            x = 0.0
             for c in range(cols):
                 if grid[r][c] is not placeholder:
-                    alignment = row_alignments[r] + col_alignments[c]
+                    alignment = row_alignments_seq[r] + col_alignments_seq[c]
                     line = Line(
                         x * RIGHT + y * UP,
                         (x + widths[c]) * RIGHT + (y + heights[r]) * UP,
@@ -1179,7 +1329,13 @@ class OpenGLMobject:
         self.move_to(start_pos)
         return self
 
-    def get_grid(self, n_rows, n_cols, height=None, **kwargs):
+    def get_grid(
+        self,
+        n_rows: int,
+        n_cols: int,
+        height: float | None = None,
+        **kwargs: Any,
+    ) -> OpenGLGroup:
         """
         Returns a new mobject containing multiple copies of this one
         arranged in a grid
@@ -1190,11 +1346,15 @@ class OpenGLMobject:
             grid.set_height(height)
         return grid
 
-    def duplicate(self, n: int):
-        """Returns an :class:`~.OpenGLVGroup` containing ``n`` copies of the mobject."""
+    def duplicate(self, n: int) -> OpenGLGroup:
+        """Returns an :class:`~.OpenGLGroup` containing ``n`` copies of the mobject."""
         return self.get_group_class()(*[self.copy() for _ in range(n)])
 
-    def sort(self, point_to_num_func=lambda p: p[0], submob_func=None):
+    def sort(
+        self,
+        point_to_num_func: Callable[[Point3DLike], float] = lambda p: p[0],
+        submob_func: Callable[[OpenGLMobject], Any] | None = None,
+    ) -> Self:
         """Sorts the list of :attr:`submobjects` by a function defined by ``submob_func``."""
         if submob_func is not None:
             self.submobjects.sort(key=submob_func)
@@ -1202,7 +1362,7 @@ class OpenGLMobject:
             self.submobjects.sort(key=lambda m: point_to_num_func(m.get_center()))
         return self
 
-    def shuffle(self, recurse=False):
+    def shuffle(self, recurse: bool = False) -> Self:
         """Shuffles the order of :attr:`submobjects`
 
         Examples
@@ -1225,7 +1385,7 @@ class OpenGLMobject:
         self.assemble_family()
         return self
 
-    def invert(self, recursive=False):
+    def invert(self, recursive: bool = False) -> Self:
         """Inverts the list of :attr:`submobjects`.
 
         Parameters
@@ -1249,11 +1409,13 @@ class OpenGLMobject:
         if recursive:
             for submob in self.submobjects:
                 submob.invert(recursive=True)
-        list.reverse(self.submobjects)
+        self.submobjects.reverse()
+        self.assemble_family()
+        return self
 
     # Copying
 
-    def copy(self, shallow: bool = False):
+    def copy(self, shallow: bool = False) -> OpenGLMobject:
         """Create and return an identical copy of the :class:`OpenGLMobject` including all
         :attr:`submobjects`.
 
@@ -1311,95 +1473,103 @@ class OpenGLMobject:
             #     setattr(copy_mobject, attr, value.copy())
         return copy_mobject
 
-    def deepcopy(self):
+    def deepcopy(self) -> OpenGLMobject:
         parents = self.parents
         self.parents = []
         result = copy.deepcopy(self)
         self.parents = parents
         return result
 
-    def generate_target(self, use_deepcopy: bool = False):
-        self.target = None  # Prevent exponential explosion
+    def generate_target(self, use_deepcopy: bool = False) -> OpenGLMobject:
+        self.target: OpenGLMobject | None = None  # Prevent exponential explosion
         if use_deepcopy:
             self.target = self.deepcopy()
         else:
             self.target = self.copy()
         return self.target
 
-    def save_state(self, use_deepcopy: bool = False):
+    def save_state(self, use_deepcopy: bool = False) -> Self:
         """Save the current state (position, color & size). Can be restored with :meth:`~.OpenGLMobject.restore`."""
         if hasattr(self, "saved_state"):
             # Prevent exponential growth of data
-            self.saved_state = None
+            self.saved_state: OpenGLMobject | None = None
         if use_deepcopy:
             self.saved_state = self.deepcopy()
         else:
             self.saved_state = self.copy()
         return self
 
-    def restore(self):
+    def restore(self) -> Self:
         """Restores the state that was previously saved with :meth:`~.OpenGLMobject.save_state`."""
-        if not hasattr(self, "saved_state") or self.save_state is None:
+        if not hasattr(self, "saved_state") or self.saved_state is None:
             raise Exception("Trying to restore without having saved")
         self.become(self.saved_state)
         return self
 
     # Updating
 
-    def init_updaters(self):
-        self.time_based_updaters = []
-        self.non_time_updaters = []
-        self.has_updaters = False
-        self.updating_suspended = False
-
-    def update(self, dt=0, recurse=True):
-        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)
+    def init_updaters(self) -> None:
+        self.time_based_updaters: list["_TimeBasedUpdater"] = []  # noqa: UP037
+        self.non_time_updaters: list["_NonTimeBasedUpdater"] = []  # noqa: UP037
+        self.has_updaters: bool = False
+        self.updating_suspended: bool = False
+
+    def update(self, dt: float = 0, recurse: bool = True) -> Self:
+        if self.has_updaters and not self.updating_suspended:
+            for time_based_updater in self.time_based_updaters:
+                time_based_updater(self, dt)
+            for non_time_updater in self.non_time_updaters:
+                non_time_updater(self)
         if recurse:
             for submob in self.submobjects:
                 submob.update(dt, recurse)
         return self
 
-    def get_time_based_updaters(self):
+    def get_time_based_updaters(self) -> Sequence[_TimeBasedUpdater]:
         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):
-        return self.time_based_updaters + self.non_time_updaters
+    def get_updaters(self) -> Sequence[_Updater]:
+        return cast("list[_Updater]", self.time_based_updaters) + cast(
+            "list[_Updater]", self.non_time_updaters
+        )
 
-    def get_family_updaters(self):
+    def get_family_updaters(self) -> Sequence[_Updater]:
         return list(it.chain(*(sm.get_updaters() for sm in self.get_family())))
 
-    def add_updater(self, update_function, index=None, call_updater=False):
-        if "dt" in get_parameters(update_function):
+    def add_updater(
+        self,
+        update_function: _Updater,
+        index: int | None = None,
+        call_updater: bool = False,
+    ) -> Self:
+        updater_list: list[_TimeBasedUpdater] | list[_NonTimeBasedUpdater]
+        if "dt" in inspect.signature(update_function).parameters:
             updater_list = self.time_based_updaters
         else:
             updater_list = self.non_time_updaters
 
         if index is None:
-            updater_list.append(update_function)
+            cast("list[_Updater]", updater_list).append(update_function)
         else:
-            updater_list.insert(index, update_function)
+            cast("list[_Updater]", updater_list).insert(index, update_function)
 
         self.refresh_has_updater_status()
         if call_updater:
             self.update()
         return self
 
-    def remove_updater(self, update_function):
+    def remove_updater(self, update_function: _Updater) -> Self:
         for updater_list in [self.time_based_updaters, self.non_time_updaters]:
+            updater_list = cast("list[_Updater]", updater_list)
             while update_function in updater_list:
                 updater_list.remove(update_function)
         self.refresh_has_updater_status()
         return self
 
-    def clear_updaters(self, recurse=True):
+    def clear_updaters(self, recurse: bool = True) -> Self:
         self.time_based_updaters = []
         self.non_time_updaters = []
         self.refresh_has_updater_status()
@@ -1408,20 +1578,20 @@ class OpenGLMobject:
                 submob.clear_updaters()
         return self
 
-    def match_updaters(self, mobject):
+    def match_updaters(self, mobject: OpenGLMobject) -> Self:
         self.clear_updaters()
         for updater in mobject.get_updaters():
             self.add_updater(updater)
         return self
 
-    def suspend_updating(self, recurse=True):
+    def suspend_updating(self, recurse: bool = True) -> Self:
         self.updating_suspended = True
         if recurse:
             for submob in self.submobjects:
                 submob.suspend_updating(recurse)
         return self
 
-    def resume_updating(self, recurse=True, call_updater=True):
+    def resume_updating(self, recurse: bool = True, call_updater: bool = True) -> Self:
         self.updating_suspended = False
         if recurse:
             for submob in self.submobjects:
@@ -1432,13 +1602,13 @@ class OpenGLMobject:
             self.update(dt=0, recurse=recurse)
         return self
 
-    def refresh_has_updater_status(self):
+    def refresh_has_updater_status(self) -> Self:
         self.has_updaters = any(mob.get_updaters() for mob in self.get_family())
         return self
 
     # Transforming operations
 
-    def shift(self, vector):
+    def shift(self, vector: Vector3DLike) -> Self:
         self.apply_points_function(
             lambda points: points + vector,
             about_edge=None,
@@ -1449,10 +1619,10 @@ class OpenGLMobject:
     def scale(
         self,
         scale_factor: float,
-        about_point: Sequence[float] | None = None,
-        about_edge: Sequence[float] = ORIGIN,
-        **kwargs,
-    ) -> OpenGLMobject:
+        about_point: Point3DLike | None = None,
+        about_edge: Point3DLike | None = ORIGIN,
+        **_kwargs: object,
+    ) -> Self:
         r"""Scale the size by a factor.
 
         Default behavior is to scale about the center of the mobject.
@@ -1471,7 +1641,7 @@ class OpenGLMobject:
             if :math:`\alpha < 0`, the mobject is also flipped.
         kwargs
             Additional keyword arguments passed to
-            :meth:`apply_points_function_about_point`.
+            :meth:`apply_points_function`.
 
         Returns
         -------
@@ -1504,28 +1674,27 @@ class OpenGLMobject:
             about_point=about_point,
             about_edge=about_edge,
             works_on_bounding_box=True,
-            **kwargs,
         )
         return self
 
-    def stretch(self, factor, dim, **kwargs):
-        def func(points):
+    def stretch(self, factor: float, dim: int, **kwargs: Any) -> Self:
+        def func(points: Point3D_Array) -> Point3D_Array:
             points[:, dim] *= factor
             return points
 
         self.apply_points_function(func, works_on_bounding_box=True, **kwargs)
         return self
 
-    def rotate_about_origin(self, angle, axis=OUT):
+    def rotate_about_origin(self, angle: float, axis: Vector3DLike = OUT) -> Self:
         return self.rotate(angle, axis, about_point=ORIGIN)
 
     def rotate(
         self,
-        angle,
-        axis=OUT,
-        about_point: Sequence[float] | None = None,
-        **kwargs,
-    ):
+        angle: float,
+        axis: Vector3DLike = OUT,
+        about_point: Point3DLike | None = None,
+        **kwargs: Any,
+    ) -> Self:
         """Rotates the :class:`~.OpenGLMobject` about a certain point."""
         rot_matrix_T = rotation_matrix_transpose(angle, axis)
         self.apply_points_function(
@@ -1535,7 +1704,7 @@ class OpenGLMobject:
         )
         return self
 
-    def flip(self, axis=UP, **kwargs):
+    def flip(self, axis: Vector3DLike = UP, **kwargs: Any) -> Self:
         """Flips/Mirrors an mobject about its center.
 
         Examples
@@ -1554,25 +1723,28 @@ class OpenGLMobject:
         """
         return self.rotate(TAU / 2, axis, **kwargs)
 
-    def apply_function(self, function, **kwargs):
+    def apply_function(self, function: MappingFunction, **kwargs: Any) -> Self:
         # Default to applying matrix about the origin, not mobjects center
         if len(kwargs) == 0:
             kwargs["about_point"] = ORIGIN
-        self.apply_points_function(
-            lambda points: np.array([function(p) for p in points]), **kwargs
-        )
+
+        def multi_mapping_function(points: Point3D_Array) -> Point3D_Array:
+            result: Point3D_Array = np.apply_along_axis(function, 1, points)
+            return result
+
+        self.apply_points_function(multi_mapping_function, **kwargs)
         return self
 
-    def apply_function_to_position(self, function):
+    def apply_function_to_position(self, function: MappingFunction) -> Self:
         self.move_to(function(self.get_center()))
         return self
 
-    def apply_function_to_submobject_positions(self, function):
+    def apply_function_to_submobject_positions(self, function: MappingFunction) -> Self:
         for submob in self.submobjects:
             submob.apply_function_to_position(function)
         return self
 
-    def apply_matrix(self, matrix, **kwargs):
+    def apply_matrix(self, matrix: MatrixMN, **kwargs: Any) -> Self:
         # Default to applying matrix about the origin, not mobjects center
         if ("about_point" not in kwargs) and ("about_edge" not in kwargs):
             kwargs["about_point"] = ORIGIN
@@ -1584,7 +1756,9 @@ class OpenGLMobject:
         )
         return self
 
-    def apply_complex_function(self, function, **kwargs):
+    def apply_complex_function(
+        self, function: Callable[[complex], complex], **kwargs: Any
+    ) -> Self:
         """Applies a complex function to a :class:`OpenGLMobject`.
         The x and y coordinates correspond to the real and imaginary parts respectively.
 
@@ -1611,14 +1785,14 @@ class OpenGLMobject:
                     self.play(t.animate.set_value(TAU), run_time=3)
         """
 
-        def R3_func(point):
+        def R3_func(point: Point3D) -> Point3D:
             x, y, z = point
             xy_complex = function(complex(x, y))
-            return [xy_complex.real, xy_complex.imag, z]
+            return np.array([xy_complex.real, xy_complex.imag, z])
 
-        return self.apply_function(R3_func)
+        return self.apply_function(R3_func, **kwargs)
 
-    def hierarchical_model_matrix(self):
+    def hierarchical_model_matrix(self) -> MatrixMN:
         if self.parent is None:
             return self.model_matrix
 
@@ -1629,7 +1803,12 @@ class OpenGLMobject:
             current_object = current_object.parent
         return np.linalg.multi_dot(list(reversed(model_matrices)))
 
-    def wag(self, direction=RIGHT, axis=DOWN, wag_factor=1.0):
+    def wag(
+        self,
+        direction: Vector3DLike = RIGHT,
+        axis: Vector3DLike = DOWN,
+        wag_factor: float = 1.0,
+    ) -> Self:
         for mob in self.family_members_with_points():
             alphas = np.dot(mob.points, np.transpose(axis))
             alphas -= min(alphas)
@@ -1646,12 +1825,16 @@ class OpenGLMobject:
 
     # Positioning methods
 
-    def center(self):
+    def center(self) -> Self:
         """Moves the mobject to the center of the Scene."""
         self.shift(-self.get_center())
         return self
 
-    def align_on_border(self, direction, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):
+    def align_on_border(
+        self,
+        direction: Vector3DLike,
+        buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER,
+    ) -> Self:
         """
         Direction just needs to be a vector pointing towards side or
         corner in the 2d plane.
@@ -1662,27 +1845,35 @@ class OpenGLMobject:
             0,
         )
         point_to_align = self.get_bounding_box_point(direction)
-        shift_val = target_point - point_to_align - buff * np.array(direction)
+        shift_val = target_point - point_to_align - buff * np.asarray(direction)
         shift_val = shift_val * abs(np.sign(direction))
         self.shift(shift_val)
         return self
 
-    def to_corner(self, corner=LEFT + DOWN, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):
+    def to_corner(
+        self,
+        corner: Vector3DLike = LEFT + DOWN,
+        buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER,
+    ) -> Self:
         return self.align_on_border(corner, buff)
 
-    def to_edge(self, edge=LEFT, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):
+    def to_edge(
+        self,
+        edge: Vector3DLike = LEFT,
+        buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER,
+    ) -> Self:
         return self.align_on_border(edge, buff)
 
     def next_to(
         self,
-        mobject_or_point,
-        direction=RIGHT,
-        buff=DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,
-        aligned_edge=ORIGIN,
-        submobject_to_align=None,
-        index_of_submobject_to_align=None,
-        coor_mask=np.array([1, 1, 1]),
-    ):
+        mobject_or_point: OpenGLMobject | Point3DLike,
+        direction: Vector3DLike = RIGHT,
+        buff: float = DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,
+        aligned_edge: Vector3DLike = ORIGIN,
+        submobject_to_align: OpenGLMobject | None = None,
+        index_of_submobject_to_align: int | None = None,
+        coor_mask: Vector3DLike = np.array([1, 1, 1]),
+    ) -> Self:
         """Move this :class:`~.OpenGLMobject` next to another's :class:`~.OpenGLMobject` or coordinate.
 
         Examples
@@ -1703,6 +1894,10 @@ class OpenGLMobject:
                     self.add(d, c, s, t)
 
         """
+        np_direction = np.asarray(direction)
+        np_aligned_edge = np.asarray(aligned_edge)
+
+        target_point: Point3DLike
         if isinstance(mobject_or_point, OpenGLMobject):
             mob = mobject_or_point
             if index_of_submobject_to_align is not None:
@@ -1710,7 +1905,7 @@ class OpenGLMobject:
             else:
                 target_aligner = mob
             target_point = target_aligner.get_bounding_box_point(
-                aligned_edge + direction,
+                np_aligned_edge + np_direction,
             )
         else:
             target_point = mobject_or_point
@@ -1720,36 +1915,43 @@ class OpenGLMobject:
             aligner = self[index_of_submobject_to_align]
         else:
             aligner = self
-        point_to_align = aligner.get_bounding_box_point(aligned_edge - direction)
-        self.shift((target_point - point_to_align + buff * direction) * coor_mask)
+        point_to_align = aligner.get_bounding_box_point(np_aligned_edge - np_direction)
+        self.shift((target_point - point_to_align + buff * np_direction) * coor_mask)
         return self
 
-    def shift_onto_screen(self, **kwargs):
-        space_lengths = [config["frame_x_radius"], config["frame_y_radius"]]
+    def shift_onto_screen(self, **kwargs: Any) -> Self:
+        space_lengths: list[float] = [
+            config["frame_x_radius"],
+            config["frame_y_radius"],
+        ]
         for vect in UP, DOWN, LEFT, RIGHT:
             dim = np.argmax(np.abs(vect))
-            buff = kwargs.get("buff", DEFAULT_MOBJECT_TO_EDGE_BUFFER)
+            buff: float = kwargs.get("buff", DEFAULT_MOBJECT_TO_EDGE_BUFFER)
             max_val = space_lengths[dim] - buff
             edge_center = self.get_edge_center(vect)
             if np.dot(edge_center, vect) > max_val:
-                self.to_edge(vect, **kwargs)
+                self.to_edge(vect, buff=buff)
         return self
 
-    def is_off_screen(self):
+    def is_off_screen(self) -> bool:
         if self.get_left()[0] > config.frame_x_radius:
             return True
         if self.get_right()[0] < config.frame_x_radius:
             return True
         if self.get_bottom()[1] > config.frame_y_radius:
             return True
-        if self.get_top()[1] < -config.frame_y_radius:
-            return True
-        return False
+        return cast(float, self.get_top()[1]) < -config.frame_y_radius
 
-    def stretch_about_point(self, factor, dim, point):
+    def stretch_about_point(self, factor: float, dim: int, point: Point3DLike) -> Self:
         return self.stretch(factor, dim, about_point=point)
 
-    def rescale_to_fit(self, length, dim, stretch=False, **kwargs):
+    def rescale_to_fit(
+        self,
+        length: float,
+        dim: int,
+        stretch: bool = False,
+        **kwargs: Any,
+    ) -> Self:
         old_length = self.length_over_dim(dim)
         if old_length == 0:
             return self
@@ -1759,7 +1961,7 @@ class OpenGLMobject:
             self.scale(length / old_length, **kwargs)
         return self
 
-    def stretch_to_fit_width(self, width, **kwargs):
+    def stretch_to_fit_width(self, width: float, **kwargs: Any) -> Self:
         """Stretches the :class:`~.OpenGLMobject` to fit a width, not keeping height/depth proportional.
 
         Returns
@@ -1772,27 +1974,33 @@ class OpenGLMobject:
         ::
 
             >>> from manim import *
+            >>> import numpy as np
             >>> sq = Square()
             >>> sq.height
-            2.0
+            np.float64(2.0)
             >>> sq.stretch_to_fit_width(5)
             Square
             >>> sq.width
-            5.0
+            np.float64(5.0)
             >>> sq.height
-            2.0
+            np.float64(2.0)
         """
         return self.rescale_to_fit(width, 0, stretch=True, **kwargs)
 
-    def stretch_to_fit_height(self, height, **kwargs):
+    def stretch_to_fit_height(self, height: float, **kwargs: Any) -> Self:
         """Stretches the :class:`~.OpenGLMobject` to fit a height, not keeping width/height proportional."""
         return self.rescale_to_fit(height, 1, stretch=True, **kwargs)
 
-    def stretch_to_fit_depth(self, depth, **kwargs):
+    def stretch_to_fit_depth(self, depth: float, **kwargs: Any) -> Self:
         """Stretches the :class:`~.OpenGLMobject` to fit a depth, not keeping width/height proportional."""
         return self.rescale_to_fit(depth, 1, stretch=True, **kwargs)
 
-    def set_width(self, width, stretch=False, **kwargs):
+    def set_width(
+        self,
+        width: float,
+        stretch: bool = False,
+        **kwargs: Any,
+    ) -> Self:
         """Scales the :class:`~.OpenGLMobject` to fit a width while keeping height/depth proportional.
 
         Returns
@@ -1805,52 +2013,65 @@ class OpenGLMobject:
         ::
 
             >>> from manim import *
+            >>> import numpy as np
             >>> sq = Square()
             >>> sq.height
-            2.0
+            np.float64(2.0)
             >>> sq.scale_to_fit_width(5)
             Square
             >>> sq.width
-            5.0
+            np.float64(5.0)
             >>> sq.height
-            5.0
+            np.float64(5.0)
         """
         return self.rescale_to_fit(width, 0, stretch=stretch, **kwargs)
 
     scale_to_fit_width = set_width
 
-    def set_height(self, height, stretch=False, **kwargs):
+    def set_height(
+        self,
+        height: float,
+        stretch: bool = False,
+        **kwargs: Any,
+    ) -> Self:
         """Scales the :class:`~.OpenGLMobject` to fit a height while keeping width/depth proportional."""
         return self.rescale_to_fit(height, 1, stretch=stretch, **kwargs)
 
     scale_to_fit_height = set_height
 
-    def set_depth(self, depth, stretch=False, **kwargs):
+    def set_depth(
+        self,
+        depth: float,
+        stretch: bool = False,
+        **kwargs: Any,
+    ) -> Self:
         """Scales the :class:`~.OpenGLMobject` to fit a depth while keeping width/height proportional."""
         return self.rescale_to_fit(depth, 2, stretch=stretch, **kwargs)
 
     scale_to_fit_depth = set_depth
 
-    def set_coord(self, value, dim, direction=ORIGIN):
+    def set_coord(
+        self, value: float, dim: int, direction: Vector3DLike = ORIGIN
+    ) -> Self:
         curr = self.get_coord(dim, direction)
         shift_vect = np.zeros(self.dim)
         shift_vect[dim] = value - curr
         self.shift(shift_vect)
         return self
 
-    def set_x(self, x, direction=ORIGIN):
+    def set_x(self, x: float, direction: Vector3DLike = ORIGIN) -> Self:
         """Set x value of the center of the :class:`~.OpenGLMobject` (``int`` or ``float``)"""
         return self.set_coord(x, 0, direction)
 
-    def set_y(self, y, direction=ORIGIN):
+    def set_y(self, y: float, direction: Vector3DLike = ORIGIN) -> Self:
         """Set y value of the center of the :class:`~.OpenGLMobject` (``int`` or ``float``)"""
         return self.set_coord(y, 1, direction)
 
-    def set_z(self, z, direction=ORIGIN):
+    def set_z(self, z: float, direction: Vector3DLike = ORIGIN) -> Self:
         """Set z value of the center of the :class:`~.OpenGLMobject` (``int`` or ``float``)"""
         return self.set_coord(z, 2, direction)
 
-    def space_out_submobjects(self, factor=1.5, **kwargs):
+    def space_out_submobjects(self, factor: float = 1.5, **kwargs: Any) -> Self:
         self.scale(factor, **kwargs)
         for submob in self.submobjects:
             submob.scale(1.0 / factor)
@@ -1858,11 +2079,12 @@ class OpenGLMobject:
 
     def move_to(
         self,
-        point_or_mobject,
-        aligned_edge=ORIGIN,
-        coor_mask=np.array([1, 1, 1]),
-    ):
+        point_or_mobject: Point3DLike | OpenGLMobject,
+        aligned_edge: Vector3DLike = ORIGIN,
+        coor_mask: Vector3DLike = np.array([1, 1, 1]),
+    ) -> Self:
         """Move center of the :class:`~.OpenGLMobject` to certain coordinate."""
+        target: Point3DLike
         if isinstance(point_or_mobject, OpenGLMobject):
             target = point_or_mobject.get_bounding_box_point(aligned_edge)
         else:
@@ -1871,7 +2093,12 @@ class OpenGLMobject:
         self.shift((target - point_to_align) * coor_mask)
         return self
 
-    def replace(self, mobject, dim_to_match=0, stretch=False):
+    def replace(
+        self,
+        mobject: OpenGLMobject,
+        dim_to_match: int = 0,
+        stretch: bool = False,
+    ) -> Self:
         if not mobject.get_num_points() and not mobject.submobjects:
             self.scale(0)
             return self
@@ -1893,13 +2120,13 @@ class OpenGLMobject:
         dim_to_match: int = 0,
         stretch: bool = False,
         buff: float = MED_SMALL_BUFF,
-    ):
+    ) -> Self:
         self.replace(mobject, dim_to_match, stretch)
         length = mobject.length_over_dim(dim_to_match)
         self.scale((length + buff) / length)
         return self
 
-    def put_start_and_end_on(self, start, end):
+    def put_start_and_end_on(self, start: Point3DLike, end: Point3DLike) -> Self:
         curr_start, curr_end = self.get_start_and_end()
         curr_vect = curr_end - curr_start
         if np.all(curr_vect == 0):
@@ -1911,7 +2138,7 @@ class OpenGLMobject:
             else OUT
         )
         self.scale(
-            np.linalg.norm(target_vect) / np.linalg.norm(curr_vect),
+            float(np.linalg.norm(target_vect) / np.linalg.norm(curr_vect)),
             about_point=curr_start,
         )
         self.rotate(
@@ -1924,9 +2151,15 @@ class OpenGLMobject:
 
     # Color functions
 
-    def set_rgba_array(self, color=None, opacity=None, name="rgbas", recurse=True):
+    def set_rgba_array(
+        self,
+        color: ParsableManimColor | Iterable[ParsableManimColor] | None = None,
+        opacity: float | Iterable[float] | None = None,
+        name: str = "rgbas",
+        recurse: bool = True,
+    ) -> Self:
         if color is not None:
-            rgbs = np.array([color_to_rgb(c) for c in listify(color)])
+            rgbs: FloatRGB_Array = np.array([color_to_rgb(c) for c in listify(color)])
         if opacity is not None:
             opacities = listify(opacity)
 
@@ -1949,12 +2182,19 @@ class OpenGLMobject:
 
         # Color and opacity
         if color is not None and opacity is not None:
-            rgbas = np.array([[*rgb, o] for rgb, o in zip(*make_even(rgbs, opacities))])
+            rgbas: FloatRGBA_Array = np.array(
+                [[*rgb, o] for rgb, o in zip(*make_even(rgbs, opacities))]
+            )
             for mob in self.get_family(recurse):
                 mob.data[name] = rgbas.copy()
         return self
 
-    def set_rgba_array_direct(self, rgbas: np.ndarray, name="rgbas", recurse=True):
+    def set_rgba_array_direct(
+        self,
+        rgbas: FloatRGBA_Array,
+        name: str = "rgbas",
+        recurse: bool = True,
+    ) -> Self:
         """Directly set rgba data from `rgbas` and optionally do the same recursively
         with submobjects. This can be used if the `rgbas` have already been generated
         with the correct shape and simply need to be set.
@@ -1970,13 +2210,19 @@ class OpenGLMobject:
         """
         for mob in self.get_family(recurse):
             mob.data[name] = rgbas.copy()
+        return self
 
-    def set_color(self, color, opacity=None, recurse=True):
+    def set_color(
+        self,
+        color: ParsableManimColor | Sequence[ParsableManimColor] | None,
+        opacity: float | Iterable[float] | None = None,
+        recurse: bool = True,
+    ) -> Self:
         self.set_rgba_array(color, opacity, recurse=False)
         # Recurse to submobjects differently from how set_rgba_array
         # in case they implement set_color differently
         if color is not None:
-            self.color = Color(color)
+            self.color = ManimColor.parse(color)
         if opacity is not None:
             self.opacity = opacity
         if recurse:
@@ -1984,24 +2230,26 @@ class OpenGLMobject:
                 submob.set_color(color, recurse=True)
         return self
 
-    def set_opacity(self, opacity, recurse=True):
+    def set_opacity(
+        self, opacity: float | Iterable[float] | None, recurse: bool = True
+    ) -> Self:
         self.set_rgba_array(color=None, opacity=opacity, recurse=False)
         if recurse:
             for submob in self.submobjects:
                 submob.set_opacity(opacity, recurse=True)
         return self
 
-    def get_color(self):
+    def get_color(self) -> str:
         return rgb_to_hex(self.rgbas[0, :3])
 
-    def get_opacity(self):
-        return self.rgbas[0, 3]
+    def get_opacity(self) -> float:
+        rv: float = self.rgbas[0, 3]
+        return rv
 
-    def set_color_by_gradient(self, *colors):
-        self.set_submobject_colors_by_gradient(*colors)
-        return self
+    def set_color_by_gradient(self, *colors: ParsableManimColor) -> Self:
+        return self.set_submobject_colors_by_gradient(*colors)
 
-    def set_submobject_colors_by_gradient(self, *colors):
+    def set_submobject_colors_by_gradient(self, *colors: ParsableManimColor) -> Self:
         if len(colors) == 0:
             raise Exception("Need at least one color")
         elif len(colors) == 1:
@@ -2015,21 +2263,21 @@ class OpenGLMobject:
             mob.set_color(color)
         return self
 
-    def fade(self, darkness=0.5, recurse=True):
-        self.set_opacity(1.0 - darkness, recurse=recurse)
+    def fade(self, darkness: float = 0.5, recurse: bool = True) -> Self:
+        return self.set_opacity(1.0 - darkness, recurse=recurse)
 
-    def get_gloss(self):
+    def get_gloss(self) -> float:
         return self.gloss
 
-    def set_gloss(self, gloss, recurse=True):
+    def set_gloss(self, gloss: float, recurse: bool = True) -> Self:
         for mob in self.get_family(recurse):
             mob.gloss = gloss
         return self
 
-    def get_shadow(self):
+    def get_shadow(self) -> float:
         return self.shadow
 
-    def set_shadow(self, shadow, recurse=True):
+    def set_shadow(self, shadow: float, recurse: bool = True) -> Self:
         for mob in self.get_family(recurse):
             mob.shadow = shadow
         return self
@@ -2037,8 +2285,11 @@ class OpenGLMobject:
     # Background rectangle
 
     def add_background_rectangle(
-        self, color: Colors | None = None, opacity: float = 0.75, **kwargs
-    ):
+        self,
+        color: ParsableManimColor | None = None,
+        opacity: float = 0.75,
+        **kwargs: Any,
+    ) -> Self:
         # TODO, this does not behave well when the mobject has points,
         # since it gets displayed on top
         """Add a BackgroundRectangle as submobject.
@@ -2070,146 +2321,153 @@ class OpenGLMobject:
         """
         from manim.mobject.geometry.shape_matchers import BackgroundRectangle
 
-        self.background_rectangle = BackgroundRectangle(
-            self, color=color, fill_opacity=opacity, **kwargs
+        self.background_rectangle: BackgroundRectangle = BackgroundRectangle(
+            self,  # type: ignore[arg-type]
+            color=color,
+            fill_opacity=opacity,
+            **kwargs,
         )
-        self.add_to_back(self.background_rectangle)
+        self.add_to_back(self.background_rectangle)  # type: ignore[arg-type]
         return self
 
-    def add_background_rectangle_to_submobjects(self, **kwargs):
+    def add_background_rectangle_to_submobjects(self, **kwargs: Any) -> Self:
         for submobject in self.submobjects:
             submobject.add_background_rectangle(**kwargs)
         return self
 
-    def add_background_rectangle_to_family_members_with_points(self, **kwargs):
+    def add_background_rectangle_to_family_members_with_points(
+        self, **kwargs: Any
+    ) -> Self:
         for mob in self.family_members_with_points():
             mob.add_background_rectangle(**kwargs)
         return self
 
     # Getters
 
-    def get_bounding_box_point(self, direction):
+    def get_bounding_box_point(self, direction: Vector3DLike) -> Point3D:
         bb = self.get_bounding_box()
         indices = (np.sign(direction) + 1).astype(int)
         return np.array([bb[indices[i]][i] for i in range(3)])
 
-    def get_edge_center(self, direction) -> np.ndarray:
+    def get_edge_center(self, direction: Vector3DLike) -> Point3D:
         """Get edge coordinates for certain direction."""
         return self.get_bounding_box_point(direction)
 
-    def get_corner(self, direction) -> np.ndarray:
+    def get_corner(self, direction: Vector3DLike) -> Point3D:
         """Get corner coordinates for certain direction."""
         return self.get_bounding_box_point(direction)
 
-    def get_center(self) -> np.ndarray:
+    def get_center(self) -> Point3D:
         """Get center coordinates."""
         return self.get_bounding_box()[1]
 
-    def get_center_of_mass(self):
+    def get_center_of_mass(self) -> Point3D:
         return self.get_all_points().mean(0)
 
-    def get_boundary_point(self, direction):
+    def get_boundary_point(self, direction: Vector3DLike) -> Point3D:
         all_points = self.get_all_points()
         boundary_directions = all_points - self.get_center()
         norms = np.linalg.norm(boundary_directions, axis=1)
         boundary_directions /= np.repeat(norms, 3).reshape((len(norms), 3))
-        index = np.argmax(np.dot(boundary_directions, np.array(direction).T))
+        index = np.argmax(np.dot(boundary_directions, direction))
         return all_points[index]
 
-    def get_continuous_bounding_box_point(self, direction):
-        dl, center, ur = self.get_bounding_box()
+    def get_continuous_bounding_box_point(self, direction: Vector3DLike) -> Point3D:
+        _dl, center, ur = self.get_bounding_box()
         corner_vect = ur - center
-        return center + direction / np.max(
+        np_direction = np.asarray(direction)
+        return center + np_direction / np.max(
             np.abs(
                 np.true_divide(
-                    direction,
+                    np_direction,
                     corner_vect,
-                    out=np.zeros(len(direction)),
+                    out=np.zeros(len(np_direction)),
                     where=((corner_vect) != 0),
                 ),
             ),
         )
 
-    def get_top(self) -> np.ndarray:
+    def get_top(self) -> Point3D:
         """Get top coordinates of a box bounding the :class:`~.OpenGLMobject`"""
         return self.get_edge_center(UP)
 
-    def get_bottom(self) -> np.ndarray:
+    def get_bottom(self) -> Point3D:
         """Get bottom coordinates of a box bounding the :class:`~.OpenGLMobject`"""
         return self.get_edge_center(DOWN)
 
-    def get_right(self) -> np.ndarray:
+    def get_right(self) -> Point3D:
         """Get right coordinates of a box bounding the :class:`~.OpenGLMobject`"""
         return self.get_edge_center(RIGHT)
 
-    def get_left(self) -> np.ndarray:
+    def get_left(self) -> Point3D:
         """Get left coordinates of a box bounding the :class:`~.OpenGLMobject`"""
         return self.get_edge_center(LEFT)
 
-    def get_zenith(self) -> np.ndarray:
+    def get_zenith(self) -> Point3D:
         """Get zenith coordinates of a box bounding a 3D :class:`~.OpenGLMobject`."""
         return self.get_edge_center(OUT)
 
-    def get_nadir(self) -> np.ndarray:
+    def get_nadir(self) -> Point3D:
         """Get nadir (opposite the zenith) coordinates of a box bounding a 3D :class:`~.OpenGLMobject`."""
         return self.get_edge_center(IN)
 
-    def length_over_dim(self, dim):
+    def length_over_dim(self, dim: int) -> float:
         bb = self.get_bounding_box()
-        return abs((bb[2] - bb[0])[dim])
+        rv: float = abs((bb[2] - bb[0])[dim])
+        return rv
 
-    def get_width(self):
+    def get_width(self) -> float:
         """Returns the width of the mobject."""
         return self.length_over_dim(0)
 
-    def get_height(self):
+    def get_height(self) -> float:
         """Returns the height of the mobject."""
         return self.length_over_dim(1)
 
-    def get_depth(self):
+    def get_depth(self) -> float:
         """Returns the depth of the mobject."""
         return self.length_over_dim(2)
 
-    def get_coord(self, dim: int, direction=ORIGIN):
+    def get_coord(self, dim: int, direction: Vector3DLike = ORIGIN) -> ManimFloat:
         """Meant to generalize ``get_x``, ``get_y`` and ``get_z``"""
         return self.get_bounding_box_point(direction)[dim]
 
-    def get_x(self, direction=ORIGIN) -> np.float64:
+    def get_x(self, direction: Vector3DLike = ORIGIN) -> ManimFloat:
         """Returns x coordinate of the center of the :class:`~.OpenGLMobject` as ``float``"""
         return self.get_coord(0, direction)
 
-    def get_y(self, direction=ORIGIN) -> np.float64:
+    def get_y(self, direction: Vector3DLike = ORIGIN) -> ManimFloat:
         """Returns y coordinate of the center of the :class:`~.OpenGLMobject` as ``float``"""
         return self.get_coord(1, direction)
 
-    def get_z(self, direction=ORIGIN) -> np.float64:
+    def get_z(self, direction: Vector3DLike = ORIGIN) -> ManimFloat:
         """Returns z coordinate of the center of the :class:`~.OpenGLMobject` as ``float``"""
         return self.get_coord(2, direction)
 
-    def get_start(self):
+    def get_start(self) -> Point3D:
         """Returns the point, where the stroke that surrounds the :class:`~.OpenGLMobject` starts."""
         self.throw_error_if_no_points()
         return np.array(self.points[0])
 
-    def get_end(self):
+    def get_end(self) -> Point3D:
         """Returns the point, where the stroke that surrounds the :class:`~.OpenGLMobject` ends."""
         self.throw_error_if_no_points()
         return np.array(self.points[-1])
 
-    def get_start_and_end(self):
+    def get_start_and_end(self) -> tuple[Point3D, Point3D]:
         """Returns starting and ending point of a stroke as a ``tuple``."""
         return self.get_start(), self.get_end()
 
-    def point_from_proportion(self, alpha):
+    def point_from_proportion(self, alpha: float) -> Point3D:
         points = self.points
         i, subalpha = integer_interpolate(0, len(points) - 1, alpha)
         return interpolate(points[i], points[i + 1], subalpha)
 
-    def pfp(self, alpha):
+    def pfp(self, alpha: float) -> Point3D:
         """Abbreviation for point_from_proportion"""
         return self.point_from_proportion(alpha)
 
-    def get_pieces(self, n_pieces):
+    def get_pieces(self, n_pieces: int) -> OpenGLMobject:
         template = self.copy()
         template.submobjects = []
         alphas = np.linspace(0, 1, n_pieces + 1)
@@ -2220,34 +2478,41 @@ class OpenGLMobject:
             )
         )
 
-    def get_z_index_reference_point(self):
+    def get_z_index_reference_point(self) -> Point3D:
         # TODO, better place to define default z_index_group?
         z_index_group = getattr(self, "z_index_group", self)
         return z_index_group.get_center()
 
     # Match other mobject properties
 
-    def match_color(self, mobject: OpenGLMobject):
+    def match_color(self, mobject: OpenGLMobject) -> Self:
         """Match the color with the color of another :class:`~.OpenGLMobject`."""
         return self.set_color(mobject.get_color())
 
-    def match_dim_size(self, mobject: OpenGLMobject, dim, **kwargs):
+    def match_dim_size(
+        self,
+        mobject: OpenGLMobject,
+        dim: int,
+        **kwargs: Any,
+    ) -> Self:
         """Match the specified dimension with the dimension of another :class:`~.OpenGLMobject`."""
         return self.rescale_to_fit(mobject.length_over_dim(dim), dim, **kwargs)
 
-    def match_width(self, mobject: OpenGLMobject, **kwargs):
+    def match_width(self, mobject: OpenGLMobject, **kwargs: Any) -> Self:
         """Match the width with the width of another :class:`~.OpenGLMobject`."""
         return self.match_dim_size(mobject, 0, **kwargs)
 
-    def match_height(self, mobject: OpenGLMobject, **kwargs):
+    def match_height(self, mobject: OpenGLMobject, **kwargs: Any) -> Self:
         """Match the height with the height of another :class:`~.OpenGLMobject`."""
         return self.match_dim_size(mobject, 1, **kwargs)
 
-    def match_depth(self, mobject: OpenGLMobject, **kwargs):
+    def match_depth(self, mobject: OpenGLMobject, **kwargs: Any) -> Self:
         """Match the depth with the depth of another :class:`~.OpenGLMobject`."""
         return self.match_dim_size(mobject, 2, **kwargs)
 
-    def match_coord(self, mobject: OpenGLMobject, dim, direction=ORIGIN):
+    def match_coord(
+        self, mobject: OpenGLMobject, dim: int, direction: Vector3DLike = ORIGIN
+    ) -> Self:
         """Match the coordinates with the coordinates of another :class:`~.OpenGLMobject`."""
         return self.set_coord(
             mobject.get_coord(dim, direction),
@@ -2255,23 +2520,23 @@ class OpenGLMobject:
             direction=direction,
         )
 
-    def match_x(self, mobject, direction=ORIGIN):
+    def match_x(self, mobject: OpenGLMobject, direction: Vector3DLike = ORIGIN) -> Self:
         """Match x coord. to the x coord. of another :class:`~.OpenGLMobject`."""
         return self.match_coord(mobject, 0, direction)
 
-    def match_y(self, mobject, direction=ORIGIN):
+    def match_y(self, mobject: OpenGLMobject, direction: Vector3DLike = ORIGIN) -> Self:
         """Match y coord. to the x coord. of another :class:`~.OpenGLMobject`."""
         return self.match_coord(mobject, 1, direction)
 
-    def match_z(self, mobject, direction=ORIGIN):
+    def match_z(self, mobject: OpenGLMobject, direction: Vector3DLike = ORIGIN) -> Self:
         """Match z coord. to the x coord. of another :class:`~.OpenGLMobject`."""
         return self.match_coord(mobject, 2, direction)
 
     def align_to(
         self,
-        mobject_or_point: OpenGLMobject | Sequence[float],
-        direction=ORIGIN,
-    ):
+        mobject_or_point: OpenGLMobject | Point3DLike,
+        direction: Vector3DLike = ORIGIN,
+    ) -> Self:
         """
         Examples:
         mob1.align_to(mob2, UP) moves mob1 vertically so that its
@@ -2281,6 +2546,7 @@ class OpenGLMobject:
         horizontally so that it's center is directly above/below
         the center of mob2
         """
+        point: Point3DLike
         if isinstance(mobject_or_point, OpenGLMobject):
             point = mobject_or_point.get_bounding_box_point(direction)
         else:
@@ -2291,21 +2557,22 @@ class OpenGLMobject:
                 self.set_coord(point[dim], dim, direction)
         return self
 
-    def get_group_class(self):
+    def get_group_class(self) -> type[OpenGLGroup]:
         return OpenGLGroup
 
     @staticmethod
-    def get_mobject_type_class():
+    def get_mobject_type_class() -> type[OpenGLMobject]:
         """Return the base class of this mobject type."""
         return OpenGLMobject
 
     # Alignment
 
-    def align_data_and_family(self, mobject):
+    def align_data_and_family(self, mobject: OpenGLMobject) -> Self:
         self.align_family(mobject)
         self.align_data(mobject)
+        return self
 
-    def align_data(self, mobject):
+    def align_data(self, mobject: OpenGLMobject) -> Self:
         # In case any data arrays get resized when aligned to shader data
         # self.refresh_shader_data()
         for mob1, mob2 in zip(self.get_family(), mobject.get_family()):
@@ -2321,14 +2588,15 @@ class OpenGLMobject:
                     mob1.data[key] = resize_preserving_order(arr1, len(arr2))
                 elif len(arr1) > len(arr2):
                     mob2.data[key] = resize_preserving_order(arr2, len(arr1))
+        return self
 
-    def align_points(self, mobject):
+    def align_points(self, mobject: OpenGLMobject) -> Self:
         max_len = max(self.get_num_points(), mobject.get_num_points())
         for mob in (self, mobject):
             mob.resize_points(max_len, resize_func=resize_preserving_order)
         return self
 
-    def align_family(self, mobject):
+    def align_family(self, mobject: OpenGLMobject) -> Self:
         mob1 = self
         mob2 = mobject
         n1 = len(mob1)
@@ -2341,14 +2609,14 @@ class OpenGLMobject:
             sm1.align_family(sm2)
         return self
 
-    def push_self_into_submobjects(self):
+    def push_self_into_submobjects(self) -> Self:
         copy = self.deepcopy()
         copy.submobjects = []
         self.resize_points(0)
         self.add(copy)
         return self
 
-    def add_n_more_submobjects(self, n):
+    def add_n_more_submobjects(self, n: int) -> Self:
         if n == 0:
             return self
 
@@ -2377,7 +2645,13 @@ class OpenGLMobject:
 
     # Interpolate
 
-    def interpolate(self, mobject1, mobject2, alpha, path_func=straight_path()):
+    def interpolate(
+        self,
+        mobject1: OpenGLMobject,
+        mobject2: OpenGLMobject,
+        alpha: float,
+        path_func: PathFuncType = straight_path(),
+    ) -> Self:
         """Turns this :class:`~.OpenGLMobject` into an interpolation between ``mobject1``
         and ``mobject2``.
 
@@ -2406,10 +2680,7 @@ class OpenGLMobject:
             if key not in mobject1.data or key not in mobject2.data:
                 continue
 
-            if key in ("points", "bounding_box"):
-                func = path_func
-            else:
-                func = interpolate
+            func = path_func if key in ("points", "bounding_box") else interpolate
 
             self.data[key][:] = func(mobject1.data[key], mobject2.data[key], alpha)
 
@@ -2430,14 +2701,18 @@ class OpenGLMobject:
                 )
         return self
 
-    def pointwise_become_partial(self, mobject, a, b):
+    def pointwise_become_partial(
+        self, mobject: OpenGLMobject, a: float, b: float
+    ) -> Self:
         """
         Set points in such a way as to become only
         part of mobject.
         Inputs 0 <= a < b <= 1 determine what portion
         of mobject to become.
+
+        Returns `self` to allow method chaining.
         """
-        pass  # To implement in subclass
+        return self  # To implement in subclass
 
     def become(
         self,
@@ -2447,7 +2722,7 @@ class OpenGLMobject:
         match_depth: bool = False,
         match_center: bool = False,
         stretch: bool = False,
-    ):
+    ) -> Self:
         """Edit all data and submobjects to be identical
         to another :class:`~.OpenGLMobject`
 
@@ -2482,7 +2757,6 @@ class OpenGLMobject:
                     circ.become(square)
                     self.wait(0.5)
         """
-
         if stretch:
             mobject.stretch_to_fit_height(self.height)
             mobject.stretch_to_fit_width(self.width)
@@ -2507,7 +2781,7 @@ class OpenGLMobject:
 
     # Locking data
 
-    def lock_data(self, keys):
+    def lock_data(self, keys: Iterable[str]) -> None:
         """
         To speed up some animations, particularly transformations,
         it can be handy to acknowledge which pieces of data
@@ -2521,7 +2795,9 @@ class OpenGLMobject:
         self.refresh_shader_data()
         self.locked_data_keys = set(keys)
 
-    def lock_matching_data(self, mobject1, mobject2):
+    def lock_matching_data(
+        self, mobject1: OpenGLMobject, mobject2: OpenGLMobject
+    ) -> Self:
         for sm, sm1, sm2 in zip(
             self.get_family(),
             mobject1.get_family(),
@@ -2538,57 +2814,57 @@ class OpenGLMobject:
             )
         return self
 
-    def unlock_data(self):
+    def unlock_data(self) -> None:
         for mob in self.get_family():
             mob.locked_data_keys = set()
 
     # Operations touching shader uniforms
 
     @affects_shader_info_id
-    def fix_in_frame(self):
+    def fix_in_frame(self) -> Self:
         self.is_fixed_in_frame = 1.0
         return self
 
     @affects_shader_info_id
-    def fix_orientation(self):
+    def fix_orientation(self) -> Self:
         self.is_fixed_orientation = 1.0
         self.fixed_orientation_center = tuple(self.get_center())
         self.depth_test = True
         return self
 
     @affects_shader_info_id
-    def unfix_from_frame(self):
+    def unfix_from_frame(self) -> Self:
         self.is_fixed_in_frame = 0.0
         return self
 
     @affects_shader_info_id
-    def unfix_orientation(self):
+    def unfix_orientation(self) -> Self:
         self.is_fixed_orientation = 0.0
         self.fixed_orientation_center = (0, 0, 0)
         self.depth_test = False
         return self
 
     @affects_shader_info_id
-    def apply_depth_test(self):
+    def apply_depth_test(self) -> Self:
         self.depth_test = True
         return self
 
     @affects_shader_info_id
-    def deactivate_depth_test(self):
+    def deactivate_depth_test(self) -> Self:
         self.depth_test = False
         return self
 
     # Shader code manipulation
 
-    def replace_shader_code(self, old, new):
+    def replace_shader_code(self, old_code: str, new_code: str) -> Self:
         # TODO, will this work with VMobject structure, given
         # that it does not simpler return shader_wrappers of
         # family?
         for wrapper in self.get_shader_wrapper_list():
-            wrapper.replace_code(old, new)
+            wrapper.replace_code(old_code, new_code)
         return self
 
-    def set_color_by_code(self, glsl_code):
+    def set_color_by_code(self, glsl_code: str) -> Self:
         """
         Takes a snippet of code and inserts it into a
         context which has the following variables:
@@ -2600,11 +2876,11 @@ class OpenGLMobject:
 
     def set_color_by_xyz_func(
         self,
-        glsl_snippet,
-        min_value=-5.0,
-        max_value=5.0,
-        colormap="viridis",
-    ):
+        glsl_snippet: str,
+        min_value: float = -5.0,
+        max_value: float = 5.0,
+        colormap: str = "viridis",
+    ) -> Self:
         """
         Pass in a glsl expression in terms of x, y and z which returns
         a float.
@@ -2613,27 +2889,27 @@ class OpenGLMobject:
         # of the shader code
         for char in "xyz":
             glsl_snippet = glsl_snippet.replace(char, "point." + char)
-        rgb_list = get_colormap_list(colormap)
+        # TODO: get_colormap_list does not exist
+        #   See https://github.com/ManimCommunity/manim/issues/4176
+        rgb_list = get_colormap_list(colormap)  # type: ignore[name-defined]
         self.set_color_by_code(
-            "color.rgb = float_to_color({}, {}, {}, {});".format(
-                glsl_snippet,
-                float(min_value),
-                float(max_value),
-                get_colormap_code(rgb_list),
-            ),
+            f"color.rgb = float_to_color({glsl_snippet}, {float(min_value)}, {float(max_value)}, {get_colormap_code(rgb_list)});",
         )
         return self
 
     # For shader data
 
-    def refresh_shader_wrapper_id(self):
-        self.shader_wrapper.refresh_id()
+    def refresh_shader_wrapper_id(self) -> Self:
+        self.get_shader_wrapper().refresh_id()
         return self
 
-    def get_shader_wrapper(self):
+    def get_shader_wrapper(self) -> "ShaderWrapper":  # noqa: UP037
         from manim.renderer.shader_wrapper import ShaderWrapper
 
-        self.shader_wrapper = ShaderWrapper(
+        # if hasattr(self, "shader_wrapper"):
+        #     return self.shader_wrapper
+
+        self.shader_wrapper: ShaderWrapper = ShaderWrapper(
             vert_data=self.get_shader_data(),
             vert_indices=self.get_shader_vert_indices(),
             uniforms=self.get_shader_uniforms(),
@@ -2644,14 +2920,14 @@ class OpenGLMobject:
         )
         return self.shader_wrapper
 
-    def get_shader_wrapper_list(self):
+    def get_shader_wrapper_list(self) -> Sequence["ShaderWrapper"]:  # noqa: UP037
         shader_wrappers = it.chain(
             [self.get_shader_wrapper()],
             *(sm.get_shader_wrapper_list() for sm in self.submobjects),
         )
         batches = batch_by_property(shader_wrappers, lambda sw: sw.get_id())
 
-        result = []
+        result: list["ShaderWrapper"] = []  # noqa: UP037
         for wrapper_group, _ in batches:
             shader_wrapper = wrapper_group[0]
             if not shader_wrapper.is_valid():
@@ -2661,7 +2937,7 @@ class OpenGLMobject:
                 result.append(shader_wrapper)
         return result
 
-    def check_data_alignment(self, array, data_key):
+    def check_data_alignment(self, array: _ShaderData, data_key: str) -> Self:
         # Makes sure that self.data[key] can be broadcast into
         # the given array, meaning its length has to be either 1
         # or the length of the array
@@ -2673,45 +2949,50 @@ class OpenGLMobject:
             )
         return self
 
-    def get_resized_shader_data_array(self, length):
+    def get_resized_shader_data_array(self, length: float) -> _ShaderData:
         # If possible, try to populate an existing array, rather
         # than recreating it each frame
         points = self.points
-        shader_data = np.zeros(len(points), dtype=self.shader_dtype)
+        shader_data = cast(_ShaderData, np.zeros(len(points), dtype=self.shader_dtype))
         return shader_data
 
-    def read_data_to_shader(self, shader_data, shader_data_key, data_key):
+    def read_data_to_shader(
+        self,
+        shader_data: _ShaderData,  # has structured data type, ex. ("point", np.float32, (3,))
+        shader_data_key: str,
+        data_key: str,
+    ) -> None:
         if data_key in self.locked_data_keys:
             return
         self.check_data_alignment(shader_data, data_key)
         shader_data[shader_data_key] = self.data[data_key]
 
-    def get_shader_data(self):
+    def get_shader_data(self) -> _ShaderData:
         shader_data = self.get_resized_shader_data_array(self.get_num_points())
         self.read_data_to_shader(shader_data, "point", "points")
         return shader_data
 
-    def refresh_shader_data(self):
+    def refresh_shader_data(self) -> None:
         self.get_shader_data()
 
-    def get_shader_uniforms(self):
+    def get_shader_uniforms(self) -> dict[str, Any]:
         return self.uniforms
 
-    def get_shader_vert_indices(self):
+    def get_shader_vert_indices(self) -> Sequence[int] | None:
         return self.shader_indices
 
     @property
-    def submobjects(self):
+    def submobjects(self) -> list[OpenGLMobject]:
         return self._submobjects if hasattr(self, "_submobjects") else []
 
     @submobjects.setter
-    def submobjects(self, submobject_list):
+    def submobjects(self, submobject_list: Iterable[OpenGLMobject]) -> None:
         self.remove(*self.submobjects)
         self.add(*submobject_list)
 
     # Errors
 
-    def throw_error_if_no_points(self):
+    def throw_error_if_no_points(self) -> None:
         if not self.has_points():
             message = (
                 "Cannot call OpenGLMobject.{} " + "for a OpenGLMobject with no points"
@@ -2721,52 +3002,57 @@ class OpenGLMobject:
 
 
 class OpenGLGroup(OpenGLMobject):
-    def __init__(self, *mobjects, **kwargs):
-        if not all([isinstance(m, OpenGLMobject) for m in mobjects]):
-            raise Exception("All submobjects must be of type OpenGLMobject")
+    def __init__(self, *mobjects: OpenGLMobject, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self.add(*mobjects)
 
 
 class OpenGLPoint(OpenGLMobject):
     def __init__(
-        self, location=ORIGIN, artificial_width=1e-6, artificial_height=1e-6, **kwargs
-    ):
-        self.artificial_width = artificial_width
-        self.artificial_height = artificial_height
+        self,
+        location: Point3DLike = ORIGIN,
+        artificial_width: float = 1e-6,
+        artificial_height: float = 1e-6,
+        **kwargs: Any,
+    ) -> None:
+        self.artificial_width: float = artificial_width
+        self.artificial_height: float = artificial_height
         super().__init__(**kwargs)
         self.set_location(location)
 
-    def get_width(self):
+    @override
+    def get_width(self) -> float:
         return self.artificial_width
 
-    def get_height(self):
+    @override
+    def get_height(self) -> float:
         return self.artificial_height
 
-    def get_location(self):
-        return self.points[0].copy()
+    def get_location(self) -> Point3D:
+        return cast(Point3D, self.points[0]).copy()
 
-    def get_bounding_box_point(self, *args, **kwargs):
+    @override
+    def get_bounding_box_point(self, *args: object, **kwargs: Any) -> Point3D:
         return self.get_location()
 
-    def set_location(self, new_loc):
+    def set_location(self, new_loc: Point3DLike) -> None:
         self.set_points(np.array(new_loc, ndmin=2, dtype=float))
 
 
 class _AnimationBuilder:
-    def __init__(self, mobject):
-        self.mobject = mobject
+    def __init__(self, mobject: OpenGLMobject) -> None:
+        self.mobject: OpenGLMobject = mobject
         self.mobject.generate_target()
 
-        self.overridden_animation = None
-        self.is_chaining = False
-        self.methods = []
+        self.overridden_animation: Animation | None = None
+        self.is_chaining: bool = False
+        self.methods: list[MethodWithArgs] = []
 
         # Whether animation args can be passed
-        self.cannot_pass_args = False
-        self.anim_args = {}
+        self.cannot_pass_args: bool = False
+        self.anim_args: dict[str, object] = {}
 
-    def __call__(self, **kwargs):
+    def __call__(self, **kwargs: Any) -> Self:
         if self.cannot_pass_args:
             raise ValueError(
                 "Animation arguments must be passed before accessing methods and can only be passed once",
@@ -2777,26 +3063,30 @@ class _AnimationBuilder:
 
         return self
 
-    def __getattr__(self, method_name):
+    def __getattr__(self, method_name: str) -> Callable[..., Self]:
         method = getattr(self.mobject.target, method_name)
         has_overridden_animation = hasattr(method, "_override_animate")
 
         if (self.is_chaining and has_overridden_animation) or self.overridden_animation:
             raise NotImplementedError(
-                "Method chaining is currently not supported for "
-                "overridden animations",
+                "Method chaining is currently not supported for overridden animations",
             )
 
-        def update_target(*method_args, **method_kwargs):
+        # NOTE: using `Self` here should not be a problem, because it's equivalent to a `TypeVar` introduced in `__getattr__`.
+        #   For this reason, here it's still in scope and can be used (that's why pyright does not flag this as an error).
+        #   However, mypy currently does not seem to understand this: hence the `type: ignore` comment.
+        def update_target(*method_args: object, **method_kwargs: object) -> Self:  # type: ignore[type-var, misc]
             if has_overridden_animation:
-                self.overridden_animation = method._override_animate(
+                self.overridden_animation = cast(
+                    "Callable[..., Animation]", method._override_animate
+                )(
                     self.mobject,
                     *method_args,
                     anim_args=self.anim_args,
                     **method_kwargs,
                 )
             else:
-                self.methods.append([method, method_args, method_kwargs])
+                self.methods.append(MethodWithArgs(method, method_args, method_kwargs))
                 method(*method_args, **method_kwargs)
             return self
 
@@ -2805,13 +3095,12 @@ class _AnimationBuilder:
 
         return update_target
 
-    def build(self):
+    def build(self) -> "Animation":  # noqa: UP037
         from manim.animation.transform import _MethodAnimation
 
-        if self.overridden_animation:
-            anim = self.overridden_animation
-        else:
-            anim = _MethodAnimation(self.mobject, self.methods)
+        # NOTE: To fix this mypy error, we'll need to update `_MethodAnimation` to accept `Mobject | OpenGLMobject` instead of `Mobject`.
+        #   Once that is done, the `type: ignore` comment below won't be necessary anymore and mypy will emit a corresponding warning.
+        anim = self.overridden_animation or _MethodAnimation(self.mobject, self.methods)  # type: ignore[arg-type]
 
         for attr, value in self.anim_args.items():
             setattr(anim, attr, value)
@@ -2819,7 +3108,15 @@ class _AnimationBuilder:
         return anim
 
 
-def override_animate(method):
+_Decorated = TypeVar("_Decorated", bound=Callable[..., "Animation"])
+
+
+class _OverrideAnimateDecorator(Protocol):
+    # The slash divider on the next line prevents a mypy error in line 3176.
+    def __call__(self, decorated: _Decorated, /) -> _Decorated: ...
+
+
+def override_animate(method: types.FunctionType) -> _OverrideAnimateDecorator:
     r"""Decorator for overriding method animations.
 
     This allows to specify a method (returning an :class:`~.Animation`)
@@ -2871,8 +3168,8 @@ def override_animate(method):
 
     """
 
-    def decorator(animation_method):
-        method._override_animate = animation_method
+    def decorator(animation_method: _Decorated) -> _Decorated:
+        method._override_animate = animation_method  # type: ignore[attr-defined]
         return animation_method
 
     return decorator