Showing preview only (1,009K chars total). Download the full file or copy to clipboard to get everything.
Repository: 3b1b/manim
Branch: master
Commit: 2e31f79a2359
Files: 160
Total size: 958.5 KB
Directory structure:
gitextract_x3i4m6_j/
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ ├── config.yml
│ │ └── error-when-using.md
│ ├── PULL_REQUEST_TEMPLATE.md
│ └── workflows/
│ ├── docs.yml
│ └── publish.yml
├── .gitignore
├── LICENSE.md
├── MANIFEST.in
├── README.md
├── docs/
│ ├── Makefile
│ ├── example.py
│ ├── make.bat
│ ├── requirements.txt
│ └── source/
│ ├── conf.py
│ ├── development/
│ │ ├── about.rst
│ │ ├── changelog.rst
│ │ └── contributing.rst
│ ├── documentation/
│ │ ├── animation/
│ │ │ └── index.rst
│ │ ├── camera/
│ │ │ └── index.rst
│ │ ├── constants.rst
│ │ ├── custom_config.rst
│ │ ├── mobject/
│ │ │ └── index.rst
│ │ ├── scene/
│ │ │ └── index.rst
│ │ ├── shaders/
│ │ │ └── index.rst
│ │ └── utils/
│ │ └── index.rst
│ ├── getting_started/
│ │ ├── configuration.rst
│ │ ├── example_scenes.rst
│ │ ├── installation.rst
│ │ ├── quickstart.rst
│ │ ├── structure.rst
│ │ └── whatsnew.rst
│ ├── index.rst
│ └── manim_example_ext.py
├── example_scenes.py
├── logo/
│ └── logo.py
├── manimlib/
│ ├── __init__.py
│ ├── __main__.py
│ ├── animation/
│ │ ├── __init__.py
│ │ ├── animation.py
│ │ ├── composition.py
│ │ ├── creation.py
│ │ ├── fading.py
│ │ ├── growing.py
│ │ ├── indication.py
│ │ ├── movement.py
│ │ ├── numbers.py
│ │ ├── rotation.py
│ │ ├── specialized.py
│ │ ├── transform.py
│ │ ├── transform_matching_parts.py
│ │ └── update.py
│ ├── camera/
│ │ ├── __init__.py
│ │ ├── camera.py
│ │ └── camera_frame.py
│ ├── config.py
│ ├── constants.py
│ ├── default_config.yml
│ ├── event_handler/
│ │ ├── __init__.py
│ │ ├── event_dispatcher.py
│ │ ├── event_listner.py
│ │ └── event_type.py
│ ├── extract_scene.py
│ ├── logger.py
│ ├── mobject/
│ │ ├── __init__.py
│ │ ├── boolean_ops.py
│ │ ├── changing.py
│ │ ├── coordinate_systems.py
│ │ ├── frame.py
│ │ ├── functions.py
│ │ ├── geometry.py
│ │ ├── interactive.py
│ │ ├── matrix.py
│ │ ├── mobject.py
│ │ ├── mobject_update_utils.py
│ │ ├── number_line.py
│ │ ├── numbers.py
│ │ ├── probability.py
│ │ ├── shape_matchers.py
│ │ ├── svg/
│ │ │ ├── __init__.py
│ │ │ ├── brace.py
│ │ │ ├── drawings.py
│ │ │ ├── old_tex_mobject.py
│ │ │ ├── special_tex.py
│ │ │ ├── string_mobject.py
│ │ │ ├── svg_mobject.py
│ │ │ ├── tex_mobject.py
│ │ │ └── text_mobject.py
│ │ ├── three_dimensions.py
│ │ ├── types/
│ │ │ ├── __init__.py
│ │ │ ├── dot_cloud.py
│ │ │ ├── image_mobject.py
│ │ │ ├── point_cloud_mobject.py
│ │ │ ├── surface.py
│ │ │ └── vectorized_mobject.py
│ │ ├── value_tracker.py
│ │ └── vector_field.py
│ ├── module_loader.py
│ ├── scene/
│ │ ├── __init__.py
│ │ ├── interactive_scene.py
│ │ ├── scene.py
│ │ ├── scene_embed.py
│ │ └── scene_file_writer.py
│ ├── shader_wrapper.py
│ ├── shaders/
│ │ ├── image/
│ │ │ ├── frag.glsl
│ │ │ └── vert.glsl
│ │ ├── inserts/
│ │ │ ├── NOTE.md
│ │ │ ├── complex_functions.glsl
│ │ │ ├── emit_gl_Position.glsl
│ │ │ ├── finalize_color.glsl
│ │ │ ├── get_unit_normal.glsl
│ │ │ └── get_xyz_to_uv.glsl
│ │ ├── mandelbrot_fractal/
│ │ │ ├── frag.glsl
│ │ │ └── vert.glsl
│ │ ├── newton_fractal/
│ │ │ ├── frag.glsl
│ │ │ └── vert.glsl
│ │ ├── quadratic_bezier/
│ │ │ ├── depth/
│ │ │ │ ├── frag.glsl
│ │ │ │ ├── geom.glsl
│ │ │ │ └── vert.glsl
│ │ │ ├── fill/
│ │ │ │ ├── frag.glsl
│ │ │ │ ├── geom.glsl
│ │ │ │ └── vert.glsl
│ │ │ └── stroke/
│ │ │ ├── frag.glsl
│ │ │ ├── geom.glsl
│ │ │ └── vert.glsl
│ │ ├── simple_vert.glsl
│ │ ├── surface/
│ │ │ ├── frag.glsl
│ │ │ └── vert.glsl
│ │ ├── textured_surface/
│ │ │ ├── frag.glsl
│ │ │ └── vert.glsl
│ │ └── true_dot/
│ │ ├── frag.glsl
│ │ ├── geom.glsl
│ │ └── vert.glsl
│ ├── tex_templates.yml
│ ├── typing.py
│ ├── utils/
│ │ ├── __init__.py
│ │ ├── bezier.py
│ │ ├── cache.py
│ │ ├── color.py
│ │ ├── debug.py
│ │ ├── dict_ops.py
│ │ ├── directories.py
│ │ ├── family_ops.py
│ │ ├── file_ops.py
│ │ ├── images.py
│ │ ├── iterables.py
│ │ ├── paths.py
│ │ ├── rate_functions.py
│ │ ├── shaders.py
│ │ ├── simple_functions.py
│ │ ├── sounds.py
│ │ ├── space_ops.py
│ │ ├── tex.py
│ │ ├── tex_file_writing.py
│ │ └── tex_to_symbol_count.py
│ └── window.py
├── pyproject.toml
├── requirements.txt
├── setup.cfg
└── setup.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: bug
assignees: ''
---
### Describe the bug
<!-- A clear and concise description of what the bug is. -->
**Code**:
<!-- The code you run which reflect the bug. -->
**Wrong display or Error traceback**:
<!-- the wrong display result of the code you run, or the error Traceback -->
### Additional context
<!-- Add any other context about the problem here. -->
================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
blank_issues_enabled: true
contact_links:
- name: Ask A Question
url: https://github.com/3b1b/manim/discussions/categories/q-a
about: Please ask questions you encountered here.
================================================
FILE: .github/ISSUE_TEMPLATE/error-when-using.md
================================================
---
name: Error when using
about: The error you encountered while using manim
title: ''
labels: ''
assignees: ''
---
### Describe the error
<!-- A clear and concise description of what you want to make. -->
### Code and Error
**Code**:
<!-- The code you run -->
**Error**:
<!-- The error traceback you get when run your code -->
### Environment
**OS System**:
**manim version**: master <!-- make sure you are using the latest version of master branch -->
**python version**:
================================================
FILE: .github/PULL_REQUEST_TEMPLATE.md
================================================
<!-- Thanks for contributing to manim!
Please ensure that your pull request works with the latest version of manim.
-->
## Motivation
<!-- Outline your motivation: In what way do your changes improve the library? -->
## Proposed changes
<!-- What you changed in those files -->
-
-
-
## Test
<!-- How do you test your changes -->
**Code**:
**Result**:
================================================
FILE: .github/workflows/docs.yml
================================================
name: docs
on:
push:
paths:
- 'docs/**'
pull_request:
paths:
- 'docs/**'
jobs:
docs:
runs-on: ubuntu-latest
name: build up document and deploy
steps:
- name: Checkout
uses: actions/checkout@master
- name: Install sphinx and manim env
run: |
pip3 install --upgrade pip
sudo apt install python3-setuptools libpango1.0-dev
pip3 install -r docs/requirements.txt
pip3 install -r requirements.txt
- name: Build document with Sphinx
run: |
cd docs
export PATH="$PATH:/home/runner/.local/bin"
export SPHINXBUILD="python3 -m sphinx"
make html
- name: Deploy to GitHub pages
if: ${{ github.event_name == 'push' }}
uses: JamesIves/github-pages-deploy-action@3.7.1
with:
ACCESS_TOKEN: ${{ secrets.DOC_DEPLOY_TOKEN }}
BRANCH: gh-pages
FOLDER: docs/build/html
================================================
FILE: .github/workflows/publish.yml
================================================
name: Upload Python Package
on:
release:
types: [created]
jobs:
deploy:
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
python: ["py37", "py38", "py39", "py310"]
steps:
- uses: actions/checkout@v6
- name: Set up Python
uses: actions/setup-python@v6
with:
python-version: '3.8'
- name: Install dependencies
run: |
python -m pip install --upgrade pip
pip install setuptools wheel twine build
- name: Build wheels
run: python setup.py bdist_wheel --python-tag ${{ matrix.python }}
- name: Upload wheels
env:
TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
run: |
twine upload dist/*
================================================
FILE: .gitignore
================================================
# Created by https://www.toptal.com/developers/gitignore/api/python
# Edit at https://www.toptal.com/developers/gitignore?templates=python
### Python ###
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
# C extensions
*.so
# Distribution / packaging
.Python
build/
develop-eggs/
dist/
manimlib.egg-info/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
pip-wheel-metadata/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# PyInstaller
# Usually these files are written by a python script from a template
# before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec
# Installer logs
pip-log.txt
pip-delete-this-directory.txt
# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
*.py,cover
.hypothesis/
.pytest_cache/
pytestdebug.log
# Translations
*.mo
*.pot
# Django stuff:
*.log
local_settings.py
db.sqlite3
db.sqlite3-journal
# Flask stuff:
instance/
.webassets-cache
# Scrapy stuff:
.scrapy
# Sphinx documentation
docs/_build/
doc/_build/
# PyBuilder
target/
# Jupyter Notebook
.ipynb_checkpoints
# IPython
profile_default/
ipython_config.py
# pyenv
.python-version
pyrightconfig.json
# pipenv
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
# However, in case of collaboration, if having platform-specific dependencies or dependencies
# having no cross-platform support, pipenv may install dependencies that don't work, or not
# install all needed dependencies.
#Pipfile.lock
# PEP 582; used by e.g. github.com/David-OConnor/pyflow
__pypackages__/
# Celery stuff
celerybeat-schedule
celerybeat.pid
# SageMath parsed files
*.sage.py
# Environments
.env
.venv
env/
venv/
ENV/
env.bak/
venv.bak/
pythonenv*
# Spyder project settings
.spyderproject
.spyproject
# Rope project settings
.ropeproject
# mkdocs documentation
/site
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
# Pyre type checker
.pyre/
# pytype static type analyzer
.pytype/
# profiling data
.prof
# End of https://www.toptal.com/developers/gitignore/api/python
# Custom exclusions:
.DS_Store
# For manim
/videos
/custom_config.yml
test.py
CLAUDE.md
================================================
FILE: LICENSE.md
================================================
MIT License
Copyright (c) 2020-2023 3Blue1Brown LLC
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: MANIFEST.in
================================================
graft manimlib
recursive-exclude manimlib *.pyc *.DS_Store
================================================
FILE: README.md
================================================
<p align="center">
<a href="https://github.com/3b1b/manim">
<img src="https://raw.githubusercontent.com/3b1b/manim/master/logo/cropped.png">
</a>
</p>
[](https://pypi.org/project/manimgl/)
[](http://choosealicense.com/licenses/mit/)
[](https://www.reddit.com/r/manim/)
[](https://discord.com/invite/bYCyhM9Kz2)
[](https://3b1b.github.io/manim/)
Manim is an engine for precise programmatic animations, designed for creating explanatory math videos.
Note, there are two versions of manim. This repository began as a personal project by the author of [3Blue1Brown](https://www.3blue1brown.com/) for the purpose of animating those videos, with video-specific code available [here](https://github.com/3b1b/videos). In 2020 a group of developers forked it into what is now the [community edition](https://github.com/ManimCommunity/manim/), with a goal of being more stable, better tested, quicker to respond to community contributions, and all around friendlier to get started with. See [this page](https://docs.manim.community/en/stable/faq/installation.html#different-versions) for more details.
## Installation
> [!Warning]
> **WARNING:** These instructions are for ManimGL _only_. Trying to use these instructions to install [Manim Community/manim](https://github.com/ManimCommunity/manim) or instructions there to install this version will cause problems. You should first decide which version you wish to install, then only follow the instructions for your desired version.
> [!Note]
> **Note**: To install manim directly through pip, please pay attention to the name of the installed package. This repository is ManimGL of 3b1b. The package name is `manimgl` instead of `manim` or `manimlib`. Please use `pip install manimgl` to install the version in this repository.
Manim runs on Python 3.7 or higher.
System requirements are [FFmpeg](https://ffmpeg.org/), [OpenGL](https://www.opengl.org/) and [LaTeX](https://www.latex-project.org) (optional, if you want to use LaTeX).
For Linux, [Pango](https://pango.org) along with its development headers are required. See instruction [here](https://github.com/ManimCommunity/ManimPango#building).
### Directly
```sh
# Install manimgl
pip install manimgl
# Try it out
manimgl
```
For more options, take a look at the [Using manim](#using-manim) sections further below.
If you want to hack on manimlib itself, clone this repository and in that directory execute:
```sh
# Install manimgl
pip install -e .
# Try it out
manimgl example_scenes.py OpeningManimExample
# or
manim-render example_scenes.py OpeningManimExample
```
### Directly (Windows)
1. [Install FFmpeg](https://www.wikihow.com/Install-FFmpeg-on-Windows).
2. Install a LaTeX distribution. [MiKTeX](https://miktex.org/download) is recommended.
3. Install the remaining Python packages.
```sh
git clone https://github.com/3b1b/manim.git
cd manim
pip install -e .
manimgl example_scenes.py OpeningManimExample
```
### Mac OSX
1. Install FFmpeg, LaTeX in terminal using homebrew.
```sh
brew install ffmpeg mactex
```
<details>
<summary>💡 An alternative to heavyweight MacTeX bundle.</summary>
> To avoid installing the full MacTeX bundle, which is ~6GB, you can alternatively install the
> lightweight [BasicTeX](https://formulae.brew.sh/cask/basictex) and then gradually add
> only the LaTeX packages you actually need. A list of packages sufficient to run examples can
> be found [here](https://github.com/3b1b/manim/issues/2133#issuecomment-2414547866).
> For an overview of the MacTeX installer bundles, see https://www.tug.org/mactex/.
</details>
2. If you are using an ARM-based processor, install Cairo.
```sh
arch -arm64 brew install pkg-config cairo
```
3. Install latest version of manim using these command.
```sh
git clone https://github.com/3b1b/manim.git
cd manim
pip install -e .
manimgl example_scenes.py OpeningManimExample (make sure to add manimgl to path first.)
```
## Anaconda Install
1. Install LaTeX as above.
2. Create a conda environment using `conda create -n manim python=3.9`.
3. Activate the environment using `conda activate manim`.
4. Install manimgl using `pip install -e .`.
## Using manim
Try running the following:
```sh
manimgl example_scenes.py OpeningManimExample
```
This should pop up a window playing a simple scene.
Look through the [example scenes](https://3b1b.github.io/manim/getting_started/example_scenes.html) to see examples of the library's syntax, animation types and object types. In the [3b1b/videos](https://github.com/3b1b/videos) repo, you can see all the code for 3blue1brown videos, though code from older videos may not be compatible with the most recent version of manim. The readme of that repo also outlines some details for how to set up a more interactive workflow, as shown in [this manim demo video](https://www.youtube.com/watch?v=rbu7Zu5X1zI) for example.
When running in the CLI, some useful flags include:
* `-w` to write the scene to a file
* `-o` to write the scene to a file and open the result
* `-s` to skip to the end and just show the final frame.
* `-so` will save the final frame to an image and show it
* `-n <number>` to skip ahead to the `n`'th animation of a scene.
* `-f` to make the playback window fullscreen
Take a look at custom_config.yml for further configuration. To add your customization, you can either edit this file, or add another file by the same name "custom_config.yml" to whatever directory you are running manim from. For example [this is the one](https://github.com/3b1b/videos/blob/master/custom_config.yml) for 3blue1brown videos. There you can specify where videos should be output to, where manim should look for image files and sounds you want to read in, and other defaults regarding style and video quality.
### Documentation
Documentation is in progress at [3b1b.github.io/manim](https://3b1b.github.io/manim/). And there is also a Chinese version maintained by [**@manim-kindergarten**](https://manim.org.cn): [docs.manim.org.cn](https://docs.manim.org.cn/) (in Chinese).
[manim-kindergarten](https://github.com/manim-kindergarten/) wrote and collected some useful extra classes and some codes of videos in [manim_sandbox repo](https://github.com/manim-kindergarten/manim_sandbox).
## Contributing
Is always welcome. As mentioned above, the [community edition](https://github.com/ManimCommunity/manim) has the most active ecosystem for contributions, with testing and continuous integration, but pull requests are welcome here too. Please explain the motivation for a given change and examples of its effect.
## License
This project falls under the MIT license.
================================================
FILE: docs/Makefile
================================================
# Minimal makefile for Sphinx documentation
#
# You can set these variables from the command line, and also
# from the environment for the first two.
SPHINXOPTS ?=
SPHINXBUILD ?= sphinx-build
SOURCEDIR = source
BUILDDIR = build
# Put it first so that "make" without argument is like "make help".
help:
@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
.PHONY: help Makefile
# Catch-all target: route all unknown targets to Sphinx using the new
# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
%: Makefile
@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
================================================
FILE: docs/example.py
================================================
from manimlib import *
class SquareToCircle(Scene):
def construct(self):
circle = Circle()
circle.set_fill(BLUE, opacity=0.5)
circle.set_stroke(BLUE_E, width=4)
square = Square()
self.play(ShowCreation(square))
self.wait()
self.play(ReplacementTransform(square, circle))
self.wait()
# Try typing the following lines
# self.play(circle.animate.stretch(4, dim=0))
# self.play(Rotate(circle, TAU / 4))
# self.play(circle.animate.shift(2 * RIGHT), circle.animate.scale(0.25))
# circle.insert_n_curves(10)
# self.play(circle.animate.apply_complex_function(lambda z: z**2))
class SquareToCircleEmbed(Scene):
def construct(self):
circle = Circle()
circle.set_fill(BLUE, opacity=0.5)
circle.set_stroke(BLUE_E, width=4)
self.add(circle)
self.wait()
self.play(circle.animate.stretch(4, dim=0))
self.wait(1.5)
self.play(Rotate(circle, TAU / 4))
self.wait(1.5)
self.play(circle.animate.shift(2 * RIGHT), circle.animate.scale(0.25))
self.wait(1.5)
circle.insert_n_curves(10)
self.play(circle.animate.apply_complex_function(lambda z: z**2))
self.wait(2)
================================================
FILE: docs/make.bat
================================================
@ECHO OFF
pushd %~dp0
REM Command file for Sphinx documentation
if "%SPHINXBUILD%" == "" (
set SPHINXBUILD=sphinx-build
)
set SOURCEDIR=source
set BUILDDIR=build
if "%1" == "" goto help
%SPHINXBUILD% >NUL 2>NUL
if errorlevel 9009 (
echo.
echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
echo.installed, then set the SPHINXBUILD environment variable to point
echo.to the full path of the 'sphinx-build' executable. Alternatively you
echo.may add the Sphinx directory to PATH.
echo.
echo.If you don't have Sphinx installed, grab it from
echo.http://sphinx-doc.org/
exit /b 1
)
%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
goto end
:help
%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
:end
popd
================================================
FILE: docs/requirements.txt
================================================
Sphinx==3.0.3
sphinx-copybutton
furo==2020.10.5b9
Jinja2
================================================
FILE: docs/source/conf.py
================================================
import os
import sys
sys.path.insert(0, os.path.abspath("."))
sys.path.insert(0, os.path.abspath('../../'))
project = 'manim'
copyright = '- This document has been placed in the public domain.'
author = 'TonyCrane'
release = ''
extensions = [
'sphinx.ext.todo',
'sphinx.ext.githubpages',
'sphinx.ext.mathjax',
'sphinx.ext.intersphinx',
'sphinx.ext.autodoc',
'sphinx.ext.coverage',
'sphinx.ext.napoleon',
'sphinx_copybutton',
'manim_example_ext'
]
autoclass_content = 'both'
mathjax_path = "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js"
templates_path = ['_templates']
source_suffix = '.rst'
master_doc = 'index'
pygments_style = 'default'
html_static_path = ["_static"]
html_css_files = [
"https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/custom.css",
"https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/colors.css"
]
html_theme = 'furo' # pip install furo==2020.10.5b9
html_favicon = '_static/icon.png'
html_logo = '../../logo/transparent_graph.png'
html_theme_options = {
"sidebar_hide_name": True,
}
================================================
FILE: docs/source/development/about.rst
================================================
About
=====
About Manim
-----------
Manim is an animation engine for explanatory math videos.
You can use it to make math videos (or other fields) like 3Blue1Brown.
There are mainly two versions here:
- `3b1b/manim <https://github.com/3b1b/manim>`_ : Maintained by Grant Sanderson of 3Blue1Brown.
Using OpenGL and its GLSL language to use GPU for rendering. It has higher efficiency,
faster rendering speed, and supports real-time rendering and interaction.
- `ManimCommunity/manim <https://github.com/ManimCommunity/manim>`_ : Maintained by Manim Community Dev Team.
Using multiple backend rendering. There is better documentation and
a more open contribution community.
About this documentation
------------------------
This documentation is based on the version in `3b1b/manim <https://github.com/3b1b/manim>`_.
Created by `TonyCrane <https://github.com/TonyCrane>`_ ("鹤翔万里" in Chinese) and in production.
Among them, the ``manim_example_ext`` extension for Sphinx refers to
`the documentation of ManimCommunity <https://docs.manim.community/>`_.
If you want to contribute to manim or this document, please see: :doc:`contributing`
================================================
FILE: docs/source/development/changelog.rst
================================================
Changelog
=========
Unreleased
----------
Breaking Changes
^^^^^^^^^^^^^^^^
- Added ``InteractiveScene`` (`#1794 <https://github.com/3b1b/manim/pull/1794>`__)
Fixed bugs
^^^^^^^^^^
- Fixed ``ImageMobject`` by overriding ``set_color`` method (`#1791 <https://github.com/3b1b/manim/pull/1791>`__)
- Fixed bug with trying to close window during embed (`#1796 <https://github.com/3b1b/manim/commit/e0f5686d667152582f052021cd62bd2ef8c6b470>`__)
- Fixed animating ``Mobject.restore`` bug (`#1796 <https://github.com/3b1b/manim/commit/62289045cc8e102121cfe4d7739f3c89102046fb>`__)
- Fixed ``InteractiveScene.refresh_selection_highlight`` (`#1802 <https://github.com/3b1b/manim/commit/205116b8cec964b5619416f6e8acf0d8ac7df828>`__)
- Fixed ``VMobject.match_style`` (`#1821 <https://github.com/3b1b/manim/commit/0060a4860c9d6b073a60cd839269c213446bba7b>`__)
New Features
^^^^^^^^^^^^
- Added specific euler angle getters (`#1794 <https://github.com/3b1b/manim/commit/df2d465140e25fee265f602608aebbbaa2898c7e>`__)
- Added start angle option to ``Circle`` (`#1794 <https://github.com/3b1b/manim/commit/217c1d7bb02f23a61722bf7275c40802be808563>`__)
- Added ``Mobject.is_touching`` (`#1794 <https://github.com/3b1b/manim/commit/c1716895c0d9f36e23487322a18963991100bb95>`__)
- Added ``Mobject.get_highlight`` (`#1794 <https://github.com/3b1b/manim/commit/29816fa74c7aa6ca060b63ab4165c89987e58d8b>`__)
- Allowed for saving and loading mobjects from file (`#1794 <https://github.com/3b1b/manim/commit/50f5d20cc379947d7253d841c060dd7c55fa7787>`__)
- Added ``Mobject.get_all_corners`` (`#1794 <https://github.com/3b1b/manim/commit/f636199d9a5d1e87ab861bcb6aebae6c9d96a133>`__)
- Added ``Scene.id_to_mobject`` and ``Scene.ids_to_group`` (`#1794 <https://github.com/3b1b/manim/commit/cb768c26a0bc63e02c3035b4af31ba5cbc2e9dda>`__)
- Added ``Scene.save_mobject`` and ``Scene.load_mobject`` to allow for saving and loading mobjects from file at the Scene level (`#1794 <https://github.com/3b1b/manim/commit/777b6d37783f8592df8a8abc3d62af972bc5a0c6>`__)
- Added ``InteractiveScene`` (`#1794 <https://github.com/3b1b/manim/commit/c3afc84bfeb3a76ea8ede4ec4d9f36df0d4d9a28>`__)
- Added ``VHighlight`` (`#1794 <https://github.com/3b1b/manim/commit/9d5e2b32fa9215219d11a601829126cea40410d1>`__)
- Allowed for sweeping selection (`#1796 <https://github.com/3b1b/manim/commit/4caa03332367631d2fff15afd7e56b15fe8701ee>`__)
- Allowed stretched-resizing (`#1796 <https://github.com/3b1b/manim/commit/b4b72d1b68d0993b96a6af76c4bb6816f77f0f12>`__)
- Added cursor location label (`#1796 <https://github.com/3b1b/manim/commit/b9751e9d06068f27a327b419c52fd3c9d68db2e6>`__)
- Added ``Mobject.deserialize`` (`#1796 <https://github.com/3b1b/manim/commit/4d8698a0e88333f6481c08d1b84b6e44f9dc4543>`__)
- Added undo and redo stacks for scene (`#1796 <https://github.com/3b1b/manim/commit/cf466006faa00fc12dc22f5732dc21ccedaa5a63>`__)
- Added ``Mobject.looks_identical`` (`#1802 <https://github.com/3b1b/manim/commit/c3c5717dde543b172b928b516d80a29bbd12651f>`__)
- Added equality for ``ShaderWrapper`` (`#1802 <https://github.com/3b1b/manim/commit/3ae0a4e81b7790194bcf27142a1deb29fa548b9d>`__)
- Added ``Mobject.get_ancestors`` (`#1802 <https://github.com/3b1b/manim/commit/db884b0a67fcee1ad7009f1869c475015fa886c7>`__)
- Added smarter default radius to ``Polygon.round_corners`` (`#1802 <https://github.com/3b1b/manim/commit/4c1210b3ab1bf66b161f3d00cb859d36068c2fbb>`__)
- Added checkpoints to ``Scene`` (`#1821 <https://github.com/3b1b/manim/commit/1b589e336f8151f2914ff00e8956baea8a95abc5>`__)
- Added ``crosshair`` to ``InteractiveScene`` (`#1821 <https://github.com/3b1b/manim/commit/33ffd4863aaa7ecf950b7044181a8e8e3c643698>`__)
- Added ``SceneState`` (`#1821 <https://github.com/3b1b/manim/commit/75e1cff5792065aa1c7fb3eb02e6ee0fa0e8e18d>`__)
- Added ``time_span`` option to ``Animation`` (`#1821 <https://github.com/3b1b/manim/commit/a6fcfa3b4053b7f68f7b029eae87dbd207d97ad2>`__)
- Added ``Mobject.arrange_to_fit_dim`` (`#1821 <https://github.com/3b1b/manim/commit/a87d3b5f59a64ce5a89ce6e17310bdbf62166157>`__)
- Added ``DecimalNumber.get_tex`` (`#1821 <https://github.com/3b1b/manim/commit/48689c8c7bc0029bf5c1b540c11f647e857d419b>`__)
Refactor
^^^^^^^^
- Updated parent updater status when adding updaters (`#1794 <https://github.com/3b1b/manim/commit/3b847da9eaad7391e779c5dbce63ad9257d8c773>`__)
- Added case for zero vectors on ``angle_between_vectors`` (`#1794 <https://github.com/3b1b/manim/commit/e8ac25903e19cbb2b2c2037c988baafce4ddcbbc>`__)
- Refactored ``Mobject.clear_updaters`` (`#1794 <https://github.com/3b1b/manim/commit/95f56f5e80106443d705c68fa220850ec38daee0>`__)
- Changed the way changing-vs-static mobjects are tracked (more details see `#1794 <https://github.com/3b1b/manim/commit/50565fcd7a43ed13dc532f17515208edf97f64d0>`__)
- Refactored ``Mobject.is_point_touching`` (`#1794 <https://github.com/3b1b/manim/commit/135f68de35712be266a1a85261d6d44234fc0056>`__)
- Refactored ``Mobject.make_movable`` and ``Mobject.set_animating_status`` to recurse over family (`#1794 <https://github.com/3b1b/manim/commit/48390375037f745c9cb82b03d1cb3a1de6c530f3>`__)
- Refactored ``AnimationGroup`` (`#1794 <https://github.com/3b1b/manim/commit/fdeab8ca953b46a902b531febcf132739ca194d4>`__)
- Refactored ``Scene.save_state`` and ``Scene.restore`` (`#1794 <https://github.com/3b1b/manim/commit/97400a5cf26f33ed507ddeeb9b9a7f1a558d4f17>`__)
- Added ``MANIM_COLORS`` (`#1794 <https://github.com/3b1b/manim/commit/5a34ca1fba8b4724eda0caa11b271d74e49f468c>`__)
- Changed default transparent background codec to be prores (`#1794 <https://github.com/3b1b/manim/commit/eae7dbbe6eaf4344374713052aae694e69b62c28>`__)
- Simplified ``Mobject.copy`` (`#1794 <https://github.com/3b1b/manim/commit/1b009a4b035244bd6a0b48bc4dc945fd3b4236ef>`__)
- Refactored ``StringMobject`` and relevant classes (`#1795 <https://github.com/3b1b/manim/pull/1795>`__)
- Updates to copying based on pickle serializing (`#1796 <https://github.com/3b1b/manim/commit/fe3e10acd29a3dd6f8b485c0e36ead819f2d937b>`)
- Removed ``refresh_shader_wrapper_id`` from ``Mobject.become`` (`#1796 <https://github.com/3b1b/manim/commit/1b2460f02a694314897437b9b8755443ed290cc1>`__)
- Refactored ``Scene.embed`` to play nicely with gui interactions (`#1796 <https://github.com/3b1b/manim/commit/c96bdc243e57c17bb75bf12d73ab5bf119cf1464>`__)
- Made ``BlankScene`` inherit from ``InteractiveScene`` (`#1796 <https://github.com/3b1b/manim/commit/2737d9a736885a594dd101ffe07bb82e00069333>`__)
- Updated behavior of -e flag to take in (optional) strings as inputs (`#1796 <https://github.com/3b1b/manim/commit/bb7fa2c8aa68d7c7992517cfde3c7d0e804e13e8>`__)
- Refactor -e flag (`#1796 <https://github.com/3b1b/manim/commit/71c14969dffc8762a43f9646a0c3dc024a51b8df>`__)
- Reverted to original copying scheme (`#1796 <https://github.com/3b1b/manim/commit/59506b89cc73fff3b3736245dd72e61dcebf9a2c>`__)
- Renamed ``Mobject.is_movable`` to ``Mobject.interaction_allowed`` (`#1796 <https://github.com/3b1b/manim/commit/3961005fd708333a3e77856d10e78451faa04075>`__)
- Refreshed static mobjects on undo's and redo's (`#1796 <https://github.com/3b1b/manim/commit/04bca6cafbb1482b8f25cfb34ce83316d8a095c9>`__)
- Factored out event handling (`#1796 <https://github.com/3b1b/manim/commit/754316bf586be5a59839f8bac6fb9fcc47da0efb>`__)
- Removed ``Mobject.interaction_allowed``, in favor of using ``_is_animating`` for multiple purposes (`#1796 <https://github.com/3b1b/manim/commit/f70e91348c8241bcb96470e7881dd92d9d3386d3>`__)
- Moved Command + z and Command + shift + z behavior to Scene (`#1797 <https://github.com/3b1b/manim/commit/0fd8491c515ad23ca308099abe0f39fc38e2dd0e>`__)
- Slight copy refactor (`#1797 <https://github.com/3b1b/manim/commit/902c2c002d6ca03c8080b2bd02ca36f2b8a748b6>`__)
- When scene saves state, have it only copy mobjects which have changed (`#1802 <https://github.com/3b1b/manim/commit/bd2dce08300e5b110c6668bd6763f3918fcdc65e>`__)
- Cleaned up ``Scene.remove`` function (`#1802 <https://github.com/3b1b/manim/commit/6310e2fb6414b01b3fe4be1d4d98525e34356b5e>`__)
- Speed-ups to ``Mobject.copy`` (`#1802 <https://github.com/3b1b/manim/commit/e49e4b8373c13c7a888193aaf61955470acbe5d6>`__)
- Slight speed-up to ``InteractiveScene.gather_selection`` (`#1802 <https://github.com/3b1b/manim/commit/f2b4245c134da577a2854732ec0331768d93ffbe>`__)
- Only leave wait notes in presenter mode (`#1802 <https://github.com/3b1b/manim/commit/42d1f48c60d11caa043d5458e64bfceb31ea203f>`__)
- Refactored ``remove_list_redundancies`` and ``list_update`` (`#1821 <https://github.com/3b1b/manim/commit/b920e7be7b85bc0bb0577e2f71c4320bb97b42d4>`__)
- Match updaters in ``Mobject.become`` (`#1821 <https://github.com/3b1b/manim/commit/0e45b41fea5f22d136f62f4af2e0d892e61a12ce>`__)
- Don't show animation progress bar by default (`#1821 <https://github.com/3b1b/manim/commit/52259af5df619d3f44fbaff4c43402b93d01be2f>`__)
- Handle quitting during scene more gracefully (`#1821 <https://github.com/3b1b/manim/commit/e83ad785caaa1a1456e07b23f207469d335bbc0d>`__)
- Made ``selection_highlight`` refresh with an updater (`#1821 <https://github.com/3b1b/manim/commit/ac08963feff24a1dd2e57f604b44ea0a18ab01f3>`__)
- Refactored ``anims_from_play_args`` to ``prepare_animations`` which deprecating old style ``self.play(mob.method, ...)`` (`#1821 <https://github.com/3b1b/manim/commit/feab79c260498fd7757a304e24c617a4e51ba1df>`__)
- Made presenter mode hold before first play call (`#1821 <https://github.com/3b1b/manim/commit/a9a151d4eff80cc37b9db0fe7117727aac45ba09>`__)
- Update frame on all play calls when skipping animations, so as to provide a rapid preview during scene loading (`#1821 <https://github.com/3b1b/manim/commit/41b811a5e7c03f528d41555217106e62b287ca3b>`__)
- Renamed frame_rate to fps (`#1821 <https://github.com/3b1b/manim/commit/6decb0c32aec21c09007f9a2b91aaa8e642ca848>`__)
- Let default text alignment be decided in default_config (`#1821 <https://github.com/3b1b/manim/commit/83b4aa6b88b6c3defb19f204189681f5afbb219e>`__)
Dependencies
^^^^^^^^^^^^
- Added dependency on ``pyperclip`` (`#1794 <https://github.com/3b1b/manim/commit/e579f4c955844fba415b976c313f64d1bb0376d0>`__)
v1.6.1
------
Fixed bugs
^^^^^^^^^^
- Fixed the bug of ``MTex`` with multi-line tex string (`#1785 <https://github.com/3b1b/manim/pull/1785>`__)
- Fixed ``interpolate`` (`#1788 <https://github.com/3b1b/manim/pull/1788>`__)
- Fixed ``ImageMobject`` (`#1791 <https://github.com/3b1b/manim/pull/1791>`__)
Refactor
^^^^^^^^
- Added ``\overset`` as a special string in ``Tex`` (`#1783 <https://github.com/3b1b/manim/pull/1783>`__)
- Added ``outer_interpolate`` to perform interpolation using ``np.outer`` on arrays (`#1788 <https://github.com/3b1b/manim/pull/1788>`__)
v1.6.0
------
Breaking changes
^^^^^^^^^^^^^^^^
- **Python 3.6 is no longer supported** (`#1736 <https://github.com/3b1b/manim/pull/1736>`__)
Fixed bugs
^^^^^^^^^^
- Fixed the width of riemann rectangles (`#1762 <https://github.com/3b1b/manim/pull/1762>`__)
- Bug fixed in cases where empty array is passed to shader (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/fa38b56fd87f713657c7f778f39dca7faf15baa8>`__)
- Fixed ``AddTextWordByWord`` (`#1772 <https://github.com/3b1b/manim/pull/1772>`__)
- Fixed ``ControlsExample`` (`#1781 <https://github.com/3b1b/manim/pull/1781>`__)
New features
^^^^^^^^^^^^
- Added more functions to ``Text`` (details: `#1751 <https://github.com/3b1b/manim/pull/1751>`__)
- Allowed ``interpolate`` to work on an array of alpha values (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/bf2d9edfe67c7e63ac0107d1d713df7ae7c3fb8f>`__)
- Allowed ``Numberline.number_to_point`` and ``CoordinateSystem.coords_to_point`` to work on an array of inputs (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/c3e13fff0587d3bb007e71923af7eaf9e4926560>`__)
- Added a basic ``Prismify`` to turn a flat ``VMobject`` into something with depth (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/f249da95fb65ed5495cd1db1f12ece7e90061af6>`__)
- Added ``GlowDots``, analogous to ``GlowDot`` (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/e19f35585d817e74b40bc30b1ab7cee84b24da05>`__)
- Added ``TransformMatchingStrings`` which is compatible with ``Text`` and ``MTex`` (`#1772 <https://github.com/3b1b/manim/pull/1772>`__)
- Added support for ``substring`` and ``case_sensitive`` parameters for ``LabelledString.get_parts_by_string`` (`#1780 <https://github.com/3b1b/manim/pull/1780>`__)
Refactor
^^^^^^^^
- Added type hints (`#1736 <https://github.com/3b1b/manim/pull/1736>`__)
- Specifid UTF-8 encoding for tex files (`#1748 <https://github.com/3b1b/manim/pull/1748>`__)
- Refactored ``Text`` with the latest manimpango (`#1751 <https://github.com/3b1b/manim/pull/1751>`__)
- Reorganized getters for ``ParametricCurve`` (`#1757 <https://github.com/3b1b/manim/pull/1757>`__)
- Refactored ``CameraFrame`` to use ``scipy.spatial.transform.Rotation`` (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/625460467fdc01fc1b6621cbb3d2612195daedb9>`__)
- Refactored rotation methods to use ``scipy.spatial.transform.Rotation`` (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/7bf3615bb15cc6d15506d48ac800a23313054c8e>`__)
- Used ``stroke_color`` to init ``Arrow`` (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/c0b7b55e49f06b75ae133b5a810bebc28c212cd6>`__)
- Refactored ``Mobject.set_rgba_array_by_color`` (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/8b1f0a8749d91eeda4b674ed156cbc7f8e1e48a8>`__)
- Made panning more sensitive to mouse movements (`#1764 <https://github.com/3b1b/manim/pull/1764/commits/9d0cc810c5fcb4252990e706c6bf880d571cb1a2>`__)
- Added loading progress for large SVGs (`#1766 <https://github.com/3b1b/manim/pull/1766>`__)
- Added getter/setter of ``field_of_view`` for ``CameraFrame`` (`#1770 <https://github.com/3b1b/manim/pull/1770/commits/0610f331a4f7a126a3aae34f8a2a86eabcb692f4>`__)
- Renamed ``focal_distance`` to ``focal_dist_to_height`` and added getter/setter (`#1770 <https://github.com/3b1b/manim/pull/1770/commits/0610f331a4f7a126a3aae34f8a2a86eabcb692f4>`__)
- Added getter and setter for ``VMobject.joint_type`` (`#1770 <https://github.com/3b1b/manim/pull/1770/commits/2a7a7ac5189a14170f883533137e8a2ae09aac41>`__)
- Refactored ``VCube`` (`#1770 <https://github.com/3b1b/manim/pull/1770/commits/0f8d7ed59751d42d5011813ba5694ecb506082f7>`__)
- Refactored ``Prism`` to receive ``width height depth`` instead of ``dimensions`` (`#1770 <https://github.com/3b1b/manim/pull/1770/commits/0f8d7ed59751d42d5011813ba5694ecb506082f7>`__)
- Refactored ``Text``, ``MarkupText`` and ``MTex`` based on ``LabelledString`` (`#1772 <https://github.com/3b1b/manim/pull/1772>`__)
- Refactored ``LabelledString`` and relevant classes (`#1779 <https://github.com/3b1b/manim/pull/1779>`__)
v1.5.0
------
Fixed bugs
^^^^^^^^^^
- Bug fix for the case of calling ``Write`` on a null object (`#1740 <https://github.com/3b1b/manim/pull/1740>`__)
New features
^^^^^^^^^^^^
- Added ``TransformMatchingMTex`` (`#1725 <https://github.com/3b1b/manim/pull/1725>`__)
- Added ``ImplicitFunction`` (`#1727 <https://github.com/3b1b/manim/pull/1727>`__)
- Added ``Polyline`` (`#1731 <https://github.com/3b1b/manim/pull/1731>`__)
- Allowed ``Mobject.set_points`` to take in an empty list, and added ``Mobject.add_point`` (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/a64259158538eae6043566aaf3d3329ff4ac394b>`__)
- Added ``Scene.refresh_locked_data`` (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/33d2894c167c577a15fdadbaf26488ff1f5bff87>`__)
- Added presenter mode to scenes with ``-p`` option (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/9a9cc8bdacb7541b7cd4a52ad705abc21f3e27fe>`__ and `#1742 <https://github.com/3b1b/manim/pull/1742>`__)
- Allowed for an embed by hitting ``ctrl+shift+e`` during interaction (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/9df12fcb7d8360e51cd7021d6877ca1a5c31835e>`__ and `#1746 <https://github.com/3b1b/manim/pull/1746>`__)
- Added ``Mobject.set_min_width/height/depth`` (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/2798d15591a0375ae6bb9135473e6f5328267323>`__)
- Allowed ``Mobject.match_coord/x/y/z`` to take in a point (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/29a4d3e82ba94c007c996b2d1d0f923941452698>`__)
- Added ``text_config`` to ``DecimalNumber`` (`#1744 <https://github.com/3b1b/manim/pull/1744>`__)
Refactor
^^^^^^^^
- Refactored ``MTex`` (`#1725 <https://github.com/3b1b/manim/pull/1725>`__)
- Refactored ``SVGMobject`` with svgelements (`#1731 <https://github.com/3b1b/manim/pull/1731>`__)
- Made sure ``ParametricCurve`` has at least one point (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/2488b9e866fb1ecb842a27dd9f4956ec167e3dee>`__)
- Set default to no tips on ``Axes`` (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/6c6d387a210756c38feca7d34838aa9ac99bb58a>`__)
- Stopped displaying when writing tex string is happening (`#1739 <https://github.com/3b1b/manim/pull/1739/commits/58e06e8f6b7c5059ff315d51fd0018fec5cfbb05>`__)
- Reorganize inheriting order and refactor SVGMobject (`#1745 <https://github.com/3b1b/manim/pull/1745>`__)
Dependencies
^^^^^^^^^^^^
- Added dependency on ``isosurfaces`` (`#1727 <https://github.com/3b1b/manim/pull/1727>`__)
- Removed dependency on ``argparse`` since it's a built-in module (`#1728 <https://github.com/3b1b/manim/pull/1728>`__)
- Removed dependency on ``pyreadline`` (`#1728 <https://github.com/3b1b/manim/pull/1728>`__)
- Removed dependency on ``cssselect2`` (`#1731 <https://github.com/3b1b/manim/pull/1731>`__)
- Added dependency on ``svgelements`` (`#1731 <https://github.com/3b1b/manim/pull/1731>`__)
v1.4.1
------
Fixed bugs
^^^^^^^^^^
- Temporarily fixed boolean operations' bug (`#1724 <https://github.com/3b1b/manim/pull/1724>`__)
- Import ``Iterable`` from ``collections.abc`` instead of ``collections`` which is deprecated since python 3.9 (`d2e0811 <https://github.com/3b1b/manim/commit/d2e0811285f7908e71a65e664fec88b1af1c6144>`__)
v1.4.0
------
Fixed bugs
^^^^^^^^^^
- Temporarily fixed ``Lightbulb`` (`f1996f8 <https://github.com/3b1b/manim/pull/1697/commits/f1996f8479f9e33d626b3b66e9eb6995ce231d86>`__)
- Fixed some bugs of ``SVGMobject`` (`#1712 <https://github.com/3b1b/manim/pull/1712>`__)
- Fixed some bugs of SVG path string parser (`#1717 <https://github.com/3b1b/manim/pull/1717>`__)
- Fixed some bugs of ``MTex`` (`#1720 <https://github.com/3b1b/manim/pull/1720>`__)
New features
^^^^^^^^^^^^
- Added option to add ticks on x-axis in ``BarChart`` (`#1694 <https://github.com/3b1b/manim/pull/1694>`__)
- Added ``lable_buff`` config parameter for ``Brace`` (`#1704 <https://github.com/3b1b/manim/pull/1704>`__)
- Added support for ``rotate skewX skewY`` transform in SVG (`#1712 <https://github.com/3b1b/manim/pull/1712>`__)
- Added style support to ``SVGMobject`` (`#1717 <https://github.com/3b1b/manim/pull/1717>`__)
- Added parser to <style> element of SVG (`#1719 <https://github.com/3b1b/manim/pull/1719>`__)
- Added support for <line> element in ``SVGMobject`` (`#1719 <https://github.com/3b1b/manim/pull/1719>`__)
Refactor
^^^^^^^^
- Used ``FFMPEG_BIN`` instead of ``"ffmpeg"`` for sound incorporation (`5aa8d15 <https://github.com/3b1b/manim/pull/1697/commits/5aa8d15d85797f68a8f169ca69fd90d441a3abbe>`__)
- Decorated ``CoordinateSystem.get_axes`` and ``.get_all_ranges`` as abstract method (`#1709 <https://github.com/3b1b/manim/pull/1709>`__)
- Refactored SVG path string parser (`#1712 <https://github.com/3b1b/manim/pull/1712>`__)
- Allowed ``Mobject.scale`` to receive iterable ``scale_factor`` (`#1712 <https://github.com/3b1b/manim/pull/1712>`__)
- Refactored ``MTex`` (`#1716 <https://github.com/3b1b/manim/pull/1716>`__)
- Improved config helper (``manimgl --config``) (`#1721 <https://github.com/3b1b/manim/pull/1721>`__)
- Refactored ``MTex`` (`#1723 <https://github.com/3b1b/manim/pull/1723>`__)
Dependencies
^^^^^^^^^^^^
- Added dependency on python package `cssselect2 <https://github.com/Kozea/cssselect2>`__ (`#1719 <https://github.com/3b1b/manim/pull/1719>`__)
v1.3.0
------
Fixed bugs
^^^^^^^^^^
- Fixed ``Mobject.stretch_to_fit_depth`` (`#1653 <https://github.com/3b1b/manim/pull/1653>`__)
- Fixed the bug of rotating camera (`#1655 <https://github.com/3b1b/manim/pull/1655>`__)
- Fixed ``SurfaceMesh`` to be evenly spaced (`c73d507 <https://github.com/3b1b/manim/pull/1688/commits/c73d507c76af5c8602d4118bc7538ba04c03ebae>`__)
- Fixed ``angle_between_vectors`` add ``rotation_between_vectors`` (`82bd02d <https://github.com/3b1b/manim/pull/1688/commits/82bd02d21fbd89b71baa21e077e143f440df9014>`__)
- Fixed ``VMobject.fade`` (`a717314 <https://github.com/3b1b/manim/pull/1688/commits/a7173142bf93fd309def0cc10f3c56f5e6972332>`__)
- Fixed ``angle_between_vectors`` (`fbc329d <https://github.com/3b1b/manim/pull/1688/commits/fbc329d7ce3b11821d47adf6052d932f7eff724a>`__)
- Fixed bug in ``ShowSubmobjectsOneByOne`` (`bcd0990 <https://github.com/3b1b/manim/pull/1688/commits/bcd09906bea5eaaa5352e7bee8f3153f434cf606>`__)
- Fixed bug in ``TransformMatchingParts`` (`7023548 <https://github.com/3b1b/manim/pull/1691/commits/7023548ec62c4adb2f371aab6a8c7f62deb7c33c>`__)
New features
^^^^^^^^^^^^
- Added CLI flag ``--log-level`` to specify log level (`e10f850 <https://github.com/3b1b/manim/commit/e10f850d0d9f971931cc85d44befe67dc842af6d>`__)
- Added operations (``+`` and ``*``) for ``Mobject`` (`#1667 <https://github.com/3b1b/manim/pull/1667>`__)
- Added 4 boolean operations for ``VMobject`` in ``manimlib/mobject/boolean_ops.py`` (`#1675 <https://github.com/3b1b/manim/pull/1675>`__)
- ``Union(*vmobjects, **kwargs)``
- ``Difference(subject, clip, **kwargs)``
- ``Intersection(*vmobjects, **kwargs)``
- ``Exclusion(*vmobjects, **kwargs)``
- Added reflectiveness (`81c3ae3 <https://github.com/3b1b/manim/pull/1688/commits/81c3ae30372e288dc772633dbd17def6e603753e>`__)
- Enabled ``glow_factor`` on ``DotCloud`` (`2c7689e <https://github.com/3b1b/manim/pull/1688/commits/2c7689ed9e81229ce87c648f97f26267956c0bc9>`__)
- Added option ``-e`` to insert embed line from the command line (`d065e19 <https://github.com/3b1b/manim/pull/1688/commits/d065e1973d1d6ebd2bece81ce4bdf0c2fff7c772>`__)
- Improved ``point_from_proportion`` to account for arc length (`0e78027 <https://github.com/3b1b/manim/pull/1688/commits/0e78027186a976f7e5fa8d586f586bf6e6baab8d>`__)
- Added shortcut ``set_backstroke`` for setting black background stroke (`781a993 <https://github.com/3b1b/manim/pull/1688/commits/781a9934fda6ba11f22ba32e8ccddcb3ba78592e>`__)
- Added ``Suface.always_sort_to_camera`` (`0b898a5 <https://github.com/3b1b/manim/pull/1688/commits/0b898a5594203668ed9cad38b490ab49ba233bd4>`__)
- Added getter methods for specific euler angles (`e899604 <https://github.com/3b1b/manim/pull/1688/commits/e899604a2d05f78202fcb3b9824ec34647237eae>`__)
- Hade ``rotation_between_vectors`` handle identical/similar vectors (`407c53f <https://github.com/3b1b/manim/pull/1688/commits/407c53f97c061bfd8a53beacd88af4c786f9e9ee>`__)
- Added ``Mobject.insert_submobject`` method (`49743da <https://github.com/3b1b/manim/pull/1688/commits/49743daf3244bfa11a427040bdde8e2bb79589e8>`__)
- Created single progress display for full scene render (`9dd1f47 <https://github.com/3b1b/manim/pull/1688/commits/9dd1f47dabca1580d6102e34e44574b0cba556e7>`__)
- Added ``Circle.get_radius`` (`264f7b1 <https://github.com/3b1b/manim/pull/1691/commits/264f7b11726e9e736f0fe472f66e38539f74e848>`__)
- Added ``Dodecahedron`` (`83841ae <https://github.com/3b1b/manim/pull/1691/commits/83841ae41568a9c9dff44cd163106c19a74ac281>`__)
- Added ``GlowDot`` (`a1d5147 <https://github.com/3b1b/manim/pull/1691/commits/a1d51474ea1ce3b7aa3efbe4c5e221be70ee2f5b>`__)
- Added ``MTex`` , see `#1678 <https://github.com/3b1b/manim/pull/1678>`__ for details (`#1678 <https://github.com/3b1b/manim/pull/1678>`__)
Refactor
^^^^^^^^
- Refactored support for command ``A`` in path of SVG (`#1662 <https://github.com/3b1b/manim/pull/1662>`__)
- Refactored ``SingleStringTex.balance_braces`` (`#1662 <https://github.com/3b1b/manim/pull/1662>`__)
- Slight tweaks to how saturation_factor works on newton-fractal (`8b454fb <https://github.com/3b1b/manim/pull/1688/commits/8b454fbe9335a7011e947093230b07a74ba9c653>`__)
- Made it possible to set full screen preview as a default (`317a5d6 <https://github.com/3b1b/manim/pull/1688/commits/317a5d6226475b6b54a78db7116c373ef84ea923>`__)
- Used ``quick_point_from_proportion`` for graph points (`e764da3 <https://github.com/3b1b/manim/pull/1688/commits/e764da3c3adc5ae2a4ce877b340d2b6abcddc2fc>`__)
- Made sure ``Line.set_length`` returns self (`d2182b9 <https://github.com/3b1b/manim/pull/1688/commits/d2182b9112300558b6c074cefd685f97c10b3898>`__)
- Better align ``SurfaceMesh`` to the corresponding surface polygons (`eea3c6b <https://github.com/3b1b/manim/pull/1688/commits/eea3c6b29438f9e9325329c4355e76b9f635e97a>`__)
- Match ``fix_in_frame`` status for ``FlashAround`` mobject (`ee1594a <https://github.com/3b1b/manim/pull/1688/commits/ee1594a3cb7a79b8fc361e4c4397a88c7d20c7e3>`__)
- Made sure ``Mobject.is_fixed_in_frame`` stays updated with uniforms (`ba23fbe <https://github.com/3b1b/manim/pull/1688/commits/ba23fbe71e4a038201cd7df1d200514ed1c13bc2>`__)
- Made sure ``skip_animations`` and ``start_at_animation_number`` play well together (`98b0d26 <https://github.com/3b1b/manim/pull/1691/commits/98b0d266d2475926a606331923cca3dc1dea97ad>`__)
- Updated progress display for full scene render (`f8e6e7d <https://github.com/3b1b/manim/pull/1691/commits/f8e6e7df3ceb6f3d845ced4b690a85b35e0b8d00>`__)
- ``VectorizedPoint`` should call ``__init__`` for both super classes (`8f1dfab <https://github.com/3b1b/manim/pull/1691/commits/8f1dfabff04a8456f5c4df75b0f97d50b2755003>`__)
- Used array copy when checking need for refreshing triangulation (`758f329 <https://github.com/3b1b/manim/pull/1691/commits/758f329a06a0c198b27a48c577575d94554305bf>`__)
Dependencies
^^^^^^^^^^^^
- Added dependency on python package `skia-pathops <https://github.com/fonttools/skia-pathops>`__ (`#1675 <https://github.com/3b1b/manim/pull/1675>`__)
v1.2.0
------
Fixed bugs
^^^^^^^^^^
- Fixed ``put_start_and_end_on`` in 3D (`#1592 <https://github.com/3b1b/manim/pull/1592>`__)
- Fixed ``DecimalNumber``'s scaling issue (`#1601 <https://github.com/3b1b/manim/pull/1601>`__)
- Fixed bug with common range array used for all coordinate systems (`56df154 <https://github.com/3b1b/manim/commit/56df15453f3e3837ed731581e52a1d76d5692077>`__)
- Fixed ``CoordinateSystem`` init bug (`8645894 <https://github.com/3b1b/manim/commit/86458942550c639a241267d04d57d0e909fcf252>`__)
- Fixed bug for single-valued ``ValueTracker`` (`0dc096b <https://github.com/3b1b/manim/commit/0dc096bf576ea900b351e6f4a80c13a77676f89b>`__)
- Fixed bug with SVG rectangles (`54ad355 <https://github.com/3b1b/manim/commit/54ad3550ef0c0e2fda46b26700a43fa8cde0973f>`__)
- Fixed ``DotCloud.set_radii`` (`d45ea28 <https://github.com/3b1b/manim/commit/d45ea28dc1d92ab9c639a047c00c151382eb0131>`__)
- Temporarily fixed bug for ``PMobject`` array resizing (`b543cc0 <https://github.com/3b1b/manim/commit/b543cc0e32d45399ee81638b6d4fb631437664cd>`__)
- Fixed ``match_style`` (`5f878a2 <https://github.com/3b1b/manim/commit/5f878a2c1aa531b7682bd048468c72d2835c7fe5>`__)
- Fixed negative ``path_arc`` case (`719c81d <https://github.com/3b1b/manim/commit/719c81d72b00dcf49f148d7c146774b22e0fe348>`__)
- Fixed bug with ``CoordinateSystem.get_lines_parallel_to_axis`` (`c726eb7 <https://github.com/3b1b/manim/commit/c726eb7a180b669ee81a18555112de26a8aff6d6>`__)
- Fixed ``ComplexPlane`` -i display bug (`7732d2f <https://github.com/3b1b/manim/commit/7732d2f0ee10449c5731499396d4911c03e89648>`__)
New features
^^^^^^^^^^^^
- Supported the elliptical arc command ``A`` for ``SVGMobject`` (`#1598 <https://github.com/3b1b/manim/pull/1598>`__)
- Added ``FlashyFadeIn`` (`#1607 <https://github.com/3b1b/manim/pull/1607>`__)
- Save triangulation (`#1607 <https://github.com/3b1b/manim/pull/1607>`__)
- Added new ``Code`` mobject (`#1625 <https://github.com/3b1b/manim/pull/1625>`__)
- Add warnings and use rich to display log (`#1637 <https://github.com/3b1b/manim/pull/1637>`__)
- Added ``VCube`` (`bd356da <https://github.com/3b1b/manim/commit/bd356daa99bfe3134fcb192a5f72e0d76d853801>`__)
- Supported ``ValueTracker`` to track vectors (`6d72893 <https://github.com/3b1b/manim/commit/6d7289338234acc6658b9377c0f0084aa1fa7119>`__)
- Added ``set_max_width``, ``set_max_height``, ``set_max_depth`` to ``Mobject`` (`3bb8f3f <https://github.com/3b1b/manim/commit/3bb8f3f0422a5dfba0da6ef122dc0c01f31aff03>`__)
- Added ``TracgTail`` (`a35dd5a <https://github.com/3b1b/manim/commit/a35dd5a3cbdeffa3891d5aa5f80287c18dba2f7f>`__)
- Added ``Scene.point_to_mobject`` (`acba13f <https://github.com/3b1b/manim/commit/acba13f4991b78d54c0bf93cce7ca3b351c25476>`__)
- Added poly_fractal shader (`f84b8a6 <https://github.com/3b1b/manim/commit/f84b8a66fe9e8b3872e5c716c5c240c14bb555ee>`__)
- Added kwargs to ``TipableVMobject.set_length`` (`b24ba19 <https://github.com/3b1b/manim/commit/b24ba19dec48ba4e38acbde8eec6d3a308b6ab83>`__)
- Added ``Mobject.replicate`` (`17c2772 <https://github.com/3b1b/manim/commit/17c2772b84abf6392a4170030e36e981de4737d0>`__)
- Added mandelbrot_fractal shader (`33fa76d <https://github.com/3b1b/manim/commit/33fa76dfac36e70bb5fad69dc6a336800c6dacce>`__)
- Saved state before each embed (`f22a341 <https://github.com/3b1b/manim/commit/f22a341e8411eae9331d4dd976b5e15bc6db08d9>`__)
- Allowed releasing of Textures (`e10a752 <https://github.com/3b1b/manim/commit/e10a752c0001e8981038faa03be4de2603d3565f>`__)
- Consolidated and renamed newton_fractal shader (`14fbed7 <https://github.com/3b1b/manim/commit/14fbed76da4b493191136caebb8a955e2d41265b>`__)
- Hade ``ImageMoject`` remember the filepath to the Image (`6cdbe0d <https://github.com/3b1b/manim/commit/6cdbe0d67a11ab14a6d84840a114ae6d3af10168>`__)
Refactor
^^^^^^^^
- Changed back to simpler ``Mobject.scale`` implementation (`#1601 <https://github.com/3b1b/manim/pull/1601>`__)
- Simplified ``Square`` (`b667db2 <https://github.com/3b1b/manim/commit/b667db2d311a11cbbca2a6ff511d2c3cf1675486>`__)
- Removed unused parameter ``triangulation_locked`` (`40290ad <https://github.com/3b1b/manim/commit/40290ada8343f10901fa9151cbdf84689667786d>`__)
- Reimplemented ``Arrow`` (`8647a64 <https://github.com/3b1b/manim/commit/8647a6429dd0c52cba14e971b8c09194a93cfd87>`__)
- Used ``make_approximately_smooth`` for ``set_points_smoothly`` by default (`d8378d8 <https://github.com/3b1b/manim/commit/d8378d8157040cd797cc47ef9576beffd8607863>`__)
- Refactored to call ``_handle_scale_side_effects`` after scaling takes place (`7b4199c <https://github.com/3b1b/manim/commit/7b4199c674e291f1b84678828b63b6bd4fcc6b17>`__)
- Refactored to only call ``throw_error_if_no_points`` once for ``get_start_and_end`` (`7356a36 <https://github.com/3b1b/manim/commit/7356a36fa70a8279b43ae74e247cbd43b2bfd411>`__)
- Made sure framerate is 30 for previewed scenes (`0787c4f <https://github.com/3b1b/manim/commit/0787c4f36270a6560b50ce3e07b30b0ec5f2ba3e>`__)
- Pushed ``pixel_coords_to_space_coords`` to ``Window`` (`c635f19 <https://github.com/3b1b/manim/commit/c635f19f2a33e916509e53ded46f55e2afa8f5f2>`__)
- Refactored to pass tuples and not arrays to uniforms (`d5a88d0 <https://github.com/3b1b/manim/commit/d5a88d0fa457cfcf4cb9db417a098c37c95c7051>`__)
- Refactored to copy uniform arrays in ``Mobject.copy`` (`9483f26 <https://github.com/3b1b/manim/commit/9483f26a3b056de0e34f27acabd1a946f1adbdf9>`__)
- Added ``bounding_box`` as exceptional key to point_cloud mobject (`ed1fc4d <https://github.com/3b1b/manim/commit/ed1fc4d5f94467d602a568466281ca2d0368b506>`__)
- Made sure stroke width is always a float (`329d2c6 <https://github.com/3b1b/manim/commit/329d2c6eaec3d88bfb754b555575a3ea7c97a7e0>`__)
v1.1.0
-------
Fixed bugs
^^^^^^^^^^
- Fixed the bug of :func:`~manimlib.utils.iterables.resize_with_interpolation` in the case of ``length=0``
- Fixed the bug of ``__init__`` in :class:`~manimlib.mobject.geometry.Elbow`
- If chosen monitor is not available, choose one that does exist
- Make sure mobject data gets unlocked after animations
- Fixed a bug for off-center vector fields
- Had ``Mobject.match_points`` return self
- Fixed chaining animation in example scenes
- Fixed the default color of tip
- Fixed a typo in ``ShowPassingFlashWithThinningStrokeWidth``
- Fixed the default size of ``Text``
- Fixed a missing import line in ``mobject.py``
- Fixed the bug in ControlsExample
- Make sure frame is added to the scene when initialization
- Fixed zooming directions
- Rewrote ``earclip_triangulation`` to fix triangulation
- Allowed sound_file_name to be taken in without extensions
New features
^^^^^^^^^^^^
- Added :class:`~manimlib.animation.indication.VShowPassingFlash`
- Added ``COLORMAP_3B1B``
- Added some methods to coordinate system to access all axes ranges
- :meth:`~manimlib.mobject.coordinate_systems.CoordinateSystem.get_origin`
- :meth:`~manimlib.mobject.coordinate_systems.CoordinateSystem.get_all_ranges`
- Added :meth:`~manimlib.mobject.mobject.Mobject.set_color_by_rgba_func`
- Updated :class:`~manimlib.mobject.vector_field.VectorField` and :class:`~manimlib.mobject.vector_field.StreamLines`
- Allow ``3b1b_colormap`` as an option for :func:`~manimlib.utils.color.get_colormap_list`
- Return ``stroke_width`` as 1d array
- Added :meth:`~manimlib.mobject.svg.text_mobject.Text.get_parts_by_text`
- Use Text not TexText for Brace
- Update to Cross to make it default to variable stroke width
- Added :class:`~manimlib.animation.indication.FlashAround` and :class:`~manimlib.animation.indication.FlashUnder`
- Allowed configuration in ``Brace.get_text``
- Added :meth:`~manimlib.camera.camera.CameraFrame.reorient` for quicker changes to frame angle
- Added ``units`` to :meth:`~manimlib.camera.camera.CameraFrame.set_euler_angles`
- Allowed any ``VMobject`` to be passed into ``TransformMatchingTex``
- Removed double brace convention in ``Tex`` and ``TexText``
- Added support for debugger launch
- Added CLI flag ``--config_file`` to load configuration file manually
- Added ``tip_style`` to ``tip_config``
- Added ``MarkupText``
- Take in ``u_range`` and ``v_range`` as arguments to ``ParametricSurface``
- Added ``TrueDot``
================================================
FILE: docs/source/development/contributing.rst
================================================
Contributing
============
Accept any contribution you make :)
- **Contribute to the manim source code**:
Please fork to your own repository and make changes, submit a pull request, and fill in
the motivation for the change following the instructions in the template. We will check
your pull request in detail (this usually takes a while, please be patient)
- **Contribute to the documentation**:
Also submit a pull request and write down the main changes.
- **If you find a bug in the code**:
Please open an issue and fill in the found problem and your environment according
to the template. (But please note that if you think this problem is just a problem
of yourself, rather than a problem of source code, it is recommended that you ask a
question in the `Q&A category <https://github.com/3b1b/manim/discussions/categories/q-a>`_
of the discussion page)
- **You are welcome to share the content you made with manim**:
Post it in the `show and tell category <https://github.com/3b1b/manim/discussions/categories/show-and-tell>`_
of the discussion page.
- **You are also welcome to share some of your suggestions and ideas**:
Post them in the `ideas category <https://github.com/3b1b/manim/discussions/categories/ideas>`_
of the discussion page.
How to build this documentation
-------------------------------
- Clone the 3b1b/manim repository
.. code-block:: sh
git clone https://github.com/3b1b/manim.git
# or your own repo
# git clone https://github.com/<your user name>/manim.git
cd manim
- Install python package dependencies
.. code-block:: sh
pip install -r docs/requirements.txt
- Go to the ``docs/`` folder and build
.. code-block:: sh
cd docs/
make html
- The output document is located in ``docs/build/html/``
================================================
FILE: docs/source/documentation/animation/index.rst
================================================
Animation (TODO)
================
================================================
FILE: docs/source/documentation/camera/index.rst
================================================
Camera (TODO)
=============
================================================
FILE: docs/source/documentation/constants.rst
================================================
constants
=========
The ``constants.py`` in the ``manimlib`` folder defines the constants
needed when running manim. Some constants are not explained here because
they are only used inside manim.
Frame and pixel shape
---------------------
These values will be determined based on the ``camera`` configuration in default_config.yml or custom_config.yml
.. code-block:: python
ASPECT_RATIO
FRAME_HEIGHT
FRAME_WIDTH
FRAME_Y_RADIUS
FRAME_X_RADIUS
DEFAULT_PIXEL_HEIGHT
DEFAULT_PIXEL_WIDTH
DEFAULT_FPS
Buffs
-----
These values will be determined based on the ``size`` configuration in default_config.yml or custom_config.yml
.. code-block:: python
SMALL_BUFF
MED_SMALL_BUFF
MED_LARGE_BUFF
LARGE_BUFF
DEFAULT_MOBJECT_TO_EDGE_BUFF
DEFAULT_MOBJECT_TO_MOBJECT_BUFF
Coordinates
-----------
manim uses three-dimensional coordinates and uses the type of ``ndarray``
.. code-block:: python
ORIGIN = np.array((0., 0., 0.))
UP = np.array((0., 1., 0.))
DOWN = np.array((0., -1., 0.))
RIGHT = np.array((1., 0., 0.))
LEFT = np.array((-1., 0., 0.))
IN = np.array((0., 0., -1.))
OUT = np.array((0., 0., 1.))
X_AXIS = np.array((1., 0., 0.))
Y_AXIS = np.array((0., 1., 0.))
Z_AXIS = np.array((0., 0., 1.))
# Useful abbreviations for diagonals
UL = UP + LEFT
UR = UP + RIGHT
DL = DOWN + LEFT
DR = DOWN + RIGHT
TOP = FRAME_Y_RADIUS * UP
BOTTOM = FRAME_Y_RADIUS * DOWN
LEFT_SIDE = FRAME_X_RADIUS * LEFT
RIGHT_SIDE = FRAME_X_RADIUS * RIGHT
Mathematical constant
---------------------
.. code-block:: python
PI = np.pi
TAU = 2 * PI
DEG = TAU / 360
Text
----
.. code-block:: python
NORMAL = "NORMAL"
ITALIC = "ITALIC"
OBLIQUE = "OBLIQUE"
BOLD = "BOLD"
Colours
-------
Color constants are determined based on the ``color`` configuration in default_config.yml or custom_config.yml
Here are the preview of default colours. (Modified from
`elteoremadebeethoven <https://elteoremadebeethoven.github.io/manim_3feb_docs.github.io/html/_static/colors/colors.html>`_)
.. raw:: html
<div style="float: left;">
<h3>BLUE</h3>
<div class="colors BLUE_E"><p class="color-text">BLUE_E</p></div>
<div class="colors BLUE_D"><p class="color-text">BLUE_D</p></div>
<div class="colors BLUE_C"><p class="color-text">BLUE_C</p></div>
<div class="colors BLUE_B"><p class="color-text">BLUE_B</p></div>
<div class="colors BLUE_A"><p class="color-text">BLUE_A</p></div>
</div>
<div style="float: left;">
<h3>TEAL</h3>
<div class="colors TEAL_E"><p class="color-text">TEAL_E</p></div>
<div class="colors TEAL_D"><p class="color-text">TEAL_D</p></div>
<div class="colors TEAL_C"><p class="color-text">TEAL_C</p></div>
<div class="colors TEAL_B"><p class="color-text">TEAL_B</p></div>
<div class="colors TEAL_A"><p class="color-text">TEAL_A</p></div>
</div>
<div style="float: left;">
<h3>GREEN</h3>
<div class="colors GREEN_E"><p class="color-text">GREEN_E</p></div>
<div class="colors GREEN_D"><p class="color-text">GREEN_D</p></div>
<div class="colors GREEN_C"><p class="color-text">GREEN_C</p></div>
<div class="colors GREEN_B"><p class="color-text">GREEN_B</p></div>
<div class="colors GREEN_A"><p class="color-text">GREEN_A</p></div>
</div>
<div style="float: left;">
<h3>YELLOW</h3>
<div class="colors YELLOW_E"><p class="color-text">YELLOW_E</p></div>
<div class="colors YELLOW_D"><p class="color-text">YELLOW_D</p></div>
<div class="colors YELLOW_C"><p class="color-text">YELLOW_C</p></div>
<div class="colors YELLOW_B"><p class="color-text">YELLOW_B</p></div>
<div class="colors YELLOW_A"><p class="color-text">YELLOW_A</p></div>
</div>
<div style="float: left;">
<h3>GOLD</h3>
<div class="colors GOLD_E"><p class="color-text">GOLD_E</p></div>
<div class="colors GOLD_D"><p class="color-text">GOLD_D</p></div>
<div class="colors GOLD_C"><p class="color-text">GOLD_C</p></div>
<div class="colors GOLD_B"><p class="color-text">GOLD_B</p></div>
<div class="colors GOLD_A"><p class="color-text">GOLD_A</p></div>
</div>
<div style="float: left;">
<h3>RED</h3>
<div class="colors RED_E"><p class="color-text">RED_E</p></div>
<div class="colors RED_D"><p class="color-text">RED_D</p></div>
<div class="colors RED_C"><p class="color-text">RED_C</p></div>
<div class="colors RED_B"><p class="color-text">RED_B</p></div>
<div class="colors RED_A"><p class="color-text">RED_A</p></div>
</div>
<div style="float: left;">
<h3>MAROON</h3>
<div class="colors MAROON_E"><p class="color-text">MAROON_E</p></div>
<div class="colors MAROON_D"><p class="color-text">MAROON_D</p></div>
<div class="colors MAROON_C"><p class="color-text">MAROON_C</p></div>
<div class="colors MAROON_B"><p class="color-text">MAROON_B</p></div>
<div class="colors MAROON_A"><p class="color-text">MAROON_A</p></div>
</div>
<div style="float: left;">
<h3>PURPLE</h3>
<div class="colors PURPLE_E"><p class="color-text">PURPLE_E</p></div>
<div class="colors PURPLE_D"><p class="color-text">PURPLE_D</p></div>
<div class="colors PURPLE_C"><p class="color-text">PURPLE_C</p></div>
<div class="colors PURPLE_B"><p class="color-text">PURPLE_B</p></div>
<div class="colors PURPLE_A"><p class="color-text">PURPLE_A</p></div>
</div>
<div style="float: left;">
<h3>GREY</h3>
<div class="colors GREY_E"><p class="color-text">GREY_E</p></div>
<div class="colors GREY_D"><p class="color-text">GREY_D</p></div>
<div class="colors GREY_C"><p class="color-text">GREY_C</p></div>
<div class="colors GREY_B"><p class="color-text">GREY_B</p></div>
<div class="colors GREY_A"><p class="color-text">GREY_A</p></div>
</div>
<div style="float: left;">
<h3>Others</h3>
<div class="colors WHITE"><p class="color-text" style="color: BLACK">WHITE</p></div>
<div class="colors BLACK"><p class="color-text">BLACK</p></div>
<div class="colors GREY_BROWN"><p class="color-text-small">GREY_BROWN</p></div>
<div class="colors DARK_BROWN"><p class="color-text-small">DARK_BROWN</p></div>
<div class="colors LIGHT_BROWN"><p class="color-text-small">LIGHT_BROWN</p></div>
<div class="colors PINK"><p class="color-text">PINK</p></div>
<div class="colors LIGHT_PINK"><p class="color-text-small">LIGHT_PINK</p></div>
<div class="colors GREEN_SCREEN"><p class="color-text-small">GREEN_SCREEN</p></div>
<div class="colors ORANGE"><p class="color-text">ORANGE</p></div>
</div>
================================================
FILE: docs/source/documentation/custom_config.rst
================================================
custom_config
==============
``directories``
---------------
- ``mirror_module_path``
(``True`` or ``False``) Whether to create a folder named the name of the
running file under the ``output`` path, and save the output (``images/``
or ``videos/``) in it.
- ``base``
The root directory that will hold files, such as video files manim renders,
or image resources that it pulls from
- ``output``
Output file path, the videos will be saved in the ``videos/`` folder under it,
and the pictures will be saved in the ``images/`` folder under it.
For example, if you set ``output`` to ``"/.../manim/output"`` and
``mirror_module_path`` to ``False``, then you exported ``Scene1`` in the code
file and saved the last frame, then the final directory structure will be like:
.. code-block:: text
:emphasize-lines: 9, 11
manim/
├── manimlib/
│ ├── animation/
│ ├── ...
│ ├── default_config.yml
│ └── window.py
├── output/
│ ├── images
│ │ └── Scene1.png
│ └── videos
│ └── Scene1.mp4
├── code.py
└── custom_config.yml
But if you set ``mirror_module_path`` to ``True``, the directory structure will be:
.. code-block:: text
:emphasize-lines: 8
manim/
├── manimlib/
│ ├── animation/
│ ├── ...
│ ├── default_config.yml
│ └── window.py
├── output/
│ └── code/
│ ├── images
│ │ └── Scene1.png
│ └── videos
│ └── Scene1.mp4
├── code.py
└── custom_config.yml
- ``raster_images``
The directory for storing raster images to be used in the code (including
``.jpg``, ``.jpeg``, ``.png`` and ``.gif``), which will be read by ``ImageMobject``.
- ``vector_images``
The directory for storing vector images to be used in the code (including
``.svg`` and ``.xdv``), which will be read by ``SVGMobject``.
- ``sounds``
The directory for storing sound files to be used in ``Scene.add_sound()`` (
including ``.wav`` and ``.mp3``).
- ``cache``
The directory for storing temporarily generated cache files, including
``Tex`` cache, ``Text`` cache and storage of object points.
``window``
----------
- ``position_string``
The relative position of the playback window on the display (two characters,
the first character means upper(U) / middle(O) / lower(D), the second character
means left(L) / middle(O) / right(R)).
- ``monitor_index``
If using multiple monitors, which one should the window show up in?
- ``full_screen``
Should the preview window be full screen. If not, it defaults to half the screen
- ``position``
This is an option to more manually set the default window position, in pixel
coordinates, e.g. (500, 300)
- ``size``
Option to more manually set the default window size, in pixel coordinates,
e.g. (1920, 1080)
``camera``
----------
- ``resolution``
Resolution to render at, e.g. (1920, 1080)
- ``background_color``
Default background color of scenes
- ``fps``
Framerate
- ``background_opacity``
Opacity of the background
``file_writer``
---------------
Configuration specifying how files are written, e.g. what ffmpeg parameters to use
``scene``
-------
Some default configuration for the Scene class
``text``
-------
- ``font``
Default font of Text
- ``text_alignment``
Default text alignment for LaTeX
``tex``
-------
- ``template``
Which configuration from the manimlib/tex_template.yml file should be used
to determine the latex compiler to use, and what preamble to include for
rendering tex.
``sizes``
---------
Valuess for various constants used in manimm to specify distances, like the height
of the frame, the value of SMALL_BUFF, LARGE_BUFF, etc.
``colors``
----------
Color pallete to use, determining values of color constants like RED, BLUE_E, TEAL, etc.
``loglevel``
------------
Can be DEBUG / INFO / WARNING / ERROR / CRITICAL
``universal_import_line``
-------------------------
Import line that need to execute when entering interactive mode directly.
``ignore_manimlib_modules_on_reload``
-------------------------------------
When calling ``reload`` during the interactive mode, imported modules are
by default reloaded, in case the user writing a scene which pulls from various
other files they have written. By default, modules withinn the manim library will
be ignored, but one developing manim may want to set this to be False so that
edits to the library are reloaded as well.
================================================
FILE: docs/source/documentation/mobject/index.rst
================================================
Mobject (TODO)
==============
================================================
FILE: docs/source/documentation/scene/index.rst
================================================
Scene (TODO)
============
================================================
FILE: docs/source/documentation/shaders/index.rst
================================================
Shaders (TODO)
==============
================================================
FILE: docs/source/documentation/utils/index.rst
================================================
Utils (TODO)
============
================================================
FILE: docs/source/getting_started/configuration.rst
================================================
CLI flags and configuration
===========================
Command Line Interface
----------------------
To run manim, you need to enter the directory at the same level as ``manimlib/``
and enter the command in the following format into terminal:
.. code-block:: sh
manimgl <code>.py <Scene> <flags>
# or
manim-render <code>.py <Scene> <flags>
- ``<code>.py`` : The python file you wrote. Needs to be at the same level as ``manimlib/``, otherwise you need to use an absolute path or a relative path.
- ``<Scene>`` : The scene you want to render here. If it is not written or written incorrectly, it will list all for you to choose. And if there is only one ``Scene`` in the file, this class will be rendered directly.
- ``<flags>`` : CLI flags.
Some useful flags
^^^^^^^^^^^^^^^^^
- ``-w`` to write the scene to a file.
- ``-o`` to write the scene to a file and open the result.
- ``-s`` to skip to the end and just show the final frame.
- ``-so`` will save the final frame to an image and show it.
- ``-n <number>`` to skip ahead to the ``n``\ ’th animation of a scene.
- ``-f`` to make the playback window fullscreen.
All supported flags
^^^^^^^^^^^^^^^^^^^
========================================================== ====== =====================================================================================================================================================================================================
flag abbr function
========================================================== ====== =====================================================================================================================================================================================================
``--help`` ``-h`` Show the help message and exit
``--version`` ``-v`` Display the version of manimgl
``--write_file`` ``-w`` Render the scene as a movie file
``--skip_animations`` ``-s`` Skip to the last frame
``--low_quality`` ``-l`` Render at a low quality (for faster rendering)
``--medium_quality`` ``-m`` Render at a medium quality
``--hd`` Render at a 1080p quality
``--uhd`` Render at a 4k quality
``--full_screen`` ``-f`` Show window in full screen
``--presenter_mode`` ``-p`` Scene will stay paused during wait calls until space bar or right arrow is hit, like a slide show
``--save_pngs`` ``-g`` Save each frame as a png
``--gif`` ``-i`` Save the video as gif
``--transparent`` ``-t`` Render to a movie file with an alpha channel
``--quiet`` ``-q``
``--write_all`` ``-a`` Write all the scenes from a file
``--open`` ``-o`` Automatically open the saved file once its done
``--finder`` Show the output file in finder
``--config`` Guide for automatic configuration
``--file_name FILE_NAME`` Name for the movie or image file
``--start_at_animation_number START_AT_ANIMATION_NUMBER`` ``-n`` Start rendering not from the first animation, but from another, specified by its index. If you passing two comma separated values, e.g. "3,6", it will end the rendering at the second value.
``--embed [EMBED]`` ``-e`` Creates a new file where the line ``self.embed`` is inserted into the Scenes construct method. If a string is passed in, the line will be inserted below the last line of code including that string.
``--resolution RESOLUTION`` ``-r`` Resolution, passed as "WxH", e.g. "1920x1080"
``--fps FPS`` Frame rate, as an integer
``--color COLOR`` ``-c`` Background color
``--leave_progress_bars`` Leave progress bars displayed in terminal
``--video_dir VIDEO_DIR`` Directory to write video
``--config_file CONFIG_FILE`` Path to the custom configuration file
``--log-level LOG_LEVEL`` Level of messages to Display, can be DEBUG / INFO / WARNING / ERROR / CRITICAL
``--autoreload`` Automatically reload Python modules to pick up code changes across during an interactive embedding
========================================================== ====== =====================================================================================================================================================================================================
custom_config
--------------
In order to perform more configuration (about directories, etc.) and permanently
change the default value (you don't have to add flags to the command every time),
you can modify ``custom_config.yml``. The meaning of each option is in
page :doc:`../documentation/custom_config`.
You can also use different ``custom_config.yml`` for different directories, such as
following the directory structure:
.. code-block:: text
manim/
├── manimlib/
│ ├── animation/
│ ├── ...
│ ├── default_config.yml
│ └── window.py
├── project/
│ ├── code.py
│ └── custom_config.yml
└── custom_config.yml
When you enter the ``project/`` folder and run ``manimgl code.py <Scene>``,
it will overwrite ``manim/default_config.yml`` with ``custom_config.yml``
in the ``project`` folder.
Alternatively, you can use ``--config_file`` flag in CLI to specify configuration file manually.
.. code-block:: sh
manimgl project/code.py --config_file /path/to/custom_config.yml
================================================
FILE: docs/source/getting_started/example_scenes.rst
================================================
Example Scenes
==============
After understanding the previous knowledge, we can understand more scenes.
Many example scenes are given in ``example_scenes.py``, let's start with
the simplest and one by one.
InteractiveDevlopment
---------------------
.. manim-example:: InteractiveDevelopment
:media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/InteractiveDevelopment.mp4
from manimlib import *
class InteractiveDevelopment(Scene):
def construct(self):
circle = Circle()
circle.set_fill(BLUE, opacity=0.5)
circle.set_stroke(BLUE_E, width=4)
square = Square()
self.play(ShowCreation(square))
self.wait()
# This opens an iPython terminal where you can keep writing
# lines as if they were part of this construct method.
# In particular, 'square', 'circle' and 'self' will all be
# part of the local namespace in that terminal.
self.embed()
# Try copying and pasting some of the lines below into
# the interactive shell
self.play(ReplacementTransform(square, circle))
self.wait()
self.play(circle.animate.stretch(4, 0))
self.play(Rotate(circle, 90 * DEG))
self.play(circle.animate.shift(2 * RIGHT).scale(0.25))
text = Text("""
In general, using the interactive shell
is very helpful when developing new scenes
""")
self.play(Write(text))
# In the interactive shell, you can just type
# play, add, remove, clear, wait, save_state and restore,
# instead of self.play, self.add, self.remove, etc.
# To interact with the window, type touch(). You can then
# scroll in the window, or zoom by holding down 'z' while scrolling,
# and change camera perspective by holding down 'd' while moving
# the mouse. Press 'r' to reset to the standard camera position.
# Press 'q' to stop interacting with the window and go back to
# typing new commands into the shell.
# In principle you can customize a scene to be responsive to
# mouse and keyboard interactions
always(circle.move_to, self.mouse_point)
This scene is similar to what we wrote in :doc:`quickstart`.
And how to interact has been written in the comments.
No more explanation here.
AnimatingMethods
----------------
.. manim-example:: AnimatingMethods
:media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/AnimatingMethods.mp4
class AnimatingMethods(Scene):
def construct(self):
grid = OldTex(r"\pi").get_grid(10, 10, height=4)
self.add(grid)
# You can animate the application of mobject methods with the
# ".animate" syntax:
self.play(grid.animate.shift(LEFT))
# Alternatively, you can use the older syntax by passing the
# method and then the arguments to the scene's "play" function:
self.play(grid.shift, LEFT)
# Both of those will interpolate between the mobject's initial
# state and whatever happens when you apply that method.
# For this example, calling grid.shift(LEFT) would shift the
# grid one unit to the left, but both of the previous calls to
# "self.play" animate that motion.
# The same applies for any method, including those setting colors.
self.play(grid.animate.set_color(YELLOW))
self.wait()
self.play(grid.animate.set_submobject_colors_by_gradient(BLUE, GREEN))
self.wait()
self.play(grid.animate.set_height(TAU - MED_SMALL_BUFF))
self.wait()
# The method Mobject.apply_complex_function lets you apply arbitrary
# complex functions, treating the points defining the mobject as
# complex numbers.
self.play(grid.animate.apply_complex_function(np.exp), run_time=5)
self.wait()
# Even more generally, you could apply Mobject.apply_function,
# which takes in functions form R^3 to R^3
self.play(
grid.animate.apply_function(
lambda p: [
p[0] + 0.5 * math.sin(p[1]),
p[1] + 0.5 * math.sin(p[0]),
p[2]
]
),
run_time=5,
)
self.wait()
The new usage in this scene is ``.get_grid()`` and ``self.play(mob.animate.method(args))``.
- ``.get_grid()`` method will return a new mobject containing multiple copies of this one arranged in a grid.
- ``self.play(mob.animate.method(args))`` animates the method, and the details are in the comments above.
TextExample
-----------
.. manim-example:: TextExample
:media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/TextExample.mp4
class TextExample(Scene):
def construct(self):
# To run this scene properly, you should have "Consolas" font in your computer
# for full usage, you can see https://github.com/3b1b/manim/pull/680
text = Text("Here is a text", font="Consolas", font_size=90)
difference = Text(
"""
The most important difference between Text and TexText is that\n
you can change the font more easily, but can't use the LaTeX grammar
""",
font="Arial", font_size=24,
# t2c is a dict that you can choose color for different text
t2c={"Text": BLUE, "TexText": BLUE, "LaTeX": ORANGE}
)
VGroup(text, difference).arrange(DOWN, buff=1)
self.play(Write(text))
self.play(FadeIn(difference, UP))
self.wait(3)
fonts = Text(
"And you can also set the font according to different words",
font="Arial",
t2f={"font": "Consolas", "words": "Consolas"},
t2c={"font": BLUE, "words": GREEN}
)
fonts.set_width(FRAME_WIDTH - 1)
slant = Text(
"And the same as slant and weight",
font="Consolas",
t2s={"slant": ITALIC},
t2w={"weight": BOLD},
t2c={"slant": ORANGE, "weight": RED}
)
VGroup(fonts, slant).arrange(DOWN, buff=0.8)
self.play(FadeOut(text), FadeOut(difference, shift=DOWN))
self.play(Write(fonts))
self.wait()
self.play(Write(slant))
self.wait()
The new classes in this scene are ``Text``, ``VGroup``, ``Write``, ``FadeIn`` and ``FadeOut``.
- ``Text`` can create text, define fonts, etc. The usage ais clearly reflected in the above examples.
- ``VGroup`` can put multiple ``VMobject`` together as a whole. In the example, the ``.arrange()`` method is called to arrange the sub-mobjects in sequence downward (``DOWN``), and the spacing is ``buff``.
- ``Write`` is an animation that shows similar writing effects.
- ``FadeIn`` fades the object in, the second parameter indicates the direction of the fade in.
- ``FadeOut`` fades out the object, the second parameter indicates the direction of the fade out.
TexTransformExample
-------------------
.. manim-example:: TexTransformExample
:media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/TexTransformExample.mp4
class TexTransformExample(Scene):
def construct(self):
to_isolate = ["B", "C", "=", "(", ")"]
lines = VGroup(
# Passing in muliple arguments to Tex will result
# in the same expression as if those arguments had
# been joined together, except that the submobject
# hierarchy of the resulting mobject ensure that the
# Tex mobject has a subject corresponding to
# each of these strings. For example, the Tex mobject
# below will have 5 subjects, corresponding to the
# expressions [A^2, +, B^2, =, C^2]
OldTex("A^2", "+", "B^2", "=", "C^2"),
# Likewise here
OldTex("A^2", "=", "C^2", "-", "B^2"),
# Alternatively, you can pass in the keyword argument
# "isolate" with a list of strings that should be out as
# their own submobject. So the line below is equivalent
# to the commented out line below it.
OldTex("A^2 = (C + B)(C - B)", isolate=["A^2", *to_isolate]),
# OldTex("A^2", "=", "(", "C", "+", "B", ")", "(", "C", "-", "B", ")"),
OldTex("A = \\sqrt{(C + B)(C - B)}", isolate=["A", *to_isolate])
)
lines.arrange(DOWN, buff=LARGE_BUFF)
for line in lines:
line.set_color_by_tex_to_color_map({
"A": BLUE,
"B": TEAL,
"C": GREEN,
})
play_kw = {"run_time": 2}
self.add(lines[0])
# The animation TransformMatchingTex will line up parts
# of the source and target which have matching tex strings.
# Here, giving it a little path_arc makes each part sort of
# rotate into their final positions, which feels appropriate
# for the idea of rearranging an equation
self.play(
TransformMatchingTex(
lines[0].copy(), lines[1],
path_arc=90 * DEG,
),
**play_kw
)
self.wait()
# Now, we could try this again on the next line...
self.play(
TransformMatchingTex(lines[1].copy(), lines[2]),
**play_kw
)
self.wait()
# ...and this looks nice enough, but since there's no tex
# in lines[2] which matches "C^2" or "B^2", those terms fade
# out to nothing while the C and B terms fade in from nothing.
# If, however, we want the C^2 to go to C, and B^2 to go to B,
# we can specify that with a key map.
self.play(FadeOut(lines[2]))
self.play(
TransformMatchingTex(
lines[1].copy(), lines[2],
key_map={
"C^2": "C",
"B^2": "B",
}
),
**play_kw
)
self.wait()
# And to finish off, a simple TransformMatchingShapes would work
# just fine. But perhaps we want that exponent on A^2 to transform into
# the square root symbol. At the moment, lines[2] treats the expression
# A^2 as a unit, so we might create a new version of the same line which
# separates out just the A. This way, when TransformMatchingTex lines up
# all matching parts, the only mismatch will be between the "^2" from
# new_line2 and the "\sqrt" from the final line. By passing in,
# transform_mismatches=True, it will transform this "^2" part into
# the "\sqrt" part.
new_line2 = OldTex("A^2 = (C + B)(C - B)", isolate=["A", *to_isolate])
new_line2.replace(lines[2])
new_line2.match_style(lines[2])
self.play(
TransformMatchingTex(
new_line2, lines[3],
transform_mismatches=True,
),
**play_kw
)
self.wait(3)
self.play(FadeOut(lines, RIGHT))
# Alternatively, if you don't want to think about breaking up
# the tex strings deliberately, you can TransformMatchingShapes,
# which will try to line up all pieces of a source mobject with
# those of a target, regardless of the submobject hierarchy in
# each one, according to whether those pieces have the same
# shape (as best it can).
source = Text("the morse code", height=1)
target = Text("here come dots", height=1)
self.play(Write(source))
self.wait()
kw = {"run_time": 3, "path_arc": PI / 2}
self.play(TransformMatchingShapes(source, target, **kw))
self.wait()
self.play(TransformMatchingShapes(target, source, **kw))
self.wait()
The new classes in this scene are ``Tex``, ``TexText``, ``TransformMatchingTex``
and ``TransformMatchingShapes``.
- ``Tex`` uses LaTeX to create mathematical formulas.
- ``TexText`` uses LaTeX to create text.
- ``TransformMatchingTeX`` automatically transforms sub-objects according to the similarities and differences of tex in ``Tex``.
- ``TransformMatchingShapes`` automatically transform sub-objects directly based on the similarities and differences of the object point sets.
UpdatersExample
---------------
.. manim-example:: UpdatersExample
:media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/UpdatersExample.mp4
class UpdatersExample(Scene):
def construct(self):
square = Square()
square.set_fill(BLUE_E, 1)
# On all all frames, the constructor Brace(square, UP) will
# be called, and the mobject brace will set its data to match
# that of the newly constructed object
brace = always_redraw(Brace, square, UP)
text, number = label = VGroup(
Text("Width = "),
DecimalNumber(
0,
show_ellipsis=True,
num_decimal_places=2,
include_sign=True,
)
)
label.arrange(RIGHT)
# This ensures that the method deicmal.next_to(square)
# is called on every frame
always(label.next_to, brace, UP)
# You could also write the following equivalent line
# label.add_updater(lambda m: m.next_to(brace, UP))
# If the argument itself might change, you can use f_always,
# for which the arguments following the initial Mobject method
# should be functions returning arguments to that method.
# The following line ensures that decimal.set_value(square.get_y())
# is called every frame
f_always(number.set_value, square.get_width)
# You could also write the following equivalent line
# number.add_updater(lambda m: m.set_value(square.get_width()))
self.add(square, brace, label)
# Notice that the brace and label track with the square
self.play(
square.animate.scale(2),
rate_func=there_and_back,
run_time=2,
)
self.wait()
self.play(
square.animate.set_width(5, stretch=True),
run_time=3,
)
self.wait()
self.play(
square.animate.set_width(2),
run_time=3
)
self.wait()
# In general, you can alway call Mobject.add_updater, and pass in
# a function that you want to be called on every frame. The function
# should take in either one argument, the mobject, or two arguments,
# the mobject and the amount of time since the last frame.
now = self.time
w0 = square.get_width()
square.add_updater(
lambda m: m.set_width(w0 * math.cos(self.time - now))
)
self.wait(4 * PI)
The new classes and usage in this scene are ``always_redraw()``, ``DecimalNumber``, ``.to_edge()``,
``.center()``, ``always()``, ``f_always()``, ``.set_y()`` and ``.add_updater()``.
- ``always_redraw()`` function create a new mobject every frame.
- ``DecimalNumber`` is a variable number, speed it up by breaking it into ``Text`` characters.
- ``.to_edge()`` means to place the object on the edge of the screen.
- ``.center()`` means to place the object in the center of the screen.
- ``always(f, x)`` means that a certain function (``f(x)``) is executed every frame.
- ``f_always(f, g)`` is similar to ``always``, executed ``f(g())`` every frame.
- ``.set_y()`` means to set the ordinate of the object on the screen.
- ``.add_updater()`` sets an update function for the object. For example: ``mob1.add_updater(lambda mob: mob.next_to(mob2))`` means ``mob1.next_to(mob2)`` is executed every frame.
CoordinateSystemExample
-----------------------
.. manim-example:: CoordinateSystemExample
:media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/CoordinateSystemExample.mp4
class CoordinateSystemExample(Scene):
def construct(self):
axes = Axes(
# x-axis ranges from -1 to 10, with a default step size of 1
x_range=(-1, 10),
# y-axis ranges from -2 to 2 with a step size of 0.5
y_range=(-2, 2, 0.5),
# The axes will be stretched so as to match the specified
# height and width
height=6,
width=10,
# Axes is made of two NumberLine mobjects. You can specify
# their configuration with axis_config
axis_config={
"stroke_color": GREY_A,
"stroke_width": 2,
},
# Alternatively, you can specify configuration for just one
# of them, like this.
y_axis_config={
"include_tip": False,
}
)
# Keyword arguments of add_coordinate_labels can be used to
# configure the DecimalNumber mobjects which it creates and
# adds to the axes
axes.add_coordinate_labels(
font_size=20,
num_decimal_places=1,
)
self.add(axes)
# Axes descends from the CoordinateSystem class, meaning
# you can call call axes.coords_to_point, abbreviated to
# axes.c2p, to associate a set of coordinates with a point,
# like so:
dot = Dot(fill_color=RED)
dot.move_to(axes.c2p(0, 0))
self.play(FadeIn(dot, scale=0.5))
self.play(dot.animate.move_to(axes.c2p(3, 2)))
self.wait()
self.play(dot.animate.move_to(axes.c2p(5, 0.5)))
self.wait()
# Similarly, you can call axes.point_to_coords, or axes.p2c
# print(axes.p2c(dot.get_center()))
# We can draw lines from the axes to better mark the coordinates
# of a given point.
# Here, the always_redraw command means that on each new frame
# the lines will be redrawn
h_line = always_redraw(lambda: axes.get_h_line(dot.get_left()))
v_line = always_redraw(lambda: axes.get_v_line(dot.get_bottom()))
self.play(
ShowCreation(h_line),
ShowCreation(v_line),
)
self.play(dot.animate.move_to(axes.c2p(3, -2)))
self.wait()
self.play(dot.animate.move_to(axes.c2p(1, 1)))
self.wait()
# If we tie the dot to a particular set of coordinates, notice
# that as we move the axes around it respects the coordinate
# system defined by them.
f_always(dot.move_to, lambda: axes.c2p(1, 1))
self.play(
axes.animate.scale(0.75).to_corner(UL),
run_time=2,
)
self.wait()
self.play(FadeOut(VGroup(axes, dot, h_line, v_line)))
# Other coordinate systems you can play around with include
# ThreeDAxes, NumberPlane, and ComplexPlane.
GraphExample
------------
.. manim-example:: GraphExample
:media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/GraphExample.mp4
class GraphExample(Scene):
def construct(self):
axes = Axes((-3, 10), (-1, 8))
axes.add_coordinate_labels()
self.play(Write(axes, lag_ratio=0.01, run_time=1))
# Axes.get_graph will return the graph of a function
sin_graph = axes.get_graph(
lambda x: 2 * math.sin(x),
color=BLUE,
)
# By default, it draws it so as to somewhat smoothly interpolate
# between sampled points (x, f(x)). If the graph is meant to have
# a corner, though, you can set use_smoothing to False
relu_graph = axes.get_graph(
lambda x: max(x, 0),
use_smoothing=False,
color=YELLOW,
)
# For discontinuous functions, you can specify the point of
# discontinuity so that it does not try to draw over the gap.
step_graph = axes.get_graph(
lambda x: 2.0 if x > 3 else 1.0,
discontinuities=[3],
color=GREEN,
)
# Axes.get_graph_label takes in either a string or a mobject.
# If it's a string, it treats it as a LaTeX expression. By default
# it places the label next to the graph near the right side, and
# has it match the color of the graph
sin_label = axes.get_graph_label(sin_graph, "\\sin(x)")
relu_label = axes.get_graph_label(relu_graph, Text("ReLU"))
step_label = axes.get_graph_label(step_graph, Text("Step"), x=4)
self.play(
ShowCreation(sin_graph),
FadeIn(sin_label, RIGHT),
)
self.wait(2)
self.play(
ReplacementTransform(sin_graph, relu_graph),
FadeTransform(sin_label, relu_label),
)
self.wait()
self.play(
ReplacementTransform(relu_graph, step_graph),
FadeTransform(relu_label, step_label),
)
self.wait()
parabola = axes.get_graph(lambda x: 0.25 * x**2)
parabola.set_stroke(BLUE)
self.play(
FadeOut(step_graph),
FadeOut(step_label),
ShowCreation(parabola)
)
self.wait()
# You can use axes.input_to_graph_point, abbreviated
# to axes.i2gp, to find a particular point on a graph
dot = Dot(fill_color=RED)
dot.move_to(axes.i2gp(2, parabola))
self.play(FadeIn(dot, scale=0.5))
# A value tracker lets us animate a parameter, usually
# with the intent of having other mobjects update based
# on the parameter
x_tracker = ValueTracker(2)
f_always(
dot.move_to,
lambda: axes.i2gp(x_tracker.get_value(), parabola)
)
self.play(x_tracker.animate.set_value(4), run_time=3)
self.play(x_tracker.animate.set_value(-2), run_time=3)
self.wait()
SurfaceExample
--------------
.. manim-example:: SurfaceExample
:media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/SurfaceExample.mp4
class SurfaceExample(Scene):
CONFIG = {
"camera_class": ThreeDCamera,
}
def construct(self):
surface_text = Text("For 3d scenes, try using surfaces")
surface_text.fix_in_frame()
surface_text.to_edge(UP)
self.add(surface_text)
self.wait(0.1)
torus1 = Torus(r1=1, r2=1)
torus2 = Torus(r1=3, r2=1)
sphere = Sphere(radius=3, resolution=torus1.resolution)
# You can texture a surface with up to two images, which will
# be interpreted as the side towards the light, and away from
# the light. These can be either urls, or paths to a local file
# in whatever you've set as the image directory in
# the custom_config.yml file
# day_texture = "EarthTextureMap"
# night_texture = "NightEarthTextureMap"
day_texture = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Whole_world_-_land_and_oceans.jpg/1280px-Whole_world_-_land_and_oceans.jpg"
night_texture = "https://upload.wikimedia.org/wikipedia/commons/thumb/b/ba/The_earth_at_night.jpg/1280px-The_earth_at_night.jpg"
surfaces = [
TexturedSurface(surface, day_texture, night_texture)
for surface in [sphere, torus1, torus2]
]
for mob in surfaces:
mob.shift(IN)
mob.mesh = SurfaceMesh(mob)
mob.mesh.set_stroke(BLUE, 1, opacity=0.5)
# Set perspective
frame = self.camera.frame
frame.set_euler_angles(
theta=-30 * DEG,
phi=70 * DEG,
)
surface = surfaces[0]
self.play(
FadeIn(surface),
ShowCreation(surface.mesh, lag_ratio=0.01, run_time=3),
)
for mob in surfaces:
mob.add(mob.mesh)
surface.save_state()
self.play(Rotate(surface, PI / 2), run_time=2)
for mob in surfaces[1:]:
mob.rotate(PI / 2)
self.play(
Transform(surface, surfaces[1]),
run_time=3
)
self.play(
Transform(surface, surfaces[2]),
# Move camera frame during the transition
frame.animate.increment_phi(-10 * DEG),
frame.animate.increment_theta(-20 * DEG),
run_time=3
)
# Add ambient rotation
frame.add_updater(lambda m, dt: m.increment_theta(-0.1 * dt))
# Play around with where the light is
light_text = Text("You can move around the light source")
light_text.move_to(surface_text)
light_text.fix_in_frame()
self.play(FadeTransform(surface_text, light_text))
light = self.camera.light_source
self.add(light)
light.save_state()
self.play(light.animate.move_to(3 * IN), run_time=5)
self.play(light.animate.shift(10 * OUT), run_time=5)
drag_text = Text("Try moving the mouse while pressing d or s")
drag_text.move_to(light_text)
drag_text.fix_in_frame()
self.play(FadeTransform(light_text, drag_text))
self.wait()
This scene shows an example of using a three-dimensional surface, and
the related usage has been briefly described in the notes.
- ``.fix_in_frame()`` makes the object not change with the view angle of the screen, and is always displayed at a fixed position on the screen.
OpeningManimExample
-------------------
.. manim-example:: OpeningManimExample
:media: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/example_scenes/OpeningManimExample.mp4
class OpeningManimExample(Scene):
def construct(self):
intro_words = Text("""
The original motivation for manim was to
better illustrate mathematical functions
as transformations.
""")
intro_words.to_edge(UP)
self.play(Write(intro_words))
self.wait(2)
# Linear transform
grid = NumberPlane((-10, 10), (-5, 5))
matrix = [[1, 1], [0, 1]]
linear_transform_words = VGroup(
Text("This is what the matrix"),
IntegerMatrix(matrix, include_background_rectangle=True),
Text("looks like")
)
linear_transform_words.arrange(RIGHT)
linear_transform_words.to_edge(UP)
linear_transform_words.set_stroke(BLACK, 10, background=True)
self.play(
ShowCreation(grid),
FadeTransform(intro_words, linear_transform_words)
)
self.wait()
self.play(grid.animate.apply_matrix(matrix), run_time=3)
self.wait()
# Complex map
c_grid = ComplexPlane()
moving_c_grid = c_grid.copy()
moving_c_grid.prepare_for_nonlinear_transform()
c_grid.set_stroke(BLUE_E, 1)
c_grid.add_coordinate_labels(font_size=24)
complex_map_words = TexText("""
Or thinking of the plane as $\\mathds{C}$,\\\\
this is the map $z \\rightarrow z^2$
""")
complex_map_words.to_corner(UR)
complex_map_words.set_stroke(BLACK, 5, background=True)
self.play(
FadeOut(grid),
Write(c_grid, run_time=3),
FadeIn(moving_c_grid),
FadeTransform(linear_transform_words, complex_map_words),
)
self.wait()
self.play(
moving_c_grid.animate.apply_complex_function(lambda z: z**2),
run_time=6,
)
self.wait(2)
This scene is a comprehensive application of a two-dimensional scene.
After seeing these scenes, you have already understood part of the
usage of manim. For more examples, see `the video code of 3b1b <https://github.com/3b1b/videos>`_.
================================================
FILE: docs/source/getting_started/installation.rst
================================================
Installation
============
Manim runs on Python 3.7 or higher.
System requirements are：
- `FFmpeg <https://ffmpeg.org/>`__
- `OpenGL <https://www.opengl.org//>`__ (included in python package ``PyOpenGL``)
- `LaTeX <https://www.latex-project.org>`__ (optional, if you want to use LaTeX)
- `Pango <https://pango.org>`__ (only for Linux)
Install FFmpeg
--------------
Install FFmpeg Windows
------------------------
.. code-block:: cmd
choco install ffmpeg
# Install FFmepeg Linux
----------------------------
.. code-block:: sh
$ sudo apt update
$ sudo apt install ffmpeg
$ ffmpeg -version
# Install FFmpeg MacOS
----------------------------
- Download This ZIP file `https://www.gyan.dev/ffmpeg/builds/ffmpeg-git-full.7z`(if the link is not working download this zip file from there original website)
Directly
--------
.. code-block:: sh
# Install manimgl
pip install manimgl
# Try it out
manimgl
If you want to hack on manimlib itself, clone this repository and in
that directory execute:
.. code-block:: sh
# Install python requirements
pip install -e .
# Try it out
manimgl example_scenes.py OpeningManimExample
# or
manim-render example_scenes.py OpeningManimExample
If you run the above command and no error message appears,
then you have successfully installed all the environments required by manim.
Directly (Windows)
------------------
1. `Install
FFmpeg <https://www.wikihow.com/Install-FFmpeg-on-Windows>`__, and make sure that its path is in the PATH environment variable.
2. Install a LaTeX distribution.
`TeXLive-full <http://tug.org/texlive/>`__ is recommended.
3. Install the remaining Python packages.
.. code-block:: sh
git clone https://github.com/3b1b/manim.git
cd manim
pip install -e .
manimgl example_scenes.py OpeningManimExample
For Anaconda
------------
- Install FFmpeg and LaTeX as above.
- Create a conda environment using
.. code-block:: sh
git clone https://github.com/3b1b/manim.git
cd manim
conda create -n manim python=3.8
conda activate manim
pip install -e .
================================================
FILE: docs/source/getting_started/quickstart.rst
================================================
Quick Start
===========
After installing the manim environment according to the instructions on the
:doc:`installation` page, you can try to make a scene yourself from scratch.
First, create a new ``.py`` file (such as ``start.py``) according to the following
directory structure:
.. code-block:: text
:emphasize-lines: 8
manim/
├── manimlib/
│ ├── animation/
│ ├── ...
│ ├── default_config.yml
│ └── window.py
├── custom_config.yml
└── start.py
And paste the following code (I will explain the function of each line in detail later):
.. code-block:: python
:linenos:
from manimlib import *
class SquareToCircle(Scene):
def construct(self):
circle = Circle()
circle.set_fill(BLUE, opacity=0.5)
circle.set_stroke(BLUE_E, width=4)
self.add(circle)
And run this command:
.. code-block:: sh
manimgl start.py SquareToCircle
A window will pop up on the screen. And then you can :
- scroll the middle mouse button to move the screen up and down
- hold down the :kbd:`z` on the keyboard while scrolling the middle mouse button to zoom the screen
- hold down the :kbd:`s` key on the keyboard and move the mouse to pan the screen
- hold down the :kbd:`d` key on the keyboard and move the mouse to change the three-dimensional perspective.
Finally, you can close the window and exit the program by pressing :kbd:`q`.
Run this command again:
.. code-block:: sh
manimgl start.py SquareToCircle -os
At this time, no window will pop up. When the program is finished, this rendered
image will be automatically opened (saved in the subdirectory ``images/`` of the same
level directory of ``start.py`` by default):
.. image:: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/quickstart/SquareToCircle.png
:align: center
Make an image
-------------
Next, let's take a detailed look at what each row does.
**Line 1**:
.. code-block:: python
from manimlib import *
This will import all the classes that may be used when using manim.
**Line 3**:
.. code-block:: python
class SquareToCircle(Scene):
Create a :class:`Scene` subclass ``SquareToCircle``, which will be
the scene you write and render.
**Line 4**:
.. code-block:: python
def construct(self):
Write the ``construct()`` method, the content of which will determine
how to create the mobjects in the screen and what operations need to be performed.
**Line 5**:
.. code-block:: python
circle = Circle()
Create a circle (an instance of the :class:`Circle` class), called ``circle``
**Line 6~7**:
.. code-block:: python
circle.set_fill(BLUE, opacity=0.5)
circle.set_stroke(BLUE_E, width=4)
Set the circle style by calling the circle's method.
- The ``.set_fill()`` method sets the fill color of this circle to blue (``BLUE``, defined in :doc:`../documentation/constants`), and the fill transparency to 0.5.
- The ``.set_stroke()`` method sets the stroke color of this circle to dark blue (``BLUE_E``, defined in :doc:`../documentation/constants`), and the stroke width to 4.
**Line 9**:
.. code-block:: python
self.add(circle)
Add this circle to the screen through the ``.add()`` method of :class:`Scene`.
Add animations
--------------
Let's change some codes and add some animations to make videos instead of just pictures.
.. code-block:: python
:linenos:
from manimlib import *
class SquareToCircle(Scene):
def construct(self):
circle = Circle()
circle.set_fill(BLUE, opacity=0.5)
circle.set_stroke(BLUE_E, width=4)
square = Square()
self.play(ShowCreation(square))
self.wait()
self.play(ReplacementTransform(square, circle))
self.wait()
Run this command this time:
.. code-block:: sh
manimgl start.py SquareToCircle
The pop-up window will play animations of drawing a square and transforming
it into a circle. If you want to save this video, run:
.. code-block:: sh
manimgl start.py SquareToCircle -o
This time there will be no pop-up window, but the video file (saved in the subdirectory
``videos/`` of the same level directory of ``start.py`` by default) will be automatically
opened after the operation is over:
.. raw:: html
<video class="manim-video" controls loop autoplay src="https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/quickstart/SquareToCircle.mp4"></video>
Let's take a look at the code this time. The first 7 lines are the same as the previous
ones, and the 8th line is similar to the 5th line, which creates an instance of the
:class:`Square` class and named it ``square``.
**Line 10**:
.. code-block:: python
self.play(ShowCreation(square))
An animation is played through :class:`Scene`'s ``.play()`` method. :class:`ShowCreation`
is an animation that shows the process of creating a given mobject.
``self.play(ShowCreation(square))`` is to play the animation of creating ``square``.
**Line 11**:
.. code-block:: python
self.wait()
Use :class:`Scene`'s ``.wait()`` method to pause (default 1s), you can pass in
parameters to indicate the pause time (for example, ``self.wait(3)`` means pause for 3s).
**Line 12**:
.. code-block:: python
self.play(ReplacementTransform(square, circle))
Play the animation that transforms ``square`` into ``circle``.
``ReplacementTransform(A, B)`` means to transform A into B's pattern and replace A with B.
**Line 13**: Same as line 11, pause for 1s.
Enable interaction
------------------
Interaction is a new feature of the new version. You can add the following line
at the end of the code to enable interaction:
.. code-block:: python
self.embed()
Then run ``manimgl start.py SquareToCircle``.
After the previous animation is executed, the ipython terminal will be opened on
the command line. After that, you can continue to write code in it, and the statement
you entered will be executed immediately after pressing :kbd:`Enter`.
For example: input the following lines (without comment lines) into it respectively
(``self.play`` can be abbreviated as ``play`` in this mode):
.. code-block:: python
# Stretched 4 times in the vertical direction
play(circle.animate.stretch(4, dim=0))
# Rotate the ellipse 90°
play(Rotate(circle, TAU / 4))
# Move 2 units to the right and shrink to 1/4 of the original
play(circle.animate.shift(2 * RIGHT), circle.animate.scale(0.25))
# Insert 10 curves into circle for non-linear transformation (no animation will play)
circle.insert_n_curves(10)
# Apply a complex transformation of f(z)=z^2 to all points on the circle
play(circle.animate.apply_complex_function(lambda z: z**2))
# Close the window and exit the program
exit()
You will get an animation similar to the following:
.. raw:: html
<video class="manim-video" controls loop autoplay src="https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/quickstart/SquareToCircleEmbed.mp4"></video>
If you want to enter the interactive mode directly, you don't have to write an
empty scene containing only ``self.embed()``, you can directly run the following command
(this will enter the ipython terminal while the window pops up):
.. code-block:: sh
manimgl
You succeeded!
--------------
After reading the above content, you already know how to use manim.
Below you can see some examples, in the :doc:`example_scenes` page.
But before that, you'd better have a look at the :doc:`configuration` of manim.
================================================
FILE: docs/source/getting_started/structure.rst
================================================
Manim's structure
=================
Manim's directory structure
---------------------------
The manim directory looks very complicated, with a lot of files,
but the structure is clear.
Below is the directory structure of manim:
.. code-block:: text
manimlib/ # manim library
├── __init__.py
├── __main__.py
├── default_config.yml # Default configuration file
├── config.py # Process CLI flags
├── constants.py # Defined some constants
├── extract_scene.py # Extract and run the scene
├── shader_wrapper.py # Shaders' Wrapper for convenient control
├── window.py # Playback window
├── tex_templates/ # Templates preset for LaTeX
│ ├── tex_templates.tex # Tex template (will be compiled with latex, default)
│ └── ctex_templates.tex # Tex template that support Chinese (will be compiled with xelatex)
├── camera/
│ └── camera.py # Including Camera and CameraFrame
├── scene/
│ ├── scene_file_writer.py # Used to write scene to video file
│ ├── scene.py # The basic Scene class
│ ├── three_d_scene.py # Three-dimensional scene
│ ├── sample_space_scene.py # Probability related sample space scene
│ └── vector_space_scene.py # Vector field scene
├── animation/
│ ├── animation.py # The basic class of animation
│ ├── composition.py # Animation group
│ ├── creation.py # Animation related to Create
│ ├── fading.py # Fade related animation
│ ├── growing.py # Animation related to Grow
│ ├── indication.py # Some animations for emphasis
│ ├── movement.py # Animation related to movement
│ ├── numbers.py # Realize changes to DecimalNumber
│ ├── rotation.py # Animation related to rotation
│ ├── specialized.py # Some uncommon animations for special projects
│ ├── transform_matching_parts.py # Transform which can automatically match parts
│ ├── transform.py # Some Transforms
│ └── update.py # Realize update from function
├── mobject/
│ ├── mobject.py # The basic class of all math object
│ ├── types/ # 4 types of mobject
│ │ ├── dot_cloud.py # Dot cloud (an subclass of PMobject)
│ │ ├── image_mobject.py # Insert pictures
│ │ ├── point_cloud_mobject.py # PMobject (mobject composed of points)
│ │ ├── surface.py # ParametricSurface
│ │ └── vectorized_mobject.py # VMobject (vectorized mobject)
│ ├── svg/ # mobject related to svg
│ │ ├── svg_mobject.py # SVGMobject
│ │ ├── brace.py # Brace
│ │ ├── drawings.py # Some special mobject of svg image
│ │ ├── tex_mobject.py # Tex and TexText implemented by LaTeX
│ │ └── text_mobject.py # Text implemented by manimpango
│ ├── changing.py # Dynamically changing mobject
│ ├── coordinate_systems.py # coordinate system
│ ├── frame.py # mobject related to frame
│ ├── functions.py # ParametricFunction
│ ├── geometry.py # geometry mobjects
│ ├── matrix.py # matrix
│ ├── mobject_update_utils.py # some defined updater
│ ├── number_line.py # Number line
│ ├── numbers.py # Numbers that can be changed
│ ├── probability.py # mobject related to probability
│ ├── shape_matchers.py # mobject adapted to the size of other objects
│ ├── three_dimensions.py # Three-dimensional objects
│ ├── value_tracker.py # ValueTracker which storage number
│ └── vector_field.py # VectorField
├── once_useful_constructs/ # 3b1b's Common scenes written for some videos
│ └── ...
├── shaders/ # GLSL scripts for rendering
│ ├── simple_vert.glsl # a simple glsl script for position
│ ├── insert/ # glsl scripts to be inserted in other glsl scripts
│ │ ├── NOTE.md # explain how to insert glsl scripts
│ │ └── ... # useful scripts
│ ├── image/ # glsl for images
│ │ └── ... # containing shaders for vertex and fragment
│ ├── quadratic_bezier_fill/ # glsl for the fill of quadratic bezier curve
│ │ └── ... # containing shaders for vertex, fragment and geometry
│ ├── quadratic_bezier_stroke/ # glsl for the stroke of quadratic bezier curve
│ │ └── ... # containing shaders for vertex, fragment and geometry
│ ├── surface/ # glsl for surfaces
│ │ └── ... # containing shaders for vertex and fragment
│ ├── textured_surface/ # glsl for textured_surface
│ │ └── ... # containing shaders for vertex and fragment
│ └── true_dot/ # glsl for a dot
│ └── ... # containing shaders for vertex, fragment and geometry
└── utils/ # Some useful utility functions
├── bezier.py # For bezier curve
├── color.py # For color
├── dict_ops.py # Functions related to dictionary processing
├── customization.py # Read from custom_config.yml
├── debug.py # Utilities for debugging in program
├── directories.py # Read directories from config file
├── family_ops.py # Process family members
├── file_ops.py # Process files and directories
├── images.py # Read image
├── iterables.py # Functions related to list/dictionary processing
├── paths.py # Curve path
├── rate_functions.py # Some defined rate_functions
├── simple_functions.py # Some commonly used functions
├── sounds.py # Process sounds
├── space_ops.py # Space coordinate calculation
├── strings.py # Process strings
└── tex_file_writing.py # Use LaTeX to write strings as svg
Inheritance structure of manim's classes
----------------------------------------
`Here <https://github.com/3b1b/manim/files/5824383/manim_shaders_structure.pdf>`_
is a pdf showed inheritance structure of manim's classes, large,
but basically all classes have included:
.. image:: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/manim_shaders_structure.png
Manim execution process
-----------------------
.. image:: https://cdn.jsdelivr.net/gh/manim-kindergarten/CDN@master/manimgl_assets/manim_shaders_process_en.png
================================================
FILE: docs/source/getting_started/whatsnew.rst
================================================
What's new
==========
Usage changes of new version manim
----------------------------------
There are many changes in the new version of manim, and here are only the changes that
may have an impact at the code writing level.
Some of the changes here may not have any major impact on the use, and some changes
that affect the use are not mentioned below.
This document is for reference only, see the source code for details.
- ``Animation``
- Added ``Fade`` as the parent class of ``FadeIn`` and ``FadeOut``
- ``FadeIn`` and ``FadeOut`` can be passed in ``shift`` and ``scale`` parameters
- Deleted ``FadeInFrom, FadeInFromDown, FadeOutAndShift, FadeOutAndShiftDown, FadeInFromLarge``, these can be used ``FadeIn, FadeOut`` to achieve the same effect more easily
- Added ``FadeTransform`` to cross fade between two objects, and subclass ``FadeTransformPieces``
- Added ``CountInFrom(decimal_mob, source_number=0)`` to count ``decimal_mob`` from ``source_number`` to the current value
- ``Rotating`` can directly pass in ``angle`` and ``axis`` without writing keywords ``angle=, axis=``
- ``Rotate`` has become a subclass of ``Rotating``, and the distortion effect in ``Transform`` will not appear
- Removed ``MoveCar`` animation
- Added ``TransformMatchingShapes(mobject, target_mobject)`` and ``TransformMatchingTex(mobject, target_mobject)``
- ``Camera``
- Removed all camera classes except ``Camera`` (``MappingCamera``, ``MovingCamera``, ``MultiCamera``) and all functions in ``ThreeDCamera``
- Implemented ``CameraFrame`` (as a ``Mobject``)
- Can be called by ``self.camera.frame`` in ``Scene``
- All methods of ``Mobject`` can be used, such as ``.shift()``, ``.scale()``, etc.
- Call ``.to_default_state()`` to place in the default position
- Set the Euler angles of the camera by ``.set_euler_angles(theta, phi, gamma)``
- Set three single Euler angles by ``.set_theta(theta)``, ``.set_phi(phi)``, ``.set_gamma(gamma)``
- Use ``.increment_theta(dtheta)``, ``.increment_phi(dphi)``, ``.increment_gamma(gamma)`` to increase the three Euler angles by a certain value. Can be used to realize automatic rotation ``self.camera.frame.add_updater(lambda mob, dt: mob.increment_theta(0.1 * dt))``
- ``Camera`` adds a light source, which is a ``Point``, which can be called by ``self.camera.light_source`` in ``Scene`` to move and so on. The default position is ``(- 10, 10, 10)``
- Delete ``Container``
- ``Mobject``
- ``svg`` related
- Added ``Checkmark`` and ``Exmark``
- Some unnecessary classes have been removed from ``drawings.py``
- Removed ``Code`` and ``Paragraph`` (by mistake)
- ``TexMobject`` is renamed to ``Tex``, ``TextMobject`` is renamed to ``TexText``
- ``font_size`` has been added to ``Tex``, ``TexText`` and ``Text``
- ``Tex`` and ``TexText`` added ``isolate``, which is a list, which will be automatically split
- Mobject ``types``
- Added a new class ``Surface``, which is the parent class of ``ParametricSurface`` and ``TexturedSurface``.
- Added the group ``SGroup`` for ``Surface``
- Added ``TexturedSurface(uv_surface, image_file, dark_image_file=None)``, where ``uv_surface`` is a ``Surface``, ``image_file`` is the image to be posted, and ``dark_image_file`` is the image to be posted in the dark (default and ``image_file`` is the same)
- Deleted ``Mobject1D``, ``Mobject2D``, ``PointCloudDot``
- Added ``DotCloud`` (a ``PMobject``), which has been greatly optimized
- Removed ``AbstractImageMobject``, ``ImageMobjectFromCamera``
- Removed ``sheen`` from ``VMobject``
- ``Mobject``
- Added ``gloss`` and ``shadow``, which are the numbers between ``[0, 1]`` respectively. There are four methods of ``.get_gloss()``, ``.set_gloss(gloss)``, ``.get_shadow()``, ``.set_shadow(shadow)``
- Added ``.get_grid(n_rows, n_cols)`` to copy into grid
- Added ``.set_color_by_code(glsl_code)`` to use GLSL code to change the color
- Added ``.set_color_by_xyz_func(glsl_snippet, min_value=-5.0, max_value=5.0, colormap="viridis")`` to pass in GLSL expression in the form of ``x,y,z``, the return value should be a floating point number
- Coordinate system (including ``Axes``, ``ThreeDAxes``, ``NumberPlane``, ``ComplexPlane``)
- No longer use ``x_min``, ``x_max``, ``y_min``, ``y_max``, but use ``x_range``, ``y_range`` as a ``np.array()``, containing three numbers ``np.array([ Minimum, maximum, step size])``
- Added the abbreviation ``.i2gp(x, graph)`` of ``.input_to_graph_point(x, graph)``
- Added some functions of the original ``GraphScene``
- Added ``.get_v_line(point)``, ``.get_h_line(point)`` to return the line from ``point`` to the two coordinate axes, and specify the line type through the keyword argument of ``line_func`` (default ``DashedLine``)
- Added ``.get_graph_label(graph, label, x, direction, buff, color)`` to return the label added to the image
- Added ``.get_v_line_to_graph(x, graph)``, ``.get_h_line_to_graph(x, graph)`` to return the line from the point with the abscissa of ``x`` on the ``graph`` to the two- axis line
- Added ``.angle_of_tangent(x, graph, dx=EPSILON)``, returns the inclination angle of ``graph`` at ``x``
- Added ``.slope_of_tangent(x, graph, dx=EPSILON)``, returns the slope of tangent line of ``graph`` at ``x``
- Added ``.get_tangent_line(x, graph, length=5)`` to return the tangent line of ``graph`` at ``x``
- Added ``.get_riemann_rectangles(graph, x_range, dx, input_sample_type, ...)`` to return Riemann rectangles (a ``VGroup``)
- The attribute ``number_line_config`` of ``Axes`` is renamed to ``axis_config``
- ``Axes`` original ``.get_coordinate_labels(x_values, y_values)`` method was renamed to ``.add_coordinate_labels(x_values, y_values)`` (but it is not added to the screen)
- ``.add_coordinate_labels(numbers)`` of ``ComplexPlane`` will directly add the coordinates to the screen
- ``NumberLine``
- No longer use ``x_min``, ``x_max``, ``tick_frequency``, but use ``x_range``, which is an array containing three numbers ``[min, max, step]``
- The original ``label_direction`` attribute changed to the ``line_to_number_direction`` attribute
- Replace ``tip_width`` and ``tip_height`` with ``tip_config`` (dictionary) attributes
- The original ``exclude_zero_from_default`` attribute is modified to the ``numbers_to_exclude`` attribute (default is None)
- The original ``.add_tick_marks()`` method was changed to the ``.add_ticks()`` method
- Delete the ``.get_number_mobjects(*numbers)`` method, only use the ``.add_numbers(x_values=None, excluding=None)`` method
- Three-dimensional objects
- Added ``SurfaceMesh(uv_surface)``, pass in a ``Surface`` to generate its uv mesh
- ``ParametricSurface`` no longer uses ``u_min, u_max, v_min, v_max``, but instead uses ``u_range, v_range``, which is a tuple (``(min, max)``), and ``resolution`` can be set larger, don’t worry Speed issue
- Added ``Torus``, controlled by ``r1, r2`` keyword parameters
- Added ``Cylinder``, controlled by ``height, radius`` keyword parameters
- Added ``Line3D`` (extremely thin cylinder), controlled by the ``width`` keyword parameter
- Added ``Disk3D``, controlled by ``radius`` keyword parameter
- Add ``Square3D``, controlled by ``side_length`` keyword parameter
- Improved ``Cube`` and ``Prism``, the usage remains unchanged
- Other objects
- ``ParametricFunction`` is renamed to ``ParametricCurve``. Instead of using ``t_min, t_max, step_size``, use ``t_range``, which is an array of three numbers (``[t_min, t_max, step_size]``). ``dt`` was renamed to ``epsilon``. Other usage remains unchanged
- All ``TipableVMobject`` can pass in ``tip_length`` to control the style of ``tip``
- ``Line`` adds ``.set_points_by_ends(start, end, buff=0, path_arc=0)`` method
- ``Line`` added ``.get_projection(point)`` to return the projection position of ``point`` on a straight line
- ``Arrow`` adds three attributes of ``thickness, tip_width_ratio, tip_angle``
- ``CubicBezier`` is changed to ``a0, h0, h1, a1``, that is, only a third-order Bezier curve is supported
- ``Square`` can be initialized directly by passing in ``side_length`` instead of using the keyword ``side_length=``
- ``always_redraw(func, *args, **kwargs)`` supports incoming parameters ``*args, **kwargs``
- The ``digit_to_digit_buff`` property of ``DecimalNumber`` has been renamed to ``digit_buff_per_font_unit``, and the ``.scale()`` method has been improved
- ``ValueTracker`` adds ``value_type`` attribute, the default is ``np.float64``
- ``Scene``
- Removed all functions of ``GraphScene`` (moved to ``once_useful_constructs``), ``MovingCameraScene``, ``ReconfigurableScene``, ``SceneFromVideo``, ``ZoomedScene``, and ``ThreeDScene``. Because these can basically be achieved by adjusting ``CameraFrame`` (``self.camera.frame``)
- Currently ``SampleSpaceScene`` and ``VectorScene`` have not been changed for the new version, so it is not recommended to use (only ``Scene`` is recommended)
- Fix the export of gif, just use the ``-i`` option directly
- Added the ``.interact()`` method, during which the mouse and keyboard can be used to continue the interaction, which will be executed by default after the scene ends
- Added ``.embed()`` method, open iPython terminal to enter interactive mode
- Added ``.save_state()`` method to save the current state of the scene
- Added ``.restore()`` method to restore the entire scene to the saved state
- ``utils``
- A series of functions related to second-order Bezier have been added to ``utils/bezier.py``
- Added a function to read color map from ``matplotlib`` in ``utils/color.py``
- Added a series of related functions for processing folders/custom styles/object families
- ``resize_array``, ``resize_preserving_order``, ``resize_with_interpolation`` three functions have been added to ``utils/iterables.py``
- The definition of ``smooth`` is updated in ``utils/rate_functions.py``
- ``clip(a, min_a, max_a)`` function has been added to ``utils/simple_functions.py``
- Some functions have been improved in ``utils/space_ops.py``, some functions for space calculation, and functions for processing triangulation have been added
- ``constants``
- Fixed the aspect ratio of the screen to 16:9
- Deleted the old gray series (``LIGHT_GREY``, ``GREY``, ``DARK_GREY``, ``DARKER_GREY``), added a new series of gray ``GREY_A`` ~ ``GREY_E``
================================================
FILE: docs/source/index.rst
================================================
Manim's documentation
=====================
.. image:: https://cdn.jsdelivr.net/gh/3b1b/manim@master/logo/white_with_name.png
Manim is an animation engine for explanatory math videos. It's used to create precise animations programmatically, as seen in the videos
at `3Blue1Brown <https://www.3blue1brown.com/>`_.
And here is a Chinese version of this documentation: https://docs.manim.org.cn/
.. toctree::
:maxdepth: 2
:caption: Getting Started
getting_started/installation
getting_started/quickstart
getting_started/configuration
getting_started/example_scenes
getting_started/config
getting_started/structure
getting_started/whatsnew
.. toctree::
:maxdepth: 2
:caption: Documentation
documentation/constants
documentation/custom_config
.. toctree::
:maxdepth: 2
:caption: Development
development/changelog
development/contributing
development/about
================================================
FILE: docs/source/manim_example_ext.py
================================================
from docutils import nodes
from docutils.parsers.rst import directives, Directive
import jinja2
import os
class skip_manim_node(nodes.Admonition, nodes.Element):
pass
def visit(self, node, name=""):
self.visit_admonition(node, name)
def depart(self, node):
self.depart_admonition(node)
class ManimExampleDirective(Directive):
has_content = True
required_arguments = 1
optional_arguments = 0
option_spec = {
"hide_code": bool,
"media": str,
}
final_argument_whitespace = True
def run(self):
hide_code = "hide_code" in self.options
scene_name = self.arguments[0]
media_file_name = self.options["media"]
source_block = [
".. code-block:: python",
"",
*[" " + line for line in self.content],
]
source_block = "\n".join(source_block)
state_machine = self.state_machine
document = state_machine.document
if any(media_file_name.endswith(ext) for ext in [".png", ".jpg", ".gif"]):
is_video = False
else:
is_video = True
rendered_template = jinja2.Template(TEMPLATE).render(
scene_name=scene_name,
scene_name_lowercase=scene_name.lower(),
hide_code=hide_code,
is_video=is_video,
media_file_name=media_file_name,
source_block=source_block,
)
state_machine.insert_input(
rendered_template.split("\n"), source=document.attributes["source"]
)
return []
def setup(app):
app.add_node(skip_manim_node, html=(visit, depart))
setup.app = app
setup.config = app.config
setup.confdir = app.confdir
app.add_directive("manim-example", ManimExampleDirective)
metadata = {"parallel_read_safe": False, "parallel_write_safe": True}
return metadata
TEMPLATE = r"""
{% if not hide_code %}
.. raw:: html
<div class="manim-example">
{% endif %}
{% if is_video %}
.. raw:: html
<video id="{{ scene_name_lowercase }}" class="manim-video" controls loop autoplay src="{{ media_file_name }}"></video>
{% else %}
.. image:: {{ media_file_name }}
:align: center
:name: {{ scene_name_lowercase }}
{% endif %}
{% if not hide_code %}
.. raw:: html
<h5 class="example-header">{{ scene_name }}<a class="headerlink" href="#{{ scene_name_lowercase }}">¶</a></h5>
{{ source_block }}
{% endif %}
.. raw:: html
</div>
"""
================================================
FILE: example_scenes.py
================================================
from manimlib import *
import numpy as np
# To watch one of these scenes, run the following:
# manimgl example_scenes.py OpeningManimExample
# Use -s to skip to the end and just save the final frame
# Use -w to write the animation to a file
# Use -o to write it to a file and open it once done
# Use -n <number> to skip ahead to the n'th animation of a scene.
class OpeningManimExample(Scene):
def construct(self):
intro_words = Text("""
The original motivation for manim was to
better illustrate mathematical functions
as transformations.
""")
intro_words.to_edge(UP)
self.play(Write(intro_words))
self.wait(2)
# Linear transform
grid = NumberPlane((-10, 10), (-5, 5))
matrix = [[1, 1], [0, 1]]
linear_transform_words = VGroup(
Text("This is what the matrix"),
IntegerMatrix(matrix),
Text("looks like")
)
linear_transform_words.arrange(RIGHT)
linear_transform_words.to_edge(UP)
linear_transform_words.set_backstroke(width=5)
self.play(
ShowCreation(grid),
FadeTransform(intro_words, linear_transform_words)
)
self.wait()
self.play(grid.animate.apply_matrix(matrix), run_time=3)
self.wait()
# Complex map
c_grid = ComplexPlane()
moving_c_grid = c_grid.copy()
moving_c_grid.prepare_for_nonlinear_transform()
c_grid.set_stroke(BLUE_E, 1)
c_grid.add_coordinate_labels(font_size=24)
complex_map_words = TexText("""
Or thinking of the plane as $\\mathds{C}$,\\\\
this is the map $z \\rightarrow z^2$
""")
complex_map_words.to_corner(UR)
complex_map_words.set_backstroke(width=5)
self.play(
FadeOut(grid),
Write(c_grid, run_time=3),
FadeIn(moving_c_grid),
FadeTransform(linear_transform_words, complex_map_words),
)
self.wait()
self.play(
moving_c_grid.animate.apply_complex_function(lambda z: z**2),
run_time=6,
)
self.wait(2)
class AnimatingMethods(Scene):
def construct(self):
grid = Tex(R"\pi").get_grid(10, 10, height=4)
self.add(grid)
# You can animate the application of mobject methods with the
# ".animate" syntax:
self.play(grid.animate.shift(LEFT))
# Both of those will interpolate between the mobject's initial
# state and whatever happens when you apply that method.
# For this example, calling grid.shift(LEFT) would shift the
# grid one unit to the left, but both of the previous calls to
# "self.play" animate that motion.
# The same applies for any method, including those setting colors.
self.play(grid.animate.set_color(YELLOW))
self.wait()
self.play(grid.animate.set_submobject_colors_by_gradient(BLUE, GREEN))
self.wait()
self.play(grid.animate.set_height(TAU - MED_SMALL_BUFF))
self.wait()
# The method Mobject.apply_complex_function lets you apply arbitrary
# complex functions, treating the points defining the mobject as
# complex numbers.
self.play(grid.animate.apply_complex_function(np.exp), run_time=5)
self.wait()
# Even more generally, you could apply Mobject.apply_function,
# which takes in functions form R^3 to R^3
self.play(
grid.animate.apply_function(
lambda p: [
p[0] + 0.5 * math.sin(p[1]),
p[1] + 0.5 * math.sin(p[0]),
p[2]
]
),
run_time=5,
)
self.wait()
class TextExample(Scene):
def construct(self):
# To run this scene properly, you should have "Consolas" font in your computer
# for full usage, you can see https://github.com/3b1b/manim/pull/680
text = Text("Here is a text", font="Consolas", font_size=90)
difference = Text(
"""
The most important difference between Text and TexText is that\n
you can change the font more easily, but can't use the LaTeX grammar
""",
font="Arial", font_size=24,
# t2c is a dict that you can choose color for different text
t2c={"Text": BLUE, "TexText": BLUE, "LaTeX": ORANGE}
)
VGroup(text, difference).arrange(DOWN, buff=1)
self.play(Write(text))
self.play(FadeIn(difference, UP))
self.wait(3)
fonts = Text(
"And you can also set the font according to different words",
font="Arial",
t2f={"font": "Consolas", "words": "Consolas"},
t2c={"font": BLUE, "words": GREEN}
)
fonts.set_width(FRAME_WIDTH - 1)
slant = Text(
"And the same as slant and weight",
font="Consolas",
t2s={"slant": ITALIC},
t2w={"weight": BOLD},
t2c={"slant": ORANGE, "weight": RED}
)
VGroup(fonts, slant).arrange(DOWN, buff=0.8)
self.play(FadeOut(text), FadeOut(difference, shift=DOWN))
self.play(Write(fonts))
self.wait()
self.play(Write(slant))
self.wait()
class TexTransformExample(Scene):
def construct(self):
# Tex to color map
t2c = {
"A": BLUE,
"B": TEAL,
"C": GREEN,
}
# Configuration to pass along to each Tex mobject
kw = dict(font_size=72, t2c=t2c)
lines = VGroup(
Tex("A^2 + B^2 = C^2", **kw),
Tex("A^2 = C^2 - B^2", **kw),
Tex("A^2 = (C + B)(C - B)", **kw),
Tex(R"A = \sqrt{(C + B)(C - B)}", **kw),
)
lines.arrange(DOWN, buff=LARGE_BUFF)
self.add(lines[0])
# The animation TransformMatchingStrings will line up parts
# of the source and target which have matching substring strings.
# Here, giving it a little path_arc makes each part rotate into
# their final positions, which feels appropriate for the idea of
# rearranging an equation
self.play(
TransformMatchingStrings(
lines[0].copy(), lines[1],
# matched_keys specifies which substring should
# line up. If it's not specified, the animation
# will align the longest matching substrings.
# In this case, the substring "^2 = C^2" would
# trip it up
matched_keys=["A^2", "B^2", "C^2"],
# When you want a substring from the source
# to go to a non-equal substring from the target,
# use the key map.
key_map={"+": "-"},
path_arc=90 * DEG,
),
)
self.wait()
self.play(TransformMatchingStrings(
lines[1].copy(), lines[2],
matched_keys=["A^2"]
))
self.wait()
self.play(
TransformMatchingStrings(
lines[2].copy(), lines[3],
key_map={"2": R"\sqrt"},
path_arc=-30 * DEG,
),
)
self.wait(2)
self.play(LaggedStartMap(FadeOut, lines, shift=2 * RIGHT))
# TransformMatchingShapes will try to line up all pieces of a
# source mobject with those of a target, regardless of the
# what Mobject type they are.
source = Text("the morse code", height=1)
target = Text("here come dots", height=1)
saved_source = source.copy()
self.play(Write(source))
self.wait()
kw = dict(run_time=3, path_arc=PI / 2)
self.play(TransformMatchingShapes(source, target, **kw))
self.wait()
self.play(TransformMatchingShapes(target, saved_source, **kw))
self.wait()
class TexIndexing(Scene):
def construct(self):
# You can index into Tex mobject (or other StringMobjects) by substrings
equation = Tex(R"e^{\pi i} = -1", font_size=144)
self.add(equation)
self.play(FlashAround(equation["e"]))
self.wait()
self.play(Indicate(equation[R"\pi"]))
self.wait()
self.play(TransformFromCopy(
equation[R"e^{\pi i}"].copy().set_opacity(0.5),
equation["-1"],
path_arc=-PI / 2,
run_time=3
))
self.play(FadeOut(equation))
# Or regular expressions
equation = Tex("A^2 + B^2 = C^2", font_size=144)
self.play(Write(equation))
for part in equation[re.compile(r"\w\^2")]:
self.play(FlashAround(part))
self.wait()
self.play(FadeOut(equation))
# Indexing by substrings like this may not work when
# the order in which Latex draws symbols does not match
# the order in which they show up in the string.
# For example, here the infinity is drawn before the sigma
# so we don't get the desired behavior.
equation = Tex(R"\sum_{n = 1}^\infty \frac{1}{n^2} = \frac{\pi^2}{6}", font_size=72)
self.play(FadeIn(equation))
self.play(equation[R"\infty"].animate.set_color(RED)) # Doesn't hit the infinity
self.wait()
self.play(FadeOut(equation))
# However you can always fix this by explicitly passing in
# a string you might want to isolate later. Also, using
# \over instead of \frac helps to avoid the issue for fractions
equation = Tex(
R"\sum_{n = 1}^\infty {1 \over n^2} = {\pi^2 \over 6}",
# Explicitly mark "\infty" as a substring you might want to access
isolate=[R"\infty"],
font_size=72
)
self.play(FadeIn(equation))
self.play(equation[R"\infty"].animate.set_color(RED)) # Got it!
self.wait()
self.play(FadeOut(equation))
class UpdatersExample(Scene):
def construct(self):
square = Square()
square.set_fill(BLUE_E, 1)
# On all frames, the constructor Brace(square, UP) will
# be called, and the mobject brace will set its data to match
# that of the newly constructed object
brace = always_redraw(Brace, square, UP)
label = TexText("Width = 0.00")
number = label.make_number_changeable("0.00")
# This ensures that the method deicmal.next_to(square)
# is called on every frame
label.always.next_to(brace, UP)
# You could also write the following equivalent line
# label.add_updater(lambda m: m.next_to(brace, UP))
# If the argument itself might change, you can use f_always,
# for which the arguments following the initial Mobject method
# should be functions returning arguments to that method.
# The following line ensures thst decimal.set_value(square.get_y())
# is called every frame
number.f_always.set_value(square.get_width)
# You could also write the following equivalent line
# number.add_updater(lambda m: m.set_value(square.get_width()))
self.add(square, brace, label)
# Notice that the brace and label track with the square
self.play(
square.animate.scale(2),
rate_func=there_and_back,
run_time=2,
)
self.wait()
self.play(
square.animate.set_width(5, stretch=True),
run_time=3,
)
self.wait()
self.play(
square.animate.set_width(2),
run_time=3
)
self.wait()
# In general, you can always call Mobject.add_updater, and pass in
# a function that you want to be called on every frame. The function
# should take in either one argument, the mobject, or two arguments,
# the mobject and the amount of time since the last frame.
now = self.time
w0 = square.get_width()
square.add_updater(
lambda m: m.set_width(w0 * math.sin(self.time - now) + w0)
)
self.wait(4 * PI)
class CoordinateSystemExample(Scene):
def construct(self):
axes = Axes(
# x-axis ranges from -1 to 10, with a default step size of 1
x_range=(-1, 10),
# y-axis ranges from -2 to 2 with a step size of 0.5
y_range=(-2, 2, 0.5),
# The axes will be stretched so as to match the specified
# height and width
height=6,
width=10,
# Axes is made of two NumberLine mobjects. You can specify
# their configuration with axis_config
axis_config=dict(
stroke_color=GREY_A,
stroke_width=2,
numbers_to_exclude=[0],
),
# Alternatively, you can specify configuration for just one
# of them, like this.
y_axis_config=dict(
big_tick_numbers=[-2, 2],
)
)
# Keyword arguments of add_coordinate_labels can be used to
# configure the DecimalNumber mobjects which it creates and
# adds to the axes
axes.add_coordinate_labels(
font_size=20,
num_decimal_places=1,
)
self.add(axes)
# Axes descends from the CoordinateSystem class, meaning
# you can call call axes.coords_to_point, abbreviated to
# axes.c2p, to associate a set of coordinates with a point,
# like so:
dot = Dot(fill_color=RED)
dot.move_to(axes.c2p(0, 0))
self.play(FadeIn(dot, scale=0.5))
self.play(dot.animate.move_to(axes.c2p(3, 2)))
self.wait()
self.play(dot.animate.move_to(axes.c2p(5, 0.5)))
self.wait()
# Similarly, you can call axes.point_to_coords, or axes.p2c
# print(axes.p2c(dot.get_center()))
# We can draw lines from the axes to better mark the coordinates
# of a given point.
# Here, the always_redraw command means that on each new frame
# the lines will be redrawn
h_line = always_redraw(lambda: axes.get_h_line(dot.get_left()))
v_line = always_redraw(lambda: axes.get_v_line(dot.get_bottom()))
self.play(
ShowCreation(h_line),
ShowCreation(v_line),
)
self.play(dot.animate.move_to(axes.c2p(3, -2)))
self.wait()
self.play(dot.animate.move_to(axes.c2p(1, 1)))
self.wait()
# If we tie the dot to a particular set of coordinates, notice
# that as we move the axes around it respects the coordinate
# system defined by them.
f_always(dot.move_to, lambda: axes.c2p(1, 1))
self.play(
axes.animate.scale(0.75).to_corner(UL),
run_time=2,
)
self.wait()
self.play(FadeOut(VGroup(axes, dot, h_line, v_line)))
# Other coordinate systems you can play around with include
# ThreeDAxes, NumberPlane, and ComplexPlane.
class GraphExample(Scene):
def construct(self):
axes = Axes((-3, 10), (-1, 8), height=6)
axes.add_coordinate_labels()
self.play(Write(axes, lag_ratio=0.01, run_time=1))
# Axes.get_graph will return the graph of a function
sin_graph = axes.get_graph(
lambda x: 2 * math.sin(x),
color=BLUE,
)
# By default, it draws it so as to somewhat smoothly interpolate
# between sampled points (x, f(x)). If the graph is meant to have
# a corner, though, you can set use_smoothing to False
relu_graph = axes.get_graph(
lambda x: max(x, 0),
use_smoothing=False,
color=YELLOW,
)
# For discontinuous functions, you can specify the point of
# discontinuity so that it does not try to draw over the gap.
step_graph = axes.get_graph(
lambda x: 2.0 if x > 3 else 1.0,
discontinuities=[3],
color=GREEN,
)
# Axes.get_graph_label takes in either a string or a mobject.
# If it's a string, it treats it as a LaTeX expression. By default
# it places the label next to the graph near the right side, and
# has it match the color of the graph
sin_label = axes.get_graph_label(sin_graph, "\\sin(x)")
relu_label = axes.get_graph_label(relu_graph, Text("ReLU"))
step_label = axes.get_graph_label(step_graph, Text("Step"), x=4)
self.play(
ShowCreation(sin_graph),
FadeIn(sin_label, RIGHT),
)
self.wait(2)
self.play(
ReplacementTransform(sin_graph, relu_graph),
FadeTransform(sin_label, relu_label),
)
self.wait()
self.play(
ReplacementTransform(relu_graph, step_graph),
FadeTransform(relu_label, step_label),
)
self.wait()
parabola = axes.get_graph(lambda x: 0.25 * x**2)
parabola.set_stroke(BLUE)
self.play(
FadeOut(step_graph),
FadeOut(step_label),
ShowCreation(parabola)
)
self.wait()
# You can use axes.input_to_graph_point, abbreviated
# to axes.i2gp, to find a particular point on a graph
dot = Dot(fill_color=RED)
dot.move_to(axes.i2gp(2, parabola))
self.play(FadeIn(dot, scale=0.5))
# A value tracker lets us animate a parameter, usually
# with the intent of having other mobjects update based
# on the parameter
x_tracker = ValueTracker(2)
dot.add_updater(lambda d: d.move_to(axes.i2gp(x_tracker.get_value(), parabola)))
self.play(x_tracker.animate.set_value(4), run_time=3)
self.play(x_tracker.animate.set_value(-2), run_time=3)
self.wait()
class TexAndNumbersExample(Scene):
def construct(self):
axes = Axes((-3, 3), (-3, 3), unit_size=1)
axes.to_edge(DOWN)
axes.add_coordinate_labels(font_size=16)
circle = Circle(radius=2)
circle.set_stroke(YELLOW, 3)
circle.move_to(axes.get_origin())
self.add(axes, circle)
# When numbers show up in tex, they can be readily
# replaced with DecimalMobjects so that methods like
# get_value and set_value can be called on them, and
# animations like ChangeDecimalToValue can be called
# on them.
tex = Tex("x^2 + y^2 = 4.00")
tex.next_to(axes, UP, buff=0.5)
value = tex.make_number_changeable("4.00")
# This will tie the right hand side of our equation to
# the square of the radius of the circle
value.add_updater(lambda v: v.set_value(circle.get_radius()**2))
self.add(tex)
text = Text("""
You can manipulate numbers
in Tex mobjects
""", font_size=30)
text.next_to(tex, RIGHT, buff=1.5)
arrow = Arrow(text, tex)
self.add(text, arrow)
self.play(
circle.animate.set_height(2.0),
run_time=4,
rate_func=there_and_back,
)
# By default, tex.make_number_changeable replaces the first occurrence
# of the number,but by passing replace_all=True it replaces all and
# returns a group of the results
exponents = tex.make_number_changeable("2", replace_all=True)
self.play(
LaggedStartMap(
FlashAround, exponents,
lag_ratio=0.2, buff=0.1, color=RED
),
exponents.animate.set_color(RED)
)
def func(x, y):
# Switch from manim coords to axes coords
xa, ya = axes.point_to_coords(np.array([x, y, 0]))
return xa**4 + ya**4 - 4
new_curve = ImplicitFunction(func)
new_curve.match_style(circle)
circle.rotate(angle_of_vector(new_curve.get_start())) # Align
value.clear_updaters()
self.play(
*(ChangeDecimalToValue(exp, 4) for exp in exponents),
ReplacementTransform(circle.copy(), new_curve),
circle.animate.set_stroke(width=1, opacity=0.5),
)
class SurfaceExample(ThreeDScene):
def construct(self):
surface_text = Text("For 3d scenes, try using surfaces")
surface_text.fix_in_frame()
surface_text.to_edge(UP)
self.add(surface_text)
self.wait(0.1)
torus1 = Torus(r1=1, r2=1)
torus2 = Torus(r1=3, r2=1)
sphere = Sphere(radius=3, resolution=torus1.resolution)
# You can texture a surface with up to two images, which will
# be interpreted as the side towards the light, and away from
# the light. These can be either urls, or paths to a local file
# in whatever you've set as the image directory in
# the custom_config.yml file
# day_texture = "EarthTextureMap"
# night_texture = "NightEarthTextureMap"
day_texture = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Whole_world_-_land_and_oceans.jpg/1280px-Whole_world_-_land_and_oceans.jpg"
night_texture = "https://upload.wikimedia.org/wikipedia/commons/thumb/b/ba/The_earth_at_night.jpg/1280px-The_earth_at_night.jpg"
surfaces = [
TexturedSurface(surface, day_texture, night_texture)
for surface in [sphere, torus1, torus2]
]
for mob in surfaces:
mob.shift(IN)
mob.mesh = SurfaceMesh(mob)
mob.mesh.set_stroke(BLUE, 1, opacity=0.5)
surface = surfaces[0]
self.play(
FadeIn(surface),
ShowCreation(surface.mesh, lag_ratio=0.01, run_time=3),
)
for mob in surfaces:
mob.add(mob.mesh)
surface.save_state()
self.play(Rotate(surface, PI / 2), run_time=2)
for mob in surfaces[1:]:
mob.rotate(PI / 2)
self.play(
Transform(surface, surfaces[1]),
run_time=3
)
self.play(
Transform(surface, surfaces[2]),
# Move camera frame during the transition
self.frame.animate.increment_phi(-10 * DEG),
self.frame.animate.increment_theta(-20 * DEG),
run_time=3
)
# Add ambient rotation
self.frame.add_updater(lambda m, dt: m.increment_theta(-0.1 * dt))
# Play around with where the light is
light_text = Text("You can move around the light source")
light_text.move_to(surface_text)
light_text.fix_in_frame()
self.play(FadeTransform(surface_text, light_text))
light = self.camera.light_source
light_dot = GlowDot(color=WHITE, radius=0.5)
light_dot.always.move_to(light)
self.add(light, light_dot)
light.save_state()
self.play(light.animate.move_to(3 * IN), run_time=5)
self.play(light.animate.shift(10 * OUT), run_time=5)
drag_text = Text("Try moving the mouse while pressing d or f")
drag_text.move_to(light_text)
drag_text.fix_in_frame()
self.play(FadeTransform(light_text, drag_text))
self.wait()
class InteractiveDevelopment(Scene):
def construct(self):
circle = Circle()
circle.set_fill(BLUE, opacity=0.5)
circle.set_stroke(BLUE_E, width=4)
square = Square()
self.play(ShowCreation(square))
self.wait()
# This opens an iPython terminal where you can keep writing
# lines as if they were part of this construct method.
# In particular, 'square', 'circle' and 'self' will all be
# part of the local namespace in that terminal.
self.embed()
# Try copying and pasting some of the lines below into
# the interactive shell
self.play(ReplacementTransform(square, circle))
self.wait()
self.play(circle.animate.stretch(4, 0))
self.play(Rotate(circle, 90 * DEG))
self.play(circle.animate.shift(2 * RIGHT).scale(0.25))
text = Text("""
In general, using the interactive shell
is very helpful when developing new scenes
""")
self.play(Write(text))
# In the interactive shell, you can just type
# play, add, remove, clear, wait, save_state and restore,
# instead of self.play, self.add, self.remove, etc.
# To interact with the window, type touch(). You can then
# scroll in the window, or zoom by holding down 'z' while scrolling,
# and change camera perspective by holding down 'd' while moving
# the mouse. Press 'r' to reset to the standard camera position.
# Press 'q' to stop interacting with the window and go back to
# typing new commands into the shell.
# In principle you can customize a scene to be responsive to
# mouse and keyboard interactions
always(circle.move_to, self.mouse_point)
class ControlsExample(Scene):
drag_to_pan = False
def setup(self):
self.textbox = Textbox()
self.checkbox = Checkbox()
self.color_picker = ColorSliders()
self.panel = ControlPanel(
Text("Text", font_size=24), self.textbox, Line(),
Text("Show/Hide Text", font_size=24), self.checkbox, Line(),
Text("Color of Text", font_size=24), self.color_picker
)
self.add(self.panel)
def construct(self):
text = Text("text", font_size=96)
def text_updater(old_text):
assert(isinstance(old_text, Text))
new_text = Text(self.textbox.get_value(), font_size=old_text.font_size)
# new_text.align_data_and_family(old_text)
new_text.move_to(old_text)
if self.checkbox.get_value():
new_text.set_fill(
color=self.color_picker.get_picked_color(),
opacity=self.color_picker.get_picked_opacity()
)
else:
new_text.set_opacity(0)
old_text.become(new_text)
text.add_updater(text_updater)
self.add(MotionMobject(text))
self.textbox.set_value("Manim")
# self.wait(60)
# self.embed()
# See https://github.com/3b1b/videos for many, many more
================================================
FILE: logo/logo.py
================================================
from manimlib.imports import *
NEW_BLUE = "#68a8e1"
class Thumbnail(GraphScene):
CONFIG = {
"y_max": 8,
"y_axis_height": 5,
}
def construct(self):
self.show_function_graph()
def show_function_graph(self):
self.setup_axes(animate=False)
def func(x):
return 0.1 * (x + 3-5) * (x - 3-5) * (x-5) + 5
def rect(x):
return 2.775*(x-1.5)+3.862
recta = self.get_graph(rect,x_min=-1,x_max=5)
graph = self.get_graph(func,x_min=0.2,x_max=9)
graph.set_color(NEW_BLUE)
input_tracker_p1 = ValueTracker(1.5)
input_tracker_p2 = ValueTracker(3.5)
def get_x_value(input_tracker):
return input_tracker.get_value()
def get_y_value(input_tracker):
return graph.underlying_function(get_x_value(input_tracker))
def get_x_point(input_tracker):
return self.coords_to_point(get_x_value(input_tracker), 0)
def get_y_point(input_tracker):
return self.coords_to_point(0, get_y_value(input_tracker))
def get_graph_point(input_tracker):
return self.coords_to_point(get_x_value(input_tracker), get_y_value(input_tracker))
def get_v_line(input_tracker):
return DashedLine(get_x_point(input_tracker), get_graph_point(input_tracker), stroke_width=2)
def get_h_line(input_tracker):
return DashedLine(get_graph_point(input_tracker), get_y_point(input_tracker), stroke_width=2)
#
input_triangle_p1 = RegularPolygon(n=3, start_angle=TAU / 4)
output_triangle_p1 = RegularPolygon(n=3, start_angle=0)
for triangle in input_triangle_p1, output_triangle_p1:
triangle.set_fill(WHITE, 1)
triangle.set_stroke(width=0)
triangle.scale(0.1)
#
input_triangle_p2 = RegularPolygon(n=3, start_angle=TAU / 4)
output_triangle_p2 = RegularPolygon(n=3, start_angle=0)
for triangle in input_triangle_p2, output_triangle_p2:
triangle.set_fill(WHITE, 1)
triangle.set_stroke(width=0)
triangle.scale(0.1)
#
x_label_p1 = Tex("a")
output_label_p1 = Tex("f(a)")
x_label_p2 = Tex("b")
output_label_p2 = Tex("f(b)")
v_line_p1 = get_v_line(input_tracker_p1)
v_line_p2 = get_v_line(input_tracker_p2)
h_line_p1 = get_h_line(input_tracker_p1)
h_line_p2 = get_h_line(input_tracker_p2)
graph_dot_p1 = Dot(color=WHITE)
graph_dot_p2 = Dot(color=WHITE)
# reposition mobjects
x_label_p1.next_to(v_line_p1, DOWN)
x_label_p2.next_to(v_line_p2, DOWN)
output_label_p1.next_to(h_line_p1, LEFT)
output_label_p2.next_to(h_line_p2, LEFT)
input_triangle_p1.next_to(v_line_p1, DOWN, buff=0)
input_triangle_p2.next_to(v_line_p2, DOWN, buff=0)
output_triangle_p1.next_to(h_line_p1, LEFT, buff=0)
output_triangle_p2.next_to(h_line_p2, LEFT, buff=0)
graph_dot_p1.move_to(get_graph_point(input_tracker_p1))
graph_dot_p2.move_to(get_graph_point(input_tracker_p2))
#
self.play(
ShowCreation(graph),
)
# Animacion del punto a
self.add_foreground_mobject(graph_dot_p1)
self.add_foreground_mobject(graph_dot_p2)
self.play(
DrawBorderThenFill(input_triangle_p1),
Write(x_label_p1),
ShowCreation(v_line_p1),
GrowFromCenter(graph_dot_p1),
ShowCreation(h_line_p1),
Write(output_label_p1),
DrawBorderThenFill(output_triangle_p1),
DrawBorderThenFill(input_triangle_p2),
Write(x_label_p2),
ShowCreation(v_line_p2),
GrowFromCenter(graph_dot_p2),
ShowCreation(h_line_p2),
Write(output_label_p2),
DrawBorderThenFill(output_triangle_p2),
run_time=0.5
)
self.add(
input_triangle_p2,
x_label_p2,
graph_dot_p2,
v_line_p2,
h_line_p2,
output_triangle_p2,
output_label_p2,
)
###################
pendiente_recta = self.get_secant_slope_group(
1.9, recta, dx = 1.4,
df_label = None,
dx_label = None,
dx_line_color = PURPLE,
df_line_color= ORANGE,
)
grupo_secante = self.get_secant_slope_group(
1.5, graph, dx = 2,
df_label = None,
dx_label = None,
dx_line_color = "#942357",
df_line_color= "#3f7d5c",
secant_line_color = RED,
)
self.add(
input_triangle_p2,
graph_dot_p2,
v_line_p2,
h_line_p2,
output_triangle_p2,
)
self.play(FadeIn(grupo_secante))
kwargs = {
"x_min" : 4,
"x_max" : 9,
"fill_opacity" : 0.75,
"stroke_width" : 0.25,
}
self.graph=graph
iteraciones=6
self.rect_list = self.get_riemann_rectangles_list(
graph, iteraciones,start_color=PURPLE,end_color=ORANGE, **kwargs
)
flat_rects = self.get_riemann_rectangles(
self.get_graph(lambda x : 0), dx = 0.5,start_color=invert_color(PURPLE),end_color=invert_color(ORANGE),**kwargs
)
rects = self.rect_list[0]
self.transform_between_riemann_rects(
flat_rects, rects,
replace_mobject_with_target_in_scene = True,
run_time=0.9
)
# adding manim
picture = Group(*self.mobjects)
picture.scale(0.6).to_edge(LEFT, buff=SMALL_BUFF)
manim = TexText("Manim").set_height(1.5) \
.next_to(picture, RIGHT) \
.shift(DOWN * 0.7)
self.add(manim)
================================================
FILE: manimlib/__init__.py
================================================
try:
from importlib.metadata import version, PackageNotFoundError
except ImportError: # For Python <3.8 fallback
from importlib_metadata import version, PackageNotFoundError # type: ignore
try:
__version__ = version("manimgl")
except PackageNotFoundError:
__version__ = "unknown"
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from manimlib.typing import *
from manimlib.constants import *
from manimlib.window import *
from manimlib.animation.animation import *
from manimlib.animation.composition import *
from manimlib.animation.creation import *
from manimlib.animation.fading import *
from manimlib.animation.growing import *
from manimlib.animation.indication import *
from manimlib.animation.movement import *
from manimlib.animation.numbers import *
from manimlib.animation.rotation import *
from manimlib.animation.specialized import *
from manimlib.animation.transform import *
from manimlib.animation.transform_matching_parts import *
from manimlib.animation.update import *
from manimlib.camera.camera import *
from manimlib.mobject.boolean_ops import *
from manimlib.mobject.changing import *
from manimlib.mobject.coordinate_systems import *
from manimlib.mobject.frame import *
from manimlib.mobject.functions import *
from manimlib.mobject.geometry import *
from manimlib.mobject.interactive import *
from manimlib.mobject.matrix import *
from manimlib.mobject.mobject import *
from manimlib.mobject.mobject_update_utils import *
from manimlib.mobject.number_line import *
from manimlib.mobject.numbers import *
from manimlib.mobject.probability import *
from manimlib.mobject.shape_matchers import *
from manimlib.mobject.svg.brace import *
from manimlib.mobject.svg.drawings import *
from manimlib.mobject.svg.string_mobject import *
from manimlib.mobject.svg.svg_mobject import *
from manimlib.mobject.svg.special_tex import *
from manimlib.mobject.svg.tex_mobject import *
from manimlib.mobject.svg.text_mobject import *
from manimlib.mobject.three_dimensions import *
from manimlib.mobject.types.dot_cloud import *
from manimlib.mobject.types.image_mobject import *
from manimlib.mobject.types.point_cloud_mobject import *
from manimlib.mobject.types.surface import *
from manimlib.mobject.types.vectorized_mobject import *
from manimlib.mobject.value_tracker import *
from manimlib.mobject.vector_field import *
from manimlib.scene.interactive_scene import *
from manimlib.scene.scene import *
from manimlib.utils.bezier import *
from manimlib.utils.cache import *
from manimlib.utils.color import *
from manimlib.utils.dict_ops import *
from manimlib.utils.debug import *
from manimlib.utils.directories import *
from manimlib.utils.file_ops import *
from manimlib.utils.images import *
from manimlib.utils.iterables import *
from manimlib.utils.paths import *
from manimlib.utils.rate_functions import *
from manimlib.utils.simple_functions import *
from manimlib.utils.shaders import *
from manimlib.utils.sounds import *
from manimlib.utils.space_ops import *
from manimlib.utils.tex import *
================================================
FILE: manimlib/__main__.py
================================================
#!/usr/bin/env python
from addict import Dict
from manimlib import __version__
from manimlib.config import manim_config
from manimlib.config import parse_cli
import manimlib.extract_scene
from manimlib.utils.cache import clear_cache
from manimlib.window import Window
from IPython.terminal.embed import KillEmbedded
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from argparse import Namespace
def run_scenes():
"""
Runs the scenes in a loop and detects when a scene reload is requested.
"""
# Create a new dict to be able to upate without
# altering global configuration
scene_config = Dict(manim_config.scene)
run_config = manim_config.run
if run_config.show_in_window:
# Create a reusable window
window = Window(**manim_config.window)
scene_config.update(window=window)
while True:
try:
# Blocking call since a scene may init an IPython shell()
scenes = manimlib.extract_scene.main(scene_config, run_config)
for scene in scenes:
scene.run()
return
except KillEmbedded:
# Requested via the `exit_raise` IPython runline magic
# by means of the reload_scene() command
pass
except KeyboardInterrupt:
break
def main():
"""
Main entry point for ManimGL.
"""
print(f"ManimGL \033[32mv{__version__}\033[0m")
args = parse_cli()
if args.version and args.file is None:
return
if args.clear_cache:
clear_cache()
run_scenes()
if __name__ == "__main__":
main()
================================================
FILE: manimlib/animation/__init__.py
================================================
================================================
FILE: manimlib/animation/animation.py
================================================
from __future__ import annotations
from copy import deepcopy
from manimlib.mobject.mobject import _AnimationBuilder
from manimlib.mobject.mobject import Mobject
from manimlib.utils.iterables import remove_list_redundancies
from manimlib.utils.rate_functions import smooth
from manimlib.utils.simple_functions import clip
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from typing import Callable
from manimlib.scene.scene import Scene
DEFAULT_ANIMATION_RUN_TIME = 1.0
DEFAULT_ANIMATION_LAG_RATIO = 0
class Animation(object):
def __init__(
self,
mobject: Mobject,
run_time: float = DEFAULT_ANIMATION_RUN_TIME,
# Tuple of times, between which the animation will run
time_span: tuple[float, float] | None = None,
# If 0, the animation is applied to all submobjects at the same time
# If 1, it is applied to each successively.
# If 0 < lag_ratio < 1, its applied to each with lagged start times
lag_ratio: float = DEFAULT_ANIMATION_LAG_RATIO,
rate_func: Callable[[float], float] = smooth,
name: str = "",
# Does this animation add or remove a mobject from the screen
remover: bool = False,
# What to enter into the update function upon completion
final_alpha_value: float = 1.0,
# If set to True, the mobject itself will have its internal updaters called,
# but the start or target mobjects would not be suspended. To completely suspend
# updating, call mobject.suspend_updating() before the animation
suspend_mobject_updating: bool = False,
):
self._validate_input_type(mobject)
self.mobject = mobject
self.run_time = run_time
self.time_span = time_span
self.rate_func = rate_func
self.name = name or self.__class__.__name__ + str(self.mobject)
self.remover = remover
self.final_alpha_value = final_alpha_value
self.lag_ratio = lag_ratio
self.suspend_mobject_updating = suspend_mobject_updating
def _validate_input_type(self, mobject: Mobject) -> None:
if not isinstance(mobject, Mobject):
raise TypeError("Animation only works for Mobjects.")
def __str__(self) -> str:
return self.name
def begin(self) -> None:
# This is called right as an animation is being
# played. As much initialization as possible,
# especially any mobject copying, should live in
# this method
if self.time_span is not None:
start, end = self.time_span
self.run_time = max(end, self.run_time)
self.mobject.set_animating_status(True)
self.starting_mobject = self.create_starting_mobject()
if self.suspend_mobject_updating:
self.mobject_was_updating = not self.mobject.updating_suspended
self.mobject.suspend_updating()
self.families = list(self.get_all_families_zipped())
self.interpolate(0)
def finish(self) -> None:
self.interpolate(self.final_alpha_value)
self.mobject.set_animating_status(False)
if self.suspend_mobject_updating and self.mobject_was_updating:
self.mobject.resume_updating()
def clean_up_from_scene(self, scene: Scene) -> None:
if self.is_remover():
scene.remove(self.mobject)
def create_starting_mobject(self) -> Mobject:
# Keep track of where the mobject starts
return self.mobject.copy()
def get_all_mobjects(self) -> tuple[Mobject, Mobject]:
"""
Ordering must match the ording of arguments to interpolate_submobject
"""
return self.mobject, self.starting_mobject
def get_all_families_zipped(self) -> zip[tuple[Mobject]]:
return zip(*[
mob.get_family()
for mob in self.get_all_mobjects()
])
def update_mobjects(self, dt: float) -> None:
"""
Updates things like starting_mobject, and (for
Transforms) target_mobject.
"""
for mob in self.get_all_mobjects_to_update():
mob.update(dt)
def get_all_mobjects_to_update(self) -> list[Mobject]:
# The surrounding scene typically handles
# updating of self.mobject.
items = list(filter(
lambda m: m is not self.mobject,
self.get_all_mobjects()
))
items = remove_list_redundancies(items)
return items
def copy(self):
return deepcopy(self)
def update_rate_info(
self,
run_time: float | None = None,
rate_func: Callable[[float], float] | None = None,
lag_ratio: float | None = None,
):
self.run_time = run_time or self.run_time
self.rate_func = rate_func or self.rate_func
self.lag_ratio = lag_ratio or self.lag_ratio
return self
# Methods for interpolation, the mean of an Animation
def interpolate(self, alpha: float) -> None:
self.interpolate_mobject(alpha)
def update(self, alpha: float) -> None:
"""
This method shouldn't exist, but it's here to
keep many old scenes from breaking
"""
self.interpolate(alpha)
def time_spanned_alpha(self, alpha: float) -> float:
if self.time_span is not None:
start, end = self.time_span
return clip(alpha * self.run_time - start, 0, end - start) / (end - start)
return alpha
def interpolate_mobject(self, alpha: float) -> None:
for i, mobs in enumerate(self.families):
sub_alpha = self.get_sub_alpha(self.time_spanned_alpha(alpha), i, len(self.families))
self.interpolate_submobject(*mobs, sub_alpha)
def interpolate_submobject(
self,
submobject: Mobject,
starting_submobject: Mobject,
alpha: float
):
# Typically ipmlemented by subclass
pass
def get_sub_alpha(
self,
alpha: float,
index: int,
num_submobjects: int
) -> float:
# TODO, make this more understanable, and/or combine
# its functionality with AnimationGroup's method
# build_animations_with_timings
lag_ratio = self.lag_ratio
full_length = (num_submobjects - 1) * lag_ratio + 1
value = alpha * full_length
lower = index * lag_ratio
raw_sub_alpha = clip((value - lower), 0, 1)
return self.rate_func(raw_sub_alpha)
# Getters and setters
def set_run_time(self, run_time: float):
self.run_time = run_time
return self
def get_run_time(self) -> float:
if self.time_span:
return max(self.run_time, self.time_span[1])
return self.run_time
def set_rate_func(self, rate_func: Callable[[float], float]):
self.rate_func = rate_func
return self
def get_rate_func(self) -> Callable[[float], float]:
return self.rate_func
def set_name(self, name: str):
self.name = name
return self
def is_remover(self) -> bool:
return self.remover
def prepare_animation(anim: Animation | _AnimationBuilder):
if isinstance(anim, _AnimationBuilder):
return anim.build()
if isinstance(anim, Animation):
return anim
raise TypeError(f"Object {anim} cannot be converted to an animation")
================================================
FILE: manimlib/animation/composition.py
================================================
from __future__ import annotations
from manimlib.animation.animation import Animation
from manimlib.animation.animation import prepare_animation
from manimlib.mobject.mobject import _AnimationBuilder
from manimlib.mobject.mobject import Group
from manimlib.mobject.types.vectorized_mobject import VGroup
from manimlib.mobject.types.vectorized_mobject import VMobject
from manimlib.utils.bezier import integer_interpolate
from manimlib.utils.bezier import interpolate
from manimlib.utils.iterables import remove_list_redundancies
from manimlib.utils.simple_functions import clip
from typing import TYPE_CHECKING, Union, Iterable
AnimationType = Union[Animation, _AnimationBuilder]
if TYPE_CHECKING:
from typing import Callable, Optional
from manimlib.mobject.mobject import Mobject
from manimlib.scene.scene import Scene
DEFAULT_LAGGED_START_LAG_RATIO = 0.05
class AnimationGroup(Animation):
def __init__(
self,
*args: AnimationType | Iterable[AnimationType],
run_time: float = -1, # If negative, default to sum of inputed animation runtimes
lag_ratio: float = 0.0,
group: Optional[Mobject] = None,
group_type: Optional[type] = None,
**kwargs
):
animations = args[0] if isinstance(args[0], Iterable) else args
self.animations = [prepare_animation(anim) for anim in animations]
self.build_animations_with_timings(lag_ratio)
self.max_end_time = max((awt[2] for awt in self.anims_with_timings), default=0)
self.run_time = self.max_end_time if run_time < 0 else run_time
self.lag_ratio = lag_ratio
mobs = remove_list_redundancies([a.mobject for a in self.animations])
if group is not None:
self.group = group
elif group_type is not None:
self.group = group_type(*mobs)
elif all(isinstance(anim.mobject, VMobject) for anim in animations):
self.group = VGroup(*mobs)
else:
self.group = Group(*mobs)
super().__init__(
self.group,
run_time=self.run_time,
lag_ratio=lag_ratio,
**kwargs
)
def get_all_mobjects(self) -> Mobject:
return self.group
def begin(self) -> None:
self.group.set_animating_status(True)
for anim in self.animations:
anim.begin()
# self.init_run_time()
def finish(self) -> None:
self.group.set_animating_status(False)
for anim in self.animations:
anim.finish()
def clean_up_from_scene(self, scene: Scene) -> None:
for anim in self.animations:
anim.clean_up_from_scene(scene)
def update_mobjects(self, dt: float) -> None:
for anim in self.animations:
anim.update_mobjects(dt)
def calculate_max_end_time(self) -> None:
self.max_end_time = max(
(awt[2] for awt in self.anims_with_timings),
default=0,
)
if self.run_time < 0:
self.run_time = self.max_end_time
def build_animations_with_timings(self, lag_ratio: float) -> None:
"""
Creates a list of triplets of the form
(anim, start_time, end_time)
"""
self.anims_with_timings = []
curr_time = 0
for anim in self.animations:
start_time = curr_time
end_time = start_time + anim.get_run_time()
self.anims_with_timings.append(
(anim, start_time, end_time)
)
# Start time of next animation is based on the lag_ratio
curr_time = interpolate(
start_time, end_time, lag_ratio
)
def interpolate(self, alpha: float) -> None:
# Note, if the run_time of AnimationGroup has been
# set to something other than its default, these
# times might not correspond to actual times,
# e.g. of the surrounding scene. Instead they'd
# be a rescaled version. But that's okay!
time = alpha * self.max_end_time
for anim, start_time, end_time in self.anims_with_timings:
anim_time = end_time - start_time
if anim_time == 0:
sub_alpha = 0
else:
sub_alpha = clip((time - start_time) / anim_time, 0, 1)
anim.interpolate(sub_alpha)
class Succession(AnimationGroup):
def __init__(
self,
*animations: Animation,
lag_ratio: float = 1.0,
**kwargs
):
super().__init__(*animations, lag_ratio=lag_ratio, **kwargs)
def begin(self) -> None:
assert len(self.animations) > 0
self.active_animation = self.animations[0]
self.active_animation.begin()
def finish(self) -> None:
self.active_animation.finish()
def update_mobjects(self, dt: float) -> None:
self.active_animation.update_mobjects(dt)
def interpolate(self, alpha: float) -> None:
index, subalpha = integer_interpolate(
0, len(self.animations), alpha
)
animation = self.animations[index]
if animation is not self.active_animation:
self.active_animation.finish()
animation.begin()
self.active_animation = animation
animation.interpolate(subalpha)
class LaggedStart(AnimationGroup):
def __init__(
self,
*animations,
lag_ratio: float = DEFAULT_LAGGED_START_LAG_RATIO,
**kwargs
):
super().__init__(*animations, lag_ratio=lag_ratio, **kwargs)
class LaggedStartMap(LaggedStart):
def __init__(
self,
anim_func: Callable[[Mobject], Animation],
group: Mobject,
run_time: float = 2.0,
lag_ratio: float = DEFAULT_LAGGED_START_LAG_RATIO,
**kwargs
):
anim_kwargs = dict(kwargs)
anim_kwargs.pop("lag_ratio", None)
super().__init__(
*(anim_func(submob, **anim_kwargs) for submob in group),
run_time=run_time,
lag_ratio=lag_ratio,
group=group
)
================================================
FILE: manimlib/animation/creation.py
================================================
from __future__ import annotations
from abc import ABC, abstractmethod
import numpy as np
from manimlib.animation.animation import Animation
from manimlib.mobject.svg.string_mobject import StringMobject
from manimlib.mobject.types.vectorized_mobject import VMobject
from manimlib.utils.bezier import integer_interpolate
from manimlib.utils.rate_functions import linear
from manimlib.utils.rate_functions import double_smooth
from manimlib.utils.rate_functions import smooth
from manimlib.utils.simple_functions import clip
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from typing import Callable
from manimlib.mobject.mobject import Mobject
from manimlib.scene.scene import Scene
from manimlib.typing import ManimColor
class ShowPartial(Animation, ABC):
"""
Abstract class for ShowCreation and ShowPassingFlash
"""
def __init__(self, mobject: Mobject, should_match_start: bool = False, **kwargs):
self.should_match_start = should_match_start
super().__init__(mobject, **kwargs)
def interpolate_submobject(
self,
submob: Mobject,
start_submob: Mobject,
alpha: float
) -> None:
submob.pointwise_become_partial(
start_submob, *self.get_bounds(alpha)
)
@abstractmethod
def get_bounds(self, alpha: float) -> tuple[float, float]:
raise Exception("Not Implemented")
class ShowCreation(ShowPartial):
def __init__(self, mobject: Mobject, lag_ratio: float = 1.0, **kwargs):
super().__init__(mobject, lag_ratio=lag_ratio, **kwargs)
def get_bounds(self, alpha: float) -> tuple[float, float]:
return (0, alpha)
class Uncreate(ShowCreation):
def __init__(
self,
mobject: Mobject,
rate_func: Callable[[float], float] = lambda t: smooth(1 - t),
remover: bool = True,
should_match_start: bool = True,
**kwargs,
):
super().__init__(
mobject,
rate_func=rate_func,
remover=remover,
should_match_start=should_match_start,
**kwargs,
)
class DrawBorderThenFill(Animation):
def __init__(
self,
vmobject: VMobject,
run_time: float = 2.0,
rate_func: Callable[[float], float] = double_smooth,
stroke_width: float = 2.0,
stroke_color: ManimColor = None,
draw_border_animation_config: dict = {},
fill_animation_config: dict = {},
**kwargs
):
assert isinstance(vmobject, VMobject)
self.sm_to_index = {hash(sm): 0 for sm in vmobject.get_family()}
self.stroke_width = stroke_width
self.stroke_color = stroke_color
self.draw_border_animation_config = draw_border_animation_config
self.fill_animation_config = fill_animation_config
super().__init__(
vmobject,
run_time=run_time,
rate_func=rate_func,
**kwargs
)
self.mobject = vmobject
def begin(self) -> None:
self.mobject.set_animating_status(True)
self.outline = self.get_outline()
super().begin()
self.mobject.match_style(self.outline)
def finish(self) -> None:
super().finish()
self.mobject.refresh_joint_angles()
def get_outline(self) -> VMobject:
outline = self.mobject.copy()
outline.set_fill(opacity=0)
for sm in outline.family_members_with_points():
sm.set_stroke(
color=self.stroke_color or sm.get_stroke_color(),
width=self.stroke_width,
behind=self.mobject.stroke_behind,
)
return outline
def get_all_mobjects(self) -> list[Mobject]:
return [*super().get_all_mobjects(), self.outline]
def interpolate_submobject(
self,
submob: VMobject,
start: VMobject,
outline: VMobject,
alpha: float
) -> None:
index, subalpha = integer_interpolate(0, 2, alpha)
if index == 1 and self.sm_to_index[hash(submob)] == 0:
# First time crossing over
submob.set_data(outline.data)
self.sm_to_index[hash(submob)] = 1
if index == 0:
submob.pointwise_become_partial(outline, 0, subalpha)
else:
submob.interpolate(outline, start, subalpha)
class Write(DrawBorderThenFill):
def __init__(
self,
vmobject: VMobject,
run_time: float = -1, # If negative, this will be reassigned
lag_ratio: float = -1, # If negative, this will be reassigned
rate_func: Callable[[float], float] = linear,
stroke_color: ManimColor = None,
**kwargs
):
if stroke_color is None:
stroke_color = vmobject.get_color()
family_size = len(vmobject.family_members_with_points())
super().__init__(
vmobject,
run_time=self.compute_run_time(family_size, run_time),
lag_ratio=self.compute_lag_ratio(family_size, lag_ratio),
rate_func=rate_func,
stroke_color=stroke_color,
**kwargs
)
def compute_run_time(self, family_size: int, run_time: float):
if run_time < 0:
return 1 if family_size < 15 else 2
return run_time
def compute_lag_ratio(self, family_size: int, lag_ratio: float):
if lag_ratio < 0:
return min(4.0 / (family_size + 1.0), 0.2)
return lag_ratio
class ShowIncreasingSubsets(Animation):
def __init__(
self,
group: Mobject,
int_func: Callable[[float], float] = np.round,
suspend_mobject_updating: bool = False,
**kwargs
):
self.all_submobs = list(group.submobjects)
self.int_func = int_func
super().__init__(
group,
suspend_mobject_updating=suspend_mobject_updating,
**kwargs
)
def interpolate_mobject(self, alpha: float) -> None:
n_submobs = len(self.all_submobs)
alpha = self.rate_func(alpha)
index = int(self.int_func(alpha * n_submobs))
self.update_submobject_list(index)
def update_submobject_list(self, index: int) -> None:
self.mobject.set_submobjects(self.all_submobs[:index])
class ShowSubmobjectsOneByOne(ShowIncreasingSubsets):
def __init__(
self,
group: Mobject,
int_func: Callable[[float], float] = np.ceil,
**kwargs
):
super().__init__(group, int_func=int_func, **kwargs)
def update_submobject_list(self, index: int) -> None:
index = int(clip(index, 0, len(self.all_submobs) - 1))
if index == 0:
self.mobject.set_submobjects([])
else:
self.mobject.set_submobjects([self.all_submobs[index - 1]])
class AddTextWordByWord(ShowIncreasingSubsets):
def __init__(
self,
string_mobject: StringMobject,
time_per_word: float = 0.2,
run_time: float = -1.0, # If negative, it will be recomputed with time_per_word
rate_func: Callable[[float], float] = linear,
**kwargs
):
assert isinstance(string_mobject, StringMobject)
grouped_mobject = string_mobject.build_groups()
if run_time < 0:
run_time = time_per_word * len(grouped_mobject)
super().__init__(
grouped_mobject,
run_time=run_time,
rate_func=rate_func,
**kwargs
)
self.string_mobject = string_mobject
def clean_up_from_scene(self, scene: Scene) -> None:
scene.remove(self.mobject)
if not self.is_remover():
scene.add(self.string_mobject)
================================================
FILE: manimlib/animation/fading.py
================================================
from __future__ import annotations
import numpy as np
from manimlib.animation.animation import Animation
from manimlib.animation.transform import Transform
from manimlib.constants import ORIGIN
from manimlib.mobject.types.vectorized_mobject import VMobject
from manimlib.mobject.mobject import Group
from manimlib.utils.bezier import interpolate
from manimlib.utils.rate_functions import there_and_back
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from typing import Callable
from manimlib.mobject.mobject import Mobject
from manimlib.scene.scene import Scene
from manimlib.typing import Vect3
class Fade(Transform):
def __init__(
self,
mobject: Mobject,
shift: np.ndarray = ORIGIN,
scale: float = 1,
**kwargs
):
self.shift_vect = shift
self.scale_factor = scale
super().__init__(mobject, **kwargs)
class FadeIn(Fade):
def create_target(self) -> Mobject:
return self.mobject.copy()
def create_starting_mobject(self) -> Mobject:
start = super().create_starting_mobject()
start.set_opacity(0)
start.scale(1.0 / self.scale_factor)
start.shift(-self.shift_vect)
return start
class FadeOut(Fade):
def __init__(
self,
mobject: Mobject,
shift: Vect3 = ORIGIN,
remover: bool = True,
final_alpha_value: float = 0.0, # Put it back in original state when done,
**kwargs
):
super().__init__(
mobject, shift,
remover=remover,
final_alpha_value=final_alpha_value,
**kwargs
)
def create_target(self) -> Mobject:
result = self.mobject.copy()
result.set_opacity(0)
result.shift(self.shift_vect)
result.scale(self.scale_factor)
return result
class FadeInFromPoint(FadeIn):
def __init__(self, mobject: Mobject, point: Vect3, **kwargs):
super().__init__(
mobject,
shift=mobject.get_center() - point,
scale=np.inf,
**kwargs,
)
class FadeOutToPoint(F
gitextract_x3i4m6_j/ ├── .github/ │ ├── ISSUE_TEMPLATE/ │ │ ├── bug_report.md │ │ ├── config.yml │ │ └── error-when-using.md │ ├── PULL_REQUEST_TEMPLATE.md │ └── workflows/ │ ├── docs.yml │ └── publish.yml ├── .gitignore ├── LICENSE.md ├── MANIFEST.in ├── README.md ├── docs/ │ ├── Makefile │ ├── example.py │ ├── make.bat │ ├── requirements.txt │ └── source/ │ ├── conf.py │ ├── development/ │ │ ├── about.rst │ │ ├── changelog.rst │ │ └── contributing.rst │ ├── documentation/ │ │ ├── animation/ │ │ │ └── index.rst │ │ ├── camera/ │ │ │ └── index.rst │ │ ├── constants.rst │ │ ├── custom_config.rst │ │ ├── mobject/ │ │ │ └── index.rst │ │ ├── scene/ │ │ │ └── index.rst │ │ ├── shaders/ │ │ │ └── index.rst │ │ └── utils/ │ │ └── index.rst │ ├── getting_started/ │ │ ├── configuration.rst │ │ ├── example_scenes.rst │ │ ├── installation.rst │ │ ├── quickstart.rst │ │ ├── structure.rst │ │ └── whatsnew.rst │ ├── index.rst │ └── manim_example_ext.py ├── example_scenes.py ├── logo/ │ └── logo.py ├── manimlib/ │ ├── __init__.py │ ├── __main__.py │ ├── animation/ │ │ ├── __init__.py │ │ ├── animation.py │ │ ├── composition.py │ │ ├── creation.py │ │ ├── fading.py │ │ ├── growing.py │ │ ├── indication.py │ │ ├── movement.py │ │ ├── numbers.py │ │ ├── rotation.py │ │ ├── specialized.py │ │ ├── transform.py │ │ ├── transform_matching_parts.py │ │ └── update.py │ ├── camera/ │ │ ├── __init__.py │ │ ├── camera.py │ │ └── camera_frame.py │ ├── config.py │ ├── constants.py │ ├── default_config.yml │ ├── event_handler/ │ │ ├── __init__.py │ │ ├── event_dispatcher.py │ │ ├── event_listner.py │ │ └── event_type.py │ ├── extract_scene.py │ ├── logger.py │ ├── mobject/ │ │ ├── __init__.py │ │ ├── boolean_ops.py │ │ ├── changing.py │ │ ├── coordinate_systems.py │ │ ├── frame.py │ │ ├── functions.py │ │ ├── geometry.py │ │ ├── interactive.py │ │ ├── matrix.py │ │ ├── mobject.py │ │ ├── mobject_update_utils.py │ │ ├── number_line.py │ │ ├── numbers.py │ │ ├── probability.py │ │ ├── shape_matchers.py │ │ ├── svg/ │ │ │ ├── __init__.py │ │ │ ├── brace.py │ │ │ ├── drawings.py │ │ │ ├── old_tex_mobject.py │ │ │ ├── special_tex.py │ │ │ ├── string_mobject.py │ │ │ ├── svg_mobject.py │ │ │ ├── tex_mobject.py │ │ │ └── text_mobject.py │ │ ├── three_dimensions.py │ │ ├── types/ │ │ │ ├── __init__.py │ │ │ ├── dot_cloud.py │ │ │ ├── image_mobject.py │ │ │ ├── point_cloud_mobject.py │ │ │ ├── surface.py │ │ │ └── vectorized_mobject.py │ │ ├── value_tracker.py │ │ └── vector_field.py │ ├── module_loader.py │ ├── scene/ │ │ ├── __init__.py │ │ ├── interactive_scene.py │ │ ├── scene.py │ │ ├── scene_embed.py │ │ └── scene_file_writer.py │ ├── shader_wrapper.py │ ├── shaders/ │ │ ├── image/ │ │ │ ├── frag.glsl │ │ │ └── vert.glsl │ │ ├── inserts/ │ │ │ ├── NOTE.md │ │ │ ├── complex_functions.glsl │ │ │ ├── emit_gl_Position.glsl │ │ │ ├── finalize_color.glsl │ │ │ ├── get_unit_normal.glsl │ │ │ └── get_xyz_to_uv.glsl │ │ ├── mandelbrot_fractal/ │ │ │ ├── frag.glsl │ │ │ └── vert.glsl │ │ ├── newton_fractal/ │ │ │ ├── frag.glsl │ │ │ └── vert.glsl │ │ ├── quadratic_bezier/ │ │ │ ├── depth/ │ │ │ │ ├── frag.glsl │ │ │ │ ├── geom.glsl │ │ │ │ └── vert.glsl │ │ │ ├── fill/ │ │ │ │ ├── frag.glsl │ │ │ │ ├── geom.glsl │ │ │ │ └── vert.glsl │ │ │ └── stroke/ │ │ │ ├── frag.glsl │ │ │ ├── geom.glsl │ │ │ └── vert.glsl │ │ ├── simple_vert.glsl │ │ ├── surface/ │ │ │ ├── frag.glsl │ │ │ └── vert.glsl │ │ ├── textured_surface/ │ │ │ ├── frag.glsl │ │ │ └── vert.glsl │ │ └── true_dot/ │ │ ├── frag.glsl │ │ ├── geom.glsl │ │ └── vert.glsl │ ├── tex_templates.yml │ ├── typing.py │ ├── utils/ │ │ ├── __init__.py │ │ ├── bezier.py │ │ ├── cache.py │ │ ├── color.py │ │ ├── debug.py │ │ ├── dict_ops.py │ │ ├── directories.py │ │ ├── family_ops.py │ │ ├── file_ops.py │ │ ├── images.py │ │ ├── iterables.py │ │ ├── paths.py │ │ ├── rate_functions.py │ │ ├── shaders.py │ │ ├── simple_functions.py │ │ ├── sounds.py │ │ ├── space_ops.py │ │ ├── tex.py │ │ ├── tex_file_writing.py │ │ └── tex_to_symbol_count.py │ └── window.py ├── pyproject.toml ├── requirements.txt ├── setup.cfg └── setup.py
SYMBOL INDEX (1997 symbols across 80 files)
FILE: docs/example.py
class SquareToCircle (line 3) | class SquareToCircle(Scene):
method construct (line 4) | def construct(self):
class SquareToCircleEmbed (line 21) | class SquareToCircleEmbed(Scene):
method construct (line 22) | def construct(self):
FILE: docs/source/manim_example_ext.py
class skip_manim_node (line 8) | class skip_manim_node(nodes.Admonition, nodes.Element):
function visit (line 12) | def visit(self, node, name=""):
function depart (line 16) | def depart(self, node):
class ManimExampleDirective (line 20) | class ManimExampleDirective(Directive):
method run (line 30) | def run(self):
function setup (line 65) | def setup(app):
FILE: example_scenes.py
class OpeningManimExample (line 12) | class OpeningManimExample(Scene):
method construct (line 13) | def construct(self):
class AnimatingMethods (line 71) | class AnimatingMethods(Scene):
method construct (line 72) | def construct(self):
class TextExample (line 115) | class TextExample(Scene):
method construct (line 116) | def construct(self):
class TexTransformExample (line 156) | class TexTransformExample(Scene):
method construct (line 157) | def construct(self):
class TexIndexing (line 228) | class TexIndexing(Scene):
method construct (line 229) | def construct(self):
class UpdatersExample (line 281) | class UpdatersExample(Scene):
method construct (line 282) | def construct(self):
class CoordinateSystemExample (line 341) | class CoordinateSystemExample(Scene):
method construct (line 342) | def construct(self):
class GraphExample (line 420) | class GraphExample(Scene):
method construct (line 421) | def construct(self):
class TexAndNumbersExample (line 498) | class TexAndNumbersExample(Scene):
method construct (line 499) | def construct(self):
class SurfaceExample (line 566) | class SurfaceExample(ThreeDScene):
method construct (line 567) | def construct(self):
class InteractiveDevelopment (line 648) | class InteractiveDevelopment(Scene):
method construct (line 649) | def construct(self):
class ControlsExample (line 694) | class ControlsExample(Scene):
method setup (line 697) | def setup(self):
method construct (line 708) | def construct(self):
FILE: logo/logo.py
class Thumbnail (line 5) | class Thumbnail(GraphScene):
method construct (line 11) | def construct(self):
method show_function_graph (line 14) | def show_function_graph(self):
FILE: manimlib/__main__.py
function run_scenes (line 20) | def run_scenes():
function main (line 49) | def main():
FILE: manimlib/animation/animation.py
class Animation (line 23) | class Animation(object):
method __init__ (line 24) | def __init__(
method _validate_input_type (line 56) | def _validate_input_type(self, mobject: Mobject) -> None:
method __str__ (line 60) | def __str__(self) -> str:
method begin (line 63) | def begin(self) -> None:
method finish (line 79) | def finish(self) -> None:
method clean_up_from_scene (line 85) | def clean_up_from_scene(self, scene: Scene) -> None:
method create_starting_mobject (line 89) | def create_starting_mobject(self) -> Mobject:
method get_all_mobjects (line 93) | def get_all_mobjects(self) -> tuple[Mobject, Mobject]:
method get_all_families_zipped (line 99) | def get_all_families_zipped(self) -> zip[tuple[Mobject]]:
method update_mobjects (line 105) | def update_mobjects(self, dt: float) -> None:
method get_all_mobjects_to_update (line 113) | def get_all_mobjects_to_update(self) -> list[Mobject]:
method copy (line 123) | def copy(self):
method update_rate_info (line 126) | def update_rate_info(
method interpolate (line 138) | def interpolate(self, alpha: float) -> None:
method update (line 141) | def update(self, alpha: float) -> None:
method time_spanned_alpha (line 148) | def time_spanned_alpha(self, alpha: float) -> float:
method interpolate_mobject (line 154) | def interpolate_mobject(self, alpha: float) -> None:
method interpolate_submobject (line 159) | def interpolate_submobject(
method get_sub_alpha (line 168) | def get_sub_alpha(
method set_run_time (line 185) | def set_run_time(self, run_time: float):
method get_run_time (line 189) | def get_run_time(self) -> float:
method set_rate_func (line 194) | def set_rate_func(self, rate_func: Callable[[float], float]):
method get_rate_func (line 198) | def get_rate_func(self) -> Callable[[float], float]:
method set_name (line 201) | def set_name(self, name: str):
method is_remover (line 205) | def is_remover(self) -> bool:
function prepare_animation (line 209) | def prepare_animation(anim: Animation | _AnimationBuilder):
FILE: manimlib/animation/composition.py
class AnimationGroup (line 27) | class AnimationGroup(Animation):
method __init__ (line 28) | def __init__(
method get_all_mobjects (line 60) | def get_all_mobjects(self) -> Mobject:
method begin (line 63) | def begin(self) -> None:
method finish (line 69) | def finish(self) -> None:
method clean_up_from_scene (line 74) | def clean_up_from_scene(self, scene: Scene) -> None:
method update_mobjects (line 78) | def update_mobjects(self, dt: float) -> None:
method calculate_max_end_time (line 82) | def calculate_max_end_time(self) -> None:
method build_animations_with_timings (line 90) | def build_animations_with_timings(self, lag_ratio: float) -> None:
method interpolate (line 108) | def interpolate(self, alpha: float) -> None:
class Succession (line 124) | class Succession(AnimationGroup):
method __init__ (line 125) | def __init__(
method begin (line 133) | def begin(self) -> None:
method finish (line 138) | def finish(self) -> None:
method update_mobjects (line 141) | def update_mobjects(self, dt: float) -> None:
method interpolate (line 144) | def interpolate(self, alpha: float) -> None:
class LaggedStart (line 156) | class LaggedStart(AnimationGroup):
method __init__ (line 157) | def __init__(
class LaggedStartMap (line 166) | class LaggedStartMap(LaggedStart):
method __init__ (line 167) | def __init__(
FILE: manimlib/animation/creation.py
class ShowPartial (line 25) | class ShowPartial(Animation, ABC):
method __init__ (line 29) | def __init__(self, mobject: Mobject, should_match_start: bool = False,...
method interpolate_submobject (line 33) | def interpolate_submobject(
method get_bounds (line 44) | def get_bounds(self, alpha: float) -> tuple[float, float]:
class ShowCreation (line 48) | class ShowCreation(ShowPartial):
method __init__ (line 49) | def __init__(self, mobject: Mobject, lag_ratio: float = 1.0, **kwargs):
method get_bounds (line 52) | def get_bounds(self, alpha: float) -> tuple[float, float]:
class Uncreate (line 56) | class Uncreate(ShowCreation):
method __init__ (line 57) | def __init__(
class DrawBorderThenFill (line 74) | class DrawBorderThenFill(Animation):
method __init__ (line 75) | def __init__(
method begin (line 100) | def begin(self) -> None:
method finish (line 106) | def finish(self) -> None:
method get_outline (line 110) | def get_outline(self) -> VMobject:
method get_all_mobjects (line 121) | def get_all_mobjects(self) -> list[Mobject]:
method interpolate_submobject (line 124) | def interpolate_submobject(
class Write (line 144) | class Write(DrawBorderThenFill):
method __init__ (line 145) | def __init__(
method compute_run_time (line 166) | def compute_run_time(self, family_size: int, run_time: float):
method compute_lag_ratio (line 171) | def compute_lag_ratio(self, family_size: int, lag_ratio: float):
class ShowIncreasingSubsets (line 177) | class ShowIncreasingSubsets(Animation):
method __init__ (line 178) | def __init__(
method interpolate_mobject (line 193) | def interpolate_mobject(self, alpha: float) -> None:
method update_submobject_list (line 199) | def update_submobject_list(self, index: int) -> None:
class ShowSubmobjectsOneByOne (line 203) | class ShowSubmobjectsOneByOne(ShowIncreasingSubsets):
method __init__ (line 204) | def __init__(
method update_submobject_list (line 212) | def update_submobject_list(self, index: int) -> None:
class AddTextWordByWord (line 220) | class AddTextWordByWord(ShowIncreasingSubsets):
method __init__ (line 221) | def __init__(
method clean_up_from_scene (line 241) | def clean_up_from_scene(self, scene: Scene) -> None:
FILE: manimlib/animation/fading.py
class Fade (line 22) | class Fade(Transform):
method __init__ (line 23) | def __init__(
class FadeIn (line 35) | class FadeIn(Fade):
method create_target (line 36) | def create_target(self) -> Mobject:
method create_starting_mobject (line 39) | def create_starting_mobject(self) -> Mobject:
class FadeOut (line 47) | class FadeOut(Fade):
method __init__ (line 48) | def __init__(
method create_target (line 63) | def create_target(self) -> Mobject:
class FadeInFromPoint (line 71) | class FadeInFromPoint(FadeIn):
method __init__ (line 72) | def __init__(self, mobject: Mobject, point: Vect3, **kwargs):
class FadeOutToPoint (line 81) | class FadeOutToPoint(FadeOut):
method __init__ (line 82) | def __init__(self, mobject: Mobject, point: Vect3, **kwargs):
class FadeTransform (line 91) | class FadeTransform(Transform):
method __init__ (line 92) | def __init__(
method begin (line 107) | def begin(self) -> None:
method ghost_to (line 117) | def ghost_to(self, source: Mobject, target: Mobject) -> None:
method get_all_mobjects (line 122) | def get_all_mobjects(self) -> list[Mobject]:
method get_all_families_zipped (line 129) | def get_all_families_zipped(self) -> zip[tuple[Mobject]]:
method clean_up_from_scene (line 132) | def clean_up_from_scene(self, scene: Scene) -> None:
class FadeTransformPieces (line 140) | class FadeTransformPieces(FadeTransform):
method begin (line 141) | def begin(self) -> None:
method ghost_to (line 145) | def ghost_to(self, source: Mobject, target: Mobject) -> None:
class VFadeIn (line 150) | class VFadeIn(Animation):
method __init__ (line 154) | def __init__(self, vmobject: VMobject, suspend_mobject_updating: bool ...
method interpolate_submobject (line 161) | def interpolate_submobject(
class VFadeOut (line 175) | class VFadeOut(VFadeIn):
method __init__ (line 176) | def __init__(
method interpolate_submobject (line 190) | def interpolate_submobject(
class VFadeInThenOut (line 199) | class VFadeInThenOut(VFadeIn):
method __init__ (line 200) | def __init__(
FILE: manimlib/animation/growing.py
class GrowFromPoint (line 15) | class GrowFromPoint(Transform):
method __init__ (line 16) | def __init__(
method create_target (line 27) | def create_target(self) -> Mobject:
method create_starting_mobject (line 30) | def create_starting_mobject(self) -> Mobject:
class GrowFromCenter (line 39) | class GrowFromCenter(GrowFromPoint):
method __init__ (line 40) | def __init__(self, mobject: Mobject, **kwargs):
class GrowFromEdge (line 45) | class GrowFromEdge(GrowFromPoint):
method __init__ (line 46) | def __init__(self, mobject: Mobject, edge: np.ndarray, **kwargs):
class GrowArrow (line 51) | class GrowArrow(GrowFromPoint):
method __init__ (line 52) | def __init__(self, arrow: Arrow, **kwargs):
FILE: manimlib/animation/indication.py
class FocusOn (line 41) | class FocusOn(Transform):
method __init__ (line 42) | def __init__(
method create_target (line 58) | def create_target(self) -> Dot:
method create_starting_mobject (line 64) | def create_starting_mobject(self) -> Dot:
class Indicate (line 73) | class Indicate(Transform):
method __init__ (line 74) | def __init__(
method create_target (line 86) | def create_target(self) -> Mobject:
class Flash (line 93) | class Flash(AnimationGroup):
method __init__ (line 94) | def __init__(
method create_lines (line 121) | def create_lines(self) -> VGroup:
method create_line_anims (line 135) | def create_line_anims(self) -> list[Animation]:
class CircleIndicate (line 142) | class CircleIndicate(Transform):
method __init__ (line 143) | def __init__(
class ShowPassingFlash (line 165) | class ShowPassingFlash(ShowPartial):
method __init__ (line 166) | def __init__(
method get_bounds (line 180) | def get_bounds(self, alpha: float) -> tuple[float, float]:
method finish (line 188) | def finish(self) -> None:
class VShowPassingFlash (line 194) | class VShowPassingFlash(Animation):
method __init__ (line 195) | def __init__(
method taper_kernel (line 208) | def taper_kernel(self, x):
method begin (line 215) | def begin(self) -> None:
method interpolate_submobject (line 227) | def interpolate_submobject(
method finish (line 249) | def finish(self) -> None:
class FlashAround (line 255) | class FlashAround(VShowPassingFlash):
method __init__ (line 256) | def __init__(
method get_path (line 275) | def get_path(self, mobject: Mobject, buff: float) -> SurroundingRectan...
class FlashUnder (line 279) | class FlashUnder(FlashAround):
method get_path (line 280) | def get_path(self, mobject: Mobject, buff: float) -> Underline:
class ShowCreationThenDestruction (line 284) | class ShowCreationThenDestruction(ShowPassingFlash):
method __init__ (line 285) | def __init__(self, vmobject: VMobject, time_width: float = 2.0, **kwar...
class ShowCreationThenFadeOut (line 289) | class ShowCreationThenFadeOut(Succession):
method __init__ (line 290) | def __init__(self, mobject: Mobject, remover: bool = True, **kwargs):
class AnimationOnSurroundingRectangle (line 299) | class AnimationOnSurroundingRectangle(AnimationGroup):
method __init__ (line 302) | def __init__(
class ShowPassingFlashAround (line 320) | class ShowPassingFlashAround(AnimationOnSurroundingRectangle):
class ShowCreationThenDestructionAround (line 324) | class ShowCreationThenDestructionAround(AnimationOnSurroundingRectangle):
class ShowCreationThenFadeAround (line 328) | class ShowCreationThenFadeAround(AnimationOnSurroundingRectangle):
class ApplyWave (line 332) | class ApplyWave(Homotopy):
method __init__ (line 333) | def __init__(
class WiggleOutThenIn (line 355) | class WiggleOutThenIn(Animation):
method __init__ (line 356) | def __init__(
method get_scale_about_point (line 374) | def get_scale_about_point(self) -> np.ndarray:
method get_rotate_about_point (line 377) | def get_rotate_about_point(self) -> np.ndarray:
method interpolate_submobject (line 380) | def interpolate_submobject(
class TurnInsideOut (line 397) | class TurnInsideOut(Transform):
method __init__ (line 398) | def __init__(self, mobject: Mobject, path_arc: float = 90 * DEG, **kwa...
method create_target (line 401) | def create_target(self) -> Mobject:
class FlashyFadeIn (line 408) | class FlashyFadeIn(AnimationGroup):
method __init__ (line 409) | def __init__(self,
FILE: manimlib/animation/movement.py
class Homotopy (line 17) | class Homotopy(Animation):
method __init__ (line 20) | def __init__(
method function_at_time_t (line 34) | def function_at_time_t(self, t: float) -> Callable[[np.ndarray], Seque...
method interpolate_submobject (line 39) | def interpolate_submobject(
class SmoothedVectorizedHomotopy (line 52) | class SmoothedVectorizedHomotopy(Homotopy):
class ComplexHomotopy (line 56) | class ComplexHomotopy(Homotopy):
method __init__ (line 57) | def __init__(
class PhaseFlow (line 75) | class PhaseFlow(Animation):
method __init__ (line 76) | def __init__(
method interpolate_mobject (line 96) | def interpolate_mobject(self, alpha: float) -> None:
class MoveAlongPath (line 105) | class MoveAlongPath(Animation):
method __init__ (line 106) | def __init__(
method interpolate_mobject (line 116) | def interpolate_mobject(self, alpha: float) -> None:
FILE: manimlib/animation/numbers.py
class ChangingDecimal (line 14) | class ChangingDecimal(Animation):
method __init__ (line 15) | def __init__(
method interpolate_mobject (line 31) | def interpolate_mobject(self, alpha: float) -> None:
class ChangeDecimalToValue (line 37) | class ChangeDecimalToValue(ChangingDecimal):
method __init__ (line 38) | def __init__(
class CountInFrom (line 52) | class CountInFrom(ChangingDecimal):
method __init__ (line 53) | def __init__(
FILE: manimlib/animation/rotation.py
class Rotating (line 17) | class Rotating(Animation):
method __init__ (line 18) | def __init__(
method interpolate_mobject (line 42) | def interpolate_mobject(self, alpha: float) -> None:
class Rotate (line 58) | class Rotate(Rotating):
method __init__ (line 59) | def __init__(
FILE: manimlib/animation/specialized.py
class Broadcast (line 16) | class Broadcast(LaggedStart):
method __init__ (line 17) | def __init__(
FILE: manimlib/animation/transform.py
class Transform (line 24) | class Transform(Animation):
method __init__ (line 27) | def __init__(
method init_path_func (line 43) | def init_path_func(self) -> None:
method begin (line 54) | def begin(self) -> None:
method finish (line 74) | def finish(self) -> None:
method create_target (line 78) | def create_target(self) -> Mobject:
method check_target_mobject_validity (line 83) | def check_target_mobject_validity(self) -> None:
method clean_up_from_scene (line 89) | def clean_up_from_scene(self, scene: Scene) -> None:
method update_config (line 95) | def update_config(self, **kwargs) -> None:
method get_all_mobjects (line 103) | def get_all_mobjects(self) -> list[Mobject]:
method get_all_families_zipped (line 111) | def get_all_families_zipped(self) -> zip[tuple[Mobject]]:
method interpolate_submobject (line 121) | def interpolate_submobject(
class ReplacementTransform (line 132) | class ReplacementTransform(Transform):
class TransformFromCopy (line 136) | class TransformFromCopy(Transform):
method __init__ (line 139) | def __init__(self, mobject: Mobject, target_mobject: Mobject, **kwargs):
class MoveToTarget (line 143) | class MoveToTarget(Transform):
method __init__ (line 144) | def __init__(self, mobject: Mobject, **kwargs):
method check_validity_of_input (line 148) | def check_validity_of_input(self, mobject: Mobject) -> None:
class _MethodAnimation (line 155) | class _MethodAnimation(MoveToTarget):
method __init__ (line 156) | def __init__(self, mobject: Mobject, methods: list[Callable], **kwargs):
class ApplyMethod (line 161) | class ApplyMethod(Transform):
method __init__ (line 162) | def __init__(self, method: Callable, *args, **kwargs):
method check_validity_of_input (line 176) | def check_validity_of_input(self, method: Callable) -> None:
method create_target (line 184) | def create_target(self) -> Mobject:
class ApplyPointwiseFunction (line 198) | class ApplyPointwiseFunction(ApplyMethod):
method __init__ (line 199) | def __init__(
class ApplyPointwiseFunctionToCenter (line 209) | class ApplyPointwiseFunctionToCenter(Transform):
method __init__ (line 210) | def __init__(
method create_target (line 219) | def create_target(self) -> Mobject:
class FadeToColor (line 223) | class FadeToColor(ApplyMethod):
method __init__ (line 224) | def __init__(
class ScaleInPlace (line 233) | class ScaleInPlace(ApplyMethod):
method __init__ (line 234) | def __init__(
class ShrinkToCenter (line 243) | class ShrinkToCenter(ScaleInPlace):
method __init__ (line 244) | def __init__(self, mobject: Mobject, **kwargs):
class Restore (line 248) | class Restore(Transform):
method __init__ (line 249) | def __init__(self, mobject: Mobject, **kwargs):
class ApplyFunction (line 255) | class ApplyFunction(Transform):
method __init__ (line 256) | def __init__(
method create_target (line 265) | def create_target(self) -> Mobject:
class ApplyMatrix (line 272) | class ApplyMatrix(ApplyPointwiseFunction):
method __init__ (line 273) | def __init__(
method initialize_matrix (line 286) | def initialize_matrix(self, matrix: npt.ArrayLike) -> np.ndarray:
class ApplyComplexFunction (line 297) | class ApplyComplexFunction(ApplyMethod):
method __init__ (line 298) | def __init__(
method init_path_func (line 308) | def init_path_func(self) -> None:
class CyclicReplace (line 316) | class CyclicReplace(Transform):
method __init__ (line 317) | def __init__(self, *mobjects: Mobject, path_arc=90 * DEG, **kwargs):
method create_target (line 320) | def create_target(self) -> Mobject:
class Swap (line 329) | class Swap(CyclicReplace):
FILE: manimlib/animation/transform_matching_parts.py
class TransformMatchingParts (line 21) | class TransformMatchingParts(AnimationGroup):
method __init__ (line 22) | def __init__(
method add_transform (line 76) | def add_transform(
method find_pairs_with_matching_shapes (line 101) | def find_pairs_with_matching_shapes(
method clean_up_from_scene (line 112) | def clean_up_from_scene(self, scene: Scene) -> None:
class TransformMatchingShapes (line 118) | class TransformMatchingShapes(TransformMatchingParts):
class TransformMatchingStrings (line 123) | class TransformMatchingStrings(TransformMatchingParts):
method __init__ (line 124) | def __init__(
method matching_blocks (line 144) | def matching_blocks(
class TransformMatchingTex (line 189) | class TransformMatchingTex(TransformMatchingStrings):
FILE: manimlib/animation/update.py
class UpdateFromFunc (line 13) | class UpdateFromFunc(Animation):
method __init__ (line 19) | def __init__(
method interpolate_mobject (line 33) | def interpolate_mobject(self, alpha: float) -> None:
class UpdateFromAlphaFunc (line 37) | class UpdateFromAlphaFunc(Animation):
method __init__ (line 38) | def __init__(
method interpolate_mobject (line 48) | def interpolate_mobject(self, alpha: float) -> None:
class MaintainPositionRelativeTo (line 53) | class MaintainPositionRelativeTo(Animation):
method __init__ (line 54) | def __init__(
method interpolate_mobject (line 64) | def interpolate_mobject(self, alpha: float) -> None:
FILE: manimlib/camera/camera.py
class Camera (line 25) | class Camera(object):
method __init__ (line 26) | def __init__(
method init_frame (line 69) | def init_frame(self, **config) -> None:
method init_context (line 72) | def init_context(self) -> None:
method init_fbo (line 81) | def init_fbo(self) -> None:
method init_light_source (line 97) | def init_light_source(self) -> None:
method use_window_fbo (line 100) | def use_window_fbo(self, use: bool = True):
method get_fbo (line 108) | def get_fbo(
method clear (line 124) | def clear(self) -> None:
method blit (line 129) | def blit(self, src_fbo, dst_fbo):
method get_raw_fbo_data (line 141) | def get_raw_fbo_data(self, dtype: str = 'f1') -> bytes:
method get_image (line 149) | def get_image(self) -> Image.Image:
method get_pixel_array (line 157) | def get_pixel_array(self) -> np.ndarray:
method get_texture (line 166) | def get_texture(self) -> moderngl.Texture:
method get_pixel_size (line 176) | def get_pixel_size(self) -> float:
method get_pixel_shape (line 179) | def get_pixel_shape(self) -> tuple[int, int]:
method get_pixel_width (line 182) | def get_pixel_width(self) -> int:
method get_pixel_height (line 185) | def get_pixel_height(self) -> int:
method get_aspect_ratio (line 188) | def get_aspect_ratio(self):
method get_frame_height (line 192) | def get_frame_height(self) -> float:
method get_frame_width (line 195) | def get_frame_width(self) -> float:
method get_frame_shape (line 198) | def get_frame_shape(self) -> tuple[float, float]:
method get_frame_center (line 201) | def get_frame_center(self) -> np.ndarray:
method get_location (line 204) | def get_location(self) -> tuple[float, float, float]:
method resize_frame_shape (line 207) | def resize_frame_shape(self, fixed_dimension: bool = False) -> None:
method capture (line 225) | def capture(self, *mobjects: Mobject) -> None:
method refresh_uniforms (line 238) | def refresh_uniforms(self) -> None:
class ThreeDCamera (line 259) | class ThreeDCamera(Camera):
method __init__ (line 260) | def __init__(self, samples: int = 4, **kwargs):
FILE: manimlib/camera/camera_frame.py
class CameraFrame (line 23) | class CameraFrame(Mobject):
method __init__ (line 24) | def __init__(
method set_orientation (line 51) | def set_orientation(self, rotation: Rotation):
method get_orientation (line 55) | def get_orientation(self):
method make_orientation_default (line 58) | def make_orientation_default(self):
method to_default_state (line 62) | def to_default_state(self):
method get_euler_angles (line 68) | def get_euler_angles(self) -> np.ndarray:
method get_theta (line 85) | def get_theta(self):
method get_phi (line 88) | def get_phi(self):
method get_gamma (line 91) | def get_gamma(self):
method get_scale (line 94) | def get_scale(self):
method get_inverse_camera_rotation_matrix (line 97) | def get_inverse_camera_rotation_matrix(self):
method get_view_matrix (line 100) | def get_view_matrix(self, refresh=False):
method get_inv_view_matrix (line 118) | def get_inv_view_matrix(self):
method interpolate (line 122) | def interpolate(self, *args, **kwargs):
method rotate (line 126) | def rotate(self, angle: float, axis: np.ndarray = OUT, **kwargs):
method set_euler_angles (line 131) | def set_euler_angles(
method increment_euler_angles (line 149) | def increment_euler_angles(
method set_euler_axes (line 169) | def set_euler_axes(self, seq: str):
method reorient (line 172) | def reorient(
method set_theta (line 191) | def set_theta(self, theta: float):
method set_phi (line 194) | def set_phi(self, phi: float):
method set_gamma (line 197) | def set_gamma(self, gamma: float):
method increment_theta (line 200) | def increment_theta(self, dtheta: float, units=RADIANS):
method increment_phi (line 204) | def increment_phi(self, dphi: float, units=RADIANS):
method increment_gamma (line 208) | def increment_gamma(self, dgamma: float, units=RADIANS):
method add_ambient_rotation (line 212) | def add_ambient_rotation(self, angular_speed=1 * DEG):
method set_focal_distance (line 217) | def set_focal_distance(self, focal_distance: float):
method set_field_of_view (line 222) | def set_field_of_view(self, field_of_view: float):
method get_shape (line 226) | def get_shape(self):
method get_aspect_ratio (line 229) | def get_aspect_ratio(self):
method get_center (line 233) | def get_center(self) -> np.ndarray:
method get_width (line 237) | def get_width(self) -> float:
method get_height (line 241) | def get_height(self) -> float:
method get_focal_distance (line 245) | def get_focal_distance(self) -> float:
method get_field_of_view (line 248) | def get_field_of_view(self) -> float:
method get_implied_camera_location (line 251) | def get_implied_camera_location(self) -> np.ndarray:
method to_fixed_frame_point (line 258) | def to_fixed_frame_point(self, point: Vect3, relative: bool = False):
method from_fixed_frame_point (line 263) | def from_fixed_frame_point(self, point: Vect3, relative: bool = False):
FILE: manimlib/config.py
function initialize_manim_config (line 23) | def initialize_manim_config() -> Dict:
function parse_cli (line 54) | def parse_cli():
function update_directory_config (line 235) | def update_directory_config(config: Dict):
function update_window_config (line 242) | def update_window_config(config: Dict, args: Namespace):
function update_camera_config (line 251) | def update_camera_config(config: Dict, args: Namespace):
function update_file_writer_config (line 268) | def update_file_writer_config(config: Dict, args: Namespace):
function update_scene_config (line 295) | def update_scene_config(config: Dict, args: Namespace):
function update_run_config (line 315) | def update_run_config(config: Dict, args: Namespace):
function update_embed_config (line 328) | def update_embed_config(config: Dict, args: Namespace):
function load_yaml (line 336) | def load_yaml(file_path: str):
function get_manim_dir (line 344) | def get_manim_dir():
function get_resolution_from_args (line 350) | def get_resolution_from_args(args: Optional[Namespace], resolution_optio...
function get_file_ext (line 364) | def get_file_ext(args: Namespace) -> str:
function get_animations_numbers (line 374) | def get_animations_numbers(args: Namespace) -> tuple[int | None, int | N...
function get_output_directory (line 384) | def get_output_directory(args: Namespace, config: Dict) -> str:
FILE: manimlib/event_handler/event_dispatcher.py
class EventDispatcher (line 9) | class EventDispatcher(object):
method __init__ (line 10) | def __init__(self):
method add_listner (line 22) | def add_listner(self, event_listner: EventListener):
method remove_listner (line 27) | def remove_listner(self, event_listner: EventListener):
method dispatch (line 37) | def dispatch(self, event_type: EventType, **event_data):
method get_listners_count (line 80) | def get_listners_count(self) -> int:
method get_mouse_point (line 83) | def get_mouse_point(self) -> np.ndarray:
method get_mouse_drag_point (line 86) | def get_mouse_drag_point(self) -> np.ndarray:
method is_key_pressed (line 89) | def is_key_pressed(self, symbol: int) -> bool:
FILE: manimlib/event_handler/event_listner.py
class EventListener (line 12) | class EventListener(object):
method __init__ (line 13) | def __init__(
method __eq__ (line 23) | def __eq__(self, o: object) -> bool:
FILE: manimlib/event_handler/event_type.py
class EventType (line 4) | class EventType(Enum):
FILE: manimlib/extract_scene.py
class BlankScene (line 22) | class BlankScene(InteractiveScene):
method construct (line 23) | def construct(self):
function is_child_scene (line 28) | def is_child_scene(obj, module):
function prompt_user_for_choice (line 40) | def prompt_user_for_choice(scene_classes):
function compute_total_frames (line 63) | def compute_total_frames(scene_class, scene_config):
function scene_from_class (line 81) | def scene_from_class(scene_class, scene_config: Dict, run_config: Dict):
function note_missing_scenes (line 88) | def note_missing_scenes(arg_names, module_names):
function get_scenes_to_render (line 94) | def get_scenes_to_render(all_scene_classes: list, scene_config: Dict, ru...
function get_scene_classes (line 112) | def get_scene_classes(module: Optional[Module]):
function get_indent (line 128) | def get_indent(code_lines: list[str], line_number: int) -> str:
function insert_embed_line_to_module (line 146) | def insert_embed_line_to_module(module: Module, run_config: Dict) -> None:
function get_module (line 181) | def get_module(run_config: Dict) -> Module:
function main (line 188) | def main(scene_config: Dict, run_config: Dict):
FILE: manimlib/mobject/boolean_ops.py
function _convert_vmobject_to_skia_path (line 12) | def _convert_vmobject_to_skia_path(vmobject: VMobject) -> pathops.Path:
function _convert_skia_path_to_vmobject (line 26) | def _convert_skia_path_to_vmobject(
class Union (line 52) | class Union(VMobject):
method __init__ (line 53) | def __init__(self, *vmobjects: VMobject, **kwargs):
class Difference (line 66) | class Difference(VMobject):
method __init__ (line 67) | def __init__(self, subject: VMobject, clip: VMobject, **kwargs):
class Intersection (line 78) | class Intersection(VMobject):
method __init__ (line 79) | def __init__(self, *vmobjects: VMobject, **kwargs):
class Exclusion (line 101) | class Exclusion(VMobject):
method __init__ (line 102) | def __init__(self, *vmobjects: VMobject, **kwargs):
FILE: manimlib/mobject/changing.py
class AnimatedBoundary (line 18) | class AnimatedBoundary(VGroup):
method __init__ (line 19) | def __init__(
method update_boundary_copies (line 52) | def update_boundary_copies(self, dt: float) -> Self:
method full_family_become_partial (line 84) | def full_family_become_partial(
class TracedPath (line 98) | class TracedPath(VMobject):
method __init__ (line 99) | def __init__(
method update_path (line 123) | def update_path(self, dt: float) -> Self:
class TracingTail (line 151) | class TracingTail(TracedPath):
method __init__ (line 152) | def __init__(
FILE: manimlib/mobject/coordinate_systems.py
function full_range_specifier (line 48) | def full_range_specifier(range_args):
class CoordinateSystem (line 54) | class CoordinateSystem(ABC):
method __init__ (line 60) | def __init__(
method coords_to_point (line 71) | def coords_to_point(self, *coords: float | VectN) -> Vect3 | Vect3Array:
method point_to_coords (line 75) | def point_to_coords(self, point: Vect3 | Vect3Array) -> tuple[float | ...
method c2p (line 78) | def c2p(self, *coords: float) -> Vect3 | Vect3Array:
method p2c (line 82) | def p2c(self, point: Vect3) -> tuple[float | VectN, ...]:
method get_origin (line 86) | def get_origin(self) -> Vect3:
method get_axes (line 90) | def get_axes(self) -> VGroup:
method get_all_ranges (line 94) | def get_all_ranges(self) -> list[np.ndarray]:
method get_axis (line 97) | def get_axis(self, index: int) -> NumberLine:
method get_x_axis (line 100) | def get_x_axis(self) -> NumberLine:
method get_y_axis (line 103) | def get_y_axis(self) -> NumberLine:
method get_z_axis (line 106) | def get_z_axis(self) -> NumberLine:
method get_x_axis_label (line 109) | def get_x_axis_label(
method get_y_axis_label (line 121) | def get_y_axis_label(
method get_axis_label (line 133) | def get_axis_label(
method get_axis_labels (line 152) | def get_axis_labels(
method get_line_from_axis_to_point (line 164) | def get_line_from_axis_to_point(
method get_v_line (line 177) | def get_v_line(self, point: Vect3, **kwargs):
method get_h_line (line 180) | def get_h_line(self, point: Vect3, **kwargs):
method get_graph (line 184) | def get_graph(
method get_parametric_curve (line 215) | def get_parametric_curve(
method input_to_graph_point (line 228) | def input_to_graph_point(
method i2gp (line 249) | def i2gp(self, x: float, graph: ParametricCurve) -> Vect3 | None:
method bind_graph_to_func (line 255) | def bind_graph_to_func(
method get_graph_label (line 284) | def get_graph_label(
method get_v_line_to_graph (line 319) | def get_v_line_to_graph(self, x: float, graph: ParametricCurve, **kwar...
method get_h_line_to_graph (line 322) | def get_h_line_to_graph(self, x: float, graph: ParametricCurve, **kwar...
method get_scatterplot (line 325) | def get_scatterplot(self,
method angle_of_tangent (line 332) | def angle_of_tangent(
method slope_of_tangent (line 342) | def slope_of_tangent(
method get_tangent_line (line 350) | def get_tangent_line(
method get_riemann_rectangles (line 363) | def get_riemann_rectangles(
method get_area_under_graph (line 417) | def get_area_under_graph(self, graph, x_range=None, fill_color=BLUE, f...
class Axes (line 441) | class Axes(VGroup, CoordinateSystem):
method __init__ (line 446) | def __init__(
method create_axis (line 491) | def create_axis(
method coords_to_point (line 501) | def coords_to_point(self, *coords: float | VectN) -> Vect3 | Vect3Array:
method point_to_coords (line 508) | def point_to_coords(self, point: Vect3 | Vect3Array) -> tuple[float | ...
method get_axes (line 514) | def get_axes(self) -> VGroup:
method get_all_ranges (line 517) | def get_all_ranges(self) -> list[Sequence[float]]:
method add_coordinate_labels (line 520) | def add_coordinate_labels(
class ThreeDAxes (line 535) | class ThreeDAxes(Axes):
method __init__ (line 539) | def __init__(
method get_all_ranges (line 571) | def get_all_ranges(self) -> list[Sequence[float]]:
method add_axis_labels (line 574) | def add_axis_labels(self, x_tex="x", y_tex="y", z_tex="z", font_size=2...
method get_graph (line 585) | def get_graph(
method get_parametric_surface (line 609) | def get_parametric_surface(
class NumberPlane (line 624) | class NumberPlane(Axes):
method __init__ (line 637) | def __init__(
method init_background_lines (line 662) | def init_background_lines(self) -> None:
method get_lines (line 674) | def get_lines(self) -> tuple[VGroup, VGroup]:
method get_lines_parallel_to_axis (line 684) | def get_lines_parallel_to_axis(
method get_x_unit_size (line 709) | def get_x_unit_size(self) -> float:
method get_y_unit_size (line 712) | def get_y_unit_size(self) -> list:
method get_axes (line 715) | def get_axes(self) -> VGroup:
method get_vector (line 718) | def get_vector(self, coords: Iterable[float], **kwargs) -> Arrow:
method prepare_for_nonlinear_transform (line 722) | def prepare_for_nonlinear_transform(self, num_inserted_curves: int = 5...
class ComplexPlane (line 731) | class ComplexPlane(NumberPlane):
method number_to_point (line 732) | def number_to_point(self, number: complex | float | np.array) -> Vect3:
method n2p (line 735) | def n2p(self, number: complex | float | np.array) -> Vect3:
method point_to_number (line 738) | def point_to_number(self, point: Vect3) -> complex:
method p2n (line 742) | def p2n(self, point: Vect3) -> complex:
method get_unit_size (line 745) | def get_unit_size(self) -> float:
method get_default_coordinate_values (line 748) | def get_default_coordinate_values(
method add_coordinate_labels (line 757) | def add_coordinate_labels(
FILE: manimlib/mobject/frame.py
class ScreenRectangle (line 12) | class ScreenRectangle(Rectangle):
method __init__ (line 13) | def __init__(
class FullScreenRectangle (line 26) | class FullScreenRectangle(ScreenRectangle):
method __init__ (line 27) | def __init__(
class FullScreenFadeRectangle (line 44) | class FullScreenFadeRectangle(FullScreenRectangle):
method __init__ (line 45) | def __init__(
FILE: manimlib/mobject/functions.py
class ParametricCurve (line 17) | class ParametricCurve(VMobject):
method __init__ (line 18) | def __init__(
method get_point_from_function (line 35) | def get_point_from_function(self, t: float) -> Vect3:
method init_points (line 38) | def init_points(self):
method get_t_func (line 56) | def get_t_func(self):
method get_function (line 59) | def get_function(self):
method get_x_range (line 65) | def get_x_range(self):
class FunctionGraph (line 70) | class FunctionGraph(ParametricCurve):
method __init__ (line 71) | def __init__(
class ImplicitFunction (line 87) | class ImplicitFunction(VMobject):
method __init__ (line 88) | def __init__(
FILE: manimlib/mobject/geometry.py
class TipableVMobject (line 46) | class TipableVMobject(VMobject):
method add_tip (line 71) | def add_tip(self, at_start: bool = False, **kwargs) -> Self:
method create_tip (line 84) | def create_tip(self, at_start: bool = False, **kwargs) -> ArrowTip:
method get_unpositioned_tip (line 93) | def get_unpositioned_tip(self, **kwargs) -> ArrowTip:
method position_tip (line 103) | def position_tip(self, tip: ArrowTip, at_start: bool = False) -> Arrow...
method reset_endpoints_based_on_tip (line 116) | def reset_endpoints_based_on_tip(self, tip: ArrowTip, at_start: bool) ...
method asign_tip_attr (line 131) | def asign_tip_attr(self, tip: ArrowTip, at_start: bool) -> Self:
method has_tip (line 139) | def has_tip(self) -> bool:
method has_start_tip (line 142) | def has_start_tip(self) -> bool:
method pop_tips (line 146) | def pop_tips(self) -> VGroup:
method get_tips (line 158) | def get_tips(self) -> VGroup:
method get_tip (line 170) | def get_tip(self) -> ArrowTip:
method get_default_tip_length (line 179) | def get_default_tip_length(self) -> float:
method get_first_handle (line 182) | def get_first_handle(self) -> Vect3:
method get_last_handle (line 185) | def get_last_handle(self) -> Vect3:
method get_end (line 188) | def get_end(self) -> Vect3:
method get_start (line 194) | def get_start(self) -> Vect3:
method get_length (line 200) | def get_length(self) -> float:
class Arc (line 205) | class Arc(TipableVMobject):
method __init__ (line 227) | def __init__(
method get_arc_center (line 247) | def get_arc_center(self) -> Vect3:
method get_start_angle (line 262) | def get_start_angle(self) -> float:
method get_stop_angle (line 266) | def get_stop_angle(self) -> float:
method move_arc_center_to (line 270) | def move_arc_center_to(self, point: Vect3) -> Self:
class ArcBetweenPoints (line 275) | class ArcBetweenPoints(Arc):
method __init__ (line 296) | def __init__(
class CurvedArrow (line 309) | class CurvedArrow(ArcBetweenPoints):
method __init__ (line 330) | def __init__(
class CurvedDoubleArrow (line 340) | class CurvedDoubleArrow(CurvedArrow):
method __init__ (line 361) | def __init__(
class Circle (line 371) | class Circle(Arc):
method __init__ (line 389) | def __init__(
method surround (line 401) | def surround(
method point_at_angle (line 413) | def point_at_angle(self, angle: float) -> Vect3:
method get_radius (line 419) | def get_radius(self) -> float:
class Dot (line 423) | class Dot(Circle):
method __init__ (line 439) | def __init__(
class SmallDot (line 460) | class SmallDot(Dot):
method __init__ (line 476) | def __init__(
class Ellipse (line 485) | class Ellipse(Circle):
method __init__ (line 505) | def __init__(
class AnnularSector (line 516) | class AnnularSector(VMobject):
method __init__ (line 539) | def __init__(
class Sector (line 574) | class Sector(AnnularSector):
method __init__ (line 596) | def __init__(
class Annulus (line 610) | class Annulus(VMobject):
method __init__ (line 630) | def __init__(
class Line (line 655) | class Line(TipableVMobject):
method __init__ (line 673) | def __init__(
method set_points_by_ends (line 687) | def set_points_by_ends(
method reset_points_around_ends (line 705) | def reset_points_around_ends(self) -> Self:
method set_path_arc (line 713) | def set_path_arc(self, path_arc: float) -> Self:
method set_start_and_end_attrs (line 718) | def set_start_and_end_attrs(self, start: Vect3 | Mobject, end: Vect3 |...
method pointify (line 730) | def pointify(
method put_start_and_end_on (line 751) | def put_start_and_end_on(self, start: Vect3, end: Vect3) -> Self:
method get_vector (line 759) | def get_vector(self) -> Vect3:
method get_unit_vector (line 762) | def get_unit_vector(self) -> Vect3:
method get_angle (line 765) | def get_angle(self) -> float:
method get_projection (line 768) | def get_projection(self, point: Vect3) -> Vect3:
method get_slope (line 776) | def get_slope(self) -> float:
method set_angle (line 779) | def set_angle(self, angle: float, about_point: Optional[Vect3] = None)...
method set_length (line 788) | def set_length(self, length: float, **kwargs):
method get_arc_length (line 792) | def get_arc_length(self) -> float:
method set_perpendicular_to_camera (line 798) | def set_perpendicular_to_camera(self, camera_frame):
class DashedLine (line 808) | class DashedLine(Line):
method __init__ (line 828) | def __init__(
method calculate_num_dashes (line 847) | def calculate_num_dashes(self, dash_length: float, positive_space_rati...
method get_start (line 854) | def get_start(self) -> Vect3:
method get_end (line 860) | def get_end(self) -> Vect3:
method get_start_and_end (line 866) | def get_start_and_end(self) -> Tuple[Vect3, Vect3]:
method get_first_handle (line 869) | def get_first_handle(self) -> Vect3:
method get_last_handle (line 872) | def get_last_handle(self) -> Vect3:
class TangentLine (line 876) | class TangentLine(Line):
method __init__ (line 897) | def __init__(
class Elbow (line 911) | class Elbow(VMobject):
method __init__ (line 928) | def __init__(
class StrokeArrow (line 940) | class StrokeArrow(Line):
method __init__ (line 941) | def __init__(
method set_points_by_ends (line 968) | def set_points_by_ends(
method insert_tip_anchor (line 980) | def insert_tip_anchor(self) -> Self:
method create_tip_with_stroke_width (line 996) | def create_tip_with_stroke_width(self) -> Self:
method reset_tip (line 1008) | def reset_tip(self) -> Self:
method set_stroke (line 1015) | def set_stroke(
method _handle_scale_side_effects (line 1027) | def _handle_scale_side_effects(self, scale_factor: float) -> Self:
class Arrow (line 1033) | class Arrow(Line):
method __init__ (line 1077) | def __init__(
method get_key_dimensions (line 1108) | def get_key_dimensions(self, length):
method set_points_by_ends (line 1123) | def set_points_by_ends(
method get_start (line 1188) | def get_start(self) -> Vect3:
method get_end (line 1192) | def get_end(self) -> Vect3:
method get_start_and_end (line 1195) | def get_start_and_end(self):
method put_start_and_end_on (line 1198) | def put_start_and_end_on(self, start: Vect3, end: Vect3) -> Self:
method scale (line 1202) | def scale(self, *args, **kwargs) -> Self:
method set_thickness (line 1207) | def set_thickness(self, thickness: float) -> Self:
class Vector (line 1213) | class Vector(Arrow):
method __init__ (line 1228) | def __init__(
class CubicBezier (line 1239) | class CubicBezier(VMobject):
method __init__ (line 1267) | def __init__(
class Polygon (line 1279) | class Polygon(VMobject):
method __init__ (line 1294) | def __init__(
method get_vertices (line 1302) | def get_vertices(self) -> Vect3Array:
method round_corners (line 1305) | def round_corners(self, radius: Optional[float] = None) -> Self:
class Polyline (line 1341) | class Polyline(VMobject):
method __init__ (line 1342) | def __init__(
class RegularPolygon (line 1351) | class RegularPolygon(Polygon):
method __init__ (line 1368) | def __init__(
class Triangle (line 1383) | class Triangle(RegularPolygon):
method __init__ (line 1398) | def __init__(self, **kwargs):
class ArrowTip (line 1402) | class ArrowTip(Triangle):
method __init__ (line 1403) | def __init__(
method get_base (line 1431) | def get_base(self) -> Vect3:
method get_tip_point (line 1434) | def get_tip_point(self) -> Vect3:
method get_vector (line 1437) | def get_vector(self) -> Vect3:
method get_angle (line 1440) | def get_angle(self) -> float:
method get_length (line 1443) | def get_length(self) -> float:
class Rectangle (line 1447) | class Rectangle(Polygon):
method __init__ (line 1464) | def __init__(
method surround (line 1474) | def surround(self, mobject, buff=SMALL_BUFF) -> Self:
class Square (line 1481) | class Square(Rectangle):
method __init__ (line 1496) | def __init__(self, side_length: float = 2.0, **kwargs):
class RoundedRectangle (line 1500) | class RoundedRectangle(Rectangle):
method __init__ (line 1519) | def __init__(
FILE: manimlib/mobject/interactive.py
class MotionMobject (line 34) | class MotionMobject(Mobject):
method __init__ (line 38) | def __init__(self, mobject: Mobject, **kwargs):
method mob_on_mouse_drag (line 47) | def mob_on_mouse_drag(self, mob: Mobject, event_data: dict[str, np.nda...
class Button (line 52) | class Button(Mobject):
method __init__ (line 59) | def __init__(self, mobject: Mobject, on_click: Callable[[Mobject]], **...
method mob_on_mouse_press (line 67) | def mob_on_mouse_press(self, mob: Mobject, event_data) -> bool:
class ControlMobject (line 74) | class ControlMobject(ValueTracker):
method __init__ (line 75) | def __init__(self, value: float, *mobjects: Mobject, **kwargs):
method set_value (line 83) | def set_value(self, value: float):
method assert_value (line 88) | def assert_value(self, value):
method set_value_anim (line 92) | def set_value_anim(self, value):
class EnableDisableButton (line 97) | class EnableDisableButton(ControlMobject):
method __init__ (line 98) | def __init__(
method assert_value (line 121) | def assert_value(self, value: bool) -> None:
method set_value_anim (line 124) | def set_value_anim(self, value: bool) -> None:
method toggle_value (line 130) | def toggle_value(self) -> None:
method on_mouse_press (line 133) | def on_mouse_press(self, mob: Mobject, event_data) -> bool:
class Checkbox (line 138) | class Checkbox(ControlMobject):
method __init__ (line 139) | def __init__(
method assert_value (line 170) | def assert_value(self, value: bool) -> None:
method toggle_value (line 173) | def toggle_value(self) -> None:
method set_value_anim (line 176) | def set_value_anim(self, value: bool) -> None:
method on_mouse_press (line 182) | def on_mouse_press(self, mob: Mobject, event_data) -> None:
method get_checkmark (line 188) | def get_checkmark(self) -> VGroup:
method get_cross (line 200) | def get_cross(self) -> VGroup:
class LinearNumberSlider (line 213) | class LinearNumberSlider(ControlMobject):
method __init__ (line 214) | def __init__(
method assert_value (line 254) | def assert_value(self, value: float) -> None:
method set_value_anim (line 257) | def set_value_anim(self, value: float) -> None:
method slider_on_mouse_drag (line 261) | def slider_on_mouse_drag(self, mob, event_data: dict[str, np.ndarray])...
method get_value_from_point (line 267) | def get_value_from_point(self, point: np.ndarray) -> float:
class ColorSliders (line 277) | class ColorSliders(Group):
method __init__ (line 278) | def __init__(
method get_background (line 338) | def get_background(self) -> VGroup:
method set_value (line 360) | def set_value(self, r: float, g: float, b: float, a: float):
method get_value (line 366) | def get_value(self) -> np.ndarary:
method get_picked_color (line 373) | def get_picked_color(self) -> str:
method get_picked_opacity (line 377) | def get_picked_opacity(self) -> float:
class Textbox (line 382) | class Textbox(ControlMobject):
method __init__ (line 383) | def __init__(
method set_value_anim (line 419) | def set_value_anim(self, value: str) -> None:
method update_text (line 422) | def update_text(self, value: str) -> None:
method active_anim (line 434) | def active_anim(self, isActive: bool) -> None:
method box_on_mouse_press (line 440) | def box_on_mouse_press(self, mob, event_data) -> bool:
method on_key_press (line 445) | def on_key_press(self, mob: Mobject, event_data: dict[str, int]) -> bo...
class ControlPanel (line 467) | class ControlPanel(Group):
method __init__ (line 468) | def __init__(
method move_panel_and_controls_to_panel_opener (line 520) | def move_panel_and_controls_to_panel_opener(self) -> None:
method add_controls (line 536) | def add_controls(self, *new_controls: ControlMobject) -> None:
method remove_controls (line 540) | def remove_controls(self, *controls_to_remove: ControlMobject) -> None:
method open_panel (line 544) | def open_panel(self):
method close_panel (line 551) | def close_panel(self):
method panel_opener_on_mouse_drag (line 558) | def panel_opener_on_mouse_drag(self, mob, event_data: dict[str, np.nda...
method panel_on_mouse_scroll (line 564) | def panel_on_mouse_scroll(self, mob, event_data: dict[str, np.ndarray]...
FILE: manimlib/mobject/matrix.py
class Matrix (line 24) | class Matrix(VMobject):
method __init__ (line 25) | def __init__(
method copy (line 73) | def copy(self, deep: bool = False):
method create_mobject_matrix (line 84) | def create_mobject_matrix(
method element_to_mobject (line 111) | def element_to_mobject(self, element, **config) -> VMobject:
method create_brackets (line 119) | def create_brackets(self, rows, v_buff: float, h_buff: float) -> VGroup:
method get_column (line 132) | def get_column(self, index: int):
method get_row (line 137) | def get_row(self, index: int):
method get_columns (line 142) | def get_columns(self) -> VGroup:
method get_rows (line 145) | def get_rows(self) -> VGroup:
method set_column_colors (line 148) | def set_column_colors(self, *colors: ManimColor) -> Self:
method add_background_to_entries (line 154) | def add_background_to_entries(self) -> Self:
method swap_entry_for_dots (line 159) | def swap_entry_for_dots(self, entry, dots):
method swap_entries_for_ellipses (line 167) | def swap_entries_for_ellipses(
method get_mob_matrix (line 202) | def get_mob_matrix(self) -> VMobjectMatrixType:
method get_entries (line 205) | def get_entries(self) -> VGroup:
method get_brackets (line 208) | def get_brackets(self) -> VGroup:
method get_ellipses (line 211) | def get_ellipses(self) -> VGroup:
class DecimalMatrix (line 215) | class DecimalMatrix(Matrix):
method __init__ (line 216) | def __init__(
method element_to_mobject (line 233) | def element_to_mobject(self, element, **decimal_config) -> DecimalNumber:
class IntegerMatrix (line 237) | class IntegerMatrix(DecimalMatrix):
method __init__ (line 238) | def __init__(
class TexMatrix (line 248) | class TexMatrix(Matrix):
method __init__ (line 249) | def __init__(
class MobjectMatrix (line 262) | class MobjectMatrix(Matrix):
method __init__ (line 263) | def __init__(
method element_to_mobject (line 292) | def element_to_mobject(self, element: VMobject, **config) -> VMobject:
FILE: manimlib/mobject/mobject.py
class Mobject (line 64) | class Mobject(object):
method __init__ (line 79) | def __init__(
method __str__ (line 126) | def __str__(self):
method __add__ (line 129) | def __add__(self, other: Mobject) -> Mobject:
method __mul__ (line 133) | def __mul__(self, other: int) -> Mobject:
method init_data (line 137) | def init_data(self, length: int = 0):
method init_uniforms (line 141) | def init_uniforms(self):
method init_colors (line 151) | def init_colors(self):
method init_points (line 154) | def init_points(self):
method set_uniforms (line 158) | def set_uniforms(self, uniforms: dict) -> Self:
method animate (line 166) | def animate(self) -> _AnimationBuilder | Self:
method always (line 177) | def always(self) -> _UpdaterBuilder:
method f_always (line 186) | def f_always(self) -> _FunctionalUpdaterBuilder:
method note_changed_data (line 208) | def note_changed_data(self, recurse_up: bool = True) -> Self:
method affects_data (line 216) | def affects_data(func: Callable[..., T]) -> Callable[..., T]:
method affects_family_data (line 225) | def affects_family_data(func: Callable[..., T]) -> Callable[..., T]:
method set_data (line 236) | def set_data(self, data: np.ndarray) -> Self:
method resize_points (line 243) | def resize_points(
method set_points (line 259) | def set_points(self, points: Vect3Array | list[Vect3]) -> Self:
method append_points (line 265) | def append_points(self, new_points: Vect3Array) -> Self:
method reverse_points (line 276) | def reverse_points(self) -> Self:
method apply_points_function (line 282) | def apply_points_function(
method match_points (line 311) | def match_points(self, mobject: Mobject) -> Self:
method get_points (line 319) | def get_points(self) -> Vect3Array:
method clear_points (line 322) | def clear_points(self) -> Self:
method get_num_points (line 326) | def get_num_points(self) -> int:
method get_all_points (line 329) | def get_all_points(self) -> Vect3Array:
method has_points (line 335) | def has_points(self) -> bool:
method get_bounding_box (line 338) | def get_bounding_box(self) -> Vect3Array:
method compute_bounding_box (line 344) | def compute_bounding_box(self) -> Vect3Array:
method refresh_bounding_box (line 362) | def refresh_bounding_box(
method are_points_touching (line 374) | def are_points_touching(
method is_point_touching (line 384) | def is_point_touching(
method is_touching (line 391) | def is_touching(self, mobject: Mobject, buff: float = 1e-2) -> bool:
method __getitem__ (line 401) | def __getitem__(self, value: int | slice) -> Mobject:
method __iter__ (line 407) | def __iter__(self) -> Iterator[Self]:
method __len__ (line 410) | def __len__(self) -> int:
method split (line 413) | def split(self) -> list[Self]:
method note_changed_family (line 417) | def note_changed_family(self, only_changed_order=False) -> Self:
method get_family (line 426) | def get_family(self, recurse: bool = True) -> list[Mobject]:
method family_members_with_points (line 435) | def family_members_with_points(self) -> list[Mobject]:
method get_ancestors (line 438) | def get_ancestors(self, extended: bool = False) -> list[Mobject]:
method add (line 459) | def add(self, *mobjects: Mobject) -> Self:
method remove (line 470) | def remove(
method clear (line 486) | def clear(self) -> Self:
method add_to_back (line 490) | def add_to_back(self, *mobjects: Mobject) -> Self:
method replace_submobject (line 494) | def replace_submobject(self, index: int, new_submob: Mobject) -> Self:
method insert_submobject (line 503) | def insert_submobject(self, index: int, new_submob: Mobject) -> Self:
method set_submobjects (line 508) | def set_submobjects(self, submobject_list: list[Mobject]) -> Self:
method digest_mobject_attrs (line 515) | def digest_mobject_attrs(self) -> Self:
method arrange (line 526) | def arrange(
method arrange_in_grid (line 538) | def arrange_in_grid(
method arrange_to_fit_dim (line 583) | def arrange_to_fit_dim(self, length: float, dim: int, about_edge=ORIGI...
method arrange_to_fit_width (line 599) | def arrange_to_fit_width(self, width: float, about_edge=ORIGIN) -> Self:
method arrange_to_fit_height (line 602) | def arrange_to_fit_height(self, height: float, about_edge=ORIGIN) -> S...
method arrange_to_fit_depth (line 605) | def arrange_to_fit_depth(self, depth: float, about_edge=ORIGIN) -> Self:
method sort (line 608) | def sort(
method shuffle (line 620) | def shuffle(self, recurse: bool = False) -> Self:
method reverse_submobjects (line 628) | def reverse_submobjects(self) -> Self:
method stash_mobject_pointers (line 636) | def stash_mobject_pointers(func: Callable[..., T]) -> Callable[..., T]:
method serialize (line 653) | def serialize(self) -> bytes:
method deserialize (line 656) | def deserialize(self, data: bytes) -> Self:
method deepcopy (line 661) | def deepcopy(self) -> Self:
method copy (line 664) | def copy(self, deep: bool = False) -> Self:
method generate_target (line 705) | def generate_target(self, use_deepcopy: bool = False) -> Self:
method save_state (line 710) | def save_state(self, use_deepcopy: bool = False) -> Self:
method restore (line 715) | def restore(self) -> Self:
method become (line 721) | def become(self, mobject: Mobject, match_updaters=False) -> Self:
method looks_identical (line 746) | def looks_identical(self, mobject: Mobject) -> bool:
method has_same_shape_as (line 770) | def has_same_shape_as(self, mobject: Mobject) -> bool:
method replicate (line 782) | def replicate(self, n: int) -> Self:
method get_grid (line 786) | def get_grid(
method init_updaters (line 820) | def init_updaters(self):
method update (line 825) | def update(self, dt: float = 0, recurse: bool = True) -> Self:
method get_updaters (line 840) | def get_updaters(self) -> list[Updater]:
method add_updater (line 843) | def add_updater(self, update_func: Updater, call: bool = True) -> Self:
method insert_updater (line 851) | def insert_updater(self, update_func: Updater, index=0):
method remove_updater (line 856) | def remove_updater(self, update_func: Updater) -> Self:
method clear_updaters (line 862) | def clear_updaters(self, recurse: bool = True) -> Self:
method match_updaters (line 870) | def match_updaters(self, mobject: Mobject) -> Self:
method suspend_updating (line 875) | def suspend_updating(self, recurse: bool = True) -> Self:
method resume_updating (line 882) | def resume_updating(self, recurse: bool = True, call_updater: bool = T...
method has_updaters (line 893) | def has_updaters(self) -> bool:
method refresh_has_updater_status (line 901) | def refresh_has_updater_status(self) -> Self:
method is_changing (line 909) | def is_changing(self) -> bool:
method set_animating_status (line 912) | def set_animating_status(self, is_animating: bool, recurse: bool = Tru...
method shift (line 919) | def shift(self, vector: Vect3) -> Self:
method scale (line 927) | def scale(
method _handle_scale_side_effects (line 957) | def _handle_scale_side_effects(self, scale_factor):
method stretch (line 962) | def stretch(self, factor: float, dim: int, **kwargs) -> Self:
method rotate_about_origin (line 969) | def rotate_about_origin(self, angle: float, axis: Vect3 = OUT) -> Self:
method rotate (line 972) | def rotate(
method flip (line 987) | def flip(self, axis: Vect3 = UP, **kwargs) -> Self:
method apply_function (line 990) | def apply_function(self, function: Callable[[np.ndarray], np.ndarray],...
method apply_function_to_position (line 1000) | def apply_function_to_position(self, function: Callable[[np.ndarray], ...
method apply_function_to_submobject_positions (line 1004) | def apply_function_to_submobject_positions(
method apply_matrix (line 1012) | def apply_matrix(self, matrix: npt.ArrayLike, **kwargs) -> Self:
method apply_complex_function (line 1025) | def apply_complex_function(self, function: Callable[[complex], complex...
method wag (line 1036) | def wag(
method center (line 1055) | def center(self) -> Self:
method align_on_border (line 1059) | def align_on_border(
method to_corner (line 1075) | def to_corner(
method to_edge (line 1082) | def to_edge(
method next_to (line 1089) | def next_to(
method shift_onto_screen (line 1120) | def shift_onto_screen(self, **kwargs) -> Self:
method is_off_screen (line 1131) | def is_off_screen(self) -> bool:
method stretch_about_point (line 1142) | def stretch_about_point(self, factor: float, dim: int, point: Vect3) -...
method stretch_in_place (line 1145) | def stretch_in_place(self, factor: float, dim: int) -> Self:
method rescale_to_fit (line 1149) | def rescale_to_fit(self, length: float, dim: int, stretch: bool = Fals...
method stretch_to_fit_width (line 1159) | def stretch_to_fit_width(self, width: float, **kwargs) -> Self:
method stretch_to_fit_height (line 1162) | def stretch_to_fit_height(self, height: float, **kwargs) -> Self:
method stretch_to_fit_depth (line 1165) | def stretch_to_fit_depth(self, depth: float, **kwargs) -> Self:
method set_width (line 1168) | def set_width(self, width: float, stretch: bool = False, **kwargs) -> ...
method set_height (line 1171) | def set_height(self, height: float, stretch: bool = False, **kwargs) -...
method set_depth (line 1174) | def set_depth(self, depth: float, stretch: bool = False, **kwargs) -> ...
method set_max_width (line 1177) | def set_max_width(self, max_width: float, **kwargs) -> Self:
method set_max_height (line 1182) | def set_max_height(self, max_height: float, **kwargs) -> Self:
method set_max_depth (line 1187) | def set_max_depth(self, max_depth: float, **kwargs) -> Self:
method set_min_width (line 1192) | def set_min_width(self, min_width: float, **kwargs) -> Self:
method set_min_height (line 1197) | def set_min_height(self, min_height: float, **kwargs) -> Self:
method set_min_depth (line 1202) | def set_min_depth(self, min_depth: float, **kwargs) -> Self:
method set_shape (line 1207) | def set_shape(
method set_coord (line 1222) | def set_coord(self, value: float, dim: int, direction: Vect3 = ORIGIN)...
method set_x (line 1229) | def set_x(self, x: float, direction: Vect3 = ORIGIN) -> Self:
method set_y (line 1232) | def set_y(self, y: float, direction: Vect3 = ORIGIN) -> Self:
method set_z (line 1235) | def set_z(self, z: float, direction: Vect3 = ORIGIN) -> Self:
method set_z_index (line 1238) | def set_z_index(self, z_index: int, recurse=True) -> Self:
method space_out_submobjects (line 1243) | def space_out_submobjects(self, factor: float = 1.5, **kwargs) -> Self:
method move_to (line 1249) | def move_to(
method replace (line 1263) | def replace(self, mobject: Mobject, dim_to_match: int = 0, stretch: bo...
method surround (line 1279) | def surround(
method put_start_on (line 1291) | def put_start_on(self, point: Vect3) -> Self:
method put_end_on (line 1295) | def put_end_on(self, point: Vect3) -> Self:
method put_start_and_end_on (line 1299) | def put_start_and_end_on(self, start: Vect3, end: Vect3) -> Self:
method set_rgba_array (line 1322) | def set_rgba_array(
method set_color_by_rgba_func (line 1333) | def set_color_by_rgba_func(
method set_color_by_rgb_func (line 1345) | def set_color_by_rgb_func(
method set_rgba_array_by_color (line 1361) | def set_rgba_array_by_color(
method set_color (line 1381) | def set_color(
method set_opacity (line 1395) | def set_opacity(
method get_color (line 1406) | def get_color(self) -> str:
method get_opacity (line 1409) | def get_opacity(self) -> float:
method get_opacities (line 1412) | def get_opacities(self) -> float:
method set_color_by_gradient (line 1415) | def set_color_by_gradient(self, *colors: ManimColor) -> Self:
method set_submobject_colors_by_gradient (line 1422) | def set_submobject_colors_by_gradient(self, *colors: ManimColor, inter...
method fade (line 1436) | def fade(self, darkness: float = 0.5, recurse: bool = True) -> Self:
method get_shading (line 1439) | def get_shading(self) -> np.ndarray:
method set_shading (line 1442) | def set_shading(
method get_reflectiveness (line 1462) | def get_reflectiveness(self) -> float:
method get_gloss (line 1465) | def get_gloss(self) -> float:
method get_shadow (line 1468) | def get_shadow(self) -> float:
method set_reflectiveness (line 1471) | def set_reflectiveness(self, reflectiveness: float, recurse: bool = Tr...
method set_gloss (line 1475) | def set_gloss(self, gloss: float, recurse: bool = True) -> Self:
method set_shadow (line 1479) | def set_shadow(self, shadow: float, recurse: bool = True) -> Self:
method add_background_rectangle (line 1485) | def add_background_rectangle(
method add_background_rectangle_to_submobjects (line 1500) | def add_background_rectangle_to_submobjects(self, **kwargs) -> Self:
method add_background_rectangle_to_family_members_with_points (line 1505) | def add_background_rectangle_to_family_members_with_points(self, **kwa...
method get_bounding_box_point (line 1512) | def get_bounding_box_point(self, direction: Vect3) -> Vect3:
method get_edge_center (line 1520) | def get_edge_center(self, direction: Vect3) -> Vect3:
method get_corner (line 1523) | def get_corner(self, direction: Vect3) -> Vect3:
method get_all_corners (line 1526) | def get_all_corners(self):
method get_center (line 1533) | def get_center(self) -> Vect3:
method get_center_of_mass (line 1536) | def get_center_of_mass(self) -> Vect3:
method get_boundary_point (line 1539) | def get_boundary_point(self, direction: Vect3) -> Vect3:
method get_continuous_bounding_box_point (line 1547) | def get_continuous_bounding_box_point(self, direction: Vect3) -> Vect3:
method get_top (line 1556) | def get_top(self) -> Vect3:
method get_bottom (line 1559) | def get_bottom(self) -> Vect3:
method get_right (line 1562) | def get_right(self) -> Vect3:
method get_left (line 1565) | def get_left(self) -> Vect3:
method get_zenith (line 1568) | def get_zenith(self) -> Vect3:
method get_nadir (line 1571) | def get_nadir(self) -> Vect3:
method length_over_dim (line 1574) | def length_over_dim(self, dim: int) -> float:
method get_width (line 1578) | def get_width(self) -> float:
method get_height (line 1581) | def get_height(self) -> float:
method get_depth (line 1584) | def get_depth(self) -> float:
method get_shape (line 1587) | def get_shape(self) -> Tuple[float]:
method get_coord (line 1590) | def get_coord(self, dim: int, direction: Vect3 = ORIGIN) -> float:
method get_x (line 1596) | def get_x(self, direction=ORIGIN) -> float:
method get_y (line 1599) | def get_y(self, direction=ORIGIN) -> float:
method get_z (line 1602) | def get_z(self, direction=ORIGIN) -> float:
method get_start (line 1605) | def get_start(self) -> Vect3:
method get_end (line 1609) | def get_end(self) -> Vect3:
method get_start_and_end (line 1613) | def get_start_and_end(self) -> tuple[Vect3, Vect3]:
method point_from_proportion (line 1618) | def point_from_proportion(self, alpha: float) -> Vect3:
method pfp (line 1623) | def pfp(self, alpha):
method get_pieces (line 1627) | def get_pieces(self, n_pieces: int) -> Group:
method get_z_index_reference_point (line 1638) | def get_z_index_reference_point(self) -> Vect3:
method match_color (line 1645) | def match_color(self, mobject: Mobject) -> Self:
method match_style (line 1648) | def match_style(self, mobject: Mobject) -> Self:
method match_dim_size (line 1654) | def match_dim_size(self, mobject: Mobject, dim: int, **kwargs) -> Self:
method match_width (line 1660) | def match_width(self, mobject: Mobject, **kwargs) -> Self:
method match_height (line 1663) | def match_height(self, mobject: Mobject, **kwargs) -> Self:
method match_depth (line 1666) | def match_depth(self, mobject: Mobject, **kwargs) -> Self:
method match_coord (line 1669) | def match_coord(
method match_x (line 1681) | def match_x(
method match_y (line 1688) | def match_y(
method match_z (line 1695) | def match_z(
method align_to (line 1702) | def align_to(
method get_group_class (line 1726) | def get_group_class(self):
method is_aligned_with (line 1731) | def is_aligned_with(self, mobject: Mobject) -> bool:
method align_data_and_family (line 1741) | def align_data_and_family(self, mobject: Mobject) -> Self:
method align_data (line 1746) | def align_data(self, mobject: Mobject) -> Self:
method align_points (line 1751) | def align_points(self, mobject: Mobject) -> Self:
method align_family (line 1757) | def align_family(self, mobject: Mobject) -> Self:
method push_self_into_submobjects (line 1770) | def push_self_into_submobjects(self) -> Self:
method add_n_more_submobjects (line 1777) | def add_n_more_submobjects(self, n: int) -> Self:
method invisible_copy (line 1805) | def invisible_copy(self) -> Self:
method interpolate (line 1810) | def interpolate(
method pointwise_become_partial (line 1840) | def pointwise_become_partial(self, mobject, a, b) -> Self:
method lock_data (line 1852) | def lock_data(self, keys: Iterable[str]) -> Self:
method lock_uniforms (line 1865) | def lock_uniforms(self, keys: Iterable[str]) -> Self:
method lock_matching_data (line 1871) | def lock_matching_data(self, mobject1: Mobject, mobject2: Mobject) -> ...
method unlock_data (line 1899) | def unlock_data(self) -> Self:
method affects_shader_info_id (line 1909) | def affects_shader_info_id(func: Callable[..., T]) -> Callable[..., T]:
method set_uniform (line 1918) | def set_uniform(self, recurse: bool = True, **new_uniforms) -> Self:
method fix_in_frame (line 1924) | def fix_in_frame(self, recurse: bool = True) -> Self:
method unfix_from_frame (line 1929) | def unfix_from_frame(self, recurse: bool = True) -> Self:
method is_fixed_in_frame (line 1933) | def is_fixed_in_frame(self) -> bool:
method apply_depth_test (line 1937) | def apply_depth_test(self, recurse: bool = True) -> Self:
method deactivate_depth_test (line 1943) | def deactivate_depth_test(self, recurse: bool = True) -> Self:
method set_clip_plane (line 1948) | def set_clip_plane(self, vect: Vect3, threshold: float, recurse=True) ...
method set_clip_planes (line 1953) | def set_clip_planes(
method deactivate_clip_plane (line 1965) | def deactivate_clip_plane(self, recurse=True) -> Self:
method clip_to_box (line 1971) | def clip_to_box(self, box: Mobject, recurse=True) -> Self:
method replace_shader_code (line 1983) | def replace_shader_code(self, old: str, new: str) -> Self:
method set_color_by_code (line 1989) | def set_color_by_code(self, glsl_code: str) -> Self:
method set_color_by_xyz_func (line 2002) | def set_color_by_xyz_func(
method init_shader_wrapper (line 2030) | def init_shader_wrapper(self, ctx: Context):
method refresh_shader_wrapper_id (line 2042) | def refresh_shader_wrapper_id(self):
method get_shader_wrapper (line 2051) | def get_shader_wrapper(self, ctx: Context) -> ShaderWrapper:
method get_shader_wrapper_list (line 2056) | def get_shader_wrapper_list(self, ctx: Context) -> list[ShaderWrapper]:
method get_shader_data (line 2068) | def get_shader_data(self) -> np.ndarray:
method get_uniforms (line 2075) | def get_uniforms(self):
method get_shader_vert_indices (line 2078) | def get_shader_vert_indices(self) -> Optional[np.ndarray]:
method render (line 2081) | def render(self, ctx: Context, camera_uniforms: dict):
method init_event_listners (line 2101) | def init_event_listners(self):
method add_event_listner (line 2104) | def add_event_listner(
method remove_event_listner (line 2114) | def remove_event_listner(
method clear_event_listners (line 2125) | def clear_event_listners(self, recurse: bool = True):
method get_event_listners (line 2132) | def get_event_listners(self):
method get_family_event_listners (line 2135) | def get_family_event_listners(self):
method get_has_event_listner (line 2138) | def get_has_event_listner(self):
method add_mouse_motion_listner (line 2144) | def add_mouse_motion_listner(self, callback):
method remove_mouse_motion_listner (line 2147) | def remove_mouse_motion_listner(self, callback):
method add_mouse_press_listner (line 2150) | def add_mouse_press_listner(self, callback):
method remove_mouse_press_listner (line 2153) | def remove_mouse_press_listner(self, callback):
method add_mouse_release_listner (line 2156) | def add_mouse_release_listner(self, callback):
method remove_mouse_release_listner (line 2159) | def remove_mouse_release_listner(self, callback):
method add_mouse_drag_listner (line 2162) | def add_mouse_drag_listner(self, callback):
method remove_mouse_drag_listner (line 2165) | def remove_mouse_drag_listner(self, callback):
method add_mouse_scroll_listner (line 2168) | def add_mouse_scroll_listner(self, callback):
method remove_mouse_scroll_listner (line 2171) | def remove_mouse_scroll_listner(self, callback):
method add_key_press_listner (line 2174) | def add_key_press_listner(self, callback):
method remove_key_press_listner (line 2177) | def remove_key_press_listner(self, callback):
method add_key_release_listner (line 2180) | def add_key_release_listner(self, callback):
method remove_key_release_listner (line 2183) | def remove_key_release_listner(self, callback):
method throw_error_if_no_points (line 2188) | def throw_error_if_no_points(self):
class Group (line 2196) | class Group(Mobject, Generic[SubmobjectType]):
method __init__ (line 2197) | def __init__(self, *mobjects: SubmobjectType | Iterable[SubmobjectType...
method _ingest_args (line 2201) | def _ingest_args(self, *args: Mobject | Iterable[Mobject]):
method __add__ (line 2211) | def __add__(self, other: Mobject | Group) -> Self:
method __getitem__ (line 2216) | def __getitem__(self, index) -> SubmobjectType:
class Point (line 2220) | class Point(Mobject):
method __init__ (line 2221) | def __init__(
method get_width (line 2233) | def get_width(self) -> float:
method get_height (line 2236) | def get_height(self) -> float:
method get_location (line 2239) | def get_location(self) -> Vect3:
method get_bounding_box_point (line 2242) | def get_bounding_box_point(self, *args, **kwargs) -> Vect3:
method set_location (line 2245) | def set_location(self, new_loc: npt.ArrayLike) -> Self:
class _AnimationBuilder (line 2250) | class _AnimationBuilder:
method __init__ (line 2251) | def __init__(self, mobject: Mobject):
method __getattr__ (line 2260) | def __getattr__(self, method_name: str):
method __call__ (line 2283) | def __call__(self, **kwargs):
method __dir__ (line 2286) | def __dir__(self) -> list[str]:
method set_anim_args (line 2298) | def set_anim_args(self, **kwargs):
method build (line 2322) | def build(self):
function override_animate (line 2331) | def override_animate(method):
class _UpdaterBuilder (line 2339) | class _UpdaterBuilder:
method __init__ (line 2340) | def __init__(self, mobject: Mobject):
method __getattr__ (line 2343) | def __getattr__(self, method_name: str):
class _FunctionalUpdaterBuilder (line 2352) | class _FunctionalUpdaterBuilder:
method __init__ (line 2353) | def __init__(self, mobject: Mobject):
method __getattr__ (line 2356) | def __getattr__(self, method_name: str):
FILE: manimlib/mobject/mobject_update_utils.py
function assert_is_mobject_method (line 20) | def assert_is_mobject_method(method):
function always (line 26) | def always(method, *args, **kwargs):
function f_always (line 34) | def f_always(method, *arg_generators, **kwargs):
function always_redraw (line 55) | def always_redraw(func: Callable[..., Mobject], *args, **kwargs) -> Mobj...
function always_shift (line 61) | def always_shift(
function always_rotate (line 72) | def always_rotate(
function turn_animation_into_updater (line 83) | def turn_animation_into_updater(
function cycle_animation (line 120) | def cycle_animation(animation: Animation, **kwargs) -> Mobject:
FILE: manimlib/mobject/number_line.py
class NumberLine (line 27) | class NumberLine(Line):
method __init__ (line 28) | def __init__(
method get_tick_range (line 104) | def get_tick_range(self) -> np.ndarray:
method add_ticks (line 112) | def add_ticks(self) -> None:
method get_tick (line 122) | def get_tick(self, x: float, size: float | None = None) -> Line:
method get_tick_marks (line 131) | def get_tick_marks(self) -> VGroup:
method number_to_point (line 134) | def number_to_point(self, number: float | VectN) -> Vect3 | Vect3Array:
method point_to_number (line 140) | def point_to_number(self, point: Vect3 | Vect3Array) -> float | VectN:
method n2p (line 150) | def n2p(self, number: float | VectN) -> Vect3 | Vect3Array:
method p2n (line 154) | def p2n(self, point: Vect3 | Vect3Array) -> float | VectN:
method get_unit_size (line 158) | def get_unit_size(self) -> float:
method get_number_mobject (line 161) | def get_number_mobject(
method add_numbers (line 199) | def add_numbers(
class UnitInterval (line 224) | class UnitInterval(NumberLine):
method __init__ (line 225) | def __init__(
class Slider (line 244) | class Slider(VGroup):
method __init__ (line 245) | def __init__(
FILE: manimlib/mobject/numbers.py
function char_to_cahced_mob (line 25) | def char_to_cahced_mob(char: str, **text_config):
class DecimalNumber (line 34) | class DecimalNumber(VMobject):
method __init__ (line 35) | def __init__(
method set_submobjects_from_number (line 80) | def set_submobjects_from_number(self, number: float | complex) -> None:
method get_num_string (line 123) | def get_num_string(self, number: float | complex) -> str:
method char_to_mob (line 148) | def char_to_mob(self, char: str) -> Text:
method interpolate (line 151) | def interpolate(
method get_font_size (line 162) | def get_font_size(self) -> float:
method get_formatter (line 165) | def get_formatter(self, **kwargs) -> str:
method get_complex_formatter (line 197) | def get_complex_formatter(self, **kwargs) -> str:
method get_tex (line 204) | def get_tex(self):
method set_value (line 207) | def set_value(self, number: float | complex) -> Self:
method _handle_scale_side_effects (line 217) | def _handle_scale_side_effects(self, scale_factor: float) -> Self:
method get_value (line 221) | def get_value(self) -> float | complex:
method increment_value (line 224) | def increment_value(self, delta_t: float | complex = 1) -> Self:
class Integer (line 229) | class Integer(DecimalNumber):
method __init__ (line 230) | def __init__(
method get_value (line 238) | def get_value(self) -> int:
FILE: manimlib/mobject/probability.py
class SampleSpace (line 28) | class SampleSpace(Rectangle):
method __init__ (line 29) | def __init__(
method add_title (line 50) | def add_title(
method add_label (line 63) | def add_label(self, label: str) -> None:
method complete_p_list (line 66) | def complete_p_list(self, p_list: list[float]) -> list[float]:
method get_division_along_dimension (line 73) | def get_division_along_dimension(
method get_horizontal_division (line 95) | def get_horizontal_division(
method get_vertical_division (line 103) | def get_vertical_division(
method divide_horizontally (line 111) | def divide_horizontally(self, *args, **kwargs) -> None:
method divide_vertically (line 115) | def divide_vertically(self, *args, **kwargs) -> None:
method get_subdivision_braces_and_labels (line 119) | def get_subdivision_braces_and_labels(
method get_side_braces_and_labels (line 151) | def get_side_braces_and_labels(
method get_top_braces_and_labels (line 161) | def get_top_braces_and_labels(
method get_bottom_braces_and_labels (line 170) | def get_bottom_braces_and_labels(
method add_braces_and_labels (line 179) | def add_braces_and_labels(self) -> None:
method __getitem__ (line 188) | def __getitem__(self, index: int | slice) -> VGroup:
class BarChart (line 196) | class BarChart(VGroup):
method __init__ (line 197) | def __init__(
method add_axes (line 240) | def add_axes(self) -> None:
method add_bars (line 277) | def add_bars(self, values: Iterable[float]) -> None:
method change_bar_values (line 302) | def change_bar_values(self, values: Iterable[float]) -> None:
FILE: manimlib/mobject/shape_matchers.py
class SurroundingRectangle (line 22) | class SurroundingRectangle(Rectangle):
method __init__ (line 23) | def __init__(
method surround (line 36) | def surround(self, mobject, buff=None) -> Self:
method set_buff (line 42) | def set_buff(self, buff) -> Self:
class BackgroundRectangle (line 48) | class BackgroundRectangle(SurroundingRectangle):
method __init__ (line 49) | def __init__(
method pointwise_become_partial (line 72) | def pointwise_become_partial(self, mobject: Mobject, a: float, b: floa...
method set_style (line 76) | def set_style(
method get_fill_color (line 95) | def get_fill_color(self) -> Color:
class Cross (line 99) | class Cross(VGroup):
method __init__ (line 100) | def __init__(
class Underline (line 116) | class Underline(Line):
method __init__ (line 117) | def __init__(
FILE: manimlib/mobject/svg/brace.py
class Brace (line 32) | class Brace(Tex):
method __init__ (line 33) | def __init__(
method set_initial_width (line 55) | def set_initial_width(self, width: float):
method put_at_tip (line 68) | def put_at_tip(
method get_text (line 87) | def get_text(self, text: str, **kwargs) -> Text:
method get_tex (line 93) | def get_tex(self, *tex: str, **kwargs) -> Tex:
method get_tip (line 99) | def get_tip(self) -> np.ndarray:
method get_direction (line 105) | def get_direction(self) -> np.ndarray:
class BraceLabel (line 110) | class BraceLabel(VMobject):
method __init__ (line 113) | def __init__(
method creation_anim (line 137) | def creation_anim(
method shift_brace (line 144) | def shift_brace(self, obj: VMobject | list[VMobject], **kwargs):
method change_label (line 152) | def change_label(self, *text: str, **kwargs):
method change_brace_label (line 161) | def change_brace_label(self, obj: VMobject | list[VMobject], *text: str):
method copy (line 166) | def copy(self):
class BraceText (line 175) | class BraceText(BraceLabel):
class LineBrace (line 179) | class LineBrace(Brace):
method __init__ (line 180) | def __init__(self, line: Line, direction=UP, **kwargs):
FILE: manimlib/mobject/svg/drawings.py
class Checkmark (line 80) | class Checkmark(TexTextFromPresetString):
class Exmark (line 85) | class Exmark(TexTextFromPresetString):
class Lightbulb (line 90) | class Lightbulb(SVGMobject):
method __init__ (line 93) | def __init__(
class Speedometer (line 111) | class Speedometer(VMobject):
method __init__ (line 112) | def __init__(
method get_center (line 161) | def get_center(self):
method get_needle_tip (line 167) | def get_needle_tip(self):
method get_needle_angle (line 170) | def get_needle_angle(self):
method rotate_needle (line 175) | def rotate_needle(self, angle):
method move_needle_to_velocity (line 179) | def move_needle_to_velocity(self, velocity):
class Laptop (line 188) | class Laptop(VGroup):
method __init__ (line 189) | def __init__(
class VideoIcon (line 266) | class VideoIcon(SVGMobject):
method __init__ (line 269) | def __init__(
class VideoSeries (line 279) | class VideoSeries(VGroup):
method __init__ (line 280) | def __init__(
class Clock (line 296) | class Clock(VGroup):
method __init__ (line 297) | def __init__(
class ClockPassesTime (line 323) | class ClockPassesTime(AnimationGroup):
method __init__ (line 324) | def __init__(
class Bubble (line 354) | class Bubble(VGroup):
method __init__ (line 358) | def __init__(
method get_body (line 394) | def get_body(self, content: VMobject, direction: Vect3, buff: float) -...
method get_tip (line 408) | def get_tip(self):
method get_bubble_center (line 411) | def get_bubble_center(self):
method move_tip_to (line 415) | def move_tip_to(self, point):
method flip (line 419) | def flip(self, axis=UP, only_body=True, **kwargs):
method pin_to (line 428) | def pin_to(self, mobject, auto_flip=False):
method position_mobject_inside (line 438) | def position_mobject_inside(self, mobject, buff=MED_LARGE_BUFF):
method add_content (line 444) | def add_content(self, mobject):
method write (line 449) | def write(self, text):
method resize_to_content (line 453) | def resize_to_content(self, buff=1.0): # TODO
method clear (line 458) | def clear(self):
class SpeechBubble (line 463) | class SpeechBubble(Bubble):
method __init__ (line 464) | def __init__(
method get_body (line 477) | def get_body(self, content: VMobject, direction: Vect3, buff: float) -...
class ThoughtBubble (line 497) | class ThoughtBubble(Bubble):
method __init__ (line 498) | def __init__(
method get_body (line 515) | def get_body(self, content: VMobject, direction: Vect3, buff: float) -...
class OldSpeechBubble (line 552) | class OldSpeechBubble(Bubble):
class DoubleSpeechBubble (line 556) | class DoubleSpeechBubble(Bubble):
class OldThoughtBubble (line 560) | class OldThoughtBubble(Bubble):
method get_body (line 563) | def get_body(self, content: VMobject, direction: Vect3, buff: float) -...
method make_green_screen (line 568) | def make_green_screen(self):
class VectorizedEarth (line 573) | class VectorizedEarth(SVGMobject):
method __init__ (line 576) | def __init__(
class Piano (line 593) | class Piano(VGroup):
method __init__ (line 594) | def __init__(
method add_white_keys (line 624) | def add_white_keys(self):
method add_black_keys (line 631) | def add_black_keys(self):
method sort_keys (line 653) | def sort_keys(self):
class Piano3D (line 657) | class Piano3D(VGroup):
method __init__ (line 658) | def __init__(
class DieFace (line 687) | class DieFace(VGroup):
method __init__ (line 688) | def __init__(
class Dartboard (line 734) | class Dartboard(VGroup):
method __init__ (line 738) | def __init__(self, **kwargs):
FILE: manimlib/mobject/svg/old_tex_mobject.py
class SingleStringTex (line 20) | class SingleStringTex(SVGMobject):
method __init__ (line 23) | def __init__(
method hash_seed (line 65) | def hash_seed(self) -> tuple:
method get_svg_string_by_content (line 77) | def get_svg_string_by_content(self, content: str) -> str:
method get_tex_file_body (line 80) | def get_tex_file_body(self, tex_string: str) -> str:
method get_modified_expression (line 86) | def get_modified_expression(self, tex_string: str) -> str:
method modify_special_strings (line 89) | def modify_special_strings(self, tex: str) -> str:
method balance_braces (line 153) | def balance_braces(self, tex: str) -> str:
method get_tex (line 173) | def get_tex(self) -> str:
method organize_submobjects_left_to_right (line 176) | def organize_submobjects_left_to_right(self):
class OldTex (line 181) | class OldTex(SingleStringTex):
method __init__ (line 182) | def __init__(
method break_up_tex_strings (line 203) | def break_up_tex_strings(self, tex_strings: Iterable[str], substrings_...
method break_up_by_substrings (line 221) | def break_up_by_substrings(self, tex_strings: Iterable[str]):
method get_parts_by_tex (line 248) | def get_parts_by_tex(
method get_part_by_tex (line 268) | def get_part_by_tex(self, tex: str, **kwargs) -> SingleStringTex | None:
method set_color_by_tex (line 272) | def set_color_by_tex(self, tex: str, color: ManimColor, **kwargs):
method set_color_by_tex_to_color_map (line 276) | def set_color_by_tex_to_color_map(
method index_of_part (line 285) | def index_of_part(self, part: SingleStringTex, start: int = 0) -> int:
method index_of_part_by_tex (line 288) | def index_of_part_by_tex(self, tex: str, start: int = 0, **kwargs) -> ...
method slice_by_tex (line 292) | def slice_by_tex(
method sort_alphabetically (line 309) | def sort_alphabetically(self) -> None:
method set_bstroke (line 312) | def set_bstroke(self, color: ManimColor = BLACK, width: float = 4):
class OldTexText (line 317) | class OldTexText(OldTex):
method __init__ (line 318) | def __init__(
FILE: manimlib/mobject/svg/special_tex.py
class BulletedList (line 18) | class BulletedList(VGroup):
method __init__ (line 19) | def __init__(
method fade_all_but (line 41) | def fade_all_but(self, index: int, opacity: float = 0.25, scale_factor...
class TexTextFromPresetString (line 49) | class TexTextFromPresetString(TexText):
method __init__ (line 53) | def __init__(self, **kwargs):
class Title (line 61) | class Title(TexText):
method __init__ (line 62) | def __init__(
FILE: manimlib/mobject/svg/string_mobject.py
class StringMobject (line 25) | class StringMobject(SVGMobject, ABC):
method __init__ (line 46) | def __init__(
method get_svg_string (line 75) | def get_svg_string(self, is_labelled: bool = False) -> str:
method get_svg_string_by_content (line 80) | def get_svg_string_by_content(self, content: str) -> str:
method assign_labels_by_color (line 83) | def assign_labels_by_color(self, mobjects: list[VMobject]) -> None:
method mobjects_from_svg_string (line 113) | def mobjects_from_svg_string(self, svg_string: str) -> list[VMobject]:
method rearrange_submobjects_by_positions (line 146) | def rearrange_submobjects_by_positions(
method find_spans_by_selector (line 169) | def find_spans_by_selector(self, selector: Selector) -> list[Span]:
method span_contains (line 205) | def span_contains(span_0: Span, span_1: Span) -> bool:
method parse (line 210) | def parse(self) -> None:
method get_content (line 373) | def get_content(self, is_labelled: bool) -> str:
method get_command_matches (line 390) | def get_command_matches(string: str) -> list[re.Match]:
method get_command_flag (line 395) | def get_command_flag(match_obj: re.Match) -> int:
method replace_for_content (line 400) | def replace_for_content(match_obj: re.Match) -> str:
method replace_for_matching (line 405) | def replace_for_matching(match_obj: re.Match) -> str:
method get_attr_dict_from_command_pair (line 410) | def get_attr_dict_from_command_pair(
method get_configured_items (line 416) | def get_configured_items(self) -> list[tuple[Span, dict[str, str]]]:
method get_command_string (line 421) | def get_command_string(
method get_content_prefix_and_suffix (line 427) | def get_content_prefix_and_suffix(
method get_submob_indices_list_by_span (line 434) | def get_submob_indices_list_by_span(
method get_specified_part_items (line 443) | def get_specified_part_items(self) -> list[tuple[str, list[int]]]:
method get_specified_substrings (line 452) | def get_specified_substrings(self) -> list[str]:
method get_group_part_items (line 460) | def get_group_part_items(self) -> list[tuple[str, list[int]]]:
method get_submob_indices_lists_by_selector (line 514) | def get_submob_indices_lists_by_selector(
method build_parts_from_indices_lists (line 525) | def build_parts_from_indices_lists(
method build_groups (line 536) | def build_groups(self) -> VGroup:
method select_parts (line 542) | def select_parts(self, selector: Selector) -> VGroup:
method __getitem__ (line 549) | def __getitem__(self, value: int | slice | Selector) -> VMobject:
method select_part (line 554) | def select_part(self, selector: Selector, index: int = 0) -> VMobject:
method substr_to_path_count (line 557) | def substr_to_path_count(self, substr: str) -> int:
method get_symbol_substrings (line 560) | def get_symbol_substrings(self):
method select_unisolated_substring (line 563) | def select_unisolated_substring(self, pattern: str | re.Pattern) -> VG...
method set_parts_color (line 575) | def set_parts_color(self, selector: Selector, color: ManimColor):
method set_parts_color_by_dict (line 579) | def set_parts_color_by_dict(self, color_map: dict[Selector, ManimColor]):
method get_string (line 584) | def get_string(self) -> str:
FILE: manimlib/mobject/svg/svg_mobject.py
function get_svg_content_height (line 34) | def get_svg_content_height(svg_string: str) -> float:
function _convert_point_to_3d (line 49) | def _convert_point_to_3d(x: float, y: float) -> np.ndarray:
class SVGMobject (line 53) | class SVGMobject(VMobject):
method __init__ (line 58) | def __init__(
method init_svg_mobject (line 123) | def init_svg_mobject(self) -> None:
method hash_seed (line 135) | def hash_seed(self) -> tuple:
method mobjects_from_svg_string (line 145) | def mobjects_from_svg_string(self, svg_string: str) -> list[VMobject]:
method file_name_to_svg_string (line 158) | def file_name_to_svg_string(self, file_name: str) -> str:
method modify_xml_tree (line 161) | def modify_xml_tree(self, element_tree: ET.ElementTree) -> ET.ElementT...
method generate_config_style_dict (line 186) | def generate_config_style_dict(self) -> dict[str, str]:
method mobjects_from_svg (line 203) | def mobjects_from_svg(self, svg: se.SVG) -> list[VMobject]:
method handle_transform (line 237) | def handle_transform(mob: VMobject, matrix: se.Matrix) -> VMobject:
method apply_style_to_mobject (line 248) | def apply_style_to_mobject(
method path_to_mobject (line 261) | def path_to_mobject(self, path: se.Path, svg: se.SVG) -> VMobjectFromS...
method line_to_mobject (line 285) | def line_to_mobject(self, line: se.SimpleLine) -> Line:
method rect_to_mobject (line 291) | def rect_to_mobject(self, rect: se.Rect) -> Rectangle:
method ellipse_to_mobject (line 310) | def ellipse_to_mobject(self, ellipse: se.Circle | se.Ellipse) -> Circle:
method polygon_to_mobject (line 318) | def polygon_to_mobject(self, polygon: se.Polygon) -> Polygon:
method polyline_to_mobject (line 325) | def polyline_to_mobject(self, polyline: se.Polyline) -> Polyline:
method text_to_mobject (line 332) | def text_to_mobject(self, text: se.Text):
class VMobjectFromSVGPath (line 336) | class VMobjectFromSVGPath(VMobject):
method __init__ (line 337) | def __init__(
method init_points (line 348) | def init_points(self) -> None:
method handle_commands (line 361) | def handle_commands(self) -> None:
method handle_arc (line 385) | def handle_arc(self, arc: se.Arc) -> None:
FILE: manimlib/mobject/svg/tex_mobject.py
function get_tex_mob_scale_factor (line 26) | def get_tex_mob_scale_factor() -> float:
class Tex (line 35) | class Tex(StringMobject):
method __init__ (line 38) | def __init__(
method get_svg_string_by_content (line 81) | def get_svg_string_by_content(self, content: str) -> str:
method _handle_scale_side_effects (line 84) | def _handle_scale_side_effects(self, scale_factor: float) -> Self:
method get_command_matches (line 92) | def get_command_matches(string: str) -> list[re.Match]:
method get_command_flag (line 131) | def get_command_flag(match_obj: re.Match) -> int:
method replace_for_content (line 139) | def replace_for_content(match_obj: re.Match) -> str:
method replace_for_matching (line 143) | def replace_for_matching(match_obj: re.Match) -> str:
method get_attr_dict_from_command_pair (line 149) | def get_attr_dict_from_command_pair(
method get_configured_items (line 156) | def get_configured_items(self) -> list[tuple[Span, dict[str, str]]]:
method get_color_command (line 164) | def get_color_command(rgb_hex: str) -> str:
method get_command_string (line 171) | def get_command_string(
method get_content_prefix_and_suffix (line 180) | def get_content_prefix_and_suffix(
method get_parts_by_tex (line 201) | def get_parts_by_tex(self, selector: Selector) -> VGroup:
method get_part_by_tex (line 204) | def get_part_by_tex(self, selector: Selector, index: int = 0) -> VMobj...
method set_color_by_tex (line 207) | def set_color_by_tex(self, selector: Selector, color: ManimColor):
method set_color_by_tex_to_color_map (line 210) | def set_color_by_tex_to_color_map(
method get_tex (line 215) | def get_tex(self) -> str:
method substr_to_path_count (line 219) | def substr_to_path_count(self, substr: str) -> int:
method get_symbol_substrings (line 225) | def get_symbol_substrings(self):
method make_number_changeable (line 234) | def make_number_changeable(
class TexText (line 276) | class TexText(Tex):
FILE: manimlib/mobject/svg/text_mobject.py
class _Alignment (line 42) | class _Alignment:
method __init__ (line 49) | def __init__(self, s: str):
function markup_to_svg (line 55) | def markup_to_svg(
function get_text_mob_scale_factor (line 104) | def get_text_mob_scale_factor() -> float:
class MarkupText (line 115) | class MarkupText(StringMobject):
method __init__ (line 136) | def __init__(
method get_svg_string_by_content (line 205) | def get_svg_string_by_content(self, content: str) -> str:
method escape_markup_char (line 218) | def escape_markup_char(substr: str) -> str:
method unescape_markup_char (line 222) | def unescape_markup_char(substr: str) -> str:
method get_command_matches (line 231) | def get_command_matches(string: str) -> list[re.Match]:
method get_command_flag (line 250) | def get_command_flag(match_obj: re.Match) -> int:
method replace_for_content (line 259) | def replace_for_content(match_obj: re.Match) -> str:
method replace_for_matching (line 267) | def replace_for_matching(match_obj: re.Match) -> str:
method get_attr_dict_from_command_pair (line 280) | def get_attr_dict_from_command_pair(
method get_configured_items (line 298) | def get_configured_items(self) -> list[tuple[Span, dict[str, str]]]:
method get_command_string (line 319) | def get_command_string(
method get_content_prefix_and_suffix (line 343) | def get_content_prefix_and_suffix(
method get_parts_by_text (line 382) | def get_parts_by_text(self, selector: Selector) -> VGroup:
method get_part_by_text (line 385) | def get_part_by_text(self, selector: Selector, **kwargs) -> VGroup:
method set_color_by_text (line 388) | def set_color_by_text(self, selector: Selector, color: ManimColor):
method set_color_by_text_to_color_map (line 391) | def set_color_by_text_to_color_map(
method get_text (line 396) | def get_text(self) -> str:
class Text (line 400) | class Text(MarkupText):
method __init__ (line 401) | def __init__(
method get_command_matches (line 421) | def get_command_matches(string: str) -> list[re.Match]:
method get_command_flag (line 426) | def get_command_flag(match_obj: re.Match) -> int:
method replace_for_content (line 430) | def replace_for_content(match_obj: re.Match) -> str:
method replace_for_matching (line 434) | def replace_for_matching(match_obj: re.Match) -> str:
class Code (line 438) | class Code(MarkupText):
method __init__ (line 439) | def __init__(
function register_font (line 470) | def register_font(font_file: str | Path):
FILE: manimlib/mobject/three_dimensions.py
class SurfaceMesh (line 31) | class SurfaceMesh(VGroup):
method __init__ (line 32) | def __init__(
method init_points (line 55) | def init_points(self) -> None:
class Sphere (line 93) | class Sphere(Surface):
method __init__ (line 94) | def __init__(
method uv_func (line 116) | def uv_func(self, u: float, v: float) -> np.ndarray:
class Torus (line 125) | class Torus(Surface):
method __init__ (line 126) | def __init__(
method uv_func (line 142) | def uv_func(self, u: float, v: float) -> np.ndarray:
class Cylinder (line 147) | class Cylinder(Surface):
method __init__ (line 148) | def __init__(
method init_points (line 168) | def init_points(self):
method uv_func (line 174) | def uv_func(self, u: float, v: float) -> np.ndarray:
class Cone (line 178) | class Cone(Cylinder):
method __init__ (line 179) | def __init__(
method uv_func (line 188) | def uv_func(self, u: float, v: float) -> np.ndarray:
class Line3D (line 192) | class Line3D(Cylinder):
method __init__ (line 193) | def __init__(
class Disk3D (line 212) | class Disk3D(Surface):
method __init__ (line 213) | def __init__(
method uv_func (line 229) | def uv_func(self, u: float, v: float) -> np.ndarray:
class Square3D (line 237) | class Square3D(Surface):
method __init__ (line 238) | def __init__(
method uv_func (line 254) | def uv_func(self, u: float, v: float) -> np.ndarray:
function square_to_cube_faces (line 258) | def square_to_cube_faces(square: T) -> list[T]:
class Cube (line 270) | class Cube(SGroup):
method __init__ (line 271) | def __init__(
class Prism (line 290) | class Prism(Cube):
method __init__ (line 291) | def __init__(
class VGroup3D (line 303) | class VGroup3D(VGroup):
method __init__ (line 304) | def __init__(
class VCube (line 319) | class VCube(VGroup3D):
method __init__ (line 320) | def __init__(
class VPrism (line 338) | class VPrism(VCube):
method __init__ (line 339) | def __init__(
class Dodecahedron (line 351) | class Dodecahedron(VGroup3D):
method __init__ (line 352) | def __init__(
class Prismify (line 398) | class Prismify(VGroup3D):
method __init__ (line 399) | def __init__(self, vmobject, depth=1.0, direction=IN, **kwargs):
FILE: manimlib/mobject/types/dot_cloud.py
class DotCloud (line 26) | class DotCloud(PMobject):
method __init__ (line 35) | def __init__(
method init_uniforms (line 59) | def init_uniforms(self) -> None:
method to_grid (line 64) | def to_grid(
method set_radii (line 100) | def set_radii(self, radii: npt.ArrayLike) -> Self:
method get_radii (line 107) | def get_radii(self) -> np.ndarray:
method set_radius (line 111) | def set_radius(self, radius: float) -> Self:
method get_radius (line 117) | def get_radius(self) -> float:
method scale_radii (line 120) | def scale_radii(self, scale_factor: float) -> Self:
method set_glow_factor (line 124) | def set_glow_factor(self, glow_factor: float) -> Self:
method get_glow_factor (line 128) | def get_glow_factor(self) -> float:
method compute_bounding_box (line 131) | def compute_bounding_box(self) -> Vect3Array:
method scale (line 138) | def scale(
method make_3d (line 149) | def make_3d(
class TrueDot (line 160) | class TrueDot(DotCloud):
method __init__ (line 161) | def __init__(self, center: Vect3 = ORIGIN, **kwargs):
class GlowDots (line 165) | class GlowDots(DotCloud):
method __init__ (line 166) | def __init__(
class GlowDot (line 183) | class GlowDot(GlowDots):
method __init__ (line 184) | def __init__(self, center: Vect3 = ORIGIN, **kwargs):
FILE: manimlib/mobject/types/image_mobject.py
class ImageMobject (line 21) | class ImageMobject(Mobject):
method __init__ (line 30) | def __init__(
method init_data (line 41) | def init_data(self) -> None:
method init_points (line 47) | def init_points(self) -> None:
method set_opacity (line 53) | def set_opacity(self, opacity: float, recurse: bool = True):
method set_color (line 60) | def set_color(self, color, opacity=None, recurse=None):
method point_to_rgb (line 63) | def point_to_rgb(self, point: Vect3) -> Vect3:
FILE: manimlib/mobject/types/point_cloud_mobject.py
class PMobject (line 17) | class PMobject(Mobject):
method set_points (line 18) | def set_points(self, points: Vect3Array):
method add_points (line 25) | def add_points(
method add_point (line 49) | def add_point(self, point: Vect3, rgba=None, color=None, opacity=None)...
method set_color_by_gradient (line 55) | def set_color_by_gradient(self, *colors: ManimColor) -> Self:
method match_colors (line 63) | def match_colors(self, pmobject: PMobject) -> Self:
method filter_out (line 70) | def filter_out(self, condition: Callable[[np.ndarray], bool]) -> Self:
method sort_points (line 76) | def sort_points(self, function: Callable[[Vect3], None] = lambda p: p[...
method ingest_submobjects (line 88) | def ingest_submobjects(self) -> Self:
method point_from_proportion (line 94) | def point_from_proportion(self, alpha: float) -> np.ndarray:
method pointwise_become_partial (line 99) | def pointwise_become_partial(self, pmobject: PMobject, a: float, b: fl...
class PGroup (line 106) | class PGroup(PMobject):
method __init__ (line 107) | def __init__(self, *pmobs: PMobject, **kwargs):
FILE: manimlib/mobject/types/surface.py
class Surface (line 34) | class Surface(Mobject):
method __init__ (line 44) | def __init__(
method uv_func (line 78) | def uv_func(self, u: float, v: float) -> tuple[float, float, float]:
method init_points (line 83) | def init_points(self):
method get_uv_grid (line 107) | def get_uv_grid(self) -> np.array:
method uv_to_point (line 118) | def uv_to_point(self, u, v):
method apply_points_function (line 144) | def apply_points_function(self, *args, **kwargs) -> Self:
method compute_triangle_indices (line 149) | def compute_triangle_indices(self) -> np.ndarray:
method get_triangle_indices (line 168) | def get_triangle_indices(self) -> np.ndarray:
method get_unit_normals (line 171) | def get_unit_normals(self) -> Vect3Array:
method pointwise_become_partial (line 176) | def pointwise_become_partial(
method get_partial_points_array (line 198) | def get_partial_points_array(
method sort_faces_back_to_front (line 239) | def sort_faces_back_to_front(self, vect: Vect3 = OUT) -> Self:
method always_sort_to_camera (line 249) | def always_sort_to_camera(self, camera: Camera) -> Self:
method color_by_uv_function (line 256) | def color_by_uv_function(self, uv_to_color: Callable[[Vect2], Color]):
method get_shader_vert_indices (line 264) | def get_shader_vert_indices(self) -> np.ndarray:
class ParametricSurface (line 268) | class ParametricSurface(Surface):
method __init__ (line 269) | def __init__(
method uv_func (line 279) | def uv_func(self, u, v):
class SGroup (line 283) | class SGroup(Surface):
method __init__ (line 284) | def __init__(
method init_points (line 292) | def init_points(self):
class TexturedSurface (line 296) | class TexturedSurface(Surface):
method __init__ (line 305) | def __init__(
method init_points (line 338) | def init_points(self):
method set_image_coords_by_uv_func (line 353) | def set_image_coords_by_uv_func(self, uv_func) -> Self:
method init_uniforms (line 366) | def init_uniforms(self):
method set_opacity (line 371) | def set_opacity(self, opacity: float | Iterable[float], recurse=True) ...
method set_color (line 376) | def set_color(
method pointwise_become_partial (line 386) | def pointwise_become_partial(
class TexturedGeometry (line 407) | class TexturedGeometry(TexturedSurface):
method __init__ (line 408) | def __init__(self, geometry: trimesh.base.Trimesh, texture_file: str, ...
method init_points (line 418) | def init_points(self):
class ThreeDModel (line 435) | class ThreeDModel(Group):
method __init__ (line 436) | def __init__(self, obj_file: str, height=3):
method get_textures_from_mtl (line 460) | def get_textures_from_mtl(self, obj_filepath, suppress_warnings=True):
FILE: manimlib/mobject/types/vectorized_mobject.py
class VMobject (line 58) | class VMobject(Mobject):
method __init__ (line 79) | def __init__(
method get_group_class (line 122) | def get_group_class(self):
method init_uniforms (line 125) | def init_uniforms(self):
method add (line 134) | def add(self, *vmobjects: VMobject) -> Self:
method init_colors (line 140) | def init_colors(self):
method set_fill (line 157) | def set_fill(
method set_stroke (line 172) | def set_stroke(
method set_backstroke (line 204) | def set_backstroke(
method set_style (line 213) | def set_style(
method get_style (line 261) | def get_style(self) -> dict[str, Any]:
method match_style (line 273) | def match_style(self, vmobject: VMobject, recurse: bool = True) -> Self:
method set_color (line 287) | def set_color(
method set_opacity (line 297) | def set_opacity(
method set_color_by_proportion (line 306) | def set_color_by_proportion(self, prop_to_color: Callable[[float], Col...
method set_anti_alias_width (line 311) | def set_anti_alias_width(self, anti_alias_width: float, recurse: bool ...
method fade (line 315) | def fade(self, darkness: float = 0.5, recurse: bool = True) -> Self:
method get_fill_colors (line 329) | def get_fill_colors(self) -> list[str]:
method get_fill_opacities (line 335) | def get_fill_opacities(self) -> np.ndarray:
method get_stroke_colors (line 338) | def get_stroke_colors(self) -> list[str]:
method get_stroke_opacities (line 344) | def get_stroke_opacities(self) -> np.ndarray:
method get_stroke_widths (line 347) | def get_stroke_widths(self) -> np.ndarray:
method get_fill_color (line 352) | def get_fill_color(self) -> str:
method get_fill_opacity (line 360) | def get_fill_opacity(self) -> float:
method get_stroke_color (line 368) | def get_stroke_color(self) -> str:
method get_stroke_width (line 372) | def get_stroke_width(self) -> float:
method get_stroke_opacity (line 376) | def get_stroke_opacity(self) -> float:
method get_color (line 380) | def get_color(self) -> str:
method get_anti_alias_width (line 385) | def get_anti_alias_width(self):
method has_stroke (line 388) | def has_stroke(self) -> bool:
method has_fill (line 392) | def has_fill(self) -> bool:
method get_opacity (line 396) | def get_opacity(self) -> float:
method set_flat_stroke (line 401) | def set_flat_stroke(self, flat_stroke: bool = True, recurse: bool = Tr...
method get_flat_stroke (line 405) | def get_flat_stroke(self) -> bool:
method set_scale_stroke_with_zoom (line 408) | def set_scale_stroke_with_zoom(self, scale_stroke_with_zoom: bool = Tr...
method get_scale_stroke_with_zoom (line 412) | def get_scale_stroke_with_zoom(self) -> bool:
method set_joint_type (line 415) | def set_joint_type(self, joint_type: str, recurse: bool = True) -> Self:
method get_joint_type (line 420) | def get_joint_type(self) -> float:
method apply_depth_test (line 423) | def apply_depth_test(
method deactivate_depth_test (line 432) | def deactivate_depth_test(
method use_winding_fill (line 441) | def use_winding_fill(self, value: bool = True, recurse: bool = True) -...
method set_anchors_and_handles (line 446) | def set_anchors_and_handles(
method start_new_path (line 461) | def start_new_path(self, point: Vect3) -> Self:
method add_cubic_bezier_curve (line 470) | def add_cubic_bezier_curve(
method add_cubic_bezier_curve_to (line 481) | def add_cubic_bezier_curve_to(
method add_quadratic_bezier_curve_to (line 511) | def add_quadratic_bezier_curve_to(self, handle: Vect3, anchor: Vect3, ...
method add_line_to (line 522) | def add_line_to(self, point: Vect3, allow_null_line: bool = True) -> S...
method add_smooth_curve_to (line 531) | def add_smooth_curve_to(self, point: Vect3) -> Self:
method add_smooth_cubic_curve_to (line 540) | def add_smooth_cubic_curve_to(self, handle: Vect3, point: Vect3) -> Self:
method add_arc_to (line 549) | def add_arc_to(self, point: Vect3, angle: float, n_components: int | N...
method has_new_path_started (line 569) | def has_new_path_started(self) -> bool:
method get_last_point (line 577) | def get_last_point(self) -> Vect3:
method get_reflection_of_last_handle (line 580) | def get_reflection_of_last_handle(self) -> Vect3:
method close_path (line 584) | def close_path(self, smooth: bool = False) -> Self:
method is_closed (line 595) | def is_closed(self) -> bool:
method subdivide_curves_by_condition (line 601) | def subdivide_curves_by_condition(
method subdivide_sharp_curves (line 623) | def subdivide_sharp_curves(
method subdivide_intersections (line 635) | def subdivide_intersections(self, recurse: bool = True, n_subdivisions...
method add_points_as_corners (line 645) | def add_points_as_corners(self, points: Iterable[Vect3]) -> Self:
method set_points_as_corners (line 650) | def set_points_as_corners(self, points: Iterable[Vect3]) -> Self:
method set_points_smoothly (line 656) | def set_points_smoothly(
method is_smooth (line 665) | def is_smooth(self, angle_tol=1 * DEG) -> bool:
method change_anchor_mode (line 669) | def change_anchor_mode(self, mode: str) -> Self:
method make_smooth (line 697) | def make_smooth(self, approx=True, recurse=True) -> Self:
method make_approximately_smooth (line 712) | def make_approximately_smooth(self, recurse=True) -> Self:
method make_jagged (line 716) | def make_jagged(self, recurse=True) -> Self:
method add_subpath (line 721) | def add_subpath(self, points: Vect3Array) -> Self:
method append_vectorized_mobject (line 731) | def append_vectorized_mobject(self, vmobject: VMobject) -> Self:
method consider_points_equal (line 738) | def consider_points_equal(self, p0: Vect3, p1: Vect3) -> bool:
method get_bezier_tuples_from_points (line 742) | def get_bezier_tuples_from_points(self, points: Vect3Array) -> Iterabl...
method get_bezier_tuples (line 746) | def get_bezier_tuples(self) -> Iterable[Vect3Array]:
method get_subpath_end_indices_from_points (line 749) | def get_subpath_end_indices_from_points(self, points: Vect3Array) -> n...
method get_subpath_end_indices (line 761) | def get_subpath_end_indices(self) -> np.ndarray:
method get_subpaths_from_points (line 766) | def get_subpaths_from_points(self, points: Vect3Array) -> list[Vect3Ar...
method get_subpaths (line 773) | def get_subpaths(self) -> list[Vect3Array]:
method get_nth_curve_points (line 776) | def get_nth_curve_points(self, n: int) -> Vect3Array:
method get_nth_curve_function (line 780) | def get_nth_curve_function(self, n: int) -> Callable[[float], Vect3]:
method get_num_curves (line 783) | def get_num_curves(self) -> int:
method quick_point_from_proportion (line 786) | def quick_point_from_proportion(self, alpha: float) -> Vect3:
method curve_and_prop_of_partial_point (line 795) | def curve_and_prop_of_partial_point(self, alpha) -> Tuple[int, float]:
method point_from_proportion (line 825) | def point_from_proportion(self, alpha: float) -> Vect3:
method get_anchors_and_handles (line 835) | def get_anchors_and_handles(self) -> list[Vect3]:
method get_start_anchors (line 845) | def get_start_anchors(self) -> Vect3Array:
method get_end_anchors (line 848) | def get_end_anchors(self) -> Vect3:
method get_anchors (line 851) | def get_anchors(self) -> Vect3Array:
method get_points_without_null_curves (line 854) | def get_points_without_null_curves(self, atol: float = 1e-9) -> Vect3A...
method get_arc_length (line 861) | def get_arc_length(self, n_sample_points: int | None = None) -> float:
method get_area_vector (line 873) | def get_area_vector(self) -> Vect3:
method get_unit_normal (line 898) | def get_unit_normal(self, refresh: bool = False) -> Vect3:
method refresh_unit_normal (line 916) | def refresh_unit_normal(self) -> Self:
method rotate (line 920) | def rotate(
method ensure_positive_orientation (line 932) | def ensure_positive_orientation(self, recurse=True) -> Self:
method align_points (line 939) | def align_points(self, vmobject: VMobject) -> Self:
method insert_n_curves (line 991) | def insert_n_curves(self, n: int, recurse: bool = True) -> Self:
method insert_n_curves_to_point_list (line 998) | def insert_n_curves_to_point_list(self, n: int, points: Vect3Array) ->...
method pointwise_become_partial (line 1025) | def pointwise_become_partial(self, vmobject: VMobject, a: float, b: fl...
method get_subcurve (line 1068) | def get_subcurve(self, a: float, b: float) -> Self:
method get_outer_vert_indices (line 1073) | def get_outer_vert_indices(self) -> np.ndarray:
method get_triangulation (line 1085) | def get_triangulation(self) -> np.ndarray:
method refresh_joint_angles (line 1134) | def refresh_joint_angles(self) -> Self:
method get_joint_angles (line 1139) | def get_joint_angles(self, refresh: bool = False) -> np.ndarray:
method lock_matching_data (line 1196) | def lock_matching_data(self, vmobject1: VMobject, vmobject2: VMobject)...
method triggers_refresh (line 1202) | def triggers_refresh(func: Callable):
method set_points (line 1214) | def set_points(self, points: Vect3Array) -> Self:
method append_points (line 1219) | def append_points(self, points: Vect3Array) -> Self:
method reverse_points (line 1223) | def reverse_points(self, recurse: bool = True) -> Self:
method set_data (line 1236) | def set_data(self, data: np.ndarray) -> Self:
method apply_function (line 1241) | def apply_function(
method stretch (line 1253) | def stretch(self, *args, **kwargs) -> Self:
method apply_matrix (line 1257) | def apply_matrix(self, *args, **kwargs) -> Self:
method rotate (line 1260) | def rotate(
method set_animating_status (line 1277) | def set_animating_status(self, is_animating: bool, recurse: bool = True):
method init_shader_wrapper (line 1285) | def init_shader_wrapper(self, ctx: Context):
method refresh_shader_wrapper_id (line 1295) | def refresh_shader_wrapper_id(self):
method get_shader_data (line 1302) | def get_shader_data(self) -> np.ndarray:
method get_shader_vert_indices (line 1308) | def get_shader_vert_indices(self) -> Optional[np.ndarray]:
class VGroup (line 1312) | class VGroup(Group, VMobject, Generic[SubVmobjectType]):
method __init__ (line 1313) | def __init__(self, *vmobjects: SubVmobjectType | Iterable[SubVmobjectT...
method __add__ (line 1321) | def __add__(self, other: VMobject) -> Self:
method __getitem__ (line 1326) | def __getitem__(self, index) -> SubVmobjectType:
class VectorizedPoint (line 1330) | class VectorizedPoint(Point, VMobject):
method __init__ (line 1331) | def __init__(
class CurvesAsSubmobjects (line 1350) | class CurvesAsSubmobjects(VGroup):
method __init__ (line 1351) | def __init__(self, vmobject: VMobject, **kwargs):
class DashedVMobject (line 1360) | class DashedVMobject(VMobject):
method __init__ (line 1361) | def __init__(
class VHighlight (line 1391) | class VHighlight(VGroup):
method __init__ (line 1392) | def __init__(
FILE: manimlib/mobject/value_tracker.py
class ValueTracker (line 13) | class ValueTracker(Mobject):
method __init__ (line 22) | def __init__(
method init_uniforms (line 30) | def init_uniforms(self) -> None:
method get_value (line 37) | def get_value(self) -> float | complex | np.ndarray:
method set_value (line 43) | def set_value(self, value: float | complex | np.ndarray) -> Self:
method increment_value (line 47) | def increment_value(self, d_value: float | complex) -> None:
class ExponentialValueTracker (line 51) | class ExponentialValueTracker(ValueTracker):
method get_value (line 58) | def get_value(self) -> float | complex:
method set_value (line 61) | def set_value(self, value: float | complex):
class ComplexValueTracker (line 65) | class ComplexValueTracker(ValueTracker):
FILE: manimlib/mobject/vector_field.py
function get_vectorized_rgb_gradient_function (line 34) | def get_vectorized_rgb_gradient_function(
function get_rgb_gradient_function (line 57) | def get_rgb_gradient_function(
function ode_solution_points (line 67) | def ode_solution_points(function, state0, time, dt=0.01):
function move_along_vector_field (line 77) | def move_along_vector_field(
function move_submobjects_along_vector_field (line 89) | def move_submobjects_along_vector_field(
function move_points_along_vector_field (line 103) | def move_points_along_vector_field(
function get_sample_coords (line 119) | def get_sample_coords(
function vectorize (line 131) | def vectorize(pointwise_function: Callable[[Tuple], Tuple]):
class VectorField (line 141) | class VectorField(VMobject):
method __init__ (line 142) | def __init__(
method init_points (line 206) | def init_points(self):
method get_sample_points (line 211) | def get_sample_points(
method init_base_stroke_width_array (line 231) | def init_base_stroke_width_array(self, n_sample_points):
method set_sample_coords (line 239) | def set_sample_coords(self, sample_coords: VectArray):
method set_stroke (line 243) | def set_stroke(self, color=None, width=None, opacity=None, behind=None...
method set_stroke_width (line 249) | def set_stroke_width(self, width: float):
method update_sample_points (line 255) | def update_sample_points(self):
method update_vectors (line 258) | def update_vectors(self):
class TimeVaryingVectorField (line 316) | class TimeVaryingVectorField(VectorField):
method __init__ (line 317) | def __init__(
method increment_time (line 333) | def increment_time(self, dt):
class StreamLines (line 337) | class StreamLines(VGroup):
method __init__ (line 338) | def __init__(
method point_func (line 385) | def point_func(self, points: Vect3Array) -> Vect3:
method draw_lines (line 391) | def draw_lines(self) -> None:
method get_sample_coords (line 406) | def get_sample_coords(self):
method init_style (line 420) | def init_style(self) -> None:
class AnimatedStreamLines (line 446) | class AnimatedStreamLines(VGroup):
method __init__ (line 447) | def __init__(
method update (line 473) | def update(self, dt: float = 0) -> None:
FILE: manimlib/module_loader.py
class ModuleLoader (line 15) | class ModuleLoader:
method get_module (line 24) | def get_module(file_name: str | None, is_during_reload=False) -> Modul...
method _exec_module_and_track_imports (line 53) | def _exec_module_and_track_imports(spec, module: Module) -> set[str]:
method _reload_modules (line 88) | def _reload_modules(modules: set[str], reloaded_modules_tracker: set[s...
method _is_user_defined_module (line 107) | def _is_user_defined_module(mod: str) -> bool:
method _deep_reload (line 139) | def _deep_reload(module: Module, reloaded_modules_tracker: set[str]):
FILE: manimlib/scene/interactive_scene.py
class InteractiveScene (line 66) | class InteractiveScene(Scene):
method setup (line 112) | def setup(self):
method get_selection_rectangle (line 135) | def get_selection_rectangle(self):
method update_selection_rectangle (line 145) | def update_selection_rectangle(self, rect: Rectangle):
method get_selection_highlight (line 155) | def get_selection_highlight(self):
method update_selection_highlight (line 161) | def update_selection_highlight(self, highlight: Mobject):
method get_crosshair (line 182) | def get_crosshair(self):
method get_color_palette (line 194) | def get_color_palette(self):
method get_information_label (line 206) | def get_information_label(self):
method get_state (line 230) | def get_state(self):
method restore_state (line 237) | def restore_state(self, scene_state: SceneState):
method add (line 241) | def add(self, *mobjects: Mobject):
method remove (line 245) | def remove(self, *mobjects: Mobject):
method remove_all_except (line 249) | def remove_all_except(self, *mobjects_to_keep : Mobject):
method toggle_selection_mode (line 255) | def toggle_selection_mode(self):
method get_selection_search_set (line 260) | def get_selection_search_set(self) -> list[Mobject]:
method regenerate_selection_search_set (line 263) | def regenerate_selection_search_set(self):
method refresh_selection_scope (line 277) | def refresh_selection_scope(self):
method get_corner_dots (line 293) | def get_corner_dots(self, mobject: Mobject) -> Mobject:
method get_highlight (line 306) | def get_highlight(self, mobject: Mobject) -> Mobject:
method add_to_selection (line 320) | def add_to_selection(self, *mobjects: Mobject):
method toggle_from_selection (line 331) | def toggle_from_selection(self, *mobjects: Mobject):
method clear_selection (line 340) | def clear_selection(self):
method disable_interaction (line 346) | def disable_interaction(self, *mobjects: Mobject):
method enable_interaction (line 352) | def enable_interaction(self, *mobjects: Mobject):
method copy_selection (line 360) | def copy_selection(self):
method paste_selection (line 373) | def paste_selection(self):
method delete_selection (line 401) | def delete_selection(self):
method enable_selection (line 405) | def enable_selection(self):
method gather_new_selection (line 412) | def gather_new_selection(self):
method prepare_grab (line 424) | def prepare_grab(self):
method prepare_resizing (line 429) | def prepare_resizing(self, about_corner=False):
method toggle_color_palette (line 440) | def toggle_color_palette(self):
method display_information (line 449) | def display_information(self, show=True):
method group_selection (line 455) | def group_selection(self):
method ungroup_selection (line 461) | def ungroup_selection(self):
method nudge_selection (line 470) | def nudge_selection(self, vect: np.ndarray, large: bool = False):
method on_key_press (line 477) | def on_key_press(self, symbol: int, modifiers: int) -> None:
method on_key_release (line 538) | def on_key_release(self, symbol: int, modifiers: int) -> None:
method handle_grabbing (line 550) | def handle_grabbing(self, point: Vect3):
method handle_resizing (line 561) | def handle_resizing(self, point: Vect3):
method handle_sweeping_selection (line 581) | def handle_sweeping_selection(self, point: Vect3):
method choose_color (line 590) | def choose_color(self, point: Vect3):
method on_mouse_motion (line 603) | def on_mouse_motion(self, point: Vect3, d_point: Vect3) -> None:
method on_mouse_drag (line 613) | def on_mouse_drag(
method on_mouse_release (line 623) | def on_mouse_release(self, point: Vect3, button: int, mods: int) -> None:
method copy_frame_positioning (line 631) | def copy_frame_positioning(self):
method copy_cursor_position (line 647) | def copy_cursor_position(self):
FILE: manimlib/scene/scene.py
class Scene (line 52) | class Scene(object):
method __init__ (line 64) | def __init__(
method __str__ (line 143) | def __str__(self) -> str:
method get_window (line 146) | def get_window(self) -> Window | None:
method run (line 149) | def run(self) -> None:
method setup (line 166) | def setup(self) -> None:
method construct (line 174) | def construct(self) -> None:
method tear_down (line 179) | def tear_down(self) -> None:
method interact (line 186) | def interact(self) -> None:
method embed (line 203) | def embed(
method get_image (line 223) | def get_image(self) -> Image:
method show (line 232) | def show(self) -> None:
method update_frame (line 236) | def update_frame(self, dt: float = 0, force_draw: bool = False) -> None:
method emit_frame (line 258) | def emit_frame(self) -> None:
method update_mobjects (line 264) | def update_mobjects(self, dt: float) -> None:
method should_update_mobjects (line 268) | def should_update_mobjects(self) -> bool:
method get_time (line 275) | def get_time(self) -> float:
method increment_time (line 278) | def increment_time(self, dt: float) -> None:
method get_top_level_mobjects (line 283) | def get_top_level_mobjects(self) -> list[Mobject]:
method get_mobject_family_members (line 297) | def get_mobject_family_members(self) -> list[Mobject]:
method assemble_render_groups (line 300) | def assemble_render_groups(self):
method affects_mobject_list (line 319) | def affects_mobject_list(func: Callable[..., T]) -> Callable[..., T]:
method add (line 328) | def add(self, *new_mobjects: Mobject):
method add_mobjects_among (line 347) | def add_mobjects_among(self, values: Iterable):
method replace (line 360) | def replace(self, mobject: Mobject, *replacements: Mobject):
method remove (line 371) | def remove(self, *mobjects_to_remove: Mobject):
method remove_all_except (line 385) | def remove_all_except(self, *mobjects_to_keep : Mobject):
method bring_to_front (line 389) | def bring_to_front(self, *mobjects: Mobject):
method bring_to_back (line 394) | def bring_to_back(self, *mobjects: Mobject):
method clear (line 400) | def clear(self):
method get_mobjects (line 404) | def get_mobjects(self) -> list[Mobject]:
method get_mobject_copies (line 407) | def get_mobject_copies(self) -> list[Mobject]:
method point_to_mobject (line 410) | def point_to_mobject(
method get_group (line 427) | def get_group(self, *mobjects):
method id_to_mobject (line 433) | def id_to_mobject(self, id_value):
method ids_to_group (line 436) | def ids_to_group(self, *id_values):
method i2g (line 442) | def i2g(self, *id_values):
method i2m (line 445) | def i2m(self, id_value):
method update_skipping_status (line 450) | def update_skipping_status(self) -> None:
method stop_skipping (line 460) | def stop_skipping(self) -> None:
method get_time_progression (line 467) | def get_time_progression(
method get_run_time (line 493) | def get_run_time(self, animations: Iterable[Animation]) -> float:
method get_animation_time_progression (line 496) | def get_animation_time_progression(
method get_wait_time_progression (line 508) | def get_wait_time_progression(
method pre_play (line 519) | def pre_play(self):
method post_play (line 532) | def post_play(self):
method begin_animations (line 542) | def begin_animations(self, animations: Iterable[Animation]) -> None:
method progress_through_animations (line 555) | def progress_through_animations(self, animations: Iterable[Animation])...
method finish_animations (line 567) | def finish_animations(self, animations: Iterable[Animation]) -> None:
method play (line 577) | def play(
method wait (line 596) | def wait(
method hold_loop (line 623) | def hold_loop(self):
method wait_until (line 628) | def wait_until(
method force_skipping (line 635) | def force_skipping(self):
method revert_to_original_skipping_status (line 640) | def revert_to_original_skipping_status(self):
method add_sound (line 645) | def add_sound(
method get_state (line 659) | def get_state(self) -> SceneState:
method restore_state (line 663) | def restore_state(self, scene_state: SceneState):
method save_state (line 666) | def save_state(self) -> None:
method undo (line 675) | def undo(self):
method redo (line 680) | def redo(self):
method temp_skip (line 686) | def temp_skip(self):
method temp_progress_bar (line 696) | def temp_progress_bar(self):
method temp_record (line 705) | def temp_record(self):
method temp_config_change (line 714) | def temp_config_change(self, skip=False, record=False, progress_bar=Fa...
method is_window_closing (line 724) | def is_window_closing(self):
method set_floor_plane (line 728) | def set_floor_plane(self, plane: str = "xy"):
method on_mouse_motion (line 736) | def on_mouse_motion(
method on_mouse_drag (line 760) | def on_mouse_drag(
method on_mouse_press (line 776) | def on_mouse_press(
method on_mouse_release (line 788) | def on_mouse_release(
method on_mouse_scroll (line 799) | def on_mouse_scroll(
method on_key_release (line 817) | def on_key_release(
method on_key_press (line 827) | def on_key_press(
method on_resize (line 856) | def on_resize(self, width: int, height: int) -> None:
method on_show (line 859) | def on_show(self) -> None:
method on_hide (line 862) | def on_hide(self) -> None:
method on_close (line 865) | def on_close(self) -> None:
method focus (line 868) | def focus(self) -> None:
method set_background_color (line 876) | def set_background_color(self, background_color, background_opacity=1)...
class SceneState (line 882) | class SceneState():
method __init__ (line 883) | def __init__(self, scene: Scene, ignore: list[Mobject] | None = None):
method __eq__ (line 900) | def __eq__(self, state: SceneState):
method mobjects_match (line 907) | def mobjects_match(self, state: SceneState):
method n_changes (line 910) | def n_changes(self, state: SceneState):
method restore_scene (line 917) | def restore_scene(self, scene: Scene):
class EndScene (line 926) | class EndScene(Exception):
class ThreeDScene (line 930) | class ThreeDScene(Scene):
method add (line 935) | def add(self, *mobjects: Mobject, set_depth_test: bool = True, perp_st...
FILE: manimlib/scene/scene_embed.py
class InteractiveSceneEmbed (line 23) | class InteractiveSceneEmbed:
method __init__ (line 24) | def __init__(self, scene: Scene):
method launch (line 35) | def launch(self):
method get_ipython_shell_for_embedded_scene (line 38) | def get_ipython_shell_for_embedded_scene(self) -> InteractiveShellEmbed:
method get_shortcuts (line 59) | def get_shortcuts(self):
method enable_gui (line 82) | def enable_gui(self):
method ensure_frame_update_post_cell (line 94) | def ensure_frame_update_post_cell(self):
method ensure_flash_on_error (line 102) | def ensure_flash_on_error(self):
method validate_syntax (line 113) | def validate_syntax(self, file_path: str) -> bool:
method reload_scene (line 138) | def reload_scene(self, embed_line: int | None = None) -> None:
method auto_reload (line 178) | def auto_reload(self):
method checkpoint_paste (line 186) | def checkpoint_paste(
class CheckpointManager (line 196) | class CheckpointManager:
method __init__ (line 197) | def __init__(self):
method checkpoint_paste (line 200) | def checkpoint_paste(self, shell, scene):
method get_leading_comment (line 215) | def get_leading_comment(code_string: str) -> str:
method handle_checkpoint_key (line 221) | def handle_checkpoint_key(self, scene, key: str):
method clear_checkpoints (line 236) | def clear_checkpoints(self):
FILE: manimlib/scene/scene_file_writer.py
class SceneFileWriter (line 28) | class SceneFileWriter(object):
method __init__ (line 29) | def __init__(
method init_output_directories (line 80) | def init_output_directories(self) -> None:
method init_image_file_path (line 88) | def init_image_file_path(self) -> Path:
method init_movie_file_path (line 91) | def init_movie_file_path(self) -> Path:
method init_partial_movie_directory (line 94) | def init_partial_movie_directory(self):
method get_output_file_rootname (line 97) | def get_output_file_rootname(self) -> Path:
method get_output_file_name (line 103) | def get_output_file_name(self) -> str:
method get_image_file_path (line 118) | def get_image_file_path(self) -> str:
method get_next_partial_movie_path (line 121) | def get_next_partial_movie_path(self) -> str:
method get_movie_file_path (line 125) | def get_movie_file_path(self) -> str:
method init_audio (line 129) | def init_audio(self) -> None:
method create_audio_segment (line 132) | def create_audio_segment(self) -> None:
method add_audio_segment (line 135) | def add_audio_segment(
method add_sound (line 164) | def add_sound(
method begin (line 178) | def begin(self) -> None:
method begin_animation (line 182) | def begin_animation(self) -> None:
method end_animation (line 186) | def end_animation(self) -> None:
method finish (line 190) | def finish(self) -> None:
method open_movie_pipe (line 202) | def open_movie_pipe(self, file_path: str) -> None:
method use_fast_encoding (line 241) | def use_fast_encoding(self):
method get_insert_file_path (line 245) | def get_insert_file_path(self, index: int) -> Path:
method begin_insert (line 252) | def begin_insert(self):
method end_insert (line 262) | def end_insert(self):
method has_progress_display (line 267) | def has_progress_display(self):
method set_progress_display_description (line 270) | def set_progress_display_description(self, file: str = "", sub_desc: s...
method write_frame (line 284) | def write_frame(self, camera: Camera) -> None:
method close_movie_pipe (line 291) | def close_movie_pipe(self) -> None:
method add_sound_to_video (line 303) | def add_sound_to_video(self) -> None:
method save_final_image (line 334) | def save_final_image(self, image: Image) -> None:
method print_file_ready_message (line 339) | def print_file_ready_message(self, file_path: str) -> None:
method should_open_file (line 343) | def should_open_file(self) -> bool:
method open_file (line 349) | def open_file(self) -> None:
FILE: manimlib/shader_wrapper.py
class ShaderWrapper (line 34) | class ShaderWrapper(object):
method __init__ (line 35) | def __init__(
method __deepcopy__ (line 65) | def __deepcopy__(self, memo):
method init_program_code (line 71) | def init_program_code(self) -> None:
method init_program (line 83) | def init_program(self):
method init_textures (line 93) | def init_textures(self):
method init_vertex_objects (line 99) | def init_vertex_objects(self):
method add_texture (line 103) | def add_texture(self, name: str, texture: moderngl.Texture):
method bind_to_mobject_uniforms (line 111) | def bind_to_mobject_uniforms(self, mobject_uniforms: UniformDict):
method get_id (line 114) | def get_id(self) -> int:
method refresh_id (line 117) | def refresh_id(self) -> None:
method replace_code (line 126) | def replace_code(self, old: str, new: str) -> None:
method num_clip_planes (line 136) | def num_clip_planes(self):
method set_ctx_depth_test (line 144) | def set_ctx_depth_test(self, enable: bool = True) -> None:
method set_ctx_clip_plane (line 150) | def set_ctx_clip_plane(self, num_planes: int = 0) -> None:
method read_in (line 165) | def read_in(self, data_list: Iterable[np.ndarray]):
method generate_vaos (line 188) | def generate_vaos(self):
method pre_render (line 200) | def pre_render(self):
method render (line 206) | def render(self):
method update_program_uniforms (line 210) | def update_program_uniforms(self, camera_uniforms: UniformDict):
method release (line 218) | def release(self):
method release_textures (line 224) | def release_textures(self):
class VShaderWrapper (line 232) | class VShaderWrapper(ShaderWrapper):
method __init__ (line 233) | def __init__(
method init_program_code (line 260) | def init_program_code(self) -> None:
method init_program (line 269) | def init_program(self):
method init_vertex_objects (line 319) | def init_vertex_objects(self):
method generate_vaos (line 326) | def generate_vaos(self):
method set_backstroke (line 349) | def set_backstroke(self, value: bool = True):
method refresh_id (line 352) | def refresh_id(self):
method render_stroke (line 357) | def render_stroke(self):
method render_fill (line 362) | def render_fill(self):
method get_fill_canvas (line 414) | def get_fill_canvas(ctx: moderngl.Context) -> Tuple[Framebuffer, Verte...
method render (line 486) | def render(self):
FILE: manimlib/utils/bezier.py
function bezier (line 28) | def bezier(
function partial_bezier_points (line 45) | def partial_bezier_points(
function partial_quadratic_bezier_points (line 75) | def partial_quadratic_bezier_points(
function interpolate (line 97) | def interpolate(start: Scalable, end: Scalable, alpha: float | VectN) ->...
function outer_interpolate (line 108) | def outer_interpolate(
function set_array_by_interpolation (line 117) | def set_array_by_interpolation(
function integer_interpolate (line 128) | def integer_interpolate(
function mid (line 153) | def mid(start: Scalable, end: Scalable) -> Scalable:
function inverse_interpolate (line 157) | def inverse_interpolate(start: Scalable, end: Scalable, value: Scalable)...
function match_interpolate (line 161) | def match_interpolate(
function quadratic_bezier_points_for_arc (line 174) | def quadratic_bezier_points_for_arc(angle: float, n_components: int = 8):
function approx_smooth_quadratic_bezier_handles (line 184) | def approx_smooth_quadratic_bezier_handles(
function smooth_quadratic_path (line 220) | def smooth_quadratic_path(anchors: Vect3Array) -> Vect3Array:
function get_smooth_cubic_bezier_handle_points (line 257) | def get_smooth_cubic_bezier_handle_points(
function diag_to_matrix (line 317) | def diag_to_matrix(
function is_closed (line 337) | def is_closed(points: FloatArray) -> bool:
function get_quadratic_approximation_of_cubic (line 343) | def get_quadratic_approximation_of_cubic(
function get_smooth_quadratic_bezier_path_through (line 415) | def get_smooth_quadratic_bezier_path_through(
FILE: manimlib/utils/cache.py
function cache_on_disk (line 21) | def cache_on_disk(func: Callable[..., T]) -> Callable[..., T]:
function clear_cache (line 33) | def clear_cache():
FILE: manimlib/utils/color.py
function color_to_rgb (line 22) | def color_to_rgb(color: ManimColor) -> Vect3:
function color_to_rgba (line 31) | def color_to_rgba(color: ManimColor, alpha: float = 1.0) -> Vect4:
function rgb_to_color (line 35) | def rgb_to_color(rgb: Vect3 | Sequence[float]) -> Color:
function rgba_to_color (line 42) | def rgba_to_color(rgba: Vect4) -> Color:
function rgb_to_hex (line 46) | def rgb_to_hex(rgb: Vect3 | Sequence[float]) -> str:
function hex_to_rgb (line 50) | def hex_to_rgb(hex_code: str) -> Vect3:
function invert_color (line 54) | def invert_color(color: ManimColor) -> Color:
function color_to_int_rgb (line 58) | def color_to_int_rgb(color: ManimColor) -> np.ndarray[int, np.dtype[np.u...
function color_to_int_rgba (line 62) | def color_to_int_rgba(color: ManimColor, opacity: float = 1.0) -> np.nda...
function color_to_hex (line 67) | def color_to_hex(color: ManimColor) -> str:
function hex_to_int (line 71) | def hex_to_int(rgb_hex: str) -> int:
function int_to_hex (line 75) | def int_to_hex(rgb_int: int) -> str:
function color_gradient (line 79) | def color_gradient(
function interpolate_color (line 104) | def interpolate_color(
function interpolate_color_by_hsl (line 119) | def interpolate_color_by_hsl(
function average_color (line 127) | def average_color(*colors: ManimColor) -> Color:
function random_color (line 132) | def random_color() -> Color:
function random_bright_color (line 136) | def random_bright_color(
function get_colormap_from_colors (line 148) | def get_colormap_from_colors(colors: Iterable[ManimColor]) -> Callable[[...
function get_color_map (line 168) | def get_color_map(map_name: str) -> Callable[[Sequence[float]], Vect4Arr...
function get_colormap_list (line 175) | def get_colormap_list(
FILE: manimlib/utils/debug.py
function print_family (line 14) | def print_family(mobject: Mobject, n_tabs: int = 0) -> None:
function index_labels (line 21) | def index_labels(
FILE: manimlib/utils/dict_ops.py
function merge_dicts_recursively (line 5) | def merge_dicts_recursively(*dicts):
FILE: manimlib/utils/directories.py
function get_directories (line 13) | def get_directories() -> dict[str, str]:
function get_cache_dir (line 17) | def get_cache_dir() -> str:
function get_temp_dir (line 21) | def get_temp_dir() -> str:
function get_downloads_dir (line 25) | def get_downloads_dir() -> str:
function get_output_dir (line 29) | def get_output_dir() -> str:
function get_raster_image_dir (line 33) | def get_raster_image_dir() -> str:
function get_vector_image_dir (line 37) | def get_vector_image_dir() -> str:
function get_three_d_model_dir (line 41) | def get_three_d_model_dir() -> str:
function get_sound_dir (line 45) | def get_sound_dir() -> str:
function get_shader_dir (line 49) | def get_shader_dir() -> str:
FILE: manimlib/utils/family_ops.py
function extract_mobject_family_members (line 11) | def extract_mobject_family_members(
function recursive_mobject_remove (line 23) | def recursive_mobject_remove(mobjects: List[Mobject], to_remove: Set[Mob...
FILE: manimlib/utils/file_ops.py
function guarantee_existence (line 20) | def guarantee_existence(path: str | Path) -> Path:
function find_file (line 26) | def find_file(
FILE: manimlib/utils/images.py
function get_full_raster_image_path (line 17) | def get_full_raster_image_path(image_file_name: str) -> str:
function get_full_vector_image_path (line 25) | def get_full_vector_image_path(image_file_name: str) -> str:
function get_full_three_d_model_path (line 33) | def get_full_three_d_model_path(model_file_name: str) -> str:
function invert_image (line 41) | def invert_image(image: Iterable) -> Image.Image:
FILE: manimlib/utils/iterables.py
function remove_list_redundancies (line 17) | def remove_list_redundancies(lst: Sequence[T]) -> list[T]:
function list_update (line 25) | def list_update(l1: Iterable[T], l2: Iterable[T]) -> list[T]:
function list_difference_update (line 33) | def list_difference_update(l1: Iterable[T], l2: Iterable[T]) -> list[T]:
function adjacent_n_tuples (line 37) | def adjacent_n_tuples(objects: Sequence[T], n: int) -> zip[tuple[T, ...]]:
function adjacent_pairs (line 44) | def adjacent_pairs(objects: Sequence[T]) -> zip[tuple[T, T]]:
function batch_by_property (line 48) | def batch_by_property(
function listify (line 78) | def listify(obj: object) -> list:
function shuffled (line 87) | def shuffled(iterable: Iterable) -> list:
function resize_array (line 93) | def resize_array(nparray: np.ndarray, length: int) -> np.ndarray:
function resize_preserving_order (line 99) | def resize_preserving_order(nparray: np.ndarray, length: int) -> np.ndar...
function resize_with_interpolation (line 108) | def resize_with_interpolation(nparray: np.ndarray, length: int) -> np.nd...
function make_even (line 123) | def make_even(
function arrays_match (line 138) | def arrays_match(arr1: np.ndarray, arr2: np.ndarray) -> bool:
function array_is_constant (line 142) | def array_is_constant(arr: np.ndarray) -> bool:
function cartesian_product (line 146) | def cartesian_product(*arrays: np.ndarray):
function hash_obj (line 158) | def hash_obj(obj: object) -> int:
FILE: manimlib/utils/paths.py
function straight_path (line 22) | def straight_path(
function path_along_arc (line 36) | def path_along_arc(
function clockwise_path (line 78) | def clockwise_path() -> Callable[[Vect3Array, Vect3Array, float], Vect3A...
function counterclockwise_path (line 82) | def counterclockwise_path() -> Callable[[Vect3Array, Vect3Array, float],...
FILE: manimlib/utils/rate_functions.py
function linear (line 13) | def linear(t: float) -> float:
function smooth (line 17) | def smooth(t: float) -> float:
function rush_into (line 24) | def rush_into(t: float) -> float:
function rush_from (line 28) | def rush_from(t: float) -> float:
function slow_into (line 32) | def slow_into(t: float) -> float:
function double_smooth (line 36) | def double_smooth(t: float) -> float:
function there_and_back (line 43) | def there_and_back(t: float) -> float:
function there_and_back_with_pause (line 48) | def there_and_back_with_pause(t: float, pause_ratio: float = 1. / 3) -> ...
function running_start (line 58) | def running_start(t: float, pull_factor: float = -0.5) -> float:
function overshoot (line 62) | def overshoot(t: float, pull_factor: float = 1.5) -> float:
function not_quite_there (line 66) | def not_quite_there(
function wiggle (line 75) | def wiggle(t: float, wiggles: float = 2) -> float:
function squish_rate_func (line 79) | def squish_rate_func(
function lingering (line 102) | def lingering(t: float) -> float:
function exponential_decay (line 106) | def exponential_decay(t: float, half_life: float = 0.1) -> float:
FILE: manimlib/utils/shaders.py
function image_path_to_texture (line 24) | def image_path_to_texture(path: str, ctx: moderngl.Context) -> moderngl....
function get_shader_program (line 34) | def get_shader_program(
function set_program_uniform (line 47) | def set_program_uniform(
function get_shader_code_from_file (line 80) | def get_shader_code_from_file(filename: str) -> str | None:
function get_colormap_code (line 109) | def get_colormap_code(rgb_list: Sequence[float]) -> str:
FILE: manimlib/utils/simple_functions.py
function sigmoid (line 19) | def sigmoid(x: float | FloatArray):
function choose (line 24) | def choose(n: int, k: int) -> int:
function gen_choose (line 28) | def gen_choose(n: int, r: int) -> int:
function get_num_args (line 32) | def get_num_args(function: Callable) -> int:
function get_parameters (line 36) | def get_parameters(function: Callable) -> Iterable[str]:
function clip (line 40) | def clip(a: float, min_a: float, max_a: float) -> float:
function arr_clip (line 48) | def arr_clip(arr: np.ndarray, min_a: float, max_a: float) -> np.ndarray:
function fdiv (line 54) | def fdiv(a: Scalable, b: Scalable, zero_over_zero_value: Scalable | None...
function binary_search (line 69) | def binary_search(
function hash_string (line 99) | def hash_string(string: str, n_bytes=16) -> str:
FILE: manimlib/utils/sounds.py
function get_full_sound_file_path (line 11) | def get_full_sound_file_path(sound_file_name: str) -> str:
function play_sound (line 19) | def play_sound(sound_file):
FILE: manimlib/utils/space_ops.py
function cross (line 25) | def cross(
function get_norm (line 47) | def get_norm(vect: VectN | List[float]) -> float:
function get_dist (line 51) | def get_dist(vect1: VectN, vect2: VectN):
function normalize (line 55) | def normalize(
function poly_line_length (line 68) | def poly_line_length(points):
function quaternion_mult (line 78) | def quaternion_mult(*quats: Vect4) -> Vect4:
function quaternion_from_angle_axis (line 98) | def quaternion_from_angle_axis(
function angle_axis_from_quaternion (line 105) | def angle_axis_from_quaternion(quat: Vect4) -> Tuple[float, Vect3]:
function quaternion_conjugate (line 111) | def quaternion_conjugate(quaternion: Vect4) -> Vect4:
function rotate_vector (line 117) | def rotate_vector(
function rotate_vector_2d (line 126) | def rotate_vector_2d(vector: Vect2, angle: float) -> Vect2:
function rotation_matrix_transpose_from_quaternion (line 132) | def rotation_matrix_transpose_from_quaternion(quat: Vect4) -> Matrix3x3:
function rotation_matrix_from_quaternion (line 136) | def rotation_matrix_from_quaternion(quat: Vect4) -> Matrix3x3:
function rotation_matrix (line 140) | def rotation_matrix(angle: float, axis: Vect3) -> Matrix3x3:
function rotation_matrix_transpose (line 147) | def rotation_matrix_transpose(angle: float, axis: Vect3) -> Matrix3x3:
function rotation_about_z (line 151) | def rotation_about_z(angle: float) -> Matrix3x3:
function rotation_between_vectors (line 161) | def rotation_between_vectors(v1: Vect3, v2: Vect3) -> Matrix3x3:
function z_to_vector (line 178) | def z_to_vector(vector: Vect3) -> Matrix3x3:
function angle_of_vector (line 182) | def angle_of_vector(vector: Vect2 | Vect3) -> float:
function angle_between_vectors (line 189) | def angle_between_vectors(v1: VectN, v2: VectN) -> float:
function project_along_vector (line 202) | def project_along_vector(point: Vect3, vector: Vect3) -> Vect3:
function normalize_along_axis (line 207) | def normalize_along_axis(
function get_unit_normal (line 216) | def get_unit_normal(
function thick_diagonal (line 238) | def thick_diagonal(dim: int, thickness: int = 2) -> np.ndarray:
function compass_directions (line 244) | def compass_directions(n: int = 4, start_vect: Vect3 = RIGHT) -> Vect3:
function complex_to_R3 (line 252) | def complex_to_R3(complex_num: complex) -> Vect3:
function R3_to_complex (line 256) | def R3_to_complex(point: Vect3) -> complex:
function complex_func_to_R3_func (line 260) | def complex_func_to_R3_func(complex_func: Callable[[complex], complex]) ...
function center_of_mass (line 266) | def center_of_mass(points: Sequence[Vect3]) -> Vect3:
function midpoint (line 270) | def midpoint(point1: VectN, point2: VectN) -> VectN:
function line_intersection (line 274) | def line_intersection(
function find_intersection (line 298) | def find_intersection(
function line_intersects_path (line 331) | def line_intersects_path(
function get_closest_point_on_line (line 356) | def get_closest_point_on_line(a: VectN, b: VectN, p: VectN) -> VectN:
function get_winding_number (line 371) | def get_winding_number(points: Sequence[Vect2 | Vect3]) -> float:
function cross2d (line 382) | def cross2d(a: Vect2 | Vect2Array, b: Vect2 | Vect2Array) -> Vect2 | Vec...
function tri_area (line 389) | def tri_area(
function is_inside_triangle (line 401) | def is_inside_triangle(
function norm_squared (line 418) | def norm_squared(v: VectN | List[float]) -> float:
function earclip_triangulation (line 423) | def earclip_triangulation(verts: Vect3Array | Vect2Array, ring_ends: lis...
FILE: manimlib/utils/tex.py
function num_tex_symbols (line 10) | def num_tex_symbols(tex: str) -> int:
function remove_tex_environments (line 36) | def remove_tex_environments(tex: str) -> str:
FILE: manimlib/utils/tex_file_writing.py
function get_tex_template_config (line 19) | def get_tex_template_config(template_name: str) -> dict[str, str]:
function get_tex_config (line 31) | def get_tex_config(template: str = "") -> tuple[str, str]:
function get_full_tex (line 40) | def get_full_tex(content: str, preamble: str = ""):
function latex_to_svg (line 51) | def latex_to_svg(
function full_tex_to_svg (line 85) | def full_tex_to_svg(full_tex: str, compiler: str = "latex", message: str...
class LatexError (line 153) | class LatexError(Exception):
FILE: manimlib/window.py
class Window (line 23) | class Window(PygletWindow):
method __init__ (line 30) | def __init__(
method init_for_scene (line 52) | def init_for_scene(self, scene: Scene):
method get_monitor (line 75) | def get_monitor(self, index):
method get_default_size (line 83) | def get_default_size(self, full_screen=False):
method position_from_string (line 88) | def position_from_string(self, position_string):
method focus (line 99) | def focus(self):
method to_default_position (line 111) | def to_default_position(self):
method pixel_coords_to_space_coords (line 120) | def pixel_coords_to_space_coords(
method has_undrawn_event (line 139) | def has_undrawn_event(self) -> bool:
method swap_buffers (line 142) | def swap_buffers(self):
method note_undrawn_event (line 147) | def note_undrawn_event(func: Callable[..., T]) -> Callable[..., T]:
method on_mouse_motion (line 155) | def on_mouse_motion(self, x: int, y: int, dx: int, dy: int) -> None:
method on_mouse_drag (line 164) | def on_mouse_drag(self, x: int, y: int, dx: int, dy: int, buttons: int...
method on_mouse_press (line 173) | def on_mouse_press(self, x: int, y: int, button: int, mods: int) -> None:
method on_mouse_release (line 181) | def on_mouse_release(self, x: int, y: int, button: int, mods: int) -> ...
method on_mouse_scroll (line 189) | def on_mouse_scroll(self, x: int, y: int, x_offset: float, y_offset: f...
method on_key_press (line 198) | def on_key_press(self, symbol: int, modifiers: int) -> None:
method on_key_release (line 206) | def on_key_release(self, symbol: int, modifiers: int) -> None:
method on_resize (line 214) | def on_resize(self, width: int, height: int) -> None:
method on_show (line 221) | def on_show(self) -> None:
method on_hide (line 228) | def on_hide(self) -> None:
method on_close (line 235) | def on_close(self) -> None:
method is_key_pressed (line 241) | def is_key_pressed(self, symbol: int) -> bool:
Condensed preview — 160 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (1,026K chars).
[
{
"path": ".github/ISSUE_TEMPLATE/bug_report.md",
"chars": 443,
"preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: ''\nlabels: bug\nassignees: ''\n\n---\n\n### Describe th"
},
{
"path": ".github/ISSUE_TEMPLATE/config.yml",
"chars": 186,
"preview": "blank_issues_enabled: true\ncontact_links:\n - name: Ask A Question\n url: https://github.com/3b1b/manim/discussions/ca"
},
{
"path": ".github/ISSUE_TEMPLATE/error-when-using.md",
"chars": 481,
"preview": "---\nname: Error when using\nabout: The error you encountered while using manim\ntitle: ''\nlabels: ''\nassignees: ''\n\n---\n\n#"
},
{
"path": ".github/PULL_REQUEST_TEMPLATE.md",
"chars": 362,
"preview": "<!-- Thanks for contributing to manim!\n Please ensure that your pull request works with the latest version of manim.\n"
},
{
"path": ".github/workflows/docs.yml",
"chars": 947,
"preview": "name: docs\n\non: \n push:\n paths:\n - 'docs/**'\n pull_request:\n paths:\n - 'docs/**'\n\njobs:\n docs:\n ru"
},
{
"path": ".github/workflows/publish.yml",
"chars": 783,
"preview": "name: Upload Python Package\n\non:\n release:\n types: [created]\n\njobs:\n deploy:\n runs-on: ubuntu-latest\n\n strate"
},
{
"path": ".gitignore",
"chars": 2251,
"preview": "# Created by https://www.toptal.com/developers/gitignore/api/python\n# Edit at https://www.toptal.com/developers/gitignor"
},
{
"path": "LICENSE.md",
"chars": 1077,
"preview": "MIT License\n\nCopyright (c) 2020-2023 3Blue1Brown LLC\n\nPermission is hereby granted, free of charge, to any person obtain"
},
{
"path": "MANIFEST.in",
"chars": 58,
"preview": "graft manimlib\nrecursive-exclude manimlib *.pyc *.DS_Store"
},
{
"path": "README.md",
"chars": 7179,
"preview": "<p align=\"center\">\n <a href=\"https://github.com/3b1b/manim\">\n <img src=\"https://raw.githubusercontent.com/3b1b"
},
{
"path": "docs/Makefile",
"chars": 638,
"preview": "# Minimal makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line, and also\n# from the "
},
{
"path": "docs/example.py",
"chars": 1276,
"preview": "from manimlib import *\n\nclass SquareToCircle(Scene):\n def construct(self):\n circle = Circle()\n circle.s"
},
{
"path": "docs/make.bat",
"chars": 764,
"preview": "@ECHO OFF\n\npushd %~dp0\n\nREM Command file for Sphinx documentation\n\nif \"%SPHINXBUILD%\" == \"\" (\n\tset SPHINXBUILD=sphinx-bu"
},
{
"path": "docs/requirements.txt",
"chars": 56,
"preview": "Sphinx==3.0.3\nsphinx-copybutton\nfuro==2020.10.5b9\nJinja2"
},
{
"path": "docs/source/conf.py",
"chars": 1122,
"preview": "import os\nimport sys\nsys.path.insert(0, os.path.abspath(\".\"))\nsys.path.insert(0, os.path.abspath('../../'))\n\n\nproject = "
},
{
"path": "docs/source/development/about.rst",
"chars": 1150,
"preview": "About\n=====\n\nAbout Manim\n-----------\n\nManim is an animation engine for explanatory math videos. \nYou can use it to make "
},
{
"path": "docs/source/development/changelog.rst",
"chars": 34447,
"preview": "Changelog\n=========\n\nUnreleased\n----------\n\nBreaking Changes\n^^^^^^^^^^^^^^^^\n- Added ``InteractiveScene`` (`#1794 <http"
},
{
"path": "docs/source/development/contributing.rst",
"chars": 1783,
"preview": "Contributing\n============\n\nAccept any contribution you make :)\n\n- **Contribute to the manim source code**: \n\nPlease fork"
},
{
"path": "docs/source/documentation/animation/index.rst",
"chars": 33,
"preview": "Animation (TODO)\n================"
},
{
"path": "docs/source/documentation/camera/index.rst",
"chars": 27,
"preview": "Camera (TODO)\n============="
},
{
"path": "docs/source/documentation/constants.rst",
"chars": 6671,
"preview": "constants\n=========\n\nThe ``constants.py`` in the ``manimlib`` folder defines the constants \nneeded when running manim. S"
},
{
"path": "docs/source/documentation/custom_config.rst",
"chars": 4807,
"preview": "custom_config\n==============\n\n``directories``\n---------------\n\n- ``mirror_module_path``\n (``True`` or ``False``) Whet"
},
{
"path": "docs/source/documentation/mobject/index.rst",
"chars": 29,
"preview": "Mobject (TODO)\n=============="
},
{
"path": "docs/source/documentation/scene/index.rst",
"chars": 25,
"preview": "Scene (TODO)\n============"
},
{
"path": "docs/source/documentation/shaders/index.rst",
"chars": 29,
"preview": "Shaders (TODO)\n=============="
},
{
"path": "docs/source/documentation/utils/index.rst",
"chars": 25,
"preview": "Utils (TODO)\n============"
},
{
"path": "docs/source/getting_started/configuration.rst",
"chars": 6400,
"preview": "CLI flags and configuration\n===========================\n\nCommand Line Interface\n----------------------\n\nTo run manim, yo"
},
{
"path": "docs/source/getting_started/example_scenes.rst",
"chars": 30148,
"preview": "Example Scenes\n==============\n\nAfter understanding the previous knowledge, we can understand more scenes.\nMany example s"
},
{
"path": "docs/source/getting_started/installation.rst",
"chars": 2114,
"preview": "Installation\n============\n\nManim runs on Python 3.7 or higher.\n\nSystem requirements are：\n\n- `FFmpeg <https://ffmpeg.org/"
},
{
"path": "docs/source/getting_started/quickstart.rst",
"chars": 7603,
"preview": "Quick Start\n===========\n\nAfter installing the manim environment according to the instructions on the\n:doc:`installation`"
},
{
"path": "docs/source/getting_started/structure.rst",
"chars": 6660,
"preview": "Manim's structure\n=================\n\n\nManim's directory structure\n---------------------------\n\nThe manim directory looks"
},
{
"path": "docs/source/getting_started/whatsnew.rst",
"chars": 10613,
"preview": "What's new\n==========\n\nUsage changes of new version manim\n----------------------------------\n\nThere are many changes in "
},
{
"path": "docs/source/index.rst",
"chars": 914,
"preview": "Manim's documentation\n=====================\n\n.. image:: https://cdn.jsdelivr.net/gh/3b1b/manim@master/logo/white_with_na"
},
{
"path": "docs/source/manim_example_ext.py",
"chars": 2481,
"preview": "from docutils import nodes\nfrom docutils.parsers.rst import directives, Directive\n\nimport jinja2\nimport os\n\n\nclass skip_"
},
{
"path": "example_scenes.py",
"chars": 26519,
"preview": "from manimlib import *\nimport numpy as np\n\n# To watch one of these scenes, run the following:\n# manimgl example_scenes.p"
},
{
"path": "logo/logo.py",
"chars": 6003,
"preview": "from manimlib.imports import *\n\nNEW_BLUE = \"#68a8e1\"\n\nclass Thumbnail(GraphScene):\n CONFIG = {\n \"y_max\": 8,\n "
},
{
"path": "manimlib/__init__.py",
"chars": 3056,
"preview": "try:\n from importlib.metadata import version, PackageNotFoundError\nexcept ImportError: # For Python <3.8 fallback\n "
},
{
"path": "manimlib/__main__.py",
"chars": 1621,
"preview": "#!/usr/bin/env python\nfrom addict import Dict\n\nfrom manimlib import __version__\nfrom manimlib.config import manim_config"
},
{
"path": "manimlib/animation/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "manimlib/animation/animation.py",
"chars": 7377,
"preview": "from __future__ import annotations\n\nfrom copy import deepcopy\n\nfrom manimlib.mobject.mobject import _AnimationBuilder\nfr"
},
{
"path": "manimlib/animation/composition.py",
"chars": 6094,
"preview": "from __future__ import annotations\n\nfrom manimlib.animation.animation import Animation\nfrom manimlib.animation.animation"
},
{
"path": "manimlib/animation/creation.py",
"chars": 7724,
"preview": "from __future__ import annotations\n\nfrom abc import ABC, abstractmethod\n\nimport numpy as np\n\nfrom manimlib.animation.ani"
},
{
"path": "manimlib/animation/fading.py",
"chars": 6026,
"preview": "from __future__ import annotations\n\nimport numpy as np\n\nfrom manimlib.animation.animation import Animation\nfrom manimlib"
},
{
"path": "manimlib/animation/growing.py",
"chars": 1494,
"preview": "from __future__ import annotations\n\nfrom manimlib.animation.transform import Transform\n\nfrom typing import TYPE_CHECKING"
},
{
"path": "manimlib/animation/indication.py",
"chars": 13305,
"preview": "from __future__ import annotations\n\nimport numpy as np\n\nfrom manimlib.animation.animation import Animation\nfrom manimlib"
},
{
"path": "manimlib/animation/movement.py",
"chars": 3329,
"preview": "from __future__ import annotations\n\nfrom manimlib.animation.animation import Animation\nfrom manimlib.utils.rate_function"
},
{
"path": "manimlib/animation/numbers.py",
"chars": 1795,
"preview": "from __future__ import annotations\n\nfrom manimlib.animation.animation import Animation\nfrom manimlib.mobject.numbers imp"
},
{
"path": "manimlib/animation/rotation.py",
"chars": 2193,
"preview": "from __future__ import annotations\n\nfrom manimlib.animation.animation import Animation\nfrom manimlib.constants import OR"
},
{
"path": "manimlib/animation/specialized.py",
"chars": 1655,
"preview": "from __future__ import annotations\n\nfrom manimlib.animation.composition import LaggedStart\nfrom manimlib.animation.trans"
},
{
"path": "manimlib/animation/transform.py",
"chars": 9988,
"preview": "from __future__ import annotations\n\nimport inspect\n\nimport numpy as np\n\nfrom manimlib.animation.animation import Animati"
},
{
"path": "manimlib/animation/transform_matching_parts.py",
"chars": 6639,
"preview": "from __future__ import annotations\n\nimport itertools as it\nfrom difflib import SequenceMatcher\n\nfrom manimlib.animation."
},
{
"path": "manimlib/animation/update.py",
"chars": 2017,
"preview": "from __future__ import annotations\n\nfrom manimlib.animation.animation import Animation\n\nfrom typing import TYPE_CHECKING"
},
{
"path": "manimlib/camera/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "manimlib/camera/camera.py",
"chars": 8706,
"preview": "from __future__ import annotations\n\nimport moderngl\nimport numpy as np\nimport OpenGL.GL as gl\nfrom PIL import Image\n\nfro"
},
{
"path": "manimlib/camera/camera_frame.py",
"chars": 8798,
"preview": "from __future__ import annotations\n\nimport math\nimport warnings\n\nimport numpy as np\nfrom scipy.spatial.transform import "
},
{
"path": "manimlib/config.py",
"chars": 13146,
"preview": "from __future__ import annotations\n\nimport argparse\nimport colour\nimport importlib\nimport inspect\nimport os\nimport sys\ni"
},
{
"path": "manimlib/constants.py",
"chars": 6311,
"preview": "from __future__ import annotations\nimport numpy as np\n\nfrom typing import TYPE_CHECKING\nif TYPE_CHECKING:\n from typin"
},
{
"path": "manimlib/default_config.yml",
"chars": 6036,
"preview": "# This file determines the default configuration for how manim is\n# run, including names for directories it will write t"
},
{
"path": "manimlib/event_handler/__init__.py",
"chars": 219,
"preview": "from manimlib.event_handler.event_dispatcher import EventDispatcher\n\n\n# This is supposed to be a Singleton\n# i.e., durin"
},
{
"path": "manimlib/event_handler/event_dispatcher.py",
"chars": 3856,
"preview": "from __future__ import annotations\n\nimport numpy as np\n\nfrom manimlib.event_handler.event_listner import EventListener\nf"
},
{
"path": "manimlib/event_handler/event_listner.py",
"chars": 815,
"preview": "from __future__ import annotations\n\nfrom typing import TYPE_CHECKING\n\nif TYPE_CHECKING:\n from typing import Callable\n"
},
{
"path": "manimlib/event_handler/event_type.py",
"chars": 343,
"preview": "from enum import Enum\n\n\nclass EventType(Enum):\n MouseMotionEvent = 'mouse_motion_event'\n MousePressEvent = 'mouse_"
},
{
"path": "manimlib/extract_scene.py",
"chars": 6722,
"preview": "from __future__ import annotations\n\nimport copy\nimport inspect\nimport sys\n\nfrom manimlib.module_loader import ModuleLoad"
},
{
"path": "manimlib/logger.py",
"chars": 239,
"preview": "import logging\n\nfrom rich.logging import RichHandler\n\n__all__ = [\"log\"]\n\n\nFORMAT = \"%(message)s\"\nlogging.basicConfig(\n "
},
{
"path": "manimlib/mobject/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "manimlib/mobject/boolean_ops.py",
"chars": 4384,
"preview": "from __future__ import annotations\r\n\r\nimport numpy as np\r\nimport pathops\r\n\r\nfrom manimlib.mobject.types.vectorized_mobje"
},
{
"path": "manimlib/mobject/changing.py",
"chars": 5764,
"preview": "from __future__ import annotations\n\nimport numpy as np\n\nfrom manimlib.constants import BLUE_B, BLUE_D, BLUE_E, GREY_BROW"
},
{
"path": "manimlib/mobject/coordinate_systems.py",
"chars": 25634,
"preview": "from __future__ import annotations\n\nfrom abc import ABC, abstractmethod\nimport numbers\n\nimport numpy as np\nimport iterto"
},
{
"path": "manimlib/mobject/frame.py",
"chars": 1369,
"preview": "from __future__ import annotations\n\nfrom manimlib.constants import BLACK, GREY_E\nfrom manimlib.constants import FRAME_HE"
},
{
"path": "manimlib/mobject/functions.py",
"chars": 3840,
"preview": "from __future__ import annotations\n\nfrom isosurfaces import plot_isoline\nimport numpy as np\n\nfrom manimlib.constants imp"
},
{
"path": "manimlib/mobject/geometry.py",
"chars": 47559,
"preview": "from __future__ import annotations\n\nimport math\n\nimport numpy as np\n\nfrom manimlib.constants import DL, DOWN, DR, LEFT, "
},
{
"path": "manimlib/mobject/interactive.py",
"chars": 19387,
"preview": "from __future__ import annotations\n\nimport numpy as np\nfrom pyglet.window import key as PygletWindowKeys\n\nfrom manimlib."
},
{
"path": "manimlib/mobject/matrix.py",
"chars": 9423,
"preview": "from __future__ import annotations\n\nimport numpy as np\n\nfrom manimlib.constants import DOWN, LEFT, RIGHT, ORIGIN\nfrom ma"
},
{
"path": "manimlib/mobject/mobject.py",
"chars": 81705,
"preview": "from __future__ import annotations\n\nimport copy\nfrom functools import wraps\nimport itertools as it\nimport os\nimport pick"
},
{
"path": "manimlib/mobject/mobject_update_utils.py",
"chars": 3064,
"preview": "from __future__ import annotations\n\nimport inspect\n\nfrom manimlib.constants import DEG\nfrom manimlib.constants import RI"
},
{
"path": "manimlib/mobject/number_line.py",
"chars": 10438,
"preview": "from __future__ import annotations\n\nimport numpy as np\n\nfrom manimlib.constants import DOWN, LEFT, RIGHT, UP\nfrom maniml"
},
{
"path": "manimlib/mobject/numbers.py",
"chars": 8613,
"preview": "from __future__ import annotations\nfrom functools import lru_cache\n\nimport numpy as np\n\nfrom manimlib.constants import D"
},
{
"path": "manimlib/mobject/probability.py",
"chars": 10410,
"preview": "from __future__ import annotations\n\nimport numpy as np\n\nfrom manimlib.constants import BLUE, BLUE_E, GREEN_E, GREY_B, GR"
},
{
"path": "manimlib/mobject/shape_matchers.py",
"chars": 3851,
"preview": "from __future__ import annotations\n\nfrom colour import Color\n\nfrom manimlib.config import manim_config\nfrom manimlib.con"
},
{
"path": "manimlib/mobject/svg/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "manimlib/mobject/svg/brace.py",
"chars": 6070,
"preview": "from __future__ import annotations\n\nimport math\nimport copy\n\nimport numpy as np\n\nfrom manimlib.constants import DEFAULT_"
},
{
"path": "manimlib/mobject/svg/drawings.py",
"chars": 24827,
"preview": "from __future__ import annotations\n\nimport numpy as np\nimport itertools as it\nimport random\nimport math\n\nfrom manimlib.a"
},
{
"path": "manimlib/mobject/svg/old_tex_mobject.py",
"chars": 10762,
"preview": "from __future__ import annotations\n\nfrom functools import reduce\nimport operator as op\nimport re\n\nfrom manimlib.constant"
},
{
"path": "manimlib/mobject/svg/special_tex.py",
"chars": 2945,
"preview": "from __future__ import annotations\n\nfrom manimlib.constants import MED_SMALL_BUFF, DEFAULT_MOBJECT_COLOR, GREY_C\nfrom ma"
},
{
"path": "manimlib/mobject/svg/string_mobject.py",
"chars": 21275,
"preview": "from __future__ import annotations\n\nfrom abc import ABC, abstractmethod\nimport itertools as it\nimport re\nfrom scipy.opti"
},
{
"path": "manimlib/mobject/svg/svg_mobject.py",
"chars": 15672,
"preview": "from __future__ import annotations\n\nfrom xml.etree import ElementTree as ET\n\nimport numpy as np\nimport svgelements as se"
},
{
"path": "manimlib/mobject/svg/tex_mobject.py",
"chars": 9537,
"preview": "from __future__ import annotations\n\nimport re\nfrom pathlib import Path\n\nfrom functools import lru_cache\n\nfrom manimlib.c"
},
{
"path": "manimlib/mobject/svg/text_mobject.py",
"chars": 16611,
"preview": "from __future__ import annotations\n\nfrom contextlib import contextmanager\nimport os\nfrom pathlib import Path\nimport re\ni"
},
{
"path": "manimlib/mobject/three_dimensions.py",
"chars": 12043,
"preview": "from __future__ import annotations\n\nimport math\n\nimport numpy as np\n\nfrom manimlib.constants import BLUE, BLUE_D, BLUE_E"
},
{
"path": "manimlib/mobject/types/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "manimlib/mobject/types/dot_cloud.py",
"chars": 5482,
"preview": "from __future__ import annotations\n\nimport moderngl\nimport numpy as np\n\nfrom manimlib.constants import GREY_C, YELLOW\nfr"
},
{
"path": "manimlib/mobject/types/image_mobject.py",
"chars": 2541,
"preview": "from __future__ import annotations\n\nimport numpy as np\nimport moderngl\nfrom PIL import Image\n\nfrom manimlib.constants im"
},
{
"path": "manimlib/mobject/types/point_cloud_mobject.py",
"chars": 3710,
"preview": "from __future__ import annotations\n\nimport numpy as np\n\nfrom manimlib.mobject.mobject import Mobject\nfrom manimlib.utils"
},
{
"path": "manimlib/mobject/types/surface.py",
"chars": 16467,
"preview": "from __future__ import annotations\n\nimport moderngl\nimport numpy as np\nimport trimesh\nimport pywavefront\nimport logging\n"
},
{
"path": "manimlib/mobject/types/vectorized_mobject.py",
"chars": 53247,
"preview": "from __future__ import annotations\n\nfrom functools import wraps\n\nimport numpy as np\n\nfrom manimlib.constants import GREY"
},
{
"path": "manimlib/mobject/value_tracker.py",
"chars": 1881,
"preview": "from __future__ import annotations\n\nimport numpy as np\nfrom manimlib.mobject.mobject import Mobject\nfrom manimlib.utils."
},
{
"path": "manimlib/mobject/vector_field.py",
"chars": 16445,
"preview": "from __future__ import annotations\n\nimport itertools as it\n\nimport numpy as np\nfrom scipy.integrate import solve_ivp\n\nfr"
},
{
"path": "manimlib/module_loader.py",
"chars": 6411,
"preview": "from __future__ import annotations\n\nimport builtins\nimport importlib\nimport os\nimport sys\nimport sysconfig\n\nfrom manimli"
},
{
"path": "manimlib/scene/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "manimlib/scene/interactive_scene.py",
"chars": 23822,
"preview": "from __future__ import annotations\n\nimport itertools as it\nimport numpy as np\nimport pyperclip\nfrom IPython.core.getipyt"
},
{
"path": "manimlib/scene/scene.py",
"chars": 32167,
"preview": "from __future__ import annotations\n\nfrom collections import OrderedDict\nimport platform\nimport random\nimport time\nfrom f"
},
{
"path": "manimlib/scene/scene_embed.py",
"chars": 8976,
"preview": "from __future__ import annotations\n\nimport inspect\nimport pyperclip\nimport traceback\n\nfrom IPython.terminal import pt_in"
},
{
"path": "manimlib/scene/scene_file_writer.py",
"chars": 13353,
"preview": "from __future__ import annotations\n\nimport os\nimport platform\nimport shutil\nimport subprocess as sp\nimport sys\n\nimport n"
},
{
"path": "manimlib/shader_wrapper.py",
"chars": 17813,
"preview": "from __future__ import annotations\n\nimport copy\nimport os\nimport re\n\nimport OpenGL.GL as gl\nimport moderngl\nimport numpy"
},
{
"path": "manimlib/shaders/image/frag.glsl",
"chars": 200,
"preview": "#version 330\n\nuniform sampler2D Texture;\n\nin vec2 v_im_coords;\nin float v_opacity;\n\nout vec4 frag_color;\n\nvoid main() {\n"
},
{
"path": "manimlib/shaders/image/vert.glsl",
"chars": 302,
"preview": "#version 330\n\nuniform sampler2D Texture;\n\nin vec3 point;\nin vec2 im_coords;\nin float opacity;\n\nout vec2 v_im_coords;\nout"
},
{
"path": "manimlib/shaders/inserts/NOTE.md",
"chars": 562,
"preview": "There seems to be no analog to #include in C++ for OpenGL shaders. While there are other options for sharing code betwe"
},
{
"path": "manimlib/shaders/inserts/complex_functions.glsl",
"chars": 376,
"preview": "vec2 complex_mult(vec2 z, vec2 w){\n return vec2(z.x * w.x - z.y * w.y, z.x * w.y + z.y * w.x);\n}\n\nvec2 complex_div(ve"
},
{
"path": "manimlib/shaders/inserts/emit_gl_Position.glsl",
"chars": 1158,
"preview": "uniform float is_fixed_in_frame;\nuniform mat4 view;\nuniform float focal_distance;\nuniform vec3 frame_rescale_factors;\nun"
},
{
"path": "manimlib/shaders/inserts/finalize_color.glsl",
"chars": 1768,
"preview": "uniform vec3 light_position;\nuniform vec3 camera_position;\nuniform vec3 shading;\n\nvec3 float_to_color(float value, float"
},
{
"path": "manimlib/shaders/inserts/get_unit_normal.glsl",
"chars": 615,
"preview": "vec3 get_unit_normal(vec3 p0, vec3 p1, vec3 p2){\n float tol = 1e-6;\n vec3 v1 = normalize(p1 - p0);\n vec3 v2 = n"
},
{
"path": "manimlib/shaders/inserts/get_xyz_to_uv.glsl",
"chars": 3210,
"preview": "vec2 xs_on_clean_parabola(vec3 b0, vec3 b1, vec3 b2){\n /*\n Given three control points for a quadratic bezier,\n "
},
{
"path": "manimlib/shaders/mandelbrot_fractal/frag.glsl",
"chars": 1383,
"preview": "#version 330\n\nuniform vec2 parameter;\nuniform float opacity;\nuniform float n_steps;\nuniform float mandelbrot;\n\nuniform v"
},
{
"path": "manimlib/shaders/mandelbrot_fractal/vert.glsl",
"chars": 225,
"preview": "#version 330\n\nin vec3 point;\nout vec3 xyz_coords;\n\nuniform float scale_factor;\nuniform vec3 offset;\n\n#INSERT emit_gl_Pos"
},
{
"path": "manimlib/shaders/newton_fractal/frag.glsl",
"chars": 3895,
"preview": "#version 330\n\nuniform vec4 color0;\nuniform vec4 color1;\nuniform vec4 color2;\nuniform vec4 color3;\nuniform vec4 color4;\n\n"
},
{
"path": "manimlib/shaders/newton_fractal/vert.glsl",
"chars": 225,
"preview": "#version 330\n\nin vec3 point;\nout vec3 xyz_coords;\n\nuniform float scale_factor;\nuniform vec3 offset;\n\n#INSERT emit_gl_Pos"
},
{
"path": "manimlib/shaders/quadratic_bezier/depth/frag.glsl",
"chars": 86,
"preview": "#version 330\n\nout float frag_depth;\n\nvoid main() {\n frag_depth = gl_FragCoord.z;\n}\n"
},
{
"path": "manimlib/shaders/quadratic_bezier/depth/geom.glsl",
"chars": 648,
"preview": "#version 330\n\nlayout (triangles) in;\nlayout (triangle_strip, max_vertices = 6) out;\n\nin vec3 verts[3];\nin vec3 v_base_po"
},
{
"path": "manimlib/shaders/quadratic_bezier/depth/vert.glsl",
"chars": 156,
"preview": "#version 330\n\nin vec3 point;\nin vec3 base_normal;\n\nout vec3 verts;\nout vec3 v_base_point;\n\nvoid main(){\n verts = poin"
},
{
"path": "manimlib/shaders/quadratic_bezier/fill/frag.glsl",
"chars": 1371,
"preview": "#version 330\n\nuniform bool winding;\n\nin vec4 color;\nin float fill_all;\nin float orientation;\nin vec2 uv_coords;\n\nout vec"
},
{
"path": "manimlib/shaders/quadratic_bezier/fill/geom.glsl",
"chars": 1721,
"preview": "#version 330\n\nlayout (triangles) in;\nlayout (triangle_strip, max_vertices = 6) out;\n\nin vec3 verts[3];\nin vec4 v_color[3"
},
{
"path": "manimlib/shaders/quadratic_bezier/fill/vert.glsl",
"chars": 245,
"preview": "#version 330\n\nin vec3 point;\nin vec4 fill_rgba;\nin vec3 base_normal;\n\nout vec3 verts; // Bezier control point\nout vec4 "
},
{
"path": "manimlib/shaders/quadratic_bezier/stroke/frag.glsl",
"chars": 506,
"preview": "#version 330\n\n// Distance to the curve, and half the curve width, both as\n// a ratio of the antialias width\nin float dis"
},
{
"path": "manimlib/shaders/quadratic_bezier/stroke/geom.glsl",
"chars": 7312,
"preview": "#version 330\n\nlayout (triangles) in;\nlayout (triangle_strip, max_vertices = 64) out; // Related to MAX_STEPS below\n\nuni"
},
{
"path": "manimlib/shaders/quadratic_bezier/stroke/vert.glsl",
"chars": 629,
"preview": "#version 330\n\nuniform float frame_scale;\nuniform float is_fixed_in_frame;\nuniform float scale_stroke_with_zoom;\n\nin vec3"
},
{
"path": "manimlib/shaders/simple_vert.glsl",
"chars": 104,
"preview": "#version 330\n\nin vec3 point;\n\n#INSERT emit_gl_Position.glsl\n\nvoid main(){\n emit_gl_Position(point);\n}"
},
{
"path": "manimlib/shaders/surface/frag.glsl",
"chars": 94,
"preview": "#version 330\n\nin vec4 v_color;\nout vec4 frag_color;\n\nvoid main() {\n frag_color = v_color;\n}"
},
{
"path": "manimlib/shaders/surface/vert.glsl",
"chars": 362,
"preview": "#version 330\n\nin vec3 point;\nin vec3 d_normal_point;\nin vec4 rgba;\n\nout vec4 v_color;\n\n#INSERT emit_gl_Position.glsl\n#IN"
},
{
"path": "manimlib/shaders/textured_surface/frag.glsl",
"chars": 810,
"preview": "#version 330\n\nuniform sampler2D LightTexture;\nuniform sampler2D DarkTexture;\nuniform float num_textures;\n\nin vec3 v_poin"
},
{
"path": "manimlib/shaders/textured_surface/vert.glsl",
"chars": 488,
"preview": "#version 330\n\nin vec3 point;\nin vec3 d_normal_point;\nin vec2 im_coords;\nin float opacity;\n\nout vec3 v_point;\nout vec3 v_"
},
{
"path": "manimlib/shaders/true_dot/frag.glsl",
"chars": 758,
"preview": "#version 330\n\nuniform float glow_factor;\nuniform mat4 perspective;\n\nin vec4 color;\nin float scaled_aaw;\nin vec3 point;\ni"
},
{
"path": "manimlib/shaders/true_dot/geom.glsl",
"chars": 1023,
"preview": "#version 330\n\nlayout (points) in;\nlayout (triangle_strip, max_vertices = 4) out;\n\nuniform float pixel_size;\nuniform floa"
},
{
"path": "manimlib/shaders/true_dot/vert.glsl",
"chars": 195,
"preview": "#version 330\n\nin vec3 point;\nin float radius;\nin vec4 rgba;\n\nout vec3 v_point;\nout float v_radius;\nout vec4 v_rgba;\n\n\nvo"
},
{
"path": "manimlib/tex_templates.yml",
"chars": 19573,
"preview": "# Classical TeX templates\n\ndefault:\n description: \"\"\n compiler: latex\n preamble: |-\n \\usepackage[english]{babel}\n "
},
{
"path": "manimlib/typing.py",
"chars": 1694,
"preview": "from typing import TYPE_CHECKING\n\nif TYPE_CHECKING:\n from typing import Union, Tuple, Annotated, Literal, Iterable, D"
},
{
"path": "manimlib/utils/__init__.py",
"chars": 0,
"preview": ""
},
{
"path": "manimlib/utils/bezier.py",
"chars": 13063,
"preview": "from __future__ import annotations\n\nimport numpy as np\nfrom scipy import linalg\nfrom fontTools.cu2qu.cu2qu import curve_"
},
{
"path": "manimlib/utils/cache.py",
"chars": 798,
"preview": "from __future__ import annotations\n\nimport os\nfrom diskcache import Cache\nfrom contextlib import contextmanager\nfrom fun"
},
{
"path": "manimlib/utils/color.py",
"chars": 5483,
"preview": "from __future__ import annotations\n\nfrom colour import Color\nfrom colour import hex2rgb\nfrom colour import rgb2hex\nimpor"
},
{
"path": "manimlib/utils/debug.py",
"chars": 887,
"preview": "from __future__ import annotations\n\nfrom manimlib.constants import BLACK\nfrom manimlib.logger import log\nfrom manimlib.m"
},
{
"path": "manimlib/utils/dict_ops.py",
"chars": 699,
"preview": "import itertools as it\nimport numpy as np\n\n\ndef merge_dicts_recursively(*dicts):\n \"\"\"\n Creates a dict whose keyset"
},
{
"path": "manimlib/utils/directories.py",
"chars": 1131,
"preview": "from __future__ import annotations\n\nimport os\nimport tempfile\nimport appdirs\n\n\nfrom manimlib.config import manim_config\n"
},
{
"path": "manimlib/utils/family_ops.py",
"chars": 1468,
"preview": "from __future__ import annotations\n\nfrom typing import TYPE_CHECKING\n\nif TYPE_CHECKING:\n from typing import Iterable,"
},
{
"path": "manimlib/utils/file_ops.py",
"chars": 1658,
"preview": "from __future__ import annotations\n\nimport os\nfrom pathlib import Path\nimport hashlib\n\nimport numpy as np\nimport validat"
},
{
"path": "manimlib/utils/images.py",
"chars": 1180,
"preview": "from __future__ import annotations\n\nimport numpy as np\nfrom PIL import Image\n\nfrom manimlib.utils.directories import get"
},
{
"path": "manimlib/utils/iterables.py",
"chars": 4766,
"preview": "from __future__ import annotations\n\nfrom colour import Color\n\nimport numpy as np\nimport random\n\nfrom typing import TYPE_"
},
{
"path": "manimlib/utils/paths.py",
"chars": 2813,
"preview": "from __future__ import annotations\n\nimport math\n\nimport numpy as np\n\nfrom manimlib.constants import OUT\nfrom manimlib.ut"
},
{
"path": "manimlib/utils/rate_functions.py",
"chars": 2675,
"preview": "from __future__ import annotations\n\nimport numpy as np\n\nfrom manimlib.utils.bezier import bezier\n\nfrom typing import TYP"
},
{
"path": "manimlib/utils/shaders.py",
"chars": 3086,
"preview": "from __future__ import annotations\n\nimport os\nimport re\nfrom functools import lru_cache\nimport moderngl\nfrom PIL import "
},
{
"path": "manimlib/utils/simple_functions.py",
"chars": 2389,
"preview": "from __future__ import annotations\n\nfrom functools import lru_cache\nimport hashlib\nimport inspect\nimport math\n\nimport nu"
},
{
"path": "manimlib/utils/sounds.py",
"chars": 1130,
"preview": "from __future__ import annotations\n\nimport subprocess\nimport threading\nimport platform\n\nfrom manimlib.utils.directories "
},
{
"path": "manimlib/utils/space_ops.py",
"chars": 13781,
"preview": "from __future__ import annotations\n\nfrom functools import reduce\nimport math\nimport operator as op\nimport platform\n\nfrom"
},
{
"path": "manimlib/utils/tex.py",
"chars": 1353,
"preview": "from __future__ import annotations\n\nimport re\nfrom functools import lru_cache\n\nfrom manimlib.utils.tex_to_symbol_count i"
},
{
"path": "manimlib/utils/tex_file_writing.py",
"chars": 4351,
"preview": "from __future__ import annotations\n\nimport os\nimport re\nimport yaml\nimport subprocess\nfrom functools import lru_cache\n\nf"
},
{
"path": "manimlib/utils/tex_to_symbol_count.py",
"chars": 3563,
"preview": "TEX_TO_SYMBOL_COUNT = {\n R\"\\!\": 0,\n R\"\\,\": 0,\n R\"\\-\": 0,\n R\"\\/\": 0,\n R\"\\:\": 0,\n R\"\\;\": 0,\n R\"\\>\": 0"
},
{
"path": "manimlib/window.py",
"chars": 8345,
"preview": "from __future__ import annotations\n\nimport numpy as np\n\nimport moderngl_window as mglw\nfrom moderngl_window.context.pygl"
},
{
"path": "pyproject.toml",
"chars": 49,
"preview": "[build-system]\nrequires = [\"setuptools\", \"wheel\"]"
},
{
"path": "requirements.txt",
"chars": 378,
"preview": "addict\nappdirs\naudioop-lts; python_version>='3.13'\ncolour\ndiskcache\nipython>=8.18.0\nisosurfaces\nfontTools\nmanimpango>=0."
},
{
"path": "setup.cfg",
"chars": 1604,
"preview": "[metadata]\nname = manimgl\nversion = 1.7.2\nauthor = Grant Sanderson\nauthor_email= grant@3blue1brown.com\ndescription = Ani"
},
{
"path": "setup.py",
"chars": 36,
"preview": "import setuptools\nsetuptools.setup()"
}
]
About this extraction
This page contains the full source code of the 3b1b/manim GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 160 files (958.5 KB), approximately 248.9k tokens, and a symbol index with 1997 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.