出现与消失¶

影片代码

import manimgx as m


class AppearHero(m.Scene):
    def construct(self) -> None:
        square = m.Square(color=m.BLUE, fill_opacity=0.5)
        word = m.Text("Write", font_size=56)
        star = m.Star(color=m.YELLOW, fill_opacity=0.5)
        circle = m.Circle(color=m.GREEN, fill_opacity=0.5)
        shapes = m.VGroup(square, word, star, circle).arrange(buff=0.8)
        self.play(
            m.Create(square),
            m.Write(word),
            m.GrowFromCenter(star),
            m.FadeIn(circle, shift=m.UP),
        )
        self.play(
            m.Uncreate(square),
            m.Unwrite(word),
            m.ShrinkToCenter(star),
            m.FadeOut(circle, shift=m.DOWN),
        )

将 mobject 带入的动画会在其开始时将它添加到场景中：你无需事先添加它。将 mobject 移出的动画会在其结束时将它从场景中移除。在此之间，mobject 沿其路径被绘制、如手写般被书写、被淡入淡出，或从某点生长出来。

绘制与书写¶

Create ¶

代码

import manimgx as m


class CreateExample(m.Scene):
    def construct(self) -> None:
        square = m.Square(side_length=4, color=m.BLUE, fill_opacity=0.5)
        self.play(m.Create(square, run_time=2))

沿其路径将一个 mobject 绘制到视图中，一个部分接一个部分地显现。

该 mobject 在动画开始时加入场景。每个部分从其起点到终点被显现；使用默认的 lag_ratio 1，一个部分在前一个部分绘制完成后开始显现。

m.Create(mobject, **kwargs)

mobject: 要绘制的 mobject。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(self, mobject: Mobject, **kwargs: Unpack[AnimationOptions]) -> None:
    super().__init__(mobject, keys=(lambda m: trimmed(m, 0, 0), None), **kwargs)

Uncreate ¶

代码

import manimgx as m


class UncreateExample(m.Scene):
    def construct(self) -> None:
        formula = m.MathTex("a^2 + b^2 = c^2", font_size=120)
        box = m.SurroundingRectangle(formula, buff=0.4, color=m.YELLOW)
        self.add(formula, box)
        self.play(m.Uncreate(box, run_time=2))

沿其路径擦除一个 mobject，并将其移出场景。

每个部分从其终点向起点被擦除，按 Create 绘制它们的顺序一个接一个地进行。该 mobject 在动画结束时离开场景。

m.Uncreate(mobject, **kwargs)

mobject: 要擦除的 mobject。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(self, mobject: Mobject, **kwargs: Unpack[AnimationOptions]) -> None:
    super().__init__(mobject, keys=(lambda m: trimmed(m, 0, 0), None), **kwargs)

DrawBorderThenFill ¶

代码

import manimgx as m


class DrawBorderThenFillExample(m.Scene):
    def construct(self) -> None:
        shapes = m.VGroup(
            m.Square(side_length=3, color=m.ORANGE, fill_opacity=1),
            m.Star(outer_radius=2, color=m.BLUE, fill_opacity=1),
        ).arrange(buff=1.5)
        self.play(m.DrawBorderThenFill(shapes, stroke_color=m.YELLOW))

先绘制一个 mobject 的轮廓，再将其填充。

在前半段，每个部分的边框沿其路径被绘制，宽度为 stroke_width，使用该部分所呈现的绘制颜色：若其绘制描边则为其自身的描边，否则为其填充（渐变保持为一色），除非给定了 stroke_color。在后半段，填充出现的同时边框转变为该部分自身的描边；对于不绘制描边的部分，边框以相同绘制颜色变细直至消失。各部分最终恢复原状。该 mobject 在动画开始时加入场景。动画运行 2 秒，由 double_smooth 缓动：两半段各自平滑过渡。

m.DrawBorderThenFill(vmobject, stroke_width=2, stroke_color=None, **kwargs)

vmobject: 要绘制的 mobject。
stroke_width: 边框的宽度，以场景单位的百分之一为单位。
stroke_color: 边框的颜色；None 表示使用每个部分所呈现的绘制颜色。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    vmobject: Mobject,
    stroke_width: float = 2,
    stroke_color: ParsableManimColor | None = None,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    super().__init__(
        vmobject,
        keys=(self._undrawn, self._outline, self._filled),
        **kwargs,
    )
    self.stroke_width, self.stroke_color = stroke_width, stroke_color

Write ¶

代码

import manimgx as m


class WriteExample(m.Scene):
    def construct(self) -> None:
        formula = m.MathTex(r"e^{i\pi} + 1 = 0", font_size=144)
        self.play(m.Write(formula))

如同手写一般书写一个 mobject：每个部分先绘制轮廓，再填充。

采用 DrawBorderThenFill 的绘制方式，以匀速（linear）进行，各部分交错显现：lag_ratio 为 4 除以部分数，至多为 0.2，当部分数少于 15 时运行 1 秒，否则运行 2 秒。该 mobject 在动画开始时加入场景。 Unwrite 可将其擦除。

m.Write(vmobject, reverse=False, **kwargs)

vmobject: 要书写的 mobject，如文本或公式。
reverse: 是否从最后一个部分向第一个部分书写（它们保持自身顺序，因此较后的部分仍绘制在较前的部分之上）；此时该 mobject 在动画结束时离开场景（除非给定 remover=False）。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    vmobject: Mobject,
    reverse: bool = False,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    n = len(vmobject.family_members_with_points())
    kwargs.setdefault("run_time", 1 if n < 15 else 2)
    kwargs.setdefault("lag_ratio", min(4.0 / max(1.0, n), 0.2))
    kwargs.setdefault("remover", reverse)
    kwargs.setdefault("introducer", not reverse)
    self.reverse = reverse
    super().__init__(vmobject, **kwargs)

Unwrite ¶

代码

import manimgx as m


class UnwriteExample(m.Scene):
    def construct(self) -> None:
        alice = m.Text("Alice", font_size=96)
        rest = m.Text("and Bob", font_size=96)
        m.VGroup(alice, rest).arrange(buff=0.4)
        self.add(alice, rest)
        self.play(m.Unwrite(rest))

如同倒退书写一般擦除一个 mobject，并将其移出场景。

Write 的逆过程：每个部分的填充渐变为其轮廓，然后轮廓被擦除，一个部分接一个部分地进行，默认从最后一个部分开始。各部分在播放期间保持自身顺序，因此较后的部分仍绘制在较前的部分之上。该 mobject 在动画结束时离开场景。

m.Unwrite(vmobject, reverse=True, **kwargs)

vmobject: 要擦除的 mobject。
reverse: 是否从最后一个部分向第一个部分擦除；False 表示从第一个部分开始擦除。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    vmobject: Mobject,
    reverse: bool = True,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    super().__init__(vmobject, reverse=reverse, **kwargs)

淡入淡出¶

FadeIn ¶

代码

import manimgx as m


class FadeInExample(m.Scene):
    def construct(self) -> None:
        dot = m.Dot(2 * m.UP + 4 * m.LEFT, radius=0.2, color=m.YELLOW)
        names = ("plain", "shift", "target", "scale")
        words = m.VGroup(*(m.Text(name, font_size=60) for name in names))
        words.arrange(buff=0.8)
        self.add(dot)
        self.play(
            m.LaggedStart(
                m.FadeIn(words[0]),
                m.FadeIn(words[1], shift=m.DOWN),
                m.FadeIn(words[2], target_position=dot),
                m.FadeIn(words[3], scale=1.5),
                lag_ratio=0.5,
            )
        )

将 mobjects 淡入视图。

它们起始为透明状态（被 shift 向后移动，或位于 target_position，大小为自身的 scale 倍），并最终到达自身原状。它们在动画开始时加入场景。

m.FadeIn(*mobjects, shift=None, target_position=None, scale=1, **kwargs)

*mobjects: 要一同淡入的 mobjects；至少一个。
shift: 它们在淡入时移动的方向与距离：起始时落后其最终位置这么远。
target_position: 未给定 shift 时它们的起始位置：一个点，或一个 mobject 的中心。
scale: 起始时的大小，相对于自身大小。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    *mobjects: Mobject,
    shift: Vector3DLike | None = None,
    target_position: Point3DLike | Mobject | None = None,
    scale: float = 1,
    **kwargs: Unpack[TransformOptions],
) -> None:
    if not mobjects:
        raise ValueError("At least one mobject must be passed.")
    mobject = mobjects[0] if len(mobjects) == 1 else _gathered(*mobjects)
    self.point_target = shift is None and target_position is not None
    if self.point_target:
        center = (
            target_position.get_center()
            if isinstance(target_position, Mobject)
            else np.asarray(target_position, dtype=float)
        )
        shift = center - mobject.get_center()
    self.shift_vector = ORIGIN if shift is None else np.asarray(shift, dtype=float)
    self.scale_factor = scale
    super().__init__(
        mobject,
        keys=(self._faded, None) if self.fading_in else (None, self._faded),
        **kwargs,
    )

FadeOut ¶

代码

import manimgx as m


class FadeOutExample(m.Scene):
    def construct(self) -> None:
        dot = m.Dot(2 * m.UP + 4 * m.LEFT, radius=0.2, color=m.YELLOW)
        names = ("plain", "shift", "target", "scale")
        words = m.VGroup(*(m.Text(name, font_size=60) for name in names))
        words.arrange(buff=0.8)
        self.add(dot, words)
        self.play(
            m.LaggedStart(
                m.FadeOut(words[0]),
                m.FadeOut(words[1], shift=m.DOWN),
                m.FadeOut(words[2], target_position=dot),
                m.FadeOut(words[3], scale=0.5),
                lag_ratio=0.5,
            )
        )

将 mobjects 淡出视图，并将其移出场景。

它们终止为透明状态（沿 shift 移动，或到达 target_position，大小为自身的 scale 倍）。它们在动画结束时离开场景，并恢复为动画之前的状态：再次添加它们即可显示。

m.FadeOut(*mobjects, shift=None, target_position=None, scale=1, **kwargs)

*mobjects: 要一同淡出的 mobjects；至少一个。
shift: 它们在淡出时移动的方向与距离。
target_position: 未给定 shift 时它们前往的位置：一个点，或一个 mobject 的中心。
scale: 终止时的大小，相对于自身大小。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    *mobjects: Mobject,
    shift: Vector3DLike | None = None,
    target_position: Point3DLike | Mobject | None = None,
    scale: float = 1,
    **kwargs: Unpack[TransformOptions],
) -> None:
    if not mobjects:
        raise ValueError("At least one mobject must be passed.")
    mobject = mobjects[0] if len(mobjects) == 1 else _gathered(*mobjects)
    self.point_target = shift is None and target_position is not None
    if self.point_target:
        center = (
            target_position.get_center()
            if isinstance(target_position, Mobject)
            else np.asarray(target_position, dtype=float)
        )
        shift = center - mobject.get_center()
    self.shift_vector = ORIGIN if shift is None else np.asarray(shift, dtype=float)
    self.scale_factor = scale
    super().__init__(
        mobject,
        keys=(self._faded, None) if self.fading_in else (None, self._faded),
        **kwargs,
    )

生长与收缩¶

GrowFromCenter ¶

代码

import manimgx as m


class GrowFromCenterExample(m.Scene):
    def construct(self) -> None:
        left = m.Circle(radius=1.5, color=m.BLUE, fill_opacity=0.5)
        right = m.Circle(radius=1.5, color=m.GREEN, fill_opacity=0.5)
        m.VGroup(left, right).arrange(buff=2)
        self.play(
            m.GrowFromCenter(left), m.GrowFromCenter(right, point_color=m.RED)
        )

从一个 mobject 的中心生长出该 mobject。

它起始为在其中心处缩为一点的状态（若给定 point_color 则使用该颜色）。该 mobject 在动画开始时加入场景。

m.GrowFromCenter(mobject, point_color=None, **kwargs)

mobject: 要生长的 mobject。
point_color: 起始颜色；None 表示使用其自身颜色。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    mobject: Mobject,
    point_color: ParsableManimColor | None = None,
    **kwargs: Unpack[TransformOptions],
) -> None:
    super().__init__(
        mobject, mobject.get_center(), point_color=point_color, **kwargs
    )

GrowFromPoint ¶

代码

import manimgx as m


class GrowFromPointExample(m.Scene):
    def construct(self) -> None:
        dot = m.Dot(3 * m.UP + 5 * m.LEFT, radius=0.2, color=m.YELLOW)
        square = m.Square(side_length=3, color=m.BLUE, fill_opacity=0.5)
        self.add(dot)
        self.play(m.GrowFromPoint(square, dot, point_color=m.YELLOW))

从一个点生长出一个 mobject。

它起始为在 point 处缩为一点的状态（若给定 point_color 则使用该颜色），并生长至自身大小与位置。该 mobject 在动画开始时加入场景。

m.GrowFromPoint(mobject, point, point_color=None, **kwargs)

mobject: 要生长的 mobject。
point: 生长起自的点，或一个以其中心为生长起点的 mobject （在动画创建时取定）。
point_color: 起始颜色；None 表示使用其自身颜色。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    mobject: Mobject,
    point: Point3DLike | Mobject,
    point_color: ParsableManimColor | None = None,
    **kwargs: Unpack[TransformOptions],
) -> None:
    self.point = (
        point.get_center()
        if isinstance(point, Mobject)
        else np.asarray(point, dtype=float)
    )
    self.point_color = point_color
    super().__init__(mobject, keys=(self._shrunk, None), **kwargs)

GrowFromEdge ¶

代码

import manimgx as m


class GrowFromEdgeExample(m.Scene):
    def construct(self) -> None:
        squares = m.VGroup(
            *(m.Square(side_length=2.5, fill_opacity=0.5) for _ in range(3))
        ).arrange(buff=1.5)
        squares.set_color_by_gradient(m.BLUE, m.GREEN)
        self.play(
            m.GrowFromEdge(squares[0], m.DOWN),
            m.GrowFromEdge(squares[1], m.RIGHT),
            m.GrowFromEdge(squares[2], m.UR),
        )

从一个 mobject 的边界框的某条边或某个角生长出该 mobject。

它起始为在该处缩为一点的状态（若给定 point_color 则使用该颜色）。该 mobject 在动画开始时加入场景。

m.GrowFromEdge(mobject, edge, point_color=None, **kwargs)

mobject: 要生长的 mobject。
edge: 生长起自的边的方向（如 DOWN 表示底边）或角的方向（如 UR 表示右上角）。
point_color: 起始颜色；None 表示使用其自身颜色。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    mobject: Mobject,
    edge: Vector3DLike,
    point_color: ParsableManimColor | None = None,
    **kwargs: Unpack[TransformOptions],
) -> None:
    super().__init__(
        mobject, mobject.get_critical_point(edge), point_color=point_color, **kwargs
    )

GrowArrow ¶

代码

import manimgx as m


class GrowArrowExample(m.Scene):
    def construct(self) -> None:
        right = m.Arrow(3 * m.LEFT, 3 * m.RIGHT, color=m.BLUE).shift(1.5 * m.UP)
        up = m.Arrow(3 * m.LEFT, 3 * m.RIGHT + 1.5 * m.UP, color=m.YELLOW)
        up.shift(1.5 * m.DOWN)
        self.play(m.GrowArrow(right), m.GrowArrow(up, point_color=m.RED))

从其起点生长出一支箭；其箭尖随之生长。

该箭在动画开始时加入场景。

m.GrowArrow(arrow, point_color=None, **kwargs)

arrow: 要生长的箭。
point_color: 起始颜色；None 表示使用其自身颜色。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    arrow: Mobject,
    point_color: ParsableManimColor | None = None,
    **kwargs: Unpack[TransformOptions],
) -> None:
    super().__init__(arrow, arrow.get_start(), point_color=point_color, **kwargs)

SpinInFromNothing ¶

代码

import manimgx as m


class SpinInFromNothingExample(m.Scene):
    def construct(self) -> None:
        left = m.Square(side_length=2.5, color=m.BLUE, fill_opacity=0.5)
        right = m.Star(outer_radius=1.5, color=m.YELLOW, fill_opacity=0.5)
        m.VGroup(left, right).arrange(buff=3)
        self.play(
            m.SpinInFromNothing(left),
            m.SpinInFromNothing(right, angle=m.TAU, point_color=m.RED),
            run_time=2,
        )

从一个 mobject 的中心生长出该 mobject，同时旋转着就位。

它在生长过程中转过 angle 角度（正角度为逆时针方向）。该 mobject 在动画开始时加入场景。

m.SpinInFromNothing(mobject, angle=PI / 2, point_color=None, **kwargs)

mobject: 要旋转着生长的 mobject。
angle: 途中转过的角度，以弧度为单位。
point_color: 起始颜色；None 表示使用其自身颜色。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    mobject: Mobject,
    angle: float = PI / 2,
    point_color: ParsableManimColor | None = None,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    self.angle = angle
    super().__init__(
        mobject, path_func=spiral_path(angle), point_color=point_color, **kwargs
    )

ShrinkToCenter ¶

代码

import manimgx as m


class ShrinkToCenterExample(m.Scene):
    def construct(self) -> None:
        circles = m.VGroup(
            *(
                m.Circle(radius=1.2, color=color, fill_opacity=0.5)
                for color in (m.BLUE, m.YELLOW, m.GREEN)
            )
        ).arrange(buff=1)
        self.add(circles)
        self.play(m.ShrinkToCenter(circles[1]))

将一个 mobject 在其中心处收缩为一点。

它留在场景中，缩为一点：传入 remover=True 可在动画结束时将其移出场景。

m.ShrinkToCenter(mobject, **kwargs)

mobject: 要收缩的 mobject。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\animation\motion.py

def __init__(self, mobject: Mobject, **kwargs: Unpack[TransformOptions]) -> None:
    super().__init__(mobject.scale, 0, **kwargs)

SpiralIn ¶

代码

import manimgx as m


class SpiralInExample(m.Scene):
    def construct(self) -> None:
        shapes = m.VGroup(
            m.Circle(color=m.GREEN, fill_opacity=1),
            m.Square(color=m.BLUE, fill_opacity=1),
            m.Triangle(color=m.YELLOW, fill_opacity=1),
            m.Star(color=m.RED, fill_opacity=1),
        ).arrange(buff=1)
        self.play(m.SpiralIn(shapes, run_time=2))

让一个 mobject 的子对象从远处飞入，盘旋着就位。

每个子对象回到动画开始时其所在位置，出发点距该 mobject 中心 scale_factor + 1 倍远：途中绕该中心转一圈（并绕自身中心反向转一圈，以保持其朝向），并在前 fade_in_fraction 的路程中淡入。该 mobject 在动画开始时加入场景；创建该动画不改变任何内容。

m.SpiralIn(shapes, scale_factor=8, fade_in_fraction=0.3, **kwargs)

shapes: 其子对象盘旋入位的 mobject。
scale_factor: 出发距离：距中心为其位置的 scale_factor + 1 倍远。
fade_in_fraction: 淡入所占的路程比例，从 0 到 1。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    shapes: Mobject,
    scale_factor: float = 8,
    fade_in_fraction: float = 0.3,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    self.scale_factor, self.fade_in_fraction = scale_factor, fade_in_fraction
    super().__init__(shapes, **kwargs)

逐部分¶

ShowIncreasingSubsets ¶

代码

import manimgx as m


class ShowIncreasingSubsetsExample(m.Scene):
    def construct(self) -> None:
        dots = m.VGroup(*(m.Dot(radius=0.4) for _ in range(8)))
        dots.arrange(buff=0.6).set_color_by_gradient(m.BLUE, m.YELLOW)
        self.play(m.ShowIncreasingSubsets(dots, rate_func=m.linear, run_time=2))

逐个增多地展示一个组的子对象。

在进度 p（由速率函数缓动）处，其 n 个子对象中的前 ⌊p·n⌋ 个被展示，其余被隐藏：即置于画面之外而非被改变，因此每个部分以其原貌展示，无论其上还播放着什么。该组在动画开始时加入场景。动画结束时仍被隐藏的部分保持不可见，留为透明；移除器的组按原状离开场景。传入 rate_func=linear 可获得匀速。

m.ShowIncreasingSubsets(group, int_func=floor, **kwargs)

group: 其子对象被展示的组。
int_func: 展示多少个的函数：关于 p·n 的函数（默认向下取整）。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    group: Mobject,
    int_func: Callable[[float], float] = np.floor,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    self.all_submobs, self.int_func = list(group.submobjects), int_func
    self._hidden: list[Mobject] = []
    super().__init__(group, **kwargs)

ShowSubmobjectsOneByOne ¶

代码

import manimgx as m


class ShowSubmobjectsOneByOneExample(m.Scene):
    def construct(self) -> None:
        polygons = (
            m.VGroup(
                *(m.RegularPolygon(n, fill_opacity=1) for n in range(3, 9))
            )
            .set_color(m.YELLOW)
            .scale(2.5)
        )
        self.play(
            m.ShowSubmobjectsOneByOne(polygons, rate_func=m.linear, run_time=3)
        )

逐一展示 mobject，每个取代前一个的位置。

在进度 p（由速率函数缓动）处，仅展示 n 个 mobject 中的第 ⌈p·n⌉ 个，以其原貌展示，其余被隐藏；动画结束时，被隐藏的那些保持不可见，留为透明。传入 rate_func=linear 可获得匀速。

m.ShowSubmobjectsOneByOne(group, int_func=ceil, **kwargs)

group: 依次展示的 mobject。
int_func: 展示哪一个的函数：关于 p·n 的函数（默认向上取整）。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    group: Iterable[Mobject],
    int_func: Callable[[float], float] = np.ceil,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    super().__init__(_gathered(*group), int_func=int_func, **kwargs)

打字文本¶

AddTextLetterByLetter ¶

代码

import manimgx as m


class AddTextLetterByLetterExample(m.Scene):
    def construct(self) -> None:
        text = m.Text("Hello, world!", font_size=96)
        self.play(m.AddTextLetterByLetter(text, time_per_char=0.15))

逐字输入一段文本，一次一个字母。

字母以匀速（linear）依次出现，每个字母 time_per_char 秒，除非给定 run_time。该文本在动画开始时加入场景。

m.AddTextLetterByLetter(text, int_func=ceil, time_per_char=0.1, **kwargs)

text: 要输入的文本，其子对象为字母；不含任何字母的文本会引发 ValueError。
int_func: 展示多少个字母的函数：关于进度乘以字母数的函数（默认向上取整，因此第一个字母立即出现）。
time_per_char: 每个字母耗时，以秒为单位。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    text: Mobject,
    int_func: Callable[[float], float] = np.ceil,
    time_per_char: float = 0.1,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    self.time_per_char = time_per_char
    if not text.family_members_with_points():
        raise ValueError(
            f"The text mobject {text} does not seem to contain any characters."
        )
    kwargs.setdefault(
        "run_time", max(1 / config.frame_rate, time_per_char) * len(text)
    )
    super().__init__(text, int_func=int_func, **kwargs)

RemoveTextLetterByLetter ¶

代码

import manimgx as m


class RemoveTextLetterByLetterExample(m.Scene):
    def construct(self) -> None:
        text = m.Text("Hello, world!", font_size=96)
        self.add(text)
        self.play(m.RemoveTextLetterByLetter(text, time_per_char=0.15))

从最后一个字母起逐字移除一段文本，并将其移出场景。

AddTextLetterByLetter 的逆过程：字母从最后一个到第一个消失，每个 time_per_char 秒，除非给定 run_time。该文本在动画结束时离开场景，并恢复为动画之前的状态：再次添加即可显示。

m.RemoveTextLetterByLetter(text, int_func=ceil, time_per_char=0.1, **kwargs)

text: 要移除的文本，其子对象为字母；不含任何字母的文本会引发 ValueError。
int_func: 仍展示多少个字母的函数：关于进度剩余部分乘以字母数的函数（默认向上取整）。
time_per_char: 每个字母耗时，以秒为单位。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    text: Mobject,
    int_func: Callable[[float], float] = np.ceil,
    time_per_char: float = 0.1,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    self.time_per_char = time_per_char
    if not text.family_members_with_points():
        raise ValueError(
            f"The text mobject {text} does not seem to contain any characters."
        )
    kwargs.setdefault(
        "run_time", max(1 / config.frame_rate, time_per_char) * len(text)
    )
    super().__init__(text, int_func=int_func, **kwargs)

AddTextWordByWord ¶

代码

import manimgx as m


class AddTextWordByWordExample(m.Scene):
    def construct(self) -> None:
        words = m.VGroup(
            *(m.Text(word, font_size=120) for word in ("Word", "by", "word"))
        ).arrange(buff=0.5)
        self.play(m.AddTextWordByWord(words, time_per_char=0.12))

逐字输入单词，每个单词之后短暂停顿。

text_mobject 的每个子对象是一个单词，单词依次出现：一个单词自身的子对象即其字母，一个接一个出现，每个 time_per_char 秒；然后该单词保持 0.005 × (其字母数)^1.5 秒。应传入一个单词的组，例如由 Text 构成的 VGroup：单个 Text 的子对象是其字母，它们没有自身的部分可供输入，因此每个在其轮次中整体出现。

m.AddTextWordByWord(text_mobject, time_per_char=0.06, **kwargs)

text_mobject: 这些单词：一个子对象为由字母构成的单词的组。
time_per_char: 每个字母耗时，以秒为单位。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    text_mobject: Mobject,
    time_per_char: float = 0.06,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    self.time_per_char = time_per_char
    anims = it.chain(
        *(
            [
                ShowIncreasingSubsets(w, run_time=time_per_char * len(w)),
                Animation(w, run_time=0.005 * len(w) ** 1.5),
            ]
            for w in text_mobject
        )
    )
    super().__init__(*anims, **kwargs)

TypeWithCursor ¶

代码

import manimgx as m


class TypeWithCursorExample(m.Scene):
    def construct(self) -> None:
        text = m.Text("Typing...", font_size=96, color=m.PURPLE)
        cursor = m.Rectangle(m.GREY_A, height=1.1, width=0.4, fill_opacity=1)
        cursor.move_to(text[0])
        self.play(m.TypeWithCursor(text, cursor))

逐字输入一段文本，光标跟在最后输入的字母之后。

字母如 AddTextLetterByLetter 那样出现，光标以其原貌显示，并随之移动。光标成为该文本的一部分，位于其末尾，在动画结束时留在那里，除非 leave_cursor_on 为 False。该文本在动画开始时加入场景。

m.TypeWithCursor(text, cursor, buff=0.1, keep_cursor_y=True, leave_cursor_on=True, time_per_char=0.1, **kwargs)

text: 要输入的文本，其子对象为字母。
cursor: 光标：任意 mobject，例如一个细长矩形。
buff: 最后一个字母与光标之间的间距，以场景单位表示。
keep_cursor_y: 光标移动时是否保持其自身高度；若否，它沿文本的中间高度移动。
leave_cursor_on: 动画结束时光标是否留在文本末尾。
time_per_char: 每个字母耗时，以秒为单位。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    text: Mobject,
    cursor: Mobject,
    buff: float = 0.1,
    keep_cursor_y: bool = True,
    leave_cursor_on: bool = True,
    time_per_char: float = 0.1,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    self.cursor, self.buff, self.keep_cursor_y, self.leave_cursor_on = (
        cursor,
        buff,
        keep_cursor_y,
        leave_cursor_on,
    )
    super().__init__(text, time_per_char=time_per_char, **kwargs)

UntypeWithCursor ¶

代码

import manimgx as m


class UntypeWithCursorExample(m.Scene):
    def construct(self) -> None:
        text = m.Text("Deleting...", font_size=96, color=m.PURPLE)
        cursor = m.Rectangle(m.GREY_A, height=1.1, width=0.4, fill_opacity=1)
        cursor.move_to(text[0])
        self.add(text)
        self.play(m.UntypeWithCursor(text, cursor))

逐字删除一段文本，光标跟在最后留下的字母之后。

TypeWithCursor 的逆过程：字母从最后一个到第一个消失。该文本在动画结束时离开场景，并恢复为动画之前的状态（再次添加即可显示）；光标成为该文本的一部分，并随其离开。

m.UntypeWithCursor(text, cursor, buff=0.1, keep_cursor_y=True, leave_cursor_on=True, time_per_char=0.1, **kwargs)

text: 要删除的文本，其子对象为字母。
cursor: 光标：任意 mobject，例如一个细长矩形。
buff: 最后一个字母与光标之间的间距，以场景单位表示。
keep_cursor_y: 光标移动时是否保持其自身高度；若否，它沿文本的中间高度移动。
leave_cursor_on: 动画结束时光标是否仍作为该文本的一部分。
time_per_char: 每个字母耗时，以秒为单位。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受动画关键字。

源码

manimgx\animation\motion.py

def __init__(
    self,
    text: Mobject,
    cursor: Mobject,
    buff: float = 0.1,
    keep_cursor_y: bool = True,
    leave_cursor_on: bool = True,
    time_per_char: float = 0.1,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    self.cursor, self.buff, self.keep_cursor_y, self.leave_cursor_on = (
        cursor,
        buff,
        keep_cursor_y,
        leave_cursor_on,
    )
    super().__init__(text, time_per_char=time_per_char, **kwargs)