Add rendering loop to experimental

example_scenes/new_test_new.py

@@ -12,7 +12,7 @@
 from manim.animation.creation import Create, DrawBorderThenFill, Write
 from manim.animation.fading import FadeIn
 from manim.animation.transform import Transform
-from manim.camera.camera import OpenGLCameraFrame
+from manim.camera.camera import Camera
 from manim.constants import LEFT, OUT, RIGHT, UP
 from manim.mobject.geometry.arc import Circle
 from manim.mobject.geometry.polygram import Square
@@ -39,6 +39,7 @@ def progress_through_animations(animations):
         win = Window(
             width=1920,
             height=1080,
+            fullscreen=True,
             vsync=True,
             config=Config(double_buffer=True, samples=0),
         )
@@ -70,7 +71,7 @@ def progress_through_animations(animations):
         clock_mobject = DecimalNumber(0.0).shift(4 * LEFT + 2.5 * UP)
         clock_mobject.fix_in_frame()
 
-        camera = OpenGLCameraFrame()
+        camera = Camera()
         camera.save_state()
         # renderer.init_camera(camera)
 
@@ -151,6 +152,8 @@ def on_resize(width, height):
                 if not is_finished:
                     if virtual_time >= run_time:
                         animation.finish()
+                        buffer = str(animation.buffer)
+                        print(f"{buffer = }")
                         has_finished = True
                     else:
                         animation.update_mobjects(dt)

example_scenes/test_new_rendering.py

@@ -0,0 +1,13 @@
+from manim import *
+
+
+class Test(Scene):
+    def construct(self) -> None:
+        s = Square()
+        c = Circle()
+        st = Star(color=YELLOW, fill_color=YELLOW)
+        self.play(Succession(*[Create(x) for x in VGroup(s, c, st).arrange()]))
+
+
+with tempconfig({"renderer": "opengl", "preview": True, "parallel": False}):
+    Test().render()

manim/__init__.py

@@ -37,7 +37,6 @@
 from .animation.transform_matching_parts import *
 from .animation.updaters.mobject_update_utils import *
 from .animation.updaters.update import *
-from .camera.cairo_camera import *
 from .constants import *
 from .mobject.frame import *
 from .mobject.geometry.arc import *
@@ -73,7 +72,6 @@
 from .mobject.types.vectorized_mobject import *
 from .mobject.value_tracker import *
 from .mobject.vector_field import *
-from .renderer.cairo_renderer import *
 from .scene.scene import *
 from .scene.scene_file_writer import *
 from .scene.section import *

manim/_config/utils.py

@@ -311,6 +311,7 @@ class MyScene(Scene):
         "write_to_movie",
         "zero_pad",
         "force_window",
+        "parallel",
     }
 
     def __init__(self) -> None:
@@ -582,6 +583,7 @@ def digest_parser(self, parser: configparser.ConfigParser) -> ManimConfig:
             "use_projection_stroke_shaders",
             "enable_wireframe",
             "force_window",
+            "parallel",
         ]:
             setattr(self, key, parser["CLI"].getboolean(key, fallback=False))
 
@@ -995,6 +997,14 @@ def format(self, val: str) -> None:
                 "Output format set as webm, this can be slower than other formats",
             )
 
+    @property
+    def in_parallel(self) -> None:
+        return self._d["parallel"]
+
+    @in_parallel.setter
+    def in_parallel(self, val: bool) -> None:
+        self._set_boolean("parallel", val)
+
     ffmpeg_loglevel = property(
         lambda self: self._d["ffmpeg_loglevel"],
         lambda self, val: self._set_from_list(

manim/animation/animation.py

@@ -11,22 +11,23 @@
 from ..mobject.mobject import Mobject
 from ..mobject.opengl import opengl_mobject
 from ..utils.rate_functions import linear, smooth
+from .protocol import AnimationProtocol
+from .scene_buffer import SceneBuffer
 
 __all__ = ["Animation", "Wait", "override_animation"]
 
-
 from copy import deepcopy
-from typing import TYPE_CHECKING, Callable, Iterable, Sequence
+from typing import TYPE_CHECKING, Callable, Iterable, Sequence, TypeVar
 
 if TYPE_CHECKING:
-    from manim.scene.scene import Scene
+    from typing_extensions import Self
 
 
 DEFAULT_ANIMATION_RUN_TIME: float = 1.0
 DEFAULT_ANIMATION_LAG_RATIO: float = 0.0
 
 
-class Animation:
+class Animation(AnimationProtocol):
     """An animation.
 
     Animations have a fixed time span.
@@ -127,17 +128,17 @@ def __new__(
 
     def __init__(
         self,
-        mobject: Mobject | None,
+        mobject: OpenGLMobject | None,
         lag_ratio: float = DEFAULT_ANIMATION_LAG_RATIO,
         run_time: float = DEFAULT_ANIMATION_RUN_TIME,
         rate_func: Callable[[float], float] = smooth,
         reverse_rate_function: bool = False,
-        name: str = None,
-        remover: bool = False,  # remove a mobject from the screen?
+        name: str | None = None,
+        remover: bool = False,  # remove a mobject from the screen at end of animation
         suspend_mobject_updating: bool = True,
         introducer: bool = False,
         *,
-        _on_finish: Callable[[], None] = lambda _: None,
+        _on_finish: Callable[[SceneBuffer], object] = lambda _: None,
         **kwargs,
     ) -> None:
         self._typecheck_input(mobject)
@@ -149,15 +150,15 @@ def __init__(
         self.introducer: bool = introducer
         self.suspend_mobject_updating: bool = suspend_mobject_updating
         self.lag_ratio: float = lag_ratio
-        self._on_finish: Callable[[Scene], None] = _on_finish
-        if config["renderer"] == RendererType.OPENGL:
-            self.starting_mobject: OpenGLMobject = OpenGLMobject()
-            self.mobject: OpenGLMobject = (
-                mobject if mobject is not None else OpenGLMobject()
-            )
-        else:
-            self.starting_mobject: Mobject = Mobject()
-            self.mobject: Mobject = mobject if mobject is not None else Mobject()
+        self._on_finish = _on_finish
+
+        self.buffer = SceneBuffer()
+        self.apply_buffer = False  # ask scene to apply buffer
+
+        self.starting_mobject: OpenGLMobject = OpenGLMobject()
+        self.mobject: OpenGLMobject = (
+            mobject if mobject is not None else OpenGLMobject()
+        )
         if kwargs:
             logger.debug("Animation received extra kwargs: %s", kwargs)
 
@@ -169,7 +170,7 @@ def __init__(
                 ),
             )
 
-    def _typecheck_input(self, mobject: Mobject | None) -> None:
+    def _typecheck_input(self, mobject: Mobject | OpenGLMobject | None) -> None:
         if mobject is None:
             logger.debug("Animation with empty mobject")
         elif not isinstance(mobject, (Mobject, OpenGLMobject)):
@@ -213,10 +214,12 @@ def begin(self) -> None:
             self.mobject.suspend_updating()
         self.interpolate(0)
 
+        # TODO: Figure out a way to check
+        # if self.mobject in scene.get_mobject_family
+        if self.is_introducer():
+            self.buffer.add(self.mobject)
+
     def finish(self) -> None:
-        # TODO: begin and finish should require a scene as parameter.
-        # That way Animation.clean_up_from_screen and Scene.add_mobjects_from_animations
-        # could be removed as they fulfill basically the same purpose.
         """Finish the animation.
 
         This method gets called when the animation is over.
@@ -226,39 +229,9 @@ def finish(self) -> None:
         if self.suspend_mobject_updating and self.mobject is not None:
             self.mobject.resume_updating()
 
-    def clean_up_from_scene(self, scene: Scene) -> None:
-        """Clean up the :class:`~.Scene` after finishing the animation.
-
-        This includes to :meth:`~.Scene.remove` the Animation's
-        :class:`~.Mobject` if the animation is a remover.
-
-        Parameters
-        ----------
-        scene
-            The scene the animation should be cleaned up from.
-        """
-        self._on_finish(scene)
+        self._on_finish(self.buffer)
         if self.is_remover():
-            scene.remove(self.mobject)
-
-    def _setup_scene(self, scene: Scene) -> None:
-        """Setup up the :class:`~.Scene` before starting the animation.
-
-        This includes to :meth:`~.Scene.add` the Animation's
-        :class:`~.Mobject` if the animation is an introducer.
-
-        Parameters
-        ----------
-        scene
-            The scene the animation should be cleaned up from.
-        """
-        if scene is None:
-            return
-        if (
-            self.is_introducer()
-            and self.mobject not in scene.get_mobject_family_members()
-        ):
-            scene.add(self.mobject)
+            self.buffer.remove(self.mobject)
 
     def create_starting_mobject(self) -> Mobject:
         # Keep track of where the mobject starts
@@ -294,6 +267,17 @@ def update_mobjects(self, dt: float) -> None:
         for mob in self.get_all_mobjects_to_update():
             mob.update(dt)
 
+    def process_subanimation_buffer(self, buffer: SceneBuffer):
+        """
+        This is used in animations that are proxies around
+        other animations, like :class:`.AnimationGroup`
+        """
+        self.buffer.remove(*buffer.to_remove)
+        for to_replace_pairs in buffer.to_replace:
+            self.buffer.replace(*to_replace_pairs)
+        self.buffer.add(*buffer.to_add)
+        buffer.clear()
+
     def get_all_mobjects_to_update(self) -> list[Mobject]:
         """Get all mobjects to be updated during the animation.
 
@@ -305,9 +289,9 @@ def get_all_mobjects_to_update(self) -> list[Mobject]:
         # The surrounding scene typically handles
         # updating of self.mobject.  Besides, in
         # most cases its updating is suspended anyway
-        return list(filter(lambda m: m is not self.mobject, self.get_all_mobjects()))
+        return [m for m in self.get_all_mobjects() if m is not self.mobject]
 
-    def copy(self) -> Animation:
+    def copy(self) -> Self:
         """Create a copy of the animation.
 
         Returns
@@ -343,7 +327,7 @@ def interpolate_mobject(self, alpha: float) -> None:
             is completed. For example, alpha-values of 0, 0.5, and 1 correspond
             to the animation being completed 0%, 50%, and 100%, respectively.
         """
-        families = list(self.get_all_families_zipped())
+        families = tuple(self.get_all_families_zipped())
         for i, mobs in enumerate(families):
             sub_alpha = self.get_sub_alpha(alpha, i, len(families))
             self.interpolate_submobject(*mobs, sub_alpha)
@@ -356,7 +340,7 @@ def interpolate_submobject(
         alpha: float,
     ) -> Animation:
         # Typically implemented by subclass
-        pass
+        raise NotImplementedError()
 
     def get_sub_alpha(self, alpha: float, index: int, num_submobjects: int) -> float:
         """Get the animation progress of any submobjects subanimation.
@@ -422,7 +406,7 @@ def get_run_time(self) -> float:
     def set_rate_func(
         self,
         rate_func: Callable[[float], float],
-    ) -> Animation:
+    ) -> Self:
         """Set the rate function of the animation.
 
         Parameters
@@ -451,7 +435,7 @@ def get_rate_func(
         """
         return self.rate_func
 
-    def set_name(self, name: str) -> Animation:
+    def set_name(self, name: str) -> Self:
         """Set the name of the animation.
 
         Parameters
@@ -489,7 +473,9 @@ def is_introducer(self) -> bool:
 
 
 def prepare_animation(
-    anim: Animation | mobject._AnimationBuilder,
+    anim: AnimationProtocol
+    | mobject._AnimationBuilder
+    | opengl_mobject._AnimationBuilder,
 ) -> Animation:
     r"""Returns either an unchanged animation, or the animation built
     from a passed animation factory.
@@ -517,10 +503,7 @@ def prepare_animation(
         TypeError: Object 42 cannot be converted to an animation
 
     """
-    if isinstance(anim, mobject._AnimationBuilder):
-        return anim.build()
-
-    if isinstance(anim, opengl_mobject._AnimationBuilder):
+    if isinstance(anim, (mobject._AnimationBuilder, opengl_mobject._AnimationBuilder)):
         return anim.build()
 
     if isinstance(anim, Animation):
@@ -576,9 +559,6 @@ def begin(self) -> None:
     def finish(self) -> None:
         pass
 
-    def clean_up_from_scene(self, scene: Scene) -> None:
-        pass
-
     def update_mobjects(self, dt: float) -> None:
         pass
 
@@ -625,7 +605,9 @@ def construct(self):
 
     """
 
-    def decorator(func):
+    _F = TypeVar("_F", bound=Callable)
+
+    def decorator(func: _F) -> _F:
         func._override_animation = animation_class
         return func