Add dearpygui integration

example_scenes/opengl.py

@@ -4,6 +4,7 @@
 import manim.utils.opengl as opengl
 import manim.utils.space_ops as space_ops
 from manim import *
+from manim.cli.new.group import scene
 from manim.opengl import *
 
 # Copied from https://3b1b.github.io/manim/getting_started/example_scenes.html#surfaceexample.
@@ -72,6 +73,49 @@ def get_plane_mesh(context):
     return Mesh(shader, attributes)
 
 
+class GuiTest(Scene):
+    def construct(self):
+        mesh = get_plane_mesh(self.renderer.context)
+        # mesh.attributes["in_vert"][:, 0]
+        self.add(mesh)
+
+        def update_mesh(mesh, dt):
+            mesh.model_matrix = np.matmul(
+                opengl.rotation_matrix(z=dt), mesh.model_matrix
+            )
+
+        mesh.add_updater(update_mesh)
+
+        self.interactive_embed()
+
+
+class GuiTest2(Scene):
+    def construct(self):
+        mesh = get_plane_mesh(self.renderer.context)
+        mesh.attributes["in_vert"][:, 0] -= 2
+        self.add(mesh)
+
+        mesh2 = get_plane_mesh(self.renderer.context)
+        mesh2.attributes["in_vert"][:, 0] += 2
+        self.add(mesh2)
+
+        def callback(sender, data):
+            mesh2.attributes["in_color"][:, 3] = dpg.get_value(sender)
+
+        self.widgets.append(
+            {
+                "name": "mesh2 opacity",
+                "widget": "slider_float",
+                "callback": callback,
+                "min_value": 0,
+                "max_value": 1,
+                "default_value": 1,
+            }
+        )
+
+        self.interactive_embed()
+
+
 class ThreeDMobjectTest(Scene):
     def construct(self):
         # config["background_color"] = "#333333"
@@ -98,7 +142,9 @@ def update_mesh(mesh, dt):
 class NamedFullScreenQuad(Scene):
     def construct(self):
         surface = FullScreenQuad(self.renderer.context, fragment_shader_name="design_3")
-        surface.shader.set_uniform("u_resolution", (854.0, 480.0, 0.0))
+        surface.shader.set_uniform(
+            "u_resolution", (config["pixel_width"], config["pixel_height"], 0.0)
+        )
         surface.shader.set_uniform("u_time", 0)
         self.add(surface)
 
@@ -127,6 +173,7 @@ def construct(self):
 
             uniform vec2 u_resolution;
             uniform float u_time;
+            out vec4 frag_color;
 
             //  Function from Iñigo Quiles
             //  https://www.shadertoy.com/view/MsS3Wc
@@ -153,12 +200,13 @@ def construct(self):
                 // and the Saturation to the radius
                 color = hsb2rgb(vec3((angle/TWO_PI)+0.5,radius,1.0));
 
-                gl_FragColor = vec4(color,1.0);
+                frag_color = vec4(color,1.0);
             }
             """,
-            output_color_variable="gl_FragColor",
         )
-        surface.shader.set_uniform("u_resolution", (854.0, 480.0))
+        surface.shader.set_uniform(
+            "u_resolution", (config["pixel_width"], config["pixel_height"])
+        )
         shader_time = 0
 
         def update_surface(surface):
@@ -182,6 +230,7 @@ def construct(self):
             uniform float v_red;
             uniform float v_green;
             uniform float v_blue;
+            out vec4 frag_color;
 
             void main() {
               frag_color = vec4(v_red, v_green, v_blue, 1);

manim/_config/default.cfg

@@ -98,6 +98,12 @@ webgl_renderer_path =
 # --use_opengl_renderer
 use_opengl_renderer = False
 
+# --enable_gui
+enable_gui = False
+
+# --gui_location
+gui_location = 40,800
+
 # 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/_config/utils.py

@@ -15,6 +15,7 @@
 import errno
 import logging
 import os
+import re
 import sys
 import typing
 from collections.abc import Mapping, MutableMapping
@@ -282,6 +283,8 @@ class MyScene(Scene):
         "renderer",
         "use_opengl_renderer",
         "use_webgl_renderer",
+        "enable_gui",
+        "gui_location",
         "verbosity",
         "video_dir",
         "write_all",
@@ -407,6 +410,12 @@ def _set_boolean(self, key: typing.Union[str, int], val: typing.Any) -> None:
         else:
             raise ValueError(f"{key} must be boolean")
 
+    def _set_tuple(self, key: str, val: tuple) -> None:
+        if isinstance(val, tuple):
+            self._d[key] = val
+        else:
+            raise ValueError(f"{key} must be tuple")
+
     def _set_str(self, key: str, val: typing.Any) -> None:
         """Set ``key`` to ``val`` if ``val`` is a string."""
         if isinstance(val, str):
@@ -509,6 +518,7 @@ def digest_parser(self, parser: configparser.ConfigParser) -> "ManimConfig":
             "custom_folders",
             "use_opengl_renderer",
             "use_webgl_renderer",
+            "enable_gui",
         ]:
             setattr(self, key, parser["CLI"].getboolean(key, fallback=False))
 
@@ -553,6 +563,10 @@ def digest_parser(self, parser: configparser.ConfigParser) -> "ManimConfig":
             # "frame_height",
         ]:
             setattr(self, key, parser["CLI"].getfloat(key))
+
+        gui_location = tuple(map(int, re.split(";|,|-", parser["CLI"]["gui_location"])))
+        setattr(self, "gui_location", gui_location)
+
         # plugins
         self.plugins = parser["CLI"].get("plugins", fallback="", raw=True).split(",")
         # the next two must be set AFTER digesting pixel_width and pixel_height
@@ -638,6 +652,7 @@ def digest_args(self, args: argparse.Namespace) -> "ManimConfig":
             "background_color",
             "use_opengl_renderer",
             "use_webgl_renderer",
+            "enable_gui",
         ]:
             if hasattr(args, key):
                 attr = getattr(args, key)
@@ -715,6 +730,9 @@ def digest_args(self, args: argparse.Namespace) -> "ManimConfig":
                 # --write_to_movie was not passed on the command line, so don't generate video.
                 self["write_to_movie"] = False
 
+        # Handle --gui_location flag.
+        self.gui_location = args.gui_location
+
         return self
 
     def digest_file(self, filename: str) -> "ManimConfig":
@@ -760,7 +778,7 @@ def digest_file(self, filename: str) -> "ManimConfig":
 
     # config options are properties
     preview = property(
-        lambda self: self._d["preview"],
+        lambda self: self._d["preview"] or self._d["enable_gui"],
         lambda self, val: self._set_boolean("preview", val),
         doc="Whether to play the rendered movie (-p).",
     )
@@ -1129,6 +1147,18 @@ def use_webgl_renderer(self, val: bool) -> None:
         doc="Main output directory.  See :meth:`ManimConfig.get_dir`.",
     )
 
+    enable_gui = property(
+        lambda self: self._d["enable_gui"],
+        lambda self, val: self._set_boolean("enable_gui", val),
+        doc="Enable GUI interaction.",
+    )
+
+    gui_location = property(
+        lambda self: self._d["gui_location"],
+        lambda self, val: self._set_tuple("gui_location", val),
+        doc="Enable GUI interaction.",
+    )
+
     def get_dir(self, key: str, **kwargs: str) -> Path:
         """Resolve a config option that stores a directory.
 

manim/cli/render/global_options.py

@@ -1,6 +1,21 @@
+import re
+
 import click
 from cloup import option, option_group
 
+from ... import logger
+
+
+def validate_gui_location(ctx, param, value):
+    if value:
+        try:
+            x_offset, y_offset = map(int, re.split(";|,|-", value))
+            return (x_offset, y_offset)
+        except Exception:
+            logger.error("GUI location option is invalid.")
+            exit()
+
+
 global_options = option_group(
     "Global options",
     option(
@@ -36,4 +51,15 @@
         default=None,
         help="Display warnings for outdated installation.",
     ),
+    option(
+        "--enable_gui",
+        is_flag=True,
+        help="Enable GUI interaction.",
+    ),
+    option(
+        "--gui_location",
+        default="40,800",
+        callback=validate_gui_location,
+        help="Starting location for the GUI.",
+    ),
 )

manim/cli/render/render_options.py

@@ -26,10 +26,7 @@ def validate_resolution(ctx, param, value):
     if value:
         try:
             start, end = map(int, re.split(";|,|-", value))
-            return (
-                start,
-                end,
-            )
+            return (start, end)
         except Exception:
             logger.error("Resolution option is invalid.")
             exit()

manim/gui/gui.py

@@ -0,0 +1,71 @@
+from pathlib import Path
+
+try:
+    import dearpygui.core
+    import dearpygui.demo
+    import dearpygui.simple
+
+    dearpygui_imported = True
+except ImportError:
+    dearpygui_imported = False
+
+
+from .. import config
+from ..utils.module_ops import scene_classes_from_file
+
+
+def configure_pygui(renderer, widgets, update=True):
+    if not dearpygui_imported:
+        raise RuntimeError("Attempted to use DearPyGUI when it isn't imported.")
+    if update:
+        dearpygui.core.delete_item("Manim GUI")
+
+    def rerun_callback(sender, data):
+        renderer.scene.queue.put(("rerun_gui", [], {}))
+
+    def continue_callback(sender, data):
+        renderer.scene.queue.put(("exit_gui", [], {}))
+
+    def scene_selection_callback(sender, data):
+        config["scene_names"] = (dearpygui.core.get_value(sender),)
+        renderer.scene.queue.put(("rerun_gui", [], {}))
+
+    scene_classes = scene_classes_from_file(Path(config["input_file"]), full_list=True)
+    scene_names = [scene_class.__name__ for scene_class in scene_classes]
+
+    with dearpygui.simple.window(
+        "Manim GUI",
+        x_pos=config["gui_location"][0],
+        y_pos=config["gui_location"][1],
+        width=1000,
+        height=500,
+    ):
+        dearpygui.core.set_global_font_scale(2)
+        dearpygui.core.add_button("Rerun", callback=rerun_callback)
+        dearpygui.core.add_button("Continue", callback=continue_callback)
+        dearpygui.core.add_combo(
+            "Selected scene",
+            items=scene_names,
+            callback=scene_selection_callback,
+            default_value=config["scene_names"][0],
+        )
+        dearpygui.core.add_separator()
+        if len(widgets) != 0:
+            with dearpygui.simple.collapsing_header(
+                f"{config['scene_names'][0]} widgets", default_open=True
+            ):
+                for widget_config in widgets:
+                    widget_config_copy = widget_config.copy()
+                    name = widget_config_copy["name"]
+                    widget = widget_config_copy["widget"]
+                    if widget != "separator":
+                        del widget_config_copy["name"]
+                        del widget_config_copy["widget"]
+                        getattr(dearpygui.core, f"add_{widget}")(
+                            name, **widget_config_copy
+                        )
+                    else:
+                        dearpygui.core.add_separator()
+    # dearpygui.demo.show_demo()
+    if not update:
+        dearpygui.core.start_dearpygui()

manim/mobject/opengl_three_dimensions.py

@@ -1,5 +1,7 @@
 import math
 
+import numpy as np
+
 from ..constants import *
 from ..mobject.types.opengl_surface import OpenGLSurface
 from ..mobject.types.opengl_vectorized_mobject import OpenGLVGroup, OpenGLVMobject

manim/opengl/__init__.py

@@ -1,3 +1,5 @@
+from dearpygui import core as dpg
+
 from ..mobject.opengl_geometry import *
 from ..mobject.opengl_mobject import *
 from ..mobject.opengl_three_dimensions import *