diff --git a/data/rag/manim_docs/manim_core/docs/guides/.DS_Store b/data/rag/manim_docs/manim_core/docs/guides/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6
Binary files /dev/null and b/data/rag/manim_docs/manim_core/docs/guides/.DS_Store differ
diff --git a/data/rag/manim_docs/manim_core/docs/guides/add_voiceovers.md b/data/rag/manim_docs/manim_core/docs/guides/add_voiceovers.md
new file mode 100644
index 0000000000000000000000000000000000000000..a4f6177cc2d4c806967cb37de8c7af6bad0fe564
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/guides/add_voiceovers.md
@@ -0,0 +1,63 @@
+# Adding Voiceovers to Videos
+
+Creating a full-fledged video with voiceovers is a bit more involved than
+creating purely visual Manim scenes. One has to use [a video editing
+program](https://en.wikipedia.org/wiki/List_of_video_editing_software)
+to add the voiceovers after the video has been rendered. This process
+can be difficult and time-consuming, since it requires a lot of planning
+and preparation.
+
+To ease the process of adding voiceovers to videos, we have created
+[Manim Voiceover](https://voiceover.manim.community), a plugin
+that lets you add voiceovers to scenes directly in Python. To install it, run
+
+```bash
+pip install "manim-voiceover[azure,gtts]"
+```
+
+Visit [the installation page](https://voiceover.manim.community/en/latest/installation.html)
+for more details on how to install Manim Voiceover.
+
+## Basic Usage
+
+Manim Voiceover lets you …
+
+- Add voiceovers to Manim videos directly in Python, without having to use a video editor.
+- Record voiceovers with your microphone during rendering through a simple command line interface.
+- Develop animations with auto-generated AI voices from various free and proprietary services.
+
+It provides a very simple API that lets you specify your voiceover script
+and then record it during rendering:
+
+```python
+from manim import *
+from manim_voiceover import VoiceoverScene
+from manim_voiceover.services.recorder import RecorderService
+
+
+# Simply inherit from VoiceoverScene instead of Scene to get all the
+# voiceover functionality.
+class RecorderExample(VoiceoverScene):
+ def construct(self):
+ # You can choose from a multitude of TTS services,
+ # or in this example, record your own voice:
+ self.set_speech_service(RecorderService())
+
+ circle = Circle()
+
+ # Surround animation sections with with-statements:
+ with self.voiceover(text="This circle is drawn as I speak.") as tracker:
+ self.play(Create(circle), run_time=tracker.duration)
+ # The duration of the animation is received from the audio file
+ # and passed to the tracker automatically.
+
+ # This part will not start playing until the previous voiceover is finished.
+ with self.voiceover(text="Let's shift it to the left 2 units.") as tracker:
+ self.play(circle.animate.shift(2 * LEFT), run_time=tracker.duration)
+```
+
+To get started with Manim Voiceover,
+visit the [Quick Start Guide](https://voiceover.manim.community/en/latest/quickstart.html).
+
+Visit the [Example Gallery](https://voiceover.manim.community/en/latest/examples.html)
+to see some examples of Manim Voiceover in action.
diff --git a/data/rag/manim_docs/manim_core/docs/guides/deep_dive.md b/data/rag/manim_docs/manim_core/docs/guides/deep_dive.md
new file mode 100644
index 0000000000000000000000000000000000000000..b094fa6ac1dadd804380048c4a523200737850a5
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/guides/deep_dive.md
@@ -0,0 +1,1004 @@
+# A deep dive into Manim’s internals
+
+**Author:** [Benjamin Hackl](https://benjamin-hackl.at)
+
+## Introduction
+
+Manim can be a wonderful library, if it behaves the way you would like it to,
+and/or the way you expect it to. Unfortunately, this is not always the case
+(as you probably know if you have played with some manimations yourself already).
+To understand where things *go wrong*, digging through the library’s source code
+is sometimes the only option – but in order to do that, you need to know where
+to start digging.
+
+This article is intended as some sort of life line through the render process.
+We aim to give an appropriate amount of detail describing what happens when
+Manim reads your scene code and produces the corresponding animation. Throughout
+this article, we will focus on the following toy example:
+
+```default
+from manim import *
+
+class ToyExample(Scene):
+ def construct(self):
+ orange_square = Square(color=ORANGE, fill_opacity=0.5)
+ blue_circle = Circle(color=BLUE, fill_opacity=0.5)
+ self.add(orange_square)
+ self.play(ReplacementTransform(orange_square, blue_circle, run_time=3))
+ small_dot = Dot()
+ small_dot.add_updater(lambda mob: mob.next_to(blue_circle, DOWN))
+ self.play(Create(small_dot))
+ self.play(blue_circle.animate.shift(RIGHT))
+ self.wait()
+ self.play(FadeOut(blue_circle, small_dot))
+```
+
+Before we go into details or even look at the rendered output of this scene,
+let us first describe verbally what happens in this *manimation*. In the first
+three lines of the `construct` method, a [`Square`](../reference/manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square) and a [`Circle`](../reference/manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle)
+are initialized, then the square is added to the scene. The first frame of the
+rendered output should thus show an orange square.
+
+Then the actual animations happen: the square first transforms into a circle,
+then a [`Dot`](../reference/manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) is created (Where do you guess the dot is located when
+it is first added to the scene? Answering this already requires detailed
+knowledge about the render process.). The dot has an updater attached to it, and
+as the circle moves right, the dot moves with it. In the end, all mobjects are
+faded out.
+
+Actually rendering the code yields the following video:
+
+
+
+For this example, the output (fortunately) coincides with our expectations.
+
+## Overview
+
+Because there is a lot of information in this article, here is a brief overview
+discussing the contents of the following chapters on a very high level.
+
+- [Preliminaries](): In this chapter we unravel all the steps that take place
+ to prepare a scene for rendering; right until the point where the user-overridden
+ `construct` method is ran. This includes a brief discussion on using Manim’s CLI
+ versus other means of rendering (e.g., via Jupyter notebooks, or in your Python
+ script by calling the [`Scene.render()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.render) method yourself).
+- [Mobject Initialization](): For the second chapter we dive into creating and handling
+ Mobjects, the basic elements that should be displayed in our scene.
+ We discuss the [`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) base class, how there are essentially
+ three different types of Mobjects, and then discuss the most important of them,
+ vectorized Mobjects. In particular, we describe the internal point data structure
+ that governs how the mechanism responsible for drawing the vectorized Mobject
+ to the screen sets the corresponding Bézier curves. We conclude the chapter
+ with a tour into [`Scene.add()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.add), the bookkeeping mechanism controlling which
+ mobjects should be rendered.
+- [Animations and the Render Loop](): And finally, in the last chapter we walk
+ through the instantiation of [`Animation`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation) objects (the blueprints that
+ hold information on how Mobjects should be modified when the render loop runs),
+ followed by a investigation of the infamous [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call. We will
+ see that there are three relevant parts in a [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call;
+ a part in which the passed animations and keyword arguments are processed
+ and prepared, followed by the actual “render loop” in which the library
+ steps through a time line and renders frame by frame. The final part
+ does some post-processing to save a short video segment (“partial movie file”)
+ and cleanup for the next call to [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play). In the end, after all of
+ [`Scene.construct()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.construct) has been run, the library combines the partial movie
+ files to one video.
+
+And with that, let us get *in medias res*.
+
+## Preliminaries
+
+### Importing the library
+
+Independent of how exactly you are telling your system
+to render the scene, i.e., whether you run `manim -qm -p file_name.py ToyExample`, or
+whether you are rendering the scene directly from the Python script via a snippet
+like
+
+```default
+with tempconfig({"quality": "medium_quality", "preview": True}):
+ scene = ToyExample()
+ scene.render()
+```
+
+or whether you are rendering the code in a Jupyter notebook, you are still telling your
+python interpreter to import the library. The usual pattern used to do this is
+
+```default
+from manim import *
+```
+
+which (while being a debatable strategy in general) imports a lot of classes and
+functions shipped with the library and makes them available in your global name space.
+I explicitly avoided stating that it imports **all** classes and functions of the
+library, because it does not do that: Manim makes use of the practice described
+in [Section 6.4.1 of the Python tutorial](https://docs.python.org/3/tutorial/modules.html#importing-from-a-package),
+and all module members that should be exposed to the user upon running the `*`-import
+are explicitly declared in the `__all__` variable of the module.
+
+Manim also uses this strategy internally: taking a peek at the file that is run when
+the import is called, `__init__.py` (see
+[here](https://github.com/ManimCommunity/manim/blob/main/manim/__init__.py)),
+you will notice that most of the code in that module is concerned with importing
+members from various different submodules, again using `*`-imports.
+
+In that file, there is one particular import at the beginning of the file however,
+namely:
+
+```default
+from ._config import *
+```
+
+This initializes Manim’s global configuration system, which is used in various places
+throughout the library. After the library runs this line, the current configuration
+options are set. The code in there takes care of reading the options in your `.cfg`
+files (all users have at least the global one that is shipped with the library)
+as well as correctly handling command line arguments (if you used the CLI to render).
+
+You can read more about the config system in the
+[corresponding thematic guide](configuration.md), and if you are interested in learning
+more about the internals of the configuration system and how it is initialized,
+follow the code flow starting in [the config module’s init file](https://github.com/ManimCommunity/manim/blob/main/manim/_config/__init__.py).
+
+Now that the library is imported, we can turn our attention to the next step:
+reading your scene code (which is not particularly exciting, Python just creates
+a new class `ToyExample` based on our code; Manim is virtually not involved
+in that step, with the exception that `ToyExample` inherits from `Scene`).
+
+However, with the `ToyExample` class created and ready to go, there is a new
+excellent question to answer: how is the code in our `construct` method
+actually executed?
+
+### Scene instantiation and rendering
+
+The answer to this question depends on how exactly you are running the code.
+To make things a bit clearer, let us first consider the case that you
+have created a file `toy_example.py` which looks like this:
+
+```default
+from manim import *
+
+class ToyExample(Scene):
+ def construct(self):
+ orange_square = Square(color=ORANGE, fill_opacity=0.5)
+ blue_circle = Circle(color=BLUE, fill_opacity=0.5)
+ self.add(orange_square)
+ self.play(ReplacementTransform(orange_square, blue_circle, run_time=3))
+ small_dot = Dot()
+ small_dot.add_updater(lambda mob: mob.next_to(blue_circle, DOWN))
+ self.play(Create(small_dot))
+ self.play(blue_circle.animate.shift(RIGHT))
+ self.wait()
+ self.play(FadeOut(blue_circle, small_dot))
+
+with tempconfig({"quality": "medium_quality", "preview": True}):
+ scene = ToyExample()
+ scene.render()
+```
+
+With such a file, the desired scene is rendered by simply running this Python
+script via `python toy_example.py`. Then, as described above, the library
+is imported and Python has read and defined the `ToyExample` class (but,
+read carefully: *no instance of this class has been created yet*).
+
+At this point, the interpreter is about to enter the `tempconfig` context
+manager. Even if you have not seen Manim’s `tempconfig` before, its name
+already suggests what it does: it creates a copy of the current state of the
+configuration, applies the changes to the key-value pairs in the passed
+dictionary, and upon leaving the context the original version of the
+configuration is restored. TL;DR: it provides a fancy way of temporarily setting
+configuration options.
+
+Inside the context manager, two things happen: an actual `ToyExample`-scene
+object is instantiated, and the `render` method is called. Every way of using
+Manim ultimately does something along of these lines, the library always instantiates
+the scene object and then calls its `render` method. To illustrate that this
+really is the case, let us briefly look at the two most common ways of rendering
+scenes:
+
+**Command Line Interface.** When using the CLI and running the command
+`manim -qm -p toy_example.py ToyExample` in your terminal, the actual
+entry point is Manim’s `__main__.py` file (located
+[here](https://github.com/ManimCommunity/manim/blob/main/manim/__main__.py).
+Manim uses [Click](https://click.palletsprojects.com/en/8.0.x/) to implement
+the command line interface, and the corresponding code is located in Manim’s
+`cli` module ([https://github.com/ManimCommunity/manim/tree/main/manim/cli](https://github.com/ManimCommunity/manim/tree/main/manim/cli)).
+The corresponding code creating the scene class and calling its render method
+is located [here](https://github.com/ManimCommunity/manim/blob/ac1ee9a683ce8b92233407351c681f7d71a4f2db/manim/cli/render/commands.py#L139-L141).
+
+**Jupyter notebooks.** In Jupyter notebooks, the communication with the library
+is handled by the `%%manim` magic command, which is implemented in the
+`manim.utils.ipython_magic` module. There is
+[`some documentation`](../reference/manim.utils.ipython_magic.ManimMagic.md#manim.utils.ipython_magic.ManimMagic.manim) available for the magic command,
+and the code creating the scene class and calling its render method is located
+[here](https://github.com/ManimCommunity/manim/blob/ac1ee9a683ce8b92233407351c681f7d71a4f2db/manim/utils/ipython_magic.py#L137-L138).
+
+Now that we know that either way, a [`Scene`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene) object is created, let us investigate
+what Manim does when that happens. When instantiating our scene object
+
+```default
+scene = ToyExample()
+```
+
+the `Scene.__init__` method is called, given that we did not implement our own initialization
+method. Inspecting the corresponding code (see
+[here](https://github.com/ManimCommunity/manim/blob/main/manim/scene/scene.py))
+reveals that `Scene.__init__` first sets several attributes of the scene objects that do not
+depend on any configuration options set in `config`. Then the scene inspects the value of
+`config.renderer`, and based on its value, either instantiates a `CairoRenderer` or an
+`OpenGLRenderer` object and assigns it to its `renderer` attribute.
+
+The scene then asks its renderer to initialize the scene by calling
+
+```default
+self.renderer.init_scene(self)
+```
+
+Inspecting both the default Cairo renderer and the OpenGL renderer shows that the `init_scene`
+method effectively makes the renderer instantiate a [`SceneFileWriter`](../reference/manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter) object, which
+basically is Manim’s interface to `libav` (FFMPEG) and actually writes the movie file. The Cairo
+renderer (see the implementation [here](https://github.com/ManimCommunity/manim/blob/main/manim/renderer/cairo_renderer.py)) does not require any further initialization. The OpenGL renderer
+does some additional setup to enable the realtime rendering preview window, which we do not go
+into detail further here.
+
+#### WARNING
+Currently, there is a lot of interplay between a scene and its renderer. This is a flaw
+in Manim’s current architecture, and we are working on reducing this interdependency to
+achieve a less convoluted code flow.
+
+After the renderer has been instantiated and initialized its file writer, the scene populates
+further initial attributes (notable mention: the `mobjects` attribute which keeps track
+of the mobjects that have been added to the scene). It is then done with its instantiation
+and ready to be rendered.
+
+The rest of this article is concerned with the last line in our toy example script:
+
+```default
+scene.render()
+```
+
+This is where the actual magic happens.
+
+Inspecting the [implementation of the render method](https://github.com/ManimCommunity/manim/blob/df1a60421ea1119cbbbd143ef288d294851baaac/manim/scene/scene.py#L211)
+reveals that there are several hooks that can be used for pre- or postprocessing
+a scene. Unsurprisingly, [`Scene.render()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.render) describes the full *render cycle*
+of a scene. During this life cycle, there are three custom methods whose base
+implementation is empty and that can be overwritten to suit your purposes. In
+the order they are called, these customizable methods are:
+
+- [`Scene.setup()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.setup), which is intended for preparing and, well, *setting up*
+ the scene for your animation (e.g., adding initial mobjects, assigning custom
+ attributes to your scene class, etc.),
+- [`Scene.construct()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.construct), which is the *script* for your screen play and
+ contains programmatic descriptions of your animations, and
+- [`Scene.tear_down()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.tear_down), which is intended for any operations you might
+ want to run on the scene after the last frame has already been rendered
+ (for example, this could run some code that generates a custom thumbnail
+ for the video based on the state of the objects in the scene – this
+ hook is more relevant for situations where Manim is used within other
+ Python scripts).
+
+After these three methods are run, the animations have been fully rendered,
+and Manim calls `CairoRenderer.scene_finished()` to gracefully
+complete the rendering process. This checks whether any animations have been
+played – and if so, it tells the [`SceneFileWriter`](../reference/manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter) to close the output
+file. If not, Manim assumes that a static image should be output
+which it then renders using the same strategy by calling the render loop
+(see below) once.
+
+**Back in our toy example,** the call to [`Scene.render()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.render) first
+triggers [`Scene.setup()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.setup) (which only consists of `pass`), followed by
+a call of [`Scene.construct()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.construct). At this point, our *animation script*
+is run, starting with the initialization of `orange_square`.
+
+## Mobject Initialization
+
+Mobjects are, in a nutshell, the Python objects that represent all the
+*things* we want to display in our scene. Before we follow our debugger
+into the depths of mobject initialization code, it makes sense to
+discuss Manim’s different types of Mobjects and their basic data
+structure.
+
+### What even is a Mobject?
+
+[`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) stands for *mathematical object* or *Manim object*
+(depends on who you ask 😄). The Python class [`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) is
+the base class for all objects that should be displayed on screen.
+Looking at the [initialization method](https://github.com/ManimCommunity/manim/blob/5d72d9cfa2e3dd21c844b1da807576f5a7194fda/manim/mobject/mobject.py#L94)
+of [`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject), you will find that not too much happens in there:
+
+- some initial attribute values are assigned, like `name` (which makes the
+ render logs mention the name of the mobject instead of its type),
+ `submobjects` (initially an empty list), `color`, and some others.
+- Then, two methods related to *points* are called: `reset_points`
+ followed by `generate_points`,
+- and finally, `init_colors` is called.
+
+Digging deeper, you will find that [`Mobject.reset_points()`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.reset_points) simply
+sets the `points` attribute of the mobject to an empty NumPy vector,
+while the other two methods, [`Mobject.generate_points()`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.generate_points) and
+[`Mobject.init_colors()`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.init_colors) are just implemented as `pass`.
+
+This makes sense: [`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) is not supposed to be used as
+an *actual* object that is displayed on screen; in fact the camera
+(which we will discuss later in more detail; it is the class that is,
+for the Cairo renderer, responsible for “taking a picture” of the
+current scene) does not process “pure” [`Mobjects`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+in any way, they *cannot* even appear in the rendered output.
+
+This is where different types of mobjects come into play. Roughly
+speaking, the Cairo renderer setup knows three different types of
+mobjects that can be rendered:
+
+- [`ImageMobject`](../reference/manim.mobject.types.image_mobject.ImageMobject.md#manim.mobject.types.image_mobject.ImageMobject), which represent images that you can display
+ in your scene,
+- [`PMobject`](../reference/manim.mobject.types.point_cloud_mobject.PMobject.md#manim.mobject.types.point_cloud_mobject.PMobject), which are very special mobjects used to represent
+ point clouds; we will not discuss them further in this guide,
+- [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject), which are *vectorized mobjects*, that is, mobjects
+ that consist of points that are connected via curves. These are pretty
+ much everywhere, and we will discuss them in detail in the next section.
+
+### … and what are VMobjects?
+
+As just mentioned, [`VMobjects`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) represent vectorized
+mobjects. To render a [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject), the camera looks at the
+`points` attribute of a [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) and divides it into sets
+of four points each. Each of these sets is then used to construct a
+cubic Bézier curve with the first and last entry describing the
+end points of the curve (“anchors”), and the second and third entry
+describing the control points in between (“handles”).
+
+In contrast to [`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject), [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) can be displayed
+on screen (even though, technically, it is still considered a base class).
+To illustrate how points are processed, consider the following short example
+of a [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) with 8 points (and thus made out of 8/4 = 2 cubic
+Bézier curves). The resulting [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) is drawn in green.
+The handles are drawn as red dots with a line to their closest anchor.
+
+
+```python
+from manim import *
+
+class VMobjectDemo(Scene):
+ def construct(self):
+ plane = NumberPlane()
+ my_vmobject = VMobject(color=GREEN)
+ my_vmobject.points = [
+ np.array([-2, -1, 0]), # start of first curve
+ np.array([-3, 1, 0]),
+ np.array([0, 3, 0]),
+ np.array([1, 3, 0]), # end of first curve
+ np.array([1, 3, 0]), # start of second curve
+ np.array([0, 1, 0]),
+ np.array([4, 3, 0]),
+ np.array([4, -2, 0]), # end of second curve
+ ]
+ handles = [
+ Dot(point, color=RED) for point in
+ [[-3, 1, 0], [0, 3, 0], [0, 1, 0], [4, 3, 0]]
+ ]
+ handle_lines = [
+ Line(
+ my_vmobject.points[ind],
+ my_vmobject.points[ind+1],
+ color=RED,
+ stroke_width=2
+ ) for ind in range(0, len(my_vmobject.points), 2)
+ ]
+ self.add(plane, *handles, *handle_lines, my_vmobject)
+```
+
+
+class VMobjectDemo(Scene):
+ def construct(self):
+ plane = NumberPlane()
+ my_vmobject = VMobject(color=GREEN)
+ my_vmobject.points = [
+ np.array([-2, -1, 0]), # start of first curve
+ np.array([-3, 1, 0]),
+ np.array([0, 3, 0]),
+ np.array([1, 3, 0]), # end of first curve
+ np.array([1, 3, 0]), # start of second curve
+ np.array([0, 1, 0]),
+ np.array([4, 3, 0]),
+ np.array([4, -2, 0]), # end of second curve
+ ]
+ handles = [
+ Dot(point, color=RED) for point in
+ [[-3, 1, 0], [0, 3, 0], [0, 1, 0], [4, 3, 0]]
+ ]
+ handle_lines = [
+ Line(
+ my_vmobject.points[ind],
+ my_vmobject.points[ind+1],
+ color=RED,
+ stroke_width=2
+ ) for ind in range(0, len(my_vmobject.points), 2)
+ ]
+ self.add(plane, \*handles, \*handle_lines, my_vmobject)
+
+
+
+#### WARNING
+Manually setting the points of your [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) is usually
+discouraged; there are specialized methods that can take care of
+that for you – but it might be relevant when implementing your own,
+custom [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+
+### Squares and Circles: back to our Toy Example
+
+With a basic understanding of different types of mobjects,
+and an idea of how vectorized mobjects are built we can now
+come back to our toy example and the execution of the
+[`Scene.construct()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.construct) method. In the first two lines
+of our animation script, the `orange_square` and the
+`blue_circle` are initialized.
+
+When creating the orange square by running
+
+```default
+Square(color=ORANGE, fill_opacity=0.5)
+```
+
+the initialization method of [`Square`](../reference/manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square),
+`Square.__init__`, is called. [Looking at the
+implementation](https://github.com/ManimCommunity/manim/blob/5d72d9cfa2e3dd21c844b1da807576f5a7194fda/manim/mobject/geometry/polygram.py#L607),
+we can see that the `side_length` attribute of the square is set,
+and then
+
+```default
+super().__init__(height=side_length, width=side_length, **kwargs)
+```
+
+is called. This `super` call is the Python way of calling the
+initialization function of the parent class. As [`Square`](../reference/manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square)
+inherits from [`Rectangle`](../reference/manim.mobject.geometry.polygram.Rectangle.md#manim.mobject.geometry.polygram.Rectangle), the next method called
+is `Rectangle.__init__`. There, only the first three lines
+are really relevant for us:
+
+```default
+super().__init__(UR, UL, DL, DR, color=color, **kwargs)
+self.stretch_to_fit_width(width)
+self.stretch_to_fit_height(height)
+```
+
+First, the initialization function of the parent class of
+[`Rectangle`](../reference/manim.mobject.geometry.polygram.Rectangle.md#manim.mobject.geometry.polygram.Rectangle) – [`Polygon`](../reference/manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon) – is called. The
+four positional arguments passed are the four corners of
+the polygon: `UR` is up right (and equal to `UP + RIGHT`),
+`UL` is up left (and equal to `UP + LEFT`), and so forth.
+Before we follow our debugger deeper, let us observe what
+happens with the constructed polygon: the remaining two lines
+stretch the polygon to fit the specified width and height
+such that a rectangle with the desired measurements is created.
+
+The initialization function of [`Polygon`](../reference/manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon) is particularly
+simple, it only calls the initialization function of its parent
+class, [`Polygram`](../reference/manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram). There, we have almost reached the end
+of the chain: [`Polygram`](../reference/manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram) inherits from [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject),
+whose initialization function mainly sets the values of some
+attributes (quite similar to `Mobject.__init__`, but more specific
+to the Bézier curves that make up the mobject).
+
+After calling the initialization function of [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject),
+the constructor of [`Polygram`](../reference/manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram) also does something somewhat
+odd: it sets the points (which, you might remember above, should
+actually be set in a corresponding `generate_points` method
+of [`Polygram`](../reference/manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram)).
+
+#### WARNING
+In several instances, the implementation of mobjects does
+not really stick to all aspects of Manim’s interface. This
+is unfortunate, and increasing consistency is something
+that we actively work on. Help is welcome!
+
+Without going too much into detail, [`Polygram`](../reference/manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram) sets its
+`points` attribute via [`VMobject.start_new_path()`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject.start_new_path),
+[`VMobject.add_points_as_corners()`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject.add_points_as_corners), which take care of
+setting the quadruples of anchors and handles appropriately.
+After the points are set, Python continues to process the
+call stack until it reaches the method that was first called;
+the initialization method of [`Square`](../reference/manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square). After this,
+the square is initialized and assigned to the `orange_square`
+variable.
+
+The initialization of `blue_circle` is similar to the one of
+`orange_square`, with the main difference being that the inheritance
+chain of [`Circle`](../reference/manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle) is different. Let us briefly follow the trace
+of the debugger:
+
+The implementation of `Circle.__init__()` immediately calls
+the initialization method of [`Arc`](../reference/manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc), as a circle in Manim
+is simply an arc with an angle of $\tau = 2\pi$. When
+initializing the arc, some basic attributes are set (like
+`Arc.radius`, `Arc.arc_center`, `Arc.start_angle`, and
+`Arc.angle`), and then the initialization method of its
+parent class, [`TipableVMobject`](../reference/manim.mobject.geometry.arc.TipableVMobject.md#manim.mobject.geometry.arc.TipableVMobject), is called (which is
+a rather abstract base class for mobjects which a arrow tip can
+be attached to). Note that in contrast to [`Polygram`](../reference/manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram),
+this class does **not** preemptively generate the points of the circle.
+
+After that, things are less exciting: [`TipableVMobject`](../reference/manim.mobject.geometry.arc.TipableVMobject.md#manim.mobject.geometry.arc.TipableVMobject) again
+sets some attributes relevant for adding arrow tips, and afterwards
+passes to the initialization method of [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject). From there,
+[`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) is initialized and [`Mobject.generate_points()`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.generate_points)
+is called, which actually runs the method implemented in
+[`Arc.generate_points()`](../reference/manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc.generate_points).
+
+After both our `orange_square` and the `blue_circle` are initialized,
+the square is actually added to the scene. The [`Scene.add()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) method
+is actually doing a few interesting things, so it is worth to dig a bit
+deeper in the next section.
+
+### Adding Mobjects to the Scene
+
+The code in our `construct` method that is run next is
+
+```default
+self.add(orange_square)
+```
+
+From a high-level point of view, [`Scene.add()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) adds the
+`orange_square` to the list of mobjects that should be rendered,
+which is stored in the `mobjects` attribute of the scene. However,
+it does so in a very careful way to avoid the situation that a mobject
+is being added to the scene more than once. At a first glance, this
+sounds like a simple task – the problem is that `Scene.mobjects`
+is not a “flat” list of mobjects, but a list of mobjects which
+might contain mobjects themselves, and so on.
+
+Stepping through the code in [`Scene.add()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.add), we see that first
+it is checked whether we are currently using the OpenGL renderer
+(which we are not) – adding mobjects to the scene works slightly
+different (and actually easier!) for the OpenGL renderer. Then, the
+code branch for the Cairo renderer is entered and the list of so-called
+foreground mobjects (which are rendered on top of all other mobjects)
+is added to the list of passed mobjects. This is to ensure that the
+foreground mobjects will stay above of the other mobjects, even after
+adding the new ones. In our case, the list of foreground mobjects
+is actually empty, and nothing changes.
+
+Next, [`Scene.restructure_mobjects()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.restructure_mobjects) is called with the list
+of mobjects to be added as the `to_remove` argument, which might
+sound odd at first. Practically, this ensures that mobjects are not
+added twice, as mentioned above: if they were present in the scene
+`Scene.mobjects` list before (even if they were contained as a
+child of some other mobject), they are first removed from the list.
+The way [`Scene.restructure_mobjects()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.restructure_mobjects) works is rather aggressive:
+It always operates on a given list of mobjects; in the `add` method
+two different lists occur: the default one, `Scene.mobjects` (no extra
+keyword argument is passed), and `Scene.moving_mobjects` (which we will
+discuss later in more detail). It iterates through all of the members of
+the list, and checks whether any of the mobjects passed in `to_remove`
+are contained as children (in any nesting level). If so, **their parent
+mobject is deconstructed** and their siblings are inserted directly
+one level higher. Consider the following example:
+
+```default
+>>> from manim import Scene, Square, Circle, Group
+>>> test_scene = Scene()
+>>> mob1 = Square()
+>>> mob2 = Circle()
+>>> mob_group = Group(mob1, mob2)
+>>> test_scene.add(mob_group)
+
+>>> test_scene.mobjects
+[Group]
+>>> test_scene.restructure_mobjects(to_remove=[mob1])
+
+>>> test_scene.mobjects
+[Circle]
+```
+
+Note that the group is disbanded and the circle moves into the
+root layer of mobjects in `test_scene.mobjects`.
+
+After the mobject list is “restructured”, the mobject to be added
+are simply appended to `Scene.mobjects`. In our toy example,
+the `Scene.mobjects` list is actually empty, so the
+`restructure_mobjects` method does not actually do anything. The
+`orange_square` is simply added to `Scene.mobjects`, and as
+the aforementioned `Scene.moving_mobjects` list is, at this point,
+also still empty, nothing happens and [`Scene.add()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) returns.
+
+We will hear more about the `moving_mobject` list when we discuss
+the render loop. Before we do that, let us look at the next line
+of code in our toy example, which includes the initialization of
+an animation class,
+
+```default
+ReplacementTransform(orange_square, blue_circle, run_time=3)
+```
+
+Hence it is time to talk about [`Animation`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation).
+
+## Animations and the Render Loop
+
+### Initializing animations
+
+Before we follow the trace of the debugger, let us briefly discuss
+the general structure of the (abstract) base class [`Animation`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation).
+An animation object holds all the information necessary for the renderer
+to generate the corresponding frames. Animations (in the sense of
+animation objects) in Manim are *always* tied to a specific mobject;
+even in the case of [`AnimationGroup`](../reference/manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup) (which you should actually
+think of as an animation on a group of mobjects rather than a group
+of animations). Moreover, except for in a particular special case,
+the run time of animations is also fixed and known beforehand.
+
+The initialization of animations actually is not very exciting,
+`Animation.__init__()` merely sets some attributes derived
+from the passed keyword arguments and additionally ensures that
+the `Animation.starting_mobject` and `Animation.mobject`
+attributes are populated. Once the animation is played, the
+`starting_mobject` attribute holds an unmodified copy of the
+mobject the animation is attached to; during the initialization
+it is set to a placeholder mobject. The `mobject` attribute
+is set to the mobject the animation is attached to.
+
+Animations have a few special methods which are called during the
+render loop:
+
+- [`Animation.begin()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.begin), which is called (as hinted by its name)
+ at the beginning of every animation, so before the first frame
+ is rendered. In it, all the required setup for the animation happens.
+- [`Animation.finish()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.finish) is the counterpart to the `begin` method
+ which is called at the end of the life cycle of the animation (after
+ the last frame has been rendered).
+- [`Animation.interpolate()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.interpolate) is the method that updates the mobject
+ attached to the animation to the corresponding animation completion
+ percentage. For example, if in the render loop,
+ `some_animation.interpolate(0.5)` is called, the attached mobject
+ will be updated to the state where 50% of the animation are completed.
+
+We will discuss details about these and some further animation methods
+once we walk through the actual render loop. For now, we continue with
+our toy example and the code that is run when initializing the
+[`ReplacementTransform`](../reference/manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform) animation.
+
+The initialization method of [`ReplacementTransform`](../reference/manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform) only
+consists of a call to the constructor of its parent class,
+[`Transform`](../reference/manim.animation.transform.Transform.md#manim.animation.transform.Transform), with the additional keyword argument
+`replace_mobject_with_target_in_scene` set to `True`.
+[`Transform`](../reference/manim.animation.transform.Transform.md#manim.animation.transform.Transform) then sets attributes that control how the
+points of the starting mobject are deformed into the points of
+the target mobject, and then passes on to the initialization
+method of [`Animation`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation). Other basic properties of the
+animation (like its `run_time`, the `rate_func`, etc.) are
+processed there – and then the animation object is fully
+initialized and ready to be played.
+
+### The `play` call: preparing to enter Manim’s render loop
+
+We are finally there, the render loop is in our reach. Let us
+walk through the code that is run when [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) is called.
+
+As you will see when inspecting the method, [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) almost
+immediately passes over to the `play` method of the renderer,
+in our case `CairoRenderer.play`. The one thing [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play)
+takes care of is the management of subcaptions that you might have
+passed to it (see the the documentation of [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) and
+[`Scene.add_subcaption()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.add_subcaption) for more information).
+
+#### WARNING
+As has been said before, the communication between scene and renderer
+is not in a very clean state at this point, so the following paragraphs
+might be confusing if you don’t run a debugger and step through the
+code yourself a bit.
+
+Inside `CairoRenderer.play()`, the renderer first checks whether
+it may skip rendering of the current play call. This might happen, for example,
+when `-s` is passed to the CLI (i.e., only the last frame should be rendered),
+or when the `-n` flag is passed and the current play call is outside of the
+specified render bounds. The “skipping status” is updated in form of the
+call to `CairoRenderer.update_skipping_status()`.
+
+Next, the renderer asks the scene to process the animations in the play
+call so that renderer obtains all of the information it needs. To
+be more concrete, [`Scene.compile_animation_data()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.compile_animation_data) is called,
+which then takes care of several things:
+
+- The method processes all animations and the keyword arguments passed
+ to the initial [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call. In particular, this means
+ that it makes sure all arguments passed to the play call are actually
+ animations (or `.animate` syntax calls, which are also assembled to
+ be actual [`Animation`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation)-objects at that point). It also propagates
+ any animation-related keyword arguments (like `run_time`,
+ or `rate_func`) passed to `Scene.play` to each individual
+ animation. The processed animations are then stored in the `animations`
+ attribute of the scene (which the renderer later reads…).
+- It adds all mobjects to which the animations that are played are
+ bound to to the scene (provided the animation is not an mobject-introducing
+ animation – for these, the addition to the scene happens later).
+- In case the played animation is a [`Wait`](../reference/manim.animation.animation.Wait.md#manim.animation.animation.Wait) animation (this is the
+ case in a [`Scene.wait()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.wait) call), the method checks whether a static
+ image should be rendered, or whether the render loop should be processed
+ as usual (see [`Scene.should_update_mobjects()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.should_update_mobjects) for the exact conditions,
+ basically it checks whether there are any time-dependent updater functions
+ and so on).
+- Finally, the method determines the total run time of the play call (which
+ at this point is computed as the maximum of the run times of the passed
+ animations). This is stored in the `duration` attribute of the scene.
+
+After the animation data has been compiled by the scene, the renderer
+continues to prepare for entering the render loop. It now checks the
+skipping status which has been determined before. If the renderer can
+skip this play call, it does so: it sets the current play call hash (which
+we will get back to in a moment) to `None` and increases the time of the
+renderer by the determined animation run time.
+
+Otherwise, the renderer checks whether or not Manim’s caching system should
+be used. The idea of the caching system is simple: for every play call, a
+hash value is computed, which is then stored and upon re-rendering the scene,
+the hash is generated again and checked against the stored value. If it is the
+same, the cached output is reused, otherwise it is fully rerendered again.
+We will not go into details of the caching system here; if you would like
+to learn more, the [`get_hash_from_play_call()`](../reference/manim.utils.hashing.md#manim.utils.hashing.get_hash_from_play_call) function in the
+[`utils.hashing`](../reference/manim.utils.hashing.md#module-manim.utils.hashing) module is essentially the entry point to the caching
+mechanism.
+
+In the event that the animation has to be rendered, the renderer asks
+its [`SceneFileWriter`](../reference/manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter) to open an output container. The process
+is started by a call to `libav` and opens a container to which rendered
+raw frames can be written. As long as the output is open, the container
+can be accessed via the `output_container` attribute of the file writer.
+With the writing process in place, the renderer then asks the scene
+to “begin” the animations.
+
+First, it literally *begins* all of the animations by calling their
+setup methods ([`Animation._setup_scene()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation._setup_scene), [`Animation.begin()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.begin)).
+In doing so, the mobjects that are newly introduced by an animation
+(like via [`Create`](../reference/manim.animation.creation.Create.md#manim.animation.creation.Create) etc.) are added to the scene. Furthermore, the
+animation suspends updater functions being called on its mobject, and
+it sets its mobject to the state that corresponds to the first frame
+of the animation.
+
+After this has happened for all animations in the current `play` call,
+the Cairo renderer determines which of the scene’s mobjects can be
+painted statically to the background, and which ones have to be
+redrawn every frame. It does so by calling
+`Scene.get_moving_and_static_mobjects()`, and the resulting
+partition of mobjects is stored in the corresponding `moving_mobjects`
+and `static_mobjects` attributes.
+
+#### NOTE
+The mechanism that determines static and moving mobjects is
+specific for the Cairo renderer, the OpenGL renderer works differently.
+Basically, moving mobjects are determined by checking whether they,
+any of their children, or any of the mobjects “below” them (in the
+sense of the order in which mobjects are processed in the scene)
+either have an update function attached, or whether they appear
+in one of the current animations. See the implementation of
+[`Scene.get_moving_mobjects()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.get_moving_mobjects) for more details.
+
+Up to this very point, we did not actually render any (partial)
+image or movie files from the scene yet. This is, however, about to change.
+Before we enter the render loop, let us briefly revisit our toy
+example and discuss how the generic [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call
+setup looks like there.
+
+For the call that plays the [`ReplacementTransform`](../reference/manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform), there
+is no subcaption to be taken care of. The renderer then asks
+the scene to compile the animation data: the passed argument
+already is an animation (no additional preparations needed),
+there is no need for processing any keyword arguments (as
+we did not specify any additional ones to `play`). The
+mobject bound to the animation, `orange_square`, is already
+part of the scene (so again, no action taken). Finally, the run
+time is extracted (3 seconds long) and stored in
+`Scene.duration`. The renderer then checks whether it should
+skip (it should not), then whether the animation is already
+cached (it is not). The corresponding animation hash value is
+determined and passed to the file writer, which then also calls
+`libav` to start the writing process which waits for rendered
+frames from the library.
+
+The scene then `begin`s the animation: for the
+[`ReplacementTransform`](../reference/manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform) this means that the animation populates
+all of its relevant animation attributes (i.e., compatible copies
+of the starting and the target mobject so that it can safely interpolate
+between the two).
+
+The mechanism determining static and moving mobjects considers
+all of the scenes mobjects (at this point only the
+`orange_square`), and determines that the `orange_square` is
+bound to an animation that is currently played. As a result,
+the square is classified as a “moving mobject”.
+
+Time to render some frames.
+
+### The render loop (for real this time)
+
+As mentioned above, due to the mechanism that determines static and moving
+mobjects in the scene, the renderer knows which mobjects it can paint
+statically to the background of the scene. Practically, this means that
+it partially renders a scene (to produce a background image), and then
+when iterating through the time progression of the animation only the
+“moving mobjects” are re-painted on top of the static background.
+
+The renderer calls `CairoRenderer.save_static_frame_data()`, which
+first checks whether there are currently any static mobjects, and if there
+are, it updates the frame (only with the static mobjects; more about how
+exactly this works in a moment) and then saves a NumPy array representing
+the rendered frame in the `static_image` attribute. In our toy example,
+there are no static mobjects, and so the `static_image` attribute is
+simply set to `None`.
+
+Next, the renderer asks the scene whether the current animation is
+a “frozen frame” animation, which would mean that the renderer actually
+does not have to repaint the moving mobjects in every frame of the time
+progression. It can then just take the latest static frame, and display it
+throughout the animation.
+
+#### NOTE
+An animation is considered a “frozen frame” animation if only a
+static [`Wait`](../reference/manim.animation.animation.Wait.md#manim.animation.animation.Wait) animation is played. See the description
+of [`Scene.compile_animation_data()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.compile_animation_data) above, or the
+implementation of [`Scene.should_update_mobjects()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.should_update_mobjects) for
+more details.
+
+If this is not the case (just as in our toy example), the renderer
+then calls the [`Scene.play_internal()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play_internal) method, which is the
+integral part of the render loop (in which the library steps through
+the time progression of the animation and renders the corresponding
+frames).
+
+Within [`Scene.play_internal()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play_internal), the following steps are performed:
+
+- The scene determines the run time of the animations by calling
+ [`Scene.get_run_time()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.get_run_time). This method basically takes the maximum
+ `run_time` attribute of all of the animations passed to the
+ [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call.
+- Then the *time progression* is constructed via the (internal)
+ [`Scene._get_animation_time_progression()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene._get_animation_time_progression) method, which wraps
+ the actual [`Scene.get_time_progression()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.get_time_progression) method. The time
+ progression is a `tqdm` [progress bar object](https://tqdm.github.io)
+ for an iterator over `np.arange(0, run_time, 1 / config.frame_rate)`. In
+ other words, the time progression holds the time stamps (relative to the
+ current animations, so starting at 0 and ending at the total animation run time,
+ with the step size determined by the render frame rate) of the timeline where
+ a new animation frame should be rendered.
+- Then the scene iterates over the time progression: for each time stamp `t`,
+ `Scene.update_to_time()` is called, which …
+ - … first computes the time passed since the last update (which might be 0,
+ especially for the initial call) and references it as `dt`,
+ - then (in the order in which the animations are passed to [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play))
+ calls [`Animation.update_mobjects()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.update_mobjects) to trigger all updater functions that
+ are attached to the respective animation except for the “main mobject” of
+ the animation (that is, for example, for [`Transform`](../reference/manim.animation.transform.Transform.md#manim.animation.transform.Transform) the unmodified
+ copies of start and target mobject – see [`Animation.get_all_mobjects_to_update()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.get_all_mobjects_to_update)
+ for more details),
+ - then the relative time progression with respect to the current animation
+ is computed (`alpha = t / animation.run_time`), which is then used to
+ update the state of the animation with a call to [`Animation.interpolate()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.interpolate).
+ - After all of the passed animations have been processed, the updater functions
+ of all mobjects in the scene, all meshes, and finally those attached to
+ the scene itself are run.
+
+At this point, the internal (Python) state of all mobjects has been updated
+to match the currently processed timestamp. If rendering should not be skipped,
+then it is now time to *take a picture*!
+
+#### NOTE
+The update of the internal state (iteration over the time progression) happens
+*always* once [`Scene.play_internal()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play_internal) is entered. This ensures that even
+if frames do not need to be rendered (because, e.g., the `-n` CLI flag has
+been passed, something has been cached, or because we might be in a *Section*
+with skipped rendering), updater functions still run correctly, and the state
+of the first frame that *is* rendered is kept consistent.
+
+To render an image, the scene calls the corresponding method of its renderer,
+`CairoRenderer.render()` and passes just the list of *moving mobjects* (remember,
+the *static mobjects* are assumed to have already been painted statically to
+the background of the scene). All of the hard work then happens when the renderer
+updates its current frame via a call to `CairoRenderer.update_frame()`:
+
+First, the renderer prepares its [`Camera`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera) by checking whether the renderer
+has a `static_image` different from `None` stored already. If so, it sets the
+image as the *background image* of the camera via `Camera.set_frame_to_background()`,
+and otherwise it just resets the camera via [`Camera.reset()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.reset). The camera is then
+asked to capture the scene with a call to [`Camera.capture_mobjects()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.capture_mobjects).
+
+Things get a bit technical here, and at some point it is more efficient to
+delve into the implementation – but here is a summary of what happens once the
+camera is asked to capture the scene:
+
+- First, a flat list of mobjects is created (so submobjects get extracted from
+ their parents). This list is then processed in groups of the same type of
+ mobjects (e.g., a batch of vectorized mobjects, followed by a batch of image mobjects,
+ followed by more vectorized mobjects, etc. – in many cases there will just be
+ one batch of vectorized mobjects).
+- Depending on the type of the currently processed batch, the camera uses dedicated
+ *display functions* to convert the [`Mobject`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) Python object to
+ a NumPy array stored in the camera’s `pixel_array` attribute.
+ The most important example in that context is the display function for
+ vectorized mobjects, [`Camera.display_multiple_vectorized_mobjects()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.display_multiple_vectorized_mobjects),
+ or the more particular (in case you did not add a background image to your
+ [`VMobject`](../reference/manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)), [`Camera.display_multiple_non_background_colored_vmobjects()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.display_multiple_non_background_colored_vmobjects).
+ This method first gets the current Cairo context, and then, for every (vectorized)
+ mobject in the batch, calls [`Camera.display_vectorized()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.display_vectorized). There,
+ the actual background stroke, fill, and then stroke of the mobject is
+ drawn onto the context. See [`Camera.apply_stroke()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.apply_stroke) and
+ [`Camera.set_cairo_context_color()`](../reference/manim.camera.camera.Camera.md#manim.camera.camera.Camera.set_cairo_context_color) for more details – but it does not get
+ much deeper than that, in the latter method the actual Bézier curves
+ determined by the points of the mobject are drawn; this is where the low-level
+ interaction with Cairo happens.
+
+After all batches have been processed, the camera has an image representation
+of the Scene at the current time stamp in form of a NumPy array stored in its
+`pixel_array` attribute. The renderer then takes this array and passes it to
+its [`SceneFileWriter`](../reference/manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter). This concludes one iteration of the render loop,
+and once the time progression has been processed completely, a final bit
+of cleanup is performed before the [`Scene.play_internal()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play_internal) call is completed.
+
+A TL;DR for the render loop, in the context of our toy example, reads as follows:
+
+- The scene finds that a 3 second long animation (the [`ReplacementTransform`](../reference/manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform)
+ changing the orange square to the blue circle) should be played. Given the requested
+ medium render quality, the frame rate is 30 frames per second, and so the time
+ progression with steps `[0, 1/30, 2/30, ..., 89/30]` is created.
+- In the internal render loop, each of these time stamps is processed:
+ there are no updater functions, so effectively the scene updates the
+ state of the transformation animation to the desired time stamp (for example,
+ at time stamp `t = 45/30`, the animation is completed to a rate of
+ `alpha = 0.5`).
+- Then the scene asks the renderer to do its job. The renderer asks its camera
+ to capture the scene, the only mobject that needs to be processed at this point
+ is the main mobject attached to the transformation; the camera converts the
+ current state of the mobject to entries in a NumPy array. The renderer passes
+ this array to the file writer.
+- At the end of the loop, 90 frames have been passed to the file writer.
+
+### Completing the render loop
+
+The last few steps in the [`Scene.play_internal()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play_internal) call are not too
+exciting: for every animation, the corresponding [`Animation.finish()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.finish)
+and [`Animation.clean_up_from_scene()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.clean_up_from_scene) methods are called.
+
+#### NOTE
+Note that as part of [`Animation.finish()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.finish), the [`Animation.interpolate()`](../reference/manim.animation.animation.Animation.md#manim.animation.animation.Animation.interpolate)
+method is called with an argument of 1.0 – you might have noticed already that
+the last frame of an animation can sometimes be a bit off or incomplete.
+This is by current design! The last frame rendered in the render loop (and displayed
+for a duration of `1 / frame_rate` seconds in the rendered video) corresponds to
+the state of the animation `1 / frame_rate` seconds before it ends. To display
+the final frame as well in the video, we would need to append another `1 / frame_rate`
+seconds to the video – which would then mean that a 1 second rendered Manim video
+would be slightly longer than 1 second. We decided against this at some point.
+
+In the end, the time progression is closed (which completes the displayed progress bar)
+in the terminal. With the closing of the time progression, the
+[`Scene.play_internal()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play_internal) call is completed, and we return to the renderer,
+which now orders the [`SceneFileWriter`](../reference/manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter) to close the output container that has
+been opened for this animation: a partial movie file is written.
+
+This pretty much concludes the walkthrough of a `Scene.play` call,
+and actually there is not too much more to say for our toy example either: at
+this point, a partial movie file that represents playing the
+[`ReplacementTransform`](../reference/manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform) has been written. The initialization of
+the [`Dot`](../reference/manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) happens analogous to the initialization of `blue_circle`,
+which has been discussed above. The [`Mobject.add_updater()`](../reference/manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.add_updater) call literally
+just attaches a function to the `updaters` attribute of the `small_dot`. And
+the remaining [`Scene.play()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) and [`Scene.wait()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.wait) calls follow the
+exact same procedure as discussed in the render loop section above; each such call
+produces a corresponding partial movie file.
+
+Once the [`Scene.construct()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.construct) method has been fully processed (and thus all
+of the corresponding partial movie files have been written), the
+scene calls its cleanup method [`Scene.tear_down()`](../reference/manim.scene.scene.Scene.md#manim.scene.scene.Scene.tear_down), and then
+asks its renderer to finish the scene. The renderer, in turn, asks
+its scene file writer to wrap things up by calling [`SceneFileWriter.finish()`](../reference/manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter.finish),
+which triggers the combination of the partial movie files into the final product.
+
+And there you go! This is a more or less detailed description of how Manim works
+under the hood. While we did not discuss every single line of code in detail
+in this walkthrough, it should still give you a fairly good idea of how the general
+structural design of the library and at least the Cairo rendering flow in particular
+looks like.
diff --git a/data/rag/manim_docs/manim_core/docs/guides/using_text.md b/data/rag/manim_docs/manim_core/docs/guides/using_text.md
new file mode 100644
index 0000000000000000000000000000000000000000..1082a950904877352acf9f61db34b403ccf6096c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/guides/using_text.md
@@ -0,0 +1,826 @@
+# Rendering Text and Formulas
+
+There are two different ways by which you can render **Text** in videos:
+
+1. Using Pango ([`text_mobject`](../reference/manim.mobject.text.text_mobject.md#module-manim.mobject.text.text_mobject))
+2. Using LaTeX ([`tex_mobject`](../reference/manim.mobject.text.tex_mobject.md#module-manim.mobject.text.tex_mobject))
+
+If you want to render simple text, you should use either [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) or
+[`MarkupText`](../reference/manim.mobject.text.text_mobject.MarkupText.md#manim.mobject.text.text_mobject.MarkupText), or one of its derivatives like [`Paragraph`](../reference/manim.mobject.text.text_mobject.Paragraph.md#manim.mobject.text.text_mobject.Paragraph).
+See [Text Without LaTeX](#using-text-objects) for more information.
+
+LaTeX should be used when you need mathematical typesetting. See
+[Text With LaTeX](#rendering-with-latex) for more information.
+
+
+
+## Text Without LaTeX
+
+The simplest way to add text to your animations is to use the [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text)
+class. It uses the [Pango library](https://pango.gnome.org) to render text. With Pango, you can also
+render non-English alphabets like 你好 or こんにちは or 안녕하세요 or
+مرحبا بالعالم.
+
+Here is a simple *Hello World* animation.
+
+
+
+You can also use [`MarkupText`](../reference/manim.mobject.text.text_mobject.MarkupText.md#manim.mobject.text.text_mobject.MarkupText) which allows the use of PangoMarkup
+(see the documentation of [`MarkupText`](../reference/manim.mobject.text.text_mobject.MarkupText.md#manim.mobject.text.text_mobject.MarkupText) for details) to render text.
+For example:
+
+
+
+### Working with [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text)
+
+This section explains the properties of [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) and how can it be used
+in your animations.
+
+#### Using Fonts
+
+You can set a different font using `font`.
+
+#### NOTE
+The font used must be installed in your system, and Pango should know
+about it. You can get a list of fonts using `manimpango.list_fonts()`.
+
+```pycon
+>>> import manimpango
+>>> manimpango.list_fonts()
+[...]
+```
+
+
+
+#### Setting Slant and Weight
+
+Slant is the style of the Text, and it can be `NORMAL` (the default),
+`ITALIC` or `OBLIQUE`. Usually, for many fonts both `ITALIC` and
+`OBLIQUE` look similar, but `ITALIC` uses **Roman Style**, whereas
+`OBLIQUE` uses **Italic Style**.
+
+Weight specifies the boldness of a font. You can see a list of weights in
+`manimpango.Weight`.
+
+
+
+You can use utilities like `t2c` for coloring specific characters.
+This may be problematic if your text contains ligatures
+as explained in [Iterating Text](#iterating-text).
+
+`t2c` accepts two types of dictionaries,
+
+* The keys can contain indices like `[2:-1]` or `[4:8]`,
+ this works similar to how [slicing](https://realpython.com/python-strings/#string-slicing)
+ works in Python. The values should be the color of the Text from `Color`.
+* The keys contain words or characters which should be colored separately
+ and the values should be the color from `Color`:
+
+
+
+If you want to avoid problems when using colors (due to ligatures), consider using
+`MarkupText`.
+
+#### Using Gradients
+
+You can add a gradient using `gradient`. The value must
+be an iterable of any length:
+
+
+
+You can also use `t2g` for gradients with specific
+characters of the text. It shares a similar syntax to [the
+interface for colors](#using-colors):
+
+
+class LineSpacing(Scene):
+ def construct(self):
+ a = Text("Hello\\nWorld", line_spacing=1)
+ b = Text("Hello\\nWorld", line_spacing=4)
+ self.add(Group(a,b).arrange(LEFT, buff=5))
+
+
+
+
+
+#### Disabling Ligatures
+
+By disabling ligatures you would get a one-to-one mapping between characters and
+submobjects. This fixes the issues with coloring text.
+
+#### WARNING
+Be aware that using this method with text that heavily depends on
+ligatures (Arabic text) may yield unexpected results.
+
+You can disable ligatures by passing `disable_ligatures` to
+`Text`. For example:
+
+
+
+
+
+#### Iterating [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text)
+
+Text objects behave like [`VGroups`](../reference/manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup). Therefore, you can slice and index
+the text.
+
+For example, you can set each letter to different color by iterating it.
+
+
+```python
+from manim import *
+
+class IterateColor(Scene):
+ def construct(self):
+ text = Text("Colors", font_size=96)
+ for letter in text:
+ letter.set_color(random_bright_color())
+ self.add(text)
+```
+
+
+class IterateColor(Scene):
+ def construct(self):
+ text = Text("Colors", font_size=96)
+ for letter in text:
+ letter.set_color(random_bright_color())
+ self.add(text)
+
+
+
+#### WARNING
+Please note that [Ligature](https://en.wikipedia.org/wiki/Ligature_(writing)) can cause problems here. If you need a
+one-to-one mapping of characters to submobjects you should pass
+the `disable_ligatures` parameter to [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text).
+See [Disabling Ligatures](#disable-ligatures).
+
+### Working with [`MarkupText`](../reference/manim.mobject.text.text_mobject.MarkupText.md#manim.mobject.text.text_mobject.MarkupText)
+
+MarkupText is similar to [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text), the only difference between them is
+that this accepts and processes PangoMarkup (which is similar to
+html), instead of just rendering plain text.
+
+Consult the documentation of [`MarkupText`](../reference/manim.mobject.text.text_mobject.MarkupText.md#manim.mobject.text.text_mobject.MarkupText) for more details
+and further references about PangoMarkup.
+
+
+```python
+from manim import *
+
+class MarkupTest(Scene):
+ def construct(self):
+ text = MarkupText(
+ f'double green underline in red text except this',
+ color=RED,
+ font_size=34
+ )
+ self.add(text)
+```
+
+
+class MarkupTest(Scene):
+ def construct(self):
+ text = MarkupText(
+ f'double green underline in red text except this',
+ color=RED,
+ font_size=34
+ )
+ self.add(text)
+
+
+
+
+
+## Text With LaTeX
+
+Just as you can use [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) to add text to your videos, you can
+use [`Tex`](../reference/manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) to insert LaTeX.
+
+For example,
+
+
+
+#### NOTE
+Note that we are using a raw string (`r'...'`) instead of a regular string (`'...'`).
+This is because TeX code uses a lot of special characters - like `\` for example - that
+have special meaning within a regular python string. An alternative would have been to
+write `\\` to escape the backslash: `Tex('\\LaTeX')`.
+
+### Working with [`MathTex`](../reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex)
+
+Everything passed to [`MathTex`](../reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) is in math mode by default. To be more precise,
+[`MathTex`](../reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) is processed within an `align*` environment. You can achieve a
+similar effect with [`Tex`](../reference/manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) by enclosing your formula with `$` symbols:
+`$\xrightarrow{x^6y^8}$`:
+
+
+
+### LaTeX commands and keyword arguments
+
+We can use any standard LaTeX commands in the AMS maths packages. Such
+as the `mathtt` math-text type or the `looparrowright` arrow.
+
+
+
+On the Manim side, the [`Tex`](../reference/manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) class also accepts attributes to
+change the appearance of the output. This is very similar to the
+[`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) class. For example, the `color` keyword changes the
+color of the TeX mobject.
+
+
+
+### Extra LaTeX Packages
+
+Some commands require special packages to be loaded into the TeX template.
+For example, to use the `mathscr` script, we need to add the `mathrsfs`
+package. Since this package isn’t loaded into Manim’s tex template by default,
+we have to add it manually.
+
+
+
+### Substrings and parts
+
+The TeX mobject can accept multiple strings as arguments. Afterwards you can
+refer to the individual parts either by their index (like `tex[1]`), or by
+selecting parts of the tex code. In this example, we set the color
+of the `\bigstar` using `set_color_by_tex()`:
+
+
+
+Note that `set_color_by_tex()` colors the entire substring containing
+the Tex, not just the specific symbol or Tex expression. Consider the following example:
+
+
+
+As you can see, this colors the entire equation yellow, contrary to what
+may be expected. To color only `x` yellow, we have to do the following:
+
+
+
+By setting `substrings_to_isolate` to `x`, we split up the
+[`MathTex`](../reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) into substrings automatically and isolate the `x` components
+into individual substrings. Only then can `set_color_by_tex()` be used
+to achieve the desired result.
+
+Note that Manim also supports a custom syntax that allows splitting
+a TeX string into substrings easily: simply enclose parts of your formula
+that you want to isolate with double braces. In the string
+`MathTex(r"{{ a^2 }} + {{ b^2 }} = {{ c^2 }}")`, the rendered mobject
+will consist of the substrings `a^2`, `+`, `b^2`, `=`, and `c^2`.
+This makes transformations between similar text fragments easy
+to write using [`TransformMatchingTex`](../reference/manim.animation.transform_matching_parts.TransformMatchingTex.md#manim.animation.transform_matching_parts.TransformMatchingTex).
+
+### Using `index_labels` to work with complicated strings
+
+You might sometimes be working with a very complicated [`MathTex`](../reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) mobject
+that makes it difficult to work with its individual components. This is
+where the debugging function [`index_labels()`](../reference/manim.utils.debug.md#manim.utils.debug.index_labels) is very useful.
+
+The method shows the index of a mobject’s submobjects, allowing you
+to easily find the components of the mobject you would like to change.
+
+
+```python
+from manim import *
+
+class IndexLabelsMathTex(Scene):
+ def construct(self):
+ text = MathTex(r"\binom{2n}{n+2}", font_size=96)
+
+ # index the first (and only) term of the MathTex mob
+ self.add(index_labels(text[0]))
+
+ text[0][1:3].set_color(YELLOW)
+ text[0][3:6].set_color(RED)
+ self.add(text)
+```
+
+
+class IndexLabelsMathTex(Scene):
+ def construct(self):
+ text = MathTex(r"\\binom{2n}{n+2}", font_size=96)
+
+ # index the first (and only) term of the MathTex mob
+ self.add(index_labels(text[0]))
+
+ text[0][1:3].set_color(YELLOW)
+ text[0][3:6].set_color(RED)
+ self.add(text)
+
+
+
+### LaTeX Maths Fonts - The Template Library
+
+Changing fonts in LaTeX when typesetting mathematical formulae is
+trickier than regular text. It requires changing the template that is used
+to compile the TeX. Manim comes with a collection of [`TexFontTemplates`](../reference/manim.utils.tex_templates.TexFontTemplates.md#manim.utils.tex_templates.TexFontTemplates)
+ready for you to use. These templates will all work in math mode:
+
+
+
+Manim also has a [`TexTemplateLibrary`](../reference/manim.utils.tex_templates.TexTemplateLibrary.md#manim.utils.tex_templates.TexTemplateLibrary) containing the TeX
+templates used by 3Blue1Brown. One example is the ctex template,
+used for typesetting Chinese script. For this to work, the ctex LaTeX package
+must be installed on your system. Furthermore, if you are only
+typesetting Text, you probably do not need [`Tex`](../reference/manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) at all, and
+should use [`Text`](../reference/manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) instead.
+
+
+
+### Aligning formulae
+
+[`MathTex`](../reference/manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) mobject is typeset in the LaTeX `align*`
+environment. This means you can use the `&` alignment character
+when typesetting multiline formulae:
+
+
diff --git a/data/rag/manim_docs/manim_core/docs/reference/.DS_Store b/data/rag/manim_docs/manim_core/docs/reference/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6
Binary files /dev/null and b/data/rag/manim_docs/manim_core/docs/reference/.DS_Store differ
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim._config.logger_utils.JSONFormatter.md b/data/rag/manim_docs/manim_core/docs/reference/manim._config.logger_utils.JSONFormatter.md
new file mode 100644
index 0000000000000000000000000000000000000000..844cf60e065e45af41770dd6f59fd00174c970ee
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim._config.logger_utils.JSONFormatter.md
@@ -0,0 +1,45 @@
+# JSONFormatter
+
+Qualified name: `manim.\_config.logger\_utils.JSONFormatter`
+
+### *class* JSONFormatter(fmt=None, datefmt=None, style='%', validate=True, \*, defaults=None)
+
+Bases: `Formatter`
+
+A formatter that outputs logs in a custom JSON format.
+
+This class is used internally for testing purposes.
+
+Initialize the formatter with specified format strings.
+
+Initialize the formatter either with the specified format string, or a
+default as described above. Allow for specialized date formatting with
+the optional datefmt argument. If datefmt is omitted, you get an
+ISO8601-like (or RFC 3339-like) format.
+
+Use a style parameter of ‘%’, ‘{’ or ‘$’ to specify that you want to
+use one of %-formatting, `str.format()` (`{}`) formatting or
+`string.Template` formatting in your format string.
+
+#### Versionchanged
+Changed in version 3.2: Added the `style` parameter.
+
+### Methods
+
+| [`format`](#manim._config.logger_utils.JSONFormatter.format) | Format the record in a custom JSON format. |
+|----------------------------------------------------------------|----------------------------------------------|
+
+### Attributes
+
+| `default_msec_format` | |
+|-------------------------|----|
+| `default_time_format` | |
+
+#### format(record)
+
+Format the record in a custom JSON format.
+
+* **Parameters:**
+ **record** (*LogRecord*)
+* **Return type:**
+ str
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim._config.logger_utils.md b/data/rag/manim_docs/manim_core/docs/reference/manim._config.logger_utils.md
new file mode 100644
index 0000000000000000000000000000000000000000..bdc585edfd175130d6707d53a80208becf1b7266
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim._config.logger_utils.md
@@ -0,0 +1,67 @@
+# logger_utils
+
+Utilities to create and set the logger.
+
+Manim’s logger can be accessed as `manim.logger`, or as
+`logging.getLogger("manim")`, once the library has been imported. Manim also
+exports a second object, `console`, which should be used to print on screen
+messages that need not be logged.
+
+Both `logger` and `console` use the `rich` library to produce rich text
+format.
+
+### Classes
+
+| [`JSONFormatter`](manim._config.logger_utils.JSONFormatter.md#manim._config.logger_utils.JSONFormatter) | A formatter that outputs logs in a custom JSON format. |
+|-----------------------------------------------------------------------------------------------------------|----------------------------------------------------------|
+
+### Functions
+
+### make_logger(parser, verbosity)
+
+Make the manim logger and console.
+
+* **Parameters:**
+ * **parser** (*SectionProxy*) – A parser containing any .cfg files in use.
+ * **verbosity** (*str*) – The verbosity level of the logger.
+* **Returns:**
+ The manim logger and consoles. The first console outputs
+ to stdout, the second to stderr. All use the theme returned by
+ [`parse_theme()`](#manim._config.logger_utils.parse_theme).
+* **Return type:**
+ `logging.Logger`, `rich.Console`, `rich.Console`
+
+#### SEE ALSO
+[`make_config_parser()`](manim._config.utils.md#manim._config.utils.make_config_parser), [`parse_theme()`](#manim._config.logger_utils.parse_theme)
+
+### Notes
+
+The `parser` is assumed to contain only the options related to
+configuring the logger at the top level.
+
+### parse_theme(parser)
+
+Configure the rich style of logger and console output.
+
+* **Parameters:**
+ **parser** (*SectionProxy*) – A parser containing any .cfg files in use.
+* **Returns:**
+ The rich theme to be used by the manim logger.
+* **Return type:**
+ `rich.Theme`
+
+#### SEE ALSO
+[`make_logger()`](#manim._config.logger_utils.make_logger)
+
+### set_file_logger(scene_name, module_name, log_dir)
+
+Add a file handler to manim logger.
+
+The path to the file is built using `config.log_dir`.
+
+* **Parameters:**
+ * **scene_name** (*str*) – The name of the scene, used in the name of the log file.
+ * **module_name** (*str*) – The name of the module, used in the name of the log file.
+ * **log_dir** (*Path*) – Path to the folder where log files are stored.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim._config.md b/data/rag/manim_docs/manim_core/docs/reference/manim._config.md
new file mode 100644
index 0000000000000000000000000000000000000000..eb905d953b9a1c2439f871ed6e6f0dab3b8733d5
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim._config.md
@@ -0,0 +1,33 @@
+# \_config
+
+Set the global config and logger.
+
+### Functions
+
+### tempconfig(temp)
+
+Context manager that temporarily modifies the global `config` object.
+
+Inside the `with` statement, the modified config will be used. After
+context manager exits, the config will be restored to its original state.
+
+* **Parameters:**
+ **temp** ([*ManimConfig*](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig) *|* *dict* *[**str* *,* *Any* *]*) – Object whose keys will be used to temporarily update the global
+ `config`.
+* **Return type:**
+ *Generator*[None, None, None]
+
+### Examples
+
+Use `with tempconfig({...})` to temporarily change the default values of
+certain config options.
+
+```pycon
+>>> config["frame_height"]
+8.0
+>>> with tempconfig({"frame_height": 100.0}):
+... print(config["frame_height"])
+100.0
+>>> config["frame_height"]
+8.0
+```
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim._config.utils.ManimConfig.md b/data/rag/manim_docs/manim_core/docs/reference/manim._config.utils.ManimConfig.md
new file mode 100644
index 0000000000000000000000000000000000000000..65a582c1c0148a3e22ff489ec2e7df153864ea4b
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim._config.utils.ManimConfig.md
@@ -0,0 +1,838 @@
+# ManimConfig
+
+Qualified name: `manim.\_config.utils.ManimConfig`
+
+### *class* ManimConfig
+
+Bases: `MutableMapping`
+
+Dict-like class storing all config options.
+
+The global `config` object is an instance of this class, and acts as a
+single source of truth for all of the library’s customizable behavior.
+
+The global `config` object is capable of digesting different types of
+sources and converting them into a uniform interface. These sources are
+(in ascending order of precedence): configuration files, command line
+arguments, and programmatic changes. Regardless of how the user chooses to
+set a config option, she can access its current value using
+[`ManimConfig`](#manim._config.utils.ManimConfig)’s attributes and properties.
+
+### Notes
+
+Each config option is implemented as a property of this class.
+
+Each config option can be set via a config file, using the full name of the
+property. If a config option has an associated CLI flag, then the flag is
+equal to the full name of the property. Those that admit an alternative
+flag or no flag at all are documented in the individual property’s
+docstring.
+
+### Examples
+
+We use a copy of the global configuration object in the following
+examples for the sake of demonstration; you can skip these lines
+and just import `config` directly if you actually want to modify
+the configuration:
+
+```pycon
+>>> from manim import config as global_config
+>>> config = global_config.copy()
+```
+
+Each config option allows for dict syntax and attribute syntax. For
+example, the following two lines are equivalent,
+
+```pycon
+>>> from manim import WHITE
+>>> config.background_color = WHITE
+>>> config["background_color"] = WHITE
+```
+
+The former is preferred; the latter is provided mostly for backwards
+compatibility.
+
+The config options are designed to keep internal consistency. For example,
+setting `frame_y_radius` will affect `frame_height`:
+
+```pycon
+>>> config.frame_height
+8.0
+>>> config.frame_y_radius = 5.0
+>>> config.frame_height
+10.0
+```
+
+There are many ways of interacting with config options. Take for example
+the config option `background_color`. There are three ways to change it:
+via a config file, via CLI flags, or programmatically.
+
+To set the background color via a config file, save the following
+`manim.cfg` file with the following contents.
+
+```default
+[CLI]
+background_color = WHITE
+```
+
+In order to have this `.cfg` file apply to a manim scene, it needs to be
+placed in the same directory as the script,
+
+```bash
+project/
+├─scene.py
+└─manim.cfg
+```
+
+Now, when the user executes
+
+```bash
+manim scene.py
+```
+
+the background of the scene will be set to `WHITE`. This applies regardless
+of where the manim command is invoked from.
+
+Command line arguments override `.cfg` files. In the previous example,
+executing
+
+```bash
+manim scene.py -c BLUE
+```
+
+will set the background color to BLUE, regardless of the contents of
+`manim.cfg`.
+
+Finally, any programmatic changes made within the scene script itself will
+override the command line arguments. For example, if `scene.py` contains
+the following
+
+```python
+from manim import *
+
+config.background_color = RED
+
+class MyScene(Scene): ...
+```
+
+the background color will be set to RED, regardless of the contents of
+`manim.cfg` or the CLI arguments used when invoking manim.
+
+### Methods
+
+| [`copy`](#manim._config.utils.ManimConfig.copy) | Deepcopy the contents of this ManimConfig. |
+|-------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------|
+| [`digest_args`](#manim._config.utils.ManimConfig.digest_args) | Process the config options present in CLI arguments. |
+| [`digest_file`](#manim._config.utils.ManimConfig.digest_file) | Process the config options present in a `.cfg` file. |
+| [`digest_parser`](#manim._config.utils.ManimConfig.digest_parser) | Process the config options present in a `ConfigParser` object. |
+| [`get_dir`](#manim._config.utils.ManimConfig.get_dir) | Resolve a config option that stores a directory. |
+| `resolve_movie_file_extension` | |
+| [`update`](#manim._config.utils.ManimConfig.update) | Digest the options found in another [`ManimConfig`](#manim._config.utils.ManimConfig) or in a dict. |
+
+### Attributes
+
+| [`aspect_ratio`](#manim._config.utils.ManimConfig.aspect_ratio) | Aspect ratio (width / height) in pixels (--resolution, -r). |
+|---------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
+| [`assets_dir`](#manim._config.utils.ManimConfig.assets_dir) | Directory to locate video assets (no flag). |
+| [`background_color`](#manim._config.utils.ManimConfig.background_color) | Background color of the scene (-c). |
+| [`background_opacity`](#manim._config.utils.ManimConfig.background_opacity) | A number between 0.0 (fully transparent) and 1.0 (fully opaque). |
+| [`bottom`](#manim._config.utils.ManimConfig.bottom) | Coordinate at the center bottom of the frame. |
+| [`custom_folders`](#manim._config.utils.ManimConfig.custom_folders) | Whether to use custom folder output. |
+| [`disable_caching`](#manim._config.utils.ManimConfig.disable_caching) | Whether to use scene caching. |
+| [`disable_caching_warning`](#manim._config.utils.ManimConfig.disable_caching_warning) | Whether a warning is raised if there are too much submobjects to hash. |
+| [`dry_run`](#manim._config.utils.ManimConfig.dry_run) | Whether dry run is enabled. |
+| [`enable_gui`](#manim._config.utils.ManimConfig.enable_gui) | Enable GUI interaction. |
+| [`enable_wireframe`](#manim._config.utils.ManimConfig.enable_wireframe) | Whether to enable wireframe debugging mode in opengl. |
+| [`ffmpeg_loglevel`](#manim._config.utils.ManimConfig.ffmpeg_loglevel) | Verbosity level of ffmpeg (no flag). |
+| [`flush_cache`](#manim._config.utils.ManimConfig.flush_cache) | Whether to delete all the cached partial movie files. |
+| [`force_window`](#manim._config.utils.ManimConfig.force_window) | Whether to force window when using the opengl renderer. |
+| [`format`](#manim._config.utils.ManimConfig.format) | File format; "png", "gif", "mp4", "webm" or "mov". |
+| [`frame_height`](#manim._config.utils.ManimConfig.frame_height) | Frame height in logical units (no flag). |
+| [`frame_rate`](#manim._config.utils.ManimConfig.frame_rate) | Frame rate in frames per second. |
+| [`frame_size`](#manim._config.utils.ManimConfig.frame_size) | Tuple with (pixel width, pixel height) (no flag). |
+| [`frame_width`](#manim._config.utils.ManimConfig.frame_width) | Frame width in logical units (no flag). |
+| [`frame_x_radius`](#manim._config.utils.ManimConfig.frame_x_radius) | Half the frame width (no flag). |
+| [`frame_y_radius`](#manim._config.utils.ManimConfig.frame_y_radius) | Half the frame height (no flag). |
+| [`from_animation_number`](#manim._config.utils.ManimConfig.from_animation_number) | Start rendering animations at this number (-n). |
+| [`fullscreen`](#manim._config.utils.ManimConfig.fullscreen) | Expand the window to its maximum possible size. |
+| [`gui_location`](#manim._config.utils.ManimConfig.gui_location) | Enable GUI interaction. |
+| [`images_dir`](#manim._config.utils.ManimConfig.images_dir) | Directory to place images (no flag). |
+| [`input_file`](#manim._config.utils.ManimConfig.input_file) | Input file name. |
+| [`left_side`](#manim._config.utils.ManimConfig.left_side) | Coordinate at the middle left of the frame. |
+| [`log_dir`](#manim._config.utils.ManimConfig.log_dir) | Directory to place logs. |
+| [`log_to_file`](#manim._config.utils.ManimConfig.log_to_file) | Whether to save logs to a file. |
+| [`max_files_cached`](#manim._config.utils.ManimConfig.max_files_cached) | Maximum number of files cached. |
+| [`media_dir`](#manim._config.utils.ManimConfig.media_dir) | Main output directory. |
+| [`media_embed`](#manim._config.utils.ManimConfig.media_embed) | Whether to embed videos in Jupyter notebook. |
+| [`media_width`](#manim._config.utils.ManimConfig.media_width) | Media width in Jupyter notebook. |
+| [`movie_file_extension`](#manim._config.utils.ManimConfig.movie_file_extension) | Either .mp4, .webm or .mov. |
+| [`no_latex_cleanup`](#manim._config.utils.ManimConfig.no_latex_cleanup) | Prevents deletion of .aux, .dvi, and .log files produced by Tex and MathTex. |
+| [`notify_outdated_version`](#manim._config.utils.ManimConfig.notify_outdated_version) | Whether to notify if there is a version update available. |
+| [`output_file`](#manim._config.utils.ManimConfig.output_file) | Output file name (-o). |
+| [`partial_movie_dir`](#manim._config.utils.ManimConfig.partial_movie_dir) | Directory to place partial movie files (no flag). |
+| [`pixel_height`](#manim._config.utils.ManimConfig.pixel_height) | Frame height in pixels (--resolution, -r). |
+| [`pixel_width`](#manim._config.utils.ManimConfig.pixel_width) | Frame width in pixels (--resolution, -r). |
+| [`plugins`](#manim._config.utils.ManimConfig.plugins) | List of plugins to enable. |
+| [`preview`](#manim._config.utils.ManimConfig.preview) | Whether to play the rendered movie (-p). |
+| `preview_command` | |
+| [`progress_bar`](#manim._config.utils.ManimConfig.progress_bar) | Whether to show progress bars while rendering animations. |
+| [`quality`](#manim._config.utils.ManimConfig.quality) | Video quality (-q). |
+| [`renderer`](#manim._config.utils.ManimConfig.renderer) | The currently active renderer. |
+| [`right_side`](#manim._config.utils.ManimConfig.right_side) | Coordinate at the middle right of the frame. |
+| [`save_as_gif`](#manim._config.utils.ManimConfig.save_as_gif) | Whether to save the rendered scene in .gif format (-i). |
+| [`save_last_frame`](#manim._config.utils.ManimConfig.save_last_frame) | Whether to save the last frame of the scene as an image file (-s). |
+| [`save_pngs`](#manim._config.utils.ManimConfig.save_pngs) | Whether to save all frames in the scene as images files (-g). |
+| [`save_sections`](#manim._config.utils.ManimConfig.save_sections) | Whether to save single videos for each section in addition to the movie file. |
+| [`scene_names`](#manim._config.utils.ManimConfig.scene_names) | Scenes to play from file. |
+| [`sections_dir`](#manim._config.utils.ManimConfig.sections_dir) | Directory to place section videos (no flag). |
+| [`show_in_file_browser`](#manim._config.utils.ManimConfig.show_in_file_browser) | Whether to show the output file in the file browser (-f). |
+| [`tex_dir`](#manim._config.utils.ManimConfig.tex_dir) | Directory to place tex (no flag). |
+| [`tex_template`](#manim._config.utils.ManimConfig.tex_template) | Template used when rendering Tex. |
+| [`tex_template_file`](#manim._config.utils.ManimConfig.tex_template_file) | File to read Tex template from (no flag). |
+| [`text_dir`](#manim._config.utils.ManimConfig.text_dir) | Directory to place text (no flag). |
+| [`top`](#manim._config.utils.ManimConfig.top) | Coordinate at the center top of the frame. |
+| [`transparent`](#manim._config.utils.ManimConfig.transparent) | Whether the background opacity is less than 1.0 (-t). |
+| [`upto_animation_number`](#manim._config.utils.ManimConfig.upto_animation_number) | Stop rendering animations at this number. |
+| [`use_projection_fill_shaders`](#manim._config.utils.ManimConfig.use_projection_fill_shaders) | Use shaders for OpenGLVMobject fill which are compatible with transformation matrices. |
+| [`use_projection_stroke_shaders`](#manim._config.utils.ManimConfig.use_projection_stroke_shaders) | Use shaders for OpenGLVMobject stroke which are compatible with transformation matrices. |
+| [`verbosity`](#manim._config.utils.ManimConfig.verbosity) | Logger verbosity; "DEBUG", "INFO", "WARNING", "ERROR", or "CRITICAL" (-v). |
+| [`video_dir`](#manim._config.utils.ManimConfig.video_dir) | Directory to place videos (no flag). |
+| [`window_monitor`](#manim._config.utils.ManimConfig.window_monitor) | The monitor on which the scene will be rendered. |
+| [`window_position`](#manim._config.utils.ManimConfig.window_position) | Set the position of preview window. |
+| [`window_size`](#manim._config.utils.ManimConfig.window_size) | The size of the opengl window. |
+| [`write_all`](#manim._config.utils.ManimConfig.write_all) | Whether to render all scenes in the input file (-a). |
+| [`write_to_movie`](#manim._config.utils.ManimConfig.write_to_movie) | Whether to render the scene to a movie file (-w). |
+| [`zero_pad`](#manim._config.utils.ManimConfig.zero_pad) | PNG zero padding. |
+
+#### \_set_between(key, val, lo, hi)
+
+Set `key` to `val` if lo <= val <= hi.
+
+* **Parameters:**
+ * **key** (*str*)
+ * **val** (*float*)
+ * **lo** (*float*)
+ * **hi** (*float*)
+* **Return type:**
+ None
+
+#### \_set_boolean(key, val)
+
+Set `key` to `val` if `val` is Boolean.
+
+* **Parameters:**
+ * **key** (*str*)
+ * **val** (*Any*)
+* **Return type:**
+ None
+
+#### \_set_from_enum(key, enum_value, enum_class)
+
+Set `key` to the enum object with value `enum_value` in the given
+`enum_class`.
+
+Tests:
+
+```default
+>>> from enum import Enum
+>>> class Fruit(Enum):
+... APPLE = 1
+... BANANA = 2
+... CANTALOUPE = 3
+>>> test_config = ManimConfig()
+>>> test_config._set_from_enum("fruit", 1, Fruit)
+>>> test_config._d['fruit']
+
+>>> test_config._set_from_enum("fruit", Fruit.BANANA, Fruit)
+>>> test_config._d['fruit']
+
+>>> test_config._set_from_enum("fruit", 42, Fruit)
+Traceback (most recent call last):
+...
+ValueError: 42 is not a valid Fruit
+```
+
+* **Parameters:**
+ * **key** (*str*)
+ * **enum_value** (*Any*)
+ * **enum_class** (*EnumMeta*)
+* **Return type:**
+ None
+
+#### \_set_from_list(key, val, values)
+
+Set `key` to `val` if `val` is contained in `values`.
+
+* **Parameters:**
+ * **key** (*str*)
+ * **val** (*Any*)
+ * **values** (*list* *[**Any* *]*)
+* **Return type:**
+ None
+
+#### \_set_int_between(key, val, lo, hi)
+
+Set `key` to `val` if lo <= val <= hi.
+
+* **Parameters:**
+ * **key** (*str*)
+ * **val** (*int*)
+ * **lo** (*int*)
+ * **hi** (*int*)
+* **Return type:**
+ None
+
+#### \_set_pos_number(key, val, allow_inf)
+
+Set `key` to `val` if `val` is a positive integer.
+
+* **Parameters:**
+ * **key** (*str*)
+ * **val** (*int*)
+ * **allow_inf** (*bool*)
+* **Return type:**
+ None
+
+#### \_set_str(key, val)
+
+Set `key` to `val` if `val` is a string.
+
+* **Parameters:**
+ * **key** (*str*)
+ * **val** (*Any*)
+* **Return type:**
+ None
+
+#### *property* aspect_ratio *: int*
+
+Aspect ratio (width / height) in pixels (–resolution, -r).
+
+#### *property* assets_dir *: str*
+
+Directory to locate video assets (no flag).
+
+#### *property* background_color *: [ManimColor](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)*
+
+Background color of the scene (-c).
+
+#### *property* background_opacity *: float*
+
+A number between 0.0 (fully transparent) and 1.0 (fully opaque).
+
+#### *property* bottom *: [Vector3D](manim.typing.md#manim.typing.Vector3D)*
+
+Coordinate at the center bottom of the frame.
+
+#### copy()
+
+Deepcopy the contents of this ManimConfig.
+
+* **Returns:**
+ A copy of this object containing no shared references.
+* **Return type:**
+ [`ManimConfig`](#manim._config.utils.ManimConfig)
+
+#### SEE ALSO
+`tempconfig()`
+
+### Notes
+
+This is the main mechanism behind `tempconfig()`.
+
+#### *property* custom_folders *: str*
+
+Whether to use custom folder output.
+
+#### digest_args(args)
+
+Process the config options present in CLI arguments.
+
+* **Parameters:**
+ **args** (*argparse.Namespace*) – An object returned by `main_utils.parse_args()`.
+* **Returns:**
+ **self** – This object, after processing the contents of `parser`.
+* **Return type:**
+ [`ManimConfig`](#manim._config.utils.ManimConfig)
+
+#### SEE ALSO
+`main_utils.parse_args()`, [`digest_parser()`](#manim._config.utils.ManimConfig.digest_parser),
+[`digest_file()`](#manim._config.utils.ManimConfig.digest_file)
+
+### Notes
+
+If `args.config_file` is a non-empty string, `ManimConfig` tries to digest the
+contents of said file with [`digest_file()`](#manim._config.utils.ManimConfig.digest_file) before
+digesting any other CLI arguments.
+
+#### digest_file(filename)
+
+Process the config options present in a `.cfg` file.
+
+This method processes a single `.cfg` file, whereas
+[`digest_parser()`](#manim._config.utils.ManimConfig.digest_parser) can process arbitrary parsers, built
+perhaps from multiple `.cfg` files.
+
+* **Parameters:**
+ **filename** ([*StrPath*](manim.typing.md#manim.typing.StrPath)) – Path to the `.cfg` file.
+* **Returns:**
+ **self** – This object, after processing the contents of `filename`.
+* **Return type:**
+ [`ManimConfig`](#manim._config.utils.ManimConfig)
+
+#### SEE ALSO
+[`digest_file()`](#manim._config.utils.ManimConfig.digest_file), [`digest_args()`](#manim._config.utils.ManimConfig.digest_args), [`make_config_parser()`](manim._config.utils.md#manim._config.utils.make_config_parser)
+
+### Notes
+
+If there are multiple `.cfg` files to process, it is always more
+efficient to parse them into a single `ConfigParser` object
+first and digesting them with one call to
+[`digest_parser()`](#manim._config.utils.ManimConfig.digest_parser), instead of calling this method
+multiple times.
+
+#### digest_parser(parser)
+
+Process the config options present in a `ConfigParser` object.
+
+This method processes arbitrary parsers, not only those read from a
+single file, whereas [`digest_file()`](#manim._config.utils.ManimConfig.digest_file) can only process one
+file at a time.
+
+* **Parameters:**
+ **parser** (*configparser.ConfigParser*) – An object reflecting the contents of one or many `.cfg` files. In
+ particular, it may reflect the contents of multiple files that have
+ been parsed in a cascading fashion.
+* **Returns:**
+ **self** – This object, after processing the contents of `parser`.
+* **Return type:**
+ [`ManimConfig`](#manim._config.utils.ManimConfig)
+
+#### SEE ALSO
+[`make_config_parser()`](manim._config.utils.md#manim._config.utils.make_config_parser), [`digest_file()`](#manim._config.utils.ManimConfig.digest_file), [`digest_args()`](#manim._config.utils.ManimConfig.digest_args)
+
+### Notes
+
+If there are multiple `.cfg` files to process, it is always more
+efficient to parse them into a single `ConfigParser` object
+first, and then call this function once (instead of calling
+[`digest_file()`](#manim._config.utils.ManimConfig.digest_file) multiple times).
+
+### Examples
+
+To digest the config options set in two files, first create a
+ConfigParser and parse both files and then digest the parser:
+
+```python
+parser = configparser.ConfigParser()
+parser.read([file1, file2])
+config = ManimConfig().digest_parser(parser)
+```
+
+In fact, the global `config` object is initialized like so:
+
+```python
+parser = make_config_parser()
+config = ManimConfig().digest_parser(parser)
+```
+
+#### *property* disable_caching *: bool*
+
+Whether to use scene caching.
+
+#### *property* disable_caching_warning *: bool*
+
+Whether a warning is raised if there are too much submobjects to hash.
+
+#### *property* dry_run *: bool*
+
+Whether dry run is enabled.
+
+#### *property* enable_gui *: bool*
+
+Enable GUI interaction.
+
+#### *property* enable_wireframe *: bool*
+
+Whether to enable wireframe debugging mode in opengl.
+
+#### *property* ffmpeg_loglevel *: str*
+
+Verbosity level of ffmpeg (no flag).
+
+#### *property* flush_cache *: bool*
+
+Whether to delete all the cached partial movie files.
+
+#### *property* force_window *: bool*
+
+Whether to force window when using the opengl renderer.
+
+#### *property* format *: str*
+
+File format; “png”, “gif”, “mp4”, “webm” or “mov”.
+
+#### *property* frame_height *: float*
+
+Frame height in logical units (no flag).
+
+#### *property* frame_rate *: float*
+
+Frame rate in frames per second.
+
+#### *property* frame_size *: tuple[int, int]*
+
+Tuple with (pixel width, pixel height) (no flag).
+
+#### *property* frame_width *: float*
+
+Frame width in logical units (no flag).
+
+#### *property* frame_x_radius *: float*
+
+Half the frame width (no flag).
+
+#### *property* frame_y_radius *: float*
+
+Half the frame height (no flag).
+
+#### *property* from_animation_number *: int*
+
+Start rendering animations at this number (-n).
+
+#### *property* fullscreen *: bool*
+
+Expand the window to its maximum possible size.
+
+#### get_dir(key, \*\*kwargs)
+
+Resolve a config option that stores a directory.
+
+Config options that store directories may depend on one another. This
+method is used to provide the actual directory to the end user.
+
+* **Parameters:**
+ * **key** (*str*) – The config option to be resolved. Must be an option ending in
+ `'_dir'`, for example `'media_dir'` or `'video_dir'`.
+ * **kwargs** (*Any*) – Any strings to be used when resolving the directory.
+* **Returns:**
+ Path to the requested directory. If the path resolves to the empty
+ string, return `None` instead.
+* **Return type:**
+ `pathlib.Path`
+* **Raises:**
+ **KeyError** – When `key` is not a config option that stores a directory and
+ thus [`get_dir()`](#manim._config.utils.ManimConfig.get_dir) is not appropriate; or when
+ `key` is appropriate but there is not enough information to
+ resolve the directory.
+
+### Notes
+
+Standard `str.format()` syntax is used to resolve the paths so the
+paths may contain arbitrary placeholders using f-string notation.
+However, these will require `kwargs` to contain the required values.
+
+### Examples
+
+The value of `config.tex_dir` is `'{media_dir}/Tex'` by default,
+i.e. it is a subfolder of wherever `config.media_dir` is located. In
+order to get the *actual* directory, use [`get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+```pycon
+>>> from manim import config as globalconfig
+>>> config = globalconfig.copy()
+>>> config.tex_dir
+'{media_dir}/Tex'
+>>> config.media_dir
+'./media'
+>>> config.get_dir("tex_dir").as_posix()
+'media/Tex'
+```
+
+Resolving directories is done in a lazy way, at the last possible
+moment, to reflect any changes in other config options:
+
+```pycon
+>>> config.media_dir = "my_media_dir"
+>>> config.get_dir("tex_dir").as_posix()
+'my_media_dir/Tex'
+```
+
+Some directories depend on information that is not available to
+[`ManimConfig`](#manim._config.utils.ManimConfig). For example, the default value of video_dir
+includes the name of the input file and the video quality
+(e.g. 480p15). This informamtion has to be supplied via `kwargs`:
+
+```pycon
+>>> config.video_dir
+'{media_dir}/videos/{module_name}/{quality}'
+>>> config.get_dir("video_dir")
+Traceback (most recent call last):
+KeyError: 'video_dir {media_dir}/videos/{module_name}/{quality} requires the following keyword arguments: module_name'
+>>> config.get_dir("video_dir", module_name="myfile").as_posix()
+'my_media_dir/videos/myfile/1080p60'
+```
+
+Note the quality does not need to be passed as keyword argument since
+[`ManimConfig`](#manim._config.utils.ManimConfig) does store information about quality.
+
+Directories may be recursively defined. For example, the config option
+`partial_movie_dir` depends on `video_dir`, which in turn depends
+on `media_dir`:
+
+```pycon
+>>> config.partial_movie_dir
+'{video_dir}/partial_movie_files/{scene_name}'
+>>> config.get_dir("partial_movie_dir")
+Traceback (most recent call last):
+KeyError: 'partial_movie_dir {video_dir}/partial_movie_files/{scene_name} requires the following keyword arguments: scene_name'
+>>> config.get_dir(
+... "partial_movie_dir", module_name="myfile", scene_name="myscene"
+... ).as_posix()
+'my_media_dir/videos/myfile/1080p60/partial_movie_files/myscene'
+```
+
+Standard f-string syntax is used. Arbitrary names can be used when
+defining directories, as long as the corresponding values are passed to
+[`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir) via `kwargs`.
+
+```pycon
+>>> config.media_dir = "{dir1}/{dir2}"
+>>> config.get_dir("media_dir")
+Traceback (most recent call last):
+KeyError: 'media_dir {dir1}/{dir2} requires the following keyword arguments: dir1'
+>>> config.get_dir("media_dir", dir1="foo", dir2="bar").as_posix()
+'foo/bar'
+>>> config.media_dir = "./media"
+>>> config.get_dir("media_dir").as_posix()
+'media'
+```
+
+#### *property* gui_location *: tuple[Any]*
+
+Enable GUI interaction.
+
+#### *property* images_dir *: str*
+
+Directory to place images (no flag). See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* input_file *: str*
+
+Input file name.
+
+#### *property* left_side *: [Vector3D](manim.typing.md#manim.typing.Vector3D)*
+
+Coordinate at the middle left of the frame.
+
+#### *property* log_dir *: str*
+
+Directory to place logs. See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* log_to_file *: bool*
+
+Whether to save logs to a file.
+
+#### *property* max_files_cached *: int*
+
+Maximum number of files cached. Use -1 for infinity (no flag).
+
+#### *property* media_dir *: str*
+
+Main output directory. See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* media_embed *: bool*
+
+Whether to embed videos in Jupyter notebook.
+
+#### *property* media_width *: str*
+
+Media width in Jupyter notebook.
+
+#### *property* movie_file_extension *: str*
+
+Either .mp4, .webm or .mov.
+
+#### *property* no_latex_cleanup *: bool*
+
+Prevents deletion of .aux, .dvi, and .log files produced by Tex and MathTex.
+
+#### *property* notify_outdated_version *: bool*
+
+Whether to notify if there is a version update available.
+
+#### *property* output_file *: str*
+
+Output file name (-o).
+
+#### *property* partial_movie_dir *: str*
+
+Directory to place partial movie files (no flag). See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* pixel_height *: int*
+
+Frame height in pixels (–resolution, -r).
+
+#### *property* pixel_width *: int*
+
+Frame width in pixels (–resolution, -r).
+
+#### *property* plugins *: list[str]*
+
+List of plugins to enable.
+
+#### *property* preview *: bool*
+
+Whether to play the rendered movie (-p).
+
+#### *property* progress_bar *: str*
+
+Whether to show progress bars while rendering animations.
+
+#### *property* quality *: str | None*
+
+Video quality (-q).
+
+#### *property* renderer *: [RendererType](manim.constants.RendererType.md#manim.constants.RendererType)*
+
+The currently active renderer.
+
+Populated with one of the available renderers in [`RendererType`](manim.constants.RendererType.md#manim.constants.RendererType).
+
+Tests:
+
+```default
+>>> test_config = ManimConfig()
+>>> test_config.renderer is None # a new ManimConfig is unpopulated
+True
+>>> test_config.renderer = 'opengl'
+>>> test_config.renderer
+
+>>> test_config.renderer = 42
+Traceback (most recent call last):
+...
+ValueError: 42 is not a valid RendererType
+```
+
+Check that capitalization of renderer types is irrelevant:
+
+```default
+>>> test_config.renderer = 'OpenGL'
+>>> test_config.renderer = 'cAirO'
+```
+
+#### *property* right_side *: [Vector3D](manim.typing.md#manim.typing.Vector3D)*
+
+Coordinate at the middle right of the frame.
+
+#### *property* save_as_gif *: bool*
+
+Whether to save the rendered scene in .gif format (-i).
+
+#### *property* save_last_frame *: bool*
+
+Whether to save the last frame of the scene as an image file (-s).
+
+#### *property* save_pngs *: bool*
+
+Whether to save all frames in the scene as images files (-g).
+
+#### *property* save_sections *: bool*
+
+Whether to save single videos for each section in addition to the movie file.
+
+#### *property* scene_names *: list[str]*
+
+Scenes to play from file.
+
+#### *property* sections_dir *: str*
+
+Directory to place section videos (no flag). See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* show_in_file_browser *: bool*
+
+Whether to show the output file in the file browser (-f).
+
+#### *property* tex_dir *: str*
+
+Directory to place tex (no flag). See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* tex_template *: [TexTemplate](manim.utils.tex.TexTemplate.md#manim.utils.tex.TexTemplate)*
+
+Template used when rendering Tex. See [`TexTemplate`](manim.utils.tex.TexTemplate.md#manim.utils.tex.TexTemplate).
+
+#### *property* tex_template_file *: Path*
+
+File to read Tex template from (no flag). See [`TexTemplate`](manim.utils.tex.TexTemplate.md#manim.utils.tex.TexTemplate).
+
+#### *property* text_dir *: str*
+
+Directory to place text (no flag). See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* top *: [Vector3D](manim.typing.md#manim.typing.Vector3D)*
+
+Coordinate at the center top of the frame.
+
+#### *property* transparent *: bool*
+
+Whether the background opacity is less than 1.0 (-t).
+
+#### update(obj)
+
+Digest the options found in another [`ManimConfig`](#manim._config.utils.ManimConfig) or in a dict.
+
+Similar to `dict.update()`, replaces the values of this object with
+those of `obj`.
+
+* **Parameters:**
+ **obj** ([*ManimConfig*](#manim._config.utils.ManimConfig) *|* *dict* *[**str* *,* *Any* *]*) – The object to copy values from.
+* **Return type:**
+ None
+* **Raises:**
+ **AttributeError** – If `obj` is a dict but contains keys that do not belong to any
+ config options.
+
+#### SEE ALSO
+[`digest_file()`](#manim._config.utils.ManimConfig.digest_file), [`digest_args()`](#manim._config.utils.ManimConfig.digest_args), [`digest_parser()`](#manim._config.utils.ManimConfig.digest_parser)
+
+#### *property* upto_animation_number *: int*
+
+Stop rendering animations at this number. Use -1 to avoid skipping (-n).
+
+#### *property* use_projection_fill_shaders *: bool*
+
+Use shaders for OpenGLVMobject fill which are compatible with transformation matrices.
+
+#### *property* use_projection_stroke_shaders *: bool*
+
+Use shaders for OpenGLVMobject stroke which are compatible with transformation matrices.
+
+#### *property* verbosity *: str*
+
+Logger verbosity; “DEBUG”, “INFO”, “WARNING”, “ERROR”, or “CRITICAL” (-v).
+
+#### *property* video_dir *: str*
+
+Directory to place videos (no flag). See [`ManimConfig.get_dir()`](#manim._config.utils.ManimConfig.get_dir).
+
+#### *property* window_monitor *: int*
+
+The monitor on which the scene will be rendered.
+
+#### *property* window_position *: str*
+
+Set the position of preview window. You can use directions, e.g. UL/DR/ORIGIN/LEFT…or the position(pixel) of the upper left corner of the window, e.g. ‘960,540’.
+
+#### *property* window_size *: str*
+
+The size of the opengl window. ‘default’ to automatically scale the window based on the display monitor.
+
+#### *property* write_all *: bool*
+
+Whether to render all scenes in the input file (-a).
+
+#### *property* write_to_movie *: bool*
+
+Whether to render the scene to a movie file (-w).
+
+#### *property* zero_pad *: int*
+
+PNG zero padding. A number between 0 (no zero padding) and 9 (9 columns minimum).
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim._config.utils.ManimFrame.md b/data/rag/manim_docs/manim_core/docs/reference/manim._config.utils.ManimFrame.md
new file mode 100644
index 0000000000000000000000000000000000000000..6906ba6cb068857be72172f3820922c0024ac19c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim._config.utils.ManimFrame.md
@@ -0,0 +1,40 @@
+# ManimFrame
+
+Qualified name: `manim.\_config.utils.ManimFrame`
+
+### *class* ManimFrame(c)
+
+Bases: `Mapping`
+
+### Methods
+
+### Attributes
+
+| `DL` | |
+|------------------|----|
+| `DOWN` | |
+| `DR` | |
+| `IN` | |
+| `LEFT` | |
+| `ORIGIN` | |
+| `OUT` | |
+| `RIGHT` | |
+| `UL` | |
+| `UP` | |
+| `UR` | |
+| `X_AXIS` | |
+| `Y_AXIS` | |
+| `Z_AXIS` | |
+| `aspect_ratio` | |
+| `bottom` | |
+| `frame_height` | |
+| `frame_width` | |
+| `frame_x_radius` | |
+| `frame_y_radius` | |
+| `left_side` | |
+| `pixel_height` | |
+| `pixel_width` | |
+| `right_side` | |
+| `top` | |
+* **Parameters:**
+ **c** ([*ManimConfig*](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig))
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim._config.utils.md b/data/rag/manim_docs/manim_core/docs/reference/manim._config.utils.md
new file mode 100644
index 0000000000000000000000000000000000000000..1056a6403be89d843c443000a7418f3558ed131c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim._config.utils.md
@@ -0,0 +1,75 @@
+# utils
+
+Utilities to create and set the config.
+
+The main class exported by this module is [`ManimConfig`](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig). This class
+contains all configuration options, including frame geometry (e.g. frame
+height/width, frame rate), output (e.g. directories, logging), styling
+(e.g. background color, transparency), and general behavior (e.g. writing a
+movie vs writing a single frame).
+
+See [Configuration](../guides/configuration.md) for an introduction to Manim’s configuration system.
+
+### Classes
+
+| [`ManimConfig`](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig) | Dict-like class storing all config options. |
+|---------------------------------------------------------------------------------------|-----------------------------------------------|
+| [`ManimFrame`](manim._config.utils.ManimFrame.md#manim._config.utils.ManimFrame) | |
+
+### Functions
+
+### config_file_paths()
+
+The paths where `.cfg` files will be searched for.
+
+When manim is first imported, it processes any `.cfg` files it finds. This
+function returns the locations in which these files are searched for. In
+ascending order of precedence, these are: the library-wide config file, the
+user-wide config file, and the folder-wide config file.
+
+The library-wide config file determines manim’s default behavior. The
+user-wide config file is stored in the user’s home folder, and determines
+the behavior of manim whenever the user invokes it from anywhere in the
+system. The folder-wide config file only affects scenes that are in the
+same folder. The latter two files are optional.
+
+These files, if they exist, are meant to loaded into a single
+`configparser.ConfigParser` object, and then processed by
+[`ManimConfig`](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig).
+
+* **Returns:**
+ List of paths which may contain `.cfg` files, in ascending order of
+ precedence.
+* **Return type:**
+ List[`Path`]
+
+#### SEE ALSO
+[`make_config_parser()`](#manim._config.utils.make_config_parser), [`ManimConfig.digest_file()`](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig.digest_file), [`ManimConfig.digest_parser()`](manim._config.utils.ManimConfig.md#manim._config.utils.ManimConfig.digest_parser)
+
+### Notes
+
+The location of the user-wide config file is OS-specific.
+
+### make_config_parser(custom_file=None)
+
+Make a `ConfigParser` object and load any `.cfg` files.
+
+The user-wide file, if it exists, overrides the library-wide file. The
+folder-wide file, if it exists, overrides the other two.
+
+The folder-wide file can be ignored by passing `custom_file`. However,
+the user-wide and library-wide config files cannot be ignored.
+
+* **Parameters:**
+ **custom_file** ([*StrPath*](manim.typing.md#manim.typing.StrPath) *|* *None*) – Path to a custom config file. If used, the folder-wide file in the
+ relevant directory will be ignored, if it exists. If None, the
+ folder-wide file will be used, if it exists.
+* **Returns:**
+ A parser containing the config options found in the .cfg files that
+ were found. It is guaranteed to contain at least the config options
+ found in the library-wide file.
+* **Return type:**
+ `ConfigParser`
+
+#### SEE ALSO
+[`config_file_paths()`](#manim._config.utils.config_file_paths)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.Add.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.Add.md
new file mode 100644
index 0000000000000000000000000000000000000000..fc950a29b63c80bce50fb4bcc727ef6fffba8ead
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.Add.md
@@ -0,0 +1,206 @@
+# Add
+
+Qualified name: `manim.animation.animation.Add`
+
+### *class* Add(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+Add Mobjects to a scene, without animating them in any other way. This
+is similar to the [`Scene.add()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) method, but [`Add`](#manim.animation.animation.Add) is an
+animation which can be grouped into other animations.
+
+* **Parameters:**
+ * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – One [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) or more to add to a scene.
+ * **run_time** (*float*) – The duration of the animation after adding the `mobjects`. Defaults
+ to 0, which means this is an instant animation without extra wait time
+ after adding them.
+ * **\*\*kwargs** (*Any*) – Additional arguments to pass to the parent [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) class.
+
+### Examples
+
+
+```python
+from manim import *
+
+class AddWithRunTimeScene(Scene):
+ def construct(self):
+ # A 5x5 grid of circles
+ circles = VGroup(
+ *[Circle(radius=0.5) for _ in range(25)]
+ ).arrange_in_grid(5, 5)
+
+ self.play(
+ Succession(
+ # Add a run_time of 0.2 to wait for 0.2 seconds after
+ # adding the circle, instead of using Wait(0.2) after Add!
+ *[Add(circle, run_time=0.2) for circle in circles],
+ rate_func=smooth,
+ )
+ )
+ self.wait()
+```
+
+
+class AddWithRunTimeScene(Scene):
+ def construct(self):
+ # A 5x5 grid of circles
+ circles = VGroup(
+ \*[Circle(radius=0.5) for \_ in range(25)]
+ ).arrange_in_grid(5, 5)
+
+ self.play(
+ Succession(
+ # Add a run_time of 0.2 to wait for 0.2 seconds after
+ # adding the circle, instead of using Wait(0.2) after Add!
+ \*[Add(circle, run_time=0.2) for circle in circles],
+ rate_func=smooth,
+ )
+ )
+ self.wait()
+
+
+
+### Methods
+
+| [`begin`](#manim.animation.animation.Add.begin) | Begin the animation. |
+|-----------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`clean_up_from_scene`](#manim.animation.animation.Add.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| [`finish`](#manim.animation.animation.Add.finish) | Finish the animation. |
+| [`interpolate`](#manim.animation.animation.Add.interpolate) | Set the animation progress. |
+| [`update_mobjects`](#manim.animation.animation.Add.update_mobjects) | Updates things like starting_mobject, and (for Transforms) target_mobject. |
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(\*mobjects, run_time=0.0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **run_time** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+ None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+ **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+ None
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+ **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+ the end.
+* **Return type:**
+ None
+
+#### update_mobjects(dt)
+
+Updates things like starting_mobject, and (for
+Transforms) target_mobject. Note, since typically
+(always?) self.mobject will have its updating
+suspended during the animation, this will do
+nothing to self.mobject.
+
+* **Parameters:**
+ **dt** (*float*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.Animation.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.Animation.md
new file mode 100644
index 0000000000000000000000000000000000000000..e7a1977b9b8ed9cde4b6e8e6427357ec5585258d
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.Animation.md
@@ -0,0 +1,400 @@
+# Animation
+
+Qualified name: `manim.animation.animation.Animation`
+
+### *class* Animation(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: `object`
+
+An animation.
+
+Animations have a fixed time span.
+
+* **Parameters:**
+ * **mobject** – The mobject to be animated. This is not required for all types of animations.
+ * **lag_ratio** –
+
+ Defines the delay after which the animation is applied to submobjects. This lag
+ is relative to the duration of the animation.
+
+ This does not influence the total
+ runtime of the animation. Instead the runtime of individual animations is
+ adjusted so that the complete animation has the defined run time.
+ * **run_time** – The duration of the animation in seconds.
+ * **rate_func** –
+
+ The function defining the animation progress based on the relative runtime (see [`rate_functions`](manim.utils.rate_functions.md#module-manim.utils.rate_functions)) .
+
+ For example `rate_func(0.5)` is the proportion of the animation that is done
+ after half of the animations run time.
+* **Return type:**
+ Self
+
+reverse_rate_function
+: Reverses the rate function of the animation. Setting `reverse_rate_function`
+ does not have any effect on `remover` or `introducer`. These need to be
+ set explicitly if an introducer-animation should be turned into a remover one
+ and vice versa.
+
+name
+: The name of the animation. This gets displayed while rendering the animation.
+ Defaults to ().
+
+remover
+: Whether the given mobject should be removed from the scene after this animation.
+
+suspend_mobject_updating
+: Whether updaters of the mobject should be suspended during the animation.
+
+#### NOTE
+In the current implementation of this class, the specified rate function is applied
+within [`Animation.interpolate_mobject()`](#manim.animation.animation.Animation.interpolate_mobject) call as part of the call to
+`Animation.interpolate_submobject()`. For subclasses of [`Animation`](#manim.animation.animation.Animation)
+that are implemented by overriding [`interpolate_mobject()`](#manim.animation.animation.Animation.interpolate_mobject), the rate function
+has to be applied manually (e.g., by passing `self.rate_func(alpha)` instead
+of just `alpha`).
+
+### Examples
+
+
+```python
+from manim import *
+
+class LagRatios(Scene):
+ def construct(self):
+ ratios = [0, 0.1, 0.5, 1, 2] # demonstrated lag_ratios
+
+ # Create dot groups
+ group = VGroup(*[Dot() for _ in range(4)]).arrange_submobjects()
+ groups = VGroup(*[group.copy() for _ in ratios]).arrange_submobjects(buff=1)
+ self.add(groups)
+
+ # Label groups
+ self.add(Text("lag_ratio = ", font_size=36).next_to(groups, UP, buff=1.5))
+ for group, ratio in zip(groups, ratios):
+ self.add(Text(str(ratio), font_size=36).next_to(group, UP))
+
+ #Animate groups with different lag_ratios
+ self.play(AnimationGroup(*[
+ group.animate(lag_ratio=ratio, run_time=1.5).shift(DOWN * 2)
+ for group, ratio in zip(groups, ratios)
+ ]))
+
+ # lag_ratio also works recursively on nested submobjects:
+ self.play(groups.animate(run_time=1, lag_ratio=0.1).shift(UP * 2))
+```
+
+
+class LagRatios(Scene):
+ def construct(self):
+ ratios = [0, 0.1, 0.5, 1, 2] # demonstrated lag_ratios
+
+ # Create dot groups
+ group = VGroup(\*[Dot() for \_ in range(4)]).arrange_submobjects()
+ groups = VGroup(\*[group.copy() for \_ in ratios]).arrange_submobjects(buff=1)
+ self.add(groups)
+
+ # Label groups
+ self.add(Text("lag_ratio = ", font_size=36).next_to(groups, UP, buff=1.5))
+ for group, ratio in zip(groups, ratios):
+ self.add(Text(str(ratio), font_size=36).next_to(group, UP))
+
+ #Animate groups with different lag_ratios
+ self.play(AnimationGroup(\*[
+ group.animate(lag_ratio=ratio, run_time=1.5).shift(DOWN \* 2)
+ for group, ratio in zip(groups, ratios)
+ ]))
+
+ # lag_ratio also works recursively on nested submobjects:
+ self.play(groups.animate(run_time=1, lag_ratio=0.1).shift(UP \* 2))
+
+
+
+### Methods
+
+| [`begin`](#manim.animation.animation.Animation.begin) | Begin the animation. |
+|-------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`clean_up_from_scene`](#manim.animation.animation.Animation.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| [`copy`](#manim.animation.animation.Animation.copy) | Create a copy of the animation. |
+| `create_starting_mobject` | |
+| [`finish`](#manim.animation.animation.Animation.finish) | Finish the animation. |
+| `get_all_families_zipped` | |
+| [`get_all_mobjects`](#manim.animation.animation.Animation.get_all_mobjects) | Get all mobjects involved in the animation. |
+| [`get_all_mobjects_to_update`](#manim.animation.animation.Animation.get_all_mobjects_to_update) | Get all mobjects to be updated during the animation. |
+| [`get_rate_func`](#manim.animation.animation.Animation.get_rate_func) | Get the rate function of the animation. |
+| [`get_run_time`](#manim.animation.animation.Animation.get_run_time) | Get the run time of the animation. |
+| [`get_sub_alpha`](#manim.animation.animation.Animation.get_sub_alpha) | Get the animation progress of any submobjects subanimation. |
+| [`interpolate`](#manim.animation.animation.Animation.interpolate) | Set the animation progress. |
+| [`interpolate_mobject`](#manim.animation.animation.Animation.interpolate_mobject) | Interpolates the mobject of the [`Animation`](#manim.animation.animation.Animation) based on alpha value. |
+| `interpolate_submobject` | |
+| [`is_introducer`](#manim.animation.animation.Animation.is_introducer) | Test if the animation is an introducer. |
+| [`is_remover`](#manim.animation.animation.Animation.is_remover) | Test if the animation is a remover. |
+| [`set_default`](#manim.animation.animation.Animation.set_default) | Sets the default values of keyword arguments. |
+| [`set_name`](#manim.animation.animation.Animation.set_name) | Set the name of the animation. |
+| [`set_rate_func`](#manim.animation.animation.Animation.set_rate_func) | Set the rate function of the animation. |
+| [`set_run_time`](#manim.animation.animation.Animation.set_run_time) | Set the run time of the animation. |
+| [`update_mobjects`](#manim.animation.animation.Animation.update_mobjects) | Updates things like starting_mobject, and (for Transforms) target_mobject. |
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_setup_scene(scene)
+
+Setup up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) before starting the animation.
+
+This includes to [`add()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is an introducer.
+
+* **Parameters:**
+ **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+ None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+ **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
+
+#### copy()
+
+Create a copy of the animation.
+
+* **Returns:**
+ A copy of `self`
+* **Return type:**
+ [Animation](#manim.animation.animation.Animation)
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+ None
+
+#### get_all_mobjects()
+
+Get all mobjects involved in the animation.
+
+Ordering must match the ordering of arguments to interpolate_submobject
+
+* **Returns:**
+ The sequence of mobjects.
+* **Return type:**
+ Sequence[[Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)]
+
+#### get_all_mobjects_to_update()
+
+Get all mobjects to be updated during the animation.
+
+* **Returns:**
+ The list of mobjects to be updated during the animation.
+* **Return type:**
+ List[[Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)]
+
+#### get_rate_func()
+
+Get the rate function of the animation.
+
+* **Returns:**
+ The rate function of the animation.
+* **Return type:**
+ Callable[[float], float]
+
+#### get_run_time()
+
+Get the run time of the animation.
+
+* **Returns:**
+ The time the animation takes in seconds.
+* **Return type:**
+ float
+
+#### get_sub_alpha(alpha, index, num_submobjects)
+
+Get the animation progress of any submobjects subanimation.
+
+* **Parameters:**
+ * **alpha** (*float*) – The overall animation progress
+ * **index** (*int*) – The index of the subanimation.
+ * **num_submobjects** (*int*) – The total count of subanimations.
+* **Returns:**
+ The progress of the subanimation.
+* **Return type:**
+ float
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+ **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+ the end.
+* **Return type:**
+ None
+
+#### interpolate_mobject(alpha)
+
+Interpolates the mobject of the [`Animation`](#manim.animation.animation.Animation) based on alpha value.
+
+* **Parameters:**
+ **alpha** (*float*) – A float between 0 and 1 expressing the ratio to which the animation
+ is completed. For example, alpha-values of 0, 0.5, and 1 correspond
+ to the animation being completed 0%, 50%, and 100%, respectively.
+* **Return type:**
+ None
+
+#### is_introducer()
+
+Test if the animation is an introducer.
+
+* **Returns:**
+ `True` if the animation is an introducer, `False` otherwise.
+* **Return type:**
+ bool
+
+#### is_remover()
+
+Test if the animation is a remover.
+
+* **Returns:**
+ `True` if the animation is a remover, `False` otherwise.
+* **Return type:**
+ bool
+
+#### *classmethod* set_default(\*\*kwargs)
+
+Sets the default values of keyword arguments.
+
+If this method is called without any additional keyword
+arguments, the original default values of the initialization
+method of this class are restored.
+
+* **Parameters:**
+ **kwargs** – Passing any keyword argument will update the default
+ values of the keyword arguments of the initialization
+ function of this class.
+* **Return type:**
+ None
+
+### Examples
+
+
+
+#### set_name(name)
+
+Set the name of the animation.
+
+* **Parameters:**
+ **name** (*str*) – The new name of the animation.
+* **Returns:**
+ `self`
+* **Return type:**
+ [Animation](#manim.animation.animation.Animation)
+
+#### set_rate_func(rate_func)
+
+Set the rate function of the animation.
+
+* **Parameters:**
+ **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*) – The new function defining the animation progress based on the
+ relative runtime (see [`rate_functions`](manim.utils.rate_functions.md#module-manim.utils.rate_functions)).
+* **Returns:**
+ `self`
+* **Return type:**
+ [Animation](#manim.animation.animation.Animation)
+
+#### set_run_time(run_time)
+
+Set the run time of the animation.
+
+* **Parameters:**
+ * **run_time** (*float*) – The new time the animation should take in seconds.
+ * **note::** ( *..*) – The run_time of an animation should not be changed while it is already
+ running.
+* **Returns:**
+ `self`
+* **Return type:**
+ [Animation](#manim.animation.animation.Animation)
+
+#### update_mobjects(dt)
+
+Updates things like starting_mobject, and (for
+Transforms) target_mobject. Note, since typically
+(always?) self.mobject will have its updating
+suspended during the animation, this will do
+nothing to self.mobject.
+
+* **Parameters:**
+ **dt** (*float*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.Wait.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.Wait.md
new file mode 100644
index 0000000000000000000000000000000000000000..1a2ff436bf11f6fe680eb2177a3dc71aee7558d7
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.Wait.md
@@ -0,0 +1,105 @@
+# Wait
+
+Qualified name: `manim.animation.animation.Wait`
+
+### *class* Wait(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+A “no operation” animation.
+
+* **Parameters:**
+ * **run_time** (*float*) – The amount of time that should pass.
+ * **stop_condition** (*Callable* *[* *[* *]* *,* *bool* *]* *|* *None*) – A function without positional arguments that evaluates to a boolean.
+ The function is evaluated after every new frame has been rendered.
+ Playing the animation stops after the return value is truthy, or
+ after the specified `run_time` has passed.
+ * **frozen_frame** (*bool* *|* *None*) – Controls whether or not the wait animation is static, i.e., corresponds
+ to a frozen frame. If `False` is passed, the render loop still
+ progresses through the animation as usual and (among other things)
+ continues to call updater functions. If `None` (the default value),
+ the [`Scene.play()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call tries to determine whether the Wait call
+ can be static or not itself via `Scene.should_mobjects_update()`.
+ * **kwargs** – Keyword arguments to be passed to the parent class, [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation).
+ * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+
+### Methods
+
+| [`begin`](#manim.animation.animation.Wait.begin) | Begin the animation. |
+|------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`clean_up_from_scene`](#manim.animation.animation.Wait.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| [`finish`](#manim.animation.animation.Wait.finish) | Finish the animation. |
+| [`interpolate`](#manim.animation.animation.Wait.interpolate) | Set the animation progress. |
+| [`update_mobjects`](#manim.animation.animation.Wait.update_mobjects) | Updates things like starting_mobject, and (for Transforms) target_mobject. |
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(run_time=1, stop_condition=None, frozen_frame=None, rate_func=, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **run_time** (*float*)
+ * **stop_condition** (*Callable* *[* *[* *]* *,* *bool* *]* *|* *None*)
+ * **frozen_frame** (*bool* *|* *None*)
+ * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+ None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+ **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+ None
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+ **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+ the end.
+* **Return type:**
+ None
+
+#### update_mobjects(dt)
+
+Updates things like starting_mobject, and (for
+Transforms) target_mobject. Note, since typically
+(always?) self.mobject will have its updating
+suspended during the animation, this will do
+nothing to self.mobject.
+
+* **Parameters:**
+ **dt** (*float*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.md
new file mode 100644
index 0000000000000000000000000000000000000000..505c1ba06fe6699c515ccf935d30da485278a9e7
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.animation.md
@@ -0,0 +1,96 @@
+# animation
+
+Animate mobjects.
+
+### Classes
+
+| [`Add`](manim.animation.animation.Add.md#manim.animation.animation.Add) | Add Mobjects to a scene, without animating them in any other way. |
+|-------------------------------------------------------------------------------------------|---------------------------------------------------------------------|
+| [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) | An animation. |
+| [`Wait`](manim.animation.animation.Wait.md#manim.animation.animation.Wait) | A "no operation" animation. |
+
+### Functions
+
+### override_animation(animation_class)
+
+Decorator used to mark methods as overrides for specific [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) types.
+
+Should only be used to decorate methods of classes derived from [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+`Animation` overrides get inherited to subclasses of the `Mobject` who defined
+them. They don’t override subclasses of the `Animation` they override.
+
+#### SEE ALSO
+[`add_animation_override()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.add_animation_override)
+
+* **Parameters:**
+ **animation_class** (*type* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – The animation to be overridden.
+* **Returns:**
+ The actual decorator. This marks the method as overriding an animation.
+* **Return type:**
+ Callable[[Callable], Callable]
+
+### Examples
+
+
+
+### Methods
+
+| `full_family_become_partial` | |
+|--------------------------------|----|
+| `update_boundary_copies` | |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(vmobject, colors=[ManimColor('#29ABCA'), ManimColor('#9CDCEB'), ManimColor('#236B8E'), ManimColor('#736357')], max_stroke_width=3, cycle_rate=0.5, back_and_forth=True, draw_rate_func=, fade_rate_func=, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.changing.TracedPath.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.changing.TracedPath.md
new file mode 100644
index 0000000000000000000000000000000000000000..97770f224af549367f8ef20708e963cf6e431b26
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.changing.TracedPath.md
@@ -0,0 +1,113 @@
+# TracedPath
+
+Qualified name: `manim.animation.changing.TracedPath`
+
+### *class* TracedPath(traced_point_func, stroke_width=2, stroke_color=ManimColor('#FFFFFF'), dissipating_time=None, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+Traces the path of a point returned by a function call.
+
+* **Parameters:**
+ * **traced_point_func** (*Callable*) – The function to be traced.
+ * **stroke_width** (*float*) – The width of the trace.
+ * **stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The color of the trace.
+ * **dissipating_time** (*float* *|* *None*) – The time taken for the path to dissipate. Default set to `None`
+ which disables dissipation.
+
+### Examples
+
+
+
+### Methods
+
+| `update_path` | |
+|-----------------|----|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(traced_point_func, stroke_width=2, stroke_color=ManimColor('#FFFFFF'), dissipating_time=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **traced_point_func** (*Callable*)
+ * **stroke_width** (*float*)
+ * **stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **dissipating_time** (*float* *|* *None*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.changing.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.changing.md
new file mode 100644
index 0000000000000000000000000000000000000000..695c76ea48298c172c1c75a3b8463560e7d2fec0
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.changing.md
@@ -0,0 +1,9 @@
+# changing
+
+Animation of a mobject boundary and tracing of points.
+
+### Classes
+
+| [`AnimatedBoundary`](manim.animation.changing.AnimatedBoundary.md#manim.animation.changing.AnimatedBoundary) | Boundary of a [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) with animated color change. |
+|----------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`TracedPath`](manim.animation.changing.TracedPath.md#manim.animation.changing.TracedPath) | Traces the path of a point returned by a function call. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.AnimationGroup.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.AnimationGroup.md
new file mode 100644
index 0000000000000000000000000000000000000000..4cded51a77c20a977cea98720711652a9b514ba1
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.AnimationGroup.md
@@ -0,0 +1,153 @@
+# AnimationGroup
+
+Qualified name: `manim.animation.composition.AnimationGroup`
+
+### *class* AnimationGroup(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+Plays a group or series of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation).
+
+* **Parameters:**
+ * **animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *|* *Iterable* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]* *|* *types.GeneratorType* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – Sequence of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) objects to be played.
+ * **group** ([*Group*](manim.mobject.mobject.Group.md#manim.mobject.mobject.Group) *|* [*VGroup*](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) *|* *OpenGLGroup* *|* *OpenGLVGroup*) – A group of multiple [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+ * **run_time** (*float* *|* *None*) – The duration of the animation in seconds.
+ * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*) – The function defining the animation progress based on the relative
+ runtime (see [`rate_functions`](manim.utils.rate_functions.md#module-manim.utils.rate_functions)) .
+ * **lag_ratio** (*float*) –
+
+ Defines the delay after which the animation is applied to submobjects. A lag_ratio of
+ `n.nn` means the next animation will play when `nnn%` of the current animation has played.
+ Defaults to 0.0, meaning that all animations will be played together.
+
+ This does not influence the total runtime of the animation. Instead the runtime
+ of individual animations is adjusted so that the complete animation has the defined
+ run time.
+
+### Methods
+
+| [`begin`](#manim.animation.composition.AnimationGroup.begin) | Begin the animation. |
+|--------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`build_animations_with_timings`](#manim.animation.composition.AnimationGroup.build_animations_with_timings) | Creates a list of triplets of the form (anim, start_time, end_time). |
+| [`clean_up_from_scene`](#manim.animation.composition.AnimationGroup.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| [`finish`](#manim.animation.composition.AnimationGroup.finish) | Finish the animation. |
+| [`get_all_mobjects`](#manim.animation.composition.AnimationGroup.get_all_mobjects) | Get all mobjects involved in the animation. |
+| [`init_run_time`](#manim.animation.composition.AnimationGroup.init_run_time) | Calculates the run time of the animation, if different from `run_time`. |
+| [`interpolate`](#manim.animation.composition.AnimationGroup.interpolate) | Set the animation progress. |
+| [`update_mobjects`](#manim.animation.composition.AnimationGroup.update_mobjects) | Updates things like starting_mobject, and (for Transforms) target_mobject. |
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(\*animations, group=None, run_time=None, rate_func=, lag_ratio=0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *|* *Iterable* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]* *|* *types.GeneratorType* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*)
+ * **group** ([*Group*](manim.mobject.mobject.Group.md#manim.mobject.mobject.Group) *|* [*VGroup*](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) *|* *OpenGLGroup* *|* *OpenGLVGroup*)
+ * **run_time** (*float* *|* *None*)
+ * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+ * **lag_ratio** (*float*)
+* **Return type:**
+ None
+
+#### \_setup_scene(scene)
+
+Setup up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) before starting the animation.
+
+This includes to [`add()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is an introducer.
+
+* **Parameters:**
+ **scene** – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+ None
+
+#### build_animations_with_timings()
+
+Creates a list of triplets of the form (anim, start_time, end_time).
+
+* **Return type:**
+ None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+ **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+ None
+
+#### get_all_mobjects()
+
+Get all mobjects involved in the animation.
+
+Ordering must match the ordering of arguments to interpolate_submobject
+
+* **Returns:**
+ The sequence of mobjects.
+* **Return type:**
+ Sequence[[Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)]
+
+#### init_run_time(run_time)
+
+Calculates the run time of the animation, if different from `run_time`.
+
+* **Parameters:**
+ **run_time** – The duration of the animation in seconds.
+* **Returns:**
+ The duration of the animation in seconds.
+* **Return type:**
+ run_time
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+ **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+ the end.
+* **Return type:**
+ None
+
+#### update_mobjects(dt)
+
+Updates things like starting_mobject, and (for
+Transforms) target_mobject. Note, since typically
+(always?) self.mobject will have its updating
+suspended during the animation, this will do
+nothing to self.mobject.
+
+* **Parameters:**
+ **dt** (*float*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.LaggedStart.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.LaggedStart.md
new file mode 100644
index 0000000000000000000000000000000000000000..93870792b27c24d085a952d88553c600c868eaaa
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.LaggedStart.md
@@ -0,0 +1,100 @@
+# LaggedStart
+
+Qualified name: `manim.animation.composition.LaggedStart`
+
+### *class* LaggedStart(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup)
+
+Adjusts the timing of a series of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) according to `lag_ratio`.
+
+* **Parameters:**
+ * **animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation)) – Sequence of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) objects to be played.
+ * **lag_ratio** (*float*) –
+
+ Defines the delay after which the animation is applied to submobjects. A lag_ratio of
+ `n.nn` means the next animation will play when `nnn%` of the current animation has played.
+ Defaults to 0.05, meaning that the next animation will begin when 5% of the current
+ animation has played.
+
+ This does not influence the total runtime of the animation. Instead the runtime
+ of individual animations is adjusted so that the complete animation has the defined
+ run time.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(AnimationClass, mobject, arg_creator=None, run_time=2, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **AnimationClass** (*Callable* *[* *[* *...* *]* *,* [*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*)
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **arg_creator** (*Callable* *[* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]* *,* *str* *]*)
+ * **run_time** (*float*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.Succession.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.Succession.md
new file mode 100644
index 0000000000000000000000000000000000000000..96eedc0b72a9b15566afc19a1a66f830846c1ed8
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.Succession.md
@@ -0,0 +1,160 @@
+# Succession
+
+Qualified name: `manim.animation.composition.Succession`
+
+### *class* Succession(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup)
+
+Plays a series of animations in succession.
+
+* **Parameters:**
+ * **animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation)) – Sequence of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) objects to be played.
+ * **lag_ratio** (*float*) –
+
+ Defines the delay after which the animation is applied to submobjects. A lag_ratio of
+ `n.nn` means the next animation will play when `nnn%` of the current animation has played.
+ Defaults to 1.0, meaning that the next animation will begin when 100% of the current
+ animation has played.
+
+ This does not influence the total runtime of the animation. Instead the runtime
+ of individual animations is adjusted so that the complete animation has the defined
+ run time.
+
+### Examples
+
+
+
+### Methods
+
+| [`begin`](#manim.animation.composition.Succession.begin) | Begin the animation. |
+|------------------------------------------------------------------------------|----------------------------------------------------------------------------|
+| [`finish`](#manim.animation.composition.Succession.finish) | Finish the animation. |
+| [`interpolate`](#manim.animation.composition.Succession.interpolate) | Set the animation progress. |
+| [`next_animation`](#manim.animation.composition.Succession.next_animation) | Proceeds to the next animation. |
+| `update_active_animation` | |
+| [`update_mobjects`](#manim.animation.composition.Succession.update_mobjects) | Updates things like starting_mobject, and (for Transforms) target_mobject. |
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(\*animations, lag_ratio=1, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation))
+ * **lag_ratio** (*float*)
+* **Return type:**
+ None
+
+#### \_setup_scene(scene)
+
+Setup up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) before starting the animation.
+
+This includes to [`add()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is an introducer.
+
+* **Parameters:**
+ **scene** – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+ None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+ None
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+ **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+ the end.
+* **Return type:**
+ None
+
+#### next_animation()
+
+Proceeds to the next animation.
+
+This method is called right when the active animation finishes.
+
+* **Return type:**
+ None
+
+#### update_mobjects(dt)
+
+Updates things like starting_mobject, and (for
+Transforms) target_mobject. Note, since typically
+(always?) self.mobject will have its updating
+suspended during the animation, this will do
+nothing to self.mobject.
+
+* **Parameters:**
+ **dt** (*float*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.md
new file mode 100644
index 0000000000000000000000000000000000000000..36f605700cd48412bf5bf756854e1f4597f839ad
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.composition.md
@@ -0,0 +1,11 @@
+# composition
+
+Tools for displaying multiple animations at once.
+
+### Classes
+
+| [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup) | Plays a group or series of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation). |
+|----------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`LaggedStart`](manim.animation.composition.LaggedStart.md#manim.animation.composition.LaggedStart) | Adjusts the timing of a series of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) according to `lag_ratio`. |
+| [`LaggedStartMap`](manim.animation.composition.LaggedStartMap.md#manim.animation.composition.LaggedStartMap) | Plays a series of [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) while mapping a function to submobjects. |
+| [`Succession`](manim.animation.composition.Succession.md#manim.animation.composition.Succession) | Plays a series of animations in succession. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.AddTextLetterByLetter.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.AddTextLetterByLetter.md
new file mode 100644
index 0000000000000000000000000000000000000000..51b92071138fb7c52c67dadd6449ad8cbaf89ef9
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.AddTextLetterByLetter.md
@@ -0,0 +1,39 @@
+# AddTextLetterByLetter
+
+Qualified name: `manim.animation.creation.AddTextLetterByLetter`
+
+### *class* AddTextLetterByLetter(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`ShowIncreasingSubsets`](manim.animation.creation.ShowIncreasingSubsets.md#manim.animation.creation.ShowIncreasingSubsets)
+
+Show a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) letter by letter on the scene.
+
+* **Parameters:**
+ * **time_per_char** (*float*) – Frequency of appearance of the letters.
+ * **tip::** ( *..*) – This is currently only possible for class:~.Text and not for class:~.MathTex
+ * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+ * **suspend_mobject_updating** (*bool*)
+ * **int_func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*)
+ * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+ * **run_time** (*float* *|* *None*)
+
+### Methods
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(text, suspend_mobject_updating=False, int_func=, rate_func=, time_per_char=0.1, run_time=None, reverse_rate_function=False, introducer=True, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+ * **suspend_mobject_updating** (*bool*)
+ * **int_func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*)
+ * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+ * **time_per_char** (*float*)
+ * **run_time** (*float* *|* *None*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.AddTextWordByWord.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.AddTextWordByWord.md
new file mode 100644
index 0000000000000000000000000000000000000000..e65d1ffcc996b842d44f3221aad4a81ae02ef383
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.AddTextWordByWord.md
@@ -0,0 +1,31 @@
+# AddTextWordByWord
+
+Qualified name: `manim.animation.creation.AddTextWordByWord`
+
+### *class* AddTextWordByWord(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Succession`](manim.animation.composition.Succession.md#manim.animation.composition.Succession)
+
+Show a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) word by word on the scene. Note: currently broken.
+
+### Methods
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+* **Parameters:**
+ * **text_mobject** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+ * **run_time** (*float*)
+ * **time_per_char** (*float*)
+
+#### \_original_\_init_\_(text_mobject, run_time=None, time_per_char=0.06, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **text_mobject** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+ * **run_time** (*float*)
+ * **time_per_char** (*float*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.Create.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.Create.md
new file mode 100644
index 0000000000000000000000000000000000000000..8a09c5c4811d5afb4ea465daa8c12a2c79b0ab7c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.Create.md
@@ -0,0 +1,62 @@
+# Create
+
+Qualified name: `manim.animation.creation.Create`
+
+### *class* Create(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`ShowPartial`](manim.animation.creation.ShowPartial.md#manim.animation.creation.ShowPartial)
+
+Incrementally show a VMobject.
+
+* **Parameters:**
+ * **mobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject* *|* *OpenGLSurface*) – The VMobject to animate.
+ * **lag_ratio** (*float*)
+ * **introducer** (*bool*)
+* **Raises:**
+ **TypeError** – If `mobject` is not an instance of [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+
+### Examples
+
+
+
+### Methods
+
+| [`interpolate_mobject`](#manim.animation.creation.SpiralIn.interpolate_mobject) | Interpolates the mobject of the `Animation` based on alpha value. |
+|-----------------------------------------------------------------------------------|---------------------------------------------------------------------|
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(shapes, scale_factor=8, fade_in_fraction=0.3, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **shapes** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **scale_factor** (*float*)
+* **Return type:**
+ None
+
+#### interpolate_mobject(alpha)
+
+Interpolates the mobject of the `Animation` based on alpha value.
+
+* **Parameters:**
+ **alpha** (*float*) – A float between 0 and 1 expressing the ratio to which the animation
+ is completed. For example, alpha-values of 0, 0.5, and 1 correspond
+ to the animation being completed 0%, 50%, and 100%, respectively.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.TypeWithCursor.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.TypeWithCursor.md
new file mode 100644
index 0000000000000000000000000000000000000000..cd2459031f94a628f8b2844455e9c71aaf9a4a4c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.TypeWithCursor.md
@@ -0,0 +1,126 @@
+# TypeWithCursor
+
+Qualified name: `manim.animation.creation.TypeWithCursor`
+
+### *class* TypeWithCursor(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`AddTextLetterByLetter`](manim.animation.creation.AddTextLetterByLetter.md#manim.animation.creation.AddTextLetterByLetter)
+
+Similar to [`AddTextLetterByLetter`](manim.animation.creation.AddTextLetterByLetter.md#manim.animation.creation.AddTextLetterByLetter) , but with an additional cursor mobject at the end.
+
+* **Parameters:**
+ * **time_per_char** (*float*) – Frequency of appearance of the letters.
+ * **cursor** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) shown after the last added letter.
+ * **buff** (*float*) – Controls how far away the cursor is to the right of the last added letter.
+ * **keep_cursor_y** (*bool*) – If `True`, the cursor’s y-coordinate is set to the center of the `Text` and remains the same throughout the animation. Otherwise, it is set to the center of the last added letter.
+ * **leave_cursor_on** (*bool*) – Whether to show the cursor after the animation.
+ * **tip::** ( *..*) – This is currently only possible for class:~.Text and not for class:~.MathTex.
+ * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+
+### Examples
+
+
+
+### Methods
+
+| [`begin`](#manim.animation.creation.TypeWithCursor.begin) | Begin the animation. |
+|---------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`clean_up_from_scene`](#manim.animation.creation.TypeWithCursor.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| [`finish`](#manim.animation.creation.TypeWithCursor.finish) | Finish the animation. |
+| `update_submobject_list` | |
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(text, cursor, buff=0.1, keep_cursor_y=True, leave_cursor_on=True, time_per_char=0.1, reverse_rate_function=False, introducer=True, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+ * **cursor** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **buff** (*float*)
+ * **keep_cursor_y** (*bool*)
+ * **leave_cursor_on** (*bool*)
+ * **time_per_char** (*float*)
+* **Return type:**
+ None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+ None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+ **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.Uncreate.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.Uncreate.md
new file mode 100644
index 0000000000000000000000000000000000000000..ccc886e5c50fc3f7f4299296532e27e1b1a5c655
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.Uncreate.md
@@ -0,0 +1,59 @@
+# Uncreate
+
+Qualified name: `manim.animation.creation.Uncreate`
+
+### *class* Uncreate(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create)
+
+Like [`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create) but in reverse.
+
+### Examples
+
+
+
+#### SEE ALSO
+[`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create)
+
+### Methods
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+* **Parameters:**
+ * **mobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject*)
+ * **reverse_rate_function** (*bool*)
+ * **remover** (*bool*)
+
+#### \_original_\_init_\_(mobject, reverse_rate_function=True, remover=True, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject*)
+ * **reverse_rate_function** (*bool*)
+ * **remover** (*bool*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.UntypeWithCursor.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.UntypeWithCursor.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a7744524533dbad6f591d208d685101c6da7d21
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.UntypeWithCursor.md
@@ -0,0 +1,85 @@
+# UntypeWithCursor
+
+Qualified name: `manim.animation.creation.UntypeWithCursor`
+
+### *class* UntypeWithCursor(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`TypeWithCursor`](manim.animation.creation.TypeWithCursor.md#manim.animation.creation.TypeWithCursor)
+
+Similar to [`RemoveTextLetterByLetter`](manim.animation.creation.RemoveTextLetterByLetter.md#manim.animation.creation.RemoveTextLetterByLetter) , but with an additional cursor mobject at the end.
+
+* **Parameters:**
+ * **time_per_char** (*float*) – Frequency of appearance of the letters.
+ * **cursor** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *None*) – [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) shown after the last added letter.
+ * **buff** – Controls how far away the cursor is to the right of the last added letter.
+ * **keep_cursor_y** – If `True`, the cursor’s y-coordinate is set to the center of the `Text` and remains the same throughout the animation. Otherwise, it is set to the center of the last added letter.
+ * **leave_cursor_on** – Whether to show the cursor after the animation.
+ * **tip::** ( *..*) – This is currently only possible for class:~.Text and not for class:~.MathTex.
+ * **text** ([*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+
+### Examples
+
+
+
+### Tests
+
+Check that creating empty [`Write`](#manim.animation.creation.Write) animations works:
+
+```default
+>>> from manim import Write, Text
+>>> Write(Text(''))
+Write(Text(''))
+```
+
+### Methods
+
+| [`begin`](#manim.animation.creation.Write.begin) | Begin the animation. |
+|----------------------------------------------------|------------------------|
+| [`finish`](#manim.animation.creation.Write.finish) | Finish the animation. |
+| `reverse_submobjects` | |
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+* **Parameters:**
+ * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject*)
+ * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+ * **reverse** (*bool*)
+
+#### \_original_\_init_\_(vmobject, rate_func=, reverse=False, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *OpenGLVMobject*)
+ * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+ * **reverse** (*bool*)
+* **Return type:**
+ None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+ None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.md
new file mode 100644
index 0000000000000000000000000000000000000000..c299da72638a77eb16195ceab4b70cea84a80f48
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.creation.md
@@ -0,0 +1,29 @@
+# creation
+
+Animate the display or removal of a mobject from a scene.
+
+
+
+### Classes
+
+| [`AddTextLetterByLetter`](manim.animation.creation.AddTextLetterByLetter.md#manim.animation.creation.AddTextLetterByLetter) | Show a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) letter by letter on the scene. |
+|--------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`AddTextWordByWord`](manim.animation.creation.AddTextWordByWord.md#manim.animation.creation.AddTextWordByWord) | Show a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) word by word on the scene. |
+| [`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create) | Incrementally show a VMobject. |
+| [`DrawBorderThenFill`](manim.animation.creation.DrawBorderThenFill.md#manim.animation.creation.DrawBorderThenFill) | Draw the border first and then show the fill. |
+| [`RemoveTextLetterByLetter`](manim.animation.creation.RemoveTextLetterByLetter.md#manim.animation.creation.RemoveTextLetterByLetter) | Remove a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) letter by letter from the scene. |
+| [`ShowIncreasingSubsets`](manim.animation.creation.ShowIncreasingSubsets.md#manim.animation.creation.ShowIncreasingSubsets) | Show one submobject at a time, leaving all previous ones displayed on screen. |
+| [`ShowPartial`](manim.animation.creation.ShowPartial.md#manim.animation.creation.ShowPartial) | Abstract class for Animations that show the VMobject partially. |
+| [`ShowSubmobjectsOneByOne`](manim.animation.creation.ShowSubmobjectsOneByOne.md#manim.animation.creation.ShowSubmobjectsOneByOne) | Show one submobject at a time, removing all previously displayed ones from screen. |
+| [`SpiralIn`](manim.animation.creation.SpiralIn.md#manim.animation.creation.SpiralIn) | Create the Mobject with sub-Mobjects flying in on spiral trajectories. |
+| [`TypeWithCursor`](manim.animation.creation.TypeWithCursor.md#manim.animation.creation.TypeWithCursor) | Similar to [`AddTextLetterByLetter`](manim.animation.creation.AddTextLetterByLetter.md#manim.animation.creation.AddTextLetterByLetter) , but with an additional cursor mobject at the end. |
+| [`Uncreate`](manim.animation.creation.Uncreate.md#manim.animation.creation.Uncreate) | Like [`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create) but in reverse. |
+| [`UntypeWithCursor`](manim.animation.creation.UntypeWithCursor.md#manim.animation.creation.UntypeWithCursor) | Similar to [`RemoveTextLetterByLetter`](manim.animation.creation.RemoveTextLetterByLetter.md#manim.animation.creation.RemoveTextLetterByLetter) , but with an additional cursor mobject at the end. |
+| [`Unwrite`](manim.animation.creation.Unwrite.md#manim.animation.creation.Unwrite) | Simulate erasing by hand a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) or a [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject). |
+| [`Write`](manim.animation.creation.Write.md#manim.animation.creation.Write) | Simulate hand-writing a [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) or hand-drawing a [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject). |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.fading.FadeIn.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.fading.FadeIn.md
new file mode 100644
index 0000000000000000000000000000000000000000..f0372547b0d4b1af853357e4ed08195dba1ea224
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.fading.FadeIn.md
@@ -0,0 +1,86 @@
+# FadeIn
+
+Qualified name: `manim.animation.fading.FadeIn`
+
+### *class* FadeIn(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: `_Fade`
+
+Fade in [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) s.
+
+* **Parameters:**
+ * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to be faded in.
+ * **shift** – The vector by which the mobject shifts while being faded in.
+ * **target_position** – The position from which the mobject starts while being faded in. In case
+ another mobject is given as target position, its center is used.
+ * **scale** – The factor by which the mobject is scaled initially before being rescaling to
+ its original size while being faded in.
+
+### Examples
+
+
+
+### Methods
+
+| `create_starting_mobject` | |
+|-----------------------------|----|
+| `create_target` | |
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+
+#### \_original_\_init_\_(\*mobjects, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.fading.FadeOut.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.fading.FadeOut.md
new file mode 100644
index 0000000000000000000000000000000000000000..92a0cc7d3c7ad14e24085f05d72067c483a3f559
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.fading.FadeOut.md
@@ -0,0 +1,97 @@
+# FadeOut
+
+Qualified name: `manim.animation.fading.FadeOut`
+
+### *class* FadeOut(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: `_Fade`
+
+Fade out [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) s.
+
+* **Parameters:**
+ * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to be faded out.
+ * **shift** – The vector by which the mobject shifts while being faded out.
+ * **target_position** – The position to which the mobject moves while being faded out. In case another
+ mobject is given as target position, its center is used.
+ * **scale** – The factor by which the mobject is scaled while being faded out.
+
+### Examples
+
+
+
+### Methods
+
+| [`clean_up_from_scene`](#manim.animation.fading.FadeOut.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+|--------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|
+| `create_target` | |
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+
+#### \_original_\_init_\_(\*mobjects, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+* **Return type:**
+ None
+
+#### clean_up_from_scene(scene=None)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+ **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.fading.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.fading.md
new file mode 100644
index 0000000000000000000000000000000000000000..7b6039dd22619042f9f539af1caf4f45a2d2ad98
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.fading.md
@@ -0,0 +1,40 @@
+# fading
+
+Fading in and out of view.
+
+
+
+### Classes
+
+| [`FadeIn`](manim.animation.fading.FadeIn.md#manim.animation.fading.FadeIn) | Fade in [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) s. |
+|-------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
+| [`FadeOut`](manim.animation.fading.FadeOut.md#manim.animation.fading.FadeOut) | Fade out [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) s. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.growing.GrowArrow.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.growing.GrowArrow.md
new file mode 100644
index 0000000000000000000000000000000000000000..9b21b73264ecedc489cd5dfbc84cc722e5544ed6
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.growing.GrowArrow.md
@@ -0,0 +1,66 @@
+# GrowArrow
+
+Qualified name: `manim.animation.growing.GrowArrow`
+
+### *class* GrowArrow(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`GrowFromPoint`](manim.animation.growing.GrowFromPoint.md#manim.animation.growing.GrowFromPoint)
+
+Introduce an [`Arrow`](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow) by growing it from its start toward its tip.
+
+* **Parameters:**
+ * **arrow** ([*Arrow*](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow)) – The arrow to be introduced.
+ * **point_color** (*str*) – Initial color of the arrow before growing to its full size. Leave empty to match arrow’s color.
+
+### Examples
+
+
+
+### Methods
+
+| `create_starting_mobject` | |
+|-----------------------------|----|
+| `create_target` | |
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+
+#### \_original_\_init_\_(mobject, point, point_color=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **point** (*np.ndarray*)
+ * **point_color** (*str*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.growing.SpinInFromNothing.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.growing.SpinInFromNothing.md
new file mode 100644
index 0000000000000000000000000000000000000000..1bdd9f55044ade3673dc83f8b14c913c0b06d764
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.growing.SpinInFromNothing.md
@@ -0,0 +1,68 @@
+# SpinInFromNothing
+
+Qualified name: `manim.animation.growing.SpinInFromNothing`
+
+### *class* SpinInFromNothing(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`GrowFromCenter`](manim.animation.growing.GrowFromCenter.md#manim.animation.growing.GrowFromCenter)
+
+Introduce an [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) spinning and growing it from its center.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to be introduced.
+ * **angle** (*float*) – The amount of spinning before mobject reaches its full size. E.g. 2\*PI means
+ that the object will do one full spin before being fully introduced.
+ * **point_color** (*str*) – Initial color of the mobject before growing to its full size. Leave empty to match mobject’s color.
+
+### Examples
+
+
+
+### Classes
+
+| [`GrowArrow`](manim.animation.growing.GrowArrow.md#manim.animation.growing.GrowArrow) | Introduce an [`Arrow`](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow) by growing it from its start toward its tip. |
+|---------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|
+| [`GrowFromCenter`](manim.animation.growing.GrowFromCenter.md#manim.animation.growing.GrowFromCenter) | Introduce an [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) by growing it from its center. |
+| [`GrowFromEdge`](manim.animation.growing.GrowFromEdge.md#manim.animation.growing.GrowFromEdge) | Introduce an [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) by growing it from one of its bounding box edges. |
+| [`GrowFromPoint`](manim.animation.growing.GrowFromPoint.md#manim.animation.growing.GrowFromPoint) | Introduce an [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) by growing it from a point. |
+| [`SpinInFromNothing`](manim.animation.growing.SpinInFromNothing.md#manim.animation.growing.SpinInFromNothing) | Introduce an [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) spinning and growing it from its center. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.ApplyWave.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.ApplyWave.md
new file mode 100644
index 0000000000000000000000000000000000000000..139a932546cf0ab420d6aeee6c7eea91d49c2f52
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.ApplyWave.md
@@ -0,0 +1,89 @@
+# ApplyWave
+
+Qualified name: `manim.animation.indication.ApplyWave`
+
+### *class* ApplyWave(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Homotopy`](manim.animation.movement.Homotopy.md#manim.animation.movement.Homotopy)
+
+Send a wave through the Mobject distorting it temporarily.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject to be distorted.
+ * **direction** (*np.ndarray*) – The direction in which the wave nudges points of the shape
+ * **amplitude** (*float*) – The distance points of the shape get shifted
+ * **wave_func** (*Callable* *[* *[**float* *]* *,* *float* *]*) – The function defining the shape of one wave flank.
+ * **time_width** (*float*) – The length of the wave relative to the width of the mobject.
+ * **ripples** (*int*) – The number of ripples of the wave
+ * **run_time** (*float*) – The duration of the animation.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(mobject, time_on=0.5, time_off=0.5, blinks=1, hide_at_end=False, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **time_on** (*float*)
+ * **time_off** (*float*)
+ * **blinks** (*int*)
+ * **hide_at_end** (*bool*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.Circumscribe.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.Circumscribe.md
new file mode 100644
index 0000000000000000000000000000000000000000..f5a4ea6d118109b37c8c1d3462b00893566f5564
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.Circumscribe.md
@@ -0,0 +1,75 @@
+# Circumscribe
+
+Qualified name: `manim.animation.indication.Circumscribe`
+
+### *class* Circumscribe(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Succession`](manim.animation.composition.Succession.md#manim.animation.composition.Succession)
+
+Draw a temporary line surrounding the mobject.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject to be circumscribed.
+ * **shape** (*type*) – The shape with which to surround the given mobject. Should be either
+ [`Rectangle`](manim.mobject.geometry.polygram.Rectangle.md#manim.mobject.geometry.polygram.Rectangle) or [`Circle`](manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle)
+ * **fade_in** – Whether to make the surrounding shape to fade in. It will be drawn otherwise.
+ * **fade_out** – Whether to make the surrounding shape to fade out. It will be undrawn otherwise.
+ * **time_width** – The time_width of the drawing and undrawing. Gets ignored if either fade_in or fade_out is True.
+ * **buff** (*float*) – The distance between the surrounding shape and the given mobject.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the surrounding shape.
+ * **run_time** – The duration of the entire animation.
+ * **kwargs** – Additional arguments to be passed to the [`Succession`](manim.animation.composition.Succession.md#manim.animation.composition.Succession) constructor
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(mobject, shape=, fade_in=False, fade_out=False, time_width=0.3, buff=0.1, color=ManimColor('#FFFF00'), run_time=1, stroke_width=4, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **shape** (*type*)
+ * **buff** (*float*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.Flash.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.Flash.md
new file mode 100644
index 0000000000000000000000000000000000000000..f74a5bd03b1f0105fb1b5a95d1b352b15724716b
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.Flash.md
@@ -0,0 +1,117 @@
+# Flash
+
+Qualified name: `manim.animation.indication.Flash`
+
+### *class* Flash(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup)
+
+Send out lines in all directions.
+
+* **Parameters:**
+ * **point** (*np.ndarray* *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The center of the flash lines. If it is a `Mobject` its center will be used.
+ * **line_length** (*float*) – The length of the flash lines.
+ * **num_lines** (*int*) – The number of flash lines.
+ * **flash_radius** (*float*) – The distance from point at which the flash lines start.
+ * **line_stroke_width** (*int*) – The stroke width of the flash lines.
+ * **color** (*str*) – The color of the flash lines.
+ * **time_width** (*float*) – The time width used for the flash lines. See `ShowPassingFlash` for more details.
+ * **run_time** (*float*) – The duration of the animation.
+ * **kwargs** – Additional arguments to be passed to the [`Succession`](manim.animation.composition.Succession.md#manim.animation.composition.Succession) constructor
+
+### Examples
+
+
+
+#### SEE ALSO
+[`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create)
+
+### Methods
+
+| [`clean_up_from_scene`](#manim.animation.indication.ShowPassingFlash.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+|---------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(mobject, time_width=0.1, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+ * **time_width** (*float*)
+* **Return type:**
+ None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+ **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.ShowPassingFlashWithThinningStrokeWidth.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.ShowPassingFlashWithThinningStrokeWidth.md
new file mode 100644
index 0000000000000000000000000000000000000000..53b4a25fff2406bd34ef6a1eab449f62d3308891
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.ShowPassingFlashWithThinningStrokeWidth.md
@@ -0,0 +1,18 @@
+# ShowPassingFlashWithThinningStrokeWidth
+
+Qualified name: `manim.animation.indication.ShowPassingFlashWithThinningStrokeWidth`
+
+### *class* ShowPassingFlashWithThinningStrokeWidth(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup)
+
+### Methods
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(vmobject, n_segments=10, time_width=0.1, remover=True, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.Wiggle.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.Wiggle.md
new file mode 100644
index 0000000000000000000000000000000000000000..18f8d0121260b8abdc45a4ef571d62aafeea5188
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.indication.Wiggle.md
@@ -0,0 +1,74 @@
+# Wiggle
+
+Qualified name: `manim.animation.indication.Wiggle`
+
+### *class* Wiggle(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+Wiggle a Mobject.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject to wiggle.
+ * **scale_value** (*float*) – The factor by which the mobject will be temporarily scaled.
+ * **rotation_angle** (*float*) – The wiggle angle.
+ * **n_wiggles** (*int*) – The number of wiggles.
+ * **scale_about_point** (*np.ndarray* *|* *None*) – The point about which the mobject gets scaled.
+ * **rotate_about_point** (*np.ndarray* *|* *None*) – The point around which the mobject gets rotated.
+ * **run_time** (*float*) – The duration of the animation
+
+### Examples
+
+
+```python
+from manim import *
+
+class Indications(Scene):
+ def construct(self):
+ indications = [ApplyWave,Circumscribe,Flash,FocusOn,Indicate,ShowPassingFlash,Wiggle]
+ names = [Tex(i.__name__).scale(3) for i in indications]
+
+ self.add(names[0])
+ for i in range(len(names)):
+ if indications[i] is Flash:
+ self.play(Flash(UP))
+ elif indications[i] is ShowPassingFlash:
+ self.play(ShowPassingFlash(Underline(names[i])))
+ else:
+ self.play(indications[i](names[i]))
+ self.play(AnimationGroup(
+ FadeOut(names[i], shift=UP*1.5),
+ FadeIn(names[(i+1)%len(names)], shift=UP*1.5),
+ ))
+```
+
+
+class Indications(Scene):
+ def construct(self):
+ indications = [ApplyWave,Circumscribe,Flash,FocusOn,Indicate,ShowPassingFlash,Wiggle]
+ names = [Tex(i._\_name_\_).scale(3) for i in indications]
+
+ self.add(names[0])
+ for i in range(len(names)):
+ if indications[i] is Flash:
+ self.play(Flash(UP))
+ elif indications[i] is ShowPassingFlash:
+ self.play(ShowPassingFlash(Underline(names[i])))
+ else:
+ self.play(indications[i](names[i]))
+ self.play(AnimationGroup(
+ FadeOut(names[i], shift=UP\*1.5),
+ FadeIn(names[(i+1)%len(names)], shift=UP\*1.5),
+ ))
+
+
+
+### Classes
+
+| [`ApplyWave`](manim.animation.indication.ApplyWave.md#manim.animation.indication.ApplyWave) | Send a wave through the Mobject distorting it temporarily. |
+|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------|
+| [`Blink`](manim.animation.indication.Blink.md#manim.animation.indication.Blink) | Blink the mobject. |
+| [`Circumscribe`](manim.animation.indication.Circumscribe.md#manim.animation.indication.Circumscribe) | Draw a temporary line surrounding the mobject. |
+| [`Flash`](manim.animation.indication.Flash.md#manim.animation.indication.Flash) | Send out lines in all directions. |
+| [`FocusOn`](manim.animation.indication.FocusOn.md#manim.animation.indication.FocusOn) | Shrink a spotlight to a position. |
+| [`Indicate`](manim.animation.indication.Indicate.md#manim.animation.indication.Indicate) | Indicate a Mobject by temporarily resizing and recoloring it. |
+| [`ShowPassingFlash`](manim.animation.indication.ShowPassingFlash.md#manim.animation.indication.ShowPassingFlash) | Show only a sliver of the VMobject each frame. |
+| [`ShowPassingFlashWithThinningStrokeWidth`](manim.animation.indication.ShowPassingFlashWithThinningStrokeWidth.md#manim.animation.indication.ShowPassingFlashWithThinningStrokeWidth) | |
+| [`Wiggle`](manim.animation.indication.Wiggle.md#manim.animation.indication.Wiggle) | Wiggle a Mobject. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.movement.ComplexHomotopy.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.movement.ComplexHomotopy.md
new file mode 100644
index 0000000000000000000000000000000000000000..11ca8d6e09ddf74f39b8cbcc8c76d7d2c68f6820
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.movement.ComplexHomotopy.md
@@ -0,0 +1,29 @@
+# ComplexHomotopy
+
+Qualified name: `manim.animation.movement.ComplexHomotopy`
+
+### *class* ComplexHomotopy(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Homotopy`](manim.animation.movement.Homotopy.md#manim.animation.movement.Homotopy)
+
+Complex Homotopy a function Cx[0, 1] to C
+
+### Methods
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+* **Parameters:**
+ * **complex_homotopy** (*Callable* *[* *[**complex* *]* *,* *float* *]*)
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+
+#### \_original_\_init_\_(complex_homotopy, mobject, \*\*kwargs)
+
+Complex Homotopy a function Cx[0, 1] to C
+
+* **Parameters:**
+ * **complex_homotopy** (*Callable* *[* *[**complex* *]* *,* *float* *]*)
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.movement.Homotopy.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.movement.Homotopy.md
new file mode 100644
index 0000000000000000000000000000000000000000..335c8e81d7e25237b29c5f05b074f12fc3107709
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.movement.Homotopy.md
@@ -0,0 +1,92 @@
+# Homotopy
+
+Qualified name: `manim.animation.movement.Homotopy`
+
+### *class* Homotopy(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+A Homotopy.
+
+This is an animation transforming the points of a mobject according
+to the specified transformation function. With the parameter $t$
+moving from 0 to 1 throughout the animation and $(x, y, z)$
+describing the coordinates of the point of a mobject,
+the function passed to the `homotopy` keyword argument should
+transform the tuple $(x, y, z, t)$ to $(x', y', z')$,
+the coordinates the original point is transformed to at time $t$.
+
+* **Parameters:**
+ * **homotopy** (*Callable* *[* *[**float* *,* *float* *,* *float* *,* *float* *]* *,* *tuple* *[**float* *,* *float* *,* *float* *]* *]*) – A function mapping $(x, y, z, t)$ to $(x', y', z')$.
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject transformed under the given homotopy.
+ * **run_time** (*float*) – The run time of the animation.
+ * **apply_function_kwargs** (*dict* *[**str* *,* *Any* *]* *|* *None*) – Keyword arguments propagated to `Mobject.apply_function()`.
+ * **kwargs** – Further keyword arguments passed to the parent class.
+
+### Examples
+
+
+
+### Methods
+
+| [`add_updater`](#manim.animation.speedmodifier.ChangeSpeed.add_updater) | This static method can be used to apply speed change to updaters. |
+|---------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`begin`](#manim.animation.speedmodifier.ChangeSpeed.begin) | Begin the animation. |
+| [`clean_up_from_scene`](#manim.animation.speedmodifier.ChangeSpeed.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| [`finish`](#manim.animation.speedmodifier.ChangeSpeed.finish) | Finish the animation. |
+| [`get_scaled_total_time`](#manim.animation.speedmodifier.ChangeSpeed.get_scaled_total_time) | The time taken by the animation under the assumption that the `run_time` is 1. |
+| [`interpolate`](#manim.animation.speedmodifier.ChangeSpeed.interpolate) | Set the animation progress. |
+| `setup` | |
+| [`update_mobjects`](#manim.animation.speedmodifier.ChangeSpeed.update_mobjects) | Updates things like starting_mobject, and (for Transforms) target_mobject. |
+
+### Attributes
+
+| `dt` | |
+|------------------|----|
+| `is_changing_dt` | |
+| `run_time` | |
+
+#### \_original_\_init_\_(anim, speedinfo, rate_func=None, affects_speed_updaters=True, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **anim** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *|* *\_AnimationBuilder*)
+ * **speedinfo** (*dict* *[**float* *,* *float* *]*)
+ * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]* *|* *None*)
+ * **affects_speed_updaters** (*bool*)
+* **Return type:**
+ None
+
+#### \_setup_scene(scene)
+
+Setup up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) before starting the animation.
+
+This includes to [`add()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.add) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is an introducer.
+
+* **Parameters:**
+ **scene** – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
+
+#### *classmethod* add_updater(mobject, update_function, index=None, call_updater=False)
+
+This static method can be used to apply speed change to updaters.
+
+This updater will follow speed and rate function of any [`ChangeSpeed`](#manim.animation.speedmodifier.ChangeSpeed)
+animation that is playing with `affects_speed_updaters=True`. By default,
+updater functions added via the usual [`Mobject.add_updater()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.add_updater) method
+do not respect the change of animation speed.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject to which the updater should be attached.
+ * **update_function** (*Updater*) – The function that is called whenever a new frame is rendered.
+ * **index** (*int* *|* *None*) – The position in the list of the mobject’s updaters at which the
+ function should be inserted.
+ * **call_updater** (*bool*) – If `True`, calls the update function when attaching it to the
+ mobject.
+
+#### SEE ALSO
+[`ChangeSpeed`](#manim.animation.speedmodifier.ChangeSpeed), [`Mobject.add_updater()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.add_updater)
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+ None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+ **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
+
+#### finish()
+
+Finish the animation.
+
+This method gets called when the animation is over.
+
+* **Return type:**
+ None
+
+#### get_scaled_total_time()
+
+The time taken by the animation under the assumption that the `run_time` is 1.
+
+* **Return type:**
+ float
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+ **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+ the end.
+* **Return type:**
+ None
+
+#### update_mobjects(dt)
+
+Updates things like starting_mobject, and (for
+Transforms) target_mobject. Note, since typically
+(always?) self.mobject will have its updating
+suspended during the animation, this will do
+nothing to self.mobject.
+
+* **Parameters:**
+ **dt** (*float*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.speedmodifier.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.speedmodifier.md
new file mode 100644
index 0000000000000000000000000000000000000000..f0d7d3f7c34caed5c4b1432f64d4263375a69380
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.speedmodifier.md
@@ -0,0 +1,8 @@
+# speedmodifier
+
+Utilities for modifying the speed at which animations are played.
+
+### Classes
+
+| [`ChangeSpeed`](manim.animation.speedmodifier.ChangeSpeed.md#manim.animation.speedmodifier.ChangeSpeed) | Modifies the speed of passed animation. |
+|-----------------------------------------------------------------------------------------------------------|-------------------------------------------|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.ApplyComplexFunction.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.ApplyComplexFunction.md
new file mode 100644
index 0000000000000000000000000000000000000000..e8cae65c2c141b32a5daabed466043eb72cfd73f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.ApplyComplexFunction.md
@@ -0,0 +1,29 @@
+# ApplyComplexFunction
+
+Qualified name: `manim.animation.transform.ApplyComplexFunction`
+
+### *class* ApplyComplexFunction(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`ApplyMethod`](manim.animation.transform.ApplyMethod.md#manim.animation.transform.ApplyMethod)
+
+### Methods
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+* **Parameters:**
+ * **function** (*types.MethodType*)
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+
+#### \_original_\_init_\_(function, mobject, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **function** (*MethodType*)
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.ApplyFunction.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.ApplyFunction.md
new file mode 100644
index 0000000000000000000000000000000000000000..192805464052e7e7e09718c388e8a0fec718cc0a
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.ApplyFunction.md
@@ -0,0 +1,32 @@
+# ApplyFunction
+
+Qualified name: `manim.animation.transform.ApplyFunction`
+
+### *class* ApplyFunction(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Transform`](manim.animation.transform.Transform.md#manim.animation.transform.Transform)
+
+### Methods
+
+| `create_target` | |
+|-------------------|----|
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+* **Parameters:**
+ * **function** (*types.MethodType*)
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+
+#### \_original_\_init_\_(function, mobject, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **function** (*MethodType*)
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.ApplyMatrix.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.ApplyMatrix.md
new file mode 100644
index 0000000000000000000000000000000000000000..26e0eff8b14b42e3b0781b5bee6c5281b47a3c69
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.ApplyMatrix.md
@@ -0,0 +1,65 @@
+# ApplyMatrix
+
+Qualified name: `manim.animation.transform.ApplyMatrix`
+
+### *class* ApplyMatrix(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`ApplyPointwiseFunction`](manim.animation.transform.ApplyPointwiseFunction.md#manim.animation.transform.ApplyPointwiseFunction)
+
+Applies a matrix transform to an mobject.
+
+* **Parameters:**
+ * **matrix** (*np.ndarray*) – The transformation matrix.
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+ * **about_point** (*np.ndarray*) – The origin point for the transform. Defaults to `ORIGIN`.
+ * **kwargs** – Further keyword arguments that are passed to [`ApplyPointwiseFunction`](manim.animation.transform.ApplyPointwiseFunction.md#manim.animation.transform.ApplyPointwiseFunction).
+
+### Examples
+
+
+```python
+from manim import *
+
+class CounterclockwiseTransform_vs_Transform(Scene):
+ def construct(self):
+ # set up the numbers
+ c_transform = VGroup(DecimalNumber(number=3.141, num_decimal_places=3), DecimalNumber(number=1.618, num_decimal_places=3))
+ text_1 = Text("CounterclockwiseTransform", color=RED)
+ c_transform.add(text_1)
+
+ transform = VGroup(DecimalNumber(number=1.618, num_decimal_places=3), DecimalNumber(number=3.141, num_decimal_places=3))
+ text_2 = Text("Transform", color=BLUE)
+ transform.add(text_2)
+
+ ints = VGroup(c_transform, transform)
+ texts = VGroup(text_1, text_2).scale(0.75)
+ c_transform.arrange(direction=UP, buff=1)
+ transform.arrange(direction=UP, buff=1)
+
+ ints.arrange(buff=2)
+ self.add(ints, texts)
+
+ # The mobs move in clockwise direction for ClockwiseTransform()
+ self.play(CounterclockwiseTransform(c_transform[0], c_transform[1]))
+
+ # The mobs move straight up for Transform()
+ self.play(Transform(transform[0], transform[1]))
+```
+
+
+class CounterclockwiseTransform_vs_Transform(Scene):
+ def construct(self):
+ # set up the numbers
+ c_transform = VGroup(DecimalNumber(number=3.141, num_decimal_places=3), DecimalNumber(number=1.618, num_decimal_places=3))
+ text_1 = Text("CounterclockwiseTransform", color=RED)
+ c_transform.add(text_1)
+
+ transform = VGroup(DecimalNumber(number=1.618, num_decimal_places=3), DecimalNumber(number=3.141, num_decimal_places=3))
+ text_2 = Text("Transform", color=BLUE)
+ transform.add(text_2)
+
+ ints = VGroup(c_transform, transform)
+ texts = VGroup(text_1, text_2).scale(0.75)
+ c_transform.arrange(direction=UP, buff=1)
+ transform.arrange(direction=UP, buff=1)
+
+ ints.arrange(buff=2)
+ self.add(ints, texts)
+
+ # The mobs move in clockwise direction for ClockwiseTransform()
+ self.play(CounterclockwiseTransform(c_transform[0], c_transform[1]))
+
+ # The mobs move straight up for Transform()
+ self.play(Transform(transform[0], transform[1]))
+
+
+
+### Methods
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **target_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **path_arc** (*float*)
+
+#### \_original_\_init_\_(mobject, target_mobject, path_arc=3.141592653589793, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **target_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **path_arc** (*float*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.CyclicReplace.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.CyclicReplace.md
new file mode 100644
index 0000000000000000000000000000000000000000..f39a654d7ba95e066e4335f8dac9f626ca9277f8
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.CyclicReplace.md
@@ -0,0 +1,77 @@
+# CyclicReplace
+
+Qualified name: `manim.animation.transform.CyclicReplace`
+
+### *class* CyclicReplace(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Transform`](manim.animation.transform.Transform.md#manim.animation.transform.Transform)
+
+An animation moving mobjects cyclically.
+
+In particular, this means: the first mobject takes the place
+of the second mobject, the second one takes the place of
+the third mobject, and so on. The last mobject takes the
+place of the first one.
+
+* **Parameters:**
+ * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – List of mobjects to be transformed.
+ * **path_arc** (*float*) – The angle of the arc (in radians) that the mobjects will follow to reach
+ their target.
+ * **kwargs** – Further keyword arguments that are passed to [`Transform`](manim.animation.transform.Transform.md#manim.animation.transform.Transform).
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **color** (*str*)
+
+#### \_original_\_init_\_(mobject, color, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **color** (*str*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.FadeTransform.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.FadeTransform.md
new file mode 100644
index 0000000000000000000000000000000000000000..b5ffce9b25c361e0ed48857f098b96f24ded5e8a
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.FadeTransform.md
@@ -0,0 +1,127 @@
+# FadeTransform
+
+Qualified name: `manim.animation.transform.FadeTransform`
+
+### *class* FadeTransform(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Transform`](manim.animation.transform.Transform.md#manim.animation.transform.Transform)
+
+Fades one mobject into another.
+
+* **Parameters:**
+ * **mobject** – The starting [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+ * **target_mobject** – The target [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+ * **stretch** – Controls whether the target [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) is stretched during
+ the animation. Default: `True`.
+ * **dim_to_match** – If the target mobject is not stretched automatically, this allows
+ to adjust the initial scale of the target [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) while
+ it is shifted in. Setting this to 0, 1, and 2, respectively,
+ matches the length of the target with the length of the starting
+ [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) in x, y, and z direction, respectively.
+ * **kwargs** – Further keyword arguments are passed to the parent class.
+
+### Examples
+
+
+```python
+from manim import *
+
+class DifferentFadeTransforms(Scene):
+ def construct(self):
+ starts = [Rectangle(width=4, height=1) for _ in range(3)]
+ VGroup(*starts).arrange(DOWN, buff=1).shift(3*LEFT)
+ targets = [Circle(fill_opacity=1).scale(0.25) for _ in range(3)]
+ VGroup(*targets).arrange(DOWN, buff=1).shift(3*RIGHT)
+
+ self.play(*[FadeIn(s) for s in starts])
+ self.play(
+ FadeTransform(starts[0], targets[0], stretch=True),
+ FadeTransform(starts[1], targets[1], stretch=False, dim_to_match=0),
+ FadeTransform(starts[2], targets[2], stretch=False, dim_to_match=1)
+ )
+
+ self.play(*[FadeOut(mobj) for mobj in self.mobjects])
+```
+
+
+class DifferentFadeTransforms(Scene):
+ def construct(self):
+ starts = [Rectangle(width=4, height=1) for \_ in range(3)]
+ VGroup(\*starts).arrange(DOWN, buff=1).shift(3\*LEFT)
+ targets = [Circle(fill_opacity=1).scale(0.25) for \_ in range(3)]
+ VGroup(\*targets).arrange(DOWN, buff=1).shift(3\*RIGHT)
+
+ self.play(\*[FadeIn(s) for s in starts])
+ self.play(
+ FadeTransform(starts[0], targets[0], stretch=True),
+ FadeTransform(starts[1], targets[1], stretch=False, dim_to_match=0),
+ FadeTransform(starts[2], targets[2], stretch=False, dim_to_match=1)
+ )
+
+ self.play(\*[FadeOut(mobj) for mobj in self.mobjects])
+
+
+
+### Methods
+
+| [`begin`](#manim.animation.transform.FadeTransform.begin) | Initial setup for the animation. |
+|---------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`clean_up_from_scene`](#manim.animation.transform.FadeTransform.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| `get_all_families_zipped` | |
+| [`get_all_mobjects`](#manim.animation.transform.FadeTransform.get_all_mobjects) | Get all mobjects involved in the animation. |
+| [`ghost_to`](#manim.animation.transform.FadeTransform.ghost_to) | Replaces the source by the target and sets the opacity to 0. |
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+
+#### \_original_\_init_\_(mobject, target_mobject, stretch=True, dim_to_match=1, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+#### begin()
+
+Initial setup for the animation.
+
+The mobject to which this animation is bound is a group consisting of
+both the starting and the ending mobject. At the start, the ending
+mobject replaces the starting mobject (and is completely faded). In the
+end, it is set to be the other way around.
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+ **scene** – The scene the animation should be cleaned up from.
+
+#### get_all_mobjects()
+
+Get all mobjects involved in the animation.
+
+Ordering must match the ordering of arguments to interpolate_submobject
+
+* **Returns:**
+ The sequence of mobjects.
+* **Return type:**
+ Sequence[[Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)]
+
+#### ghost_to(source, target)
+
+Replaces the source by the target and sets the opacity to 0.
+
+If the provided target has no points, and thus a location of [0, 0, 0]
+the source will simply fade out where it currently is.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.FadeTransformPieces.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.FadeTransformPieces.md
new file mode 100644
index 0000000000000000000000000000000000000000..073ee90952c982f97b0a06f056e1a00e65cb1dae
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.FadeTransformPieces.md
@@ -0,0 +1,94 @@
+# FadeTransformPieces
+
+Qualified name: `manim.animation.transform.FadeTransformPieces`
+
+### *class* FadeTransformPieces(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`FadeTransform`](manim.animation.transform.FadeTransform.md#manim.animation.transform.FadeTransform)
+
+Fades submobjects of one mobject into submobjects of another one.
+
+#### SEE ALSO
+[`FadeTransform`](manim.animation.transform.FadeTransform.md#manim.animation.transform.FadeTransform)
+
+### Examples
+
+
+
+### Methods
+
+| [`begin`](#manim.animation.transform.FadeTransformPieces.begin) | Initial setup for the animation. |
+|-----------------------------------------------------------------------|--------------------------------------------------------------------------------------|
+| [`ghost_to`](#manim.animation.transform.FadeTransformPieces.ghost_to) | Replaces the source submobjects by the target submobjects and sets the opacity to 0. |
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+
+#### \_original_\_init_\_(mobject, target_mobject, stretch=True, dim_to_match=1, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+#### begin()
+
+Initial setup for the animation.
+
+The mobject to which this animation is bound is a group consisting of
+both the starting and the ending mobject. At the start, the ending
+mobject replaces the starting mobject (and is completely faded). In the
+end, it is set to be the other way around.
+
+#### ghost_to(source, target)
+
+Replaces the source submobjects by the target submobjects and sets
+the opacity to 0.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.MoveToTarget.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.MoveToTarget.md
new file mode 100644
index 0000000000000000000000000000000000000000..db2cac7b7a8e6c04d0aa8a0a3d7b12e97759dc2c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.MoveToTarget.md
@@ -0,0 +1,76 @@
+# MoveToTarget
+
+Qualified name: `manim.animation.transform.MoveToTarget`
+
+### *class* MoveToTarget(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Transform`](manim.animation.transform.Transform.md#manim.animation.transform.Transform)
+
+Transforms a mobject to the mobject stored in its `target` attribute.
+
+After calling the `generate_target()` method, the `target`
+attribute of the mobject is populated with a copy of it. After modifying the attribute,
+playing the [`MoveToTarget`](#manim.animation.transform.MoveToTarget) animation transforms the original mobject
+into the modified one stored in the `target` attribute.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+* **Parameters:**
+ **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+
+#### \_original_\_init_\_(mobject, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.Swap.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.Swap.md
new file mode 100644
index 0000000000000000000000000000000000000000..a163df2732307fcb1feede432603d9a615946846
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.Swap.md
@@ -0,0 +1,29 @@
+# Swap
+
+Qualified name: `manim.animation.transform.Swap`
+
+### *class* Swap(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`CyclicReplace`](manim.animation.transform.CyclicReplace.md#manim.animation.transform.CyclicReplace)
+
+### Methods
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+* **Parameters:**
+ * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **path_arc** (*float*)
+
+#### \_original_\_init_\_(\*mobjects, path_arc=1.5707963267948966, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **path_arc** (*float*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.Transform.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.Transform.md
new file mode 100644
index 0000000000000000000000000000000000000000..980d2a8ab1957c447a93832dbc62bc34239a2e12
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.Transform.md
@@ -0,0 +1,188 @@
+# Transform
+
+Qualified name: `manim.animation.transform.Transform`
+
+### *class* Transform(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+A Transform transforms a Mobject into a target Mobject.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* *None*) – The [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) to be transformed. It will be mutated to become the `target_mobject`.
+ * **target_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* *None*) – The target of the transformation.
+ * **path_func** (*Callable* *|* *None*) – A function defining the path that the points of the `mobject` are being moved
+ along until they match the points of the `target_mobject`, see [`utils.paths`](manim.utils.paths.md#module-manim.utils.paths).
+ * **path_arc** (*float*) – The arc angle (in radians) that the points of `mobject` will follow to reach
+ the points of the target if using a circular path arc, see `path_arc_centers`.
+ See also [`manim.utils.paths.path_along_arc()`](manim.utils.paths.md#manim.utils.paths.path_along_arc).
+ * **path_arc_axis** (*np.ndarray*) – The axis to rotate along if using a circular path arc, see `path_arc_centers`.
+ * **path_arc_centers** (*np.ndarray*) –
+
+ The center of the circular arcs along which the points of `mobject` are
+ moved by the transformation.
+
+ If this is set and `path_func` is not set, then a `path_along_circles` path will be generated
+ using the `path_arc` parameters and stored in `path_func`. If `path_func` is set, this and the
+ other `path_arc` fields are set as attributes, but a `path_func` is not generated from it.
+ * **replace_mobject_with_target_in_scene** (*bool*) –
+
+ Controls which mobject is replaced when the transformation is complete.
+
+ If set to True, `mobject` will be removed from the scene and `target_mobject` will
+ replace it. Otherwise, `target_mobject` is never added and `mobject` just takes its shape.
+
+### Examples
+
+
+```python
+from manim import *
+
+class TransformPathArc(Scene):
+ def construct(self):
+ def make_arc_path(start, end, arc_angle):
+ points = []
+ p_fn = path_along_arc(arc_angle)
+ # alpha animates between 0.0 and 1.0, where 0.0
+ # is the beginning of the animation and 1.0 is the end.
+ for alpha in range(0, 11):
+ points.append(p_fn(start, end, alpha / 10.0))
+ path = VMobject(stroke_color=YELLOW)
+ path.set_points_smoothly(points)
+ return path
+
+ left = Circle(stroke_color=BLUE_E, fill_opacity=1.0, radius=0.5).move_to(LEFT * 2)
+ colors = [TEAL_A, TEAL_B, TEAL_C, TEAL_D, TEAL_E, GREEN_A]
+ # Positive angles move counter-clockwise, negative angles move clockwise.
+ examples = [-90, 0, 30, 90, 180, 270]
+ anims = []
+ for idx, angle in enumerate(examples):
+ left_c = left.copy().shift((3 - idx) * UP)
+ left_c.fill_color = colors[idx]
+ right_c = left_c.copy().shift(4 * RIGHT)
+ path_arc = make_arc_path(left_c.get_center(), right_c.get_center(),
+ arc_angle=angle * DEGREES)
+ desc = Text('%d°' % examples[idx]).next_to(left_c, LEFT)
+ # Make the circles in front of the text in front of the arcs.
+ self.add(
+ path_arc.set_z_index(1),
+ desc.set_z_index(2),
+ left_c.set_z_index(3),
+ )
+ anims.append(Transform(left_c, right_c, path_arc=angle * DEGREES))
+
+ self.play(*anims, run_time=2)
+ self.wait()
+```
+
+
+class TransformPathArc(Scene):
+ def construct(self):
+ def make_arc_path(start, end, arc_angle):
+ points = []
+ p_fn = path_along_arc(arc_angle)
+ # alpha animates between 0.0 and 1.0, where 0.0
+ # is the beginning of the animation and 1.0 is the end.
+ for alpha in range(0, 11):
+ points.append(p_fn(start, end, alpha / 10.0))
+ path = VMobject(stroke_color=YELLOW)
+ path.set_points_smoothly(points)
+ return path
+
+ left = Circle(stroke_color=BLUE_E, fill_opacity=1.0, radius=0.5).move_to(LEFT \* 2)
+ colors = [TEAL_A, TEAL_B, TEAL_C, TEAL_D, TEAL_E, GREEN_A]
+ # Positive angles move counter-clockwise, negative angles move clockwise.
+ examples = [-90, 0, 30, 90, 180, 270]
+ anims = []
+ for idx, angle in enumerate(examples):
+ left_c = left.copy().shift((3 - idx) \* UP)
+ left_c.fill_color = colors[idx]
+ right_c = left_c.copy().shift(4 \* RIGHT)
+ path_arc = make_arc_path(left_c.get_center(), right_c.get_center(),
+ arc_angle=angle \* DEGREES)
+ desc = Text('%d°' % examples[idx]).next_to(left_c, LEFT)
+ # Make the circles in front of the text in front of the arcs.
+ self.add(
+ path_arc.set_z_index(1),
+ desc.set_z_index(2),
+ left_c.set_z_index(3),
+ )
+ anims.append(Transform(left_c, right_c, path_arc=angle \* DEGREES))
+
+ self.play(\*anims, run_time=2)
+ self.wait()
+
+
+
+### Methods
+
+| [`begin`](#manim.animation.transform.Transform.begin) | Begin the animation. |
+|-----------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`clean_up_from_scene`](#manim.animation.transform.Transform.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+| `create_target` | |
+| `get_all_families_zipped` | |
+| [`get_all_mobjects`](#manim.animation.transform.Transform.get_all_mobjects) | Get all mobjects involved in the animation. |
+| `interpolate_submobject` | |
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+
+#### \_original_\_init_\_(mobject, target_mobject=None, path_func=None, path_arc=0, path_arc_axis=array([0., 0., 1.]), path_arc_centers=None, replace_mobject_with_target_in_scene=False, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* *None*)
+ * **target_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* *None*)
+ * **path_func** (*Callable* *|* *None*)
+ * **path_arc** (*float*)
+ * **path_arc_axis** (*ndarray*)
+ * **path_arc_centers** (*ndarray*)
+ * **replace_mobject_with_target_in_scene** (*bool*)
+* **Return type:**
+ None
+
+#### begin()
+
+Begin the animation.
+
+This method is called right as an animation is being played. As much
+initialization as possible, especially any mobject copying, should live in this
+method.
+
+* **Return type:**
+ None
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+ **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
+
+#### get_all_mobjects()
+
+Get all mobjects involved in the animation.
+
+Ordering must match the ordering of arguments to interpolate_submobject
+
+* **Returns:**
+ The sequence of mobjects.
+* **Return type:**
+ Sequence[[Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)]
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.TransformAnimations.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.TransformAnimations.md
new file mode 100644
index 0000000000000000000000000000000000000000..71dc8efa9370870e45aa51c09b3616a826bfe8db
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.TransformAnimations.md
@@ -0,0 +1,46 @@
+# TransformAnimations
+
+Qualified name: `manim.animation.transform.TransformAnimations`
+
+### *class* TransformAnimations(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Transform`](manim.animation.transform.Transform.md#manim.animation.transform.Transform)
+
+### Methods
+
+| [`interpolate`](#manim.animation.transform.TransformAnimations.interpolate) | Set the animation progress. |
+|-------------------------------------------------------------------------------|-------------------------------|
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+* **Parameters:**
+ * **start_anim** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation))
+ * **end_anim** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation))
+ * **rate_func** (*Callable*)
+
+#### \_original_\_init_\_(start_anim, end_anim, rate_func=.result>, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **start_anim** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation))
+ * **end_anim** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation))
+ * **rate_func** (*Callable*)
+* **Return type:**
+ None
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+ **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+ the end.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.TransformFromCopy.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.TransformFromCopy.md
new file mode 100644
index 0000000000000000000000000000000000000000..c5e93c46250d656d3fb32ec8eaae234331de8e70
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.TransformFromCopy.md
@@ -0,0 +1,46 @@
+# TransformFromCopy
+
+Qualified name: `manim.animation.transform.TransformFromCopy`
+
+### *class* TransformFromCopy(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Transform`](manim.animation.transform.Transform.md#manim.animation.transform.Transform)
+
+Performs a reversed Transform
+
+### Methods
+
+| [`interpolate`](#manim.animation.transform.TransformFromCopy.interpolate) | Set the animation progress. |
+|-----------------------------------------------------------------------------|-------------------------------|
+
+### Attributes
+
+| `path_arc` | |
+|--------------|----|
+| `path_func` | |
+| `run_time` | |
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **target_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+
+#### \_original_\_init_\_(mobject, target_mobject, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **target_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+* **Return type:**
+ None
+
+#### interpolate(alpha)
+
+Set the animation progress.
+
+This method gets called for every frame during an animation.
+
+* **Parameters:**
+ **alpha** (*float*) – The relative time to set the animation to, 0 meaning the start, 1 meaning
+ the end.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.md
new file mode 100644
index 0000000000000000000000000000000000000000..88a75a7ad5e7309f10aceb17ed60efa5e73a7e5c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform.md
@@ -0,0 +1,28 @@
+# transform
+
+Animations transforming one mobject into another.
+
+### Classes
+
+| [`ApplyComplexFunction`](manim.animation.transform.ApplyComplexFunction.md#manim.animation.transform.ApplyComplexFunction) | |
+|----------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------|
+| [`ApplyFunction`](manim.animation.transform.ApplyFunction.md#manim.animation.transform.ApplyFunction) | |
+| [`ApplyMatrix`](manim.animation.transform.ApplyMatrix.md#manim.animation.transform.ApplyMatrix) | Applies a matrix transform to an mobject. |
+| [`ApplyMethod`](manim.animation.transform.ApplyMethod.md#manim.animation.transform.ApplyMethod) | Animates a mobject by applying a method. |
+| [`ApplyPointwiseFunction`](manim.animation.transform.ApplyPointwiseFunction.md#manim.animation.transform.ApplyPointwiseFunction) | Animation that applies a pointwise function to a mobject. |
+| [`ApplyPointwiseFunctionToCenter`](manim.animation.transform.ApplyPointwiseFunctionToCenter.md#manim.animation.transform.ApplyPointwiseFunctionToCenter) | |
+| [`ClockwiseTransform`](manim.animation.transform.ClockwiseTransform.md#manim.animation.transform.ClockwiseTransform) | Transforms the points of a mobject along a clockwise oriented arc. |
+| [`CounterclockwiseTransform`](manim.animation.transform.CounterclockwiseTransform.md#manim.animation.transform.CounterclockwiseTransform) | Transforms the points of a mobject along a counterclockwise oriented arc. |
+| [`CyclicReplace`](manim.animation.transform.CyclicReplace.md#manim.animation.transform.CyclicReplace) | An animation moving mobjects cyclically. |
+| [`FadeToColor`](manim.animation.transform.FadeToColor.md#manim.animation.transform.FadeToColor) | Animation that changes color of a mobject. |
+| [`FadeTransform`](manim.animation.transform.FadeTransform.md#manim.animation.transform.FadeTransform) | Fades one mobject into another. |
+| [`FadeTransformPieces`](manim.animation.transform.FadeTransformPieces.md#manim.animation.transform.FadeTransformPieces) | Fades submobjects of one mobject into submobjects of another one. |
+| [`MoveToTarget`](manim.animation.transform.MoveToTarget.md#manim.animation.transform.MoveToTarget) | Transforms a mobject to the mobject stored in its `target` attribute. |
+| [`ReplacementTransform`](manim.animation.transform.ReplacementTransform.md#manim.animation.transform.ReplacementTransform) | Replaces and morphs a mobject into a target mobject. |
+| [`Restore`](manim.animation.transform.Restore.md#manim.animation.transform.Restore) | Transforms a mobject to its last saved state. |
+| [`ScaleInPlace`](manim.animation.transform.ScaleInPlace.md#manim.animation.transform.ScaleInPlace) | Animation that scales a mobject by a certain factor. |
+| [`ShrinkToCenter`](manim.animation.transform.ShrinkToCenter.md#manim.animation.transform.ShrinkToCenter) | Animation that makes a mobject shrink to center. |
+| [`Swap`](manim.animation.transform.Swap.md#manim.animation.transform.Swap) | |
+| [`Transform`](manim.animation.transform.Transform.md#manim.animation.transform.Transform) | A Transform transforms a Mobject into a target Mobject. |
+| [`TransformAnimations`](manim.animation.transform.TransformAnimations.md#manim.animation.transform.TransformAnimations) | |
+| [`TransformFromCopy`](manim.animation.transform.TransformFromCopy.md#manim.animation.transform.TransformFromCopy) | Performs a reversed Transform |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform_matching_parts.TransformMatchingAbstractBase.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform_matching_parts.TransformMatchingAbstractBase.md
new file mode 100644
index 0000000000000000000000000000000000000000..3e4013eb9e7240ce966adb4359e11ff9fb371304
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform_matching_parts.TransformMatchingAbstractBase.md
@@ -0,0 +1,75 @@
+# TransformMatchingAbstractBase
+
+Qualified name: `manim.animation.transform\_matching\_parts.TransformMatchingAbstractBase`
+
+### *class* TransformMatchingAbstractBase(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup)
+
+Abstract base class for transformations that keep track of matching parts.
+
+Subclasses have to implement the two static methods
+`get_mobject_parts()` and
+`get_mobject_key()`.
+
+Basically, this transformation first maps all submobjects returned
+by the `get_mobject_parts` method to certain keys by applying the
+`get_mobject_key` method. Then, submobjects with matching keys
+are transformed into each other.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The starting [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+ * **target_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The target [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+ * **transform_mismatches** (*bool*) – Controls whether submobjects without a matching key are transformed
+ into each other by using [`Transform`](manim.animation.transform.Transform.md#manim.animation.transform.Transform). Default: `False`.
+ * **fade_transform_mismatches** (*bool*) – Controls whether submobjects without a matching key are transformed
+ into each other by using [`FadeTransform`](manim.animation.transform.FadeTransform.md#manim.animation.transform.FadeTransform). Default: `False`.
+ * **key_map** (*dict* *|* *None*) – Optional. A dictionary mapping keys belonging to some of the starting mobject’s
+ submobjects (i.e., the return values of the `get_mobject_key` method)
+ to some keys belonging to the target mobject’s submobjects that should
+ be transformed although the keys don’t match.
+ * **kwargs** – All further keyword arguments are passed to the submobject transformations.
+
+#### NOTE
+If neither `transform_mismatches` nor `fade_transform_mismatches`
+are set to `True`, submobjects without matching keys in the starting
+mobject are faded out in the direction of the unmatched submobjects in
+the target mobject, and unmatched submobjects in the target mobject
+are faded in from the direction of the unmatched submobjects in the
+start mobject.
+
+### Methods
+
+| [`clean_up_from_scene`](#manim.animation.transform_matching_parts.TransformMatchingAbstractBase.clean_up_from_scene) | Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation. |
+|------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|
+| `get_mobject_key` | |
+| `get_mobject_parts` | |
+| `get_shape_map` | |
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+
+#### \_original_\_init_\_(mobject, target_mobject, transform_mismatches=False, fade_transform_mismatches=False, key_map=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **target_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **transform_mismatches** (*bool*)
+ * **fade_transform_mismatches** (*bool*)
+ * **key_map** (*dict* *|* *None*)
+
+#### clean_up_from_scene(scene)
+
+Clean up the [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) after finishing the animation.
+
+This includes to [`remove()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.remove) the Animation’s
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) if the animation is a remover.
+
+* **Parameters:**
+ **scene** ([*Scene*](manim.scene.scene.Scene.md#manim.scene.scene.Scene)) – The scene the animation should be cleaned up from.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform_matching_parts.TransformMatchingShapes.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform_matching_parts.TransformMatchingShapes.md
new file mode 100644
index 0000000000000000000000000000000000000000..41d225d7f7e600eaf945dfe6eb20a72809cd752b
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.transform_matching_parts.TransformMatchingShapes.md
@@ -0,0 +1,81 @@
+# TransformMatchingShapes
+
+Qualified name: `manim.animation.transform\_matching\_parts.TransformMatchingShapes`
+
+### *class* TransformMatchingShapes(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`TransformMatchingAbstractBase`](manim.animation.transform_matching_parts.TransformMatchingAbstractBase.md#manim.animation.transform_matching_parts.TransformMatchingAbstractBase)
+
+An animation trying to transform groups by matching the shape
+of their submobjects.
+
+Two submobjects match if the hash of their point coordinates after
+normalization (i.e., after translation to the origin, fixing the submobject
+height at 1 unit, and rounding the coordinates to three decimal places)
+matches.
+
+#### SEE ALSO
+[`TransformMatchingAbstractBase`](manim.animation.transform_matching_parts.TransformMatchingAbstractBase.md#manim.animation.transform_matching_parts.TransformMatchingAbstractBase)
+
+### Examples
+
+
+
+### always_rotate(mobject, rate=0.3490658503988659, \*\*kwargs)
+
+A mobject which is continuously rotated at a certain rate.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject to be rotated.
+ * **rate** (*float*) – The angle which the mobject is rotated by
+ over one second.
+ * **kwags** – Further arguments to be passed to [`Mobject.rotate()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.rotate).
+* **Return type:**
+ [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+### Examples
+
+
+```python
+from manim import *
+
+class SpinningTriangle(Scene):
+ def construct(self):
+ tri = Triangle().set_fill(opacity=1).set_z_index(2)
+ sq = Square().to_edge(LEFT)
+
+ # will keep spinning while there is an animation going on
+ always_rotate(tri, rate=2*PI, about_point=ORIGIN)
+
+ self.add(tri, sq)
+ self.play(sq.animate.to_edge(RIGHT), rate_func=linear, run_time=1)
+```
+
+
+class SpinningTriangle(Scene):
+ def construct(self):
+ tri = Triangle().set_fill(opacity=1).set_z_index(2)
+ sq = Square().to_edge(LEFT)
+
+ # will keep spinning while there is an animation going on
+ always_rotate(tri, rate=2\*PI, about_point=ORIGIN)
+
+ self.add(tri, sq)
+ self.play(sq.animate.to_edge(RIGHT), rate_func=linear, run_time=1)
+
+
+
+### always_shift(mobject, direction=array([1., 0., 0.]), rate=0.1)
+
+A mobject which is continuously shifted along some direction
+at a certain rate.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject to shift.
+ * **direction** (*ndarray* *[**float64* *]*) – The direction to shift. The vector is normalized, the specified magnitude
+ is not relevant.
+ * **rate** (*float*) – Length in Manim units which the mobject travels in one
+ second along the specified direction.
+* **Return type:**
+ [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+### Examples
+
+
+* **Parameters:**
+ * **animation** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation))
+ * **cycle** (*bool*)
+ * **delay** (*float*)
+* **Return type:**
+ [Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.updaters.update.MaintainPositionRelativeTo.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.updaters.update.MaintainPositionRelativeTo.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac2886707932db9512c39be3293f25163f775526
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.updaters.update.MaintainPositionRelativeTo.md
@@ -0,0 +1,41 @@
+# MaintainPositionRelativeTo
+
+Qualified name: `manim.animation.updaters.update.MaintainPositionRelativeTo`
+
+### *class* MaintainPositionRelativeTo(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+### Methods
+
+| [`interpolate_mobject`](#manim.animation.updaters.update.MaintainPositionRelativeTo.interpolate_mobject) | Interpolates the mobject of the `Animation` based on alpha value. |
+|------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------|
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **tracked_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+
+#### \_original_\_init_\_(mobject, tracked_mobject, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **tracked_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+* **Return type:**
+ None
+
+#### interpolate_mobject(alpha)
+
+Interpolates the mobject of the `Animation` based on alpha value.
+
+* **Parameters:**
+ **alpha** (*float*) – A float between 0 and 1 expressing the ratio to which the animation
+ is completed. For example, alpha-values of 0, 0.5, and 1 correspond
+ to the animation being completed 0%, 50%, and 100%, respectively.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.updaters.update.UpdateFromAlphaFunc.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.updaters.update.UpdateFromAlphaFunc.md
new file mode 100644
index 0000000000000000000000000000000000000000..eb9bcb4a1e54838bb98c0957f665bc554c41e2b3
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.updaters.update.UpdateFromAlphaFunc.md
@@ -0,0 +1,43 @@
+# UpdateFromAlphaFunc
+
+Qualified name: `manim.animation.updaters.update.UpdateFromAlphaFunc`
+
+### *class* UpdateFromAlphaFunc(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`UpdateFromFunc`](manim.animation.updaters.update.UpdateFromFunc.md#manim.animation.updaters.update.UpdateFromFunc)
+
+### Methods
+
+| [`interpolate_mobject`](#manim.animation.updaters.update.UpdateFromAlphaFunc.interpolate_mobject) | Interpolates the mobject of the `Animation` based on alpha value. |
+|-----------------------------------------------------------------------------------------------------|---------------------------------------------------------------------|
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **update_function** (*Callable* *[* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]* *,* *Any* *]*)
+ * **suspend_mobject_updating** (*bool*)
+
+#### \_original_\_init_\_(mobject, update_function, suspend_mobject_updating=False, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **update_function** (*Callable* *[* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]* *,* *Any* *]*)
+ * **suspend_mobject_updating** (*bool*)
+* **Return type:**
+ None
+
+#### interpolate_mobject(alpha)
+
+Interpolates the mobject of the `Animation` based on alpha value.
+
+* **Parameters:**
+ **alpha** (*float*) – A float between 0 and 1 expressing the ratio to which the animation
+ is completed. For example, alpha-values of 0, 0.5, and 1 correspond
+ to the animation being completed 0%, 50%, and 100%, respectively.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.updaters.update.UpdateFromFunc.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.updaters.update.UpdateFromFunc.md
new file mode 100644
index 0000000000000000000000000000000000000000..ddb54dd75e02ec0e8fe391526e2ffefa2c0068f6
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.updaters.update.UpdateFromFunc.md
@@ -0,0 +1,47 @@
+# UpdateFromFunc
+
+Qualified name: `manim.animation.updaters.update.UpdateFromFunc`
+
+### *class* UpdateFromFunc(mobject=None, \*args, use_override=True, \*\*kwargs)
+
+Bases: [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+update_function of the form func(mobject), presumably
+to be used when the state of one mobject is dependent
+on another simultaneously animated mobject
+
+### Methods
+
+| [`interpolate_mobject`](#manim.animation.updaters.update.UpdateFromFunc.interpolate_mobject) | Interpolates the mobject of the `Animation` based on alpha value. |
+|------------------------------------------------------------------------------------------------|---------------------------------------------------------------------|
+
+### Attributes
+
+| `run_time` | |
+|--------------|----|
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **update_function** (*Callable* *[* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]* *,* *Any* *]*)
+ * **suspend_mobject_updating** (*bool*)
+
+#### \_original_\_init_\_(mobject, update_function, suspend_mobject_updating=False, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **update_function** (*Callable* *[* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]* *,* *Any* *]*)
+ * **suspend_mobject_updating** (*bool*)
+* **Return type:**
+ None
+
+#### interpolate_mobject(alpha)
+
+Interpolates the mobject of the `Animation` based on alpha value.
+
+* **Parameters:**
+ **alpha** (*float*) – A float between 0 and 1 expressing the ratio to which the animation
+ is completed. For example, alpha-values of 0, 0.5, and 1 correspond
+ to the animation being completed 0%, 50%, and 100%, respectively.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.animation.updaters.update.md b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.updaters.update.md
new file mode 100644
index 0000000000000000000000000000000000000000..fb857daa5867762834e90c376344d34445c9c033
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.animation.updaters.update.md
@@ -0,0 +1,10 @@
+# update
+
+Animations that update mobjects.
+
+### Classes
+
+| [`MaintainPositionRelativeTo`](manim.animation.updaters.update.MaintainPositionRelativeTo.md#manim.animation.updaters.update.MaintainPositionRelativeTo) | |
+|------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`UpdateFromAlphaFunc`](manim.animation.updaters.update.UpdateFromAlphaFunc.md#manim.animation.updaters.update.UpdateFromAlphaFunc) | |
+| [`UpdateFromFunc`](manim.animation.updaters.update.UpdateFromFunc.md#manim.animation.updaters.update.UpdateFromFunc) | update_function of the form func(mobject), presumably to be used when the state of one mobject is dependent on another simultaneously animated mobject |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.camera.BackgroundColoredVMobjectDisplayer.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.camera.BackgroundColoredVMobjectDisplayer.md
new file mode 100644
index 0000000000000000000000000000000000000000..4cacc6cbaf3fcb588deea39c8a79d2516d0b6e67
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.camera.BackgroundColoredVMobjectDisplayer.md
@@ -0,0 +1,70 @@
+# BackgroundColoredVMobjectDisplayer
+
+Qualified name: `manim.camera.camera.BackgroundColoredVMobjectDisplayer`
+
+### *class* BackgroundColoredVMobjectDisplayer(camera)
+
+Bases: `object`
+
+Auxiliary class that handles displaying vectorized mobjects with
+a set background image.
+
+* **Parameters:**
+ **camera** ([*Camera*](manim.camera.camera.Camera.md#manim.camera.camera.Camera)) – Camera object to use.
+
+### Methods
+
+| [`display`](#manim.camera.camera.BackgroundColoredVMobjectDisplayer.display) | Displays the colored VMobjects. |
+|--------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------|
+| [`get_background_array`](#manim.camera.camera.BackgroundColoredVMobjectDisplayer.get_background_array) | Gets the background array that has the passed file_name. |
+| `reset_pixel_array` | |
+| [`resize_background_array`](#manim.camera.camera.BackgroundColoredVMobjectDisplayer.resize_background_array) | Resizes the pixel array representing the background. |
+| [`resize_background_array_to_match`](#manim.camera.camera.BackgroundColoredVMobjectDisplayer.resize_background_array_to_match) | Resizes the background array to match the passed pixel array. |
+
+#### display(\*cvmobjects)
+
+Displays the colored VMobjects.
+
+* **Parameters:**
+ **\*cvmobjects** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The VMobjects
+* **Returns:**
+ The pixel array with the cvmobjects displayed.
+* **Return type:**
+ np.array
+
+#### get_background_array(image)
+
+Gets the background array that has the passed file_name.
+
+* **Parameters:**
+ **image** (*Image* *|* *Path* *|* *str*) – The background image or its file name.
+* **Returns:**
+ The pixel array of the image.
+* **Return type:**
+ np.ndarray
+
+#### resize_background_array(background_array, new_width, new_height, mode='RGBA')
+
+Resizes the pixel array representing the background.
+
+* **Parameters:**
+ * **background_array** (*ndarray*) – The pixel
+ * **new_width** (*float*) – The new width of the background
+ * **new_height** (*float*) – The new height of the background
+ * **mode** (*str*) – The PIL image mode, by default “RGBA”
+* **Returns:**
+ The numpy pixel array of the resized background.
+* **Return type:**
+ np.array
+
+#### resize_background_array_to_match(background_array, pixel_array)
+
+Resizes the background array to match the passed pixel array.
+
+* **Parameters:**
+ * **background_array** (*ndarray*) – The prospective pixel array.
+ * **pixel_array** (*ndarray*) – The pixel array whose width and height should be matched.
+* **Returns:**
+ The resized background array.
+* **Return type:**
+ np.array
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.camera.Camera.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.camera.Camera.md
new file mode 100644
index 0000000000000000000000000000000000000000..6f3c6d47dc6add7c10f6a5e6738307523ac29efe
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.camera.Camera.md
@@ -0,0 +1,549 @@
+# Camera
+
+Qualified name: `manim.camera.camera.Camera`
+
+### *class* Camera(background_image=None, frame_center=array([0., 0., 0.]), image_mode='RGBA', n_channels=4, pixel_array_dtype='uint8', cairo_line_width_multiple=0.01, use_z_index=True, background=None, pixel_height=None, pixel_width=None, frame_height=None, frame_width=None, frame_rate=None, background_color=None, background_opacity=None, \*\*kwargs)
+
+Bases: `object`
+
+Base camera class.
+
+This is the object which takes care of what exactly is displayed
+on screen at any given moment.
+
+* **Parameters:**
+ * **background_image** (*str* *|* *None*) – The path to an image that should be the background image.
+ If not set, the background is filled with `self.background_color`
+ * **background** (*np.ndarray* *|* *None*) – What `background` is set to. By default, `None`.
+ * **pixel_height** (*int* *|* *None*) – The height of the scene in pixels.
+ * **pixel_width** (*int* *|* *None*) – The width of the scene in pixels.
+ * **kwargs** – Additional arguments (`background_color`, `background_opacity`)
+ to be set.
+ * **frame_center** (*np.ndarray*)
+ * **image_mode** (*str*)
+ * **n_channels** (*int*)
+ * **pixel_array_dtype** (*str*)
+ * **cairo_line_width_multiple** (*float*)
+ * **use_z_index** (*bool*)
+ * **frame_height** (*float* *|* *None*)
+ * **frame_width** (*float* *|* *None*)
+ * **frame_rate** (*float* *|* *None*)
+ * **background_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **background_opacity** (*float* *|* *None*)
+
+### Methods
+
+| [`adjust_out_of_range_points`](#manim.camera.camera.Camera.adjust_out_of_range_points) | If any of the points in the passed array are out of the viable range, they are adjusted suitably. |
+|--------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`adjusted_thickness`](#manim.camera.camera.Camera.adjusted_thickness) | Computes the adjusted stroke width for a zoomed camera. |
+| [`apply_fill`](#manim.camera.camera.Camera.apply_fill) | Fills the cairo context |
+| [`apply_stroke`](#manim.camera.camera.Camera.apply_stroke) | Applies a stroke to the VMobject in the cairo context. |
+| [`cache_cairo_context`](#manim.camera.camera.Camera.cache_cairo_context) | Caches the passed Pixel array into a Cairo Context |
+| [`capture_mobject`](#manim.camera.camera.Camera.capture_mobject) | Capture mobjects by storing it in `pixel_array`. |
+| [`capture_mobjects`](#manim.camera.camera.Camera.capture_mobjects) | Capture mobjects by printing them on `pixel_array`. |
+| [`convert_pixel_array`](#manim.camera.camera.Camera.convert_pixel_array) | Converts a pixel array from values that have floats in then to proper RGB values. |
+| [`display_image_mobject`](#manim.camera.camera.Camera.display_image_mobject) | Displays an ImageMobject by changing the pixel_array suitably. |
+| [`display_multiple_background_colored_vmobjects`](#manim.camera.camera.Camera.display_multiple_background_colored_vmobjects) | Displays multiple vmobjects that have the same color as the background. |
+| [`display_multiple_image_mobjects`](#manim.camera.camera.Camera.display_multiple_image_mobjects) | Displays multiple image mobjects by modifying the passed pixel_array. |
+| [`display_multiple_non_background_colored_vmobjects`](#manim.camera.camera.Camera.display_multiple_non_background_colored_vmobjects) | Displays multiple VMobjects in the cairo context, as long as they don't have background colors. |
+| [`display_multiple_point_cloud_mobjects`](#manim.camera.camera.Camera.display_multiple_point_cloud_mobjects) | Displays multiple PMobjects by modifying the passed pixel array. |
+| [`display_multiple_vectorized_mobjects`](#manim.camera.camera.Camera.display_multiple_vectorized_mobjects) | Displays multiple VMobjects in the pixel_array |
+| [`display_point_cloud`](#manim.camera.camera.Camera.display_point_cloud) | Displays a PMobject by modifying the pixel array suitably. |
+| [`display_vectorized`](#manim.camera.camera.Camera.display_vectorized) | Displays a VMobject in the cairo context |
+| [`get_background_colored_vmobject_displayer`](#manim.camera.camera.Camera.get_background_colored_vmobject_displayer) | Returns the background_colored_vmobject_displayer if it exists or makes one and returns it if not. |
+| [`get_cached_cairo_context`](#manim.camera.camera.Camera.get_cached_cairo_context) | Returns the cached cairo context of the passed pixel array if it exists, and None if it doesn't. |
+| [`get_cairo_context`](#manim.camera.camera.Camera.get_cairo_context) | Returns the cairo context for a pixel array after caching it to self.pixel_array_to_cairo_context If that array has already been cached, it returns the cached version instead. |
+| [`get_coords_of_all_pixels`](#manim.camera.camera.Camera.get_coords_of_all_pixels) | Returns the cartesian coordinates of each pixel. |
+| [`get_fill_rgbas`](#manim.camera.camera.Camera.get_fill_rgbas) | Returns the RGBA array of the fill of the passed VMobject |
+| [`get_image`](#manim.camera.camera.Camera.get_image) | Returns an image from the passed pixel array, or from the current frame if the passed pixel array is none. |
+| [`get_mobjects_to_display`](#manim.camera.camera.Camera.get_mobjects_to_display) | Used to get the list of mobjects to display with the camera. |
+| [`get_stroke_rgbas`](#manim.camera.camera.Camera.get_stroke_rgbas) | Gets the RGBA array for the stroke of the passed VMobject. |
+| [`get_thickening_nudges`](#manim.camera.camera.Camera.get_thickening_nudges) | Determine a list of vectors used to nudge two-dimensional pixel coordinates. |
+| [`init_background`](#manim.camera.camera.Camera.init_background) | Initialize the background. |
+| [`is_in_frame`](#manim.camera.camera.Camera.is_in_frame) | Checks whether the passed mobject is in frame or not. |
+| [`make_background_from_func`](#manim.camera.camera.Camera.make_background_from_func) | Makes a pixel array for the background by using coords_to_colors_func to determine each pixel's color. |
+| [`on_screen_pixels`](#manim.camera.camera.Camera.on_screen_pixels) | Returns array of pixels that are on the screen from a given array of pixel_coordinates |
+| [`overlay_PIL_image`](#manim.camera.camera.Camera.overlay_PIL_image) | Overlays a PIL image on the passed pixel array. |
+| [`overlay_rgba_array`](#manim.camera.camera.Camera.overlay_rgba_array) | Overlays an RGBA array on top of the given Pixel array. |
+| `points_to_pixel_coords` | |
+| [`reset`](#manim.camera.camera.Camera.reset) | Resets the camera's pixel array to that of the background |
+| [`reset_pixel_shape`](#manim.camera.camera.Camera.reset_pixel_shape) | This method resets the height and width of a single pixel to the passed new_height and new_width. |
+| [`resize_frame_shape`](#manim.camera.camera.Camera.resize_frame_shape) | Changes frame_shape to match the aspect ratio of the pixels, where fixed_dimension determines whether frame_height or frame_width remains fixed while the other changes accordingly. |
+| [`set_background`](#manim.camera.camera.Camera.set_background) | Sets the background to the passed pixel_array after converting to valid RGB values. |
+| [`set_background_from_func`](#manim.camera.camera.Camera.set_background_from_func) | Sets the background to a pixel array using coords_to_colors_func to determine each pixel's color. |
+| [`set_cairo_context_color`](#manim.camera.camera.Camera.set_cairo_context_color) | Sets the color of the cairo context |
+| [`set_cairo_context_path`](#manim.camera.camera.Camera.set_cairo_context_path) | Sets a path for the cairo context with the vmobject passed |
+| `set_frame_to_background` | |
+| [`set_pixel_array`](#manim.camera.camera.Camera.set_pixel_array) | Sets the pixel array of the camera to the passed pixel array. |
+| [`thickened_coordinates`](#manim.camera.camera.Camera.thickened_coordinates) | Returns thickened coordinates for a passed array of pixel coords and a thickness to thicken by. |
+| `transform_points_pre_display` | |
+| [`type_or_raise`](#manim.camera.camera.Camera.type_or_raise) | Return the type of mobject, if it is a type that can be rendered. |
+
+### Attributes
+
+| `background_color` | |
+|----------------------|----|
+| `background_opacity` | |
+
+#### adjust_out_of_range_points(points)
+
+If any of the points in the passed array are out of
+the viable range, they are adjusted suitably.
+
+* **Parameters:**
+ **points** (*ndarray*) – The points to adjust
+* **Returns:**
+ The adjusted points.
+* **Return type:**
+ np.array
+
+#### adjusted_thickness(thickness)
+
+Computes the adjusted stroke width for a zoomed camera.
+
+* **Parameters:**
+ **thickness** (*float*) – The stroke width of a mobject.
+* **Returns:**
+ The adjusted stroke width that reflects zooming in with
+ the camera.
+* **Return type:**
+ float
+
+#### apply_fill(ctx, vmobject)
+
+Fills the cairo context
+
+* **Parameters:**
+ * **ctx** (*Context*) – The cairo context
+ * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The VMobject
+* **Returns:**
+ The camera object.
+* **Return type:**
+ [Camera](#manim.camera.camera.Camera)
+
+#### apply_stroke(ctx, vmobject, background=False)
+
+Applies a stroke to the VMobject in the cairo context.
+
+* **Parameters:**
+ * **ctx** (*Context*) – The cairo context
+ * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The VMobject
+ * **background** (*bool*) – Whether or not to consider the background when applying this
+ stroke width, by default False
+* **Returns:**
+ The camera object with the stroke applied.
+* **Return type:**
+ [Camera](#manim.camera.camera.Camera)
+
+#### cache_cairo_context(pixel_array, ctx)
+
+Caches the passed Pixel array into a Cairo Context
+
+* **Parameters:**
+ * **pixel_array** (*ndarray*) – The pixel array to cache
+ * **ctx** (*Context*) – The context to cache it into.
+
+#### capture_mobject(mobject, \*\*kwargs)
+
+Capture mobjects by storing it in `pixel_array`.
+
+This is a single-mobject version of [`capture_mobjects()`](#manim.camera.camera.Camera.capture_mobjects).
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – Mobject to capture.
+ * **kwargs** (*Any*) – Keyword arguments to be passed to [`get_mobjects_to_display()`](#manim.camera.camera.Camera.get_mobjects_to_display).
+
+#### capture_mobjects(mobjects, \*\*kwargs)
+
+Capture mobjects by printing them on `pixel_array`.
+
+This is the essential function that converts the contents of a Scene
+into an array, which is then converted to an image or video.
+
+* **Parameters:**
+ * **mobjects** (*Iterable* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – Mobjects to capture.
+ * **kwargs** – Keyword arguments to be passed to [`get_mobjects_to_display()`](#manim.camera.camera.Camera.get_mobjects_to_display).
+
+### Notes
+
+For a list of classes that can currently be rendered, see `display_funcs()`.
+
+#### convert_pixel_array(pixel_array, convert_from_floats=False)
+
+Converts a pixel array from values that have floats in then
+to proper RGB values.
+
+* **Parameters:**
+ * **pixel_array** (*ndarray* *|* *list* *|* *tuple*) – Pixel array to convert.
+ * **convert_from_floats** (*bool*) – Whether or not to convert float values to ints, by default False
+* **Returns:**
+ The new, converted pixel array.
+* **Return type:**
+ np.array
+
+#### display_image_mobject(image_mobject, pixel_array)
+
+Displays an ImageMobject by changing the pixel_array suitably.
+
+* **Parameters:**
+ * **image_mobject** ([*AbstractImageMobject*](manim.mobject.types.image_mobject.AbstractImageMobject.md#manim.mobject.types.image_mobject.AbstractImageMobject)) – The imageMobject to display
+ * **pixel_array** (*ndarray*) – The Pixel array to put the imagemobject in.
+
+#### display_multiple_background_colored_vmobjects(cvmobjects, pixel_array)
+
+Displays multiple vmobjects that have the same color as the background.
+
+* **Parameters:**
+ * **cvmobjects** (*list*) – List of Colored VMobjects
+ * **pixel_array** (*ndarray*) – The pixel array.
+* **Returns:**
+ The camera object.
+* **Return type:**
+ [Camera](#manim.camera.camera.Camera)
+
+#### display_multiple_image_mobjects(image_mobjects, pixel_array)
+
+Displays multiple image mobjects by modifying the passed pixel_array.
+
+* **Parameters:**
+ * **image_mobjects** (*list*) – list of ImageMobjects
+ * **pixel_array** (*ndarray*) – The pixel array to modify.
+
+#### display_multiple_non_background_colored_vmobjects(vmobjects, pixel_array)
+
+Displays multiple VMobjects in the cairo context, as long as they don’t have
+background colors.
+
+* **Parameters:**
+ * **vmobjects** (*list*) – list of the VMobjects
+ * **pixel_array** (*ndarray*) – The Pixel array to add the VMobjects to.
+
+#### display_multiple_point_cloud_mobjects(pmobjects, pixel_array)
+
+Displays multiple PMobjects by modifying the passed pixel array.
+
+* **Parameters:**
+ * **pmobjects** (*list*) – List of PMobjects
+ * **pixel_array** (*ndarray*) – The pixel array to modify.
+
+#### display_multiple_vectorized_mobjects(vmobjects, pixel_array)
+
+Displays multiple VMobjects in the pixel_array
+
+* **Parameters:**
+ * **vmobjects** (*list*) – list of VMobjects to display
+ * **pixel_array** (*ndarray*) – The pixel array
+
+#### display_point_cloud(pmobject, points, rgbas, thickness, pixel_array)
+
+Displays a PMobject by modifying the pixel array suitably.
+
+TODO: Write a description for the rgbas argument.
+
+* **Parameters:**
+ * **pmobject** ([*PMobject*](manim.mobject.types.point_cloud_mobject.PMobject.md#manim.mobject.types.point_cloud_mobject.PMobject)) – Point Cloud Mobject
+ * **points** (*list*) – The points to display in the point cloud mobject
+ * **rgbas** (*ndarray*)
+ * **thickness** (*float*) – The thickness of each point of the PMobject
+ * **pixel_array** (*ndarray*) – The pixel array to modify.
+
+#### display_vectorized(vmobject, ctx)
+
+Displays a VMobject in the cairo context
+
+* **Parameters:**
+ * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The Vectorized Mobject to display
+ * **ctx** (*Context*) – The cairo context to use.
+* **Returns:**
+ The camera object
+* **Return type:**
+ [Camera](#manim.camera.camera.Camera)
+
+#### get_background_colored_vmobject_displayer()
+
+Returns the background_colored_vmobject_displayer
+if it exists or makes one and returns it if not.
+
+* **Returns:**
+ Object that displays VMobjects that have the same color
+ as the background.
+* **Return type:**
+ BackGroundColoredVMobjectDisplayer
+
+#### get_cached_cairo_context(pixel_array)
+
+Returns the cached cairo context of the passed
+pixel array if it exists, and None if it doesn’t.
+
+* **Parameters:**
+ **pixel_array** (*ndarray*) – The pixel array to check.
+* **Returns:**
+ The cached cairo context.
+* **Return type:**
+ cairo.Context
+
+#### get_cairo_context(pixel_array)
+
+Returns the cairo context for a pixel array after
+caching it to self.pixel_array_to_cairo_context
+If that array has already been cached, it returns the
+cached version instead.
+
+* **Parameters:**
+ **pixel_array** (*ndarray*) – The Pixel array to get the cairo context of.
+* **Returns:**
+ The cairo context of the pixel array.
+* **Return type:**
+ cairo.Context
+
+#### get_coords_of_all_pixels()
+
+Returns the cartesian coordinates of each pixel.
+
+* **Returns:**
+ The array of cartesian coordinates.
+* **Return type:**
+ np.ndarray
+
+#### get_fill_rgbas(vmobject)
+
+Returns the RGBA array of the fill of the passed VMobject
+
+* **Parameters:**
+ **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The VMobject
+* **Returns:**
+ The RGBA Array of the fill of the VMobject
+* **Return type:**
+ np.array
+
+#### get_image(pixel_array=None)
+
+Returns an image from the passed
+pixel array, or from the current frame
+if the passed pixel array is none.
+
+* **Parameters:**
+ **pixel_array** (*ndarray* *|* *list* *|* *tuple* *|* *None*) – The pixel array from which to get an image, by default None
+* **Returns:**
+ The PIL image of the array.
+* **Return type:**
+ PIL.Image
+
+#### get_mobjects_to_display(mobjects, include_submobjects=True, excluded_mobjects=None)
+
+Used to get the list of mobjects to display
+with the camera.
+
+* **Parameters:**
+ * **mobjects** (*Iterable* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The Mobjects
+ * **include_submobjects** (*bool*) – Whether or not to include the submobjects of mobjects, by default True
+ * **excluded_mobjects** (*list* *|* *None*) – Any mobjects to exclude, by default None
+* **Returns:**
+ list of mobjects
+* **Return type:**
+ list
+
+#### get_stroke_rgbas(vmobject, background=False)
+
+Gets the RGBA array for the stroke of the passed
+VMobject.
+
+* **Parameters:**
+ * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The VMobject
+ * **background** (*bool*) – Whether or not to consider the background when getting the stroke
+ RGBAs, by default False
+* **Returns:**
+ The RGBA array of the stroke.
+* **Return type:**
+ np.ndarray
+
+#### get_thickening_nudges(thickness)
+
+Determine a list of vectors used to nudge
+two-dimensional pixel coordinates.
+
+* **Parameters:**
+ **thickness** (*float*)
+* **Return type:**
+ np.array
+
+#### init_background()
+
+Initialize the background.
+If self.background_image is the path of an image
+the image is set as background; else, the default
+background color fills the background.
+
+#### is_in_frame(mobject)
+
+Checks whether the passed mobject is in
+frame or not.
+
+* **Parameters:**
+ **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject for which the checking needs to be done.
+* **Returns:**
+ True if in frame, False otherwise.
+* **Return type:**
+ bool
+
+#### make_background_from_func(coords_to_colors_func)
+
+Makes a pixel array for the background by using coords_to_colors_func to determine each pixel’s color. Each input
+pixel’s color. Each input to coords_to_colors_func is an (x, y) pair in space (in ordinary space coordinates; not
+pixel coordinates), and each output is expected to be an RGBA array of 4 floats.
+
+* **Parameters:**
+ **coords_to_colors_func** (*Callable* *[* *[**ndarray* *]* *,* *ndarray* *]*) – The function whose input is an (x,y) pair of coordinates and
+ whose return values must be the colors for that point
+* **Returns:**
+ The pixel array which can then be passed to set_background.
+* **Return type:**
+ np.array
+
+#### on_screen_pixels(pixel_coords)
+
+Returns array of pixels that are on the screen from a given
+array of pixel_coordinates
+
+* **Parameters:**
+ **pixel_coords** (*ndarray*) – The pixel coords to check.
+* **Returns:**
+ The pixel coords on screen.
+* **Return type:**
+ np.array
+
+#### overlay_PIL_image(pixel_array, image)
+
+Overlays a PIL image on the passed pixel array.
+
+* **Parameters:**
+ * **pixel_array** (*ndarray*) – The Pixel array
+ * **image** ( **) – The Image to overlay.
+
+#### overlay_rgba_array(pixel_array, new_array)
+
+Overlays an RGBA array on top of the given Pixel array.
+
+* **Parameters:**
+ * **pixel_array** (*ndarray*) – The original pixel array to modify.
+ * **new_array** (*ndarray*) – The new pixel array to overlay.
+
+#### reset()
+
+Resets the camera’s pixel array
+to that of the background
+
+* **Returns:**
+ The camera object after setting the pixel array.
+* **Return type:**
+ [Camera](#manim.camera.camera.Camera)
+
+#### reset_pixel_shape(new_height, new_width)
+
+This method resets the height and width
+of a single pixel to the passed new_height and new_width.
+
+* **Parameters:**
+ * **new_height** (*float*) – The new height of the entire scene in pixels
+ * **new_width** (*float*) – The new width of the entire scene in pixels
+
+#### resize_frame_shape(fixed_dimension=0)
+
+Changes frame_shape to match the aspect ratio
+of the pixels, where fixed_dimension determines
+whether frame_height or frame_width
+remains fixed while the other changes accordingly.
+
+* **Parameters:**
+ **fixed_dimension** (*int*) – If 0, height is scaled with respect to width
+ else, width is scaled with respect to height.
+
+#### set_background(pixel_array, convert_from_floats=False)
+
+Sets the background to the passed pixel_array after converting
+to valid RGB values.
+
+* **Parameters:**
+ * **pixel_array** (*ndarray* *|* *list* *|* *tuple*) – The pixel array to set the background to.
+ * **convert_from_floats** (*bool*) – Whether or not to convert floats values to proper RGB valid ones, by default False
+
+#### set_background_from_func(coords_to_colors_func)
+
+Sets the background to a pixel array using coords_to_colors_func to determine each pixel’s color. Each input
+pixel’s color. Each input to coords_to_colors_func is an (x, y) pair in space (in ordinary space coordinates; not
+pixel coordinates), and each output is expected to be an RGBA array of 4 floats.
+
+* **Parameters:**
+ **coords_to_colors_func** (*Callable* *[* *[**ndarray* *]* *,* *ndarray* *]*) – The function whose input is an (x,y) pair of coordinates and
+ whose return values must be the colors for that point
+
+#### set_cairo_context_color(ctx, rgbas, vmobject)
+
+Sets the color of the cairo context
+
+* **Parameters:**
+ * **ctx** (*Context*) – The cairo context
+ * **rgbas** (*ndarray*) – The RGBA array with which to color the context.
+ * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The VMobject with which to set the color.
+* **Returns:**
+ The camera object
+* **Return type:**
+ [Camera](#manim.camera.camera.Camera)
+
+#### set_cairo_context_path(ctx, vmobject)
+
+Sets a path for the cairo context with the vmobject passed
+
+* **Parameters:**
+ * **ctx** (*Context*) – The cairo context
+ * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The VMobject
+* **Returns:**
+ Camera object after setting cairo_context_path
+* **Return type:**
+ [Camera](#manim.camera.camera.Camera)
+
+#### set_pixel_array(pixel_array, convert_from_floats=False)
+
+Sets the pixel array of the camera to the passed pixel array.
+
+* **Parameters:**
+ * **pixel_array** (*ndarray* *|* *list* *|* *tuple*) – The pixel array to convert and then set as the camera’s pixel array.
+ * **convert_from_floats** (*bool*) – Whether or not to convert float values to proper RGB values, by default False
+
+#### thickened_coordinates(pixel_coords, thickness)
+
+Returns thickened coordinates for a passed array of pixel coords and
+a thickness to thicken by.
+
+* **Parameters:**
+ * **pixel_coords** (*ndarray*) – Pixel coordinates
+ * **thickness** (*float*) – Thickness
+* **Returns:**
+ Array of thickened pixel coords.
+* **Return type:**
+ np.array
+
+#### type_or_raise(mobject)
+
+Return the type of mobject, if it is a type that can be rendered.
+
+If mobject is an instance of a class that inherits from a class that
+can be rendered, return the super class. For example, an instance of a
+Square is also an instance of VMobject, and these can be rendered.
+Therefore, type_or_raise(Square()) returns True.
+
+* **Parameters:**
+ **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The object to take the type of.
+
+### Notes
+
+For a list of classes that can currently be rendered, see `display_funcs()`.
+
+* **Returns:**
+ The type of mobjects, if it can be rendered.
+* **Return type:**
+ Type[[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)]
+* **Raises:**
+ **TypeError** – When mobject is not an instance of a class that can be rendered.
+* **Parameters:**
+ **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.camera.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.camera.md
new file mode 100644
index 0000000000000000000000000000000000000000..497c6fba9bea5bf9bc06acfe0dc4f03d1c575eb7
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.camera.md
@@ -0,0 +1,9 @@
+# camera
+
+A camera converts the mobjects contained in a Scene into an array of pixels.
+
+### Classes
+
+| [`BackgroundColoredVMobjectDisplayer`](manim.camera.camera.BackgroundColoredVMobjectDisplayer.md#manim.camera.camera.BackgroundColoredVMobjectDisplayer) | Auxiliary class that handles displaying vectorized mobjects with a set background image. |
+|------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|
+| [`Camera`](manim.camera.camera.Camera.md#manim.camera.camera.Camera) | Base camera class. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.mapping_camera.MappingCamera.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.mapping_camera.MappingCamera.md
new file mode 100644
index 0000000000000000000000000000000000000000..9f49fd2a3401c18705996542af43f72d391f3db0
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.mapping_camera.MappingCamera.md
@@ -0,0 +1,37 @@
+# MappingCamera
+
+Qualified name: `manim.camera.mapping\_camera.MappingCamera`
+
+### *class* MappingCamera(mapping_func=>, min_num_curves=50, allow_object_intrusion=False, \*\*kwargs)
+
+Bases: [`Camera`](manim.camera.camera.Camera.md#manim.camera.camera.Camera)
+
+Camera object that allows mapping
+between objects.
+
+### Methods
+
+| [`capture_mobjects`](#manim.camera.mapping_camera.MappingCamera.capture_mobjects) | Capture mobjects by printing them on `pixel_array`. |
+|-------------------------------------------------------------------------------------|-------------------------------------------------------|
+| `points_to_pixel_coords` | |
+
+### Attributes
+
+| `background_color` | |
+|----------------------|----|
+| `background_opacity` | |
+
+#### capture_mobjects(mobjects, \*\*kwargs)
+
+Capture mobjects by printing them on `pixel_array`.
+
+This is the essential function that converts the contents of a Scene
+into an array, which is then converted to an image or video.
+
+* **Parameters:**
+ * **mobjects** – Mobjects to capture.
+ * **kwargs** – Keyword arguments to be passed to `get_mobjects_to_display()`.
+
+### Notes
+
+For a list of classes that can currently be rendered, see `display_funcs()`.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.mapping_camera.OldMultiCamera.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.mapping_camera.OldMultiCamera.md
new file mode 100644
index 0000000000000000000000000000000000000000..8e8597d9c6fa1bd706ed1f18bdf5c25172a5eb36
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.mapping_camera.OldMultiCamera.md
@@ -0,0 +1,60 @@
+# OldMultiCamera
+
+Qualified name: `manim.camera.mapping\_camera.OldMultiCamera`
+
+### *class* OldMultiCamera(\*cameras_with_start_positions, \*\*kwargs)
+
+Bases: [`Camera`](manim.camera.camera.Camera.md#manim.camera.camera.Camera)
+
+### Methods
+
+| [`capture_mobjects`](#manim.camera.mapping_camera.OldMultiCamera.capture_mobjects) | Capture mobjects by printing them on `pixel_array`. |
+|--------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------|
+| [`init_background`](#manim.camera.mapping_camera.OldMultiCamera.init_background) | Initialize the background. |
+| [`set_background`](#manim.camera.mapping_camera.OldMultiCamera.set_background) | Sets the background to the passed pixel_array after converting to valid RGB values. |
+| [`set_pixel_array`](#manim.camera.mapping_camera.OldMultiCamera.set_pixel_array) | Sets the pixel array of the camera to the passed pixel array. |
+
+### Attributes
+
+| `background_color` | |
+|----------------------|----|
+| `background_opacity` | |
+
+#### capture_mobjects(mobjects, \*\*kwargs)
+
+Capture mobjects by printing them on `pixel_array`.
+
+This is the essential function that converts the contents of a Scene
+into an array, which is then converted to an image or video.
+
+* **Parameters:**
+ * **mobjects** – Mobjects to capture.
+ * **kwargs** – Keyword arguments to be passed to `get_mobjects_to_display()`.
+
+### Notes
+
+For a list of classes that can currently be rendered, see `display_funcs()`.
+
+#### init_background()
+
+Initialize the background.
+If self.background_image is the path of an image
+the image is set as background; else, the default
+background color fills the background.
+
+#### set_background(pixel_array, \*\*kwargs)
+
+Sets the background to the passed pixel_array after converting
+to valid RGB values.
+
+* **Parameters:**
+ * **pixel_array** – The pixel array to set the background to.
+ * **convert_from_floats** – Whether or not to convert floats values to proper RGB valid ones, by default False
+
+#### set_pixel_array(pixel_array, \*\*kwargs)
+
+Sets the pixel array of the camera to the passed pixel array.
+
+* **Parameters:**
+ * **pixel_array** – The pixel array to convert and then set as the camera’s pixel array.
+ * **convert_from_floats** – Whether or not to convert float values to proper RGB values, by default False
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.mapping_camera.SplitScreenCamera.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.mapping_camera.SplitScreenCamera.md
new file mode 100644
index 0000000000000000000000000000000000000000..7f8184b2ef0c80a63227753c5902a175f0f22c8e
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.mapping_camera.SplitScreenCamera.md
@@ -0,0 +1,15 @@
+# SplitScreenCamera
+
+Qualified name: `manim.camera.mapping\_camera.SplitScreenCamera`
+
+### *class* SplitScreenCamera(left_camera, right_camera, \*\*kwargs)
+
+Bases: [`OldMultiCamera`](manim.camera.mapping_camera.OldMultiCamera.md#manim.camera.mapping_camera.OldMultiCamera)
+
+### Methods
+
+### Attributes
+
+| `background_color` | |
+|----------------------|----|
+| `background_opacity` | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.mapping_camera.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.mapping_camera.md
new file mode 100644
index 0000000000000000000000000000000000000000..6a15a4a29f4d8336456a5bc69d0ff59ab61b286c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.mapping_camera.md
@@ -0,0 +1,10 @@
+# mapping_camera
+
+A camera that allows mapping between objects.
+
+### Classes
+
+| [`MappingCamera`](manim.camera.mapping_camera.MappingCamera.md#manim.camera.mapping_camera.MappingCamera) | Camera object that allows mapping between objects. |
+|-----------------------------------------------------------------------------------------------------------------------|------------------------------------------------------|
+| [`OldMultiCamera`](manim.camera.mapping_camera.OldMultiCamera.md#manim.camera.mapping_camera.OldMultiCamera) | |
+| [`SplitScreenCamera`](manim.camera.mapping_camera.SplitScreenCamera.md#manim.camera.mapping_camera.SplitScreenCamera) | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.moving_camera.MovingCamera.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.moving_camera.MovingCamera.md
new file mode 100644
index 0000000000000000000000000000000000000000..f20475fe9fb1ea314dea26dafdd001a7227787fa
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.moving_camera.MovingCamera.md
@@ -0,0 +1,115 @@
+# MovingCamera
+
+Qualified name: `manim.camera.moving\_camera.MovingCamera`
+
+### *class* MovingCamera(frame=None, fixed_dimension=0, default_frame_stroke_color=ManimColor('#FFFFFF'), default_frame_stroke_width=0, \*\*kwargs)
+
+Bases: [`Camera`](manim.camera.camera.Camera.md#manim.camera.camera.Camera)
+
+Stays in line with the height, width and position of it’s ‘frame’, which is a Rectangle
+
+#### SEE ALSO
+[`MovingCameraScene`](manim.scene.moving_camera_scene.MovingCameraScene.md#manim.scene.moving_camera_scene.MovingCameraScene)
+
+Frame is a Mobject, (should almost certainly be a rectangle)
+determining which region of space the camera displays
+
+### Methods
+
+| [`auto_zoom`](#manim.camera.moving_camera.MovingCamera.auto_zoom) | Zooms on to a given array of mobjects (or a singular mobject) and automatically resizes to frame all the mobjects. |
+|-----------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------|
+| [`cache_cairo_context`](#manim.camera.moving_camera.MovingCamera.cache_cairo_context) | Since the frame can be moving around, the cairo context used for updating should be regenerated at each frame. |
+| [`capture_mobjects`](#manim.camera.moving_camera.MovingCamera.capture_mobjects) | Capture mobjects by printing them on `pixel_array`. |
+| [`get_cached_cairo_context`](#manim.camera.moving_camera.MovingCamera.get_cached_cairo_context) | Since the frame can be moving around, the cairo context used for updating should be regenerated at each frame. |
+| [`get_mobjects_indicating_movement`](#manim.camera.moving_camera.MovingCamera.get_mobjects_indicating_movement) | Returns all mobjects whose movement implies that the camera should think of all other mobjects on the screen as moving |
+
+### Attributes
+
+| `background_color` | |
+|-------------------------------------------------------------------------|----------------------------------------------------------------|
+| `background_opacity` | |
+| [`frame_center`](#manim.camera.moving_camera.MovingCamera.frame_center) | Returns the centerpoint of the frame in cartesian coordinates. |
+| [`frame_height`](#manim.camera.moving_camera.MovingCamera.frame_height) | Returns the height of the frame. |
+| [`frame_width`](#manim.camera.moving_camera.MovingCamera.frame_width) | Returns the width of the frame |
+
+#### auto_zoom(mobjects, margin=0, only_mobjects_in_frame=False, animate=True)
+
+Zooms on to a given array of mobjects (or a singular mobject)
+and automatically resizes to frame all the mobjects.
+
+#### NOTE
+This method only works when 2D-objects in the XY-plane are considered, it
+will not work correctly when the camera has been rotated.
+
+* **Parameters:**
+ * **mobjects** (*list* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The mobject or array of mobjects that the camera will focus on.
+ * **margin** (*float*) – The width of the margin that is added to the frame (optional, 0 by default).
+ * **only_mobjects_in_frame** (*bool*) – If set to `True`, only allows focusing on mobjects that are already in frame.
+ * **animate** (*bool*) – If set to `False`, applies the changes instead of returning the corresponding animation
+* **Returns:**
+ \_AnimationBuilder that zooms the camera view to a given list of mobjects
+ or ScreenRectangle with position and size updated to zoomed position.
+* **Return type:**
+ [Union](manim.mobject.geometry.boolean_ops.Union.md#manim.mobject.geometry.boolean_ops.Union)[\_AnimationBuilder, [ScreenRectangle](manim.mobject.frame.ScreenRectangle.md#manim.mobject.frame.ScreenRectangle)]
+
+#### cache_cairo_context(pixel_array, ctx)
+
+Since the frame can be moving around, the cairo
+context used for updating should be regenerated
+at each frame. So no caching.
+
+#### capture_mobjects(mobjects, \*\*kwargs)
+
+Capture mobjects by printing them on `pixel_array`.
+
+This is the essential function that converts the contents of a Scene
+into an array, which is then converted to an image or video.
+
+* **Parameters:**
+ * **mobjects** – Mobjects to capture.
+ * **kwargs** – Keyword arguments to be passed to `get_mobjects_to_display()`.
+
+### Notes
+
+For a list of classes that can currently be rendered, see `display_funcs()`.
+
+#### *property* frame_center
+
+Returns the centerpoint of the frame in cartesian coordinates.
+
+* **Returns:**
+ The cartesian coordinates of the center of the frame.
+* **Return type:**
+ np.array
+
+#### *property* frame_height
+
+Returns the height of the frame.
+
+* **Returns:**
+ The height of the frame.
+* **Return type:**
+ float
+
+#### *property* frame_width
+
+Returns the width of the frame
+
+* **Returns:**
+ The width of the frame.
+* **Return type:**
+ float
+
+#### get_cached_cairo_context(pixel_array)
+
+Since the frame can be moving around, the cairo
+context used for updating should be regenerated
+at each frame. So no caching.
+
+#### get_mobjects_indicating_movement()
+
+Returns all mobjects whose movement implies that the camera
+should think of all other mobjects on the screen as moving
+
+* **Return type:**
+ list
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.moving_camera.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.moving_camera.md
new file mode 100644
index 0000000000000000000000000000000000000000..0b3915ce0e1165cff5dd2c40fe698305263e03d6
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.moving_camera.md
@@ -0,0 +1,11 @@
+# moving_camera
+
+A camera able to move through a scene.
+
+#### SEE ALSO
+[`moving_camera_scene`](manim.scene.moving_camera_scene.md#module-manim.scene.moving_camera_scene)
+
+### Classes
+
+| [`MovingCamera`](manim.camera.moving_camera.MovingCamera.md#manim.camera.moving_camera.MovingCamera) | Stays in line with the height, width and position of it's 'frame', which is a Rectangle |
+|--------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.multi_camera.MultiCamera.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.multi_camera.MultiCamera.md
new file mode 100644
index 0000000000000000000000000000000000000000..20f7dcbbccc418640bb9bfce8417456a62d039c0
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.multi_camera.MultiCamera.md
@@ -0,0 +1,77 @@
+# MultiCamera
+
+Qualified name: `manim.camera.multi\_camera.MultiCamera`
+
+### *class* MultiCamera(image_mobjects_from_cameras=None, allow_cameras_to_capture_their_own_display=False, \*\*kwargs)
+
+Bases: [`MovingCamera`](manim.camera.moving_camera.MovingCamera.md#manim.camera.moving_camera.MovingCamera)
+
+Camera Object that allows for multiple perspectives.
+
+Initialises the MultiCamera
+
+* **Parameters:**
+ * **image_mobjects_from_cameras** ([*ImageMobject*](manim.mobject.types.image_mobject.ImageMobject.md#manim.mobject.types.image_mobject.ImageMobject) *|* *None*)
+ * **kwargs** – Any valid keyword arguments of MovingCamera.
+
+### Methods
+
+| [`add_image_mobject_from_camera`](#manim.camera.multi_camera.MultiCamera.add_image_mobject_from_camera) | Adds an ImageMobject that's been obtained from the camera into the list `self.image_mobject_from_cameras` |
+|---------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------|
+| [`capture_mobjects`](#manim.camera.multi_camera.MultiCamera.capture_mobjects) | Capture mobjects by printing them on `pixel_array`. |
+| [`get_mobjects_indicating_movement`](#manim.camera.multi_camera.MultiCamera.get_mobjects_indicating_movement) | Returns all mobjects whose movement implies that the camera should think of all other mobjects on the screen as moving |
+| [`reset`](#manim.camera.multi_camera.MultiCamera.reset) | Resets the MultiCamera. |
+| [`update_sub_cameras`](#manim.camera.multi_camera.MultiCamera.update_sub_cameras) | Reshape sub_camera pixel_arrays |
+
+### Attributes
+
+| `background_color` | |
+|----------------------|----------------------------------------------------------------|
+| `background_opacity` | |
+| `frame_center` | Returns the centerpoint of the frame in cartesian coordinates. |
+| `frame_height` | Returns the height of the frame. |
+| `frame_width` | Returns the width of the frame |
+
+#### add_image_mobject_from_camera(image_mobject_from_camera)
+
+Adds an ImageMobject that’s been obtained from the camera
+into the list `self.image_mobject_from_cameras`
+
+* **Parameters:**
+ **image_mobject_from_camera** ([*ImageMobject*](manim.mobject.types.image_mobject.ImageMobject.md#manim.mobject.types.image_mobject.ImageMobject)) – The ImageMobject to add to self.image_mobject_from_cameras
+
+#### capture_mobjects(mobjects, \*\*kwargs)
+
+Capture mobjects by printing them on `pixel_array`.
+
+This is the essential function that converts the contents of a Scene
+into an array, which is then converted to an image or video.
+
+* **Parameters:**
+ * **mobjects** – Mobjects to capture.
+ * **kwargs** – Keyword arguments to be passed to `get_mobjects_to_display()`.
+
+### Notes
+
+For a list of classes that can currently be rendered, see `display_funcs()`.
+
+#### get_mobjects_indicating_movement()
+
+Returns all mobjects whose movement implies that the camera
+should think of all other mobjects on the screen as moving
+
+* **Return type:**
+ list
+
+#### reset()
+
+Resets the MultiCamera.
+
+* **Returns:**
+ The reset MultiCamera
+* **Return type:**
+ [MultiCamera](#manim.camera.multi_camera.MultiCamera)
+
+#### update_sub_cameras()
+
+Reshape sub_camera pixel_arrays
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.multi_camera.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.multi_camera.md
new file mode 100644
index 0000000000000000000000000000000000000000..ae4255135de6e4132d91b3058a827b6c0165b380
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.multi_camera.md
@@ -0,0 +1,8 @@
+# multi_camera
+
+A camera supporting multiple perspectives.
+
+### Classes
+
+| [`MultiCamera`](manim.camera.multi_camera.MultiCamera.md#manim.camera.multi_camera.MultiCamera) | Camera Object that allows for multiple perspectives. |
+|---------------------------------------------------------------------------------------------------|--------------------------------------------------------|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.three_d_camera.ThreeDCamera.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.three_d_camera.ThreeDCamera.md
new file mode 100644
index 0000000000000000000000000000000000000000..42c0fd195082ef7ae7d6d38aded768c51c8def52
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.three_d_camera.ThreeDCamera.md
@@ -0,0 +1,286 @@
+# ThreeDCamera
+
+Qualified name: `manim.camera.three\_d\_camera.ThreeDCamera`
+
+### *class* ThreeDCamera(focal_distance=20.0, shading_factor=0.2, default_distance=5.0, light_source_start_point=array([-7., -9., 10.]), should_apply_shading=True, exponential_projection=False, phi=0, theta=-1.5707963267948966, gamma=0, zoom=1, \*\*kwargs)
+
+Bases: [`Camera`](manim.camera.camera.Camera.md#manim.camera.camera.Camera)
+
+Initializes the ThreeDCamera
+
+* **Parameters:**
+ **\*kwargs** – Any keyword argument of Camera.
+
+### Methods
+
+| [`add_fixed_in_frame_mobjects`](#manim.camera.three_d_camera.ThreeDCamera.add_fixed_in_frame_mobjects) | This method allows the mobject to have a fixed position, even when the camera moves around. |
+|--------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`add_fixed_orientation_mobjects`](#manim.camera.three_d_camera.ThreeDCamera.add_fixed_orientation_mobjects) | This method allows the mobject to have a fixed orientation, even when the camera moves around. |
+| [`capture_mobjects`](#manim.camera.three_d_camera.ThreeDCamera.capture_mobjects) | Capture mobjects by printing them on `pixel_array`. |
+| [`generate_rotation_matrix`](#manim.camera.three_d_camera.ThreeDCamera.generate_rotation_matrix) | Generates a rotation matrix based off the current position of the camera. |
+| [`get_fill_rgbas`](#manim.camera.three_d_camera.ThreeDCamera.get_fill_rgbas) | Returns the RGBA array of the fill of the passed VMobject |
+| [`get_focal_distance`](#manim.camera.three_d_camera.ThreeDCamera.get_focal_distance) | Returns focal_distance of the Camera. |
+| [`get_gamma`](#manim.camera.three_d_camera.ThreeDCamera.get_gamma) | Returns the rotation of the camera about the vector from the ORIGIN to the Camera. |
+| [`get_mobjects_to_display`](#manim.camera.three_d_camera.ThreeDCamera.get_mobjects_to_display) | Used to get the list of mobjects to display with the camera. |
+| [`get_phi`](#manim.camera.three_d_camera.ThreeDCamera.get_phi) | Returns the Polar angle (the angle off Z_AXIS) phi. |
+| [`get_rotation_matrix`](#manim.camera.three_d_camera.ThreeDCamera.get_rotation_matrix) | Returns the matrix corresponding to the current position of the camera. |
+| [`get_stroke_rgbas`](#manim.camera.three_d_camera.ThreeDCamera.get_stroke_rgbas) | Gets the RGBA array for the stroke of the passed VMobject. |
+| [`get_theta`](#manim.camera.three_d_camera.ThreeDCamera.get_theta) | Returns the Azimuthal i.e the angle that spins the camera around the Z_AXIS. |
+| [`get_value_trackers`](#manim.camera.three_d_camera.ThreeDCamera.get_value_trackers) | A list of [`ValueTrackers`](manim.mobject.value_tracker.ValueTracker.md#manim.mobject.value_tracker.ValueTracker) of phi, theta, focal_distance, gamma and zoom. |
+| [`get_zoom`](#manim.camera.three_d_camera.ThreeDCamera.get_zoom) | Returns the zoom amount of the camera. |
+| `modified_rgbas` | |
+| [`project_point`](#manim.camera.three_d_camera.ThreeDCamera.project_point) | Applies the current rotation_matrix as a projection matrix to the passed point. |
+| [`project_points`](#manim.camera.three_d_camera.ThreeDCamera.project_points) | Applies the current rotation_matrix as a projection matrix to the passed array of points. |
+| [`remove_fixed_in_frame_mobjects`](#manim.camera.three_d_camera.ThreeDCamera.remove_fixed_in_frame_mobjects) | If a mobject was fixed in frame by passing it through [`add_fixed_in_frame_mobjects()`](#manim.camera.three_d_camera.ThreeDCamera.add_fixed_in_frame_mobjects), then this undoes that fixing. |
+| [`remove_fixed_orientation_mobjects`](#manim.camera.three_d_camera.ThreeDCamera.remove_fixed_orientation_mobjects) | If a mobject was fixed in its orientation by passing it through [`add_fixed_orientation_mobjects()`](#manim.camera.three_d_camera.ThreeDCamera.add_fixed_orientation_mobjects), then this undoes that fixing. |
+| [`reset_rotation_matrix`](#manim.camera.three_d_camera.ThreeDCamera.reset_rotation_matrix) | Sets the value of self.rotation_matrix to the matrix corresponding to the current position of the camera |
+| [`set_focal_distance`](#manim.camera.three_d_camera.ThreeDCamera.set_focal_distance) | Sets the focal_distance of the Camera. |
+| [`set_gamma`](#manim.camera.three_d_camera.ThreeDCamera.set_gamma) | Sets the angle of rotation of the camera about the vector from the ORIGIN to the Camera. |
+| [`set_phi`](#manim.camera.three_d_camera.ThreeDCamera.set_phi) | Sets the polar angle i.e the angle between Z_AXIS and Camera through ORIGIN in radians. |
+| [`set_theta`](#manim.camera.three_d_camera.ThreeDCamera.set_theta) | Sets the azimuthal angle i.e the angle that spins the camera around Z_AXIS in radians. |
+| [`set_zoom`](#manim.camera.three_d_camera.ThreeDCamera.set_zoom) | Sets the zoom amount of the camera. |
+| `transform_points_pre_display` | |
+
+### Attributes
+
+| `background_color` | |
+|----------------------|----|
+| `background_opacity` | |
+| `frame_center` | |
+
+#### add_fixed_in_frame_mobjects(\*mobjects)
+
+This method allows the mobject to have a fixed position,
+even when the camera moves around.
+E.G If it was passed through this method, at the top of the frame, it
+will continue to be displayed at the top of the frame.
+
+Highly useful when displaying Titles or formulae or the like.
+
+* **Parameters:**
+ **\*\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject to fix in frame.
+
+#### add_fixed_orientation_mobjects(\*mobjects, use_static_center_func=False, center_func=None)
+
+This method allows the mobject to have a fixed orientation,
+even when the camera moves around.
+E.G If it was passed through this method, facing the camera, it
+will continue to face the camera even as the camera moves.
+Highly useful when adding labels to graphs and the like.
+
+* **Parameters:**
+ * **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject whose orientation must be fixed.
+ * **use_static_center_func** (*bool*) – Whether or not to use the function that takes the mobject’s
+ center as centerpoint, by default False
+ * **center_func** (*Callable* *[* *[* *]* *,* *ndarray* *]* *|* *None*) – The function which returns the centerpoint
+ with respect to which the mobject will be oriented, by default None
+
+#### capture_mobjects(mobjects, \*\*kwargs)
+
+Capture mobjects by printing them on `pixel_array`.
+
+This is the essential function that converts the contents of a Scene
+into an array, which is then converted to an image or video.
+
+* **Parameters:**
+ * **mobjects** – Mobjects to capture.
+ * **kwargs** – Keyword arguments to be passed to [`get_mobjects_to_display()`](#manim.camera.three_d_camera.ThreeDCamera.get_mobjects_to_display).
+
+### Notes
+
+For a list of classes that can currently be rendered, see `display_funcs()`.
+
+#### generate_rotation_matrix()
+
+Generates a rotation matrix based off the current position of the camera.
+
+* **Returns:**
+ The matrix corresponding to the current position of the camera.
+* **Return type:**
+ np.array
+
+#### get_fill_rgbas(vmobject)
+
+Returns the RGBA array of the fill of the passed VMobject
+
+* **Parameters:**
+ **vmobject** – The VMobject
+* **Returns:**
+ The RGBA Array of the fill of the VMobject
+* **Return type:**
+ np.array
+
+#### get_focal_distance()
+
+Returns focal_distance of the Camera.
+
+* **Returns:**
+ The focal_distance of the Camera in MUnits.
+* **Return type:**
+ float
+
+#### get_gamma()
+
+Returns the rotation of the camera about the vector from the ORIGIN to the Camera.
+
+* **Returns:**
+ The angle of rotation of the camera about the vector
+ from the ORIGIN to the Camera in radians
+* **Return type:**
+ float
+
+#### get_mobjects_to_display(\*args, \*\*kwargs)
+
+Used to get the list of mobjects to display
+with the camera.
+
+* **Parameters:**
+ * **mobjects** – The Mobjects
+ * **include_submobjects** – Whether or not to include the submobjects of mobjects, by default True
+ * **excluded_mobjects** – Any mobjects to exclude, by default None
+* **Returns:**
+ list of mobjects
+* **Return type:**
+ list
+
+#### get_phi()
+
+Returns the Polar angle (the angle off Z_AXIS) phi.
+
+* **Returns:**
+ The Polar angle in radians.
+* **Return type:**
+ float
+
+#### get_rotation_matrix()
+
+Returns the matrix corresponding to the current position of the camera.
+
+* **Returns:**
+ The matrix corresponding to the current position of the camera.
+* **Return type:**
+ np.array
+
+#### get_stroke_rgbas(vmobject, background=False)
+
+Gets the RGBA array for the stroke of the passed
+VMobject.
+
+* **Parameters:**
+ * **vmobject** – The VMobject
+ * **background** – Whether or not to consider the background when getting the stroke
+ RGBAs, by default False
+* **Returns:**
+ The RGBA array of the stroke.
+* **Return type:**
+ np.ndarray
+
+#### get_theta()
+
+Returns the Azimuthal i.e the angle that spins the camera around the Z_AXIS.
+
+* **Returns:**
+ The Azimuthal angle in radians.
+* **Return type:**
+ float
+
+#### get_value_trackers()
+
+A list of [`ValueTrackers`](manim.mobject.value_tracker.ValueTracker.md#manim.mobject.value_tracker.ValueTracker) of phi, theta, focal_distance,
+gamma and zoom.
+
+* **Returns:**
+ list of ValueTracker objects
+* **Return type:**
+ list
+
+#### get_zoom()
+
+Returns the zoom amount of the camera.
+
+* **Returns:**
+ The zoom amount of the camera.
+* **Return type:**
+ float
+
+#### project_point(point)
+
+Applies the current rotation_matrix as a projection
+matrix to the passed point.
+
+* **Parameters:**
+ **point** (*list* *|* *ndarray*) – The point to project.
+* **Returns:**
+ The point after projection.
+* **Return type:**
+ np.array
+
+#### project_points(points)
+
+Applies the current rotation_matrix as a projection
+matrix to the passed array of points.
+
+* **Parameters:**
+ **points** (*ndarray* *|* *list*) – The list of points to project.
+* **Returns:**
+ The points after projecting.
+* **Return type:**
+ np.array
+
+#### remove_fixed_in_frame_mobjects(\*mobjects)
+
+If a mobject was fixed in frame by passing it through
+[`add_fixed_in_frame_mobjects()`](#manim.camera.three_d_camera.ThreeDCamera.add_fixed_in_frame_mobjects), then this undoes that fixing.
+The Mobject will no longer be fixed in frame.
+
+* **Parameters:**
+ **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects which need not be fixed in frame any longer.
+
+#### remove_fixed_orientation_mobjects(\*mobjects)
+
+If a mobject was fixed in its orientation by passing it through
+[`add_fixed_orientation_mobjects()`](#manim.camera.three_d_camera.ThreeDCamera.add_fixed_orientation_mobjects), then this undoes that fixing.
+The Mobject will no longer have a fixed orientation.
+
+* **Parameters:**
+ **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects whose orientation need not be fixed any longer.
+
+#### reset_rotation_matrix()
+
+Sets the value of self.rotation_matrix to
+the matrix corresponding to the current position of the camera
+
+#### set_focal_distance(value)
+
+Sets the focal_distance of the Camera.
+
+* **Parameters:**
+ **value** (*float*) – The focal_distance of the Camera.
+
+#### set_gamma(value)
+
+Sets the angle of rotation of the camera about the vector from the ORIGIN to the Camera.
+
+* **Parameters:**
+ **value** (*float*) – The new angle of rotation of the camera.
+
+#### set_phi(value)
+
+Sets the polar angle i.e the angle between Z_AXIS and Camera through ORIGIN in radians.
+
+* **Parameters:**
+ **value** (*float*) – The new value of the polar angle in radians.
+
+#### set_theta(value)
+
+Sets the azimuthal angle i.e the angle that spins the camera around Z_AXIS in radians.
+
+* **Parameters:**
+ **value** (*float*) – The new value of the azimuthal angle in radians.
+
+#### set_zoom(value)
+
+Sets the zoom amount of the camera.
+
+* **Parameters:**
+ **value** (*float*) – The zoom amount of the camera.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.camera.three_d_camera.md b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.three_d_camera.md
new file mode 100644
index 0000000000000000000000000000000000000000..b1bfb68efd8954b01fc6e236fd2cdbb1277563e4
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.camera.three_d_camera.md
@@ -0,0 +1,8 @@
+# three_d_camera
+
+A camera that can be positioned and oriented in three-dimensional space.
+
+### Classes
+
+| [`ThreeDCamera`](manim.camera.three_d_camera.ThreeDCamera.md#manim.camera.three_d_camera.ThreeDCamera) | Initializes the ThreeDCamera |
+|----------------------------------------------------------------------------------------------------------|--------------------------------|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.cli.cfg.md b/data/rag/manim_docs/manim_core/docs/reference/manim.cli.cfg.md
new file mode 100644
index 0000000000000000000000000000000000000000..8214a792c2984169850b39d51d763e3be5051588
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.cli.cfg.md
@@ -0,0 +1 @@
+# cfg
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.cli.checkhealth.md b/data/rag/manim_docs/manim_core/docs/reference/manim.cli.checkhealth.md
new file mode 100644
index 0000000000000000000000000000000000000000..8835cd85ce9639e785edbc0d37ad5af0613a4da9
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.cli.checkhealth.md
@@ -0,0 +1 @@
+# checkhealth
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.cli.init.md b/data/rag/manim_docs/manim_core/docs/reference/manim.cli.init.md
new file mode 100644
index 0000000000000000000000000000000000000000..a6131c10e6a0636dfad21d2d40d5fe7db6cd9f9f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.cli.init.md
@@ -0,0 +1 @@
+# init
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.cli.md b/data/rag/manim_docs/manim_core/docs/reference/manim.cli.md
new file mode 100644
index 0000000000000000000000000000000000000000..c1a0bfc36ebfe7181ec339d337d9aff67bcb11d8
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.cli.md
@@ -0,0 +1,15 @@
+# cli
+
+The Manim CLI, and the available commands for `manim`.
+
+This page is a work in progress. Please run `manim` or `manim --help` in
+your terminal to find more information on the following commands.
+
+## Available commands
+
+| [`cfg`](manim.cli.cfg.md#module-manim.cli.cfg) | |
+|------------------------------------------------------------------------|----|
+| [`checkhealth`](manim.cli.checkhealth.md#module-manim.cli.checkhealth) | |
+| [`init`](manim.cli.init.md#module-manim.cli.init) | |
+| [`plugins`](manim.cli.plugins.md#module-manim.cli.plugins) | |
+| [`render`](manim.cli.render.md#module-manim.cli.render) | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.cli.plugins.md b/data/rag/manim_docs/manim_core/docs/reference/manim.cli.plugins.md
new file mode 100644
index 0000000000000000000000000000000000000000..f130fd14ebd1a3f2f1616cdd9867467eee34c649
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.cli.plugins.md
@@ -0,0 +1 @@
+# plugins
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.cli.render.md b/data/rag/manim_docs/manim_core/docs/reference/manim.cli.render.md
new file mode 100644
index 0000000000000000000000000000000000000000..1bdca149c77368df8791b7cad46f6e6a42e09660
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.cli.render.md
@@ -0,0 +1 @@
+# render
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.constants.CapStyleType.md b/data/rag/manim_docs/manim_core/docs/reference/manim.constants.CapStyleType.md
new file mode 100644
index 0000000000000000000000000000000000000000..d306fb4885802d8e74ec94c59285e4246671d335
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.constants.CapStyleType.md
@@ -0,0 +1,69 @@
+# CapStyleType
+
+Qualified name: `manim.constants.CapStyleType`
+
+### *class* CapStyleType(value, names=None, \*, module=None, qualname=None, type=None, start=1, boundary=None)
+
+Bases: `Enum`
+
+Collection of available cap styles.
+
+See the example below for a visual illustration of the different
+cap styles.
+
+### Examples
+
+
+class LineJointVariants(Scene):
+ def construct(self):
+ mob = VMobject(stroke_width=20, color=GREEN).set_points_as_corners([
+ np.array([-2, 0, 0]),
+ np.array([0, 0, 0]),
+ np.array([-2, 1, 0]),
+ ])
+ lines = VGroup(\*[mob.copy() for \_ in range(len(LineJointType))])
+ for line, joint_type in zip(lines, LineJointType):
+ line.joint_type = joint_type
+
+ lines.arrange(RIGHT, buff=1)
+ self.add(lines)
+ for line in lines:
+ label = Text(line.joint_type.name).next_to(line, DOWN)
+ self.add(label)
+
+
+
+### Attributes
+
+| `AUTO` | |
+|----------|----|
+| `ROUND` | |
+| `BEVEL` | |
+| `MITER` | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.constants.QualityDict.md b/data/rag/manim_docs/manim_core/docs/reference/manim.constants.QualityDict.md
new file mode 100644
index 0000000000000000000000000000000000000000..16dfcf517406a83e03c1a8e17a1e9afd8aa8fb9a
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.constants.QualityDict.md
@@ -0,0 +1,17 @@
+# QualityDict
+
+Qualified name: `manim.constants.QualityDict`
+
+### *class* QualityDict
+
+Bases: `TypedDict`
+
+### Methods
+
+### Attributes
+
+| `flag` | |
+|----------------|----|
+| `pixel_height` | |
+| `pixel_width` | |
+| `frame_rate` | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.constants.RendererType.md b/data/rag/manim_docs/manim_core/docs/reference/manim.constants.RendererType.md
new file mode 100644
index 0000000000000000000000000000000000000000..cca9d451273bd14994711488b027e9a73cf7fe59
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.constants.RendererType.md
@@ -0,0 +1,39 @@
+# RendererType
+
+Qualified name: `manim.constants.RendererType`
+
+### *class* RendererType(value, names=None, \*, module=None, qualname=None, type=None, start=1, boundary=None)
+
+Bases: `Enum`
+
+An enumeration of all renderer types that can be assigned to
+the `config.renderer` attribute.
+
+Manim’s configuration allows assigning string values to the renderer
+setting, the values are then replaced by the corresponding enum object.
+In other words, you can run:
+
+```default
+config.renderer = "opengl"
+```
+
+and checking the renderer afterwards reveals that the attribute has
+assumed the value:
+
+```default
+
+```
+
+### Attributes
+
+| [`CAIRO`](#manim.constants.RendererType.CAIRO) | A renderer based on the cairo backend. |
+|--------------------------------------------------|------------------------------------------|
+| [`OPENGL`](#manim.constants.RendererType.OPENGL) | An OpenGL-based renderer. |
+
+#### CAIRO *= 'cairo'*
+
+A renderer based on the cairo backend.
+
+#### OPENGL *= 'opengl'*
+
+An OpenGL-based renderer.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.constants.md b/data/rag/manim_docs/manim_core/docs/reference/manim.constants.md
new file mode 100644
index 0000000000000000000000000000000000000000..98e089ed1668407c15f78c5613c163dd08d1a3f6
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.constants.md
@@ -0,0 +1,26 @@
+# constants
+
+Constant definitions.
+
+### Module Attributes
+
+| `ORIGIN` | The center of the coordinate system. |
+|------------|--------------------------------------------|
+| `UP` | One unit step in the positive Y direction. |
+| `DOWN` | One unit step in the negative Y direction. |
+| `RIGHT` | One unit step in the positive X direction. |
+| `LEFT` | One unit step in the negative X direction. |
+| `IN` | One unit step in the negative Z direction. |
+| `OUT` | One unit step in the positive Z direction. |
+| `UL` | One step up plus one step left. |
+| `UR` | One step up plus one step right. |
+| `DL` | One step down plus one step left. |
+| `DR` | One step down plus one step right. |
+
+### Classes
+
+| [`CapStyleType`](manim.constants.CapStyleType.md#manim.constants.CapStyleType) | Collection of available cap styles. |
+|-----------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------|
+| [`LineJointType`](manim.constants.LineJointType.md#manim.constants.LineJointType) | Collection of available line joint types. |
+| [`QualityDict`](manim.constants.QualityDict.md#manim.constants.QualityDict) | |
+| [`RendererType`](manim.constants.RendererType.md#manim.constants.RendererType) | An enumeration of all renderer types that can be assigned to the `config.renderer` attribute. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.frame.FullScreenRectangle.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.frame.FullScreenRectangle.md
new file mode 100644
index 0000000000000000000000000000000000000000..a523d60c563aa16f85bb2389ca299f563160e0e1
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.frame.FullScreenRectangle.md
@@ -0,0 +1,28 @@
+# FullScreenRectangle
+
+Qualified name: `manim.mobject.frame.FullScreenRectangle`
+
+### *class* FullScreenRectangle(\*\*kwargs)
+
+Bases: [`ScreenRectangle`](manim.mobject.frame.ScreenRectangle.md#manim.mobject.frame.ScreenRectangle)
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `aspect_ratio` | The aspect ratio. |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.frame.ScreenRectangle.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.frame.ScreenRectangle.md
new file mode 100644
index 0000000000000000000000000000000000000000..1d877306200f973a714f05dc1162e8a592097ab5
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.frame.ScreenRectangle.md
@@ -0,0 +1,35 @@
+# ScreenRectangle
+
+Qualified name: `manim.mobject.frame.ScreenRectangle`
+
+### *class* ScreenRectangle(aspect_ratio=1.7777777777777777, height=4, \*\*kwargs)
+
+Bases: [`Rectangle`](manim.mobject.geometry.polygram.Rectangle.md#manim.mobject.geometry.polygram.Rectangle)
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|---------------------------------------------------------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| [`aspect_ratio`](#manim.mobject.frame.ScreenRectangle.aspect_ratio) | The aspect ratio. |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(aspect_ratio=1.7777777777777777, height=4, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+#### *property* aspect_ratio
+
+The aspect ratio.
+
+When set, the width is stretched to accommodate
+the new aspect ratio.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.frame.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.frame.md
new file mode 100644
index 0000000000000000000000000000000000000000..42bc28dcd7472bcf25a93e8dac66444ac7ba3f17
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.frame.md
@@ -0,0 +1,9 @@
+# frame
+
+Special rectangles.
+
+### Classes
+
+| [`FullScreenRectangle`](manim.mobject.frame.FullScreenRectangle.md#manim.mobject.frame.FullScreenRectangle) | |
+|---------------------------------------------------------------------------------------------------------------|----|
+| [`ScreenRectangle`](manim.mobject.frame.ScreenRectangle.md#manim.mobject.frame.ScreenRectangle) | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.AnnotationDot.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.AnnotationDot.md
new file mode 100644
index 0000000000000000000000000000000000000000..ed8a0cd6f28be9984b549a5a997eb23aea3da973
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.AnnotationDot.md
@@ -0,0 +1,44 @@
+# AnnotationDot
+
+Qualified name: `manim.mobject.geometry.arc.AnnotationDot`
+
+### *class* AnnotationDot(radius=0.10400000000000001, stroke_width=5, stroke_color=ManimColor('#FFFFFF'), fill_color=ManimColor('#58C4DD'), \*\*kwargs)
+
+Bases: [`Dot`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot)
+
+A dot with bigger radius and bold stroke to annotate scenes.
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **radius** (*float*)
+ * **stroke_width** (*float*)
+ * **stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **fill_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(radius=0.10400000000000001, stroke_width=5, stroke_color=ManimColor('#FFFFFF'), fill_color=ManimColor('#58C4DD'), \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **radius** (*float*)
+ * **stroke_width** (*float*)
+ * **stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **fill_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.AnnularSector.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.AnnularSector.md
new file mode 100644
index 0000000000000000000000000000000000000000..023a3fbe79f4e6af202a57c903dd672e7393311a
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.AnnularSector.md
@@ -0,0 +1,124 @@
+# AnnularSector
+
+Qualified name: `manim.mobject.geometry.arc.AnnularSector`
+
+### *class* AnnularSector(inner_radius=1, outer_radius=2, angle=1.5707963267948966, start_angle=0, fill_opacity=1, stroke_width=0, color=ManimColor('#FFFFFF'), \*\*kwargs)
+
+Bases: [`Arc`](manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc)
+
+A sector of an annulus.
+
+* **Parameters:**
+ * **inner_radius** (*float*) – The inside radius of the Annular Sector.
+ * **outer_radius** (*float*) – The outside radius of the Annular Sector.
+ * **angle** (*float*) – The clockwise angle of the Annular Sector.
+ * **start_angle** (*float*) – The starting clockwise angle of the Annular Sector.
+ * **fill_opacity** (*float*) – The opacity of the color filled in the Annular Sector.
+ * **stroke_width** (*float*) – The stroke width of the Annular Sector.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color filled into the Annular Sector.
+ * **kwargs** (*Any*)
+
+### Examples
+
+
+```python
+from manim import *
+
+class AnnularSectorExample(Scene):
+ def construct(self):
+ # Changes background color to clearly visualize changes in fill_opacity.
+ self.camera.background_color = WHITE
+
+ # The default parameter start_angle is 0, so the AnnularSector starts from the +x-axis.
+ s1 = AnnularSector(color=YELLOW).move_to(2 * UL)
+
+ # Different inner_radius and outer_radius than the default.
+ s2 = AnnularSector(inner_radius=1.5, outer_radius=2, angle=45 * DEGREES, color=RED).move_to(2 * UR)
+
+ # fill_opacity is typically a number > 0 and <= 1. If fill_opacity=0, the AnnularSector is transparent.
+ s3 = AnnularSector(inner_radius=1, outer_radius=1.5, angle=PI, fill_opacity=0.25, color=BLUE).move_to(2 * DL)
+
+ # With a negative value for the angle, the AnnularSector is drawn clockwise from the start value.
+ s4 = AnnularSector(inner_radius=1, outer_radius=1.5, angle=-3 * PI / 2, color=GREEN).move_to(2 * DR)
+
+ self.add(s1, s2, s3, s4)
+```
+
+
+class AnnularSectorExample(Scene):
+ def construct(self):
+ # Changes background color to clearly visualize changes in fill_opacity.
+ self.camera.background_color = WHITE
+
+ # The default parameter start_angle is 0, so the AnnularSector starts from the +x-axis.
+ s1 = AnnularSector(color=YELLOW).move_to(2 \* UL)
+
+ # Different inner_radius and outer_radius than the default.
+ s2 = AnnularSector(inner_radius=1.5, outer_radius=2, angle=45 \* DEGREES, color=RED).move_to(2 \* UR)
+
+ # fill_opacity is typically a number > 0 and <= 1. If fill_opacity=0, the AnnularSector is transparent.
+ s3 = AnnularSector(inner_radius=1, outer_radius=1.5, angle=PI, fill_opacity=0.25, color=BLUE).move_to(2 \* DL)
+
+ # With a negative value for the angle, the AnnularSector is drawn clockwise from the start value.
+ s4 = AnnularSector(inner_radius=1, outer_radius=1.5, angle=-3 \* PI / 2, color=GREEN).move_to(2 \* DR)
+
+ self.add(s1, s2, s3, s4)
+
+
+
+### Methods
+
+| [`generate_points`](#manim.mobject.geometry.arc.AnnularSector.generate_points) | Initializes `points` and therefore the shape. |
+|----------------------------------------------------------------------------------|-------------------------------------------------|
+| [`init_points`](#manim.mobject.geometry.arc.AnnularSector.init_points) | Initializes `points` and therefore the shape. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(inner_radius=1, outer_radius=2, angle=1.5707963267948966, start_angle=0, fill_opacity=1, stroke_width=0, color=ManimColor('#FFFFFF'), \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **inner_radius** (*float*)
+ * **outer_radius** (*float*)
+ * **angle** (*float*)
+ * **start_angle** (*float*)
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### generate_points()
+
+Initializes `points` and therefore the shape.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
+
+* **Return type:**
+ None
+
+#### init_points()
+
+Initializes `points` and therefore the shape.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
+
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.Annulus.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.Annulus.md
new file mode 100644
index 0000000000000000000000000000000000000000..938856f0c8c817cdfc9a17c0803933096b01b7a5
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.Annulus.md
@@ -0,0 +1,96 @@
+# Annulus
+
+Qualified name: `manim.mobject.geometry.arc.Annulus`
+
+### *class* Annulus(inner_radius=1, outer_radius=2, fill_opacity=1, stroke_width=0, color=ManimColor('#FFFFFF'), mark_paths_closed=False, \*\*kwargs)
+
+Bases: [`Circle`](manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle)
+
+Region between two concentric [`Circles`](manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle).
+
+* **Parameters:**
+ * **inner_radius** (*float*) – The radius of the inner [`Circle`](manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle).
+ * **outer_radius** (*float*) – The radius of the outer [`Circle`](manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle).
+ * **kwargs** (*Any*) – Additional arguments to be passed to [`Annulus`](#manim.mobject.geometry.arc.Annulus)
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **mark_paths_closed** (*bool*)
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **start** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **end** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **angle** (*float*)
+ * **radius** (*float* *|* *None*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(start, end, angle=1.5707963267948966, radius=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **start** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **end** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **angle** (*float*)
+ * **radius** (*float* *|* *None*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.ArcPolygon.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.ArcPolygon.md
new file mode 100644
index 0000000000000000000000000000000000000000..8b8e243c580997e7d292604f2ace3d6df445e545
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.ArcPolygon.md
@@ -0,0 +1,129 @@
+# ArcPolygon
+
+Qualified name: `manim.mobject.geometry.arc.ArcPolygon`
+
+### *class* ArcPolygon(\*vertices, angle=0.7853981633974483, radius=None, arc_config=None, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A generalized polygon allowing for points to be connected with arcs.
+
+This version tries to stick close to the way `Polygon` is used. Points
+can be passed to it directly which are used to generate the according arcs
+(using [`ArcBetweenPoints`](manim.mobject.geometry.arc.ArcBetweenPoints.md#manim.mobject.geometry.arc.ArcBetweenPoints)). An angle or radius can be passed to it to
+use across all arcs, but to configure arcs individually an `arc_config` list
+has to be passed with the syntax explained below.
+
+* **Parameters:**
+ * **vertices** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – A list of vertices, start and end points for the arc segments.
+ * **angle** (*float*) – The angle used for constructing the arcs. If no other parameters
+ are set, this angle is used to construct all arcs.
+ * **radius** (*float* *|* *None*) – The circle radius used to construct the arcs. If specified,
+ overrides the specified `angle`.
+ * **arc_config** (*list* *[**dict* *]* *|* *None*) – When passing a `dict`, its content will be passed as keyword
+ arguments to [`ArcBetweenPoints`](manim.mobject.geometry.arc.ArcBetweenPoints.md#manim.mobject.geometry.arc.ArcBetweenPoints). Otherwise, a list
+ of dictionaries containing values that are passed as keyword
+ arguments for every individual arc can be passed.
+ * **kwargs** (*Any*) – Further keyword arguments that are passed to the constructor of
+ [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+
+#### arcs
+
+The arcs created from the input parameters:
+
+```default
+>>> from manim import ArcPolygon
+>>> ap = ArcPolygon([0, 0, 0], [2, 0, 0], [0, 2, 0])
+>>> ap.arcs
+[ArcBetweenPoints, ArcBetweenPoints, ArcBetweenPoints]
+```
+
+* **Type:**
+ `list`
+
+#### NOTE
+There is an alternative version ([`ArcPolygonFromArcs`](manim.mobject.geometry.arc.ArcPolygonFromArcs.md#manim.mobject.geometry.arc.ArcPolygonFromArcs)) that is instantiated
+with pre-defined arcs.
+
+#### SEE ALSO
+[`ArcPolygonFromArcs`](manim.mobject.geometry.arc.ArcPolygonFromArcs.md#manim.mobject.geometry.arc.ArcPolygonFromArcs)
+
+### Examples
+
+
+
+For further examples see [`ArcPolygonFromArcs`](manim.mobject.geometry.arc.ArcPolygonFromArcs.md#manim.mobject.geometry.arc.ArcPolygonFromArcs).
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*vertices, angle=0.7853981633974483, radius=None, arc_config=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **vertices** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **angle** (*float*)
+ * **radius** (*float* *|* *None*)
+ * **arc_config** (*list* *[**dict* *]* *|* *None*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.ArcPolygonFromArcs.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.ArcPolygonFromArcs.md
new file mode 100644
index 0000000000000000000000000000000000000000..5159871a755dacc4f880d6f5fc6bda2ddc62e07c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.ArcPolygonFromArcs.md
@@ -0,0 +1,181 @@
+# ArcPolygonFromArcs
+
+Qualified name: `manim.mobject.geometry.arc.ArcPolygonFromArcs`
+
+### *class* ArcPolygonFromArcs(\*arcs, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A generalized polygon allowing for points to be connected with arcs.
+
+This version takes in pre-defined arcs to generate the arcpolygon and introduces
+little new syntax. However unlike `Polygon` it can’t be created with points
+directly.
+
+For proper appearance the passed arcs should connect seamlessly:
+`[a,b][b,c][c,a]`
+
+If there are any gaps between the arcs, those will be filled in
+with straight lines, which can be used deliberately for any straight
+sections. Arcs can also be passed as straight lines such as an arc
+initialized with `angle=0`.
+
+* **Parameters:**
+ * **arcs** ([*Arc*](manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc) *|* [*ArcBetweenPoints*](manim.mobject.geometry.arc.ArcBetweenPoints.md#manim.mobject.geometry.arc.ArcBetweenPoints)) – These are the arcs from which the arcpolygon is assembled.
+ * **kwargs** (*Any*) – Keyword arguments that are passed to the constructor of
+ [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject). Affects how the ArcPolygon itself is drawn,
+ but doesn’t affect passed arcs.
+
+#### arcs
+
+The arcs used to initialize the ArcPolygonFromArcs:
+
+```default
+>>> from manim import ArcPolygonFromArcs, Arc, ArcBetweenPoints
+>>> ap = ArcPolygonFromArcs(Arc(), ArcBetweenPoints([1,0,0], [0,1,0]), Arc())
+>>> ap.arcs
+[Arc, ArcBetweenPoints, Arc]
+```
+
+#### NOTE
+There is an alternative version ([`ArcPolygon`](manim.mobject.geometry.arc.ArcPolygon.md#manim.mobject.geometry.arc.ArcPolygon)) that can be instantiated
+with points.
+
+#### SEE ALSO
+[`ArcPolygon`](manim.mobject.geometry.arc.ArcPolygon.md#manim.mobject.geometry.arc.ArcPolygon)
+
+### Examples
+
+One example of an arcpolygon is the Reuleaux triangle.
+Instead of 3 straight lines connecting the outer points,
+a Reuleaux triangle has 3 arcs connecting those points,
+making a shape with constant width.
+
+Passed arcs are stored as submobjects in the arcpolygon.
+This means that the arcs are changed along with the arcpolygon,
+for example when it’s shifted, and these arcs can be manipulated
+after the arcpolygon has been initialized.
+
+Also both the arcs contained in an [`ArcPolygonFromArcs`](#manim.mobject.geometry.arc.ArcPolygonFromArcs), as well as the
+arcpolygon itself are drawn, which affects draw time in [`Create`](manim.animation.creation.Create.md#manim.animation.creation.Create)
+for example. In most cases the arcs themselves don’t
+need to be drawn, in which case they can be passed as invisible.
+
+
+
+The arcpolygon itself can also be hidden so that instead only the contained
+arcs are drawn. This can be used to easily debug arcs or to highlight them.
+
+
+
+### Methods
+
+| [`from_three_points`](#manim.mobject.geometry.arc.Circle.from_three_points) | Returns a circle passing through the specified three points. |
+|-------------------------------------------------------------------------------|----------------------------------------------------------------|
+| [`point_at_angle`](#manim.mobject.geometry.arc.Circle.point_at_angle) | Returns the position of a point on the circle. |
+| [`surround`](#manim.mobject.geometry.arc.Circle.surround) | Modifies a circle so that it surrounds a given mobject. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(radius=None, color=ManimColor('#FC6255'), \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **radius** (*float* *|* *None*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### *static* from_three_points(p1, p2, p3, \*\*kwargs)
+
+Returns a circle passing through the specified
+three points.
+
+### Example
+
+
+* **Parameters:**
+ * **p1** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **p2** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **p3** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **kwargs** (*Any*)
+* **Return type:**
+ [Circle](#manim.mobject.geometry.arc.Circle)
+
+#### point_at_angle(angle)
+
+Returns the position of a point on the circle.
+
+* **Parameters:**
+ **angle** (*float*) – The angle of the point along the circle in radians.
+* **Returns:**
+ The location of the point along the circle’s circumference.
+* **Return type:**
+ `numpy.ndarray`
+
+### Examples
+
+
+
+#### surround(mobject, dim_to_match=0, stretch=False, buffer_factor=1.2)
+
+Modifies a circle so that it surrounds a given mobject.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject that the circle will be surrounding.
+ * **dim_to_match** (*int*)
+ * **buffer_factor** (*float*) – Scales the circle with respect to the mobject. A buffer_factor < 1 makes the circle smaller than the mobject.
+ * **stretch** (*bool*) – Stretches the circle to fit more tightly around the mobject. Note: Does not work with `Line`
+* **Return type:**
+ Self
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(width=2, height=1, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **width** (*float*)
+ * **height** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.LabeledDot.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.LabeledDot.md
new file mode 100644
index 0000000000000000000000000000000000000000..8edcbb32ec9ddbc224587803e49aa76f2e942e3c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.LabeledDot.md
@@ -0,0 +1,84 @@
+# LabeledDot
+
+Qualified name: `manim.mobject.geometry.arc.LabeledDot`
+
+### *class* LabeledDot(label, radius=None, \*\*kwargs)
+
+Bases: [`Dot`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot)
+
+A [`Dot`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) containing a label in its center.
+
+* **Parameters:**
+ * **label** (*str* *|* [*SingleStringMathTex*](manim.mobject.text.tex_mobject.SingleStringMathTex.md#manim.mobject.text.tex_mobject.SingleStringMathTex) *|* [*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) *|* [*Tex*](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex)) – The label of the [`Dot`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot). This is rendered as [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex)
+ by default (i.e., when passing a `str`), but other classes
+ representing rendered strings like [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) or [`Tex`](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex)
+ can be passed as well.
+ * **radius** (*float* *|* *None*) – The radius of the [`Dot`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot). If `None` (the default), the radius
+ is calculated based on the size of the `label`.
+ * **kwargs** (*Any*)
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **radius** (*float*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(radius=1, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **radius** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.TipableVMobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.TipableVMobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..5da7e8b9d601cb1717cf82a653b65ff6a24653e6
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.TipableVMobject.md
@@ -0,0 +1,143 @@
+# TipableVMobject
+
+Qualified name: `manim.mobject.geometry.arc.TipableVMobject`
+
+### *class* TipableVMobject(tip_length=0.35, normal_vector=array([0., 0., 1.]), tip_style={}, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+Meant for shared functionality between Arc and Line.
+Functionality can be classified broadly into these groups:
+
+> * Adding, Creating, Modifying tips
+> : - add_tip calls create_tip, before pushing the new tip
+> : into the TipableVMobject’s list of submobjects
+> - stylistic and positional configuration
+> * Checking for tips
+> : - Boolean checks for whether the TipableVMobject has a tip
+> : and a starting tip
+> * Getters
+> : - Straightforward accessors, returning information pertaining
+> : to the TipableVMobject instance’s tip(s), its length etc
+
+### Methods
+
+| [`add_tip`](#manim.mobject.geometry.arc.TipableVMobject.add_tip) | Adds a tip to the TipableVMobject instance, recognising that the endpoints might need to be switched if it's a 'starting tip' or not. |
+|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------|
+| `asign_tip_attr` | |
+| [`create_tip`](#manim.mobject.geometry.arc.TipableVMobject.create_tip) | Stylises the tip, positions it spatially, and returns the newly instantiated tip to the caller. |
+| `get_default_tip_length` | |
+| [`get_end`](#manim.mobject.geometry.arc.TipableVMobject.get_end) | Returns the point, where the stroke that surrounds the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) ends. |
+| `get_first_handle` | |
+| `get_last_handle` | |
+| `get_length` | |
+| [`get_start`](#manim.mobject.geometry.arc.TipableVMobject.get_start) | Returns the point, where the stroke that surrounds the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) starts. |
+| [`get_tip`](#manim.mobject.geometry.arc.TipableVMobject.get_tip) | Returns the TipableVMobject instance's (first) tip, otherwise throws an exception. |
+| [`get_tips`](#manim.mobject.geometry.arc.TipableVMobject.get_tips) | Returns a VGroup (collection of VMobjects) containing the TipableVMObject instance's tips. |
+| [`get_unpositioned_tip`](#manim.mobject.geometry.arc.TipableVMobject.get_unpositioned_tip) | Returns a tip that has been stylistically configured, but has not yet been given a position in space. |
+| `has_start_tip` | |
+| `has_tip` | |
+| `pop_tips` | |
+| `position_tip` | |
+| `reset_endpoints_based_on_tip` | |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **tip_length** (*float*)
+ * **normal_vector** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+ * **tip_style** (*dict*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(tip_length=0.35, normal_vector=array([0., 0., 1.]), tip_style={}, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **tip_length** (*float*)
+ * **normal_vector** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+ * **tip_style** (*dict*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### add_tip(tip=None, tip_shape=None, tip_length=None, tip_width=None, at_start=False)
+
+Adds a tip to the TipableVMobject instance, recognising
+that the endpoints might need to be switched if it’s
+a ‘starting tip’ or not.
+
+* **Parameters:**
+ * **tip** ([*tips.ArrowTip*](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip) *|* *None*)
+ * **tip_shape** (*type* *[*[*tips.ArrowTip*](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip) *]* *|* *None*)
+ * **tip_length** (*float* *|* *None*)
+ * **tip_width** (*float* *|* *None*)
+ * **at_start** (*bool*)
+* **Return type:**
+ Self
+
+#### create_tip(tip_shape=None, tip_length=None, tip_width=None, at_start=False)
+
+Stylises the tip, positions it spatially, and returns
+the newly instantiated tip to the caller.
+
+* **Parameters:**
+ * **tip_shape** (*type* *[*[*tips.ArrowTip*](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip) *]* *|* *None*)
+ * **tip_length** (*float* *|* *None*)
+ * **tip_width** (*float* *|* *None*)
+ * **at_start** (*bool*)
+* **Return type:**
+ [tips.ArrowTip](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip)
+
+#### get_end()
+
+Returns the point, where the stroke that surrounds the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) ends.
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_start()
+
+Returns the point, where the stroke that surrounds the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) starts.
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_tip()
+
+Returns the TipableVMobject instance’s (first) tip,
+otherwise throws an exception.
+
+* **Return type:**
+ [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### get_tips()
+
+Returns a VGroup (collection of VMobjects) containing
+the TipableVMObject instance’s tips.
+
+* **Return type:**
+ [*VGroup*](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+#### get_unpositioned_tip(tip_shape=None, tip_length=None, tip_width=None)
+
+Returns a tip that has been stylistically configured,
+but has not yet been given a position in space.
+
+* **Parameters:**
+ * **tip_shape** (*type* *[*[*tips.ArrowTip*](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip) *]* *|* *None*)
+ * **tip_length** (*float* *|* *None*)
+ * **tip_width** (*float* *|* *None*)
+* **Return type:**
+ [tips.ArrowTip](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip) | [tips.ArrowTriangleFilledTip](manim.mobject.geometry.tips.ArrowTriangleFilledTip.md#manim.mobject.geometry.tips.ArrowTriangleFilledTip)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.md
new file mode 100644
index 0000000000000000000000000000000000000000..91ad424d1ca8c498bfbecb326c49a309c6e9bba7
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.arc.md
@@ -0,0 +1,62 @@
+# arc
+
+Mobjects that are curved.
+
+### Examples
+
+
+
+### Classes
+
+| [`AnnotationDot`](manim.mobject.geometry.arc.AnnotationDot.md#manim.mobject.geometry.arc.AnnotationDot) | A dot with bigger radius and bold stroke to annotate scenes. |
+|------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------|
+| [`AnnularSector`](manim.mobject.geometry.arc.AnnularSector.md#manim.mobject.geometry.arc.AnnularSector) | A sector of an annulus. |
+| [`Annulus`](manim.mobject.geometry.arc.Annulus.md#manim.mobject.geometry.arc.Annulus) | Region between two concentric [`Circles`](manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle). |
+| [`Arc`](manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc) | A circular arc. |
+| [`ArcBetweenPoints`](manim.mobject.geometry.arc.ArcBetweenPoints.md#manim.mobject.geometry.arc.ArcBetweenPoints) | Inherits from Arc and additionally takes 2 points between which the arc is spanned. |
+| [`ArcPolygon`](manim.mobject.geometry.arc.ArcPolygon.md#manim.mobject.geometry.arc.ArcPolygon) | A generalized polygon allowing for points to be connected with arcs. |
+| [`ArcPolygonFromArcs`](manim.mobject.geometry.arc.ArcPolygonFromArcs.md#manim.mobject.geometry.arc.ArcPolygonFromArcs) | A generalized polygon allowing for points to be connected with arcs. |
+| [`Circle`](manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle) | A circle. |
+| [`CubicBezier`](manim.mobject.geometry.arc.CubicBezier.md#manim.mobject.geometry.arc.CubicBezier) | A cubic Bézier curve. |
+| [`CurvedArrow`](manim.mobject.geometry.arc.CurvedArrow.md#manim.mobject.geometry.arc.CurvedArrow) | |
+| [`CurvedDoubleArrow`](manim.mobject.geometry.arc.CurvedDoubleArrow.md#manim.mobject.geometry.arc.CurvedDoubleArrow) | |
+| [`Dot`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) | A circle with a very small radius. |
+| [`Ellipse`](manim.mobject.geometry.arc.Ellipse.md#manim.mobject.geometry.arc.Ellipse) | A circular shape; oval, circle. |
+| [`LabeledDot`](manim.mobject.geometry.arc.LabeledDot.md#manim.mobject.geometry.arc.LabeledDot) | A [`Dot`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) containing a label in its center. |
+| [`Sector`](manim.mobject.geometry.arc.Sector.md#manim.mobject.geometry.arc.Sector) | A sector of a circle. |
+| [`TipableVMobject`](manim.mobject.geometry.arc.TipableVMobject.md#manim.mobject.geometry.arc.TipableVMobject) | Meant for shared functionality between Arc and Line. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.Difference.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.Difference.md
new file mode 100644
index 0000000000000000000000000000000000000000..04e7f958a0189eb2c63c4de3babaa3600c4664c0
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.Difference.md
@@ -0,0 +1,72 @@
+# Difference
+
+Qualified name: `manim.mobject.geometry.boolean\_ops.Difference`
+
+### *class* Difference(subject, clip, \*\*kwargs)
+
+Bases: `_BooleanOps`
+
+Subtracts one [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) from another one.
+
+* **Parameters:**
+ * **subject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The 1st [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+ * **clip** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The 2nd [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+ * **kwargs** (*Any*)
+
+### Example
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(subject, clip, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **subject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+ * **clip** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.Exclusion.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.Exclusion.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a66d87e103355abbaf3c4e98ff20b4be7f06607
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.Exclusion.md
@@ -0,0 +1,74 @@
+# Exclusion
+
+Qualified name: `manim.mobject.geometry.boolean\_ops.Exclusion`
+
+### *class* Exclusion(subject, clip, \*\*kwargs)
+
+Bases: `_BooleanOps`
+
+Find the XOR between two [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+This creates a new [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) consisting of the region
+covered by exactly one of them.
+
+* **Parameters:**
+ * **subject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The 1st [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+ * **clip** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The 2nd [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+ * **kwargs** (*Any*)
+
+### Example
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(subject, clip, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **subject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+ * **clip** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.Intersection.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.Intersection.md
new file mode 100644
index 0000000000000000000000000000000000000000..755b8321ea6a88b06930c62311c7317434b1a36c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.Intersection.md
@@ -0,0 +1,73 @@
+# Intersection
+
+Qualified name: `manim.mobject.geometry.boolean\_ops.Intersection`
+
+### *class* Intersection(\*vmobjects, \*\*kwargs)
+
+Bases: `_BooleanOps`
+
+Find the intersection of two [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) s.
+This keeps the parts covered by both [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) s.
+
+* **Parameters:**
+ * **vmobjects** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) to find the intersection.
+ * **kwargs** (*Any*)
+* **Raises:**
+ **ValueError** – If less the 2 [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) are passed.
+
+### Example
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*vmobjects, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **vmobjects** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.Union.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.Union.md
new file mode 100644
index 0000000000000000000000000000000000000000..ac1da314db46655fe53dc6f7f6157da654534949
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.Union.md
@@ -0,0 +1,73 @@
+# Union
+
+Qualified name: `manim.mobject.geometry.boolean\_ops.Union`
+
+### *class* Union(\*vmobjects, \*\*kwargs)
+
+Bases: `_BooleanOps`
+
+Union of two or more [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) s. This returns the common region of
+the `VMobject` s.
+
+* **Parameters:**
+ * **vmobjects** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) s to find the union of.
+ * **kwargs** (*Any*)
+* **Raises:**
+ **ValueError** – If less than 2 [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) s are passed.
+
+### Example
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*vmobjects, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **vmobjects** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.md
new file mode 100644
index 0000000000000000000000000000000000000000..3363f26888c98b5000158cce13ed12e1adf595a5
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.boolean_ops.md
@@ -0,0 +1,11 @@
+# boolean_ops
+
+Boolean operations for two-dimensional mobjects.
+
+### Classes
+
+| [`Difference`](manim.mobject.geometry.boolean_ops.Difference.md#manim.mobject.geometry.boolean_ops.Difference) | Subtracts one [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) from another one. |
+|----------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`Exclusion`](manim.mobject.geometry.boolean_ops.Exclusion.md#manim.mobject.geometry.boolean_ops.Exclusion) | Find the XOR between two [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject). |
+| [`Intersection`](manim.mobject.geometry.boolean_ops.Intersection.md#manim.mobject.geometry.boolean_ops.Intersection) | Find the intersection of two [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) s. |
+| [`Union`](manim.mobject.geometry.boolean_ops.Union.md#manim.mobject.geometry.boolean_ops.Union) | Union of two or more [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) s. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.Label.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.Label.md
new file mode 100644
index 0000000000000000000000000000000000000000..f988a67534dffc05985b35ff767a848421bd82a8
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.Label.md
@@ -0,0 +1,81 @@
+# Label
+
+Qualified name: `manim.mobject.geometry.labeled.Label`
+
+### *class* Label(label, label_config=None, box_config=None, frame_config=None, \*\*kwargs)
+
+Bases: [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+A Label consisting of text surrounded by a frame.
+
+* **Parameters:**
+ * **label** (*str* *|* [*Tex*](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) *|* [*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) *|* [*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text)) – Label that will be displayed.
+ * **label_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) – A dictionary containing the configuration for the label.
+ This is only applied if `label` is of type `str`.
+ * **box_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) – A dictionary containing the configuration for the background box.
+ * **frame_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) – A dictionary containing the configuration for the frame.
+ * **kwargs** (*Any*)
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(label, label_config=None, box_config=None, frame_config=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **label** (*str* *|* [*Tex*](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) *|* [*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) *|* [*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+ * **label_config** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **box_config** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **frame_config** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.LabeledArrow.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.LabeledArrow.md
new file mode 100644
index 0000000000000000000000000000000000000000..8509ee32a5019311050964e964f04ce94aca12c8
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.LabeledArrow.md
@@ -0,0 +1,74 @@
+# LabeledArrow
+
+Qualified name: `manim.mobject.geometry.labeled.LabeledArrow`
+
+### *class* LabeledArrow(\*args, \*\*kwargs)
+
+Bases: [`LabeledLine`](manim.mobject.geometry.labeled.LabeledLine.md#manim.mobject.geometry.labeled.LabeledLine), [`Arrow`](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow)
+
+Constructs an arrow containing a label box somewhere along its length.
+This class inherits its label properties from LabeledLine, so the main parameters controlling it are the same.
+
+* **Parameters:**
+ * **label** – Label that will be displayed on the Arrow.
+ * **label_position** – A ratio in the range [0-1] to indicate the position of the label with respect to the length of the line. Default value is 0.5.
+ * **label_config** – A dictionary containing the configuration for the label.
+ This is only applied if `label` is of type `str`.
+ * **box_config** – A dictionary containing the configuration for the background box.
+ * **frame_config** –
+
+ A dictionary containing the configuration for the frame.
+
+ #### SEE ALSO
+ [`LabeledLine`](manim.mobject.geometry.labeled.LabeledLine.md#manim.mobject.geometry.labeled.LabeledLine)
+ * **args** (*Any*)
+ * **kwargs** (*Any*)
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*args, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **args** (*Any*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.LabeledLine.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.LabeledLine.md
new file mode 100644
index 0000000000000000000000000000000000000000..4ddb528290a35767a964598d23a479afb67a5505
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.LabeledLine.md
@@ -0,0 +1,94 @@
+# LabeledLine
+
+Qualified name: `manim.mobject.geometry.labeled.LabeledLine`
+
+### *class* LabeledLine(label, label_position=0.5, label_config=None, box_config=None, frame_config=None, \*args, \*\*kwargs)
+
+Bases: [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line)
+
+Constructs a line containing a label box somewhere along its length.
+
+* **Parameters:**
+ * **label** (*str* *|* [*Tex*](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) *|* [*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) *|* [*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text)) – Label that will be displayed on the line.
+ * **label_position** (*float*) – A ratio in the range [0-1] to indicate the position of the label with respect to the length of the line. Default value is 0.5.
+ * **label_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) – A dictionary containing the configuration for the label.
+ This is only applied if `label` is of type `str`.
+ * **box_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) – A dictionary containing the configuration for the background box.
+ * **frame_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) –
+
+ A dictionary containing the configuration for the frame.
+
+ #### SEE ALSO
+ [`LabeledArrow`](manim.mobject.geometry.labeled.LabeledArrow.md#manim.mobject.geometry.labeled.LabeledArrow)
+ * **args** (*Any*)
+ * **kwargs** (*Any*)
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(label, label_position=0.5, label_config=None, box_config=None, frame_config=None, \*args, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **label** (*str* *|* [*Tex*](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) *|* [*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) *|* [*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+ * **label_position** (*float*)
+ * **label_config** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **box_config** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **frame_config** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **args** (*Any*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.LabeledPolygram.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.LabeledPolygram.md
new file mode 100644
index 0000000000000000000000000000000000000000..c389b85059f07c2b2be7d1695d027ecca778de17
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.LabeledPolygram.md
@@ -0,0 +1,229 @@
+# LabeledPolygram
+
+Qualified name: `manim.mobject.geometry.labeled.LabeledPolygram`
+
+### *class* LabeledPolygram(\*vertex_groups, label, precision=0.01, label_config=None, box_config=None, frame_config=None, \*\*kwargs)
+
+Bases: [`Polygram`](manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram)
+
+Constructs a polygram containing a label box at its pole of inaccessibility.
+
+* **Parameters:**
+ * **vertex_groups** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array)) – Vertices passed to the [`Polygram`](manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram) constructor.
+ * **label** (*str* *|* [*Tex*](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) *|* [*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) *|* [*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text)) – Label that will be displayed on the Polygram.
+ * **precision** (*float*) – The precision used by the PolyLabel algorithm.
+ * **label_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) – A dictionary containing the configuration for the label.
+ This is only applied if `label` is of type `str`.
+ * **box_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) – A dictionary containing the configuration for the background box.
+ * **frame_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) –
+
+ A dictionary containing the configuration for the frame.
+
+ #### NOTE
+ The PolyLabel Algorithm expects each vertex group to form a closed ring.
+ If the input is open, [`LabeledPolygram`](#manim.mobject.geometry.labeled.LabeledPolygram) will attempt to close it.
+ This may cause the polygon to intersect itself leading to unexpected results.
+ * **kwargs** (*Any*)
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*vertex_groups, label, precision=0.01, label_config=None, box_config=None, frame_config=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **vertex_groups** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array))
+ * **label** (*str* *|* [*Tex*](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) *|* [*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) *|* [*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text))
+ * **precision** (*float*)
+ * **label_config** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **box_config** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **frame_config** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.md
new file mode 100644
index 0000000000000000000000000000000000000000..0b17c10946d5d16095b3803bb1c0470c1bcb28c9
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.labeled.md
@@ -0,0 +1,11 @@
+# labeled
+
+Mobjects that inherit from lines and contain a label along the length.
+
+### Classes
+
+| [`Label`](manim.mobject.geometry.labeled.Label.md#manim.mobject.geometry.labeled.Label) | A Label consisting of text surrounded by a frame. |
+|-----------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------|
+| [`LabeledArrow`](manim.mobject.geometry.labeled.LabeledArrow.md#manim.mobject.geometry.labeled.LabeledArrow) | Constructs an arrow containing a label box somewhere along its length. |
+| [`LabeledLine`](manim.mobject.geometry.labeled.LabeledLine.md#manim.mobject.geometry.labeled.LabeledLine) | Constructs a line containing a label box somewhere along its length. |
+| [`LabeledPolygram`](manim.mobject.geometry.labeled.LabeledPolygram.md#manim.mobject.geometry.labeled.LabeledPolygram) | Constructs a polygram containing a label box at its pole of inaccessibility. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.Angle.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.Angle.md
new file mode 100644
index 0000000000000000000000000000000000000000..9d33a595779748e3d10cd60a52a5aa74bd602e33
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.Angle.md
@@ -0,0 +1,316 @@
+# Angle
+
+Qualified name: `manim.mobject.geometry.line.Angle`
+
+### *class* Angle(line1, line2, radius=None, quadrant=(1, 1), other_angle=False, dot=False, dot_radius=None, dot_distance=0.55, dot_color=ManimColor('#FFFFFF'), elbow=False, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A circular arc or elbow-type mobject representing an angle of two lines.
+
+* **Parameters:**
+ * **line1** ([*Line*](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line)) – The first line.
+ * **line2** ([*Line*](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line)) – The second line.
+ * **radius** (*float* *|* *None*) – The radius of the `Arc`.
+ * **quadrant** ([*AngleQuadrant*](manim.mobject.geometry.line.md#manim.mobject.geometry.line.AngleQuadrant)) – A sequence of two `int` numbers determining which of the 4 quadrants should be used.
+ The first value indicates whether to anchor the arc on the first line closer to the end point (1)
+ or start point (-1), and the second value functions similarly for the
+ end (1) or start (-1) of the second line.
+ Possibilities: (1,1), (-1,1), (1,-1), (-1,-1).
+ * **other_angle** (*bool*) – Toggles between the two possible angles defined by two points and an arc center. If set to
+ False (default), the arc will always go counterclockwise from the point on line1 until
+ the point on line2 is reached. If set to True, the angle will go clockwise from line1 to line2.
+ * **dot** (*bool*) – Allows for a `Dot` in the arc. Mainly used as an convention to indicate a right angle.
+ The dot can be customized in the next three parameters.
+ * **dot_radius** (*float* *|* *None*) – The radius of the `Dot`. If not specified otherwise, this radius will be 1/10 of the arc radius.
+ * **dot_distance** (*float*) – Relative distance from the center to the arc: 0 puts the dot in the center and 1 on the arc itself.
+ * **dot_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the `Dot`.
+ * **elbow** (*bool*) – Produces an elbow-type mobject indicating a right angle, see [`RightAngle`](manim.mobject.geometry.line.RightAngle.md#manim.mobject.geometry.line.RightAngle) for more information
+ and a shorthand.
+ * **\*\*kwargs** (*Any*) – Further keyword arguments that are passed to the constructor of `Arc` or [`Elbow`](manim.mobject.geometry.line.Elbow.md#manim.mobject.geometry.line.Elbow).
+
+### Examples
+
+The first example shows some right angles with a dot in the middle while the second example shows
+all 8 possible angles defined by two lines.
+
+
+```python
+from manim import *
+
+class FilledAngle(Scene):
+ def construct(self):
+ l1 = Line(ORIGIN, 2 * UP + RIGHT).set_color(GREEN)
+ l2 = (
+ Line(ORIGIN, 2 * UP + RIGHT)
+ .set_color(GREEN)
+ .rotate(-20 * DEGREES, about_point=ORIGIN)
+ )
+ norm = l1.get_length()
+ a1 = Angle(l1, l2, other_angle=True, radius=norm - 0.5).set_color(GREEN)
+ a2 = Angle(l1, l2, other_angle=True, radius=norm).set_color(GREEN)
+ q1 = a1.points # save all coordinates of points of angle a1
+ q2 = a2.reverse_direction().points # save all coordinates of points of angle a1 (in reversed direction)
+ pnts = np.concatenate([q1, q2, q1[0].reshape(1, 3)]) # adds points and ensures that path starts and ends at same point
+ mfill = VMobject().set_color(ORANGE)
+ mfill.set_points_as_corners(pnts).set_fill(GREEN, opacity=1)
+ self.add(l1, l2)
+ self.add(mfill)
+```
+
+
+class FilledAngle(Scene):
+ def construct(self):
+ l1 = Line(ORIGIN, 2 \* UP + RIGHT).set_color(GREEN)
+ l2 = (
+ Line(ORIGIN, 2 \* UP + RIGHT)
+ .set_color(GREEN)
+ .rotate(-20 \* DEGREES, about_point=ORIGIN)
+ )
+ norm = l1.get_length()
+ a1 = Angle(l1, l2, other_angle=True, radius=norm - 0.5).set_color(GREEN)
+ a2 = Angle(l1, l2, other_angle=True, radius=norm).set_color(GREEN)
+ q1 = a1.points # save all coordinates of points of angle a1
+ q2 = a2.reverse_direction().points # save all coordinates of points of angle a1 (in reversed direction)
+ pnts = np.concatenate([q1, q2, q1[0].reshape(1, 3)]) # adds points and ensures that path starts and ends at same point
+ mfill = VMobject().set_color(ORANGE)
+ mfill.set_points_as_corners(pnts).set_fill(GREEN, opacity=1)
+ self.add(l1, l2)
+ self.add(mfill)
+
+
+
+### Methods
+
+| [`from_three_points`](#manim.mobject.geometry.line.Angle.from_three_points) | The angle between the lines AB and BC. |
+|-------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|
+| [`get_lines`](#manim.mobject.geometry.line.Angle.get_lines) | Get the lines forming an angle of the [`Angle`](#manim.mobject.geometry.line.Angle) class. |
+| [`get_value`](#manim.mobject.geometry.line.Angle.get_value) | Get the value of an angle of the [`Angle`](#manim.mobject.geometry.line.Angle) class. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(line1, line2, radius=None, quadrant=(1, 1), other_angle=False, dot=False, dot_radius=None, dot_distance=0.55, dot_color=ManimColor('#FFFFFF'), elbow=False, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **line1** ([*Line*](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line))
+ * **line2** ([*Line*](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line))
+ * **radius** (*float* *|* *None*)
+ * **quadrant** ([*AngleQuadrant*](manim.mobject.geometry.line.md#manim.mobject.geometry.line.AngleQuadrant))
+ * **other_angle** (*bool*)
+ * **dot** (*bool*)
+ * **dot_radius** (*float* *|* *None*)
+ * **dot_distance** (*float*)
+ * **dot_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **elbow** (*bool*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### *static* from_three_points(A, B, C, \*\*kwargs)
+
+The angle between the lines AB and BC.
+
+This constructs the angle $\\angle ABC$.
+
+* **Parameters:**
+ * **A** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – The endpoint of the first angle leg
+ * **B** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – The vertex of the angle
+ * **C** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – The endpoint of the second angle leg
+ * **\*\*kwargs** (*Any*) – Further keyword arguments are passed to [`Angle`](#manim.mobject.geometry.line.Angle)
+* **Returns:**
+ Angle(line1, line2, radius=0.5, quadrant=(-1,1), stroke_width=8),
+ Angle(line1, line2, radius=0.7, quadrant=(-1,-1), color=RED, other_angle=True),
+* **Return type:**
+ The Angle calculated from the three points
+
+### Examples
+
+
+
+#### get_lines()
+
+Get the lines forming an angle of the [`Angle`](#manim.mobject.geometry.line.Angle) class.
+
+* **Returns:**
+ A [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) containing the lines that form the angle of the [`Angle`](#manim.mobject.geometry.line.Angle) class.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+### Examples
+
+```default
+>>> line_1, line_2 = Line(ORIGIN, RIGHT), Line(ORIGIN, UR)
+>>> angle = Angle(line_1, line_2)
+>>> angle.get_lines()
+VGroup(Line, Line)
+```
+
+#### get_value(degrees=False)
+
+Get the value of an angle of the [`Angle`](#manim.mobject.geometry.line.Angle) class.
+
+* **Parameters:**
+ **degrees** (*bool*) – A boolean to decide the unit (deg/rad) in which the value of the angle is returned.
+* **Returns:**
+ The value in degrees/radians of an angle of the [`Angle`](#manim.mobject.geometry.line.Angle) class.
+* **Return type:**
+ `float`
+
+### Examples
+
+
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.Arrow.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.Arrow.md
new file mode 100644
index 0000000000000000000000000000000000000000..e28793779d4d9536dbc32369fd5c9dcb5fc6bae4
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.Arrow.md
@@ -0,0 +1,263 @@
+# Arrow
+
+Qualified name: `manim.mobject.geometry.line.Arrow`
+
+### *class* Arrow(\*args, stroke_width=6, buff=0.25, max_tip_length_to_length_ratio=0.25, max_stroke_width_to_length_ratio=5, \*\*kwargs)
+
+Bases: [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line)
+
+An arrow.
+
+* **Parameters:**
+ * **args** (*Any*) – Arguments to be passed to [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line).
+ * **stroke_width** (*float*) – The thickness of the arrow. Influenced by `max_stroke_width_to_length_ratio`.
+ * **buff** (*float*) – The distance of the arrow from its start and end points.
+ * **max_tip_length_to_length_ratio** (*float*) – `tip_length` scales with the length of the arrow. Increasing this ratio raises the max value of `tip_length`.
+ * **max_stroke_width_to_length_ratio** (*float*) – `stroke_width` scales with the length of the arrow. Increasing this ratio ratios the max value of `stroke_width`.
+ * **kwargs** (*Any*) – Additional arguments to be passed to [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line).
+
+#### SEE ALSO
+`ArrowTip`
+`CurvedArrow`
+
+### Examples
+
+
+
+### Methods
+
+| [`get_end`](#manim.mobject.geometry.line.DashedLine.get_end) | Returns the end point of the line. |
+|--------------------------------------------------------------------------------|----------------------------------------|
+| [`get_first_handle`](#manim.mobject.geometry.line.DashedLine.get_first_handle) | Returns the point of the first handle. |
+| [`get_last_handle`](#manim.mobject.geometry.line.DashedLine.get_last_handle) | Returns the point of the last handle. |
+| [`get_start`](#manim.mobject.geometry.line.DashedLine.get_start) | Returns the start point of the line. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_calculate_num_dashes()
+
+Returns the number of dashes in the dashed line.
+
+### Examples
+
+```default
+>>> DashedLine()._calculate_num_dashes()
+20
+```
+
+* **Return type:**
+ int
+
+#### \_original_\_init_\_(\*args, dash_length=0.05, dashed_ratio=0.5, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **args** (*Any*)
+ * **dash_length** (*float*)
+ * **dashed_ratio** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### get_end()
+
+Returns the end point of the line.
+
+### Examples
+
+```default
+>>> DashedLine().get_end()
+array([1., 0., 0.])
+```
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_first_handle()
+
+Returns the point of the first handle.
+
+### Examples
+
+```default
+>>> DashedLine().get_first_handle()
+array([-0.98333333, 0. , 0. ])
+```
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_last_handle()
+
+Returns the point of the last handle.
+
+### Examples
+
+```default
+>>> DashedLine().get_last_handle()
+array([0.98333333, 0. , 0. ])
+```
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_start()
+
+Returns the start point of the line.
+
+### Examples
+
+```default
+>>> DashedLine().get_start()
+array([-1., 0., 0.])
+```
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.DoubleArrow.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.DoubleArrow.md
new file mode 100644
index 0000000000000000000000000000000000000000..a69e3d78956b7823660e25226311755b4cb05d8a
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.DoubleArrow.md
@@ -0,0 +1,101 @@
+# DoubleArrow
+
+Qualified name: `manim.mobject.geometry.line.DoubleArrow`
+
+### *class* DoubleArrow(\*args, \*\*kwargs)
+
+Bases: [`Arrow`](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow)
+
+An arrow with tips on both ends.
+
+* **Parameters:**
+ * **args** (*Any*) – Arguments to be passed to [`Arrow`](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow)
+ * **kwargs** (*Any*) – Additional arguments to be passed to [`Arrow`](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow)
+
+#### SEE ALSO
+`ArrowTip`
+`CurvedDoubleArrow`
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(width=0.2, angle=0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **width** (*float*)
+ * **angle** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.Line.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.Line.md
new file mode 100644
index 0000000000000000000000000000000000000000..8e98028ecc5c9c41bdcb0fd2b7e8ad53904e0b5c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.Line.md
@@ -0,0 +1,167 @@
+# Line
+
+Qualified name: `manim.mobject.geometry.line.Line`
+
+### *class* Line(start=array([-1., 0., 0.]), end=array([1., 0., 0.]), buff=0, path_arc=None, \*\*kwargs)
+
+Bases: [`TipableVMobject`](manim.mobject.geometry.arc.TipableVMobject.md#manim.mobject.geometry.arc.TipableVMobject)
+
+### Methods
+
+| [`generate_points`](#manim.mobject.geometry.line.Line.generate_points) | Initializes `points` and therefore the shape. |
+|----------------------------------------------------------------------------------|----------------------------------------------------------------|
+| `get_angle` | |
+| [`get_projection`](#manim.mobject.geometry.line.Line.get_projection) | Returns the projection of a point onto a line. |
+| `get_slope` | |
+| `get_unit_vector` | |
+| `get_vector` | |
+| [`init_points`](#manim.mobject.geometry.line.Line.init_points) | Initializes `points` and therefore the shape. |
+| [`put_start_and_end_on`](#manim.mobject.geometry.line.Line.put_start_and_end_on) | Sets starts and end coordinates of a line. |
+| `set_angle` | |
+| `set_length` | |
+| `set_path_arc` | |
+| [`set_points_by_ends`](#manim.mobject.geometry.line.Line.set_points_by_ends) | Sets the points of the line based on its start and end points. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **start** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **end** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **buff** (*float*)
+ * **path_arc** (*float* *|* *None*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(start=array([-1., 0., 0.]), end=array([1., 0., 0.]), buff=0, path_arc=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **start** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **end** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **buff** (*float*)
+ * **path_arc** (*float* *|* *None*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### \_pointify(mob_or_point, direction=None)
+
+Transforms a mobject into its corresponding point. Does nothing if a point is passed.
+
+`direction` determines the location of the point along its bounding box in that direction.
+
+* **Parameters:**
+ * **mob_or_point** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* [*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – The mobject or point.
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D) *|* *None*) – The direction.
+* **Return type:**
+ [Point3D](manim.typing.md#manim.typing.Point3D)
+
+#### generate_points()
+
+Initializes `points` and therefore the shape.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
+
+* **Return type:**
+ None
+
+#### get_projection(point)
+
+Returns the projection of a point onto a line.
+
+* **Parameters:**
+ **point** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – The point to which the line is projected.
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### init_points()
+
+Initializes `points` and therefore the shape.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
+
+* **Return type:**
+ None
+
+#### put_start_and_end_on(start, end)
+
+Sets starts and end coordinates of a line.
+
+### Examples
+
+
+class LineExample(Scene):
+ def construct(self):
+ d = VGroup()
+ for i in range(0,10):
+ d.add(Dot())
+ d.arrange_in_grid(buff=1)
+ self.add(d)
+ l= Line(d[0], d[1])
+ self.add(l)
+ self.wait()
+ l.put_start_and_end_on(d[1].get_center(), d[2].get_center())
+ self.wait()
+ l.put_start_and_end_on(d[4].get_center(), d[7].get_center())
+ self.wait()
+
+
+* **Parameters:**
+ * **start** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **end** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+* **Return type:**
+ Self
+
+#### set_points_by_ends(start, end, buff=0, path_arc=0)
+
+Sets the points of the line based on its start and end points.
+Unlike [`put_start_and_end_on()`](#manim.mobject.geometry.line.Line.put_start_and_end_on), this method respects self.buff and
+Mobject bounding boxes.
+
+* **Parameters:**
+ * **start** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The start point or Mobject of the line.
+ * **end** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The end point or Mobject of the line.
+ * **buff** (*float*) – The empty space between the start and end of the line, by default 0.
+ * **path_arc** (*float*) – The angle of a circle spanned by this arc, by default 0 which is a straight line.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.RightAngle.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.RightAngle.md
new file mode 100644
index 0000000000000000000000000000000000000000..00a407e9c3bae121ab099c7e50ebc39432ca42c7
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.RightAngle.md
@@ -0,0 +1,88 @@
+# RightAngle
+
+Qualified name: `manim.mobject.geometry.line.RightAngle`
+
+### *class* RightAngle(line1, line2, length=None, \*\*kwargs)
+
+Bases: [`Angle`](manim.mobject.geometry.line.Angle.md#manim.mobject.geometry.line.Angle)
+
+An elbow-type mobject representing a right angle between two lines.
+
+* **Parameters:**
+ * **line1** ([*Line*](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line)) – The first line.
+ * **line2** ([*Line*](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line)) – The second line.
+ * **length** (*float* *|* *None*) – The length of the arms.
+ * **\*\*kwargs** (*Any*) – Further keyword arguments that are passed to the constructor of [`Angle`](manim.mobject.geometry.line.Angle.md#manim.mobject.geometry.line.Angle).
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(line1, line2, length=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **line1** ([*Line*](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line))
+ * **line2** ([*Line*](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line))
+ * **length** (*float* *|* *None*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.TangentLine.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.TangentLine.md
new file mode 100644
index 0000000000000000000000000000000000000000..4573e707211a4171ce1e2e262355dc3b9753765b
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.TangentLine.md
@@ -0,0 +1,73 @@
+# TangentLine
+
+Qualified name: `manim.mobject.geometry.line.TangentLine`
+
+### *class* TangentLine(vmob, alpha, length=1, d_alpha=1e-06, \*\*kwargs)
+
+Bases: [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line)
+
+Constructs a line tangent to a [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) at a specific point.
+
+* **Parameters:**
+ * **vmob** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The VMobject on which the tangent line is drawn.
+ * **alpha** (*float*) – How far along the shape that the line will be constructed. range: 0-1.
+ * **length** (*float*) – Length of the tangent line.
+ * **d_alpha** (*float*) – The `dx` value
+ * **kwargs** (*Any*) – Additional arguments to be passed to [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line)
+
+#### SEE ALSO
+[`point_from_proportion()`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject.point_from_proportion)
+
+### Examples
+
+
+
+### Methods
+
+| [`coordinate_label`](#manim.mobject.geometry.line.Vector.coordinate_label) | Creates a label based on the coordinates of the vector. |
+|------------------------------------------------------------------------------|-----------------------------------------------------------|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(direction=array([1., 0., 0.]), buff=0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **direction** ([*Point2DLike*](manim.typing.md#manim.typing.Point2DLike) *|* [*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **buff** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### coordinate_label(integer_labels=True, n_dim=2, color=None, \*\*kwargs)
+
+Creates a label based on the coordinates of the vector.
+
+* **Parameters:**
+ * **integer_labels** (*bool*) – Whether or not to round the coordinates to integers.
+ * **n_dim** (*int*) – The number of dimensions of the vector.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – Sets the color of label, optional.
+ * **kwargs** (*Any*) – Additional arguments to be passed to [`Matrix`](manim.mobject.matrix.Matrix.md#manim.mobject.matrix.Matrix).
+* **Returns:**
+ The label.
+* **Return type:**
+ [`Matrix`](manim.mobject.matrix.Matrix.md#manim.mobject.matrix.Matrix)
+
+### Examples
+
+
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.md
new file mode 100644
index 0000000000000000000000000000000000000000..c15be2c14fd1c02e2c5aa482b5b67beb0583d97a
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.line.md
@@ -0,0 +1,24 @@
+# line
+
+Mobjects that are lines or variations of them.
+
+### Type Aliases
+
+### *class* AngleQuadrant
+
+```default
+tuple[Literal[-1, 1], Literal[-1, 1]]
+```
+
+### Classes
+
+| [`Angle`](manim.mobject.geometry.line.Angle.md#manim.mobject.geometry.line.Angle) | A circular arc or elbow-type mobject representing an angle of two lines. |
+|-----------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`Arrow`](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow) | An arrow. |
+| [`DashedLine`](manim.mobject.geometry.line.DashedLine.md#manim.mobject.geometry.line.DashedLine) | A dashed [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line). |
+| [`DoubleArrow`](manim.mobject.geometry.line.DoubleArrow.md#manim.mobject.geometry.line.DoubleArrow) | An arrow with tips on both ends. |
+| [`Elbow`](manim.mobject.geometry.line.Elbow.md#manim.mobject.geometry.line.Elbow) | Two lines that create a right angle about each other: L-shape. |
+| [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line) | |
+| [`RightAngle`](manim.mobject.geometry.line.RightAngle.md#manim.mobject.geometry.line.RightAngle) | An elbow-type mobject representing a right angle between two lines. |
+| [`TangentLine`](manim.mobject.geometry.line.TangentLine.md#manim.mobject.geometry.line.TangentLine) | Constructs a line tangent to a [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) at a specific point. |
+| [`Vector`](manim.mobject.geometry.line.Vector.md#manim.mobject.geometry.line.Vector) | A vector specialized for use in graphs. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.md
new file mode 100644
index 0000000000000000000000000000000000000000..df76c473f2ff29bf83147ed2c53e22d705c2efff
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.md
@@ -0,0 +1,14 @@
+# geometry
+
+Various geometric Mobjects.
+
+## Modules
+
+| [`arc`](manim.mobject.geometry.arc.md#module-manim.mobject.geometry.arc) | Mobjects that are curved. |
+|-----------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`boolean_ops`](manim.mobject.geometry.boolean_ops.md#module-manim.mobject.geometry.boolean_ops) | Boolean operations for two-dimensional mobjects. |
+| [`labeled`](manim.mobject.geometry.labeled.md#module-manim.mobject.geometry.labeled) | Mobjects that inherit from lines and contain a label along the length. |
+| [`line`](manim.mobject.geometry.line.md#module-manim.mobject.geometry.line) | Mobjects that are lines or variations of them. |
+| [`polygram`](manim.mobject.geometry.polygram.md#module-manim.mobject.geometry.polygram) | Mobjects that are simple geometric shapes. |
+| [`shape_matchers`](manim.mobject.geometry.shape_matchers.md#module-manim.mobject.geometry.shape_matchers) | Mobjects used to mark and annotate other mobjects. |
+| [`tips`](manim.mobject.geometry.tips.md#module-manim.mobject.geometry.tips) | A collection of tip mobjects for use with [`TipableVMobject`](manim.mobject.geometry.arc.TipableVMobject.md#manim.mobject.geometry.arc.TipableVMobject). |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.ConvexHull.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.ConvexHull.md
new file mode 100644
index 0000000000000000000000000000000000000000..87f4222aedae39439835f47e28d3f0bb0026f614
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.ConvexHull.md
@@ -0,0 +1,90 @@
+# ConvexHull
+
+Qualified name: `manim.mobject.geometry.polygram.ConvexHull`
+
+### *class* ConvexHull(\*points, tolerance=1e-05, \*\*kwargs)
+
+Bases: [`Polygram`](manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram)
+
+Constructs a convex hull for a set of points in no particular order.
+
+* **Parameters:**
+ * **points** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – The points to consider.
+ * **tolerance** (*float*) – The tolerance used by quickhull.
+ * **kwargs** (*Any*) – Forwarded to the parent constructor.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*points, tolerance=1e-05, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **points** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **tolerance** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.Cutout.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.Cutout.md
new file mode 100644
index 0000000000000000000000000000000000000000..aad9cb8896cf16078194a8ccf30f12b90fbfe147
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.Cutout.md
@@ -0,0 +1,86 @@
+# Cutout
+
+Qualified name: `manim.mobject.geometry.polygram.Cutout`
+
+### *class* Cutout(main_shape, \*mobjects, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A shape with smaller cutouts.
+
+* **Parameters:**
+ * **main_shape** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The primary shape from which cutouts are made.
+ * **mobjects** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The smaller shapes which are to be cut out of the `main_shape`.
+ * **kwargs** (*Any*) – Further keyword arguments that are passed to the constructor of
+ [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+
+#### WARNING
+Technically, this class behaves similar to a symmetric difference: if
+parts of the `mobjects` are not located within the `main_shape`,
+these parts will be added to the resulting [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*vertices, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **vertices** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.Polygram.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.Polygram.md
new file mode 100644
index 0000000000000000000000000000000000000000..9c663c71c5bc13780d2bb5e11ff169a58633776b
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.Polygram.md
@@ -0,0 +1,211 @@
+# Polygram
+
+Qualified name: `manim.mobject.geometry.polygram.Polygram`
+
+### *class* Polygram(\*vertex_groups, color=ManimColor('#58C4DD'), \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A generalized [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon), allowing for disconnected sets of edges.
+
+* **Parameters:**
+ * **vertex_groups** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array)) –
+
+ The groups of vertices making up the [`Polygram`](#manim.mobject.geometry.polygram.Polygram).
+
+ The first vertex in each group is repeated to close the shape.
+ Each point must be 3-dimensional: `[x,y,z]`
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the [`Polygram`](#manim.mobject.geometry.polygram.Polygram).
+ * **kwargs** (*Any*) – Forwarded to the parent constructor.
+
+### Examples
+
+
+
+### Methods
+
+| [`get_vertex_groups`](#manim.mobject.geometry.polygram.Polygram.get_vertex_groups) | Gets the vertex groups of the [`Polygram`](#manim.mobject.geometry.polygram.Polygram). |
+|--------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
+| [`get_vertices`](#manim.mobject.geometry.polygram.Polygram.get_vertices) | Gets the vertices of the [`Polygram`](#manim.mobject.geometry.polygram.Polygram). |
+| [`round_corners`](#manim.mobject.geometry.polygram.Polygram.round_corners) | Rounds off the corners of the [`Polygram`](#manim.mobject.geometry.polygram.Polygram). |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*vertex_groups, color=ManimColor('#58C4DD'), \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **vertex_groups** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array))
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **kwargs** (*Any*)
+
+#### get_vertex_groups()
+
+Gets the vertex groups of the [`Polygram`](#manim.mobject.geometry.polygram.Polygram).
+
+* **Returns:**
+ The vertex groups of the [`Polygram`](#manim.mobject.geometry.polygram.Polygram).
+* **Return type:**
+ `numpy.ndarray`
+
+### Examples
+
+```default
+>>> poly = Polygram([ORIGIN, RIGHT, UP], [LEFT, LEFT + UP, 2 * LEFT])
+>>> poly.get_vertex_groups()
+array([[[ 0., 0., 0.],
+ [ 1., 0., 0.],
+ [ 0., 1., 0.]],
+
+ [[-1., 0., 0.],
+ [-1., 1., 0.],
+ [-2., 0., 0.]]])
+```
+
+#### get_vertices()
+
+Gets the vertices of the [`Polygram`](#manim.mobject.geometry.polygram.Polygram).
+
+* **Returns:**
+ The vertices of the [`Polygram`](#manim.mobject.geometry.polygram.Polygram).
+* **Return type:**
+ `numpy.ndarray`
+
+### Examples
+
+```default
+>>> sq = Square()
+>>> sq.get_vertices()
+array([[ 1., 1., 0.],
+ [-1., 1., 0.],
+ [-1., -1., 0.],
+ [ 1., -1., 0.]])
+```
+
+#### round_corners(radius=0.5, evenly_distribute_anchors=False, components_per_rounded_corner=2)
+
+Rounds off the corners of the [`Polygram`](#manim.mobject.geometry.polygram.Polygram).
+
+* **Parameters:**
+ * **radius** (*float* *|* *list* *[**float* *]*) – The curvature of the corners of the [`Polygram`](#manim.mobject.geometry.polygram.Polygram).
+ * **evenly_distribute_anchors** (*bool*) – Break long line segments into proportionally-sized segments.
+ * **components_per_rounded_corner** (*int*) – The number of points used to represent the rounded corner curve.
+* **Return type:**
+ Self
+
+#### SEE ALSO
+`RoundedRectangle`
+
+#### NOTE
+If radius is supplied as a single value, then the same radius
+will be applied to all corners. If radius is a list, then the
+individual values will be applied sequentially, with the first
+corner receiving radius[0], the second corner receiving
+radius[1], etc. The radius list will be repeated as necessary.
+
+The components_per_rounded_corner value is provided so that the
+fidelity of the rounded corner may be fine-tuned as needed. 2 is
+an appropriate value for most shapes, however a larger value may be
+need if the rounded corner is particularly large. 2 is the minimum
+number allowed, representing the start and end of the curve. 3 will
+result in a start, middle, and end point, meaning 2 curves will be
+generated.
+
+The option to evenly_distribute_anchors is provided so that the
+line segments (the part part of each line remaining after rounding
+off the corners) can be subdivided to a density similar to that of
+the average density of the rounded corners. This may be desirable
+in situations in which an even distribution of curves is desired
+for use in later transformation animations. Be aware, though, that
+enabling this option can result in an an object containing
+significantly more points than the original, especially when the
+rounded corner curves are small.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(n=6, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **n** (*int*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.RegularPolygram.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.RegularPolygram.md
new file mode 100644
index 0000000000000000000000000000000000000000..54b5704a7c3e395d6139a77f2202dad4880d7ece
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.RegularPolygram.md
@@ -0,0 +1,73 @@
+# RegularPolygram
+
+Qualified name: `manim.mobject.geometry.polygram.RegularPolygram`
+
+### *class* RegularPolygram(num_vertices, \*, density=2, radius=1, start_angle=None, \*\*kwargs)
+
+Bases: [`Polygram`](manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram)
+
+A [`Polygram`](manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram) with regularly spaced vertices.
+
+* **Parameters:**
+ * **num_vertices** (*int*) – The number of vertices.
+ * **density** (*int*) –
+
+ The density of the [`RegularPolygram`](#manim.mobject.geometry.polygram.RegularPolygram).
+
+ Can be thought of as how many vertices to hop
+ to draw a line between them. Every `density`-th
+ vertex is connected.
+ * **radius** (*float*) – The radius of the circle that the vertices are placed on.
+ * **start_angle** (*float* *|* *None*) – The angle the vertices start at; the rotation of
+ the [`RegularPolygram`](#manim.mobject.geometry.polygram.RegularPolygram).
+ * **kwargs** (*Any*) – Forwarded to the parent constructor.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(corner_radius=0.5, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **corner_radius** (*float* *|* *list* *[**float* *]*)
+ * **kwargs** (*Any*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.Square.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.Square.md
new file mode 100644
index 0000000000000000000000000000000000000000..5dfe2e6d4496040f752860407a26fd8d963ceb4b
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.Square.md
@@ -0,0 +1,65 @@
+# Square
+
+Qualified name: `manim.mobject.geometry.polygram.Square`
+
+### *class* Square(side_length=2.0, \*\*kwargs)
+
+Bases: [`Rectangle`](manim.mobject.geometry.polygram.Rectangle.md#manim.mobject.geometry.polygram.Rectangle)
+
+A rectangle with equal side lengths.
+
+* **Parameters:**
+ * **side_length** (*float*) – The length of the sides of the square.
+ * **kwargs** (*Any*) – Additional arguments to be passed to [`Rectangle`](manim.mobject.geometry.polygram.Rectangle.md#manim.mobject.geometry.polygram.Rectangle).
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `side_length` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(side_length=2.0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **side_length** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.Star.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.Star.md
new file mode 100644
index 0000000000000000000000000000000000000000..c10cf985915e8e8ef55232856a8e6f60a6714858
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.Star.md
@@ -0,0 +1,119 @@
+# Star
+
+Qualified name: `manim.mobject.geometry.polygram.Star`
+
+### *class* Star(n=5, \*, outer_radius=1, inner_radius=None, density=2, start_angle=1.5707963267948966, \*\*kwargs)
+
+Bases: [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon)
+
+A regular polygram without the intersecting lines.
+
+* **Parameters:**
+ * **n** (*int*) – How many points on the [`Star`](#manim.mobject.geometry.polygram.Star).
+ * **outer_radius** (*float*) – The radius of the circle that the outer vertices are placed on.
+ * **inner_radius** (*float* *|* *None*) –
+
+ The radius of the circle that the inner vertices are placed on.
+
+ If unspecified, the inner radius will be
+ calculated such that the edges of the [`Star`](#manim.mobject.geometry.polygram.Star)
+ perfectly follow the edges of its [`RegularPolygram`](manim.mobject.geometry.polygram.RegularPolygram.md#manim.mobject.geometry.polygram.RegularPolygram)
+ counterpart.
+ * **density** (*int*) –
+
+ The density of the [`Star`](#manim.mobject.geometry.polygram.Star). Only used if
+ `inner_radius` is unspecified.
+
+ See [`RegularPolygram`](manim.mobject.geometry.polygram.RegularPolygram.md#manim.mobject.geometry.polygram.RegularPolygram) for more information.
+ * **start_angle** (*float* *|* *None*) – The angle the vertices start at; the rotation of
+ the [`Star`](#manim.mobject.geometry.polygram.Star).
+ * **kwargs** (*Any*) – Forwardeds to the parent constructor.
+* **Raises:**
+ **ValueError** – If `inner_radius` is unspecified and `density`
+ is not in the range `[1, n/2)`.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.md
new file mode 100644
index 0000000000000000000000000000000000000000..95eef29f43ddbca446f9338b471e0751ef87cbe0
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.polygram.md
@@ -0,0 +1,18 @@
+# polygram
+
+Mobjects that are simple geometric shapes.
+
+### Classes
+
+| [`ConvexHull`](manim.mobject.geometry.polygram.ConvexHull.md#manim.mobject.geometry.polygram.ConvexHull) | Constructs a convex hull for a set of points in no particular order. |
+|----------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`Cutout`](manim.mobject.geometry.polygram.Cutout.md#manim.mobject.geometry.polygram.Cutout) | A shape with smaller cutouts. |
+| [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon) | A shape consisting of one closed loop of vertices. |
+| [`Polygram`](manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram) | A generalized [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon), allowing for disconnected sets of edges. |
+| [`Rectangle`](manim.mobject.geometry.polygram.Rectangle.md#manim.mobject.geometry.polygram.Rectangle) | A quadrilateral with two sets of parallel sides. |
+| [`RegularPolygon`](manim.mobject.geometry.polygram.RegularPolygon.md#manim.mobject.geometry.polygram.RegularPolygon) | An n-sided regular [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon). |
+| [`RegularPolygram`](manim.mobject.geometry.polygram.RegularPolygram.md#manim.mobject.geometry.polygram.RegularPolygram) | A [`Polygram`](manim.mobject.geometry.polygram.Polygram.md#manim.mobject.geometry.polygram.Polygram) with regularly spaced vertices. |
+| [`RoundedRectangle`](manim.mobject.geometry.polygram.RoundedRectangle.md#manim.mobject.geometry.polygram.RoundedRectangle) | A rectangle with rounded corners. |
+| [`Square`](manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square) | A rectangle with equal side lengths. |
+| [`Star`](manim.mobject.geometry.polygram.Star.md#manim.mobject.geometry.polygram.Star) | A regular polygram without the intersecting lines. |
+| [`Triangle`](manim.mobject.geometry.polygram.Triangle.md#manim.mobject.geometry.polygram.Triangle) | An equilateral triangle. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.shape_matchers.BackgroundRectangle.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.shape_matchers.BackgroundRectangle.md
new file mode 100644
index 0000000000000000000000000000000000000000..8bacdf64dc2d07554a3d08b103ac419431ef39ea
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.shape_matchers.BackgroundRectangle.md
@@ -0,0 +1,122 @@
+# BackgroundRectangle
+
+Qualified name: `manim.mobject.geometry.shape\_matchers.BackgroundRectangle`
+
+### *class* BackgroundRectangle(\*mobjects, color=None, stroke_width=0, stroke_opacity=0, fill_opacity=0.75, buff=0, \*\*kwargs)
+
+Bases: [`SurroundingRectangle`](manim.mobject.geometry.shape_matchers.SurroundingRectangle.md#manim.mobject.geometry.shape_matchers.SurroundingRectangle)
+
+A background rectangle. Its default color is the background color
+of the scene.
+
+### Examples
+
+
+
+### Methods
+
+| [`get_fill_color`](#manim.mobject.geometry.shape_matchers.BackgroundRectangle.get_fill_color) | If there are multiple colors (for gradient) this returns the first one |
+|-------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`pointwise_become_partial`](#manim.mobject.geometry.shape_matchers.BackgroundRectangle.pointwise_become_partial) | Given a 2nd [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) `vmobject`, a lower bound `a` and an upper bound `b`, modify this [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)'s points to match the portion of the Bézier spline described by `vmobject.points` with the parameter `t` between `a` and `b`. |
+| `set_style` | |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **stroke_width** (*float*)
+ * **stroke_opacity** (*float*)
+ * **fill_opacity** (*float*)
+ * **buff** (*float*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(\*mobjects, color=None, stroke_width=0, stroke_opacity=0, fill_opacity=0.75, buff=0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **stroke_width** (*float*)
+ * **stroke_opacity** (*float*)
+ * **fill_opacity** (*float*)
+ * **buff** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### get_fill_color()
+
+If there are multiple colors (for gradient)
+this returns the first one
+
+* **Return type:**
+ [*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+
+#### pointwise_become_partial(mobject, a, b)
+
+Given a 2nd [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) `vmobject`, a lower bound `a` and
+an upper bound `b`, modify this [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)’s points to
+match the portion of the Bézier spline described by `vmobject.points`
+with the parameter `t` between `a` and `b`.
+
+* **Parameters:**
+ * **vmobject** – The [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) that will serve as a model.
+ * **a** (*Any*) – The lower bound for `t`.
+ * **b** (*float*) – The upper bound for `t`
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+* **Returns:**
+ The [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) itself, after the transformation.
+* **Return type:**
+ [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+* **Raises:**
+ **TypeError** – If `vmobject` is not an instance of `VMobject`.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.shape_matchers.Cross.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.shape_matchers.Cross.md
new file mode 100644
index 0000000000000000000000000000000000000000..baac581b59a4a3fadfa924736895772464b16086
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.shape_matchers.Cross.md
@@ -0,0 +1,66 @@
+# Cross
+
+Qualified name: `manim.mobject.geometry.shape\_matchers.Cross`
+
+### *class* Cross(mobject=None, stroke_color=ManimColor('#FC6255'), stroke_width=6.0, scale_factor=1.0, \*\*kwargs)
+
+Bases: [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+Creates a cross.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* *None*) – The mobject linked to this instance. It fits the mobject when specified. Defaults to None.
+ * **stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – Specifies the color of the cross lines. Defaults to RED.
+ * **stroke_width** (*float*) – Specifies the width of the cross lines. Defaults to 6.
+ * **scale_factor** (*float*) – Scales the cross to the provided units. Defaults to 1.
+ * **kwargs** (*Any*)
+
+### Examples
+
+
+```python
+from manim import *
+
+class UnderLine(Scene):
+ def construct(self):
+ man = Tex("Manim") # Full Word
+ ul = Underline(man) # Underlining the word
+ self.add(man, ul)
+```
+
+
+class UnderLine(Scene):
+ def construct(self):
+ man = Tex("Manim") # Full Word
+ ul = Underline(man) # Underlining the word
+ self.add(man, ul)
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **buff** (*float*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(mobject, buff=0.1, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **buff** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.shape_matchers.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.shape_matchers.md
new file mode 100644
index 0000000000000000000000000000000000000000..57b7d0c85e0e1a2a240564131a6a73f3d0649ae1
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.shape_matchers.md
@@ -0,0 +1,11 @@
+# shape_matchers
+
+Mobjects used to mark and annotate other mobjects.
+
+### Classes
+
+| [`BackgroundRectangle`](manim.mobject.geometry.shape_matchers.BackgroundRectangle.md#manim.mobject.geometry.shape_matchers.BackgroundRectangle) | A background rectangle. |
+|----------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------|
+| [`Cross`](manim.mobject.geometry.shape_matchers.Cross.md#manim.mobject.geometry.shape_matchers.Cross) | Creates a cross. |
+| [`SurroundingRectangle`](manim.mobject.geometry.shape_matchers.SurroundingRectangle.md#manim.mobject.geometry.shape_matchers.SurroundingRectangle) | A rectangle surrounding a [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) |
+| [`Underline`](manim.mobject.geometry.shape_matchers.Underline.md#manim.mobject.geometry.shape_matchers.Underline) | Creates an underline. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowCircleFilledTip.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowCircleFilledTip.md
new file mode 100644
index 0000000000000000000000000000000000000000..f5084bb9f28107242a7d5f3e1229062d0b6ae496
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowCircleFilledTip.md
@@ -0,0 +1,45 @@
+# ArrowCircleFilledTip
+
+Qualified name: `manim.mobject.geometry.tips.ArrowCircleFilledTip`
+
+### *class* ArrowCircleFilledTip(fill_opacity=1, stroke_width=0, \*\*kwargs)
+
+Bases: [`ArrowCircleTip`](manim.mobject.geometry.tips.ArrowCircleTip.md#manim.mobject.geometry.tips.ArrowCircleTip)
+
+Circular arrow tip with filled tip.
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `base` | The base point of the arrow tip. |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `length` | The length of the arrow tip. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `tip_angle` | The angle of the arrow tip. |
+| `tip_point` | The tip point of the arrow tip. |
+| `vector` | The vector pointing from the base point to the tip point. |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(fill_opacity=1, stroke_width=0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowCircleTip.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowCircleTip.md
new file mode 100644
index 0000000000000000000000000000000000000000..c428d04f486dd3dd34bff210aa8a2549f57a7c65
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowCircleTip.md
@@ -0,0 +1,49 @@
+# ArrowCircleTip
+
+Qualified name: `manim.mobject.geometry.tips.ArrowCircleTip`
+
+### *class* ArrowCircleTip(fill_opacity=0, stroke_width=3, length=0.35, start_angle=3.141592653589793, \*\*kwargs)
+
+Bases: [`ArrowTip`](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip), [`Circle`](manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle)
+
+Circular arrow tip.
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `base` | The base point of the arrow tip. |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `length` | The length of the arrow tip. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `tip_angle` | The angle of the arrow tip. |
+| `tip_point` | The tip point of the arrow tip. |
+| `vector` | The vector pointing from the base point to the tip point. |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **length** (*float*)
+ * **start_angle** (*float*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(fill_opacity=0, stroke_width=3, length=0.35, start_angle=3.141592653589793, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **length** (*float*)
+ * **start_angle** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowSquareFilledTip.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowSquareFilledTip.md
new file mode 100644
index 0000000000000000000000000000000000000000..56f7450638ae6ccccc06f1d9f3e58247a24b2b0b
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowSquareFilledTip.md
@@ -0,0 +1,46 @@
+# ArrowSquareFilledTip
+
+Qualified name: `manim.mobject.geometry.tips.ArrowSquareFilledTip`
+
+### *class* ArrowSquareFilledTip(fill_opacity=1, stroke_width=0, \*\*kwargs)
+
+Bases: [`ArrowSquareTip`](manim.mobject.geometry.tips.ArrowSquareTip.md#manim.mobject.geometry.tips.ArrowSquareTip)
+
+Square arrow tip with filled tip.
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `base` | The base point of the arrow tip. |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `length` | The length of the arrow tip. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `side_length` | |
+| `stroke_color` | |
+| `tip_angle` | The angle of the arrow tip. |
+| `tip_point` | The tip point of the arrow tip. |
+| `vector` | The vector pointing from the base point to the tip point. |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(fill_opacity=1, stroke_width=0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowSquareTip.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowSquareTip.md
new file mode 100644
index 0000000000000000000000000000000000000000..e962842558eb2daf9e90e81f9b065c9d83458419
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowSquareTip.md
@@ -0,0 +1,50 @@
+# ArrowSquareTip
+
+Qualified name: `manim.mobject.geometry.tips.ArrowSquareTip`
+
+### *class* ArrowSquareTip(fill_opacity=0, stroke_width=3, length=0.35, start_angle=3.141592653589793, \*\*kwargs)
+
+Bases: [`ArrowTip`](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip), [`Square`](manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square)
+
+Square arrow tip.
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `base` | The base point of the arrow tip. |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `length` | The length of the arrow tip. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `side_length` | |
+| `stroke_color` | |
+| `tip_angle` | The angle of the arrow tip. |
+| `tip_point` | The tip point of the arrow tip. |
+| `vector` | The vector pointing from the base point to the tip point. |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **length** (*float*)
+ * **start_angle** (*float*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(fill_opacity=0, stroke_width=3, length=0.35, start_angle=3.141592653589793, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **length** (*float*)
+ * **start_angle** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowTip.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowTip.md
new file mode 100644
index 0000000000000000000000000000000000000000..15e27abb71cd24dcd7836148720f1319c5b02700
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowTip.md
@@ -0,0 +1,258 @@
+# ArrowTip
+
+Qualified name: `manim.mobject.geometry.tips.ArrowTip`
+
+### *class* ArrowTip(\*args, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+Base class for arrow tips.
+
+#### SEE ALSO
+[`ArrowTriangleTip`](manim.mobject.geometry.tips.ArrowTriangleTip.md#manim.mobject.geometry.tips.ArrowTriangleTip)
+[`ArrowTriangleFilledTip`](manim.mobject.geometry.tips.ArrowTriangleFilledTip.md#manim.mobject.geometry.tips.ArrowTriangleFilledTip)
+[`ArrowCircleTip`](manim.mobject.geometry.tips.ArrowCircleTip.md#manim.mobject.geometry.tips.ArrowCircleTip)
+[`ArrowCircleFilledTip`](manim.mobject.geometry.tips.ArrowCircleFilledTip.md#manim.mobject.geometry.tips.ArrowCircleFilledTip)
+[`ArrowSquareTip`](manim.mobject.geometry.tips.ArrowSquareTip.md#manim.mobject.geometry.tips.ArrowSquareTip)
+[`ArrowSquareFilledTip`](manim.mobject.geometry.tips.ArrowSquareFilledTip.md#manim.mobject.geometry.tips.ArrowSquareFilledTip)
+[`StealthTip`](manim.mobject.geometry.tips.StealthTip.md#manim.mobject.geometry.tips.StealthTip)
+
+### Examples
+
+Cannot be used directly, only intended for inheritance:
+
+```default
+>>> tip = ArrowTip()
+Traceback (most recent call last):
+...
+NotImplementedError: Has to be implemented in inheriting subclasses.
+```
+
+Instead, use one of the pre-defined ones, or make
+a custom one like this:
+
+
+
+Using a class inherited from [`ArrowTip`](#manim.mobject.geometry.tips.ArrowTip) to get a non-filled
+tip is a shorthand to manually specifying the arrow tip style as follows:
+
+```default
+>>> arrow = Arrow(np.array([0, 0, 0]), np.array([1, 1, 0]),
+... tip_style={'fill_opacity': 0, 'stroke_width': 3})
+```
+
+The following example illustrates the usage of all of the predefined
+arrow tips.
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|----------------------------------------------------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| [`base`](#manim.mobject.geometry.tips.ArrowTip.base) | The base point of the arrow tip. |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| [`length`](#manim.mobject.geometry.tips.ArrowTip.length) | The length of the arrow tip. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| [`tip_angle`](#manim.mobject.geometry.tips.ArrowTip.tip_angle) | The angle of the arrow tip. |
+| [`tip_point`](#manim.mobject.geometry.tips.ArrowTip.tip_point) | The tip point of the arrow tip. |
+| [`vector`](#manim.mobject.geometry.tips.ArrowTip.vector) | The vector pointing from the base point to the tip point. |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **args** (*Any*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(\*args, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **args** (*Any*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### *property* base *: [Point3D](manim.typing.md#manim.typing.Point3D)*
+
+The base point of the arrow tip.
+
+This is the point connecting to the arrow line.
+
+### Examples
+
+```default
+>>> from manim import Arrow
+>>> arrow = Arrow(np.array([0, 0, 0]), np.array([2, 0, 0]), buff=0)
+>>> arrow.tip.base.round(2) + 0. # add 0. to avoid negative 0 in output
+array([1.65, 0. , 0. ])
+```
+
+#### *property* length *: float*
+
+The length of the arrow tip.
+
+### Examples
+
+```default
+>>> from manim import Arrow
+>>> arrow = Arrow(np.array([0, 0, 0]), np.array([1, 2, 0]))
+>>> round(arrow.tip.length, 3)
+0.35
+```
+
+#### *property* tip_angle *: float*
+
+The angle of the arrow tip.
+
+### Examples
+
+```default
+>>> from manim import Arrow
+>>> arrow = Arrow(np.array([0, 0, 0]), np.array([1, 1, 0]), buff=0)
+>>> bool(round(arrow.tip.tip_angle, 5) == round(PI/4, 5))
+True
+```
+
+#### *property* tip_point *: [Point3D](manim.typing.md#manim.typing.Point3D)*
+
+The tip point of the arrow tip.
+
+### Examples
+
+```default
+>>> from manim import Arrow
+>>> arrow = Arrow(np.array([0, 0, 0]), np.array([2, 0, 0]), buff=0)
+>>> arrow.tip.tip_point.round(2) + 0.
+array([2., 0., 0.])
+```
+
+#### *property* vector *: [Vector3D](manim.typing.md#manim.typing.Vector3D)*
+
+The vector pointing from the base point to the tip point.
+
+### Examples
+
+```default
+>>> from manim import Arrow
+>>> arrow = Arrow(np.array([0, 0, 0]), np.array([2, 2, 0]), buff=0)
+>>> arrow.tip.vector.round(2) + 0.
+array([0.25, 0.25, 0. ])
+```
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowTriangleFilledTip.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowTriangleFilledTip.md
new file mode 100644
index 0000000000000000000000000000000000000000..a9967579cd0c9eaf99d717b0fa2eb69d695a59bb
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowTriangleFilledTip.md
@@ -0,0 +1,47 @@
+# ArrowTriangleFilledTip
+
+Qualified name: `manim.mobject.geometry.tips.ArrowTriangleFilledTip`
+
+### *class* ArrowTriangleFilledTip(fill_opacity=1, stroke_width=0, \*\*kwargs)
+
+Bases: [`ArrowTriangleTip`](manim.mobject.geometry.tips.ArrowTriangleTip.md#manim.mobject.geometry.tips.ArrowTriangleTip)
+
+Triangular arrow tip with filled tip.
+
+This is the default arrow tip shape.
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `base` | The base point of the arrow tip. |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `length` | The length of the arrow tip. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `tip_angle` | The angle of the arrow tip. |
+| `tip_point` | The tip point of the arrow tip. |
+| `vector` | The vector pointing from the base point to the tip point. |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(fill_opacity=1, stroke_width=0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowTriangleTip.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowTriangleTip.md
new file mode 100644
index 0000000000000000000000000000000000000000..819a8b24dc0e4fe0824c09a09e12e0493ac0ce6d
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.ArrowTriangleTip.md
@@ -0,0 +1,51 @@
+# ArrowTriangleTip
+
+Qualified name: `manim.mobject.geometry.tips.ArrowTriangleTip`
+
+### *class* ArrowTriangleTip(fill_opacity=0, stroke_width=3, length=0.35, width=0.35, start_angle=3.141592653589793, \*\*kwargs)
+
+Bases: [`ArrowTip`](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip), [`Triangle`](manim.mobject.geometry.polygram.Triangle.md#manim.mobject.geometry.polygram.Triangle)
+
+Triangular arrow tip.
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `base` | The base point of the arrow tip. |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `length` | The length of the arrow tip. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `tip_angle` | The angle of the arrow tip. |
+| `tip_point` | The tip point of the arrow tip. |
+| `vector` | The vector pointing from the base point to the tip point. |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **length** (*float*)
+ * **width** (*float*)
+ * **start_angle** (*float*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(fill_opacity=0, stroke_width=3, length=0.35, width=0.35, start_angle=3.141592653589793, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **length** (*float*)
+ * **width** (*float*)
+ * **start_angle** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.StealthTip.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.StealthTip.md
new file mode 100644
index 0000000000000000000000000000000000000000..dfb2d95c3ffd407c0c31e15b2c46bf5e692aa66b
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.StealthTip.md
@@ -0,0 +1,58 @@
+# StealthTip
+
+Qualified name: `manim.mobject.geometry.tips.StealthTip`
+
+### *class* StealthTip(fill_opacity=1, stroke_width=3, length=0.175, start_angle=3.141592653589793, \*\*kwargs)
+
+Bases: [`ArrowTip`](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip)
+
+‘Stealth’ fighter / kite arrow shape.
+
+Naming is inspired by the corresponding
+[TikZ arrow shape](https://tikz.dev/tikz-arrows#sec-16.3).
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|------------------------------------------------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `base` | The base point of the arrow tip. |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| [`length`](#manim.mobject.geometry.tips.StealthTip.length) | The length of the arrow tip. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `tip_angle` | The angle of the arrow tip. |
+| `tip_point` | The tip point of the arrow tip. |
+| `vector` | The vector pointing from the base point to the tip point. |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **length** (*float*)
+ * **start_angle** (*float*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(fill_opacity=1, stroke_width=3, length=0.175, start_angle=3.141592653589793, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **length** (*float*)
+ * **start_angle** (*float*)
+ * **kwargs** (*Any*)
+
+#### *property* length *: float*
+
+The length of the arrow tip.
+
+In this case, the length is computed as the height of
+the triangle encompassing the stealth tip (otherwise,
+the tip is scaled too large).
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.md
new file mode 100644
index 0000000000000000000000000000000000000000..ef642ed17c2f5759535fd15e051d98b05a67ada4
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.geometry.tips.md
@@ -0,0 +1,15 @@
+# tips
+
+A collection of tip mobjects for use with [`TipableVMobject`](manim.mobject.geometry.arc.TipableVMobject.md#manim.mobject.geometry.arc.TipableVMobject).
+
+### Classes
+
+| [`ArrowCircleFilledTip`](manim.mobject.geometry.tips.ArrowCircleFilledTip.md#manim.mobject.geometry.tips.ArrowCircleFilledTip) | Circular arrow tip with filled tip. |
+|--------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------|
+| [`ArrowCircleTip`](manim.mobject.geometry.tips.ArrowCircleTip.md#manim.mobject.geometry.tips.ArrowCircleTip) | Circular arrow tip. |
+| [`ArrowSquareFilledTip`](manim.mobject.geometry.tips.ArrowSquareFilledTip.md#manim.mobject.geometry.tips.ArrowSquareFilledTip) | Square arrow tip with filled tip. |
+| [`ArrowSquareTip`](manim.mobject.geometry.tips.ArrowSquareTip.md#manim.mobject.geometry.tips.ArrowSquareTip) | Square arrow tip. |
+| [`ArrowTip`](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip) | Base class for arrow tips. |
+| [`ArrowTriangleFilledTip`](manim.mobject.geometry.tips.ArrowTriangleFilledTip.md#manim.mobject.geometry.tips.ArrowTriangleFilledTip) | Triangular arrow tip with filled tip. |
+| [`ArrowTriangleTip`](manim.mobject.geometry.tips.ArrowTriangleTip.md#manim.mobject.geometry.tips.ArrowTriangleTip) | Triangular arrow tip. |
+| [`StealthTip`](manim.mobject.geometry.tips.StealthTip.md#manim.mobject.geometry.tips.StealthTip) | 'Stealth' fighter / kite arrow shape. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graph.DiGraph.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graph.DiGraph.md
new file mode 100644
index 0000000000000000000000000000000000000000..106918214d0651ae1dcacdb7965121517c24ddb7
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graph.DiGraph.md
@@ -0,0 +1,350 @@
+# DiGraph
+
+Qualified name: `manim.mobject.graph.DiGraph`
+
+### *class* DiGraph(vertices, edges, labels=False, label_fill_color=ManimColor('#000000'), layout='spring', layout_scale=2, layout_config=None, vertex_type=, vertex_config=None, vertex_mobjects=None, edge_type=, partitions=None, root_vertex=None, edge_config=None)
+
+Bases: [`GenericGraph`](manim.mobject.graph.GenericGraph.md#manim.mobject.graph.GenericGraph)
+
+A directed graph.
+
+#### NOTE
+In contrast to undirected graphs, the order in which vertices in a given
+edge are specified is relevant here.
+
+#### SEE ALSO
+[`GenericGraph`](manim.mobject.graph.GenericGraph.md#manim.mobject.graph.GenericGraph)
+
+* **Parameters:**
+ * **vertices** (*Sequence* *[**Hashable* *]*) – A list of vertices. Must be hashable elements.
+ * **edges** (*Sequence* *[**tuple* *[**Hashable* *,* *Hashable* *]* *]*) – A list of edges, specified as tuples `(u, v)` where both `u`
+ and `v` are vertices. The edge is directed from `u` to `v`.
+ * **labels** (*bool* *|* *dict*) – Controls whether or not vertices are labeled. If `False` (the default),
+ the vertices are not labeled; if `True` they are labeled using their
+ names (as specified in `vertices`) via [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex). Alternatively,
+ custom labels can be specified by passing a dictionary whose keys are
+ the vertices, and whose values are the corresponding vertex labels
+ (rendered via, e.g., [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) or [`Tex`](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex)).
+ * **label_fill_color** (*str*) – Sets the fill color of the default labels generated when `labels`
+ is set to `True`. Has no effect for other values of `labels`.
+ * **layout** (*LayoutName* *|* *dict* *[**Hashable* *,* [*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *]* *|* [*LayoutFunction*](manim.mobject.graph.LayoutFunction.md#manim.mobject.graph.LayoutFunction)) – Either one of `"spring"` (the default), `"circular"`, `"kamada_kawai"`,
+ `"planar"`, `"random"`, `"shell"`, `"spectral"`, `"spiral"`, `"tree"`, and `"partite"`
+ for automatic vertex positioning using `networkx`
+ (see [their documentation](https://networkx.org/documentation/stable/reference/drawing.html#module-networkx.drawing.layout)
+ for more details), or a dictionary specifying a coordinate (value)
+ for each vertex (key) for manual positioning.
+ * **layout_config** (*dict* *|* *None*) – Only for automatically generated layouts. A dictionary whose entries
+ are passed as keyword arguments to the automatic layout algorithm
+ specified via `layout` of `networkx`.
+ The `tree` layout also accepts a special parameter `vertex_spacing`
+ passed as a keyword argument inside the `layout_config` dictionary.
+ Passing a tuple `(space_x, space_y)` as this argument overrides
+ the value of `layout_scale` and ensures that vertices are arranged
+ in a way such that the centers of siblings in the same layer are
+ at least `space_x` units apart horizontally, and neighboring layers
+ are spaced `space_y` units vertically.
+ * **layout_scale** (*float* *|* *tuple* *[**float* *,* *float* *,* *float* *]*) – The scale of automatically generated layouts: the vertices will
+ be arranged such that the coordinates are located within the
+ interval `[-scale, scale]`. Some layouts accept a tuple `(scale_x, scale_y)`
+ causing the first coordinate to be in the interval `[-scale_x, scale_x]`,
+ and the second in `[-scale_y, scale_y]`. Default: 2.
+ * **vertex_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The mobject class used for displaying vertices in the scene.
+ * **vertex_config** (*dict* *|* *None*) – Either a dictionary containing keyword arguments to be passed to
+ the class specified via `vertex_type`, or a dictionary whose keys
+ are the vertices, and whose values are dictionaries containing keyword
+ arguments for the mobject related to the corresponding vertex.
+ * **vertex_mobjects** (*dict* *|* *None*) – A dictionary whose keys are the vertices, and whose values are
+ mobjects to be used as vertices. Passing vertices here overrides
+ all other configuration options for a vertex.
+ * **edge_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The mobject class used for displaying edges in the scene.
+ * **edge_config** (*dict* *|* *None*) – Either a dictionary containing keyword arguments to be passed
+ to the class specified via `edge_type`, or a dictionary whose
+ keys are the edges, and whose values are dictionaries containing
+ keyword arguments for the mobject related to the corresponding edge.
+ You can further customize the tip by adding a `tip_config` dictionary
+ for global styling, or by adding the dict to a specific `edge_config`.
+ * **partitions** (*Sequence* *[**Sequence* *[**Hashable* *]* *]* *|* *None*)
+ * **root_vertex** (*Hashable* *|* *None*)
+
+### Examples
+
+
+
+### Methods
+
+| [`update_edges`](#manim.mobject.graph.DiGraph.update_edges) | Updates the edges to stick at their corresponding vertices. |
+|---------------------------------------------------------------|---------------------------------------------------------------|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### *static* \_empty_networkx_graph()
+
+Return an empty networkx graph for the given graph type.
+
+* **Return type:**
+ *DiGraph*
+
+#### \_original_\_init_\_(vertices, edges, labels=False, label_fill_color=ManimColor('#000000'), layout='spring', layout_scale=2, layout_config=None, vertex_type=, vertex_config=None, vertex_mobjects=None, edge_type=, partitions=None, root_vertex=None, edge_config=None)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **vertices** (*Sequence* *[**Hashable* *]*)
+ * **edges** (*Sequence* *[**tuple* *[**Hashable* *,* *Hashable* *]* *]*)
+ * **labels** (*bool* *|* *dict*)
+ * **label_fill_color** (*str*)
+ * **layout** (*Literal* *[* *'circular'* *,* *'kamada_kawai'* *,* *'partite'* *,* *'planar'* *,* *'random'* *,* *'shell'* *,* *'spectral'* *,* *'spiral'* *,* *'spring'* *,* *'tree'* *]* *|* *dict* *[* *~collections.abc.Hashable* *,* *~manim.typing.Point3DLike* *]* *|* *~manim.mobject.graph.LayoutFunction*)
+ * **layout_scale** (*float* *|* *tuple* *[**float* *,* *float* *,* *float* *]*)
+ * **layout_config** (*dict* *|* *None*)
+ * **vertex_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*)
+ * **vertex_config** (*dict* *|* *None*)
+ * **vertex_mobjects** (*dict* *|* *None*)
+ * **edge_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*)
+ * **partitions** (*Sequence* *[**Sequence* *[**Hashable* *]* *]* *|* *None*)
+ * **root_vertex** (*Hashable* *|* *None*)
+ * **edge_config** (*dict* *|* *None*)
+* **Return type:**
+ None
+
+#### \_populate_edge_dict(edges, edge_type)
+
+Helper method for populating the edges of the graph.
+
+* **Parameters:**
+ * **edges** (*list* *[**tuple* *[**Hashable* *,* *Hashable* *]* *]*)
+ * **edge_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*)
+
+#### update_edges(graph)
+
+Updates the edges to stick at their corresponding vertices.
+
+Arrow tips need to be repositioned since otherwise they can be
+deformed.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graph.GenericGraph.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graph.GenericGraph.md
new file mode 100644
index 0000000000000000000000000000000000000000..22c1a2685e1232291c0296c53d625f0b9022550a
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graph.GenericGraph.md
@@ -0,0 +1,367 @@
+# GenericGraph
+
+Qualified name: `manim.mobject.graph.GenericGraph`
+
+### *class* GenericGraph(vertices, edges, labels=False, label_fill_color=ManimColor('#000000'), layout='spring', layout_scale=2, layout_config=None, vertex_type=, vertex_config=None, vertex_mobjects=None, edge_type=, partitions=None, root_vertex=None, edge_config=None)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+Abstract base class for graphs (that is, a collection of vertices
+connected with edges).
+
+Graphs can be instantiated by passing both a list of (distinct, hashable)
+vertex names, together with list of edges (as tuples of vertex names). See
+the examples for concrete implementations of this class for details.
+
+#### NOTE
+This implementation uses updaters to make the edges move with
+the vertices.
+
+#### SEE ALSO
+[`Graph`](manim.mobject.graph.Graph.md#manim.mobject.graph.Graph), [`DiGraph`](manim.mobject.graph.DiGraph.md#manim.mobject.graph.DiGraph)
+
+* **Parameters:**
+ * **vertices** (*Sequence* *[**Hashable* *]*) – A list of vertices. Must be hashable elements.
+ * **edges** (*Sequence* *[**tuple* *[**Hashable* *,* *Hashable* *]* *]*) – A list of edges, specified as tuples `(u, v)` where both `u`
+ and `v` are vertices.
+ * **labels** (*bool* *|* *dict*) – Controls whether or not vertices are labeled. If `False` (the default),
+ the vertices are not labeled; if `True` they are labeled using their
+ names (as specified in `vertices`) via [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex). Alternatively,
+ custom labels can be specified by passing a dictionary whose keys are
+ the vertices, and whose values are the corresponding vertex labels
+ (rendered via, e.g., [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) or [`Tex`](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex)).
+ * **label_fill_color** (*str*) – Sets the fill color of the default labels generated when `labels`
+ is set to `True`. Has no effect for other values of `labels`.
+ * **layout** (*LayoutName* *|* *dict* *[**Hashable* *,* [*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *]* *|* [*LayoutFunction*](manim.mobject.graph.LayoutFunction.md#manim.mobject.graph.LayoutFunction)) – Either one of `"spring"` (the default), `"circular"`, `"kamada_kawai"`,
+ `"planar"`, `"random"`, `"shell"`, `"spectral"`, `"spiral"`, `"tree"`, and `"partite"`
+ for automatic vertex positioning primarily using `networkx`
+ (see [their documentation](https://networkx.org/documentation/stable/reference/drawing.html#module-networkx.drawing.layout)
+ for more details), a dictionary specifying a coordinate (value)
+ for each vertex (key) for manual positioning, or a .:class:~.LayoutFunction with a user-defined automatic layout.
+ * **layout_config** (*dict* *|* *None*) – Only for automatic layouts. A dictionary whose entries
+ are passed as keyword arguments to the named layout or automatic layout function
+ specified via `layout`.
+ The `tree` layout also accepts a special parameter `vertex_spacing`
+ passed as a keyword argument inside the `layout_config` dictionary.
+ Passing a tuple `(space_x, space_y)` as this argument overrides
+ the value of `layout_scale` and ensures that vertices are arranged
+ in a way such that the centers of siblings in the same layer are
+ at least `space_x` units apart horizontally, and neighboring layers
+ are spaced `space_y` units vertically.
+ * **layout_scale** (*float* *|* *tuple* *[**float* *,* *float* *,* *float* *]*) – The scale of automatically generated layouts: the vertices will
+ be arranged such that the coordinates are located within the
+ interval `[-scale, scale]`. Some layouts accept a tuple `(scale_x, scale_y)`
+ causing the first coordinate to be in the interval `[-scale_x, scale_x]`,
+ and the second in `[-scale_y, scale_y]`. Default: 2.
+ * **vertex_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The mobject class used for displaying vertices in the scene.
+ * **vertex_config** (*dict* *|* *None*) – Either a dictionary containing keyword arguments to be passed to
+ the class specified via `vertex_type`, or a dictionary whose keys
+ are the vertices, and whose values are dictionaries containing keyword
+ arguments for the mobject related to the corresponding vertex.
+ * **vertex_mobjects** (*dict* *|* *None*) – A dictionary whose keys are the vertices, and whose values are
+ mobjects to be used as vertices. Passing vertices here overrides
+ all other configuration options for a vertex.
+ * **edge_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The mobject class used for displaying edges in the scene.
+ Must be a subclass of [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line) for default updaters to work.
+ * **edge_config** (*dict* *|* *None*) – Either a dictionary containing keyword arguments to be passed
+ to the class specified via `edge_type`, or a dictionary whose
+ keys are the edges, and whose values are dictionaries containing
+ keyword arguments for the mobject related to the corresponding edge.
+ * **partitions** (*Sequence* *[**Sequence* *[**Hashable* *]* *]* *|* *None*)
+ * **root_vertex** (*Hashable* *|* *None*)
+
+### Methods
+
+| [`add_edges`](#manim.mobject.graph.GenericGraph.add_edges) | Add new edges to the graph. |
+|------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`add_vertices`](#manim.mobject.graph.GenericGraph.add_vertices) | Add a list of vertices to the graph. |
+| [`change_layout`](#manim.mobject.graph.GenericGraph.change_layout) | Change the layout of this graph. |
+| [`from_networkx`](#manim.mobject.graph.GenericGraph.from_networkx) | Build a [`Graph`](manim.mobject.graph.Graph.md#manim.mobject.graph.Graph) or [`DiGraph`](manim.mobject.graph.DiGraph.md#manim.mobject.graph.DiGraph) from a given `networkx` graph. |
+| [`remove_edges`](#manim.mobject.graph.GenericGraph.remove_edges) | Remove several edges from the graph. |
+| [`remove_vertices`](#manim.mobject.graph.GenericGraph.remove_vertices) | Remove several vertices from the graph. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_add_edge(edge, edge_type=, edge_config=None)
+
+Add a new edge to the graph.
+
+* **Parameters:**
+ * **edge** (*tuple* *[**Hashable* *,* *Hashable* *]*) – The edge (as a tuple of vertex identifiers) to be added. If a non-existing
+ vertex is passed, a new vertex with default settings will be created. Create
+ new vertices yourself beforehand to customize them.
+ * **edge_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The mobject class used for displaying edges in the scene.
+ * **edge_config** (*dict* *|* *None*) – A dictionary containing keyword arguments to be passed
+ to the class specified via `edge_type`.
+* **Returns:**
+ A group containing all newly added vertices and edges.
+* **Return type:**
+ [Group](manim.mobject.mobject.Group.md#manim.mobject.mobject.Group)
+
+#### \_add_vertex(vertex, position=None, label=False, label_fill_color=ManimColor('#000000'), vertex_type=, vertex_config=None, vertex_mobject=None)
+
+Add a vertex to the graph.
+
+* **Parameters:**
+ * **vertex** (*Hashable*) – A hashable vertex identifier.
+ * **position** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* *None*) – The coordinates where the new vertex should be added. If `None`, the center
+ of the graph is used.
+ * **label** (*bool*) – Controls whether or not the vertex is labeled. If `False` (the default),
+ the vertex is not labeled; if `True` it is labeled using its
+ names (as specified in `vertex`) via [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex). Alternatively,
+ any [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) can be passed to be used as the label.
+ * **label_fill_color** (*str*) – Sets the fill color of the default labels generated when `labels`
+ is set to `True`. Has no effect for other values of `label`.
+ * **vertex_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The mobject class used for displaying vertices in the scene.
+ * **vertex_config** (*dict* *|* *None*) – A dictionary containing keyword arguments to be passed to
+ the class specified via `vertex_type`.
+ * **vertex_mobject** (*dict* *|* *None*) – The mobject to be used as the vertex. Overrides all other
+ vertex customization options.
+* **Return type:**
+ [Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+#### *static* \_empty_networkx_graph()
+
+Return an empty networkx graph for the given graph type.
+
+* **Return type:**
+ *Graph*
+
+#### \_original_\_init_\_(vertices, edges, labels=False, label_fill_color=ManimColor('#000000'), layout='spring', layout_scale=2, layout_config=None, vertex_type=, vertex_config=None, vertex_mobjects=None, edge_type=, partitions=None, root_vertex=None, edge_config=None)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **vertices** (*Sequence* *[**Hashable* *]*)
+ * **edges** (*Sequence* *[**tuple* *[**Hashable* *,* *Hashable* *]* *]*)
+ * **labels** (*bool* *|* *dict*)
+ * **label_fill_color** (*str*)
+ * **layout** (*Literal* *[* *'circular'* *,* *'kamada_kawai'* *,* *'partite'* *,* *'planar'* *,* *'random'* *,* *'shell'* *,* *'spectral'* *,* *'spiral'* *,* *'spring'* *,* *'tree'* *]* *|* *dict* *[* *~collections.abc.Hashable* *,* *~manim.typing.Point3DLike* *]* *|* *~manim.mobject.graph.LayoutFunction*)
+ * **layout_scale** (*float* *|* *tuple* *[**float* *,* *float* *,* *float* *]*)
+ * **layout_config** (*dict* *|* *None*)
+ * **vertex_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*)
+ * **vertex_config** (*dict* *|* *None*)
+ * **vertex_mobjects** (*dict* *|* *None*)
+ * **edge_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*)
+ * **partitions** (*Sequence* *[**Sequence* *[**Hashable* *]* *]* *|* *None*)
+ * **root_vertex** (*Hashable* *|* *None*)
+ * **edge_config** (*dict* *|* *None*)
+* **Return type:**
+ None
+
+#### \_populate_edge_dict(edges, edge_type)
+
+Helper method for populating the edges of the graph.
+
+* **Parameters:**
+ * **edges** (*list* *[**tuple* *[**Hashable* *,* *Hashable* *]* *]*)
+ * **edge_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*)
+
+#### \_remove_edge(edge)
+
+Remove an edge from the graph.
+
+* **Parameters:**
+ **edge** (*tuple* *[**Hashable* *]*) – The edge (i.e., a tuple of vertex identifiers) to be removed from the graph.
+* **Returns:**
+ The removed edge.
+* **Return type:**
+ [Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+#### \_remove_vertex(vertex)
+
+Remove a vertex (as well as all incident edges) from the graph.
+
+* **Parameters:**
+ **vertex** – The identifier of a vertex to be removed.
+* **Returns:**
+ A mobject containing all removed objects.
+* **Return type:**
+ [Group](manim.mobject.mobject.Group.md#manim.mobject.mobject.Group)
+
+#### add_edges(\*edges, edge_type=, edge_config=None, \*\*kwargs)
+
+Add new edges to the graph.
+
+* **Parameters:**
+ * **edges** (*tuple* *[**Hashable* *,* *Hashable* *]*) – Edges (as tuples of vertex identifiers) to be added. If a non-existing
+ vertex is passed, a new vertex with default settings will be created. Create
+ new vertices yourself beforehand to customize them.
+ * **edge_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The mobject class used for displaying edges in the scene.
+ * **edge_config** (*dict* *|* *None*) – A dictionary either containing keyword arguments to be passed
+ to the class specified via `edge_type`, or a dictionary
+ whose keys are the edge tuples, and whose values are dictionaries
+ containing keyword arguments to be passed for the construction
+ of the corresponding edge.
+ * **kwargs** – Any further keyword arguments are passed to [`add_vertices()`](#manim.mobject.graph.GenericGraph.add_vertices)
+ which is used to create new vertices in the passed edges.
+* **Returns:**
+ A group containing all newly added vertices and edges.
+* **Return type:**
+ [Group](manim.mobject.mobject.Group.md#manim.mobject.mobject.Group)
+
+#### add_vertices(\*vertices, positions=None, labels=False, label_fill_color=ManimColor('#000000'), vertex_type=, vertex_config=None, vertex_mobjects=None)
+
+Add a list of vertices to the graph.
+
+* **Parameters:**
+ * **vertices** (*Hashable*) – Hashable vertex identifiers.
+ * **positions** (*dict* *|* *None*) – A dictionary specifying the coordinates where the new vertices should be added.
+ If `None`, all vertices are created at the center of the graph.
+ * **labels** (*bool*) – Controls whether or not the vertex is labeled. If `False` (the default),
+ the vertex is not labeled; if `True` it is labeled using its
+ names (as specified in `vertex`) via [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex). Alternatively,
+ any [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) can be passed to be used as the label.
+ * **label_fill_color** (*str*) – Sets the fill color of the default labels generated when `labels`
+ is set to `True`. Has no effect for other values of `labels`.
+ * **vertex_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The mobject class used for displaying vertices in the scene.
+ * **vertex_config** (*dict* *|* *None*) – A dictionary containing keyword arguments to be passed to
+ the class specified via `vertex_type`.
+ * **vertex_mobjects** (*dict* *|* *None*) – A dictionary whose keys are the vertex identifiers, and whose
+ values are mobjects that should be used as vertices. Overrides
+ all other vertex customization options.
+ * **self** ([*Graph*](manim.mobject.graph.Graph.md#manim.mobject.graph.Graph))
+
+#### change_layout(layout='spring', layout_scale=2, layout_config=None, partitions=None, root_vertex=None)
+
+Change the layout of this graph.
+
+See the documentation of [`Graph`](manim.mobject.graph.Graph.md#manim.mobject.graph.Graph) for details about the
+keyword arguments.
+
+### Examples
+
+
+```python
+from manim import *
+
+import networkx as nx
+
+nxgraph = nx.erdos_renyi_graph(14, 0.5)
+
+class ImportNetworkxGraph(Scene):
+ def construct(self):
+ G = Graph.from_networkx(nxgraph, layout="spring", layout_scale=3.5)
+ self.play(Create(G))
+ self.play(*[G[v].animate.move_to(5*RIGHT*np.cos(ind/7 * PI) +
+ 3*UP*np.sin(ind/7 * PI))
+ for ind, v in enumerate(G.vertices)])
+ self.play(Uncreate(G))
+```
+
+
+import networkx as nx
+
+nxgraph = nx.erdos_renyi_graph(14, 0.5)
+
+class ImportNetworkxGraph(Scene):
+ def construct(self):
+ G = Graph.from_networkx(nxgraph, layout="spring", layout_scale=3.5)
+ self.play(Create(G))
+ self.play(\*[G[v].animate.move_to(5\*RIGHT\*np.cos(ind/7 \* PI) +
+ 3\*UP\*np.sin(ind/7 \* PI))
+ for ind, v in enumerate(G.vertices)])
+ self.play(Uncreate(G))
+
+
+
+#### remove_edges(\*edges)
+
+Remove several edges from the graph.
+
+* **Parameters:**
+ **edges** (*tuple* *[**Hashable* *]*) – Edges to be removed from the graph.
+* **Returns:**
+ A group containing all removed edges.
+* **Return type:**
+ [Group](manim.mobject.mobject.Group.md#manim.mobject.mobject.Group)
+
+#### remove_vertices(\*vertices)
+
+Remove several vertices from the graph.
+
+* **Parameters:**
+ **vertices** – Vertices to be removed from the graph.
+
+### Examples
+
+```default
+>>> G = Graph([1, 2, 3], [(1, 2), (2, 3)])
+>>> removed = G.remove_vertices(2, 3); removed
+VGroup(Line, Line, Dot, Dot)
+>>> G
+Undirected graph on 1 vertices and 0 edges
+```
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graph.Graph.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graph.Graph.md
new file mode 100644
index 0000000000000000000000000000000000000000..14ec909995c82b043c1afd2da02199e1e652fee0
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graph.Graph.md
@@ -0,0 +1,492 @@
+# Graph
+
+Qualified name: `manim.mobject.graph.Graph`
+
+### *class* Graph(vertices, edges, labels=False, label_fill_color=ManimColor('#000000'), layout='spring', layout_scale=2, layout_config=None, vertex_type=, vertex_config=None, vertex_mobjects=None, edge_type=, partitions=None, root_vertex=None, edge_config=None)
+
+Bases: [`GenericGraph`](manim.mobject.graph.GenericGraph.md#manim.mobject.graph.GenericGraph)
+
+An undirected graph (vertices connected with edges).
+
+The graph comes with an updater which makes the edges stick to
+the vertices when moved around. See [`DiGraph`](manim.mobject.graph.DiGraph.md#manim.mobject.graph.DiGraph) for
+a version with directed edges.
+
+#### SEE ALSO
+[`GenericGraph`](manim.mobject.graph.GenericGraph.md#manim.mobject.graph.GenericGraph)
+
+* **Parameters:**
+ * **vertices** (*Sequence* *[**Hashable* *]*) – A list of vertices. Must be hashable elements.
+ * **edges** (*Sequence* *[**tuple* *[**Hashable* *,* *Hashable* *]* *]*) – A list of edges, specified as tuples `(u, v)` where both `u`
+ and `v` are vertices. The vertex order is irrelevant.
+ * **labels** (*bool* *|* *dict*) – Controls whether or not vertices are labeled. If `False` (the default),
+ the vertices are not labeled; if `True` they are labeled using their
+ names (as specified in `vertices`) via [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex). Alternatively,
+ custom labels can be specified by passing a dictionary whose keys are
+ the vertices, and whose values are the corresponding vertex labels
+ (rendered via, e.g., [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) or [`Tex`](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex)).
+ * **label_fill_color** (*str*) – Sets the fill color of the default labels generated when `labels`
+ is set to `True`. Has no effect for other values of `labels`.
+ * **layout** (*LayoutName* *|* *dict* *[**Hashable* *,* [*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *]* *|* [*LayoutFunction*](manim.mobject.graph.LayoutFunction.md#manim.mobject.graph.LayoutFunction)) – Either one of `"spring"` (the default), `"circular"`, `"kamada_kawai"`,
+ `"planar"`, `"random"`, `"shell"`, `"spectral"`, `"spiral"`, `"tree"`, and `"partite"`
+ for automatic vertex positioning using `networkx`
+ (see [their documentation](https://networkx.org/documentation/stable/reference/drawing.html#module-networkx.drawing.layout)
+ for more details), or a dictionary specifying a coordinate (value)
+ for each vertex (key) for manual positioning.
+ * **layout_config** (*dict* *|* *None*) – Only for automatically generated layouts. A dictionary whose entries
+ are passed as keyword arguments to the automatic layout algorithm
+ specified via `layout` of `networkx`.
+ The `tree` layout also accepts a special parameter `vertex_spacing`
+ passed as a keyword argument inside the `layout_config` dictionary.
+ Passing a tuple `(space_x, space_y)` as this argument overrides
+ the value of `layout_scale` and ensures that vertices are arranged
+ in a way such that the centers of siblings in the same layer are
+ at least `space_x` units apart horizontally, and neighboring layers
+ are spaced `space_y` units vertically.
+ * **layout_scale** (*float* *|* *tuple* *[**float* *,* *float* *,* *float* *]*) – The scale of automatically generated layouts: the vertices will
+ be arranged such that the coordinates are located within the
+ interval `[-scale, scale]`. Some layouts accept a tuple `(scale_x, scale_y)`
+ causing the first coordinate to be in the interval `[-scale_x, scale_x]`,
+ and the second in `[-scale_y, scale_y]`. Default: 2.
+ * **vertex_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The mobject class used for displaying vertices in the scene.
+ * **vertex_config** (*dict* *|* *None*) – Either a dictionary containing keyword arguments to be passed to
+ the class specified via `vertex_type`, or a dictionary whose keys
+ are the vertices, and whose values are dictionaries containing keyword
+ arguments for the mobject related to the corresponding vertex.
+ * **vertex_mobjects** (*dict* *|* *None*) – A dictionary whose keys are the vertices, and whose values are
+ mobjects to be used as vertices. Passing vertices here overrides
+ all other configuration options for a vertex.
+ * **edge_type** (*type* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The mobject class used for displaying edges in the scene.
+ * **edge_config** (*dict* *|* *None*) – Either a dictionary containing keyword arguments to be passed
+ to the class specified via `edge_type`, or a dictionary whose
+ keys are the edges, and whose values are dictionaries containing
+ keyword arguments for the mobject related to the corresponding edge.
+ * **partitions** (*Sequence* *[**Sequence* *[**Hashable* *]* *]* *|* *None*)
+ * **root_vertex** (*Hashable* *|* *None*)
+
+### Examples
+
+First, we create a small graph and demonstrate that the edges move
+together with the vertices.
+
+
+
+The vertices in graphs can be labeled, and configurations for vertices
+and edges can be modified both by default and for specific vertices and
+edges.
+
+#### NOTE
+In `edge_config`, edges can be passed in both directions: if
+`(u, v)` is an edge in the graph, both `(u, v)` as well
+as `(v, u)` can be used as keys in the dictionary.
+
+
+
+You can also lay out a partite graph on columns by specifying
+a list of the vertices on each side and choosing the partite layout.
+
+#### NOTE
+All vertices in your graph which are not listed in any of the partitions
+are collected in their own partition and rendered in the rightmost column.
+
+
+
+The representation of a linear artificial neural network is facilitated
+by the use of the partite layout and defining partitions for each layer.
+
+
+```python
+from manim import *
+
+class LinearNN(Scene):
+ def construct(self):
+ edges = []
+ partitions = []
+ c = 0
+ layers = [2, 3, 3, 2] # the number of neurons in each layer
+
+ for i in layers:
+ partitions.append(list(range(c + 1, c + i + 1)))
+ c += i
+ for i, v in enumerate(layers[1:]):
+ last = sum(layers[:i+1])
+ for j in range(v):
+ for k in range(last - layers[i], last):
+ edges.append((k + 1, j + last + 1))
+
+ vertices = np.arange(1, sum(layers) + 1)
+
+ graph = Graph(
+ vertices,
+ edges,
+ layout='partite',
+ partitions=partitions,
+ layout_scale=3,
+ vertex_config={'radius': 0.20},
+ )
+ self.add(graph)
+```
+
+
+class LinearNN(Scene):
+ def construct(self):
+ edges = []
+ partitions = []
+ c = 0
+ layers = [2, 3, 3, 2] # the number of neurons in each layer
+
+ for i in layers:
+ partitions.append(list(range(c + 1, c + i + 1)))
+ c += i
+ for i, v in enumerate(layers[1:]):
+ last = sum(layers[:i+1])
+ for j in range(v):
+ for k in range(last - layers[i], last):
+ edges.append((k + 1, j + last + 1))
+
+ vertices = np.arange(1, sum(layers) + 1)
+
+ graph = Graph(
+ vertices,
+ edges,
+ layout='partite',
+ partitions=partitions,
+ layout_scale=3,
+ vertex_config={'radius': 0.20},
+ )
+ self.add(graph)
+
+
+
+The custom tree layout can be used to show the graph
+by distance from the root vertex. You must pass the root vertex
+of the tree.
+
+
+
+Several automatic layouts are provided by manim, and can be used by passing their name as the `layout` parameter to `change_layout()`.
+Alternatively, a custom layout function can be passed to `change_layout()` as the `layout` parameter. Such a function must adhere to the [`LayoutFunction`](#manim.mobject.graph.LayoutFunction) protocol.
+
+The [`LayoutFunction`](#manim.mobject.graph.LayoutFunction) s provided by manim are illustrated below:
+
+- Circular Layout: places the vertices on a circle
+
+
+- Spring Layout: places nodes according to the Fruchterman-Reingold force-directed algorithm (attempts to minimize edge length while maximizing node separation)
+
+
+
+### Methods
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graph.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graph.md
new file mode 100644
index 0000000000000000000000000000000000000000..4a9c46806cf571d2355d855c984d2c78bfe71086
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graph.md
@@ -0,0 +1,19 @@
+# graph
+
+Mobjects used to represent mathematical graphs (think graph theory, not plotting).
+
+### Type Aliases
+
+### *class* NxGraph
+
+```default
+nx.classes.graph.Graph | nx.classes.digraph.DiGraph
+```
+
+### Classes
+
+| [`DiGraph`](manim.mobject.graph.DiGraph.md#manim.mobject.graph.DiGraph) | A directed graph. |
+|----------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------|
+| [`GenericGraph`](manim.mobject.graph.GenericGraph.md#manim.mobject.graph.GenericGraph) | Abstract base class for graphs (that is, a collection of vertices connected with edges). |
+| [`Graph`](manim.mobject.graph.Graph.md#manim.mobject.graph.Graph) | An undirected graph (vertices connected with edges). |
+| [`LayoutFunction`](manim.mobject.graph.LayoutFunction.md#manim.mobject.graph.LayoutFunction) | A protocol for automatic layout functions that compute a layout for a graph to be used in `change_layout()`. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.coordinate_systems.Axes.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.coordinate_systems.Axes.md
new file mode 100644
index 0000000000000000000000000000000000000000..9994961ba9402a7bbd046511019578ab202ea9b5
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.coordinate_systems.Axes.md
@@ -0,0 +1,441 @@
+# Axes
+
+Qualified name: `manim.mobject.graphing.coordinate\_systems.Axes`
+
+### *class* Axes(x_range=None, y_range=None, x_length=12, y_length=6, axis_config=None, x_axis_config=None, y_axis_config=None, tips=True, \*\*kwargs)
+
+Bases: [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup), [`CoordinateSystem`](manim.mobject.graphing.coordinate_systems.CoordinateSystem.md#manim.mobject.graphing.coordinate_systems.CoordinateSystem)
+
+Creates a set of axes.
+
+* **Parameters:**
+ * **x_range** (*Sequence* *[**float* *]* *|* *None*) – The `(x_min, x_max, x_step)` values of the x-axis.
+ * **y_range** (*Sequence* *[**float* *]* *|* *None*) – The `(y_min, y_max, y_step)` values of the y-axis.
+ * **x_length** (*float* *|* *None*) – The length of the x-axis.
+ * **y_length** (*float* *|* *None*) – The length of the y-axis.
+ * **axis_config** (*dict* *|* *None*) – Arguments to be passed to [`NumberLine`](manim.mobject.graphing.number_line.NumberLine.md#manim.mobject.graphing.number_line.NumberLine) that influences both axes.
+ * **x_axis_config** (*dict* *|* *None*) – Arguments to be passed to [`NumberLine`](manim.mobject.graphing.number_line.NumberLine.md#manim.mobject.graphing.number_line.NumberLine) that influence the x-axis.
+ * **y_axis_config** (*dict* *|* *None*) – Arguments to be passed to [`NumberLine`](manim.mobject.graphing.number_line.NumberLine.md#manim.mobject.graphing.number_line.NumberLine) that influence the y-axis.
+ * **tips** (*bool*) – Whether or not to include the tips on both axes.
+ * **kwargs** (*Any*) – Additional arguments to be passed to [`CoordinateSystem`](manim.mobject.graphing.coordinate_systems.CoordinateSystem.md#manim.mobject.graphing.coordinate_systems.CoordinateSystem) and [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup).
+
+### Examples
+
+
+class LogScalingExample(Scene):
+ def construct(self):
+ ax = Axes(
+ x_range=[0, 10, 1],
+ y_range=[-2, 6, 1],
+ tips=False,
+ axis_config={"include_numbers": True},
+ y_axis_config={"scaling": LogBase(custom_labels=True)},
+ )
+
+ # x_min must be > 0 because log is undefined at 0.
+ graph = ax.plot(lambda x: x \*\* 2, x_range=[0.001, 10], use_smoothing=False)
+ self.add(ax, graph)
+
+
+
+Styling arguments can be passed to the underlying [`NumberLine`](manim.mobject.graphing.number_line.NumberLine.md#manim.mobject.graphing.number_line.NumberLine)
+mobjects that represent the axes:
+
+
+
+### Methods
+
+| [`coords_to_point`](#manim.mobject.graphing.coordinate_systems.Axes.coords_to_point) | Accepts coordinates from the axes and returns a point with respect to the scene. |
+|----------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------|
+| [`get_axes`](#manim.mobject.graphing.coordinate_systems.Axes.get_axes) | Gets the axes. |
+| [`get_axis_labels`](#manim.mobject.graphing.coordinate_systems.Axes.get_axis_labels) | Defines labels for the x-axis and y-axis of the graph. |
+| [`plot_line_graph`](#manim.mobject.graphing.coordinate_systems.Axes.plot_line_graph) | Draws a line graph. |
+| [`point_to_coords`](#manim.mobject.graphing.coordinate_systems.Axes.point_to_coords) | Accepts a point from the scene and returns its coordinates with respect to the axes. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_create_axis(range_terms, axis_config, length)
+
+Creates an axis and dynamically adjusts its position depending on where 0 is located on the line.
+
+* **Parameters:**
+ * **range_terms** (*Sequence* *[**float* *]*) – The range of the the axis : `(x_min, x_max, x_step)`.
+ * **axis_config** (*dict* *[**str* *,* *Any* *]*) – Additional parameters that are passed to [`NumberLine`](manim.mobject.graphing.number_line.NumberLine.md#manim.mobject.graphing.number_line.NumberLine).
+ * **length** (*float*) – The length of the axis.
+* **Returns:**
+ Returns a number line based on `range_terms`.
+* **Return type:**
+ `NumberLine`
+
+#### *static* \_origin_shift(axis_range)
+
+Determines how to shift graph mobjects to compensate when 0 is not on the axis.
+
+* **Parameters:**
+ **axis_range** (*Sequence* *[**float* *]*) – The range of the axis : `(x_min, x_max, x_step)`.
+* **Return type:**
+ float
+
+#### \_original_\_init_\_(x_range=None, y_range=None, x_length=12, y_length=6, axis_config=None, x_axis_config=None, y_axis_config=None, tips=True, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **x_range** (*Sequence* *[**float* *]* *|* *None*)
+ * **y_range** (*Sequence* *[**float* *]* *|* *None*)
+ * **x_length** (*float* *|* *None*)
+ * **y_length** (*float* *|* *None*)
+ * **axis_config** (*dict* *|* *None*)
+ * **x_axis_config** (*dict* *|* *None*)
+ * **y_axis_config** (*dict* *|* *None*)
+ * **tips** (*bool*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### *static* \_update_default_configs(default_configs, passed_configs)
+
+Takes in two tuples of dicts and return modifies the first such that values from
+`passed_configs` overwrite values in `default_configs`. If a key does not exist
+in default_configs, it is added to the dict.
+
+This method is useful for having defaults in a class and being able to overwrite
+them with user-defined input.
+
+* **Parameters:**
+ * **default_configs** (*tuple* *[**dict* *[**Any* *,* *Any* *]* *]*) – The dict that will be updated.
+ * **passed_configs** (*tuple* *[**dict* *[**Any* *,* *Any* *]* *]*) – The dict that will be used to update.
+* **Return type:**
+ None
+
+### Examples
+
+To create a tuple with one dictionary, add a comma after the element:
+
+```python
+self._update_default_configs(
+ (dict_1,)(
+ dict_2,
+ )
+)
+```
+
+#### coords_to_point(\*coords)
+
+Accepts coordinates from the axes and returns a point with respect to the scene.
+Equivalent to ax @ (coord1)
+
+* **Parameters:**
+ **coords** (*float* *|* *Sequence* *[**float* *]* *|* *Sequence* *[**Sequence* *[**float* *]* *]* *|* *ndarray*) –
+
+ The coordinates. Each coord is passed as a separate argument: `ax.coords_to_point(1, 2, 3)`.
+
+ Also accepts a list of coordinates
+
+ `ax.coords_to_point( [x_0, x_1, ...], [y_0, y_1, ...], ... )`
+
+ `ax.coords_to_point( [[x_0, y_0, z_0], [x_1, y_1, z_1]] )`
+* **Returns:**
+ A point with respect to the scene’s coordinate system.
+ The shape of the array will be similar to the shape of the input.
+* **Return type:**
+ np.ndarray
+
+### Examples
+
+```pycon
+>>> from manim import Axes
+>>> import numpy as np
+>>> ax = Axes()
+>>> np.around(ax.coords_to_point(1, 0, 0), 2)
+array([0.86, 0. , 0. ])
+>>> np.around(ax @ (1, 0, 0), 2)
+array([0.86, 0. , 0. ])
+>>> np.around(ax.coords_to_point([[0, 1], [1, 1], [1, 0]]), 2)
+array([[0. , 0.75, 0. ],
+ [0.86, 0.75, 0. ],
+ [0.86, 0. , 0. ]])
+>>> np.around(
+... ax.coords_to_point([0, 1, 1], [1, 1, 0]), 2
+... ) # Transposed version of the above
+array([[0. , 0.86, 0.86],
+ [0.75, 0.75, 0. ],
+ [0. , 0. , 0. ]])
+```
+
+
+```python
+from manim import *
+
+class CoordsToPointExample(Scene):
+ def construct(self):
+ ax = Axes().add_coordinates()
+
+ # a dot with respect to the axes
+ dot_axes = Dot(ax.coords_to_point(2, 2), color=GREEN)
+ lines = ax.get_lines_to_point(ax.c2p(2,2))
+
+ # a dot with respect to the scene
+ # the default plane corresponds to the coordinates of the scene.
+ plane = NumberPlane()
+ dot_scene = Dot((2,2,0), color=RED)
+
+ self.add(plane, dot_scene, ax, dot_axes, lines)
+```
+
+
+class CoordsToPointExample(Scene):
+ def construct(self):
+ ax = Axes().add_coordinates()
+
+ # a dot with respect to the axes
+ dot_axes = Dot(ax.coords_to_point(2, 2), color=GREEN)
+ lines = ax.get_lines_to_point(ax.c2p(2,2))
+
+ # a dot with respect to the scene
+ # the default plane corresponds to the coordinates of the scene.
+ plane = NumberPlane()
+ dot_scene = Dot((2,2,0), color=RED)
+
+ self.add(plane, dot_scene, ax, dot_axes, lines)
+
+
+
+#### get_axes()
+
+Gets the axes.
+
+* **Returns:**
+ A pair of axes.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+#### get_axis_labels(x_label='x', y_label='y')
+
+Defines labels for the x-axis and y-axis of the graph.
+
+For increased control over the position of the labels,
+use [`get_x_axis_label()`](manim.mobject.graphing.coordinate_systems.CoordinateSystem.md#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_x_axis_label) and
+[`get_y_axis_label()`](manim.mobject.graphing.coordinate_systems.CoordinateSystem.md#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_y_axis_label).
+
+* **Parameters:**
+ * **x_label** (*float* *|* *str* *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The label for the x_axis. Defaults to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) for `str` and `float` inputs.
+ * **y_label** (*float* *|* *str* *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The label for the y_axis. Defaults to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) for `str` and `float` inputs.
+* **Returns:**
+ A [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) of the labels for the x_axis and y_axis.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+#### SEE ALSO
+[`get_x_axis_label()`](manim.mobject.graphing.coordinate_systems.CoordinateSystem.md#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_x_axis_label)
+[`get_y_axis_label()`](manim.mobject.graphing.coordinate_systems.CoordinateSystem.md#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_y_axis_label)
+
+### Examples
+
+
+
+#### plot_line_graph(x_values, y_values, z_values=None, line_color=ManimColor('#FFFF00'), add_vertex_dots=True, vertex_dot_radius=0.08, vertex_dot_style=None, \*\*kwargs)
+
+Draws a line graph.
+
+The graph connects the vertices formed from zipping
+`x_values`, `y_values` and `z_values`. Also adds [`Dots`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) at the
+vertices if `add_vertex_dots` is set to `True`.
+
+* **Parameters:**
+ * **x_values** (*Iterable* *[**float* *]*) – Iterable of values along the x-axis.
+ * **y_values** (*Iterable* *[**float* *]*) – Iterable of values along the y-axis.
+ * **z_values** (*Iterable* *[**float* *]* *|* *None*) – Iterable of values (zeros if z_values is None) along the z-axis.
+ * **line_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – Color for the line graph.
+ * **add_vertex_dots** (*bool*) – Whether or not to add [`Dot`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) at each vertex.
+ * **vertex_dot_radius** (*float*) – Radius for the [`Dot`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) at each vertex.
+ * **vertex_dot_style** (*dict* *[**str* *,* *Any* *]* *|* *None*) – Style arguments to be passed into [`Dot`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot) at each vertex.
+ * **kwargs** (*Any*) – Additional arguments to be passed into [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+* **Returns:**
+ A VDict containing both the line and dots (if specified). The line can be accessed with: `line_graph["line_graph"]`.
+ The dots can be accessed with: `line_graph["vertex_dots"]`.
+* **Return type:**
+ [`VDict`](manim.mobject.types.vectorized_mobject.VDict.md#manim.mobject.types.vectorized_mobject.VDict)
+
+### Examples
+
+
+
+#### point_to_coords(point)
+
+Accepts a point from the scene and returns its coordinates with respect to the axes.
+
+* **Parameters:**
+ **point** (*Sequence* *[**float* *]*) – The point, i.e. `RIGHT` or `[0, 1, 0]`.
+ Also accepts a list of points as `[RIGHT, [0, 1, 0]]`.
+* **Returns:**
+ The coordinates on the axes, i.e. `[4.0, 7.0]`.
+ Or a list of coordinates if point is a list of points.
+* **Return type:**
+ np.ndarray[float]
+
+### Examples
+
+```pycon
+>>> from manim import Axes, RIGHT
+>>> import numpy as np
+>>> ax = Axes(x_range=[0, 10, 2])
+>>> np.around(ax.point_to_coords(RIGHT), 2)
+array([5.83, 0. ])
+>>> np.around(ax.point_to_coords([[0, 0, 1], [1, 0, 0]]), 2)
+array([[5. , 0. ],
+ [5.83, 0. ]])
+```
+
+
+
+### Methods
+
+| [`add_coordinates`](#manim.mobject.graphing.coordinate_systems.ComplexPlane.add_coordinates) | Adds the labels produced from `get_coordinate_labels()` to the plane. |
+|----------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`get_coordinate_labels`](#manim.mobject.graphing.coordinate_systems.ComplexPlane.get_coordinate_labels) | Generates the [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber) mobjects for the coordinates of the plane. |
+| [`n2p`](#manim.mobject.graphing.coordinate_systems.ComplexPlane.n2p) | Abbreviation for [`number_to_point()`](#manim.mobject.graphing.coordinate_systems.ComplexPlane.number_to_point). |
+| [`number_to_point`](#manim.mobject.graphing.coordinate_systems.ComplexPlane.number_to_point) | Accepts a float/complex number and returns the equivalent point on the plane. |
+| [`p2n`](#manim.mobject.graphing.coordinate_systems.ComplexPlane.p2n) | Abbreviation for [`point_to_number()`](#manim.mobject.graphing.coordinate_systems.ComplexPlane.point_to_number). |
+| [`point_to_number`](#manim.mobject.graphing.coordinate_systems.ComplexPlane.point_to_number) | Accepts a point and returns a complex number equivalent to that point on the plane. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ **kwargs** (*Any*)
+
+#### \_get_default_coordinate_values()
+
+Generate a list containing the numerical values of the plane’s labels.
+
+* **Returns:**
+ A list of floats representing the x-axis and complex numbers representing the y-axis.
+* **Return type:**
+ List[float | complex]
+
+#### \_original_\_init_\_(\*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### add_coordinates(\*numbers, \*\*kwargs)
+
+Adds the labels produced from `get_coordinate_labels()` to the plane.
+
+* **Parameters:**
+ * **numbers** (*Iterable* *[**float* *|* *complex* *]*) – An iterable of floats/complex numbers. Floats are positioned along the x-axis, complex numbers along the y-axis.
+ * **kwargs** (*Any*) – Additional arguments to be passed to [`get_number_mobject()`](manim.mobject.graphing.number_line.NumberLine.md#manim.mobject.graphing.number_line.NumberLine.get_number_mobject), i.e. [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber).
+* **Return type:**
+ *Self*
+
+#### get_coordinate_labels(\*numbers, \*\*kwargs)
+
+Generates the [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber) mobjects for the coordinates of the plane.
+
+* **Parameters:**
+ * **numbers** (*Iterable* *[**float* *|* *complex* *]*) – An iterable of floats/complex numbers. Floats are positioned along the x-axis, complex numbers along the y-axis.
+ * **kwargs** (*Any*) – Additional arguments to be passed to [`get_number_mobject()`](manim.mobject.graphing.number_line.NumberLine.md#manim.mobject.graphing.number_line.NumberLine.get_number_mobject), i.e. [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber).
+* **Returns:**
+ A [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) containing the positioned label mobjects.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+#### n2p(number)
+
+Abbreviation for [`number_to_point()`](#manim.mobject.graphing.coordinate_systems.ComplexPlane.number_to_point).
+
+* **Parameters:**
+ **number** (*float* *|* *complex*)
+* **Return type:**
+ *ndarray*
+
+#### number_to_point(number)
+
+Accepts a float/complex number and returns the equivalent point on the plane.
+
+* **Parameters:**
+ **number** (*float* *|* *complex*) – The number. Can be a float or a complex number.
+* **Returns:**
+ The point on the plane.
+* **Return type:**
+ np.ndarray
+
+#### p2n(point)
+
+Abbreviation for [`point_to_number()`](#manim.mobject.graphing.coordinate_systems.ComplexPlane.point_to_number).
+
+* **Parameters:**
+ **point** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+* **Return type:**
+ complex
+
+#### point_to_number(point)
+
+Accepts a point and returns a complex number equivalent to that point on the plane.
+
+* **Parameters:**
+ **point** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – The point in manim’s coordinate-system
+* **Returns:**
+ A complex number consisting of real and imaginary components.
+* **Return type:**
+ complex
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.coordinate_systems.CoordinateSystem.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.coordinate_systems.CoordinateSystem.md
new file mode 100644
index 0000000000000000000000000000000000000000..77d58e68cfc79a0c85b6eb5fe39aba7bc00dfa25
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.coordinate_systems.CoordinateSystem.md
@@ -0,0 +1,1500 @@
+# CoordinateSystem
+
+Qualified name: `manim.mobject.graphing.coordinate\_systems.CoordinateSystem`
+
+### *class* CoordinateSystem(x_range=None, y_range=None, x_length=None, y_length=None, dimension=2)
+
+Bases: `object`
+
+Abstract base class for Axes and NumberPlane.
+
+### Examples
+
+
+```python
+from manim import *
+
+class CoordSysExample(Scene):
+ def construct(self):
+ # the location of the ticks depends on the x_range and y_range.
+ grid = Axes(
+ x_range=[0, 1, 0.05], # step size determines num_decimal_places.
+ y_range=[0, 1, 0.05],
+ x_length=9,
+ y_length=5.5,
+ axis_config={
+ "numbers_to_include": np.arange(0, 1 + 0.1, 0.1),
+ "font_size": 24,
+ },
+ tips=False,
+ )
+
+ # Labels for the x-axis and y-axis.
+ y_label = grid.get_y_axis_label("y", edge=LEFT, direction=LEFT, buff=0.4)
+ x_label = grid.get_x_axis_label("x")
+ grid_labels = VGroup(x_label, y_label)
+
+ graphs = VGroup()
+ for n in np.arange(1, 20 + 0.5, 0.5):
+ graphs += grid.plot(lambda x: x ** n, color=WHITE)
+ graphs += grid.plot(
+ lambda x: x ** (1 / n), color=WHITE, use_smoothing=False
+ )
+
+ # Extra lines and labels for point (1,1)
+ graphs += grid.get_horizontal_line(grid @ (1, 1, 0), color=BLUE)
+ graphs += grid.get_vertical_line(grid @ (1, 1, 0), color=BLUE)
+ graphs += Dot(point=grid @ (1, 1, 0), color=YELLOW)
+ graphs += Tex("(1,1)").scale(0.75).next_to(grid @ (1, 1, 0))
+ title = Title(
+ # spaces between braces to prevent SyntaxError
+ r"Graphs of $y=x^{ {1}\over{n} }$ and $y=x^n (n=1,2,3,...,20)$",
+ include_underline=False,
+ font_size=40,
+ )
+
+ self.add(title, graphs, grid, grid_labels)
+```
+
+
+class CoordSysExample(Scene):
+ def construct(self):
+ # the location of the ticks depends on the x_range and y_range.
+ grid = Axes(
+ x_range=[0, 1, 0.05], # step size determines num_decimal_places.
+ y_range=[0, 1, 0.05],
+ x_length=9,
+ y_length=5.5,
+ axis_config={
+ "numbers_to_include": np.arange(0, 1 + 0.1, 0.1),
+ "font_size": 24,
+ },
+ tips=False,
+ )
+
+ # Labels for the x-axis and y-axis.
+ y_label = grid.get_y_axis_label("y", edge=LEFT, direction=LEFT, buff=0.4)
+ x_label = grid.get_x_axis_label("x")
+ grid_labels = VGroup(x_label, y_label)
+
+ graphs = VGroup()
+ for n in np.arange(1, 20 + 0.5, 0.5):
+ graphs += grid.plot(lambda x: x \*\* n, color=WHITE)
+ graphs += grid.plot(
+ lambda x: x \*\* (1 / n), color=WHITE, use_smoothing=False
+ )
+
+ # Extra lines and labels for point (1,1)
+ graphs += grid.get_horizontal_line(grid @ (1, 1, 0), color=BLUE)
+ graphs += grid.get_vertical_line(grid @ (1, 1, 0), color=BLUE)
+ graphs += Dot(point=grid @ (1, 1, 0), color=YELLOW)
+ graphs += Tex("(1,1)").scale(0.75).next_to(grid @ (1, 1, 0))
+ title = Title(
+ # spaces between braces to prevent SyntaxError
+ r"Graphs of $y=x^{ {1}\\over{n} }$ and $y=x^n (n=1,2,3,...,20)$",
+ include_underline=False,
+ font_size=40,
+ )
+
+ self.add(title, graphs, grid, grid_labels)
+
+
+
+### Methods
+
+| [`add_coordinates`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.add_coordinates) | Adds labels to the axes. |
+|--------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`angle_of_tangent`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.angle_of_tangent) | Returns the angle to the x-axis of the tangent to the plotted curve at a particular x-value. |
+| [`c2p`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.c2p) | Abbreviation for `coords_to_point()` |
+| `coords_to_point` | |
+| [`get_T_label`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_T_label) | Creates a labelled triangle marker with a vertical line from the x-axis to a curve at a given x-value. |
+| [`get_area`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_area) | Returns a [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon) representing the area under the graph passed. |
+| `get_axes` | |
+| `get_axis` | |
+| `get_axis_labels` | |
+| [`get_graph_label`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_graph_label) | Creates a properly positioned label for the passed graph, with an optional dot. |
+| [`get_horizontal_line`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_horizontal_line) | A horizontal line from the y-axis to a given point in the scene. |
+| [`get_line_from_axis_to_point`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_line_from_axis_to_point) | Returns a straight line from a given axis to a point in the scene. |
+| [`get_lines_to_point`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_lines_to_point) | Generate both horizontal and vertical lines from the axis to a point. |
+| [`get_origin`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_origin) | Gets the origin of [`Axes`](manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes). |
+| [`get_riemann_rectangles`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_riemann_rectangles) | Generates a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) of the Riemann Rectangles for a given curve. |
+| [`get_secant_slope_group`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_secant_slope_group) | Creates two lines representing dx and df, the labels for dx and df, and |
+| [`get_vertical_line`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_vertical_line) | A vertical line from the x-axis to a given point in the scene. |
+| [`get_vertical_lines_to_graph`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_vertical_lines_to_graph) | Obtains multiple lines from the x-axis to the curve. |
+| `get_x_axis` | |
+| [`get_x_axis_label`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_x_axis_label) | Generate an x-axis label. |
+| `get_x_unit_size` | |
+| `get_y_axis` | |
+| [`get_y_axis_label`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_y_axis_label) | Generate a y-axis label. |
+| `get_y_unit_size` | |
+| `get_z_axis` | |
+| [`i2gc`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.i2gc) | Alias for [`input_to_graph_coords()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.input_to_graph_coords). |
+| [`i2gp`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.i2gp) | Alias for [`input_to_graph_point()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.input_to_graph_point). |
+| [`input_to_graph_coords`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.input_to_graph_coords) | Returns a tuple of the axis relative coordinates of the point on the graph based on the x-value given. |
+| [`input_to_graph_point`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.input_to_graph_point) | Returns the coordinates of the point on a `graph` corresponding to an `x` value. |
+| [`p2c`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.p2c) | Abbreviation for `point_to_coords()` |
+| [`plot`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.plot) | Generates a curve based on a function. |
+| [`plot_antiderivative_graph`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.plot_antiderivative_graph) | Plots an antiderivative graph. |
+| [`plot_derivative_graph`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.plot_derivative_graph) | Returns the curve of the derivative of the passed graph. |
+| [`plot_implicit_curve`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.plot_implicit_curve) | Creates the curves of an implicit function. |
+| [`plot_parametric_curve`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.plot_parametric_curve) | A parametric curve. |
+| [`plot_polar_graph`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.plot_polar_graph) | A polar graph. |
+| [`plot_surface`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.plot_surface) | Generates a surface based on a function. |
+| `point_to_coords` | |
+| [`point_to_polar`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.point_to_polar) | Gets polar coordinates from a point. |
+| [`polar_to_point`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.polar_to_point) | Gets a point from polar coordinates. |
+| [`pr2pt`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.pr2pt) | Abbreviation for [`polar_to_point()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.polar_to_point) |
+| [`pt2pr`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.pt2pr) | Abbreviation for [`point_to_polar()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.point_to_polar) |
+| [`slope_of_tangent`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.slope_of_tangent) | Returns the slope of the tangent to the plotted curve at a particular x-value. |
+* **Parameters:**
+ * **x_range** (*Sequence* *[**float* *]* *|* *None*)
+ * **y_range** (*Sequence* *[**float* *]* *|* *None*)
+ * **x_length** (*float* *|* *None*)
+ * **y_length** (*float* *|* *None*)
+ * **dimension** (*int*)
+
+#### \_get_axis_label(label, axis, edge, direction, buff=0.1)
+
+Gets the label for an axis.
+
+* **Parameters:**
+ * **label** (*float* *|* *str* *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The label. Defaults to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) for `str` and `float` inputs.
+ * **axis** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The axis to which the label will be added.
+ * **edge** (*Sequence* *[**float* *]*) – The edge of the axes to which the label will be added. `RIGHT` adds to the right side of the axis
+ * **direction** (*Sequence* *[**float* *]*) – Allows for further positioning of the label.
+ * **buff** (*float*) – The distance of the label from the line.
+* **Returns:**
+ The positioned label along the given axis.
+* **Return type:**
+ [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+#### add_coordinates(\*axes_numbers, \*\*kwargs)
+
+Adds labels to the axes. Use `Axes.coordinate_labels` to
+access the coordinates after creation.
+
+* **Parameters:**
+ * **axes_numbers** (*Iterable* *[**float* *]* *|* *None* *|* *dict* *[**float* *,* *str* *|* *float* *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The numbers to be added to the axes. Use `None` to represent an axis with default labels.
+ * **kwargs** (*Any*)
+* **Return type:**
+ *Self*
+
+### Examples
+
+```python
+ax = ThreeDAxes()
+x_labels = range(-4, 5)
+z_labels = range(-4, 4, 2)
+ax.add_coordinates(
+ x_labels, None, z_labels
+) # default y labels, custom x & z labels
+ax.add_coordinates(x_labels) # only x labels
+```
+
+You can also specifically control the position and value of the labels using a dict.
+
+```python
+ax = Axes(x_range=[0, 7])
+x_pos = [x for x in range(1, 8)]
+
+# strings are automatically converted into a Tex mobject.
+x_vals = [
+ "Monday",
+ "Tuesday",
+ "Wednesday",
+ "Thursday",
+ "Friday",
+ "Saturday",
+ "Sunday",
+]
+x_dict = dict(zip(x_pos, x_vals))
+ax.add_coordinates(x_dict)
+```
+
+#### angle_of_tangent(x, graph, dx=1e-08)
+
+Returns the angle to the x-axis of the tangent
+to the plotted curve at a particular x-value.
+
+* **Parameters:**
+ * **x** (*float*) – The x-value at which the tangent must touch the curve.
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)) – The [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction) for which to calculate the tangent.
+ * **dx** (*float*) – The change in x used to determine the angle of the tangent to the curve.
+* **Returns:**
+ The angle of the tangent to the curve.
+* **Return type:**
+ `float`
+
+### Examples
+
+```python
+ax = Axes()
+curve = ax.plot(lambda x: x**2)
+ax.angle_of_tangent(x=3, graph=curve)
+# 1.4056476493802699
+```
+
+#### c2p(\*coords)
+
+Abbreviation for `coords_to_point()`
+
+* **Parameters:**
+ **coords** (*float* *|* *Sequence* *[**float* *]* *|* *Sequence* *[**Sequence* *[**float* *]* *]* *|* *ndarray*)
+* **Return type:**
+ *ndarray*
+
+#### get_T_label(x_val, graph, label=None, label_color=None, triangle_size=0.25, triangle_color=ManimColor('#FFFFFF'), line_func=, line_color=ManimColor('#FFFF00'))
+
+Creates a labelled triangle marker with a vertical line from the x-axis
+to a curve at a given x-value.
+
+* **Parameters:**
+ * **x_val** (*float*) – The position along the curve at which the label, line and triangle will be constructed.
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)) – The [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction) for which to construct the label.
+ * **label** (*float* *|* *str* *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* *None*) – The label of the vertical line and triangle.
+ * **label_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The color of the label.
+ * **triangle_size** (*float*) – The size of the triangle.
+ * **triangle_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The color of the triangle.
+ * **line_func** (*type* *[*[*Line*](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line) *]*) – The function used to construct the vertical line.
+ * **line_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the vertical line.
+* **Returns:**
+ A [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) of the label, triangle and vertical line mobjects.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+### Examples
+
+
+class TLabelExample(Scene):
+ def construct(self):
+ # defines the axes and linear function
+ axes = Axes(x_range=[-1, 10], y_range=[-1, 10], x_length=9, y_length=6)
+ func = axes.plot(lambda x: x, color=BLUE)
+ # creates the T_label
+ t_label = axes.get_T_label(x_val=4, graph=func, label=Tex("x-value"))
+ self.add(axes, func, t_label)
+
+
+
+#### get_area(graph, x_range=None, color=(ManimColor('#58C4DD'), ManimColor('#83C167')), opacity=0.3, bounded_graph=None, \*\*kwargs)
+
+Returns a [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon) representing the area under the graph passed.
+
+* **Parameters:**
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)) – The graph/curve for which the area needs to be gotten.
+ * **x_range** (*tuple* *[**float* *,* *float* *]* *|* *None*) – The range of the minimum and maximum x-values of the area. `x_range = [x_min, x_max]`.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *Iterable* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]*) – The color of the area. Creates a gradient if a list of colors is provided.
+ * **opacity** (*float*) – The opacity of the area.
+ * **bounded_graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)) – If a secondary `graph` is specified, encloses the area between the two curves.
+ * **kwargs** (*Any*) – Additional parameters passed to [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon).
+* **Returns:**
+ The [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon) representing the area.
+* **Return type:**
+ [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon)
+* **Raises:**
+ **ValueError** – When x_ranges do not match (either area x_range, graph’s x_range or bounded_graph’s x_range).
+
+### Examples
+
+
+
+#### get_graph_label(graph, label='f(x)', x_val=None, direction=array([1., 0., 0.]), buff=0.25, color=None, dot=False, dot_config=None)
+
+Creates a properly positioned label for the passed graph, with an optional dot.
+
+* **Parameters:**
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)) – The curve.
+ * **label** (*float* *|* *str* *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The label for the function’s curve. Defaults to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) for `str` and `float` inputs.
+ * **x_val** (*float* *|* *None*) – The x_value along the curve that positions the label.
+ * **direction** (*Sequence* *[**float* *]*) – The cartesian position, relative to the curve that the label will be at –> `LEFT`, `RIGHT`.
+ * **buff** (*float*) – The distance between the curve and the label.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The color of the label. Defaults to the color of the curve.
+ * **dot** (*bool*) – Whether to add a dot at the point on the graph.
+ * **dot_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) – Additional parameters to be passed to [`Dot`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot).
+* **Returns:**
+ The positioned label and [`Dot`](manim.mobject.geometry.arc.Dot.md#manim.mobject.geometry.arc.Dot), if applicable.
+* **Return type:**
+ `Mobject`
+
+### Examples
+
+
+
+#### get_horizontal_line(point, \*\*kwargs)
+
+A horizontal line from the y-axis to a given point in the scene.
+
+* **Parameters:**
+ * **point** (*Sequence* *[**float* *]*) – The point to which the horizontal line will be drawn.
+ * **kwargs** – Additional parameters to be passed to [`get_line_from_axis_to_point`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_line_from_axis_to_point).
+* **Returns:**
+ A horizontal line from the y-axis to the point.
+* **Return type:**
+ `Line`
+
+### Examples
+
+
+
+#### get_line_from_axis_to_point(index: int, point: Sequence[float], line_config: dict | None = None, color: [ParsableManimColor](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) | None = None, stroke_width: float = 2) → [DashedLine](manim.mobject.geometry.line.DashedLine.md#manim.mobject.geometry.line.DashedLine)
+
+#### get_line_from_axis_to_point(index: int, point: Sequence[float], line_func: type[[LineType](manim.mobject.graphing.coordinate_systems.md#manim.mobject.graphing.coordinate_systems.LineType)], line_config: dict | None = None, color: [ParsableManimColor](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) | None = None, stroke_width: float = 2) → [LineType](manim.mobject.graphing.coordinate_systems.md#manim.mobject.graphing.coordinate_systems.LineType)
+
+Returns a straight line from a given axis to a point in the scene.
+
+* **Parameters:**
+ * **index** – Specifies the axis from which to draw the line. 0 = x_axis, 1 = y_axis
+ * **point** – The point to which the line will be drawn.
+ * **line_func** – The function of the [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line) mobject used to construct the line.
+ * **line_config** – Optional arguments to passed to `line_func`.
+ * **color** – The color of the line.
+ * **stroke_width** – The stroke width of the line.
+* **Returns:**
+ The line from an axis to a point.
+* **Return type:**
+ [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line)
+
+#### SEE ALSO
+[`get_vertical_line()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_vertical_line)
+[`get_horizontal_line()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_horizontal_line)
+
+#### get_lines_to_point(point, \*\*kwargs)
+
+Generate both horizontal and vertical lines from the axis to a point.
+
+* **Parameters:**
+ * **point** (*Sequence* *[**float* *]*) – A point on the scene.
+ * **kwargs** – Additional parameters to be passed to [`get_line_from_axis_to_point()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_line_from_axis_to_point)
+* **Returns:**
+ A [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) of the horizontal and vertical lines.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+#### SEE ALSO
+[`get_vertical_line()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_vertical_line)
+[`get_horizontal_line()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_horizontal_line)
+
+### Examples
+
+
+
+#### get_origin()
+
+Gets the origin of [`Axes`](manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes).
+
+* **Returns:**
+ The center point.
+* **Return type:**
+ np.ndarray
+
+#### get_riemann_rectangles(graph, x_range=None, dx=0.1, input_sample_type='left', stroke_width=1, stroke_color=ManimColor('#000000'), fill_opacity=1, color=(ManimColor('#58C4DD'), ManimColor('#83C167')), show_signed_area=True, bounded_graph=None, blend=False, width_scale_factor=1.001)
+
+Generates a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) of the Riemann Rectangles for a given curve.
+
+* **Parameters:**
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)) – The graph whose area will be approximated by Riemann rectangles.
+ * **x_range** (*Sequence* *[**float* *]* *|* *None*) – The minimum and maximum x-values of the rectangles. `x_range = [x_min, x_max]`.
+ * **dx** (*float* *|* *None*) – The change in x-value that separates each rectangle.
+ * **input_sample_type** (*str*) – Can be any of `"left"`, `"right"` or `"center"`. Refers to where
+ the sample point for the height of each Riemann Rectangle
+ will be inside the segments of the partition.
+ * **stroke_width** (*float*) – The stroke_width of the border of the rectangles.
+ * **stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the border of the rectangle.
+ * **fill_opacity** (*float*) – The opacity of the rectangles.
+ * **color** (*Iterable* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]* *|* [*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The colors of the rectangles. Creates a balanced gradient if multiple colors are passed.
+ * **show_signed_area** (*bool*) – Indicates negative area when the curve dips below the x-axis by inverting its color.
+ * **blend** (*bool*) – Sets the `stroke_color` to `fill_color`, blending the rectangles without clear separation.
+ * **bounded_graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)) – If a secondary graph is specified, encloses the area between the two curves.
+ * **width_scale_factor** (*float*) – The factor by which the width of the rectangles is scaled.
+* **Returns:**
+ A [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) containing the Riemann Rectangles.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+### Examples
+
+
+```python
+from manim import *
+
+class GetRiemannRectanglesExample(Scene):
+ def construct(self):
+ ax = Axes(y_range=[-2, 10])
+ quadratic = ax.plot(lambda x: 0.5 * x ** 2 - 0.5)
+
+ # the rectangles are constructed from their top right corner.
+ # passing an iterable to `color` produces a gradient
+ rects_right = ax.get_riemann_rectangles(
+ quadratic,
+ x_range=[-4, -3],
+ dx=0.25,
+ color=(TEAL, BLUE_B, DARK_BLUE),
+ input_sample_type="right",
+ )
+
+ # the colour of rectangles below the x-axis is inverted
+ # due to show_signed_area
+ rects_left = ax.get_riemann_rectangles(
+ quadratic, x_range=[-1.5, 1.5], dx=0.15, color=YELLOW
+ )
+
+ bounding_line = ax.plot(
+ lambda x: 1.5 * x, color=BLUE_B, x_range=[3.3, 6]
+ )
+ bounded_rects = ax.get_riemann_rectangles(
+ bounding_line,
+ bounded_graph=quadratic,
+ dx=0.15,
+ x_range=[4, 5],
+ show_signed_area=False,
+ color=(MAROON_A, RED_B, PURPLE_D),
+ )
+
+ self.add(
+ ax, bounding_line, quadratic, rects_right, rects_left, bounded_rects
+ )
+```
+
+
+class GetRiemannRectanglesExample(Scene):
+ def construct(self):
+ ax = Axes(y_range=[-2, 10])
+ quadratic = ax.plot(lambda x: 0.5 \* x \*\* 2 - 0.5)
+
+ # the rectangles are constructed from their top right corner.
+ # passing an iterable to \`color\` produces a gradient
+ rects_right = ax.get_riemann_rectangles(
+ quadratic,
+ x_range=[-4, -3],
+ dx=0.25,
+ color=(TEAL, BLUE_B, DARK_BLUE),
+ input_sample_type="right",
+ )
+
+ # the colour of rectangles below the x-axis is inverted
+ # due to show_signed_area
+ rects_left = ax.get_riemann_rectangles(
+ quadratic, x_range=[-1.5, 1.5], dx=0.15, color=YELLOW
+ )
+
+ bounding_line = ax.plot(
+ lambda x: 1.5 \* x, color=BLUE_B, x_range=[3.3, 6]
+ )
+ bounded_rects = ax.get_riemann_rectangles(
+ bounding_line,
+ bounded_graph=quadratic,
+ dx=0.15,
+ x_range=[4, 5],
+ show_signed_area=False,
+ color=(MAROON_A, RED_B, PURPLE_D),
+ )
+
+ self.add(
+ ax, bounding_line, quadratic, rects_right, rects_left, bounded_rects
+ )
+
+
+
+#### get_secant_slope_group(x, graph, dx=None, dx_line_color=ManimColor('#FFFF00'), dy_line_color=None, dx_label=None, dy_label=None, include_secant_line=True, secant_line_color=ManimColor('#83C167'), secant_line_length=10)
+
+Creates two lines representing dx and df, the labels for dx and df, and
+: the secant to the curve at a particular x-value.
+
+* **Parameters:**
+ * **x** (*float*) – The x-value at which the secant intersects the graph for the first time.
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)) – The curve for which the secant will be found.
+ * **dx** (*float* *|* *None*) – The change in x after which the secant exits.
+ * **dx_line_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the line that indicates the change in x.
+ * **dy_line_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The color of the line that indicates the change in y. Defaults to the color of `graph`.
+ * **dx_label** (*float* *|* *str* *|* *None*) – The label for the dx line. Defaults to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) for `str` and `float` inputs.
+ * **dy_label** (*float* *|* *str* *|* *None*) – The label for the dy line. Defaults to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) for `str` and `float` inputs.
+ * **include_secant_line** (*bool*) – Whether to include the secant line in the graph,
+ or just the df/dx lines and labels.
+ * **secant_line_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the secant line.
+ * **secant_line_length** (*float*) – The length of the secant line.
+* **Returns:**
+ A group containing the elements: dx_line, df_line, and
+ if applicable also `dx_label`, `df_label`, secant_line.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+### Examples
+
+
+
+#### get_vertical_line(point, \*\*kwargs)
+
+A vertical line from the x-axis to a given point in the scene.
+
+* **Parameters:**
+ * **point** (*Sequence* *[**float* *]*) – The point to which the vertical line will be drawn.
+ * **kwargs** (*Any*) – Additional parameters to be passed to [`get_line_from_axis_to_point`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_line_from_axis_to_point).
+* **Returns:**
+ A vertical line from the x-axis to the point.
+* **Return type:**
+ `Line`
+
+### Examples
+
+
+
+#### get_vertical_lines_to_graph(graph, x_range=None, num_lines=20, \*\*kwargs)
+
+Obtains multiple lines from the x-axis to the curve.
+
+* **Parameters:**
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)) – The graph along which the lines are placed.
+ * **x_range** (*Sequence* *[**float* *]* *|* *None*) – A list containing the lower and and upper bounds of the lines: `x_range = [x_min, x_max]`.
+ * **num_lines** (*int*) – The number of evenly spaced lines.
+ * **kwargs** (*Any*) – Additional arguments to be passed to [`get_vertical_line()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.get_vertical_line).
+* **Returns:**
+ The [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) of the evenly spaced lines.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+### Examples
+
+
+
+#### get_x_axis_label(label, edge=array([1., 1., 0.]), direction=array([1., 1., 0.]), buff=0.1, \*\*kwargs)
+
+Generate an x-axis label.
+
+* **Parameters:**
+ * **label** (*float* *|* *str* *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The label. Defaults to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) for `str` and `float` inputs.
+ * **edge** (*Sequence* *[**float* *]*) – The edge of the x-axis to which the label will be added, by default `UR`.
+ * **direction** (*Sequence* *[**float* *]*) – Allows for further positioning of the label from an edge, by default `UR`.
+ * **buff** (*float*) – The distance of the label from the line.
+* **Returns:**
+ The positioned label.
+* **Return type:**
+ [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+### Examples
+
+
+
+#### get_y_axis_label(label, edge=array([1., 1., 0.]), direction=array([1., 0.5, 0.]), buff=0.1, \*\*kwargs)
+
+Generate a y-axis label.
+
+* **Parameters:**
+ * **label** (*float* *|* *str* *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The label. Defaults to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) for `str` and `float` inputs.
+ * **edge** (*Sequence* *[**float* *]*) – The edge of the y-axis to which the label will be added, by default `UR`.
+ * **direction** (*Sequence* *[**float* *]*) – Allows for further positioning of the label from an edge, by default `UR`
+ * **buff** (*float*) – The distance of the label from the line.
+* **Returns:**
+ The positioned label.
+* **Return type:**
+ [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+### Examples
+
+
+
+#### i2gc(x, graph)
+
+Alias for [`input_to_graph_coords()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.input_to_graph_coords).
+
+* **Parameters:**
+ * **x** (*float*)
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction))
+* **Return type:**
+ tuple[float, float]
+
+#### i2gp(x, graph)
+
+Alias for [`input_to_graph_point()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.input_to_graph_point).
+
+* **Parameters:**
+ * **x** (*float*)
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction))
+* **Return type:**
+ *ndarray*
+
+#### input_to_graph_coords(x, graph)
+
+Returns a tuple of the axis relative coordinates of the point
+on the graph based on the x-value given.
+
+### Examples
+
+```pycon
+>>> from manim import Axes
+>>> ax = Axes()
+>>> parabola = ax.plot(lambda x: x**2)
+>>> ax.input_to_graph_coords(x=3, graph=parabola)
+(3, 9)
+```
+
+* **Parameters:**
+ * **x** (*float*)
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction))
+* **Return type:**
+ tuple[float, float]
+
+#### input_to_graph_point(x, graph)
+
+Returns the coordinates of the point on a `graph` corresponding to an `x` value.
+
+* **Parameters:**
+ * **x** (*float*) – The x-value of a point on the `graph`.
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction) *|* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction) on which the point lies.
+* **Returns:**
+ The coordinates of the point on the `graph` corresponding to the `x` value.
+* **Return type:**
+ `np.ndarray`
+* **Raises:**
+ **ValueError** – When the target x is not in the range of the line graph.
+
+### Examples
+
+
+```python
+from manim import *
+
+class InputToGraphPointExample(Scene):
+ def construct(self):
+ ax = Axes()
+ curve = ax.plot(lambda x : np.cos(x))
+
+ # move a square to PI on the cosine curve.
+ position = ax.input_to_graph_point(x=PI, graph=curve)
+ sq = Square(side_length=1, color=YELLOW).move_to(position)
+
+ self.add(ax, curve, sq)
+```
+
+
+class InputToGraphPointExample(Scene):
+ def construct(self):
+ ax = Axes()
+ curve = ax.plot(lambda x : np.cos(x))
+
+ # move a square to PI on the cosine curve.
+ position = ax.input_to_graph_point(x=PI, graph=curve)
+ sq = Square(side_length=1, color=YELLOW).move_to(position)
+
+ self.add(ax, curve, sq)
+
+
+
+#### p2c(point)
+
+Abbreviation for `point_to_coords()`
+
+* **Parameters:**
+ **point** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+
+#### plot(function, x_range=None, use_vectorized=False, colorscale=None, colorscale_axis=1, \*\*kwargs)
+
+Generates a curve based on a function.
+
+* **Parameters:**
+ * **function** (*Callable* *[* *[**float* *]* *,* *float* *]*) – The function used to construct the [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction).
+ * **x_range** (*Sequence* *[**float* *]* *|* *None*) – The range of the curve along the axes. `x_range = [x_min, x_max, x_step]`.
+ * **use_vectorized** (*bool*) – Whether to pass in the generated t value array to the function. Only use this if your function supports it.
+ Output should be a numpy array of shape `[y_0, y_1, ...]`
+ * **colorscale** ([*Union*](manim.mobject.geometry.boolean_ops.Union.md#manim.mobject.geometry.boolean_ops.Union) *[**Iterable* *[**Color* *]* *,* *Iterable* *[**Color* *,* *float* *]* *]* *|* *None*) – Colors of the function. Optional parameter used when coloring a function by values. Passing a list of colors
+ and a colorscale_axis will color the function by y-value. Passing a list of tuples in the form `(color, pivot)`
+ allows user-defined pivots where the color transitions.
+ * **colorscale_axis** (*int*) – Defines the axis on which the colorscale is applied (0 = x, 1 = y), default is y-axis (1).
+ * **kwargs** (*Any*) – Additional parameters to be passed to [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction).
+* **Returns:**
+ The plotted curve.
+* **Return type:**
+ [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)
+
+#### WARNING
+This method may not produce accurate graphs since Manim currently relies on interpolation between
+evenly-spaced samples of the curve, instead of intelligent plotting.
+See the example below for some solutions to this problem.
+
+### Examples
+
+
+```python
+from manim import *
+
+class PlotExample(Scene):
+ def construct(self):
+ # construct the axes
+ ax_1 = Axes(
+ x_range=[0.001, 6],
+ y_range=[-8, 2],
+ x_length=5,
+ y_length=3,
+ tips=False,
+ )
+ ax_2 = ax_1.copy()
+ ax_3 = ax_1.copy()
+
+ # position the axes
+ ax_1.to_corner(UL)
+ ax_2.to_corner(UR)
+ ax_3.to_edge(DOWN)
+ axes = VGroup(ax_1, ax_2, ax_3)
+
+ # create the logarithmic curves
+ def log_func(x):
+ return np.log(x)
+
+ # a curve without adjustments; poor interpolation.
+ curve_1 = ax_1.plot(log_func, color=PURE_RED)
+
+ # disabling interpolation makes the graph look choppy as not enough
+ # inputs are available
+ curve_2 = ax_2.plot(log_func, use_smoothing=False, color=ORANGE)
+
+ # taking more inputs of the curve by specifying a step for the
+ # x_range yields expected results, but increases rendering time.
+ curve_3 = ax_3.plot(
+ log_func, x_range=(0.001, 6, 0.001), color=PURE_GREEN
+ )
+
+ curves = VGroup(curve_1, curve_2, curve_3)
+
+ self.add(axes, curves)
+```
+
+
+class PlotExample(Scene):
+ def construct(self):
+ # construct the axes
+ ax_1 = Axes(
+ x_range=[0.001, 6],
+ y_range=[-8, 2],
+ x_length=5,
+ y_length=3,
+ tips=False,
+ )
+ ax_2 = ax_1.copy()
+ ax_3 = ax_1.copy()
+
+ # position the axes
+ ax_1.to_corner(UL)
+ ax_2.to_corner(UR)
+ ax_3.to_edge(DOWN)
+ axes = VGroup(ax_1, ax_2, ax_3)
+
+ # create the logarithmic curves
+ def log_func(x):
+ return np.log(x)
+
+ # a curve without adjustments; poor interpolation.
+ curve_1 = ax_1.plot(log_func, color=PURE_RED)
+
+ # disabling interpolation makes the graph look choppy as not enough
+ # inputs are available
+ curve_2 = ax_2.plot(log_func, use_smoothing=False, color=ORANGE)
+
+ # taking more inputs of the curve by specifying a step for the
+ # x_range yields expected results, but increases rendering time.
+ curve_3 = ax_3.plot(
+ log_func, x_range=(0.001, 6, 0.001), color=PURE_GREEN
+ )
+
+ curves = VGroup(curve_1, curve_2, curve_3)
+
+ self.add(axes, curves)
+
+
+
+#### plot_antiderivative_graph(graph, y_intercept=0, samples=50, use_vectorized=False, \*\*kwargs)
+
+Plots an antiderivative graph.
+
+* **Parameters:**
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)) – The graph for which the antiderivative will be found.
+ * **y_intercept** (*float*) – The y-value at which the graph intercepts the y-axis.
+ * **samples** (*int*) – The number of points to take the area under the graph.
+ * **use_vectorized** (*bool*) – Whether to use the vectorized version of the antiderivative. This means
+ to pass in the generated t value array to the function. Only use this if your function supports it.
+ Output should be a numpy array of shape `[y_0, y_1, ...]`
+ * **kwargs** (*Any*) – Any valid keyword argument of [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction).
+* **Returns:**
+ The curve of the antiderivative.
+* **Return type:**
+ [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)
+
+#### NOTE
+This graph is plotted from the values of area under the reference graph.
+The result might not be ideal if the reference graph contains uncalculatable
+areas from x=0.
+
+### Examples
+
+
+
+#### plot_derivative_graph(graph, color=ManimColor('#83C167'), \*\*kwargs)
+
+Returns the curve of the derivative of the passed graph.
+
+* **Parameters:**
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)) – The graph for which the derivative will be found.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the derivative curve.
+ * **kwargs** – Any valid keyword argument of [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction).
+* **Returns:**
+ The curve of the derivative.
+* **Return type:**
+ [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)
+
+### Examples
+
+
+
+#### plot_implicit_curve(func, min_depth=5, max_quads=1500, \*\*kwargs)
+
+Creates the curves of an implicit function.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**float* *,* *float* *]* *,* *float* *]*) – The function to graph, in the form of f(x, y) = 0.
+ * **min_depth** (*int*) – The minimum depth of the function to calculate.
+ * **max_quads** (*int*) – The maximum number of quads to use.
+ * **kwargs** (*Any*) – Additional parameters to pass into `ImplicitFunction`.
+* **Return type:**
+ [*ImplicitFunction*](manim.mobject.graphing.functions.ImplicitFunction.md#manim.mobject.graphing.functions.ImplicitFunction)
+
+### Examples
+
+
+class ImplicitExample(Scene):
+ def construct(self):
+ ax = Axes()
+ a = ax.plot_implicit_curve(
+ lambda x, y: y \* (x - y) \*\* 2 - 4 \* x - 8, color=BLUE
+ )
+ self.add(ax, a)
+
+
+
+#### plot_parametric_curve(function, use_vectorized=False, \*\*kwargs)
+
+A parametric curve.
+
+* **Parameters:**
+ * **function** (*Callable* *[* *[**float* *]* *,* *ndarray* *]*) – A parametric function mapping a number to a point in the
+ coordinate system.
+ * **use_vectorized** (*bool*) – Whether to pass in the generated t value array to the function. Only use this if your function supports it.
+ * **kwargs** (*Any*) – Any further keyword arguments are passed to [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction).
+* **Return type:**
+ [*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)
+
+### Example
+
+
+
+#### plot_surface(function, u_range=None, v_range=None, colorscale=None, colorscale_axis=2, \*\*kwargs)
+
+Generates a surface based on a function.
+
+* **Parameters:**
+ * **function** (*Callable* *[* *[**float* *]* *,* *float* *]*) – The function used to construct the [`Surface`](manim.mobject.three_d.three_dimensions.Surface.md#manim.mobject.three_d.three_dimensions.Surface).
+ * **u_range** (*Sequence* *[**float* *]* *|* *None*) – The range of the `u` variable: `(u_min, u_max)`.
+ * **v_range** (*Sequence* *[**float* *]* *|* *None*) – The range of the `v` variable: `(v_min, v_max)`.
+ * **colorscale** (*Sequence* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]* *|* *Sequence* *[**tuple* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *,* *float* *]* *]* *|* *None*) – Colors of the surface. Passing a list of colors will color the surface by z-value.
+ Passing a list of tuples in the form `(color, pivot)` allows user-defined pivots
+ where the color transitions.
+ * **colorscale_axis** (*int*) – Defines the axis on which the colorscale is applied (0 = x, 1 = y, 2 = z), default
+ is z-axis (2).
+ * **kwargs** (*Any*) – Additional parameters to be passed to [`Surface`](manim.mobject.three_d.three_dimensions.Surface.md#manim.mobject.three_d.three_dimensions.Surface).
+* **Returns:**
+ The plotted surface.
+* **Return type:**
+ [`Surface`](manim.mobject.three_d.three_dimensions.Surface.md#manim.mobject.three_d.three_dimensions.Surface)
+
+### Examples
+
+
+
+#### pr2pt(radius, azimuth)
+
+Abbreviation for [`polar_to_point()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.polar_to_point)
+
+* **Parameters:**
+ * **radius** (*float*)
+ * **azimuth** (*float*)
+* **Return type:**
+ *ndarray*
+
+#### pt2pr(point)
+
+Abbreviation for [`point_to_polar()`](#manim.mobject.graphing.coordinate_systems.CoordinateSystem.point_to_polar)
+
+* **Parameters:**
+ **point** (*ndarray*)
+* **Return type:**
+ tuple[float, float]
+
+#### slope_of_tangent(x, graph, \*\*kwargs)
+
+Returns the slope of the tangent to the plotted curve
+at a particular x-value.
+
+* **Parameters:**
+ * **x** (*float*) – The x-value at which the tangent must touch the curve.
+ * **graph** ([*ParametricFunction*](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction)) – The [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction) for which to calculate the tangent.
+ * **kwargs** (*Any*)
+* **Returns:**
+ The slope of the tangent with the x axis.
+* **Return type:**
+ `float`
+
+### Examples
+
+```python
+ax = Axes()
+curve = ax.plot(lambda x: x**2)
+ax.slope_of_tangent(x=-2, graph=curve)
+# -3.5000000259052038
+```
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.coordinate_systems.NumberPlane.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.coordinate_systems.NumberPlane.md
new file mode 100644
index 0000000000000000000000000000000000000000..80417787734d737e57d6a8bcc3bd4073eb931d8e
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.coordinate_systems.NumberPlane.md
@@ -0,0 +1,167 @@
+# NumberPlane
+
+Qualified name: `manim.mobject.graphing.coordinate\_systems.NumberPlane`
+
+### *class* NumberPlane(x_range=(-7.111111111111111, 7.111111111111111, 1), y_range=(-4.0, 4.0, 1), x_length=None, y_length=None, background_line_style=None, faded_line_style=None, faded_line_ratio=1, make_smooth_after_applying_functions=True, \*\*kwargs)
+
+Bases: [`Axes`](manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes)
+
+Creates a cartesian plane with background lines.
+
+* **Parameters:**
+ * **x_range** (*Sequence* *[**float* *]* *|* *None*) – The `[x_min, x_max, x_step]` values of the plane in the horizontal direction.
+ * **y_range** (*Sequence* *[**float* *]* *|* *None*) – The `[y_min, y_max, y_step]` values of the plane in the vertical direction.
+ * **x_length** (*float* *|* *None*) – The width of the plane.
+ * **y_length** (*float* *|* *None*) – The height of the plane.
+ * **background_line_style** (*dict* *[**str* *,* *Any* *]* *|* *None*) – Arguments that influence the construction of the background lines of the plane.
+ * **faded_line_style** (*dict* *[**str* *,* *Any* *]* *|* *None*) – Similar to `background_line_style`, affects the construction of the scene’s background lines.
+ * **faded_line_ratio** (*int*) – Determines the number of boxes within the background lines: `2` = 4 boxes, `3` = 9 boxes.
+ * **make_smooth_after_applying_functions** (*bool*) – Currently non-functional.
+ * **kwargs** (*dict* *[**str* *,* *Any* *]*) – Additional arguments to be passed to [`Axes`](manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes).
+
+#### NOTE
+If `x_length` or `y_length` are not defined, they are automatically calculated such that
+one unit on each axis is one Manim unit long.
+
+### Examples
+
+
+
+### Methods
+
+| `get_vector` | |
+|-----------------------------------|----|
+| `prepare_for_nonlinear_transform` | |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_get_lines()
+
+Generate all the lines, faded and not faded.
+: Two sets of lines are generated: one parallel to the X-axis, and parallel to the Y-axis.
+
+* **Returns:**
+ The first (i.e the non faded lines) and second (i.e the faded lines) sets of lines, respectively.
+* **Return type:**
+ Tuple[[`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup), [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)]
+
+#### \_get_lines_parallel_to_axis(axis_parallel_to, axis_perpendicular_to, freq, ratio_faded_lines)
+
+Generate a set of lines parallel to an axis.
+
+* **Parameters:**
+ * **axis_parallel_to** ([*NumberLine*](manim.mobject.graphing.number_line.NumberLine.md#manim.mobject.graphing.number_line.NumberLine)) – The axis with which the lines will be parallel.
+ * **axis_perpendicular_to** ([*NumberLine*](manim.mobject.graphing.number_line.NumberLine.md#manim.mobject.graphing.number_line.NumberLine)) – The axis with which the lines will be perpendicular.
+ * **ratio_faded_lines** (*int*) – The ratio between the space between faded lines and the space between non-faded lines.
+ * **freq** (*float*) – Frequency of non-faded lines (number of non-faded lines per graph unit).
+* **Returns:**
+ The first (i.e the non-faded lines parallel to axis_parallel_to) and second
+ : (i.e the faded lines parallel to axis_parallel_to) sets of lines, respectively.
+* **Return type:**
+ Tuple[[`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup), [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)]
+
+#### \_init_background_lines()
+
+Will init all the lines of NumberPlanes (faded or not)
+
+* **Return type:**
+ None
+
+#### \_original_\_init_\_(x_range=(-7.111111111111111, 7.111111111111111, 1), y_range=(-4.0, 4.0, 1), x_length=None, y_length=None, background_line_style=None, faded_line_style=None, faded_line_ratio=1, make_smooth_after_applying_functions=True, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **x_range** (*Sequence* *[**float* *]* *|* *None*)
+ * **y_range** (*Sequence* *[**float* *]* *|* *None*)
+ * **x_length** (*float* *|* *None*)
+ * **y_length** (*float* *|* *None*)
+ * **background_line_style** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **faded_line_style** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **faded_line_ratio** (*int*)
+ * **make_smooth_after_applying_functions** (*bool*)
+ * **kwargs** (*dict* *[**str* *,* *Any* *]*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.coordinate_systems.PolarPlane.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.coordinate_systems.PolarPlane.md
new file mode 100644
index 0000000000000000000000000000000000000000..ead9a3cc1cc18989868b9df2c454e8c41e398432
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.coordinate_systems.PolarPlane.md
@@ -0,0 +1,180 @@
+# PolarPlane
+
+Qualified name: `manim.mobject.graphing.coordinate\_systems.PolarPlane`
+
+### *class* PolarPlane(radius_max=4.0, size=None, radius_step=1, azimuth_step=None, azimuth_units='PI radians', azimuth_compact_fraction=True, azimuth_offset=0, azimuth_direction='CCW', azimuth_label_buff=0.1, azimuth_label_font_size=24, radius_config=None, background_line_style=None, faded_line_style=None, faded_line_ratio=1, make_smooth_after_applying_functions=True, \*\*kwargs)
+
+Bases: [`Axes`](manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes)
+
+Creates a polar plane with background lines.
+
+* **Parameters:**
+ * **azimuth_step** (*float* *|* *None*) –
+
+ The number of divisions in the azimuth (also known as the angular coordinate or polar angle). If `None` is specified then it will use the default
+ specified by `azimuth_units`:
+ - `"PI radians"` or `"TAU radians"`: 20
+ - `"degrees"`: 36
+ - `"gradians"`: 40
+ - `None`: 1
+
+ A non-integer value will result in a partial division at the end of the circle.
+ * **size** (*float* *|* *None*) – The diameter of the plane.
+ * **radius_step** (*float*) – The distance between faded radius lines.
+ * **radius_max** (*float*) – The maximum value of the radius.
+ * **azimuth_units** (*str* *|* *None*) –
+
+ Specifies a default labelling system for the azimuth. Choices are:
+ - `"PI radians"`: Fractional labels in the interval $\left[0, 2\pi\right]$ with $\pi$ as a constant.
+ - `"TAU radians"`: Fractional labels in the interval $\left[0, \tau\right]$ (where $\tau = 2\pi$) with $\tau$ as a constant.
+ - `"degrees"`: Decimal labels in the interval $\left[0, 360\right]$ with a degree ($^{\circ}$) symbol.
+ - `"gradians"`: Decimal labels in the interval $\left[0, 400\right]$ with a superscript “g” ($^{g}$).
+ - `None`: Decimal labels in the interval $\left[0, 1\right]$.
+ * **azimuth_compact_fraction** (*bool*) – If the `azimuth_units` choice has fractional labels, choose whether to
+ combine the constant in a compact form $\tfrac{xu}{y}$ as opposed to
+ $\tfrac{x}{y}u$, where $u$ is the constant.
+ * **azimuth_offset** (*float*) – The angle offset of the azimuth, expressed in radians.
+ * **azimuth_direction** (*str*) –
+
+ The direction of the azimuth.
+ - `"CW"`: Clockwise.
+ - `"CCW"`: Anti-clockwise.
+ * **azimuth_label_buff** (*float*) – The buffer for the azimuth labels.
+ * **azimuth_label_font_size** (*float*) – The font size of the azimuth labels.
+ * **radius_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) – The axis config for the radius.
+ * **background_line_style** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **faded_line_style** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **faded_line_ratio** (*int*)
+ * **make_smooth_after_applying_functions** (*bool*)
+ * **kwargs** (*Any*)
+
+### Examples
+
+
+
+#### get_y_axis_label(label, edge=array([1., 1., 0.]), direction=array([1., 1., 0.]), buff=0.1, rotation=1.5707963267948966, rotation_axis=array([0., 0., 1.]), \*\*kwargs)
+
+Generate a y-axis label.
+
+* **Parameters:**
+ * **label** (*float* *|* *str* *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The label. Defaults to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) for `str` and `float` inputs.
+ * **edge** (*Sequence* *[**float* *]*) – The edge of the y-axis to which the label will be added, by default `UR`.
+ * **direction** (*Sequence* *[**float* *]*) – Allows for further positioning of the label from an edge, by default `UR`.
+ * **buff** (*float*) – The distance of the label from the line, by default `SMALL_BUFF`.
+ * **rotation** (*float*) – The angle at which to rotate the label, by default `PI/2`.
+ * **rotation_axis** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D)) – The axis about which to rotate the label, by default `OUT`.
+* **Returns:**
+ The positioned label.
+* **Return type:**
+ [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+### Examples
+
+
+
+#### get_z_axis_label(label, edge=array([0., 0., 1.]), direction=array([1., 0., 0.]), buff=0.1, rotation=1.5707963267948966, rotation_axis=array([1., 0., 0.]), \*\*kwargs)
+
+Generate a z-axis label.
+
+* **Parameters:**
+ * **label** (*float* *|* *str* *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The label. Defaults to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) for `str` and `float` inputs.
+ * **edge** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D)) – The edge of the z-axis to which the label will be added, by default `OUT`.
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D)) – Allows for further positioning of the label from an edge, by default `RIGHT`.
+ * **buff** (*float*) – The distance of the label from the line, by default `SMALL_BUFF`.
+ * **rotation** (*float*) – The angle at which to rotate the label, by default `PI/2`.
+ * **rotation_axis** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D)) – The axis about which to rotate the label, by default `RIGHT`.
+ * **kwargs** (*Any*)
+* **Returns:**
+ The positioned label.
+* **Return type:**
+ [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+### Examples
+
+
+
+### Methods
+
+| `get_function` | |
+|---------------------------|----|
+| `get_point_from_function` | |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(function, x_range=None, color=ManimColor('#FFFF00'), \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.functions.ImplicitFunction.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.functions.ImplicitFunction.md
new file mode 100644
index 0000000000000000000000000000000000000000..c10077685cc66ba4f5562a9f4ebd6c14aa846fad
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.functions.ImplicitFunction.md
@@ -0,0 +1,137 @@
+# ImplicitFunction
+
+Qualified name: `manim.mobject.graphing.functions.ImplicitFunction`
+
+### *class* ImplicitFunction(func, x_range=None, y_range=None, min_depth=5, max_quads=1500, use_smoothing=True, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+An implicit function.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**float* *,* *float* *]* *,* *float* *]*) – The implicit function in the form `f(x, y) = 0`.
+ * **x_range** (*Sequence* *[**float* *]* *|* *None*) – The x min and max of the function.
+ * **y_range** (*Sequence* *[**float* *]* *|* *None*) – The y min and max of the function.
+ * **min_depth** (*int*) – The minimum depth of the function to calculate.
+ * **max_quads** (*int*) – The maximum number of quads to use.
+ * **use_smoothing** (*bool*) – Whether or not to smoothen the curves.
+ * **kwargs** – Additional parameters to pass into `VMobject`
+
+#### NOTE
+A small `min_depth` $d$ means that some small details might
+be ignored if they don’t cross an edge of one of the
+$4^d$ uniform quads.
+
+The value of `max_quads` strongly corresponds to the
+quality of the curve, but a higher number of quads
+may take longer to render.
+
+### Examples
+
+
+class ImplicitFunctionExample(Scene):
+ def construct(self):
+ graph = ImplicitFunction(
+ lambda x, y: x \* y \*\* 2 - x \*\* 2 \* y - 2,
+ color=YELLOW
+ )
+ self.add(NumberPlane(), graph)
+
+
+
+### Methods
+
+| [`generate_points`](#manim.mobject.graphing.functions.ImplicitFunction.generate_points) | Initializes `points` and therefore the shape. |
+|-------------------------------------------------------------------------------------------|-------------------------------------------------|
+| [`init_points`](#manim.mobject.graphing.functions.ImplicitFunction.init_points) | Initializes `points` and therefore the shape. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(func, x_range=None, y_range=None, min_depth=5, max_quads=1500, use_smoothing=True, \*\*kwargs)
+
+An implicit function.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**float* *,* *float* *]* *,* *float* *]*) – The implicit function in the form `f(x, y) = 0`.
+ * **x_range** (*Sequence* *[**float* *]* *|* *None*) – The x min and max of the function.
+ * **y_range** (*Sequence* *[**float* *]* *|* *None*) – The y min and max of the function.
+ * **min_depth** (*int*) – The minimum depth of the function to calculate.
+ * **max_quads** (*int*) – The maximum number of quads to use.
+ * **use_smoothing** (*bool*) – Whether or not to smoothen the curves.
+ * **kwargs** – Additional parameters to pass into `VMobject`
+
+#### NOTE
+A small `min_depth` $d$ means that some small details might
+be ignored if they don’t cross an edge of one of the
+$4^d$ uniform quads.
+
+The value of `max_quads` strongly corresponds to the
+quality of the curve, but a higher number of quads
+may take longer to render.
+
+### Examples
+
+
+class ImplicitFunctionExample(Scene):
+ def construct(self):
+ graph = ImplicitFunction(
+ lambda x, y: x \* y \*\* 2 - x \*\* 2 \* y - 2,
+ color=YELLOW
+ )
+ self.add(NumberPlane(), graph)
+
+
+
+#### generate_points()
+
+Initializes `points` and therefore the shape.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
+
+#### init_points()
+
+Initializes `points` and therefore the shape.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.functions.ParametricFunction.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.functions.ParametricFunction.md
new file mode 100644
index 0000000000000000000000000000000000000000..b381ec6e247770f6c0ae402eea18a054c67b6906
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.functions.ParametricFunction.md
@@ -0,0 +1,182 @@
+# ParametricFunction
+
+Qualified name: `manim.mobject.graphing.functions.ParametricFunction`
+
+### *class* ParametricFunction(function, t_range=(0, 1), scaling=, dt=1e-08, discontinuities=None, use_smoothing=True, use_vectorized=False, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A parametric curve.
+
+* **Parameters:**
+ * **function** (*Callable* *[* *[**float* *]* *,* [*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *]*) – The function to be plotted in the form of `(lambda t: (x(t), y(t), z(t)))`
+ * **t_range** (*tuple* *[**float* *,* *float* *]* *|* *tuple* *[**float* *,* *float* *,* *float* *]*) – Determines the length that the function spans in the form of (t_min, t_max, step=0.01). By default `[0, 1]`
+ * **scaling** ( *\_ScaleBase*) – Scaling class applied to the points of the function. Default of [`LinearBase`](manim.mobject.graphing.scale.LinearBase.md#manim.mobject.graphing.scale.LinearBase).
+ * **use_smoothing** (*bool*) – Whether to interpolate between the points of the function after they have been created.
+ (Will have odd behaviour with a low number of points)
+ * **use_vectorized** (*bool*) – Whether to pass in the generated t value array to the function as `[t_0, t_1, ...]`.
+ Only use this if your function supports it. Output should be a numpy array
+ of shape `[[x_0, x_1, ...], [y_0, y_1, ...], [z_0, z_1, ...]]` but `z` can
+ also be 0 if the Axes is 2D
+ * **discontinuities** (*Iterable* *[**float* *]* *|* *None*) – Values of t at which the function experiences discontinuity.
+ * **dt** (*float*) – The left and right tolerance for the discontinuities.
+
+### Examples
+
+
+
+#### ATTENTION
+If your function has discontinuities, you’ll have to specify the location
+of the discontinuities manually. See the following example for guidance.
+
+
+
+### Methods
+
+| [`generate_points`](#manim.mobject.graphing.functions.ParametricFunction.generate_points) | Initializes `points` and therefore the shape. |
+|---------------------------------------------------------------------------------------------|-------------------------------------------------|
+| `get_function` | |
+| `get_point_from_function` | |
+| [`init_points`](#manim.mobject.graphing.functions.ParametricFunction.init_points) | Initializes `points` and therefore the shape. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(function, t_range=(0, 1), scaling=, dt=1e-08, discontinuities=None, use_smoothing=True, use_vectorized=False, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **function** (*Callable* *[* *[**float* *]* *,* [*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *]*)
+ * **t_range** (*tuple* *[**float* *,* *float* *]* *|* *tuple* *[**float* *,* *float* *,* *float* *]*)
+ * **scaling** ( *\_ScaleBase*)
+ * **dt** (*float*)
+ * **discontinuities** (*Iterable* *[**float* *]* *|* *None*)
+ * **use_smoothing** (*bool*)
+ * **use_vectorized** (*bool*)
+
+#### generate_points()
+
+Initializes `points` and therefore the shape.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
+
+* **Return type:**
+ Self
+
+#### init_points()
+
+Initializes `points` and therefore the shape.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
+
+* **Return type:**
+ Self
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.functions.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.functions.md
new file mode 100644
index 0000000000000000000000000000000000000000..96775862a8134b29113f86e4c0301ddc806ac055
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.functions.md
@@ -0,0 +1,10 @@
+# functions
+
+Mobjects representing function graphs.
+
+### Classes
+
+| [`FunctionGraph`](manim.mobject.graphing.functions.FunctionGraph.md#manim.mobject.graphing.functions.FunctionGraph) | A [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction) that spans the length of the scene by default. |
+|------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`ImplicitFunction`](manim.mobject.graphing.functions.ImplicitFunction.md#manim.mobject.graphing.functions.ImplicitFunction) | An implicit function. |
+| [`ParametricFunction`](manim.mobject.graphing.functions.ParametricFunction.md#manim.mobject.graphing.functions.ParametricFunction) | A parametric curve. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.md
new file mode 100644
index 0000000000000000000000000000000000000000..6845971c98269bfd1d6fe9305153f9245aeec625
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.md
@@ -0,0 +1,12 @@
+# graphing
+
+Coordinate systems and function graphing related mobjects.
+
+## Modules
+
+| [`coordinate_systems`](manim.mobject.graphing.coordinate_systems.md#module-manim.mobject.graphing.coordinate_systems) | Mobjects that represent coordinate systems. |
+|-------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------|
+| [`functions`](manim.mobject.graphing.functions.md#module-manim.mobject.graphing.functions) | Mobjects representing function graphs. |
+| [`number_line`](manim.mobject.graphing.number_line.md#module-manim.mobject.graphing.number_line) | Mobject representing a number line. |
+| [`probability`](manim.mobject.graphing.probability.md#module-manim.mobject.graphing.probability) | Mobjects representing objects from probability theory and statistics. |
+| [`scale`](manim.mobject.graphing.scale.md#module-manim.mobject.graphing.scale) | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.number_line.NumberLine.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.number_line.NumberLine.md
new file mode 100644
index 0000000000000000000000000000000000000000..c03bd8d97c5538255280e4245073fcf2e04fa1e1
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.number_line.NumberLine.md
@@ -0,0 +1,363 @@
+# NumberLine
+
+Qualified name: `manim.mobject.graphing.number\_line.NumberLine`
+
+### *class* NumberLine(x_range=None, length=None, unit_size=1, include_ticks=True, tick_size=0.1, numbers_with_elongated_ticks=None, longer_tick_multiple=2, exclude_origin_tick=False, rotation=0, stroke_width=2.0, include_tip=False, tip_width=0.35, tip_height=0.35, tip_shape=None, include_numbers=False, font_size=36, label_direction=array([ 0., -1., 0.]), label_constructor=, scaling=, line_to_number_buff=0.25, decimal_number_config=None, numbers_to_exclude=None, numbers_to_include=None, \*\*kwargs)
+
+Bases: [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line)
+
+Creates a number line with tick marks.
+
+* **Parameters:**
+ * **x_range** (*Sequence* *[**float* *]* *|* *None*) – The `[x_min, x_max, x_step]` values to create the line.
+ * **length** (*float* *|* *None*) – The length of the number line.
+ * **unit_size** (*float*) – The distance between each tick of the line. Overwritten by `length`, if specified.
+ * **include_ticks** (*bool*) – Whether to include ticks on the number line.
+ * **tick_size** (*float*) – The length of each tick mark.
+ * **numbers_with_elongated_ticks** (*Iterable* *[**float* *]* *|* *None*) – An iterable of specific values with elongated ticks.
+ * **longer_tick_multiple** (*int*) – Influences how many times larger elongated ticks are than regular ticks (2 = 2x).
+ * **rotation** (*float*) – The angle (in radians) at which the line is rotated.
+ * **stroke_width** (*float*) – The thickness of the line.
+ * **include_tip** (*bool*) – Whether to add a tip to the end of the line.
+ * **tip_width** (*float*) – The width of the tip.
+ * **tip_height** (*float*) – The height of the tip.
+ * **tip_shape** (*type* *[*[*ArrowTip*](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip) *]* *|* *None*) – The mobject class used to construct the tip, or `None` (the
+ default) for the default arrow tip. Passed classes have to inherit
+ from [`ArrowTip`](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip).
+ * **include_numbers** (*bool*) – Whether to add numbers to the tick marks. The number of decimal places is determined
+ by the step size, this default can be overridden by `decimal_number_config`.
+ * **scaling** ( *\_ScaleBase*) – The way the `x_range` is value is scaled, i.e. [`LogBase`](manim.mobject.graphing.scale.LogBase.md#manim.mobject.graphing.scale.LogBase) for a logarithmic numberline. Defaults to [`LinearBase`](manim.mobject.graphing.scale.LinearBase.md#manim.mobject.graphing.scale.LinearBase).
+ * **font_size** (*float*) – The size of the label mobjects. Defaults to 36.
+ * **label_direction** (*Sequence* *[**float* *]*) – The specific position to which label mobjects are added on the line.
+ * **label_constructor** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – Determines the mobject class that will be used to construct the labels of the number line.
+ * **line_to_number_buff** (*float*) – The distance between the line and the label mobject.
+ * **decimal_number_config** (*dict* *|* *None*) – Arguments that can be passed to [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber) to influence number mobjects.
+ * **numbers_to_exclude** (*Iterable* *[**float* *]* *|* *None*) – An explicit iterable of numbers to not be added to the number line.
+ * **numbers_to_include** (*Iterable* *[**float* *]* *|* *None*) – An explicit iterable of numbers to add to the number line
+ * **kwargs** – Additional arguments to be passed to [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line).
+ * **exclude_origin_tick** (*bool*)
+
+#### NOTE
+Number ranges that include both negative and positive values will be generated
+from the 0 point, and may not include a tick at the min / max
+values as the tick locations are dependent on the step size.
+
+### Examples
+
+
+
+### Methods
+
+| [`add_labels`](#manim.mobject.graphing.number_line.NumberLine.add_labels) | Adds specifically positioned labels to the [`NumberLine`](#manim.mobject.graphing.number_line.NumberLine) using a `dict`. |
+|-------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`add_numbers`](#manim.mobject.graphing.number_line.NumberLine.add_numbers) | Adds [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber) mobjects representing their position at each tick of the number line. |
+| [`add_ticks`](#manim.mobject.graphing.number_line.NumberLine.add_ticks) | Adds ticks to the number line. |
+| `get_labels` | |
+| [`get_number_mobject`](#manim.mobject.graphing.number_line.NumberLine.get_number_mobject) | Generates a positioned [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber) mobject generated according to `label_constructor`. |
+| `get_number_mobjects` | |
+| [`get_tick`](#manim.mobject.graphing.number_line.NumberLine.get_tick) | Generates a tick and positions it along the number line. |
+| `get_tick_marks` | |
+| [`get_tick_range`](#manim.mobject.graphing.number_line.NumberLine.get_tick_range) | Generates the range of values on which labels are plotted based on the `x_range` attribute of the number line. |
+| `get_unit_size` | |
+| `get_unit_vector` | |
+| [`n2p`](#manim.mobject.graphing.number_line.NumberLine.n2p) | Abbreviation for [`number_to_point()`](#manim.mobject.graphing.number_line.NumberLine.number_to_point). |
+| [`number_to_point`](#manim.mobject.graphing.number_line.NumberLine.number_to_point) | Accepts a value along the number line and returns a point with respect to the scene. |
+| [`p2n`](#manim.mobject.graphing.number_line.NumberLine.p2n) | Abbreviation for [`point_to_number()`](#manim.mobject.graphing.number_line.NumberLine.point_to_number). |
+| [`point_to_number`](#manim.mobject.graphing.number_line.NumberLine.point_to_number) | Accepts a point with respect to the scene and returns a float along the number line. |
+| `rotate_about_number` | |
+| `rotate_about_zero` | |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_create_label_tex(label_tex, label_constructor=None, \*\*kwargs)
+
+Checks if the label is a [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject), otherwise, creates a
+label by passing `label_tex` to `label_constructor`.
+
+* **Parameters:**
+ * **label_tex** (*str* *|* *float* *|* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The label for which a mobject should be created. If the label already
+ is a mobject, no new mobject is created.
+ * **label_constructor** (*Callable* *|* *None*) – Optional. A class or function returning a mobject when
+ passing `label_tex` as an argument. If `None` is passed
+ (the default), the label constructor from the `label_constructor`
+ attribute is used.
+* **Returns:**
+ The label.
+* **Return type:**
+ [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### \_original_\_init_\_(x_range=None, length=None, unit_size=1, include_ticks=True, tick_size=0.1, numbers_with_elongated_ticks=None, longer_tick_multiple=2, exclude_origin_tick=False, rotation=0, stroke_width=2.0, include_tip=False, tip_width=0.35, tip_height=0.35, tip_shape=None, include_numbers=False, font_size=36, label_direction=array([ 0., -1., 0.]), label_constructor=, scaling=, line_to_number_buff=0.25, decimal_number_config=None, numbers_to_exclude=None, numbers_to_include=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **x_range** (*Sequence* *[**float* *]* *|* *None*)
+ * **length** (*float* *|* *None*)
+ * **unit_size** (*float*)
+ * **include_ticks** (*bool*)
+ * **tick_size** (*float*)
+ * **numbers_with_elongated_ticks** (*Iterable* *[**float* *]* *|* *None*)
+ * **longer_tick_multiple** (*int*)
+ * **exclude_origin_tick** (*bool*)
+ * **rotation** (*float*)
+ * **stroke_width** (*float*)
+ * **include_tip** (*bool*)
+ * **tip_width** (*float*)
+ * **tip_height** (*float*)
+ * **tip_shape** (*type* *[*[*ArrowTip*](manim.mobject.geometry.tips.ArrowTip.md#manim.mobject.geometry.tips.ArrowTip) *]* *|* *None*)
+ * **include_numbers** (*bool*)
+ * **font_size** (*float*)
+ * **label_direction** (*Sequence* *[**float* *]*)
+ * **label_constructor** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+ * **scaling** ( *\_ScaleBase*)
+ * **line_to_number_buff** (*float*)
+ * **decimal_number_config** (*dict* *|* *None*)
+ * **numbers_to_exclude** (*Iterable* *[**float* *]* *|* *None*)
+ * **numbers_to_include** (*Iterable* *[**float* *]* *|* *None*)
+
+#### add_labels(dict_values, direction=None, buff=None, font_size=None, label_constructor=None)
+
+Adds specifically positioned labels to the [`NumberLine`](#manim.mobject.graphing.number_line.NumberLine) using a `dict`.
+The labels can be accessed after creation via `self.labels`.
+
+* **Parameters:**
+ * **dict_values** (*dict* *[**float* *,* *str* *|* *float* *|* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*) – A dictionary consisting of the position along the number line and the mobject to be added:
+ `{1: Tex("Monday"), 3: Tex("Tuesday")}`. `label_constructor` will be used
+ to construct the labels if the value is not a mobject (`str` or `float`).
+ * **direction** (*Sequence* *[**float* *]*) – Determines the direction at which the label is positioned next to the line.
+ * **buff** (*float* *|* *None*) – The distance of the label from the line.
+ * **font_size** (*float* *|* *None*) – The font size of the mobject to be positioned.
+ * **label_constructor** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *None*) – The [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) class that will be used to construct the label.
+ Defaults to the `label_constructor` attribute of the number line
+ if not specified.
+* **Raises:**
+ **AttributeError** – If the label does not have a `font_size` attribute, an `AttributeError` is raised.
+
+#### add_numbers(x_values=None, excluding=None, font_size=None, label_constructor=None, \*\*kwargs)
+
+Adds [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber) mobjects representing their position
+at each tick of the number line. The numbers can be accessed after creation
+via `self.numbers`.
+
+* **Parameters:**
+ * **x_values** (*Iterable* *[**float* *]* *|* *None*) – An iterable of the values used to position and create the labels.
+ Defaults to the output produced by [`get_tick_range()`](#manim.mobject.graphing.number_line.NumberLine.get_tick_range)
+ * **excluding** (*Iterable* *[**float* *]* *|* *None*) – A list of values to exclude from `x_values`.
+ * **font_size** (*float* *|* *None*) – The font size of the labels. Defaults to the `font_size` attribute
+ of the number line.
+ * **label_constructor** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *None*) – The [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) class that will be used to construct the label.
+ Defaults to the `label_constructor` attribute of the number line
+ if not specified.
+
+#### add_ticks()
+
+Adds ticks to the number line. Ticks can be accessed after creation
+via `self.ticks`.
+
+#### get_number_mobject(x, direction=None, buff=None, font_size=None, label_constructor=None, \*\*number_config)
+
+Generates a positioned [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber) mobject
+generated according to `label_constructor`.
+
+* **Parameters:**
+ * **x** (*float*) – The x-value at which the mobject should be positioned.
+ * **direction** (*Sequence* *[**float* *]* *|* *None*) – Determines the direction at which the label is positioned next to the line.
+ * **buff** (*float* *|* *None*) – The distance of the label from the line.
+ * **font_size** (*float* *|* *None*) – The font size of the label mobject.
+ * **label_constructor** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *None*) – The [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) class that will be used to construct the label.
+ Defaults to the `label_constructor` attribute of the number line
+ if not specified.
+* **Returns:**
+ The positioned mobject.
+* **Return type:**
+ [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber)
+
+#### get_tick(x, size=None)
+
+Generates a tick and positions it along the number line.
+
+* **Parameters:**
+ * **x** (*float*) – The position of the tick.
+ * **size** (*float* *|* *None*) – The factor by which the tick is scaled.
+* **Returns:**
+ A positioned tick.
+* **Return type:**
+ [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line)
+
+#### get_tick_range()
+
+Generates the range of values on which labels are plotted based on the
+`x_range` attribute of the number line.
+
+* **Returns:**
+ A numpy array of floats represnting values along the number line.
+* **Return type:**
+ np.ndarray
+
+#### n2p(number)
+
+Abbreviation for [`number_to_point()`](#manim.mobject.graphing.number_line.NumberLine.number_to_point).
+
+* **Parameters:**
+ **number** (*float* *|* *ndarray*)
+* **Return type:**
+ *ndarray*
+
+#### number_to_point(number)
+
+Accepts a value along the number line and returns a point with
+respect to the scene.
+Equivalent to NumberLine @ number
+
+* **Parameters:**
+ **number** (*float* *|* *ndarray*) – The value to be transformed into a coordinate. Or a list of values.
+* **Returns:**
+ A point with respect to the scene’s coordinate system. Or a list of points.
+* **Return type:**
+ np.ndarray
+
+### Examples
+
+```pycon
+>>> from manim import NumberLine
+>>> number_line = NumberLine()
+>>> number_line.number_to_point(0)
+array([0., 0., 0.])
+>>> number_line.number_to_point(1)
+array([1., 0., 0.])
+>>> number_line @ 1
+array([1., 0., 0.])
+>>> number_line.number_to_point([1, 2, 3])
+array([[1., 0., 0.],
+ [2., 0., 0.],
+ [3., 0., 0.]])
+```
+
+#### p2n(point)
+
+Abbreviation for [`point_to_number()`](#manim.mobject.graphing.number_line.NumberLine.point_to_number).
+
+* **Parameters:**
+ **point** (*Sequence* *[**float* *]*)
+* **Return type:**
+ float
+
+#### point_to_number(point)
+
+Accepts a point with respect to the scene and returns
+a float along the number line.
+
+* **Parameters:**
+ **point** (*Sequence* *[**float* *]*) – A sequence of values consisting of `(x_coord, y_coord, z_coord)`.
+* **Returns:**
+ A float representing a value along the number line.
+* **Return type:**
+ float
+
+### Examples
+
+```pycon
+>>> from manim import NumberLine
+>>> number_line = NumberLine()
+>>> number_line.point_to_number((0, 0, 0))
+np.float64(0.0)
+>>> number_line.point_to_number((1, 0, 0))
+np.float64(1.0)
+>>> number_line.point_to_number([[0.5, 0, 0], [1, 0, 0], [1.5, 0, 0]])
+array([0.5, 1. , 1.5])
+```
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.number_line.UnitInterval.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.number_line.UnitInterval.md
new file mode 100644
index 0000000000000000000000000000000000000000..e18616e1ecf8bd1908969f768feec38b85e6be0d
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.number_line.UnitInterval.md
@@ -0,0 +1,27 @@
+# UnitInterval
+
+Qualified name: `manim.mobject.graphing.number\_line.UnitInterval`
+
+### *class* UnitInterval(unit_size=10, numbers_with_elongated_ticks=None, decimal_number_config=None, \*\*kwargs)
+
+Bases: [`NumberLine`](manim.mobject.graphing.number_line.NumberLine.md#manim.mobject.graphing.number_line.NumberLine)
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(unit_size=10, numbers_with_elongated_ticks=None, decimal_number_config=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.number_line.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.number_line.md
new file mode 100644
index 0000000000000000000000000000000000000000..f40bc03630adb9eace0c36b361f40f34c93499f9
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.number_line.md
@@ -0,0 +1,9 @@
+# number_line
+
+Mobject representing a number line.
+
+### Classes
+
+| [`NumberLine`](manim.mobject.graphing.number_line.NumberLine.md#manim.mobject.graphing.number_line.NumberLine) | Creates a number line with tick marks. |
+|----------------------------------------------------------------------------------------------------------------------|------------------------------------------|
+| [`UnitInterval`](manim.mobject.graphing.number_line.UnitInterval.md#manim.mobject.graphing.number_line.UnitInterval) | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.probability.BarChart.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.probability.BarChart.md
new file mode 100644
index 0000000000000000000000000000000000000000..3452a77a15e61fc2971e1b2b701970ccfe498827
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.probability.BarChart.md
@@ -0,0 +1,221 @@
+# BarChart
+
+Qualified name: `manim.mobject.graphing.probability.BarChart`
+
+### *class* BarChart(values, bar_names=None, y_range=None, x_length=None, y_length=None, bar_colors=['#003f5c', '#58508d', '#bc5090', '#ff6361', '#ffa600'], bar_width=0.6, bar_fill_opacity=0.7, bar_stroke_width=3, \*\*kwargs)
+
+Bases: [`Axes`](manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes)
+
+Creates a bar chart. Inherits from [`Axes`](manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes), so it shares its methods
+and attributes. Each axis inherits from [`NumberLine`](manim.mobject.graphing.number_line.NumberLine.md#manim.mobject.graphing.number_line.NumberLine), so pass in `x_axis_config`/`y_axis_config`
+to control their attributes.
+
+* **Parameters:**
+ * **values** (*MutableSequence* *[**float* *]*) – A sequence of values that determines the height of each bar. Accepts negative values.
+ * **bar_names** (*Sequence* *[**str* *]* *|* *None*) – A sequence of names for each bar. Does not have to match the length of `values`.
+ * **y_range** (*Sequence* *[**float* *]* *|* *None*) – The y_axis range of values. If `None`, the range will be calculated based on the
+ min/max of `values` and the step will be calculated based on `y_length`.
+ * **x_length** (*float* *|* *None*) – The length of the x-axis. If `None`, it is automatically calculated based on
+ the number of values and the width of the screen.
+ * **y_length** (*float* *|* *None*) – The length of the y-axis.
+ * **bar_colors** (*Iterable* *[**str* *]*) – The color for the bars. Accepts a sequence of colors (can contain just one item).
+ If the length of\`\`bar_colors\`\` does not match that of `values`,
+ intermediate colors will be automatically determined.
+ * **bar_width** (*float*) – The length of a bar. Must be between 0 and 1.
+ * **bar_fill_opacity** (*float*) – The fill opacity of the bars.
+ * **bar_stroke_width** (*float*) – The stroke width of the bars.
+
+### Examples
+
+
+
+### Methods
+
+| [`change_bar_values`](#manim.mobject.graphing.probability.BarChart.change_bar_values) | Updates the height of the bars of the chart. |
+|-----------------------------------------------------------------------------------------|--------------------------------------------------|
+| [`get_bar_labels`](#manim.mobject.graphing.probability.BarChart.get_bar_labels) | Annotates each bar with its corresponding value. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_add_x_axis_labels()
+
+Essentially :meth\`:~.NumberLine.add_labels\`, but differs in that
+the direction of the label with respect to the x_axis changes to UP or DOWN
+depending on the value.
+
+UP for negative values and DOWN for positive values.
+
+#### \_create_bar(bar_number, value)
+
+Creates a positioned bar on the chart.
+
+* **Parameters:**
+ * **bar_number** (*int*) – Determines the x-position of the bar.
+ * **value** (*float*) – The value that determines the height of the bar.
+* **Returns:**
+ A positioned rectangle representing a bar on the chart.
+* **Return type:**
+ [Rectangle](manim.mobject.geometry.polygram.Rectangle.md#manim.mobject.geometry.polygram.Rectangle)
+
+#### \_original_\_init_\_(values, bar_names=None, y_range=None, x_length=None, y_length=None, bar_colors=['#003f5c', '#58508d', '#bc5090', '#ff6361', '#ffa600'], bar_width=0.6, bar_fill_opacity=0.7, bar_stroke_width=3, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **values** (*MutableSequence* *[**float* *]*)
+ * **bar_names** (*Sequence* *[**str* *]* *|* *None*)
+ * **y_range** (*Sequence* *[**float* *]* *|* *None*)
+ * **x_length** (*float* *|* *None*)
+ * **y_length** (*float* *|* *None*)
+ * **bar_colors** (*Iterable* *[**str* *]*)
+ * **bar_width** (*float*)
+ * **bar_fill_opacity** (*float*)
+ * **bar_stroke_width** (*float*)
+
+#### \_update_colors()
+
+Initialize the colors of the bars of the chart.
+
+Sets the color of `self.bars` via `self.bar_colors`.
+
+Primarily used when the bars are initialized with `self._add_bars`
+or updated via `self.change_bar_values`.
+
+#### change_bar_values(values, update_colors=True)
+
+Updates the height of the bars of the chart.
+
+* **Parameters:**
+ * **values** (*Iterable* *[**float* *]*) – The values that will be used to update the height of the bars.
+ Does not have to match the number of bars.
+ * **update_colors** (*bool*) – Whether to re-initalize the colors of the bars based on `self.bar_colors`.
+
+### Examples
+
+
+
+#### get_bar_labels(color=None, font_size=24, buff=0.25, label_constructor=)
+
+Annotates each bar with its corresponding value. Use `self.bar_labels` to access the
+labels after creation.
+
+* **Parameters:**
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The color of each label. By default `None` and is based on the parent’s bar color.
+ * **font_size** (*float*) – The font size of each label.
+ * **buff** (*float*) – The distance from each label to its bar. By default 0.4.
+ * **label_constructor** (*type* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*) – The Mobject class to construct the labels, by default [`Tex`](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex).
+
+### Examples
+
+
+
+### Methods
+
+| `add_braces_and_labels` | |
+|-------------------------------------|----|
+| `add_label` | |
+| `add_title` | |
+| `complete_p_list` | |
+| `divide_horizontally` | |
+| `divide_vertically` | |
+| `get_bottom_braces_and_labels` | |
+| `get_division_along_dimension` | |
+| `get_horizontal_division` | |
+| `get_side_braces_and_labels` | |
+| `get_subdivision_braces_and_labels` | |
+| `get_top_braces_and_labels` | |
+| `get_vertical_division` | |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(height=3, width=3, fill_color=ManimColor('#444444'), fill_opacity=1, stroke_width=0.5, stroke_color=ManimColor('#BBBBBB'), default_label_scale_val=1)
+
+Initialize self. See help(type(self)) for accurate signature.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.probability.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.probability.md
new file mode 100644
index 0000000000000000000000000000000000000000..8b08299e55ebafe7bbb08c17b505108e6a335c20
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.probability.md
@@ -0,0 +1,9 @@
+# probability
+
+Mobjects representing objects from probability theory and statistics.
+
+### Classes
+
+| [`BarChart`](manim.mobject.graphing.probability.BarChart.md#manim.mobject.graphing.probability.BarChart) | Creates a bar chart. |
+|-------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------|
+| [`SampleSpace`](manim.mobject.graphing.probability.SampleSpace.md#manim.mobject.graphing.probability.SampleSpace) | A mobject representing a twodimensional rectangular sampling space. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.scale.LinearBase.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.scale.LinearBase.md
new file mode 100644
index 0000000000000000000000000000000000000000..8f6def2c9f6a79f076e2add6cb8c88ec0f067c68
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.scale.LinearBase.md
@@ -0,0 +1,36 @@
+# LinearBase
+
+Qualified name: `manim.mobject.graphing.scale.LinearBase`
+
+### *class* LinearBase(scale_factor=1.0)
+
+Bases: `_ScaleBase`
+
+The default scaling class.
+
+* **Parameters:**
+ **scale_factor** (*float*) – The slope of the linear function, by default 1.0
+
+### Methods
+
+| [`function`](#manim.mobject.graphing.scale.LinearBase.function) | Multiplies the value by the scale factor. |
+|---------------------------------------------------------------------------------|---------------------------------------------|
+| [`inverse_function`](#manim.mobject.graphing.scale.LinearBase.inverse_function) | Inverse of function. |
+
+#### function(value)
+
+Multiplies the value by the scale factor.
+
+* **Parameters:**
+ **value** (*float*) – Value to be multiplied by the scale factor.
+* **Return type:**
+ float
+
+#### inverse_function(value)
+
+Inverse of function. Divides the value by the scale factor.
+
+* **Parameters:**
+ **value** (*float*) – value to be divided by the scale factor.
+* **Return type:**
+ float
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.scale.LogBase.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.scale.LogBase.md
new file mode 100644
index 0000000000000000000000000000000000000000..45a8db5d31cfd4cc7dadf17921d478e9cf5384e7
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.scale.LogBase.md
@@ -0,0 +1,56 @@
+# LogBase
+
+Qualified name: `manim.mobject.graphing.scale.LogBase`
+
+### *class* LogBase(base=10, custom_labels=True)
+
+Bases: `_ScaleBase`
+
+Scale for logarithmic graphs/functions.
+
+* **Parameters:**
+ * **base** (*float*) – The base of the log, by default 10.
+ * **custom_labels** (*bool*) – For use with [`Axes`](manim.mobject.graphing.coordinate_systems.Axes.md#manim.mobject.graphing.coordinate_systems.Axes):
+ Whether or not to include `LaTeX` axis labels, by default True.
+
+### Examples
+
+```python
+func = ParametricFunction(lambda x: x, scaling=LogBase(base=2))
+```
+
+### Methods
+
+| [`function`](#manim.mobject.graphing.scale.LogBase.function) | Scales the value to fit it to a logarithmic scale.\`\`self.function(5)==10\*\*5\`\` |
+|--------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------|
+| [`get_custom_labels`](#manim.mobject.graphing.scale.LogBase.get_custom_labels) | Produces custom [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer) labels in the form of `10^2`. |
+| [`inverse_function`](#manim.mobject.graphing.scale.LogBase.inverse_function) | Inverse of `function`. |
+
+#### function(value)
+
+Scales the value to fit it to a logarithmic scale.\`\`self.function(5)==10\*\*5\`\`
+
+* **Parameters:**
+ **value** (*float*)
+* **Return type:**
+ float
+
+#### get_custom_labels(val_range, unit_decimal_places=0, \*\*base_config)
+
+Produces custom [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer) labels in the form of `10^2`.
+
+* **Parameters:**
+ * **val_range** (*Iterable* *[**float* *]*) – The iterable of values used to create the labels. Determines the exponent.
+ * **unit_decimal_places** (*int*) – The number of decimal places to include in the exponent
+ * **base_config** (*dict* *[**str* *,* *Any* *]*) – Additional arguments to be passed to [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer).
+* **Return type:**
+ list[[Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)]
+
+#### inverse_function(value)
+
+Inverse of `function`. The value must be greater than 0
+
+* **Parameters:**
+ **value** (*float*)
+* **Return type:**
+ float
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.scale.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.scale.md
new file mode 100644
index 0000000000000000000000000000000000000000..9d8c30bc5604329dccbd37072f4154185c88d00c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.graphing.scale.md
@@ -0,0 +1,7 @@
+# scale
+
+### Classes
+
+| [`LinearBase`](manim.mobject.graphing.scale.LinearBase.md#manim.mobject.graphing.scale.LinearBase) | The default scaling class. |
+|------------------------------------------------------------------------------------------------------|-----------------------------------------|
+| [`LogBase`](manim.mobject.graphing.scale.LogBase.md#manim.mobject.graphing.scale.LogBase) | Scale for logarithmic graphs/functions. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.logo.ManimBanner.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.logo.ManimBanner.md
new file mode 100644
index 0000000000000000000000000000000000000000..cc7969cbe2d08e65ecb18e7ba6cdc97bec69e785
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.logo.ManimBanner.md
@@ -0,0 +1,189 @@
+# ManimBanner
+
+Qualified name: `manim.mobject.logo.ManimBanner`
+
+### *class* ManimBanner(dark_theme=True)
+
+Bases: [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+Convenience class representing Manim’s banner.
+
+Can be animated using custom methods.
+
+* **Parameters:**
+ **dark_theme** (*bool*) – If `True` (the default), the dark theme version of the logo
+ (with light text font) will be rendered. Otherwise, if `False`,
+ the light theme version (with dark text font) is used.
+
+### Examples
+
+
+
+### Methods
+
+| [`create`](#manim.mobject.logo.ManimBanner.create) | The creation animation for Manim's logo. |
+|------------------------------------------------------|---------------------------------------------------------|
+| [`expand`](#manim.mobject.logo.ManimBanner.expand) | An animation that expands Manim's logo into its banner. |
+| [`scale`](#manim.mobject.logo.ManimBanner.scale) | Scale the banner by the specified scale factor. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(dark_theme=True)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **dark_theme** (*bool*)
+
+#### create(run_time=2)
+
+The creation animation for Manim’s logo.
+
+* **Parameters:**
+ **run_time** (*float*) – The run time of the animation.
+* **Returns:**
+ An animation to be used in a [`Scene.play()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call.
+* **Return type:**
+ [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup)
+
+#### expand(run_time=1.5, direction='center')
+
+An animation that expands Manim’s logo into its banner.
+
+The returned animation transforms the banner from its initial
+state (representing Manim’s logo with just the icons) to its
+expanded state (showing the full name together with the icons).
+
+See the class documentation for how to use this.
+
+#### NOTE
+Before calling this method, the text “anim” is not a
+submobject of the banner object. After the expansion,
+it is added as a submobject so subsequent animations
+to the banner object apply to the text “anim” as well.
+
+* **Parameters:**
+ * **run_time** (*float*) – The run time of the animation.
+ * **direction** – The direction in which the logo is expanded.
+* **Returns:**
+ An animation to be used in a [`Scene.play()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) call.
+* **Return type:**
+ [`Succession`](manim.animation.composition.Succession.md#manim.animation.composition.Succession)
+
+### Examples
+
+
+
+Will round/truncate the decimal places as per the provided config.
+
+* **Parameters:**
+ * **matrix** (*Iterable*) – A numpy 2d array or list of lists
+ * **element_to_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – Mobject to use, by default DecimalNumber
+ * **element_to_mobject_config** (*dict* *[**str* *,* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – Config for the desired mobject, by default {“num_decimal_places”: 1}
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(matrix, element_to_mobject=, element_to_mobject_config={'num_decimal_places': 1}, \*\*kwargs)
+
+Will round/truncate the decimal places as per the provided config.
+
+* **Parameters:**
+ * **matrix** (*Iterable*) – A numpy 2d array or list of lists
+ * **element_to_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – Mobject to use, by default DecimalNumber
+ * **element_to_mobject_config** (*dict* *[**str* *,* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – Config for the desired mobject, by default {“num_decimal_places”: 1}
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.matrix.IntegerMatrix.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.matrix.IntegerMatrix.md
new file mode 100644
index 0000000000000000000000000000000000000000..c77b90e0f1f1583f986458149ad152830ff1cf44
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.matrix.IntegerMatrix.md
@@ -0,0 +1,66 @@
+# IntegerMatrix
+
+Qualified name: `manim.mobject.matrix.IntegerMatrix`
+
+### *class* IntegerMatrix(matrix, element_to_mobject=, \*\*kwargs)
+
+Bases: [`Matrix`](manim.mobject.matrix.Matrix.md#manim.mobject.matrix.Matrix)
+
+A mobject that displays a matrix with integer entries on the screen.
+
+### Examples
+
+
+
+Will round if there are decimal entries in the matrix.
+
+* **Parameters:**
+ * **matrix** (*Iterable*) – A numpy 2d array or list of lists
+ * **element_to_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – Mobject to use, by default Integer
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(matrix, element_to_mobject=, \*\*kwargs)
+
+Will round if there are decimal entries in the matrix.
+
+* **Parameters:**
+ * **matrix** (*Iterable*) – A numpy 2d array or list of lists
+ * **element_to_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – Mobject to use, by default Integer
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.matrix.Matrix.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.matrix.Matrix.md
new file mode 100644
index 0000000000000000000000000000000000000000..0cbc778d6af9ad1b861f8c1b2ef711fe92e73341
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.matrix.Matrix.md
@@ -0,0 +1,418 @@
+# Matrix
+
+Qualified name: `manim.mobject.matrix.Matrix`
+
+### *class* Matrix(matrix, v_buff=0.8, h_buff=1.3, bracket_h_buff=0.25, bracket_v_buff=0.25, add_background_rectangles_to_entries=False, include_background_rectangle=False, element_to_mobject=, element_to_mobject_config={}, element_alignment_corner=array([ 1., -1., 0.]), left_bracket='[', right_bracket=']', stretch_brackets=True, bracket_config={}, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A mobject that displays a matrix on the screen.
+
+* **Parameters:**
+ * **matrix** (*Iterable*) – A numpy 2d array or list of lists.
+ * **v_buff** (*float*) – Vertical distance between elements, by default 0.8.
+ * **h_buff** (*float*) – Horizontal distance between elements, by default 1.3.
+ * **bracket_h_buff** (*float*) – Distance of the brackets from the matrix, by default `MED_SMALL_BUFF`.
+ * **bracket_v_buff** (*float*) – Height of the brackets, by default `MED_SMALL_BUFF`.
+ * **add_background_rectangles_to_entries** (*bool*) – `True` if should add backgraound rectangles to entries, by default `False`.
+ * **include_background_rectangle** (*bool*) – `True` if should include background rectangle, by default `False`.
+ * **element_to_mobject** (*type* *[*[*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) *]*) – The mobject class used to construct the elements, by default [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex).
+ * **element_to_mobject_config** (*dict*) – Additional arguments to be passed to the constructor in `element_to_mobject`,
+ by default `{}`.
+ * **element_alignment_corner** (*Sequence* *[**float* *]*) – The corner to which elements are aligned, by default `DR`.
+ * **left_bracket** (*str*) – The left bracket type, by default `"["`.
+ * **right_bracket** (*str*) – The right bracket type, by default `"]"`.
+ * **stretch_brackets** (*bool*) – `True` if should stretch the brackets to fit the height of matrix contents, by default `True`.
+ * **bracket_config** (*dict*) – Additional arguments to be passed to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) when constructing
+ the brackets.
+
+### Examples
+
+The first example shows a variety of uses of this module while the second example
+exlpains the use of the options add_background_rectangles_to_entries and
+include_background_rectangle.
+
+
+```python
+from manim import *
+
+class GetBracketsExample(Scene):
+ def construct(self):
+ m0 = Matrix([["\\pi", 3], [1, 5]])
+ bra = m0.get_brackets()
+ colors = [BLUE, GREEN]
+ for k in range(len(colors)):
+ bra[k].set_color(colors[k])
+ self.add(m0)
+```
+
+
+class GetBracketsExample(Scene):
+ def construct(self):
+ m0 = Matrix([["\\\\pi", 3], [1, 5]])
+ bra = m0.get_brackets()
+ colors = [BLUE, GREEN]
+ for k in range(len(colors)):
+ bra[k].set_color(colors[k])
+ self.add(m0)
+
+
+
+#### get_columns()
+
+Return columns of the matrix as VGroups.
+
+* **Returns:**
+ Each VGroup contains a column of the matrix.
+* **Return type:**
+ List[[`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)]
+
+### Examples
+
+
+class GetEntriesExample(Scene):
+ def construct(self):
+ m0 = Matrix([[2, 3], [1, 5]])
+ ent = m0.get_entries()
+ colors = [BLUE, GREEN, YELLOW, RED]
+ for k in range(len(colors)):
+ ent[k].set_color(colors[k])
+ self.add(m0)
+
+
+
+#### get_mob_matrix()
+
+Return the underlying mob matrix mobjects.
+
+* **Returns:**
+ Each VGroup contains a row of the matrix.
+* **Return type:**
+ List[[`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)]
+
+#### get_rows()
+
+Return rows of the matrix as VGroups.
+
+* **Returns:**
+ Each VGroup contains a row of the matrix.
+* **Return type:**
+ List[[`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)]
+
+### Examples
+
+
+
+#### set_column_colors(\*colors)
+
+Set individual colors for each columns of the matrix.
+
+* **Parameters:**
+ **colors** (*str*) – The list of colors; each color specified corresponds to a column.
+* **Returns:**
+ The current matrix object (self).
+* **Return type:**
+ [`Matrix`](#manim.mobject.matrix.Matrix)
+
+### Examples
+
+
+
+#### set_row_colors(\*colors)
+
+Set individual colors for each row of the matrix.
+
+* **Parameters:**
+ **colors** (*str*) – The list of colors; each color specified corresponds to a row.
+* **Returns:**
+ The current matrix object (self).
+* **Return type:**
+ [`Matrix`](#manim.mobject.matrix.Matrix)
+
+### Examples
+
+
+```python
+from manim import *
+
+class MobjectMatrixExample(Scene):
+ def construct(self):
+ a = Circle().scale(0.3)
+ b = Square().scale(0.3)
+ c = MathTex("\\pi").scale(2)
+ d = Star().scale(0.3)
+ m0 = MobjectMatrix([[a, b], [c, d]])
+ self.add(m0)
+```
+
+
+class MobjectMatrixExample(Scene):
+ def construct(self):
+ a = Circle().scale(0.3)
+ b = Square().scale(0.3)
+ c = MathTex("\\\\pi").scale(2)
+ d = Star().scale(0.3)
+ m0 = MobjectMatrix([[a, b], [c, d]])
+ self.add(m0)
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(matrix, element_to_mobject=>, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.matrix.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.matrix.md
new file mode 100644
index 0000000000000000000000000000000000000000..20bdc4479f8fbadac5baceda0d357d18e7698d5f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.matrix.md
@@ -0,0 +1,123 @@
+# matrix
+
+Mobjects representing matrices.
+
+### Examples
+
+
+
+### Classes
+
+| [`DecimalMatrix`](manim.mobject.matrix.DecimalMatrix.md#manim.mobject.matrix.DecimalMatrix) | A mobject that displays a matrix with decimal entries on the screen. |
+|-----------------------------------------------------------------------------------------------|------------------------------------------------------------------------|
+| [`IntegerMatrix`](manim.mobject.matrix.IntegerMatrix.md#manim.mobject.matrix.IntegerMatrix) | A mobject that displays a matrix with integer entries on the screen. |
+| [`Matrix`](manim.mobject.matrix.Matrix.md#manim.mobject.matrix.Matrix) | A mobject that displays a matrix on the screen. |
+| [`MobjectMatrix`](manim.mobject.matrix.MobjectMatrix.md#manim.mobject.matrix.MobjectMatrix) | A mobject that displays a matrix of mobject entries on the screen. |
+
+### Functions
+
+### get_det_text(matrix, determinant=None, background_rect=False, initial_scale_factor=2)
+
+Helper function to create determinant.
+
+* **Parameters:**
+ * **matrix** ([*Matrix*](manim.mobject.matrix.Matrix.md#manim.mobject.matrix.Matrix)) – The matrix whose determinant is to be created
+ * **determinant** (*int* *|* *str* *|* *None*) – The value of the determinant of the matrix
+ * **background_rect** (*bool*) – The background rectangle
+ * **initial_scale_factor** (*float*) – The scale of the text det w.r.t the matrix
+* **Returns:**
+ A VGroup containing the determinant
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+### Examples
+
+
+class DeterminantOfAMatrix(Scene):
+ def construct(self):
+ matrix = Matrix([
+ [2, 0],
+ [-1, 1]
+ ])
+
+ # scaling down the \`det\` string
+ det = get_det_text(matrix,
+ determinant=3,
+ initial_scale_factor=1)
+
+ # must add the matrix
+ self.add(matrix)
+ self.add(det)
+
+
+
+### matrix_to_mobject(matrix)
+
+### matrix_to_tex_string(matrix)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.mobject.Group.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.mobject.Group.md
new file mode 100644
index 0000000000000000000000000000000000000000..c160787e927a5a7138226cbbe307c749f7074b4f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.mobject.Group.md
@@ -0,0 +1,33 @@
+# Group
+
+Qualified name: `manim.mobject.mobject.Group`
+
+### *class* Group(\*mobjects, \*\*kwargs)
+
+Bases: [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+Groups together multiple [`Mobjects`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+
+### Notes
+
+When adding the same mobject more than once, repetitions are ignored.
+Use [`Mobject.copy()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.copy) to create a separate copy which can then
+be added to the group.
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------|
+| `animation_overrides` | |
+| `depth` | The depth of the mobject. |
+| `height` | The height of the mobject. |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*mobjects, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.mobject.Mobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.mobject.Mobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..7e3c231ecc3827f94c95faf7e439f31663d18328
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.mobject.Mobject.md
@@ -0,0 +1,2592 @@
+# Mobject
+
+Qualified name: `manim.mobject.mobject.Mobject`
+
+### *class* Mobject(color=ManimColor('#FFFFFF'), name=None, dim=3, target=None, z_index=0)
+
+Bases: `object`
+
+Mathematical Object: base class for objects that can be displayed on screen.
+
+There is a compatibility layer that allows for
+getting and setting generic attributes with `get_*`
+and `set_*` methods. See [`set()`](#manim.mobject.mobject.Mobject.set) for more details.
+
+* **Parameters:**
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *list* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]*)
+ * **name** (*str* *|* *None*)
+ * **dim** (*int*)
+ * **z_index** (*float*)
+
+#### submobjects
+
+The contained objects.
+
+* **Type:**
+ List[[`Mobject`](#manim.mobject.mobject.Mobject)]
+
+#### points
+
+The points of the objects.
+
+#### SEE ALSO
+[`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+* **Type:**
+ `numpy.ndarray`
+
+### Methods
+
+| [`add`](#manim.mobject.mobject.Mobject.add) | Add mobjects as submobjects. |
+|---------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`add_animation_override`](#manim.mobject.mobject.Mobject.add_animation_override) | Add an animation override. |
+| [`add_background_rectangle`](#manim.mobject.mobject.Mobject.add_background_rectangle) | Add a BackgroundRectangle as submobject. |
+| `add_background_rectangle_to_family_members_with_points` | |
+| `add_background_rectangle_to_submobjects` | |
+| `add_n_more_submobjects` | |
+| [`add_to_back`](#manim.mobject.mobject.Mobject.add_to_back) | Add all passed mobjects to the back of the submobjects. |
+| [`add_updater`](#manim.mobject.mobject.Mobject.add_updater) | Add an update function to this mobject. |
+| [`align_data`](#manim.mobject.mobject.Mobject.align_data) | Aligns the data of this mobject with another mobject. |
+| [`align_on_border`](#manim.mobject.mobject.Mobject.align_on_border) | Direction just needs to be a vector pointing towards side or corner in the 2d plane. |
+| `align_points` | |
+| `align_points_with_larger` | |
+| `align_submobjects` | |
+| [`align_to`](#manim.mobject.mobject.Mobject.align_to) | Aligns mobject to another [`Mobject`](#manim.mobject.mobject.Mobject) in a certain direction. |
+| [`animation_override_for`](#manim.mobject.mobject.Mobject.animation_override_for) | Returns the function defining a specific animation override for this class. |
+| [`apply_complex_function`](#manim.mobject.mobject.Mobject.apply_complex_function) | Applies a complex function to a [`Mobject`](#manim.mobject.mobject.Mobject). |
+| `apply_function` | |
+| `apply_function_to_position` | |
+| `apply_function_to_submobject_positions` | |
+| `apply_matrix` | |
+| `apply_over_attr_arrays` | |
+| `apply_points_function_about_point` | |
+| [`apply_to_family`](#manim.mobject.mobject.Mobject.apply_to_family) | Apply a function to `self` and every submobject with points recursively. |
+| [`arrange`](#manim.mobject.mobject.Mobject.arrange) | Sorts [`Mobject`](#manim.mobject.mobject.Mobject) next to each other on screen. |
+| [`arrange_in_grid`](#manim.mobject.mobject.Mobject.arrange_in_grid) | Arrange submobjects in a grid. |
+| [`arrange_submobjects`](#manim.mobject.mobject.Mobject.arrange_submobjects) | Arrange the position of [`submobjects`](#manim.mobject.mobject.Mobject.submobjects) with a small buffer. |
+| [`become`](#manim.mobject.mobject.Mobject.become) | Edit points, colors and submobjects to be identical to another [`Mobject`](#manim.mobject.mobject.Mobject) |
+| [`center`](#manim.mobject.mobject.Mobject.center) | Moves the center of the mobject to the center of the scene. |
+| [`clear_updaters`](#manim.mobject.mobject.Mobject.clear_updaters) | Remove every updater. |
+| [`copy`](#manim.mobject.mobject.Mobject.copy) | Create and return an identical copy of the [`Mobject`](#manim.mobject.mobject.Mobject) including all [`submobjects`](#manim.mobject.mobject.Mobject.submobjects). |
+| `fade` | |
+| `fade_to` | |
+| `family_members_with_points` | |
+| [`flip`](#manim.mobject.mobject.Mobject.flip) | Flips/Mirrors an mobject about its center. |
+| [`generate_points`](#manim.mobject.mobject.Mobject.generate_points) | Initializes [`points`](#manim.mobject.mobject.Mobject.points) and therefore the shape. |
+| `generate_target` | |
+| [`get_all_points`](#manim.mobject.mobject.Mobject.get_all_points) | Return all points from this mobject and all submobjects. |
+| `get_array_attrs` | |
+| [`get_bottom`](#manim.mobject.mobject.Mobject.get_bottom) | Get bottom Point3Ds of a box bounding the [`Mobject`](#manim.mobject.mobject.Mobject) |
+| `get_boundary_point` | |
+| [`get_center`](#manim.mobject.mobject.Mobject.get_center) | Get center Point3Ds |
+| `get_center_of_mass` | |
+| [`get_color`](#manim.mobject.mobject.Mobject.get_color) | Returns the color of the [`Mobject`](#manim.mobject.mobject.Mobject) |
+| [`get_coord`](#manim.mobject.mobject.Mobject.get_coord) | Meant to generalize `get_x`, `get_y` and `get_z` |
+| [`get_corner`](#manim.mobject.mobject.Mobject.get_corner) | Get corner Point3Ds for certain direction. |
+| [`get_critical_point`](#manim.mobject.mobject.Mobject.get_critical_point) | Picture a box bounding the [`Mobject`](#manim.mobject.mobject.Mobject). |
+| [`get_edge_center`](#manim.mobject.mobject.Mobject.get_edge_center) | Get edge Point3Ds for certain direction. |
+| [`get_end`](#manim.mobject.mobject.Mobject.get_end) | Returns the point, where the stroke that surrounds the [`Mobject`](#manim.mobject.mobject.Mobject) ends. |
+| `get_extremum_along_dim` | |
+| `get_family` | |
+| `get_family_updaters` | |
+| `get_group_class` | |
+| `get_image` | |
+| [`get_left`](#manim.mobject.mobject.Mobject.get_left) | Get left Point3Ds of a box bounding the [`Mobject`](#manim.mobject.mobject.Mobject) |
+| [`get_merged_array`](#manim.mobject.mobject.Mobject.get_merged_array) | Return all of a given attribute from this mobject and all submobjects. |
+| [`get_midpoint`](#manim.mobject.mobject.Mobject.get_midpoint) | Get Point3Ds of the middle of the path that forms the [`Mobject`](#manim.mobject.mobject.Mobject). |
+| [`get_mobject_type_class`](#manim.mobject.mobject.Mobject.get_mobject_type_class) | Return the base class of this mobject type. |
+| [`get_nadir`](#manim.mobject.mobject.Mobject.get_nadir) | Get nadir (opposite the zenith) Point3Ds of a box bounding a 3D [`Mobject`](#manim.mobject.mobject.Mobject). |
+| `get_num_points` | |
+| `get_pieces` | |
+| [`get_point_mobject`](#manim.mobject.mobject.Mobject.get_point_mobject) | The simplest [`Mobject`](#manim.mobject.mobject.Mobject) to be transformed to or from self. |
+| `get_points_defining_boundary` | |
+| [`get_right`](#manim.mobject.mobject.Mobject.get_right) | Get right Point3Ds of a box bounding the [`Mobject`](#manim.mobject.mobject.Mobject) |
+| [`get_start`](#manim.mobject.mobject.Mobject.get_start) | Returns the point, where the stroke that surrounds the [`Mobject`](#manim.mobject.mobject.Mobject) starts. |
+| [`get_start_and_end`](#manim.mobject.mobject.Mobject.get_start_and_end) | Returns starting and ending point of a stroke as a `tuple`. |
+| [`get_time_based_updaters`](#manim.mobject.mobject.Mobject.get_time_based_updaters) | Return all updaters using the `dt` parameter. |
+| [`get_top`](#manim.mobject.mobject.Mobject.get_top) | Get top Point3Ds of a box bounding the [`Mobject`](#manim.mobject.mobject.Mobject) |
+| [`get_updaters`](#manim.mobject.mobject.Mobject.get_updaters) | Return all updaters. |
+| [`get_x`](#manim.mobject.mobject.Mobject.get_x) | Returns x Point3D of the center of the [`Mobject`](#manim.mobject.mobject.Mobject) as `float` |
+| [`get_y`](#manim.mobject.mobject.Mobject.get_y) | Returns y Point3D of the center of the [`Mobject`](#manim.mobject.mobject.Mobject) as `float` |
+| [`get_z`](#manim.mobject.mobject.Mobject.get_z) | Returns z Point3D of the center of the [`Mobject`](#manim.mobject.mobject.Mobject) as `float` |
+| `get_z_index_reference_point` | |
+| [`get_zenith`](#manim.mobject.mobject.Mobject.get_zenith) | Get zenith Point3Ds of a box bounding a 3D [`Mobject`](#manim.mobject.mobject.Mobject). |
+| [`has_no_points`](#manim.mobject.mobject.Mobject.has_no_points) | Check if [`Mobject`](#manim.mobject.mobject.Mobject) *does not* contains points. |
+| [`has_points`](#manim.mobject.mobject.Mobject.has_points) | Check if [`Mobject`](#manim.mobject.mobject.Mobject) contains points. |
+| [`has_time_based_updater`](#manim.mobject.mobject.Mobject.has_time_based_updater) | Test if `self` has a time based updater. |
+| [`init_colors`](#manim.mobject.mobject.Mobject.init_colors) | Initializes the colors. |
+| [`insert`](#manim.mobject.mobject.Mobject.insert) | Inserts a mobject at a specific position into self.submobjects |
+| [`interpolate`](#manim.mobject.mobject.Mobject.interpolate) | Turns this [`Mobject`](#manim.mobject.mobject.Mobject) into an interpolation between `mobject1` and `mobject2`. |
+| `interpolate_color` | |
+| [`invert`](#manim.mobject.mobject.Mobject.invert) | Inverts the list of [`submobjects`](#manim.mobject.mobject.Mobject.submobjects). |
+| `is_off_screen` | |
+| [`length_over_dim`](#manim.mobject.mobject.Mobject.length_over_dim) | Measure the length of an [`Mobject`](#manim.mobject.mobject.Mobject) in a certain direction. |
+| [`match_color`](#manim.mobject.mobject.Mobject.match_color) | Match the color with the color of another [`Mobject`](#manim.mobject.mobject.Mobject). |
+| [`match_coord`](#manim.mobject.mobject.Mobject.match_coord) | Match the Point3Ds with the Point3Ds of another [`Mobject`](#manim.mobject.mobject.Mobject). |
+| [`match_depth`](#manim.mobject.mobject.Mobject.match_depth) | Match the depth with the depth of another [`Mobject`](#manim.mobject.mobject.Mobject). |
+| [`match_dim_size`](#manim.mobject.mobject.Mobject.match_dim_size) | Match the specified dimension with the dimension of another [`Mobject`](#manim.mobject.mobject.Mobject). |
+| [`match_height`](#manim.mobject.mobject.Mobject.match_height) | Match the height with the height of another [`Mobject`](#manim.mobject.mobject.Mobject). |
+| [`match_points`](#manim.mobject.mobject.Mobject.match_points) | Edit points, positions, and submobjects to be identical to another [`Mobject`](#manim.mobject.mobject.Mobject), while keeping the style unchanged. |
+| [`match_updaters`](#manim.mobject.mobject.Mobject.match_updaters) | Match the updaters of the given mobject. |
+| [`match_width`](#manim.mobject.mobject.Mobject.match_width) | Match the width with the width of another [`Mobject`](#manim.mobject.mobject.Mobject). |
+| [`match_x`](#manim.mobject.mobject.Mobject.match_x) | Match x coord. |
+| [`match_y`](#manim.mobject.mobject.Mobject.match_y) | Match y coord. |
+| [`match_z`](#manim.mobject.mobject.Mobject.match_z) | Match z coord. |
+| [`move_to`](#manim.mobject.mobject.Mobject.move_to) | Move center of the [`Mobject`](#manim.mobject.mobject.Mobject) to certain Point3D. |
+| [`next_to`](#manim.mobject.mobject.Mobject.next_to) | Move this [`Mobject`](#manim.mobject.mobject.Mobject) next to another's [`Mobject`](#manim.mobject.mobject.Mobject) or Point3D. |
+| `nonempty_submobjects` | |
+| [`null_point_align`](#manim.mobject.mobject.Mobject.null_point_align) | If a [`Mobject`](#manim.mobject.mobject.Mobject) with points is being aligned to one without, treat both as groups, and push the one with points into its own submobjects list. |
+| `point_from_proportion` | |
+| `pose_at_angle` | |
+| `proportion_from_point` | |
+| `push_self_into_submobjects` | |
+| `put_start_and_end_on` | |
+| [`reduce_across_dimension`](#manim.mobject.mobject.Mobject.reduce_across_dimension) | Find the min or max value from a dimension across all points in this and submobjects. |
+| [`remove`](#manim.mobject.mobject.Mobject.remove) | Remove [`submobjects`](#manim.mobject.mobject.Mobject.submobjects). |
+| [`remove_updater`](#manim.mobject.mobject.Mobject.remove_updater) | Remove an updater. |
+| [`repeat`](#manim.mobject.mobject.Mobject.repeat) | This can make transition animations nicer |
+| `repeat_submobject` | |
+| `replace` | |
+| `rescale_to_fit` | |
+| [`reset_points`](#manim.mobject.mobject.Mobject.reset_points) | Sets [`points`](#manim.mobject.mobject.Mobject.points) to be an empty array. |
+| [`restore`](#manim.mobject.mobject.Mobject.restore) | Restores the state that was previously saved with [`save_state()`](#manim.mobject.mobject.Mobject.save_state). |
+| [`resume_updating`](#manim.mobject.mobject.Mobject.resume_updating) | Enable updating from updaters and animations. |
+| `reverse_points` | |
+| [`rotate`](#manim.mobject.mobject.Mobject.rotate) | Rotates the [`Mobject`](#manim.mobject.mobject.Mobject) about a certain point. |
+| [`rotate_about_origin`](#manim.mobject.mobject.Mobject.rotate_about_origin) | Rotates the [`Mobject`](#manim.mobject.mobject.Mobject) about the ORIGIN, which is at [0,0,0]. |
+| [`save_image`](#manim.mobject.mobject.Mobject.save_image) | Saves an image of only this [`Mobject`](#manim.mobject.mobject.Mobject) at its position to a png file. |
+| [`save_state`](#manim.mobject.mobject.Mobject.save_state) | Save the current state (position, color & size). |
+| [`scale`](#manim.mobject.mobject.Mobject.scale) | Scale the size by a factor. |
+| [`scale_to_fit_depth`](#manim.mobject.mobject.Mobject.scale_to_fit_depth) | Scales the [`Mobject`](#manim.mobject.mobject.Mobject) to fit a depth while keeping width/height proportional. |
+| [`scale_to_fit_height`](#manim.mobject.mobject.Mobject.scale_to_fit_height) | Scales the [`Mobject`](#manim.mobject.mobject.Mobject) to fit a height while keeping width/depth proportional. |
+| [`scale_to_fit_width`](#manim.mobject.mobject.Mobject.scale_to_fit_width) | Scales the [`Mobject`](#manim.mobject.mobject.Mobject) to fit a width while keeping height/depth proportional. |
+| [`set`](#manim.mobject.mobject.Mobject.set) | Sets attributes. |
+| [`set_color`](#manim.mobject.mobject.Mobject.set_color) | Condition is function which takes in one arguments, (x, y, z). |
+| [`set_color_by_gradient`](#manim.mobject.mobject.Mobject.set_color_by_gradient) | |
+| `set_colors_by_radial_gradient` | |
+| `set_coord` | |
+| [`set_default`](#manim.mobject.mobject.Mobject.set_default) | Sets the default values of keyword arguments. |
+| `set_submobject_colors_by_gradient` | |
+| `set_submobject_colors_by_radial_gradient` | |
+| [`set_x`](#manim.mobject.mobject.Mobject.set_x) | Set x value of the center of the [`Mobject`](#manim.mobject.mobject.Mobject) (`int` or `float`) |
+| [`set_y`](#manim.mobject.mobject.Mobject.set_y) | Set y value of the center of the [`Mobject`](#manim.mobject.mobject.Mobject) (`int` or `float`) |
+| [`set_z`](#manim.mobject.mobject.Mobject.set_z) | Set z value of the center of the [`Mobject`](#manim.mobject.mobject.Mobject) (`int` or `float`) |
+| [`set_z_index`](#manim.mobject.mobject.Mobject.set_z_index) | Sets the [`Mobject`](#manim.mobject.mobject.Mobject)'s `z_index` to the value specified in z_index_value. |
+| [`set_z_index_by_z_Point3D`](#manim.mobject.mobject.Mobject.set_z_index_by_z_Point3D) | Sets the [`Mobject`](#manim.mobject.mobject.Mobject)'s z Point3D to the value of `z_index`. |
+| [`shift`](#manim.mobject.mobject.Mobject.shift) | Shift by the given vectors. |
+| `shift_onto_screen` | |
+| `show` | |
+| [`shuffle`](#manim.mobject.mobject.Mobject.shuffle) | Shuffles the list of [`submobjects`](#manim.mobject.mobject.Mobject.submobjects). |
+| [`shuffle_submobjects`](#manim.mobject.mobject.Mobject.shuffle_submobjects) | Shuffles the order of [`submobjects`](#manim.mobject.mobject.Mobject.submobjects) |
+| [`sort`](#manim.mobject.mobject.Mobject.sort) | Sorts the list of [`submobjects`](#manim.mobject.mobject.Mobject.submobjects) by a function defined by `submob_func`. |
+| [`sort_submobjects`](#manim.mobject.mobject.Mobject.sort_submobjects) | Sort the [`submobjects`](#manim.mobject.mobject.Mobject.submobjects) |
+| `space_out_submobjects` | |
+| `split` | |
+| `stretch` | |
+| `stretch_about_point` | |
+| [`stretch_to_fit_depth`](#manim.mobject.mobject.Mobject.stretch_to_fit_depth) | Stretches the [`Mobject`](#manim.mobject.mobject.Mobject) to fit a depth, not keeping width/height proportional. |
+| [`stretch_to_fit_height`](#manim.mobject.mobject.Mobject.stretch_to_fit_height) | Stretches the [`Mobject`](#manim.mobject.mobject.Mobject) to fit a height, not keeping width/depth proportional. |
+| [`stretch_to_fit_width`](#manim.mobject.mobject.Mobject.stretch_to_fit_width) | Stretches the [`Mobject`](#manim.mobject.mobject.Mobject) to fit a width, not keeping height/depth proportional. |
+| `surround` | |
+| [`suspend_updating`](#manim.mobject.mobject.Mobject.suspend_updating) | Disable updating from updaters and animations. |
+| `throw_error_if_no_points` | |
+| [`to_corner`](#manim.mobject.mobject.Mobject.to_corner) | Moves this [`Mobject`](#manim.mobject.mobject.Mobject) to the given corner of the screen. |
+| [`to_edge`](#manim.mobject.mobject.Mobject.to_edge) | Moves this [`Mobject`](#manim.mobject.mobject.Mobject) to the given edge of the screen, without affecting its position in the other dimension. |
+| `to_original_color` | |
+| [`update`](#manim.mobject.mobject.Mobject.update) | Apply all updaters. |
+
+### Attributes
+
+| [`animate`](#manim.mobject.mobject.Mobject.animate) | Used to animate the application of any method of `self`. |
+|-------------------------------------------------------|------------------------------------------------------------|
+| `animation_overrides` | |
+| [`depth`](#manim.mobject.mobject.Mobject.depth) | The depth of the mobject. |
+| [`height`](#manim.mobject.mobject.Mobject.height) | The height of the mobject. |
+| [`width`](#manim.mobject.mobject.Mobject.width) | The width of the mobject. |
+
+#### *classmethod* \_add_intrinsic_animation_overrides()
+
+Initializes animation overrides marked with the [`override_animation()`](manim.animation.animation.md#manim.animation.animation.override_animation)
+decorator.
+
+* **Return type:**
+ None
+
+#### \_assert_valid_submobjects(submobjects)
+
+Check that all submobjects are actually instances of
+[`Mobject`](#manim.mobject.mobject.Mobject), and that none of them is `self` (a
+[`Mobject`](#manim.mobject.mobject.Mobject) cannot contain itself).
+
+This is an auxiliary function called when adding Mobjects to the
+[`submobjects`](#manim.mobject.mobject.Mobject.submobjects) list.
+
+This function is intended to be overridden by subclasses such as
+`VMobject`, which should assert that only other VMobjects
+may be added into it.
+
+* **Parameters:**
+ **submobjects** (*Iterable* *[*[*Mobject*](#manim.mobject.mobject.Mobject) *]*) – The list containing values to validate.
+* **Returns:**
+ The Mobject itself.
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+* **Raises:**
+ * **TypeError** – If any of the values in submobjects is not a [`Mobject`](#manim.mobject.mobject.Mobject).
+ * **ValueError** – If there was an attempt to add a [`Mobject`](#manim.mobject.mobject.Mobject) as its own
+ submobject.
+
+#### add(\*mobjects)
+
+Add mobjects as submobjects.
+
+The mobjects are added to [`submobjects`](#manim.mobject.mobject.Mobject.submobjects).
+
+Subclasses of mobject may implement `+` and `+=` dunder methods.
+
+* **Parameters:**
+ **mobjects** ([*Mobject*](#manim.mobject.mobject.Mobject)) – The mobjects to add.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+* **Raises:**
+ * **ValueError** – When a mobject tries to add itself.
+ * **TypeError** – When trying to add an object that is not an instance of [`Mobject`](#manim.mobject.mobject.Mobject).
+
+### Notes
+
+A mobject cannot contain itself, and it cannot contain a submobject
+more than once. If the parent mobject is displayed, the newly-added
+submobjects will also be displayed (i.e. they are automatically added
+to the parent Scene).
+
+#### SEE ALSO
+[`remove()`](#manim.mobject.mobject.Mobject.remove), [`add_to_back()`](#manim.mobject.mobject.Mobject.add_to_back)
+
+### Examples
+
+```default
+>>> outer = Mobject()
+>>> inner = Mobject()
+>>> outer = outer.add(inner)
+```
+
+Duplicates are not added again:
+
+```default
+>>> outer = outer.add(inner)
+>>> len(outer.submobjects)
+1
+```
+
+Only Mobjects can be added:
+
+```default
+>>> outer.add(3)
+Traceback (most recent call last):
+...
+TypeError: Only values of type Mobject can be added as submobjects of Mobject, but the value 3 (at index 0) is of type int.
+```
+
+Adding an object to itself raises an error:
+
+```default
+>>> outer.add(outer)
+Traceback (most recent call last):
+...
+ValueError: Cannot add Mobject as a submobject of itself (at index 0).
+```
+
+A given mobject cannot be added as a submobject
+twice to some parent:
+
+```default
+>>> parent = Mobject(name="parent")
+>>> child = Mobject(name="child")
+>>> parent.add(child, child)
+[...] WARNING ...
+parent
+>>> parent.submobjects
+[child]
+```
+
+#### *classmethod* add_animation_override(animation_class, override_func)
+
+Add an animation override.
+
+This does not apply to subclasses.
+
+* **Parameters:**
+ * **animation_class** (*type* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – The animation type to be overridden
+ * **override_func** ([*FunctionOverride*](manim.typing.md#manim.typing.FunctionOverride)) – The function returning an animation replacing the default animation. It gets
+ passed the parameters given to the animation constructor.
+* **Raises:**
+ **MultiAnimationOverrideException** – If the overridden animation was already overridden.
+* **Return type:**
+ None
+
+#### add_background_rectangle(color=None, opacity=0.75, \*\*kwargs)
+
+Add a BackgroundRectangle as submobject.
+
+The BackgroundRectangle is added behind other submobjects.
+
+This can be used to increase the mobjects visibility in front of a noisy background.
+
+* **Parameters:**
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The color of the BackgroundRectangle
+ * **opacity** (*float*) – The opacity of the BackgroundRectangle
+ * **kwargs** – Additional keyword arguments passed to the BackgroundRectangle constructor
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### SEE ALSO
+[`add_to_back()`](#manim.mobject.mobject.Mobject.add_to_back), [`BackgroundRectangle`](manim.mobject.geometry.shape_matchers.BackgroundRectangle.md#manim.mobject.geometry.shape_matchers.BackgroundRectangle)
+
+#### add_to_back(\*mobjects)
+
+Add all passed mobjects to the back of the submobjects.
+
+If [`submobjects`](#manim.mobject.mobject.Mobject.submobjects) already contains the given mobjects, they just get moved
+to the back instead.
+
+* **Parameters:**
+ **mobjects** ([*Mobject*](#manim.mobject.mobject.Mobject)) – The mobjects to add.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### NOTE
+Technically, this is done by adding (or moving) the mobjects to
+the head of [`submobjects`](#manim.mobject.mobject.Mobject.submobjects). The head of this list is rendered
+first, which places the corresponding mobjects behind the
+subsequent list members.
+
+* **Raises:**
+ * **ValueError** – When a mobject tries to add itself.
+ * **TypeError** – When trying to add an object that is not an instance of [`Mobject`](#manim.mobject.mobject.Mobject).
+* **Parameters:**
+ **mobjects** ([*Mobject*](#manim.mobject.mobject.Mobject))
+* **Return type:**
+ Self
+
+### Notes
+
+A mobject cannot contain itself, and it cannot contain a submobject
+more than once. If the parent mobject is displayed, the newly-added
+submobjects will also be displayed (i.e. they are automatically added
+to the parent Scene).
+
+#### SEE ALSO
+[`remove()`](#manim.mobject.mobject.Mobject.remove), [`add()`](#manim.mobject.mobject.Mobject.add)
+
+#### add_updater(update_function, index=None, call_updater=False)
+
+Add an update function to this mobject.
+
+Update functions, or updaters in short, are functions that are applied to the
+Mobject in every frame.
+
+* **Parameters:**
+ * **update_function** ([*Updater*](manim.mobject.mobject.md#manim.mobject.mobject.Updater)) – The update function to be added.
+ Whenever [`update()`](#manim.mobject.mobject.Mobject.update) is called, this update function gets called using
+ `self` as the first parameter.
+ The updater can have a second parameter `dt`. If it uses this parameter,
+ it gets called using a second value `dt`, usually representing the time
+ in seconds since the last call of [`update()`](#manim.mobject.mobject.Mobject.update).
+ * **index** (*int* *|* *None*) – The index at which the new updater should be added in `self.updaters`.
+ In case `index` is `None` the updater will be added at the end.
+ * **call_updater** (*bool*) – Whether or not to call the updater initially. If `True`, the updater will
+ be called using `dt=0`.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+### Examples
+
+
+class DtUpdater(Scene):
+ def construct(self):
+ square = Square()
+
+ #Let the square rotate 90° per second
+ square.add_updater(lambda mobject, dt: mobject.rotate(dt\*90\*DEGREES))
+ self.add(square)
+ self.wait(2)
+
+
+
+#### SEE ALSO
+[`get_updaters()`](#manim.mobject.mobject.Mobject.get_updaters), [`remove_updater()`](#manim.mobject.mobject.Mobject.remove_updater), [`UpdateFromFunc`](manim.animation.updaters.update.UpdateFromFunc.md#manim.animation.updaters.update.UpdateFromFunc)
+
+#### align_data(mobject, skip_point_alignment=False)
+
+Aligns the data of this mobject with another mobject.
+
+Afterwards, the two mobjects will have the same number of submobjects
+(see `align_submobjects()`), the same parent structure (see
+[`null_point_align()`](#manim.mobject.mobject.Mobject.null_point_align)). If `skip_point_alignment` is false,
+they will also have the same number of points (see [`align_points()`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject.align_points)).
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](#manim.mobject.mobject.Mobject)) – The other mobject this mobject should be aligned to.
+ * **skip_point_alignment** (*bool*) – Controls whether or not the computationally expensive
+ point alignment is skipped (default: False).
+* **Return type:**
+ None
+
+#### align_on_border(direction, buff=0.5)
+
+Direction just needs to be a vector pointing towards side or
+corner in the 2d plane.
+
+* **Parameters:**
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+ * **buff** (*float*)
+* **Return type:**
+ Self
+
+#### align_to(mobject_or_point, direction=array([0., 0., 0.]))
+
+Aligns mobject to another [`Mobject`](#manim.mobject.mobject.Mobject) in a certain direction.
+
+Examples:
+mob1.align_to(mob2, UP) moves mob1 vertically so that its
+top edge lines ups with mob2’s top edge.
+
+* **Parameters:**
+ * **mobject_or_point** ([*Mobject*](#manim.mobject.mobject.Mobject) *|* [*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ Self
+
+#### *property* animate *: \_AnimationBuilder | Self*
+
+Used to animate the application of any method of `self`.
+
+Any method called on `animate` is converted to an animation of applying
+that method on the mobject itself.
+
+For example, `square.set_fill(WHITE)` sets the fill color of a square,
+while `square.animate.set_fill(WHITE)` animates this action.
+
+Multiple methods can be put in a single animation once via chaining:
+
+```default
+self.play(my_mobject.animate.shift(RIGHT).rotate(PI))
+```
+
+#### WARNING
+Passing multiple animations for the same [`Mobject`](#manim.mobject.mobject.Mobject) in one
+call to [`play()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) is discouraged and will most likely
+not work properly. Instead of writing an animation like
+
+```default
+self.play(
+ my_mobject.animate.shift(RIGHT), my_mobject.animate.rotate(PI)
+)
+```
+
+make use of method chaining.
+
+Keyword arguments that can be passed to [`Scene.play()`](manim.scene.scene.Scene.md#manim.scene.scene.Scene.play) can be passed
+directly after accessing `.animate`, like so:
+
+```default
+self.play(my_mobject.animate(rate_func=linear).shift(RIGHT))
+```
+
+This is especially useful when animating simultaneous `.animate` calls that
+you want to behave differently:
+
+```default
+self.play(
+ mobject1.animate(run_time=2).rotate(PI),
+ mobject2.animate(rate_func=there_and_back).shift(RIGHT),
+)
+```
+
+#### SEE ALSO
+[`override_animate()`](manim.mobject.mobject.md#manim.mobject.mobject.override_animate)
+
+### Examples
+
+
+
+#### WARNING
+`.animate`
+: will interpolate the [`Mobject`](#manim.mobject.mobject.Mobject) between its points prior to
+ `.animate` and its points after applying `.animate` to it. This may
+ result in unexpected behavior when attempting to interpolate along paths,
+ or rotations.
+ If you want animations to consider the points between, consider using
+ [`ValueTracker`](manim.mobject.value_tracker.ValueTracker.md#manim.mobject.value_tracker.ValueTracker) with updaters instead.
+
+#### *classmethod* animation_override_for(animation_class)
+
+Returns the function defining a specific animation override for this class.
+
+* **Parameters:**
+ **animation_class** (*type* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – The animation class for which the override function should be returned.
+* **Returns:**
+ The function returning the override animation or `None` if no such animation
+ override is defined.
+* **Return type:**
+ Optional[Callable[[[Mobject](#manim.mobject.mobject.Mobject), …], [Animation](manim.animation.animation.Animation.md#manim.animation.animation.Animation)]]
+
+#### apply_complex_function(function, \*\*kwargs)
+
+Applies a complex function to a [`Mobject`](#manim.mobject.mobject.Mobject).
+The x and y Point3Ds correspond to the real and imaginary parts respectively.
+
+### Example
+
+
+* **Parameters:**
+ **function** (*Callable* *[* *[**complex* *]* *,* *complex* *]*)
+* **Return type:**
+ Self
+
+#### apply_to_family(func)
+
+Apply a function to `self` and every submobject with points recursively.
+
+* **Parameters:**
+ **func** (*Callable* *[* *[*[*Mobject*](#manim.mobject.mobject.Mobject) *]* *,* *None* *]*) – The function to apply to each mobject. `func` gets passed the respective
+ (sub)mobject as parameter.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### SEE ALSO
+`family_members_with_points()`
+
+#### arrange(direction=array([1., 0., 0.]), buff=0.25, center=True, \*\*kwargs)
+
+Sorts [`Mobject`](#manim.mobject.mobject.Mobject) next to each other on screen.
+
+### Examples
+
+
+* **Parameters:**
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+ * **buff** (*float*)
+ * **center** (*bool*)
+* **Return type:**
+ Self
+
+#### arrange_in_grid(rows=None, cols=None, buff=0.25, cell_alignment=array([0., 0., 0.]), row_alignments=None, col_alignments=None, row_heights=None, col_widths=None, flow_order='rd', \*\*kwargs)
+
+Arrange submobjects in a grid.
+
+* **Parameters:**
+ * **rows** (*int* *|* *None*) – The number of rows in the grid.
+ * **cols** (*int* *|* *None*) – The number of columns in the grid.
+ * **buff** (*float* *|* *tuple* *[**float* *,* *float* *]*) – The gap between grid cells. To specify a different buffer in the horizontal and
+ vertical directions, a tuple of two values can be given - `(row, col)`.
+ * **cell_alignment** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D)) – The way each submobject is aligned in its grid cell.
+ * **row_alignments** (*str* *|* *None*) – The vertical alignment for each row (top to bottom). Accepts the following characters: `"u"` -
+ up, `"c"` - center, `"d"` - down.
+ * **col_alignments** (*str* *|* *None*) – The horizontal alignment for each column (left to right). Accepts the following characters `"l"` - left,
+ `"c"` - center, `"r"` - right.
+ * **row_heights** (*Iterable* *[**float* *|* *None* *]* *|* *None*) – Defines a list of heights for certain rows (top to bottom). If the list contains
+ `None`, the corresponding row will fit its height automatically based
+ on the highest element in that row.
+ * **col_widths** (*Iterable* *[**float* *|* *None* *]* *|* *None*) – Defines a list of widths for certain columns (left to right). If the list contains `None`, the
+ corresponding column will fit its width automatically based on the widest element in that column.
+ * **flow_order** (*str*) – The order in which submobjects fill the grid. Can be one of the following values:
+ “rd”, “dr”, “ld”, “dl”, “ru”, “ur”, “lu”, “ul”. (“rd” -> fill rightwards then downwards)
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+* **Raises:**
+ * **ValueError** – If `rows` and `cols` are too small to fit all submobjects.
+ * **ValueError** – If `cols`, `col_alignments` and `col_widths` or `rows`,
+ `row_alignments` and `row_heights` have mismatching sizes.
+
+### Notes
+
+If only one of `cols` and `rows` is set implicitly, the other one will be chosen big
+enough to fit all submobjects. If neither is set, they will be chosen to be about the same,
+tending towards `cols` > `rows` (simply because videos are wider than they are high).
+
+If both `cell_alignment` and `row_alignments` / `col_alignments` are
+defined, the latter has higher priority.
+
+### Examples
+
+
+
+#### arrange_submobjects(\*args, \*\*kwargs)
+
+Arrange the position of [`submobjects`](#manim.mobject.mobject.Mobject.submobjects) with a small buffer.
+
+### Examples
+
+
+class ArrangeSumobjectsExample(Scene):
+ def construct(self):
+ s= VGroup(\*[Dot().shift(i\*0.1\*RIGHT\*np.random.uniform(-1,1)+UP\*np.random.uniform(-1,1)) for i in range(0,15)])
+ s.shift(UP).set_color(BLUE)
+ s2= s.copy().set_color(RED)
+ s2.arrange_submobjects()
+ s2.shift(DOWN)
+ self.add(s,s2)
+
+
+* **Return type:**
+ Self
+
+#### become(mobject, match_height=False, match_width=False, match_depth=False, match_center=False, stretch=False)
+
+Edit points, colors and submobjects to be identical
+to another [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### NOTE
+If both match_height and match_width are `True` then the transformed [`Mobject`](#manim.mobject.mobject.Mobject)
+will match the height first and then the width.
+
+* **Parameters:**
+ * **match_height** (*bool*) – Whether or not to preserve the height of the original
+ [`Mobject`](#manim.mobject.mobject.Mobject).
+ * **match_width** (*bool*) – Whether or not to preserve the width of the original
+ [`Mobject`](#manim.mobject.mobject.Mobject).
+ * **match_depth** (*bool*) – Whether or not to preserve the depth of the original
+ [`Mobject`](#manim.mobject.mobject.Mobject).
+ * **match_center** (*bool*) – Whether or not to preserve the center of the original
+ [`Mobject`](#manim.mobject.mobject.Mobject).
+ * **stretch** (*bool*) – Whether or not to stretch the target mobject to match the
+ the proportions of the original [`Mobject`](#manim.mobject.mobject.Mobject).
+ * **mobject** ([*Mobject*](#manim.mobject.mobject.Mobject))
+* **Return type:**
+ Self
+
+### Examples
+
+
+
+The following examples illustrate how mobject measurements
+change when using the `match_...` and `stretch` arguments.
+We start with a rectangle that is 2 units high and 4 units wide,
+which we want to turn into a circle of radius 3:
+
+```default
+>>> from manim import Rectangle, Circle
+>>> import numpy as np
+>>> rect = Rectangle(height=2, width=4)
+>>> circ = Circle(radius=3)
+```
+
+With `stretch=True`, the target circle is deformed to match
+the proportions of the rectangle, which results in the target
+mobject being an ellipse with height 2 and width 4. We can
+check that the resulting points satisfy the ellipse equation
+$x^2/a^2 + y^2/b^2 = 1$ with $a = 4/2$ and $b = 2/2$
+being the semi-axes:
+
+```default
+>>> result = rect.copy().become(circ, stretch=True)
+>>> result.height, result.width
+(np.float64(2.0), np.float64(4.0))
+>>> ellipse_points = np.array(result.get_anchors())
+>>> ellipse_eq = np.sum(ellipse_points**2 * [1/4, 1, 0], axis=1)
+>>> np.allclose(ellipse_eq, 1)
+True
+```
+
+With `match_height=True` and `match_width=True` the circle is
+scaled such that the height or the width of the rectangle will
+be preserved, respectively.
+The points of the resulting mobject satisfy the circle equation
+$x^2 + y^2 = r^2$ for the corresponding radius $r$:
+
+```default
+>>> result = rect.copy().become(circ, match_height=True)
+>>> result.height, result.width
+(np.float64(2.0), np.float64(2.0))
+>>> circle_points = np.array(result.get_anchors())
+>>> circle_eq = np.sum(circle_points**2, axis=1)
+>>> np.allclose(circle_eq, 1)
+True
+>>> result = rect.copy().become(circ, match_width=True)
+>>> result.height, result.width
+(np.float64(4.0), np.float64(4.0))
+>>> circle_points = np.array(result.get_anchors())
+>>> circle_eq = np.sum(circle_points**2, axis=1)
+>>> np.allclose(circle_eq, 2**2)
+True
+```
+
+With `match_center=True`, the resulting mobject is moved such that
+its center is the same as the center of the original mobject:
+
+```default
+>>> rect = rect.shift(np.array([0, 1, 0]))
+>>> np.allclose(rect.get_center(), circ.get_center())
+False
+>>> result = rect.copy().become(circ, match_center=True)
+>>> np.allclose(rect.get_center(), result.get_center())
+True
+```
+
+#### center()
+
+Moves the center of the mobject to the center of the scene.
+
+* **Returns:**
+ The centered mobject.
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### clear_updaters(recursive=True)
+
+Remove every updater.
+
+* **Parameters:**
+ **recursive** (*bool*) – Whether to recursively call `clear_updaters` on all submobjects.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### SEE ALSO
+[`remove_updater()`](#manim.mobject.mobject.Mobject.remove_updater), [`add_updater()`](#manim.mobject.mobject.Mobject.add_updater), [`get_updaters()`](#manim.mobject.mobject.Mobject.get_updaters)
+
+#### copy()
+
+Create and return an identical copy of the [`Mobject`](#manim.mobject.mobject.Mobject) including all
+[`submobjects`](#manim.mobject.mobject.Mobject.submobjects).
+
+* **Returns:**
+ The copy.
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### NOTE
+The clone is initially not visible in the Scene, even if the original was.
+
+#### *property* depth *: float*
+
+The depth of the mobject.
+
+* **Return type:**
+ `float`
+
+#### SEE ALSO
+[`length_over_dim()`](#manim.mobject.mobject.Mobject.length_over_dim)
+
+#### flip(axis=array([0., 1., 0.]), \*\*kwargs)
+
+Flips/Mirrors an mobject about its center.
+
+### Examples
+
+
+* **Parameters:**
+ **axis** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ Self
+
+#### generate_points()
+
+Initializes [`points`](#manim.mobject.mobject.Mobject.points) and therefore the shape.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
+
+* **Return type:**
+ object
+
+#### get_all_points()
+
+Return all points from this mobject and all submobjects.
+
+May contain duplicates; the order is in a depth-first (pre-order)
+traversal of the submobjects.
+
+* **Return type:**
+ [*Point3D_Array*](manim.typing.md#manim.typing.Point3D_Array)
+
+#### get_bottom()
+
+Get bottom Point3Ds of a box bounding the [`Mobject`](#manim.mobject.mobject.Mobject)
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_center()
+
+Get center Point3Ds
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_color()
+
+Returns the color of the [`Mobject`](#manim.mobject.mobject.Mobject)
+
+### Examples
+
+```default
+>>> from manim import Square, RED
+>>> Square(color=RED).get_color() == RED
+True
+```
+
+* **Return type:**
+ [*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+
+#### get_coord(dim, direction=array([0., 0., 0.]))
+
+Meant to generalize `get_x`, `get_y` and `get_z`
+
+* **Parameters:**
+ * **dim** (*int*)
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+
+#### get_corner(direction)
+
+Get corner Point3Ds for certain direction.
+
+* **Parameters:**
+ **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_critical_point(direction)
+
+Picture a box bounding the [`Mobject`](#manim.mobject.mobject.Mobject). Such a box has
+9 ‘critical points’: 4 corners, 4 edge center, the
+center. This returns one of them, along the given direction.
+
+```default
+sample = Arc(start_angle=PI / 7, angle=PI / 5)
+
+# These are all equivalent
+max_y_1 = sample.get_top()[1]
+max_y_2 = sample.get_critical_point(UP)[1]
+max_y_3 = sample.get_extremum_along_dim(dim=1, key=1)
+```
+
+* **Parameters:**
+ **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_edge_center(direction)
+
+Get edge Point3Ds for certain direction.
+
+* **Parameters:**
+ **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_end()
+
+Returns the point, where the stroke that surrounds the [`Mobject`](#manim.mobject.mobject.Mobject) ends.
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_left()
+
+Get left Point3Ds of a box bounding the [`Mobject`](#manim.mobject.mobject.Mobject)
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_merged_array(array_attr)
+
+Return all of a given attribute from this mobject and all submobjects.
+
+May contain duplicates; the order is in a depth-first (pre-order)
+traversal of the submobjects.
+
+* **Parameters:**
+ **array_attr** (*str*)
+* **Return type:**
+ *ndarray*
+
+#### get_midpoint()
+
+Get Point3Ds of the middle of the path that forms the [`Mobject`](#manim.mobject.mobject.Mobject).
+
+### Examples
+
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### *static* get_mobject_type_class()
+
+Return the base class of this mobject type.
+
+* **Return type:**
+ type[[*Mobject*](#manim.mobject.mobject.Mobject)]
+
+#### get_nadir()
+
+Get nadir (opposite the zenith) Point3Ds of a box bounding a 3D [`Mobject`](#manim.mobject.mobject.Mobject).
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_point_mobject(center=None)
+
+The simplest [`Mobject`](#manim.mobject.mobject.Mobject) to be transformed to or from self.
+Should by a point of the appropriate type
+
+#### get_right()
+
+Get right Point3Ds of a box bounding the [`Mobject`](#manim.mobject.mobject.Mobject)
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_start()
+
+Returns the point, where the stroke that surrounds the [`Mobject`](#manim.mobject.mobject.Mobject) starts.
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_start_and_end()
+
+Returns starting and ending point of a stroke as a `tuple`.
+
+* **Return type:**
+ tuple[[*Point3D*](manim.typing.md#manim.typing.Point3D), [*Point3D*](manim.typing.md#manim.typing.Point3D)]
+
+#### get_time_based_updaters()
+
+Return all updaters using the `dt` parameter.
+
+The updaters use this parameter as the input for difference in time.
+
+* **Returns:**
+ The list of time based updaters.
+* **Return type:**
+ List[`Callable`]
+
+#### SEE ALSO
+[`get_updaters()`](#manim.mobject.mobject.Mobject.get_updaters), [`has_time_based_updater()`](#manim.mobject.mobject.Mobject.has_time_based_updater)
+
+#### get_top()
+
+Get top Point3Ds of a box bounding the [`Mobject`](#manim.mobject.mobject.Mobject)
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### get_updaters()
+
+Return all updaters.
+
+* **Returns:**
+ The list of updaters.
+* **Return type:**
+ List[`Callable`]
+
+#### SEE ALSO
+[`add_updater()`](#manim.mobject.mobject.Mobject.add_updater), [`get_time_based_updaters()`](#manim.mobject.mobject.Mobject.get_time_based_updaters)
+
+#### get_x(direction=array([0., 0., 0.]))
+
+Returns x Point3D of the center of the [`Mobject`](#manim.mobject.mobject.Mobject) as `float`
+
+* **Parameters:**
+ **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ float
+
+#### get_y(direction=array([0., 0., 0.]))
+
+Returns y Point3D of the center of the [`Mobject`](#manim.mobject.mobject.Mobject) as `float`
+
+* **Parameters:**
+ **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ float
+
+#### get_z(direction=array([0., 0., 0.]))
+
+Returns z Point3D of the center of the [`Mobject`](#manim.mobject.mobject.Mobject) as `float`
+
+* **Parameters:**
+ **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ float
+
+#### get_zenith()
+
+Get zenith Point3Ds of a box bounding a 3D [`Mobject`](#manim.mobject.mobject.Mobject).
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+#### has_no_points()
+
+Check if [`Mobject`](#manim.mobject.mobject.Mobject) *does not* contains points.
+
+* **Return type:**
+ bool
+
+#### has_points()
+
+Check if [`Mobject`](#manim.mobject.mobject.Mobject) contains points.
+
+* **Return type:**
+ bool
+
+#### has_time_based_updater()
+
+Test if `self` has a time based updater.
+
+* **Returns:**
+ `True` if at least one updater uses the `dt` parameter, `False`
+ otherwise.
+* **Return type:**
+ `bool`
+
+#### SEE ALSO
+[`get_time_based_updaters()`](#manim.mobject.mobject.Mobject.get_time_based_updaters)
+
+#### *property* height *: float*
+
+The height of the mobject.
+
+* **Return type:**
+ `float`
+
+### Examples
+
+
+
+#### SEE ALSO
+[`length_over_dim()`](#manim.mobject.mobject.Mobject.length_over_dim)
+
+#### init_colors()
+
+Initializes the colors.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
+
+* **Return type:**
+ object
+
+#### insert(index, mobject)
+
+Inserts a mobject at a specific position into self.submobjects
+
+Effectively just calls `self.submobjects.insert(index, mobject)`,
+where `self.submobjects` is a list.
+
+Highly adapted from `Mobject.add`.
+
+* **Parameters:**
+ * **index** (*int*) – The index at which
+ * **mobject** ([*Mobject*](#manim.mobject.mobject.Mobject)) – The mobject to be inserted.
+* **Return type:**
+ None
+
+#### interpolate(mobject1, mobject2, alpha, path_func=)
+
+Turns this [`Mobject`](#manim.mobject.mobject.Mobject) into an interpolation between `mobject1`
+and `mobject2`.
+
+### Examples
+
+
+```python
+from manim import *
+
+class InvertSumobjectsExample(Scene):
+ def construct(self):
+ s = VGroup(*[Dot().shift(i*0.1*RIGHT) for i in range(-20,20)])
+ s2 = s.copy()
+ s2.invert()
+ s2.shift(DOWN)
+ self.play(Write(s), Write(s2))
+```
+
+
+class InvertSumobjectsExample(Scene):
+ def construct(self):
+ s = VGroup(\*[Dot().shift(i\*0.1\*RIGHT) for i in range(-20,20)])
+ s2 = s.copy()
+ s2.invert()
+ s2.shift(DOWN)
+ self.play(Write(s), Write(s2))
+
+
+
+#### length_over_dim(dim)
+
+Measure the length of an [`Mobject`](#manim.mobject.mobject.Mobject) in a certain direction.
+
+* **Parameters:**
+ **dim** (*int*)
+* **Return type:**
+ float
+
+#### match_color(mobject)
+
+Match the color with the color of another [`Mobject`](#manim.mobject.mobject.Mobject).
+
+* **Parameters:**
+ **mobject** ([*Mobject*](#manim.mobject.mobject.Mobject))
+* **Return type:**
+ Self
+
+#### match_coord(mobject, dim, direction=array([0., 0., 0.]))
+
+Match the Point3Ds with the Point3Ds of another [`Mobject`](#manim.mobject.mobject.Mobject).
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](#manim.mobject.mobject.Mobject))
+ * **dim** (*int*)
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ Self
+
+#### match_depth(mobject, \*\*kwargs)
+
+Match the depth with the depth of another [`Mobject`](#manim.mobject.mobject.Mobject).
+
+* **Parameters:**
+ **mobject** ([*Mobject*](#manim.mobject.mobject.Mobject))
+* **Return type:**
+ Self
+
+#### match_dim_size(mobject, dim, \*\*kwargs)
+
+Match the specified dimension with the dimension of another [`Mobject`](#manim.mobject.mobject.Mobject).
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](#manim.mobject.mobject.Mobject))
+ * **dim** (*int*)
+* **Return type:**
+ Self
+
+#### match_height(mobject, \*\*kwargs)
+
+Match the height with the height of another [`Mobject`](#manim.mobject.mobject.Mobject).
+
+* **Parameters:**
+ **mobject** ([*Mobject*](#manim.mobject.mobject.Mobject))
+* **Return type:**
+ Self
+
+#### match_points(mobject, copy_submobjects=True)
+
+Edit points, positions, and submobjects to be identical
+to another [`Mobject`](#manim.mobject.mobject.Mobject), while keeping the style unchanged.
+
+### Examples
+
+
+class GeometricShapes(Scene):
+ def construct(self):
+ d = Dot()
+ c = Circle()
+ s = Square()
+ t = Triangle()
+ d.next_to(c, RIGHT)
+ s.next_to(c, LEFT)
+ t.next_to(c, DOWN)
+ self.add(d, c, s, t)
+
+
+* **Parameters:**
+ * **mobject_or_point** ([*Mobject*](#manim.mobject.mobject.Mobject) *|* [*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+ * **buff** (*float*)
+ * **aligned_edge** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+ * **submobject_to_align** ([*Mobject*](#manim.mobject.mobject.Mobject) *|* *None*)
+ * **index_of_submobject_to_align** (*int* *|* *None*)
+ * **coor_mask** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ Self
+
+#### null_point_align(mobject)
+
+If a [`Mobject`](#manim.mobject.mobject.Mobject) with points is being aligned to
+one without, treat both as groups, and push
+the one with points into its own submobjects
+list.
+
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+* **Parameters:**
+ **mobject** ([*Mobject*](#manim.mobject.mobject.Mobject))
+
+#### reduce_across_dimension(reduce_func, dim)
+
+Find the min or max value from a dimension across all points in this and submobjects.
+
+* **Parameters:**
+ * **reduce_func** (*Callable*)
+ * **dim** (*int*)
+
+#### remove(\*mobjects)
+
+Remove [`submobjects`](#manim.mobject.mobject.Mobject.submobjects).
+
+The mobjects are removed from [`submobjects`](#manim.mobject.mobject.Mobject.submobjects), if they exist.
+
+Subclasses of mobject may implement `-` and `-=` dunder methods.
+
+* **Parameters:**
+ **mobjects** ([*Mobject*](#manim.mobject.mobject.Mobject)) – The mobjects to remove.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### SEE ALSO
+[`add()`](#manim.mobject.mobject.Mobject.add)
+
+#### remove_updater(update_function)
+
+Remove an updater.
+
+If the same updater is applied multiple times, every instance gets removed.
+
+* **Parameters:**
+ **update_function** ([*Updater*](manim.mobject.mobject.md#manim.mobject.mobject.Updater)) – The update function to be removed.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### SEE ALSO
+[`clear_updaters()`](#manim.mobject.mobject.Mobject.clear_updaters), [`add_updater()`](#manim.mobject.mobject.Mobject.add_updater), [`get_updaters()`](#manim.mobject.mobject.Mobject.get_updaters)
+
+#### repeat(count)
+
+This can make transition animations nicer
+
+* **Parameters:**
+ **count** (*int*)
+* **Return type:**
+ Self
+
+#### reset_points()
+
+Sets [`points`](#manim.mobject.mobject.Mobject.points) to be an empty array.
+
+* **Return type:**
+ None
+
+#### restore()
+
+Restores the state that was previously saved with [`save_state()`](#manim.mobject.mobject.Mobject.save_state).
+
+* **Return type:**
+ Self
+
+#### resume_updating(recursive=True)
+
+Enable updating from updaters and animations.
+
+* **Parameters:**
+ **recursive** (*bool*) – Whether to recursively enable updating on all submobjects.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### SEE ALSO
+[`suspend_updating()`](#manim.mobject.mobject.Mobject.suspend_updating), [`add_updater()`](#manim.mobject.mobject.Mobject.add_updater)
+
+#### rotate(angle, axis=array([0., 0., 1.]), about_point=None, \*\*kwargs)
+
+Rotates the [`Mobject`](#manim.mobject.mobject.Mobject) about a certain point.
+
+* **Parameters:**
+ * **angle** (*float*)
+ * **axis** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+ * **about_point** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* *None*)
+* **Return type:**
+ Self
+
+#### rotate_about_origin(angle, axis=array([0., 0., 1.]), axes=[])
+
+Rotates the [`Mobject`](#manim.mobject.mobject.Mobject) about the ORIGIN, which is at [0,0,0].
+
+* **Parameters:**
+ * **angle** (*float*)
+ * **axis** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ Self
+
+#### save_image(name=None)
+
+Saves an image of only this [`Mobject`](#manim.mobject.mobject.Mobject) at its position to a png
+file.
+
+* **Parameters:**
+ **name** (*str* *|* *None*)
+* **Return type:**
+ None
+
+#### save_state()
+
+Save the current state (position, color & size). Can be restored with [`restore()`](#manim.mobject.mobject.Mobject.restore).
+
+* **Return type:**
+ Self
+
+#### scale(scale_factor, \*\*kwargs)
+
+Scale the size by a factor.
+
+Default behavior is to scale about the center of the mobject.
+
+* **Parameters:**
+ * **scale_factor** (*float*) – The scaling factor $\alpha$. If $0 < |\alpha| < 1$, the mobject
+ will shrink, and for $|\alpha| > 1$ it will grow. Furthermore,
+ if $\alpha < 0$, the mobject is also flipped.
+ * **kwargs** – Additional keyword arguments passed to
+ `apply_points_function_about_point()`.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+### Examples
+
+
+
+#### SEE ALSO
+[`move_to()`](#manim.mobject.mobject.Mobject.move_to)
+
+#### scale_to_fit_depth(depth, \*\*kwargs)
+
+Scales the [`Mobject`](#manim.mobject.mobject.Mobject) to fit a depth while keeping width/height proportional.
+
+* **Parameters:**
+ **depth** (*float*)
+* **Return type:**
+ Self
+
+#### scale_to_fit_height(height, \*\*kwargs)
+
+Scales the [`Mobject`](#manim.mobject.mobject.Mobject) to fit a height while keeping width/depth proportional.
+
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+* **Parameters:**
+ **height** (*float*)
+
+### Examples
+
+```default
+>>> from manim import *
+>>> sq = Square()
+>>> sq.width
+np.float64(2.0)
+>>> sq.scale_to_fit_height(5)
+Square
+>>> sq.height
+np.float64(5.0)
+>>> sq.width
+np.float64(5.0)
+```
+
+#### scale_to_fit_width(width, \*\*kwargs)
+
+Scales the [`Mobject`](#manim.mobject.mobject.Mobject) to fit a width while keeping height/depth proportional.
+
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+* **Parameters:**
+ **width** (*float*)
+
+### Examples
+
+```default
+>>> from manim import *
+>>> sq = Square()
+>>> sq.height
+np.float64(2.0)
+>>> sq.scale_to_fit_width(5)
+Square
+>>> sq.width
+np.float64(5.0)
+>>> sq.height
+np.float64(5.0)
+```
+
+#### set(\*\*kwargs)
+
+Sets attributes.
+
+I.e. `my_mobject.set(foo=1)` applies `my_mobject.foo = 1`.
+
+This is a convenience to be used along with [`animate`](#manim.mobject.mobject.Mobject.animate) to
+animate setting attributes.
+
+In addition to this method, there is a compatibility
+layer that allows `get_*` and `set_*` methods to
+get and set generic attributes. For instance:
+
+```default
+>>> mob = Mobject()
+>>> mob.set_foo(0)
+Mobject
+>>> mob.get_foo()
+0
+>>> mob.foo
+0
+```
+
+This compatibility layer does not interfere with any
+`get_*` or `set_*` methods that are explicitly
+defined.
+
+#### WARNING
+This compatibility layer is for backwards compatibility
+and is not guaranteed to stay around. Where applicable,
+please prefer getting/setting attributes normally or with
+the [`set()`](#manim.mobject.mobject.Mobject.set) method.
+
+* **Parameters:**
+ **\*\*kwargs** – The attributes and corresponding values to set.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+### Examples
+
+```default
+>>> mob = Mobject()
+>>> mob.set(foo=0)
+Mobject
+>>> mob.foo
+0
+```
+
+#### set_color(color=ManimColor('#FFFF00'), family=True)
+
+Condition is function which takes in one arguments, (x, y, z).
+Here it just recurses to submobjects, but in subclasses this
+should be further implemented based on the the inner workings
+of color
+
+* **Parameters:**
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **family** (*bool*)
+* **Return type:**
+ Self
+
+#### set_color_by_gradient(\*colors)
+
+* **Parameters:**
+ * **colors** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The colors to use for the gradient. Use like set_color_by_gradient(RED, BLUE, GREEN).
+ * **ManimColor.parse****(****color****)** (*self.color =*)
+ * **self** (*return*)
+* **Return type:**
+ Self
+
+#### *classmethod* set_default(\*\*kwargs)
+
+Sets the default values of keyword arguments.
+
+If this method is called without any additional keyword
+arguments, the original default values of the initialization
+method of this class are restored.
+
+* **Parameters:**
+ **kwargs** – Passing any keyword argument will update the default
+ values of the keyword arguments of the initialization
+ function of this class.
+* **Return type:**
+ None
+
+### Examples
+
+```default
+>>> from manim import Square, GREEN
+>>> Square.set_default(color=GREEN, fill_opacity=0.25)
+>>> s = Square(); s.color, s.fill_opacity
+(ManimColor('#83C167'), 0.25)
+>>> Square.set_default()
+>>> s = Square(); s.color, s.fill_opacity
+(ManimColor('#FFFFFF'), 0.0)
+```
+
+
+```python
+from manim import *
+
+config.background_color = WHITE
+
+class ChangedDefaultTextcolor(Scene):
+ def construct(self):
+ Text.set_default(color=BLACK)
+ self.add(Text("Changing default values is easy!"))
+
+ # we revert the colour back to the default to prevent a bug in the docs.
+ Text.set_default(color=WHITE)
+```
+
+
+config.background_color = WHITE
+
+class ChangedDefaultTextcolor(Scene):
+ def construct(self):
+ Text.set_default(color=BLACK)
+ self.add(Text("Changing default values is easy!"))
+
+ # we revert the colour back to the default to prevent a bug in the docs.
+ Text.set_default(color=WHITE)
+
+
+
+#### set_x(x, direction=array([0., 0., 0.]))
+
+Set x value of the center of the [`Mobject`](#manim.mobject.mobject.Mobject) (`int` or `float`)
+
+* **Parameters:**
+ * **x** (*float*)
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ Self
+
+#### set_y(y, direction=array([0., 0., 0.]))
+
+Set y value of the center of the [`Mobject`](#manim.mobject.mobject.Mobject) (`int` or `float`)
+
+* **Parameters:**
+ * **y** (*float*)
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ Self
+
+#### set_z(z, direction=array([0., 0., 0.]))
+
+Set z value of the center of the [`Mobject`](#manim.mobject.mobject.Mobject) (`int` or `float`)
+
+* **Parameters:**
+ * **z** (*float*)
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+* **Return type:**
+ Self
+
+#### set_z_index(z_index_value, family=True)
+
+Sets the [`Mobject`](#manim.mobject.mobject.Mobject)’s `z_index` to the value specified in z_index_value.
+
+* **Parameters:**
+ * **z_index_value** (*float*) – The new value of `z_index` set.
+ * **family** (*bool*) – If `True`, the `z_index` value of all submobjects is also set.
+* **Returns:**
+ The Mobject itself, after `z_index` is set. For chaining purposes. (Returns self.)
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+### Examples
+
+
+```python
+from manim import *
+
+class SetZIndex(Scene):
+ def construct(self):
+ text = Text('z_index = 3', color = PURE_RED).shift(UP).set_z_index(3)
+ square = Square(2, fill_opacity=1).set_z_index(2)
+ tex = Tex(r'zIndex = 1', color = PURE_BLUE).shift(DOWN).set_z_index(1)
+ circle = Circle(radius = 1.7, color = GREEN, fill_opacity = 1) # z_index = 0
+
+ # Displaying order is now defined by z_index values
+ self.add(text)
+ self.add(square)
+ self.add(tex)
+ self.add(circle)
+```
+
+
+class SetZIndex(Scene):
+ def construct(self):
+ text = Text('z_index = 3', color = PURE_RED).shift(UP).set_z_index(3)
+ square = Square(2, fill_opacity=1).set_z_index(2)
+ tex = Tex(r'zIndex = 1', color = PURE_BLUE).shift(DOWN).set_z_index(1)
+ circle = Circle(radius = 1.7, color = GREEN, fill_opacity = 1) # z_index = 0
+
+ # Displaying order is now defined by z_index values
+ self.add(text)
+ self.add(square)
+ self.add(tex)
+ self.add(circle)
+
+
+
+#### set_z_index_by_z_Point3D()
+
+Sets the [`Mobject`](#manim.mobject.mobject.Mobject)’s z Point3D to the value of `z_index`.
+
+* **Returns:**
+ The Mobject itself, after `z_index` is set. (Returns self.)
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### shift(\*vectors)
+
+Shift by the given vectors.
+
+* **Parameters:**
+ **vectors** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D)) – Vectors to shift by. If multiple vectors are given, they are added
+ together.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### SEE ALSO
+[`move_to()`](#manim.mobject.mobject.Mobject.move_to)
+
+#### shuffle(recursive=False)
+
+Shuffles the list of [`submobjects`](#manim.mobject.mobject.Mobject.submobjects).
+
+* **Parameters:**
+ **recursive** (*bool*)
+* **Return type:**
+ None
+
+#### shuffle_submobjects(\*args, \*\*kwargs)
+
+Shuffles the order of [`submobjects`](#manim.mobject.mobject.Mobject.submobjects)
+
+### Examples
+
+
+
+#### to_edge(edge=array([-1., 0., 0.]), buff=0.5)
+
+Moves this [`Mobject`](#manim.mobject.mobject.Mobject) to the given edge of the screen,
+without affecting its position in the other dimension.
+
+* **Returns:**
+ The newly positioned mobject.
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+* **Parameters:**
+ * **edge** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+ * **buff** (*float*)
+
+### Examples
+
+
+```python
+from manim import *
+
+class ToEdgeExample(Scene):
+ def construct(self):
+ tex_top = Tex("I am at the top!")
+ tex_top.to_edge(UP)
+ tex_side = Tex("I am moving to the side!")
+ c = Circle().shift(2*DOWN)
+ self.add(tex_top, tex_side, c)
+ tex_side.to_edge(LEFT)
+ c.to_edge(RIGHT, buff=0)
+```
+
+
+class ToEdgeExample(Scene):
+ def construct(self):
+ tex_top = Tex("I am at the top!")
+ tex_top.to_edge(UP)
+ tex_side = Tex("I am moving to the side!")
+ c = Circle().shift(2\*DOWN)
+ self.add(tex_top, tex_side, c)
+ tex_side.to_edge(LEFT)
+ c.to_edge(RIGHT, buff=0)
+
+
+
+#### update(dt=0, recursive=True)
+
+Apply all updaters.
+
+Does nothing if updating is suspended.
+
+* **Parameters:**
+ * **dt** (*float*) – The parameter `dt` to pass to the update functions. Usually this is the
+ time in seconds since the last call of `update`.
+ * **recursive** (*bool*) – Whether to recursively update all submobjects.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`Mobject`](#manim.mobject.mobject.Mobject)
+
+#### SEE ALSO
+[`add_updater()`](#manim.mobject.mobject.Mobject.add_updater), [`get_updaters()`](#manim.mobject.mobject.Mobject.get_updaters)
+
+#### *property* width *: float*
+
+The width of the mobject.
+
+* **Return type:**
+ `float`
+
+### Examples
+
+
+
+#### SEE ALSO
+[`length_over_dim()`](#manim.mobject.mobject.Mobject.length_over_dim)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.mobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.mobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..06f5ca5cb94ef86541b406b6341795572048bb2e
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.mobject.md
@@ -0,0 +1,121 @@
+# mobject
+
+Base classes for objects that can be displayed.
+
+### Type Aliases
+
+### *class* TimeBasedUpdater
+
+```default
+Callable[['Mobject', float], object]
+```
+
+### *class* NonTimeBasedUpdater
+
+```default
+Callable[['Mobject'], object]
+```
+
+### *class* Updater
+
+```default
+`NonTimeBasedUpdater`` | `TimeBasedUpdater``
+```
+
+### Classes
+
+| [`Group`](manim.mobject.mobject.Group.md#manim.mobject.mobject.Group) | Groups together multiple [`Mobjects`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject). |
+|-----------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------|
+| [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) | Mathematical Object: base class for objects that can be displayed on screen. |
+
+### Functions
+
+### override_animate(method)
+
+Decorator for overriding method animations.
+
+This allows to specify a method (returning an [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation))
+which is called when the decorated method is used with the `.animate` syntax
+for animating the application of a method.
+
+#### SEE ALSO
+[`Mobject.animate`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.animate)
+
+#### NOTE
+Overridden methods cannot be combined with normal or other overridden
+methods using method chaining with the `.animate` syntax.
+
+### Examples
+
+
+* **Return type:**
+ *LambdaType*
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.ArcBrace.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.ArcBrace.md
new file mode 100644
index 0000000000000000000000000000000000000000..b016735020c79da26b024fb7f1ca65d57f63de30
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.ArcBrace.md
@@ -0,0 +1,110 @@
+# ArcBrace
+
+Qualified name: `manim.mobject.svg.brace.ArcBrace`
+
+### *class* ArcBrace(arc=None, direction=array([1., 0., 0.]), \*\*kwargs)
+
+Bases: [`Brace`](manim.mobject.svg.brace.Brace.md#manim.mobject.svg.brace.Brace)
+
+Creates a [`Brace`](manim.mobject.svg.brace.Brace.md#manim.mobject.svg.brace.Brace) that wraps around an [`Arc`](manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc).
+
+The direction parameter allows the brace to be applied
+from outside or inside the arc.
+
+#### WARNING
+The [`ArcBrace`](#manim.mobject.svg.brace.ArcBrace) is smaller for arcs with smaller radii.
+
+#### NOTE
+The [`ArcBrace`](#manim.mobject.svg.brace.ArcBrace) is initially a vertical [`Brace`](manim.mobject.svg.brace.Brace.md#manim.mobject.svg.brace.Brace) defined by the
+length of the [`Arc`](manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc), but is scaled down to match the start and end
+angles. An exponential function is then applied after it is shifted based on
+the radius of the arc.
+
+The scaling effect is not applied for arcs with radii smaller than 1 to prevent
+over-scaling.
+
+* **Parameters:**
+ * **arc** ([*Arc*](manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc) *|* *None*) – The [`Arc`](manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc) that wraps around the [`Brace`](manim.mobject.svg.brace.Brace.md#manim.mobject.svg.brace.Brace) mobject.
+ * **direction** (*Sequence* *[**float* *]*) – The direction from which the brace faces the arc.
+ `LEFT` for inside the arc, and `RIGHT` for the outside.
+
+### Example
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(arc=None, direction=array([1., 0., 0.]), \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **arc** ([*Arc*](manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc) *|* *None*)
+ * **direction** (*Sequence* *[**float* *]*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.Brace.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.Brace.md
new file mode 100644
index 0000000000000000000000000000000000000000..348e30d3f79c4cd73e2f329e6602cafbed517009
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.Brace.md
@@ -0,0 +1,136 @@
+# Brace
+
+Qualified name: `manim.mobject.svg.brace.Brace`
+
+### *class* Brace(mobject, direction=array([0., -1., 0.]), buff=0.2, sharpness=2, stroke_width=0, fill_opacity=1.0, background_stroke_width=0, background_stroke_color=ManimColor('#000000'), \*\*kwargs)
+
+Bases: [`VMobjectFromSVGPath`](manim.mobject.svg.svg_mobject.VMobjectFromSVGPath.md#manim.mobject.svg.svg_mobject.VMobjectFromSVGPath)
+
+Takes a mobject and draws a brace adjacent to it.
+
+Passing a direction vector determines the direction from which the
+brace is drawn. By default it is drawn from below.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject adjacent to which the brace is placed.
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D) *|* *None*) – The direction from which the brace faces the mobject.
+ * **buff** (*float*)
+ * **sharpness** (*float*)
+ * **stroke_width** (*float*)
+ * **fill_opacity** (*float*)
+ * **background_stroke_width** (*float*)
+ * **background_stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+
+#### SEE ALSO
+[`BraceBetweenPoints`](manim.mobject.svg.brace.BraceBetweenPoints.md#manim.mobject.svg.brace.BraceBetweenPoints)
+
+### Examples
+
+
+```python
+from manim import *
+
+class BraceExample(Scene):
+ def construct(self):
+ s = Square()
+ self.add(s)
+ for i in np.linspace(0.1,1.0,4):
+ br = Brace(s, sharpness=i)
+ t = Text(f"sharpness= {i}").next_to(br, RIGHT)
+ self.add(t)
+ self.add(br)
+ VGroup(*self.mobjects).arrange(DOWN, buff=0.2)
+```
+
+
+class BraceExample(Scene):
+ def construct(self):
+ s = Square()
+ self.add(s)
+ for i in np.linspace(0.1,1.0,4):
+ br = Brace(s, sharpness=i)
+ t = Text(f"sharpness= {i}").next_to(br, RIGHT)
+ self.add(t)
+ self.add(br)
+ VGroup(\*self.mobjects).arrange(DOWN, buff=0.2)
+
+
+
+### Methods
+
+| [`get_direction`](#manim.mobject.svg.brace.Brace.get_direction) | Returns the direction from the center to the brace tip. |
+|-------------------------------------------------------------------|-----------------------------------------------------------|
+| [`get_tex`](#manim.mobject.svg.brace.Brace.get_tex) | Places the tex at the brace tip. |
+| [`get_text`](#manim.mobject.svg.brace.Brace.get_text) | Places the text at the brace tip. |
+| [`get_tip`](#manim.mobject.svg.brace.Brace.get_tip) | Returns the point at the brace tip. |
+| [`put_at_tip`](#manim.mobject.svg.brace.Brace.put_at_tip) | Puts the given mobject at the brace tip. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(mobject, direction=array([0., -1., 0.]), buff=0.2, sharpness=2, stroke_width=0, fill_opacity=1.0, background_stroke_width=0, background_stroke_color=ManimColor('#000000'), \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D) *|* *None*)
+ * **buff** (*float*)
+ * **sharpness** (*float*)
+ * **stroke_width** (*float*)
+ * **fill_opacity** (*float*)
+ * **background_stroke_width** (*float*)
+ * **background_stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+
+#### get_direction()
+
+Returns the direction from the center to the brace tip.
+
+#### get_tex(\*tex, \*\*kwargs)
+
+Places the tex at the brace tip.
+
+* **Parameters:**
+ * **tex** – The tex to be placed at the brace tip.
+ * **kwargs** – Any further keyword arguments are passed to [`put_at_tip()`](#manim.mobject.svg.brace.Brace.put_at_tip) which
+ is used to position the tex at the brace tip.
+* **Return type:**
+ [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex)
+
+#### get_text(\*text, \*\*kwargs)
+
+Places the text at the brace tip.
+
+* **Parameters:**
+ * **text** – The text to be placed at the brace tip.
+ * **kwargs** – Any additional keyword arguments are passed to [`put_at_tip()`](#manim.mobject.svg.brace.Brace.put_at_tip) which
+ is used to position the text at the brace tip.
+* **Return type:**
+ [`Tex`](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex)
+
+#### get_tip()
+
+Returns the point at the brace tip.
+
+#### put_at_tip(mob, use_next_to=True, \*\*kwargs)
+
+Puts the given mobject at the brace tip.
+
+* **Parameters:**
+ * **mob** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject to be placed at the tip.
+ * **use_next_to** (*bool*) – If true, then `next_to()` is used to place the mobject at the
+ tip.
+ * **kwargs** – Any additional keyword arguments are passed to `next_to()` which
+ is used to put the mobject next to the brace tip.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.BraceBetweenPoints.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.BraceBetweenPoints.md
new file mode 100644
index 0000000000000000000000000000000000000000..f137fa6941777db90e7faf4fe38abda454bb3ce5
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.BraceBetweenPoints.md
@@ -0,0 +1,80 @@
+# BraceBetweenPoints
+
+Qualified name: `manim.mobject.svg.brace.BraceBetweenPoints`
+
+### *class* BraceBetweenPoints(point_1, point_2, direction=array([0., 0., 0.]), \*\*kwargs)
+
+Bases: [`Brace`](manim.mobject.svg.brace.Brace.md#manim.mobject.svg.brace.Brace)
+
+Similar to Brace, but instead of taking a mobject it uses 2
+points to place the brace.
+
+A fitting direction for the brace is
+computed, but it still can be manually overridden.
+If the points go from left to right, the brace is drawn from below.
+Swapping the points places the brace on the opposite side.
+
+* **Parameters:**
+ * **point_1** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* *None*) – The first point.
+ * **point_2** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* *None*) – The second point.
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D) *|* *None*) – The direction from which the brace faces towards the points.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(point_1, point_2, direction=array([0., 0., 0.]), \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **point_1** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* *None*)
+ * **point_2** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* *None*)
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D) *|* *None*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.BraceLabel.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.BraceLabel.md
new file mode 100644
index 0000000000000000000000000000000000000000..c44176ecd05c0f3b1a0b1f4a55cf4258e05ffedb
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.BraceLabel.md
@@ -0,0 +1,55 @@
+# BraceLabel
+
+Qualified name: `manim.mobject.svg.brace.BraceLabel`
+
+### *class* BraceLabel(obj, text, brace_direction=array([ 0., -1., 0.]), label_constructor=, font_size=48, buff=0.2, brace_config=None, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+Create a brace with a label attached.
+
+* **Parameters:**
+ * **obj** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject adjacent to which the brace is placed.
+ * **text** (*str*) – The label text.
+ * **brace_direction** (*np.ndarray*) – The direction of the brace. By default `DOWN`.
+ * **label_constructor** (*type*) – A class or function used to construct a mobject representing
+ the label. By default [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex).
+ * **font_size** (*float*) – The font size of the label, passed to the `label_constructor`.
+ * **buff** (*float*) – The buffer between the mobject and the brace.
+ * **brace_config** (*dict* *|* *None*) – Arguments to be passed to [`Brace`](manim.mobject.svg.brace.Brace.md#manim.mobject.svg.brace.Brace).
+ * **kwargs** – Additional arguments to be passed to [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+
+### Methods
+
+| `change_brace_label` | |
+|------------------------|----|
+| `change_label` | |
+| `creation_anim` | |
+| `shift_brace` | |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(obj, text, brace_direction=array([ 0., -1., 0.]), label_constructor=, font_size=48, buff=0.2, brace_config=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **obj** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **text** (*str*)
+ * **brace_direction** (*ndarray*)
+ * **label_constructor** (*type*)
+ * **font_size** (*float*)
+ * **buff** (*float*)
+ * **brace_config** (*dict* *|* *None*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.BraceText.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.BraceText.md
new file mode 100644
index 0000000000000000000000000000000000000000..fe0abe82edb270f8195d40aadc84c0abfca21de7
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.BraceText.md
@@ -0,0 +1,27 @@
+# BraceText
+
+Qualified name: `manim.mobject.svg.brace.BraceText`
+
+### *class* BraceText(obj, text, label_constructor=, \*\*kwargs)
+
+Bases: [`BraceLabel`](manim.mobject.svg.brace.BraceLabel.md#manim.mobject.svg.brace.BraceLabel)
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(obj, text, label_constructor=, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.md
new file mode 100644
index 0000000000000000000000000000000000000000..6db3780d5a85d73d960311d71f5214f57ebed9e3
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.brace.md
@@ -0,0 +1,12 @@
+# brace
+
+Mobject representing curly braces.
+
+### Classes
+
+| [`ArcBrace`](manim.mobject.svg.brace.ArcBrace.md#manim.mobject.svg.brace.ArcBrace) | Creates a [`Brace`](manim.mobject.svg.brace.Brace.md#manim.mobject.svg.brace.Brace) that wraps around an [`Arc`](manim.mobject.geometry.arc.Arc.md#manim.mobject.geometry.arc.Arc). |
+|------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`Brace`](manim.mobject.svg.brace.Brace.md#manim.mobject.svg.brace.Brace) | Takes a mobject and draws a brace adjacent to it. |
+| [`BraceBetweenPoints`](manim.mobject.svg.brace.BraceBetweenPoints.md#manim.mobject.svg.brace.BraceBetweenPoints) | Similar to Brace, but instead of taking a mobject it uses 2 points to place the brace. |
+| [`BraceLabel`](manim.mobject.svg.brace.BraceLabel.md#manim.mobject.svg.brace.BraceLabel) | Create a brace with a label attached. |
+| [`BraceText`](manim.mobject.svg.brace.BraceText.md#manim.mobject.svg.brace.BraceText) | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.md
new file mode 100644
index 0000000000000000000000000000000000000000..6dbb5d96ae4d19a0360222ed2771f8205bb0c367
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.md
@@ -0,0 +1,9 @@
+# svg
+
+Mobjects related to SVG images.
+
+## Modules
+
+| [`brace`](manim.mobject.svg.brace.md#module-manim.mobject.svg.brace) | Mobject representing curly braces. |
+|----------------------------------------------------------------------------------------|--------------------------------------|
+| [`svg_mobject`](manim.mobject.svg.svg_mobject.md#module-manim.mobject.svg.svg_mobject) | Mobjects generated from an SVG file. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.svg_mobject.SVGMobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.svg_mobject.SVGMobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..d470a981ad0da46fe8aed62a3c94f774634a2901
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.svg_mobject.SVGMobject.md
@@ -0,0 +1,257 @@
+# SVGMobject
+
+Qualified name: `manim.mobject.svg.svg\_mobject.SVGMobject`
+
+### *class* SVGMobject(file_name=None, should_center=True, height=2, width=None, color=None, opacity=None, fill_color=None, fill_opacity=None, stroke_color=None, stroke_opacity=None, stroke_width=None, svg_default=None, path_string_config=None, use_svg_cache=True, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A vectorized mobject created from importing an SVG file.
+
+* **Parameters:**
+ * **file_name** (*str* *|* *os.PathLike* *|* *None*) – The path to the SVG file.
+ * **should_center** (*bool*) – Whether or not the mobject should be centered after
+ being imported.
+ * **height** (*float* *|* *None*) – The target height of the mobject, set to 2 Manim units by default.
+ If the height and width are both set to `None`, the mobject
+ is imported without being scaled.
+ * **width** (*float* *|* *None*) – The target width of the mobject, set to `None` by default. If
+ the height and the width are both set to `None`, the mobject
+ is imported without being scaled.
+ * **color** (*str* *|* *None*) – The color (both fill and stroke color) of the mobject. If
+ `None` (the default), the colors set in the SVG file
+ are used.
+ * **opacity** (*float* *|* *None*) – The opacity (both fill and stroke opacity) of the mobject.
+ If `None` (the default), the opacity set in the SVG file
+ is used.
+ * **fill_color** (*str* *|* *None*) – The fill color of the mobject. If `None` (the default),
+ the fill colors set in the SVG file are used.
+ * **fill_opacity** (*float* *|* *None*) – The fill opacity of the mobject. If `None` (the default),
+ the fill opacities set in the SVG file are used.
+ * **stroke_color** (*str* *|* *None*) – The stroke color of the mobject. If `None` (the default),
+ the stroke colors set in the SVG file are used.
+ * **stroke_opacity** (*float* *|* *None*) – The stroke opacity of the mobject. If `None` (the default),
+ the stroke opacities set in the SVG file are used.
+ * **stroke_width** (*float* *|* *None*) – The stroke width of the mobject. If `None` (the default),
+ the stroke width values set in the SVG file are used.
+ * **svg_default** (*dict* *|* *None*) – A dictionary in which fallback values for unspecified
+ properties of elements in the SVG file are defined. If
+ `None` (the default), `color`, `opacity`, `fill_color`
+ `fill_opacity`, `stroke_color`, and `stroke_opacity`
+ are set to `None`, and `stroke_width` is set to 0.
+ * **path_string_config** (*dict* *|* *None*) – A dictionary with keyword arguments passed to
+ [`VMobjectFromSVGPath`](manim.mobject.svg.svg_mobject.VMobjectFromSVGPath.md#manim.mobject.svg.svg_mobject.VMobjectFromSVGPath) used for importing path elements.
+ If `None` (the default), no additional arguments are passed.
+ * **use_svg_cache** (*bool*) – If True (default), the svg inputs (e.g. file_name, settings)
+ will be used as a key and a copy of the created mobject will
+ be saved using that key to be quickly retrieved if the same
+ inputs need be processed later. For large SVGs which are used
+ only once, this can be omitted to improve performance.
+ * **kwargs** – Further arguments passed to the parent class.
+
+### Methods
+
+| [`apply_style_to_mobject`](#manim.mobject.svg.svg_mobject.SVGMobject.apply_style_to_mobject) | Apply SVG style information to the converted mobject. |
+|------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------|
+| [`ellipse_to_mobject`](#manim.mobject.svg.svg_mobject.SVGMobject.ellipse_to_mobject) | Convert an ellipse or circle element to a vectorized mobject. |
+| [`generate_config_style_dict`](#manim.mobject.svg.svg_mobject.SVGMobject.generate_config_style_dict) | Generate a dictionary holding the default style information. |
+| [`generate_mobject`](#manim.mobject.svg.svg_mobject.SVGMobject.generate_mobject) | Parse the SVG and translate its elements to submobjects. |
+| [`get_file_path`](#manim.mobject.svg.svg_mobject.SVGMobject.get_file_path) | Search for an existing file based on the specified file name. |
+| [`get_mobjects_from`](#manim.mobject.svg.svg_mobject.SVGMobject.get_mobjects_from) | Convert the elements of the SVG to a list of mobjects. |
+| [`handle_transform`](#manim.mobject.svg.svg_mobject.SVGMobject.handle_transform) | Apply SVG transformations to the converted mobject. |
+| [`init_svg_mobject`](#manim.mobject.svg.svg_mobject.SVGMobject.init_svg_mobject) | Checks whether the SVG has already been imported and generates it if not. |
+| [`line_to_mobject`](#manim.mobject.svg.svg_mobject.SVGMobject.line_to_mobject) | Convert a line element to a vectorized mobject. |
+| [`modify_xml_tree`](#manim.mobject.svg.svg_mobject.SVGMobject.modify_xml_tree) | Modifies the SVG element tree to include default style information. |
+| [`move_into_position`](#manim.mobject.svg.svg_mobject.SVGMobject.move_into_position) | Scale and move the generated mobject into position. |
+| [`path_to_mobject`](#manim.mobject.svg.svg_mobject.SVGMobject.path_to_mobject) | Convert a path element to a vectorized mobject. |
+| [`polygon_to_mobject`](#manim.mobject.svg.svg_mobject.SVGMobject.polygon_to_mobject) | Convert a polygon element to a vectorized mobject. |
+| [`polyline_to_mobject`](#manim.mobject.svg.svg_mobject.SVGMobject.polyline_to_mobject) | Convert a polyline element to a vectorized mobject. |
+| [`rect_to_mobject`](#manim.mobject.svg.svg_mobject.SVGMobject.rect_to_mobject) | Convert a rectangle element to a vectorized mobject. |
+| [`text_to_mobject`](#manim.mobject.svg.svg_mobject.SVGMobject.text_to_mobject) | Convert a text element to a vectorized mobject. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|--------------------------------------------------------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| [`hash_seed`](#manim.mobject.svg.svg_mobject.SVGMobject.hash_seed) | A unique hash representing the result of the generated mobject points. |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(file_name=None, should_center=True, height=2, width=None, color=None, opacity=None, fill_color=None, fill_opacity=None, stroke_color=None, stroke_opacity=None, stroke_width=None, svg_default=None, path_string_config=None, use_svg_cache=True, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **file_name** (*str* *|* *PathLike* *|* *None*)
+ * **should_center** (*bool*)
+ * **height** (*float* *|* *None*)
+ * **width** (*float* *|* *None*)
+ * **color** (*str* *|* *None*)
+ * **opacity** (*float* *|* *None*)
+ * **fill_color** (*str* *|* *None*)
+ * **fill_opacity** (*float* *|* *None*)
+ * **stroke_color** (*str* *|* *None*)
+ * **stroke_opacity** (*float* *|* *None*)
+ * **stroke_width** (*float* *|* *None*)
+ * **svg_default** (*dict* *|* *None*)
+ * **path_string_config** (*dict* *|* *None*)
+ * **use_svg_cache** (*bool*)
+
+#### *static* apply_style_to_mobject(mob, shape)
+
+Apply SVG style information to the converted mobject.
+
+* **Parameters:**
+ * **mob** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The converted mobject.
+ * **shape** (*GraphicObject*) – The parsed SVG element.
+* **Return type:**
+ [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### *static* ellipse_to_mobject(ellipse)
+
+Convert an ellipse or circle element to a vectorized mobject.
+
+* **Parameters:**
+ **ellipse** (*Ellipse* *|* *Circle*) – The parsed SVG ellipse or circle.
+* **Return type:**
+ [*Circle*](manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle)
+
+#### generate_config_style_dict()
+
+Generate a dictionary holding the default style information.
+
+* **Return type:**
+ dict[str, str]
+
+#### generate_mobject()
+
+Parse the SVG and translate its elements to submobjects.
+
+* **Return type:**
+ None
+
+#### get_file_path()
+
+Search for an existing file based on the specified file name.
+
+* **Return type:**
+ *Path*
+
+#### get_mobjects_from(svg)
+
+Convert the elements of the SVG to a list of mobjects.
+
+* **Parameters:**
+ **svg** (*SVG*) – The parsed SVG file.
+* **Return type:**
+ list[[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)]
+
+#### *static* handle_transform(mob, matrix)
+
+Apply SVG transformations to the converted mobject.
+
+* **Parameters:**
+ * **mob** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The converted mobject.
+ * **matrix** (*Matrix*) – The transformation matrix determined from the SVG
+ transformation.
+* **Return type:**
+ [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### *property* hash_seed *: tuple*
+
+A unique hash representing the result of the generated
+mobject points.
+
+Used as keys in the `SVG_HASH_TO_MOB_MAP` caching dictionary.
+
+#### init_svg_mobject(use_svg_cache)
+
+Checks whether the SVG has already been imported and
+generates it if not.
+
+#### SEE ALSO
+[`SVGMobject.generate_mobject()`](#manim.mobject.svg.svg_mobject.SVGMobject.generate_mobject)
+
+* **Parameters:**
+ **use_svg_cache** (*bool*)
+* **Return type:**
+ None
+
+#### *static* line_to_mobject(line)
+
+Convert a line element to a vectorized mobject.
+
+* **Parameters:**
+ **line** (*Line*) – The parsed SVG line.
+* **Return type:**
+ [*Line*](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line)
+
+#### modify_xml_tree(element_tree)
+
+Modifies the SVG element tree to include default
+style information.
+
+* **Parameters:**
+ **element_tree** (*ElementTree*) – The parsed element tree from the SVG file.
+* **Return type:**
+ *ElementTree*
+
+#### move_into_position()
+
+Scale and move the generated mobject into position.
+
+* **Return type:**
+ None
+
+#### path_to_mobject(path)
+
+Convert a path element to a vectorized mobject.
+
+* **Parameters:**
+ **path** (*Path*) – The parsed SVG path.
+* **Return type:**
+ [*VMobjectFromSVGPath*](manim.mobject.svg.svg_mobject.VMobjectFromSVGPath.md#manim.mobject.svg.svg_mobject.VMobjectFromSVGPath)
+
+#### *static* polygon_to_mobject(polygon)
+
+Convert a polygon element to a vectorized mobject.
+
+* **Parameters:**
+ **polygon** (*Polygon*) – The parsed SVG polygon.
+* **Return type:**
+ [*Polygon*](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon)
+
+#### polyline_to_mobject(polyline)
+
+Convert a polyline element to a vectorized mobject.
+
+* **Parameters:**
+ **polyline** (*Polyline*) – The parsed SVG polyline.
+* **Return type:**
+ [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### *static* rect_to_mobject(rect)
+
+Convert a rectangle element to a vectorized mobject.
+
+* **Parameters:**
+ **rect** (*Rect*) – The parsed SVG rectangle.
+* **Return type:**
+ [*Rectangle*](manim.mobject.geometry.polygram.Rectangle.md#manim.mobject.geometry.polygram.Rectangle)
+
+#### *static* text_to_mobject(text)
+
+Convert a text element to a vectorized mobject.
+
+#### WARNING
+Not yet implemented.
+
+* **Parameters:**
+ **text** (*Text*) – The parsed SVG text.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.svg_mobject.VMobjectFromSVGPath.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.svg_mobject.VMobjectFromSVGPath.md
new file mode 100644
index 0000000000000000000000000000000000000000..460c32e12ec5f0e588a9c22a25c64e8e07aea172
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.svg_mobject.VMobjectFromSVGPath.md
@@ -0,0 +1,66 @@
+# VMobjectFromSVGPath
+
+Qualified name: `manim.mobject.svg.svg\_mobject.VMobjectFromSVGPath`
+
+### *class* VMobjectFromSVGPath(path_obj, long_lines=False, should_subdivide_sharp_curves=False, should_remove_null_curves=False, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A vectorized mobject representing an SVG path.
+
+#### NOTE
+The `long_lines`, `should_subdivide_sharp_curves`,
+and `should_remove_null_curves` keyword arguments are
+only respected with the OpenGL renderer.
+
+* **Parameters:**
+ * **path_obj** (*se.Path*) – A parsed SVG path object.
+ * **long_lines** (*bool*) – Whether or not straight lines in the vectorized mobject
+ are drawn in one or two segments.
+ * **should_subdivide_sharp_curves** (*bool*) – Whether or not to subdivide subcurves further in case
+ two segments meet at an angle that is sharper than a
+ given threshold.
+ * **should_remove_null_curves** (*bool*) – Whether or not to remove subcurves of length 0.
+ * **kwargs** – Further keyword arguments are passed to the parent
+ class.
+
+### Methods
+
+| [`generate_points`](#manim.mobject.svg.svg_mobject.VMobjectFromSVGPath.generate_points) | Initializes `points` and therefore the shape. |
+|-------------------------------------------------------------------------------------------|-------------------------------------------------|
+| `handle_commands` | |
+| `init_points` | |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(path_obj, long_lines=False, should_subdivide_sharp_curves=False, should_remove_null_curves=False, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **path_obj** (*Path*)
+ * **long_lines** (*bool*)
+ * **should_subdivide_sharp_curves** (*bool*)
+ * **should_remove_null_curves** (*bool*)
+
+#### generate_points()
+
+Initializes `points` and therefore the shape.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
+
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.svg_mobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.svg_mobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..851ef7452dc3ff91000f9fca02ac5e60509f57a0
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.svg.svg_mobject.md
@@ -0,0 +1,9 @@
+# svg_mobject
+
+Mobjects generated from an SVG file.
+
+### Classes
+
+| [`SVGMobject`](manim.mobject.svg.svg_mobject.SVGMobject.md#manim.mobject.svg.svg_mobject.SVGMobject) | A vectorized mobject created from importing an SVG file. |
+|---------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------|
+| [`VMobjectFromSVGPath`](manim.mobject.svg.svg_mobject.VMobjectFromSVGPath.md#manim.mobject.svg.svg_mobject.VMobjectFromSVGPath) | A vectorized mobject representing an SVG path. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.DecimalTable.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.DecimalTable.md
new file mode 100644
index 0000000000000000000000000000000000000000..e48df7396d18c95a323b9954aa555061b6136fe7
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.DecimalTable.md
@@ -0,0 +1,82 @@
+# DecimalTable
+
+Qualified name: `manim.mobject.table.DecimalTable`
+
+### *class* DecimalTable(table, element_to_mobject=, element_to_mobject_config={'num_decimal_places': 1}, \*\*kwargs)
+
+Bases: [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table)
+
+A specialized [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) mobject for use with [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber) to display decimal entries.
+
+### Examples
+
+
+
+Special case of [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) with `element_to_mobject` set to [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber).
+By default, `num_decimal_places` is set to 1.
+Will round/truncate the decimal places based on the provided `element_to_mobject_config`.
+
+* **Parameters:**
+ * **table** (*Iterable* *[**Iterable* *[**float* *|* *str* *]* *]*) – A 2D array, or a list of lists. Content of the table must be valid input
+ for [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber).
+ * **element_to_mobject** (*Callable* *[* *[**float* *|* *str* *]* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*) – The [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) class applied to the table entries. Set as [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber).
+ * **element_to_mobject_config** (*dict*) – Element to mobject config, here set as {“num_decimal_places”: 1}.
+ * **kwargs** – Additional arguments to be passed to [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table).
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(table, element_to_mobject=, element_to_mobject_config={'num_decimal_places': 1}, \*\*kwargs)
+
+Special case of [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) with `element_to_mobject` set to [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber).
+By default, `num_decimal_places` is set to 1.
+Will round/truncate the decimal places based on the provided `element_to_mobject_config`.
+
+* **Parameters:**
+ * **table** (*Iterable* *[**Iterable* *[**float* *|* *str* *]* *]*) – A 2D array, or a list of lists. Content of the table must be valid input
+ for [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber).
+ * **element_to_mobject** (*Callable* *[* *[**float* *|* *str* *]* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*) – The [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) class applied to the table entries. Set as [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber).
+ * **element_to_mobject_config** (*dict*) – Element to mobject config, here set as {“num_decimal_places”: 1}.
+ * **kwargs** – Additional arguments to be passed to [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table).
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.IntegerTable.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.IntegerTable.md
new file mode 100644
index 0000000000000000000000000000000000000000..2fe414e7057f32a4602100ddd48486cec5c5067d
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.IntegerTable.md
@@ -0,0 +1,88 @@
+# IntegerTable
+
+Qualified name: `manim.mobject.table.IntegerTable`
+
+### *class* IntegerTable(table, element_to_mobject=, \*\*kwargs)
+
+Bases: [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table)
+
+A specialized [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) mobject for use with [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer).
+
+### Examples
+
+
+
+Special case of [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) with element_to_mobject set to [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer).
+Will round if there are decimal entries in the table.
+
+* **Parameters:**
+ * **table** (*Iterable* *[**Iterable* *[**float* *|* *str* *]* *]*) – A 2d array or list of lists. Content of the table has to be valid input
+ for [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer).
+ * **element_to_mobject** (*Callable* *[* *[**float* *|* *str* *]* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*) – The [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) class applied to the table entries. Set as [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer).
+ * **kwargs** – Additional arguments to be passed to [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table).
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(table, element_to_mobject=, \*\*kwargs)
+
+Special case of [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) with element_to_mobject set to [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer).
+Will round if there are decimal entries in the table.
+
+* **Parameters:**
+ * **table** (*Iterable* *[**Iterable* *[**float* *|* *str* *]* *]*) – A 2d array or list of lists. Content of the table has to be valid input
+ for [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer).
+ * **element_to_mobject** (*Callable* *[* *[**float* *|* *str* *]* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*) – The [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) class applied to the table entries. Set as [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer).
+ * **kwargs** – Additional arguments to be passed to [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table).
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.MathTable.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.MathTable.md
new file mode 100644
index 0000000000000000000000000000000000000000..451a677ed435c6c4290746e75fbcc1876eb730db
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.MathTable.md
@@ -0,0 +1,76 @@
+# MathTable
+
+Qualified name: `manim.mobject.table.MathTable`
+
+### *class* MathTable(table, element_to_mobject=, \*\*kwargs)
+
+Bases: [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table)
+
+A specialized [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) mobject for use with LaTeX.
+
+### Examples
+
+
+
+Special case of [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) with element_to_mobject set to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex).
+Every entry in table is set in a Latex align environment.
+
+* **Parameters:**
+ * **table** (*Iterable* *[**Iterable* *[**float* *|* *str* *]* *]*) – A 2d array or list of lists. Content of the table have to be valid input
+ for [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex).
+ * **element_to_mobject** (*Callable* *[* *[**float* *|* *str* *]* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*) – The [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) class applied to the table entries. Set as [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex).
+ * **kwargs** – Additional arguments to be passed to [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table).
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(table, element_to_mobject=, \*\*kwargs)
+
+Special case of [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) with element_to_mobject set to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex).
+Every entry in table is set in a Latex align environment.
+
+* **Parameters:**
+ * **table** (*Iterable* *[**Iterable* *[**float* *|* *str* *]* *]*) – A 2d array or list of lists. Content of the table have to be valid input
+ for [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex).
+ * **element_to_mobject** (*Callable* *[* *[**float* *|* *str* *]* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*) – The [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) class applied to the table entries. Set as [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex).
+ * **kwargs** – Additional arguments to be passed to [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table).
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.MobjectTable.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.MobjectTable.md
new file mode 100644
index 0000000000000000000000000000000000000000..544c0876db35aded7a052c42d82ea7924e6bac6c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.MobjectTable.md
@@ -0,0 +1,90 @@
+# MobjectTable
+
+Qualified name: `manim.mobject.table.MobjectTable`
+
+### *class* MobjectTable(table, element_to_mobject=>, \*\*kwargs)
+
+Bases: [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table)
+
+A specialized [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) mobject for use with [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+
+### Examples
+
+
+
+Special case of [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) with `element_to_mobject` set to an identity function.
+Here, every item in `table` must already be of type [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+
+* **Parameters:**
+ * **table** (*Iterable* *[**Iterable* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *]*) – A 2D array or list of lists. Content of the table must be of type [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+ * **element_to_mobject** (*Callable* *[* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*) – The [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) class applied to the table entries. Set as `lambda m : m` to return itself.
+ * **kwargs** – Additional arguments to be passed to [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table).
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(table, element_to_mobject=>, \*\*kwargs)
+
+Special case of [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) with `element_to_mobject` set to an identity function.
+Here, every item in `table` must already be of type [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+
+* **Parameters:**
+ * **table** (*Iterable* *[**Iterable* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *]*) – A 2D array or list of lists. Content of the table must be of type [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+ * **element_to_mobject** (*Callable* *[* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*) – The [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) class applied to the table entries. Set as `lambda m : m` to return itself.
+ * **kwargs** – Additional arguments to be passed to [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table).
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.Table.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.Table.md
new file mode 100644
index 0000000000000000000000000000000000000000..ee3290d5228c3f716a387ba2ba4922220cdc88d2
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.table.Table.md
@@ -0,0 +1,991 @@
+# Table
+
+Qualified name: `manim.mobject.table.Table`
+
+### *class* Table(table, row_labels=None, col_labels=None, top_left_entry=None, v_buff=0.8, h_buff=1.3, include_outer_lines=False, add_background_rectangles_to_entries=False, entries_background_color=ManimColor('#000000'), include_background_rectangle=False, background_rectangle_color=ManimColor('#000000'), element_to_mobject=, element_to_mobject_config={}, arrange_in_grid_config={}, line_config={}, \*\*kwargs)
+
+Bases: [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+A mobject that displays a table on the screen.
+
+* **Parameters:**
+ * **table** (*Iterable* *[**Iterable* *[**float* *|* *str* *|* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *]*) – A 2D array or list of lists. Content of the table has to be a valid input
+ for the callable set in `element_to_mobject`.
+ * **row_labels** (*Iterable* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *|* *None*) – List of [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) representing the labels of each row.
+ * **col_labels** (*Iterable* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *|* *None*) – List of [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) representing the labels of each column.
+ * **top_left_entry** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *None*) – The top-left entry of the table, can only be specified if row and
+ column labels are given.
+ * **v_buff** (*float*) – Vertical buffer passed to [`arrange_in_grid()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.arrange_in_grid), by default 0.8.
+ * **h_buff** (*float*) – Horizontal buffer passed to [`arrange_in_grid()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.arrange_in_grid), by default 1.3.
+ * **include_outer_lines** (*bool*) – `True` if the table should include outer lines, by default False.
+ * **add_background_rectangles_to_entries** (*bool*) – `True` if background rectangles should be added to entries, by default `False`.
+ * **entries_background_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – Background color of entries if `add_background_rectangles_to_entries` is `True`.
+ * **include_background_rectangle** (*bool*) – `True` if the table should have a background rectangle, by default `False`.
+ * **background_rectangle_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – Background color of table if `include_background_rectangle` is `True`.
+ * **element_to_mobject** (*Callable* *[* *[**float* *|* *str* *|* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*) – The [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) class applied to the table entries. by default [`Paragraph`](manim.mobject.text.text_mobject.Paragraph.md#manim.mobject.text.text_mobject.Paragraph). For common choices, see [`text_mobject`](manim.mobject.text.text_mobject.md#module-manim.mobject.text.text_mobject)/[`tex_mobject`](manim.mobject.text.tex_mobject.md#module-manim.mobject.text.tex_mobject).
+ * **element_to_mobject_config** (*dict*) – Custom configuration passed to `element_to_mobject`, by default {}.
+ * **arrange_in_grid_config** (*dict*) – Dict passed to [`arrange_in_grid()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.arrange_in_grid), customizes the arrangement of the table.
+ * **line_config** (*dict*) – Dict passed to [`Line`](manim.mobject.geometry.line.Line.md#manim.mobject.geometry.line.Line), customizes the lines of the table.
+ * **kwargs** – Additional arguments to be passed to [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup).
+
+### Examples
+
+
+
+### Methods
+
+| [`add_background_to_entries`](#manim.mobject.table.Table.add_background_to_entries) | Adds a black [`BackgroundRectangle`](manim.mobject.geometry.shape_matchers.BackgroundRectangle.md#manim.mobject.geometry.shape_matchers.BackgroundRectangle) to each entry of the table. |
+|---------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`add_highlighted_cell`](#manim.mobject.table.Table.add_highlighted_cell) | Highlights one cell at a specific position on the table by adding a [`BackgroundRectangle`](manim.mobject.geometry.shape_matchers.BackgroundRectangle.md#manim.mobject.geometry.shape_matchers.BackgroundRectangle). |
+| [`create`](#manim.mobject.table.Table.create) | Customized create-type function for tables. |
+| [`get_cell`](#manim.mobject.table.Table.get_cell) | Returns one specific cell as a rectangular [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon) without the entry. |
+| [`get_col_labels`](#manim.mobject.table.Table.get_col_labels) | Return the column labels of the table. |
+| [`get_columns`](#manim.mobject.table.Table.get_columns) | Return columns of the table as a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) of [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup). |
+| [`get_entries`](#manim.mobject.table.Table.get_entries) | Return the individual entries of the table (including labels) or one specific entry if the parameter, `pos`, is set. |
+| [`get_entries_without_labels`](#manim.mobject.table.Table.get_entries_without_labels) | Return the individual entries of the table (without labels) or one specific entry if the parameter, `pos`, is set. |
+| [`get_highlighted_cell`](#manim.mobject.table.Table.get_highlighted_cell) | Returns a [`BackgroundRectangle`](manim.mobject.geometry.shape_matchers.BackgroundRectangle.md#manim.mobject.geometry.shape_matchers.BackgroundRectangle) of the cell at the given position. |
+| [`get_horizontal_lines`](#manim.mobject.table.Table.get_horizontal_lines) | Return the horizontal lines of the table. |
+| [`get_labels`](#manim.mobject.table.Table.get_labels) | Returns the labels of the table. |
+| [`get_row_labels`](#manim.mobject.table.Table.get_row_labels) | Return the row labels of the table. |
+| [`get_rows`](#manim.mobject.table.Table.get_rows) | Return the rows of the table as a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) of [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup). |
+| [`get_vertical_lines`](#manim.mobject.table.Table.get_vertical_lines) | Return the vertical lines of the table. |
+| [`scale`](#manim.mobject.table.Table.scale) | Scale the size by a factor. |
+| [`set_column_colors`](#manim.mobject.table.Table.set_column_colors) | Set individual colors for each column of the table. |
+| [`set_row_colors`](#manim.mobject.table.Table.set_row_colors) | Set individual colors for each row of the table. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_add_horizontal_lines()
+
+Adds the horizontal lines to the table.
+
+* **Return type:**
+ [*Table*](#manim.mobject.table.Table)
+
+#### \_add_labels(mob_table)
+
+Adds labels to an in a grid arranged [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup).
+
+* **Parameters:**
+ **mob_table** ([*VGroup*](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)) – An in a grid organized class:~.VGroup.
+* **Returns:**
+ Returns the `mob_table` with added labels.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+#### \_add_vertical_lines()
+
+Adds the vertical lines to the table
+
+* **Return type:**
+ [*Table*](#manim.mobject.table.Table)
+
+#### \_organize_mob_table(table)
+
+Arranges the [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) of `table` in a grid.
+
+* **Parameters:**
+ **table** (*Iterable* *[**Iterable* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *]*) – A 2D iterable object with [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) entries.
+* **Returns:**
+ The [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) of the `table` in a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) already
+ arranged in a table-like grid.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+#### \_original_\_init_\_(table, row_labels=None, col_labels=None, top_left_entry=None, v_buff=0.8, h_buff=1.3, include_outer_lines=False, add_background_rectangles_to_entries=False, entries_background_color=ManimColor('#000000'), include_background_rectangle=False, background_rectangle_color=ManimColor('#000000'), element_to_mobject=, element_to_mobject_config={}, arrange_in_grid_config={}, line_config={}, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **table** (*Iterable* *[**Iterable* *[**float* *|* *str* *|* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *]*)
+ * **row_labels** (*Iterable* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *|* *None*)
+ * **col_labels** (*Iterable* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *|* *None*)
+ * **top_left_entry** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *None*)
+ * **v_buff** (*float*)
+ * **h_buff** (*float*)
+ * **include_outer_lines** (*bool*)
+ * **add_background_rectangles_to_entries** (*bool*)
+ * **entries_background_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **include_background_rectangle** (*bool*)
+ * **background_rectangle_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **element_to_mobject** (*Callable* *[* *[**float* *|* *str* *|* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*)
+ * **element_to_mobject_config** (*dict*)
+ * **arrange_in_grid_config** (*dict*)
+ * **line_config** (*dict*)
+
+#### \_table_to_mob_table(table)
+
+Initilaizes the entries of `table` as [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject).
+
+* **Parameters:**
+ **table** (*Iterable* *[**Iterable* *[**float* *|* *str* *|* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *]*) – A 2D array or list of lists. Content of the table has to be a valid input
+ for the callable set in `element_to_mobject`.
+* **Returns:**
+ List of [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) from the entries of `table`.
+* **Return type:**
+ List
+
+#### add_background_to_entries(color=ManimColor('#000000'))
+
+Adds a black [`BackgroundRectangle`](manim.mobject.geometry.shape_matchers.BackgroundRectangle.md#manim.mobject.geometry.shape_matchers.BackgroundRectangle) to each entry of the table.
+
+* **Parameters:**
+ **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+* **Return type:**
+ [*Table*](#manim.mobject.table.Table)
+
+#### add_highlighted_cell(pos=(1, 1), color=ManimColor('#FFFF00'), \*\*kwargs)
+
+Highlights one cell at a specific position on the table by adding a [`BackgroundRectangle`](manim.mobject.geometry.shape_matchers.BackgroundRectangle.md#manim.mobject.geometry.shape_matchers.BackgroundRectangle).
+
+* **Parameters:**
+ * **pos** (*Sequence* *[**int* *]*) – The position of a specific entry on the table. `(1,1)` being the top left entry
+ of the table.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color used to highlight the cell.
+ * **kwargs** – Additional arguments to be passed to [`BackgroundRectangle`](manim.mobject.geometry.shape_matchers.BackgroundRectangle.md#manim.mobject.geometry.shape_matchers.BackgroundRectangle).
+* **Return type:**
+ [*Table*](#manim.mobject.table.Table)
+
+### Examples
+
+
+
+#### create(lag_ratio=1, line_animation=, label_animation=, element_animation=, entry_animation=, \*\*kwargs)
+
+Customized create-type function for tables.
+
+* **Parameters:**
+ * **lag_ratio** (*float*) – The lag ratio of the animation.
+ * **line_animation** (*Callable* *[* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* [*VGroup*](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) *]* *,* [*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – The animation style of the table lines, see [`creation`](manim.animation.creation.md#module-manim.animation.creation) for examples.
+ * **label_animation** (*Callable* *[* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* [*VGroup*](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) *]* *,* [*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – The animation style of the table labels, see [`creation`](manim.animation.creation.md#module-manim.animation.creation) for examples.
+ * **element_animation** (*Callable* *[* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* [*VGroup*](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) *]* *,* [*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – The animation style of the table elements, see [`creation`](manim.animation.creation.md#module-manim.animation.creation) for examples.
+ * **entry_animation** (*Callable* *[* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* [*VGroup*](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) *]* *,* [*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – The entry animation of the table background, see [`creation`](manim.animation.creation.md#module-manim.animation.creation) for examples.
+ * **kwargs** – Further arguments passed to the creation animations.
+* **Returns:**
+ AnimationGroup containing creation of the lines and of the elements.
+* **Return type:**
+ [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup)
+
+### Examples
+
+
+
+#### get_cell(pos=(1, 1), \*\*kwargs)
+
+Returns one specific cell as a rectangular [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon) without the entry.
+
+* **Parameters:**
+ * **pos** (*Sequence* *[**int* *]*) – The position of a specific entry on the table. `(1,1)` being the top left entry
+ of the table.
+ * **kwargs** – Additional arguments to be passed to [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon).
+* **Returns:**
+ Polygon mimicking one specific cell of the Table.
+* **Return type:**
+ [`Polygon`](manim.mobject.geometry.polygram.Polygon.md#manim.mobject.geometry.polygram.Polygon)
+
+### Examples
+
+
+
+#### get_columns()
+
+Return columns of the table as a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) of [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup).
+
+* **Returns:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) containing each column in a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup).
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+### Examples
+
+
+
+#### get_entries(pos=None)
+
+Return the individual entries of the table (including labels) or one specific entry
+if the parameter, `pos`, is set.
+
+* **Parameters:**
+ **pos** (*Sequence* *[**int* *]* *|* *None*) – The position of a specific entry on the table. `(1,1)` being the top left entry
+ of the table.
+* **Returns:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) containing all entries of the table (including labels)
+ or the [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) at the given position if `pos` is set.
+* **Return type:**
+ Union[[`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject), [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)]
+
+### Examples
+
+
+
+#### get_entries_without_labels(pos=None)
+
+Return the individual entries of the table (without labels) or one specific entry
+if the parameter, `pos`, is set.
+
+* **Parameters:**
+ **pos** (*Sequence* *[**int* *]* *|* *None*) – The position of a specific entry on the table. `(1,1)` being the top left entry
+ of the table (without labels).
+* **Returns:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) containing all entries of the table (without labels)
+ or the [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) at the given position if `pos` is set.
+* **Return type:**
+ Union[[`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject), [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)]
+
+### Examples
+
+
+
+#### get_highlighted_cell(pos=(1, 1), color=ManimColor('#FFFF00'), \*\*kwargs)
+
+Returns a [`BackgroundRectangle`](manim.mobject.geometry.shape_matchers.BackgroundRectangle.md#manim.mobject.geometry.shape_matchers.BackgroundRectangle) of the cell at the given position.
+
+* **Parameters:**
+ * **pos** (*Sequence* *[**int* *]*) – The position of a specific entry on the table. `(1,1)` being the top left entry
+ of the table.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color used to highlight the cell.
+ * **kwargs** – Additional arguments to be passed to [`BackgroundRectangle`](manim.mobject.geometry.shape_matchers.BackgroundRectangle.md#manim.mobject.geometry.shape_matchers.BackgroundRectangle).
+* **Return type:**
+ [*BackgroundRectangle*](manim.mobject.geometry.shape_matchers.BackgroundRectangle.md#manim.mobject.geometry.shape_matchers.BackgroundRectangle)
+
+### Examples
+
+
+
+#### get_horizontal_lines()
+
+Return the horizontal lines of the table.
+
+* **Returns:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) containing all the horizontal lines of the table.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+### Examples
+
+
+
+#### get_labels()
+
+Returns the labels of the table.
+
+* **Returns:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) containing all the labels of the table.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+### Examples
+
+
+
+#### get_rows()
+
+Return the rows of the table as a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) of [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup).
+
+* **Returns:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) containing each row in a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup).
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+### Examples
+
+
+
+#### get_vertical_lines()
+
+Return the vertical lines of the table.
+
+* **Returns:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) containing all the vertical lines of the table.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+### Examples
+
+
+
+#### scale(scale_factor, \*\*kwargs)
+
+Scale the size by a factor.
+
+Default behavior is to scale about the center of the vmobject.
+
+* **Parameters:**
+ * **scale_factor** (*float*) – The scaling factor $\alpha$. If $0 < |\alpha| < 1$, the mobject
+ will shrink, and for $|\alpha| > 1$ it will grow. Furthermore,
+ if $\alpha < 0$, the mobject is also flipped.
+ * **scale_stroke** – Boolean determining if the object’s outline is scaled when the object is scaled.
+ If enabled, and object with 2px outline is scaled by a factor of .5, it will have an outline of 1px.
+ * **kwargs** – Additional keyword arguments passed to
+ [`scale()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.scale).
+* **Returns:**
+ `self`
+* **Return type:**
+ `VMobject`
+
+### Examples
+
+
+
+#### SEE ALSO
+`move_to()`
+
+#### set_column_colors(\*colors)
+
+Set individual colors for each column of the table.
+
+* **Parameters:**
+ **colors** (*Iterable* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]*) – An iterable of colors; each color corresponds to a column.
+* **Return type:**
+ [*Table*](#manim.mobject.table.Table)
+
+### Examples
+
+
+
+#### set_row_colors(\*colors)
+
+Set individual colors for each row of the table.
+
+* **Parameters:**
+ **colors** (*Iterable* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]*) – An iterable of colors; each color corresponds to a row.
+* **Return type:**
+ [*Table*](#manim.mobject.table.Table)
+
+### Examples
+
+
+
+### Classes
+
+| [`DecimalTable`](manim.mobject.table.DecimalTable.md#manim.mobject.table.DecimalTable) | A specialized [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) mobject for use with [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber) to display decimal entries. |
+|------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`IntegerTable`](manim.mobject.table.IntegerTable.md#manim.mobject.table.IntegerTable) | A specialized [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) mobject for use with [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer). |
+| [`MathTable`](manim.mobject.table.MathTable.md#manim.mobject.table.MathTable) | A specialized [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) mobject for use with LaTeX. |
+| [`MobjectTable`](manim.mobject.table.MobjectTable.md#manim.mobject.table.MobjectTable) | A specialized [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) mobject for use with [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject). |
+| [`Table`](manim.mobject.table.Table.md#manim.mobject.table.Table) | A mobject that displays a table on the screen. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.code_mobject.Code.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.code_mobject.Code.md
new file mode 100644
index 0000000000000000000000000000000000000000..b833fe89a2c1f4bd17ecfdcc8b06467fc4e4b850
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.code_mobject.Code.md
@@ -0,0 +1,142 @@
+# Code
+
+Qualified name: `manim.mobject.text.code\_mobject.Code`
+
+### *class* Code(code_file=None, code_string=None, language=None, formatter_style='vim', tab_width=4, add_line_numbers=True, line_numbers_from=1, background='rectangle', background_config=None, paragraph_config=None)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A highlighted source code listing.
+
+### Examples
+
+Normal usage:
+
+```default
+listing = Code(
+ "helloworldcpp.cpp",
+ tab_width=4,
+ formatter_style="emacs",
+ background="window",
+ language="cpp",
+ background_config={"stroke_color": WHITE},
+ paragraph_config={"font": "Noto Sans Mono"},
+)
+```
+
+We can also render code passed as a string. As the automatic language
+detection can be a bit flaky, it is recommended to specify the language
+explicitly:
+
+
+* **Parameters:**
+ * **code_file** ([*StrPath*](manim.typing.md#manim.typing.StrPath) *|* *None*) – The path to the code file to display.
+ * **code_string** (*str* *|* *None*) – Alternatively, the code string to display.
+ * **language** (*str* *|* *None*) – The programming language of the code. If not specified, it will be
+ guessed from the file extension or the code itself.
+ * **formatter_style** (*str*) – The style to use for the code highlighting. Defaults to `"vim"`.
+ A list of all available styles can be obtained by calling
+ [`Code.get_styles_list()`](#manim.mobject.text.code_mobject.Code.get_styles_list).
+ * **tab_width** (*int*) – The width of a tab character in spaces. Defaults to 4.
+ * **add_line_numbers** (*bool*) – Whether to display line numbers. Defaults to `True`.
+ * **line_numbers_from** (*int*) – The first line number to display. Defaults to 1.
+ * **background** (*Literal* *[* *'rectangle'* *,* *'window'* *]*) – The type of background to use. Can be either `"rectangle"` (the
+ default) or `"window"`.
+ * **background_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) – Keyword arguments passed to the background constructor. Default
+ settings are stored in the class attribute
+ `default_background_config` (which can also be modified
+ directly).
+ * **paragraph_config** (*dict* *[**str* *,* *Any* *]* *|* *None*) – Keyword arguments passed to the constructor of the
+ [`Paragraph`](manim.mobject.text.text_mobject.Paragraph.md#manim.mobject.text.text_mobject.Paragraph) objects holding the code, and the line
+ numbers. Default settings are stored in the class attribute
+ `default_paragraph_config` (which can also be modified
+ directly).
+
+### Methods
+
+| [`get_styles_list`](#manim.mobject.text.code_mobject.Code.get_styles_list) | Get the list of all available formatter styles. |
+|------------------------------------------------------------------------------|---------------------------------------------------|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `default_background_config` | |
+| `default_paragraph_config` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(code_file=None, code_string=None, language=None, formatter_style='vim', tab_width=4, add_line_numbers=True, line_numbers_from=1, background='rectangle', background_config=None, paragraph_config=None)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **code_file** ([*StrPath*](manim.typing.md#manim.typing.StrPath) *|* *None*)
+ * **code_string** (*str* *|* *None*)
+ * **language** (*str* *|* *None*)
+ * **formatter_style** (*str*)
+ * **tab_width** (*int*)
+ * **add_line_numbers** (*bool*)
+ * **line_numbers_from** (*int*)
+ * **background** (*Literal* *[* *'rectangle'* *,* *'window'* *]*)
+ * **background_config** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+ * **paragraph_config** (*dict* *[**str* *,* *Any* *]* *|* *None*)
+
+#### *classmethod* get_styles_list()
+
+Get the list of all available formatter styles.
+
+* **Return type:**
+ list[str]
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.code_mobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.code_mobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..eedaf521ffeb56e27e4f83119d0cd13403060a5f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.code_mobject.md
@@ -0,0 +1,8 @@
+# code_mobject
+
+Mobject representing highlighted source code listings.
+
+### Classes
+
+| [`Code`](manim.mobject.text.code_mobject.Code.md#manim.mobject.text.code_mobject.Code) | A highlighted source code listing. |
+|------------------------------------------------------------------------------------------|--------------------------------------|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.md
new file mode 100644
index 0000000000000000000000000000000000000000..0ce13c944090d9cf0be7eaa34bc9b738b08ebbd3
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.md
@@ -0,0 +1,11 @@
+# text
+
+Mobjects used to display Text using Pango or LaTeX.
+
+## Modules
+
+| [`code_mobject`](manim.mobject.text.code_mobject.md#module-manim.mobject.text.code_mobject) | Mobject representing highlighted source code listings. |
+|-----------------------------------------------------------------------------------------------|----------------------------------------------------------|
+| [`numbers`](manim.mobject.text.numbers.md#module-manim.mobject.text.numbers) | Mobjects representing numbers. |
+| [`tex_mobject`](manim.mobject.text.tex_mobject.md#module-manim.mobject.text.tex_mobject) | Mobjects representing text rendered using LaTeX. |
+| [`text_mobject`](manim.mobject.text.text_mobject.md#module-manim.mobject.text.text_mobject) | Mobjects used for displaying (non-LaTeX) text. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.numbers.DecimalNumber.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.numbers.DecimalNumber.md
new file mode 100644
index 0000000000000000000000000000000000000000..29ade9b7422fc10244bdaa9ef1090b7cd28066ce
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.numbers.DecimalNumber.md
@@ -0,0 +1,150 @@
+# DecimalNumber
+
+Qualified name: `manim.mobject.text.numbers.DecimalNumber`
+
+### *class* DecimalNumber(number=0, num_decimal_places=2, mob_class=, include_sign=False, group_with_commas=True, digit_buff_per_font_unit=0.001, show_ellipsis=False, unit=None, unit_buff_per_font_unit=0, include_background_rectangle=False, edge_to_fix=array([-1., 0., 0.]), font_size=48, stroke_width=0, fill_opacity=1.0, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+An mobject representing a decimal number.
+
+* **Parameters:**
+ * **number** (*float*) – The numeric value to be displayed. It can later be modified using [`set_value()`](#manim.mobject.text.numbers.DecimalNumber.set_value).
+ * **num_decimal_places** (*int*) – The number of decimal places after the decimal separator. Values are automatically rounded.
+ * **mob_class** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The class for rendering digits and units, by default [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex).
+ * **include_sign** (*bool*) – Set to `True` to include a sign for positive numbers and zero.
+ * **group_with_commas** (*bool*) – When `True` thousands groups are separated by commas for readability.
+ * **digit_buff_per_font_unit** (*float*) – Additional spacing between digits. Scales with font size.
+ * **show_ellipsis** (*bool*) – When a number has been truncated by rounding, indicate with an ellipsis (`...`).
+ * **unit** (*str* *|* *None*) – A unit string which can be placed to the right of the numerical values.
+ * **unit_buff_per_font_unit** (*float*) – An additional spacing between the numerical values and the unit. A value
+ of `unit_buff_per_font_unit=0.003` gives a decent spacing. Scales with font size.
+ * **include_background_rectangle** (*bool*) – Adds a background rectangle to increase contrast on busy scenes.
+ * **edge_to_fix** (*Sequence* *[**float* *]*) – Assuring right- or left-alignment of the full object.
+ * **font_size** (*float*) – Size of the font.
+ * **stroke_width** (*float*)
+ * **fill_opacity** (*float*)
+
+### Examples
+
+
+
+### Methods
+
+| `get_value` | |
+|--------------------------------------------------------------------|----------------------------------------------------------------------------------------------------|
+| `increment_value` | |
+| [`set_value`](#manim.mobject.text.numbers.DecimalNumber.set_value) | Set the value of the [`DecimalNumber`](#manim.mobject.text.numbers.DecimalNumber) to a new number. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|--------------------------------------------------------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| [`font_size`](#manim.mobject.text.numbers.DecimalNumber.font_size) | The font size of the tex mobject. |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_get_formatter(\*\*kwargs)
+
+Configuration is based first off instance attributes,
+but overwritten by any kew word argument. Relevant
+key words:
+- include_sign
+- group_with_commas
+- num_decimal_places
+- field_name (e.g. 0 or 0.real)
+
+#### \_original_\_init_\_(number=0, num_decimal_places=2, mob_class=, include_sign=False, group_with_commas=True, digit_buff_per_font_unit=0.001, show_ellipsis=False, unit=None, unit_buff_per_font_unit=0, include_background_rectangle=False, edge_to_fix=array([-1., 0., 0.]), font_size=48, stroke_width=0, fill_opacity=1.0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **number** (*float*)
+ * **num_decimal_places** (*int*)
+ * **mob_class** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+ * **include_sign** (*bool*)
+ * **group_with_commas** (*bool*)
+ * **digit_buff_per_font_unit** (*float*)
+ * **show_ellipsis** (*bool*)
+ * **unit** (*str* *|* *None*)
+ * **unit_buff_per_font_unit** (*float*)
+ * **include_background_rectangle** (*bool*)
+ * **edge_to_fix** (*Sequence* *[**float* *]*)
+ * **font_size** (*float*)
+ * **stroke_width** (*float*)
+ * **fill_opacity** (*float*)
+
+#### *property* font_size
+
+The font size of the tex mobject.
+
+#### set_value(number)
+
+Set the value of the [`DecimalNumber`](#manim.mobject.text.numbers.DecimalNumber) to a new number.
+
+* **Parameters:**
+ **number** (*float*) – The value that will overwrite the current number of the [`DecimalNumber`](#manim.mobject.text.numbers.DecimalNumber).
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.numbers.Integer.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.numbers.Integer.md
new file mode 100644
index 0000000000000000000000000000000000000000..fe956d7c6702b4b9b7f3831b1e4cb82a54da7c2f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.numbers.Integer.md
@@ -0,0 +1,69 @@
+# Integer
+
+Qualified name: `manim.mobject.text.numbers.Integer`
+
+### *class* Integer(number=0, num_decimal_places=0, \*\*kwargs)
+
+Bases: [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber)
+
+A class for displaying Integers.
+
+### Examples
+
+
+
+### Methods
+
+| `get_value` | |
+|---------------|----|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `font_size` | The font size of the tex mobject. |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **number** (*float*)
+ * **num_decimal_places** (*int*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(number=0, num_decimal_places=0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **number** (*float*)
+ * **num_decimal_places** (*int*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.numbers.Variable.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.numbers.Variable.md
new file mode 100644
index 0000000000000000000000000000000000000000..651b11663e33c39b6c24519ce607a4765f47af0c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.numbers.Variable.md
@@ -0,0 +1,222 @@
+# Variable
+
+Qualified name: `manim.mobject.text.numbers.Variable`
+
+### *class* Variable(var, label, var_type=, num_decimal_places=2, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A class for displaying text that shows “label = value” with
+the value continuously updated from a [`ValueTracker`](manim.mobject.value_tracker.ValueTracker.md#manim.mobject.value_tracker.ValueTracker).
+
+* **Parameters:**
+ * **var** (*float*) – The initial value you need to keep track of and display.
+ * **label** (*str* *|* [*Tex*](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) *|* [*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) *|* [*Text*](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) *|* [*SingleStringMathTex*](manim.mobject.text.tex_mobject.SingleStringMathTex.md#manim.mobject.text.tex_mobject.SingleStringMathTex)) – The label for your variable. Raw strings are convertex to [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) objects.
+ * **var_type** ([*DecimalNumber*](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber) *|* [*Integer*](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer)) – The class used for displaying the number. Defaults to [`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber).
+ * **num_decimal_places** (*int*) – The number of decimal places to display in your variable. Defaults to 2.
+ If var_type is an [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer), this parameter is ignored.
+ * **kwargs** – Other arguments to be passed to ~.Mobject.
+
+#### label
+
+The label for your variable, for example `x = ...`.
+
+* **Type:**
+ Union[`str`, [`Tex`](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex), [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex), [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text), [`SingleStringMathTex`](manim.mobject.text.tex_mobject.SingleStringMathTex.md#manim.mobject.text.tex_mobject.SingleStringMathTex)]
+
+#### tracker
+
+Useful in updating the value of your variable on-screen.
+
+* **Type:**
+ [`ValueTracker`](manim.mobject.value_tracker.ValueTracker.md#manim.mobject.value_tracker.ValueTracker)
+
+#### value
+
+The tex for the value of your variable.
+
+* **Type:**
+ Union[[`DecimalNumber`](manim.mobject.text.numbers.DecimalNumber.md#manim.mobject.text.numbers.DecimalNumber), [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer)]
+
+### Examples
+
+Normal usage:
+
+```default
+# DecimalNumber type
+var = 0.5
+on_screen_var = Variable(var, Text("var"), num_decimal_places=3)
+# Integer type
+int_var = 0
+on_screen_int_var = Variable(int_var, Text("int_var"), var_type=Integer)
+# Using math mode for the label
+on_screen_int_var = Variable(int_var, "{a}_{i}", var_type=Integer)
+```
+
+
+```python
+from manim import *
+
+class VariablesWithValueTracker(Scene):
+ def construct(self):
+ var = 0.5
+ on_screen_var = Variable(var, Text("var"), num_decimal_places=3)
+
+ # You can also change the colours for the label and value
+ on_screen_var.label.set_color(RED)
+ on_screen_var.value.set_color(GREEN)
+
+ self.play(Write(on_screen_var))
+ # The above line will just display the variable with
+ # its initial value on the screen. If you also wish to
+ # update it, you can do so by accessing the `tracker` attribute
+ self.wait()
+ var_tracker = on_screen_var.tracker
+ var = 10.5
+ self.play(var_tracker.animate.set_value(var))
+ self.wait()
+
+ int_var = 0
+ on_screen_int_var = Variable(
+ int_var, Text("int_var"), var_type=Integer
+ ).next_to(on_screen_var, DOWN)
+ on_screen_int_var.label.set_color(RED)
+ on_screen_int_var.value.set_color(GREEN)
+
+ self.play(Write(on_screen_int_var))
+ self.wait()
+ var_tracker = on_screen_int_var.tracker
+ var = 10.5
+ self.play(var_tracker.animate.set_value(var))
+ self.wait()
+
+ # If you wish to have a somewhat more complicated label for your
+ # variable with subscripts, superscripts, etc. the default class
+ # for the label is MathTex
+ subscript_label_var = 10
+ on_screen_subscript_var = Variable(subscript_label_var, "{a}_{i}").next_to(
+ on_screen_int_var, DOWN
+ )
+ self.play(Write(on_screen_subscript_var))
+ self.wait()
+```
+
+
+class VariablesWithValueTracker(Scene):
+ def construct(self):
+ var = 0.5
+ on_screen_var = Variable(var, Text("var"), num_decimal_places=3)
+
+ # You can also change the colours for the label and value
+ on_screen_var.label.set_color(RED)
+ on_screen_var.value.set_color(GREEN)
+
+ self.play(Write(on_screen_var))
+ # The above line will just display the variable with
+ # its initial value on the screen. If you also wish to
+ # update it, you can do so by accessing the \`tracker\` attribute
+ self.wait()
+ var_tracker = on_screen_var.tracker
+ var = 10.5
+ self.play(var_tracker.animate.set_value(var))
+ self.wait()
+
+ int_var = 0
+ on_screen_int_var = Variable(
+ int_var, Text("int_var"), var_type=Integer
+ ).next_to(on_screen_var, DOWN)
+ on_screen_int_var.label.set_color(RED)
+ on_screen_int_var.value.set_color(GREEN)
+
+ self.play(Write(on_screen_int_var))
+ self.wait()
+ var_tracker = on_screen_int_var.tracker
+ var = 10.5
+ self.play(var_tracker.animate.set_value(var))
+ self.wait()
+
+ # If you wish to have a somewhat more complicated label for your
+ # variable with subscripts, superscripts, etc. the default class
+ # for the label is MathTex
+ subscript_label_var = 10
+ on_screen_subscript_var = Variable(subscript_label_var, "{a}_{i}").next_to(
+ on_screen_int_var, DOWN
+ )
+ self.play(Write(on_screen_subscript_var))
+ self.wait()
+
+
+
+### Methods
+
+| `fade_all_but` | |
+|------------------|----|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `font_size` | The font size of the tex mobject. |
+| `hash_seed` | A unique hash representing the result of the generated mobject points. |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*items, buff=0.5, dot_scale_factor=2, tex_environment=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.MathTex.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.MathTex.md
new file mode 100644
index 0000000000000000000000000000000000000000..7c317d68dc123d42a81f4b33eeb2e53bff02204d
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.MathTex.md
@@ -0,0 +1,110 @@
+# MathTex
+
+Qualified name: `manim.mobject.text.tex\_mobject.MathTex`
+
+### *class* MathTex(\*tex_strings, arg_separator=' ', substrings_to_isolate=None, tex_to_color_map=None, tex_environment='align\*', \*\*kwargs)
+
+Bases: [`SingleStringMathTex`](manim.mobject.text.tex_mobject.SingleStringMathTex.md#manim.mobject.text.tex_mobject.SingleStringMathTex)
+
+A string compiled with LaTeX in math mode.
+
+### Examples
+
+
+
+### Tests
+
+Check that creating a [`MathTex`](#manim.mobject.text.tex_mobject.MathTex) works:
+
+```default
+>>> MathTex('a^2 + b^2 = c^2')
+MathTex('a^2 + b^2 = c^2')
+```
+
+Check that double brace group splitting works correctly:
+
+```default
+>>> t1 = MathTex('{{ a }} + {{ b }} = {{ c }}')
+>>> len(t1.submobjects)
+5
+>>> t2 = MathTex(r"\frac{1}{a+b\sqrt{2}}")
+>>> len(t2.submobjects)
+1
+```
+
+### Methods
+
+| `get_part_by_tex` | |
+|------------------------------------------------------------------------------------|----------------------------------------|
+| `get_parts_by_tex` | |
+| `index_of_part` | |
+| `index_of_part_by_tex` | |
+| `set_color_by_tex` | |
+| `set_color_by_tex_to_color_map` | |
+| [`set_opacity_by_tex`](#manim.mobject.text.tex_mobject.MathTex.set_opacity_by_tex) | Sets the opacity of the tex specified. |
+| `sort_alphabetically` | |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `font_size` | The font size of the tex mobject. |
+| `hash_seed` | A unique hash representing the result of the generated mobject points. |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **arg_separator** (*str*)
+ * **substrings_to_isolate** (*Iterable* *[**str* *]* *|* *None*)
+ * **tex_to_color_map** (*dict* *[**str* *,* [*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) *]*)
+ * **tex_environment** (*str*)
+
+#### \_break_up_by_substrings()
+
+Reorganize existing submobjects one layer
+deeper based on the structure of tex_strings (as a list
+of tex_strings)
+
+#### \_original_\_init_\_(\*tex_strings, arg_separator=' ', substrings_to_isolate=None, tex_to_color_map=None, tex_environment='align\*', \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **arg_separator** (*str*)
+ * **substrings_to_isolate** (*Iterable* *[**str* *]* *|* *None*)
+ * **tex_to_color_map** (*dict* *[**str* *,* [*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) *]*)
+ * **tex_environment** (*str*)
+
+#### set_opacity_by_tex(tex, opacity=0.5, remaining_opacity=None, \*\*kwargs)
+
+Sets the opacity of the tex specified. If ‘remaining_opacity’ is specified,
+then the remaining tex will be set to that opacity.
+
+* **Parameters:**
+ * **tex** (*str*) – The tex to set the opacity of.
+ * **opacity** (*float*) – Default 0.5. The opacity to set the tex to
+ * **remaining_opacity** (*float*) – Default None. The opacity to set the remaining tex to.
+ If None, then the remaining tex will not be changed
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.SingleStringMathTex.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.SingleStringMathTex.md
new file mode 100644
index 0000000000000000000000000000000000000000..6541f3eb3689051a8f24b41a4ca685dcdcfcb561
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.SingleStringMathTex.md
@@ -0,0 +1,83 @@
+# SingleStringMathTex
+
+Qualified name: `manim.mobject.text.tex\_mobject.SingleStringMathTex`
+
+### *class* SingleStringMathTex(tex_string, stroke_width=0, should_center=True, height=None, organize_left_to_right=False, tex_environment='align\*', tex_template=None, font_size=48, color=None, \*\*kwargs)
+
+Bases: [`SVGMobject`](manim.mobject.svg.svg_mobject.SVGMobject.md#manim.mobject.svg.svg_mobject.SVGMobject)
+
+Elementary building block for rendering text with LaTeX.
+
+### Tests
+
+Check that creating a [`SingleStringMathTex`](#manim.mobject.text.tex_mobject.SingleStringMathTex) object works:
+
+```default
+>>> SingleStringMathTex('Test')
+SingleStringMathTex('Test')
+```
+
+### Methods
+
+| `get_tex_string` | |
+|----------------------------------------------------------------------------------|-------------------------|
+| [`init_colors`](#manim.mobject.text.tex_mobject.SingleStringMathTex.init_colors) | Initializes the colors. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|------------------------------------------------------------------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| [`font_size`](#manim.mobject.text.tex_mobject.SingleStringMathTex.font_size) | The font size of the tex mobject. |
+| `hash_seed` | A unique hash representing the result of the generated mobject points. |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **tex_string** (*str*)
+ * **stroke_width** (*float*)
+ * **should_center** (*bool*)
+ * **height** (*float* *|* *None*)
+ * **organize_left_to_right** (*bool*)
+ * **tex_environment** (*str*)
+ * **tex_template** ([*TexTemplate*](manim.utils.tex.TexTemplate.md#manim.utils.tex.TexTemplate) *|* *None*)
+ * **font_size** (*float*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+
+#### \_original_\_init_\_(tex_string, stroke_width=0, should_center=True, height=None, organize_left_to_right=False, tex_environment='align\*', tex_template=None, font_size=48, color=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **tex_string** (*str*)
+ * **stroke_width** (*float*)
+ * **should_center** (*bool*)
+ * **height** (*float* *|* *None*)
+ * **organize_left_to_right** (*bool*)
+ * **tex_environment** (*str*)
+ * **tex_template** ([*TexTemplate*](manim.utils.tex.TexTemplate.md#manim.utils.tex.TexTemplate) *|* *None*)
+ * **font_size** (*float*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+
+#### \_remove_stray_braces(tex)
+
+Makes [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) resilient to unmatched braces.
+
+This is important when the braces in the TeX code are spread over
+multiple arguments as in, e.g., `MathTex(r"e^{i", r"\tau} = 1")`.
+
+#### *property* font_size
+
+The font size of the tex mobject.
+
+#### init_colors(propagate_colors=True)
+
+Initializes the colors.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.Tex.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.Tex.md
new file mode 100644
index 0000000000000000000000000000000000000000..bbb3073dd206b8d9b75b7a1ac5cba225d2c1d060
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.Tex.md
@@ -0,0 +1,44 @@
+# Tex
+
+Qualified name: `manim.mobject.text.tex\_mobject.Tex`
+
+### *class* Tex(\*tex_strings, arg_separator='', tex_environment='center', \*\*kwargs)
+
+Bases: [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex)
+
+A string compiled with LaTeX in normal mode.
+
+The color can be set using
+the `color` argument. Any parts of the `tex_string` that are colored by the
+TeX commands `\color` or `\textcolor` will retain their original color.
+
+### Tests
+
+Check whether writing a LaTeX string works:
+
+```default
+>>> Tex('The horse does not eat cucumber salad.')
+Tex('The horse does not eat cucumber salad.')
+```
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `font_size` | The font size of the tex mobject. |
+| `hash_seed` | A unique hash representing the result of the generated mobject points. |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*tex_strings, arg_separator='', tex_environment='center', \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.Title.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.Title.md
new file mode 100644
index 0000000000000000000000000000000000000000..441842141b210efab96b2af0bee0a2c1097ab84c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.Title.md
@@ -0,0 +1,58 @@
+# Title
+
+Qualified name: `manim.mobject.text.tex\_mobject.Title`
+
+### *class* Title(\*text_parts, include_underline=True, match_underline_width_to_text=False, underline_buff=0.25, \*\*kwargs)
+
+Bases: [`Tex`](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex)
+
+A mobject representing an underlined title.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `font_size` | The font size of the tex mobject. |
+| `hash_seed` | A unique hash representing the result of the generated mobject points. |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*text_parts, include_underline=True, match_underline_width_to_text=False, underline_buff=0.25, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..780a236c85c7115b63da4257d52e05e772badfd4
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.tex_mobject.md
@@ -0,0 +1,18 @@
+# tex_mobject
+
+Mobjects representing text rendered using LaTeX.
+
+#### IMPORTANT
+See the corresponding tutorial [Text With LaTeX](../guides/using_text.md#rendering-with-latex)
+
+#### NOTE
+Just as you can use [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) (from the module [`text_mobject`](manim.mobject.text.text_mobject.md#module-manim.mobject.text.text_mobject)) to add text to your videos, you can use [`Tex`](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) and [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) to insert LaTeX.
+
+### Classes
+
+| [`BulletedList`](manim.mobject.text.tex_mobject.BulletedList.md#manim.mobject.text.tex_mobject.BulletedList) | A bulleted list. |
+|-----------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------|
+| [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) | A string compiled with LaTeX in math mode. |
+| [`SingleStringMathTex`](manim.mobject.text.tex_mobject.SingleStringMathTex.md#manim.mobject.text.tex_mobject.SingleStringMathTex) | Elementary building block for rendering text with LaTeX. |
+| [`Tex`](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) | A string compiled with LaTeX in normal mode. |
+| [`Title`](manim.mobject.text.tex_mobject.Title.md#manim.mobject.text.tex_mobject.Title) | A mobject representing an underlined title. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.text_mobject.MarkupText.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.text_mobject.MarkupText.md
new file mode 100644
index 0000000000000000000000000000000000000000..61fa7949c61b9f5746606eb65d8ce68372628cb9
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.text_mobject.MarkupText.md
@@ -0,0 +1,577 @@
+# MarkupText
+
+Qualified name: `manim.mobject.text.text\_mobject.MarkupText`
+
+### *class* MarkupText(text, fill_opacity=1, stroke_width=0, color=None, font_size=48, line_spacing=-1, font='', slant='NORMAL', weight='NORMAL', justify=False, gradient=None, tab_width=4, height=None, width=None, should_center=True, disable_ligatures=False, warn_missing_font=True, \*\*kwargs)
+
+Bases: [`SVGMobject`](manim.mobject.svg.svg_mobject.SVGMobject.md#manim.mobject.svg.svg_mobject.SVGMobject)
+
+Display (non-LaTeX) text rendered using [Pango](https://pango.gnome.org/).
+
+Text objects behave like a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)-like iterable of all characters
+in the given text. In particular, slicing is possible.
+
+**What is PangoMarkup?**
+
+PangoMarkup is a small markup language like html and it helps you avoid using
+“range of characters” while coloring or styling a piece a Text. You can use
+this language with [`MarkupText`](#manim.mobject.text.text_mobject.MarkupText).
+
+A simple example of a marked-up string might be:
+
+```default
+Blue text is cool!"
+```
+
+and it can be used with [`MarkupText`](#manim.mobject.text.text_mobject.MarkupText) as
+
+
+```python
+from manim import *
+
+class JustifyText(Scene):
+ def construct(self):
+ ipsum_text = (
+ "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
+ "Praesent feugiat metus sit amet iaculis pulvinar. Nulla posuere "
+ "quam a ex aliquam, eleifend consectetur tellus viverra. Aliquam "
+ "fermentum interdum justo, nec rutrum elit pretium ac. Nam quis "
+ "leo pulvinar, dignissim est at, venenatis nisi."
+ )
+ justified_text = MarkupText(ipsum_text, justify=True).scale(0.4)
+ not_justified_text = MarkupText(ipsum_text, justify=False).scale(0.4)
+ just_title = Title("Justified")
+ njust_title = Title("Not Justified")
+ self.add(njust_title, not_justified_text)
+ self.play(
+ FadeOut(not_justified_text),
+ FadeIn(justified_text),
+ FadeOut(njust_title),
+ FadeIn(just_title),
+ )
+ self.wait(1)
+```
+
+
+class JustifyText(Scene):
+ def construct(self):
+ ipsum_text = (
+ "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
+ "Praesent feugiat metus sit amet iaculis pulvinar. Nulla posuere "
+ "quam a ex aliquam, eleifend consectetur tellus viverra. Aliquam "
+ "fermentum interdum justo, nec rutrum elit pretium ac. Nam quis "
+ "leo pulvinar, dignissim est at, venenatis nisi."
+ )
+ justified_text = MarkupText(ipsum_text, justify=True).scale(0.4)
+ not_justified_text = MarkupText(ipsum_text, justify=False).scale(0.4)
+ just_title = Title("Justified")
+ njust_title = Title("Not Justified")
+ self.add(njust_title, not_justified_text)
+ self.play(
+ FadeOut(not_justified_text),
+ FadeIn(justified_text),
+ FadeOut(njust_title),
+ FadeIn(just_title),
+ )
+ self.wait(1)
+
+
+
+### Tests
+
+Check that the creation of [`MarkupText`](#manim.mobject.text.text_mobject.MarkupText) works:
+
+```default
+>>> MarkupText('The horse does not eat cucumber salad.')
+MarkupText('The horse does not eat cucumber salad.')
+```
+
+### Methods
+
+| `font_list` | |
+|---------------|----|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `font_size` | |
+| `hash_seed` | A unique hash representing the result of the generated mobject points. |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_count_real_chars(s)
+
+Counts characters that will be displayed.
+
+This is needed for partial coloring or gradients, because space
+counts to the text’s len, but has no corresponding character.
+
+#### \_extract_color_tags()
+
+Used to determine which parts (if any) of the string should be formatted
+with a custom color.
+
+Removes the `` tag, as it is not part of Pango’s markup and would cause an error.
+
+Note: Using the `` tags is deprecated. As soon as the legacy syntax is gone, this function
+will be removed.
+
+#### \_extract_gradient_tags()
+
+Used to determine which parts (if any) of the string should be formatted
+with a gradient.
+
+Removes the `` tag, as it is not part of Pango’s markup and would cause an error.
+
+#### \_original_\_init_\_(text, fill_opacity=1, stroke_width=0, color=None, font_size=48, line_spacing=-1, font='', slant='NORMAL', weight='NORMAL', justify=False, gradient=None, tab_width=4, height=None, width=None, should_center=True, disable_ligatures=False, warn_missing_font=True, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **text** (*str*)
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **font_size** (*float*)
+ * **line_spacing** (*int*)
+ * **font** (*str*)
+ * **slant** (*str*)
+ * **weight** (*str*)
+ * **justify** (*bool*)
+ * **gradient** (*tuple*)
+ * **tab_width** (*int*)
+ * **height** (*int*)
+ * **width** (*int*)
+ * **should_center** (*bool*)
+ * **disable_ligatures** (*bool*)
+ * **warn_missing_font** (*bool*)
+* **Return type:**
+ None
+
+#### \_parse_color(col)
+
+Parse color given in `` or `` tags.
+
+#### \_text2hash(color)
+
+Generates `sha256` hash for file name.
+
+* **Parameters:**
+ **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+
+#### \_text2svg(color)
+
+Convert the text to SVG using Pango.
+
+* **Parameters:**
+ **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.text_mobject.Paragraph.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.text_mobject.Paragraph.md
new file mode 100644
index 0000000000000000000000000000000000000000..0bd3541f49bdb92114d80e72c5647b73f906f0e1
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.text_mobject.Paragraph.md
@@ -0,0 +1,126 @@
+# Paragraph
+
+Qualified name: `manim.mobject.text.text\_mobject.Paragraph`
+
+### *class* Paragraph(\*text, line_spacing=-1, alignment=None, \*\*kwargs)
+
+Bases: [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+Display a paragraph of text.
+
+For a given [`Paragraph`](#manim.mobject.text.text_mobject.Paragraph) `par`, the attribute `par.chars` is a
+[`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) containing all the lines. In this context, every line is
+constructed as a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) of characters contained in the line.
+
+* **Parameters:**
+ * **line_spacing** (*float*) – Represents the spacing between lines. Defaults to -1, which means auto.
+ * **alignment** (*str* *|* *None*) – Defines the alignment of paragraph. Defaults to None. Possible values are “left”, “right” or “center”.
+ * **text** (*Sequence* *[**str* *]*)
+
+### Examples
+
+Normal usage:
+
+```default
+paragraph = Paragraph(
+ "this is a awesome",
+ "paragraph",
+ "With \nNewlines",
+ "\tWith Tabs",
+ " With Spaces",
+ "With Alignments",
+ "center",
+ "left",
+ "right",
+)
+```
+
+Remove unwanted invisible characters:
+
+```default
+self.play(Transform(remove_invisible_chars(paragraph.chars[0:2]),
+ remove_invisible_chars(paragraph.chars[3][0:3]))
+```
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_change_alignment_for_a_line(alignment, line_no)
+
+Function to change one line’s alignment to a specific value.
+
+* **Parameters:**
+ * **alignment** (*str*) – Defines the alignment of paragraph. Possible values are “left”, “right”, “center”.
+ * **line_no** (*int*) – Defines the line number for which we want to set given alignment.
+* **Return type:**
+ None
+
+#### \_gen_chars(lines_str_list)
+
+Function to convert a list of plain strings to a VGroup of VGroups of chars.
+
+* **Parameters:**
+ **lines_str_list** (*list*) – List of plain text strings.
+* **Returns:**
+ The generated 2d-VGroup of chars.
+* **Return type:**
+ [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+#### \_original_\_init_\_(\*text, line_spacing=-1, alignment=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **text** (*Sequence* *[**str* *]*)
+ * **line_spacing** (*float*)
+ * **alignment** (*str* *|* *None*)
+* **Return type:**
+ None
+
+#### \_set_all_lines_alignments(alignment)
+
+Function to set all line’s alignment to a specific value.
+
+* **Parameters:**
+ **alignment** (*str*) – Defines the alignment of paragraph. Possible values are “left”, “right”, “center”.
+* **Return type:**
+ [*Paragraph*](#manim.mobject.text.text_mobject.Paragraph)
+
+#### \_set_all_lines_to_initial_positions()
+
+Set all lines to their initial positions.
+
+* **Return type:**
+ [*Paragraph*](#manim.mobject.text.text_mobject.Paragraph)
+
+#### \_set_line_alignment(alignment, line_no)
+
+Function to set one line’s alignment to a specific value.
+
+* **Parameters:**
+ * **alignment** (*str*) – Defines the alignment of paragraph. Possible values are “left”, “right”, “center”.
+ * **line_no** (*int*) – Defines the line number for which we want to set given alignment.
+* **Return type:**
+ [*Paragraph*](#manim.mobject.text.text_mobject.Paragraph)
+
+#### \_set_line_to_initial_position(line_no)
+
+Function to set one line to initial positions.
+
+* **Parameters:**
+ **line_no** (*int*) – Defines the line number for which we want to set given alignment.
+* **Return type:**
+ [*Paragraph*](#manim.mobject.text.text_mobject.Paragraph)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.text_mobject.Text.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.text_mobject.Text.md
new file mode 100644
index 0000000000000000000000000000000000000000..f58f93f544fe60fac379b0e1e2efa36ee7d47473
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.text_mobject.Text.md
@@ -0,0 +1,332 @@
+# Text
+
+Qualified name: `manim.mobject.text.text\_mobject.Text`
+
+### *class* Text(text, fill_opacity=1.0, stroke_width=0, \*, color=ManimColor('#FFFFFF'), font_size=48, line_spacing=-1, font='', slant='NORMAL', weight='NORMAL', t2c=None, t2f=None, t2g=None, t2s=None, t2w=None, gradient=None, tab_width=4, warn_missing_font=True, height=None, width=None, should_center=True, disable_ligatures=False, use_svg_cache=False, \*\*kwargs)
+
+Bases: [`SVGMobject`](manim.mobject.svg.svg_mobject.SVGMobject.md#manim.mobject.svg.svg_mobject.SVGMobject)
+
+Display (non-LaTeX) text rendered using [Pango](https://pango.gnome.org/).
+
+Text objects behave like a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)-like iterable of all characters
+in the given text. In particular, slicing is possible.
+
+* **Parameters:**
+ * **text** (*str*) – The text that needs to be created as a mobject.
+ * **font** (*str*) – The font family to be used to render the text. This is either a system font or
+ one loaded with register_font(). Note that font family names may be different
+ across operating systems.
+ * **warn_missing_font** (*bool*) – If True (default), Manim will issue a warning if the font does not exist in the
+ (case-sensitive) list of fonts returned from manimpango.list_fonts().
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **font_size** (*float*)
+ * **line_spacing** (*float*)
+ * **slant** (*str*)
+ * **weight** (*str*)
+ * **t2c** (*dict* *[**str* *,* *str* *]*)
+ * **t2f** (*dict* *[**str* *,* *str* *]*)
+ * **t2g** (*dict* *[**str* *,* *tuple* *]*)
+ * **t2s** (*dict* *[**str* *,* *str* *]*)
+ * **t2w** (*dict* *[**str* *,* *str* *]*)
+ * **gradient** (*tuple*)
+ * **tab_width** (*int*)
+ * **height** (*float*)
+ * **width** (*float*)
+ * **should_center** (*bool*)
+ * **disable_ligatures** (*bool*)
+ * **use_svg_cache** (*bool*)
+* **Returns:**
+ The mobject-like [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup).
+* **Return type:**
+ [`Text`](#manim.mobject.text.text_mobject.Text)
+
+### Examples
+
+
+
+### Tests
+
+Check that the creation of [`Text`](#manim.mobject.text.text_mobject.Text) works:
+
+```default
+>>> Text('The horse does not eat cucumber salad.')
+Text('The horse does not eat cucumber salad.')
+```
+
+### Methods
+
+| `font_list` | |
+|--------------------------------------------------------------------|-------------------------|
+| [`init_colors`](#manim.mobject.text.text_mobject.Text.init_colors) | Initializes the colors. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `font_size` | |
+| `hash_seed` | A unique hash representing the result of the generated mobject points. |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_find_indexes(word, text)
+
+Finds the indexes of `text` in `word`.
+
+* **Parameters:**
+ * **word** (*str*)
+ * **text** (*str*)
+
+#### \_original_\_init_\_(text, fill_opacity=1.0, stroke_width=0, color=None, font_size=48, line_spacing=-1, font='', slant='NORMAL', weight='NORMAL', t2c=None, t2f=None, t2g=None, t2s=None, t2w=None, gradient=None, tab_width=4, warn_missing_font=True, height=None, width=None, should_center=True, disable_ligatures=False, use_svg_cache=False, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **text** (*str*)
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **font_size** (*float*)
+ * **line_spacing** (*float*)
+ * **font** (*str*)
+ * **slant** (*str*)
+ * **weight** (*str*)
+ * **t2c** (*dict* *[**str* *,* *str* *]*)
+ * **t2f** (*dict* *[**str* *,* *str* *]*)
+ * **t2g** (*dict* *[**str* *,* *tuple* *]*)
+ * **t2s** (*dict* *[**str* *,* *str* *]*)
+ * **t2w** (*dict* *[**str* *,* *str* *]*)
+ * **gradient** (*tuple*)
+ * **tab_width** (*int*)
+ * **warn_missing_font** (*bool*)
+ * **height** (*float*)
+ * **width** (*float*)
+ * **should_center** (*bool*)
+ * **disable_ligatures** (*bool*)
+ * **use_svg_cache** (*bool*)
+* **Return type:**
+ None
+
+#### \_set_color_by_t2c(t2c=None)
+
+Sets color for specified strings.
+
+#### ATTENTION
+Deprecated
+The method Text._set_color_by_t2c has been deprecated since v0.14.0 and is expected to be removed after v0.15.0. This was internal function, you shouldn’t be using it anyway.
+
+#### \_set_color_by_t2g(t2g=None)
+
+Sets gradient colors for specified
+: strings. Behaves similarly to `set_color_by_t2c`.
+
+#### ATTENTION
+Deprecated
+The method Text._set_color_by_t2g has been deprecated since v0.14.0 and is expected to be removed after v0.15.0. This was internal function, you shouldn’t be using it anyway.
+
+#### \_text2hash(color)
+
+Generates `sha256` hash for file name.
+
+* **Parameters:**
+ **color** ([*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor))
+
+#### \_text2settings(color)
+
+Converts the texts and styles to a setting for parsing.
+
+* **Parameters:**
+ **color** (*str*)
+
+#### \_text2svg(color)
+
+Convert the text to SVG using Pango.
+
+* **Parameters:**
+ **color** ([*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor))
+
+#### init_colors(propagate_colors=True)
+
+Initializes the colors.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.text_mobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.text_mobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..be6b5b7a43e939173bd35a92507640094c827497
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.text.text_mobject.md
@@ -0,0 +1,131 @@
+# text_mobject
+
+Mobjects used for displaying (non-LaTeX) text.
+
+#### NOTE
+Just as you can use [`Tex`](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex) and [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) (from the module [`tex_mobject`](manim.mobject.text.tex_mobject.md#module-manim.mobject.text.tex_mobject))
+to insert LaTeX to your videos, you can use [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) to to add normal text.
+
+#### IMPORTANT
+See the corresponding tutorial [Text Without LaTeX](../guides/using_text.md#using-text-objects), especially for information about fonts.
+
+The simplest way to add text to your animations is to use the [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) class. It uses the Pango library to render text.
+With Pango, you are also able to render non-English alphabets like 你好 or こんにちは or 안녕하세요 or مرحبا بالعالم.
+
+### Examples
+
+
+
+### Classes
+
+| [`MarkupText`](manim.mobject.text.text_mobject.MarkupText.md#manim.mobject.text.text_mobject.MarkupText) | Display (non-LaTeX) text rendered using [Pango](https://pango.gnome.org/). |
+|------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------|
+| [`Paragraph`](manim.mobject.text.text_mobject.Paragraph.md#manim.mobject.text.text_mobject.Paragraph) | Display a paragraph of text. |
+| [`Text`](manim.mobject.text.text_mobject.Text.md#manim.mobject.text.text_mobject.Text) | |
+
+### Functions
+
+### register_font(font_file)
+
+Temporarily add a font file to Pango’s search path.
+
+This searches for the font_file at various places. The order it searches it described below.
+
+1. Absolute path.
+2. In `assets/fonts` folder.
+3. In `font/` folder.
+4. In the same directory.
+
+* **Parameters:**
+ **font_file** (*str* *|* *Path*) – The font file to add.
+
+### Examples
+
+Use `with register_font(...)` to add a font file to search
+path.
+
+```python
+with register_font("path/to/font_file.ttf"):
+ a = Text("Hello", font="Custom Font Name")
+```
+
+* **Raises:**
+ * **FileNotFoundError:** – If the font doesn’t exists.
+ * **AttributeError:** – If this method is used on macOS.
+ * **.. important ::** – This method is available for macOS for `ManimPango>=v0.2.3`. Using this
+ method with previous releases will raise an `AttributeError` on macOS.
+* **Parameters:**
+ **font_file** (*str* *|* *Path*)
+
+### remove_invisible_chars(mobject)
+
+Function to remove unwanted invisible characters from some mobjects.
+
+* **Parameters:**
+ **mobject** ([*SVGMobject*](manim.mobject.svg.svg_mobject.SVGMobject.md#manim.mobject.svg.svg_mobject.SVGMobject)) – Any SVGMobject from which we want to remove unwanted invisible characters.
+* **Returns:**
+ The SVGMobject without unwanted invisible characters.
+* **Return type:**
+ [`SVGMobject`](manim.mobject.svg.svg_mobject.SVGMobject.md#manim.mobject.svg.svg_mobject.SVGMobject)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.md
new file mode 100644
index 0000000000000000000000000000000000000000..8153c3f35aaa41772348775acb3aab14fdd0372f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.md
@@ -0,0 +1,10 @@
+# three_d
+
+Three-dimensional mobjects.
+
+## Modules
+
+| [`polyhedra`](manim.mobject.three_d.polyhedra.md#module-manim.mobject.three_d.polyhedra) | General polyhedral class and platonic solids. |
+|---------------------------------------------------------------------------------------------------------------|---------------------------------------------------|
+| [`three_d_utils`](manim.mobject.three_d.three_d_utils.md#module-manim.mobject.three_d.three_d_utils) | Utility functions for three-dimensional mobjects. |
+| [`three_dimensions`](manim.mobject.three_d.three_dimensions.md#module-manim.mobject.three_d.three_dimensions) | Three-dimensional mobjects. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.ConvexHull3D.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.ConvexHull3D.md
new file mode 100644
index 0000000000000000000000000000000000000000..16bfe20baf1dc20104e3246ba5037f95c1c778f8
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.ConvexHull3D.md
@@ -0,0 +1,121 @@
+# ConvexHull3D
+
+Qualified name: `manim.mobject.three\_d.polyhedra.ConvexHull3D`
+
+### *class* ConvexHull3D(\*points, tolerance=1e-05, \*\*kwargs)
+
+Bases: [`Polyhedron`](manim.mobject.three_d.polyhedra.Polyhedron.md#manim.mobject.three_d.polyhedra.Polyhedron)
+
+A convex hull for a set of points
+
+* **Parameters:**
+ * **points** ([*Point3D*](manim.typing.md#manim.typing.Point3D)) – The points to consider.
+ * **tolerance** (*float*) – The tolerance used for quickhull.
+ * **kwargs** – Forwarded to the parent constructor.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(\*points, tolerance=1e-05, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **points** ([*Point3D*](manim.typing.md#manim.typing.Point3D))
+ * **tolerance** (*float*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.Dodecahedron.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.Dodecahedron.md
new file mode 100644
index 0000000000000000000000000000000000000000..6d4f16304d1f1030f7e9a8a378f5871900153c52
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.Dodecahedron.md
@@ -0,0 +1,58 @@
+# Dodecahedron
+
+Qualified name: `manim.mobject.three\_d.polyhedra.Dodecahedron`
+
+### *class* Dodecahedron(edge_length=1, \*\*kwargs)
+
+Bases: [`Polyhedron`](manim.mobject.three_d.polyhedra.Polyhedron.md#manim.mobject.three_d.polyhedra.Polyhedron)
+
+A dodecahedron, one of the five platonic solids. It has 12 faces, 30 edges and 20 vertices.
+
+* **Parameters:**
+ **edge_length** (*float*) – The length of an edge between any two vertices.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(edge_length=1, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **edge_length** (*float*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.Icosahedron.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.Icosahedron.md
new file mode 100644
index 0000000000000000000000000000000000000000..0687d47e725b971e8c69a6900a23a1d18ef7c015
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.Icosahedron.md
@@ -0,0 +1,58 @@
+# Icosahedron
+
+Qualified name: `manim.mobject.three\_d.polyhedra.Icosahedron`
+
+### *class* Icosahedron(edge_length=1, \*\*kwargs)
+
+Bases: [`Polyhedron`](manim.mobject.three_d.polyhedra.Polyhedron.md#manim.mobject.three_d.polyhedra.Polyhedron)
+
+An icosahedron, one of the five platonic solids. It has 20 faces, 30 edges and 12 vertices.
+
+* **Parameters:**
+ **edge_length** (*float*) – The length of an edge between any two vertices.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(edge_length=1, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **edge_length** (*float*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.Octahedron.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.Octahedron.md
new file mode 100644
index 0000000000000000000000000000000000000000..b60eb3fd47a596b87d5738c7cd222d25cb309912
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.Octahedron.md
@@ -0,0 +1,58 @@
+# Octahedron
+
+Qualified name: `manim.mobject.three\_d.polyhedra.Octahedron`
+
+### *class* Octahedron(edge_length=1, \*\*kwargs)
+
+Bases: [`Polyhedron`](manim.mobject.three_d.polyhedra.Polyhedron.md#manim.mobject.three_d.polyhedra.Polyhedron)
+
+An octahedron, one of the five platonic solids. It has 8 faces, 12 edges and 6 vertices.
+
+* **Parameters:**
+ **edge_length** (*float*) – The length of an edge between any two vertices.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(edge_length=1, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **edge_length** (*float*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.Polyhedron.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.Polyhedron.md
new file mode 100644
index 0000000000000000000000000000000000000000..2b1940a2f99b539d56133aa4b183185703064481
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.Polyhedron.md
@@ -0,0 +1,166 @@
+# Polyhedron
+
+Qualified name: `manim.mobject.three\_d.polyhedra.Polyhedron`
+
+### *class* Polyhedron(vertex_coords, faces_list, faces_config={}, graph_config={})
+
+Bases: [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+An abstract polyhedra class.
+
+In this implementation, polyhedra are defined with a list of vertex coordinates in space, and a list
+of faces. This implementation mirrors that of a standard polyhedral data format (OFF, object file format).
+
+* **Parameters:**
+ * **vertex_coords** (*list* *[**list* *[**float* *]* *|* *np.ndarray* *]*) – A list of coordinates of the corresponding vertices in the polyhedron. Each coordinate will correspond to
+ a vertex. The vertices are indexed with the usual indexing of Python.
+ * **faces_list** (*list* *[**list* *[**int* *]* *]*) – A list of faces. Each face is a sublist containing the indices of the vertices that form the corners of that face.
+ * **faces_config** (*dict* *[**str* *,* *str* *|* *int* *|* *float* *|* *bool* *]*) – Configuration for the polygons representing the faces of the polyhedron.
+ * **graph_config** (*dict* *[**str* *,* *str* *|* *int* *|* *float* *|* *bool* *]*) – Configuration for the graph containing the vertices and edges of the polyhedron.
+
+### Examples
+
+To understand how to create a custom polyhedra, let’s use the example of a rather simple one - a square pyramid.
+
+
+
+In defining the polyhedron above, we first defined the coordinates of the vertices.
+These are the corners of the square base, given as the first four coordinates in the vertex list,
+and the apex, the last coordinate in the list.
+
+Next, we define the faces of the polyhedron. The triangular surfaces of the pyramid are polygons
+with two adjacent vertices in the base and the vertex at the apex as corners. We thus define these
+surfaces in the first four elements of our face list. The last element defines the base of the pyramid.
+
+The graph and faces of polyhedra can also be accessed and modified directly, after instantiation.
+They are stored in the graph and faces attributes respectively.
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(edge_length=1, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **edge_length** (*float*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.md
new file mode 100644
index 0000000000000000000000000000000000000000..cf5949d61f2d7199cb44eafe8f7495e0efa44d97
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.polyhedra.md
@@ -0,0 +1,13 @@
+# polyhedra
+
+General polyhedral class and platonic solids.
+
+### Classes
+
+| [`ConvexHull3D`](manim.mobject.three_d.polyhedra.ConvexHull3D.md#manim.mobject.three_d.polyhedra.ConvexHull3D) | A convex hull for a set of points |
+|------------------------------------------------------------------------------------------------------------------|--------------------------------------------------|
+| [`Dodecahedron`](manim.mobject.three_d.polyhedra.Dodecahedron.md#manim.mobject.three_d.polyhedra.Dodecahedron) | A dodecahedron, one of the five platonic solids. |
+| [`Icosahedron`](manim.mobject.three_d.polyhedra.Icosahedron.md#manim.mobject.three_d.polyhedra.Icosahedron) | An icosahedron, one of the five platonic solids. |
+| [`Octahedron`](manim.mobject.three_d.polyhedra.Octahedron.md#manim.mobject.three_d.polyhedra.Octahedron) | An octahedron, one of the five platonic solids. |
+| [`Polyhedron`](manim.mobject.three_d.polyhedra.Polyhedron.md#manim.mobject.three_d.polyhedra.Polyhedron) | An abstract polyhedra class. |
+| [`Tetrahedron`](manim.mobject.three_d.polyhedra.Tetrahedron.md#manim.mobject.three_d.polyhedra.Tetrahedron) | A tetrahedron, one of the five platonic solids. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_d_utils.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_d_utils.md
new file mode 100644
index 0000000000000000000000000000000000000000..43511d6322ef5806d8e2f377bfa7c55c5388f5bb
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_d_utils.md
@@ -0,0 +1,47 @@
+# three_d_utils
+
+Utility functions for three-dimensional mobjects.
+
+### Functions
+
+### get_3d_vmob_end_corner(vmob)
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+### get_3d_vmob_end_corner_index(vmob)
+
+* **Return type:**
+ int
+
+### get_3d_vmob_end_corner_unit_normal(vmob)
+
+* **Return type:**
+ [*Vector3D*](manim.typing.md#manim.typing.Vector3D)
+
+### get_3d_vmob_gradient_start_and_end_points(vmob)
+
+* **Return type:**
+ tuple[[*Point3D*](manim.typing.md#manim.typing.Point3D), [*Point3D*](manim.typing.md#manim.typing.Point3D)]
+
+### get_3d_vmob_start_corner(vmob)
+
+* **Return type:**
+ [*Point3D*](manim.typing.md#manim.typing.Point3D)
+
+### get_3d_vmob_start_corner_index(vmob)
+
+* **Return type:**
+ *Literal*[0]
+
+### get_3d_vmob_start_corner_unit_normal(vmob)
+
+* **Return type:**
+ [*Vector3D*](manim.typing.md#manim.typing.Vector3D)
+
+### get_3d_vmob_unit_normal(vmob, point_index)
+
+* **Parameters:**
+ **point_index** (*int*)
+* **Return type:**
+ [*Vector3D*](manim.typing.md#manim.typing.Vector3D)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Arrow3D.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Arrow3D.md
new file mode 100644
index 0000000000000000000000000000000000000000..550b7ba9bf294ab31e1a663d79e785c2805d4e9e
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Arrow3D.md
@@ -0,0 +1,94 @@
+# Arrow3D
+
+Qualified name: `manim.mobject.three\_d.three\_dimensions.Arrow3D`
+
+### *class* Arrow3D(start=array([-1., 0., 0.]), end=array([1., 0., 0.]), thickness=0.02, height=0.3, base_radius=0.08, color=ManimColor('#FFFFFF'), resolution=24, \*\*kwargs)
+
+Bases: [`Line3D`](manim.mobject.three_d.three_dimensions.Line3D.md#manim.mobject.three_d.three_dimensions.Line3D)
+
+An arrow made out of a cylindrical line and a conical tip.
+
+* **Parameters:**
+ * **start** (*np.ndarray*) – The start position of the arrow.
+ * **end** (*np.ndarray*) – The end position of the arrow.
+ * **thickness** (*float*) – The thickness of the arrow.
+ * **height** (*float*) – The height of the conical tip.
+ * **base_radius** (*float*) – The base radius of the conical tip.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the arrow.
+ * **resolution** (*int* *|* *Sequence* *[**int* *]*) – The resolution of the arrow line.
+
+### Examples
+
+
+
+### Methods
+
+| [`get_end`](#manim.mobject.three_d.three_dimensions.Arrow3D.get_end) | Returns the ending point of the [`Line3D`](manim.mobject.three_d.three_dimensions.Line3D.md#manim.mobject.three_d.three_dimensions.Line3D). |
+|------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(start=array([-1., 0., 0.]), end=array([1., 0., 0.]), thickness=0.02, height=0.3, base_radius=0.08, color=ManimColor('#FFFFFF'), resolution=24, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **start** (*ndarray*)
+ * **end** (*ndarray*)
+ * **thickness** (*float*)
+ * **height** (*float*)
+ * **base_radius** (*float*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **resolution** (*int* *|* *Sequence* *[**int* *]*)
+* **Return type:**
+ None
+
+#### get_end()
+
+Returns the ending point of the [`Line3D`](manim.mobject.three_d.three_dimensions.Line3D.md#manim.mobject.three_d.three_dimensions.Line3D).
+
+* **Returns:**
+ **end** – Ending point of the [`Line3D`](manim.mobject.three_d.three_dimensions.Line3D.md#manim.mobject.three_d.three_dimensions.Line3D).
+* **Return type:**
+ `numpy.array`
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Cone.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Cone.md
new file mode 100644
index 0000000000000000000000000000000000000000..56219b59bf8c6b010e8658ff67945ffe97f8cdbd
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Cone.md
@@ -0,0 +1,132 @@
+# Cone
+
+Qualified name: `manim.mobject.three\_d.three\_dimensions.Cone`
+
+### *class* Cone(base_radius=1, height=1, direction=array([0., 0., 1.]), show_base=False, v_range=[0, 6.283185307179586], u_min=0, checkerboard_colors=False, \*\*kwargs)
+
+Bases: [`Surface`](manim.mobject.three_d.three_dimensions.Surface.md#manim.mobject.three_d.three_dimensions.Surface)
+
+A circular cone.
+Can be defined using 2 parameters: its height, and its base radius.
+The polar angle, theta, can be calculated using arctan(base_radius /
+height) The spherical radius, r, is calculated using the pythagorean
+theorem.
+
+* **Parameters:**
+ * **base_radius** (*float*) – The base radius from which the cone tapers.
+ * **height** (*float*) – The height measured from the plane formed by the base_radius to
+ the apex of the cone.
+ * **direction** (*np.ndarray*) – The direction of the apex.
+ * **show_base** (*bool*) – Whether to show the base plane or not.
+ * **v_range** (*Sequence* *[**float* *]*) – The azimuthal angle to start and end at.
+ * **u_min** (*float*) – The radius at the apex.
+ * **checkerboard_colors** (*bool*) – Show checkerboard grid texture on the cone.
+ * **kwargs** (*Any*)
+
+### Examples
+
+
+
+### Methods
+
+| [`func`](#manim.mobject.three_d.three_dimensions.Cone.func) | Converts from spherical coordinates to cartesian. |
+|-------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------|
+| [`get_direction`](#manim.mobject.three_d.three_dimensions.Cone.get_direction) | Returns the current direction of the apex of the [`Cone`](#manim.mobject.three_d.three_dimensions.Cone). |
+| [`get_end`](#manim.mobject.three_d.three_dimensions.Cone.get_end) | Returns the point, where the stroke that surrounds the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) ends. |
+| [`get_start`](#manim.mobject.three_d.three_dimensions.Cone.get_start) | Returns the point, where the stroke that surrounds the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) starts. |
+| [`set_direction`](#manim.mobject.three_d.three_dimensions.Cone.set_direction) | Changes the direction of the apex of the [`Cone`](#manim.mobject.three_d.three_dimensions.Cone). |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(base_radius=1, height=1, direction=array([0., 0., 1.]), show_base=False, v_range=[0, 6.283185307179586], u_min=0, checkerboard_colors=False, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **base_radius** (*float*)
+ * **height** (*float*)
+ * **direction** (*ndarray*)
+ * **show_base** (*bool*)
+ * **v_range** (*Sequence* *[**float* *]*)
+ * **u_min** (*float*)
+ * **checkerboard_colors** (*bool*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### func(u, v)
+
+Converts from spherical coordinates to cartesian.
+
+* **Parameters:**
+ * **u** (*float*) – The radius.
+ * **v** (*float*) – The azimuthal angle.
+* **Returns:**
+ Points defining the [`Cone`](#manim.mobject.three_d.three_dimensions.Cone).
+* **Return type:**
+ `numpy.array`
+
+#### get_direction()
+
+Returns the current direction of the apex of the [`Cone`](#manim.mobject.three_d.three_dimensions.Cone).
+
+* **Returns:**
+ **direction** – The direction of the apex.
+* **Return type:**
+ `numpy.array`
+
+#### get_end()
+
+Returns the point, where the stroke that surrounds the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) ends.
+
+* **Return type:**
+ *ndarray*
+
+#### get_start()
+
+Returns the point, where the stroke that surrounds the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) starts.
+
+* **Return type:**
+ *ndarray*
+
+#### set_direction(direction)
+
+Changes the direction of the apex of the [`Cone`](#manim.mobject.three_d.three_dimensions.Cone).
+
+* **Parameters:**
+ **direction** (*ndarray*) – The direction of the apex.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Cube.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Cube.md
new file mode 100644
index 0000000000000000000000000000000000000000..89ecba78b4a93e396bf1a693cd1cc0c2882074ee
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Cube.md
@@ -0,0 +1,89 @@
+# Cube
+
+Qualified name: `manim.mobject.three\_d.three\_dimensions.Cube`
+
+### *class* Cube(side_length=2, fill_opacity=0.75, fill_color=ManimColor('#58C4DD'), stroke_width=0, \*\*kwargs)
+
+Bases: [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+A three-dimensional cube.
+
+* **Parameters:**
+ * **side_length** (*float*) – Length of each side of the [`Cube`](#manim.mobject.three_d.three_dimensions.Cube).
+ * **fill_opacity** (*float*) – The opacity of the [`Cube`](#manim.mobject.three_d.three_dimensions.Cube), from 0 being fully transparent to 1 being
+ fully opaque. Defaults to 0.75.
+ * **fill_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the [`Cube`](#manim.mobject.three_d.three_dimensions.Cube).
+ * **stroke_width** (*float*) – The width of the stroke surrounding each face of the [`Cube`](#manim.mobject.three_d.three_dimensions.Cube).
+
+### Examples
+
+
+
+### Methods
+
+| [`generate_points`](#manim.mobject.three_d.three_dimensions.Cube.generate_points) | Creates the sides of the [`Cube`](#manim.mobject.three_d.three_dimensions.Cube). |
+|-------------------------------------------------------------------------------------|------------------------------------------------------------------------------------|
+| [`init_points`](#manim.mobject.three_d.three_dimensions.Cube.init_points) | Creates the sides of the [`Cube`](#manim.mobject.three_d.three_dimensions.Cube). |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(side_length=2, fill_opacity=0.75, fill_color=ManimColor('#58C4DD'), stroke_width=0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **side_length** (*float*)
+ * **fill_opacity** (*float*)
+ * **fill_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **stroke_width** (*float*)
+* **Return type:**
+ None
+
+#### generate_points()
+
+Creates the sides of the [`Cube`](#manim.mobject.three_d.three_dimensions.Cube).
+
+* **Return type:**
+ None
+
+#### init_points()
+
+Creates the sides of the [`Cube`](#manim.mobject.three_d.three_dimensions.Cube).
+
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Cylinder.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Cylinder.md
new file mode 100644
index 0000000000000000000000000000000000000000..0828bef135cea3713489b98d2b98bbeacbe23611
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Cylinder.md
@@ -0,0 +1,116 @@
+# Cylinder
+
+Qualified name: `manim.mobject.three\_d.three\_dimensions.Cylinder`
+
+### *class* Cylinder(radius=1, height=2, direction=array([0., 0., 1.]), v_range=[0, 6.283185307179586], show_ends=True, resolution=(24, 24), \*\*kwargs)
+
+Bases: [`Surface`](manim.mobject.three_d.three_dimensions.Surface.md#manim.mobject.three_d.three_dimensions.Surface)
+
+A cylinder, defined by its height, radius and direction,
+
+* **Parameters:**
+ * **radius** (*float*) – The radius of the cylinder.
+ * **height** (*float*) – The height of the cylinder.
+ * **direction** (*np.ndarray*) – The direction of the central axis of the cylinder.
+ * **v_range** (*Sequence* *[**float* *]*) – The height along the height axis (given by direction) to start and end on.
+ * **show_ends** (*bool*) – Whether to show the end caps or not.
+ * **resolution** (*Sequence* *[**int* *]*) – The number of samples taken of the [`Cylinder`](#manim.mobject.three_d.three_dimensions.Cylinder). A tuple can be used
+ to define different resolutions for `u` and `v` respectively.
+
+### Examples
+
+
+
+### Methods
+
+| [`add_bases`](#manim.mobject.three_d.three_dimensions.Cylinder.add_bases) | Adds the end caps of the cylinder. |
+|-----------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------|
+| [`func`](#manim.mobject.three_d.three_dimensions.Cylinder.func) | Converts from cylindrical coordinates to cartesian. |
+| [`get_direction`](#manim.mobject.three_d.three_dimensions.Cylinder.get_direction) | Returns the direction of the central axis of the [`Cylinder`](#manim.mobject.three_d.three_dimensions.Cylinder). |
+| [`set_direction`](#manim.mobject.three_d.three_dimensions.Cylinder.set_direction) | Sets the direction of the central axis of the [`Cylinder`](#manim.mobject.three_d.three_dimensions.Cylinder). |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(radius=1, height=2, direction=array([0., 0., 1.]), v_range=[0, 6.283185307179586], show_ends=True, resolution=(24, 24), \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **radius** (*float*)
+ * **height** (*float*)
+ * **direction** (*ndarray*)
+ * **v_range** (*Sequence* *[**float* *]*)
+ * **show_ends** (*bool*)
+ * **resolution** (*Sequence* *[**int* *]*)
+* **Return type:**
+ None
+
+#### add_bases()
+
+Adds the end caps of the cylinder.
+
+* **Return type:**
+ None
+
+#### func(u, v)
+
+Converts from cylindrical coordinates to cartesian.
+
+* **Parameters:**
+ * **u** (*float*) – The height.
+ * **v** (*float*) – The azimuthal angle.
+* **Returns:**
+ Points defining the [`Cylinder`](#manim.mobject.three_d.three_dimensions.Cylinder).
+* **Return type:**
+ `numpy.ndarray`
+
+#### get_direction()
+
+Returns the direction of the central axis of the [`Cylinder`](#manim.mobject.three_d.three_dimensions.Cylinder).
+
+* **Returns:**
+ **direction** – The direction of the central axis of the [`Cylinder`](#manim.mobject.three_d.three_dimensions.Cylinder).
+* **Return type:**
+ `numpy.array`
+
+#### set_direction(direction)
+
+Sets the direction of the central axis of the [`Cylinder`](#manim.mobject.three_d.three_dimensions.Cylinder).
+
+* **Parameters:**
+ **direction** (`numpy.array`) – The direction of the central axis of the [`Cylinder`](#manim.mobject.three_d.three_dimensions.Cylinder).
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Dot3D.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Dot3D.md
new file mode 100644
index 0000000000000000000000000000000000000000..f2098d01859ed1157151a1b49fa6860c9a7b571b
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Dot3D.md
@@ -0,0 +1,75 @@
+# Dot3D
+
+Qualified name: `manim.mobject.three\_d.three\_dimensions.Dot3D`
+
+### *class* Dot3D(point=array([0., 0., 0.]), radius=0.08, color=ManimColor('#FFFFFF'), resolution=(8, 8), \*\*kwargs)
+
+Bases: [`Sphere`](manim.mobject.three_d.three_dimensions.Sphere.md#manim.mobject.three_d.three_dimensions.Sphere)
+
+A spherical dot.
+
+* **Parameters:**
+ * **point** (*list* *|* *np.ndarray*) – The location of the dot.
+ * **radius** (*float*) – The radius of the dot.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the [`Dot3D`](#manim.mobject.three_d.three_dimensions.Dot3D).
+ * **resolution** (*tuple* *[**int* *,* *int* *]*) – The number of samples taken of the [`Dot3D`](#manim.mobject.three_d.three_dimensions.Dot3D). A tuple can be
+ used to define different resolutions for `u` and `v` respectively.
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(point=array([0., 0., 0.]), radius=0.08, color=ManimColor('#FFFFFF'), resolution=(8, 8), \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **point** (*list* *|* *ndarray*)
+ * **radius** (*float*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **resolution** (*tuple* *[**int* *,* *int* *]*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Line3D.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Line3D.md
new file mode 100644
index 0000000000000000000000000000000000000000..59f0df0587a4e8a6af9dccca1e5896b573b9902b
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Line3D.md
@@ -0,0 +1,207 @@
+# Line3D
+
+Qualified name: `manim.mobject.three\_d.three\_dimensions.Line3D`
+
+### *class* Line3D(start=array([-1., 0., 0.]), end=array([1., 0., 0.]), thickness=0.02, color=None, resolution=24, \*\*kwargs)
+
+Bases: [`Cylinder`](manim.mobject.three_d.three_dimensions.Cylinder.md#manim.mobject.three_d.three_dimensions.Cylinder)
+
+A cylindrical line, for use in ThreeDScene.
+
+* **Parameters:**
+ * **start** (*np.ndarray*) – The start point of the line.
+ * **end** (*np.ndarray*) – The end point of the line.
+ * **thickness** (*float*) – The thickness of the line.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The color of the line.
+ * **resolution** (*int* *|* *Sequence* *[**int* *]*) – The resolution of the line.
+ By default this value is the number of points the line will sampled at.
+ If you want the line to also come out checkered, use a tuple.
+ For example, for a line made of 24 points with 4 checker points on each
+ cylinder, pass the tuple (4, 24).
+
+### Examples
+
+
+
+### Methods
+
+| [`get_end`](#manim.mobject.three_d.three_dimensions.Line3D.get_end) | Returns the ending point of the [`Line3D`](#manim.mobject.three_d.three_dimensions.Line3D). |
+|-----------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------|
+| [`get_start`](#manim.mobject.three_d.three_dimensions.Line3D.get_start) | Returns the starting point of the [`Line3D`](#manim.mobject.three_d.three_dimensions.Line3D). |
+| [`parallel_to`](#manim.mobject.three_d.three_dimensions.Line3D.parallel_to) | Returns a line parallel to another line going through a given point. |
+| [`perpendicular_to`](#manim.mobject.three_d.three_dimensions.Line3D.perpendicular_to) | Returns a line perpendicular to another line going through a given point. |
+| [`pointify`](#manim.mobject.three_d.three_dimensions.Line3D.pointify) | Gets a point representing the center of the [`Mobjects`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject). |
+| [`set_start_and_end_attrs`](#manim.mobject.three_d.three_dimensions.Line3D.set_start_and_end_attrs) | Sets the start and end points of the line. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(start=array([-1., 0., 0.]), end=array([1., 0., 0.]), thickness=0.02, color=None, resolution=24, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **start** (*np.ndarray*)
+ * **end** (*np.ndarray*)
+ * **thickness** (*float*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **resolution** (*int* *|* *Sequence* *[**int* *]*)
+
+#### get_end()
+
+Returns the ending point of the [`Line3D`](#manim.mobject.three_d.three_dimensions.Line3D).
+
+* **Returns:**
+ **end** – Ending point of the [`Line3D`](#manim.mobject.three_d.three_dimensions.Line3D).
+* **Return type:**
+ `numpy.array`
+
+#### get_start()
+
+Returns the starting point of the [`Line3D`](#manim.mobject.three_d.three_dimensions.Line3D).
+
+* **Returns:**
+ **start** – Starting point of the [`Line3D`](#manim.mobject.three_d.three_dimensions.Line3D).
+* **Return type:**
+ `numpy.array`
+
+#### *classmethod* parallel_to(line, point=array([0., 0., 0.]), length=5, \*\*kwargs)
+
+Returns a line parallel to another line going through
+a given point.
+
+* **Parameters:**
+ * **line** ([*Line3D*](#manim.mobject.three_d.three_dimensions.Line3D)) – The line to be parallel to.
+ * **point** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D)) – The point to pass through.
+ * **length** (*float*) – Length of the parallel line.
+ * **kwargs** – Additional parameters to be passed to the class.
+* **Returns:**
+ Line parallel to `line`.
+* **Return type:**
+ [`Line3D`](#manim.mobject.three_d.three_dimensions.Line3D)
+
+### Examples
+
+
+
+#### *classmethod* perpendicular_to(line, point=array([0., 0., 0.]), length=5, \*\*kwargs)
+
+Returns a line perpendicular to another line going through
+a given point.
+
+* **Parameters:**
+ * **line** ([*Line3D*](#manim.mobject.three_d.three_dimensions.Line3D)) – The line to be perpendicular to.
+ * **point** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D)) – The point to pass through.
+ * **length** (*float*) – Length of the perpendicular line.
+ * **kwargs** – Additional parameters to be passed to the class.
+* **Returns:**
+ Line perpendicular to `line`.
+* **Return type:**
+ [`Line3D`](#manim.mobject.three_d.three_dimensions.Line3D)
+
+### Examples
+
+
+
+#### pointify(mob_or_point, direction=None)
+
+Gets a point representing the center of the [`Mobjects`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+
+* **Parameters:**
+ * **mob_or_point** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* [*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – [`Mobjects`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) or point whose center should be returned.
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D)) – If an edge of a [`Mobjects`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) should be returned, the direction of the edge.
+* **Returns:**
+ Center of the [`Mobjects`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) or point, or edge if direction is given.
+* **Return type:**
+ `numpy.array`
+
+#### set_start_and_end_attrs(start, end, \*\*kwargs)
+
+Sets the start and end points of the line.
+
+If either `start` or `end` are [`Mobjects`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject),
+this gives their centers.
+
+* **Parameters:**
+ * **start** (*ndarray*) – Starting point or `Mobject`.
+ * **end** (*ndarray*) – Ending point or `Mobject`.
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Prism.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Prism.md
new file mode 100644
index 0000000000000000000000000000000000000000..5d570b55364e3ba1d7612353ddc77fd3a5df6155
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Prism.md
@@ -0,0 +1,73 @@
+# Prism
+
+Qualified name: `manim.mobject.three\_d.three\_dimensions.Prism`
+
+### *class* Prism(dimensions=[3, 2, 1], \*\*kwargs)
+
+Bases: [`Cube`](manim.mobject.three_d.three_dimensions.Cube.md#manim.mobject.three_d.three_dimensions.Cube)
+
+A right rectangular prism (or rectangular cuboid).
+Defined by the length of each side in `[x, y, z]` format.
+
+* **Parameters:**
+ **dimensions** (*tuple* *[**float* *,* *float* *,* *float* *]* *|* *np.ndarray*) – Dimensions of the [`Prism`](#manim.mobject.three_d.three_dimensions.Prism) in `[x, y, z]` format.
+
+### Examples
+
+
+
+### Methods
+
+| [`generate_points`](#manim.mobject.three_d.three_dimensions.Prism.generate_points) | Creates the sides of the [`Prism`](#manim.mobject.three_d.three_dimensions.Prism). |
+|--------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(dimensions=[3, 2, 1], \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **dimensions** (*tuple* *[**float* *,* *float* *,* *float* *]* *|* *ndarray*)
+* **Return type:**
+ None
+
+#### generate_points()
+
+Creates the sides of the [`Prism`](#manim.mobject.three_d.three_dimensions.Prism).
+
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Sphere.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Sphere.md
new file mode 100644
index 0000000000000000000000000000000000000000..595ba75101c61b252e21a26a1466aab579120437
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Sphere.md
@@ -0,0 +1,110 @@
+# Sphere
+
+Qualified name: `manim.mobject.three\_d.three\_dimensions.Sphere`
+
+### *class* Sphere(center=array([0., 0., 0.]), radius=1, resolution=None, u_range=(0, 6.283185307179586), v_range=(0, 3.141592653589793), \*\*kwargs)
+
+Bases: [`Surface`](manim.mobject.three_d.three_dimensions.Surface.md#manim.mobject.three_d.three_dimensions.Surface)
+
+A three-dimensional sphere.
+
+* **Parameters:**
+ * **center** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – Center of the [`Sphere`](#manim.mobject.three_d.three_dimensions.Sphere).
+ * **radius** (*float*) – The radius of the [`Sphere`](#manim.mobject.three_d.three_dimensions.Sphere).
+ * **resolution** (*Sequence* *[**int* *]* *|* *None*) – The number of samples taken of the [`Sphere`](#manim.mobject.three_d.three_dimensions.Sphere). A tuple can be used
+ to define different resolutions for `u` and `v` respectively.
+ * **u_range** (*Sequence* *[**float* *]*) – The range of the `u` variable: `(u_min, u_max)`.
+ * **v_range** (*Sequence* *[**float* *]*) – The range of the `v` variable: `(v_min, v_max)`.
+
+### Examples
+
+
+
+### Methods
+
+| [`func`](#manim.mobject.three_d.three_dimensions.Sphere.func) | The z values defining the [`Sphere`](#manim.mobject.three_d.three_dimensions.Sphere) being plotted. |
+|-----------------------------------------------------------------|-------------------------------------------------------------------------------------------------------|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(center=array([0., 0., 0.]), radius=1, resolution=None, u_range=(0, 6.283185307179586), v_range=(0, 3.141592653589793), \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **center** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **radius** (*float*)
+ * **resolution** (*Sequence* *[**int* *]* *|* *None*)
+ * **u_range** (*Sequence* *[**float* *]*)
+ * **v_range** (*Sequence* *[**float* *]*)
+* **Return type:**
+ None
+
+#### func(u, v)
+
+The z values defining the [`Sphere`](#manim.mobject.three_d.three_dimensions.Sphere) being plotted.
+
+* **Returns:**
+ The z values defining the [`Sphere`](#manim.mobject.three_d.three_dimensions.Sphere).
+* **Return type:**
+ `numpy.array`
+* **Parameters:**
+ * **u** (*float*)
+ * **v** (*float*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Surface.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Surface.md
new file mode 100644
index 0000000000000000000000000000000000000000..a91ccddd57464a8d92dbc9e9c6966b7348f2b2bc
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Surface.md
@@ -0,0 +1,194 @@
+# Surface
+
+Qualified name: `manim.mobject.three\_d.three\_dimensions.Surface`
+
+### *class* Surface(func, u_range=[0, 1], v_range=[0, 1], resolution=32, surface_piece_config={}, fill_color=ManimColor('#29ABCA'), fill_opacity=1.0, checkerboard_colors=[ManimColor('#29ABCA'), ManimColor('#236B8E')], stroke_color=ManimColor('#BBBBBB'), stroke_width=0.5, should_make_jagged=False, pre_function_handle_to_anchor_scale_factor=1e-05, \*\*kwargs)
+
+Bases: [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+Creates a Parametric Surface using a checkerboard pattern.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**float* *,* *float* *]* *,* *np.ndarray* *]*) – The function defining the [`Surface`](#manim.mobject.three_d.three_dimensions.Surface).
+ * **u_range** (*Sequence* *[**float* *]*) – The range of the `u` variable: `(u_min, u_max)`.
+ * **v_range** (*Sequence* *[**float* *]*) – The range of the `v` variable: `(v_min, v_max)`.
+ * **resolution** (*Sequence* *[**int* *]*) – The number of samples taken of the [`Surface`](#manim.mobject.three_d.three_dimensions.Surface). A tuple can be
+ used to define different resolutions for `u` and `v` respectively.
+ * **fill_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the [`Surface`](#manim.mobject.three_d.three_dimensions.Surface). Ignored if `checkerboard_colors`
+ is set.
+ * **fill_opacity** (*float*) – The opacity of the [`Surface`](#manim.mobject.three_d.three_dimensions.Surface), from 0 being fully transparent
+ to 1 being fully opaque. Defaults to 1.
+ * **checkerboard_colors** (*Sequence* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]* *|* *bool*) – ng individual faces alternating colors. Overrides `fill_color`.
+ * **stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – Color of the stroke surrounding each face of [`Surface`](#manim.mobject.three_d.three_dimensions.Surface).
+ * **stroke_width** (*float*) – Width of the stroke surrounding each face of [`Surface`](#manim.mobject.three_d.three_dimensions.Surface).
+ Defaults to 0.5.
+ * **should_make_jagged** (*bool*) – Changes the anchor mode of the Bézier curves from smooth to jagged.
+ Defaults to `False`.
+ * **surface_piece_config** (*dict*)
+ * **pre_function_handle_to_anchor_scale_factor** (*float*)
+ * **kwargs** (*Any*)
+
+### Examples
+
+
+
+### Methods
+
+| `func` | |
+|--------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------|
+| [`set_fill_by_checkerboard`](#manim.mobject.three_d.three_dimensions.Surface.set_fill_by_checkerboard) | Sets the fill_color of each face of [`Surface`](#manim.mobject.three_d.three_dimensions.Surface) in an alternating pattern. |
+| [`set_fill_by_value`](#manim.mobject.three_d.three_dimensions.Surface.set_fill_by_value) | Sets the color of each mobject of a parametric surface to a color relative to its axis-value. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(func, u_range=[0, 1], v_range=[0, 1], resolution=32, surface_piece_config={}, fill_color=ManimColor('#29ABCA'), fill_opacity=1.0, checkerboard_colors=[ManimColor('#29ABCA'), ManimColor('#236B8E')], stroke_color=ManimColor('#BBBBBB'), stroke_width=0.5, should_make_jagged=False, pre_function_handle_to_anchor_scale_factor=1e-05, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**float* *,* *float* *]* *,* *ndarray* *]*)
+ * **u_range** (*Sequence* *[**float* *]*)
+ * **v_range** (*Sequence* *[**float* *]*)
+ * **resolution** (*Sequence* *[**int* *]*)
+ * **surface_piece_config** (*dict*)
+ * **fill_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **fill_opacity** (*float*)
+ * **checkerboard_colors** (*Sequence* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]* *|* *bool*)
+ * **stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **stroke_width** (*float*)
+ * **should_make_jagged** (*bool*)
+ * **pre_function_handle_to_anchor_scale_factor** (*float*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### set_fill_by_checkerboard(\*colors, opacity=None)
+
+Sets the fill_color of each face of [`Surface`](#manim.mobject.three_d.three_dimensions.Surface) in
+an alternating pattern.
+
+* **Parameters:**
+ * **colors** (*Iterable* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]*) – List of colors for alternating pattern.
+ * **opacity** (*float* *|* *None*) – The fill_opacity of [`Surface`](#manim.mobject.three_d.three_dimensions.Surface), from 0 being fully transparent
+ to 1 being fully opaque.
+* **Returns:**
+ The parametric surface with an alternating pattern.
+* **Return type:**
+ [`Surface`](#manim.mobject.three_d.three_dimensions.Surface)
+
+#### set_fill_by_value(axes, colorscale=None, axis=2, \*\*kwargs)
+
+Sets the color of each mobject of a parametric surface to a color
+relative to its axis-value.
+
+* **Parameters:**
+ * **axes** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The axes for the parametric surface, which will be used to map
+ axis-values to colors.
+ * **colorscale** (*list* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]* *|* [*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – A list of colors, ordered from lower axis-values to higher axis-values.
+ If a list of tuples is passed containing colors paired with numbers,
+ then those numbers will be used as the pivots.
+ * **axis** (*int*) – The chosen axis to use for the color mapping. (0 = x, 1 = y, 2 = z)
+* **Returns:**
+ The parametric surface with a gradient applied by value. For chaining.
+* **Return type:**
+ [`Surface`](#manim.mobject.three_d.three_dimensions.Surface)
+
+### Examples
+
+
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.ThreeDVMobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.ThreeDVMobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..c3b126ea5e3d4afd6135c1b51867d5d12280265d
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.ThreeDVMobject.md
@@ -0,0 +1,32 @@
+# ThreeDVMobject
+
+Qualified name: `manim.mobject.three\_d.three\_dimensions.ThreeDVMobject`
+
+### *class* ThreeDVMobject(shade_in_3d=True, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ **shade_in_3d** (*bool*)
+
+#### \_original_\_init_\_(shade_in_3d=True, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **shade_in_3d** (*bool*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Torus.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Torus.md
new file mode 100644
index 0000000000000000000000000000000000000000..3cd0a18097faf8061b437aad68635add611c6f3c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.Torus.md
@@ -0,0 +1,86 @@
+# Torus
+
+Qualified name: `manim.mobject.three\_d.three\_dimensions.Torus`
+
+### *class* Torus(major_radius=3, minor_radius=1, u_range=(0, 6.283185307179586), v_range=(0, 6.283185307179586), resolution=None, \*\*kwargs)
+
+Bases: [`Surface`](manim.mobject.three_d.three_dimensions.Surface.md#manim.mobject.three_d.three_dimensions.Surface)
+
+A torus.
+
+* **Parameters:**
+ * **major_radius** (*float*) – Distance from the center of the tube to the center of the torus.
+ * **minor_radius** (*float*) – Radius of the tube.
+ * **u_range** (*Sequence* *[**float* *]*) – The range of the `u` variable: `(u_min, u_max)`.
+ * **v_range** (*Sequence* *[**float* *]*) – The range of the `v` variable: `(v_min, v_max)`.
+ * **resolution** (*tuple* *[**int* *,* *int* *]* *|* *None*) – The number of samples taken of the [`Torus`](#manim.mobject.three_d.three_dimensions.Torus). A tuple can be
+ used to define different resolutions for `u` and `v` respectively.
+
+### Examples
+
+
+
+### Methods
+
+| [`func`](#manim.mobject.three_d.three_dimensions.Torus.func) | The z values defining the [`Torus`](#manim.mobject.three_d.three_dimensions.Torus) being plotted. |
+|----------------------------------------------------------------|-----------------------------------------------------------------------------------------------------|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(major_radius=3, minor_radius=1, u_range=(0, 6.283185307179586), v_range=(0, 6.283185307179586), resolution=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **major_radius** (*float*)
+ * **minor_radius** (*float*)
+ * **u_range** (*Sequence* *[**float* *]*)
+ * **v_range** (*Sequence* *[**float* *]*)
+ * **resolution** (*tuple* *[**int* *,* *int* *]* *|* *None*)
+* **Return type:**
+ None
+
+#### func(u, v)
+
+The z values defining the [`Torus`](#manim.mobject.three_d.three_dimensions.Torus) being plotted.
+
+* **Returns:**
+ The z values defining the [`Torus`](#manim.mobject.three_d.three_dimensions.Torus).
+* **Return type:**
+ `numpy.ndarray`
+* **Parameters:**
+ * **u** (*float*)
+ * **v** (*float*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.md
new file mode 100644
index 0000000000000000000000000000000000000000..6234437747420af48ec64f8da046e954e4103197
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.three_d.three_dimensions.md
@@ -0,0 +1,18 @@
+# three_dimensions
+
+Three-dimensional mobjects.
+
+### Classes
+
+| [`Arrow3D`](manim.mobject.three_d.three_dimensions.Arrow3D.md#manim.mobject.three_d.three_dimensions.Arrow3D) | An arrow made out of a cylindrical line and a conical tip. |
+|------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------|
+| [`Cone`](manim.mobject.three_d.three_dimensions.Cone.md#manim.mobject.three_d.three_dimensions.Cone) | A circular cone. |
+| [`Cube`](manim.mobject.three_d.three_dimensions.Cube.md#manim.mobject.three_d.three_dimensions.Cube) | A three-dimensional cube. |
+| [`Cylinder`](manim.mobject.three_d.three_dimensions.Cylinder.md#manim.mobject.three_d.three_dimensions.Cylinder) | A cylinder, defined by its height, radius and direction, |
+| [`Dot3D`](manim.mobject.three_d.three_dimensions.Dot3D.md#manim.mobject.three_d.three_dimensions.Dot3D) | A spherical dot. |
+| [`Line3D`](manim.mobject.three_d.three_dimensions.Line3D.md#manim.mobject.three_d.three_dimensions.Line3D) | A cylindrical line, for use in ThreeDScene. |
+| [`Prism`](manim.mobject.three_d.three_dimensions.Prism.md#manim.mobject.three_d.three_dimensions.Prism) | A right rectangular prism (or rectangular cuboid). |
+| [`Sphere`](manim.mobject.three_d.three_dimensions.Sphere.md#manim.mobject.three_d.three_dimensions.Sphere) | A three-dimensional sphere. |
+| [`Surface`](manim.mobject.three_d.three_dimensions.Surface.md#manim.mobject.three_d.three_dimensions.Surface) | Creates a Parametric Surface using a checkerboard pattern. |
+| [`ThreeDVMobject`](manim.mobject.three_d.three_dimensions.ThreeDVMobject.md#manim.mobject.three_d.three_dimensions.ThreeDVMobject) | |
+| [`Torus`](manim.mobject.three_d.three_dimensions.Torus.md#manim.mobject.three_d.three_dimensions.Torus) | A torus. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.image_mobject.AbstractImageMobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.image_mobject.AbstractImageMobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..f961ede5bf825847de4419eaaa840ef4ff63c417
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.image_mobject.AbstractImageMobject.md
@@ -0,0 +1,84 @@
+# AbstractImageMobject
+
+Qualified name: `manim.mobject.types.image\_mobject.AbstractImageMobject`
+
+### *class* AbstractImageMobject(scale_to_resolution, pixel_array_dtype='uint8', resampling_algorithm=Resampling.BICUBIC, \*\*kwargs)
+
+Bases: [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+Automatically filters out black pixels
+
+* **Parameters:**
+ * **scale_to_resolution** (*int*) – At this resolution the image is placed pixel by pixel onto the screen, so it
+ will look the sharpest and best.
+ This is a custom parameter of ImageMobject so that rendering a scene with
+ e.g. the `--quality low` or `--quality medium` flag for faster rendering
+ won’t effect the position of the image on the screen.
+ * **pixel_array_dtype** (*str*)
+ * **resampling_algorithm** (*Resampling*)
+ * **kwargs** (*Any*)
+
+### Methods
+
+| `get_pixel_array` | |
+|----------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------|
+| [`reset_points`](#manim.mobject.types.image_mobject.AbstractImageMobject.reset_points) | Sets `points` to be the four image corners. |
+| [`set_color`](#manim.mobject.types.image_mobject.AbstractImageMobject.set_color) | Condition is function which takes in one arguments, (x, y, z). |
+| [`set_resampling_algorithm`](#manim.mobject.types.image_mobject.AbstractImageMobject.set_resampling_algorithm) | Sets the interpolation method for upscaling the image. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------|
+| `animation_overrides` | |
+| `depth` | The depth of the mobject. |
+| `height` | The height of the mobject. |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(scale_to_resolution, pixel_array_dtype='uint8', resampling_algorithm=Resampling.BICUBIC, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **scale_to_resolution** (*int*)
+ * **pixel_array_dtype** (*str*)
+ * **resampling_algorithm** (*Resampling*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### reset_points()
+
+Sets `points` to be the four image corners.
+
+* **Return type:**
+ None
+
+#### set_color(color, alpha=None, family=True)
+
+Condition is function which takes in one arguments, (x, y, z).
+Here it just recurses to submobjects, but in subclasses this
+should be further implemented based on the the inner workings
+of color
+
+#### set_resampling_algorithm(resampling_algorithm)
+
+Sets the interpolation method for upscaling the image. By default the image is
+interpolated using bicubic algorithm. This method lets you change it.
+Interpolation is done internally using Pillow, and the function besides the
+string constants describing the algorithm accepts the Pillow integer constants.
+
+* **Parameters:**
+ **resampling_algorithm** (*int*) –
+
+ An integer constant described in the Pillow library,
+ or one from the RESAMPLING_ALGORITHMS global dictionary,
+ under the following keys:
+ * ’bicubic’ or ‘cubic’
+ * ’nearest’ or ‘none’
+ * ’box’
+ * ’bilinear’ or ‘linear’
+ * ’hamming’
+ * ’lanczos’ or ‘antialias’
+* **Return type:**
+ Self
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.image_mobject.ImageMobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.image_mobject.ImageMobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..0924bb77b9875d17c8ea9ec3afaf1ebee5a7a8d5
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.image_mobject.ImageMobject.md
@@ -0,0 +1,192 @@
+# ImageMobject
+
+Qualified name: `manim.mobject.types.image\_mobject.ImageMobject`
+
+### *class* ImageMobject(filename_or_array, scale_to_resolution=1080, invert=False, image_mode='RGBA', \*\*kwargs)
+
+Bases: [`AbstractImageMobject`](manim.mobject.types.image_mobject.AbstractImageMobject.md#manim.mobject.types.image_mobject.AbstractImageMobject)
+
+Displays an Image from a numpy array or a file.
+
+* **Parameters:**
+ * **scale_to_resolution** (*int*) – At this resolution the image is placed pixel by pixel onto the screen, so it
+ will look the sharpest and best.
+ This is a custom parameter of ImageMobject so that rendering a scene with
+ e.g. the `--quality low` or `--quality medium` flag for faster rendering
+ won’t effect the position of the image on the screen.
+ * **filename_or_array** ([*StrPath*](manim.typing.md#manim.typing.StrPath) *|* *npt.NDArray*)
+ * **invert** (*bool*)
+ * **image_mode** (*str*)
+ * **kwargs** (*Any*)
+
+### Example
+
+
+```python
+from manim import *
+
+class PMobjectExample(Scene):
+ def construct(self):
+
+ pG = PGroup() # This is just a collection of PMobject's
+
+ # As the scale factor increases, the number of points
+ # removed increases.
+ for sf in range(1, 9 + 1):
+ p = PointCloudDot(density=20, radius=1).thin_out(sf)
+ # PointCloudDot is a type of PMobject
+ # and can therefore be added to a PGroup
+ pG.add(p)
+
+ # This organizes all the shapes in a grid.
+ pG.arrange_in_grid()
+
+ self.add(pG)
+```
+
+
+class PMobjectExample(Scene):
+ def construct(self):
+
+ pG = PGroup() # This is just a collection of PMobject's
+
+ # As the scale factor increases, the number of points
+ # removed increases.
+ for sf in range(1, 9 + 1):
+ p = PointCloudDot(density=20, radius=1).thin_out(sf)
+ # PointCloudDot is a type of PMobject
+ # and can therefore be added to a PGroup
+ pG.add(p)
+
+ # This organizes all the shapes in a grid.
+ pG.arrange_in_grid()
+
+ self.add(pG)
+
+
+
+### Methods
+
+| [`add_points`](#manim.mobject.types.point_cloud_mobject.PMobject.add_points) | Add points. |
+|------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------|
+| `align_points_with_larger` | |
+| `fade_to` | |
+| `filter_out` | |
+| `get_all_rgbas` | |
+| `get_array_attrs` | |
+| [`get_color`](#manim.mobject.types.point_cloud_mobject.PMobject.get_color) | Returns the color of the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) |
+| [`get_mobject_type_class`](#manim.mobject.types.point_cloud_mobject.PMobject.get_mobject_type_class) | Return the base class of this mobject type. |
+| [`get_point_mobject`](#manim.mobject.types.point_cloud_mobject.PMobject.get_point_mobject) | The simplest [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) to be transformed to or from self. |
+| `get_stroke_width` | |
+| `ingest_submobjects` | |
+| `interpolate_color` | |
+| `match_colors` | |
+| `point_from_proportion` | |
+| `pointwise_become_partial` | |
+| [`reset_points`](#manim.mobject.types.point_cloud_mobject.PMobject.reset_points) | Sets `points` to be an empty array. |
+| [`set_color`](#manim.mobject.types.point_cloud_mobject.PMobject.set_color) | Condition is function which takes in one arguments, (x, y, z). |
+| [`set_color_by_gradient`](#manim.mobject.types.point_cloud_mobject.PMobject.set_color_by_gradient) | |
+| `set_colors_by_radial_gradient` | |
+| `set_stroke_width` | |
+| [`sort_points`](#manim.mobject.types.point_cloud_mobject.PMobject.sort_points) | Function is any map from R^3 to R |
+| [`thin_out`](#manim.mobject.types.point_cloud_mobject.PMobject.thin_out) | Removes all but every nth point for n = factor |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------|
+| `animation_overrides` | |
+| `depth` | The depth of the mobject. |
+| `height` | The height of the mobject. |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **stroke_width** (*int*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(stroke_width=4, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **stroke_width** (*int*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### add_points(points, rgbas=None, color=None, alpha=1)
+
+Add points.
+
+Points must be a Nx3 numpy array.
+Rgbas must be a Nx4 numpy array if it is not None.
+
+* **Parameters:**
+ * **points** (*npt.NDArray*)
+ * **rgbas** (*npt.NDArray* *|* *None*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **alpha** (*float*)
+* **Return type:**
+ Self
+
+#### get_color()
+
+Returns the color of the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+### Examples
+
+```default
+>>> from manim import Square, RED
+>>> Square(color=RED).get_color() == RED
+True
+```
+
+* **Return type:**
+ [*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+
+#### *static* get_mobject_type_class()
+
+Return the base class of this mobject type.
+
+* **Return type:**
+ type[[*PMobject*](#manim.mobject.types.point_cloud_mobject.PMobject)]
+
+#### get_point_mobject(center=None)
+
+The simplest [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) to be transformed to or from self.
+Should by a point of the appropriate type
+
+* **Parameters:**
+ **center** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* *None*)
+* **Return type:**
+ [Point](manim.mobject.types.point_cloud_mobject.Point.md#manim.mobject.types.point_cloud_mobject.Point)
+
+#### reset_points()
+
+Sets `points` to be an empty array.
+
+* **Return type:**
+ Self
+
+#### set_color(color=ManimColor('#FFFF00'), family=True)
+
+Condition is function which takes in one arguments, (x, y, z).
+Here it just recurses to submobjects, but in subclasses this
+should be further implemented based on the the inner workings
+of color
+
+* **Parameters:**
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **family** (*bool*)
+* **Return type:**
+ Self
+
+#### set_color_by_gradient(\*colors)
+
+* **Parameters:**
+ * **colors** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The colors to use for the gradient. Use like set_color_by_gradient(RED, BLUE, GREEN).
+ * **ManimColor.parse****(****color****)** (*self.color =*)
+ * **self** (*return*)
+* **Return type:**
+ Self
+
+#### sort_points(function=>)
+
+Function is any map from R^3 to R
+
+* **Parameters:**
+ **function** (*Callable* *[* *[**npt.NDArray* *[*[*ManimFloat*](manim.typing.md#manim.typing.ManimFloat) *]* *]* *,* *float* *]*)
+* **Return type:**
+ Self
+
+#### thin_out(factor=5)
+
+Removes all but every nth point for n = factor
+
+* **Parameters:**
+ **factor** (*int*)
+* **Return type:**
+ Self
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.point_cloud_mobject.Point.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.point_cloud_mobject.Point.md
new file mode 100644
index 0000000000000000000000000000000000000000..8078df77dda803965f571c79b7f279b14e7a049f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.point_cloud_mobject.Point.md
@@ -0,0 +1,82 @@
+# Point
+
+Qualified name: `manim.mobject.types.point\_cloud\_mobject.Point`
+
+### *class* Point(location=array([0., 0., 0.]), color=ManimColor('#000000'), \*\*kwargs)
+
+Bases: [`PMobject`](manim.mobject.types.point_cloud_mobject.PMobject.md#manim.mobject.types.point_cloud_mobject.PMobject)
+
+A mobject representing a point.
+
+### Examples
+
+
+
+### Methods
+
+| [`point_from_proportion`](#manim.mobject.types.vectorized_mobject.CurvesAsSubmobjects.point_from_proportion) | Gets the point at a proportion along the path of the [`CurvesAsSubmobjects`](#manim.mobject.types.vectorized_mobject.CurvesAsSubmobjects). |
+|----------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+
+#### \_original_\_init_\_(vmobject, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+* **Return type:**
+ None
+
+#### point_from_proportion(alpha)
+
+Gets the point at a proportion along the path of the [`CurvesAsSubmobjects`](#manim.mobject.types.vectorized_mobject.CurvesAsSubmobjects).
+
+* **Parameters:**
+ **alpha** (*float*) – The proportion along the the path of the [`CurvesAsSubmobjects`](#manim.mobject.types.vectorized_mobject.CurvesAsSubmobjects).
+* **Returns:**
+ The point on the [`CurvesAsSubmobjects`](#manim.mobject.types.vectorized_mobject.CurvesAsSubmobjects).
+* **Return type:**
+ `numpy.ndarray`
+* **Raises:**
+ * **ValueError** – If `alpha` is not between 0 and 1.
+ * **Exception** – If the [`CurvesAsSubmobjects`](#manim.mobject.types.vectorized_mobject.CurvesAsSubmobjects) has no submobjects, or no submobject has points.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.DashedVMobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.DashedVMobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..9bcd4da7a2739a1bd9c9253378d10e1681af979e
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.DashedVMobject.md
@@ -0,0 +1,115 @@
+# DashedVMobject
+
+Qualified name: `manim.mobject.types.vectorized\_mobject.DashedVMobject`
+
+### *class* DashedVMobject(vmobject, num_dashes=15, dashed_ratio=0.5, dash_offset=0, color=ManimColor('#FFFFFF'), equal_lengths=True, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) composed of dashes instead of lines.
+
+* **Parameters:**
+ * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The object that will get dashed
+ * **num_dashes** (*int*) – Number of dashes to add.
+ * **dashed_ratio** (*float*) – Ratio of dash to empty space.
+ * **dash_offset** (*float*) – Shifts the starting point of dashes along the
+ path. Value 1 shifts by one full dash length.
+ * **equal_lengths** (*bool*) – If `True`, dashes will be (approximately) equally long.
+ If `False`, dashes will be split evenly in the curve’s
+ input t variable (legacy behavior).
+ * **color** ([*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor))
+
+### Examples
+
+
+
+### Methods
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(vmobject, num_dashes=15, dashed_ratio=0.5, dash_offset=0, color=ManimColor('#FFFFFF'), equal_lengths=True, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **vmobject** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject))
+ * **num_dashes** (*int*)
+ * **dashed_ratio** (*float*)
+ * **dash_offset** (*float*)
+ * **color** ([*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor))
+ * **equal_lengths** (*bool*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.VDict.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.VDict.md
new file mode 100644
index 0000000000000000000000000000000000000000..af3ea5c4e7283da8d5b94e9c52277519c8f5fe8e
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.VDict.md
@@ -0,0 +1,298 @@
+# VDict
+
+Qualified name: `manim.mobject.types.vectorized\_mobject.VDict`
+
+### *class* VDict(mapping_or_iterable={}, show_keys=False, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A VGroup-like class, also offering submobject access by
+key, like a python dict
+
+* **Parameters:**
+ * **mapping_or_iterable** (*Mapping* *[**Hashable* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *|* *Iterable* *[**tuple* *[**Hashable* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *]*) – The parameter specifying the key-value mapping of keys and mobjects.
+ * **show_keys** (*bool*) – Whether to also display the key associated with
+ the mobject. This might be useful when debugging,
+ especially when there are a lot of mobjects in the
+ [`VDict`](#manim.mobject.types.vectorized_mobject.VDict). Defaults to False.
+ * **kwargs** – Other arguments to be passed to Mobject.
+
+#### show_keys
+
+Whether to also display the key associated with
+the mobject. This might be useful when debugging,
+especially when there are a lot of mobjects in the
+[`VDict`](#manim.mobject.types.vectorized_mobject.VDict). When displayed, the key is towards
+the left of the mobject.
+Defaults to False.
+
+* **Type:**
+ `bool`
+
+#### submob_dict
+
+Is the actual python dictionary that is used to bind
+the keys to the mobjects.
+
+* **Type:**
+ `dict`
+
+### Examples
+
+
+```python
+from manim import *
+
+class ShapesWithVDict(Scene):
+ def construct(self):
+ square = Square().set_color(RED)
+ circle = Circle().set_color(YELLOW).next_to(square, UP)
+
+ # create dict from list of tuples each having key-mobject pair
+ pairs = [("s", square), ("c", circle)]
+ my_dict = VDict(pairs, show_keys=True)
+
+ # display it just like a VGroup
+ self.play(Create(my_dict))
+ self.wait()
+
+ text = Tex("Some text").set_color(GREEN).next_to(square, DOWN)
+
+ # add a key-value pair by wrapping it in a single-element list of tuple
+ # after attrs branch is merged, it will be easier like `.add(t=text)`
+ my_dict.add([("t", text)])
+ self.wait()
+
+ rect = Rectangle().next_to(text, DOWN)
+ # can also do key assignment like a python dict
+ my_dict["r"] = rect
+
+ # access submobjects like a python dict
+ my_dict["t"].set_color(PURPLE)
+ self.play(my_dict["t"].animate.scale(3))
+ self.wait()
+
+ # also supports python dict styled reassignment
+ my_dict["t"] = Tex("Some other text").set_color(BLUE)
+ self.wait()
+
+ # remove submobject by key
+ my_dict.remove("t")
+ self.wait()
+
+ self.play(Uncreate(my_dict["s"]))
+ self.wait()
+
+ self.play(FadeOut(my_dict["c"]))
+ self.wait()
+
+ self.play(FadeOut(my_dict["r"], shift=DOWN))
+ self.wait()
+
+ # you can also make a VDict from an existing dict of mobjects
+ plain_dict = {
+ 1: Integer(1).shift(DOWN),
+ 2: Integer(2).shift(2 * DOWN),
+ 3: Integer(3).shift(3 * DOWN),
+ }
+
+ vdict_from_plain_dict = VDict(plain_dict)
+ vdict_from_plain_dict.shift(1.5 * (UP + LEFT))
+ self.play(Create(vdict_from_plain_dict))
+
+ # you can even use zip
+ vdict_using_zip = VDict(zip(["s", "c", "r"], [Square(), Circle(), Rectangle()]))
+ vdict_using_zip.shift(1.5 * RIGHT)
+ self.play(Create(vdict_using_zip))
+ self.wait()
+```
+
+
+class ShapesWithVDict(Scene):
+ def construct(self):
+ square = Square().set_color(RED)
+ circle = Circle().set_color(YELLOW).next_to(square, UP)
+
+ # create dict from list of tuples each having key-mobject pair
+ pairs = [("s", square), ("c", circle)]
+ my_dict = VDict(pairs, show_keys=True)
+
+ # display it just like a VGroup
+ self.play(Create(my_dict))
+ self.wait()
+
+ text = Tex("Some text").set_color(GREEN).next_to(square, DOWN)
+
+ # add a key-value pair by wrapping it in a single-element list of tuple
+ # after attrs branch is merged, it will be easier like \`.add(t=text)\`
+ my_dict.add([("t", text)])
+ self.wait()
+
+ rect = Rectangle().next_to(text, DOWN)
+ # can also do key assignment like a python dict
+ my_dict["r"] = rect
+
+ # access submobjects like a python dict
+ my_dict["t"].set_color(PURPLE)
+ self.play(my_dict["t"].animate.scale(3))
+ self.wait()
+
+ # also supports python dict styled reassignment
+ my_dict["t"] = Tex("Some other text").set_color(BLUE)
+ self.wait()
+
+ # remove submobject by key
+ my_dict.remove("t")
+ self.wait()
+
+ self.play(Uncreate(my_dict["s"]))
+ self.wait()
+
+ self.play(FadeOut(my_dict["c"]))
+ self.wait()
+
+ self.play(FadeOut(my_dict["r"], shift=DOWN))
+ self.wait()
+
+ # you can also make a VDict from an existing dict of mobjects
+ plain_dict = {
+ 1: Integer(1).shift(DOWN),
+ 2: Integer(2).shift(2 \* DOWN),
+ 3: Integer(3).shift(3 \* DOWN),
+ }
+
+ vdict_from_plain_dict = VDict(plain_dict)
+ vdict_from_plain_dict.shift(1.5 \* (UP + LEFT))
+ self.play(Create(vdict_from_plain_dict))
+
+ # you can even use zip
+ vdict_using_zip = VDict(zip(["s", "c", "r"], [Square(), Circle(), Rectangle()]))
+ vdict_using_zip.shift(1.5 \* RIGHT)
+ self.play(Create(vdict_using_zip))
+ self.wait()
+
+
+
+### Methods
+
+| [`add`](#manim.mobject.types.vectorized_mobject.VDict.add) | Adds the key-value pairs to the [`VDict`](#manim.mobject.types.vectorized_mobject.VDict) object. |
+|--------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`add_key_value_pair`](#manim.mobject.types.vectorized_mobject.VDict.add_key_value_pair) | A utility function used by [`add()`](#manim.mobject.types.vectorized_mobject.VDict.add) to add the key-value pair to [`submob_dict`](#manim.mobject.types.vectorized_mobject.VDict.submob_dict). |
+| [`get_all_submobjects`](#manim.mobject.types.vectorized_mobject.VDict.get_all_submobjects) | To get all the submobjects associated with a particular [`VDict`](#manim.mobject.types.vectorized_mobject.VDict) object |
+| [`remove`](#manim.mobject.types.vectorized_mobject.VDict.remove) | Removes the mobject from the [`VDict`](#manim.mobject.types.vectorized_mobject.VDict) object having the key key |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(mapping_or_iterable={}, show_keys=False, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **mapping_or_iterable** (*Mapping* *[**Hashable* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *|* *Iterable* *[**tuple* *[**Hashable* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *]*)
+ * **show_keys** (*bool*)
+* **Return type:**
+ None
+
+#### add(mapping_or_iterable)
+
+Adds the key-value pairs to the [`VDict`](#manim.mobject.types.vectorized_mobject.VDict) object.
+
+Also, it internally adds the value to the submobjects `list`
+of [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject), which is responsible for actual on-screen display.
+
+* **Parameters:**
+ **mapping_or_iterable** (*Mapping* *[**Hashable* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *|* *Iterable* *[**tuple* *[**Hashable* *,* [*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]* *]*) – The parameter specifying the key-value mapping of keys and mobjects.
+* **Returns:**
+ Returns the [`VDict`](#manim.mobject.types.vectorized_mobject.VDict) object on which this method was called.
+* **Return type:**
+ [`VDict`](#manim.mobject.types.vectorized_mobject.VDict)
+
+### Examples
+
+Normal usage:
+
+```default
+square_obj = Square()
+my_dict.add([("s", square_obj)])
+```
+
+#### add_key_value_pair(key, value)
+
+A utility function used by [`add()`](#manim.mobject.types.vectorized_mobject.VDict.add) to add the key-value pair
+to [`submob_dict`](#manim.mobject.types.vectorized_mobject.VDict.submob_dict). Not really meant to be used externally.
+
+* **Parameters:**
+ * **key** (*Hashable*) – The key of the submobject to be added.
+ * **value** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)) – The mobject associated with the key
+* **Return type:**
+ None
+* **Raises:**
+ **TypeError** – If the value is not an instance of VMobject
+
+### Examples
+
+Normal usage:
+
+```default
+square_obj = Square()
+self.add_key_value_pair("s", square_obj)
+```
+
+#### get_all_submobjects()
+
+To get all the submobjects associated with a particular [`VDict`](#manim.mobject.types.vectorized_mobject.VDict) object
+
+* **Returns:**
+ All the submobjects associated with the [`VDict`](#manim.mobject.types.vectorized_mobject.VDict) object
+* **Return type:**
+ `dict_values`
+
+### Examples
+
+Normal usage:
+
+```default
+for submob in my_dict.get_all_submobjects():
+ self.play(Create(submob))
+```
+
+#### remove(key)
+
+Removes the mobject from the [`VDict`](#manim.mobject.types.vectorized_mobject.VDict) object having the key key
+
+Also, it internally removes the mobject from the submobjects `list`
+of [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject), (which is responsible for removing it from the screen)
+
+* **Parameters:**
+ **key** (*Hashable*) – The key of the submoject to be removed.
+* **Returns:**
+ Returns the [`VDict`](#manim.mobject.types.vectorized_mobject.VDict) object on which this method was called.
+* **Return type:**
+ [`VDict`](#manim.mobject.types.vectorized_mobject.VDict)
+
+### Examples
+
+Normal usage:
+
+```default
+my_dict.remove("square")
+```
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.VGroup.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.VGroup.md
new file mode 100644
index 0000000000000000000000000000000000000000..52dc3ee9a2e92980d95fc0c9f0233bf0c1413963
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.VGroup.md
@@ -0,0 +1,238 @@
+# VGroup
+
+Qualified name: `manim.mobject.types.vectorized\_mobject.VGroup`
+
+### *class* VGroup(\*vmobjects, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+A group of vectorized mobjects.
+
+This can be used to group multiple [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) instances together
+in order to scale, move, … them together.
+
+### Notes
+
+When adding the same mobject more than once, repetitions are ignored.
+Use [`Mobject.copy()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.copy) to create a separate copy which can then
+be added to the group.
+
+### Examples
+
+To add `VGroup`, you can either use the
+[`add()`](#manim.mobject.types.vectorized_mobject.VGroup.add) method, or use the + and += operators. Similarly, you
+can subtract elements of a VGroup via `remove()` method, or
+- and -= operators:
+
+```pycon
+>>> from manim import Triangle, Square, VGroup
+>>> vg = VGroup()
+>>> triangle, square = Triangle(), Square()
+>>> vg.add(triangle)
+VGroup(Triangle)
+>>> vg + square # a new VGroup is constructed
+VGroup(Triangle, Square)
+>>> vg # not modified
+VGroup(Triangle)
+>>> vg += square
+>>> vg # modifies vg
+VGroup(Triangle, Square)
+>>> vg.remove(triangle)
+VGroup(Square)
+>>> vg - square # a new VGroup is constructed
+VGroup()
+>>> vg # not modified
+VGroup(Square)
+>>> vg -= square
+>>> vg # modifies vg
+VGroup()
+```
+
+
+```python
+from manim import *
+
+class ArcShapeIris(Scene):
+ def construct(self):
+ colors = [DARK_BROWN, BLUE_E, BLUE_D, BLUE_A, TEAL_B, GREEN_B, YELLOW_E]
+ radius = [1 + rad * 0.1 for rad in range(len(colors))]
+
+ circles_group = VGroup()
+
+ # zip(radius, color) makes the iterator [(radius[i], color[i]) for i in range(radius)]
+ circles_group.add(*[Circle(radius=rad, stroke_width=10, color=col)
+ for rad, col in zip(radius, colors)])
+ self.add(circles_group)
+```
+
+
+class ArcShapeIris(Scene):
+ def construct(self):
+ colors = [DARK_BROWN, BLUE_E, BLUE_D, BLUE_A, TEAL_B, GREEN_B, YELLOW_E]
+ radius = [1 + rad \* 0.1 for rad in range(len(colors))]
+
+ circles_group = VGroup()
+
+ # zip(radius, color) makes the iterator [(radius[i], color[i]) for i in range(radius)]
+ circles_group.add(\*[Circle(radius=rad, stroke_width=10, color=col)
+ for rad, col in zip(radius, colors)])
+ self.add(circles_group)
+
+
+
+### Methods
+
+| [`add`](#manim.mobject.types.vectorized_mobject.VGroup.add) | Checks if all passed elements are an instance, or iterables of VMobject and then adds them to submobjects |
+|---------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+* **Parameters:**
+ * **vmobjects** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *Iterable* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*)
+ * **kwargs** (*Any*)
+
+#### \_original_\_init_\_(\*vmobjects, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **vmobjects** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *Iterable* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*)
+ * **kwargs** (*Any*)
+* **Return type:**
+ None
+
+#### add(\*vmobjects)
+
+Checks if all passed elements are an instance, or iterables of VMobject and then adds them to submobjects
+
+* **Parameters:**
+ **vmobjects** ([*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *|* *Iterable* *[*[*VMobject*](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) *]*) – List or iterable of VMobjects to add
+* **Return type:**
+ [`VGroup`](#manim.mobject.types.vectorized_mobject.VGroup)
+* **Raises:**
+ **TypeError** – If one element of the list, or iterable is not an instance of VMobject
+
+### Examples
+
+The following example shows how to add individual or multiple VMobject instances through the VGroup
+constructor and its .add() method.
+
+
+```python
+from manim import *
+
+class AddToVGroup(Scene):
+ def construct(self):
+ circle_red = Circle(color=RED)
+ circle_green = Circle(color=GREEN)
+ circle_blue = Circle(color=BLUE)
+ circle_red.shift(LEFT)
+ circle_blue.shift(RIGHT)
+ gr = VGroup(circle_red, circle_green)
+ gr2 = VGroup(circle_blue) # Constructor uses add directly
+ self.add(gr,gr2)
+ self.wait()
+ gr += gr2 # Add group to another
+ self.play(
+ gr.animate.shift(DOWN),
+ )
+ gr -= gr2 # Remove group
+ self.play( # Animate groups separately
+ gr.animate.shift(LEFT),
+ gr2.animate.shift(UP),
+ )
+ self.play( #Animate groups without modification
+ (gr+gr2).animate.shift(RIGHT)
+ )
+ self.play( # Animate group without component
+ (gr-circle_red).animate.shift(RIGHT)
+ )
+```
+
+
+class AddToVGroup(Scene):
+ def construct(self):
+ circle_red = Circle(color=RED)
+ circle_green = Circle(color=GREEN)
+ circle_blue = Circle(color=BLUE)
+ circle_red.shift(LEFT)
+ circle_blue.shift(RIGHT)
+ gr = VGroup(circle_red, circle_green)
+ gr2 = VGroup(circle_blue) # Constructor uses add directly
+ self.add(gr,gr2)
+ self.wait()
+ gr += gr2 # Add group to another
+ self.play(
+ gr.animate.shift(DOWN),
+ )
+ gr -= gr2 # Remove group
+ self.play( # Animate groups separately
+ gr.animate.shift(LEFT),
+ gr2.animate.shift(UP),
+ )
+ self.play( #Animate groups without modification
+ (gr+gr2).animate.shift(RIGHT)
+ )
+ self.play( # Animate group without component
+ (gr-circle_red).animate.shift(RIGHT)
+ )
+
+
+
+A VGroup can be created using iterables as well. Keep in mind that all generated values from an
+iterable must be an instance of VMobject. This is demonstrated below:
+
+
+```python
+from manim import *
+
+class AddIterableToVGroupExample(Scene):
+ def construct(self):
+ v = VGroup(
+ Square(), # Singular VMobject instance
+ [Circle(), Triangle()], # List of VMobject instances
+ Dot(),
+ (Dot() for _ in range(2)), # Iterable that generates VMobjects
+ )
+ v.arrange()
+ self.add(v)
+```
+
+
+class AddIterableToVGroupExample(Scene):
+ def construct(self):
+ v = VGroup(
+ Square(), # Singular VMobject instance
+ [Circle(), Triangle()], # List of VMobject instances
+ Dot(),
+ (Dot() for \_ in range(2)), # Iterable that generates VMobjects
+ )
+ v.arrange()
+ self.add(v)
+
+
+
+To facilitate this, the iterable is unpacked before its individual instances are added to the VGroup.
+As a result, when you index a VGroup, you will never get back an iterable.
+Instead, you will always receive VMobject instances, including those
+that were part of the iterable/s that you originally added to the VGroup.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.VMobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.VMobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..65d89d67483eba131494ff135885a2267e767626
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.VMobject.md
@@ -0,0 +1,1150 @@
+# VMobject
+
+Qualified name: `manim.mobject.types.vectorized\_mobject.VMobject`
+
+### *class* VMobject(fill_color=None, fill_opacity=0.0, stroke_color=None, stroke_opacity=1.0, stroke_width=4, background_stroke_color=ManimColor('#000000'), background_stroke_opacity=1.0, background_stroke_width=0, sheen_factor=0.0, joint_type=None, sheen_direction=array([-1., 1., 0.]), close_new_points=False, pre_function_handle_to_anchor_scale_factor=0.01, make_smooth_after_applying_functions=False, background_image=None, shade_in_3d=False, tolerance_for_point_equality=1e-06, n_points_per_cubic_curve=4, cap_style=CapStyleType.AUTO, \*\*kwargs)
+
+Bases: [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+A vectorized mobject.
+
+* **Parameters:**
+ * **background_stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The purpose of background stroke is to have something
+ that won’t overlap fill, e.g. For text against some
+ textured background.
+ * **sheen_factor** (*float*) – When a color c is set, there will be a second color
+ computed based on interpolating c to WHITE by with
+ sheen_factor, and the display will gradient to this
+ secondary color in the direction of sheen_direction.
+ * **close_new_points** (*bool*) – Indicates that it will not be displayed, but
+ that it should count in parent mobject’s path
+ * **tolerance_for_point_equality** (*float*) – This is within a pixel
+ * **joint_type** ([*LineJointType*](manim.constants.LineJointType.md#manim.constants.LineJointType) *|* *None*) – The line joint type used to connect the curve segments
+ of this vectorized mobject. See [`LineJointType`](manim.constants.LineJointType.md#manim.constants.LineJointType)
+ for options.
+ * **fill_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **fill_opacity** (*float*)
+ * **stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **stroke_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **background_stroke_opacity** (*float*)
+ * **background_stroke_width** (*float*)
+ * **sheen_direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+ * **pre_function_handle_to_anchor_scale_factor** (*float*)
+ * **make_smooth_after_applying_functions** (*bool*)
+ * **background_image** (*Image* *|* *str* *|* *None*)
+ * **shade_in_3d** (*bool*)
+ * **n_points_per_cubic_curve** (*int*)
+ * **cap_style** ([*CapStyleType*](manim.constants.CapStyleType.md#manim.constants.CapStyleType))
+ * **kwargs** (*Any*)
+
+### Methods
+
+| `add_cubic_bezier_curve` | |
+|-------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`add_cubic_bezier_curve_to`](#manim.mobject.types.vectorized_mobject.VMobject.add_cubic_bezier_curve_to) | Add cubic bezier curve to the path. |
+| `add_cubic_bezier_curves` | |
+| [`add_line_to`](#manim.mobject.types.vectorized_mobject.VMobject.add_line_to) | Add a straight line from the last point of VMobject to the given point. |
+| [`add_points_as_corners`](#manim.mobject.types.vectorized_mobject.VMobject.add_points_as_corners) | Append multiple straight lines at the end of `VMobject.points`, which connect the given `points` in order starting from the end of the current path. |
+| [`add_quadratic_bezier_curve_to`](#manim.mobject.types.vectorized_mobject.VMobject.add_quadratic_bezier_curve_to) | Add Quadratic bezier curve to the path. |
+| [`add_smooth_curve_to`](#manim.mobject.types.vectorized_mobject.VMobject.add_smooth_curve_to) | Creates a smooth curve from given points and add it to the VMobject. |
+| `add_subpath` | |
+| [`align_points`](#manim.mobject.types.vectorized_mobject.VMobject.align_points) | Adds points to self and vmobject so that they both have the same number of subpaths, with corresponding subpaths each containing the same number of points. |
+| `align_rgbas` | |
+| [`append_points`](#manim.mobject.types.vectorized_mobject.VMobject.append_points) | Append the given `new_points` to the end of `VMobject.points`. |
+| `append_vectorized_mobject` | |
+| `apply_function` | |
+| [`change_anchor_mode`](#manim.mobject.types.vectorized_mobject.VMobject.change_anchor_mode) | Changes the anchor mode of the bezier curves. |
+| `clear_points` | |
+| `close_path` | |
+| `color_using_background_image` | |
+| `consider_points_equals` | |
+| [`consider_points_equals_2d`](#manim.mobject.types.vectorized_mobject.VMobject.consider_points_equals_2d) | Determine if two points are close enough to be considered equal. |
+| `fade` | |
+| [`force_direction`](#manim.mobject.types.vectorized_mobject.VMobject.force_direction) | Makes sure that points are either directed clockwise or counterclockwise. |
+| [`gen_cubic_bezier_tuples_from_points`](#manim.mobject.types.vectorized_mobject.VMobject.gen_cubic_bezier_tuples_from_points) | Returns the bezier tuples from an array of points. |
+| `gen_subpaths_from_points_2d` | |
+| [`generate_rgbas_array`](#manim.mobject.types.vectorized_mobject.VMobject.generate_rgbas_array) | First arg can be either a color, or a tuple/list of colors. |
+| [`get_anchors`](#manim.mobject.types.vectorized_mobject.VMobject.get_anchors) | Returns the anchors of the curves forming the VMobject. |
+| [`get_anchors_and_handles`](#manim.mobject.types.vectorized_mobject.VMobject.get_anchors_and_handles) | Returns anchors1, handles1, handles2, anchors2, where (anchors1[i], handles1[i], handles2[i], anchors2[i]) will be four points defining a cubic bezier curve for any i in range(0, len(anchors1)) |
+| [`get_arc_length`](#manim.mobject.types.vectorized_mobject.VMobject.get_arc_length) | Return the approximated length of the whole curve. |
+| `get_background_image` | |
+| [`get_color`](#manim.mobject.types.vectorized_mobject.VMobject.get_color) | Returns the color of the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) |
+| `get_cubic_bezier_tuples` | |
+| `get_cubic_bezier_tuples_from_points` | |
+| [`get_curve_functions`](#manim.mobject.types.vectorized_mobject.VMobject.get_curve_functions) | Gets the functions for the curves of the mobject. |
+| [`get_curve_functions_with_lengths`](#manim.mobject.types.vectorized_mobject.VMobject.get_curve_functions_with_lengths) | Gets the functions and lengths of the curves for the mobject. |
+| [`get_direction`](#manim.mobject.types.vectorized_mobject.VMobject.get_direction) | Uses [`shoelace_direction()`](manim.utils.space_ops.md#manim.utils.space_ops.shoelace_direction) to calculate the direction. |
+| [`get_end_anchors`](#manim.mobject.types.vectorized_mobject.VMobject.get_end_anchors) | Return the end anchors of the bezier curves. |
+| [`get_fill_color`](#manim.mobject.types.vectorized_mobject.VMobject.get_fill_color) | If there are multiple colors (for gradient) this returns the first one |
+| `get_fill_colors` | |
+| `get_fill_opacities` | |
+| [`get_fill_opacity`](#manim.mobject.types.vectorized_mobject.VMobject.get_fill_opacity) | If there are multiple opacities, this returns the first |
+| `get_fill_rgbas` | |
+| `get_gradient_start_and_end_points` | |
+| `get_group_class` | |
+| `get_last_point` | |
+| [`get_mobject_type_class`](#manim.mobject.types.vectorized_mobject.VMobject.get_mobject_type_class) | Return the base class of this mobject type. |
+| [`get_nth_curve_function`](#manim.mobject.types.vectorized_mobject.VMobject.get_nth_curve_function) | Returns the expression of the nth curve. |
+| [`get_nth_curve_function_with_length`](#manim.mobject.types.vectorized_mobject.VMobject.get_nth_curve_function_with_length) | Returns the expression of the nth curve along with its (approximate) length. |
+| [`get_nth_curve_length`](#manim.mobject.types.vectorized_mobject.VMobject.get_nth_curve_length) | Returns the (approximate) length of the nth curve. |
+| [`get_nth_curve_length_pieces`](#manim.mobject.types.vectorized_mobject.VMobject.get_nth_curve_length_pieces) | Returns the array of short line lengths used for length approximation. |
+| [`get_nth_curve_points`](#manim.mobject.types.vectorized_mobject.VMobject.get_nth_curve_points) | Returns the points defining the nth curve of the vmobject. |
+| [`get_num_curves`](#manim.mobject.types.vectorized_mobject.VMobject.get_num_curves) | Returns the number of curves of the vmobject. |
+| [`get_point_mobject`](#manim.mobject.types.vectorized_mobject.VMobject.get_point_mobject) | The simplest [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) to be transformed to or from self. |
+| `get_points_defining_boundary` | |
+| `get_sheen_direction` | |
+| `get_sheen_factor` | |
+| [`get_start_anchors`](#manim.mobject.types.vectorized_mobject.VMobject.get_start_anchors) | Returns the start anchors of the bezier curves. |
+| `get_stroke_color` | |
+| `get_stroke_colors` | |
+| `get_stroke_opacities` | |
+| `get_stroke_opacity` | |
+| `get_stroke_rgbas` | |
+| `get_stroke_width` | |
+| `get_style` | |
+| [`get_subcurve`](#manim.mobject.types.vectorized_mobject.VMobject.get_subcurve) | Returns the subcurve of the VMobject between the interval [a, b]. |
+| [`get_subpaths`](#manim.mobject.types.vectorized_mobject.VMobject.get_subpaths) | Returns subpaths formed by the curves of the VMobject. |
+| `get_subpaths_from_points` | |
+| `has_new_path_started` | |
+| [`init_colors`](#manim.mobject.types.vectorized_mobject.VMobject.init_colors) | Initializes the colors. |
+| [`insert_n_curves`](#manim.mobject.types.vectorized_mobject.VMobject.insert_n_curves) | Inserts n curves to the bezier curves of the vmobject. |
+| [`insert_n_curves_to_point_list`](#manim.mobject.types.vectorized_mobject.VMobject.insert_n_curves_to_point_list) | Given an array of k points defining a bezier curves (anchors and handles), returns points defining exactly k + n bezier curves. |
+| `interpolate_color` | |
+| `is_closed` | |
+| `make_jagged` | |
+| `make_smooth` | |
+| `match_background_image` | |
+| `match_style` | |
+| [`point_from_proportion`](#manim.mobject.types.vectorized_mobject.VMobject.point_from_proportion) | Gets the point at a proportion along the path of the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject). |
+| [`pointwise_become_partial`](#manim.mobject.types.vectorized_mobject.VMobject.pointwise_become_partial) | Given a 2nd [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject) `vmobject`, a lower bound `a` and an upper bound `b`, modify this [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)'s points to match the portion of the Bézier spline described by `vmobject.points` with the parameter `t` between `a` and `b`. |
+| [`proportion_from_point`](#manim.mobject.types.vectorized_mobject.VMobject.proportion_from_point) | Returns the proportion along the path of the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject) a particular given point is at. |
+| [`resize_points`](#manim.mobject.types.vectorized_mobject.VMobject.resize_points) | Resize the array of anchor points and handles to have the specified size. |
+| [`reverse_direction`](#manim.mobject.types.vectorized_mobject.VMobject.reverse_direction) | Reverts the point direction by inverting the point order. |
+| [`rotate`](#manim.mobject.types.vectorized_mobject.VMobject.rotate) | Rotates the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) about a certain point. |
+| [`rotate_sheen_direction`](#manim.mobject.types.vectorized_mobject.VMobject.rotate_sheen_direction) | Rotates the direction of the applied sheen. |
+| [`scale`](#manim.mobject.types.vectorized_mobject.VMobject.scale) | Scale the size by a factor. |
+| [`scale_handle_to_anchor_distances`](#manim.mobject.types.vectorized_mobject.VMobject.scale_handle_to_anchor_distances) | If the distance between a given handle point H and its associated anchor point A is d, then it changes H to be a distances factor\*d away from A, but so that the line from A to H doesn't change. |
+| [`set_anchors_and_handles`](#manim.mobject.types.vectorized_mobject.VMobject.set_anchors_and_handles) | Given two sets of anchors and handles, process them to set them as anchors and handles of the VMobject. |
+| `set_background_stroke` | |
+| [`set_cap_style`](#manim.mobject.types.vectorized_mobject.VMobject.set_cap_style) | Sets the cap style of the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject). |
+| [`set_color`](#manim.mobject.types.vectorized_mobject.VMobject.set_color) | Condition is function which takes in one arguments, (x, y, z). |
+| [`set_fill`](#manim.mobject.types.vectorized_mobject.VMobject.set_fill) | Set the fill color and fill opacity of a [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject). |
+| `set_opacity` | |
+| `set_points` | |
+| [`set_points_as_corners`](#manim.mobject.types.vectorized_mobject.VMobject.set_points_as_corners) | Given an array of points, set them as corners of the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject). |
+| `set_points_smoothly` | |
+| `set_shade_in_3d` | |
+| [`set_sheen`](#manim.mobject.types.vectorized_mobject.VMobject.set_sheen) | Applies a color gradient from a direction. |
+| [`set_sheen_direction`](#manim.mobject.types.vectorized_mobject.VMobject.set_sheen_direction) | Sets the direction of the applied sheen. |
+| `set_stroke` | |
+| `set_style` | |
+| [`start_new_path`](#manim.mobject.types.vectorized_mobject.VMobject.start_new_path) | Append a `point` to the `VMobject.points`, which will be the beginning of a new Bézier curve in the path given by the points. |
+| `update_rgbas_array` | |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------------------------------------------------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| [`fill_color`](#manim.mobject.types.vectorized_mobject.VMobject.fill_color) | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_assert_valid_submobjects(submobjects)
+
+Check that all submobjects are actually instances of
+`Mobject`, and that none of them is `self` (a
+`Mobject` cannot contain itself).
+
+This is an auxiliary function called when adding Mobjects to the
+`submobjects` list.
+
+This function is intended to be overridden by subclasses such as
+[`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject), which should assert that only other VMobjects
+may be added into it.
+
+* **Parameters:**
+ **submobjects** (*Iterable* *[*[*VMobject*](#manim.mobject.types.vectorized_mobject.VMobject) *]*) – The list containing values to validate.
+* **Returns:**
+ The Mobject itself.
+* **Return type:**
+ `Mobject`
+* **Raises:**
+ * **TypeError** – If any of the values in submobjects is not a `Mobject`.
+ * **ValueError** – If there was an attempt to add a `Mobject` as its own
+ submobject.
+
+#### \_gen_subpaths_from_points(points, filter_func)
+
+Given an array of points defining the bezier curves of the vmobject, return subpaths formed by these points.
+Here, Two bezier curves form a path if at least two of their anchors are evaluated True by the relation defined by filter_func.
+
+The algorithm every bezier tuple (anchors and handles) in `self.points` (by regrouping each n elements, where
+n is the number of points per cubic curve)), and evaluate the relation between two anchors with filter_func.
+NOTE : The filter_func takes an int n as parameter, and will evaluate the relation between points[n] and points[n - 1]. This should probably be changed so
+the function takes two points as parameters.
+
+* **Parameters:**
+ * **points** ([*CubicBezierPath*](manim.typing.md#manim.typing.CubicBezierPath)) – points defining the bezier curve.
+ * **filter_func** (*Callable* *[* *[**int* *]* *,* *bool* *]*) – Filter-func defining the relation.
+* **Returns:**
+ subpaths formed by the points.
+* **Return type:**
+ Iterable[[CubicSpline](manim.typing.md#manim.typing.CubicSpline)]
+
+#### \_original_\_init_\_(fill_color=None, fill_opacity=0.0, stroke_color=None, stroke_opacity=1.0, stroke_width=4, background_stroke_color=ManimColor('#000000'), background_stroke_opacity=1.0, background_stroke_width=0, sheen_factor=0.0, joint_type=None, sheen_direction=array([-1., 1., 0.]), close_new_points=False, pre_function_handle_to_anchor_scale_factor=0.01, make_smooth_after_applying_functions=False, background_image=None, shade_in_3d=False, tolerance_for_point_equality=1e-06, n_points_per_cubic_curve=4, cap_style=CapStyleType.AUTO, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **fill_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **fill_opacity** (*float*)
+ * **stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **stroke_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **background_stroke_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **background_stroke_opacity** (*float*)
+ * **background_stroke_width** (*float*)
+ * **sheen_factor** (*float*)
+ * **joint_type** ([*LineJointType*](manim.constants.LineJointType.md#manim.constants.LineJointType) *|* *None*)
+ * **sheen_direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+ * **close_new_points** (*bool*)
+ * **pre_function_handle_to_anchor_scale_factor** (*float*)
+ * **make_smooth_after_applying_functions** (*bool*)
+ * **background_image** (*Image* *|* *str* *|* *None*)
+ * **shade_in_3d** (*bool*)
+ * **tolerance_for_point_equality** (*float*)
+ * **n_points_per_cubic_curve** (*int*)
+ * **cap_style** ([*CapStyleType*](manim.constants.CapStyleType.md#manim.constants.CapStyleType))
+ * **kwargs** (*Any*)
+
+#### add_cubic_bezier_curve_to(handle1, handle2, anchor)
+
+Add cubic bezier curve to the path.
+
+NOTE : the first anchor is not a parameter as by default the end of the last sub-path!
+
+* **Parameters:**
+ * **handle1** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – first handle
+ * **handle2** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – second handle
+ * **anchor** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – anchor
+* **Returns:**
+ `self`
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### add_line_to(point)
+
+Add a straight line from the last point of VMobject to the given point.
+
+* **Parameters:**
+ **point** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – The end of the straight line.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### add_points_as_corners(points)
+
+Append multiple straight lines at the end of
+`VMobject.points`, which connect the given `points` in order
+starting from the end of the current path. These `points` would be
+therefore the corners of the new polyline appended to the path.
+
+* **Parameters:**
+ **points** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array)) – An array of 3D points representing the corners of the polyline to
+ append to `VMobject.points`.
+* **Returns:**
+ The VMobject itself, after appending the straight lines to its
+ path.
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### add_quadratic_bezier_curve_to(handle, anchor)
+
+Add Quadratic bezier curve to the path.
+
+* **Returns:**
+ `self`
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+* **Parameters:**
+ * **handle** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **anchor** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+
+#### add_smooth_curve_to(\*points)
+
+Creates a smooth curve from given points and add it to the VMobject. If two points are passed in, the first is interpreted
+as a handle, the second as an anchor.
+
+* **Parameters:**
+ **points** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – Points (anchor and handle, or just anchor) to add a smooth curve from
+* **Returns:**
+ `self`
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+* **Raises:**
+ **ValueError** – If 0 or more than 2 points are given.
+
+#### align_points(vmobject)
+
+Adds points to self and vmobject so that they both have the same number of subpaths, with
+corresponding subpaths each containing the same number of points.
+
+Points are added either by subdividing curves evenly along the subpath, or by creating new subpaths consisting
+of a single point repeated.
+
+* **Parameters:**
+ **vmobject** ([*VMobject*](#manim.mobject.types.vectorized_mobject.VMobject)) – The object to align points with.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### append_points(new_points)
+
+Append the given `new_points` to the end of
+`VMobject.points`.
+
+* **Parameters:**
+ **new_points** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array)) – An array of 3D points to append.
+* **Returns:**
+ The VMobject itself, after appending `new_points`.
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### change_anchor_mode(mode)
+
+Changes the anchor mode of the bezier curves. This will modify the handles.
+
+There can be only two modes, “jagged”, and “smooth”.
+
+* **Returns:**
+ `self`
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+* **Parameters:**
+ **mode** (*Literal* *[* *'jagged'* *,* *'smooth'* *]*)
+
+#### consider_points_equals_2d(p0, p1)
+
+Determine if two points are close enough to be considered equal.
+
+This uses the algorithm from np.isclose(), but expanded here for the
+2D point case. NumPy is overkill for such a small question.
+:param p0: first point
+:param p1: second point
+
+* **Returns:**
+ whether two points considered close.
+* **Return type:**
+ bool
+* **Parameters:**
+ * **p0** ([*Point2DLike*](manim.typing.md#manim.typing.Point2DLike))
+ * **p1** ([*Point2DLike*](manim.typing.md#manim.typing.Point2DLike))
+
+#### *property* fill_color *: [ManimColor](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)*
+
+If there are multiple colors (for gradient)
+this returns the first one
+
+#### force_direction(target_direction)
+
+Makes sure that points are either directed clockwise or
+counterclockwise.
+
+* **Parameters:**
+ **target_direction** (*Literal* *[* *'CW'* *,* *'CCW'* *]*) – Either `"CW"` or `"CCW"`.
+* **Return type:**
+ Self
+
+#### gen_cubic_bezier_tuples_from_points(points)
+
+Returns the bezier tuples from an array of points.
+
+self.points is a list of the anchors and handles of the bezier curves of the mobject (ie [anchor1, handle1, handle2, anchor2, anchor3 ..])
+This algorithm basically retrieve them by taking an element every n, where n is the number of control points
+of the bezier curve.
+
+* **Parameters:**
+ **points** ([*CubicBezierPathLike*](manim.typing.md#manim.typing.CubicBezierPathLike)) – Points from which control points will be extracted.
+* **Returns:**
+ Bezier control points.
+* **Return type:**
+ tuple
+
+#### generate_rgbas_array(color, opacity)
+
+First arg can be either a color, or a tuple/list of colors.
+Likewise, opacity can either be a float, or a tuple of floats.
+If self.sheen_factor is not zero, and only
+one color was passed in, a second slightly light color
+will automatically be added for the gradient
+
+* **Parameters:**
+ * **color** ([*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) *|* *list* *[*[*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) *]*)
+ * **opacity** (*float* *|* *Iterable* *[**float* *]*)
+* **Return type:**
+ [*RGBA_Array_Float*](manim.typing.md#manim.typing.RGBA_Array_Float)
+
+#### get_anchors()
+
+Returns the anchors of the curves forming the VMobject.
+
+* **Returns:**
+ The anchors.
+* **Return type:**
+ [Point3D_Array](manim.typing.md#manim.typing.Point3D_Array)
+
+#### get_anchors_and_handles()
+
+Returns anchors1, handles1, handles2, anchors2,
+where (anchors1[i], handles1[i], handles2[i], anchors2[i])
+will be four points defining a cubic bezier curve
+for any i in range(0, len(anchors1))
+
+* **Returns:**
+ Iterable of the anchors and handles.
+* **Return type:**
+ list[Point3D_Array]
+
+#### get_arc_length(sample_points_per_curve=None)
+
+Return the approximated length of the whole curve.
+
+* **Parameters:**
+ **sample_points_per_curve** (*int* *|* *None*) – Number of sample points per curve used to approximate the length. More points result in a better approximation.
+* **Returns:**
+ The length of the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject).
+* **Return type:**
+ float
+
+#### get_color()
+
+Returns the color of the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+### Examples
+
+```default
+>>> from manim import Square, RED
+>>> Square(color=RED).get_color() == RED
+True
+```
+
+* **Return type:**
+ [*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+
+#### get_curve_functions()
+
+Gets the functions for the curves of the mobject.
+
+* **Returns:**
+ The functions for the curves.
+* **Return type:**
+ Iterable[Callable[[float], [Point3D](manim.typing.md#manim.typing.Point3D)]]
+
+#### get_curve_functions_with_lengths(\*\*kwargs)
+
+Gets the functions and lengths of the curves for the mobject.
+
+* **Parameters:**
+ **\*\*kwargs** – The keyword arguments passed to [`get_nth_curve_function_with_length()`](#manim.mobject.types.vectorized_mobject.VMobject.get_nth_curve_function_with_length)
+* **Returns:**
+ The functions and lengths of the curves.
+* **Return type:**
+ Iterable[tuple[Callable[[float], [Point3D](manim.typing.md#manim.typing.Point3D)], float]]
+
+#### get_direction()
+
+Uses [`shoelace_direction()`](manim.utils.space_ops.md#manim.utils.space_ops.shoelace_direction) to calculate the direction.
+The direction of points determines in which direction the
+object is drawn, clockwise or counterclockwise.
+
+### Examples
+
+The default direction of a [`Circle`](manim.mobject.geometry.arc.Circle.md#manim.mobject.geometry.arc.Circle) is counterclockwise:
+
+```default
+>>> from manim import Circle
+>>> Circle().get_direction()
+'CCW'
+```
+
+* **Returns:**
+ Either `"CW"` or `"CCW"`.
+* **Return type:**
+ `str`
+
+#### get_end_anchors()
+
+Return the end anchors of the bezier curves.
+
+* **Returns:**
+ Starting anchors
+* **Return type:**
+ [Point3D_Array](manim.typing.md#manim.typing.Point3D_Array)
+
+#### get_fill_color()
+
+If there are multiple colors (for gradient)
+this returns the first one
+
+* **Return type:**
+ [*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+
+#### get_fill_opacity()
+
+If there are multiple opacities, this returns the
+first
+
+* **Return type:**
+ [*ManimFloat*](manim.typing.md#manim.typing.ManimFloat)
+
+#### *static* get_mobject_type_class()
+
+Return the base class of this mobject type.
+
+* **Return type:**
+ type[[*VMobject*](#manim.mobject.types.vectorized_mobject.VMobject)]
+
+#### get_nth_curve_function(n)
+
+Returns the expression of the nth curve.
+
+* **Parameters:**
+ **n** (*int*) – index of the desired curve.
+* **Returns:**
+ expression of the nth bezier curve.
+* **Return type:**
+ Callable[float, [Point3D](manim.typing.md#manim.typing.Point3D)]
+
+#### get_nth_curve_function_with_length(n, sample_points=None)
+
+Returns the expression of the nth curve along with its (approximate) length.
+
+* **Parameters:**
+ * **n** (*int*) – The index of the desired curve.
+ * **sample_points** (*int* *|* *None*) – The number of points to sample to find the length.
+* **Returns:**
+ * **curve** (*Callable[[float], Point3D]*) – The function for the nth curve.
+ * **length** (`float`) – The length of the nth curve.
+* **Return type:**
+ tuple[*Callable*[[float], [*Point3D*](manim.typing.md#manim.typing.Point3D)], float]
+
+#### get_nth_curve_length(n, sample_points=None)
+
+Returns the (approximate) length of the nth curve.
+
+* **Parameters:**
+ * **n** (*int*) – The index of the desired curve.
+ * **sample_points** (*int* *|* *None*) – The number of points to sample to find the length.
+* **Returns:**
+ **length** – The length of the nth curve.
+* **Return type:**
+ `float`
+
+#### get_nth_curve_length_pieces(n, sample_points=None)
+
+Returns the array of short line lengths used for length approximation.
+
+* **Parameters:**
+ * **n** (*int*) – The index of the desired curve.
+ * **sample_points** (*int* *|* *None*) – The number of points to sample to find the length.
+* **Return type:**
+ The short length-pieces of the nth curve.
+
+#### get_nth_curve_points(n)
+
+Returns the points defining the nth curve of the vmobject.
+
+* **Parameters:**
+ **n** (*int*) – index of the desired bezier curve.
+* **Returns:**
+ points defining the nth bezier curve (anchors, handles)
+* **Return type:**
+ [CubicBezierPoints](manim.typing.md#manim.typing.CubicBezierPoints)
+
+#### get_num_curves()
+
+Returns the number of curves of the vmobject.
+
+* **Returns:**
+ number of curves of the vmobject.
+* **Return type:**
+ int
+
+#### get_point_mobject(center=None)
+
+The simplest [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) to be transformed to or from self.
+Should by a point of the appropriate type
+
+* **Parameters:**
+ **center** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* *None*)
+* **Return type:**
+ [VectorizedPoint](manim.mobject.types.vectorized_mobject.VectorizedPoint.md#manim.mobject.types.vectorized_mobject.VectorizedPoint)
+
+#### get_start_anchors()
+
+Returns the start anchors of the bezier curves.
+
+* **Returns:**
+ Starting anchors
+* **Return type:**
+ [Point3D_Array](manim.typing.md#manim.typing.Point3D_Array)
+
+#### get_subcurve(a, b)
+
+Returns the subcurve of the VMobject between the interval [a, b].
+The curve is a VMobject itself.
+
+* **Parameters:**
+ * **a** (*float*) – The lower bound.
+ * **b** (*float*) – The upper bound.
+* **Returns:**
+ The subcurve between of [a, b]
+* **Return type:**
+ [VMobject](#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### get_subpaths()
+
+Returns subpaths formed by the curves of the VMobject.
+
+Subpaths are ranges of curves with each pair of consecutive curves having their end/start points coincident.
+
+* **Returns:**
+ subpaths.
+* **Return type:**
+ list[[CubicSpline](manim.typing.md#manim.typing.CubicSpline)]
+
+#### init_colors(propagate_colors=True)
+
+Initializes the colors.
+
+Gets called upon creation. This is an empty method that can be implemented by
+subclasses.
+
+* **Parameters:**
+ **propagate_colors** (*bool*)
+* **Return type:**
+ Self
+
+#### insert_n_curves(n)
+
+Inserts n curves to the bezier curves of the vmobject.
+
+* **Parameters:**
+ **n** (*int*) – Number of curves to insert.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### insert_n_curves_to_point_list(n, points)
+
+Given an array of k points defining a bezier curves (anchors and handles), returns points defining exactly k + n bezier curves.
+
+* **Parameters:**
+ * **n** (*int*) – Number of desired curves.
+ * **points** ([*BezierPathLike*](manim.typing.md#manim.typing.BezierPathLike)) – Starting points.
+* **Return type:**
+ Points generated.
+
+#### point_from_proportion(alpha)
+
+Gets the point at a proportion along the path of the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject).
+
+* **Parameters:**
+ **alpha** (*float*) – The proportion along the the path of the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject).
+* **Returns:**
+ The point on the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject).
+* **Return type:**
+ `numpy.ndarray`
+* **Raises:**
+ * **ValueError** – If `alpha` is not between 0 and 1.
+ * **Exception** – If the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject) has no points.
+
+### Example
+
+
+
+#### pointwise_become_partial(vmobject, a, b)
+
+Given a 2nd [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject) `vmobject`, a lower bound `a` and
+an upper bound `b`, modify this [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)’s points to
+match the portion of the Bézier spline described by `vmobject.points`
+with the parameter `t` between `a` and `b`.
+
+* **Parameters:**
+ * **vmobject** ([*VMobject*](#manim.mobject.types.vectorized_mobject.VMobject)) – The [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject) that will serve as a model.
+ * **a** (*float*) – The lower bound for `t`.
+ * **b** (*float*) – The upper bound for `t`
+* **Returns:**
+ The [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject) itself, after the transformation.
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+* **Raises:**
+ **TypeError** – If `vmobject` is not an instance of [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject).
+
+#### proportion_from_point(point)
+
+Returns the proportion along the path of the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+a particular given point is at.
+
+* **Parameters:**
+ **point** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – The Cartesian coordinates of the point which may or may not lie on the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+* **Returns:**
+ The proportion along the path of the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject).
+* **Return type:**
+ float
+* **Raises:**
+ * **ValueError** – If `point` does not lie on the curve.
+ * **Exception** – If the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject) has no points.
+
+#### resize_points(new_length, resize_func=)
+
+Resize the array of anchor points and handles to have
+the specified size.
+
+* **Parameters:**
+ * **new_length** (*int*) – The new (total) number of points.
+ * **resize_func** (*Callable* *[* *[*[*Point3D_Array*](manim.typing.md#manim.typing.Point3D_Array) *,* *int* *]* *,* [*Point3D_Array*](manim.typing.md#manim.typing.Point3D_Array) *]*) – A function mapping a Numpy array (the points) and an integer
+ (the target size) to a Numpy array. The default implementation
+ is based on Numpy’s `resize` function.
+* **Return type:**
+ Self
+
+#### reverse_direction()
+
+Reverts the point direction by inverting the point order.
+
+* **Returns:**
+ Returns self.
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+
+### Examples
+
+
+
+#### rotate(angle, axis=array([0., 0., 1.]), about_point=None, \*\*kwargs)
+
+Rotates the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) about a certain point.
+
+* **Parameters:**
+ * **angle** (*float*)
+ * **axis** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D))
+ * **about_point** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike) *|* *None*)
+* **Return type:**
+ Self
+
+#### rotate_sheen_direction(angle, axis=array([0., 0., 1.]), family=True)
+
+Rotates the direction of the applied sheen.
+
+* **Parameters:**
+ * **angle** (*float*) – Angle by which the direction of sheen is rotated.
+ * **axis** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D)) – Axis of rotation.
+ * **family** (*bool*)
+* **Return type:**
+ Self
+
+### Examples
+
+Normal usage:
+
+```default
+Circle().set_sheen_direction(UP).rotate_sheen_direction(PI)
+```
+
+#### SEE ALSO
+[`set_sheen_direction()`](#manim.mobject.types.vectorized_mobject.VMobject.set_sheen_direction)
+
+#### scale(scale_factor, scale_stroke=False, \*\*kwargs)
+
+Scale the size by a factor.
+
+Default behavior is to scale about the center of the vmobject.
+
+* **Parameters:**
+ * **scale_factor** (*float*) – The scaling factor $\alpha$. If $0 < |\alpha| < 1$, the mobject
+ will shrink, and for $|\alpha| > 1$ it will grow. Furthermore,
+ if $\alpha < 0$, the mobject is also flipped.
+ * **scale_stroke** (*bool*) – Boolean determining if the object’s outline is scaled when the object is scaled.
+ If enabled, and object with 2px outline is scaled by a factor of .5, it will have an outline of 1px.
+ * **kwargs** – Additional keyword arguments passed to
+ [`scale()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.scale).
+* **Returns:**
+ `self`
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+
+### Examples
+
+
+
+#### SEE ALSO
+`move_to()`
+
+#### scale_handle_to_anchor_distances(factor)
+
+If the distance between a given handle point H and its associated
+anchor point A is d, then it changes H to be a distances factor\*d
+away from A, but so that the line from A to H doesn’t change.
+This is mostly useful in the context of applying a (differentiable)
+function, to preserve tangency properties. One would pull all the
+handles closer to their anchors, apply the function then push them out
+again.
+
+* **Parameters:**
+ **factor** (*float*) – The factor used for scaling.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### set_anchors_and_handles(anchors1, handles1, handles2, anchors2)
+
+Given two sets of anchors and handles, process them to set them as anchors
+and handles of the VMobject.
+
+anchors1[i], handles1[i], handles2[i] and anchors2[i] define the i-th bezier
+curve of the vmobject. There are four hardcoded parameters and this is a
+problem as it makes the number of points per cubic curve unchangeable from 4
+(two anchors and two handles).
+
+* **Returns:**
+ `self`
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+* **Parameters:**
+ * **anchors1** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array))
+ * **handles1** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array))
+ * **handles2** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array))
+ * **anchors2** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array))
+
+#### set_cap_style(cap_style)
+
+Sets the cap style of the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject).
+
+* **Parameters:**
+ **cap_style** ([*CapStyleType*](manim.constants.CapStyleType.md#manim.constants.CapStyleType)) – The cap style to be set. See [`CapStyleType`](manim.constants.CapStyleType.md#manim.constants.CapStyleType) for options.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+
+### Examples
+
+
+
+#### set_color(color, family=True)
+
+Condition is function which takes in one arguments, (x, y, z).
+Here it just recurses to submobjects, but in subclasses this
+should be further implemented based on the the inner workings
+of color
+
+* **Parameters:**
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor))
+ * **family** (*bool*)
+* **Return type:**
+ Self
+
+#### set_fill(color=None, opacity=None, family=True)
+
+Set the fill color and fill opacity of a [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject).
+
+* **Parameters:**
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – Fill color of the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject).
+ * **opacity** (*float* *|* *None*) – Fill opacity of the [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject).
+ * **family** (*bool*) – If `True`, the fill color of all submobjects is also set.
+* **Returns:**
+ `self`
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+
+### Examples
+
+
+
+#### SEE ALSO
+`set_style()`
+
+#### set_points_as_corners(points)
+
+Given an array of points, set them as corners of the
+[`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject).
+
+To achieve that, this algorithm sets handles aligned with the anchors
+such that the resultant Bézier curve will be the segment between the
+two anchors.
+
+* **Parameters:**
+ **points** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array)) – Array of points that will be set as corners.
+* **Returns:**
+ The VMobject itself, after setting the new points as corners.
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
+
+### Examples
+
+
+
+#### set_sheen(factor, direction=None, family=True)
+
+Applies a color gradient from a direction.
+
+* **Parameters:**
+ * **factor** (*float*) – The extent of lustre/gradient to apply. If negative, the gradient
+ starts from black, if positive the gradient starts from white and
+ changes to the current color.
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D) *|* *None*) – Direction from where the gradient is applied.
+ * **family** (*bool*)
+* **Return type:**
+ Self
+
+### Examples
+
+
+
+#### set_sheen_direction(direction, family=True)
+
+Sets the direction of the applied sheen.
+
+* **Parameters:**
+ * **direction** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D)) – Direction from where the gradient is applied.
+ * **family** (*bool*)
+* **Return type:**
+ Self
+
+### Examples
+
+Normal usage:
+
+```default
+Circle().set_sheen_direction(UP)
+```
+
+#### SEE ALSO
+[`set_sheen()`](#manim.mobject.types.vectorized_mobject.VMobject.set_sheen), [`rotate_sheen_direction()`](#manim.mobject.types.vectorized_mobject.VMobject.rotate_sheen_direction)
+
+#### start_new_path(point)
+
+Append a `point` to the `VMobject.points`, which will be the
+beginning of a new Bézier curve in the path given by the points. If
+there’s an unfinished curve at the end of `VMobject.points`,
+complete it by appending the last Bézier curve’s start anchor as many
+times as needed.
+
+* **Parameters:**
+ **point** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – A 3D point to append to `VMobject.points`.
+* **Returns:**
+ The VMobject itself, after appending `point` and starting a new
+ curve.
+* **Return type:**
+ [`VMobject`](#manim.mobject.types.vectorized_mobject.VMobject)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.VectorizedPoint.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.VectorizedPoint.md
new file mode 100644
index 0000000000000000000000000000000000000000..ad5003d2c26aa9c3c2304bb7f2cfce26bfa554c0
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.VectorizedPoint.md
@@ -0,0 +1,154 @@
+# VectorizedPoint
+
+Qualified name: `manim.mobject.types.vectorized\_mobject.VectorizedPoint`
+
+### *class* VectorizedPoint(location=array([0., 0., 0.]), color=ManimColor('#000000'), fill_opacity=0, stroke_width=0, artificial_width=0.01, artificial_height=0.01, \*\*kwargs)
+
+Bases: [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+### Methods
+
+| `get_location` | |
+|------------------|----|
+| `set_location` | |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|----------------------------------------------------------------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| [`height`](#manim.mobject.types.vectorized_mobject.VectorizedPoint.height) | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| [`width`](#manim.mobject.types.vectorized_mobject.VectorizedPoint.width) | The width of the mobject. |
+* **Parameters:**
+ * **location** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **color** ([*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor))
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **artificial_width** (*float*)
+ * **artificial_height** (*float*)
+
+#### \_original_\_init_\_(location=array([0., 0., 0.]), color=ManimColor('#000000'), fill_opacity=0, stroke_width=0, artificial_width=0.01, artificial_height=0.01, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **location** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike))
+ * **color** ([*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor))
+ * **fill_opacity** (*float*)
+ * **stroke_width** (*float*)
+ * **artificial_width** (*float*)
+ * **artificial_height** (*float*)
+* **Return type:**
+ None
+
+#### basecls
+
+alias of [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject)
+
+#### *property* height *: float*
+
+The height of the mobject.
+
+* **Return type:**
+ `float`
+
+### Examples
+
+
+
+#### SEE ALSO
+`length_over_dim()`
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.md
new file mode 100644
index 0000000000000000000000000000000000000000..b0db21470868a1451e7613c78be21bc5648f5d03
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.types.vectorized_mobject.md
@@ -0,0 +1,13 @@
+# vectorized_mobject
+
+Mobjects that use vector graphics.
+
+### Classes
+
+| [`CurvesAsSubmobjects`](manim.mobject.types.vectorized_mobject.CurvesAsSubmobjects.md#manim.mobject.types.vectorized_mobject.CurvesAsSubmobjects) | Convert a curve's elements to submobjects. |
+|-----------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`DashedVMobject`](manim.mobject.types.vectorized_mobject.DashedVMobject.md#manim.mobject.types.vectorized_mobject.DashedVMobject) | A [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) composed of dashes instead of lines. |
+| [`VDict`](manim.mobject.types.vectorized_mobject.VDict.md#manim.mobject.types.vectorized_mobject.VDict) | A VGroup-like class, also offering submobject access by key, like a python dict |
+| [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) | A group of vectorized mobjects. |
+| [`VMobject`](manim.mobject.types.vectorized_mobject.VMobject.md#manim.mobject.types.vectorized_mobject.VMobject) | A vectorized mobject. |
+| [`VectorizedPoint`](manim.mobject.types.vectorized_mobject.VectorizedPoint.md#manim.mobject.types.vectorized_mobject.VectorizedPoint) | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.utils.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.utils.md
new file mode 100644
index 0000000000000000000000000000000000000000..8d620c17c629c2fcdeb5654cc7a3d6f77025d242
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.utils.md
@@ -0,0 +1,79 @@
+# utils
+
+Utilities for working with mobjects.
+
+### Functions
+
+### get_mobject_class()
+
+Gets the base mobject class, depending on the currently active renderer.
+
+#### NOTE
+This method is intended to be used in the code base of Manim itself
+or in plugins where code should work independent of the selected
+renderer.
+
+### Examples
+
+The function has to be explicitly imported. We test that
+the name of the returned class is one of the known mobject
+base classes:
+
+```default
+>>> from manim.mobject.utils import get_mobject_class
+>>> get_mobject_class().__name__ in ['Mobject', 'OpenGLMobject']
+True
+```
+
+* **Return type:**
+ type
+
+### get_point_mobject_class()
+
+Gets the point cloud mobject class, depending on the currently
+active renderer.
+
+#### NOTE
+This method is intended to be used in the code base of Manim itself
+or in plugins where code should work independent of the selected
+renderer.
+
+### Examples
+
+The function has to be explicitly imported. We test that
+the name of the returned class is one of the known mobject
+base classes:
+
+```default
+>>> from manim.mobject.utils import get_point_mobject_class
+>>> get_point_mobject_class().__name__ in ['PMobject', 'OpenGLPMobject']
+True
+```
+
+* **Return type:**
+ type
+
+### get_vectorized_mobject_class()
+
+Gets the vectorized mobject class, depending on the currently
+active renderer.
+
+#### NOTE
+This method is intended to be used in the code base of Manim itself
+or in plugins where code should work independent of the selected
+renderer.
+
+### Examples
+
+The function has to be explicitly imported. We test that
+the name of the returned class is one of the known mobject
+base classes:
+
+```default
+>>> from manim.mobject.utils import get_vectorized_mobject_class
+>>> get_vectorized_mobject_class().__name__ in ['VMobject', 'OpenGLVMobject']
+True
+```
+
+* **Return type:**
+ type
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.value_tracker.ComplexValueTracker.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.value_tracker.ComplexValueTracker.md
new file mode 100644
index 0000000000000000000000000000000000000000..0485ea1370be564fe08002d1b44ba3d5f73c0de4
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.value_tracker.ComplexValueTracker.md
@@ -0,0 +1,87 @@
+# ComplexValueTracker
+
+Qualified name: `manim.mobject.value\_tracker.ComplexValueTracker`
+
+### *class* ComplexValueTracker(value=0, \*\*kwargs)
+
+Bases: [`ValueTracker`](manim.mobject.value_tracker.ValueTracker.md#manim.mobject.value_tracker.ValueTracker)
+
+Tracks a complex-valued parameter.
+
+When the value is set through `animate`, the value will take a straight path from the
+source point to the destination point.
+
+### Examples
+
+
+
+### Methods
+
+| [`get_value`](#manim.mobject.value_tracker.ComplexValueTracker.get_value) | Get the current value of this value tracker as a complex number. |
+|-----------------------------------------------------------------------------|--------------------------------------------------------------------|
+| [`set_value`](#manim.mobject.value_tracker.ComplexValueTracker.set_value) | Sets a new complex value to the ComplexValueTracker |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------|
+| `animation_overrides` | |
+| `depth` | The depth of the mobject. |
+| `height` | The height of the mobject. |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(value=0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+#### get_value()
+
+Get the current value of this value tracker as a complex number.
+
+The value is internally stored as a points array [a, b, 0]. This can be accessed directly
+to represent the value geometrically, see the usage example.
+
+#### set_value(z)
+
+Sets a new complex value to the ComplexValueTracker
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.value_tracker.ValueTracker.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.value_tracker.ValueTracker.md
new file mode 100644
index 0000000000000000000000000000000000000000..dd302051586cf68a2783698e32bf7d02380b4f4d
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.value_tracker.ValueTracker.md
@@ -0,0 +1,166 @@
+# ValueTracker
+
+Qualified name: `manim.mobject.value\_tracker.ValueTracker`
+
+### *class* ValueTracker(value=0, \*\*kwargs)
+
+Bases: [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)
+
+A mobject that can be used for tracking (real-valued) parameters.
+Useful for animating parameter changes.
+
+Not meant to be displayed. Instead the position encodes some
+number, often one which another animation or continual_animation
+uses for its update function, and by treating it as a mobject it can
+still be animated and manipulated just like anything else.
+
+This value changes continuously when animated using the `animate` syntax.
+
+### Examples
+
+
+
+#### NOTE
+You can also link ValueTrackers to updaters. In this case, you have to make sure that the
+ValueTracker is added to the scene by `add`
+
+
+
+### Methods
+
+| [`get_value`](#manim.mobject.value_tracker.ValueTracker.get_value) | Get the current value of this ValueTracker. |
+|--------------------------------------------------------------------------------|-----------------------------------------------------------------|
+| [`increment_value`](#manim.mobject.value_tracker.ValueTracker.increment_value) | Increments (adds) a scalar value to the ValueTracker |
+| [`interpolate`](#manim.mobject.value_tracker.ValueTracker.interpolate) | Turns self into an interpolation between mobject1 and mobject2. |
+| [`set_value`](#manim.mobject.value_tracker.ValueTracker.set_value) | Sets a new scalar value to the ValueTracker |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------|
+| `animation_overrides` | |
+| `depth` | The depth of the mobject. |
+| `height` | The height of the mobject. |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(value=0, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+#### get_value()
+
+Get the current value of this ValueTracker.
+
+* **Return type:**
+ float
+
+#### increment_value(d_value)
+
+Increments (adds) a scalar value to the ValueTracker
+
+* **Parameters:**
+ **d_value** (*float*)
+
+#### interpolate(mobject1, mobject2, alpha, path_func=)
+
+Turns self into an interpolation between mobject1
+and mobject2.
+
+#### set_value(value)
+
+Sets a new scalar value to the ValueTracker
+
+* **Parameters:**
+ **value** (*float*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.value_tracker.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.value_tracker.md
new file mode 100644
index 0000000000000000000000000000000000000000..2b73fdc73bfe7eb0e5743d736110d44f89b9b770
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.value_tracker.md
@@ -0,0 +1,9 @@
+# value_tracker
+
+Simple mobjects that can be used for storing (and updating) a value.
+
+### Classes
+
+| [`ComplexValueTracker`](manim.mobject.value_tracker.ComplexValueTracker.md#manim.mobject.value_tracker.ComplexValueTracker) | Tracks a complex-valued parameter. |
+|-------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------|
+| [`ValueTracker`](manim.mobject.value_tracker.ValueTracker.md#manim.mobject.value_tracker.ValueTracker) | A mobject that can be used for tracking (real-valued) parameters. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.vector_field.ArrowVectorField.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.vector_field.ArrowVectorField.md
new file mode 100644
index 0000000000000000000000000000000000000000..18c5476cc1610f7ed150d932913f770f89a97247
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.vector_field.ArrowVectorField.md
@@ -0,0 +1,169 @@
+# ArrowVectorField
+
+Qualified name: `manim.mobject.vector\_field.ArrowVectorField`
+
+### *class* ArrowVectorField(func, color=None, color_scheme=None, min_color_scheme_value=0, max_color_scheme_value=2, colors=[ManimColor('#236B8E'), ManimColor('#83C167'), ManimColor('#FFFF00'), ManimColor('#FC6255')], x_range=None, y_range=None, z_range=None, three_dimensions=False, length_func=>, opacity=1.0, vector_config=None, \*\*kwargs)
+
+Bases: [`VectorField`](manim.mobject.vector_field.VectorField.md#manim.mobject.vector_field.VectorField)
+
+A [`VectorField`](manim.mobject.vector_field.VectorField.md#manim.mobject.vector_field.VectorField) represented by a set of change vectors.
+
+Vector fields are always based on a function defining the [`Vector`](manim.mobject.geometry.line.Vector.md#manim.mobject.geometry.line.Vector) at every position.
+The values of this functions is displayed as a grid of vectors.
+By default the color of each vector is determined by it’s magnitude.
+Other color schemes can be used however.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*) – The function defining the rate of change at every position of the vector field.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The color of the vector field. If set, position-specific coloring is disabled.
+ * **color_scheme** (*Callable* *[* *[**np.ndarray* *]* *,* *float* *]* *|* *None*) – A function mapping a vector to a single value. This value gives the position in the color gradient defined using min_color_scheme_value, max_color_scheme_value and colors.
+ * **min_color_scheme_value** (*float*) – The value of the color_scheme function to be mapped to the first color in colors. Lower values also result in the first color of the gradient.
+ * **max_color_scheme_value** (*float*) – The value of the color_scheme function to be mapped to the last color in colors. Higher values also result in the last color of the gradient.
+ * **colors** (*Sequence* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]*) – The colors defining the color gradient of the vector field.
+ * **x_range** (*Sequence* *[**float* *]*) – A sequence of x_min, x_max, delta_x
+ * **y_range** (*Sequence* *[**float* *]*) – A sequence of y_min, y_max, delta_y
+ * **z_range** (*Sequence* *[**float* *]*) – A sequence of z_min, z_max, delta_z
+ * **three_dimensions** (*bool*) – Enables three_dimensions. Default set to False, automatically turns True if
+ z_range is not None.
+ * **length_func** (*Callable* *[* *[**float* *]* *,* *float* *]*) – The function determining the displayed size of the vectors. The actual size
+ of the vector is passed, the returned value will be used as display size for the
+ vector. By default this is used to cap the displayed size of vectors to reduce the clutter.
+ * **opacity** (*float*) – The opacity of the arrows.
+ * **vector_config** (*dict* *|* *None*) – Additional arguments to be passed to the [`Vector`](manim.mobject.geometry.line.Vector.md#manim.mobject.geometry.line.Vector) constructor
+ * **kwargs** – Additional arguments to be passed to the [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) constructor
+
+### Examples
+
+
+
+### Methods
+
+| [`get_vector`](#manim.mobject.vector_field.ArrowVectorField.get_vector) | Creates a vector in the vector field. |
+|---------------------------------------------------------------------------|-----------------------------------------|
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(func, color=None, color_scheme=None, min_color_scheme_value=0, max_color_scheme_value=2, colors=[ManimColor('#236B8E'), ManimColor('#83C167'), ManimColor('#FFFF00'), ManimColor('#FC6255')], x_range=None, y_range=None, z_range=None, three_dimensions=False, length_func=>, opacity=1.0, vector_config=None, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **color_scheme** (*Callable* *[* *[**np.ndarray* *]* *,* *float* *]* *|* *None*)
+ * **min_color_scheme_value** (*float*)
+ * **max_color_scheme_value** (*float*)
+ * **colors** (*Sequence* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]*)
+ * **x_range** (*Sequence* *[**float* *]*)
+ * **y_range** (*Sequence* *[**float* *]*)
+ * **z_range** (*Sequence* *[**float* *]*)
+ * **three_dimensions** (*bool*)
+ * **length_func** (*Callable* *[* *[**float* *]* *,* *float* *]*)
+ * **opacity** (*float*)
+ * **vector_config** (*dict* *|* *None*)
+
+#### get_vector(point)
+
+Creates a vector in the vector field.
+
+The created vector is based on the function of the vector field and is
+rooted in the given point. Color and length fit the specifications of
+this vector field.
+
+* **Parameters:**
+ **point** (*ndarray*) – The root point of the vector.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.vector_field.StreamLines.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.vector_field.StreamLines.md
new file mode 100644
index 0000000000000000000000000000000000000000..e79cb496b1d2a96fd2e37e27a6d7e1154aed3753
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.vector_field.StreamLines.md
@@ -0,0 +1,293 @@
+# StreamLines
+
+Qualified name: `manim.mobject.vector\_field.StreamLines`
+
+### *class* StreamLines(func, color=None, color_scheme=None, min_color_scheme_value=0, max_color_scheme_value=2, colors=[ManimColor('#236B8E'), ManimColor('#83C167'), ManimColor('#FFFF00'), ManimColor('#FC6255')], x_range=None, y_range=None, z_range=None, three_dimensions=False, noise_factor=None, n_repeats=1, dt=0.05, virtual_time=3, max_anchors_per_line=100, padding=3, stroke_width=1, opacity=1, \*\*kwargs)
+
+Bases: [`VectorField`](manim.mobject.vector_field.VectorField.md#manim.mobject.vector_field.VectorField)
+
+StreamLines represent the flow of a [`VectorField`](manim.mobject.vector_field.VectorField.md#manim.mobject.vector_field.VectorField) using the trace of moving agents.
+
+Vector fields are always based on a function defining the vector at every position.
+The values of this functions is displayed by moving many agents along the vector field
+and showing their trace.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*) – The function defining the rate of change at every position of the vector field.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The color of the vector field. If set, position-specific coloring is disabled.
+ * **color_scheme** (*Callable* *[* *[**np.ndarray* *]* *,* *float* *]* *|* *None*) – A function mapping a vector to a single value. This value gives the position in the color gradient defined using min_color_scheme_value, max_color_scheme_value and colors.
+ * **min_color_scheme_value** (*float*) – The value of the color_scheme function to be mapped to the first color in colors. Lower values also result in the first color of the gradient.
+ * **max_color_scheme_value** (*float*) – The value of the color_scheme function to be mapped to the last color in colors. Higher values also result in the last color of the gradient.
+ * **colors** (*Sequence* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]*) – The colors defining the color gradient of the vector field.
+ * **x_range** (*Sequence* *[**float* *]*) – A sequence of x_min, x_max, delta_x
+ * **y_range** (*Sequence* *[**float* *]*) – A sequence of y_min, y_max, delta_y
+ * **z_range** (*Sequence* *[**float* *]*) – A sequence of z_min, z_max, delta_z
+ * **three_dimensions** (*bool*) – Enables three_dimensions. Default set to False, automatically turns True if
+ z_range is not None.
+ * **noise_factor** (*float* *|* *None*) – The amount by which the starting position of each agent is altered along each axis. Defaults to `delta_y / 2` if not defined.
+ * **n_repeats** – The number of agents generated at each starting point.
+ * **dt** – The factor by which the distance an agent moves per step is stretched. Lower values result in a better approximation of the trajectories in the vector field.
+ * **virtual_time** – The time the agents get to move in the vector field. Higher values therefore result in longer stream lines. However, this whole time gets simulated upon creation.
+ * **max_anchors_per_line** – The maximum number of anchors per line. Lines with more anchors get reduced in complexity, not in length.
+ * **padding** – The distance agents can move out of the generation area before being terminated.
+ * **stroke_width** – The stroke with of the stream lines.
+ * **opacity** – The opacity of the stream lines.
+
+### Examples
+
+
+
+### Methods
+
+| [`create`](#manim.mobject.vector_field.StreamLines.create) | The creation animation of the stream lines. |
+|------------------------------------------------------------------------------|-----------------------------------------------|
+| [`end_animation`](#manim.mobject.vector_field.StreamLines.end_animation) | End the stream line animation smoothly. |
+| [`start_animation`](#manim.mobject.vector_field.StreamLines.start_animation) | Animates the stream lines using an updater. |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(func, color=None, color_scheme=None, min_color_scheme_value=0, max_color_scheme_value=2, colors=[ManimColor('#236B8E'), ManimColor('#83C167'), ManimColor('#FFFF00'), ManimColor('#FC6255')], x_range=None, y_range=None, z_range=None, three_dimensions=False, noise_factor=None, n_repeats=1, dt=0.05, virtual_time=3, max_anchors_per_line=100, padding=3, stroke_width=1, opacity=1, \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **color_scheme** (*Callable* *[* *[**np.ndarray* *]* *,* *float* *]* *|* *None*)
+ * **min_color_scheme_value** (*float*)
+ * **max_color_scheme_value** (*float*)
+ * **colors** (*Sequence* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]*)
+ * **x_range** (*Sequence* *[**float* *]*)
+ * **y_range** (*Sequence* *[**float* *]*)
+ * **z_range** (*Sequence* *[**float* *]*)
+ * **three_dimensions** (*bool*)
+ * **noise_factor** (*float* *|* *None*)
+
+#### create(lag_ratio=None, run_time=None, \*\*kwargs)
+
+The creation animation of the stream lines.
+
+The stream lines appear in random order.
+
+* **Parameters:**
+ * **lag_ratio** (*float* *|* *None*) – The lag ratio of the animation.
+ If undefined, it will be selected so that the total animation length is 1.5 times the run time of each stream line creation.
+ * **run_time** (*Callable* *[* *[**float* *]* *,* *float* *]* *|* *None*) – The run time of every single stream line creation. The runtime of the whole animation might be longer due to the lag_ratio.
+ If undefined, the virtual time of the stream lines is used as run time.
+* **Returns:**
+ The creation animation of the stream lines.
+* **Return type:**
+ [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup)
+
+### Examples
+
+
+
+#### end_animation()
+
+End the stream line animation smoothly.
+
+Returns an animation resulting in fully displayed stream lines without a noticeable cut.
+
+* **Returns:**
+ The animation fading out the running stream animation.
+* **Return type:**
+ [`AnimationGroup`](manim.animation.composition.AnimationGroup.md#manim.animation.composition.AnimationGroup)
+* **Raises:**
+ **ValueError** – if no stream line animation is running
+
+### Examples
+
+
+
+#### start_animation(warm_up=True, flow_speed=1, time_width=0.3, rate_func=, line_animation_class=, \*\*kwargs)
+
+Animates the stream lines using an updater.
+
+The stream lines will continuously flow
+
+* **Parameters:**
+ * **warm_up** (*bool*) – If True the animation is initialized line by line. Otherwise it starts with all lines shown.
+ * **flow_speed** (*float*) – At flow_speed=1 the distance the flow moves per second is equal to the magnitude of the vector field along its path. The speed value scales the speed of this flow.
+ * **time_width** (*float*) – The proportion of the stream line shown while being animated
+ * **rate_func** (*Callable* *[* *[**float* *]* *,* *float* *]*) – The rate function of each stream line flashing
+ * **line_animation_class** (*type* *[*[*ShowPassingFlash*](manim.animation.indication.ShowPassingFlash.md#manim.animation.indication.ShowPassingFlash) *]*) – The animation class being used
+* **Return type:**
+ None
+
+### Examples
+
+
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.vector_field.VectorField.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.vector_field.VectorField.md
new file mode 100644
index 0000000000000000000000000000000000000000..6ad2c57f95f69832de9ee28ecfe9739b92c7c5bf
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.vector_field.VectorField.md
@@ -0,0 +1,298 @@
+# VectorField
+
+Qualified name: `manim.mobject.vector\_field.VectorField`
+
+### *class* VectorField(func, color=None, color_scheme=None, min_color_scheme_value=0, max_color_scheme_value=2, colors=[ManimColor('#236B8E'), ManimColor('#83C167'), ManimColor('#FFFF00'), ManimColor('#FC6255')], \*\*kwargs)
+
+Bases: [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+A vector field.
+
+Vector fields are based on a function defining a vector at every position.
+This class does by default not include any visible elements but provides
+methods to move other [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) s along the vector field.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*) – The function defining the rate of change at every position of the VectorField.
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – The color of the vector field. If set, position-specific coloring is disabled.
+ * **color_scheme** (*Callable* *[* *[**np.ndarray* *]* *,* *float* *]* *|* *None*) – A function mapping a vector to a single value. This value gives the position in the color gradient defined using min_color_scheme_value, max_color_scheme_value and colors.
+ * **min_color_scheme_value** (*float*) – The value of the color_scheme function to be mapped to the first color in colors. Lower values also result in the first color of the gradient.
+ * **max_color_scheme_value** (*float*) – The value of the color_scheme function to be mapped to the last color in colors. Higher values also result in the last color of the gradient.
+ * **colors** (*Sequence* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]*) – The colors defining the color gradient of the vector field.
+ * **kwargs** – Additional arguments to be passed to the [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) constructor
+
+### Methods
+
+| [`fit_to_coordinate_system`](#manim.mobject.vector_field.VectorField.fit_to_coordinate_system) | Scale the vector field to fit a coordinate system. |
+|--------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`get_colored_background_image`](#manim.mobject.vector_field.VectorField.get_colored_background_image) | Generate an image that displays the vector field. |
+| [`get_nudge_updater`](#manim.mobject.vector_field.VectorField.get_nudge_updater) | Get an update function to move a [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) along the vector field. |
+| [`get_vectorized_rgba_gradient_function`](#manim.mobject.vector_field.VectorField.get_vectorized_rgba_gradient_function) | Generates a gradient of rgbas as a numpy array |
+| [`nudge`](#manim.mobject.vector_field.VectorField.nudge) | Nudge a [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) along the vector field. |
+| [`nudge_submobjects`](#manim.mobject.vector_field.VectorField.nudge_submobjects) | Apply a nudge along the vector field to all submobjects. |
+| [`scale_func`](#manim.mobject.vector_field.VectorField.scale_func) | Scale a vector field function. |
+| [`shift_func`](#manim.mobject.vector_field.VectorField.shift_func) | Shift a vector field function. |
+| [`start_submobject_movement`](#manim.mobject.vector_field.VectorField.start_submobject_movement) | Start continuously moving all submobjects along the vector field. |
+| [`stop_submobject_movement`](#manim.mobject.vector_field.VectorField.stop_submobject_movement) | Stops the continuous movement started using [`start_submobject_movement()`](#manim.mobject.vector_field.VectorField.start_submobject_movement). |
+
+### Attributes
+
+| `animate` | Used to animate the application of any method of `self`. |
+|-----------------------|------------------------------------------------------------------------|
+| `animation_overrides` | |
+| `color` | |
+| `depth` | The depth of the mobject. |
+| `fill_color` | If there are multiple colors (for gradient) this returns the first one |
+| `height` | The height of the mobject. |
+| `n_points_per_curve` | |
+| `sheen_factor` | |
+| `stroke_color` | |
+| `width` | The width of the mobject. |
+
+#### \_original_\_init_\_(func, color=None, color_scheme=None, min_color_scheme_value=0, max_color_scheme_value=2, colors=[ManimColor('#236B8E'), ManimColor('#83C167'), ManimColor('#FFFF00'), ManimColor('#FC6255')], \*\*kwargs)
+
+Initialize self. See help(type(self)) for accurate signature.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**np.ndarray* *]* *,* *np.ndarray* *]*)
+ * **color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*)
+ * **color_scheme** (*Callable* *[* *[**np.ndarray* *]* *,* *float* *]* *|* *None*)
+ * **min_color_scheme_value** (*float*)
+ * **max_color_scheme_value** (*float*)
+ * **colors** (*Sequence* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]*)
+
+#### fit_to_coordinate_system(coordinate_system)
+
+Scale the vector field to fit a coordinate system.
+
+This method is useful when the vector field is defined in a coordinate system
+different from the one used to display the vector field.
+
+This method can only be used once because it transforms the origin of each vector.
+
+* **Parameters:**
+ **coordinate_system** ([*CoordinateSystem*](manim.mobject.graphing.coordinate_systems.CoordinateSystem.md#manim.mobject.graphing.coordinate_systems.CoordinateSystem)) – The coordinate system to fit the vector field to.
+
+#### get_colored_background_image(sampling_rate=5)
+
+Generate an image that displays the vector field.
+
+The color at each position is calculated by passing the positing through a
+series of steps:
+Calculate the vector field function at that position, map that vector to a
+single value using self.color_scheme and finally generate a color from
+that value using the color gradient.
+
+* **Parameters:**
+ **sampling_rate** (*int*) – The stepsize at which pixels get included in the image. Lower values give
+ more accurate results, but may take a long time to compute.
+* **Returns:**
+ The vector field image.
+* **Return type:**
+ Image.Imgae
+
+#### get_nudge_updater(speed=1, pointwise=False)
+
+Get an update function to move a [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) along the vector field.
+
+When used with [`add_updater()`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject.add_updater), the mobject will move along the vector field, where its speed is determined by the magnitude of the vector field.
+
+* **Parameters:**
+ * **speed** (*float*) – At speed=1 the distance a mobject moves per second is equal to the magnitude of the vector field along its path. The speed value scales the speed of such a mobject.
+ * **pointwise** (*bool*) – Whether to move the mobject along the vector field. See [`nudge()`](#manim.mobject.vector_field.VectorField.nudge) for details.
+* **Returns:**
+ The update function.
+* **Return type:**
+ Callable[[[Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject), float], [Mobject](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)]
+
+#### get_vectorized_rgba_gradient_function(start, end, colors)
+
+Generates a gradient of rgbas as a numpy array
+
+* **Parameters:**
+ * **start** (*float*) – start value used for inverse interpolation at [`inverse_interpolate()`](manim.utils.bezier.md#manim.utils.bezier.inverse_interpolate)
+ * **end** (*float*) – end value used for inverse interpolation at [`inverse_interpolate()`](manim.utils.bezier.md#manim.utils.bezier.inverse_interpolate)
+ * **colors** (*Iterable* *[*[*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *]*) – list of colors to generate the gradient
+* **Return type:**
+ function to generate the gradients as numpy arrays representing rgba values
+
+#### nudge(mob, dt=1, substeps=1, pointwise=False)
+
+Nudge a [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) along the vector field.
+
+* **Parameters:**
+ * **mob** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject to move along the vector field
+ * **dt** (*float*) – A scalar to the amount the mobject is moved along the vector field.
+ The actual distance is based on the magnitude of the vector field.
+ * **substeps** (*int*) – The amount of steps the whole nudge is divided into. Higher values
+ give more accurate approximations.
+ * **pointwise** (*bool*) – Whether to move the mobject along the vector field. If False the
+ vector field takes effect on the center of the given
+ [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject). If True the vector field takes effect on the
+ points of the individual points of the [`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject),
+ potentially distorting it.
+* **Returns:**
+ This vector field.
+* **Return type:**
+ [VectorField](#manim.mobject.vector_field.VectorField)
+
+### Examples
+
+
+
+#### nudge_submobjects(dt=1, substeps=1, pointwise=False)
+
+Apply a nudge along the vector field to all submobjects.
+
+* **Parameters:**
+ * **dt** (*float*) – A scalar to the amount the mobject is moved along the vector field.
+ The actual distance is based on the magnitude of the vector field.
+ * **substeps** (*int*) – The amount of steps the whole nudge is divided into. Higher values
+ give more accurate approximations.
+ * **pointwise** (*bool*) – Whether to move the mobject along the vector field. See [`nudge()`](#manim.mobject.vector_field.VectorField.nudge) for details.
+* **Returns:**
+ This vector field.
+* **Return type:**
+ [VectorField](#manim.mobject.vector_field.VectorField)
+
+#### *static* scale_func(func, scalar)
+
+Scale a vector field function.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**ndarray* *]* *,* *ndarray* *]*) – The function defining a vector field.
+ * **scalar** (*float*) – The scalar to be applied to the vector field.
+* **Return type:**
+ *Callable*[[*ndarray*], *ndarray*]
+
+### Examples
+
+
+* **Returns:**
+ The scaled vector field function.
+* **Return type:**
+ Callable[[np.ndarray], np.ndarray]
+* **Parameters:**
+ * **func** (*Callable* *[* *[**ndarray* *]* *,* *ndarray* *]*)
+ * **scalar** (*float*)
+
+#### *static* shift_func(func, shift_vector)
+
+Shift a vector field function.
+
+* **Parameters:**
+ * **func** (*Callable* *[* *[**ndarray* *]* *,* *ndarray* *]*) – The function defining a vector field.
+ * **shift_vector** (*ndarray*) – The shift to be applied to the vector field.
+* **Returns:**
+ The shifted vector field function.
+* **Return type:**
+ Callable[[np.ndarray], np.ndarray]
+
+#### start_submobject_movement(speed=1, pointwise=False)
+
+Start continuously moving all submobjects along the vector field.
+
+Calling this method multiple times will result in removing the previous updater created by this method.
+
+* **Parameters:**
+ * **speed** (*float*) – The speed at which to move the submobjects. See [`get_nudge_updater()`](#manim.mobject.vector_field.VectorField.get_nudge_updater) for details.
+ * **pointwise** (*bool*) – Whether to move the mobject along the vector field. See [`nudge()`](#manim.mobject.vector_field.VectorField.nudge) for details.
+* **Returns:**
+ This vector field.
+* **Return type:**
+ [VectorField](#manim.mobject.vector_field.VectorField)
+
+#### stop_submobject_movement()
+
+Stops the continuous movement started using [`start_submobject_movement()`](#manim.mobject.vector_field.VectorField.start_submobject_movement).
+
+* **Returns:**
+ This vector field.
+* **Return type:**
+ [VectorField](#manim.mobject.vector_field.VectorField)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.vector_field.md b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.vector_field.md
new file mode 100644
index 0000000000000000000000000000000000000000..b984801cdd2f4582ffb761b2ac49463654935968
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.mobject.vector_field.md
@@ -0,0 +1,10 @@
+# vector_field
+
+Mobjects representing vector fields.
+
+### Classes
+
+| [`ArrowVectorField`](manim.mobject.vector_field.ArrowVectorField.md#manim.mobject.vector_field.ArrowVectorField) | A [`VectorField`](manim.mobject.vector_field.VectorField.md#manim.mobject.vector_field.VectorField) represented by a set of change vectors. |
+|--------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`StreamLines`](manim.mobject.vector_field.StreamLines.md#manim.mobject.vector_field.StreamLines) | StreamLines represent the flow of a [`VectorField`](manim.mobject.vector_field.VectorField.md#manim.mobject.vector_field.VectorField) using the trace of moving agents. |
+| [`VectorField`](manim.mobject.vector_field.VectorField.md#manim.mobject.vector_field.VectorField) | A vector field. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.moving_camera_scene.MovingCameraScene.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.moving_camera_scene.MovingCameraScene.md
new file mode 100644
index 0000000000000000000000000000000000000000..7214f8ce87f6c95db31045df4d092700fcab9e58
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.moving_camera_scene.MovingCameraScene.md
@@ -0,0 +1,36 @@
+# MovingCameraScene
+
+Qualified name: `manim.scene.moving\_camera\_scene.MovingCameraScene`
+
+### *class* MovingCameraScene(camera_class=, \*\*kwargs)
+
+Bases: [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene)
+
+This is a Scene, with special configurations and properties that
+make it suitable for cases where the camera must be moved around.
+
+Note: Examples are included in the moving_camera_scene module
+documentation, see below in the ‘see also’ section.
+
+#### SEE ALSO
+[`moving_camera_scene`](manim.scene.moving_camera_scene.md#module-manim.scene.moving_camera_scene)
+[`MovingCamera`](manim.camera.moving_camera.MovingCamera.md#manim.camera.moving_camera.MovingCamera)
+
+### Methods
+
+| [`get_moving_mobjects`](#manim.scene.moving_camera_scene.MovingCameraScene.get_moving_mobjects) | This method returns a list of all of the Mobjects in the Scene that are moving, that are also in the animations passed. |
+|---------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------|
+
+### Attributes
+
+| `camera` | |
+|------------|----------------------------------------|
+| `time` | The time since the start of the scene. |
+
+#### get_moving_mobjects(\*animations)
+
+This method returns a list of all of the Mobjects in the Scene that
+are moving, that are also in the animations passed.
+
+* **Parameters:**
+ **\*animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation)) – The Animations whose mobjects will be checked.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.moving_camera_scene.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.moving_camera_scene.md
new file mode 100644
index 0000000000000000000000000000000000000000..c86867aa4b8c5aad58be53cec08f9a8258230af0
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.moving_camera_scene.md
@@ -0,0 +1,208 @@
+# moving_camera_scene
+
+A scene whose camera can be moved around.
+
+#### SEE ALSO
+[`moving_camera`](manim.camera.moving_camera.md#module-manim.camera.moving_camera)
+
+### Examples
+
+
+```python
+from manim import *
+
+class SlidingMultipleScenes(MovingCameraScene):
+ def construct(self):
+ def create_scene(number):
+ frame = Rectangle(width=16,height=9)
+ circ = Circle().shift(LEFT)
+ text = Tex(f"This is Scene {str(number)}").next_to(circ, RIGHT)
+ frame.add(circ,text)
+ return frame
+
+ group = VGroup(*(create_scene(i) for i in range(4))).arrange_in_grid(buff=4)
+ self.add(group)
+ self.camera.auto_zoom(group[0], animate=False)
+ for scene in group:
+ self.play(self.camera.auto_zoom(scene))
+ self.wait()
+
+ self.play(self.camera.auto_zoom(group, margin=2))
+```
+
+
+class SlidingMultipleScenes(MovingCameraScene):
+ def construct(self):
+ def create_scene(number):
+ frame = Rectangle(width=16,height=9)
+ circ = Circle().shift(LEFT)
+ text = Tex(f"This is Scene {str(number)}").next_to(circ, RIGHT)
+ frame.add(circ,text)
+ return frame
+
+ group = VGroup(\*(create_scene(i) for i in range(4))).arrange_in_grid(buff=4)
+ self.add(group)
+ self.camera.auto_zoom(group[0], animate=False)
+ for scene in group:
+ self.play(self.camera.auto_zoom(scene))
+ self.wait()
+
+ self.play(self.camera.auto_zoom(group, margin=2))
+
+
+
+### Classes
+
+| [`MovingCameraScene`](manim.scene.moving_camera_scene.MovingCameraScene.md#manim.scene.moving_camera_scene.MovingCameraScene) | This is a Scene, with special configurations and properties that make it suitable for cases where the camera must be moved around. |
+|---------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene.RerunSceneHandler.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene.RerunSceneHandler.md
new file mode 100644
index 0000000000000000000000000000000000000000..3ff877d7f1431c74ca2aae292b7e0b9a6ddd7c85
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene.RerunSceneHandler.md
@@ -0,0 +1,21 @@
+# RerunSceneHandler
+
+Qualified name: `manim.scene.scene.RerunSceneHandler`
+
+### *class* RerunSceneHandler(queue)
+
+Bases: `FileSystemEventHandler`
+
+A class to handle rerunning a Scene after the input file is modified.
+
+### Methods
+
+| [`on_modified`](#manim.scene.scene.RerunSceneHandler.on_modified) | Called when a file or directory is modified. |
+|---------------------------------------------------------------------|------------------------------------------------|
+
+#### on_modified(event)
+
+Called when a file or directory is modified.
+
+* **Parameters:**
+ **event** (`DirModifiedEvent` or `FileModifiedEvent`) – Event representing file/directory modification.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene.Scene.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene.Scene.md
new file mode 100644
index 0000000000000000000000000000000000000000..b1eee8e8545502ce48283bb01cfdcf034b1826e7
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene.Scene.md
@@ -0,0 +1,700 @@
+# Scene
+
+Qualified name: `manim.scene.scene.Scene`
+
+### *class* Scene(renderer=None, camera_class=, always_update_mobjects=False, random_seed=None, skip_animations=False)
+
+Bases: `object`
+
+A Scene is the canvas of your animation.
+
+The primary role of [`Scene`](#manim.scene.scene.Scene) is to provide the user with tools to manage
+mobjects and animations. Generally speaking, a manim script consists of a class
+that derives from [`Scene`](#manim.scene.scene.Scene) whose [`Scene.construct()`](#manim.scene.scene.Scene.construct) method is overridden
+by the user’s code.
+
+Mobjects are displayed on screen by calling [`Scene.add()`](#manim.scene.scene.Scene.add) and removed from
+screen by calling [`Scene.remove()`](#manim.scene.scene.Scene.remove). All mobjects currently on screen are kept
+in `Scene.mobjects`. Animations are played by calling [`Scene.play()`](#manim.scene.scene.Scene.play).
+
+A [`Scene`](#manim.scene.scene.Scene) is rendered internally by calling [`Scene.render()`](#manim.scene.scene.Scene.render). This in
+turn calls [`Scene.setup()`](#manim.scene.scene.Scene.setup), [`Scene.construct()`](#manim.scene.scene.Scene.construct), and
+[`Scene.tear_down()`](#manim.scene.scene.Scene.tear_down), in that order.
+
+It is not recommended to override the `__init__` method in user Scenes. For code
+that should be ran before a Scene is rendered, use [`Scene.setup()`](#manim.scene.scene.Scene.setup) instead.
+
+### Examples
+
+Override the [`Scene.construct()`](#manim.scene.scene.Scene.construct) method with your code.
+
+```python
+class MyScene(Scene):
+ def construct(self):
+ self.play(Write(Text("Hello World!")))
+```
+
+### Methods
+
+| [`add`](#manim.scene.scene.Scene.add) | Mobjects will be displayed, from background to foreground in the order with which they are added. |
+|---------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`add_foreground_mobject`](#manim.scene.scene.Scene.add_foreground_mobject) | Adds a single mobject to the foreground, and internally to the list foreground_mobjects, and mobjects. |
+| [`add_foreground_mobjects`](#manim.scene.scene.Scene.add_foreground_mobjects) | Adds mobjects to the foreground, and internally to the list foreground_mobjects, and mobjects. |
+| `add_mobjects_from_animations` | |
+| [`add_sound`](#manim.scene.scene.Scene.add_sound) | This method is used to add a sound to the animation. |
+| [`add_subcaption`](#manim.scene.scene.Scene.add_subcaption) | Adds an entry in the corresponding subcaption file at the current time stamp. |
+| [`add_updater`](#manim.scene.scene.Scene.add_updater) | Add an update function to the scene. |
+| [`begin_animations`](#manim.scene.scene.Scene.begin_animations) | Start the animations of the scene. |
+| [`bring_to_back`](#manim.scene.scene.Scene.bring_to_back) | Removes the mobject from the scene and adds them to the back of the scene. |
+| [`bring_to_front`](#manim.scene.scene.Scene.bring_to_front) | Adds the passed mobjects to the scene again, pushing them to he front of the scene. |
+| `check_interactive_embed_is_valid` | |
+| [`clear`](#manim.scene.scene.Scene.clear) | Removes all mobjects present in self.mobjects and self.foreground_mobjects from the scene. |
+| [`compile_animation_data`](#manim.scene.scene.Scene.compile_animation_data) | Given a list of animations, compile the corresponding static and moving mobjects, and gather the animation durations. |
+| [`compile_animations`](#manim.scene.scene.Scene.compile_animations) | Creates \_MethodAnimations from any \_AnimationBuilders and updates animation kwargs with kwargs passed to play(). |
+| [`construct`](#manim.scene.scene.Scene.construct) | Add content to the Scene. |
+| `embed` | |
+| [`get_attrs`](#manim.scene.scene.Scene.get_attrs) | Gets attributes of a scene given the attribute's identifier/name. |
+| [`get_mobject_family_members`](#manim.scene.scene.Scene.get_mobject_family_members) | Returns list of family-members of all mobjects in scene. |
+| `get_moving_and_static_mobjects` | |
+| [`get_moving_mobjects`](#manim.scene.scene.Scene.get_moving_mobjects) | Gets all moving mobjects in the passed animation(s). |
+| [`get_restructured_mobject_list`](#manim.scene.scene.Scene.get_restructured_mobject_list) | Given a list of mobjects and a list of mobjects to be removed, this filters out the removable mobjects from the list of mobjects. |
+| [`get_run_time`](#manim.scene.scene.Scene.get_run_time) | Gets the total run time for a list of animations. |
+| [`get_time_progression`](#manim.scene.scene.Scene.get_time_progression) | You will hardly use this when making your own animations. |
+| [`get_top_level_mobjects`](#manim.scene.scene.Scene.get_top_level_mobjects) | Returns all mobjects which are not submobjects. |
+| `interact` | |
+| [`interactive_embed`](#manim.scene.scene.Scene.interactive_embed) | Like embed(), but allows for screen interaction. |
+| [`is_current_animation_frozen_frame`](#manim.scene.scene.Scene.is_current_animation_frozen_frame) | Returns whether the current animation produces a static frame (generally a Wait). |
+| `mouse_drag_orbit_controls` | |
+| `mouse_scroll_orbit_controls` | |
+| [`next_section`](#manim.scene.scene.Scene.next_section) | Create separation here; the last section gets finished and a new one gets created. |
+| `on_key_press` | |
+| `on_key_release` | |
+| `on_mouse_drag` | |
+| `on_mouse_motion` | |
+| `on_mouse_press` | |
+| `on_mouse_scroll` | |
+| [`pause`](#manim.scene.scene.Scene.pause) | Pauses the scene (i.e., displays a frozen frame). |
+| [`play`](#manim.scene.scene.Scene.play) | Plays an animation in this scene. |
+| [`play_internal`](#manim.scene.scene.Scene.play_internal) | This method is used to prep the animations for rendering, apply the arguments and parameters required to them, render them, and write them to the video file. |
+| [`remove`](#manim.scene.scene.Scene.remove) | Removes mobjects in the passed list of mobjects from the scene and the foreground, by removing them from "mobjects" and "foreground_mobjects" |
+| [`remove_foreground_mobject`](#manim.scene.scene.Scene.remove_foreground_mobject) | Removes a single mobject from the foreground, and internally from the list foreground_mobjects. |
+| [`remove_foreground_mobjects`](#manim.scene.scene.Scene.remove_foreground_mobjects) | Removes mobjects from the foreground, and internally from the list foreground_mobjects. |
+| [`remove_updater`](#manim.scene.scene.Scene.remove_updater) | Remove an update function from the scene. |
+| [`render`](#manim.scene.scene.Scene.render) | Renders this Scene. |
+| [`replace`](#manim.scene.scene.Scene.replace) | Replace one mobject in the scene with another, preserving draw order. |
+| [`restructure_mobjects`](#manim.scene.scene.Scene.restructure_mobjects) | tl:wr |
+| `set_key_function` | |
+| [`setup`](#manim.scene.scene.Scene.setup) | This is meant to be implemented by any scenes which are commonly subclassed, and have some common setup involved before the construct method is called. |
+| [`should_update_mobjects`](#manim.scene.scene.Scene.should_update_mobjects) | Returns True if the mobjects of this scene should be updated. |
+| [`tear_down`](#manim.scene.scene.Scene.tear_down) | This is meant to be implemented by any scenes which are commonly subclassed, and have some common method to be invoked before the scene ends. |
+| `update_meshes` | |
+| [`update_mobjects`](#manim.scene.scene.Scene.update_mobjects) | Begins updating all mobjects in the Scene. |
+| [`update_self`](#manim.scene.scene.Scene.update_self) | Run all scene updater functions. |
+| `update_to_time` | |
+| `validate_run_time` | |
+| [`wait`](#manim.scene.scene.Scene.wait) | Plays a "no operation" animation. |
+| [`wait_until`](#manim.scene.scene.Scene.wait_until) | Wait until a condition is satisfied, up to a given maximum duration. |
+
+### Attributes
+
+| `camera` | |
+|-----------------------------------------|----------------------------------------|
+| [`time`](#manim.scene.scene.Scene.time) | The time since the start of the scene. |
+* **Parameters:**
+ * **renderer** (*CairoRenderer* *|* *OpenGLRenderer* *|* *None*)
+ * **camera_class** (*type* *[*[*Camera*](manim.camera.camera.Camera.md#manim.camera.camera.Camera) *]*)
+ * **always_update_mobjects** (*bool*)
+ * **random_seed** (*int* *|* *None*)
+ * **skip_animations** (*bool*)
+
+#### \_get_animation_time_progression(animations, duration)
+
+You will hardly use this when making your own animations.
+This method is for Manim’s internal use.
+
+Uses `get_time_progression()` to obtain a
+CommandLine ProgressBar whose `fill_time` is
+dependent on the qualities of the passed Animation,
+
+* **Parameters:**
+ * **animations** (*list* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – The list of animations to get
+ the time progression for.
+ * **duration** (*float*) – duration of wait time
+* **Returns:**
+ The CommandLine Progress Bar.
+* **Return type:**
+ time_progression
+
+#### add(\*mobjects)
+
+Mobjects will be displayed, from background to
+foreground in the order with which they are added.
+
+* **Parameters:**
+ **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – Mobjects to add.
+* **Returns:**
+ The same scene after adding the Mobjects in.
+* **Return type:**
+ [Scene](#manim.scene.scene.Scene)
+
+#### add_foreground_mobject(mobject)
+
+Adds a single mobject to the foreground, and internally to the list
+foreground_mobjects, and mobjects.
+
+* **Parameters:**
+ **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The Mobject to add to the foreground.
+* **Returns:**
+ The Scene, with the foreground mobject added.
+* **Return type:**
+ [Scene](#manim.scene.scene.Scene)
+
+#### add_foreground_mobjects(\*mobjects)
+
+Adds mobjects to the foreground, and internally to the list
+foreground_mobjects, and mobjects.
+
+* **Parameters:**
+ **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The Mobjects to add to the foreground.
+* **Returns:**
+ The Scene, with the foreground mobjects added.
+* **Return type:**
+ [Scene](#manim.scene.scene.Scene)
+
+#### add_sound(sound_file, time_offset=0, gain=None, \*\*kwargs)
+
+This method is used to add a sound to the animation.
+
+* **Parameters:**
+ * **sound_file** (*str*) – The path to the sound file.
+ * **time_offset** (*float*) – The offset in the sound file after which
+ the sound can be played.
+ * **gain** (*float* *|* *None*) – Amplification of the sound.
+
+### Examples
+
+
+
+Download the resource for the previous example [here](https://github.com/ManimCommunity/manim/blob/main/docs/source/_static/click.wav) .
+
+#### add_subcaption(content, duration=1, offset=0)
+
+Adds an entry in the corresponding subcaption file
+at the current time stamp.
+
+The current time stamp is obtained from `Scene.time`.
+
+* **Parameters:**
+ * **content** (*str*) – The subcaption content.
+ * **duration** (*float*) – The duration (in seconds) for which the subcaption is shown.
+ * **offset** (*float*) – This offset (in seconds) is added to the starting time stamp
+ of the subcaption.
+* **Return type:**
+ None
+
+### Examples
+
+This example illustrates both possibilities for adding
+subcaptions to Manimations:
+
+```default
+class SubcaptionExample(Scene):
+ def construct(self):
+ square = Square()
+ circle = Circle()
+
+ # first option: via the add_subcaption method
+ self.add_subcaption("Hello square!", duration=1)
+ self.play(Create(square))
+
+ # second option: within the call to Scene.play
+ self.play(
+ Transform(square, circle), subcaption="The square transforms."
+ )
+```
+
+#### add_updater(func)
+
+Add an update function to the scene.
+
+The scene updater functions are run every frame,
+and they are the last type of updaters to run.
+
+#### WARNING
+When using the Cairo renderer, scene updaters that
+modify mobjects are not detected in the same way
+that mobject updaters are. To be more concrete,
+a mobject only modified via a scene updater will
+not necessarily be added to the list of *moving
+mobjects* and thus might not be updated every frame.
+
+TL;DR: Use mobject updaters to update mobjects.
+
+* **Parameters:**
+ **func** (*Callable* *[* *[**float* *]* *,* *None* *]*) – The updater function. It takes a float, which is the
+ time difference since the last update (usually equal
+ to the frame rate).
+* **Return type:**
+ None
+
+#### SEE ALSO
+[`Scene.remove_updater()`](#manim.scene.scene.Scene.remove_updater), [`Scene.update_self()`](#manim.scene.scene.Scene.update_self)
+
+#### begin_animations()
+
+Start the animations of the scene.
+
+* **Return type:**
+ None
+
+#### bring_to_back(\*mobjects)
+
+Removes the mobject from the scene and
+adds them to the back of the scene.
+
+* **Parameters:**
+ **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject(s) to push to the back of the scene.
+* **Returns:**
+ The Scene, with the mobjects pushed to the back
+ of the scene.
+* **Return type:**
+ [Scene](#manim.scene.scene.Scene)
+
+#### bring_to_front(\*mobjects)
+
+Adds the passed mobjects to the scene again,
+pushing them to he front of the scene.
+
+* **Parameters:**
+ **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject(s) to bring to the front of the scene.
+* **Returns:**
+ The Scene, with the mobjects brought to the front
+ of the scene.
+* **Return type:**
+ [Scene](#manim.scene.scene.Scene)
+
+#### clear()
+
+Removes all mobjects present in self.mobjects
+and self.foreground_mobjects from the scene.
+
+* **Returns:**
+ The Scene, with all of its mobjects in
+ self.mobjects and self.foreground_mobjects
+ removed.
+* **Return type:**
+ [Scene](#manim.scene.scene.Scene)
+
+#### compile_animation_data(\*animations, \*\*play_kwargs)
+
+Given a list of animations, compile the corresponding
+static and moving mobjects, and gather the animation durations.
+
+This also begins the animations.
+
+* **Parameters:**
+ * **animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* *\_AnimationBuilder*) – Animation or mobject with mobject method and params
+ * **play_kwargs** – Named parameters affecting what was passed in `animations`,
+ e.g. `run_time`, `lag_ratio` and so on.
+* **Returns:**
+ None if there is nothing to play, or self otherwise.
+* **Return type:**
+ self, None
+
+#### compile_animations(\*args, \*\*kwargs)
+
+Creates \_MethodAnimations from any \_AnimationBuilders and updates animation
+kwargs with kwargs passed to play().
+
+* **Parameters:**
+ * **\*args** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* *\_AnimationBuilder*) – Animations to be played.
+ * **\*\*kwargs** – Configuration for the call to play().
+* **Returns:**
+ Animations to be played.
+* **Return type:**
+ Tuple[`Animation`]
+
+#### construct()
+
+Add content to the Scene.
+
+From within [`Scene.construct()`](#manim.scene.scene.Scene.construct), display mobjects on screen by calling
+[`Scene.add()`](#manim.scene.scene.Scene.add) and remove them from screen by calling [`Scene.remove()`](#manim.scene.scene.Scene.remove).
+All mobjects currently on screen are kept in `Scene.mobjects`. Play
+animations by calling [`Scene.play()`](#manim.scene.scene.Scene.play).
+
+### Notes
+
+Initialization code should go in [`Scene.setup()`](#manim.scene.scene.Scene.setup). Termination code should
+go in [`Scene.tear_down()`](#manim.scene.scene.Scene.tear_down).
+
+### Examples
+
+A typical manim script includes a class derived from [`Scene`](#manim.scene.scene.Scene) with an
+overridden [`Scene.construct()`](#manim.scene.scene.Scene.construct) method:
+
+```python
+class MyScene(Scene):
+ def construct(self):
+ self.play(Write(Text("Hello World!")))
+```
+
+#### SEE ALSO
+[`Scene.setup()`](#manim.scene.scene.Scene.setup), [`Scene.render()`](#manim.scene.scene.Scene.render), [`Scene.tear_down()`](#manim.scene.scene.Scene.tear_down)
+
+#### get_attrs(\*keys)
+
+Gets attributes of a scene given the attribute’s identifier/name.
+
+* **Parameters:**
+ **\*keys** (*str*) – Name(s) of the argument(s) to return the attribute of.
+* **Returns:**
+ List of attributes of the passed identifiers.
+* **Return type:**
+ list
+
+#### get_mobject_family_members()
+
+Returns list of family-members of all mobjects in scene.
+If a Circle() and a VGroup(Rectangle(),Triangle()) were added,
+it returns not only the Circle(), Rectangle() and Triangle(), but
+also the VGroup() object.
+
+* **Returns:**
+ List of mobject family members.
+* **Return type:**
+ list
+
+#### get_moving_mobjects(\*animations)
+
+Gets all moving mobjects in the passed animation(s).
+
+* **Parameters:**
+ **\*animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation)) – The animations to check for moving mobjects.
+* **Returns:**
+ The list of mobjects that could be moving in
+ the Animation(s)
+* **Return type:**
+ list
+
+#### get_restructured_mobject_list(mobjects, to_remove)
+
+Given a list of mobjects and a list of mobjects to be removed, this
+filters out the removable mobjects from the list of mobjects.
+
+* **Parameters:**
+ * **mobjects** (*list*) – The Mobjects to check.
+ * **to_remove** (*list*) – The list of mobjects to remove.
+* **Returns:**
+ The list of mobjects with the mobjects to remove removed.
+* **Return type:**
+ list
+
+#### get_run_time(animations)
+
+Gets the total run time for a list of animations.
+
+* **Parameters:**
+ **animations** (*list* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – A list of the animations whose total
+ `run_time` is to be calculated.
+* **Returns:**
+ The total `run_time` of all of the animations in the list.
+* **Return type:**
+ float
+
+#### get_time_progression(run_time, description, n_iterations=None, override_skip_animations=False)
+
+You will hardly use this when making your own animations.
+This method is for Manim’s internal use.
+
+Returns a CommandLine ProgressBar whose `fill_time`
+is dependent on the `run_time` of an animation,
+the iterations to perform in that animation
+and a bool saying whether or not to consider
+the skipped animations.
+
+* **Parameters:**
+ * **run_time** (*float*) – The `run_time` of the animation.
+ * **n_iterations** (*int* *|* *None*) – The number of iterations in the animation.
+ * **override_skip_animations** (*bool*) – Whether or not to show skipped animations in the progress bar.
+* **Returns:**
+ The CommandLine Progress Bar.
+* **Return type:**
+ time_progression
+
+#### get_top_level_mobjects()
+
+Returns all mobjects which are not submobjects.
+
+* **Returns:**
+ List of top level mobjects.
+* **Return type:**
+ list
+
+#### interactive_embed()
+
+Like embed(), but allows for screen interaction.
+
+#### is_current_animation_frozen_frame()
+
+Returns whether the current animation produces a static frame (generally a Wait).
+
+* **Return type:**
+ bool
+
+#### next_section(name='unnamed', section_type=DefaultSectionType.NORMAL, skip_animations=False)
+
+Create separation here; the last section gets finished and a new one gets created.
+`skip_animations` skips the rendering of all animations in this section.
+Refer to [the documentation](../tutorials/output_and_config.md) on how to use sections.
+
+* **Parameters:**
+ * **name** (*str*)
+ * **section_type** (*str*)
+ * **skip_animations** (*bool*)
+* **Return type:**
+ None
+
+#### pause(duration=1.0)
+
+Pauses the scene (i.e., displays a frozen frame).
+
+This is an alias for [`wait()`](#manim.scene.scene.Scene.wait) with `frozen_frame`
+set to `True`.
+
+* **Parameters:**
+ **duration** (*float*) – The duration of the pause.
+
+#### SEE ALSO
+[`wait()`](#manim.scene.scene.Scene.wait), [`Wait`](manim.animation.animation.Wait.md#manim.animation.animation.Wait)
+
+#### play(\*args, subcaption=None, subcaption_duration=None, subcaption_offset=0, \*\*kwargs)
+
+Plays an animation in this scene.
+
+* **Parameters:**
+ * **args** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *|* [*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* *\_AnimationBuilder*) – Animations to be played.
+ * **subcaption** – The content of the external subcaption that should
+ be added during the animation.
+ * **subcaption_duration** – The duration for which the specified subcaption is
+ added. If `None` (the default), the run time of the
+ animation is taken.
+ * **subcaption_offset** – An offset (in seconds) for the start time of the
+ added subcaption.
+ * **kwargs** – All other keywords are passed to the renderer.
+
+#### play_internal(skip_rendering=False)
+
+This method is used to prep the animations for rendering,
+apply the arguments and parameters required to them,
+render them, and write them to the video file.
+
+* **Parameters:**
+ **skip_rendering** (*bool*) – Whether the rendering should be skipped, by default False
+
+#### remove(\*mobjects)
+
+Removes mobjects in the passed list of mobjects
+from the scene and the foreground, by removing them
+from “mobjects” and “foreground_mobjects”
+
+* **Parameters:**
+ **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to remove.
+
+#### remove_foreground_mobject(mobject)
+
+Removes a single mobject from the foreground, and internally from the list
+foreground_mobjects.
+
+* **Parameters:**
+ **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject to remove from the foreground.
+* **Returns:**
+ The Scene, with the foreground mobject removed.
+* **Return type:**
+ [Scene](#manim.scene.scene.Scene)
+
+#### remove_foreground_mobjects(\*to_remove)
+
+Removes mobjects from the foreground, and internally from the list
+foreground_mobjects.
+
+* **Parameters:**
+ **\*to_remove** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject(s) to remove from the foreground.
+* **Returns:**
+ The Scene, with the foreground mobjects removed.
+* **Return type:**
+ [Scene](#manim.scene.scene.Scene)
+
+#### remove_updater(func)
+
+Remove an update function from the scene.
+
+* **Parameters:**
+ **func** (*Callable* *[* *[**float* *]* *,* *None* *]*) – The updater function to be removed.
+* **Return type:**
+ None
+
+#### SEE ALSO
+[`Scene.add_updater()`](#manim.scene.scene.Scene.add_updater), [`Scene.update_self()`](#manim.scene.scene.Scene.update_self)
+
+#### render(preview=False)
+
+Renders this Scene.
+
+* **Parameters:**
+ **preview** (*bool*) – If true, opens scene in a file viewer.
+
+#### replace(old_mobject, new_mobject)
+
+Replace one mobject in the scene with another, preserving draw order.
+
+If `old_mobject` is a submobject of some other Mobject (e.g. a
+[`Group`](manim.mobject.mobject.Group.md#manim.mobject.mobject.Group)), the new_mobject will replace it inside the group,
+without otherwise changing the parent mobject.
+
+* **Parameters:**
+ * **old_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject to be replaced. Must be present in the scene.
+ * **new_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – A mobject which must not already be in the scene.
+* **Return type:**
+ None
+
+#### restructure_mobjects(to_remove, mobject_list_name='mobjects', extract_families=True)
+
+tl:wr
+: If your scene has a Group(), and you removed a mobject from the Group,
+ this dissolves the group and puts the rest of the mobjects directly
+ in self.mobjects or self.foreground_mobjects.
+
+In cases where the scene contains a group, e.g. Group(m1, m2, m3), but one
+of its submobjects is removed, e.g. scene.remove(m1), the list of mobjects
+will be edited to contain other submobjects, but not m1, e.g. it will now
+insert m2 and m3 to where the group once was.
+
+* **Parameters:**
+ * **to_remove** (*Sequence* *[*[*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *]*) – The Mobject to remove.
+ * **mobject_list_name** (*str*) – The list of mobjects (“mobjects”, “foreground_mobjects” etc) to remove from.
+ * **extract_families** (*bool*) – Whether the mobject’s families should be recursively extracted.
+* **Returns:**
+ The Scene mobject with restructured Mobjects.
+* **Return type:**
+ [Scene](#manim.scene.scene.Scene)
+
+#### setup()
+
+This is meant to be implemented by any scenes which
+are commonly subclassed, and have some common setup
+involved before the construct method is called.
+
+#### should_update_mobjects()
+
+Returns True if the mobjects of this scene should be updated.
+
+In particular, this checks whether
+
+- the `always_update_mobjects` attribute of [`Scene`](#manim.scene.scene.Scene)
+ is set to `True`,
+- the [`Scene`](#manim.scene.scene.Scene) itself has time-based updaters attached,
+- any mobject in this [`Scene`](#manim.scene.scene.Scene) has time-based updaters attached.
+
+This is only called when a single Wait animation is played.
+
+* **Return type:**
+ bool
+
+#### tear_down()
+
+This is meant to be implemented by any scenes which
+are commonly subclassed, and have some common method
+to be invoked before the scene ends.
+
+#### *property* time *: float*
+
+The time since the start of the scene.
+
+#### update_mobjects(dt)
+
+Begins updating all mobjects in the Scene.
+
+* **Parameters:**
+ **dt** (*float*) – Change in time between updates. Defaults (mostly) to 1/frames_per_second
+
+#### update_self(dt)
+
+Run all scene updater functions.
+
+Among all types of update functions (mobject updaters, mesh updaters,
+scene updaters), scene update functions are called last.
+
+* **Parameters:**
+ **dt** (*float*) – Scene time since last update.
+
+#### SEE ALSO
+[`Scene.add_updater()`](#manim.scene.scene.Scene.add_updater), [`Scene.remove_updater()`](#manim.scene.scene.Scene.remove_updater)
+
+#### wait(duration=1.0, stop_condition=None, frozen_frame=None)
+
+Plays a “no operation” animation.
+
+* **Parameters:**
+ * **duration** (*float*) – The run time of the animation.
+ * **stop_condition** (*Callable* *[* *[* *]* *,* *bool* *]* *|* *None*) – A function without positional arguments that is evaluated every time
+ a frame is rendered. The animation only stops when the return value
+ of the function is truthy, or when the time specified in `duration`
+ passes.
+ * **frozen_frame** (*bool* *|* *None*) – If True, updater functions are not evaluated, and the animation outputs
+ a frozen frame. If False, updater functions are called and frames
+ are rendered as usual. If None (the default), the scene tries to
+ determine whether or not the frame is frozen on its own.
+
+#### SEE ALSO
+[`Wait`](manim.animation.animation.Wait.md#manim.animation.animation.Wait), `should_mobjects_update()`
+
+#### wait_until(stop_condition, max_time=60)
+
+Wait until a condition is satisfied, up to a given maximum duration.
+
+* **Parameters:**
+ * **stop_condition** (*Callable* *[* *[* *]* *,* *bool* *]*) – A function with no arguments that determines whether or not the
+ scene should keep waiting.
+ * **max_time** (*float*) – The maximum wait time in seconds.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene.md
new file mode 100644
index 0000000000000000000000000000000000000000..6663c31f6180c9aa7e1f85912183a0d91f361c4e
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene.md
@@ -0,0 +1,9 @@
+# scene
+
+Basic canvas for animations.
+
+### Classes
+
+| [`RerunSceneHandler`](manim.scene.scene.RerunSceneHandler.md#manim.scene.scene.RerunSceneHandler) | A class to handle rerunning a Scene after the input file is modified. |
+|-----------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------|
+| [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) | A Scene is the canvas of your animation. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene_file_writer.SceneFileWriter.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene_file_writer.SceneFileWriter.md
new file mode 100644
index 0000000000000000000000000000000000000000..9fc3ecfbeb6b051eddb253b331231dab34a475bb
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene_file_writer.SceneFileWriter.md
@@ -0,0 +1,310 @@
+# SceneFileWriter
+
+Qualified name: `manim.scene.scene\_file\_writer.SceneFileWriter`
+
+### *class* SceneFileWriter(renderer, scene_name, \*\*kwargs)
+
+Bases: `object`
+
+SceneFileWriter is the object that actually writes the animations
+played, into video files, using FFMPEG.
+This is mostly for Manim’s internal use. You will rarely, if ever,
+have to use the methods for this class, unless tinkering with the very
+fabric of Manim’s reality.
+
+* **Parameters:**
+ * **renderer** (*CairoRenderer* *|* *OpenGLRenderer*)
+ * **scene_name** ([*StrPath*](manim.typing.md#manim.typing.StrPath))
+ * **kwargs** (*Any*)
+
+#### sections
+
+used to segment scene
+
+* **Type:**
+ list of [`Section`](manim.scene.section.Section.md#manim.scene.section.Section)
+
+#### sections_output_dir
+
+where are section videos stored
+
+* **Type:**
+ `pathlib.Path`
+
+#### output_name
+
+name of movie without extension and basis for section video names
+
+* **Type:**
+ str
+
+Some useful attributes are:
+: “write_to_movie” (bool=False)
+ : Whether or not to write the animations into a video file.
+
+ “movie_file_extension” (str=”.mp4”)
+ : The file-type extension of the outputted video.
+
+ “partial_movie_files”
+ : List of all the partial-movie files.
+
+### Methods
+
+| [`add_audio_segment`](#manim.scene.scene_file_writer.SceneFileWriter.add_audio_segment) | This method adds an audio segment from an AudioSegment type object and suitable parameters. |
+|-----------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------|
+| [`add_partial_movie_file`](#manim.scene.scene_file_writer.SceneFileWriter.add_partial_movie_file) | Adds a new partial movie file path to scene.partial_movie_files and current section from a hash. |
+| [`add_sound`](#manim.scene.scene_file_writer.SceneFileWriter.add_sound) | This method adds an audio segment from a sound file. |
+| [`begin_animation`](#manim.scene.scene_file_writer.SceneFileWriter.begin_animation) | Used internally by manim to stream the animation to FFMPEG for displaying or writing to a file. |
+| [`clean_cache`](#manim.scene.scene_file_writer.SceneFileWriter.clean_cache) | Will clean the cache by removing the oldest partial_movie_files. |
+| [`close_partial_movie_stream`](#manim.scene.scene_file_writer.SceneFileWriter.close_partial_movie_stream) | Close the currently opened video container. |
+| `combine_files` | |
+| [`combine_to_movie`](#manim.scene.scene_file_writer.SceneFileWriter.combine_to_movie) | Used internally by Manim to combine the separate partial movie files that make up a Scene into a single video file for that Scene. |
+| [`combine_to_section_videos`](#manim.scene.scene_file_writer.SceneFileWriter.combine_to_section_videos) | Concatenate partial movie files for each section. |
+| [`create_audio_segment`](#manim.scene.scene_file_writer.SceneFileWriter.create_audio_segment) | Creates an empty, silent, Audio Segment. |
+| [`encode_and_write_frame`](#manim.scene.scene_file_writer.SceneFileWriter.encode_and_write_frame) | For internal use only: takes a given frame in `np.ndarray` format and write it to the stream |
+| [`end_animation`](#manim.scene.scene_file_writer.SceneFileWriter.end_animation) | Internally used by Manim to stop streaming to FFMPEG gracefully. |
+| [`finish`](#manim.scene.scene_file_writer.SceneFileWriter.finish) | Finishes writing to the FFMPEG buffer or writing images to output directory. |
+| [`finish_last_section`](#manim.scene.scene_file_writer.SceneFileWriter.finish_last_section) | Delete current section if it is empty. |
+| [`flush_cache_directory`](#manim.scene.scene_file_writer.SceneFileWriter.flush_cache_directory) | Delete all the cached partial movie files |
+| [`get_resolution_directory`](#manim.scene.scene_file_writer.SceneFileWriter.get_resolution_directory) | Get the name of the resolution directory directly containing the video file. |
+| [`init_audio`](#manim.scene.scene_file_writer.SceneFileWriter.init_audio) | Preps the writer for adding audio to the movie. |
+| [`init_output_directories`](#manim.scene.scene_file_writer.SceneFileWriter.init_output_directories) | Initialise output directories. |
+| [`is_already_cached`](#manim.scene.scene_file_writer.SceneFileWriter.is_already_cached) | Will check if a file named with hash_invocation exists. |
+| [`listen_and_write`](#manim.scene.scene_file_writer.SceneFileWriter.listen_and_write) | For internal use only: blocks until new frame is available on the queue. |
+| [`next_section`](#manim.scene.scene_file_writer.SceneFileWriter.next_section) | Create segmentation cut here. |
+| [`open_partial_movie_stream`](#manim.scene.scene_file_writer.SceneFileWriter.open_partial_movie_stream) | Open a container holding a video stream. |
+| `output_image` | |
+| [`print_file_ready_message`](#manim.scene.scene_file_writer.SceneFileWriter.print_file_ready_message) | Prints the "File Ready" message to STDOUT. |
+| [`save_final_image`](#manim.scene.scene_file_writer.SceneFileWriter.save_final_image) | The name is a misnomer. |
+| [`write_frame`](#manim.scene.scene_file_writer.SceneFileWriter.write_frame) | Used internally by Manim to write a frame to the FFMPEG input buffer. |
+| [`write_subcaption_file`](#manim.scene.scene_file_writer.SceneFileWriter.write_subcaption_file) | Writes the subcaption file. |
+
+### Attributes
+
+| `force_output_as_scene_name` | |
+|--------------------------------|----|
+
+#### add_audio_segment(new_segment, time=None, gain_to_background=None)
+
+This method adds an audio segment from an
+AudioSegment type object and suitable parameters.
+
+* **Parameters:**
+ * **new_segment** (*AudioSegment*) – The audio segment to add
+ * **time** (*float* *|* *None*) – the timestamp at which the
+ sound should be added.
+ * **gain_to_background** (*float* *|* *None*) – The gain of the segment from the background.
+
+#### add_partial_movie_file(hash_animation)
+
+Adds a new partial movie file path to scene.partial_movie_files and current section from a hash.
+This method will compute the path from the hash. In addition to that it adds the new animation to the current section.
+
+* **Parameters:**
+ **hash_animation** (*str*) – Hash of the animation.
+
+#### add_sound(sound_file, time=None, gain=None, \*\*kwargs)
+
+This method adds an audio segment from a sound file.
+
+* **Parameters:**
+ * **sound_file** (*str*) – The path to the sound file.
+ * **time** (*float* *|* *None*) – The timestamp at which the audio should be added.
+ * **gain** (*float* *|* *None*) – The gain of the given audio segment.
+ * **\*\*kwargs** – This method uses add_audio_segment, so any keyword arguments
+ used there can be referenced here.
+
+#### begin_animation(allow_write=False, file_path=None)
+
+Used internally by manim to stream the animation to FFMPEG for
+displaying or writing to a file.
+
+* **Parameters:**
+ * **allow_write** (*bool*) – Whether or not to write to a video file.
+ * **file_path** ([*StrPath*](manim.typing.md#manim.typing.StrPath) *|* *None*)
+* **Return type:**
+ None
+
+#### clean_cache()
+
+Will clean the cache by removing the oldest partial_movie_files.
+
+#### close_partial_movie_stream()
+
+Close the currently opened video container.
+
+Used internally by Manim to first flush the remaining packages
+in the video stream holding a partial file, and then close
+the corresponding container.
+
+* **Return type:**
+ None
+
+#### combine_to_movie()
+
+Used internally by Manim to combine the separate
+partial movie files that make up a Scene into a single
+video file for that Scene.
+
+#### combine_to_section_videos()
+
+Concatenate partial movie files for each section.
+
+* **Return type:**
+ None
+
+#### create_audio_segment()
+
+Creates an empty, silent, Audio Segment.
+
+#### encode_and_write_frame(frame, num_frames)
+
+For internal use only: takes a given frame in `np.ndarray` format and
+write it to the stream
+
+* **Parameters:**
+ * **frame** ([*PixelArray*](manim.typing.md#manim.typing.PixelArray))
+ * **num_frames** (*int*)
+* **Return type:**
+ None
+
+#### end_animation(allow_write=False)
+
+Internally used by Manim to stop streaming to
+FFMPEG gracefully.
+
+* **Parameters:**
+ **allow_write** (*bool*) – Whether or not to write to a video file.
+* **Return type:**
+ None
+
+#### finish()
+
+Finishes writing to the FFMPEG buffer or writing images
+to output directory.
+Combines the partial movie files into the
+whole scene.
+If save_last_frame is True, saves the last
+frame in the default image directory.
+
+* **Return type:**
+ None
+
+#### finish_last_section()
+
+Delete current section if it is empty.
+
+* **Return type:**
+ None
+
+#### flush_cache_directory()
+
+Delete all the cached partial movie files
+
+#### get_resolution_directory()
+
+Get the name of the resolution directory directly containing
+the video file.
+
+This method gets the name of the directory that immediately contains the
+video file. This name is `p`.
+For example, if you are rendering an 854x480 px animation at 15fps,
+the name of the directory that immediately contains the video, file
+will be `480p15`.
+
+The file structure should look something like:
+
+```default
+MEDIA_DIR
+ |--Tex
+ |--texts
+ |--videos
+ |--
+ |--p
+ |--.mp4
+```
+
+* **Returns:**
+ The name of the directory.
+* **Return type:**
+ `str`
+
+#### init_audio()
+
+Preps the writer for adding audio to the movie.
+
+#### init_output_directories(scene_name)
+
+Initialise output directories.
+
+### Notes
+
+The directories are read from `config`, for example
+`config['media_dir']`. If the target directories don’t already
+exist, they will be created.
+
+* **Parameters:**
+ **scene_name** ([*StrPath*](manim.typing.md#manim.typing.StrPath))
+* **Return type:**
+ None
+
+#### is_already_cached(hash_invocation)
+
+Will check if a file named with hash_invocation exists.
+
+* **Parameters:**
+ **hash_invocation** (*str*) – The hash corresponding to an invocation to either scene.play or scene.wait.
+* **Returns:**
+ Whether the file exists.
+* **Return type:**
+ `bool`
+
+#### listen_and_write()
+
+For internal use only: blocks until new frame is available on the queue.
+
+#### next_section(name, type_, skip_animations)
+
+Create segmentation cut here.
+
+* **Parameters:**
+ * **name** (*str*)
+ * **type_** (*str*)
+ * **skip_animations** (*bool*)
+* **Return type:**
+ None
+
+#### open_partial_movie_stream(file_path=None)
+
+Open a container holding a video stream.
+
+This is used internally by Manim initialize the container holding
+the video stream of a partial movie file.
+
+* **Return type:**
+ None
+
+#### print_file_ready_message(file_path)
+
+Prints the “File Ready” message to STDOUT.
+
+#### save_final_image(image)
+
+The name is a misnomer. This method saves the image
+passed to it as an in the default image directory.
+
+* **Parameters:**
+ **image** (*ndarray*) – The pixel array of the image to save.
+
+#### write_frame(frame_or_renderer, num_frames=1)
+
+Used internally by Manim to write a frame to
+the FFMPEG input buffer.
+
+* **Parameters:**
+ * **frame_or_renderer** (*np.ndarray* *|* *OpenGLRenderer*) – Pixel array of the frame.
+ * **num_frames** (*int*) – The number of times to write frame.
+
+#### write_subcaption_file()
+
+Writes the subcaption file.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene_file_writer.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene_file_writer.md
new file mode 100644
index 0000000000000000000000000000000000000000..1992be72145b1e5628bac7f2884810beda69a3e3
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.scene_file_writer.md
@@ -0,0 +1,19 @@
+# scene_file_writer
+
+The interface between scenes and ffmpeg.
+
+### Classes
+
+| [`SceneFileWriter`](manim.scene.scene_file_writer.SceneFileWriter.md#manim.scene.scene_file_writer.SceneFileWriter) | SceneFileWriter is the object that actually writes the animations played, into video files, using FFMPEG. |
+|-----------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------|
+
+### Functions
+
+### convert_audio(input_path, output_path, codec_name)
+
+* **Parameters:**
+ * **input_path** (*Path*)
+ * **output_path** (*Path*)
+ * **codec_name** (*str*)
+
+### to_av_frame_rate(fps)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.section.DefaultSectionType.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.section.DefaultSectionType.md
new file mode 100644
index 0000000000000000000000000000000000000000..519b2daaf1a8f6af2f6502d5ce1f765b41a8ee31
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.section.DefaultSectionType.md
@@ -0,0 +1,33 @@
+# DefaultSectionType
+
+Qualified name: `manim.scene.section.DefaultSectionType`
+
+### *class* DefaultSectionType(value, names=None, \*, module=None, qualname=None, type=None, start=1, boundary=None)
+
+Bases: `str`, `Enum`
+
+The type of a section can be used for third party applications.
+A presentation system could for example use the types to created loops.
+
+### Examples
+
+This class can be reimplemented for more types:
+
+```default
+class PresentationSectionType(str, Enum):
+ # start, end, wait for continuation by user
+ NORMAL = "presentation.normal"
+ # start, end, immediately continue to next section
+ SKIP = "presentation.skip"
+ # start, end, restart, immediately continue to next section when continued by user
+ LOOP = "presentation.loop"
+ # start, end, restart, finish animation first when user continues
+ COMPLETE_LOOP = "presentation.complete_loop"
+```
+
+### Methods
+
+### Attributes
+
+| `NORMAL` | |
+|------------|----|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.section.Section.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.section.Section.md
new file mode 100644
index 0000000000000000000000000000000000000000..3bb7942138fb2e43db0bf3f885b0013c35ecdb63
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.section.Section.md
@@ -0,0 +1,77 @@
+# Section
+
+Qualified name: `manim.scene.section.Section`
+
+### *class* Section(type_, video, name, skip_animations)
+
+Bases: `object`
+
+A [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) can be segmented into multiple Sections.
+Refer to [the documentation](../tutorials/output_and_config.md) for more info.
+It consists of multiple animations.
+
+* **Parameters:**
+ * **type_** (*str*)
+ * **video** (*str* *|* *None*)
+ * **name** (*str*)
+ * **skip_animations** (*bool*)
+
+### type\\_
+
+Can be used by a third party applications to classify different types of sections.
+
+#### video
+
+Path to video file with animations belonging to section relative to sections directory.
+If `None`, then the section will not be saved.
+
+#### name
+
+Human readable, non-unique name for this section.
+
+#### skip_animations
+
+Skip rendering the animations in this section when `True`.
+
+#### partial_movie_files
+
+Animations belonging to this section.
+
+#### SEE ALSO
+[`DefaultSectionType`](manim.scene.section.DefaultSectionType.md#manim.scene.section.DefaultSectionType), `CairoRenderer.update_skipping_status()`, `OpenGLRenderer.update_skipping_status()`
+
+### Methods
+
+| [`get_clean_partial_movie_files`](#manim.scene.section.Section.get_clean_partial_movie_files) | Return all partial movie files that are not `None`. |
+|-------------------------------------------------------------------------------------------------|--------------------------------------------------------------|
+| [`get_dict`](#manim.scene.section.Section.get_dict) | Get dictionary representation with metadata of output video. |
+| [`is_empty`](#manim.scene.section.Section.is_empty) | Check whether this section is empty. |
+
+#### get_clean_partial_movie_files()
+
+Return all partial movie files that are not `None`.
+
+* **Return type:**
+ list[str]
+
+#### get_dict(sections_dir)
+
+Get dictionary representation with metadata of output video.
+
+The output from this function is used from every section to build the sections index file.
+The output video must have been created in the `sections_dir` before executing this method.
+This is the main part of the Segmented Video API.
+
+* **Parameters:**
+ **sections_dir** (*Path*)
+* **Return type:**
+ dict[str, *Any*]
+
+#### is_empty()
+
+Check whether this section is empty.
+
+Note that animations represented by `None` are also counted.
+
+* **Return type:**
+ bool
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.section.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.section.md
new file mode 100644
index 0000000000000000000000000000000000000000..a85181e9c8ee2e6d62b95a66e3d4f8dec8d24043
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.section.md
@@ -0,0 +1,9 @@
+# section
+
+building blocks of segmented video API
+
+### Classes
+
+| [`DefaultSectionType`](manim.scene.section.DefaultSectionType.md#manim.scene.section.DefaultSectionType) | The type of a section can be used for third party applications. |
+|------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------|
+| [`Section`](manim.scene.section.Section.md#manim.scene.section.Section) | A [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene) can be segmented into multiple Sections. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.three_d_scene.SpecialThreeDScene.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.three_d_scene.SpecialThreeDScene.md
new file mode 100644
index 0000000000000000000000000000000000000000..d7f047b116c5a2420c64a374e4e0c4bd72656cc1
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.three_d_scene.SpecialThreeDScene.md
@@ -0,0 +1,64 @@
+# SpecialThreeDScene
+
+Qualified name: `manim.scene.three\_d\_scene.SpecialThreeDScene`
+
+### *class* SpecialThreeDScene(cut_axes_at_radius=True, camera_config={'exponential_projection': True, 'should_apply_shading': True}, three_d_axes_config={'axis_config': {'numbers_with_elongated_ticks': [0, 1, 2], 'stroke_width': 2, 'tick_frequency': 1, 'unit_size': 2}, 'num_axis_pieces': 1}, sphere_config={'radius': 2, 'resolution': (24, 48)}, default_angled_camera_position={'phi': 1.2217304763960306, 'theta': -1.9198621771937625}, low_quality_config={'camera_config': {'should_apply_shading': False}, 'sphere_config': {'resolution': (12, 24)}, 'three_d_axes_config': {'num_axis_pieces': 1}}, \*\*kwargs)
+
+Bases: [`ThreeDScene`](manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene)
+
+An extension of [`ThreeDScene`](manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene) with more settings.
+
+It has some extra configuration for axes, spheres,
+and an override for low quality rendering. Further key differences
+are:
+
+* The camera shades applicable 3DMobjects by default,
+ except if rendering in low quality.
+* Some default params for Spheres and Axes have been added.
+
+### Methods
+
+| [`get_axes`](#manim.scene.three_d_scene.SpecialThreeDScene.get_axes) | Return a set of 3D axes. |
+|------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------|
+| [`get_default_camera_position`](#manim.scene.three_d_scene.SpecialThreeDScene.get_default_camera_position) | Returns the default_angled_camera position. |
+| [`get_sphere`](#manim.scene.three_d_scene.SpecialThreeDScene.get_sphere) | Returns a sphere with the passed keyword arguments as properties. |
+| [`set_camera_to_default_position`](#manim.scene.three_d_scene.SpecialThreeDScene.set_camera_to_default_position) | Sets the camera to its default position. |
+
+### Attributes
+
+| `camera` | |
+|------------|----------------------------------------|
+| `time` | The time since the start of the scene. |
+
+#### get_axes()
+
+Return a set of 3D axes.
+
+* **Returns:**
+ A set of 3D axes.
+* **Return type:**
+ [`ThreeDAxes`](manim.mobject.graphing.coordinate_systems.ThreeDAxes.md#manim.mobject.graphing.coordinate_systems.ThreeDAxes)
+
+#### get_default_camera_position()
+
+Returns the default_angled_camera position.
+
+* **Returns:**
+ Dictionary of phi, theta, focal_distance, and gamma.
+* **Return type:**
+ dict
+
+#### get_sphere(\*\*kwargs)
+
+Returns a sphere with the passed keyword arguments as properties.
+
+* **Parameters:**
+ **\*\*kwargs** – Any valid parameter of [`Sphere`](manim.mobject.three_d.three_dimensions.Sphere.md#manim.mobject.three_d.three_dimensions.Sphere) or [`Surface`](manim.mobject.three_d.three_dimensions.Surface.md#manim.mobject.three_d.three_dimensions.Surface).
+* **Returns:**
+ The sphere object.
+* **Return type:**
+ [`Sphere`](manim.mobject.three_d.three_dimensions.Sphere.md#manim.mobject.three_d.three_dimensions.Sphere)
+
+#### set_camera_to_default_position()
+
+Sets the camera to its default position.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.three_d_scene.ThreeDScene.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.three_d_scene.ThreeDScene.md
new file mode 100644
index 0000000000000000000000000000000000000000..9e56cb747c2690d1fc820259ddedad5df5d44263
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.three_d_scene.ThreeDScene.md
@@ -0,0 +1,149 @@
+# ThreeDScene
+
+Qualified name: `manim.scene.three\_d\_scene.ThreeDScene`
+
+### *class* ThreeDScene(camera_class=, ambient_camera_rotation=None, default_angled_camera_orientation_kwargs=None, \*\*kwargs)
+
+Bases: [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene)
+
+This is a Scene, with special configurations and properties that
+make it suitable for Three Dimensional Scenes.
+
+### Methods
+
+| [`add_fixed_in_frame_mobjects`](#manim.scene.three_d_scene.ThreeDScene.add_fixed_in_frame_mobjects) | This method is used to prevent the rotation and movement of mobjects as the camera moves around. |
+|-------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------|
+| [`add_fixed_orientation_mobjects`](#manim.scene.three_d_scene.ThreeDScene.add_fixed_orientation_mobjects) | This method is used to prevent the rotation and tilting of mobjects as the camera moves around. |
+| [`begin_3dillusion_camera_rotation`](#manim.scene.three_d_scene.ThreeDScene.begin_3dillusion_camera_rotation) | This method creates a 3D camera rotation illusion around the current camera orientation. |
+| [`begin_ambient_camera_rotation`](#manim.scene.three_d_scene.ThreeDScene.begin_ambient_camera_rotation) | This method begins an ambient rotation of the camera about the Z_AXIS, in the anticlockwise direction |
+| [`get_moving_mobjects`](#manim.scene.three_d_scene.ThreeDScene.get_moving_mobjects) | This method returns a list of all of the Mobjects in the Scene that are moving, that are also in the animations passed. |
+| [`move_camera`](#manim.scene.three_d_scene.ThreeDScene.move_camera) | This method animates the movement of the camera to the given spherical coordinates. |
+| [`remove_fixed_in_frame_mobjects`](#manim.scene.three_d_scene.ThreeDScene.remove_fixed_in_frame_mobjects) | This method undoes what add_fixed_in_frame_mobjects does. |
+| [`remove_fixed_orientation_mobjects`](#manim.scene.three_d_scene.ThreeDScene.remove_fixed_orientation_mobjects) | This method "unfixes" the orientation of the mobjects passed, meaning they will no longer be at the same angle relative to the camera. |
+| [`set_camera_orientation`](#manim.scene.three_d_scene.ThreeDScene.set_camera_orientation) | This method sets the orientation of the camera in the scene. |
+| [`set_to_default_angled_camera_orientation`](#manim.scene.three_d_scene.ThreeDScene.set_to_default_angled_camera_orientation) | This method sets the default_angled_camera_orientation to the keyword arguments passed, and sets the camera to that orientation. |
+| [`stop_3dillusion_camera_rotation`](#manim.scene.three_d_scene.ThreeDScene.stop_3dillusion_camera_rotation) | This method stops all illusion camera rotations. |
+| [`stop_ambient_camera_rotation`](#manim.scene.three_d_scene.ThreeDScene.stop_ambient_camera_rotation) | This method stops all ambient camera rotation. |
+
+### Attributes
+
+| `camera` | |
+|------------|----------------------------------------|
+| `time` | The time since the start of the scene. |
+
+#### add_fixed_in_frame_mobjects(\*mobjects)
+
+This method is used to prevent the rotation and movement
+of mobjects as the camera moves around. The mobject is
+essentially overlaid, and is not impacted by the camera’s
+movement in any way.
+
+* **Parameters:**
+ **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The Mobjects whose orientation must be fixed.
+
+#### add_fixed_orientation_mobjects(\*mobjects, \*\*kwargs)
+
+This method is used to prevent the rotation and tilting
+of mobjects as the camera moves around. The mobject can
+still move in the x,y,z directions, but will always be
+at the angle (relative to the camera) that it was at
+when it was passed through this method.)
+
+* **Parameters:**
+ * **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The Mobject(s) whose orientation must be fixed.
+ * **\*\*kwargs** –
+
+ Some valid kwargs are
+ : use_static_center_func : bool
+ center_func : function
+
+#### begin_3dillusion_camera_rotation(rate=1, origin_phi=None, origin_theta=None)
+
+This method creates a 3D camera rotation illusion around
+the current camera orientation.
+
+* **Parameters:**
+ * **rate** (*float*) – The rate at which the camera rotation illusion should operate.
+ * **origin_phi** (*float* *|* *None*) – The polar angle the camera should move around. Defaults
+ to the current phi angle.
+ * **origin_theta** (*float* *|* *None*) – The azimutal angle the camera should move around. Defaults
+ to the current theta angle.
+
+#### begin_ambient_camera_rotation(rate=0.02, about='theta')
+
+This method begins an ambient rotation of the camera about the Z_AXIS,
+in the anticlockwise direction
+
+* **Parameters:**
+ * **rate** (*float*) – The rate at which the camera should rotate about the Z_AXIS.
+ Negative rate means clockwise rotation.
+ * **about** (*str*) – one of 3 options: [“theta”, “phi”, “gamma”]. defaults to theta.
+
+#### get_moving_mobjects(\*animations)
+
+This method returns a list of all of the Mobjects in the Scene that
+are moving, that are also in the animations passed.
+
+* **Parameters:**
+ **\*animations** ([*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation)) – The animations whose mobjects will be checked.
+
+#### move_camera(phi=None, theta=None, gamma=None, zoom=None, focal_distance=None, frame_center=None, added_anims=[], \*\*kwargs)
+
+This method animates the movement of the camera
+to the given spherical coordinates.
+
+* **Parameters:**
+ * **phi** (*float* *|* *None*) – The polar angle i.e the angle between Z_AXIS and Camera through ORIGIN in radians.
+ * **theta** (*float* *|* *None*) – The azimuthal angle i.e the angle that spins the camera around the Z_AXIS.
+ * **focal_distance** (*float* *|* *None*) – The radial focal_distance between ORIGIN and Camera.
+ * **gamma** (*float* *|* *None*) – The rotation of the camera about the vector from the ORIGIN to the Camera.
+ * **zoom** (*float* *|* *None*) – The zoom factor of the camera.
+ * **frame_center** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* *Sequence* *[**float* *]* *|* *None*) – The new center of the camera frame in cartesian coordinates.
+ * **added_anims** (*Iterable* *[*[*Animation*](manim.animation.animation.Animation.md#manim.animation.animation.Animation) *]*) – Any other animations to be played at the same time.
+
+#### remove_fixed_in_frame_mobjects(\*mobjects)
+
+> This method undoes what add_fixed_in_frame_mobjects does.
+> It allows the mobject to be affected by the movement of
+> the camera.
+* **Parameters:**
+ **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The Mobjects whose position and orientation must be unfixed.
+
+#### remove_fixed_orientation_mobjects(\*mobjects)
+
+This method “unfixes” the orientation of the mobjects
+passed, meaning they will no longer be at the same angle
+relative to the camera. This only makes sense if the
+mobject was passed through add_fixed_orientation_mobjects first.
+
+* **Parameters:**
+ **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The Mobjects whose orientation must be unfixed.
+
+#### set_camera_orientation(phi=None, theta=None, gamma=None, zoom=None, focal_distance=None, frame_center=None, \*\*kwargs)
+
+This method sets the orientation of the camera in the scene.
+
+* **Parameters:**
+ * **phi** (*float* *|* *None*) – The polar angle i.e the angle between Z_AXIS and Camera through ORIGIN in radians.
+ * **theta** (*float* *|* *None*) – The azimuthal angle i.e the angle that spins the camera around the Z_AXIS.
+ * **focal_distance** (*float* *|* *None*) – The focal_distance of the Camera.
+ * **gamma** (*float* *|* *None*) – The rotation of the camera about the vector from the ORIGIN to the Camera.
+ * **zoom** (*float* *|* *None*) – The zoom factor of the scene.
+ * **frame_center** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* *Sequence* *[**float* *]* *|* *None*) – The new center of the camera frame in cartesian coordinates.
+
+#### set_to_default_angled_camera_orientation(\*\*kwargs)
+
+This method sets the default_angled_camera_orientation to the
+keyword arguments passed, and sets the camera to that orientation.
+
+* **Parameters:**
+ **\*\*kwargs** – Some recognised kwargs are phi, theta, focal_distance, gamma,
+ which have the same meaning as the parameters in set_camera_orientation.
+
+#### stop_3dillusion_camera_rotation()
+
+This method stops all illusion camera rotations.
+
+#### stop_ambient_camera_rotation(about='theta')
+
+This method stops all ambient camera rotation.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.three_d_scene.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.three_d_scene.md
new file mode 100644
index 0000000000000000000000000000000000000000..a1a7226f0e71c37ec41636d9e1b105824ff7b7c9
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.three_d_scene.md
@@ -0,0 +1,9 @@
+# three_d_scene
+
+A scene suitable for rendering three-dimensional objects and animations.
+
+### Classes
+
+| [`SpecialThreeDScene`](manim.scene.three_d_scene.SpecialThreeDScene.md#manim.scene.three_d_scene.SpecialThreeDScene) | An extension of [`ThreeDScene`](manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene) with more settings. |
+|------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|
+| [`ThreeDScene`](manim.scene.three_d_scene.ThreeDScene.md#manim.scene.three_d_scene.ThreeDScene) | This is a Scene, with special configurations and properties that make it suitable for Three Dimensional Scenes. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.vector_space_scene.LinearTransformationScene.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.vector_space_scene.LinearTransformationScene.md
new file mode 100644
index 0000000000000000000000000000000000000000..8aae5c0cb470ea151fc36747deae226af55865df
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.vector_space_scene.LinearTransformationScene.md
@@ -0,0 +1,383 @@
+# LinearTransformationScene
+
+Qualified name: `manim.scene.vector\_space\_scene.LinearTransformationScene`
+
+### *class* LinearTransformationScene(include_background_plane=True, include_foreground_plane=True, background_plane_kwargs=None, foreground_plane_kwargs=None, show_coordinates=False, show_basis_vectors=True, basis_vector_stroke_width=6, i_hat_color=ManimColor('#83C167'), j_hat_color=ManimColor('#FC6255'), leave_ghost_vectors=False, \*\*kwargs)
+
+Bases: [`VectorScene`](manim.scene.vector_space_scene.VectorScene.md#manim.scene.vector_space_scene.VectorScene)
+
+This scene contains special methods that make it
+especially suitable for showing linear transformations.
+
+* **Parameters:**
+ * **include_background_plane** (*bool*) – Whether or not to include the background plane in the scene.
+ * **include_foreground_plane** (*bool*) – Whether or not to include the foreground plane in the scene.
+ * **background_plane_kwargs** (*dict* *|* *None*) – Parameters to be passed to `NumberPlane` to adjust the background plane.
+ * **foreground_plane_kwargs** (*dict* *|* *None*) – Parameters to be passed to `NumberPlane` to adjust the foreground plane.
+ * **show_coordinates** (*bool*) – Whether or not to include the coordinates for the background plane.
+ * **show_basis_vectors** (*bool*) – Whether to show the basis x_axis -> `i_hat` and y_axis -> `j_hat` vectors.
+ * **basis_vector_stroke_width** (*float*) – The `stroke_width` of the basis vectors.
+ * **i_hat_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the `i_hat` vector.
+ * **j_hat_color** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)) – The color of the `j_hat` vector.
+ * **leave_ghost_vectors** (*bool*) – Indicates the previous position of the basis vectors following a transformation.
+
+### Examples
+
+
+
+### Methods
+
+| [`add_background_mobject`](#manim.scene.vector_space_scene.LinearTransformationScene.add_background_mobject) | Adds the mobjects to the special list self.background_mobjects. |
+|------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`add_foreground_mobject`](#manim.scene.vector_space_scene.LinearTransformationScene.add_foreground_mobject) | Adds the mobjects to the special list self.foreground_mobjects. |
+| [`add_moving_mobject`](#manim.scene.vector_space_scene.LinearTransformationScene.add_moving_mobject) | Adds the mobject to the special list self.moving_mobject, and adds a property to the mobject called mobject.target, which keeps track of what the mobject will move to or become etc. |
+| [`add_special_mobjects`](#manim.scene.vector_space_scene.LinearTransformationScene.add_special_mobjects) | Adds mobjects to a separate list that can be tracked, if these mobjects have some extra importance. |
+| [`add_title`](#manim.scene.vector_space_scene.LinearTransformationScene.add_title) | Adds a title, after scaling it, adding a background rectangle, moving it to the top and adding it to foreground_mobjects adding it as a local variable of self. |
+| [`add_transformable_label`](#manim.scene.vector_space_scene.LinearTransformationScene.add_transformable_label) | Method for creating, and animating the addition of a transformable label for the vector. |
+| [`add_transformable_mobject`](#manim.scene.vector_space_scene.LinearTransformationScene.add_transformable_mobject) | Adds the mobjects to the special list self.transformable_mobjects. |
+| [`add_unit_square`](#manim.scene.vector_space_scene.LinearTransformationScene.add_unit_square) | Adds a unit square to the scene via self.get_unit_square. |
+| [`add_vector`](#manim.scene.vector_space_scene.LinearTransformationScene.add_vector) | Adds a vector to the scene, and puts it in the special list self.moving_vectors. |
+| [`apply_function`](#manim.scene.vector_space_scene.LinearTransformationScene.apply_function) | Applies the given function to each of the mobjects in self.transformable_mobjects, and plays the animation showing this. |
+| [`apply_inverse`](#manim.scene.vector_space_scene.LinearTransformationScene.apply_inverse) | This method applies the linear transformation represented by the inverse of the passed matrix to the number plane, and each vector/similar mobject on it. |
+| [`apply_inverse_transpose`](#manim.scene.vector_space_scene.LinearTransformationScene.apply_inverse_transpose) | Applies the inverse of the transformation represented by the given transposed matrix to the number plane and each vector/similar mobject on it. |
+| [`apply_matrix`](#manim.scene.vector_space_scene.LinearTransformationScene.apply_matrix) | Applies the transformation represented by the given matrix to the number plane, and each vector/similar mobject on it. |
+| [`apply_nonlinear_transformation`](#manim.scene.vector_space_scene.LinearTransformationScene.apply_nonlinear_transformation) | Applies the non-linear transformation represented by the given function to the number plane and each vector/similar mobject on it. |
+| [`apply_transposed_matrix`](#manim.scene.vector_space_scene.LinearTransformationScene.apply_transposed_matrix) | Applies the transformation represented by the given transposed matrix to the number plane, and each vector/similar mobject on it. |
+| [`get_ghost_vectors`](#manim.scene.vector_space_scene.LinearTransformationScene.get_ghost_vectors) | Returns all ghost vectors ever added to `self`. |
+| [`get_matrix_transformation`](#manim.scene.vector_space_scene.LinearTransformationScene.get_matrix_transformation) | Returns a function corresponding to the linear transformation represented by the matrix passed. |
+| [`get_moving_mobject_movement`](#manim.scene.vector_space_scene.LinearTransformationScene.get_moving_mobject_movement) | This method returns an animation that moves a mobject in "self.moving_mobjects" to its corresponding .target value. |
+| [`get_piece_movement`](#manim.scene.vector_space_scene.LinearTransformationScene.get_piece_movement) | This method returns an animation that moves an arbitrary mobject in "pieces" to its corresponding .target value. |
+| [`get_transformable_label_movement`](#manim.scene.vector_space_scene.LinearTransformationScene.get_transformable_label_movement) | This method returns an animation that moves all labels in "self.transformable_labels" to its corresponding .target . |
+| [`get_transposed_matrix_transformation`](#manim.scene.vector_space_scene.LinearTransformationScene.get_transposed_matrix_transformation) | Returns a function corresponding to the linear transformation represented by the transposed matrix passed. |
+| [`get_unit_square`](#manim.scene.vector_space_scene.LinearTransformationScene.get_unit_square) | Returns a unit square for the current NumberPlane. |
+| [`get_vector_movement`](#manim.scene.vector_space_scene.LinearTransformationScene.get_vector_movement) | This method returns an animation that moves a mobject in "self.moving_vectors" to its corresponding .target value. |
+| [`setup`](#manim.scene.vector_space_scene.LinearTransformationScene.setup) | This is meant to be implemented by any scenes which are commonly subclassed, and have some common setup involved before the construct method is called. |
+| `update_default_configs` | |
+| [`write_vector_coordinates`](#manim.scene.vector_space_scene.LinearTransformationScene.write_vector_coordinates) | Returns a column matrix indicating the vector coordinates, after writing them to the screen, and adding them to the special list self.foreground_mobjects |
+
+### Attributes
+
+| `camera` | |
+|------------|----------------------------------------|
+| `time` | The time since the start of the scene. |
+
+#### add_background_mobject(\*mobjects)
+
+Adds the mobjects to the special list
+self.background_mobjects.
+
+* **Parameters:**
+ **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to add to the list.
+
+#### add_foreground_mobject(\*mobjects)
+
+Adds the mobjects to the special list
+self.foreground_mobjects.
+
+* **Parameters:**
+ **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to add to the list
+
+#### add_moving_mobject(mobject, target_mobject=None)
+
+Adds the mobject to the special list
+self.moving_mobject, and adds a property
+to the mobject called mobject.target, which
+keeps track of what the mobject will move to
+or become etc.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to add to the list
+ * **target_mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject) *|* *None*) – What the moving_mobject goes to, etc.
+
+#### add_special_mobjects(mob_list, \*mobs_to_add)
+
+Adds mobjects to a separate list that can be tracked,
+if these mobjects have some extra importance.
+
+* **Parameters:**
+ * **mob_list** (*list*) – The special list to which you want to add
+ these mobjects.
+ * **\*mobs_to_add** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to add.
+
+#### add_title(title, scale_factor=1.5, animate=False)
+
+Adds a title, after scaling it, adding a background rectangle,
+moving it to the top and adding it to foreground_mobjects adding
+it as a local variable of self. Returns the Scene.
+
+* **Parameters:**
+ * **title** (*str* *|* [*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) *|* [*Tex*](manim.mobject.text.tex_mobject.Tex.md#manim.mobject.text.tex_mobject.Tex)) – What the title should be.
+ * **scale_factor** (*float*) – How much the title should be scaled by.
+ * **animate** (*bool*) – Whether or not to animate the addition.
+* **Returns:**
+ The scene with the title added to it.
+* **Return type:**
+ [LinearTransformationScene](#manim.scene.vector_space_scene.LinearTransformationScene)
+
+#### add_transformable_label(vector, label, transformation_name='L', new_label=None, \*\*kwargs)
+
+Method for creating, and animating the addition of
+a transformable label for the vector.
+
+* **Parameters:**
+ * **vector** ([*Vector*](manim.mobject.geometry.line.Vector.md#manim.mobject.geometry.line.Vector)) – The vector for which the label must be added.
+ * **label** ([*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) *|* *str*) – The MathTex/string of the label.
+ * **transformation_name** (*str* *|* [*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex)) – The name to give the transformation as a label.
+ * **new_label** (*str* *|* [*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) *|* *None*) – What the label should display after a Linear Transformation
+ * **\*\*kwargs** – Any valid keyword argument of get_vector_label
+* **Returns:**
+ The MathTex of the label.
+* **Return type:**
+ [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex)
+
+#### add_transformable_mobject(\*mobjects)
+
+Adds the mobjects to the special list
+self.transformable_mobjects.
+
+* **Parameters:**
+ **\*mobjects** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobjects to add to the list.
+
+#### add_unit_square(animate=False, \*\*kwargs)
+
+Adds a unit square to the scene via
+self.get_unit_square.
+
+* **Parameters:**
+ * **animate** (*bool*) – Whether or not to animate the addition
+ with DrawBorderThenFill.
+ * **\*\*kwargs** – Any valid keyword arguments of
+ self.get_unit_square()
+* **Returns:**
+ The unit square.
+* **Return type:**
+ [Square](manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square)
+
+#### add_vector(vector, color=ManimColor('#FFFF00'), \*\*kwargs)
+
+Adds a vector to the scene, and puts it in the special
+list self.moving_vectors.
+
+* **Parameters:**
+ * **vector** ([*Arrow*](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow) *|* *list* *|* *tuple* *|* *ndarray*) – It can be a pre-made graphical vector, or the
+ coordinates of one.
+ * **color** (*str*) – The string of the hex color of the vector.
+ This is only taken into consideration if
+ ‘vector’ is not an Arrow. Defaults to YELLOW.
+ * **\*\*kwargs** – Any valid keyword argument of VectorScene.add_vector.
+* **Returns:**
+ The arrow representing the vector.
+* **Return type:**
+ [Arrow](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow)
+
+#### apply_function(function, added_anims=[], \*\*kwargs)
+
+Applies the given function to each of the mobjects in
+self.transformable_mobjects, and plays the animation showing
+this.
+
+* **Parameters:**
+ * **function** (*Callable* *[* *[**ndarray* *]* *,* *ndarray* *]*) – The function that affects each point
+ of each mobject in self.transformable_mobjects.
+ * **added_anims** (*list*) – Any other animations that need to be played
+ simultaneously with this.
+ * **\*\*kwargs** – Any valid keyword argument of a self.play() call.
+
+#### apply_inverse(matrix, \*\*kwargs)
+
+This method applies the linear transformation
+represented by the inverse of the passed matrix
+to the number plane, and each vector/similar mobject on it.
+
+* **Parameters:**
+ * **matrix** (*ndarray* *|* *list* *|* *tuple*) – The matrix whose inverse is to be applied.
+ * **\*\*kwargs** – Any valid keyword argument of self.apply_matrix()
+
+#### apply_inverse_transpose(t_matrix, \*\*kwargs)
+
+Applies the inverse of the transformation represented
+by the given transposed matrix to the number plane and each
+vector/similar mobject on it.
+
+* **Parameters:**
+ * **t_matrix** (*ndarray* *|* *list* *|* *tuple*) – The matrix.
+ * **\*\*kwargs** – Any valid keyword argument of self.apply_transposed_matrix()
+
+#### apply_matrix(matrix, \*\*kwargs)
+
+Applies the transformation represented by the
+given matrix to the number plane, and each vector/similar
+mobject on it.
+
+* **Parameters:**
+ * **matrix** (*ndarray* *|* *list* *|* *tuple*) – The matrix.
+ * **\*\*kwargs** – Any valid keyword argument of self.apply_transposed_matrix()
+
+#### apply_nonlinear_transformation(function, \*\*kwargs)
+
+Applies the non-linear transformation represented
+by the given function to the number plane and each
+vector/similar mobject on it.
+
+* **Parameters:**
+ * **function** (*Callable* *[* *[**ndarray* *]* *,* *ndarray* *]*) – The function.
+ * **\*\*kwargs** – Any valid keyword argument of self.apply_function()
+
+#### apply_transposed_matrix(transposed_matrix, \*\*kwargs)
+
+Applies the transformation represented by the
+given transposed matrix to the number plane,
+and each vector/similar mobject on it.
+
+* **Parameters:**
+ * **transposed_matrix** (*ndarray* *|* *list* *|* *tuple*) – The matrix.
+ * **\*\*kwargs** – Any valid keyword argument of self.apply_function()
+
+#### get_ghost_vectors()
+
+Returns all ghost vectors ever added to `self`. Each element is a `VGroup` of
+two ghost vectors.
+
+* **Return type:**
+ [*VGroup*](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+#### get_matrix_transformation(matrix)
+
+Returns a function corresponding to the linear
+transformation represented by the matrix passed.
+
+* **Parameters:**
+ **matrix** (*ndarray* *|* *list* *|* *tuple*) – The matrix.
+
+#### get_moving_mobject_movement(func)
+
+This method returns an animation that moves a mobject
+in “self.moving_mobjects” to its corresponding .target value.
+func is a function that determines where the .target goes.
+
+* **Parameters:**
+ **func** (*Callable* *[* *[**ndarray* *]* *,* *ndarray* *]*) – The function that determines where the .target of
+ the moving mobject goes.
+* **Returns:**
+ The animation of the movement.
+* **Return type:**
+ [Animation](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+#### get_piece_movement(pieces)
+
+This method returns an animation that moves an arbitrary
+mobject in “pieces” to its corresponding .target value.
+If self.leave_ghost_vectors is True, ghosts of the original
+positions/mobjects are left on screen
+
+* **Parameters:**
+ **pieces** (*list* *|* *tuple* *|* *ndarray*) – The pieces for which the movement must be shown.
+* **Returns:**
+ The animation of the movement.
+* **Return type:**
+ [Animation](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+#### get_transformable_label_movement()
+
+This method returns an animation that moves all labels
+in “self.transformable_labels” to its corresponding .target .
+
+* **Returns:**
+ The animation of the movement.
+* **Return type:**
+ [Animation](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+#### get_transposed_matrix_transformation(transposed_matrix)
+
+Returns a function corresponding to the linear
+transformation represented by the transposed
+matrix passed.
+
+* **Parameters:**
+ **transposed_matrix** (*ndarray* *|* *list* *|* *tuple*) – The matrix.
+
+#### get_unit_square(color=ManimColor('#FFFF00'), opacity=0.3, stroke_width=3)
+
+Returns a unit square for the current NumberPlane.
+
+* **Parameters:**
+ * **color** (*str*) – The string of the hex color code of the color wanted.
+ * **opacity** (*float*) – The opacity of the square
+ * **stroke_width** (*float*) – The stroke_width in pixels of the border of the square
+* **Return type:**
+ [Square](manim.mobject.geometry.polygram.Square.md#manim.mobject.geometry.polygram.Square)
+
+#### get_vector_movement(func)
+
+This method returns an animation that moves a mobject
+in “self.moving_vectors” to its corresponding .target value.
+func is a function that determines where the .target goes.
+
+* **Parameters:**
+ **func** (*Callable* *[* *[**ndarray* *]* *,* *ndarray* *]*) – The function that determines where the .target of
+ the moving mobject goes.
+* **Returns:**
+ The animation of the movement.
+* **Return type:**
+ [Animation](manim.animation.animation.Animation.md#manim.animation.animation.Animation)
+
+#### setup()
+
+This is meant to be implemented by any scenes which
+are commonly subclassed, and have some common setup
+involved before the construct method is called.
+
+#### write_vector_coordinates(vector, \*\*kwargs)
+
+Returns a column matrix indicating the vector coordinates,
+after writing them to the screen, and adding them to the
+special list self.foreground_mobjects
+
+* **Parameters:**
+ * **vector** ([*Arrow*](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow)) – The arrow representing the vector.
+ * **\*\*kwargs** – Any valid keyword arguments of VectorScene.write_vector_coordinates
+* **Returns:**
+ The column matrix representing the vector.
+* **Return type:**
+ [Matrix](manim.mobject.matrix.Matrix.md#manim.mobject.matrix.Matrix)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.vector_space_scene.VectorScene.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.vector_space_scene.VectorScene.md
new file mode 100644
index 0000000000000000000000000000000000000000..fb33bab1d1d3b8c9b1c9294ab6984ee77952d863
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.vector_space_scene.VectorScene.md
@@ -0,0 +1,205 @@
+# VectorScene
+
+Qualified name: `manim.scene.vector\_space\_scene.VectorScene`
+
+### *class* VectorScene(basis_vector_stroke_width=6, \*\*kwargs)
+
+Bases: [`Scene`](manim.scene.scene.Scene.md#manim.scene.scene.Scene)
+
+### Methods
+
+| [`add_axes`](#manim.scene.vector_space_scene.VectorScene.add_axes) | Adds a pair of Axes to the Scene. |
+|----------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`add_plane`](#manim.scene.vector_space_scene.VectorScene.add_plane) | Adds a NumberPlane object to the background. |
+| [`add_vector`](#manim.scene.vector_space_scene.VectorScene.add_vector) | Returns the Vector after adding it to the Plane. |
+| [`coords_to_vector`](#manim.scene.vector_space_scene.VectorScene.coords_to_vector) | This method writes the vector as a column matrix (henceforth called the label), takes the values in it one by one, and form the corresponding lines that make up the x and y components of the vector. |
+| [`get_basis_vector_labels`](#manim.scene.vector_space_scene.VectorScene.get_basis_vector_labels) | Returns naming labels for the basis vectors. |
+| [`get_basis_vectors`](#manim.scene.vector_space_scene.VectorScene.get_basis_vectors) | Returns a VGroup of the Basis Vectors (1,0) and (0,1) |
+| [`get_vector`](#manim.scene.vector_space_scene.VectorScene.get_vector) | Returns an arrow on the Plane given an input numerical vector. |
+| [`get_vector_label`](#manim.scene.vector_space_scene.VectorScene.get_vector_label) | Returns naming labels for the passed vector. |
+| [`label_vector`](#manim.scene.vector_space_scene.VectorScene.label_vector) | Shortcut method for creating, and animating the addition of a label for the vector. |
+| [`lock_in_faded_grid`](#manim.scene.vector_space_scene.VectorScene.lock_in_faded_grid) | This method freezes the NumberPlane and Axes that were already in the background, and adds new, manipulatable ones to the foreground. |
+| `position_x_coordinate` | |
+| `position_y_coordinate` | |
+| [`show_ghost_movement`](#manim.scene.vector_space_scene.VectorScene.show_ghost_movement) | This method plays an animation that partially shows the entire plane moving in the direction of a particular vector. |
+| [`vector_to_coords`](#manim.scene.vector_space_scene.VectorScene.vector_to_coords) | This method displays vector as a Vector() based vector, and then shows the corresponding lines that make up the x and y components of the vector. |
+| [`write_vector_coordinates`](#manim.scene.vector_space_scene.VectorScene.write_vector_coordinates) | Returns a column matrix indicating the vector coordinates, after writing them to the screen. |
+
+### Attributes
+
+| `camera` | |
+|------------|----------------------------------------|
+| `time` | The time since the start of the scene. |
+
+#### add_axes(animate=False, color=ManimColor('#FFFFFF'), \*\*kwargs)
+
+Adds a pair of Axes to the Scene.
+
+* **Parameters:**
+ * **animate** (*bool*) – Whether or not to animate the addition of the axes through Create.
+ * **color** (*bool*) – The color of the axes. Defaults to WHITE.
+
+#### add_plane(animate=False, \*\*kwargs)
+
+Adds a NumberPlane object to the background.
+
+* **Parameters:**
+ * **animate** (*bool*) – Whether or not to animate the addition of the plane via Create.
+ * **\*\*kwargs** – Any valid keyword arguments accepted by NumberPlane.
+* **Returns:**
+ The NumberPlane object.
+* **Return type:**
+ [NumberPlane](manim.mobject.graphing.coordinate_systems.NumberPlane.md#manim.mobject.graphing.coordinate_systems.NumberPlane)
+
+#### add_vector(vector, color=ManimColor('#FFFF00'), animate=True, \*\*kwargs)
+
+Returns the Vector after adding it to the Plane.
+
+* **Parameters:**
+ * **vector** ([*Arrow*](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow) *|* *list* *|* *tuple* *|* *ndarray*) – It can be a pre-made graphical vector, or the
+ coordinates of one.
+ * **color** (*str*) – The string of the hex color of the vector.
+ This is only taken into consideration if
+ ‘vector’ is not an Arrow. Defaults to YELLOW.
+ * **animate** (*bool*) – Whether or not to animate the addition of the vector
+ by using GrowArrow
+ * **\*\*kwargs** – Any valid keyword argument of Arrow.
+ These are only considered if vector is not
+ an Arrow.
+* **Returns:**
+ The arrow representing the vector.
+* **Return type:**
+ [Arrow](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow)
+
+#### coords_to_vector(vector, coords_start=array([2., 2., 0.]), clean_up=True)
+
+This method writes the vector as a column matrix (henceforth called the label),
+takes the values in it one by one, and form the corresponding
+lines that make up the x and y components of the vector. Then, an
+Vector() based vector is created between the lines on the Screen.
+
+* **Parameters:**
+ * **vector** (*ndarray* *|* *list* *|* *tuple*) – The vector to show.
+ * **coords_start** (*ndarray* *|* *list* *|* *tuple*) – The starting point of the location of
+ the label of the vector that shows it
+ numerically.
+ Defaults to 2 \* RIGHT + 2 \* UP or (2,2)
+ * **clean_up** (*bool*) – Whether or not to remove whatever
+ this method did after it’s done.
+
+#### get_basis_vector_labels(\*\*kwargs)
+
+Returns naming labels for the basis vectors.
+
+* **Parameters:**
+ **\*\*kwargs** –
+
+ Any valid keyword arguments of get_vector_label:
+ : vector,
+ label (str,MathTex)
+ at_tip (bool=False),
+ direction (str=”left”),
+ rotate (bool),
+ color (str),
+ label_scale_factor=VECTOR_LABEL_SCALE_FACTOR (int, float),
+
+#### get_basis_vectors(i_hat_color=ManimColor('#83C167'), j_hat_color=ManimColor('#FC6255'))
+
+Returns a VGroup of the Basis Vectors (1,0) and (0,1)
+
+* **Parameters:**
+ * **i_hat_color** (*str*) – The hex colour to use for the basis vector in the x direction
+ * **j_hat_color** (*str*) – The hex colour to use for the basis vector in the y direction
+* **Returns:**
+ VGroup of the Vector Mobjects representing the basis vectors.
+* **Return type:**
+ [VGroup](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+#### get_vector(numerical_vector, \*\*kwargs)
+
+Returns an arrow on the Plane given an input numerical vector.
+
+* **Parameters:**
+ * **numerical_vector** (*ndarray* *|* *list* *|* *tuple*) – The Vector to plot.
+ * **\*\*kwargs** – Any valid keyword argument of Arrow.
+* **Returns:**
+ The Arrow representing the Vector.
+* **Return type:**
+ [Arrow](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow)
+
+#### get_vector_label(vector, label, at_tip=False, direction='left', rotate=False, color=None, label_scale_factor=0.8)
+
+Returns naming labels for the passed vector.
+
+* **Parameters:**
+ * **vector** ([*Vector*](manim.mobject.geometry.line.Vector.md#manim.mobject.geometry.line.Vector)) – Vector Object for which to get the label.
+ * **at_tip** (*bool*) – Whether or not to place the label at the tip of the vector.
+ * **direction** (*str*) – If the label should be on the “left” or right of the vector.
+ * **rotate** (*bool*) – Whether or not to rotate it to align it with the vector.
+ * **color** (*str* *|* *None*) – The color to give the label.
+ * **label_scale_factor** (*float*) – How much to scale the label by.
+* **Returns:**
+ The MathTex of the label.
+* **Return type:**
+ [MathTex](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex)
+
+#### label_vector(vector, label, animate=True, \*\*kwargs)
+
+Shortcut method for creating, and animating the addition of
+a label for the vector.
+
+* **Parameters:**
+ * **vector** ([*Vector*](manim.mobject.geometry.line.Vector.md#manim.mobject.geometry.line.Vector)) – The vector for which the label must be added.
+ * **label** ([*MathTex*](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex) *|* *str*) – The MathTex/string of the label.
+ * **animate** (*bool*) – Whether or not to animate the labelling w/ Write
+ * **\*\*kwargs** – Any valid keyword argument of get_vector_label
+* **Returns:**
+ The MathTex of the label.
+* **Return type:**
+ [`MathTex`](manim.mobject.text.tex_mobject.MathTex.md#manim.mobject.text.tex_mobject.MathTex)
+
+#### lock_in_faded_grid(dimness=0.7, axes_dimness=0.5)
+
+This method freezes the NumberPlane and Axes that were already
+in the background, and adds new, manipulatable ones to the foreground.
+
+* **Parameters:**
+ * **dimness** (*float*) – The required dimness of the NumberPlane
+ * **axes_dimness** (*float*) – The required dimness of the Axes.
+
+#### show_ghost_movement(vector)
+
+This method plays an animation that partially shows the entire plane moving
+in the direction of a particular vector. This is useful when you wish to
+convey the idea of mentally moving the entire plane in a direction, without
+actually moving the plane.
+
+* **Parameters:**
+ **vector** ([*Arrow*](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow) *|* *list* *|* *tuple* *|* *ndarray*) – The vector which indicates the direction of movement.
+
+#### vector_to_coords(vector, integer_labels=True, clean_up=True)
+
+This method displays vector as a Vector() based vector, and then shows
+the corresponding lines that make up the x and y components of the vector.
+Then, a column matrix (henceforth called the label) is created near the
+head of the Vector.
+
+* **Parameters:**
+ * **vector** (*ndarray* *|* *list* *|* *tuple*) – The vector to show.
+ * **integer_labels** (*bool*) – Whether or not to round the value displayed.
+ in the vector’s label to the nearest integer
+ * **clean_up** (*bool*) – Whether or not to remove whatever
+ this method did after it’s done.
+
+#### write_vector_coordinates(vector, \*\*kwargs)
+
+Returns a column matrix indicating the vector coordinates,
+after writing them to the screen.
+
+* **Parameters:**
+ * **vector** ([*Arrow*](manim.mobject.geometry.line.Arrow.md#manim.mobject.geometry.line.Arrow)) – The arrow representing the vector.
+ * **\*\*kwargs** – Any valid keyword arguments of [`coordinate_label()`](manim.mobject.geometry.line.Vector.md#manim.mobject.geometry.line.Vector.coordinate_label):
+* **Returns:**
+ The column matrix representing the vector.
+* **Return type:**
+ [`Matrix`](manim.mobject.matrix.Matrix.md#manim.mobject.matrix.Matrix)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.vector_space_scene.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.vector_space_scene.md
new file mode 100644
index 0000000000000000000000000000000000000000..e29683720f3fcee9657704e6ccf0abaa46cbfd87
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.vector_space_scene.md
@@ -0,0 +1,9 @@
+# vector_space_scene
+
+A scene suitable for vector spaces.
+
+### Classes
+
+| [`LinearTransformationScene`](manim.scene.vector_space_scene.LinearTransformationScene.md#manim.scene.vector_space_scene.LinearTransformationScene) | This scene contains special methods that make it especially suitable for showing linear transformations. |
+|-------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------|
+| [`VectorScene`](manim.scene.vector_space_scene.VectorScene.md#manim.scene.vector_space_scene.VectorScene) | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.zoomed_scene.ZoomedScene.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.zoomed_scene.ZoomedScene.md
new file mode 100644
index 0000000000000000000000000000000000000000..61260304f1d0768dc43ee28977f8589251b760b5
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.zoomed_scene.ZoomedScene.md
@@ -0,0 +1,72 @@
+# ZoomedScene
+
+Qualified name: `manim.scene.zoomed\_scene.ZoomedScene`
+
+### *class* ZoomedScene(camera_class=, zoomed_display_height=3, zoomed_display_width=3, zoomed_display_center=None, zoomed_display_corner=array([1., 1., 0.]), zoomed_display_corner_buff=0.5, zoomed_camera_config={'background_opacity': 1, 'default_frame_stroke_width': 2}, zoomed_camera_image_mobject_config={}, zoomed_camera_frame_starting_position=array([0., 0., 0.]), zoom_factor=0.15, image_frame_stroke_width=3, zoom_activated=False, \*\*kwargs)
+
+Bases: [`MovingCameraScene`](manim.scene.moving_camera_scene.MovingCameraScene.md#manim.scene.moving_camera_scene.MovingCameraScene)
+
+This is a Scene with special configurations made for when
+a particular part of the scene must be zoomed in on and displayed
+separately.
+
+### Methods
+
+| [`activate_zooming`](#manim.scene.zoomed_scene.ZoomedScene.activate_zooming) | This method is used to activate the zooming for the zoomed_camera. |
+|----------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------|
+| [`get_zoom_factor`](#manim.scene.zoomed_scene.ZoomedScene.get_zoom_factor) | Returns the Zoom factor of the Zoomed camera. |
+| [`get_zoom_in_animation`](#manim.scene.zoomed_scene.ZoomedScene.get_zoom_in_animation) | Returns the animation of camera zooming in. |
+| [`get_zoomed_display_pop_out_animation`](#manim.scene.zoomed_scene.ZoomedScene.get_zoomed_display_pop_out_animation) | This is the animation of the popping out of the mini-display that shows the content of the zoomed camera. |
+| [`setup`](#manim.scene.zoomed_scene.ZoomedScene.setup) | This method is used internally by Manim to setup the scene for proper use. |
+
+### Attributes
+
+| `camera` | |
+|------------|----------------------------------------|
+| `time` | The time since the start of the scene. |
+
+#### activate_zooming(animate=False)
+
+This method is used to activate the zooming for
+the zoomed_camera.
+
+* **Parameters:**
+ **animate** (*bool*) – Whether or not to animate the activation
+ of the zoomed camera.
+
+#### get_zoom_factor()
+
+Returns the Zoom factor of the Zoomed camera.
+Defined as the ratio between the height of the
+zoomed camera and the height of the zoomed mini
+display.
+:returns: The zoom factor.
+:rtype: float
+
+#### get_zoom_in_animation(run_time=2, \*\*kwargs)
+
+Returns the animation of camera zooming in.
+
+* **Parameters:**
+ * **run_time** (*float*) – The run_time of the animation of the camera zooming in.
+ * **\*\*kwargs** – Any valid keyword arguments of ApplyMethod()
+* **Returns:**
+ The animation of the camera zooming in.
+* **Return type:**
+ [ApplyMethod](manim.animation.transform.ApplyMethod.md#manim.animation.transform.ApplyMethod)
+
+#### get_zoomed_display_pop_out_animation(\*\*kwargs)
+
+This is the animation of the popping out of the
+mini-display that shows the content of the zoomed
+camera.
+
+* **Returns:**
+ The Animation of the Zoomed Display popping out.
+* **Return type:**
+ [ApplyMethod](manim.animation.transform.ApplyMethod.md#manim.animation.transform.ApplyMethod)
+
+#### setup()
+
+This method is used internally by Manim to
+setup the scene for proper use.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.scene.zoomed_scene.md b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.zoomed_scene.md
new file mode 100644
index 0000000000000000000000000000000000000000..6b31699b15ccc8c552bcda2a5d94a649130e27e6
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.scene.zoomed_scene.md
@@ -0,0 +1,108 @@
+# zoomed_scene
+
+A scene supporting zooming in on a specified section.
+
+### Examples
+
+
+
+### Classes
+
+| [`ZoomedScene`](manim.scene.zoomed_scene.ZoomedScene.md#manim.scene.zoomed_scene.ZoomedScene) | This is a Scene with special configurations made for when a particular part of the scene must be zoomed in on and displayed separately. |
+|-------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.typing.md b/data/rag/manim_docs/manim_core/docs/reference/manim.typing.md
new file mode 100644
index 0000000000000000000000000000000000000000..78b8633f6f26b8a639fb5d54b3edfe070705a6b7
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.typing.md
@@ -0,0 +1,1032 @@
+# typing
+
+Custom type definitions used in Manim.
+
+### Type Aliases
+
+### Primitive data types
+
+### *class* ManimFloat
+
+```default
+np.float64
+```
+
+A double-precision floating-point value (64 bits, or 8 bytes),
+according to the IEEE 754 standard.
+
+### *class* ManimInt
+
+```default
+np.int64
+```
+
+A long integer (64 bits, or 8 bytes).
+
+It can take values between $-2^{63}$ and $+2^{63} - 1$,
+which expressed in base 10 is a range between around
+$-9.223 \cdot 10^{18}$ and $+9.223 \cdot 10^{18}$.
+
+### Color types
+
+### *class* ManimColorDType
+
+```default
+[`ManimFloat`](#manim.typing.ManimFloat)
+```
+
+Data type used in [`ManimColorInternal`](#manim.typing.ManimColorInternal): a
+double-precision float between 0 and 1.
+
+### *class* RGB_Array_Float
+
+```default
+NDArray[[`ManimColorDType`](#manim.typing.ManimColorDType)]
+```
+
+`shape: (3,)`
+
+A `numpy.ndarray` of 3 floats between 0 and 1, representing a
+color in RGB format.
+
+Its components describe, in order, the intensity of Red, Green, and
+Blue in the represented color.
+
+### *class* RGB_Tuple_Float
+
+```default
+tuple[float, float, float]
+```
+
+`shape: (3,)`
+
+A tuple of 3 floats between 0 and 1, representing a color in RGB
+format.
+
+Its components describe, in order, the intensity of Red, Green, and
+Blue in the represented color.
+
+### *class* RGB_Array_Int
+
+```default
+NDArray[[`ManimInt`](#manim.typing.ManimInt)]
+```
+
+`shape: (3,)`
+
+A `numpy.ndarray` of 3 integers between 0 and 255,
+representing a color in RGB format.
+
+Its components describe, in order, the intensity of Red, Green, and
+Blue in the represented color.
+
+### *class* RGB_Tuple_Int
+
+```default
+tuple[int, int, int]
+```
+
+`shape: (3,)`
+
+A tuple of 3 integers between 0 and 255, representing a color in RGB
+format.
+
+Its components describe, in order, the intensity of Red, Green, and
+Blue in the represented color.
+
+### *class* RGBA_Array_Float
+
+```default
+NDArray[[`ManimColorDType`](#manim.typing.ManimColorDType)]
+```
+
+`shape: (4,)`
+
+A `numpy.ndarray` of 4 floats between 0 and 1, representing a
+color in RGBA format.
+
+Its components describe, in order, the intensity of Red, Green, Blue
+and Alpha (opacity) in the represented color.
+
+### *class* RGBA_Tuple_Float
+
+```default
+tuple[float, float, float, float]
+```
+
+`shape: (4,)`
+
+A tuple of 4 floats between 0 and 1, representing a color in RGBA
+format.
+
+Its components describe, in order, the intensity of Red, Green, Blue
+and Alpha (opacity) in the represented color.
+
+### *class* RGBA_Array_Int
+
+```default
+NDArray[[`ManimInt`](#manim.typing.ManimInt)]
+```
+
+`shape: (4,)`
+
+A `numpy.ndarray` of 4 integers between 0 and 255,
+representing a color in RGBA format.
+
+Its components describe, in order, the intensity of Red, Green, Blue
+and Alpha (opacity) in the represented color.
+
+### *class* RGBA_Tuple_Int
+
+```default
+tuple[int, int, int, int]
+```
+
+`shape: (4,)`
+
+A tuple of 4 integers between 0 and 255, representing a color in RGBA
+format.
+
+Its components describe, in order, the intensity of Red, Green, Blue
+and Alpha (opacity) in the represented color.
+
+### *class* HSV_Array_Float
+
+```default
+[`RGB_Array_Float`](#manim.typing.RGB_Array_Float)
+```
+
+`shape: (3,)`
+
+A `numpy.ndarray` of 3 floats between 0 and 1, representing a
+color in HSV (or HSB) format.
+
+Its components describe, in order, the Hue, Saturation and Value (or
+Brightness) in the represented color.
+
+### *class* HSV_Tuple_Float
+
+```default
+[`RGB_Tuple_Float`](#manim.typing.RGB_Tuple_Float)
+```
+
+`shape: (3,)`
+
+A tuple of 3 floats between 0 and 1, representing a color in HSV (or
+HSB) format.
+
+Its components describe, in order, the Hue, Saturation and Value (or
+Brightness) in the represented color.
+
+### *class* HSVA_Array_Float
+
+```default
+[`RGBA_Array_Float`](#manim.typing.RGBA_Array_Float)
+```
+
+`shape: (4,)`
+
+A `numpy.ndarray` of 4 floats between 0 and 1, representing a
+color in HSVA (or HSBA) format.
+
+Its components describe, in order, the Hue, Saturation and Value (or
+Brightness) in the represented color.
+
+### *class* HSVA_Tuple_Float
+
+```default
+[`RGBA_Tuple_Float`](#manim.typing.RGBA_Tuple_Float)
+```
+
+`shape: (4,)`
+
+A tuple of 4 floats between 0 and 1, representing a color in HSVA (or
+HSBA) format.
+
+Its components describe, in order, the Hue, Saturation and Value (or
+Brightness) in the represented color.
+
+### *class* HSL_Array_Float
+
+```default
+[`RGB_Array_Float`](#manim.typing.RGB_Array_Float)
+```
+
+`shape: (3,)`
+
+A `numpy.ndarray` of 3 floats between 0 and 1, representing a
+color in HSL format.
+
+Its components describe, in order, the Hue, Saturation and Lightness
+in the represented color.
+
+### *class* HSL_Tuple_Float
+
+```default
+[`RGB_Tuple_Float`](#manim.typing.RGB_Tuple_Float)
+```
+
+`shape: (3,)`
+
+A `numpy.ndarray` of 3 floats between 0 and 1, representing a
+color in HSL format.
+
+Its components describe, in order, the Hue, Saturation and Lightness
+in the represented color.
+
+### *class* ManimColorInternal
+
+```default
+[`RGBA_Array_Float`](#manim.typing.RGBA_Array_Float)
+```
+
+`shape: (4,)`
+
+Internal color representation used by [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor),
+following the RGBA format.
+
+It is a `numpy.ndarray` consisting of 4 floats between 0 and
+1, describing respectively the intensities of Red, Green, Blue and
+Alpha (opacity) in the represented color.
+
+### Point types
+
+### *class* PointDType
+
+```default
+[`ManimFloat`](#manim.typing.ManimFloat)
+```
+
+Default type for arrays representing points: a double-precision
+floating point value.
+
+### *class* Point2D
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (2,)`
+
+A NumPy array representing a 2-dimensional point: `[float, float]`.
+
+### *class* Point2DLike
+
+```default
+[`Point2D`](#manim.typing.Point2D) | tuple[float, float]
+```
+
+`shape: (2,)`
+
+A 2-dimensional point: `[float, float]`.
+
+This represents anything which can be converted to a :class:[`Point2D`](#manim.typing.Point2D) NumPy
+array.
+
+Normally, a function or method which expects a [`Point2D`](#manim.typing.Point2D) as a
+parameter can handle being passed a [`Point3D`](#manim.typing.Point3D) instead.
+
+### *class* Point2D_Array
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (M, 2)`
+
+A NumPy array representing a sequence of [`Point2D`](#manim.typing.Point2D) objects:
+`[[float, float], ...]`.
+
+### *class* Point2DLike_Array
+
+```default
+[`Point2D_Array`](#manim.typing.Point2D_Array) | Sequence[[`Point2DLike`](#manim.typing.Point2DLike)]
+```
+
+`shape: (M, 2)`
+
+An array of [`Point2DLike`](#manim.typing.Point2DLike) objects: `[[float, float], ...]`.
+
+This represents anything which can be converted to a :class:[`Point2D_Array`](#manim.typing.Point2D_Array)
+NumPy array.
+
+Normally, a function or method which expects a [`Point2D_Array`](#manim.typing.Point2D_Array) as a
+parameter can handle being passed a [`Point3D_Array`](#manim.typing.Point3D_Array) instead.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* Point3D
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (3,)`
+
+A NumPy array representing a 3-dimensional point: `[float, float, float]`.
+
+### *class* Point3DLike
+
+```default
+[`Point3D`](#manim.typing.Point3D) | tuple[float, float, float]
+```
+
+`shape: (3,)`
+
+A 3-dimensional point: `[float, float, float]`.
+
+This represents anything which can be converted to a :class:[`Point3D`](#manim.typing.Point3D) NumPy
+array.
+
+### *class* Point3D_Array
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (M, 3)`
+
+A NumPy array representing a sequence of [`Point3D`](#manim.typing.Point3D) objects:
+`[[float, float, float], ...]`.
+
+### *class* Point3DLike_Array
+
+```default
+[`Point3D_Array`](#manim.typing.Point3D_Array) | Sequence[[`Point3DLike`](#manim.typing.Point3DLike)]
+```
+
+`shape: (M, 3)`
+
+An array of [`Point3D`](#manim.typing.Point3D) objects: `[[float, float, float], ...]`.
+
+This represents anything which can be converted to a :class:[`Point3D_Array`](#manim.typing.Point3D_Array)
+NumPy array.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* PointND
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (N,)`
+
+A NumPy array representing an N-dimensional point: `[float, ...]`.
+
+### *class* PointNDLike
+
+```default
+[`PointND`](#manim.typing.PointND) | Sequence[float]
+```
+
+`shape: (N,)`
+
+An N-dimensional point: `[float, ...]`.
+
+This represents anything which can be converted to a :class:[`PointND`](#manim.typing.PointND) NumPy
+array.
+
+### *class* PointND_Array
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (M, N)`
+
+A NumPy array representing a sequence of [`PointND`](#manim.typing.PointND) objects:
+`[[float, ...], ...]`.
+
+### *class* PointNDLike_Array
+
+```default
+[`PointND_Array`](#manim.typing.PointND_Array) | Sequence[[`PointNDLike`](#manim.typing.PointNDLike)]
+```
+
+`shape: (M, N)`
+
+An array of [`PointND`](#manim.typing.PointND) objects: `[[float, ...], ...]`.
+
+This represents anything which can be converted to a :class:[`PointND_Array`](#manim.typing.PointND_Array)
+NumPy array.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### Vector types
+
+### *class* Vector2D
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (2,)`
+
+A 2-dimensional vector: `[float, float]`.
+
+Normally, a function or method which expects a [`Vector2D`](#manim.typing.Vector2D) as a
+parameter can handle being passed a [`Vector3D`](#manim.typing.Vector3D) instead.
+
+### *class* Vector2D_Array
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (M, 2)`
+
+An array of [`Vector2D`](#manim.typing.Vector2D) objects: `[[float, float], ...]`.
+
+Normally, a function or method which expects a [`Vector2D_Array`](#manim.typing.Vector2D_Array) as a
+parameter can handle being passed a [`Vector3D_Array`](#manim.typing.Vector3D_Array) instead.
+
+### *class* Vector3D
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (3,)`
+
+A 3-dimensional vector: `[float, float, float]`.
+
+### *class* Vector3D_Array
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (M, 3)`
+
+An array of [`Vector3D`](#manim.typing.Vector3D) objects: `[[float, float, float], ...]`.
+
+### *class* VectorND
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape (N,)`
+
+An $N$-dimensional vector: `[float, ...]`.
+
+### *class* VectorND_Array
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape (M, N)`
+
+An array of [`VectorND`](#manim.typing.VectorND) objects: `[[float, ...], ...]`.
+
+### *class* RowVector
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (1, N)`
+
+A row vector: `[[float, ...]]`.
+
+### *class* ColVector
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (N, 1)`
+
+A column vector: `[[float], [float], ...]`.
+
+### Matrix types
+
+### *class* MatrixMN
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (M, N)`
+
+A matrix: `[[float, ...], [float, ...], ...]`.
+
+### *class* Zeros
+
+```default
+[`MatrixMN`](#manim.typing.MatrixMN)
+```
+
+`shape: (M, N)`
+
+A [`MatrixMN`](#manim.typing.MatrixMN) filled with zeros, typically created with
+`numpy.zeros((M, N))`.
+
+### Bézier types
+
+### *class* QuadraticBezierPoints
+
+```default
+[`Point3D_Array`](#manim.typing.Point3D_Array)
+```
+
+`shape: (3, 3)`
+
+A [`Point3D_Array`](#manim.typing.Point3D_Array) of three 3D control points for a single quadratic Bézier
+curve:
+`[[float, float, float], [float, float, float], [float, float, float]]`.
+
+### *class* QuadraticBezierPointsLike
+
+```default
+[`QuadraticBezierPoints`](#manim.typing.QuadraticBezierPoints) | tuple[[`Point3DLike`](#manim.typing.Point3DLike), [`Point3DLike`](#manim.typing.Point3DLike), [`Point3DLike`](#manim.typing.Point3DLike)]
+```
+
+`shape: (3, 3)`
+
+A [`Point3DLike_Array`](#manim.typing.Point3DLike_Array) of three 3D control points for a single quadratic Bézier
+curve:
+`[[float, float, float], [float, float, float], [float, float, float]]`.
+
+This represents anything which can be converted to a
+:class:[`QuadraticBezierPoints`](#manim.typing.QuadraticBezierPoints) NumPy array.
+
+### *class* QuadraticBezierPoints_Array
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (N, 3, 3)`
+
+A NumPy array containing $N$ [`QuadraticBezierPoints`](#manim.typing.QuadraticBezierPoints) objects:
+`[[[float, float, float], [float, float, float], [float, float, float]], ...]`.
+
+### *class* QuadraticBezierPointsLike_Array
+
+```default
+[`QuadraticBezierPoints_Array`](#manim.typing.QuadraticBezierPoints_Array) | Sequence[[`QuadraticBezierPointsLike`](#manim.typing.QuadraticBezierPointsLike)]
+```
+
+`shape: (N, 3, 3)`
+
+A sequence of $N$ [`QuadraticBezierPointsLike`](#manim.typing.QuadraticBezierPointsLike) objects:
+`[[[float, float, float], [float, float, float], [float, float, float]], ...]`.
+
+This represents anything which can be converted to a
+:class:[`QuadraticBezierPoints_Array`](#manim.typing.QuadraticBezierPoints_Array) NumPy array.
+
+### *class* QuadraticBezierPath
+
+```default
+[`Point3D_Array`](#manim.typing.Point3D_Array)
+```
+
+`shape: (3*N, 3)`
+
+A [`Point3D_Array`](#manim.typing.Point3D_Array) of $3N$ points, where each one of the
+$N$ consecutive blocks of 3 points represents a quadratic
+Bézier curve:
+`[[float, float, float], ...], ...]`.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* QuadraticBezierPathLike
+
+```default
+[`Point3DLike_Array`](#manim.typing.Point3DLike_Array)
+```
+
+`shape: (3*N, 3)`
+
+A [`Point3DLike_Array`](#manim.typing.Point3DLike_Array) of $3N$ points, where each one of the
+$N$ consecutive blocks of 3 points represents a quadratic
+Bézier curve:
+`[[float, float, float], ...], ...]`.
+
+This represents anything which can be converted to a
+:class:[`QuadraticBezierPath`](#manim.typing.QuadraticBezierPath) NumPy array.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* QuadraticSpline
+
+```default
+[`QuadraticBezierPath`](#manim.typing.QuadraticBezierPath)
+```
+
+`shape: (3*N, 3)`
+
+A special case of [`QuadraticBezierPath`](#manim.typing.QuadraticBezierPath) where all the $N$
+quadratic Bézier curves are connected, forming a quadratic spline:
+`[[float, float, float], ...], ...]`.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* QuadraticSplineLike
+
+```default
+[`QuadraticBezierPathLike`](#manim.typing.QuadraticBezierPathLike)
+```
+
+`shape: (3*N, 3)`
+
+A special case of [`QuadraticBezierPathLike`](#manim.typing.QuadraticBezierPathLike) where all the $N$
+quadratic Bézier curves are connected, forming a quadratic spline:
+`[[float, float, float], ...], ...]`.
+
+This represents anything which can be converted to a :class:[`QuadraticSpline`](#manim.typing.QuadraticSpline)
+NumPy array.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* CubicBezierPoints
+
+```default
+[`Point3D_Array`](#manim.typing.Point3D_Array)
+```
+
+`shape: (4, 3)`
+
+A [`Point3D_Array`](#manim.typing.Point3D_Array) of four 3D control points for a single cubic Bézier curve:
+`[[float, float, float], [float, float, float], [float, float, float], [float, float, float]]`.
+
+### *class* CubicBezierPointsLike
+
+```default
+[`CubicBezierPoints`](#manim.typing.CubicBezierPoints) | tuple[[`Point3DLike`](#manim.typing.Point3DLike), [`Point3DLike`](#manim.typing.Point3DLike), [`Point3DLike`](#manim.typing.Point3DLike), [`Point3DLike`](#manim.typing.Point3DLike)]
+```
+
+`shape: (4, 3)`
+
+A [`Point3DLike_Array`](#manim.typing.Point3DLike_Array) of 4 control points for a single cubic Bézier curve:
+`[[float, float, float], [float, float, float], [float, float, float], [float, float, float]]`.
+
+This represents anything which can be converted to a :class:[`CubicBezierPoints`](#manim.typing.CubicBezierPoints)
+NumPy array.
+
+### *class* CubicBezierPoints_Array
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (N, 4, 3)`
+
+A NumPy array containing $N$ [`CubicBezierPoints`](#manim.typing.CubicBezierPoints) objects:
+`[[[float, float, float], [float, float, float], [float, float, float], [float, float, float]], ...]`.
+
+### *class* CubicBezierPointsLike_Array
+
+```default
+[`CubicBezierPoints_Array`](#manim.typing.CubicBezierPoints_Array) | Sequence[[`CubicBezierPointsLike`](#manim.typing.CubicBezierPointsLike)]
+```
+
+`shape: (N, 4, 3)`
+
+A sequence of $N$ [`CubicBezierPointsLike`](#manim.typing.CubicBezierPointsLike) objects:
+`[[[float, float, float], [float, float, float], [float, float, float], [float, float, float]], ...]`.
+
+This represents anything which can be converted to a
+:class:[`CubicBezierPoints_Array`](#manim.typing.CubicBezierPoints_Array) NumPy array.
+
+### *class* CubicBezierPath
+
+```default
+[`Point3D_Array`](#manim.typing.Point3D_Array)
+```
+
+`shape: (4*N, 3)`
+
+A [`Point3D_Array`](#manim.typing.Point3D_Array) of $4N$ points, where each one of the
+$N$ consecutive blocks of 4 points represents a cubic Bézier
+curve:
+`[[float, float, float], ...], ...]`.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* CubicBezierPathLike
+
+```default
+[`Point3DLike_Array`](#manim.typing.Point3DLike_Array)
+```
+
+`shape: (4*N, 3)`
+
+A [`Point3DLike_Array`](#manim.typing.Point3DLike_Array) of $4N$ points, where each one of the
+$N$ consecutive blocks of 4 points represents a cubic Bézier
+curve:
+`[[float, float, float], ...], ...]`.
+
+This represents anything which can be converted to a
+:class:[`CubicBezierPath`](#manim.typing.CubicBezierPath) NumPy array.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* CubicSpline
+
+```default
+[`CubicBezierPath`](#manim.typing.CubicBezierPath)
+```
+
+`shape: (4*N, 3)`
+
+A special case of [`CubicBezierPath`](#manim.typing.CubicBezierPath) where all the $N$ cubic
+Bézier curves are connected, forming a quadratic spline:
+`[[float, float, float], ...], ...]`.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* CubicSplineLike
+
+```default
+[`CubicBezierPathLike`](#manim.typing.CubicBezierPathLike)
+```
+
+`shape: (4*N, 3)`
+
+A special case of [`CubicBezierPath`](#manim.typing.CubicBezierPath) where all the $N$ cubic
+Bézier curves are connected, forming a quadratic spline:
+`[[float, float, float], ...], ...]`.
+
+This represents anything which can be converted to a
+:class:[`CubicSpline`](#manim.typing.CubicSpline) NumPy array.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* BezierPoints
+
+```default
+[`Point3D_Array`](#manim.typing.Point3D_Array)
+```
+
+`shape: (PPC, 3)`
+
+A [`Point3D_Array`](#manim.typing.Point3D_Array) of $\text{PPC}$ control points
+($\text{PPC: Points Per Curve} = n + 1$) for a single
+$n$-th degree Bézier curve:
+`[[float, float, float], ...]`.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* BezierPointsLike
+
+```default
+[`Point3DLike_Array`](#manim.typing.Point3DLike_Array)
+```
+
+`shape: (PPC, 3)`
+
+A [`Point3DLike_Array`](#manim.typing.Point3DLike_Array) of $\text{PPC}$ control points
+($\text{PPC: Points Per Curve} = n + 1$) for a single
+$n$-th degree Bézier curve:
+`[[float, float, float], ...]`.
+
+This represents anything which can be converted to a
+:class:[`BezierPoints`](#manim.typing.BezierPoints) NumPy array.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* BezierPoints_Array
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)]
+```
+
+`shape: (N, PPC, 3)`
+
+A NumPy array of $N$ [`BezierPoints`](#manim.typing.BezierPoints) objects containing
+$\text{PPC}$ [`Point3D`](#manim.typing.Point3D) objects each
+($\text{PPC: Points Per Curve} = n + 1$):
+`[[[float, float, float], ...], ...]`.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* BezierPointsLike_Array
+
+```default
+[`BezierPoints_Array`](#manim.typing.BezierPoints_Array) | Sequence[[`BezierPointsLike`](#manim.typing.BezierPointsLike)]
+```
+
+`shape: (N, PPC, 3)`
+
+A sequence of $N$ [`BezierPointsLike`](#manim.typing.BezierPointsLike) objects containing
+$\text{PPC}$ [`Point3DLike`](#manim.typing.Point3DLike) objects each
+($\text{PPC: Points Per Curve} = n + 1$):
+`[[[float, float, float], ...], ...]`.
+
+This represents anything which can be converted to a
+:class:[`BezierPoints_Array`](#manim.typing.BezierPoints_Array) NumPy array.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* BezierPath
+
+```default
+[`Point3D_Array`](#manim.typing.Point3D_Array)
+```
+
+`shape: (PPC*N, 3)`
+
+A [`Point3D_Array`](#manim.typing.Point3D_Array) of $\text{PPC} \cdot N$ points, where each
+one of the $N$ consecutive blocks of $\text{PPC}$ control
+points ($\text{PPC: Points Per Curve} = n + 1$) represents a
+Bézier curve of $n$-th degree:
+`[[float, float, float], ...], ...]`.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* BezierPathLike
+
+```default
+[`Point3DLike_Array`](#manim.typing.Point3DLike_Array)
+```
+
+`shape: (PPC*N, 3)`
+
+A [`Point3DLike_Array`](#manim.typing.Point3DLike_Array) of $\text{PPC} \cdot N$ points, where each
+one of the $N$ consecutive blocks of $\text{PPC}$ control
+points ($\text{PPC: Points Per Curve} = n + 1$) represents a
+Bézier curve of $n$-th degree:
+`[[float, float, float], ...], ...]`.
+
+This represents anything which can be converted to a
+:class:[`BezierPath`](#manim.typing.BezierPath) NumPy array.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* Spline
+
+```default
+[`BezierPath`](#manim.typing.BezierPath)
+```
+
+`shape: (PPC*N, 3)`
+
+A special case of [`BezierPath`](#manim.typing.BezierPath) where all the $N$ Bézier curves
+consisting of $\text{PPC}$ [`Point3D`](#manim.typing.Point3D) objects
+($\text{PPC: Points Per Curve} = n + 1$) are connected, forming
+an $n$-th degree spline:
+`[[float, float, float], ...], ...]`.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* SplineLike
+
+```default
+[`BezierPathLike`](#manim.typing.BezierPathLike)
+```
+
+`shape: (PPC*N, 3)`
+
+A special case of [`BezierPathLike`](#manim.typing.BezierPathLike) where all the $N$ Bézier curves
+consisting of $\text{PPC}$ [`Point3D`](#manim.typing.Point3D) objects
+($\text{PPC: Points Per Curve} = n + 1$) are connected, forming
+an $n$-th degree spline:
+`[[float, float, float], ...], ...]`.
+
+This represents anything which can be converted to a
+:class:[`Spline`](#manim.typing.Spline) NumPy array.
+
+Please refer to the documentation of the function you are using for
+further type information.
+
+### *class* FlatBezierPoints
+
+```default
+NDArray[[`PointDType`](#manim.typing.PointDType)] | tuple[float, ...]
+```
+
+`shape: (3*PPC*N,)`
+
+A flattened array of Bézier control points:
+`[float, ...]`.
+
+### Function types
+
+### *class* FunctionOverride
+
+```default
+Callable
+```
+
+Function type returning an [`Animation`](manim.animation.animation.Animation.md#manim.animation.animation.Animation) for the specified
+[`Mobject`](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject).
+
+### *class* PathFuncType
+
+```default
+Callable[[[`Point3DLike`](#manim.typing.Point3DLike), [`Point3DLike`](#manim.typing.Point3DLike), float], [`Point3DLike`](#manim.typing.Point3DLike)]
+```
+
+Function mapping two :class:[`Point3D`](#manim.typing.Point3D) objects and an alpha value to a new
+:class:[`Point3D`](#manim.typing.Point3D).
+
+### *class* MappingFunction
+
+```default
+Callable[[[`Point3D`](#manim.typing.Point3D)], [`Point3D`](#manim.typing.Point3D)]
+```
+
+A function mapping a :class:[`Point3D`](#manim.typing.Point3D) to another :class:[`Point3D`](#manim.typing.Point3D).
+
+### *class* MultiMappingFunction
+
+```default
+Callable[[[`Point3D_Array`](#manim.typing.Point3D_Array)], [`Point3D_Array`](#manim.typing.Point3D_Array)]
+```
+
+A function mapping a :class:[`Point3D_Array`](#manim.typing.Point3D_Array) to another
+:class:[`Point3D_Array`](#manim.typing.Point3D_Array).
+
+### Image types
+
+### *class* PixelArray
+
+```default
+NDArray[[`ManimInt`](#manim.typing.ManimInt)]
+```
+
+`shape: (height, width) | (height, width, 3) | (height, width, 4)`
+
+A rasterized image with a height of `height` pixels and a width of
+`width` pixels.
+
+Every value in the array is an integer from 0 to 255.
+
+Every pixel is represented either by a single integer indicating its
+lightness (for greyscale images), an [`RGB_Array_Int`](#manim.typing.RGB_Array_Int) or an
+[`RGBA_Array_Int`](#manim.typing.RGBA_Array_Int).
+
+### *class* GrayscalePixelArray
+
+```default
+[`PixelArray`](#manim.typing.PixelArray)
+```
+
+`shape: (height, width)`
+
+A 100% opaque grayscale [`PixelArray`](#manim.typing.PixelArray), where every pixel value is a
+[`ManimInt`](#manim.typing.ManimInt) indicating its lightness (black -> gray -> white).
+
+### *class* RGBPixelArray
+
+```default
+[`PixelArray`](#manim.typing.PixelArray)
+```
+
+`shape: (height, width, 3)`
+
+A 100% opaque [`PixelArray`](#manim.typing.PixelArray) in color, where every pixel value is an
+[`RGB_Array_Int`](#manim.typing.RGB_Array_Int) object.
+
+### *class* RGBAPixelArray
+
+```default
+[`PixelArray`](#manim.typing.PixelArray)
+```
+
+`shape: (height, width, 4)`
+
+A [`PixelArray`](#manim.typing.PixelArray) in color where pixels can be transparent. Every pixel
+value is an [`RGBA_Array_Int`](#manim.typing.RGBA_Array_Int) object.
+
+### Path types
+
+### *class* StrPath
+
+```default
+str | PathLike[str]
+```
+
+A string or `os.PathLike` representing a path to a
+directory or file.
+
+### *class* StrOrBytesPath
+
+```default
+str | bytes | PathLike[str] | PathLike[bytes]
+```
+
+A string, bytes or `os.PathLike` object representing a path
+to a directory or file.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.bezier.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.bezier.md
new file mode 100644
index 0000000000000000000000000000000000000000..17b0ac00ea20aa4792c86519df3a6e6cb9a8aed2
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.bezier.md
@@ -0,0 +1,1250 @@
+# bezier
+
+Utility functions related to Bézier curves.
+
+### Functions
+
+### bezier(points: [BezierPointsLike](manim.typing.md#manim.typing.BezierPointsLike)) → Callable[[float | [ColVector](manim.typing.md#manim.typing.ColVector)], [Point3D](manim.typing.md#manim.typing.Point3D) | [Point3D_Array](manim.typing.md#manim.typing.Point3D_Array)]
+
+### bezier(points: Sequence[[Point3DLike_Array](manim.typing.md#manim.typing.Point3DLike_Array)]) → Callable[[float | [ColVector](manim.typing.md#manim.typing.ColVector)], [Point3D_Array](manim.typing.md#manim.typing.Point3D_Array)]
+
+Classic implementation of a Bézier curve.
+
+* **Parameters:**
+ **points** – $(d+1, 3)$-shaped array of $d+1$ control points defining a single Bézier
+ curve of degree $d$. Alternatively, for vectorization purposes, `points` can
+ also be a $(d+1, M, 3)$-shaped sequence of $d+1$ arrays of $M$
+ control points each, which define M Bézier curves instead.
+* **Returns:**
+ **bezier_func** – Function describing the Bézier curve. The behaviour of this function depends on
+ the shape of `points`:
+ > * If `points` was a $(d+1, 3)$ array representing a single Bézier curve,
+ > then `bezier_func` can receive either:
+ > * a `float` `t`, in which case it returns a
+ > single $(1, 3)$-shaped [`Point3D`](manim.typing.md#manim.typing.Point3D) representing the evaluation
+ > of the Bézier at `t`, or
+ > * an $(n, 1)$-shaped [`ColVector`](manim.typing.md#manim.typing.ColVector)
+ > containing $n$ values to evaluate the Bézier curve at, returning instead
+ > an $(n, 3)$-shaped [`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array) containing the points
+ > resulting from evaluating the Bézier at each of the $n$ values.
+
+ > #### WARNING
+ > If passing a vector of $t$-values to `bezier_func`, it **must**
+ > be a column vector/matrix of shape $(n, 1)$. Passing an 1D array of
+ > shape $(n,)$ is not supported and **will result in undefined behaviour**.
+ > * If `points` was a $(d+1, M, 3)$ array describing $M$ Bézier curves,
+ > then `bezier_func` can receive either:
+ > * a `float` `t`, in which case it returns an
+ > $(M, 3)$-shaped [`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array) representing the evaluation
+ > of the $M$ Bézier curves at the same value `t`, or
+ > * an $(M, 1)$-shaped
+ > [`ColVector`](manim.typing.md#manim.typing.ColVector) containing $M$ values, such that the $i$-th
+ > Bézier curve defined by `points` is evaluated at the corresponding $i$-th
+ > value in `t`, returning again an $(M, 3)$-shaped [`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array)
+ > containing those $M$ evaluations.
+
+ > #### WARNING
+ > Unlike the previous case, if you pass a [`ColVector`](manim.typing.md#manim.typing.ColVector) to `bezier_func`,
+ > it **must** contain exactly $M$ values, each value for each of the $M$
+ > Bézier curves defined by `points`. Any array of shape other than $(M, 1)$
+ > **will result in undefined behaviour**.
+* **Return type:**
+ `typing.Callable` [[`float` | [`ColVector`](manim.typing.md#manim.typing.ColVector)], [`Point3D`](manim.typing.md#manim.typing.Point3D) | [`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array)]
+
+### bezier_remap(bezier_tuples, new_number_of_curves)
+
+Subdivides each curve in `bezier_tuples` into as many parts as necessary, until the final number of
+curves reaches a desired amount, `new_number_of_curves`.
+
+* **Parameters:**
+ * **bezier_tuples** ([*BezierPointsLike_Array*](manim.typing.md#manim.typing.BezierPointsLike_Array)) –
+
+ An array of multiple Bézier curves of degree $d$ to be remapped. The shape of this array
+ must be `(current_number_of_curves, nppc, dim)`, where:
+ * `current_number_of_curves` is the current amount of curves in the array `bezier_tuples`,
+ * `nppc` is the amount of points per curve, such that their degree is `nppc-1`, and
+ * `dim` is the dimension of the points, usually $3$.
+ * **new_number_of_curves** (*int*) – The number of curves that the output will contain. This needs to be higher than the current number.
+* **Returns:**
+ The new array of shape `(new_number_of_curves, nppc, dim)`,
+ containing the new Bézier curves after the remap.
+* **Return type:**
+ [`BezierPoints_Array`](manim.typing.md#manim.typing.BezierPoints_Array)
+
+### get_quadratic_approximation_of_cubic(a0: [Point3DLike](manim.typing.md#manim.typing.Point3DLike), h0: [Point3DLike](manim.typing.md#manim.typing.Point3DLike), h1: [Point3DLike](manim.typing.md#manim.typing.Point3DLike), a1: [Point3DLike](manim.typing.md#manim.typing.Point3DLike)) → [QuadraticSpline](manim.typing.md#manim.typing.QuadraticSpline)
+
+### get_quadratic_approximation_of_cubic(a0: [Point3DLike_Array](manim.typing.md#manim.typing.Point3DLike_Array), h0: [Point3DLike_Array](manim.typing.md#manim.typing.Point3DLike_Array), h1: [Point3DLike_Array](manim.typing.md#manim.typing.Point3DLike_Array), a1: [Point3DLike_Array](manim.typing.md#manim.typing.Point3DLike_Array)) → [QuadraticBezierPath](manim.typing.md#manim.typing.QuadraticBezierPath)
+
+If `a0`, `h0`, `h1` and `a1` are the control points of a cubic
+Bézier curve, approximate the curve with two quadratic Bézier curves and
+return an array of 6 points, where the first 3 points represent the first
+quadratic curve and the last 3 represent the second one.
+
+Otherwise, if `a0`, `h0`, `h1` and `a1` are \_arrays_ of $N$
+points representing $N$ cubic Bézier curves, return an array of
+$6N$ points where each group of $6$ consecutive points
+approximates each of the $N$ curves in a similar way as above.
+
+#### NOTE
+If the cubic spline given by the original cubic Bézier curves is
+smooth, this algorithm will generate a quadratic spline which is also
+smooth.
+
+If a cubic Bézier is given by
+
+$$
+C(t) = (1-t)^3 A_0 + 3(1-t)^2 t H_0 + 3(1-t)t^2 H_1 + t^3 A_1
+
+$$
+
+where $A_0$, $H_0$, $H_1$ and $A_1$ are its
+control points, then this algorithm should generate two quadratic
+Béziers given by
+
+$$
+Q_0(t) &= (1-t)^2 A_0 + 2(1-t)t M_0 + t^2 K \\
+Q_1(t) &= (1-t)^2 K + 2(1-t)t M_1 + t^2 A_1
+
+$$
+
+where $M_0$ and $M_1$ are the respective handles to be
+found for both curves, and $K$ is the end anchor of the 1st curve
+and the start anchor of the 2nd, which must also be found.
+
+To solve for $M_0$, $M_1$ and $K$, three conditions
+can be imposed:
+
+1. $Q_0'(0) = \frac{1}{2}C'(0)$. The derivative of the first
+ quadratic curve at $t = 0$ should be proportional to that of
+ the original cubic curve, also at $t = 0$. Because the cubic
+ curve is split into two parts, it is necessary to divide this by
+ two: the speed of a point travelling through the curve should be
+ half of the original. This gives:
+ $$
+ Q_0'(0) &= \frac{1}{2}C'(0) \\
+ 2(M_0 - A_0) &= \frac{3}{2}(H_0 - A_0) \\
+ 2M_0 - 2A_0 &= \frac{3}{2}H_0 - \frac{3}{2}A_0 \\
+ 2M_0 &= \frac{3}{2}H_0 + \frac{1}{2}A_0 \\
+ M_0 &= \frac{1}{4}(3H_0 + A_0)
+
+ $$
+2. $Q_1'(1) = \frac{1}{2}C'(1)$. The derivative of the second
+ quadratic curve at $t = 1$ should be half of that of the
+ original cubic curve for the same reasons as above, also at
+ $t = 1$. This gives:
+ $$
+ Q_1'(1) &= \frac{1}{2}C'(1) \\
+ 2(A_1 - M_1) &= \frac{3}{2}(A_1 - H_1) \\
+ 2A_1 - 2M_1 &= \frac{3}{2}A_1 - \frac{3}{2}H_1 \\
+ -2M_1 &= -\frac{1}{2}A_1 - \frac{3}{2}H_1 \\
+ M_1 &= \frac{1}{4}(3H_1 + A_1)
+
+ $$
+3. $Q_0'(1) = Q_1'(0)$. The derivatives of both quadratic curves
+ should match at the point $K$, in order for the final spline
+ to be smooth. This gives:
+ $$
+ Q_0'(1) &= Q_1'(0) \\
+ 2(K - M_0) &= 2(M_1 - K) \\
+ 2K - 2M_0 &= 2M_1 - 2K \\
+ 4K &= 2M_0 + 2M_1 \\
+ K &= \frac{1}{2}(M_0 + M_1)
+
+ $$
+
+This is sufficient to find proper control points for the quadratic
+Bézier curves.
+
+* **Parameters:**
+ * **a0** – The start anchor of a single cubic Bézier curve, or an array of
+ $N$ start anchors for $N$ curves.
+ * **h0** – The first handle of a single cubic Bézier curve, or an array of
+ $N$ first handles for $N$ curves.
+ * **h1** – The second handle of a single cubic Bézier curve, or an array of
+ $N$ second handles for $N$ curves.
+ * **a1** – The end anchor of a single cubic Bézier curve, or an array of
+ $N$ end anchors for $N$ curves.
+* **Returns:**
+ An array containing either 6 points for 2 quadratic Bézier curves
+ approximating the original cubic curve, or $6N$ points for
+ $2N$ quadratic curves approximating $N$ cubic curves.
+* **Return type:**
+ result
+* **Raises:**
+ **ValueError** – If `a0`, `h0`, `h1` and `a1` have different dimensions, or
+ if their number of dimensions is not 1 or 2.
+
+### get_smooth_closed_cubic_bezier_handle_points(anchors)
+
+Special case of [`get_smooth_cubic_bezier_handle_points()`](#manim.utils.bezier.get_smooth_cubic_bezier_handle_points),
+when the `anchors` form a closed loop.
+
+#### NOTE
+A system of equations must be solved to get the first handles of
+every Bézier curve (referred to as $H_1$).
+Then $H_2$ (the second handles) can be obtained separately.
+
+#### SEE ALSO
+The equations were obtained from:
+
+* [Conditions on control points for continuous curvature. (2016). Jaco Stuifbergen.](http://www.jacos.nl/jacos_html/spline/theory/theory_2.html)
+
+In general, if there are $N+1$ anchors, there will be $N$ Bézier curves
+and thus $N$ pairs of handles to find. We must solve the following
+system of equations for the 1st handles (example for $N = 5$):
+
+$$
+\begin{pmatrix}
+ 4 & 1 & 0 & 0 & 1 \\
+ 1 & 4 & 1 & 0 & 0 \\
+ 0 & 1 & 4 & 1 & 0 \\
+ 0 & 0 & 1 & 4 & 1 \\
+ 1 & 0 & 0 & 1 & 4
+\end{pmatrix}
+\begin{pmatrix}
+ H_{1,0} \\
+ H_{1,1} \\
+ H_{1,2} \\
+ H_{1,3} \\
+ H_{1,4}
+\end{pmatrix}
+=
+\begin{pmatrix}
+ 4A_0 + 2A_1 \\
+ 4A_1 + 2A_2 \\
+ 4A_2 + 2A_3 \\
+ 4A_3 + 2A_4 \\
+ 4A_4 + 2A_5
+\end{pmatrix}
+
+$$
+
+which will be expressed as $RH_1 = D$.
+
+$R$ is almost a tridiagonal matrix, so we could use Thomas’ algorithm.
+
+#### SEE ALSO
+[Tridiagonal matrix algorithm. Wikipedia.](https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm)
+
+However, $R$ has ones at the opposite corners. A solution to this is
+the first decomposition proposed in the link below, with $\alpha = 1$:
+
+#### SEE ALSO
+[Tridiagonal matrix algorithm # Variants. Wikipedia.](https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm#Variants)
+
+$$
+R
+=
+\begin{pmatrix}
+ 4 & 1 & 0 & 0 & 1 \\
+ 1 & 4 & 1 & 0 & 0 \\
+ 0 & 1 & 4 & 1 & 0 \\
+ 0 & 0 & 1 & 4 & 1 \\
+ 1 & 0 & 0 & 1 & 4
+\end{pmatrix}
+&=
+\begin{pmatrix}
+ 3 & 1 & 0 & 0 & 0 \\
+ 1 & 4 & 1 & 0 & 0 \\
+ 0 & 1 & 4 & 1 & 0 \\
+ 0 & 0 & 1 & 4 & 1 \\
+ 0 & 0 & 0 & 1 & 3
+\end{pmatrix}
++
+\begin{pmatrix}
+ 1 & 0 & 0 & 0 & 1 \\
+ 0 & 0 & 0 & 0 & 0 \\
+ 0 & 0 & 0 & 0 & 0 \\
+ 0 & 0 & 0 & 0 & 0 \\
+ 1 & 0 & 0 & 0 & 1
+\end{pmatrix}
+\\
+&
+\\
+&=
+\begin{pmatrix}
+ 3 & 1 & 0 & 0 & 0 \\
+ 1 & 4 & 1 & 0 & 0 \\
+ 0 & 1 & 4 & 1 & 0 \\
+ 0 & 0 & 1 & 4 & 1 \\
+ 0 & 0 & 0 & 1 & 3
+\end{pmatrix}
++
+\begin{pmatrix}
+ 1 \\
+ 0 \\
+ 0 \\
+ 0 \\
+ 1
+\end{pmatrix}
+\begin{pmatrix}
+ 1 & 0 & 0 & 0 & 1
+\end{pmatrix}
+\\
+&
+\\
+&=
+T + uv^t
+
+$$
+
+We decompose $R = T + uv^t$, where $T$ is a tridiagonal matrix, and
+$u, v$ are $N$-D vectors such that $u_0 = u_{N-1} = v_0 = v_{N-1} = 1$,
+and $u_i = v_i = 0, \forall i \in \{1, ..., N-2\}$.
+
+Thus:
+
+$$
+RH_1 &= D \\
+\Rightarrow (T + uv^t)H_1 &= D
+
+$$
+
+If we find a vector $q$ such that $Tq = u$:
+
+$$
+\Rightarrow (T + Tqv^t)H_1 &= D \\
+\Rightarrow T(I + qv^t)H_1 &= D \\
+\Rightarrow H_1 &= (I + qv^t)^{-1} T^{-1} D
+
+$$
+
+According to Sherman-Morrison’s formula:
+
+#### SEE ALSO
+[Sherman-Morrison’s formula. Wikipedia.](https://en.wikipedia.org/wiki/Sherman%E2%80%93Morrison_formula)
+
+$$
+(I + qv^t)^{-1} = I - \frac{1}{1 + v^tq} qv^t
+
+$$
+
+If we find $Y = T^{-1} D$, or in other words, if we solve for
+$Y$ in $TY = D$:
+
+$$
+H_1 &= (I + qv^t)^{-1} T^{-1} D \\
+&= (I + qv^t)^{-1} Y \\
+&= (I - \frac{1}{1 + v^tq} qv^t) Y \\
+&= Y - \frac{1}{1 + v^tq} qv^tY
+
+$$
+
+Therefore, we must solve for $q$ and $Y$ in $Tq = u$ and $TY = D$.
+As $T$ is now tridiagonal, we shall use Thomas’ algorithm.
+
+Define:
+
+* $a = [a_0, \ a_1, \ ..., \ a_{N-2}]$ as $T$’s lower diagonal of $N-1$ elements,
+ such that $a_0 = a_1 = ... = a_{N-2} = 1$, so this diagonal is filled with ones;
+* $b = [b_0, \ b_1, \ ..., \ b_{N-2}, \ b_{N-1}]$ as $T$’s main diagonal of $N$ elements,
+ such that $b_0 = b_{N-1} = 3$, and $b_1 = b_2 = ... = b_{N-2} = 4$;
+* $c = [c_0, \ c_1, \ ..., \ c_{N-2}]$ as $T$’s upper diagonal of $N-1$ elements,
+ such that $c_0 = c_1 = ... = c_{N-2} = 1$: this diagonal is also filled with ones.
+
+If, according to Thomas’ algorithm, we define:
+
+$$
+c'_0 &= \frac{c_0}{b_0} & \\
+c'_i &= \frac{c_i}{b_i - a_{i-1} c'_{i-1}}, & \quad \forall i \in \{1, ..., N-2\} \\
+& & \\
+u'_0 &= \frac{u_0}{b_0} & \\
+u'_i &= \frac{u_i - a_{i-1} u'_{i-1}}{b_i - a_{i-1} c'_{i-1}}, & \quad \forall i \in \{1, ..., N-1\} \\
+& & \\
+D'_0 &= \frac{1}{b_0} D_0 & \\
+D'_i &= \frac{1}{b_i - a_{i-1} c'_{i-1}} (D_i - a_{i-1} D'_{i-1}), & \quad \forall i \in \{1, ..., N-1\}
+
+$$
+
+Then:
+
+$$
+c'_0 &= \frac{1}{3} & \\
+c'_i &= \frac{1}{4 - c'_{i-1}}, & \quad \forall i \in \{1, ..., N-2\} \\
+& & \\
+u'_0 &= \frac{1}{3} & \\
+u'_i &= \frac{-u'_{i-1}}{4 - c'_{i-1}} = -c'_i u'_{i-1}, & \quad \forall i \in \{1, ..., N-2\} \\
+u'_{N-1} &= \frac{1 - u'_{N-2}}{3 - c'_{N-2}} & \\
+& & \\
+D'_0 &= \frac{1}{3} (4A_0 + 2A_1) & \\
+D'_i &= \frac{1}{4 - c'_{i-1}} (4A_i + 2A_{i+1} - D'_{i-1}) & \\
+&= c_i (4A_i + 2A_{i+1} - D'_{i-1}), & \quad \forall i \in \{1, ..., N-2\} \\
+D'_{N-1} &= \frac{1}{3 - c'_{N-2}} (4A_{N-1} + 2A_N - D'_{N-2}) &
+
+$$
+
+Finally, we can do Backward Substitution to find $q$ and $Y$:
+
+$$
+q_{N-1} &= u'_{N-1} & \\
+q_i &= u'_{i} - c'_i q_{i+1}, & \quad \forall i \in \{0, ..., N-2\} \\
+& & \\
+Y_{N-1} &= D'_{N-1} & \\
+Y_i &= D'_i - c'_i Y_{i+1}, & \quad \forall i \in \{0, ..., N-2\}
+
+$$
+
+With those values, we can finally calculate $H_1 = Y - \frac{1}{1 + v^tq} qv^tY$.
+Given that $v_0 = v_{N-1} = 1$, and $v_1 = v_2 = ... = v_{N-2} = 0$, its dot products
+with $q$ and $Y$ are respectively $v^tq = q_0 + q_{N-1}$ and
+$v^tY = Y_0 + Y_{N-1}$. Thus:
+
+$$
+H_1 = Y - \frac{1}{1 + q_0 + q_{N-1}} q(Y_0 + Y_{N-1})
+
+$$
+
+Once we have $H_1$, we can get $H_2$ (the array of second handles) as follows:
+
+$$
+H_{2, i} &= 2A_{i+1} - H_{1, i+1}, & \quad \forall i \in \{0, ..., N-2\} \\
+H_{2, N-1} &= 2A_0 - H_{1, 0} &
+
+$$
+
+Because the matrix $R$ always follows the same pattern (and thus $T, u, v$ as well),
+we can define a memo list for $c'$ and $u'$ to avoid recalculation. We cannot
+memoize $D$ and $Y$, however, because they are always different matrices. We
+cannot make a memo for $q$ either, but we can calculate it faster because $u'$
+can be memoized.
+
+* **Parameters:**
+ **anchors** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array)) – Anchors of a closed cubic spline.
+* **Returns:**
+ A tuple of two arrays: one containing the 1st handle for every curve in
+ the closed cubic spline, and the other containing the 2nd handles.
+* **Return type:**
+ `tuple` [[`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array), [`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array)]
+
+### get_smooth_cubic_bezier_handle_points(anchors)
+
+Given an array of anchors for a cubic spline (array of connected cubic
+Bézier curves), compute the 1st and 2nd handle for every curve, so that
+the resulting spline is smooth.
+
+* **Parameters:**
+ **anchors** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array)) – Anchors of a cubic spline.
+* **Returns:**
+ A tuple of two arrays: one containing the 1st handle for every curve in
+ the cubic spline, and the other containing the 2nd handles.
+* **Return type:**
+ `tuple` [[`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array), [`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array)]
+
+### get_smooth_open_cubic_bezier_handle_points(anchors)
+
+Special case of [`get_smooth_cubic_bezier_handle_points()`](#manim.utils.bezier.get_smooth_cubic_bezier_handle_points),
+when the `anchors` do not form a closed loop.
+
+#### NOTE
+A system of equations must be solved to get the first handles of
+every Bèzier curve (referred to as $H_1$).
+Then $H_2$ (the second handles) can be obtained separately.
+
+#### SEE ALSO
+The equations were obtained from:
+
+* [Smooth Bézier Spline Through Prescribed Points. (2012). Particle in Cell Consulting LLC.](https://www.particleincell.com/2012/bezier-splines/)
+* [Conditions on control points for continuous curvature. (2016). Jaco Stuifbergen.](http://www.jacos.nl/jacos_html/spline/theory/theory_2.html)
+
+#### WARNING
+The equations in the first webpage have some typos which were corrected in the comments.
+
+In general, if there are $N+1$ anchors, there will be $N$ Bézier curves
+and thus $N$ pairs of handles to find. We must solve the following
+system of equations for the 1st handles (example for $N = 5$):
+
+$$
+\begin{pmatrix}
+ 2 & 1 & 0 & 0 & 0 \\
+ 1 & 4 & 1 & 0 & 0 \\
+ 0 & 1 & 4 & 1 & 0 \\
+ 0 & 0 & 1 & 4 & 1 \\
+ 0 & 0 & 0 & 2 & 7
+\end{pmatrix}
+\begin{pmatrix}
+ H_{1,0} \\
+ H_{1,1} \\
+ H_{1,2} \\
+ H_{1,3} \\
+ H_{1,4}
+\end{pmatrix}
+=
+\begin{pmatrix}
+ A_0 + 2A_1 \\
+ 4A_1 + 2A_2 \\
+ 4A_2 + 2A_3 \\
+ 4A_3 + 2A_4 \\
+ 8A_4 + A_5
+\end{pmatrix}
+
+$$
+
+which will be expressed as $TH_1 = D$.
+$T$ is a tridiagonal matrix, so the system can be solved in $O(N)$
+operations. Here we shall use Thomas’ algorithm or the tridiagonal matrix
+algorithm.
+
+#### SEE ALSO
+[Tridiagonal matrix algorithm. Wikipedia.](https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm)
+
+Define:
+
+* $a = [a_0, \ a_1, \ ..., \ a_{N-2}]$ as $T$’s lower diagonal of $N-1$ elements,
+ such that $a_0 = a_1 = ... = a_{N-3} = 1$, and $a_{N-2} = 2$;
+* $b = [b_0, \ b_1, \ ..., \ b_{N-2}, \ b_{N-1}]$ as $T$’s main diagonal of $N$ elements,
+ such that $b_0 = 2$, $b_1 = b_2 = ... = b_{N-2} = 4$, and $b_{N-1} = 7$;
+* $c = [c_0, \ c_1, \ ..., \ c_{N-2}]$ as $T$’s upper diagonal of ${N-1}$ elements,
+ such that $c_0 = c_1 = ... = c_{N-2} = 1$: this diagonal is filled with ones.
+
+If, according to Thomas’ algorithm, we define:
+
+$$
+c'_0 &= \frac{c_0}{b_0} & \\
+c'_i &= \frac{c_i}{b_i - a_{i-1} c'_{i-1}}, & \quad \forall i \in \{1, ..., N-2\} \\
+& & \\
+D'_0 &= \frac{1}{b_0} D_0 & \\
+D'_i &= \frac{1}{b_i - a_{i-1} c'{i-1}} (D_i - a_{i-1} D'_{i-1}), & \quad \forall i \in \{1, ..., N-1\}
+
+$$
+
+Then:
+
+$$
+c'_0 &= 0.5 & \\
+c'_i &= \frac{1}{4 - c'_{i-1}}, & \quad \forall i \in \{1, ..., N-2\} \\
+& & \\
+D'_0 &= 0.5A_0 + A_1 & \\
+D'_i &= \frac{1}{4 - c'_{i-1}} (4A_i + 2A_{i+1} - D'_{i-1}) & \\
+&= c_i (4A_i + 2A_{i+1} - D'_{i-1}), & \quad \forall i \in \{1, ..., N-2\} \\
+D'_{N-1} &= \frac{1}{7 - 2c'_{N-2}} (8A_{N-1} + A_N - 2D'_{N-2}) &
+
+$$
+
+Finally, we can do Backward Substitution to find $H_1$:
+
+$$
+H_{1, N-1} &= D'_{N-1} & \\
+H_{1, i} &= D'_i - c'_i H_{1, i+1}, & \quad \forall i \in \{0, ..., N-2\}
+
+$$
+
+Once we have $H_1$, we can get $H_2$ (the array of second handles) as follows:
+
+$$
+H_{2, i} &= 2A_{i+1} - H_{1, i+1}, & \quad \forall i \in \{0, ..., N-2\} \\
+H_{2, N-1} &= 0.5A_N + 0.5H_{1, N-1} &
+
+$$
+
+As the matrix $T$ always follows the same pattern, we can define a memo list
+for $c'$ to avoid recalculation. We cannot do the same for $D$, however,
+because it is always a different matrix.
+
+* **Parameters:**
+ **anchors** ([*Point3DLike_Array*](manim.typing.md#manim.typing.Point3DLike_Array)) – Anchors of an open cubic spline.
+* **Returns:**
+ A tuple of two arrays: one containing the 1st handle for every curve in
+ the open cubic spline, and the other containing the 2nd handles.
+* **Return type:**
+ `tuple` [[`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array), [`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array)]
+
+### integer_interpolate(start, end, alpha)
+
+This is a variant of interpolate that returns an integer and the residual
+
+* **Parameters:**
+ * **start** (*float*) – The start of the range
+ * **end** (*float*) – The end of the range
+ * **alpha** (*float*) – a float between 0 and 1.
+* **Returns:**
+ This returns an integer between start and end (inclusive) representing
+ appropriate interpolation between them, along with a
+ “residue” representing a new proportion between the
+ returned integer and the next one of the
+ list.
+* **Return type:**
+ tuple[int, float]
+
+### Example
+
+```pycon
+>>> integer, residue = integer_interpolate(start=0, end=10, alpha=0.46)
+>>> np.allclose((integer, residue), (4, 0.6))
+True
+```
+
+### interpolate(start: float, end: float, alpha: float) → float
+
+### interpolate(start: float, end: float, alpha: [ColVector](manim.typing.md#manim.typing.ColVector)) → [ColVector](manim.typing.md#manim.typing.ColVector)
+
+### interpolate(start: [Point3D](manim.typing.md#manim.typing.Point3D), end: [Point3D](manim.typing.md#manim.typing.Point3D), alpha: float) → [Point3D](manim.typing.md#manim.typing.Point3D)
+
+### interpolate(start: [Point3D](manim.typing.md#manim.typing.Point3D), end: [Point3D](manim.typing.md#manim.typing.Point3D), alpha: [ColVector](manim.typing.md#manim.typing.ColVector)) → [Point3D_Array](manim.typing.md#manim.typing.Point3D_Array)
+
+Linearly interpolates between two values `start` and `end`.
+
+* **Parameters:**
+ * **start** – The start of the range.
+ * **end** – The end of the range.
+ * **alpha** – A float between 0 and 1, or an $(n, 1)$ column vector containing
+ $n$ floats between 0 and 1 to interpolate in a vectorized fashion.
+* **Returns:**
+ The result of the linear interpolation.
+ * If `start` and `end` are of type `float`, and:
+ * `alpha` is also a `float`, the return is simply another `float`.
+ * `alpha` is a [`ColVector`](manim.typing.md#manim.typing.ColVector), the return is another [`ColVector`](manim.typing.md#manim.typing.ColVector).
+ * If `start` and `end` are of type [`Point3D`](manim.typing.md#manim.typing.Point3D), and:
+ * `alpha` is a `float`, the return is another [`Point3D`](manim.typing.md#manim.typing.Point3D).
+ * `alpha` is a [`ColVector`](manim.typing.md#manim.typing.ColVector), the return is a [`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array).
+* **Return type:**
+ `float` | [`ColVector`](manim.typing.md#manim.typing.ColVector) | [`Point3D`](manim.typing.md#manim.typing.Point3D) | [`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array)
+
+### inverse_interpolate(start: float, end: float, value: float) → float
+
+### inverse_interpolate(start: float, end: float, value: [Point3D](manim.typing.md#manim.typing.Point3D)) → [Point3D](manim.typing.md#manim.typing.Point3D)
+
+### inverse_interpolate(start: [Point3D](manim.typing.md#manim.typing.Point3D), end: [Point3D](manim.typing.md#manim.typing.Point3D), value: [Point3D](manim.typing.md#manim.typing.Point3D)) → [Point3D](manim.typing.md#manim.typing.Point3D)
+
+Perform inverse interpolation to determine the alpha
+values that would produce the specified `value`
+given the `start` and `end` values or points.
+
+* **Parameters:**
+ * **start** – The start value or point of the interpolation.
+ * **end** – The end value or point of the interpolation.
+ * **value** – The value or point for which the alpha value
+ should be determined.
+* **Returns:**
+ * *The alpha values producing the given input*
+ * when interpolating between `start` and `end`.
+
+### Example
+
+```pycon
+>>> inverse_interpolate(start=2, end=6, value=4)
+np.float64(0.5)
+
+>>> start = np.array([1, 2, 1])
+>>> end = np.array([7, 8, 11])
+>>> value = np.array([4, 5, 5])
+>>> inverse_interpolate(start, end, value)
+array([0.5, 0.5, 0.4])
+```
+
+### is_closed(points)
+
+Returns `True` if the spline given by `points` is closed, by
+checking if its first and last points are close to each other, or\`\`False\`\`
+otherwise.
+
+#### NOTE
+This function reimplements `np.allclose()`, because repeated
+calling of `np.allclose()` for only 2 points is inefficient.
+
+* **Parameters:**
+ **points** ([*Point3D_Array*](manim.typing.md#manim.typing.Point3D_Array)) – An array of points defining a spline.
+* **Returns:**
+ Whether the first and last points of the array are close enough or not
+ to be considered the same, thus considering the defined spline as
+ closed.
+* **Return type:**
+ `bool`
+
+### Examples
+
+```pycon
+>>> import numpy as np
+>>> from manim import is_closed
+>>> is_closed(
+... np.array(
+... [
+... [0, 0, 0],
+... [1, 2, 3],
+... [3, 2, 1],
+... [0, 0, 0],
+... ]
+... )
+... )
+True
+>>> is_closed(
+... np.array(
+... [
+... [0, 0, 0],
+... [1, 2, 3],
+... [3, 2, 1],
+... [1e-10, 1e-10, 1e-10],
+... ]
+... )
+... )
+True
+>>> is_closed(
+... np.array(
+... [
+... [0, 0, 0],
+... [1, 2, 3],
+... [3, 2, 1],
+... [1e-2, 1e-2, 1e-2],
+... ]
+... )
+... )
+False
+```
+
+### match_interpolate(new_start: float, new_end: float, old_start: float, old_end: float, old_value: float) → float
+
+### match_interpolate(new_start: float, new_end: float, old_start: float, old_end: float, old_value: [Point3D](manim.typing.md#manim.typing.Point3D)) → [Point3D](manim.typing.md#manim.typing.Point3D)
+
+Interpolate a value from an old range to a new range.
+
+* **Parameters:**
+ * **new_start** – The start of the new range.
+ * **new_end** – The end of the new range.
+ * **old_start** – The start of the old range.
+ * **old_end** – The end of the old range.
+ * **old_value** – The value within the old range whose corresponding
+ value in the new range (with the same alpha value)
+ is desired.
+* **Return type:**
+ The interpolated value within the new range.
+
+### Examples
+
+```pycon
+>>> match_interpolate(0, 100, 10, 20, 15)
+np.float64(50.0)
+```
+
+### mid(start: float, end: float) → float
+
+### mid(start: [Point3D](manim.typing.md#manim.typing.Point3D), end: [Point3D](manim.typing.md#manim.typing.Point3D)) → [Point3D](manim.typing.md#manim.typing.Point3D)
+
+Returns the midpoint between two values.
+
+* **Parameters:**
+ * **start** – The first value
+ * **end** – The second value
+* **Return type:**
+ The midpoint between the two values
+
+### partial_bezier_points(points, a, b)
+
+Given an array of `points` which define a Bézier curve, and two numbers $a, b$
+such that $0 \le a < b \le 1$, return an array of the same size, which describes the
+portion of the original Bézier curve on the interval $[a, b]$.
+
+[`partial_bezier_points()`](#manim.utils.bezier.partial_bezier_points) is conceptually equivalent to calling [`split_bezier()`](#manim.utils.bezier.split_bezier)
+twice and discarding unused Bézier curves, but this is more efficient and doesn’t waste
+computations.
+
+#### SEE ALSO
+See [`split_bezier()`](#manim.utils.bezier.split_bezier) for an explanation on how to split Bézier curves.
+
+#### NOTE
+To find the portion of a Bézier curve with $t$ between $a$ and $b$:
+
+1. Split the curve at $t = a$ and extract its 2nd subcurve.
+2. We cannot evaluate the new subcurve at $t = b$ because its range of values for $t$ is different.
+ To find the correct value, we need to transform the interval $[a, 1]$ into $[0, 1]$
+ by first subtracting $a$ to get $[0, 1-a]$ and then dividing by $1-a$. Thus, our new
+ value must be $t = \frac{b - a}{1 - a}$. Define $u = \frac{b - a}{1 - a}$.
+3. Split the subcurve at $t = u$ and extract its 1st subcurve.
+
+The final portion is a linear combination of points, and thus the process can be
+summarized as a linear transformation by some matrix in terms of $a$ and $b$.
+This matrix is given explicitly for Bézier curves up to degree 3, which are often used in Manim.
+For higher degrees, the algorithm described previously is used.
+
+For the case of a quadratic Bézier curve:
+
+* Step 1:
+
+$$
+H'_1
+=
+\begin{pmatrix}
+ (1-a)^2 & 2(1-a)a & a^2 \\
+ 0 & (1-a) & a \\
+ 0 & 0 & 1
+\end{pmatrix}
+\begin{pmatrix}
+ p_0 \\
+ p_1 \\
+ p_2
+\end{pmatrix}
+
+$$
+
+* Step 2:
+
+$$
+H''_0
+&=
+\begin{pmatrix}
+ 1 & 0 & 0 \\
+ (1-u) & u & 0\\
+ (1-u)^2 & 2(1-u)u & u^2
+\end{pmatrix}
+H'_1
+\\
+&
+\\
+&=
+\begin{pmatrix}
+ 1 & 0 & 0 \\
+ (1-u) & u & 0\\
+ (1-u)^2 & 2(1-u)u & u^2
+\end{pmatrix}
+\begin{pmatrix}
+ (1-a)^2 & 2(1-a)a & a^2 \\
+ 0 & (1-a) & a \\
+ 0 & 0 & 1
+\end{pmatrix}
+\begin{pmatrix}
+ p_0 \\
+ p_1 \\
+ p_2
+\end{pmatrix}
+\\
+&
+\\
+&=
+\begin{pmatrix}
+ (1-a)^2 & 2(1-a)a & a^2 \\
+ (1-a)(1-b) & a(1-b) + (1-a)b & ab \\
+ (1-b)^2 & 2(1-b)b & b^2
+\end{pmatrix}
+\begin{pmatrix}
+ p_0 \\
+ p_1 \\
+ p_2
+\end{pmatrix}
+
+$$
+
+from where one can define a $(3, 3)$ matrix $P_2$ which, when applied over
+the array of `points`, will return the desired partial quadratic Bézier curve:
+
+$$
+P_2
+=
+\begin{pmatrix}
+ (1-a)^2 & 2(1-a)a & a^2 \\
+ (1-a)(1-b) & a(1-b) + (1-a)b & ab \\
+ (1-b)^2 & 2(1-b)b & b^2
+\end{pmatrix}
+
+$$
+
+Similarly, for the cubic Bézier curve case, one can define the following
+$(4, 4)$ matrix $P_3$:
+
+$$
+P_3
+=
+\begin{pmatrix}
+ (1-a)^3 & 3(1-a)^2a & 3(1-a)a^2 & a^3 \\
+ (1-a)^2(1-b) & 2(1-a)a(1-b) + (1-a)^2b & a^2(1-b) + 2(1-a)ab & a^2b \\
+ (1-a)(1-b)^2 & a(1-b)^2 + 2(1-a)(1-b)b & 2a(1-b)b + (1-a)b^2 & ab^2 \\
+ (1-b)^3 & 3(1-b)^2b & 3(1-b)b^2 & b^3
+\end{pmatrix}
+
+$$
+
+* **Parameters:**
+ * **points** ([*BezierPointsLike*](manim.typing.md#manim.typing.BezierPointsLike)) – set of points defining the bezier curve.
+ * **a** (*float*) – lower bound of the desired partial bezier curve.
+ * **b** (*float*) – upper bound of the desired partial bezier curve.
+* **Returns:**
+ An array containing the control points defining the partial Bézier curve.
+* **Return type:**
+ [`BezierPoints`](manim.typing.md#manim.typing.BezierPoints)
+
+### point_lies_on_bezier(point, control_points, round_to=1e-06)
+
+Checks if a given point lies on the bezier curves with the given control points.
+
+This is done by solving the bezier polynomial with the point as the constant term; if
+any real roots exist, the point lies on the bezier curve.
+
+* **Parameters:**
+ * **point** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – The Cartesian Coordinates of the point to check.
+ * **control_points** ([*BezierPointsLike*](manim.typing.md#manim.typing.BezierPointsLike)) – The Cartesian Coordinates of the ordered control
+ points of the bezier curve on which the point may
+ or may not lie.
+ * **round_to** (*float*) – A float whose number of decimal places all values
+ such as coordinates of points will be rounded.
+* **Returns:**
+ Whether the point lies on the curve.
+* **Return type:**
+ bool
+
+### proportions_along_bezier_curve_for_point(point, control_points, round_to=1e-06)
+
+Obtains the proportion along the bezier curve corresponding to a given point
+given the bezier curve’s control points.
+
+The bezier polynomial is constructed using the coordinates of the given point
+as well as the bezier curve’s control points. On solving the polynomial for each dimension,
+if there are roots common to every dimension, those roots give the proportion along the
+curve the point is at. If there are no real roots, the point does not lie on the curve.
+
+* **Parameters:**
+ * **point** ([*Point3DLike*](manim.typing.md#manim.typing.Point3DLike)) – The Cartesian Coordinates of the point whose parameter
+ should be obtained.
+ * **control_points** ([*BezierPointsLike*](manim.typing.md#manim.typing.BezierPointsLike)) – The Cartesian Coordinates of the ordered control
+ points of the bezier curve on which the point may
+ or may not lie.
+ * **round_to** (*float*) – A float whose number of decimal places all values
+ such as coordinates of points will be rounded.
+* **Returns:**
+ List containing possible parameters (the proportions along the bezier curve)
+ for the given point on the given bezier curve.
+ This usually only contains one or zero elements, but if the
+ point is, say, at the beginning/end of a closed loop, may return
+ a list with more than 1 value, corresponding to the beginning and
+ end etc. of the loop.
+* **Return type:**
+ np.ndarray[float]
+* **Raises:**
+ **ValueError** – When `point` and the control points have different shapes.
+
+### split_bezier(points, t)
+
+Split a Bézier curve at argument `t` into two curves.
+
+#### NOTE
+#### SEE ALSO
+[A Primer on Bézier Curves #10: Splitting curves. Pomax.](https://pomax.github.io/bezierinfo/#splitting)
+
+As an example for a cubic Bézier curve, let $p_0, p_1, p_2, p_3$ be the points
+needed for the curve $C_0 = [p_0, \ p_1, \ p_2, \ p_3]$.
+
+Define the 3 linear Béziers $L_0, L_1, L_2$ as interpolations of $p_0, p_1, p_2, p_3$:
+
+$$
+L_0(t) &= p_0 + t(p_1 - p_0) \\
+L_1(t) &= p_1 + t(p_2 - p_1) \\
+L_2(t) &= p_2 + t(p_3 - p_2)
+
+$$
+
+Define the 2 quadratic Béziers $Q_0, Q_1$ as interpolations of $L_0, L_1, L_2$:
+
+$$
+Q_0(t) &= L_0(t) + t(L_1(t) - L_0(t)) \\
+Q_1(t) &= L_1(t) + t(L_2(t) - L_1(t))
+
+$$
+
+Then $C_0$ is the following interpolation of $Q_0$ and $Q_1$:
+
+$$
+C_0(t) = Q_0(t) + t(Q_1(t) - Q_0(t))
+
+$$
+
+Evaluating $C_0$ at a value $t=t'$ splits $C_0$ into two cubic Béziers $H_0$
+and $H_1$, defined by some of the points we calculated earlier:
+
+$$
+H_0 &= [p_0, &\ L_0(t'), &\ Q_0(t'), &\ C_0(t') &] \\
+H_1 &= [p_0(t'), &\ Q_1(t'), &\ L_2(t'), &\ p_3 &]
+
+$$
+
+As the resulting curves are obtained from linear combinations of `points`, everything can
+be encoded into a matrix for efficiency, which is done for Bézier curves of degree up to 3.
+
+#### SEE ALSO
+[A Primer on Bézier Curves #11: Splitting curves using matrices. Pomax.](https://pomax.github.io/bezierinfo/#matrixsplit)
+
+For the simpler case of a quadratic Bézier curve:
+
+$$
+H_0
+&=
+\begin{pmatrix}
+ p_0 \\
+ (1-t) p_0 + t p_1 \\
+ (1-t)^2 p_0 + 2(1-t)t p_1 + t^2 p_2 \\
+\end{pmatrix}
+&=
+\begin{pmatrix}
+ 1 & 0 & 0 \\
+ (1-t) & t & 0\\
+ (1-t)^2 & 2(1-t)t & t^2
+\end{pmatrix}
+\begin{pmatrix}
+ p_0 \\
+ p_1 \\
+ p_2
+\end{pmatrix}
+\\
+&
+\\
+H_1
+&=
+\begin{pmatrix}
+ (1-t)^2 p_0 + 2(1-t)t p_1 + t^2 p_2 \\
+ (1-t) p_1 + t p_2 \\
+ p_2
+\end{pmatrix}
+&=
+\begin{pmatrix}
+ (1-t)^2 & 2(1-t)t & t^2 \\
+ 0 & (1-t) & t \\
+ 0 & 0 & 1
+\end{pmatrix}
+\begin{pmatrix}
+ p_0 \\
+ p_1 \\
+ p_2
+\end{pmatrix}
+
+$$
+
+from where one can define a $(6, 3)$ split matrix $S_2$ which can multiply
+the array of `points` to compute the return value:
+
+$$
+S_2
+&=
+\begin{pmatrix}
+ 1 & 0 & 0 \\
+ (1-t) & t & 0 \\
+ (1-t)^2 & 2(1-t)t & t^2 \\
+ (1-t)^2 & 2(1-t)t & t^2 \\
+ 0 & (1-t) & t \\
+ 0 & 0 & 1
+\end{pmatrix}
+\\
+&
+\\
+S_2 P
+&=
+\begin{pmatrix}
+ 1 & 0 & 0 \\
+ (1-t) & t & 0 \\
+ (1-t)^2 & 2(1-t)t & t^2 \\
+ (1-t)^2 & 2(1-t)t & t^2 \\
+ 0 & (1-t) & t \\
+ 0 & 0 & 1
+\end{pmatrix}
+\begin{pmatrix}
+ p_0 \\
+ p_1 \\
+ p_2
+\end{pmatrix}
+=
+\begin{pmatrix}
+ \vert \\
+ H_0 \\
+ \vert \\
+ \vert \\
+ H_1 \\
+ \vert
+\end{pmatrix}
+
+$$
+
+For the previous example with a cubic Bézier curve:
+
+$$
+H_0
+&=
+\begin{pmatrix}
+ p_0 \\
+ (1-t) p_0 + t p_1 \\
+ (1-t)^2 p_0 + 2(1-t)t p_1 + t^2 p_2 \\
+ (1-t)^3 p_0 + 3(1-t)^2 t p_1 + 3(1-t)t^2 p_2 + t^3 p_3
+\end{pmatrix}
+&=
+\begin{pmatrix}
+ 1 & 0 & 0 & 0 \\
+ (1-t) & t & 0 & 0 \\
+ (1-t)^2 & 2(1-t)t & t^2 & 0 \\
+ (1-t)^3 & 3(1-t)^2 t & 3(1-t)t^2 & t^3
+\end{pmatrix}
+\begin{pmatrix}
+ p_0 \\
+ p_1 \\
+ p_2 \\
+ p_3
+\end{pmatrix}
+\\
+&
+\\
+H_1
+&=
+\begin{pmatrix}
+ (1-t)^3 p_0 + 3(1-t)^2 t p_1 + 3(1-t)t^2 p_2 + t^3 p_3 \\
+ (1-t)^2 p_1 + 2(1-t)t p_2 + t^2 p_3 \\
+ (1-t) p_2 + t p_3 \\
+ p_3
+\end{pmatrix}
+&=
+\begin{pmatrix}
+ (1-t)^3 & 3(1-t)^2 t & 3(1-t)t^2 & t^3 \\
+ 0 & (1-t)^2 & 2(1-t)t & t^2 \\
+ 0 & 0 & (1-t) & t \\
+ 0 & 0 & 0 & 1
+\end{pmatrix}
+\begin{pmatrix}
+ p_0 \\
+ p_1 \\
+ p_2 \\
+ p_3
+\end{pmatrix}
+
+$$
+
+from where one can define a $(8, 4)$ split matrix $S_3$ which can multiply
+the array of `points` to compute the return value:
+
+$$
+S_3
+&=
+\begin{pmatrix}
+ 1 & 0 & 0 & 0 \\
+ (1-t) & t & 0 & 0 \\
+ (1-t)^2 & 2(1-t)t & t^2 & 0 \\
+ (1-t)^3 & 3(1-t)^2 t & 3(1-t)t^2 & t^3 \\
+ (1-t)^3 & 3(1-t)^2 t & 3(1-t)t^2 & t^3 \\
+ 0 & (1-t)^2 & 2(1-t)t & t^2 \\
+ 0 & 0 & (1-t) & t \\
+ 0 & 0 & 0 & 1
+\end{pmatrix}
+\\
+&
+\\
+S_3 P
+&=
+\begin{pmatrix}
+ 1 & 0 & 0 & 0 \\
+ (1-t) & t & 0 & 0 \\
+ (1-t)^2 & 2(1-t)t & t^2 & 0 \\
+ (1-t)^3 & 3(1-t)^2 t & 3(1-t)t^2 & t^3 \\
+ (1-t)^3 & 3(1-t)^2 t & 3(1-t)t^2 & t^3 \\
+ 0 & (1-t)^2 & 2(1-t)t & t^2 \\
+ 0 & 0 & (1-t) & t \\
+ 0 & 0 & 0 & 1
+\end{pmatrix}
+\begin{pmatrix}
+ p_0 \\
+ p_1 \\
+ p_2 \\
+ p_3
+\end{pmatrix}
+=
+\begin{pmatrix}
+ \vert \\
+ H_0 \\
+ \vert \\
+ \vert \\
+ H_1 \\
+ \vert
+\end{pmatrix}
+
+$$
+
+* **Parameters:**
+ * **points** ([*BezierPointsLike*](manim.typing.md#manim.typing.BezierPointsLike)) – The control points of the Bézier curve.
+ * **t** (*float*) – The `t`-value at which to split the Bézier curve.
+* **Returns:**
+ An array containing the control points defining the two Bézier curves.
+* **Return type:**
+ [`Point3D_Array`](manim.typing.md#manim.typing.Point3D_Array)
+
+### subdivide_bezier(points, n_divisions)
+
+Subdivide a Bézier curve into $n$ subcurves which have the same shape.
+
+The points at which the curve is split are located at the
+arguments $t = \frac{i}{n}$, for $i \in \{1, ..., n-1\}$.
+
+#### SEE ALSO
+* See [`split_bezier()`](#manim.utils.bezier.split_bezier) for an explanation on how to split Bézier curves.
+* See [`partial_bezier_points()`](#manim.utils.bezier.partial_bezier_points) for an extra understanding of this function.
+
+#### NOTE
+The resulting subcurves can be expressed as linear combinations of
+`points`, which can be encoded in a single matrix that is precalculated
+for 2nd and 3rd degree Bézier curves.
+
+As an example for a quadratic Bézier curve: taking inspiration from the
+explanation in [`partial_bezier_points()`](#manim.utils.bezier.partial_bezier_points), where the following matrix
+$P_2$ was defined to extract the portion of a quadratic Bézier
+curve for $t \in [a, b]$:
+
+$$
+P_2
+=
+\begin{pmatrix}
+ (1-a)^2 & 2(1-a)a & a^2 \\
+ (1-a)(1-b) & a(1-b) + (1-a)b & ab \\
+ (1-b)^2 & 2(1-b)b & b^2
+\end{pmatrix}
+
+$$
+
+the plan is to replace $[a, b]$ with
+$\left[ \frac{i-1}{n}, \frac{i}{n} \right], \ \forall i \in \{1, ..., n\}$.
+
+As an example for $n = 2$ divisions, construct $P_1$ for
+the interval $\left[ 0, \frac{1}{2} \right]$, and $P_2$ for the
+interval $\left[ \frac{1}{2}, 1 \right]$:
+
+$$
+P_1
+=
+\begin{pmatrix}
+ 1 & 0 & 0 \\
+ 0.5 & 0.5 & 0 \\
+ 0.25 & 0.5 & 0.25
+\end{pmatrix}
+,
+\quad
+P_2
+=
+\begin{pmatrix}
+ 0.25 & 0.5 & 0.25 \\
+ 0 & 0.5 & 0.5 \\
+ 0 & 0 & 1
+\end{pmatrix}
+
+$$
+
+Therefore, the following $(6, 3)$ subdivision matrix $D_2$ can be
+constructed, which will subdivide an array of `points` into 2 parts:
+
+$$
+D_2
+=
+\begin{pmatrix}
+ M_1 \\
+ M_2
+\end{pmatrix}
+=
+\begin{pmatrix}
+ 1 & 0 & 0 \\
+ 0.5 & 0.5 & 0 \\
+ 0.25 & 0.5 & 0.25 \\
+ 0.25 & 0.5 & 0.25 \\
+ 0 & 0.5 & 0.5 \\
+ 0 & 0 & 1
+\end{pmatrix}
+
+$$
+
+For quadratic and cubic Bézier curves, the subdivision matrices are memoized for
+efficiency. For higher degree curves, an iterative algorithm inspired by the
+one from [`split_bezier()`](#manim.utils.bezier.split_bezier) is used instead.
+
+
+* **Parameters:**
+ * **points** ([*BezierPointsLike*](manim.typing.md#manim.typing.BezierPointsLike)) – The control points of the Bézier curve.
+ * **n_divisions** (*int*) – The number of curves to subdivide the Bézier curve into
+* **Returns:**
+ An array containing the points defining the new $n$ subcurves.
+* **Return type:**
+ [`Spline`](manim.typing.md#manim.typing.Spline)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.AS2700.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.AS2700.md
new file mode 100644
index 0000000000000000000000000000000000000000..288c43c71c076352caf8d7a7df5c80f0a5693456
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.AS2700.md
@@ -0,0 +1,128 @@
+# AS2700
+
+Australian Color Standard
+
+In 1985 the Australian Independent Color Standard AS 2700 was created. In
+this standard, all colors can be identified via a category code (one of
+B – Blue, G – Green, N – Neutrals (grey), P – Purple, R – Red, T – Blue/Green,
+X – Yellow/Red, Y – Yellow) and a number. The colors also have (natural) names.
+
+To use the colors from this list, access them directly from the module (which
+is exposed to Manim’s global name space):
+
+```pycon
+>>> from manim import AS2700
+>>> AS2700.B23_BRIGHT_BLUE
+ManimColor('#174F90')
+```
+
+## List of Color Constants
+
+These hex values (taken from [https://www.w3schools.com/colors/colors_australia.asp](https://www.w3schools.com/colors/colors_australia.asp))
+are non official approximate values intended to simulate AS 2700 colors:
+
+| Color Name | RGB Hex Code | Color Name | RGB Hex Code |
+|----------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| `B11_RICH_BLUE` |
#2B3770
| `B12_ROYAL_BLUE` |
#2C3563
|
+| `B13_NAVY_BLUE` |
#28304D
| `B14_SAPHHIRE` |
#28426B
|
+| `B15_MID_BLUE` |
#144B6F
| `B21_ULTRAMARINE` |
#2C5098
|
+| `B22_HOMEBUSH_BLUE` |
#215097
| `B23_BRIGHT_BLUE` |
#174F90
|
+| `B24_HARBOUR_BLUE` |
#1C6293
| `B25_AQUA` |
#5097AC
|
+| `B32_POWDER_BLUE` |
#B7C8DB
| `B33_MIST_BLUE` |
#E0E6E2
|
+| `B34_PARADISE_BLUE` |
#3499BA
| `B35_PALE_BLUE` |
#CDE4E2
|
+| `B41_BLUEBELL` |
#5B94D1
| `B42_PURPLE_BLUE` |
#5E7899
|
+| `B43_GREY_BLUE` |
#627C8D
| `B44_LIGHT_GREY_BLUE` |
#C0C0C1
|
+| `B45_SKY_BLUE` |
#7DB7C7
| `B51_PERIWINKLE` |
#3871AC
|
+| `B53_DARK_GREY_BLUE` |
#4F6572
| `B55_STORM_BLUE` |
#3F7C94
|
+| `B61_CORAL_SEA` |
#2B3873
| `B62_MIDNIGHT_BLUE` |
#292A34
|
+| `B64_CHARCOAL` |
#363E45
| `G11_BOTTLE_GREEN` |
#253A32
|
+| `G12_HOLLY` |
#21432D
| `G13_EMERALD` |
#195F35
|
+| `G14_MOSS_GREEN` |
#33572D
| `G15_RAINFOREST_GREEN` |
#3D492D
|
+| `G16_TRAFFIC_GREEN` |
#305442
| `G17_MINT_GREEN` |
#006B45
|
+| `G21_JADE` |
#127453
| `G22_SERPENTINE` |
#78A681
|
+| `G23_SHAMROCK` |
#336634
| `G24_FERN_TREE` |
#477036
|
+| `G25_OLIVE` |
#595B2A
| `G26_APPLE_GREEN` |
#4E9843
|
+| `G27_HOMEBUSH_GREEN` |
#017F4D
| `G31_VERTIGRIS` |
#468A65
|
+| `G32_OPALINE` |
#AFCBB8
| `G33_LETTUCE` |
#7B9954
|
+| `G34_AVOCADO` |
#757C4C
| `G35_LIME_GREEN` |
#89922E
|
+| `G36_KIKUYU` |
#95B43B
| `G37_BEANSTALK` |
#45A56A
|
+| `G41_LAWN_GREEN` |
#0D875D
| `G42_GLACIER` |
#D5E1D2
|
+| `G43_SURF_GREEN` |
#C8C8A7
| `G44_PALM_GREEN` |
#99B179
|
+| `G45_CHARTREUSE` |
#C7C98D
| `G46_CITRONELLA` |
#BFC83E
|
+| `G47_CRYSTAL_GREEN` |
#ADCCA8
| `G51_SPRUCE` |
#05674F
|
+| `G52_EUCALYPTUS` |
#66755B
| `G53_BANKSIA` |
#929479
|
+| `G54_MIST_GREEN` |
#7A836D
| `G55_LICHEN` |
#A7A98C
|
+| `G56_SAGE_GREEN` |
#677249
| `G61_DARK_GREEN` |
#283533
|
+| `G62_RIVERGUM` |
#617061
| `G63_DEEP_BRONZE_GREEN` |
#333334
|
+| `G64_SLATE` |
#5E6153
| `G65_TI_TREE` |
#5D5F4E
|
+| `G66_ENVIRONMENT_GREEN` |
#484C3F
| `G67_ZUCCHINI` |
#2E443A
|
+| `N11_PEARL_GREY` |
#D8D3C7
| `N12_PASTEL_GREY` |
#CCCCCC
|
+| `N14_WHITE` |
#FFFFFF
| `N15_HOMEBUSH_GREY` |
#A29B93
|
+| `N22_CLOUD_GREY` |
#C4C1B9
| `N23_NEUTRAL_GREY` |
#CCCCCC
|
+| `N24_SILVER_GREY` |
#BDC7C5
| `N25_BIRCH_GREY` |
#ABA498
|
+| `N32_GREEN_GREY` |
#8E9282
| `N33_LIGHTBOX_GREY` |
#ACADAD
|
+| `N35_LIGHT_GREY` |
#A6A7A1
| `N41_OYSTER` |
#998F78
|
+| `N42_STORM_GREY` |
#858F88
| `N43_PIPELINE_GREY` |
#999999
|
+| `N44_BRIDGE_GREY` |
#767779
| `N45_KOALA_GREY` |
#928F88
|
+| `N52_MID_GREY` |
#727A77
| `N53_BLUE_GREY` |
#7C8588
|
+| `N54_BASALT` |
#585C63
| `N55_LEAD_GREY` |
#5E5C58
|
+| `N61_BLACK` |
#2A2A2C
| `N63_PEWTER` |
#596064
|
+| `N64_DARK_GREY` |
#4B5259
| `N65_GRAPHITE_GREY` |
#45474A
|
+| `P11_MAGENTA` |
#7B2B48
| `P12_PURPLE` |
#85467B
|
+| `P13_VIOLET` |
#5D3A61
| `P14_BLUEBERRY` |
#4C4176
|
+| `P21_SUNSET_PINK` |
#E3BBBD
| `P22_CYCLAMEN` |
#83597D
|
+| `P23_LILAC` |
#A69FB1
| `P24_JACKARANDA` |
#795F91
|
+| `P31_DUSTY_PINK` |
#DBBEBC
| `P33_RIBBON_PINK` |
#D1BCC9
|
+| `P41_ERICA_PINK` |
#C55A83
| `P42_MULBERRY` |
#A06574
|
+| `P43_WISTERIA` |
#756D91
| `P52_PLUM` |
#6E3D4B
|
+| `R11_INTERNATIONAL_ORANGE` |
#CE482A
| `R12_SCARLET` |
#CD392A
|
+| `R13_SIGNAL_RED` |
#BA312B
| `R14_WARATAH` |
#AA2429
|
+| `R15_CRIMSON` |
#9E2429
| `R21_TANGERINE` |
#E96957
|
+| `R22_HOMEBUSH_RED` |
#D83A2D
| `R23_LOLLIPOP` |
#CC5058
|
+| `R24_STRAWBERRY` |
#B4292A
| `R25_ROSE_PINK` |
#E8919C
|
+| `R32_APPLE_BLOSSOM` |
#F2E1D8
| `R33_GHOST_GUM` |
#E8DAD4
|
+| `R34_MUSHROOM` |
#D7C0B6
| `R35_DEEP_ROSE` |
#CD6D71
|
+| `R41_SHELL_PINK` |
#F9D9BB
| `R42_SALMON_PINK` |
#D99679
|
+| `R43_RED_DUST` |
#D0674F
| `R44_POSSUM` |
#A18881
|
+| `R45_RUBY` |
#8F3E5C
| `R51_BURNT_PINK` |
#E19B8E
|
+| `R52_TERRACOTTA` |
#A04C36
| `R53_RED_GUM` |
#8D4338
|
+| `R54_RASPBERRY` |
#852F31
| `R55_CLARET` |
#67292D
|
+| `R62_VENETIAN_RED` |
#77372B
| `R63_RED_OXIDE` |
#663334
|
+| `R64_DEEP_INDIAN_RED` |
#542E2B
| `R65_MAROON` |
#3F2B3C
|
+| `T11_TROPICAL_BLUE` |
#006698
| `T12_DIAMANTIA` |
#006C74
|
+| `T14_MALACHITE` |
#105154
| `T15_TURQUOISE` |
#098587
|
+| `T22_ORIENTAL_BLUE` |
#358792
| `T24_BLUE_JADE` |
#427F7E
|
+| `T32_HUON_GREEN` |
#72B3B1
| `T33_SMOKE_BLUE` |
#9EB6B2
|
+| `T35_GREEN_ICE` |
#78AEA2
| `T44_BLUE_GUM` |
#6A8A88
|
+| `T45_COOTAMUNDRA` |
#759E91
| `T51_MOUNTAIN_BLUE` |
#295668
|
+| `T53_PEACOCK_BLUE` |
#245764
| `T63_TEAL` |
#183F4E
|
+| `X11_BUTTERSCOTCH` |
#D38F43
| `X12_PUMPKIN` |
#DD7E1A
|
+| `X13_MARIGOLD` |
#ED7F15
| `X14_MANDARIN` |
#E45427
|
+| `X15_ORANGE` |
#E36C2B
| `X21_PALE_OCHRE` |
#DAA45F
|
+| `X22_SAFFRON` |
#F6AA51
| `X23_APRICOT` |
#FEB56D
|
+| `X24_ROCKMELON` |
#F6894B
| `X31_RAFFIA` |
#EBC695
|
+| `X32_MAGNOLIA` |
#F1DEBE
| `X33_WARM_WHITE` |
#F3E7D4
|
+| `X34_DRIFTWOOD` |
#D5C4AE
| `X41_BUFF` |
#C28A44
|
+| `X42_BISCUIT` |
#DEBA92
| `X43_BEIGE` |
#C9AA8C
|
+| `X45_CINNAMON` |
#AC826D
| `X51_TAN` |
#8F5F32
|
+| `X52_COFFEE` |
#AD7948
| `X53_GOLDEN_TAN` |
#925629
|
+| `X54_BROWN` |
#68452C
| `X55_NUT_BROWN` |
#764832
|
+| `X61_WOMBAT` |
#6E5D52
| `X62_DARK_EARTH` |
#6E5D52
|
+| `X63_IRONBARK` |
#443B36
| `X64_CHOCOLATE` |
#4A3B31
|
+| `X65_DARK_BROWN` |
#4F372D
| `Y11_CANARY` |
#E7BD11
|
+| `Y12_WATTLE` |
#E8AF01
| `Y13_VIVID_YELLOW` |
#FCAE01
|
+| `Y14_GOLDEN_YELLOW` |
#F5A601
| `Y15_SUNFLOWER` |
#FFA709
|
+| `Y16_INCA_GOLD` |
#DF8C19
| `Y21_PRIMROSE` |
#F5CF5B
|
+| `Y22_CUSTARD` |
#EFD25C
| `Y23_BUTTERCUP` |
#E0CD41
|
+| `Y24_STRAW` |
#E3C882
| `Y25_DEEP_CREAM` |
#F3C968
|
+| `Y26_HOMEBUSH_GOLD` |
#FCC51A
| `Y31_LILY_GREEN` |
#E3E3CD
|
+| `Y32_FLUMMERY` |
#E6DF9E
| `Y33_PALE_PRIMROSE` |
#F5F3CE
|
+| `Y34_CREAM` |
#EFE3BE
| `Y35_OFF_WHITE` |
#F1E9D5
|
+| `Y41_OLIVE_YELLOW` |
#8E7426
| `Y42_MUSTARD` |
#C4A32E
|
+| `Y43_PARCHMENT` |
#D4C9A3
| `Y44_SAND` |
#DCC18B
|
+| `Y45_MANILLA` |
#E5D0A7
| `Y51_BRONZE_OLIVE` |
#695D3E
|
+| `Y52_CHAMOIS` |
#BEA873
| `Y53_SANDSTONE` |
#D5BF8E
|
+| `Y54_OATMEAL` |
#CAAE82
| `Y55_DEEP_STONE` |
#BC9969
|
+| `Y56_MERINO` |
#C9B79E
| `Y61_BLACK_OLIVE` |
#47473B
|
+| `Y62_SUGAR_CANE` |
#BCA55C
| `Y63_KHAKI` |
#826843
|
+| `Y65_MUSHROOM` |
#A39281
| `Y66_MUDSTONE` |
#574E45
|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.BS381.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.BS381.md
new file mode 100644
index 0000000000000000000000000000000000000000..62b4637bdce404724e9e82ac7bb4acfbf5d02631
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.BS381.md
@@ -0,0 +1,170 @@
+# BS381
+
+British Color Standard
+
+This module contains colors defined in one of the British Standards
+for colors, BS381C. This standard specifies colors used in identification,
+coding, and other special purposes. See [https://www.britishstandardcolour.com/](https://www.britishstandardcolour.com/)
+for more information.
+
+To use the colors from this list, access them directly from the module (which
+is exposed to Manim’s global name space):
+
+```pycon
+>>> from manim import BS381
+>>> BS381.OXFORD_BLUE
+ManimColor('#1F3057')
+```
+
+## List of Color Constants
+
+These hex values (taken from [https://www.w3schools.com/colors/colors_british.asp](https://www.w3schools.com/colors/colors_british.asp))
+are non official approximate values intended to simulate the ones defined
+in the standard:
+
+| Color Name | RGB Hex Code | Color Name | RGB Hex Code |
+|--------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| `AIRCRAFT_BLUE` |
#173679
| `AIRCRAFT_GREY` |
#88918D
|
+| `AIRCRAFT_GREY_GREEN` |
#7E8F6E
| `APRICOT` |
#FB9C06
|
+| `ARCTIC_BLUE` |
#78ADC2
| `AZO_ORANGE` |
#F24816
|
+| `AZURE_BLUE` |
#264D7E
| `BEECH_BROWN` |
#573320
|
+| `BEIGE` |
#E4CF93
| `BISCUIT` |
#FEEBA8
|
+| `BOLD_GREEN` |
#44945E
| `BOLD_RED` |
#DD3524
|
+| `BOLD_YELLOW` |
#FDE706
| `BRILLIANT_GREEN` |
#507D3A
|
+| `BS381_101` |
#94BFAC
| `BS381_102` |
#5B9291
|
+| `BS381_103` |
#3B6879
| `BS381_104` |
#264D7E
|
+| `BS381_105` |
#1F3057
| `BS381_106` |
#2A283D
|
+| `BS381_107` |
#3A73A9
| `BS381_108` |
#173679
|
+| `BS381_109` |
#1C5680
| `BS381_110` |
#2C3E75
|
+| `BS381_111` |
#8CC5BB
| `BS381_112` |
#78ADC2
|
+| `BS381_113` |
#3F687D
| `BS381_114` |
#1F4B61
|
+| `BS381_115` |
#5F88C1
| `BS381_166` |
#2458AF
|
+| `BS381_169` |
#135B75
| `BS381_172` |
#A7C6EB
|
+| `BS381_174` |
#64A0AA
| `BS381_175` |
#4F81C5
|
+| `BS381_210` |
#BBC9A5
| `BS381_216` |
#BCD890
|
+| `BS381_217` |
#96BF65
| `BS381_218` |
#698B47
|
+| `BS381_219` |
#757639
| `BS381_220` |
#4B5729
|
+| `BS381_221` |
#507D3A
| `BS381_222` |
#6A7031
|
+| `BS381_223` |
#49523A
| `BS381_224` |
#3E4630
|
+| `BS381_225` |
#406A28
| `BS381_226` |
#33533B
|
+| `BS381_227` |
#254432
| `BS381_228` |
#428B64
|
+| `BS381_241` |
#4F5241
| `BS381_262` |
#44945E
|
+| `BS381_267` |
#476A4C
| `BS381_275` |
#8FC693
|
+| `BS381_276` |
#2E4C1E
| `BS381_277` |
#364A20
|
+| `BS381_278` |
#87965A
| `BS381_279` |
#3B3629
|
+| `BS381_280` |
#68AB77
| `BS381_282` |
#506B52
|
+| `BS381_283` |
#7E8F6E
| `BS381_284` |
#6B6F5A
|
+| `BS381_285` |
#5F5C4B
| `BS381_298` |
#4F5138
|
+| `BS381_309` |
#FEEC04
| `BS381_310` |
#FEF963
|
+| `BS381_315` |
#FEF96A
| `BS381_320` |
#9E7339
|
+| `BS381_337` |
#4C4A3C
| `BS381_350` |
#7B6B4F
|
+| `BS381_352` |
#FCED96
| `BS381_353` |
#FDF07A
|
+| `BS381_354` |
#E9BB43
| `BS381_355` |
#FDD906
|
+| `BS381_356` |
#FCC808
| `BS381_358` |
#F6C870
|
+| `BS381_359` |
#DBAC50
| `BS381_361` |
#D4B97D
|
+| `BS381_362` |
#AC7C42
| `BS381_363` |
#FDE706
|
+| `BS381_364` |
#CEC093
| `BS381_365` |
#F4F0BD
|
+| `BS381_366` |
#F5E7A1
| `BS381_367` |
#FEF6BF
|
+| `BS381_368` |
#DD7B00
| `BS381_369` |
#FEEBA8
|
+| `BS381_380` |
#BBA38A
| `BS381_384` |
#EEDFA5
|
+| `BS381_385` |
#E8C88F
| `BS381_386` |
#E6C18D
|
+| `BS381_387` |
#CFB48A
| `BS381_388` |
#E4CF93
|
+| `BS381_389` |
#B2A788
| `BS381_397` |
#F3D163
|
+| `BS381_411` |
#74542F
| `BS381_412` |
#5C422E
|
+| `BS381_413` |
#402D21
| `BS381_414` |
#A86C29
|
+| `BS381_415` |
#61361E
| `BS381_420` |
#A89177
|
+| `BS381_435` |
#845B4D
| `BS381_436` |
#564B47
|
+| `BS381_439` |
#753B1E
| `BS381_443` |
#C98A71
|
+| `BS381_444` |
#A65341
| `BS381_445` |
#83422B
|
+| `BS381_446` |
#774430
| `BS381_447` |
#F3B28B
|
+| `BS381_448` |
#67403A
| `BS381_449` |
#693B3F
|
+| `BS381_452` |
#613339
| `BS381_453` |
#FBDED6
|
+| `BS381_454` |
#E8A1A2
| `BS381_460` |
#BD8F56
|
+| `BS381_473` |
#793932
| `BS381_489` |
#8D5B41
|
+| `BS381_490` |
#573320
| `BS381_499` |
#59493E
|
+| `BS381_536` |
#BB3016
| `BS381_537` |
#DD3420
|
+| `BS381_538` |
#C41C22
| `BS381_539` |
#D21E2B
|
+| `BS381_540` |
#8B1A32
| `BS381_541` |
#471B21
|
+| `BS381_542` |
#982D57
| `BS381_557` |
#EF841E
|
+| `BS381_564` |
#DD3524
| `BS381_568` |
#FB9C06
|
+| `BS381_570` |
#A83C19
| `BS381_591` |
#D04E09
|
+| `BS381_592` |
#E45523
| `BS381_593` |
#F24816
|
+| `BS381_626` |
#A0A9AA
| `BS381_627` |
#BEC0B8
|
+| `BS381_628` |
#9D9D7E
| `BS381_629` |
#7A838B
|
+| `BS381_630` |
#A5AD98
| `BS381_631` |
#9AAA9F
|
+| `BS381_632` |
#6B7477
| `BS381_633` |
#424C53
|
+| `BS381_634` |
#6F7264
| `BS381_635` |
#525B55
|
+| `BS381_636` |
#5F7682
| `BS381_637` |
#8E9B9C
|
+| `BS381_638` |
#6C7377
| `BS381_639` |
#667563
|
+| `BS381_640` |
#566164
| `BS381_642` |
#282B2F
|
+| `BS381_671` |
#4E5355
| `BS381_676` |
#A9B7B9
|
+| `BS381_677` |
#676F76
| `BS381_692` |
#7B93A3
|
+| `BS381_693` |
#88918D
| `BS381_694` |
#909A92
|
+| `BS381_697` |
#B6D3CC
| `BS381_796` |
#6E4A75
|
+| `BS381_797` |
#C9A8CE
| `CAMOUFLAGE_BEIGE` |
#B2A788
|
+| `CAMOUFLAGE_DESERT_SAND` |
#BBA38A
| `CAMOUFLAGE_GREY` |
#A0A9AA
|
+| `CAMOUFLAGE_RED` |
#845B4D
| `CANARY_YELLOW` |
#FEEC04
|
+| `CHAMPAGNE` |
#E6C18D
| `CHERRY` |
#C41C22
|
+| `COBALT_BLUE` |
#5F88C1
| `CRIMSON` |
#8B1A32
|
+| `CURRANT_RED` |
#D21E2B
| `CYPRESS_GREEN` |
#364A20
|
+| `DARK_ADMIRALTY_GREY` |
#6B7477
| `DARK_BROWN` |
#5C422E
|
+| `DARK_CAMOUFLAGE_BROWN` |
#564B47
| `DARK_CAMOUFLAGE_DESERT_SAND` |
#A89177
|
+| `DARK_CAMOUFLAGE_GREY` |
#7A838B
| `DARK_CRIMSON` |
#613339
|
+| `DARK_EARTH` |
#7B6B4F
| `DARK_GREEN` |
#4F5241
|
+| `DARK_SEA_GREY` |
#6C7377
| `DARK_VIOLET` |
#6E4A75
|
+| `DARK_WEATHERWORK_GREY` |
#676F76
| `DEEP_BRONZE_GREEN` |
#3E4630
|
+| `DEEP_BRUNSWICK_GREEN` |
#254432
| `DEEP_BUFF` |
#BD8F56
|
+| `DEEP_CHROME_GREEN` |
#476A4C
| `DEEP_CREAM` |
#FDF07A
|
+| `DEEP_INDIAN_RED` |
#67403A
| `DEEP_ORANGE` |
#D04E09
|
+| `DEEP_SAXE_BLUE` |
#3F687D
| `DOVE_GREY` |
#909A92
|
+| `EAU_DE_NIL` |
#BCD890
| `EMERALD_GREEN` |
#428B64
|
+| `EXTRA_DARK_SEA_GREY` |
#566164
| `FIESTA_BLUE` |
#78ADC2
|
+| `FOREST_GREEN` |
#506B52
| `FRENCH_BLUE` |
#2458AF
|
+| `FRENCH_GREY` |
#A5AD98
| `GOLDEN_BROWN` |
#A86C29
|
+| `GOLDEN_YELLOW` |
#FCC808
| `GRAPEFRUIT` |
#FEF96A
|
+| `GRASS_GREEN` |
#698B47
| `GULF_RED` |
#793932
|
+| `IMPERIAL_BROWN` |
#61361E
| `INTERNATIONAL_ORANGE` |
#E45523
|
+| `JASMINE_YELLOW` |
#F3D163
| `LEAD` |
#525B55
|
+| `LEAF_BROWN` |
#8D5B41
| `LEMON` |
#FDD906
|
+| `LIGHT_ADMIRALTY_GREY` |
#B6D3CC
| `LIGHT_AIRCRAFT_GREY` |
#BEC0B8
|
+| `LIGHT_BEIGE` |
#F5E7A1
| `LIGHT_BISCUIT` |
#E8C88F
|
+| `LIGHT_BRONZE_GREEN` |
#6A7031
| `LIGHT_BROWN` |
#9E7339
|
+| `LIGHT_BRUNSWICK_GREEN` |
#406A28
| `LIGHT_BUFF` |
#F6C870
|
+| `LIGHT_FRENCH_BLUE` |
#4F81C5
| `LIGHT_GREY` |
#9AAA9F
|
+| `LIGHT_OLIVE_GREEN` |
#87965A
| `LIGHT_ORANGE` |
#EF841E
|
+| `LIGHT_PURPLE_BROWN` |
#693B3F
| `LIGHT_SLATE_GREY` |
#667563
|
+| `LIGHT_STONE` |
#D4B97D
| `LIGHT_STRAW` |
#EEDFA5
|
+| `LIGHT_VIOLET` |
#C9A8CE
| `LIGHT_WEATHERWORK_GREY` |
#A9B7B9
|
+| `LINCON_GREEN` |
#2E4C1E
| `MANILLA` |
#FEF6BF
|
+| `MAROON` |
#471B21
| `MEDIUM_SEA_GREY` |
#8E9B9C
|
+| `MIDDLE_BLUE` |
#1C5680
| `MIDDLE_BRONZE_GREEN` |
#49523A
|
+| `MIDDLE_BROWN` |
#74542F
| `MIDDLE_BUFF` |
#DBAC50
|
+| `MIDDLE_GRAPHITE` |
#4E5355
| `MIDDLE_STONE` |
#AC7C42
|
+| `MID_BRUNSWICK_GREEN` |
#33533B
| `NATO_GREEN` |
#5F5C4B
|
+| `NIGHT` |
#282B2F
| `NUT_BROWN` |
#402D21
|
+| `OLIVE_DRAB` |
#4F5138
| `OLIVE_GREEN` |
#4B5729
|
+| `OPALINE_GREEN` |
#8FC693
| `ORANGE_BROWN` |
#753B1E
|
+| `ORIENT_BLUE` |
#64A0AA
| `OXFORD_BLUE` |
#1F3057
|
+| `PALE_BLUE` |
#8CC5BB
| `PALE_CREAM` |
#FCED96
|
+| `PALE_ROUNDEL_BLUE` |
#A7C6EB
| `PALE_ROUNDEL_RED` |
#E8A1A2
|
+| `PEACOCK_BLUE` |
#3B6879
| `POPPY` |
#BB3016
|
+| `PORTLAND_STONE` |
#CEC093
| `POST_OFFICE_RED` |
#C41C22
|
+| `PRIMROSE` |
#FEF963
| `PRIMROSE_2` |
#E9BB43
|
+| `PRU_BLUE` |
#5F7682
| `RAF_BLUE_GREY` |
#424C53
|
+| `RAIL_BLUE` |
#1F4B61
| `RAIL_RED` |
#F24816
|
+| `RED_OXIDE` |
#774430
| `ROUNDEL_BLUE` |
#2C3E75
|
+| `ROYAL_BLUE` |
#2A283D
| `RUBY` |
#982D57
|
+| `SAGE_GREEN` |
#757639
| `SALMON` |
#C98A71
|
+| `SALMON_PINK` |
#F3B28B
| `SEA_GREEN` |
#96BF65
|
+| `SERVICE_BROWN` |
#59493E
| `SHELL_PINK` |
#FBDED6
|
+| `SIGNAL_RED` |
#DD3420
| `SILVER_GREY` |
#9D9D7E
|
+| `SKY` |
#BBC9A5
| `SKY_BLUE` |
#94BFAC
|
+| `SLATE` |
#6F7264
| `SMOKE_GREY` |
#7B93A3
|
+| `SPRUCE_GREEN` |
#6B6F5A
| `STEEL_FURNITURE_GREEN` |
#3B3629
|
+| `STRONG_BLUE` |
#3A73A9
| `SUNRISE` |
#CFB48A
|
+| `SUNSHINE` |
#CFB48A
| `TERRACOTTA` |
#A65341
|
+| `TRAFFIC_BLUE` |
#135B75
| `TRAFFIC_GREEN` |
#476A4C
|
+| `TRAFFIC_RED` |
#A83C19
| `TRAFFIC_YELLOW` |
#DD7B00
|
+| `TURQUOISE_BLUE` |
#5B9291
| `VELLUM` |
#F4F0BD
|
+| `VENETIAN_RED` |
#83422B
| `VERDIGRIS_GREEN` |
#68AB77
|
+| `VERY_DARK_DRAB` |
#4C4A3C
| | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.DVIPSNAMES.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.DVIPSNAMES.md
new file mode 100644
index 0000000000000000000000000000000000000000..51574cacf3557566bcfca38e8cdedf0fd5775b8d
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.DVIPSNAMES.md
@@ -0,0 +1,57 @@
+# DVIPSNAMES
+
+dvips Colors
+
+This module contains the colors defined in the dvips driver, which are commonly accessed
+as named colors in LaTeX via the `\usepackage[dvipsnames]{xcolor}` package.
+
+To use the colors from this list, access them directly from the module (which
+is exposed to Manim’s global name space):
+
+```pycon
+>>> from manim import DVIPSNAMES
+>>> DVIPSNAMES.DARKORCHID
+ManimColor('#A4538A')
+```
+
+## List of Color Constants
+
+These hex values are derived from those specified in the `xcolor` package
+documentation (see [https://ctan.org/pkg/xcolor](https://ctan.org/pkg/xcolor)):
+
+| Color Name | RGB Hex Code | Color Name | RGB Hex Code |
+|------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| `APRICOT` |
#FBB982
| `AQUAMARINE` |
#00B5BE
|
+| `BITTERSWEET` |
#C04F17
| `BLACK` |
#221E1F
|
+| `BLUE` |
#2D2F92
| `BLUEGREEN` |
#00B3B8
|
+| `BLUEVIOLET` |
#473992
| `BRICKRED` |
#B6321C
|
+| `BROWN` |
#792500
| `BURNTORANGE` |
#F7921D
|
+| `CADETBLUE` |
#74729A
| `CARNATIONPINK` |
#F282B4
|
+| `CERULEAN` |
#00A2E3
| `CORNFLOWERBLUE` |
#41B0E4
|
+| `CYAN` |
#00AEEF
| `DANDELION` |
#FDBC42
|
+| `DARKORCHID` |
#A4538A
| `EMERALD` |
#00A99D
|
+| `FORESTGREEN` |
#009B55
| `FUCHSIA` |
#8C368C
|
+| `GOLDENROD` |
#FFDF42
| `GRAY` |
#949698
|
+| `GREEN` |
#00A64F
| `GREENYELLOW` |
#DFE674
|
+| `JUNGLEGREEN` |
#00A99A
| `LAVENDER` |
#F49EC4
|
+| `LIMEGREEN` |
#8DC73E
| `MAGENTA` |
#EC008C
|
+| `MAHOGANY` |
#A9341F
| `MAROON` |
#AF3235
|
+| `MELON` |
#F89E7B
| `MIDNIGHTBLUE` |
#006795
|
+| `MULBERRY` |
#A93C93
| `NAVYBLUE` |
#006EB8
|
+| `OLIVEGREEN` |
#3C8031
| `ORANGE` |
#F58137
|
+| `ORANGERED` |
#ED135A
| `ORCHID` |
#AF72B0
|
+| `PEACH` |
#F7965A
| `PERIWINKLE` |
#7977B8
|
+| `PINEGREEN` |
#008B72
| `PLUM` |
#92268F
|
+| `PROCESSBLUE` |
#00B0F0
| `PURPLE` |
#99479B
|
+| `RAWSIENNA` |
#974006
| `RED` |
#ED1B23
|
+| `REDORANGE` |
#F26035
| `REDVIOLET` |
#A1246B
|
+| `RHODAMINE` |
#EF559F
| `ROYALBLUE` |
#0071BC
|
+| `ROYALPURPLE` |
#613F99
| `RUBINERED` |
#ED017D
|
+| `SALMON` |
#F69289
| `SEAGREEN` |
#3FBC9D
|
+| `SEPIA` |
#671800
| `SKYBLUE` |
#46C5DD
|
+| `SPRINGGREEN` |
#C6DC67
| `TAN` |
#DA9D76
|
+| `TEALBLUE` |
#00AEB3
| `THISTLE` |
#D883B7
|
+| `TURQUOISE` |
#00B4CE
| `VIOLET` |
#58429B
|
+| `VIOLETRED` |
#EF58A0
| `WHITE` |
#FFFFFF
|
+| `WILDSTRAWBERRY` |
#EE2967
| `YELLOW` |
#FFF200
|
+| `YELLOWGREEN` |
#98CC70
| `YELLOWORANGE` |
#FAA21A
|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.SVGNAMES.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.SVGNAMES.md
new file mode 100644
index 0000000000000000000000000000000000000000..07624fb1c4dc0711665e5f43e578743b33adc88c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.SVGNAMES.md
@@ -0,0 +1,99 @@
+# SVGNAMES
+
+SVG 1.1 Colors
+
+This module contains the colors defined in the SVG 1.1 specification, which are commonly
+accessed as named colors in LaTeX via the `\usepackage[svgnames]{xcolor}` package.
+
+To use the colors from this list, access them directly from the module (which
+is exposed to Manim’s global name space):
+
+```pycon
+>>> from manim import SVGNAMES
+>>> SVGNAMES.LIGHTCORAL
+ManimColor('#EF7F7F')
+```
+
+## List of Color Constants
+
+These hex values are derived from those specified in the `xcolor` package
+documentation (see [https://ctan.org/pkg/xcolor](https://ctan.org/pkg/xcolor)):
+
+| Color Name | RGB Hex Code | Color Name | RGB Hex Code |
+|-------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| `ALICEBLUE` |
#EFF7FF
| `ANTIQUEWHITE` |
#F9EAD7
|
+| `AQUA` |
#00FFFF
| `AQUAMARINE` |
#7EFFD3
|
+| `AZURE` |
#EFFFFF
| `BEIGE` |
#F4F4DC
|
+| `BISQUE` |
#FFE3C4
| `BLACK` |
#000000
|
+| `BLANCHEDALMOND` |
#FFEACD
| `BLUE` |
#0000FF
|
+| `BLUEVIOLET` |
#892BE2
| `BROWN` |
#A52A2A
|
+| `BURLYWOOD` |
#DDB787
| `CADETBLUE` |
#5E9EA0
|
+| `CHARTREUSE` |
#7EFF00
| `CHOCOLATE` |
#D2681D
|
+| `CORAL` |
#FF7E4F
| `CORNFLOWERBLUE` |
#6395ED
|
+| `CORNSILK` |
#FFF7DC
| `CRIMSON` |
#DC143B
|
+| `CYAN` |
#00FFFF
| `DARKBLUE` |
#00008A
|
+| `DARKCYAN` |
#008A8A
| `DARKGOLDENROD` |
#B7850B
|
+| `DARKGRAY` |
#A9A9A9
| `DARKGREEN` |
#006300
|
+| `DARKGREY` |
#A9A9A9
| `DARKKHAKI` |
#BCB66B
|
+| `DARKMAGENTA` |
#8A008A
| `DARKOLIVEGREEN` |
#546B2F
|
+| `DARKORANGE` |
#FF8C00
| `DARKORCHID` |
#9931CC
|
+| `DARKRED` |
#8A0000
| `DARKSALMON` |
#E8967A
|
+| `DARKSEAGREEN` |
#8EBB8E
| `DARKSLATEBLUE` |
#483D8A
|
+| `DARKSLATEGRAY` |
#2F4F4F
| `DARKSLATEGREY` |
#2F4F4F
|
+| `DARKTURQUOISE` |
#00CED1
| `DARKVIOLET` |
#9300D3
|
+| `DEEPPINK` |
#FF1492
| `DEEPSKYBLUE` |
#00BFFF
|
+| `DIMGRAY` |
#686868
| `DIMGREY` |
#686868
|
+| `DODGERBLUE` |
#1D90FF
| `FIREBRICK` |
#B12121
|
+| `FLORALWHITE` |
#FFF9EF
| `FORESTGREEN` |
#218A21
|
+| `FUCHSIA` |
#FF00FF
| `GAINSBORO` |
#DCDCDC
|
+| `GHOSTWHITE` |
#F7F7FF
| `GOLD` |
#FFD700
|
+| `GOLDENROD` |
#DAA51F
| `GRAY` |
#7F7F7F
|
+| `GREEN` |
#007F00
| `GREENYELLOW` |
#ADFF2F
|
+| `GREY` |
#7F7F7F
| `HONEYDEW` |
#EFFFEF
|
+| `HOTPINK` |
#FF68B3
| `INDIANRED` |
#CD5B5B
|
+| `INDIGO` |
#4A0082
| `IVORY` |
#FFFFEF
|
+| `KHAKI` |
#EFE58C
| `LAVENDER` |
#E5E5F9
|
+| `LAVENDERBLUSH` |
#FFEFF4
| `LAWNGREEN` |
#7CFC00
|
+| `LEMONCHIFFON` |
#FFF9CD
| `LIGHTBLUE` |
#ADD8E5
|
+| `LIGHTCORAL` |
#EF7F7F
| `LIGHTCYAN` |
#E0FFFF
|
+| `LIGHTGOLDENROD` |
#EDDD82
| `LIGHTGOLDENRODYELLOW` |
#F9F9D2
|
+| `LIGHTGRAY` |
#D3D3D3
| `LIGHTGREEN` |
#90ED90
|
+| `LIGHTGREY` |
#D3D3D3
| `LIGHTPINK` |
#FFB5C0
|
+| `LIGHTSALMON` |
#FFA07A
| `LIGHTSEAGREEN` |
#1FB1AA
|
+| `LIGHTSKYBLUE` |
#87CEF9
| `LIGHTSLATEBLUE` |
#8470FF
|
+| `LIGHTSLATEGRAY` |
#778799
| `LIGHTSLATEGREY` |
#778799
|
+| `LIGHTSTEELBLUE` |
#AFC4DD
| `LIGHTYELLOW` |
#FFFFE0
|
+| `LIME` |
#00FF00
| `LIMEGREEN` |
#31CD31
|
+| `LINEN` |
#F9EFE5
| `MAGENTA` |
#FF00FF
|
+| `MAROON` |
#7F0000
| `MEDIUMAQUAMARINE` |
#66CDAA
|
+| `MEDIUMBLUE` |
#0000CD
| `MEDIUMORCHID` |
#BA54D3
|
+| `MEDIUMPURPLE` |
#9270DB
| `MEDIUMSEAGREEN` |
#3BB271
|
+| `MEDIUMSLATEBLUE` |
#7B68ED
| `MEDIUMSPRINGGREEN` |
#00F99A
|
+| `MEDIUMTURQUOISE` |
#48D1CC
| `MEDIUMVIOLETRED` |
#C61584
|
+| `MIDNIGHTBLUE` |
#181870
| `MINTCREAM` |
#F4FFF9
|
+| `MISTYROSE` |
#FFE3E1
| `MOCCASIN` |
#FFE3B5
|
+| `NAVAJOWHITE` |
#FFDDAD
| `NAVY` |
#00007F
|
+| `NAVYBLUE` |
#00007F
| `OLDLACE` |
#FCF4E5
|
+| `OLIVE` |
#7F7F00
| `OLIVEDRAB` |
#6B8D22
|
+| `ORANGE` |
#FFA500
| `ORANGERED` |
#FF4400
|
+| `ORCHID` |
#DA70D6
| `PALEGOLDENROD` |
#EDE8AA
|
+| `PALEGREEN` |
#97FB97
| `PALETURQUOISE` |
#AFEDED
|
+| `PALEVIOLETRED` |
#DB7092
| `PAPAYAWHIP` |
#FFEED4
|
+| `PEACHPUFF` |
#FFDAB8
| `PERU` |
#CD843F
|
+| `PINK` |
#FFBFCA
| `PLUM` |
#DDA0DD
|
+| `POWDERBLUE` |
#AFE0E5
| `PURPLE` |
#7F007F
|
+| `RED` |
#FF0000
| `ROSYBROWN` |
#BB8E8E
|
+| `ROYALBLUE` |
#4168E1
| `SADDLEBROWN` |
#8A4413
|
+| `SALMON` |
#F97F72
| `SANDYBROWN` |
#F3A45F
|
+| `SEAGREEN` |
#2D8A56
| `SEASHELL` |
#FFF4ED
|
+| `SIENNA` |
#A0512C
| `SILVER` |
#BFBFBF
|
+| `SKYBLUE` |
#87CEEA
| `SLATEBLUE` |
#6959CD
|
+| `SLATEGRAY` |
#707F90
| `SLATEGREY` |
#707F90
|
+| `SNOW` |
#FFF9F9
| `SPRINGGREEN` |
#00FF7E
|
+| `STEELBLUE` |
#4682B3
| `TAN` |
#D2B38C
|
+| `TEAL` |
#007F7F
| `THISTLE` |
#D8BFD8
|
+| `TOMATO` |
#FF6347
| `TURQUOISE` |
#3FE0CF
|
+| `VIOLET` |
#ED82ED
| `VIOLETRED` |
#D01F90
|
+| `WHEAT` |
#F4DDB2
| `WHITE` |
#FFFFFF
|
+| `WHITESMOKE` |
#F4F4F4
| `YELLOW` |
#FFFF00
|
+| `YELLOWGREEN` |
#9ACD30
| | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.X11.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.X11.md
new file mode 100644
index 0000000000000000000000000000000000000000..7c207676e5a552da4d0a58c87e0e44729ea03477
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.X11.md
@@ -0,0 +1,274 @@
+# X11
+
+X11 Colors
+
+These color and their names (taken from
+[https://www.w3schools.com/colors/colors_x11.asp](https://www.w3schools.com/colors/colors_x11.asp)) were developed at the
+Massachusetts Intitute of Technology (MIT) during
+the development of color based computer display system.
+
+To use the colors from this list, access them directly from the module (which
+is exposed to Manim’s global name space):
+
+```pycon
+>>> from manim import X11
+>>> X11.BEIGE
+ManimColor('#F5F5DC')
+```
+
+## List of Color Constants
+
+| Color Name | RGB Hex Code | Color Name | RGB Hex Code |
+|------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| `ALICEBLUE` |
#F0F8FF
| `ANTIQUEWHITE` |
#FAEBD7
|
+| `ANTIQUEWHITE1` |
#FFEFDB
| `ANTIQUEWHITE2` |
#EEDFCC
|
+| `ANTIQUEWHITE3` |
#CDC0B0
| `ANTIQUEWHITE4` |
#8B8378
|
+| `AQUAMARINE1` |
#7FFFD4
| `AQUAMARINE2` |
#76EEC6
|
+| `AQUAMARINE4` |
#458B74
| `AZURE1` |
#F0FFFF
|
+| `AZURE2` |
#E0EEEE
| `AZURE3` |
#C1CDCD
|
+| `AZURE4` |
#838B8B
| `BEIGE` |
#F5F5DC
|
+| `BISQUE1` |
#FFE4C4
| `BISQUE2` |
#EED5B7
|
+| `BISQUE3` |
#CDB79E
| `BISQUE4` |
#8B7D6B
|
+| `BLACK` |
#000000
| `BLANCHEDALMOND` |
#FFEBCD
|
+| `BLUE1` |
#0000FF
| `BLUE2` |
#0000EE
|
+| `BLUE4` |
#00008B
| `BLUEVIOLET` |
#8A2BE2
|
+| `BROWN` |
#A52A2A
| `BROWN1` |
#FF4040
|
+| `BROWN2` |
#EE3B3B
| `BROWN3` |
#CD3333
|
+| `BROWN4` |
#8B2323
| `BURLYWOOD` |
#DEB887
|
+| `BURLYWOOD1` |
#FFD39B
| `BURLYWOOD2` |
#EEC591
|
+| `BURLYWOOD3` |
#CDAA7D
| `BURLYWOOD4` |
#8B7355
|
+| `CADETBLUE` |
#5F9EA0
| `CADETBLUE1` |
#98F5FF
|
+| `CADETBLUE2` |
#8EE5EE
| `CADETBLUE3` |
#7AC5CD
|
+| `CADETBLUE4` |
#53868B
| `CHARTREUSE1` |
#7FFF00
|
+| `CHARTREUSE2` |
#76EE00
| `CHARTREUSE3` |
#66CD00
|
+| `CHARTREUSE4` |
#458B00
| `CHOCOLATE` |
#D2691E
|
+| `CHOCOLATE1` |
#FF7F24
| `CHOCOLATE2` |
#EE7621
|
+| `CHOCOLATE3` |
#CD661D
| `CORAL` |
#FF7F50
|
+| `CORAL1` |
#FF7256
| `CORAL2` |
#EE6A50
|
+| `CORAL3` |
#CD5B45
| `CORAL4` |
#8B3E2F
|
+| `CORNFLOWERBLUE` |
#6495ED
| `CORNSILK1` |
#FFF8DC
|
+| `CORNSILK2` |
#EEE8CD
| `CORNSILK3` |
#CDC8B1
|
+| `CORNSILK4` |
#8B8878
| `CYAN1` |
#00FFFF
|
+| `CYAN2` |
#00EEEE
| `CYAN3` |
#00CDCD
|
+| `CYAN4` |
#008B8B
| `DARKGOLDENROD` |
#B8860B
|
+| `DARKGOLDENROD1` |
#FFB90F
| `DARKGOLDENROD2` |
#EEAD0E
|
+| `DARKGOLDENROD3` |
#CD950C
| `DARKGOLDENROD4` |
#8B6508
|
+| `DARKGREEN` |
#006400
| `DARKKHAKI` |
#BDB76B
|
+| `DARKOLIVEGREEN` |
#556B2F
| `DARKOLIVEGREEN1` |
#CAFF70
|
+| `DARKOLIVEGREEN2` |
#BCEE68
| `DARKOLIVEGREEN3` |
#A2CD5A
|
+| `DARKOLIVEGREEN4` |
#6E8B3D
| `DARKORANGE` |
#FF8C00
|
+| `DARKORANGE1` |
#FF7F00
| `DARKORANGE2` |
#EE7600
|
+| `DARKORANGE3` |
#CD6600
| `DARKORANGE4` |
#8B4500
|
+| `DARKORCHID` |
#9932CC
| `DARKORCHID1` |
#BF3EFF
|
+| `DARKORCHID2` |
#B23AEE
| `DARKORCHID3` |
#9A32CD
|
+| `DARKORCHID4` |
#68228B
| `DARKSALMON` |
#E9967A
|
+| `DARKSEAGREEN` |
#8FBC8F
| `DARKSEAGREEN1` |
#C1FFC1
|
+| `DARKSEAGREEN2` |
#B4EEB4
| `DARKSEAGREEN3` |
#9BCD9B
|
+| `DARKSEAGREEN4` |
#698B69
| `DARKSLATEBLUE` |
#483D8B
|
+| `DARKSLATEGRAY` |
#2F4F4F
| `DARKSLATEGRAY1` |
#97FFFF
|
+| `DARKSLATEGRAY2` |
#8DEEEE
| `DARKSLATEGRAY3` |
#79CDCD
|
+| `DARKSLATEGRAY4` |
#528B8B
| `DARKTURQUOISE` |
#00CED1
|
+| `DARKVIOLET` |
#9400D3
| `DEEPPINK1` |
#FF1493
|
+| `DEEPPINK2` |
#EE1289
| `DEEPPINK3` |
#CD1076
|
+| `DEEPPINK4` |
#8B0A50
| `DEEPSKYBLUE1` |
#00BFFF
|
+| `DEEPSKYBLUE2` |
#00B2EE
| `DEEPSKYBLUE3` |
#009ACD
|
+| `DEEPSKYBLUE4` |
#00688B
| `DIMGRAY` |
#696969
|
+| `DODGERBLUE1` |
#1E90FF
| `DODGERBLUE2` |
#1C86EE
|
+| `DODGERBLUE3` |
#1874CD
| `DODGERBLUE4` |
#104E8B
|
+| `FIREBRICK` |
#B22222
| `FIREBRICK1` |
#FF3030
|
+| `FIREBRICK2` |
#EE2C2C
| `FIREBRICK3` |
#CD2626
|
+| `FIREBRICK4` |
#8B1A1A
| `FLORALWHITE` |
#FFFAF0
|
+| `FORESTGREEN` |
#228B22
| `GAINSBORO` |
#DCDCDC
|
+| `GHOSTWHITE` |
#F8F8FF
| `GOLD1` |
#FFD700
|
+| `GOLD2` |
#EEC900
| `GOLD3` |
#CDAD00
|
+| `GOLD4` |
#8B7500
| `GOLDENROD` |
#DAA520
|
+| `GOLDENROD1` |
#FFC125
| `GOLDENROD2` |
#EEB422
|
+| `GOLDENROD3` |
#CD9B1D
| `GOLDENROD4` |
#8B6914
|
+| `GRAY` |
#BEBEBE
| `GRAY1` |
#030303
|
+| `GRAY10` |
#1A1A1A
| `GRAY11` |
#1C1C1C
|
+| `GRAY12` |
#1F1F1F
| `GRAY13` |
#212121
|
+| `GRAY14` |
#242424
| `GRAY15` |
#262626
|
+| `GRAY16` |
#292929
| `GRAY17` |
#2B2B2B
|
+| `GRAY18` |
#2E2E2E
| `GRAY19` |
#303030
|
+| `GRAY2` |
#050505
| `GRAY20` |
#333333
|
+| `GRAY21` |
#363636
| `GRAY22` |
#383838
|
+| `GRAY23` |
#3B3B3B
| `GRAY24` |
#3D3D3D
|
+| `GRAY25` |
#404040
| `GRAY26` |
#424242
|
+| `GRAY27` |
#454545
| `GRAY28` |
#474747
|
+| `GRAY29` |
#4A4A4A
| `GRAY3` |
#080808
|
+| `GRAY30` |
#4D4D4D
| `GRAY31` |
#4F4F4F
|
+| `GRAY32` |
#525252
| `GRAY33` |
#545454
|
+| `GRAY34` |
#575757
| `GRAY35` |
#595959
|
+| `GRAY36` |
#5C5C5C
| `GRAY37` |
#5E5E5E
|
+| `GRAY38` |
#616161
| `GRAY39` |
#636363
|
+| `GRAY4` |
#0A0A0A
| `GRAY40` |
#666666
|
+| `GRAY41` |
#696969
| `GRAY42` |
#6B6B6B
|
+| `GRAY43` |
#6E6E6E
| `GRAY44` |
#707070
|
+| `GRAY45` |
#737373
| `GRAY46` |
#757575
|
+| `GRAY47` |
#787878
| `GRAY48` |
#7A7A7A
|
+| `GRAY49` |
#7D7D7D
| `GRAY5` |
#0D0D0D
|
+| `GRAY50` |
#7F7F7F
| `GRAY51` |
#828282
|
+| `GRAY52` |
#858585
| `GRAY53` |
#878787
|
+| `GRAY54` |
#8A8A8A
| `GRAY55` |
#8C8C8C
|
+| `GRAY56` |
#8F8F8F
| `GRAY57` |
#919191
|
+| `GRAY58` |
#949494
| `GRAY59` |
#969696
|
+| `GRAY6` |
#0F0F0F
| `GRAY60` |
#999999
|
+| `GRAY61` |
#9C9C9C
| `GRAY62` |
#9E9E9E
|
+| `GRAY63` |
#A1A1A1
| `GRAY64` |
#A3A3A3
|
+| `GRAY65` |
#A6A6A6
| `GRAY66` |
#A8A8A8
|
+| `GRAY67` |
#ABABAB
| `GRAY68` |
#ADADAD
|
+| `GRAY69` |
#B0B0B0
| `GRAY7` |
#121212
|
+| `GRAY70` |
#B3B3B3
| `GRAY71` |
#B5B5B5
|
+| `GRAY72` |
#B8B8B8
| `GRAY73` |
#BABABA
|
+| `GRAY74` |
#BDBDBD
| `GRAY75` |
#BFBFBF
|
+| `GRAY76` |
#C2C2C2
| `GRAY77` |
#C4C4C4
|
+| `GRAY78` |
#C7C7C7
| `GRAY79` |
#C9C9C9
|
+| `GRAY8` |
#141414
| `GRAY80` |
#CCCCCC
|
+| `GRAY81` |
#CFCFCF
| `GRAY82` |
#D1D1D1
|
+| `GRAY83` |
#D4D4D4
| `GRAY84` |
#D6D6D6
|
+| `GRAY85` |
#D9D9D9
| `GRAY86` |
#DBDBDB
|
+| `GRAY87` |
#DEDEDE
| `GRAY88` |
#E0E0E0
|
+| `GRAY89` |
#E3E3E3
| `GRAY9` |
#171717
|
+| `GRAY90` |
#E5E5E5
| `GRAY91` |
#E8E8E8
|
+| `GRAY92` |
#EBEBEB
| `GRAY93` |
#EDEDED
|
+| `GRAY94` |
#F0F0F0
| `GRAY95` |
#F2F2F2
|
+| `GRAY97` |
#F7F7F7
| `GRAY98` |
#FAFAFA
|
+| `GRAY99` |
#FCFCFC
| `GREEN1` |
#00FF00
|
+| `GREEN2` |
#00EE00
| `GREEN3` |
#00CD00
|
+| `GREEN4` |
#008B00
| `GREENYELLOW` |
#ADFF2F
|
+| `HONEYDEW1` |
#F0FFF0
| `HONEYDEW2` |
#E0EEE0
|
+| `HONEYDEW3` |
#C1CDC1
| `HONEYDEW4` |
#838B83
|
+| `HOTPINK` |
#FF69B4
| `HOTPINK1` |
#FF6EB4
|
+| `HOTPINK2` |
#EE6AA7
| `HOTPINK3` |
#CD6090
|
+| `HOTPINK4` |
#8B3A62
| `INDIANRED` |
#CD5C5C
|
+| `INDIANRED1` |
#FF6A6A
| `INDIANRED2` |
#EE6363
|
+| `INDIANRED3` |
#CD5555
| `INDIANRED4` |
#8B3A3A
|
+| `IVORY1` |
#FFFFF0
| `IVORY2` |
#EEEEE0
|
+| `IVORY3` |
#CDCDC1
| `IVORY4` |
#8B8B83
|
+| `KHAKI` |
#F0E68C
| `KHAKI1` |
#FFF68F
|
+| `KHAKI2` |
#EEE685
| `KHAKI3` |
#CDC673
|
+| `KHAKI4` |
#8B864E
| `LAVENDER` |
#E6E6FA
|
+| `LAVENDERBLUSH1` |
#FFF0F5
| `LAVENDERBLUSH2` |
#EEE0E5
|
+| `LAVENDERBLUSH3` |
#CDC1C5
| `LAVENDERBLUSH4` |
#8B8386
|
+| `LAWNGREEN` |
#7CFC00
| `LEMONCHIFFON1` |
#FFFACD
|
+| `LEMONCHIFFON2` |
#EEE9BF
| `LEMONCHIFFON3` |
#CDC9A5
|
+| `LEMONCHIFFON4` |
#8B8970
| `LIGHT` |
#EEDD82
|
+| `LIGHTBLUE` |
#ADD8E6
| `LIGHTBLUE1` |
#BFEFFF
|
+| `LIGHTBLUE2` |
#B2DFEE
| `LIGHTBLUE3` |
#9AC0CD
|
+| `LIGHTBLUE4` |
#68838B
| `LIGHTCORAL` |
#F08080
|
+| `LIGHTCYAN1` |
#E0FFFF
| `LIGHTCYAN2` |
#D1EEEE
|
+| `LIGHTCYAN3` |
#B4CDCD
| `LIGHTCYAN4` |
#7A8B8B
|
+| `LIGHTGOLDENROD1` |
#FFEC8B
| `LIGHTGOLDENROD2` |
#EEDC82
|
+| `LIGHTGOLDENROD3` |
#CDBE70
| `LIGHTGOLDENROD4` |
#8B814C
|
+| `LIGHTGOLDENRODYELLOW` |
#FAFAD2
| `LIGHTGRAY` |
#D3D3D3
|
+| `LIGHTPINK` |
#FFB6C1
| `LIGHTPINK1` |
#FFAEB9
|
+| `LIGHTPINK2` |
#EEA2AD
| `LIGHTPINK3` |
#CD8C95
|
+| `LIGHTPINK4` |
#8B5F65
| `LIGHTSALMON1` |
#FFA07A
|
+| `LIGHTSALMON2` |
#EE9572
| `LIGHTSALMON3` |
#CD8162
|
+| `LIGHTSALMON4` |
#8B5742
| `LIGHTSEAGREEN` |
#20B2AA
|
+| `LIGHTSKYBLUE` |
#87CEFA
| `LIGHTSKYBLUE1` |
#B0E2FF
|
+| `LIGHTSKYBLUE2` |
#A4D3EE
| `LIGHTSKYBLUE3` |
#8DB6CD
|
+| `LIGHTSKYBLUE4` |
#607B8B
| `LIGHTSLATEBLUE` |
#8470FF
|
+| `LIGHTSLATEGRAY` |
#778899
| `LIGHTSTEELBLUE` |
#B0C4DE
|
+| `LIGHTSTEELBLUE1` |
#CAE1FF
| `LIGHTSTEELBLUE2` |
#BCD2EE
|
+| `LIGHTSTEELBLUE3` |
#A2B5CD
| `LIGHTSTEELBLUE4` |
#6E7B8B
|
+| `LIGHTYELLOW1` |
#FFFFE0
| `LIGHTYELLOW2` |
#EEEED1
|
+| `LIGHTYELLOW3` |
#CDCDB4
| `LIGHTYELLOW4` |
#8B8B7A
|
+| `LIMEGREEN` |
#32CD32
| `LINEN` |
#FAF0E6
|
+| `MAGENTA` |
#FF00FF
| `MAGENTA2` |
#EE00EE
|
+| `MAGENTA3` |
#CD00CD
| `MAGENTA4` |
#8B008B
|
+| `MAROON` |
#B03060
| `MAROON1` |
#FF34B3
|
+| `MAROON2` |
#EE30A7
| `MAROON3` |
#CD2990
|
+| `MAROON4` |
#8B1C62
| `MEDIUM` |
#66CDAA
|
+| `MEDIUMAQUAMARINE` |
#66CDAA
| `MEDIUMBLUE` |
#0000CD
|
+| `MEDIUMORCHID` |
#BA55D3
| `MEDIUMORCHID1` |
#E066FF
|
+| `MEDIUMORCHID2` |
#D15FEE
| `MEDIUMORCHID3` |
#B452CD
|
+| `MEDIUMORCHID4` |
#7A378B
| `MEDIUMPURPLE` |
#9370DB
|
+| `MEDIUMPURPLE1` |
#AB82FF
| `MEDIUMPURPLE2` |
#9F79EE
|
+| `MEDIUMPURPLE3` |
#8968CD
| `MEDIUMPURPLE4` |
#5D478B
|
+| `MEDIUMSEAGREEN` |
#3CB371
| `MEDIUMSLATEBLUE` |
#7B68EE
|
+| `MEDIUMSPRINGGREEN` |
#00FA9A
| `MEDIUMTURQUOISE` |
#48D1CC
|
+| `MEDIUMVIOLETRED` |
#C71585
| `MIDNIGHTBLUE` |
#191970
|
+| `MINTCREAM` |
#F5FFFA
| `MISTYROSE1` |
#FFE4E1
|
+| `MISTYROSE2` |
#EED5D2
| `MISTYROSE3` |
#CDB7B5
|
+| `MISTYROSE4` |
#8B7D7B
| `MOCCASIN` |
#FFE4B5
|
+| `NAVAJOWHITE1` |
#FFDEAD
| `NAVAJOWHITE2` |
#EECFA1
|
+| `NAVAJOWHITE3` |
#CDB38B
| `NAVAJOWHITE4` |
#8B795E
|
+| `NAVYBLUE` |
#000080
| `OLDLACE` |
#FDF5E6
|
+| `OLIVEDRAB` |
#6B8E23
| `OLIVEDRAB1` |
#C0FF3E
|
+| `OLIVEDRAB2` |
#B3EE3A
| `OLIVEDRAB4` |
#698B22
|
+| `ORANGE1` |
#FFA500
| `ORANGE2` |
#EE9A00
|
+| `ORANGE3` |
#CD8500
| `ORANGE4` |
#8B5A00
|
+| `ORANGERED1` |
#FF4500
| `ORANGERED2` |
#EE4000
|
+| `ORANGERED3` |
#CD3700
| `ORANGERED4` |
#8B2500
|
+| `ORCHID` |
#DA70D6
| `ORCHID1` |
#FF83FA
|
+| `ORCHID2` |
#EE7AE9
| `ORCHID3` |
#CD69C9
|
+| `ORCHID4` |
#8B4789
| `PALE` |
#DB7093
|
+| `PALEGOLDENROD` |
#EEE8AA
| `PALEGREEN` |
#98FB98
|
+| `PALEGREEN1` |
#9AFF9A
| `PALEGREEN2` |
#90EE90
|
+| `PALEGREEN3` |
#7CCD7C
| `PALEGREEN4` |
#548B54
|
+| `PALETURQUOISE` |
#AFEEEE
| `PALETURQUOISE1` |
#BBFFFF
|
+| `PALETURQUOISE2` |
#AEEEEE
| `PALETURQUOISE3` |
#96CDCD
|
+| `PALETURQUOISE4` |
#668B8B
| `PALEVIOLETRED` |
#DB7093
|
+| `PALEVIOLETRED1` |
#FF82AB
| `PALEVIOLETRED2` |
#EE799F
|
+| `PALEVIOLETRED3` |
#CD6889
| `PALEVIOLETRED4` |
#8B475D
|
+| `PAPAYAWHIP` |
#FFEFD5
| `PEACHPUFF1` |
#FFDAB9
|
+| `PEACHPUFF2` |
#EECBAD
| `PEACHPUFF3` |
#CDAF95
|
+| `PEACHPUFF4` |
#8B7765
| `PINK` |
#FFC0CB
|
+| `PINK1` |
#FFB5C5
| `PINK2` |
#EEA9B8
|
+| `PINK3` |
#CD919E
| `PINK4` |
#8B636C
|
+| `PLUM` |
#DDA0DD
| `PLUM1` |
#FFBBFF
|
+| `PLUM2` |
#EEAEEE
| `PLUM3` |
#CD96CD
|
+| `PLUM4` |
#8B668B
| `POWDERBLUE` |
#B0E0E6
|
+| `PURPLE` |
#A020F0
| `PURPLE1` |
#9B30FF
|
+| `PURPLE2` |
#912CEE
| `PURPLE3` |
#7D26CD
|
+| `PURPLE4` |
#551A8B
| `RED1` |
#FF0000
|
+| `RED2` |
#EE0000
| `RED3` |
#CD0000
|
+| `RED4` |
#8B0000
| `ROSYBROWN` |
#BC8F8F
|
+| `ROSYBROWN1` |
#FFC1C1
| `ROSYBROWN2` |
#EEB4B4
|
+| `ROSYBROWN3` |
#CD9B9B
| `ROSYBROWN4` |
#8B6969
|
+| `ROYALBLUE` |
#4169E1
| `ROYALBLUE1` |
#4876FF
|
+| `ROYALBLUE2` |
#436EEE
| `ROYALBLUE3` |
#3A5FCD
|
+| `ROYALBLUE4` |
#27408B
| `SADDLEBROWN` |
#8B4513
|
+| `SALMON` |
#FA8072
| `SALMON1` |
#FF8C69
|
+| `SALMON2` |
#EE8262
| `SALMON3` |
#CD7054
|
+| `SALMON4` |
#8B4C39
| `SANDYBROWN` |
#F4A460
|
+| `SEAGREEN1` |
#54FF9F
| `SEAGREEN2` |
#4EEE94
|
+| `SEAGREEN3` |
#43CD80
| `SEAGREEN4` |
#2E8B57
|
+| `SEASHELL1` |
#FFF5EE
| `SEASHELL2` |
#EEE5DE
|
+| `SEASHELL3` |
#CDC5BF
| `SEASHELL4` |
#8B8682
|
+| `SIENNA` |
#A0522D
| `SIENNA1` |
#FF8247
|
+| `SIENNA2` |
#EE7942
| `SIENNA3` |
#CD6839
|
+| `SIENNA4` |
#8B4726
| `SKYBLUE` |
#87CEEB
|
+| `SKYBLUE1` |
#87CEFF
| `SKYBLUE2` |
#7EC0EE
|
+| `SKYBLUE3` |
#6CA6CD
| `SKYBLUE4` |
#4A708B
|
+| `SLATEBLUE` |
#6A5ACD
| `SLATEBLUE1` |
#836FFF
|
+| `SLATEBLUE2` |
#7A67EE
| `SLATEBLUE3` |
#6959CD
|
+| `SLATEBLUE4` |
#473C8B
| `SLATEGRAY` |
#708090
|
+| `SLATEGRAY1` |
#C6E2FF
| `SLATEGRAY2` |
#B9D3EE
|
+| `SLATEGRAY3` |
#9FB6CD
| `SLATEGRAY4` |
#6C7B8B
|
+| `SNOW1` |
#FFFAFA
| `SNOW2` |
#EEE9E9
|
+| `SNOW3` |
#CDC9C9
| `SNOW4` |
#8B8989
|
+| `SPRINGGREEN1` |
#00FF7F
| `SPRINGGREEN2` |
#00EE76
|
+| `SPRINGGREEN3` |
#00CD66
| `SPRINGGREEN4` |
#008B45
|
+| `STEELBLUE` |
#4682B4
| `STEELBLUE1` |
#63B8FF
|
+| `STEELBLUE2` |
#5CACEE
| `STEELBLUE3` |
#4F94CD
|
+| `STEELBLUE4` |
#36648B
| `TAN` |
#D2B48C
|
+| `TAN1` |
#FFA54F
| `TAN2` |
#EE9A49
|
+| `TAN3` |
#CD853F
| `TAN4` |
#8B5A2B
|
+| `THISTLE` |
#D8BFD8
| `THISTLE1` |
#FFE1FF
|
+| `THISTLE2` |
#EED2EE
| `THISTLE3` |
#CDB5CD
|
+| `THISTLE4` |
#8B7B8B
| `TOMATO1` |
#FF6347
|
+| `TOMATO2` |
#EE5C42
| `TOMATO3` |
#CD4F39
|
+| `TOMATO4` |
#8B3626
| `TURQUOISE` |
#40E0D0
|
+| `TURQUOISE1` |
#00F5FF
| `TURQUOISE2` |
#00E5EE
|
+| `TURQUOISE3` |
#00C5CD
| `TURQUOISE4` |
#00868B
|
+| `VIOLET` |
#EE82EE
| `VIOLETRED` |
#D02090
|
+| `VIOLETRED1` |
#FF3E96
| `VIOLETRED2` |
#EE3A8C
|
+| `VIOLETRED3` |
#CD3278
| `VIOLETRED4` |
#8B2252
|
+| `WHEAT` |
#F5DEB3
| `WHEAT1` |
#FFE7BA
|
+| `WHEAT2` |
#EED8AE
| `WHEAT3` |
#CDBA96
|
+| `WHEAT4` |
#8B7E66
| `WHITE` |
#FFFFFF
|
+| `WHITESMOKE` |
#F5F5F5
| `YELLOW1` |
#FFFF00
|
+| `YELLOW2` |
#EEEE00
| `YELLOW3` |
#CDCD00
|
+| `YELLOW4` |
#8B8B00
| `YELLOWGREEN` |
#9ACD32
|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.XKCD.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.XKCD.md
new file mode 100644
index 0000000000000000000000000000000000000000..e359a4e3ab52c9430556d59f3633a851e5d29a98
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.XKCD.md
@@ -0,0 +1,485 @@
+# XKCD
+
+Colors from the XKCD Color Name Survey
+
+XKCD is a popular [web comic](https://xkcd.com/353/) created by Randall Munroe.
+His “[Color Name Survey](http://blog.xkcd.com/2010/05/03/color-survey-results/)” (with
+200000 participants) resulted in a list of nearly 1000 color names.
+
+While the `XKCD` module is exposed to Manim’s global name space, the colors included
+in it are not. This means that in order to use the colors, access them via the module name:
+
+```pycon
+>>> from manim import XKCD
+>>> XKCD.MANGO
+ManimColor('#FFA62B')
+```
+
+## List of Color Constants
+
+These hex values are non official approximate values intended to simulate the colors in HTML,
+taken from [https://www.w3schools.com/colors/colors_xkcd.asp](https://www.w3schools.com/colors/colors_xkcd.asp).
+
+| Color Name | RGB Hex Code | Color Name | RGB Hex Code |
+|-------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| `ACIDGREEN` |
#8FFE09
| `ADOBE` |
#BD6C48
|
+| `ALGAE` |
#54AC68
| `ALGAEGREEN` |
#21C36F
|
+| `ALMOSTBLACK` |
#070D0D
| `AMBER` |
#FEB308
|
+| `AMETHYST` |
#9B5FC0
| `APPLE` |
#6ECB3C
|
+| `APPLEGREEN` |
#76CD26
| `APRICOT` |
#FFB16D
|
+| `AQUA` |
#13EAC9
| `AQUABLUE` |
#02D8E9
|
+| `AQUAGREEN` |
#12E193
| `AQUAMARINE` |
#2EE8BB
|
+| `ARMYGREEN` |
#4B5D16
| `ASPARAGUS` |
#77AB56
|
+| `AUBERGINE` |
#3D0734
| `AUBURN` |
#9A3001
|
+| `AVOCADO` |
#90B134
| `AVOCADOGREEN` |
#87A922
|
+| `AZUL` |
#1D5DEC
| `AZURE` |
#069AF3
|
+| `BABYBLUE` |
#A2CFFE
| `BABYGREEN` |
#8CFF9E
|
+| `BABYPINK` |
#FFB7CE
| `BABYPOO` |
#AB9004
|
+| `BABYPOOP` |
#937C00
| `BABYPOOPGREEN` |
#8F9805
|
+| `BABYPUKEGREEN` |
#B6C406
| `BABYPURPLE` |
#CA9BF7
|
+| `BABYSHITBROWN` |
#AD900D
| `BABYSHITGREEN` |
#889717
|
+| `BANANA` |
#FFFF7E
| `BANANAYELLOW` |
#FAFE4B
|
+| `BARBIEPINK` |
#FE46A5
| `BARFGREEN` |
#94AC02
|
+| `BARNEY` |
#AC1DB8
| `BARNEYPURPLE` |
#A00498
|
+| `BATTLESHIPGREY` |
#6B7C85
| `BEIGE` |
#E6DAA6
|
+| `BERRY` |
#990F4B
| `BILE` |
#B5C306
|
+| `BLACK` |
#000000
| `BLAND` |
#AFA88B
|
+| `BLOOD` |
#770001
| `BLOODORANGE` |
#FE4B03
|
+| `BLOODRED` |
#980002
| `BLUE` |
#0343DF
|
+| `BLUEBERRY` |
#464196
| `BLUEBLUE` |
#2242C7
|
+| `BLUEGREEN` |
#0F9B8E
| `BLUEGREY` |
#85A3B2
|
+| `BLUEPURPLE` |
#5A06EF
| `BLUEVIOLET` |
#5D06E9
|
+| `BLUEWITHAHINTOFPURPLE` |
#533CC6
| `BLUEYGREEN` |
#2BB179
|
+| `BLUEYGREY` |
#89A0B0
| `BLUEYPURPLE` |
#6241C7
|
+| `BLUISH` |
#2976BB
| `BLUISHGREEN` |
#10A674
|
+| `BLUISHGREY` |
#748B97
| `BLUISHPURPLE` |
#703BE7
|
+| `BLURPLE` |
#5539CC
| `BLUSH` |
#F29E8E
|
+| `BLUSHPINK` |
#FE828C
| `BOOGER` |
#9BB53C
|
+| `BOOGERGREEN` |
#96B403
| `BORDEAUX` |
#7B002C
|
+| `BORINGGREEN` |
#63B365
| `BOTTLEGREEN` |
#044A05
|
+| `BRICK` |
#A03623
| `BRICKORANGE` |
#C14A09
|
+| `BRICKRED` |
#8F1402
| `BRIGHTAQUA` |
#0BF9EA
|
+| `BRIGHTBLUE` |
#0165FC
| `BRIGHTCYAN` |
#41FDFE
|
+| `BRIGHTGREEN` |
#01FF07
| `BRIGHTLAVENDER` |
#C760FF
|
+| `BRIGHTLIGHTBLUE` |
#26F7FD
| `BRIGHTLIGHTGREEN` |
#2DFE54
|
+| `BRIGHTLILAC` |
#C95EFB
| `BRIGHTLIME` |
#87FD05
|
+| `BRIGHTLIMEGREEN` |
#65FE08
| `BRIGHTMAGENTA` |
#FF08E8
|
+| `BRIGHTOLIVE` |
#9CBB04
| `BRIGHTORANGE` |
#FF5B00
|
+| `BRIGHTPINK` |
#FE01B1
| `BRIGHTPURPLE` |
#BE03FD
|
+| `BRIGHTRED` |
#FF000D
| `BRIGHTSEAGREEN` |
#05FFA6
|
+| `BRIGHTSKYBLUE` |
#02CCFE
| `BRIGHTTEAL` |
#01F9C6
|
+| `BRIGHTTURQUOISE` |
#0FFEF9
| `BRIGHTVIOLET` |
#AD0AFD
|
+| `BRIGHTYELLOW` |
#FFFD01
| `BRIGHTYELLOWGREEN` |
#9DFF00
|
+| `BRITISHRACINGGREEN` |
#05480D
| `BRONZE` |
#A87900
|
+| `BROWN` |
#653700
| `BROWNGREEN` |
#706C11
|
+| `BROWNGREY` |
#8D8468
| `BROWNISH` |
#9C6D57
|
+| `BROWNISHGREEN` |
#6A6E09
| `BROWNISHGREY` |
#86775F
|
+| `BROWNISHORANGE` |
#CB7723
| `BROWNISHPINK` |
#C27E79
|
+| `BROWNISHPURPLE` |
#76424E
| `BROWNISHRED` |
#9E3623
|
+| `BROWNISHYELLOW` |
#C9B003
| `BROWNORANGE` |
#B96902
|
+| `BROWNRED` |
#922B05
| `BROWNYELLOW` |
#B29705
|
+| `BROWNYGREEN` |
#6F6C0A
| `BROWNYORANGE` |
#CA6B02
|
+| `BRUISE` |
#7E4071
| `BUBBLEGUM` |
#FF6CB5
|
+| `BUBBLEGUMPINK` |
#FF69AF
| `BUFF` |
#FEF69E
|
+| `BURGUNDY` |
#610023
| `BURNTORANGE` |
#C04E01
|
+| `BURNTRED` |
#9F2305
| `BURNTSIENA` |
#B75203
|
+| `BURNTSIENNA` |
#B04E0F
| `BURNTUMBER` |
#A0450E
|
+| `BURNTYELLOW` |
#D5AB09
| `BURPLE` |
#6832E3
|
+| `BUTTER` |
#FFFF81
| `BUTTERSCOTCH` |
#FDB147
|
+| `BUTTERYELLOW` |
#FFFD74
| `CADETBLUE` |
#4E7496
|
+| `CAMEL` |
#C69F59
| `CAMO` |
#7F8F4E
|
+| `CAMOGREEN` |
#526525
| `CAMOUFLAGEGREEN` |
#4B6113
|
+| `CANARY` |
#FDFF63
| `CANARYYELLOW` |
#FFFE40
|
+| `CANDYPINK` |
#FF63E9
| `CARAMEL` |
#AF6F09
|
+| `CARMINE` |
#9D0216
| `CARNATION` |
#FD798F
|
+| `CARNATIONPINK` |
#FF7FA7
| `CAROLINABLUE` |
#8AB8FE
|
+| `CELADON` |
#BEFDB7
| `CELERY` |
#C1FD95
|
+| `CEMENT` |
#A5A391
| `CERISE` |
#DE0C62
|
+| `CERULEAN` |
#0485D1
| `CERULEANBLUE` |
#056EEE
|
+| `CHARCOAL` |
#343837
| `CHARCOALGREY` |
#3C4142
|
+| `CHARTREUSE` |
#C1F80A
| `CHERRY` |
#CF0234
|
+| `CHERRYRED` |
#F7022A
| `CHESTNUT` |
#742802
|
+| `CHOCOLATE` |
#3D1C02
| `CHOCOLATEBROWN` |
#411900
|
+| `CINNAMON` |
#AC4F06
| `CLARET` |
#680018
|
+| `CLAY` |
#B66A50
| `CLAYBROWN` |
#B2713D
|
+| `CLEARBLUE` |
#247AFD
| `COBALT` |
#1E488F
|
+| `COBALTBLUE` |
#030AA7
| `COCOA` |
#875F42
|
+| `COFFEE` |
#A6814C
| `COOLBLUE` |
#4984B8
|
+| `COOLGREEN` |
#33B864
| `COOLGREY` |
#95A3A6
|
+| `COPPER` |
#B66325
| `CORAL` |
#FC5A50
|
+| `CORALPINK` |
#FF6163
| `CORNFLOWER` |
#6A79F7
|
+| `CORNFLOWERBLUE` |
#5170D7
| `CRANBERRY` |
#9E003A
|
+| `CREAM` |
#FFFFC2
| `CREME` |
#FFFFB6
|
+| `CRIMSON` |
#8C000F
| `CUSTARD` |
#FFFD78
|
+| `CYAN` |
#00FFFF
| `DANDELION` |
#FEDF08
|
+| `DARK` |
#1B2431
| `DARKAQUA` |
#05696B
|
+| `DARKAQUAMARINE` |
#017371
| `DARKBEIGE` |
#AC9362
|
+| `DARKBLUE` |
#030764
| `DARKBLUEGREEN` |
#005249
|
+| `DARKBLUEGREY` |
#1F3B4D
| `DARKBROWN` |
#341C02
|
+| `DARKCORAL` |
#CF524E
| `DARKCREAM` |
#FFF39A
|
+| `DARKCYAN` |
#0A888A
| `DARKFORESTGREEN` |
#002D04
|
+| `DARKFUCHSIA` |
#9D0759
| `DARKGOLD` |
#B59410
|
+| `DARKGRASSGREEN` |
#388004
| `DARKGREEN` |
#054907
|
+| `DARKGREENBLUE` |
#1F6357
| `DARKGREY` |
#363737
|
+| `DARKGREYBLUE` |
#29465B
| `DARKHOTPINK` |
#D90166
|
+| `DARKINDIGO` |
#1F0954
| `DARKISHBLUE` |
#014182
|
+| `DARKISHGREEN` |
#287C37
| `DARKISHPINK` |
#DA467D
|
+| `DARKISHPURPLE` |
#751973
| `DARKISHRED` |
#A90308
|
+| `DARKKHAKI` |
#9B8F55
| `DARKLAVENDER` |
#856798
|
+| `DARKLILAC` |
#9C6DA5
| `DARKLIME` |
#84B701
|
+| `DARKLIMEGREEN` |
#7EBD01
| `DARKMAGENTA` |
#960056
|
+| `DARKMAROON` |
#3C0008
| `DARKMAUVE` |
#874C62
|
+| `DARKMINT` |
#48C072
| `DARKMINTGREEN` |
#20C073
|
+| `DARKMUSTARD` |
#A88905
| `DARKNAVY` |
#000435
|
+| `DARKNAVYBLUE` |
#00022E
| `DARKOLIVE` |
#373E02
|
+| `DARKOLIVEGREEN` |
#3C4D03
| `DARKORANGE` |
#C65102
|
+| `DARKPASTELGREEN` |
#56AE57
| `DARKPEACH` |
#DE7E5D
|
+| `DARKPERIWINKLE` |
#665FD1
| `DARKPINK` |
#CB416B
|
+| `DARKPLUM` |
#3F012C
| `DARKPURPLE` |
#35063E
|
+| `DARKRED` |
#840000
| `DARKROSE` |
#B5485D
|
+| `DARKROYALBLUE` |
#02066F
| `DARKSAGE` |
#598556
|
+| `DARKSALMON` |
#C85A53
| `DARKSAND` |
#A88F59
|
+| `DARKSEAFOAM` |
#1FB57A
| `DARKSEAFOAMGREEN` |
#3EAF76
|
+| `DARKSEAGREEN` |
#11875D
| `DARKSKYBLUE` |
#448EE4
|
+| `DARKSLATEBLUE` |
#214761
| `DARKTAN` |
#AF884A
|
+| `DARKTAUPE` |
#7F684E
| `DARKTEAL` |
#014D4E
|
+| `DARKTURQUOISE` |
#045C5A
| `DARKVIOLET` |
#34013F
|
+| `DARKYELLOW` |
#D5B60A
| `DARKYELLOWGREEN` |
#728F02
|
+| `DEEPAQUA` |
#08787F
| `DEEPBLUE` |
#040273
|
+| `DEEPBROWN` |
#410200
| `DEEPGREEN` |
#02590F
|
+| `DEEPLAVENDER` |
#8D5EB7
| `DEEPLILAC` |
#966EBD
|
+| `DEEPMAGENTA` |
#A0025C
| `DEEPORANGE` |
#DC4D01
|
+| `DEEPPINK` |
#CB0162
| `DEEPPURPLE` |
#36013F
|
+| `DEEPRED` |
#9A0200
| `DEEPROSE` |
#C74767
|
+| `DEEPSEABLUE` |
#015482
| `DEEPSKYBLUE` |
#0D75F8
|
+| `DEEPTEAL` |
#00555A
| `DEEPTURQUOISE` |
#017374
|
+| `DEEPVIOLET` |
#490648
| `DENIM` |
#3B638C
|
+| `DENIMBLUE` |
#3B5B92
| `DESERT` |
#CCAD60
|
+| `DIARRHEA` |
#9F8303
| `DIRT` |
#8A6E45
|
+| `DIRTBROWN` |
#836539
| `DIRTYBLUE` |
#3F829D
|
+| `DIRTYGREEN` |
#667E2C
| `DIRTYORANGE` |
#C87606
|
+| `DIRTYPINK` |
#CA7B80
| `DIRTYPURPLE` |
#734A65
|
+| `DIRTYYELLOW` |
#CDC50A
| `DODGERBLUE` |
#3E82FC
|
+| `DRAB` |
#828344
| `DRABGREEN` |
#749551
|
+| `DRIEDBLOOD` |
#4B0101
| `DUCKEGGBLUE` |
#C3FBF4
|
+| `DULLBLUE` |
#49759C
| `DULLBROWN` |
#876E4B
|
+| `DULLGREEN` |
#74A662
| `DULLORANGE` |
#D8863B
|
+| `DULLPINK` |
#D5869D
| `DULLPURPLE` |
#84597E
|
+| `DULLRED` |
#BB3F3F
| `DULLTEAL` |
#5F9E8F
|
+| `DULLYELLOW` |
#EEDC5B
| `DUSK` |
#4E5481
|
+| `DUSKBLUE` |
#26538D
| `DUSKYBLUE` |
#475F94
|
+| `DUSKYPINK` |
#CC7A8B
| `DUSKYPURPLE` |
#895B7B
|
+| `DUSKYROSE` |
#BA6873
| `DUST` |
#B2996E
|
+| `DUSTYBLUE` |
#5A86AD
| `DUSTYGREEN` |
#76A973
|
+| `DUSTYLAVENDER` |
#AC86A8
| `DUSTYORANGE` |
#F0833A
|
+| `DUSTYPINK` |
#D58A94
| `DUSTYPURPLE` |
#825F87
|
+| `DUSTYRED` |
#B9484E
| `DUSTYROSE` |
#C0737A
|
+| `DUSTYTEAL` |
#4C9085
| `EARTH` |
#A2653E
|
+| `EASTERGREEN` |
#8CFD7E
| `EASTERPURPLE` |
#C071FE
|
+| `ECRU` |
#FEFFCA
| `EGGPLANT` |
#380835
|
+| `EGGPLANTPURPLE` |
#430541
| `EGGSHELL` |
#FFFCC4
|
+| `EGGSHELLBLUE` |
#C4FFF7
| `ELECTRICBLUE` |
#0652FF
|
+| `ELECTRICGREEN` |
#21FC0D
| `ELECTRICLIME` |
#A8FF04
|
+| `ELECTRICPINK` |
#FF0490
| `ELECTRICPURPLE` |
#AA23FF
|
+| `EMERALD` |
#01A049
| `EMERALDGREEN` |
#028F1E
|
+| `EVERGREEN` |
#05472A
| `FADEDBLUE` |
#658CBB
|
+| `FADEDGREEN` |
#7BB274
| `FADEDORANGE` |
#F0944D
|
+| `FADEDPINK` |
#DE9DAC
| `FADEDPURPLE` |
#916E99
|
+| `FADEDRED` |
#D3494E
| `FADEDYELLOW` |
#FEFF7F
|
+| `FAWN` |
#CFAF7B
| `FERN` |
#63A950
|
+| `FERNGREEN` |
#548D44
| `FIREENGINERED` |
#FE0002
|
+| `FLATBLUE` |
#3C73A8
| `FLATGREEN` |
#699D4C
|
+| `FLUORESCENTGREEN` |
#08FF08
| `FLUROGREEN` |
#0AFF02
|
+| `FOAMGREEN` |
#90FDA9
| `FOREST` |
#0B5509
|
+| `FORESTGREEN` |
#06470C
| `FORRESTGREEN` |
#154406
|
+| `FRENCHBLUE` |
#436BAD
| `FRESHGREEN` |
#69D84F
|
+| `FROGGREEN` |
#58BC08
| `FUCHSIA` |
#ED0DD9
|
+| `GOLD` |
#DBB40C
| `GOLDEN` |
#F5BF03
|
+| `GOLDENBROWN` |
#B27A01
| `GOLDENROD` |
#F9BC08
|
+| `GOLDENYELLOW` |
#FEC615
| `GRAPE` |
#6C3461
|
+| `GRAPEFRUIT` |
#FD5956
| `GRAPEPURPLE` |
#5D1451
|
+| `GRASS` |
#5CAC2D
| `GRASSGREEN` |
#3F9B0B
|
+| `GRASSYGREEN` |
#419C03
| `GREEN` |
#15B01A
|
+| `GREENAPPLE` |
#5EDC1F
| `GREENBLUE` |
#01C08D
|
+| `GREENBROWN` |
#544E03
| `GREENGREY` |
#77926F
|
+| `GREENISH` |
#40A368
| `GREENISHBEIGE` |
#C9D179
|
+| `GREENISHBLUE` |
#0B8B87
| `GREENISHBROWN` |
#696112
|
+| `GREENISHCYAN` |
#2AFEB7
| `GREENISHGREY` |
#96AE8D
|
+| `GREENISHTAN` |
#BCCB7A
| `GREENISHTEAL` |
#32BF84
|
+| `GREENISHTURQUOISE` |
#00FBB0
| `GREENISHYELLOW` |
#CDFD02
|
+| `GREENTEAL` |
#0CB577
| `GREENYBLUE` |
#42B395
|
+| `GREENYBROWN` |
#696006
| `GREENYELLOW` |
#B5CE08
|
+| `GREENYGREY` |
#7EA07A
| `GREENYYELLOW` |
#C6F808
|
+| `GREY` |
#929591
| `GREYBLUE` |
#647D8E
|
+| `GREYBROWN` |
#7F7053
| `GREYGREEN` |
#86A17D
|
+| `GREYISH` |
#A8A495
| `GREYISHBLUE` |
#5E819D
|
+| `GREYISHBROWN` |
#7A6A4F
| `GREYISHGREEN` |
#82A67D
|
+| `GREYISHPINK` |
#C88D94
| `GREYISHPURPLE` |
#887191
|
+| `GREYISHTEAL` |
#719F91
| `GREYPINK` |
#C3909B
|
+| `GREYPURPLE` |
#826D8C
| `GREYTEAL` |
#5E9B8A
|
+| `GROSSGREEN` |
#A0BF16
| `GUNMETAL` |
#536267
|
+| `HAZEL` |
#8E7618
| `HEATHER` |
#A484AC
|
+| `HELIOTROPE` |
#D94FF5
| `HIGHLIGHTERGREEN` |
#1BFC06
|
+| `HOSPITALGREEN` |
#9BE5AA
| `HOTGREEN` |
#25FF29
|
+| `HOTMAGENTA` |
#F504C9
| `HOTPINK` |
#FF028D
|
+| `HOTPURPLE` |
#CB00F5
| `HUNTERGREEN` |
#0B4008
|
+| `ICE` |
#D6FFFA
| `ICEBLUE` |
#D7FFFE
|
+| `ICKYGREEN` |
#8FAE22
| `INDIANRED` |
#850E04
|
+| `INDIGO` |
#380282
| `INDIGOBLUE` |
#3A18B1
|
+| `IRIS` |
#6258C4
| `IRISHGREEN` |
#019529
|
+| `IVORY` |
#FFFFCB
| `JADE` |
#1FA774
|
+| `JADEGREEN` |
#2BAF6A
| `JUNGLEGREEN` |
#048243
|
+| `KELLEYGREEN` |
#009337
| `KELLYGREEN` |
#02AB2E
|
+| `KERMITGREEN` |
#5CB200
| `KEYLIME` |
#AEFF6E
|
+| `KHAKI` |
#AAA662
| `KHAKIGREEN` |
#728639
|
+| `KIWI` |
#9CEF43
| `KIWIGREEN` |
#8EE53F
|
+| `LAVENDER` |
#C79FEF
| `LAVENDERBLUE` |
#8B88F8
|
+| `LAVENDERPINK` |
#DD85D7
| `LAWNGREEN` |
#4DA409
|
+| `LEAF` |
#71AA34
| `LEAFGREEN` |
#5CA904
|
+| `LEAFYGREEN` |
#51B73B
| `LEATHER` |
#AC7434
|
+| `LEMON` |
#FDFF52
| `LEMONGREEN` |
#ADF802
|
+| `LEMONLIME` |
#BFFE28
| `LEMONYELLOW` |
#FDFF38
|
+| `LICHEN` |
#8FB67B
| `LIGHTAQUA` |
#8CFFDB
|
+| `LIGHTAQUAMARINE` |
#7BFDC7
| `LIGHTBEIGE` |
#FFFEB6
|
+| `LIGHTBLUE` |
#7BC8F6
| `LIGHTBLUEGREEN` |
#7EFBB3
|
+| `LIGHTBLUEGREY` |
#B7C9E2
| `LIGHTBLUISHGREEN` |
#76FDA8
|
+| `LIGHTBRIGHTGREEN` |
#53FE5C
| `LIGHTBROWN` |
#AD8150
|
+| `LIGHTBURGUNDY` |
#A8415B
| `LIGHTCYAN` |
#ACFFFC
|
+| `LIGHTEGGPLANT` |
#894585
| `LIGHTERGREEN` |
#75FD63
|
+| `LIGHTERPURPLE` |
#A55AF4
| `LIGHTFORESTGREEN` |
#4F9153
|
+| `LIGHTGOLD` |
#FDDC5C
| `LIGHTGRASSGREEN` |
#9AF764
|
+| `LIGHTGREEN` |
#76FF7B
| `LIGHTGREENBLUE` |
#56FCA2
|
+| `LIGHTGREENISHBLUE` |
#63F7B4
| `LIGHTGREY` |
#D8DCD6
|
+| `LIGHTGREYBLUE` |
#9DBCD4
| `LIGHTGREYGREEN` |
#B7E1A1
|
+| `LIGHTINDIGO` |
#6D5ACF
| `LIGHTISHBLUE` |
#3D7AFD
|
+| `LIGHTISHGREEN` |
#61E160
| `LIGHTISHPURPLE` |
#A552E6
|
+| `LIGHTISHRED` |
#FE2F4A
| `LIGHTKHAKI` |
#E6F2A2
|
+| `LIGHTLAVENDAR` |
#EFC0FE
| `LIGHTLAVENDER` |
#DFC5FE
|
+| `LIGHTLIGHTBLUE` |
#CAFFFB
| `LIGHTLIGHTGREEN` |
#C8FFB0
|
+| `LIGHTLILAC` |
#EDC8FF
| `LIGHTLIME` |
#AEFD6C
|
+| `LIGHTLIMEGREEN` |
#B9FF66
| `LIGHTMAGENTA` |
#FA5FF7
|
+| `LIGHTMAROON` |
#A24857
| `LIGHTMAUVE` |
#C292A1
|
+| `LIGHTMINT` |
#B6FFBB
| `LIGHTMINTGREEN` |
#A6FBB2
|
+| `LIGHTMOSSGREEN` |
#A6C875
| `LIGHTMUSTARD` |
#F7D560
|
+| `LIGHTNAVY` |
#155084
| `LIGHTNAVYBLUE` |
#2E5A88
|
+| `LIGHTNEONGREEN` |
#4EFD54
| `LIGHTOLIVE` |
#ACBF69
|
+| `LIGHTOLIVEGREEN` |
#A4BE5C
| `LIGHTORANGE` |
#FDAA48
|
+| `LIGHTPASTELGREEN` |
#B2FBA5
| `LIGHTPEACH` |
#FFD8B1
|
+| `LIGHTPEAGREEN` |
#C4FE82
| `LIGHTPERIWINKLE` |
#C1C6FC
|
+| `LIGHTPINK` |
#FFD1DF
| `LIGHTPLUM` |
#9D5783
|
+| `LIGHTPURPLE` |
#BF77F6
| `LIGHTRED` |
#FF474C
|
+| `LIGHTROSE` |
#FFC5CB
| `LIGHTROYALBLUE` |
#3A2EFE
|
+| `LIGHTSAGE` |
#BCECAC
| `LIGHTSALMON` |
#FEA993
|
+| `LIGHTSEAFOAM` |
#A0FEBF
| `LIGHTSEAFOAMGREEN` |
#A7FFB5
|
+| `LIGHTSEAGREEN` |
#98F6B0
| `LIGHTSKYBLUE` |
#C6FCFF
|
+| `LIGHTTAN` |
#FBEEAC
| `LIGHTTEAL` |
#90E4C1
|
+| `LIGHTTURQUOISE` |
#7EF4CC
| `LIGHTURPLE` |
#B36FF6
|
+| `LIGHTVIOLET` |
#D6B4FC
| `LIGHTYELLOW` |
#FFFE7A
|
+| `LIGHTYELLOWGREEN` |
#CCFD7F
| `LIGHTYELLOWISHGREEN` |
#C2FF89
|
+| `LILAC` |
#CEA2FD
| `LILIAC` |
#C48EFD
|
+| `LIME` |
#AAFF32
| `LIMEGREEN` |
#89FE05
|
+| `LIMEYELLOW` |
#D0FE1D
| `LIPSTICK` |
#D5174E
|
+| `LIPSTICKRED` |
#C0022F
| `MACARONIANDCHEESE` |
#EFB435
|
+| `MAGENTA` |
#C20078
| `MAHOGANY` |
#4A0100
|
+| `MAIZE` |
#F4D054
| `MANGO` |
#FFA62B
|
+| `MANILLA` |
#FFFA86
| `MARIGOLD` |
#FCC006
|
+| `MARINE` |
#042E60
| `MARINEBLUE` |
#01386A
|
+| `MAROON` |
#650021
| `MAUVE` |
#AE7181
|
+| `MEDIUMBLUE` |
#2C6FBB
| `MEDIUMBROWN` |
#7F5112
|
+| `MEDIUMGREEN` |
#39AD48
| `MEDIUMGREY` |
#7D7F7C
|
+| `MEDIUMPINK` |
#F36196
| `MEDIUMPURPLE` |
#9E43A2
|
+| `MELON` |
#FF7855
| `MERLOT` |
#730039
|
+| `METALLICBLUE` |
#4F738E
| `MIDBLUE` |
#276AB3
|
+| `MIDGREEN` |
#50A747
| `MIDNIGHT` |
#03012D
|
+| `MIDNIGHTBLUE` |
#020035
| `MIDNIGHTPURPLE` |
#280137
|
+| `MILITARYGREEN` |
#667C3E
| `MILKCHOCOLATE` |
#7F4E1E
|
+| `MINT` |
#9FFEB0
| `MINTGREEN` |
#8FFF9F
|
+| `MINTYGREEN` |
#0BF77D
| `MOCHA` |
#9D7651
|
+| `MOSS` |
#769958
| `MOSSGREEN` |
#658B38
|
+| `MOSSYGREEN` |
#638B27
| `MUD` |
#735C12
|
+| `MUDBROWN` |
#60460F
| `MUDDYBROWN` |
#886806
|
+| `MUDDYGREEN` |
#657432
| `MUDDYYELLOW` |
#BFAC05
|
+| `MUDGREEN` |
#606602
| `MULBERRY` |
#920A4E
|
+| `MURKYGREEN` |
#6C7A0E
| `MUSHROOM` |
#BA9E88
|
+| `MUSTARD` |
#CEB301
| `MUSTARDBROWN` |
#AC7E04
|
+| `MUSTARDGREEN` |
#A8B504
| `MUSTARDYELLOW` |
#D2BD0A
|
+| `MUTEDBLUE` |
#3B719F
| `MUTEDGREEN` |
#5FA052
|
+| `MUTEDPINK` |
#D1768F
| `MUTEDPURPLE` |
#805B87
|
+| `NASTYGREEN` |
#70B23F
| `NAVY` |
#01153E
|
+| `NAVYBLUE` |
#001146
| `NAVYGREEN` |
#35530A
|
+| `NEONBLUE` |
#04D9FF
| `NEONGREEN` |
#0CFF0C
|
+| `NEONPINK` |
#FE019A
| `NEONPURPLE` |
#BC13FE
|
+| `NEONRED` |
#FF073A
| `NEONYELLOW` |
#CFFF04
|
+| `NICEBLUE` |
#107AB0
| `NIGHTBLUE` |
#040348
|
+| `OCEAN` |
#017B92
| `OCEANBLUE` |
#03719C
|
+| `OCEANGREEN` |
#3D9973
| `OCHER` |
#BF9B0C
|
+| `OCHRE` |
#BF9005
| `OCRE` |
#C69C04
|
+| `OFFBLUE` |
#5684AE
| `OFFGREEN` |
#6BA353
|
+| `OFFWHITE` |
#FFFFE4
| `OFFYELLOW` |
#F1F33F
|
+| `OLDPINK` |
#C77986
| `OLDROSE` |
#C87F89
|
+| `OLIVE` |
#6E750E
| `OLIVEBROWN` |
#645403
|
+| `OLIVEDRAB` |
#6F7632
| `OLIVEGREEN` |
#677A04
|
+| `OLIVEYELLOW` |
#C2B709
| `ORANGE` |
#F97306
|
+| `ORANGEBROWN` |
#BE6400
| `ORANGEISH` |
#FD8D49
|
+| `ORANGEPINK` |
#FF6F52
| `ORANGERED` |
#FE420F
|
+| `ORANGEYBROWN` |
#B16002
| `ORANGEYELLOW` |
#FFAD01
|
+| `ORANGEYRED` |
#FA4224
| `ORANGEYYELLOW` |
#FDB915
|
+| `ORANGISH` |
#FC824A
| `ORANGISHBROWN` |
#B25F03
|
+| `ORANGISHRED` |
#F43605
| `ORCHID` |
#C875C4
|
+| `PALE` |
#FFF9D0
| `PALEAQUA` |
#B8FFEB
|
+| `PALEBLUE` |
#D0FEFE
| `PALEBROWN` |
#B1916E
|
+| `PALECYAN` |
#B7FFFA
| `PALEGOLD` |
#FDDE6C
|
+| `PALEGREEN` |
#C7FDB5
| `PALEGREY` |
#FDFDFE
|
+| `PALELAVENDER` |
#EECFFE
| `PALELIGHTGREEN` |
#B1FC99
|
+| `PALELILAC` |
#E4CBFF
| `PALELIME` |
#BEFD73
|
+| `PALELIMEGREEN` |
#B1FF65
| `PALEMAGENTA` |
#D767AD
|
+| `PALEMAUVE` |
#FED0FC
| `PALEOLIVE` |
#B9CC81
|
+| `PALEOLIVEGREEN` |
#B1D27B
| `PALEORANGE` |
#FFA756
|
+| `PALEPEACH` |
#FFE5AD
| `PALEPINK` |
#FFCFDC
|
+| `PALEPURPLE` |
#B790D4
| `PALERED` |
#D9544D
|
+| `PALEROSE` |
#FDC1C5
| `PALESALMON` |
#FFB19A
|
+| `PALESKYBLUE` |
#BDF6FE
| `PALETEAL` |
#82CBB2
|
+| `PALETURQUOISE` |
#A5FBD5
| `PALEVIOLET` |
#CEAEFA
|
+| `PALEYELLOW` |
#FFFF84
| `PARCHMENT` |
#FEFCAF
|
+| `PASTELBLUE` |
#A2BFFE
| `PASTELGREEN` |
#B0FF9D
|
+| `PASTELORANGE` |
#FF964F
| `PASTELPINK` |
#FFBACD
|
+| `PASTELPURPLE` |
#CAA0FF
| `PASTELRED` |
#DB5856
|
+| `PASTELYELLOW` |
#FFFE71
| `PEA` |
#A4BF20
|
+| `PEACH` |
#FFB07C
| `PEACHYPINK` |
#FF9A8A
|
+| `PEACOCKBLUE` |
#016795
| `PEAGREEN` |
#8EAB12
|
+| `PEAR` |
#CBF85F
| `PEASOUP` |
#929901
|
+| `PEASOUPGREEN` |
#94A617
| `PERIWINKLE` |
#8E82FE
|
+| `PERIWINKLEBLUE` |
#8F99FB
| `PERRYWINKLE` |
#8F8CE7
|
+| `PETROL` |
#005F6A
| `PIGPINK` |
#E78EA5
|
+| `PINE` |
#2B5D34
| `PINEGREEN` |
#0A481E
|
+| `PINK` |
#FF81C0
| `PINKISH` |
#D46A7E
|
+| `PINKISHBROWN` |
#B17261
| `PINKISHGREY` |
#C8ACA9
|
+| `PINKISHORANGE` |
#FF724C
| `PINKISHPURPLE` |
#D648D7
|
+| `PINKISHRED` |
#F10C45
| `PINKISHTAN` |
#D99B82
|
+| `PINKPURPLE` |
#EF1DE7
| `PINKRED` |
#F5054F
|
+| `PINKY` |
#FC86AA
| `PINKYPURPLE` |
#C94CBE
|
+| `PINKYRED` |
#FC2647
| `PISSYELLOW` |
#DDD618
|
+| `PISTACHIO` |
#C0FA8B
| `PLUM` |
#580F41
|
+| `PLUMPURPLE` |
#4E0550
| `POISONGREEN` |
#40FD14
|
+| `POO` |
#8F7303
| `POOBROWN` |
#885F01
|
+| `POOP` |
#7F5E00
| `POOPBROWN` |
#7A5901
|
+| `POOPGREEN` |
#6F7C00
| `POWDERBLUE` |
#B1D1FC
|
+| `POWDERPINK` |
#FFB2D0
| `PRIMARYBLUE` |
#0804F9
|
+| `PRUSSIANBLUE` |
#004577
| `PUCE` |
#A57E52
|
+| `PUKE` |
#A5A502
| `PUKEBROWN` |
#947706
|
+| `PUKEGREEN` |
#9AAE07
| `PUKEYELLOW` |
#C2BE0E
|
+| `PUMPKIN` |
#E17701
| `PUMPKINORANGE` |
#FB7D07
|
+| `PUREBLUE` |
#0203E2
| `PURPLE` |
#7E1E9C
|
+| `PURPLEBLUE` |
#5D21D0
| `PURPLEBROWN` |
#673A3F
|
+| `PURPLEGREY` |
#866F85
| `PURPLEISH` |
#98568D
|
+| `PURPLEISHBLUE` |
#6140EF
| `PURPLEISHPINK` |
#DF4EC8
|
+| `PURPLEPINK` |
#D725DE
| `PURPLERED` |
#990147
|
+| `PURPLEY` |
#8756E4
| `PURPLEYBLUE` |
#5F34E7
|
+| `PURPLEYGREY` |
#947E94
| `PURPLEYPINK` |
#C83CB9
|
+| `PURPLISH` |
#94568C
| `PURPLISHBLUE` |
#601EF9
|
+| `PURPLISHBROWN` |
#6B4247
| `PURPLISHGREY` |
#7A687F
|
+| `PURPLISHPINK` |
#CE5DAE
| `PURPLISHRED` |
#B0054B
|
+| `PURPLY` |
#983FB2
| `PURPLYBLUE` |
#661AEE
|
+| `PURPLYPINK` |
#F075E6
| `PUTTY` |
#BEAE8A
|
+| `RACINGGREEN` |
#014600
| `RADIOACTIVEGREEN` |
#2CFA1F
|
+| `RASPBERRY` |
#B00149
| `RAWSIENNA` |
#9A6200
|
+| `RAWUMBER` |
#A75E09
| `REALLYLIGHTBLUE` |
#D4FFFF
|
+| `RED` |
#E50000
| `REDBROWN` |
#8B2E16
|
+| `REDDISH` |
#C44240
| `REDDISHBROWN` |
#7F2B0A
|
+| `REDDISHGREY` |
#997570
| `REDDISHORANGE` |
#F8481C
|
+| `REDDISHPINK` |
#FE2C54
| `REDDISHPURPLE` |
#910951
|
+| `REDDYBROWN` |
#6E1005
| `REDORANGE` |
#FD3C06
|
+| `REDPINK` |
#FA2A55
| `REDPURPLE` |
#820747
|
+| `REDVIOLET` |
#9E0168
| `REDWINE` |
#8C0034
|
+| `RICHBLUE` |
#021BF9
| `RICHPURPLE` |
#720058
|
+| `ROBINEGGBLUE` |
#8AF1FE
| `ROBINSEGG` |
#6DEDFD
|
+| `ROBINSEGGBLUE` |
#98EFF9
| `ROGUE` |
#AB1239
|
+| `ROSA` |
#FE86A4
| `ROSE` |
#CF6275
|
+| `ROSEPINK` |
#F7879A
| `ROSERED` |
#BE013C
|
+| `ROSYPINK` |
#F6688E
| `ROYAL` |
#0C1793
|
+| `ROYALBLUE` |
#0504AA
| `ROYALPURPLE` |
#4B006E
|
+| `RUBY` |
#CA0147
| `RUSSET` |
#A13905
|
+| `RUST` |
#A83C09
| `RUSTBROWN` |
#8B3103
|
+| `RUSTORANGE` |
#C45508
| `RUSTRED` |
#AA2704
|
+| `RUSTYORANGE` |
#CD5909
| `RUSTYRED` |
#AF2F0D
|
+| `SAFFRON` |
#FEB209
| `SAGE` |
#87AE73
|
+| `SAGEGREEN` |
#88B378
| `SALMON` |
#FF796C
|
+| `SALMONPINK` |
#FE7B7C
| `SAND` |
#E2CA76
|
+| `SANDBROWN` |
#CBA560
| `SANDSTONE` |
#C9AE74
|
+| `SANDY` |
#F1DA7A
| `SANDYBROWN` |
#C4A661
|
+| `SANDYELLOW` |
#FCE166
| `SANDYYELLOW` |
#FDEE73
|
+| `SAPGREEN` |
#5C8B15
| `SAPPHIRE` |
#2138AB
|
+| `SCARLET` |
#BE0119
| `SEA` |
#3C9992
|
+| `SEABLUE` |
#047495
| `SEAFOAM` |
#80F9AD
|
+| `SEAFOAMBLUE` |
#78D1B6
| `SEAFOAMGREEN` |
#7AF9AB
|
+| `SEAGREEN` |
#53FCA1
| `SEAWEED` |
#18D17B
|
+| `SEAWEEDGREEN` |
#35AD6B
| `SEPIA` |
#985E2B
|
+| `SHAMROCK` |
#01B44C
| `SHAMROCKGREEN` |
#02C14D
|
+| `SHIT` |
#7F5F00
| `SHITBROWN` |
#7B5804
|
+| `SHITGREEN` |
#758000
| `SHOCKINGPINK` |
#FE02A2
|
+| `SICKGREEN` |
#9DB92C
| `SICKLYGREEN` |
#94B21C
|
+| `SICKLYYELLOW` |
#D0E429
| `SIENNA` |
#A9561E
|
+| `SILVER` |
#C5C9C7
| `SKY` |
#82CAFC
|
+| `SKYBLUE` |
#75BBFD
| `SLATE` |
#516572
|
+| `SLATEBLUE` |
#5B7C99
| `SLATEGREEN` |
#658D6D
|
+| `SLATEGREY` |
#59656D
| `SLIMEGREEN` |
#99CC04
|
+| `SNOT` |
#ACBB0D
| `SNOTGREEN` |
#9DC100
|
+| `SOFTBLUE` |
#6488EA
| `SOFTGREEN` |
#6FC276
|
+| `SOFTPINK` |
#FDB0C0
| `SOFTPURPLE` |
#A66FB5
|
+| `SPEARMINT` |
#1EF876
| `SPRINGGREEN` |
#A9F971
|
+| `SPRUCE` |
#0A5F38
| `SQUASH` |
#F2AB15
|
+| `STEEL` |
#738595
| `STEELBLUE` |
#5A7D9A
|
+| `STEELGREY` |
#6F828A
| `STONE` |
#ADA587
|
+| `STORMYBLUE` |
#507B9C
| `STRAW` |
#FCF679
|
+| `STRAWBERRY` |
#FB2943
| `STRONGBLUE` |
#0C06F7
|
+| `STRONGPINK` |
#FF0789
| `SUNFLOWER` |
#FFC512
|
+| `SUNFLOWERYELLOW` |
#FFDA03
| `SUNNYYELLOW` |
#FFF917
|
+| `SUNSHINEYELLOW` |
#FFFD37
| `SUNYELLOW` |
#FFDF22
|
+| `SWAMP` |
#698339
| `SWAMPGREEN` |
#748500
|
+| `TAN` |
#D1B26F
| `TANBROWN` |
#AB7E4C
|
+| `TANGERINE` |
#FF9408
| `TANGREEN` |
#A9BE70
|
+| `TAUPE` |
#B9A281
| `TEA` |
#65AB7C
|
+| `TEAGREEN` |
#BDF8A3
| `TEAL` |
#029386
|
+| `TEALBLUE` |
#01889F
| `TEALGREEN` |
#25A36F
|
+| `TEALISH` |
#24BCA8
| `TEALISHGREEN` |
#0CDC73
|
+| `TERRACOTA` |
#CB6843
| `TERRACOTTA` |
#C9643B
|
+| `TIFFANYBLUE` |
#7BF2DA
| `TOMATO` |
#EF4026
|
+| `TOMATORED` |
#EC2D01
| `TOPAZ` |
#13BBAF
|
+| `TOUPE` |
#C7AC7D
| `TOXICGREEN` |
#61DE2A
|
+| `TREEGREEN` |
#2A7E19
| `TRUEBLUE` |
#010FCC
|
+| `TRUEGREEN` |
#089404
| `TURQUOISE` |
#06C2AC
|
+| `TURQUOISEBLUE` |
#06B1C4
| `TURQUOISEGREEN` |
#04F489
|
+| `TURTLEGREEN` |
#75B84F
| `TWILIGHT` |
#4E518B
|
+| `TWILIGHTBLUE` |
#0A437A
| `UGLYBLUE` |
#31668A
|
+| `UGLYBROWN` |
#7D7103
| `UGLYGREEN` |
#7A9703
|
+| `UGLYPINK` |
#CD7584
| `UGLYPURPLE` |
#A442A0
|
+| `UGLYYELLOW` |
#D0C101
| `ULTRAMARINE` |
#2000B1
|
+| `ULTRAMARINEBLUE` |
#1805DB
| `UMBER` |
#B26400
|
+| `VELVET` |
#750851
| `VERMILION` |
#F4320C
|
+| `VERYDARKBLUE` |
#000133
| `VERYDARKBROWN` |
#1D0200
|
+| `VERYDARKGREEN` |
#062E03
| `VERYDARKPURPLE` |
#2A0134
|
+| `VERYLIGHTBLUE` |
#D5FFFF
| `VERYLIGHTBROWN` |
#D3B683
|
+| `VERYLIGHTGREEN` |
#D1FFBD
| `VERYLIGHTPINK` |
#FFF4F2
|
+| `VERYLIGHTPURPLE` |
#F6CEFC
| `VERYPALEBLUE` |
#D6FFFE
|
+| `VERYPALEGREEN` |
#CFFDBC
| `VIBRANTBLUE` |
#0339F8
|
+| `VIBRANTGREEN` |
#0ADD08
| `VIBRANTPURPLE` |
#AD03DE
|
+| `VIOLET` |
#9A0EEA
| `VIOLETBLUE` |
#510AC9
|
+| `VIOLETPINK` |
#FB5FFC
| `VIOLETRED` |
#A50055
|
+| `VIRIDIAN` |
#1E9167
| `VIVIDBLUE` |
#152EFF
|
+| `VIVIDGREEN` |
#2FEF10
| `VIVIDPURPLE` |
#9900FA
|
+| `VOMIT` |
#A2A415
| `VOMITGREEN` |
#89A203
|
+| `VOMITYELLOW` |
#C7C10C
| `WARMBLUE` |
#4B57DB
|
+| `WARMBROWN` |
#964E02
| `WARMGREY` |
#978A84
|
+| `WARMPINK` |
#FB5581
| `WARMPURPLE` |
#952E8F
|
+| `WASHEDOUTGREEN` |
#BCF5A6
| `WATERBLUE` |
#0E87CC
|
+| `WATERMELON` |
#FD4659
| `WEIRDGREEN` |
#3AE57F
|
+| `WHEAT` |
#FBDD7E
| `WHITE` |
#FFFFFF
|
+| `WINDOWSBLUE` |
#3778BF
| `WINE` |
#80013F
|
+| `WINERED` |
#7B0323
| `WINTERGREEN` |
#20F986
|
+| `WISTERIA` |
#A87DC2
| `YELLOW` |
#FFFF14
|
+| `YELLOWBROWN` |
#B79400
| `YELLOWGREEN` |
#BBF90F
|
+| `YELLOWISH` |
#FAEE66
| `YELLOWISHBROWN` |
#9B7A01
|
+| `YELLOWISHGREEN` |
#B0DD16
| `YELLOWISHORANGE` |
#FFAB0F
|
+| `YELLOWISHTAN` |
#FCFC81
| `YELLOWOCHRE` |
#CB9D06
|
+| `YELLOWORANGE` |
#FCB001
| `YELLOWTAN` |
#FFE36E
|
+| `YELLOWYBROWN` |
#AE8B0C
| `YELLOWYGREEN` |
#BFF128
|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.core.HSV.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.core.HSV.md
new file mode 100644
index 0000000000000000000000000000000000000000..dca9b51cc8e9135ad046a8e08c1e9b9d89c76f12
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.core.HSV.md
@@ -0,0 +1,54 @@
+# HSV
+
+Qualified name: `manim.utils.color.core.HSV`
+
+### *class* HSV(hsv, alpha=1.0)
+
+Bases: [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+
+HSV Color Space
+
+### Methods
+
+### Attributes
+
+| `h` | |
+|--------------|----|
+| `hue` | |
+| `s` | |
+| `saturation` | |
+| `v` | |
+| `value` | |
+* **Parameters:**
+ * **hsv** ([*HSV_Array_Float*](manim.typing.md#manim.typing.HSV_Array_Float) *|* [*HSV_Tuple_Float*](manim.typing.md#manim.typing.HSV_Tuple_Float) *|* [*HSVA_Array_Float*](manim.typing.md#manim.typing.HSVA_Array_Float) *|* [*HSVA_Tuple_Float*](manim.typing.md#manim.typing.HSVA_Tuple_Float))
+ * **alpha** (*float*)
+
+#### *classmethod* \_from_internal(value)
+
+This method is intended to be overwritten by custom color space classes
+which are subtypes of [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor).
+
+The method constructs a new object of the given class by transforming the value
+in the internal format `[r,g,b,a]` into a format which the constructor of the
+custom class can understand. Look at [`HSV`](#manim.utils.color.core.HSV) for an example.
+
+* **Parameters:**
+ **value** ([*ManimColorInternal*](manim.typing.md#manim.typing.ManimColorInternal))
+* **Return type:**
+ *Self*
+
+#### *property* \_internal_space *: ndarray[Any, dtype[\_ScalarType_co]]*
+
+This is a readonly property which is a custom representation for color space
+operations. It is used for operators and can be used when implementing a custom
+color space.
+
+#### *property* \_internal_value *: [ManimColorInternal](manim.typing.md#manim.typing.ManimColorInternal)*
+
+Return the internal value of the current [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) as an
+`[r,g,b,a]` float array.
+
+* **Returns:**
+ Internal color representation.
+* **Return type:**
+ [ManimColorInternal](manim.typing.md#manim.typing.ManimColorInternal)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.core.ManimColor.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.core.ManimColor.md
new file mode 100644
index 0000000000000000000000000000000000000000..ebeba5dd2b8c6add091190b5a12d6a666d7b512c
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.core.ManimColor.md
@@ -0,0 +1,559 @@
+# ManimColor
+
+Qualified name: `manim.utils.color.core.ManimColor`
+
+### *class* ManimColor(value, alpha=1.0)
+
+Bases: `object`
+
+Internal representation of a color.
+
+The [`ManimColor`](#manim.utils.color.core.ManimColor) class is the main class for the representation of a color.
+Its internal representation is an array of 4 floats corresponding to a `[r,g,b,a]`
+value where `r,g,b,a` can be between 0.0 and 1.0.
+
+This is done in order to reduce the amount of color inconsistencies by constantly
+casting between integers and floats which introduces errors.
+
+The class can accept any value of type [`ParsableManimColor`](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) i.e.
+
+`ManimColor, int, str, RGB_Tuple_Int, RGB_Tuple_Float, RGBA_Tuple_Int, RGBA_Tuple_Float, RGB_Array_Int,
+RGB_Array_Float, RGBA_Array_Int, RGBA_Array_Float`
+
+[`ManimColor`](#manim.utils.color.core.ManimColor) itself only accepts singular values and will directly interpret
+them into a single color if possible. Be careful when passing strings to
+[`ManimColor`](#manim.utils.color.core.ManimColor): it can create a big overhead for the color processing.
+
+If you want to parse a list of colors, use the [`parse()`](#manim.utils.color.core.ManimColor.parse) method, which assumes
+that you’re going to pass a list of colors so that arrays will not be interpreted as
+a single color.
+
+#### WARNING
+If you pass an array of numbers to [`parse()`](#manim.utils.color.core.ManimColor.parse), it will interpret the
+`r,g,b,a` numbers in that array as colors: Instead of the expected
+singular color, you will get an array with 4 colors.
+
+For conversion behaviors, see the `_internal` functions for further documentation.
+
+You can create a [`ManimColor`](#manim.utils.color.core.ManimColor) instance via its classmethods. See the
+respective methods for more info.
+
+```python
+mycolor = ManimColor.from_rgb((0, 1, 0.4, 0.5))
+myothercolor = ManimColor.from_rgb((153, 255, 255))
+```
+
+You can also convert between different color spaces:
+
+```python
+mycolor_hex = mycolor.to_hex()
+myoriginalcolor = ManimColor.from_hex(mycolor_hex).to_hsv()
+```
+
+* **Parameters:**
+ * **value** ([*ParsableManimColor*](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) *|* *None*) – Some representation of a color (e.g., a string or
+ a suitable tuple). The default `None` is `BLACK`.
+ * **alpha** (*float*) – The opacity of the color. By default, colors are
+ fully opaque (value 1.0).
+
+### Methods
+
+| [`contrasting`](#manim.utils.color.core.ManimColor.contrasting) | Return one of two colors, light or dark (by default white or black), that contrasts with the current color (depending on its luminance). |
+|---------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [`darker`](#manim.utils.color.core.ManimColor.darker) | Return a new color that is darker than the current color, i.e. interpolated with `BLACK`. |
+| [`from_hex`](#manim.utils.color.core.ManimColor.from_hex) | Create a [`ManimColor`](#manim.utils.color.core.ManimColor) from a hex string. |
+| [`from_hsl`](#manim.utils.color.core.ManimColor.from_hsl) | Create a [`ManimColor`](#manim.utils.color.core.ManimColor) from an HSL array. |
+| [`from_hsv`](#manim.utils.color.core.ManimColor.from_hsv) | Create a [`ManimColor`](#manim.utils.color.core.ManimColor) from an HSV array. |
+| [`from_rgb`](#manim.utils.color.core.ManimColor.from_rgb) | Create a ManimColor from an RGB array. |
+| [`from_rgba`](#manim.utils.color.core.ManimColor.from_rgba) | Create a ManimColor from an RGBA Array. |
+| [`gradient`](#manim.utils.color.core.ManimColor.gradient) | This method is currently not implemented. |
+| [`interpolate`](#manim.utils.color.core.ManimColor.interpolate) | Interpolate between the current and the given [`ManimColor`](#manim.utils.color.core.ManimColor), and return the result. |
+| [`into`](#manim.utils.color.core.ManimColor.into) | Convert the current color into a different colorspace given by `class_type`, without changing the [`_internal_value`](#manim.utils.color.core.ManimColor._internal_value). |
+| [`invert`](#manim.utils.color.core.ManimColor.invert) | Return a new, linearly inverted version of this [`ManimColor`](#manim.utils.color.core.ManimColor) (no inplace changes). |
+| [`lighter`](#manim.utils.color.core.ManimColor.lighter) | Return a new color that is lighter than the current color, i.e. interpolated with `WHITE`. |
+| [`opacity`](#manim.utils.color.core.ManimColor.opacity) | Create a new [`ManimColor`](#manim.utils.color.core.ManimColor) with the given opacity and the same color values as before. |
+| [`parse`](#manim.utils.color.core.ManimColor.parse) | Parse one color as a [`ManimColor`](#manim.utils.color.core.ManimColor) or a sequence of colors as a list of [`ManimColor`](#manim.utils.color.core.ManimColor)'s. |
+| [`to_hex`](#manim.utils.color.core.ManimColor.to_hex) | Convert the [`ManimColor`](#manim.utils.color.core.ManimColor) to a hexadecimal representation of the color. |
+| [`to_hsl`](#manim.utils.color.core.ManimColor.to_hsl) | Convert the [`ManimColor`](#manim.utils.color.core.ManimColor) to an HSL array. |
+| [`to_hsv`](#manim.utils.color.core.ManimColor.to_hsv) | Convert the [`ManimColor`](#manim.utils.color.core.ManimColor) to an HSV array. |
+| [`to_int_rgb`](#manim.utils.color.core.ManimColor.to_int_rgb) | Convert the current [`ManimColor`](#manim.utils.color.core.ManimColor) into an RGB array of integers. |
+| [`to_int_rgba`](#manim.utils.color.core.ManimColor.to_int_rgba) | Convert the current ManimColor into an RGBA array of integers. |
+| [`to_int_rgba_with_alpha`](#manim.utils.color.core.ManimColor.to_int_rgba_with_alpha) | Convert the current [`ManimColor`](#manim.utils.color.core.ManimColor) into an RGBA array of integers. |
+| [`to_integer`](#manim.utils.color.core.ManimColor.to_integer) | Convert the current [`ManimColor`](#manim.utils.color.core.ManimColor) into an integer. |
+| [`to_rgb`](#manim.utils.color.core.ManimColor.to_rgb) | Convert the current [`ManimColor`](#manim.utils.color.core.ManimColor) into an RGB array of floats. |
+| [`to_rgba`](#manim.utils.color.core.ManimColor.to_rgba) | Convert the current [`ManimColor`](#manim.utils.color.core.ManimColor) into an RGBA array of floats. |
+| [`to_rgba_with_alpha`](#manim.utils.color.core.ManimColor.to_rgba_with_alpha) | Convert the current [`ManimColor`](#manim.utils.color.core.ManimColor) into an RGBA array of floats. |
+
+#### *classmethod* \_construct_from_space(\_space)
+
+This function is used as a proxy for constructing a color with an internal
+value. This can be used by subclasses to hook into the construction of new
+objects using the internal value format.
+
+* **Parameters:**
+ **\_space** (*ndarray* *[**Any* *,* *dtype* *[*[*ManimFloat*](manim.typing.md#manim.typing.ManimFloat) *]* *]* *|* *tuple* *[**float* *,* *float* *,* *float* *]* *|* *tuple* *[**float* *,* *float* *,* *float* *,* *float* *]*)
+* **Return type:**
+ *Self*
+
+#### *classmethod* \_from_internal(value)
+
+This method is intended to be overwritten by custom color space classes
+which are subtypes of [`ManimColor`](#manim.utils.color.core.ManimColor).
+
+The method constructs a new object of the given class by transforming the value
+in the internal format `[r,g,b,a]` into a format which the constructor of the
+custom class can understand. Look at [`HSV`](manim.utils.color.core.HSV.md#manim.utils.color.core.HSV) for an example.
+
+* **Parameters:**
+ **value** ([*ManimColorInternal*](manim.typing.md#manim.typing.ManimColorInternal))
+* **Return type:**
+ *Self*
+
+#### *static* \_internal_from_hex_string(hex_, alpha)
+
+Internal function for converting a hex string into the internal representation
+of a [`ManimColor`](#manim.utils.color.core.ManimColor).
+
+#### WARNING
+This does not accept any prefixes like # or similar in front of the hex string.
+This is just intended for the raw hex part.
+
+*For internal use only*
+
+* **Parameters:**
+ * **hex** – Hex string to be parsed.
+ * **alpha** (*float*) – Alpha value used for the color, if the color is only 3 bytes long. Otherwise,
+ if the color is 4 bytes long, this parameter will not be used.
+ * **hex_** (*str*)
+* **Returns:**
+ Internal color representation
+* **Return type:**
+ [ManimColorInternal](manim.typing.md#manim.typing.ManimColorInternal)
+
+#### *static* \_internal_from_int_rgb(rgb, alpha=1.0)
+
+Internal function for converting an RGB tuple of integers into the internal
+representation of a [`ManimColor`](#manim.utils.color.core.ManimColor).
+
+*For internal use only*
+
+* **Parameters:**
+ * **rgb** ([*RGB_Tuple_Int*](manim.typing.md#manim.typing.RGB_Tuple_Int)) – Integer RGB tuple to be parsed
+ * **alpha** (*float*) – Optional alpha value. Default is 1.0.
+* **Returns:**
+ Internal color representation.
+* **Return type:**
+ [ManimColorInternal](manim.typing.md#manim.typing.ManimColorInternal)
+
+#### *static* \_internal_from_int_rgba(rgba)
+
+Internal function for converting an RGBA tuple of integers into the internal
+representation of a [`ManimColor`](#manim.utils.color.core.ManimColor).
+
+*For internal use only*
+
+* **Parameters:**
+ **rgba** ([*RGBA_Tuple_Int*](manim.typing.md#manim.typing.RGBA_Tuple_Int)) – Int RGBA tuple to be parsed.
+* **Returns:**
+ Internal color representation.
+* **Return type:**
+ [ManimColorInternal](manim.typing.md#manim.typing.ManimColorInternal)
+
+#### *static* \_internal_from_rgb(rgb, alpha=1.0)
+
+Internal function for converting a rgb tuple of floats into the internal
+representation of a [`ManimColor`](#manim.utils.color.core.ManimColor).
+
+*For internal use only*
+
+* **Parameters:**
+ * **rgb** ([*RGB_Tuple_Float*](manim.typing.md#manim.typing.RGB_Tuple_Float)) – Float RGB tuple to be parsed.
+ * **alpha** (*float*) – Optional alpha value. Default is 1.0.
+* **Returns:**
+ Internal color representation.
+* **Return type:**
+ [ManimColorInternal](manim.typing.md#manim.typing.ManimColorInternal)
+
+#### *static* \_internal_from_rgba(rgba)
+
+Internal function for converting an RGBA tuple of floats into the internal
+representation of a [`ManimColor`](#manim.utils.color.core.ManimColor).
+
+*For internal use only*
+
+* **Parameters:**
+ **rgba** ([*RGBA_Tuple_Float*](manim.typing.md#manim.typing.RGBA_Tuple_Float)) – Int RGBA tuple to be parsed.
+* **Returns:**
+ Internal color representation.
+* **Return type:**
+ [ManimColorInternal](manim.typing.md#manim.typing.ManimColorInternal)
+
+#### *static* \_internal_from_string(name, alpha)
+
+Internal function for converting a string into the internal representation of
+a [`ManimColor`](#manim.utils.color.core.ManimColor). This is not used for hex strings: please refer to
+`_internal_from_hex()` for this functionality.
+
+*For internal use only*
+
+* **Parameters:**
+ * **name** (*str*) – The color name to be parsed into a color. Refer to the different color
+ modules in the documentation page to find the corresponding color names.
+ * **alpha** (*float*)
+* **Returns:**
+ Internal color representation.
+* **Return type:**
+ [ManimColorInternal](manim.typing.md#manim.typing.ManimColorInternal)
+* **Raises:**
+ **ValueError** – If the color name is not present in Manim.
+
+#### *property* \_internal_space *: ndarray[Any, dtype[[ManimFloat](manim.typing.md#manim.typing.ManimFloat)]]*
+
+This is a readonly property which is a custom representation for color space
+operations. It is used for operators and can be used when implementing a custom
+color space.
+
+#### *property* \_internal_value *: [ManimColorInternal](manim.typing.md#manim.typing.ManimColorInternal)*
+
+Return the internal value of the current Manim color `[r,g,b,a]` float
+array.
+
+* **Returns:**
+ Internal color representation.
+* **Return type:**
+ [ManimColorInternal](manim.typing.md#manim.typing.ManimColorInternal)
+
+#### contrasting(threshold=0.5, light=None, dark=None)
+
+Return one of two colors, light or dark (by default white or black),
+that contrasts with the current color (depending on its luminance).
+This is typically used to set text in a contrasting color that ensures
+it is readable against a background of the current color.
+
+* **Parameters:**
+ * **threshold** (*float*) – The luminance threshold which dictates whether the current color is
+ considered light or dark (and thus whether to return the dark or
+ light color, respectively). Default is 0.5.
+ * **light** (*Self* *|* *None*) – The light color to return if the current color is considered dark.
+ Default is `None`: in this case, pure `WHITE` will be returned.
+ * **dark** (*Self* *|* *None*) – The dark color to return if the current color is considered light,
+ Default is `None`: in this case, pure `BLACK` will be returned.
+* **Returns:**
+ The contrasting [`ManimColor`](#manim.utils.color.core.ManimColor).
+* **Return type:**
+ [ManimColor](#manim.utils.color.core.ManimColor)
+
+#### darker(blend=0.2)
+
+Return a new color that is darker than the current color, i.e.
+interpolated with `BLACK`. The opacity is unchanged.
+
+* **Parameters:**
+ **blend** (*float*) – The blend ratio for the interpolation, from 0.0 (the current color
+ unchanged) to 1.0 (pure black). Default is 0.2, which results in a
+ slightly darker color.
+* **Returns:**
+ The darker [`ManimColor`](#manim.utils.color.core.ManimColor).
+* **Return type:**
+ [ManimColor](#manim.utils.color.core.ManimColor)
+
+#### SEE ALSO
+[`lighter()`](#manim.utils.color.core.ManimColor.lighter)
+
+#### *classmethod* from_hex(hex_str, alpha=1.0)
+
+Create a [`ManimColor`](#manim.utils.color.core.ManimColor) from a hex string.
+
+* **Parameters:**
+ * **hex_str** (*str*) – The hex string to be converted. The allowed prefixes for this string are
+ `#` and `0x`. Currently, this method only supports 6 nibbles, i.e. only
+ strings in the format `#XXXXXX` or `0xXXXXXX`.
+ * **alpha** (*float*) – Alpha value to be used for the hex string. Default is 1.0.
+* **Returns:**
+ The [`ManimColor`](#manim.utils.color.core.ManimColor) represented by the hex string.
+* **Return type:**
+ [ManimColor](#manim.utils.color.core.ManimColor)
+
+#### *classmethod* from_hsl(hsl, alpha=1.0)
+
+Create a [`ManimColor`](#manim.utils.color.core.ManimColor) from an HSL array.
+
+* **Parameters:**
+ * **hsl** ([*HSL_Array_Float*](manim.typing.md#manim.typing.HSL_Array_Float) *|* [*HSL_Tuple_Float*](manim.typing.md#manim.typing.HSL_Tuple_Float)) – Any iterable containing 3 floats from 0.0 to 1.0.
+ * **alpha** (*float*) – The alpha value to be used. Default is 1.0.
+* **Returns:**
+ The [`ManimColor`](#manim.utils.color.core.ManimColor) with the corresponding RGB values to the given HSL
+ array.
+* **Return type:**
+ [ManimColor](#manim.utils.color.core.ManimColor)
+
+#### *classmethod* from_hsv(hsv, alpha=1.0)
+
+Create a [`ManimColor`](#manim.utils.color.core.ManimColor) from an HSV array.
+
+* **Parameters:**
+ * **hsv** ([*HSV_Array_Float*](manim.typing.md#manim.typing.HSV_Array_Float) *|* [*HSV_Tuple_Float*](manim.typing.md#manim.typing.HSV_Tuple_Float)) – Any iterable containing 3 floats from 0.0 to 1.0.
+ * **alpha** (*float*) – The alpha value to be used. Default is 1.0.
+* **Returns:**
+ The [`ManimColor`](#manim.utils.color.core.ManimColor) with the corresponding RGB values to the given HSV
+ array.
+* **Return type:**
+ [ManimColor](#manim.utils.color.core.ManimColor)
+
+#### *classmethod* from_rgb(rgb, alpha=1.0)
+
+Create a ManimColor from an RGB array. Automagically decides which type it
+is: `int` or `float`.
+
+#### WARNING
+Please make sure that your elements are not floats if you want integers. A
+`5.0` will result in the input being interpreted as if it was an RGB float
+array with the value `5.0` and not the integer `5`.
+
+* **Parameters:**
+ * **rgb** ([*RGB_Array_Float*](manim.typing.md#manim.typing.RGB_Array_Float) *|* [*RGB_Tuple_Float*](manim.typing.md#manim.typing.RGB_Tuple_Float) *|* [*RGB_Array_Int*](manim.typing.md#manim.typing.RGB_Array_Int) *|* [*RGB_Tuple_Int*](manim.typing.md#manim.typing.RGB_Tuple_Int)) – Any iterable of 3 floats or 3 integers.
+ * **alpha** (*float*) – Alpha value to be used in the color. Default is 1.0.
+* **Returns:**
+ The [`ManimColor`](#manim.utils.color.core.ManimColor) which corresponds to the given `rgb`.
+* **Return type:**
+ [ManimColor](#manim.utils.color.core.ManimColor)
+
+#### *classmethod* from_rgba(rgba)
+
+Create a ManimColor from an RGBA Array. Automagically decides which type it
+is: `int` or `float`.
+
+#### WARNING
+Please make sure that your elements are not floats if you want integers. A
+`5.0` will result in the input being interpreted as if it was a float RGB
+array with the float `5.0` and not the integer `5`.
+
+* **Parameters:**
+ **rgba** ([*RGBA_Array_Float*](manim.typing.md#manim.typing.RGBA_Array_Float) *|* [*RGBA_Tuple_Float*](manim.typing.md#manim.typing.RGBA_Tuple_Float) *|* [*RGBA_Array_Int*](manim.typing.md#manim.typing.RGBA_Array_Int) *|* [*RGBA_Tuple_Int*](manim.typing.md#manim.typing.RGBA_Tuple_Int)) – Any iterable of 4 floats or 4 integers.
+* **Returns:**
+ The [`ManimColor`](#manim.utils.color.core.ManimColor) corresponding to the given `rgba`.
+* **Return type:**
+ [ManimColor](#manim.utils.color.core.ManimColor)
+
+#### *static* gradient(colors, length)
+
+This method is currently not implemented. Refer to [`color_gradient()`](manim.utils.color.core.md#manim.utils.color.core.color_gradient) for
+a working implementation for now.
+
+* **Parameters:**
+ * **colors** (*list* *[*[*ManimColor*](#manim.utils.color.core.ManimColor) *]*)
+ * **length** (*int*)
+* **Return type:**
+ [*ManimColor*](#manim.utils.color.core.ManimColor) | list[[*ManimColor*](#manim.utils.color.core.ManimColor)]
+
+#### interpolate(other, alpha)
+
+Interpolate between the current and the given [`ManimColor`](#manim.utils.color.core.ManimColor), and return
+the result.
+
+* **Parameters:**
+ * **other** (*Self*) – The other [`ManimColor`](#manim.utils.color.core.ManimColor) to be used for interpolation.
+ * **alpha** (*float*) – A point on the line in RGBA colorspace connecting the two colors, i.e. the
+ interpolation point. 0.0 corresponds to the current [`ManimColor`](#manim.utils.color.core.ManimColor) and
+ 1.0 corresponds to the other [`ManimColor`](#manim.utils.color.core.ManimColor).
+* **Returns:**
+ The interpolated [`ManimColor`](#manim.utils.color.core.ManimColor).
+* **Return type:**
+ [ManimColor](#manim.utils.color.core.ManimColor)
+
+#### into(class_type)
+
+Convert the current color into a different colorspace given by `class_type`,
+without changing the [`_internal_value`](#manim.utils.color.core.ManimColor._internal_value).
+
+* **Parameters:**
+ **class_type** (*type* *[*[*ManimColorT*](manim.utils.color.core.md#manim.utils.color.core.ManimColorT) *]*) – The class that is used for conversion. It must be a subclass of
+ [`ManimColor`](#manim.utils.color.core.ManimColor) which respects the specification HSV, RGBA, …
+* **Returns:**
+ A new color object of type `class_type` and the same
+ [`_internal_value`](#manim.utils.color.core.ManimColor._internal_value) as the original color.
+* **Return type:**
+ [ManimColorT](manim.utils.color.core.md#manim.utils.color.core.ManimColorT)
+
+#### invert(with_alpha=False)
+
+Return a new, linearly inverted version of this [`ManimColor`](#manim.utils.color.core.ManimColor) (no
+inplace changes).
+
+* **Parameters:**
+ **with_alpha** (*bool*) –
+
+ If `True`, the alpha value will be inverted too. Default is `False`.
+
+ #### NOTE
+ Setting `with_alpha=True` can result in unintended behavior where
+ objects are not displayed because their new alpha value is suddenly 0 or
+ very low.
+* **Returns:**
+ The linearly inverted [`ManimColor`](#manim.utils.color.core.ManimColor).
+* **Return type:**
+ [ManimColor](#manim.utils.color.core.ManimColor)
+
+#### lighter(blend=0.2)
+
+Return a new color that is lighter than the current color, i.e.
+interpolated with `WHITE`. The opacity is unchanged.
+
+* **Parameters:**
+ **blend** (*float*) – The blend ratio for the interpolation, from 0.0 (the current color
+ unchanged) to 1.0 (pure white). Default is 0.2, which results in a
+ slightly lighter color.
+* **Returns:**
+ The lighter [`ManimColor`](#manim.utils.color.core.ManimColor).
+* **Return type:**
+ [ManimColor](#manim.utils.color.core.ManimColor)
+
+#### SEE ALSO
+[`darker()`](#manim.utils.color.core.ManimColor.darker)
+
+#### opacity(opacity)
+
+Create a new [`ManimColor`](#manim.utils.color.core.ManimColor) with the given opacity and the same color
+values as before.
+
+* **Parameters:**
+ **opacity** (*float*) – The new opacity value to be used.
+* **Returns:**
+ The new [`ManimColor`](#manim.utils.color.core.ManimColor) with the same color values and the new opacity.
+* **Return type:**
+ [ManimColor](#manim.utils.color.core.ManimColor)
+
+#### *classmethod* parse(color: [ParsableManimColor](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor) | None, alpha: float = 1.0) → Self
+
+#### *classmethod* parse(color: Sequence[[ParsableManimColor](manim.utils.color.core.md#manim.utils.color.core.ParsableManimColor)], alpha: float = 1.0) → list[Self]
+
+Parse one color as a [`ManimColor`](#manim.utils.color.core.ManimColor) or a sequence of colors as a list of
+[`ManimColor`](#manim.utils.color.core.ManimColor)’s.
+
+* **Parameters:**
+ * **color** – The color or list of colors to parse. Note that this function can not accept
+ tuples: it will assume that you mean `Sequence[ParsableManimColor]` and will
+ return a `list[ManimColor]`.
+ * **alpha** – The alpha (opacity) value to use for the passed color(s).
+* **Returns:**
+ Either a list of colors or a singular color, depending on the input.
+* **Return type:**
+ [ManimColor](#manim.utils.color.core.ManimColor) | list[[ManimColor](#manim.utils.color.core.ManimColor)]
+
+#### to_hex(with_alpha=False)
+
+Convert the [`ManimColor`](#manim.utils.color.core.ManimColor) to a hexadecimal representation of the color.
+
+* **Parameters:**
+ **with_alpha** (*bool*) – If `True`, append 2 extra characters to the hex string which represent the
+ alpha value of the color between 0 and 255. Default is `False`.
+* **Returns:**
+ A hex string starting with a `#`, with either 6 or 8 nibbles depending on
+ the `with_alpha` parameter. By default, it has 6 nibbles, i.e. `#XXXXXX`.
+* **Return type:**
+ str
+
+#### to_hsl()
+
+Convert the [`ManimColor`](#manim.utils.color.core.ManimColor) to an HSL array.
+
+#### NOTE
+Be careful: this returns an array in the form `[h, s, l]`, where the
+elements are floats. This might be confusing, because RGB can also be an array
+of floats. You might want to annotate the usage of this function in your code
+by typing your HSL array variables as `HSL_Array_Float` in order to
+differentiate them from RGB arrays.
+
+* **Returns:**
+ An HSL array of 3 floats from 0.0 to 1.0.
+* **Return type:**
+ [HSL_Array_Float](manim.typing.md#manim.typing.HSL_Array_Float)
+
+#### to_hsv()
+
+Convert the [`ManimColor`](#manim.utils.color.core.ManimColor) to an HSV array.
+
+#### NOTE
+Be careful: this returns an array in the form `[h, s, v]`, where the
+elements are floats. This might be confusing, because RGB can also be an array
+of floats. You might want to annotate the usage of this function in your code
+by typing your HSV array variables as `HSV_Array_Float` in order to
+differentiate them from RGB arrays.
+
+* **Returns:**
+ An HSV array of 3 floats from 0.0 to 1.0.
+* **Return type:**
+ [HSV_Array_Float](manim.typing.md#manim.typing.HSV_Array_Float)
+
+#### to_int_rgb()
+
+Convert the current [`ManimColor`](#manim.utils.color.core.ManimColor) into an RGB array of integers.
+
+* **Returns:**
+ RGB array of 3 integers from 0 to 255.
+* **Return type:**
+ [RGB_Array_Int](manim.typing.md#manim.typing.RGB_Array_Int)
+
+#### to_int_rgba()
+
+Convert the current ManimColor into an RGBA array of integers.
+
+* **Returns:**
+ RGBA array of 4 integers from 0 to 255.
+* **Return type:**
+ [RGBA_Array_Int](manim.typing.md#manim.typing.RGBA_Array_Int)
+
+#### to_int_rgba_with_alpha(alpha)
+
+Convert the current [`ManimColor`](#manim.utils.color.core.ManimColor) into an RGBA array of integers. This
+is similar to [`to_int_rgba()`](#manim.utils.color.core.ManimColor.to_int_rgba), but you can change the alpha value.
+
+* **Parameters:**
+ **alpha** (*float*) – Alpha value to be used for the return value. Pass a float between 0.0 and
+ 1.0: it will automatically be scaled to an integer between 0 and 255.
+* **Returns:**
+ RGBA array of 4 integers from 0 to 255.
+* **Return type:**
+ [RGBA_Array_Int](manim.typing.md#manim.typing.RGBA_Array_Int)
+
+#### to_integer()
+
+Convert the current [`ManimColor`](#manim.utils.color.core.ManimColor) into an integer.
+
+#### WARNING
+This will return only the RGB part of the color.
+
+* **Returns:**
+ Integer representation of the color.
+* **Return type:**
+ int
+
+#### to_rgb()
+
+Convert the current [`ManimColor`](#manim.utils.color.core.ManimColor) into an RGB array of floats.
+
+* **Returns:**
+ RGB array of 3 floats from 0.0 to 1.0.
+* **Return type:**
+ [RGB_Array_Float](manim.typing.md#manim.typing.RGB_Array_Float)
+
+#### to_rgba()
+
+Convert the current [`ManimColor`](#manim.utils.color.core.ManimColor) into an RGBA array of floats.
+
+* **Returns:**
+ RGBA array of 4 floats from 0.0 to 1.0.
+* **Return type:**
+ [RGBA_Array_Float](manim.typing.md#manim.typing.RGBA_Array_Float)
+
+#### to_rgba_with_alpha(alpha)
+
+Convert the current [`ManimColor`](#manim.utils.color.core.ManimColor) into an RGBA array of floats. This is
+similar to [`to_rgba()`](#manim.utils.color.core.ManimColor.to_rgba), but you can change the alpha value.
+
+* **Parameters:**
+ **alpha** (*float*) – Alpha value to be used in the return value.
+* **Returns:**
+ RGBA array of 4 floats from 0.0 to 1.0.
+* **Return type:**
+ [RGBA_Array_Float](manim.typing.md#manim.typing.RGBA_Array_Float)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.core.RGBA.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.core.RGBA.md
new file mode 100644
index 0000000000000000000000000000000000000000..e69dea8a2d1cc4293bf10e0172d08f2c6bc862a3
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.core.RGBA.md
@@ -0,0 +1,35 @@
+# RGBA
+
+Qualified name: `manim.utils.color.core.RGBA`
+
+### RGBA
+
+RGBA Color Space
+
+### Methods
+
+| `contrasting` | Return one of two colors, light or dark (by default white or black), that contrasts with the current color (depending on its luminance). |
+|--------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `darker` | Return a new color that is darker than the current color, i.e. interpolated with `BLACK`. |
+| `from_hex` | Create a [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) from a hex string. |
+| `from_hsl` | Create a [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) from an HSL array. |
+| `from_hsv` | Create a [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) from an HSV array. |
+| `from_rgb` | Create a ManimColor from an RGB array. |
+| `from_rgba` | Create a ManimColor from an RGBA Array. |
+| `gradient` | This method is currently not implemented. |
+| `interpolate` | Interpolate between the current and the given [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor), and return the result. |
+| `into` | Convert the current color into a different colorspace given by `class_type`, without changing the `_internal_value`. |
+| `invert` | Return a new, linearly inverted version of this [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) (no inplace changes). |
+| `lighter` | Return a new color that is lighter than the current color, i.e. interpolated with `WHITE`. |
+| `opacity` | Create a new [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) with the given opacity and the same color values as before. |
+| `parse` | Parse one color as a [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) or a sequence of colors as a list of [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)'s. |
+| `to_hex` | Convert the [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) to a hexadecimal representation of the color. |
+| `to_hsl` | Convert the [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) to an HSL array. |
+| `to_hsv` | Convert the [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) to an HSV array. |
+| `to_int_rgb` | Convert the current [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) into an RGB array of integers. |
+| `to_int_rgba` | Convert the current ManimColor into an RGBA array of integers. |
+| `to_int_rgba_with_alpha` | Convert the current [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) into an RGBA array of integers. |
+| `to_integer` | Convert the current [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) into an integer. |
+| `to_rgb` | Convert the current [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) into an RGB array of floats. |
+| `to_rgba` | Convert the current [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) into an RGBA array of floats. |
+| `to_rgba_with_alpha` | Convert the current [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) into an RGBA array of floats. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.core.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.core.md
new file mode 100644
index 0000000000000000000000000000000000000000..1cfc742ee0dac28759311f9e68eb86b801bfb9f1
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.core.md
@@ -0,0 +1,277 @@
+# core
+
+Manim’s (internal) color data structure and some utilities for color conversion.
+
+This module contains the implementation of [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor), the data structure
+internally used to represent colors.
+
+The preferred way of using these colors is by importing their constants from Manim:
+
+```pycon
+>>> from manim import RED, GREEN, BLUE
+>>> print(RED)
+#FC6255
+```
+
+Note that this way uses the name of the colors in UPPERCASE.
+
+#### NOTE
+The colors with a `_C` suffix have an alias equal to the colorname without a
+letter. For example, `GREEN = GREEN_C`.
+
+## Custom Color Spaces
+
+Hello, dear visitor. You seem to be interested in implementing a custom color class for
+a color space we don’t currently support.
+
+The current system is using a few indirections for ensuring a consistent behavior with
+all other color types in Manim.
+
+To implement a custom color space, you must subclass [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) and implement
+three important methods:
+
+> - [`_internal_value`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor._internal_value): a `@property` implemented on
+> [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) with the goal of keeping a consistent internal representation
+> which can be referenced by other functions in [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor). This property acts
+> as a proxy to whatever representation you need in your class.
+> > - The getter should always return a NumPy array in the format `[r,g,b,a]`, in
+> > accordance with the type `ManimColorInternal`.
+> > - The setter should always accept a value in the format `[r,g,b,a]` which can be
+> > converted to whatever attributes you need.
+> - [`_internal_space`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor._internal_space): a read-only `@property` implemented on
+> [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) with the goal of providing a useful representation which can be
+> used by operators, interpolation and color transform functions.
+
+> The only constraints on this value are:
+> > - It must be a NumPy array.
+> > - The last value must be the opacity in a range `0.0` to `1.0`.
+
+> Additionally, your `__init__` must support this format as an initialization value
+> without additional parameters to ensure correct functionality of all other methods in
+> [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor).
+> - [`_from_internal()`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor._from_internal): a `@classmethod` which converts an
+> `[r,g,b,a]` value into suitable parameters for your `__init__` method and calls
+> the `cls` parameter.
+
+### Type Aliases
+
+### *class* ParsableManimColor
+
+```default
+ManimColor | int | str | [`RGB_Tuple_Int`](manim.typing.md#manim.typing.RGB_Tuple_Int) | [`RGB_Tuple_Float`](manim.typing.md#manim.typing.RGB_Tuple_Float) | [`RGBA_Tuple_Int`](manim.typing.md#manim.typing.RGBA_Tuple_Int) | [`RGBA_Tuple_Float`](manim.typing.md#manim.typing.RGBA_Tuple_Float) | [`RGB_Array_Int`](manim.typing.md#manim.typing.RGB_Array_Int) | [`RGB_Array_Float`](manim.typing.md#manim.typing.RGB_Array_Float) | [`RGBA_Array_Int`](manim.typing.md#manim.typing.RGBA_Array_Int) | [`RGBA_Array_Float`](manim.typing.md#manim.typing.RGBA_Array_Float)
+```
+
+[`ParsableManimColor`](#manim.utils.color.core.ParsableManimColor) represents all the types which can be parsed
+to a [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) in Manim.
+
+### TypeVar’s
+
+### *class* ManimColorT
+
+```default
+TypeVar('ManimColorT', bound=ManimColor)
+```
+
+### Classes
+
+| [`HSV`](manim.utils.color.core.HSV.md#manim.utils.color.core.HSV) | HSV Color Space |
+|----------------------------------------------------------------------------------------|-------------------------------------|
+| [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) | Internal representation of a color. |
+| [`RGBA`](manim.utils.color.core.RGBA.md#manim.utils.color.core.RGBA) | RGBA Color Space |
+
+### Functions
+
+### average_color(\*colors)
+
+Determine the average color between the given parameters.
+
+#### NOTE
+This operation does not consider the alphas (opacities) of the colors. The
+generated color has an alpha or opacity of 1.0.
+
+* **Returns:**
+ The average color of the input.
+* **Return type:**
+ [ManimColor](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+* **Parameters:**
+ **colors** ([*ParsableManimColor*](#manim.utils.color.core.ParsableManimColor))
+
+### color_gradient(reference_colors, length_of_output)
+
+Create a list of colors interpolated between the input array of colors with a
+specific number of colors.
+
+* **Parameters:**
+ * **reference_colors** (*Sequence* *[*[*ParsableManimColor*](#manim.utils.color.core.ParsableManimColor) *]*) – The colors to be interpolated between or spread apart.
+ * **length_of_output** (*int*) – The number of colors that the output should have, ideally more than the input.
+* **Returns:**
+ A [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) or a list of interpolated [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)’s.
+* **Return type:**
+ list[[ManimColor](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)] | [ManimColor](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+
+### color_to_int_rgb(color)
+
+Helper function for use in functional style programming. Refer to
+[`ManimColor.to_int_rgb()`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor.to_int_rgb).
+
+* **Parameters:**
+ **color** ([*ParsableManimColor*](#manim.utils.color.core.ParsableManimColor)) – A color to convert to an RGB integer array.
+* **Returns:**
+ The corresponding RGB integer array.
+* **Return type:**
+ [RGB_Array_Int](manim.typing.md#manim.typing.RGB_Array_Int)
+
+### color_to_int_rgba(color, alpha=1.0)
+
+Helper function for use in functional style programming. Refer to
+[`ManimColor.to_int_rgba_with_alpha()`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor.to_int_rgba_with_alpha).
+
+* **Parameters:**
+ * **color** ([*ParsableManimColor*](#manim.utils.color.core.ParsableManimColor)) – A color to convert to an RGBA integer array.
+ * **alpha** (*float*) – An alpha value between 0.0 and 1.0 to be used as opacity in the color. Default is
+ 1.0.
+* **Returns:**
+ The corresponding RGBA integer array.
+* **Return type:**
+ [RGBA_Array_Int](manim.typing.md#manim.typing.RGBA_Array_Int)
+
+### color_to_rgb(color)
+
+Helper function for use in functional style programming.
+Refer to [`ManimColor.to_rgb()`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor.to_rgb).
+
+* **Parameters:**
+ **color** ([*ParsableManimColor*](#manim.utils.color.core.ParsableManimColor)) – A color to convert to an RGB float array.
+* **Returns:**
+ The corresponding RGB float array.
+* **Return type:**
+ [RGB_Array_Float](manim.typing.md#manim.typing.RGB_Array_Float)
+
+### color_to_rgba(color, alpha=1.0)
+
+Helper function for use in functional style programming. Refer to
+[`ManimColor.to_rgba_with_alpha()`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor.to_rgba_with_alpha).
+
+* **Parameters:**
+ * **color** ([*ParsableManimColor*](#manim.utils.color.core.ParsableManimColor)) – A color to convert to an RGBA float array.
+ * **alpha** (*float*) – An alpha value between 0.0 and 1.0 to be used as opacity in the color. Default is
+ 1.0.
+* **Returns:**
+ The corresponding RGBA float array.
+* **Return type:**
+ [RGBA_Array_Float](manim.typing.md#manim.typing.RGBA_Array_Float)
+
+### get_shaded_rgb(rgb, point, unit_normal_vect, light_source)
+
+Add light or shadow to the `rgb` color of some surface which is located at a
+given `point` in space and facing in the direction of `unit_normal_vect`,
+depending on whether the surface is facing a `light_source` or away from it.
+
+* **Parameters:**
+ * **rgb** ([*RGB_Array_Float*](manim.typing.md#manim.typing.RGB_Array_Float)) – An RGB array of floats.
+ * **point** ([*Point3D*](manim.typing.md#manim.typing.Point3D)) – The location of the colored surface.
+ * **unit_normal_vect** ([*Vector3D*](manim.typing.md#manim.typing.Vector3D)) – The direction in which the colored surface is facing.
+ * **light_source** ([*Point3D*](manim.typing.md#manim.typing.Point3D)) – The location of a light source which might illuminate the surface.
+* **Returns:**
+ The color with added light or shadow, depending on the direction of the colored
+ surface.
+* **Return type:**
+ [RGB_Array_Float](manim.typing.md#manim.typing.RGB_Array_Float)
+
+### hex_to_rgb(hex_code)
+
+Helper function for use in functional style programming. Refer to
+[`ManimColor.to_rgb()`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor.to_rgb).
+
+* **Parameters:**
+ **hex_code** (*str*) – A hex string representing a color.
+* **Returns:**
+ An RGB array representing the color.
+* **Return type:**
+ [RGB_Array_Float](manim.typing.md#manim.typing.RGB_Array_Float)
+
+### interpolate_color(color1, color2, alpha)
+
+Standalone function to interpolate two ManimColors and get the result. Refer to
+[`ManimColor.interpolate()`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor.interpolate).
+
+* **Parameters:**
+ * **color1** ([*ManimColorT*](#manim.utils.color.core.ManimColorT)) – The first [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor).
+ * **color2** ([*ManimColorT*](#manim.utils.color.core.ManimColorT)) – The second [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor).
+ * **alpha** (*float*) – The alpha value determining the point of interpolation between the colors.
+* **Returns:**
+ The interpolated ManimColor.
+* **Return type:**
+ [ManimColor](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+
+### invert_color(color)
+
+Helper function for use in functional style programming. Refer to
+[`ManimColor.invert()`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor.invert)
+
+* **Parameters:**
+ **color** ([*ManimColorT*](#manim.utils.color.core.ManimColorT)) – The [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor) to invert.
+* **Returns:**
+ The linearly inverted [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor).
+* **Return type:**
+ [ManimColor](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+
+### random_bright_color()
+
+Return a random bright color: a random color averaged with `WHITE`.
+
+#### WARNING
+This operation is very expensive. Please keep in mind the performance loss.
+
+* **Returns:**
+ A random bright [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor).
+* **Return type:**
+ [ManimColor](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+
+### random_color()
+
+Return a random [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor).
+
+#### WARNING
+This operation is very expensive. Please keep in mind the performance loss.
+
+* **Returns:**
+ A random [`ManimColor`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor).
+* **Return type:**
+ [ManimColor](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+
+### rgb_to_color(rgb)
+
+Helper function for use in functional style programming. Refer to
+[`ManimColor.from_rgb()`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor.from_rgb).
+
+* **Parameters:**
+ **rgb** ([*RGB_Array_Float*](manim.typing.md#manim.typing.RGB_Array_Float) *|* [*RGB_Tuple_Float*](manim.typing.md#manim.typing.RGB_Tuple_Float) *|* [*RGB_Array_Int*](manim.typing.md#manim.typing.RGB_Array_Int) *|* [*RGB_Tuple_Int*](manim.typing.md#manim.typing.RGB_Tuple_Int)) – A 3 element iterable.
+* **Returns:**
+ A ManimColor with the corresponding value.
+* **Return type:**
+ [ManimColor](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
+
+### rgb_to_hex(rgb)
+
+Helper function for use in functional style programming. Refer to
+[`ManimColor.from_rgb()`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor.from_rgb) and [`ManimColor.to_hex()`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor.to_hex).
+
+* **Parameters:**
+ **rgb** ([*RGB_Array_Float*](manim.typing.md#manim.typing.RGB_Array_Float) *|* [*RGB_Tuple_Float*](manim.typing.md#manim.typing.RGB_Tuple_Float) *|* [*RGB_Array_Int*](manim.typing.md#manim.typing.RGB_Array_Int) *|* [*RGB_Tuple_Int*](manim.typing.md#manim.typing.RGB_Tuple_Int)) – A 3 element iterable.
+* **Returns:**
+ A hex representation of the color.
+* **Return type:**
+ str
+
+### rgba_to_color(rgba)
+
+Helper function for use in functional style programming. Refer to
+[`ManimColor.from_rgba()`](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor.from_rgba).
+
+* **Parameters:**
+ **rgba** ([*RGBA_Array_Float*](manim.typing.md#manim.typing.RGBA_Array_Float) *|* [*RGBA_Tuple_Float*](manim.typing.md#manim.typing.RGBA_Tuple_Float) *|* [*RGBA_Array_Int*](manim.typing.md#manim.typing.RGBA_Array_Int) *|* [*RGBA_Tuple_Int*](manim.typing.md#manim.typing.RGBA_Tuple_Int)) – A 4 element iterable.
+* **Returns:**
+ A ManimColor with the corresponding value
+* **Return type:**
+ [ManimColor](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.manim_colors.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.manim_colors.md
new file mode 100644
index 0000000000000000000000000000000000000000..c623c997568a48063db63d06ceeb83ba18b214a6
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.manim_colors.md
@@ -0,0 +1,53 @@
+# manim_colors
+
+Colors included in the global name space.
+
+These colors form Manim’s default color space.
+
+
+
+| Color Name | RGB Hex Code | Color Name | RGB Hex Code |
+|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------|----------------|--------------------------------------------------------------------------------------------------------------------------------------------------|
+| `BLACK` |
#000000
| `BLUE` |
#58C4DD
|
+| `BLUE_A` |
#C7E9F1
| `BLUE_B` |
#9CDCEB
|
+| `BLUE_C` |
#58C4DD
| `BLUE_D` |
#29ABCA
|
+| `BLUE_E` |
#236B8E
| `DARKER_GRAY` |
#222222
|
+| `DARKER_GREY` |
#222222
| `DARK_BLUE` |
#236B8E
|
+| `DARK_BROWN` |
#8B4513
| `DARK_GRAY` |
#444444
|
+| `DARK_GREY` |
#444444
| `GOLD` |
#F0AC5F
|
+| `GOLD_A` |
#F7C797
| `GOLD_B` |
#F9B775
|
+| `GOLD_C` |
#F0AC5F
| `GOLD_D` |
#E1A158
|
+| `GOLD_E` |
#C78D46
| `GRAY` |
#888888
|
+| `GRAY_A` |
#DDDDDD
| `GRAY_B` |
#BBBBBB
|
+| `GRAY_BROWN` |
#736357
| `GRAY_C` |
#888888
|
+| `GRAY_D` |
#444444
| `GRAY_E` |
#222222
|
+| `GREEN` |
#83C167
| `GREEN_A` |
#C9E2AE
|
+| `GREEN_B` |
#A6CF8C
| `GREEN_C` |
#83C167
|
+| `GREEN_D` |
#77B05D
| `GREEN_E` |
#699C52
|
+| `GREY` |
#888888
| `GREY_A` |
#DDDDDD
|
+| `GREY_B` |
#BBBBBB
| `GREY_BROWN` |
#736357
|
+| `GREY_C` |
#888888
| `GREY_D` |
#444444
|
+| `GREY_E` |
#222222
| `LIGHTER_GRAY` |
#DDDDDD
|
+| `LIGHTER_GREY` |
#DDDDDD
| `LIGHT_BROWN` |
#CD853F
|
+| `LIGHT_GRAY` |
#BBBBBB
| `LIGHT_GREY` |
#BBBBBB
|
+| `LIGHT_PINK` |
#DC75CD
| `LOGO_BLACK` |
#343434
|
+| `LOGO_BLUE` |
#525893
| `LOGO_GREEN` |
#87C2A5
|
+| `LOGO_RED` |
#E07A5F
| `LOGO_WHITE` |
#ECE7E2
|
+| `MAROON` |
#C55F73
| `MAROON_A` |
#ECABC1
|
+| `MAROON_B` |
#EC92AB
| `MAROON_C` |
#C55F73
|
+| `MAROON_D` |
#A24D61
| `MAROON_E` |
#94424F
|
+| `ORANGE` |
#FF862F
| `PINK` |
#D147BD
|
+| `PURE_BLUE` |
#0000FF
| `PURE_GREEN` |
#00FF00
|
+| `PURE_RED` |
#FF0000
| `PURPLE` |
#9A72AC
|
+| `PURPLE_A` |
#CAA3E8
| `PURPLE_B` |
#B189C6
|
+| `PURPLE_C` |
#9A72AC
| `PURPLE_D` |
#715582
|
+| `PURPLE_E` |
#644172
| `RED` |
#FC6255
|
+| `RED_A` |
#F7A1A3
| `RED_B` |
#FF8080
|
+| `RED_C` |
#FC6255
| `RED_D` |
#E65A4C
|
+| `RED_E` |
#CF5044
| `TEAL` |
#5CD0B3
|
+| `TEAL_A` |
#ACEAD7
| `TEAL_B` |
#76DDC0
|
+| `TEAL_C` |
#5CD0B3
| `TEAL_D` |
#55C1A7
|
+| `TEAL_E` |
#49A88F
| `WHITE` |
#FFFFFF
|
+| `YELLOW` |
#FFFF00
| `YELLOW_A` |
#FFF1B6
|
+| `YELLOW_B` |
#FFEA94
| `YELLOW_C` |
#FFFF00
|
+| `YELLOW_D` |
#F4D345
| `YELLOW_E` |
#E8C11C
|
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.md
new file mode 100644
index 0000000000000000000000000000000000000000..0064f4c6155d80e4afb16617ce01f08d43218c82
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.color.md
@@ -0,0 +1,42 @@
+# color
+
+Utilities for working with colors and predefined color constants.
+
+## Color data structure
+
+| [`core`](manim.utils.color.core.md#module-manim.utils.color.core) | Manim's (internal) color data structure and some utilities for color conversion. |
+|---------------------------------------------------------------------|------------------------------------------------------------------------------------|
+
+## Predefined colors
+
+There are several predefined colors available in Manim:
+
+- The colors listed in [`color.manim_colors`](manim.utils.color.manim_colors.md#module-manim.utils.color.manim_colors) are loaded into
+ Manim’s global name space.
+- The colors in [`color.AS2700`](manim.utils.color.AS2700.md#module-manim.utils.color.AS2700), [`color.BS381`](manim.utils.color.BS381.md#module-manim.utils.color.BS381),
+ [`color.DVIPSNAMES`](manim.utils.color.DVIPSNAMES.md#module-manim.utils.color.DVIPSNAMES), [`color.SVGNAMES`](manim.utils.color.SVGNAMES.md#module-manim.utils.color.SVGNAMES), [`color.X11`](manim.utils.color.X11.md#module-manim.utils.color.X11) and
+ [`color.XKCD`](manim.utils.color.XKCD.md#module-manim.utils.color.XKCD) need to be accessed via their module (which are available
+ in Manim’s global name space), or imported separately. For example:
+ ```pycon
+ >>> from manim import XKCD
+ >>> XKCD.AVOCADO
+ ManimColor('#90B134')
+ ```
+
+ Or, alternatively:
+ ```pycon
+ >>> from manim.utils.color.XKCD import AVOCADO
+ >>> AVOCADO
+ ManimColor('#90B134')
+ ```
+
+The following modules contain the predefined color constants:
+
+| [`manim_colors`](manim.utils.color.manim_colors.md#module-manim.utils.color.manim_colors) | Colors included in the global name space. |
+|---------------------------------------------------------------------------------------------|---------------------------------------------|
+| [`AS2700`](manim.utils.color.AS2700.md#module-manim.utils.color.AS2700) | Australian Color Standard |
+| [`BS381`](manim.utils.color.BS381.md#module-manim.utils.color.BS381) | British Color Standard |
+| [`DVIPSNAMES`](manim.utils.color.DVIPSNAMES.md#module-manim.utils.color.DVIPSNAMES) | dvips Colors |
+| [`SVGNAMES`](manim.utils.color.SVGNAMES.md#module-manim.utils.color.SVGNAMES) | SVG 1.1 Colors |
+| [`XKCD`](manim.utils.color.XKCD.md#module-manim.utils.color.XKCD) | Colors from the XKCD Color Name Survey |
+| [`X11`](manim.utils.color.X11.md#module-manim.utils.color.X11) | X11 Colors |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.commands.VideoMetadata.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.commands.VideoMetadata.md
new file mode 100644
index 0000000000000000000000000000000000000000..3c084f7afd92810867c856f897f6f5d8bda3439a
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.commands.VideoMetadata.md
@@ -0,0 +1,20 @@
+# VideoMetadata
+
+Qualified name: `manim.utils.commands.VideoMetadata`
+
+### *class* VideoMetadata
+
+Bases: `TypedDict`
+
+### Methods
+
+### Attributes
+
+| `width` | |
+|------------------|----|
+| `height` | |
+| `nb_frames` | |
+| `duration` | |
+| `avg_frame_rate` | |
+| `codec_name` | |
+| `pix_fmt` | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.commands.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.commands.md
new file mode 100644
index 0000000000000000000000000000000000000000..9eb53c50f30bee21c04efb8915bd544605cee062
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.commands.md
@@ -0,0 +1,33 @@
+# commands
+
+### Classes
+
+| [`VideoMetadata`](manim.utils.commands.VideoMetadata.md#manim.utils.commands.VideoMetadata) | |
+|-----------------------------------------------------------------------------------------------|----|
+
+### Functions
+
+### capture(command, cwd=None, command_input=None)
+
+* **Parameters:**
+ * **command** (*str*)
+ * **cwd** ([*StrOrBytesPath*](manim.typing.md#manim.typing.StrOrBytesPath) *|* *None*)
+ * **command_input** (*str* *|* *None*)
+* **Return type:**
+ tuple[str, str, int]
+
+### get_dir_layout(dirpath)
+
+Get list of paths relative to dirpath of all files in dir and subdirs recursively.
+
+* **Parameters:**
+ **dirpath** (*Path*)
+* **Return type:**
+ *Generator*[str, None, None]
+
+### get_video_metadata(path_to_video)
+
+* **Parameters:**
+ **path_to_video** (*str* *|* *PathLike*)
+* **Return type:**
+ [*VideoMetadata*](manim.utils.commands.VideoMetadata.md#manim.utils.commands.VideoMetadata)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.config_ops.DictAsObject.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.config_ops.DictAsObject.md
new file mode 100644
index 0000000000000000000000000000000000000000..378133910b73ba635474cb43ea62ee4d837443f8
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.config_ops.DictAsObject.md
@@ -0,0 +1,12 @@
+# DictAsObject
+
+Qualified name: `manim.utils.config\_ops.DictAsObject`
+
+### *class* DictAsObject(dictin)
+
+Bases: `object`
+
+### Methods
+
+* **Parameters:**
+ **dictin** (*dict* *[**str* *,* *Any* *]*)
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.config_ops.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.config_ops.md
new file mode 100644
index 0000000000000000000000000000000000000000..3fd9484aecc4aadbc562425d4418764721f2c0d5
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.config_ops.md
@@ -0,0 +1,33 @@
+# config_ops
+
+Utilities that might be useful for configuration dictionaries.
+
+### Classes
+
+| [`DictAsObject`](manim.utils.config_ops.DictAsObject.md#manim.utils.config_ops.DictAsObject) | |
+|------------------------------------------------------------------------------------------------|----|
+
+### Functions
+
+### merge_dicts_recursively(\*dicts)
+
+Creates a dict whose keyset is the union of all the
+input dictionaries. The value for each key is based
+on the first dict in the list with that key.
+
+dicts later in the list have higher priority
+
+When values are dictionaries, it is applied recursively
+
+* **Parameters:**
+ **dicts** (*dict* *[**Any* *,* *Any* *]*)
+* **Return type:**
+ dict[*Any*, *Any*]
+
+### update_dict_recursively(current_dict, \*others)
+
+* **Parameters:**
+ * **current_dict** (*dict* *[**Any* *,* *Any* *]*)
+ * **others** (*dict* *[**Any* *,* *Any* *]*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.debug.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.debug.md
new file mode 100644
index 0000000000000000000000000000000000000000..ca6cb8429d166432cb86cc75dfa7c10823d21a2f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.debug.md
@@ -0,0 +1,77 @@
+# debug
+
+Debugging utilities.
+
+### Functions
+
+### index_labels(mobject, label_height=0.15, background_stroke_width=5, background_stroke_color=ManimColor('#000000'), \*\*kwargs)
+
+Returns a [`VGroup`](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup) of [`Integer`](manim.mobject.text.numbers.Integer.md#manim.mobject.text.numbers.Integer) mobjects
+that shows the index of each submobject.
+
+Useful for working with parts of complicated mobjects.
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject)) – The mobject that will have its submobjects labelled.
+ * **label_height** (*float*) – The height of the labels, by default 0.15.
+ * **background_stroke_width** (*float*) – The stroke width of the outline of the labels, by default 5.
+ * **background_stroke_color** ([*ManimColor*](manim.utils.color.core.ManimColor.md#manim.utils.color.core.ManimColor)) – The stroke color of the outline of labels.
+ * **kwargs** (*Any*) – Additional parameters to be passed into the :class\`~.Integer\`
+ mobjects used to construct the labels.
+* **Return type:**
+ [*VGroup*](manim.mobject.types.vectorized_mobject.VGroup.md#manim.mobject.types.vectorized_mobject.VGroup)
+
+### Examples
+
+
+```python
+from manim import *
+
+class IndexLabelsExample(Scene):
+ def construct(self):
+ text = MathTex(
+ "\\frac{d}{dx}f(x)g(x)=",
+ "f(x)\\frac{d}{dx}g(x)",
+ "+",
+ "g(x)\\frac{d}{dx}f(x)",
+ )
+
+ #index the fist term in the MathTex mob
+ indices = index_labels(text[0])
+
+ text[0][1].set_color(PURPLE_B)
+ text[0][8:12].set_color(DARK_BLUE)
+
+ self.add(text, indices)
+```
+
+
+class IndexLabelsExample(Scene):
+ def construct(self):
+ text = MathTex(
+ "\\\\frac{d}{dx}f(x)g(x)=",
+ "f(x)\\\\frac{d}{dx}g(x)",
+ "+",
+ "g(x)\\\\frac{d}{dx}f(x)",
+ )
+
+ #index the fist term in the MathTex mob
+ indices = index_labels(text[0])
+
+ text[0][1].set_color(PURPLE_B)
+ text[0][8:12].set_color(DARK_BLUE)
+
+ self.add(text, indices)
+
+
+
+### print_family(mobject, n_tabs=0)
+
+For debugging purposes
+
+* **Parameters:**
+ * **mobject** ([*Mobject*](manim.mobject.mobject.Mobject.md#manim.mobject.mobject.Mobject))
+ * **n_tabs** (*int*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.deprecation.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.deprecation.md
new file mode 100644
index 0000000000000000000000000000000000000000..4e55e4d8f0682d2c9d0c3cfe421529e452fa2a72
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.deprecation.md
@@ -0,0 +1,255 @@
+# deprecation
+
+Decorators for deprecating classes, functions and function parameters.
+
+### TypeVar’s
+
+### *class* T
+
+```default
+TypeVar('T')
+```
+
+### Functions
+
+### deprecated(func: Callable[[...], [T](#manim.utils.deprecation.T)], since: str | None = None, until: str | None = None, replacement: str | None = None, message: str | None = '') → Callable[[...], [T](#manim.utils.deprecation.T)]
+
+### deprecated(func: None = None, since: str | None = None, until: str | None = None, replacement: str | None = None, message: str | None = '') → Callable[[Callable[[...], [T](#manim.utils.deprecation.T)]], Callable[[...], [T](#manim.utils.deprecation.T)]]
+
+Decorator to mark a callable as deprecated.
+
+The decorated callable will cause a warning when used. The docstring of the
+deprecated callable is adjusted to indicate that this callable is deprecated.
+
+* **Parameters:**
+ * **func** – The function to be decorated. Should not be set by the user.
+ * **since** – The version or date since deprecation.
+ * **until** – The version or date until removal of the deprecated callable.
+ * **replacement** – The identifier of the callable replacing the deprecated one.
+ * **message** – The reason for why the callable has been deprecated.
+* **Returns:**
+ The decorated callable.
+* **Return type:**
+ Callable
+
+### Examples
+
+Basic usage:
+
+```default
+from manim.utils.deprecation import deprecated
+
+@deprecated
+def foo(**kwargs):
+ pass
+
+
+@deprecated
+class Bar:
+ def __init__(self):
+ pass
+
+ @deprecated
+ def baz(self):
+ pass
+
+
+foo()
+# WARNING The function foo has been deprecated and may be removed in a later version.
+
+a = Bar()
+# WARNING The class Bar has been deprecated and may be removed in a later version.
+
+a.baz()
+# WARNING The method Bar.baz has been deprecated and may be removed in a later version.
+```
+
+You can specify additional information for a more precise warning:
+
+```default
+from manim.utils.deprecation import deprecated
+
+
+@deprecated(
+ since="v0.2", until="v0.4", replacement="bar", message="It is cooler."
+)
+def foo():
+ pass
+
+
+foo()
+# WARNING The function foo has been deprecated since v0.2 and is expected to be removed after v0.4. Use bar instead. It is cooler.
+```
+
+You may also use dates instead of versions:
+
+```default
+from manim.utils.deprecation import deprecated
+
+
+@deprecated(since="05/01/2021", until="06/01/2021")
+def foo():
+ pass
+
+
+foo()
+# WARNING The function foo has been deprecated since 05/01/2021 and is expected to be removed after 06/01/2021.
+```
+
+### deprecated_params(params=None, since=None, until=None, message='', redirections=None)
+
+Decorator to mark parameters of a callable as deprecated.
+
+It can also be used to automatically redirect deprecated parameter values to their
+replacements.
+
+* **Parameters:**
+ * **params** (*str* *|* *Iterable* *[**str* *]* *|* *None*) –
+
+ The parameters to be deprecated. Can consist of:
+ * An iterable of strings, with each element representing a parameter to deprecate
+ * A single string, with parameter names separated by commas or spaces.
+ * **since** (*str* *|* *None*) – The version or date since deprecation.
+ * **until** (*str* *|* *None*) – The version or date until removal of the deprecated callable.
+ * **message** (*str*) – The reason for why the callable has been deprecated.
+ * **redirections** (*None* *|* *Iterable* *[**tuple* *[**str* *,* *str* *]* *|* *Callable* *[* *[* *...* *]* *,* *dict* *[**str* *,* *Any* *]* *]* *]*) –
+
+ A list of parameter redirections. Each redirection can be one of the following:
+ * A tuple of two strings. The first string defines the name of the deprecated
+ parameter; the second string defines the name of the parameter to redirect to,
+ when attempting to use the first string.
+ * A function performing the mapping operation. The parameter names of the
+ function determine which parameters are used as input. The function must
+ return a dictionary which contains the redirected arguments.
+
+ Redirected parameters are also implicitly deprecated.
+* **Returns:**
+ The decorated callable.
+* **Return type:**
+ Callable
+* **Raises:**
+ * **ValueError** – If no parameters are defined (neither explicitly nor implicitly).
+ * **ValueError** – If defined parameters are invalid python identifiers.
+
+### Examples
+
+Basic usage:
+
+```default
+from manim.utils.deprecation import deprecated_params
+
+@deprecated_params(params="a, b, c")
+def foo(**kwargs):
+ pass
+
+
+foo(x=2, y=3, z=4)
+# No warning
+
+foo(a=2, b=3, z=4)
+# WARNING The parameters a and b of method foo have been deprecated and may be removed in a later version.
+```
+
+You can also specify additional information for a more precise warning:
+
+```default
+from manim.utils.deprecation import deprecated_params
+
+
+@deprecated_params(
+ params="a, b, c",
+ since="v0.2",
+ until="v0.4",
+ message="The letters x, y, z are cooler.",
+)
+def foo(**kwargs):
+ pass
+
+
+foo(a=2)
+# WARNING The parameter a of method foo has been deprecated since v0.2 and is expected to be removed after v0.4. The letters x, y, z are cooler.
+```
+
+Basic parameter redirection:
+
+```default
+from manim.utils.deprecation import deprecated_params
+
+
+@deprecated_params(
+ redirections=[
+ # Two ways to redirect one parameter to another:
+ ("old_param", "new_param"),
+ lambda old_param2: {"new_param22": old_param2},
+ ]
+)
+def foo(**kwargs):
+ return kwargs
+
+
+foo(x=1, old_param=2)
+# WARNING The parameter old_param of method foo has been deprecated and may be removed in a later version.
+# returns {"x": 1, "new_param": 2}
+```
+
+Redirecting using a calculated value:
+
+```default
+from manim.utils.deprecation import deprecated_params
+
+
+@deprecated_params(
+ redirections=[lambda runtime_in_ms: {"run_time": runtime_in_ms / 1000}]
+)
+def foo(**kwargs):
+ return kwargs
+
+
+foo(runtime_in_ms=500)
+# WARNING The parameter runtime_in_ms of method foo has been deprecated and may be removed in a later version.
+# returns {"run_time": 0.5}
+```
+
+Redirecting multiple parameter values to one:
+
+```default
+from manim.utils.deprecation import deprecated_params
+
+
+@deprecated_params(
+ redirections=[lambda buff_x=1, buff_y=1: {"buff": (buff_x, buff_y)}]
+)
+def foo(**kwargs):
+ return kwargs
+
+
+foo(buff_x=2)
+# WARNING The parameter buff_x of method foo has been deprecated and may be removed in a later version.
+# returns {"buff": (2, 1)}
+```
+
+Redirect one parameter to multiple:
+
+```default
+from manim.utils.deprecation import deprecated_params
+
+
+@deprecated_params(
+ redirections=[
+ lambda buff=1: {"buff_x": buff[0], "buff_y": buff[1]}
+ if isinstance(buff, tuple)
+ else {"buff_x": buff, "buff_y": buff}
+ ]
+)
+def foo(**kwargs):
+ return kwargs
+
+
+foo(buff=0)
+# WARNING The parameter buff of method foo has been deprecated and may be removed in a later version.
+# returns {"buff_x": 0, buff_y: 0}
+
+foo(buff=(1, 2))
+# WARNING The parameter buff of method foo has been deprecated and may be removed in a later version.
+# returns {"buff_x": 1, buff_y: 2}
+```
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.autoaliasattr_directive.AliasAttrDocumenter.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.autoaliasattr_directive.AliasAttrDocumenter.md
new file mode 100644
index 0000000000000000000000000000000000000000..4f86586c02097dab0b0035d7fc79480ded350654
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.autoaliasattr_directive.AliasAttrDocumenter.md
@@ -0,0 +1,48 @@
+# AliasAttrDocumenter
+
+Qualified name: `manim.utils.docbuild.autoaliasattr\_directive.AliasAttrDocumenter`
+
+### *class* AliasAttrDocumenter(name, arguments, options, content, lineno, content_offset, block_text, state, state_machine)
+
+Bases: `Directive`
+
+Directive which replaces Sphinx’s Autosummary for module-level
+attributes: instead, it manually crafts a new “Type Aliases”
+section, where all the module-level attributes which are explicitly
+annotated as `TypeAlias` are considered as such, for their
+use all around the Manim docs.
+
+These type aliases are separated from the “regular” module-level
+attributes, which get their traditional “Module Attributes”
+section autogenerated with Sphinx’s Autosummary under “Type
+Aliases”.
+
+See `docs/source/_templates/autosummary/module.rst` to watch
+this directive in action.
+
+See [`parse_module_attributes()`](manim.utils.docbuild.module_parsing.md#manim.utils.docbuild.module_parsing.parse_module_attributes) for more information on how
+the modules are parsed to obtain the `TypeAlias` information
+and separate it from the other attributes.
+
+### Methods
+
+| `run` | |
+|---------|----|
+
+### Attributes
+
+| `final_argument_whitespace` | May the final argument contain whitespace? |
+|--------------------------------------------------------------------------------------------------------------|------------------------------------------------------------|
+| [`has_content`](#manim.utils.docbuild.autoaliasattr_directive.AliasAttrDocumenter.has_content) | May the directive have content? |
+| `objtype` | |
+| `option_spec` | Mapping of option names to validator functions. |
+| `optional_arguments` | Number of optional arguments after the required arguments. |
+| [`required_arguments`](#manim.utils.docbuild.autoaliasattr_directive.AliasAttrDocumenter.required_arguments) | Number of required directive arguments. |
+
+#### has_content *= True*
+
+May the directive have content?
+
+#### required_arguments *= 1*
+
+Number of required directive arguments.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.autoaliasattr_directive.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.autoaliasattr_directive.md
new file mode 100644
index 0000000000000000000000000000000000000000..56579a259190a7a3045aa8c2e3577cb35badda39
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.autoaliasattr_directive.md
@@ -0,0 +1,32 @@
+# autoaliasattr_directive
+
+A directive for documenting type aliases and other module-level attributes.
+
+### Classes
+
+| [`AliasAttrDocumenter`](manim.utils.docbuild.autoaliasattr_directive.AliasAttrDocumenter.md#manim.utils.docbuild.autoaliasattr_directive.AliasAttrDocumenter) | Directive which replaces Sphinx's Autosummary for module-level attributes: instead, it manually crafts a new "Type Aliases" section, where all the module-level attributes which are explicitly annotated as `TypeAlias` are considered as such, for their use all around the Manim docs. |
+|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+
+### Functions
+
+### setup(app)
+
+* **Parameters:**
+ **app** (*Sphinx*)
+* **Return type:**
+ None
+
+### smart_replace(base, alias, substitution)
+
+Auxiliary function for substituting type aliases into a base
+string, when there are overlaps between the aliases themselves.
+
+* **Parameters:**
+ * **base** (*str*) – The string in which the type aliases will be located and
+ replaced.
+ * **alias** (*str*) – The substring to be substituted.
+ * **substitution** (*str*) – The string which will replace every occurrence of `alias`.
+* **Returns:**
+ The new string after the alias substitution.
+* **Return type:**
+ str
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.autocolor_directive.ManimColorModuleDocumenter.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.autocolor_directive.ManimColorModuleDocumenter.md
new file mode 100644
index 0000000000000000000000000000000000000000..cd43ecd5a4d8a1beea859c603aa3d9e5fb3a4fc4
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.autocolor_directive.ManimColorModuleDocumenter.md
@@ -0,0 +1,31 @@
+# ManimColorModuleDocumenter
+
+Qualified name: `manim.utils.docbuild.autocolor\_directive.ManimColorModuleDocumenter`
+
+### *class* ManimColorModuleDocumenter(name, arguments, options, content, lineno, content_offset, block_text, state, state_machine)
+
+Bases: `Directive`
+
+### Methods
+
+| `add_directive_header` | |
+|--------------------------|----|
+| `run` | |
+
+### Attributes
+
+| `final_argument_whitespace` | May the final argument contain whitespace? |
+|-----------------------------------------------------------------------------------------------------------------|------------------------------------------------------------|
+| [`has_content`](#manim.utils.docbuild.autocolor_directive.ManimColorModuleDocumenter.has_content) | May the directive have content? |
+| `objtype` | |
+| `option_spec` | Mapping of option names to validator functions. |
+| `optional_arguments` | Number of optional arguments after the required arguments. |
+| [`required_arguments`](#manim.utils.docbuild.autocolor_directive.ManimColorModuleDocumenter.required_arguments) | Number of required directive arguments. |
+
+#### has_content *= True*
+
+May the directive have content?
+
+#### required_arguments *= 1*
+
+Number of required directive arguments.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.autocolor_directive.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.autocolor_directive.md
new file mode 100644
index 0000000000000000000000000000000000000000..b9f7eeb808a0ade04faf3b383a8657e5ca03aed6
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.autocolor_directive.md
@@ -0,0 +1,17 @@
+# autocolor_directive
+
+A directive for documenting colors in Manim.
+
+### Classes
+
+| [`ManimColorModuleDocumenter`](manim.utils.docbuild.autocolor_directive.ManimColorModuleDocumenter.md#manim.utils.docbuild.autocolor_directive.ManimColorModuleDocumenter) | |
+|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----|
+
+### Functions
+
+### setup(app)
+
+* **Parameters:**
+ **app** (*Sphinx*)
+* **Return type:**
+ None
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.manim_directive.ManimDirective.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.manim_directive.ManimDirective.md
new file mode 100644
index 0000000000000000000000000000000000000000..7ff60d6c462bdb8eb4bab7ced8ceda2b7ed401f4
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.manim_directive.ManimDirective.md
@@ -0,0 +1,46 @@
+# ManimDirective
+
+Qualified name: `manim.utils.docbuild.manim\_directive.ManimDirective`
+
+### *class* ManimDirective(name, arguments, options, content, lineno, content_offset, block_text, state, state_machine)
+
+Bases: `Directive`
+
+The manim directive, rendering videos while building
+the documentation.
+
+See the module docstring for documentation.
+
+### Methods
+
+| `run` | |
+|---------|----|
+
+### Attributes
+
+| [`final_argument_whitespace`](#manim.utils.docbuild.manim_directive.ManimDirective.final_argument_whitespace) | May the final argument contain whitespace? |
+|-----------------------------------------------------------------------------------------------------------------|------------------------------------------------------------|
+| [`has_content`](#manim.utils.docbuild.manim_directive.ManimDirective.has_content) | May the directive have content? |
+| [`option_spec`](#manim.utils.docbuild.manim_directive.ManimDirective.option_spec) | Mapping of option names to validator functions. |
+| [`optional_arguments`](#manim.utils.docbuild.manim_directive.ManimDirective.optional_arguments) | Number of optional arguments after the required arguments. |
+| [`required_arguments`](#manim.utils.docbuild.manim_directive.ManimDirective.required_arguments) | Number of required directive arguments. |
+
+#### final_argument_whitespace *= True*
+
+May the final argument contain whitespace?
+
+#### has_content *= True*
+
+May the directive have content?
+
+#### option_spec *= {'hide_source': , 'no_autoplay': , 'quality': >, 'ref_classes': >, 'ref_functions': >, 'ref_methods': >, 'ref_modules': >, 'save_as_gif': , 'save_last_frame': }*
+
+Mapping of option names to validator functions.
+
+#### optional_arguments *= 0*
+
+Number of optional arguments after the required arguments.
+
+#### required_arguments *= 1*
+
+Number of required directive arguments.
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.manim_directive.SetupMetadata.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.manim_directive.SetupMetadata.md
new file mode 100644
index 0000000000000000000000000000000000000000..1597700c5c69d198e08eda2d32314ea4940ed327
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.manim_directive.SetupMetadata.md
@@ -0,0 +1,15 @@
+# SetupMetadata
+
+Qualified name: `manim.utils.docbuild.manim\_directive.SetupMetadata`
+
+### *class* SetupMetadata
+
+Bases: `TypedDict`
+
+### Methods
+
+### Attributes
+
+| `parallel_read_safe` | |
+|------------------------|----|
+| `parallel_write_safe` | |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.manim_directive.SkipManimNode.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.manim_directive.SkipManimNode.md
new file mode 100644
index 0000000000000000000000000000000000000000..8b6fa9aba378f1aae630423c1c5744aacfd0dc46
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.manim_directive.SkipManimNode.md
@@ -0,0 +1,31 @@
+# SkipManimNode
+
+Qualified name: `manim.utils.docbuild.manim\_directive.SkipManimNode`
+
+### *class* SkipManimNode(rawsource='', \*children, \*\*attributes)
+
+Bases: `Admonition`, `Element`
+
+Auxiliary node class that is used when the `skip-manim` tag is present
+or `.pot` files are being built.
+
+Skips rendering the manim directive and outputs a placeholder instead.
+
+### Methods
+
+### Attributes
+
+| `basic_attributes` | Tuple of attributes which are defined for every Element-derived class instance and can be safely transferred to a different node. |
+|------------------------|-------------------------------------------------------------------------------------------------------------------------------------|
+| `child_text_separator` | Separator for child nodes, used by astext() method. |
+| `document` | Return the document root node of the tree containing this Node. |
+| `known_attributes` | Tuple of attributes that are known to the Element base class. |
+| `line` | The line number (1-based) of the beginning of this Node in source. |
+| `list_attributes` | Tuple of attributes that are automatically initialized to empty lists for all nodes. |
+| `local_attributes` | Tuple of class-specific attributes that should not be copied with the standard attributes when replacing a node. |
+| `parent` | Back-reference to the Node immediately containing this Node. |
+| `source` | Path or description of the input source which generated this Node. |
+| `tagname` | The element generic identifier. |
+| `rawsource` | The raw text from which this element was constructed. |
+| `children` | List of child nodes (elements and/or Text). |
+| `attributes` | value}. |
diff --git a/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.manim_directive.md b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.manim_directive.md
new file mode 100644
index 0000000000000000000000000000000000000000..8c0e15d84cb1db2679fba8d1541f0363734f2fbc
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/docs/reference/manim.utils.docbuild.manim_directive.md
@@ -0,0 +1,134 @@
+# manim_directive
+
+## A directive for including Manim videos in a Sphinx document
+
+When rendering the HTML documentation, the `.. manim::` directive
+implemented here allows to include rendered videos.
+
+Its basic usage that allows processing **inline content**
+looks as follows:
+
+```default
+.. manim:: MyScene
+
+ class MyScene(Scene):
+ def construct(self):
+ ...
+```
+
+It is required to pass the name of the class representing the
+scene to be rendered to the directive.
+
+As a second application, the directive can also be used to
+render scenes that are defined within doctests, for example:
+
+```default
+.. manim:: DirectiveDoctestExample
+ :ref_classes: Dot
+
+ >>> from manim import Create, Dot, RED, Scene
+ >>> dot = Dot(color=RED)
+ >>> dot.color
+ ManimColor('#FC6255')
+ >>> class DirectiveDoctestExample(Scene):
+ ... def construct(self):
+ ... self.play(Create(dot))
+```
+
+### Options
+
+Options can be passed as follows:
+
+```default
+.. manim::
+ :", "")
+
+ for i in range(10, -1, -1):
+ self.html_string = self.html_string.replace(
+ "" + " " * i,
+ " " * i + "",
+ )
+ self.html_string = self.html_string.replace("background-color:", "background:")
+
+ if self.insert_line_no:
+ start_point = self.html_string.find("
")
+ lines[0] = lines[0][start_point + 1 :]
+ # print(lines)
+ self.code_json = []
+ self.tab_spaces = []
+ code_json_line_index = -1
+ for line_index in range(0, lines.__len__()):
+ # print(lines[line_index])
+ self.code_json.append([])
+ code_json_line_index = code_json_line_index + 1
+ if lines[line_index].startswith(self.indentation_chars):
+ start_point = lines[line_index].find("<")
+ starting_string = lines[line_index][:start_point]
+ indentation_chars_count = lines[line_index][:start_point].count(
+ self.indentation_chars,
+ )
+ if (
+ starting_string.__len__()
+ != indentation_chars_count * self.indentation_chars.__len__()
+ ):
+ lines[line_index] = (
+ "\t" * indentation_chars_count
+ + starting_string[
+ starting_string.rfind(self.indentation_chars)
+ + self.indentation_chars.__len__() :
+ ]
+ + lines[line_index][start_point:]
+ )
+ else:
+ lines[line_index] = (
+ "\t" * indentation_chars_count + lines[line_index][start_point:]
+ )
+ indentation_chars_count = 0
+ if lines[line_index]:
+ while lines[line_index][indentation_chars_count] == "\t":
+ indentation_chars_count = indentation_chars_count + 1
+ self.tab_spaces.append(indentation_chars_count)
+ # print(lines[line_index])
+ lines[line_index] = self._correct_non_span(lines[line_index])
+ # print(lines[line_index])
+ words = lines[line_index].split("")
+ end_point = words[word_index].find("")
+ text = words[word_index][start_point + 1 : end_point]
+ text = html.unescape(text)
+ if text != "":
+ # print(text, "'" + color + "'")
+ self.code_json[code_json_line_index].append([text, color])
+ # print(self.code_json)
+
+ def _correct_non_span(self, line_str: str):
+ """Function put text color to those strings that don't have one according to background_color of displayed code.
+
+ Parameters
+ ---------
+ line_str
+ Takes a html element's string to put color to it according to background_color of displayed code.
+
+ Returns
+ -------
+ :class:`str`
+ The generated html element's string with having color attributes.
+ """
+ words = line_str.split("")
+ line_str = ""
+ for i in range(0, words.__len__()):
+ if i != words.__len__() - 1:
+ j = words[i].find("'
+ + words[i][starti:j]
+ + ""
+ )
+ else:
+ temp = (
+ ''
+ + words[i][starti:j]
+ )
+ temp = temp + words[i][j:]
+ words[i] = temp
+ if words[i] != "":
+ line_str = line_str + words[i] + ""
+ return line_str
+
+
+def _hilite_me(
+ code: str,
+ language: str,
+ style: str,
+ insert_line_no: bool,
+ divstyles: str,
+ file_path: Path,
+ line_no_from: int,
+):
+ """Function to highlight code from string to html.
+
+ Parameters
+ ---------
+ code
+ Code string.
+ language
+ The name of the programming language the given code was written in.
+ style
+ Code style name.
+ insert_line_no
+ Defines whether line numbers should be inserted in the html file.
+ divstyles
+ Some html css styles.
+ file_path
+ Path of code file.
+ line_no_from
+ Defines the first line's number in the line count.
+ """
+ style = style or "colorful"
+ defstyles = "overflow:auto;width:auto;"
+
+ formatter = HtmlFormatter(
+ style=style,
+ linenos=False,
+ noclasses=True,
+ cssclass="",
+ cssstyles=defstyles + divstyles,
+ prestyles="margin: 0",
+ )
+ if language is None and file_path:
+ lexer = guess_lexer_for_filename(file_path, code)
+ html = highlight(code, lexer, formatter)
+ elif language is None:
+ raise ValueError(
+ "The code language has to be specified when rendering a code string",
+ )
+ else:
+ html = highlight(code, get_lexer_by_name(language, **{}), formatter)
+ if insert_line_no:
+ html = _insert_line_numbers_in_html(html, line_no_from)
+ html = "" + html
+ return html
+
+
+def _insert_line_numbers_in_html(html: str, line_no_from: int):
+ """Function that inserts line numbers in the highlighted HTML code.
+
+ Parameters
+ ---------
+ html
+ html string of highlighted code.
+ line_no_from
+ Defines the first line's number in the line count.
+
+ Returns
+ -------
+ :class:`str`
+ The generated html string with having line numbers.
+ """
+ match = re.search("(]*>)(.*)()", html, re.DOTALL)
+ if not match:
+ return html
+ pre_open = match.group(1)
+ pre = match.group(2)
+ pre_close = match.group(3)
+
+ html = html.replace(pre_close, "
")
+ numbers = range(line_no_from, line_no_from + pre.count("\n") + 1)
+ format_lines = "%" + str(len(str(numbers[-1]))) + "i"
+ lines = "\n".join(format_lines % i for i in numbers)
+ html = html.replace(
+ pre_open,
+ "
`` and ``strike through``
+ - ``typewriter font``
+ - ``bigger font`` and ``smaller font``
+ - ``superscript`` and ``subscript``
+ - ``double underline``
+ - ``error underline``
+ - ``overline``
+ - ``strikethrough``
+ - ``temporary change of font``
+ - ``temporary change of color``
+ - ``temporary change of color``
+ - ``temporary gradient``
+
+ For ```` markup, colors can be specified either as
+ hex triples like ``#aabbcc`` or as named CSS colors like
+ ``AliceBlue``.
+ The ```` tag is handled by Manim rather than
+ Pango, and supports hex triplets or Manim constants like
+ ``RED`` or ``RED_A``.
+ If you want to use Manim constants like ``RED_A`` together
+ with ````, you will need to use Python's f-String
+ syntax as follows::
+
+ MarkupText(f'here you go')
+
+ If your text contains ligatures, the :class:`MarkupText` class may
+ incorrectly determine the first and last letter when creating the
+ gradient. This is due to the fact that ``fl`` are two separate characters,
+ but might be set as one single glyph - a ligature. If your language
+ does not depend on ligatures, consider setting ``disable_ligatures``
+ to ``True``. If you must use ligatures, the ``gradient`` tag supports an optional
+ attribute ``offset`` which can be used to compensate for that error.
+
+ For example:
+
+ - ``example`` to *start* the gradient one letter earlier
+ - ``example`` to *end* the gradient one letter earlier
+ - ``example`` to *start* the gradient two letters earlier and *end* it one letter earlier
+
+ Specifying a second offset may be necessary if the text to be colored does
+ itself contain ligatures. The same can happen when using HTML entities for
+ special chars.
+
+ When using ``underline``, ``overline`` or ``strikethrough`` together with
+ ```` tags, you will also need to use the offset, because
+ underlines are additional paths in the final :class:`SVGMobject`.
+ Check out the following example.
+
+ Escaping of special characters: ``>`` **should** be written as ``>``
+ whereas ``<`` and ``&`` *must* be written as ``<`` and
+ ``&``.
+
+ You can find more information about Pango markup formatting at the
+ corresponding documentation page:
+ `Pango Markup `_.
+ Please be aware that not all features are supported by this class and that
+ the ```` tag mentioned above is not supported by Pango.
+
+ Parameters
+ ----------
+
+ text
+ The text that needs to be created as mobject.
+ fill_opacity
+ The fill opacity, with 1 meaning opaque and 0 meaning transparent.
+ stroke_width
+ Stroke width.
+ font_size
+ Font size.
+ line_spacing
+ Line spacing.
+ font
+ Global font setting for the entire text. Local overrides are possible.
+ slant
+ Global slant setting, e.g. `NORMAL` or `ITALIC`. Local overrides are possible.
+ weight
+ Global weight setting, e.g. `NORMAL` or `BOLD`. Local overrides are possible.
+ gradient
+ Global gradient setting. Local overrides are possible.
+ warn_missing_font
+ If True (default), Manim will issue a warning if the font does not exist in the
+ (case-sensitive) list of fonts returned from `manimpango.list_fonts()`.
+
+ Returns
+ -------
+ :class:`MarkupText`
+ The text displayed in form of a :class:`.VGroup`-like mobject.
+
+ Examples
+ ---------
+
+ .. manim:: BasicMarkupExample
+ :save_last_frame:
+
+ class BasicMarkupExample(Scene):
+ def construct(self):
+ text1 = MarkupText("foobarfoobar")
+ text2 = MarkupText("foobar big small")
+ text3 = MarkupText("H2O and H3O+")
+ text4 = MarkupText("type help for help")
+ text5 = MarkupText(
+ 'foobar'
+ )
+ group = VGroup(text1, text2, text3, text4, text5).arrange(DOWN)
+ self.add(group)
+
+ .. manim:: ColorExample
+ :save_last_frame:
+
+ class ColorExample(Scene):
+ def construct(self):
+ text1 = MarkupText(
+ f'all in red except this', color=RED
+ )
+ text2 = MarkupText("nice gradient", gradient=(BLUE, GREEN))
+ text3 = MarkupText(
+ 'nice intermediate gradient',
+ gradient=(BLUE, GREEN),
+ )
+ text4 = MarkupText(
+ 'fl ligature causing trouble here'
+ )
+ text5 = MarkupText(
+ 'fl ligature defeated with offset'
+ )
+ text6 = MarkupText(
+ 'fl ligature floating inside'
+ )
+ text7 = MarkupText(
+ 'fl ligature floating inside'
+ )
+ group = VGroup(text1, text2, text3, text4, text5, text6, text7).arrange(DOWN)
+ self.add(group)
+
+ .. manim:: UnderlineExample
+ :save_last_frame:
+
+ class UnderlineExample(Scene):
+ def construct(self):
+ text1 = MarkupText(
+ 'bla'
+ )
+ text2 = MarkupText(
+ 'xxxaabby'
+ )
+ text3 = MarkupText(
+ 'xxxaabby'
+ )
+ text4 = MarkupText(
+ 'xxxaabby'
+ )
+ text5 = MarkupText(
+ 'xxxaabby'
+ )
+ group = VGroup(text1, text2, text3, text4, text5).arrange(DOWN)
+ self.add(group)
+
+ .. manim:: FontExample
+ :save_last_frame:
+
+ class FontExample(Scene):
+ def construct(self):
+ text1 = MarkupText(
+ 'all in sans except this', font="sans"
+ )
+ text2 = MarkupText(
+ 'mixingfontsis ugly'
+ )
+ text3 = MarkupText("special char > or >")
+ text4 = MarkupText("special char < and &")
+ group = VGroup(text1, text2, text3, text4).arrange(DOWN)
+ self.add(group)
+
+ .. manim:: NewlineExample
+ :save_last_frame:
+
+ class NewlineExample(Scene):
+ def construct(self):
+ text = MarkupText('foooooo\nbaaaar')
+ self.add(text)
+
+ .. manim:: NoLigaturesExample
+ :save_last_frame:
+
+ class NoLigaturesExample(Scene):
+ def construct(self):
+ text1 = MarkupText('floating')
+ text2 = MarkupText('floating', disable_ligatures=True)
+ group = VGroup(text1, text2).arrange(DOWN)
+ self.add(group)
+
+
+ As :class:`MarkupText` uses Pango to render text, rendering non-English
+ characters is easily possible:
+
+ .. manim:: MultiLanguage
+ :save_last_frame:
+
+ class MultiLanguage(Scene):
+ def construct(self):
+ morning = MarkupText("வணக்கம்", font="sans-serif")
+ japanese = MarkupText(
+ '日本へようこそ'
+ ) # works as in ``Text``.
+ mess = MarkupText("Multi-Language", weight=BOLD)
+ russ = MarkupText("Здравствуйте मस नम म ", font="sans-serif")
+ hin = MarkupText("नमस्ते", font="sans-serif")
+ chinese = MarkupText("臂猿「黛比」帶著孩子", font="sans-serif")
+ group = VGroup(morning, japanese, mess, russ, hin, chinese).arrange(DOWN)
+ self.add(group)
+
+ You can justify the text by passing :attr:`justify` parameter.
+
+ .. manim:: JustifyText
+
+ class JustifyText(Scene):
+ def construct(self):
+ ipsum_text = (
+ "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
+ "Praesent feugiat metus sit amet iaculis pulvinar. Nulla posuere "
+ "quam a ex aliquam, eleifend consectetur tellus viverra. Aliquam "
+ "fermentum interdum justo, nec rutrum elit pretium ac. Nam quis "
+ "leo pulvinar, dignissim est at, venenatis nisi."
+ )
+ justified_text = MarkupText(ipsum_text, justify=True).scale(0.4)
+ not_justified_text = MarkupText(ipsum_text, justify=False).scale(0.4)
+ just_title = Title("Justified")
+ njust_title = Title("Not Justified")
+ self.add(njust_title, not_justified_text)
+ self.play(
+ FadeOut(not_justified_text),
+ FadeIn(justified_text),
+ FadeOut(njust_title),
+ FadeIn(just_title),
+ )
+ self.wait(1)
+
+ Tests
+ -----
+
+ Check that the creation of :class:`~.MarkupText` works::
+
+ >>> MarkupText('The horse does not eat cucumber salad.')
+ MarkupText('The horse does not eat cucumber salad.')
+
+ """
+
+ def __init__(
+ self,
+ text: str,
+ fill_opacity: float = 1,
+ stroke_width: float = 0,
+ color: ParsableManimColor | None = None,
+ font_size: float = DEFAULT_FONT_SIZE,
+ line_spacing: int = -1,
+ font: str = "",
+ slant: str = NORMAL,
+ weight: str = NORMAL,
+ justify: bool = False,
+ gradient: tuple = None,
+ tab_width: int = 4,
+ height: int = None,
+ width: int = None,
+ should_center: bool = True,
+ disable_ligatures: bool = False,
+ warn_missing_font: bool = True,
+ **kwargs,
+ ) -> None:
+ self.text = text
+ self.line_spacing = line_spacing
+ if font and warn_missing_font:
+ fonts_list = manimpango.list_fonts()
+ if font not in fonts_list:
+ logger.warning(f"Font {font} not in {fonts_list}.")
+ self.font = font
+ self._font_size = float(font_size)
+ self.slant = slant
+ self.weight = weight
+ self.gradient = gradient
+ self.tab_width = tab_width
+ self.justify = justify
+
+ self.original_text = text
+ self.disable_ligatures = disable_ligatures
+ text_without_tabs = text
+ if "\t" in text:
+ text_without_tabs = text.replace("\t", " " * self.tab_width)
+
+ colormap = self._extract_color_tags()
+ if len(colormap) > 0:
+ logger.warning(
+ 'Using tags in MarkupText is deprecated. Please use instead.',
+ )
+ gradientmap = self._extract_gradient_tags()
+ validate_error = MarkupUtils.validate(self.text)
+ if validate_error:
+ raise ValueError(validate_error)
+
+ if self.line_spacing == -1:
+ self.line_spacing = (
+ self._font_size + self._font_size * DEFAULT_LINE_SPACING_SCALE
+ )
+ else:
+ self.line_spacing = self._font_size + self._font_size * self.line_spacing
+
+ color: ManimColor = ManimColor(color) if color else VMobject().color
+ file_name = self._text2svg(color)
+
+ PangoUtils.remove_last_M(file_name)
+ super().__init__(
+ file_name,
+ fill_opacity=fill_opacity,
+ stroke_width=stroke_width,
+ height=height,
+ width=width,
+ should_center=should_center,
+ **kwargs,
+ )
+
+ self.chars = self.get_group_class()(*self.submobjects)
+ self.text = text_without_tabs.replace(" ", "").replace("\n", "")
+
+ nppc = self.n_points_per_curve
+ for each in self:
+ if len(each.points) == 0:
+ continue
+ points = each.points
+ curve_start = points[0]
+ assert len(curve_start) == self.dim, curve_start
+ # Some of the glyphs in this text might not be closed,
+ # so we close them by identifying when one curve ends
+ # but it is not where the next curve starts.
+ # It is more efficient to temporarily create a list
+ # of points and add them one at a time, then turn them
+ # into a numpy array at the end, rather than creating
+ # new numpy arrays every time a point or fixing line
+ # is added (which is O(n^2) for numpy arrays).
+ closed_curve_points = []
+ # OpenGL has points be part of quadratic Bezier curves;
+ # Cairo uses cubic Bezier curves.
+ if nppc == 3: # RendererType.OPENGL
+
+ def add_line_to(end):
+ nonlocal closed_curve_points
+ start = closed_curve_points[-1]
+ closed_curve_points += [
+ start,
+ (start + end) / 2,
+ end,
+ ]
+
+ else: # RendererType.CAIRO
+
+ def add_line_to(end):
+ nonlocal closed_curve_points
+ start = closed_curve_points[-1]
+ closed_curve_points += [
+ start,
+ (start + start + end) / 3,
+ (start + end + end) / 3,
+ end,
+ ]
+
+ for index, point in enumerate(points):
+ closed_curve_points.append(point)
+ if (
+ index != len(points) - 1
+ and (index + 1) % nppc == 0
+ and any(point != points[index + 1])
+ ):
+ # Add straight line from last point on this curve to the
+ # start point on the next curve.
+ add_line_to(curve_start)
+ curve_start = points[index + 1]
+ # Make sure last curve is closed
+ add_line_to(curve_start)
+ each.points = np.array(closed_curve_points, ndmin=2)
+
+ if self.gradient:
+ self.set_color_by_gradient(*self.gradient)
+ for col in colormap:
+ self.chars[
+ col["start"]
+ - col["start_offset"] : col["end"]
+ - col["start_offset"]
+ - col["end_offset"]
+ ].set_color(self._parse_color(col["color"]))
+ for grad in gradientmap:
+ self.chars[
+ grad["start"]
+ - grad["start_offset"] : grad["end"]
+ - grad["start_offset"]
+ - grad["end_offset"]
+ ].set_color_by_gradient(
+ *(self._parse_color(grad["from"]), self._parse_color(grad["to"]))
+ )
+ # anti-aliasing
+ if height is None and width is None:
+ self.scale(TEXT_MOB_SCALE_FACTOR)
+
+ self.initial_height = self.height
+
+ @property
+ def font_size(self):
+ return (
+ self.height
+ / self.initial_height
+ / TEXT_MOB_SCALE_FACTOR
+ * 2.4
+ * self._font_size
+ / DEFAULT_FONT_SIZE
+ )
+
+ @font_size.setter
+ def font_size(self, font_val):
+ # TODO: use pango's font size scaling.
+ if font_val <= 0:
+ raise ValueError("font_size must be greater than 0.")
+ else:
+ self.scale(font_val / self.font_size)
+
+ def _text2hash(self, color: ParsableManimColor):
+ """Generates ``sha256`` hash for file name."""
+ settings = (
+ "MARKUPPANGO"
+ + self.font
+ + self.slant
+ + self.weight
+ + ManimColor(color).to_hex().lower()
+ ) # to differentiate from classical Pango Text
+ settings += str(self.line_spacing) + str(self._font_size)
+ settings += str(self.disable_ligatures)
+ settings += str(self.justify)
+ id_str = self.text + settings
+ hasher = hashlib.sha256()
+ hasher.update(id_str.encode())
+ return hasher.hexdigest()[:16]
+
+ def _text2svg(self, color: ParsableManimColor | None):
+ """Convert the text to SVG using Pango."""
+ color = ManimColor(color)
+ size = self._font_size
+ line_spacing = self.line_spacing
+ size /= TEXT2SVG_ADJUSTMENT_FACTOR
+ line_spacing /= TEXT2SVG_ADJUSTMENT_FACTOR
+
+ dir_name = config.get_dir("text_dir")
+ if not dir_name.is_dir():
+ dir_name.mkdir(parents=True)
+ hash_name = self._text2hash(color)
+ file_name = dir_name / (hash_name + ".svg")
+
+ if file_name.exists():
+ svg_file = str(file_name.resolve())
+ else:
+ final_text = (
+ f'{self.text}'
+ if color is not None
+ else self.text
+ )
+ logger.debug(f"Setting Text {self.text}")
+ svg_file = MarkupUtils.text2svg(
+ final_text,
+ self.font,
+ self.slant,
+ self.weight,
+ size,
+ line_spacing,
+ self.disable_ligatures,
+ str(file_name.resolve()),
+ START_X,
+ START_Y,
+ 600, # width
+ 400, # height
+ justify=self.justify,
+ pango_width=500,
+ )
+ return svg_file
+
+ def _count_real_chars(self, s):
+ """Counts characters that will be displayed.
+
+ This is needed for partial coloring or gradients, because space
+ counts to the text's `len`, but has no corresponding character."""
+ count = 0
+ level = 0
+ # temporarily replace HTML entities by single char
+ s = re.sub("&[^;]+;", "x", s)
+ for c in s:
+ if c == "<":
+ level += 1
+ if c == ">" and level > 0:
+ level -= 1
+ elif c != " " and c != "\t" and level == 0:
+ count += 1
+ return count
+
+ def _extract_gradient_tags(self):
+ """Used to determine which parts (if any) of the string should be formatted
+ with a gradient.
+
+ Removes the ```` tag, as it is not part of Pango's markup and would cause an error.
+ """
+ tags = re.finditer(
+ r'(.+?)',
+ self.original_text,
+ re.S,
+ )
+ gradientmap = []
+ for tag in tags:
+ start = self._count_real_chars(self.original_text[: tag.start(0)])
+ end = start + self._count_real_chars(tag.group(5))
+ offsets = tag.group(4).split(",") if tag.group(4) else [0]
+ start_offset = int(offsets[0]) if offsets[0] else 0
+ end_offset = int(offsets[1]) if len(offsets) == 2 and offsets[1] else 0
+
+ gradientmap.append(
+ {
+ "start": start,
+ "end": end,
+ "from": tag.group(1),
+ "to": tag.group(2),
+ "start_offset": start_offset,
+ "end_offset": end_offset,
+ },
+ )
+ self.text = re.sub("]+>(.+?)", r"\1", self.text, 0, re.S)
+ return gradientmap
+
+ def _parse_color(self, col):
+ """Parse color given in ```` or ```` tags."""
+ if re.match("#[0-9a-f]{6}", col):
+ return col
+ else:
+ return ManimColor(col).to_hex()
+
+ def _extract_color_tags(self):
+ """Used to determine which parts (if any) of the string should be formatted
+ with a custom color.
+
+ Removes the ```` tag, as it is not part of Pango's markup and would cause an error.
+
+ Note: Using the ```` tags is deprecated. As soon as the legacy syntax is gone, this function
+ will be removed.
+ """
+ tags = re.finditer(
+ r'(.+?)',
+ self.original_text,
+ re.S,
+ )
+
+ colormap = []
+ for tag in tags:
+ start = self._count_real_chars(self.original_text[: tag.start(0)])
+ end = start + self._count_real_chars(tag.group(4))
+ offsets = tag.group(3).split(",") if tag.group(3) else [0]
+ start_offset = int(offsets[0]) if offsets[0] else 0
+ end_offset = int(offsets[1]) if len(offsets) == 2 and offsets[1] else 0
+
+ colormap.append(
+ {
+ "start": start,
+ "end": end,
+ "color": tag.group(1),
+ "start_offset": start_offset,
+ "end_offset": end_offset,
+ },
+ )
+ self.text = re.sub("]+>(.+?)", r"\1", self.text, 0, re.S)
+ return colormap
+
+ def __repr__(self):
+ return f"MarkupText({repr(self.original_text)})"
+
+
+@contextmanager
+def register_font(font_file: str | Path):
+ """Temporarily add a font file to Pango's search path.
+
+ This searches for the font_file at various places. The order it searches it described below.
+
+ 1. Absolute path.
+ 2. In ``assets/fonts`` folder.
+ 3. In ``font/`` folder.
+ 4. In the same directory.
+
+ Parameters
+ ----------
+ font_file
+ The font file to add.
+
+ Examples
+ --------
+ Use ``with register_font(...)`` to add a font file to search
+ path.
+
+ .. code-block:: python
+
+ with register_font("path/to/font_file.ttf"):
+ a = Text("Hello", font="Custom Font Name")
+
+ Raises
+ ------
+ FileNotFoundError:
+ If the font doesn't exists.
+
+ AttributeError:
+ If this method is used on macOS.
+
+ .. important ::
+
+ This method is available for macOS for ``ManimPango>=v0.2.3``. Using this
+ method with previous releases will raise an :class:`AttributeError` on macOS.
+ """
+
+ input_folder = Path(config.input_file).parent.resolve()
+ possible_paths = [
+ Path(font_file),
+ input_folder / "assets/fonts" / font_file,
+ input_folder / "fonts" / font_file,
+ input_folder / font_file,
+ ]
+ for path in possible_paths:
+ path = path.resolve()
+ if path.exists():
+ file_path = path
+ logger.debug("Found file at %s", file_path.absolute())
+ break
+ else:
+ error = f"Can't find {font_file}." f"Tried these : {possible_paths}"
+ raise FileNotFoundError(error)
+
+ try:
+ assert manimpango.register_font(str(file_path))
+ yield
+ finally:
+ manimpango.unregister_font(str(file_path))
diff --git a/data/rag/manim_docs/manim_core/source/mobject/three_d/__init__.py b/data/rag/manim_docs/manim_core/source/mobject/three_d/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..98d295a24e5dc8cdeaa13a0d9cbc5c9152c1b6f9
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/mobject/three_d/__init__.py
@@ -0,0 +1,12 @@
+"""Three-dimensional mobjects.
+
+Modules
+=======
+
+.. autosummary::
+ :toctree: ../reference
+
+ ~polyhedra
+ ~three_d_utils
+ ~three_dimensions
+"""
diff --git a/data/rag/manim_docs/manim_core/source/mobject/three_d/polyhedra.py b/data/rag/manim_docs/manim_core/source/mobject/three_d/polyhedra.py
new file mode 100644
index 0000000000000000000000000000000000000000..300cf660a8b78328167cd73356a6a9a46a905494
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/mobject/three_d/polyhedra.py
@@ -0,0 +1,363 @@
+"""General polyhedral class and platonic solids."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from manim.mobject.geometry.polygram import Polygon
+from manim.mobject.graph import Graph
+from manim.mobject.three_d.three_dimensions import Dot3D
+from manim.mobject.types.vectorized_mobject import VGroup
+
+if TYPE_CHECKING:
+ from manim.mobject.mobject import Mobject
+
+__all__ = ["Polyhedron", "Tetrahedron", "Octahedron", "Icosahedron", "Dodecahedron"]
+
+
+class Polyhedron(VGroup):
+ """An abstract polyhedra class.
+
+ In this implementation, polyhedra are defined with a list of vertex coordinates in space, and a list
+ of faces. This implementation mirrors that of a standard polyhedral data format (OFF, object file format).
+
+ Parameters
+ ----------
+ vertex_coords
+ A list of coordinates of the corresponding vertices in the polyhedron. Each coordinate will correspond to
+ a vertex. The vertices are indexed with the usual indexing of Python.
+ faces_list
+ A list of faces. Each face is a sublist containing the indices of the vertices that form the corners of that face.
+ faces_config
+ Configuration for the polygons representing the faces of the polyhedron.
+ graph_config
+ Configuration for the graph containing the vertices and edges of the polyhedron.
+
+ Examples
+ --------
+ To understand how to create a custom polyhedra, let's use the example of a rather simple one - a square pyramid.
+
+ .. manim:: SquarePyramidScene
+ :save_last_frame:
+
+ class SquarePyramidScene(ThreeDScene):
+ def construct(self):
+ self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+ vertex_coords = [
+ [1, 1, 0],
+ [1, -1, 0],
+ [-1, -1, 0],
+ [-1, 1, 0],
+ [0, 0, 2]
+ ]
+ faces_list = [
+ [0, 1, 4],
+ [1, 2, 4],
+ [2, 3, 4],
+ [3, 0, 4],
+ [0, 1, 2, 3]
+ ]
+ pyramid = Polyhedron(vertex_coords, faces_list)
+ self.add(pyramid)
+
+ In defining the polyhedron above, we first defined the coordinates of the vertices.
+ These are the corners of the square base, given as the first four coordinates in the vertex list,
+ and the apex, the last coordinate in the list.
+
+ Next, we define the faces of the polyhedron. The triangular surfaces of the pyramid are polygons
+ with two adjacent vertices in the base and the vertex at the apex as corners. We thus define these
+ surfaces in the first four elements of our face list. The last element defines the base of the pyramid.
+
+ The graph and faces of polyhedra can also be accessed and modified directly, after instantiation.
+ They are stored in the `graph` and `faces` attributes respectively.
+
+ .. manim:: PolyhedronSubMobjects
+ :save_last_frame:
+
+ class PolyhedronSubMobjects(ThreeDScene):
+ def construct(self):
+ self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+ octahedron = Octahedron(edge_length = 3)
+ octahedron.graph[0].set_color(RED)
+ octahedron.faces[2].set_color(YELLOW)
+ self.add(octahedron)
+ """
+
+ def __init__(
+ self,
+ vertex_coords: list[list[float] | np.ndarray],
+ faces_list: list[list[int]],
+ faces_config: dict[str, str | int | float | bool] = {},
+ graph_config: dict[str, str | int | float | bool] = {},
+ ):
+ super().__init__()
+ self.faces_config = dict(
+ {"fill_opacity": 0.5, "shade_in_3d": True}, **faces_config
+ )
+ self.graph_config = dict(
+ {
+ "vertex_type": Dot3D,
+ "edge_config": {
+ "stroke_opacity": 0, # I find that having the edges visible makes the polyhedra look weird
+ },
+ },
+ **graph_config,
+ )
+ self.vertex_coords = vertex_coords
+ self.vertex_indices = list(range(len(self.vertex_coords)))
+ self.layout = dict(enumerate(self.vertex_coords))
+ self.faces_list = faces_list
+ self.face_coords = [[self.layout[j] for j in i] for i in faces_list]
+ self.edges = self.get_edges(self.faces_list)
+ self.faces = self.create_faces(self.face_coords)
+ self.graph = Graph(
+ self.vertex_indices, self.edges, layout=self.layout, **self.graph_config
+ )
+ self.add(self.faces, self.graph)
+ self.add_updater(self.update_faces)
+
+ def get_edges(self, faces_list: list[list[int]]) -> list[tuple[int, int]]:
+ """Creates list of cyclic pairwise tuples."""
+ edges = []
+ for face in faces_list:
+ edges += zip(face, face[1:] + face[:1])
+ return edges
+
+ def create_faces(
+ self,
+ face_coords: list[list[list | np.ndarray]],
+ ) -> VGroup:
+ """Creates VGroup of faces from a list of face coordinates."""
+ face_group = VGroup()
+ for face in face_coords:
+ face_group.add(Polygon(*face, **self.faces_config))
+ return face_group
+
+ def update_faces(self, m: Mobject):
+ face_coords = self.extract_face_coords()
+ new_faces = self.create_faces(face_coords)
+ self.faces.match_points(new_faces)
+
+ def extract_face_coords(self) -> list[list[np.ndarray]]:
+ """Extracts the coordinates of the vertices in the graph.
+ Used for updating faces.
+ """
+ new_vertex_coords = []
+ for v in self.graph.vertices:
+ new_vertex_coords.append(self.graph[v].get_center())
+ layout = dict(enumerate(new_vertex_coords))
+ return [[layout[j] for j in i] for i in self.faces_list]
+
+
+class Tetrahedron(Polyhedron):
+ """A tetrahedron, one of the five platonic solids. It has 4 faces, 6 edges, and 4 vertices.
+
+ Parameters
+ ----------
+ edge_length
+ The length of an edge between any two vertices.
+
+ Examples
+ --------
+
+ .. manim:: TetrahedronScene
+ :save_last_frame:
+
+ class TetrahedronScene(ThreeDScene):
+ def construct(self):
+ self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+ obj = Tetrahedron()
+ self.add(obj)
+ """
+
+ def __init__(self, edge_length: float = 1, **kwargs):
+ unit = edge_length * np.sqrt(2) / 4
+ super().__init__(
+ vertex_coords=[
+ np.array([unit, unit, unit]),
+ np.array([unit, -unit, -unit]),
+ np.array([-unit, unit, -unit]),
+ np.array([-unit, -unit, unit]),
+ ],
+ faces_list=[[0, 1, 2], [3, 0, 2], [0, 1, 3], [3, 1, 2]],
+ **kwargs,
+ )
+
+
+class Octahedron(Polyhedron):
+ """An octahedron, one of the five platonic solids. It has 8 faces, 12 edges and 6 vertices.
+
+ Parameters
+ ----------
+ edge_length
+ The length of an edge between any two vertices.
+
+ Examples
+ --------
+
+ .. manim:: OctahedronScene
+ :save_last_frame:
+
+ class OctahedronScene(ThreeDScene):
+ def construct(self):
+ self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+ obj = Octahedron()
+ self.add(obj)
+ """
+
+ def __init__(self, edge_length: float = 1, **kwargs):
+ unit = edge_length * np.sqrt(2) / 2
+ super().__init__(
+ vertex_coords=[
+ np.array([unit, 0, 0]),
+ np.array([-unit, 0, 0]),
+ np.array([0, unit, 0]),
+ np.array([0, -unit, 0]),
+ np.array([0, 0, unit]),
+ np.array([0, 0, -unit]),
+ ],
+ faces_list=[
+ [2, 4, 1],
+ [0, 4, 2],
+ [4, 3, 0],
+ [1, 3, 4],
+ [3, 5, 0],
+ [1, 5, 3],
+ [2, 5, 1],
+ [0, 5, 2],
+ ],
+ **kwargs,
+ )
+
+
+class Icosahedron(Polyhedron):
+ """An icosahedron, one of the five platonic solids. It has 20 faces, 30 edges and 12 vertices.
+
+ Parameters
+ ----------
+ edge_length
+ The length of an edge between any two vertices.
+
+ Examples
+ --------
+
+ .. manim:: IcosahedronScene
+ :save_last_frame:
+
+ class IcosahedronScene(ThreeDScene):
+ def construct(self):
+ self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+ obj = Icosahedron()
+ self.add(obj)
+ """
+
+ def __init__(self, edge_length: float = 1, **kwargs):
+ unit_a = edge_length * ((1 + np.sqrt(5)) / 4)
+ unit_b = edge_length * (1 / 2)
+ super().__init__(
+ vertex_coords=[
+ np.array([0, unit_b, unit_a]),
+ np.array([0, -unit_b, unit_a]),
+ np.array([0, unit_b, -unit_a]),
+ np.array([0, -unit_b, -unit_a]),
+ np.array([unit_b, unit_a, 0]),
+ np.array([unit_b, -unit_a, 0]),
+ np.array([-unit_b, unit_a, 0]),
+ np.array([-unit_b, -unit_a, 0]),
+ np.array([unit_a, 0, unit_b]),
+ np.array([unit_a, 0, -unit_b]),
+ np.array([-unit_a, 0, unit_b]),
+ np.array([-unit_a, 0, -unit_b]),
+ ],
+ faces_list=[
+ [1, 8, 0],
+ [1, 5, 7],
+ [8, 5, 1],
+ [7, 3, 5],
+ [5, 9, 3],
+ [8, 9, 5],
+ [3, 2, 9],
+ [9, 4, 2],
+ [8, 4, 9],
+ [0, 4, 8],
+ [6, 4, 0],
+ [6, 2, 4],
+ [11, 2, 6],
+ [3, 11, 2],
+ [0, 6, 10],
+ [10, 1, 0],
+ [10, 7, 1],
+ [11, 7, 3],
+ [10, 11, 7],
+ [10, 11, 6],
+ ],
+ **kwargs,
+ )
+
+
+class Dodecahedron(Polyhedron):
+ """A dodecahedron, one of the five platonic solids. It has 12 faces, 30 edges and 20 vertices.
+
+ Parameters
+ ----------
+ edge_length
+ The length of an edge between any two vertices.
+
+ Examples
+ --------
+
+ .. manim:: DodecahedronScene
+ :save_last_frame:
+
+ class DodecahedronScene(ThreeDScene):
+ def construct(self):
+ self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+ obj = Dodecahedron()
+ self.add(obj)
+ """
+
+ def __init__(self, edge_length: float = 1, **kwargs):
+ unit_a = edge_length * ((1 + np.sqrt(5)) / 4)
+ unit_b = edge_length * ((3 + np.sqrt(5)) / 4)
+ unit_c = edge_length * (1 / 2)
+ super().__init__(
+ vertex_coords=[
+ np.array([unit_a, unit_a, unit_a]),
+ np.array([unit_a, unit_a, -unit_a]),
+ np.array([unit_a, -unit_a, unit_a]),
+ np.array([unit_a, -unit_a, -unit_a]),
+ np.array([-unit_a, unit_a, unit_a]),
+ np.array([-unit_a, unit_a, -unit_a]),
+ np.array([-unit_a, -unit_a, unit_a]),
+ np.array([-unit_a, -unit_a, -unit_a]),
+ np.array([0, unit_c, unit_b]),
+ np.array([0, unit_c, -unit_b]),
+ np.array([0, -unit_c, -unit_b]),
+ np.array([0, -unit_c, unit_b]),
+ np.array([unit_c, unit_b, 0]),
+ np.array([-unit_c, unit_b, 0]),
+ np.array([unit_c, -unit_b, 0]),
+ np.array([-unit_c, -unit_b, 0]),
+ np.array([unit_b, 0, unit_c]),
+ np.array([-unit_b, 0, unit_c]),
+ np.array([unit_b, 0, -unit_c]),
+ np.array([-unit_b, 0, -unit_c]),
+ ],
+ faces_list=[
+ [18, 16, 0, 12, 1],
+ [3, 18, 16, 2, 14],
+ [3, 10, 9, 1, 18],
+ [1, 9, 5, 13, 12],
+ [0, 8, 4, 13, 12],
+ [2, 16, 0, 8, 11],
+ [4, 17, 6, 11, 8],
+ [17, 19, 5, 13, 4],
+ [19, 7, 15, 6, 17],
+ [6, 15, 14, 2, 11],
+ [19, 5, 9, 10, 7],
+ [7, 10, 3, 14, 15],
+ ],
+ **kwargs,
+ )
diff --git a/data/rag/manim_docs/manim_core/source/mobject/three_d/three_d_utils.py b/data/rag/manim_docs/manim_core/source/mobject/three_d/three_d_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec3af9ac055258596cadd112fbe4c3072dfe82e7
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/mobject/three_d/three_d_utils.py
@@ -0,0 +1,76 @@
+"""Utility functions for three-dimensional mobjects."""
+
+from __future__ import annotations
+
+__all__ = [
+ "get_3d_vmob_gradient_start_and_end_points",
+ "get_3d_vmob_start_corner_index",
+ "get_3d_vmob_end_corner_index",
+ "get_3d_vmob_start_corner",
+ "get_3d_vmob_end_corner",
+ "get_3d_vmob_unit_normal",
+ "get_3d_vmob_start_corner_unit_normal",
+ "get_3d_vmob_end_corner_unit_normal",
+]
+
+
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+
+from manim.constants import ORIGIN, UP
+from manim.utils.space_ops import get_unit_normal
+
+if TYPE_CHECKING:
+ from manim.typing import Point3D, Vector
+
+
+def get_3d_vmob_gradient_start_and_end_points(vmob) -> tuple[Point3D, Point3D]:
+ return (
+ get_3d_vmob_start_corner(vmob),
+ get_3d_vmob_end_corner(vmob),
+ )
+
+
+def get_3d_vmob_start_corner_index(vmob) -> Literal[0]:
+ return 0
+
+
+def get_3d_vmob_end_corner_index(vmob) -> int:
+ return ((len(vmob.points) - 1) // 6) * 3
+
+
+def get_3d_vmob_start_corner(vmob) -> Point3D:
+ if vmob.get_num_points() == 0:
+ return np.array(ORIGIN)
+ return vmob.points[get_3d_vmob_start_corner_index(vmob)]
+
+
+def get_3d_vmob_end_corner(vmob) -> Point3D:
+ if vmob.get_num_points() == 0:
+ return np.array(ORIGIN)
+ return vmob.points[get_3d_vmob_end_corner_index(vmob)]
+
+
+def get_3d_vmob_unit_normal(vmob, point_index: int) -> Vector:
+ n_points = vmob.get_num_points()
+ if len(vmob.get_anchors()) <= 2:
+ return np.array(UP)
+ i = point_index
+ im3 = i - 3 if i > 2 else (n_points - 4)
+ ip3 = i + 3 if i < (n_points - 3) else 3
+ unit_normal = get_unit_normal(
+ vmob.points[ip3] - vmob.points[i],
+ vmob.points[im3] - vmob.points[i],
+ )
+ if np.linalg.norm(unit_normal) == 0:
+ return np.array(UP)
+ return unit_normal
+
+
+def get_3d_vmob_start_corner_unit_normal(vmob) -> Vector:
+ return get_3d_vmob_unit_normal(vmob, get_3d_vmob_start_corner_index(vmob))
+
+
+def get_3d_vmob_end_corner_unit_normal(vmob) -> Vector:
+ return get_3d_vmob_unit_normal(vmob, get_3d_vmob_end_corner_index(vmob))
diff --git a/data/rag/manim_docs/manim_core/source/mobject/three_d/three_dimensions.py b/data/rag/manim_docs/manim_core/source/mobject/three_d/three_dimensions.py
new file mode 100644
index 0000000000000000000000000000000000000000..1be9edf7dd8aaf69f0a2e2c3c3ac899973258d7d
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/mobject/three_d/three_dimensions.py
@@ -0,0 +1,1232 @@
+"""Three-dimensional mobjects."""
+
+from __future__ import annotations
+
+from manim.typing import Point3D, Vector3
+from manim.utils.color import BLUE, BLUE_D, BLUE_E, LIGHT_GREY, WHITE, interpolate_color
+
+__all__ = [
+ "ThreeDVMobject",
+ "Surface",
+ "Sphere",
+ "Dot3D",
+ "Cube",
+ "Prism",
+ "Cone",
+ "Arrow3D",
+ "Cylinder",
+ "Line3D",
+ "Torus",
+]
+
+from typing import Any, Callable, Iterable, Sequence
+
+import numpy as np
+from typing_extensions import Self
+
+from manim import config, logger
+from manim.constants import *
+from manim.mobject.geometry.arc import Circle
+from manim.mobject.geometry.polygram import Square
+from manim.mobject.mobject import *
+from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
+from manim.mobject.opengl.opengl_mobject import OpenGLMobject
+from manim.mobject.types.vectorized_mobject import VGroup, VMobject
+from manim.utils.color import (
+ BLUE,
+ BLUE_D,
+ BLUE_E,
+ LIGHT_GREY,
+ WHITE,
+ ManimColor,
+ ParsableManimColor,
+ interpolate_color,
+)
+from manim.utils.iterables import tuplify
+from manim.utils.space_ops import normalize, perpendicular_bisector, z_to_vector
+
+
+class ThreeDVMobject(VMobject, metaclass=ConvertToOpenGL):
+ def __init__(self, shade_in_3d: bool = True, **kwargs):
+ super().__init__(shade_in_3d=shade_in_3d, **kwargs)
+
+
+class Surface(VGroup, metaclass=ConvertToOpenGL):
+ """Creates a Parametric Surface using a checkerboard pattern.
+
+ Parameters
+ ----------
+ func
+ The function defining the :class:`Surface`.
+ u_range
+ The range of the ``u`` variable: ``(u_min, u_max)``.
+ v_range
+ The range of the ``v`` variable: ``(v_min, v_max)``.
+ resolution
+ The number of samples taken of the :class:`Surface`. A tuple can be
+ used to define different resolutions for ``u`` and ``v`` respectively.
+ fill_color
+ The color of the :class:`Surface`. Ignored if ``checkerboard_colors``
+ is set.
+ fill_opacity
+ The opacity of the :class:`Surface`, from 0 being fully transparent
+ to 1 being fully opaque. Defaults to 1.
+ checkerboard_colors
+ ng individual faces alternating colors. Overrides ``fill_color``.
+ stroke_color
+ Color of the stroke surrounding each face of :class:`Surface`.
+ stroke_width
+ Width of the stroke surrounding each face of :class:`Surface`.
+ Defaults to 0.5.
+ should_make_jagged
+ Changes the anchor mode of the Bézier curves from smooth to jagged.
+ Defaults to ``False``.
+
+ Examples
+ --------
+ .. manim:: ParaSurface
+ :save_last_frame:
+
+ class ParaSurface(ThreeDScene):
+ def func(self, u, v):
+ return np.array([np.cos(u) * np.cos(v), np.cos(u) * np.sin(v), u])
+
+ def construct(self):
+ axes = ThreeDAxes(x_range=[-4,4], x_length=8)
+ surface = Surface(
+ lambda u, v: axes.c2p(*self.func(u, v)),
+ u_range=[-PI, PI],
+ v_range=[0, TAU],
+ resolution=8,
+ )
+ self.set_camera_orientation(theta=70 * DEGREES, phi=75 * DEGREES)
+ self.add(axes, surface)
+ """
+
+ def __init__(
+ self,
+ func: Callable[[float, float], np.ndarray],
+ u_range: Sequence[float] = [0, 1],
+ v_range: Sequence[float] = [0, 1],
+ resolution: Sequence[int] = 32,
+ surface_piece_config: dict = {},
+ fill_color: ParsableManimColor = BLUE_D,
+ fill_opacity: float = 1.0,
+ checkerboard_colors: Sequence[ParsableManimColor] | bool = [BLUE_D, BLUE_E],
+ stroke_color: ParsableManimColor = LIGHT_GREY,
+ stroke_width: float = 0.5,
+ should_make_jagged: bool = False,
+ pre_function_handle_to_anchor_scale_factor: float = 0.00001,
+ **kwargs: Any,
+ ) -> None:
+ self.u_range = u_range
+ self.v_range = v_range
+ super().__init__(**kwargs)
+ self.resolution = resolution
+ self.surface_piece_config = surface_piece_config
+ self.fill_color: ManimColor = ManimColor(fill_color)
+ self.fill_opacity = fill_opacity
+ if checkerboard_colors:
+ self.checkerboard_colors: list[ManimColor] = [
+ ManimColor(x) for x in checkerboard_colors
+ ]
+ else:
+ self.checkerboard_colors = checkerboard_colors
+ self.stroke_color: ManimColor = ManimColor(stroke_color)
+ self.stroke_width = stroke_width
+ self.should_make_jagged = should_make_jagged
+ self.pre_function_handle_to_anchor_scale_factor = (
+ pre_function_handle_to_anchor_scale_factor
+ )
+ self._func = func
+ self._setup_in_uv_space()
+ self.apply_function(lambda p: func(p[0], p[1]))
+ if self.should_make_jagged:
+ self.make_jagged()
+
+ def func(self, u: float, v: float) -> np.ndarray:
+ return self._func(u, v)
+
+ def _get_u_values_and_v_values(self) -> tuple[np.ndarray, np.ndarray]:
+ res = tuplify(self.resolution)
+ if len(res) == 1:
+ u_res = v_res = res[0]
+ else:
+ u_res, v_res = res
+
+ u_values = np.linspace(*self.u_range, u_res + 1)
+ v_values = np.linspace(*self.v_range, v_res + 1)
+
+ return u_values, v_values
+
+ def _setup_in_uv_space(self) -> None:
+ u_values, v_values = self._get_u_values_and_v_values()
+ faces = VGroup()
+ for i in range(len(u_values) - 1):
+ for j in range(len(v_values) - 1):
+ u1, u2 = u_values[i : i + 2]
+ v1, v2 = v_values[j : j + 2]
+ face = ThreeDVMobject()
+ face.set_points_as_corners(
+ [
+ [u1, v1, 0],
+ [u2, v1, 0],
+ [u2, v2, 0],
+ [u1, v2, 0],
+ [u1, v1, 0],
+ ],
+ )
+ faces.add(face)
+ face.u_index = i
+ face.v_index = j
+ face.u1 = u1
+ face.u2 = u2
+ face.v1 = v1
+ face.v2 = v2
+ faces.set_fill(color=self.fill_color, opacity=self.fill_opacity)
+ faces.set_stroke(
+ color=self.stroke_color,
+ width=self.stroke_width,
+ opacity=self.stroke_opacity,
+ )
+ self.add(*faces)
+ if self.checkerboard_colors:
+ self.set_fill_by_checkerboard(*self.checkerboard_colors)
+
+ def set_fill_by_checkerboard(
+ self, *colors: Iterable[ParsableManimColor], opacity: float | None = None
+ ) -> Self:
+ """Sets the fill_color of each face of :class:`Surface` in
+ an alternating pattern.
+
+ Parameters
+ ----------
+ colors
+ List of colors for alternating pattern.
+ opacity
+ The fill_opacity of :class:`Surface`, from 0 being fully transparent
+ to 1 being fully opaque.
+
+ Returns
+ -------
+ :class:`~.Surface`
+ The parametric surface with an alternating pattern.
+ """
+ n_colors = len(colors)
+ for face in self:
+ c_index = (face.u_index + face.v_index) % n_colors
+ face.set_fill(colors[c_index], opacity=opacity)
+ return self
+
+ def set_fill_by_value(
+ self,
+ axes: Mobject,
+ colorscale: list[ParsableManimColor] | ParsableManimColor | None = None,
+ axis: int = 2,
+ **kwargs,
+ ) -> Self:
+ """Sets the color of each mobject of a parametric surface to a color
+ relative to its axis-value.
+
+ Parameters
+ ----------
+ axes
+ The axes for the parametric surface, which will be used to map
+ axis-values to colors.
+ colorscale
+ A list of colors, ordered from lower axis-values to higher axis-values.
+ If a list of tuples is passed containing colors paired with numbers,
+ then those numbers will be used as the pivots.
+ axis
+ The chosen axis to use for the color mapping. (0 = x, 1 = y, 2 = z)
+
+ Returns
+ -------
+ :class:`~.Surface`
+ The parametric surface with a gradient applied by value. For chaining.
+
+ Examples
+ --------
+ .. manim:: FillByValueExample
+ :save_last_frame:
+
+ class FillByValueExample(ThreeDScene):
+ def construct(self):
+ resolution_fa = 8
+ self.set_camera_orientation(phi=75 * DEGREES, theta=-160 * DEGREES)
+ axes = ThreeDAxes(x_range=(0, 5, 1), y_range=(0, 5, 1), z_range=(-1, 1, 0.5))
+ def param_surface(u, v):
+ x = u
+ y = v
+ z = np.sin(x) * np.cos(y)
+ return z
+ surface_plane = Surface(
+ lambda u, v: axes.c2p(u, v, param_surface(u, v)),
+ resolution=(resolution_fa, resolution_fa),
+ v_range=[0, 5],
+ u_range=[0, 5],
+ )
+ surface_plane.set_style(fill_opacity=1)
+ surface_plane.set_fill_by_value(axes=axes, colorscale=[(RED, -0.5), (YELLOW, 0), (GREEN, 0.5)], axis=2)
+ self.add(axes, surface_plane)
+ """
+ if "colors" in kwargs and colorscale is None:
+ colorscale = kwargs.pop("colors")
+ if kwargs:
+ raise ValueError(
+ "Unsupported keyword argument(s): "
+ f"{', '.join(str(key) for key in kwargs)}"
+ )
+ if colorscale is None:
+ logger.warning(
+ "The value passed to the colorscale keyword argument was None, "
+ "the surface fill color has not been changed"
+ )
+ return self
+
+ ranges = [axes.x_range, axes.y_range, axes.z_range]
+
+ if type(colorscale[0]) is tuple:
+ new_colors, pivots = [
+ [i for i, j in colorscale],
+ [j for i, j in colorscale],
+ ]
+ else:
+ new_colors = colorscale
+
+ pivot_min = ranges[axis][0]
+ pivot_max = ranges[axis][1]
+ pivot_frequency = (pivot_max - pivot_min) / (len(new_colors) - 1)
+ pivots = np.arange(
+ start=pivot_min,
+ stop=pivot_max + pivot_frequency,
+ step=pivot_frequency,
+ )
+
+ for mob in self.family_members_with_points():
+ axis_value = axes.point_to_coords(mob.get_midpoint())[axis]
+ if axis_value <= pivots[0]:
+ mob.set_color(new_colors[0])
+ elif axis_value >= pivots[-1]:
+ mob.set_color(new_colors[-1])
+ else:
+ for i, pivot in enumerate(pivots):
+ if pivot > axis_value:
+ color_index = (axis_value - pivots[i - 1]) / (
+ pivots[i] - pivots[i - 1]
+ )
+ color_index = min(color_index, 1)
+ mob_color = interpolate_color(
+ new_colors[i - 1],
+ new_colors[i],
+ color_index,
+ )
+ if config.renderer == RendererType.OPENGL:
+ mob.set_color(mob_color, recurse=False)
+ elif config.renderer == RendererType.CAIRO:
+ mob.set_color(mob_color, family=False)
+ break
+
+ return self
+
+
+# Specific shapes
+
+
+class Sphere(Surface):
+ """A three-dimensional sphere.
+
+ Parameters
+ ----------
+ center
+ Center of the :class:`Sphere`.
+ radius
+ The radius of the :class:`Sphere`.
+ resolution
+ The number of samples taken of the :class:`Sphere`. A tuple can be used
+ to define different resolutions for ``u`` and ``v`` respectively.
+ u_range
+ The range of the ``u`` variable: ``(u_min, u_max)``.
+ v_range
+ The range of the ``v`` variable: ``(v_min, v_max)``.
+
+ Examples
+ --------
+
+ .. manim:: ExampleSphere
+ :save_last_frame:
+
+ class ExampleSphere(ThreeDScene):
+ def construct(self):
+ self.set_camera_orientation(phi=PI / 6, theta=PI / 6)
+ sphere1 = Sphere(
+ center=(3, 0, 0),
+ radius=1,
+ resolution=(20, 20),
+ u_range=[0.001, PI - 0.001],
+ v_range=[0, TAU]
+ )
+ sphere1.set_color(RED)
+ self.add(sphere1)
+ sphere2 = Sphere(center=(-1, -3, 0), radius=2, resolution=(18, 18))
+ sphere2.set_color(GREEN)
+ self.add(sphere2)
+ sphere3 = Sphere(center=(-1, 2, 0), radius=2, resolution=(16, 16))
+ sphere3.set_color(BLUE)
+ self.add(sphere3)
+ """
+
+ def __init__(
+ self,
+ center: Point3D = ORIGIN,
+ radius: float = 1,
+ resolution: Sequence[int] | None = None,
+ u_range: Sequence[float] = (0, TAU),
+ v_range: Sequence[float] = (0, PI),
+ **kwargs,
+ ) -> None:
+ if config.renderer == RendererType.OPENGL:
+ res_value = (101, 51)
+ elif config.renderer == RendererType.CAIRO:
+ res_value = (24, 12)
+ else:
+ raise Exception("Unknown renderer")
+
+ resolution = resolution if resolution is not None else res_value
+
+ self.radius = radius
+
+ super().__init__(
+ self.func,
+ resolution=resolution,
+ u_range=u_range,
+ v_range=v_range,
+ **kwargs,
+ )
+
+ self.shift(center)
+
+ def func(self, u: float, v: float) -> np.ndarray:
+ """The z values defining the :class:`Sphere` being plotted.
+
+ Returns
+ -------
+ :class:`numpy.array`
+ The z values defining the :class:`Sphere`.
+ """
+ return self.radius * np.array(
+ [np.cos(u) * np.sin(v), np.sin(u) * np.sin(v), -np.cos(v)],
+ )
+
+
+class Dot3D(Sphere):
+ """A spherical dot.
+
+ Parameters
+ ----------
+ point
+ The location of the dot.
+ radius
+ The radius of the dot.
+ color
+ The color of the :class:`Dot3D`.
+ resolution
+ The number of samples taken of the :class:`Dot3D`. A tuple can be
+ used to define different resolutions for ``u`` and ``v`` respectively.
+
+ Examples
+ --------
+
+ .. manim:: Dot3DExample
+ :save_last_frame:
+
+ class Dot3DExample(ThreeDScene):
+ def construct(self):
+ self.set_camera_orientation(phi=75*DEGREES, theta=-45*DEGREES)
+
+ axes = ThreeDAxes()
+ dot_1 = Dot3D(point=axes.coords_to_point(0, 0, 1), color=RED)
+ dot_2 = Dot3D(point=axes.coords_to_point(2, 0, 0), radius=0.1, color=BLUE)
+ dot_3 = Dot3D(point=[0, 0, 0], radius=0.1, color=ORANGE)
+ self.add(axes, dot_1, dot_2,dot_3)
+ """
+
+ def __init__(
+ self,
+ point: list | np.ndarray = ORIGIN,
+ radius: float = DEFAULT_DOT_RADIUS,
+ color: ParsableManimColor = WHITE,
+ resolution: tuple[int, int] = (8, 8),
+ **kwargs,
+ ) -> None:
+ super().__init__(center=point, radius=radius, resolution=resolution, **kwargs)
+ self.set_color(color)
+
+
+class Cube(VGroup):
+ """A three-dimensional cube.
+
+ Parameters
+ ----------
+ side_length
+ Length of each side of the :class:`Cube`.
+ fill_opacity
+ The opacity of the :class:`Cube`, from 0 being fully transparent to 1 being
+ fully opaque. Defaults to 0.75.
+ fill_color
+ The color of the :class:`Cube`.
+ stroke_width
+ The width of the stroke surrounding each face of the :class:`Cube`.
+
+ Examples
+ --------
+
+ .. manim:: CubeExample
+ :save_last_frame:
+
+ class CubeExample(ThreeDScene):
+ def construct(self):
+ self.set_camera_orientation(phi=75*DEGREES, theta=-45*DEGREES)
+
+ axes = ThreeDAxes()
+ cube = Cube(side_length=3, fill_opacity=0.7, fill_color=BLUE)
+ self.add(cube)
+ """
+
+ def __init__(
+ self,
+ side_length: float = 2,
+ fill_opacity: float = 0.75,
+ fill_color: ParsableManimColor = BLUE,
+ stroke_width: float = 0,
+ **kwargs,
+ ) -> None:
+ self.side_length = side_length
+ super().__init__(
+ fill_color=fill_color,
+ fill_opacity=fill_opacity,
+ stroke_width=stroke_width,
+ **kwargs,
+ )
+
+ def generate_points(self) -> None:
+ """Creates the sides of the :class:`Cube`."""
+ for vect in IN, OUT, LEFT, RIGHT, UP, DOWN:
+ face = Square(
+ side_length=self.side_length,
+ shade_in_3d=True,
+ )
+ face.flip()
+ face.shift(self.side_length * OUT / 2.0)
+ face.apply_matrix(z_to_vector(vect))
+
+ self.add(face)
+
+ init_points = generate_points
+
+
+class Prism(Cube):
+ """A right rectangular prism (or rectangular cuboid).
+ Defined by the length of each side in ``[x, y, z]`` format.
+
+ Parameters
+ ----------
+ dimensions
+ Dimensions of the :class:`Prism` in ``[x, y, z]`` format.
+
+ Examples
+ --------
+
+ .. manim:: ExamplePrism
+ :save_last_frame:
+
+ class ExamplePrism(ThreeDScene):
+ def construct(self):
+ self.set_camera_orientation(phi=60 * DEGREES, theta=150 * DEGREES)
+ prismSmall = Prism(dimensions=[1, 2, 3]).rotate(PI / 2)
+ prismLarge = Prism(dimensions=[1.5, 3, 4.5]).move_to([2, 0, 0])
+ self.add(prismSmall, prismLarge)
+ """
+
+ def __init__(
+ self, dimensions: tuple[float, float, float] | np.ndarray = [3, 2, 1], **kwargs
+ ) -> None:
+ self.dimensions = dimensions
+ super().__init__(**kwargs)
+
+ def generate_points(self) -> None:
+ """Creates the sides of the :class:`Prism`."""
+ super().generate_points()
+ for dim, value in enumerate(self.dimensions):
+ self.rescale_to_fit(value, dim, stretch=True)
+
+
+class Cone(Surface):
+ """A circular cone.
+ Can be defined using 2 parameters: its height, and its base radius.
+ The polar angle, theta, can be calculated using arctan(base_radius /
+ height) The spherical radius, r, is calculated using the pythagorean
+ theorem.
+
+ Parameters
+ ----------
+ base_radius
+ The base radius from which the cone tapers.
+ height
+ The height measured from the plane formed by the base_radius to
+ the apex of the cone.
+ direction
+ The direction of the apex.
+ show_base
+ Whether to show the base plane or not.
+ v_range
+ The azimuthal angle to start and end at.
+ u_min
+ The radius at the apex.
+ checkerboard_colors
+ Show checkerboard grid texture on the cone.
+
+ Examples
+ --------
+ .. manim:: ExampleCone
+ :save_last_frame:
+
+ class ExampleCone(ThreeDScene):
+ def construct(self):
+ axes = ThreeDAxes()
+ cone = Cone(direction=X_AXIS+Y_AXIS+2*Z_AXIS, resolution=8)
+ self.set_camera_orientation(phi=5*PI/11, theta=PI/9)
+ self.add(axes, cone)
+ """
+
+ def __init__(
+ self,
+ base_radius: float = 1,
+ height: float = 1,
+ direction: np.ndarray = Z_AXIS,
+ show_base: bool = False,
+ v_range: Sequence[float] = [0, TAU],
+ u_min: float = 0,
+ checkerboard_colors: bool = False,
+ **kwargs: Any,
+ ) -> None:
+ self.direction = direction
+ self.theta = PI - np.arctan(base_radius / height)
+
+ super().__init__(
+ self.func,
+ v_range=v_range,
+ u_range=[u_min, np.sqrt(base_radius**2 + height**2)],
+ checkerboard_colors=checkerboard_colors,
+ **kwargs,
+ )
+ # used for rotations
+ self._current_theta = 0
+ self._current_phi = 0
+
+ if show_base:
+ self.base_circle = Circle(
+ radius=base_radius,
+ color=self.fill_color,
+ fill_opacity=self.fill_opacity,
+ stroke_width=0,
+ )
+ self.base_circle.shift(height * IN)
+ self.add(self.base_circle)
+
+ self._rotate_to_direction()
+
+ def func(self, u: float, v: float) -> np.ndarray:
+ """Converts from spherical coordinates to cartesian.
+
+ Parameters
+ ----------
+ u
+ The radius.
+ v
+ The azimuthal angle.
+
+ Returns
+ -------
+ :class:`numpy.array`
+ Points defining the :class:`Cone`.
+ """
+ r = u
+ phi = v
+ return np.array(
+ [
+ r * np.sin(self.theta) * np.cos(phi),
+ r * np.sin(self.theta) * np.sin(phi),
+ r * np.cos(self.theta),
+ ],
+ )
+
+ def _rotate_to_direction(self) -> None:
+ x, y, z = self.direction
+
+ r = np.sqrt(x**2 + y**2 + z**2)
+ if r > 0:
+ theta = np.arccos(z / r)
+ else:
+ theta = 0
+
+ if x == 0:
+ if y == 0: # along the z axis
+ phi = 0
+ else:
+ phi = np.arctan(np.inf)
+ if y < 0:
+ phi += PI
+ else:
+ phi = np.arctan(y / x)
+ if x < 0:
+ phi += PI
+
+ # Undo old rotation (in reverse order)
+ self.rotate(-self._current_phi, Z_AXIS, about_point=ORIGIN)
+ self.rotate(-self._current_theta, Y_AXIS, about_point=ORIGIN)
+
+ # Do new rotation
+ self.rotate(theta, Y_AXIS, about_point=ORIGIN)
+ self.rotate(phi, Z_AXIS, about_point=ORIGIN)
+
+ # Store values
+ self._current_theta = theta
+ self._current_phi = phi
+
+ def set_direction(self, direction: np.ndarray) -> None:
+ """Changes the direction of the apex of the :class:`Cone`.
+
+ Parameters
+ ----------
+ direction
+ The direction of the apex.
+ """
+ self.direction = direction
+ self._rotate_to_direction()
+
+ def get_direction(self) -> np.ndarray:
+ """Returns the current direction of the apex of the :class:`Cone`.
+
+ Returns
+ -------
+ direction : :class:`numpy.array`
+ The direction of the apex.
+ """
+ return self.direction
+
+
+class Cylinder(Surface):
+ """A cylinder, defined by its height, radius and direction,
+
+ Parameters
+ ----------
+ radius
+ The radius of the cylinder.
+ height
+ The height of the cylinder.
+ direction
+ The direction of the central axis of the cylinder.
+ v_range
+ The height along the height axis (given by direction) to start and end on.
+ show_ends
+ Whether to show the end caps or not.
+ resolution
+ The number of samples taken of the :class:`Cylinder`. A tuple can be used
+ to define different resolutions for ``u`` and ``v`` respectively.
+
+ Examples
+ --------
+ .. manim:: ExampleCylinder
+ :save_last_frame:
+
+ class ExampleCylinder(ThreeDScene):
+ def construct(self):
+ axes = ThreeDAxes()
+ cylinder = Cylinder(radius=2, height=3)
+ self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+ self.add(axes, cylinder)
+ """
+
+ def __init__(
+ self,
+ radius: float = 1,
+ height: float = 2,
+ direction: np.ndarray = Z_AXIS,
+ v_range: Sequence[float] = [0, TAU],
+ show_ends: bool = True,
+ resolution: Sequence[int] = (24, 24),
+ **kwargs,
+ ) -> None:
+ self._height = height
+ self.radius = radius
+ super().__init__(
+ self.func,
+ resolution=resolution,
+ u_range=[-self._height / 2, self._height / 2],
+ v_range=v_range,
+ **kwargs,
+ )
+ if show_ends:
+ self.add_bases()
+ self._current_phi = 0
+ self._current_theta = 0
+ self.set_direction(direction)
+
+ def func(self, u: float, v: float) -> np.ndarray:
+ """Converts from cylindrical coordinates to cartesian.
+
+ Parameters
+ ----------
+ u
+ The height.
+ v
+ The azimuthal angle.
+
+ Returns
+ -------
+ :class:`numpy.ndarray`
+ Points defining the :class:`Cylinder`.
+ """
+ height = u
+ phi = v
+ r = self.radius
+ return np.array([r * np.cos(phi), r * np.sin(phi), height])
+
+ def add_bases(self) -> None:
+ """Adds the end caps of the cylinder."""
+ if config.renderer == RendererType.OPENGL:
+ color = self.color
+ opacity = self.opacity
+ elif config.renderer == RendererType.CAIRO:
+ color = self.fill_color
+ opacity = self.fill_opacity
+
+ self.base_top = Circle(
+ radius=self.radius,
+ color=color,
+ fill_opacity=opacity,
+ shade_in_3d=True,
+ stroke_width=0,
+ )
+ self.base_top.shift(self.u_range[1] * IN)
+ self.base_bottom = Circle(
+ radius=self.radius,
+ color=color,
+ fill_opacity=opacity,
+ shade_in_3d=True,
+ stroke_width=0,
+ )
+ self.base_bottom.shift(self.u_range[0] * IN)
+ self.add(self.base_top, self.base_bottom)
+
+ def _rotate_to_direction(self) -> None:
+ x, y, z = self.direction
+
+ r = np.sqrt(x**2 + y**2 + z**2)
+ if r > 0:
+ theta = np.arccos(z / r)
+ else:
+ theta = 0
+
+ if x == 0:
+ if y == 0: # along the z axis
+ phi = 0
+ else: # along the x axis
+ phi = np.arctan(np.inf)
+ if y < 0:
+ phi += PI
+ else:
+ phi = np.arctan(y / x)
+ if x < 0:
+ phi += PI
+
+ # undo old rotation (in reverse direction)
+ self.rotate(-self._current_phi, Z_AXIS, about_point=ORIGIN)
+ self.rotate(-self._current_theta, Y_AXIS, about_point=ORIGIN)
+
+ # do new rotation
+ self.rotate(theta, Y_AXIS, about_point=ORIGIN)
+ self.rotate(phi, Z_AXIS, about_point=ORIGIN)
+
+ # store new values
+ self._current_theta = theta
+ self._current_phi = phi
+
+ def set_direction(self, direction: np.ndarray) -> None:
+ """Sets the direction of the central axis of the :class:`Cylinder`.
+
+ Parameters
+ ----------
+ direction : :class:`numpy.array`
+ The direction of the central axis of the :class:`Cylinder`.
+ """
+ # if get_norm(direction) is get_norm(self.direction):
+ # pass
+ self.direction = direction
+ self._rotate_to_direction()
+
+ def get_direction(self) -> np.ndarray:
+ """Returns the direction of the central axis of the :class:`Cylinder`.
+
+ Returns
+ -------
+ direction : :class:`numpy.array`
+ The direction of the central axis of the :class:`Cylinder`.
+ """
+ return self.direction
+
+
+class Line3D(Cylinder):
+ """A cylindrical line, for use in ThreeDScene.
+
+ Parameters
+ ----------
+ start
+ The start point of the line.
+ end
+ The end point of the line.
+ thickness
+ The thickness of the line.
+ color
+ The color of the line.
+
+ Examples
+ --------
+ .. manim:: ExampleLine3D
+ :save_last_frame:
+
+ class ExampleLine3D(ThreeDScene):
+ def construct(self):
+ axes = ThreeDAxes()
+ line = Line3D(start=np.array([0, 0, 0]), end=np.array([2, 2, 2]))
+ self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+ self.add(axes, line)
+ """
+
+ def __init__(
+ self,
+ start: np.ndarray = LEFT,
+ end: np.ndarray = RIGHT,
+ thickness: float = 0.02,
+ color: ParsableManimColor | None = None,
+ **kwargs,
+ ):
+ self.thickness = thickness
+ self.set_start_and_end_attrs(start, end, **kwargs)
+ if color is not None:
+ self.set_color(color)
+
+ def set_start_and_end_attrs(
+ self, start: np.ndarray, end: np.ndarray, **kwargs
+ ) -> None:
+ """Sets the start and end points of the line.
+
+ If either ``start`` or ``end`` are :class:`Mobjects <.Mobject>`,
+ this gives their centers.
+
+ Parameters
+ ----------
+ start
+ Starting point or :class:`Mobject`.
+ end
+ Ending point or :class:`Mobject`.
+ """
+ rough_start = self.pointify(start)
+ rough_end = self.pointify(end)
+ self.vect = rough_end - rough_start
+ self.length = np.linalg.norm(self.vect)
+ self.direction = normalize(self.vect)
+ # Now that we know the direction between them,
+ # we can the appropriate boundary point from
+ # start and end, if they're mobjects
+ self.start = self.pointify(start, self.direction)
+ self.end = self.pointify(end, -self.direction)
+ super().__init__(
+ height=np.linalg.norm(self.vect),
+ radius=self.thickness,
+ direction=self.direction,
+ **kwargs,
+ )
+ self.shift((self.start + self.end) / 2)
+
+ def pointify(
+ self,
+ mob_or_point: Mobject | Point3D,
+ direction: Vector3 = None,
+ ) -> np.ndarray:
+ """Gets a point representing the center of the :class:`Mobjects <.Mobject>`.
+
+ Parameters
+ ----------
+ mob_or_point
+ :class:`Mobjects <.Mobject>` or point whose center should be returned.
+ direction
+ If an edge of a :class:`Mobjects <.Mobject>` should be returned, the direction of the edge.
+
+ Returns
+ -------
+ :class:`numpy.array`
+ Center of the :class:`Mobjects <.Mobject>` or point, or edge if direction is given.
+ """
+ if isinstance(mob_or_point, (Mobject, OpenGLMobject)):
+ mob = mob_or_point
+ if direction is None:
+ return mob.get_center()
+ else:
+ return mob.get_boundary_point(direction)
+ return np.array(mob_or_point)
+
+ def get_start(self) -> np.ndarray:
+ """Returns the starting point of the :class:`Line3D`.
+
+ Returns
+ -------
+ start : :class:`numpy.array`
+ Starting point of the :class:`Line3D`.
+ """
+ return self.start
+
+ def get_end(self) -> np.ndarray:
+ """Returns the ending point of the :class:`Line3D`.
+
+ Returns
+ -------
+ end : :class:`numpy.array`
+ Ending point of the :class:`Line3D`.
+ """
+ return self.end
+
+ @classmethod
+ def parallel_to(
+ cls,
+ line: Line3D,
+ point: Vector3 = ORIGIN,
+ length: float = 5,
+ **kwargs,
+ ) -> Line3D:
+ """Returns a line parallel to another line going through
+ a given point.
+
+ Parameters
+ ----------
+ line
+ The line to be parallel to.
+ point
+ The point to pass through.
+ length
+ Length of the parallel line.
+ kwargs
+ Additional parameters to be passed to the class.
+
+ Returns
+ -------
+ :class:`Line3D`
+ Line parallel to ``line``.
+
+ Examples
+ --------
+ .. manim:: ParallelLineExample
+ :save_last_frame:
+
+ class ParallelLineExample(ThreeDScene):
+ def construct(self):
+ self.set_camera_orientation(PI / 3, -PI / 4)
+ ax = ThreeDAxes((-5, 5), (-5, 5), (-5, 5), 10, 10, 10)
+ line1 = Line3D(RIGHT * 2, UP + OUT, color=RED)
+ line2 = Line3D.parallel_to(line1, color=YELLOW)
+ self.add(ax, line1, line2)
+ """
+ point = np.array(point)
+ vect = normalize(line.vect)
+ return cls(
+ point + vect * length / 2,
+ point - vect * length / 2,
+ **kwargs,
+ )
+
+ @classmethod
+ def perpendicular_to(
+ cls,
+ line: Line3D,
+ point: Vector3 = ORIGIN,
+ length: float = 5,
+ **kwargs,
+ ) -> Line3D:
+ """Returns a line perpendicular to another line going through
+ a given point.
+
+ Parameters
+ ----------
+ line
+ The line to be perpendicular to.
+ point
+ The point to pass through.
+ length
+ Length of the perpendicular line.
+ kwargs
+ Additional parameters to be passed to the class.
+
+ Returns
+ -------
+ :class:`Line3D`
+ Line perpendicular to ``line``.
+
+ Examples
+ --------
+ .. manim:: PerpLineExample
+ :save_last_frame:
+
+ class PerpLineExample(ThreeDScene):
+ def construct(self):
+ self.set_camera_orientation(PI / 3, -PI / 4)
+ ax = ThreeDAxes((-5, 5), (-5, 5), (-5, 5), 10, 10, 10)
+ line1 = Line3D(RIGHT * 2, UP + OUT, color=RED)
+ line2 = Line3D.perpendicular_to(line1, color=BLUE)
+ self.add(ax, line1, line2)
+ """
+ point = np.array(point)
+
+ norm = np.cross(line.vect, point - line.start)
+ if all(np.linalg.norm(norm) == np.zeros(3)):
+ raise ValueError("Could not find the perpendicular.")
+
+ start, end = perpendicular_bisector([line.start, line.end], norm)
+ vect = normalize(end - start)
+ return cls(
+ point + vect * length / 2,
+ point - vect * length / 2,
+ **kwargs,
+ )
+
+
+class Arrow3D(Line3D):
+ """An arrow made out of a cylindrical line and a conical tip.
+
+ Parameters
+ ----------
+ start
+ The start position of the arrow.
+ end
+ The end position of the arrow.
+ thickness
+ The thickness of the arrow.
+ height
+ The height of the conical tip.
+ base_radius
+ The base radius of the conical tip.
+ color
+ The color of the arrow.
+
+ Examples
+ --------
+ .. manim:: ExampleArrow3D
+ :save_last_frame:
+
+ class ExampleArrow3D(ThreeDScene):
+ def construct(self):
+ axes = ThreeDAxes()
+ arrow = Arrow3D(
+ start=np.array([0, 0, 0]),
+ end=np.array([2, 2, 2]),
+ resolution=8
+ )
+ self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+ self.add(axes, arrow)
+ """
+
+ def __init__(
+ self,
+ start: np.ndarray = LEFT,
+ end: np.ndarray = RIGHT,
+ thickness: float = 0.02,
+ height: float = 0.3,
+ base_radius: float = 0.08,
+ color: ParsableManimColor = WHITE,
+ **kwargs,
+ ) -> None:
+ super().__init__(
+ start=start, end=end, thickness=thickness, color=color, **kwargs
+ )
+
+ self.length = np.linalg.norm(self.vect)
+ self.set_start_and_end_attrs(
+ self.start,
+ self.end - height * self.direction,
+ **kwargs,
+ )
+
+ self.cone = Cone(
+ direction=self.direction, base_radius=base_radius, height=height, **kwargs
+ )
+ self.cone.shift(end)
+ self.add(self.cone)
+ self.set_color(color)
+
+
+class Torus(Surface):
+ """A torus.
+
+ Parameters
+ ----------
+ major_radius
+ Distance from the center of the tube to the center of the torus.
+ minor_radius
+ Radius of the tube.
+ u_range
+ The range of the ``u`` variable: ``(u_min, u_max)``.
+ v_range
+ The range of the ``v`` variable: ``(v_min, v_max)``.
+ resolution
+ The number of samples taken of the :class:`Torus`. A tuple can be
+ used to define different resolutions for ``u`` and ``v`` respectively.
+
+ Examples
+ --------
+ .. manim :: ExampleTorus
+ :save_last_frame:
+
+ class ExampleTorus(ThreeDScene):
+ def construct(self):
+ axes = ThreeDAxes()
+ torus = Torus()
+ self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+ self.add(axes, torus)
+ """
+
+ def __init__(
+ self,
+ major_radius: float = 3,
+ minor_radius: float = 1,
+ u_range: Sequence[float] = (0, TAU),
+ v_range: Sequence[float] = (0, TAU),
+ resolution: tuple[int, int] | None = None,
+ **kwargs,
+ ) -> None:
+ if config.renderer == RendererType.OPENGL:
+ res_value = (101, 101)
+ elif config.renderer == RendererType.CAIRO:
+ res_value = (24, 24)
+
+ resolution = resolution if resolution is not None else res_value
+
+ self.R = major_radius
+ self.r = minor_radius
+ super().__init__(
+ self.func,
+ u_range=u_range,
+ v_range=v_range,
+ resolution=resolution,
+ **kwargs,
+ )
+
+ def func(self, u: float, v: float) -> np.ndarray:
+ """The z values defining the :class:`Torus` being plotted.
+
+ Returns
+ -------
+ :class:`numpy.ndarray`
+ The z values defining the :class:`Torus`.
+ """
+ P = np.array([np.cos(u), np.sin(u), 0])
+ return (self.R - self.r * np.cos(v)) * P - self.r * np.sin(v) * OUT
diff --git a/data/rag/manim_docs/manim_core/source/mobject/types/__init__.py b/data/rag/manim_docs/manim_core/source/mobject/types/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c73aaa28a67072aae8c61923d3f6a2946593a70
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/mobject/types/__init__.py
@@ -0,0 +1,12 @@
+"""Specialized mobject base classes.
+
+Modules
+=======
+
+.. autosummary::
+ :toctree: ../reference
+
+ ~image_mobject
+ ~point_cloud_mobject
+ ~vectorized_mobject
+"""
diff --git a/data/rag/manim_docs/manim_core/source/mobject/types/image_mobject.py b/data/rag/manim_docs/manim_core/source/mobject/types/image_mobject.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb0248d3a5e8b14a4704c039dcb622c2cf364db2
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/mobject/types/image_mobject.py
@@ -0,0 +1,325 @@
+"""Mobjects representing raster images."""
+
+from __future__ import annotations
+
+__all__ = ["AbstractImageMobject", "ImageMobject", "ImageMobjectFromCamera"]
+
+import pathlib
+
+import numpy as np
+from PIL import Image
+from PIL.Image import Resampling
+
+from manim.mobject.geometry.shape_matchers import SurroundingRectangle
+
+from ... import config
+from ...constants import *
+from ...mobject.mobject import Mobject
+from ...utils.bezier import interpolate
+from ...utils.color import WHITE, ManimColor, color_to_int_rgb
+from ...utils.images import change_to_rgba_array, get_full_raster_image_path
+
+
+class AbstractImageMobject(Mobject):
+ """
+ Automatically filters out black pixels
+
+ Parameters
+ ----------
+ scale_to_resolution
+ At this resolution the image is placed pixel by pixel onto the screen, so it
+ will look the sharpest and best.
+ This is a custom parameter of ImageMobject so that rendering a scene with
+ e.g. the ``--quality low`` or ``--quality medium`` flag for faster rendering
+ won't effect the position of the image on the screen.
+ """
+
+ def __init__(
+ self,
+ scale_to_resolution: int,
+ pixel_array_dtype="uint8",
+ resampling_algorithm=Resampling.BICUBIC,
+ **kwargs,
+ ):
+ self.pixel_array_dtype = pixel_array_dtype
+ self.scale_to_resolution = scale_to_resolution
+ self.set_resampling_algorithm(resampling_algorithm)
+ super().__init__(**kwargs)
+
+ def get_pixel_array(self):
+ raise NotImplementedError()
+
+ def set_color(self, color, alpha=None, family=True):
+ # Likely to be implemented in subclasses, but no obligation
+ pass
+
+ def set_resampling_algorithm(self, resampling_algorithm: int):
+ """
+ Sets the interpolation method for upscaling the image. By default the image is
+ interpolated using bicubic algorithm. This method lets you change it.
+ Interpolation is done internally using Pillow, and the function besides the
+ string constants describing the algorithm accepts the Pillow integer constants.
+
+ Parameters
+ ----------
+ resampling_algorithm
+ An integer constant described in the Pillow library,
+ or one from the RESAMPLING_ALGORITHMS global dictionary,
+ under the following keys:
+
+ * 'bicubic' or 'cubic'
+ * 'nearest' or 'none'
+ * 'box'
+ * 'bilinear' or 'linear'
+ * 'hamming'
+ * 'lanczos' or 'antialias'
+ """
+ if isinstance(resampling_algorithm, int):
+ self.resampling_algorithm = resampling_algorithm
+ else:
+ raise ValueError(
+ "resampling_algorithm has to be an int, one of the values defined in "
+ "RESAMPLING_ALGORITHMS or a Pillow resampling filter constant. "
+ "Available algorithms: 'bicubic', 'nearest', 'box', 'bilinear', "
+ "'hamming', 'lanczos'.",
+ )
+ return self
+
+ def reset_points(self):
+ """Sets :attr:`points` to be the four image corners."""
+ self.points = np.array(
+ [
+ UP + LEFT,
+ UP + RIGHT,
+ DOWN + LEFT,
+ DOWN + RIGHT,
+ ],
+ )
+ self.center()
+ h, w = self.get_pixel_array().shape[:2]
+ if self.scale_to_resolution:
+ height = h / self.scale_to_resolution * config["frame_height"]
+ else:
+ height = 3 # this is the case for ImageMobjectFromCamera
+ self.stretch_to_fit_height(height)
+ self.stretch_to_fit_width(height * w / h)
+
+
+class ImageMobject(AbstractImageMobject):
+ """Displays an Image from a numpy array or a file.
+
+ Parameters
+ ----------
+ scale_to_resolution
+ At this resolution the image is placed pixel by pixel onto the screen, so it
+ will look the sharpest and best.
+ This is a custom parameter of ImageMobject so that rendering a scene with
+ e.g. the ``--quality low`` or ``--quality medium`` flag for faster rendering
+ won't effect the position of the image on the screen.
+
+
+ Example
+ -------
+ .. manim:: ImageFromArray
+ :save_last_frame:
+
+ class ImageFromArray(Scene):
+ def construct(self):
+ image = ImageMobject(np.uint8([[0, 100, 30, 200],
+ [255, 0, 5, 33]]))
+ image.height = 7
+ self.add(image)
+
+
+ Changing interpolation style:
+
+ .. manim:: ImageInterpolationEx
+ :save_last_frame:
+
+ class ImageInterpolationEx(Scene):
+ def construct(self):
+ img = ImageMobject(np.uint8([[63, 0, 0, 0],
+ [0, 127, 0, 0],
+ [0, 0, 191, 0],
+ [0, 0, 0, 255]
+ ]))
+
+ img.height = 2
+ img1 = img.copy()
+ img2 = img.copy()
+ img3 = img.copy()
+ img4 = img.copy()
+ img5 = img.copy()
+
+ img1.set_resampling_algorithm(RESAMPLING_ALGORITHMS["nearest"])
+ img2.set_resampling_algorithm(RESAMPLING_ALGORITHMS["lanczos"])
+ img3.set_resampling_algorithm(RESAMPLING_ALGORITHMS["linear"])
+ img4.set_resampling_algorithm(RESAMPLING_ALGORITHMS["cubic"])
+ img5.set_resampling_algorithm(RESAMPLING_ALGORITHMS["box"])
+ img1.add(Text("nearest").scale(0.5).next_to(img1,UP))
+ img2.add(Text("lanczos").scale(0.5).next_to(img2,UP))
+ img3.add(Text("linear").scale(0.5).next_to(img3,UP))
+ img4.add(Text("cubic").scale(0.5).next_to(img4,UP))
+ img5.add(Text("box").scale(0.5).next_to(img5,UP))
+
+ x= Group(img1,img2,img3,img4,img5)
+ x.arrange()
+ self.add(x)
+ """
+
+ def __init__(
+ self,
+ filename_or_array,
+ scale_to_resolution: int = QUALITIES[DEFAULT_QUALITY]["pixel_height"],
+ invert=False,
+ image_mode="RGBA",
+ **kwargs,
+ ):
+ self.fill_opacity = 1
+ self.stroke_opacity = 1
+ self.invert = invert
+ self.image_mode = image_mode
+ if isinstance(filename_or_array, (str, pathlib.PurePath)):
+ path = get_full_raster_image_path(filename_or_array)
+ image = Image.open(path).convert(self.image_mode)
+ self.pixel_array = np.array(image)
+ self.path = path
+ else:
+ self.pixel_array = np.array(filename_or_array)
+ self.pixel_array_dtype = kwargs.get("pixel_array_dtype", "uint8")
+ self.pixel_array = change_to_rgba_array(
+ self.pixel_array, self.pixel_array_dtype
+ )
+ if self.invert:
+ self.pixel_array[:, :, :3] = 255 - self.pixel_array[:, :, :3]
+ super().__init__(scale_to_resolution, **kwargs)
+
+ def get_pixel_array(self):
+ """A simple getter method."""
+ return self.pixel_array
+
+ def set_color(self, color, alpha=None, family=True):
+ rgb = color_to_int_rgb(color)
+ self.pixel_array[:, :, :3] = rgb
+ if alpha is not None:
+ self.pixel_array[:, :, 3] = int(255 * alpha)
+ for submob in self.submobjects:
+ submob.set_color(color, alpha, family)
+ self.color = color
+ return self
+
+ def set_opacity(self, alpha: float):
+ """Sets the image's opacity.
+
+ Parameters
+ ----------
+ alpha
+ The alpha value of the object, 1 being opaque and 0 being
+ transparent.
+ """
+ self.pixel_array[:, :, 3] = int(255 * alpha)
+ self.fill_opacity = alpha
+ self.stroke_opacity = alpha
+ return self
+
+ def fade(self, darkness: float = 0.5, family: bool = True):
+ """Sets the image's opacity using a 1 - alpha relationship.
+
+ Parameters
+ ----------
+ darkness
+ The alpha value of the object, 1 being transparent and 0 being
+ opaque.
+ family
+ Whether the submobjects of the ImageMobject should be affected.
+ """
+ self.set_opacity(1 - darkness)
+ super().fade(darkness, family)
+ return self
+
+ def interpolate_color(
+ self, mobject1: ImageMobject, mobject2: ImageMobject, alpha: float
+ ):
+ """Interpolates the array of pixel color values from one ImageMobject
+ into an array of equal size in the target ImageMobject.
+
+ Parameters
+ ----------
+ mobject1
+ The ImageMobject to transform from.
+
+ mobject2
+ The ImageMobject to transform into.
+
+ alpha
+ Used to track the lerp relationship. Not opacity related.
+ """
+ assert mobject1.pixel_array.shape == mobject2.pixel_array.shape, (
+ f"Mobject pixel array shapes incompatible for interpolation.\n"
+ f"Mobject 1 ({mobject1}) : {mobject1.pixel_array.shape}\n"
+ f"Mobject 2 ({mobject2}) : {mobject2.pixel_array.shape}"
+ )
+ self.fill_opacity = interpolate(
+ mobject1.fill_opacity,
+ mobject2.fill_opacity,
+ alpha,
+ )
+ self.stroke_opacity = interpolate(
+ mobject1.stroke_opacity,
+ mobject2.stroke_opacity,
+ alpha,
+ )
+ self.pixel_array = interpolate(
+ mobject1.pixel_array,
+ mobject2.pixel_array,
+ alpha,
+ ).astype(self.pixel_array_dtype)
+
+ def get_style(self):
+ return {
+ "fill_color": ManimColor(self.color.get_rgb()).to_hex(),
+ "fill_opacity": self.fill_opacity,
+ }
+
+
+# TODO, add the ability to have the dimensions/orientation of this
+# mobject more strongly tied to the frame of the camera it contains,
+# in the case where that's a MovingCamera
+
+
+class ImageMobjectFromCamera(AbstractImageMobject):
+ def __init__(self, camera, default_display_frame_config=None, **kwargs):
+ self.camera = camera
+ if default_display_frame_config is None:
+ default_display_frame_config = {
+ "stroke_width": 3,
+ "stroke_color": WHITE,
+ "buff": 0,
+ }
+ self.default_display_frame_config = default_display_frame_config
+ self.pixel_array = self.camera.pixel_array
+ super().__init__(scale_to_resolution=False, **kwargs)
+
+ # TODO: Get rid of this.
+ def get_pixel_array(self):
+ self.pixel_array = self.camera.pixel_array
+ return self.pixel_array
+
+ def add_display_frame(self, **kwargs):
+ config = dict(self.default_display_frame_config)
+ config.update(kwargs)
+ self.display_frame = SurroundingRectangle(self, **config)
+ self.add(self.display_frame)
+ return self
+
+ def interpolate_color(self, mobject1, mobject2, alpha):
+ assert mobject1.pixel_array.shape == mobject2.pixel_array.shape, (
+ f"Mobject pixel array shapes incompatible for interpolation.\n"
+ f"Mobject 1 ({mobject1}) : {mobject1.pixel_array.shape}\n"
+ f"Mobject 2 ({mobject2}) : {mobject2.pixel_array.shape}"
+ )
+ self.pixel_array = interpolate(
+ mobject1.pixel_array,
+ mobject2.pixel_array,
+ alpha,
+ ).astype(self.pixel_array_dtype)
diff --git a/data/rag/manim_docs/manim_core/source/mobject/types/point_cloud_mobject.py b/data/rag/manim_docs/manim_core/source/mobject/types/point_cloud_mobject.py
new file mode 100644
index 0000000000000000000000000000000000000000..43e2ff08e20308c7294f685cc77ab30d9180a6e2
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/mobject/types/point_cloud_mobject.py
@@ -0,0 +1,382 @@
+"""Mobjects representing point clouds."""
+
+from __future__ import annotations
+
+__all__ = ["PMobject", "Mobject1D", "Mobject2D", "PGroup", "PointCloudDot", "Point"]
+
+import numpy as np
+
+from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
+from manim.mobject.opengl.opengl_point_cloud_mobject import OpenGLPMobject
+
+from ...constants import *
+from ...mobject.mobject import Mobject
+from ...utils.bezier import interpolate
+from ...utils.color import (
+ BLACK,
+ WHITE,
+ YELLOW,
+ ManimColor,
+ color_gradient,
+ color_to_rgba,
+ rgba_to_color,
+)
+from ...utils.iterables import stretch_array_to_length
+
+
+class PMobject(Mobject, metaclass=ConvertToOpenGL):
+ """A disc made of a cloud of Dots
+
+ Examples
+ --------
+
+ .. manim:: PMobjectExample
+ :save_last_frame:
+
+ class PMobjectExample(Scene):
+ def construct(self):
+
+ pG = PGroup() # This is just a collection of PMobject's
+
+ # As the scale factor increases, the number of points
+ # removed increases.
+ for sf in range(1, 9 + 1):
+ p = PointCloudDot(density=20, radius=1).thin_out(sf)
+ # PointCloudDot is a type of PMobject
+ # and can therefore be added to a PGroup
+ pG.add(p)
+
+ # This organizes all the shapes in a grid.
+ pG.arrange_in_grid()
+
+ self.add(pG)
+
+ """
+
+ def __init__(self, stroke_width=DEFAULT_STROKE_WIDTH, **kwargs):
+ self.stroke_width = stroke_width
+ super().__init__(**kwargs)
+
+ def reset_points(self):
+ self.rgbas = np.zeros((0, 4))
+ self.points = np.zeros((0, 3))
+ return self
+
+ def get_array_attrs(self):
+ return super().get_array_attrs() + ["rgbas"]
+
+ def add_points(self, points, rgbas=None, color=None, alpha=1):
+ """Add points.
+
+ Points must be a Nx3 numpy array.
+ Rgbas must be a Nx4 numpy array if it is not None.
+ """
+ if not isinstance(points, np.ndarray):
+ points = np.array(points)
+ num_new_points = len(points)
+ self.points = np.append(self.points, points, axis=0)
+ if rgbas is None:
+ color = ManimColor(color) if color else self.color
+ rgbas = np.repeat([color_to_rgba(color, alpha)], num_new_points, axis=0)
+ elif len(rgbas) != len(points):
+ raise ValueError("points and rgbas must have same length")
+ self.rgbas = np.append(self.rgbas, rgbas, axis=0)
+ return self
+
+ def set_color(self, color=YELLOW, family=True):
+ rgba = color_to_rgba(color)
+ mobs = self.family_members_with_points() if family else [self]
+ for mob in mobs:
+ mob.rgbas[:, :] = rgba
+ self.color = color
+ return self
+
+ def get_stroke_width(self):
+ return self.stroke_width
+
+ def set_stroke_width(self, width, family=True):
+ mobs = self.family_members_with_points() if family else [self]
+ for mob in mobs:
+ mob.stroke_width = width
+ return self
+
+ def set_color_by_gradient(self, *colors):
+ self.rgbas = np.array(
+ list(map(color_to_rgba, color_gradient(*colors, len(self.points)))),
+ )
+ return self
+
+ def set_colors_by_radial_gradient(
+ self,
+ center=None,
+ radius=1,
+ inner_color=WHITE,
+ outer_color=BLACK,
+ ):
+ start_rgba, end_rgba = list(map(color_to_rgba, [inner_color, outer_color]))
+ if center is None:
+ center = self.get_center()
+ for mob in self.family_members_with_points():
+ distances = np.abs(self.points - center)
+ alphas = np.linalg.norm(distances, axis=1) / radius
+
+ mob.rgbas = np.array(
+ np.array(
+ [interpolate(start_rgba, end_rgba, alpha) for alpha in alphas],
+ ),
+ )
+ return self
+
+ def match_colors(self, mobject):
+ Mobject.align_data(self, mobject)
+ self.rgbas = np.array(mobject.rgbas)
+ return self
+
+ def filter_out(self, condition):
+ for mob in self.family_members_with_points():
+ to_eliminate = ~np.apply_along_axis(condition, 1, mob.points)
+ mob.points = mob.points[to_eliminate]
+ mob.rgbas = mob.rgbas[to_eliminate]
+ return self
+
+ def thin_out(self, factor=5):
+ """
+ Removes all but every nth point for n = factor
+ """
+ for mob in self.family_members_with_points():
+ num_points = self.get_num_points()
+ mob.apply_over_attr_arrays(
+ lambda arr: arr[np.arange(0, num_points, factor)],
+ )
+ return self
+
+ def sort_points(self, function=lambda p: p[0]):
+ """
+ Function is any map from R^3 to R
+ """
+ for mob in self.family_members_with_points():
+ indices = np.argsort(np.apply_along_axis(function, 1, mob.points))
+ mob.apply_over_attr_arrays(lambda arr: arr[indices])
+ return self
+
+ def fade_to(self, color, alpha, family=True):
+ self.rgbas = interpolate(self.rgbas, color_to_rgba(color), alpha)
+ for mob in self.submobjects:
+ mob.fade_to(color, alpha, family)
+ return self
+
+ def get_all_rgbas(self):
+ return self.get_merged_array("rgbas")
+
+ def ingest_submobjects(self):
+ attrs = self.get_array_attrs()
+ arrays = list(map(self.get_merged_array, attrs))
+ for attr, array in zip(attrs, arrays):
+ setattr(self, attr, array)
+ self.submobjects = []
+ return self
+
+ def get_color(self):
+ return rgba_to_color(self.rgbas[0, :])
+
+ def point_from_proportion(self, alpha):
+ index = alpha * (self.get_num_points() - 1)
+ return self.points[index]
+
+ @staticmethod
+ def get_mobject_type_class():
+ return PMobject
+
+ # Alignment
+ def align_points_with_larger(self, larger_mobject):
+ assert isinstance(larger_mobject, PMobject)
+ self.apply_over_attr_arrays(
+ lambda a: stretch_array_to_length(a, larger_mobject.get_num_points()),
+ )
+
+ def get_point_mobject(self, center=None):
+ if center is None:
+ center = self.get_center()
+ return Point(center)
+
+ def interpolate_color(self, mobject1, mobject2, alpha):
+ self.rgbas = interpolate(mobject1.rgbas, mobject2.rgbas, alpha)
+ self.set_stroke_width(
+ interpolate(
+ mobject1.get_stroke_width(),
+ mobject2.get_stroke_width(),
+ alpha,
+ ),
+ )
+ return self
+
+ def pointwise_become_partial(self, mobject, a, b):
+ lower_index, upper_index = (int(x * mobject.get_num_points()) for x in (a, b))
+ for attr in self.get_array_attrs():
+ full_array = getattr(mobject, attr)
+ partial_array = full_array[lower_index:upper_index]
+ setattr(self, attr, partial_array)
+
+
+# TODO, Make the two implementations below non-redundant
+class Mobject1D(PMobject, metaclass=ConvertToOpenGL):
+ def __init__(self, density=DEFAULT_POINT_DENSITY_1D, **kwargs):
+ self.density = density
+ self.epsilon = 1.0 / self.density
+ super().__init__(**kwargs)
+
+ def add_line(self, start, end, color=None):
+ start, end = list(map(np.array, [start, end]))
+ length = np.linalg.norm(end - start)
+ if length == 0:
+ points = [start]
+ else:
+ epsilon = self.epsilon / length
+ points = [interpolate(start, end, t) for t in np.arange(0, 1, epsilon)]
+ self.add_points(points, color=color)
+
+
+class Mobject2D(PMobject, metaclass=ConvertToOpenGL):
+ def __init__(self, density=DEFAULT_POINT_DENSITY_2D, **kwargs):
+ self.density = density
+ self.epsilon = 1.0 / self.density
+ super().__init__(**kwargs)
+
+
+class PGroup(PMobject):
+ """A group for several point mobjects.
+
+ Examples
+ --------
+
+ .. manim:: PgroupExample
+ :save_last_frame:
+
+ class PgroupExample(Scene):
+ def construct(self):
+
+ p1 = PointCloudDot(radius=1, density=20, color=BLUE)
+ p1.move_to(4.5 * LEFT)
+ p2 = PointCloudDot()
+ p3 = PointCloudDot(radius=1.5, stroke_width=2.5, color=PINK)
+ p3.move_to(4.5 * RIGHT)
+ pList = PGroup(p1, p2, p3)
+
+ self.add(pList)
+
+ """
+
+ def __init__(self, *pmobs, **kwargs):
+ if not all(isinstance(m, (PMobject, OpenGLPMobject)) for m in pmobs):
+ raise ValueError(
+ "All submobjects must be of type PMobject or OpenGLPMObject"
+ " if using the opengl renderer",
+ )
+ super().__init__(**kwargs)
+ self.add(*pmobs)
+
+ def fade_to(self, color, alpha, family=True):
+ if family:
+ for mob in self.submobjects:
+ mob.fade_to(color, alpha, family)
+
+
+class PointCloudDot(Mobject1D):
+ """A disc made of a cloud of dots.
+
+ Examples
+ --------
+ .. manim:: PointCloudDotExample
+ :save_last_frame:
+
+ class PointCloudDotExample(Scene):
+ def construct(self):
+ cloud_1 = PointCloudDot(color=RED)
+ cloud_2 = PointCloudDot(stroke_width=4, radius=1)
+ cloud_3 = PointCloudDot(density=15)
+
+ group = Group(cloud_1, cloud_2, cloud_3).arrange()
+ self.add(group)
+
+ .. manim:: PointCloudDotExample2
+
+ class PointCloudDotExample2(Scene):
+ def construct(self):
+ plane = ComplexPlane()
+ cloud = PointCloudDot(color=RED)
+ self.add(
+ plane, cloud
+ )
+ self.wait()
+ self.play(
+ cloud.animate.apply_complex_function(lambda z: np.exp(z))
+ )
+ """
+
+ def __init__(
+ self,
+ center=ORIGIN,
+ radius=2.0,
+ stroke_width=2,
+ density=DEFAULT_POINT_DENSITY_1D,
+ color=YELLOW,
+ **kwargs,
+ ):
+ self.radius = radius
+ self.epsilon = 1.0 / density
+ super().__init__(
+ stroke_width=stroke_width, density=density, color=color, **kwargs
+ )
+ self.shift(center)
+
+ def init_points(self):
+ self.reset_points()
+ self.generate_points()
+
+ def generate_points(self):
+ self.add_points(
+ [
+ r * (np.cos(theta) * RIGHT + np.sin(theta) * UP)
+ for r in np.arange(self.epsilon, self.radius, self.epsilon)
+ # Num is equal to int(stop - start)/ (step + 1) reformulated.
+ for theta in np.linspace(
+ 0,
+ 2 * np.pi,
+ num=int(2 * np.pi * (r + self.epsilon) / self.epsilon),
+ )
+ ],
+ )
+
+
+class Point(PMobject):
+ """A mobject representing a point.
+
+ Examples
+ --------
+
+ .. manim:: ExamplePoint
+ :save_last_frame:
+
+ class ExamplePoint(Scene):
+ def construct(self):
+ colorList = [RED, GREEN, BLUE, YELLOW]
+ for i in range(200):
+ point = Point(location=[0.63 * np.random.randint(-4, 4), 0.37 * np.random.randint(-4, 4), 0], color=np.random.choice(colorList))
+ self.add(point)
+ for i in range(200):
+ point = Point(location=[0.37 * np.random.randint(-4, 4), 0.63 * np.random.randint(-4, 4), 0], color=np.random.choice(colorList))
+ self.add(point)
+ self.add(point)
+ """
+
+ def __init__(self, location=ORIGIN, color=BLACK, **kwargs):
+ self.location = location
+ super().__init__(color=color, **kwargs)
+
+ def init_points(self):
+ self.reset_points()
+ self.generate_points()
+ self.set_points([self.location])
+
+ def generate_points(self):
+ self.add_points([self.location])
diff --git a/data/rag/manim_docs/manim_core/source/mobject/types/vectorized_mobject.py b/data/rag/manim_docs/manim_core/source/mobject/types/vectorized_mobject.py
new file mode 100644
index 0000000000000000000000000000000000000000..6048fe4c6701dda0e28c1aed41a55cd90726f18b
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/mobject/types/vectorized_mobject.py
@@ -0,0 +1,2633 @@
+"""Mobjects that use vector graphics."""
+
+from __future__ import annotations
+
+__all__ = [
+ "VMobject",
+ "VGroup",
+ "VDict",
+ "VectorizedPoint",
+ "CurvesAsSubmobjects",
+ "DashedVMobject",
+]
+
+
+import itertools as it
+import sys
+from typing import (
+ TYPE_CHECKING,
+ Callable,
+ Generator,
+ Hashable,
+ Iterable,
+ Literal,
+ Mapping,
+ Sequence,
+)
+
+import numpy as np
+import numpy.typing as npt
+from PIL.Image import Image
+from typing_extensions import Self
+
+from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
+from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVMobject
+from manim.mobject.three_d.three_d_utils import (
+ get_3d_vmob_gradient_start_and_end_points,
+)
+
+from ... import config
+from ...constants import *
+from ...mobject.mobject import Mobject
+from ...utils.bezier import (
+ bezier,
+ get_smooth_handle_points,
+ integer_interpolate,
+ interpolate,
+ partial_bezier_points,
+ proportions_along_bezier_curve_for_point,
+)
+from ...utils.color import BLACK, WHITE, ManimColor, ParsableManimColor
+from ...utils.iterables import make_even, resize_array, stretch_array_to_length, tuplify
+from ...utils.space_ops import rotate_vector, shoelace_direction
+
+if TYPE_CHECKING:
+ from manim.typing import (
+ BezierPoints,
+ CubicBezierPoints,
+ ManimFloat,
+ MappingFunction,
+ Point2D,
+ Point3D,
+ Point3D_Array,
+ QuadraticBezierPoints,
+ RGBA_Array_Float,
+ Vector3,
+ Zeros,
+ )
+
+# TODO
+# - Change cubic curve groups to have 4 points instead of 3
+# - Change sub_path idea accordingly
+# - No more mark_paths_closed, instead have the camera test
+# if last point in close to first point
+# - Think about length of self.points. Always 0 or 1 mod 4?
+# That's kind of weird.
+
+
+class VMobject(Mobject):
+ """A vectorized mobject.
+
+ Parameters
+ ----------
+ background_stroke_color
+ The purpose of background stroke is to have something
+ that won't overlap fill, e.g. For text against some
+ textured background.
+ sheen_factor
+ When a color c is set, there will be a second color
+ computed based on interpolating c to WHITE by with
+ sheen_factor, and the display will gradient to this
+ secondary color in the direction of sheen_direction.
+ close_new_points
+ Indicates that it will not be displayed, but
+ that it should count in parent mobject's path
+ tolerance_for_point_equality
+ This is within a pixel
+ joint_type
+ The line joint type used to connect the curve segments
+ of this vectorized mobject. See :class:`.LineJointType`
+ for options.
+ """
+
+ sheen_factor = 0.0
+
+ def __init__(
+ self,
+ fill_color: ParsableManimColor | None = None,
+ fill_opacity: float = 0.0,
+ stroke_color: ParsableManimColor | None = None,
+ stroke_opacity: float = 1.0,
+ stroke_width: float = DEFAULT_STROKE_WIDTH,
+ background_stroke_color: ParsableManimColor | None = BLACK,
+ background_stroke_opacity: float = 1.0,
+ background_stroke_width: float = 0,
+ sheen_factor: float = 0.0,
+ joint_type: LineJointType | None = None,
+ sheen_direction: Vector3 = UL,
+ close_new_points: bool = False,
+ pre_function_handle_to_anchor_scale_factor: float = 0.01,
+ make_smooth_after_applying_functions: bool = False,
+ background_image: Image | str | None = None,
+ shade_in_3d: bool = False,
+ # TODO, do we care about accounting for varying zoom levels?
+ tolerance_for_point_equality: float = 1e-6,
+ n_points_per_cubic_curve: int = 4,
+ **kwargs,
+ ):
+ self.fill_opacity = fill_opacity
+ self.stroke_opacity = stroke_opacity
+ self.stroke_width = stroke_width
+ if background_stroke_color is not None:
+ self.background_stroke_color: ManimColor = ManimColor(
+ background_stroke_color
+ )
+ self.background_stroke_opacity: float = background_stroke_opacity
+ self.background_stroke_width: float = background_stroke_width
+ self.sheen_factor: float = sheen_factor
+ self.joint_type: LineJointType = (
+ LineJointType.AUTO if joint_type is None else joint_type
+ )
+ self.sheen_direction: Vector3 = sheen_direction
+ self.close_new_points: bool = close_new_points
+ self.pre_function_handle_to_anchor_scale_factor: float = (
+ pre_function_handle_to_anchor_scale_factor
+ )
+ self.make_smooth_after_applying_functions: bool = (
+ make_smooth_after_applying_functions
+ )
+ self.background_image: Image | str | None = background_image
+ self.shade_in_3d: bool = shade_in_3d
+ self.tolerance_for_point_equality: float = tolerance_for_point_equality
+ self.n_points_per_cubic_curve: int = n_points_per_cubic_curve
+ super().__init__(**kwargs)
+ self.submobjects: list[VMobject]
+
+ # TODO: Find where color overwrites are happening and remove the color doubling
+ # if "color" in kwargs:
+ # fill_color = kwargs["color"]
+ # stroke_color = kwargs["color"]
+ if fill_color is not None:
+ self.fill_color = ManimColor.parse(fill_color)
+ if stroke_color is not None:
+ self.stroke_color = ManimColor.parse(stroke_color)
+
+ # OpenGL compatibility
+ @property
+ def n_points_per_curve(self) -> int:
+ return self.n_points_per_cubic_curve
+
+ def get_group_class(self) -> type[VGroup]:
+ return VGroup
+
+ @staticmethod
+ def get_mobject_type_class() -> type[VMobject]:
+ return VMobject
+
+ # Colors
+ def init_colors(self, propagate_colors: bool = True) -> Self:
+ self.set_fill(
+ color=self.fill_color,
+ opacity=self.fill_opacity,
+ family=propagate_colors,
+ )
+ self.set_stroke(
+ color=self.stroke_color,
+ width=self.stroke_width,
+ opacity=self.stroke_opacity,
+ family=propagate_colors,
+ )
+ self.set_background_stroke(
+ color=self.background_stroke_color,
+ width=self.background_stroke_width,
+ opacity=self.background_stroke_opacity,
+ family=propagate_colors,
+ )
+ self.set_sheen(
+ factor=self.sheen_factor,
+ direction=self.sheen_direction,
+ family=propagate_colors,
+ )
+
+ if not propagate_colors:
+ for submobject in self.submobjects:
+ submobject.init_colors(propagate_colors=False)
+
+ return self
+
+ def generate_rgbas_array(
+ self, color: ManimColor | list[ManimColor], opacity: float | Iterable[float]
+ ) -> RGBA_Array_Float:
+ """
+ First arg can be either a color, or a tuple/list of colors.
+ Likewise, opacity can either be a float, or a tuple of floats.
+ If self.sheen_factor is not zero, and only
+ one color was passed in, a second slightly light color
+ will automatically be added for the gradient
+ """
+ colors: list[ManimColor] = [
+ ManimColor(c) if (c is not None) else BLACK for c in tuplify(color)
+ ]
+ opacities: list[float] = [
+ o if (o is not None) else 0.0 for o in tuplify(opacity)
+ ]
+ rgbas: npt.NDArray[RGBA_Array_Float] = np.array(
+ [c.to_rgba_with_alpha(o) for c, o in zip(*make_even(colors, opacities))],
+ )
+
+ sheen_factor = self.get_sheen_factor()
+ if sheen_factor != 0 and len(rgbas) == 1:
+ light_rgbas = np.array(rgbas)
+ light_rgbas[:, :3] += sheen_factor
+ np.clip(light_rgbas, 0, 1, out=light_rgbas)
+ rgbas = np.append(rgbas, light_rgbas, axis=0)
+ return rgbas
+
+ def update_rgbas_array(
+ self,
+ array_name: str,
+ color: ManimColor | None = None,
+ opacity: float | None = None,
+ ) -> Self:
+ rgbas = self.generate_rgbas_array(color, opacity)
+ if not hasattr(self, array_name):
+ setattr(self, array_name, rgbas)
+ return self
+ # Match up current rgbas array with the newly calculated
+ # one. 99% of the time they'll be the same.
+ curr_rgbas = getattr(self, array_name)
+ if len(curr_rgbas) < len(rgbas):
+ curr_rgbas = stretch_array_to_length(curr_rgbas, len(rgbas))
+ setattr(self, array_name, curr_rgbas)
+ elif len(rgbas) < len(curr_rgbas):
+ rgbas = stretch_array_to_length(rgbas, len(curr_rgbas))
+ # Only update rgb if color was not None, and only
+ # update alpha channel if opacity was passed in
+ if color is not None:
+ curr_rgbas[:, :3] = rgbas[:, :3]
+ if opacity is not None:
+ curr_rgbas[:, 3] = rgbas[:, 3]
+ return self
+
+ def set_fill(
+ self,
+ color: ParsableManimColor | None = None,
+ opacity: float | None = None,
+ family: bool = True,
+ ) -> Self:
+ """Set the fill color and fill opacity of a :class:`VMobject`.
+
+ Parameters
+ ----------
+ color
+ Fill color of the :class:`VMobject`.
+ opacity
+ Fill opacity of the :class:`VMobject`.
+ family
+ If ``True``, the fill color of all submobjects is also set.
+
+ Returns
+ -------
+ :class:`VMobject`
+ ``self``
+
+ Examples
+ --------
+ .. manim:: SetFill
+ :save_last_frame:
+
+ class SetFill(Scene):
+ def construct(self):
+ square = Square().scale(2).set_fill(WHITE,1)
+ circle1 = Circle().set_fill(GREEN,0.8)
+ circle2 = Circle().set_fill(YELLOW) # No fill_opacity
+ circle3 = Circle().set_fill(color = '#FF2135', opacity = 0.2)
+ group = Group(circle1,circle2,circle3).arrange()
+ self.add(square)
+ self.add(group)
+
+ See Also
+ --------
+ :meth:`~.VMobject.set_style`
+ """
+ if family:
+ for submobject in self.submobjects:
+ submobject.set_fill(color, opacity, family)
+ self.update_rgbas_array("fill_rgbas", color, opacity)
+ self.fill_rgbas: RGBA_Array_Float
+ if opacity is not None:
+ self.fill_opacity = opacity
+ return self
+
+ def set_stroke(
+ self,
+ color: ParsableManimColor = None,
+ width: float | None = None,
+ opacity: float | None = None,
+ background=False,
+ family: bool = True,
+ ) -> Self:
+ if family:
+ for submobject in self.submobjects:
+ submobject.set_stroke(color, width, opacity, background, family)
+ if background:
+ array_name = "background_stroke_rgbas"
+ width_name = "background_stroke_width"
+ opacity_name = "background_stroke_opacity"
+ else:
+ array_name = "stroke_rgbas"
+ width_name = "stroke_width"
+ opacity_name = "stroke_opacity"
+ self.update_rgbas_array(array_name, color, opacity)
+ if width is not None:
+ setattr(self, width_name, width)
+ if opacity is not None:
+ setattr(self, opacity_name, opacity)
+ if color is not None and background:
+ if isinstance(color, (list, tuple)):
+ self.background_stroke_color = color
+ else:
+ self.background_stroke_color = ManimColor(color)
+ return self
+
+ def set_background_stroke(self, **kwargs) -> Self:
+ kwargs["background"] = True
+ self.set_stroke(**kwargs)
+ return self
+
+ def set_style(
+ self,
+ fill_color: ParsableManimColor | None = None,
+ fill_opacity: float | None = None,
+ stroke_color: ParsableManimColor | None = None,
+ stroke_width: float | None = None,
+ stroke_opacity: float | None = None,
+ background_stroke_color: ParsableManimColor | None = None,
+ background_stroke_width: float | None = None,
+ background_stroke_opacity: float | None = None,
+ sheen_factor: float | None = None,
+ sheen_direction: Vector3 | None = None,
+ background_image: Image | str | None = None,
+ family: bool = True,
+ ) -> Self:
+ self.set_fill(color=fill_color, opacity=fill_opacity, family=family)
+ self.set_stroke(
+ color=stroke_color,
+ width=stroke_width,
+ opacity=stroke_opacity,
+ family=family,
+ )
+ self.set_background_stroke(
+ color=background_stroke_color,
+ width=background_stroke_width,
+ opacity=background_stroke_opacity,
+ family=family,
+ )
+ if sheen_factor:
+ self.set_sheen(
+ factor=sheen_factor,
+ direction=sheen_direction,
+ family=family,
+ )
+ if background_image:
+ self.color_using_background_image(background_image)
+ return self
+
+ def get_style(self, simple: bool = False) -> dict:
+ ret = {
+ "stroke_opacity": self.get_stroke_opacity(),
+ "stroke_width": self.get_stroke_width(),
+ }
+
+ # TODO: FIX COLORS HERE
+ if simple:
+ ret["fill_color"] = self.get_fill_color()
+ ret["fill_opacity"] = self.get_fill_opacity()
+ ret["stroke_color"] = self.get_stroke_color()
+ else:
+ ret["fill_color"] = self.get_fill_colors()
+ ret["fill_opacity"] = self.get_fill_opacities()
+ ret["stroke_color"] = self.get_stroke_colors()
+ ret["background_stroke_color"] = self.get_stroke_colors(background=True)
+ ret["background_stroke_width"] = self.get_stroke_width(background=True)
+ ret["background_stroke_opacity"] = self.get_stroke_opacity(background=True)
+ ret["sheen_factor"] = self.get_sheen_factor()
+ ret["sheen_direction"] = self.get_sheen_direction()
+ ret["background_image"] = self.get_background_image()
+
+ return ret
+
+ def match_style(self, vmobject: VMobject, family: bool = True) -> Self:
+ self.set_style(**vmobject.get_style(), family=False)
+
+ if family:
+ # Does its best to match up submobject lists, and
+ # match styles accordingly
+ submobs1, submobs2 = self.submobjects, vmobject.submobjects
+ if len(submobs1) == 0:
+ return self
+ elif len(submobs2) == 0:
+ submobs2 = [vmobject]
+ for sm1, sm2 in zip(*make_even(submobs1, submobs2)):
+ sm1.match_style(sm2)
+ return self
+
+ def set_color(self, color: ParsableManimColor, family: bool = True) -> Self:
+ self.set_fill(color, family=family)
+ self.set_stroke(color, family=family)
+ return self
+
+ def set_opacity(self, opacity: float, family: bool = True) -> Self:
+ self.set_fill(opacity=opacity, family=family)
+ self.set_stroke(opacity=opacity, family=family)
+ self.set_stroke(opacity=opacity, family=family, background=True)
+ return self
+
+ def fade(self, darkness: float = 0.5, family: bool = True) -> Self:
+ factor = 1.0 - darkness
+ self.set_fill(opacity=factor * self.get_fill_opacity(), family=False)
+ self.set_stroke(opacity=factor * self.get_stroke_opacity(), family=False)
+ self.set_background_stroke(
+ opacity=factor * self.get_stroke_opacity(background=True),
+ family=False,
+ )
+ super().fade(darkness, family)
+ return self
+
+ def get_fill_rgbas(self) -> RGBA_Array_Float | Zeros:
+ try:
+ return self.fill_rgbas
+ except AttributeError:
+ return np.zeros((1, 4))
+
+ def get_fill_color(self) -> ManimColor:
+ """
+ If there are multiple colors (for gradient)
+ this returns the first one
+ """
+ return self.get_fill_colors()[0]
+
+ fill_color = property(get_fill_color, set_fill)
+
+ def get_fill_opacity(self) -> ManimFloat:
+ """
+ If there are multiple opacities, this returns the
+ first
+ """
+ return self.get_fill_opacities()[0]
+
+ # TODO: Does this just do a copy?
+ # TODO: I have the feeling that this function should not return None, does that have any usage ?
+ def get_fill_colors(self) -> list[ManimColor | None]:
+ return [
+ ManimColor(rgba[:3]) if rgba.any() else None
+ for rgba in self.get_fill_rgbas()
+ ]
+
+ def get_fill_opacities(self) -> npt.NDArray[ManimFloat]:
+ return self.get_fill_rgbas()[:, 3]
+
+ def get_stroke_rgbas(self, background: bool = False) -> RGBA_Array_float | Zeros:
+ try:
+ if background:
+ self.background_stroke_rgbas: RGBA_Array_Float
+ rgbas = self.background_stroke_rgbas
+ else:
+ self.stroke_rgbas: RGBA_Array_Float
+ rgbas = self.stroke_rgbas
+ return rgbas
+ except AttributeError:
+ return np.zeros((1, 4))
+
+ def get_stroke_color(self, background: bool = False) -> ManimColor | None:
+ return self.get_stroke_colors(background)[0]
+
+ stroke_color = property(get_stroke_color, set_stroke)
+
+ def get_stroke_width(self, background: bool = False) -> float:
+ if background:
+ self.background_stroke_width: float
+ width = self.background_stroke_width
+ else:
+ width = self.stroke_width
+ if isinstance(width, str):
+ width = int(width)
+ return max(0.0, width)
+
+ def get_stroke_opacity(self, background: bool = False) -> ManimFloat:
+ return self.get_stroke_opacities(background)[0]
+
+ def get_stroke_colors(self, background: bool = False) -> list[ManimColor | None]:
+ return [
+ ManimColor(rgba[:3]) if rgba.any() else None
+ for rgba in self.get_stroke_rgbas(background)
+ ]
+
+ def get_stroke_opacities(self, background: bool = False) -> npt.NDArray[ManimFloat]:
+ return self.get_stroke_rgbas(background)[:, 3]
+
+ def get_color(self) -> ManimColor:
+ if np.all(self.get_fill_opacities() == 0):
+ return self.get_stroke_color()
+ return self.get_fill_color()
+
+ color = property(get_color, set_color)
+
+ def set_sheen_direction(self, direction: Vector3, family: bool = True) -> Self:
+ """Sets the direction of the applied sheen.
+
+ Parameters
+ ----------
+ direction
+ Direction from where the gradient is applied.
+
+ Examples
+ --------
+ Normal usage::
+
+ Circle().set_sheen_direction(UP)
+
+ See Also
+ --------
+ :meth:`~.VMobject.set_sheen`
+ :meth:`~.VMobject.rotate_sheen_direction`
+ """
+
+ direction = np.array(direction)
+ if family:
+ for submob in self.get_family():
+ submob.sheen_direction = direction
+ else:
+ self.sheen_direction: Vector3 = direction
+ return self
+
+ def rotate_sheen_direction(
+ self, angle: float, axis: Vector3 = OUT, family: bool = True
+ ) -> Self:
+ """Rotates the direction of the applied sheen.
+
+ Parameters
+ ----------
+ angle
+ Angle by which the direction of sheen is rotated.
+ axis
+ Axis of rotation.
+
+ Examples
+ --------
+ Normal usage::
+
+ Circle().set_sheen_direction(UP).rotate_sheen_direction(PI)
+
+ See Also
+ --------
+ :meth:`~.VMobject.set_sheen_direction`
+ """
+ if family:
+ for submob in self.get_family():
+ submob.sheen_direction = rotate_vector(
+ submob.sheen_direction,
+ angle,
+ axis,
+ )
+ else:
+ self.sheen_direction = rotate_vector(self.sheen_direction, angle, axis)
+ return self
+
+ def set_sheen(
+ self, factor: float, direction: Vector3 | None = None, family: bool = True
+ ) -> Self:
+ """Applies a color gradient from a direction.
+
+ Parameters
+ ----------
+ factor
+ The extent of lustre/gradient to apply. If negative, the gradient
+ starts from black, if positive the gradient starts from white and
+ changes to the current color.
+ direction
+ Direction from where the gradient is applied.
+
+ Examples
+ --------
+ .. manim:: SetSheen
+ :save_last_frame:
+
+ class SetSheen(Scene):
+ def construct(self):
+ circle = Circle(fill_opacity=1).set_sheen(-0.3, DR)
+ self.add(circle)
+ """
+
+ if family:
+ for submob in self.submobjects:
+ submob.set_sheen(factor, direction, family)
+ self.sheen_factor: float = factor
+ if direction is not None:
+ # family set to false because recursion will
+ # already be handled above
+ self.set_sheen_direction(direction, family=False)
+ # Reset color to put sheen_factor into effect
+ if factor != 0:
+ self.set_stroke(self.get_stroke_color(), family=family)
+ self.set_fill(self.get_fill_color(), family=family)
+ return self
+
+ def get_sheen_direction(self) -> Vector3:
+ return np.array(self.sheen_direction)
+
+ def get_sheen_factor(self) -> float:
+ return self.sheen_factor
+
+ def get_gradient_start_and_end_points(self) -> tuple[Point3D, Point3D]:
+ if self.shade_in_3d:
+ return get_3d_vmob_gradient_start_and_end_points(self)
+ else:
+ direction = self.get_sheen_direction()
+ c = self.get_center()
+ bases = np.array(
+ [self.get_edge_center(vect) - c for vect in [RIGHT, UP, OUT]],
+ ).transpose()
+ offset = np.dot(bases, direction)
+ return (c - offset, c + offset)
+
+ def color_using_background_image(self, background_image: Image | str) -> Self:
+ self.background_image: Image | str = background_image
+ self.set_color(WHITE)
+ for submob in self.submobjects:
+ submob.color_using_background_image(background_image)
+ return self
+
+ def get_background_image(self) -> Image | str:
+ return self.background_image
+
+ def match_background_image(self, vmobject: VMobject) -> Self:
+ self.color_using_background_image(vmobject.get_background_image())
+ return self
+
+ def set_shade_in_3d(
+ self, value: bool = True, z_index_as_group: bool = False
+ ) -> Self:
+ for submob in self.get_family():
+ submob.shade_in_3d = value
+ if z_index_as_group:
+ submob.z_index_group = self
+ return self
+
+ def set_points(self, points: Point3D_Array) -> Self:
+ self.points: Point3D_Array = np.array(points)
+ return self
+
+ def resize_points(
+ self,
+ new_length: int,
+ resize_func: Callable[[Point3D, int], Point3D] = resize_array,
+ ) -> Self:
+ """Resize the array of anchor points and handles to have
+ the specified size.
+
+ Parameters
+ ----------
+ new_length
+ The new (total) number of points.
+ resize_func
+ A function mapping a Numpy array (the points) and an integer
+ (the target size) to a Numpy array. The default implementation
+ is based on Numpy's ``resize`` function.
+ """
+ if new_length != len(self.points):
+ self.points = resize_func(self.points, new_length)
+ return self
+
+ def set_anchors_and_handles(
+ self,
+ anchors1: CubicBezierPoints,
+ handles1: CubicBezierPoints,
+ handles2: CubicBezierPoints,
+ anchors2: CubicBezierPoints,
+ ) -> Self:
+ """Given two sets of anchors and handles, process them to set them as anchors
+ and handles of the VMobject.
+
+ anchors1[i], handles1[i], handles2[i] and anchors2[i] define the i-th bezier
+ curve of the vmobject. There are four hardcoded parameters and this is a
+ problem as it makes the number of points per cubic curve unchangeable from 4
+ (two anchors and two handles).
+
+ Returns
+ -------
+ :class:`VMobject`
+ ``self``
+ """
+ assert len(anchors1) == len(handles1) == len(handles2) == len(anchors2)
+ nppcc = self.n_points_per_cubic_curve # 4
+ total_len = nppcc * len(anchors1)
+ self.points = np.zeros((total_len, self.dim))
+ # the following will, from the four sets, dispatch them in points such that
+ # self.points = [
+ # anchors1[0], handles1[0], handles2[0], anchors1[0], anchors1[1],
+ # handles1[1], ...
+ # ]
+ arrays = [anchors1, handles1, handles2, anchors2]
+ for index, array in enumerate(arrays):
+ self.points[index::nppcc] = array
+ return self
+
+ def clear_points(self) -> None:
+ self.points = np.zeros((0, self.dim))
+
+ def append_points(self, new_points: Point3D_Array) -> Self:
+ # TODO, check that number new points is a multiple of 4?
+ # or else that if len(self.points) % 4 == 1, then
+ # len(new_points) % 4 == 3?
+ self.points = np.append(self.points, new_points, axis=0)
+ return self
+
+ def start_new_path(self, point: Point3D) -> Self:
+ if len(self.points) % 4 != 0:
+ # close the open path by appending the last
+ # start anchor sufficiently often
+ last_anchor = self.get_start_anchors()[-1]
+ for _ in range(4 - (len(self.points) % 4)):
+ self.append_points([last_anchor])
+ self.append_points([point])
+ return self
+
+ def add_cubic_bezier_curve(
+ self,
+ anchor1: CubicBezierPoints,
+ handle1: CubicBezierPoints,
+ handle2: CubicBezierPoints,
+ anchor2: CubicBezierPoints,
+ ) -> None:
+ # TODO, check the len(self.points) % 4 == 0?
+ self.append_points([anchor1, handle1, handle2, anchor2])
+
+ # what type is curves?
+ def add_cubic_bezier_curves(self, curves) -> None:
+ self.append_points(curves.flatten())
+
+ def add_cubic_bezier_curve_to(
+ self,
+ handle1: CubicBezierPoints,
+ handle2: CubicBezierPoints,
+ anchor: CubicBezierPoints,
+ ) -> Self:
+ """Add cubic bezier curve to the path.
+
+ NOTE : the first anchor is not a parameter as by default the end of the last sub-path!
+
+ Parameters
+ ----------
+ handle1
+ first handle
+ handle2
+ second handle
+ anchor
+ anchor
+
+ Returns
+ -------
+ :class:`VMobject`
+ ``self``
+ """
+ self.throw_error_if_no_points()
+ new_points = [handle1, handle2, anchor]
+ if self.has_new_path_started():
+ self.append_points(new_points)
+ else:
+ self.append_points([self.get_last_point()] + new_points)
+ return self
+
+ def add_quadratic_bezier_curve_to(
+ self,
+ handle: QuadraticBezierPoints,
+ anchor: QuadraticBezierPoints,
+ ) -> Self:
+ """Add Quadratic bezier curve to the path.
+
+ Returns
+ -------
+ :class:`VMobject`
+ ``self``
+ """
+ # How does one approximate a quadratic with a cubic?
+ # refer to the Wikipedia page on Bezier curves
+ # https://en.wikipedia.org/wiki/B%C3%A9zier_curve#Degree_elevation, accessed Jan 20, 2021
+ # 1. Copy the end points, and then
+ # 2. Place the 2 middle control points 2/3 along the line segments
+ # from the end points to the quadratic curve's middle control point.
+ # I think that's beautiful.
+ self.add_cubic_bezier_curve_to(
+ 2 / 3 * handle + 1 / 3 * self.get_last_point(),
+ 2 / 3 * handle + 1 / 3 * anchor,
+ anchor,
+ )
+ return self
+
+ def add_line_to(self, point: Point3D) -> Self:
+ """Add a straight line from the last point of VMobject to the given point.
+
+ Parameters
+ ----------
+
+ point
+ end of the straight line.
+
+ Returns
+ -------
+ :class:`VMobject`
+ ``self``
+ """
+ nppcc = self.n_points_per_cubic_curve
+ self.add_cubic_bezier_curve_to(
+ *(
+ interpolate(self.get_last_point(), point, a)
+ for a in np.linspace(0, 1, nppcc)[1:]
+ )
+ )
+ return self
+
+ def add_smooth_curve_to(self, *points: Point3D) -> Self:
+ """Creates a smooth curve from given points and add it to the VMobject. If two points are passed in, the first is interpreted
+ as a handle, the second as an anchor.
+
+ Parameters
+ ----------
+ points
+ Points (anchor and handle, or just anchor) to add a smooth curve from
+
+ Returns
+ -------
+ :class:`VMobject`
+ ``self``
+
+ Raises
+ ------
+ ValueError
+ If 0 or more than 2 points are given.
+ """
+ # TODO remove the value error and just add two parameters with one optional
+ if len(points) == 1:
+ handle2 = None
+ new_anchor = points[0]
+ elif len(points) == 2:
+ handle2, new_anchor = points
+ else:
+ name = sys._getframe(0).f_code.co_name
+ raise ValueError(f"Only call {name} with 1 or 2 points")
+
+ if self.has_new_path_started():
+ self.add_line_to(new_anchor)
+ else:
+ self.throw_error_if_no_points()
+ last_h2, last_a2 = self.points[-2:]
+ last_tangent = last_a2 - last_h2
+ handle1 = last_a2 + last_tangent
+ if handle2 is None:
+ to_anchor_vect = new_anchor - last_a2
+ new_tangent = rotate_vector(last_tangent, PI, axis=to_anchor_vect)
+ handle2 = new_anchor - new_tangent
+ self.append_points([last_a2, handle1, handle2, new_anchor])
+ return self
+
+ def has_new_path_started(self) -> bool:
+ nppcc = self.n_points_per_cubic_curve # 4
+ # A new path starting is defined by a control point which is not part of a bezier subcurve.
+ return len(self.points) % nppcc == 1
+
+ def get_last_point(self) -> Point3D:
+ return self.points[-1]
+
+ def is_closed(self) -> bool:
+ # TODO use consider_points_equals_2d ?
+ return self.consider_points_equals(self.points[0], self.points[-1])
+
+ def close_path(self) -> None:
+ if not self.is_closed():
+ self.add_line_to(self.get_subpaths()[-1][0])
+
+ def add_points_as_corners(self, points: Iterable[Point3D]) -> Iterable[Point3D]:
+ for point in points:
+ self.add_line_to(point)
+ return points
+
+ def set_points_as_corners(self, points: Point3D_Array) -> Self:
+ """Given an array of points, set them as corner of the vmobject.
+
+ To achieve that, this algorithm sets handles aligned with the anchors such that the resultant bezier curve will be the segment
+ between the two anchors.
+
+ Parameters
+ ----------
+ points
+ Array of points that will be set as corners.
+
+ Returns
+ -------
+ :class:`VMobject`
+ ``self``
+ """
+ nppcc = self.n_points_per_cubic_curve
+ points = np.array(points)
+ # This will set the handles aligned with the anchors.
+ # Id est, a bezier curve will be the segment from the two anchors such that the handles belongs to this segment.
+ self.set_anchors_and_handles(
+ *(interpolate(points[:-1], points[1:], a) for a in np.linspace(0, 1, nppcc))
+ )
+ return self
+
+ def set_points_smoothly(self, points: Point3D_Array) -> Self:
+ self.set_points_as_corners(points)
+ self.make_smooth()
+ return self
+
+ def change_anchor_mode(self, mode: Literal["jagged", "smooth"]) -> Self:
+ """Changes the anchor mode of the bezier curves. This will modify the handles.
+
+ There can be only two modes, "jagged", and "smooth".
+
+ Returns
+ -------
+ :class:`VMobject`
+ ``self``
+ """
+ assert mode in ["jagged", "smooth"], 'mode must be either "jagged" or "smooth"'
+ nppcc = self.n_points_per_cubic_curve
+ for submob in self.family_members_with_points():
+ subpaths = submob.get_subpaths()
+ submob.clear_points()
+ # A subpath can be composed of several bezier curves.
+ for subpath in subpaths:
+ # This will retrieve the anchors of the subpath, by selecting every n element in the array subpath
+ # The append is needed as the last element is not reached when slicing with numpy.
+ anchors = np.append(subpath[::nppcc], subpath[-1:], 0)
+ if mode == "smooth":
+ h1, h2 = get_smooth_handle_points(anchors)
+ else: # mode == "jagged"
+ # The following will make the handles aligned with the anchors, thus making the bezier curve a segment
+ a1 = anchors[:-1]
+ a2 = anchors[1:]
+ h1 = interpolate(a1, a2, 1.0 / 3)
+ h2 = interpolate(a1, a2, 2.0 / 3)
+ new_subpath = np.array(subpath)
+ new_subpath[1::nppcc] = h1
+ new_subpath[2::nppcc] = h2
+ submob.append_points(new_subpath)
+ return self
+
+ def make_smooth(self) -> Self:
+ return self.change_anchor_mode("smooth")
+
+ def make_jagged(self) -> Self:
+ return self.change_anchor_mode("jagged")
+
+ def add_subpath(self, points: Point3D_Array) -> Self:
+ assert len(points) % 4 == 0
+ self.points: Point3D_Array = np.append(self.points, points, axis=0)
+ return self
+
+ def append_vectorized_mobject(self, vectorized_mobject: VMobject) -> None:
+ new_points = list(vectorized_mobject.points)
+
+ if self.has_new_path_started():
+ # Remove last point, which is starting
+ # a new path
+ self.points = self.points[:-1]
+ self.append_points(new_points)
+
+ def apply_function(self, function: MappingFunction) -> Self:
+ factor = self.pre_function_handle_to_anchor_scale_factor
+ self.scale_handle_to_anchor_distances(factor)
+ super().apply_function(function)
+ self.scale_handle_to_anchor_distances(1.0 / factor)
+ if self.make_smooth_after_applying_functions:
+ self.make_smooth()
+ return self
+
+ def rotate(
+ self,
+ angle: float,
+ axis: Vector3 = OUT,
+ about_point: Point3D | None = None,
+ **kwargs,
+ ) -> Self:
+ self.rotate_sheen_direction(angle, axis)
+ super().rotate(angle, axis, about_point, **kwargs)
+ return self
+
+ def scale_handle_to_anchor_distances(self, factor: float) -> Self:
+ """If the distance between a given handle point H and its associated
+ anchor point A is d, then it changes H to be a distances factor*d
+ away from A, but so that the line from A to H doesn't change.
+ This is mostly useful in the context of applying a (differentiable)
+ function, to preserve tangency properties. One would pull all the
+ handles closer to their anchors, apply the function then push them out
+ again.
+
+ Parameters
+ ----------
+ factor
+ The factor used for scaling.
+
+ Returns
+ -------
+ :class:`VMobject`
+ ``self``
+ """
+ for submob in self.family_members_with_points():
+ if len(submob.points) < self.n_points_per_cubic_curve:
+ # The case that a bezier quad is not complete (there is no bezier curve as there is not enough control points.)
+ continue
+ a1, h1, h2, a2 = submob.get_anchors_and_handles()
+ a1_to_h1 = h1 - a1
+ a2_to_h2 = h2 - a2
+ new_h1 = a1 + factor * a1_to_h1
+ new_h2 = a2 + factor * a2_to_h2
+ submob.set_anchors_and_handles(a1, new_h1, new_h2, a2)
+ return self
+
+ #
+ def consider_points_equals(self, p0: Point3D, p1: Point3D) -> bool:
+ return np.allclose(p0, p1, atol=self.tolerance_for_point_equality)
+
+ def consider_points_equals_2d(self, p0: Point2D, p1: Point2D) -> bool:
+ """Determine if two points are close enough to be considered equal.
+
+ This uses the algorithm from np.isclose(), but expanded here for the
+ 2D point case. NumPy is overkill for such a small question.
+ Parameters
+ ----------
+ p0
+ first point
+ p1
+ second point
+
+ Returns
+ -------
+ bool
+ whether two points considered close.
+ """
+ rtol = 1.0e-5 # default from np.isclose()
+ atol = self.tolerance_for_point_equality
+ if abs(p0[0] - p1[0]) > atol + rtol * abs(p1[0]):
+ return False
+ if abs(p0[1] - p1[1]) > atol + rtol * abs(p1[1]):
+ return False
+ return True
+
+ # Information about line
+ def get_cubic_bezier_tuples_from_points(
+ self, points: Point3D_Array
+ ) -> npt.NDArray[Point3D_Array]:
+ return np.array(self.gen_cubic_bezier_tuples_from_points(points))
+
+ def gen_cubic_bezier_tuples_from_points(
+ self, points: Point3D_Array
+ ) -> tuple[Point3D_Array]:
+ """Returns the bezier tuples from an array of points.
+
+ self.points is a list of the anchors and handles of the bezier curves of the mobject (ie [anchor1, handle1, handle2, anchor2, anchor3 ..])
+ This algorithm basically retrieve them by taking an element every n, where n is the number of control points
+ of the bezier curve.
+
+
+ Parameters
+ ----------
+ points
+ Points from which control points will be extracted.
+
+ Returns
+ -------
+ tuple
+ Bezier control points.
+ """
+ nppcc = self.n_points_per_cubic_curve
+ remainder = len(points) % nppcc
+ points = points[: len(points) - remainder]
+ # Basically take every nppcc element.
+ return tuple(points[i : i + nppcc] for i in range(0, len(points), nppcc))
+
+ def get_cubic_bezier_tuples(self) -> npt.NDArray[Point3D_Array]:
+ return self.get_cubic_bezier_tuples_from_points(self.points)
+
+ def _gen_subpaths_from_points(
+ self,
+ points: Point3D_Array,
+ filter_func: Callable[[int], bool],
+ ) -> Generator[Point3D_Array]:
+ """Given an array of points defining the bezier curves of the vmobject, return subpaths formed by these points.
+ Here, Two bezier curves form a path if at least two of their anchors are evaluated True by the relation defined by filter_func.
+
+ The algorithm every bezier tuple (anchors and handles) in ``self.points`` (by regrouping each n elements, where
+ n is the number of points per cubic curve)), and evaluate the relation between two anchors with filter_func.
+ NOTE : The filter_func takes an int n as parameter, and will evaluate the relation between points[n] and points[n - 1]. This should probably be changed so
+ the function takes two points as parameters.
+
+ Parameters
+ ----------
+ points
+ points defining the bezier curve.
+ filter_func
+ Filter-func defining the relation.
+
+ Returns
+ -------
+ Generator[Point3D_Array]
+ subpaths formed by the points.
+ """
+ nppcc = self.n_points_per_cubic_curve
+ filtered = filter(filter_func, range(nppcc, len(points), nppcc))
+ split_indices = [0] + list(filtered) + [len(points)]
+ return (
+ points[i1:i2]
+ for i1, i2 in zip(split_indices, split_indices[1:])
+ if (i2 - i1) >= nppcc
+ )
+
+ def get_subpaths_from_points(self, points: Point3D_Array) -> list[Point3D_Array]:
+ return list(
+ self._gen_subpaths_from_points(
+ points,
+ lambda n: not self.consider_points_equals(points[n - 1], points[n]),
+ ),
+ )
+
+ def gen_subpaths_from_points_2d(
+ self, points: Point3D_Array
+ ) -> Generator[Point3D_Array]:
+ return self._gen_subpaths_from_points(
+ points,
+ lambda n: not self.consider_points_equals_2d(points[n - 1], points[n]),
+ )
+
+ def get_subpaths(self) -> list[Point3D_Array]:
+ """Returns subpaths formed by the curves of the VMobject.
+
+ Subpaths are ranges of curves with each pair of consecutive curves having their end/start points coincident.
+
+ Returns
+ -------
+ list[Point3D_Array]
+ subpaths.
+ """
+ return self.get_subpaths_from_points(self.points)
+
+ def get_nth_curve_points(self, n: int) -> Point3D_Array:
+ """Returns the points defining the nth curve of the vmobject.
+
+ Parameters
+ ----------
+ n
+ index of the desired bezier curve.
+
+ Returns
+ -------
+ Point3D_Array
+ points defining the nth bezier curve (anchors, handles)
+ """
+ assert n < self.get_num_curves()
+ nppcc = self.n_points_per_cubic_curve
+ return self.points[nppcc * n : nppcc * (n + 1)]
+
+ def get_nth_curve_function(self, n: int) -> Callable[[float], Point3D]:
+ """Returns the expression of the nth curve.
+
+ Parameters
+ ----------
+ n
+ index of the desired curve.
+
+ Returns
+ -------
+ Callable[float, Point3D]
+ expression of the nth bezier curve.
+ """
+ return bezier(self.get_nth_curve_points(n))
+
+ def get_nth_curve_length_pieces(
+ self,
+ n: int,
+ sample_points: int | None = None,
+ ) -> npt.NDArray[ManimFloat]:
+ """Returns the array of short line lengths used for length approximation.
+
+ Parameters
+ ----------
+ n
+ The index of the desired curve.
+ sample_points
+ The number of points to sample to find the length.
+
+ Returns
+ -------
+ The short length-pieces of the nth curve.
+ """
+ if sample_points is None:
+ sample_points = 10
+
+ curve = self.get_nth_curve_function(n)
+ points = np.array([curve(a) for a in np.linspace(0, 1, sample_points)])
+ diffs = points[1:] - points[:-1]
+ norms = np.linalg.norm(diffs, axis=1)
+
+ return norms
+
+ def get_nth_curve_length(
+ self,
+ n: int,
+ sample_points: int | None = None,
+ ) -> float:
+ """Returns the (approximate) length of the nth curve.
+
+ Parameters
+ ----------
+ n
+ The index of the desired curve.
+ sample_points
+ The number of points to sample to find the length.
+
+ Returns
+ -------
+ length : :class:`float`
+ The length of the nth curve.
+ """
+
+ _, length = self.get_nth_curve_function_with_length(n, sample_points)
+
+ return length
+
+ def get_nth_curve_function_with_length(
+ self,
+ n: int,
+ sample_points: int | None = None,
+ ) -> tuple[Callable[[float], Point3D], float]:
+ """Returns the expression of the nth curve along with its (approximate) length.
+
+ Parameters
+ ----------
+ n
+ The index of the desired curve.
+ sample_points
+ The number of points to sample to find the length.
+
+ Returns
+ -------
+ curve : Callable[[float], Point3D]
+ The function for the nth curve.
+ length : :class:`float`
+ The length of the nth curve.
+ """
+
+ curve = self.get_nth_curve_function(n)
+ norms = self.get_nth_curve_length_pieces(n, sample_points=sample_points)
+ length = np.sum(norms)
+
+ return curve, length
+
+ def get_num_curves(self) -> int:
+ """Returns the number of curves of the vmobject.
+
+ Returns
+ -------
+ int
+ number of curves of the vmobject.
+ """
+ nppcc = self.n_points_per_cubic_curve
+ return len(self.points) // nppcc
+
+ def get_curve_functions(
+ self,
+ ) -> Generator[Callable[[float], Point3D]]:
+ """Gets the functions for the curves of the mobject.
+
+ Returns
+ -------
+ Generator[Callable[[float], Point3D]]
+ The functions for the curves.
+ """
+
+ num_curves = self.get_num_curves()
+
+ for n in range(num_curves):
+ yield self.get_nth_curve_function(n)
+
+ def get_curve_functions_with_lengths(
+ self, **kwargs
+ ) -> Generator[tuple[Callable[[float], Point3D], float]]:
+ """Gets the functions and lengths of the curves for the mobject.
+
+ Parameters
+ ----------
+ **kwargs
+ The keyword arguments passed to :meth:`get_nth_curve_function_with_length`
+
+ Returns
+ -------
+ Generator[tuple[Callable[[float], Point3D], float]]
+ The functions and lengths of the curves.
+ """
+
+ num_curves = self.get_num_curves()
+
+ for n in range(num_curves):
+ yield self.get_nth_curve_function_with_length(n, **kwargs)
+
+ def point_from_proportion(self, alpha: float) -> Point3D:
+ """Gets the point at a proportion along the path of the :class:`VMobject`.
+
+ Parameters
+ ----------
+ alpha
+ The proportion along the the path of the :class:`VMobject`.
+
+ Returns
+ -------
+ :class:`numpy.ndarray`
+ The point on the :class:`VMobject`.
+
+ Raises
+ ------
+ :exc:`ValueError`
+ If ``alpha`` is not between 0 and 1.
+ :exc:`Exception`
+ If the :class:`VMobject` has no points.
+ """
+
+ if alpha < 0 or alpha > 1:
+ raise ValueError(f"Alpha {alpha} not between 0 and 1.")
+
+ self.throw_error_if_no_points()
+ if alpha == 1:
+ return self.points[-1]
+
+ curves_and_lengths = tuple(self.get_curve_functions_with_lengths())
+
+ target_length = alpha * sum(length for _, length in curves_and_lengths)
+ current_length = 0
+
+ for curve, length in curves_and_lengths:
+ if current_length + length >= target_length:
+ if length != 0:
+ residue = (target_length - current_length) / length
+ else:
+ residue = 0
+
+ return curve(residue)
+
+ current_length += length
+
+ def proportion_from_point(
+ self,
+ point: Iterable[float | int],
+ ) -> float:
+ """Returns the proportion along the path of the :class:`VMobject`
+ a particular given point is at.
+
+ Parameters
+ ----------
+ point
+ The Cartesian coordinates of the point which may or may not lie on the :class:`VMobject`
+
+ Returns
+ -------
+ float
+ The proportion along the path of the :class:`VMobject`.
+
+ Raises
+ ------
+ :exc:`ValueError`
+ If ``point`` does not lie on the curve.
+ :exc:`Exception`
+ If the :class:`VMobject` has no points.
+ """
+ self.throw_error_if_no_points()
+
+ # Iterate over each bezier curve that the ``VMobject`` is composed of, checking
+ # if the point lies on that curve. If it does not lie on that curve, add
+ # the whole length of the curve to ``target_length`` and move onto the next
+ # curve. If the point does lie on the curve, add how far along the curve
+ # the point is to ``target_length``.
+ # Then, divide ``target_length`` by the total arc length of the shape to get
+ # the proportion along the ``VMobject`` the point is at.
+
+ num_curves = self.get_num_curves()
+ total_length = self.get_arc_length()
+ target_length = 0
+ for n in range(num_curves):
+ control_points = self.get_nth_curve_points(n)
+ length = self.get_nth_curve_length(n)
+ proportions_along_bezier = proportions_along_bezier_curve_for_point(
+ point,
+ control_points,
+ )
+ if len(proportions_along_bezier) > 0:
+ proportion_along_nth_curve = max(proportions_along_bezier)
+ target_length += length * proportion_along_nth_curve
+ break
+ target_length += length
+ else:
+ raise ValueError(f"Point {point} does not lie on this curve.")
+
+ alpha = target_length / total_length
+
+ return alpha
+
+ def get_anchors_and_handles(self) -> list[Point3D_Array]:
+ """Returns anchors1, handles1, handles2, anchors2,
+ where (anchors1[i], handles1[i], handles2[i], anchors2[i])
+ will be four points defining a cubic bezier curve
+ for any i in range(0, len(anchors1))
+
+ Returns
+ -------
+ `list[Point3D_Array]`
+ Iterable of the anchors and handles.
+ """
+ nppcc = self.n_points_per_cubic_curve
+ return [self.points[i::nppcc] for i in range(nppcc)]
+
+ def get_start_anchors(self) -> Point3D_Array:
+ """Returns the start anchors of the bezier curves.
+
+ Returns
+ -------
+ Point3D_Array
+ Starting anchors
+ """
+ return self.points[:: self.n_points_per_cubic_curve]
+
+ def get_end_anchors(self) -> Point3D_Array:
+ """Return the end anchors of the bezier curves.
+
+ Returns
+ -------
+ Point3D_Array
+ Starting anchors
+ """
+ nppcc = self.n_points_per_cubic_curve
+ return self.points[nppcc - 1 :: nppcc]
+
+ def get_anchors(self) -> Point3D_Array:
+ """Returns the anchors of the curves forming the VMobject.
+
+ Returns
+ -------
+ Point3D_Array
+ The anchors.
+ """
+ if self.points.shape[0] == 1:
+ return self.points
+ return np.array(
+ tuple(it.chain(*zip(self.get_start_anchors(), self.get_end_anchors()))),
+ )
+
+ def get_points_defining_boundary(self) -> Point3D_Array:
+ # Probably returns all anchors, but this is weird regarding the name of the method.
+ return np.array(
+ tuple(it.chain(*(sm.get_anchors() for sm in self.get_family())))
+ )
+
+ def get_arc_length(self, sample_points_per_curve: int | None = None) -> float:
+ """Return the approximated length of the whole curve.
+
+ Parameters
+ ----------
+ sample_points_per_curve
+ Number of sample points per curve used to approximate the length. More points result in a better approximation.
+
+ Returns
+ -------
+ float
+ The length of the :class:`VMobject`.
+ """
+
+ return sum(
+ length
+ for _, length in self.get_curve_functions_with_lengths(
+ sample_points=sample_points_per_curve,
+ )
+ )
+
+ # Alignment
+ def align_points(self, vmobject: VMobject) -> Self:
+ """Adds points to self and vmobject so that they both have the same number of subpaths, with
+ corresponding subpaths each containing the same number of points.
+
+ Points are added either by subdividing curves evenly along the subpath, or by creating new subpaths consisting
+ of a single point repeated.
+
+ Parameters
+ ----------
+ vmobject
+ The object to align points with.
+
+ Returns
+ -------
+ :class:`VMobject`
+ ``self``
+ """
+ self.align_rgbas(vmobject)
+ # TODO: This shortcut can be a bit over eager. What if they have the same length, but different subpath lengths?
+ if self.get_num_points() == vmobject.get_num_points():
+ return
+
+ for mob in self, vmobject:
+ # If there are no points, add one to
+ # wherever the "center" is
+ if mob.has_no_points():
+ mob.start_new_path(mob.get_center())
+ # If there's only one point, turn it into
+ # a null curve
+ if mob.has_new_path_started():
+ mob.add_line_to(mob.get_last_point())
+
+ # Figure out what the subpaths are
+ subpaths1 = self.get_subpaths()
+ subpaths2 = vmobject.get_subpaths()
+ n_subpaths = max(len(subpaths1), len(subpaths2))
+ # Start building new ones
+ new_path1 = np.zeros((0, self.dim))
+ new_path2 = np.zeros((0, self.dim))
+
+ nppcc = self.n_points_per_cubic_curve
+
+ def get_nth_subpath(path_list, n):
+ if n >= len(path_list):
+ # Create a null path at the very end
+ return [path_list[-1][-1]] * nppcc
+ path = path_list[n]
+ # Check for useless points at the end of the path and remove them
+ # https://github.com/ManimCommunity/manim/issues/1959
+ while len(path) > nppcc:
+ # If the last nppc points are all equal to the preceding point
+ if self.consider_points_equals(path[-nppcc:], path[-nppcc - 1]):
+ path = path[:-nppcc]
+ else:
+ break
+ return path
+
+ for n in range(n_subpaths):
+ # For each pair of subpaths, add points until they are the same length
+ sp1 = get_nth_subpath(subpaths1, n)
+ sp2 = get_nth_subpath(subpaths2, n)
+ diff1 = max(0, (len(sp2) - len(sp1)) // nppcc)
+ diff2 = max(0, (len(sp1) - len(sp2)) // nppcc)
+ sp1 = self.insert_n_curves_to_point_list(diff1, sp1)
+ sp2 = self.insert_n_curves_to_point_list(diff2, sp2)
+ new_path1 = np.append(new_path1, sp1, axis=0)
+ new_path2 = np.append(new_path2, sp2, axis=0)
+ self.set_points(new_path1)
+ vmobject.set_points(new_path2)
+ return self
+
+ def insert_n_curves(self, n: int) -> Self:
+ """Inserts n curves to the bezier curves of the vmobject.
+
+ Parameters
+ ----------
+ n
+ Number of curves to insert.
+
+ Returns
+ -------
+ :class:`VMobject`
+ ``self``
+ """
+ new_path_point = None
+ if self.has_new_path_started():
+ new_path_point = self.get_last_point()
+
+ new_points = self.insert_n_curves_to_point_list(n, self.points)
+ self.set_points(new_points)
+
+ if new_path_point is not None:
+ self.append_points([new_path_point])
+ return self
+
+ def insert_n_curves_to_point_list(
+ self, n: int, points: Point3D_Array
+ ) -> npt.NDArray[BezierPoints]:
+ """Given an array of k points defining a bezier curves (anchors and handles), returns points defining exactly k + n bezier curves.
+
+ Parameters
+ ----------
+ n
+ Number of desired curves.
+ points
+ Starting points.
+
+ Returns
+ -------
+ Points generated.
+ """
+
+ if len(points) == 1:
+ nppcc = self.n_points_per_cubic_curve
+ return np.repeat(points, nppcc * n, 0)
+ bezier_quads = self.get_cubic_bezier_tuples_from_points(points)
+ curr_num = len(bezier_quads)
+ target_num = curr_num + n
+ # This is an array with values ranging from 0
+ # up to curr_num, with repeats such that
+ # it's total length is target_num. For example,
+ # with curr_num = 10, target_num = 15, this would
+ # be [0, 0, 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9]
+ repeat_indices = (np.arange(target_num, dtype="i") * curr_num) // target_num
+
+ # If the nth term of this list is k, it means
+ # that the nth curve of our path should be split
+ # into k pieces.
+ # In the above example our array had the following elements
+ # [0, 0, 1, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9]
+ # We have two 0s, one 1, two 2s and so on.
+ # The split factors array would hence be:
+ # [2, 1, 2, 1, 2, 1, 2, 1, 2, 1]
+ split_factors = np.zeros(curr_num, dtype="i")
+ for val in repeat_indices:
+ split_factors[val] += 1
+
+ new_points = np.zeros((0, self.dim))
+ for quad, sf in zip(bezier_quads, split_factors):
+ # What was once a single cubic curve defined
+ # by "quad" will now be broken into sf
+ # smaller cubic curves
+ alphas = np.linspace(0, 1, sf + 1)
+ for a1, a2 in zip(alphas, alphas[1:]):
+ new_points = np.append(
+ new_points,
+ partial_bezier_points(quad, a1, a2),
+ axis=0,
+ )
+ return new_points
+
+ def align_rgbas(self, vmobject: VMobject) -> Self:
+ attrs = ["fill_rgbas", "stroke_rgbas", "background_stroke_rgbas"]
+ for attr in attrs:
+ a1 = getattr(self, attr)
+ a2 = getattr(vmobject, attr)
+ if len(a1) > len(a2):
+ new_a2 = stretch_array_to_length(a2, len(a1))
+ setattr(vmobject, attr, new_a2)
+ elif len(a2) > len(a1):
+ new_a1 = stretch_array_to_length(a1, len(a2))
+ setattr(self, attr, new_a1)
+ return self
+
+ def get_point_mobject(self, center: Point3D | None = None) -> VectorizedPoint:
+ if center is None:
+ center = self.get_center()
+ point = VectorizedPoint(center)
+ point.match_style(self)
+ return point
+
+ def interpolate_color(
+ self, mobject1: VMobject, mobject2: VMobject, alpha: float
+ ) -> None:
+ attrs = [
+ "fill_rgbas",
+ "stroke_rgbas",
+ "background_stroke_rgbas",
+ "stroke_width",
+ "background_stroke_width",
+ "sheen_direction",
+ "sheen_factor",
+ ]
+ for attr in attrs:
+ setattr(
+ self,
+ attr,
+ interpolate(getattr(mobject1, attr), getattr(mobject2, attr), alpha),
+ )
+ if alpha == 1.0:
+ setattr(self, attr, getattr(mobject2, attr))
+
+ def pointwise_become_partial(
+ self,
+ vmobject: VMobject,
+ a: float,
+ b: float,
+ ) -> Self:
+ """Given two bounds a and b, transforms the points of the self vmobject into the points of the vmobject
+ passed as parameter with respect to the bounds. Points here stand for control points of the bezier curves (anchors and handles)
+
+ Parameters
+ ----------
+ vmobject
+ The vmobject that will serve as a model.
+ a
+ upper-bound.
+ b
+ lower-bound
+
+ Returns
+ -------
+ :class:`VMobject`
+ ``self``
+ """
+ assert isinstance(vmobject, VMobject)
+ # Partial curve includes three portions:
+ # - A middle section, which matches the curve exactly
+ # - A start, which is some ending portion of an inner cubic
+ # - An end, which is the starting portion of a later inner cubic
+ if a <= 0 and b >= 1:
+ self.set_points(vmobject.points)
+ return self
+ bezier_quads = vmobject.get_cubic_bezier_tuples()
+ num_cubics = len(bezier_quads)
+
+ # The following two lines will compute which bezier curves of the given mobject need to be processed.
+ # The residue basically indicates de proportion of the selected bezier curve that have to be selected.
+ # Ex : if lower_index is 3, and lower_residue is 0.4, then the algorithm will append to the points 0.4 of the third bezier curve
+ lower_index, lower_residue = integer_interpolate(0, num_cubics, a)
+ upper_index, upper_residue = integer_interpolate(0, num_cubics, b)
+
+ self.clear_points()
+ if num_cubics == 0:
+ return self
+ if lower_index == upper_index:
+ self.append_points(
+ partial_bezier_points(
+ bezier_quads[lower_index],
+ lower_residue,
+ upper_residue,
+ ),
+ )
+ else:
+ self.append_points(
+ partial_bezier_points(bezier_quads[lower_index], lower_residue, 1),
+ )
+ for quad in bezier_quads[lower_index + 1 : upper_index]:
+ self.append_points(quad)
+ self.append_points(
+ partial_bezier_points(bezier_quads[upper_index], 0, upper_residue),
+ )
+ return self
+
+ def get_subcurve(self, a: float, b: float) -> Self:
+ """Returns the subcurve of the VMobject between the interval [a, b].
+ The curve is a VMobject itself.
+
+ Parameters
+ ----------
+
+ a
+ The lower bound.
+ b
+ The upper bound.
+
+ Returns
+ -------
+ VMobject
+ The subcurve between of [a, b]
+ """
+ if self.is_closed() and a > b:
+ vmob = self.copy()
+ vmob.pointwise_become_partial(self, a, 1)
+ vmob2 = self.copy()
+ vmob2.pointwise_become_partial(self, 0, b)
+ vmob.append_vectorized_mobject(vmob2)
+ else:
+ vmob = self.copy()
+ vmob.pointwise_become_partial(self, a, b)
+ return vmob
+
+ def get_direction(self) -> Literal["CW", "CCW"]:
+ """Uses :func:`~.space_ops.shoelace_direction` to calculate the direction.
+ The direction of points determines in which direction the
+ object is drawn, clockwise or counterclockwise.
+
+ Examples
+ --------
+ The default direction of a :class:`~.Circle` is counterclockwise::
+
+ >>> from manim import Circle
+ >>> Circle().get_direction()
+ 'CCW'
+
+ Returns
+ -------
+ :class:`str`
+ Either ``"CW"`` or ``"CCW"``.
+ """
+ return shoelace_direction(self.get_start_anchors())
+
+ def reverse_direction(self) -> Self:
+ """Reverts the point direction by inverting the point order.
+
+ Returns
+ -------
+ :class:`VMobject`
+ Returns self.
+
+ Examples
+ --------
+ .. manim:: ChangeOfDirection
+
+ class ChangeOfDirection(Scene):
+ def construct(self):
+ ccw = RegularPolygon(5)
+ ccw.shift(LEFT)
+ cw = RegularPolygon(5)
+ cw.shift(RIGHT).reverse_direction()
+
+ self.play(Create(ccw), Create(cw),
+ run_time=4)
+ """
+ self.points = self.points[::-1]
+ return self
+
+ def force_direction(self, target_direction: Literal["CW", "CCW"]) -> Self:
+ """Makes sure that points are either directed clockwise or
+ counterclockwise.
+
+ Parameters
+ ----------
+ target_direction
+ Either ``"CW"`` or ``"CCW"``.
+ """
+ if target_direction not in ("CW", "CCW"):
+ raise ValueError('Invalid input for force_direction. Use "CW" or "CCW"')
+ if self.get_direction() != target_direction:
+ # Since we already assured the input is CW or CCW,
+ # and the directions don't match, we just reverse
+ self.reverse_direction()
+ return self
+
+
+class VGroup(VMobject, metaclass=ConvertToOpenGL):
+ """A group of vectorized mobjects.
+
+ This can be used to group multiple :class:`~.VMobject` instances together
+ in order to scale, move, ... them together.
+
+ Notes
+ -----
+ When adding the same mobject more than once, repetitions are ignored.
+ Use :meth:`.Mobject.copy` to create a separate copy which can then
+ be added to the group.
+
+ Examples
+ --------
+
+ To add :class:`~.VMobject`s to a :class:`~.VGroup`, you can either use the
+ :meth:`~.VGroup.add` method, or use the `+` and `+=` operators. Similarly, you
+ can subtract elements of a VGroup via :meth:`~.VGroup.remove` method, or
+ `-` and `-=` operators:
+
+ >>> from manim import Triangle, Square, VGroup
+ >>> vg = VGroup()
+ >>> triangle, square = Triangle(), Square()
+ >>> vg.add(triangle)
+ VGroup(Triangle)
+ >>> vg + square # a new VGroup is constructed
+ VGroup(Triangle, Square)
+ >>> vg # not modified
+ VGroup(Triangle)
+ >>> vg += square; vg # modifies vg
+ VGroup(Triangle, Square)
+ >>> vg.remove(triangle)
+ VGroup(Square)
+ >>> vg - square; # a new VGroup is constructed
+ VGroup()
+ >>> vg # not modified
+ VGroup(Square)
+ >>> vg -= square; vg # modifies vg
+ VGroup()
+
+ .. manim:: ArcShapeIris
+ :save_last_frame:
+
+ class ArcShapeIris(Scene):
+ def construct(self):
+ colors = [DARK_BROWN, BLUE_E, BLUE_D, BLUE_A, TEAL_B, GREEN_B, YELLOW_E]
+ radius = [1 + rad * 0.1 for rad in range(len(colors))]
+
+ circles_group = VGroup()
+
+ # zip(radius, color) makes the iterator [(radius[i], color[i]) for i in range(radius)]
+ circles_group.add(*[Circle(radius=rad, stroke_width=10, color=col)
+ for rad, col in zip(radius, colors)])
+ self.add(circles_group)
+
+ """
+
+ def __init__(self, *vmobjects, **kwargs):
+ super().__init__(**kwargs)
+ self.add(*vmobjects)
+
+ def __repr__(self) -> str:
+ return f'{self.__class__.__name__}({", ".join(str(mob) for mob in self.submobjects)})'
+
+ def __str__(self) -> str:
+ return (
+ f"{self.__class__.__name__} of {len(self.submobjects)} "
+ f"submobject{'s' if len(self.submobjects) > 0 else ''}"
+ )
+
+ def add(self, *vmobjects: VMobject) -> Self:
+ """Checks if all passed elements are an instance of VMobject and then add them to submobjects
+
+ Parameters
+ ----------
+ vmobjects
+ List of VMobject to add
+
+ Returns
+ -------
+ :class:`VGroup`
+
+ Raises
+ ------
+ TypeError
+ If one element of the list is not an instance of VMobject
+
+ Examples
+ --------
+ .. manim:: AddToVGroup
+
+ class AddToVGroup(Scene):
+ def construct(self):
+ circle_red = Circle(color=RED)
+ circle_green = Circle(color=GREEN)
+ circle_blue = Circle(color=BLUE)
+ circle_red.shift(LEFT)
+ circle_blue.shift(RIGHT)
+ gr = VGroup(circle_red, circle_green)
+ gr2 = VGroup(circle_blue) # Constructor uses add directly
+ self.add(gr,gr2)
+ self.wait()
+ gr += gr2 # Add group to another
+ self.play(
+ gr.animate.shift(DOWN),
+ )
+ gr -= gr2 # Remove group
+ self.play( # Animate groups separately
+ gr.animate.shift(LEFT),
+ gr2.animate.shift(UP),
+ )
+ self.play( #Animate groups without modification
+ (gr+gr2).animate.shift(RIGHT)
+ )
+ self.play( # Animate group without component
+ (gr-circle_red).animate.shift(RIGHT)
+ )
+ """
+ if not all(isinstance(m, (VMobject, OpenGLVMobject)) for m in vmobjects):
+ raise TypeError("All submobjects must be of type VMobject")
+ return super().add(*vmobjects)
+
+ def __add__(self, vmobject: VMobject) -> Self:
+ return VGroup(*self.submobjects, vmobject)
+
+ def __iadd__(self, vmobject: VMobject) -> Self:
+ return self.add(vmobject)
+
+ def __sub__(self, vmobject: VMobject) -> Self:
+ copy = VGroup(*self.submobjects)
+ copy.remove(vmobject)
+ return copy
+
+ def __isub__(self, vmobject: VMobject) -> Self:
+ return self.remove(vmobject)
+
+ def __setitem__(self, key: int, value: VMobject | Sequence[VMobject]) -> None:
+ """Override the [] operator for item assignment.
+
+ Parameters
+ ----------
+ key
+ The index of the submobject to be assigned
+ value
+ The vmobject value to assign to the key
+
+ Returns
+ -------
+ None
+
+ Tests
+ -----
+ Check that item assignment does not raise error::
+ >>> vgroup = VGroup(VMobject())
+ >>> new_obj = VMobject()
+ >>> vgroup[0] = new_obj
+ """
+ if not all(isinstance(m, (VMobject, OpenGLVMobject)) for m in value):
+ raise TypeError("All submobjects must be of type VMobject")
+ self.submobjects[key] = value
+
+
+class VDict(VMobject, metaclass=ConvertToOpenGL):
+ """A VGroup-like class, also offering submobject access by
+ key, like a python dict
+
+ Parameters
+ ----------
+ mapping_or_iterable
+ The parameter specifying the key-value mapping of keys and mobjects.
+ show_keys
+ Whether to also display the key associated with
+ the mobject. This might be useful when debugging,
+ especially when there are a lot of mobjects in the
+ :class:`VDict`. Defaults to False.
+ kwargs
+ Other arguments to be passed to `Mobject`.
+
+ Attributes
+ ----------
+ show_keys : :class:`bool`
+ Whether to also display the key associated with
+ the mobject. This might be useful when debugging,
+ especially when there are a lot of mobjects in the
+ :class:`VDict`. When displayed, the key is towards
+ the left of the mobject.
+ Defaults to False.
+ submob_dict : :class:`dict`
+ Is the actual python dictionary that is used to bind
+ the keys to the mobjects.
+
+ Examples
+ --------
+
+ .. manim:: ShapesWithVDict
+
+ class ShapesWithVDict(Scene):
+ def construct(self):
+ square = Square().set_color(RED)
+ circle = Circle().set_color(YELLOW).next_to(square, UP)
+
+ # create dict from list of tuples each having key-mobject pair
+ pairs = [("s", square), ("c", circle)]
+ my_dict = VDict(pairs, show_keys=True)
+
+ # display it just like a VGroup
+ self.play(Create(my_dict))
+ self.wait()
+
+ text = Tex("Some text").set_color(GREEN).next_to(square, DOWN)
+
+ # add a key-value pair by wrapping it in a single-element list of tuple
+ # after attrs branch is merged, it will be easier like `.add(t=text)`
+ my_dict.add([("t", text)])
+ self.wait()
+
+ rect = Rectangle().next_to(text, DOWN)
+ # can also do key assignment like a python dict
+ my_dict["r"] = rect
+
+ # access submobjects like a python dict
+ my_dict["t"].set_color(PURPLE)
+ self.play(my_dict["t"].animate.scale(3))
+ self.wait()
+
+ # also supports python dict styled reassignment
+ my_dict["t"] = Tex("Some other text").set_color(BLUE)
+ self.wait()
+
+ # remove submobject by key
+ my_dict.remove("t")
+ self.wait()
+
+ self.play(Uncreate(my_dict["s"]))
+ self.wait()
+
+ self.play(FadeOut(my_dict["c"]))
+ self.wait()
+
+ self.play(FadeOut(my_dict["r"], shift=DOWN))
+ self.wait()
+
+ # you can also make a VDict from an existing dict of mobjects
+ plain_dict = {
+ 1: Integer(1).shift(DOWN),
+ 2: Integer(2).shift(2 * DOWN),
+ 3: Integer(3).shift(3 * DOWN),
+ }
+
+ vdict_from_plain_dict = VDict(plain_dict)
+ vdict_from_plain_dict.shift(1.5 * (UP + LEFT))
+ self.play(Create(vdict_from_plain_dict))
+
+ # you can even use zip
+ vdict_using_zip = VDict(zip(["s", "c", "r"], [Square(), Circle(), Rectangle()]))
+ vdict_using_zip.shift(1.5 * RIGHT)
+ self.play(Create(vdict_using_zip))
+ self.wait()
+ """
+
+ def __init__(
+ self,
+ mapping_or_iterable: (
+ Mapping[Hashable, VMobject] | Iterable[tuple[Hashable, VMobject]]
+ ) = {},
+ show_keys: bool = False,
+ **kwargs,
+ ) -> None:
+ super().__init__(**kwargs)
+ self.show_keys = show_keys
+ self.submob_dict = {}
+ self.add(mapping_or_iterable)
+
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}({repr(self.submob_dict)})"
+
+ def add(
+ self,
+ mapping_or_iterable: (
+ Mapping[Hashable, VMobject] | Iterable[tuple[Hashable, VMobject]]
+ ),
+ ) -> Self:
+ """Adds the key-value pairs to the :class:`VDict` object.
+
+ Also, it internally adds the value to the `submobjects` :class:`list`
+ of :class:`~.Mobject`, which is responsible for actual on-screen display.
+
+ Parameters
+ ---------
+ mapping_or_iterable
+ The parameter specifying the key-value mapping of keys and mobjects.
+
+ Returns
+ -------
+ :class:`VDict`
+ Returns the :class:`VDict` object on which this method was called.
+
+ Examples
+ --------
+ Normal usage::
+
+ square_obj = Square()
+ my_dict.add([('s', square_obj)])
+ """
+ for key, value in dict(mapping_or_iterable).items():
+ self.add_key_value_pair(key, value)
+
+ return self
+
+ def remove(self, key: Hashable) -> Self:
+ """Removes the mobject from the :class:`VDict` object having the key `key`
+
+ Also, it internally removes the mobject from the `submobjects` :class:`list`
+ of :class:`~.Mobject`, (which is responsible for removing it from the screen)
+
+ Parameters
+ ----------
+ key
+ The key of the submoject to be removed.
+
+ Returns
+ -------
+ :class:`VDict`
+ Returns the :class:`VDict` object on which this method was called.
+
+ Examples
+ --------
+ Normal usage::
+
+ my_dict.remove('square')
+ """
+ if key not in self.submob_dict:
+ raise KeyError("The given key '%s' is not present in the VDict" % str(key))
+ super().remove(self.submob_dict[key])
+ del self.submob_dict[key]
+ return self
+
+ def __getitem__(self, key: Hashable):
+ """Override the [] operator for item retrieval.
+
+ Parameters
+ ----------
+ key
+ The key of the submoject to be accessed
+
+ Returns
+ -------
+ :class:`VMobject`
+ The submobject corresponding to the key `key`
+
+ Examples
+ --------
+ Normal usage::
+
+ self.play(Create(my_dict['s']))
+ """
+ submob = self.submob_dict[key]
+ return submob
+
+ def __setitem__(self, key: Hashable, value: VMobject) -> None:
+ """Override the [] operator for item assignment.
+
+ Parameters
+ ----------
+ key
+ The key of the submoject to be assigned
+ value
+ The submobject to bind the key to
+
+ Returns
+ -------
+ None
+
+ Examples
+ --------
+ Normal usage::
+
+ square_obj = Square()
+ my_dict['sq'] = square_obj
+ """
+ if key in self.submob_dict:
+ self.remove(key)
+ self.add([(key, value)])
+
+ def __delitem__(self, key: Hashable):
+ """Override the del operator for deleting an item.
+
+ Parameters
+ ----------
+ key
+ The key of the submoject to be deleted
+
+ Returns
+ -------
+ None
+
+ Examples
+ --------
+ ::
+
+ >>> from manim import *
+ >>> my_dict = VDict({'sq': Square()})
+ >>> 'sq' in my_dict
+ True
+ >>> del my_dict['sq']
+ >>> 'sq' in my_dict
+ False
+
+ Notes
+ -----
+ Removing an item from a VDict does not remove that item from any Scene
+ that the VDict is part of.
+
+ """
+ del self.submob_dict[key]
+
+ def __contains__(self, key: Hashable):
+ """Override the in operator.
+
+ Parameters
+ ----------
+ key
+ The key to check membership of.
+
+ Returns
+ -------
+ :class:`bool`
+
+ Examples
+ --------
+ ::
+
+ >>> from manim import *
+ >>> my_dict = VDict({'sq': Square()})
+ >>> 'sq' in my_dict
+ True
+
+ """
+ return key in self.submob_dict
+
+ def get_all_submobjects(self) -> list[list]:
+ """To get all the submobjects associated with a particular :class:`VDict` object
+
+ Returns
+ -------
+ :class:`dict_values`
+ All the submobjects associated with the :class:`VDict` object
+
+ Examples
+ --------
+ Normal usage::
+
+ for submob in my_dict.get_all_submobjects():
+ self.play(Create(submob))
+ """
+ submobjects = self.submob_dict.values()
+ return submobjects
+
+ def add_key_value_pair(self, key: Hashable, value: VMobject) -> None:
+ """A utility function used by :meth:`add` to add the key-value pair
+ to :attr:`submob_dict`. Not really meant to be used externally.
+
+ Parameters
+ ----------
+ key
+ The key of the submobject to be added.
+ value
+ The mobject associated with the key
+
+ Returns
+ -------
+ None
+
+ Raises
+ ------
+ TypeError
+ If the value is not an instance of VMobject
+
+ Examples
+ --------
+ Normal usage::
+
+ square_obj = Square()
+ self.add_key_value_pair('s', square_obj)
+
+ """
+ if not isinstance(value, (VMobject, OpenGLVMobject)):
+ raise TypeError("All submobjects must be of type VMobject")
+ mob = value
+ if self.show_keys:
+ # This import is here and not at the top to avoid circular import
+ from manim.mobject.text.tex_mobject import Tex
+
+ key_text = Tex(str(key)).next_to(value, LEFT)
+ mob.add(key_text)
+
+ self.submob_dict[key] = mob
+ super().add(value)
+
+
+class VectorizedPoint(VMobject, metaclass=ConvertToOpenGL):
+ def __init__(
+ self,
+ location: Point3D = ORIGIN,
+ color: ManimColor = BLACK,
+ fill_opacity: float = 0,
+ stroke_width: float = 0,
+ artificial_width: float = 0.01,
+ artificial_height: float = 0.01,
+ **kwargs,
+ ) -> None:
+ self.artificial_width = artificial_width
+ self.artificial_height = artificial_height
+ super().__init__(
+ color=color,
+ fill_opacity=fill_opacity,
+ stroke_width=stroke_width,
+ **kwargs,
+ )
+ self.set_points(np.array([location]))
+
+ basecls = OpenGLVMobject if config.renderer == RendererType.OPENGL else VMobject
+
+ @basecls.width.getter
+ def width(self) -> float:
+ return self.artificial_width
+
+ @basecls.height.getter
+ def height(self) -> float:
+ return self.artificial_height
+
+ def get_location(self) -> Point3D:
+ return np.array(self.points[0])
+
+ def set_location(self, new_loc: Point3D):
+ self.set_points(np.array([new_loc]))
+
+
+class CurvesAsSubmobjects(VGroup):
+ """Convert a curve's elements to submobjects.
+
+ Examples
+ --------
+ .. manim:: LineGradientExample
+ :save_last_frame:
+
+ class LineGradientExample(Scene):
+ def construct(self):
+ curve = ParametricFunction(lambda t: [t, np.sin(t), 0], t_range=[-PI, PI, 0.01], stroke_width=10)
+ new_curve = CurvesAsSubmobjects(curve)
+ new_curve.set_color_by_gradient(BLUE, RED)
+ self.add(new_curve.shift(UP), curve)
+
+ """
+
+ def __init__(self, vmobject: VMobject, **kwargs) -> None:
+ super().__init__(**kwargs)
+ tuples = vmobject.get_cubic_bezier_tuples()
+ for tup in tuples:
+ part = VMobject()
+ part.set_points(tup)
+ part.match_style(vmobject)
+ self.add(part)
+
+ def point_from_proportion(self, alpha: float) -> Point3D:
+ """Gets the point at a proportion along the path of the :class:`CurvesAsSubmobjects`.
+
+ Parameters
+ ----------
+ alpha
+ The proportion along the the path of the :class:`CurvesAsSubmobjects`.
+
+ Returns
+ -------
+ :class:`numpy.ndarray`
+ The point on the :class:`CurvesAsSubmobjects`.
+
+ Raises
+ ------
+ :exc:`ValueError`
+ If ``alpha`` is not between 0 and 1.
+ :exc:`Exception`
+ If the :class:`CurvesAsSubmobjects` has no submobjects, or no submobject has points.
+ """
+ if alpha < 0 or alpha > 1:
+ raise ValueError(f"Alpha {alpha} not between 0 and 1.")
+
+ self._throw_error_if_no_submobjects()
+ submobjs_with_pts = self._get_submobjects_with_points()
+
+ if alpha == 1:
+ return submobjs_with_pts[-1].points[-1]
+
+ submobjs_arc_lengths = tuple(
+ part.get_arc_length() for part in submobjs_with_pts
+ )
+
+ total_length = sum(submobjs_arc_lengths)
+ target_length = alpha * total_length
+ current_length = 0
+
+ for i, part in enumerate(submobjs_with_pts):
+ part_length = submobjs_arc_lengths[i]
+ if current_length + part_length >= target_length:
+ residue = (target_length - current_length) / part_length
+ return part.point_from_proportion(residue)
+
+ current_length += part_length
+
+ def _throw_error_if_no_submobjects(self):
+ if len(self.submobjects) == 0:
+ caller_name = sys._getframe(1).f_code.co_name
+ raise Exception(
+ f"Cannot call CurvesAsSubmobjects.{caller_name} for a CurvesAsSubmobject with no submobjects"
+ )
+
+ def _get_submobjects_with_points(self):
+ submobjs_with_pts = tuple(
+ part for part in self.submobjects if len(part.points) > 0
+ )
+ if len(submobjs_with_pts) == 0:
+ caller_name = sys._getframe(1).f_code.co_name
+ raise Exception(
+ f"Cannot call CurvesAsSubmobjects.{caller_name} for a CurvesAsSubmobject whose submobjects have no points"
+ )
+ return submobjs_with_pts
+
+
+class DashedVMobject(VMobject, metaclass=ConvertToOpenGL):
+ """A :class:`VMobject` composed of dashes instead of lines.
+
+ Parameters
+ ----------
+ vmobject
+ The object that will get dashed
+ num_dashes
+ Number of dashes to add.
+ dashed_ratio
+ Ratio of dash to empty space.
+ dash_offset
+ Shifts the starting point of dashes along the
+ path. Value 1 shifts by one full dash length.
+ equal_lengths
+ If ``True``, dashes will be (approximately) equally long.
+ If ``False``, dashes will be split evenly in the curve's
+ input t variable (legacy behavior).
+
+ Examples
+ --------
+ .. manim:: DashedVMobjectExample
+ :save_last_frame:
+
+ class DashedVMobjectExample(Scene):
+ def construct(self):
+ r = 0.5
+
+ top_row = VGroup() # Increasing num_dashes
+ for dashes in range(1, 12):
+ circ = DashedVMobject(Circle(radius=r, color=WHITE), num_dashes=dashes)
+ top_row.add(circ)
+
+ middle_row = VGroup() # Increasing dashed_ratio
+ for ratio in np.arange(1 / 11, 1, 1 / 11):
+ circ = DashedVMobject(
+ Circle(radius=r, color=WHITE), dashed_ratio=ratio
+ )
+ middle_row.add(circ)
+
+ func1 = FunctionGraph(lambda t: t**5,[-1,1],color=WHITE)
+ func_even = DashedVMobject(func1,num_dashes=6,equal_lengths=True)
+ func_stretched = DashedVMobject(func1, num_dashes=6, equal_lengths=False)
+ bottom_row = VGroup(func_even,func_stretched)
+
+
+ top_row.arrange(buff=0.3)
+ middle_row.arrange()
+ bottom_row.arrange(buff=1)
+ everything = VGroup(top_row, middle_row, bottom_row).arrange(DOWN, buff=1)
+ self.add(everything)
+
+ """
+
+ def __init__(
+ self,
+ vmobject: VMobject,
+ num_dashes: int = 15,
+ dashed_ratio: float = 0.5,
+ dash_offset: float = 0,
+ color: ManimColor = WHITE,
+ equal_lengths: bool = True,
+ **kwargs,
+ ) -> None:
+ self.dashed_ratio = dashed_ratio
+ self.num_dashes = num_dashes
+ super().__init__(color=color, **kwargs)
+ r = self.dashed_ratio
+ n = self.num_dashes
+ if n > 0:
+ # Assuming total length is 1
+ dash_len = r / n
+ if vmobject.is_closed():
+ void_len = (1 - r) / n
+ else:
+ if n == 1:
+ void_len = 1 - r
+ else:
+ void_len = (1 - r) / (n - 1)
+
+ period = dash_len + void_len
+ phase_shift = (dash_offset % 1) * period
+
+ if vmobject.is_closed():
+ # closed curves have equal amount of dashes and voids
+ pattern_len = 1
+ else:
+ # open curves start and end with a dash, so the whole dash pattern with the last void is longer
+ pattern_len = 1 + void_len
+
+ dash_starts = [((i * period + phase_shift) % pattern_len) for i in range(n)]
+ dash_ends = [
+ ((i * period + dash_len + phase_shift) % pattern_len) for i in range(n)
+ ]
+
+ # closed shapes can handle overflow at the 0-point
+ # open shapes need special treatment for it
+ if not vmobject.is_closed():
+ # due to phase shift being [0...1] range, always the last dash element needs attention for overflow
+ # if an entire dash moves out of the shape end:
+ if dash_ends[-1] > 1 and dash_starts[-1] > 1:
+ # remove the last element since it is out-of-bounds
+ dash_ends.pop()
+ dash_starts.pop()
+ elif dash_ends[-1] < dash_len: # if it overflowed
+ if (
+ dash_starts[-1] < 1
+ ): # if the beginning of the piece is still in range
+ dash_starts.append(0)
+ dash_ends.append(dash_ends[-1])
+ dash_ends[-2] = 1
+ else:
+ dash_starts[-1] = 0
+ elif dash_starts[-1] > (1 - dash_len):
+ dash_ends[-1] = 1
+
+ if equal_lengths:
+ # calculate the entire length by adding up short line-pieces
+ norms = np.array(0)
+ for k in range(vmobject.get_num_curves()):
+ norms = np.append(norms, vmobject.get_nth_curve_length_pieces(k))
+ # add up length-pieces in array form
+ length_vals = np.cumsum(norms)
+ ref_points = np.linspace(0, 1, length_vals.size)
+ curve_length = length_vals[-1]
+ self.add(
+ *(
+ vmobject.get_subcurve(
+ np.interp(
+ dash_starts[i] * curve_length,
+ length_vals,
+ ref_points,
+ ),
+ np.interp(
+ dash_ends[i] * curve_length,
+ length_vals,
+ ref_points,
+ ),
+ )
+ for i in range(len(dash_starts))
+ )
+ )
+ else:
+ self.add(
+ *(
+ vmobject.get_subcurve(
+ dash_starts[i],
+ dash_ends[i],
+ )
+ for i in range(len(dash_starts))
+ )
+ )
+ # Family is already taken care of by get_subcurve
+ # implementation
+ if config.renderer == RendererType.OPENGL:
+ self.match_style(vmobject, recurse=False)
+ else:
+ self.match_style(vmobject, family=False)
diff --git a/data/rag/manim_docs/manim_core/source/mobject/utils.py b/data/rag/manim_docs/manim_core/source/mobject/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..b38bb57f2e271d756b0e39945d900df0fad9c112
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/mobject/utils.py
@@ -0,0 +1,107 @@
+"""Utilities for working with mobjects."""
+
+from __future__ import annotations
+
+__all__ = [
+ "get_mobject_class",
+ "get_point_mobject_class",
+ "get_vectorized_mobject_class",
+]
+
+from .._config import config
+from ..constants import RendererType
+from .mobject import Mobject
+from .opengl.opengl_mobject import OpenGLMobject
+from .opengl.opengl_point_cloud_mobject import OpenGLPMobject
+from .opengl.opengl_vectorized_mobject import OpenGLVMobject
+from .types.point_cloud_mobject import PMobject
+from .types.vectorized_mobject import VMobject
+
+
+def get_mobject_class() -> type:
+ """Gets the base mobject class, depending on the currently active renderer.
+
+ .. NOTE::
+
+ This method is intended to be used in the code base of Manim itself
+ or in plugins where code should work independent of the selected
+ renderer.
+
+ Examples
+ --------
+
+ The function has to be explicitly imported. We test that
+ the name of the returned class is one of the known mobject
+ base classes::
+
+ >>> from manim.mobject.utils import get_mobject_class
+ >>> get_mobject_class().__name__ in ['Mobject', 'OpenGLMobject']
+ True
+ """
+ if config.renderer == RendererType.CAIRO:
+ return Mobject
+ if config.renderer == RendererType.OPENGL:
+ return OpenGLMobject
+ raise NotImplementedError(
+ "Base mobjects are not implemented for the active renderer."
+ )
+
+
+def get_vectorized_mobject_class() -> type:
+ """Gets the vectorized mobject class, depending on the currently
+ active renderer.
+
+ .. NOTE::
+
+ This method is intended to be used in the code base of Manim itself
+ or in plugins where code should work independent of the selected
+ renderer.
+
+ Examples
+ --------
+
+ The function has to be explicitly imported. We test that
+ the name of the returned class is one of the known mobject
+ base classes::
+
+ >>> from manim.mobject.utils import get_vectorized_mobject_class
+ >>> get_vectorized_mobject_class().__name__ in ['VMobject', 'OpenGLVMobject']
+ True
+ """
+ if config.renderer == RendererType.CAIRO:
+ return VMobject
+ if config.renderer == RendererType.OPENGL:
+ return OpenGLVMobject
+ raise NotImplementedError(
+ "Vectorized mobjects are not implemented for the active renderer."
+ )
+
+
+def get_point_mobject_class() -> type:
+ """Gets the point cloud mobject class, depending on the currently
+ active renderer.
+
+ .. NOTE::
+
+ This method is intended to be used in the code base of Manim itself
+ or in plugins where code should work independent of the selected
+ renderer.
+
+ Examples
+ --------
+
+ The function has to be explicitly imported. We test that
+ the name of the returned class is one of the known mobject
+ base classes::
+
+ >>> from manim.mobject.utils import get_point_mobject_class
+ >>> get_point_mobject_class().__name__ in ['PMobject', 'OpenGLPMobject']
+ True
+ """
+ if config.renderer == RendererType.CAIRO:
+ return PMobject
+ if config.renderer == RendererType.OPENGL:
+ return OpenGLPMobject
+ raise NotImplementedError(
+ "Point cloud mobjects are not implemented for the active renderer."
+ )
diff --git a/data/rag/manim_docs/manim_core/source/mobject/value_tracker.py b/data/rag/manim_docs/manim_core/source/mobject/value_tracker.py
new file mode 100644
index 0000000000000000000000000000000000000000..b60d89887ebd8d26b468d6fe9e10c1cacac5351f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/mobject/value_tracker.py
@@ -0,0 +1,175 @@
+"""Simple mobjects that can be used for storing (and updating) a value."""
+
+from __future__ import annotations
+
+__all__ = ["ValueTracker", "ComplexValueTracker"]
+
+
+import numpy as np
+
+from manim.mobject.mobject import Mobject
+from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
+from manim.utils.paths import straight_path
+
+
+class ValueTracker(Mobject, metaclass=ConvertToOpenGL):
+ """A mobject that can be used for tracking (real-valued) parameters.
+ Useful for animating parameter changes.
+
+ Not meant to be displayed. Instead the position encodes some
+ number, often one which another animation or continual_animation
+ uses for its update function, and by treating it as a mobject it can
+ still be animated and manipulated just like anything else.
+
+ This value changes continuously when animated using the :attr:`animate` syntax.
+
+ Examples
+ --------
+ .. manim:: ValueTrackerExample
+
+ class ValueTrackerExample(Scene):
+ def construct(self):
+ number_line = NumberLine()
+ pointer = Vector(DOWN)
+ label = MathTex("x").add_updater(lambda m: m.next_to(pointer, UP))
+
+ tracker = ValueTracker(0)
+ pointer.add_updater(
+ lambda m: m.next_to(
+ number_line.n2p(tracker.get_value()),
+ UP
+ )
+ )
+ self.add(number_line, pointer,label)
+ tracker += 1.5
+ self.wait(1)
+ tracker -= 4
+ self.wait(0.5)
+ self.play(tracker.animate.set_value(5)),
+ self.wait(0.5)
+ self.play(tracker.animate.set_value(3))
+ self.play(tracker.animate.increment_value(-2))
+ self.wait(0.5)
+
+ .. note::
+
+ You can also link ValueTrackers to updaters. In this case, you have to make sure that the
+ ValueTracker is added to the scene by ``add``
+
+ .. manim:: ValueTrackerExample
+
+ class ValueTrackerExample(Scene):
+ def construct(self):
+ tracker = ValueTracker(0)
+ label = Dot(radius=3).add_updater(lambda x : x.set_x(tracker.get_value()))
+ self.add(label)
+ self.add(tracker)
+ tracker.add_updater(lambda mobject, dt: mobject.increment_value(dt))
+ self.wait(2)
+
+ """
+
+ def __init__(self, value=0, **kwargs):
+ super().__init__(**kwargs)
+ self.set_points(np.zeros((1, 3)))
+ self.set_value(value)
+
+ def get_value(self) -> float:
+ """Get the current value of this ValueTracker."""
+ return self.points[0, 0]
+
+ def set_value(self, value: float):
+ """Sets a new scalar value to the ValueTracker"""
+ self.points[0, 0] = value
+ return self
+
+ def increment_value(self, d_value: float):
+ """Increments (adds) a scalar value to the ValueTracker"""
+ self.set_value(self.get_value() + d_value)
+ return self
+
+ def __bool__(self):
+ """Return whether the value of this value tracker evaluates as true."""
+ return bool(self.get_value())
+
+ def __iadd__(self, d_value: float):
+ """adds ``+=`` syntax to increment the value of the ValueTracker"""
+ self.increment_value(d_value)
+ return self
+
+ def __ifloordiv__(self, d_value: float):
+ """Set the value of this value tracker to the floor division of the current value by ``d_value``."""
+ self.set_value(self.get_value() // d_value)
+ return self
+
+ def __imod__(self, d_value: float):
+ """Set the value of this value tracker to the current value modulo ``d_value``."""
+ self.set_value(self.get_value() % d_value)
+ return self
+
+ def __imul__(self, d_value: float):
+ """Set the value of this value tracker to the product of the current value and ``d_value``."""
+ self.set_value(self.get_value() * d_value)
+ return self
+
+ def __ipow__(self, d_value: float):
+ """Set the value of this value tracker to the current value raised to the power of ``d_value``."""
+ self.set_value(self.get_value() ** d_value)
+ return self
+
+ def __isub__(self, d_value: float):
+ """adds ``-=`` syntax to decrement the value of the ValueTracker"""
+ self.increment_value(-d_value)
+ return self
+
+ def __itruediv__(self, d_value: float):
+ """Sets the value of this value tracker to the current value divided by ``d_value``."""
+ self.set_value(self.get_value() / d_value)
+ return self
+
+ def interpolate(self, mobject1, mobject2, alpha, path_func=straight_path()):
+ """
+ Turns self into an interpolation between mobject1
+ and mobject2.
+ """
+ self.set_points(path_func(mobject1.points, mobject2.points, alpha))
+ return self
+
+
+class ComplexValueTracker(ValueTracker):
+ """Tracks a complex-valued parameter.
+
+ When the value is set through :attr:`animate`, the value will take a straight path from the
+ source point to the destination point.
+
+ Examples
+ --------
+ .. manim:: ComplexValueTrackerExample
+
+ class ComplexValueTrackerExample(Scene):
+ def construct(self):
+ tracker = ComplexValueTracker(-2+1j)
+ dot = Dot().add_updater(
+ lambda x: x.move_to(tracker.points)
+ )
+
+ self.add(NumberPlane(), dot)
+
+ self.play(tracker.animate.set_value(3+2j))
+ self.play(tracker.animate.set_value(tracker.get_value() * 1j))
+ self.play(tracker.animate.set_value(tracker.get_value() - 2j))
+ self.play(tracker.animate.set_value(tracker.get_value() / (-2 + 3j)))
+ """
+
+ def get_value(self):
+ """Get the current value of this value tracker as a complex number.
+
+ The value is internally stored as a points array [a, b, 0]. This can be accessed directly
+ to represent the value geometrically, see the usage example."""
+ return complex(*self.points[0, :2])
+
+ def set_value(self, z):
+ """Sets a new complex value to the ComplexValueTracker"""
+ z = complex(z)
+ self.points[0, :2] = (z.real, z.imag)
+ return self
diff --git a/data/rag/manim_docs/manim_core/source/mobject/vector_field.py b/data/rag/manim_docs/manim_core/source/mobject/vector_field.py
new file mode 100644
index 0000000000000000000000000000000000000000..67bdd5e6a2c41356edd3515a825faa952635ca31
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/mobject/vector_field.py
@@ -0,0 +1,1076 @@
+"""Mobjects representing vector fields."""
+
+from __future__ import annotations
+
+__all__ = [
+ "VectorField",
+ "ArrowVectorField",
+ "StreamLines",
+]
+
+import itertools as it
+import random
+from math import ceil, floor
+from typing import Callable, Iterable, Sequence
+
+import numpy as np
+from PIL import Image
+
+from manim.animation.updaters.update import UpdateFromAlphaFunc
+from manim.mobject.geometry.line import Vector
+from manim.mobject.graphing.coordinate_systems import CoordinateSystem
+
+from .. import config
+from ..animation.composition import AnimationGroup, Succession
+from ..animation.creation import Create
+from ..animation.indication import ShowPassingFlash
+from ..constants import OUT, RIGHT, UP, RendererType
+from ..mobject.mobject import Mobject
+from ..mobject.types.vectorized_mobject import VGroup
+from ..mobject.utils import get_vectorized_mobject_class
+from ..utils.bezier import interpolate, inverse_interpolate
+from ..utils.color import (
+ BLUE_E,
+ GREEN,
+ RED,
+ YELLOW,
+ ManimColor,
+ ParsableManimColor,
+ color_to_rgb,
+ rgb_to_color,
+)
+from ..utils.rate_functions import ease_out_sine, linear
+from ..utils.simple_functions import sigmoid
+
+DEFAULT_SCALAR_FIELD_COLORS: list = [BLUE_E, GREEN, YELLOW, RED]
+
+
+class VectorField(VGroup):
+ """A vector field.
+
+ Vector fields are based on a function defining a vector at every position.
+ This class does by default not include any visible elements but provides
+ methods to move other :class:`~.Mobject` s along the vector field.
+
+ Parameters
+ ----------
+ func
+ The function defining the rate of change at every position of the `VectorField`.
+ color
+ The color of the vector field. If set, position-specific coloring is disabled.
+ color_scheme
+ A function mapping a vector to a single value. This value gives the position in the color gradient defined using `min_color_scheme_value`, `max_color_scheme_value` and `colors`.
+ min_color_scheme_value
+ The value of the color_scheme function to be mapped to the first color in `colors`. Lower values also result in the first color of the gradient.
+ max_color_scheme_value
+ The value of the color_scheme function to be mapped to the last color in `colors`. Higher values also result in the last color of the gradient.
+ colors
+ The colors defining the color gradient of the vector field.
+ kwargs
+ Additional arguments to be passed to the :class:`~.VGroup` constructor
+
+ """
+
+ def __init__(
+ self,
+ func: Callable[[np.ndarray], np.ndarray],
+ color: ParsableManimColor | None = None,
+ color_scheme: Callable[[np.ndarray], float] | None = None,
+ min_color_scheme_value: float = 0,
+ max_color_scheme_value: float = 2,
+ colors: Sequence[ParsableManimColor] = DEFAULT_SCALAR_FIELD_COLORS,
+ **kwargs,
+ ):
+ super().__init__(**kwargs)
+ self.func = func
+ if color is None:
+ self.single_color = False
+ if color_scheme is None:
+
+ def color_scheme(p):
+ return np.linalg.norm(p)
+
+ self.color_scheme = color_scheme # TODO maybe other default for direction?
+ self.rgbs = np.array(list(map(color_to_rgb, colors)))
+
+ def pos_to_rgb(pos: np.ndarray) -> tuple[float, float, float, float]:
+ vec = self.func(pos)
+ color_value = np.clip(
+ self.color_scheme(vec),
+ min_color_scheme_value,
+ max_color_scheme_value,
+ )
+ alpha = inverse_interpolate(
+ min_color_scheme_value,
+ max_color_scheme_value,
+ color_value,
+ )
+ alpha *= len(self.rgbs) - 1
+ c1 = self.rgbs[int(alpha)]
+ c2 = self.rgbs[min(int(alpha + 1), len(self.rgbs) - 1)]
+ alpha %= 1
+ return interpolate(c1, c2, alpha)
+
+ self.pos_to_rgb = pos_to_rgb
+ self.pos_to_color = lambda pos: rgb_to_color(self.pos_to_rgb(pos))
+ else:
+ self.single_color = True
+ self.color = ManimColor.parse(color)
+ self.submob_movement_updater = None
+
+ @staticmethod
+ def shift_func(
+ func: Callable[[np.ndarray], np.ndarray],
+ shift_vector: np.ndarray,
+ ) -> Callable[[np.ndarray], np.ndarray]:
+ """Shift a vector field function.
+
+ Parameters
+ ----------
+ func
+ The function defining a vector field.
+ shift_vector
+ The shift to be applied to the vector field.
+
+ Returns
+ -------
+ `Callable[[np.ndarray], np.ndarray]`
+ The shifted vector field function.
+
+ """
+ return lambda p: func(p - shift_vector)
+
+ @staticmethod
+ def scale_func(
+ func: Callable[[np.ndarray], np.ndarray],
+ scalar: float,
+ ) -> Callable[[np.ndarray], np.ndarray]:
+ """Scale a vector field function.
+
+ Parameters
+ ----------
+ func
+ The function defining a vector field.
+ scalar
+ The scalar to be applied to the vector field.
+
+ Examples
+ --------
+ .. manim:: ScaleVectorFieldFunction
+
+ class ScaleVectorFieldFunction(Scene):
+ def construct(self):
+ func = lambda pos: np.sin(pos[1]) * RIGHT + np.cos(pos[0]) * UP
+ vector_field = ArrowVectorField(func)
+ self.add(vector_field)
+ self.wait()
+
+ func = VectorField.scale_func(func, 0.5)
+ self.play(vector_field.animate.become(ArrowVectorField(func)))
+ self.wait()
+
+ Returns
+ -------
+ `Callable[[np.ndarray], np.ndarray]`
+ The scaled vector field function.
+
+ """
+ return lambda p: func(p * scalar)
+
+ def fit_to_coordinate_system(self, coordinate_system: CoordinateSystem):
+ """Scale the vector field to fit a coordinate system.
+
+ This method is useful when the vector field is defined in a coordinate system
+ different from the one used to display the vector field.
+
+ This method can only be used once because it transforms the origin of each vector.
+
+ Parameters
+ ----------
+ coordinate_system
+ The coordinate system to fit the vector field to.
+
+ """
+ self.apply_function(lambda pos: coordinate_system.coords_to_point(*pos))
+
+ def nudge(
+ self,
+ mob: Mobject,
+ dt: float = 1,
+ substeps: int = 1,
+ pointwise: bool = False,
+ ) -> VectorField:
+ """Nudge a :class:`~.Mobject` along the vector field.
+
+ Parameters
+ ----------
+ mob
+ The mobject to move along the vector field
+ dt
+ A scalar to the amount the mobject is moved along the vector field.
+ The actual distance is based on the magnitude of the vector field.
+ substeps
+ The amount of steps the whole nudge is divided into. Higher values
+ give more accurate approximations.
+ pointwise
+ Whether to move the mobject along the vector field. If `False` the
+ vector field takes effect on the center of the given
+ :class:`~.Mobject`. If `True` the vector field takes effect on the
+ points of the individual points of the :class:`~.Mobject`,
+ potentially distorting it.
+
+ Returns
+ -------
+ VectorField
+ This vector field.
+
+ Examples
+ --------
+
+ .. manim:: Nudging
+
+ class Nudging(Scene):
+ def construct(self):
+ func = lambda pos: np.sin(pos[1] / 2) * RIGHT + np.cos(pos[0] / 2) * UP
+ vector_field = ArrowVectorField(
+ func, x_range=[-7, 7, 1], y_range=[-4, 4, 1], length_func=lambda x: x / 2
+ )
+ self.add(vector_field)
+ circle = Circle(radius=2).shift(LEFT)
+ self.add(circle.copy().set_color(GRAY))
+ dot = Dot().move_to(circle)
+
+ vector_field.nudge(circle, -2, 60, True)
+ vector_field.nudge(dot, -2, 60)
+
+ circle.add_updater(vector_field.get_nudge_updater(pointwise=True))
+ dot.add_updater(vector_field.get_nudge_updater())
+ self.add(circle, dot)
+ self.wait(6)
+
+ """
+
+ def runge_kutta(self, p: Sequence[float], step_size: float) -> float:
+ """Returns the change in position of a point along a vector field.
+ Parameters
+ ----------
+ p
+ The position of each point being moved along the vector field.
+ step_size
+ A scalar that is used to determine how much a point is shifted in a single step.
+
+ Returns
+ -------
+ float
+ How much the point is shifted.
+ """
+ k_1 = self.func(p)
+ k_2 = self.func(p + step_size * (k_1 * 0.5))
+ k_3 = self.func(p + step_size * (k_2 * 0.5))
+ k_4 = self.func(p + step_size * k_3)
+ return step_size / 6.0 * (k_1 + 2.0 * k_2 + 2.0 * k_3 + k_4)
+
+ step_size = dt / substeps
+ for _ in range(substeps):
+ if pointwise:
+ mob.apply_function(lambda p: p + runge_kutta(self, p, step_size))
+ else:
+ mob.shift(runge_kutta(self, mob.get_center(), step_size))
+ return self
+
+ def nudge_submobjects(
+ self,
+ dt: float = 1,
+ substeps: int = 1,
+ pointwise: bool = False,
+ ) -> VectorField:
+ """Apply a nudge along the vector field to all submobjects.
+
+ Parameters
+ ----------
+ dt
+ A scalar to the amount the mobject is moved along the vector field.
+ The actual distance is based on the magnitude of the vector field.
+ substeps
+ The amount of steps the whole nudge is divided into. Higher values
+ give more accurate approximations.
+ pointwise
+ Whether to move the mobject along the vector field. See :meth:`nudge` for details.
+
+ Returns
+ -------
+ VectorField
+ This vector field.
+
+ """
+ for mob in self.submobjects:
+ self.nudge(mob, dt, substeps, pointwise)
+ return self
+
+ def get_nudge_updater(
+ self,
+ speed: float = 1,
+ pointwise: bool = False,
+ ) -> Callable[[Mobject, float], Mobject]:
+ """Get an update function to move a :class:`~.Mobject` along the vector field.
+
+ When used with :meth:`~.Mobject.add_updater`, the mobject will move along the vector field, where its speed is determined by the magnitude of the vector field.
+
+ Parameters
+ ----------
+ speed
+ At `speed=1` the distance a mobject moves per second is equal to the magnitude of the vector field along its path. The speed value scales the speed of such a mobject.
+ pointwise
+ Whether to move the mobject along the vector field. See :meth:`nudge` for details.
+
+ Returns
+ -------
+ Callable[[Mobject, float], Mobject]
+ The update function.
+ """
+ return lambda mob, dt: self.nudge(mob, dt * speed, pointwise=pointwise)
+
+ def start_submobject_movement(
+ self,
+ speed: float = 1,
+ pointwise: bool = False,
+ ) -> VectorField:
+ """Start continuously moving all submobjects along the vector field.
+
+ Calling this method multiple times will result in removing the previous updater created by this method.
+
+ Parameters
+ ----------
+ speed
+ The speed at which to move the submobjects. See :meth:`get_nudge_updater` for details.
+ pointwise
+ Whether to move the mobject along the vector field. See :meth:`nudge` for details.
+
+ Returns
+ -------
+ VectorField
+ This vector field.
+
+ """
+
+ self.stop_submobject_movement()
+ self.submob_movement_updater = lambda mob, dt: mob.nudge_submobjects(
+ dt * speed,
+ pointwise=pointwise,
+ )
+ self.add_updater(self.submob_movement_updater)
+ return self
+
+ def stop_submobject_movement(self) -> VectorField:
+ """Stops the continuous movement started using :meth:`start_submobject_movement`.
+
+ Returns
+ -------
+ VectorField
+ This vector field.
+ """
+ self.remove_updater(self.submob_movement_updater)
+ self.submob_movement_updater = None
+ return self
+
+ def get_colored_background_image(self, sampling_rate: int = 5) -> Image.Image:
+ """Generate an image that displays the vector field.
+
+ The color at each position is calculated by passing the positing through a
+ series of steps:
+ Calculate the vector field function at that position, map that vector to a
+ single value using `self.color_scheme` and finally generate a color from
+ that value using the color gradient.
+
+ Parameters
+ ----------
+ sampling_rate
+ The stepsize at which pixels get included in the image. Lower values give
+ more accurate results, but may take a long time to compute.
+
+ Returns
+ -------
+ Image.Imgae
+ The vector field image.
+ """
+ if self.single_color:
+ raise ValueError(
+ "There is no point in generating an image if the vector field uses a single color.",
+ )
+ ph = int(config["pixel_height"] / sampling_rate)
+ pw = int(config["pixel_width"] / sampling_rate)
+ fw = config["frame_width"]
+ fh = config["frame_height"]
+ points_array = np.zeros((ph, pw, 3))
+ x_array = np.linspace(-fw / 2, fw / 2, pw)
+ y_array = np.linspace(fh / 2, -fh / 2, ph)
+ x_array = x_array.reshape((1, len(x_array)))
+ y_array = y_array.reshape((len(y_array), 1))
+ x_array = x_array.repeat(ph, axis=0)
+ y_array.repeat(pw, axis=1) # TODO why not y_array = y_array.repeat(...)?
+ points_array[:, :, 0] = x_array
+ points_array[:, :, 1] = y_array
+ rgbs = np.apply_along_axis(self.pos_to_rgb, 2, points_array)
+ return Image.fromarray((rgbs * 255).astype("uint8"))
+
+ def get_vectorized_rgba_gradient_function(
+ self,
+ start: float,
+ end: float,
+ colors: Iterable[ParsableManimColor],
+ ):
+ """
+ Generates a gradient of rgbas as a numpy array
+
+ Parameters
+ ----------
+ start
+ start value used for inverse interpolation at :func:`~.inverse_interpolate`
+ end
+ end value used for inverse interpolation at :func:`~.inverse_interpolate`
+ colors
+ list of colors to generate the gradient
+
+ Returns
+ -------
+ function to generate the gradients as numpy arrays representing rgba values
+ """
+ rgbs = np.array([color_to_rgb(c) for c in colors])
+
+ def func(values, opacity=1):
+ alphas = inverse_interpolate(start, end, np.array(values))
+ alphas = np.clip(alphas, 0, 1)
+ scaled_alphas = alphas * (len(rgbs) - 1)
+ indices = scaled_alphas.astype(int)
+ next_indices = np.clip(indices + 1, 0, len(rgbs) - 1)
+ inter_alphas = scaled_alphas % 1
+ inter_alphas = inter_alphas.repeat(3).reshape((len(indices), 3))
+ result = interpolate(rgbs[indices], rgbs[next_indices], inter_alphas)
+ result = np.concatenate(
+ (result, np.full([len(result), 1], opacity)),
+ axis=1,
+ )
+ return result
+
+ return func
+
+
+class ArrowVectorField(VectorField):
+ """A :class:`VectorField` represented by a set of change vectors.
+
+ Vector fields are always based on a function defining the :class:`~.Vector` at every position.
+ The values of this functions is displayed as a grid of vectors.
+ By default the color of each vector is determined by it's magnitude.
+ Other color schemes can be used however.
+
+ Parameters
+ ----------
+ func
+ The function defining the rate of change at every position of the vector field.
+ color
+ The color of the vector field. If set, position-specific coloring is disabled.
+ color_scheme
+ A function mapping a vector to a single value. This value gives the position in the color gradient defined using `min_color_scheme_value`, `max_color_scheme_value` and `colors`.
+ min_color_scheme_value
+ The value of the color_scheme function to be mapped to the first color in `colors`. Lower values also result in the first color of the gradient.
+ max_color_scheme_value
+ The value of the color_scheme function to be mapped to the last color in `colors`. Higher values also result in the last color of the gradient.
+ colors
+ The colors defining the color gradient of the vector field.
+ x_range
+ A sequence of x_min, x_max, delta_x
+ y_range
+ A sequence of y_min, y_max, delta_y
+ z_range
+ A sequence of z_min, z_max, delta_z
+ three_dimensions
+ Enables three_dimensions. Default set to False, automatically turns True if
+ z_range is not None.
+ length_func
+ The function determining the displayed size of the vectors. The actual size
+ of the vector is passed, the returned value will be used as display size for the
+ vector. By default this is used to cap the displayed size of vectors to reduce the clutter.
+ opacity
+ The opacity of the arrows.
+ vector_config
+ Additional arguments to be passed to the :class:`~.Vector` constructor
+ kwargs
+ Additional arguments to be passed to the :class:`~.VGroup` constructor
+
+ Examples
+ --------
+
+ .. manim:: BasicUsage
+ :save_last_frame:
+
+ class BasicUsage(Scene):
+ def construct(self):
+ func = lambda pos: ((pos[0] * UR + pos[1] * LEFT) - pos) / 3
+ self.add(ArrowVectorField(func))
+
+ .. manim:: SizingAndSpacing
+
+ class SizingAndSpacing(Scene):
+ def construct(self):
+ func = lambda pos: np.sin(pos[0] / 2) * UR + np.cos(pos[1] / 2) * LEFT
+ vf = ArrowVectorField(func, x_range=[-7, 7, 1])
+ self.add(vf)
+ self.wait()
+
+ length_func = lambda x: x / 3
+ vf2 = ArrowVectorField(func, x_range=[-7, 7, 1], length_func=length_func)
+ self.play(vf.animate.become(vf2))
+ self.wait()
+
+ .. manim:: Coloring
+ :save_last_frame:
+
+ class Coloring(Scene):
+ def construct(self):
+ func = lambda pos: pos - LEFT * 5
+ colors = [RED, YELLOW, BLUE, DARK_GRAY]
+ min_radius = Circle(radius=2, color=colors[0]).shift(LEFT * 5)
+ max_radius = Circle(radius=10, color=colors[-1]).shift(LEFT * 5)
+ vf = ArrowVectorField(
+ func, min_color_scheme_value=2, max_color_scheme_value=10, colors=colors
+ )
+ self.add(vf, min_radius, max_radius)
+
+ """
+
+ def __init__(
+ self,
+ func: Callable[[np.ndarray], np.ndarray],
+ color: ParsableManimColor | None = None,
+ color_scheme: Callable[[np.ndarray], float] | None = None,
+ min_color_scheme_value: float = 0,
+ max_color_scheme_value: float = 2,
+ colors: Sequence[ParsableManimColor] = DEFAULT_SCALAR_FIELD_COLORS,
+ # Determining Vector positions:
+ x_range: Sequence[float] = None,
+ y_range: Sequence[float] = None,
+ z_range: Sequence[float] = None,
+ three_dimensions: bool = False, # Automatically True if z_range is set
+ # Takes in actual norm, spits out displayed norm
+ length_func: Callable[[float], float] = lambda norm: 0.45 * sigmoid(norm),
+ opacity: float = 1.0,
+ vector_config: dict | None = None,
+ **kwargs,
+ ):
+ self.x_range = x_range or [
+ floor(-config["frame_width"] / 2),
+ ceil(config["frame_width"] / 2),
+ ]
+ self.y_range = y_range or [
+ floor(-config["frame_height"] / 2),
+ ceil(config["frame_height"] / 2),
+ ]
+ self.ranges = [self.x_range, self.y_range]
+
+ if three_dimensions or z_range:
+ self.z_range = z_range or self.y_range.copy()
+ self.ranges += [self.z_range]
+ else:
+ self.ranges += [[0, 0]]
+
+ for i in range(len(self.ranges)):
+ if len(self.ranges[i]) == 2:
+ self.ranges[i] += [0.5]
+ self.ranges[i][1] += self.ranges[i][2]
+
+ self.x_range, self.y_range, self.z_range = self.ranges
+
+ super().__init__(
+ func,
+ color,
+ color_scheme,
+ min_color_scheme_value,
+ max_color_scheme_value,
+ colors,
+ **kwargs,
+ )
+
+ self.length_func = length_func
+ self.opacity = opacity
+ if vector_config is None:
+ vector_config = {}
+ self.vector_config = vector_config
+ self.func = func
+
+ x_range = np.arange(*self.x_range)
+ y_range = np.arange(*self.y_range)
+ z_range = np.arange(*self.z_range)
+ self.add(
+ *[
+ self.get_vector(x * RIGHT + y * UP + z * OUT)
+ for x, y, z in it.product(x_range, y_range, z_range)
+ ]
+ )
+ self.set_opacity(self.opacity)
+
+ def get_vector(self, point: np.ndarray):
+ """Creates a vector in the vector field.
+
+ The created vector is based on the function of the vector field and is
+ rooted in the given point. Color and length fit the specifications of
+ this vector field.
+
+ Parameters
+ ----------
+ point
+ The root point of the vector.
+
+ """
+ output = np.array(self.func(point))
+ norm = np.linalg.norm(output)
+ if norm != 0:
+ output *= self.length_func(norm) / norm
+ vect = Vector(output, **self.vector_config)
+ vect.shift(point)
+ if self.single_color:
+ vect.set_color(self.color)
+ else:
+ vect.set_color(self.pos_to_color(point))
+ return vect
+
+
+class StreamLines(VectorField):
+ """StreamLines represent the flow of a :class:`VectorField` using the trace of moving agents.
+
+ Vector fields are always based on a function defining the vector at every position.
+ The values of this functions is displayed by moving many agents along the vector field
+ and showing their trace.
+
+ Parameters
+ ----------
+ func
+ The function defining the rate of change at every position of the vector field.
+ color
+ The color of the vector field. If set, position-specific coloring is disabled.
+ color_scheme
+ A function mapping a vector to a single value. This value gives the position in the color gradient defined using `min_color_scheme_value`, `max_color_scheme_value` and `colors`.
+ min_color_scheme_value
+ The value of the color_scheme function to be mapped to the first color in `colors`. Lower values also result in the first color of the gradient.
+ max_color_scheme_value
+ The value of the color_scheme function to be mapped to the last color in `colors`. Higher values also result in the last color of the gradient.
+ colors
+ The colors defining the color gradient of the vector field.
+ x_range
+ A sequence of x_min, x_max, delta_x
+ y_range
+ A sequence of y_min, y_max, delta_y
+ z_range
+ A sequence of z_min, z_max, delta_z
+ three_dimensions
+ Enables three_dimensions. Default set to False, automatically turns True if
+ z_range is not None.
+ noise_factor
+ The amount by which the starting position of each agent is altered along each axis. Defaults to :code:`delta_y / 2` if not defined.
+ n_repeats
+ The number of agents generated at each starting point.
+ dt
+ The factor by which the distance an agent moves per step is stretched. Lower values result in a better approximation of the trajectories in the vector field.
+ virtual_time
+ The time the agents get to move in the vector field. Higher values therefore result in longer stream lines. However, this whole time gets simulated upon creation.
+ max_anchors_per_line
+ The maximum number of anchors per line. Lines with more anchors get reduced in complexity, not in length.
+ padding
+ The distance agents can move out of the generation area before being terminated.
+ stroke_width
+ The stroke with of the stream lines.
+ opacity
+ The opacity of the stream lines.
+
+ Examples
+ --------
+
+ .. manim:: BasicUsage
+ :save_last_frame:
+
+ class BasicUsage(Scene):
+ def construct(self):
+ func = lambda pos: ((pos[0] * UR + pos[1] * LEFT) - pos) / 3
+ self.add(StreamLines(func))
+
+ .. manim:: SpawningAndFlowingArea
+ :save_last_frame:
+
+ class SpawningAndFlowingArea(Scene):
+ def construct(self):
+ func = lambda pos: np.sin(pos[0]) * UR + np.cos(pos[1]) * LEFT + pos / 5
+ stream_lines = StreamLines(
+ func, x_range=[-3, 3, 0.2], y_range=[-2, 2, 0.2], padding=1
+ )
+
+ spawning_area = Rectangle(width=6, height=4)
+ flowing_area = Rectangle(width=8, height=6)
+ labels = [Tex("Spawning Area"), Tex("Flowing Area").shift(DOWN * 2.5)]
+ for lbl in labels:
+ lbl.add_background_rectangle(opacity=0.6, buff=0.05)
+
+ self.add(stream_lines, spawning_area, flowing_area, *labels)
+
+ """
+
+ def __init__(
+ self,
+ func: Callable[[np.ndarray], np.ndarray],
+ color: ParsableManimColor | None = None,
+ color_scheme: Callable[[np.ndarray], float] | None = None,
+ min_color_scheme_value: float = 0,
+ max_color_scheme_value: float = 2,
+ colors: Sequence[ParsableManimColor] = DEFAULT_SCALAR_FIELD_COLORS,
+ # Determining stream line starting positions:
+ x_range: Sequence[float] = None,
+ y_range: Sequence[float] = None,
+ z_range: Sequence[float] = None,
+ three_dimensions: bool = False,
+ noise_factor: float | None = None,
+ n_repeats=1,
+ # Determining how lines are drawn
+ dt=0.05,
+ virtual_time=3,
+ max_anchors_per_line=100,
+ padding=3,
+ # Determining stream line appearance:
+ stroke_width=1,
+ opacity=1,
+ **kwargs,
+ ):
+ self.x_range = x_range or [
+ floor(-config["frame_width"] / 2),
+ ceil(config["frame_width"] / 2),
+ ]
+ self.y_range = y_range or [
+ floor(-config["frame_height"] / 2),
+ ceil(config["frame_height"] / 2),
+ ]
+ self.ranges = [self.x_range, self.y_range]
+
+ if three_dimensions or z_range:
+ self.z_range = z_range or self.y_range.copy()
+ self.ranges += [self.z_range]
+ else:
+ self.ranges += [[0, 0]]
+
+ for i in range(len(self.ranges)):
+ if len(self.ranges[i]) == 2:
+ self.ranges[i] += [0.5]
+ self.ranges[i][1] += self.ranges[i][2]
+
+ self.x_range, self.y_range, self.z_range = self.ranges
+
+ super().__init__(
+ func,
+ color,
+ color_scheme,
+ min_color_scheme_value,
+ max_color_scheme_value,
+ colors,
+ **kwargs,
+ )
+
+ self.noise_factor = (
+ noise_factor if noise_factor is not None else self.y_range[2] / 2
+ )
+ self.n_repeats = n_repeats
+ self.virtual_time = virtual_time
+ self.max_anchors_per_line = max_anchors_per_line
+ self.padding = padding
+ self.stroke_width = stroke_width
+
+ half_noise = self.noise_factor / 2
+ np.random.seed(0)
+ start_points = np.array(
+ [
+ (x - half_noise) * RIGHT
+ + (y - half_noise) * UP
+ + (z - half_noise) * OUT
+ + self.noise_factor * np.random.random(3)
+ for n in range(self.n_repeats)
+ for x in np.arange(*self.x_range)
+ for y in np.arange(*self.y_range)
+ for z in np.arange(*self.z_range)
+ ],
+ )
+
+ def outside_box(p):
+ return (
+ p[0] < self.x_range[0] - self.padding
+ or p[0] > self.x_range[1] + self.padding - self.x_range[2]
+ or p[1] < self.y_range[0] - self.padding
+ or p[1] > self.y_range[1] + self.padding - self.y_range[2]
+ or p[2] < self.z_range[0] - self.padding
+ or p[2] > self.z_range[1] + self.padding - self.z_range[2]
+ )
+
+ max_steps = ceil(virtual_time / dt) + 1
+ if not self.single_color:
+ self.background_img = self.get_colored_background_image()
+ if config["renderer"] == RendererType.OPENGL:
+ self.values_to_rgbas = self.get_vectorized_rgba_gradient_function(
+ min_color_scheme_value,
+ max_color_scheme_value,
+ colors,
+ )
+ for point in start_points:
+ points = [point]
+ for _ in range(max_steps):
+ last_point = points[-1]
+ new_point = last_point + dt * func(last_point)
+ if outside_box(new_point):
+ break
+ points.append(new_point)
+ step = max_steps
+ if not step:
+ continue
+ line = get_vectorized_mobject_class()()
+ line.duration = step * dt
+ step = max(1, int(len(points) / self.max_anchors_per_line))
+ line.set_points_smoothly(points[::step])
+ if self.single_color:
+ line.set_stroke(self.color)
+ else:
+ if config.renderer == RendererType.OPENGL:
+ # scaled for compatibility with cairo
+ line.set_stroke(width=self.stroke_width / 4.0)
+ norms = np.array(
+ [np.linalg.norm(self.func(point)) for point in line.points],
+ )
+ line.set_rgba_array_direct(
+ self.values_to_rgbas(norms, opacity),
+ name="stroke_rgba",
+ )
+ else:
+ if np.any(self.z_range != np.array([0, 0.5, 0.5])):
+ line.set_stroke(
+ [self.pos_to_color(p) for p in line.get_anchors()],
+ )
+ else:
+ line.color_using_background_image(self.background_img)
+ line.set_stroke(width=self.stroke_width, opacity=opacity)
+ self.add(line)
+ self.stream_lines = [*self.submobjects]
+
+ def create(
+ self,
+ lag_ratio: float | None = None,
+ run_time: Callable[[float], float] | None = None,
+ **kwargs,
+ ) -> AnimationGroup:
+ """The creation animation of the stream lines.
+
+ The stream lines appear in random order.
+
+ Parameters
+ ----------
+ lag_ratio
+ The lag ratio of the animation.
+ If undefined, it will be selected so that the total animation length is 1.5 times the run time of each stream line creation.
+ run_time
+ The run time of every single stream line creation. The runtime of the whole animation might be longer due to the `lag_ratio`.
+ If undefined, the virtual time of the stream lines is used as run time.
+
+ Returns
+ -------
+ :class:`~.AnimationGroup`
+ The creation animation of the stream lines.
+
+ Examples
+ --------
+
+ .. manim:: StreamLineCreation
+
+ class StreamLineCreation(Scene):
+ def construct(self):
+ func = lambda pos: (pos[0] * UR + pos[1] * LEFT) - pos
+ stream_lines = StreamLines(
+ func,
+ color=YELLOW,
+ x_range=[-7, 7, 1],
+ y_range=[-4, 4, 1],
+ stroke_width=3,
+ virtual_time=1, # use shorter lines
+ max_anchors_per_line=5, # better performance with fewer anchors
+ )
+ self.play(stream_lines.create()) # uses virtual_time as run_time
+ self.wait()
+
+ """
+ if run_time is None:
+ run_time = self.virtual_time
+ if lag_ratio is None:
+ lag_ratio = run_time / 2 / len(self.submobjects)
+
+ animations = [
+ Create(line, run_time=run_time, **kwargs) for line in self.stream_lines
+ ]
+ random.shuffle(animations)
+ return AnimationGroup(*animations, lag_ratio=lag_ratio)
+
+ def start_animation(
+ self,
+ warm_up: bool = True,
+ flow_speed: float = 1,
+ time_width: float = 0.3,
+ rate_func: Callable[[float], float] = linear,
+ line_animation_class: type[ShowPassingFlash] = ShowPassingFlash,
+ **kwargs,
+ ) -> None:
+ """Animates the stream lines using an updater.
+
+ The stream lines will continuously flow
+
+ Parameters
+ ----------
+ warm_up
+ If `True` the animation is initialized line by line. Otherwise it starts with all lines shown.
+ flow_speed
+ At `flow_speed=1` the distance the flow moves per second is equal to the magnitude of the vector field along its path. The speed value scales the speed of this flow.
+ time_width
+ The proportion of the stream line shown while being animated
+ rate_func
+ The rate function of each stream line flashing
+ line_animation_class
+ The animation class being used
+
+ Examples
+ --------
+
+ .. manim:: ContinuousMotion
+
+ class ContinuousMotion(Scene):
+ def construct(self):
+ func = lambda pos: np.sin(pos[0] / 2) * UR + np.cos(pos[1] / 2) * LEFT
+ stream_lines = StreamLines(func, stroke_width=3, max_anchors_per_line=30)
+ self.add(stream_lines)
+ stream_lines.start_animation(warm_up=False, flow_speed=1.5)
+ self.wait(stream_lines.virtual_time / stream_lines.flow_speed)
+
+ """
+
+ for line in self.stream_lines:
+ run_time = line.duration / flow_speed
+ line.anim = line_animation_class(
+ line,
+ run_time=run_time,
+ rate_func=rate_func,
+ time_width=time_width,
+ **kwargs,
+ )
+ line.anim.begin()
+ line.time = random.random() * self.virtual_time
+ if warm_up:
+ line.time *= -1
+ self.add(line.anim.mobject)
+
+ def updater(mob, dt):
+ for line in mob.stream_lines:
+ line.time += dt * flow_speed
+ if line.time >= self.virtual_time:
+ line.time -= self.virtual_time
+ line.anim.interpolate(np.clip(line.time / line.anim.run_time, 0, 1))
+
+ self.add_updater(updater)
+ self.flow_animation = updater
+ self.flow_speed = flow_speed
+ self.time_width = time_width
+
+ def end_animation(self) -> AnimationGroup:
+ """End the stream line animation smoothly.
+
+ Returns an animation resulting in fully displayed stream lines without a noticeable cut.
+
+ Returns
+ -------
+ :class:`~.AnimationGroup`
+ The animation fading out the running stream animation.
+
+ Raises
+ ------
+ ValueError
+ if no stream line animation is running
+
+ Examples
+ --------
+
+ .. manim:: EndAnimation
+
+ class EndAnimation(Scene):
+ def construct(self):
+ func = lambda pos: np.sin(pos[0] / 2) * UR + np.cos(pos[1] / 2) * LEFT
+ stream_lines = StreamLines(
+ func, stroke_width=3, max_anchors_per_line=5, virtual_time=1, color=BLUE
+ )
+ self.add(stream_lines)
+ stream_lines.start_animation(warm_up=False, flow_speed=1.5, time_width=0.5)
+ self.wait(1)
+ self.play(stream_lines.end_animation())
+
+ """
+
+ if self.flow_animation is None:
+ raise ValueError("You have to start the animation before fading it out.")
+
+ def hide_and_wait(mob, alpha):
+ if alpha == 0:
+ mob.set_stroke(opacity=0)
+ elif alpha == 1:
+ mob.set_stroke(opacity=1)
+
+ def finish_updater_cycle(line, alpha):
+ line.time += dt * self.flow_speed
+ line.anim.interpolate(min(line.time / line.anim.run_time, 1))
+ if alpha == 1:
+ self.remove(line.anim.mobject)
+ line.anim.finish()
+
+ max_run_time = self.virtual_time / self.flow_speed
+ creation_rate_func = ease_out_sine
+ creation_staring_speed = creation_rate_func(0.001) * 1000
+ creation_run_time = (
+ max_run_time / (1 + self.time_width) * creation_staring_speed
+ )
+ # creation_run_time is calculated so that the creation animation starts at the same speed
+ # as the regular line flash animation but eases out.
+
+ dt = 1 / config["frame_rate"]
+ animations = []
+ self.remove_updater(self.flow_animation)
+ self.flow_animation = None
+
+ for line in self.stream_lines:
+ create = Create(
+ line,
+ run_time=creation_run_time,
+ rate_func=creation_rate_func,
+ )
+ if line.time <= 0:
+ animations.append(
+ Succession(
+ UpdateFromAlphaFunc(
+ line,
+ hide_and_wait,
+ run_time=-line.time / self.flow_speed,
+ ),
+ create,
+ ),
+ )
+ self.remove(line.anim.mobject)
+ line.anim.finish()
+ else:
+ remaining_time = max_run_time - line.time / self.flow_speed
+ animations.append(
+ Succession(
+ UpdateFromAlphaFunc(
+ line,
+ finish_updater_cycle,
+ run_time=remaining_time,
+ ),
+ create,
+ ),
+ )
+ return AnimationGroup(*animations)
+
+
+# TODO: Variant of StreamLines that is able to respond to changes in the vector field function
diff --git a/data/rag/manim_docs/manim_core/source/opengl/__init__.py b/data/rag/manim_docs/manim_core/source/opengl/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..83f6a4ccded2ca05cda36b4937aabe6d6e2aa499
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/opengl/__init__.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+try:
+ from dearpygui import dearpygui as dpg
+except ImportError:
+ pass
+
+
+from manim.mobject.opengl.dot_cloud import *
+from manim.mobject.opengl.opengl_image_mobject import *
+from manim.mobject.opengl.opengl_mobject import *
+from manim.mobject.opengl.opengl_point_cloud_mobject import *
+from manim.mobject.opengl.opengl_surface import *
+from manim.mobject.opengl.opengl_three_dimensions import *
+from manim.mobject.opengl.opengl_vectorized_mobject import *
+
+from ..renderer.shader import *
+from ..utils.opengl import *
diff --git a/data/rag/manim_docs/manim_core/source/plugins/__init__.py b/data/rag/manim_docs/manim_core/source/plugins/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a899f63bb85ac8337ab9a99a44e30b65588b6eca
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/plugins/__init__.py
@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from .import_plugins import *
diff --git a/data/rag/manim_docs/manim_core/source/plugins/import_plugins.py b/data/rag/manim_docs/manim_core/source/plugins/import_plugins.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f11accbf9453ddb29b877edf7a5891e898e4649
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/plugins/import_plugins.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import types
+
+import pkg_resources
+
+from .. import config, logger
+
+__all__ = []
+
+
+plugins_requested: list[str] = config["plugins"]
+if "" in plugins_requested:
+ plugins_requested.remove("")
+for plugin in pkg_resources.iter_entry_points("manim.plugins"):
+ if plugin.name not in plugins_requested:
+ continue
+ loaded_plugin = plugin.load()
+ if isinstance(loaded_plugin, types.ModuleType):
+ # it is a module so it can't be called
+ # see if __all__ is defined
+ # if it is defined use that to load all the modules necessary
+ # essentially this would be similar to `from plugin import *``
+ # if not just import the module with the plugin name
+ if hasattr(loaded_plugin, "__all__"):
+ for thing in loaded_plugin.__all__: # type: ignore
+ exec(f"{thing}=loaded_plugin.{thing}")
+ __all__.append(thing)
+ else:
+ exec(f"{plugin.name}=loaded_plugin")
+ __all__.append(plugin.name)
+ elif isinstance(loaded_plugin, types.FunctionType):
+ # call the function first
+ # it will return a list of modules to add globally
+ # finally add it
+ lists = loaded_plugin()
+ for lst in lists:
+ exec(f"{lst.__name__}=lst")
+ __all__.append(lst.__name__)
+ plugins_requested.remove(plugin.name)
+
+if plugins_requested != []:
+ logger.warning("Missing Plugins: %s", plugins_requested)
diff --git a/data/rag/manim_docs/manim_core/source/plugins/plugins_flags.py b/data/rag/manim_docs/manim_core/source/plugins/plugins_flags.py
new file mode 100644
index 0000000000000000000000000000000000000000..a1487e577412ae87836312a390d00dd3144deaab
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/plugins/plugins_flags.py
@@ -0,0 +1,25 @@
+"""Plugin Managing Utility"""
+
+from __future__ import annotations
+
+import pkg_resources
+
+from manim import console
+
+__all__ = ["list_plugins"]
+
+
+def get_plugins():
+ plugins = {
+ entry_point.name: entry_point.load()
+ for entry_point in pkg_resources.iter_entry_points("manim.plugins")
+ }
+ return plugins
+
+
+def list_plugins():
+ console.print("[green bold]Plugins:[/green bold]", justify="left")
+
+ plugins = get_plugins()
+ for plugin in plugins:
+ console.print(f" • {plugin}")
diff --git a/data/rag/manim_docs/manim_core/source/renderer/__init__.py b/data/rag/manim_docs/manim_core/source/renderer/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/data/rag/manim_docs/manim_core/source/renderer/cairo_renderer.py b/data/rag/manim_docs/manim_core/source/renderer/cairo_renderer.py
new file mode 100644
index 0000000000000000000000000000000000000000..f11b7ea7ca692a5efd7f8c65ac3c7b6fe7e5da04
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/cairo_renderer.py
@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import typing
+from typing import Any
+
+import numpy as np
+
+from manim.utils.hashing import get_hash_from_play_call
+
+from .. import config, logger
+from ..camera.camera import Camera
+from ..mobject.mobject import Mobject
+from ..scene.scene_file_writer import SceneFileWriter
+from ..utils.exceptions import EndSceneEarlyException
+from ..utils.iterables import list_update
+
+if typing.TYPE_CHECKING:
+ from manim.scene.scene import Scene
+
+
+class CairoRenderer:
+ """A renderer using Cairo.
+
+ num_plays : Number of play() functions in the scene.
+ time: time elapsed since initialisation of scene.
+ """
+
+ def __init__(
+ self,
+ file_writer_class=SceneFileWriter,
+ camera_class=None,
+ skip_animations=False,
+ **kwargs,
+ ):
+ # All of the following are set to EITHER the value passed via kwargs,
+ # OR the value stored in the global config dict at the time of
+ # _instance construction_.
+ self._file_writer_class = file_writer_class
+ camera_cls = camera_class if camera_class is not None else Camera
+ self.camera = camera_cls()
+ self._original_skipping_status = skip_animations
+ self.skip_animations = skip_animations
+ self.animations_hashes = []
+ self.num_plays = 0
+ self.time = 0
+ self.static_image = None
+
+ def init_scene(self, scene):
+ self.file_writer: Any = self._file_writer_class(
+ self,
+ scene.__class__.__name__,
+ )
+
+ def play(self, scene, *args, **kwargs):
+ # Reset skip_animations to the original state.
+ # Needed when rendering only some animations, and skipping others.
+ self.skip_animations = self._original_skipping_status
+ self.update_skipping_status()
+
+ scene.compile_animation_data(*args, **kwargs)
+
+ if self.skip_animations:
+ logger.debug(f"Skipping animation {self.num_plays}")
+ hash_current_animation = None
+ self.time += scene.duration
+ else:
+ if config["disable_caching"]:
+ logger.info("Caching disabled.")
+ hash_current_animation = f"uncached_{self.num_plays:05}"
+ else:
+ hash_current_animation = get_hash_from_play_call(
+ scene,
+ self.camera,
+ scene.animations,
+ scene.mobjects,
+ )
+ if self.file_writer.is_already_cached(hash_current_animation):
+ logger.info(
+ f"Animation {self.num_plays} : Using cached data (hash : %(hash_current_animation)s)",
+ {"hash_current_animation": hash_current_animation},
+ )
+ self.skip_animations = True
+ self.time += scene.duration
+ # adding None as a partial movie file will make file_writer ignore the latter.
+ self.file_writer.add_partial_movie_file(hash_current_animation)
+ self.animations_hashes.append(hash_current_animation)
+ logger.debug(
+ "List of the first few animation hashes of the scene: %(h)s",
+ {"h": str(self.animations_hashes[:5])},
+ )
+
+ self.file_writer.begin_animation(not self.skip_animations)
+ scene.begin_animations()
+
+ # Save a static image, to avoid rendering non moving objects.
+ self.save_static_frame_data(scene, scene.static_mobjects)
+
+ if scene.is_current_animation_frozen_frame():
+ self.update_frame(scene, mobjects=scene.moving_mobjects)
+ # self.duration stands for the total run time of all the animations.
+ # In this case, as there is only a wait, it will be the length of the wait.
+ self.freeze_current_frame(scene.duration)
+ else:
+ scene.play_internal()
+ self.file_writer.end_animation(not self.skip_animations)
+
+ self.num_plays += 1
+
+ def update_frame( # TODO Description in Docstring
+ self,
+ scene,
+ mobjects: typing.Iterable[Mobject] | None = None,
+ include_submobjects: bool = True,
+ ignore_skipping: bool = True,
+ **kwargs,
+ ):
+ """Update the frame.
+
+ Parameters
+ ----------
+ scene
+
+ mobjects
+ list of mobjects
+
+ include_submobjects
+
+ ignore_skipping
+
+ **kwargs
+
+ """
+ if self.skip_animations and not ignore_skipping:
+ return
+ if not mobjects:
+ mobjects = list_update(
+ scene.mobjects,
+ scene.foreground_mobjects,
+ )
+ if self.static_image is not None:
+ self.camera.set_frame_to_background(self.static_image)
+ else:
+ self.camera.reset()
+
+ kwargs["include_submobjects"] = include_submobjects
+ self.camera.capture_mobjects(mobjects, **kwargs)
+
+ def render(self, scene, time, moving_mobjects):
+ self.update_frame(scene, moving_mobjects)
+ self.add_frame(self.get_frame())
+
+ def get_frame(self):
+ """
+ Gets the current frame as NumPy array.
+
+ Returns
+ -------
+ np.array
+ NumPy array of pixel values of each pixel in screen.
+ The shape of the array is height x width x 3
+ """
+ return np.array(self.camera.pixel_array)
+
+ def add_frame(self, frame: np.ndarray, num_frames: int = 1):
+ """
+ Adds a frame to the video_file_stream
+
+ Parameters
+ ----------
+ frame
+ The frame to add, as a pixel array.
+ num_frames
+ The number of times to add frame.
+ """
+ dt = 1 / self.camera.frame_rate
+ if self.skip_animations:
+ return
+ self.time += num_frames * dt
+ for _ in range(num_frames):
+ self.file_writer.write_frame(frame)
+
+ def freeze_current_frame(self, duration: float):
+ """Adds a static frame to the movie for a given duration. The static frame is the current frame.
+
+ Parameters
+ ----------
+ duration
+ [description]
+ """
+ dt = 1 / self.camera.frame_rate
+ self.add_frame(
+ self.get_frame(),
+ num_frames=int(duration / dt),
+ )
+
+ def show_frame(self):
+ """
+ Opens the current frame in the Default Image Viewer
+ of your system.
+ """
+ self.update_frame(ignore_skipping=True)
+ self.camera.get_image().show()
+
+ def save_static_frame_data(
+ self,
+ scene: Scene,
+ static_mobjects: typing.Iterable[Mobject],
+ ) -> typing.Iterable[Mobject] | None:
+ """Compute and save the static frame, that will be reused at each frame
+ to avoid unnecessarily computing static mobjects.
+
+ Parameters
+ ----------
+ scene
+ The scene played.
+ static_mobjects
+ Static mobjects of the scene. If None, self.static_image is set to None
+
+ Returns
+ -------
+ typing.Iterable[Mobject]
+ The static image computed.
+ """
+ self.static_image = None
+ if not static_mobjects:
+ return None
+ self.update_frame(scene, mobjects=static_mobjects)
+ self.static_image = self.get_frame()
+ return self.static_image
+
+ def update_skipping_status(self):
+ """
+ This method is used internally to check if the current
+ animation needs to be skipped or not. It also checks if
+ the number of animations that were played correspond to
+ the number of animations that need to be played, and
+ raises an EndSceneEarlyException if they don't correspond.
+ """
+ # there is always at least one section -> no out of bounds here
+ if self.file_writer.sections[-1].skip_animations:
+ self.skip_animations = True
+ if config["save_last_frame"]:
+ self.skip_animations = True
+ if (
+ config["from_animation_number"]
+ and self.num_plays < config["from_animation_number"]
+ ):
+ self.skip_animations = True
+ if (
+ config["upto_animation_number"]
+ and self.num_plays > config["upto_animation_number"]
+ ):
+ self.skip_animations = True
+ raise EndSceneEarlyException()
+
+ def scene_finished(self, scene):
+ # If no animations in scene, render an image instead
+ if self.num_plays:
+ self.file_writer.finish()
+ elif config.write_to_movie:
+ config.save_last_frame = True
+ config.write_to_movie = False
+ else:
+ self.static_image = None
+ self.update_frame(scene)
+
+ if config["save_last_frame"]:
+ self.static_image = None
+ self.update_frame(scene)
+ self.file_writer.save_final_image(self.camera.get_image())
diff --git a/data/rag/manim_docs/manim_core/source/renderer/opengl_renderer.py b/data/rag/manim_docs/manim_core/source/renderer/opengl_renderer.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa0bdbebf4d5879e2a3f782affbf67505cdc8621
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/opengl_renderer.py
@@ -0,0 +1,593 @@
+from __future__ import annotations
+
+import itertools as it
+import sys
+import time
+from typing import Any
+
+if sys.version_info < (3, 8):
+ from backports.cached_property import cached_property
+else:
+ from functools import cached_property
+
+import moderngl
+import numpy as np
+from PIL import Image
+
+from manim import config, logger
+from manim.mobject.opengl.opengl_mobject import OpenGLMobject, OpenGLPoint
+from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVMobject
+from manim.utils.caching import handle_caching_play
+from manim.utils.color import color_to_rgba
+from manim.utils.exceptions import EndSceneEarlyException
+
+from ..constants import *
+from ..scene.scene_file_writer import SceneFileWriter
+from ..utils import opengl
+from ..utils.config_ops import _Data
+from ..utils.simple_functions import clip
+from ..utils.space_ops import (
+ angle_of_vector,
+ quaternion_from_angle_axis,
+ quaternion_mult,
+ rotation_matrix_transpose,
+ rotation_matrix_transpose_from_quaternion,
+)
+from .shader import Mesh, Shader
+from .vectorized_mobject_rendering import (
+ render_opengl_vectorized_mobject_fill,
+ render_opengl_vectorized_mobject_stroke,
+)
+
+
+class OpenGLCamera(OpenGLMobject):
+ euler_angles = _Data()
+
+ def __init__(
+ self,
+ frame_shape=None,
+ center_point=None,
+ # Theta, phi, gamma
+ euler_angles=[0, 0, 0],
+ focal_distance=2,
+ light_source_position=[-10, 10, 10],
+ orthographic=False,
+ minimum_polar_angle=-PI / 2,
+ maximum_polar_angle=PI / 2,
+ model_matrix=None,
+ **kwargs,
+ ):
+ self.use_z_index = True
+ self.frame_rate = 60
+ self.orthographic = orthographic
+ self.minimum_polar_angle = minimum_polar_angle
+ self.maximum_polar_angle = maximum_polar_angle
+ if self.orthographic:
+ self.projection_matrix = opengl.orthographic_projection_matrix()
+ self.unformatted_projection_matrix = opengl.orthographic_projection_matrix(
+ format=False,
+ )
+ else:
+ self.projection_matrix = opengl.perspective_projection_matrix()
+ self.unformatted_projection_matrix = opengl.perspective_projection_matrix(
+ format=False,
+ )
+
+ if frame_shape is None:
+ self.frame_shape = (config["frame_width"], config["frame_height"])
+ else:
+ self.frame_shape = frame_shape
+
+ if center_point is None:
+ self.center_point = ORIGIN
+ else:
+ self.center_point = center_point
+
+ if model_matrix is None:
+ model_matrix = opengl.translation_matrix(0, 0, 11)
+
+ self.focal_distance = focal_distance
+
+ if light_source_position is None:
+ self.light_source_position = [-10, 10, 10]
+ else:
+ self.light_source_position = light_source_position
+ self.light_source = OpenGLPoint(self.light_source_position)
+
+ self.default_model_matrix = model_matrix
+ super().__init__(model_matrix=model_matrix, should_render=False, **kwargs)
+
+ if euler_angles is None:
+ euler_angles = [0, 0, 0]
+ euler_angles = np.array(euler_angles, dtype=float)
+
+ self.euler_angles = euler_angles
+ self.refresh_rotation_matrix()
+
+ def get_position(self):
+ return self.model_matrix[:, 3][:3]
+
+ def set_position(self, position):
+ self.model_matrix[:, 3][:3] = position
+ return self
+
+ @cached_property
+ def formatted_view_matrix(self):
+ return opengl.matrix_to_shader_input(np.linalg.inv(self.model_matrix))
+
+ @cached_property
+ def unformatted_view_matrix(self):
+ return np.linalg.inv(self.model_matrix)
+
+ def init_points(self):
+ self.set_points([ORIGIN, LEFT, RIGHT, DOWN, UP])
+ self.set_width(self.frame_shape[0], stretch=True)
+ self.set_height(self.frame_shape[1], stretch=True)
+ self.move_to(self.center_point)
+
+ def to_default_state(self):
+ self.center()
+ self.set_height(config["frame_height"])
+ self.set_width(config["frame_width"])
+ self.set_euler_angles(0, 0, 0)
+ self.model_matrix = self.default_model_matrix
+ return self
+
+ def refresh_rotation_matrix(self):
+ # Rotate based on camera orientation
+ theta, phi, gamma = self.euler_angles
+ quat = quaternion_mult(
+ quaternion_from_angle_axis(theta, OUT, axis_normalized=True),
+ quaternion_from_angle_axis(phi, RIGHT, axis_normalized=True),
+ quaternion_from_angle_axis(gamma, OUT, axis_normalized=True),
+ )
+ self.inverse_rotation_matrix = rotation_matrix_transpose_from_quaternion(quat)
+
+ def rotate(self, angle, axis=OUT, **kwargs):
+ curr_rot_T = self.inverse_rotation_matrix
+ added_rot_T = rotation_matrix_transpose(angle, axis)
+ new_rot_T = np.dot(curr_rot_T, added_rot_T)
+ Fz = new_rot_T[2]
+ phi = np.arccos(Fz[2])
+ theta = angle_of_vector(Fz[:2]) + PI / 2
+ partial_rot_T = np.dot(
+ rotation_matrix_transpose(phi, RIGHT),
+ rotation_matrix_transpose(theta, OUT),
+ )
+ gamma = angle_of_vector(np.dot(partial_rot_T, new_rot_T.T)[:, 0])
+ self.set_euler_angles(theta, phi, gamma)
+ return self
+
+ def set_euler_angles(self, theta=None, phi=None, gamma=None):
+ if theta is not None:
+ self.euler_angles[0] = theta
+ if phi is not None:
+ self.euler_angles[1] = phi
+ if gamma is not None:
+ self.euler_angles[2] = gamma
+ self.refresh_rotation_matrix()
+ return self
+
+ def set_theta(self, theta):
+ return self.set_euler_angles(theta=theta)
+
+ def set_phi(self, phi):
+ return self.set_euler_angles(phi=phi)
+
+ def set_gamma(self, gamma):
+ return self.set_euler_angles(gamma=gamma)
+
+ def increment_theta(self, dtheta):
+ self.euler_angles[0] += dtheta
+ self.refresh_rotation_matrix()
+ return self
+
+ def increment_phi(self, dphi):
+ phi = self.euler_angles[1]
+ new_phi = clip(phi + dphi, -PI / 2, PI / 2)
+ self.euler_angles[1] = new_phi
+ self.refresh_rotation_matrix()
+ return self
+
+ def increment_gamma(self, dgamma):
+ self.euler_angles[2] += dgamma
+ self.refresh_rotation_matrix()
+ return self
+
+ def get_shape(self):
+ return (self.get_width(), self.get_height())
+
+ def get_center(self):
+ # Assumes first point is at the center
+ return self.points[0]
+
+ def get_width(self):
+ points = self.points
+ return points[2, 0] - points[1, 0]
+
+ def get_height(self):
+ points = self.points
+ return points[4, 1] - points[3, 1]
+
+ def get_focal_distance(self):
+ return self.focal_distance * self.get_height()
+
+ def interpolate(self, *args, **kwargs):
+ super().interpolate(*args, **kwargs)
+ self.refresh_rotation_matrix()
+
+
+points_per_curve = 3
+
+
+class OpenGLRenderer:
+ def __init__(self, file_writer_class=SceneFileWriter, skip_animations=False):
+ # Measured in pixel widths, used for vector graphics
+ self.anti_alias_width = 1.5
+ self._file_writer_class = file_writer_class
+
+ self._original_skipping_status = skip_animations
+ self.skip_animations = skip_animations
+ self.animation_start_time = 0
+ self.animation_elapsed_time = 0
+ self.time = 0
+ self.animations_hashes = []
+ self.num_plays = 0
+
+ self.camera = OpenGLCamera()
+ self.pressed_keys = set()
+
+ # Initialize texture map.
+ self.path_to_texture_id = {}
+
+ self.background_color = config["background_color"]
+
+ def init_scene(self, scene):
+ self.partial_movie_files = []
+ self.file_writer: Any = self._file_writer_class(
+ self,
+ scene.__class__.__name__,
+ )
+ self.scene = scene
+ self.background_color = config["background_color"]
+ if not hasattr(self, "window"):
+ if self.should_create_window():
+ from .opengl_renderer_window import Window
+
+ self.window = Window(self)
+ self.context = self.window.ctx
+ self.frame_buffer_object = self.context.detect_framebuffer()
+ else:
+ self.window = None
+ try:
+ self.context = moderngl.create_context(standalone=True)
+ except Exception:
+ self.context = moderngl.create_context(
+ standalone=True,
+ backend="egl",
+ )
+ self.frame_buffer_object = self.get_frame_buffer_object(self.context, 0)
+ self.frame_buffer_object.use()
+ self.context.enable(moderngl.BLEND)
+ self.context.wireframe = config["enable_wireframe"]
+ self.context.blend_func = (
+ moderngl.SRC_ALPHA,
+ moderngl.ONE_MINUS_SRC_ALPHA,
+ moderngl.ONE,
+ moderngl.ONE,
+ )
+
+ def should_create_window(self):
+ if config["force_window"]:
+ logger.warning(
+ "'--force_window' is enabled, this is intended for debugging purposes "
+ "and may impact performance if used when outputting files",
+ )
+ return True
+ return (
+ config["preview"]
+ and not config["save_last_frame"]
+ and not config["format"]
+ and not config["write_to_movie"]
+ and not config["dry_run"]
+ )
+
+ def get_pixel_shape(self):
+ if hasattr(self, "frame_buffer_object"):
+ return self.frame_buffer_object.viewport[2:4]
+ else:
+ return None
+
+ def refresh_perspective_uniforms(self, camera):
+ pw, ph = self.get_pixel_shape()
+ fw, fh = camera.get_shape()
+ # TODO, this should probably be a mobject uniform, with
+ # the camera taking care of the conversion factor
+ anti_alias_width = self.anti_alias_width / (ph / fh)
+ # Orient light
+ rotation = camera.inverse_rotation_matrix
+ light_pos = camera.light_source.get_location()
+ light_pos = np.dot(rotation, light_pos)
+
+ self.perspective_uniforms = {
+ "frame_shape": camera.get_shape(),
+ "anti_alias_width": anti_alias_width,
+ "camera_center": tuple(camera.get_center()),
+ "camera_rotation": tuple(np.array(rotation).T.flatten()),
+ "light_source_position": tuple(light_pos),
+ "focal_distance": camera.get_focal_distance(),
+ }
+
+ def render_mobject(self, mobject):
+ if isinstance(mobject, OpenGLVMobject):
+ if config["use_projection_fill_shaders"]:
+ render_opengl_vectorized_mobject_fill(self, mobject)
+
+ if config["use_projection_stroke_shaders"]:
+ render_opengl_vectorized_mobject_stroke(self, mobject)
+
+ shader_wrapper_list = mobject.get_shader_wrapper_list()
+
+ # Convert ShaderWrappers to Meshes.
+ for shader_wrapper in shader_wrapper_list:
+ shader = Shader(self.context, shader_wrapper.shader_folder)
+
+ # Set textures.
+ for name, path in shader_wrapper.texture_paths.items():
+ tid = self.get_texture_id(path)
+ shader.shader_program[name].value = tid
+
+ # Set uniforms.
+ for name, value in it.chain(
+ shader_wrapper.uniforms.items(),
+ self.perspective_uniforms.items(),
+ ):
+ try:
+ shader.set_uniform(name, value)
+ except KeyError:
+ pass
+ try:
+ shader.set_uniform(
+ "u_view_matrix", self.scene.camera.formatted_view_matrix
+ )
+ shader.set_uniform(
+ "u_projection_matrix",
+ self.scene.camera.projection_matrix,
+ )
+ except KeyError:
+ pass
+
+ # Set depth test.
+ if shader_wrapper.depth_test:
+ self.context.enable(moderngl.DEPTH_TEST)
+ else:
+ self.context.disable(moderngl.DEPTH_TEST)
+
+ # Render.
+ mesh = Mesh(
+ shader,
+ shader_wrapper.vert_data,
+ indices=shader_wrapper.vert_indices,
+ use_depth_test=shader_wrapper.depth_test,
+ primitive=mobject.render_primitive,
+ )
+ mesh.set_uniforms(self)
+ mesh.render()
+
+ def get_texture_id(self, path):
+ if repr(path) not in self.path_to_texture_id:
+ tid = len(self.path_to_texture_id)
+ texture = self.context.texture(
+ size=path.size,
+ components=len(path.getbands()),
+ data=path.tobytes(),
+ )
+ texture.repeat_x = False
+ texture.repeat_y = False
+ texture.filter = (moderngl.NEAREST, moderngl.NEAREST)
+ texture.swizzle = "RRR1" if path.mode == "L" else "RGBA"
+ texture.use(location=tid)
+ self.path_to_texture_id[repr(path)] = tid
+
+ return self.path_to_texture_id[repr(path)]
+
+ def update_skipping_status(self):
+ """
+ This method is used internally to check if the current
+ animation needs to be skipped or not. It also checks if
+ the number of animations that were played correspond to
+ the number of animations that need to be played, and
+ raises an EndSceneEarlyException if they don't correspond.
+ """
+ # there is always at least one section -> no out of bounds here
+ if self.file_writer.sections[-1].skip_animations:
+ self.skip_animations = True
+ if (
+ config["from_animation_number"]
+ and self.num_plays < config["from_animation_number"]
+ ):
+ self.skip_animations = True
+ if (
+ config["upto_animation_number"]
+ and self.num_plays > config["upto_animation_number"]
+ ):
+ self.skip_animations = True
+ raise EndSceneEarlyException()
+
+ @handle_caching_play
+ def play(self, scene, *args, **kwargs):
+ # TODO: Handle data locking / unlocking.
+ self.animation_start_time = time.time()
+ self.file_writer.begin_animation(not self.skip_animations)
+
+ scene.compile_animation_data(*args, **kwargs)
+ scene.begin_animations()
+ if scene.is_current_animation_frozen_frame():
+ self.update_frame(scene)
+
+ if not self.skip_animations:
+ for _ in range(int(config.frame_rate * scene.duration)):
+ self.file_writer.write_frame(self)
+
+ if self.window is not None:
+ self.window.swap_buffers()
+ while time.time() - self.animation_start_time < scene.duration:
+ pass
+ self.animation_elapsed_time = scene.duration
+
+ else:
+ scene.play_internal()
+
+ self.file_writer.end_animation(not self.skip_animations)
+ self.time += scene.duration
+ self.num_plays += 1
+
+ def clear_screen(self):
+ self.frame_buffer_object.clear(*self.background_color)
+ self.window.swap_buffers()
+
+ def render(self, scene, frame_offset, moving_mobjects):
+ self.update_frame(scene)
+
+ if self.skip_animations:
+ return
+
+ self.file_writer.write_frame(self)
+
+ if self.window is not None:
+ self.window.swap_buffers()
+ while self.animation_elapsed_time < frame_offset:
+ self.update_frame(scene)
+ self.window.swap_buffers()
+
+ def update_frame(self, scene):
+ self.frame_buffer_object.clear(*self.background_color)
+ self.refresh_perspective_uniforms(scene.camera)
+
+ for mobject in scene.mobjects:
+ if not mobject.should_render:
+ continue
+ self.render_mobject(mobject)
+
+ for obj in scene.meshes:
+ for mesh in obj.get_meshes():
+ mesh.set_uniforms(self)
+ mesh.render()
+
+ self.animation_elapsed_time = time.time() - self.animation_start_time
+
+ def scene_finished(self, scene):
+ # When num_plays is 0, no images have been output, so output a single
+ # image in this case
+ if self.num_plays > 0:
+ self.file_writer.finish()
+ elif self.num_plays == 0 and config.write_to_movie:
+ config.write_to_movie = False
+
+ if self.should_save_last_frame():
+ config.save_last_frame = True
+ self.update_frame(scene)
+ self.file_writer.save_final_image(self.get_image())
+
+ def should_save_last_frame(self):
+ if config["save_last_frame"]:
+ return True
+ if self.scene.interactive_mode:
+ return False
+ return self.num_plays == 0
+
+ def get_image(self) -> Image.Image:
+ """Returns an image from the current frame. The first argument passed to image represents
+ the mode RGB with the alpha channel A. The data we read is from the currently bound frame
+ buffer. We pass in 'raw' as the name of the decoder, 0 and -1 args are specifically
+ used for the decoder tand represent the stride and orientation. 0 means there is no
+ padding expected between bytes and -1 represents the orientation and means the first
+ line of the image is the bottom line on the screen.
+
+ Returns
+ -------
+ PIL.Image
+ The PIL image of the array.
+ """
+ raw_buffer_data = self.get_raw_frame_buffer_object_data()
+ image = Image.frombytes(
+ "RGBA",
+ self.get_pixel_shape(),
+ raw_buffer_data,
+ "raw",
+ "RGBA",
+ 0,
+ -1,
+ )
+ return image
+
+ def save_static_frame_data(self, scene, static_mobjects):
+ pass
+
+ def get_frame_buffer_object(self, context, samples=0):
+ pixel_width = config["pixel_width"]
+ pixel_height = config["pixel_height"]
+ num_channels = 4
+ return context.framebuffer(
+ color_attachments=context.texture(
+ (pixel_width, pixel_height),
+ components=num_channels,
+ samples=samples,
+ ),
+ depth_attachment=context.depth_renderbuffer(
+ (pixel_width, pixel_height),
+ samples=samples,
+ ),
+ )
+
+ def get_raw_frame_buffer_object_data(self, dtype="f1"):
+ # Copy blocks from the fbo_msaa to the drawn fbo using Blit
+ # pw, ph = self.get_pixel_shape()
+ # gl.glBindFramebuffer(gl.GL_READ_FRAMEBUFFER, self.fbo_msaa.glo)
+ # gl.glBindFramebuffer(gl.GL_DRAW_FRAMEBUFFER, self.fbo.glo)
+ # gl.glBlitFramebuffer(
+ # 0, 0, pw, ph, 0, 0, pw, ph, gl.GL_COLOR_BUFFER_BIT, gl.GL_LINEAR
+ # )
+ num_channels = 4
+ ret = self.frame_buffer_object.read(
+ viewport=self.frame_buffer_object.viewport,
+ components=num_channels,
+ dtype=dtype,
+ )
+ return ret
+
+ def get_frame(self):
+ # get current pixel values as numpy data in order to test output
+ raw = self.get_raw_frame_buffer_object_data(dtype="f1")
+ pixel_shape = self.get_pixel_shape()
+ result_dimensions = (pixel_shape[1], pixel_shape[0], 4)
+ np_buf = np.frombuffer(raw, dtype="uint8").reshape(result_dimensions)
+ np_buf = np.flipud(np_buf)
+ return np_buf
+
+ # Returns offset from the bottom left corner in pixels.
+ # top_left flag should be set to True when using a GUI framework
+ # where the (0,0) is at the top left: e.g. PySide6
+ def pixel_coords_to_space_coords(self, px, py, relative=False, top_left=False):
+ pixel_shape = self.get_pixel_shape()
+ if pixel_shape is None:
+ return np.array([0, 0, 0])
+ pw, ph = pixel_shape
+ fw, fh = config["frame_width"], config["frame_height"]
+ fc = self.camera.get_center()
+ if relative:
+ return 2 * np.array([px / pw, py / ph, 0])
+ else:
+ # Only scale wrt one axis
+ scale = fh / ph
+ return fc + scale * np.array(
+ [(px - pw / 2), (-1 if top_left else 1) * (py - ph / 2), 0]
+ )
+
+ @property
+ def background_color(self):
+ return self._background_color
+
+ @background_color.setter
+ def background_color(self, value):
+ self._background_color = color_to_rgba(value, 1.0)
diff --git a/data/rag/manim_docs/manim_core/source/renderer/opengl_renderer_window.py b/data/rag/manim_docs/manim_core/source/renderer/opengl_renderer_window.py
new file mode 100644
index 0000000000000000000000000000000000000000..14d913899c17d00cf71836bae972cebd31a892bc
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/opengl_renderer_window.py
@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import moderngl_window as mglw
+from moderngl_window.context.pyglet.window import Window as PygletWindow
+from moderngl_window.timers.clock import Timer
+from screeninfo import get_monitors
+
+from .. import __version__, config
+
+
+class Window(PygletWindow):
+ fullscreen = False
+ resizable = True
+ gl_version = (3, 3)
+ vsync = True
+ cursor = True
+
+ def __init__(self, renderer, size=config.window_size, **kwargs):
+ monitors = get_monitors()
+ mon_index = config.window_monitor
+ monitor = monitors[min(mon_index, len(monitors) - 1)]
+
+ if size == "default":
+ # make window_width half the width of the monitor
+ # but make it full screen if --fullscreen
+
+ window_width = monitor.width
+ if not config.fullscreen:
+ window_width //= 2
+
+ # by default window_height = 9/16 * window_width
+ window_height = int(
+ window_width * config.frame_height // config.frame_width,
+ )
+ size = (window_width, window_height)
+ else:
+ size = tuple(size)
+
+ super().__init__(size=size)
+
+ self.title = f"Manim Community {__version__}"
+ self.size = size
+ self.renderer = renderer
+
+ mglw.activate_context(window=self)
+ self.timer = Timer()
+ self.config = mglw.WindowConfig(ctx=self.ctx, wnd=self, timer=self.timer)
+ self.timer.start()
+
+ self.swap_buffers()
+
+ initial_position = self.find_initial_position(size, monitor)
+ self.position = initial_position
+
+ # Delegate event handling to scene.
+ def on_mouse_motion(self, x, y, dx, dy):
+ super().on_mouse_motion(x, y, dx, dy)
+ point = self.renderer.pixel_coords_to_space_coords(x, y)
+ d_point = self.renderer.pixel_coords_to_space_coords(dx, dy, relative=True)
+ self.renderer.scene.on_mouse_motion(point, d_point)
+
+ def on_mouse_scroll(self, x, y, x_offset: float, y_offset: float):
+ super().on_mouse_scroll(x, y, x_offset, y_offset)
+ point = self.renderer.pixel_coords_to_space_coords(x, y)
+ offset = self.renderer.pixel_coords_to_space_coords(
+ x_offset,
+ y_offset,
+ relative=True,
+ )
+ self.renderer.scene.on_mouse_scroll(point, offset)
+
+ def on_key_press(self, symbol, modifiers):
+ self.renderer.pressed_keys.add(symbol)
+ super().on_key_press(symbol, modifiers)
+ self.renderer.scene.on_key_press(symbol, modifiers)
+
+ def on_key_release(self, symbol, modifiers):
+ if symbol in self.renderer.pressed_keys:
+ self.renderer.pressed_keys.remove(symbol)
+ super().on_key_release(symbol, modifiers)
+ self.renderer.scene.on_key_release(symbol, modifiers)
+
+ def on_mouse_drag(self, x, y, dx, dy, buttons, modifiers):
+ super().on_mouse_drag(x, y, dx, dy, buttons, modifiers)
+ point = self.renderer.pixel_coords_to_space_coords(x, y)
+ d_point = self.renderer.pixel_coords_to_space_coords(dx, dy, relative=True)
+ self.renderer.scene.on_mouse_drag(point, d_point, buttons, modifiers)
+
+ def find_initial_position(self, size, monitor):
+ custom_position = config.window_position
+ window_width, window_height = size
+ # Position might be specified with a string of the form
+ # x,y for integers x and y
+ if len(custom_position) == 1:
+ raise ValueError(
+ "window_position must specify both Y and X positions (Y/X -> UR). Also accepts LEFT/RIGHT/ORIGIN/UP/DOWN.",
+ )
+ # in the form Y/X (UR)
+ if custom_position in ["LEFT", "RIGHT"]:
+ custom_position = "O" + custom_position[0]
+ elif custom_position in ["UP", "DOWN"]:
+ custom_position = custom_position[0] + "O"
+ elif custom_position == "ORIGIN":
+ custom_position = "O" * 2
+ elif "," in custom_position:
+ return tuple(map(int, custom_position.split(",")))
+
+ # Alternatively, it might be specified with a string like
+ # UR, OO, DL, etc. specifying what corner it should go to
+ char_to_n = {"L": 0, "U": 0, "O": 1, "R": 2, "D": 2}
+ width_diff = monitor.width - window_width
+ height_diff = monitor.height - window_height
+
+ return (
+ monitor.x + char_to_n[custom_position[1]] * width_diff // 2,
+ -monitor.y + char_to_n[custom_position[0]] * height_diff // 2,
+ )
+
+ def on_mouse_press(self, x, y, button, modifiers):
+ super().on_mouse_press(x, y, button, modifiers)
+ point = self.renderer.pixel_coords_to_space_coords(x, y)
+ mouse_button_map = {
+ 1: "LEFT",
+ 2: "MOUSE",
+ 4: "RIGHT",
+ }
+ self.renderer.scene.on_mouse_press(point, mouse_button_map[button], modifiers)
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shader.py b/data/rag/manim_docs/manim_core/source/renderer/shader.py
new file mode 100644
index 0000000000000000000000000000000000000000..85b9dad14a5c0b0e4002414c381de1ac06909ec8
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shader.py
@@ -0,0 +1,444 @@
+from __future__ import annotations
+
+import inspect
+import re
+import textwrap
+from pathlib import Path
+
+import moderngl
+import numpy as np
+
+from .. import config
+from ..utils import opengl
+
+SHADER_FOLDER = Path(__file__).parent / "shaders"
+shader_program_cache: dict = {}
+file_path_to_code_map: dict = {}
+
+__all__ = [
+ "Object3D",
+ "Mesh",
+ "Shader",
+ "FullScreenQuad",
+]
+
+
+def get_shader_code_from_file(file_path: Path) -> str:
+ if file_path in file_path_to_code_map:
+ return file_path_to_code_map[file_path]
+ source = file_path.read_text()
+ include_lines = re.finditer(
+ r"^#include (?P.*\.glsl)$",
+ source,
+ flags=re.MULTILINE,
+ )
+ for match in include_lines:
+ include_path = match.group("include_path")
+ included_code = get_shader_code_from_file(
+ file_path.parent / include_path,
+ )
+ source = source.replace(match.group(0), included_code)
+ file_path_to_code_map[file_path] = source
+ return source
+
+
+def filter_attributes(unfiltered_attributes, attributes):
+ # Construct attributes for only those needed by the shader.
+ filtered_attributes_dtype = []
+ for i, dtype_name in enumerate(unfiltered_attributes.dtype.names):
+ if dtype_name in attributes:
+ filtered_attributes_dtype.append(
+ (
+ dtype_name,
+ unfiltered_attributes.dtype[i].subdtype[0].str,
+ unfiltered_attributes.dtype[i].shape,
+ ),
+ )
+
+ filtered_attributes = np.zeros(
+ unfiltered_attributes[unfiltered_attributes.dtype.names[0]].shape[0],
+ dtype=filtered_attributes_dtype,
+ )
+
+ for dtype_name in unfiltered_attributes.dtype.names:
+ if dtype_name in attributes:
+ filtered_attributes[dtype_name] = unfiltered_attributes[dtype_name]
+
+ return filtered_attributes
+
+
+class Object3D:
+ def __init__(self, *children):
+ self.model_matrix = np.eye(4)
+ self.normal_matrix = np.eye(4)
+ self.children = []
+ self.parent = None
+ self.add(*children)
+ self.init_updaters()
+
+ # TODO: Use path_func.
+ def interpolate(self, start, end, alpha, _):
+ self.model_matrix = (1 - alpha) * start.model_matrix + alpha * end.model_matrix
+ self.normal_matrix = (
+ 1 - alpha
+ ) * start.normal_matrix + alpha * end.normal_matrix
+
+ def single_copy(self):
+ copy = Object3D()
+ copy.model_matrix = self.model_matrix.copy()
+ copy.normal_matrix = self.normal_matrix.copy()
+ return copy
+
+ def copy(self):
+ node_to_copy = {}
+
+ bfs = [self]
+ while bfs:
+ node = bfs.pop(0)
+ bfs.extend(node.children)
+
+ node_copy = node.single_copy()
+ node_to_copy[node] = node_copy
+
+ # Add the copy to the copy of the parent.
+ if node.parent is not None and node is not self:
+ node_to_copy[node.parent].add(node_copy)
+ return node_to_copy[self]
+
+ def add(self, *children):
+ for child in children:
+ if child.parent is not None:
+ raise Exception(
+ "Attempt to add child that's already added to another Object3D",
+ )
+ self.remove(*children, current_children_only=False)
+ self.children.extend(children)
+ for child in children:
+ child.parent = self
+
+ def remove(self, *children, current_children_only=True):
+ if current_children_only:
+ for child in children:
+ if child.parent != self:
+ raise Exception(
+ "Attempt to remove child that isn't added to this Object3D",
+ )
+ self.children = list(filter(lambda child: child not in children, self.children))
+ for child in children:
+ child.parent = None
+
+ def get_position(self):
+ return self.model_matrix[:, 3][:3]
+
+ def set_position(self, position):
+ self.model_matrix[:, 3][:3] = position
+ return self
+
+ def get_meshes(self):
+ dfs = [self]
+ while dfs:
+ parent = dfs.pop()
+ if isinstance(parent, Mesh):
+ yield parent
+ dfs.extend(parent.children)
+
+ def get_family(self):
+ dfs = [self]
+ while dfs:
+ parent = dfs.pop()
+ yield parent
+ dfs.extend(parent.children)
+
+ def align_data_and_family(self, _):
+ pass
+
+ def hierarchical_model_matrix(self):
+ if self.parent is None:
+ return self.model_matrix
+
+ model_matrices = [self.model_matrix]
+ current_object = self
+ while current_object.parent is not None:
+ model_matrices.append(current_object.parent.model_matrix)
+ current_object = current_object.parent
+ return np.linalg.multi_dot(list(reversed(model_matrices)))
+
+ def hierarchical_normal_matrix(self):
+ if self.parent is None:
+ return self.normal_matrix[:3, :3]
+
+ normal_matrices = [self.normal_matrix]
+ current_object = self
+ while current_object.parent is not None:
+ normal_matrices.append(current_object.parent.model_matrix)
+ current_object = current_object.parent
+ return np.linalg.multi_dot(list(reversed(normal_matrices)))[:3, :3]
+
+ def init_updaters(self):
+ self.time_based_updaters = []
+ self.non_time_updaters = []
+ self.has_updaters = False
+ self.updating_suspended = False
+
+ def update(self, dt=0):
+ if not self.has_updaters or self.updating_suspended:
+ return self
+ for updater in self.time_based_updaters:
+ updater(self, dt)
+ for updater in self.non_time_updaters:
+ updater(self)
+ return self
+
+ def get_time_based_updaters(self):
+ return self.time_based_updaters
+
+ def has_time_based_updater(self):
+ return len(self.time_based_updaters) > 0
+
+ def get_updaters(self):
+ return self.time_based_updaters + self.non_time_updaters
+
+ def add_updater(self, update_function, index=None, call_updater=True):
+ if "dt" in inspect.signature(update_function).parameters:
+ updater_list = self.time_based_updaters
+ else:
+ updater_list = self.non_time_updaters
+
+ if index is None:
+ updater_list.append(update_function)
+ else:
+ updater_list.insert(index, update_function)
+
+ self.refresh_has_updater_status()
+ if call_updater:
+ self.update()
+ return self
+
+ def remove_updater(self, update_function):
+ for updater_list in [self.time_based_updaters, self.non_time_updaters]:
+ while update_function in updater_list:
+ updater_list.remove(update_function)
+ self.refresh_has_updater_status()
+ return self
+
+ def clear_updaters(self):
+ self.time_based_updaters = []
+ self.non_time_updaters = []
+ self.refresh_has_updater_status()
+ return self
+
+ def match_updaters(self, mobject):
+ self.clear_updaters()
+ for updater in mobject.get_updaters():
+ self.add_updater(updater)
+ return self
+
+ def suspend_updating(self):
+ self.updating_suspended = True
+ return self
+
+ def resume_updating(self, call_updater=True):
+ self.updating_suspended = False
+ if call_updater:
+ self.update(dt=0)
+ return self
+
+ def refresh_has_updater_status(self):
+ self.has_updaters = len(self.get_updaters()) > 0
+ return self
+
+
+class Mesh(Object3D):
+ def __init__(
+ self,
+ shader=None,
+ attributes=None,
+ geometry=None,
+ material=None,
+ indices=None,
+ use_depth_test=True,
+ primitive=moderngl.TRIANGLES,
+ ):
+ super().__init__()
+ if shader is not None and attributes is not None:
+ self.shader = shader
+ self.attributes = attributes
+ self.indices = indices
+ elif geometry is not None and material is not None:
+ self.shader = material
+ self.attributes = geometry.attributes
+ self.indices = geometry.index
+ else:
+ raise Exception(
+ "Mesh requires either attributes and a Shader or a Geometry and a "
+ "Material",
+ )
+ self.use_depth_test = use_depth_test
+ self.primitive = primitive
+ self.skip_render = False
+ self.init_updaters()
+
+ def single_copy(self):
+ copy = Mesh(
+ attributes=self.attributes.copy(),
+ shader=self.shader,
+ indices=self.indices.copy() if self.indices is not None else None,
+ use_depth_test=self.use_depth_test,
+ primitive=self.primitive,
+ )
+ copy.skip_render = self.skip_render
+ copy.model_matrix = self.model_matrix.copy()
+ copy.normal_matrix = self.normal_matrix.copy()
+ # TODO: Copy updaters?
+ return copy
+
+ def set_uniforms(self, renderer):
+ self.shader.set_uniform(
+ "u_model_matrix",
+ opengl.matrix_to_shader_input(self.model_matrix),
+ )
+ self.shader.set_uniform("u_view_matrix", renderer.camera.formatted_view_matrix)
+ self.shader.set_uniform(
+ "u_projection_matrix",
+ renderer.camera.projection_matrix,
+ )
+
+ def render(self):
+ if self.skip_render:
+ return
+
+ if self.use_depth_test:
+ self.shader.context.enable(moderngl.DEPTH_TEST)
+ else:
+ self.shader.context.disable(moderngl.DEPTH_TEST)
+
+ from moderngl import Attribute
+
+ shader_attributes = []
+ for k, v in self.shader.shader_program._members.items():
+ if isinstance(v, Attribute):
+ shader_attributes.append(k)
+ shader_attributes = filter_attributes(self.attributes, shader_attributes)
+
+ vertex_buffer_object = self.shader.context.buffer(shader_attributes.tobytes())
+ if self.indices is None:
+ index_buffer_object = None
+ else:
+ vert_index_data = self.indices.astype("i4").tobytes()
+ if vert_index_data:
+ index_buffer_object = self.shader.context.buffer(vert_index_data)
+ else:
+ index_buffer_object = None
+ vertex_array_object = self.shader.context.simple_vertex_array(
+ self.shader.shader_program,
+ vertex_buffer_object,
+ *shader_attributes.dtype.names,
+ index_buffer=index_buffer_object,
+ )
+ vertex_array_object.render(self.primitive)
+ vertex_buffer_object.release()
+ vertex_array_object.release()
+ if index_buffer_object is not None:
+ index_buffer_object.release()
+
+
+class Shader:
+ def __init__(
+ self,
+ context,
+ name=None,
+ source=None,
+ ):
+ global shader_program_cache
+ self.context = context
+ self.name = name
+
+ # See if the program is cached.
+ if (
+ self.name in shader_program_cache
+ and shader_program_cache[self.name].ctx == self.context
+ ):
+ self.shader_program = shader_program_cache[self.name]
+ elif source is not None:
+ # Generate the shader from inline code if it was passed.
+ self.shader_program = context.program(**source)
+ else:
+ # Search for a file containing the shader.
+ source_dict = {}
+ source_dict_key = {
+ "vert": "vertex_shader",
+ "frag": "fragment_shader",
+ "geom": "geometry_shader",
+ }
+ shader_folder = SHADER_FOLDER / name
+ for shader_file in shader_folder.iterdir():
+ shader_file_path = shader_folder / shader_file
+ shader_source = get_shader_code_from_file(shader_file_path)
+ source_dict[source_dict_key[shader_file_path.stem]] = shader_source
+ self.shader_program = context.program(**source_dict)
+
+ # Cache the shader.
+ if name is not None and name not in shader_program_cache:
+ shader_program_cache[self.name] = self.shader_program
+
+ def set_uniform(self, name, value):
+ try:
+ self.shader_program[name] = value
+ except KeyError:
+ pass
+
+
+class FullScreenQuad(Mesh):
+ def __init__(
+ self,
+ context,
+ fragment_shader_source=None,
+ fragment_shader_name=None,
+ ):
+ if fragment_shader_source is None and fragment_shader_name is None:
+ raise Exception("Must either pass shader name or shader source.")
+
+ if fragment_shader_name is not None:
+ # Use the name.
+ shader_file_path = SHADER_FOLDER / f"{fragment_shader_name}.frag"
+ fragment_shader_source = get_shader_code_from_file(shader_file_path)
+ elif fragment_shader_source is not None:
+ fragment_shader_source = textwrap.dedent(fragment_shader_source.lstrip())
+
+ shader = Shader(
+ context,
+ source={
+ "vertex_shader": """
+ #version 330
+ in vec4 in_vert;
+ uniform mat4 u_model_view_matrix;
+ uniform mat4 u_projection_matrix;
+ void main() {{
+ vec4 camera_space_vertex = u_model_view_matrix * in_vert;
+ vec4 clip_space_vertex = u_projection_matrix * camera_space_vertex;
+ gl_Position = clip_space_vertex;
+ }}
+ """,
+ "fragment_shader": fragment_shader_source,
+ },
+ )
+ attributes = np.zeros(6, dtype=[("in_vert", np.float32, (4,))])
+ attributes["in_vert"] = np.array(
+ [
+ [-config["frame_x_radius"], -config["frame_y_radius"], 0, 1],
+ [-config["frame_x_radius"], config["frame_y_radius"], 0, 1],
+ [config["frame_x_radius"], config["frame_y_radius"], 0, 1],
+ [-config["frame_x_radius"], -config["frame_y_radius"], 0, 1],
+ [config["frame_x_radius"], -config["frame_y_radius"], 0, 1],
+ [config["frame_x_radius"], config["frame_y_radius"], 0, 1],
+ ],
+ )
+ shader.set_uniform("u_model_view_matrix", opengl.view_matrix())
+ shader.set_uniform(
+ "u_projection_matrix",
+ opengl.orthographic_projection_matrix(),
+ )
+ super().__init__(shader, attributes)
+
+ def render(self):
+ super().render()
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shader_wrapper.py b/data/rag/manim_docs/manim_core/source/renderer/shader_wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b38b1b53a3a0a5cc6bfa60b03c8dbd7ea34a9da
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shader_wrapper.py
@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import copy
+import re
+from pathlib import Path
+
+import moderngl
+import numpy as np
+
+from .. import logger
+
+# Mobjects that should be rendered with
+# the same shader will be organized and
+# clumped together based on keeping track
+# of a dict holding all the relevant information
+# to that shader
+
+
+def get_shader_dir():
+ return Path(__file__).parent / "shaders"
+
+
+def find_file(file_name: Path, directories: list[Path]) -> Path:
+ # Check if what was passed in is already a valid path to a file
+ if file_name.exists():
+ return file_name
+ possible_paths = (directory / file_name for directory in directories)
+ for path in possible_paths:
+ if path.exists():
+ return path
+ else:
+ logger.debug(f"{path} does not exist.")
+ raise OSError(f"{file_name} not Found")
+
+
+class ShaderWrapper:
+ def __init__(
+ self,
+ vert_data=None,
+ vert_indices=None,
+ shader_folder=None,
+ uniforms=None, # A dictionary mapping names of uniform variables
+ texture_paths=None, # A dictionary mapping names to filepaths for textures.
+ depth_test=False,
+ render_primitive=moderngl.TRIANGLE_STRIP,
+ ):
+ self.vert_data = vert_data
+ self.vert_indices = vert_indices
+ self.vert_attributes = vert_data.dtype.names
+ self.shader_folder = Path(shader_folder or "")
+ self.uniforms = uniforms or {}
+ self.texture_paths = texture_paths or {}
+ self.depth_test = depth_test
+ self.render_primitive = str(render_primitive)
+ self.init_program_code()
+ self.refresh_id()
+
+ def copy(self):
+ result = copy.copy(self)
+ result.vert_data = np.array(self.vert_data)
+ if result.vert_indices is not None:
+ result.vert_indices = np.array(self.vert_indices)
+ if self.uniforms:
+ result.uniforms = dict(self.uniforms)
+ if self.texture_paths:
+ result.texture_paths = dict(self.texture_paths)
+ return result
+
+ def is_valid(self):
+ return all(
+ [
+ self.vert_data is not None,
+ self.program_code["vertex_shader"] is not None,
+ self.program_code["fragment_shader"] is not None,
+ ],
+ )
+
+ def get_id(self):
+ return self.id
+
+ def get_program_id(self):
+ return self.program_id
+
+ def create_id(self):
+ # A unique id for a shader
+ return "|".join(
+ map(
+ str,
+ [
+ self.program_id,
+ self.uniforms,
+ self.texture_paths,
+ self.depth_test,
+ self.render_primitive,
+ ],
+ ),
+ )
+
+ def refresh_id(self):
+ self.program_id = self.create_program_id()
+ self.id = self.create_id()
+
+ def create_program_id(self):
+ return hash(
+ "".join(
+ self.program_code[f"{name}_shader"] or ""
+ for name in ("vertex", "geometry", "fragment")
+ ),
+ )
+
+ def init_program_code(self):
+ def get_code(name: str) -> str | None:
+ return get_shader_code_from_file(
+ self.shader_folder / f"{name}.glsl",
+ )
+
+ self.program_code = {
+ "vertex_shader": get_code("vert"),
+ "geometry_shader": get_code("geom"),
+ "fragment_shader": get_code("frag"),
+ }
+
+ def get_program_code(self):
+ return self.program_code
+
+ def replace_code(self, old, new):
+ code_map = self.program_code
+ for name, _code in code_map.items():
+ if code_map[name] is None:
+ continue
+ code_map[name] = re.sub(old, new, code_map[name])
+ self.refresh_id()
+
+ def combine_with(self, *shader_wrappers):
+ # Assume they are of the same type
+ if len(shader_wrappers) == 0:
+ return
+ if self.vert_indices is not None:
+ num_verts = len(self.vert_data)
+ indices_list = [self.vert_indices]
+ data_list = [self.vert_data]
+ for sw in shader_wrappers:
+ indices_list.append(sw.vert_indices + num_verts)
+ data_list.append(sw.vert_data)
+ num_verts += len(sw.vert_data)
+ self.vert_indices = np.hstack(indices_list)
+ self.vert_data = np.hstack(data_list)
+ else:
+ self.vert_data = np.hstack(
+ [self.vert_data, *(sw.vert_data for sw in shader_wrappers)],
+ )
+ return self
+
+
+# For caching
+filename_to_code_map: dict = {}
+
+
+def get_shader_code_from_file(filename: Path) -> str | None:
+ if filename in filename_to_code_map:
+ return filename_to_code_map[filename]
+
+ try:
+ filepath = find_file(
+ filename,
+ directories=[get_shader_dir(), Path("/")],
+ )
+ except OSError:
+ return None
+
+ result = filepath.read_text()
+
+ # To share functionality between shaders, some functions are read in
+ # from other files an inserted into the relevant strings before
+ # passing to ctx.program for compiling
+ # Replace "#INSERT " lines with relevant code
+ insertions = re.findall(
+ r"^#include ../include/.*\.glsl$",
+ result,
+ flags=re.MULTILINE,
+ )
+ for line in insertions:
+ inserted_code = get_shader_code_from_file(
+ Path() / "include" / line.replace("#include ../include/", ""),
+ )
+ if inserted_code is None:
+ return None
+ result = result.replace(line, inserted_code)
+ filename_to_code_map[filename] = result
+ return result
+
+
+def get_colormap_code(rgb_list):
+ data = ",".join("vec3({}, {}, {})".format(*rgb) for rgb in rgb_list)
+ return f"vec3[{len(rgb_list)}]({data})"
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/default/frag.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/default/frag.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..2a721a51eaeab88474077f2af6a8cdc9d7815293
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/default/frag.glsl
@@ -0,0 +1,8 @@
+#version 330
+
+uniform vec4 u_color;
+out vec4 frag_color;
+
+void main() {
+ frag_color = u_color;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/default/vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/default/vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..4d69971c50cc529faf650eac65122848355923ee
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/default/vert.glsl
@@ -0,0 +1,10 @@
+#version 330
+
+in vec3 in_vert;
+uniform mat4 u_model_matrix;
+uniform mat4 u_view_matrix;
+uniform mat4 u_projection_matrix;
+
+void main() {
+ gl_Position = u_projection_matrix * u_view_matrix * u_model_matrix * vec4(in_vert, 1.0);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/design.frag b/data/rag/manim_docs/manim_core/source/renderer/shaders/design.frag
new file mode 100644
index 0000000000000000000000000000000000000000..e84e3984af2bd11e8d92f0ec7ee3a717ab1a68f3
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/design.frag
@@ -0,0 +1,15 @@
+#version 330
+
+out vec4 frag_color;
+
+void main() {
+ vec2 st = gl_FragCoord.xy / vec2(854, 360);
+ vec3 color = vec3(0.0);
+
+ st *= 3.0;
+ st = fract(st);
+
+ color = vec3(st, 0.0);
+
+ frag_color = vec4(color, 1.0);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/design_2.frag b/data/rag/manim_docs/manim_core/source/renderer/shaders/design_2.frag
new file mode 100644
index 0000000000000000000000000000000000000000..02c91490d0c01d689f7412a08611d53e5bc72aaf
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/design_2.frag
@@ -0,0 +1,45 @@
+#version 330
+
+uniform vec2 u_resolution;
+out vec4 frag_color;
+
+
+#define PI 3.14159265358979323846
+
+vec2 rotate2D(vec2 _st, float _angle){
+ _st -= 0.5;
+ _st = mat2(cos(_angle),-sin(_angle),
+ sin(_angle),cos(_angle)) * _st;
+ _st += 0.5;
+ return _st;
+}
+
+vec2 tile(vec2 _st, float _zoom){
+ _st *= _zoom;
+ return fract(_st);
+}
+
+float box(vec2 _st, vec2 _size, float _smoothEdges){
+ _size = vec2(0.5)-_size*0.5;
+ vec2 aa = vec2(_smoothEdges*0.5);
+ vec2 uv = smoothstep(_size,_size+aa,_st);
+ uv *= smoothstep(_size,_size+aa,vec2(1.0)-_st);
+ return uv.x*uv.y;
+}
+
+void main(void){
+ vec2 st = gl_FragCoord.xy/u_resolution.xy;
+ vec3 color = vec3(0.0);
+
+ // Divide the space in 4
+ st = tile(st,4.);
+
+ // Use a matrix to rotate the space 45 degrees
+ st = rotate2D(st,PI*0.25);
+
+ // Draw a square
+ color = vec3(box(st,vec2(0.7),0.01));
+ // color = vec3(st,0.0);
+
+ frag_color = vec4(color,1.0);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/design_3.frag b/data/rag/manim_docs/manim_core/source/renderer/shaders/design_3.frag
new file mode 100644
index 0000000000000000000000000000000000000000..6a0e601c70f0de3642c76f3c03ac2351b648cc61
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/design_3.frag
@@ -0,0 +1,59 @@
+#version 330
+
+uniform vec3 u_resolution;
+uniform float u_time;
+out vec4 frag_color;
+
+vec3 palette(float d){
+ return mix(vec3(0.2,0.7,0.9),vec3(1.,0.,1.),d);
+}
+
+vec2 rotate(vec2 p,float a){
+ float c = cos(a);
+ float s = sin(a);
+ return p*mat2(c,s,-s,c);
+}
+
+float map(vec3 p){
+ for( int i = 0; i<8; ++i){
+ float t = u_time*0.1;
+ p.xz =rotate(p.xz,t);
+ p.xy =rotate(p.xy,t*1.89);
+ p.xz = abs(p.xz);
+ p.xz-=.5;
+ }
+ return dot(sign(p),p)/5.;
+}
+
+vec4 rm (vec3 ro, vec3 rd){
+ float t = 0.;
+ vec3 col = vec3(0.);
+ float d;
+ for(float i =0.; i<64.; i++){
+ vec3 p = ro + rd*t;
+ d = map(p)*.5;
+ if(d<0.02){
+ break;
+ }
+ if(d>100.){
+ break;
+ }
+ //col+=vec3(0.6,0.8,0.8)/(400.*(d));
+ col+=palette(length(p)*.1)/(400.*(d));
+ t+=d;
+ }
+ return vec4(col,1./(d*100.));
+}
+
+void main(void){
+ vec2 uv = (gl_FragCoord.xy-(u_resolution.xy/2.))/u_resolution.x;
+ vec3 ro = vec3(0.,0.,-50.);
+ ro.xz = rotate(ro.xz,u_time);
+ vec3 cf = normalize(-ro);
+ vec3 cs = normalize(cross(cf,vec3(0.,1.,0.)));
+ vec3 cu = normalize(cross(cf,cs));
+ vec3 uuv = ro+cf*3. + uv.x*cs + uv.y*cu;
+ vec3 rd = normalize(uuv-ro);
+ vec4 col = rm(ro,rd);
+ frag_color = vec4(col.xyz, 1);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/image/frag.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/image/frag.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..fe6cbd4ca2ab409c0205fddba5c2db083305dd00
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/image/frag.glsl
@@ -0,0 +1,13 @@
+#version 330
+
+uniform sampler2D Texture;
+
+in vec2 v_im_coords;
+in float v_opacity;
+
+out vec4 frag_color;
+
+void main() {
+ frag_color = texture(Texture, v_im_coords);
+ frag_color.a = v_opacity;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/image/vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/image/vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..aaaae6bff7ef375c680c77ddab1ab913545b40ab
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/image/vert.glsl
@@ -0,0 +1,22 @@
+#version 330
+
+#include ../include/camera_uniform_declarations.glsl
+
+uniform sampler2D Texture;
+
+in vec3 point;
+in vec2 im_coords;
+in float opacity;
+
+out vec2 v_im_coords;
+out float v_opacity;
+
+// Analog of import for manim only
+#include ../include/get_gl_Position.glsl
+#include ../include/position_point_into_frame.glsl
+
+void main(){
+ v_im_coords = im_coords;
+ v_opacity = opacity;
+ gl_Position = get_gl_Position(position_point_into_frame(point));
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/include/NOTE.md b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/NOTE.md
new file mode 100644
index 0000000000000000000000000000000000000000..5aada430b83e5e7e9fe8f8f3616b47bdef89910e
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/NOTE.md
@@ -0,0 +1,7 @@
+There seems to be no analog to #include in C++ for OpenGL shaders. While there are other options for sharing code between shaders, a lot of them aren't great, especially if the goal is to have all the logic for which specific bits of code to share handled in the shader file itself. So the way manim currently works is to replace any line which looks like
+
+#INSERT
+
+with the code from one of the files in this folder.
+
+The functions in this file often include reference to uniforms which are assumed to be part of the surrounding context into which they are inserted.
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/include/add_light.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/add_light.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..cc6291994471ba081b3328b2164f30de082c2f6f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/add_light.glsl
@@ -0,0 +1,43 @@
+///// INSERT COLOR_MAP FUNCTION HERE /////
+
+vec4 add_light(vec4 color,
+ vec3 point,
+ vec3 unit_normal,
+ vec3 light_coords,
+ float gloss,
+ float shadow){
+ ///// INSERT COLOR FUNCTION HERE /////
+ // The line above may be replaced by arbitrary code snippets, as per
+ // the method Mobject.set_color_by_code
+ if(gloss == 0.0 && shadow == 0.0) return color;
+
+ // TODO, do we actually want this? It effectively treats surfaces as two-sided
+ if(unit_normal.z < 0){
+ unit_normal *= -1;
+ }
+
+ // TODO, read this in as a uniform?
+ float camera_distance = 6;
+ // Assume everything has already been rotated such that camera is in the z-direction
+ vec3 to_camera = vec3(0, 0, camera_distance) - point;
+ vec3 to_light = light_coords - point;
+ vec3 light_reflection = -to_light + 2 * unit_normal * dot(to_light, unit_normal);
+ float dot_prod = dot(normalize(light_reflection), normalize(to_camera));
+ float shine = gloss * exp(-3 * pow(1 - dot_prod, 2));
+ float dp2 = dot(normalize(to_light), unit_normal);
+ float darkening = mix(1, max(dp2, 0), shadow);
+ return vec4(
+ darkening * mix(color.rgb, vec3(1.0), shine),
+ color.a
+ );
+}
+
+vec4 finalize_color(vec4 color,
+ vec3 point,
+ vec3 unit_normal,
+ vec3 light_coords,
+ float gloss,
+ float shadow){
+ // Put insertion here instead
+ return add_light(color, point, unit_normal, light_coords, gloss, shadow);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/include/camera_uniform_declarations.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/camera_uniform_declarations.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..fea450300fce5fc3c2a72ccc32c5b12be6468213
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/camera_uniform_declarations.glsl
@@ -0,0 +1,8 @@
+uniform vec2 frame_shape;
+uniform float anti_alias_width;
+uniform vec3 camera_center;
+uniform mat3 camera_rotation;
+uniform float is_fixed_in_frame;
+uniform float is_fixed_orientation;
+uniform vec3 fixed_orientation_center;
+uniform float focal_distance;
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/include/finalize_color.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/finalize_color.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..26b10376a268a9c2942a7c9afc91053d9e25a760
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/finalize_color.glsl
@@ -0,0 +1,51 @@
+vec3 float_to_color(float value, float min_val, float max_val, vec3[9] colormap_data){
+ float alpha = clamp((value - min_val) / (max_val - min_val), 0.0, 1.0);
+ int disc_alpha = min(int(alpha * 8), 7);
+ return mix(
+ colormap_data[disc_alpha],
+ colormap_data[disc_alpha + 1],
+ 8.0 * alpha - disc_alpha
+ );
+}
+
+
+vec4 add_light(vec4 color,
+ vec3 point,
+ vec3 unit_normal,
+ vec3 light_coords,
+ float gloss,
+ float shadow){
+ if(gloss == 0.0 && shadow == 0.0) return color;
+
+ // TODO, do we actually want this? It effectively treats surfaces as two-sided
+ if(unit_normal.z < 0){
+ unit_normal *= -1;
+ }
+
+ // TODO, read this in as a uniform?
+ float camera_distance = 6;
+ // Assume everything has already been rotated such that camera is in the z-direction
+ vec3 to_camera = vec3(0, 0, camera_distance) - point;
+ vec3 to_light = light_coords - point;
+ vec3 light_reflection = -to_light + 2 * unit_normal * dot(to_light, unit_normal);
+ float dot_prod = dot(normalize(light_reflection), normalize(to_camera));
+ float shine = gloss * exp(-3 * pow(1 - dot_prod, 2));
+ float dp2 = dot(normalize(to_light), unit_normal);
+ float darkening = mix(1, max(dp2, 0), shadow);
+ return vec4(
+ darkening * mix(color.rgb, vec3(1.0), shine),
+ color.a
+ );
+}
+
+vec4 finalize_color(vec4 color,
+ vec3 point,
+ vec3 unit_normal,
+ vec3 light_coords,
+ float gloss,
+ float shadow){
+ ///// INSERT COLOR FUNCTION HERE /////
+ // The line above may be replaced by arbitrary code snippets, as per
+ // the method Mobject.set_color_by_code
+ return add_light(color, point, unit_normal, light_coords, gloss, shadow);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/include/get_gl_Position.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/get_gl_Position.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..9c16c932120cd483933fefb6d21b14fb799bcb12
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/get_gl_Position.glsl
@@ -0,0 +1,38 @@
+// Assumes the following uniforms exist in the surrounding context:
+// uniform vec2 frame_shape;
+// uniform float focal_distance;
+// uniform float is_fixed_in_frame;
+// uniform float is_fixed_orientation;
+// uniform vec3 fixed_orientation_center;
+
+const vec2 DEFAULT_FRAME_SHAPE = vec2(8.0 * 16.0 / 9.0, 8.0);
+
+float perspective_scale_factor(float z, float focal_distance){
+ return max(0.0, focal_distance / (focal_distance - z));
+}
+
+
+vec4 get_gl_Position(vec3 point){
+ vec4 result = vec4(point, 1.0);
+ if(!bool(is_fixed_in_frame)){
+ result.x *= 2.0 / frame_shape.x;
+ result.y *= 2.0 / frame_shape.y;
+ float psf = perspective_scale_factor(result.z, focal_distance);
+ if (psf > 0){
+ result.xy *= psf;
+ // TODO, what's the better way to do this?
+ // This is to keep vertices too far out of frame from getting cut.
+ result.z *= 0.01;
+ }
+ } else{
+ if (!bool(is_fixed_orientation)){
+ result.x *= 2.0 / DEFAULT_FRAME_SHAPE.x;
+ result.y *= 2.0 / DEFAULT_FRAME_SHAPE.y;
+ } else{
+ result.x *= 2.0 / frame_shape.x;
+ result.y *= 2.0 / frame_shape.y;
+ }
+ }
+ result.z *= -1;
+ return result;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/include/get_rotated_surface_unit_normal_vector.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/get_rotated_surface_unit_normal_vector.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..8c6350d7a0732820f1128c0b9199d3e4b990e21d
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/get_rotated_surface_unit_normal_vector.glsl
@@ -0,0 +1,16 @@
+// Assumes the following uniforms exist in the surrounding context:
+// uniform vec3 camera_center;
+// uniform mat3 camera_rotation;
+
+vec3 get_rotated_surface_unit_normal_vector(vec3 point, vec3 du_point, vec3 dv_point){
+ vec3 cp = cross(
+ (du_point - point),
+ (dv_point - point)
+ );
+ if(length(cp) == 0){
+ // Instead choose a normal to just dv_point - point in the direction of point
+ vec3 v2 = dv_point - point;
+ cp = cross(cross(v2, point), v2);
+ }
+ return normalize(rotate_point_into_frame(cp));
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/include/get_unit_normal.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/get_unit_normal.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..65bb9c71e7e18e68ceaf1702b538249ddbb6ae4f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/get_unit_normal.glsl
@@ -0,0 +1,22 @@
+vec3 get_unit_normal(in vec3[3] points){
+ float tol = 1e-6;
+ vec3 v1 = normalize(points[1] - points[0]);
+ vec3 v2 = normalize(points[2] - points[0]);
+ vec3 cp = cross(v1, v2);
+ float cp_norm = length(cp);
+ if(cp_norm < tol){
+ // Three points form a line, so find a normal vector
+ // to that line in the plane shared with the z-axis
+ vec3 k_hat = vec3(0.0, 0.0, 1.0);
+ vec3 new_cp = cross(cross(v2, k_hat), v2);
+ float new_cp_norm = length(new_cp);
+ if(new_cp_norm < tol){
+ // We only come here if all three points line up
+ // on the z-axis.
+ return vec3(0.0, -1.0, 0.0);
+ // return k_hat;
+ }
+ return new_cp / new_cp_norm;
+ }
+ return cp / cp_norm;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/include/position_point_into_frame.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/position_point_into_frame.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..67b5080f5642b26073650503cdb661380a908165
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/position_point_into_frame.glsl
@@ -0,0 +1,25 @@
+// Assumes the following uniforms exist in the surrounding context:
+// uniform float is_fixed_in_frame;
+// uniform float is_fixed_orientation;
+// uniform vec3 fixed_orientation_center;
+// uniform vec3 camera_center;
+// uniform mat3 camera_rotation;
+
+vec3 rotate_point_into_frame(vec3 point){
+ if(bool(is_fixed_in_frame)){
+ return point;
+ }
+ return camera_rotation * point;
+}
+
+
+vec3 position_point_into_frame(vec3 point){
+ if(bool(is_fixed_in_frame)){
+ return point;
+ }
+ if(bool(is_fixed_orientation)){
+ vec3 new_center = rotate_point_into_frame(fixed_orientation_center);
+ return point + (new_center - fixed_orientation_center);
+ }
+ return rotate_point_into_frame(point - camera_center);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/include/quadratic_bezier_distance.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/quadratic_bezier_distance.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..847fa4ab6d077032f02fedebf1067c8c1d18cb8a
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/quadratic_bezier_distance.glsl
@@ -0,0 +1,107 @@
+// Must be inserted in a context with a definition for modify_distance_for_endpoints
+
+// All of this is with respect to a curve that's been rotated/scaled
+// so that b0 = (0, 0) and b1 = (1, 0). That is, b2 entirely
+// determines the shape of the curve
+
+vec2 bezier(float t, vec2 b2){
+ // Quick returns for the 0 and 1 cases
+ if (t == 0) return vec2(0, 0);
+ else if (t == 1) return b2;
+ // Everything else
+ return vec2(
+ 2 * t * (1 - t) + b2.x * t*t,
+ b2.y * t * t
+ );
+}
+
+
+float cube_root(float x){
+ return sign(x) * pow(abs(x), 1.0 / 3.0);
+}
+
+
+int cubic_solve(float a, float b, float c, float d, out float roots[3]){
+ // Normalize so a = 1
+ b = b / a;
+ c = c / a;
+ d = d / a;
+
+ float p = c - b*b / 3.0;
+ float q = b * (2.0*b*b - 9.0*c) / 27.0 + d;
+ float p3 = p*p*p;
+ float disc = q*q + 4.0*p3 / 27.0;
+ float offset = -b / 3.0;
+ if(disc >= 0.0){
+ float z = sqrt(disc);
+ float u = (-q + z) / 2.0;
+ float v = (-q - z) / 2.0;
+ u = cube_root(u);
+ v = cube_root(v);
+ roots[0] = offset + u + v;
+ return 1;
+ }
+ float u = sqrt(-p / 3.0);
+ float v = acos(-sqrt( -27.0 / p3) * q / 2.0) / 3.0;
+ float m = cos(v);
+ float n = sin(v) * 1.732050808;
+
+ float all_roots[3] = float[3](
+ offset + u * (n - m),
+ offset - u * (n + m),
+ offset + u * (m + m)
+ );
+
+ // Only accept roots with a positive derivative
+ int n_valid_roots = 0;
+ for(int i = 0; i < 3; i++){
+ float r = all_roots[i];
+ if(3*r*r + 2*b*r + c > 0){
+ roots[n_valid_roots] = r;
+ n_valid_roots++;
+ }
+ }
+ return n_valid_roots;
+}
+
+float dist_to_line(vec2 p, vec2 b2){
+ float t = clamp(p.x / b2.x, 0, 1);
+ float dist;
+ if(t == 0) dist = length(p);
+ else if(t == 1) dist = distance(p, b2);
+ else dist = abs(p.y);
+
+ return modify_distance_for_endpoints(p, dist, t);
+}
+
+
+float dist_to_point_on_curve(vec2 p, float t, vec2 b2){
+ t = clamp(t, 0, 1);
+ return modify_distance_for_endpoints(
+ p, length(p - bezier(t, b2)), t
+ );
+}
+
+
+float min_dist_to_curve(vec2 p, vec2 b2, float degree){
+ // Check if curve is really a a line
+ if(degree == 1) return dist_to_line(p, b2);
+
+ // Try finding the exact sdf by solving the equation
+ // (d/dt) dist^2(t) = 0, which amount to the following
+ // cubic.
+ float xm2 = uv_b2.x - 2.0;
+ float y = uv_b2.y;
+ float a = xm2*xm2 + y*y;
+ float b = 3 * xm2;
+ float c = -(p.x*xm2 + p.y*y) + 2;
+ float d = -p.x;
+
+ float roots[3];
+ int n = cubic_solve(a, b, c, d, roots);
+ // At most 2 roots will have been populated.
+ float d0 = dist_to_point_on_curve(p, roots[0], b2);
+ if(n == 1) return d0;
+ float d1 = dist_to_point_on_curve(p, roots[1], b2);
+ return min(d0, d1);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/include/quadratic_bezier_geometry_functions.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/quadratic_bezier_geometry_functions.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..d2e3e0fb7147798b5096aec83f6454c14f7a5176
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/include/quadratic_bezier_geometry_functions.glsl
@@ -0,0 +1,92 @@
+float cross2d(vec2 v, vec2 w){
+ return v.x * w.y - w.x * v.y;
+}
+
+
+mat3 get_xy_to_uv(vec2 b0, vec2 b1){
+ mat3 shift = mat3(
+ 1.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0,
+ -b0.x, -b0.y, 1.0
+ );
+
+ float sf = length(b1 - b0);
+ vec2 I = (b1 - b0) / sf;
+ vec2 J = vec2(-I.y, I.x);
+ mat3 rotate = mat3(
+ I.x, J.x, 0.0,
+ I.y, J.y, 0.0,
+ 0.0, 0.0, 1.0
+ );
+ return (1 / sf) * rotate * shift;
+}
+
+
+// Orthogonal matrix to convert to a uv space defined so that
+// b0 goes to [0, 0] and b1 goes to [1, 0]
+mat4 get_xyz_to_uv(vec3 b0, vec3 b1, vec3 unit_normal){
+ mat4 shift = mat4(
+ 1, 0, 0, 0,
+ 0, 1, 0, 0,
+ 0, 0, 1, 0,
+ -b0.x, -b0.y, -b0.z, 1
+ );
+
+ float scale_factor = length(b1 - b0);
+ vec3 I = (b1 - b0) / scale_factor;
+ vec3 K = unit_normal;
+ vec3 J = cross(K, I);
+ // Transpose (hence inverse) of matrix taking
+ // i-hat to I, k-hat to unit_normal, and j-hat to their cross
+ mat4 rotate = mat4(
+ I.x, J.x, K.x, 0.0,
+ I.y, J.y, K.y, 0.0,
+ I.z, J.z, K.z, 0.0,
+ 0.0, 0.0, 0.0, 1.0
+ );
+ return (1 / scale_factor) * rotate * shift;
+}
+
+
+// Returns 0 for null curve, 1 for linear, 2 for quadratic.
+// Populates new_points with bezier control points for the curve,
+// which for quadratics will be the same, but for linear and null
+// might change. The idea is to inform the caller of the degree,
+// while also passing tangency information in the linear case.
+// float get_reduced_control_points(vec3 b0, vec3 b1, vec3 b2, out vec3 new_points[3]){
+float get_reduced_control_points(in vec3 points[3], out vec3 new_points[3]){
+ float length_threshold = 1e-6;
+ float angle_threshold = 5e-2;
+
+ vec3 p0 = points[0];
+ vec3 p1 = points[1];
+ vec3 p2 = points[2];
+ vec3 v01 = (p1 - p0);
+ vec3 v12 = (p2 - p1);
+
+ float dot_prod = clamp(dot(normalize(v01), normalize(v12)), -1, 1);
+ bool aligned = acos(dot_prod) < angle_threshold;
+ bool distinct_01 = length(v01) > length_threshold; // v01 is considered nonzero
+ bool distinct_12 = length(v12) > length_threshold; // v12 is considered nonzero
+ int n_uniques = int(distinct_01) + int(distinct_12);
+
+ bool quadratic = (n_uniques == 2) && !aligned;
+ bool linear = (n_uniques == 1) || ((n_uniques == 2) && aligned);
+ bool constant = (n_uniques == 0);
+ if(quadratic){
+ new_points[0] = p0;
+ new_points[1] = p1;
+ new_points[2] = p2;
+ return 2.0;
+ }else if(linear){
+ new_points[0] = p0;
+ new_points[1] = (p0 + p2) / 2.0;
+ new_points[2] = p2;
+ return 1.0;
+ }else{
+ new_points[0] = p0;
+ new_points[1] = p0;
+ new_points[2] = p0;
+ return 0.0;
+ }
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/manim_coords/frag.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/manim_coords/frag.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..2a721a51eaeab88474077f2af6a8cdc9d7815293
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/manim_coords/frag.glsl
@@ -0,0 +1,8 @@
+#version 330
+
+uniform vec4 u_color;
+out vec4 frag_color;
+
+void main() {
+ frag_color = u_color;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/manim_coords/vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/manim_coords/vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..e12bd25a37953ea12e40798535ed42b5a2944021
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/manim_coords/vert.glsl
@@ -0,0 +1,11 @@
+#version 330
+
+in vec4 in_vert;
+uniform mat4 u_model_view_matrix;
+uniform mat4 u_projection_matrix;
+
+void main() {
+ vec4 camera_space_vertex = u_model_view_matrix * in_vert;
+ vec4 clip_space_vertex = u_projection_matrix * camera_space_vertex;
+ gl_Position = clip_space_vertex;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_fill/frag.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_fill/frag.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..28a1879799129e5ad5d20422b82926ee73286231
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_fill/frag.glsl
@@ -0,0 +1,66 @@
+#version 330
+
+#include ../include/camera_uniform_declarations.glsl
+
+in vec4 color;
+in float fill_all; // Either 0 or 1e
+in float uv_anti_alias_width;
+
+in vec3 xyz_coords;
+in float orientation;
+in vec2 uv_coords;
+in vec2 uv_b2;
+in float bezier_degree;
+
+out vec4 frag_color;
+
+// Needed for quadratic_bezier_distance insertion below
+float modify_distance_for_endpoints(vec2 p, float dist, float t){
+ return dist;
+}
+
+#include ../include/quadratic_bezier_distance.glsl
+
+
+float sdf(){
+ if(bezier_degree < 2){
+ return abs(uv_coords[1]);
+ }
+ float u2 = uv_b2.x;
+ float v2 = uv_b2.y;
+ // For really flat curves, just take the distance to x-axis
+ if(abs(v2 / u2) < 0.1 * uv_anti_alias_width){
+ return abs(uv_coords[1]);
+ }
+ // For flat-ish curves, take the curve
+ else if(abs(v2 / u2) < 0.5 * uv_anti_alias_width){
+ return min_dist_to_curve(uv_coords, uv_b2, bezier_degree);
+ }
+ // I know, I don't love this amount of arbitrary-seeming branching either,
+ // but a number of strange dimples and bugs pop up otherwise.
+
+ // This converts uv_coords to yet another space where the bezier points sit on
+ // (0, 0), (1/2, 0) and (1, 1), so that the curve can be expressed implicityly
+ // as y = x^2.
+ mat2 to_simple_space = mat2(
+ v2, 0,
+ 2 - u2, 4 * v2
+ );
+ vec2 p = to_simple_space * uv_coords;
+ // Sign takes care of whether we should be filling the inside or outside of curve.
+ float sgn = orientation * sign(v2);
+ float Fp = (p.x * p.x - p.y);
+ if(sgn * Fp < 0){
+ return 0.0;
+ }else{
+ return min_dist_to_curve(uv_coords, uv_b2, bezier_degree);
+ }
+}
+
+
+void main() {
+ if (color.a == 0) discard;
+ frag_color = color;
+ if (fill_all == 1.0) return;
+ frag_color.a *= smoothstep(1, 0, sdf() / uv_anti_alias_width);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_fill/geom.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_fill/geom.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..b6a9fceea27c6f320e04c1fdd53afdaad6e5b1f3
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_fill/geom.glsl
@@ -0,0 +1,135 @@
+#version 330
+
+layout (triangles) in;
+layout (triangle_strip, max_vertices = 5) out;
+
+uniform float anti_alias_width;
+
+// Needed for get_gl_Position
+uniform vec2 frame_shape;
+uniform float focal_distance;
+uniform float is_fixed_in_frame;
+uniform float is_fixed_orientation;
+uniform vec3 fixed_orientation_center;
+// Needed for finalize_color
+uniform vec3 light_source_position;
+uniform float gloss;
+uniform float shadow;
+
+in vec3 bp[3];
+in vec3 v_global_unit_normal[3];
+in vec4 v_color[3];
+in float v_vert_index[3];
+
+out vec4 color;
+out float fill_all;
+out float uv_anti_alias_width;
+
+out vec3 xyz_coords;
+out float orientation;
+// uv space is where b0 = (0, 0), b1 = (1, 0), and transform is orthogonal
+out vec2 uv_coords;
+out vec2 uv_b2;
+out float bezier_degree;
+
+
+// Analog of import for manim only
+#include ../include/quadratic_bezier_geometry_functions.glsl
+#include ../include/get_gl_Position.glsl
+#include ../include/get_unit_normal.glsl
+#include ../include/finalize_color.glsl
+
+
+void emit_vertex_wrapper(vec3 point, int index){
+ color = finalize_color(
+ v_color[index],
+ point,
+ v_global_unit_normal[index],
+ light_source_position,
+ gloss,
+ shadow
+ );
+ xyz_coords = point;
+ gl_Position = get_gl_Position(xyz_coords);
+ EmitVertex();
+}
+
+
+void emit_simple_triangle(){
+ for(int i = 0; i < 3; i++){
+ emit_vertex_wrapper(bp[i], i);
+ }
+ EndPrimitive();
+}
+
+
+void emit_pentagon(vec3[3] points, vec3 normal){
+ vec3 p0 = points[0];
+ vec3 p1 = points[1];
+ vec3 p2 = points[2];
+ // Tangent vectors
+ vec3 t01 = normalize(p1 - p0);
+ vec3 t12 = normalize(p2 - p1);
+ // Vectors perpendicular to the curve in the plane of the curve pointing outside the curve
+ vec3 p0_perp = cross(t01, normal);
+ vec3 p2_perp = cross(t12, normal);
+
+ bool fill_inside = orientation > 0;
+ float aaw = anti_alias_width;
+ vec3 corners[5];
+ if(fill_inside){
+ // Note, straight lines will also fall into this case, and since p0_perp and p2_perp
+ // will point to the right of the curve, it's just what we want
+ corners = vec3[5](
+ p0 + aaw * p0_perp,
+ p0,
+ p1 + 0.5 * aaw * (p0_perp + p2_perp),
+ p2,
+ p2 + aaw * p2_perp
+ );
+ }else{
+ corners = vec3[5](
+ p0,
+ p0 - aaw * p0_perp,
+ p1,
+ p2 - aaw * p2_perp,
+ p2
+ );
+ }
+
+ mat4 xyz_to_uv = get_xyz_to_uv(p0, p1, normal);
+ uv_b2 = (xyz_to_uv * vec4(p2, 1)).xy;
+ uv_anti_alias_width = anti_alias_width / length(p1 - p0);
+
+ for(int i = 0; i < 5; i++){
+ vec3 corner = corners[i];
+ uv_coords = (xyz_to_uv * vec4(corner, 1)).xy;
+ int j = int(sign(i - 1) + 1); // Maps i = [0, 1, 2, 3, 4] onto j = [0, 0, 1, 2, 2]
+ emit_vertex_wrapper(corner, j);
+ }
+ EndPrimitive();
+}
+
+
+void main(){
+ // If vert indices are sequential, don't fill all
+ fill_all = float(
+ (v_vert_index[1] - v_vert_index[0]) != 1.0 ||
+ (v_vert_index[2] - v_vert_index[1]) != 1.0
+ );
+
+ if(fill_all == 1.0){
+ emit_simple_triangle();
+ return;
+ }
+
+ vec3 new_bp[3];
+ bezier_degree = get_reduced_control_points(vec3[3](bp[0], bp[1], bp[2]), new_bp);
+ vec3 local_unit_normal = get_unit_normal(new_bp);
+ orientation = sign(dot(v_global_unit_normal[0], local_unit_normal));
+
+ if(bezier_degree >= 1){
+ emit_pentagon(new_bp, local_unit_normal);
+ }
+ // Don't emit any vertices for bezier_degree 0
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_fill/vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_fill/vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..e8913398871cbfc1e605d06b05df38ea226210d9
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_fill/vert.glsl
@@ -0,0 +1,23 @@
+#version 330
+
+#include ../include/camera_uniform_declarations.glsl
+
+in vec3 point;
+in vec3 unit_normal;
+in vec4 color;
+in float vert_index;
+
+out vec3 bp; // Bezier control point
+out vec3 v_global_unit_normal;
+out vec4 v_color;
+out float v_vert_index;
+
+// Analog of import for manim only
+#include ../include/position_point_into_frame.glsl
+
+void main(){
+ bp = position_point_into_frame(point.xyz);
+ v_global_unit_normal = rotate_point_into_frame(unit_normal.xyz);
+ v_color = color;
+ v_vert_index = vert_index;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_stroke/frag.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_stroke/frag.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..8cf383a058f318887844a4845738abb87da647e6
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_stroke/frag.glsl
@@ -0,0 +1,93 @@
+#version 330
+
+#include ../include/camera_uniform_declarations.glsl
+
+in vec2 uv_coords;
+in vec2 uv_b2;
+
+in float uv_stroke_width;
+in vec4 color;
+in float uv_anti_alias_width;
+
+in float has_prev;
+in float has_next;
+in float bevel_start;
+in float bevel_end;
+in float angle_from_prev;
+in float angle_to_next;
+
+in float bezier_degree;
+
+out vec4 frag_color;
+
+
+float cross2d(vec2 v, vec2 w){
+ return v.x * w.y - w.x * v.y;
+}
+
+
+float modify_distance_for_endpoints(vec2 p, float dist, float t){
+ float buff = 0.5 * uv_stroke_width - uv_anti_alias_width;
+ // Check the beginning of the curve
+ if(t == 0){
+ // Clip the start
+ if(has_prev == 0) return max(dist, -p.x + buff);
+ // Bevel start
+ if(bevel_start == 1){
+ float a = angle_from_prev;
+ mat2 rot = mat2(
+ cos(a), sin(a),
+ -sin(a), cos(a)
+ );
+ // Dist for intersection of two lines
+ float bevel_d = max(abs(p.y), abs((rot * p).y));
+ // Dist for union of this intersection with the real curve
+ // intersected with radius 2 away from curve to smooth out
+ // really sharp corners
+ return max(min(dist, bevel_d), dist / 2);
+ }
+ // Otherwise, start will be rounded off
+ }else if(t == 1){
+ // Check the end of the curve
+ // TODO, too much code repetition
+ vec2 v21 = (bezier_degree == 2) ? vec2(1, 0) - uv_b2 : vec2(-1, 0);
+ float len_v21 = length(v21);
+ if(len_v21 == 0){
+ v21 = -uv_b2;
+ len_v21 = length(v21);
+ }
+
+ float perp_dist = dot(p - uv_b2, v21) / len_v21;
+ if(has_next == 0) return max(dist, -perp_dist + buff);
+ // Bevel end
+ if(bevel_end == 1){
+ float a = -angle_to_next;
+ mat2 rot = mat2(
+ cos(a), sin(a),
+ -sin(a), cos(a)
+ );
+ vec2 v21_unit = v21 / length(v21);
+ float bevel_d = max(
+ abs(cross2d(p - uv_b2, v21_unit)),
+ abs(cross2d((rot * (p - uv_b2)), v21_unit))
+ );
+ return max(min(dist, bevel_d), dist / 2);
+ }
+ // Otherwise, end will be rounded off
+ }
+ return dist;
+}
+
+
+#include ../include/quadratic_bezier_distance.glsl
+
+
+void main() {
+ if (uv_stroke_width == 0) discard;
+ float dist_to_curve = min_dist_to_curve(uv_coords, uv_b2, bezier_degree);
+ // An sdf for the region around the curve we wish to color.
+ float signed_dist = abs(dist_to_curve) - 0.5 * uv_stroke_width;
+
+ frag_color = color;
+ frag_color.a *= smoothstep(0.5, -0.5, signed_dist / uv_anti_alias_width);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_stroke/geom.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_stroke/geom.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..2433142410fce75f35baf58d6f8735b475942e29
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_stroke/geom.glsl
@@ -0,0 +1,274 @@
+#version 330
+
+layout (triangles) in;
+layout (triangle_strip, max_vertices = 5) out;
+
+// Needed for get_gl_Position
+uniform vec2 frame_shape;
+uniform float focal_distance;
+uniform float is_fixed_in_frame;
+uniform float is_fixed_orientation;
+uniform vec3 fixed_orientation_center;
+
+uniform float anti_alias_width;
+uniform float flat_stroke;
+
+//Needed for lighting
+uniform vec3 light_source_position;
+uniform float joint_type;
+uniform float gloss;
+uniform float shadow;
+
+in vec3 bp[3];
+in vec3 prev_bp[3];
+in vec3 next_bp[3];
+in vec3 v_global_unit_normal[3];
+
+in vec4 v_color[3];
+in float v_stroke_width[3];
+
+out vec4 color;
+out float uv_stroke_width;
+out float uv_anti_alias_width;
+
+out float has_prev;
+out float has_next;
+out float bevel_start;
+out float bevel_end;
+out float angle_from_prev;
+out float angle_to_next;
+
+out float bezier_degree;
+
+out vec2 uv_coords;
+out vec2 uv_b2;
+
+// Codes for joint types
+const float AUTO_JOINT = 0;
+const float ROUND_JOINT = 1;
+const float BEVEL_JOINT = 2;
+const float MITER_JOINT = 3;
+const float PI = 3.141592653;
+
+
+#include ../include/quadratic_bezier_geometry_functions.glsl
+#include ../include/get_gl_Position.glsl
+#include ../include/get_unit_normal.glsl
+#include ../include/finalize_color.glsl
+
+
+void flatten_points(in vec3[3] points, out vec2[3] flat_points){
+ for(int i = 0; i < 3; i++){
+ float sf = perspective_scale_factor(points[i].z, focal_distance);
+ flat_points[i] = sf * points[i].xy;
+ }
+}
+
+
+float angle_between_vectors(vec2 v1, vec2 v2){
+ float v1_norm = length(v1);
+ float v2_norm = length(v2);
+ if(v1_norm == 0 || v2_norm == 0) return 0.0;
+ float dp = dot(v1, v2) / (v1_norm * v2_norm);
+ float angle = acos(clamp(dp, -1.0, 1.0));
+ float sn = sign(cross2d(v1, v2));
+ return sn * angle;
+}
+
+
+bool find_intersection(vec2 p0, vec2 v0, vec2 p1, vec2 v1, out vec2 intersection){
+ // Find the intersection of a line passing through
+ // p0 in the direction v0 and one passing through p1 in
+ // the direction p1.
+ // That is, find a solutoin to p0 + v0 * t = p1 + v1 * s
+ float det = -v0.x * v1.y + v1.x * v0.y;
+ if(det == 0) return false;
+ float t = cross2d(p0 - p1, v1) / det;
+ intersection = p0 + v0 * t;
+ return true;
+}
+
+
+void create_joint(float angle, vec2 unit_tan, float buff,
+ vec2 static_c0, out vec2 changing_c0,
+ vec2 static_c1, out vec2 changing_c1){
+ float shift;
+ if(abs(angle) < 1e-3){
+ // No joint
+ shift = 0;
+ }else if(joint_type == MITER_JOINT){
+ shift = buff * (-1.0 - cos(angle)) / sin(angle);
+ }else{
+ // For a Bevel joint
+ shift = buff * (1.0 - cos(angle)) / sin(angle);
+ }
+ changing_c0 = static_c0 - shift * unit_tan;
+ changing_c1 = static_c1 + shift * unit_tan;
+}
+
+
+// This function is responsible for finding the corners of
+// a bounding region around the bezier curve, which can be
+// emitted as a triangle fan
+int get_corners(vec2 controls[3], int degree, float stroke_widths[3], out vec2 corners[5]){
+ vec2 p0 = controls[0];
+ vec2 p1 = controls[1];
+ vec2 p2 = controls[2];
+
+ // Unit vectors for directions between control points
+ vec2 v10 = normalize(p0 - p1);
+ vec2 v12 = normalize(p2 - p1);
+ vec2 v01 = -v10;
+ vec2 v21 = -v12;
+
+ vec2 p0_perp = vec2(-v01.y, v01.x); // Pointing to the left of the curve from p0
+ vec2 p2_perp = vec2(-v12.y, v12.x); // Pointing to the left of the curve from p2
+
+ // aaw is the added width given around the polygon for antialiasing.
+ // In case the normal is faced away from (0, 0, 1), the vector to the
+ // camera, this is scaled up.
+ float aaw = anti_alias_width;
+ float buff0 = 0.5 * stroke_widths[0] + aaw;
+ float buff2 = 0.5 * stroke_widths[2] + aaw;
+ float aaw0 = (1 - has_prev) * aaw;
+ float aaw2 = (1 - has_next) * aaw;
+
+ vec2 c0 = p0 - buff0 * p0_perp + aaw0 * v10;
+ vec2 c1 = p0 + buff0 * p0_perp + aaw0 * v10;
+ vec2 c2 = p2 + buff2 * p2_perp + aaw2 * v12;
+ vec2 c3 = p2 - buff2 * p2_perp + aaw2 * v12;
+
+ // Account for previous and next control points
+ if(has_prev > 0) create_joint(angle_from_prev, v01, buff0, c0, c0, c1, c1);
+ if(has_next > 0) create_joint(angle_to_next, v21, buff2, c3, c3, c2, c2);
+
+ // Linear case is the simplest
+ if(degree == 1){
+ // The order of corners should be for a triangle_strip. Last entry is a dummy
+ corners = vec2[5](c0, c1, c3, c2, vec2(0.0));
+ return 4;
+ }
+ // Otherwise, form a pentagon around the curve
+ float orientation = sign(cross2d(v01, v12)); // Positive for ccw curves
+ if(orientation > 0) corners = vec2[5](c0, c1, p1, c2, c3);
+ else corners = vec2[5](c1, c0, p1, c3, c2);
+ // Replace corner[2] with convex hull point accounting for stroke width
+ find_intersection(corners[0], v01, corners[4], v21, corners[2]);
+ return 5;
+}
+
+
+void set_adjascent_info(vec2 c0, vec2 tangent,
+ int degree,
+ vec2 adj[3],
+ out float bevel,
+ out float angle
+ ){
+ bool linear_adj = (angle_between_vectors(adj[1] - adj[0], adj[2] - adj[1]) < 1e-3);
+ angle = angle_between_vectors(c0 - adj[1], tangent);
+ // Decide on joint type
+ bool one_linear = (degree == 1 || linear_adj);
+ bool should_bevel = (
+ (joint_type == AUTO_JOINT && one_linear) ||
+ joint_type == BEVEL_JOINT
+ );
+ bevel = should_bevel ? 1.0 : 0.0;
+}
+
+
+void find_joint_info(vec2 controls[3], vec2 prev[3], vec2 next[3], int degree){
+ float tol = 1e-6;
+
+ // Made as floats not bools so they can be passed to the frag shader
+ has_prev = float(distance(prev[2], controls[0]) < tol);
+ has_next = float(distance(next[0], controls[2]) < tol);
+
+ if(bool(has_prev)){
+ vec2 tangent = controls[1] - controls[0];
+ set_adjascent_info(
+ controls[0], tangent, degree, prev,
+ bevel_start, angle_from_prev
+ );
+ }
+ if(bool(has_next)){
+ vec2 tangent = controls[1] - controls[2];
+ set_adjascent_info(
+ controls[2], tangent, degree, next,
+ bevel_end, angle_to_next
+ );
+ angle_to_next *= -1;
+ }
+}
+
+
+void main() {
+ // Convert control points to a standard form if they are linear or null
+ vec3 controls[3];
+ vec3 prev[3];
+ vec3 next[3];
+ bezier_degree = get_reduced_control_points(vec3[3](bp[0], bp[1], bp[2]), controls);
+ if(bezier_degree == 0.0) return; // Null curve
+ int degree = int(bezier_degree);
+ get_reduced_control_points(vec3[3](prev_bp[0], prev_bp[1], prev_bp[2]), prev);
+ get_reduced_control_points(vec3[3](next_bp[0], next_bp[1], next_bp[2]), next);
+
+
+ // Adjust stroke width based on distance from the camera
+ float scaled_strokes[3];
+ for(int i = 0; i < 3; i++){
+ float sf = perspective_scale_factor(controls[i].z, focal_distance);
+ if(bool(flat_stroke)){
+ vec3 to_cam = normalize(vec3(0.0, 0.0, focal_distance) - controls[i]);
+ sf *= abs(dot(v_global_unit_normal[i], to_cam));
+ }
+ scaled_strokes[i] = v_stroke_width[i] * sf;
+ }
+
+ // Control points are projected to the xy plane before drawing, which in turn
+ // gets translated to a uv plane. The z-coordinate information will be remembered
+ // by what's sent out to gl_Position, and by how it affects the lighting and stroke width
+ vec2 flat_controls[3];
+ vec2 flat_prev[3];
+ vec2 flat_next[3];
+ flatten_points(controls, flat_controls);
+ flatten_points(prev, flat_prev);
+ flatten_points(next, flat_next);
+
+ find_joint_info(flat_controls, flat_prev, flat_next, degree);
+
+ // Corners of a bounding region around curve
+ vec2 corners[5];
+ int n_corners = get_corners(flat_controls, degree, scaled_strokes, corners);
+
+ int index_map[5] = int[5](0, 0, 1, 2, 2);
+ if(n_corners == 4) index_map[2] = 2;
+
+ // Find uv conversion matrix
+ mat3 xy_to_uv = get_xy_to_uv(flat_controls[0], flat_controls[1]);
+ float scale_factor = length(flat_controls[1] - flat_controls[0]);
+ uv_anti_alias_width = anti_alias_width / scale_factor;
+ uv_b2 = (xy_to_uv * vec3(flat_controls[2], 1.0)).xy;
+
+ // Emit each corner
+ for(int i = 0; i < n_corners; i++){
+ uv_coords = (xy_to_uv * vec3(corners[i], 1.0)).xy;
+ uv_stroke_width = scaled_strokes[index_map[i]] / scale_factor;
+ // Apply some lighting to the color before sending out.
+ // vec3 xyz_coords = vec3(corners[i], controls[index_map[i]].z);
+ vec3 xyz_coords = vec3(corners[i], controls[index_map[i]].z);
+ color = finalize_color(
+ v_color[index_map[i]],
+ xyz_coords,
+ v_global_unit_normal[index_map[i]],
+ light_source_position,
+ gloss,
+ shadow
+ );
+ gl_Position = vec4(
+ get_gl_Position(vec3(corners[i], 0.0)).xy,
+ get_gl_Position(controls[index_map[i]]).zw
+ );
+ EmitVertex();
+ }
+ EndPrimitive();
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_stroke/vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_stroke/vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..4ed9d0a7e21f6acfa422260fb6f5c6522c6b83f4
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/quadratic_bezier_stroke/vert.glsl
@@ -0,0 +1,34 @@
+#version 330
+
+#include ../include/camera_uniform_declarations.glsl
+
+in vec3 point;
+in vec3 prev_point;
+in vec3 next_point;
+in vec3 unit_normal;
+
+in float stroke_width;
+in vec4 color;
+
+// Bezier control point
+out vec3 bp;
+out vec3 prev_bp;
+out vec3 next_bp;
+out vec3 v_global_unit_normal;
+
+out float v_stroke_width;
+out vec4 v_color;
+
+const float STROKE_WIDTH_CONVERSION = 0.01;
+
+#include ../include/position_point_into_frame.glsl
+
+void main(){
+ bp = position_point_into_frame(point);
+ prev_bp = position_point_into_frame(prev_point);
+ next_bp = position_point_into_frame(next_point);
+ v_global_unit_normal = rotate_point_into_frame(unit_normal);
+
+ v_stroke_width = STROKE_WIDTH_CONVERSION * stroke_width;
+ v_color = color;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/simple_vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/simple_vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..f3f8162ee3d6c7e58df94ee4f61d45163804ff68
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/simple_vert.glsl
@@ -0,0 +1,13 @@
+#version 330
+
+#include ../include/camera_uniform_declarations.glsl
+
+in vec3 point;
+
+// Analog of import for manim only
+#include ../include/get_gl_Position.glsl
+#include ../include/position_point_into_frame.glsl
+
+void main(){
+ gl_Position = get_gl_Position(position_point_into_frame(point));
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/surface/frag.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/surface/frag.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..fb7cee13d9cfef2de65366eb2f90fd47965bff0e
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/surface/frag.glsl
@@ -0,0 +1,24 @@
+#version 330
+
+uniform vec3 light_source_position;
+uniform float gloss;
+uniform float shadow;
+
+in vec3 xyz_coords;
+in vec3 v_normal;
+in vec4 v_color;
+
+out vec4 frag_color;
+
+#include ../include/finalize_color.glsl
+
+void main() {
+ frag_color = finalize_color(
+ v_color,
+ xyz_coords,
+ normalize(v_normal),
+ light_source_position,
+ gloss,
+ shadow
+ );
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/surface/vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/surface/vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..9f9293e7963e182fe5165531c5685385820d34af
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/surface/vert.glsl
@@ -0,0 +1,23 @@
+#version 330
+
+#include ../include/camera_uniform_declarations.glsl
+
+in vec3 point;
+in vec3 du_point;
+in vec3 dv_point;
+in vec4 color;
+
+out vec3 xyz_coords;
+out vec3 v_normal;
+out vec4 v_color;
+
+#include ../include/position_point_into_frame.glsl
+#include ../include/get_gl_Position.glsl
+#include ../include/get_rotated_surface_unit_normal_vector.glsl
+
+void main(){
+ xyz_coords = position_point_into_frame(point);
+ v_normal = get_rotated_surface_unit_normal_vector(point, du_point, dv_point);
+ v_color = color;
+ gl_Position = get_gl_Position(xyz_coords);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/test/frag.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/test/frag.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..2cf48d39c4cc816fd3c001b4b4285db13ad3e9d0
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/test/frag.glsl
@@ -0,0 +1,9 @@
+#version 330
+
+in vec4 v_color;
+
+out vec4 frag_color;
+
+void main() {
+ frag_color = v_color;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/test/vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/test/vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..850b85ce328537002a14020c1ef3d109435cc2ba
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/test/vert.glsl
@@ -0,0 +1,11 @@
+#version 330
+
+in vec2 in_vert;
+in vec4 in_color;
+
+out vec4 v_color;
+
+void main() {
+ v_color = in_color;
+ gl_Position = vec4(in_vert, 0.0, 1.0);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/textured_surface/frag.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/textured_surface/frag.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..ff162ffa71fae633c41d0dfc64280cf2cbd506f6
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/textured_surface/frag.glsl
@@ -0,0 +1,42 @@
+#version 330
+
+uniform sampler2D LightTexture;
+uniform sampler2D DarkTexture;
+uniform float num_textures;
+uniform vec3 light_source_position;
+uniform float gloss;
+uniform float shadow;
+
+in vec3 xyz_coords;
+in vec3 v_normal;
+in vec2 v_im_coords;
+in float v_opacity;
+
+out vec4 frag_color;
+
+#include ../include/finalize_color.glsl
+
+const float dark_shift = 0.2;
+
+void main() {
+ vec4 color = texture(LightTexture, v_im_coords);
+ if(num_textures == 2.0){
+ vec4 dark_color = texture(DarkTexture, v_im_coords);
+ float dp = dot(
+ normalize(light_source_position - xyz_coords),
+ normalize(v_normal)
+ );
+ float alpha = smoothstep(-dark_shift, dark_shift, dp);
+ color = mix(dark_color, color, alpha);
+ }
+
+ frag_color = finalize_color(
+ color,
+ xyz_coords,
+ normalize(v_normal),
+ light_source_position,
+ gloss,
+ shadow
+ );
+ frag_color.a = v_opacity;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/textured_surface/vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/textured_surface/vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..f0573ea39bea33041748c2b12bff4c66f14e1388
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/textured_surface/vert.glsl
@@ -0,0 +1,26 @@
+#version 330
+
+#include ../include/camera_uniform_declarations.glsl
+
+in vec3 point;
+in vec3 du_point;
+in vec3 dv_point;
+in vec2 im_coords;
+in float opacity;
+
+out vec3 xyz_coords;
+out vec3 v_normal;
+out vec2 v_im_coords;
+out float v_opacity;
+
+#include ../include/position_point_into_frame.glsl
+#include ../include/get_gl_Position.glsl
+#include ../include/get_rotated_surface_unit_normal_vector.glsl
+
+void main(){
+ xyz_coords = position_point_into_frame(point);
+ v_normal = get_rotated_surface_unit_normal_vector(point, du_point, dv_point);
+ v_im_coords = im_coords;
+ v_opacity = opacity;
+ gl_Position = get_gl_Position(xyz_coords);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/true_dot/frag.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/true_dot/frag.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..e5838ef7c665a074359105aafe0db53f167eabe0
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/true_dot/frag.glsl
@@ -0,0 +1,34 @@
+#version 330
+
+uniform vec3 light_source_position;
+uniform float gloss;
+uniform float shadow;
+uniform float anti_alias_width;
+
+in vec4 color;
+in float point_radius;
+in vec2 center;
+in vec2 point;
+
+out vec4 frag_color;
+
+#include ../include/finalize_color.glsl
+
+void main() {
+ vec2 diff = point - center;
+ float dist = length(diff);
+ float signed_dist = dist - point_radius;
+ if (signed_dist > 0.5 * anti_alias_width){
+ discard;
+ }
+ vec3 normal = vec3(diff / point_radius, sqrt(1 - (dist * dist) / (point_radius * point_radius)));
+ frag_color = finalize_color(
+ color,
+ vec3(point.xy, 0.0),
+ normal,
+ light_source_position,
+ gloss,
+ shadow
+ );
+ frag_color.a *= smoothstep(0.5, -0.5, signed_dist / anti_alias_width);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/true_dot/geom.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/true_dot/geom.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..beca4029e6c928d2b61ecdc6a588780da0367e10
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/true_dot/geom.glsl
@@ -0,0 +1,45 @@
+#version 330
+
+layout (points) in;
+layout (triangle_strip, max_vertices = 4) out;
+
+// Needed for get_gl_Position
+uniform vec2 frame_shape;
+uniform float focal_distance;
+uniform float is_fixed_in_frame;
+uniform float is_fixed_orientation;
+uniform vec3 fixed_orientation_center;
+uniform float anti_alias_width;
+
+in vec3 v_point[1];
+in float v_point_radius[1];
+in vec4 v_color[1];
+
+out vec4 color;
+out float point_radius;
+out vec2 center;
+out vec2 point;
+
+#include ../include/get_gl_Position.glsl
+
+void main() {
+ color = v_color[0];
+ point_radius = v_point_radius[0];
+ center = v_point[0].xy;
+
+ point_radius = v_point_radius[0] / max(1.0 - v_point[0].z / focal_distance / frame_shape.y, 0.0);
+ float rpa = point_radius + anti_alias_width;
+
+ for(int i = 0; i < 4; i++){
+ // To account for perspective
+
+ int x_index = 2 * (i % 2) - 1;
+ int y_index = 2 * (i / 2) - 1;
+ vec3 corner = v_point[0] + vec3(x_index * rpa, y_index * rpa, 0.0);
+
+ gl_Position = get_gl_Position(corner);
+ point = corner.xy;
+ EmitVertex();
+ }
+ EndPrimitive();
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/true_dot/vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/true_dot/vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..4f071018e3672b1d14863ce80d3fa994d7464118
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/true_dot/vert.glsl
@@ -0,0 +1,20 @@
+#version 330
+
+#include ../include/camera_uniform_declarations.glsl
+
+in vec3 point;
+in vec4 color;
+
+uniform float point_radius;
+
+out vec3 v_point;
+out float v_point_radius;
+out vec4 v_color;
+
+#include ../include/position_point_into_frame.glsl
+
+void main(){
+ v_point = position_point_into_frame(point);
+ v_point_radius = point_radius;
+ v_color = color;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/vectorized_mobject_fill/frag.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/vectorized_mobject_fill/frag.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..70887f2874daaf07c816ce07080b6dd07159a0e1
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/vectorized_mobject_fill/frag.glsl
@@ -0,0 +1,16 @@
+#version 330
+
+in vec4 v_color;
+in vec2 v_texture_coords;
+flat in int v_texture_mode;
+
+out vec4 frag_color;
+
+void main() {
+ float curve_func = v_texture_coords[0] * v_texture_coords[0] - v_texture_coords[1];
+ if (v_texture_mode * curve_func >= 0.0) {
+ frag_color = v_color;
+ } else {
+ discard;
+ }
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/vectorized_mobject_fill/vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/vectorized_mobject_fill/vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..9456665f144c01172187f49498c87ceb28727864
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/vectorized_mobject_fill/vert.glsl
@@ -0,0 +1,20 @@
+#version 330
+
+uniform mat4 u_model_view_matrix;
+uniform mat4 u_projection_matrix;
+
+in vec3 in_vert;
+in vec4 in_color;
+in vec2 texture_coords;
+in int texture_mode;
+
+out vec4 v_color;
+out vec2 v_texture_coords;
+flat out int v_texture_mode;
+
+void main() {
+ v_color = in_color;
+ v_texture_coords = texture_coords;
+ v_texture_mode = texture_mode;
+ gl_Position = u_projection_matrix * u_model_view_matrix * vec4(in_vert, 1.0);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/vectorized_mobject_stroke/frag.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/vectorized_mobject_stroke/frag.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..2eca6f163cfe64093923de3e219704f3f6dd8930
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/vectorized_mobject_stroke/frag.glsl
@@ -0,0 +1,85 @@
+#version 330
+
+in float v_degree;
+in float v_thickness;
+in vec2 uv_point;
+in vec2[3] uv_curve;
+in vec4 v_color;
+
+out vec4 frag_color;
+
+// https://www.shadertoy.com/view/ltXSDB
+// Test if point p crosses line (a, b), returns sign of result
+float testCross(vec2 a, vec2 b, vec2 p) {
+ return sign((b.y-a.y) * (p.x-a.x) - (b.x-a.x) * (p.y-a.y));
+}
+
+// Determine which side we're on (using barycentric parameterization)
+float signBezier(vec2 A, vec2 B, vec2 C, vec2 p)
+{
+ vec2 a = C - A, b = B - A, c = p - A;
+ vec2 bary = vec2(c.x*b.y-b.x*c.y,a.x*c.y-c.x*a.y) / (a.x*b.y-b.x*a.y);
+ vec2 d = vec2(bary.y * 0.5, 0.0) + 1.0 - bary.x - bary.y;
+ return mix(sign(d.x * d.x - d.y), mix(-1.0, 1.0,
+ step(testCross(A, B, p) * testCross(B, C, p), 0.0)),
+ step((d.x - d.y), 0.0)) * testCross(A, C, B);
+}
+
+// Solve cubic equation for roots
+vec3 solveCubic(float a, float b, float c)
+{
+ float p = b - a*a / 3.0, p3 = p*p*p;
+ float q = a * (2.0*a*a - 9.0*b) / 27.0 + c;
+ float d = q*q + 4.0*p3 / 27.0;
+ float offset = -a / 3.0;
+ if(d >= 0.0) {
+ float z = sqrt(d);
+ vec2 x = (vec2(z, -z) - q) / 2.0;
+ vec2 uv = sign(x)*pow(abs(x), vec2(1.0/3.0));
+ return vec3(offset + uv.x + uv.y);
+ }
+ float v = acos(-sqrt(-27.0 / p3) * q / 2.0) / 3.0;
+ float m = cos(v), n = sin(v)*1.732050808;
+ return vec3(m + m, -n - m, n - m) * sqrt(-p / 3.0) + offset;
+}
+
+// Find the signed distance from a point to a bezier curve
+float sdBezier(vec2 A, vec2 B, vec2 C, vec2 p)
+{
+ B = mix(B + vec2(1e-4), B, abs(sign(B * 2.0 - A - C)));
+ vec2 a = B - A, b = A - B * 2.0 + C, c = a * 2.0, d = A - p;
+ vec3 k = vec3(3.*dot(a,b),2.*dot(a,a)+dot(d,b),dot(d,a)) / dot(b,b);
+ vec3 t = clamp(solveCubic(k.x, k.y, k.z), 0.0, 1.0);
+ vec2 pos = A + (c + b*t.x)*t.x;
+ float dis = length(pos - p);
+ pos = A + (c + b*t.y)*t.y;
+ dis = min(dis, length(pos - p));
+ pos = A + (c + b*t.z)*t.z;
+ dis = min(dis, length(pos - p));
+ return dis * signBezier(A, B, C, p);
+}
+
+// https://www.shadertoy.com/view/llcfR7
+float dLine(vec2 p1, vec2 p2, vec2 x) {
+ vec4 colA = vec4(clamp (5.0 - length (x - p1), 0.0, 1.0));
+ vec4 colB = vec4(clamp (5.0 - length (x - p2), 0.0, 1.0));
+
+ vec2 a_p1 = x - p1;
+ vec2 p2_p1 = p2 - p1;
+ float h = clamp (dot (a_p1, p2_p1) / dot (p2_p1, p2_p1), 0.0, 1.0);
+ return length (a_p1 - p2_p1 * h);
+}
+
+void main() {
+ float distance;
+ if (v_degree == 2.0) {
+ distance = sdBezier(uv_curve[0], uv_curve[1], uv_curve[2], uv_point);
+ } else {
+ distance = dLine(uv_curve[0], uv_curve[2], uv_point);
+ }
+ if (abs(distance) < v_thickness) {
+ frag_color = v_color;
+ } else {
+ discard;
+ }
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/vectorized_mobject_stroke/vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/vectorized_mobject_stroke/vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..63982ee71f6deee172a63e7a52ffc2077cc6da6f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/vectorized_mobject_stroke/vert.glsl
@@ -0,0 +1,125 @@
+#version 330
+
+uniform vec3 manim_unit_normal;
+uniform mat4 u_model_view_matrix;
+uniform mat4 u_projection_matrix;
+
+in vec3[3] current_curve;
+in vec2 tile_coordinate;
+in vec4 in_color;
+in float in_width;
+
+out float v_degree;
+out float v_thickness;
+out vec2 uv_point;
+out vec2[3] uv_curve;
+out vec4 v_color;
+
+int get_degree(in vec3 points[3], out vec3 normal) {
+ float length_threshold = 1e-6;
+ float angle_threshold = 5e-2;
+
+ vec3 v01 = (points[1] - points[0]);
+ vec3 v12 = (points[2] - points[1]);
+
+ float dot_prod = clamp(dot(normalize(v01), normalize(v12)), -1, 1);
+ bool aligned = acos(dot_prod) < angle_threshold;
+ bool distinct_01 = length(v01) > length_threshold; // v01 is considered nonzero
+ bool distinct_12 = length(v12) > length_threshold; // v12 is considered nonzero
+ int num_distinct = int(distinct_01) + int(distinct_12);
+
+ bool quadratic = (num_distinct == 2) && !aligned;
+ bool linear = (num_distinct == 1) || ((num_distinct == 2) && aligned);
+ bool constant = (num_distinct == 0);
+
+ if (quadratic) {
+ // If the curve is quadratic pass a normal vector to the caller.
+ normal = normalize(cross(v01, v12));
+ return 2;
+ } else if (linear) {
+ return 1;
+ } else {
+ return 0;
+ }
+}
+
+// https://iquilezles.org/www/articles/bezierbbox/bezierbbox.htm
+vec4 bboxBezier(in vec2 p0, in vec2 p1, in vec2 p2) {
+ vec2 mi = min(p0, p2);
+ vec2 ma = max(p0, p2);
+
+ if (p1.x < mi.x || p1.x > ma.x || p1.y < mi.y || p1.y > ma.y) {
+ vec2 t = clamp((p0 - p1) / (p0 - 2.0 * p1 + p2), 0.0, 1.0);
+ vec2 s = 1.0 - t;
+ vec2 q = s * s * p0 + 2.0 * s * t * p1 + t * t * p2;
+ mi = min(mi, q);
+ ma = max(ma, q);
+ }
+
+ return vec4(mi, ma);
+}
+
+vec2 convert_to_uv(vec3 x_unit, vec3 y_unit, vec3 point) {
+ return vec2(dot(point, x_unit), dot(point, y_unit));
+}
+
+vec3 convert_from_uv(vec3 translation, vec3 x_unit, vec3 y_unit, vec2 point) {
+ vec3 untranslated_point = point[0] * x_unit + point[1] * y_unit;
+ return untranslated_point + translation;
+}
+
+void main() {
+ float thickness_multiplier = 0.004;
+ v_color = in_color;
+
+ vec3 computed_normal;
+ v_degree = get_degree(current_curve, computed_normal);
+
+ vec3 tile_x_unit = normalize(current_curve[2] - current_curve[0]);
+ vec3 unit_normal;
+ vec3 tile_y_unit;
+ if (v_degree == 0) {
+ tile_y_unit = vec3(0.0, 0.0, 0.0);
+ } else if (v_degree == 1) {
+ // Since the curve forms a straight line there's no way to compute a normal.
+ unit_normal = manim_unit_normal;
+
+ tile_y_unit = cross(unit_normal, tile_x_unit);
+ } else {
+ // Prefer to use a computed normal vector rather than the one from manim.
+ unit_normal = computed_normal;
+
+ // Ensure tile_y_unit is pointing toward p1 from p0.
+ tile_y_unit = cross(unit_normal, tile_x_unit);
+ if (dot(tile_y_unit, current_curve[1] - current_curve[0]) < 0) {
+ tile_y_unit *= -1;
+ }
+ }
+
+ // Project the curve onto the tile.
+ for(int i = 0; i < 3; i++) {
+ uv_curve[i] = convert_to_uv(tile_x_unit, tile_y_unit, current_curve[i]);
+ }
+
+ // Compute the curve's bounding box.
+ vec4 uv_bounding_box = bboxBezier(uv_curve[0], uv_curve[1], uv_curve[2]);
+ vec3 tile_translation = unit_normal * dot(current_curve[0], unit_normal);
+ vec3 bounding_box_min = convert_from_uv(tile_translation, tile_x_unit, tile_y_unit, uv_bounding_box.xy);
+ vec3 bounding_box_max = convert_from_uv(tile_translation, tile_x_unit, tile_y_unit, uv_bounding_box.zw);
+ vec3 bounding_box_vec = bounding_box_max - bounding_box_min;
+ vec3 tile_origin = bounding_box_min;
+ vec3 tile_x_vec = tile_x_unit * dot(tile_x_unit, bounding_box_vec);
+ vec3 tile_y_vec = tile_y_unit * dot(tile_y_unit, bounding_box_vec);
+
+ // Expand the tile according to the line's thickness.
+ v_thickness = thickness_multiplier * in_width;
+ tile_origin = current_curve[0] - v_thickness * (tile_x_unit + tile_y_unit);
+ tile_x_vec += 2 * v_thickness * tile_x_unit;
+ tile_y_vec += 2 * v_thickness * tile_y_unit;
+
+ vec3 tile_point = tile_origin + \
+ tile_coordinate[0] * tile_x_vec + \
+ tile_coordinate[1] * tile_y_vec;
+ gl_Position = u_projection_matrix * u_model_view_matrix * vec4(tile_point, 1.0);
+ uv_point = convert_to_uv(tile_x_unit, tile_y_unit, tile_point);
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/vertex_colors/frag.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/vertex_colors/frag.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..dc5d0d76648bf0de04b572a83c1e53e0f4215f6e
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/vertex_colors/frag.glsl
@@ -0,0 +1,8 @@
+#version 330
+
+in vec4 v_color;
+out vec4 frag_color;
+
+void main() {
+ frag_color = v_color;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/shaders/vertex_colors/vert.glsl b/data/rag/manim_docs/manim_core/source/renderer/shaders/vertex_colors/vert.glsl
new file mode 100644
index 0000000000000000000000000000000000000000..944dc928068a38a223eb7966432d6eb7e1c565aa
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/shaders/vertex_colors/vert.glsl
@@ -0,0 +1,13 @@
+#version 330
+
+uniform mat4 u_model_matrix;
+uniform mat4 u_view_matrix;
+uniform mat4 u_projection_matrix;
+in vec4 in_vert;
+in vec4 in_color;
+out vec4 v_color;
+
+void main() {
+ v_color = in_color;
+ gl_Position = u_projection_matrix * u_view_matrix * u_model_matrix * in_vert;
+}
diff --git a/data/rag/manim_docs/manim_core/source/renderer/vectorized_mobject_rendering.py b/data/rag/manim_docs/manim_core/source/renderer/vectorized_mobject_rendering.py
new file mode 100644
index 0000000000000000000000000000000000000000..4cfd582d20f23ee8b7ccbfae757c43aef5398db9
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/renderer/vectorized_mobject_rendering.py
@@ -0,0 +1,287 @@
+from __future__ import annotations
+
+import collections
+
+import numpy as np
+
+from ..utils import opengl
+from ..utils.space_ops import cross2d, earclip_triangulation
+from .shader import Shader
+
+
+def build_matrix_lists(mob):
+ root_hierarchical_matrix = mob.hierarchical_model_matrix()
+ matrix_to_mobject_list = collections.defaultdict(list)
+ if mob.has_points():
+ matrix_to_mobject_list[tuple(root_hierarchical_matrix.ravel())].append(mob)
+ mobject_to_hierarchical_matrix = {mob: root_hierarchical_matrix}
+ dfs = [mob]
+ while dfs:
+ parent = dfs.pop()
+ for child in parent.submobjects:
+ child_hierarchical_matrix = (
+ mobject_to_hierarchical_matrix[parent] @ child.model_matrix
+ )
+ mobject_to_hierarchical_matrix[child] = child_hierarchical_matrix
+ if child.has_points():
+ matrix_to_mobject_list[tuple(child_hierarchical_matrix.ravel())].append(
+ child,
+ )
+ dfs.append(child)
+ return matrix_to_mobject_list
+
+
+def render_opengl_vectorized_mobject_fill(renderer, mobject):
+ matrix_to_mobject_list = build_matrix_lists(mobject)
+
+ for matrix_tuple, mobject_list in matrix_to_mobject_list.items():
+ model_matrix = np.array(matrix_tuple).reshape((4, 4))
+ render_mobject_fills_with_matrix(renderer, model_matrix, mobject_list)
+
+
+def render_mobject_fills_with_matrix(renderer, model_matrix, mobjects):
+ # Precompute the total number of vertices for which to reserve space.
+ # Note that triangulate_mobject() will cache its results.
+ total_size = 0
+ for submob in mobjects:
+ total_size += triangulate_mobject(submob).shape[0]
+
+ attributes = np.empty(
+ total_size,
+ dtype=[
+ ("in_vert", np.float32, (3,)),
+ ("in_color", np.float32, (4,)),
+ ("texture_coords", np.float32, (2,)),
+ ("texture_mode", np.int32),
+ ],
+ )
+
+ write_offset = 0
+ for submob in mobjects:
+ if not submob.has_points():
+ continue
+ mobject_triangulation = triangulate_mobject(submob)
+ end_offset = write_offset + mobject_triangulation.shape[0]
+ attributes[write_offset:end_offset] = mobject_triangulation
+ attributes["in_color"][write_offset:end_offset] = np.repeat(
+ submob.fill_rgba,
+ mobject_triangulation.shape[0],
+ axis=0,
+ )
+ write_offset = end_offset
+
+ fill_shader = Shader(renderer.context, name="vectorized_mobject_fill")
+ fill_shader.set_uniform(
+ "u_model_view_matrix",
+ opengl.matrix_to_shader_input(
+ renderer.camera.unformatted_view_matrix @ model_matrix,
+ ),
+ )
+ fill_shader.set_uniform(
+ "u_projection_matrix",
+ renderer.scene.camera.projection_matrix,
+ )
+
+ vbo = renderer.context.buffer(attributes.tobytes())
+ vao = renderer.context.simple_vertex_array(
+ fill_shader.shader_program,
+ vbo,
+ *attributes.dtype.names,
+ )
+ vao.render()
+ vao.release()
+ vbo.release()
+
+
+def triangulate_mobject(mob):
+ if not mob.needs_new_triangulation:
+ return mob.triangulation
+
+ # Figure out how to triangulate the interior to know
+ # how to send the points as to the vertex shader.
+ # First triangles come directly from the points
+ # normal_vector = mob.get_unit_normal()
+ points = mob.points
+
+ b0s = points[0::3]
+ b1s = points[1::3]
+ b2s = points[2::3]
+ v01s = b1s - b0s
+ v12s = b2s - b1s
+
+ crosses = cross2d(v01s, v12s)
+ convexities = np.sign(crosses)
+ if mob.orientation == 1:
+ concave_parts = convexities > 0
+ convex_parts = convexities <= 0
+ else:
+ concave_parts = convexities < 0
+ convex_parts = convexities >= 0
+
+ # These are the vertices to which we'll apply a polygon triangulation
+ atol = mob.tolerance_for_point_equality
+ end_of_loop = np.zeros(len(b0s), dtype=bool)
+ end_of_loop[:-1] = (np.abs(b2s[:-1] - b0s[1:]) > atol).any(1)
+ end_of_loop[-1] = True
+
+ indices = np.arange(len(points), dtype=int)
+ inner_vert_indices = np.hstack(
+ [
+ indices[0::3],
+ indices[1::3][concave_parts],
+ indices[2::3][end_of_loop],
+ ],
+ )
+ inner_vert_indices.sort()
+ rings = np.arange(1, len(inner_vert_indices) + 1)[inner_vert_indices % 3 == 2]
+
+ # Triangulate
+ inner_verts = points[inner_vert_indices]
+ inner_tri_indices = inner_vert_indices[earclip_triangulation(inner_verts, rings)]
+
+ bezier_triangle_indices = np.reshape(indices, (-1, 3))
+ concave_triangle_indices = np.reshape(bezier_triangle_indices[concave_parts], (-1))
+ convex_triangle_indices = np.reshape(bezier_triangle_indices[convex_parts], (-1))
+
+ points = points[
+ np.hstack(
+ [
+ concave_triangle_indices,
+ convex_triangle_indices,
+ inner_tri_indices,
+ ],
+ )
+ ]
+ texture_coords = np.tile(
+ [
+ [0.0, 0.0],
+ [0.5, 0.0],
+ [1.0, 1.0],
+ ],
+ (points.shape[0] // 3, 1),
+ )
+ texture_mode = np.hstack(
+ (
+ np.ones(concave_triangle_indices.shape[0]),
+ -1 * np.ones(convex_triangle_indices.shape[0]),
+ np.zeros(inner_tri_indices.shape[0]),
+ ),
+ )
+
+ attributes = np.zeros(
+ points.shape[0],
+ dtype=[
+ ("in_vert", np.float32, (3,)),
+ ("in_color", np.float32, (4,)),
+ ("texture_coords", np.float32, (2,)),
+ ("texture_mode", np.int32),
+ ],
+ )
+ attributes["in_vert"] = points
+ attributes["texture_coords"] = texture_coords
+ attributes["texture_mode"] = texture_mode
+
+ mob.triangulation = attributes
+ mob.needs_new_triangulation = False
+
+ return attributes
+
+
+def render_opengl_vectorized_mobject_stroke(renderer, mobject):
+ matrix_to_mobject_list = build_matrix_lists(mobject)
+ for matrix_tuple, mobject_list in matrix_to_mobject_list.items():
+ model_matrix = np.array(matrix_tuple).reshape((4, 4))
+ render_mobject_strokes_with_matrix(renderer, model_matrix, mobject_list)
+
+
+def render_mobject_strokes_with_matrix(renderer, model_matrix, mobjects):
+ # Precompute the total number of vertices for which to reserve space.
+ total_size = 0
+ for submob in mobjects:
+ total_size += submob.points.shape[0]
+
+ points = np.empty((total_size, 3))
+ colors = np.empty((total_size, 4))
+ widths = np.empty(total_size)
+
+ write_offset = 0
+ for submob in mobjects:
+ if not submob.has_points():
+ continue
+ end_offset = write_offset + submob.points.shape[0]
+
+ points[write_offset:end_offset] = submob.points
+ if submob.stroke_rgba.shape[0] == points[write_offset:end_offset].shape[0]:
+ colors[write_offset:end_offset] = submob.stroke_rgba
+ else:
+ colors[write_offset:end_offset] = np.repeat(
+ submob.stroke_rgba,
+ submob.points.shape[0],
+ axis=0,
+ )
+ widths[write_offset:end_offset] = np.repeat(
+ submob.stroke_width,
+ submob.points.shape[0],
+ )
+ write_offset = end_offset
+
+ stroke_data = np.zeros(
+ len(points),
+ dtype=[
+ # ("previous_curve", np.float32, (3, 3)),
+ ("current_curve", np.float32, (3, 3)),
+ # ("next_curve", np.float32, (3, 3)),
+ ("tile_coordinate", np.float32, (2,)),
+ ("in_color", np.float32, (4,)),
+ ("in_width", np.float32),
+ ],
+ )
+
+ stroke_data["in_color"] = colors
+ stroke_data["in_width"] = widths
+ curves = np.reshape(points, (-1, 3, 3))
+ # stroke_data["previous_curve"] = np.repeat(np.roll(curves, 1, axis=0), 3, axis=0)
+ stroke_data["current_curve"] = np.repeat(curves, 3, axis=0)
+ # stroke_data["next_curve"] = np.repeat(np.roll(curves, -1, axis=0), 3, axis=0)
+
+ # Repeat each vertex in order to make a tile.
+ stroke_data = np.tile(stroke_data, 2)
+ stroke_data["tile_coordinate"] = np.vstack(
+ (
+ np.tile(
+ [
+ [0.0, 0.0],
+ [0.0, 1.0],
+ [1.0, 1.0],
+ ],
+ (len(points) // 3, 1),
+ ),
+ np.tile(
+ [
+ [0.0, 0.0],
+ [1.0, 0.0],
+ [1.0, 1.0],
+ ],
+ (len(points) // 3, 1),
+ ),
+ ),
+ )
+
+ shader = Shader(renderer.context, "vectorized_mobject_stroke")
+ shader.set_uniform(
+ "u_model_view_matrix",
+ opengl.matrix_to_shader_input(
+ renderer.camera.unformatted_view_matrix @ model_matrix,
+ ),
+ )
+ shader.set_uniform("u_projection_matrix", renderer.scene.camera.projection_matrix)
+ shader.set_uniform("manim_unit_normal", tuple(-mobjects[0].unit_normal[0]))
+
+ vbo = renderer.context.buffer(stroke_data.tobytes())
+ vao = renderer.context.simple_vertex_array(
+ shader.shader_program, vbo, *stroke_data.dtype.names
+ )
+ renderer.frame_buffer_object.use()
+ vao.render()
+ vao.release()
+ vbo.release()
diff --git a/data/rag/manim_docs/manim_core/source/scene/__init__.py b/data/rag/manim_docs/manim_core/source/scene/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/data/rag/manim_docs/manim_core/source/scene/moving_camera_scene.py b/data/rag/manim_docs/manim_core/source/scene/moving_camera_scene.py
new file mode 100644
index 0000000000000000000000000000000000000000..3adef5fc787043d2611c72cab0139a2472de4086
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/scene/moving_camera_scene.py
@@ -0,0 +1,112 @@
+"""A scene whose camera can be moved around.
+
+.. SEEALSO::
+
+ :mod:`.moving_camera`
+
+
+Examples
+--------
+
+.. manim:: ChangingCameraWidthAndRestore
+
+ class ChangingCameraWidthAndRestore(MovingCameraScene):
+ def construct(self):
+ text = Text("Hello World").set_color(BLUE)
+ self.add(text)
+ self.camera.frame.save_state()
+ self.play(self.camera.frame.animate.set(width=text.width * 1.2))
+ self.wait(0.3)
+ self.play(Restore(self.camera.frame))
+
+
+.. manim:: MovingCameraCenter
+
+ class MovingCameraCenter(MovingCameraScene):
+ def construct(self):
+ s = Square(color=RED, fill_opacity=0.5).move_to(2 * LEFT)
+ t = Triangle(color=GREEN, fill_opacity=0.5).move_to(2 * RIGHT)
+ self.wait(0.3)
+ self.add(s, t)
+ self.play(self.camera.frame.animate.move_to(s))
+ self.wait(0.3)
+ self.play(self.camera.frame.animate.move_to(t))
+
+
+.. manim:: MovingAndZoomingCamera
+
+ class MovingAndZoomingCamera(MovingCameraScene):
+ def construct(self):
+ s = Square(color=BLUE, fill_opacity=0.5).move_to(2 * LEFT)
+ t = Triangle(color=YELLOW, fill_opacity=0.5).move_to(2 * RIGHT)
+ self.add(s, t)
+ self.play(self.camera.frame.animate.move_to(s).set(width=s.width*2))
+ self.wait(0.3)
+ self.play(self.camera.frame.animate.move_to(t).set(width=t.width*2))
+
+ self.play(self.camera.frame.animate.move_to(ORIGIN).set(width=14))
+
+.. manim:: MovingCameraOnGraph
+
+ class MovingCameraOnGraph(MovingCameraScene):
+ def construct(self):
+ self.camera.frame.save_state()
+
+ ax = Axes(x_range=[-1, 10], y_range=[-1, 10])
+ graph = ax.plot(lambda x: np.sin(x), color=WHITE, x_range=[0, 3 * PI])
+
+ dot_1 = Dot(ax.i2gp(graph.t_min, graph))
+ dot_2 = Dot(ax.i2gp(graph.t_max, graph))
+ self.add(ax, graph, dot_1, dot_2)
+
+ self.play(self.camera.frame.animate.scale(0.5).move_to(dot_1))
+ self.play(self.camera.frame.animate.move_to(dot_2))
+ self.play(Restore(self.camera.frame))
+ self.wait()
+
+"""
+
+from __future__ import annotations
+
+__all__ = ["MovingCameraScene"]
+
+from manim.animation.animation import Animation
+
+from ..camera.moving_camera import MovingCamera
+from ..scene.scene import Scene
+from ..utils.family import extract_mobject_family_members
+from ..utils.iterables import list_update
+
+
+class MovingCameraScene(Scene):
+ """
+ This is a Scene, with special configurations and properties that
+ make it suitable for cases where the camera must be moved around.
+
+ .. SEEALSO::
+
+ :class:`.MovingCamera`
+ """
+
+ def __init__(self, camera_class=MovingCamera, **kwargs):
+ super().__init__(camera_class=camera_class, **kwargs)
+
+ def get_moving_mobjects(self, *animations: Animation):
+ """
+ This method returns a list of all of the Mobjects in the Scene that
+ are moving, that are also in the animations passed.
+
+ Parameters
+ ----------
+ *animations
+ The Animations whose mobjects will be checked.
+ """
+ moving_mobjects = super().get_moving_mobjects(*animations)
+ all_moving_mobjects = extract_mobject_family_members(moving_mobjects)
+ movement_indicators = self.renderer.camera.get_mobjects_indicating_movement()
+ for movement_indicator in movement_indicators:
+ if movement_indicator in all_moving_mobjects:
+ # When one of these is moving, the camera should
+ # consider all mobjects to be moving
+ return list_update(self.mobjects, moving_mobjects)
+ return moving_mobjects
diff --git a/data/rag/manim_docs/manim_core/source/scene/scene.py b/data/rag/manim_docs/manim_core/source/scene/scene.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f3fb992477de307db013da767d29a19610b715b
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/scene/scene.py
@@ -0,0 +1,1722 @@
+"""Basic canvas for animations."""
+
+from __future__ import annotations
+
+__all__ = ["Scene"]
+
+import copy
+import datetime
+import inspect
+import platform
+import random
+import threading
+import time
+import types
+from queue import Queue
+from typing import Callable
+
+import srt
+
+from manim.scene.section import DefaultSectionType
+
+try:
+ import dearpygui.dearpygui as dpg
+
+ dearpygui_imported = True
+except ImportError:
+ dearpygui_imported = False
+import numpy as np
+from tqdm import tqdm
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+from manim.mobject.mobject import Mobject
+from manim.mobject.opengl.opengl_mobject import OpenGLPoint
+
+from .. import config, logger
+from ..animation.animation import Animation, Wait, prepare_animation
+from ..camera.camera import Camera
+from ..constants import *
+from ..gui.gui import configure_pygui
+from ..renderer.cairo_renderer import CairoRenderer
+from ..renderer.opengl_renderer import OpenGLRenderer
+from ..renderer.shader import Object3D
+from ..utils import opengl, space_ops
+from ..utils.exceptions import EndSceneEarlyException, RerunSceneException
+from ..utils.family import extract_mobject_family_members
+from ..utils.family_ops import restructure_list_to_exclude_certain_family_members
+from ..utils.file_ops import open_media_file
+from ..utils.iterables import list_difference_update, list_update
+
+
+class RerunSceneHandler(FileSystemEventHandler):
+ """A class to handle rerunning a Scene after the input file is modified."""
+
+ def __init__(self, queue):
+ super().__init__()
+ self.queue = queue
+
+ def on_modified(self, event):
+ self.queue.put(("rerun_file", [], {}))
+
+
+class Scene:
+ """A Scene is the canvas of your animation.
+
+ The primary role of :class:`Scene` is to provide the user with tools to manage
+ mobjects and animations. Generally speaking, a manim script consists of a class
+ that derives from :class:`Scene` whose :meth:`Scene.construct` method is overridden
+ by the user's code.
+
+ Mobjects are displayed on screen by calling :meth:`Scene.add` and removed from
+ screen by calling :meth:`Scene.remove`. All mobjects currently on screen are kept
+ in :attr:`Scene.mobjects`. Animations are played by calling :meth:`Scene.play`.
+
+ A :class:`Scene` is rendered internally by calling :meth:`Scene.render`. This in
+ turn calls :meth:`Scene.setup`, :meth:`Scene.construct`, and
+ :meth:`Scene.tear_down`, in that order.
+
+ It is not recommended to override the ``__init__`` method in user Scenes. For code
+ that should be ran before a Scene is rendered, use :meth:`Scene.setup` instead.
+
+ Examples
+ --------
+ Override the :meth:`Scene.construct` method with your code.
+
+ .. code-block:: python
+
+ class MyScene(Scene):
+ def construct(self):
+ self.play(Write(Text("Hello World!")))
+
+ """
+
+ def __init__(
+ self,
+ renderer=None,
+ camera_class=Camera,
+ always_update_mobjects=False,
+ random_seed=None,
+ skip_animations=False,
+ ):
+ self.camera_class = camera_class
+ self.always_update_mobjects = always_update_mobjects
+ self.random_seed = random_seed
+ self.skip_animations = skip_animations
+
+ self.animations = None
+ self.stop_condition = None
+ self.moving_mobjects = []
+ self.static_mobjects = []
+ self.time_progression = None
+ self.duration = None
+ self.last_t = None
+ self.queue = Queue()
+ self.skip_animation_preview = False
+ self.meshes = []
+ self.camera_target = ORIGIN
+ self.widgets = []
+ self.dearpygui_imported = dearpygui_imported
+ self.updaters = []
+ self.point_lights = []
+ self.ambient_light = None
+ self.key_to_function_map = {}
+ self.mouse_press_callbacks = []
+ self.interactive_mode = False
+
+ if config.renderer == RendererType.OPENGL:
+ # Items associated with interaction
+ self.mouse_point = OpenGLPoint()
+ self.mouse_drag_point = OpenGLPoint()
+ if renderer is None:
+ renderer = OpenGLRenderer()
+
+ if renderer is None:
+ self.renderer = CairoRenderer(
+ camera_class=self.camera_class,
+ skip_animations=self.skip_animations,
+ )
+ else:
+ self.renderer = renderer
+ self.renderer.init_scene(self)
+
+ self.mobjects = []
+ # TODO, remove need for foreground mobjects
+ self.foreground_mobjects = []
+ if self.random_seed is not None:
+ random.seed(self.random_seed)
+ np.random.seed(self.random_seed)
+
+ @property
+ def camera(self):
+ return self.renderer.camera
+
+ def __deepcopy__(self, clone_from_id):
+ cls = self.__class__
+ result = cls.__new__(cls)
+ clone_from_id[id(self)] = result
+ for k, v in self.__dict__.items():
+ if k in ["renderer", "time_progression"]:
+ continue
+ if k == "camera_class":
+ setattr(result, k, v)
+ setattr(result, k, copy.deepcopy(v, clone_from_id))
+ result.mobject_updater_lists = []
+
+ # Update updaters
+ for mobject in self.mobjects:
+ cloned_updaters = []
+ for updater in mobject.updaters:
+ # Make the cloned updater use the cloned Mobjects as free variables
+ # rather than the original ones. Analyzing function bytecode with the
+ # dis module will help in understanding this.
+ # https://docs.python.org/3/library/dis.html
+ # TODO: Do the same for function calls recursively.
+ free_variable_map = inspect.getclosurevars(updater).nonlocals
+ cloned_co_freevars = []
+ cloned_closure = []
+ for free_variable_name in updater.__code__.co_freevars:
+ free_variable_value = free_variable_map[free_variable_name]
+
+ # If the referenced variable has not been cloned, raise.
+ if id(free_variable_value) not in clone_from_id:
+ raise Exception(
+ f"{free_variable_name} is referenced from an updater "
+ "but is not an attribute of the Scene, which isn't "
+ "allowed.",
+ )
+
+ # Add the cloned object's name to the free variable list.
+ cloned_co_freevars.append(free_variable_name)
+
+ # Add a cell containing the cloned object's reference to the
+ # closure list.
+ cloned_closure.append(
+ types.CellType(clone_from_id[id(free_variable_value)]),
+ )
+
+ cloned_updater = types.FunctionType(
+ updater.__code__.replace(co_freevars=tuple(cloned_co_freevars)),
+ updater.__globals__,
+ updater.__name__,
+ updater.__defaults__,
+ tuple(cloned_closure),
+ )
+ cloned_updaters.append(cloned_updater)
+ mobject_clone = clone_from_id[id(mobject)]
+ mobject_clone.updaters = cloned_updaters
+ if len(cloned_updaters) > 0:
+ result.mobject_updater_lists.append((mobject_clone, cloned_updaters))
+ return result
+
+ def render(self, preview: bool = False):
+ """
+ Renders this Scene.
+
+ Parameters
+ ---------
+ preview
+ If true, opens scene in a file viewer.
+ """
+ self.setup()
+ try:
+ self.construct()
+ except EndSceneEarlyException:
+ pass
+ except RerunSceneException as e:
+ self.remove(*self.mobjects)
+ self.renderer.clear_screen()
+ self.renderer.num_plays = 0
+ return True
+ self.tear_down()
+ # We have to reset these settings in case of multiple renders.
+ self.renderer.scene_finished(self)
+
+ # Show info only if animations are rendered or to get image
+ if (
+ self.renderer.num_plays
+ or config["format"] == "png"
+ or config["save_last_frame"]
+ ):
+ logger.info(
+ f"Rendered {str(self)}\nPlayed {self.renderer.num_plays} animations",
+ )
+
+ # If preview open up the render after rendering.
+ if preview:
+ config["preview"] = True
+
+ if config["preview"] or config["show_in_file_browser"]:
+ open_media_file(self.renderer.file_writer)
+
+ def setup(self):
+ """
+ This is meant to be implemented by any scenes which
+ are commonly subclassed, and have some common setup
+ involved before the construct method is called.
+ """
+ pass
+
+ def tear_down(self):
+ """
+ This is meant to be implemented by any scenes which
+ are commonly subclassed, and have some common method
+ to be invoked before the scene ends.
+ """
+ pass
+
+ def construct(self):
+ """Add content to the Scene.
+
+ From within :meth:`Scene.construct`, display mobjects on screen by calling
+ :meth:`Scene.add` and remove them from screen by calling :meth:`Scene.remove`.
+ All mobjects currently on screen are kept in :attr:`Scene.mobjects`. Play
+ animations by calling :meth:`Scene.play`.
+
+ Notes
+ -----
+ Initialization code should go in :meth:`Scene.setup`. Termination code should
+ go in :meth:`Scene.tear_down`.
+
+ Examples
+ --------
+ A typical manim script includes a class derived from :class:`Scene` with an
+ overridden :meth:`Scene.contruct` method:
+
+ .. code-block:: python
+
+ class MyScene(Scene):
+ def construct(self):
+ self.play(Write(Text("Hello World!")))
+
+ See Also
+ --------
+ :meth:`Scene.setup`
+ :meth:`Scene.render`
+ :meth:`Scene.tear_down`
+
+ """
+ pass # To be implemented in subclasses
+
+ def next_section(
+ self,
+ name: str = "unnamed",
+ type: str = DefaultSectionType.NORMAL,
+ skip_animations: bool = False,
+ ) -> None:
+ """Create separation here; the last section gets finished and a new one gets created.
+ ``skip_animations`` skips the rendering of all animations in this section.
+ Refer to :doc:`the documentation` on how to use sections.
+ """
+ self.renderer.file_writer.next_section(name, type, skip_animations)
+
+ def __str__(self):
+ return self.__class__.__name__
+
+ def get_attrs(self, *keys: str):
+ """
+ Gets attributes of a scene given the attribute's identifier/name.
+
+ Parameters
+ ----------
+ *keys
+ Name(s) of the argument(s) to return the attribute of.
+
+ Returns
+ -------
+ list
+ List of attributes of the passed identifiers.
+ """
+ return [getattr(self, key) for key in keys]
+
+ def update_mobjects(self, dt: float):
+ """
+ Begins updating all mobjects in the Scene.
+
+ Parameters
+ ----------
+ dt
+ Change in time between updates. Defaults (mostly) to 1/frames_per_second
+ """
+ for mobject in self.mobjects:
+ mobject.update(dt)
+
+ def update_meshes(self, dt):
+ for obj in self.meshes:
+ for mesh in obj.get_family():
+ mesh.update(dt)
+
+ def update_self(self, dt: float):
+ """Run all scene updater functions.
+
+ Among all types of update functions (mobject updaters, mesh updaters,
+ scene updaters), scene update functions are called last.
+
+ Parameters
+ ----------
+ dt
+ Scene time since last update.
+
+ See Also
+ --------
+ :meth:`.Scene.add_updater`
+ :meth:`.Scene.remove_updater`
+ """
+ for func in self.updaters:
+ func(dt)
+
+ def should_update_mobjects(self) -> bool:
+ """
+ Returns True if the mobjects of this scene should be updated.
+
+ In particular, this checks whether
+
+ - the :attr:`always_update_mobjects` attribute of :class:`.Scene`
+ is set to ``True``,
+ - the :class:`.Scene` itself has time-based updaters attached,
+ - any mobject in this :class:`.Scene` has time-based updaters attached.
+
+ This is only called when a single Wait animation is played.
+ """
+ wait_animation = self.animations[0]
+ if wait_animation.is_static_wait is None:
+ should_update = (
+ self.always_update_mobjects
+ or self.updaters
+ or wait_animation.stop_condition is not None
+ or any(
+ mob.has_time_based_updater()
+ for mob in self.get_mobject_family_members()
+ )
+ )
+ wait_animation.is_static_wait = not should_update
+ return not wait_animation.is_static_wait
+
+ def get_top_level_mobjects(self):
+ """
+ Returns all mobjects which are not submobjects.
+
+ Returns
+ -------
+ list
+ List of top level mobjects.
+ """
+ # Return only those which are not in the family
+ # of another mobject from the scene
+ families = [m.get_family() for m in self.mobjects]
+
+ def is_top_level(mobject):
+ num_families = sum((mobject in family) for family in families)
+ return num_families == 1
+
+ return list(filter(is_top_level, self.mobjects))
+
+ def get_mobject_family_members(self):
+ """
+ Returns list of family-members of all mobjects in scene.
+ If a Circle() and a VGroup(Rectangle(),Triangle()) were added,
+ it returns not only the Circle(), Rectangle() and Triangle(), but
+ also the VGroup() object.
+
+ Returns
+ -------
+ list
+ List of mobject family members.
+ """
+ if config.renderer == RendererType.OPENGL:
+ family_members = []
+ for mob in self.mobjects:
+ family_members.extend(mob.get_family())
+ return family_members
+ elif config.renderer == RendererType.CAIRO:
+ return extract_mobject_family_members(
+ self.mobjects,
+ use_z_index=self.renderer.camera.use_z_index,
+ )
+
+ def add(self, *mobjects: Mobject):
+ """
+ Mobjects will be displayed, from background to
+ foreground in the order with which they are added.
+
+ Parameters
+ ---------
+ *mobjects
+ Mobjects to add.
+
+ Returns
+ -------
+ Scene
+ The same scene after adding the Mobjects in.
+
+ """
+ if config.renderer == RendererType.OPENGL:
+ new_mobjects = []
+ new_meshes = []
+ for mobject_or_mesh in mobjects:
+ if isinstance(mobject_or_mesh, Object3D):
+ new_meshes.append(mobject_or_mesh)
+ else:
+ new_mobjects.append(mobject_or_mesh)
+ self.remove(*new_mobjects)
+ self.mobjects += new_mobjects
+ self.remove(*new_meshes)
+ self.meshes += new_meshes
+ elif config.renderer == RendererType.CAIRO:
+ mobjects = [*mobjects, *self.foreground_mobjects]
+ self.restructure_mobjects(to_remove=mobjects)
+ self.mobjects += mobjects
+ if self.moving_mobjects:
+ self.restructure_mobjects(
+ to_remove=mobjects,
+ mobject_list_name="moving_mobjects",
+ )
+ self.moving_mobjects += mobjects
+ return self
+
+ def add_mobjects_from_animations(self, animations):
+ curr_mobjects = self.get_mobject_family_members()
+ for animation in animations:
+ if animation.is_introducer():
+ continue
+ # Anything animated that's not already in the
+ # scene gets added to the scene
+ mob = animation.mobject
+ if mob is not None and mob not in curr_mobjects:
+ self.add(mob)
+ curr_mobjects += mob.get_family()
+
+ def remove(self, *mobjects: Mobject):
+ """
+ Removes mobjects in the passed list of mobjects
+ from the scene and the foreground, by removing them
+ from "mobjects" and "foreground_mobjects"
+
+ Parameters
+ ----------
+ *mobjects
+ The mobjects to remove.
+ """
+ if config.renderer == RendererType.OPENGL:
+ mobjects_to_remove = []
+ meshes_to_remove = set()
+ for mobject_or_mesh in mobjects:
+ if isinstance(mobject_or_mesh, Object3D):
+ meshes_to_remove.add(mobject_or_mesh)
+ else:
+ mobjects_to_remove.append(mobject_or_mesh)
+ self.mobjects = restructure_list_to_exclude_certain_family_members(
+ self.mobjects,
+ mobjects_to_remove,
+ )
+ self.meshes = list(
+ filter(lambda mesh: mesh not in set(meshes_to_remove), self.meshes),
+ )
+ return self
+ elif config.renderer == RendererType.CAIRO:
+ for list_name in "mobjects", "foreground_mobjects":
+ self.restructure_mobjects(mobjects, list_name, False)
+ return self
+
+ def replace(self, old_mobject: Mobject, new_mobject: Mobject) -> None:
+ """Replace one mobject in the scene with another, preserving draw order.
+
+ If ``old_mobject`` is a submobject of some other Mobject (e.g. a
+ :class:`.Group`), the new_mobject will replace it inside the group,
+ without otherwise changing the parent mobject.
+
+ Parameters
+ ----------
+ old_mobject
+ The mobject to be replaced. Must be present in the scene.
+ new_mobject
+ A mobject which must not already be in the scene.
+
+ """
+ if old_mobject is None or new_mobject is None:
+ raise ValueError("Specified mobjects cannot be None")
+
+ def replace_in_list(
+ mobj_list: list[Mobject], old_m: Mobject, new_m: Mobject
+ ) -> bool:
+ # We use breadth-first search because some Mobjects get very deep and
+ # we expect top-level elements to be the most common targets for replace.
+ for i in range(0, len(mobj_list)):
+ # Is this the old mobject?
+ if mobj_list[i] == old_m:
+ # If so, write the new object to the same spot and stop looking.
+ mobj_list[i] = new_m
+ return True
+ # Now check all the children of all these mobs.
+ for mob in mobj_list: # noqa: SIM110
+ if replace_in_list(mob.submobjects, old_m, new_m):
+ # If we found it in a submobject, stop looking.
+ return True
+ # If we did not find the mobject in the mobject list or any submobjects,
+ # (or the list was empty), indicate we did not make the replacement.
+ return False
+
+ # Make use of short-circuiting conditionals to check mobjects and then
+ # foreground_mobjects
+ replaced = replace_in_list(
+ self.mobjects, old_mobject, new_mobject
+ ) or replace_in_list(self.foreground_mobjects, old_mobject, new_mobject)
+
+ if not replaced:
+ raise ValueError(f"Could not find {old_mobject} in scene")
+
+ def add_updater(self, func: Callable[[float], None]) -> None:
+ """Add an update function to the scene.
+
+ The scene updater functions are run every frame,
+ and they are the last type of updaters to run.
+
+ .. WARNING::
+
+ When using the Cairo renderer, scene updaters that
+ modify mobjects are not detected in the same way
+ that mobject updaters are. To be more concrete,
+ a mobject only modified via a scene updater will
+ not necessarily be added to the list of *moving
+ mobjects* and thus might not be updated every frame.
+
+ TL;DR: Use mobject updaters to update mobjects.
+
+ Parameters
+ ----------
+ func
+ The updater function. It takes a float, which is the
+ time difference since the last update (usually equal
+ to the frame rate).
+
+ See also
+ --------
+ :meth:`.Scene.remove_updater`
+ :meth:`.Scene.update_self`
+ """
+ self.updaters.append(func)
+
+ def remove_updater(self, func: Callable[[float], None]) -> None:
+ """Remove an update function from the scene.
+
+ Parameters
+ ----------
+ func
+ The updater function to be removed.
+
+ See also
+ --------
+ :meth:`.Scene.add_updater`
+ :meth:`.Scene.update_self`
+ """
+ self.updaters = [f for f in self.updaters if f is not func]
+
+ def restructure_mobjects(
+ self,
+ to_remove: Mobject,
+ mobject_list_name: str = "mobjects",
+ extract_families: bool = True,
+ ):
+ """
+ tl:wr
+ If your scene has a Group(), and you removed a mobject from the Group,
+ this dissolves the group and puts the rest of the mobjects directly
+ in self.mobjects or self.foreground_mobjects.
+
+ In cases where the scene contains a group, e.g. Group(m1, m2, m3), but one
+ of its submobjects is removed, e.g. scene.remove(m1), the list of mobjects
+ will be edited to contain other submobjects, but not m1, e.g. it will now
+ insert m2 and m3 to where the group once was.
+
+ Parameters
+ ----------
+ to_remove
+ The Mobject to remove.
+
+ mobject_list_name
+ The list of mobjects ("mobjects", "foreground_mobjects" etc) to remove from.
+
+ extract_families
+ Whether the mobject's families should be recursively extracted.
+
+ Returns
+ -------
+ Scene
+ The Scene mobject with restructured Mobjects.
+ """
+ if extract_families:
+ to_remove = extract_mobject_family_members(
+ to_remove,
+ use_z_index=self.renderer.camera.use_z_index,
+ )
+ _list = getattr(self, mobject_list_name)
+ new_list = self.get_restructured_mobject_list(_list, to_remove)
+ setattr(self, mobject_list_name, new_list)
+ return self
+
+ def get_restructured_mobject_list(self, mobjects: list, to_remove: list):
+ """
+ Given a list of mobjects and a list of mobjects to be removed, this
+ filters out the removable mobjects from the list of mobjects.
+
+ Parameters
+ ----------
+
+ mobjects
+ The Mobjects to check.
+
+ to_remove
+ The list of mobjects to remove.
+
+ Returns
+ -------
+ list
+ The list of mobjects with the mobjects to remove removed.
+ """
+
+ new_mobjects = []
+
+ def add_safe_mobjects_from_list(list_to_examine, set_to_remove):
+ for mob in list_to_examine:
+ if mob in set_to_remove:
+ continue
+ intersect = set_to_remove.intersection(mob.get_family())
+ if intersect:
+ add_safe_mobjects_from_list(mob.submobjects, intersect)
+ else:
+ new_mobjects.append(mob)
+
+ add_safe_mobjects_from_list(mobjects, set(to_remove))
+ return new_mobjects
+
+ # TODO, remove this, and calls to this
+ def add_foreground_mobjects(self, *mobjects: Mobject):
+ """
+ Adds mobjects to the foreground, and internally to the list
+ foreground_mobjects, and mobjects.
+
+ Parameters
+ ----------
+ *mobjects
+ The Mobjects to add to the foreground.
+
+ Returns
+ ------
+ Scene
+ The Scene, with the foreground mobjects added.
+ """
+ self.foreground_mobjects = list_update(self.foreground_mobjects, mobjects)
+ self.add(*mobjects)
+ return self
+
+ def add_foreground_mobject(self, mobject: Mobject):
+ """
+ Adds a single mobject to the foreground, and internally to the list
+ foreground_mobjects, and mobjects.
+
+ Parameters
+ ----------
+ mobject
+ The Mobject to add to the foreground.
+
+ Returns
+ ------
+ Scene
+ The Scene, with the foreground mobject added.
+ """
+ return self.add_foreground_mobjects(mobject)
+
+ def remove_foreground_mobjects(self, *to_remove: Mobject):
+ """
+ Removes mobjects from the foreground, and internally from the list
+ foreground_mobjects.
+
+ Parameters
+ ----------
+ *to_remove
+ The mobject(s) to remove from the foreground.
+
+ Returns
+ ------
+ Scene
+ The Scene, with the foreground mobjects removed.
+ """
+ self.restructure_mobjects(to_remove, "foreground_mobjects")
+ return self
+
+ def remove_foreground_mobject(self, mobject: Mobject):
+ """
+ Removes a single mobject from the foreground, and internally from the list
+ foreground_mobjects.
+
+ Parameters
+ ----------
+ mobject
+ The mobject to remove from the foreground.
+
+ Returns
+ ------
+ Scene
+ The Scene, with the foreground mobject removed.
+ """
+ return self.remove_foreground_mobjects(mobject)
+
+ def bring_to_front(self, *mobjects: Mobject):
+ """
+ Adds the passed mobjects to the scene again,
+ pushing them to he front of the scene.
+
+ Parameters
+ ----------
+ *mobjects
+ The mobject(s) to bring to the front of the scene.
+
+ Returns
+ ------
+ Scene
+ The Scene, with the mobjects brought to the front
+ of the scene.
+ """
+ self.add(*mobjects)
+ return self
+
+ def bring_to_back(self, *mobjects: Mobject):
+ """
+ Removes the mobject from the scene and
+ adds them to the back of the scene.
+
+ Parameters
+ ----------
+ *mobjects
+ The mobject(s) to push to the back of the scene.
+
+ Returns
+ ------
+ Scene
+ The Scene, with the mobjects pushed to the back
+ of the scene.
+ """
+ self.remove(*mobjects)
+ self.mobjects = list(mobjects) + self.mobjects
+ return self
+
+ def clear(self):
+ """
+ Removes all mobjects present in self.mobjects
+ and self.foreground_mobjects from the scene.
+
+ Returns
+ ------
+ Scene
+ The Scene, with all of its mobjects in
+ self.mobjects and self.foreground_mobjects
+ removed.
+ """
+ self.mobjects = []
+ self.foreground_mobjects = []
+ return self
+
+ def get_moving_mobjects(self, *animations: Animation):
+ """
+ Gets all moving mobjects in the passed animation(s).
+
+ Parameters
+ ----------
+ *animations
+ The animations to check for moving mobjects.
+
+ Returns
+ ------
+ list
+ The list of mobjects that could be moving in
+ the Animation(s)
+ """
+ # Go through mobjects from start to end, and
+ # as soon as there's one that needs updating of
+ # some kind per frame, return the list from that
+ # point forward.
+ animation_mobjects = [anim.mobject for anim in animations]
+ mobjects = self.get_mobject_family_members()
+ for i, mob in enumerate(mobjects):
+ update_possibilities = [
+ mob in animation_mobjects,
+ len(mob.get_family_updaters()) > 0,
+ mob in self.foreground_mobjects,
+ ]
+ if any(update_possibilities):
+ return mobjects[i:]
+ return []
+
+ def get_moving_and_static_mobjects(self, animations):
+ all_mobjects = list_update(self.mobjects, self.foreground_mobjects)
+ all_mobject_families = extract_mobject_family_members(
+ all_mobjects,
+ use_z_index=self.renderer.camera.use_z_index,
+ only_those_with_points=True,
+ )
+ moving_mobjects = self.get_moving_mobjects(*animations)
+ all_moving_mobject_families = extract_mobject_family_members(
+ moving_mobjects,
+ use_z_index=self.renderer.camera.use_z_index,
+ )
+ static_mobjects = list_difference_update(
+ all_mobject_families,
+ all_moving_mobject_families,
+ )
+ return all_moving_mobject_families, static_mobjects
+
+ def compile_animations(self, *args: Animation, **kwargs):
+ """
+ Creates _MethodAnimations from any _AnimationBuilders and updates animation
+ kwargs with kwargs passed to play().
+
+ Parameters
+ ----------
+ *args
+ Animations to be played.
+ **kwargs
+ Configuration for the call to play().
+
+ Returns
+ -------
+ Tuple[:class:`Animation`]
+ Animations to be played.
+ """
+ animations = []
+ for arg in args:
+ try:
+ animations.append(prepare_animation(arg))
+ except TypeError:
+ if inspect.ismethod(arg):
+ raise TypeError(
+ "Passing Mobject methods to Scene.play is no longer"
+ " supported. Use Mobject.animate instead.",
+ )
+ else:
+ raise TypeError(
+ f"Unexpected argument {arg} passed to Scene.play().",
+ )
+
+ for animation in animations:
+ for k, v in kwargs.items():
+ setattr(animation, k, v)
+
+ return animations
+
+ def _get_animation_time_progression(
+ self, animations: list[Animation], duration: float
+ ):
+ """
+ You will hardly use this when making your own animations.
+ This method is for Manim's internal use.
+
+ Uses :func:`~.get_time_progression` to obtain a
+ CommandLine ProgressBar whose ``fill_time`` is
+ dependent on the qualities of the passed Animation,
+
+ Parameters
+ ----------
+ animations
+ The list of animations to get
+ the time progression for.
+
+ duration
+ duration of wait time
+
+ Returns
+ -------
+ time_progression
+ The CommandLine Progress Bar.
+ """
+ if len(animations) == 1 and isinstance(animations[0], Wait):
+ stop_condition = animations[0].stop_condition
+ if stop_condition is not None:
+ time_progression = self.get_time_progression(
+ duration,
+ f"Waiting for {stop_condition.__name__}",
+ n_iterations=-1, # So it doesn't show % progress
+ override_skip_animations=True,
+ )
+ else:
+ time_progression = self.get_time_progression(
+ duration,
+ f"Waiting {self.renderer.num_plays}",
+ )
+ else:
+ time_progression = self.get_time_progression(
+ duration,
+ "".join(
+ [
+ f"Animation {self.renderer.num_plays}: ",
+ str(animations[0]),
+ (", etc." if len(animations) > 1 else ""),
+ ],
+ ),
+ )
+ return time_progression
+
+ def get_time_progression(
+ self,
+ run_time: float,
+ description,
+ n_iterations: int | None = None,
+ override_skip_animations: bool = False,
+ ):
+ """
+ You will hardly use this when making your own animations.
+ This method is for Manim's internal use.
+
+ Returns a CommandLine ProgressBar whose ``fill_time``
+ is dependent on the ``run_time`` of an animation,
+ the iterations to perform in that animation
+ and a bool saying whether or not to consider
+ the skipped animations.
+
+ Parameters
+ ----------
+ run_time
+ The ``run_time`` of the animation.
+
+ n_iterations
+ The number of iterations in the animation.
+
+ override_skip_animations
+ Whether or not to show skipped animations in the progress bar.
+
+ Returns
+ -------
+ time_progression
+ The CommandLine Progress Bar.
+ """
+ if self.renderer.skip_animations and not override_skip_animations:
+ times = [run_time]
+ else:
+ step = 1 / config["frame_rate"]
+ times = np.arange(0, run_time, step)
+ time_progression = tqdm(
+ times,
+ desc=description,
+ total=n_iterations,
+ leave=config["progress_bar"] == "leave",
+ ascii=True if platform.system() == "Windows" else None,
+ disable=config["progress_bar"] == "none",
+ )
+ return time_progression
+
+ def get_run_time(self, animations: list[Animation]):
+ """
+ Gets the total run time for a list of animations.
+
+ Parameters
+ ----------
+ animations
+ A list of the animations whose total
+ ``run_time`` is to be calculated.
+
+ Returns
+ -------
+ float
+ The total ``run_time`` of all of the animations in the list.
+ """
+
+ if len(animations) == 1 and isinstance(animations[0], Wait):
+ return animations[0].duration
+
+ else:
+ return np.max([animation.run_time for animation in animations])
+
+ def play(
+ self,
+ *args,
+ subcaption=None,
+ subcaption_duration=None,
+ subcaption_offset=0,
+ **kwargs,
+ ):
+ r"""Plays an animation in this scene.
+
+ Parameters
+ ----------
+
+ args
+ Animations to be played.
+ subcaption
+ The content of the external subcaption that should
+ be added during the animation.
+ subcaption_duration
+ The duration for which the specified subcaption is
+ added. If ``None`` (the default), the run time of the
+ animation is taken.
+ subcaption_offset
+ An offset (in seconds) for the start time of the
+ added subcaption.
+ kwargs
+ All other keywords are passed to the renderer.
+
+ """
+ # If we are in interactive embedded mode, make sure this is running on the main thread (required for OpenGL)
+ if (
+ self.interactive_mode
+ and config.renderer == RendererType.OPENGL
+ and threading.current_thread().name != "MainThread"
+ ):
+ kwargs.update(
+ {
+ "subcaption": subcaption,
+ "subcaption_duration": subcaption_duration,
+ "subcaption_offset": subcaption_offset,
+ }
+ )
+ self.queue.put(
+ (
+ "play",
+ args,
+ kwargs,
+ )
+ )
+ return
+
+ start_time = self.renderer.time
+ self.renderer.play(self, *args, **kwargs)
+ run_time = self.renderer.time - start_time
+ if subcaption:
+ if subcaption_duration is None:
+ subcaption_duration = run_time
+ # The start of the subcaption needs to be offset by the
+ # run_time of the animation because it is added after
+ # the animation has already been played (and Scene.renderer.time
+ # has already been updated).
+ self.add_subcaption(
+ content=subcaption,
+ duration=subcaption_duration,
+ offset=-run_time + subcaption_offset,
+ )
+
+ def wait(
+ self,
+ duration: float = DEFAULT_WAIT_TIME,
+ stop_condition: Callable[[], bool] | None = None,
+ frozen_frame: bool | None = None,
+ ):
+ """Plays a "no operation" animation.
+
+ Parameters
+ ----------
+ duration
+ The run time of the animation.
+ stop_condition
+ A function without positional arguments that is evaluated every time
+ a frame is rendered. The animation only stops when the return value
+ of the function is truthy, or when the time specified in ``duration``
+ passes.
+ frozen_frame
+ If True, updater functions are not evaluated, and the animation outputs
+ a frozen frame. If False, updater functions are called and frames
+ are rendered as usual. If None (the default), the scene tries to
+ determine whether or not the frame is frozen on its own.
+
+ See also
+ --------
+ :class:`.Wait`, :meth:`.should_mobjects_update`
+ """
+ self.play(
+ Wait(
+ run_time=duration,
+ stop_condition=stop_condition,
+ frozen_frame=frozen_frame,
+ )
+ )
+
+ def pause(self, duration: float = DEFAULT_WAIT_TIME):
+ """Pauses the scene (i.e., displays a frozen frame).
+
+ This is an alias for :meth:`.wait` with ``frozen_frame``
+ set to ``True``.
+
+ Parameters
+ ----------
+ duration
+ The duration of the pause.
+
+ See also
+ --------
+ :meth:`.wait`, :class:`.Wait`
+ """
+ self.wait(duration=duration, frozen_frame=True)
+
+ def wait_until(self, stop_condition: Callable[[], bool], max_time: float = 60):
+ """Wait until a condition is satisfied, up to a given maximum duration.
+
+ Parameters
+ ----------
+ stop_condition
+ A function with no arguments that determines whether or not the
+ scene should keep waiting.
+ max_time
+ The maximum wait time in seconds.
+ """
+ self.wait(max_time, stop_condition=stop_condition)
+
+ def compile_animation_data(self, *animations: Animation, **play_kwargs):
+ """Given a list of animations, compile the corresponding
+ static and moving mobjects, and gather the animation durations.
+
+ This also begins the animations.
+
+ Parameters
+ ----------
+ animations
+ Animation or mobject with mobject method and params
+ play_kwargs
+ Named parameters affecting what was passed in ``animations``,
+ e.g. ``run_time``, ``lag_ratio`` and so on.
+
+ Returns
+ -------
+ self, None
+ None if there is nothing to play, or self otherwise.
+ """
+ # NOTE TODO : returns statement of this method are wrong. It should return nothing, as it makes a little sense to get any information from this method.
+ # The return are kept to keep webgl renderer from breaking.
+ if len(animations) == 0:
+ raise ValueError("Called Scene.play with no animations")
+
+ self.animations = self.compile_animations(*animations, **play_kwargs)
+ self.add_mobjects_from_animations(self.animations)
+
+ self.last_t = 0
+ self.stop_condition = None
+ self.moving_mobjects = []
+ self.static_mobjects = []
+
+ if len(self.animations) == 1 and isinstance(self.animations[0], Wait):
+ if self.should_update_mobjects():
+ self.update_mobjects(dt=0) # Any problems with this?
+ self.stop_condition = self.animations[0].stop_condition
+ else:
+ self.duration = self.animations[0].duration
+ # Static image logic when the wait is static is done by the renderer, not here.
+ self.animations[0].is_static_wait = True
+ return None
+ self.duration = self.get_run_time(self.animations)
+ return self
+
+ def begin_animations(self) -> None:
+ """Start the animations of the scene."""
+ for animation in self.animations:
+ animation._setup_scene(self)
+ animation.begin()
+
+ if config.renderer == RendererType.CAIRO:
+ # Paint all non-moving objects onto the screen, so they don't
+ # have to be rendered every frame
+ (
+ self.moving_mobjects,
+ self.static_mobjects,
+ ) = self.get_moving_and_static_mobjects(self.animations)
+
+ def is_current_animation_frozen_frame(self) -> bool:
+ """Returns whether the current animation produces a static frame (generally a Wait)."""
+ return (
+ isinstance(self.animations[0], Wait)
+ and len(self.animations) == 1
+ and self.animations[0].is_static_wait
+ )
+
+ def play_internal(self, skip_rendering: bool = False):
+ """
+ This method is used to prep the animations for rendering,
+ apply the arguments and parameters required to them,
+ render them, and write them to the video file.
+
+ Parameters
+ ----------
+ skip_rendering
+ Whether the rendering should be skipped, by default False
+ """
+ self.duration = self.get_run_time(self.animations)
+ self.time_progression = self._get_animation_time_progression(
+ self.animations,
+ self.duration,
+ )
+ for t in self.time_progression:
+ self.update_to_time(t)
+ if not skip_rendering and not self.skip_animation_preview:
+ self.renderer.render(self, t, self.moving_mobjects)
+ if self.stop_condition is not None and self.stop_condition():
+ self.time_progression.close()
+ break
+
+ for animation in self.animations:
+ animation.finish()
+ animation.clean_up_from_scene(self)
+ if not self.renderer.skip_animations:
+ self.update_mobjects(0)
+ self.renderer.static_image = None
+ # Closing the progress bar at the end of the play.
+ self.time_progression.close()
+
+ def check_interactive_embed_is_valid(self):
+ if config["force_window"]:
+ return True
+ if self.skip_animation_preview:
+ logger.warning(
+ "Disabling interactive embed as 'skip_animation_preview' is enabled",
+ )
+ return False
+ elif config["write_to_movie"]:
+ logger.warning("Disabling interactive embed as 'write_to_movie' is enabled")
+ return False
+ elif config["format"]:
+ logger.warning(
+ "Disabling interactive embed as '--format' is set as "
+ + config["format"],
+ )
+ return False
+ elif not self.renderer.window:
+ logger.warning("Disabling interactive embed as no window was created")
+ return False
+ elif config.dry_run:
+ logger.warning("Disabling interactive embed as dry_run is enabled")
+ return False
+ return True
+
+ def interactive_embed(self):
+ """
+ Like embed(), but allows for screen interaction.
+ """
+ if not self.check_interactive_embed_is_valid():
+ return
+ self.interactive_mode = True
+
+ def ipython(shell, namespace):
+ import manim.opengl
+
+ def load_module_into_namespace(module, namespace):
+ for name in dir(module):
+ namespace[name] = getattr(module, name)
+
+ load_module_into_namespace(manim, namespace)
+ load_module_into_namespace(manim.opengl, namespace)
+
+ def embedded_rerun(*args, **kwargs):
+ self.queue.put(("rerun_keyboard", args, kwargs))
+ shell.exiter()
+
+ namespace["rerun"] = embedded_rerun
+
+ shell(local_ns=namespace)
+ self.queue.put(("exit_keyboard", [], {}))
+
+ def get_embedded_method(method_name):
+ return lambda *args, **kwargs: self.queue.put((method_name, args, kwargs))
+
+ local_namespace = inspect.currentframe().f_back.f_locals
+ for method in ("play", "wait", "add", "remove"):
+ embedded_method = get_embedded_method(method)
+ # Allow for calling scene methods without prepending 'self.'.
+ local_namespace[method] = embedded_method
+
+ from sqlite3 import connect
+
+ from IPython.core.getipython import get_ipython
+ from IPython.terminal.embed import InteractiveShellEmbed
+ from traitlets.config import Config
+
+ cfg = Config()
+ cfg.TerminalInteractiveShell.confirm_exit = False
+ if get_ipython() is None:
+ shell = InteractiveShellEmbed.instance(config=cfg)
+ else:
+ shell = InteractiveShellEmbed(config=cfg)
+ hist = get_ipython().history_manager
+ hist.db = connect(hist.hist_file, check_same_thread=False)
+
+ keyboard_thread = threading.Thread(
+ target=ipython,
+ args=(shell, local_namespace),
+ )
+ # run as daemon to kill thread when main thread exits
+ if not shell.pt_app:
+ keyboard_thread.daemon = True
+ keyboard_thread.start()
+
+ if self.dearpygui_imported and config["enable_gui"]:
+ if not dpg.is_dearpygui_running():
+ gui_thread = threading.Thread(
+ target=configure_pygui,
+ args=(self.renderer, self.widgets),
+ kwargs={"update": False},
+ )
+ gui_thread.start()
+ else:
+ configure_pygui(self.renderer, self.widgets, update=True)
+
+ self.camera.model_matrix = self.camera.default_model_matrix
+
+ self.interact(shell, keyboard_thread)
+
+ def interact(self, shell, keyboard_thread):
+ event_handler = RerunSceneHandler(self.queue)
+ file_observer = Observer()
+ file_observer.schedule(event_handler, config["input_file"], recursive=True)
+ file_observer.start()
+
+ self.quit_interaction = False
+ keyboard_thread_needs_join = shell.pt_app is not None
+ assert self.queue.qsize() == 0
+
+ last_time = time.time()
+ while not (self.renderer.window.is_closing or self.quit_interaction):
+ if not self.queue.empty():
+ tup = self.queue.get_nowait()
+ if tup[0].startswith("rerun"):
+ # Intentionally skip calling join() on the file thread to save time.
+ if not tup[0].endswith("keyboard"):
+ if shell.pt_app:
+ shell.pt_app.app.exit(exception=EOFError)
+ file_observer.unschedule_all()
+ raise RerunSceneException
+ keyboard_thread.join()
+
+ kwargs = tup[2]
+ if "from_animation_number" in kwargs:
+ config["from_animation_number"] = kwargs[
+ "from_animation_number"
+ ]
+ # # TODO: This option only makes sense if interactive_embed() is run at the
+ # # end of a scene by default.
+ # if "upto_animation_number" in kwargs:
+ # config["upto_animation_number"] = kwargs[
+ # "upto_animation_number"
+ # ]
+
+ keyboard_thread.join()
+ file_observer.unschedule_all()
+ raise RerunSceneException
+ elif tup[0].startswith("exit"):
+ # Intentionally skip calling join() on the file thread to save time.
+ if not tup[0].endswith("keyboard") and shell.pt_app:
+ shell.pt_app.app.exit(exception=EOFError)
+ keyboard_thread.join()
+ # Remove exit_keyboard from the queue if necessary.
+ while self.queue.qsize() > 0:
+ self.queue.get()
+ keyboard_thread_needs_join = False
+ break
+ else:
+ method, args, kwargs = tup
+ getattr(self, method)(*args, **kwargs)
+ else:
+ self.renderer.animation_start_time = 0
+ dt = time.time() - last_time
+ last_time = time.time()
+ self.renderer.render(self, dt, self.moving_mobjects)
+ self.update_mobjects(dt)
+ self.update_meshes(dt)
+ self.update_self(dt)
+
+ # Join the keyboard thread if necessary.
+ if shell is not None and keyboard_thread_needs_join:
+ shell.pt_app.app.exit(exception=EOFError)
+ keyboard_thread.join()
+ # Remove exit_keyboard from the queue if necessary.
+ while self.queue.qsize() > 0:
+ self.queue.get()
+
+ file_observer.stop()
+ file_observer.join()
+
+ if self.dearpygui_imported and config["enable_gui"]:
+ dpg.stop_dearpygui()
+
+ if self.renderer.window.is_closing:
+ self.renderer.window.destroy()
+
+ def embed(self):
+ if not config["preview"]:
+ logger.warning("Called embed() while no preview window is available.")
+ return
+ if config["write_to_movie"]:
+ logger.warning("embed() is skipped while writing to a file.")
+ return
+
+ self.renderer.animation_start_time = 0
+ self.renderer.render(self, -1, self.moving_mobjects)
+
+ # Configure IPython shell.
+ from IPython.terminal.embed import InteractiveShellEmbed
+
+ shell = InteractiveShellEmbed()
+
+ # Have the frame update after each command
+ shell.events.register(
+ "post_run_cell",
+ lambda *a, **kw: self.renderer.render(self, -1, self.moving_mobjects),
+ )
+
+ # Use the locals of the caller as the local namespace
+ # once embedded, and add a few custom shortcuts.
+ local_ns = inspect.currentframe().f_back.f_locals
+ # local_ns["touch"] = self.interact
+ for method in (
+ "play",
+ "wait",
+ "add",
+ "remove",
+ "interact",
+ # "clear",
+ # "save_state",
+ # "restore",
+ ):
+ local_ns[method] = getattr(self, method)
+ shell(local_ns=local_ns, stack_depth=2)
+
+ # End scene when exiting an embed.
+ raise Exception("Exiting scene.")
+
+ def update_to_time(self, t):
+ dt = t - self.last_t
+ self.last_t = t
+ for animation in self.animations:
+ animation.update_mobjects(dt)
+ alpha = t / animation.run_time
+ animation.interpolate(alpha)
+ self.update_mobjects(dt)
+ self.update_meshes(dt)
+ self.update_self(dt)
+
+ def add_subcaption(
+ self, content: str, duration: float = 1, offset: float = 0
+ ) -> None:
+ r"""Adds an entry in the corresponding subcaption file
+ at the current time stamp.
+
+ The current time stamp is obtained from ``Scene.renderer.time``.
+
+ Parameters
+ ----------
+
+ content
+ The subcaption content.
+ duration
+ The duration (in seconds) for which the subcaption is shown.
+ offset
+ This offset (in seconds) is added to the starting time stamp
+ of the subcaption.
+
+ Examples
+ --------
+
+ This example illustrates both possibilities for adding
+ subcaptions to Manimations::
+
+ class SubcaptionExample(Scene):
+ def construct(self):
+ square = Square()
+ circle = Circle()
+
+ # first option: via the add_subcaption method
+ self.add_subcaption("Hello square!", duration=1)
+ self.play(Create(square))
+
+ # second option: within the call to Scene.play
+ self.play(
+ Transform(square, circle),
+ subcaption="The square transforms."
+ )
+
+ """
+ subtitle = srt.Subtitle(
+ index=len(self.renderer.file_writer.subcaptions),
+ content=content,
+ start=datetime.timedelta(seconds=float(self.renderer.time + offset)),
+ end=datetime.timedelta(
+ seconds=float(self.renderer.time + offset + duration)
+ ),
+ )
+ self.renderer.file_writer.subcaptions.append(subtitle)
+
+ def add_sound(
+ self,
+ sound_file: str,
+ time_offset: float = 0,
+ gain: float | None = None,
+ **kwargs,
+ ):
+ """
+ This method is used to add a sound to the animation.
+
+ Parameters
+ ----------
+
+ sound_file
+ The path to the sound file.
+ time_offset
+ The offset in the sound file after which
+ the sound can be played.
+ gain
+ Amplification of the sound.
+
+ Examples
+ --------
+ .. manim:: SoundExample
+ :no_autoplay:
+
+ class SoundExample(Scene):
+ # Source of sound under Creative Commons 0 License. https://freesound.org/people/Druminfected/sounds/250551/
+ def construct(self):
+ dot = Dot().set_color(GREEN)
+ self.add_sound("click.wav")
+ self.add(dot)
+ self.wait()
+ self.add_sound("click.wav")
+ dot.set_color(BLUE)
+ self.wait()
+ self.add_sound("click.wav")
+ dot.set_color(RED)
+ self.wait()
+
+ Download the resource for the previous example `here `_ .
+ """
+ if self.renderer.skip_animations:
+ return
+ time = self.renderer.time + time_offset
+ self.renderer.file_writer.add_sound(sound_file, time, gain, **kwargs)
+
+ def on_mouse_motion(self, point, d_point):
+ self.mouse_point.move_to(point)
+ if SHIFT_VALUE in self.renderer.pressed_keys:
+ shift = -d_point
+ shift[0] *= self.camera.get_width() / 2
+ shift[1] *= self.camera.get_height() / 2
+ transform = self.camera.inverse_rotation_matrix
+ shift = np.dot(np.transpose(transform), shift)
+ self.camera.shift(shift)
+
+ def on_mouse_scroll(self, point, offset):
+ if not config.use_projection_stroke_shaders:
+ factor = 1 + np.arctan(-2.1 * offset[1])
+ self.camera.scale(factor, about_point=self.camera_target)
+ self.mouse_scroll_orbit_controls(point, offset)
+
+ def on_key_press(self, symbol, modifiers):
+ try:
+ char = chr(symbol)
+ except OverflowError:
+ logger.warning("The value of the pressed key is too large.")
+ return
+
+ if char == "r":
+ self.camera.to_default_state()
+ self.camera_target = np.array([0, 0, 0], dtype=np.float32)
+ elif char == "q":
+ self.quit_interaction = True
+ else:
+ if char in self.key_to_function_map:
+ self.key_to_function_map[char]()
+
+ def on_key_release(self, symbol, modifiers):
+ pass
+
+ def on_mouse_drag(self, point, d_point, buttons, modifiers):
+ self.mouse_drag_point.move_to(point)
+ if buttons == 1:
+ self.camera.increment_theta(-d_point[0])
+ self.camera.increment_phi(d_point[1])
+ elif buttons == 4:
+ camera_x_axis = self.camera.model_matrix[:3, 0]
+ horizontal_shift_vector = -d_point[0] * camera_x_axis
+ vertical_shift_vector = -d_point[1] * np.cross(OUT, camera_x_axis)
+ total_shift_vector = horizontal_shift_vector + vertical_shift_vector
+ self.camera.shift(1.1 * total_shift_vector)
+
+ self.mouse_drag_orbit_controls(point, d_point, buttons, modifiers)
+
+ def mouse_scroll_orbit_controls(self, point, offset):
+ camera_to_target = self.camera_target - self.camera.get_position()
+ camera_to_target *= np.sign(offset[1])
+ shift_vector = 0.01 * camera_to_target
+ self.camera.model_matrix = (
+ opengl.translation_matrix(*shift_vector) @ self.camera.model_matrix
+ )
+
+ def mouse_drag_orbit_controls(self, point, d_point, buttons, modifiers):
+ # Left click drag.
+ if buttons == 1:
+ # Translate to target the origin and rotate around the z axis.
+ self.camera.model_matrix = (
+ opengl.rotation_matrix(z=-d_point[0])
+ @ opengl.translation_matrix(*-self.camera_target)
+ @ self.camera.model_matrix
+ )
+
+ # Rotation off of the z axis.
+ camera_position = self.camera.get_position()
+ camera_y_axis = self.camera.model_matrix[:3, 1]
+ axis_of_rotation = space_ops.normalize(
+ np.cross(camera_y_axis, camera_position),
+ )
+ rotation_matrix = space_ops.rotation_matrix(
+ d_point[1],
+ axis_of_rotation,
+ homogeneous=True,
+ )
+
+ maximum_polar_angle = self.camera.maximum_polar_angle
+ minimum_polar_angle = self.camera.minimum_polar_angle
+
+ potential_camera_model_matrix = rotation_matrix @ self.camera.model_matrix
+ potential_camera_location = potential_camera_model_matrix[:3, 3]
+ potential_camera_y_axis = potential_camera_model_matrix[:3, 1]
+ sign = (
+ np.sign(potential_camera_y_axis[2])
+ if potential_camera_y_axis[2] != 0
+ else 1
+ )
+ potential_polar_angle = sign * np.arccos(
+ potential_camera_location[2]
+ / np.linalg.norm(potential_camera_location),
+ )
+ if minimum_polar_angle <= potential_polar_angle <= maximum_polar_angle:
+ self.camera.model_matrix = potential_camera_model_matrix
+ else:
+ sign = np.sign(camera_y_axis[2]) if camera_y_axis[2] != 0 else 1
+ current_polar_angle = sign * np.arccos(
+ camera_position[2] / np.linalg.norm(camera_position),
+ )
+ if potential_polar_angle > maximum_polar_angle:
+ polar_angle_delta = maximum_polar_angle - current_polar_angle
+ else:
+ polar_angle_delta = minimum_polar_angle - current_polar_angle
+ rotation_matrix = space_ops.rotation_matrix(
+ polar_angle_delta,
+ axis_of_rotation,
+ homogeneous=True,
+ )
+ self.camera.model_matrix = rotation_matrix @ self.camera.model_matrix
+
+ # Translate to target the original target.
+ self.camera.model_matrix = (
+ opengl.translation_matrix(*self.camera_target)
+ @ self.camera.model_matrix
+ )
+ # Right click drag.
+ elif buttons == 4:
+ camera_x_axis = self.camera.model_matrix[:3, 0]
+ horizontal_shift_vector = -d_point[0] * camera_x_axis
+ vertical_shift_vector = -d_point[1] * np.cross(OUT, camera_x_axis)
+ total_shift_vector = horizontal_shift_vector + vertical_shift_vector
+
+ self.camera.model_matrix = (
+ opengl.translation_matrix(*total_shift_vector)
+ @ self.camera.model_matrix
+ )
+ self.camera_target += total_shift_vector
+
+ def set_key_function(self, char, func):
+ self.key_to_function_map[char] = func
+
+ def on_mouse_press(self, point, button, modifiers):
+ for func in self.mouse_press_callbacks:
+ func()
diff --git a/data/rag/manim_docs/manim_core/source/scene/scene_file_writer.py b/data/rag/manim_docs/manim_core/source/scene/scene_file_writer.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9e509de8953e42d4c1a68426649aa00a7b456da
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/scene/scene_file_writer.py
@@ -0,0 +1,735 @@
+"""The interface between scenes and ffmpeg."""
+
+from __future__ import annotations
+
+__all__ = ["SceneFileWriter"]
+
+import json
+import os
+import shutil
+import subprocess
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import srt
+from PIL import Image
+from pydub import AudioSegment
+
+from manim import __version__
+
+from .. import config, logger
+from .._config.logger_utils import set_file_logger
+from ..constants import RendererType
+from ..utils.file_ops import (
+ add_extension_if_not_present,
+ add_version_before_extension,
+ ensure_executable,
+ guarantee_existence,
+ is_gif_format,
+ is_png_format,
+ is_webm_format,
+ modify_atime,
+ write_to_movie,
+)
+from ..utils.sounds import get_full_sound_file_path
+from .section import DefaultSectionType, Section
+
+if TYPE_CHECKING:
+ from manim.renderer.opengl_renderer import OpenGLRenderer
+
+
+class SceneFileWriter:
+ """
+ SceneFileWriter is the object that actually writes the animations
+ played, into video files, using FFMPEG.
+ This is mostly for Manim's internal use. You will rarely, if ever,
+ have to use the methods for this class, unless tinkering with the very
+ fabric of Manim's reality.
+
+ Attributes
+ ----------
+ sections : list of :class:`.Section`
+ used to segment scene
+
+ sections_output_dir : :class:`pathlib.Path`
+ where are section videos stored
+
+ output_name : str
+ name of movie without extension and basis for section video names
+
+ Some useful attributes are:
+ "write_to_movie" (bool=False)
+ Whether or not to write the animations into a video file.
+ "movie_file_extension" (str=".mp4")
+ The file-type extension of the outputted video.
+ "partial_movie_files"
+ List of all the partial-movie files.
+
+ """
+
+ force_output_as_scene_name = False
+
+ def __init__(self, renderer, scene_name, **kwargs):
+ self.renderer = renderer
+ self.init_output_directories(scene_name)
+ self.init_audio()
+ self.frame_count = 0
+ self.partial_movie_files: list[str] = []
+ self.subcaptions: list[srt.Subtitle] = []
+ self.sections: list[Section] = []
+ # first section gets automatically created for convenience
+ # if you need the first section to be skipped, add a first section by hand, it will replace this one
+ self.next_section(
+ name="autocreated", type=DefaultSectionType.NORMAL, skip_animations=False
+ )
+ # fail fast if ffmpeg is not found
+ if not ensure_executable(Path(config.ffmpeg_executable)):
+ raise RuntimeError(
+ "Manim could not find ffmpeg, which is required for generating video output.\n"
+ "For installing ffmpeg please consult https://docs.manim.community/en/stable/installation.html\n"
+ "Make sure to either add ffmpeg to the PATH environment variable\n"
+ "or set path to the ffmpeg executable under the ffmpeg header in Manim's configuration."
+ )
+
+ def init_output_directories(self, scene_name):
+ """Initialise output directories.
+
+ Notes
+ -----
+ The directories are read from ``config``, for example
+ ``config['media_dir']``. If the target directories don't already
+ exist, they will be created.
+
+ """
+ if config["dry_run"]: # in dry-run mode there is no output
+ return
+
+ if config["input_file"]:
+ module_name = config.get_dir("input_file").stem
+ else:
+ module_name = ""
+
+ if SceneFileWriter.force_output_as_scene_name:
+ self.output_name = Path(scene_name)
+ elif config["output_file"] and not config["write_all"]:
+ self.output_name = config.get_dir("output_file")
+ else:
+ self.output_name = Path(scene_name)
+
+ if config["media_dir"]:
+ image_dir = guarantee_existence(
+ config.get_dir(
+ "images_dir", module_name=module_name, scene_name=scene_name
+ ),
+ )
+ self.image_file_path = image_dir / add_extension_if_not_present(
+ self.output_name, ".png"
+ )
+
+ if write_to_movie():
+ movie_dir = guarantee_existence(
+ config.get_dir(
+ "video_dir", module_name=module_name, scene_name=scene_name
+ ),
+ )
+ self.movie_file_path = movie_dir / add_extension_if_not_present(
+ self.output_name, config["movie_file_extension"]
+ )
+
+ # TODO: /dev/null would be good in case sections_output_dir is used without bein set (doesn't work on Windows), everyone likes defensive programming, right?
+ self.sections_output_dir = Path("")
+ if config.save_sections:
+ self.sections_output_dir = guarantee_existence(
+ config.get_dir(
+ "sections_dir", module_name=module_name, scene_name=scene_name
+ )
+ )
+
+ if is_gif_format():
+ self.gif_file_path = add_extension_if_not_present(
+ self.output_name, ".gif"
+ )
+
+ if not config["output_file"]:
+ self.gif_file_path = add_version_before_extension(
+ self.gif_file_path
+ )
+
+ self.gif_file_path = movie_dir / self.gif_file_path
+
+ self.partial_movie_directory = guarantee_existence(
+ config.get_dir(
+ "partial_movie_dir",
+ scene_name=scene_name,
+ module_name=module_name,
+ ),
+ )
+
+ if config["log_to_file"]:
+ log_dir = guarantee_existence(config.get_dir("log_dir"))
+ set_file_logger(
+ scene_name=scene_name, module_name=module_name, log_dir=log_dir
+ )
+
+ def finish_last_section(self) -> None:
+ """Delete current section if it is empty."""
+ if len(self.sections) and self.sections[-1].is_empty():
+ self.sections.pop()
+
+ def next_section(self, name: str, type: str, skip_animations: bool) -> None:
+ """Create segmentation cut here."""
+ self.finish_last_section()
+
+ # images don't support sections
+ section_video: str | None = None
+ # don't save when None
+ if (
+ not config.dry_run
+ and write_to_movie()
+ and config.save_sections
+ and not skip_animations
+ ):
+ # relative to index file
+ section_video = f"{self.output_name}_{len(self.sections):04}{config.movie_file_extension}"
+
+ self.sections.append(
+ Section(
+ type,
+ section_video,
+ name,
+ skip_animations,
+ ),
+ )
+
+ def add_partial_movie_file(self, hash_animation: str):
+ """Adds a new partial movie file path to `scene.partial_movie_files` and current section from a hash.
+ This method will compute the path from the hash. In addition to that it adds the new animation to the current section.
+
+ Parameters
+ ----------
+ hash_animation
+ Hash of the animation.
+ """
+ if not hasattr(self, "partial_movie_directory") or not write_to_movie():
+ return
+
+ # None has to be added to partial_movie_files to keep the right index with scene.num_plays.
+ # i.e if an animation is skipped, scene.num_plays is still incremented and we add an element to partial_movie_file be even with num_plays.
+ if hash_animation is None:
+ self.partial_movie_files.append(None)
+ self.sections[-1].partial_movie_files.append(None)
+ else:
+ new_partial_movie_file = str(
+ self.partial_movie_directory
+ / f"{hash_animation}{config['movie_file_extension']}"
+ )
+ self.partial_movie_files.append(new_partial_movie_file)
+ self.sections[-1].partial_movie_files.append(new_partial_movie_file)
+
+ def get_resolution_directory(self):
+ """Get the name of the resolution directory directly containing
+ the video file.
+
+ This method gets the name of the directory that immediately contains the
+ video file. This name is ``p``.
+ For example, if you are rendering an 854x480 px animation at 15fps,
+ the name of the directory that immediately contains the video, file
+ will be ``480p15``.
+
+ The file structure should look something like::
+
+ MEDIA_DIR
+ |--Tex
+ |--texts
+ |--videos
+ |--
+ |--p
+ |--.mp4
+
+ Returns
+ -------
+ :class:`str`
+ The name of the directory.
+ """
+ pixel_height = config["pixel_height"]
+ frame_rate = config["frame_rate"]
+ return f"{pixel_height}p{frame_rate}"
+
+ # Sound
+ def init_audio(self):
+ """
+ Preps the writer for adding audio to the movie.
+ """
+ self.includes_sound = False
+
+ def create_audio_segment(self):
+ """
+ Creates an empty, silent, Audio Segment.
+ """
+ self.audio_segment = AudioSegment.silent()
+
+ def add_audio_segment(
+ self,
+ new_segment: AudioSegment,
+ time: float | None = None,
+ gain_to_background: float | None = None,
+ ):
+ """
+ This method adds an audio segment from an
+ AudioSegment type object and suitable parameters.
+
+ Parameters
+ ----------
+ new_segment
+ The audio segment to add
+
+ time
+ the timestamp at which the
+ sound should be added.
+
+ gain_to_background
+ The gain of the segment from the background.
+ """
+ if not self.includes_sound:
+ self.includes_sound = True
+ self.create_audio_segment()
+ segment = self.audio_segment
+ curr_end = segment.duration_seconds
+ if time is None:
+ time = curr_end
+ if time < 0:
+ raise ValueError("Adding sound at timestamp < 0")
+
+ new_end = time + new_segment.duration_seconds
+ diff = new_end - curr_end
+ if diff > 0:
+ segment = segment.append(
+ AudioSegment.silent(int(np.ceil(diff * 1000))),
+ crossfade=0,
+ )
+ self.audio_segment = segment.overlay(
+ new_segment,
+ position=int(1000 * time),
+ gain_during_overlay=gain_to_background,
+ )
+
+ def add_sound(
+ self,
+ sound_file: str,
+ time: float | None = None,
+ gain: float | None = None,
+ **kwargs,
+ ):
+ """
+ This method adds an audio segment from a sound file.
+
+ Parameters
+ ----------
+ sound_file
+ The path to the sound file.
+
+ time
+ The timestamp at which the audio should be added.
+
+ gain
+ The gain of the given audio segment.
+
+ **kwargs
+ This method uses add_audio_segment, so any keyword arguments
+ used there can be referenced here.
+
+ """
+ file_path = get_full_sound_file_path(sound_file)
+ new_segment = AudioSegment.from_file(file_path)
+ if gain:
+ new_segment = new_segment.apply_gain(gain)
+ self.add_audio_segment(new_segment, time, **kwargs)
+
+ # Writers
+ def begin_animation(self, allow_write: bool = False, file_path=None):
+ """
+ Used internally by manim to stream the animation to FFMPEG for
+ displaying or writing to a file.
+
+ Parameters
+ ----------
+ allow_write
+ Whether or not to write to a video file.
+ """
+ if write_to_movie() and allow_write:
+ self.open_movie_pipe(file_path=file_path)
+
+ def end_animation(self, allow_write: bool = False):
+ """
+ Internally used by Manim to stop streaming to
+ FFMPEG gracefully.
+
+ Parameters
+ ----------
+ allow_write
+ Whether or not to write to a video file.
+ """
+ if write_to_movie() and allow_write:
+ self.close_movie_pipe()
+
+ def write_frame(self, frame_or_renderer: np.ndarray | OpenGLRenderer):
+ """
+ Used internally by Manim to write a frame to
+ the FFMPEG input buffer.
+
+ Parameters
+ ----------
+ frame_or_renderer
+ Pixel array of the frame.
+ """
+ if config.renderer == RendererType.OPENGL:
+ self.write_opengl_frame(frame_or_renderer)
+ elif config.renderer == RendererType.CAIRO:
+ frame = frame_or_renderer
+ if write_to_movie():
+ self.writing_process.stdin.write(frame.tobytes())
+ if is_png_format() and not config["dry_run"]:
+ self.output_image_from_array(frame)
+
+ def write_opengl_frame(self, renderer: OpenGLRenderer):
+ if write_to_movie():
+ self.writing_process.stdin.write(
+ renderer.get_raw_frame_buffer_object_data(),
+ )
+ elif is_png_format() and not config["dry_run"]:
+ target_dir = self.image_file_path.parent / self.image_file_path.stem
+ extension = self.image_file_path.suffix
+ self.output_image(
+ renderer.get_image(),
+ target_dir,
+ extension,
+ config["zero_pad"],
+ )
+
+ def output_image_from_array(self, frame_data):
+ target_dir = self.image_file_path.parent / self.image_file_path.stem
+ extension = self.image_file_path.suffix
+ self.output_image(
+ Image.fromarray(frame_data),
+ target_dir,
+ extension,
+ config["zero_pad"],
+ )
+
+ def output_image(self, image: Image.Image, target_dir, ext, zero_pad: bool):
+ if zero_pad:
+ image.save(f"{target_dir}{str(self.frame_count).zfill(zero_pad)}{ext}")
+ else:
+ image.save(f"{target_dir}{self.frame_count}{ext}")
+ self.frame_count += 1
+
+ def save_final_image(self, image: np.ndarray):
+ """
+ The name is a misnomer. This method saves the image
+ passed to it as an in the default image directory.
+
+ Parameters
+ ----------
+ image
+ The pixel array of the image to save.
+ """
+ if config["dry_run"]:
+ return
+ if not config["output_file"]:
+ self.image_file_path = add_version_before_extension(self.image_file_path)
+
+ image.save(self.image_file_path)
+ self.print_file_ready_message(self.image_file_path)
+
+ def finish(self):
+ """
+ Finishes writing to the FFMPEG buffer or writing images
+ to output directory.
+ Combines the partial movie files into the
+ whole scene.
+ If save_last_frame is True, saves the last
+ frame in the default image directory.
+ """
+ if write_to_movie():
+ if hasattr(self, "writing_process"):
+ self.writing_process.terminate()
+ self.combine_to_movie()
+ if config.save_sections:
+ self.combine_to_section_videos()
+ if config["flush_cache"]:
+ self.flush_cache_directory()
+ else:
+ self.clean_cache()
+ elif is_png_format() and not config["dry_run"]:
+ target_dir = self.image_file_path.parent / self.image_file_path.stem
+ logger.info("\n%i images ready at %s\n", self.frame_count, str(target_dir))
+ if self.subcaptions:
+ self.write_subcaption_file()
+
+ def open_movie_pipe(self, file_path=None):
+ """
+ Used internally by Manim to initialise
+ FFMPEG and begin writing to FFMPEG's input
+ buffer.
+ """
+ if file_path is None:
+ file_path = self.partial_movie_files[self.renderer.num_plays]
+ self.partial_movie_file_path = file_path
+
+ fps = config["frame_rate"]
+ if fps == int(fps): # fps is integer
+ fps = int(fps)
+ if config.renderer == RendererType.OPENGL:
+ width, height = self.renderer.get_pixel_shape()
+ else:
+ height = config["pixel_height"]
+ width = config["pixel_width"]
+
+ command = [
+ config.ffmpeg_executable,
+ "-y", # overwrite output file if it exists
+ "-f",
+ "rawvideo",
+ "-s",
+ "%dx%d" % (width, height), # size of one frame
+ "-pix_fmt",
+ "rgba",
+ "-r",
+ str(fps), # frames per second
+ "-i",
+ "-", # The input comes from a pipe
+ "-an", # Tells FFMPEG not to expect any audio
+ "-loglevel",
+ config["ffmpeg_loglevel"].lower(),
+ "-metadata",
+ f"comment=Rendered with Manim Community v{__version__}",
+ ]
+ if config.renderer == RendererType.OPENGL:
+ command += ["-vf", "vflip"]
+ if is_webm_format():
+ command += ["-vcodec", "libvpx-vp9", "-auto-alt-ref", "0"]
+ # .mov format
+ elif config["transparent"]:
+ command += ["-vcodec", "qtrle"]
+ else:
+ command += ["-vcodec", "libx264", "-pix_fmt", "yuv420p"]
+ command += [file_path]
+ self.writing_process = subprocess.Popen(command, stdin=subprocess.PIPE)
+
+ def close_movie_pipe(self):
+ """
+ Used internally by Manim to gracefully stop writing to FFMPEG's input buffer
+ """
+ self.writing_process.stdin.close()
+ self.writing_process.wait()
+
+ logger.info(
+ f"Animation {self.renderer.num_plays} : Partial movie file written in %(path)s",
+ {"path": f"'{self.partial_movie_file_path}'"},
+ )
+
+ def is_already_cached(self, hash_invocation: str):
+ """Will check if a file named with `hash_invocation` exists.
+
+ Parameters
+ ----------
+ hash_invocation
+ The hash corresponding to an invocation to either `scene.play` or `scene.wait`.
+
+ Returns
+ -------
+ :class:`bool`
+ Whether the file exists.
+ """
+ if not hasattr(self, "partial_movie_directory") or not write_to_movie():
+ return False
+ path = (
+ self.partial_movie_directory
+ / f"{hash_invocation}{config['movie_file_extension']}"
+ )
+ return path.exists()
+
+ def combine_files(
+ self,
+ input_files: list[str],
+ output_file: Path,
+ create_gif=False,
+ includes_sound=False,
+ ):
+ file_list = self.partial_movie_directory / "partial_movie_file_list.txt"
+ logger.debug(
+ f"Partial movie files to combine ({len(input_files)} files): %(p)s",
+ {"p": input_files[:5]},
+ )
+ with file_list.open("w", encoding="utf-8") as fp:
+ fp.write("# This file is used internally by FFMPEG.\n")
+ for pf_path in input_files:
+ pf_path = Path(pf_path).as_posix()
+ fp.write(f"file 'file:{pf_path}'\n")
+ commands = [
+ config.ffmpeg_executable,
+ "-y", # overwrite output file if it exists
+ "-f",
+ "concat",
+ "-safe",
+ "0",
+ "-i",
+ str(file_list),
+ "-loglevel",
+ config.ffmpeg_loglevel.lower(),
+ "-metadata",
+ f"comment=Rendered with Manim Community v{__version__}",
+ "-nostdin",
+ ]
+
+ if create_gif:
+ commands += [
+ "-vf",
+ f"fps={np.clip(config['frame_rate'], 1, 50)},split[s0][s1];[s0]palettegen=stats_mode=diff[p];[s1][p]paletteuse=dither=bayer:bayer_scale=5:diff_mode=rectangle",
+ ]
+ else:
+ commands += ["-c", "copy"]
+
+ if not includes_sound:
+ commands += ["-an"]
+
+ commands += [str(output_file)]
+
+ combine_process = subprocess.Popen(commands)
+ combine_process.wait()
+
+ def combine_to_movie(self):
+ """Used internally by Manim to combine the separate
+ partial movie files that make up a Scene into a single
+ video file for that Scene.
+ """
+ partial_movie_files = [el for el in self.partial_movie_files if el is not None]
+ # NOTE: Here we should do a check and raise an exception if partial
+ # movie file is empty. We can't, as a lot of stuff (in particular, in
+ # tests) use scene initialization, and this error would be raised as
+ # it's just an empty scene initialized.
+
+ # determine output path
+ movie_file_path = self.movie_file_path
+ if is_gif_format():
+ movie_file_path = self.gif_file_path
+ logger.info("Combining to Movie file.")
+ self.combine_files(
+ partial_movie_files,
+ movie_file_path,
+ is_gif_format(),
+ self.includes_sound,
+ )
+
+ # handle sound
+ if self.includes_sound:
+ sound_file_path = movie_file_path.with_suffix(".wav")
+ # Makes sure sound file length will match video file
+ self.add_audio_segment(AudioSegment.silent(0))
+ self.audio_segment.export(
+ sound_file_path,
+ bitrate="312k",
+ )
+ temp_file_path = movie_file_path.with_name(
+ f"{movie_file_path.stem}_temp{movie_file_path.suffix}"
+ )
+ commands = [
+ config.ffmpeg_executable,
+ "-i",
+ str(movie_file_path),
+ "-i",
+ str(sound_file_path),
+ "-y", # overwrite output file if it exists
+ "-c:v",
+ "copy",
+ "-c:a",
+ "aac",
+ "-b:a",
+ "320k",
+ # select video stream from first file
+ "-map",
+ "0:v:0",
+ # select audio stream from second file
+ "-map",
+ "1:a:0",
+ "-loglevel",
+ config.ffmpeg_loglevel.lower(),
+ "-metadata",
+ f"comment=Rendered with Manim Community v{__version__}",
+ # "-shortest",
+ str(temp_file_path),
+ ]
+ subprocess.call(commands)
+ shutil.move(str(temp_file_path), str(movie_file_path))
+ sound_file_path.unlink()
+
+ self.print_file_ready_message(str(movie_file_path))
+ if write_to_movie():
+ for file_path in partial_movie_files:
+ # We have to modify the accessed time so if we have to clean the cache we remove the one used the longest.
+ modify_atime(file_path)
+
+ def combine_to_section_videos(self) -> None:
+ """Concatenate partial movie files for each section."""
+
+ self.finish_last_section()
+ sections_index: list[dict[str, Any]] = []
+ for section in self.sections:
+ # only if section does want to be saved
+ if section.video is not None:
+ logger.info(f"Combining partial files for section '{section.name}'")
+ self.combine_files(
+ section.get_clean_partial_movie_files(),
+ self.sections_output_dir / section.video,
+ )
+ sections_index.append(section.get_dict(self.sections_output_dir))
+ with (self.sections_output_dir / f"{self.output_name}.json").open("w") as file:
+ json.dump(sections_index, file, indent=4)
+
+ def clean_cache(self):
+ """Will clean the cache by removing the oldest partial_movie_files."""
+ cached_partial_movies = [
+ (self.partial_movie_directory / file_name)
+ for file_name in self.partial_movie_directory.iterdir()
+ if file_name != "partial_movie_file_list.txt"
+ ]
+ if len(cached_partial_movies) > config["max_files_cached"]:
+ number_files_to_delete = (
+ len(cached_partial_movies) - config["max_files_cached"]
+ )
+ oldest_files_to_delete = sorted(
+ cached_partial_movies,
+ key=lambda path: path.stat().st_atime,
+ )[:number_files_to_delete]
+ for file_to_delete in oldest_files_to_delete:
+ file_to_delete.unlink()
+ logger.info(
+ f"The partial movie directory is full (> {config['max_files_cached']} files). Therefore, manim has removed the {number_files_to_delete} oldest file(s)."
+ " You can change this behaviour by changing max_files_cached in config.",
+ )
+
+ def flush_cache_directory(self):
+ """Delete all the cached partial movie files"""
+ cached_partial_movies = [
+ self.partial_movie_directory / file_name
+ for file_name in self.partial_movie_directory.iterdir()
+ if file_name != "partial_movie_file_list.txt"
+ ]
+ for f in cached_partial_movies:
+ f.unlink()
+ logger.info(
+ f"Cache flushed. {len(cached_partial_movies)} file(s) deleted in %(par_dir)s.",
+ {"par_dir": self.partial_movie_directory},
+ )
+
+ def write_subcaption_file(self):
+ """Writes the subcaption file."""
+ subcaption_file = Path(config.output_file).with_suffix(".srt")
+ subcaption_file.write_text(srt.compose(self.subcaptions), encoding="utf-8")
+ logger.info(f"Subcaption file has been written as {subcaption_file}")
+
+ def print_file_ready_message(self, file_path):
+ """Prints the "File Ready" message to STDOUT."""
+ config["output_file"] = file_path
+ logger.info("\nFile ready at %(file_path)s\n", {"file_path": f"'{file_path}'"})
diff --git a/data/rag/manim_docs/manim_core/source/scene/section.py b/data/rag/manim_docs/manim_core/source/scene/section.py
new file mode 100644
index 0000000000000000000000000000000000000000..860a969ad50cd4002cb172575f9ffe401032b307
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/scene/section.py
@@ -0,0 +1,102 @@
+"""building blocks of segmented video API"""
+
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from manim import get_video_metadata
+
+
+class DefaultSectionType(str, Enum):
+ """The type of a section can be used for third party applications.
+ A presentation system could for example use the types to created loops.
+
+ Examples
+ --------
+ This class can be reimplemented for more types::
+
+ class PresentationSectionType(str, Enum):
+ # start, end, wait for continuation by user
+ NORMAL = "presentation.normal"
+ # start, end, immediately continue to next section
+ SKIP = "presentation.skip"
+ # start, end, restart, immediately continue to next section when continued by user
+ LOOP = "presentation.loop"
+ # start, end, restart, finish animation first when user continues
+ COMPLETE_LOOP = "presentation.complete_loop"
+ """
+
+ NORMAL = "default.normal"
+
+
+class Section:
+ """A :class:`.Scene` can be segmented into multiple Sections.
+ Refer to :doc:`the documentation` for more info.
+ It consists of multiple animations.
+
+ Attributes
+ ----------
+ type
+ Can be used by a third party applications to classify different types of sections.
+ video
+ Path to video file with animations belonging to section relative to sections directory.
+ If ``None``, then the section will not be saved.
+ name
+ Human readable, non-unique name for this section.
+ skip_animations
+ Skip rendering the animations in this section when ``True``.
+ partial_movie_files
+ Animations belonging to this section.
+
+ See Also
+ --------
+ :class:`.DefaultSectionType`
+ :meth:`.CairoRenderer.update_skipping_status`
+ :meth:`.OpenGLRenderer.update_skipping_status`
+ """
+
+ def __init__(self, type: str, video: str | None, name: str, skip_animations: bool):
+ self.type = type
+ # None when not to be saved -> still keeps section alive
+ self.video: str | None = video
+ self.name = name
+ self.skip_animations = skip_animations
+ self.partial_movie_files: list[str | None] = []
+
+ def is_empty(self) -> bool:
+ """Check whether this section is empty.
+
+ Note that animations represented by ``None`` are also counted.
+ """
+ return len(self.partial_movie_files) == 0
+
+ def get_clean_partial_movie_files(self) -> list[str]:
+ """Return all partial movie files that are not ``None``."""
+ return [el for el in self.partial_movie_files if el is not None]
+
+ def get_dict(self, sections_dir: Path) -> dict[str, Any]:
+ """Get dictionary representation with metadata of output video.
+
+ The output from this function is used from every section to build the sections index file.
+ The output video must have been created in the ``sections_dir`` before executing this method.
+ This is the main part of the Segmented Video API.
+ """
+ if self.video is None:
+ raise ValueError(
+ f"Section '{self.name}' cannot be exported as dict, it does not have a video path assigned to it"
+ )
+
+ video_metadata = get_video_metadata(sections_dir / self.video)
+ return dict(
+ {
+ "name": self.name,
+ "type": self.type,
+ "video": self.video,
+ },
+ **video_metadata,
+ )
+
+ def __repr__(self):
+ return f""
diff --git a/data/rag/manim_docs/manim_core/source/scene/three_d_scene.py b/data/rag/manim_docs/manim_core/source/scene/three_d_scene.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f9e7a651b7fcab5352073369ab4cc6707b2d006
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/scene/three_d_scene.py
@@ -0,0 +1,552 @@
+"""A scene suitable for rendering three-dimensional objects and animations."""
+
+from __future__ import annotations
+
+__all__ = ["ThreeDScene", "SpecialThreeDScene"]
+
+
+import warnings
+from typing import Iterable, Sequence
+
+import numpy as np
+
+from manim.mobject.geometry.line import Line
+from manim.mobject.graphing.coordinate_systems import ThreeDAxes
+from manim.mobject.opengl.opengl_mobject import OpenGLMobject
+from manim.mobject.three_d.three_dimensions import Sphere
+from manim.mobject.value_tracker import ValueTracker
+
+from .. import config
+from ..animation.animation import Animation
+from ..animation.transform import Transform
+from ..camera.three_d_camera import ThreeDCamera
+from ..constants import DEGREES, RendererType
+from ..mobject.mobject import Mobject
+from ..mobject.types.vectorized_mobject import VectorizedPoint, VGroup
+from ..renderer.opengl_renderer import OpenGLCamera
+from ..scene.scene import Scene
+from ..utils.config_ops import merge_dicts_recursively
+
+
+class ThreeDScene(Scene):
+ """
+ This is a Scene, with special configurations and properties that
+ make it suitable for Three Dimensional Scenes.
+ """
+
+ def __init__(
+ self,
+ camera_class=ThreeDCamera,
+ ambient_camera_rotation=None,
+ default_angled_camera_orientation_kwargs=None,
+ **kwargs,
+ ):
+ self.ambient_camera_rotation = ambient_camera_rotation
+ if default_angled_camera_orientation_kwargs is None:
+ default_angled_camera_orientation_kwargs = {
+ "phi": 70 * DEGREES,
+ "theta": -135 * DEGREES,
+ }
+ self.default_angled_camera_orientation_kwargs = (
+ default_angled_camera_orientation_kwargs
+ )
+ super().__init__(camera_class=camera_class, **kwargs)
+
+ def set_camera_orientation(
+ self,
+ phi: float | None = None,
+ theta: float | None = None,
+ gamma: float | None = None,
+ zoom: float | None = None,
+ focal_distance: float | None = None,
+ frame_center: Mobject | Sequence[float] | None = None,
+ **kwargs,
+ ):
+ """
+ This method sets the orientation of the camera in the scene.
+
+ Parameters
+ ----------
+ phi
+ The polar angle i.e the angle between Z_AXIS and Camera through ORIGIN in radians.
+
+ theta
+ The azimuthal angle i.e the angle that spins the camera around the Z_AXIS.
+
+ focal_distance
+ The focal_distance of the Camera.
+
+ gamma
+ The rotation of the camera about the vector from the ORIGIN to the Camera.
+
+ zoom
+ The zoom factor of the scene.
+
+ frame_center
+ The new center of the camera frame in cartesian coordinates.
+
+ """
+
+ if phi is not None:
+ self.renderer.camera.set_phi(phi)
+ if theta is not None:
+ self.renderer.camera.set_theta(theta)
+ if focal_distance is not None:
+ self.renderer.camera.set_focal_distance(focal_distance)
+ if gamma is not None:
+ self.renderer.camera.set_gamma(gamma)
+ if zoom is not None:
+ self.renderer.camera.set_zoom(zoom)
+ if frame_center is not None:
+ self.renderer.camera._frame_center.move_to(frame_center)
+
+ def begin_ambient_camera_rotation(self, rate: float = 0.02, about: str = "theta"):
+ """
+ This method begins an ambient rotation of the camera about the Z_AXIS,
+ in the anticlockwise direction
+
+ Parameters
+ ----------
+ rate
+ The rate at which the camera should rotate about the Z_AXIS.
+ Negative rate means clockwise rotation.
+ about
+ one of 3 options: ["theta", "phi", "gamma"]. defaults to theta.
+ """
+ # TODO, use a ValueTracker for rate, so that it
+ # can begin and end smoothly
+ about: str = about.lower()
+ try:
+ if config.renderer == RendererType.CAIRO:
+ trackers = {
+ "theta": self.camera.theta_tracker,
+ "phi": self.camera.phi_tracker,
+ "gamma": self.camera.gamma_tracker,
+ }
+ x: ValueTracker = trackers[about]
+ x.add_updater(lambda m, dt: x.increment_value(rate * dt))
+ self.add(x)
+ elif config.renderer == RendererType.OPENGL:
+ cam: OpenGLCamera = self.camera
+ methods = {
+ "theta": cam.increment_theta,
+ "phi": cam.increment_phi,
+ "gamma": cam.increment_gamma,
+ }
+ cam.add_updater(lambda m, dt: methods[about](rate * dt))
+ self.add(self.camera)
+ except Exception:
+ raise ValueError("Invalid ambient rotation angle.")
+
+ def stop_ambient_camera_rotation(self, about="theta"):
+ """
+ This method stops all ambient camera rotation.
+ """
+ about: str = about.lower()
+ try:
+ if config.renderer == RendererType.CAIRO:
+ trackers = {
+ "theta": self.camera.theta_tracker,
+ "phi": self.camera.phi_tracker,
+ "gamma": self.camera.gamma_tracker,
+ }
+ x: ValueTracker = trackers[about]
+ x.clear_updaters()
+ self.remove(x)
+ elif config.renderer == RendererType.OPENGL:
+ self.camera.clear_updaters()
+ except Exception:
+ raise ValueError("Invalid ambient rotation angle.")
+
+ def begin_3dillusion_camera_rotation(
+ self,
+ rate: float = 1,
+ origin_phi: float | None = None,
+ origin_theta: float | None = None,
+ ):
+ """
+ This method creates a 3D camera rotation illusion around
+ the current camera orientation.
+
+ Parameters
+ ----------
+ rate
+ The rate at which the camera rotation illusion should operate.
+ origin_phi
+ The polar angle the camera should move around. Defaults
+ to the current phi angle.
+ origin_theta
+ The azimutal angle the camera should move around. Defaults
+ to the current theta angle.
+ """
+ if origin_theta is None:
+ origin_theta = self.renderer.camera.theta_tracker.get_value()
+ if origin_phi is None:
+ origin_phi = self.renderer.camera.phi_tracker.get_value()
+
+ val_tracker_theta = ValueTracker(0)
+
+ def update_theta(m, dt):
+ val_tracker_theta.increment_value(dt * rate)
+ val_for_left_right = 0.2 * np.sin(val_tracker_theta.get_value())
+ return m.set_value(origin_theta + val_for_left_right)
+
+ self.renderer.camera.theta_tracker.add_updater(update_theta)
+ self.add(self.renderer.camera.theta_tracker)
+
+ val_tracker_phi = ValueTracker(0)
+
+ def update_phi(m, dt):
+ val_tracker_phi.increment_value(dt * rate)
+ val_for_up_down = 0.1 * np.cos(val_tracker_phi.get_value()) - 0.1
+ return m.set_value(origin_phi + val_for_up_down)
+
+ self.renderer.camera.phi_tracker.add_updater(update_phi)
+ self.add(self.renderer.camera.phi_tracker)
+
+ def stop_3dillusion_camera_rotation(self):
+ """
+ This method stops all illusion camera rotations.
+ """
+ self.renderer.camera.theta_tracker.clear_updaters()
+ self.remove(self.renderer.camera.theta_tracker)
+ self.renderer.camera.phi_tracker.clear_updaters()
+ self.remove(self.renderer.camera.phi_tracker)
+
+ def move_camera(
+ self,
+ phi: float | None = None,
+ theta: float | None = None,
+ gamma: float | None = None,
+ zoom: float | None = None,
+ focal_distance: float | None = None,
+ frame_center: Mobject | Sequence[float] | None = None,
+ added_anims: Iterable[Animation] = [],
+ **kwargs,
+ ):
+ """
+ This method animates the movement of the camera
+ to the given spherical coordinates.
+
+ Parameters
+ ----------
+ phi
+ The polar angle i.e the angle between Z_AXIS and Camera through ORIGIN in radians.
+
+ theta
+ The azimuthal angle i.e the angle that spins the camera around the Z_AXIS.
+
+ focal_distance
+ The radial focal_distance between ORIGIN and Camera.
+
+ gamma
+ The rotation of the camera about the vector from the ORIGIN to the Camera.
+
+ zoom
+ The zoom factor of the camera.
+
+ frame_center
+ The new center of the camera frame in cartesian coordinates.
+
+ added_anims
+ Any other animations to be played at the same time.
+
+ """
+ anims = []
+
+ if config.renderer == RendererType.CAIRO:
+ self.camera: ThreeDCamera
+ value_tracker_pairs = [
+ (phi, self.camera.phi_tracker),
+ (theta, self.camera.theta_tracker),
+ (focal_distance, self.camera.focal_distance_tracker),
+ (gamma, self.camera.gamma_tracker),
+ (zoom, self.camera.zoom_tracker),
+ ]
+ for value, tracker in value_tracker_pairs:
+ if value is not None:
+ anims.append(tracker.animate.set_value(value))
+ if frame_center is not None:
+ anims.append(self.camera._frame_center.animate.move_to(frame_center))
+ elif config.renderer == RendererType.OPENGL:
+ cam: OpenGLCamera = self.camera
+ cam2 = cam.copy()
+ methods = {
+ "theta": cam2.set_theta,
+ "phi": cam2.set_phi,
+ "gamma": cam2.set_gamma,
+ "zoom": cam2.scale,
+ "frame_center": cam2.move_to,
+ }
+ if frame_center is not None:
+ if isinstance(frame_center, OpenGLMobject):
+ frame_center = frame_center.get_center()
+ frame_center = list(frame_center)
+
+ for value, method in [
+ [theta, "theta"],
+ [phi, "phi"],
+ [gamma, "gamma"],
+ [
+ config.frame_height / (zoom * cam.height)
+ if zoom is not None
+ else None,
+ "zoom",
+ ],
+ [frame_center, "frame_center"],
+ ]:
+ if value is not None:
+ methods[method](value)
+
+ if focal_distance is not None:
+ warnings.warn(
+ "focal distance of OpenGLCamera can not be adjusted.",
+ stacklevel=2,
+ )
+
+ anims += [Transform(cam, cam2)]
+
+ self.play(*anims + added_anims, **kwargs)
+
+ # These lines are added to improve performance. If manim thinks that frame_center is moving,
+ # it is required to redraw every object. These lines remove frame_center from the Scene once
+ # its animation is done, ensuring that manim does not think that it is moving. Since the
+ # frame_center is never actually drawn, this shouldn't break anything.
+ if frame_center is not None and config.renderer == RendererType.CAIRO:
+ self.remove(self.camera._frame_center)
+
+ def get_moving_mobjects(self, *animations: Animation):
+ """
+ This method returns a list of all of the Mobjects in the Scene that
+ are moving, that are also in the animations passed.
+
+ Parameters
+ ----------
+ *animations
+ The animations whose mobjects will be checked.
+ """
+ moving_mobjects = super().get_moving_mobjects(*animations)
+ camera_mobjects = self.renderer.camera.get_value_trackers() + [
+ self.renderer.camera._frame_center,
+ ]
+ if any(cm in moving_mobjects for cm in camera_mobjects):
+ return self.mobjects
+ return moving_mobjects
+
+ def add_fixed_orientation_mobjects(self, *mobjects: Mobject, **kwargs):
+ """
+ This method is used to prevent the rotation and tilting
+ of mobjects as the camera moves around. The mobject can
+ still move in the x,y,z directions, but will always be
+ at the angle (relative to the camera) that it was at
+ when it was passed through this method.)
+
+ Parameters
+ ----------
+ *mobjects
+ The Mobject(s) whose orientation must be fixed.
+
+ **kwargs
+ Some valid kwargs are
+ use_static_center_func : bool
+ center_func : function
+ """
+ if config.renderer == RendererType.CAIRO:
+ self.add(*mobjects)
+ self.renderer.camera.add_fixed_orientation_mobjects(*mobjects, **kwargs)
+ elif config.renderer == RendererType.OPENGL:
+ for mob in mobjects:
+ mob: OpenGLMobject
+ mob.fix_orientation()
+ self.add(mob)
+
+ def add_fixed_in_frame_mobjects(self, *mobjects: Mobject):
+ """
+ This method is used to prevent the rotation and movement
+ of mobjects as the camera moves around. The mobject is
+ essentially overlaid, and is not impacted by the camera's
+ movement in any way.
+
+ Parameters
+ ----------
+ *mobjects
+ The Mobjects whose orientation must be fixed.
+ """
+ if config.renderer == RendererType.CAIRO:
+ self.add(*mobjects)
+ self.camera: ThreeDCamera
+ self.camera.add_fixed_in_frame_mobjects(*mobjects)
+ elif config.renderer == RendererType.OPENGL:
+ for mob in mobjects:
+ mob: OpenGLMobject
+ mob.fix_in_frame()
+ self.add(mob)
+
+ def remove_fixed_orientation_mobjects(self, *mobjects: Mobject):
+ """
+ This method "unfixes" the orientation of the mobjects
+ passed, meaning they will no longer be at the same angle
+ relative to the camera. This only makes sense if the
+ mobject was passed through add_fixed_orientation_mobjects first.
+
+ Parameters
+ ----------
+ *mobjects
+ The Mobjects whose orientation must be unfixed.
+ """
+ if config.renderer == RendererType.CAIRO:
+ self.renderer.camera.remove_fixed_orientation_mobjects(*mobjects)
+ elif config.renderer == RendererType.OPENGL:
+ for mob in mobjects:
+ mob: OpenGLMobject
+ mob.unfix_orientation()
+ self.remove(mob)
+
+ def remove_fixed_in_frame_mobjects(self, *mobjects: Mobject):
+ """
+ This method undoes what add_fixed_in_frame_mobjects does.
+ It allows the mobject to be affected by the movement of
+ the camera.
+
+ Parameters
+ ----------
+ *mobjects
+ The Mobjects whose position and orientation must be unfixed.
+ """
+ if config.renderer == RendererType.CAIRO:
+ self.renderer.camera.remove_fixed_in_frame_mobjects(*mobjects)
+ elif config.renderer == RendererType.OPENGL:
+ for mob in mobjects:
+ mob: OpenGLMobject
+ mob.unfix_from_frame()
+ self.remove(mob)
+
+ ##
+ def set_to_default_angled_camera_orientation(self, **kwargs):
+ """
+ This method sets the default_angled_camera_orientation to the
+ keyword arguments passed, and sets the camera to that orientation.
+
+ Parameters
+ ----------
+ **kwargs
+ Some recognised kwargs are phi, theta, focal_distance, gamma,
+ which have the same meaning as the parameters in set_camera_orientation.
+ """
+ config = dict(
+ self.default_camera_orientation_kwargs,
+ ) # Where doe this come from?
+ config.update(kwargs)
+ self.set_camera_orientation(**config)
+
+
+class SpecialThreeDScene(ThreeDScene):
+ """An extension of :class:`ThreeDScene` with more settings.
+
+ It has some extra configuration for axes, spheres,
+ and an override for low quality rendering. Further key differences
+ are:
+
+ * The camera shades applicable 3DMobjects by default,
+ except if rendering in low quality.
+ * Some default params for Spheres and Axes have been added.
+
+ """
+
+ def __init__(
+ self,
+ cut_axes_at_radius=True,
+ camera_config={"should_apply_shading": True, "exponential_projection": True},
+ three_d_axes_config={
+ "num_axis_pieces": 1,
+ "axis_config": {
+ "unit_size": 2,
+ "tick_frequency": 1,
+ "numbers_with_elongated_ticks": [0, 1, 2],
+ "stroke_width": 2,
+ },
+ },
+ sphere_config={"radius": 2, "resolution": (24, 48)},
+ default_angled_camera_position={
+ "phi": 70 * DEGREES,
+ "theta": -110 * DEGREES,
+ },
+ # When scene is extracted with -l flag, this
+ # configuration will override the above configuration.
+ low_quality_config={
+ "camera_config": {"should_apply_shading": False},
+ "three_d_axes_config": {"num_axis_pieces": 1},
+ "sphere_config": {"resolution": (12, 24)},
+ },
+ **kwargs,
+ ):
+ self.cut_axes_at_radius = cut_axes_at_radius
+ self.camera_config = camera_config
+ self.three_d_axes_config = three_d_axes_config
+ self.sphere_config = sphere_config
+ self.default_angled_camera_position = default_angled_camera_position
+ self.low_quality_config = low_quality_config
+ if self.renderer.camera_config["pixel_width"] == config["pixel_width"]:
+ _config = {}
+ else:
+ _config = self.low_quality_config
+ _config = merge_dicts_recursively(_config, kwargs)
+ super().__init__(**_config)
+
+ def get_axes(self):
+ """Return a set of 3D axes.
+
+ Returns
+ -------
+ :class:`.ThreeDAxes`
+ A set of 3D axes.
+ """
+ axes = ThreeDAxes(**self.three_d_axes_config)
+ for axis in axes:
+ if self.cut_axes_at_radius:
+ p0 = axis.get_start()
+ p1 = axis.number_to_point(-1)
+ p2 = axis.number_to_point(1)
+ p3 = axis.get_end()
+ new_pieces = VGroup(Line(p0, p1), Line(p1, p2), Line(p2, p3))
+ for piece in new_pieces:
+ piece.shade_in_3d = True
+ new_pieces.match_style(axis.pieces)
+ axis.pieces.submobjects = new_pieces.submobjects
+ for tick in axis.tick_marks:
+ tick.add(VectorizedPoint(1.5 * tick.get_center()))
+ return axes
+
+ def get_sphere(self, **kwargs):
+ """
+ Returns a sphere with the passed keyword arguments as properties.
+
+ Parameters
+ ----------
+ **kwargs
+ Any valid parameter of :class:`~.Sphere` or :class:`~.Surface`.
+
+ Returns
+ -------
+ :class:`~.Sphere`
+ The sphere object.
+ """
+ config = merge_dicts_recursively(self.sphere_config, kwargs)
+ return Sphere(**config)
+
+ def get_default_camera_position(self):
+ """
+ Returns the default_angled_camera position.
+
+ Returns
+ -------
+ dict
+ Dictionary of phi, theta, focal_distance, and gamma.
+ """
+ return self.default_angled_camera_position
+
+ def set_camera_to_default_position(self):
+ """
+ Sets the camera to its default position.
+ """
+ self.set_camera_orientation(**self.default_angled_camera_position)
diff --git a/data/rag/manim_docs/manim_core/source/scene/vector_space_scene.py b/data/rag/manim_docs/manim_core/source/scene/vector_space_scene.py
new file mode 100644
index 0000000000000000000000000000000000000000..f651c2c86a7c4a6c3adc0c64910f54a80ae86383
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/scene/vector_space_scene.py
@@ -0,0 +1,1195 @@
+"""A scene suitable for vector spaces."""
+
+from __future__ import annotations
+
+__all__ = ["VectorScene", "LinearTransformationScene"]
+
+from typing import Callable
+
+import numpy as np
+
+from manim.mobject.geometry.arc import Dot
+from manim.mobject.geometry.line import Arrow, Line, Vector
+from manim.mobject.geometry.polygram import Rectangle
+from manim.mobject.graphing.coordinate_systems import Axes, NumberPlane
+from manim.mobject.opengl.opengl_mobject import OpenGLMobject
+from manim.mobject.text.tex_mobject import MathTex, Tex
+from manim.utils.config_ops import update_dict_recursively
+
+from .. import config
+from ..animation.animation import Animation
+from ..animation.creation import Create, Write
+from ..animation.fading import FadeOut
+from ..animation.growing import GrowArrow
+from ..animation.transform import ApplyFunction, ApplyPointwiseFunction, Transform
+from ..constants import *
+from ..mobject.matrix import Matrix
+from ..mobject.mobject import Mobject
+from ..mobject.types.vectorized_mobject import VGroup, VMobject
+from ..scene.scene import Scene
+from ..utils.color import (
+ BLACK,
+ BLUE_D,
+ GREEN_C,
+ GREY,
+ RED_C,
+ WHITE,
+ YELLOW,
+ ManimColor,
+ ParsableManimColor,
+)
+from ..utils.rate_functions import rush_from, rush_into
+from ..utils.space_ops import angle_of_vector
+
+X_COLOR = GREEN_C
+Y_COLOR = RED_C
+Z_COLOR = BLUE_D
+
+
+# TODO: Much of this scene type seems dependent on the coordinate system chosen.
+# That is, being centered at the origin with grid units corresponding to the
+# arbitrary space units. Change it!
+#
+# Also, methods I would have thought of as getters, like coords_to_vector, are
+# actually doing a lot of animating.
+class VectorScene(Scene):
+ def __init__(self, basis_vector_stroke_width=6, **kwargs):
+ super().__init__(**kwargs)
+ self.basis_vector_stroke_width = basis_vector_stroke_width
+
+ def add_plane(self, animate: bool = False, **kwargs):
+ """
+ Adds a NumberPlane object to the background.
+
+ Parameters
+ ----------
+ animate
+ Whether or not to animate the addition of the plane via Create.
+ **kwargs
+ Any valid keyword arguments accepted by NumberPlane.
+
+ Returns
+ -------
+ NumberPlane
+ The NumberPlane object.
+ """
+ plane = NumberPlane(**kwargs)
+ if animate:
+ self.play(Create(plane, lag_ratio=0.5))
+ self.add(plane)
+ return plane
+
+ def add_axes(self, animate: bool = False, color: bool = WHITE, **kwargs):
+ """
+ Adds a pair of Axes to the Scene.
+
+ Parameters
+ ----------
+ animate
+ Whether or not to animate the addition of the axes through Create.
+ color
+ The color of the axes. Defaults to WHITE.
+ """
+ axes = Axes(color=color, axis_config={"unit_size": 1})
+ if animate:
+ self.play(Create(axes))
+ self.add(axes)
+ return axes
+
+ def lock_in_faded_grid(self, dimness: float = 0.7, axes_dimness: float = 0.5):
+ """
+ This method freezes the NumberPlane and Axes that were already
+ in the background, and adds new, manipulatable ones to the foreground.
+
+ Parameters
+ ----------
+ dimness
+ The required dimness of the NumberPlane
+
+ axes_dimness
+ The required dimness of the Axes.
+ """
+ plane = self.add_plane()
+ axes = plane.get_axes()
+ plane.fade(dimness)
+ axes.set_color(WHITE)
+ axes.fade(axes_dimness)
+ self.add(axes)
+
+ self.renderer.update_frame()
+ self.renderer.camera = Camera(self.renderer.get_frame())
+ self.clear()
+
+ def get_vector(self, numerical_vector: np.ndarray | list | tuple, **kwargs):
+ """
+ Returns an arrow on the Plane given an input numerical vector.
+
+ Parameters
+ ----------
+ numerical_vector
+ The Vector to plot.
+ **kwargs
+ Any valid keyword argument of Arrow.
+
+ Returns
+ -------
+ Arrow
+ The Arrow representing the Vector.
+ """
+ return Arrow(
+ self.plane.coords_to_point(0, 0),
+ self.plane.coords_to_point(*numerical_vector[:2]),
+ buff=0,
+ **kwargs,
+ )
+
+ def add_vector(
+ self,
+ vector: Arrow | list | tuple | np.ndarray,
+ color: str = YELLOW,
+ animate: bool = True,
+ **kwargs,
+ ):
+ """
+ Returns the Vector after adding it to the Plane.
+
+ Parameters
+ ----------
+ vector
+ It can be a pre-made graphical vector, or the
+ coordinates of one.
+
+ color
+ The string of the hex color of the vector.
+ This is only taken into consideration if
+ 'vector' is not an Arrow. Defaults to YELLOW.
+
+ animate
+ Whether or not to animate the addition of the vector
+ by using GrowArrow
+
+ **kwargs
+ Any valid keyword argument of Arrow.
+ These are only considered if vector is not
+ an Arrow.
+
+ Returns
+ -------
+ Arrow
+ The arrow representing the vector.
+ """
+ if not isinstance(vector, Arrow):
+ vector = Vector(vector, color=color, **kwargs)
+ if animate:
+ self.play(GrowArrow(vector))
+ self.add(vector)
+ return vector
+
+ def write_vector_coordinates(self, vector: Arrow, **kwargs):
+ """
+ Returns a column matrix indicating the vector coordinates,
+ after writing them to the screen.
+
+ Parameters
+ ----------
+ vector
+ The arrow representing the vector.
+
+ **kwargs
+ Any valid keyword arguments of :meth:`~.Vector.coordinate_label`:
+
+ Returns
+ -------
+ :class:`.Matrix`
+ The column matrix representing the vector.
+ """
+ coords = vector.coordinate_label(**kwargs)
+ self.play(Write(coords))
+ return coords
+
+ def get_basis_vectors(self, i_hat_color: str = X_COLOR, j_hat_color: str = Y_COLOR):
+ """
+ Returns a VGroup of the Basis Vectors (1,0) and (0,1)
+
+ Parameters
+ ----------
+ i_hat_color
+ The hex colour to use for the basis vector in the x direction
+
+ j_hat_color
+ The hex colour to use for the basis vector in the y direction
+
+ Returns
+ -------
+ VGroup
+ VGroup of the Vector Mobjects representing the basis vectors.
+ """
+ return VGroup(
+ *(
+ Vector(vect, color=color, stroke_width=self.basis_vector_stroke_width)
+ for vect, color in [([1, 0], i_hat_color), ([0, 1], j_hat_color)]
+ )
+ )
+
+ def get_basis_vector_labels(self, **kwargs):
+ """
+ Returns naming labels for the basis vectors.
+
+ Parameters
+ ----------
+ **kwargs
+ Any valid keyword arguments of get_vector_label:
+ vector,
+ label (str,MathTex)
+ at_tip (bool=False),
+ direction (str="left"),
+ rotate (bool),
+ color (str),
+ label_scale_factor=VECTOR_LABEL_SCALE_FACTOR (int, float),
+ """
+ i_hat, j_hat = self.get_basis_vectors()
+ return VGroup(
+ *(
+ self.get_vector_label(
+ vect, label, color=color, label_scale_factor=1, **kwargs
+ )
+ for vect, label, color in [
+ (i_hat, "\\hat{\\imath}", X_COLOR),
+ (j_hat, "\\hat{\\jmath}", Y_COLOR),
+ ]
+ )
+ )
+
+ def get_vector_label(
+ self,
+ vector: Vector,
+ label,
+ at_tip: bool = False,
+ direction: str = "left",
+ rotate: bool = False,
+ color: str | None = None,
+ label_scale_factor: float = LARGE_BUFF - 0.2,
+ ):
+ """
+ Returns naming labels for the passed vector.
+
+ Parameters
+ ----------
+ vector
+ Vector Object for which to get the label.
+
+ at_tip
+ Whether or not to place the label at the tip of the vector.
+
+ direction
+ If the label should be on the "left" or right of the vector.
+ rotate
+ Whether or not to rotate it to align it with the vector.
+ color
+ The color to give the label.
+ label_scale_factor
+ How much to scale the label by.
+
+ Returns
+ -------
+ MathTex
+ The MathTex of the label.
+ """
+ if not isinstance(label, MathTex):
+ if len(label) == 1:
+ label = "\\vec{\\textbf{%s}}" % label
+ label = MathTex(label)
+ if color is None:
+ color = vector.get_color()
+ label.set_color(color)
+ label.scale(label_scale_factor)
+ label.add_background_rectangle()
+
+ if at_tip:
+ vect = vector.get_vector()
+ vect /= np.linalg.norm(vect)
+ label.next_to(vector.get_end(), vect, buff=SMALL_BUFF)
+ else:
+ angle = vector.get_angle()
+ if not rotate:
+ label.rotate(-angle, about_point=ORIGIN)
+ if direction == "left":
+ label.shift(-label.get_bottom() + 0.1 * UP)
+ else:
+ label.shift(-label.get_top() + 0.1 * DOWN)
+ label.rotate(angle, about_point=ORIGIN)
+ label.shift((vector.get_end() - vector.get_start()) / 2)
+ return label
+
+ def label_vector(
+ self, vector: Vector, label: MathTex | str, animate: bool = True, **kwargs
+ ):
+ """
+ Shortcut method for creating, and animating the addition of
+ a label for the vector.
+
+ Parameters
+ ----------
+ vector
+ The vector for which the label must be added.
+
+ label
+ The MathTex/string of the label.
+
+ animate
+ Whether or not to animate the labelling w/ Write
+
+ **kwargs
+ Any valid keyword argument of get_vector_label
+
+ Returns
+ -------
+ :class:`~.MathTex`
+ The MathTex of the label.
+ """
+ label = self.get_vector_label(vector, label, **kwargs)
+ if animate:
+ self.play(Write(label, run_time=1))
+ self.add(label)
+ return label
+
+ def position_x_coordinate(
+ self,
+ x_coord,
+ x_line,
+ vector,
+ ): # TODO Write DocStrings for this.
+ x_coord.next_to(x_line, -np.sign(vector[1]) * UP)
+ x_coord.set_color(X_COLOR)
+ return x_coord
+
+ def position_y_coordinate(
+ self,
+ y_coord,
+ y_line,
+ vector,
+ ): # TODO Write DocStrings for this.
+ y_coord.next_to(y_line, np.sign(vector[0]) * RIGHT)
+ y_coord.set_color(Y_COLOR)
+ return y_coord
+
+ def coords_to_vector(
+ self,
+ vector: np.ndarray | list | tuple,
+ coords_start: np.ndarray | list | tuple = 2 * RIGHT + 2 * UP,
+ clean_up: bool = True,
+ ):
+ """
+ This method writes the vector as a column matrix (henceforth called the label),
+ takes the values in it one by one, and form the corresponding
+ lines that make up the x and y components of the vector. Then, an
+ Vector() based vector is created between the lines on the Screen.
+
+ Parameters
+ ----------
+ vector
+ The vector to show.
+
+ coords_start
+ The starting point of the location of
+ the label of the vector that shows it
+ numerically.
+ Defaults to 2 * RIGHT + 2 * UP or (2,2)
+
+ clean_up
+ Whether or not to remove whatever
+ this method did after it's done.
+
+ """
+ starting_mobjects = list(self.mobjects)
+ array = Matrix(vector)
+ array.shift(coords_start)
+ arrow = Vector(vector)
+ x_line = Line(ORIGIN, vector[0] * RIGHT)
+ y_line = Line(x_line.get_end(), arrow.get_end())
+ x_line.set_color(X_COLOR)
+ y_line.set_color(Y_COLOR)
+ x_coord, y_coord = array.get_mob_matrix().flatten()
+
+ self.play(Write(array, run_time=1))
+ self.wait()
+ self.play(
+ ApplyFunction(
+ lambda x: self.position_x_coordinate(x, x_line, vector),
+ x_coord,
+ ),
+ )
+ self.play(Create(x_line))
+ animations = [
+ ApplyFunction(
+ lambda y: self.position_y_coordinate(y, y_line, vector),
+ y_coord,
+ ),
+ FadeOut(array.get_brackets()),
+ ]
+ self.play(*animations)
+ y_coord, _ = (anim.mobject for anim in animations)
+ self.play(Create(y_line))
+ self.play(Create(arrow))
+ self.wait()
+ if clean_up:
+ self.clear()
+ self.add(*starting_mobjects)
+
+ def vector_to_coords(
+ self,
+ vector: np.ndarray | list | tuple,
+ integer_labels: bool = True,
+ clean_up: bool = True,
+ ):
+ """
+ This method displays vector as a Vector() based vector, and then shows
+ the corresponding lines that make up the x and y components of the vector.
+ Then, a column matrix (henceforth called the label) is created near the
+ head of the Vector.
+
+ Parameters
+ ----------
+ vector
+ The vector to show.
+
+ integer_labels
+ Whether or not to round the value displayed.
+ in the vector's label to the nearest integer
+
+ clean_up
+ Whether or not to remove whatever
+ this method did after it's done.
+
+ """
+ starting_mobjects = list(self.mobjects)
+ show_creation = False
+ if isinstance(vector, Arrow):
+ arrow = vector
+ vector = arrow.get_end()[:2]
+ else:
+ arrow = Vector(vector)
+ show_creation = True
+ array = arrow.coordinate_label(integer_labels=integer_labels)
+ x_line = Line(ORIGIN, vector[0] * RIGHT)
+ y_line = Line(x_line.get_end(), arrow.get_end())
+ x_line.set_color(X_COLOR)
+ y_line.set_color(Y_COLOR)
+ x_coord, y_coord = array.get_entries()
+ x_coord_start = self.position_x_coordinate(x_coord.copy(), x_line, vector)
+ y_coord_start = self.position_y_coordinate(y_coord.copy(), y_line, vector)
+ brackets = array.get_brackets()
+
+ if show_creation:
+ self.play(Create(arrow))
+ self.play(Create(x_line), Write(x_coord_start), run_time=1)
+ self.play(Create(y_line), Write(y_coord_start), run_time=1)
+ self.wait()
+ self.play(
+ Transform(x_coord_start, x_coord, lag_ratio=0),
+ Transform(y_coord_start, y_coord, lag_ratio=0),
+ Write(brackets, run_time=1),
+ )
+ self.wait()
+
+ self.remove(x_coord_start, y_coord_start, brackets)
+ self.add(array)
+ if clean_up:
+ self.clear()
+ self.add(*starting_mobjects)
+ return array, x_line, y_line
+
+ def show_ghost_movement(self, vector: Arrow | list | tuple | np.ndarray):
+ """
+ This method plays an animation that partially shows the entire plane moving
+ in the direction of a particular vector. This is useful when you wish to
+ convey the idea of mentally moving the entire plane in a direction, without
+ actually moving the plane.
+
+ Parameters
+ ----------
+ vector
+ The vector which indicates the direction of movement.
+ """
+ if isinstance(vector, Arrow):
+ vector = vector.get_end() - vector.get_start()
+ elif len(vector) == 2:
+ vector = np.append(np.array(vector), 0.0)
+ x_max = int(config["frame_x_radius"] + abs(vector[0]))
+ y_max = int(config["frame_y_radius"] + abs(vector[1]))
+ dots = VMobject(
+ *(
+ Dot(x * RIGHT + y * UP)
+ for x in range(-x_max, x_max)
+ for y in range(-y_max, y_max)
+ )
+ )
+ dots.set_fill(BLACK, opacity=0)
+ dots_halfway = dots.copy().shift(vector / 2).set_fill(WHITE, 1)
+ dots_end = dots.copy().shift(vector)
+
+ self.play(Transform(dots, dots_halfway, rate_func=rush_into))
+ self.play(Transform(dots, dots_end, rate_func=rush_from))
+ self.remove(dots)
+
+
+class LinearTransformationScene(VectorScene):
+ """
+ This scene contains special methods that make it
+ especially suitable for showing linear transformations.
+
+ Parameters
+ ----------
+ include_background_plane
+ Whether or not to include the background plane in the scene.
+ include_foreground_plane
+ Whether or not to include the foreground plane in the scene.
+ background_plane_kwargs
+ Parameters to be passed to :class:`NumberPlane` to adjust the background plane.
+ foreground_plane_kwargs
+ Parameters to be passed to :class:`NumberPlane` to adjust the foreground plane.
+ show_coordinates
+ Whether or not to include the coordinates for the background plane.
+ show_basis_vectors
+ Whether to show the basis x_axis -> ``i_hat`` and y_axis -> ``j_hat`` vectors.
+ basis_vector_stroke_width
+ The ``stroke_width`` of the basis vectors.
+ i_hat_color
+ The color of the ``i_hat`` vector.
+ j_hat_color
+ The color of the ``j_hat`` vector.
+ leave_ghost_vectors
+ Indicates the previous position of the basis vectors following a transformation.
+
+ Examples
+ -------
+
+ .. manim:: LinearTransformationSceneExample
+
+ class LinearTransformationSceneExample(LinearTransformationScene):
+ def __init__(self, **kwargs):
+ LinearTransformationScene.__init__(
+ self,
+ show_coordinates=True,
+ leave_ghost_vectors=True,
+ *kwargs
+ )
+
+ def construct(self):
+ matrix = [[1, 1], [0, 1]]
+ self.apply_matrix(matrix)
+ self.wait()
+ """
+
+ def __init__(
+ self,
+ include_background_plane: bool = True,
+ include_foreground_plane: bool = True,
+ background_plane_kwargs: dict | None = None,
+ foreground_plane_kwargs: dict | None = None,
+ show_coordinates: bool = False,
+ show_basis_vectors: bool = True,
+ basis_vector_stroke_width: float = 6,
+ i_hat_color: ParsableManimColor = X_COLOR,
+ j_hat_color: ParsableManimColor = Y_COLOR,
+ leave_ghost_vectors: bool = False,
+ **kwargs,
+ ):
+ super().__init__(**kwargs)
+
+ self.include_background_plane = include_background_plane
+ self.include_foreground_plane = include_foreground_plane
+ self.show_coordinates = show_coordinates
+ self.show_basis_vectors = show_basis_vectors
+ self.basis_vector_stroke_width = basis_vector_stroke_width
+ self.i_hat_color = ManimColor(i_hat_color)
+ self.j_hat_color = ManimColor(j_hat_color)
+ self.leave_ghost_vectors = leave_ghost_vectors
+ self.background_plane_kwargs = {
+ "color": GREY,
+ "axis_config": {
+ "color": GREY,
+ },
+ "background_line_style": {
+ "stroke_color": GREY,
+ "stroke_width": 1,
+ },
+ }
+
+ self.foreground_plane_kwargs = {
+ "x_range": np.array([-config["frame_width"], config["frame_width"], 1.0]),
+ "y_range": np.array([-config["frame_width"], config["frame_width"], 1.0]),
+ "faded_line_ratio": 1,
+ }
+
+ self.update_default_configs(
+ (self.foreground_plane_kwargs, self.background_plane_kwargs),
+ (foreground_plane_kwargs, background_plane_kwargs),
+ )
+
+ @staticmethod
+ def update_default_configs(default_configs, passed_configs):
+ for default_config, passed_config in zip(default_configs, passed_configs):
+ if passed_config is not None:
+ update_dict_recursively(default_config, passed_config)
+
+ def setup(self):
+ # The has_already_setup attr is to not break all the old Scenes
+ if hasattr(self, "has_already_setup"):
+ return
+ self.has_already_setup = True
+ self.background_mobjects = []
+ self.foreground_mobjects = []
+ self.transformable_mobjects = []
+ self.moving_vectors = []
+ self.transformable_labels = []
+ self.moving_mobjects = []
+
+ self.background_plane = NumberPlane(**self.background_plane_kwargs)
+
+ if self.show_coordinates:
+ self.background_plane.add_coordinates()
+ if self.include_background_plane:
+ self.add_background_mobject(self.background_plane)
+ if self.include_foreground_plane:
+ self.plane = NumberPlane(**self.foreground_plane_kwargs)
+ self.add_transformable_mobject(self.plane)
+ if self.show_basis_vectors:
+ self.basis_vectors = self.get_basis_vectors(
+ i_hat_color=self.i_hat_color,
+ j_hat_color=self.j_hat_color,
+ )
+ self.moving_vectors += list(self.basis_vectors)
+ self.i_hat, self.j_hat = self.basis_vectors
+ self.add(self.basis_vectors)
+
+ def add_special_mobjects(self, mob_list: list, *mobs_to_add: Mobject):
+ """
+ Adds mobjects to a separate list that can be tracked,
+ if these mobjects have some extra importance.
+
+ Parameters
+ ----------
+ mob_list
+ The special list to which you want to add
+ these mobjects.
+
+ *mobs_to_add
+ The mobjects to add.
+
+ """
+ for mobject in mobs_to_add:
+ if mobject not in mob_list:
+ mob_list.append(mobject)
+ self.add(mobject)
+
+ def add_background_mobject(self, *mobjects: Mobject):
+ """
+ Adds the mobjects to the special list
+ self.background_mobjects.
+
+ Parameters
+ ----------
+ *mobjects
+ The mobjects to add to the list.
+ """
+ self.add_special_mobjects(self.background_mobjects, *mobjects)
+
+ # TODO, this conflicts with Scene.add_fore
+ def add_foreground_mobject(self, *mobjects: Mobject):
+ """
+ Adds the mobjects to the special list
+ self.foreground_mobjects.
+
+ Parameters
+ ----------
+ *mobjects
+ The mobjects to add to the list
+ """
+ self.add_special_mobjects(self.foreground_mobjects, *mobjects)
+
+ def add_transformable_mobject(self, *mobjects: Mobject):
+ """
+ Adds the mobjects to the special list
+ self.transformable_mobjects.
+
+ Parameters
+ ----------
+ *mobjects
+ The mobjects to add to the list.
+ """
+ self.add_special_mobjects(self.transformable_mobjects, *mobjects)
+
+ def add_moving_mobject(
+ self, mobject: Mobject, target_mobject: Mobject | None = None
+ ):
+ """
+ Adds the mobject to the special list
+ self.moving_mobject, and adds a property
+ to the mobject called mobject.target, which
+ keeps track of what the mobject will move to
+ or become etc.
+
+ Parameters
+ ----------
+ mobject
+ The mobjects to add to the list
+
+ target_mobject
+ What the moving_mobject goes to, etc.
+ """
+ mobject.target = target_mobject
+ self.add_special_mobjects(self.moving_mobjects, mobject)
+
+ def get_unit_square(
+ self, color: str = YELLOW, opacity: float = 0.3, stroke_width: float = 3
+ ):
+ """
+ Returns a unit square for the current NumberPlane.
+
+ Parameters
+ ----------
+ color
+ The string of the hex color code of the color wanted.
+
+ opacity
+ The opacity of the square
+
+ stroke_width
+ The stroke_width in pixels of the border of the square
+
+ Returns
+ -------
+ Square
+ """
+ square = self.square = Rectangle(
+ color=color,
+ width=self.plane.get_x_unit_size(),
+ height=self.plane.get_y_unit_size(),
+ stroke_color=color,
+ stroke_width=stroke_width,
+ fill_color=color,
+ fill_opacity=opacity,
+ )
+ square.move_to(self.plane.coords_to_point(0, 0), DL)
+ return square
+
+ def add_unit_square(self, animate: bool = False, **kwargs):
+ """
+ Adds a unit square to the scene via
+ self.get_unit_square.
+
+ Parameters
+ ----------
+ animate
+ Whether or not to animate the addition
+ with DrawBorderThenFill.
+ **kwargs
+ Any valid keyword arguments of
+ self.get_unit_square()
+
+ Returns
+ -------
+ Square
+ The unit square.
+ """
+ square = self.get_unit_square(**kwargs)
+ if animate:
+ self.play(
+ DrawBorderThenFill(square),
+ Animation(Group(*self.moving_vectors)),
+ )
+ self.add_transformable_mobject(square)
+ self.bring_to_front(*self.moving_vectors)
+ self.square = square
+ return self
+
+ def add_vector(
+ self, vector: Arrow | list | tuple | np.ndarray, color: str = YELLOW, **kwargs
+ ):
+ """
+ Adds a vector to the scene, and puts it in the special
+ list self.moving_vectors.
+
+ Parameters
+ ----------
+ vector
+ It can be a pre-made graphical vector, or the
+ coordinates of one.
+
+ color
+ The string of the hex color of the vector.
+ This is only taken into consideration if
+ 'vector' is not an Arrow. Defaults to YELLOW.
+
+ **kwargs
+ Any valid keyword argument of VectorScene.add_vector.
+
+ Returns
+ -------
+ Arrow
+ The arrow representing the vector.
+ """
+ vector = super().add_vector(vector, color=color, **kwargs)
+ self.moving_vectors.append(vector)
+ return vector
+
+ def write_vector_coordinates(self, vector: Arrow, **kwargs):
+ """
+ Returns a column matrix indicating the vector coordinates,
+ after writing them to the screen, and adding them to the
+ special list self.foreground_mobjects
+
+ Parameters
+ ----------
+ vector
+ The arrow representing the vector.
+
+ **kwargs
+ Any valid keyword arguments of VectorScene.write_vector_coordinates
+
+ Returns
+ -------
+ Matrix
+ The column matrix representing the vector.
+ """
+ coords = super().write_vector_coordinates(vector, **kwargs)
+ self.add_foreground_mobject(coords)
+ return coords
+
+ def add_transformable_label(
+ self,
+ vector: Vector,
+ label: MathTex | str,
+ transformation_name: str | MathTex = "L",
+ new_label: str | MathTex | None = None,
+ **kwargs,
+ ):
+ """
+ Method for creating, and animating the addition of
+ a transformable label for the vector.
+
+ Parameters
+ ----------
+ vector
+ The vector for which the label must be added.
+
+ label
+ The MathTex/string of the label.
+
+ transformation_name
+ The name to give the transformation as a label.
+
+ new_label
+ What the label should display after a Linear Transformation
+
+ **kwargs
+ Any valid keyword argument of get_vector_label
+
+ Returns
+ -------
+ :class:`~.MathTex`
+ The MathTex of the label.
+ """
+ label_mob = self.label_vector(vector, label, **kwargs)
+ if new_label:
+ label_mob.target_text = new_label
+ else:
+ label_mob.target_text = "{}({})".format(
+ transformation_name,
+ label_mob.get_tex_string(),
+ )
+ label_mob.vector = vector
+ label_mob.kwargs = kwargs
+ if "animate" in label_mob.kwargs:
+ label_mob.kwargs.pop("animate")
+ self.transformable_labels.append(label_mob)
+ return label_mob
+
+ def add_title(
+ self,
+ title: str | MathTex | Tex,
+ scale_factor: float = 1.5,
+ animate: bool = False,
+ ):
+ """
+ Adds a title, after scaling it, adding a background rectangle,
+ moving it to the top and adding it to foreground_mobjects adding
+ it as a local variable of self. Returns the Scene.
+
+ Parameters
+ ----------
+ title
+ What the title should be.
+
+ scale_factor
+ How much the title should be scaled by.
+
+ animate
+ Whether or not to animate the addition.
+
+ Returns
+ -------
+ LinearTransformationScene
+ The scene with the title added to it.
+ """
+ if not isinstance(title, (Mobject, OpenGLMobject)):
+ title = Tex(title).scale(scale_factor)
+ title.to_edge(UP)
+ title.add_background_rectangle()
+ if animate:
+ self.play(Write(title))
+ self.add_foreground_mobject(title)
+ self.title = title
+ return self
+
+ def get_matrix_transformation(self, matrix: np.ndarray | list | tuple):
+ """
+ Returns a function corresponding to the linear
+ transformation represented by the matrix passed.
+
+ Parameters
+ ----------
+ matrix
+ The matrix.
+ """
+ return self.get_transposed_matrix_transformation(np.array(matrix).T)
+
+ def get_transposed_matrix_transformation(
+ self, transposed_matrix: np.ndarray | list | tuple
+ ):
+ """
+ Returns a function corresponding to the linear
+ transformation represented by the transposed
+ matrix passed.
+
+ Parameters
+ ----------
+ transposed_matrix
+ The matrix.
+ """
+ transposed_matrix = np.array(transposed_matrix)
+ if transposed_matrix.shape == (2, 2):
+ new_matrix = np.identity(3)
+ new_matrix[:2, :2] = transposed_matrix
+ transposed_matrix = new_matrix
+ elif transposed_matrix.shape != (3, 3):
+ raise ValueError("Matrix has bad dimensions")
+ return lambda point: np.dot(point, transposed_matrix)
+
+ def get_piece_movement(self, pieces: list | tuple | np.ndarray):
+ """
+ This method returns an animation that moves an arbitrary
+ mobject in "pieces" to its corresponding .target value.
+ If self.leave_ghost_vectors is True, ghosts of the original
+ positions/mobjects are left on screen
+
+ Parameters
+ ----------
+ pieces
+ The pieces for which the movement must be shown.
+
+ Returns
+ -------
+ Animation
+ The animation of the movement.
+ """
+ start = VGroup(*pieces)
+ target = VGroup(*(mob.target for mob in pieces))
+ if self.leave_ghost_vectors:
+ self.add(start.copy().fade(0.7))
+ return Transform(start, target, lag_ratio=0)
+
+ def get_moving_mobject_movement(self, func: Callable[[np.ndarray], np.ndarray]):
+ """
+ This method returns an animation that moves a mobject
+ in "self.moving_mobjects" to its corresponding .target value.
+ func is a function that determines where the .target goes.
+
+ Parameters
+ ----------
+
+ func
+ The function that determines where the .target of
+ the moving mobject goes.
+
+ Returns
+ -------
+ Animation
+ The animation of the movement.
+ """
+ for m in self.moving_mobjects:
+ if m.target is None:
+ m.target = m.copy()
+ target_point = func(m.get_center())
+ m.target.move_to(target_point)
+ return self.get_piece_movement(self.moving_mobjects)
+
+ def get_vector_movement(self, func: Callable[[np.ndarray], np.ndarray]):
+ """
+ This method returns an animation that moves a mobject
+ in "self.moving_vectors" to its corresponding .target value.
+ func is a function that determines where the .target goes.
+
+ Parameters
+ ----------
+
+ func
+ The function that determines where the .target of
+ the moving mobject goes.
+
+ Returns
+ -------
+ Animation
+ The animation of the movement.
+ """
+ for v in self.moving_vectors:
+ v.target = Vector(func(v.get_end()), color=v.get_color())
+ norm = np.linalg.norm(v.target.get_end())
+ if norm < 0.1:
+ v.target.get_tip().scale(norm)
+ return self.get_piece_movement(self.moving_vectors)
+
+ def get_transformable_label_movement(self):
+ """
+ This method returns an animation that moves all labels
+ in "self.transformable_labels" to its corresponding .target .
+
+ Returns
+ -------
+ Animation
+ The animation of the movement.
+ """
+ for label in self.transformable_labels:
+ label.target = self.get_vector_label(
+ label.vector.target, label.target_text, **label.kwargs
+ )
+ return self.get_piece_movement(self.transformable_labels)
+
+ def apply_matrix(self, matrix: np.ndarray | list | tuple, **kwargs):
+ """
+ Applies the transformation represented by the
+ given matrix to the number plane, and each vector/similar
+ mobject on it.
+
+ Parameters
+ ----------
+ matrix
+ The matrix.
+ **kwargs
+ Any valid keyword argument of self.apply_transposed_matrix()
+ """
+ self.apply_transposed_matrix(np.array(matrix).T, **kwargs)
+
+ def apply_inverse(self, matrix: np.ndarray | list | tuple, **kwargs):
+ """
+ This method applies the linear transformation
+ represented by the inverse of the passed matrix
+ to the number plane, and each vector/similar mobject on it.
+
+ Parameters
+ ----------
+ matrix
+ The matrix whose inverse is to be applied.
+ **kwargs
+ Any valid keyword argument of self.apply_matrix()
+ """
+ self.apply_matrix(np.linalg.inv(matrix), **kwargs)
+
+ def apply_transposed_matrix(
+ self, transposed_matrix: np.ndarray | list | tuple, **kwargs
+ ):
+ """
+ Applies the transformation represented by the
+ given transposed matrix to the number plane,
+ and each vector/similar mobject on it.
+
+ Parameters
+ ----------
+ transposed_matrix
+ The matrix.
+ **kwargs
+ Any valid keyword argument of self.apply_function()
+ """
+ func = self.get_transposed_matrix_transformation(transposed_matrix)
+ if "path_arc" not in kwargs:
+ net_rotation = np.mean(
+ [angle_of_vector(func(RIGHT)), angle_of_vector(func(UP)) - np.pi / 2],
+ )
+ kwargs["path_arc"] = net_rotation
+ self.apply_function(func, **kwargs)
+
+ def apply_inverse_transpose(self, t_matrix: np.ndarray | list | tuple, **kwargs):
+ """
+ Applies the inverse of the transformation represented
+ by the given transposed matrix to the number plane and each
+ vector/similar mobject on it.
+
+ Parameters
+ ----------
+ t_matrix
+ The matrix.
+ **kwargs
+ Any valid keyword argument of self.apply_transposed_matrix()
+ """
+ t_inv = np.linalg.inv(np.array(t_matrix).T).T
+ self.apply_transposed_matrix(t_inv, **kwargs)
+
+ def apply_nonlinear_transformation(
+ self, function: Callable[[np.ndarray], np.ndarray], **kwargs
+ ):
+ """
+ Applies the non-linear transformation represented
+ by the given function to the number plane and each
+ vector/similar mobject on it.
+
+ Parameters
+ ----------
+ function
+ The function.
+ **kwargs
+ Any valid keyword argument of self.apply_function()
+ """
+ self.plane.prepare_for_nonlinear_transform()
+ self.apply_function(function, **kwargs)
+
+ def apply_function(
+ self,
+ function: Callable[[np.ndarray], np.ndarray],
+ added_anims: list = [],
+ **kwargs,
+ ):
+ """
+ Applies the given function to each of the mobjects in
+ self.transformable_mobjects, and plays the animation showing
+ this.
+
+ Parameters
+ ----------
+ function
+ The function that affects each point
+ of each mobject in self.transformable_mobjects.
+
+ added_anims
+ Any other animations that need to be played
+ simultaneously with this.
+
+ **kwargs
+ Any valid keyword argument of a self.play() call.
+ """
+ if "run_time" not in kwargs:
+ kwargs["run_time"] = 3
+ anims = (
+ [
+ ApplyPointwiseFunction(function, t_mob)
+ for t_mob in self.transformable_mobjects
+ ]
+ + [
+ self.get_vector_movement(function),
+ self.get_transformable_label_movement(),
+ self.get_moving_mobject_movement(function),
+ ]
+ + [Animation(f_mob) for f_mob in self.foreground_mobjects]
+ + added_anims
+ )
+ self.play(*anims, **kwargs)
diff --git a/data/rag/manim_docs/manim_core/source/scene/zoomed_scene.py b/data/rag/manim_docs/manim_core/source/scene/zoomed_scene.py
new file mode 100644
index 0000000000000000000000000000000000000000..361c4eaf5582e5908c2a86499c4793917c6c5a11
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/scene/zoomed_scene.py
@@ -0,0 +1,209 @@
+"""A scene supporting zooming in on a specified section.
+
+
+Examples
+--------
+
+.. manim:: UseZoomedScene
+
+ class UseZoomedScene(ZoomedScene):
+ def construct(self):
+ dot = Dot().set_color(GREEN)
+ self.add(dot)
+ self.wait(1)
+ self.activate_zooming(animate=False)
+ self.wait(1)
+ self.play(dot.animate.shift(LEFT))
+
+.. manim:: ChangingZoomScale
+
+ class ChangingZoomScale(ZoomedScene):
+ def __init__(self, **kwargs):
+ ZoomedScene.__init__(
+ self,
+ zoom_factor=0.3,
+ zoomed_display_height=1,
+ zoomed_display_width=3,
+ image_frame_stroke_width=20,
+ zoomed_camera_config={
+ "default_frame_stroke_width": 3,
+ },
+ **kwargs
+ )
+
+ def construct(self):
+ dot = Dot().set_color(GREEN)
+ sq = Circle(fill_opacity=1, radius=0.2).next_to(dot, RIGHT)
+ self.add(dot, sq)
+ self.wait(1)
+ self.activate_zooming(animate=False)
+ self.wait(1)
+ self.play(dot.animate.shift(LEFT * 0.3))
+
+ self.play(self.zoomed_camera.frame.animate.scale(4))
+ self.play(self.zoomed_camera.frame.animate.shift(0.5 * DOWN))
+
+"""
+
+from __future__ import annotations
+
+__all__ = ["ZoomedScene"]
+
+
+from ..animation.transform import ApplyMethod
+from ..camera.moving_camera import MovingCamera
+from ..camera.multi_camera import MultiCamera
+from ..constants import *
+from ..mobject.types.image_mobject import ImageMobjectFromCamera
+from ..scene.moving_camera_scene import MovingCameraScene
+
+# Note, any scenes from old videos using ZoomedScene will almost certainly
+# break, as it was restructured.
+
+
+class ZoomedScene(MovingCameraScene):
+ """
+ This is a Scene with special configurations made for when
+ a particular part of the scene must be zoomed in on and displayed
+ separately.
+ """
+
+ def __init__(
+ self,
+ camera_class=MultiCamera,
+ zoomed_display_height=3,
+ zoomed_display_width=3,
+ zoomed_display_center=None,
+ zoomed_display_corner=UP + RIGHT,
+ zoomed_display_corner_buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER,
+ zoomed_camera_config={
+ "default_frame_stroke_width": 2,
+ "background_opacity": 1,
+ },
+ zoomed_camera_image_mobject_config={},
+ zoomed_camera_frame_starting_position=ORIGIN,
+ zoom_factor=0.15,
+ image_frame_stroke_width=3,
+ zoom_activated=False,
+ **kwargs,
+ ):
+ self.zoomed_display_height = zoomed_display_height
+ self.zoomed_display_width = zoomed_display_width
+ self.zoomed_display_center = zoomed_display_center
+ self.zoomed_display_corner = zoomed_display_corner
+ self.zoomed_display_corner_buff = zoomed_display_corner_buff
+ self.zoomed_camera_config = zoomed_camera_config
+ self.zoomed_camera_image_mobject_config = zoomed_camera_image_mobject_config
+ self.zoomed_camera_frame_starting_position = (
+ zoomed_camera_frame_starting_position
+ )
+ self.zoom_factor = zoom_factor
+ self.image_frame_stroke_width = image_frame_stroke_width
+ self.zoom_activated = zoom_activated
+ super().__init__(camera_class=camera_class, **kwargs)
+
+ def setup(self):
+ """
+ This method is used internally by Manim to
+ setup the scene for proper use.
+ """
+ super().setup()
+ # Initialize camera and display
+ zoomed_camera = MovingCamera(**self.zoomed_camera_config)
+ zoomed_display = ImageMobjectFromCamera(
+ zoomed_camera, **self.zoomed_camera_image_mobject_config
+ )
+ zoomed_display.add_display_frame()
+ for mob in zoomed_camera.frame, zoomed_display:
+ mob.stretch_to_fit_height(self.zoomed_display_height)
+ mob.stretch_to_fit_width(self.zoomed_display_width)
+ zoomed_camera.frame.scale(self.zoom_factor)
+
+ # Position camera and display
+ zoomed_camera.frame.move_to(self.zoomed_camera_frame_starting_position)
+ if self.zoomed_display_center is not None:
+ zoomed_display.move_to(self.zoomed_display_center)
+ else:
+ zoomed_display.to_corner(
+ self.zoomed_display_corner,
+ buff=self.zoomed_display_corner_buff,
+ )
+
+ self.zoomed_camera = zoomed_camera
+ self.zoomed_display = zoomed_display
+
+ def activate_zooming(self, animate: bool = False):
+ """
+ This method is used to activate the zooming for
+ the zoomed_camera.
+
+ Parameters
+ ----------
+ animate
+ Whether or not to animate the activation
+ of the zoomed camera.
+ """
+ self.zoom_activated = True
+ self.renderer.camera.add_image_mobject_from_camera(self.zoomed_display)
+ if animate:
+ self.play(self.get_zoom_in_animation())
+ self.play(self.get_zoomed_display_pop_out_animation())
+ self.add_foreground_mobjects(
+ self.zoomed_camera.frame,
+ self.zoomed_display,
+ )
+
+ def get_zoom_in_animation(self, run_time: float = 2, **kwargs):
+ """
+ Returns the animation of camera zooming in.
+
+ Parameters
+ ----------
+ run_time
+ The run_time of the animation of the camera zooming in.
+ **kwargs
+ Any valid keyword arguments of ApplyMethod()
+
+ Returns
+ -------
+ ApplyMethod
+ The animation of the camera zooming in.
+ """
+ frame = self.zoomed_camera.frame
+ full_frame_height = self.camera.frame_height
+ full_frame_width = self.camera.frame_width
+ frame.save_state()
+ frame.stretch_to_fit_width(full_frame_width)
+ frame.stretch_to_fit_height(full_frame_height)
+ frame.center()
+ frame.set_stroke(width=0)
+ return ApplyMethod(frame.restore, run_time=run_time, **kwargs)
+
+ def get_zoomed_display_pop_out_animation(self, **kwargs):
+ """
+ This is the animation of the popping out of the
+ mini-display that shows the content of the zoomed
+ camera.
+
+ Returns
+ -------
+ ApplyMethod
+ The Animation of the Zoomed Display popping out.
+ """
+ display = self.zoomed_display
+ display.save_state()
+ display.replace(self.zoomed_camera.frame, stretch=True)
+ return ApplyMethod(display.restore)
+
+ def get_zoom_factor(self):
+ """
+ Returns the Zoom factor of the Zoomed camera.
+ Defined as the ratio between the height of the
+ zoomed camera and the height of the zoomed mini
+ display.
+ Returns
+ -------
+ float
+ The zoom factor.
+ """
+ return self.zoomed_camera.frame.height / self.zoomed_display.height
diff --git a/data/rag/manim_docs/manim_core/source/templates/Axes.mtp b/data/rag/manim_docs/manim_core/source/templates/Axes.mtp
new file mode 100644
index 0000000000000000000000000000000000000000..8c2b8ed9a53bfc8d72e4f8aaf9388e89d4562944
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/templates/Axes.mtp
@@ -0,0 +1,11 @@
+class AxesTemplate(Scene):
+ def construct(self):
+ graph = Axes(
+ x_range=[-1,10,1],
+ y_range=[-1,10,1],
+ x_length=9,
+ y_length=6,
+ axis_config={"include_tip":False}
+ )
+ labels = graph.get_axis_labels()
+ self.add(graph, labels)
diff --git a/data/rag/manim_docs/manim_core/source/templates/Default.mtp b/data/rag/manim_docs/manim_core/source/templates/Default.mtp
new file mode 100644
index 0000000000000000000000000000000000000000..317ca7ba10d40c7406c346ceae83d45b3d628750
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/templates/Default.mtp
@@ -0,0 +1,12 @@
+class DefaultTemplate(Scene):
+ def construct(self):
+ circle = Circle() # create a circle
+ circle.set_fill(PINK, opacity=0.5) # set color and transparency
+
+ square = Square() # create a square
+ square.flip(RIGHT) # flip horizontally
+ square.rotate(-3 * TAU / 8) # rotate a certain amount
+
+ self.play(Create(square)) # animate the creation of the square
+ self.play(Transform(square, circle)) # interpolate the square into the circle
+ self.play(FadeOut(square)) # fade out animation
diff --git a/data/rag/manim_docs/manim_core/source/templates/MovingCamera.mtp b/data/rag/manim_docs/manim_core/source/templates/MovingCamera.mtp
new file mode 100644
index 0000000000000000000000000000000000000000..02ea5dc4e66a5d7cac0c6d2e6c36008e05d21e33
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/templates/MovingCamera.mtp
@@ -0,0 +1,8 @@
+class MovingCameraTemplate(MovingCameraScene):
+ def construct(self):
+ text = Text("Hello World").set_color(BLUE)
+ self.add(text)
+ self.camera.frame.save_state()
+ self.play(self.camera.frame.animate.set(width=text.width * 1.2))
+ self.wait(0.3)
+ self.play(Restore(self.camera.frame))
diff --git a/data/rag/manim_docs/manim_core/source/templates/template.cfg b/data/rag/manim_docs/manim_core/source/templates/template.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..7be41783b6836c1e3383f68840e7b9e38015db56
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/templates/template.cfg
@@ -0,0 +1,7 @@
+[CLI]
+frame_rate = 30
+pixel_height = 480
+pixel_width = 854
+background_color = BLACK
+background_opacity = 1
+scene_names = DefaultScene
diff --git a/data/rag/manim_docs/manim_core/source/typing.py b/data/rag/manim_docs/manim_core/source/typing.py
new file mode 100644
index 0000000000000000000000000000000000000000..495f1997587bda59946e3f90bba6fd6138aa9a25
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/typing.py
@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+from os import PathLike
+from typing import Callable, Tuple, Union
+
+import numpy as np
+import numpy.typing as npt
+from typing_extensions import TypeAlias
+
+# Color Types
+
+ManimFloat: TypeAlias = np.float64
+ManimInt: TypeAlias = np.int64
+ManimColorDType: TypeAlias = ManimFloat
+
+RGB_Array_Float: TypeAlias = npt.NDArray[ManimFloat]
+RGB_Tuple_Float: TypeAlias = Tuple[float, float, float]
+
+RGB_Array_Int: TypeAlias = npt.NDArray[ManimInt]
+RGB_Tuple_Int: TypeAlias = Tuple[int, int, int]
+
+RGBA_Array_Float: TypeAlias = npt.NDArray[ManimFloat]
+RGBA_Tuple_Float: TypeAlias = Tuple[float, float, float, float]
+
+RGBA_Array_Int: TypeAlias = npt.NDArray[ManimInt]
+RGBA_Tuple_Int: TypeAlias = Tuple[int, int, int, int]
+
+HSV_Array_Float: TypeAlias = RGB_Array_Float
+HSV_Tuple_Float: TypeAlias = RGB_Tuple_Float
+
+ManimColorInternal: TypeAlias = npt.NDArray[ManimColorDType]
+
+# Point Types
+
+PointDType: TypeAlias = ManimFloat
+""" DType for all points. """
+
+InternalPoint2D: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (2,)` A 2D point. `[float, float]`.
+This type alias is mostly made available for internal use and only includes the numpy type.
+"""
+
+Point2D: TypeAlias = Union[InternalPoint2D, Tuple[float, float]]
+""" `shape: (2,)` A 2D point. `[float, float]`. """
+
+InternalPoint3D: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (3,)` A 3D point. `[float, float, float]`.
+This type alias is mostly made available for internal use and only includes the numpy type.
+"""
+
+Point3D: TypeAlias = Union[InternalPoint3D, Tuple[float, float, float]]
+""" `shape: (3,)` A 3D point. `[float, float, float]` """
+
+# Bezier Types
+QuadraticBezierPoints: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (3,3)` An Array of Quadratic Bezier Handles `[[float, float, float], [float, float, float], [float, float, float]]`. """
+
+QuadraticBezierPoints_Array: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,3,3)` An Array of Quadratic Bezier Handles `[[[float, float, float], [float, float, float], [float, float, float]], ...]`. """
+
+CubicBezierPoints: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (4,3)` An Array of Cubic Bezier Handles `[[float, float, float], [float, float, float], [float, float, float], [float, float, float]]`. """
+
+BezierPoints: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,3)` An Array of Cubic Bezier Handles `[[float, float, float], ...]`.
+`N` Is always multiples of the degree of the Bezier curve.
+(Please refer to the documentation of the function you are using for further type Information)
+"""
+
+FlatBezierPoints: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N)` An Array of Bezier Handles but flattened `[float, ...]`."""
+
+Point2D_Array: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,2)` An Array of Points in 2D Space `[[float, float], ...]`.
+
+(Please refer to the documentation of the function you are using for further type Information)
+"""
+
+InternalPoint3D_Array: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,3)` An Array of Points in 3D Space `[[float, float, float], ...]`.
+This type alias is mostly made available for internal use and only includes the numpy type.
+"""
+
+Point3D_Array: TypeAlias = Union[
+ InternalPoint3D_Array, Tuple[Tuple[float, float, float], ...]
+]
+""" `shape: (N,3)` An Array of Points in 3D Space `[[float, float, float], ...]`.
+
+(Please refer to the documentation of the function you are using for further type Information)
+"""
+
+BezierPoints_Array: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,PPC,3)` An Array of Bezier Handles `[[[float, float, float], ...], ...]`.
+`PPC` Is the number of points per bezier curve. `N` Is the number of bezier curves.
+(Please refer to the documentation of the function you are using for further type Information)
+"""
+
+# Vector Types
+Vector3: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (3,)` A Vector `[float, float, float]`. """
+
+Vector: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,)` A Vector `[float, ...]`. """
+
+RowVector: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (1,N)` A Row Vector `[[float, ...]]`. """
+
+ColVector: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (N,1)` A Column Vector `[[float], [float], ...]`. """
+
+MatrixMN: TypeAlias = npt.NDArray[PointDType]
+""" `shape: (M,N)` A Matrix `[[float, ...], [float, ...], ...]`. """
+
+Zeros: TypeAlias = npt.NDArray[ManimFloat]
+"""A Matrix of Zeros. Typically created with `numpy.zeros((M,N))`"""
+
+# Due to current limitations (see https://github.com/python/mypy/issues/14656 / 8263), we don't specify the first argument type (Mobject).
+FunctionOverride: TypeAlias = Callable[..., None]
+"""Function type returning an animation for the specified Mobject."""
+
+
+# Misc
+PathFuncType: TypeAlias = Callable[[Point3D, Point3D, float], Point3D]
+"""Function mapping two points and an alpha value to a new point"""
+
+MappingFunction: TypeAlias = Callable[[Point3D], Point3D]
+"""A function mapping a Point3D to another Point3D"""
+
+Image: TypeAlias = np.ndarray
+"""An Image"""
+
+StrPath: TypeAlias = "str | PathLike[str]"
+StrOrBytesPath: TypeAlias = "str | bytes | PathLike[str] | PathLike[bytes]"
diff --git a/data/rag/manim_docs/manim_core/source/utils/__init__.py b/data/rag/manim_docs/manim_core/source/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/data/rag/manim_docs/manim_core/source/utils/bezier.py b/data/rag/manim_docs/manim_core/source/utils/bezier.py
new file mode 100644
index 0000000000000000000000000000000000000000..938e7362b56dae6edf9ce8f5f6ea37ef9b608359
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/bezier.py
@@ -0,0 +1,811 @@
+"""Utility functions related to Bézier curves."""
+
+from __future__ import annotations
+
+from manim.typing import (
+ BezierPoints,
+ ColVector,
+ MatrixMN,
+ Point3D,
+ Point3D_Array,
+ PointDType,
+ QuadraticBezierPoints,
+ QuadraticBezierPoints_Array,
+)
+
+__all__ = [
+ "bezier",
+ "partial_bezier_points",
+ "partial_quadratic_bezier_points",
+ "interpolate",
+ "integer_interpolate",
+ "mid",
+ "inverse_interpolate",
+ "match_interpolate",
+ "get_smooth_handle_points",
+ "get_smooth_cubic_bezier_handle_points",
+ "diag_to_matrix",
+ "is_closed",
+ "proportions_along_bezier_curve_for_point",
+ "point_lies_on_bezier",
+]
+
+
+from functools import reduce
+from typing import Any, Callable, Sequence, overload
+
+import numpy as np
+import numpy.typing as npt
+from scipy import linalg
+
+from ..utils.simple_functions import choose
+from ..utils.space_ops import cross2d, find_intersection
+
+
+def bezier(
+ points: Sequence[Point3D] | Point3D_Array,
+) -> Callable[[float], Point3D]:
+ """Classic implementation of a bezier curve.
+
+ Parameters
+ ----------
+ points
+ points defining the desired bezier curve.
+
+ Returns
+ -------
+ function describing the bezier curve.
+ You can pass a t value between 0 and 1 to get the corresponding point on the curve.
+ """
+ n = len(points) - 1
+ # Cubic Bezier curve
+ if n == 3:
+ return lambda t: np.asarray(
+ (1 - t) ** 3 * points[0]
+ + 3 * t * (1 - t) ** 2 * points[1]
+ + 3 * (1 - t) * t**2 * points[2]
+ + t**3 * points[3],
+ dtype=PointDType,
+ )
+ # Quadratic Bezier curve
+ if n == 2:
+ return lambda t: np.asarray(
+ (1 - t) ** 2 * points[0] + 2 * t * (1 - t) * points[1] + t**2 * points[2],
+ dtype=PointDType,
+ )
+
+ return lambda t: np.asarray(
+ np.asarray(
+ [
+ (((1 - t) ** (n - k)) * (t**k) * choose(n, k) * point)
+ for k, point in enumerate(points)
+ ],
+ dtype=PointDType,
+ ).sum(axis=0)
+ )
+
+
+# !TODO: This function has still a weird implementation with the overlapping points
+def partial_bezier_points(points: BezierPoints, a: float, b: float) -> BezierPoints:
+ """Given an array of points which define bezier curve, and two numbers 0<=a QuadraticBezierPoints:
+ if a == 1:
+ return np.asarray(3 * [points[-1]])
+
+ def curve(t: float) -> Point3D:
+ return np.asarray(
+ points[0] * (1 - t) * (1 - t)
+ + 2 * points[1] * t * (1 - t)
+ + points[2] * t * t
+ )
+
+ # bezier(points)
+ h0 = curve(a) if a > 0 else points[0]
+ h2 = curve(b) if b < 1 else points[2]
+ h1_prime = (1 - a) * points[1] + a * points[2]
+ end_prop = (b - a) / (1.0 - a)
+ h1 = (1 - end_prop) * h0 + end_prop * h1_prime
+ return np.asarray((h0, h1, h2))
+
+
+def split_quadratic_bezier(points: QuadraticBezierPoints, t: float) -> BezierPoints:
+ """Split a quadratic Bézier curve at argument ``t`` into two quadratic curves.
+
+ Parameters
+ ----------
+ points
+ The control points of the bezier curve
+ has shape ``[a1, h1, b1]``
+
+ t
+ The ``t``-value at which to split the Bézier curve
+
+ Returns
+ -------
+ The two Bézier curves as a list of tuples,
+ has the shape ``[a1, h1, b1], [a2, h2, b2]``
+ """
+ a1, h1, a2 = points
+ s1 = interpolate(a1, h1, t)
+ s2 = interpolate(h1, a2, t)
+ p = interpolate(s1, s2, t)
+
+ return np.array((a1, s1, p, p, s2, a2))
+
+
+def subdivide_quadratic_bezier(points: QuadraticBezierPoints, n: int) -> BezierPoints:
+ """Subdivide a quadratic Bézier curve into ``n`` subcurves which have the same shape.
+
+ The points at which the curve is split are located at the
+ arguments :math:`t = i/n` for :math:`i = 1, ..., n-1`.
+
+ Parameters
+ ----------
+ points
+ The control points of the Bézier curve in form ``[a1, h1, b1]``
+
+ n
+ The number of curves to subdivide the Bézier curve into
+
+ Returns
+ -------
+ The new points for the Bézier curve in the form ``[a1, h1, b1, a2, h2, b2, ...]``
+
+ .. image:: /_static/bezier_subdivision_example.png
+
+ """
+ beziers = np.empty((n, 3, 3))
+ current = points
+ for j in range(0, n):
+ i = n - j
+ tmp = split_quadratic_bezier(current, 1 / i)
+ beziers[j] = tmp[:3]
+ current = tmp[3:]
+ return beziers.reshape(-1, 3)
+
+
+def quadratic_bezier_remap(
+ triplets: QuadraticBezierPoints_Array, new_number_of_curves: int
+) -> QuadraticBezierPoints_Array:
+ """Remaps the number of curves to a higher amount by splitting bezier curves
+
+ Parameters
+ ----------
+ triplets
+ The triplets of the quadratic bezier curves to be remapped shape(n, 3, 3)
+
+ new_number_of_curves
+ The number of curves that the output will contain. This needs to be higher than the current number.
+
+ Returns
+ -------
+ The new triplets for the quadratic bezier curves.
+ """
+ difference = new_number_of_curves - len(triplets)
+ if difference <= 0:
+ return triplets
+ new_triplets = np.zeros((new_number_of_curves, 3, 3))
+ idx = 0
+ for triplet in triplets:
+ if difference > 0:
+ tmp_noc = int(np.ceil(difference / len(triplets))) + 1
+ tmp = subdivide_quadratic_bezier(triplet, tmp_noc).reshape(-1, 3, 3)
+ for i in range(tmp_noc):
+ new_triplets[idx + i] = tmp[i]
+ difference -= tmp_noc - 1
+ idx += tmp_noc
+ else:
+ new_triplets[idx] = triplet
+ idx += 1
+ return new_triplets
+
+ """
+ This is an alternate version of the function just for documentation purposes
+ --------
+
+ difference = new_number_of_curves - len(triplets)
+ if difference <= 0:
+ return triplets
+ new_triplets = []
+ for triplet in triplets:
+ if difference > 0:
+ tmp_noc = int(np.ceil(difference / len(triplets))) + 1
+ tmp = subdivide_quadratic_bezier(triplet, tmp_noc).reshape(-1, 3, 3)
+ for i in range(tmp_noc):
+ new_triplets.append(tmp[i])
+ difference -= tmp_noc - 1
+ else:
+ new_triplets.append(triplet)
+ return new_triplets
+ """
+
+
+# Linear interpolation variants
+
+
+@overload
+def interpolate(start: float, end: float, alpha: float) -> float:
+ ...
+
+
+@overload
+def interpolate(start: Point3D, end: Point3D, alpha: float) -> Point3D:
+ ...
+
+
+def interpolate(
+ start: int | float | Point3D, end: int | float | Point3D, alpha: float | Point3D
+) -> float | Point3D:
+ return (1 - alpha) * start + alpha * end
+
+
+def integer_interpolate(
+ start: float,
+ end: float,
+ alpha: float,
+) -> tuple[int, float]:
+ """
+ This is a variant of interpolate that returns an integer and the residual
+
+ Parameters
+ ----------
+ start
+ The start of the range
+ end
+ The end of the range
+ alpha
+ a float between 0 and 1.
+
+ Returns
+ -------
+ tuple[int, float]
+ This returns an integer between start and end (inclusive) representing
+ appropriate interpolation between them, along with a
+ "residue" representing a new proportion between the
+ returned integer and the next one of the
+ list.
+
+ Example
+ -------
+
+ .. code-block:: pycon
+
+ >>> integer, residue = integer_interpolate(start=0, end=10, alpha=0.46)
+ >>> np.allclose((integer, residue), (4, 0.6))
+ True
+ """
+ if alpha >= 1:
+ return (int(end - 1), 1.0)
+ if alpha <= 0:
+ return (int(start), 0)
+ value = int(interpolate(start, end, alpha))
+ residue = ((end - start) * alpha) % 1
+ return (value, residue)
+
+
+@overload
+def mid(start: float, end: float) -> float:
+ ...
+
+
+@overload
+def mid(start: Point3D, end: Point3D) -> Point3D:
+ ...
+
+
+def mid(start: float | Point3D, end: float | Point3D) -> float | Point3D:
+ """Returns the midpoint between two values.
+
+ Parameters
+ ----------
+ start
+ The first value
+ end
+ The second value
+
+ Returns
+ -------
+ The midpoint between the two values
+ """
+ return (start + end) / 2.0
+
+
+@overload
+def inverse_interpolate(start: float, end: float, value: float) -> float:
+ ...
+
+
+@overload
+def inverse_interpolate(start: float, end: float, value: Point3D) -> Point3D:
+ ...
+
+
+@overload
+def inverse_interpolate(start: Point3D, end: Point3D, value: Point3D) -> Point3D:
+ ...
+
+
+def inverse_interpolate(
+ start: float | Point3D, end: float | Point3D, value: float | Point3D
+) -> float | Point3D:
+ """Perform inverse interpolation to determine the alpha
+ values that would produce the specified ``value``
+ given the ``start`` and ``end`` values or points.
+
+ Parameters
+ ----------
+ start
+ The start value or point of the interpolation.
+ end
+ The end value or point of the interpolation.
+ value
+ The value or point for which the alpha value
+ should be determined.
+
+ Returns
+ -------
+ The alpha values producing the given input
+ when interpolating between ``start`` and ``end``.
+
+ Example
+ -------
+
+ .. code-block:: pycon
+
+ >>> inverse_interpolate(start=2, end=6, value=4)
+ 0.5
+
+ >>> start = np.array([1, 2, 1])
+ >>> end = np.array([7, 8, 11])
+ >>> value = np.array([4, 5, 5])
+ >>> inverse_interpolate(start, end, value)
+ array([0.5, 0.5, 0.4])
+ """
+ return np.true_divide(value - start, end - start)
+
+
+@overload
+def match_interpolate(
+ new_start: float,
+ new_end: float,
+ old_start: float,
+ old_end: float,
+ old_value: float,
+) -> float:
+ ...
+
+
+@overload
+def match_interpolate(
+ new_start: float,
+ new_end: float,
+ old_start: float,
+ old_end: float,
+ old_value: Point3D,
+) -> Point3D:
+ ...
+
+
+def match_interpolate(
+ new_start: float,
+ new_end: float,
+ old_start: float,
+ old_end: float,
+ old_value: float | Point3D,
+) -> float | Point3D:
+ """Interpolate a value from an old range to a new range.
+
+ Parameters
+ ----------
+ new_start
+ The start of the new range.
+ new_end
+ The end of the new range.
+ old_start
+ The start of the old range.
+ old_end
+ The end of the old range.
+ old_value
+ The value within the old range whose corresponding
+ value in the new range (with the same alpha value)
+ is desired.
+
+ Returns
+ -------
+ The interpolated value within the new range.
+
+ Examples
+ --------
+ >>> match_interpolate(0, 100, 10, 20, 15)
+ 50.0
+ """
+ old_alpha = inverse_interpolate(old_start, old_end, old_value)
+ return interpolate(
+ new_start,
+ new_end,
+ old_alpha, # type: ignore
+ )
+
+
+def get_smooth_cubic_bezier_handle_points(
+ points: Point3D_Array,
+) -> tuple[BezierPoints, BezierPoints]:
+ points = np.asarray(points)
+ num_handles = len(points) - 1
+ dim = points.shape[1]
+ if num_handles < 1:
+ return np.zeros((0, dim)), np.zeros((0, dim))
+ # Must solve 2*num_handles equations to get the handles.
+ # l and u are the number of lower an upper diagonal rows
+ # in the matrix to solve.
+ l, u = 2, 1
+ # diag is a representation of the matrix in diagonal form
+ # See https://www.particleincell.com/2012/bezier-splines/
+ # for how to arrive at these equations
+ diag: MatrixMN = np.zeros((l + u + 1, 2 * num_handles))
+ diag[0, 1::2] = -1
+ diag[0, 2::2] = 1
+ diag[1, 0::2] = 2
+ diag[1, 1::2] = 1
+ diag[2, 1:-2:2] = -2
+ diag[3, 0:-3:2] = 1
+ # last
+ diag[2, -2] = -1
+ diag[1, -1] = 2
+ # This is the b as in Ax = b, where we are solving for x,
+ # and A is represented using diag. However, think of entries
+ # to x and b as being points in space, not numbers
+ b: Point3D_Array = np.zeros((2 * num_handles, dim))
+ b[1::2] = 2 * points[1:]
+ b[0] = points[0]
+ b[-1] = points[-1]
+
+ def solve_func(b: ColVector) -> ColVector | MatrixMN:
+ return linalg.solve_banded((l, u), diag, b) # type: ignore
+
+ use_closed_solve_function = is_closed(points)
+ if use_closed_solve_function:
+ # Get equations to relate first and last points
+ matrix = diag_to_matrix((l, u), diag)
+ # last row handles second derivative
+ matrix[-1, [0, 1, -2, -1]] = [2, -1, 1, -2]
+ # first row handles first derivative
+ matrix[0, :] = np.zeros(matrix.shape[1])
+ matrix[0, [0, -1]] = [1, 1]
+ b[0] = 2 * points[0]
+ b[-1] = np.zeros(dim)
+
+ def closed_curve_solve_func(b: ColVector) -> ColVector | MatrixMN:
+ return linalg.solve(matrix, b) # type: ignore
+
+ handle_pairs = np.zeros((2 * num_handles, dim))
+ for i in range(dim):
+ if use_closed_solve_function:
+ handle_pairs[:, i] = closed_curve_solve_func(b[:, i])
+ else:
+ handle_pairs[:, i] = solve_func(b[:, i])
+ return handle_pairs[0::2], handle_pairs[1::2]
+
+
+def get_smooth_handle_points(
+ points: BezierPoints,
+) -> tuple[BezierPoints, BezierPoints]:
+ """Given some anchors (points), compute handles so the resulting bezier curve is smooth.
+
+ Parameters
+ ----------
+ points
+ Anchors.
+
+ Returns
+ -------
+ typing.Tuple[np.ndarray, np.ndarray]
+ Computed handles.
+ """
+ # NOTE points here are anchors.
+ points = np.asarray(points)
+ num_handles = len(points) - 1
+ dim = points.shape[1]
+ if num_handles < 1:
+ return np.zeros((0, dim)), np.zeros((0, dim))
+ # Must solve 2*num_handles equations to get the handles.
+ # l and u are the number of lower an upper diagonal rows
+ # in the matrix to solve.
+ l, u = 2, 1
+ # diag is a representation of the matrix in diagonal form
+ # See https://www.particleincell.com/2012/bezier-splines/
+ # for how to arrive at these equations
+ diag: MatrixMN = np.zeros((l + u + 1, 2 * num_handles))
+ diag[0, 1::2] = -1
+ diag[0, 2::2] = 1
+ diag[1, 0::2] = 2
+ diag[1, 1::2] = 1
+ diag[2, 1:-2:2] = -2
+ diag[3, 0:-3:2] = 1
+ # last
+ diag[2, -2] = -1
+ diag[1, -1] = 2
+ # This is the b as in Ax = b, where we are solving for x,
+ # and A is represented using diag. However, think of entries
+ # to x and b as being points in space, not numbers
+ b = np.zeros((2 * num_handles, dim))
+ b[1::2] = 2 * points[1:]
+ b[0] = points[0]
+ b[-1] = points[-1]
+
+ def solve_func(b: ColVector) -> ColVector | MatrixMN:
+ return linalg.solve_banded((l, u), diag, b) # type: ignore
+
+ use_closed_solve_function = is_closed(points)
+ if use_closed_solve_function:
+ # Get equations to relate first and last points
+ matrix = diag_to_matrix((l, u), diag)
+ # last row handles second derivative
+ matrix[-1, [0, 1, -2, -1]] = [2, -1, 1, -2]
+ # first row handles first derivative
+ matrix[0, :] = np.zeros(matrix.shape[1])
+ matrix[0, [0, -1]] = [1, 1]
+ b[0] = 2 * points[0]
+ b[-1] = np.zeros(dim)
+
+ def closed_curve_solve_func(b: ColVector) -> ColVector | MatrixMN:
+ return linalg.solve(matrix, b) # type: ignore
+
+ handle_pairs = np.zeros((2 * num_handles, dim))
+ for i in range(dim):
+ if use_closed_solve_function:
+ handle_pairs[:, i] = closed_curve_solve_func(b[:, i])
+ else:
+ handle_pairs[:, i] = solve_func(b[:, i])
+ return handle_pairs[0::2], handle_pairs[1::2]
+
+
+def diag_to_matrix(
+ l_and_u: tuple[int, int], diag: npt.NDArray[Any]
+) -> npt.NDArray[Any]:
+ """
+ Converts array whose rows represent diagonal
+ entries of a matrix into the matrix itself.
+ See scipy.linalg.solve_banded
+ """
+ l, u = l_and_u
+ dim = diag.shape[1]
+ matrix = np.zeros((dim, dim))
+ for i in range(l + u + 1):
+ np.fill_diagonal(
+ matrix[max(0, i - u) :, max(0, u - i) :],
+ diag[i, max(0, u - i) :],
+ )
+ return matrix
+
+
+# Given 4 control points for a cubic bezier curve (or arrays of such)
+# return control points for 2 quadratics (or 2n quadratics) approximating them.
+def get_quadratic_approximation_of_cubic(
+ a0: Point3D, h0: Point3D, h1: Point3D, a1: Point3D
+) -> BezierPoints:
+ a0 = np.array(a0, ndmin=2)
+ h0 = np.array(h0, ndmin=2)
+ h1 = np.array(h1, ndmin=2)
+ a1 = np.array(a1, ndmin=2)
+ # Tangent vectors at the start and end.
+ T0 = h0 - a0
+ T1 = a1 - h1
+
+ # Search for inflection points. If none are found, use the
+ # midpoint as a cut point.
+ # Based on http://www.caffeineowl.com/graphics/2d/vectorial/cubic-inflexion.html
+ has_infl = np.ones(len(a0), dtype=bool)
+
+ p = h0 - a0
+ q = h1 - 2 * h0 + a0
+ r = a1 - 3 * h1 + 3 * h0 - a0
+
+ a = cross2d(q, r)
+ b = cross2d(p, r)
+ c = cross2d(p, q)
+
+ disc = b * b - 4 * a * c
+ has_infl &= disc > 0
+ sqrt_disc = np.sqrt(np.abs(disc))
+ settings = np.seterr(all="ignore")
+ ti_bounds = []
+ for sgn in [-1, +1]:
+ ti = (-b + sgn * sqrt_disc) / (2 * a)
+ ti[a == 0] = (-c / b)[a == 0]
+ ti[(a == 0) & (b == 0)] = 0
+ ti_bounds.append(ti)
+ ti_min, ti_max = ti_bounds
+ np.seterr(**settings)
+ ti_min_in_range = has_infl & (0 < ti_min) & (ti_min < 1)
+ ti_max_in_range = has_infl & (0 < ti_max) & (ti_max < 1)
+
+ # Choose a value of t which starts at 0.5,
+ # but is updated to one of the inflection points
+ # if they lie between 0 and 1
+
+ t_mid = 0.5 * np.ones(len(a0))
+ t_mid[ti_min_in_range] = ti_min[ti_min_in_range]
+ t_mid[ti_max_in_range] = ti_max[ti_max_in_range]
+
+ m, n = a0.shape
+ t_mid = t_mid.repeat(n).reshape((m, n))
+
+ # Compute bezier point and tangent at the chosen value of t (these are vectorized)
+ mid = bezier([a0, h0, h1, a1])(t_mid) # type: ignore
+ Tm = bezier([h0 - a0, h1 - h0, a1 - h1])(t_mid) # type: ignore
+
+ # Intersection between tangent lines at end points
+ # and tangent in the middle
+ i0 = find_intersection(a0, T0, mid, Tm)
+ i1 = find_intersection(a1, T1, mid, Tm)
+
+ m, n = np.shape(a0)
+ result = np.zeros((6 * m, n))
+ result[0::6] = a0
+ result[1::6] = i0
+ result[2::6] = mid
+ result[3::6] = mid
+ result[4::6] = i1
+ result[5::6] = a1
+ return result
+
+
+def is_closed(points: Point3D_Array) -> bool:
+ return np.allclose(points[0], points[-1]) # type: ignore
+
+
+def proportions_along_bezier_curve_for_point(
+ point: Point3D,
+ control_points: BezierPoints,
+ round_to: float = 1e-6,
+) -> npt.NDArray[Any]:
+ """Obtains the proportion along the bezier curve corresponding to a given point
+ given the bezier curve's control points.
+
+ The bezier polynomial is constructed using the coordinates of the given point
+ as well as the bezier curve's control points. On solving the polynomial for each dimension,
+ if there are roots common to every dimension, those roots give the proportion along the
+ curve the point is at. If there are no real roots, the point does not lie on the curve.
+
+ Parameters
+ ----------
+ point
+ The Cartesian Coordinates of the point whose parameter
+ should be obtained.
+ control_points
+ The Cartesian Coordinates of the ordered control
+ points of the bezier curve on which the point may
+ or may not lie.
+ round_to
+ A float whose number of decimal places all values
+ such as coordinates of points will be rounded.
+
+ Returns
+ -------
+ np.ndarray[float]
+ List containing possible parameters (the proportions along the bezier curve)
+ for the given point on the given bezier curve.
+ This usually only contains one or zero elements, but if the
+ point is, say, at the beginning/end of a closed loop, may return
+ a list with more than 1 value, corresponding to the beginning and
+ end etc. of the loop.
+
+ Raises
+ ------
+ :class:`ValueError`
+ When ``point`` and the control points have different shapes.
+ """
+ # Method taken from
+ # http://polymathprogrammer.com/2012/04/03/does-point-lie-on-bezier-curve/
+
+ if not all(np.shape(point) == np.shape(c_p) for c_p in control_points):
+ raise ValueError(
+ f"Point {point} and Control Points {control_points} have different shapes.",
+ )
+
+ control_points = np.array(control_points)
+ n = len(control_points) - 1
+
+ roots = []
+ for dim, coord in enumerate(point):
+ control_coords = control_points[:, dim]
+ terms = []
+ for term_power in range(n, -1, -1):
+ outercoeff = choose(n, term_power)
+ term = []
+ sign = 1
+ for subterm_num in range(term_power, -1, -1):
+ innercoeff = choose(term_power, subterm_num) * sign
+ subterm = innercoeff * control_coords[subterm_num]
+ if term_power == 0:
+ subterm -= coord
+ term.append(subterm)
+ sign *= -1
+ terms.append(outercoeff * sum(np.array(term)))
+ if all(term == 0 for term in terms):
+ # Then both Bezier curve and Point lie on the same plane.
+ # Roots will be none, but in this specific instance, we don't need to consider that.
+ continue
+ bezier_polynom = np.polynomial.Polynomial(terms[::-1])
+ polynom_roots = bezier_polynom.roots() # type: ignore
+ if len(polynom_roots) > 0:
+ polynom_roots = np.around(polynom_roots, int(np.log10(1 / round_to)))
+ roots.append(polynom_roots)
+
+ roots = [[root for root in rootlist if root.imag == 0] for rootlist in roots]
+ # Get common roots
+ # arg-type: ignore
+ roots = reduce(np.intersect1d, roots) # type: ignore
+ result = np.asarray([r.real for r in roots if 0 <= r.real <= 1])
+ return result
+
+
+def point_lies_on_bezier(
+ point: Point3D,
+ control_points: BezierPoints,
+ round_to: float = 1e-6,
+) -> bool:
+ """Checks if a given point lies on the bezier curves with the given control points.
+
+ This is done by solving the bezier polynomial with the point as the constant term; if
+ any real roots exist, the point lies on the bezier curve.
+
+ Parameters
+ ----------
+ point
+ The Cartesian Coordinates of the point to check.
+ control_points
+ The Cartesian Coordinates of the ordered control
+ points of the bezier curve on which the point may
+ or may not lie.
+ round_to
+ A float whose number of decimal places all values
+ such as coordinates of points will be rounded.
+
+ Returns
+ -------
+ bool
+ Whether the point lies on the curve.
+ """
+
+ roots = proportions_along_bezier_curve_for_point(point, control_points, round_to)
+
+ return len(roots) > 0
diff --git a/data/rag/manim_docs/manim_core/source/utils/caching.py b/data/rag/manim_docs/manim_core/source/utils/caching.py
new file mode 100644
index 0000000000000000000000000000000000000000..cabecd6567a02b2afed9778e60fec9c6a086b237
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/caching.py
@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from .. import config, logger
+from ..utils.hashing import get_hash_from_play_call
+
+
+def handle_caching_play(func: Callable[..., None]):
+ """Decorator that returns a wrapped version of func that will compute
+ the hash of the play invocation.
+
+ The returned function will act according to the computed hash: either skip
+ the animation because it's already cached, or let the invoked function
+ play normally.
+
+ Parameters
+ ----------
+ func
+ The play like function that has to be written to the video file stream.
+ Take the same parameters as `scene.play`.
+ """
+
+ # NOTE : This is only kept for OpenGL renderer.
+ # The play logic of the cairo renderer as been refactored and does not need this function anymore.
+ # When OpenGL renderer will have a proper testing system,
+ # the play logic of the latter has to be refactored in the same way the cairo renderer has been, and thus this
+ # method has to be deleted.
+
+ def wrapper(self, scene, *args, **kwargs):
+ self.skip_animations = self._original_skipping_status
+ self.update_skipping_status()
+ animations = scene.compile_animations(*args, **kwargs)
+ scene.add_mobjects_from_animations(animations)
+ if self.skip_animations:
+ logger.debug(f"Skipping animation {self.num_plays}")
+ func(self, scene, *args, **kwargs)
+ # If the animation is skipped, we mark its hash as None.
+ # When sceneFileWriter will start combining partial movie files, it won't take into account None hashes.
+ self.animations_hashes.append(None)
+ self.file_writer.add_partial_movie_file(None)
+ return
+ if not config["disable_caching"]:
+ mobjects_on_scene = scene.mobjects
+ hash_play = get_hash_from_play_call(
+ self,
+ self.camera,
+ animations,
+ mobjects_on_scene,
+ )
+ if self.file_writer.is_already_cached(hash_play):
+ logger.info(
+ f"Animation {self.num_plays} : Using cached data (hash : %(hash_play)s)",
+ {"hash_play": hash_play},
+ )
+ self.skip_animations = True
+ else:
+ hash_play = f"uncached_{self.num_plays:05}"
+ self.animations_hashes.append(hash_play)
+ self.file_writer.add_partial_movie_file(hash_play)
+ logger.debug(
+ "List of the first few animation hashes of the scene: %(h)s",
+ {"h": str(self.animations_hashes[:5])},
+ )
+ func(self, scene, *args, **kwargs)
+
+ return wrapper
diff --git a/data/rag/manim_docs/manim_core/source/utils/color/AS2700.py b/data/rag/manim_docs/manim_core/source/utils/color/AS2700.py
new file mode 100644
index 0000000000000000000000000000000000000000..83a3e6abd0dd097fcb9bb0912e77dee15574507e
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/color/AS2700.py
@@ -0,0 +1,234 @@
+"""Australian Color Standard
+
+In 1985 the Australian Independent Color Standard AS 2700 was created. In
+this standard, all colors can be identified via a category code (one of
+B -- Blue, G -- Green, N -- Neutrals (grey), P -- Purple, R -- Red, T -- Blue/Green,
+X -- Yellow/Red, Y -- Yellow) and a number. The colors also have (natural) names.
+
+To use the colors from this list, access them directly from the module (which
+is exposed to Manim's global name space):
+
+.. code:: pycon
+
+ >>> from manim import AS2700
+ >>> AS2700.B23_BRIGHT_BLUE
+ ManimColor('#174F90')
+
+List of Color Constants
+-----------------------
+
+These hex values (taken from https://www.w3schools.com/colors/colors_australia.asp)
+are non official approximate values intended to simulate AS 2700 colors:
+
+.. automanimcolormodule:: manim.utils.color.AS2700
+
+"""
+
+from .core import ManimColor
+
+B11_RICH_BLUE = ManimColor("#2B3770")
+B12_ROYAL_BLUE = ManimColor("#2C3563")
+B13_NAVY_BLUE = ManimColor("#28304D")
+B14_SAPHHIRE = ManimColor("#28426B")
+B15_MID_BLUE = ManimColor("#144B6F")
+B21_ULTRAMARINE = ManimColor("#2C5098")
+B22_HOMEBUSH_BLUE = ManimColor("#215097")
+B23_BRIGHT_BLUE = ManimColor("#174F90")
+B24_HARBOUR_BLUE = ManimColor("#1C6293")
+B25_AQUA = ManimColor("#5097AC")
+B32_POWDER_BLUE = ManimColor("#B7C8DB")
+B33_MIST_BLUE = ManimColor("#E0E6E2")
+B34_PARADISE_BLUE = ManimColor("#3499BA")
+B35_PALE_BLUE = ManimColor("#CDE4E2")
+B41_BLUEBELL = ManimColor("#5B94D1")
+B42_PURPLE_BLUE = ManimColor("#5E7899")
+B43_GREY_BLUE = ManimColor("#627C8D")
+B44_LIGHT_GREY_BLUE = ManimColor("#C0C0C1")
+B45_SKY_BLUE = ManimColor("#7DB7C7")
+B51_PERIWINKLE = ManimColor("#3871AC")
+B53_DARK_GREY_BLUE = ManimColor("#4F6572")
+B55_STORM_BLUE = ManimColor("#3F7C94")
+B61_CORAL_SEA = ManimColor("#2B3873")
+B62_MIDNIGHT_BLUE = ManimColor("#292A34")
+B64_CHARCOAL = ManimColor("#363E45")
+G11_BOTTLE_GREEN = ManimColor("#253A32")
+G12_HOLLY = ManimColor("#21432D")
+G13_EMERALD = ManimColor("#195F35")
+G14_MOSS_GREEN = ManimColor("#33572D")
+G15_RAINFOREST_GREEN = ManimColor("#3D492D")
+G16_TRAFFIC_GREEN = ManimColor("#305442")
+G17_MINT_GREEN = ManimColor("#006B45")
+G21_JADE = ManimColor("#127453")
+G22_SERPENTINE = ManimColor("#78A681")
+G23_SHAMROCK = ManimColor("#336634")
+G24_FERN_TREE = ManimColor("#477036")
+G25_OLIVE = ManimColor("#595B2A")
+G26_APPLE_GREEN = ManimColor("#4E9843")
+G27_HOMEBUSH_GREEN = ManimColor("#017F4D")
+G31_VERTIGRIS = ManimColor("#468A65")
+G32_OPALINE = ManimColor("#AFCBB8")
+G33_LETTUCE = ManimColor("#7B9954")
+G34_AVOCADO = ManimColor("#757C4C")
+G35_LIME_GREEN = ManimColor("#89922E")
+G36_KIKUYU = ManimColor("#95B43B")
+G37_BEANSTALK = ManimColor("#45A56A")
+G41_LAWN_GREEN = ManimColor("#0D875D")
+G42_GLACIER = ManimColor("#D5E1D2")
+G43_SURF_GREEN = ManimColor("#C8C8A7")
+G44_PALM_GREEN = ManimColor("#99B179")
+G45_CHARTREUSE = ManimColor("#C7C98D")
+G46_CITRONELLA = ManimColor("#BFC83E")
+G47_CRYSTAL_GREEN = ManimColor("#ADCCA8")
+G51_SPRUCE = ManimColor("#05674F")
+G52_EUCALYPTUS = ManimColor("#66755B")
+G53_BANKSIA = ManimColor("#929479")
+G54_MIST_GREEN = ManimColor("#7A836D")
+G55_LICHEN = ManimColor("#A7A98C")
+G56_SAGE_GREEN = ManimColor("#677249")
+G61_DARK_GREEN = ManimColor("#283533")
+G62_RIVERGUM = ManimColor("#617061")
+G63_DEEP_BRONZE_GREEN = ManimColor("#333334")
+G64_SLATE = ManimColor("#5E6153")
+G65_TI_TREE = ManimColor("#5D5F4E")
+G66_ENVIRONMENT_GREEN = ManimColor("#484C3F")
+G67_ZUCCHINI = ManimColor("#2E443A")
+N11_PEARL_GREY = ManimColor("#D8D3C7")
+N12_PASTEL_GREY = ManimColor("#CCCCCC")
+N14_WHITE = ManimColor("#FFFFFF")
+N15_HOMEBUSH_GREY = ManimColor("#A29B93")
+N22_CLOUD_GREY = ManimColor("#C4C1B9")
+N23_NEUTRAL_GREY = ManimColor("#CCCCCC")
+N24_SILVER_GREY = ManimColor("#BDC7C5")
+N25_BIRCH_GREY = ManimColor("#ABA498")
+N32_GREEN_GREY = ManimColor("#8E9282")
+N33_LIGHTBOX_GREY = ManimColor("#ACADAD")
+N35_LIGHT_GREY = ManimColor("#A6A7A1")
+N41_OYSTER = ManimColor("#998F78")
+N42_STORM_GREY = ManimColor("#858F88")
+N43_PIPELINE_GREY = ManimColor("#999999")
+N44_BRIDGE_GREY = ManimColor("#767779")
+N45_KOALA_GREY = ManimColor("#928F88")
+N52_MID_GREY = ManimColor("#727A77")
+N53_BLUE_GREY = ManimColor("#7C8588")
+N54_BASALT = ManimColor("#585C63")
+N55_LEAD_GREY = ManimColor("#5E5C58")
+N61_BLACK = ManimColor("#2A2A2C")
+N63_PEWTER = ManimColor("#596064")
+N64_DARK_GREY = ManimColor("#4B5259")
+N65_GRAPHITE_GREY = ManimColor("#45474A")
+P11_MAGENTA = ManimColor("#7B2B48")
+P12_PURPLE = ManimColor("#85467B")
+P13_VIOLET = ManimColor("#5D3A61")
+P14_BLUEBERRY = ManimColor("#4C4176")
+P21_SUNSET_PINK = ManimColor("#E3BBBD")
+P22_CYCLAMEN = ManimColor("#83597D")
+P23_LILAC = ManimColor("#A69FB1")
+P24_JACKARANDA = ManimColor("#795F91")
+P31_DUSTY_PINK = ManimColor("#DBBEBC")
+P33_RIBBON_PINK = ManimColor("#D1BCC9")
+P41_ERICA_PINK = ManimColor("#C55A83")
+P42_MULBERRY = ManimColor("#A06574")
+P43_WISTERIA = ManimColor("#756D91")
+P52_PLUM = ManimColor("#6E3D4B")
+R11_INTERNATIONAL_ORANGE = ManimColor("#CE482A")
+R12_SCARLET = ManimColor("#CD392A")
+R13_SIGNAL_RED = ManimColor("#BA312B")
+R14_WARATAH = ManimColor("#AA2429")
+R15_CRIMSON = ManimColor("#9E2429")
+R21_TANGERINE = ManimColor("#E96957")
+R22_HOMEBUSH_RED = ManimColor("#D83A2D")
+R23_LOLLIPOP = ManimColor("#CC5058")
+R24_STRAWBERRY = ManimColor("#B4292A")
+R25_ROSE_PINK = ManimColor("#E8919C")
+R32_APPLE_BLOSSOM = ManimColor("#F2E1D8")
+R33_GHOST_GUM = ManimColor("#E8DAD4")
+R34_MUSHROOM = ManimColor("#D7C0B6")
+R35_DEEP_ROSE = ManimColor("#CD6D71")
+R41_SHELL_PINK = ManimColor("#F9D9BB")
+R42_SALMON_PINK = ManimColor("#D99679")
+R43_RED_DUST = ManimColor("#D0674F")
+R44_POSSUM = ManimColor("#A18881")
+R45_RUBY = ManimColor("#8F3E5C")
+R51_BURNT_PINK = ManimColor("#E19B8E")
+R52_TERRACOTTA = ManimColor("#A04C36")
+R53_RED_GUM = ManimColor("#8D4338")
+R54_RASPBERRY = ManimColor("#852F31")
+R55_CLARET = ManimColor("#67292D")
+R62_VENETIAN_RED = ManimColor("#77372B")
+R63_RED_OXIDE = ManimColor("#663334")
+R64_DEEP_INDIAN_RED = ManimColor("#542E2B")
+R65_MAROON = ManimColor("#3F2B3C")
+T11_TROPICAL_BLUE = ManimColor("#006698")
+T12_DIAMANTIA = ManimColor("#006C74")
+T14_MALACHITE = ManimColor("#105154")
+T15_TURQUOISE = ManimColor("#098587")
+T22_ORIENTAL_BLUE = ManimColor("#358792")
+T24_BLUE_JADE = ManimColor("#427F7E")
+T32_HUON_GREEN = ManimColor("#72B3B1")
+T33_SMOKE_BLUE = ManimColor("#9EB6B2")
+T35_GREEN_ICE = ManimColor("#78AEA2")
+T44_BLUE_GUM = ManimColor("#6A8A88")
+T45_COOTAMUNDRA = ManimColor("#759E91")
+T51_MOUNTAIN_BLUE = ManimColor("#295668")
+T53_PEACOCK_BLUE = ManimColor("#245764")
+T63_TEAL = ManimColor("#183F4E")
+X11_BUTTERSCOTCH = ManimColor("#D38F43")
+X12_PUMPKIN = ManimColor("#DD7E1A")
+X13_MARIGOLD = ManimColor("#ED7F15")
+X14_MANDARIN = ManimColor("#E45427")
+X15_ORANGE = ManimColor("#E36C2B")
+X21_PALE_OCHRE = ManimColor("#DAA45F")
+X22_SAFFRON = ManimColor("#F6AA51")
+X23_APRICOT = ManimColor("#FEB56D")
+X24_ROCKMELON = ManimColor("#F6894B")
+X31_RAFFIA = ManimColor("#EBC695")
+X32_MAGNOLIA = ManimColor("#F1DEBE")
+X33_WARM_WHITE = ManimColor("#F3E7D4")
+X34_DRIFTWOOD = ManimColor("#D5C4AE")
+X41_BUFF = ManimColor("#C28A44")
+X42_BISCUIT = ManimColor("#DEBA92")
+X43_BEIGE = ManimColor("#C9AA8C")
+X45_CINNAMON = ManimColor("#AC826D")
+X51_TAN = ManimColor("#8F5F32")
+X52_COFFEE = ManimColor("#AD7948")
+X53_GOLDEN_TAN = ManimColor("#925629")
+X54_BROWN = ManimColor("#68452C")
+X55_NUT_BROWN = ManimColor("#764832")
+X61_WOMBAT = ManimColor("#6E5D52")
+X62_DARK_EARTH = ManimColor("#6E5D52")
+X63_IRONBARK = ManimColor("#443B36")
+X64_CHOCOLATE = ManimColor("#4A3B31")
+X65_DARK_BROWN = ManimColor("#4F372D")
+Y11_CANARY = ManimColor("#E7BD11")
+Y12_WATTLE = ManimColor("#E8AF01")
+Y13_VIVID_YELLOW = ManimColor("#FCAE01")
+Y14_GOLDEN_YELLOW = ManimColor("#F5A601")
+Y15_SUNFLOWER = ManimColor("#FFA709")
+Y16_INCA_GOLD = ManimColor("#DF8C19")
+Y21_PRIMROSE = ManimColor("#F5CF5B")
+Y22_CUSTARD = ManimColor("#EFD25C")
+Y23_BUTTERCUP = ManimColor("#E0CD41")
+Y24_STRAW = ManimColor("#E3C882")
+Y25_DEEP_CREAM = ManimColor("#F3C968")
+Y26_HOMEBUSH_GOLD = ManimColor("#FCC51A")
+Y31_LILY_GREEN = ManimColor("#E3E3CD")
+Y32_FLUMMERY = ManimColor("#E6DF9E")
+Y33_PALE_PRIMROSE = ManimColor("#F5F3CE")
+Y34_CREAM = ManimColor("#EFE3BE")
+Y35_OFF_WHITE = ManimColor("#F1E9D5")
+Y41_OLIVE_YELLOW = ManimColor("#8E7426")
+Y42_MUSTARD = ManimColor("#C4A32E")
+Y43_PARCHMENT = ManimColor("#D4C9A3")
+Y44_SAND = ManimColor("#DCC18B")
+Y45_MANILLA = ManimColor("#E5D0A7")
+Y51_BRONZE_OLIVE = ManimColor("#695D3E")
+Y52_CHAMOIS = ManimColor("#BEA873")
+Y53_SANDSTONE = ManimColor("#D5BF8E")
+Y54_OATMEAL = ManimColor("#CAAE82")
+Y55_DEEP_STONE = ManimColor("#BC9969")
+Y56_MERINO = ManimColor("#C9B79E")
+Y61_BLACK_OLIVE = ManimColor("#47473B")
+Y62_SUGAR_CANE = ManimColor("#BCA55C")
+Y63_KHAKI = ManimColor("#826843")
+Y65_MUSHROOM = ManimColor("#A39281")
+Y66_MUDSTONE = ManimColor("#574E45")
diff --git a/data/rag/manim_docs/manim_core/source/utils/color/BS381.py b/data/rag/manim_docs/manim_core/source/utils/color/BS381.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d09a6f1b32e6a51ff54c5028ec5bebdc7f65e75
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/color/BS381.py
@@ -0,0 +1,315 @@
+"""British Color Standard
+
+This module contains colors defined in one of the British Standards
+for colors, BS381C. This standard specifies colors used in identification,
+coding, and other special purposes. See https://www.britishstandardcolour.com/
+for more information.
+
+To use the colors from this list, access them directly from the module (which
+is exposed to Manim's global name space):
+
+.. code:: pycon
+
+ >>> from manim import BS381
+ >>> BS381.OXFORD_BLUE
+ ManimColor('#1F3057')
+
+List of Color Constants
+-----------------------
+
+These hex values (taken from https://www.w3schools.com/colors/colors_british.asp)
+are non official approximate values intended to simulate the ones defined
+in the standard:
+
+.. automanimcolormodule:: manim.utils.color.BS381
+
+"""
+from .core import ManimColor
+
+BS381_101 = ManimColor("#94BFAC")
+SKY_BLUE = ManimColor("#94BFAC")
+BS381_102 = ManimColor("#5B9291")
+TURQUOISE_BLUE = ManimColor("#5B9291")
+BS381_103 = ManimColor("#3B6879")
+PEACOCK_BLUE = ManimColor("#3B6879")
+BS381_104 = ManimColor("#264D7E")
+AZURE_BLUE = ManimColor("#264D7E")
+BS381_105 = ManimColor("#1F3057")
+OXFORD_BLUE = ManimColor("#1F3057")
+BS381_106 = ManimColor("#2A283D")
+ROYAL_BLUE = ManimColor("#2A283D")
+BS381_107 = ManimColor("#3A73A9")
+STRONG_BLUE = ManimColor("#3A73A9")
+BS381_108 = ManimColor("#173679")
+AIRCRAFT_BLUE = ManimColor("#173679")
+BS381_109 = ManimColor("#1C5680")
+MIDDLE_BLUE = ManimColor("#1C5680")
+BS381_110 = ManimColor("#2C3E75")
+ROUNDEL_BLUE = ManimColor("#2C3E75")
+BS381_111 = ManimColor("#8CC5BB")
+PALE_BLUE = ManimColor("#8CC5BB")
+BS381_112 = ManimColor("#78ADC2")
+ARCTIC_BLUE = ManimColor("#78ADC2")
+FIESTA_BLUE = ManimColor("#78ADC2")
+BS381_113 = ManimColor("#3F687D")
+DEEP_SAXE_BLUE = ManimColor("#3F687D")
+BS381_114 = ManimColor("#1F4B61")
+RAIL_BLUE = ManimColor("#1F4B61")
+BS381_115 = ManimColor("#5F88C1")
+COBALT_BLUE = ManimColor("#5F88C1")
+BS381_166 = ManimColor("#2458AF")
+FRENCH_BLUE = ManimColor("#2458AF")
+BS381_169 = ManimColor("#135B75")
+TRAFFIC_BLUE = ManimColor("#135B75")
+BS381_172 = ManimColor("#A7C6EB")
+PALE_ROUNDEL_BLUE = ManimColor("#A7C6EB")
+BS381_174 = ManimColor("#64A0AA")
+ORIENT_BLUE = ManimColor("#64A0AA")
+BS381_175 = ManimColor("#4F81C5")
+LIGHT_FRENCH_BLUE = ManimColor("#4F81C5")
+BS381_210 = ManimColor("#BBC9A5")
+SKY = ManimColor("#BBC9A5")
+BS381_216 = ManimColor("#BCD890")
+EAU_DE_NIL = ManimColor("#BCD890")
+BS381_217 = ManimColor("#96BF65")
+SEA_GREEN = ManimColor("#96BF65")
+BS381_218 = ManimColor("#698B47")
+GRASS_GREEN = ManimColor("#698B47")
+BS381_219 = ManimColor("#757639")
+SAGE_GREEN = ManimColor("#757639")
+BS381_220 = ManimColor("#4B5729")
+OLIVE_GREEN = ManimColor("#4B5729")
+BS381_221 = ManimColor("#507D3A")
+BRILLIANT_GREEN = ManimColor("#507D3A")
+BS381_222 = ManimColor("#6A7031")
+LIGHT_BRONZE_GREEN = ManimColor("#6A7031")
+BS381_223 = ManimColor("#49523A")
+MIDDLE_BRONZE_GREEN = ManimColor("#49523A")
+BS381_224 = ManimColor("#3E4630")
+DEEP_BRONZE_GREEN = ManimColor("#3E4630")
+BS381_225 = ManimColor("#406A28")
+LIGHT_BRUNSWICK_GREEN = ManimColor("#406A28")
+BS381_226 = ManimColor("#33533B")
+MID_BRUNSWICK_GREEN = ManimColor("#33533B")
+BS381_227 = ManimColor("#254432")
+DEEP_BRUNSWICK_GREEN = ManimColor("#254432")
+BS381_228 = ManimColor("#428B64")
+EMERALD_GREEN = ManimColor("#428B64")
+BS381_241 = ManimColor("#4F5241")
+DARK_GREEN = ManimColor("#4F5241")
+BS381_262 = ManimColor("#44945E")
+BOLD_GREEN = ManimColor("#44945E")
+BS381_267 = ManimColor("#476A4C")
+DEEP_CHROME_GREEN = ManimColor("#476A4C")
+TRAFFIC_GREEN = ManimColor("#476A4C")
+BS381_275 = ManimColor("#8FC693")
+OPALINE_GREEN = ManimColor("#8FC693")
+BS381_276 = ManimColor("#2E4C1E")
+LINCON_GREEN = ManimColor("#2E4C1E")
+BS381_277 = ManimColor("#364A20")
+CYPRESS_GREEN = ManimColor("#364A20")
+BS381_278 = ManimColor("#87965A")
+LIGHT_OLIVE_GREEN = ManimColor("#87965A")
+BS381_279 = ManimColor("#3B3629")
+STEEL_FURNITURE_GREEN = ManimColor("#3B3629")
+BS381_280 = ManimColor("#68AB77")
+VERDIGRIS_GREEN = ManimColor("#68AB77")
+BS381_282 = ManimColor("#506B52")
+FOREST_GREEN = ManimColor("#506B52")
+BS381_283 = ManimColor("#7E8F6E")
+AIRCRAFT_GREY_GREEN = ManimColor("#7E8F6E")
+BS381_284 = ManimColor("#6B6F5A")
+SPRUCE_GREEN = ManimColor("#6B6F5A")
+BS381_285 = ManimColor("#5F5C4B")
+NATO_GREEN = ManimColor("#5F5C4B")
+BS381_298 = ManimColor("#4F5138")
+OLIVE_DRAB = ManimColor("#4F5138")
+BS381_309 = ManimColor("#FEEC04")
+CANARY_YELLOW = ManimColor("#FEEC04")
+BS381_310 = ManimColor("#FEF963")
+PRIMROSE = ManimColor("#FEF963")
+BS381_315 = ManimColor("#FEF96A")
+GRAPEFRUIT = ManimColor("#FEF96A")
+BS381_320 = ManimColor("#9E7339")
+LIGHT_BROWN = ManimColor("#9E7339")
+BS381_337 = ManimColor("#4C4A3C")
+VERY_DARK_DRAB = ManimColor("#4C4A3C")
+BS381_350 = ManimColor("#7B6B4F")
+DARK_EARTH = ManimColor("#7B6B4F")
+BS381_352 = ManimColor("#FCED96")
+PALE_CREAM = ManimColor("#FCED96")
+BS381_353 = ManimColor("#FDF07A")
+DEEP_CREAM = ManimColor("#FDF07A")
+BS381_354 = ManimColor("#E9BB43")
+PRIMROSE_2 = ManimColor("#E9BB43")
+BS381_355 = ManimColor("#FDD906")
+LEMON = ManimColor("#FDD906")
+BS381_356 = ManimColor("#FCC808")
+GOLDEN_YELLOW = ManimColor("#FCC808")
+BS381_358 = ManimColor("#F6C870")
+LIGHT_BUFF = ManimColor("#F6C870")
+BS381_359 = ManimColor("#DBAC50")
+MIDDLE_BUFF = ManimColor("#DBAC50")
+BS381_361 = ManimColor("#D4B97D")
+LIGHT_STONE = ManimColor("#D4B97D")
+BS381_362 = ManimColor("#AC7C42")
+MIDDLE_STONE = ManimColor("#AC7C42")
+BS381_363 = ManimColor("#FDE706")
+BOLD_YELLOW = ManimColor("#FDE706")
+BS381_364 = ManimColor("#CEC093")
+PORTLAND_STONE = ManimColor("#CEC093")
+BS381_365 = ManimColor("#F4F0BD")
+VELLUM = ManimColor("#F4F0BD")
+BS381_366 = ManimColor("#F5E7A1")
+LIGHT_BEIGE = ManimColor("#F5E7A1")
+BS381_367 = ManimColor("#FEF6BF")
+MANILLA = ManimColor("#fef6bf")
+BS381_368 = ManimColor("#DD7B00")
+TRAFFIC_YELLOW = ManimColor("#DD7B00")
+BS381_369 = ManimColor("#FEEBA8")
+BISCUIT = ManimColor("#feeba8")
+BS381_380 = ManimColor("#BBA38A")
+CAMOUFLAGE_DESERT_SAND = ManimColor("#BBA38A")
+BS381_384 = ManimColor("#EEDFA5")
+LIGHT_STRAW = ManimColor("#EEDFA5")
+BS381_385 = ManimColor("#E8C88F")
+LIGHT_BISCUIT = ManimColor("#E8C88F")
+BS381_386 = ManimColor("#E6C18D")
+CHAMPAGNE = ManimColor("#e6c18d")
+BS381_387 = ManimColor("#CFB48A")
+SUNRISE = ManimColor("#cfb48a")
+SUNSHINE = ManimColor("#cfb48a")
+BS381_388 = ManimColor("#E4CF93")
+BEIGE = ManimColor("#e4cf93")
+BS381_389 = ManimColor("#B2A788")
+CAMOUFLAGE_BEIGE = ManimColor("#B2A788")
+BS381_397 = ManimColor("#F3D163")
+JASMINE_YELLOW = ManimColor("#F3D163")
+BS381_411 = ManimColor("#74542F")
+MIDDLE_BROWN = ManimColor("#74542F")
+BS381_412 = ManimColor("#5C422E")
+DARK_BROWN = ManimColor("#5C422E")
+BS381_413 = ManimColor("#402D21")
+NUT_BROWN = ManimColor("#402D21")
+BS381_414 = ManimColor("#A86C29")
+GOLDEN_BROWN = ManimColor("#A86C29")
+BS381_415 = ManimColor("#61361E")
+IMPERIAL_BROWN = ManimColor("#61361E")
+BS381_420 = ManimColor("#A89177")
+DARK_CAMOUFLAGE_DESERT_SAND = ManimColor("#A89177")
+BS381_435 = ManimColor("#845B4D")
+CAMOUFLAGE_RED = ManimColor("#845B4D")
+BS381_436 = ManimColor("#564B47")
+DARK_CAMOUFLAGE_BROWN = ManimColor("#564B47")
+BS381_439 = ManimColor("#753B1E")
+ORANGE_BROWN = ManimColor("#753B1E")
+BS381_443 = ManimColor("#C98A71")
+SALMON = ManimColor("#c98a71")
+BS381_444 = ManimColor("#A65341")
+TERRACOTTA = ManimColor("#a65341")
+BS381_445 = ManimColor("#83422B")
+VENETIAN_RED = ManimColor("#83422B")
+BS381_446 = ManimColor("#774430")
+RED_OXIDE = ManimColor("#774430")
+BS381_447 = ManimColor("#F3B28B")
+SALMON_PINK = ManimColor("#F3B28B")
+BS381_448 = ManimColor("#67403A")
+DEEP_INDIAN_RED = ManimColor("#67403A")
+BS381_449 = ManimColor("#693B3F")
+LIGHT_PURPLE_BROWN = ManimColor("#693B3F")
+BS381_452 = ManimColor("#613339")
+DARK_CRIMSON = ManimColor("#613339")
+BS381_453 = ManimColor("#FBDED6")
+SHELL_PINK = ManimColor("#FBDED6")
+BS381_454 = ManimColor("#E8A1A2")
+PALE_ROUNDEL_RED = ManimColor("#E8A1A2")
+BS381_460 = ManimColor("#BD8F56")
+DEEP_BUFF = ManimColor("#BD8F56")
+BS381_473 = ManimColor("#793932")
+GULF_RED = ManimColor("#793932")
+BS381_489 = ManimColor("#8D5B41")
+LEAF_BROWN = ManimColor("#8D5B41")
+BS381_490 = ManimColor("#573320")
+BEECH_BROWN = ManimColor("#573320")
+BS381_499 = ManimColor("#59493E")
+SERVICE_BROWN = ManimColor("#59493E")
+BS381_536 = ManimColor("#BB3016")
+POPPY = ManimColor("#bb3016")
+BS381_537 = ManimColor("#DD3420")
+SIGNAL_RED = ManimColor("#DD3420")
+BS381_538 = ManimColor("#C41C22")
+POST_OFFICE_RED = ManimColor("#C41C22")
+CHERRY = ManimColor("#c41c22")
+BS381_539 = ManimColor("#D21E2B")
+CURRANT_RED = ManimColor("#D21E2B")
+BS381_540 = ManimColor("#8B1A32")
+CRIMSON = ManimColor("#8b1a32")
+BS381_541 = ManimColor("#471B21")
+MAROON = ManimColor("#471b21")
+BS381_542 = ManimColor("#982D57")
+RUBY = ManimColor("#982d57")
+BS381_557 = ManimColor("#EF841E")
+LIGHT_ORANGE = ManimColor("#EF841E")
+BS381_564 = ManimColor("#DD3524")
+BOLD_RED = ManimColor("#DD3524")
+BS381_568 = ManimColor("#FB9C06")
+APRICOT = ManimColor("#fb9c06")
+BS381_570 = ManimColor("#A83C19")
+TRAFFIC_RED = ManimColor("#A83C19")
+BS381_591 = ManimColor("#D04E09")
+DEEP_ORANGE = ManimColor("#D04E09")
+BS381_592 = ManimColor("#E45523")
+INTERNATIONAL_ORANGE = ManimColor("#E45523")
+BS381_593 = ManimColor("#F24816")
+RAIL_RED = ManimColor("#F24816")
+AZO_ORANGE = ManimColor("#F24816")
+BS381_626 = ManimColor("#A0A9AA")
+CAMOUFLAGE_GREY = ManimColor("#A0A9AA")
+BS381_627 = ManimColor("#BEC0B8")
+LIGHT_AIRCRAFT_GREY = ManimColor("#BEC0B8")
+BS381_628 = ManimColor("#9D9D7E")
+SILVER_GREY = ManimColor("#9D9D7E")
+BS381_629 = ManimColor("#7A838B")
+DARK_CAMOUFLAGE_GREY = ManimColor("#7A838B")
+BS381_630 = ManimColor("#A5AD98")
+FRENCH_GREY = ManimColor("#A5AD98")
+BS381_631 = ManimColor("#9AAA9F")
+LIGHT_GREY = ManimColor("#9AAA9F")
+BS381_632 = ManimColor("#6B7477")
+DARK_ADMIRALTY_GREY = ManimColor("#6B7477")
+BS381_633 = ManimColor("#424C53")
+RAF_BLUE_GREY = ManimColor("#424C53")
+BS381_634 = ManimColor("#6F7264")
+SLATE = ManimColor("#6f7264")
+BS381_635 = ManimColor("#525B55")
+LEAD = ManimColor("#525b55")
+BS381_636 = ManimColor("#5F7682")
+PRU_BLUE = ManimColor("#5F7682")
+BS381_637 = ManimColor("#8E9B9C")
+MEDIUM_SEA_GREY = ManimColor("#8E9B9C")
+BS381_638 = ManimColor("#6C7377")
+DARK_SEA_GREY = ManimColor("#6C7377")
+BS381_639 = ManimColor("#667563")
+LIGHT_SLATE_GREY = ManimColor("#667563")
+BS381_640 = ManimColor("#566164")
+EXTRA_DARK_SEA_GREY = ManimColor("#566164")
+BS381_642 = ManimColor("#282B2F")
+NIGHT = ManimColor("#282b2f")
+BS381_671 = ManimColor("#4E5355")
+MIDDLE_GRAPHITE = ManimColor("#4E5355")
+BS381_676 = ManimColor("#A9B7B9")
+LIGHT_WEATHERWORK_GREY = ManimColor("#A9B7B9")
+BS381_677 = ManimColor("#676F76")
+DARK_WEATHERWORK_GREY = ManimColor("#676F76")
+BS381_692 = ManimColor("#7B93A3")
+SMOKE_GREY = ManimColor("#7B93A3")
+BS381_693 = ManimColor("#88918D")
+AIRCRAFT_GREY = ManimColor("#88918D")
+BS381_694 = ManimColor("#909A92")
+DOVE_GREY = ManimColor("#909A92")
+BS381_697 = ManimColor("#B6D3CC")
+LIGHT_ADMIRALTY_GREY = ManimColor("#B6D3CC")
+BS381_796 = ManimColor("#6E4A75")
+DARK_VIOLET = ManimColor("#6E4A75")
+BS381_797 = ManimColor("#C9A8CE")
+LIGHT_VIOLET = ManimColor("#C9A8CE")
diff --git a/data/rag/manim_docs/manim_core/source/utils/color/X11.py b/data/rag/manim_docs/manim_core/source/utils/color/X11.py
new file mode 100644
index 0000000000000000000000000000000000000000..06d7c7575ff66819f534cabec686998e526696c3
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/color/X11.py
@@ -0,0 +1,530 @@
+# from https://www.w3schools.com/colors/colors_x11.asp
+
+"""X11 Colors
+
+These color and their names (taken from
+https://www.w3schools.com/colors/colors_x11.asp) were developed at the
+Massachusetts Intitute of Technology (MIT) during
+the development of color based computer display system.
+
+To use the colors from this list, access them directly from the module (which
+is exposed to Manim's global name space):
+
+.. code:: pycon
+
+ >>> from manim import X11
+ >>> X11.BEIGE
+ ManimColor('#F5F5DC')
+
+
+List of Color Constants
+-----------------------
+
+.. automanimcolormodule:: manim.utils.color.X11
+"""
+from .core import ManimColor
+
+ALICEBLUE = ManimColor("#F0F8FF")
+ANTIQUEWHITE = ManimColor("#FAEBD7")
+ANTIQUEWHITE1 = ManimColor("#FFEFDB")
+ANTIQUEWHITE2 = ManimColor("#EEDFCC")
+ANTIQUEWHITE3 = ManimColor("#CDC0B0")
+ANTIQUEWHITE4 = ManimColor("#8B8378")
+AQUAMARINE1 = ManimColor("#7FFFD4")
+AQUAMARINE2 = ManimColor("#76EEC6")
+AQUAMARINE4 = ManimColor("#458B74")
+AZURE1 = ManimColor("#F0FFFF")
+AZURE2 = ManimColor("#E0EEEE")
+AZURE3 = ManimColor("#C1CDCD")
+AZURE4 = ManimColor("#838B8B")
+BEIGE = ManimColor("#F5F5DC")
+BISQUE1 = ManimColor("#FFE4C4")
+BISQUE2 = ManimColor("#EED5B7")
+BISQUE3 = ManimColor("#CDB79E")
+BISQUE4 = ManimColor("#8B7D6B")
+BLACK = ManimColor("#000000")
+BLANCHEDALMOND = ManimColor("#FFEBCD")
+BLUE1 = ManimColor("#0000FF")
+BLUE2 = ManimColor("#0000EE")
+BLUE4 = ManimColor("#00008B")
+BLUEVIOLET = ManimColor("#8A2BE2")
+BROWN = ManimColor("#A52A2A")
+BROWN1 = ManimColor("#FF4040")
+BROWN2 = ManimColor("#EE3B3B")
+BROWN3 = ManimColor("#CD3333")
+BROWN4 = ManimColor("#8B2323")
+BURLYWOOD = ManimColor("#DEB887")
+BURLYWOOD1 = ManimColor("#FFD39B")
+BURLYWOOD2 = ManimColor("#EEC591")
+BURLYWOOD3 = ManimColor("#CDAA7D")
+BURLYWOOD4 = ManimColor("#8B7355")
+CADETBLUE = ManimColor("#5F9EA0")
+CADETBLUE1 = ManimColor("#98F5FF")
+CADETBLUE2 = ManimColor("#8EE5EE")
+CADETBLUE3 = ManimColor("#7AC5CD")
+CADETBLUE4 = ManimColor("#53868B")
+CHARTREUSE1 = ManimColor("#7FFF00")
+CHARTREUSE2 = ManimColor("#76EE00")
+CHARTREUSE3 = ManimColor("#66CD00")
+CHARTREUSE4 = ManimColor("#458B00")
+CHOCOLATE = ManimColor("#D2691E")
+CHOCOLATE1 = ManimColor("#FF7F24")
+CHOCOLATE2 = ManimColor("#EE7621")
+CHOCOLATE3 = ManimColor("#CD661D")
+CORAL = ManimColor("#FF7F50")
+CORAL1 = ManimColor("#FF7256")
+CORAL2 = ManimColor("#EE6A50")
+CORAL3 = ManimColor("#CD5B45")
+CORAL4 = ManimColor("#8B3E2F")
+CORNFLOWERBLUE = ManimColor("#6495ED")
+CORNSILK1 = ManimColor("#FFF8DC")
+CORNSILK2 = ManimColor("#EEE8CD")
+CORNSILK3 = ManimColor("#CDC8B1")
+CORNSILK4 = ManimColor("#8B8878")
+CYAN1 = ManimColor("#00FFFF")
+CYAN2 = ManimColor("#00EEEE")
+CYAN3 = ManimColor("#00CDCD")
+CYAN4 = ManimColor("#008B8B")
+DARKGOLDENROD = ManimColor("#B8860B")
+DARKGOLDENROD1 = ManimColor("#FFB90F")
+DARKGOLDENROD2 = ManimColor("#EEAD0E")
+DARKGOLDENROD3 = ManimColor("#CD950C")
+DARKGOLDENROD4 = ManimColor("#8B6508")
+DARKGREEN = ManimColor("#006400")
+DARKKHAKI = ManimColor("#BDB76B")
+DARKOLIVEGREEN = ManimColor("#556B2F")
+DARKOLIVEGREEN1 = ManimColor("#CAFF70")
+DARKOLIVEGREEN2 = ManimColor("#BCEE68")
+DARKOLIVEGREEN3 = ManimColor("#A2CD5A")
+DARKOLIVEGREEN4 = ManimColor("#6E8B3D")
+DARKORANGE = ManimColor("#FF8C00")
+DARKORANGE1 = ManimColor("#FF7F00")
+DARKORANGE2 = ManimColor("#EE7600")
+DARKORANGE3 = ManimColor("#CD6600")
+DARKORANGE4 = ManimColor("#8B4500")
+DARKORCHID = ManimColor("#9932CC")
+DARKORCHID1 = ManimColor("#BF3EFF")
+DARKORCHID2 = ManimColor("#B23AEE")
+DARKORCHID3 = ManimColor("#9A32CD")
+DARKORCHID4 = ManimColor("#68228B")
+DARKSALMON = ManimColor("#E9967A")
+DARKSEAGREEN = ManimColor("#8FBC8F")
+DARKSEAGREEN1 = ManimColor("#C1FFC1")
+DARKSEAGREEN2 = ManimColor("#B4EEB4")
+DARKSEAGREEN3 = ManimColor("#9BCD9B")
+DARKSEAGREEN4 = ManimColor("#698B69")
+DARKSLATEBLUE = ManimColor("#483D8B")
+DARKSLATEGRAY = ManimColor("#2F4F4F")
+DARKSLATEGRAY1 = ManimColor("#97FFFF")
+DARKSLATEGRAY2 = ManimColor("#8DEEEE")
+DARKSLATEGRAY3 = ManimColor("#79CDCD")
+DARKSLATEGRAY4 = ManimColor("#528B8B")
+DARKTURQUOISE = ManimColor("#00CED1")
+DARKVIOLET = ManimColor("#9400D3")
+DEEPPINK1 = ManimColor("#FF1493")
+DEEPPINK2 = ManimColor("#EE1289")
+DEEPPINK3 = ManimColor("#CD1076")
+DEEPPINK4 = ManimColor("#8B0A50")
+DEEPSKYBLUE1 = ManimColor("#00BFFF")
+DEEPSKYBLUE2 = ManimColor("#00B2EE")
+DEEPSKYBLUE3 = ManimColor("#009ACD")
+DEEPSKYBLUE4 = ManimColor("#00688B")
+DIMGRAY = ManimColor("#696969")
+DODGERBLUE1 = ManimColor("#1E90FF")
+DODGERBLUE2 = ManimColor("#1C86EE")
+DODGERBLUE3 = ManimColor("#1874CD")
+DODGERBLUE4 = ManimColor("#104E8B")
+FIREBRICK = ManimColor("#B22222")
+FIREBRICK1 = ManimColor("#FF3030")
+FIREBRICK2 = ManimColor("#EE2C2C")
+FIREBRICK3 = ManimColor("#CD2626")
+FIREBRICK4 = ManimColor("#8B1A1A")
+FLORALWHITE = ManimColor("#FFFAF0")
+FORESTGREEN = ManimColor("#228B22")
+GAINSBORO = ManimColor("#DCDCDC")
+GHOSTWHITE = ManimColor("#F8F8FF")
+GOLD1 = ManimColor("#FFD700")
+GOLD2 = ManimColor("#EEC900")
+GOLD3 = ManimColor("#CDAD00")
+GOLD4 = ManimColor("#8B7500")
+GOLDENROD = ManimColor("#DAA520")
+GOLDENROD1 = ManimColor("#FFC125")
+GOLDENROD2 = ManimColor("#EEB422")
+GOLDENROD3 = ManimColor("#CD9B1D")
+GOLDENROD4 = ManimColor("#8B6914")
+GRAY = ManimColor("#BEBEBE")
+GRAY1 = ManimColor("#030303")
+GRAY2 = ManimColor("#050505")
+GRAY3 = ManimColor("#080808")
+GRAY4 = ManimColor("#0A0A0A")
+GRAY5 = ManimColor("#0D0D0D")
+GRAY6 = ManimColor("#0F0F0F")
+GRAY7 = ManimColor("#121212")
+GRAY8 = ManimColor("#141414")
+GRAY9 = ManimColor("#171717")
+GRAY10 = ManimColor("#1A1A1A")
+GRAY11 = ManimColor("#1C1C1C")
+GRAY12 = ManimColor("#1F1F1F")
+GRAY13 = ManimColor("#212121")
+GRAY14 = ManimColor("#242424")
+GRAY15 = ManimColor("#262626")
+GRAY16 = ManimColor("#292929")
+GRAY17 = ManimColor("#2B2B2B")
+GRAY18 = ManimColor("#2E2E2E")
+GRAY19 = ManimColor("#303030")
+GRAY20 = ManimColor("#333333")
+GRAY21 = ManimColor("#363636")
+GRAY22 = ManimColor("#383838")
+GRAY23 = ManimColor("#3B3B3B")
+GRAY24 = ManimColor("#3D3D3D")
+GRAY25 = ManimColor("#404040")
+GRAY26 = ManimColor("#424242")
+GRAY27 = ManimColor("#454545")
+GRAY28 = ManimColor("#474747")
+GRAY29 = ManimColor("#4A4A4A")
+GRAY30 = ManimColor("#4D4D4D")
+GRAY31 = ManimColor("#4F4F4F")
+GRAY32 = ManimColor("#525252")
+GRAY33 = ManimColor("#545454")
+GRAY34 = ManimColor("#575757")
+GRAY35 = ManimColor("#595959")
+GRAY36 = ManimColor("#5C5C5C")
+GRAY37 = ManimColor("#5E5E5E")
+GRAY38 = ManimColor("#616161")
+GRAY39 = ManimColor("#636363")
+GRAY40 = ManimColor("#666666")
+GRAY41 = ManimColor("#696969")
+GRAY42 = ManimColor("#6B6B6B")
+GRAY43 = ManimColor("#6E6E6E")
+GRAY44 = ManimColor("#707070")
+GRAY45 = ManimColor("#737373")
+GRAY46 = ManimColor("#757575")
+GRAY47 = ManimColor("#787878")
+GRAY48 = ManimColor("#7A7A7A")
+GRAY49 = ManimColor("#7D7D7D")
+GRAY50 = ManimColor("#7F7F7F")
+GRAY51 = ManimColor("#828282")
+GRAY52 = ManimColor("#858585")
+GRAY53 = ManimColor("#878787")
+GRAY54 = ManimColor("#8A8A8A")
+GRAY55 = ManimColor("#8C8C8C")
+GRAY56 = ManimColor("#8F8F8F")
+GRAY57 = ManimColor("#919191")
+GRAY58 = ManimColor("#949494")
+GRAY59 = ManimColor("#969696")
+GRAY60 = ManimColor("#999999")
+GRAY61 = ManimColor("#9C9C9C")
+GRAY62 = ManimColor("#9E9E9E")
+GRAY63 = ManimColor("#A1A1A1")
+GRAY64 = ManimColor("#A3A3A3")
+GRAY65 = ManimColor("#A6A6A6")
+GRAY66 = ManimColor("#A8A8A8")
+GRAY67 = ManimColor("#ABABAB")
+GRAY68 = ManimColor("#ADADAD")
+GRAY69 = ManimColor("#B0B0B0")
+GRAY70 = ManimColor("#B3B3B3")
+GRAY71 = ManimColor("#B5B5B5")
+GRAY72 = ManimColor("#B8B8B8")
+GRAY73 = ManimColor("#BABABA")
+GRAY74 = ManimColor("#BDBDBD")
+GRAY75 = ManimColor("#BFBFBF")
+GRAY76 = ManimColor("#C2C2C2")
+GRAY77 = ManimColor("#C4C4C4")
+GRAY78 = ManimColor("#C7C7C7")
+GRAY79 = ManimColor("#C9C9C9")
+GRAY80 = ManimColor("#CCCCCC")
+GRAY81 = ManimColor("#CFCFCF")
+GRAY82 = ManimColor("#D1D1D1")
+GRAY83 = ManimColor("#D4D4D4")
+GRAY84 = ManimColor("#D6D6D6")
+GRAY85 = ManimColor("#D9D9D9")
+GRAY86 = ManimColor("#DBDBDB")
+GRAY87 = ManimColor("#DEDEDE")
+GRAY88 = ManimColor("#E0E0E0")
+GRAY89 = ManimColor("#E3E3E3")
+GRAY90 = ManimColor("#E5E5E5")
+GRAY91 = ManimColor("#E8E8E8")
+GRAY92 = ManimColor("#EBEBEB")
+GRAY93 = ManimColor("#EDEDED")
+GRAY94 = ManimColor("#F0F0F0")
+GRAY95 = ManimColor("#F2F2F2")
+GRAY97 = ManimColor("#F7F7F7")
+GRAY98 = ManimColor("#FAFAFA")
+GRAY99 = ManimColor("#FCFCFC")
+GREEN1 = ManimColor("#00FF00")
+GREEN2 = ManimColor("#00EE00")
+GREEN3 = ManimColor("#00CD00")
+GREEN4 = ManimColor("#008B00")
+GREENYELLOW = ManimColor("#ADFF2F")
+HONEYDEW1 = ManimColor("#F0FFF0")
+HONEYDEW2 = ManimColor("#E0EEE0")
+HONEYDEW3 = ManimColor("#C1CDC1")
+HONEYDEW4 = ManimColor("#838B83")
+HOTPINK = ManimColor("#FF69B4")
+HOTPINK1 = ManimColor("#FF6EB4")
+HOTPINK2 = ManimColor("#EE6AA7")
+HOTPINK3 = ManimColor("#CD6090")
+HOTPINK4 = ManimColor("#8B3A62")
+INDIANRED = ManimColor("#CD5C5C")
+INDIANRED1 = ManimColor("#FF6A6A")
+INDIANRED2 = ManimColor("#EE6363")
+INDIANRED3 = ManimColor("#CD5555")
+INDIANRED4 = ManimColor("#8B3A3A")
+IVORY1 = ManimColor("#FFFFF0")
+IVORY2 = ManimColor("#EEEEE0")
+IVORY3 = ManimColor("#CDCDC1")
+IVORY4 = ManimColor("#8B8B83")
+KHAKI = ManimColor("#F0E68C")
+KHAKI1 = ManimColor("#FFF68F")
+KHAKI2 = ManimColor("#EEE685")
+KHAKI3 = ManimColor("#CDC673")
+KHAKI4 = ManimColor("#8B864E")
+LAVENDER = ManimColor("#E6E6FA")
+LAVENDERBLUSH1 = ManimColor("#FFF0F5")
+LAVENDERBLUSH2 = ManimColor("#EEE0E5")
+LAVENDERBLUSH3 = ManimColor("#CDC1C5")
+LAVENDERBLUSH4 = ManimColor("#8B8386")
+LAWNGREEN = ManimColor("#7CFC00")
+LEMONCHIFFON1 = ManimColor("#FFFACD")
+LEMONCHIFFON2 = ManimColor("#EEE9BF")
+LEMONCHIFFON3 = ManimColor("#CDC9A5")
+LEMONCHIFFON4 = ManimColor("#8B8970")
+LIGHT = ManimColor("#EEDD82")
+LIGHTBLUE = ManimColor("#ADD8E6")
+LIGHTBLUE1 = ManimColor("#BFEFFF")
+LIGHTBLUE2 = ManimColor("#B2DFEE")
+LIGHTBLUE3 = ManimColor("#9AC0CD")
+LIGHTBLUE4 = ManimColor("#68838B")
+LIGHTCORAL = ManimColor("#F08080")
+LIGHTCYAN1 = ManimColor("#E0FFFF")
+LIGHTCYAN2 = ManimColor("#D1EEEE")
+LIGHTCYAN3 = ManimColor("#B4CDCD")
+LIGHTCYAN4 = ManimColor("#7A8B8B")
+LIGHTGOLDENROD1 = ManimColor("#FFEC8B")
+LIGHTGOLDENROD2 = ManimColor("#EEDC82")
+LIGHTGOLDENROD3 = ManimColor("#CDBE70")
+LIGHTGOLDENROD4 = ManimColor("#8B814C")
+LIGHTGOLDENRODYELLOW = ManimColor("#FAFAD2")
+LIGHTGRAY = ManimColor("#D3D3D3")
+LIGHTPINK = ManimColor("#FFB6C1")
+LIGHTPINK1 = ManimColor("#FFAEB9")
+LIGHTPINK2 = ManimColor("#EEA2AD")
+LIGHTPINK3 = ManimColor("#CD8C95")
+LIGHTPINK4 = ManimColor("#8B5F65")
+LIGHTSALMON1 = ManimColor("#FFA07A")
+LIGHTSALMON2 = ManimColor("#EE9572")
+LIGHTSALMON3 = ManimColor("#CD8162")
+LIGHTSALMON4 = ManimColor("#8B5742")
+LIGHTSEAGREEN = ManimColor("#20B2AA")
+LIGHTSKYBLUE = ManimColor("#87CEFA")
+LIGHTSKYBLUE1 = ManimColor("#B0E2FF")
+LIGHTSKYBLUE2 = ManimColor("#A4D3EE")
+LIGHTSKYBLUE3 = ManimColor("#8DB6CD")
+LIGHTSKYBLUE4 = ManimColor("#607B8B")
+LIGHTSLATEBLUE = ManimColor("#8470FF")
+LIGHTSLATEGRAY = ManimColor("#778899")
+LIGHTSTEELBLUE = ManimColor("#B0C4DE")
+LIGHTSTEELBLUE1 = ManimColor("#CAE1FF")
+LIGHTSTEELBLUE2 = ManimColor("#BCD2EE")
+LIGHTSTEELBLUE3 = ManimColor("#A2B5CD")
+LIGHTSTEELBLUE4 = ManimColor("#6E7B8B")
+LIGHTYELLOW1 = ManimColor("#FFFFE0")
+LIGHTYELLOW2 = ManimColor("#EEEED1")
+LIGHTYELLOW3 = ManimColor("#CDCDB4")
+LIGHTYELLOW4 = ManimColor("#8B8B7A")
+LIMEGREEN = ManimColor("#32CD32")
+LINEN = ManimColor("#FAF0E6")
+MAGENTA = ManimColor("#FF00FF")
+MAGENTA2 = ManimColor("#EE00EE")
+MAGENTA3 = ManimColor("#CD00CD")
+MAGENTA4 = ManimColor("#8B008B")
+MAROON = ManimColor("#B03060")
+MAROON1 = ManimColor("#FF34B3")
+MAROON2 = ManimColor("#EE30A7")
+MAROON3 = ManimColor("#CD2990")
+MAROON4 = ManimColor("#8B1C62")
+MEDIUM = ManimColor("#66CDAA")
+MEDIUMAQUAMARINE = ManimColor("#66CDAA")
+MEDIUMBLUE = ManimColor("#0000CD")
+MEDIUMORCHID = ManimColor("#BA55D3")
+MEDIUMORCHID1 = ManimColor("#E066FF")
+MEDIUMORCHID2 = ManimColor("#D15FEE")
+MEDIUMORCHID3 = ManimColor("#B452CD")
+MEDIUMORCHID4 = ManimColor("#7A378B")
+MEDIUMPURPLE = ManimColor("#9370DB")
+MEDIUMPURPLE1 = ManimColor("#AB82FF")
+MEDIUMPURPLE2 = ManimColor("#9F79EE")
+MEDIUMPURPLE3 = ManimColor("#8968CD")
+MEDIUMPURPLE4 = ManimColor("#5D478B")
+MEDIUMSEAGREEN = ManimColor("#3CB371")
+MEDIUMSLATEBLUE = ManimColor("#7B68EE")
+MEDIUMSPRINGGREEN = ManimColor("#00FA9A")
+MEDIUMTURQUOISE = ManimColor("#48D1CC")
+MEDIUMVIOLETRED = ManimColor("#C71585")
+MIDNIGHTBLUE = ManimColor("#191970")
+MINTCREAM = ManimColor("#F5FFFA")
+MISTYROSE1 = ManimColor("#FFE4E1")
+MISTYROSE2 = ManimColor("#EED5D2")
+MISTYROSE3 = ManimColor("#CDB7B5")
+MISTYROSE4 = ManimColor("#8B7D7B")
+MOCCASIN = ManimColor("#FFE4B5")
+NAVAJOWHITE1 = ManimColor("#FFDEAD")
+NAVAJOWHITE2 = ManimColor("#EECFA1")
+NAVAJOWHITE3 = ManimColor("#CDB38B")
+NAVAJOWHITE4 = ManimColor("#8B795E")
+NAVYBLUE = ManimColor("#000080")
+OLDLACE = ManimColor("#FDF5E6")
+OLIVEDRAB = ManimColor("#6B8E23")
+OLIVEDRAB1 = ManimColor("#C0FF3E")
+OLIVEDRAB2 = ManimColor("#B3EE3A")
+OLIVEDRAB4 = ManimColor("#698B22")
+ORANGE1 = ManimColor("#FFA500")
+ORANGE2 = ManimColor("#EE9A00")
+ORANGE3 = ManimColor("#CD8500")
+ORANGE4 = ManimColor("#8B5A00")
+ORANGERED1 = ManimColor("#FF4500")
+ORANGERED2 = ManimColor("#EE4000")
+ORANGERED3 = ManimColor("#CD3700")
+ORANGERED4 = ManimColor("#8B2500")
+ORCHID = ManimColor("#DA70D6")
+ORCHID1 = ManimColor("#FF83FA")
+ORCHID2 = ManimColor("#EE7AE9")
+ORCHID3 = ManimColor("#CD69C9")
+ORCHID4 = ManimColor("#8B4789")
+PALE = ManimColor("#DB7093")
+PALEGOLDENROD = ManimColor("#EEE8AA")
+PALEGREEN = ManimColor("#98FB98")
+PALEGREEN1 = ManimColor("#9AFF9A")
+PALEGREEN2 = ManimColor("#90EE90")
+PALEGREEN3 = ManimColor("#7CCD7C")
+PALEGREEN4 = ManimColor("#548B54")
+PALETURQUOISE = ManimColor("#AFEEEE")
+PALETURQUOISE1 = ManimColor("#BBFFFF")
+PALETURQUOISE2 = ManimColor("#AEEEEE")
+PALETURQUOISE3 = ManimColor("#96CDCD")
+PALETURQUOISE4 = ManimColor("#668B8B")
+PALEVIOLETRED = ManimColor("#DB7093")
+PALEVIOLETRED1 = ManimColor("#FF82AB")
+PALEVIOLETRED2 = ManimColor("#EE799F")
+PALEVIOLETRED3 = ManimColor("#CD6889")
+PALEVIOLETRED4 = ManimColor("#8B475D")
+PAPAYAWHIP = ManimColor("#FFEFD5")
+PEACHPUFF1 = ManimColor("#FFDAB9")
+PEACHPUFF2 = ManimColor("#EECBAD")
+PEACHPUFF3 = ManimColor("#CDAF95")
+PEACHPUFF4 = ManimColor("#8B7765")
+PINK = ManimColor("#FFC0CB")
+PINK1 = ManimColor("#FFB5C5")
+PINK2 = ManimColor("#EEA9B8")
+PINK3 = ManimColor("#CD919E")
+PINK4 = ManimColor("#8B636C")
+PLUM = ManimColor("#DDA0DD")
+PLUM1 = ManimColor("#FFBBFF")
+PLUM2 = ManimColor("#EEAEEE")
+PLUM3 = ManimColor("#CD96CD")
+PLUM4 = ManimColor("#8B668B")
+POWDERBLUE = ManimColor("#B0E0E6")
+PURPLE = ManimColor("#A020F0")
+PURPLE1 = ManimColor("#9B30FF")
+PURPLE2 = ManimColor("#912CEE")
+PURPLE3 = ManimColor("#7D26CD")
+PURPLE4 = ManimColor("#551A8B")
+RED1 = ManimColor("#FF0000")
+RED2 = ManimColor("#EE0000")
+RED3 = ManimColor("#CD0000")
+RED4 = ManimColor("#8B0000")
+ROSYBROWN = ManimColor("#BC8F8F")
+ROSYBROWN1 = ManimColor("#FFC1C1")
+ROSYBROWN2 = ManimColor("#EEB4B4")
+ROSYBROWN3 = ManimColor("#CD9B9B")
+ROSYBROWN4 = ManimColor("#8B6969")
+ROYALBLUE = ManimColor("#4169E1")
+ROYALBLUE1 = ManimColor("#4876FF")
+ROYALBLUE2 = ManimColor("#436EEE")
+ROYALBLUE3 = ManimColor("#3A5FCD")
+ROYALBLUE4 = ManimColor("#27408B")
+SADDLEBROWN = ManimColor("#8B4513")
+SALMON = ManimColor("#FA8072")
+SALMON1 = ManimColor("#FF8C69")
+SALMON2 = ManimColor("#EE8262")
+SALMON3 = ManimColor("#CD7054")
+SALMON4 = ManimColor("#8B4C39")
+SANDYBROWN = ManimColor("#F4A460")
+SEAGREEN1 = ManimColor("#54FF9F")
+SEAGREEN2 = ManimColor("#4EEE94")
+SEAGREEN3 = ManimColor("#43CD80")
+SEAGREEN4 = ManimColor("#2E8B57")
+SEASHELL1 = ManimColor("#FFF5EE")
+SEASHELL2 = ManimColor("#EEE5DE")
+SEASHELL3 = ManimColor("#CDC5BF")
+SEASHELL4 = ManimColor("#8B8682")
+SIENNA = ManimColor("#A0522D")
+SIENNA1 = ManimColor("#FF8247")
+SIENNA2 = ManimColor("#EE7942")
+SIENNA3 = ManimColor("#CD6839")
+SIENNA4 = ManimColor("#8B4726")
+SKYBLUE = ManimColor("#87CEEB")
+SKYBLUE1 = ManimColor("#87CEFF")
+SKYBLUE2 = ManimColor("#7EC0EE")
+SKYBLUE3 = ManimColor("#6CA6CD")
+SKYBLUE4 = ManimColor("#4A708B")
+SLATEBLUE = ManimColor("#6A5ACD")
+SLATEBLUE1 = ManimColor("#836FFF")
+SLATEBLUE2 = ManimColor("#7A67EE")
+SLATEBLUE3 = ManimColor("#6959CD")
+SLATEBLUE4 = ManimColor("#473C8B")
+SLATEGRAY = ManimColor("#708090")
+SLATEGRAY1 = ManimColor("#C6E2FF")
+SLATEGRAY2 = ManimColor("#B9D3EE")
+SLATEGRAY3 = ManimColor("#9FB6CD")
+SLATEGRAY4 = ManimColor("#6C7B8B")
+SNOW1 = ManimColor("#FFFAFA")
+SNOW2 = ManimColor("#EEE9E9")
+SNOW3 = ManimColor("#CDC9C9")
+SNOW4 = ManimColor("#8B8989")
+SPRINGGREEN1 = ManimColor("#00FF7F")
+SPRINGGREEN2 = ManimColor("#00EE76")
+SPRINGGREEN3 = ManimColor("#00CD66")
+SPRINGGREEN4 = ManimColor("#008B45")
+STEELBLUE = ManimColor("#4682B4")
+STEELBLUE1 = ManimColor("#63B8FF")
+STEELBLUE2 = ManimColor("#5CACEE")
+STEELBLUE3 = ManimColor("#4F94CD")
+STEELBLUE4 = ManimColor("#36648B")
+TAN = ManimColor("#D2B48C")
+TAN1 = ManimColor("#FFA54F")
+TAN2 = ManimColor("#EE9A49")
+TAN3 = ManimColor("#CD853F")
+TAN4 = ManimColor("#8B5A2B")
+THISTLE = ManimColor("#D8BFD8")
+THISTLE1 = ManimColor("#FFE1FF")
+THISTLE2 = ManimColor("#EED2EE")
+THISTLE3 = ManimColor("#CDB5CD")
+THISTLE4 = ManimColor("#8B7B8B")
+TOMATO1 = ManimColor("#FF6347")
+TOMATO2 = ManimColor("#EE5C42")
+TOMATO3 = ManimColor("#CD4F39")
+TOMATO4 = ManimColor("#8B3626")
+TURQUOISE = ManimColor("#40E0D0")
+TURQUOISE1 = ManimColor("#00F5FF")
+TURQUOISE2 = ManimColor("#00E5EE")
+TURQUOISE3 = ManimColor("#00C5CD")
+TURQUOISE4 = ManimColor("#00868B")
+VIOLET = ManimColor("#EE82EE")
+VIOLETRED = ManimColor("#D02090")
+VIOLETRED1 = ManimColor("#FF3E96")
+VIOLETRED2 = ManimColor("#EE3A8C")
+VIOLETRED3 = ManimColor("#CD3278")
+VIOLETRED4 = ManimColor("#8B2252")
+WHEAT = ManimColor("#F5DEB3")
+WHEAT1 = ManimColor("#FFE7BA")
+WHEAT2 = ManimColor("#EED8AE")
+WHEAT3 = ManimColor("#CDBA96")
+WHEAT4 = ManimColor("#8B7E66")
+WHITE = ManimColor("#FFFFFF")
+WHITESMOKE = ManimColor("#F5F5F5")
+YELLOW1 = ManimColor("#FFFF00")
+YELLOW2 = ManimColor("#EEEE00")
+YELLOW3 = ManimColor("#CDCD00")
+YELLOW4 = ManimColor("#8B8B00")
+YELLOWGREEN = ManimColor("#9ACD32")
diff --git a/data/rag/manim_docs/manim_core/source/utils/color/XKCD.py b/data/rag/manim_docs/manim_core/source/utils/color/XKCD.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8ee93bac5318a56ce9836a449f9ba81cb14dc72
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/color/XKCD.py
@@ -0,0 +1,949 @@
+"""Colors from the XKCD Color Name Survey
+
+XKCD is a popular `web comic `__ created by Randall Munroe.
+His "`Color Name Survey `__" (with
+200000 participants) resulted in a list of nearly 1000 color names.
+
+While the ``XKCD`` module is exposed to Manim's global name space, the colors included
+in it are not. This means that in order to use the colors, access them via the module name:
+
+.. code:: pycon
+
+ >>> from manim import XKCD
+ >>> XKCD.MANGO
+ ManimColor('#FFA62B')
+
+
+List of Color Constants
+-----------------------
+
+These hex values are non official approximate values intended to simulate the colors in HTML,
+taken from https://www.w3schools.com/colors/colors_xkcd.asp.
+
+.. automanimcolormodule:: manim.utils.color.XKCD
+
+"""
+from .core import ManimColor
+
+ACIDGREEN = ManimColor("#8FFE09")
+ADOBE = ManimColor("#BD6C48")
+ALGAE = ManimColor("#54AC68")
+ALGAEGREEN = ManimColor("#21C36F")
+ALMOSTBLACK = ManimColor("#070D0D")
+AMBER = ManimColor("#FEB308")
+AMETHYST = ManimColor("#9B5FC0")
+APPLE = ManimColor("#6ECB3C")
+APPLEGREEN = ManimColor("#76CD26")
+APRICOT = ManimColor("#FFB16D")
+AQUA = ManimColor("#13EAC9")
+AQUABLUE = ManimColor("#02D8E9")
+AQUAGREEN = ManimColor("#12E193")
+AQUAMARINE = ManimColor("#2EE8BB")
+ARMYGREEN = ManimColor("#4B5D16")
+ASPARAGUS = ManimColor("#77AB56")
+AUBERGINE = ManimColor("#3D0734")
+AUBURN = ManimColor("#9A3001")
+AVOCADO = ManimColor("#90B134")
+AVOCADOGREEN = ManimColor("#87A922")
+AZUL = ManimColor("#1D5DEC")
+AZURE = ManimColor("#069AF3")
+BABYBLUE = ManimColor("#A2CFFE")
+BABYGREEN = ManimColor("#8CFF9E")
+BABYPINK = ManimColor("#FFB7CE")
+BABYPOO = ManimColor("#AB9004")
+BABYPOOP = ManimColor("#937C00")
+BABYPOOPGREEN = ManimColor("#8F9805")
+BABYPUKEGREEN = ManimColor("#B6C406")
+BABYPURPLE = ManimColor("#CA9BF7")
+BABYSHITBROWN = ManimColor("#AD900D")
+BABYSHITGREEN = ManimColor("#889717")
+BANANA = ManimColor("#FFFF7E")
+BANANAYELLOW = ManimColor("#FAFE4B")
+BARBIEPINK = ManimColor("#FE46A5")
+BARFGREEN = ManimColor("#94AC02")
+BARNEY = ManimColor("#AC1DB8")
+BARNEYPURPLE = ManimColor("#A00498")
+BATTLESHIPGREY = ManimColor("#6B7C85")
+BEIGE = ManimColor("#E6DAA6")
+BERRY = ManimColor("#990F4B")
+BILE = ManimColor("#B5C306")
+BLACK = ManimColor("#000000")
+BLAND = ManimColor("#AFA88B")
+BLOOD = ManimColor("#770001")
+BLOODORANGE = ManimColor("#FE4B03")
+BLOODRED = ManimColor("#980002")
+BLUE = ManimColor("#0343DF")
+BLUEBERRY = ManimColor("#464196")
+BLUEBLUE = ManimColor("#2242C7")
+BLUEGREEN = ManimColor("#0F9B8E")
+BLUEGREY = ManimColor("#85A3B2")
+BLUEPURPLE = ManimColor("#5A06EF")
+BLUEVIOLET = ManimColor("#5D06E9")
+BLUEWITHAHINTOFPURPLE = ManimColor("#533CC6")
+BLUEYGREEN = ManimColor("#2BB179")
+BLUEYGREY = ManimColor("#89A0B0")
+BLUEYPURPLE = ManimColor("#6241C7")
+BLUISH = ManimColor("#2976BB")
+BLUISHGREEN = ManimColor("#10A674")
+BLUISHGREY = ManimColor("#748B97")
+BLUISHPURPLE = ManimColor("#703BE7")
+BLURPLE = ManimColor("#5539CC")
+BLUSH = ManimColor("#F29E8E")
+BLUSHPINK = ManimColor("#FE828C")
+BOOGER = ManimColor("#9BB53C")
+BOOGERGREEN = ManimColor("#96B403")
+BORDEAUX = ManimColor("#7B002C")
+BORINGGREEN = ManimColor("#63B365")
+BOTTLEGREEN = ManimColor("#044A05")
+BRICK = ManimColor("#A03623")
+BRICKORANGE = ManimColor("#C14A09")
+BRICKRED = ManimColor("#8F1402")
+BRIGHTAQUA = ManimColor("#0BF9EA")
+BRIGHTBLUE = ManimColor("#0165FC")
+BRIGHTCYAN = ManimColor("#41FDFE")
+BRIGHTGREEN = ManimColor("#01FF07")
+BRIGHTLAVENDER = ManimColor("#C760FF")
+BRIGHTLIGHTBLUE = ManimColor("#26F7FD")
+BRIGHTLIGHTGREEN = ManimColor("#2DFE54")
+BRIGHTLILAC = ManimColor("#C95EFB")
+BRIGHTLIME = ManimColor("#87FD05")
+BRIGHTLIMEGREEN = ManimColor("#65FE08")
+BRIGHTMAGENTA = ManimColor("#FF08E8")
+BRIGHTOLIVE = ManimColor("#9CBB04")
+BRIGHTORANGE = ManimColor("#FF5B00")
+BRIGHTPINK = ManimColor("#FE01B1")
+BRIGHTPURPLE = ManimColor("#BE03FD")
+BRIGHTRED = ManimColor("#FF000D")
+BRIGHTSEAGREEN = ManimColor("#05FFA6")
+BRIGHTSKYBLUE = ManimColor("#02CCFE")
+BRIGHTTEAL = ManimColor("#01F9C6")
+BRIGHTTURQUOISE = ManimColor("#0FFEF9")
+BRIGHTVIOLET = ManimColor("#AD0AFD")
+BRIGHTYELLOW = ManimColor("#FFFD01")
+BRIGHTYELLOWGREEN = ManimColor("#9DFF00")
+BRITISHRACINGGREEN = ManimColor("#05480D")
+BRONZE = ManimColor("#A87900")
+BROWN = ManimColor("#653700")
+BROWNGREEN = ManimColor("#706C11")
+BROWNGREY = ManimColor("#8D8468")
+BROWNISH = ManimColor("#9C6D57")
+BROWNISHGREEN = ManimColor("#6A6E09")
+BROWNISHGREY = ManimColor("#86775F")
+BROWNISHORANGE = ManimColor("#CB7723")
+BROWNISHPINK = ManimColor("#C27E79")
+BROWNISHPURPLE = ManimColor("#76424E")
+BROWNISHRED = ManimColor("#9E3623")
+BROWNISHYELLOW = ManimColor("#C9B003")
+BROWNORANGE = ManimColor("#B96902")
+BROWNRED = ManimColor("#922B05")
+BROWNYELLOW = ManimColor("#B29705")
+BROWNYGREEN = ManimColor("#6F6C0A")
+BROWNYORANGE = ManimColor("#CA6B02")
+BRUISE = ManimColor("#7E4071")
+BUBBLEGUM = ManimColor("#FF6CB5")
+BUBBLEGUMPINK = ManimColor("#FF69AF")
+BUFF = ManimColor("#FEF69E")
+BURGUNDY = ManimColor("#610023")
+BURNTORANGE = ManimColor("#C04E01")
+BURNTRED = ManimColor("#9F2305")
+BURNTSIENA = ManimColor("#B75203")
+BURNTSIENNA = ManimColor("#B04E0F")
+BURNTUMBER = ManimColor("#A0450E")
+BURNTYELLOW = ManimColor("#D5AB09")
+BURPLE = ManimColor("#6832E3")
+BUTTER = ManimColor("#FFFF81")
+BUTTERSCOTCH = ManimColor("#FDB147")
+BUTTERYELLOW = ManimColor("#FFFD74")
+CADETBLUE = ManimColor("#4E7496")
+CAMEL = ManimColor("#C69F59")
+CAMO = ManimColor("#7F8F4E")
+CAMOGREEN = ManimColor("#526525")
+CAMOUFLAGEGREEN = ManimColor("#4B6113")
+CANARY = ManimColor("#FDFF63")
+CANARYYELLOW = ManimColor("#FFFE40")
+CANDYPINK = ManimColor("#FF63E9")
+CARAMEL = ManimColor("#AF6F09")
+CARMINE = ManimColor("#9D0216")
+CARNATION = ManimColor("#FD798F")
+CARNATIONPINK = ManimColor("#FF7FA7")
+CAROLINABLUE = ManimColor("#8AB8FE")
+CELADON = ManimColor("#BEFDB7")
+CELERY = ManimColor("#C1FD95")
+CEMENT = ManimColor("#A5A391")
+CERISE = ManimColor("#DE0C62")
+CERULEAN = ManimColor("#0485D1")
+CERULEANBLUE = ManimColor("#056EEE")
+CHARCOAL = ManimColor("#343837")
+CHARCOALGREY = ManimColor("#3C4142")
+CHARTREUSE = ManimColor("#C1F80A")
+CHERRY = ManimColor("#CF0234")
+CHERRYRED = ManimColor("#F7022A")
+CHESTNUT = ManimColor("#742802")
+CHOCOLATE = ManimColor("#3D1C02")
+CHOCOLATEBROWN = ManimColor("#411900")
+CINNAMON = ManimColor("#AC4F06")
+CLARET = ManimColor("#680018")
+CLAY = ManimColor("#B66A50")
+CLAYBROWN = ManimColor("#B2713D")
+CLEARBLUE = ManimColor("#247AFD")
+COBALT = ManimColor("#1E488F")
+COBALTBLUE = ManimColor("#030AA7")
+COCOA = ManimColor("#875F42")
+COFFEE = ManimColor("#A6814C")
+COOLBLUE = ManimColor("#4984B8")
+COOLGREEN = ManimColor("#33B864")
+COOLGREY = ManimColor("#95A3A6")
+COPPER = ManimColor("#B66325")
+CORAL = ManimColor("#FC5A50")
+CORALPINK = ManimColor("#FF6163")
+CORNFLOWER = ManimColor("#6A79F7")
+CORNFLOWERBLUE = ManimColor("#5170D7")
+CRANBERRY = ManimColor("#9E003A")
+CREAM = ManimColor("#FFFFC2")
+CREME = ManimColor("#FFFFB6")
+CRIMSON = ManimColor("#8C000F")
+CUSTARD = ManimColor("#FFFD78")
+CYAN = ManimColor("#00FFFF")
+DANDELION = ManimColor("#FEDF08")
+DARK = ManimColor("#1B2431")
+DARKAQUA = ManimColor("#05696B")
+DARKAQUAMARINE = ManimColor("#017371")
+DARKBEIGE = ManimColor("#AC9362")
+DARKBLUE = ManimColor("#030764")
+DARKBLUEGREEN = ManimColor("#005249")
+DARKBLUEGREY = ManimColor("#1F3B4D")
+DARKBROWN = ManimColor("#341C02")
+DARKCORAL = ManimColor("#CF524E")
+DARKCREAM = ManimColor("#FFF39A")
+DARKCYAN = ManimColor("#0A888A")
+DARKFORESTGREEN = ManimColor("#002D04")
+DARKFUCHSIA = ManimColor("#9D0759")
+DARKGOLD = ManimColor("#B59410")
+DARKGRASSGREEN = ManimColor("#388004")
+DARKGREEN = ManimColor("#054907")
+DARKGREENBLUE = ManimColor("#1F6357")
+DARKGREY = ManimColor("#363737")
+DARKGREYBLUE = ManimColor("#29465B")
+DARKHOTPINK = ManimColor("#D90166")
+DARKINDIGO = ManimColor("#1F0954")
+DARKISHBLUE = ManimColor("#014182")
+DARKISHGREEN = ManimColor("#287C37")
+DARKISHPINK = ManimColor("#DA467D")
+DARKISHPURPLE = ManimColor("#751973")
+DARKISHRED = ManimColor("#A90308")
+DARKKHAKI = ManimColor("#9B8F55")
+DARKLAVENDER = ManimColor("#856798")
+DARKLILAC = ManimColor("#9C6DA5")
+DARKLIME = ManimColor("#84B701")
+DARKLIMEGREEN = ManimColor("#7EBD01")
+DARKMAGENTA = ManimColor("#960056")
+DARKMAROON = ManimColor("#3C0008")
+DARKMAUVE = ManimColor("#874C62")
+DARKMINT = ManimColor("#48C072")
+DARKMINTGREEN = ManimColor("#20C073")
+DARKMUSTARD = ManimColor("#A88905")
+DARKNAVY = ManimColor("#000435")
+DARKNAVYBLUE = ManimColor("#00022E")
+DARKOLIVE = ManimColor("#373E02")
+DARKOLIVEGREEN = ManimColor("#3C4D03")
+DARKORANGE = ManimColor("#C65102")
+DARKPASTELGREEN = ManimColor("#56AE57")
+DARKPEACH = ManimColor("#DE7E5D")
+DARKPERIWINKLE = ManimColor("#665FD1")
+DARKPINK = ManimColor("#CB416B")
+DARKPLUM = ManimColor("#3F012C")
+DARKPURPLE = ManimColor("#35063E")
+DARKRED = ManimColor("#840000")
+DARKROSE = ManimColor("#B5485D")
+DARKROYALBLUE = ManimColor("#02066F")
+DARKSAGE = ManimColor("#598556")
+DARKSALMON = ManimColor("#C85A53")
+DARKSAND = ManimColor("#A88F59")
+DARKSEAFOAM = ManimColor("#1FB57A")
+DARKSEAFOAMGREEN = ManimColor("#3EAF76")
+DARKSEAGREEN = ManimColor("#11875D")
+DARKSKYBLUE = ManimColor("#448EE4")
+DARKSLATEBLUE = ManimColor("#214761")
+DARKTAN = ManimColor("#AF884A")
+DARKTAUPE = ManimColor("#7F684E")
+DARKTEAL = ManimColor("#014D4E")
+DARKTURQUOISE = ManimColor("#045C5A")
+DARKVIOLET = ManimColor("#34013F")
+DARKYELLOW = ManimColor("#D5B60A")
+DARKYELLOWGREEN = ManimColor("#728F02")
+DEEPAQUA = ManimColor("#08787F")
+DEEPBLUE = ManimColor("#040273")
+DEEPBROWN = ManimColor("#410200")
+DEEPGREEN = ManimColor("#02590F")
+DEEPLAVENDER = ManimColor("#8D5EB7")
+DEEPLILAC = ManimColor("#966EBD")
+DEEPMAGENTA = ManimColor("#A0025C")
+DEEPORANGE = ManimColor("#DC4D01")
+DEEPPINK = ManimColor("#CB0162")
+DEEPPURPLE = ManimColor("#36013F")
+DEEPRED = ManimColor("#9A0200")
+DEEPROSE = ManimColor("#C74767")
+DEEPSEABLUE = ManimColor("#015482")
+DEEPSKYBLUE = ManimColor("#0D75F8")
+DEEPTEAL = ManimColor("#00555A")
+DEEPTURQUOISE = ManimColor("#017374")
+DEEPVIOLET = ManimColor("#490648")
+DENIM = ManimColor("#3B638C")
+DENIMBLUE = ManimColor("#3B5B92")
+DESERT = ManimColor("#CCAD60")
+DIARRHEA = ManimColor("#9F8303")
+DIRT = ManimColor("#8A6E45")
+DIRTBROWN = ManimColor("#836539")
+DIRTYBLUE = ManimColor("#3F829D")
+DIRTYGREEN = ManimColor("#667E2C")
+DIRTYORANGE = ManimColor("#C87606")
+DIRTYPINK = ManimColor("#CA7B80")
+DIRTYPURPLE = ManimColor("#734A65")
+DIRTYYELLOW = ManimColor("#CDC50A")
+DODGERBLUE = ManimColor("#3E82FC")
+DRAB = ManimColor("#828344")
+DRABGREEN = ManimColor("#749551")
+DRIEDBLOOD = ManimColor("#4B0101")
+DUCKEGGBLUE = ManimColor("#C3FBF4")
+DULLBLUE = ManimColor("#49759C")
+DULLBROWN = ManimColor("#876E4B")
+DULLGREEN = ManimColor("#74A662")
+DULLORANGE = ManimColor("#D8863B")
+DULLPINK = ManimColor("#D5869D")
+DULLPURPLE = ManimColor("#84597E")
+DULLRED = ManimColor("#BB3F3F")
+DULLTEAL = ManimColor("#5F9E8F")
+DULLYELLOW = ManimColor("#EEDC5B")
+DUSK = ManimColor("#4E5481")
+DUSKBLUE = ManimColor("#26538D")
+DUSKYBLUE = ManimColor("#475F94")
+DUSKYPINK = ManimColor("#CC7A8B")
+DUSKYPURPLE = ManimColor("#895B7B")
+DUSKYROSE = ManimColor("#BA6873")
+DUST = ManimColor("#B2996E")
+DUSTYBLUE = ManimColor("#5A86AD")
+DUSTYGREEN = ManimColor("#76A973")
+DUSTYLAVENDER = ManimColor("#AC86A8")
+DUSTYORANGE = ManimColor("#F0833A")
+DUSTYPINK = ManimColor("#D58A94")
+DUSTYPURPLE = ManimColor("#825F87")
+DUSTYRED = ManimColor("#B9484E")
+DUSTYROSE = ManimColor("#C0737A")
+DUSTYTEAL = ManimColor("#4C9085")
+EARTH = ManimColor("#A2653E")
+EASTERGREEN = ManimColor("#8CFD7E")
+EASTERPURPLE = ManimColor("#C071FE")
+ECRU = ManimColor("#FEFFCA")
+EGGPLANT = ManimColor("#380835")
+EGGPLANTPURPLE = ManimColor("#430541")
+EGGSHELL = ManimColor("#FFFCC4")
+EGGSHELLBLUE = ManimColor("#C4FFF7")
+ELECTRICBLUE = ManimColor("#0652FF")
+ELECTRICGREEN = ManimColor("#21FC0D")
+ELECTRICLIME = ManimColor("#A8FF04")
+ELECTRICPINK = ManimColor("#FF0490")
+ELECTRICPURPLE = ManimColor("#AA23FF")
+EMERALD = ManimColor("#01A049")
+EMERALDGREEN = ManimColor("#028F1E")
+EVERGREEN = ManimColor("#05472A")
+FADEDBLUE = ManimColor("#658CBB")
+FADEDGREEN = ManimColor("#7BB274")
+FADEDORANGE = ManimColor("#F0944D")
+FADEDPINK = ManimColor("#DE9DAC")
+FADEDPURPLE = ManimColor("#916E99")
+FADEDRED = ManimColor("#D3494E")
+FADEDYELLOW = ManimColor("#FEFF7F")
+FAWN = ManimColor("#CFAF7B")
+FERN = ManimColor("#63A950")
+FERNGREEN = ManimColor("#548D44")
+FIREENGINERED = ManimColor("#FE0002")
+FLATBLUE = ManimColor("#3C73A8")
+FLATGREEN = ManimColor("#699D4C")
+FLUORESCENTGREEN = ManimColor("#08FF08")
+FLUROGREEN = ManimColor("#0AFF02")
+FOAMGREEN = ManimColor("#90FDA9")
+FOREST = ManimColor("#0B5509")
+FORESTGREEN = ManimColor("#06470C")
+FORRESTGREEN = ManimColor("#154406")
+FRENCHBLUE = ManimColor("#436BAD")
+FRESHGREEN = ManimColor("#69D84F")
+FROGGREEN = ManimColor("#58BC08")
+FUCHSIA = ManimColor("#ED0DD9")
+GOLD = ManimColor("#DBB40C")
+GOLDEN = ManimColor("#F5BF03")
+GOLDENBROWN = ManimColor("#B27A01")
+GOLDENROD = ManimColor("#F9BC08")
+GOLDENYELLOW = ManimColor("#FEC615")
+GRAPE = ManimColor("#6C3461")
+GRAPEFRUIT = ManimColor("#FD5956")
+GRAPEPURPLE = ManimColor("#5D1451")
+GRASS = ManimColor("#5CAC2D")
+GRASSGREEN = ManimColor("#3F9B0B")
+GRASSYGREEN = ManimColor("#419C03")
+GREEN = ManimColor("#15B01A")
+GREENAPPLE = ManimColor("#5EDC1F")
+GREENBLUE = ManimColor("#01C08D")
+GREENBROWN = ManimColor("#544E03")
+GREENGREY = ManimColor("#77926F")
+GREENISH = ManimColor("#40A368")
+GREENISHBEIGE = ManimColor("#C9D179")
+GREENISHBLUE = ManimColor("#0B8B87")
+GREENISHBROWN = ManimColor("#696112")
+GREENISHCYAN = ManimColor("#2AFEB7")
+GREENISHGREY = ManimColor("#96AE8D")
+GREENISHTAN = ManimColor("#BCCB7A")
+GREENISHTEAL = ManimColor("#32BF84")
+GREENISHTURQUOISE = ManimColor("#00FBB0")
+GREENISHYELLOW = ManimColor("#CDFD02")
+GREENTEAL = ManimColor("#0CB577")
+GREENYBLUE = ManimColor("#42B395")
+GREENYBROWN = ManimColor("#696006")
+GREENYELLOW = ManimColor("#B5CE08")
+GREENYGREY = ManimColor("#7EA07A")
+GREENYYELLOW = ManimColor("#C6F808")
+GREY = ManimColor("#929591")
+GREYBLUE = ManimColor("#647D8E")
+GREYBROWN = ManimColor("#7F7053")
+GREYGREEN = ManimColor("#86A17D")
+GREYISH = ManimColor("#A8A495")
+GREYISHBLUE = ManimColor("#5E819D")
+GREYISHBROWN = ManimColor("#7A6A4F")
+GREYISHGREEN = ManimColor("#82A67D")
+GREYISHPINK = ManimColor("#C88D94")
+GREYISHPURPLE = ManimColor("#887191")
+GREYISHTEAL = ManimColor("#719F91")
+GREYPINK = ManimColor("#C3909B")
+GREYPURPLE = ManimColor("#826D8C")
+GREYTEAL = ManimColor("#5E9B8A")
+GROSSGREEN = ManimColor("#A0BF16")
+GUNMETAL = ManimColor("#536267")
+HAZEL = ManimColor("#8E7618")
+HEATHER = ManimColor("#A484AC")
+HELIOTROPE = ManimColor("#D94FF5")
+HIGHLIGHTERGREEN = ManimColor("#1BFC06")
+HOSPITALGREEN = ManimColor("#9BE5AA")
+HOTGREEN = ManimColor("#25FF29")
+HOTMAGENTA = ManimColor("#F504C9")
+HOTPINK = ManimColor("#FF028D")
+HOTPURPLE = ManimColor("#CB00F5")
+HUNTERGREEN = ManimColor("#0B4008")
+ICE = ManimColor("#D6FFFA")
+ICEBLUE = ManimColor("#D7FFFE")
+ICKYGREEN = ManimColor("#8FAE22")
+INDIANRED = ManimColor("#850E04")
+INDIGO = ManimColor("#380282")
+INDIGOBLUE = ManimColor("#3A18B1")
+IRIS = ManimColor("#6258C4")
+IRISHGREEN = ManimColor("#019529")
+IVORY = ManimColor("#FFFFCB")
+JADE = ManimColor("#1FA774")
+JADEGREEN = ManimColor("#2BAF6A")
+JUNGLEGREEN = ManimColor("#048243")
+KELLEYGREEN = ManimColor("#009337")
+KELLYGREEN = ManimColor("#02AB2E")
+KERMITGREEN = ManimColor("#5CB200")
+KEYLIME = ManimColor("#AEFF6E")
+KHAKI = ManimColor("#AAA662")
+KHAKIGREEN = ManimColor("#728639")
+KIWI = ManimColor("#9CEF43")
+KIWIGREEN = ManimColor("#8EE53F")
+LAVENDER = ManimColor("#C79FEF")
+LAVENDERBLUE = ManimColor("#8B88F8")
+LAVENDERPINK = ManimColor("#DD85D7")
+LAWNGREEN = ManimColor("#4DA409")
+LEAF = ManimColor("#71AA34")
+LEAFGREEN = ManimColor("#5CA904")
+LEAFYGREEN = ManimColor("#51B73B")
+LEATHER = ManimColor("#AC7434")
+LEMON = ManimColor("#FDFF52")
+LEMONGREEN = ManimColor("#ADF802")
+LEMONLIME = ManimColor("#BFFE28")
+LEMONYELLOW = ManimColor("#FDFF38")
+LICHEN = ManimColor("#8FB67B")
+LIGHTAQUA = ManimColor("#8CFFDB")
+LIGHTAQUAMARINE = ManimColor("#7BFDC7")
+LIGHTBEIGE = ManimColor("#FFFEB6")
+LIGHTBLUE = ManimColor("#7BC8F6")
+LIGHTBLUEGREEN = ManimColor("#7EFBB3")
+LIGHTBLUEGREY = ManimColor("#B7C9E2")
+LIGHTBLUISHGREEN = ManimColor("#76FDA8")
+LIGHTBRIGHTGREEN = ManimColor("#53FE5C")
+LIGHTBROWN = ManimColor("#AD8150")
+LIGHTBURGUNDY = ManimColor("#A8415B")
+LIGHTCYAN = ManimColor("#ACFFFC")
+LIGHTEGGPLANT = ManimColor("#894585")
+LIGHTERGREEN = ManimColor("#75FD63")
+LIGHTERPURPLE = ManimColor("#A55AF4")
+LIGHTFORESTGREEN = ManimColor("#4F9153")
+LIGHTGOLD = ManimColor("#FDDC5C")
+LIGHTGRASSGREEN = ManimColor("#9AF764")
+LIGHTGREEN = ManimColor("#76FF7B")
+LIGHTGREENBLUE = ManimColor("#56FCA2")
+LIGHTGREENISHBLUE = ManimColor("#63F7B4")
+LIGHTGREY = ManimColor("#D8DCD6")
+LIGHTGREYBLUE = ManimColor("#9DBCD4")
+LIGHTGREYGREEN = ManimColor("#B7E1A1")
+LIGHTINDIGO = ManimColor("#6D5ACF")
+LIGHTISHBLUE = ManimColor("#3D7AFD")
+LIGHTISHGREEN = ManimColor("#61E160")
+LIGHTISHPURPLE = ManimColor("#A552E6")
+LIGHTISHRED = ManimColor("#FE2F4A")
+LIGHTKHAKI = ManimColor("#E6F2A2")
+LIGHTLAVENDAR = ManimColor("#EFC0FE")
+LIGHTLAVENDER = ManimColor("#DFC5FE")
+LIGHTLIGHTBLUE = ManimColor("#CAFFFB")
+LIGHTLIGHTGREEN = ManimColor("#C8FFB0")
+LIGHTLILAC = ManimColor("#EDC8FF")
+LIGHTLIME = ManimColor("#AEFD6C")
+LIGHTLIMEGREEN = ManimColor("#B9FF66")
+LIGHTMAGENTA = ManimColor("#FA5FF7")
+LIGHTMAROON = ManimColor("#A24857")
+LIGHTMAUVE = ManimColor("#C292A1")
+LIGHTMINT = ManimColor("#B6FFBB")
+LIGHTMINTGREEN = ManimColor("#A6FBB2")
+LIGHTMOSSGREEN = ManimColor("#A6C875")
+LIGHTMUSTARD = ManimColor("#F7D560")
+LIGHTNAVY = ManimColor("#155084")
+LIGHTNAVYBLUE = ManimColor("#2E5A88")
+LIGHTNEONGREEN = ManimColor("#4EFD54")
+LIGHTOLIVE = ManimColor("#ACBF69")
+LIGHTOLIVEGREEN = ManimColor("#A4BE5C")
+LIGHTORANGE = ManimColor("#FDAA48")
+LIGHTPASTELGREEN = ManimColor("#B2FBA5")
+LIGHTPEACH = ManimColor("#FFD8B1")
+LIGHTPEAGREEN = ManimColor("#C4FE82")
+LIGHTPERIWINKLE = ManimColor("#C1C6FC")
+LIGHTPINK = ManimColor("#FFD1DF")
+LIGHTPLUM = ManimColor("#9D5783")
+LIGHTPURPLE = ManimColor("#BF77F6")
+LIGHTRED = ManimColor("#FF474C")
+LIGHTROSE = ManimColor("#FFC5CB")
+LIGHTROYALBLUE = ManimColor("#3A2EFE")
+LIGHTSAGE = ManimColor("#BCECAC")
+LIGHTSALMON = ManimColor("#FEA993")
+LIGHTSEAFOAM = ManimColor("#A0FEBF")
+LIGHTSEAFOAMGREEN = ManimColor("#a7ffb5")
+LIGHTSEAGREEN = ManimColor("#98F6B0")
+LIGHTSKYBLUE = ManimColor("#C6FCFF")
+LIGHTTAN = ManimColor("#FBEEAC")
+LIGHTTEAL = ManimColor("#90E4C1")
+LIGHTTURQUOISE = ManimColor("#7EF4CC")
+LIGHTURPLE = ManimColor("#B36FF6")
+LIGHTVIOLET = ManimColor("#D6B4FC")
+LIGHTYELLOW = ManimColor("#FFFE7A")
+LIGHTYELLOWGREEN = ManimColor("#CCFD7F")
+LIGHTYELLOWISHGREEN = ManimColor("#C2FF89")
+LILAC = ManimColor("#CEA2FD")
+LILIAC = ManimColor("#C48EFD")
+LIME = ManimColor("#AAFF32")
+LIMEGREEN = ManimColor("#89FE05")
+LIMEYELLOW = ManimColor("#D0FE1D")
+LIPSTICK = ManimColor("#D5174E")
+LIPSTICKRED = ManimColor("#C0022F")
+MACARONIANDCHEESE = ManimColor("#EFB435")
+MAGENTA = ManimColor("#C20078")
+MAHOGANY = ManimColor("#4A0100")
+MAIZE = ManimColor("#F4D054")
+MANGO = ManimColor("#FFA62B")
+MANILLA = ManimColor("#FFFA86")
+MARIGOLD = ManimColor("#FCC006")
+MARINE = ManimColor("#042E60")
+MARINEBLUE = ManimColor("#01386A")
+MAROON = ManimColor("#650021")
+MAUVE = ManimColor("#AE7181")
+MEDIUMBLUE = ManimColor("#2C6FBB")
+MEDIUMBROWN = ManimColor("#7F5112")
+MEDIUMGREEN = ManimColor("#39AD48")
+MEDIUMGREY = ManimColor("#7D7F7C")
+MEDIUMPINK = ManimColor("#F36196")
+MEDIUMPURPLE = ManimColor("#9E43A2")
+MELON = ManimColor("#FF7855")
+MERLOT = ManimColor("#730039")
+METALLICBLUE = ManimColor("#4F738E")
+MIDBLUE = ManimColor("#276AB3")
+MIDGREEN = ManimColor("#50A747")
+MIDNIGHT = ManimColor("#03012D")
+MIDNIGHTBLUE = ManimColor("#020035")
+MIDNIGHTPURPLE = ManimColor("#280137")
+MILITARYGREEN = ManimColor("#667C3E")
+MILKCHOCOLATE = ManimColor("#7F4E1E")
+MINT = ManimColor("#9FFEB0")
+MINTGREEN = ManimColor("#8FFF9F")
+MINTYGREEN = ManimColor("#0BF77D")
+MOCHA = ManimColor("#9D7651")
+MOSS = ManimColor("#769958")
+MOSSGREEN = ManimColor("#658B38")
+MOSSYGREEN = ManimColor("#638B27")
+MUD = ManimColor("#735C12")
+MUDBROWN = ManimColor("#60460F")
+MUDDYBROWN = ManimColor("#886806")
+MUDDYGREEN = ManimColor("#657432")
+MUDDYYELLOW = ManimColor("#BFAC05")
+MUDGREEN = ManimColor("#606602")
+MULBERRY = ManimColor("#920A4E")
+MURKYGREEN = ManimColor("#6C7A0E")
+MUSHROOM = ManimColor("#BA9E88")
+MUSTARD = ManimColor("#CEB301")
+MUSTARDBROWN = ManimColor("#AC7E04")
+MUSTARDGREEN = ManimColor("#A8B504")
+MUSTARDYELLOW = ManimColor("#D2BD0A")
+MUTEDBLUE = ManimColor("#3B719F")
+MUTEDGREEN = ManimColor("#5FA052")
+MUTEDPINK = ManimColor("#D1768F")
+MUTEDPURPLE = ManimColor("#805B87")
+NASTYGREEN = ManimColor("#70B23F")
+NAVY = ManimColor("#01153E")
+NAVYBLUE = ManimColor("#001146")
+NAVYGREEN = ManimColor("#35530A")
+NEONBLUE = ManimColor("#04D9FF")
+NEONGREEN = ManimColor("#0CFF0C")
+NEONPINK = ManimColor("#FE019A")
+NEONPURPLE = ManimColor("#BC13FE")
+NEONRED = ManimColor("#FF073A")
+NEONYELLOW = ManimColor("#CFFF04")
+NICEBLUE = ManimColor("#107AB0")
+NIGHTBLUE = ManimColor("#040348")
+OCEAN = ManimColor("#017B92")
+OCEANBLUE = ManimColor("#03719C")
+OCEANGREEN = ManimColor("#3D9973")
+OCHER = ManimColor("#BF9B0C")
+OCHRE = ManimColor("#BF9005")
+OCRE = ManimColor("#C69C04")
+OFFBLUE = ManimColor("#5684AE")
+OFFGREEN = ManimColor("#6BA353")
+OFFWHITE = ManimColor("#FFFFE4")
+OFFYELLOW = ManimColor("#F1F33F")
+OLDPINK = ManimColor("#C77986")
+OLDROSE = ManimColor("#C87F89")
+OLIVE = ManimColor("#6E750E")
+OLIVEBROWN = ManimColor("#645403")
+OLIVEDRAB = ManimColor("#6F7632")
+OLIVEGREEN = ManimColor("#677A04")
+OLIVEYELLOW = ManimColor("#C2B709")
+ORANGE = ManimColor("#F97306")
+ORANGEBROWN = ManimColor("#BE6400")
+ORANGEISH = ManimColor("#FD8D49")
+ORANGEPINK = ManimColor("#FF6F52")
+ORANGERED = ManimColor("#FE420F")
+ORANGEYBROWN = ManimColor("#B16002")
+ORANGEYELLOW = ManimColor("#FFAD01")
+ORANGEYRED = ManimColor("#FA4224")
+ORANGEYYELLOW = ManimColor("#FDB915")
+ORANGISH = ManimColor("#FC824A")
+ORANGISHBROWN = ManimColor("#B25F03")
+ORANGISHRED = ManimColor("#F43605")
+ORCHID = ManimColor("#C875C4")
+PALE = ManimColor("#FFF9D0")
+PALEAQUA = ManimColor("#B8FFEB")
+PALEBLUE = ManimColor("#D0FEFE")
+PALEBROWN = ManimColor("#B1916E")
+PALECYAN = ManimColor("#B7FFFA")
+PALEGOLD = ManimColor("#FDDE6C")
+PALEGREEN = ManimColor("#C7FDB5")
+PALEGREY = ManimColor("#FDFDFE")
+PALELAVENDER = ManimColor("#EECFFE")
+PALELIGHTGREEN = ManimColor("#B1FC99")
+PALELILAC = ManimColor("#E4CBFF")
+PALELIME = ManimColor("#BEFD73")
+PALELIMEGREEN = ManimColor("#B1FF65")
+PALEMAGENTA = ManimColor("#D767AD")
+PALEMAUVE = ManimColor("#FED0FC")
+PALEOLIVE = ManimColor("#B9CC81")
+PALEOLIVEGREEN = ManimColor("#B1D27B")
+PALEORANGE = ManimColor("#FFA756")
+PALEPEACH = ManimColor("#FFE5AD")
+PALEPINK = ManimColor("#FFCFDC")
+PALEPURPLE = ManimColor("#B790D4")
+PALERED = ManimColor("#D9544D")
+PALEROSE = ManimColor("#FDC1C5")
+PALESALMON = ManimColor("#FFB19A")
+PALESKYBLUE = ManimColor("#BDF6FE")
+PALETEAL = ManimColor("#82CBB2")
+PALETURQUOISE = ManimColor("#A5FBD5")
+PALEVIOLET = ManimColor("#CEAEFA")
+PALEYELLOW = ManimColor("#FFFF84")
+PARCHMENT = ManimColor("#FEFCAF")
+PASTELBLUE = ManimColor("#A2BFFE")
+PASTELGREEN = ManimColor("#B0FF9D")
+PASTELORANGE = ManimColor("#FF964F")
+PASTELPINK = ManimColor("#FFBACD")
+PASTELPURPLE = ManimColor("#CAA0FF")
+PASTELRED = ManimColor("#DB5856")
+PASTELYELLOW = ManimColor("#FFFE71")
+PEA = ManimColor("#A4BF20")
+PEACH = ManimColor("#FFB07C")
+PEACHYPINK = ManimColor("#FF9A8A")
+PEACOCKBLUE = ManimColor("#016795")
+PEAGREEN = ManimColor("#8EAB12")
+PEAR = ManimColor("#CBF85F")
+PEASOUP = ManimColor("#929901")
+PEASOUPGREEN = ManimColor("#94A617")
+PERIWINKLE = ManimColor("#8E82FE")
+PERIWINKLEBLUE = ManimColor("#8F99FB")
+PERRYWINKLE = ManimColor("#8F8CE7")
+PETROL = ManimColor("#005F6A")
+PIGPINK = ManimColor("#E78EA5")
+PINE = ManimColor("#2B5D34")
+PINEGREEN = ManimColor("#0A481E")
+PINK = ManimColor("#FF81C0")
+PINKISH = ManimColor("#D46A7E")
+PINKISHBROWN = ManimColor("#B17261")
+PINKISHGREY = ManimColor("#C8ACA9")
+PINKISHORANGE = ManimColor("#FF724C")
+PINKISHPURPLE = ManimColor("#D648D7")
+PINKISHRED = ManimColor("#F10C45")
+PINKISHTAN = ManimColor("#D99B82")
+PINKPURPLE = ManimColor("#EF1DE7")
+PINKRED = ManimColor("#F5054F")
+PINKY = ManimColor("#FC86AA")
+PINKYPURPLE = ManimColor("#C94CBE")
+PINKYRED = ManimColor("#FC2647")
+PISSYELLOW = ManimColor("#DDD618")
+PISTACHIO = ManimColor("#C0FA8B")
+PLUM = ManimColor("#580F41")
+PLUMPURPLE = ManimColor("#4E0550")
+POISONGREEN = ManimColor("#40FD14")
+POO = ManimColor("#8F7303")
+POOBROWN = ManimColor("#885F01")
+POOP = ManimColor("#7F5E00")
+POOPBROWN = ManimColor("#7A5901")
+POOPGREEN = ManimColor("#6F7C00")
+POWDERBLUE = ManimColor("#B1D1FC")
+POWDERPINK = ManimColor("#FFB2D0")
+PRIMARYBLUE = ManimColor("#0804F9")
+PRUSSIANBLUE = ManimColor("#004577")
+PUCE = ManimColor("#A57E52")
+PUKE = ManimColor("#A5A502")
+PUKEBROWN = ManimColor("#947706")
+PUKEGREEN = ManimColor("#9AAE07")
+PUKEYELLOW = ManimColor("#C2BE0E")
+PUMPKIN = ManimColor("#E17701")
+PUMPKINORANGE = ManimColor("#FB7D07")
+PUREBLUE = ManimColor("#0203E2")
+PURPLE = ManimColor("#7E1E9C")
+PURPLEBLUE = ManimColor("#5D21D0")
+PURPLEBROWN = ManimColor("#673A3F")
+PURPLEGREY = ManimColor("#866F85")
+PURPLEISH = ManimColor("#98568D")
+PURPLEISHBLUE = ManimColor("#6140EF")
+PURPLEISHPINK = ManimColor("#DF4EC8")
+PURPLEPINK = ManimColor("#D725DE")
+PURPLERED = ManimColor("#990147")
+PURPLEY = ManimColor("#8756E4")
+PURPLEYBLUE = ManimColor("#5F34E7")
+PURPLEYGREY = ManimColor("#947E94")
+PURPLEYPINK = ManimColor("#C83CB9")
+PURPLISH = ManimColor("#94568C")
+PURPLISHBLUE = ManimColor("#601EF9")
+PURPLISHBROWN = ManimColor("#6B4247")
+PURPLISHGREY = ManimColor("#7A687F")
+PURPLISHPINK = ManimColor("#CE5DAE")
+PURPLISHRED = ManimColor("#B0054B")
+PURPLY = ManimColor("#983FB2")
+PURPLYBLUE = ManimColor("#661AEE")
+PURPLYPINK = ManimColor("#F075E6")
+PUTTY = ManimColor("#BEAE8A")
+RACINGGREEN = ManimColor("#014600")
+RADIOACTIVEGREEN = ManimColor("#2CFA1F")
+RASPBERRY = ManimColor("#B00149")
+RAWSIENNA = ManimColor("#9A6200")
+RAWUMBER = ManimColor("#A75E09")
+REALLYLIGHTBLUE = ManimColor("#D4FFFF")
+RED = ManimColor("#E50000")
+REDBROWN = ManimColor("#8B2E16")
+REDDISH = ManimColor("#C44240")
+REDDISHBROWN = ManimColor("#7F2B0A")
+REDDISHGREY = ManimColor("#997570")
+REDDISHORANGE = ManimColor("#F8481C")
+REDDISHPINK = ManimColor("#FE2C54")
+REDDISHPURPLE = ManimColor("#910951")
+REDDYBROWN = ManimColor("#6E1005")
+REDORANGE = ManimColor("#FD3C06")
+REDPINK = ManimColor("#FA2A55")
+REDPURPLE = ManimColor("#820747")
+REDVIOLET = ManimColor("#9E0168")
+REDWINE = ManimColor("#8C0034")
+RICHBLUE = ManimColor("#021BF9")
+RICHPURPLE = ManimColor("#720058")
+ROBINEGGBLUE = ManimColor("#8AF1FE")
+ROBINSEGG = ManimColor("#6DEDFD")
+ROBINSEGGBLUE = ManimColor("#98EFF9")
+ROSA = ManimColor("#FE86A4")
+ROSE = ManimColor("#CF6275")
+ROSEPINK = ManimColor("#F7879A")
+ROSERED = ManimColor("#BE013C")
+ROSYPINK = ManimColor("#F6688E")
+ROGUE = ManimColor("#AB1239")
+ROYAL = ManimColor("#0C1793")
+ROYALBLUE = ManimColor("#0504AA")
+ROYALPURPLE = ManimColor("#4B006E")
+RUBY = ManimColor("#CA0147")
+RUSSET = ManimColor("#A13905")
+RUST = ManimColor("#A83C09")
+RUSTBROWN = ManimColor("#8B3103")
+RUSTORANGE = ManimColor("#C45508")
+RUSTRED = ManimColor("#AA2704")
+RUSTYORANGE = ManimColor("#CD5909")
+RUSTYRED = ManimColor("#AF2F0D")
+SAFFRON = ManimColor("#FEB209")
+SAGE = ManimColor("#87AE73")
+SAGEGREEN = ManimColor("#88B378")
+SALMON = ManimColor("#FF796C")
+SALMONPINK = ManimColor("#FE7B7C")
+SAND = ManimColor("#E2CA76")
+SANDBROWN = ManimColor("#CBA560")
+SANDSTONE = ManimColor("#C9AE74")
+SANDY = ManimColor("#F1DA7A")
+SANDYBROWN = ManimColor("#C4A661")
+SANDYELLOW = ManimColor("#FCE166")
+SANDYYELLOW = ManimColor("#FDEE73")
+SAPGREEN = ManimColor("#5C8B15")
+SAPPHIRE = ManimColor("#2138AB")
+SCARLET = ManimColor("#BE0119")
+SEA = ManimColor("#3C9992")
+SEABLUE = ManimColor("#047495")
+SEAFOAM = ManimColor("#80F9AD")
+SEAFOAMBLUE = ManimColor("#78D1B6")
+SEAFOAMGREEN = ManimColor("#7AF9AB")
+SEAGREEN = ManimColor("#53FCA1")
+SEAWEED = ManimColor("#18D17B")
+SEAWEEDGREEN = ManimColor("#35AD6B")
+SEPIA = ManimColor("#985E2B")
+SHAMROCK = ManimColor("#01B44C")
+SHAMROCKGREEN = ManimColor("#02C14D")
+SHIT = ManimColor("#7F5F00")
+SHITBROWN = ManimColor("#7B5804")
+SHITGREEN = ManimColor("#758000")
+SHOCKINGPINK = ManimColor("#FE02A2")
+SICKGREEN = ManimColor("#9DB92C")
+SICKLYGREEN = ManimColor("#94B21C")
+SICKLYYELLOW = ManimColor("#D0E429")
+SIENNA = ManimColor("#A9561E")
+SILVER = ManimColor("#C5C9C7")
+SKY = ManimColor("#82CAFC")
+SKYBLUE = ManimColor("#75BBFD")
+SLATE = ManimColor("#516572")
+SLATEBLUE = ManimColor("#5B7C99")
+SLATEGREEN = ManimColor("#658D6D")
+SLATEGREY = ManimColor("#59656D")
+SLIMEGREEN = ManimColor("#99CC04")
+SNOT = ManimColor("#ACBB0D")
+SNOTGREEN = ManimColor("#9DC100")
+SOFTBLUE = ManimColor("#6488EA")
+SOFTGREEN = ManimColor("#6FC276")
+SOFTPINK = ManimColor("#FDB0C0")
+SOFTPURPLE = ManimColor("#A66FB5")
+SPEARMINT = ManimColor("#1EF876")
+SPRINGGREEN = ManimColor("#A9F971")
+SPRUCE = ManimColor("#0A5F38")
+SQUASH = ManimColor("#F2AB15")
+STEEL = ManimColor("#738595")
+STEELBLUE = ManimColor("#5A7D9A")
+STEELGREY = ManimColor("#6F828A")
+STONE = ManimColor("#ADA587")
+STORMYBLUE = ManimColor("#507B9C")
+STRAW = ManimColor("#FCF679")
+STRAWBERRY = ManimColor("#FB2943")
+STRONGBLUE = ManimColor("#0C06F7")
+STRONGPINK = ManimColor("#FF0789")
+SUNFLOWER = ManimColor("#FFC512")
+SUNFLOWERYELLOW = ManimColor("#FFDA03")
+SUNNYYELLOW = ManimColor("#FFF917")
+SUNSHINEYELLOW = ManimColor("#FFFD37")
+SUNYELLOW = ManimColor("#FFDF22")
+SWAMP = ManimColor("#698339")
+SWAMPGREEN = ManimColor("#748500")
+TAN = ManimColor("#D1B26F")
+TANBROWN = ManimColor("#AB7E4C")
+TANGERINE = ManimColor("#FF9408")
+TANGREEN = ManimColor("#A9BE70")
+TAUPE = ManimColor("#B9A281")
+TEA = ManimColor("#65AB7C")
+TEAGREEN = ManimColor("#BDF8A3")
+TEAL = ManimColor("#029386")
+TEALBLUE = ManimColor("#01889F")
+TEALGREEN = ManimColor("#25A36F")
+TEALISH = ManimColor("#24BCA8")
+TEALISHGREEN = ManimColor("#0CDC73")
+TERRACOTA = ManimColor("#CB6843")
+TERRACOTTA = ManimColor("#C9643B")
+TIFFANYBLUE = ManimColor("#7BF2DA")
+TOMATO = ManimColor("#EF4026")
+TOMATORED = ManimColor("#EC2D01")
+TOPAZ = ManimColor("#13BBAF")
+TOUPE = ManimColor("#C7AC7D")
+TOXICGREEN = ManimColor("#61DE2A")
+TREEGREEN = ManimColor("#2A7E19")
+TRUEBLUE = ManimColor("#010FCC")
+TRUEGREEN = ManimColor("#089404")
+TURQUOISE = ManimColor("#06C2AC")
+TURQUOISEBLUE = ManimColor("#06B1C4")
+TURQUOISEGREEN = ManimColor("#04F489")
+TURTLEGREEN = ManimColor("#75B84F")
+TWILIGHT = ManimColor("#4E518B")
+TWILIGHTBLUE = ManimColor("#0A437A")
+UGLYBLUE = ManimColor("#31668A")
+UGLYBROWN = ManimColor("#7D7103")
+UGLYGREEN = ManimColor("#7A9703")
+UGLYPINK = ManimColor("#CD7584")
+UGLYPURPLE = ManimColor("#A442A0")
+UGLYYELLOW = ManimColor("#D0C101")
+ULTRAMARINE = ManimColor("#2000B1")
+ULTRAMARINEBLUE = ManimColor("#1805DB")
+UMBER = ManimColor("#B26400")
+VELVET = ManimColor("#750851")
+VERMILION = ManimColor("#F4320C")
+VERYDARKBLUE = ManimColor("#000133")
+VERYDARKBROWN = ManimColor("#1D0200")
+VERYDARKGREEN = ManimColor("#062E03")
+VERYDARKPURPLE = ManimColor("#2A0134")
+VERYLIGHTBLUE = ManimColor("#D5FFFF")
+VERYLIGHTBROWN = ManimColor("#D3B683")
+VERYLIGHTGREEN = ManimColor("#D1FFBD")
+VERYLIGHTPINK = ManimColor("#FFF4F2")
+VERYLIGHTPURPLE = ManimColor("#F6CEFC")
+VERYPALEBLUE = ManimColor("#D6FFFE")
+VERYPALEGREEN = ManimColor("#CFFDBC")
+VIBRANTBLUE = ManimColor("#0339F8")
+VIBRANTGREEN = ManimColor("#0ADD08")
+VIBRANTPURPLE = ManimColor("#AD03DE")
+VIOLET = ManimColor("#9A0EEA")
+VIOLETBLUE = ManimColor("#510AC9")
+VIOLETPINK = ManimColor("#FB5FFC")
+VIOLETRED = ManimColor("#A50055")
+VIRIDIAN = ManimColor("#1E9167")
+VIVIDBLUE = ManimColor("#152EFF")
+VIVIDGREEN = ManimColor("#2FEF10")
+VIVIDPURPLE = ManimColor("#9900FA")
+VOMIT = ManimColor("#A2A415")
+VOMITGREEN = ManimColor("#89A203")
+VOMITYELLOW = ManimColor("#C7C10C")
+WARMBLUE = ManimColor("#4B57DB")
+WARMBROWN = ManimColor("#964E02")
+WARMGREY = ManimColor("#978A84")
+WARMPINK = ManimColor("#FB5581")
+WARMPURPLE = ManimColor("#952E8F")
+WASHEDOUTGREEN = ManimColor("#BCF5A6")
+WATERBLUE = ManimColor("#0E87CC")
+WATERMELON = ManimColor("#FD4659")
+WEIRDGREEN = ManimColor("#3AE57F")
+WHEAT = ManimColor("#FBDD7E")
+WHITE = ManimColor("#FFFFFF")
+WINDOWSBLUE = ManimColor("#3778BF")
+WINE = ManimColor("#80013F")
+WINERED = ManimColor("#7B0323")
+WINTERGREEN = ManimColor("#20F986")
+WISTERIA = ManimColor("#A87DC2")
+YELLOW = ManimColor("#FFFF14")
+YELLOWBROWN = ManimColor("#B79400")
+YELLOWGREEN = ManimColor("#BBF90F")
+YELLOWISH = ManimColor("#FAEE66")
+YELLOWISHBROWN = ManimColor("#9B7A01")
+YELLOWISHGREEN = ManimColor("#B0DD16")
+YELLOWISHORANGE = ManimColor("#FFAB0F")
+YELLOWISHTAN = ManimColor("#FCFC81")
+YELLOWOCHRE = ManimColor("#CB9D06")
+YELLOWORANGE = ManimColor("#FCB001")
+YELLOWTAN = ManimColor("#FFE36E")
+YELLOWYBROWN = ManimColor("#AE8B0C")
+YELLOWYGREEN = ManimColor("#BFF128")
diff --git a/data/rag/manim_docs/manim_core/source/utils/color/__init__.py b/data/rag/manim_docs/manim_core/source/utils/color/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e0f36ff442dd2984a1f274d06dfd26f7bb40cec
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/color/__init__.py
@@ -0,0 +1,58 @@
+"""Utilities for working with colors and predefined color constants.
+
+Color data structure
+--------------------
+
+.. autosummary::
+ :toctree: ../reference
+
+ core
+
+
+Predefined colors
+-----------------
+
+There are several predefined colors available in Manim:
+
+- The colors listed in :mod:`.color.manim_colors` are loaded into
+ Manim's global name space.
+- The colors in :mod:`.color.AS2700`, :mod:`.color.BS381`, :mod:`.color.X11`,
+ and :mod:`.color.XKCD` need to be accessed via their module (which are available
+ in Manim's global name space), or imported separately. For example:
+
+ .. code:: pycon
+
+ >>> from manim import XKCD
+ >>> XKCD.AVOCADO
+ ManimColor('#90B134')
+
+ Or, alternatively:
+
+ .. code:: pycon
+
+ >>> from manim.utils.color.XKCD import AVOCADO
+ >>> AVOCADO
+ ManimColor('#90B134')
+
+The following modules contain the predefined color constants:
+
+.. autosummary::
+ :toctree: ../reference
+
+ manim_colors
+ AS2700
+ BS381
+ XKCD
+ X11
+
+"""
+
+from typing import Dict, List
+
+from . import AS2700, BS381, X11, XKCD
+from .core import *
+from .manim_colors import *
+
+_all_color_dict: Dict[str, ManimColor] = {
+ k: v for k, v in globals().items() if isinstance(v, ManimColor)
+}
diff --git a/data/rag/manim_docs/manim_core/source/utils/color/core.py b/data/rag/manim_docs/manim_core/source/utils/color/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..cdd75ad9aeb2267fce225d46e0f00958e8ad6a0a
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/color/core.py
@@ -0,0 +1,1036 @@
+"""Manim's (internal) color data structure and some utilities for
+color conversion.
+
+This module contains the implementation of :class:`.ManimColor`,
+the data structure internally used to represent colors.
+
+The preferred way of using these colors is by importing their constants from manim:
+
+.. code-block:: pycon
+
+ >>> from manim import RED, GREEN, BLUE
+ >>> print(RED)
+ #FC6255
+
+Note this way uses the name of the colors in UPPERCASE.
+
+.. note::
+
+ The colors of type "C" have an alias equal to the colorname without a letter,
+ e.g. GREEN = GREEN_C
+"""
+
+from __future__ import annotations
+
+import colorsys
+
+# logger = _config.logger
+import random
+import re
+from typing import Any, Sequence, TypeVar, Union, overload
+
+import numpy as np
+import numpy.typing as npt
+from typing_extensions import Self, TypeAlias
+
+from manim.typing import (
+ HSV_Array_Float,
+ HSV_Tuple_Float,
+ ManimColorDType,
+ ManimColorInternal,
+ RGB_Array_Float,
+ RGB_Array_Int,
+ RGB_Tuple_Float,
+ RGB_Tuple_Int,
+ RGBA_Array_Float,
+ RGBA_Array_Int,
+ RGBA_Tuple_Float,
+ RGBA_Tuple_Int,
+)
+
+from ...utils.space_ops import normalize
+
+# import manim._config as _config
+
+
+re_hex = re.compile("((?<=#)|(?<=0x))[A-F0-9]{6,8}", re.IGNORECASE)
+
+
+class ManimColor:
+ """Internal representation of a color.
+
+ The ManimColor class is the main class for the representation of a color.
+ It's internal representation is a 4 element array of floats corresponding
+ to a [r,g,b,a] value where r,g,b,a can be between 0 to 1.
+
+ This is done in order to reduce the amount of color inconsitencies by constantly
+ casting between integers and floats which introduces errors.
+
+ The class can accept any value of type :class:`ParsableManimColor` i.e.
+
+ ManimColor, int, str, RGB_Tuple_Int, RGB_Tuple_Float, RGBA_Tuple_Int, RGBA_Tuple_Float, RGB_Array_Int,
+ RGB_Array_Float, RGBA_Array_Int, RGBA_Array_Float
+
+ ManimColor itself only accepts singular values and will directly interpret them into a single color if possible
+ Be careful when passing strings to ManimColor it can create a big overhead for the color processing.
+
+ If you want to parse a list of colors use the function :meth:`parse` in :class:`ManimColor` which assumes that
+ you are going to pass a list of color so arrays will not bei interpreted as a single color.
+
+ .. warning::
+ If you pass an array of numbers to :meth:`parse` it will interpret the r,g,b,a numbers in that array as colors
+ so instead of the expect singular color you get and array with 4 colors.
+
+ For conversion behaviors see the _internal functions for further documentation
+
+ Parameters
+ ----------
+ value
+ Some representation of a color (e.g., a string or
+ a suitable tuple).
+ alpha
+ The opacity of the color. By default, colors are
+ fully opaque (value 1.0).
+ """
+
+ def __init__(
+ self,
+ value: ParsableManimColor | None,
+ alpha: float = 1.0,
+ ) -> None:
+ if value is None:
+ self._internal_value = np.array((0, 0, 0, alpha), dtype=ManimColorDType)
+ elif isinstance(value, ManimColor):
+ # logger.info(
+ # "ManimColor was passed another ManimColor. This is probably not what "
+ # "you want. Created a copy of the passed ManimColor instead."
+ # )
+ self._internal_value = value._internal_value
+ elif isinstance(value, int):
+ self._internal_value = ManimColor._internal_from_integer(value, alpha)
+ elif isinstance(value, str):
+ result = re_hex.search(value)
+ if result is not None:
+ self._internal_value = ManimColor._internal_from_hex_string(
+ result.group(), alpha
+ )
+ else:
+ # This is not expected to be called on module initialization time
+ # It can be horribly slow to convert a string to a color because
+ # it has to access the dictionary of colors and find the right color
+ self._internal_value = ManimColor._internal_from_string(value)
+ elif isinstance(value, (list, tuple, np.ndarray)):
+ length = len(value)
+ if all(isinstance(x, float) for x in value):
+ if length == 3:
+ self._internal_value = ManimColor._internal_from_rgb(value, alpha) # type: ignore
+ elif length == 4:
+ self._internal_value = ManimColor._internal_from_rgba(value) # type: ignore
+ else:
+ raise ValueError(
+ f"ManimColor only accepts lists/tuples/arrays of length 3 or 4, not {length}"
+ )
+ else:
+ if length == 3:
+ self._internal_value = ManimColor._internal_from_int_rgb(
+ value, alpha # type: ignore
+ )
+ elif length == 4:
+ self._internal_value = ManimColor._internal_from_int_rgba(value) # type: ignore
+ else:
+ raise ValueError(
+ f"ManimColor only accepts lists/tuples/arrays of length 3 or 4, not {length}"
+ )
+ elif hasattr(value, "get_hex") and callable(value.get_hex):
+ result = re_hex.search(value.get_hex())
+ if result is None:
+ raise ValueError(f"Failed to parse a color from {value}")
+
+ self._internal_value = ManimColor._internal_from_hex_string(
+ result.group(), alpha
+ )
+ else:
+ # logger.error(f"Invalid color value: {value}")
+ raise TypeError(
+ "ManimColor only accepts int, str, list[int, int, int], "
+ "list[int, int, int, int], list[float, float, float], "
+ f"list[float, float, float, float], not {type(value)}"
+ )
+
+ @property
+ def _internal_value(self) -> ManimColorInternal:
+ """Returns the internal value of the current Manim color [r,g,b,a] float array
+
+ Returns
+ -------
+ ManimColorInternal
+ internal color representation
+ """
+ return self.__value
+
+ @_internal_value.setter
+ def _internal_value(self, value: ManimColorInternal) -> None:
+ """Overwrites the internal color value of the ManimColor object
+
+ Parameters
+ ----------
+ value : ManimColorInternal
+ The value which will overwrite the current color
+
+ Raises
+ ------
+ TypeError
+ Raises a TypeError if an invalid array is passed
+ """
+ if not isinstance(value, np.ndarray):
+ raise TypeError("value must be a numpy array")
+ if value.shape[0] != 4:
+ raise TypeError("Array must have 4 values exactly")
+ self.__value: ManimColorInternal = value
+
+ @staticmethod
+ def _internal_from_integer(value: int, alpha: float) -> ManimColorInternal:
+ return np.asarray(
+ (
+ ((value >> 16) & 0xFF) / 255,
+ ((value >> 8) & 0xFF) / 255,
+ ((value >> 0) & 0xFF) / 255,
+ alpha,
+ ),
+ dtype=ManimColorDType,
+ )
+
+ # TODO: Maybe make 8 nibble hex also convertible ?
+ @staticmethod
+ def _internal_from_hex_string(hex: str, alpha: float) -> ManimColorInternal:
+ """Internal function for converting a hex string into the internal representation of a ManimColor.
+
+ .. warning::
+ This does not accept any prefixes like # or similar in front of the hex string.
+ This is just intended for the raw hex part
+
+ *For internal use only*
+
+ Parameters
+ ----------
+ hex : str
+ hex string to be parsed
+ alpha : float
+ alpha value used for the color
+
+ Returns
+ -------
+ ManimColorInternal
+ Internal color representation
+ """
+ if len(hex) == 6:
+ hex += "00"
+ tmp = int(hex, 16)
+ return np.asarray(
+ (
+ ((tmp >> 24) & 0xFF) / 255,
+ ((tmp >> 16) & 0xFF) / 255,
+ ((tmp >> 8) & 0xFF) / 255,
+ alpha,
+ ),
+ dtype=ManimColorDType,
+ )
+
+ @staticmethod
+ def _internal_from_int_rgb(
+ rgb: RGB_Tuple_Int, alpha: float = 1.0
+ ) -> ManimColorInternal:
+ """Internal function for converting a rgb tuple of integers into the internal representation of a ManimColor.
+
+ *For internal use only*
+
+ Parameters
+ ----------
+ rgb : RGB_Tuple_Int
+ integer rgb tuple to be parsed
+ alpha : float, optional
+ optional alpha value, by default 1.0
+
+ Returns
+ -------
+ ManimColorInternal
+ Internal color representation
+
+ """
+ value: np.ndarray = np.asarray(rgb, dtype=ManimColorDType).copy() / 255
+ value.resize(4, refcheck=False)
+ value[3] = alpha
+ return value
+
+ @staticmethod
+ def _internal_from_rgb(
+ rgb: RGB_Tuple_Float, alpha: float = 1.0
+ ) -> ManimColorInternal:
+ """Internal function for converting a rgb tuple of floats into the internal representation of a ManimColor.
+
+ *For internal use only*
+
+ Parameters
+ ----------
+ rgb : RGB_Tuple_Float
+ float rgb tuple to be parsed
+
+ alpha : float, optional
+ optional alpha value, by default 1.0
+
+ Returns
+ -------
+ ManimColorInternal
+ Internal color representation
+ """
+ value: np.ndarray = np.asarray(rgb, dtype=ManimColorDType).copy()
+ value.resize(4, refcheck=False)
+ value[3] = alpha
+ return value
+
+ @staticmethod
+ def _internal_from_int_rgba(rgba: RGBA_Tuple_Int) -> ManimColorInternal:
+ """Internal function for converting a rgba tuple of integers into the internal representation of a ManimColor.
+
+ *For internal use only*
+
+ Parameters
+ ----------
+ rgba : RGBA_Tuple_Int
+ int rgba tuple to be parsed
+
+ Returns
+ -------
+ ManimColorInternal
+ Internal color representation
+ """
+ return np.asarray(rgba, dtype=ManimColorDType) / 255
+
+ @staticmethod
+ def _internal_from_rgba(rgba: RGBA_Tuple_Float) -> ManimColorInternal:
+ """Internal function for converting a rgba tuple of floats into the internal representation of a ManimColor.
+
+ *For internal use only*
+
+ Parameters
+ ----------
+ rgba : RGBA_Tuple_Float
+ int rgba tuple to be parsed
+
+ Returns
+ -------
+ ManimColorInternal
+ Internal color representation
+ """
+ return np.asarray(rgba, dtype=ManimColorDType)
+
+ @staticmethod
+ def _internal_from_string(name: str) -> ManimColorInternal:
+ """Internal function for converting a string into the internal representation of a ManimColor.
+ This is not used for hex strings, please refer to :meth:`_internal_from_hex` for this functionality.
+
+ *For internal use only*
+
+ Parameters
+ ----------
+ name : str
+ The color name to be parsed into a color. Refer to the different color Modules in the documentation Page to
+ find the corresponding Color names.
+
+ Returns
+ -------
+ ManimColorInternal
+ Internal color representation
+
+ Raises
+ ------
+ ValueError
+ Raises a ValueError if the color name is not present with manim
+ """
+ from . import _all_color_dict
+
+ upper_name = name.upper()
+
+ if upper_name in _all_color_dict:
+ return _all_color_dict[upper_name]._internal_value
+ else:
+ raise ValueError(f"Color {name} not found")
+
+ def to_integer(self) -> int:
+ """Converts the current ManimColor into an integer
+
+ Returns
+ -------
+ int
+ integer representation of the color
+
+ .. warning::
+ This will return only the rgb part of the color
+ """
+ return int.from_bytes(
+ (self._internal_value[:3] * 255).astype(int).tobytes(), "big"
+ )
+
+ def to_rgb(self) -> RGB_Array_Float:
+ """Converts the current ManimColor into a rgb array of floats
+
+ Returns
+ -------
+ RGB_Array_Float
+ rgb array with 3 elements of type float
+ """
+ return self._internal_value[:3]
+
+ def to_int_rgb(self) -> RGB_Array_Int:
+ """Converts the current ManimColor into a rgb array of int
+
+ Returns
+ -------
+ RGB_Array_Int
+ rgb array with 3 elements of type int
+ """
+ return (self._internal_value[:3] * 255).astype(int)
+
+ def to_rgba(self) -> RGBA_Array_Float:
+ """Converts the current ManimColor into a rgba array of floats
+
+ Returns
+ -------
+ RGBA_Array_Float
+ rgba array with 4 elements of type float
+ """
+ return self._internal_value
+
+ def to_int_rgba(self) -> RGBA_Array_Int:
+ """Converts the current ManimColor into a rgba array of int
+
+
+ Returns
+ -------
+ RGBA_Array_Int
+ rgba array with 4 elements of type int
+ """
+ return (self._internal_value * 255).astype(int)
+
+ def to_rgba_with_alpha(self, alpha: float) -> RGBA_Array_Float:
+ """Converts the current ManimColor into a rgba array of float as :meth:`to_rgba` but you can change the alpha
+ value.
+
+ Parameters
+ ----------
+ alpha : float
+ alpha value to be used in the return value
+
+ Returns
+ -------
+ RGBA_Array_Float
+ rgba array with 4 elements of type float
+ """
+ return np.fromiter((*self._internal_value[:3], alpha), dtype=ManimColorDType)
+
+ def to_int_rgba_with_alpha(self, alpha: float) -> RGBA_Array_Int:
+ """Converts the current ManimColor into a rgba array of integers as :meth:`to_int_rgba` but you can change the alpha
+ value.
+
+ Parameters
+ ----------
+ alpha : float
+ alpha value to be used for the return value. (Will automatically be scaled from 0-1 to 0-255 so just pass 0-1)
+
+ Returns
+ -------
+ RGBA_Array_Int
+ rgba array with 4 elements of type int
+ """
+ tmp = self._internal_value * 255
+ tmp[3] = alpha * 255
+ return tmp.astype(int)
+
+ def to_hex(self, with_alpha: bool = False) -> str:
+ """Converts the manim color to a hexadecimal representation of the color
+
+ Parameters
+ ----------
+ with_alpha : bool, optional
+ Changes the result from 6 to 8 values where the last 2 nibbles represent the alpha value of 0-255,
+ by default False
+
+ Returns
+ -------
+ str
+ A hex string starting with a # with either 6 or 8 nibbles depending on your input, by default 6 i.e #XXXXXX
+ """
+ tmp = f"#{int(self._internal_value[0]*255):02X}{int(self._internal_value[1]*255):02X}{int(self._internal_value[2]*255):02X}"
+ if with_alpha:
+ tmp += f"{int(self._internal_value[3]*255):02X}"
+ return tmp
+
+ def to_hsv(self) -> HSV_Array_Float:
+ """Converts the Manim Color to HSV array.
+
+ .. note::
+ Be careful this returns an array in the form `[h, s, v]` where the elements are floats.
+ This might be confusing because rgb can also be an array of floats so you might want to annotate the usage
+ of this function in your code by typing the variables with :class:`HSV_Array_Float` in order to differentiate
+ between rgb arrays and hsv arrays
+
+ Returns
+ -------
+ HSV_Array_Float
+ A hsv array containing 3 elements of type float ranging from 0 to 1
+ """
+ return colorsys.rgb_to_hsv(*self.to_rgb())
+
+ def invert(self, with_alpha=False) -> ManimColor:
+ """Returns an linearly inverted version of the color (no inplace changes)
+
+ Parameters
+ ----------
+ with_alpha : bool, optional
+ if true the alpha value will be inverted too, by default False
+
+ .. note::
+ This can result in unintended behavior where objects are not displayed because their alpha
+ value is suddenly 0 or very low. Please keep that in mind when setting this to true
+
+ Returns
+ -------
+ ManimColor
+ The linearly inverted ManimColor
+ """
+ return ManimColor(1.0 - self._internal_value, with_alpha)
+
+ def interpolate(self, other: ManimColor, alpha: float) -> ManimColor:
+ """Interpolates between the current and the given ManimColor an returns the interpolated color
+
+ Parameters
+ ----------
+ other : ManimColor
+ The other ManimColor to be used for interpolation
+ alpha : float
+ A point on the line in rgba colorspace connecting the two colors i.e. the interpolation point
+
+ 0 corresponds to the current ManimColor and 1 corresponds to the other ManimColor
+
+ Returns
+ -------
+ ManimColor
+ The interpolated ManimColor
+ """
+ return ManimColor(
+ self._internal_value * (1 - alpha) + other._internal_value * alpha
+ )
+
+ @classmethod
+ def from_rgb(
+ cls,
+ rgb: RGB_Array_Float | RGB_Tuple_Float | RGB_Array_Int | RGB_Tuple_Int,
+ alpha: float = 1.0,
+ ) -> Self:
+ """Creates a ManimColor from an RGB Array. Automagically decides which type it is int/float
+
+ .. warning::
+ Please make sure that your elements are not floats if you want integers. A 5.0 will result in the input
+ being interpreted as if it was a float rgb array with the value 5.0 and not the integer 5
+
+
+ Parameters
+ ----------
+ rgb : RGB_Array_Float | RGB_Tuple_Float | RGB_Array_Int | RGB_Tuple_Int
+ Any 3 Element Iterable
+ alpha : float, optional
+ alpha value to be used in the color, by default 1.0
+
+ Returns
+ -------
+ ManimColor
+ Returns the ManimColor object
+ """
+ return cls(rgb, alpha)
+
+ @classmethod
+ def from_rgba(
+ cls, rgba: RGBA_Array_Float | RGBA_Tuple_Float | RGBA_Array_Int | RGBA_Tuple_Int
+ ) -> Self:
+ """Creates a ManimColor from an RGBA Array. Automagically decides which type it is int/float
+
+ .. warning::
+ Please make sure that your elements are not floats if you want integers. A 5.0 will result in the input
+ being interpreted as if it was a float rgb array with the value 5.0 and not the integer 5
+
+ Parameters
+ ----------
+ rgba : RGBA_Array_Float | RGBA_Tuple_Float | RGBA_Array_Int | RGBA_Tuple_Int
+ Any 4 Element Iterable
+
+ Returns
+ -------
+ ManimColor
+ Returns the ManimColor object
+ """
+ return cls(rgba)
+
+ @classmethod
+ def from_hex(cls, hex: str, alpha: float = 1.0) -> Self:
+ """Creates a Manim Color from a hex string, prefixes allowed # and 0x
+
+ Parameters
+ ----------
+ hex : str
+ The hex string to be converted (currently only supports 6 nibbles)
+ alpha : float, optional
+ alpha value to be used for the hex string, by default 1.0
+
+ Returns
+ -------
+ ManimColor
+ The ManimColor represented by the hex string
+ """
+ return cls(hex, alpha)
+
+ @classmethod
+ def from_hsv(
+ cls, hsv: HSV_Array_Float | HSV_Tuple_Float, alpha: float = 1.0
+ ) -> Self:
+ """Creates a ManimColor from an HSV Array
+
+ Parameters
+ ----------
+ hsv : HSV_Array_Float | HSV_Tuple_Float
+ Any 3 Element Iterable containing floats from 0-1
+ alpha : float, optional
+ the alpha value to be used, by default 1.0
+
+ Returns
+ -------
+ ManimColor
+ The ManimColor with the corresponding RGB values to the HSV
+ """
+ rgb = colorsys.hsv_to_rgb(*hsv)
+ return cls(rgb, alpha)
+
+ @overload
+ @classmethod
+ def parse(
+ cls,
+ color: ParsableManimColor | None,
+ alpha: float = ...,
+ ) -> Self:
+ ...
+
+ @overload
+ @classmethod
+ def parse(
+ cls,
+ color: Sequence[ParsableManimColor],
+ alpha: float = ...,
+ ) -> list[Self]:
+ ...
+
+ @classmethod
+ def parse(
+ cls,
+ color: ParsableManimColor | list[ParsableManimColor] | None,
+ alpha: float = 1.0,
+ ) -> Self | list[Self]:
+ """
+ Handles the parsing of a list of colors or a single color.
+
+ Parameters
+ ----------
+ color
+ The color or list of colors to parse. Note that this function can not accept rgba tuples. It will assume that you mean list[ManimColor] and will return a list of ManimColors.
+ alpha
+ The alpha value to use if a single color is passed. or if a list of colors is passed to set the value of all colors.
+
+ Returns
+ -------
+ ManimColor
+ Either a list of colors or a singular color depending on the input
+ """
+ if isinstance(color, (list, tuple)):
+ return [cls(c, alpha) for c in color] # type: ignore
+ return cls(color, alpha) # type: ignore
+
+ @staticmethod
+ def gradient(colors: list[ManimColor], length: int):
+ """This is not implemented by now refer to :func:`color_gradient` for a working implementation for now"""
+ # TODO: implement proper gradient, research good implementation for this or look at 3b1b implementation
+ raise NotImplementedError
+
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}('{self.to_hex()}')"
+
+ def __str__(self) -> str:
+ return f"{self.to_hex()}"
+
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, ManimColor):
+ raise TypeError(
+ f"Cannot compare {self.__class__.__name__} with {other.__class__.__name__}"
+ )
+ return np.allclose(self._internal_value, other._internal_value)
+
+ def __add__(self, other: ManimColor) -> ManimColor:
+ return ManimColor(self._internal_value + other._internal_value)
+
+ def __sub__(self, other: ManimColor) -> ManimColor:
+ return ManimColor(self._internal_value - other._internal_value)
+
+ def __mul__(self, other: ManimColor) -> ManimColor:
+ return ManimColor(self._internal_value * other._internal_value)
+
+ def __truediv__(self, other: ManimColor) -> ManimColor:
+ return ManimColor(self._internal_value / other._internal_value)
+
+ def __floordiv__(self, other: ManimColor) -> ManimColor:
+ return ManimColor(self._internal_value // other._internal_value)
+
+ def __mod__(self, other: ManimColor) -> ManimColor:
+ return ManimColor(self._internal_value % other._internal_value)
+
+ def __pow__(self, other: ManimColor) -> ManimColor:
+ return ManimColor(self._internal_value**other._internal_value)
+
+ def __and__(self, other: ManimColor) -> ManimColor:
+ return ManimColor(self.to_integer() & other.to_integer())
+
+ def __or__(self, other: ManimColor) -> ManimColor:
+ return ManimColor(self.to_integer() | other.to_integer())
+
+ def __xor__(self, other: ManimColor) -> ManimColor:
+ return ManimColor(self.to_integer() ^ other.to_integer())
+
+
+ParsableManimColor: TypeAlias = Union[
+ ManimColor,
+ int,
+ str,
+ RGB_Tuple_Int,
+ RGB_Tuple_Float,
+ RGBA_Tuple_Int,
+ RGBA_Tuple_Float,
+ RGB_Array_Int,
+ RGB_Array_Float,
+ RGBA_Array_Int,
+ RGBA_Array_Float,
+]
+"""ParsableManimColor is the representation for all types that are parsable to a color in manim"""
+
+
+ManimColorT = TypeVar("ManimColorT", bound=ManimColor)
+
+
+def color_to_rgb(color: ParsableManimColor) -> RGB_Array_Float:
+ """Helper function for use in functional style programming refer to :meth:`to_rgb` in :class:`ManimColor`
+
+ Parameters
+ ----------
+ color : ParsableManimColor
+ A color
+
+ Returns
+ -------
+ RGB_Array_Float
+ the corresponding rgb array
+ """
+ return ManimColor(color).to_rgb()
+
+
+def color_to_rgba(color: ParsableManimColor, alpha: float = 1) -> RGBA_Array_Float:
+ """Helper function for use in functional style programming refer to :meth:`to_rgba_with_alpha` in :class:`ManimColor`
+
+ Parameters
+ ----------
+ color : ParsableManimColor
+ A color
+ alpha : float, optional
+ alpha value to be used in the color, by default 1
+
+ Returns
+ -------
+ RGBA_Array_Float
+ the corresponding rgba array
+ """
+ return ManimColor(color).to_rgba_with_alpha(alpha)
+
+
+def color_to_int_rgb(color: ParsableManimColor) -> RGB_Array_Int:
+ """Helper function for use in functional style programming refer to :meth:`to_int_rgb` in :class:`ManimColor`
+
+ Parameters
+ ----------
+ color : ParsableManimColor
+ A color
+
+ Returns
+ -------
+ RGB_Array_Int
+ the corresponding int rgb array
+ """
+ return ManimColor(color).to_int_rgb()
+
+
+def color_to_int_rgba(color: ParsableManimColor, alpha: float = 1.0) -> RGBA_Array_Int:
+ """Helper function for use in functional style programming refer to :meth:`to_int_rgba_with_alpha` in :class:`ManimColor`
+
+ Parameters
+ ----------
+ color : ParsableManimColor
+ A color
+ alpha : float, optional
+ alpha value to be used in the color, by default 1.0
+
+ Returns
+ -------
+ RGBA_Array_Int
+ the corresponding int rgba array
+ """
+ return ManimColor(color).to_int_rgba_with_alpha(alpha)
+
+
+def rgb_to_color(
+ rgb: RGB_Array_Float | RGB_Tuple_Float | RGB_Array_Int | RGB_Tuple_Int,
+) -> ManimColor:
+ """Helper function for use in functional style programming refer to :meth:`from_rgb` in :class:`ManimColor`
+
+ Parameters
+ ----------
+ rgb : RGB_Array_Float | RGB_Tuple_Float
+ A 3 element iterable
+
+ Returns
+ -------
+ ManimColor
+ A ManimColor with the corresponding value
+ """
+ return ManimColor.from_rgb(rgb)
+
+
+def rgba_to_color(
+ rgba: RGBA_Array_Float | RGBA_Tuple_Float | RGBA_Array_Int | RGBA_Tuple_Int,
+) -> ManimColor:
+ """Helper function for use in functional style programming refer to :meth:`from_rgba` in :class:`ManimColor`
+
+ Parameters
+ ----------
+ rgba : RGBA_Array_Float | RGBA_Tuple_Float
+ A 4 element iterable
+
+ Returns
+ -------
+ ManimColor
+ A ManimColor with the corresponding value
+ """
+ return ManimColor.from_rgba(rgba)
+
+
+def rgb_to_hex(
+ rgb: RGB_Array_Float | RGB_Tuple_Float | RGB_Array_Int | RGB_Tuple_Int,
+) -> str:
+ """Helper function for use in functional style programming refer to :meth:`from_rgb` in :class:`ManimColor`
+
+ Parameters
+ ----------
+ rgb : RGB_Array_Float | RGB_Tuple_Float
+ A 3 element iterable
+
+ Returns
+ -------
+ str
+ A hex representation of the color, refer to :meth:`to_hex` in :class:`ManimColor`
+ """
+ return ManimColor.from_rgb(rgb).to_hex()
+
+
+def hex_to_rgb(hex_code: str) -> RGB_Array_Float:
+ """Helper function for use in functional style programming refer to :meth:`to_hex` in :class:`ManimColor`
+
+ Parameters
+ ----------
+ hex_code : str
+ A hex string representing a color
+
+ Returns
+ -------
+ RGB_Array_Float
+ RGB array representing the color
+ """
+ return ManimColor(hex_code).to_rgb()
+
+
+def invert_color(color: ManimColorT) -> ManimColorT:
+ """Helper function for use in functional style programming refer to :meth:`invert` in :class:`ManimColor`
+
+ Parameters
+ ----------
+ color : ManimColor
+ A ManimColor
+
+ Returns
+ -------
+ ManimColor
+ The linearly inverted ManimColor
+ """
+ return color.invert()
+
+
+def interpolate_arrays(
+ arr1: npt.NDArray[Any], arr2: npt.NDArray[Any], alpha: float
+) -> np.ndarray:
+ """Helper function used in Manim to fade between two objects smoothly
+
+ Parameters
+ ----------
+ arr1 : npt.NDArray[Any]
+ The first array of colors
+ arr2 : npt.NDArray[Any]
+ The second array of colors
+ alpha : float
+ The alpha value corresponding to the interpolation point between the two inputs
+
+ Returns
+ -------
+ np.ndarray
+ The interpolated value of the to arrays
+ """
+ return (1 - alpha) * arr1 + alpha * arr2
+
+
+def color_gradient(
+ reference_colors: Sequence[ParsableManimColor],
+ length_of_output: int,
+) -> list[ManimColor] | ManimColor:
+ """Creates a list of colors interpolated between the input array of colors with a specific number of colors
+
+ Parameters
+ ----------
+ reference_colors : Sequence[ParsableManimColor]
+ The colors to be interpolated between or spread apart
+ length_of_output : int
+ The number of colors that the output should have, ideally more than the input
+
+ Returns
+ -------
+ list[ManimColor] | ManimColor
+ A list of ManimColor's which has the interpolated colors
+ """
+ if length_of_output == 0:
+ return ManimColor(reference_colors[0])
+ if len(reference_colors) == 1:
+ return [ManimColor(reference_colors[0])] * length_of_output
+ rgbs = [color_to_rgb(color) for color in reference_colors]
+ alphas = np.linspace(0, (len(rgbs) - 1), length_of_output)
+ floors = alphas.astype("int")
+ alphas_mod1 = alphas % 1
+ # End edge case
+ alphas_mod1[-1] = 1
+ floors[-1] = len(rgbs) - 2
+ return [
+ rgb_to_color((rgbs[i] * (1 - alpha)) + (rgbs[i + 1] * alpha))
+ for i, alpha in zip(floors, alphas_mod1)
+ ]
+
+
+def interpolate_color(
+ color1: ManimColorT, color2: ManimColor, alpha: float
+) -> ManimColorT:
+ """Standalone function to interpolate two ManimColors and get the result refer to :meth:`interpolate` in :class:`ManimColor`
+
+ Parameters
+ ----------
+ color1 : ManimColor
+ First ManimColor
+ color2 : ManimColor
+ Second ManimColor
+ alpha : float
+ The alpha value determining the point of interpolation between the colors
+
+ Returns
+ -------
+ ManimColor
+ The interpolated ManimColor
+ """
+ return color1.interpolate(color2, alpha)
+
+
+def average_color(*colors: ParsableManimColor) -> ManimColor:
+ """Determines the Average color of the given parameters
+
+ Returns
+ -------
+ ManimColor
+ The average color of the input
+ """
+ rgbs = np.array([color_to_rgb(color) for color in colors])
+ mean_rgb = np.apply_along_axis(np.mean, 0, rgbs)
+ return rgb_to_color(mean_rgb)
+
+
+def random_bright_color() -> ManimColor:
+ """Returns you a random bright color
+
+ .. warning::
+ This operation is very expensive please keep in mind the performance loss.
+
+ Returns
+ -------
+ ManimColor
+ A bright ManimColor
+ """
+ curr_rgb = color_to_rgb(random_color())
+ new_rgb = interpolate_arrays(curr_rgb, np.ones(len(curr_rgb)), 0.5)
+ return ManimColor(new_rgb)
+
+
+def random_color() -> ManimColor:
+ """Return you a random ManimColor
+
+ .. warning::
+ This operation is very expensive please keep in mind the performance loss.
+
+ Returns
+ -------
+ ManimColor
+ _description_
+ """
+ import manim.utils.color.manim_colors as manim_colors
+
+ return random.choice(manim_colors._all_manim_colors)
+
+
+def get_shaded_rgb(
+ rgb: npt.NDArray[Any],
+ point: npt.NDArray[Any],
+ unit_normal_vect: npt.NDArray[Any],
+ light_source: npt.NDArray[Any],
+) -> RGBA_Array_Float:
+ to_sun = normalize(light_source - point)
+ factor = 0.5 * np.dot(unit_normal_vect, to_sun) ** 3
+ if factor < 0:
+ factor *= 0.5
+ result = rgb + factor
+ return result
+
+
+__all__ = [
+ "ManimColor",
+ "ManimColorDType",
+ "ParsableManimColor",
+ "color_to_rgb",
+ "color_to_rgba",
+ "color_to_int_rgb",
+ "color_to_int_rgba",
+ "rgb_to_color",
+ "rgba_to_color",
+ "rgb_to_hex",
+ "hex_to_rgb",
+ "invert_color",
+ "interpolate_arrays",
+ "color_gradient",
+ "interpolate_color",
+ "average_color",
+ "random_bright_color",
+ "random_color",
+ "get_shaded_rgb",
+]
diff --git a/data/rag/manim_docs/manim_core/source/utils/color/manim_colors.py b/data/rag/manim_docs/manim_core/source/utils/color/manim_colors.py
new file mode 100644
index 0000000000000000000000000000000000000000..42c93985e62e3de71697f049f721170195f5fdfb
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/color/manim_colors.py
@@ -0,0 +1,220 @@
+"""Colors included in the global name space.
+
+These colors form Manim's default color space.
+
+.. manim:: ColorsOverview
+ :save_last_frame:
+ :hide_source:
+
+ import manim.utils.color.manim_colors as Colors
+
+ class ColorsOverview(Scene):
+ def construct(self):
+ def color_group(color):
+ group = VGroup(
+ *[
+ Line(ORIGIN, RIGHT * 1.5, stroke_width=35, color=getattr(Colors, name.upper()))
+ for name in subnames(color)
+ ]
+ ).arrange_submobjects(buff=0.4, direction=DOWN)
+
+ name = Text(color).scale(0.6).next_to(group, UP, buff=0.3)
+ if any(decender in color for decender in "gjpqy"):
+ name.shift(DOWN * 0.08)
+ group.add(name)
+ return group
+
+ def subnames(name):
+ return [name + "_" + char for char in "abcde"]
+
+ color_groups = VGroup(
+ *[
+ color_group(color)
+ for color in [
+ "blue",
+ "teal",
+ "green",
+ "yellow",
+ "gold",
+ "red",
+ "maroon",
+ "purple",
+ ]
+ ]
+ ).arrange_submobjects(buff=0.2, aligned_edge=DOWN)
+
+ for line, char in zip(color_groups[0], "abcde"):
+ color_groups.add(Text(char).scale(0.6).next_to(line, LEFT, buff=0.2))
+
+ def named_lines_group(length, colors, names, text_colors, align_to_block):
+ lines = VGroup(
+ *[
+ Line(
+ ORIGIN,
+ RIGHT * length,
+ stroke_width=55,
+ color=getattr(Colors, color.upper()),
+ )
+ for color in colors
+ ]
+ ).arrange_submobjects(buff=0.6, direction=DOWN)
+
+ for line, name, color in zip(lines, names, text_colors):
+ line.add(Text(name, color=color).scale(0.6).move_to(line))
+ lines.next_to(color_groups, DOWN, buff=0.5).align_to(
+ color_groups[align_to_block], LEFT
+ )
+ return lines
+
+ other_colors = (
+ "pink",
+ "light_pink",
+ "orange",
+ "light_brown",
+ "dark_brown",
+ "gray_brown",
+ )
+
+ other_lines = named_lines_group(
+ 3.2,
+ other_colors,
+ other_colors,
+ [BLACK] * 4 + [WHITE] * 2,
+ 0,
+ )
+
+ gray_lines = named_lines_group(
+ 6.6,
+ ["white"] + subnames("gray") + ["black"],
+ [
+ "white",
+ "lighter_gray / gray_a",
+ "light_gray / gray_b",
+ "gray / gray_c",
+ "dark_gray / gray_d",
+ "darker_gray / gray_e",
+ "black",
+ ],
+ [BLACK] * 3 + [WHITE] * 4,
+ 2,
+ )
+
+ pure_colors = (
+ "pure_red",
+ "pure_green",
+ "pure_blue",
+ )
+
+ pure_lines = named_lines_group(
+ 3.2,
+ pure_colors,
+ pure_colors,
+ [BLACK, BLACK, WHITE],
+ 6,
+ )
+
+ self.add(color_groups, other_lines, gray_lines, pure_lines)
+
+ VGroup(*self.mobjects).move_to(ORIGIN)
+
+.. automanimcolormodule:: manim.utils.color.manim_colors
+
+"""
+
+from typing import List
+
+from .core import ManimColor
+
+WHITE = ManimColor("#FFFFFF")
+GRAY_A = ManimColor("#DDDDDD")
+GREY_A = ManimColor("#DDDDDD")
+GRAY_B = ManimColor("#BBBBBB")
+GREY_B = ManimColor("#BBBBBB")
+GRAY_C = ManimColor("#888888")
+GREY_C = ManimColor("#888888")
+GRAY_D = ManimColor("#444444")
+GREY_D = ManimColor("#444444")
+GRAY_E = ManimColor("#222222")
+GREY_E = ManimColor("#222222")
+BLACK = ManimColor("#000000")
+LIGHTER_GRAY = ManimColor("#DDDDDD")
+LIGHTER_GREY = ManimColor("#DDDDDD")
+LIGHT_GRAY = ManimColor("#BBBBBB")
+LIGHT_GREY = ManimColor("#BBBBBB")
+GRAY = ManimColor("#888888")
+GREY = ManimColor("#888888")
+DARK_GRAY = ManimColor("#444444")
+DARK_GREY = ManimColor("#444444")
+DARKER_GRAY = ManimColor("#222222")
+DARKER_GREY = ManimColor("#222222")
+BLUE_A = ManimColor("#C7E9F1")
+BLUE_B = ManimColor("#9CDCEB")
+BLUE_C = ManimColor("#58C4DD")
+BLUE_D = ManimColor("#29ABCA")
+BLUE_E = ManimColor("#236B8E")
+PURE_BLUE = ManimColor("#0000FF")
+BLUE = ManimColor("#58C4DD")
+DARK_BLUE = ManimColor("#236B8E")
+TEAL_A = ManimColor("#ACEAD7")
+TEAL_B = ManimColor("#76DDC0")
+TEAL_C = ManimColor("#5CD0B3")
+TEAL_D = ManimColor("#55C1A7")
+TEAL_E = ManimColor("#49A88F")
+TEAL = ManimColor("#5CD0B3")
+GREEN_A = ManimColor("#C9E2AE")
+GREEN_B = ManimColor("#A6CF8C")
+GREEN_C = ManimColor("#83C167")
+GREEN_D = ManimColor("#77B05D")
+GREEN_E = ManimColor("#699C52")
+PURE_GREEN = ManimColor("#00FF00")
+GREEN = ManimColor("#83C167")
+YELLOW_A = ManimColor("#FFF1B6")
+YELLOW_B = ManimColor("#FFEA94")
+YELLOW_C = ManimColor("#FFFF00")
+YELLOW_D = ManimColor("#F4D345")
+YELLOW_E = ManimColor("#E8C11C")
+YELLOW = ManimColor("#FFFF00")
+GOLD_A = ManimColor("#F7C797")
+GOLD_B = ManimColor("#F9B775")
+GOLD_C = ManimColor("#F0AC5F")
+GOLD_D = ManimColor("#E1A158")
+GOLD_E = ManimColor("#C78D46")
+GOLD = ManimColor("#F0AC5F")
+RED_A = ManimColor("#F7A1A3")
+RED_B = ManimColor("#FF8080")
+RED_C = ManimColor("#FC6255")
+RED_D = ManimColor("#E65A4C")
+RED_E = ManimColor("#CF5044")
+PURE_RED = ManimColor("#FF0000")
+RED = ManimColor("#FC6255")
+MAROON_A = ManimColor("#ECABC1")
+MAROON_B = ManimColor("#EC92AB")
+MAROON_C = ManimColor("#C55F73")
+MAROON_D = ManimColor("#A24D61")
+MAROON_E = ManimColor("#94424F")
+MAROON = ManimColor("#C55F73")
+PURPLE_A = ManimColor("#CAA3E8")
+PURPLE_B = ManimColor("#B189C6")
+PURPLE_C = ManimColor("#9A72AC")
+PURPLE_D = ManimColor("#715582")
+PURPLE_E = ManimColor("#644172")
+PURPLE = ManimColor("#9A72AC")
+PINK = ManimColor("#D147BD")
+LIGHT_PINK = ManimColor("#DC75CD")
+ORANGE = ManimColor("#FF862F")
+LIGHT_BROWN = ManimColor("#CD853F")
+DARK_BROWN = ManimColor("#8B4513")
+GRAY_BROWN = ManimColor("#736357")
+GREY_BROWN = ManimColor("#736357")
+
+# Colors used for Manim Community's logo and banner
+
+LOGO_WHITE = ManimColor("#ECE7E2")
+LOGO_GREEN = ManimColor("#87C2A5")
+LOGO_BLUE = ManimColor("#525893")
+LOGO_RED = ManimColor("#E07A5F")
+LOGO_BLACK = ManimColor("#343434")
+
+_all_manim_colors: List[ManimColor] = [
+ x for x in globals().values() if isinstance(x, ManimColor)
+]
diff --git a/data/rag/manim_docs/manim_core/source/utils/commands.py b/data/rag/manim_docs/manim_core/source/utils/commands.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ec9a776ddb1bff9c63808002bbf8b83cea2ab4d
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/commands.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from subprocess import run
+from typing import Generator
+
+__all__ = [
+ "capture",
+ "get_video_metadata",
+ "get_dir_layout",
+]
+
+
+def capture(command, cwd=None, command_input=None):
+ p = run(command, cwd=cwd, input=command_input, capture_output=True, text=True)
+ out, err = p.stdout, p.stderr
+ return out, err, p.returncode
+
+
+def get_video_metadata(path_to_video: str | os.PathLike) -> dict[str]:
+ command = [
+ "ffprobe",
+ "-v",
+ "error",
+ "-select_streams",
+ "v:0",
+ "-show_entries",
+ "stream=width,height,nb_frames,duration,avg_frame_rate,codec_name",
+ "-print_format",
+ "json",
+ str(path_to_video),
+ ]
+ config, err, exitcode = capture(command)
+ assert exitcode == 0, f"FFprobe error: {err}"
+ return json.loads(config)["streams"][0]
+
+
+def get_dir_layout(dirpath: Path) -> Generator[str, None, None]:
+ """Get list of paths relative to dirpath of all files in dir and subdirs recursively."""
+ for p in dirpath.iterdir():
+ if p.is_dir():
+ yield from get_dir_layout(p)
+ continue
+ yield str(p.relative_to(dirpath))
diff --git a/data/rag/manim_docs/manim_core/source/utils/config_ops.py b/data/rag/manim_docs/manim_core/source/utils/config_ops.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e1f09990e6c762c21ebc699ceea5531610811b8
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/config_ops.py
@@ -0,0 +1,78 @@
+"""Utilities that might be useful for configuration dictionaries."""
+
+from __future__ import annotations
+
+__all__ = [
+ "merge_dicts_recursively",
+ "update_dict_recursively",
+ "DictAsObject",
+]
+
+
+import itertools as it
+
+import numpy as np
+
+
+def merge_dicts_recursively(*dicts):
+ """
+ Creates a dict whose keyset is the union of all the
+ input dictionaries. The value for each key is based
+ on the first dict in the list with that key.
+
+ dicts later in the list have higher priority
+
+ When values are dictionaries, it is applied recursively
+ """
+ result = {}
+ all_items = it.chain(*(d.items() for d in dicts))
+ for key, value in all_items:
+ if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+ result[key] = merge_dicts_recursively(result[key], value)
+ else:
+ result[key] = value
+ return result
+
+
+def update_dict_recursively(current_dict, *others):
+ updated_dict = merge_dicts_recursively(current_dict, *others)
+ current_dict.update(updated_dict)
+
+
+# Occasionally convenient in order to write dict.x instead of more laborious
+# (and less in keeping with all other attr accesses) dict["x"]
+
+
+class DictAsObject:
+ def __init__(self, dictin):
+ self.__dict__ = dictin
+
+
+class _Data:
+ """Descriptor that allows _Data variables to be grouped and accessed from self.data["attr"] via self.attr.
+ self.data attributes must be arrays.
+ """
+
+ def __set_name__(self, obj, name):
+ self.name = name
+
+ def __get__(self, obj, owner):
+ return obj.data[self.name]
+
+ def __set__(self, obj, array: np.ndarray):
+ obj.data[self.name] = array
+
+
+class _Uniforms:
+ """Descriptor that allows _Uniforms variables to be grouped from self.uniforms["attr"] via self.attr.
+ self.uniforms attributes must be floats.
+ """
+
+ def __set_name__(self, obj, name):
+ self.name = name
+
+ def __get__(self, obj, owner):
+ return obj.__dict__["uniforms"][self.name]
+
+ def __set__(self, obj, num: float):
+ obj.__dict__["uniforms"][self.name] = num
diff --git a/data/rag/manim_docs/manim_core/source/utils/debug.py b/data/rag/manim_docs/manim_core/source/utils/debug.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e066837e27355ae882da01cdad308b6ed0b3b18
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/debug.py
@@ -0,0 +1,81 @@
+"""Debugging utilities."""
+
+
+from __future__ import annotations
+
+__all__ = ["print_family", "index_labels"]
+
+
+from manim.mobject.mobject import Mobject
+from manim.mobject.text.numbers import Integer
+
+from ..mobject.types.vectorized_mobject import VGroup
+from .color import BLACK
+
+
+def print_family(mobject, n_tabs=0):
+ """For debugging purposes"""
+ print("\t" * n_tabs, mobject, id(mobject))
+ for submob in mobject.submobjects:
+ print_family(submob, n_tabs + 1)
+
+
+def index_labels(
+ mobject: Mobject,
+ label_height: float = 0.15,
+ background_stroke_width=5,
+ background_stroke_color=BLACK,
+ **kwargs,
+):
+ r"""Returns a :class:`~.VGroup` of :class:`~.Integer` mobjects
+ that shows the index of each submobject.
+
+ Useful for working with parts of complicated mobjects.
+
+ Parameters
+ ----------
+ mobject
+ The mobject that will have its submobjects labelled.
+ label_height
+ The height of the labels, by default 0.15.
+ background_stroke_width
+ The stroke width of the outline of the labels, by default 5.
+ background_stroke_color
+ The stroke color of the outline of labels.
+ kwargs
+ Additional parameters to be passed into the :class`~.Integer`
+ mobjects used to construct the labels.
+
+ Examples
+ --------
+ .. manim:: IndexLabelsExample
+ :save_last_frame:
+
+ class IndexLabelsExample(Scene):
+ def construct(self):
+ text = MathTex(
+ "\\frac{d}{dx}f(x)g(x)=",
+ "f(x)\\frac{d}{dx}g(x)",
+ "+",
+ "g(x)\\frac{d}{dx}f(x)",
+ )
+
+ #index the fist term in the MathTex mob
+ indices = index_labels(text[0])
+
+ text[0][1].set_color(PURPLE_B)
+ text[0][8:12].set_color(DARK_BLUE)
+
+ self.add(text, indices)
+ """
+
+ labels = VGroup()
+ for n, submob in enumerate(mobject):
+ label = Integer(n, **kwargs)
+ label.set_stroke(
+ background_stroke_color, background_stroke_width, background=True
+ )
+ label.height = label_height
+ label.move_to(submob)
+ labels.add(label)
+ return labels
diff --git a/data/rag/manim_docs/manim_core/source/utils/deprecation.py b/data/rag/manim_docs/manim_core/source/utils/deprecation.py
new file mode 100644
index 0000000000000000000000000000000000000000..b72ecc7508e7b495571034aeaafebde289c86c8f
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/deprecation.py
@@ -0,0 +1,487 @@
+"""Decorators for deprecating classes, functions and function parameters."""
+
+from __future__ import annotations
+
+__all__ = ["deprecated", "deprecated_params"]
+
+
+import inspect
+import re
+from typing import Any, Callable, Iterable
+
+from decorator import decorate, decorator
+
+from .. import logger
+
+
+def _get_callable_info(callable: Callable) -> tuple[str, str]:
+ """Returns type and name of a callable.
+
+ Parameters
+ ----------
+ callable
+ The callable
+
+ Returns
+ -------
+ Tuple[str, str]
+ The type and name of the callable. Type can can be one of "class", "method" (for
+ functions defined in classes) or "function"). For methods, name is Class.method.
+ """
+ what = type(callable).__name__
+ name = callable.__qualname__
+ if what == "function" and "." in name:
+ what = "method"
+ elif what != "function":
+ what = "class"
+ return (what, name)
+
+
+def _deprecation_text_component(
+ since: str | None,
+ until: str | None,
+ message: str,
+) -> str:
+ """Generates a text component used in deprecation messages.
+
+ Parameters
+ ----------
+ since
+ The version or date since deprecation
+ until
+ The version or date until removal of the deprecated callable
+ message
+ The reason for why the callable has been deprecated
+
+ Returns
+ -------
+ str
+ The deprecation message text component.
+ """
+ since = f"since {since} " if since else ""
+ until = (
+ f"is expected to be removed after {until}"
+ if until
+ else "may be removed in a later version"
+ )
+ msg = " " + message if message else ""
+ return f"deprecated {since}and {until}.{msg}"
+
+
+def deprecated(
+ func: Callable = None,
+ since: str | None = None,
+ until: str | None = None,
+ replacement: str | None = None,
+ message: str | None = "",
+) -> Callable:
+ """Decorator to mark a callable as deprecated.
+
+ The decorated callable will cause a warning when used. The docstring of the
+ deprecated callable is adjusted to indicate that this callable is deprecated.
+
+ Parameters
+ ----------
+ func
+ The function to be decorated. Should not be set by the user.
+ since
+ The version or date since deprecation.
+ until
+ The version or date until removal of the deprecated callable.
+ replacement
+ The identifier of the callable replacing the deprecated one.
+ message
+ The reason for why the callable has been deprecated.
+
+ Returns
+ -------
+ Callable
+ The decorated callable.
+
+ Examples
+ --------
+ Basic usage::
+
+ from manim.utils.deprecation import deprecated
+
+ @deprecated
+ def foo(**kwargs):
+ pass
+
+ @deprecated
+ class Bar:
+ def __init__(self):
+ pass
+
+ @deprecated
+ def baz(self):
+ pass
+
+ foo()
+ # WARNING The function foo has been deprecated and may be removed in a later version.
+
+ a = Bar()
+ # WARNING The class Bar has been deprecated and may be removed in a later version.
+
+ a.baz()
+ # WARNING The method Bar.baz has been deprecated and may be removed in a later version.
+
+ You can specify additional information for a more precise warning::
+
+ from manim.utils.deprecation import deprecated
+
+ @deprecated(
+ since="v0.2",
+ until="v0.4",
+ replacement="bar",
+ message="It is cooler."
+ )
+ def foo():
+ pass
+
+ foo()
+ # WARNING The function foo has been deprecated since v0.2 and is expected to be removed after v0.4. Use bar instead. It is cooler.
+
+ You may also use dates instead of versions::
+
+ from manim.utils.deprecation import deprecated
+
+ @deprecated(since="05/01/2021", until="06/01/2021")
+ def foo():
+ pass
+
+ foo()
+ # WARNING The function foo has been deprecated since 05/01/2021 and is expected to be removed after 06/01/2021.
+
+ """
+ # If used as factory:
+ if func is None:
+ return lambda func: deprecated(func, since, until, replacement, message)
+
+ what, name = _get_callable_info(func)
+
+ def warning_msg(for_docs: bool = False) -> str:
+ """Generate the deprecation warning message.
+
+ Parameters
+ ----------
+ for_docs
+ Whether or not to format the message for use in documentation.
+
+ Returns
+ -------
+ str
+ The deprecation message.
+ """
+ msg = message
+ if replacement is not None:
+ repl = replacement
+ if for_docs:
+ mapper = {"class": "class", "method": "meth", "function": "func"}
+ repl = f":{mapper[what]}:`~.{replacement}`"
+ msg = f"Use {repl} instead.{' ' + message if message else ''}"
+ deprecated = _deprecation_text_component(since, until, msg)
+ return f"The {what} {name} has been {deprecated}"
+
+ def deprecate_docs(func: Callable):
+ """Adjust docstring to indicate the deprecation.
+
+ Parameters
+ ----------
+ func
+ The callable whose docstring to adjust.
+ """
+ warning = warning_msg(True)
+ doc_string = func.__doc__ or ""
+ func.__doc__ = f"{doc_string}\n\n.. attention:: Deprecated\n {warning}"
+
+ def deprecate(func: Callable, *args, **kwargs):
+ """The actual decorator used to extend the callables behavior.
+
+ Logs a warning message.
+
+ Parameters
+ ----------
+ func
+ The callable to decorate.
+ args
+ The arguments passed to the given callable.
+ kwargs
+ The keyword arguments passed to the given callable.
+
+ Returns
+ -------
+ Any
+ The return value of the given callable when being passed the given
+ arguments.
+ """
+ logger.warning(warning_msg())
+ return func(*args, **kwargs)
+
+ if type(func).__name__ != "function":
+ deprecate_docs(func)
+ func.__init__ = decorate(func.__init__, deprecate)
+ return func
+
+ func = decorate(func, deprecate)
+ deprecate_docs(func)
+ return func
+
+
+def deprecated_params(
+ params: str | Iterable[str] | None = None,
+ since: str | None = None,
+ until: str | None = None,
+ message: str | None = "",
+ redirections: None
+ | (Iterable[tuple[str, str] | Callable[..., dict[str, Any]]]) = None,
+) -> Callable:
+ """Decorator to mark parameters of a callable as deprecated.
+
+ It can also be used to automatically redirect deprecated parameter values to their
+ replacements.
+
+ Parameters
+ ----------
+ params
+ The parameters to be deprecated. Can consist of:
+
+ * An iterable of strings, with each element representing a parameter to deprecate
+ * A single string, with parameter names separated by commas or spaces.
+ since
+ The version or date since deprecation.
+ until
+ The version or date until removal of the deprecated callable.
+ message
+ The reason for why the callable has been deprecated.
+ redirections
+ A list of parameter redirections. Each redirection can be one of the following:
+
+ * A tuple of two strings. The first string defines the name of the deprecated
+ parameter; the second string defines the name of the parameter to redirect to,
+ when attempting to use the first string.
+
+ * A function performing the mapping operation. The parameter names of the
+ function determine which parameters are used as input. The function must
+ return a dictionary which contains the redirected arguments.
+
+ Redirected parameters are also implicitly deprecated.
+
+ Returns
+ -------
+ Callable
+ The decorated callable.
+
+ Raises
+ ------
+ ValueError
+ If no parameters are defined (neither explicitly nor implicitly).
+ ValueError
+ If defined parameters are invalid python identifiers.
+
+ Examples
+ --------
+ Basic usage::
+
+ from manim.utils.deprecation import deprecated_params
+
+ @deprecated_params(params="a, b, c")
+ def foo(**kwargs):
+ pass
+
+ foo(x=2, y=3, z=4)
+ # No warning
+
+ foo(a=2, b=3, z=4)
+ # WARNING The parameters a and b of method foo have been deprecated and may be removed in a later version.
+
+ You can also specify additional information for a more precise warning::
+
+ from manim.utils.deprecation import deprecated_params
+
+ @deprecated_params(
+ params="a, b, c",
+ since="v0.2",
+ until="v0.4",
+ message="The letters x, y, z are cooler."
+ )
+ def foo(**kwargs):
+ pass
+
+ foo(a=2)
+ # WARNING The parameter a of method foo has been deprecated since v0.2 and is expected to be removed after v0.4. The letters x, y, z are cooler.
+
+ Basic parameter redirection::
+
+ from manim.utils.deprecation import deprecated_params
+
+ @deprecated_params(redirections=[
+ # Two ways to redirect one parameter to another:
+ ("old_param", "new_param"),
+ lambda old_param2: {"new_param22": old_param2}
+ ])
+ def foo(**kwargs):
+ return kwargs
+
+ foo(x=1, old_param=2)
+ # WARNING The parameter old_param of method foo has been deprecated and may be removed in a later version.
+ # returns {"x": 1, "new_param": 2}
+
+ Redirecting using a calculated value::
+
+ from manim.utils.deprecation import deprecated_params
+
+ @deprecated_params(redirections=[
+ lambda runtime_in_ms: {"run_time": runtime_in_ms / 1000}
+ ])
+ def foo(**kwargs):
+ return kwargs
+
+ foo(runtime_in_ms=500)
+ # WARNING The parameter runtime_in_ms of method foo has been deprecated and may be removed in a later version.
+ # returns {"run_time": 0.5}
+
+ Redirecting multiple parameter values to one::
+
+ from manim.utils.deprecation import deprecated_params
+
+ @deprecated_params(redirections=[
+ lambda buff_x=1, buff_y=1: {"buff": (buff_x, buff_y)}
+ ])
+ def foo(**kwargs):
+ return kwargs
+
+ foo(buff_x=2)
+ # WARNING The parameter buff_x of method foo has been deprecated and may be removed in a later version.
+ # returns {"buff": (2, 1)}
+
+ Redirect one parameter to multiple::
+
+ from manim.utils.deprecation import deprecated_params
+
+ @deprecated_params(redirections=[
+ lambda buff=1: {"buff_x": buff[0], "buff_y": buff[1]} if isinstance(buff, tuple)
+ else {"buff_x": buff, "buff_y": buff}
+ ])
+ def foo(**kwargs):
+ return kwargs
+
+ foo(buff=0)
+ # WARNING The parameter buff of method foo has been deprecated and may be removed in a later version.
+ # returns {"buff_x": 0, buff_y: 0}
+
+ foo(buff=(1,2))
+ # WARNING The parameter buff of method foo has been deprecated and may be removed in a later version.
+ # returns {"buff_x": 1, buff_y: 2}
+
+
+ """
+ # Check if decorator is used without parenthesis
+ if callable(params):
+ raise ValueError("deprecate_parameters requires arguments to be specified.")
+
+ if params is None:
+ params = []
+
+ # Construct params list
+ params = re.split(r"[,\s]+", params) if isinstance(params, str) else list(params)
+
+ # Add params which are only implicitly given via redirections
+ if redirections is None:
+ redirections = []
+ for redirector in redirections:
+ if isinstance(redirector, tuple):
+ params.append(redirector[0])
+ else:
+ params.extend(list(inspect.signature(redirector).parameters))
+ # Keep ordering of params so that warning message is consistently the same
+ # This will also help pass unit testing
+ params = list(dict.fromkeys(params))
+
+ # Make sure params only contains valid identifiers
+ identifier = re.compile(r"^[^\d\W]\w*\Z", re.UNICODE)
+ if not all(re.match(identifier, param) for param in params):
+ raise ValueError("Given parameter values are invalid.")
+
+ redirections = list(redirections)
+
+ def warning_msg(func: Callable, used: list[str]):
+ """Generate the deprecation warning message.
+
+ Parameters
+ ----------
+ func
+ The callable with deprecated parameters.
+ used
+ The list of deprecated parameters used in a call.
+
+ Returns
+ -------
+ str
+ The deprecation message.
+ """
+ what, name = _get_callable_info(func)
+ plural = len(used) > 1
+ parameter_s = "s" if plural else ""
+ used_ = ", ".join(used[:-1]) + " and " + used[-1] if plural else used[0]
+ has_have_been = "have been" if plural else "has been"
+ deprecated = _deprecation_text_component(since, until, message)
+ return f"The parameter{parameter_s} {used_} of {what} {name} {has_have_been} {deprecated}"
+
+ def redirect_params(kwargs: dict, used: list[str]):
+ """Adjust the keyword arguments as defined by the redirections.
+
+ Parameters
+ ----------
+ kwargs
+ The keyword argument dictionary to be updated.
+ used
+ The list of deprecated parameters used in a call.
+ """
+ for redirector in redirections:
+ if isinstance(redirector, tuple):
+ old_param, new_param = redirector
+ if old_param in used:
+ kwargs[new_param] = kwargs.pop(old_param)
+ else:
+ redirector_params = list(inspect.signature(redirector).parameters)
+ redirector_args = {}
+ for redirector_param in redirector_params:
+ if redirector_param in used:
+ redirector_args[redirector_param] = kwargs.pop(redirector_param)
+ if len(redirector_args) > 0:
+ kwargs.update(redirector(**redirector_args))
+
+ def deprecate_params(func, *args, **kwargs):
+ """The actual decorator function used to extend the callables behavior.
+
+ Logs a warning message when a deprecated parameter is used and redirects it if
+ specified.
+
+ Parameters
+ ----------
+ func
+ The callable to decorate.
+ args
+ The arguments passed to the given callable.
+ kwargs
+ The keyword arguments passed to the given callable.
+
+ Returns
+ -------
+ Any
+ The return value of the given callable when being passed the given
+ arguments.
+
+ """
+ used = []
+ for param in params:
+ if param in kwargs:
+ used.append(param)
+
+ if len(used) > 0:
+ logger.warning(warning_msg(func, used))
+ redirect_params(kwargs, used)
+ return func(*args, **kwargs)
+
+ return decorator(deprecate_params)
diff --git a/data/rag/manim_docs/manim_core/source/utils/docbuild/__init__.py b/data/rag/manim_docs/manim_core/source/utils/docbuild/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/data/rag/manim_docs/manim_core/source/utils/docbuild/autocolor_directive.py b/data/rag/manim_docs/manim_core/source/utils/docbuild/autocolor_directive.py
new file mode 100644
index 0000000000000000000000000000000000000000..cdd906f1648512b9b5fd5e39de041bf2db6fd8e5
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/docbuild/autocolor_directive.py
@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import inspect
+
+from docutils import nodes
+from docutils.parsers.rst import Directive
+from sphinx.application import Sphinx
+
+from manim import ManimColor
+
+
+def setup(app: Sphinx) -> None:
+ app.add_directive("automanimcolormodule", ManimColorModuleDocumenter)
+
+
+class ManimColorModuleDocumenter(Directive):
+ objtype = "automanimcolormodule"
+ required_arguments = 1
+ has_content = True
+
+ def add_directive_header(self, sig: str) -> None:
+ super().add_directive_header(sig)
+
+ def run(
+ self,
+ ) -> None:
+ module_name = self.arguments[0]
+ try:
+ import importlib
+
+ module = importlib.import_module(module_name)
+ except ImportError:
+ return [
+ nodes.error(
+ None,
+ nodes.paragraph(text="Failed to import module '%s'" % module_name),
+ )
+ ]
+
+ # Number of Colors displayed in one row
+ num_color_cols = 2
+ table = nodes.table(align="center")
+
+ tgroup = nodes.tgroup(cols=num_color_cols * 2)
+ table += tgroup
+ for _ in range(num_color_cols * 2):
+ tgroup += nodes.colspec(colwidth=1)
+
+ # Create header rows for the table
+ thead = nodes.thead()
+ row = nodes.row()
+ for _ in range(num_color_cols):
+ col1 = nodes.paragraph(text="Color Name")
+ col2 = nodes.paragraph(text="RGB Hex Code")
+ row += nodes.entry("", col1)
+ row += nodes.entry("", col2)
+ thead += row
+ tgroup += thead
+
+ color_elements = []
+ for member_name, member_obj in inspect.getmembers(module):
+ if isinstance(member_obj, ManimColor):
+ r, g, b = member_obj.to_rgb()
+ luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b
+
+ # Choose the font color based on the background luminance
+ if luminance > 0.5:
+ font_color = "black"
+ else:
+ font_color = "white"
+
+ color_elements.append((member_name, member_obj.to_hex(), font_color))
+
+ tbody = nodes.tbody()
+
+ for base_i in range(0, len(color_elements), num_color_cols):
+ row = nodes.row()
+ for member_name, hex_code, font_color in color_elements[
+ base_i : base_i + num_color_cols
+ ]:
+ col1 = nodes.literal(text=member_name)
+ col2 = nodes.raw(
+ "",
+ f'
{hex_code}
',
+ format="html",
+ )
+ row += nodes.entry("", col1)
+ row += nodes.entry("", col2)
+ tbody += row
+ tgroup += tbody
+
+ return [table]
diff --git a/data/rag/manim_docs/manim_core/source/utils/docbuild/manim_directive.py b/data/rag/manim_docs/manim_core/source/utils/docbuild/manim_directive.py
new file mode 100644
index 0000000000000000000000000000000000000000..ebd4b09acf054ee11b9df4f1d388d922d6819f2d
--- /dev/null
+++ b/data/rag/manim_docs/manim_core/source/utils/docbuild/manim_directive.py
@@ -0,0 +1,454 @@
+r"""
+A directive for including Manim videos in a Sphinx document
+===========================================================
+
+When rendering the HTML documentation, the ``.. manim::`` directive
+implemented here allows to include rendered videos.
+
+Its basic usage that allows processing **inline content**
+looks as follows::
+
+ .. manim:: MyScene
+
+ class MyScene(Scene):
+ def construct(self):
+ ...
+
+It is required to pass the name of the class representing the
+scene to be rendered to the directive.
+
+As a second application, the directive can also be used to
+render scenes that are defined within doctests, for example::
+
+ .. manim:: DirectiveDoctestExample
+ :ref_classes: Dot
+
+ >>> from manim import Create, Dot, RED, Scene
+ >>> dot = Dot(color=RED)
+ >>> dot.color
+ ManimColor('#FC6255')
+ >>> class DirectiveDoctestExample(Scene):
+ ... def construct(self):
+ ... self.play(Create(dot))
+
+
+Options
+-------
+
+Options can be passed as follows::
+
+ .. manim::
+ :