Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Animating DecimalNumber with OpenGL crashes due to array dimensions #4097

Open
idg10 opened this issue Jan 10, 2025 · 0 comments
Open

Animating DecimalNumber with OpenGL crashes due to array dimensions #4097

idg10 opened this issue Jan 10, 2025 · 0 comments

Comments

@idg10
Copy link

idg10 commented Jan 10, 2025 •
edited
Loading

Description of bug / unexpected behavior

When animating the value of a DecimalNumber with --renderer=opengl, the stroke_width becomes an ever more deeply nested array, eventually leading to a failure in OpenGLVMobject's set_stroke method:

ValueError: setting an array element with a sequence. The requested array would exceed the maximum number of dimension of 32.

At the point of the crash, the DecimalNumber instance has this value as self.stroke_width:

array([[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[0]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]])

This only occurs with the OpenGL renderer.

Expected behavior

Examples such as the Counting Scene in the 'building blocks' documentation page should not crash when used with the OpenGL renderer. Code that animates the value of a DecimalNumber, and which works perfectly with Cairo should also work with OpenGL.

How to reproduce the issue

Copy the code in (https://docs.manim.community/en/stable/tutorials/building_blocks.html#countingscene) into a file. Run it with this command line:

manim render count.py -p --renderer=opengl

It gets as far as 11.25 and then crashes with the error described earlier:

ValueError: setting an array element with a sequence. The requested array would exceed the maximum number of dimension of 32

(Note that if you omit the --renderer option, enabling the default Cairo renderer to be used, the problem does not occur.)

Code for reproducing the problem

This is from (https://docs.manim.community/en/stable/tutorials/building_blocks.html#countingscene). Just in case that example changes, here's what was in it when I hit this problem:

from manim import *

class Count(Animation):
    def __init__(self, number: DecimalNumber, start: float, end: float, **kwargs) -> None:
        # Pass number as the mobject of the animation
        super().__init__(number,  **kwargs)
        # Set start and end
        self.start = start
        self.end = end

    def interpolate_mobject(self, alpha: float) -> None:
        # Set value of DecimalNumber according to alpha
        value = self.start + (alpha * (self.end - self.start))
        self.mobject.set_value(value)


class CountingScene(Scene):
    def construct(self):
        # Create Decimal Number and add it to scene
        number = DecimalNumber().set_color(WHITE).scale(5)
        # Add an updater to keep the DecimalNumber centered as its value changes
        number.add_updater(lambda number: number.move_to(ORIGIN))

        self.add(number)

        self.wait()

        # Play the Count Animation to count from 0 to 100 in 4 seconds
        self.play(Count(number, 0, 100), run_time=4, rate_func=linear)

        self.wait()

Logs

Terminal output 
Manim Community v0.18.1

╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮                                                                                                                                    
│ /usr/local/lib/python3.11/site-packages/manim/cli/render/commands.py:102 in render               │
│                                                                                                  │
│    99 │   │   │   │   for SceneClass in scene_classes_from_file(file):                           │
│   100 │   │   │   │   │   with tempconfig({}):                                                   │
│   101 │   │   │   │   │   │   scene = SceneClass(renderer)                                       │
│ ❱ 102 │   │   │   │   │   │   rerun = scene.render()                                             │
│   103 │   │   │   │   │   if rerun or config["write_all"]:                                       │
│   104 │   │   │   │   │   │   renderer.num_plays = 0                                             │
│   105 │   │   │   │   │   │   continue                                                           │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/scene/scene.py:229 in render                       │
│                                                                                                  │
│    226 │   │   """                                                                               │
│    227 │   │   self.setup()                                                                      │
│    228 │   │   try:                                                                              │
│ ❱  229 │   │   │   self.construct()                                                              │
│    230 │   │   except EndSceneEarlyException:                                                    │
│    231 │   │   │   pass                                                                          │
│    232 │   │   except RerunSceneException as e:                                                  │
│                                                                                                  │
│ /workspaces/idg10-manim-playground/basic_experiment/count.py:29 in construct                     │
│                                                                                                  │
│   26 │   │   self.wait()                                                                         │
│   27 │   │                                                                                       │
│   28 │   │   # Play the Count Animation to count from 0 to 100 in 4 seconds                      │
│ ❱ 29 │   │   self.play(Count(number, 0, 100), run_time=4, rate_func=linear)                      │
│   30 │   │                                                                                       │
│   31 │   │   self.wait()                                                                         │
│   32                                                                                             │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/scene/scene.py:1092 in play                        │
│                                                                                                  │
│   1089 │   │   │   return                                                                        │
│   1090 │   │                                                                                     │
│   1091 │   │   start_time = self.renderer.time                                                   │
│ ❱ 1092 │   │   self.renderer.play(self, *args, **kwargs)                                         │
│   1093 │   │   run_time = self.renderer.time - start_time                                        │
│   1094 │   │   if subcaption:                                                                    │
│   1095 │   │   │   if subcaption_duration is None:                                               │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/utils/caching.py:67 in wrapper                     │
│                                                                                                  │
│   64 │   │   │   "List of the first few animation hashes of the scene: %(h)s",                   │
│   65 │   │   │   {"h": str(self.animations_hashes[:5])},                                         │
│   66 │   │   )                                                                                   │
│ ❱ 67 │   │   func(self, scene, *args, **kwargs)                                                  │
│   68 │                                                                                           │
│   69 │   return wrapper                                                                          │
│   70                                                                                             │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/renderer/opengl_renderer.py:438 in play            │
│                                                                                                  │
│   435 │   │   │   self.animation_elapsed_time = scene.duration                                   │
│   436 │   │                                                                                      │
│   437 │   │   else:                                                                              │
│ ❱ 438 │   │   │   scene.play_internal()                                                          │
│   439 │   │                                                                                      │
│   440 │   │   self.file_writer.end_animation(not self.skip_animations)                           │
│   441 │   │   self.time += scene.duration                                                        │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/scene/scene.py:1259 in play_internal               │
│                                                                                                  │
│   1256 │   │   │   self.duration,                                                                │
│   1257 │   │   )                                                                                 │
│   1258 │   │   for t in self.time_progression:                                                   │
│ ❱ 1259 │   │   │   self.update_to_time(t)                                                        │
│   1260 │   │   │   if not skip_rendering and not self.skip_animation_preview:                    │
│   1261 │   │   │   │   self.renderer.render(self, t, self.moving_mobjects)                       │
│   1262 │   │   │   if self.stop_condition is not None and self.stop_condition():                 │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/scene/scene.py:1500 in update_to_time              │
│                                                                                                  │
│   1497 │   │   for animation in self.animations:                                                 │
│   1498 │   │   │   animation.update_mobjects(dt)                                                 │
│   1499 │   │   │   alpha = t / animation.run_time                                                │
│ ❱ 1500 │   │   │   animation.interpolate(alpha)                                                  │
│   1501 │   │   self.update_mobjects(dt)                                                          │
│   1502 │   │   self.update_meshes(dt)                                                            │
│   1503 │   │   self.update_self(dt)                                                              │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/animation/animation.py:329 in interpolate          │
│                                                                                                  │
│   326 │   │   │   The relative time to set the animation to, 0 meaning the start, 1 meaning      │
│   327 │   │   │   the end.                                                                       │
│   328 │   │   """                                                                                │
│ ❱ 329 │   │   self.interpolate_mobject(alpha)                                                    │
│   330 │                                                                                          │
│   331 │   def interpolate_mobject(self, alpha: float) -> None:                                   │
│   332 │   │   """Interpolates the mobject of the :class:`Animation` based on alpha value.        │
│                                                                                                  │
│ /workspaces/idg10-manim-playground/basic_experiment/count.py:14 in interpolate_mobject           │
│                                                                                                  │
│   11 │   def interpolate_mobject(self, alpha: float) -> None:                                    │
│   12 │   │   # Set value of DecimalNumber according to alpha                                     │
│   13 │   │   value = self.start + (alpha * (self.end - self.start))                              │
│ ❱ 14 │   │   self.mobject.set_value(value)                                                       │
│   15                                                                                             │
│   16                                                                                             │
│   17 class CountingScene(Scene):                                                                 │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/mobject/text/numbers.py:306 in set_value           │
│                                                                                                  │
│   303 │   │   │   │   # not needed with opengl renderer                                          │
│   304 │   │   │   │   mob.points[:] = 0                                                          │
│   305 │   │                                                                                      │
│ ❱ 306 │   │   self.init_colors()                                                                 │
│   307 │   │   return self                                                                        │
│   308 │                                                                                          │
│   309 │   def get_value(self):                                                                   │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/mobject/opengl/opengl_vectorized_mobject.py:184 in │
│ init_colors                                                                                      │
│                                                                                                  │
│    181 │   │   │   color=self.fill_color or self.color,                                          │
│    182 │   │   │   opacity=self.fill_opacity,                                                    │
│    183 │   │   )                                                                                 │
│ ❱  184 │   │   self.set_stroke(                                                                  │
│    185 │   │   │   color=self.stroke_color or self.color,                                        │
│    186 │   │   │   width=self.stroke_width,                                                      │
│    187 │   │   │   opacity=self.stroke_opacity,                                                  │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/mobject/opengl/opengl_vectorized_mobject.py:256 in │
│ set_stroke                                                                                       │
│                                                                                                  │
│    253 │   │   │   self.stroke_opacity = opacity                                                 │
│    254 │   │   if recurse:                                                                       │
│    255 │   │   │   for submobject in self.submobjects:                                           │
│ ❱  256 │   │   │   │   submobject.set_stroke(                                                    │
│    257 │   │   │   │   │   color=color,                                                          │
│    258 │   │   │   │   │   width=width,                                                          │
│    259 │   │   │   │   │   opacity=opacity,                                                      │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/mobject/opengl/opengl_vectorized_mobject.py:256 in │
│ set_stroke                                                                                       │
│                                                                                                  │
│    253 │   │   │   self.stroke_opacity = opacity                                                 │
│    254 │   │   if recurse:                                                                       │
│    255 │   │   │   for submobject in self.submobjects:                                           │
│ ❱  256 │   │   │   │   submobject.set_stroke(                                                    │
│    257 │   │   │   │   │   color=color,                                                          │
│    258 │   │   │   │   │   width=width,                                                          │
│    259 │   │   │   │   │   opacity=opacity,                                                      │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/mobject/opengl/opengl_vectorized_mobject.py:256 in │
│ set_stroke                                                                                       │
│                                                                                                  │
│    253 │   │   │   self.stroke_opacity = opacity                                                 │
│    254 │   │   if recurse:                                                                       │
│    255 │   │   │   for submobject in self.submobjects:                                           │
│ ❱  256 │   │   │   │   submobject.set_stroke(                                                    │
│    257 │   │   │   │   │   color=color,                                                          │
│    258 │   │   │   │   │   width=width,                                                          │
│    259 │   │   │   │   │   opacity=opacity,                                                      │
│                                                                                                  │
│ /usr/local/lib/python3.11/site-packages/manim/mobject/opengl/opengl_vectorized_mobject.py:268 in │
│ set_stroke                                                                                       │
│                                                                                                  │
│    265 │   │                                                                                     │
│    266 │   │   if width is not None:                                                             │
│    267 │   │   │   for mob in self.get_family(recurse):                                          │
│ ❱  268 │   │   │   │   mob.stroke_width = np.array([[width] for width in listify(width)])        │
│    269 │   │                                                                                     │
│    270 │   │   if background is not None:                                                        │
│    271 │   │   │   for mob in self.get_family(recurse):                                          │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
ValueError: setting an array element with a sequence. The requested array would exceed the maximum number of dimension of 32.

System specifications

System Details
  • OS: the manimcommunity/manim:stable docker image, hosted inside Ubuntu 20.04.6 LTS (GNU/Linux 5.15.167.4-microsoft-standard-WSL2 x86_64) (via WSL2 on Windows 11 23H2):
  • RAM: 64GB
  • Python version (python/py/python3 --version): Python 3.11.9
  • Installed modules (provide output from pip list):
Package                       Version
----------------------------- --------------
alabaster                     0.7.16
anyio                         4.3.0
argon2-cffi                   23.1.0
argon2-cffi-bindings          21.2.0
arrow                         1.3.0
asttokens                     2.4.1
async-lru                     2.0.4
attrs                         23.2.0
Babel                         2.14.0
beautifulsoup4                4.12.3
bleach                        6.1.0
certifi                       2024.2.2
cffi                          1.16.0
charset-normalizer            3.3.2
click                         8.1.7
cloup                         3.0.5
comm                          0.2.2
debugpy                       1.8.1
decorator                     5.1.1
defusedxml                    0.7.1
docutils                      0.21.2
executing                     2.0.1
fastjsonschema                2.19.1
fqdn                          1.5.1
furo                          2024.4.27
glcontext                     2.5.0
h11                           0.14.0
httpcore                      1.0.5
httpx                         0.27.0
idna                          3.7
imagesize                     1.4.1
ipykernel                     6.29.4
ipython                       8.24.0
isoduration                   20.11.0
isosurfaces                   0.1.2
jedi                          0.19.1
Jinja2                        3.1.3
json5                         0.9.25
jsonpointer                   2.4
jsonschema                    4.21.1
jsonschema-specifications     2023.12.1
jupyter_client                8.6.1
jupyter_core                  5.7.2
jupyter-events                0.10.0
jupyter-lsp                   2.2.5
jupyter_server                2.14.0
jupyter_server_terminals      0.5.3
jupyterlab                    4.1.8
jupyterlab_pygments           0.3.0
jupyterlab_server             2.27.1
manim                         0.18.1
ManimPango                    0.5.0
mapbox-earcut                 1.0.1
markdown-it-py                3.0.0
MarkupSafe                    2.1.5
matplotlib-inline             0.1.7
mdit-py-plugins               0.4.0
mdurl                         0.1.2
mistune                       3.0.2
moderngl                      5.10.0
moderngl-window               2.4.6
multipledispatch              1.0.0
myst-parser                   3.0.0
nbclient                      0.10.0
nbconvert                     7.16.3
nbformat                      5.10.4
nest-asyncio                  1.6.0
networkx                      3.3
notebook                      7.1.3
notebook_shim                 0.2.4
numpy                         1.26.4
overrides                     7.7.0
packaging                     24.0
pandocfilters                 1.5.1
parso                         0.8.4
pexpect                       4.9.0
pillow                        10.3.0
pip                           24.0
platformdirs                  4.2.1
prometheus_client             0.20.0
prompt-toolkit                3.0.43
psutil                        5.9.8
ptyprocess                    0.7.0
pure-eval                     0.2.2
pycairo                       1.26.0
pycparser                     2.22
pydub                         0.25.1
pyglet                        2.0.15
Pygments                      2.17.2
pyrr                          0.10.3
python-dateutil               2.9.0.post0
python-json-logger            2.0.7
PyYAML                        6.0.1
pyzmq                         26.0.2
referencing                   0.35.0
requests                      2.31.0
rfc3339-validator             0.1.4
rfc3986-validator             0.1.1
rich                          13.7.1
rpds-py                       0.18.0
scipy                         1.13.0
screeninfo                    0.8.1
Send2Trash                    1.8.3
setuptools                    65.5.1
six                           1.16.0
skia-pathops                  0.8.0.post1
sniffio                       1.3.1
snowballstemmer               2.2.0
soupsieve                     2.5
Sphinx                        7.3.7
sphinx-basic-ng               1.0.0b2
sphinx-copybutton             0.5.2
sphinxcontrib-applehelp       1.0.8
sphinxcontrib-devhelp         1.0.6
sphinxcontrib-htmlhelp        2.0.5
sphinxcontrib-jsmath          1.0.1
sphinxcontrib-qthelp          1.0.7
sphinxcontrib-serializinghtml 1.1.10
sphinxext-opengraph           0.9.1
srt                           3.5.3
stack-data                    0.6.3
svgelements                   1.9.6
terminado                     0.18.1
tinycss2                      1.3.0
tornado                       6.4
tqdm                          4.66.2
traitlets                     5.14.3
types-python-dateutil         2.9.0.20240316
typing_extensions             4.11.0
uri-template                  1.3.0
urllib3                       2.2.1
watchdog                      4.0.0
wcwidth                       0.2.13
webcolors                     1.13
webencodings                  0.5.1
websocket-client              1.8.0
wheel                         0.43.0```
</details>

<details><summary>LaTeX details</summary>

+ LaTeX distribution (e.g. TeX Live 2020):

The version installed in your docker image, which `tlmgr -v` reports as:

tlmgr revision 71079 (2024-04-26 00:15:30 +0200)
tlmgr using installation: /usr/local/texlive
TeX Live (https://tug.org/texlive) version 2024


+ Installed LaTeX packages:

i adjustbox: Graphics package-alike macros for "general" boxes
i adobemapping: Adobe cmap and pdfmapping files
i amscls: AMS document classes for LaTeX
i amsfonts: TeX fonts from the American Mathematical Society
i amsmath: AMS mathematical facilities for LaTeX
i arphic: Arphic (Chinese) font packages
i atbegshi: Execute stuff at \shipout time
i atveryend: Hooks at the very end of a document
i auxhook: Hooks for auxiliary files
i babel: Multilingual support for LaTeX, LuaLaTeX, XeLaTeX, and Plain TeX
i babel-english: Babel support for English
i beamer: A LaTeX class for producing presentations and slides
i bibtex: Process bibliographies (bib files) for LaTeX or other formats
i bibtex.x86_64-linux: x86_64-linux files of bibtex
i bigintcalc: Integer calculations on very large numbers
i bitset: Handle bit-vector datatype
i cbfonts-fd: LaTeX font description files for the CB Greek fonts
i cjk: CJK language support
i cjkpunct: Adjust locations and kerning of CJK punctuation marks
i cm: Computer Modern fonts
i cm-super: CM-Super family of fonts
i cns: Chinese/Japanese/Korean bitmap fonts
i collectbox: Collect and process macro arguments as boxes
i collection-basic: Essential programs and files
i colorprofiles: Collection of free ICC profiles
i ctablestack: Catcode table stable support
i ctex: LaTeX classes and packages for Chinese typesetting
i currfile: Provide file name and path of input files
i dehyph: German hyphenation patterns for traditional orthography
i doublestroke: Typeset mathematical double stroke symbols
i dvipdfmx: An extended version of dvipdfm
i dvipdfmx.x86_64-linux: x86_64-linux files of dvipdfmx
i dvips: A DVI to PostScript driver
i dvips.x86_64-linux: x86_64-linux files of dvips
i dvisvgm: Convert DVI, EPS, and PDF files to Scalable Vector Graphics format (SVG)
i dvisvgm.x86_64-linux: x86_64-linux files of dvisvgm
i ec: Computer modern fonts in T1 and TS1 encodings
i enctex: A TeX extension that translates input on its way into TeX
i epstopdf: Convert EPS to PDF using Ghostscript
i epstopdf-pkg: Call epstopdf "on the fly"
i epstopdf.x86_64-linux: x86_64-linux files of epstopdf
i etex: An extended version of TeX, from the NTS project
i etex-pkg: E-TeX support package
i etexcmds: Avoid name clashes with e-TeX commands
i etoolbox: e-TeX tools for LaTeX
i euenc: Unicode font encoding definitions for XeTeX
i everyhook: Hooks for standard TeX token lists
i everysel: Provides hooks into \selectfont
i fandol: Four basic fonts for Chinese typesetting
i filemod: Provide file modification times, and compare them
i firstaid: First aid for external LaTeX files and packages that need updating
i fonts-tlwg: Thai fonts for LaTeX from TLWG
i fontspec: Advanced font selection in XeLaTeX and LuaLaTeX
i fp: Fixed point arithmetic
i frcursive: French cursive hand fonts
i fundus-calligra: Support for the calligra font in LaTeX documents
i garuda-c90: TeX support (from CJK) for the garuda font
i geometry: Flexible and complete interface to document dimensions
i gettitlestring: Clean up title references
i gincltex: Include TeX files as graphics (.tex support for \includegraphics)
i glyphlist: Adobe Glyph List and TeX extensions
i gnu-freefont: A Unicode font, with rather wide coverage
i graphics: The LaTeX standard graphics bundle
i graphics-cfg: Sample configuration files for LaTeX color and graphics
i graphics-def: Colour and graphics option files
i hycolor: Implements colour for packages hyperref and bookmark
i hyperref: Extensive support for hypertext in LaTeX
i hyph-utf8: Hyphenation patterns expressed in UTF-8
i hyphen-base: core hyphenation support files
i hyphen-english: English hyphenation patterns.
i hyphenex: US English hyphenation exceptions file
i ifplatform: Conditionals to test which platform is being used
i iftex: Am I running under pdfTeX, XeTeX or LuaTeX?
i infwarerr: Complete set of information/warning/error message macros
i intcalc: Expandable arithmetic operations with integers
i jknapltx: Miscellaneous packages by Joerg Knappen
i knuth-lib: Core TeX and Metafont sources from Knuth
i knuth-local: Knuth's local information
i kpathsea: Path searching library for TeX-related files
i kpathsea.x86_64-linux: x86_64-linux files of kpathsea
i kvdefinekeys: Define keys for use in the kvsetkeys package
i kvoptions: Key value format for package options
i kvsetkeys: Key value parser with default handler support
i l3backend: LaTeX3 backend drivers
i l3backend-dev: LaTeX3 backend drivers (dev)
i l3kernel: LaTeX3 programming conventions
i l3kernel-dev: Development pre-release of l3kernel
i l3packages: High-level LaTeX3 concepts
i latex: A TeX macro package that defines LaTeX
i latex-base-dev: Development pre-release of the LaTeX kernel
i latex-bin: LaTeX executables and man pages
i latex-bin.x86_64-linux: x86_64-linux files of latex-bin
i latex-firstaid-dev: Development pre-release of the LaTeX firstaid package
i latex-fonts: A collection of fonts used in LaTeX distributions
i latexconfig: configuration files for LaTeX-related formats
i letltxmacro: Let assignment for LaTeX macros
i lm: Latin modern fonts in outline formats
i ltxcmds: Some LaTeX kernel commands for general use
i lua-alt-getopt: Process application arguments the same way as getopt_long
i lua-uni-algos: Unicode algorithms for LuaTeX
i luahbtex: LuaTeX with HarfBuzz library for glyph shaping
i luahbtex.x86_64-linux: x86_64-linux files of luahbtex
i lualibs: Additional Lua functions for LuaTeX macro programmers
i luaotfload: OpenType 'loader' for Plain TeX and LaTeX
i luaotfload.x86_64-linux: x86_64-linux files of luaotfload
i luatex: The LuaTeX engine
i luatex.x86_64-linux: x86_64-linux files of luatex
i luatexbase: Basic resource management for LuaTeX code
i luatexja: Typeset Japanese with Lua(La)TeX
i makeindex: Makeindex development sources
i makeindex.x86_64-linux: x86_64-linux files of makeindex
i mathastext: Use the text font in maths mode
i metafont: A system for specifying fonts
i metafont.x86_64-linux: x86_64-linux files of metafont
i mflogo: LaTeX support for Metafont logo fonts
i mfware: Supporting tools for use with Metafont
i mfware.x86_64-linux: x86_64-linux files of mfware
i microtype: Subliminal refinements towards typographical perfection
i modes: A collection of Metafont mode_def's
i mptopdf: mpost to PDF, native MetaPost graphics inclusion
i mptopdf.x86_64-linux: x86_64-linux files of mptopdf
i ms: Various LaTeX packages by Martin Schroder
i norasi-c90: TeX support (from CJK) for the norasi font
i pdfescape: Implements pdfTeX's escape features using TeX or e-TeX
i pdftex: A TeX extension for direct creation of PDF
i pdftex.x86_64-linux: x86_64-linux files of pdftex
i pdftexcmds: LuaTeX support for pdfTeX utility functions
i pgf: Create PostScript and PDF graphics in TeX
i physics: Macros supporting the Mathematics of Physics
i plain: The Plain TeX format
i platex: pLaTeX2e and miscellaneous macros for pTeX
i platex-tools: pLaTeX standard tools bundle
i platex.x86_64-linux: x86_64-linux files of platex
i preview: Extract bits of a LaTeX source for output
i ptex: A TeX system for publishing in Japanese
i ptex-base: Plain TeX format for pTeX and e-pTeX
i ptex-fonts: Fonts for use with pTeX
i ptex.x86_64-linux: x86_64-linux files of ptex
i ragged2e: Alternative versions of "ragged"-type commands
i refcount: Counter operations with label references
i relsize: Set the font size relative to the current font size
i rerunfilecheck: Checksum based rerun checks on auxiliary files
i rsfs: Ralph Smith's Formal Script font
i scheme-infraonly: infrastructure-only scheme (no TeX at all)
i scheme-minimal: minimal scheme (plain only)
i setspace: Set space between lines
i standalone: Compile TeX pictures stand-alone or as part of a document
i stringenc: Converting a string between different encodings
i svn-prov: Subversion variants of \Provides... macros
i tex: A sophisticated typesetting engine
i tex-ini-files: Model TeX format creation files
i tex.x86_64-linux: x86_64-linux files of tex
i texlive-common: TeX Live documentation (common elements)
i texlive-en: TeX Live manual (English)
i texlive-msg-translations: translations of the TeX Live installer and TeX Live Manager
i texlive-scripts: TeX Live infrastructure programs
i texlive-scripts.x86_64-linux: x86_64-linux files of texlive-scripts
i texlive.infra: basic TeX Live infrastructure
i texlive.infra.x86_64-linux: x86_64-linux files of texlive.infra
i tipa: Fonts and macros for IPA phonetics characters
i tlshell: GUI frontend (tcl/tk-based) for tlmgr
i tlshell.x86_64-linux: x86_64-linux files of tlshell
i tools: The LaTeX standard tools bundle
i translator: Easy translation of strings in LaTeX
i ttfutils: convert TrueType to TFM and PK fonts
i ttfutils.x86_64-linux: x86_64-linux files of ttfutils
i uhc: Fonts for the Korean language
i ulem: Package for underlining
i unicode-data: Unicode data and loaders for TeX
i uniquecounter: Provides unlimited unique counter
i uplatex: pLaTeX2e and miscellaneous macros for upTeX
i uplatex.x86_64-linux: x86_64-linux files of uplatex
i uptex: Unicode version of pTeX
i uptex-base: Plain TeX formats and documents for upTeX
i uptex-fonts: Fonts for use with upTeX
i uptex.x86_64-linux: x86_64-linux files of uptex
i url: Verbatim with URL-sensitive line breaks
i wadalab: Wadalab (Japanese) font packages
i wasy: The wasy fonts (Waldi symbol fonts)
i wasysym: LaTeX support for the wasy fonts
i xcjk2uni: Convert CJK characters to Unicode, in pdfTeX
i xcolor: Driver-independent color extensions for LaTeX and pdfLaTeX
i xdvi: A DVI previewer for the X Window System
i xdvi.x86_64-linux: x86_64-linux files of xdvi
i xecjk: Support for CJK documents in XeLaTeX
i xetex: An extended variant of TeX for use with Unicode sources
i xetex.x86_64-linux: x86_64-linux files of xetex
i xetexconfig: crop.cfg for XeLaTeX
i xkeyval: Extension of the keyval package
i xpinyin: Automatically add pinyin to Chinese characters
i xunicode: Generate Unicode characters from accented glyphs
i zapfding: URW 'Base 35' font pack for LaTeX
i zhmetrics: TFM subfont files for using Chinese fonts in 8-bit TeX
i zhmetrics-uptex: Chinese font metrics for upTeX
i zhnumber: Typeset Chinese representations of numbers


</details>

## Additional comments

I suspect this is because of this line:

https://github.com/ManimCommunity/manim/blob/7879fe43770da2e93240f99adb79ef8ee91b6661/manim/mobject/opengl/opengl_vectorized_mobject.py#L272

This works fine the first time it runs, but it gradually ends up wrapping the value more and more deeply.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
1 participant
@idg10