`MObjects` dependent on `OpenGLSurface` behave differently in Cairo and OpenGL

[alembcke]

Description of bug / unexpected behavior

When doing 3D animations with Dot3D or other 3D mobjects based on OpenGLSurface there are issues as Surface is a VMObject (vectorized) and OpenGLSurface is an OpenGLMObject (not vectorized). This can cause errors or unexpected behavior when running the same code in OpenGL (see code and log below).

Expected behavior

Dot3D and other mobjects based on Surface and OpenGLSurface should behave the same in both Cairo and OpenGL.

How to reproduce the issue

Code for reproducing the problem

from manim import *
from manim.opengl import *


class Test(ThreeDScene):
    def construct(self):
        vect = Vector().to_edge(LEFT)
        self.add(vect)
        self.wait()
        dot = Dot3D().to_edge(RIGHT)
        self.add(dot)
        self.wait()
        self.play(Transform(vect, dot))
        self.wait()

Additional media files

Example of what Cairo outputs:

Images/GIFs

Test.mp4

Logs

Terminal output

Manim Community v0.11.0

╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮    
│                                                                                                  │
│ /home/alexlembcke/.local/lib/python3.9/site-packages/manim/cli/render/commands.py:108 in render  │
│                                                                                                  │
│   105 │   │   │   while keep_running:                                                            │
│   106 │   │   │   │   for SceneClass in scene_classes_from_file(file):                           │
│   107 │   │   │   │   │   scene = SceneClass(renderer)                                           │
│ ❱ 108 │   │   │   │   │   rerun = scene.render()                                                 │
│   109 │   │   │   │   │   if rerun or config["write_all"]:                                       │
│   110 │   │   │   │   │   │   renderer.num_plays = 0                                             │
│   111 │   │   │   │   │   │   continue                                                           │
│ /home/alexlembcke/.local/lib/python3.9/site-packages/manim/scene/scene.py:213 in render          │
│                                                                                                  │
│    210 │   │   """                                                                               │
│    211 │   │   self.setup()                                                                      │
│    212 │   │   try:                                                                              │
│ ❱  213 │   │   │   self.construct()                                                              │
│    214 │   │   except EndSceneEarlyException:                                                    │
│    215 │   │   │   pass                                                                          │
│    216 │   │   except RerunSceneException as e:                                                  │
│                                                                                                  │
│ /home/alexlembcke/ManimDev/vector_translation.py:13 in construct                                 │
│                                                                                                  │
│   10 │   │   dot = Dot3D().to_edge(RIGHT)                                                        │
│   11 │   │   self.add(dot)                                                                       │
│   12 │   │   self.wait()                                                                         │
│ ❱ 13 │   │   self.play(Transform(vect, dot))                                                     │
│   14 │   │   self.wait()                                                                         │
│   15                                                                                             │
│                                                                                                  │
│ /home/alexlembcke/.local/lib/python3.9/site-packages/manim/scene/scene.py:888 in play            │
│                                                                                                  │
│    885 │   │   │   return np.max([animation.run_time for animation in animations])               │
│    886 │                                                                                         │
│    887 │   def play(self, *args, **kwargs):                                                      │
│ ❱  888 │   │   self.renderer.play(self, *args, **kwargs)                                         │
│    889 │                                                                                         │
│    890 │   def wait(self, duration=DEFAULT_WAIT_TIME, stop_condition=None):                      │
│    891 │   │   self.play(Wait(run_time=duration, stop_condition=stop_condition))                 │
│                                                                                                  │
│ /home/alexlembcke/.local/lib/python3.9/site-packages/manim/utils/caching.py:61 in wrapper        │
│                                                                                                  │
│   58 │   │   │   "List of the first few animation hashes of the scene: %(h)s",                   │
│   59 │   │   │   {"h": str(self.animations_hashes[:5])},                                         │
│   60 │   │   )                                                                                   │
│ ❱ 61 │   │   func(self, scene, *args, **kwargs)                                                  │
│   62 │                                                                                           │
│   63 │   return wrapper                                                                          │
│   64                                                                                             │
│                                                                                                  │
│ /home/alexlembcke/.local/lib/python3.9/site-packages/manim/renderer/cairo_renderer.py:46 in      │
│ wrapper                                                                                          │
│                                                                                                  │
│    43 │   def wrapper(self, scene, *args, **kwargs):                                             │
│    44 │   │   self.animation_start_time = time.time()                                            │
│    45 │   │   self.file_writer.begin_animation(not self.skip_animations)                         │
│ ❱  46 │   │   func(self, scene, *args, **kwargs)                                                 │
│    47 │   │   self.file_writer.end_animation(not self.skip_animations)                           │
│    48 │   │   self.num_plays += 1                                                                │
│    49                                                                                            │
│                                                                                                  │
│ /home/alexlembcke/.local/lib/python3.9/site-packages/manim/renderer/opengl_renderer.py:406 in    │
│ play                                                                                             │
│                                                                                                  │
│   403 │   def play(self, scene, *args, **kwargs):                                                │
│   404 │   │   # TODO: Handle data locking / unlocking.                                           │
│   405 │   │   if scene.compile_animation_data(*args, **kwargs):                                  │
│ ❱ 406 │   │   │   scene.begin_animations()                                                       │
│   407 │   │   │   scene.play_internal()                                                          │
│   408 │                                                                                          │
│   409 │   def clear_screen(self):                                                                │
│                                                                                                  │
│ /home/alexlembcke/.local/lib/python3.9/site-packages/manim/scene/scene.py:961 in                 │
│ begin_animations                                                                                 │
│                                                                                                  │
│    958 │   def begin_animations(self) -> None:                                                   │
│    959 │   │   """Start the animations of the scene."""                                          │
│    960 │   │   for animation in self.animations:                                                 │
│ ❱  961 │   │   │   animation.begin()                                                             │
│    962 │                                                                                         │
│    963 │   def is_current_animation_frozen_frame(self) -> bool:                                  │
│    964 │   │   """Returns whether the current animation produces a static frame (generally a Wa  │
│                                                                                                  │
│ /home/alexlembcke/.local/lib/python3.9/site-packages/manim/animation/transform.py:111 in begin   │
│                                                                                                  │
│   108 │   │   # Note, this potentially changes the structure                                     │
│   109 │   │   # of both mobject and target_mobject                                               │
│   110 │   │   if config["renderer"] == "opengl":                                                 │
│ ❱ 111 │   │   │   self.mobject.align_data_and_family(self.target_copy)                           │
│   112 │   │   else:                                                                              │
│   113 │   │   │   self.mobject.align_data(self.target_copy)                                      │
│   114 │   │   super().begin()                                                                    │
│                                                                                                  │
│ /home/alexlembcke/.local/lib/python3.9/site-packages/manim/mobject/opengl_mobject.py:1611 in     │
│ align_data_and_family                                                                            │
│                                                                                                  │
│   1608 │                                                                                         │
│   1609 │   def align_data_and_family(self, mobject):                                             │
│   1610 │   │   self.align_family(mobject)                                                        │
│ ❱ 1611 │   │   self.align_data(mobject)                                                          │
│   1612 │                                                                                         │
│   1613 │   def align_data(self, mobject):                                                        │
│   1614 │   │   # In case any data arrays get resized when aligned to shader data                 │
│                                                                                                  │
│ /home/alexlembcke/.local/lib/python3.9/site-packages/manim/mobject/opengl_mobject.py:1619 in     │
│ align_data                                                                                       │
│                                                                                                  │
│   1616 │   │   for mob1, mob2 in zip(self.get_family(), mobject.get_family()):                   │
│   1617 │   │   │   # Separate out how points are treated so that subclasses                      │
│   1618 │   │   │   # can handle that case differently if they choose                             │
│ ❱ 1619 │   │   │   mob1.align_points(mob2)                                                       │
│   1620 │   │   │   for key in mob1.data.keys() & mob2.data.keys():                               │
│   1621 │   │   │   │   if key == "points":                                                       │
│   1622 │   │   │   │   │   continue                                                              │
│                                                                                                  │
│ /home/alexlembcke/.local/lib/python3.9/site-packages/manim/mobject/types/opengl_vectorized_mobje │
│ ct.py:856 in align_points                                                                        │
│                                                                                                  │
│    853 │   │   │   │   mob.start_new_path(mob.get_center())                                      │
│    854 │   │   │   # If there's only one point, turn it into                                     │
│    855 │   │   │   # a null curve                                                                │
│ ❱  856 │   │   │   if mob.has_new_path_started():                                                │
│    857 │   │   │   │   mob.add_line_to(mob.points[0])                                            │
│    858 │   │                                                                                     │
│    859 │   │   # Figure out what the subpaths are, and align                                     │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
AttributeError: 'Dot3D' object has no attribute 'has_new_path_started'

System specifications

System Details

• OS: Ubuntu 21.04
• RAM: 32GB
• Python version (python/py/python3 --version): 3.9.5
• Installed modules (provide output from pip list):

Package                 Version
----------------------- ---------------------
manim                   0.10.0
moderngl                5.6.4
moderngl-window         2.4.0

LaTeX details

• LaTeX distribution (e.g. TeX Live 2020):
• Installed LaTeX packages:

FFMPEG

Output of ffmpeg -version:

ffmpeg version 4.3.2-0+deb11u1ubuntu1 Copyright (c) 2000-2021 the FFmpeg developers
built with gcc 10 (Ubuntu 10.2.1-20ubuntu1)
configuration: --prefix=/usr --extra-version=0+deb11u1ubuntu1 --toolchain=hardened --libdir=/usr/lib/x86_64-linux-gnu --incdir=/usr/include/x86_64-linux-gnu --arch=amd64 --enable-gpl --disable-stripping --enable-avresample --disable-filter=resample --enable-gnutls --enable-ladspa --enable-libaom --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --enable-libcdio --enable-libcodec2 --enable-libdav1d --enable-libflite --enable-libfontconfig --enable-libfreetype --enable-libfribidi --enable-libgme --enable-libgsm --enable-libjack --enable-libmp3lame --enable-libmysofa --enable-libopenjpeg --enable-libopenmpt --enable-libopus --enable-libpulse --enable-librabbitmq --enable-librsvg --enable-librubberband --enable-libshine --enable-libsnappy --enable-libsoxr --enable-libspeex --enable-libsrt --enable-libssh --enable-libtheora --enable-libtwolame --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwavpack --enable-libwebp --enable-libx265 --enable-libxml2 --enable-libxvid --enable-libzmq --enable-libzvbi --enable-lv2 --enable-omx --enable-openal --enable-opencl --enable-opengl --enable-sdl2 --enable-pocketsphinx --enable-libmfx --enable-libdc1394 --enable-libdrm --enable-libiec61883 --enable-nvenc --enable-chromaprint --enable-frei0r --enable-libx264 --enable-shared
libavutil      56. 51.100 / 56. 51.100
libavcodec     58. 91.100 / 58. 91.100
libavformat    58. 45.100 / 58. 45.100
libavdevice    58. 10.100 / 58. 10.100
libavfilter     7. 85.100 /  7. 85.100
libavresample   4.  0.  0 /  4.  0.  0
libswscale      5.  7.100 /  5.  7.100
libswresample   3.  7.100 /  3.  7.100
libpostproc    55.  7.100 / 55.  7.100

Additional comments

[NaoPross]

Hi, I have a similar issue with the code below. Are there any updates on this? I find working with the OpenGL renderer much more pleasant, and would really appreciate if this gets fixed. Could someone with a bit of knowledge give an estimate of how hard it would be to fix this problem?

Code

from manim import *

import numpy as np
from scipy.special import sph_harm


class FourierOnS1(ThreeDScene):
    @staticmethod
    def harmonic_cos(m, n, theta, phi):
        # get only the cos() part
        r = np.real(sph_harm(m, n, theta, phi)) * 5 # Y_n^m 

        # coordinates transformation
        x = r * np.cos(theta) * np.sin(phi)
        y = r * np.sin(phi) * np.sin(theta)
        z = r * np.cos(phi)

        return [x, y, z]

    @staticmethod
    def harmonic_surf(m, n):
        surf = Surface(lambda u, v: FourierOnS1.harmonic_cos(m, n, u, v),
                       u_range=[0, 2 * PI], v_range=[-PI, PI], resolution=[50, 50],
                       fill_opacity=.8, checkerboard_colors=[BLUE_D, BLUE_E])

        return surf

    def construct(self):
        axes = ThreeDAxes(x_range=[-1, 1], y_range=[-1, 1])
        self.add(axes)

        self.set_camera_orientation(theta=30 * DEGREES, phi=75 * DEGREES)
        self.begin_ambient_camera_rotation(rate=.1)

        last_surf = None
        last_label = None
        for n in range(0, 5):
            for m in range(0, n):
                surf = FourierOnS1.harmonic_surf(m, n)
                label = MathTex(r"Y_{%d}^{%d}(\theta, \phi)" % (n, m))

                if last_surf is not None:
                    self.play(ReplacementTransform(last_surf, surf))

                if last_label is not None:
                    self.remove(last_label)

                self.play(Create(surf))
                self.add_fixed_in_frame_mobjects(label)
                label.to_corner(UL)

                last_surf = surf 
                last_label = label
                self.wait()

        self.wait(5)

Stacktrace

$ manim --renderer=opengl -p -ql harmonics.py                                      1
Manim Community v0.15.1

2022-04-08 13:36:10.286 Python[12312:406165] ApplePersistenceIgnoreState: Existing state will not be touched. New state will be written to /var/folders/w1/cmd2jfv1229gcxvtdyfg1vjc0000gn/T/org.python.python.savedState
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮                
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/cli/render/commands.py:110 in render             │
│                                                                                                  │
│   107 │   │   │   while keep_running:                                                            │
│   108 │   │   │   │   for SceneClass in scene_classes_from_file(file):                           │
│   109 │   │   │   │   │   scene = SceneClass(renderer)                                           │
│ ❱ 110 │   │   │   │   │   rerun = scene.render()                                                 │
│   111 │   │   │   │   │   if rerun or config["write_all"]:                                       │
│   112 │   │   │   │   │   │   renderer.num_plays = 0                                             │
│   113 │   │   │   │   │   │   continue                                                           │
│ /opt/homebrew/lib/python3.9/site-packages/manim/scene/scene.py:222 in render                     │
│                                                                                                  │
│    219 │   │   """                                                                               │
│    220 │   │   self.setup()                                                                      │
│    221 │   │   try:                                                                              │
│ ❱  222 │   │   │   self.construct()                                                              │
│    223 │   │   except EndSceneEarlyException:                                                    │
│    224 │   │   │   pass                                                                          │
│    225 │   │   except RerunSceneException as e:                                                  │
│                                                                                                  │
│ /Users/npross/Documents/School/HSR/module/MathSem1/SeminarSpezielleFunktionen/vorlesungen/kugel/ │
│ harmonics.py:58 in construct                                                                     │
│                                                                                                  │
│   55 │   │   │   │   if last_label is not None:                                                  │
│   56 │   │   │   │   │   self.remove(last_label)                                                 │
│   57 │   │   │   │                                                                               │
│ ❱ 58 │   │   │   │   self.play(Create(surf))                                                     │
│   59 │   │   │   │   self.add_fixed_in_frame_mobjects(label)                                     │
│   60 │   │   │   │   label.to_corner(UL)                                                         │
│   61                                                                                             │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/scene/scene.py:957 in play                       │
│                                                                                                  │
│    954 │   │                                                                                     │
│    955 │   │   """                                                                               │
│    956 │   │   start_time = self.renderer.time                                                   │
│ ❱  957 │   │   self.renderer.play(self, *args, **kwargs)                                         │
│    958 │   │   run_time = self.renderer.time - start_time                                        │
│    959 │   │   if subcaption:                                                                    │
│    960 │   │   │   if subcaption_duration is None:                                               │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/utils/caching.py:63 in wrapper                   │
│                                                                                                  │
│   60 │   │   │   "List of the first few animation hashes of the scene: %(h)s",                   │
│   61 │   │   │   {"h": str(self.animations_hashes[:5])},                                         │
│   62 │   │   )                                                                                   │
│ ❱ 63 │   │   func(self, scene, *args, **kwargs)                                                  │
│   64 │                                                                                           │
│   65 │   return wrapper                                                                          │
│   66                                                                                             │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/renderer/opengl_renderer.py:441 in play          │
│                                                                                                  │
│   438 │   │   │   self.animation_elapsed_time = scene.duration                                   │
│   439 │   │                                                                                      │
│   440 │   │   else:                                                                              │
│ ❱ 441 │   │   │   scene.play_internal()                                                          │
│   442 │   │                                                                                      │
│   443 │   │   self.file_writer.end_animation(not self.skip_animations)                           │
│   444 │   │   self.time += scene.duration                                                        │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/scene/scene.py:1122 in play_internal             │
│                                                                                                  │
│   1119 │   │   │   self.duration,                                                                │
│   1120 │   │   )                                                                                 │
│   1121 │   │   for t in self.time_progression:                                                   │
│ ❱ 1122 │   │   │   self.update_to_time(t)                                                        │
│   1123 │   │   │   if not skip_rendering and not self.skip_animation_preview:                    │
│   1124 │   │   │   │   self.renderer.render(self, t, self.moving_mobjects)                       │
│   1125 │   │   │   if self.stop_condition is not None and self.stop_condition():                 │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/scene/scene.py:1355 in update_to_time            │
│                                                                                                  │
│   1352 │   │   for animation in self.animations:                                                 │
│   1353 │   │   │   animation.update_mobjects(dt)                                                 │
│   1354 │   │   │   alpha = t / animation.run_time                                                │
│ ❱ 1355 │   │   │   animation.interpolate(alpha)                                                  │
│   1356 │   │   self.update_mobjects(dt)                                                          │
│   1357 │   │   self.update_meshes(dt)                                                            │
│   1358 │   │   self.update_self(dt)                                                              │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/animation/animation.py:313 in interpolate        │
│                                                                                                  │
│   310 │   │   │   The relative time to set the animation to, 0 meaning the start, 1 meaning      │
│   311 │   │   │   the end.                                                                       │
│   312 │   │   """                                                                                │
│ ❱ 313 │   │   self.interpolate_mobject(alpha)                                                    │
│   314 │                                                                                          │
│   315 │   def interpolate_mobject(self, alpha: float) -> None:                                   │
│   316 │   │   """Interpolates the mobject of the :class:`Animation` based on alpha value.        │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/animation/animation.py:328 in                    │
│ interpolate_mobject                                                                              │
│                                                                                                  │
│   325 │   │   families = list(self.get_all_families_zipped())                                    │
│   326 │   │   for i, mobs in enumerate(families):                                                │
│   327 │   │   │   sub_alpha = self.get_sub_alpha(alpha, i, len(families))                        │
│ ❱ 328 │   │   │   self.interpolate_submobject(*mobs, sub_alpha)                                  │
│   329 │                                                                                          │
│   330 │   def interpolate_submobject(                                                            │
│   331 │   │   self,                                                                              │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/animation/creation.py:124 in                     │
│ interpolate_submobject                                                                           │
│                                                                                                  │
│   121 │   │   starting_submobject: Mobject,                                                      │
│   122 │   │   alpha: float,                                                                      │
│   123 │   ) -> None:                                                                             │
│ ❱ 124 │   │   submobject.pointwise_become_partial(                                               │
│   125 │   │   │   starting_submobject, *self._get_bounds(alpha)                                  │
│   126 │   │   )                                                                                  │
│   127                                                                                            │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/mobject/opengl/opengl_vectorized_mobject.py:1306 │
│ in pointwise_become_partial                                                                      │
│                                                                                                  │
│   1303 │   │   """                                                                               │
│   1304 │   │   assert isinstance(vmobject, OpenGLVMobject)                                       │
│   1305 │   │   if a <= 0 and b >= 1:                                                             │
│ ❱ 1306 │   │   │   self.become(vmobject)                                                         │
│   1307 │   │   │   return self                                                                   │
│   1308 │   │   num_curves = vmobject.get_num_curves()                                            │
│   1309 │   │   nppc = self.n_points_per_curve                                                    │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/mobject/opengl/opengl_mobject.py:2443 in become  │
│                                                                                                  │
│   2440 │   │                                                                                     │
│   2441 │   │   self.align_family(mobject)                                                        │
│   2442 │   │   for sm1, sm2 in zip(self.get_family(), mobject.get_family()):                     │
│ ❱ 2443 │   │   │   sm1.set_data(sm2.data)                                                        │
│   2444 │   │   │   sm1.set_uniforms(sm2.uniforms)                                                │
│   2445 │   │   self.refresh_bounding_box(recurse_down=True)                                      │
│   2446 │   │   return self                                                                       │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/mobject/opengl/opengl_vectorized_mobject.py:1451 │
│ in wrapper                                                                                       │
│                                                                                                  │
│   1448 │   │   │   old_points = np.empty((0, 3))                                                 │
│   1449 │   │   │   for mob in self.family_members_with_points():                                 │
│   1450 │   │   │   │   old_points = np.concatenate((old_points, mob.points), axis=0)             │
│ ❱ 1451 │   │   │   func(self, *args, **kwargs)                                                   │
│   1452 │   │   │   new_points = np.empty((0, 3))                                                 │
│   1453 │   │   │   for mob in self.family_members_with_points():                                 │
│   1454 │   │   │   │   new_points = np.concatenate((new_points, mob.points), axis=0)             │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/mobject/opengl/opengl_vectorized_mobject.py:1469 │
│ in set_data                                                                                      │
│                                                                                                  │
│   1466 │                                                                                         │
│   1467 │   @triggers_refreshed_triangulation                                                     │
│   1468 │   def set_data(self, data):                                                             │
│ ❱ 1469 │   │   super().set_data(data)                                                            │
│   1470 │   │   return self                                                                       │
│   1471 │                                                                                         │
│   1472 │   # TODO, how to be smart about tangents here?                                          │
│                                                                                                  │
│ /opt/homebrew/lib/python3.9/site-packages/manim/mobject/opengl/opengl_mobject.py:274 in set_data │
│                                                                                                  │
│    271 │                                                                                         │
│    272 │   def set_data(self, data):                                                             │
│    273 │   │   for key in data:                                                                  │
│ ❱  274 │   │   │   self.data[key] = data[key].copy()                                             │
│    275 │   │   return self                                                                       │
│    276 │                                                                                         │
│    277 │   def set_uniforms(self, uniforms):                                                     │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
AttributeError: 'float' object has no attribute 'copy'

[alembcke]

@NaoPross there are two draft PRs being worked on that I think would fix this issue. The first one is #2450 which gets rid of MObject and VMObject in favor of one base class - this one PR may be enough to fix this issue. But if not, there is #2454 which merges the OpenGL and Cairo implementations, which includes Surface and OpenGLSurface.

As for how hard it would be to fix this issue, the answer is very hard. It basically requires a refactoring of how surfaces are rendered, as far as I can tell.

[behackl]

How is the situation in manimgl? Do vector-based animations like Create and Transform work for Surface etc. there? If so, it is likely that we could port something over with more or less realistic effort.

[NaoPross]

@behackl I quickly tried a few today and they all seem to work in manimgl.

[alembcke]

@NaoPross and @behackl when I try I get the same error:

ManimGL v1.6.1
[19:22:05] INFO     Using the default configuration file, which you can modify in `/home/alexlembcke/.pyenv/versions/3.7.12/lib/python3.7/site-packages/manimlib/default_config.yml`                  config.py:265
           INFO     If you want to create a local configuration file, you can create a file named `custom_config.yml`, or run `manimgl --config`                                                      config.py:267
Traceback (most recent call last):                                                                      
  File "/home/alexlembcke/.pyenv/versions/3.7.12/bin/manimgl", line 8, in <module>
    sys.exit(main())
  File "/home/alexlembcke/.pyenv/versions/3.7.12/lib/python3.7/site-packages/manimlib/__main__.py", line 25, in main
    scene.run()
  File "/home/alexlembcke/.pyenv/versions/3.7.12/lib/python3.7/site-packages/manimlib/scene/scene.py", line 91, in run
    self.construct()
  File "manim_test.py", line 12, in construct
    self.play(Transform(vect, disk))
  File "/home/alexlembcke/.pyenv/versions/3.7.12/lib/python3.7/site-packages/manimlib/scene/scene.py", line 446, in wrapper
    func(self, *args, **kwargs)
  File "/home/alexlembcke/.pyenv/versions/3.7.12/lib/python3.7/site-packages/manimlib/scene/scene.py", line 511, in play
    self.begin_animations(animations)
  File "/home/alexlembcke/.pyenv/versions/3.7.12/lib/python3.7/site-packages/manimlib/scene/scene.py", line 474, in begin_animations
    animation.begin()
  File "/home/alexlembcke/.pyenv/versions/3.7.12/lib/python3.7/site-packages/manimlib/animation/transform.py", line 66, in begin
    self.mobject.align_data_and_family(self.target_copy)
  File "/home/alexlembcke/.pyenv/versions/3.7.12/lib/python3.7/site-packages/manimlib/mobject/mobject.py", line 1367, in align_data_and_family
    self.align_data(mobject)
  File "/home/alexlembcke/.pyenv/versions/3.7.12/lib/python3.7/site-packages/manimlib/mobject/mobject.py", line 1375, in align_data
    mob1.align_points(mob2)
  File "/home/alexlembcke/.pyenv/versions/3.7.12/lib/python3.7/site-packages/manimlib/mobject/types/vectorized_mobject.py", line 761, in align_points
    if mob.has_new_path_started():
AttributeError: 'Disk3D' object has no attribute 'has_new_path_started'

Since manimgl doesn't have Dot3D I had to change that to Disk3D, but both are sub-classes of Surface. So it appears as though this bug is in manimgl as well.