Create opengl running 'modes'

[k4pran]

Enhancement proposal

Opengl brings along a number of new features that is creating a lot of complexity. I think it is slowly becoming confusing to maintain.

First example is the number of output formats:

• -s results in saving a single png
• --format <INSERT_FORMAT> allows outputs such as mp4, webm, png, gif etc
• write_to_movie results in mp4 output
• -p triggers a preview on the above format

This is just like cairo but now in opengl we have the pyglet window and interactive_embed. So now we have all the above options, plus two different ways to create windows:

• Pyglet window can be created just to view the scene, then close after the scene has finished
• interactive_embed that keeps the window open and allows for interaction

See this PR #1982 to see how it can start getting messy, trying to determine how different permutations of these should behave.

I am not sure of the best solution, but I think we should at least agree on how the different flags should interact, when windows should be created, the precedence order etc, then when we agree on this boil it down to a number of modes that are determined at startup so that we don't need to keep checking lots of flags to determine the behaviour.

Additional comments

[hydrobeam]

I think we can take inspiration from how manimgl operates. To get a full breakdown of the flag situation works over there: https://3b1b.github.io/manim/getting_started/configuration.html

For a quick breakdown of the most important points:
manim file.py Scene --> creates an interactive window (no flags needed)
manim -w --> equivalent to --write_to_movie, disables interactive window and writes to a file
manim -w -o --> opens the file after is created
manim -w -o -s --> saves the last frame as a png and opens it.
manim -s --> just renders the final frame in the interactive window.

I think we should have either self.interactive_embed() be the default, or implement(/copy) manimgl's lingering window after all animations. Currently, default behaviour in manimgl is to have the window linger when an animation is played, without using a shell. I lean towards this as it takes a relatively long time to create an IPython shell, and it makes the creation process slower overall to constantly rely on the interactive_embed() process. Plus, more often than not, you just want to view the scene, not interact with its elements.

Our current approach to have the window automatically close is very inconvient, since it means that manimations without animations instantly close, and it's not possible to just view the product of a scene. Of course, you can manually call self.interactive_embed(), but this is just a needless hassle.

Plus, interactive_embed() should probably be renamed to embed() and have the original embed() dropped, since it's redundant.

This also means dropping the -p flag, which is ambigous.

[k4pran]

Yea it does seem cleaner and open makes more sense in opengl than preview, since preview in the context of being able to preview in the window or in the output file.

manim -w --> equivalent to --write_to_movie, disables interactive window and writes to a file

What about also either removing write_to_movie or making it an alias of format --mp4 as they should both do the same thing? Having them separate is confusing as they do the same thing but there are lots of checks for write_to_movie that changes the behaviour but I assume --format mp4 doesn't as it is rarely checked. Also write_to_movie is a bit ambiguous since we have multiple movie formats, I would prefer to remove it.

I think we should have either self.interactive_embed() be the default, or implement(/copy) manimgl's lingering window after all animations

Just to make sure I understand, do you mean by default the window is created and animation is played by default but there is no interactive ipython console by default? So this means interactive embed will behave the same as the default with the exception that it will also start the interactive shell?

I do like the changes to flags you mentioned, but I still thing we should distill the options you mentioned to different modes of running, as in some cases we would need to check multiple flags like -w -o -s, if we can take those combination of flags and create one mode from them that makes sense it will be easier to do the checks we need and give us more control. By more control I mean that we won't have some places checking a few flags and missing one of them, or some parts of the code checking the wrong combination of flags

[hydrobeam]

Sorry for getting to this quite late!

What about also either removing write_to_movie or making it an alias of format --mp4 as they should both do the same thing? Having them separate is confusing as they do the same thing but there are lots of checks for write_to_movie that changes the behaviour but I assume --format mp4 doesn't as it is rarely checked. Also write_to_movie is a bit ambiguous since we have multiple movie formats, I would prefer to remove it.

I think we could instead rename --write_to_movie to just be write, and then have it be paired with --format=<desired_format> if someone wants to change the file format. Having -w/--write for write makes sense. And I agree that write_to_movie is in fact quite amibigious, but I'm unsure about full transitioning to the format syntax since --write/-w feels a bit more natural to me than specifying a file format and implying that it'll write.

Just to make sure I understand, do you mean by default the window is created and animation is played by default but there is no interactive ipython console by default? So this means interactive embed will behave the same as the default with the exception that it will also start the interactive shell?

That's essentially the case. The parameter that handles this behaviour in manimgl is linger_after_completion, which would make it so that after an animation finishes playing, the interactive window simply hangs back after creation and you can manipulate the camera to view the scene. This would also make it so that single-frame scenes don't instantly close.

I tried porting this functionality over from manimgl, but ran into some issues since I'm not really comfortable with the internals of the opengl renderer.

If we can take those combination of flags and create one mode from them that makes sense it will be easier to do the checks we need and give us more control.

That's fair. Would this look like: disable_window for flags that would disable the window?