Add interface to JS renderer (#465)

* Add interface to JS renderer

* Update manim_directive.py

* Add simple flag to get_style()

* Change add_frames to add_frame

* Update changelog.rst

Author: eulertour

docs/source/changelog.rst

@@ -32,6 +32,7 @@ Command line
 #. Re-implement GIF export with the :code:`-i` flag (using this flag outputs ONLY a .gif file, and no .mp4 file)
 #. Added a :code:`--verbose` flag
 #. You can save the logs to a file by using :code:`--log_to_file`
+#. Add experimental javascript rendering with :code:`--use_js_renderer`
 
 
 Config system
@@ -62,6 +63,7 @@ Mobjects, Scenes, and Animations
 #. Add a :code:`Variable` class for displaying text that continuously updates to reflect the value of a python variable.
 #. The ``Tex`` and ``MathTex`` objects allow you to specify a custom TexTemplate using the ``template`` keyword argument.
 #. :code:`VGroup` now supports printing the class names of contained mobjects and :code:`VDict` supports printing the internal dict of mobjects
+#. :code:`Scene` now renders when :code:`Scene.render()` is called rather than upon instantiation.
 #. :code:`ValueTracker` now supports increment using the `+=` operator (in addition to the already existing `increment_value` method)
 
 

docs/source/manim_directive.py

@@ -192,7 +192,7 @@ def run(self):
             "from manim import *",
             *file_writer_config_code,
             *user_code,
-            f"{clsname}()",
+            f"{clsname}().render()",
         ]
         exec("\n".join(code), globals())
 

manim/__init__.py

@@ -56,6 +56,7 @@
 from .scene.graph_scene import *
 from .scene.moving_camera_scene import *
 from .scene.reconfigurable_scene import *
+from .scene.js_scene import *
 from .scene.scene import *
 from .scene.sample_space_scene import *
 from .scene.three_d_scene import *

manim/__main__.py

@@ -9,12 +9,17 @@
 import types
 
 from . import constants, logger, console, file_writer_config
-from .config.config import args
+from .config.config import camera_config, args
 from .config import cfg_subcmds
+from .utils.module_ops import (
+    get_module,
+    get_scene_classes_from_module,
+    get_scenes_to_render,
+)
 from .scene.scene import Scene
 from .utils.sounds import play_error_sound, play_finish_sound
 from .utils.file_ops import open_file as open_media_file
-from . import constants
+from .grpc.impl import frame_server_impl
 
 
 def open_file_if_needed(file_writer):
@@ -50,104 +55,6 @@ def open_file_if_needed(file_writer):
         sys.stdout = curr_stdout
 
 
-def is_child_scene(obj, module):
-    return (
-        inspect.isclass(obj)
-        and issubclass(obj, Scene)
-        and obj != Scene
-        and obj.__module__.startswith(module.__name__)
-    )
-
-
-def prompt_user_for_choice(scene_classes):
-    num_to_class = {}
-    for count, scene_class in enumerate(scene_classes):
-        count += 1  # start with 1 instead of 0
-        name = scene_class.__name__
-        console.print(f"{count}: {name}", style="logging.level.info")
-        num_to_class[count] = scene_class
-    try:
-        user_input = console.input(
-            f"[log.message] {constants.CHOOSE_NUMBER_MESSAGE} [/log.message]"
-        )
-        return [
-            num_to_class[int(num_str)]
-            for num_str in re.split(r"\s*,\s*", user_input.strip())
-        ]
-    except KeyError:
-        logger.error(constants.INVALID_NUMBER_MESSAGE)
-        sys.exit(2)
-    except EOFError:
-        sys.exit(1)
-
-
-def get_scenes_to_render(scene_classes):
-    if not scene_classes:
-        logger.error(constants.NO_SCENE_MESSAGE)
-        return []
-    if file_writer_config["write_all"]:
-        return scene_classes
-    result = []
-    for scene_name in file_writer_config["scene_names"]:
-        found = False
-        for scene_class in scene_classes:
-            if scene_class.__name__ == scene_name:
-                result.append(scene_class)
-                found = True
-                break
-        if not found and (scene_name != ""):
-            logger.error(constants.SCENE_NOT_FOUND_MESSAGE.format(scene_name))
-    if result:
-        return result
-    return (
-        [scene_classes[0]]
-        if len(scene_classes) == 1
-        else prompt_user_for_choice(scene_classes)
-    )
-
-
-def get_scene_classes_from_module(module):
-    return [
-        member[1]
-        for member in inspect.getmembers(module, lambda x: is_child_scene(x, module))
-    ]
-
-
-def get_module(file_name):
-    if file_name == "-":
-        # Since this feature is used for rapid testing, using Scene Caching would be a
-        # hindrance in this case.
-        file_writer_config["disable_caching"] = True
-        module = types.ModuleType("input_scenes")
-        logger.info(
-            "Enter the animation's code & end with an EOF (CTRL+D on Linux/Unix, CTRL+Z on Windows):"
-        )
-        code = sys.stdin.read()
-        if not code.startswith("from manim import"):
-            logger.warning(
-                "Didn't find an import statement for Manim. Importing automatically..."
-            )
-            code = "from manim import *\n" + code
-        logger.info("Rendering animation from typed code...")
-        try:
-            exec(code, module.__dict__)
-            return module
-        except Exception as e:
-            logger.error(f"Failed to render scene: {str(e)}")
-            sys.exit(2)
-    else:
-        if os.path.exists(file_name):
-            if file_name[-3:] != ".py":
-                raise Exception(f"{file_name} is not a valid Manim python script.")
-            module_name = file_name[:-3].replace(os.sep, ".").split(".")[-1]
-            spec = importlib.util.spec_from_file_location(module_name, file_name)
-            module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(module)
-            return module
-        else:
-            raise FileNotFoundError(f"{file_name} not found")
-
-
 def main():
     if hasattr(args, "subcommands"):
         if "cfg" in args.subcommands:
@@ -169,15 +76,19 @@ def main():
         sound_on = file_writer_config["sound"]
         for SceneClass in scene_classes_to_render:
             try:
-                # By invoking, this renders the full scene
-                scene = SceneClass()
-                open_file_if_needed(scene.file_writer)
-                if sound_on:
-                    play_finish_sound()
+                if camera_config["use_js_renderer"]:
+                    frame_server_impl.get(SceneClass).start()
+                else:
+                    scene = SceneClass()
+                    scene.render()
+                    open_file_if_needed(scene.file_writer)
+                    if sound_on:
+                        play_finish_sound()
             except Exception:
                 print("\n\n")
                 traceback.print_exc()
                 print("\n\n")
+            if not camera_config["use_js_renderer"]:
                 if sound_on:
                     play_error_sound()
 

manim/camera/camera.py

@@ -104,12 +104,6 @@ def __init__(self, background=None, **kwargs):
         # corresponding class.  If a Mobject is not an instance of a class in
         # this dict (or an instance of a class that inherits from a class in
         # this dict), then it cannot be rendered.
-        self.display_funcs = {
-            VMobject: self.display_multiple_vectorized_mobjects,
-            PMobject: self.display_multiple_point_cloud_mobjects,
-            AbstractImageMobject: self.display_multiple_image_mobjects,
-            Mobject: lambda batch, pa: batch,  # Do nothing
-        }
 
         self.init_background()
         self.resize_frame_shape()
@@ -149,6 +143,12 @@ def type_or_raise(self, mobject):
         :exc:`TypeError`
             When mobject is not an instance of a class that can be rendered.
         """
+        self.display_funcs = {
+            VMobject: self.display_multiple_vectorized_mobjects,
+            PMobject: self.display_multiple_point_cloud_mobjects,
+            AbstractImageMobject: self.display_multiple_image_mobjects,
+            Mobject: lambda batch, pa: batch,  # Do nothing
+        }
         # We have to check each type in turn because we are dealing with
         # super classes.  For example, if square = Square(), then
         # type(square) != VMobject, but isinstance(square, VMobject) == True.
@@ -358,6 +358,9 @@ def reset(self):
         self.set_pixel_array(self.background)
         return self
 
+    def set_frame_to_background(self, background):
+        self.set_pixel_array(background)
+
     ####
 
     # TODO, it's weird that this is part of camera.

manim/camera/js_camera.py

@@ -0,0 +1,32 @@
+from .camera import Camera
+import copy
+
+
+class JsCamera(Camera):
+    def __init__(self, **kwargs):
+        super().__init__(self, **kwargs)
+        self.serialized_frame = []
+        self.pixel_array = None
+
+    def display_multiple_non_background_colored_vmobjects(self, vmobjects, _):
+        for vmobject in vmobjects:
+            # TODO: Store a proto instead of JSON.
+            needs_redraw = False
+            point_hash = hash(tuple(vmobject.points.flatten()))
+            if vmobject.point_hash != point_hash:
+                vmobject.point_hash = point_hash
+                needs_redraw = True
+            self.serialized_frame.append(
+                {
+                    "points": vmobject.points.tolist(),
+                    "style": vmobject.get_style(simple=True),
+                    "id": id(vmobject),
+                    "needs_redraw": needs_redraw,
+                }
+            )
+
+    def reset(self):
+        self.serialized_frame = []
+
+    def set_frame_to_background(self, background):
+        self.serialized_frame = copy.deepcopy(background)

manim/config/config.py

@@ -112,6 +112,14 @@ def _parse_config(config_parser, args):
         background_color = colour.Color(default["background_color"])
     config["background_color"] = background_color
 
+    config["use_js_renderer"] = args.use_js_renderer or default.getboolean(
+        "use_js_renderer"
+    )
+
+    config["js_renderer_path"] = args.js_renderer_path or default.get(
+        "js_renderer_path"
+    )
+
     # Set the rest of the frame properties
     config["frame_height"] = 8.0
     config["frame_width"] = (
@@ -151,6 +159,8 @@ def _parse_config(config_parser, args):
     if not (hasattr(args, "subcommands")):
         _init_dirs(file_writer_config)
 config = _parse_config(config_parser, args)
+if config["use_js_renderer"]:
+    file_writer_config["disable_caching"] = True
 camera_config = config
 
 # Set the different loggers

manim/config/config_utils.py

@@ -391,6 +391,18 @@ def _parse_cli(arg_list, input=True):
         "the rendering at the second value",
     )
 
+    parser.add_argument(
+        "--use_js_renderer",
+        help="Render animations using the javascript frontend",
+        action="store_const",
+        const=True,
+    )
+
+    parser.add_argument(
+        "--js_renderer_path",
+        help="Path to the javascript frontend",
+    )
+
     # Specify the manim.cfg file
     parser.add_argument(
         "--config_file",

manim/config/default.cfg

@@ -78,6 +78,21 @@ media_dir = ./media
 # --log_dir (by default "/logs", that will be put inside the media dir)
 log_dir = logs
 
+# # --video_dir
+# video_dir = %(MEDIA_DIR)s/videos
+
+# # --tex_dir
+# tex_dir = %(MEDIA_DIR)s/Tex
+
+# # --text_dir
+# text_dir = %(MEDIA_DIR)s/texts
+
+# --use_js_renderer
+use_js_renderer = False
+
+# --js_renderer_path
+js_renderer_path =
+
 # 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/constants.py

@@ -120,3 +120,9 @@ class MyText(Text):
     "CRITICAL": "fatal",
 }
 VERBOSITY_CHOICES = FFMPEG_VERBOSITY_MAP.keys()
+JS_RENDERER_INFO = (
+    "The Electron frontend to Manim is hosted at "
+    "https://github.com/ManimCommunity/manim-renderer. After cloning and building it, "
+    "you can either start it prior to running Manim or specify the path to the "
+    "executable with the --js_renderer_path flag."
+)