Manim Community Edition

Mobjects (Mathematical Objects) are the fundamental building blocks of Manim animations. They represent the visual elements that appear on screen, such as shapes, text, mathematical formulas, and graphs. The manim module provides a wide variety of specialized Mobjects categorized by their function:

• Basic & Geometric: Standard shapes and geometric primitives (mobject.geometry, mobject.types).
• Text & Math: Textual elements, mathematical notation, and matrices (mobject.text, mobject.matrix).
• Data & Graphs: Visual representations of data, including graphs, graphing functions, and vector fields (mobject.graph, mobject.graphing, mobject.vector_field).
• Tables & Structures: Organized data structures like tables (mobject.table).
• 3D Objects: Mobjects designed for three-dimensional scenes (mobject.three_d).
• Specialized: SVG imports (mobject.svg), logos (mobject.logo), and frames (mobject.frame).
• Dynamic Control: Tools for managing animation state, such as ValueTracker (mobject.value_tracker).

A ValueTracker is a specialized Mobject used to track a numerical value that can be animated. By using add_updater on other Mobjects, you can make them react to the changes in a ValueTracker's value, allowing for complex, coordinated animations.

Key concepts:

• tracker.get_value(): Retrieves the current value.
• tracker.animate.set_value(new_value): Animates the tracker to a new value.
• tracker.animate.increment_value(amount): Animates an incremental change.
• add_updater(func): Attaches a function to a Mobject that runs every frame, typically using the tracker's value to update the Mobject's properties.

Example: Animating an angle and its label using a ValueTracker:

theta_tracker = ValueTracker(110)
# ... inside construct ...
line_moving.add_updater(
    lambda x: x.become(line_ref.copy()).rotate(
        theta_tracker.get_value() * DEGREES, about_point=rotation_center
    )
)
self.play(theta_tracker.animate.set_value(40))

class MovingAngle(Scene):
    def construct(self):
        rotation_center = LEFT

        theta_tracker = ValueTracker(110)
        line1 = Line(LEFT, RIGHT)
        line_moving = Line(LEFT, RIGHT)
        line_ref = line_moving.copy()
        line_moving.rotate(
            theta_tracker.get_value() * DEGREES, about_point=rotation_center
        )
        a = Angle(line1, line_moving, radius=0.5, other_angle=False)
        tex = MathTex(r"\theta").move_to(
            Angle(
                line1, line_moving, radius=0.5 + 3 * SMALL_BUFF, other_angle=False
            ).point_from_proportion(0.5)
        )

        self.add(line1, line_moving, a, tex)
        self.wait()

        line_moving.add_updater(
            lambda x: x.become(line_ref.copy()).rotate(
                theta_tracker.get_value() * DEGREES, about_point=rotation_center
            )
        )

        a.add_updater(
            lambda x: x.become(Angle(line1, line_moving, radius=0.5, other_angle=False))
        )
        tex.add_updater(
            lambda x: x.move_to(
                Angle(
                    line1, line_moving, radius=0.5 + 3 * SMALL_BUFF, other_angle=False
                ).point_from_proportion(0.5)
            )
        )

        self.play(theta_tracker.animate.set_value(40))
        self.play(theta_tracker.animate.increment_value(140))
        self.play(tex.animate.set_color(RED), run_time=0.5)
        self.play(theta_tracker.animate.set_value(350))

Manim provides two primary ways to handle objects that change over time based on other objects' movements:

1. add_updater(func): Attaches a function to a Mobject that is called every frame. The function receives the Mobject (mob) and the time delta (dt) as arguments. This is useful for continuous movement, such as a dot orbiting a circle.
2. always_redraw(func): A helper function that creates a new Mobject every frame by calling func. This is ideal for lines or shapes that must constantly re-calculate their geometry based on the current position of other moving objects (e.g., a line connecting a moving dot to a fixed point).

To stop an updater, use remove_updater(func).

# Using an updater for continuous movement
def go_around_circle(mob, dt):
    self.t_offset += (dt * rate)
    mob.move_to(orbit.point_from_proportion(self.t_offset % 1))

dot.add_updater(go_around_circle)

# Using always_redraw for a line that follows a moving object
def get_line_to_circle():
    return Line(origin_point, dot.get_center(), color=BLUE)

origin_to_circle_line = always_redraw(get_line_to_circle)
self.add(origin_to_circle_line)

# Removing the updater
dot.remove_updater(go_around_circle)

In Manim, Mobject (Mathematical Object) is the base class for all visual elements. However, a pure Mobject cannot be rendered by the camera. To display something on screen, you must use one of the following specialized types:

• ImageMobject: Used for displaying images.
• PMobject: Used for representing point clouds.
• VMobject (Vectorized Mobject): The most common type. These consist of points connected via cubic Bézier curves. The renderer processes VMobject points in sets of four: the first and last points are 'anchors', and the middle two are 'handles' (control points).

from manim import VMobject

# Example of a VMobject with 8 points (forming 2 cubic Bézier curves)
my_vmobject = VMobject(color=GREEN).set_points([
    [-2, -1, 0],  # start of first curve
    [-3, 1, 0],   # handle 1
    [0, 3, 0],    # handle 2
    [1, 3, 0],    # end of first curve
    [1, 3, 0],    # start of second curve
    [0, 1, 0],   # handle 3
    [4, 3, 0],    # handle 4
    [4, -2, 0],   # end of second curve
])

Manim's rendering process follows a structured lifecycle to transform scene code into video. The process can be broken down into three main stages:

1. Preliminaries: Preparing the scene for rendering, which includes setting up the environment before the user-defined construct method is executed. This can be triggered via the Manim CLI, within Jupyter notebooks, or by manually calling the Scene.render method in a Python script.
2. Mobject Initialization: Creating and managing Mobject instances (the basic visual elements). This involves handling different Mobject types (primarily vectorized Mobjects) and using Scene.add to manage which objects are tracked for rendering.
3. Animations and the Render Loop: Executing Animation objects (blueprints for Mobject changes) via Scene.play. The Scene.play call processes animations, runs a render loop that steps through a timeline to produce frames, and handles the encoding of 'partial movie files' which are eventually combined into the final video.