强调¶

影片代码

import manimgx as m


class EmphasisHero(m.Scene):
    def construct(self) -> None:
        formula = m.MathTex("a^2", "+", "b^2", "=", "c^2", font_size=96)
        self.add(formula)
        self.play(m.Indicate(formula[0]))
        self.play(m.Circumscribe(formula[2], color=m.YELLOW))
        self.play(m.Flash(formula[4], color=m.YELLOW, flash_radius=0.8))
        self.play(m.Wiggle(formula))
        self.wait()

这些动画短暂地改变某个 mobject，然后将其恢复原状：当语音讲解它时，它们将观众的视线引向它。

Indicate ¶

代码

import manimgx as m


class IndicateExample(m.Scene):
    def construct(self) -> None:
        formula = m.MathTex("a^2", "+", "b^2", "=", "c^2", font_size=144)
        self.add(formula)
        self.play(m.Indicate(formula[4]))

引起对一个 mobject 的注意：暂时放大并着色。

它生长至 scale_factor 倍大小并变为 color 颜色，然后恢复原状（由 there_and_back 缓动）。

m.Indicate(mobject, scale_factor=1.2, color=PURE_YELLOW, **kwargs)

mobject: 要引起注意的 mobject。
scale_factor: 生长至其自身大小的多少倍。
color: 它所变成的颜色。
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,
    scale_factor: float = 1.2,
    color: ParsableManimColor = PURE_YELLOW,
    **kwargs: Unpack[TransformOptions],
) -> None:
    self.color, self.scale_factor = color, scale_factor
    super().__init__(
        mobject,
        keys=(None, lambda m: m.scale(scale_factor).set_color(color)),
        **kwargs,
    )

Circumscribe ¶

代码

import manimgx as m


class CircumscribeExample(m.Scene):
    def construct(self) -> None:
        text = m.Text("Circumscribe", font_size=96)
        self.add(text)
        self.play(m.Circumscribe(text))
        self.play(m.Circumscribe(text, m.Circle, fade_out=True))

通过在其周围绘制一个边框来引起对一个 mobject 的注意。

该边框为距该 mobject buff 远的矩形或圆形，在其周围闪光（ShowPassingFlash）；使用 fade_in 时它淡入然后被擦除，使用 fade_out 时它被绘制然后淡出，两者皆用时它淡入又淡出。它在动画结束时消失。run_time 为该边框的时长（默认 1 秒）；其他选项作用于整体。

m.Circumscribe(mobject, shape=None, fade_in=False, fade_out=False, time_width=0.3, buff=SMALL_BUFF, color=PURE_YELLOW, stroke_width=DEFAULT_STROKE_WIDTH, **kwargs)

mobject: 要加边框的 mobject。
shape: 边框的种类：Rectangle（None，即默认）或 Circle；其他任何值会引发 ValueError。
fade_in: 边框是否淡入。
fade_out: 边框是否淡出。
time_width: 当既不淡入也不淡出时，闪光段的长度，以边框长度的分数表示。
buff: 该 mobject 与边框之间的间距，以场景单位表示。
color: 边框的颜色。
stroke_width: 边框的宽度，以场景单位的百分之一为单位。
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,
    shape: type[VMobject] | None = None,
    fade_in: bool = False,
    fade_out: bool = False,
    time_width: float = 0.3,
    buff: float = SMALL_BUFF,
    color: ParsableManimColor = PURE_YELLOW,
    stroke_width: float = DEFAULT_STROKE_WIDTH,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    from manimgx.mobjects.annotations import SurroundingRectangle
    from manimgx.mobjects.shapes import Circle, Rectangle

    shape = shape or Rectangle
    if shape is Rectangle:
        frame = SurroundingRectangle(
            mobject, color=color, buff=buff, stroke_width=stroke_width
        )
    elif shape is Circle:
        frame = Circle(color=color, stroke_width=stroke_width).surround(
            mobject, buffer_factor=1
        )
        frame.scale((frame.width / 2 + buff) / (frame.width / 2))
    else:
        raise ValueError("shape should be either Rectangle or Circle.")
    run_time = kwargs.pop("run_time", 1.0)
    half = run_time / 2
    if fade_in and fade_out:
        anims = [FadeIn(frame, run_time=half), FadeOut(frame, run_time=half)]
    elif fade_in:
        frame.reverse_direction()
        anims = [FadeIn(frame, run_time=half), Uncreate(frame, run_time=half)]
    elif fade_out:
        anims = [Create(frame, run_time=half), FadeOut(frame, run_time=half)]
    else:
        anims = [ShowPassingFlash(frame, time_width, run_time=run_time)]
    super().__init__(*anims, **kwargs)

Flash ¶

代码

import manimgx as m


class FlashExample(m.Scene):
    def construct(self) -> None:
        circle = m.Circle(radius=2, color=m.BLUE, fill_opacity=0.5)
        self.add(circle)
        self.play(
            m.Flash(
                circle,
                line_length=1,
                num_lines=24,
                flash_radius=2.2,
                time_width=0.3,
                run_time=2,
            )
        )

从一个点闪出光线，如同光爆。

num_lines 条线，长度为 line_length，从距该点 flash_radius 处起始，作为掠过的闪光（ShowPassingFlash）向外射出，并在动画结束时消失。动画选项传递给每条线的闪光。

m.Flash(point, line_length=0.2, num_lines=12, flash_radius=0.1, line_stroke_width=3, color=PURE_YELLOW, time_width=1, **kwargs)

point: 闪光的起始点，或以其中心为起始点的 mobject。
line_length: 每条线的长度，以场景单位表示。
num_lines: 线的数量。
flash_radius: 线起始处距该点的距离，以场景单位表示。
line_stroke_width: 线的宽度，以场景单位的百分之一为单位。
color: 线的颜色。
time_width: 每条线的闪光窗口，以其长度的分数表示。
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,
    point: Point3DLike | Mobject,
    line_length: float = 0.2,
    num_lines: int = 12,
    flash_radius: float = 0.1,
    line_stroke_width: int = 3,
    color: ParsableManimColor = PURE_YELLOW,
    time_width: float = 1,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    from manimgx.mobjects.shapes import Line

    self.point = (
        point.get_center()
        if isinstance(point, Mobject)
        else np.asarray(point, dtype=float)
    )
    self.color, self.time_width = color, time_width
    self.lines = VGroup()
    for angle in np.arange(0, TAU, TAU / num_lines):
        line = Line(self.point, self.point + line_length * RIGHT).shift(
            flash_radius * RIGHT
        )
        self.lines.add(line.rotate(angle, about_point=self.point))
    self.lines.set_color(color).set_stroke(width=line_stroke_width)
    super().__init__(
        *(
            ShowPassingFlash(line, time_width=time_width, **kwargs)
            for line in self.lines
        ),
        group=self.lines,
    )

FocusOn ¶

代码

import manimgx as m


class FocusOnExample(m.Scene):
    def construct(self) -> None:
        dot = m.Dot(2 * m.DOWN, radius=0.2, color=m.YELLOW)
        self.add(m.Text("Focus on the dot below", font_size=60), dot)
        self.play(m.FocusOn(dot))

将聚光灯收拢到一个点。

一个覆盖整个画面的透明圆盘收缩到 focus_point 上，在收拢过程中变为 color 颜色、opacity 不透明度，并在动画结束时消失；它跟随一个移动的 mobject。运行 2 秒。

m.FocusOn(focus_point, opacity=0.2, color=GREY, **kwargs)

focus_point: 要聚焦的点，或要聚焦其中心的 mobject。
opacity: 圆盘在结束时的不透明度。
color: 圆盘的颜色。
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,
    focus_point: Point3DLike | Mobject,
    opacity: float = 0.2,
    color: ParsableManimColor = GREY,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    from manimgx.mobjects.shapes import Dot

    self.focus_point, self.color, self.opacity = focus_point, color, opacity
    start = Dot(
        radius=config.frame_x_radius + config.frame_y_radius,
        stroke_width=0,
        fill_color=color,
        fill_opacity=0,
    )
    target = Dot(radius=0).set_fill(color, opacity=opacity)
    target.add_updater(
        lambda d: d.move_to(focus_point)
    )  # its own object, following the point
    super().__init__(start, target, **kwargs)

Wiggle ¶

代码

import manimgx as m


class WiggleExample(m.Scene):
    def construct(self) -> None:
        text = m.Text("Wiggle", font_size=144)
        self.add(text)
        self.play(m.Wiggle(text))

摇摆一个 mobject：在其膨胀又缩回的同时来回摆动。

它生长至 scale_value 倍大小再缩回，同时来回转动至多 rotation_angle，共 n_wiggles 次摆动，绕其中心或给定的点进行。运行 2 秒。

m.Wiggle(mobject, scale_value=1.1, rotation_angle=0.01 * TAU, n_wiggles=6, scale_about_point=None, rotate_about_point=None, **kwargs)

mobject: 要摇摆的 mobject。
scale_value: 半程时生长至其自身大小的多少倍。
rotation_angle: 每个方向至多转过的角度，以弧度为单位。
n_wiggles: 摆动的次数。
scale_about_point: 生长所绕的点；None 表示其中心。
rotate_about_point: 转动所绕的点；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,
    scale_value: float = 1.1,
    rotation_angle: float = 0.01 * TAU,
    n_wiggles: int = 6,
    scale_about_point: Point3DLike | None = None,
    rotate_about_point: Point3DLike | None = None,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    self.scale_value, self.rotation_angle, self.n_wiggles = (
        scale_value,
        rotation_angle,
        n_wiggles,
    )
    self.scale_about_point = (
        None if scale_about_point is None else np.array(scale_about_point)
    )
    self.rotate_about_point = (
        None if rotate_about_point is None else np.array(rotate_about_point)
    )
    super().__init__(mobject, **kwargs)

ShowPassingFlash ¶

代码

import manimgx as m


class ShowPassingFlashExample(m.Scene):
    def construct(self) -> None:
        pentagon = m.RegularPolygon(5, color=m.GREY, stroke_width=8).scale(3)
        flash = pentagon.copy().set_color(m.YELLOW)
        self.add(pentagon)
        self.play(m.ShowPassingFlash(flash, time_width=0.5, run_time=2))

沿一个 mobject 的路径闪过一段，从其起点到越过其终点。

一个长度为路径长度 time_width 的窗口沿该 mobject 移动，mobject 仅显示位于窗口内的部分。该 mobject 在闪光期间加入场景并在结束时离开场景，即使它之前就在场景中也是如此（若要保留原对象，请闪过其副本）；其路径在之后恢复完整。

m.ShowPassingFlash(mobject, time_width=0.1, **kwargs)

mobject: 窗口沿其路径移动的 mobject。
time_width: 窗口的长度，以路径长度的分数表示。
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,
    time_width: float = 0.1,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    self.time_width = time_width
    super().__init__(
        mobject,
        keys=(
            lambda m: trimmed(m, -time_width, 0),
            lambda m: trimmed(m, 1, 1 + time_width),
        ),
        **kwargs,
    )

ShowPassingFlashWithThinningStrokeWidth ¶

代码

import manimgx as m


class ShowPassingFlashWithThinningStrokeWidthExample(m.Scene):
    def construct(self) -> None:
        circle = m.Circle(radius=2.5, color=m.YELLOW, stroke_width=16)
        self.add(circle.copy().set_stroke(m.GREY, width=4))
        self.play(
            m.ShowPassingFlashWithThinningStrokeWidth(
                circle, time_width=0.5, run_time=2
            )
        )

沿一个 mobject 的路径闪过一段，其后拖着一条变细的尾。

n_segments 个该 mobject 副本的掠过闪光（ShowPassingFlash）一同播放：它们的宽度从无上升到该 mobject 的描边宽度，同时其窗口从 time_width 缩到无，因此闪光在其头部最宽。副本在动画结束时消失，而该 mobject 本身保持原状。动画选项传递给每个闪光。

m.ShowPassingFlashWithThinningStrokeWidth(vmobject, n_segments=10, time_width=0.1, **kwargs)

vmobject: 闪光沿其路径移动的 mobject。
n_segments: 构成闪光的闪光数量。
time_width: 尾的长度，以路径长度的分数表示。
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,
    n_segments: int = 10,
    time_width: float = 0.1,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    self.n_segments, self.time_width = n_segments, time_width
    widths = np.linspace(0, vmobject.get_stroke_width(), n_segments)
    time_widths = np.linspace(time_width, 0, n_segments)
    super().__init__(
        *(
            ShowPassingFlash(
                vmobject.copy().set_stroke(width=w), time_width=tw, **kwargs
            )
            for w, tw in zip(widths, time_widths, strict=True)
        )
    )

Blink ¶

代码

import manimgx as m


class BlinkExample(m.Scene):
    def construct(self) -> None:
        text = m.Text("Blinking", font_size=120)
        self.add(text)
        self.play(m.Blink(text, blinks=3))

闪烁一个 mobject：将其隐藏再显示，重复若干次。

它显示 time_on 秒并隐藏 time_off 秒，共 blinks 次，然后再显示 time_on 秒（或使用 hide_at_end 保持隐藏）。显示时将其设为完全不透明，隐藏时将其设为完全透明。

m.Blink(mobject, time_on=0.5, time_off=0.5, blinks=1, hide_at_end=False, **kwargs)

mobject: 要闪烁的 mobject。
time_on: 每次显示的时长，以秒为单位。
time_off: 每次隐藏的时长，以秒为单位。
blinks: 闪烁的次数。
hide_at_end: 结束时是否保持隐藏。
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,
    time_on: float = 0.5,
    time_off: float = 0.5,
    blinks: int = 1,
    hide_at_end: bool = False,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    def show(opacity: float, run_time: float) -> UpdateFromFunc:
        return UpdateFromFunc(
            mobject,
            update_function=lambda m: m.set_opacity(opacity),
            run_time=run_time,
        )

    anims = [show(1.0, time_on), show(0.0, time_off)] * blinks
    super().__init__(
        *anims, *([] if hide_at_end else [show(1.0, time_on)]), **kwargs
    )

Broadcast ¶

代码

import manimgx as m


class BroadcastExample(m.Scene):
    def construct(self) -> None:
        self.add(m.Dot(radius=0.2, color=m.TEAL))
        self.play(m.Broadcast(m.Circle(radius=3.5, color=m.TEAL)))

将一个 mobject 的副本从一个点向外扩散，一个接一个。

n_mobs 个副本中的每一个从 focal_point 起始，宽度为 initial_width，不透明度为 initial_opacity，如涟漪般生长到该 mobject 的大小，以 focal_point 为中心，其不透明度变为 final_opacity。它们一个接一个开始（lag_ratio 为 0.2，历时 3 秒），并在动画结束时离开场景，除非给定 remover=False。填充 mobject 的副本整体淡出，轮廓的副本在其描边上淡出。该 mobject 本身不被显示。

m.Broadcast(mobject, focal_point=ORIGIN, n_mobs=5, initial_opacity=1, final_opacity=0, initial_width=0.0, **kwargs)

mobject: 涟漪的形状，处于其最大状态。
focal_point: 涟漪扩散的起始点。
n_mobs: 副本的数量。
initial_opacity: 副本起始时的不透明度。
final_opacity: 副本结束时的不透明度。
initial_width: 副本起始时的宽度，以场景单位表示。
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,
    focal_point: Point3DLike = ORIGIN,
    n_mobs: int = 5,
    initial_opacity: float = 1,
    final_opacity: float = 0,
    initial_width: float = 0.0,
    **kwargs: Unpack[AnimationOptions],
) -> None:
    remover = kwargs.pop("remover", True)
    self.focal_point, self.n_mobs = focal_point, n_mobs
    filled = bool(mobject.fill_opacity)
    opacity = (
        (lambda m, o: m.set_opacity(o))
        if filled
        else (lambda m, o: m.set_stroke(opacity=o))
    )
    anims = []
    for _ in range(n_mobs):
        mob = mobject.copy()
        opacity(mob, final_opacity)
        mob.move_to(focal_point).save_state()
        mob.set(width=initial_width)
        opacity(mob, initial_opacity)
        anims.append(Restore(mob, remover=remover))
    super().__init__(*anims, **kwargs)