Add OpenGL Renderer (#1075)

Adds and OpenGL renderer, OpenGL-enabled Mobjects, and a Scene.embed() method.

Author: eulertour

.github/workflows/ci.yml

@@ -50,7 +50,7 @@ jobs:
         run: |
           sudo apt update
           sudo apt install -y ffmpeg
-          sudo apt-get -y install texlive texlive-latex-extra texlive-fonts-extra texlive-latex-recommended texlive-science texlive-fonts-extra tipa
+          sudo apt-get -y install texlive texlive-latex-extra texlive-fonts-extra texlive-latex-recommended texlive-science texlive-fonts-extra tipa python-opengl libpango1.0-dev
           echo "$HOME/.poetry/bin" >> $GITHUB_PATH
 
       - name: Install system dependencies (MacOS)
@@ -118,7 +118,7 @@ jobs:
         run: poetry run pytest
 
       - name: Run module doctests
-        run: poetry run pytest --doctest-modules manim
+        run: poetry run pytest --doctest-modules --ignore-glob="*opengl*" manim
 
       - name: Run doctests in rst files
         run: cd docs && pip install -r requirements.txt && poetry run make doctest O=-tskip-manim

docs/source/tutorials/configuration.rst

@@ -357,8 +357,9 @@ A list of all config options
    'preview', 'progress_bar', 'quality', 'right_side', 'save_as_gif', 'save_last_frame',
    'save_pngs', 'scene_names', 'show_in_file_browser', 'sound', 'tex_dir',
    'tex_template', 'tex_template_file', 'text_dir', 'top', 'transparent',
-   'upto_animation_number', 'use_webgl_renderer', 'verbosity', 'video_dir',
-   'webgl_renderer_path', 'webgl_updater_fps', 'write_all', 'write_to_movie']
+   'upto_animation_number', 'use_opengl_renderer', 'use_webgl_renderer', 'verbosity',
+   'video_dir', 'webgl_renderer_path', 'webgl_updater_fps', 'write_all',
+   'write_to_movie']
 
 
 A list of all CLI flags
@@ -430,6 +431,8 @@ A list of all CLI flags
      -n FROM_ANIMATION_NUMBER, --from_animation_number FROM_ANIMATION_NUMBER
                            Start rendering at the specified animation index, instead of the first animation. If you pass in two comma separated values, e.g. '3,6', it will end
                            the rendering at the second value
+     --use_opengl_renderer
+                              Render animations using the OpenGL renderer
      --use_webgl_renderer     Render animations using the WebGL frontend
      --webgl_renderer_path WEBGL_RENDERER_PATH
                            Path to the WebGL frontend

example_scenes/assets/1280px-The_earth_at_night.jpg

@@ -0,0 +1,136 @@
+from manim import *
+from manim.opengl import *
+import os
+from pathlib import Path
+
+
+# Copied from https://3b1b.github.io/manim/getting_started/example_scenes.html#surfaceexample.
+# Lines that do not yet work with the Community Version are commented.
+
+
+class InteractiveDevelopment(Scene):
+    def construct(self):
+        circle = OpenGLCircle()
+        circle.set_fill(BLUE, opacity=0.5)
+        circle.set_stroke(BLUE_E, width=4)
+        square = OpenGLSquare()
+
+        self.play(ShowCreation(square))
+        self.wait()
+
+        # This opens an iPython termnial where you can keep writing
+        # lines as if they were part of this construct method.
+        # In particular, 'square', 'circle' and 'self' will all be
+        # part of the local namespace in that terminal.
+        self.embed()
+
+        # Try copying and pasting some of the lines below into
+        # the interactive shell
+        self.play(ReplacementTransform(square, circle))
+        self.wait()
+        self.play(circle.animate.stretch(4, 0))
+        self.play(Rotate(circle, 90 * DEGREES))
+        self.play(circle.animate.shift(2 * RIGHT).scale(0.25))
+
+        # text = Text("""
+        #     In general, using the interactive shell
+        #     is very helpful when developing new scenes
+        # """)
+        # self.play(Write(text))
+
+        # # In the interactive shell, you can just type
+        # # play, add, remove, clear, wait, save_state and restore,
+        # # instead of self.play, self.add, self.remove, etc.
+
+        # # To interact with the window, type touch().  You can then
+        # # scroll in the window, or zoom by holding down 'z' while scrolling,
+        # # and change camera perspective by holding down 'd' while moving
+        # # the mouse.  Press 'r' to reset to the standard camera position.
+        # # Press 'q' to stop interacting with the window and go back to
+        # # typing new commands into the shell.
+
+        # # In principle you can customize a scene to be responsive to
+        # # mouse and keyboard interactions
+        # always(circle.move_to, self.mouse_point)
+
+
+class SurfaceExample(Scene):
+    def construct(self):
+        # surface_text = Text("For 3d scenes, try using surfaces")
+        # surface_text.fix_in_frame()
+        # surface_text.to_edge(UP)
+        # self.add(surface_text)
+        # self.wait(0.1)
+
+        torus1 = OpenGLTorus(r1=1, r2=1)
+        torus2 = OpenGLTorus(r1=3, r2=1)
+        sphere = OpenGLSphere(radius=3, resolution=torus1.resolution)
+        # You can texture a surface with up to two images, which will
+        # be interpreted as the side towards the light, and away from
+        # the light.  These can be either urls, or paths to a local file
+        # in whatever you've set as the image directory in
+        # the custom_config.yml file
+
+        script_location = Path(os.path.realpath(__file__)).parent
+        day_texture = (
+            script_location / "assets" / "1280px-Whole_world_-_land_and_oceans.jpg"
+        )
+        night_texture = script_location / "assets" / "1280px-The_earth_at_night.jpg"
+
+        surfaces = [
+            OpenGLTexturedSurface(surface, day_texture, night_texture)
+            for surface in [sphere, torus1, torus2]
+        ]
+
+        for mob in surfaces:
+            mob.shift(IN)
+            mob.mesh = OpenGLSurfaceMesh(mob)
+            mob.mesh.set_stroke(BLUE, 1, opacity=0.5)
+
+        # Set perspective
+        frame = self.renderer.camera
+        frame.set_euler_angles(
+            theta=-30 * DEGREES,
+            phi=70 * DEGREES,
+        )
+
+        surface = surfaces[0]
+
+        self.play(
+            FadeIn(surface),
+            ShowCreation(surface.mesh, lag_ratio=0.01, run_time=3),
+        )
+        for mob in surfaces:
+            mob.add(mob.mesh)
+        surface.save_state()
+        self.play(Rotate(surface, PI / 2), run_time=2)
+        for mob in surfaces[1:]:
+            mob.rotate(PI / 2)
+
+        self.play(Transform(surface, surfaces[1]), run_time=3)
+
+        self.play(
+            Transform(surface, surfaces[2]),
+            # Move camera frame during the transition
+            frame.animate.increment_phi(-10 * DEGREES),
+            frame.animate.increment_theta(-20 * DEGREES),
+            run_time=3,
+        )
+        # Add ambient rotation
+        frame.add_updater(lambda m, dt: m.increment_theta(-0.1 * dt))
+
+        # Play around with where the light is
+        # light_text = Text("You can move around the light source")
+        # light_text.move_to(surface_text)
+        # light_text.fix_in_frame()
+
+        # self.play(FadeTransform(surface_text, light_text))
+        light = self.camera.light_source
+        self.add(light)
+        light.save_state()
+        self.play(light.animate.move_to(3 * IN), run_time=5)
+        self.play(light.animate.shift(10 * OUT), run_time=5)
+
+        # drag_text = Text("Try moving the mouse while pressing d or s")
+        # drag_text.move_to(light_text)
+        # drag_text.fix_in_frame()

example_scenes/assets/1280px-Whole_world_-_land_and_oceans.jpg

@@ -73,7 +73,18 @@ def main():
     else:
         config.digest_args(args)
         input_file = config.get_dir("input_file")
-        if config["use_webgl_renderer"]:
+
+        if config["use_opengl_renderer"]:
+            from manim.renderer.opengl_renderer import OpenGLRenderer
+
+            for SceneClass in scene_classes_from_file(input_file):
+                try:
+                    renderer = OpenGLRenderer()
+                    scene = SceneClass(renderer)
+                    scene.render()
+                except Exception:
+                    console.print_exception()
+        elif config["use_webgl_renderer"]:
             try:
                 from manim.grpc.impl import frame_server_impl
 

example_scenes/opengl.py

@@ -93,6 +93,9 @@ webgl_renderer_path =
 # --webgl_updater_fps
 webgl_updater_fps = 15
 
+# --use_opengl_renderer
+use_opengl_renderer = False
+
 # If the -t (--transparent) flag is used, these will be replaced with the
 # values specified in the [TRANSPARENT] section later in this file.
 png_mode = RGB

manim/__main__.py

@@ -410,6 +410,13 @@ def _parse_args_no_subcmd(args: list) -> argparse.Namespace:
         "the rendering at the second value",
     )
 
+    parser.add_argument(
+        "--use_opengl_renderer",
+        help="Render animations using the OpenGL renderer",
+        action="store_const",
+        const=True,
+    )
+
     parser.add_argument(
         "--use_webgl_renderer",
         help="Render animations using the WebGL frontend",

manim/_config/default.cfg

@@ -287,6 +287,7 @@ class MyScene(Scene):
         "tex_template_file",
         "text_dir",
         "upto_animation_number",
+        "use_opengl_renderer",
         "use_webgl_renderer",
         "webgl_updater_fps",
         "verbosity",
@@ -510,6 +511,7 @@ def digest_parser(self, parser: configparser.ConfigParser) -> "ManimConfig":
             "disable_caching",
             "flush_cache",
             "custom_folders",
+            "use_opengl_renderer",
             "use_webgl_renderer",
         ]:
             setattr(self, key, parser["CLI"].getboolean(key, fallback=False))
@@ -629,6 +631,7 @@ def digest_args(self, args: argparse.Namespace) -> "ManimConfig":
             "scene_names",
             "verbosity",
             "background_color",
+            "use_opengl_renderer",
             "use_webgl_renderer",
             "webgl_updater_fps",
         ]:
@@ -705,6 +708,11 @@ def digest_args(self, args: argparse.Namespace) -> "ManimConfig":
         if args.tex_template:
             self.tex_template = TexTemplateFromFile(tex_filename=args.tex_template)
 
+        if self.use_opengl_renderer:
+            if getattr(args, "write_to_movie") is None:
+                # --write_to_movie was not passed on the command line, so don't generate video.
+                self["write_to_movie"] = False
+
         return self
 
     def digest_file(self, filename: str) -> "ManimConfig":
@@ -1046,9 +1054,20 @@ def dry_run(self, val: bool) -> None:
                 "save_last_frame, save_pngs, or save_as_gif)"
             )
 
+    @property
+    def use_opengl_renderer(self):
+        """Whether or not to use the OpenGL renderer."""
+        return self._d["use_opengl_renderer"]
+
+    @use_opengl_renderer.setter
+    def use_opengl_renderer(self, val: bool) -> None:
+        self._d["use_opengl_renderer"] = val
+        if val:
+            self["disable_caching"] = True
+
     @property
     def use_webgl_renderer(self):
-        """Whether to use WebGL renderer or not (default)."""
+        """Whether or not to use WebGL renderer."""
         return self._d["use_webgl_renderer"]
 
     @use_webgl_renderer.setter

manim/_config/main_utils.py

@@ -14,8 +14,11 @@
     from manim.scene.scene import Scene
 
 from .. import logger
-from ..mobject.mobject import Mobject, _AnimationBuilder
+from ..mobject import mobject
+from ..mobject import opengl_mobject
+from ..mobject.mobject import Mobject
 from ..utils.rate_functions import smooth
+from ..mobject.opengl_mobject import OpenGLMobject
 
 DEFAULT_ANIMATION_RUN_TIME: float = 1.0
 DEFAULT_ANIMATION_LAG_RATIO: float = 0.0
@@ -61,7 +64,9 @@ def __init__(
     def _typecheck_input(self, mobject: Mobject) -> None:
         if mobject is None:
             logger.debug("creating dummy animation")
-        elif not isinstance(mobject, Mobject):
+        elif not isinstance(mobject, Mobject) and not isinstance(
+            mobject, OpenGLMobject
+        ):
             raise TypeError("Animation only works on Mobjects")
 
     def __str__(self) -> str:
@@ -195,7 +200,9 @@ def is_remover(self) -> bool:
         return self.remover
 
 
-def prepare_animation(anim: Union["Animation", "_AnimationBuilder"]) -> "Animation":
+def prepare_animation(
+    anim: Union["Animation", "mobject._AnimationBuilder"]
+) -> "Animation":
     r"""Returns either an unchanged animation, or the animation built
     from a passed animation factory.
 
@@ -222,7 +229,10 @@ def prepare_animation(anim: Union["Animation", "_AnimationBuilder"]) -> "Animati
         TypeError: Object 42 cannot be converted to an animation
 
     """
-    if isinstance(anim, _AnimationBuilder):
+    if isinstance(anim, mobject._AnimationBuilder):
+        return anim.build()
+
+    if isinstance(anim, opengl_mobject._AnimationBuilder):
         return anim.build()
 
     if isinstance(anim, Animation):